From ff51e352305f97312b6f0f6a7b360d97571a1728 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Thu, 11 Nov 2021 17:10:45 -0500 Subject: [PATCH 001/113] first pass at using substrait protobufs --- cpp/cmake_modules/DefineOptions.cmake | 2 + cpp/cmake_modules/FindArrowEngine.cmake | 89 + cpp/cmake_modules/ThirdpartyToolchain.cmake | 3 +- cpp/src/arrow/CMakeLists.txt | 4 + .../arrow/engine/ArrowEngineConfig.cmake.in | 36 + cpp/src/arrow/engine/CMakeLists.txt | 106 + cpp/src/arrow/engine/api.h | 22 + cpp/src/arrow/engine/arrow-engine.pc.in | 25 + cpp/src/arrow/engine/engine_test.cc | 16 + cpp/src/arrow/engine/pch.h | 23 + cpp/src/arrow/engine/substrait_consumer.cc | 43 + cpp/src/arrow/engine/substrait_consumer.h | 36 + cpp/src/arrow/engine/visibility.h | 50 + cpp/src/arrow/flight/CMakeLists.txt | 2 +- cpp/src/generated/substrait/expression.pb.cc | 9641 +++++++++++++ cpp/src/generated/substrait/expression.pb.h | 11252 ++++++++++++++++ cpp/src/generated/substrait/extensions.pb.cc | 2999 ++++ cpp/src/generated/substrait/extensions.pb.h | 2985 ++++ cpp/src/generated/substrait/function.pb.cc | 4689 +++++++ cpp/src/generated/substrait/function.pb.h | 5605 ++++++++ .../substrait/parameterized_types.pb.cc | 5564 ++++++++ .../substrait/parameterized_types.pb.h | 6624 +++++++++ cpp/src/generated/substrait/plan.pb.cc | 366 + cpp/src/generated/substrait/plan.pb.h | 382 + cpp/src/generated/substrait/relations.pb.cc | 7127 ++++++++++ cpp/src/generated/substrait/relations.pb.h | 8315 ++++++++++++ cpp/src/generated/substrait/selection.pb.cc | 5326 ++++++++ cpp/src/generated/substrait/selection.pb.h | 5460 ++++++++ cpp/src/generated/substrait/type.pb.cc | 8700 ++++++++++++ cpp/src/generated/substrait/type.pb.h | 9751 +++++++++++++ .../substrait/type_expressions.pb.cc | 5656 ++++++++ .../generated/substrait/type_expressions.pb.h | 7191 ++++++++++ dev/archery/archery/cli.py | 6 + dev/archery/archery/lang/cpp.py | 2 +- 34 files changed, 108095 insertions(+), 3 deletions(-) create mode 100644 cpp/cmake_modules/FindArrowEngine.cmake create mode 100644 cpp/src/arrow/engine/ArrowEngineConfig.cmake.in create mode 100644 cpp/src/arrow/engine/CMakeLists.txt create mode 100644 cpp/src/arrow/engine/api.h create mode 100644 cpp/src/arrow/engine/arrow-engine.pc.in create mode 100644 cpp/src/arrow/engine/engine_test.cc create mode 100644 cpp/src/arrow/engine/pch.h create mode 100644 cpp/src/arrow/engine/substrait_consumer.cc create mode 100644 cpp/src/arrow/engine/substrait_consumer.h create mode 100644 cpp/src/arrow/engine/visibility.h create mode 100644 cpp/src/generated/substrait/expression.pb.cc create mode 100644 cpp/src/generated/substrait/expression.pb.h create mode 100644 cpp/src/generated/substrait/extensions.pb.cc create mode 100644 cpp/src/generated/substrait/extensions.pb.h create mode 100644 cpp/src/generated/substrait/function.pb.cc create mode 100644 cpp/src/generated/substrait/function.pb.h create mode 100644 cpp/src/generated/substrait/parameterized_types.pb.cc create mode 100644 cpp/src/generated/substrait/parameterized_types.pb.h create mode 100644 cpp/src/generated/substrait/plan.pb.cc create mode 100644 cpp/src/generated/substrait/plan.pb.h create mode 100644 cpp/src/generated/substrait/relations.pb.cc create mode 100644 cpp/src/generated/substrait/relations.pb.h create mode 100644 cpp/src/generated/substrait/selection.pb.cc create mode 100644 cpp/src/generated/substrait/selection.pb.h create mode 100644 cpp/src/generated/substrait/type.pb.cc create mode 100644 cpp/src/generated/substrait/type.pb.h create mode 100644 cpp/src/generated/substrait/type_expressions.pb.cc create mode 100644 cpp/src/generated/substrait/type_expressions.pb.h diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake index 0a43ec18f60..a74e53b6e0f 100644 --- a/cpp/cmake_modules/DefineOptions.cmake +++ b/cpp/cmake_modules/DefineOptions.cmake @@ -219,6 +219,8 @@ if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") define_option(ARROW_COMPUTE "Build the Arrow Compute Modules" OFF) + define_option(ARROW_ENGINE "Build the Arrow Query Engine Module" OFF) + define_option(ARROW_CSV "Build the Arrow CSV Parser Module" OFF) define_option(ARROW_CUDA "Build the Arrow CUDA extensions (requires CUDA toolkit)" OFF) diff --git a/cpp/cmake_modules/FindArrowEngine.cmake b/cpp/cmake_modules/FindArrowEngine.cmake new file mode 100644 index 00000000000..3621730b264 --- /dev/null +++ b/cpp/cmake_modules/FindArrowEngine.cmake @@ -0,0 +1,89 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +# - Find Arrow Engine (arrow/engine/api.h, libarrow_engine.a, libarrow_engine.so) +# +# This module requires Arrow from which it uses +# arrow_find_package() +# +# This module defines +# ARROW_ENGINE_FOUND, whether Arrow Engine has been found +# ARROW_ENGINE_IMPORT_LIB, +# path to libarrow_engine's import library (Windows only) +# ARROW_ENGINE_INCLUDE_DIR, directory containing headers +# ARROW_ENGINE_LIB_DIR, directory containing Arrow Engine libraries +# ARROW_ENGINE_SHARED_LIB, path to libarrow_engine's shared library +# ARROW_ENGINE_STATIC_LIB, path to libarrow_engine.a + +if(DEFINED ARROW_ENGINE_FOUND) + return() +endif() + +set(find_package_arguments) +if(${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION) + list(APPEND find_package_arguments "${${CMAKE_FIND_PACKAGE_NAME}_FIND_VERSION}") +endif() +if(${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED) + list(APPEND find_package_arguments REQUIRED) +endif() +if(${CMAKE_FIND_PACKAGE_NAME}_FIND_QUIETLY) + list(APPEND find_package_arguments QUIET) +endif() +find_package(Arrow ${find_package_arguments}) +find_package(Parquet ${find_package_arguments}) + +if(ARROW_FOUND AND PARQUET_FOUND) + arrow_find_package(ARROW_ENGINE + "${ARROW_HOME}" + arrow_engine + arrow/engine/api.h + ArrowEngine + arrow-engine) + if(NOT ARROW_ENGINE_VERSION) + set(ARROW_ENGINE_VERSION "${ARROW_VERSION}") + endif() +endif() + +if("${ARROW_ENGINE_VERSION}" VERSION_EQUAL "${ARROW_VERSION}") + set(ARROW_ENGINE_VERSION_MATCH TRUE) +else() + set(ARROW_ENGINE_VERSION_MATCH FALSE) +endif() + +mark_as_advanced(ARROW_ENGINE_IMPORT_LIB + ARROW_ENGINE_INCLUDE_DIR + ARROW_ENGINE_LIBS + ARROW_ENGINE_LIB_DIR + ARROW_ENGINE_SHARED_IMP_LIB + ARROW_ENGINE_SHARED_LIB + ARROW_ENGINE_STATIC_LIB + ARROW_ENGINE_VERSION + ARROW_ENGINE_VERSION_MATCH) + +find_package_handle_standard_args( + ArrowEngine + REQUIRED_VARS ARROW_ENGINE_INCLUDE_DIR ARROW_ENGINE_LIB_DIR + ARROW_ENGINE_VERSION_MATCH + VERSION_VAR ARROW_ENGINE_VERSION) +set(ARROW_ENGINE_FOUND ${ArrowEngine_FOUND}) + +if(ArrowEngine_FOUND AND NOT ArrowEngine_FIND_QUIETLY) + message(STATUS "Found the Arrow Engine by ${ARROW_ENGINE_FIND_APPROACH}") + message(STATUS "Found the Arrow Engine shared library: ${ARROW_ENGINE_SHARED_LIB}") + message(STATUS "Found the Arrow Engine import library: ${ARROW_ENGINE_IMPORT_LIB}") + message(STATUS "Found the Arrow Engine static library: ${ARROW_ENGINE_STATIC_LIB}") +endif() diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake index d85e511c1e7..a391dc88724 100644 --- a/cpp/cmake_modules/ThirdpartyToolchain.cmake +++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake @@ -309,7 +309,8 @@ endif() if(ARROW_ORC OR ARROW_FLIGHT - OR ARROW_GANDIVA) + OR ARROW_GANDIVA + OR ARROW_ENGINE) set(ARROW_WITH_PROTOBUF ON) endif() diff --git a/cpp/src/arrow/CMakeLists.txt b/cpp/src/arrow/CMakeLists.txt index b984bc10425..e4421345189 100644 --- a/cpp/src/arrow/CMakeLists.txt +++ b/cpp/src/arrow/CMakeLists.txt @@ -722,6 +722,10 @@ if(ARROW_COMPUTE) add_subdirectory(compute) endif() +if(ARROW_ENGINE) + add_subdirectory(engine) +endif() + if(ARROW_CUDA) add_subdirectory(gpu) endif() diff --git a/cpp/src/arrow/engine/ArrowEngineConfig.cmake.in b/cpp/src/arrow/engine/ArrowEngineConfig.cmake.in new file mode 100644 index 00000000000..b7c9cb19b26 --- /dev/null +++ b/cpp/src/arrow/engine/ArrowEngineConfig.cmake.in @@ -0,0 +1,36 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +# +# This config sets the following variables in your project:: +# +# ArrowEngine_FOUND - true if Arrow Engine found on the system +# +# This config sets the following targets in your project:: +# +# arrow_engine_shared - for linked as shared library if shared library is built +# arrow_engine_static - for linked as static library if static library is built + +@PACKAGE_INIT@ + +include(CMakeFindDependencyMacro) +find_dependency(Arrow) + +# Load targets only once. If we load targets multiple times, CMake reports +# already existent target error. +if(NOT (TARGET arrow_engine_shared OR TARGET arrow_engine_static)) + include("${CMAKE_CURRENT_LIST_DIR}/ArrowEngineTargets.cmake") +endif() diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt new file mode 100644 index 00000000000..445dec04559 --- /dev/null +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -0,0 +1,106 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +add_custom_target(arrow_engine) + +arrow_install_all_headers("arrow/engine") + +set(ARROW_ENGINE_LINK_LIBS ${ARROW_PROTOBUF_LIBPROTOBUF}) + +#if(WIN32) +# list(APPEND ARROW_ENGINE_LINK_LIBS ws2_32.lib) +#endif() + +set(ARROW_ENGINE_SRCS + substrait_consumer.cc) + +set(SUBSTRAIT_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait") +set(SUBSTRAIT_GEN_DIR "${ARROW_SOURCE_DIR}/src/generated/substrait") +set(SUBSTRAIT_PROTOS expression + extensions + function + parameterized_types + plan + relations + selection + type + type_expressions) + +externalproject_add(substrait_ep + GIT_REPOSITORY "https://github.com/substrait-io/substrait" + GIT_TAG "9e84da55393a24953ed9f9869fa423f86f4860f7" + SOURCE_DIR "${SUBSTRAIT_DIR}" + CONFIGURE_COMMAND "" + BUILD_COMMAND "" + INSTALL_COMMAND "") + +set(SUBSTRAIT_PROTO_GEN_ALL) +foreach(SUBSTRAIT_PROTO ${SUBSTRAIT_PROTOS}) + set(SUBSTRAIT_PROTO_GEN "${SUBSTRAIT_GEN_DIR}/${SUBSTRAIT_PROTO}.pb.cc") + + set_source_files_properties(${SUBSTRAIT_PROTO_GEN} PROPERTIES GENERATED TRUE) + add_custom_command(OUTPUT ${SUBSTRAIT_PROTO_GEN} + COMMAND ${ARROW_PROTOBUF_PROTOC} + "-I${SUBSTRAIT_DIR}/binary" + "--cpp_out=${SUBSTRAIT_GEN_DIR}" + "${SUBSTRAIT_PROTO}.proto" + DEPENDS ${PROTO_DEPENDS} substrait_ep) + + list(APPEND ARROW_ENGINE_SRCS ${SUBSTRAIT_PROTO_GEN}) + list(APPEND SUBSTRAIT_PROTO_GEN_ALL ${SUBSTRAIT_PROTO_GEN}) +endforeach() + +add_custom_target(substrait_gen ALL DEPENDS ${SUBSTRAIT_PROTO_GEN_ALL}) + +add_arrow_lib(arrow_engine + CMAKE_PACKAGE_NAME + ArrowEngine + PKG_CONFIG_NAME + arrow-engine + OUTPUTS + ARROW_ENGINE_LIBRARIES + SOURCES + ${ARROW_ENGINE_SRCS} + PRECOMPILED_HEADERS + "$<$:arrow/engine/pch.h>" + SHARED_LINK_FLAGS + ${ARROW_VERSION_SCRIPT_FLAGS} # Defined in cpp/arrow/CMakeLists.txt + SHARED_LINK_LIBS + arrow_shared + ${ARROW_ENGINE_LINK_LIBS} + STATIC_LINK_LIBS + arrow_static + ${ARROW_ENGINE_LINK_LIBS}) + +foreach(LIB_TARGET ${ARROW_ENGINE_LIBRARIES}) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_ENGINE_EXPORTING) +endforeach() + +set(ARROW_ENGINE_TEST_LINK_LIBS ${ARROW_ENGINE_LINK_lIBS} ${ARROW_TEST_LINK_LIBS}) +if(ARROW_TEST_LINKAGE STREQUAL "static") + list(APPEND ARROW_ENGINE_TEST_LINK_LIBS arrow_engine_static) +else() + list(APPEND ARROW_ENGINE_TEST_LINK_LIBS arrow_engine_shared) +endif() + +add_arrow_test(engine_test + EXTRA_LINK_LIBS + ${ARROW_ENGINE_TEST_LINK_LIBS} + PREFIX + "arrow-engine" + LABELS + "arrow_engine") diff --git a/cpp/src/arrow/engine/api.h b/cpp/src/arrow/engine/api.h new file mode 100644 index 00000000000..f9f36a68340 --- /dev/null +++ b/cpp/src/arrow/engine/api.h @@ -0,0 +1,22 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// This API is EXPERIMENTAL. + +#pragma once + +#include "arrow/engine/substrait_consumer.h" diff --git a/cpp/src/arrow/engine/arrow-engine.pc.in b/cpp/src/arrow/engine/arrow-engine.pc.in new file mode 100644 index 00000000000..90fba82a8e9 --- /dev/null +++ b/cpp/src/arrow/engine/arrow-engine.pc.in @@ -0,0 +1,25 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +libdir=@CMAKE_INSTALL_FULL_LIBDIR@ +includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ + +Name: Apache Arrow Engine +Description: Apache Arrow's Query Engine. +Version: @ARROW_VERSION@ +Requires: arrow +Libs: -L${libdir} -larrow_engine diff --git a/cpp/src/arrow/engine/engine_test.cc b/cpp/src/arrow/engine/engine_test.cc new file mode 100644 index 00000000000..b248758bc12 --- /dev/null +++ b/cpp/src/arrow/engine/engine_test.cc @@ -0,0 +1,16 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. diff --git a/cpp/src/arrow/engine/pch.h b/cpp/src/arrow/engine/pch.h new file mode 100644 index 00000000000..ddb4c120f2a --- /dev/null +++ b/cpp/src/arrow/engine/pch.h @@ -0,0 +1,23 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// Often-used headers, for precompiling. +// If updating this header, please make sure you check compilation speed +// before checking in. Adding headers which are not used extremely often +// may incur a slowdown, since it makes the precompiled header heavier to load. + +#include "arrow/pch.h" diff --git a/cpp/src/arrow/engine/substrait_consumer.cc b/cpp/src/arrow/engine/substrait_consumer.cc new file mode 100644 index 00000000000..f42312dc30a --- /dev/null +++ b/cpp/src/arrow/engine/substrait_consumer.cc @@ -0,0 +1,43 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "arrow/engine/substrait_consumer.h" + +#include "arrow/util/string_view.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" + +#include "generated/substrait/plan.pb.h" + +namespace st = io::substrait; + +namespace arrow { +namespace engine { + +Result> ConvertPlan(const Buffer& buf) { + st::Plan plan; + + google::protobuf::io::ArrayInputStream istream{buf.data(), + static_cast(buf.size())}; + if (!plan.ParseFromZeroCopyStream(&istream)) { + return Status::Invalid("Not a valid plan"); + } + + return Status::NotImplemented(""); +} + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait_consumer.h b/cpp/src/arrow/engine/substrait_consumer.h new file mode 100644 index 00000000000..e4c6c4b46ee --- /dev/null +++ b/cpp/src/arrow/engine/substrait_consumer.h @@ -0,0 +1,36 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// This API is EXPERIMENTAL. + +#pragma once + +#include + +#include "arrow/buffer.h" +#include "arrow/compute/exec/exec_plan.h" +#include "arrow/engine/visibility.h" +#include "arrow/result.h" + +namespace arrow { +namespace engine { + +ARROW_ENGINE_EXPORT +Result> ConvertPlan(const Buffer&); + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/visibility.h b/cpp/src/arrow/engine/visibility.h new file mode 100644 index 00000000000..5b1651f78ab --- /dev/null +++ b/cpp/src/arrow/engine/visibility.h @@ -0,0 +1,50 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// This API is EXPERIMENTAL. + +#pragma once + +#if defined(_WIN32) || defined(__CYGWIN__) +#if defined(_MSC_VER) +#pragma warning(push) +#pragma warning(disable : 4251) +#else +#pragma GCC diagnostic ignored "-Wattributes" +#endif + +#ifdef ARROW_ENGINE_STATIC +#define ARROW_ENGINE_EXPORT +#elif defined(ARROW_ENGINE_EXPORTING) +#define ARROW_ENGINE_EXPORT __declspec(dllexport) +#else +#define ARROW_ENGINE_EXPORT __declspec(dllimport) +#endif + +#define ARROW_ENGINE_NO_EXPORT +#else // Not Windows +#ifndef ARROW_ENGINE_EXPORT +#define ARROW_ENGINE_EXPORT __attribute__((visibility("default"))) +#endif +#ifndef ARROW_ENGINE_NO_EXPORT +#define ARROW_ENGINE_NO_EXPORT __attribute__((visibility("hidden"))) +#endif +#endif // Non-Windows + +#if defined(_MSC_VER) +#pragma warning(pop) +#endif diff --git a/cpp/src/arrow/flight/CMakeLists.txt b/cpp/src/arrow/flight/CMakeLists.txt index 2cf8c9913e5..b57fa733468 100644 --- a/cpp/src/arrow/flight/CMakeLists.txt +++ b/cpp/src/arrow/flight/CMakeLists.txt @@ -53,7 +53,7 @@ endif() # TODO(wesm): Protobuf shared vs static linking set(FLIGHT_PROTO_PATH "${ARROW_SOURCE_DIR}/../format") -set(FLIGHT_PROTO ${ARROW_SOURCE_DIR}/../format/Flight.proto) +set(FLIGHT_PROTO "${ARROW_SOURCE_DIR}/../format/Flight.proto") set(FLIGHT_GENERATED_PROTO_FILES "${CMAKE_CURRENT_BINARY_DIR}/Flight.pb.cc" "${CMAKE_CURRENT_BINARY_DIR}/Flight.pb.h" diff --git a/cpp/src/generated/substrait/expression.pb.cc b/cpp/src/generated/substrait/expression.pb.cc new file mode 100644 index 00000000000..7f9cf3a7983 --- /dev/null +++ b/cpp/src/generated/substrait/expression.pb.cc @@ -0,0 +1,9641 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: expression.proto + +#include "expression.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace io { +namespace substrait { +constexpr Expression_Enum_Empty::Expression_Enum_Empty( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct Expression_Enum_EmptyDefaultTypeInternal { + constexpr Expression_Enum_EmptyDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_Enum_EmptyDefaultTypeInternal() {} + union { + Expression_Enum_Empty _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Enum_EmptyDefaultTypeInternal _Expression_Enum_Empty_default_instance_; +constexpr Expression_Enum::Expression_Enum( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct Expression_EnumDefaultTypeInternal { + constexpr Expression_EnumDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_EnumDefaultTypeInternal() {} + union { + Expression_Enum _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EnumDefaultTypeInternal _Expression_Enum_default_instance_; +constexpr Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : key_(nullptr) + , value_(nullptr){} +struct Expression_Literal_Map_KeyValueDefaultTypeInternal { + constexpr Expression_Literal_Map_KeyValueDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_Literal_Map_KeyValueDefaultTypeInternal() {} + union { + Expression_Literal_Map_KeyValue _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_Map_KeyValueDefaultTypeInternal _Expression_Literal_Map_KeyValue_default_instance_; +constexpr Expression_Literal_Map::Expression_Literal_Map( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : key_values_(){} +struct Expression_Literal_MapDefaultTypeInternal { + constexpr Expression_Literal_MapDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_Literal_MapDefaultTypeInternal() {} + union { + Expression_Literal_Map _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_MapDefaultTypeInternal _Expression_Literal_Map_default_instance_; +constexpr Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : years_(0) + , months_(0){} +struct Expression_Literal_IntervalYearToMonthDefaultTypeInternal { + constexpr Expression_Literal_IntervalYearToMonthDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_Literal_IntervalYearToMonthDefaultTypeInternal() {} + union { + Expression_Literal_IntervalYearToMonth _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_IntervalYearToMonthDefaultTypeInternal _Expression_Literal_IntervalYearToMonth_default_instance_; +constexpr Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : days_(0) + , seconds_(0){} +struct Expression_Literal_IntervalDayToSecondDefaultTypeInternal { + constexpr Expression_Literal_IntervalDayToSecondDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_Literal_IntervalDayToSecondDefaultTypeInternal() {} + union { + Expression_Literal_IntervalDayToSecond _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_IntervalDayToSecondDefaultTypeInternal _Expression_Literal_IntervalDayToSecond_default_instance_; +constexpr Expression_Literal_Struct::Expression_Literal_Struct( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : fields_(){} +struct Expression_Literal_StructDefaultTypeInternal { + constexpr Expression_Literal_StructDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_Literal_StructDefaultTypeInternal() {} + union { + Expression_Literal_Struct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_StructDefaultTypeInternal _Expression_Literal_Struct_default_instance_; +constexpr Expression_Literal_List::Expression_Literal_List( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : values_(){} +struct Expression_Literal_ListDefaultTypeInternal { + constexpr Expression_Literal_ListDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_Literal_ListDefaultTypeInternal() {} + union { + Expression_Literal_List _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_ListDefaultTypeInternal _Expression_Literal_List_default_instance_; +constexpr Expression_Literal::Expression_Literal( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct Expression_LiteralDefaultTypeInternal { + constexpr Expression_LiteralDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_LiteralDefaultTypeInternal() {} + union { + Expression_Literal _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_LiteralDefaultTypeInternal _Expression_Literal_default_instance_; +constexpr Expression_ScalarFunction::Expression_ScalarFunction( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : args_() + , id_(nullptr) + , output_type_(nullptr){} +struct Expression_ScalarFunctionDefaultTypeInternal { + constexpr Expression_ScalarFunctionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_ScalarFunctionDefaultTypeInternal() {} + union { + Expression_ScalarFunction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ScalarFunctionDefaultTypeInternal _Expression_ScalarFunction_default_instance_; +constexpr Expression_AggregateFunction::Expression_AggregateFunction( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : args_() + , sorts_() + , id_(nullptr) + , output_type_(nullptr) + , phase_(0) +{} +struct Expression_AggregateFunctionDefaultTypeInternal { + constexpr Expression_AggregateFunctionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_AggregateFunctionDefaultTypeInternal() {} + union { + Expression_AggregateFunction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_AggregateFunctionDefaultTypeInternal _Expression_AggregateFunction_default_instance_; +constexpr Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : offset_(PROTOBUF_LONGLONG(0)){} +struct Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal { + constexpr Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal() {} + union { + Expression_WindowFunction_Bound_Preceding _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal _Expression_WindowFunction_Bound_Preceding_default_instance_; +constexpr Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : offset_(PROTOBUF_LONGLONG(0)){} +struct Expression_WindowFunction_Bound_FollowingDefaultTypeInternal { + constexpr Expression_WindowFunction_Bound_FollowingDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_WindowFunction_Bound_FollowingDefaultTypeInternal() {} + union { + Expression_WindowFunction_Bound_Following _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_FollowingDefaultTypeInternal _Expression_WindowFunction_Bound_Following_default_instance_; +constexpr Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal { + constexpr Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal() {} + union { + Expression_WindowFunction_Bound_CurrentRow _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal _Expression_WindowFunction_Bound_CurrentRow_default_instance_; +constexpr Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal { + constexpr Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal() {} + union { + Expression_WindowFunction_Bound_Unbounded _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal _Expression_WindowFunction_Bound_Unbounded_default_instance_; +constexpr Expression_WindowFunction_Bound::Expression_WindowFunction_Bound( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct Expression_WindowFunction_BoundDefaultTypeInternal { + constexpr Expression_WindowFunction_BoundDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_WindowFunction_BoundDefaultTypeInternal() {} + union { + Expression_WindowFunction_Bound _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_BoundDefaultTypeInternal _Expression_WindowFunction_Bound_default_instance_; +constexpr Expression_WindowFunction::Expression_WindowFunction( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : partitions_() + , sorts_() + , args_() + , id_(nullptr) + , upper_bound_(nullptr) + , lower_bound_(nullptr) + , output_type_(nullptr) + , phase_(0) +{} +struct Expression_WindowFunctionDefaultTypeInternal { + constexpr Expression_WindowFunctionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_WindowFunctionDefaultTypeInternal() {} + union { + Expression_WindowFunction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunctionDefaultTypeInternal _Expression_WindowFunction_default_instance_; +constexpr Expression_SortField::Expression_SortField( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : expr_(nullptr) + , _oneof_case_{}{} +struct Expression_SortFieldDefaultTypeInternal { + constexpr Expression_SortFieldDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_SortFieldDefaultTypeInternal() {} + union { + Expression_SortField _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SortFieldDefaultTypeInternal _Expression_SortField_default_instance_; +constexpr Expression_IfThen_IfClause::Expression_IfThen_IfClause( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : if__(nullptr) + , then_(nullptr){} +struct Expression_IfThen_IfClauseDefaultTypeInternal { + constexpr Expression_IfThen_IfClauseDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_IfThen_IfClauseDefaultTypeInternal() {} + union { + Expression_IfThen_IfClause _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_IfThen_IfClauseDefaultTypeInternal _Expression_IfThen_IfClause_default_instance_; +constexpr Expression_IfThen::Expression_IfThen( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : ifs_() + , else__(nullptr){} +struct Expression_IfThenDefaultTypeInternal { + constexpr Expression_IfThenDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_IfThenDefaultTypeInternal() {} + union { + Expression_IfThen _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_IfThenDefaultTypeInternal _Expression_IfThen_default_instance_; +constexpr Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : if__(nullptr) + , then_(nullptr){} +struct Expression_SwitchExpression_IfValueDefaultTypeInternal { + constexpr Expression_SwitchExpression_IfValueDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_SwitchExpression_IfValueDefaultTypeInternal() {} + union { + Expression_SwitchExpression_IfValue _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SwitchExpression_IfValueDefaultTypeInternal _Expression_SwitchExpression_IfValue_default_instance_; +constexpr Expression_SwitchExpression::Expression_SwitchExpression( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : ifs_() + , else__(nullptr){} +struct Expression_SwitchExpressionDefaultTypeInternal { + constexpr Expression_SwitchExpressionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_SwitchExpressionDefaultTypeInternal() {} + union { + Expression_SwitchExpression _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SwitchExpressionDefaultTypeInternal _Expression_SwitchExpression_default_instance_; +constexpr Expression_SingularOrList::Expression_SingularOrList( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : options_() + , value_(nullptr){} +struct Expression_SingularOrListDefaultTypeInternal { + constexpr Expression_SingularOrListDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_SingularOrListDefaultTypeInternal() {} + union { + Expression_SingularOrList _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SingularOrListDefaultTypeInternal _Expression_SingularOrList_default_instance_; +constexpr Expression_MultiOrList_Record::Expression_MultiOrList_Record( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : fields_(){} +struct Expression_MultiOrList_RecordDefaultTypeInternal { + constexpr Expression_MultiOrList_RecordDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MultiOrList_RecordDefaultTypeInternal() {} + union { + Expression_MultiOrList_Record _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MultiOrList_RecordDefaultTypeInternal _Expression_MultiOrList_Record_default_instance_; +constexpr Expression_MultiOrList::Expression_MultiOrList( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : value_() + , options_(){} +struct Expression_MultiOrListDefaultTypeInternal { + constexpr Expression_MultiOrListDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MultiOrListDefaultTypeInternal() {} + union { + Expression_MultiOrList _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MultiOrListDefaultTypeInternal _Expression_MultiOrList_default_instance_; +constexpr Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : prerequisite_() + , function_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal { + constexpr Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal() {} + union { + Expression_EmbeddedFunction_PythonPickleFunction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal _Expression_EmbeddedFunction_PythonPickleFunction_default_instance_; +constexpr Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : prerequisite_() + , script_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal { + constexpr Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal() {} + union { + Expression_EmbeddedFunction_WebAssemblyFunction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal _Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_; +constexpr Expression_EmbeddedFunction::Expression_EmbeddedFunction( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : arguments_() + , output_type_(nullptr) + , _oneof_case_{}{} +struct Expression_EmbeddedFunctionDefaultTypeInternal { + constexpr Expression_EmbeddedFunctionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_EmbeddedFunctionDefaultTypeInternal() {} + union { + Expression_EmbeddedFunction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunctionDefaultTypeInternal _Expression_EmbeddedFunction_default_instance_; +constexpr Expression::Expression( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct ExpressionDefaultTypeInternal { + constexpr ExpressionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ExpressionDefaultTypeInternal() {} + union { + Expression _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExpressionDefaultTypeInternal _Expression_default_instance_; +} // namespace substrait +} // namespace io +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_expression_2eproto[29]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_expression_2eproto[2]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_expression_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Enum_Empty, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Enum, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Enum, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Enum, enum_kind_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map_KeyValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map_KeyValue, key_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map_KeyValue, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map, key_values_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalYearToMonth, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalYearToMonth, years_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalYearToMonth, months_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalDayToSecond, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalDayToSecond, days_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalDayToSecond, seconds_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Struct, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Struct, fields_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_List, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_List, values_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal, literal_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, args_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, output_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, args_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, sorts_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, phase_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, output_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Preceding, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Preceding, offset_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Following, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Following, offset_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_CurrentRow, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Unbounded, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound, kind_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, partitions_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, sorts_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, upper_bound_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, lower_bound_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, phase_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, output_type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, args_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SortField, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SortField, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SortField, expr_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SortField, sort_kind_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen_IfClause, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen_IfClause, if__), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen_IfClause, then_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen, ifs_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen, else__), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression_IfValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression_IfValue, if__), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression_IfValue, then_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression, ifs_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression, else__), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SingularOrList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SingularOrList, value_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SingularOrList, options_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MultiOrList_Record, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MultiOrList_Record, fields_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MultiOrList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MultiOrList, value_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MultiOrList, options_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction, function_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction, prerequisite_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, script_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, prerequisite_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, arguments_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, output_type_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, kind_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression, rex_type_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::io::substrait::Expression_Enum_Empty)}, + { 5, -1, sizeof(::io::substrait::Expression_Enum)}, + { 13, -1, sizeof(::io::substrait::Expression_Literal_Map_KeyValue)}, + { 20, -1, sizeof(::io::substrait::Expression_Literal_Map)}, + { 26, -1, sizeof(::io::substrait::Expression_Literal_IntervalYearToMonth)}, + { 33, -1, sizeof(::io::substrait::Expression_Literal_IntervalDayToSecond)}, + { 40, -1, sizeof(::io::substrait::Expression_Literal_Struct)}, + { 46, -1, sizeof(::io::substrait::Expression_Literal_List)}, + { 52, -1, sizeof(::io::substrait::Expression_Literal)}, + { 82, -1, sizeof(::io::substrait::Expression_ScalarFunction)}, + { 90, -1, sizeof(::io::substrait::Expression_AggregateFunction)}, + { 100, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Preceding)}, + { 106, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Following)}, + { 112, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_CurrentRow)}, + { 117, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Unbounded)}, + { 122, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound)}, + { 132, -1, sizeof(::io::substrait::Expression_WindowFunction)}, + { 145, -1, sizeof(::io::substrait::Expression_SortField)}, + { 154, -1, sizeof(::io::substrait::Expression_IfThen_IfClause)}, + { 161, -1, sizeof(::io::substrait::Expression_IfThen)}, + { 168, -1, sizeof(::io::substrait::Expression_SwitchExpression_IfValue)}, + { 175, -1, sizeof(::io::substrait::Expression_SwitchExpression)}, + { 182, -1, sizeof(::io::substrait::Expression_SingularOrList)}, + { 189, -1, sizeof(::io::substrait::Expression_MultiOrList_Record)}, + { 195, -1, sizeof(::io::substrait::Expression_MultiOrList)}, + { 202, -1, sizeof(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction)}, + { 209, -1, sizeof(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction)}, + { 216, -1, sizeof(::io::substrait::Expression_EmbeddedFunction)}, + { 226, -1, sizeof(::io::substrait::Expression)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_Expression_Enum_Empty_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Enum_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Literal_Map_KeyValue_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Literal_Map_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Literal_Struct_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Literal_List_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Literal_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_ScalarFunction_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_AggregateFunction_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_Following_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_WindowFunction_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_SortField_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_IfThen_IfClause_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_IfThen_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_SwitchExpression_IfValue_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_SwitchExpression_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_SingularOrList_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MultiOrList_Record_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MultiOrList_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_EmbeddedFunction_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_default_instance_), +}; + +const char descriptor_table_protodef_expression_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\020expression.proto\022\014io.substrait\032\ntype.p" + "roto\032\017selection.proto\032\020extensions.proto\"" + "\316$\n\nExpression\0223\n\007literal\030\001 \001(\0132 .io.sub" + "strait.Expression.LiteralH\000\0221\n\tselection" + "\030\002 \001(\0132\034.io.substrait.FieldReferenceH\000\022B" + "\n\017scalar_function\030\003 \001(\0132\'.io.substrait.E" + "xpression.ScalarFunctionH\000\022B\n\017window_fun" + "ction\030\005 \001(\0132\'.io.substrait.Expression.Wi" + "ndowFunctionH\000\0222\n\007if_then\030\006 \001(\0132\037.io.sub" + "strait.Expression.IfThenH\000\022F\n\021switch_exp" + "ression\030\007 \001(\0132).io.substrait.Expression." + "SwitchExpressionH\000\022C\n\020singular_or_list\030\010" + " \001(\0132\'.io.substrait.Expression.SingularO" + "rListH\000\022=\n\rmulti_or_list\030\t \001(\0132$.io.subs" + "trait.Expression.MultiOrListH\000\022-\n\004enum\030\n" + " \001(\0132\035.io.substrait.Expression.EnumH\000\032m\n" + "\004Enum\022\023\n\tspecified\030\001 \001(\tH\000\022:\n\013unspecifie" + "d\030\002 \001(\0132#.io.substrait.Expression.Enum.E" + "mptyH\000\032\007\n\005EmptyB\013\n\tenum_kind\032\361\010\n\007Literal" + "\022\021\n\007boolean\030\001 \001(\010H\000\022\014\n\002i8\030\002 \001(\005H\000\022\r\n\003i16" + "\030\003 \001(\005H\000\022\r\n\003i32\030\005 \001(\005H\000\022\r\n\003i64\030\007 \001(\003H\000\022\016" + "\n\004fp32\030\n \001(\002H\000\022\016\n\004fp64\030\013 \001(\001H\000\022\020\n\006string" + "\030\014 \001(\tH\000\022\020\n\006binary\030\r \001(\014H\000\022\023\n\ttimestamp\030" + "\016 \001(\006H\000\022\016\n\004date\030\020 \001(\007H\000\022\016\n\004time\030\021 \001(\004H\000\022" + "V\n\026interval_year_to_month\030\023 \001(\01324.io.sub" + "strait.Expression.Literal.IntervalYearTo" + "MonthH\000\022V\n\026interval_day_to_second\030\024 \001(\0132" + "4.io.substrait.Expression.Literal.Interv" + "alDayToSecondH\000\022\024\n\nfixed_char\030\025 \001(\tH\000\022\022\n" + "\010var_char\030\026 \001(\tH\000\022\026\n\014fixed_binary\030\027 \001(\014H" + "\000\022\021\n\007decimal\030\030 \001(\014H\000\0229\n\006struct\030\031 \001(\0132\'.i" + "o.substrait.Expression.Literal.StructH\000\022" + "3\n\003map\030\032 \001(\0132$.io.substrait.Expression.L" + "iteral.MapH\000\022\026\n\014timestamp_tz\030\033 \001(\006H\000\022\016\n\004" + "uuid\030\034 \001(\014H\000\022\"\n\004null\030\035 \001(\0132\022.io.substrai" + "t.TypeH\000\0225\n\004list\030\036 \001(\0132%.io.substrait.Ex" + "pression.Literal.ListH\000\032\264\001\n\003Map\022A\n\nkey_v" + "alues\030\001 \003(\0132-.io.substrait.Expression.Li" + "teral.Map.KeyValue\032j\n\010KeyValue\022-\n\003key\030\001 " + "\001(\0132 .io.substrait.Expression.Literal\022/\n" + "\005value\030\002 \001(\0132 .io.substrait.Expression.L" + "iteral\0324\n\023IntervalYearToMonth\022\r\n\005years\030\001" + " \001(\005\022\016\n\006months\030\002 \001(\005\0324\n\023IntervalDayToSec" + "ond\022\014\n\004days\030\001 \001(\005\022\017\n\007seconds\030\002 \001(\005\032:\n\006St" + "ruct\0220\n\006fields\030\001 \003(\0132 .io.substrait.Expr" + "ession.Literal\0328\n\004List\0220\n\006values\030\001 \003(\0132 " + ".io.substrait.Expression.LiteralB\016\n\014lite" + "ral_type\032\222\001\n\016ScalarFunction\022/\n\002id\030\001 \001(\0132" + "#.io.substrait.Extensions.FunctionId\022&\n\004" + "args\030\002 \003(\0132\030.io.substrait.Expression\022\'\n\013" + "output_type\030\003 \001(\0132\022.io.substrait.Type\032\202\002" + "\n\021AggregateFunction\022/\n\002id\030\001 \001(\0132#.io.sub" + "strait.Extensions.FunctionId\022&\n\004args\030\002 \003" + "(\0132\030.io.substrait.Expression\0221\n\005sorts\030\003 " + "\003(\0132\".io.substrait.Expression.SortField\022" + "8\n\005phase\030\004 \001(\0162).io.substrait.Expression" + ".AggregationPhase\022\'\n\013output_type\030\005 \001(\0132\022" + ".io.substrait.Type\032\327\006\n\016WindowFunction\022/\n" + "\002id\030\001 \001(\0132#.io.substrait.Extensions.Func" + "tionId\022,\n\npartitions\030\002 \003(\0132\030.io.substrai" + "t.Expression\0221\n\005sorts\030\003 \003(\0132\".io.substra" + "it.Expression.SortField\022B\n\013upper_bound\030\004" + " \001(\0132-.io.substrait.Expression.WindowFun" + "ction.Bound\022B\n\013lower_bound\030\005 \001(\0132-.io.su" + "bstrait.Expression.WindowFunction.Bound\022" + "8\n\005phase\030\006 \001(\0162).io.substrait.Expression" + ".AggregationPhase\022\'\n\013output_type\030\007 \001(\0132\022" + ".io.substrait.Type\022&\n\004args\030\010 \003(\0132\030.io.su" + "bstrait.Expression\032\237\003\n\005Bound\022L\n\tprecedin" + "g\030\001 \001(\01327.io.substrait.Expression.Window" + "Function.Bound.PrecedingH\000\022L\n\tfollowing\030" + "\002 \001(\01327.io.substrait.Expression.WindowFu" + "nction.Bound.FollowingH\000\022O\n\013current_row\030" + "\003 \001(\01328.io.substrait.Expression.WindowFu" + "nction.Bound.CurrentRowH\000\022L\n\tunbounded\030\004" + " \001(\01327.io.substrait.Expression.WindowFun" + "ction.Bound.UnboundedH\000\032\033\n\tPreceding\022\016\n\006" + "offset\030\001 \001(\003\032\033\n\tFollowing\022\016\n\006offset\030\001 \001(" + "\003\032\014\n\nCurrentRow\032\013\n\tUnboundedB\006\n\004kind\032\314\002\n" + "\tSortField\022&\n\004expr\030\001 \001(\0132\030.io.substrait." + "Expression\022E\n\tdirection\030\002 \001(\01620.io.subst" + "rait.Expression.SortField.SortDirectionH" + "\000\022B\n\023comparison_function\030\003 \001(\0132#.io.subs" + "trait.Extensions.FunctionIdH\000\"\177\n\rSortDir" + "ection\022\013\n\007UNKNOWN\020\000\022\023\n\017ASC_NULLS_FIRST\020\001" + "\022\022\n\016ASC_NULLS_LAST\020\002\022\024\n\020DESC_NULLS_FIRST" + "\020\003\022\023\n\017DESC_NULLS_LAST\020\004\022\r\n\tCLUSTERED\020\005B\013" + "\n\tsort_kind\032\301\001\n\006IfThen\0225\n\003ifs\030\001 \003(\0132(.io" + ".substrait.Expression.IfThen.IfClause\022&\n" + "\004else\030\002 \001(\0132\030.io.substrait.Expression\032X\n" + "\010IfClause\022$\n\002if\030\001 \001(\0132\030.io.substrait.Exp" + "ression\022&\n\004then\030\002 \001(\0132\030.io.substrait.Exp" + "ression\032\323\001\n\020SwitchExpression\022>\n\003ifs\030\001 \003(" + "\01321.io.substrait.Expression.SwitchExpres" + "sion.IfValue\022&\n\004else\030\002 \001(\0132\030.io.substrai" + "t.Expression\032W\n\007IfValue\022$\n\002if\030\001 \001(\0132\030.io" + ".substrait.Expression\022&\n\004then\030\002 \001(\0132\030.io" + ".substrait.Expression\032d\n\016SingularOrList\022" + "\'\n\005value\030\001 \001(\0132\030.io.substrait.Expression" + "\022)\n\007options\030\002 \003(\0132\030.io.substrait.Express" + "ion\032\250\001\n\013MultiOrList\022\'\n\005value\030\001 \003(\0132\030.io." + "substrait.Expression\022<\n\007options\030\002 \003(\0132+." + "io.substrait.Expression.MultiOrList.Reco" + "rd\0322\n\006Record\022(\n\006fields\030\001 \003(\0132\030.io.substr" + "ait.Expression\032\257\003\n\020EmbeddedFunction\022+\n\ta" + "rguments\030\001 \003(\0132\030.io.substrait.Expression" + "\022\'\n\013output_type\030\002 \001(\0132\022.io.substrait.Typ" + "e\022`\n\026python_pickle_function\030\003 \001(\0132>.io.s" + "ubstrait.Expression.EmbeddedFunction.Pyt" + "honPickleFunctionH\000\022^\n\025web_assembly_func" + "tion\030\004 \001(\0132=.io.substrait.Expression.Emb" + "eddedFunction.WebAssemblyFunctionH\000\032>\n\024P" + "ythonPickleFunction\022\020\n\010function\030\001 \001(\014\022\024\n" + "\014prerequisite\030\002 \003(\t\032;\n\023WebAssemblyFuncti" + "on\022\016\n\006script\030\001 \001(\014\022\024\n\014prerequisite\030\002 \003(\t" + "B\006\n\004kind\"\221\001\n\020AggregationPhase\022\013\n\007UNKNOWN" + "\020\000\022\033\n\027INITIAL_TO_INTERMEDIATE\020\001\022 \n\034INTER" + "MEDIATE_TO_INTERMEDIATE\020\002\022\025\n\021INITIAL_TO_" + "RESULT\020\003\022\032\n\026INTERMEDIATE_TO_RESULT\020\004B\n\n\010" + "rex_typeB\027P\001\252\002\022Substrait.Protobufb\006proto" + "3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_expression_2eproto_deps[3] = { + &::descriptor_table_extensions_2eproto, + &::descriptor_table_selection_2eproto, + &::descriptor_table_type_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_expression_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_expression_2eproto = { + false, false, 4801, descriptor_table_protodef_expression_2eproto, "expression.proto", + &descriptor_table_expression_2eproto_once, descriptor_table_expression_2eproto_deps, 3, 29, + schemas, file_default_instances, TableStruct_expression_2eproto::offsets, + file_level_metadata_expression_2eproto, file_level_enum_descriptors_expression_2eproto, file_level_service_descriptors_expression_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_expression_2eproto_getter() { + return &descriptor_table_expression_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_expression_2eproto(&descriptor_table_expression_2eproto); +namespace io { +namespace substrait { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_SortField_SortDirection_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_expression_2eproto); + return file_level_enum_descriptors_expression_2eproto[0]; +} +bool Expression_SortField_SortDirection_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr Expression_SortField_SortDirection Expression_SortField::UNKNOWN; +constexpr Expression_SortField_SortDirection Expression_SortField::ASC_NULLS_FIRST; +constexpr Expression_SortField_SortDirection Expression_SortField::ASC_NULLS_LAST; +constexpr Expression_SortField_SortDirection Expression_SortField::DESC_NULLS_FIRST; +constexpr Expression_SortField_SortDirection Expression_SortField::DESC_NULLS_LAST; +constexpr Expression_SortField_SortDirection Expression_SortField::CLUSTERED; +constexpr Expression_SortField_SortDirection Expression_SortField::SortDirection_MIN; +constexpr Expression_SortField_SortDirection Expression_SortField::SortDirection_MAX; +constexpr int Expression_SortField::SortDirection_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_AggregationPhase_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_expression_2eproto); + return file_level_enum_descriptors_expression_2eproto[1]; +} +bool Expression_AggregationPhase_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr Expression_AggregationPhase Expression::UNKNOWN; +constexpr Expression_AggregationPhase Expression::INITIAL_TO_INTERMEDIATE; +constexpr Expression_AggregationPhase Expression::INTERMEDIATE_TO_INTERMEDIATE; +constexpr Expression_AggregationPhase Expression::INITIAL_TO_RESULT; +constexpr Expression_AggregationPhase Expression::INTERMEDIATE_TO_RESULT; +constexpr Expression_AggregationPhase Expression::AggregationPhase_MIN; +constexpr Expression_AggregationPhase Expression::AggregationPhase_MAX; +constexpr int Expression::AggregationPhase_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) + +// =================================================================== + +class Expression_Enum_Empty::_Internal { + public: +}; + +Expression_Enum_Empty::Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Enum.Empty) +} +Expression_Enum_Empty::Expression_Enum_Empty(const Expression_Enum_Empty& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Enum.Empty) +} + +void Expression_Enum_Empty::SharedCtor() { +} + +Expression_Enum_Empty::~Expression_Enum_Empty() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Enum.Empty) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Enum_Empty::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_Enum_Empty::ArenaDtor(void* object) { + Expression_Enum_Empty* _this = reinterpret_cast< Expression_Enum_Empty* >(object); + (void)_this; +} +void Expression_Enum_Empty::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Enum_Empty::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_Enum_Empty::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Enum.Empty) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_Enum_Empty::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Enum_Empty::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Enum.Empty) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Enum.Empty) + return target; +} + +size_t Expression_Enum_Empty::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Enum.Empty) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_Enum_Empty::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Enum.Empty) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Enum_Empty* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Enum.Empty) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Enum.Empty) + MergeFrom(*source); + } +} + +void Expression_Enum_Empty::MergeFrom(const Expression_Enum_Empty& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Enum.Empty) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +void Expression_Enum_Empty::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Enum.Empty) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_Enum_Empty::CopyFrom(const Expression_Enum_Empty& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Enum.Empty) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_Enum_Empty::IsInitialized() const { + return true; +} + +void Expression_Enum_Empty::InternalSwap(Expression_Enum_Empty* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum_Empty::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[0]); +} + +// =================================================================== + +class Expression_Enum::_Internal { + public: + static const ::io::substrait::Expression_Enum_Empty& unspecified(const Expression_Enum* msg); +}; + +const ::io::substrait::Expression_Enum_Empty& +Expression_Enum::_Internal::unspecified(const Expression_Enum* msg) { + return *msg->enum_kind_.unspecified_; +} +void Expression_Enum::set_allocated_unspecified(::io::substrait::Expression_Enum_Empty* unspecified) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_enum_kind(); + if (unspecified) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(unspecified); + if (message_arena != submessage_arena) { + unspecified = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, unspecified, submessage_arena); + } + set_has_unspecified(); + enum_kind_.unspecified_ = unspecified; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Enum.unspecified) +} +Expression_Enum::Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Enum) +} +Expression_Enum::Expression_Enum(const Expression_Enum& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_enum_kind(); + switch (from.enum_kind_case()) { + case kSpecified: { + _internal_set_specified(from._internal_specified()); + break; + } + case kUnspecified: { + _internal_mutable_unspecified()->::io::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified()); + break; + } + case ENUM_KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Enum) +} + +void Expression_Enum::SharedCtor() { +clear_has_enum_kind(); +} + +Expression_Enum::~Expression_Enum() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Enum) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Enum::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_enum_kind()) { + clear_enum_kind(); + } +} + +void Expression_Enum::ArenaDtor(void* object) { + Expression_Enum* _this = reinterpret_cast< Expression_Enum* >(object); + (void)_this; +} +void Expression_Enum::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Enum::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_Enum::clear_enum_kind() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.Enum) + switch (enum_kind_case()) { + case kSpecified: { + enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kUnspecified: { + if (GetArena() == nullptr) { + delete enum_kind_.unspecified_; + } + break; + } + case ENUM_KIND_NOT_SET: { + break; + } + } + _oneof_case_[0] = ENUM_KIND_NOT_SET; +} + + +void Expression_Enum::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Enum) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_enum_kind(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_Enum::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string specified = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_specified(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Enum.specified")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Enum.Empty unspecified = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_unspecified(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Enum::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Enum) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string specified = 1; + if (_internal_has_specified()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_specified().data(), static_cast(this->_internal_specified().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.Enum.specified"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_specified(), target); + } + + // .io.substrait.Expression.Enum.Empty unspecified = 2; + if (_internal_has_unspecified()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::unspecified(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Enum) + return target; +} + +size_t Expression_Enum::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Enum) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (enum_kind_case()) { + // string specified = 1; + case kSpecified: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_specified()); + break; + } + // .io.substrait.Expression.Enum.Empty unspecified = 2; + case kUnspecified: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *enum_kind_.unspecified_); + break; + } + case ENUM_KIND_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_Enum::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Enum) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Enum* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Enum) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Enum) + MergeFrom(*source); + } +} + +void Expression_Enum::MergeFrom(const Expression_Enum& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Enum) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.enum_kind_case()) { + case kSpecified: { + _internal_set_specified(from._internal_specified()); + break; + } + case kUnspecified: { + _internal_mutable_unspecified()->::io::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified()); + break; + } + case ENUM_KIND_NOT_SET: { + break; + } + } +} + +void Expression_Enum::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Enum) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_Enum::CopyFrom(const Expression_Enum& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Enum) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_Enum::IsInitialized() const { + return true; +} + +void Expression_Enum::InternalSwap(Expression_Enum* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(enum_kind_, other->enum_kind_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[1]); +} + +// =================================================================== + +class Expression_Literal_Map_KeyValue::_Internal { + public: + static const ::io::substrait::Expression_Literal& key(const Expression_Literal_Map_KeyValue* msg); + static const ::io::substrait::Expression_Literal& value(const Expression_Literal_Map_KeyValue* msg); +}; + +const ::io::substrait::Expression_Literal& +Expression_Literal_Map_KeyValue::_Internal::key(const Expression_Literal_Map_KeyValue* msg) { + return *msg->key_; +} +const ::io::substrait::Expression_Literal& +Expression_Literal_Map_KeyValue::_Internal::value(const Expression_Literal_Map_KeyValue* msg) { + return *msg->value_; +} +Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Map.KeyValue) +} +Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_key()) { + key_ = new ::io::substrait::Expression_Literal(*from.key_); + } else { + key_ = nullptr; + } + if (from._internal_has_value()) { + value_ = new ::io::substrait::Expression_Literal(*from.value_); + } else { + value_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Map.KeyValue) +} + +void Expression_Literal_Map_KeyValue::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&value_) - + reinterpret_cast(&key_)) + sizeof(value_)); +} + +Expression_Literal_Map_KeyValue::~Expression_Literal_Map_KeyValue() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Map.KeyValue) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Literal_Map_KeyValue::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete key_; + if (this != internal_default_instance()) delete value_; +} + +void Expression_Literal_Map_KeyValue::ArenaDtor(void* object) { + Expression_Literal_Map_KeyValue* _this = reinterpret_cast< Expression_Literal_Map_KeyValue* >(object); + (void)_this; +} +void Expression_Literal_Map_KeyValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Literal_Map_KeyValue::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_Literal_Map_KeyValue::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Map.KeyValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && key_ != nullptr) { + delete key_; + } + key_ = nullptr; + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_Literal_Map_KeyValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.Literal key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map_KeyValue::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Map.KeyValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.Literal key = 1; + if (this->has_key()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::key(this), target, stream); + } + + // .io.substrait.Expression.Literal value = 2; + if (this->has_value()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::value(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Map.KeyValue) + return target; +} + +size_t Expression_Literal_Map_KeyValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Map.KeyValue) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression.Literal key = 1; + if (this->has_key()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *key_); + } + + // .io.substrait.Expression.Literal value = 2; + if (this->has_value()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_Literal_Map_KeyValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Map.KeyValue) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Literal_Map_KeyValue* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Map.KeyValue) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Map.KeyValue) + MergeFrom(*source); + } +} + +void Expression_Literal_Map_KeyValue::MergeFrom(const Expression_Literal_Map_KeyValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Map.KeyValue) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_key()) { + _internal_mutable_key()->::io::substrait::Expression_Literal::MergeFrom(from._internal_key()); + } + if (from.has_value()) { + _internal_mutable_value()->::io::substrait::Expression_Literal::MergeFrom(from._internal_value()); + } +} + +void Expression_Literal_Map_KeyValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Map.KeyValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_Literal_Map_KeyValue::CopyFrom(const Expression_Literal_Map_KeyValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Map.KeyValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_Literal_Map_KeyValue::IsInitialized() const { + return true; +} + +void Expression_Literal_Map_KeyValue::InternalSwap(Expression_Literal_Map_KeyValue* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, value_) + + sizeof(Expression_Literal_Map_KeyValue::value_) + - PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, key_)>( + reinterpret_cast(&key_), + reinterpret_cast(&other->key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map_KeyValue::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[2]); +} + +// =================================================================== + +class Expression_Literal_Map::_Internal { + public: +}; + +Expression_Literal_Map::Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + key_values_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Map) +} +Expression_Literal_Map::Expression_Literal_Map(const Expression_Literal_Map& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + key_values_(from.key_values_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Map) +} + +void Expression_Literal_Map::SharedCtor() { +} + +Expression_Literal_Map::~Expression_Literal_Map() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Map) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Literal_Map::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_Literal_Map::ArenaDtor(void* object) { + Expression_Literal_Map* _this = reinterpret_cast< Expression_Literal_Map* >(object); + (void)_this; +} +void Expression_Literal_Map::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Literal_Map::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_Literal_Map::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Map) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + key_values_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_key_values(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Map) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_key_values_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_key_values(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Map) + return target; +} + +size_t Expression_Literal_Map::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Map) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + total_size += 1UL * this->_internal_key_values_size(); + for (const auto& msg : this->key_values_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_Literal_Map::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Map) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Literal_Map* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Map) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Map) + MergeFrom(*source); + } +} + +void Expression_Literal_Map::MergeFrom(const Expression_Literal_Map& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Map) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + key_values_.MergeFrom(from.key_values_); +} + +void Expression_Literal_Map::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Map) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_Literal_Map::CopyFrom(const Expression_Literal_Map& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Map) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_Literal_Map::IsInitialized() const { + return true; +} + +void Expression_Literal_Map::InternalSwap(Expression_Literal_Map* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + key_values_.InternalSwap(&other->key_values_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[3]); +} + +// =================================================================== + +class Expression_Literal_IntervalYearToMonth::_Internal { + public: +}; + +Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.IntervalYearToMonth) +} +Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&years_, &from.years_, + static_cast(reinterpret_cast(&months_) - + reinterpret_cast(&years_)) + sizeof(months_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.IntervalYearToMonth) +} + +void Expression_Literal_IntervalYearToMonth::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&years_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&months_) - + reinterpret_cast(&years_)) + sizeof(months_)); +} + +Expression_Literal_IntervalYearToMonth::~Expression_Literal_IntervalYearToMonth() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.IntervalYearToMonth) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Literal_IntervalYearToMonth::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_Literal_IntervalYearToMonth::ArenaDtor(void* object) { + Expression_Literal_IntervalYearToMonth* _this = reinterpret_cast< Expression_Literal_IntervalYearToMonth* >(object); + (void)_this; +} +void Expression_Literal_IntervalYearToMonth::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Literal_IntervalYearToMonth::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_Literal_IntervalYearToMonth::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.IntervalYearToMonth) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&years_, 0, static_cast( + reinterpret_cast(&months_) - + reinterpret_cast(&years_)) + sizeof(months_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_Literal_IntervalYearToMonth::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 years = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + years_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 months = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + months_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalYearToMonth::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.IntervalYearToMonth) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 years = 1; + if (this->years() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_years(), target); + } + + // int32 months = 2; + if (this->months() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_months(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.IntervalYearToMonth) + return target; +} + +size_t Expression_Literal_IntervalYearToMonth::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.IntervalYearToMonth) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 years = 1; + if (this->years() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_years()); + } + + // int32 months = 2; + if (this->months() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_months()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_Literal_IntervalYearToMonth::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Literal_IntervalYearToMonth* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.IntervalYearToMonth) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.IntervalYearToMonth) + MergeFrom(*source); + } +} + +void Expression_Literal_IntervalYearToMonth::MergeFrom(const Expression_Literal_IntervalYearToMonth& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.years() != 0) { + _internal_set_years(from._internal_years()); + } + if (from.months() != 0) { + _internal_set_months(from._internal_months()); + } +} + +void Expression_Literal_IntervalYearToMonth::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_Literal_IntervalYearToMonth::CopyFrom(const Expression_Literal_IntervalYearToMonth& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_Literal_IntervalYearToMonth::IsInitialized() const { + return true; +} + +void Expression_Literal_IntervalYearToMonth::InternalSwap(Expression_Literal_IntervalYearToMonth* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, months_) + + sizeof(Expression_Literal_IntervalYearToMonth::months_) + - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, years_)>( + reinterpret_cast(&years_), + reinterpret_cast(&other->years_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalYearToMonth::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[4]); +} + +// =================================================================== + +class Expression_Literal_IntervalDayToSecond::_Internal { + public: +}; + +Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.IntervalDayToSecond) +} +Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&days_, &from.days_, + static_cast(reinterpret_cast(&seconds_) - + reinterpret_cast(&days_)) + sizeof(seconds_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.IntervalDayToSecond) +} + +void Expression_Literal_IntervalDayToSecond::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&days_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&seconds_) - + reinterpret_cast(&days_)) + sizeof(seconds_)); +} + +Expression_Literal_IntervalDayToSecond::~Expression_Literal_IntervalDayToSecond() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.IntervalDayToSecond) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Literal_IntervalDayToSecond::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_Literal_IntervalDayToSecond::ArenaDtor(void* object) { + Expression_Literal_IntervalDayToSecond* _this = reinterpret_cast< Expression_Literal_IntervalDayToSecond* >(object); + (void)_this; +} +void Expression_Literal_IntervalDayToSecond::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Literal_IntervalDayToSecond::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_Literal_IntervalDayToSecond::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.IntervalDayToSecond) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&days_, 0, static_cast( + reinterpret_cast(&seconds_) - + reinterpret_cast(&days_)) + sizeof(seconds_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_Literal_IntervalDayToSecond::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 days = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + days_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 seconds = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalDayToSecond::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.IntervalDayToSecond) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 days = 1; + if (this->days() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_days(), target); + } + + // int32 seconds = 2; + if (this->seconds() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_seconds(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.IntervalDayToSecond) + return target; +} + +size_t Expression_Literal_IntervalDayToSecond::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.IntervalDayToSecond) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 days = 1; + if (this->days() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_days()); + } + + // int32 seconds = 2; + if (this->seconds() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_seconds()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_Literal_IntervalDayToSecond::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Literal_IntervalDayToSecond* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.IntervalDayToSecond) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.IntervalDayToSecond) + MergeFrom(*source); + } +} + +void Expression_Literal_IntervalDayToSecond::MergeFrom(const Expression_Literal_IntervalDayToSecond& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.days() != 0) { + _internal_set_days(from._internal_days()); + } + if (from.seconds() != 0) { + _internal_set_seconds(from._internal_seconds()); + } +} + +void Expression_Literal_IntervalDayToSecond::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_Literal_IntervalDayToSecond::CopyFrom(const Expression_Literal_IntervalDayToSecond& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_Literal_IntervalDayToSecond::IsInitialized() const { + return true; +} + +void Expression_Literal_IntervalDayToSecond::InternalSwap(Expression_Literal_IntervalDayToSecond* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, seconds_) + + sizeof(Expression_Literal_IntervalDayToSecond::seconds_) + - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, days_)>( + reinterpret_cast(&days_), + reinterpret_cast(&other->days_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalDayToSecond::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[5]); +} + +// =================================================================== + +class Expression_Literal_Struct::_Internal { + public: +}; + +Expression_Literal_Struct::Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + fields_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Struct) +} +Expression_Literal_Struct::Expression_Literal_Struct(const Expression_Literal_Struct& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + fields_(from.fields_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Struct) +} + +void Expression_Literal_Struct::SharedCtor() { +} + +Expression_Literal_Struct::~Expression_Literal_Struct() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Struct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Literal_Struct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_Literal_Struct::ArenaDtor(void* object) { + Expression_Literal_Struct* _this = reinterpret_cast< Expression_Literal_Struct* >(object); + (void)_this; +} +void Expression_Literal_Struct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Literal_Struct::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_Literal_Struct::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Struct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + fields_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_Literal_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression.Literal fields = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_fields(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Struct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Struct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression.Literal fields = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_fields_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_fields(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Struct) + return target; +} + +size_t Expression_Literal_Struct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Struct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression.Literal fields = 1; + total_size += 1UL * this->_internal_fields_size(); + for (const auto& msg : this->fields_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_Literal_Struct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Struct) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Literal_Struct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Struct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Struct) + MergeFrom(*source); + } +} + +void Expression_Literal_Struct::MergeFrom(const Expression_Literal_Struct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Struct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + fields_.MergeFrom(from.fields_); +} + +void Expression_Literal_Struct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Struct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_Literal_Struct::CopyFrom(const Expression_Literal_Struct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Struct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_Literal_Struct::IsInitialized() const { + return true; +} + +void Expression_Literal_Struct::InternalSwap(Expression_Literal_Struct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + fields_.InternalSwap(&other->fields_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Struct::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[6]); +} + +// =================================================================== + +class Expression_Literal_List::_Internal { + public: +}; + +Expression_Literal_List::Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + values_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.List) +} +Expression_Literal_List::Expression_Literal_List(const Expression_Literal_List& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + values_(from.values_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.List) +} + +void Expression_Literal_List::SharedCtor() { +} + +Expression_Literal_List::~Expression_Literal_List() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.List) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Literal_List::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_Literal_List::ArenaDtor(void* object) { + Expression_Literal_List* _this = reinterpret_cast< Expression_Literal_List* >(object); + (void)_this; +} +void Expression_Literal_List::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Literal_List::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_Literal_List::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.List) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + values_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression.Literal values = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_values(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_List::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.List) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression.Literal values = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_values_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_values(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.List) + return target; +} + +size_t Expression_Literal_List::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.List) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression.Literal values = 1; + total_size += 1UL * this->_internal_values_size(); + for (const auto& msg : this->values_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_Literal_List::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.List) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Literal_List* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.List) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.List) + MergeFrom(*source); + } +} + +void Expression_Literal_List::MergeFrom(const Expression_Literal_List& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.List) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + values_.MergeFrom(from.values_); +} + +void Expression_Literal_List::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.List) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_Literal_List::CopyFrom(const Expression_Literal_List& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.List) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_Literal_List::IsInitialized() const { + return true; +} + +void Expression_Literal_List::InternalSwap(Expression_Literal_List* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + values_.InternalSwap(&other->values_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_List::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[7]); +} + +// =================================================================== + +class Expression_Literal::_Internal { + public: + static const ::io::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month(const Expression_Literal* msg); + static const ::io::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second(const Expression_Literal* msg); + static const ::io::substrait::Expression_Literal_Struct& struct_(const Expression_Literal* msg); + static const ::io::substrait::Expression_Literal_Map& map(const Expression_Literal* msg); + static const ::io::substrait::Type& null(const Expression_Literal* msg); + static const ::io::substrait::Expression_Literal_List& list(const Expression_Literal* msg); +}; + +const ::io::substrait::Expression_Literal_IntervalYearToMonth& +Expression_Literal::_Internal::interval_year_to_month(const Expression_Literal* msg) { + return *msg->literal_type_.interval_year_to_month_; +} +const ::io::substrait::Expression_Literal_IntervalDayToSecond& +Expression_Literal::_Internal::interval_day_to_second(const Expression_Literal* msg) { + return *msg->literal_type_.interval_day_to_second_; +} +const ::io::substrait::Expression_Literal_Struct& +Expression_Literal::_Internal::struct_(const Expression_Literal* msg) { + return *msg->literal_type_.struct__; +} +const ::io::substrait::Expression_Literal_Map& +Expression_Literal::_Internal::map(const Expression_Literal* msg) { + return *msg->literal_type_.map_; +} +const ::io::substrait::Type& +Expression_Literal::_Internal::null(const Expression_Literal* msg) { + return *msg->literal_type_.null_; +} +const ::io::substrait::Expression_Literal_List& +Expression_Literal::_Internal::list(const Expression_Literal* msg) { + return *msg->literal_type_.list_; +} +void Expression_Literal::set_allocated_interval_year_to_month(::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (interval_year_to_month) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_year_to_month); + if (message_arena != submessage_arena) { + interval_year_to_month = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interval_year_to_month, submessage_arena); + } + set_has_interval_year_to_month(); + literal_type_.interval_year_to_month_ = interval_year_to_month; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.interval_year_to_month) +} +void Expression_Literal::set_allocated_interval_day_to_second(::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (interval_day_to_second) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_day_to_second); + if (message_arena != submessage_arena) { + interval_day_to_second = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interval_day_to_second, submessage_arena); + } + set_has_interval_day_to_second(); + literal_type_.interval_day_to_second_ = interval_day_to_second; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.interval_day_to_second) +} +void Expression_Literal::set_allocated_struct_(::io::substrait::Expression_Literal_Struct* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + set_has_struct_(); + literal_type_.struct__ = struct_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.struct) +} +void Expression_Literal::set_allocated_map(::io::substrait::Expression_Literal_Map* map) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (map) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + if (message_arena != submessage_arena) { + map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map, submessage_arena); + } + set_has_map(); + literal_type_.map_ = map; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.map) +} +void Expression_Literal::set_allocated_null(::io::substrait::Type* null) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (null) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(null)->GetArena(); + if (message_arena != submessage_arena) { + null = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, null, submessage_arena); + } + set_has_null(); + literal_type_.null_ = null; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.null) +} +void Expression_Literal::clear_null() { + if (_internal_has_null()) { + if (GetArena() == nullptr) { + delete literal_type_.null_; + } + clear_has_literal_type(); + } +} +void Expression_Literal::set_allocated_list(::io::substrait::Expression_Literal_List* list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + if (message_arena != submessage_arena) { + list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, list, submessage_arena); + } + set_has_list(); + literal_type_.list_ = list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.list) +} +Expression_Literal::Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal) +} +Expression_Literal::Expression_Literal(const Expression_Literal& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_literal_type(); + switch (from.literal_type_case()) { + case kBoolean: { + _internal_set_boolean(from._internal_boolean()); + break; + } + case kI8: { + _internal_set_i8(from._internal_i8()); + break; + } + case kI16: { + _internal_set_i16(from._internal_i16()); + break; + } + case kI32: { + _internal_set_i32(from._internal_i32()); + break; + } + case kI64: { + _internal_set_i64(from._internal_i64()); + break; + } + case kFp32: { + _internal_set_fp32(from._internal_fp32()); + break; + } + case kFp64: { + _internal_set_fp64(from._internal_fp64()); + break; + } + case kString: { + _internal_set_string(from._internal_string()); + break; + } + case kBinary: { + _internal_set_binary(from._internal_binary()); + break; + } + case kTimestamp: { + _internal_set_timestamp(from._internal_timestamp()); + break; + } + case kDate: { + _internal_set_date(from._internal_date()); + break; + } + case kTime: { + _internal_set_time(from._internal_time()); + break; + } + case kIntervalYearToMonth: { + _internal_mutable_interval_year_to_month()->::io::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); + break; + } + case kIntervalDayToSecond: { + _internal_mutable_interval_day_to_second()->::io::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); + break; + } + case kFixedChar: { + _internal_set_fixed_char(from._internal_fixed_char()); + break; + } + case kVarChar: { + _internal_set_var_char(from._internal_var_char()); + break; + } + case kFixedBinary: { + _internal_set_fixed_binary(from._internal_fixed_binary()); + break; + } + case kDecimal: { + _internal_set_decimal(from._internal_decimal()); + break; + } + case kStruct: { + _internal_mutable_struct_()->::io::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); + break; + } + case kTimestampTz: { + _internal_set_timestamp_tz(from._internal_timestamp_tz()); + break; + } + case kUuid: { + _internal_set_uuid(from._internal_uuid()); + break; + } + case kNull: { + _internal_mutable_null()->::io::substrait::Type::MergeFrom(from._internal_null()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); + break; + } + case LITERAL_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal) +} + +void Expression_Literal::SharedCtor() { +clear_has_literal_type(); +} + +Expression_Literal::~Expression_Literal() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Literal::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_literal_type()) { + clear_literal_type(); + } +} + +void Expression_Literal::ArenaDtor(void* object) { + Expression_Literal* _this = reinterpret_cast< Expression_Literal* >(object); + (void)_this; +} +void Expression_Literal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Literal::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_Literal::clear_literal_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.Literal) + switch (literal_type_case()) { + case kBoolean: { + // No need to clear + break; + } + case kI8: { + // No need to clear + break; + } + case kI16: { + // No need to clear + break; + } + case kI32: { + // No need to clear + break; + } + case kI64: { + // No need to clear + break; + } + case kFp32: { + // No need to clear + break; + } + case kFp64: { + // No need to clear + break; + } + case kString: { + literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kBinary: { + literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kTimestamp: { + // No need to clear + break; + } + case kDate: { + // No need to clear + break; + } + case kTime: { + // No need to clear + break; + } + case kIntervalYearToMonth: { + if (GetArena() == nullptr) { + delete literal_type_.interval_year_to_month_; + } + break; + } + case kIntervalDayToSecond: { + if (GetArena() == nullptr) { + delete literal_type_.interval_day_to_second_; + } + break; + } + case kFixedChar: { + literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kVarChar: { + literal_type_.var_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kFixedBinary: { + literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kDecimal: { + literal_type_.decimal_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kStruct: { + if (GetArena() == nullptr) { + delete literal_type_.struct__; + } + break; + } + case kMap: { + if (GetArena() == nullptr) { + delete literal_type_.map_; + } + break; + } + case kTimestampTz: { + // No need to clear + break; + } + case kUuid: { + literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kNull: { + if (GetArena() == nullptr) { + delete literal_type_.null_; + } + break; + } + case kList: { + if (GetArena() == nullptr) { + delete literal_type_.list_; + } + break; + } + case LITERAL_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = LITERAL_TYPE_NOT_SET; +} + + +void Expression_Literal::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_literal_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // bool boolean = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _internal_set_boolean(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 i8 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _internal_set_i8(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 i16 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _internal_set_i16(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 i32 = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _internal_set_i32(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 i64 = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _internal_set_i64(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float fp32 = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 85)) { + _internal_set_fp32(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // double fp64 = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 89)) { + _internal_set_fp64(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + // string string = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + auto str = _internal_mutable_string(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.string")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes binary = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + auto str = _internal_mutable_binary(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // fixed64 timestamp = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 113)) { + _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr)); + ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint64); + } else goto handle_unusual; + continue; + // fixed32 date = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 133)) { + _internal_set_date(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint32>(ptr)); + ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint32); + } else goto handle_unusual; + continue; + // uint64 time = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) { + _internal_set_time(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_interval_year_to_month(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { + ptr = ctx->ParseMessage(_internal_mutable_interval_day_to_second(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string fixed_char = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { + auto str = _internal_mutable_fixed_char(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.fixed_char")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string var_char = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { + auto str = _internal_mutable_var_char(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.var_char")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes fixed_binary = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { + auto str = _internal_mutable_fixed_binary(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes decimal = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { + auto str = _internal_mutable_decimal(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.Struct struct = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.Map map = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) { + ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // fixed64 timestamp_tz = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 217)) { + _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr)); + ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint64); + } else goto handle_unusual; + continue; + // bytes uuid = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { + auto str = _internal_mutable_uuid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type null = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { + ptr = ctx->ParseMessage(_internal_mutable_null(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.List list = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 242)) { + ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bool boolean = 1; + if (_internal_has_boolean()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_boolean(), target); + } + + // int32 i8 = 2; + if (_internal_has_i8()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_i8(), target); + } + + // int32 i16 = 3; + if (_internal_has_i16()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_i16(), target); + } + + // int32 i32 = 5; + if (_internal_has_i32()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_i32(), target); + } + + // int64 i64 = 7; + if (_internal_has_i64()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_i64(), target); + } + + // float fp32 = 10; + if (_internal_has_fp32()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_fp32(), target); + } + + // double fp64 = 11; + if (_internal_has_fp64()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(11, this->_internal_fp64(), target); + } + + // string string = 12; + if (_internal_has_string()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_string().data(), static_cast(this->_internal_string().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.Literal.string"); + target = stream->WriteStringMaybeAliased( + 12, this->_internal_string(), target); + } + + // bytes binary = 13; + if (_internal_has_binary()) { + target = stream->WriteBytesMaybeAliased( + 13, this->_internal_binary(), target); + } + + // fixed64 timestamp = 14; + if (_internal_has_timestamp()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed64ToArray(14, this->_internal_timestamp(), target); + } + + // fixed32 date = 16; + if (_internal_has_date()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed32ToArray(16, this->_internal_date(), target); + } + + // uint64 time = 17; + if (_internal_has_time()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(17, this->_internal_time(), target); + } + + // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + if (_internal_has_interval_year_to_month()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 19, _Internal::interval_year_to_month(this), target, stream); + } + + // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + if (_internal_has_interval_day_to_second()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 20, _Internal::interval_day_to_second(this), target, stream); + } + + // string fixed_char = 21; + if (_internal_has_fixed_char()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_fixed_char().data(), static_cast(this->_internal_fixed_char().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.Literal.fixed_char"); + target = stream->WriteStringMaybeAliased( + 21, this->_internal_fixed_char(), target); + } + + // string var_char = 22; + if (_internal_has_var_char()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_var_char().data(), static_cast(this->_internal_var_char().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.Literal.var_char"); + target = stream->WriteStringMaybeAliased( + 22, this->_internal_var_char(), target); + } + + // bytes fixed_binary = 23; + if (_internal_has_fixed_binary()) { + target = stream->WriteBytesMaybeAliased( + 23, this->_internal_fixed_binary(), target); + } + + // bytes decimal = 24; + if (_internal_has_decimal()) { + target = stream->WriteBytesMaybeAliased( + 24, this->_internal_decimal(), target); + } + + // .io.substrait.Expression.Literal.Struct struct = 25; + if (_internal_has_struct_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 25, _Internal::struct_(this), target, stream); + } + + // .io.substrait.Expression.Literal.Map map = 26; + if (_internal_has_map()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 26, _Internal::map(this), target, stream); + } + + // fixed64 timestamp_tz = 27; + if (_internal_has_timestamp_tz()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed64ToArray(27, this->_internal_timestamp_tz(), target); + } + + // bytes uuid = 28; + if (_internal_has_uuid()) { + target = stream->WriteBytesMaybeAliased( + 28, this->_internal_uuid(), target); + } + + // .io.substrait.Type null = 29; + if (_internal_has_null()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 29, _Internal::null(this), target, stream); + } + + // .io.substrait.Expression.Literal.List list = 30; + if (_internal_has_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 30, _Internal::list(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal) + return target; +} + +size_t Expression_Literal::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (literal_type_case()) { + // bool boolean = 1; + case kBoolean: { + total_size += 1 + 1; + break; + } + // int32 i8 = 2; + case kI8: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_i8()); + break; + } + // int32 i16 = 3; + case kI16: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_i16()); + break; + } + // int32 i32 = 5; + case kI32: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_i32()); + break; + } + // int64 i64 = 7; + case kI64: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_i64()); + break; + } + // float fp32 = 10; + case kFp32: { + total_size += 1 + 4; + break; + } + // double fp64 = 11; + case kFp64: { + total_size += 1 + 8; + break; + } + // string string = 12; + case kString: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_string()); + break; + } + // bytes binary = 13; + case kBinary: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_binary()); + break; + } + // fixed64 timestamp = 14; + case kTimestamp: { + total_size += 1 + 8; + break; + } + // fixed32 date = 16; + case kDate: { + total_size += 2 + 4; + break; + } + // uint64 time = 17; + case kTime: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_time()); + break; + } + // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + case kIntervalYearToMonth: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.interval_year_to_month_); + break; + } + // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + case kIntervalDayToSecond: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.interval_day_to_second_); + break; + } + // string fixed_char = 21; + case kFixedChar: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_fixed_char()); + break; + } + // string var_char = 22; + case kVarChar: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_var_char()); + break; + } + // bytes fixed_binary = 23; + case kFixedBinary: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fixed_binary()); + break; + } + // bytes decimal = 24; + case kDecimal: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_decimal()); + break; + } + // .io.substrait.Expression.Literal.Struct struct = 25; + case kStruct: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.struct__); + break; + } + // .io.substrait.Expression.Literal.Map map = 26; + case kMap: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.map_); + break; + } + // fixed64 timestamp_tz = 27; + case kTimestampTz: { + total_size += 2 + 8; + break; + } + // bytes uuid = 28; + case kUuid: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_uuid()); + break; + } + // .io.substrait.Type null = 29; + case kNull: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.null_); + break; + } + // .io.substrait.Expression.Literal.List list = 30; + case kList: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.list_); + break; + } + case LITERAL_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_Literal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Literal* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal) + MergeFrom(*source); + } +} + +void Expression_Literal::MergeFrom(const Expression_Literal& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.literal_type_case()) { + case kBoolean: { + _internal_set_boolean(from._internal_boolean()); + break; + } + case kI8: { + _internal_set_i8(from._internal_i8()); + break; + } + case kI16: { + _internal_set_i16(from._internal_i16()); + break; + } + case kI32: { + _internal_set_i32(from._internal_i32()); + break; + } + case kI64: { + _internal_set_i64(from._internal_i64()); + break; + } + case kFp32: { + _internal_set_fp32(from._internal_fp32()); + break; + } + case kFp64: { + _internal_set_fp64(from._internal_fp64()); + break; + } + case kString: { + _internal_set_string(from._internal_string()); + break; + } + case kBinary: { + _internal_set_binary(from._internal_binary()); + break; + } + case kTimestamp: { + _internal_set_timestamp(from._internal_timestamp()); + break; + } + case kDate: { + _internal_set_date(from._internal_date()); + break; + } + case kTime: { + _internal_set_time(from._internal_time()); + break; + } + case kIntervalYearToMonth: { + _internal_mutable_interval_year_to_month()->::io::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); + break; + } + case kIntervalDayToSecond: { + _internal_mutable_interval_day_to_second()->::io::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); + break; + } + case kFixedChar: { + _internal_set_fixed_char(from._internal_fixed_char()); + break; + } + case kVarChar: { + _internal_set_var_char(from._internal_var_char()); + break; + } + case kFixedBinary: { + _internal_set_fixed_binary(from._internal_fixed_binary()); + break; + } + case kDecimal: { + _internal_set_decimal(from._internal_decimal()); + break; + } + case kStruct: { + _internal_mutable_struct_()->::io::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); + break; + } + case kTimestampTz: { + _internal_set_timestamp_tz(from._internal_timestamp_tz()); + break; + } + case kUuid: { + _internal_set_uuid(from._internal_uuid()); + break; + } + case kNull: { + _internal_mutable_null()->::io::substrait::Type::MergeFrom(from._internal_null()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); + break; + } + case LITERAL_TYPE_NOT_SET: { + break; + } + } +} + +void Expression_Literal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_Literal::CopyFrom(const Expression_Literal& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_Literal::IsInitialized() const { + return true; +} + +void Expression_Literal::InternalSwap(Expression_Literal* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(literal_type_, other->literal_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[8]); +} + +// =================================================================== + +class Expression_ScalarFunction::_Internal { + public: + static const ::io::substrait::Extensions_FunctionId& id(const Expression_ScalarFunction* msg); + static const ::io::substrait::Type& output_type(const Expression_ScalarFunction* msg); +}; + +const ::io::substrait::Extensions_FunctionId& +Expression_ScalarFunction::_Internal::id(const Expression_ScalarFunction* msg) { + return *msg->id_; +} +const ::io::substrait::Type& +Expression_ScalarFunction::_Internal::output_type(const Expression_ScalarFunction* msg) { + return *msg->output_type_; +} +void Expression_ScalarFunction::clear_id() { + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; +} +void Expression_ScalarFunction::clear_output_type() { + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; +} +Expression_ScalarFunction::Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + args_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ScalarFunction) +} +Expression_ScalarFunction::Expression_ScalarFunction(const Expression_ScalarFunction& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + args_(from.args_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_id()) { + id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); + } else { + id_ = nullptr; + } + if (from._internal_has_output_type()) { + output_type_ = new ::io::substrait::Type(*from.output_type_); + } else { + output_type_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ScalarFunction) +} + +void Expression_ScalarFunction::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&output_type_) - + reinterpret_cast(&id_)) + sizeof(output_type_)); +} + +Expression_ScalarFunction::~Expression_ScalarFunction() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.ScalarFunction) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_ScalarFunction::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete id_; + if (this != internal_default_instance()) delete output_type_; +} + +void Expression_ScalarFunction::ArenaDtor(void* object) { + Expression_ScalarFunction* _this = reinterpret_cast< Expression_ScalarFunction* >(object); + (void)_this; +} +void Expression_ScalarFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_ScalarFunction::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_ScalarFunction::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ScalarFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + args_.Clear(); + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Extensions.FunctionId id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression args = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_args(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Type output_type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_ScalarFunction::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ScalarFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::id(this), target, stream); + } + + // repeated .io.substrait.Expression args = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_args_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_args(i), target, stream); + } + + // .io.substrait.Type output_type = 3; + if (this->has_output_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::output_type(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ScalarFunction) + return target; +} + +size_t Expression_ScalarFunction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ScalarFunction) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression args = 2; + total_size += 1UL * this->_internal_args_size(); + for (const auto& msg : this->args_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *id_); + } + + // .io.substrait.Type output_type = 3; + if (this->has_output_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *output_type_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_ScalarFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ScalarFunction) + GOOGLE_DCHECK_NE(&from, this); + const Expression_ScalarFunction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ScalarFunction) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ScalarFunction) + MergeFrom(*source); + } +} + +void Expression_ScalarFunction::MergeFrom(const Expression_ScalarFunction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ScalarFunction) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + args_.MergeFrom(from.args_); + if (from.has_id()) { + _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); + } + if (from.has_output_type()) { + _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + } +} + +void Expression_ScalarFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ScalarFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_ScalarFunction::CopyFrom(const Expression_ScalarFunction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ScalarFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_ScalarFunction::IsInitialized() const { + return true; +} + +void Expression_ScalarFunction::InternalSwap(Expression_ScalarFunction* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + args_.InternalSwap(&other->args_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, output_type_) + + sizeof(Expression_ScalarFunction::output_type_) + - PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, id_)>( + reinterpret_cast(&id_), + reinterpret_cast(&other->id_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_ScalarFunction::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[9]); +} + +// =================================================================== + +class Expression_AggregateFunction::_Internal { + public: + static const ::io::substrait::Extensions_FunctionId& id(const Expression_AggregateFunction* msg); + static const ::io::substrait::Type& output_type(const Expression_AggregateFunction* msg); +}; + +const ::io::substrait::Extensions_FunctionId& +Expression_AggregateFunction::_Internal::id(const Expression_AggregateFunction* msg) { + return *msg->id_; +} +const ::io::substrait::Type& +Expression_AggregateFunction::_Internal::output_type(const Expression_AggregateFunction* msg) { + return *msg->output_type_; +} +void Expression_AggregateFunction::clear_id() { + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; +} +void Expression_AggregateFunction::clear_output_type() { + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; +} +Expression_AggregateFunction::Expression_AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + args_(arena), + sorts_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.AggregateFunction) +} +Expression_AggregateFunction::Expression_AggregateFunction(const Expression_AggregateFunction& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + args_(from.args_), + sorts_(from.sorts_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_id()) { + id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); + } else { + id_ = nullptr; + } + if (from._internal_has_output_type()) { + output_type_ = new ::io::substrait::Type(*from.output_type_); + } else { + output_type_ = nullptr; + } + phase_ = from.phase_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.AggregateFunction) +} + +void Expression_AggregateFunction::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&phase_) - + reinterpret_cast(&id_)) + sizeof(phase_)); +} + +Expression_AggregateFunction::~Expression_AggregateFunction() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.AggregateFunction) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_AggregateFunction::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete id_; + if (this != internal_default_instance()) delete output_type_; +} + +void Expression_AggregateFunction::ArenaDtor(void* object) { + Expression_AggregateFunction* _this = reinterpret_cast< Expression_AggregateFunction* >(object); + (void)_this; +} +void Expression_AggregateFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_AggregateFunction::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_AggregateFunction::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.AggregateFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + args_.Clear(); + sorts_.Clear(); + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; + phase_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Extensions.FunctionId id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression args = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_args(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression.SortField sorts = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_sorts(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.AggregationPhase phase = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_phase(static_cast<::io::substrait::Expression_AggregationPhase>(val)); + } else goto handle_unusual; + continue; + // .io.substrait.Type output_type = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_AggregateFunction::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.AggregateFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::id(this), target, stream); + } + + // repeated .io.substrait.Expression args = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_args_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_args(i), target, stream); + } + + // repeated .io.substrait.Expression.SortField sorts = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_sorts_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_sorts(i), target, stream); + } + + // .io.substrait.Expression.AggregationPhase phase = 4; + if (this->phase() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_phase(), target); + } + + // .io.substrait.Type output_type = 5; + if (this->has_output_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::output_type(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.AggregateFunction) + return target; +} + +size_t Expression_AggregateFunction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.AggregateFunction) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression args = 2; + total_size += 1UL * this->_internal_args_size(); + for (const auto& msg : this->args_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .io.substrait.Expression.SortField sorts = 3; + total_size += 1UL * this->_internal_sorts_size(); + for (const auto& msg : this->sorts_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *id_); + } + + // .io.substrait.Type output_type = 5; + if (this->has_output_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *output_type_); + } + + // .io.substrait.Expression.AggregationPhase phase = 4; + if (this->phase() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_AggregateFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.AggregateFunction) + GOOGLE_DCHECK_NE(&from, this); + const Expression_AggregateFunction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.AggregateFunction) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.AggregateFunction) + MergeFrom(*source); + } +} + +void Expression_AggregateFunction::MergeFrom(const Expression_AggregateFunction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.AggregateFunction) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + args_.MergeFrom(from.args_); + sorts_.MergeFrom(from.sorts_); + if (from.has_id()) { + _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); + } + if (from.has_output_type()) { + _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + } + if (from.phase() != 0) { + _internal_set_phase(from._internal_phase()); + } +} + +void Expression_AggregateFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.AggregateFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_AggregateFunction::CopyFrom(const Expression_AggregateFunction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.AggregateFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_AggregateFunction::IsInitialized() const { + return true; +} + +void Expression_AggregateFunction::InternalSwap(Expression_AggregateFunction* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + args_.InternalSwap(&other->args_); + sorts_.InternalSwap(&other->sorts_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_AggregateFunction, phase_) + + sizeof(Expression_AggregateFunction::phase_) + - PROTOBUF_FIELD_OFFSET(Expression_AggregateFunction, id_)>( + reinterpret_cast(&id_), + reinterpret_cast(&other->id_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_AggregateFunction::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[10]); +} + +// =================================================================== + +class Expression_WindowFunction_Bound_Preceding::_Internal { + public: +}; + +Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound.Preceding) +} +Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + offset_ = from.offset_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound.Preceding) +} + +void Expression_WindowFunction_Bound_Preceding::SharedCtor() { +offset_ = PROTOBUF_LONGLONG(0); +} + +Expression_WindowFunction_Bound_Preceding::~Expression_WindowFunction_Bound_Preceding() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound.Preceding) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_WindowFunction_Bound_Preceding::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_WindowFunction_Bound_Preceding::ArenaDtor(void* object) { + Expression_WindowFunction_Bound_Preceding* _this = reinterpret_cast< Expression_WindowFunction_Bound_Preceding* >(object); + (void)_this; +} +void Expression_WindowFunction_Bound_Preceding::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_WindowFunction_Bound_Preceding::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_WindowFunction_Bound_Preceding::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + offset_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_WindowFunction_Bound_Preceding::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int64 offset = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Preceding::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 offset = 1; + if (this->offset() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound.Preceding) + return target; +} + +size_t Expression_WindowFunction_Bound_Preceding::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 offset = 1; + if (this->offset() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_offset()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_WindowFunction_Bound_Preceding::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + GOOGLE_DCHECK_NE(&from, this); + const Expression_WindowFunction_Bound_Preceding* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction.Bound.Preceding) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction.Bound.Preceding) + MergeFrom(*source); + } +} + +void Expression_WindowFunction_Bound_Preceding::MergeFrom(const Expression_WindowFunction_Bound_Preceding& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.offset() != 0) { + _internal_set_offset(from._internal_offset()); + } +} + +void Expression_WindowFunction_Bound_Preceding::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_WindowFunction_Bound_Preceding::CopyFrom(const Expression_WindowFunction_Bound_Preceding& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_WindowFunction_Bound_Preceding::IsInitialized() const { + return true; +} + +void Expression_WindowFunction_Bound_Preceding::InternalSwap(Expression_WindowFunction_Bound_Preceding* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(offset_, other->offset_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Preceding::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[11]); +} + +// =================================================================== + +class Expression_WindowFunction_Bound_Following::_Internal { + public: +}; + +Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound.Following) +} +Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(const Expression_WindowFunction_Bound_Following& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + offset_ = from.offset_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound.Following) +} + +void Expression_WindowFunction_Bound_Following::SharedCtor() { +offset_ = PROTOBUF_LONGLONG(0); +} + +Expression_WindowFunction_Bound_Following::~Expression_WindowFunction_Bound_Following() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound.Following) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_WindowFunction_Bound_Following::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_WindowFunction_Bound_Following::ArenaDtor(void* object) { + Expression_WindowFunction_Bound_Following* _this = reinterpret_cast< Expression_WindowFunction_Bound_Following* >(object); + (void)_this; +} +void Expression_WindowFunction_Bound_Following::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_WindowFunction_Bound_Following::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_WindowFunction_Bound_Following::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound.Following) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + offset_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_WindowFunction_Bound_Following::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int64 offset = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Following::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound.Following) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 offset = 1; + if (this->offset() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound.Following) + return target; +} + +size_t Expression_WindowFunction_Bound_Following::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound.Following) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 offset = 1; + if (this->offset() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_offset()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_WindowFunction_Bound_Following::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Following) + GOOGLE_DCHECK_NE(&from, this); + const Expression_WindowFunction_Bound_Following* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction.Bound.Following) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction.Bound.Following) + MergeFrom(*source); + } +} + +void Expression_WindowFunction_Bound_Following::MergeFrom(const Expression_WindowFunction_Bound_Following& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Following) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.offset() != 0) { + _internal_set_offset(from._internal_offset()); + } +} + +void Expression_WindowFunction_Bound_Following::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Following) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_WindowFunction_Bound_Following::CopyFrom(const Expression_WindowFunction_Bound_Following& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Following) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_WindowFunction_Bound_Following::IsInitialized() const { + return true; +} + +void Expression_WindowFunction_Bound_Following::InternalSwap(Expression_WindowFunction_Bound_Following* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(offset_, other->offset_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Following::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[12]); +} + +// =================================================================== + +class Expression_WindowFunction_Bound_CurrentRow::_Internal { + public: +}; + +Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound.CurrentRow) +} +Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(const Expression_WindowFunction_Bound_CurrentRow& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound.CurrentRow) +} + +void Expression_WindowFunction_Bound_CurrentRow::SharedCtor() { +} + +Expression_WindowFunction_Bound_CurrentRow::~Expression_WindowFunction_Bound_CurrentRow() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_WindowFunction_Bound_CurrentRow::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_WindowFunction_Bound_CurrentRow::ArenaDtor(void* object) { + Expression_WindowFunction_Bound_CurrentRow* _this = reinterpret_cast< Expression_WindowFunction_Bound_CurrentRow* >(object); + (void)_this; +} +void Expression_WindowFunction_Bound_CurrentRow::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_WindowFunction_Bound_CurrentRow::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_WindowFunction_Bound_CurrentRow::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_WindowFunction_Bound_CurrentRow::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_CurrentRow::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + return target; +} + +size_t Expression_WindowFunction_Bound_CurrentRow::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_WindowFunction_Bound_CurrentRow::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + GOOGLE_DCHECK_NE(&from, this); + const Expression_WindowFunction_Bound_CurrentRow* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + MergeFrom(*source); + } +} + +void Expression_WindowFunction_Bound_CurrentRow::MergeFrom(const Expression_WindowFunction_Bound_CurrentRow& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +void Expression_WindowFunction_Bound_CurrentRow::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_WindowFunction_Bound_CurrentRow::CopyFrom(const Expression_WindowFunction_Bound_CurrentRow& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_WindowFunction_Bound_CurrentRow::IsInitialized() const { + return true; +} + +void Expression_WindowFunction_Bound_CurrentRow::InternalSwap(Expression_WindowFunction_Bound_CurrentRow* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_CurrentRow::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[13]); +} + +// =================================================================== + +class Expression_WindowFunction_Bound_Unbounded::_Internal { + public: +}; + +Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound.Unbounded) +} +Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(const Expression_WindowFunction_Bound_Unbounded& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound.Unbounded) +} + +void Expression_WindowFunction_Bound_Unbounded::SharedCtor() { +} + +Expression_WindowFunction_Bound_Unbounded::~Expression_WindowFunction_Bound_Unbounded() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound.Unbounded) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_WindowFunction_Bound_Unbounded::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_WindowFunction_Bound_Unbounded::ArenaDtor(void* object) { + Expression_WindowFunction_Bound_Unbounded* _this = reinterpret_cast< Expression_WindowFunction_Bound_Unbounded* >(object); + (void)_this; +} +void Expression_WindowFunction_Bound_Unbounded::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_WindowFunction_Bound_Unbounded::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_WindowFunction_Bound_Unbounded::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_WindowFunction_Bound_Unbounded::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Unbounded::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound.Unbounded) + return target; +} + +size_t Expression_WindowFunction_Bound_Unbounded::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_WindowFunction_Bound_Unbounded::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) + GOOGLE_DCHECK_NE(&from, this); + const Expression_WindowFunction_Bound_Unbounded* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction.Bound.Unbounded) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction.Bound.Unbounded) + MergeFrom(*source); + } +} + +void Expression_WindowFunction_Bound_Unbounded::MergeFrom(const Expression_WindowFunction_Bound_Unbounded& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +void Expression_WindowFunction_Bound_Unbounded::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_WindowFunction_Bound_Unbounded::CopyFrom(const Expression_WindowFunction_Bound_Unbounded& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_WindowFunction_Bound_Unbounded::IsInitialized() const { + return true; +} + +void Expression_WindowFunction_Bound_Unbounded::InternalSwap(Expression_WindowFunction_Bound_Unbounded* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Unbounded::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[14]); +} + +// =================================================================== + +class Expression_WindowFunction_Bound::_Internal { + public: + static const ::io::substrait::Expression_WindowFunction_Bound_Preceding& preceding(const Expression_WindowFunction_Bound* msg); + static const ::io::substrait::Expression_WindowFunction_Bound_Following& following(const Expression_WindowFunction_Bound* msg); + static const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row(const Expression_WindowFunction_Bound* msg); + static const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded(const Expression_WindowFunction_Bound* msg); +}; + +const ::io::substrait::Expression_WindowFunction_Bound_Preceding& +Expression_WindowFunction_Bound::_Internal::preceding(const Expression_WindowFunction_Bound* msg) { + return *msg->kind_.preceding_; +} +const ::io::substrait::Expression_WindowFunction_Bound_Following& +Expression_WindowFunction_Bound::_Internal::following(const Expression_WindowFunction_Bound* msg) { + return *msg->kind_.following_; +} +const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& +Expression_WindowFunction_Bound::_Internal::current_row(const Expression_WindowFunction_Bound* msg) { + return *msg->kind_.current_row_; +} +const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& +Expression_WindowFunction_Bound::_Internal::unbounded(const Expression_WindowFunction_Bound* msg) { + return *msg->kind_.unbounded_; +} +void Expression_WindowFunction_Bound::set_allocated_preceding(::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (preceding) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(preceding); + if (message_arena != submessage_arena) { + preceding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, preceding, submessage_arena); + } + set_has_preceding(); + kind_.preceding_ = preceding; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.Bound.preceding) +} +void Expression_WindowFunction_Bound::set_allocated_following(::io::substrait::Expression_WindowFunction_Bound_Following* following) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (following) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(following); + if (message_arena != submessage_arena) { + following = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, following, submessage_arena); + } + set_has_following(); + kind_.following_ = following; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.Bound.following) +} +void Expression_WindowFunction_Bound::set_allocated_current_row(::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (current_row) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(current_row); + if (message_arena != submessage_arena) { + current_row = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, current_row, submessage_arena); + } + set_has_current_row(); + kind_.current_row_ = current_row; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.Bound.current_row) +} +void Expression_WindowFunction_Bound::set_allocated_unbounded(::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (unbounded) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(unbounded); + if (message_arena != submessage_arena) { + unbounded = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, unbounded, submessage_arena); + } + set_has_unbounded(); + kind_.unbounded_ = unbounded; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.Bound.unbounded) +} +Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound) +} +Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(const Expression_WindowFunction_Bound& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_kind(); + switch (from.kind_case()) { + case kPreceding: { + _internal_mutable_preceding()->::io::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding()); + break; + } + case kFollowing: { + _internal_mutable_following()->::io::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following()); + break; + } + case kCurrentRow: { + _internal_mutable_current_row()->::io::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row()); + break; + } + case kUnbounded: { + _internal_mutable_unbounded()->::io::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded()); + break; + } + case KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound) +} + +void Expression_WindowFunction_Bound::SharedCtor() { +clear_has_kind(); +} + +Expression_WindowFunction_Bound::~Expression_WindowFunction_Bound() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_WindowFunction_Bound::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_kind()) { + clear_kind(); + } +} + +void Expression_WindowFunction_Bound::ArenaDtor(void* object) { + Expression_WindowFunction_Bound* _this = reinterpret_cast< Expression_WindowFunction_Bound* >(object); + (void)_this; +} +void Expression_WindowFunction_Bound::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_WindowFunction_Bound::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_WindowFunction_Bound::clear_kind() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.WindowFunction.Bound) + switch (kind_case()) { + case kPreceding: { + if (GetArena() == nullptr) { + delete kind_.preceding_; + } + break; + } + case kFollowing: { + if (GetArena() == nullptr) { + delete kind_.following_; + } + break; + } + case kCurrentRow: { + if (GetArena() == nullptr) { + delete kind_.current_row_; + } + break; + } + case kUnbounded: { + if (GetArena() == nullptr) { + delete kind_.unbounded_; + } + break; + } + case KIND_NOT_SET: { + break; + } + } + _oneof_case_[0] = KIND_NOT_SET; +} + + +void Expression_WindowFunction_Bound::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_kind(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_WindowFunction_Bound::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_preceding(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.WindowFunction.Bound.Following following = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_following(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_current_row(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_unbounded(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; + if (_internal_has_preceding()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::preceding(this), target, stream); + } + + // .io.substrait.Expression.WindowFunction.Bound.Following following = 2; + if (_internal_has_following()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::following(this), target, stream); + } + + // .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; + if (_internal_has_current_row()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::current_row(this), target, stream); + } + + // .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; + if (_internal_has_unbounded()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::unbounded(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound) + return target; +} + +size_t Expression_WindowFunction_Bound::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (kind_case()) { + // .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; + case kPreceding: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.preceding_); + break; + } + // .io.substrait.Expression.WindowFunction.Bound.Following following = 2; + case kFollowing: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.following_); + break; + } + // .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; + case kCurrentRow: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.current_row_); + break; + } + // .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; + case kUnbounded: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.unbounded_); + break; + } + case KIND_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_WindowFunction_Bound::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction.Bound) + GOOGLE_DCHECK_NE(&from, this); + const Expression_WindowFunction_Bound* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction.Bound) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction.Bound) + MergeFrom(*source); + } +} + +void Expression_WindowFunction_Bound::MergeFrom(const Expression_WindowFunction_Bound& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction.Bound) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.kind_case()) { + case kPreceding: { + _internal_mutable_preceding()->::io::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding()); + break; + } + case kFollowing: { + _internal_mutable_following()->::io::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following()); + break; + } + case kCurrentRow: { + _internal_mutable_current_row()->::io::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row()); + break; + } + case kUnbounded: { + _internal_mutable_unbounded()->::io::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded()); + break; + } + case KIND_NOT_SET: { + break; + } + } +} + +void Expression_WindowFunction_Bound::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction.Bound) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_WindowFunction_Bound::CopyFrom(const Expression_WindowFunction_Bound& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction.Bound) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_WindowFunction_Bound::IsInitialized() const { + return true; +} + +void Expression_WindowFunction_Bound::InternalSwap(Expression_WindowFunction_Bound* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(kind_, other->kind_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[15]); +} + +// =================================================================== + +class Expression_WindowFunction::_Internal { + public: + static const ::io::substrait::Extensions_FunctionId& id(const Expression_WindowFunction* msg); + static const ::io::substrait::Expression_WindowFunction_Bound& upper_bound(const Expression_WindowFunction* msg); + static const ::io::substrait::Expression_WindowFunction_Bound& lower_bound(const Expression_WindowFunction* msg); + static const ::io::substrait::Type& output_type(const Expression_WindowFunction* msg); +}; + +const ::io::substrait::Extensions_FunctionId& +Expression_WindowFunction::_Internal::id(const Expression_WindowFunction* msg) { + return *msg->id_; +} +const ::io::substrait::Expression_WindowFunction_Bound& +Expression_WindowFunction::_Internal::upper_bound(const Expression_WindowFunction* msg) { + return *msg->upper_bound_; +} +const ::io::substrait::Expression_WindowFunction_Bound& +Expression_WindowFunction::_Internal::lower_bound(const Expression_WindowFunction* msg) { + return *msg->lower_bound_; +} +const ::io::substrait::Type& +Expression_WindowFunction::_Internal::output_type(const Expression_WindowFunction* msg) { + return *msg->output_type_; +} +void Expression_WindowFunction::clear_id() { + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; +} +void Expression_WindowFunction::clear_output_type() { + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; +} +Expression_WindowFunction::Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + partitions_(arena), + sorts_(arena), + args_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction) +} +Expression_WindowFunction::Expression_WindowFunction(const Expression_WindowFunction& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + partitions_(from.partitions_), + sorts_(from.sorts_), + args_(from.args_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_id()) { + id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); + } else { + id_ = nullptr; + } + if (from._internal_has_upper_bound()) { + upper_bound_ = new ::io::substrait::Expression_WindowFunction_Bound(*from.upper_bound_); + } else { + upper_bound_ = nullptr; + } + if (from._internal_has_lower_bound()) { + lower_bound_ = new ::io::substrait::Expression_WindowFunction_Bound(*from.lower_bound_); + } else { + lower_bound_ = nullptr; + } + if (from._internal_has_output_type()) { + output_type_ = new ::io::substrait::Type(*from.output_type_); + } else { + output_type_ = nullptr; + } + phase_ = from.phase_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction) +} + +void Expression_WindowFunction::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&phase_) - + reinterpret_cast(&id_)) + sizeof(phase_)); +} + +Expression_WindowFunction::~Expression_WindowFunction() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_WindowFunction::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete id_; + if (this != internal_default_instance()) delete upper_bound_; + if (this != internal_default_instance()) delete lower_bound_; + if (this != internal_default_instance()) delete output_type_; +} + +void Expression_WindowFunction::ArenaDtor(void* object) { + Expression_WindowFunction* _this = reinterpret_cast< Expression_WindowFunction* >(object); + (void)_this; +} +void Expression_WindowFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_WindowFunction::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_WindowFunction::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + partitions_.Clear(); + sorts_.Clear(); + args_.Clear(); + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; + if (GetArena() == nullptr && upper_bound_ != nullptr) { + delete upper_bound_; + } + upper_bound_ = nullptr; + if (GetArena() == nullptr && lower_bound_ != nullptr) { + delete lower_bound_; + } + lower_bound_ = nullptr; + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; + phase_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Extensions.FunctionId id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression partitions = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_partitions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression.SortField sorts = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_sorts(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_upper_bound(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_lower_bound(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.AggregationPhase phase = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_phase(static_cast<::io::substrait::Expression_AggregationPhase>(val)); + } else goto handle_unusual; + continue; + // .io.substrait.Type output_type = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression args = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_args(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::id(this), target, stream); + } + + // repeated .io.substrait.Expression partitions = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_partitions_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_partitions(i), target, stream); + } + + // repeated .io.substrait.Expression.SortField sorts = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_sorts_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_sorts(i), target, stream); + } + + // .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; + if (this->has_upper_bound()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::upper_bound(this), target, stream); + } + + // .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; + if (this->has_lower_bound()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::lower_bound(this), target, stream); + } + + // .io.substrait.Expression.AggregationPhase phase = 6; + if (this->phase() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 6, this->_internal_phase(), target); + } + + // .io.substrait.Type output_type = 7; + if (this->has_output_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::output_type(this), target, stream); + } + + // repeated .io.substrait.Expression args = 8; + for (unsigned int i = 0, + n = static_cast(this->_internal_args_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(8, this->_internal_args(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction) + return target; +} + +size_t Expression_WindowFunction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression partitions = 2; + total_size += 1UL * this->_internal_partitions_size(); + for (const auto& msg : this->partitions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .io.substrait.Expression.SortField sorts = 3; + total_size += 1UL * this->_internal_sorts_size(); + for (const auto& msg : this->sorts_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .io.substrait.Expression args = 8; + total_size += 1UL * this->_internal_args_size(); + for (const auto& msg : this->args_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *id_); + } + + // .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; + if (this->has_upper_bound()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *upper_bound_); + } + + // .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; + if (this->has_lower_bound()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *lower_bound_); + } + + // .io.substrait.Type output_type = 7; + if (this->has_output_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *output_type_); + } + + // .io.substrait.Expression.AggregationPhase phase = 6; + if (this->phase() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_WindowFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction) + GOOGLE_DCHECK_NE(&from, this); + const Expression_WindowFunction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction) + MergeFrom(*source); + } +} + +void Expression_WindowFunction::MergeFrom(const Expression_WindowFunction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + partitions_.MergeFrom(from.partitions_); + sorts_.MergeFrom(from.sorts_); + args_.MergeFrom(from.args_); + if (from.has_id()) { + _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); + } + if (from.has_upper_bound()) { + _internal_mutable_upper_bound()->::io::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_upper_bound()); + } + if (from.has_lower_bound()) { + _internal_mutable_lower_bound()->::io::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_lower_bound()); + } + if (from.has_output_type()) { + _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + } + if (from.phase() != 0) { + _internal_set_phase(from._internal_phase()); + } +} + +void Expression_WindowFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_WindowFunction::CopyFrom(const Expression_WindowFunction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_WindowFunction::IsInitialized() const { + return true; +} + +void Expression_WindowFunction::InternalSwap(Expression_WindowFunction* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + partitions_.InternalSwap(&other->partitions_); + sorts_.InternalSwap(&other->sorts_); + args_.InternalSwap(&other->args_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, phase_) + + sizeof(Expression_WindowFunction::phase_) + - PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, id_)>( + reinterpret_cast(&id_), + reinterpret_cast(&other->id_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[16]); +} + +// =================================================================== + +class Expression_SortField::_Internal { + public: + static const ::io::substrait::Expression& expr(const Expression_SortField* msg); + static const ::io::substrait::Extensions_FunctionId& comparison_function(const Expression_SortField* msg); +}; + +const ::io::substrait::Expression& +Expression_SortField::_Internal::expr(const Expression_SortField* msg) { + return *msg->expr_; +} +const ::io::substrait::Extensions_FunctionId& +Expression_SortField::_Internal::comparison_function(const Expression_SortField* msg) { + return *msg->sort_kind_.comparison_function_; +} +void Expression_SortField::set_allocated_comparison_function(::io::substrait::Extensions_FunctionId* comparison_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_sort_kind(); + if (comparison_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(comparison_function)->GetArena(); + if (message_arena != submessage_arena) { + comparison_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, comparison_function, submessage_arena); + } + set_has_comparison_function(); + sort_kind_.comparison_function_ = comparison_function; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SortField.comparison_function) +} +void Expression_SortField::clear_comparison_function() { + if (_internal_has_comparison_function()) { + if (GetArena() == nullptr) { + delete sort_kind_.comparison_function_; + } + clear_has_sort_kind(); + } +} +Expression_SortField::Expression_SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.SortField) +} +Expression_SortField::Expression_SortField(const Expression_SortField& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_expr()) { + expr_ = new ::io::substrait::Expression(*from.expr_); + } else { + expr_ = nullptr; + } + clear_has_sort_kind(); + switch (from.sort_kind_case()) { + case kDirection: { + _internal_set_direction(from._internal_direction()); + break; + } + case kComparisonFunction: { + _internal_mutable_comparison_function()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_comparison_function()); + break; + } + case SORT_KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.SortField) +} + +void Expression_SortField::SharedCtor() { +expr_ = nullptr; +clear_has_sort_kind(); +} + +Expression_SortField::~Expression_SortField() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.SortField) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_SortField::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete expr_; + if (has_sort_kind()) { + clear_sort_kind(); + } +} + +void Expression_SortField::ArenaDtor(void* object) { + Expression_SortField* _this = reinterpret_cast< Expression_SortField* >(object); + (void)_this; +} +void Expression_SortField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_SortField::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_SortField::clear_sort_kind() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.SortField) + switch (sort_kind_case()) { + case kDirection: { + // No need to clear + break; + } + case kComparisonFunction: { + if (GetArena() == nullptr) { + delete sort_kind_.comparison_function_; + } + break; + } + case SORT_KIND_NOT_SET: { + break; + } + } + _oneof_case_[0] = SORT_KIND_NOT_SET; +} + + +void Expression_SortField::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.SortField) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && expr_ != nullptr) { + delete expr_; + } + expr_ = nullptr; + clear_sort_kind(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_SortField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression expr = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_expr(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.SortField.SortDirection direction = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_direction(static_cast<::io::substrait::Expression_SortField_SortDirection>(val)); + } else goto handle_unusual; + continue; + // .io.substrait.Extensions.FunctionId comparison_function = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_comparison_function(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_SortField::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.SortField) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression expr = 1; + if (this->has_expr()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::expr(this), target, stream); + } + + // .io.substrait.Expression.SortField.SortDirection direction = 2; + if (_internal_has_direction()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_direction(), target); + } + + // .io.substrait.Extensions.FunctionId comparison_function = 3; + if (_internal_has_comparison_function()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::comparison_function(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.SortField) + return target; +} + +size_t Expression_SortField::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.SortField) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression expr = 1; + if (this->has_expr()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *expr_); + } + + switch (sort_kind_case()) { + // .io.substrait.Expression.SortField.SortDirection direction = 2; + case kDirection: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_direction()); + break; + } + // .io.substrait.Extensions.FunctionId comparison_function = 3; + case kComparisonFunction: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *sort_kind_.comparison_function_); + break; + } + case SORT_KIND_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_SortField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.SortField) + GOOGLE_DCHECK_NE(&from, this); + const Expression_SortField* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.SortField) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.SortField) + MergeFrom(*source); + } +} + +void Expression_SortField::MergeFrom(const Expression_SortField& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.SortField) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_expr()) { + _internal_mutable_expr()->::io::substrait::Expression::MergeFrom(from._internal_expr()); + } + switch (from.sort_kind_case()) { + case kDirection: { + _internal_set_direction(from._internal_direction()); + break; + } + case kComparisonFunction: { + _internal_mutable_comparison_function()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_comparison_function()); + break; + } + case SORT_KIND_NOT_SET: { + break; + } + } +} + +void Expression_SortField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.SortField) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_SortField::CopyFrom(const Expression_SortField& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.SortField) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_SortField::IsInitialized() const { + return true; +} + +void Expression_SortField::InternalSwap(Expression_SortField* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(expr_, other->expr_); + swap(sort_kind_, other->sort_kind_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_SortField::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[17]); +} + +// =================================================================== + +class Expression_IfThen_IfClause::_Internal { + public: + static const ::io::substrait::Expression& if_(const Expression_IfThen_IfClause* msg); + static const ::io::substrait::Expression& then(const Expression_IfThen_IfClause* msg); +}; + +const ::io::substrait::Expression& +Expression_IfThen_IfClause::_Internal::if_(const Expression_IfThen_IfClause* msg) { + return *msg->if__; +} +const ::io::substrait::Expression& +Expression_IfThen_IfClause::_Internal::then(const Expression_IfThen_IfClause* msg) { + return *msg->then_; +} +Expression_IfThen_IfClause::Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.IfThen.IfClause) +} +Expression_IfThen_IfClause::Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_if_()) { + if__ = new ::io::substrait::Expression(*from.if__); + } else { + if__ = nullptr; + } + if (from._internal_has_then()) { + then_ = new ::io::substrait::Expression(*from.then_); + } else { + then_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.IfThen.IfClause) +} + +void Expression_IfThen_IfClause::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&if__) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&then_) - + reinterpret_cast(&if__)) + sizeof(then_)); +} + +Expression_IfThen_IfClause::~Expression_IfThen_IfClause() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.IfThen.IfClause) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_IfThen_IfClause::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete if__; + if (this != internal_default_instance()) delete then_; +} + +void Expression_IfThen_IfClause::ArenaDtor(void* object) { + Expression_IfThen_IfClause* _this = reinterpret_cast< Expression_IfThen_IfClause* >(object); + (void)_this; +} +void Expression_IfThen_IfClause::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_IfThen_IfClause::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_IfThen_IfClause::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.IfThen.IfClause) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && if__ != nullptr) { + delete if__; + } + if__ = nullptr; + if (GetArena() == nullptr && then_ != nullptr) { + delete then_; + } + then_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_IfThen_IfClause::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression if = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression then = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_then(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen_IfClause::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.IfThen.IfClause) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression if = 1; + if (this->has_if_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::if_(this), target, stream); + } + + // .io.substrait.Expression then = 2; + if (this->has_then()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::then(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.IfThen.IfClause) + return target; +} + +size_t Expression_IfThen_IfClause::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.IfThen.IfClause) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression if = 1; + if (this->has_if_()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *if__); + } + + // .io.substrait.Expression then = 2; + if (this->has_then()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *then_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_IfThen_IfClause::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.IfThen.IfClause) + GOOGLE_DCHECK_NE(&from, this); + const Expression_IfThen_IfClause* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.IfThen.IfClause) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.IfThen.IfClause) + MergeFrom(*source); + } +} + +void Expression_IfThen_IfClause::MergeFrom(const Expression_IfThen_IfClause& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.IfThen.IfClause) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_if_()) { + _internal_mutable_if_()->::io::substrait::Expression::MergeFrom(from._internal_if_()); + } + if (from.has_then()) { + _internal_mutable_then()->::io::substrait::Expression::MergeFrom(from._internal_then()); + } +} + +void Expression_IfThen_IfClause::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.IfThen.IfClause) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_IfThen_IfClause::CopyFrom(const Expression_IfThen_IfClause& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.IfThen.IfClause) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_IfThen_IfClause::IsInitialized() const { + return true; +} + +void Expression_IfThen_IfClause::InternalSwap(Expression_IfThen_IfClause* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, then_) + + sizeof(Expression_IfThen_IfClause::then_) + - PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, if__)>( + reinterpret_cast(&if__), + reinterpret_cast(&other->if__)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen_IfClause::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[18]); +} + +// =================================================================== + +class Expression_IfThen::_Internal { + public: + static const ::io::substrait::Expression& else_(const Expression_IfThen* msg); +}; + +const ::io::substrait::Expression& +Expression_IfThen::_Internal::else_(const Expression_IfThen* msg) { + return *msg->else__; +} +Expression_IfThen::Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + ifs_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.IfThen) +} +Expression_IfThen::Expression_IfThen(const Expression_IfThen& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + ifs_(from.ifs_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_else_()) { + else__ = new ::io::substrait::Expression(*from.else__); + } else { + else__ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.IfThen) +} + +void Expression_IfThen::SharedCtor() { +else__ = nullptr; +} + +Expression_IfThen::~Expression_IfThen() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.IfThen) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_IfThen::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete else__; +} + +void Expression_IfThen::ArenaDtor(void* object) { + Expression_IfThen* _this = reinterpret_cast< Expression_IfThen* >(object); + (void)_this; +} +void Expression_IfThen::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_IfThen::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_IfThen::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.IfThen) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ifs_.Clear(); + if (GetArena() == nullptr && else__ != nullptr) { + delete else__; + } + else__ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_ifs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Expression else = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.IfThen) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_ifs_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_ifs(i), target, stream); + } + + // .io.substrait.Expression else = 2; + if (this->has_else_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::else_(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.IfThen) + return target; +} + +size_t Expression_IfThen::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.IfThen) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + total_size += 1UL * this->_internal_ifs_size(); + for (const auto& msg : this->ifs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Expression else = 2; + if (this->has_else_()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *else__); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_IfThen::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.IfThen) + GOOGLE_DCHECK_NE(&from, this); + const Expression_IfThen* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.IfThen) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.IfThen) + MergeFrom(*source); + } +} + +void Expression_IfThen::MergeFrom(const Expression_IfThen& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.IfThen) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + ifs_.MergeFrom(from.ifs_); + if (from.has_else_()) { + _internal_mutable_else_()->::io::substrait::Expression::MergeFrom(from._internal_else_()); + } +} + +void Expression_IfThen::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.IfThen) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_IfThen::CopyFrom(const Expression_IfThen& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.IfThen) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_IfThen::IsInitialized() const { + return true; +} + +void Expression_IfThen::InternalSwap(Expression_IfThen* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ifs_.InternalSwap(&other->ifs_); + swap(else__, other->else__); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[19]); +} + +// =================================================================== + +class Expression_SwitchExpression_IfValue::_Internal { + public: + static const ::io::substrait::Expression& if_(const Expression_SwitchExpression_IfValue* msg); + static const ::io::substrait::Expression& then(const Expression_SwitchExpression_IfValue* msg); +}; + +const ::io::substrait::Expression& +Expression_SwitchExpression_IfValue::_Internal::if_(const Expression_SwitchExpression_IfValue* msg) { + return *msg->if__; +} +const ::io::substrait::Expression& +Expression_SwitchExpression_IfValue::_Internal::then(const Expression_SwitchExpression_IfValue* msg) { + return *msg->then_; +} +Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.SwitchExpression.IfValue) +} +Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(const Expression_SwitchExpression_IfValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_if_()) { + if__ = new ::io::substrait::Expression(*from.if__); + } else { + if__ = nullptr; + } + if (from._internal_has_then()) { + then_ = new ::io::substrait::Expression(*from.then_); + } else { + then_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.SwitchExpression.IfValue) +} + +void Expression_SwitchExpression_IfValue::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&if__) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&then_) - + reinterpret_cast(&if__)) + sizeof(then_)); +} + +Expression_SwitchExpression_IfValue::~Expression_SwitchExpression_IfValue() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.SwitchExpression.IfValue) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_SwitchExpression_IfValue::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete if__; + if (this != internal_default_instance()) delete then_; +} + +void Expression_SwitchExpression_IfValue::ArenaDtor(void* object) { + Expression_SwitchExpression_IfValue* _this = reinterpret_cast< Expression_SwitchExpression_IfValue* >(object); + (void)_this; +} +void Expression_SwitchExpression_IfValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_SwitchExpression_IfValue::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_SwitchExpression_IfValue::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.SwitchExpression.IfValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && if__ != nullptr) { + delete if__; + } + if__ = nullptr; + if (GetArena() == nullptr && then_ != nullptr) { + delete then_; + } + then_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_SwitchExpression_IfValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression if = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression then = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_then(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression_IfValue::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.SwitchExpression.IfValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression if = 1; + if (this->has_if_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::if_(this), target, stream); + } + + // .io.substrait.Expression then = 2; + if (this->has_then()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::then(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.SwitchExpression.IfValue) + return target; +} + +size_t Expression_SwitchExpression_IfValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.SwitchExpression.IfValue) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression if = 1; + if (this->has_if_()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *if__); + } + + // .io.substrait.Expression then = 2; + if (this->has_then()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *then_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_SwitchExpression_IfValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.SwitchExpression.IfValue) + GOOGLE_DCHECK_NE(&from, this); + const Expression_SwitchExpression_IfValue* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.SwitchExpression.IfValue) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.SwitchExpression.IfValue) + MergeFrom(*source); + } +} + +void Expression_SwitchExpression_IfValue::MergeFrom(const Expression_SwitchExpression_IfValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.SwitchExpression.IfValue) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_if_()) { + _internal_mutable_if_()->::io::substrait::Expression::MergeFrom(from._internal_if_()); + } + if (from.has_then()) { + _internal_mutable_then()->::io::substrait::Expression::MergeFrom(from._internal_then()); + } +} + +void Expression_SwitchExpression_IfValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.SwitchExpression.IfValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_SwitchExpression_IfValue::CopyFrom(const Expression_SwitchExpression_IfValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.SwitchExpression.IfValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_SwitchExpression_IfValue::IsInitialized() const { + return true; +} + +void Expression_SwitchExpression_IfValue::InternalSwap(Expression_SwitchExpression_IfValue* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_SwitchExpression_IfValue, then_) + + sizeof(Expression_SwitchExpression_IfValue::then_) + - PROTOBUF_FIELD_OFFSET(Expression_SwitchExpression_IfValue, if__)>( + reinterpret_cast(&if__), + reinterpret_cast(&other->if__)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression_IfValue::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[20]); +} + +// =================================================================== + +class Expression_SwitchExpression::_Internal { + public: + static const ::io::substrait::Expression& else_(const Expression_SwitchExpression* msg); +}; + +const ::io::substrait::Expression& +Expression_SwitchExpression::_Internal::else_(const Expression_SwitchExpression* msg) { + return *msg->else__; +} +Expression_SwitchExpression::Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + ifs_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.SwitchExpression) +} +Expression_SwitchExpression::Expression_SwitchExpression(const Expression_SwitchExpression& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + ifs_(from.ifs_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_else_()) { + else__ = new ::io::substrait::Expression(*from.else__); + } else { + else__ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.SwitchExpression) +} + +void Expression_SwitchExpression::SharedCtor() { +else__ = nullptr; +} + +Expression_SwitchExpression::~Expression_SwitchExpression() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.SwitchExpression) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_SwitchExpression::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete else__; +} + +void Expression_SwitchExpression::ArenaDtor(void* object) { + Expression_SwitchExpression* _this = reinterpret_cast< Expression_SwitchExpression* >(object); + (void)_this; +} +void Expression_SwitchExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_SwitchExpression::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_SwitchExpression::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.SwitchExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ifs_.Clear(); + if (GetArena() == nullptr && else__ != nullptr) { + delete else__; + } + else__ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_SwitchExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_ifs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Expression else = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.SwitchExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_ifs_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_ifs(i), target, stream); + } + + // .io.substrait.Expression else = 2; + if (this->has_else_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::else_(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.SwitchExpression) + return target; +} + +size_t Expression_SwitchExpression::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.SwitchExpression) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; + total_size += 1UL * this->_internal_ifs_size(); + for (const auto& msg : this->ifs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Expression else = 2; + if (this->has_else_()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *else__); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_SwitchExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.SwitchExpression) + GOOGLE_DCHECK_NE(&from, this); + const Expression_SwitchExpression* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.SwitchExpression) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.SwitchExpression) + MergeFrom(*source); + } +} + +void Expression_SwitchExpression::MergeFrom(const Expression_SwitchExpression& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.SwitchExpression) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + ifs_.MergeFrom(from.ifs_); + if (from.has_else_()) { + _internal_mutable_else_()->::io::substrait::Expression::MergeFrom(from._internal_else_()); + } +} + +void Expression_SwitchExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.SwitchExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_SwitchExpression::CopyFrom(const Expression_SwitchExpression& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.SwitchExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_SwitchExpression::IsInitialized() const { + return true; +} + +void Expression_SwitchExpression::InternalSwap(Expression_SwitchExpression* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ifs_.InternalSwap(&other->ifs_); + swap(else__, other->else__); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[21]); +} + +// =================================================================== + +class Expression_SingularOrList::_Internal { + public: + static const ::io::substrait::Expression& value(const Expression_SingularOrList* msg); +}; + +const ::io::substrait::Expression& +Expression_SingularOrList::_Internal::value(const Expression_SingularOrList* msg) { + return *msg->value_; +} +Expression_SingularOrList::Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + options_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.SingularOrList) +} +Expression_SingularOrList::Expression_SingularOrList(const Expression_SingularOrList& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + options_(from.options_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_value()) { + value_ = new ::io::substrait::Expression(*from.value_); + } else { + value_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.SingularOrList) +} + +void Expression_SingularOrList::SharedCtor() { +value_ = nullptr; +} + +Expression_SingularOrList::~Expression_SingularOrList() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.SingularOrList) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_SingularOrList::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete value_; +} + +void Expression_SingularOrList::ArenaDtor(void* object) { + Expression_SingularOrList* _this = reinterpret_cast< Expression_SingularOrList* >(object); + (void)_this; +} +void Expression_SingularOrList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_SingularOrList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_SingularOrList::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.SingularOrList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + options_.Clear(); + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_SingularOrList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression options = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_options(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_SingularOrList::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.SingularOrList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression value = 1; + if (this->has_value()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::value(this), target, stream); + } + + // repeated .io.substrait.Expression options = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_options_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_options(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.SingularOrList) + return target; +} + +size_t Expression_SingularOrList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.SingularOrList) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression options = 2; + total_size += 1UL * this->_internal_options_size(); + for (const auto& msg : this->options_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Expression value = 1; + if (this->has_value()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_SingularOrList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.SingularOrList) + GOOGLE_DCHECK_NE(&from, this); + const Expression_SingularOrList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.SingularOrList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.SingularOrList) + MergeFrom(*source); + } +} + +void Expression_SingularOrList::MergeFrom(const Expression_SingularOrList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.SingularOrList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + options_.MergeFrom(from.options_); + if (from.has_value()) { + _internal_mutable_value()->::io::substrait::Expression::MergeFrom(from._internal_value()); + } +} + +void Expression_SingularOrList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.SingularOrList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_SingularOrList::CopyFrom(const Expression_SingularOrList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.SingularOrList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_SingularOrList::IsInitialized() const { + return true; +} + +void Expression_SingularOrList::InternalSwap(Expression_SingularOrList* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + options_.InternalSwap(&other->options_); + swap(value_, other->value_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_SingularOrList::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[22]); +} + +// =================================================================== + +class Expression_MultiOrList_Record::_Internal { + public: +}; + +Expression_MultiOrList_Record::Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + fields_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MultiOrList.Record) +} +Expression_MultiOrList_Record::Expression_MultiOrList_Record(const Expression_MultiOrList_Record& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + fields_(from.fields_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MultiOrList.Record) +} + +void Expression_MultiOrList_Record::SharedCtor() { +} + +Expression_MultiOrList_Record::~Expression_MultiOrList_Record() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MultiOrList.Record) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MultiOrList_Record::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_MultiOrList_Record::ArenaDtor(void* object) { + Expression_MultiOrList_Record* _this = reinterpret_cast< Expression_MultiOrList_Record* >(object); + (void)_this; +} +void Expression_MultiOrList_Record::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MultiOrList_Record::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MultiOrList_Record::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MultiOrList.Record) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + fields_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MultiOrList_Record::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression fields = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_fields(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MultiOrList_Record::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MultiOrList.Record) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression fields = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_fields_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_fields(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MultiOrList.Record) + return target; +} + +size_t Expression_MultiOrList_Record::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MultiOrList.Record) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression fields = 1; + total_size += 1UL * this->_internal_fields_size(); + for (const auto& msg : this->fields_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MultiOrList_Record::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MultiOrList.Record) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MultiOrList_Record* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MultiOrList.Record) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MultiOrList.Record) + MergeFrom(*source); + } +} + +void Expression_MultiOrList_Record::MergeFrom(const Expression_MultiOrList_Record& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MultiOrList.Record) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + fields_.MergeFrom(from.fields_); +} + +void Expression_MultiOrList_Record::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MultiOrList.Record) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MultiOrList_Record::CopyFrom(const Expression_MultiOrList_Record& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MultiOrList.Record) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MultiOrList_Record::IsInitialized() const { + return true; +} + +void Expression_MultiOrList_Record::InternalSwap(Expression_MultiOrList_Record* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + fields_.InternalSwap(&other->fields_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList_Record::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[23]); +} + +// =================================================================== + +class Expression_MultiOrList::_Internal { + public: +}; + +Expression_MultiOrList::Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + value_(arena), + options_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MultiOrList) +} +Expression_MultiOrList::Expression_MultiOrList(const Expression_MultiOrList& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + value_(from.value_), + options_(from.options_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MultiOrList) +} + +void Expression_MultiOrList::SharedCtor() { +} + +Expression_MultiOrList::~Expression_MultiOrList() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MultiOrList) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MultiOrList::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_MultiOrList::ArenaDtor(void* object) { + Expression_MultiOrList* _this = reinterpret_cast< Expression_MultiOrList* >(object); + (void)_this; +} +void Expression_MultiOrList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MultiOrList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MultiOrList::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MultiOrList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + value_.Clear(); + options_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MultiOrList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_value(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression.MultiOrList.Record options = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_options(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MultiOrList::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MultiOrList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression value = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_value_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_value(i), target, stream); + } + + // repeated .io.substrait.Expression.MultiOrList.Record options = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_options_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_options(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MultiOrList) + return target; +} + +size_t Expression_MultiOrList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MultiOrList) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression value = 1; + total_size += 1UL * this->_internal_value_size(); + for (const auto& msg : this->value_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .io.substrait.Expression.MultiOrList.Record options = 2; + total_size += 1UL * this->_internal_options_size(); + for (const auto& msg : this->options_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MultiOrList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MultiOrList) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MultiOrList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MultiOrList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MultiOrList) + MergeFrom(*source); + } +} + +void Expression_MultiOrList::MergeFrom(const Expression_MultiOrList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MultiOrList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + value_.MergeFrom(from.value_); + options_.MergeFrom(from.options_); +} + +void Expression_MultiOrList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MultiOrList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MultiOrList::CopyFrom(const Expression_MultiOrList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MultiOrList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MultiOrList::IsInitialized() const { + return true; +} + +void Expression_MultiOrList::InternalSwap(Expression_MultiOrList* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + value_.InternalSwap(&other->value_); + options_.InternalSwap(&other->options_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[24]); +} + +// =================================================================== + +class Expression_EmbeddedFunction_PythonPickleFunction::_Internal { + public: +}; + +Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + prerequisite_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) +} +Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(const Expression_EmbeddedFunction_PythonPickleFunction& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + prerequisite_(from.prerequisite_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_function().empty()) { + function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_function(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) +} + +void Expression_EmbeddedFunction_PythonPickleFunction::SharedCtor() { +function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Expression_EmbeddedFunction_PythonPickleFunction::~Expression_EmbeddedFunction_PythonPickleFunction() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_EmbeddedFunction_PythonPickleFunction::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + function_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Expression_EmbeddedFunction_PythonPickleFunction::ArenaDtor(void* object) { + Expression_EmbeddedFunction_PythonPickleFunction* _this = reinterpret_cast< Expression_EmbeddedFunction_PythonPickleFunction* >(object); + (void)_this; +} +void Expression_EmbeddedFunction_PythonPickleFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_EmbeddedFunction_PythonPickleFunction::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_EmbeddedFunction_PythonPickleFunction::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + prerequisite_.Clear(); + function_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_EmbeddedFunction_PythonPickleFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // bytes function = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_function(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string prerequisite = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_prerequisite(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction_PythonPickleFunction::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bytes function = 1; + if (this->function().size() > 0) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_function(), target); + } + + // repeated string prerequisite = 2; + for (int i = 0, n = this->_internal_prerequisite_size(); i < n; i++) { + const auto& s = this->_internal_prerequisite(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite"); + target = stream->WriteString(2, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + return target; +} + +size_t Expression_EmbeddedFunction_PythonPickleFunction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string prerequisite = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(prerequisite_.size()); + for (int i = 0, n = prerequisite_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + prerequisite_.Get(i)); + } + + // bytes function = 1; + if (this->function().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_function()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + GOOGLE_DCHECK_NE(&from, this); + const Expression_EmbeddedFunction_PythonPickleFunction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + MergeFrom(*source); + } +} + +void Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + prerequisite_.MergeFrom(from.prerequisite_); + if (from.function().size() > 0) { + _internal_set_function(from._internal_function()); + } +} + +void Expression_EmbeddedFunction_PythonPickleFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_EmbeddedFunction_PythonPickleFunction::CopyFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_EmbeddedFunction_PythonPickleFunction::IsInitialized() const { + return true; +} + +void Expression_EmbeddedFunction_PythonPickleFunction::InternalSwap(Expression_EmbeddedFunction_PythonPickleFunction* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + prerequisite_.InternalSwap(&other->prerequisite_); + function_.Swap(&other->function_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_PythonPickleFunction::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[25]); +} + +// =================================================================== + +class Expression_EmbeddedFunction_WebAssemblyFunction::_Internal { + public: +}; + +Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + prerequisite_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) +} +Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(const Expression_EmbeddedFunction_WebAssemblyFunction& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + prerequisite_(from.prerequisite_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_script().empty()) { + script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_script(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) +} + +void Expression_EmbeddedFunction_WebAssemblyFunction::SharedCtor() { +script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Expression_EmbeddedFunction_WebAssemblyFunction::~Expression_EmbeddedFunction_WebAssemblyFunction() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_EmbeddedFunction_WebAssemblyFunction::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + script_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Expression_EmbeddedFunction_WebAssemblyFunction::ArenaDtor(void* object) { + Expression_EmbeddedFunction_WebAssemblyFunction* _this = reinterpret_cast< Expression_EmbeddedFunction_WebAssemblyFunction* >(object); + (void)_this; +} +void Expression_EmbeddedFunction_WebAssemblyFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_EmbeddedFunction_WebAssemblyFunction::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_EmbeddedFunction_WebAssemblyFunction::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + prerequisite_.Clear(); + script_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // bytes script = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_script(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string prerequisite = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_prerequisite(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // bytes script = 1; + if (this->script().size() > 0) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_script(), target); + } + + // repeated string prerequisite = 2; + for (int i = 0, n = this->_internal_prerequisite_size(); i < n; i++) { + const auto& s = this->_internal_prerequisite(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite"); + target = stream->WriteString(2, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + return target; +} + +size_t Expression_EmbeddedFunction_WebAssemblyFunction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string prerequisite = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(prerequisite_.size()); + for (int i = 0, n = prerequisite_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + prerequisite_.Get(i)); + } + + // bytes script = 1; + if (this->script().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_script()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + GOOGLE_DCHECK_NE(&from, this); + const Expression_EmbeddedFunction_WebAssemblyFunction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + MergeFrom(*source); + } +} + +void Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + prerequisite_.MergeFrom(from.prerequisite_); + if (from.script().size() > 0) { + _internal_set_script(from._internal_script()); + } +} + +void Expression_EmbeddedFunction_WebAssemblyFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_EmbeddedFunction_WebAssemblyFunction::CopyFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_EmbeddedFunction_WebAssemblyFunction::IsInitialized() const { + return true; +} + +void Expression_EmbeddedFunction_WebAssemblyFunction::InternalSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + prerequisite_.InternalSwap(&other->prerequisite_); + script_.Swap(&other->script_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_WebAssemblyFunction::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[26]); +} + +// =================================================================== + +class Expression_EmbeddedFunction::_Internal { + public: + static const ::io::substrait::Type& output_type(const Expression_EmbeddedFunction* msg); + static const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function(const Expression_EmbeddedFunction* msg); + static const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function(const Expression_EmbeddedFunction* msg); +}; + +const ::io::substrait::Type& +Expression_EmbeddedFunction::_Internal::output_type(const Expression_EmbeddedFunction* msg) { + return *msg->output_type_; +} +const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& +Expression_EmbeddedFunction::_Internal::python_pickle_function(const Expression_EmbeddedFunction* msg) { + return *msg->kind_.python_pickle_function_; +} +const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& +Expression_EmbeddedFunction::_Internal::web_assembly_function(const Expression_EmbeddedFunction* msg) { + return *msg->kind_.web_assembly_function_; +} +void Expression_EmbeddedFunction::clear_output_type() { + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; +} +void Expression_EmbeddedFunction::set_allocated_python_pickle_function(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (python_pickle_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(python_pickle_function); + if (message_arena != submessage_arena) { + python_pickle_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, python_pickle_function, submessage_arena); + } + set_has_python_pickle_function(); + kind_.python_pickle_function_ = python_pickle_function; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.python_pickle_function) +} +void Expression_EmbeddedFunction::set_allocated_web_assembly_function(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (web_assembly_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(web_assembly_function); + if (message_arena != submessage_arena) { + web_assembly_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, web_assembly_function, submessage_arena); + } + set_has_web_assembly_function(); + kind_.web_assembly_function_ = web_assembly_function; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.web_assembly_function) +} +Expression_EmbeddedFunction::Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + arguments_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.EmbeddedFunction) +} +Expression_EmbeddedFunction::Expression_EmbeddedFunction(const Expression_EmbeddedFunction& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + arguments_(from.arguments_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_output_type()) { + output_type_ = new ::io::substrait::Type(*from.output_type_); + } else { + output_type_ = nullptr; + } + clear_has_kind(); + switch (from.kind_case()) { + case kPythonPickleFunction: { + _internal_mutable_python_pickle_function()->::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function()); + break; + } + case kWebAssemblyFunction: { + _internal_mutable_web_assembly_function()->::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function()); + break; + } + case KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.EmbeddedFunction) +} + +void Expression_EmbeddedFunction::SharedCtor() { +output_type_ = nullptr; +clear_has_kind(); +} + +Expression_EmbeddedFunction::~Expression_EmbeddedFunction() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.EmbeddedFunction) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_EmbeddedFunction::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete output_type_; + if (has_kind()) { + clear_kind(); + } +} + +void Expression_EmbeddedFunction::ArenaDtor(void* object) { + Expression_EmbeddedFunction* _this = reinterpret_cast< Expression_EmbeddedFunction* >(object); + (void)_this; +} +void Expression_EmbeddedFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_EmbeddedFunction::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_EmbeddedFunction::clear_kind() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.EmbeddedFunction) + switch (kind_case()) { + case kPythonPickleFunction: { + if (GetArena() == nullptr) { + delete kind_.python_pickle_function_; + } + break; + } + case kWebAssemblyFunction: { + if (GetArena() == nullptr) { + delete kind_.web_assembly_function_; + } + break; + } + case KIND_NOT_SET: { + break; + } + } + _oneof_case_[0] = KIND_NOT_SET; +} + + +void Expression_EmbeddedFunction::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.EmbeddedFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + arguments_.Clear(); + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; + clear_kind(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_EmbeddedFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression arguments = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_arguments(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Type output_type = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_python_pickle_function(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_web_assembly_function(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.EmbeddedFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression arguments = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_arguments_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_arguments(i), target, stream); + } + + // .io.substrait.Type output_type = 2; + if (this->has_output_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::output_type(this), target, stream); + } + + // .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; + if (_internal_has_python_pickle_function()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::python_pickle_function(this), target, stream); + } + + // .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; + if (_internal_has_web_assembly_function()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::web_assembly_function(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.EmbeddedFunction) + return target; +} + +size_t Expression_EmbeddedFunction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.EmbeddedFunction) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression arguments = 1; + total_size += 1UL * this->_internal_arguments_size(); + for (const auto& msg : this->arguments_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Type output_type = 2; + if (this->has_output_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *output_type_); + } + + switch (kind_case()) { + // .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; + case kPythonPickleFunction: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.python_pickle_function_); + break; + } + // .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; + case kWebAssemblyFunction: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.web_assembly_function_); + break; + } + case KIND_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_EmbeddedFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.EmbeddedFunction) + GOOGLE_DCHECK_NE(&from, this); + const Expression_EmbeddedFunction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.EmbeddedFunction) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.EmbeddedFunction) + MergeFrom(*source); + } +} + +void Expression_EmbeddedFunction::MergeFrom(const Expression_EmbeddedFunction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.EmbeddedFunction) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + arguments_.MergeFrom(from.arguments_); + if (from.has_output_type()) { + _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + } + switch (from.kind_case()) { + case kPythonPickleFunction: { + _internal_mutable_python_pickle_function()->::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function()); + break; + } + case kWebAssemblyFunction: { + _internal_mutable_web_assembly_function()->::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function()); + break; + } + case KIND_NOT_SET: { + break; + } + } +} + +void Expression_EmbeddedFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.EmbeddedFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_EmbeddedFunction::CopyFrom(const Expression_EmbeddedFunction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.EmbeddedFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_EmbeddedFunction::IsInitialized() const { + return true; +} + +void Expression_EmbeddedFunction::InternalSwap(Expression_EmbeddedFunction* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + arguments_.InternalSwap(&other->arguments_); + swap(output_type_, other->output_type_); + swap(kind_, other->kind_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[27]); +} + +// =================================================================== + +class Expression::_Internal { + public: + static const ::io::substrait::Expression_Literal& literal(const Expression* msg); + static const ::io::substrait::FieldReference& selection(const Expression* msg); + static const ::io::substrait::Expression_ScalarFunction& scalar_function(const Expression* msg); + static const ::io::substrait::Expression_WindowFunction& window_function(const Expression* msg); + static const ::io::substrait::Expression_IfThen& if_then(const Expression* msg); + static const ::io::substrait::Expression_SwitchExpression& switch_expression(const Expression* msg); + static const ::io::substrait::Expression_SingularOrList& singular_or_list(const Expression* msg); + static const ::io::substrait::Expression_MultiOrList& multi_or_list(const Expression* msg); + static const ::io::substrait::Expression_Enum& enum_(const Expression* msg); +}; + +const ::io::substrait::Expression_Literal& +Expression::_Internal::literal(const Expression* msg) { + return *msg->rex_type_.literal_; +} +const ::io::substrait::FieldReference& +Expression::_Internal::selection(const Expression* msg) { + return *msg->rex_type_.selection_; +} +const ::io::substrait::Expression_ScalarFunction& +Expression::_Internal::scalar_function(const Expression* msg) { + return *msg->rex_type_.scalar_function_; +} +const ::io::substrait::Expression_WindowFunction& +Expression::_Internal::window_function(const Expression* msg) { + return *msg->rex_type_.window_function_; +} +const ::io::substrait::Expression_IfThen& +Expression::_Internal::if_then(const Expression* msg) { + return *msg->rex_type_.if_then_; +} +const ::io::substrait::Expression_SwitchExpression& +Expression::_Internal::switch_expression(const Expression* msg) { + return *msg->rex_type_.switch_expression_; +} +const ::io::substrait::Expression_SingularOrList& +Expression::_Internal::singular_or_list(const Expression* msg) { + return *msg->rex_type_.singular_or_list_; +} +const ::io::substrait::Expression_MultiOrList& +Expression::_Internal::multi_or_list(const Expression* msg) { + return *msg->rex_type_.multi_or_list_; +} +const ::io::substrait::Expression_Enum& +Expression::_Internal::enum_(const Expression* msg) { + return *msg->rex_type_.enum__; +} +void Expression::set_allocated_literal(::io::substrait::Expression_Literal* literal) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (literal) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(literal); + if (message_arena != submessage_arena) { + literal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, literal, submessage_arena); + } + set_has_literal(); + rex_type_.literal_ = literal; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.literal) +} +void Expression::set_allocated_selection(::io::substrait::FieldReference* selection) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (selection) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(selection)->GetArena(); + if (message_arena != submessage_arena) { + selection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, selection, submessage_arena); + } + set_has_selection(); + rex_type_.selection_ = selection; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.selection) +} +void Expression::clear_selection() { + if (_internal_has_selection()) { + if (GetArena() == nullptr) { + delete rex_type_.selection_; + } + clear_has_rex_type(); + } +} +void Expression::set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (scalar_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(scalar_function); + if (message_arena != submessage_arena) { + scalar_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, scalar_function, submessage_arena); + } + set_has_scalar_function(); + rex_type_.scalar_function_ = scalar_function; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.scalar_function) +} +void Expression::set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (window_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(window_function); + if (message_arena != submessage_arena) { + window_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, window_function, submessage_arena); + } + set_has_window_function(); + rex_type_.window_function_ = window_function; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.window_function) +} +void Expression::set_allocated_if_then(::io::substrait::Expression_IfThen* if_then) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (if_then) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_then); + if (message_arena != submessage_arena) { + if_then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, if_then, submessage_arena); + } + set_has_if_then(); + rex_type_.if_then_ = if_then; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.if_then) +} +void Expression::set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (switch_expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(switch_expression); + if (message_arena != submessage_arena) { + switch_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, switch_expression, submessage_arena); + } + set_has_switch_expression(); + rex_type_.switch_expression_ = switch_expression; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.switch_expression) +} +void Expression::set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (singular_or_list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(singular_or_list); + if (message_arena != submessage_arena) { + singular_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, singular_or_list, submessage_arena); + } + set_has_singular_or_list(); + rex_type_.singular_or_list_ = singular_or_list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.singular_or_list) +} +void Expression::set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (multi_or_list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(multi_or_list); + if (message_arena != submessage_arena) { + multi_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, multi_or_list, submessage_arena); + } + set_has_multi_or_list(); + rex_type_.multi_or_list_ = multi_or_list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.multi_or_list) +} +void Expression::set_allocated_enum_(::io::substrait::Expression_Enum* enum_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (enum_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(enum_); + if (message_arena != submessage_arena) { + enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, enum_, submessage_arena); + } + set_has_enum_(); + rex_type_.enum__ = enum_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.enum) +} +Expression::Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression) +} +Expression::Expression(const Expression& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_rex_type(); + switch (from.rex_type_case()) { + case kLiteral: { + _internal_mutable_literal()->::io::substrait::Expression_Literal::MergeFrom(from._internal_literal()); + break; + } + case kSelection: { + _internal_mutable_selection()->::io::substrait::FieldReference::MergeFrom(from._internal_selection()); + break; + } + case kScalarFunction: { + _internal_mutable_scalar_function()->::io::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function()); + break; + } + case kWindowFunction: { + _internal_mutable_window_function()->::io::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function()); + break; + } + case kIfThen: { + _internal_mutable_if_then()->::io::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); + break; + } + case kSwitchExpression: { + _internal_mutable_switch_expression()->::io::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); + break; + } + case kSingularOrList: { + _internal_mutable_singular_or_list()->::io::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); + break; + } + case kMultiOrList: { + _internal_mutable_multi_or_list()->::io::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); + break; + } + case kEnum: { + _internal_mutable_enum_()->::io::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); + break; + } + case REX_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression) +} + +void Expression::SharedCtor() { +clear_has_rex_type(); +} + +Expression::~Expression() { + // @@protoc_insertion_point(destructor:io.substrait.Expression) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_rex_type()) { + clear_rex_type(); + } +} + +void Expression::ArenaDtor(void* object) { + Expression* _this = reinterpret_cast< Expression* >(object); + (void)_this; +} +void Expression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression::clear_rex_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression) + switch (rex_type_case()) { + case kLiteral: { + if (GetArena() == nullptr) { + delete rex_type_.literal_; + } + break; + } + case kSelection: { + if (GetArena() == nullptr) { + delete rex_type_.selection_; + } + break; + } + case kScalarFunction: { + if (GetArena() == nullptr) { + delete rex_type_.scalar_function_; + } + break; + } + case kWindowFunction: { + if (GetArena() == nullptr) { + delete rex_type_.window_function_; + } + break; + } + case kIfThen: { + if (GetArena() == nullptr) { + delete rex_type_.if_then_; + } + break; + } + case kSwitchExpression: { + if (GetArena() == nullptr) { + delete rex_type_.switch_expression_; + } + break; + } + case kSingularOrList: { + if (GetArena() == nullptr) { + delete rex_type_.singular_or_list_; + } + break; + } + case kMultiOrList: { + if (GetArena() == nullptr) { + delete rex_type_.multi_or_list_; + } + break; + } + case kEnum: { + if (GetArena() == nullptr) { + delete rex_type_.enum__; + } + break; + } + case REX_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = REX_TYPE_NOT_SET; +} + + +void Expression::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_rex_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.Literal literal = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_literal(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FieldReference selection = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_selection(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.ScalarFunction scalar_function = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_scalar_function(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.WindowFunction window_function = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_window_function(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.IfThen if_then = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_if_then(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.SwitchExpression switch_expression = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_switch_expression(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.SingularOrList singular_or_list = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_singular_or_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.MultiOrList multi_or_list = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_multi_or_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Enum enum = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.Literal literal = 1; + if (_internal_has_literal()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::literal(this), target, stream); + } + + // .io.substrait.FieldReference selection = 2; + if (_internal_has_selection()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::selection(this), target, stream); + } + + // .io.substrait.Expression.ScalarFunction scalar_function = 3; + if (_internal_has_scalar_function()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::scalar_function(this), target, stream); + } + + // .io.substrait.Expression.WindowFunction window_function = 5; + if (_internal_has_window_function()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::window_function(this), target, stream); + } + + // .io.substrait.Expression.IfThen if_then = 6; + if (_internal_has_if_then()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::if_then(this), target, stream); + } + + // .io.substrait.Expression.SwitchExpression switch_expression = 7; + if (_internal_has_switch_expression()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::switch_expression(this), target, stream); + } + + // .io.substrait.Expression.SingularOrList singular_or_list = 8; + if (_internal_has_singular_or_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::singular_or_list(this), target, stream); + } + + // .io.substrait.Expression.MultiOrList multi_or_list = 9; + if (_internal_has_multi_or_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::multi_or_list(this), target, stream); + } + + // .io.substrait.Expression.Enum enum = 10; + if (_internal_has_enum_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::enum_(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression) + return target; +} + +size_t Expression::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (rex_type_case()) { + // .io.substrait.Expression.Literal literal = 1; + case kLiteral: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.literal_); + break; + } + // .io.substrait.FieldReference selection = 2; + case kSelection: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.selection_); + break; + } + // .io.substrait.Expression.ScalarFunction scalar_function = 3; + case kScalarFunction: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.scalar_function_); + break; + } + // .io.substrait.Expression.WindowFunction window_function = 5; + case kWindowFunction: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.window_function_); + break; + } + // .io.substrait.Expression.IfThen if_then = 6; + case kIfThen: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.if_then_); + break; + } + // .io.substrait.Expression.SwitchExpression switch_expression = 7; + case kSwitchExpression: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.switch_expression_); + break; + } + // .io.substrait.Expression.SingularOrList singular_or_list = 8; + case kSingularOrList: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.singular_or_list_); + break; + } + // .io.substrait.Expression.MultiOrList multi_or_list = 9; + case kMultiOrList: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.multi_or_list_); + break; + } + // .io.substrait.Expression.Enum enum = 10; + case kEnum: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.enum__); + break; + } + case REX_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression) + GOOGLE_DCHECK_NE(&from, this); + const Expression* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression) + MergeFrom(*source); + } +} + +void Expression::MergeFrom(const Expression& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.rex_type_case()) { + case kLiteral: { + _internal_mutable_literal()->::io::substrait::Expression_Literal::MergeFrom(from._internal_literal()); + break; + } + case kSelection: { + _internal_mutable_selection()->::io::substrait::FieldReference::MergeFrom(from._internal_selection()); + break; + } + case kScalarFunction: { + _internal_mutable_scalar_function()->::io::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function()); + break; + } + case kWindowFunction: { + _internal_mutable_window_function()->::io::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function()); + break; + } + case kIfThen: { + _internal_mutable_if_then()->::io::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); + break; + } + case kSwitchExpression: { + _internal_mutable_switch_expression()->::io::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); + break; + } + case kSingularOrList: { + _internal_mutable_singular_or_list()->::io::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); + break; + } + case kMultiOrList: { + _internal_mutable_multi_or_list()->::io::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); + break; + } + case kEnum: { + _internal_mutable_enum_()->::io::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); + break; + } + case REX_TYPE_NOT_SET: { + break; + } + } +} + +void Expression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression::CopyFrom(const Expression& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression::IsInitialized() const { + return true; +} + +void Expression::InternalSwap(Expression* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(rex_type_, other->rex_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[28]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage< ::io::substrait::Expression_Enum_Empty >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Enum_Empty >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Enum* Arena::CreateMaybeMessage< ::io::substrait::Expression_Enum >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Enum >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_Map_KeyValue >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_Map_KeyValue >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_Map >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_Map >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalYearToMonth >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_IntervalYearToMonth >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalDayToSecond >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_IntervalDayToSecond >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_Struct >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_Struct >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_List* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_List >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_List >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_ScalarFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_ScalarFunction >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_AggregateFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_AggregateFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_AggregateFunction >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Preceding >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound_Preceding >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Following >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound_Following >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Unbounded >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound_Unbounded >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_SortField* Arena::CreateMaybeMessage< ::io::substrait::Expression_SortField >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_SortField >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage< ::io::substrait::Expression_IfThen_IfClause >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_IfThen_IfClause >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_IfThen* Arena::CreateMaybeMessage< ::io::substrait::Expression_IfThen >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_IfThen >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage< ::io::substrait::Expression_SwitchExpression_IfValue >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_SwitchExpression_IfValue >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage< ::io::substrait::Expression_SwitchExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_SwitchExpression >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage< ::io::substrait::Expression_SingularOrList >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_SingularOrList >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage< ::io::substrait::Expression_MultiOrList_Record >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MultiOrList_Record >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage< ::io::substrait::Expression_MultiOrList >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MultiOrList >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_EmbeddedFunction >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression* Arena::CreateMaybeMessage< ::io::substrait::Expression >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/expression.pb.h b/cpp/src/generated/substrait/expression.pb.h new file mode 100644 index 00000000000..edc27212bbc --- /dev/null +++ b/cpp/src/generated/substrait/expression.pb.h @@ -0,0 +1,11252 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: expression.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_expression_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_expression_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +#include "type.pb.h" +#include "selection.pb.h" +#include "extensions.pb.h" +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_expression_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_expression_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[29] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_expression_2eproto; +namespace io { +namespace substrait { +class Expression; +struct ExpressionDefaultTypeInternal; +extern ExpressionDefaultTypeInternal _Expression_default_instance_; +class Expression_AggregateFunction; +struct Expression_AggregateFunctionDefaultTypeInternal; +extern Expression_AggregateFunctionDefaultTypeInternal _Expression_AggregateFunction_default_instance_; +class Expression_EmbeddedFunction; +struct Expression_EmbeddedFunctionDefaultTypeInternal; +extern Expression_EmbeddedFunctionDefaultTypeInternal _Expression_EmbeddedFunction_default_instance_; +class Expression_EmbeddedFunction_PythonPickleFunction; +struct Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal; +extern Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal _Expression_EmbeddedFunction_PythonPickleFunction_default_instance_; +class Expression_EmbeddedFunction_WebAssemblyFunction; +struct Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal; +extern Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal _Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_; +class Expression_Enum; +struct Expression_EnumDefaultTypeInternal; +extern Expression_EnumDefaultTypeInternal _Expression_Enum_default_instance_; +class Expression_Enum_Empty; +struct Expression_Enum_EmptyDefaultTypeInternal; +extern Expression_Enum_EmptyDefaultTypeInternal _Expression_Enum_Empty_default_instance_; +class Expression_IfThen; +struct Expression_IfThenDefaultTypeInternal; +extern Expression_IfThenDefaultTypeInternal _Expression_IfThen_default_instance_; +class Expression_IfThen_IfClause; +struct Expression_IfThen_IfClauseDefaultTypeInternal; +extern Expression_IfThen_IfClauseDefaultTypeInternal _Expression_IfThen_IfClause_default_instance_; +class Expression_Literal; +struct Expression_LiteralDefaultTypeInternal; +extern Expression_LiteralDefaultTypeInternal _Expression_Literal_default_instance_; +class Expression_Literal_IntervalDayToSecond; +struct Expression_Literal_IntervalDayToSecondDefaultTypeInternal; +extern Expression_Literal_IntervalDayToSecondDefaultTypeInternal _Expression_Literal_IntervalDayToSecond_default_instance_; +class Expression_Literal_IntervalYearToMonth; +struct Expression_Literal_IntervalYearToMonthDefaultTypeInternal; +extern Expression_Literal_IntervalYearToMonthDefaultTypeInternal _Expression_Literal_IntervalYearToMonth_default_instance_; +class Expression_Literal_List; +struct Expression_Literal_ListDefaultTypeInternal; +extern Expression_Literal_ListDefaultTypeInternal _Expression_Literal_List_default_instance_; +class Expression_Literal_Map; +struct Expression_Literal_MapDefaultTypeInternal; +extern Expression_Literal_MapDefaultTypeInternal _Expression_Literal_Map_default_instance_; +class Expression_Literal_Map_KeyValue; +struct Expression_Literal_Map_KeyValueDefaultTypeInternal; +extern Expression_Literal_Map_KeyValueDefaultTypeInternal _Expression_Literal_Map_KeyValue_default_instance_; +class Expression_Literal_Struct; +struct Expression_Literal_StructDefaultTypeInternal; +extern Expression_Literal_StructDefaultTypeInternal _Expression_Literal_Struct_default_instance_; +class Expression_MultiOrList; +struct Expression_MultiOrListDefaultTypeInternal; +extern Expression_MultiOrListDefaultTypeInternal _Expression_MultiOrList_default_instance_; +class Expression_MultiOrList_Record; +struct Expression_MultiOrList_RecordDefaultTypeInternal; +extern Expression_MultiOrList_RecordDefaultTypeInternal _Expression_MultiOrList_Record_default_instance_; +class Expression_ScalarFunction; +struct Expression_ScalarFunctionDefaultTypeInternal; +extern Expression_ScalarFunctionDefaultTypeInternal _Expression_ScalarFunction_default_instance_; +class Expression_SingularOrList; +struct Expression_SingularOrListDefaultTypeInternal; +extern Expression_SingularOrListDefaultTypeInternal _Expression_SingularOrList_default_instance_; +class Expression_SortField; +struct Expression_SortFieldDefaultTypeInternal; +extern Expression_SortFieldDefaultTypeInternal _Expression_SortField_default_instance_; +class Expression_SwitchExpression; +struct Expression_SwitchExpressionDefaultTypeInternal; +extern Expression_SwitchExpressionDefaultTypeInternal _Expression_SwitchExpression_default_instance_; +class Expression_SwitchExpression_IfValue; +struct Expression_SwitchExpression_IfValueDefaultTypeInternal; +extern Expression_SwitchExpression_IfValueDefaultTypeInternal _Expression_SwitchExpression_IfValue_default_instance_; +class Expression_WindowFunction; +struct Expression_WindowFunctionDefaultTypeInternal; +extern Expression_WindowFunctionDefaultTypeInternal _Expression_WindowFunction_default_instance_; +class Expression_WindowFunction_Bound; +struct Expression_WindowFunction_BoundDefaultTypeInternal; +extern Expression_WindowFunction_BoundDefaultTypeInternal _Expression_WindowFunction_Bound_default_instance_; +class Expression_WindowFunction_Bound_CurrentRow; +struct Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal; +extern Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal _Expression_WindowFunction_Bound_CurrentRow_default_instance_; +class Expression_WindowFunction_Bound_Following; +struct Expression_WindowFunction_Bound_FollowingDefaultTypeInternal; +extern Expression_WindowFunction_Bound_FollowingDefaultTypeInternal _Expression_WindowFunction_Bound_Following_default_instance_; +class Expression_WindowFunction_Bound_Preceding; +struct Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal; +extern Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal _Expression_WindowFunction_Bound_Preceding_default_instance_; +class Expression_WindowFunction_Bound_Unbounded; +struct Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal; +extern Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal _Expression_WindowFunction_Bound_Unbounded_default_instance_; +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::Expression* Arena::CreateMaybeMessage<::io::substrait::Expression>(Arena*); +template<> ::io::substrait::Expression_AggregateFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_AggregateFunction>(Arena*); +template<> ::io::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_EmbeddedFunction>(Arena*); +template<> ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction>(Arena*); +template<> ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction>(Arena*); +template<> ::io::substrait::Expression_Enum* Arena::CreateMaybeMessage<::io::substrait::Expression_Enum>(Arena*); +template<> ::io::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage<::io::substrait::Expression_Enum_Empty>(Arena*); +template<> ::io::substrait::Expression_IfThen* Arena::CreateMaybeMessage<::io::substrait::Expression_IfThen>(Arena*); +template<> ::io::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage<::io::substrait::Expression_IfThen_IfClause>(Arena*); +template<> ::io::substrait::Expression_Literal* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal>(Arena*); +template<> ::io::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_IntervalDayToSecond>(Arena*); +template<> ::io::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_IntervalYearToMonth>(Arena*); +template<> ::io::substrait::Expression_Literal_List* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_List>(Arena*); +template<> ::io::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Map>(Arena*); +template<> ::io::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Map_KeyValue>(Arena*); +template<> ::io::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Struct>(Arena*); +template<> ::io::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage<::io::substrait::Expression_MultiOrList>(Arena*); +template<> ::io::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage<::io::substrait::Expression_MultiOrList_Record>(Arena*); +template<> ::io::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_ScalarFunction>(Arena*); +template<> ::io::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage<::io::substrait::Expression_SingularOrList>(Arena*); +template<> ::io::substrait::Expression_SortField* Arena::CreateMaybeMessage<::io::substrait::Expression_SortField>(Arena*); +template<> ::io::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage<::io::substrait::Expression_SwitchExpression>(Arena*); +template<> ::io::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage<::io::substrait::Expression_SwitchExpression_IfValue>(Arena*); +template<> ::io::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction>(Arena*); +template<> ::io::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound>(Arena*); +template<> ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_CurrentRow>(Arena*); +template<> ::io::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_Following>(Arena*); +template<> ::io::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_Preceding>(Arena*); +template<> ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_Unbounded>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace io { +namespace substrait { + +enum Expression_SortField_SortDirection : int { + Expression_SortField_SortDirection_UNKNOWN = 0, + Expression_SortField_SortDirection_ASC_NULLS_FIRST = 1, + Expression_SortField_SortDirection_ASC_NULLS_LAST = 2, + Expression_SortField_SortDirection_DESC_NULLS_FIRST = 3, + Expression_SortField_SortDirection_DESC_NULLS_LAST = 4, + Expression_SortField_SortDirection_CLUSTERED = 5, + Expression_SortField_SortDirection_Expression_SortField_SortDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + Expression_SortField_SortDirection_Expression_SortField_SortDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool Expression_SortField_SortDirection_IsValid(int value); +constexpr Expression_SortField_SortDirection Expression_SortField_SortDirection_SortDirection_MIN = Expression_SortField_SortDirection_UNKNOWN; +constexpr Expression_SortField_SortDirection Expression_SortField_SortDirection_SortDirection_MAX = Expression_SortField_SortDirection_CLUSTERED; +constexpr int Expression_SortField_SortDirection_SortDirection_ARRAYSIZE = Expression_SortField_SortDirection_SortDirection_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_SortField_SortDirection_descriptor(); +template +inline const std::string& Expression_SortField_SortDirection_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Expression_SortField_SortDirection_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Expression_SortField_SortDirection_descriptor(), enum_t_value); +} +inline bool Expression_SortField_SortDirection_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Expression_SortField_SortDirection* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Expression_SortField_SortDirection_descriptor(), name, value); +} +enum Expression_AggregationPhase : int { + Expression_AggregationPhase_UNKNOWN = 0, + Expression_AggregationPhase_INITIAL_TO_INTERMEDIATE = 1, + Expression_AggregationPhase_INTERMEDIATE_TO_INTERMEDIATE = 2, + Expression_AggregationPhase_INITIAL_TO_RESULT = 3, + Expression_AggregationPhase_INTERMEDIATE_TO_RESULT = 4, + Expression_AggregationPhase_Expression_AggregationPhase_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + Expression_AggregationPhase_Expression_AggregationPhase_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool Expression_AggregationPhase_IsValid(int value); +constexpr Expression_AggregationPhase Expression_AggregationPhase_AggregationPhase_MIN = Expression_AggregationPhase_UNKNOWN; +constexpr Expression_AggregationPhase Expression_AggregationPhase_AggregationPhase_MAX = Expression_AggregationPhase_INTERMEDIATE_TO_RESULT; +constexpr int Expression_AggregationPhase_AggregationPhase_ARRAYSIZE = Expression_AggregationPhase_AggregationPhase_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_AggregationPhase_descriptor(); +template +inline const std::string& Expression_AggregationPhase_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Expression_AggregationPhase_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Expression_AggregationPhase_descriptor(), enum_t_value); +} +inline bool Expression_AggregationPhase_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Expression_AggregationPhase* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Expression_AggregationPhase_descriptor(), name, value); +} +// =================================================================== + +class Expression_Enum_Empty PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Enum.Empty) */ { + public: + inline Expression_Enum_Empty() : Expression_Enum_Empty(nullptr) {} + ~Expression_Enum_Empty() override; + explicit constexpr Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Enum_Empty(const Expression_Enum_Empty& from); + Expression_Enum_Empty(Expression_Enum_Empty&& from) noexcept + : Expression_Enum_Empty() { + *this = ::std::move(from); + } + + inline Expression_Enum_Empty& operator=(const Expression_Enum_Empty& from) { + CopyFrom(from); + return *this; + } + inline Expression_Enum_Empty& operator=(Expression_Enum_Empty&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Enum_Empty& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_Enum_Empty* internal_default_instance() { + return reinterpret_cast( + &_Expression_Enum_Empty_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Expression_Enum_Empty& a, Expression_Enum_Empty& b) { + a.Swap(&b); + } + inline void Swap(Expression_Enum_Empty* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Enum_Empty* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Enum_Empty* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Enum_Empty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Enum_Empty& from); + void MergeFrom(const Expression_Enum_Empty& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Enum_Empty* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Enum.Empty"; + } + protected: + explicit Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Enum.Empty) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_Enum PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Enum) */ { + public: + inline Expression_Enum() : Expression_Enum(nullptr) {} + ~Expression_Enum() override; + explicit constexpr Expression_Enum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Enum(const Expression_Enum& from); + Expression_Enum(Expression_Enum&& from) noexcept + : Expression_Enum() { + *this = ::std::move(from); + } + + inline Expression_Enum& operator=(const Expression_Enum& from) { + CopyFrom(from); + return *this; + } + inline Expression_Enum& operator=(Expression_Enum&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Enum& default_instance() { + return *internal_default_instance(); + } + enum EnumKindCase { + kSpecified = 1, + kUnspecified = 2, + ENUM_KIND_NOT_SET = 0, + }; + + static inline const Expression_Enum* internal_default_instance() { + return reinterpret_cast( + &_Expression_Enum_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(Expression_Enum& a, Expression_Enum& b) { + a.Swap(&b); + } + inline void Swap(Expression_Enum* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Enum* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Enum* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Enum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Enum& from); + void MergeFrom(const Expression_Enum& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Enum* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Enum"; + } + protected: + explicit Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_Enum_Empty Empty; + + // accessors ------------------------------------------------------- + + enum : int { + kSpecifiedFieldNumber = 1, + kUnspecifiedFieldNumber = 2, + }; + // string specified = 1; + bool has_specified() const; + private: + bool _internal_has_specified() const; + public: + void clear_specified(); + const std::string& specified() const; + template + void set_specified(ArgT0&& arg0, ArgT... args); + std::string* mutable_specified(); + std::string* release_specified(); + void set_allocated_specified(std::string* specified); + private: + const std::string& _internal_specified() const; + void _internal_set_specified(const std::string& value); + std::string* _internal_mutable_specified(); + public: + + // .io.substrait.Expression.Enum.Empty unspecified = 2; + bool has_unspecified() const; + private: + bool _internal_has_unspecified() const; + public: + void clear_unspecified(); + const ::io::substrait::Expression_Enum_Empty& unspecified() const; + ::io::substrait::Expression_Enum_Empty* release_unspecified(); + ::io::substrait::Expression_Enum_Empty* mutable_unspecified(); + void set_allocated_unspecified(::io::substrait::Expression_Enum_Empty* unspecified); + private: + const ::io::substrait::Expression_Enum_Empty& _internal_unspecified() const; + ::io::substrait::Expression_Enum_Empty* _internal_mutable_unspecified(); + public: + void unsafe_arena_set_allocated_unspecified( + ::io::substrait::Expression_Enum_Empty* unspecified); + ::io::substrait::Expression_Enum_Empty* unsafe_arena_release_unspecified(); + + void clear_enum_kind(); + EnumKindCase enum_kind_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Enum) + private: + class _Internal; + void set_has_specified(); + void set_has_unspecified(); + + inline bool has_enum_kind() const; + inline void clear_has_enum_kind(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union EnumKindUnion { + constexpr EnumKindUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr specified_; + ::io::substrait::Expression_Enum_Empty* unspecified_; + } enum_kind_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.Map.KeyValue) */ { + public: + inline Expression_Literal_Map_KeyValue() : Expression_Literal_Map_KeyValue(nullptr) {} + ~Expression_Literal_Map_KeyValue() override; + explicit constexpr Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from); + Expression_Literal_Map_KeyValue(Expression_Literal_Map_KeyValue&& from) noexcept + : Expression_Literal_Map_KeyValue() { + *this = ::std::move(from); + } + + inline Expression_Literal_Map_KeyValue& operator=(const Expression_Literal_Map_KeyValue& from) { + CopyFrom(from); + return *this; + } + inline Expression_Literal_Map_KeyValue& operator=(Expression_Literal_Map_KeyValue&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Literal_Map_KeyValue& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_Literal_Map_KeyValue* internal_default_instance() { + return reinterpret_cast( + &_Expression_Literal_Map_KeyValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(Expression_Literal_Map_KeyValue& a, Expression_Literal_Map_KeyValue& b) { + a.Swap(&b); + } + inline void Swap(Expression_Literal_Map_KeyValue* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Literal_Map_KeyValue* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Literal_Map_KeyValue* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Literal_Map_KeyValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Literal_Map_KeyValue& from); + void MergeFrom(const Expression_Literal_Map_KeyValue& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Literal_Map_KeyValue* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Literal.Map.KeyValue"; + } + protected: + explicit Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + // .io.substrait.Expression.Literal key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::io::substrait::Expression_Literal& key() const; + ::io::substrait::Expression_Literal* release_key(); + ::io::substrait::Expression_Literal* mutable_key(); + void set_allocated_key(::io::substrait::Expression_Literal* key); + private: + const ::io::substrait::Expression_Literal& _internal_key() const; + ::io::substrait::Expression_Literal* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::io::substrait::Expression_Literal* key); + ::io::substrait::Expression_Literal* unsafe_arena_release_key(); + + // .io.substrait.Expression.Literal value = 2; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + const ::io::substrait::Expression_Literal& value() const; + ::io::substrait::Expression_Literal* release_value(); + ::io::substrait::Expression_Literal* mutable_value(); + void set_allocated_value(::io::substrait::Expression_Literal* value); + private: + const ::io::substrait::Expression_Literal& _internal_value() const; + ::io::substrait::Expression_Literal* _internal_mutable_value(); + public: + void unsafe_arena_set_allocated_value( + ::io::substrait::Expression_Literal* value); + ::io::substrait::Expression_Literal* unsafe_arena_release_value(); + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.Map.KeyValue) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression_Literal* key_; + ::io::substrait::Expression_Literal* value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_Literal_Map PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.Map) */ { + public: + inline Expression_Literal_Map() : Expression_Literal_Map(nullptr) {} + ~Expression_Literal_Map() override; + explicit constexpr Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Literal_Map(const Expression_Literal_Map& from); + Expression_Literal_Map(Expression_Literal_Map&& from) noexcept + : Expression_Literal_Map() { + *this = ::std::move(from); + } + + inline Expression_Literal_Map& operator=(const Expression_Literal_Map& from) { + CopyFrom(from); + return *this; + } + inline Expression_Literal_Map& operator=(Expression_Literal_Map&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Literal_Map& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_Literal_Map* internal_default_instance() { + return reinterpret_cast( + &_Expression_Literal_Map_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(Expression_Literal_Map& a, Expression_Literal_Map& b) { + a.Swap(&b); + } + inline void Swap(Expression_Literal_Map* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Literal_Map* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Literal_Map* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Literal_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Literal_Map& from); + void MergeFrom(const Expression_Literal_Map& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Literal_Map* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Literal.Map"; + } + protected: + explicit Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_Literal_Map_KeyValue KeyValue; + + // accessors ------------------------------------------------------- + + enum : int { + kKeyValuesFieldNumber = 1, + }; + // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + int key_values_size() const; + private: + int _internal_key_values_size() const; + public: + void clear_key_values(); + ::io::substrait::Expression_Literal_Map_KeyValue* mutable_key_values(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >* + mutable_key_values(); + private: + const ::io::substrait::Expression_Literal_Map_KeyValue& _internal_key_values(int index) const; + ::io::substrait::Expression_Literal_Map_KeyValue* _internal_add_key_values(); + public: + const ::io::substrait::Expression_Literal_Map_KeyValue& key_values(int index) const; + ::io::substrait::Expression_Literal_Map_KeyValue* add_key_values(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >& + key_values() const; + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.Map) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue > key_values_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.IntervalYearToMonth) */ { + public: + inline Expression_Literal_IntervalYearToMonth() : Expression_Literal_IntervalYearToMonth(nullptr) {} + ~Expression_Literal_IntervalYearToMonth() override; + explicit constexpr Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from); + Expression_Literal_IntervalYearToMonth(Expression_Literal_IntervalYearToMonth&& from) noexcept + : Expression_Literal_IntervalYearToMonth() { + *this = ::std::move(from); + } + + inline Expression_Literal_IntervalYearToMonth& operator=(const Expression_Literal_IntervalYearToMonth& from) { + CopyFrom(from); + return *this; + } + inline Expression_Literal_IntervalYearToMonth& operator=(Expression_Literal_IntervalYearToMonth&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Literal_IntervalYearToMonth& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_Literal_IntervalYearToMonth* internal_default_instance() { + return reinterpret_cast( + &_Expression_Literal_IntervalYearToMonth_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(Expression_Literal_IntervalYearToMonth& a, Expression_Literal_IntervalYearToMonth& b) { + a.Swap(&b); + } + inline void Swap(Expression_Literal_IntervalYearToMonth* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Literal_IntervalYearToMonth* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Literal_IntervalYearToMonth* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Literal_IntervalYearToMonth* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Literal_IntervalYearToMonth& from); + void MergeFrom(const Expression_Literal_IntervalYearToMonth& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Literal_IntervalYearToMonth* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Literal.IntervalYearToMonth"; + } + protected: + explicit Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kYearsFieldNumber = 1, + kMonthsFieldNumber = 2, + }; + // int32 years = 1; + void clear_years(); + ::PROTOBUF_NAMESPACE_ID::int32 years() const; + void set_years(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_years() const; + void _internal_set_years(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // int32 months = 2; + void clear_months(); + ::PROTOBUF_NAMESPACE_ID::int32 months() const; + void set_months(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_months() const; + void _internal_set_months(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.IntervalYearToMonth) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::int32 years_; + ::PROTOBUF_NAMESPACE_ID::int32 months_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.IntervalDayToSecond) */ { + public: + inline Expression_Literal_IntervalDayToSecond() : Expression_Literal_IntervalDayToSecond(nullptr) {} + ~Expression_Literal_IntervalDayToSecond() override; + explicit constexpr Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from); + Expression_Literal_IntervalDayToSecond(Expression_Literal_IntervalDayToSecond&& from) noexcept + : Expression_Literal_IntervalDayToSecond() { + *this = ::std::move(from); + } + + inline Expression_Literal_IntervalDayToSecond& operator=(const Expression_Literal_IntervalDayToSecond& from) { + CopyFrom(from); + return *this; + } + inline Expression_Literal_IntervalDayToSecond& operator=(Expression_Literal_IntervalDayToSecond&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Literal_IntervalDayToSecond& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_Literal_IntervalDayToSecond* internal_default_instance() { + return reinterpret_cast( + &_Expression_Literal_IntervalDayToSecond_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(Expression_Literal_IntervalDayToSecond& a, Expression_Literal_IntervalDayToSecond& b) { + a.Swap(&b); + } + inline void Swap(Expression_Literal_IntervalDayToSecond* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Literal_IntervalDayToSecond* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Literal_IntervalDayToSecond* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Literal_IntervalDayToSecond* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Literal_IntervalDayToSecond& from); + void MergeFrom(const Expression_Literal_IntervalDayToSecond& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Literal_IntervalDayToSecond* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Literal.IntervalDayToSecond"; + } + protected: + explicit Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDaysFieldNumber = 1, + kSecondsFieldNumber = 2, + }; + // int32 days = 1; + void clear_days(); + ::PROTOBUF_NAMESPACE_ID::int32 days() const; + void set_days(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_days() const; + void _internal_set_days(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // int32 seconds = 2; + void clear_seconds(); + ::PROTOBUF_NAMESPACE_ID::int32 seconds() const; + void set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_seconds() const; + void _internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.IntervalDayToSecond) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::int32 days_; + ::PROTOBUF_NAMESPACE_ID::int32 seconds_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_Literal_Struct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.Struct) */ { + public: + inline Expression_Literal_Struct() : Expression_Literal_Struct(nullptr) {} + ~Expression_Literal_Struct() override; + explicit constexpr Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Literal_Struct(const Expression_Literal_Struct& from); + Expression_Literal_Struct(Expression_Literal_Struct&& from) noexcept + : Expression_Literal_Struct() { + *this = ::std::move(from); + } + + inline Expression_Literal_Struct& operator=(const Expression_Literal_Struct& from) { + CopyFrom(from); + return *this; + } + inline Expression_Literal_Struct& operator=(Expression_Literal_Struct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Literal_Struct& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_Literal_Struct* internal_default_instance() { + return reinterpret_cast( + &_Expression_Literal_Struct_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(Expression_Literal_Struct& a, Expression_Literal_Struct& b) { + a.Swap(&b); + } + inline void Swap(Expression_Literal_Struct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Literal_Struct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Literal_Struct* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Literal_Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Literal_Struct& from); + void MergeFrom(const Expression_Literal_Struct& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Literal_Struct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Literal.Struct"; + } + protected: + explicit Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFieldsFieldNumber = 1, + }; + // repeated .io.substrait.Expression.Literal fields = 1; + int fields_size() const; + private: + int _internal_fields_size() const; + public: + void clear_fields(); + ::io::substrait::Expression_Literal* mutable_fields(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* + mutable_fields(); + private: + const ::io::substrait::Expression_Literal& _internal_fields(int index) const; + ::io::substrait::Expression_Literal* _internal_add_fields(); + public: + const ::io::substrait::Expression_Literal& fields(int index) const; + ::io::substrait::Expression_Literal* add_fields(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& + fields() const; + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.Struct) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal > fields_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_Literal_List PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.List) */ { + public: + inline Expression_Literal_List() : Expression_Literal_List(nullptr) {} + ~Expression_Literal_List() override; + explicit constexpr Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Literal_List(const Expression_Literal_List& from); + Expression_Literal_List(Expression_Literal_List&& from) noexcept + : Expression_Literal_List() { + *this = ::std::move(from); + } + + inline Expression_Literal_List& operator=(const Expression_Literal_List& from) { + CopyFrom(from); + return *this; + } + inline Expression_Literal_List& operator=(Expression_Literal_List&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Literal_List& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_Literal_List* internal_default_instance() { + return reinterpret_cast( + &_Expression_Literal_List_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(Expression_Literal_List& a, Expression_Literal_List& b) { + a.Swap(&b); + } + inline void Swap(Expression_Literal_List* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Literal_List* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Literal_List* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Literal_List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Literal_List& from); + void MergeFrom(const Expression_Literal_List& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Literal_List* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Literal.List"; + } + protected: + explicit Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kValuesFieldNumber = 1, + }; + // repeated .io.substrait.Expression.Literal values = 1; + int values_size() const; + private: + int _internal_values_size() const; + public: + void clear_values(); + ::io::substrait::Expression_Literal* mutable_values(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* + mutable_values(); + private: + const ::io::substrait::Expression_Literal& _internal_values(int index) const; + ::io::substrait::Expression_Literal* _internal_add_values(); + public: + const ::io::substrait::Expression_Literal& values(int index) const; + ::io::substrait::Expression_Literal* add_values(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& + values() const; + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.List) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal > values_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_Literal PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal) */ { + public: + inline Expression_Literal() : Expression_Literal(nullptr) {} + ~Expression_Literal() override; + explicit constexpr Expression_Literal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Literal(const Expression_Literal& from); + Expression_Literal(Expression_Literal&& from) noexcept + : Expression_Literal() { + *this = ::std::move(from); + } + + inline Expression_Literal& operator=(const Expression_Literal& from) { + CopyFrom(from); + return *this; + } + inline Expression_Literal& operator=(Expression_Literal&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Literal& default_instance() { + return *internal_default_instance(); + } + enum LiteralTypeCase { + kBoolean = 1, + kI8 = 2, + kI16 = 3, + kI32 = 5, + kI64 = 7, + kFp32 = 10, + kFp64 = 11, + kString = 12, + kBinary = 13, + kTimestamp = 14, + kDate = 16, + kTime = 17, + kIntervalYearToMonth = 19, + kIntervalDayToSecond = 20, + kFixedChar = 21, + kVarChar = 22, + kFixedBinary = 23, + kDecimal = 24, + kStruct = 25, + kMap = 26, + kTimestampTz = 27, + kUuid = 28, + kNull = 29, + kList = 30, + LITERAL_TYPE_NOT_SET = 0, + }; + + static inline const Expression_Literal* internal_default_instance() { + return reinterpret_cast( + &_Expression_Literal_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(Expression_Literal& a, Expression_Literal& b) { + a.Swap(&b); + } + inline void Swap(Expression_Literal* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Literal* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Literal* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Literal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Literal& from); + void MergeFrom(const Expression_Literal& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Literal* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Literal"; + } + protected: + explicit Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_Literal_Map Map; + typedef Expression_Literal_IntervalYearToMonth IntervalYearToMonth; + typedef Expression_Literal_IntervalDayToSecond IntervalDayToSecond; + typedef Expression_Literal_Struct Struct; + typedef Expression_Literal_List List; + + // accessors ------------------------------------------------------- + + enum : int { + kBooleanFieldNumber = 1, + kI8FieldNumber = 2, + kI16FieldNumber = 3, + kI32FieldNumber = 5, + kI64FieldNumber = 7, + kFp32FieldNumber = 10, + kFp64FieldNumber = 11, + kStringFieldNumber = 12, + kBinaryFieldNumber = 13, + kTimestampFieldNumber = 14, + kDateFieldNumber = 16, + kTimeFieldNumber = 17, + kIntervalYearToMonthFieldNumber = 19, + kIntervalDayToSecondFieldNumber = 20, + kFixedCharFieldNumber = 21, + kVarCharFieldNumber = 22, + kFixedBinaryFieldNumber = 23, + kDecimalFieldNumber = 24, + kStructFieldNumber = 25, + kMapFieldNumber = 26, + kTimestampTzFieldNumber = 27, + kUuidFieldNumber = 28, + kNullFieldNumber = 29, + kListFieldNumber = 30, + }; + // bool boolean = 1; + bool has_boolean() const; + private: + bool _internal_has_boolean() const; + public: + void clear_boolean(); + bool boolean() const; + void set_boolean(bool value); + private: + bool _internal_boolean() const; + void _internal_set_boolean(bool value); + public: + + // int32 i8 = 2; + bool has_i8() const; + private: + bool _internal_has_i8() const; + public: + void clear_i8(); + ::PROTOBUF_NAMESPACE_ID::int32 i8() const; + void set_i8(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_i8() const; + void _internal_set_i8(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // int32 i16 = 3; + bool has_i16() const; + private: + bool _internal_has_i16() const; + public: + void clear_i16(); + ::PROTOBUF_NAMESPACE_ID::int32 i16() const; + void set_i16(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_i16() const; + void _internal_set_i16(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // int32 i32 = 5; + bool has_i32() const; + private: + bool _internal_has_i32() const; + public: + void clear_i32(); + ::PROTOBUF_NAMESPACE_ID::int32 i32() const; + void set_i32(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_i32() const; + void _internal_set_i32(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // int64 i64 = 7; + bool has_i64() const; + private: + bool _internal_has_i64() const; + public: + void clear_i64(); + ::PROTOBUF_NAMESPACE_ID::int64 i64() const; + void set_i64(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_i64() const; + void _internal_set_i64(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // float fp32 = 10; + bool has_fp32() const; + private: + bool _internal_has_fp32() const; + public: + void clear_fp32(); + float fp32() const; + void set_fp32(float value); + private: + float _internal_fp32() const; + void _internal_set_fp32(float value); + public: + + // double fp64 = 11; + bool has_fp64() const; + private: + bool _internal_has_fp64() const; + public: + void clear_fp64(); + double fp64() const; + void set_fp64(double value); + private: + double _internal_fp64() const; + void _internal_set_fp64(double value); + public: + + // string string = 12; + bool has_string() const; + private: + bool _internal_has_string() const; + public: + void clear_string(); + const std::string& string() const; + template + void set_string(ArgT0&& arg0, ArgT... args); + std::string* mutable_string(); + std::string* release_string(); + void set_allocated_string(std::string* string); + private: + const std::string& _internal_string() const; + void _internal_set_string(const std::string& value); + std::string* _internal_mutable_string(); + public: + + // bytes binary = 13; + bool has_binary() const; + private: + bool _internal_has_binary() const; + public: + void clear_binary(); + const std::string& binary() const; + template + void set_binary(ArgT0&& arg0, ArgT... args); + std::string* mutable_binary(); + std::string* release_binary(); + void set_allocated_binary(std::string* binary); + private: + const std::string& _internal_binary() const; + void _internal_set_binary(const std::string& value); + std::string* _internal_mutable_binary(); + public: + + // fixed64 timestamp = 14; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const; + void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_timestamp() const; + void _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // fixed32 date = 16; + bool has_date() const; + private: + bool _internal_has_date() const; + public: + void clear_date(); + ::PROTOBUF_NAMESPACE_ID::uint32 date() const; + void set_date(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_date() const; + void _internal_set_date(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // uint64 time = 17; + bool has_time() const; + private: + bool _internal_has_time() const; + public: + void clear_time(); + ::PROTOBUF_NAMESPACE_ID::uint64 time() const; + void set_time(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_time() const; + void _internal_set_time(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + bool has_interval_year_to_month() const; + private: + bool _internal_has_interval_year_to_month() const; + public: + void clear_interval_year_to_month(); + const ::io::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month() const; + ::io::substrait::Expression_Literal_IntervalYearToMonth* release_interval_year_to_month(); + ::io::substrait::Expression_Literal_IntervalYearToMonth* mutable_interval_year_to_month(); + void set_allocated_interval_year_to_month(::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month); + private: + const ::io::substrait::Expression_Literal_IntervalYearToMonth& _internal_interval_year_to_month() const; + ::io::substrait::Expression_Literal_IntervalYearToMonth* _internal_mutable_interval_year_to_month(); + public: + void unsafe_arena_set_allocated_interval_year_to_month( + ::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month); + ::io::substrait::Expression_Literal_IntervalYearToMonth* unsafe_arena_release_interval_year_to_month(); + + // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + bool has_interval_day_to_second() const; + private: + bool _internal_has_interval_day_to_second() const; + public: + void clear_interval_day_to_second(); + const ::io::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second() const; + ::io::substrait::Expression_Literal_IntervalDayToSecond* release_interval_day_to_second(); + ::io::substrait::Expression_Literal_IntervalDayToSecond* mutable_interval_day_to_second(); + void set_allocated_interval_day_to_second(::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second); + private: + const ::io::substrait::Expression_Literal_IntervalDayToSecond& _internal_interval_day_to_second() const; + ::io::substrait::Expression_Literal_IntervalDayToSecond* _internal_mutable_interval_day_to_second(); + public: + void unsafe_arena_set_allocated_interval_day_to_second( + ::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second); + ::io::substrait::Expression_Literal_IntervalDayToSecond* unsafe_arena_release_interval_day_to_second(); + + // string fixed_char = 21; + bool has_fixed_char() const; + private: + bool _internal_has_fixed_char() const; + public: + void clear_fixed_char(); + const std::string& fixed_char() const; + template + void set_fixed_char(ArgT0&& arg0, ArgT... args); + std::string* mutable_fixed_char(); + std::string* release_fixed_char(); + void set_allocated_fixed_char(std::string* fixed_char); + private: + const std::string& _internal_fixed_char() const; + void _internal_set_fixed_char(const std::string& value); + std::string* _internal_mutable_fixed_char(); + public: + + // string var_char = 22; + bool has_var_char() const; + private: + bool _internal_has_var_char() const; + public: + void clear_var_char(); + const std::string& var_char() const; + template + void set_var_char(ArgT0&& arg0, ArgT... args); + std::string* mutable_var_char(); + std::string* release_var_char(); + void set_allocated_var_char(std::string* var_char); + private: + const std::string& _internal_var_char() const; + void _internal_set_var_char(const std::string& value); + std::string* _internal_mutable_var_char(); + public: + + // bytes fixed_binary = 23; + bool has_fixed_binary() const; + private: + bool _internal_has_fixed_binary() const; + public: + void clear_fixed_binary(); + const std::string& fixed_binary() const; + template + void set_fixed_binary(ArgT0&& arg0, ArgT... args); + std::string* mutable_fixed_binary(); + std::string* release_fixed_binary(); + void set_allocated_fixed_binary(std::string* fixed_binary); + private: + const std::string& _internal_fixed_binary() const; + void _internal_set_fixed_binary(const std::string& value); + std::string* _internal_mutable_fixed_binary(); + public: + + // bytes decimal = 24; + bool has_decimal() const; + private: + bool _internal_has_decimal() const; + public: + void clear_decimal(); + const std::string& decimal() const; + template + void set_decimal(ArgT0&& arg0, ArgT... args); + std::string* mutable_decimal(); + std::string* release_decimal(); + void set_allocated_decimal(std::string* decimal); + private: + const std::string& _internal_decimal() const; + void _internal_set_decimal(const std::string& value); + std::string* _internal_mutable_decimal(); + public: + + // .io.substrait.Expression.Literal.Struct struct = 25; + bool has_struct_() const; + private: + bool _internal_has_struct_() const; + public: + void clear_struct_(); + const ::io::substrait::Expression_Literal_Struct& struct_() const; + ::io::substrait::Expression_Literal_Struct* release_struct_(); + ::io::substrait::Expression_Literal_Struct* mutable_struct_(); + void set_allocated_struct_(::io::substrait::Expression_Literal_Struct* struct_); + private: + const ::io::substrait::Expression_Literal_Struct& _internal_struct_() const; + ::io::substrait::Expression_Literal_Struct* _internal_mutable_struct_(); + public: + void unsafe_arena_set_allocated_struct_( + ::io::substrait::Expression_Literal_Struct* struct_); + ::io::substrait::Expression_Literal_Struct* unsafe_arena_release_struct_(); + + // .io.substrait.Expression.Literal.Map map = 26; + bool has_map() const; + private: + bool _internal_has_map() const; + public: + void clear_map(); + const ::io::substrait::Expression_Literal_Map& map() const; + ::io::substrait::Expression_Literal_Map* release_map(); + ::io::substrait::Expression_Literal_Map* mutable_map(); + void set_allocated_map(::io::substrait::Expression_Literal_Map* map); + private: + const ::io::substrait::Expression_Literal_Map& _internal_map() const; + ::io::substrait::Expression_Literal_Map* _internal_mutable_map(); + public: + void unsafe_arena_set_allocated_map( + ::io::substrait::Expression_Literal_Map* map); + ::io::substrait::Expression_Literal_Map* unsafe_arena_release_map(); + + // fixed64 timestamp_tz = 27; + bool has_timestamp_tz() const; + private: + bool _internal_has_timestamp_tz() const; + public: + void clear_timestamp_tz(); + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_tz() const; + void set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_timestamp_tz() const; + void _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // bytes uuid = 28; + bool has_uuid() const; + private: + bool _internal_has_uuid() const; + public: + void clear_uuid(); + const std::string& uuid() const; + template + void set_uuid(ArgT0&& arg0, ArgT... args); + std::string* mutable_uuid(); + std::string* release_uuid(); + void set_allocated_uuid(std::string* uuid); + private: + const std::string& _internal_uuid() const; + void _internal_set_uuid(const std::string& value); + std::string* _internal_mutable_uuid(); + public: + + // .io.substrait.Type null = 29; + bool has_null() const; + private: + bool _internal_has_null() const; + public: + void clear_null(); + const ::io::substrait::Type& null() const; + ::io::substrait::Type* release_null(); + ::io::substrait::Type* mutable_null(); + void set_allocated_null(::io::substrait::Type* null); + private: + const ::io::substrait::Type& _internal_null() const; + ::io::substrait::Type* _internal_mutable_null(); + public: + void unsafe_arena_set_allocated_null( + ::io::substrait::Type* null); + ::io::substrait::Type* unsafe_arena_release_null(); + + // .io.substrait.Expression.Literal.List list = 30; + bool has_list() const; + private: + bool _internal_has_list() const; + public: + void clear_list(); + const ::io::substrait::Expression_Literal_List& list() const; + ::io::substrait::Expression_Literal_List* release_list(); + ::io::substrait::Expression_Literal_List* mutable_list(); + void set_allocated_list(::io::substrait::Expression_Literal_List* list); + private: + const ::io::substrait::Expression_Literal_List& _internal_list() const; + ::io::substrait::Expression_Literal_List* _internal_mutable_list(); + public: + void unsafe_arena_set_allocated_list( + ::io::substrait::Expression_Literal_List* list); + ::io::substrait::Expression_Literal_List* unsafe_arena_release_list(); + + void clear_literal_type(); + LiteralTypeCase literal_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal) + private: + class _Internal; + void set_has_boolean(); + void set_has_i8(); + void set_has_i16(); + void set_has_i32(); + void set_has_i64(); + void set_has_fp32(); + void set_has_fp64(); + void set_has_string(); + void set_has_binary(); + void set_has_timestamp(); + void set_has_date(); + void set_has_time(); + void set_has_interval_year_to_month(); + void set_has_interval_day_to_second(); + void set_has_fixed_char(); + void set_has_var_char(); + void set_has_fixed_binary(); + void set_has_decimal(); + void set_has_struct_(); + void set_has_map(); + void set_has_timestamp_tz(); + void set_has_uuid(); + void set_has_null(); + void set_has_list(); + + inline bool has_literal_type() const; + inline void clear_has_literal_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union LiteralTypeUnion { + constexpr LiteralTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + bool boolean_; + ::PROTOBUF_NAMESPACE_ID::int32 i8_; + ::PROTOBUF_NAMESPACE_ID::int32 i16_; + ::PROTOBUF_NAMESPACE_ID::int32 i32_; + ::PROTOBUF_NAMESPACE_ID::int64 i64_; + float fp32_; + double fp64_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_; + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_; + ::PROTOBUF_NAMESPACE_ID::uint32 date_; + ::PROTOBUF_NAMESPACE_ID::uint64 time_; + ::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month_; + ::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_char_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr var_char_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_binary_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr decimal_; + ::io::substrait::Expression_Literal_Struct* struct__; + ::io::substrait::Expression_Literal_Map* map_; + ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_tz_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uuid_; + ::io::substrait::Type* null_; + ::io::substrait::Expression_Literal_List* list_; + } literal_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_ScalarFunction PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.ScalarFunction) */ { + public: + inline Expression_ScalarFunction() : Expression_ScalarFunction(nullptr) {} + ~Expression_ScalarFunction() override; + explicit constexpr Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_ScalarFunction(const Expression_ScalarFunction& from); + Expression_ScalarFunction(Expression_ScalarFunction&& from) noexcept + : Expression_ScalarFunction() { + *this = ::std::move(from); + } + + inline Expression_ScalarFunction& operator=(const Expression_ScalarFunction& from) { + CopyFrom(from); + return *this; + } + inline Expression_ScalarFunction& operator=(Expression_ScalarFunction&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_ScalarFunction& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_ScalarFunction* internal_default_instance() { + return reinterpret_cast( + &_Expression_ScalarFunction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(Expression_ScalarFunction& a, Expression_ScalarFunction& b) { + a.Swap(&b); + } + inline void Swap(Expression_ScalarFunction* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_ScalarFunction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_ScalarFunction* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_ScalarFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_ScalarFunction& from); + void MergeFrom(const Expression_ScalarFunction& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_ScalarFunction* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.ScalarFunction"; + } + protected: + explicit Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kArgsFieldNumber = 2, + kIdFieldNumber = 1, + kOutputTypeFieldNumber = 3, + }; + // repeated .io.substrait.Expression args = 2; + int args_size() const; + private: + int _internal_args_size() const; + public: + void clear_args(); + ::io::substrait::Expression* mutable_args(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + mutable_args(); + private: + const ::io::substrait::Expression& _internal_args(int index) const; + ::io::substrait::Expression* _internal_add_args(); + public: + const ::io::substrait::Expression& args(int index) const; + ::io::substrait::Expression* add_args(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + args() const; + + // .io.substrait.Extensions.FunctionId id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const ::io::substrait::Extensions_FunctionId& id() const; + ::io::substrait::Extensions_FunctionId* release_id(); + ::io::substrait::Extensions_FunctionId* mutable_id(); + void set_allocated_id(::io::substrait::Extensions_FunctionId* id); + private: + const ::io::substrait::Extensions_FunctionId& _internal_id() const; + ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); + public: + void unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id); + ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); + + // .io.substrait.Type output_type = 3; + bool has_output_type() const; + private: + bool _internal_has_output_type() const; + public: + void clear_output_type(); + const ::io::substrait::Type& output_type() const; + ::io::substrait::Type* release_output_type(); + ::io::substrait::Type* mutable_output_type(); + void set_allocated_output_type(::io::substrait::Type* output_type); + private: + const ::io::substrait::Type& _internal_output_type() const; + ::io::substrait::Type* _internal_mutable_output_type(); + public: + void unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type); + ::io::substrait::Type* unsafe_arena_release_output_type(); + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.ScalarFunction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > args_; + ::io::substrait::Extensions_FunctionId* id_; + ::io::substrait::Type* output_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_AggregateFunction PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.AggregateFunction) */ { + public: + inline Expression_AggregateFunction() : Expression_AggregateFunction(nullptr) {} + ~Expression_AggregateFunction() override; + explicit constexpr Expression_AggregateFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_AggregateFunction(const Expression_AggregateFunction& from); + Expression_AggregateFunction(Expression_AggregateFunction&& from) noexcept + : Expression_AggregateFunction() { + *this = ::std::move(from); + } + + inline Expression_AggregateFunction& operator=(const Expression_AggregateFunction& from) { + CopyFrom(from); + return *this; + } + inline Expression_AggregateFunction& operator=(Expression_AggregateFunction&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_AggregateFunction& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_AggregateFunction* internal_default_instance() { + return reinterpret_cast( + &_Expression_AggregateFunction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(Expression_AggregateFunction& a, Expression_AggregateFunction& b) { + a.Swap(&b); + } + inline void Swap(Expression_AggregateFunction* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_AggregateFunction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_AggregateFunction* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_AggregateFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_AggregateFunction& from); + void MergeFrom(const Expression_AggregateFunction& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_AggregateFunction* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.AggregateFunction"; + } + protected: + explicit Expression_AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kArgsFieldNumber = 2, + kSortsFieldNumber = 3, + kIdFieldNumber = 1, + kOutputTypeFieldNumber = 5, + kPhaseFieldNumber = 4, + }; + // repeated .io.substrait.Expression args = 2; + int args_size() const; + private: + int _internal_args_size() const; + public: + void clear_args(); + ::io::substrait::Expression* mutable_args(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + mutable_args(); + private: + const ::io::substrait::Expression& _internal_args(int index) const; + ::io::substrait::Expression* _internal_add_args(); + public: + const ::io::substrait::Expression& args(int index) const; + ::io::substrait::Expression* add_args(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + args() const; + + // repeated .io.substrait.Expression.SortField sorts = 3; + int sorts_size() const; + private: + int _internal_sorts_size() const; + public: + void clear_sorts(); + ::io::substrait::Expression_SortField* mutable_sorts(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* + mutable_sorts(); + private: + const ::io::substrait::Expression_SortField& _internal_sorts(int index) const; + ::io::substrait::Expression_SortField* _internal_add_sorts(); + public: + const ::io::substrait::Expression_SortField& sorts(int index) const; + ::io::substrait::Expression_SortField* add_sorts(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& + sorts() const; + + // .io.substrait.Extensions.FunctionId id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const ::io::substrait::Extensions_FunctionId& id() const; + ::io::substrait::Extensions_FunctionId* release_id(); + ::io::substrait::Extensions_FunctionId* mutable_id(); + void set_allocated_id(::io::substrait::Extensions_FunctionId* id); + private: + const ::io::substrait::Extensions_FunctionId& _internal_id() const; + ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); + public: + void unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id); + ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); + + // .io.substrait.Type output_type = 5; + bool has_output_type() const; + private: + bool _internal_has_output_type() const; + public: + void clear_output_type(); + const ::io::substrait::Type& output_type() const; + ::io::substrait::Type* release_output_type(); + ::io::substrait::Type* mutable_output_type(); + void set_allocated_output_type(::io::substrait::Type* output_type); + private: + const ::io::substrait::Type& _internal_output_type() const; + ::io::substrait::Type* _internal_mutable_output_type(); + public: + void unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type); + ::io::substrait::Type* unsafe_arena_release_output_type(); + + // .io.substrait.Expression.AggregationPhase phase = 4; + void clear_phase(); + ::io::substrait::Expression_AggregationPhase phase() const; + void set_phase(::io::substrait::Expression_AggregationPhase value); + private: + ::io::substrait::Expression_AggregationPhase _internal_phase() const; + void _internal_set_phase(::io::substrait::Expression_AggregationPhase value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.AggregateFunction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > args_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField > sorts_; + ::io::substrait::Extensions_FunctionId* id_; + ::io::substrait::Type* output_type_; + int phase_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound.Preceding) */ { + public: + inline Expression_WindowFunction_Bound_Preceding() : Expression_WindowFunction_Bound_Preceding(nullptr) {} + ~Expression_WindowFunction_Bound_Preceding() override; + explicit constexpr Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from); + Expression_WindowFunction_Bound_Preceding(Expression_WindowFunction_Bound_Preceding&& from) noexcept + : Expression_WindowFunction_Bound_Preceding() { + *this = ::std::move(from); + } + + inline Expression_WindowFunction_Bound_Preceding& operator=(const Expression_WindowFunction_Bound_Preceding& from) { + CopyFrom(from); + return *this; + } + inline Expression_WindowFunction_Bound_Preceding& operator=(Expression_WindowFunction_Bound_Preceding&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_WindowFunction_Bound_Preceding& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_WindowFunction_Bound_Preceding* internal_default_instance() { + return reinterpret_cast( + &_Expression_WindowFunction_Bound_Preceding_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(Expression_WindowFunction_Bound_Preceding& a, Expression_WindowFunction_Bound_Preceding& b) { + a.Swap(&b); + } + inline void Swap(Expression_WindowFunction_Bound_Preceding* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_WindowFunction_Bound_Preceding* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_WindowFunction_Bound_Preceding* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_WindowFunction_Bound_Preceding* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_WindowFunction_Bound_Preceding& from); + void MergeFrom(const Expression_WindowFunction_Bound_Preceding& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_WindowFunction_Bound_Preceding* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.WindowFunction.Bound.Preceding"; + } + protected: + explicit Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOffsetFieldNumber = 1, + }; + // int64 offset = 1; + void clear_offset(); + ::PROTOBUF_NAMESPACE_ID::int64 offset() const; + void set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_offset() const; + void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction.Bound.Preceding) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::int64 offset_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound.Following) */ { + public: + inline Expression_WindowFunction_Bound_Following() : Expression_WindowFunction_Bound_Following(nullptr) {} + ~Expression_WindowFunction_Bound_Following() override; + explicit constexpr Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_WindowFunction_Bound_Following(const Expression_WindowFunction_Bound_Following& from); + Expression_WindowFunction_Bound_Following(Expression_WindowFunction_Bound_Following&& from) noexcept + : Expression_WindowFunction_Bound_Following() { + *this = ::std::move(from); + } + + inline Expression_WindowFunction_Bound_Following& operator=(const Expression_WindowFunction_Bound_Following& from) { + CopyFrom(from); + return *this; + } + inline Expression_WindowFunction_Bound_Following& operator=(Expression_WindowFunction_Bound_Following&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_WindowFunction_Bound_Following& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_WindowFunction_Bound_Following* internal_default_instance() { + return reinterpret_cast( + &_Expression_WindowFunction_Bound_Following_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(Expression_WindowFunction_Bound_Following& a, Expression_WindowFunction_Bound_Following& b) { + a.Swap(&b); + } + inline void Swap(Expression_WindowFunction_Bound_Following* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_WindowFunction_Bound_Following* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_WindowFunction_Bound_Following* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_WindowFunction_Bound_Following* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_WindowFunction_Bound_Following& from); + void MergeFrom(const Expression_WindowFunction_Bound_Following& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_WindowFunction_Bound_Following* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.WindowFunction.Bound.Following"; + } + protected: + explicit Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOffsetFieldNumber = 1, + }; + // int64 offset = 1; + void clear_offset(); + ::PROTOBUF_NAMESPACE_ID::int64 offset() const; + void set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_offset() const; + void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction.Bound.Following) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::int64 offset_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound.CurrentRow) */ { + public: + inline Expression_WindowFunction_Bound_CurrentRow() : Expression_WindowFunction_Bound_CurrentRow(nullptr) {} + ~Expression_WindowFunction_Bound_CurrentRow() override; + explicit constexpr Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_WindowFunction_Bound_CurrentRow(const Expression_WindowFunction_Bound_CurrentRow& from); + Expression_WindowFunction_Bound_CurrentRow(Expression_WindowFunction_Bound_CurrentRow&& from) noexcept + : Expression_WindowFunction_Bound_CurrentRow() { + *this = ::std::move(from); + } + + inline Expression_WindowFunction_Bound_CurrentRow& operator=(const Expression_WindowFunction_Bound_CurrentRow& from) { + CopyFrom(from); + return *this; + } + inline Expression_WindowFunction_Bound_CurrentRow& operator=(Expression_WindowFunction_Bound_CurrentRow&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_WindowFunction_Bound_CurrentRow& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_WindowFunction_Bound_CurrentRow* internal_default_instance() { + return reinterpret_cast( + &_Expression_WindowFunction_Bound_CurrentRow_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(Expression_WindowFunction_Bound_CurrentRow& a, Expression_WindowFunction_Bound_CurrentRow& b) { + a.Swap(&b); + } + inline void Swap(Expression_WindowFunction_Bound_CurrentRow* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_WindowFunction_Bound_CurrentRow* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_WindowFunction_Bound_CurrentRow* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_WindowFunction_Bound_CurrentRow* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_WindowFunction_Bound_CurrentRow& from); + void MergeFrom(const Expression_WindowFunction_Bound_CurrentRow& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_WindowFunction_Bound_CurrentRow* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.WindowFunction.Bound.CurrentRow"; + } + protected: + explicit Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound.Unbounded) */ { + public: + inline Expression_WindowFunction_Bound_Unbounded() : Expression_WindowFunction_Bound_Unbounded(nullptr) {} + ~Expression_WindowFunction_Bound_Unbounded() override; + explicit constexpr Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_WindowFunction_Bound_Unbounded(const Expression_WindowFunction_Bound_Unbounded& from); + Expression_WindowFunction_Bound_Unbounded(Expression_WindowFunction_Bound_Unbounded&& from) noexcept + : Expression_WindowFunction_Bound_Unbounded() { + *this = ::std::move(from); + } + + inline Expression_WindowFunction_Bound_Unbounded& operator=(const Expression_WindowFunction_Bound_Unbounded& from) { + CopyFrom(from); + return *this; + } + inline Expression_WindowFunction_Bound_Unbounded& operator=(Expression_WindowFunction_Bound_Unbounded&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_WindowFunction_Bound_Unbounded& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_WindowFunction_Bound_Unbounded* internal_default_instance() { + return reinterpret_cast( + &_Expression_WindowFunction_Bound_Unbounded_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(Expression_WindowFunction_Bound_Unbounded& a, Expression_WindowFunction_Bound_Unbounded& b) { + a.Swap(&b); + } + inline void Swap(Expression_WindowFunction_Bound_Unbounded* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_WindowFunction_Bound_Unbounded* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_WindowFunction_Bound_Unbounded* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_WindowFunction_Bound_Unbounded* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_WindowFunction_Bound_Unbounded& from); + void MergeFrom(const Expression_WindowFunction_Bound_Unbounded& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_WindowFunction_Bound_Unbounded* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.WindowFunction.Bound.Unbounded"; + } + protected: + explicit Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction.Bound.Unbounded) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_WindowFunction_Bound PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound) */ { + public: + inline Expression_WindowFunction_Bound() : Expression_WindowFunction_Bound(nullptr) {} + ~Expression_WindowFunction_Bound() override; + explicit constexpr Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_WindowFunction_Bound(const Expression_WindowFunction_Bound& from); + Expression_WindowFunction_Bound(Expression_WindowFunction_Bound&& from) noexcept + : Expression_WindowFunction_Bound() { + *this = ::std::move(from); + } + + inline Expression_WindowFunction_Bound& operator=(const Expression_WindowFunction_Bound& from) { + CopyFrom(from); + return *this; + } + inline Expression_WindowFunction_Bound& operator=(Expression_WindowFunction_Bound&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_WindowFunction_Bound& default_instance() { + return *internal_default_instance(); + } + enum KindCase { + kPreceding = 1, + kFollowing = 2, + kCurrentRow = 3, + kUnbounded = 4, + KIND_NOT_SET = 0, + }; + + static inline const Expression_WindowFunction_Bound* internal_default_instance() { + return reinterpret_cast( + &_Expression_WindowFunction_Bound_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(Expression_WindowFunction_Bound& a, Expression_WindowFunction_Bound& b) { + a.Swap(&b); + } + inline void Swap(Expression_WindowFunction_Bound* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_WindowFunction_Bound* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_WindowFunction_Bound* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_WindowFunction_Bound* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_WindowFunction_Bound& from); + void MergeFrom(const Expression_WindowFunction_Bound& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_WindowFunction_Bound* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.WindowFunction.Bound"; + } + protected: + explicit Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_WindowFunction_Bound_Preceding Preceding; + typedef Expression_WindowFunction_Bound_Following Following; + typedef Expression_WindowFunction_Bound_CurrentRow CurrentRow; + typedef Expression_WindowFunction_Bound_Unbounded Unbounded; + + // accessors ------------------------------------------------------- + + enum : int { + kPrecedingFieldNumber = 1, + kFollowingFieldNumber = 2, + kCurrentRowFieldNumber = 3, + kUnboundedFieldNumber = 4, + }; + // .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; + bool has_preceding() const; + private: + bool _internal_has_preceding() const; + public: + void clear_preceding(); + const ::io::substrait::Expression_WindowFunction_Bound_Preceding& preceding() const; + ::io::substrait::Expression_WindowFunction_Bound_Preceding* release_preceding(); + ::io::substrait::Expression_WindowFunction_Bound_Preceding* mutable_preceding(); + void set_allocated_preceding(::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding); + private: + const ::io::substrait::Expression_WindowFunction_Bound_Preceding& _internal_preceding() const; + ::io::substrait::Expression_WindowFunction_Bound_Preceding* _internal_mutable_preceding(); + public: + void unsafe_arena_set_allocated_preceding( + ::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding); + ::io::substrait::Expression_WindowFunction_Bound_Preceding* unsafe_arena_release_preceding(); + + // .io.substrait.Expression.WindowFunction.Bound.Following following = 2; + bool has_following() const; + private: + bool _internal_has_following() const; + public: + void clear_following(); + const ::io::substrait::Expression_WindowFunction_Bound_Following& following() const; + ::io::substrait::Expression_WindowFunction_Bound_Following* release_following(); + ::io::substrait::Expression_WindowFunction_Bound_Following* mutable_following(); + void set_allocated_following(::io::substrait::Expression_WindowFunction_Bound_Following* following); + private: + const ::io::substrait::Expression_WindowFunction_Bound_Following& _internal_following() const; + ::io::substrait::Expression_WindowFunction_Bound_Following* _internal_mutable_following(); + public: + void unsafe_arena_set_allocated_following( + ::io::substrait::Expression_WindowFunction_Bound_Following* following); + ::io::substrait::Expression_WindowFunction_Bound_Following* unsafe_arena_release_following(); + + // .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; + bool has_current_row() const; + private: + bool _internal_has_current_row() const; + public: + void clear_current_row(); + const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row() const; + ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* release_current_row(); + ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* mutable_current_row(); + void set_allocated_current_row(::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row); + private: + const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& _internal_current_row() const; + ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* _internal_mutable_current_row(); + public: + void unsafe_arena_set_allocated_current_row( + ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row); + ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* unsafe_arena_release_current_row(); + + // .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; + bool has_unbounded() const; + private: + bool _internal_has_unbounded() const; + public: + void clear_unbounded(); + const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded() const; + ::io::substrait::Expression_WindowFunction_Bound_Unbounded* release_unbounded(); + ::io::substrait::Expression_WindowFunction_Bound_Unbounded* mutable_unbounded(); + void set_allocated_unbounded(::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded); + private: + const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& _internal_unbounded() const; + ::io::substrait::Expression_WindowFunction_Bound_Unbounded* _internal_mutable_unbounded(); + public: + void unsafe_arena_set_allocated_unbounded( + ::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded); + ::io::substrait::Expression_WindowFunction_Bound_Unbounded* unsafe_arena_release_unbounded(); + + void clear_kind(); + KindCase kind_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction.Bound) + private: + class _Internal; + void set_has_preceding(); + void set_has_following(); + void set_has_current_row(); + void set_has_unbounded(); + + inline bool has_kind() const; + inline void clear_has_kind(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union KindUnion { + constexpr KindUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding_; + ::io::substrait::Expression_WindowFunction_Bound_Following* following_; + ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row_; + ::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded_; + } kind_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_WindowFunction PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction) */ { + public: + inline Expression_WindowFunction() : Expression_WindowFunction(nullptr) {} + ~Expression_WindowFunction() override; + explicit constexpr Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_WindowFunction(const Expression_WindowFunction& from); + Expression_WindowFunction(Expression_WindowFunction&& from) noexcept + : Expression_WindowFunction() { + *this = ::std::move(from); + } + + inline Expression_WindowFunction& operator=(const Expression_WindowFunction& from) { + CopyFrom(from); + return *this; + } + inline Expression_WindowFunction& operator=(Expression_WindowFunction&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_WindowFunction& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_WindowFunction* internal_default_instance() { + return reinterpret_cast( + &_Expression_WindowFunction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(Expression_WindowFunction& a, Expression_WindowFunction& b) { + a.Swap(&b); + } + inline void Swap(Expression_WindowFunction* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_WindowFunction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_WindowFunction* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_WindowFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_WindowFunction& from); + void MergeFrom(const Expression_WindowFunction& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_WindowFunction* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.WindowFunction"; + } + protected: + explicit Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_WindowFunction_Bound Bound; + + // accessors ------------------------------------------------------- + + enum : int { + kPartitionsFieldNumber = 2, + kSortsFieldNumber = 3, + kArgsFieldNumber = 8, + kIdFieldNumber = 1, + kUpperBoundFieldNumber = 4, + kLowerBoundFieldNumber = 5, + kOutputTypeFieldNumber = 7, + kPhaseFieldNumber = 6, + }; + // repeated .io.substrait.Expression partitions = 2; + int partitions_size() const; + private: + int _internal_partitions_size() const; + public: + void clear_partitions(); + ::io::substrait::Expression* mutable_partitions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + mutable_partitions(); + private: + const ::io::substrait::Expression& _internal_partitions(int index) const; + ::io::substrait::Expression* _internal_add_partitions(); + public: + const ::io::substrait::Expression& partitions(int index) const; + ::io::substrait::Expression* add_partitions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + partitions() const; + + // repeated .io.substrait.Expression.SortField sorts = 3; + int sorts_size() const; + private: + int _internal_sorts_size() const; + public: + void clear_sorts(); + ::io::substrait::Expression_SortField* mutable_sorts(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* + mutable_sorts(); + private: + const ::io::substrait::Expression_SortField& _internal_sorts(int index) const; + ::io::substrait::Expression_SortField* _internal_add_sorts(); + public: + const ::io::substrait::Expression_SortField& sorts(int index) const; + ::io::substrait::Expression_SortField* add_sorts(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& + sorts() const; + + // repeated .io.substrait.Expression args = 8; + int args_size() const; + private: + int _internal_args_size() const; + public: + void clear_args(); + ::io::substrait::Expression* mutable_args(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + mutable_args(); + private: + const ::io::substrait::Expression& _internal_args(int index) const; + ::io::substrait::Expression* _internal_add_args(); + public: + const ::io::substrait::Expression& args(int index) const; + ::io::substrait::Expression* add_args(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + args() const; + + // .io.substrait.Extensions.FunctionId id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const ::io::substrait::Extensions_FunctionId& id() const; + ::io::substrait::Extensions_FunctionId* release_id(); + ::io::substrait::Extensions_FunctionId* mutable_id(); + void set_allocated_id(::io::substrait::Extensions_FunctionId* id); + private: + const ::io::substrait::Extensions_FunctionId& _internal_id() const; + ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); + public: + void unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id); + ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); + + // .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; + bool has_upper_bound() const; + private: + bool _internal_has_upper_bound() const; + public: + void clear_upper_bound(); + const ::io::substrait::Expression_WindowFunction_Bound& upper_bound() const; + ::io::substrait::Expression_WindowFunction_Bound* release_upper_bound(); + ::io::substrait::Expression_WindowFunction_Bound* mutable_upper_bound(); + void set_allocated_upper_bound(::io::substrait::Expression_WindowFunction_Bound* upper_bound); + private: + const ::io::substrait::Expression_WindowFunction_Bound& _internal_upper_bound() const; + ::io::substrait::Expression_WindowFunction_Bound* _internal_mutable_upper_bound(); + public: + void unsafe_arena_set_allocated_upper_bound( + ::io::substrait::Expression_WindowFunction_Bound* upper_bound); + ::io::substrait::Expression_WindowFunction_Bound* unsafe_arena_release_upper_bound(); + + // .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; + bool has_lower_bound() const; + private: + bool _internal_has_lower_bound() const; + public: + void clear_lower_bound(); + const ::io::substrait::Expression_WindowFunction_Bound& lower_bound() const; + ::io::substrait::Expression_WindowFunction_Bound* release_lower_bound(); + ::io::substrait::Expression_WindowFunction_Bound* mutable_lower_bound(); + void set_allocated_lower_bound(::io::substrait::Expression_WindowFunction_Bound* lower_bound); + private: + const ::io::substrait::Expression_WindowFunction_Bound& _internal_lower_bound() const; + ::io::substrait::Expression_WindowFunction_Bound* _internal_mutable_lower_bound(); + public: + void unsafe_arena_set_allocated_lower_bound( + ::io::substrait::Expression_WindowFunction_Bound* lower_bound); + ::io::substrait::Expression_WindowFunction_Bound* unsafe_arena_release_lower_bound(); + + // .io.substrait.Type output_type = 7; + bool has_output_type() const; + private: + bool _internal_has_output_type() const; + public: + void clear_output_type(); + const ::io::substrait::Type& output_type() const; + ::io::substrait::Type* release_output_type(); + ::io::substrait::Type* mutable_output_type(); + void set_allocated_output_type(::io::substrait::Type* output_type); + private: + const ::io::substrait::Type& _internal_output_type() const; + ::io::substrait::Type* _internal_mutable_output_type(); + public: + void unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type); + ::io::substrait::Type* unsafe_arena_release_output_type(); + + // .io.substrait.Expression.AggregationPhase phase = 6; + void clear_phase(); + ::io::substrait::Expression_AggregationPhase phase() const; + void set_phase(::io::substrait::Expression_AggregationPhase value); + private: + ::io::substrait::Expression_AggregationPhase _internal_phase() const; + void _internal_set_phase(::io::substrait::Expression_AggregationPhase value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > partitions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField > sorts_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > args_; + ::io::substrait::Extensions_FunctionId* id_; + ::io::substrait::Expression_WindowFunction_Bound* upper_bound_; + ::io::substrait::Expression_WindowFunction_Bound* lower_bound_; + ::io::substrait::Type* output_type_; + int phase_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_SortField PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.SortField) */ { + public: + inline Expression_SortField() : Expression_SortField(nullptr) {} + ~Expression_SortField() override; + explicit constexpr Expression_SortField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_SortField(const Expression_SortField& from); + Expression_SortField(Expression_SortField&& from) noexcept + : Expression_SortField() { + *this = ::std::move(from); + } + + inline Expression_SortField& operator=(const Expression_SortField& from) { + CopyFrom(from); + return *this; + } + inline Expression_SortField& operator=(Expression_SortField&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_SortField& default_instance() { + return *internal_default_instance(); + } + enum SortKindCase { + kDirection = 2, + kComparisonFunction = 3, + SORT_KIND_NOT_SET = 0, + }; + + static inline const Expression_SortField* internal_default_instance() { + return reinterpret_cast( + &_Expression_SortField_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(Expression_SortField& a, Expression_SortField& b) { + a.Swap(&b); + } + inline void Swap(Expression_SortField* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_SortField* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_SortField* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_SortField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_SortField& from); + void MergeFrom(const Expression_SortField& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_SortField* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.SortField"; + } + protected: + explicit Expression_SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_SortField_SortDirection SortDirection; + static constexpr SortDirection UNKNOWN = + Expression_SortField_SortDirection_UNKNOWN; + static constexpr SortDirection ASC_NULLS_FIRST = + Expression_SortField_SortDirection_ASC_NULLS_FIRST; + static constexpr SortDirection ASC_NULLS_LAST = + Expression_SortField_SortDirection_ASC_NULLS_LAST; + static constexpr SortDirection DESC_NULLS_FIRST = + Expression_SortField_SortDirection_DESC_NULLS_FIRST; + static constexpr SortDirection DESC_NULLS_LAST = + Expression_SortField_SortDirection_DESC_NULLS_LAST; + static constexpr SortDirection CLUSTERED = + Expression_SortField_SortDirection_CLUSTERED; + static inline bool SortDirection_IsValid(int value) { + return Expression_SortField_SortDirection_IsValid(value); + } + static constexpr SortDirection SortDirection_MIN = + Expression_SortField_SortDirection_SortDirection_MIN; + static constexpr SortDirection SortDirection_MAX = + Expression_SortField_SortDirection_SortDirection_MAX; + static constexpr int SortDirection_ARRAYSIZE = + Expression_SortField_SortDirection_SortDirection_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + SortDirection_descriptor() { + return Expression_SortField_SortDirection_descriptor(); + } + template + static inline const std::string& SortDirection_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SortDirection_Name."); + return Expression_SortField_SortDirection_Name(enum_t_value); + } + static inline bool SortDirection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + SortDirection* value) { + return Expression_SortField_SortDirection_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kExprFieldNumber = 1, + kDirectionFieldNumber = 2, + kComparisonFunctionFieldNumber = 3, + }; + // .io.substrait.Expression expr = 1; + bool has_expr() const; + private: + bool _internal_has_expr() const; + public: + void clear_expr(); + const ::io::substrait::Expression& expr() const; + ::io::substrait::Expression* release_expr(); + ::io::substrait::Expression* mutable_expr(); + void set_allocated_expr(::io::substrait::Expression* expr); + private: + const ::io::substrait::Expression& _internal_expr() const; + ::io::substrait::Expression* _internal_mutable_expr(); + public: + void unsafe_arena_set_allocated_expr( + ::io::substrait::Expression* expr); + ::io::substrait::Expression* unsafe_arena_release_expr(); + + // .io.substrait.Expression.SortField.SortDirection direction = 2; + bool has_direction() const; + private: + bool _internal_has_direction() const; + public: + void clear_direction(); + ::io::substrait::Expression_SortField_SortDirection direction() const; + void set_direction(::io::substrait::Expression_SortField_SortDirection value); + private: + ::io::substrait::Expression_SortField_SortDirection _internal_direction() const; + void _internal_set_direction(::io::substrait::Expression_SortField_SortDirection value); + public: + + // .io.substrait.Extensions.FunctionId comparison_function = 3; + bool has_comparison_function() const; + private: + bool _internal_has_comparison_function() const; + public: + void clear_comparison_function(); + const ::io::substrait::Extensions_FunctionId& comparison_function() const; + ::io::substrait::Extensions_FunctionId* release_comparison_function(); + ::io::substrait::Extensions_FunctionId* mutable_comparison_function(); + void set_allocated_comparison_function(::io::substrait::Extensions_FunctionId* comparison_function); + private: + const ::io::substrait::Extensions_FunctionId& _internal_comparison_function() const; + ::io::substrait::Extensions_FunctionId* _internal_mutable_comparison_function(); + public: + void unsafe_arena_set_allocated_comparison_function( + ::io::substrait::Extensions_FunctionId* comparison_function); + ::io::substrait::Extensions_FunctionId* unsafe_arena_release_comparison_function(); + + void clear_sort_kind(); + SortKindCase sort_kind_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression.SortField) + private: + class _Internal; + void set_has_direction(); + void set_has_comparison_function(); + + inline bool has_sort_kind() const; + inline void clear_has_sort_kind(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression* expr_; + union SortKindUnion { + constexpr SortKindUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + int direction_; + ::io::substrait::Extensions_FunctionId* comparison_function_; + } sort_kind_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_IfThen_IfClause PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.IfThen.IfClause) */ { + public: + inline Expression_IfThen_IfClause() : Expression_IfThen_IfClause(nullptr) {} + ~Expression_IfThen_IfClause() override; + explicit constexpr Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from); + Expression_IfThen_IfClause(Expression_IfThen_IfClause&& from) noexcept + : Expression_IfThen_IfClause() { + *this = ::std::move(from); + } + + inline Expression_IfThen_IfClause& operator=(const Expression_IfThen_IfClause& from) { + CopyFrom(from); + return *this; + } + inline Expression_IfThen_IfClause& operator=(Expression_IfThen_IfClause&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_IfThen_IfClause& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_IfThen_IfClause* internal_default_instance() { + return reinterpret_cast( + &_Expression_IfThen_IfClause_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(Expression_IfThen_IfClause& a, Expression_IfThen_IfClause& b) { + a.Swap(&b); + } + inline void Swap(Expression_IfThen_IfClause* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_IfThen_IfClause* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_IfThen_IfClause* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_IfThen_IfClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_IfThen_IfClause& from); + void MergeFrom(const Expression_IfThen_IfClause& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_IfThen_IfClause* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.IfThen.IfClause"; + } + protected: + explicit Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIfFieldNumber = 1, + kThenFieldNumber = 2, + }; + // .io.substrait.Expression if = 1; + bool has_if_() const; + private: + bool _internal_has_if_() const; + public: + void clear_if_(); + const ::io::substrait::Expression& if_() const; + ::io::substrait::Expression* release_if_(); + ::io::substrait::Expression* mutable_if_(); + void set_allocated_if_(::io::substrait::Expression* if_); + private: + const ::io::substrait::Expression& _internal_if_() const; + ::io::substrait::Expression* _internal_mutable_if_(); + public: + void unsafe_arena_set_allocated_if_( + ::io::substrait::Expression* if_); + ::io::substrait::Expression* unsafe_arena_release_if_(); + + // .io.substrait.Expression then = 2; + bool has_then() const; + private: + bool _internal_has_then() const; + public: + void clear_then(); + const ::io::substrait::Expression& then() const; + ::io::substrait::Expression* release_then(); + ::io::substrait::Expression* mutable_then(); + void set_allocated_then(::io::substrait::Expression* then); + private: + const ::io::substrait::Expression& _internal_then() const; + ::io::substrait::Expression* _internal_mutable_then(); + public: + void unsafe_arena_set_allocated_then( + ::io::substrait::Expression* then); + ::io::substrait::Expression* unsafe_arena_release_then(); + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.IfThen.IfClause) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression* if__; + ::io::substrait::Expression* then_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_IfThen PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.IfThen) */ { + public: + inline Expression_IfThen() : Expression_IfThen(nullptr) {} + ~Expression_IfThen() override; + explicit constexpr Expression_IfThen(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_IfThen(const Expression_IfThen& from); + Expression_IfThen(Expression_IfThen&& from) noexcept + : Expression_IfThen() { + *this = ::std::move(from); + } + + inline Expression_IfThen& operator=(const Expression_IfThen& from) { + CopyFrom(from); + return *this; + } + inline Expression_IfThen& operator=(Expression_IfThen&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_IfThen& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_IfThen* internal_default_instance() { + return reinterpret_cast( + &_Expression_IfThen_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(Expression_IfThen& a, Expression_IfThen& b) { + a.Swap(&b); + } + inline void Swap(Expression_IfThen* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_IfThen* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_IfThen* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_IfThen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_IfThen& from); + void MergeFrom(const Expression_IfThen& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_IfThen* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.IfThen"; + } + protected: + explicit Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_IfThen_IfClause IfClause; + + // accessors ------------------------------------------------------- + + enum : int { + kIfsFieldNumber = 1, + kElseFieldNumber = 2, + }; + // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + int ifs_size() const; + private: + int _internal_ifs_size() const; + public: + void clear_ifs(); + ::io::substrait::Expression_IfThen_IfClause* mutable_ifs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >* + mutable_ifs(); + private: + const ::io::substrait::Expression_IfThen_IfClause& _internal_ifs(int index) const; + ::io::substrait::Expression_IfThen_IfClause* _internal_add_ifs(); + public: + const ::io::substrait::Expression_IfThen_IfClause& ifs(int index) const; + ::io::substrait::Expression_IfThen_IfClause* add_ifs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >& + ifs() const; + + // .io.substrait.Expression else = 2; + bool has_else_() const; + private: + bool _internal_has_else_() const; + public: + void clear_else_(); + const ::io::substrait::Expression& else_() const; + ::io::substrait::Expression* release_else_(); + ::io::substrait::Expression* mutable_else_(); + void set_allocated_else_(::io::substrait::Expression* else_); + private: + const ::io::substrait::Expression& _internal_else_() const; + ::io::substrait::Expression* _internal_mutable_else_(); + public: + void unsafe_arena_set_allocated_else_( + ::io::substrait::Expression* else_); + ::io::substrait::Expression* unsafe_arena_release_else_(); + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.IfThen) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause > ifs_; + ::io::substrait::Expression* else__; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.SwitchExpression.IfValue) */ { + public: + inline Expression_SwitchExpression_IfValue() : Expression_SwitchExpression_IfValue(nullptr) {} + ~Expression_SwitchExpression_IfValue() override; + explicit constexpr Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_SwitchExpression_IfValue(const Expression_SwitchExpression_IfValue& from); + Expression_SwitchExpression_IfValue(Expression_SwitchExpression_IfValue&& from) noexcept + : Expression_SwitchExpression_IfValue() { + *this = ::std::move(from); + } + + inline Expression_SwitchExpression_IfValue& operator=(const Expression_SwitchExpression_IfValue& from) { + CopyFrom(from); + return *this; + } + inline Expression_SwitchExpression_IfValue& operator=(Expression_SwitchExpression_IfValue&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_SwitchExpression_IfValue& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_SwitchExpression_IfValue* internal_default_instance() { + return reinterpret_cast( + &_Expression_SwitchExpression_IfValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(Expression_SwitchExpression_IfValue& a, Expression_SwitchExpression_IfValue& b) { + a.Swap(&b); + } + inline void Swap(Expression_SwitchExpression_IfValue* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_SwitchExpression_IfValue* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_SwitchExpression_IfValue* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_SwitchExpression_IfValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_SwitchExpression_IfValue& from); + void MergeFrom(const Expression_SwitchExpression_IfValue& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_SwitchExpression_IfValue* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.SwitchExpression.IfValue"; + } + protected: + explicit Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIfFieldNumber = 1, + kThenFieldNumber = 2, + }; + // .io.substrait.Expression if = 1; + bool has_if_() const; + private: + bool _internal_has_if_() const; + public: + void clear_if_(); + const ::io::substrait::Expression& if_() const; + ::io::substrait::Expression* release_if_(); + ::io::substrait::Expression* mutable_if_(); + void set_allocated_if_(::io::substrait::Expression* if_); + private: + const ::io::substrait::Expression& _internal_if_() const; + ::io::substrait::Expression* _internal_mutable_if_(); + public: + void unsafe_arena_set_allocated_if_( + ::io::substrait::Expression* if_); + ::io::substrait::Expression* unsafe_arena_release_if_(); + + // .io.substrait.Expression then = 2; + bool has_then() const; + private: + bool _internal_has_then() const; + public: + void clear_then(); + const ::io::substrait::Expression& then() const; + ::io::substrait::Expression* release_then(); + ::io::substrait::Expression* mutable_then(); + void set_allocated_then(::io::substrait::Expression* then); + private: + const ::io::substrait::Expression& _internal_then() const; + ::io::substrait::Expression* _internal_mutable_then(); + public: + void unsafe_arena_set_allocated_then( + ::io::substrait::Expression* then); + ::io::substrait::Expression* unsafe_arena_release_then(); + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.SwitchExpression.IfValue) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression* if__; + ::io::substrait::Expression* then_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_SwitchExpression PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.SwitchExpression) */ { + public: + inline Expression_SwitchExpression() : Expression_SwitchExpression(nullptr) {} + ~Expression_SwitchExpression() override; + explicit constexpr Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_SwitchExpression(const Expression_SwitchExpression& from); + Expression_SwitchExpression(Expression_SwitchExpression&& from) noexcept + : Expression_SwitchExpression() { + *this = ::std::move(from); + } + + inline Expression_SwitchExpression& operator=(const Expression_SwitchExpression& from) { + CopyFrom(from); + return *this; + } + inline Expression_SwitchExpression& operator=(Expression_SwitchExpression&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_SwitchExpression& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_SwitchExpression* internal_default_instance() { + return reinterpret_cast( + &_Expression_SwitchExpression_default_instance_); + } + static constexpr int kIndexInFileMessages = + 21; + + friend void swap(Expression_SwitchExpression& a, Expression_SwitchExpression& b) { + a.Swap(&b); + } + inline void Swap(Expression_SwitchExpression* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_SwitchExpression* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_SwitchExpression* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_SwitchExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_SwitchExpression& from); + void MergeFrom(const Expression_SwitchExpression& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_SwitchExpression* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.SwitchExpression"; + } + protected: + explicit Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_SwitchExpression_IfValue IfValue; + + // accessors ------------------------------------------------------- + + enum : int { + kIfsFieldNumber = 1, + kElseFieldNumber = 2, + }; + // repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; + int ifs_size() const; + private: + int _internal_ifs_size() const; + public: + void clear_ifs(); + ::io::substrait::Expression_SwitchExpression_IfValue* mutable_ifs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >* + mutable_ifs(); + private: + const ::io::substrait::Expression_SwitchExpression_IfValue& _internal_ifs(int index) const; + ::io::substrait::Expression_SwitchExpression_IfValue* _internal_add_ifs(); + public: + const ::io::substrait::Expression_SwitchExpression_IfValue& ifs(int index) const; + ::io::substrait::Expression_SwitchExpression_IfValue* add_ifs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >& + ifs() const; + + // .io.substrait.Expression else = 2; + bool has_else_() const; + private: + bool _internal_has_else_() const; + public: + void clear_else_(); + const ::io::substrait::Expression& else_() const; + ::io::substrait::Expression* release_else_(); + ::io::substrait::Expression* mutable_else_(); + void set_allocated_else_(::io::substrait::Expression* else_); + private: + const ::io::substrait::Expression& _internal_else_() const; + ::io::substrait::Expression* _internal_mutable_else_(); + public: + void unsafe_arena_set_allocated_else_( + ::io::substrait::Expression* else_); + ::io::substrait::Expression* unsafe_arena_release_else_(); + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.SwitchExpression) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue > ifs_; + ::io::substrait::Expression* else__; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_SingularOrList PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.SingularOrList) */ { + public: + inline Expression_SingularOrList() : Expression_SingularOrList(nullptr) {} + ~Expression_SingularOrList() override; + explicit constexpr Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_SingularOrList(const Expression_SingularOrList& from); + Expression_SingularOrList(Expression_SingularOrList&& from) noexcept + : Expression_SingularOrList() { + *this = ::std::move(from); + } + + inline Expression_SingularOrList& operator=(const Expression_SingularOrList& from) { + CopyFrom(from); + return *this; + } + inline Expression_SingularOrList& operator=(Expression_SingularOrList&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_SingularOrList& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_SingularOrList* internal_default_instance() { + return reinterpret_cast( + &_Expression_SingularOrList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(Expression_SingularOrList& a, Expression_SingularOrList& b) { + a.Swap(&b); + } + inline void Swap(Expression_SingularOrList* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_SingularOrList* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_SingularOrList* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_SingularOrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_SingularOrList& from); + void MergeFrom(const Expression_SingularOrList& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_SingularOrList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.SingularOrList"; + } + protected: + explicit Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOptionsFieldNumber = 2, + kValueFieldNumber = 1, + }; + // repeated .io.substrait.Expression options = 2; + int options_size() const; + private: + int _internal_options_size() const; + public: + void clear_options(); + ::io::substrait::Expression* mutable_options(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + mutable_options(); + private: + const ::io::substrait::Expression& _internal_options(int index) const; + ::io::substrait::Expression* _internal_add_options(); + public: + const ::io::substrait::Expression& options(int index) const; + ::io::substrait::Expression* add_options(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + options() const; + + // .io.substrait.Expression value = 1; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + const ::io::substrait::Expression& value() const; + ::io::substrait::Expression* release_value(); + ::io::substrait::Expression* mutable_value(); + void set_allocated_value(::io::substrait::Expression* value); + private: + const ::io::substrait::Expression& _internal_value() const; + ::io::substrait::Expression* _internal_mutable_value(); + public: + void unsafe_arena_set_allocated_value( + ::io::substrait::Expression* value); + ::io::substrait::Expression* unsafe_arena_release_value(); + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.SingularOrList) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > options_; + ::io::substrait::Expression* value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MultiOrList_Record PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MultiOrList.Record) */ { + public: + inline Expression_MultiOrList_Record() : Expression_MultiOrList_Record(nullptr) {} + ~Expression_MultiOrList_Record() override; + explicit constexpr Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MultiOrList_Record(const Expression_MultiOrList_Record& from); + Expression_MultiOrList_Record(Expression_MultiOrList_Record&& from) noexcept + : Expression_MultiOrList_Record() { + *this = ::std::move(from); + } + + inline Expression_MultiOrList_Record& operator=(const Expression_MultiOrList_Record& from) { + CopyFrom(from); + return *this; + } + inline Expression_MultiOrList_Record& operator=(Expression_MultiOrList_Record&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MultiOrList_Record& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_MultiOrList_Record* internal_default_instance() { + return reinterpret_cast( + &_Expression_MultiOrList_Record_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; + + friend void swap(Expression_MultiOrList_Record& a, Expression_MultiOrList_Record& b) { + a.Swap(&b); + } + inline void Swap(Expression_MultiOrList_Record* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MultiOrList_Record* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MultiOrList_Record* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MultiOrList_Record* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MultiOrList_Record& from); + void MergeFrom(const Expression_MultiOrList_Record& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MultiOrList_Record* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MultiOrList.Record"; + } + protected: + explicit Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFieldsFieldNumber = 1, + }; + // repeated .io.substrait.Expression fields = 1; + int fields_size() const; + private: + int _internal_fields_size() const; + public: + void clear_fields(); + ::io::substrait::Expression* mutable_fields(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + mutable_fields(); + private: + const ::io::substrait::Expression& _internal_fields(int index) const; + ::io::substrait::Expression* _internal_add_fields(); + public: + const ::io::substrait::Expression& fields(int index) const; + ::io::substrait::Expression* add_fields(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + fields() const; + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MultiOrList.Record) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > fields_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MultiOrList PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MultiOrList) */ { + public: + inline Expression_MultiOrList() : Expression_MultiOrList(nullptr) {} + ~Expression_MultiOrList() override; + explicit constexpr Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MultiOrList(const Expression_MultiOrList& from); + Expression_MultiOrList(Expression_MultiOrList&& from) noexcept + : Expression_MultiOrList() { + *this = ::std::move(from); + } + + inline Expression_MultiOrList& operator=(const Expression_MultiOrList& from) { + CopyFrom(from); + return *this; + } + inline Expression_MultiOrList& operator=(Expression_MultiOrList&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MultiOrList& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_MultiOrList* internal_default_instance() { + return reinterpret_cast( + &_Expression_MultiOrList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(Expression_MultiOrList& a, Expression_MultiOrList& b) { + a.Swap(&b); + } + inline void Swap(Expression_MultiOrList* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MultiOrList* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MultiOrList* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MultiOrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MultiOrList& from); + void MergeFrom(const Expression_MultiOrList& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MultiOrList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MultiOrList"; + } + protected: + explicit Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_MultiOrList_Record Record; + + // accessors ------------------------------------------------------- + + enum : int { + kValueFieldNumber = 1, + kOptionsFieldNumber = 2, + }; + // repeated .io.substrait.Expression value = 1; + int value_size() const; + private: + int _internal_value_size() const; + public: + void clear_value(); + ::io::substrait::Expression* mutable_value(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + mutable_value(); + private: + const ::io::substrait::Expression& _internal_value(int index) const; + ::io::substrait::Expression* _internal_add_value(); + public: + const ::io::substrait::Expression& value(int index) const; + ::io::substrait::Expression* add_value(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + value() const; + + // repeated .io.substrait.Expression.MultiOrList.Record options = 2; + int options_size() const; + private: + int _internal_options_size() const; + public: + void clear_options(); + ::io::substrait::Expression_MultiOrList_Record* mutable_options(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >* + mutable_options(); + private: + const ::io::substrait::Expression_MultiOrList_Record& _internal_options(int index) const; + ::io::substrait::Expression_MultiOrList_Record* _internal_add_options(); + public: + const ::io::substrait::Expression_MultiOrList_Record& options(int index) const; + ::io::substrait::Expression_MultiOrList_Record* add_options(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >& + options() const; + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MultiOrList) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > value_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record > options_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) */ { + public: + inline Expression_EmbeddedFunction_PythonPickleFunction() : Expression_EmbeddedFunction_PythonPickleFunction(nullptr) {} + ~Expression_EmbeddedFunction_PythonPickleFunction() override; + explicit constexpr Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_EmbeddedFunction_PythonPickleFunction(const Expression_EmbeddedFunction_PythonPickleFunction& from); + Expression_EmbeddedFunction_PythonPickleFunction(Expression_EmbeddedFunction_PythonPickleFunction&& from) noexcept + : Expression_EmbeddedFunction_PythonPickleFunction() { + *this = ::std::move(from); + } + + inline Expression_EmbeddedFunction_PythonPickleFunction& operator=(const Expression_EmbeddedFunction_PythonPickleFunction& from) { + CopyFrom(from); + return *this; + } + inline Expression_EmbeddedFunction_PythonPickleFunction& operator=(Expression_EmbeddedFunction_PythonPickleFunction&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_EmbeddedFunction_PythonPickleFunction& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_EmbeddedFunction_PythonPickleFunction* internal_default_instance() { + return reinterpret_cast( + &_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(Expression_EmbeddedFunction_PythonPickleFunction& a, Expression_EmbeddedFunction_PythonPickleFunction& b) { + a.Swap(&b); + } + inline void Swap(Expression_EmbeddedFunction_PythonPickleFunction* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_EmbeddedFunction_PythonPickleFunction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_EmbeddedFunction_PythonPickleFunction* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_EmbeddedFunction_PythonPickleFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from); + void MergeFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_EmbeddedFunction_PythonPickleFunction* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.EmbeddedFunction.PythonPickleFunction"; + } + protected: + explicit Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPrerequisiteFieldNumber = 2, + kFunctionFieldNumber = 1, + }; + // repeated string prerequisite = 2; + int prerequisite_size() const; + private: + int _internal_prerequisite_size() const; + public: + void clear_prerequisite(); + const std::string& prerequisite(int index) const; + std::string* mutable_prerequisite(int index); + void set_prerequisite(int index, const std::string& value); + void set_prerequisite(int index, std::string&& value); + void set_prerequisite(int index, const char* value); + void set_prerequisite(int index, const char* value, size_t size); + std::string* add_prerequisite(); + void add_prerequisite(const std::string& value); + void add_prerequisite(std::string&& value); + void add_prerequisite(const char* value); + void add_prerequisite(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& prerequisite() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_prerequisite(); + private: + const std::string& _internal_prerequisite(int index) const; + std::string* _internal_add_prerequisite(); + public: + + // bytes function = 1; + void clear_function(); + const std::string& function() const; + template + void set_function(ArgT0&& arg0, ArgT... args); + std::string* mutable_function(); + std::string* release_function(); + void set_allocated_function(std::string* function); + private: + const std::string& _internal_function() const; + void _internal_set_function(const std::string& value); + std::string* _internal_mutable_function(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField prerequisite_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr function_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) */ { + public: + inline Expression_EmbeddedFunction_WebAssemblyFunction() : Expression_EmbeddedFunction_WebAssemblyFunction(nullptr) {} + ~Expression_EmbeddedFunction_WebAssemblyFunction() override; + explicit constexpr Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_EmbeddedFunction_WebAssemblyFunction(const Expression_EmbeddedFunction_WebAssemblyFunction& from); + Expression_EmbeddedFunction_WebAssemblyFunction(Expression_EmbeddedFunction_WebAssemblyFunction&& from) noexcept + : Expression_EmbeddedFunction_WebAssemblyFunction() { + *this = ::std::move(from); + } + + inline Expression_EmbeddedFunction_WebAssemblyFunction& operator=(const Expression_EmbeddedFunction_WebAssemblyFunction& from) { + CopyFrom(from); + return *this; + } + inline Expression_EmbeddedFunction_WebAssemblyFunction& operator=(Expression_EmbeddedFunction_WebAssemblyFunction&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_EmbeddedFunction_WebAssemblyFunction& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_EmbeddedFunction_WebAssemblyFunction* internal_default_instance() { + return reinterpret_cast( + &_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 26; + + friend void swap(Expression_EmbeddedFunction_WebAssemblyFunction& a, Expression_EmbeddedFunction_WebAssemblyFunction& b) { + a.Swap(&b); + } + inline void Swap(Expression_EmbeddedFunction_WebAssemblyFunction* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_EmbeddedFunction_WebAssemblyFunction* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_EmbeddedFunction_WebAssemblyFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from); + void MergeFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction"; + } + protected: + explicit Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kPrerequisiteFieldNumber = 2, + kScriptFieldNumber = 1, + }; + // repeated string prerequisite = 2; + int prerequisite_size() const; + private: + int _internal_prerequisite_size() const; + public: + void clear_prerequisite(); + const std::string& prerequisite(int index) const; + std::string* mutable_prerequisite(int index); + void set_prerequisite(int index, const std::string& value); + void set_prerequisite(int index, std::string&& value); + void set_prerequisite(int index, const char* value); + void set_prerequisite(int index, const char* value, size_t size); + std::string* add_prerequisite(); + void add_prerequisite(const std::string& value); + void add_prerequisite(std::string&& value); + void add_prerequisite(const char* value); + void add_prerequisite(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& prerequisite() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_prerequisite(); + private: + const std::string& _internal_prerequisite(int index) const; + std::string* _internal_add_prerequisite(); + public: + + // bytes script = 1; + void clear_script(); + const std::string& script() const; + template + void set_script(ArgT0&& arg0, ArgT... args); + std::string* mutable_script(); + std::string* release_script(); + void set_allocated_script(std::string* script); + private: + const std::string& _internal_script() const; + void _internal_set_script(const std::string& value); + std::string* _internal_mutable_script(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField prerequisite_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr script_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_EmbeddedFunction PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.EmbeddedFunction) */ { + public: + inline Expression_EmbeddedFunction() : Expression_EmbeddedFunction(nullptr) {} + ~Expression_EmbeddedFunction() override; + explicit constexpr Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_EmbeddedFunction(const Expression_EmbeddedFunction& from); + Expression_EmbeddedFunction(Expression_EmbeddedFunction&& from) noexcept + : Expression_EmbeddedFunction() { + *this = ::std::move(from); + } + + inline Expression_EmbeddedFunction& operator=(const Expression_EmbeddedFunction& from) { + CopyFrom(from); + return *this; + } + inline Expression_EmbeddedFunction& operator=(Expression_EmbeddedFunction&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_EmbeddedFunction& default_instance() { + return *internal_default_instance(); + } + enum KindCase { + kPythonPickleFunction = 3, + kWebAssemblyFunction = 4, + KIND_NOT_SET = 0, + }; + + static inline const Expression_EmbeddedFunction* internal_default_instance() { + return reinterpret_cast( + &_Expression_EmbeddedFunction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 27; + + friend void swap(Expression_EmbeddedFunction& a, Expression_EmbeddedFunction& b) { + a.Swap(&b); + } + inline void Swap(Expression_EmbeddedFunction* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_EmbeddedFunction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_EmbeddedFunction* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_EmbeddedFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_EmbeddedFunction& from); + void MergeFrom(const Expression_EmbeddedFunction& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_EmbeddedFunction* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.EmbeddedFunction"; + } + protected: + explicit Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_EmbeddedFunction_PythonPickleFunction PythonPickleFunction; + typedef Expression_EmbeddedFunction_WebAssemblyFunction WebAssemblyFunction; + + // accessors ------------------------------------------------------- + + enum : int { + kArgumentsFieldNumber = 1, + kOutputTypeFieldNumber = 2, + kPythonPickleFunctionFieldNumber = 3, + kWebAssemblyFunctionFieldNumber = 4, + }; + // repeated .io.substrait.Expression arguments = 1; + int arguments_size() const; + private: + int _internal_arguments_size() const; + public: + void clear_arguments(); + ::io::substrait::Expression* mutable_arguments(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + mutable_arguments(); + private: + const ::io::substrait::Expression& _internal_arguments(int index) const; + ::io::substrait::Expression* _internal_add_arguments(); + public: + const ::io::substrait::Expression& arguments(int index) const; + ::io::substrait::Expression* add_arguments(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + arguments() const; + + // .io.substrait.Type output_type = 2; + bool has_output_type() const; + private: + bool _internal_has_output_type() const; + public: + void clear_output_type(); + const ::io::substrait::Type& output_type() const; + ::io::substrait::Type* release_output_type(); + ::io::substrait::Type* mutable_output_type(); + void set_allocated_output_type(::io::substrait::Type* output_type); + private: + const ::io::substrait::Type& _internal_output_type() const; + ::io::substrait::Type* _internal_mutable_output_type(); + public: + void unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type); + ::io::substrait::Type* unsafe_arena_release_output_type(); + + // .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; + bool has_python_pickle_function() const; + private: + bool _internal_has_python_pickle_function() const; + public: + void clear_python_pickle_function(); + const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function() const; + ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* release_python_pickle_function(); + ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* mutable_python_pickle_function(); + void set_allocated_python_pickle_function(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function); + private: + const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& _internal_python_pickle_function() const; + ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* _internal_mutable_python_pickle_function(); + public: + void unsafe_arena_set_allocated_python_pickle_function( + ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function); + ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* unsafe_arena_release_python_pickle_function(); + + // .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; + bool has_web_assembly_function() const; + private: + bool _internal_has_web_assembly_function() const; + public: + void clear_web_assembly_function(); + const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function() const; + ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* release_web_assembly_function(); + ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* mutable_web_assembly_function(); + void set_allocated_web_assembly_function(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function); + private: + const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& _internal_web_assembly_function() const; + ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* _internal_mutable_web_assembly_function(); + public: + void unsafe_arena_set_allocated_web_assembly_function( + ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function); + ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* unsafe_arena_release_web_assembly_function(); + + void clear_kind(); + KindCase kind_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression.EmbeddedFunction) + private: + class _Internal; + void set_has_python_pickle_function(); + void set_has_web_assembly_function(); + + inline bool has_kind() const; + inline void clear_has_kind(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > arguments_; + ::io::substrait::Type* output_type_; + union KindUnion { + constexpr KindUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function_; + ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function_; + } kind_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression) */ { + public: + inline Expression() : Expression(nullptr) {} + ~Expression() override; + explicit constexpr Expression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression(const Expression& from); + Expression(Expression&& from) noexcept + : Expression() { + *this = ::std::move(from); + } + + inline Expression& operator=(const Expression& from) { + CopyFrom(from); + return *this; + } + inline Expression& operator=(Expression&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression& default_instance() { + return *internal_default_instance(); + } + enum RexTypeCase { + kLiteral = 1, + kSelection = 2, + kScalarFunction = 3, + kWindowFunction = 5, + kIfThen = 6, + kSwitchExpression = 7, + kSingularOrList = 8, + kMultiOrList = 9, + kEnum = 10, + REX_TYPE_NOT_SET = 0, + }; + + static inline const Expression* internal_default_instance() { + return reinterpret_cast( + &_Expression_default_instance_); + } + static constexpr int kIndexInFileMessages = + 28; + + friend void swap(Expression& a, Expression& b) { + a.Swap(&b); + } + inline void Swap(Expression* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression& from); + void MergeFrom(const Expression& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression"; + } + protected: + explicit Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_Enum Enum; + typedef Expression_Literal Literal; + typedef Expression_ScalarFunction ScalarFunction; + typedef Expression_AggregateFunction AggregateFunction; + typedef Expression_WindowFunction WindowFunction; + typedef Expression_SortField SortField; + typedef Expression_IfThen IfThen; + typedef Expression_SwitchExpression SwitchExpression; + typedef Expression_SingularOrList SingularOrList; + typedef Expression_MultiOrList MultiOrList; + typedef Expression_EmbeddedFunction EmbeddedFunction; + + typedef Expression_AggregationPhase AggregationPhase; + static constexpr AggregationPhase UNKNOWN = + Expression_AggregationPhase_UNKNOWN; + static constexpr AggregationPhase INITIAL_TO_INTERMEDIATE = + Expression_AggregationPhase_INITIAL_TO_INTERMEDIATE; + static constexpr AggregationPhase INTERMEDIATE_TO_INTERMEDIATE = + Expression_AggregationPhase_INTERMEDIATE_TO_INTERMEDIATE; + static constexpr AggregationPhase INITIAL_TO_RESULT = + Expression_AggregationPhase_INITIAL_TO_RESULT; + static constexpr AggregationPhase INTERMEDIATE_TO_RESULT = + Expression_AggregationPhase_INTERMEDIATE_TO_RESULT; + static inline bool AggregationPhase_IsValid(int value) { + return Expression_AggregationPhase_IsValid(value); + } + static constexpr AggregationPhase AggregationPhase_MIN = + Expression_AggregationPhase_AggregationPhase_MIN; + static constexpr AggregationPhase AggregationPhase_MAX = + Expression_AggregationPhase_AggregationPhase_MAX; + static constexpr int AggregationPhase_ARRAYSIZE = + Expression_AggregationPhase_AggregationPhase_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + AggregationPhase_descriptor() { + return Expression_AggregationPhase_descriptor(); + } + template + static inline const std::string& AggregationPhase_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function AggregationPhase_Name."); + return Expression_AggregationPhase_Name(enum_t_value); + } + static inline bool AggregationPhase_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + AggregationPhase* value) { + return Expression_AggregationPhase_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kLiteralFieldNumber = 1, + kSelectionFieldNumber = 2, + kScalarFunctionFieldNumber = 3, + kWindowFunctionFieldNumber = 5, + kIfThenFieldNumber = 6, + kSwitchExpressionFieldNumber = 7, + kSingularOrListFieldNumber = 8, + kMultiOrListFieldNumber = 9, + kEnumFieldNumber = 10, + }; + // .io.substrait.Expression.Literal literal = 1; + bool has_literal() const; + private: + bool _internal_has_literal() const; + public: + void clear_literal(); + const ::io::substrait::Expression_Literal& literal() const; + ::io::substrait::Expression_Literal* release_literal(); + ::io::substrait::Expression_Literal* mutable_literal(); + void set_allocated_literal(::io::substrait::Expression_Literal* literal); + private: + const ::io::substrait::Expression_Literal& _internal_literal() const; + ::io::substrait::Expression_Literal* _internal_mutable_literal(); + public: + void unsafe_arena_set_allocated_literal( + ::io::substrait::Expression_Literal* literal); + ::io::substrait::Expression_Literal* unsafe_arena_release_literal(); + + // .io.substrait.FieldReference selection = 2; + bool has_selection() const; + private: + bool _internal_has_selection() const; + public: + void clear_selection(); + const ::io::substrait::FieldReference& selection() const; + ::io::substrait::FieldReference* release_selection(); + ::io::substrait::FieldReference* mutable_selection(); + void set_allocated_selection(::io::substrait::FieldReference* selection); + private: + const ::io::substrait::FieldReference& _internal_selection() const; + ::io::substrait::FieldReference* _internal_mutable_selection(); + public: + void unsafe_arena_set_allocated_selection( + ::io::substrait::FieldReference* selection); + ::io::substrait::FieldReference* unsafe_arena_release_selection(); + + // .io.substrait.Expression.ScalarFunction scalar_function = 3; + bool has_scalar_function() const; + private: + bool _internal_has_scalar_function() const; + public: + void clear_scalar_function(); + const ::io::substrait::Expression_ScalarFunction& scalar_function() const; + ::io::substrait::Expression_ScalarFunction* release_scalar_function(); + ::io::substrait::Expression_ScalarFunction* mutable_scalar_function(); + void set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function); + private: + const ::io::substrait::Expression_ScalarFunction& _internal_scalar_function() const; + ::io::substrait::Expression_ScalarFunction* _internal_mutable_scalar_function(); + public: + void unsafe_arena_set_allocated_scalar_function( + ::io::substrait::Expression_ScalarFunction* scalar_function); + ::io::substrait::Expression_ScalarFunction* unsafe_arena_release_scalar_function(); + + // .io.substrait.Expression.WindowFunction window_function = 5; + bool has_window_function() const; + private: + bool _internal_has_window_function() const; + public: + void clear_window_function(); + const ::io::substrait::Expression_WindowFunction& window_function() const; + ::io::substrait::Expression_WindowFunction* release_window_function(); + ::io::substrait::Expression_WindowFunction* mutable_window_function(); + void set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function); + private: + const ::io::substrait::Expression_WindowFunction& _internal_window_function() const; + ::io::substrait::Expression_WindowFunction* _internal_mutable_window_function(); + public: + void unsafe_arena_set_allocated_window_function( + ::io::substrait::Expression_WindowFunction* window_function); + ::io::substrait::Expression_WindowFunction* unsafe_arena_release_window_function(); + + // .io.substrait.Expression.IfThen if_then = 6; + bool has_if_then() const; + private: + bool _internal_has_if_then() const; + public: + void clear_if_then(); + const ::io::substrait::Expression_IfThen& if_then() const; + ::io::substrait::Expression_IfThen* release_if_then(); + ::io::substrait::Expression_IfThen* mutable_if_then(); + void set_allocated_if_then(::io::substrait::Expression_IfThen* if_then); + private: + const ::io::substrait::Expression_IfThen& _internal_if_then() const; + ::io::substrait::Expression_IfThen* _internal_mutable_if_then(); + public: + void unsafe_arena_set_allocated_if_then( + ::io::substrait::Expression_IfThen* if_then); + ::io::substrait::Expression_IfThen* unsafe_arena_release_if_then(); + + // .io.substrait.Expression.SwitchExpression switch_expression = 7; + bool has_switch_expression() const; + private: + bool _internal_has_switch_expression() const; + public: + void clear_switch_expression(); + const ::io::substrait::Expression_SwitchExpression& switch_expression() const; + ::io::substrait::Expression_SwitchExpression* release_switch_expression(); + ::io::substrait::Expression_SwitchExpression* mutable_switch_expression(); + void set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression); + private: + const ::io::substrait::Expression_SwitchExpression& _internal_switch_expression() const; + ::io::substrait::Expression_SwitchExpression* _internal_mutable_switch_expression(); + public: + void unsafe_arena_set_allocated_switch_expression( + ::io::substrait::Expression_SwitchExpression* switch_expression); + ::io::substrait::Expression_SwitchExpression* unsafe_arena_release_switch_expression(); + + // .io.substrait.Expression.SingularOrList singular_or_list = 8; + bool has_singular_or_list() const; + private: + bool _internal_has_singular_or_list() const; + public: + void clear_singular_or_list(); + const ::io::substrait::Expression_SingularOrList& singular_or_list() const; + ::io::substrait::Expression_SingularOrList* release_singular_or_list(); + ::io::substrait::Expression_SingularOrList* mutable_singular_or_list(); + void set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list); + private: + const ::io::substrait::Expression_SingularOrList& _internal_singular_or_list() const; + ::io::substrait::Expression_SingularOrList* _internal_mutable_singular_or_list(); + public: + void unsafe_arena_set_allocated_singular_or_list( + ::io::substrait::Expression_SingularOrList* singular_or_list); + ::io::substrait::Expression_SingularOrList* unsafe_arena_release_singular_or_list(); + + // .io.substrait.Expression.MultiOrList multi_or_list = 9; + bool has_multi_or_list() const; + private: + bool _internal_has_multi_or_list() const; + public: + void clear_multi_or_list(); + const ::io::substrait::Expression_MultiOrList& multi_or_list() const; + ::io::substrait::Expression_MultiOrList* release_multi_or_list(); + ::io::substrait::Expression_MultiOrList* mutable_multi_or_list(); + void set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list); + private: + const ::io::substrait::Expression_MultiOrList& _internal_multi_or_list() const; + ::io::substrait::Expression_MultiOrList* _internal_mutable_multi_or_list(); + public: + void unsafe_arena_set_allocated_multi_or_list( + ::io::substrait::Expression_MultiOrList* multi_or_list); + ::io::substrait::Expression_MultiOrList* unsafe_arena_release_multi_or_list(); + + // .io.substrait.Expression.Enum enum = 10; + bool has_enum_() const; + private: + bool _internal_has_enum_() const; + public: + void clear_enum_(); + const ::io::substrait::Expression_Enum& enum_() const; + ::io::substrait::Expression_Enum* release_enum_(); + ::io::substrait::Expression_Enum* mutable_enum_(); + void set_allocated_enum_(::io::substrait::Expression_Enum* enum_); + private: + const ::io::substrait::Expression_Enum& _internal_enum_() const; + ::io::substrait::Expression_Enum* _internal_mutable_enum_(); + public: + void unsafe_arena_set_allocated_enum_( + ::io::substrait::Expression_Enum* enum_); + ::io::substrait::Expression_Enum* unsafe_arena_release_enum_(); + + void clear_rex_type(); + RexTypeCase rex_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression) + private: + class _Internal; + void set_has_literal(); + void set_has_selection(); + void set_has_scalar_function(); + void set_has_window_function(); + void set_has_if_then(); + void set_has_switch_expression(); + void set_has_singular_or_list(); + void set_has_multi_or_list(); + void set_has_enum_(); + + inline bool has_rex_type() const; + inline void clear_has_rex_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union RexTypeUnion { + constexpr RexTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Expression_Literal* literal_; + ::io::substrait::FieldReference* selection_; + ::io::substrait::Expression_ScalarFunction* scalar_function_; + ::io::substrait::Expression_WindowFunction* window_function_; + ::io::substrait::Expression_IfThen* if_then_; + ::io::substrait::Expression_SwitchExpression* switch_expression_; + ::io::substrait::Expression_SingularOrList* singular_or_list_; + ::io::substrait::Expression_MultiOrList* multi_or_list_; + ::io::substrait::Expression_Enum* enum__; + } rex_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Expression_Enum_Empty + +// ------------------------------------------------------------------- + +// Expression_Enum + +// string specified = 1; +inline bool Expression_Enum::_internal_has_specified() const { + return enum_kind_case() == kSpecified; +} +inline bool Expression_Enum::has_specified() const { + return _internal_has_specified(); +} +inline void Expression_Enum::set_has_specified() { + _oneof_case_[0] = kSpecified; +} +inline void Expression_Enum::clear_specified() { + if (_internal_has_specified()) { + enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_enum_kind(); + } +} +inline const std::string& Expression_Enum::specified() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Enum.specified) + return _internal_specified(); +} +template +inline void Expression_Enum::set_specified(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_specified()) { + clear_enum_kind(); + set_has_specified(); + enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Enum.specified) +} +inline std::string* Expression_Enum::mutable_specified() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Enum.specified) + return _internal_mutable_specified(); +} +inline const std::string& Expression_Enum::_internal_specified() const { + if (_internal_has_specified()) { + return enum_kind_.specified_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Enum::_internal_set_specified(const std::string& value) { + if (!_internal_has_specified()) { + clear_enum_kind(); + set_has_specified(); + enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Enum::_internal_mutable_specified() { + if (!_internal_has_specified()) { + clear_enum_kind(); + set_has_specified(); + enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return enum_kind_.specified_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Enum::release_specified() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Enum.specified) + if (_internal_has_specified()) { + clear_has_enum_kind(); + return enum_kind_.specified_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Enum::set_allocated_specified(std::string* specified) { + if (has_enum_kind()) { + clear_enum_kind(); + } + if (specified != nullptr) { + set_has_specified(); + enum_kind_.specified_.UnsafeSetDefault(specified); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(specified); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Enum.specified) +} + +// .io.substrait.Expression.Enum.Empty unspecified = 2; +inline bool Expression_Enum::_internal_has_unspecified() const { + return enum_kind_case() == kUnspecified; +} +inline bool Expression_Enum::has_unspecified() const { + return _internal_has_unspecified(); +} +inline void Expression_Enum::set_has_unspecified() { + _oneof_case_[0] = kUnspecified; +} +inline void Expression_Enum::clear_unspecified() { + if (_internal_has_unspecified()) { + if (GetArena() == nullptr) { + delete enum_kind_.unspecified_; + } + clear_has_enum_kind(); + } +} +inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::release_unspecified() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Enum.unspecified) + if (_internal_has_unspecified()) { + clear_has_enum_kind(); + ::io::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + enum_kind_.unspecified_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Enum_Empty& Expression_Enum::_internal_unspecified() const { + return _internal_has_unspecified() + ? *enum_kind_.unspecified_ + : reinterpret_cast< ::io::substrait::Expression_Enum_Empty&>(::io::substrait::_Expression_Enum_Empty_default_instance_); +} +inline const ::io::substrait::Expression_Enum_Empty& Expression_Enum::unspecified() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Enum.unspecified) + return _internal_unspecified(); +} +inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::unsafe_arena_release_unspecified() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Enum.unspecified) + if (_internal_has_unspecified()) { + clear_has_enum_kind(); + ::io::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; + enum_kind_.unspecified_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Enum::unsafe_arena_set_allocated_unspecified(::io::substrait::Expression_Enum_Empty* unspecified) { + clear_enum_kind(); + if (unspecified) { + set_has_unspecified(); + enum_kind_.unspecified_ = unspecified; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Enum.unspecified) +} +inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::_internal_mutable_unspecified() { + if (!_internal_has_unspecified()) { + clear_enum_kind(); + set_has_unspecified(); + enum_kind_.unspecified_ = CreateMaybeMessage< ::io::substrait::Expression_Enum_Empty >(GetArena()); + } + return enum_kind_.unspecified_; +} +inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::mutable_unspecified() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Enum.unspecified) + return _internal_mutable_unspecified(); +} + +inline bool Expression_Enum::has_enum_kind() const { + return enum_kind_case() != ENUM_KIND_NOT_SET; +} +inline void Expression_Enum::clear_has_enum_kind() { + _oneof_case_[0] = ENUM_KIND_NOT_SET; +} +inline Expression_Enum::EnumKindCase Expression_Enum::enum_kind_case() const { + return Expression_Enum::EnumKindCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Expression_Literal_Map_KeyValue + +// .io.substrait.Expression.Literal key = 1; +inline bool Expression_Literal_Map_KeyValue::_internal_has_key() const { + return this != internal_default_instance() && key_ != nullptr; +} +inline bool Expression_Literal_Map_KeyValue::has_key() const { + return _internal_has_key(); +} +inline void Expression_Literal_Map_KeyValue::clear_key() { + if (GetArena() == nullptr && key_ != nullptr) { + delete key_; + } + key_ = nullptr; +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_key() const { + const ::io::substrait::Expression_Literal* p = key_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_Literal_default_instance_); +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::key() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.KeyValue.key) + return _internal_key(); +} +inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_key( + ::io::substrait::Expression_Literal* key) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); + } + key_ = key; + if (key) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.key) +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_key() { + + ::io::substrait::Expression_Literal* temp = key_; + key_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.KeyValue.key) + + ::io::substrait::Expression_Literal* temp = key_; + key_ = nullptr; + return temp; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_key() { + + if (key_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); + key_ = p; + } + return key_; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.KeyValue.key) + return _internal_mutable_key(); +} +inline void Expression_Literal_Map_KeyValue::set_allocated_key(::io::substrait::Expression_Literal* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + + } else { + + } + key_ = key; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.key) +} + +// .io.substrait.Expression.Literal value = 2; +inline bool Expression_Literal_Map_KeyValue::_internal_has_value() const { + return this != internal_default_instance() && value_ != nullptr; +} +inline bool Expression_Literal_Map_KeyValue::has_value() const { + return _internal_has_value(); +} +inline void Expression_Literal_Map_KeyValue::clear_value() { + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_value() const { + const ::io::substrait::Expression_Literal* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_Literal_default_instance_); +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::value() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.KeyValue.value) + return _internal_value(); +} +inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_value( + ::io::substrait::Expression_Literal* value) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); + } + value_ = value; + if (value) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.value) +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_value() { + + ::io::substrait::Expression_Literal* temp = value_; + value_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.KeyValue.value) + + ::io::substrait::Expression_Literal* temp = value_; + value_ = nullptr; + return temp; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_value() { + + if (value_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); + value_ = p; + } + return value_; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.KeyValue.value) + return _internal_mutable_value(); +} +inline void Expression_Literal_Map_KeyValue::set_allocated_value(::io::substrait::Expression_Literal* value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete value_; + } + if (value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + if (message_arena != submessage_arena) { + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); + } + + } else { + + } + value_ = value; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.value) +} + +// ------------------------------------------------------------------- + +// Expression_Literal_Map + +// repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; +inline int Expression_Literal_Map::_internal_key_values_size() const { + return key_values_.size(); +} +inline int Expression_Literal_Map::key_values_size() const { + return _internal_key_values_size(); +} +inline void Expression_Literal_Map::clear_key_values() { + key_values_.Clear(); +} +inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::mutable_key_values(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.key_values) + return key_values_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >* +Expression_Literal_Map::mutable_key_values() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.Map.key_values) + return &key_values_; +} +inline const ::io::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::_internal_key_values(int index) const { + return key_values_.Get(index); +} +inline const ::io::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::key_values(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.key_values) + return _internal_key_values(index); +} +inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::_internal_add_key_values() { + return key_values_.Add(); +} +inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::add_key_values() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.Map.key_values) + return _internal_add_key_values(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >& +Expression_Literal_Map::key_values() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.Map.key_values) + return key_values_; +} + +// ------------------------------------------------------------------- + +// Expression_Literal_IntervalYearToMonth + +// int32 years = 1; +inline void Expression_Literal_IntervalYearToMonth::clear_years() { + years_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::_internal_years() const { + return years_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::years() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalYearToMonth.years) + return _internal_years(); +} +inline void Expression_Literal_IntervalYearToMonth::_internal_set_years(::PROTOBUF_NAMESPACE_ID::int32 value) { + + years_ = value; +} +inline void Expression_Literal_IntervalYearToMonth::set_years(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_years(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalYearToMonth.years) +} + +// int32 months = 2; +inline void Expression_Literal_IntervalYearToMonth::clear_months() { + months_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::_internal_months() const { + return months_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::months() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalYearToMonth.months) + return _internal_months(); +} +inline void Expression_Literal_IntervalYearToMonth::_internal_set_months(::PROTOBUF_NAMESPACE_ID::int32 value) { + + months_ = value; +} +inline void Expression_Literal_IntervalYearToMonth::set_months(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_months(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalYearToMonth.months) +} + +// ------------------------------------------------------------------- + +// Expression_Literal_IntervalDayToSecond + +// int32 days = 1; +inline void Expression_Literal_IntervalDayToSecond::clear_days() { + days_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::_internal_days() const { + return days_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::days() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalDayToSecond.days) + return _internal_days(); +} +inline void Expression_Literal_IntervalDayToSecond::_internal_set_days(::PROTOBUF_NAMESPACE_ID::int32 value) { + + days_ = value; +} +inline void Expression_Literal_IntervalDayToSecond::set_days(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_days(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalDayToSecond.days) +} + +// int32 seconds = 2; +inline void Expression_Literal_IntervalDayToSecond::clear_seconds() { + seconds_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::_internal_seconds() const { + return seconds_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::seconds() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalDayToSecond.seconds) + return _internal_seconds(); +} +inline void Expression_Literal_IntervalDayToSecond::_internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value) { + + seconds_ = value; +} +inline void Expression_Literal_IntervalDayToSecond::set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_seconds(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalDayToSecond.seconds) +} + +// ------------------------------------------------------------------- + +// Expression_Literal_Struct + +// repeated .io.substrait.Expression.Literal fields = 1; +inline int Expression_Literal_Struct::_internal_fields_size() const { + return fields_.size(); +} +inline int Expression_Literal_Struct::fields_size() const { + return _internal_fields_size(); +} +inline void Expression_Literal_Struct::clear_fields() { + fields_.Clear(); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::mutable_fields(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Struct.fields) + return fields_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* +Expression_Literal_Struct::mutable_fields() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.Struct.fields) + return &fields_; +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Struct::_internal_fields(int index) const { + return fields_.Get(index); +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Struct::fields(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Struct.fields) + return _internal_fields(index); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::_internal_add_fields() { + return fields_.Add(); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::add_fields() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.Struct.fields) + return _internal_add_fields(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& +Expression_Literal_Struct::fields() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.Struct.fields) + return fields_; +} + +// ------------------------------------------------------------------- + +// Expression_Literal_List + +// repeated .io.substrait.Expression.Literal values = 1; +inline int Expression_Literal_List::_internal_values_size() const { + return values_.size(); +} +inline int Expression_Literal_List::values_size() const { + return _internal_values_size(); +} +inline void Expression_Literal_List::clear_values() { + values_.Clear(); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_List::mutable_values(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.List.values) + return values_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* +Expression_Literal_List::mutable_values() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.List.values) + return &values_; +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_List::_internal_values(int index) const { + return values_.Get(index); +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_List::values(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.List.values) + return _internal_values(index); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_List::_internal_add_values() { + return values_.Add(); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_List::add_values() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.List.values) + return _internal_add_values(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& +Expression_Literal_List::values() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.List.values) + return values_; +} + +// ------------------------------------------------------------------- + +// Expression_Literal + +// bool boolean = 1; +inline bool Expression_Literal::_internal_has_boolean() const { + return literal_type_case() == kBoolean; +} +inline bool Expression_Literal::has_boolean() const { + return _internal_has_boolean(); +} +inline void Expression_Literal::set_has_boolean() { + _oneof_case_[0] = kBoolean; +} +inline void Expression_Literal::clear_boolean() { + if (_internal_has_boolean()) { + literal_type_.boolean_ = false; + clear_has_literal_type(); + } +} +inline bool Expression_Literal::_internal_boolean() const { + if (_internal_has_boolean()) { + return literal_type_.boolean_; + } + return false; +} +inline void Expression_Literal::_internal_set_boolean(bool value) { + if (!_internal_has_boolean()) { + clear_literal_type(); + set_has_boolean(); + } + literal_type_.boolean_ = value; +} +inline bool Expression_Literal::boolean() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.boolean) + return _internal_boolean(); +} +inline void Expression_Literal::set_boolean(bool value) { + _internal_set_boolean(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.boolean) +} + +// int32 i8 = 2; +inline bool Expression_Literal::_internal_has_i8() const { + return literal_type_case() == kI8; +} +inline bool Expression_Literal::has_i8() const { + return _internal_has_i8(); +} +inline void Expression_Literal::set_has_i8() { + _oneof_case_[0] = kI8; +} +inline void Expression_Literal::clear_i8() { + if (_internal_has_i8()) { + literal_type_.i8_ = 0; + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i8() const { + if (_internal_has_i8()) { + return literal_type_.i8_; + } + return 0; +} +inline void Expression_Literal::_internal_set_i8(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!_internal_has_i8()) { + clear_literal_type(); + set_has_i8(); + } + literal_type_.i8_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i8() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i8) + return _internal_i8(); +} +inline void Expression_Literal::set_i8(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_i8(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i8) +} + +// int32 i16 = 3; +inline bool Expression_Literal::_internal_has_i16() const { + return literal_type_case() == kI16; +} +inline bool Expression_Literal::has_i16() const { + return _internal_has_i16(); +} +inline void Expression_Literal::set_has_i16() { + _oneof_case_[0] = kI16; +} +inline void Expression_Literal::clear_i16() { + if (_internal_has_i16()) { + literal_type_.i16_ = 0; + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i16() const { + if (_internal_has_i16()) { + return literal_type_.i16_; + } + return 0; +} +inline void Expression_Literal::_internal_set_i16(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!_internal_has_i16()) { + clear_literal_type(); + set_has_i16(); + } + literal_type_.i16_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i16() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i16) + return _internal_i16(); +} +inline void Expression_Literal::set_i16(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_i16(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i16) +} + +// int32 i32 = 5; +inline bool Expression_Literal::_internal_has_i32() const { + return literal_type_case() == kI32; +} +inline bool Expression_Literal::has_i32() const { + return _internal_has_i32(); +} +inline void Expression_Literal::set_has_i32() { + _oneof_case_[0] = kI32; +} +inline void Expression_Literal::clear_i32() { + if (_internal_has_i32()) { + literal_type_.i32_ = 0; + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i32() const { + if (_internal_has_i32()) { + return literal_type_.i32_; + } + return 0; +} +inline void Expression_Literal::_internal_set_i32(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!_internal_has_i32()) { + clear_literal_type(); + set_has_i32(); + } + literal_type_.i32_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i32() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i32) + return _internal_i32(); +} +inline void Expression_Literal::set_i32(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_i32(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i32) +} + +// int64 i64 = 7; +inline bool Expression_Literal::_internal_has_i64() const { + return literal_type_case() == kI64; +} +inline bool Expression_Literal::has_i64() const { + return _internal_has_i64(); +} +inline void Expression_Literal::set_has_i64() { + _oneof_case_[0] = kI64; +} +inline void Expression_Literal::clear_i64() { + if (_internal_has_i64()) { + literal_type_.i64_ = PROTOBUF_LONGLONG(0); + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_i64() const { + if (_internal_has_i64()) { + return literal_type_.i64_; + } + return PROTOBUF_LONGLONG(0); +} +inline void Expression_Literal::_internal_set_i64(::PROTOBUF_NAMESPACE_ID::int64 value) { + if (!_internal_has_i64()) { + clear_literal_type(); + set_has_i64(); + } + literal_type_.i64_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::i64() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i64) + return _internal_i64(); +} +inline void Expression_Literal::set_i64(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_i64(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i64) +} + +// float fp32 = 10; +inline bool Expression_Literal::_internal_has_fp32() const { + return literal_type_case() == kFp32; +} +inline bool Expression_Literal::has_fp32() const { + return _internal_has_fp32(); +} +inline void Expression_Literal::set_has_fp32() { + _oneof_case_[0] = kFp32; +} +inline void Expression_Literal::clear_fp32() { + if (_internal_has_fp32()) { + literal_type_.fp32_ = 0; + clear_has_literal_type(); + } +} +inline float Expression_Literal::_internal_fp32() const { + if (_internal_has_fp32()) { + return literal_type_.fp32_; + } + return 0; +} +inline void Expression_Literal::_internal_set_fp32(float value) { + if (!_internal_has_fp32()) { + clear_literal_type(); + set_has_fp32(); + } + literal_type_.fp32_ = value; +} +inline float Expression_Literal::fp32() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fp32) + return _internal_fp32(); +} +inline void Expression_Literal::set_fp32(float value) { + _internal_set_fp32(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fp32) +} + +// double fp64 = 11; +inline bool Expression_Literal::_internal_has_fp64() const { + return literal_type_case() == kFp64; +} +inline bool Expression_Literal::has_fp64() const { + return _internal_has_fp64(); +} +inline void Expression_Literal::set_has_fp64() { + _oneof_case_[0] = kFp64; +} +inline void Expression_Literal::clear_fp64() { + if (_internal_has_fp64()) { + literal_type_.fp64_ = 0; + clear_has_literal_type(); + } +} +inline double Expression_Literal::_internal_fp64() const { + if (_internal_has_fp64()) { + return literal_type_.fp64_; + } + return 0; +} +inline void Expression_Literal::_internal_set_fp64(double value) { + if (!_internal_has_fp64()) { + clear_literal_type(); + set_has_fp64(); + } + literal_type_.fp64_ = value; +} +inline double Expression_Literal::fp64() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fp64) + return _internal_fp64(); +} +inline void Expression_Literal::set_fp64(double value) { + _internal_set_fp64(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fp64) +} + +// string string = 12; +inline bool Expression_Literal::_internal_has_string() const { + return literal_type_case() == kString; +} +inline bool Expression_Literal::has_string() const { + return _internal_has_string(); +} +inline void Expression_Literal::set_has_string() { + _oneof_case_[0] = kString; +} +inline void Expression_Literal::clear_string() { + if (_internal_has_string()) { + literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } +} +inline const std::string& Expression_Literal::string() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.string) + return _internal_string(); +} +template +inline void Expression_Literal::set_string(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_string()) { + clear_literal_type(); + set_has_string(); + literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.string) +} +inline std::string* Expression_Literal::mutable_string() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.string) + return _internal_mutable_string(); +} +inline const std::string& Expression_Literal::_internal_string() const { + if (_internal_has_string()) { + return literal_type_.string_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Literal::_internal_set_string(const std::string& value) { + if (!_internal_has_string()) { + clear_literal_type(); + set_has_string(); + literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal::_internal_mutable_string() { + if (!_internal_has_string()) { + clear_literal_type(); + set_has_string(); + literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.string_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal::release_string() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.string) + if (_internal_has_string()) { + clear_has_literal_type(); + return literal_type_.string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Literal::set_allocated_string(std::string* string) { + if (has_literal_type()) { + clear_literal_type(); + } + if (string != nullptr) { + set_has_string(); + literal_type_.string_.UnsafeSetDefault(string); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(string); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.string) +} + +// bytes binary = 13; +inline bool Expression_Literal::_internal_has_binary() const { + return literal_type_case() == kBinary; +} +inline bool Expression_Literal::has_binary() const { + return _internal_has_binary(); +} +inline void Expression_Literal::set_has_binary() { + _oneof_case_[0] = kBinary; +} +inline void Expression_Literal::clear_binary() { + if (_internal_has_binary()) { + literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } +} +inline const std::string& Expression_Literal::binary() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.binary) + return _internal_binary(); +} +template +inline void Expression_Literal::set_binary(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_binary()) { + clear_literal_type(); + set_has_binary(); + literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.binary) +} +inline std::string* Expression_Literal::mutable_binary() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.binary) + return _internal_mutable_binary(); +} +inline const std::string& Expression_Literal::_internal_binary() const { + if (_internal_has_binary()) { + return literal_type_.binary_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Literal::_internal_set_binary(const std::string& value) { + if (!_internal_has_binary()) { + clear_literal_type(); + set_has_binary(); + literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal::_internal_mutable_binary() { + if (!_internal_has_binary()) { + clear_literal_type(); + set_has_binary(); + literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.binary_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal::release_binary() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.binary) + if (_internal_has_binary()) { + clear_has_literal_type(); + return literal_type_.binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Literal::set_allocated_binary(std::string* binary) { + if (has_literal_type()) { + clear_literal_type(); + } + if (binary != nullptr) { + set_has_binary(); + literal_type_.binary_.UnsafeSetDefault(binary); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(binary); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.binary) +} + +// fixed64 timestamp = 14; +inline bool Expression_Literal::_internal_has_timestamp() const { + return literal_type_case() == kTimestamp; +} +inline bool Expression_Literal::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void Expression_Literal::set_has_timestamp() { + _oneof_case_[0] = kTimestamp; +} +inline void Expression_Literal::clear_timestamp() { + if (_internal_has_timestamp()) { + literal_type_.timestamp_ = PROTOBUF_ULONGLONG(0); + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::_internal_timestamp() const { + if (_internal_has_timestamp()) { + return literal_type_.timestamp_; + } + return PROTOBUF_ULONGLONG(0); +} +inline void Expression_Literal::_internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { + if (!_internal_has_timestamp()) { + clear_literal_type(); + set_has_timestamp(); + } + literal_type_.timestamp_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::timestamp() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.timestamp) + return _internal_timestamp(); +} +inline void Expression_Literal::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.timestamp) +} + +// fixed32 date = 16; +inline bool Expression_Literal::_internal_has_date() const { + return literal_type_case() == kDate; +} +inline bool Expression_Literal::has_date() const { + return _internal_has_date(); +} +inline void Expression_Literal::set_has_date() { + _oneof_case_[0] = kDate; +} +inline void Expression_Literal::clear_date() { + if (_internal_has_date()) { + literal_type_.date_ = 0u; + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_Literal::_internal_date() const { + if (_internal_has_date()) { + return literal_type_.date_; + } + return 0u; +} +inline void Expression_Literal::_internal_set_date(::PROTOBUF_NAMESPACE_ID::uint32 value) { + if (!_internal_has_date()) { + clear_literal_type(); + set_has_date(); + } + literal_type_.date_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_Literal::date() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.date) + return _internal_date(); +} +inline void Expression_Literal::set_date(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_date(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.date) +} + +// uint64 time = 17; +inline bool Expression_Literal::_internal_has_time() const { + return literal_type_case() == kTime; +} +inline bool Expression_Literal::has_time() const { + return _internal_has_time(); +} +inline void Expression_Literal::set_has_time() { + _oneof_case_[0] = kTime; +} +inline void Expression_Literal::clear_time() { + if (_internal_has_time()) { + literal_type_.time_ = PROTOBUF_ULONGLONG(0); + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::_internal_time() const { + if (_internal_has_time()) { + return literal_type_.time_; + } + return PROTOBUF_ULONGLONG(0); +} +inline void Expression_Literal::_internal_set_time(::PROTOBUF_NAMESPACE_ID::uint64 value) { + if (!_internal_has_time()) { + clear_literal_type(); + set_has_time(); + } + literal_type_.time_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::time() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.time) + return _internal_time(); +} +inline void Expression_Literal::set_time(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_time(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.time) +} + +// .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; +inline bool Expression_Literal::_internal_has_interval_year_to_month() const { + return literal_type_case() == kIntervalYearToMonth; +} +inline bool Expression_Literal::has_interval_year_to_month() const { + return _internal_has_interval_year_to_month(); +} +inline void Expression_Literal::set_has_interval_year_to_month() { + _oneof_case_[0] = kIntervalYearToMonth; +} +inline void Expression_Literal::clear_interval_year_to_month() { + if (_internal_has_interval_year_to_month()) { + if (GetArena() == nullptr) { + delete literal_type_.interval_year_to_month_; + } + clear_has_literal_type(); + } +} +inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::release_interval_year_to_month() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.interval_year_to_month) + if (_internal_has_interval_year_to_month()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.interval_year_to_month_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::_internal_interval_year_to_month() const { + return _internal_has_interval_year_to_month() + ? *literal_type_.interval_year_to_month_ + : reinterpret_cast< ::io::substrait::Expression_Literal_IntervalYearToMonth&>(::io::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_); +} +inline const ::io::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::interval_year_to_month() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.interval_year_to_month) + return _internal_interval_year_to_month(); +} +inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::unsafe_arena_release_interval_year_to_month() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.interval_year_to_month) + if (_internal_has_interval_year_to_month()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; + literal_type_.interval_year_to_month_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_interval_year_to_month(::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { + clear_literal_type(); + if (interval_year_to_month) { + set_has_interval_year_to_month(); + literal_type_.interval_year_to_month_ = interval_year_to_month; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.interval_year_to_month) +} +inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::_internal_mutable_interval_year_to_month() { + if (!_internal_has_interval_year_to_month()) { + clear_literal_type(); + set_has_interval_year_to_month(); + literal_type_.interval_year_to_month_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalYearToMonth >(GetArena()); + } + return literal_type_.interval_year_to_month_; +} +inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::mutable_interval_year_to_month() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.interval_year_to_month) + return _internal_mutable_interval_year_to_month(); +} + +// .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; +inline bool Expression_Literal::_internal_has_interval_day_to_second() const { + return literal_type_case() == kIntervalDayToSecond; +} +inline bool Expression_Literal::has_interval_day_to_second() const { + return _internal_has_interval_day_to_second(); +} +inline void Expression_Literal::set_has_interval_day_to_second() { + _oneof_case_[0] = kIntervalDayToSecond; +} +inline void Expression_Literal::clear_interval_day_to_second() { + if (_internal_has_interval_day_to_second()) { + if (GetArena() == nullptr) { + delete literal_type_.interval_day_to_second_; + } + clear_has_literal_type(); + } +} +inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::release_interval_day_to_second() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.interval_day_to_second) + if (_internal_has_interval_day_to_second()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.interval_day_to_second_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::_internal_interval_day_to_second() const { + return _internal_has_interval_day_to_second() + ? *literal_type_.interval_day_to_second_ + : reinterpret_cast< ::io::substrait::Expression_Literal_IntervalDayToSecond&>(::io::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_); +} +inline const ::io::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::interval_day_to_second() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.interval_day_to_second) + return _internal_interval_day_to_second(); +} +inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::unsafe_arena_release_interval_day_to_second() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.interval_day_to_second) + if (_internal_has_interval_day_to_second()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; + literal_type_.interval_day_to_second_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_interval_day_to_second(::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { + clear_literal_type(); + if (interval_day_to_second) { + set_has_interval_day_to_second(); + literal_type_.interval_day_to_second_ = interval_day_to_second; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.interval_day_to_second) +} +inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::_internal_mutable_interval_day_to_second() { + if (!_internal_has_interval_day_to_second()) { + clear_literal_type(); + set_has_interval_day_to_second(); + literal_type_.interval_day_to_second_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalDayToSecond >(GetArena()); + } + return literal_type_.interval_day_to_second_; +} +inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::mutable_interval_day_to_second() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.interval_day_to_second) + return _internal_mutable_interval_day_to_second(); +} + +// string fixed_char = 21; +inline bool Expression_Literal::_internal_has_fixed_char() const { + return literal_type_case() == kFixedChar; +} +inline bool Expression_Literal::has_fixed_char() const { + return _internal_has_fixed_char(); +} +inline void Expression_Literal::set_has_fixed_char() { + _oneof_case_[0] = kFixedChar; +} +inline void Expression_Literal::clear_fixed_char() { + if (_internal_has_fixed_char()) { + literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } +} +inline const std::string& Expression_Literal::fixed_char() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fixed_char) + return _internal_fixed_char(); +} +template +inline void Expression_Literal::set_fixed_char(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_fixed_char()) { + clear_literal_type(); + set_has_fixed_char(); + literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fixed_char) +} +inline std::string* Expression_Literal::mutable_fixed_char() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.fixed_char) + return _internal_mutable_fixed_char(); +} +inline const std::string& Expression_Literal::_internal_fixed_char() const { + if (_internal_has_fixed_char()) { + return literal_type_.fixed_char_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Literal::_internal_set_fixed_char(const std::string& value) { + if (!_internal_has_fixed_char()) { + clear_literal_type(); + set_has_fixed_char(); + literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal::_internal_mutable_fixed_char() { + if (!_internal_has_fixed_char()) { + clear_literal_type(); + set_has_fixed_char(); + literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.fixed_char_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal::release_fixed_char() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.fixed_char) + if (_internal_has_fixed_char()) { + clear_has_literal_type(); + return literal_type_.fixed_char_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Literal::set_allocated_fixed_char(std::string* fixed_char) { + if (has_literal_type()) { + clear_literal_type(); + } + if (fixed_char != nullptr) { + set_has_fixed_char(); + literal_type_.fixed_char_.UnsafeSetDefault(fixed_char); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(fixed_char); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.fixed_char) +} + +// string var_char = 22; +inline bool Expression_Literal::_internal_has_var_char() const { + return literal_type_case() == kVarChar; +} +inline bool Expression_Literal::has_var_char() const { + return _internal_has_var_char(); +} +inline void Expression_Literal::set_has_var_char() { + _oneof_case_[0] = kVarChar; +} +inline void Expression_Literal::clear_var_char() { + if (_internal_has_var_char()) { + literal_type_.var_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } +} +inline const std::string& Expression_Literal::var_char() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.var_char) + return _internal_var_char(); +} +template +inline void Expression_Literal::set_var_char(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_var_char()) { + clear_literal_type(); + set_has_var_char(); + literal_type_.var_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.var_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.var_char) +} +inline std::string* Expression_Literal::mutable_var_char() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.var_char) + return _internal_mutable_var_char(); +} +inline const std::string& Expression_Literal::_internal_var_char() const { + if (_internal_has_var_char()) { + return literal_type_.var_char_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Literal::_internal_set_var_char(const std::string& value) { + if (!_internal_has_var_char()) { + clear_literal_type(); + set_has_var_char(); + literal_type_.var_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.var_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal::_internal_mutable_var_char() { + if (!_internal_has_var_char()) { + clear_literal_type(); + set_has_var_char(); + literal_type_.var_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.var_char_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal::release_var_char() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.var_char) + if (_internal_has_var_char()) { + clear_has_literal_type(); + return literal_type_.var_char_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Literal::set_allocated_var_char(std::string* var_char) { + if (has_literal_type()) { + clear_literal_type(); + } + if (var_char != nullptr) { + set_has_var_char(); + literal_type_.var_char_.UnsafeSetDefault(var_char); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(var_char); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.var_char) +} + +// bytes fixed_binary = 23; +inline bool Expression_Literal::_internal_has_fixed_binary() const { + return literal_type_case() == kFixedBinary; +} +inline bool Expression_Literal::has_fixed_binary() const { + return _internal_has_fixed_binary(); +} +inline void Expression_Literal::set_has_fixed_binary() { + _oneof_case_[0] = kFixedBinary; +} +inline void Expression_Literal::clear_fixed_binary() { + if (_internal_has_fixed_binary()) { + literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } +} +inline const std::string& Expression_Literal::fixed_binary() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fixed_binary) + return _internal_fixed_binary(); +} +template +inline void Expression_Literal::set_fixed_binary(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_fixed_binary()) { + clear_literal_type(); + set_has_fixed_binary(); + literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.fixed_binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fixed_binary) +} +inline std::string* Expression_Literal::mutable_fixed_binary() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.fixed_binary) + return _internal_mutable_fixed_binary(); +} +inline const std::string& Expression_Literal::_internal_fixed_binary() const { + if (_internal_has_fixed_binary()) { + return literal_type_.fixed_binary_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Literal::_internal_set_fixed_binary(const std::string& value) { + if (!_internal_has_fixed_binary()) { + clear_literal_type(); + set_has_fixed_binary(); + literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.fixed_binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal::_internal_mutable_fixed_binary() { + if (!_internal_has_fixed_binary()) { + clear_literal_type(); + set_has_fixed_binary(); + literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.fixed_binary_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal::release_fixed_binary() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.fixed_binary) + if (_internal_has_fixed_binary()) { + clear_has_literal_type(); + return literal_type_.fixed_binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Literal::set_allocated_fixed_binary(std::string* fixed_binary) { + if (has_literal_type()) { + clear_literal_type(); + } + if (fixed_binary != nullptr) { + set_has_fixed_binary(); + literal_type_.fixed_binary_.UnsafeSetDefault(fixed_binary); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(fixed_binary); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.fixed_binary) +} + +// bytes decimal = 24; +inline bool Expression_Literal::_internal_has_decimal() const { + return literal_type_case() == kDecimal; +} +inline bool Expression_Literal::has_decimal() const { + return _internal_has_decimal(); +} +inline void Expression_Literal::set_has_decimal() { + _oneof_case_[0] = kDecimal; +} +inline void Expression_Literal::clear_decimal() { + if (_internal_has_decimal()) { + literal_type_.decimal_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } +} +inline const std::string& Expression_Literal::decimal() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.decimal) + return _internal_decimal(); +} +template +inline void Expression_Literal::set_decimal(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_decimal()) { + clear_literal_type(); + set_has_decimal(); + literal_type_.decimal_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.decimal_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.decimal) +} +inline std::string* Expression_Literal::mutable_decimal() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.decimal) + return _internal_mutable_decimal(); +} +inline const std::string& Expression_Literal::_internal_decimal() const { + if (_internal_has_decimal()) { + return literal_type_.decimal_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Literal::_internal_set_decimal(const std::string& value) { + if (!_internal_has_decimal()) { + clear_literal_type(); + set_has_decimal(); + literal_type_.decimal_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.decimal_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal::_internal_mutable_decimal() { + if (!_internal_has_decimal()) { + clear_literal_type(); + set_has_decimal(); + literal_type_.decimal_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.decimal_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal::release_decimal() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.decimal) + if (_internal_has_decimal()) { + clear_has_literal_type(); + return literal_type_.decimal_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Literal::set_allocated_decimal(std::string* decimal) { + if (has_literal_type()) { + clear_literal_type(); + } + if (decimal != nullptr) { + set_has_decimal(); + literal_type_.decimal_.UnsafeSetDefault(decimal); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(decimal); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.decimal) +} + +// .io.substrait.Expression.Literal.Struct struct = 25; +inline bool Expression_Literal::_internal_has_struct_() const { + return literal_type_case() == kStruct; +} +inline bool Expression_Literal::has_struct_() const { + return _internal_has_struct_(); +} +inline void Expression_Literal::set_has_struct_() { + _oneof_case_[0] = kStruct; +} +inline void Expression_Literal::clear_struct_() { + if (_internal_has_struct_()) { + if (GetArena() == nullptr) { + delete literal_type_.struct__; + } + clear_has_literal_type(); + } +} +inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.struct) + if (_internal_has_struct_()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Literal_Struct& Expression_Literal::_internal_struct_() const { + return _internal_has_struct_() + ? *literal_type_.struct__ + : reinterpret_cast< ::io::substrait::Expression_Literal_Struct&>(::io::substrait::_Expression_Literal_Struct_default_instance_); +} +inline const ::io::substrait::Expression_Literal_Struct& Expression_Literal::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.struct) + return _internal_struct_(); +} +inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.struct) + if (_internal_has_struct_()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; + literal_type_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_struct_(::io::substrait::Expression_Literal_Struct* struct_) { + clear_literal_type(); + if (struct_) { + set_has_struct_(); + literal_type_.struct__ = struct_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.struct) +} +inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::_internal_mutable_struct_() { + if (!_internal_has_struct_()) { + clear_literal_type(); + set_has_struct_(); + literal_type_.struct__ = CreateMaybeMessage< ::io::substrait::Expression_Literal_Struct >(GetArena()); + } + return literal_type_.struct__; +} +inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.struct) + return _internal_mutable_struct_(); +} + +// .io.substrait.Expression.Literal.Map map = 26; +inline bool Expression_Literal::_internal_has_map() const { + return literal_type_case() == kMap; +} +inline bool Expression_Literal::has_map() const { + return _internal_has_map(); +} +inline void Expression_Literal::set_has_map() { + _oneof_case_[0] = kMap; +} +inline void Expression_Literal::clear_map() { + if (_internal_has_map()) { + if (GetArena() == nullptr) { + delete literal_type_.map_; + } + clear_has_literal_type(); + } +} +inline ::io::substrait::Expression_Literal_Map* Expression_Literal::release_map() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.map) + if (_internal_has_map()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_Map* temp = literal_type_.map_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Literal_Map& Expression_Literal::_internal_map() const { + return _internal_has_map() + ? *literal_type_.map_ + : reinterpret_cast< ::io::substrait::Expression_Literal_Map&>(::io::substrait::_Expression_Literal_Map_default_instance_); +} +inline const ::io::substrait::Expression_Literal_Map& Expression_Literal::map() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.map) + return _internal_map(); +} +inline ::io::substrait::Expression_Literal_Map* Expression_Literal::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.map) + if (_internal_has_map()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_Map* temp = literal_type_.map_; + literal_type_.map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_map(::io::substrait::Expression_Literal_Map* map) { + clear_literal_type(); + if (map) { + set_has_map(); + literal_type_.map_ = map; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.map) +} +inline ::io::substrait::Expression_Literal_Map* Expression_Literal::_internal_mutable_map() { + if (!_internal_has_map()) { + clear_literal_type(); + set_has_map(); + literal_type_.map_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_Map >(GetArena()); + } + return literal_type_.map_; +} +inline ::io::substrait::Expression_Literal_Map* Expression_Literal::mutable_map() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.map) + return _internal_mutable_map(); +} + +// fixed64 timestamp_tz = 27; +inline bool Expression_Literal::_internal_has_timestamp_tz() const { + return literal_type_case() == kTimestampTz; +} +inline bool Expression_Literal::has_timestamp_tz() const { + return _internal_has_timestamp_tz(); +} +inline void Expression_Literal::set_has_timestamp_tz() { + _oneof_case_[0] = kTimestampTz; +} +inline void Expression_Literal::clear_timestamp_tz() { + if (_internal_has_timestamp_tz()) { + literal_type_.timestamp_tz_ = PROTOBUF_ULONGLONG(0); + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::_internal_timestamp_tz() const { + if (_internal_has_timestamp_tz()) { + return literal_type_.timestamp_tz_; + } + return PROTOBUF_ULONGLONG(0); +} +inline void Expression_Literal::_internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::uint64 value) { + if (!_internal_has_timestamp_tz()) { + clear_literal_type(); + set_has_timestamp_tz(); + } + literal_type_.timestamp_tz_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::timestamp_tz() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.timestamp_tz) + return _internal_timestamp_tz(); +} +inline void Expression_Literal::set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_timestamp_tz(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.timestamp_tz) +} + +// bytes uuid = 28; +inline bool Expression_Literal::_internal_has_uuid() const { + return literal_type_case() == kUuid; +} +inline bool Expression_Literal::has_uuid() const { + return _internal_has_uuid(); +} +inline void Expression_Literal::set_has_uuid() { + _oneof_case_[0] = kUuid; +} +inline void Expression_Literal::clear_uuid() { + if (_internal_has_uuid()) { + literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } +} +inline const std::string& Expression_Literal::uuid() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.uuid) + return _internal_uuid(); +} +template +inline void Expression_Literal::set_uuid(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_uuid()) { + clear_literal_type(); + set_has_uuid(); + literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.uuid_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.uuid) +} +inline std::string* Expression_Literal::mutable_uuid() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.uuid) + return _internal_mutable_uuid(); +} +inline const std::string& Expression_Literal::_internal_uuid() const { + if (_internal_has_uuid()) { + return literal_type_.uuid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Literal::_internal_set_uuid(const std::string& value) { + if (!_internal_has_uuid()) { + clear_literal_type(); + set_has_uuid(); + literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal::_internal_mutable_uuid() { + if (!_internal_has_uuid()) { + clear_literal_type(); + set_has_uuid(); + literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.uuid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal::release_uuid() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.uuid) + if (_internal_has_uuid()) { + clear_has_literal_type(); + return literal_type_.uuid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Literal::set_allocated_uuid(std::string* uuid) { + if (has_literal_type()) { + clear_literal_type(); + } + if (uuid != nullptr) { + set_has_uuid(); + literal_type_.uuid_.UnsafeSetDefault(uuid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(uuid); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.uuid) +} + +// .io.substrait.Type null = 29; +inline bool Expression_Literal::_internal_has_null() const { + return literal_type_case() == kNull; +} +inline bool Expression_Literal::has_null() const { + return _internal_has_null(); +} +inline void Expression_Literal::set_has_null() { + _oneof_case_[0] = kNull; +} +inline ::io::substrait::Type* Expression_Literal::release_null() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.null) + if (_internal_has_null()) { + clear_has_literal_type(); + ::io::substrait::Type* temp = literal_type_.null_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.null_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type& Expression_Literal::_internal_null() const { + return _internal_has_null() + ? *literal_type_.null_ + : reinterpret_cast< ::io::substrait::Type&>(::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Expression_Literal::null() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.null) + return _internal_null(); +} +inline ::io::substrait::Type* Expression_Literal::unsafe_arena_release_null() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.null) + if (_internal_has_null()) { + clear_has_literal_type(); + ::io::substrait::Type* temp = literal_type_.null_; + literal_type_.null_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_null(::io::substrait::Type* null) { + clear_literal_type(); + if (null) { + set_has_null(); + literal_type_.null_ = null; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.null) +} +inline ::io::substrait::Type* Expression_Literal::_internal_mutable_null() { + if (!_internal_has_null()) { + clear_literal_type(); + set_has_null(); + literal_type_.null_ = CreateMaybeMessage< ::io::substrait::Type >(GetArena()); + } + return literal_type_.null_; +} +inline ::io::substrait::Type* Expression_Literal::mutable_null() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.null) + return _internal_mutable_null(); +} + +// .io.substrait.Expression.Literal.List list = 30; +inline bool Expression_Literal::_internal_has_list() const { + return literal_type_case() == kList; +} +inline bool Expression_Literal::has_list() const { + return _internal_has_list(); +} +inline void Expression_Literal::set_has_list() { + _oneof_case_[0] = kList; +} +inline void Expression_Literal::clear_list() { + if (_internal_has_list()) { + if (GetArena() == nullptr) { + delete literal_type_.list_; + } + clear_has_literal_type(); + } +} +inline ::io::substrait::Expression_Literal_List* Expression_Literal::release_list() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.list) + if (_internal_has_list()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_List* temp = literal_type_.list_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Literal_List& Expression_Literal::_internal_list() const { + return _internal_has_list() + ? *literal_type_.list_ + : reinterpret_cast< ::io::substrait::Expression_Literal_List&>(::io::substrait::_Expression_Literal_List_default_instance_); +} +inline const ::io::substrait::Expression_Literal_List& Expression_Literal::list() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.list) + return _internal_list(); +} +inline ::io::substrait::Expression_Literal_List* Expression_Literal::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.list) + if (_internal_has_list()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_List* temp = literal_type_.list_; + literal_type_.list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_list(::io::substrait::Expression_Literal_List* list) { + clear_literal_type(); + if (list) { + set_has_list(); + literal_type_.list_ = list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.list) +} +inline ::io::substrait::Expression_Literal_List* Expression_Literal::_internal_mutable_list() { + if (!_internal_has_list()) { + clear_literal_type(); + set_has_list(); + literal_type_.list_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_List >(GetArena()); + } + return literal_type_.list_; +} +inline ::io::substrait::Expression_Literal_List* Expression_Literal::mutable_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.list) + return _internal_mutable_list(); +} + +inline bool Expression_Literal::has_literal_type() const { + return literal_type_case() != LITERAL_TYPE_NOT_SET; +} +inline void Expression_Literal::clear_has_literal_type() { + _oneof_case_[0] = LITERAL_TYPE_NOT_SET; +} +inline Expression_Literal::LiteralTypeCase Expression_Literal::literal_type_case() const { + return Expression_Literal::LiteralTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Expression_ScalarFunction + +// .io.substrait.Extensions.FunctionId id = 1; +inline bool Expression_ScalarFunction::_internal_has_id() const { + return this != internal_default_instance() && id_ != nullptr; +} +inline bool Expression_ScalarFunction::has_id() const { + return _internal_has_id(); +} +inline const ::io::substrait::Extensions_FunctionId& Expression_ScalarFunction::_internal_id() const { + const ::io::substrait::Extensions_FunctionId* p = id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_FunctionId_default_instance_); +} +inline const ::io::substrait::Extensions_FunctionId& Expression_ScalarFunction::id() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.id) + return _internal_id(); +} +inline void Expression_ScalarFunction::unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + id_ = id; + if (id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ScalarFunction.id) +} +inline ::io::substrait::Extensions_FunctionId* Expression_ScalarFunction::release_id() { + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_FunctionId* Expression_ScalarFunction::unsafe_arena_release_id() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.ScalarFunction.id) + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_FunctionId* Expression_ScalarFunction::_internal_mutable_id() { + + if (id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); + id_ = p; + } + return id_; +} +inline ::io::substrait::Extensions_FunctionId* Expression_ScalarFunction::mutable_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ScalarFunction.id) + return _internal_mutable_id(); +} +inline void Expression_ScalarFunction::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + if (id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); + if (message_arena != submessage_arena) { + id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, id, submessage_arena); + } + + } else { + + } + id_ = id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ScalarFunction.id) +} + +// repeated .io.substrait.Expression args = 2; +inline int Expression_ScalarFunction::_internal_args_size() const { + return args_.size(); +} +inline int Expression_ScalarFunction::args_size() const { + return _internal_args_size(); +} +inline void Expression_ScalarFunction::clear_args() { + args_.Clear(); +} +inline ::io::substrait::Expression* Expression_ScalarFunction::mutable_args(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ScalarFunction.args) + return args_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_ScalarFunction::mutable_args() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.ScalarFunction.args) + return &args_; +} +inline const ::io::substrait::Expression& Expression_ScalarFunction::_internal_args(int index) const { + return args_.Get(index); +} +inline const ::io::substrait::Expression& Expression_ScalarFunction::args(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.args) + return _internal_args(index); +} +inline ::io::substrait::Expression* Expression_ScalarFunction::_internal_add_args() { + return args_.Add(); +} +inline ::io::substrait::Expression* Expression_ScalarFunction::add_args() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.ScalarFunction.args) + return _internal_add_args(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_ScalarFunction::args() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.ScalarFunction.args) + return args_; +} + +// .io.substrait.Type output_type = 3; +inline bool Expression_ScalarFunction::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; +} +inline bool Expression_ScalarFunction::has_output_type() const { + return _internal_has_output_type(); +} +inline const ::io::substrait::Type& Expression_ScalarFunction::_internal_output_type() const { + const ::io::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Expression_ScalarFunction::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.output_type) + return _internal_output_type(); +} +inline void Expression_ScalarFunction::unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + output_type_ = output_type; + if (output_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ScalarFunction.output_type) +} +inline ::io::substrait::Type* Expression_ScalarFunction::release_output_type() { + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* Expression_ScalarFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.ScalarFunction.output_type) + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Expression_ScalarFunction::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + output_type_ = p; + } + return output_type_; +} +inline ::io::substrait::Type* Expression_ScalarFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ScalarFunction.output_type) + return _internal_mutable_output_type(); +} +inline void Expression_ScalarFunction::set_allocated_output_type(::io::substrait::Type* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); + } + + } else { + + } + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ScalarFunction.output_type) +} + +// ------------------------------------------------------------------- + +// Expression_AggregateFunction + +// .io.substrait.Extensions.FunctionId id = 1; +inline bool Expression_AggregateFunction::_internal_has_id() const { + return this != internal_default_instance() && id_ != nullptr; +} +inline bool Expression_AggregateFunction::has_id() const { + return _internal_has_id(); +} +inline const ::io::substrait::Extensions_FunctionId& Expression_AggregateFunction::_internal_id() const { + const ::io::substrait::Extensions_FunctionId* p = id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_FunctionId_default_instance_); +} +inline const ::io::substrait::Extensions_FunctionId& Expression_AggregateFunction::id() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.AggregateFunction.id) + return _internal_id(); +} +inline void Expression_AggregateFunction::unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + id_ = id; + if (id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.AggregateFunction.id) +} +inline ::io::substrait::Extensions_FunctionId* Expression_AggregateFunction::release_id() { + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_FunctionId* Expression_AggregateFunction::unsafe_arena_release_id() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.AggregateFunction.id) + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_FunctionId* Expression_AggregateFunction::_internal_mutable_id() { + + if (id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); + id_ = p; + } + return id_; +} +inline ::io::substrait::Extensions_FunctionId* Expression_AggregateFunction::mutable_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.AggregateFunction.id) + return _internal_mutable_id(); +} +inline void Expression_AggregateFunction::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + if (id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); + if (message_arena != submessage_arena) { + id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, id, submessage_arena); + } + + } else { + + } + id_ = id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.AggregateFunction.id) +} + +// repeated .io.substrait.Expression args = 2; +inline int Expression_AggregateFunction::_internal_args_size() const { + return args_.size(); +} +inline int Expression_AggregateFunction::args_size() const { + return _internal_args_size(); +} +inline void Expression_AggregateFunction::clear_args() { + args_.Clear(); +} +inline ::io::substrait::Expression* Expression_AggregateFunction::mutable_args(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.AggregateFunction.args) + return args_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_AggregateFunction::mutable_args() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.AggregateFunction.args) + return &args_; +} +inline const ::io::substrait::Expression& Expression_AggregateFunction::_internal_args(int index) const { + return args_.Get(index); +} +inline const ::io::substrait::Expression& Expression_AggregateFunction::args(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.AggregateFunction.args) + return _internal_args(index); +} +inline ::io::substrait::Expression* Expression_AggregateFunction::_internal_add_args() { + return args_.Add(); +} +inline ::io::substrait::Expression* Expression_AggregateFunction::add_args() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.AggregateFunction.args) + return _internal_add_args(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_AggregateFunction::args() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.AggregateFunction.args) + return args_; +} + +// repeated .io.substrait.Expression.SortField sorts = 3; +inline int Expression_AggregateFunction::_internal_sorts_size() const { + return sorts_.size(); +} +inline int Expression_AggregateFunction::sorts_size() const { + return _internal_sorts_size(); +} +inline void Expression_AggregateFunction::clear_sorts() { + sorts_.Clear(); +} +inline ::io::substrait::Expression_SortField* Expression_AggregateFunction::mutable_sorts(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.AggregateFunction.sorts) + return sorts_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* +Expression_AggregateFunction::mutable_sorts() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.AggregateFunction.sorts) + return &sorts_; +} +inline const ::io::substrait::Expression_SortField& Expression_AggregateFunction::_internal_sorts(int index) const { + return sorts_.Get(index); +} +inline const ::io::substrait::Expression_SortField& Expression_AggregateFunction::sorts(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.AggregateFunction.sorts) + return _internal_sorts(index); +} +inline ::io::substrait::Expression_SortField* Expression_AggregateFunction::_internal_add_sorts() { + return sorts_.Add(); +} +inline ::io::substrait::Expression_SortField* Expression_AggregateFunction::add_sorts() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.AggregateFunction.sorts) + return _internal_add_sorts(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& +Expression_AggregateFunction::sorts() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.AggregateFunction.sorts) + return sorts_; +} + +// .io.substrait.Expression.AggregationPhase phase = 4; +inline void Expression_AggregateFunction::clear_phase() { + phase_ = 0; +} +inline ::io::substrait::Expression_AggregationPhase Expression_AggregateFunction::_internal_phase() const { + return static_cast< ::io::substrait::Expression_AggregationPhase >(phase_); +} +inline ::io::substrait::Expression_AggregationPhase Expression_AggregateFunction::phase() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.AggregateFunction.phase) + return _internal_phase(); +} +inline void Expression_AggregateFunction::_internal_set_phase(::io::substrait::Expression_AggregationPhase value) { + + phase_ = value; +} +inline void Expression_AggregateFunction::set_phase(::io::substrait::Expression_AggregationPhase value) { + _internal_set_phase(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.AggregateFunction.phase) +} + +// .io.substrait.Type output_type = 5; +inline bool Expression_AggregateFunction::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; +} +inline bool Expression_AggregateFunction::has_output_type() const { + return _internal_has_output_type(); +} +inline const ::io::substrait::Type& Expression_AggregateFunction::_internal_output_type() const { + const ::io::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Expression_AggregateFunction::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.AggregateFunction.output_type) + return _internal_output_type(); +} +inline void Expression_AggregateFunction::unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + output_type_ = output_type; + if (output_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.AggregateFunction.output_type) +} +inline ::io::substrait::Type* Expression_AggregateFunction::release_output_type() { + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* Expression_AggregateFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.AggregateFunction.output_type) + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Expression_AggregateFunction::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + output_type_ = p; + } + return output_type_; +} +inline ::io::substrait::Type* Expression_AggregateFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.AggregateFunction.output_type) + return _internal_mutable_output_type(); +} +inline void Expression_AggregateFunction::set_allocated_output_type(::io::substrait::Type* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); + } + + } else { + + } + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.AggregateFunction.output_type) +} + +// ------------------------------------------------------------------- + +// Expression_WindowFunction_Bound_Preceding + +// int64 offset = 1; +inline void Expression_WindowFunction_Bound_Preceding::clear_offset() { + offset_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Preceding::_internal_offset() const { + return offset_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Preceding::offset() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.Preceding.offset) + return _internal_offset(); +} +inline void Expression_WindowFunction_Bound_Preceding::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + + offset_ = value; +} +inline void Expression_WindowFunction_Bound_Preceding::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.Bound.Preceding.offset) +} + +// ------------------------------------------------------------------- + +// Expression_WindowFunction_Bound_Following + +// int64 offset = 1; +inline void Expression_WindowFunction_Bound_Following::clear_offset() { + offset_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Following::_internal_offset() const { + return offset_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Following::offset() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.Following.offset) + return _internal_offset(); +} +inline void Expression_WindowFunction_Bound_Following::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + + offset_ = value; +} +inline void Expression_WindowFunction_Bound_Following::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.Bound.Following.offset) +} + +// ------------------------------------------------------------------- + +// Expression_WindowFunction_Bound_CurrentRow + +// ------------------------------------------------------------------- + +// Expression_WindowFunction_Bound_Unbounded + +// ------------------------------------------------------------------- + +// Expression_WindowFunction_Bound + +// .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; +inline bool Expression_WindowFunction_Bound::_internal_has_preceding() const { + return kind_case() == kPreceding; +} +inline bool Expression_WindowFunction_Bound::has_preceding() const { + return _internal_has_preceding(); +} +inline void Expression_WindowFunction_Bound::set_has_preceding() { + _oneof_case_[0] = kPreceding; +} +inline void Expression_WindowFunction_Bound::clear_preceding() { + if (_internal_has_preceding()) { + if (GetArena() == nullptr) { + delete kind_.preceding_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::release_preceding() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.preceding) + if (_internal_has_preceding()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.preceding_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::_internal_preceding() const { + return _internal_has_preceding() + ? *kind_.preceding_ + : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Preceding&>(::io::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::preceding() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.preceding) + return _internal_preceding(); +} +inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::unsafe_arena_release_preceding() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.preceding) + if (_internal_has_preceding()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; + kind_.preceding_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_preceding(::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { + clear_kind(); + if (preceding) { + set_has_preceding(); + kind_.preceding_ = preceding; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.preceding) +} +inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::_internal_mutable_preceding() { + if (!_internal_has_preceding()) { + clear_kind(); + set_has_preceding(); + kind_.preceding_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Preceding >(GetArena()); + } + return kind_.preceding_; +} +inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::mutable_preceding() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.preceding) + return _internal_mutable_preceding(); +} + +// .io.substrait.Expression.WindowFunction.Bound.Following following = 2; +inline bool Expression_WindowFunction_Bound::_internal_has_following() const { + return kind_case() == kFollowing; +} +inline bool Expression_WindowFunction_Bound::has_following() const { + return _internal_has_following(); +} +inline void Expression_WindowFunction_Bound::set_has_following() { + _oneof_case_[0] = kFollowing; +} +inline void Expression_WindowFunction_Bound::clear_following() { + if (_internal_has_following()) { + if (GetArena() == nullptr) { + delete kind_.following_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::release_following() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.following) + if (_internal_has_following()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.following_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::_internal_following() const { + return _internal_has_following() + ? *kind_.following_ + : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Following&>(::io::substrait::_Expression_WindowFunction_Bound_Following_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::following() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.following) + return _internal_following(); +} +inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::unsafe_arena_release_following() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.following) + if (_internal_has_following()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; + kind_.following_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_following(::io::substrait::Expression_WindowFunction_Bound_Following* following) { + clear_kind(); + if (following) { + set_has_following(); + kind_.following_ = following; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.following) +} +inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::_internal_mutable_following() { + if (!_internal_has_following()) { + clear_kind(); + set_has_following(); + kind_.following_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Following >(GetArena()); + } + return kind_.following_; +} +inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::mutable_following() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.following) + return _internal_mutable_following(); +} + +// .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; +inline bool Expression_WindowFunction_Bound::_internal_has_current_row() const { + return kind_case() == kCurrentRow; +} +inline bool Expression_WindowFunction_Bound::has_current_row() const { + return _internal_has_current_row(); +} +inline void Expression_WindowFunction_Bound::set_has_current_row() { + _oneof_case_[0] = kCurrentRow; +} +inline void Expression_WindowFunction_Bound::clear_current_row() { + if (_internal_has_current_row()) { + if (GetArena() == nullptr) { + delete kind_.current_row_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::release_current_row() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.current_row) + if (_internal_has_current_row()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.current_row_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::_internal_current_row() const { + return _internal_has_current_row() + ? *kind_.current_row_ + : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow&>(::io::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::current_row() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.current_row) + return _internal_current_row(); +} +inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::unsafe_arena_release_current_row() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.current_row) + if (_internal_has_current_row()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; + kind_.current_row_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_current_row(::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { + clear_kind(); + if (current_row) { + set_has_current_row(); + kind_.current_row_ = current_row; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.current_row) +} +inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::_internal_mutable_current_row() { + if (!_internal_has_current_row()) { + clear_kind(); + set_has_current_row(); + kind_.current_row_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow >(GetArena()); + } + return kind_.current_row_; +} +inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::mutable_current_row() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.current_row) + return _internal_mutable_current_row(); +} + +// .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; +inline bool Expression_WindowFunction_Bound::_internal_has_unbounded() const { + return kind_case() == kUnbounded; +} +inline bool Expression_WindowFunction_Bound::has_unbounded() const { + return _internal_has_unbounded(); +} +inline void Expression_WindowFunction_Bound::set_has_unbounded() { + _oneof_case_[0] = kUnbounded; +} +inline void Expression_WindowFunction_Bound::clear_unbounded() { + if (_internal_has_unbounded()) { + if (GetArena() == nullptr) { + delete kind_.unbounded_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::release_unbounded() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.unbounded) + if (_internal_has_unbounded()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.unbounded_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::_internal_unbounded() const { + return _internal_has_unbounded() + ? *kind_.unbounded_ + : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Unbounded&>(::io::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::unbounded() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.unbounded) + return _internal_unbounded(); +} +inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::unsafe_arena_release_unbounded() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.unbounded) + if (_internal_has_unbounded()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; + kind_.unbounded_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_unbounded(::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { + clear_kind(); + if (unbounded) { + set_has_unbounded(); + kind_.unbounded_ = unbounded; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.unbounded) +} +inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::_internal_mutable_unbounded() { + if (!_internal_has_unbounded()) { + clear_kind(); + set_has_unbounded(); + kind_.unbounded_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Unbounded >(GetArena()); + } + return kind_.unbounded_; +} +inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::mutable_unbounded() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.unbounded) + return _internal_mutable_unbounded(); +} + +inline bool Expression_WindowFunction_Bound::has_kind() const { + return kind_case() != KIND_NOT_SET; +} +inline void Expression_WindowFunction_Bound::clear_has_kind() { + _oneof_case_[0] = KIND_NOT_SET; +} +inline Expression_WindowFunction_Bound::KindCase Expression_WindowFunction_Bound::kind_case() const { + return Expression_WindowFunction_Bound::KindCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Expression_WindowFunction + +// .io.substrait.Extensions.FunctionId id = 1; +inline bool Expression_WindowFunction::_internal_has_id() const { + return this != internal_default_instance() && id_ != nullptr; +} +inline bool Expression_WindowFunction::has_id() const { + return _internal_has_id(); +} +inline const ::io::substrait::Extensions_FunctionId& Expression_WindowFunction::_internal_id() const { + const ::io::substrait::Extensions_FunctionId* p = id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_FunctionId_default_instance_); +} +inline const ::io::substrait::Extensions_FunctionId& Expression_WindowFunction::id() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.id) + return _internal_id(); +} +inline void Expression_WindowFunction::unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + id_ = id; + if (id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.id) +} +inline ::io::substrait::Extensions_FunctionId* Expression_WindowFunction::release_id() { + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_FunctionId* Expression_WindowFunction::unsafe_arena_release_id() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.id) + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_FunctionId* Expression_WindowFunction::_internal_mutable_id() { + + if (id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); + id_ = p; + } + return id_; +} +inline ::io::substrait::Extensions_FunctionId* Expression_WindowFunction::mutable_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.id) + return _internal_mutable_id(); +} +inline void Expression_WindowFunction::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + if (id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); + if (message_arena != submessage_arena) { + id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, id, submessage_arena); + } + + } else { + + } + id_ = id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.id) +} + +// repeated .io.substrait.Expression partitions = 2; +inline int Expression_WindowFunction::_internal_partitions_size() const { + return partitions_.size(); +} +inline int Expression_WindowFunction::partitions_size() const { + return _internal_partitions_size(); +} +inline void Expression_WindowFunction::clear_partitions() { + partitions_.Clear(); +} +inline ::io::substrait::Expression* Expression_WindowFunction::mutable_partitions(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.partitions) + return partitions_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_WindowFunction::mutable_partitions() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.partitions) + return &partitions_; +} +inline const ::io::substrait::Expression& Expression_WindowFunction::_internal_partitions(int index) const { + return partitions_.Get(index); +} +inline const ::io::substrait::Expression& Expression_WindowFunction::partitions(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.partitions) + return _internal_partitions(index); +} +inline ::io::substrait::Expression* Expression_WindowFunction::_internal_add_partitions() { + return partitions_.Add(); +} +inline ::io::substrait::Expression* Expression_WindowFunction::add_partitions() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.partitions) + return _internal_add_partitions(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_WindowFunction::partitions() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.partitions) + return partitions_; +} + +// repeated .io.substrait.Expression.SortField sorts = 3; +inline int Expression_WindowFunction::_internal_sorts_size() const { + return sorts_.size(); +} +inline int Expression_WindowFunction::sorts_size() const { + return _internal_sorts_size(); +} +inline void Expression_WindowFunction::clear_sorts() { + sorts_.Clear(); +} +inline ::io::substrait::Expression_SortField* Expression_WindowFunction::mutable_sorts(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.sorts) + return sorts_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* +Expression_WindowFunction::mutable_sorts() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.sorts) + return &sorts_; +} +inline const ::io::substrait::Expression_SortField& Expression_WindowFunction::_internal_sorts(int index) const { + return sorts_.Get(index); +} +inline const ::io::substrait::Expression_SortField& Expression_WindowFunction::sorts(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.sorts) + return _internal_sorts(index); +} +inline ::io::substrait::Expression_SortField* Expression_WindowFunction::_internal_add_sorts() { + return sorts_.Add(); +} +inline ::io::substrait::Expression_SortField* Expression_WindowFunction::add_sorts() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.sorts) + return _internal_add_sorts(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& +Expression_WindowFunction::sorts() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.sorts) + return sorts_; +} + +// .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; +inline bool Expression_WindowFunction::_internal_has_upper_bound() const { + return this != internal_default_instance() && upper_bound_ != nullptr; +} +inline bool Expression_WindowFunction::has_upper_bound() const { + return _internal_has_upper_bound(); +} +inline void Expression_WindowFunction::clear_upper_bound() { + if (GetArena() == nullptr && upper_bound_ != nullptr) { + delete upper_bound_; + } + upper_bound_ = nullptr; +} +inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_upper_bound() const { + const ::io::substrait::Expression_WindowFunction_Bound* p = upper_bound_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_WindowFunction_Bound_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::upper_bound() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.upper_bound) + return _internal_upper_bound(); +} +inline void Expression_WindowFunction::unsafe_arena_set_allocated_upper_bound( + ::io::substrait::Expression_WindowFunction_Bound* upper_bound) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(upper_bound_); + } + upper_bound_ = upper_bound; + if (upper_bound) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.upper_bound) +} +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_upper_bound() { + + ::io::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; + upper_bound_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_upper_bound() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.upper_bound) + + ::io::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; + upper_bound_ = nullptr; + return temp; +} +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_upper_bound() { + + if (upper_bound_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound>(GetArena()); + upper_bound_ = p; + } + return upper_bound_; +} +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_upper_bound() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.upper_bound) + return _internal_mutable_upper_bound(); +} +inline void Expression_WindowFunction::set_allocated_upper_bound(::io::substrait::Expression_WindowFunction_Bound* upper_bound) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete upper_bound_; + } + if (upper_bound) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(upper_bound); + if (message_arena != submessage_arena) { + upper_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, upper_bound, submessage_arena); + } + + } else { + + } + upper_bound_ = upper_bound; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.upper_bound) +} + +// .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; +inline bool Expression_WindowFunction::_internal_has_lower_bound() const { + return this != internal_default_instance() && lower_bound_ != nullptr; +} +inline bool Expression_WindowFunction::has_lower_bound() const { + return _internal_has_lower_bound(); +} +inline void Expression_WindowFunction::clear_lower_bound() { + if (GetArena() == nullptr && lower_bound_ != nullptr) { + delete lower_bound_; + } + lower_bound_ = nullptr; +} +inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_lower_bound() const { + const ::io::substrait::Expression_WindowFunction_Bound* p = lower_bound_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_WindowFunction_Bound_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::lower_bound() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.lower_bound) + return _internal_lower_bound(); +} +inline void Expression_WindowFunction::unsafe_arena_set_allocated_lower_bound( + ::io::substrait::Expression_WindowFunction_Bound* lower_bound) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lower_bound_); + } + lower_bound_ = lower_bound; + if (lower_bound) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.lower_bound) +} +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_lower_bound() { + + ::io::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; + lower_bound_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_lower_bound() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.lower_bound) + + ::io::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; + lower_bound_ = nullptr; + return temp; +} +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_lower_bound() { + + if (lower_bound_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound>(GetArena()); + lower_bound_ = p; + } + return lower_bound_; +} +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_lower_bound() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.lower_bound) + return _internal_mutable_lower_bound(); +} +inline void Expression_WindowFunction::set_allocated_lower_bound(::io::substrait::Expression_WindowFunction_Bound* lower_bound) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete lower_bound_; + } + if (lower_bound) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lower_bound); + if (message_arena != submessage_arena) { + lower_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, lower_bound, submessage_arena); + } + + } else { + + } + lower_bound_ = lower_bound; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.lower_bound) +} + +// .io.substrait.Expression.AggregationPhase phase = 6; +inline void Expression_WindowFunction::clear_phase() { + phase_ = 0; +} +inline ::io::substrait::Expression_AggregationPhase Expression_WindowFunction::_internal_phase() const { + return static_cast< ::io::substrait::Expression_AggregationPhase >(phase_); +} +inline ::io::substrait::Expression_AggregationPhase Expression_WindowFunction::phase() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.phase) + return _internal_phase(); +} +inline void Expression_WindowFunction::_internal_set_phase(::io::substrait::Expression_AggregationPhase value) { + + phase_ = value; +} +inline void Expression_WindowFunction::set_phase(::io::substrait::Expression_AggregationPhase value) { + _internal_set_phase(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.phase) +} + +// .io.substrait.Type output_type = 7; +inline bool Expression_WindowFunction::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; +} +inline bool Expression_WindowFunction::has_output_type() const { + return _internal_has_output_type(); +} +inline const ::io::substrait::Type& Expression_WindowFunction::_internal_output_type() const { + const ::io::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Expression_WindowFunction::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.output_type) + return _internal_output_type(); +} +inline void Expression_WindowFunction::unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + output_type_ = output_type; + if (output_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.output_type) +} +inline ::io::substrait::Type* Expression_WindowFunction::release_output_type() { + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* Expression_WindowFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.output_type) + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Expression_WindowFunction::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + output_type_ = p; + } + return output_type_; +} +inline ::io::substrait::Type* Expression_WindowFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.output_type) + return _internal_mutable_output_type(); +} +inline void Expression_WindowFunction::set_allocated_output_type(::io::substrait::Type* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); + } + + } else { + + } + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.output_type) +} + +// repeated .io.substrait.Expression args = 8; +inline int Expression_WindowFunction::_internal_args_size() const { + return args_.size(); +} +inline int Expression_WindowFunction::args_size() const { + return _internal_args_size(); +} +inline void Expression_WindowFunction::clear_args() { + args_.Clear(); +} +inline ::io::substrait::Expression* Expression_WindowFunction::mutable_args(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.args) + return args_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_WindowFunction::mutable_args() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.args) + return &args_; +} +inline const ::io::substrait::Expression& Expression_WindowFunction::_internal_args(int index) const { + return args_.Get(index); +} +inline const ::io::substrait::Expression& Expression_WindowFunction::args(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.args) + return _internal_args(index); +} +inline ::io::substrait::Expression* Expression_WindowFunction::_internal_add_args() { + return args_.Add(); +} +inline ::io::substrait::Expression* Expression_WindowFunction::add_args() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.args) + return _internal_add_args(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_WindowFunction::args() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.args) + return args_; +} + +// ------------------------------------------------------------------- + +// Expression_SortField + +// .io.substrait.Expression expr = 1; +inline bool Expression_SortField::_internal_has_expr() const { + return this != internal_default_instance() && expr_ != nullptr; +} +inline bool Expression_SortField::has_expr() const { + return _internal_has_expr(); +} +inline void Expression_SortField::clear_expr() { + if (GetArena() == nullptr && expr_ != nullptr) { + delete expr_; + } + expr_ = nullptr; +} +inline const ::io::substrait::Expression& Expression_SortField::_internal_expr() const { + const ::io::substrait::Expression* p = expr_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_SortField::expr() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SortField.expr) + return _internal_expr(); +} +inline void Expression_SortField::unsafe_arena_set_allocated_expr( + ::io::substrait::Expression* expr) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_); + } + expr_ = expr; + if (expr) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SortField.expr) +} +inline ::io::substrait::Expression* Expression_SortField::release_expr() { + + ::io::substrait::Expression* temp = expr_; + expr_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* Expression_SortField::unsafe_arena_release_expr() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.SortField.expr) + + ::io::substrait::Expression* temp = expr_; + expr_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_SortField::_internal_mutable_expr() { + + if (expr_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + expr_ = p; + } + return expr_; +} +inline ::io::substrait::Expression* Expression_SortField::mutable_expr() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SortField.expr) + return _internal_mutable_expr(); +} +inline void Expression_SortField::set_allocated_expr(::io::substrait::Expression* expr) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete expr_; + } + if (expr) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expr); + if (message_arena != submessage_arena) { + expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expr, submessage_arena); + } + + } else { + + } + expr_ = expr; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SortField.expr) +} + +// .io.substrait.Expression.SortField.SortDirection direction = 2; +inline bool Expression_SortField::_internal_has_direction() const { + return sort_kind_case() == kDirection; +} +inline bool Expression_SortField::has_direction() const { + return _internal_has_direction(); +} +inline void Expression_SortField::set_has_direction() { + _oneof_case_[0] = kDirection; +} +inline void Expression_SortField::clear_direction() { + if (_internal_has_direction()) { + sort_kind_.direction_ = 0; + clear_has_sort_kind(); + } +} +inline ::io::substrait::Expression_SortField_SortDirection Expression_SortField::_internal_direction() const { + if (_internal_has_direction()) { + return static_cast< ::io::substrait::Expression_SortField_SortDirection >(sort_kind_.direction_); + } + return static_cast< ::io::substrait::Expression_SortField_SortDirection >(0); +} +inline ::io::substrait::Expression_SortField_SortDirection Expression_SortField::direction() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SortField.direction) + return _internal_direction(); +} +inline void Expression_SortField::_internal_set_direction(::io::substrait::Expression_SortField_SortDirection value) { + if (!_internal_has_direction()) { + clear_sort_kind(); + set_has_direction(); + } + sort_kind_.direction_ = value; +} +inline void Expression_SortField::set_direction(::io::substrait::Expression_SortField_SortDirection value) { + // @@protoc_insertion_point(field_set:io.substrait.Expression.SortField.direction) + _internal_set_direction(value); +} + +// .io.substrait.Extensions.FunctionId comparison_function = 3; +inline bool Expression_SortField::_internal_has_comparison_function() const { + return sort_kind_case() == kComparisonFunction; +} +inline bool Expression_SortField::has_comparison_function() const { + return _internal_has_comparison_function(); +} +inline void Expression_SortField::set_has_comparison_function() { + _oneof_case_[0] = kComparisonFunction; +} +inline ::io::substrait::Extensions_FunctionId* Expression_SortField::release_comparison_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.SortField.comparison_function) + if (_internal_has_comparison_function()) { + clear_has_sort_kind(); + ::io::substrait::Extensions_FunctionId* temp = sort_kind_.comparison_function_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + sort_kind_.comparison_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Extensions_FunctionId& Expression_SortField::_internal_comparison_function() const { + return _internal_has_comparison_function() + ? *sort_kind_.comparison_function_ + : reinterpret_cast< ::io::substrait::Extensions_FunctionId&>(::io::substrait::_Extensions_FunctionId_default_instance_); +} +inline const ::io::substrait::Extensions_FunctionId& Expression_SortField::comparison_function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SortField.comparison_function) + return _internal_comparison_function(); +} +inline ::io::substrait::Extensions_FunctionId* Expression_SortField::unsafe_arena_release_comparison_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.SortField.comparison_function) + if (_internal_has_comparison_function()) { + clear_has_sort_kind(); + ::io::substrait::Extensions_FunctionId* temp = sort_kind_.comparison_function_; + sort_kind_.comparison_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_SortField::unsafe_arena_set_allocated_comparison_function(::io::substrait::Extensions_FunctionId* comparison_function) { + clear_sort_kind(); + if (comparison_function) { + set_has_comparison_function(); + sort_kind_.comparison_function_ = comparison_function; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SortField.comparison_function) +} +inline ::io::substrait::Extensions_FunctionId* Expression_SortField::_internal_mutable_comparison_function() { + if (!_internal_has_comparison_function()) { + clear_sort_kind(); + set_has_comparison_function(); + sort_kind_.comparison_function_ = CreateMaybeMessage< ::io::substrait::Extensions_FunctionId >(GetArena()); + } + return sort_kind_.comparison_function_; +} +inline ::io::substrait::Extensions_FunctionId* Expression_SortField::mutable_comparison_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SortField.comparison_function) + return _internal_mutable_comparison_function(); +} + +inline bool Expression_SortField::has_sort_kind() const { + return sort_kind_case() != SORT_KIND_NOT_SET; +} +inline void Expression_SortField::clear_has_sort_kind() { + _oneof_case_[0] = SORT_KIND_NOT_SET; +} +inline Expression_SortField::SortKindCase Expression_SortField::sort_kind_case() const { + return Expression_SortField::SortKindCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Expression_IfThen_IfClause + +// .io.substrait.Expression if = 1; +inline bool Expression_IfThen_IfClause::_internal_has_if_() const { + return this != internal_default_instance() && if__ != nullptr; +} +inline bool Expression_IfThen_IfClause::has_if_() const { + return _internal_has_if_(); +} +inline void Expression_IfThen_IfClause::clear_if_() { + if (GetArena() == nullptr && if__ != nullptr) { + delete if__; + } + if__ = nullptr; +} +inline const ::io::substrait::Expression& Expression_IfThen_IfClause::_internal_if_() const { + const ::io::substrait::Expression* p = if__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_IfThen_IfClause::if_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.IfClause.if) + return _internal_if_(); +} +inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_if_( + ::io::substrait::Expression* if_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); + } + if__ = if_; + if (if_) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.IfClause.if) +} +inline ::io::substrait::Expression* Expression_IfThen_IfClause::release_if_() { + + ::io::substrait::Expression* temp = if__; + if__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_if_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.IfClause.if) + + ::io::substrait::Expression* temp = if__; + if__ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_if_() { + + if (if__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + if__ = p; + } + return if__; +} +inline ::io::substrait::Expression* Expression_IfThen_IfClause::mutable_if_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.IfClause.if) + return _internal_mutable_if_(); +} +inline void Expression_IfThen_IfClause::set_allocated_if_(::io::substrait::Expression* if_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete if__; + } + if (if_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_); + if (message_arena != submessage_arena) { + if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, if_, submessage_arena); + } + + } else { + + } + if__ = if_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.IfClause.if) +} + +// .io.substrait.Expression then = 2; +inline bool Expression_IfThen_IfClause::_internal_has_then() const { + return this != internal_default_instance() && then_ != nullptr; +} +inline bool Expression_IfThen_IfClause::has_then() const { + return _internal_has_then(); +} +inline void Expression_IfThen_IfClause::clear_then() { + if (GetArena() == nullptr && then_ != nullptr) { + delete then_; + } + then_ = nullptr; +} +inline const ::io::substrait::Expression& Expression_IfThen_IfClause::_internal_then() const { + const ::io::substrait::Expression* p = then_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_IfThen_IfClause::then() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.IfClause.then) + return _internal_then(); +} +inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_then( + ::io::substrait::Expression* then) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); + } + then_ = then; + if (then) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.IfClause.then) +} +inline ::io::substrait::Expression* Expression_IfThen_IfClause::release_then() { + + ::io::substrait::Expression* temp = then_; + then_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_then() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.IfClause.then) + + ::io::substrait::Expression* temp = then_; + then_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_then() { + + if (then_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + then_ = p; + } + return then_; +} +inline ::io::substrait::Expression* Expression_IfThen_IfClause::mutable_then() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.IfClause.then) + return _internal_mutable_then(); +} +inline void Expression_IfThen_IfClause::set_allocated_then(::io::substrait::Expression* then) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete then_; + } + if (then) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(then); + if (message_arena != submessage_arena) { + then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, then, submessage_arena); + } + + } else { + + } + then_ = then; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.IfClause.then) +} + +// ------------------------------------------------------------------- + +// Expression_IfThen + +// repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; +inline int Expression_IfThen::_internal_ifs_size() const { + return ifs_.size(); +} +inline int Expression_IfThen::ifs_size() const { + return _internal_ifs_size(); +} +inline void Expression_IfThen::clear_ifs() { + ifs_.Clear(); +} +inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::mutable_ifs(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.ifs) + return ifs_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >* +Expression_IfThen::mutable_ifs() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.IfThen.ifs) + return &ifs_; +} +inline const ::io::substrait::Expression_IfThen_IfClause& Expression_IfThen::_internal_ifs(int index) const { + return ifs_.Get(index); +} +inline const ::io::substrait::Expression_IfThen_IfClause& Expression_IfThen::ifs(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.ifs) + return _internal_ifs(index); +} +inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::_internal_add_ifs() { + return ifs_.Add(); +} +inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::add_ifs() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.IfThen.ifs) + return _internal_add_ifs(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >& +Expression_IfThen::ifs() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.IfThen.ifs) + return ifs_; +} + +// .io.substrait.Expression else = 2; +inline bool Expression_IfThen::_internal_has_else_() const { + return this != internal_default_instance() && else__ != nullptr; +} +inline bool Expression_IfThen::has_else_() const { + return _internal_has_else_(); +} +inline void Expression_IfThen::clear_else_() { + if (GetArena() == nullptr && else__ != nullptr) { + delete else__; + } + else__ = nullptr; +} +inline const ::io::substrait::Expression& Expression_IfThen::_internal_else_() const { + const ::io::substrait::Expression* p = else__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_IfThen::else_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.else) + return _internal_else_(); +} +inline void Expression_IfThen::unsafe_arena_set_allocated_else_( + ::io::substrait::Expression* else_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); + } + else__ = else_; + if (else_) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.else) +} +inline ::io::substrait::Expression* Expression_IfThen::release_else_() { + + ::io::substrait::Expression* temp = else__; + else__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* Expression_IfThen::unsafe_arena_release_else_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.else) + + ::io::substrait::Expression* temp = else__; + else__ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_IfThen::_internal_mutable_else_() { + + if (else__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + else__ = p; + } + return else__; +} +inline ::io::substrait::Expression* Expression_IfThen::mutable_else_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.else) + return _internal_mutable_else_(); +} +inline void Expression_IfThen::set_allocated_else_(::io::substrait::Expression* else_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete else__; + } + if (else_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(else_); + if (message_arena != submessage_arena) { + else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, else_, submessage_arena); + } + + } else { + + } + else__ = else_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.else) +} + +// ------------------------------------------------------------------- + +// Expression_SwitchExpression_IfValue + +// .io.substrait.Expression if = 1; +inline bool Expression_SwitchExpression_IfValue::_internal_has_if_() const { + return this != internal_default_instance() && if__ != nullptr; +} +inline bool Expression_SwitchExpression_IfValue::has_if_() const { + return _internal_has_if_(); +} +inline void Expression_SwitchExpression_IfValue::clear_if_() { + if (GetArena() == nullptr && if__ != nullptr) { + delete if__; + } + if__ = nullptr; +} +inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::_internal_if_() const { + const ::io::substrait::Expression* p = if__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::if_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.IfValue.if) + return _internal_if_(); +} +inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_if_( + ::io::substrait::Expression* if_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); + } + if__ = if_; + if (if_) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.if) +} +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::release_if_() { + + ::io::substrait::Expression* temp = if__; + if__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_arena_release_if_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.IfValue.if) + + ::io::substrait::Expression* temp = if__; + if__ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::_internal_mutable_if_() { + + if (if__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + if__ = p; + } + return if__; +} +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::mutable_if_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.IfValue.if) + return _internal_mutable_if_(); +} +inline void Expression_SwitchExpression_IfValue::set_allocated_if_(::io::substrait::Expression* if_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete if__; + } + if (if_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_); + if (message_arena != submessage_arena) { + if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, if_, submessage_arena); + } + + } else { + + } + if__ = if_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.if) +} + +// .io.substrait.Expression then = 2; +inline bool Expression_SwitchExpression_IfValue::_internal_has_then() const { + return this != internal_default_instance() && then_ != nullptr; +} +inline bool Expression_SwitchExpression_IfValue::has_then() const { + return _internal_has_then(); +} +inline void Expression_SwitchExpression_IfValue::clear_then() { + if (GetArena() == nullptr && then_ != nullptr) { + delete then_; + } + then_ = nullptr; +} +inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::_internal_then() const { + const ::io::substrait::Expression* p = then_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::then() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.IfValue.then) + return _internal_then(); +} +inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_then( + ::io::substrait::Expression* then) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); + } + then_ = then; + if (then) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.then) +} +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::release_then() { + + ::io::substrait::Expression* temp = then_; + then_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_arena_release_then() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.IfValue.then) + + ::io::substrait::Expression* temp = then_; + then_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::_internal_mutable_then() { + + if (then_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + then_ = p; + } + return then_; +} +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::mutable_then() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.IfValue.then) + return _internal_mutable_then(); +} +inline void Expression_SwitchExpression_IfValue::set_allocated_then(::io::substrait::Expression* then) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete then_; + } + if (then) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(then); + if (message_arena != submessage_arena) { + then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, then, submessage_arena); + } + + } else { + + } + then_ = then; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.then) +} + +// ------------------------------------------------------------------- + +// Expression_SwitchExpression + +// repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; +inline int Expression_SwitchExpression::_internal_ifs_size() const { + return ifs_.size(); +} +inline int Expression_SwitchExpression::ifs_size() const { + return _internal_ifs_size(); +} +inline void Expression_SwitchExpression::clear_ifs() { + ifs_.Clear(); +} +inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::mutable_ifs(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.ifs) + return ifs_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >* +Expression_SwitchExpression::mutable_ifs() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.SwitchExpression.ifs) + return &ifs_; +} +inline const ::io::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::_internal_ifs(int index) const { + return ifs_.Get(index); +} +inline const ::io::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::ifs(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.ifs) + return _internal_ifs(index); +} +inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::_internal_add_ifs() { + return ifs_.Add(); +} +inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::add_ifs() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.SwitchExpression.ifs) + return _internal_add_ifs(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >& +Expression_SwitchExpression::ifs() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.SwitchExpression.ifs) + return ifs_; +} + +// .io.substrait.Expression else = 2; +inline bool Expression_SwitchExpression::_internal_has_else_() const { + return this != internal_default_instance() && else__ != nullptr; +} +inline bool Expression_SwitchExpression::has_else_() const { + return _internal_has_else_(); +} +inline void Expression_SwitchExpression::clear_else_() { + if (GetArena() == nullptr && else__ != nullptr) { + delete else__; + } + else__ = nullptr; +} +inline const ::io::substrait::Expression& Expression_SwitchExpression::_internal_else_() const { + const ::io::substrait::Expression* p = else__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_SwitchExpression::else_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.else) + return _internal_else_(); +} +inline void Expression_SwitchExpression::unsafe_arena_set_allocated_else_( + ::io::substrait::Expression* else_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); + } + else__ = else_; + if (else_) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.else) +} +inline ::io::substrait::Expression* Expression_SwitchExpression::release_else_() { + + ::io::substrait::Expression* temp = else__; + else__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* Expression_SwitchExpression::unsafe_arena_release_else_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.else) + + ::io::substrait::Expression* temp = else__; + else__ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_SwitchExpression::_internal_mutable_else_() { + + if (else__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + else__ = p; + } + return else__; +} +inline ::io::substrait::Expression* Expression_SwitchExpression::mutable_else_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.else) + return _internal_mutable_else_(); +} +inline void Expression_SwitchExpression::set_allocated_else_(::io::substrait::Expression* else_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete else__; + } + if (else_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(else_); + if (message_arena != submessage_arena) { + else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, else_, submessage_arena); + } + + } else { + + } + else__ = else_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.else) +} + +// ------------------------------------------------------------------- + +// Expression_SingularOrList + +// .io.substrait.Expression value = 1; +inline bool Expression_SingularOrList::_internal_has_value() const { + return this != internal_default_instance() && value_ != nullptr; +} +inline bool Expression_SingularOrList::has_value() const { + return _internal_has_value(); +} +inline void Expression_SingularOrList::clear_value() { + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; +} +inline const ::io::substrait::Expression& Expression_SingularOrList::_internal_value() const { + const ::io::substrait::Expression* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_SingularOrList::value() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SingularOrList.value) + return _internal_value(); +} +inline void Expression_SingularOrList::unsafe_arena_set_allocated_value( + ::io::substrait::Expression* value) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); + } + value_ = value; + if (value) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SingularOrList.value) +} +inline ::io::substrait::Expression* Expression_SingularOrList::release_value() { + + ::io::substrait::Expression* temp = value_; + value_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* Expression_SingularOrList::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.SingularOrList.value) + + ::io::substrait::Expression* temp = value_; + value_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_SingularOrList::_internal_mutable_value() { + + if (value_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + value_ = p; + } + return value_; +} +inline ::io::substrait::Expression* Expression_SingularOrList::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SingularOrList.value) + return _internal_mutable_value(); +} +inline void Expression_SingularOrList::set_allocated_value(::io::substrait::Expression* value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete value_; + } + if (value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + if (message_arena != submessage_arena) { + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); + } + + } else { + + } + value_ = value; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SingularOrList.value) +} + +// repeated .io.substrait.Expression options = 2; +inline int Expression_SingularOrList::_internal_options_size() const { + return options_.size(); +} +inline int Expression_SingularOrList::options_size() const { + return _internal_options_size(); +} +inline void Expression_SingularOrList::clear_options() { + options_.Clear(); +} +inline ::io::substrait::Expression* Expression_SingularOrList::mutable_options(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SingularOrList.options) + return options_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_SingularOrList::mutable_options() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.SingularOrList.options) + return &options_; +} +inline const ::io::substrait::Expression& Expression_SingularOrList::_internal_options(int index) const { + return options_.Get(index); +} +inline const ::io::substrait::Expression& Expression_SingularOrList::options(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SingularOrList.options) + return _internal_options(index); +} +inline ::io::substrait::Expression* Expression_SingularOrList::_internal_add_options() { + return options_.Add(); +} +inline ::io::substrait::Expression* Expression_SingularOrList::add_options() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.SingularOrList.options) + return _internal_add_options(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_SingularOrList::options() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.SingularOrList.options) + return options_; +} + +// ------------------------------------------------------------------- + +// Expression_MultiOrList_Record + +// repeated .io.substrait.Expression fields = 1; +inline int Expression_MultiOrList_Record::_internal_fields_size() const { + return fields_.size(); +} +inline int Expression_MultiOrList_Record::fields_size() const { + return _internal_fields_size(); +} +inline void Expression_MultiOrList_Record::clear_fields() { + fields_.Clear(); +} +inline ::io::substrait::Expression* Expression_MultiOrList_Record::mutable_fields(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.Record.fields) + return fields_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_MultiOrList_Record::mutable_fields() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.Record.fields) + return &fields_; +} +inline const ::io::substrait::Expression& Expression_MultiOrList_Record::_internal_fields(int index) const { + return fields_.Get(index); +} +inline const ::io::substrait::Expression& Expression_MultiOrList_Record::fields(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.Record.fields) + return _internal_fields(index); +} +inline ::io::substrait::Expression* Expression_MultiOrList_Record::_internal_add_fields() { + return fields_.Add(); +} +inline ::io::substrait::Expression* Expression_MultiOrList_Record::add_fields() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.Record.fields) + return _internal_add_fields(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_MultiOrList_Record::fields() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.Record.fields) + return fields_; +} + +// ------------------------------------------------------------------- + +// Expression_MultiOrList + +// repeated .io.substrait.Expression value = 1; +inline int Expression_MultiOrList::_internal_value_size() const { + return value_.size(); +} +inline int Expression_MultiOrList::value_size() const { + return _internal_value_size(); +} +inline void Expression_MultiOrList::clear_value() { + value_.Clear(); +} +inline ::io::substrait::Expression* Expression_MultiOrList::mutable_value(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.value) + return value_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_MultiOrList::mutable_value() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.value) + return &value_; +} +inline const ::io::substrait::Expression& Expression_MultiOrList::_internal_value(int index) const { + return value_.Get(index); +} +inline const ::io::substrait::Expression& Expression_MultiOrList::value(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.value) + return _internal_value(index); +} +inline ::io::substrait::Expression* Expression_MultiOrList::_internal_add_value() { + return value_.Add(); +} +inline ::io::substrait::Expression* Expression_MultiOrList::add_value() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.value) + return _internal_add_value(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_MultiOrList::value() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.value) + return value_; +} + +// repeated .io.substrait.Expression.MultiOrList.Record options = 2; +inline int Expression_MultiOrList::_internal_options_size() const { + return options_.size(); +} +inline int Expression_MultiOrList::options_size() const { + return _internal_options_size(); +} +inline void Expression_MultiOrList::clear_options() { + options_.Clear(); +} +inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::mutable_options(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.options) + return options_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >* +Expression_MultiOrList::mutable_options() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.options) + return &options_; +} +inline const ::io::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::_internal_options(int index) const { + return options_.Get(index); +} +inline const ::io::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::options(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.options) + return _internal_options(index); +} +inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::_internal_add_options() { + return options_.Add(); +} +inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::add_options() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.options) + return _internal_add_options(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >& +Expression_MultiOrList::options() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.options) + return options_; +} + +// ------------------------------------------------------------------- + +// Expression_EmbeddedFunction_PythonPickleFunction + +// bytes function = 1; +inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_function() { + function_.ClearToEmpty(); +} +inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + return _internal_function(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_function(ArgT0&& arg0, ArgT... args) { + + function_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) +} +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + return _internal_mutable_function(); +} +inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_function() const { + return function_.Get(); +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::_internal_set_function(const std::string& value) { + + function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_mutable_function() { + + return function_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::release_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + return function_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_allocated_function(std::string* function) { + if (function != nullptr) { + + } else { + + } + function_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), function, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) +} + +// repeated string prerequisite = 2; +inline int Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite_size() const { + return prerequisite_.size(); +} +inline int Expression_EmbeddedFunction_PythonPickleFunction::prerequisite_size() const { + return _internal_prerequisite_size(); +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_prerequisite() { + prerequisite_.Clear(); +} +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return _internal_add_prerequisite(); +} +inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite(int index) const { + return prerequisite_.Get(index); +} +inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::prerequisite(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return _internal_prerequisite(index); +} +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return prerequisite_.Mutable(index); +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + prerequisite_.Mutable(index)->assign(value); +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + prerequisite_.Mutable(index)->assign(std::move(value)); +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + prerequisite_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value, size_t size) { + prerequisite_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +} +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_add_prerequisite() { + return prerequisite_.Add(); +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const std::string& value) { + prerequisite_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(std::string&& value) { + prerequisite_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value) { + GOOGLE_DCHECK(value != nullptr); + prerequisite_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value, size_t size) { + prerequisite_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Expression_EmbeddedFunction_PythonPickleFunction::prerequisite() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return prerequisite_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return &prerequisite_; +} + +// ------------------------------------------------------------------- + +// Expression_EmbeddedFunction_WebAssemblyFunction + +// bytes script = 1; +inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_script() { + script_.ClearToEmpty(); +} +inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::script() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + return _internal_script(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_script(ArgT0&& arg0, ArgT... args) { + + script_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) +} +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_script() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + return _internal_mutable_script(); +} +inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_script() const { + return script_.Get(); +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::_internal_set_script(const std::string& value) { + + script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_mutable_script() { + + return script_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::release_script() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + return script_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_allocated_script(std::string* script) { + if (script != nullptr) { + + } else { + + } + script_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), script, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) +} + +// repeated string prerequisite = 2; +inline int Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite_size() const { + return prerequisite_.size(); +} +inline int Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite_size() const { + return _internal_prerequisite_size(); +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_prerequisite() { + prerequisite_.Clear(); +} +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return _internal_add_prerequisite(); +} +inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite(int index) const { + return prerequisite_.Get(index); +} +inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return _internal_prerequisite(index); +} +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return prerequisite_.Mutable(index); +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + prerequisite_.Mutable(index)->assign(value); +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + prerequisite_.Mutable(index)->assign(std::move(value)); +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + prerequisite_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value, size_t size) { + prerequisite_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_add_prerequisite() { + return prerequisite_.Add(); +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const std::string& value) { + prerequisite_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(std::string&& value) { + prerequisite_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value) { + GOOGLE_DCHECK(value != nullptr); + prerequisite_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value, size_t size) { + prerequisite_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return prerequisite_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return &prerequisite_; +} + +// ------------------------------------------------------------------- + +// Expression_EmbeddedFunction + +// repeated .io.substrait.Expression arguments = 1; +inline int Expression_EmbeddedFunction::_internal_arguments_size() const { + return arguments_.size(); +} +inline int Expression_EmbeddedFunction::arguments_size() const { + return _internal_arguments_size(); +} +inline void Expression_EmbeddedFunction::clear_arguments() { + arguments_.Clear(); +} +inline ::io::substrait::Expression* Expression_EmbeddedFunction::mutable_arguments(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.arguments) + return arguments_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_EmbeddedFunction::mutable_arguments() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.arguments) + return &arguments_; +} +inline const ::io::substrait::Expression& Expression_EmbeddedFunction::_internal_arguments(int index) const { + return arguments_.Get(index); +} +inline const ::io::substrait::Expression& Expression_EmbeddedFunction::arguments(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.arguments) + return _internal_arguments(index); +} +inline ::io::substrait::Expression* Expression_EmbeddedFunction::_internal_add_arguments() { + return arguments_.Add(); +} +inline ::io::substrait::Expression* Expression_EmbeddedFunction::add_arguments() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.arguments) + return _internal_add_arguments(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_EmbeddedFunction::arguments() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.arguments) + return arguments_; +} + +// .io.substrait.Type output_type = 2; +inline bool Expression_EmbeddedFunction::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; +} +inline bool Expression_EmbeddedFunction::has_output_type() const { + return _internal_has_output_type(); +} +inline const ::io::substrait::Type& Expression_EmbeddedFunction::_internal_output_type() const { + const ::io::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Expression_EmbeddedFunction::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.output_type) + return _internal_output_type(); +} +inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + output_type_ = output_type; + if (output_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.output_type) +} +inline ::io::substrait::Type* Expression_EmbeddedFunction::release_output_type() { + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* Expression_EmbeddedFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.output_type) + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Expression_EmbeddedFunction::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + output_type_ = p; + } + return output_type_; +} +inline ::io::substrait::Type* Expression_EmbeddedFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.output_type) + return _internal_mutable_output_type(); +} +inline void Expression_EmbeddedFunction::set_allocated_output_type(::io::substrait::Type* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); + } + + } else { + + } + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.output_type) +} + +// .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; +inline bool Expression_EmbeddedFunction::_internal_has_python_pickle_function() const { + return kind_case() == kPythonPickleFunction; +} +inline bool Expression_EmbeddedFunction::has_python_pickle_function() const { + return _internal_has_python_pickle_function(); +} +inline void Expression_EmbeddedFunction::set_has_python_pickle_function() { + _oneof_case_[0] = kPythonPickleFunction; +} +inline void Expression_EmbeddedFunction::clear_python_pickle_function() { + if (_internal_has_python_pickle_function()) { + if (GetArena() == nullptr) { + delete kind_.python_pickle_function_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::release_python_pickle_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + if (_internal_has_python_pickle_function()) { + clear_has_kind(); + ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.python_pickle_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::_internal_python_pickle_function() const { + return _internal_has_python_pickle_function() + ? *kind_.python_pickle_function_ + : reinterpret_cast< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction&>(::io::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_); +} +inline const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::python_pickle_function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + return _internal_python_pickle_function(); +} +inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::unsafe_arena_release_python_pickle_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + if (_internal_has_python_pickle_function()) { + clear_has_kind(); + ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; + kind_.python_pickle_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_python_pickle_function(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { + clear_kind(); + if (python_pickle_function) { + set_has_python_pickle_function(); + kind_.python_pickle_function_ = python_pickle_function; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.python_pickle_function) +} +inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::_internal_mutable_python_pickle_function() { + if (!_internal_has_python_pickle_function()) { + clear_kind(); + set_has_python_pickle_function(); + kind_.python_pickle_function_ = CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(GetArena()); + } + return kind_.python_pickle_function_; +} +inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::mutable_python_pickle_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + return _internal_mutable_python_pickle_function(); +} + +// .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; +inline bool Expression_EmbeddedFunction::_internal_has_web_assembly_function() const { + return kind_case() == kWebAssemblyFunction; +} +inline bool Expression_EmbeddedFunction::has_web_assembly_function() const { + return _internal_has_web_assembly_function(); +} +inline void Expression_EmbeddedFunction::set_has_web_assembly_function() { + _oneof_case_[0] = kWebAssemblyFunction; +} +inline void Expression_EmbeddedFunction::clear_web_assembly_function() { + if (_internal_has_web_assembly_function()) { + if (GetArena() == nullptr) { + delete kind_.web_assembly_function_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::release_web_assembly_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + if (_internal_has_web_assembly_function()) { + clear_has_kind(); + ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.web_assembly_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::_internal_web_assembly_function() const { + return _internal_has_web_assembly_function() + ? *kind_.web_assembly_function_ + : reinterpret_cast< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction&>(::io::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_); +} +inline const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::web_assembly_function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + return _internal_web_assembly_function(); +} +inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::unsafe_arena_release_web_assembly_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + if (_internal_has_web_assembly_function()) { + clear_has_kind(); + ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; + kind_.web_assembly_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_web_assembly_function(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { + clear_kind(); + if (web_assembly_function) { + set_has_web_assembly_function(); + kind_.web_assembly_function_ = web_assembly_function; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.web_assembly_function) +} +inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::_internal_mutable_web_assembly_function() { + if (!_internal_has_web_assembly_function()) { + clear_kind(); + set_has_web_assembly_function(); + kind_.web_assembly_function_ = CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(GetArena()); + } + return kind_.web_assembly_function_; +} +inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::mutable_web_assembly_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + return _internal_mutable_web_assembly_function(); +} + +inline bool Expression_EmbeddedFunction::has_kind() const { + return kind_case() != KIND_NOT_SET; +} +inline void Expression_EmbeddedFunction::clear_has_kind() { + _oneof_case_[0] = KIND_NOT_SET; +} +inline Expression_EmbeddedFunction::KindCase Expression_EmbeddedFunction::kind_case() const { + return Expression_EmbeddedFunction::KindCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Expression + +// .io.substrait.Expression.Literal literal = 1; +inline bool Expression::_internal_has_literal() const { + return rex_type_case() == kLiteral; +} +inline bool Expression::has_literal() const { + return _internal_has_literal(); +} +inline void Expression::set_has_literal() { + _oneof_case_[0] = kLiteral; +} +inline void Expression::clear_literal() { + if (_internal_has_literal()) { + if (GetArena() == nullptr) { + delete rex_type_.literal_; + } + clear_has_rex_type(); + } +} +inline ::io::substrait::Expression_Literal* Expression::release_literal() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.literal) + if (_internal_has_literal()) { + clear_has_rex_type(); + ::io::substrait::Expression_Literal* temp = rex_type_.literal_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.literal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Literal& Expression::_internal_literal() const { + return _internal_has_literal() + ? *rex_type_.literal_ + : reinterpret_cast< ::io::substrait::Expression_Literal&>(::io::substrait::_Expression_Literal_default_instance_); +} +inline const ::io::substrait::Expression_Literal& Expression::literal() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.literal) + return _internal_literal(); +} +inline ::io::substrait::Expression_Literal* Expression::unsafe_arena_release_literal() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.literal) + if (_internal_has_literal()) { + clear_has_rex_type(); + ::io::substrait::Expression_Literal* temp = rex_type_.literal_; + rex_type_.literal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression::unsafe_arena_set_allocated_literal(::io::substrait::Expression_Literal* literal) { + clear_rex_type(); + if (literal) { + set_has_literal(); + rex_type_.literal_ = literal; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.literal) +} +inline ::io::substrait::Expression_Literal* Expression::_internal_mutable_literal() { + if (!_internal_has_literal()) { + clear_rex_type(); + set_has_literal(); + rex_type_.literal_ = CreateMaybeMessage< ::io::substrait::Expression_Literal >(GetArena()); + } + return rex_type_.literal_; +} +inline ::io::substrait::Expression_Literal* Expression::mutable_literal() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.literal) + return _internal_mutable_literal(); +} + +// .io.substrait.FieldReference selection = 2; +inline bool Expression::_internal_has_selection() const { + return rex_type_case() == kSelection; +} +inline bool Expression::has_selection() const { + return _internal_has_selection(); +} +inline void Expression::set_has_selection() { + _oneof_case_[0] = kSelection; +} +inline ::io::substrait::FieldReference* Expression::release_selection() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.selection) + if (_internal_has_selection()) { + clear_has_rex_type(); + ::io::substrait::FieldReference* temp = rex_type_.selection_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.selection_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FieldReference& Expression::_internal_selection() const { + return _internal_has_selection() + ? *rex_type_.selection_ + : reinterpret_cast< ::io::substrait::FieldReference&>(::io::substrait::_FieldReference_default_instance_); +} +inline const ::io::substrait::FieldReference& Expression::selection() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.selection) + return _internal_selection(); +} +inline ::io::substrait::FieldReference* Expression::unsafe_arena_release_selection() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.selection) + if (_internal_has_selection()) { + clear_has_rex_type(); + ::io::substrait::FieldReference* temp = rex_type_.selection_; + rex_type_.selection_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression::unsafe_arena_set_allocated_selection(::io::substrait::FieldReference* selection) { + clear_rex_type(); + if (selection) { + set_has_selection(); + rex_type_.selection_ = selection; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.selection) +} +inline ::io::substrait::FieldReference* Expression::_internal_mutable_selection() { + if (!_internal_has_selection()) { + clear_rex_type(); + set_has_selection(); + rex_type_.selection_ = CreateMaybeMessage< ::io::substrait::FieldReference >(GetArena()); + } + return rex_type_.selection_; +} +inline ::io::substrait::FieldReference* Expression::mutable_selection() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.selection) + return _internal_mutable_selection(); +} + +// .io.substrait.Expression.ScalarFunction scalar_function = 3; +inline bool Expression::_internal_has_scalar_function() const { + return rex_type_case() == kScalarFunction; +} +inline bool Expression::has_scalar_function() const { + return _internal_has_scalar_function(); +} +inline void Expression::set_has_scalar_function() { + _oneof_case_[0] = kScalarFunction; +} +inline void Expression::clear_scalar_function() { + if (_internal_has_scalar_function()) { + if (GetArena() == nullptr) { + delete rex_type_.scalar_function_; + } + clear_has_rex_type(); + } +} +inline ::io::substrait::Expression_ScalarFunction* Expression::release_scalar_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.scalar_function) + if (_internal_has_scalar_function()) { + clear_has_rex_type(); + ::io::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.scalar_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_ScalarFunction& Expression::_internal_scalar_function() const { + return _internal_has_scalar_function() + ? *rex_type_.scalar_function_ + : reinterpret_cast< ::io::substrait::Expression_ScalarFunction&>(::io::substrait::_Expression_ScalarFunction_default_instance_); +} +inline const ::io::substrait::Expression_ScalarFunction& Expression::scalar_function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.scalar_function) + return _internal_scalar_function(); +} +inline ::io::substrait::Expression_ScalarFunction* Expression::unsafe_arena_release_scalar_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.scalar_function) + if (_internal_has_scalar_function()) { + clear_has_rex_type(); + ::io::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; + rex_type_.scalar_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression::unsafe_arena_set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function) { + clear_rex_type(); + if (scalar_function) { + set_has_scalar_function(); + rex_type_.scalar_function_ = scalar_function; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.scalar_function) +} +inline ::io::substrait::Expression_ScalarFunction* Expression::_internal_mutable_scalar_function() { + if (!_internal_has_scalar_function()) { + clear_rex_type(); + set_has_scalar_function(); + rex_type_.scalar_function_ = CreateMaybeMessage< ::io::substrait::Expression_ScalarFunction >(GetArena()); + } + return rex_type_.scalar_function_; +} +inline ::io::substrait::Expression_ScalarFunction* Expression::mutable_scalar_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.scalar_function) + return _internal_mutable_scalar_function(); +} + +// .io.substrait.Expression.WindowFunction window_function = 5; +inline bool Expression::_internal_has_window_function() const { + return rex_type_case() == kWindowFunction; +} +inline bool Expression::has_window_function() const { + return _internal_has_window_function(); +} +inline void Expression::set_has_window_function() { + _oneof_case_[0] = kWindowFunction; +} +inline void Expression::clear_window_function() { + if (_internal_has_window_function()) { + if (GetArena() == nullptr) { + delete rex_type_.window_function_; + } + clear_has_rex_type(); + } +} +inline ::io::substrait::Expression_WindowFunction* Expression::release_window_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.window_function) + if (_internal_has_window_function()) { + clear_has_rex_type(); + ::io::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.window_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_WindowFunction& Expression::_internal_window_function() const { + return _internal_has_window_function() + ? *rex_type_.window_function_ + : reinterpret_cast< ::io::substrait::Expression_WindowFunction&>(::io::substrait::_Expression_WindowFunction_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction& Expression::window_function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.window_function) + return _internal_window_function(); +} +inline ::io::substrait::Expression_WindowFunction* Expression::unsafe_arena_release_window_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.window_function) + if (_internal_has_window_function()) { + clear_has_rex_type(); + ::io::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; + rex_type_.window_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression::unsafe_arena_set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function) { + clear_rex_type(); + if (window_function) { + set_has_window_function(); + rex_type_.window_function_ = window_function; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.window_function) +} +inline ::io::substrait::Expression_WindowFunction* Expression::_internal_mutable_window_function() { + if (!_internal_has_window_function()) { + clear_rex_type(); + set_has_window_function(); + rex_type_.window_function_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction >(GetArena()); + } + return rex_type_.window_function_; +} +inline ::io::substrait::Expression_WindowFunction* Expression::mutable_window_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.window_function) + return _internal_mutable_window_function(); +} + +// .io.substrait.Expression.IfThen if_then = 6; +inline bool Expression::_internal_has_if_then() const { + return rex_type_case() == kIfThen; +} +inline bool Expression::has_if_then() const { + return _internal_has_if_then(); +} +inline void Expression::set_has_if_then() { + _oneof_case_[0] = kIfThen; +} +inline void Expression::clear_if_then() { + if (_internal_has_if_then()) { + if (GetArena() == nullptr) { + delete rex_type_.if_then_; + } + clear_has_rex_type(); + } +} +inline ::io::substrait::Expression_IfThen* Expression::release_if_then() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.if_then) + if (_internal_has_if_then()) { + clear_has_rex_type(); + ::io::substrait::Expression_IfThen* temp = rex_type_.if_then_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.if_then_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_IfThen& Expression::_internal_if_then() const { + return _internal_has_if_then() + ? *rex_type_.if_then_ + : reinterpret_cast< ::io::substrait::Expression_IfThen&>(::io::substrait::_Expression_IfThen_default_instance_); +} +inline const ::io::substrait::Expression_IfThen& Expression::if_then() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.if_then) + return _internal_if_then(); +} +inline ::io::substrait::Expression_IfThen* Expression::unsafe_arena_release_if_then() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.if_then) + if (_internal_has_if_then()) { + clear_has_rex_type(); + ::io::substrait::Expression_IfThen* temp = rex_type_.if_then_; + rex_type_.if_then_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression::unsafe_arena_set_allocated_if_then(::io::substrait::Expression_IfThen* if_then) { + clear_rex_type(); + if (if_then) { + set_has_if_then(); + rex_type_.if_then_ = if_then; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.if_then) +} +inline ::io::substrait::Expression_IfThen* Expression::_internal_mutable_if_then() { + if (!_internal_has_if_then()) { + clear_rex_type(); + set_has_if_then(); + rex_type_.if_then_ = CreateMaybeMessage< ::io::substrait::Expression_IfThen >(GetArena()); + } + return rex_type_.if_then_; +} +inline ::io::substrait::Expression_IfThen* Expression::mutable_if_then() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.if_then) + return _internal_mutable_if_then(); +} + +// .io.substrait.Expression.SwitchExpression switch_expression = 7; +inline bool Expression::_internal_has_switch_expression() const { + return rex_type_case() == kSwitchExpression; +} +inline bool Expression::has_switch_expression() const { + return _internal_has_switch_expression(); +} +inline void Expression::set_has_switch_expression() { + _oneof_case_[0] = kSwitchExpression; +} +inline void Expression::clear_switch_expression() { + if (_internal_has_switch_expression()) { + if (GetArena() == nullptr) { + delete rex_type_.switch_expression_; + } + clear_has_rex_type(); + } +} +inline ::io::substrait::Expression_SwitchExpression* Expression::release_switch_expression() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.switch_expression) + if (_internal_has_switch_expression()) { + clear_has_rex_type(); + ::io::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.switch_expression_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_SwitchExpression& Expression::_internal_switch_expression() const { + return _internal_has_switch_expression() + ? *rex_type_.switch_expression_ + : reinterpret_cast< ::io::substrait::Expression_SwitchExpression&>(::io::substrait::_Expression_SwitchExpression_default_instance_); +} +inline const ::io::substrait::Expression_SwitchExpression& Expression::switch_expression() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.switch_expression) + return _internal_switch_expression(); +} +inline ::io::substrait::Expression_SwitchExpression* Expression::unsafe_arena_release_switch_expression() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.switch_expression) + if (_internal_has_switch_expression()) { + clear_has_rex_type(); + ::io::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; + rex_type_.switch_expression_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression::unsafe_arena_set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression) { + clear_rex_type(); + if (switch_expression) { + set_has_switch_expression(); + rex_type_.switch_expression_ = switch_expression; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.switch_expression) +} +inline ::io::substrait::Expression_SwitchExpression* Expression::_internal_mutable_switch_expression() { + if (!_internal_has_switch_expression()) { + clear_rex_type(); + set_has_switch_expression(); + rex_type_.switch_expression_ = CreateMaybeMessage< ::io::substrait::Expression_SwitchExpression >(GetArena()); + } + return rex_type_.switch_expression_; +} +inline ::io::substrait::Expression_SwitchExpression* Expression::mutable_switch_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.switch_expression) + return _internal_mutable_switch_expression(); +} + +// .io.substrait.Expression.SingularOrList singular_or_list = 8; +inline bool Expression::_internal_has_singular_or_list() const { + return rex_type_case() == kSingularOrList; +} +inline bool Expression::has_singular_or_list() const { + return _internal_has_singular_or_list(); +} +inline void Expression::set_has_singular_or_list() { + _oneof_case_[0] = kSingularOrList; +} +inline void Expression::clear_singular_or_list() { + if (_internal_has_singular_or_list()) { + if (GetArena() == nullptr) { + delete rex_type_.singular_or_list_; + } + clear_has_rex_type(); + } +} +inline ::io::substrait::Expression_SingularOrList* Expression::release_singular_or_list() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.singular_or_list) + if (_internal_has_singular_or_list()) { + clear_has_rex_type(); + ::io::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.singular_or_list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_SingularOrList& Expression::_internal_singular_or_list() const { + return _internal_has_singular_or_list() + ? *rex_type_.singular_or_list_ + : reinterpret_cast< ::io::substrait::Expression_SingularOrList&>(::io::substrait::_Expression_SingularOrList_default_instance_); +} +inline const ::io::substrait::Expression_SingularOrList& Expression::singular_or_list() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.singular_or_list) + return _internal_singular_or_list(); +} +inline ::io::substrait::Expression_SingularOrList* Expression::unsafe_arena_release_singular_or_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.singular_or_list) + if (_internal_has_singular_or_list()) { + clear_has_rex_type(); + ::io::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; + rex_type_.singular_or_list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression::unsafe_arena_set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list) { + clear_rex_type(); + if (singular_or_list) { + set_has_singular_or_list(); + rex_type_.singular_or_list_ = singular_or_list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.singular_or_list) +} +inline ::io::substrait::Expression_SingularOrList* Expression::_internal_mutable_singular_or_list() { + if (!_internal_has_singular_or_list()) { + clear_rex_type(); + set_has_singular_or_list(); + rex_type_.singular_or_list_ = CreateMaybeMessage< ::io::substrait::Expression_SingularOrList >(GetArena()); + } + return rex_type_.singular_or_list_; +} +inline ::io::substrait::Expression_SingularOrList* Expression::mutable_singular_or_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.singular_or_list) + return _internal_mutable_singular_or_list(); +} + +// .io.substrait.Expression.MultiOrList multi_or_list = 9; +inline bool Expression::_internal_has_multi_or_list() const { + return rex_type_case() == kMultiOrList; +} +inline bool Expression::has_multi_or_list() const { + return _internal_has_multi_or_list(); +} +inline void Expression::set_has_multi_or_list() { + _oneof_case_[0] = kMultiOrList; +} +inline void Expression::clear_multi_or_list() { + if (_internal_has_multi_or_list()) { + if (GetArena() == nullptr) { + delete rex_type_.multi_or_list_; + } + clear_has_rex_type(); + } +} +inline ::io::substrait::Expression_MultiOrList* Expression::release_multi_or_list() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.multi_or_list) + if (_internal_has_multi_or_list()) { + clear_has_rex_type(); + ::io::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.multi_or_list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_MultiOrList& Expression::_internal_multi_or_list() const { + return _internal_has_multi_or_list() + ? *rex_type_.multi_or_list_ + : reinterpret_cast< ::io::substrait::Expression_MultiOrList&>(::io::substrait::_Expression_MultiOrList_default_instance_); +} +inline const ::io::substrait::Expression_MultiOrList& Expression::multi_or_list() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.multi_or_list) + return _internal_multi_or_list(); +} +inline ::io::substrait::Expression_MultiOrList* Expression::unsafe_arena_release_multi_or_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.multi_or_list) + if (_internal_has_multi_or_list()) { + clear_has_rex_type(); + ::io::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; + rex_type_.multi_or_list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression::unsafe_arena_set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list) { + clear_rex_type(); + if (multi_or_list) { + set_has_multi_or_list(); + rex_type_.multi_or_list_ = multi_or_list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.multi_or_list) +} +inline ::io::substrait::Expression_MultiOrList* Expression::_internal_mutable_multi_or_list() { + if (!_internal_has_multi_or_list()) { + clear_rex_type(); + set_has_multi_or_list(); + rex_type_.multi_or_list_ = CreateMaybeMessage< ::io::substrait::Expression_MultiOrList >(GetArena()); + } + return rex_type_.multi_or_list_; +} +inline ::io::substrait::Expression_MultiOrList* Expression::mutable_multi_or_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.multi_or_list) + return _internal_mutable_multi_or_list(); +} + +// .io.substrait.Expression.Enum enum = 10; +inline bool Expression::_internal_has_enum_() const { + return rex_type_case() == kEnum; +} +inline bool Expression::has_enum_() const { + return _internal_has_enum_(); +} +inline void Expression::set_has_enum_() { + _oneof_case_[0] = kEnum; +} +inline void Expression::clear_enum_() { + if (_internal_has_enum_()) { + if (GetArena() == nullptr) { + delete rex_type_.enum__; + } + clear_has_rex_type(); + } +} +inline ::io::substrait::Expression_Enum* Expression::release_enum_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.enum) + if (_internal_has_enum_()) { + clear_has_rex_type(); + ::io::substrait::Expression_Enum* temp = rex_type_.enum__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.enum__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Enum& Expression::_internal_enum_() const { + return _internal_has_enum_() + ? *rex_type_.enum__ + : reinterpret_cast< ::io::substrait::Expression_Enum&>(::io::substrait::_Expression_Enum_default_instance_); +} +inline const ::io::substrait::Expression_Enum& Expression::enum_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.enum) + return _internal_enum_(); +} +inline ::io::substrait::Expression_Enum* Expression::unsafe_arena_release_enum_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.enum) + if (_internal_has_enum_()) { + clear_has_rex_type(); + ::io::substrait::Expression_Enum* temp = rex_type_.enum__; + rex_type_.enum__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression::unsafe_arena_set_allocated_enum_(::io::substrait::Expression_Enum* enum_) { + clear_rex_type(); + if (enum_) { + set_has_enum_(); + rex_type_.enum__ = enum_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.enum) +} +inline ::io::substrait::Expression_Enum* Expression::_internal_mutable_enum_() { + if (!_internal_has_enum_()) { + clear_rex_type(); + set_has_enum_(); + rex_type_.enum__ = CreateMaybeMessage< ::io::substrait::Expression_Enum >(GetArena()); + } + return rex_type_.enum__; +} +inline ::io::substrait::Expression_Enum* Expression::mutable_enum_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.enum) + return _internal_mutable_enum_(); +} + +inline bool Expression::has_rex_type() const { + return rex_type_case() != REX_TYPE_NOT_SET; +} +inline void Expression::clear_has_rex_type() { + _oneof_case_[0] = REX_TYPE_NOT_SET; +} +inline Expression::RexTypeCase Expression::rex_type_case() const { + return Expression::RexTypeCase(_oneof_case_[0]); +} +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace substrait +} // namespace io + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::io::substrait::Expression_SortField_SortDirection> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::Expression_SortField_SortDirection>() { + return ::io::substrait::Expression_SortField_SortDirection_descriptor(); +} +template <> struct is_proto_enum< ::io::substrait::Expression_AggregationPhase> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::Expression_AggregationPhase>() { + return ::io::substrait::Expression_AggregationPhase_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_expression_2eproto diff --git a/cpp/src/generated/substrait/extensions.pb.cc b/cpp/src/generated/substrait/extensions.pb.cc new file mode 100644 index 00000000000..4e3db173880 --- /dev/null +++ b/cpp/src/generated/substrait/extensions.pb.cc @@ -0,0 +1,2999 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: extensions.proto + +#include "extensions.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace io { +namespace substrait { +constexpr Extensions_Extension_TypeExtension::Extensions_Extension_TypeExtension( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : git_uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct Extensions_Extension_TypeExtensionDefaultTypeInternal { + constexpr Extensions_Extension_TypeExtensionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Extensions_Extension_TypeExtensionDefaultTypeInternal() {} + union { + Extensions_Extension_TypeExtension _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_Extension_TypeExtensionDefaultTypeInternal _Extensions_Extension_TypeExtension_default_instance_; +constexpr Extensions_Extension_FunctionExtension::Extensions_Extension_FunctionExtension( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : git_uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct Extensions_Extension_FunctionExtensionDefaultTypeInternal { + constexpr Extensions_Extension_FunctionExtensionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Extensions_Extension_FunctionExtensionDefaultTypeInternal() {} + union { + Extensions_Extension_FunctionExtension _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_Extension_FunctionExtensionDefaultTypeInternal _Extensions_Extension_FunctionExtension_default_instance_; +constexpr Extensions_Extension::Extensions_Extension( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : extension_id_(nullptr) + , _oneof_case_{}{} +struct Extensions_ExtensionDefaultTypeInternal { + constexpr Extensions_ExtensionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Extensions_ExtensionDefaultTypeInternal() {} + union { + Extensions_Extension _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_ExtensionDefaultTypeInternal _Extensions_Extension_default_instance_; +constexpr Extensions_Mapping_TypeMapping::Extensions_Mapping_TypeMapping( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , type_id_(nullptr) + , extension_id_(nullptr){} +struct Extensions_Mapping_TypeMappingDefaultTypeInternal { + constexpr Extensions_Mapping_TypeMappingDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Extensions_Mapping_TypeMappingDefaultTypeInternal() {} + union { + Extensions_Mapping_TypeMapping _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_Mapping_TypeMappingDefaultTypeInternal _Extensions_Mapping_TypeMapping_default_instance_; +constexpr Extensions_Mapping_FunctionMapping_Option::Extensions_Mapping_FunctionMapping_Option( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal { + constexpr Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal() {} + union { + Extensions_Mapping_FunctionMapping_Option _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal _Extensions_Mapping_FunctionMapping_Option_default_instance_; +constexpr Extensions_Mapping_FunctionMapping::Extensions_Mapping_FunctionMapping( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : options_() + , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , function_id_(nullptr) + , extension_id_(nullptr){} +struct Extensions_Mapping_FunctionMappingDefaultTypeInternal { + constexpr Extensions_Mapping_FunctionMappingDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Extensions_Mapping_FunctionMappingDefaultTypeInternal() {} + union { + Extensions_Mapping_FunctionMapping _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_Mapping_FunctionMappingDefaultTypeInternal _Extensions_Mapping_FunctionMapping_default_instance_; +constexpr Extensions_Mapping::Extensions_Mapping( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct Extensions_MappingDefaultTypeInternal { + constexpr Extensions_MappingDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Extensions_MappingDefaultTypeInternal() {} + union { + Extensions_Mapping _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_MappingDefaultTypeInternal _Extensions_Mapping_default_instance_; +constexpr Extensions_ExtensionId::Extensions_ExtensionId( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : id_(0u){} +struct Extensions_ExtensionIdDefaultTypeInternal { + constexpr Extensions_ExtensionIdDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Extensions_ExtensionIdDefaultTypeInternal() {} + union { + Extensions_ExtensionId _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_ExtensionIdDefaultTypeInternal _Extensions_ExtensionId_default_instance_; +constexpr Extensions_FunctionId::Extensions_FunctionId( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : id_(PROTOBUF_ULONGLONG(0)){} +struct Extensions_FunctionIdDefaultTypeInternal { + constexpr Extensions_FunctionIdDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Extensions_FunctionIdDefaultTypeInternal() {} + union { + Extensions_FunctionId _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_FunctionIdDefaultTypeInternal _Extensions_FunctionId_default_instance_; +constexpr Extensions_TypeId::Extensions_TypeId( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : id_(PROTOBUF_ULONGLONG(0)){} +struct Extensions_TypeIdDefaultTypeInternal { + constexpr Extensions_TypeIdDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Extensions_TypeIdDefaultTypeInternal() {} + union { + Extensions_TypeId _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_TypeIdDefaultTypeInternal _Extensions_TypeId_default_instance_; +constexpr Extensions::Extensions( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct ExtensionsDefaultTypeInternal { + constexpr ExtensionsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ExtensionsDefaultTypeInternal() {} + union { + Extensions _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionsDefaultTypeInternal _Extensions_default_instance_; +} // namespace substrait +} // namespace io +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_extensions_2eproto[11]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_extensions_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_extensions_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_extensions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension_TypeExtension, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension_TypeExtension, git_uri_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension_FunctionExtension, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension_FunctionExtension, git_uri_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension, extension_id_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension, extension_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_TypeMapping, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_TypeMapping, type_id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_TypeMapping, extension_id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_TypeMapping, name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping_Option, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping_Option, key_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping_Option, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping, function_id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping, extension_id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping, name_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping, options_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping, mapping_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_ExtensionId, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_ExtensionId, id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_FunctionId, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_FunctionId, id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_TypeId, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_TypeId, id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::io::substrait::Extensions_Extension_TypeExtension)}, + { 6, -1, sizeof(::io::substrait::Extensions_Extension_FunctionExtension)}, + { 12, -1, sizeof(::io::substrait::Extensions_Extension)}, + { 21, -1, sizeof(::io::substrait::Extensions_Mapping_TypeMapping)}, + { 29, -1, sizeof(::io::substrait::Extensions_Mapping_FunctionMapping_Option)}, + { 36, -1, sizeof(::io::substrait::Extensions_Mapping_FunctionMapping)}, + { 45, -1, sizeof(::io::substrait::Extensions_Mapping)}, + { 53, -1, sizeof(::io::substrait::Extensions_ExtensionId)}, + { 59, -1, sizeof(::io::substrait::Extensions_FunctionId)}, + { 65, -1, sizeof(::io::substrait::Extensions_TypeId)}, + { 71, -1, sizeof(::io::substrait::Extensions)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_Extensions_Extension_TypeExtension_default_instance_), + reinterpret_cast(&::io::substrait::_Extensions_Extension_FunctionExtension_default_instance_), + reinterpret_cast(&::io::substrait::_Extensions_Extension_default_instance_), + reinterpret_cast(&::io::substrait::_Extensions_Mapping_TypeMapping_default_instance_), + reinterpret_cast(&::io::substrait::_Extensions_Mapping_FunctionMapping_Option_default_instance_), + reinterpret_cast(&::io::substrait::_Extensions_Mapping_FunctionMapping_default_instance_), + reinterpret_cast(&::io::substrait::_Extensions_Mapping_default_instance_), + reinterpret_cast(&::io::substrait::_Extensions_ExtensionId_default_instance_), + reinterpret_cast(&::io::substrait::_Extensions_FunctionId_default_instance_), + reinterpret_cast(&::io::substrait::_Extensions_TypeId_default_instance_), + reinterpret_cast(&::io::substrait::_Extensions_default_instance_), +}; + +const char descriptor_table_protodef_extensions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\020extensions.proto\022\014io.substrait\"\337\007\n\nExt" + "ensions\032\301\002\n\tExtension\022:\n\014extension_id\030\001 " + "\001(\0132$.io.substrait.Extensions.ExtensionI" + "d\022J\n\016type_extension\030\002 \001(\01320.io.substrait" + ".Extensions.Extension.TypeExtensionH\000\022R\n" + "\022function_extension\030\003 \001(\01324.io.substrait" + ".Extensions.Extension.FunctionExtensionH" + "\000\032 \n\rTypeExtension\022\017\n\007git_uri\030\001 \001(\t\032$\n\021F" + "unctionExtension\022\017\n\007git_uri\030\001 \001(\tB\020\n\016ext" + "ension_type\032\301\004\n\007Mapping\022D\n\014type_mapping\030" + "\001 \001(\0132,.io.substrait.Extensions.Mapping." + "TypeMappingH\000\022L\n\020function_mapping\030\002 \001(\0132" + "0.io.substrait.Extensions.Mapping.Functi" + "onMappingH\000\032\211\001\n\013TypeMapping\0220\n\007type_id\030\001" + " \001(\0132\037.io.substrait.Extensions.TypeId\022:\n" + "\014extension_id\030\002 \001(\0132$.io.substrait.Exten" + "sions.ExtensionId\022\014\n\004name\030\003 \001(\t\032\205\002\n\017Func" + "tionMapping\0228\n\013function_id\030\001 \001(\0132#.io.su" + "bstrait.Extensions.FunctionId\022:\n\014extensi" + "on_id\030\002 \001(\0132$.io.substrait.Extensions.Ex" + "tensionId\022\014\n\004name\030\003 \001(\t\022H\n\007options\030\005 \003(\013" + "27.io.substrait.Extensions.Mapping.Funct" + "ionMapping.Option\032$\n\006Option\022\013\n\003key\030\001 \001(\t" + "\022\r\n\005value\030\002 \001(\tB\016\n\014mapping_type\032\031\n\013Exten" + "sionId\022\n\n\002id\030\001 \001(\r\032\030\n\nFunctionId\022\n\n\002id\030\001" + " \001(\004\032\024\n\006TypeId\022\n\n\002id\030\001 \001(\004B\027P\001\252\002\022Substra" + "it.Protobufb\006proto3" + ; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_extensions_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_extensions_2eproto = { + false, false, 1059, descriptor_table_protodef_extensions_2eproto, "extensions.proto", + &descriptor_table_extensions_2eproto_once, nullptr, 0, 11, + schemas, file_default_instances, TableStruct_extensions_2eproto::offsets, + file_level_metadata_extensions_2eproto, file_level_enum_descriptors_extensions_2eproto, file_level_service_descriptors_extensions_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_extensions_2eproto_getter() { + return &descriptor_table_extensions_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_extensions_2eproto(&descriptor_table_extensions_2eproto); +namespace io { +namespace substrait { + +// =================================================================== + +class Extensions_Extension_TypeExtension::_Internal { + public: +}; + +Extensions_Extension_TypeExtension::Extensions_Extension_TypeExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Extension.TypeExtension) +} +Extensions_Extension_TypeExtension::Extensions_Extension_TypeExtension(const Extensions_Extension_TypeExtension& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + git_uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_git_uri().empty()) { + git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_git_uri(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Extension.TypeExtension) +} + +void Extensions_Extension_TypeExtension::SharedCtor() { +git_uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Extensions_Extension_TypeExtension::~Extensions_Extension_TypeExtension() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions.Extension.TypeExtension) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions_Extension_TypeExtension::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + git_uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Extensions_Extension_TypeExtension::ArenaDtor(void* object) { + Extensions_Extension_TypeExtension* _this = reinterpret_cast< Extensions_Extension_TypeExtension* >(object); + (void)_this; +} +void Extensions_Extension_TypeExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions_Extension_TypeExtension::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions_Extension_TypeExtension::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Extension.TypeExtension) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + git_uri_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions_Extension_TypeExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string git_uri = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_git_uri(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Extension.TypeExtension.git_uri")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Extension_TypeExtension::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Extension.TypeExtension) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string git_uri = 1; + if (this->git_uri().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_git_uri().data(), static_cast(this->_internal_git_uri().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Extensions.Extension.TypeExtension.git_uri"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_git_uri(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Extension.TypeExtension) + return target; +} + +size_t Extensions_Extension_TypeExtension::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Extension.TypeExtension) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string git_uri = 1; + if (this->git_uri().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_git_uri()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions_Extension_TypeExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Extension.TypeExtension) + GOOGLE_DCHECK_NE(&from, this); + const Extensions_Extension_TypeExtension* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Extension.TypeExtension) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Extension.TypeExtension) + MergeFrom(*source); + } +} + +void Extensions_Extension_TypeExtension::MergeFrom(const Extensions_Extension_TypeExtension& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Extension.TypeExtension) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.git_uri().size() > 0) { + _internal_set_git_uri(from._internal_git_uri()); + } +} + +void Extensions_Extension_TypeExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Extension.TypeExtension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions_Extension_TypeExtension::CopyFrom(const Extensions_Extension_TypeExtension& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Extension.TypeExtension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions_Extension_TypeExtension::IsInitialized() const { + return true; +} + +void Extensions_Extension_TypeExtension::InternalSwap(Extensions_Extension_TypeExtension* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + git_uri_.Swap(&other->git_uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Extension_TypeExtension::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[0]); +} + +// =================================================================== + +class Extensions_Extension_FunctionExtension::_Internal { + public: +}; + +Extensions_Extension_FunctionExtension::Extensions_Extension_FunctionExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Extension.FunctionExtension) +} +Extensions_Extension_FunctionExtension::Extensions_Extension_FunctionExtension(const Extensions_Extension_FunctionExtension& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + git_uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_git_uri().empty()) { + git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_git_uri(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Extension.FunctionExtension) +} + +void Extensions_Extension_FunctionExtension::SharedCtor() { +git_uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Extensions_Extension_FunctionExtension::~Extensions_Extension_FunctionExtension() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions.Extension.FunctionExtension) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions_Extension_FunctionExtension::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + git_uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Extensions_Extension_FunctionExtension::ArenaDtor(void* object) { + Extensions_Extension_FunctionExtension* _this = reinterpret_cast< Extensions_Extension_FunctionExtension* >(object); + (void)_this; +} +void Extensions_Extension_FunctionExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions_Extension_FunctionExtension::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions_Extension_FunctionExtension::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Extension.FunctionExtension) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + git_uri_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions_Extension_FunctionExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string git_uri = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_git_uri(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Extension.FunctionExtension.git_uri")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Extension_FunctionExtension::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Extension.FunctionExtension) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string git_uri = 1; + if (this->git_uri().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_git_uri().data(), static_cast(this->_internal_git_uri().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Extensions.Extension.FunctionExtension.git_uri"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_git_uri(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Extension.FunctionExtension) + return target; +} + +size_t Extensions_Extension_FunctionExtension::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Extension.FunctionExtension) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string git_uri = 1; + if (this->git_uri().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_git_uri()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions_Extension_FunctionExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Extension.FunctionExtension) + GOOGLE_DCHECK_NE(&from, this); + const Extensions_Extension_FunctionExtension* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Extension.FunctionExtension) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Extension.FunctionExtension) + MergeFrom(*source); + } +} + +void Extensions_Extension_FunctionExtension::MergeFrom(const Extensions_Extension_FunctionExtension& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Extension.FunctionExtension) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.git_uri().size() > 0) { + _internal_set_git_uri(from._internal_git_uri()); + } +} + +void Extensions_Extension_FunctionExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Extension.FunctionExtension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions_Extension_FunctionExtension::CopyFrom(const Extensions_Extension_FunctionExtension& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Extension.FunctionExtension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions_Extension_FunctionExtension::IsInitialized() const { + return true; +} + +void Extensions_Extension_FunctionExtension::InternalSwap(Extensions_Extension_FunctionExtension* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + git_uri_.Swap(&other->git_uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Extension_FunctionExtension::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[1]); +} + +// =================================================================== + +class Extensions_Extension::_Internal { + public: + static const ::io::substrait::Extensions_ExtensionId& extension_id(const Extensions_Extension* msg); + static const ::io::substrait::Extensions_Extension_TypeExtension& type_extension(const Extensions_Extension* msg); + static const ::io::substrait::Extensions_Extension_FunctionExtension& function_extension(const Extensions_Extension* msg); +}; + +const ::io::substrait::Extensions_ExtensionId& +Extensions_Extension::_Internal::extension_id(const Extensions_Extension* msg) { + return *msg->extension_id_; +} +const ::io::substrait::Extensions_Extension_TypeExtension& +Extensions_Extension::_Internal::type_extension(const Extensions_Extension* msg) { + return *msg->extension_type_.type_extension_; +} +const ::io::substrait::Extensions_Extension_FunctionExtension& +Extensions_Extension::_Internal::function_extension(const Extensions_Extension* msg) { + return *msg->extension_type_.function_extension_; +} +void Extensions_Extension::set_allocated_type_extension(::io::substrait::Extensions_Extension_TypeExtension* type_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_extension_type(); + if (type_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_extension); + if (message_arena != submessage_arena) { + type_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type_extension, submessage_arena); + } + set_has_type_extension(); + extension_type_.type_extension_ = type_extension; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Extension.type_extension) +} +void Extensions_Extension::set_allocated_function_extension(::io::substrait::Extensions_Extension_FunctionExtension* function_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_extension_type(); + if (function_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(function_extension); + if (message_arena != submessage_arena) { + function_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, function_extension, submessage_arena); + } + set_has_function_extension(); + extension_type_.function_extension_ = function_extension; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Extension.function_extension) +} +Extensions_Extension::Extensions_Extension(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Extension) +} +Extensions_Extension::Extensions_Extension(const Extensions_Extension& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_extension_id()) { + extension_id_ = new ::io::substrait::Extensions_ExtensionId(*from.extension_id_); + } else { + extension_id_ = nullptr; + } + clear_has_extension_type(); + switch (from.extension_type_case()) { + case kTypeExtension: { + _internal_mutable_type_extension()->::io::substrait::Extensions_Extension_TypeExtension::MergeFrom(from._internal_type_extension()); + break; + } + case kFunctionExtension: { + _internal_mutable_function_extension()->::io::substrait::Extensions_Extension_FunctionExtension::MergeFrom(from._internal_function_extension()); + break; + } + case EXTENSION_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Extension) +} + +void Extensions_Extension::SharedCtor() { +extension_id_ = nullptr; +clear_has_extension_type(); +} + +Extensions_Extension::~Extensions_Extension() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions.Extension) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions_Extension::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete extension_id_; + if (has_extension_type()) { + clear_extension_type(); + } +} + +void Extensions_Extension::ArenaDtor(void* object) { + Extensions_Extension* _this = reinterpret_cast< Extensions_Extension* >(object); + (void)_this; +} +void Extensions_Extension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions_Extension::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions_Extension::clear_extension_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Extensions.Extension) + switch (extension_type_case()) { + case kTypeExtension: { + if (GetArena() == nullptr) { + delete extension_type_.type_extension_; + } + break; + } + case kFunctionExtension: { + if (GetArena() == nullptr) { + delete extension_type_.function_extension_; + } + break; + } + case EXTENSION_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = EXTENSION_TYPE_NOT_SET; +} + + +void Extensions_Extension::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Extension) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && extension_id_ != nullptr) { + delete extension_id_; + } + extension_id_ = nullptr; + clear_extension_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions_Extension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Extensions.ExtensionId extension_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Extensions.Extension.TypeExtension type_extension = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_type_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Extensions.Extension.FunctionExtension function_extension = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_function_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Extension::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Extension) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Extensions.ExtensionId extension_id = 1; + if (this->has_extension_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::extension_id(this), target, stream); + } + + // .io.substrait.Extensions.Extension.TypeExtension type_extension = 2; + if (_internal_has_type_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::type_extension(this), target, stream); + } + + // .io.substrait.Extensions.Extension.FunctionExtension function_extension = 3; + if (_internal_has_function_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::function_extension(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Extension) + return target; +} + +size_t Extensions_Extension::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Extension) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Extensions.ExtensionId extension_id = 1; + if (this->has_extension_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *extension_id_); + } + + switch (extension_type_case()) { + // .io.substrait.Extensions.Extension.TypeExtension type_extension = 2; + case kTypeExtension: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *extension_type_.type_extension_); + break; + } + // .io.substrait.Extensions.Extension.FunctionExtension function_extension = 3; + case kFunctionExtension: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *extension_type_.function_extension_); + break; + } + case EXTENSION_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions_Extension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Extension) + GOOGLE_DCHECK_NE(&from, this); + const Extensions_Extension* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Extension) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Extension) + MergeFrom(*source); + } +} + +void Extensions_Extension::MergeFrom(const Extensions_Extension& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Extension) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_extension_id()) { + _internal_mutable_extension_id()->::io::substrait::Extensions_ExtensionId::MergeFrom(from._internal_extension_id()); + } + switch (from.extension_type_case()) { + case kTypeExtension: { + _internal_mutable_type_extension()->::io::substrait::Extensions_Extension_TypeExtension::MergeFrom(from._internal_type_extension()); + break; + } + case kFunctionExtension: { + _internal_mutable_function_extension()->::io::substrait::Extensions_Extension_FunctionExtension::MergeFrom(from._internal_function_extension()); + break; + } + case EXTENSION_TYPE_NOT_SET: { + break; + } + } +} + +void Extensions_Extension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Extension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions_Extension::CopyFrom(const Extensions_Extension& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Extension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions_Extension::IsInitialized() const { + return true; +} + +void Extensions_Extension::InternalSwap(Extensions_Extension* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(extension_id_, other->extension_id_); + swap(extension_type_, other->extension_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Extension::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[2]); +} + +// =================================================================== + +class Extensions_Mapping_TypeMapping::_Internal { + public: + static const ::io::substrait::Extensions_TypeId& type_id(const Extensions_Mapping_TypeMapping* msg); + static const ::io::substrait::Extensions_ExtensionId& extension_id(const Extensions_Mapping_TypeMapping* msg); +}; + +const ::io::substrait::Extensions_TypeId& +Extensions_Mapping_TypeMapping::_Internal::type_id(const Extensions_Mapping_TypeMapping* msg) { + return *msg->type_id_; +} +const ::io::substrait::Extensions_ExtensionId& +Extensions_Mapping_TypeMapping::_Internal::extension_id(const Extensions_Mapping_TypeMapping* msg) { + return *msg->extension_id_; +} +Extensions_Mapping_TypeMapping::Extensions_Mapping_TypeMapping(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Mapping.TypeMapping) +} +Extensions_Mapping_TypeMapping::Extensions_Mapping_TypeMapping(const Extensions_Mapping_TypeMapping& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); + } + if (from._internal_has_type_id()) { + type_id_ = new ::io::substrait::Extensions_TypeId(*from.type_id_); + } else { + type_id_ = nullptr; + } + if (from._internal_has_extension_id()) { + extension_id_ = new ::io::substrait::Extensions_ExtensionId(*from.extension_id_); + } else { + extension_id_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Mapping.TypeMapping) +} + +void Extensions_Mapping_TypeMapping::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&extension_id_) - + reinterpret_cast(&type_id_)) + sizeof(extension_id_)); +} + +Extensions_Mapping_TypeMapping::~Extensions_Mapping_TypeMapping() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions.Mapping.TypeMapping) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions_Mapping_TypeMapping::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete type_id_; + if (this != internal_default_instance()) delete extension_id_; +} + +void Extensions_Mapping_TypeMapping::ArenaDtor(void* object) { + Extensions_Mapping_TypeMapping* _this = reinterpret_cast< Extensions_Mapping_TypeMapping* >(object); + (void)_this; +} +void Extensions_Mapping_TypeMapping::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions_Mapping_TypeMapping::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions_Mapping_TypeMapping::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Mapping.TypeMapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmpty(); + if (GetArena() == nullptr && type_id_ != nullptr) { + delete type_id_; + } + type_id_ = nullptr; + if (GetArena() == nullptr && extension_id_ != nullptr) { + delete extension_id_; + } + extension_id_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions_Mapping_TypeMapping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Extensions.TypeId type_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_type_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Extensions.ExtensionId extension_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Mapping.TypeMapping.name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Mapping_TypeMapping::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Mapping.TypeMapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Extensions.TypeId type_id = 1; + if (this->has_type_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::type_id(this), target, stream); + } + + // .io.substrait.Extensions.ExtensionId extension_id = 2; + if (this->has_extension_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::extension_id(this), target, stream); + } + + // string name = 3; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Extensions.Mapping.TypeMapping.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Mapping.TypeMapping) + return target; +} + +size_t Extensions_Mapping_TypeMapping::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Mapping.TypeMapping) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 3; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // .io.substrait.Extensions.TypeId type_id = 1; + if (this->has_type_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_id_); + } + + // .io.substrait.Extensions.ExtensionId extension_id = 2; + if (this->has_extension_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *extension_id_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions_Mapping_TypeMapping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Mapping.TypeMapping) + GOOGLE_DCHECK_NE(&from, this); + const Extensions_Mapping_TypeMapping* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Mapping.TypeMapping) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Mapping.TypeMapping) + MergeFrom(*source); + } +} + +void Extensions_Mapping_TypeMapping::MergeFrom(const Extensions_Mapping_TypeMapping& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Mapping.TypeMapping) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } + if (from.has_type_id()) { + _internal_mutable_type_id()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_type_id()); + } + if (from.has_extension_id()) { + _internal_mutable_extension_id()->::io::substrait::Extensions_ExtensionId::MergeFrom(from._internal_extension_id()); + } +} + +void Extensions_Mapping_TypeMapping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Mapping.TypeMapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions_Mapping_TypeMapping::CopyFrom(const Extensions_Mapping_TypeMapping& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Mapping.TypeMapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions_Mapping_TypeMapping::IsInitialized() const { + return true; +} + +void Extensions_Mapping_TypeMapping::InternalSwap(Extensions_Mapping_TypeMapping* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Extensions_Mapping_TypeMapping, extension_id_) + + sizeof(Extensions_Mapping_TypeMapping::extension_id_) + - PROTOBUF_FIELD_OFFSET(Extensions_Mapping_TypeMapping, type_id_)>( + reinterpret_cast(&type_id_), + reinterpret_cast(&other->type_id_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Mapping_TypeMapping::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[3]); +} + +// =================================================================== + +class Extensions_Mapping_FunctionMapping_Option::_Internal { + public: +}; + +Extensions_Mapping_FunctionMapping_Option::Extensions_Mapping_FunctionMapping_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Mapping.FunctionMapping.Option) +} +Extensions_Mapping_FunctionMapping_Option::Extensions_Mapping_FunctionMapping_Option(const Extensions_Mapping_FunctionMapping_Option& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_key().empty()) { + key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_key(), + GetArena()); + } + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_value().empty()) { + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Mapping.FunctionMapping.Option) +} + +void Extensions_Mapping_FunctionMapping_Option::SharedCtor() { +key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Extensions_Mapping_FunctionMapping_Option::~Extensions_Mapping_FunctionMapping_Option() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions.Mapping.FunctionMapping.Option) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions_Mapping_FunctionMapping_Option::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Extensions_Mapping_FunctionMapping_Option::ArenaDtor(void* object) { + Extensions_Mapping_FunctionMapping_Option* _this = reinterpret_cast< Extensions_Mapping_FunctionMapping_Option* >(object); + (void)_this; +} +void Extensions_Mapping_FunctionMapping_Option::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions_Mapping_FunctionMapping_Option::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions_Mapping_FunctionMapping_Option::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + key_.ClearToEmpty(); + value_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions_Mapping_FunctionMapping_Option::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_key(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Mapping.FunctionMapping.Option.key")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_value(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Mapping.FunctionMapping.Option.value")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Mapping_FunctionMapping_Option::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string key = 1; + if (this->key().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_key().data(), static_cast(this->_internal_key().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Extensions.Mapping.FunctionMapping.Option.key"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_key(), target); + } + + // string value = 2; + if (this->value().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_value().data(), static_cast(this->_internal_value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Extensions.Mapping.FunctionMapping.Option.value"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_value(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Mapping.FunctionMapping.Option) + return target; +} + +size_t Extensions_Mapping_FunctionMapping_Option::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string key = 1; + if (this->key().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_key()); + } + + // string value = 2; + if (this->value().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_value()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions_Mapping_FunctionMapping_Option::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) + GOOGLE_DCHECK_NE(&from, this); + const Extensions_Mapping_FunctionMapping_Option* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Mapping.FunctionMapping.Option) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Mapping.FunctionMapping.Option) + MergeFrom(*source); + } +} + +void Extensions_Mapping_FunctionMapping_Option::MergeFrom(const Extensions_Mapping_FunctionMapping_Option& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.key().size() > 0) { + _internal_set_key(from._internal_key()); + } + if (from.value().size() > 0) { + _internal_set_value(from._internal_value()); + } +} + +void Extensions_Mapping_FunctionMapping_Option::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions_Mapping_FunctionMapping_Option::CopyFrom(const Extensions_Mapping_FunctionMapping_Option& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions_Mapping_FunctionMapping_Option::IsInitialized() const { + return true; +} + +void Extensions_Mapping_FunctionMapping_Option::InternalSwap(Extensions_Mapping_FunctionMapping_Option* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Mapping_FunctionMapping_Option::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[4]); +} + +// =================================================================== + +class Extensions_Mapping_FunctionMapping::_Internal { + public: + static const ::io::substrait::Extensions_FunctionId& function_id(const Extensions_Mapping_FunctionMapping* msg); + static const ::io::substrait::Extensions_ExtensionId& extension_id(const Extensions_Mapping_FunctionMapping* msg); +}; + +const ::io::substrait::Extensions_FunctionId& +Extensions_Mapping_FunctionMapping::_Internal::function_id(const Extensions_Mapping_FunctionMapping* msg) { + return *msg->function_id_; +} +const ::io::substrait::Extensions_ExtensionId& +Extensions_Mapping_FunctionMapping::_Internal::extension_id(const Extensions_Mapping_FunctionMapping* msg) { + return *msg->extension_id_; +} +Extensions_Mapping_FunctionMapping::Extensions_Mapping_FunctionMapping(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + options_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Mapping.FunctionMapping) +} +Extensions_Mapping_FunctionMapping::Extensions_Mapping_FunctionMapping(const Extensions_Mapping_FunctionMapping& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + options_(from.options_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); + } + if (from._internal_has_function_id()) { + function_id_ = new ::io::substrait::Extensions_FunctionId(*from.function_id_); + } else { + function_id_ = nullptr; + } + if (from._internal_has_extension_id()) { + extension_id_ = new ::io::substrait::Extensions_ExtensionId(*from.extension_id_); + } else { + extension_id_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Mapping.FunctionMapping) +} + +void Extensions_Mapping_FunctionMapping::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&function_id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&extension_id_) - + reinterpret_cast(&function_id_)) + sizeof(extension_id_)); +} + +Extensions_Mapping_FunctionMapping::~Extensions_Mapping_FunctionMapping() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions.Mapping.FunctionMapping) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions_Mapping_FunctionMapping::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete function_id_; + if (this != internal_default_instance()) delete extension_id_; +} + +void Extensions_Mapping_FunctionMapping::ArenaDtor(void* object) { + Extensions_Mapping_FunctionMapping* _this = reinterpret_cast< Extensions_Mapping_FunctionMapping* >(object); + (void)_this; +} +void Extensions_Mapping_FunctionMapping::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions_Mapping_FunctionMapping::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions_Mapping_FunctionMapping::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Mapping.FunctionMapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + options_.Clear(); + name_.ClearToEmpty(); + if (GetArena() == nullptr && function_id_ != nullptr) { + delete function_id_; + } + function_id_ = nullptr; + if (GetArena() == nullptr && extension_id_ != nullptr) { + delete extension_id_; + } + extension_id_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions_Mapping_FunctionMapping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Extensions.FunctionId function_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_function_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Extensions.ExtensionId extension_id = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Mapping.FunctionMapping.name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Extensions.Mapping.FunctionMapping.Option options = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_options(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Mapping_FunctionMapping::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Mapping.FunctionMapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Extensions.FunctionId function_id = 1; + if (this->has_function_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::function_id(this), target, stream); + } + + // .io.substrait.Extensions.ExtensionId extension_id = 2; + if (this->has_extension_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::extension_id(this), target, stream); + } + + // string name = 3; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Extensions.Mapping.FunctionMapping.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); + } + + // repeated .io.substrait.Extensions.Mapping.FunctionMapping.Option options = 5; + for (unsigned int i = 0, + n = static_cast(this->_internal_options_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(5, this->_internal_options(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Mapping.FunctionMapping) + return target; +} + +size_t Extensions_Mapping_FunctionMapping::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Mapping.FunctionMapping) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Extensions.Mapping.FunctionMapping.Option options = 5; + total_size += 1UL * this->_internal_options_size(); + for (const auto& msg : this->options_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // string name = 3; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // .io.substrait.Extensions.FunctionId function_id = 1; + if (this->has_function_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *function_id_); + } + + // .io.substrait.Extensions.ExtensionId extension_id = 2; + if (this->has_extension_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *extension_id_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions_Mapping_FunctionMapping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Mapping.FunctionMapping) + GOOGLE_DCHECK_NE(&from, this); + const Extensions_Mapping_FunctionMapping* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Mapping.FunctionMapping) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Mapping.FunctionMapping) + MergeFrom(*source); + } +} + +void Extensions_Mapping_FunctionMapping::MergeFrom(const Extensions_Mapping_FunctionMapping& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Mapping.FunctionMapping) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + options_.MergeFrom(from.options_); + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } + if (from.has_function_id()) { + _internal_mutable_function_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_function_id()); + } + if (from.has_extension_id()) { + _internal_mutable_extension_id()->::io::substrait::Extensions_ExtensionId::MergeFrom(from._internal_extension_id()); + } +} + +void Extensions_Mapping_FunctionMapping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Mapping.FunctionMapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions_Mapping_FunctionMapping::CopyFrom(const Extensions_Mapping_FunctionMapping& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Mapping.FunctionMapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions_Mapping_FunctionMapping::IsInitialized() const { + return true; +} + +void Extensions_Mapping_FunctionMapping::InternalSwap(Extensions_Mapping_FunctionMapping* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + options_.InternalSwap(&other->options_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Extensions_Mapping_FunctionMapping, extension_id_) + + sizeof(Extensions_Mapping_FunctionMapping::extension_id_) + - PROTOBUF_FIELD_OFFSET(Extensions_Mapping_FunctionMapping, function_id_)>( + reinterpret_cast(&function_id_), + reinterpret_cast(&other->function_id_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Mapping_FunctionMapping::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[5]); +} + +// =================================================================== + +class Extensions_Mapping::_Internal { + public: + static const ::io::substrait::Extensions_Mapping_TypeMapping& type_mapping(const Extensions_Mapping* msg); + static const ::io::substrait::Extensions_Mapping_FunctionMapping& function_mapping(const Extensions_Mapping* msg); +}; + +const ::io::substrait::Extensions_Mapping_TypeMapping& +Extensions_Mapping::_Internal::type_mapping(const Extensions_Mapping* msg) { + return *msg->mapping_type_.type_mapping_; +} +const ::io::substrait::Extensions_Mapping_FunctionMapping& +Extensions_Mapping::_Internal::function_mapping(const Extensions_Mapping* msg) { + return *msg->mapping_type_.function_mapping_; +} +void Extensions_Mapping::set_allocated_type_mapping(::io::substrait::Extensions_Mapping_TypeMapping* type_mapping) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_mapping_type(); + if (type_mapping) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_mapping); + if (message_arena != submessage_arena) { + type_mapping = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type_mapping, submessage_arena); + } + set_has_type_mapping(); + mapping_type_.type_mapping_ = type_mapping; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.type_mapping) +} +void Extensions_Mapping::set_allocated_function_mapping(::io::substrait::Extensions_Mapping_FunctionMapping* function_mapping) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_mapping_type(); + if (function_mapping) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(function_mapping); + if (message_arena != submessage_arena) { + function_mapping = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, function_mapping, submessage_arena); + } + set_has_function_mapping(); + mapping_type_.function_mapping_ = function_mapping; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.function_mapping) +} +Extensions_Mapping::Extensions_Mapping(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Mapping) +} +Extensions_Mapping::Extensions_Mapping(const Extensions_Mapping& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_mapping_type(); + switch (from.mapping_type_case()) { + case kTypeMapping: { + _internal_mutable_type_mapping()->::io::substrait::Extensions_Mapping_TypeMapping::MergeFrom(from._internal_type_mapping()); + break; + } + case kFunctionMapping: { + _internal_mutable_function_mapping()->::io::substrait::Extensions_Mapping_FunctionMapping::MergeFrom(from._internal_function_mapping()); + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Mapping) +} + +void Extensions_Mapping::SharedCtor() { +clear_has_mapping_type(); +} + +Extensions_Mapping::~Extensions_Mapping() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions.Mapping) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions_Mapping::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_mapping_type()) { + clear_mapping_type(); + } +} + +void Extensions_Mapping::ArenaDtor(void* object) { + Extensions_Mapping* _this = reinterpret_cast< Extensions_Mapping* >(object); + (void)_this; +} +void Extensions_Mapping::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions_Mapping::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions_Mapping::clear_mapping_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Extensions.Mapping) + switch (mapping_type_case()) { + case kTypeMapping: { + if (GetArena() == nullptr) { + delete mapping_type_.type_mapping_; + } + break; + } + case kFunctionMapping: { + if (GetArena() == nullptr) { + delete mapping_type_.function_mapping_; + } + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = MAPPING_TYPE_NOT_SET; +} + + +void Extensions_Mapping::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_mapping_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions_Mapping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Extensions.Mapping.TypeMapping type_mapping = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_type_mapping(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Extensions.Mapping.FunctionMapping function_mapping = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_function_mapping(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Mapping::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Mapping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Extensions.Mapping.TypeMapping type_mapping = 1; + if (_internal_has_type_mapping()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::type_mapping(this), target, stream); + } + + // .io.substrait.Extensions.Mapping.FunctionMapping function_mapping = 2; + if (_internal_has_function_mapping()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::function_mapping(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Mapping) + return target; +} + +size_t Extensions_Mapping::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Mapping) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (mapping_type_case()) { + // .io.substrait.Extensions.Mapping.TypeMapping type_mapping = 1; + case kTypeMapping: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mapping_type_.type_mapping_); + break; + } + // .io.substrait.Extensions.Mapping.FunctionMapping function_mapping = 2; + case kFunctionMapping: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mapping_type_.function_mapping_); + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions_Mapping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Mapping) + GOOGLE_DCHECK_NE(&from, this); + const Extensions_Mapping* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Mapping) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Mapping) + MergeFrom(*source); + } +} + +void Extensions_Mapping::MergeFrom(const Extensions_Mapping& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Mapping) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.mapping_type_case()) { + case kTypeMapping: { + _internal_mutable_type_mapping()->::io::substrait::Extensions_Mapping_TypeMapping::MergeFrom(from._internal_type_mapping()); + break; + } + case kFunctionMapping: { + _internal_mutable_function_mapping()->::io::substrait::Extensions_Mapping_FunctionMapping::MergeFrom(from._internal_function_mapping()); + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } + } +} + +void Extensions_Mapping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Mapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions_Mapping::CopyFrom(const Extensions_Mapping& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Mapping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions_Mapping::IsInitialized() const { + return true; +} + +void Extensions_Mapping::InternalSwap(Extensions_Mapping* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(mapping_type_, other->mapping_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Mapping::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[6]); +} + +// =================================================================== + +class Extensions_ExtensionId::_Internal { + public: +}; + +Extensions_ExtensionId::Extensions_ExtensionId(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.ExtensionId) +} +Extensions_ExtensionId::Extensions_ExtensionId(const Extensions_ExtensionId& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + id_ = from.id_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.ExtensionId) +} + +void Extensions_ExtensionId::SharedCtor() { +id_ = 0u; +} + +Extensions_ExtensionId::~Extensions_ExtensionId() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions.ExtensionId) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions_ExtensionId::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Extensions_ExtensionId::ArenaDtor(void* object) { + Extensions_ExtensionId* _this = reinterpret_cast< Extensions_ExtensionId* >(object); + (void)_this; +} +void Extensions_ExtensionId::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions_ExtensionId::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions_ExtensionId::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.ExtensionId) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + id_ = 0u; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions_ExtensionId::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // uint32 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions_ExtensionId::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.ExtensionId) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint32 id = 1; + if (this->id() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.ExtensionId) + return target; +} + +size_t Extensions_ExtensionId::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.ExtensionId) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // uint32 id = 1; + if (this->id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_id()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions_ExtensionId::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.ExtensionId) + GOOGLE_DCHECK_NE(&from, this); + const Extensions_ExtensionId* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.ExtensionId) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.ExtensionId) + MergeFrom(*source); + } +} + +void Extensions_ExtensionId::MergeFrom(const Extensions_ExtensionId& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.ExtensionId) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.id() != 0) { + _internal_set_id(from._internal_id()); + } +} + +void Extensions_ExtensionId::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.ExtensionId) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions_ExtensionId::CopyFrom(const Extensions_ExtensionId& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.ExtensionId) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions_ExtensionId::IsInitialized() const { + return true; +} + +void Extensions_ExtensionId::InternalSwap(Extensions_ExtensionId* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(id_, other->id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions_ExtensionId::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[7]); +} + +// =================================================================== + +class Extensions_FunctionId::_Internal { + public: +}; + +Extensions_FunctionId::Extensions_FunctionId(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.FunctionId) +} +Extensions_FunctionId::Extensions_FunctionId(const Extensions_FunctionId& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + id_ = from.id_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.FunctionId) +} + +void Extensions_FunctionId::SharedCtor() { +id_ = PROTOBUF_ULONGLONG(0); +} + +Extensions_FunctionId::~Extensions_FunctionId() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions.FunctionId) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions_FunctionId::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Extensions_FunctionId::ArenaDtor(void* object) { + Extensions_FunctionId* _this = reinterpret_cast< Extensions_FunctionId* >(object); + (void)_this; +} +void Extensions_FunctionId::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions_FunctionId::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions_FunctionId::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.FunctionId) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + id_ = PROTOBUF_ULONGLONG(0); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions_FunctionId::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // uint64 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions_FunctionId::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.FunctionId) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.FunctionId) + return target; +} + +size_t Extensions_FunctionId::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.FunctionId) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_id()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions_FunctionId::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.FunctionId) + GOOGLE_DCHECK_NE(&from, this); + const Extensions_FunctionId* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.FunctionId) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.FunctionId) + MergeFrom(*source); + } +} + +void Extensions_FunctionId::MergeFrom(const Extensions_FunctionId& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.FunctionId) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.id() != 0) { + _internal_set_id(from._internal_id()); + } +} + +void Extensions_FunctionId::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.FunctionId) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions_FunctionId::CopyFrom(const Extensions_FunctionId& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.FunctionId) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions_FunctionId::IsInitialized() const { + return true; +} + +void Extensions_FunctionId::InternalSwap(Extensions_FunctionId* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(id_, other->id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions_FunctionId::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[8]); +} + +// =================================================================== + +class Extensions_TypeId::_Internal { + public: +}; + +Extensions_TypeId::Extensions_TypeId(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.TypeId) +} +Extensions_TypeId::Extensions_TypeId(const Extensions_TypeId& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + id_ = from.id_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.TypeId) +} + +void Extensions_TypeId::SharedCtor() { +id_ = PROTOBUF_ULONGLONG(0); +} + +Extensions_TypeId::~Extensions_TypeId() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions.TypeId) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions_TypeId::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Extensions_TypeId::ArenaDtor(void* object) { + Extensions_TypeId* _this = reinterpret_cast< Extensions_TypeId* >(object); + (void)_this; +} +void Extensions_TypeId::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions_TypeId::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions_TypeId::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.TypeId) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + id_ = PROTOBUF_ULONGLONG(0); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions_TypeId::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // uint64 id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions_TypeId::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.TypeId) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.TypeId) + return target; +} + +size_t Extensions_TypeId::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.TypeId) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // uint64 id = 1; + if (this->id() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_id()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions_TypeId::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.TypeId) + GOOGLE_DCHECK_NE(&from, this); + const Extensions_TypeId* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.TypeId) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.TypeId) + MergeFrom(*source); + } +} + +void Extensions_TypeId::MergeFrom(const Extensions_TypeId& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.TypeId) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.id() != 0) { + _internal_set_id(from._internal_id()); + } +} + +void Extensions_TypeId::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.TypeId) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions_TypeId::CopyFrom(const Extensions_TypeId& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.TypeId) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions_TypeId::IsInitialized() const { + return true; +} + +void Extensions_TypeId::InternalSwap(Extensions_TypeId* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(id_, other->id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions_TypeId::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[9]); +} + +// =================================================================== + +class Extensions::_Internal { + public: +}; + +Extensions::Extensions(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions) +} +Extensions::Extensions(const Extensions& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions) +} + +void Extensions::SharedCtor() { +} + +Extensions::~Extensions() { + // @@protoc_insertion_point(destructor:io.substrait.Extensions) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Extensions::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Extensions::ArenaDtor(void* object) { + Extensions* _this = reinterpret_cast< Extensions* >(object); + (void)_this; +} +void Extensions::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Extensions::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Extensions::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Extensions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Extensions::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions) + return target; +} + +size_t Extensions::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Extensions::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions) + GOOGLE_DCHECK_NE(&from, this); + const Extensions* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions) + MergeFrom(*source); + } +} + +void Extensions::MergeFrom(const Extensions& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +void Extensions::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Extensions::CopyFrom(const Extensions& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Extensions::IsInitialized() const { + return true; +} + +void Extensions::InternalSwap(Extensions* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Extensions::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, + file_level_metadata_extensions_2eproto[10]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Extension_TypeExtension* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Extension_TypeExtension >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions_Extension_TypeExtension >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Extension_FunctionExtension* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Extension_FunctionExtension >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions_Extension_FunctionExtension >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Extension* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Extension >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions_Extension >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Mapping_TypeMapping* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Mapping_TypeMapping >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions_Mapping_TypeMapping >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Mapping_FunctionMapping_Option* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Mapping_FunctionMapping* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Mapping_FunctionMapping >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions_Mapping_FunctionMapping >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Mapping* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Mapping >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions_Mapping >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_ExtensionId* Arena::CreateMaybeMessage< ::io::substrait::Extensions_ExtensionId >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions_ExtensionId >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_FunctionId* Arena::CreateMaybeMessage< ::io::substrait::Extensions_FunctionId >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions_FunctionId >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_TypeId* Arena::CreateMaybeMessage< ::io::substrait::Extensions_TypeId >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions_TypeId >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Extensions* Arena::CreateMaybeMessage< ::io::substrait::Extensions >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Extensions >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/extensions.pb.h b/cpp/src/generated/substrait/extensions.pb.h new file mode 100644 index 00000000000..6fa99bc7d29 --- /dev/null +++ b/cpp/src/generated/substrait/extensions.pb.h @@ -0,0 +1,2985 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: extensions.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_extensions_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_extensions_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_extensions_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_extensions_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[11] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_extensions_2eproto; +namespace io { +namespace substrait { +class Extensions; +struct ExtensionsDefaultTypeInternal; +extern ExtensionsDefaultTypeInternal _Extensions_default_instance_; +class Extensions_Extension; +struct Extensions_ExtensionDefaultTypeInternal; +extern Extensions_ExtensionDefaultTypeInternal _Extensions_Extension_default_instance_; +class Extensions_ExtensionId; +struct Extensions_ExtensionIdDefaultTypeInternal; +extern Extensions_ExtensionIdDefaultTypeInternal _Extensions_ExtensionId_default_instance_; +class Extensions_Extension_FunctionExtension; +struct Extensions_Extension_FunctionExtensionDefaultTypeInternal; +extern Extensions_Extension_FunctionExtensionDefaultTypeInternal _Extensions_Extension_FunctionExtension_default_instance_; +class Extensions_Extension_TypeExtension; +struct Extensions_Extension_TypeExtensionDefaultTypeInternal; +extern Extensions_Extension_TypeExtensionDefaultTypeInternal _Extensions_Extension_TypeExtension_default_instance_; +class Extensions_FunctionId; +struct Extensions_FunctionIdDefaultTypeInternal; +extern Extensions_FunctionIdDefaultTypeInternal _Extensions_FunctionId_default_instance_; +class Extensions_Mapping; +struct Extensions_MappingDefaultTypeInternal; +extern Extensions_MappingDefaultTypeInternal _Extensions_Mapping_default_instance_; +class Extensions_Mapping_FunctionMapping; +struct Extensions_Mapping_FunctionMappingDefaultTypeInternal; +extern Extensions_Mapping_FunctionMappingDefaultTypeInternal _Extensions_Mapping_FunctionMapping_default_instance_; +class Extensions_Mapping_FunctionMapping_Option; +struct Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal; +extern Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal _Extensions_Mapping_FunctionMapping_Option_default_instance_; +class Extensions_Mapping_TypeMapping; +struct Extensions_Mapping_TypeMappingDefaultTypeInternal; +extern Extensions_Mapping_TypeMappingDefaultTypeInternal _Extensions_Mapping_TypeMapping_default_instance_; +class Extensions_TypeId; +struct Extensions_TypeIdDefaultTypeInternal; +extern Extensions_TypeIdDefaultTypeInternal _Extensions_TypeId_default_instance_; +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::Extensions* Arena::CreateMaybeMessage<::io::substrait::Extensions>(Arena*); +template<> ::io::substrait::Extensions_Extension* Arena::CreateMaybeMessage<::io::substrait::Extensions_Extension>(Arena*); +template<> ::io::substrait::Extensions_ExtensionId* Arena::CreateMaybeMessage<::io::substrait::Extensions_ExtensionId>(Arena*); +template<> ::io::substrait::Extensions_Extension_FunctionExtension* Arena::CreateMaybeMessage<::io::substrait::Extensions_Extension_FunctionExtension>(Arena*); +template<> ::io::substrait::Extensions_Extension_TypeExtension* Arena::CreateMaybeMessage<::io::substrait::Extensions_Extension_TypeExtension>(Arena*); +template<> ::io::substrait::Extensions_FunctionId* Arena::CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(Arena*); +template<> ::io::substrait::Extensions_Mapping* Arena::CreateMaybeMessage<::io::substrait::Extensions_Mapping>(Arena*); +template<> ::io::substrait::Extensions_Mapping_FunctionMapping* Arena::CreateMaybeMessage<::io::substrait::Extensions_Mapping_FunctionMapping>(Arena*); +template<> ::io::substrait::Extensions_Mapping_FunctionMapping_Option* Arena::CreateMaybeMessage<::io::substrait::Extensions_Mapping_FunctionMapping_Option>(Arena*); +template<> ::io::substrait::Extensions_Mapping_TypeMapping* Arena::CreateMaybeMessage<::io::substrait::Extensions_Mapping_TypeMapping>(Arena*); +template<> ::io::substrait::Extensions_TypeId* Arena::CreateMaybeMessage<::io::substrait::Extensions_TypeId>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace io { +namespace substrait { + +// =================================================================== + +class Extensions_Extension_TypeExtension PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Extension.TypeExtension) */ { + public: + inline Extensions_Extension_TypeExtension() : Extensions_Extension_TypeExtension(nullptr) {} + ~Extensions_Extension_TypeExtension() override; + explicit constexpr Extensions_Extension_TypeExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions_Extension_TypeExtension(const Extensions_Extension_TypeExtension& from); + Extensions_Extension_TypeExtension(Extensions_Extension_TypeExtension&& from) noexcept + : Extensions_Extension_TypeExtension() { + *this = ::std::move(from); + } + + inline Extensions_Extension_TypeExtension& operator=(const Extensions_Extension_TypeExtension& from) { + CopyFrom(from); + return *this; + } + inline Extensions_Extension_TypeExtension& operator=(Extensions_Extension_TypeExtension&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions_Extension_TypeExtension& default_instance() { + return *internal_default_instance(); + } + static inline const Extensions_Extension_TypeExtension* internal_default_instance() { + return reinterpret_cast( + &_Extensions_Extension_TypeExtension_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Extensions_Extension_TypeExtension& a, Extensions_Extension_TypeExtension& b) { + a.Swap(&b); + } + inline void Swap(Extensions_Extension_TypeExtension* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions_Extension_TypeExtension* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions_Extension_TypeExtension* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions_Extension_TypeExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions_Extension_TypeExtension& from); + void MergeFrom(const Extensions_Extension_TypeExtension& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions_Extension_TypeExtension* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions.Extension.TypeExtension"; + } + protected: + explicit Extensions_Extension_TypeExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kGitUriFieldNumber = 1, + }; + // string git_uri = 1; + void clear_git_uri(); + const std::string& git_uri() const; + template + void set_git_uri(ArgT0&& arg0, ArgT... args); + std::string* mutable_git_uri(); + std::string* release_git_uri(); + void set_allocated_git_uri(std::string* git_uri); + private: + const std::string& _internal_git_uri() const; + void _internal_set_git_uri(const std::string& value); + std::string* _internal_mutable_git_uri(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Extension.TypeExtension) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr git_uri_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_extensions_2eproto; +}; +// ------------------------------------------------------------------- + +class Extensions_Extension_FunctionExtension PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Extension.FunctionExtension) */ { + public: + inline Extensions_Extension_FunctionExtension() : Extensions_Extension_FunctionExtension(nullptr) {} + ~Extensions_Extension_FunctionExtension() override; + explicit constexpr Extensions_Extension_FunctionExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions_Extension_FunctionExtension(const Extensions_Extension_FunctionExtension& from); + Extensions_Extension_FunctionExtension(Extensions_Extension_FunctionExtension&& from) noexcept + : Extensions_Extension_FunctionExtension() { + *this = ::std::move(from); + } + + inline Extensions_Extension_FunctionExtension& operator=(const Extensions_Extension_FunctionExtension& from) { + CopyFrom(from); + return *this; + } + inline Extensions_Extension_FunctionExtension& operator=(Extensions_Extension_FunctionExtension&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions_Extension_FunctionExtension& default_instance() { + return *internal_default_instance(); + } + static inline const Extensions_Extension_FunctionExtension* internal_default_instance() { + return reinterpret_cast( + &_Extensions_Extension_FunctionExtension_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(Extensions_Extension_FunctionExtension& a, Extensions_Extension_FunctionExtension& b) { + a.Swap(&b); + } + inline void Swap(Extensions_Extension_FunctionExtension* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions_Extension_FunctionExtension* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions_Extension_FunctionExtension* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions_Extension_FunctionExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions_Extension_FunctionExtension& from); + void MergeFrom(const Extensions_Extension_FunctionExtension& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions_Extension_FunctionExtension* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions.Extension.FunctionExtension"; + } + protected: + explicit Extensions_Extension_FunctionExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kGitUriFieldNumber = 1, + }; + // string git_uri = 1; + void clear_git_uri(); + const std::string& git_uri() const; + template + void set_git_uri(ArgT0&& arg0, ArgT... args); + std::string* mutable_git_uri(); + std::string* release_git_uri(); + void set_allocated_git_uri(std::string* git_uri); + private: + const std::string& _internal_git_uri() const; + void _internal_set_git_uri(const std::string& value); + std::string* _internal_mutable_git_uri(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Extension.FunctionExtension) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr git_uri_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_extensions_2eproto; +}; +// ------------------------------------------------------------------- + +class Extensions_Extension PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Extension) */ { + public: + inline Extensions_Extension() : Extensions_Extension(nullptr) {} + ~Extensions_Extension() override; + explicit constexpr Extensions_Extension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions_Extension(const Extensions_Extension& from); + Extensions_Extension(Extensions_Extension&& from) noexcept + : Extensions_Extension() { + *this = ::std::move(from); + } + + inline Extensions_Extension& operator=(const Extensions_Extension& from) { + CopyFrom(from); + return *this; + } + inline Extensions_Extension& operator=(Extensions_Extension&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions_Extension& default_instance() { + return *internal_default_instance(); + } + enum ExtensionTypeCase { + kTypeExtension = 2, + kFunctionExtension = 3, + EXTENSION_TYPE_NOT_SET = 0, + }; + + static inline const Extensions_Extension* internal_default_instance() { + return reinterpret_cast( + &_Extensions_Extension_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(Extensions_Extension& a, Extensions_Extension& b) { + a.Swap(&b); + } + inline void Swap(Extensions_Extension* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions_Extension* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions_Extension* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions_Extension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions_Extension& from); + void MergeFrom(const Extensions_Extension& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions_Extension* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions.Extension"; + } + protected: + explicit Extensions_Extension(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Extensions_Extension_TypeExtension TypeExtension; + typedef Extensions_Extension_FunctionExtension FunctionExtension; + + // accessors ------------------------------------------------------- + + enum : int { + kExtensionIdFieldNumber = 1, + kTypeExtensionFieldNumber = 2, + kFunctionExtensionFieldNumber = 3, + }; + // .io.substrait.Extensions.ExtensionId extension_id = 1; + bool has_extension_id() const; + private: + bool _internal_has_extension_id() const; + public: + void clear_extension_id(); + const ::io::substrait::Extensions_ExtensionId& extension_id() const; + ::io::substrait::Extensions_ExtensionId* release_extension_id(); + ::io::substrait::Extensions_ExtensionId* mutable_extension_id(); + void set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id); + private: + const ::io::substrait::Extensions_ExtensionId& _internal_extension_id() const; + ::io::substrait::Extensions_ExtensionId* _internal_mutable_extension_id(); + public: + void unsafe_arena_set_allocated_extension_id( + ::io::substrait::Extensions_ExtensionId* extension_id); + ::io::substrait::Extensions_ExtensionId* unsafe_arena_release_extension_id(); + + // .io.substrait.Extensions.Extension.TypeExtension type_extension = 2; + bool has_type_extension() const; + private: + bool _internal_has_type_extension() const; + public: + void clear_type_extension(); + const ::io::substrait::Extensions_Extension_TypeExtension& type_extension() const; + ::io::substrait::Extensions_Extension_TypeExtension* release_type_extension(); + ::io::substrait::Extensions_Extension_TypeExtension* mutable_type_extension(); + void set_allocated_type_extension(::io::substrait::Extensions_Extension_TypeExtension* type_extension); + private: + const ::io::substrait::Extensions_Extension_TypeExtension& _internal_type_extension() const; + ::io::substrait::Extensions_Extension_TypeExtension* _internal_mutable_type_extension(); + public: + void unsafe_arena_set_allocated_type_extension( + ::io::substrait::Extensions_Extension_TypeExtension* type_extension); + ::io::substrait::Extensions_Extension_TypeExtension* unsafe_arena_release_type_extension(); + + // .io.substrait.Extensions.Extension.FunctionExtension function_extension = 3; + bool has_function_extension() const; + private: + bool _internal_has_function_extension() const; + public: + void clear_function_extension(); + const ::io::substrait::Extensions_Extension_FunctionExtension& function_extension() const; + ::io::substrait::Extensions_Extension_FunctionExtension* release_function_extension(); + ::io::substrait::Extensions_Extension_FunctionExtension* mutable_function_extension(); + void set_allocated_function_extension(::io::substrait::Extensions_Extension_FunctionExtension* function_extension); + private: + const ::io::substrait::Extensions_Extension_FunctionExtension& _internal_function_extension() const; + ::io::substrait::Extensions_Extension_FunctionExtension* _internal_mutable_function_extension(); + public: + void unsafe_arena_set_allocated_function_extension( + ::io::substrait::Extensions_Extension_FunctionExtension* function_extension); + ::io::substrait::Extensions_Extension_FunctionExtension* unsafe_arena_release_function_extension(); + + void clear_extension_type(); + ExtensionTypeCase extension_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Extension) + private: + class _Internal; + void set_has_type_extension(); + void set_has_function_extension(); + + inline bool has_extension_type() const; + inline void clear_has_extension_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Extensions_ExtensionId* extension_id_; + union ExtensionTypeUnion { + constexpr ExtensionTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Extensions_Extension_TypeExtension* type_extension_; + ::io::substrait::Extensions_Extension_FunctionExtension* function_extension_; + } extension_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_extensions_2eproto; +}; +// ------------------------------------------------------------------- + +class Extensions_Mapping_TypeMapping PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Mapping.TypeMapping) */ { + public: + inline Extensions_Mapping_TypeMapping() : Extensions_Mapping_TypeMapping(nullptr) {} + ~Extensions_Mapping_TypeMapping() override; + explicit constexpr Extensions_Mapping_TypeMapping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions_Mapping_TypeMapping(const Extensions_Mapping_TypeMapping& from); + Extensions_Mapping_TypeMapping(Extensions_Mapping_TypeMapping&& from) noexcept + : Extensions_Mapping_TypeMapping() { + *this = ::std::move(from); + } + + inline Extensions_Mapping_TypeMapping& operator=(const Extensions_Mapping_TypeMapping& from) { + CopyFrom(from); + return *this; + } + inline Extensions_Mapping_TypeMapping& operator=(Extensions_Mapping_TypeMapping&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions_Mapping_TypeMapping& default_instance() { + return *internal_default_instance(); + } + static inline const Extensions_Mapping_TypeMapping* internal_default_instance() { + return reinterpret_cast( + &_Extensions_Mapping_TypeMapping_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(Extensions_Mapping_TypeMapping& a, Extensions_Mapping_TypeMapping& b) { + a.Swap(&b); + } + inline void Swap(Extensions_Mapping_TypeMapping* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions_Mapping_TypeMapping* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions_Mapping_TypeMapping* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions_Mapping_TypeMapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions_Mapping_TypeMapping& from); + void MergeFrom(const Extensions_Mapping_TypeMapping& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions_Mapping_TypeMapping* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions.Mapping.TypeMapping"; + } + protected: + explicit Extensions_Mapping_TypeMapping(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 3, + kTypeIdFieldNumber = 1, + kExtensionIdFieldNumber = 2, + }; + // string name = 3; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // .io.substrait.Extensions.TypeId type_id = 1; + bool has_type_id() const; + private: + bool _internal_has_type_id() const; + public: + void clear_type_id(); + const ::io::substrait::Extensions_TypeId& type_id() const; + ::io::substrait::Extensions_TypeId* release_type_id(); + ::io::substrait::Extensions_TypeId* mutable_type_id(); + void set_allocated_type_id(::io::substrait::Extensions_TypeId* type_id); + private: + const ::io::substrait::Extensions_TypeId& _internal_type_id() const; + ::io::substrait::Extensions_TypeId* _internal_mutable_type_id(); + public: + void unsafe_arena_set_allocated_type_id( + ::io::substrait::Extensions_TypeId* type_id); + ::io::substrait::Extensions_TypeId* unsafe_arena_release_type_id(); + + // .io.substrait.Extensions.ExtensionId extension_id = 2; + bool has_extension_id() const; + private: + bool _internal_has_extension_id() const; + public: + void clear_extension_id(); + const ::io::substrait::Extensions_ExtensionId& extension_id() const; + ::io::substrait::Extensions_ExtensionId* release_extension_id(); + ::io::substrait::Extensions_ExtensionId* mutable_extension_id(); + void set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id); + private: + const ::io::substrait::Extensions_ExtensionId& _internal_extension_id() const; + ::io::substrait::Extensions_ExtensionId* _internal_mutable_extension_id(); + public: + void unsafe_arena_set_allocated_extension_id( + ::io::substrait::Extensions_ExtensionId* extension_id); + ::io::substrait::Extensions_ExtensionId* unsafe_arena_release_extension_id(); + + // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Mapping.TypeMapping) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::io::substrait::Extensions_TypeId* type_id_; + ::io::substrait::Extensions_ExtensionId* extension_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_extensions_2eproto; +}; +// ------------------------------------------------------------------- + +class Extensions_Mapping_FunctionMapping_Option PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Mapping.FunctionMapping.Option) */ { + public: + inline Extensions_Mapping_FunctionMapping_Option() : Extensions_Mapping_FunctionMapping_Option(nullptr) {} + ~Extensions_Mapping_FunctionMapping_Option() override; + explicit constexpr Extensions_Mapping_FunctionMapping_Option(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions_Mapping_FunctionMapping_Option(const Extensions_Mapping_FunctionMapping_Option& from); + Extensions_Mapping_FunctionMapping_Option(Extensions_Mapping_FunctionMapping_Option&& from) noexcept + : Extensions_Mapping_FunctionMapping_Option() { + *this = ::std::move(from); + } + + inline Extensions_Mapping_FunctionMapping_Option& operator=(const Extensions_Mapping_FunctionMapping_Option& from) { + CopyFrom(from); + return *this; + } + inline Extensions_Mapping_FunctionMapping_Option& operator=(Extensions_Mapping_FunctionMapping_Option&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions_Mapping_FunctionMapping_Option& default_instance() { + return *internal_default_instance(); + } + static inline const Extensions_Mapping_FunctionMapping_Option* internal_default_instance() { + return reinterpret_cast( + &_Extensions_Mapping_FunctionMapping_Option_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(Extensions_Mapping_FunctionMapping_Option& a, Extensions_Mapping_FunctionMapping_Option& b) { + a.Swap(&b); + } + inline void Swap(Extensions_Mapping_FunctionMapping_Option* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions_Mapping_FunctionMapping_Option* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions_Mapping_FunctionMapping_Option* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions_Mapping_FunctionMapping_Option* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions_Mapping_FunctionMapping_Option& from); + void MergeFrom(const Extensions_Mapping_FunctionMapping_Option& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions_Mapping_FunctionMapping_Option* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions.Mapping.FunctionMapping.Option"; + } + protected: + explicit Extensions_Mapping_FunctionMapping_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + // string key = 1; + void clear_key(); + const std::string& key() const; + template + void set_key(ArgT0&& arg0, ArgT... args); + std::string* mutable_key(); + std::string* release_key(); + void set_allocated_key(std::string* key); + private: + const std::string& _internal_key() const; + void _internal_set_key(const std::string& value); + std::string* _internal_mutable_key(); + public: + + // string value = 2; + void clear_value(); + const std::string& value() const; + template + void set_value(ArgT0&& arg0, ArgT... args); + std::string* mutable_value(); + std::string* release_value(); + void set_allocated_value(std::string* value); + private: + const std::string& _internal_value() const; + void _internal_set_value(const std::string& value); + std::string* _internal_mutable_value(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Mapping.FunctionMapping.Option) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_extensions_2eproto; +}; +// ------------------------------------------------------------------- + +class Extensions_Mapping_FunctionMapping PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Mapping.FunctionMapping) */ { + public: + inline Extensions_Mapping_FunctionMapping() : Extensions_Mapping_FunctionMapping(nullptr) {} + ~Extensions_Mapping_FunctionMapping() override; + explicit constexpr Extensions_Mapping_FunctionMapping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions_Mapping_FunctionMapping(const Extensions_Mapping_FunctionMapping& from); + Extensions_Mapping_FunctionMapping(Extensions_Mapping_FunctionMapping&& from) noexcept + : Extensions_Mapping_FunctionMapping() { + *this = ::std::move(from); + } + + inline Extensions_Mapping_FunctionMapping& operator=(const Extensions_Mapping_FunctionMapping& from) { + CopyFrom(from); + return *this; + } + inline Extensions_Mapping_FunctionMapping& operator=(Extensions_Mapping_FunctionMapping&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions_Mapping_FunctionMapping& default_instance() { + return *internal_default_instance(); + } + static inline const Extensions_Mapping_FunctionMapping* internal_default_instance() { + return reinterpret_cast( + &_Extensions_Mapping_FunctionMapping_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(Extensions_Mapping_FunctionMapping& a, Extensions_Mapping_FunctionMapping& b) { + a.Swap(&b); + } + inline void Swap(Extensions_Mapping_FunctionMapping* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions_Mapping_FunctionMapping* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions_Mapping_FunctionMapping* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions_Mapping_FunctionMapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions_Mapping_FunctionMapping& from); + void MergeFrom(const Extensions_Mapping_FunctionMapping& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions_Mapping_FunctionMapping* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions.Mapping.FunctionMapping"; + } + protected: + explicit Extensions_Mapping_FunctionMapping(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Extensions_Mapping_FunctionMapping_Option Option; + + // accessors ------------------------------------------------------- + + enum : int { + kOptionsFieldNumber = 5, + kNameFieldNumber = 3, + kFunctionIdFieldNumber = 1, + kExtensionIdFieldNumber = 2, + }; + // repeated .io.substrait.Extensions.Mapping.FunctionMapping.Option options = 5; + int options_size() const; + private: + int _internal_options_size() const; + public: + void clear_options(); + ::io::substrait::Extensions_Mapping_FunctionMapping_Option* mutable_options(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >* + mutable_options(); + private: + const ::io::substrait::Extensions_Mapping_FunctionMapping_Option& _internal_options(int index) const; + ::io::substrait::Extensions_Mapping_FunctionMapping_Option* _internal_add_options(); + public: + const ::io::substrait::Extensions_Mapping_FunctionMapping_Option& options(int index) const; + ::io::substrait::Extensions_Mapping_FunctionMapping_Option* add_options(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >& + options() const; + + // string name = 3; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // .io.substrait.Extensions.FunctionId function_id = 1; + bool has_function_id() const; + private: + bool _internal_has_function_id() const; + public: + void clear_function_id(); + const ::io::substrait::Extensions_FunctionId& function_id() const; + ::io::substrait::Extensions_FunctionId* release_function_id(); + ::io::substrait::Extensions_FunctionId* mutable_function_id(); + void set_allocated_function_id(::io::substrait::Extensions_FunctionId* function_id); + private: + const ::io::substrait::Extensions_FunctionId& _internal_function_id() const; + ::io::substrait::Extensions_FunctionId* _internal_mutable_function_id(); + public: + void unsafe_arena_set_allocated_function_id( + ::io::substrait::Extensions_FunctionId* function_id); + ::io::substrait::Extensions_FunctionId* unsafe_arena_release_function_id(); + + // .io.substrait.Extensions.ExtensionId extension_id = 2; + bool has_extension_id() const; + private: + bool _internal_has_extension_id() const; + public: + void clear_extension_id(); + const ::io::substrait::Extensions_ExtensionId& extension_id() const; + ::io::substrait::Extensions_ExtensionId* release_extension_id(); + ::io::substrait::Extensions_ExtensionId* mutable_extension_id(); + void set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id); + private: + const ::io::substrait::Extensions_ExtensionId& _internal_extension_id() const; + ::io::substrait::Extensions_ExtensionId* _internal_mutable_extension_id(); + public: + void unsafe_arena_set_allocated_extension_id( + ::io::substrait::Extensions_ExtensionId* extension_id); + ::io::substrait::Extensions_ExtensionId* unsafe_arena_release_extension_id(); + + // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Mapping.FunctionMapping) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping_FunctionMapping_Option > options_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::io::substrait::Extensions_FunctionId* function_id_; + ::io::substrait::Extensions_ExtensionId* extension_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_extensions_2eproto; +}; +// ------------------------------------------------------------------- + +class Extensions_Mapping PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Mapping) */ { + public: + inline Extensions_Mapping() : Extensions_Mapping(nullptr) {} + ~Extensions_Mapping() override; + explicit constexpr Extensions_Mapping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions_Mapping(const Extensions_Mapping& from); + Extensions_Mapping(Extensions_Mapping&& from) noexcept + : Extensions_Mapping() { + *this = ::std::move(from); + } + + inline Extensions_Mapping& operator=(const Extensions_Mapping& from) { + CopyFrom(from); + return *this; + } + inline Extensions_Mapping& operator=(Extensions_Mapping&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions_Mapping& default_instance() { + return *internal_default_instance(); + } + enum MappingTypeCase { + kTypeMapping = 1, + kFunctionMapping = 2, + MAPPING_TYPE_NOT_SET = 0, + }; + + static inline const Extensions_Mapping* internal_default_instance() { + return reinterpret_cast( + &_Extensions_Mapping_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(Extensions_Mapping& a, Extensions_Mapping& b) { + a.Swap(&b); + } + inline void Swap(Extensions_Mapping* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions_Mapping* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions_Mapping* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions_Mapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions_Mapping& from); + void MergeFrom(const Extensions_Mapping& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions_Mapping* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions.Mapping"; + } + protected: + explicit Extensions_Mapping(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Extensions_Mapping_TypeMapping TypeMapping; + typedef Extensions_Mapping_FunctionMapping FunctionMapping; + + // accessors ------------------------------------------------------- + + enum : int { + kTypeMappingFieldNumber = 1, + kFunctionMappingFieldNumber = 2, + }; + // .io.substrait.Extensions.Mapping.TypeMapping type_mapping = 1; + bool has_type_mapping() const; + private: + bool _internal_has_type_mapping() const; + public: + void clear_type_mapping(); + const ::io::substrait::Extensions_Mapping_TypeMapping& type_mapping() const; + ::io::substrait::Extensions_Mapping_TypeMapping* release_type_mapping(); + ::io::substrait::Extensions_Mapping_TypeMapping* mutable_type_mapping(); + void set_allocated_type_mapping(::io::substrait::Extensions_Mapping_TypeMapping* type_mapping); + private: + const ::io::substrait::Extensions_Mapping_TypeMapping& _internal_type_mapping() const; + ::io::substrait::Extensions_Mapping_TypeMapping* _internal_mutable_type_mapping(); + public: + void unsafe_arena_set_allocated_type_mapping( + ::io::substrait::Extensions_Mapping_TypeMapping* type_mapping); + ::io::substrait::Extensions_Mapping_TypeMapping* unsafe_arena_release_type_mapping(); + + // .io.substrait.Extensions.Mapping.FunctionMapping function_mapping = 2; + bool has_function_mapping() const; + private: + bool _internal_has_function_mapping() const; + public: + void clear_function_mapping(); + const ::io::substrait::Extensions_Mapping_FunctionMapping& function_mapping() const; + ::io::substrait::Extensions_Mapping_FunctionMapping* release_function_mapping(); + ::io::substrait::Extensions_Mapping_FunctionMapping* mutable_function_mapping(); + void set_allocated_function_mapping(::io::substrait::Extensions_Mapping_FunctionMapping* function_mapping); + private: + const ::io::substrait::Extensions_Mapping_FunctionMapping& _internal_function_mapping() const; + ::io::substrait::Extensions_Mapping_FunctionMapping* _internal_mutable_function_mapping(); + public: + void unsafe_arena_set_allocated_function_mapping( + ::io::substrait::Extensions_Mapping_FunctionMapping* function_mapping); + ::io::substrait::Extensions_Mapping_FunctionMapping* unsafe_arena_release_function_mapping(); + + void clear_mapping_type(); + MappingTypeCase mapping_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Mapping) + private: + class _Internal; + void set_has_type_mapping(); + void set_has_function_mapping(); + + inline bool has_mapping_type() const; + inline void clear_has_mapping_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union MappingTypeUnion { + constexpr MappingTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Extensions_Mapping_TypeMapping* type_mapping_; + ::io::substrait::Extensions_Mapping_FunctionMapping* function_mapping_; + } mapping_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_extensions_2eproto; +}; +// ------------------------------------------------------------------- + +class Extensions_ExtensionId PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.ExtensionId) */ { + public: + inline Extensions_ExtensionId() : Extensions_ExtensionId(nullptr) {} + ~Extensions_ExtensionId() override; + explicit constexpr Extensions_ExtensionId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions_ExtensionId(const Extensions_ExtensionId& from); + Extensions_ExtensionId(Extensions_ExtensionId&& from) noexcept + : Extensions_ExtensionId() { + *this = ::std::move(from); + } + + inline Extensions_ExtensionId& operator=(const Extensions_ExtensionId& from) { + CopyFrom(from); + return *this; + } + inline Extensions_ExtensionId& operator=(Extensions_ExtensionId&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions_ExtensionId& default_instance() { + return *internal_default_instance(); + } + static inline const Extensions_ExtensionId* internal_default_instance() { + return reinterpret_cast( + &_Extensions_ExtensionId_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(Extensions_ExtensionId& a, Extensions_ExtensionId& b) { + a.Swap(&b); + } + inline void Swap(Extensions_ExtensionId* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions_ExtensionId* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions_ExtensionId* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions_ExtensionId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions_ExtensionId& from); + void MergeFrom(const Extensions_ExtensionId& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions_ExtensionId* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions.ExtensionId"; + } + protected: + explicit Extensions_ExtensionId(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdFieldNumber = 1, + }; + // uint32 id = 1; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_id() const; + void _internal_set_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Extensions.ExtensionId) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::uint32 id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_extensions_2eproto; +}; +// ------------------------------------------------------------------- + +class Extensions_FunctionId PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.FunctionId) */ { + public: + inline Extensions_FunctionId() : Extensions_FunctionId(nullptr) {} + ~Extensions_FunctionId() override; + explicit constexpr Extensions_FunctionId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions_FunctionId(const Extensions_FunctionId& from); + Extensions_FunctionId(Extensions_FunctionId&& from) noexcept + : Extensions_FunctionId() { + *this = ::std::move(from); + } + + inline Extensions_FunctionId& operator=(const Extensions_FunctionId& from) { + CopyFrom(from); + return *this; + } + inline Extensions_FunctionId& operator=(Extensions_FunctionId&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions_FunctionId& default_instance() { + return *internal_default_instance(); + } + static inline const Extensions_FunctionId* internal_default_instance() { + return reinterpret_cast( + &_Extensions_FunctionId_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(Extensions_FunctionId& a, Extensions_FunctionId& b) { + a.Swap(&b); + } + inline void Swap(Extensions_FunctionId* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions_FunctionId* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions_FunctionId* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions_FunctionId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions_FunctionId& from); + void MergeFrom(const Extensions_FunctionId& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions_FunctionId* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions.FunctionId"; + } + protected: + explicit Extensions_FunctionId(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdFieldNumber = 1, + }; + // uint64 id = 1; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_id() const; + void _internal_set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Extensions.FunctionId) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::uint64 id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_extensions_2eproto; +}; +// ------------------------------------------------------------------- + +class Extensions_TypeId PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.TypeId) */ { + public: + inline Extensions_TypeId() : Extensions_TypeId(nullptr) {} + ~Extensions_TypeId() override; + explicit constexpr Extensions_TypeId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions_TypeId(const Extensions_TypeId& from); + Extensions_TypeId(Extensions_TypeId&& from) noexcept + : Extensions_TypeId() { + *this = ::std::move(from); + } + + inline Extensions_TypeId& operator=(const Extensions_TypeId& from) { + CopyFrom(from); + return *this; + } + inline Extensions_TypeId& operator=(Extensions_TypeId&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions_TypeId& default_instance() { + return *internal_default_instance(); + } + static inline const Extensions_TypeId* internal_default_instance() { + return reinterpret_cast( + &_Extensions_TypeId_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(Extensions_TypeId& a, Extensions_TypeId& b) { + a.Swap(&b); + } + inline void Swap(Extensions_TypeId* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions_TypeId* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions_TypeId* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions_TypeId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions_TypeId& from); + void MergeFrom(const Extensions_TypeId& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions_TypeId* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions.TypeId"; + } + protected: + explicit Extensions_TypeId(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIdFieldNumber = 1, + }; + // uint64 id = 1; + void clear_id(); + ::PROTOBUF_NAMESPACE_ID::uint64 id() const; + void set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_id() const; + void _internal_set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Extensions.TypeId) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::uint64 id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_extensions_2eproto; +}; +// ------------------------------------------------------------------- + +class Extensions PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions) */ { + public: + inline Extensions() : Extensions(nullptr) {} + ~Extensions() override; + explicit constexpr Extensions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Extensions(const Extensions& from); + Extensions(Extensions&& from) noexcept + : Extensions() { + *this = ::std::move(from); + } + + inline Extensions& operator=(const Extensions& from) { + CopyFrom(from); + return *this; + } + inline Extensions& operator=(Extensions&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Extensions& default_instance() { + return *internal_default_instance(); + } + static inline const Extensions* internal_default_instance() { + return reinterpret_cast( + &_Extensions_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(Extensions& a, Extensions& b) { + a.Swap(&b); + } + inline void Swap(Extensions* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Extensions* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Extensions* New() const final { + return CreateMaybeMessage(nullptr); + } + + Extensions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Extensions& from); + void MergeFrom(const Extensions& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Extensions* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Extensions"; + } + protected: + explicit Extensions(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Extensions_Extension Extension; + typedef Extensions_Mapping Mapping; + typedef Extensions_ExtensionId ExtensionId; + typedef Extensions_FunctionId FunctionId; + typedef Extensions_TypeId TypeId; + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:io.substrait.Extensions) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_extensions_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Extensions_Extension_TypeExtension + +// string git_uri = 1; +inline void Extensions_Extension_TypeExtension::clear_git_uri() { + git_uri_.ClearToEmpty(); +} +inline const std::string& Extensions_Extension_TypeExtension::git_uri() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Extension.TypeExtension.git_uri) + return _internal_git_uri(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Extensions_Extension_TypeExtension::set_git_uri(ArgT0&& arg0, ArgT... args) { + + git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Extensions.Extension.TypeExtension.git_uri) +} +inline std::string* Extensions_Extension_TypeExtension::mutable_git_uri() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Extension.TypeExtension.git_uri) + return _internal_mutable_git_uri(); +} +inline const std::string& Extensions_Extension_TypeExtension::_internal_git_uri() const { + return git_uri_.Get(); +} +inline void Extensions_Extension_TypeExtension::_internal_set_git_uri(const std::string& value) { + + git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Extensions_Extension_TypeExtension::_internal_mutable_git_uri() { + + return git_uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Extensions_Extension_TypeExtension::release_git_uri() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Extension.TypeExtension.git_uri) + return git_uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Extensions_Extension_TypeExtension::set_allocated_git_uri(std::string* git_uri) { + if (git_uri != nullptr) { + + } else { + + } + git_uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), git_uri, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Extension.TypeExtension.git_uri) +} + +// ------------------------------------------------------------------- + +// Extensions_Extension_FunctionExtension + +// string git_uri = 1; +inline void Extensions_Extension_FunctionExtension::clear_git_uri() { + git_uri_.ClearToEmpty(); +} +inline const std::string& Extensions_Extension_FunctionExtension::git_uri() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Extension.FunctionExtension.git_uri) + return _internal_git_uri(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Extensions_Extension_FunctionExtension::set_git_uri(ArgT0&& arg0, ArgT... args) { + + git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Extensions.Extension.FunctionExtension.git_uri) +} +inline std::string* Extensions_Extension_FunctionExtension::mutable_git_uri() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Extension.FunctionExtension.git_uri) + return _internal_mutable_git_uri(); +} +inline const std::string& Extensions_Extension_FunctionExtension::_internal_git_uri() const { + return git_uri_.Get(); +} +inline void Extensions_Extension_FunctionExtension::_internal_set_git_uri(const std::string& value) { + + git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Extensions_Extension_FunctionExtension::_internal_mutable_git_uri() { + + return git_uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Extensions_Extension_FunctionExtension::release_git_uri() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Extension.FunctionExtension.git_uri) + return git_uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Extensions_Extension_FunctionExtension::set_allocated_git_uri(std::string* git_uri) { + if (git_uri != nullptr) { + + } else { + + } + git_uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), git_uri, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Extension.FunctionExtension.git_uri) +} + +// ------------------------------------------------------------------- + +// Extensions_Extension + +// .io.substrait.Extensions.ExtensionId extension_id = 1; +inline bool Extensions_Extension::_internal_has_extension_id() const { + return this != internal_default_instance() && extension_id_ != nullptr; +} +inline bool Extensions_Extension::has_extension_id() const { + return _internal_has_extension_id(); +} +inline void Extensions_Extension::clear_extension_id() { + if (GetArena() == nullptr && extension_id_ != nullptr) { + delete extension_id_; + } + extension_id_ = nullptr; +} +inline const ::io::substrait::Extensions_ExtensionId& Extensions_Extension::_internal_extension_id() const { + const ::io::substrait::Extensions_ExtensionId* p = extension_id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_ExtensionId_default_instance_); +} +inline const ::io::substrait::Extensions_ExtensionId& Extensions_Extension::extension_id() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Extension.extension_id) + return _internal_extension_id(); +} +inline void Extensions_Extension::unsafe_arena_set_allocated_extension_id( + ::io::substrait::Extensions_ExtensionId* extension_id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(extension_id_); + } + extension_id_ = extension_id; + if (extension_id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Extension.extension_id) +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Extension::release_extension_id() { + + ::io::substrait::Extensions_ExtensionId* temp = extension_id_; + extension_id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Extension::unsafe_arena_release_extension_id() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Extension.extension_id) + + ::io::substrait::Extensions_ExtensionId* temp = extension_id_; + extension_id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Extension::_internal_mutable_extension_id() { + + if (extension_id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_ExtensionId>(GetArena()); + extension_id_ = p; + } + return extension_id_; +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Extension::mutable_extension_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Extension.extension_id) + return _internal_mutable_extension_id(); +} +inline void Extensions_Extension::set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete extension_id_; + } + if (extension_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_id); + if (message_arena != submessage_arena) { + extension_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_id, submessage_arena); + } + + } else { + + } + extension_id_ = extension_id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Extension.extension_id) +} + +// .io.substrait.Extensions.Extension.TypeExtension type_extension = 2; +inline bool Extensions_Extension::_internal_has_type_extension() const { + return extension_type_case() == kTypeExtension; +} +inline bool Extensions_Extension::has_type_extension() const { + return _internal_has_type_extension(); +} +inline void Extensions_Extension::set_has_type_extension() { + _oneof_case_[0] = kTypeExtension; +} +inline void Extensions_Extension::clear_type_extension() { + if (_internal_has_type_extension()) { + if (GetArena() == nullptr) { + delete extension_type_.type_extension_; + } + clear_has_extension_type(); + } +} +inline ::io::substrait::Extensions_Extension_TypeExtension* Extensions_Extension::release_type_extension() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Extension.type_extension) + if (_internal_has_type_extension()) { + clear_has_extension_type(); + ::io::substrait::Extensions_Extension_TypeExtension* temp = extension_type_.type_extension_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + extension_type_.type_extension_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Extensions_Extension_TypeExtension& Extensions_Extension::_internal_type_extension() const { + return _internal_has_type_extension() + ? *extension_type_.type_extension_ + : reinterpret_cast< ::io::substrait::Extensions_Extension_TypeExtension&>(::io::substrait::_Extensions_Extension_TypeExtension_default_instance_); +} +inline const ::io::substrait::Extensions_Extension_TypeExtension& Extensions_Extension::type_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Extension.type_extension) + return _internal_type_extension(); +} +inline ::io::substrait::Extensions_Extension_TypeExtension* Extensions_Extension::unsafe_arena_release_type_extension() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Extensions.Extension.type_extension) + if (_internal_has_type_extension()) { + clear_has_extension_type(); + ::io::substrait::Extensions_Extension_TypeExtension* temp = extension_type_.type_extension_; + extension_type_.type_extension_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Extensions_Extension::unsafe_arena_set_allocated_type_extension(::io::substrait::Extensions_Extension_TypeExtension* type_extension) { + clear_extension_type(); + if (type_extension) { + set_has_type_extension(); + extension_type_.type_extension_ = type_extension; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Extension.type_extension) +} +inline ::io::substrait::Extensions_Extension_TypeExtension* Extensions_Extension::_internal_mutable_type_extension() { + if (!_internal_has_type_extension()) { + clear_extension_type(); + set_has_type_extension(); + extension_type_.type_extension_ = CreateMaybeMessage< ::io::substrait::Extensions_Extension_TypeExtension >(GetArena()); + } + return extension_type_.type_extension_; +} +inline ::io::substrait::Extensions_Extension_TypeExtension* Extensions_Extension::mutable_type_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Extension.type_extension) + return _internal_mutable_type_extension(); +} + +// .io.substrait.Extensions.Extension.FunctionExtension function_extension = 3; +inline bool Extensions_Extension::_internal_has_function_extension() const { + return extension_type_case() == kFunctionExtension; +} +inline bool Extensions_Extension::has_function_extension() const { + return _internal_has_function_extension(); +} +inline void Extensions_Extension::set_has_function_extension() { + _oneof_case_[0] = kFunctionExtension; +} +inline void Extensions_Extension::clear_function_extension() { + if (_internal_has_function_extension()) { + if (GetArena() == nullptr) { + delete extension_type_.function_extension_; + } + clear_has_extension_type(); + } +} +inline ::io::substrait::Extensions_Extension_FunctionExtension* Extensions_Extension::release_function_extension() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Extension.function_extension) + if (_internal_has_function_extension()) { + clear_has_extension_type(); + ::io::substrait::Extensions_Extension_FunctionExtension* temp = extension_type_.function_extension_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + extension_type_.function_extension_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Extensions_Extension_FunctionExtension& Extensions_Extension::_internal_function_extension() const { + return _internal_has_function_extension() + ? *extension_type_.function_extension_ + : reinterpret_cast< ::io::substrait::Extensions_Extension_FunctionExtension&>(::io::substrait::_Extensions_Extension_FunctionExtension_default_instance_); +} +inline const ::io::substrait::Extensions_Extension_FunctionExtension& Extensions_Extension::function_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Extension.function_extension) + return _internal_function_extension(); +} +inline ::io::substrait::Extensions_Extension_FunctionExtension* Extensions_Extension::unsafe_arena_release_function_extension() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Extensions.Extension.function_extension) + if (_internal_has_function_extension()) { + clear_has_extension_type(); + ::io::substrait::Extensions_Extension_FunctionExtension* temp = extension_type_.function_extension_; + extension_type_.function_extension_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Extensions_Extension::unsafe_arena_set_allocated_function_extension(::io::substrait::Extensions_Extension_FunctionExtension* function_extension) { + clear_extension_type(); + if (function_extension) { + set_has_function_extension(); + extension_type_.function_extension_ = function_extension; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Extension.function_extension) +} +inline ::io::substrait::Extensions_Extension_FunctionExtension* Extensions_Extension::_internal_mutable_function_extension() { + if (!_internal_has_function_extension()) { + clear_extension_type(); + set_has_function_extension(); + extension_type_.function_extension_ = CreateMaybeMessage< ::io::substrait::Extensions_Extension_FunctionExtension >(GetArena()); + } + return extension_type_.function_extension_; +} +inline ::io::substrait::Extensions_Extension_FunctionExtension* Extensions_Extension::mutable_function_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Extension.function_extension) + return _internal_mutable_function_extension(); +} + +inline bool Extensions_Extension::has_extension_type() const { + return extension_type_case() != EXTENSION_TYPE_NOT_SET; +} +inline void Extensions_Extension::clear_has_extension_type() { + _oneof_case_[0] = EXTENSION_TYPE_NOT_SET; +} +inline Extensions_Extension::ExtensionTypeCase Extensions_Extension::extension_type_case() const { + return Extensions_Extension::ExtensionTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Extensions_Mapping_TypeMapping + +// .io.substrait.Extensions.TypeId type_id = 1; +inline bool Extensions_Mapping_TypeMapping::_internal_has_type_id() const { + return this != internal_default_instance() && type_id_ != nullptr; +} +inline bool Extensions_Mapping_TypeMapping::has_type_id() const { + return _internal_has_type_id(); +} +inline void Extensions_Mapping_TypeMapping::clear_type_id() { + if (GetArena() == nullptr && type_id_ != nullptr) { + delete type_id_; + } + type_id_ = nullptr; +} +inline const ::io::substrait::Extensions_TypeId& Extensions_Mapping_TypeMapping::_internal_type_id() const { + const ::io::substrait::Extensions_TypeId* p = type_id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_TypeId_default_instance_); +} +inline const ::io::substrait::Extensions_TypeId& Extensions_Mapping_TypeMapping::type_id() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.TypeMapping.type_id) + return _internal_type_id(); +} +inline void Extensions_Mapping_TypeMapping::unsafe_arena_set_allocated_type_id( + ::io::substrait::Extensions_TypeId* type_id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_id_); + } + type_id_ = type_id; + if (type_id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.TypeMapping.type_id) +} +inline ::io::substrait::Extensions_TypeId* Extensions_Mapping_TypeMapping::release_type_id() { + + ::io::substrait::Extensions_TypeId* temp = type_id_; + type_id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_TypeId* Extensions_Mapping_TypeMapping::unsafe_arena_release_type_id() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.TypeMapping.type_id) + + ::io::substrait::Extensions_TypeId* temp = type_id_; + type_id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_TypeId* Extensions_Mapping_TypeMapping::_internal_mutable_type_id() { + + if (type_id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_TypeId>(GetArena()); + type_id_ = p; + } + return type_id_; +} +inline ::io::substrait::Extensions_TypeId* Extensions_Mapping_TypeMapping::mutable_type_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.TypeMapping.type_id) + return _internal_mutable_type_id(); +} +inline void Extensions_Mapping_TypeMapping::set_allocated_type_id(::io::substrait::Extensions_TypeId* type_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete type_id_; + } + if (type_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_id); + if (message_arena != submessage_arena) { + type_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type_id, submessage_arena); + } + + } else { + + } + type_id_ = type_id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.TypeMapping.type_id) +} + +// .io.substrait.Extensions.ExtensionId extension_id = 2; +inline bool Extensions_Mapping_TypeMapping::_internal_has_extension_id() const { + return this != internal_default_instance() && extension_id_ != nullptr; +} +inline bool Extensions_Mapping_TypeMapping::has_extension_id() const { + return _internal_has_extension_id(); +} +inline void Extensions_Mapping_TypeMapping::clear_extension_id() { + if (GetArena() == nullptr && extension_id_ != nullptr) { + delete extension_id_; + } + extension_id_ = nullptr; +} +inline const ::io::substrait::Extensions_ExtensionId& Extensions_Mapping_TypeMapping::_internal_extension_id() const { + const ::io::substrait::Extensions_ExtensionId* p = extension_id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_ExtensionId_default_instance_); +} +inline const ::io::substrait::Extensions_ExtensionId& Extensions_Mapping_TypeMapping::extension_id() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.TypeMapping.extension_id) + return _internal_extension_id(); +} +inline void Extensions_Mapping_TypeMapping::unsafe_arena_set_allocated_extension_id( + ::io::substrait::Extensions_ExtensionId* extension_id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(extension_id_); + } + extension_id_ = extension_id; + if (extension_id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.TypeMapping.extension_id) +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_TypeMapping::release_extension_id() { + + ::io::substrait::Extensions_ExtensionId* temp = extension_id_; + extension_id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_TypeMapping::unsafe_arena_release_extension_id() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.TypeMapping.extension_id) + + ::io::substrait::Extensions_ExtensionId* temp = extension_id_; + extension_id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_TypeMapping::_internal_mutable_extension_id() { + + if (extension_id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_ExtensionId>(GetArena()); + extension_id_ = p; + } + return extension_id_; +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_TypeMapping::mutable_extension_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.TypeMapping.extension_id) + return _internal_mutable_extension_id(); +} +inline void Extensions_Mapping_TypeMapping::set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete extension_id_; + } + if (extension_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_id); + if (message_arena != submessage_arena) { + extension_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_id, submessage_arena); + } + + } else { + + } + extension_id_ = extension_id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.TypeMapping.extension_id) +} + +// string name = 3; +inline void Extensions_Mapping_TypeMapping::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& Extensions_Mapping_TypeMapping::name() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.TypeMapping.name) + return _internal_name(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Extensions_Mapping_TypeMapping::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Extensions.Mapping.TypeMapping.name) +} +inline std::string* Extensions_Mapping_TypeMapping::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.TypeMapping.name) + return _internal_mutable_name(); +} +inline const std::string& Extensions_Mapping_TypeMapping::_internal_name() const { + return name_.Get(); +} +inline void Extensions_Mapping_TypeMapping::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Extensions_Mapping_TypeMapping::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Extensions_Mapping_TypeMapping::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.TypeMapping.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Extensions_Mapping_TypeMapping::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.TypeMapping.name) +} + +// ------------------------------------------------------------------- + +// Extensions_Mapping_FunctionMapping_Option + +// string key = 1; +inline void Extensions_Mapping_FunctionMapping_Option::clear_key() { + key_.ClearToEmpty(); +} +inline const std::string& Extensions_Mapping_FunctionMapping_Option::key() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.Option.key) + return _internal_key(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Extensions_Mapping_FunctionMapping_Option::set_key(ArgT0&& arg0, ArgT... args) { + + key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Extensions.Mapping.FunctionMapping.Option.key) +} +inline std::string* Extensions_Mapping_FunctionMapping_Option::mutable_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.Option.key) + return _internal_mutable_key(); +} +inline const std::string& Extensions_Mapping_FunctionMapping_Option::_internal_key() const { + return key_.Get(); +} +inline void Extensions_Mapping_FunctionMapping_Option::_internal_set_key(const std::string& value) { + + key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Extensions_Mapping_FunctionMapping_Option::_internal_mutable_key() { + + return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Extensions_Mapping_FunctionMapping_Option::release_key() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.FunctionMapping.Option.key) + return key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Extensions_Mapping_FunctionMapping_Option::set_allocated_key(std::string* key) { + if (key != nullptr) { + + } else { + + } + key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.Option.key) +} + +// string value = 2; +inline void Extensions_Mapping_FunctionMapping_Option::clear_value() { + value_.ClearToEmpty(); +} +inline const std::string& Extensions_Mapping_FunctionMapping_Option::value() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.Option.value) + return _internal_value(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Extensions_Mapping_FunctionMapping_Option::set_value(ArgT0&& arg0, ArgT... args) { + + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Extensions.Mapping.FunctionMapping.Option.value) +} +inline std::string* Extensions_Mapping_FunctionMapping_Option::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.Option.value) + return _internal_mutable_value(); +} +inline const std::string& Extensions_Mapping_FunctionMapping_Option::_internal_value() const { + return value_.Get(); +} +inline void Extensions_Mapping_FunctionMapping_Option::_internal_set_value(const std::string& value) { + + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Extensions_Mapping_FunctionMapping_Option::_internal_mutable_value() { + + return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Extensions_Mapping_FunctionMapping_Option::release_value() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.FunctionMapping.Option.value) + return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Extensions_Mapping_FunctionMapping_Option::set_allocated_value(std::string* value) { + if (value != nullptr) { + + } else { + + } + value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.Option.value) +} + +// ------------------------------------------------------------------- + +// Extensions_Mapping_FunctionMapping + +// .io.substrait.Extensions.FunctionId function_id = 1; +inline bool Extensions_Mapping_FunctionMapping::_internal_has_function_id() const { + return this != internal_default_instance() && function_id_ != nullptr; +} +inline bool Extensions_Mapping_FunctionMapping::has_function_id() const { + return _internal_has_function_id(); +} +inline void Extensions_Mapping_FunctionMapping::clear_function_id() { + if (GetArena() == nullptr && function_id_ != nullptr) { + delete function_id_; + } + function_id_ = nullptr; +} +inline const ::io::substrait::Extensions_FunctionId& Extensions_Mapping_FunctionMapping::_internal_function_id() const { + const ::io::substrait::Extensions_FunctionId* p = function_id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_FunctionId_default_instance_); +} +inline const ::io::substrait::Extensions_FunctionId& Extensions_Mapping_FunctionMapping::function_id() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.function_id) + return _internal_function_id(); +} +inline void Extensions_Mapping_FunctionMapping::unsafe_arena_set_allocated_function_id( + ::io::substrait::Extensions_FunctionId* function_id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(function_id_); + } + function_id_ = function_id; + if (function_id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.function_id) +} +inline ::io::substrait::Extensions_FunctionId* Extensions_Mapping_FunctionMapping::release_function_id() { + + ::io::substrait::Extensions_FunctionId* temp = function_id_; + function_id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_FunctionId* Extensions_Mapping_FunctionMapping::unsafe_arena_release_function_id() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.FunctionMapping.function_id) + + ::io::substrait::Extensions_FunctionId* temp = function_id_; + function_id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_FunctionId* Extensions_Mapping_FunctionMapping::_internal_mutable_function_id() { + + if (function_id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); + function_id_ = p; + } + return function_id_; +} +inline ::io::substrait::Extensions_FunctionId* Extensions_Mapping_FunctionMapping::mutable_function_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.function_id) + return _internal_mutable_function_id(); +} +inline void Extensions_Mapping_FunctionMapping::set_allocated_function_id(::io::substrait::Extensions_FunctionId* function_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete function_id_; + } + if (function_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(function_id); + if (message_arena != submessage_arena) { + function_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, function_id, submessage_arena); + } + + } else { + + } + function_id_ = function_id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.function_id) +} + +// .io.substrait.Extensions.ExtensionId extension_id = 2; +inline bool Extensions_Mapping_FunctionMapping::_internal_has_extension_id() const { + return this != internal_default_instance() && extension_id_ != nullptr; +} +inline bool Extensions_Mapping_FunctionMapping::has_extension_id() const { + return _internal_has_extension_id(); +} +inline void Extensions_Mapping_FunctionMapping::clear_extension_id() { + if (GetArena() == nullptr && extension_id_ != nullptr) { + delete extension_id_; + } + extension_id_ = nullptr; +} +inline const ::io::substrait::Extensions_ExtensionId& Extensions_Mapping_FunctionMapping::_internal_extension_id() const { + const ::io::substrait::Extensions_ExtensionId* p = extension_id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_ExtensionId_default_instance_); +} +inline const ::io::substrait::Extensions_ExtensionId& Extensions_Mapping_FunctionMapping::extension_id() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.extension_id) + return _internal_extension_id(); +} +inline void Extensions_Mapping_FunctionMapping::unsafe_arena_set_allocated_extension_id( + ::io::substrait::Extensions_ExtensionId* extension_id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(extension_id_); + } + extension_id_ = extension_id; + if (extension_id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.extension_id) +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_FunctionMapping::release_extension_id() { + + ::io::substrait::Extensions_ExtensionId* temp = extension_id_; + extension_id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_FunctionMapping::unsafe_arena_release_extension_id() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.FunctionMapping.extension_id) + + ::io::substrait::Extensions_ExtensionId* temp = extension_id_; + extension_id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_FunctionMapping::_internal_mutable_extension_id() { + + if (extension_id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_ExtensionId>(GetArena()); + extension_id_ = p; + } + return extension_id_; +} +inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_FunctionMapping::mutable_extension_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.extension_id) + return _internal_mutable_extension_id(); +} +inline void Extensions_Mapping_FunctionMapping::set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete extension_id_; + } + if (extension_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_id); + if (message_arena != submessage_arena) { + extension_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_id, submessage_arena); + } + + } else { + + } + extension_id_ = extension_id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.extension_id) +} + +// string name = 3; +inline void Extensions_Mapping_FunctionMapping::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& Extensions_Mapping_FunctionMapping::name() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.name) + return _internal_name(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Extensions_Mapping_FunctionMapping::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Extensions.Mapping.FunctionMapping.name) +} +inline std::string* Extensions_Mapping_FunctionMapping::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.name) + return _internal_mutable_name(); +} +inline const std::string& Extensions_Mapping_FunctionMapping::_internal_name() const { + return name_.Get(); +} +inline void Extensions_Mapping_FunctionMapping::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Extensions_Mapping_FunctionMapping::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Extensions_Mapping_FunctionMapping::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.FunctionMapping.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Extensions_Mapping_FunctionMapping::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.name) +} + +// repeated .io.substrait.Extensions.Mapping.FunctionMapping.Option options = 5; +inline int Extensions_Mapping_FunctionMapping::_internal_options_size() const { + return options_.size(); +} +inline int Extensions_Mapping_FunctionMapping::options_size() const { + return _internal_options_size(); +} +inline void Extensions_Mapping_FunctionMapping::clear_options() { + options_.Clear(); +} +inline ::io::substrait::Extensions_Mapping_FunctionMapping_Option* Extensions_Mapping_FunctionMapping::mutable_options(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.options) + return options_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >* +Extensions_Mapping_FunctionMapping::mutable_options() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Extensions.Mapping.FunctionMapping.options) + return &options_; +} +inline const ::io::substrait::Extensions_Mapping_FunctionMapping_Option& Extensions_Mapping_FunctionMapping::_internal_options(int index) const { + return options_.Get(index); +} +inline const ::io::substrait::Extensions_Mapping_FunctionMapping_Option& Extensions_Mapping_FunctionMapping::options(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.options) + return _internal_options(index); +} +inline ::io::substrait::Extensions_Mapping_FunctionMapping_Option* Extensions_Mapping_FunctionMapping::_internal_add_options() { + return options_.Add(); +} +inline ::io::substrait::Extensions_Mapping_FunctionMapping_Option* Extensions_Mapping_FunctionMapping::add_options() { + // @@protoc_insertion_point(field_add:io.substrait.Extensions.Mapping.FunctionMapping.options) + return _internal_add_options(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >& +Extensions_Mapping_FunctionMapping::options() const { + // @@protoc_insertion_point(field_list:io.substrait.Extensions.Mapping.FunctionMapping.options) + return options_; +} + +// ------------------------------------------------------------------- + +// Extensions_Mapping + +// .io.substrait.Extensions.Mapping.TypeMapping type_mapping = 1; +inline bool Extensions_Mapping::_internal_has_type_mapping() const { + return mapping_type_case() == kTypeMapping; +} +inline bool Extensions_Mapping::has_type_mapping() const { + return _internal_has_type_mapping(); +} +inline void Extensions_Mapping::set_has_type_mapping() { + _oneof_case_[0] = kTypeMapping; +} +inline void Extensions_Mapping::clear_type_mapping() { + if (_internal_has_type_mapping()) { + if (GetArena() == nullptr) { + delete mapping_type_.type_mapping_; + } + clear_has_mapping_type(); + } +} +inline ::io::substrait::Extensions_Mapping_TypeMapping* Extensions_Mapping::release_type_mapping() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.type_mapping) + if (_internal_has_type_mapping()) { + clear_has_mapping_type(); + ::io::substrait::Extensions_Mapping_TypeMapping* temp = mapping_type_.type_mapping_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + mapping_type_.type_mapping_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Extensions_Mapping_TypeMapping& Extensions_Mapping::_internal_type_mapping() const { + return _internal_has_type_mapping() + ? *mapping_type_.type_mapping_ + : reinterpret_cast< ::io::substrait::Extensions_Mapping_TypeMapping&>(::io::substrait::_Extensions_Mapping_TypeMapping_default_instance_); +} +inline const ::io::substrait::Extensions_Mapping_TypeMapping& Extensions_Mapping::type_mapping() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.type_mapping) + return _internal_type_mapping(); +} +inline ::io::substrait::Extensions_Mapping_TypeMapping* Extensions_Mapping::unsafe_arena_release_type_mapping() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Extensions.Mapping.type_mapping) + if (_internal_has_type_mapping()) { + clear_has_mapping_type(); + ::io::substrait::Extensions_Mapping_TypeMapping* temp = mapping_type_.type_mapping_; + mapping_type_.type_mapping_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Extensions_Mapping::unsafe_arena_set_allocated_type_mapping(::io::substrait::Extensions_Mapping_TypeMapping* type_mapping) { + clear_mapping_type(); + if (type_mapping) { + set_has_type_mapping(); + mapping_type_.type_mapping_ = type_mapping; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.type_mapping) +} +inline ::io::substrait::Extensions_Mapping_TypeMapping* Extensions_Mapping::_internal_mutable_type_mapping() { + if (!_internal_has_type_mapping()) { + clear_mapping_type(); + set_has_type_mapping(); + mapping_type_.type_mapping_ = CreateMaybeMessage< ::io::substrait::Extensions_Mapping_TypeMapping >(GetArena()); + } + return mapping_type_.type_mapping_; +} +inline ::io::substrait::Extensions_Mapping_TypeMapping* Extensions_Mapping::mutable_type_mapping() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.type_mapping) + return _internal_mutable_type_mapping(); +} + +// .io.substrait.Extensions.Mapping.FunctionMapping function_mapping = 2; +inline bool Extensions_Mapping::_internal_has_function_mapping() const { + return mapping_type_case() == kFunctionMapping; +} +inline bool Extensions_Mapping::has_function_mapping() const { + return _internal_has_function_mapping(); +} +inline void Extensions_Mapping::set_has_function_mapping() { + _oneof_case_[0] = kFunctionMapping; +} +inline void Extensions_Mapping::clear_function_mapping() { + if (_internal_has_function_mapping()) { + if (GetArena() == nullptr) { + delete mapping_type_.function_mapping_; + } + clear_has_mapping_type(); + } +} +inline ::io::substrait::Extensions_Mapping_FunctionMapping* Extensions_Mapping::release_function_mapping() { + // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.function_mapping) + if (_internal_has_function_mapping()) { + clear_has_mapping_type(); + ::io::substrait::Extensions_Mapping_FunctionMapping* temp = mapping_type_.function_mapping_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + mapping_type_.function_mapping_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Extensions_Mapping_FunctionMapping& Extensions_Mapping::_internal_function_mapping() const { + return _internal_has_function_mapping() + ? *mapping_type_.function_mapping_ + : reinterpret_cast< ::io::substrait::Extensions_Mapping_FunctionMapping&>(::io::substrait::_Extensions_Mapping_FunctionMapping_default_instance_); +} +inline const ::io::substrait::Extensions_Mapping_FunctionMapping& Extensions_Mapping::function_mapping() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.function_mapping) + return _internal_function_mapping(); +} +inline ::io::substrait::Extensions_Mapping_FunctionMapping* Extensions_Mapping::unsafe_arena_release_function_mapping() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Extensions.Mapping.function_mapping) + if (_internal_has_function_mapping()) { + clear_has_mapping_type(); + ::io::substrait::Extensions_Mapping_FunctionMapping* temp = mapping_type_.function_mapping_; + mapping_type_.function_mapping_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Extensions_Mapping::unsafe_arena_set_allocated_function_mapping(::io::substrait::Extensions_Mapping_FunctionMapping* function_mapping) { + clear_mapping_type(); + if (function_mapping) { + set_has_function_mapping(); + mapping_type_.function_mapping_ = function_mapping; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.function_mapping) +} +inline ::io::substrait::Extensions_Mapping_FunctionMapping* Extensions_Mapping::_internal_mutable_function_mapping() { + if (!_internal_has_function_mapping()) { + clear_mapping_type(); + set_has_function_mapping(); + mapping_type_.function_mapping_ = CreateMaybeMessage< ::io::substrait::Extensions_Mapping_FunctionMapping >(GetArena()); + } + return mapping_type_.function_mapping_; +} +inline ::io::substrait::Extensions_Mapping_FunctionMapping* Extensions_Mapping::mutable_function_mapping() { + // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.function_mapping) + return _internal_mutable_function_mapping(); +} + +inline bool Extensions_Mapping::has_mapping_type() const { + return mapping_type_case() != MAPPING_TYPE_NOT_SET; +} +inline void Extensions_Mapping::clear_has_mapping_type() { + _oneof_case_[0] = MAPPING_TYPE_NOT_SET; +} +inline Extensions_Mapping::MappingTypeCase Extensions_Mapping::mapping_type_case() const { + return Extensions_Mapping::MappingTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Extensions_ExtensionId + +// uint32 id = 1; +inline void Extensions_ExtensionId::clear_id() { + id_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Extensions_ExtensionId::_internal_id() const { + return id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Extensions_ExtensionId::id() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.ExtensionId.id) + return _internal_id(); +} +inline void Extensions_ExtensionId::_internal_set_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + id_ = value; +} +inline void Extensions_ExtensionId::set_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:io.substrait.Extensions.ExtensionId.id) +} + +// ------------------------------------------------------------------- + +// Extensions_FunctionId + +// uint64 id = 1; +inline void Extensions_FunctionId::clear_id() { + id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Extensions_FunctionId::_internal_id() const { + return id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Extensions_FunctionId::id() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.FunctionId.id) + return _internal_id(); +} +inline void Extensions_FunctionId::_internal_set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + id_ = value; +} +inline void Extensions_FunctionId::set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:io.substrait.Extensions.FunctionId.id) +} + +// ------------------------------------------------------------------- + +// Extensions_TypeId + +// uint64 id = 1; +inline void Extensions_TypeId::clear_id() { + id_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Extensions_TypeId::_internal_id() const { + return id_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 Extensions_TypeId::id() const { + // @@protoc_insertion_point(field_get:io.substrait.Extensions.TypeId.id) + return _internal_id(); +} +inline void Extensions_TypeId::_internal_set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + id_ = value; +} +inline void Extensions_TypeId::set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:io.substrait.Extensions.TypeId.id) +} + +// ------------------------------------------------------------------- + +// Extensions + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace substrait +} // namespace io + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_extensions_2eproto diff --git a/cpp/src/generated/substrait/function.pb.cc b/cpp/src/generated/substrait/function.pb.cc new file mode 100644 index 00000000000..f3ba8054b1d --- /dev/null +++ b/cpp/src/generated/substrait/function.pb.cc @@ -0,0 +1,4689 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: function.proto + +#include "function.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace io { +namespace substrait { +constexpr FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : min_args_(PROTOBUF_LONGLONG(0)) + , max_args_(PROTOBUF_LONGLONG(0)) + , consistency_(0) +{} +struct FunctionSignature_FinalArgVariadicDefaultTypeInternal { + constexpr FunctionSignature_FinalArgVariadicDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_FinalArgVariadicDefaultTypeInternal() {} + union { + FunctionSignature_FinalArgVariadic _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_FinalArgVariadicDefaultTypeInternal _FunctionSignature_FinalArgVariadic_default_instance_; +constexpr FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct FunctionSignature_FinalArgNormalDefaultTypeInternal { + constexpr FunctionSignature_FinalArgNormalDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_FinalArgNormalDefaultTypeInternal() {} + union { + FunctionSignature_FinalArgNormal _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_FinalArgNormalDefaultTypeInternal _FunctionSignature_FinalArgNormal_default_instance_; +constexpr FunctionSignature_Scalar::FunctionSignature_Scalar( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : arguments_() + , name_() + , implementations_() + , id_(nullptr) + , description_(nullptr) + , output_type_(nullptr) + , deterministic_(false) + , session_dependent_(false) + , _oneof_case_{}{} +struct FunctionSignature_ScalarDefaultTypeInternal { + constexpr FunctionSignature_ScalarDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_ScalarDefaultTypeInternal() {} + union { + FunctionSignature_Scalar _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ScalarDefaultTypeInternal _FunctionSignature_Scalar_default_instance_; +constexpr FunctionSignature_Aggregate::FunctionSignature_Aggregate( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : arguments_() + , name_() + , implementations_() + , id_(nullptr) + , description_(nullptr) + , output_type_(nullptr) + , intermediate_type_(nullptr) + , max_set_(PROTOBUF_ULONGLONG(0)) + , deterministic_(false) + , session_dependent_(false) + , ordered_(false) + , _oneof_case_{}{} +struct FunctionSignature_AggregateDefaultTypeInternal { + constexpr FunctionSignature_AggregateDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_AggregateDefaultTypeInternal() {} + union { + FunctionSignature_Aggregate _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_AggregateDefaultTypeInternal _FunctionSignature_Aggregate_default_instance_; +constexpr FunctionSignature_Window::FunctionSignature_Window( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : arguments_() + , name_() + , implementations_() + , id_(nullptr) + , description_(nullptr) + , intermediate_type_(nullptr) + , output_type_(nullptr) + , deterministic_(false) + , session_dependent_(false) + , ordered_(false) + , window_type_(0) + + , max_set_(PROTOBUF_ULONGLONG(0)) + , _oneof_case_{}{} +struct FunctionSignature_WindowDefaultTypeInternal { + constexpr FunctionSignature_WindowDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_WindowDefaultTypeInternal() {} + union { + FunctionSignature_Window _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_WindowDefaultTypeInternal _FunctionSignature_Window_default_instance_; +constexpr FunctionSignature_Description::FunctionSignature_Description( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : language_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , body_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct FunctionSignature_DescriptionDefaultTypeInternal { + constexpr FunctionSignature_DescriptionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_DescriptionDefaultTypeInternal() {} + union { + FunctionSignature_Description _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_DescriptionDefaultTypeInternal _FunctionSignature_Description_default_instance_; +constexpr FunctionSignature_Implementation::FunctionSignature_Implementation( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , type_(0) +{} +struct FunctionSignature_ImplementationDefaultTypeInternal { + constexpr FunctionSignature_ImplementationDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_ImplementationDefaultTypeInternal() {} + union { + FunctionSignature_Implementation _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ImplementationDefaultTypeInternal _FunctionSignature_Implementation_default_instance_; +constexpr FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : type_(nullptr) + , constant_(false){} +struct FunctionSignature_Argument_ValueArgumentDefaultTypeInternal { + constexpr FunctionSignature_Argument_ValueArgumentDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_Argument_ValueArgumentDefaultTypeInternal() {} + union { + FunctionSignature_Argument_ValueArgument _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_ValueArgumentDefaultTypeInternal _FunctionSignature_Argument_ValueArgument_default_instance_; +constexpr FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : type_(nullptr){} +struct FunctionSignature_Argument_TypeArgumentDefaultTypeInternal { + constexpr FunctionSignature_Argument_TypeArgumentDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_Argument_TypeArgumentDefaultTypeInternal() {} + union { + FunctionSignature_Argument_TypeArgument _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_TypeArgumentDefaultTypeInternal _FunctionSignature_Argument_TypeArgument_default_instance_; +constexpr FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : options_() + , optional_(false){} +struct FunctionSignature_Argument_EnumArgumentDefaultTypeInternal { + constexpr FunctionSignature_Argument_EnumArgumentDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_Argument_EnumArgumentDefaultTypeInternal() {} + union { + FunctionSignature_Argument_EnumArgument _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_EnumArgumentDefaultTypeInternal _FunctionSignature_Argument_EnumArgument_default_instance_; +constexpr FunctionSignature_Argument::FunctionSignature_Argument( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , _oneof_case_{}{} +struct FunctionSignature_ArgumentDefaultTypeInternal { + constexpr FunctionSignature_ArgumentDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignature_ArgumentDefaultTypeInternal() {} + union { + FunctionSignature_Argument _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ArgumentDefaultTypeInternal _FunctionSignature_Argument_default_instance_; +constexpr FunctionSignature::FunctionSignature( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct FunctionSignatureDefaultTypeInternal { + constexpr FunctionSignatureDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FunctionSignatureDefaultTypeInternal() {} + union { + FunctionSignature _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignatureDefaultTypeInternal _FunctionSignature_default_instance_; +} // namespace substrait +} // namespace io +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_function_2eproto[12]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_function_2eproto[3]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_function_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_function_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_FinalArgVariadic, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_FinalArgVariadic, min_args_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_FinalArgVariadic, max_args_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_FinalArgVariadic, consistency_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_FinalArgNormal, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, arguments_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, name_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, description_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, deterministic_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, session_dependent_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, output_type_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, implementations_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, final_variable_behavior_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, arguments_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, name_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, description_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, deterministic_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, session_dependent_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, output_type_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, ordered_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, max_set_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, intermediate_type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, implementations_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, final_variable_behavior_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, arguments_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, name_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, description_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, deterministic_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, session_dependent_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, intermediate_type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, output_type_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, ordered_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, max_set_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, window_type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, implementations_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, final_variable_behavior_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Description, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Description, language_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Description, body_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Implementation, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Implementation, type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Implementation, uri_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_ValueArgument, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_ValueArgument, type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_ValueArgument, constant_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_TypeArgument, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_TypeArgument, type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_EnumArgument, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_EnumArgument, options_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_EnumArgument, optional_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument, name_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument, argument_kind_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::io::substrait::FunctionSignature_FinalArgVariadic)}, + { 8, -1, sizeof(::io::substrait::FunctionSignature_FinalArgNormal)}, + { 13, -1, sizeof(::io::substrait::FunctionSignature_Scalar)}, + { 29, -1, sizeof(::io::substrait::FunctionSignature_Aggregate)}, + { 48, -1, sizeof(::io::substrait::FunctionSignature_Window)}, + { 68, -1, sizeof(::io::substrait::FunctionSignature_Description)}, + { 75, -1, sizeof(::io::substrait::FunctionSignature_Implementation)}, + { 82, -1, sizeof(::io::substrait::FunctionSignature_Argument_ValueArgument)}, + { 89, -1, sizeof(::io::substrait::FunctionSignature_Argument_TypeArgument)}, + { 95, -1, sizeof(::io::substrait::FunctionSignature_Argument_EnumArgument)}, + { 102, -1, sizeof(::io::substrait::FunctionSignature_Argument)}, + { 112, -1, sizeof(::io::substrait::FunctionSignature)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_FunctionSignature_FinalArgVariadic_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_FinalArgNormal_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_Scalar_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_Aggregate_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_Window_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_Description_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_Implementation_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_Argument_default_instance_), + reinterpret_cast(&::io::substrait::_FunctionSignature_default_instance_), +}; + +const char descriptor_table_protodef_function_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\016function.proto\022\014io.substrait\032\ntype.pro" + "to\032\031parameterized_types.proto\032\026type_expr" + "essions.proto\032\020extensions.proto\"\246\026\n\021Func" + "tionSignature\032\331\001\n\020FinalArgVariadic\022\020\n\010mi" + "n_args\030\001 \001(\003\022\020\n\010max_args\030\002 \001(\003\022Z\n\013consis" + "tency\030\003 \001(\0162E.io.substrait.FunctionSigna" + "ture.FinalArgVariadic.ParameterConsisten" + "cy\"E\n\024ParameterConsistency\022\013\n\007UNKNOWN\020\000\022" + "\016\n\nCONSISTENT\020\001\022\020\n\014INCONSISTENT\020\002\032\020\n\016Fin" + "alArgNormal\032\235\004\n\006Scalar\022/\n\002id\030\001 \001(\0132#.io." + "substrait.Extensions.FunctionId\022;\n\targum" + "ents\030\002 \003(\0132(.io.substrait.FunctionSignat" + "ure.Argument\022\014\n\004name\030\003 \003(\t\022@\n\013descriptio" + "n\030\004 \001(\0132+.io.substrait.FunctionSignature" + ".Description\022\025\n\rdeterministic\030\007 \001(\010\022\031\n\021s" + "ession_dependent\030\010 \001(\010\0227\n\013output_type\030\t " + "\001(\0132\".io.substrait.DerivationExpression\022" + "D\n\010variadic\030\n \001(\01320.io.substrait.Functio" + "nSignature.FinalArgVariadicH\000\022@\n\006normal\030" + "\013 \001(\0132..io.substrait.FunctionSignature.F" + "inalArgNormalH\000\022G\n\017implementations\030\014 \003(\013" + "2..io.substrait.FunctionSignature.Implem" + "entationB\031\n\027final_variable_behavior\032\361\004\n\t" + "Aggregate\022/\n\002id\030\001 \001(\0132#.io.substrait.Ext" + "ensions.FunctionId\022;\n\targuments\030\002 \003(\0132(." + "io.substrait.FunctionSignature.Argument\022" + "\014\n\004name\030\003 \003(\t\022@\n\013description\030\004 \001(\0132+.io." + "substrait.FunctionSignature.Description\022" + "\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_depend" + "ent\030\010 \001(\010\0227\n\013output_type\030\t \001(\0132\".io.subs" + "trait.DerivationExpression\022D\n\010variadic\030\n" + " \001(\01320.io.substrait.FunctionSignature.Fi" + "nalArgVariadicH\000\022@\n\006normal\030\013 \001(\0132..io.su" + "bstrait.FunctionSignature.FinalArgNormal" + "H\000\022\017\n\007ordered\030\016 \001(\010\022\017\n\007max_set\030\014 \001(\004\022-\n\021" + "intermediate_type\030\r \001(\0132\022.io.substrait.T" + "ype\022G\n\017implementations\030\017 \003(\0132..io.substr" + "ait.FunctionSignature.ImplementationB\031\n\027" + "final_variable_behavior\032\377\005\n\006Window\022/\n\002id" + "\030\001 \001(\0132#.io.substrait.Extensions.Functio" + "nId\022;\n\targuments\030\002 \003(\0132(.io.substrait.Fu" + "nctionSignature.Argument\022\014\n\004name\030\003 \003(\t\022@" + "\n\013description\030\004 \001(\0132+.io.substrait.Funct" + "ionSignature.Description\022\025\n\rdeterministi" + "c\030\007 \001(\010\022\031\n\021session_dependent\030\010 \001(\010\022=\n\021in" + "termediate_type\030\t \001(\0132\".io.substrait.Der" + "ivationExpression\0227\n\013output_type\030\n \001(\0132\"" + ".io.substrait.DerivationExpression\022D\n\010va" + "riadic\030\020 \001(\01320.io.substrait.FunctionSign" + "ature.FinalArgVariadicH\000\022@\n\006normal\030\021 \001(\013" + "2..io.substrait.FunctionSignature.FinalA" + "rgNormalH\000\022\017\n\007ordered\030\013 \001(\010\022\017\n\007max_set\030\014" + " \001(\004\022F\n\013window_type\030\016 \001(\01621.io.substrait" + ".FunctionSignature.Window.WindowType\022G\n\017" + "implementations\030\017 \003(\0132..io.substrait.Fun" + "ctionSignature.Implementation\"7\n\nWindowT" + "ype\022\013\n\007UNKNOWN\020\000\022\r\n\tSTREAMING\020\001\022\r\n\tPARTI" + "TION\020\002B\031\n\027final_variable_behavior\032-\n\013Des" + "cription\022\020\n\010language\030\001 \001(\t\022\014\n\004body\030\002 \001(\t" + "\032\226\001\n\016Implementation\022A\n\004type\030\001 \001(\01623.io.s" + "ubstrait.FunctionSignature.Implementatio" + "n.Type\022\013\n\003uri\030\002 \001(\t\"4\n\004Type\022\013\n\007UNKNOWN\020\000" + "\022\020\n\014WEB_ASSEMBLY\020\001\022\r\n\tTRINO_JAR\020\002\032\304\003\n\010Ar" + "gument\022\014\n\004name\030\001 \001(\t\022G\n\005value\030\002 \001(\01326.io" + ".substrait.FunctionSignature.Argument.Va" + "lueArgumentH\000\022E\n\004type\030\003 \001(\01325.io.substra" + "it.FunctionSignature.Argument.TypeArgume" + "ntH\000\022E\n\004enum\030\004 \001(\01325.io.substrait.Functi" + "onSignature.Argument.EnumArgumentH\000\032P\n\rV" + "alueArgument\022-\n\004type\030\001 \001(\0132\037.io.substrai" + "t.ParameterizedType\022\020\n\010constant\030\002 \001(\010\032=\n" + "\014TypeArgument\022-\n\004type\030\001 \001(\0132\037.io.substra" + "it.ParameterizedType\0321\n\014EnumArgument\022\017\n\007" + "options\030\001 \003(\t\022\020\n\010optional\030\002 \001(\010B\017\n\rargum" + "ent_kindB\027P\001\252\002\022Substrait.Protobufb\006proto" + "3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_function_2eproto_deps[4] = { + &::descriptor_table_extensions_2eproto, + &::descriptor_table_parameterized_5ftypes_2eproto, + &::descriptor_table_type_2eproto, + &::descriptor_table_type_5fexpressions_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_function_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_function_2eproto = { + false, false, 3001, descriptor_table_protodef_function_2eproto, "function.proto", + &descriptor_table_function_2eproto_once, descriptor_table_function_2eproto_deps, 4, 12, + schemas, file_default_instances, TableStruct_function_2eproto::offsets, + file_level_metadata_function_2eproto, file_level_enum_descriptors_function_2eproto, file_level_service_descriptors_function_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_function_2eproto_getter() { + return &descriptor_table_function_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_function_2eproto(&descriptor_table_function_2eproto); +namespace io { +namespace substrait { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_function_2eproto); + return file_level_enum_descriptors_function_2eproto[0]; +} +bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::UNKNOWN; +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::CONSISTENT; +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::INCONSISTENT; +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MIN; +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MAX; +constexpr int FunctionSignature_FinalArgVariadic::ParameterConsistency_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_function_2eproto); + return file_level_enum_descriptors_function_2eproto[1]; +} +bool FunctionSignature_Window_WindowType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::UNKNOWN; +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::STREAMING; +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::PARTITION; +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MIN; +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MAX; +constexpr int FunctionSignature_Window::WindowType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_function_2eproto); + return file_level_enum_descriptors_function_2eproto[2]; +} +bool FunctionSignature_Implementation_Type_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::UNKNOWN; +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::WEB_ASSEMBLY; +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TRINO_JAR; +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MIN; +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MAX; +constexpr int FunctionSignature_Implementation::Type_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) + +// =================================================================== + +class FunctionSignature_FinalArgVariadic::_Internal { + public: +}; + +FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.FinalArgVariadic) +} +FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(const FunctionSignature_FinalArgVariadic& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&min_args_, &from.min_args_, + static_cast(reinterpret_cast(&consistency_) - + reinterpret_cast(&min_args_)) + sizeof(consistency_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.FinalArgVariadic) +} + +void FunctionSignature_FinalArgVariadic::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&min_args_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&consistency_) - + reinterpret_cast(&min_args_)) + sizeof(consistency_)); +} + +FunctionSignature_FinalArgVariadic::~FunctionSignature_FinalArgVariadic() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.FinalArgVariadic) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_FinalArgVariadic::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void FunctionSignature_FinalArgVariadic::ArenaDtor(void* object) { + FunctionSignature_FinalArgVariadic* _this = reinterpret_cast< FunctionSignature_FinalArgVariadic* >(object); + (void)_this; +} +void FunctionSignature_FinalArgVariadic::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_FinalArgVariadic::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_FinalArgVariadic::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.FinalArgVariadic) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&min_args_, 0, static_cast( + reinterpret_cast(&consistency_) - + reinterpret_cast(&min_args_)) + sizeof(consistency_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_FinalArgVariadic::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int64 min_args = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + min_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 max_args = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + max_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_consistency(static_cast<::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_FinalArgVariadic::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.FinalArgVariadic) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 min_args = 1; + if (this->min_args() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_min_args(), target); + } + + // int64 max_args = 2; + if (this->max_args() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_max_args(), target); + } + + // .io.substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; + if (this->consistency() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_consistency(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.FinalArgVariadic) + return target; +} + +size_t FunctionSignature_FinalArgVariadic::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.FinalArgVariadic) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 min_args = 1; + if (this->min_args() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_min_args()); + } + + // int64 max_args = 2; + if (this->max_args() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_max_args()); + } + + // .io.substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; + if (this->consistency() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_consistency()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_FinalArgVariadic::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.FinalArgVariadic) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_FinalArgVariadic* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.FinalArgVariadic) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.FinalArgVariadic) + MergeFrom(*source); + } +} + +void FunctionSignature_FinalArgVariadic::MergeFrom(const FunctionSignature_FinalArgVariadic& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.FinalArgVariadic) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.min_args() != 0) { + _internal_set_min_args(from._internal_min_args()); + } + if (from.max_args() != 0) { + _internal_set_max_args(from._internal_max_args()); + } + if (from.consistency() != 0) { + _internal_set_consistency(from._internal_consistency()); + } +} + +void FunctionSignature_FinalArgVariadic::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.FinalArgVariadic) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_FinalArgVariadic::CopyFrom(const FunctionSignature_FinalArgVariadic& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.FinalArgVariadic) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_FinalArgVariadic::IsInitialized() const { + return true; +} + +void FunctionSignature_FinalArgVariadic::InternalSwap(FunctionSignature_FinalArgVariadic* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FunctionSignature_FinalArgVariadic, consistency_) + + sizeof(FunctionSignature_FinalArgVariadic::consistency_) + - PROTOBUF_FIELD_OFFSET(FunctionSignature_FinalArgVariadic, min_args_)>( + reinterpret_cast(&min_args_), + reinterpret_cast(&other->min_args_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgVariadic::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[0]); +} + +// =================================================================== + +class FunctionSignature_FinalArgNormal::_Internal { + public: +}; + +FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.FinalArgNormal) +} +FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(const FunctionSignature_FinalArgNormal& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.FinalArgNormal) +} + +void FunctionSignature_FinalArgNormal::SharedCtor() { +} + +FunctionSignature_FinalArgNormal::~FunctionSignature_FinalArgNormal() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.FinalArgNormal) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_FinalArgNormal::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void FunctionSignature_FinalArgNormal::ArenaDtor(void* object) { + FunctionSignature_FinalArgNormal* _this = reinterpret_cast< FunctionSignature_FinalArgNormal* >(object); + (void)_this; +} +void FunctionSignature_FinalArgNormal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_FinalArgNormal::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_FinalArgNormal::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.FinalArgNormal) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_FinalArgNormal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_FinalArgNormal::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.FinalArgNormal) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.FinalArgNormal) + return target; +} + +size_t FunctionSignature_FinalArgNormal::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.FinalArgNormal) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_FinalArgNormal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.FinalArgNormal) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_FinalArgNormal* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.FinalArgNormal) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.FinalArgNormal) + MergeFrom(*source); + } +} + +void FunctionSignature_FinalArgNormal::MergeFrom(const FunctionSignature_FinalArgNormal& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.FinalArgNormal) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +void FunctionSignature_FinalArgNormal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.FinalArgNormal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_FinalArgNormal::CopyFrom(const FunctionSignature_FinalArgNormal& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.FinalArgNormal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_FinalArgNormal::IsInitialized() const { + return true; +} + +void FunctionSignature_FinalArgNormal::InternalSwap(FunctionSignature_FinalArgNormal* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgNormal::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[1]); +} + +// =================================================================== + +class FunctionSignature_Scalar::_Internal { + public: + static const ::io::substrait::Extensions_FunctionId& id(const FunctionSignature_Scalar* msg); + static const ::io::substrait::FunctionSignature_Description& description(const FunctionSignature_Scalar* msg); + static const ::io::substrait::DerivationExpression& output_type(const FunctionSignature_Scalar* msg); + static const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Scalar* msg); + static const ::io::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Scalar* msg); +}; + +const ::io::substrait::Extensions_FunctionId& +FunctionSignature_Scalar::_Internal::id(const FunctionSignature_Scalar* msg) { + return *msg->id_; +} +const ::io::substrait::FunctionSignature_Description& +FunctionSignature_Scalar::_Internal::description(const FunctionSignature_Scalar* msg) { + return *msg->description_; +} +const ::io::substrait::DerivationExpression& +FunctionSignature_Scalar::_Internal::output_type(const FunctionSignature_Scalar* msg) { + return *msg->output_type_; +} +const ::io::substrait::FunctionSignature_FinalArgVariadic& +FunctionSignature_Scalar::_Internal::variadic(const FunctionSignature_Scalar* msg) { + return *msg->final_variable_behavior_.variadic_; +} +const ::io::substrait::FunctionSignature_FinalArgNormal& +FunctionSignature_Scalar::_Internal::normal(const FunctionSignature_Scalar* msg) { + return *msg->final_variable_behavior_.normal_; +} +void FunctionSignature_Scalar::clear_id() { + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; +} +void FunctionSignature_Scalar::clear_output_type() { + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; +} +void FunctionSignature_Scalar::set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_final_variable_behavior(); + if (variadic) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variadic); + if (message_arena != submessage_arena) { + variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variadic, submessage_arena); + } + set_has_variadic(); + final_variable_behavior_.variadic_ = variadic; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Scalar.variadic) +} +void FunctionSignature_Scalar::set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_final_variable_behavior(); + if (normal) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(normal); + if (message_arena != submessage_arena) { + normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, normal, submessage_arena); + } + set_has_normal(); + final_variable_behavior_.normal_ = normal; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Scalar.normal) +} +FunctionSignature_Scalar::FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + arguments_(arena), + name_(arena), + implementations_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Scalar) +} +FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scalar& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + arguments_(from.arguments_), + name_(from.name_), + implementations_(from.implementations_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_id()) { + id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); + } else { + id_ = nullptr; + } + if (from._internal_has_description()) { + description_ = new ::io::substrait::FunctionSignature_Description(*from.description_); + } else { + description_ = nullptr; + } + if (from._internal_has_output_type()) { + output_type_ = new ::io::substrait::DerivationExpression(*from.output_type_); + } else { + output_type_ = nullptr; + } + ::memcpy(&deterministic_, &from.deterministic_, + static_cast(reinterpret_cast(&session_dependent_) - + reinterpret_cast(&deterministic_)) + sizeof(session_dependent_)); + clear_has_final_variable_behavior(); + switch (from.final_variable_behavior_case()) { + case kVariadic: { + _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + break; + } + case kNormal: { + _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Scalar) +} + +void FunctionSignature_Scalar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&session_dependent_) - + reinterpret_cast(&id_)) + sizeof(session_dependent_)); +clear_has_final_variable_behavior(); +} + +FunctionSignature_Scalar::~FunctionSignature_Scalar() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Scalar) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_Scalar::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete id_; + if (this != internal_default_instance()) delete description_; + if (this != internal_default_instance()) delete output_type_; + if (has_final_variable_behavior()) { + clear_final_variable_behavior(); + } +} + +void FunctionSignature_Scalar::ArenaDtor(void* object) { + FunctionSignature_Scalar* _this = reinterpret_cast< FunctionSignature_Scalar* >(object); + (void)_this; +} +void FunctionSignature_Scalar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_Scalar::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_Scalar::clear_final_variable_behavior() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.FunctionSignature.Scalar) + switch (final_variable_behavior_case()) { + case kVariadic: { + if (GetArena() == nullptr) { + delete final_variable_behavior_.variadic_; + } + break; + } + case kNormal: { + if (GetArena() == nullptr) { + delete final_variable_behavior_.normal_; + } + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } + _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; +} + + +void FunctionSignature_Scalar::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Scalar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + arguments_.Clear(); + name_.Clear(); + implementations_.Clear(); + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; + if (GetArena() == nullptr && description_ != nullptr) { + delete description_; + } + description_ = nullptr; + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; + ::memset(&deterministic_, 0, static_cast( + reinterpret_cast(&session_dependent_) - + reinterpret_cast(&deterministic_)) + sizeof(session_dependent_)); + clear_final_variable_behavior(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Extensions.FunctionId id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_arguments(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // repeated string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Scalar.name")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.Description description = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool deterministic = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool session_dependent = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression output_type = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.FunctionSignature.Implementation implementations = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_implementations(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Scalar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::id(this), target, stream); + } + + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_arguments_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_arguments(i), target, stream); + } + + // repeated string name = 3; + for (int i = 0, n = this->_internal_name_size(); i < n; i++) { + const auto& s = this->_internal_name(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.FunctionSignature.Scalar.name"); + target = stream->WriteString(3, s, target); + } + + // .io.substrait.FunctionSignature.Description description = 4; + if (this->has_description()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::description(this), target, stream); + } + + // bool deterministic = 7; + if (this->deterministic() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target); + } + + // bool session_dependent = 8; + if (this->session_dependent() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); + } + + // .io.substrait.DerivationExpression output_type = 9; + if (this->has_output_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::output_type(this), target, stream); + } + + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + if (_internal_has_variadic()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::variadic(this), target, stream); + } + + // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + if (_internal_has_normal()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::normal(this), target, stream); + } + + // repeated .io.substrait.FunctionSignature.Implementation implementations = 12; + for (unsigned int i = 0, + n = static_cast(this->_internal_implementations_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(12, this->_internal_implementations(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Scalar) + return target; +} + +size_t FunctionSignature_Scalar::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Scalar) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + total_size += 1UL * this->_internal_arguments_size(); + for (const auto& msg : this->arguments_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated string name = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(name_.size()); + for (int i = 0, n = name_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + name_.Get(i)); + } + + // repeated .io.substrait.FunctionSignature.Implementation implementations = 12; + total_size += 1UL * this->_internal_implementations_size(); + for (const auto& msg : this->implementations_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *id_); + } + + // .io.substrait.FunctionSignature.Description description = 4; + if (this->has_description()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *description_); + } + + // .io.substrait.DerivationExpression output_type = 9; + if (this->has_output_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *output_type_); + } + + // bool deterministic = 7; + if (this->deterministic() != 0) { + total_size += 1 + 1; + } + + // bool session_dependent = 8; + if (this->session_dependent() != 0) { + total_size += 1 + 1; + } + + switch (final_variable_behavior_case()) { + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + case kVariadic: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *final_variable_behavior_.variadic_); + break; + } + // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + case kNormal: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *final_variable_behavior_.normal_); + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_Scalar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Scalar) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_Scalar* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Scalar) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Scalar) + MergeFrom(*source); + } +} + +void FunctionSignature_Scalar::MergeFrom(const FunctionSignature_Scalar& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Scalar) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + arguments_.MergeFrom(from.arguments_); + name_.MergeFrom(from.name_); + implementations_.MergeFrom(from.implementations_); + if (from.has_id()) { + _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); + } + if (from.has_description()) { + _internal_mutable_description()->::io::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); + } + if (from.has_output_type()) { + _internal_mutable_output_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); + } + if (from.deterministic() != 0) { + _internal_set_deterministic(from._internal_deterministic()); + } + if (from.session_dependent() != 0) { + _internal_set_session_dependent(from._internal_session_dependent()); + } + switch (from.final_variable_behavior_case()) { + case kVariadic: { + _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + break; + } + case kNormal: { + _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } +} + +void FunctionSignature_Scalar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Scalar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_Scalar::CopyFrom(const FunctionSignature_Scalar& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Scalar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_Scalar::IsInitialized() const { + return true; +} + +void FunctionSignature_Scalar::InternalSwap(FunctionSignature_Scalar* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + arguments_.InternalSwap(&other->arguments_); + name_.InternalSwap(&other->name_); + implementations_.InternalSwap(&other->implementations_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, session_dependent_) + + sizeof(FunctionSignature_Scalar::session_dependent_) + - PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, id_)>( + reinterpret_cast(&id_), + reinterpret_cast(&other->id_)); + swap(final_variable_behavior_, other->final_variable_behavior_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Scalar::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[2]); +} + +// =================================================================== + +class FunctionSignature_Aggregate::_Internal { + public: + static const ::io::substrait::Extensions_FunctionId& id(const FunctionSignature_Aggregate* msg); + static const ::io::substrait::FunctionSignature_Description& description(const FunctionSignature_Aggregate* msg); + static const ::io::substrait::DerivationExpression& output_type(const FunctionSignature_Aggregate* msg); + static const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Aggregate* msg); + static const ::io::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Aggregate* msg); + static const ::io::substrait::Type& intermediate_type(const FunctionSignature_Aggregate* msg); +}; + +const ::io::substrait::Extensions_FunctionId& +FunctionSignature_Aggregate::_Internal::id(const FunctionSignature_Aggregate* msg) { + return *msg->id_; +} +const ::io::substrait::FunctionSignature_Description& +FunctionSignature_Aggregate::_Internal::description(const FunctionSignature_Aggregate* msg) { + return *msg->description_; +} +const ::io::substrait::DerivationExpression& +FunctionSignature_Aggregate::_Internal::output_type(const FunctionSignature_Aggregate* msg) { + return *msg->output_type_; +} +const ::io::substrait::FunctionSignature_FinalArgVariadic& +FunctionSignature_Aggregate::_Internal::variadic(const FunctionSignature_Aggregate* msg) { + return *msg->final_variable_behavior_.variadic_; +} +const ::io::substrait::FunctionSignature_FinalArgNormal& +FunctionSignature_Aggregate::_Internal::normal(const FunctionSignature_Aggregate* msg) { + return *msg->final_variable_behavior_.normal_; +} +const ::io::substrait::Type& +FunctionSignature_Aggregate::_Internal::intermediate_type(const FunctionSignature_Aggregate* msg) { + return *msg->intermediate_type_; +} +void FunctionSignature_Aggregate::clear_id() { + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; +} +void FunctionSignature_Aggregate::clear_output_type() { + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; +} +void FunctionSignature_Aggregate::set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_final_variable_behavior(); + if (variadic) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variadic); + if (message_arena != submessage_arena) { + variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variadic, submessage_arena); + } + set_has_variadic(); + final_variable_behavior_.variadic_ = variadic; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.variadic) +} +void FunctionSignature_Aggregate::set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_final_variable_behavior(); + if (normal) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(normal); + if (message_arena != submessage_arena) { + normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, normal, submessage_arena); + } + set_has_normal(); + final_variable_behavior_.normal_ = normal; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.normal) +} +void FunctionSignature_Aggregate::clear_intermediate_type() { + if (GetArena() == nullptr && intermediate_type_ != nullptr) { + delete intermediate_type_; + } + intermediate_type_ = nullptr; +} +FunctionSignature_Aggregate::FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + arguments_(arena), + name_(arena), + implementations_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Aggregate) +} +FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + arguments_(from.arguments_), + name_(from.name_), + implementations_(from.implementations_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_id()) { + id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); + } else { + id_ = nullptr; + } + if (from._internal_has_description()) { + description_ = new ::io::substrait::FunctionSignature_Description(*from.description_); + } else { + description_ = nullptr; + } + if (from._internal_has_output_type()) { + output_type_ = new ::io::substrait::DerivationExpression(*from.output_type_); + } else { + output_type_ = nullptr; + } + if (from._internal_has_intermediate_type()) { + intermediate_type_ = new ::io::substrait::Type(*from.intermediate_type_); + } else { + intermediate_type_ = nullptr; + } + ::memcpy(&max_set_, &from.max_set_, + static_cast(reinterpret_cast(&ordered_) - + reinterpret_cast(&max_set_)) + sizeof(ordered_)); + clear_has_final_variable_behavior(); + switch (from.final_variable_behavior_case()) { + case kVariadic: { + _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + break; + } + case kNormal: { + _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Aggregate) +} + +void FunctionSignature_Aggregate::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&ordered_) - + reinterpret_cast(&id_)) + sizeof(ordered_)); +clear_has_final_variable_behavior(); +} + +FunctionSignature_Aggregate::~FunctionSignature_Aggregate() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Aggregate) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_Aggregate::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete id_; + if (this != internal_default_instance()) delete description_; + if (this != internal_default_instance()) delete output_type_; + if (this != internal_default_instance()) delete intermediate_type_; + if (has_final_variable_behavior()) { + clear_final_variable_behavior(); + } +} + +void FunctionSignature_Aggregate::ArenaDtor(void* object) { + FunctionSignature_Aggregate* _this = reinterpret_cast< FunctionSignature_Aggregate* >(object); + (void)_this; +} +void FunctionSignature_Aggregate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_Aggregate::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_Aggregate::clear_final_variable_behavior() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.FunctionSignature.Aggregate) + switch (final_variable_behavior_case()) { + case kVariadic: { + if (GetArena() == nullptr) { + delete final_variable_behavior_.variadic_; + } + break; + } + case kNormal: { + if (GetArena() == nullptr) { + delete final_variable_behavior_.normal_; + } + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } + _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; +} + + +void FunctionSignature_Aggregate::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Aggregate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + arguments_.Clear(); + name_.Clear(); + implementations_.Clear(); + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; + if (GetArena() == nullptr && description_ != nullptr) { + delete description_; + } + description_ = nullptr; + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; + if (GetArena() == nullptr && intermediate_type_ != nullptr) { + delete intermediate_type_; + } + intermediate_type_ = nullptr; + ::memset(&max_set_, 0, static_cast( + reinterpret_cast(&ordered_) - + reinterpret_cast(&max_set_)) + sizeof(ordered_)); + clear_final_variable_behavior(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Extensions.FunctionId id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_arguments(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // repeated string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Aggregate.name")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.Description description = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool deterministic = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool session_dependent = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression output_type = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 max_set = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) { + max_set_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type intermediate_type = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool ordered = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) { + ordered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_implementations(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Aggregate) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::id(this), target, stream); + } + + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_arguments_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_arguments(i), target, stream); + } + + // repeated string name = 3; + for (int i = 0, n = this->_internal_name_size(); i < n; i++) { + const auto& s = this->_internal_name(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.FunctionSignature.Aggregate.name"); + target = stream->WriteString(3, s, target); + } + + // .io.substrait.FunctionSignature.Description description = 4; + if (this->has_description()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::description(this), target, stream); + } + + // bool deterministic = 7; + if (this->deterministic() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target); + } + + // bool session_dependent = 8; + if (this->session_dependent() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); + } + + // .io.substrait.DerivationExpression output_type = 9; + if (this->has_output_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::output_type(this), target, stream); + } + + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + if (_internal_has_variadic()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::variadic(this), target, stream); + } + + // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + if (_internal_has_normal()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::normal(this), target, stream); + } + + // uint64 max_set = 12; + if (this->max_set() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target); + } + + // .io.substrait.Type intermediate_type = 13; + if (this->has_intermediate_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 13, _Internal::intermediate_type(this), target, stream); + } + + // bool ordered = 14; + if (this->ordered() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(14, this->_internal_ordered(), target); + } + + // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + for (unsigned int i = 0, + n = static_cast(this->_internal_implementations_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(15, this->_internal_implementations(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Aggregate) + return target; +} + +size_t FunctionSignature_Aggregate::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Aggregate) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + total_size += 1UL * this->_internal_arguments_size(); + for (const auto& msg : this->arguments_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated string name = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(name_.size()); + for (int i = 0, n = name_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + name_.Get(i)); + } + + // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + total_size += 1UL * this->_internal_implementations_size(); + for (const auto& msg : this->implementations_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *id_); + } + + // .io.substrait.FunctionSignature.Description description = 4; + if (this->has_description()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *description_); + } + + // .io.substrait.DerivationExpression output_type = 9; + if (this->has_output_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *output_type_); + } + + // .io.substrait.Type intermediate_type = 13; + if (this->has_intermediate_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *intermediate_type_); + } + + // uint64 max_set = 12; + if (this->max_set() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_max_set()); + } + + // bool deterministic = 7; + if (this->deterministic() != 0) { + total_size += 1 + 1; + } + + // bool session_dependent = 8; + if (this->session_dependent() != 0) { + total_size += 1 + 1; + } + + // bool ordered = 14; + if (this->ordered() != 0) { + total_size += 1 + 1; + } + + switch (final_variable_behavior_case()) { + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + case kVariadic: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *final_variable_behavior_.variadic_); + break; + } + // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + case kNormal: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *final_variable_behavior_.normal_); + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_Aggregate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Aggregate) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_Aggregate* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Aggregate) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Aggregate) + MergeFrom(*source); + } +} + +void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Aggregate) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + arguments_.MergeFrom(from.arguments_); + name_.MergeFrom(from.name_); + implementations_.MergeFrom(from.implementations_); + if (from.has_id()) { + _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); + } + if (from.has_description()) { + _internal_mutable_description()->::io::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); + } + if (from.has_output_type()) { + _internal_mutable_output_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); + } + if (from.has_intermediate_type()) { + _internal_mutable_intermediate_type()->::io::substrait::Type::MergeFrom(from._internal_intermediate_type()); + } + if (from.max_set() != 0) { + _internal_set_max_set(from._internal_max_set()); + } + if (from.deterministic() != 0) { + _internal_set_deterministic(from._internal_deterministic()); + } + if (from.session_dependent() != 0) { + _internal_set_session_dependent(from._internal_session_dependent()); + } + if (from.ordered() != 0) { + _internal_set_ordered(from._internal_ordered()); + } + switch (from.final_variable_behavior_case()) { + case kVariadic: { + _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + break; + } + case kNormal: { + _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } +} + +void FunctionSignature_Aggregate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Aggregate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_Aggregate::CopyFrom(const FunctionSignature_Aggregate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Aggregate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_Aggregate::IsInitialized() const { + return true; +} + +void FunctionSignature_Aggregate::InternalSwap(FunctionSignature_Aggregate* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + arguments_.InternalSwap(&other->arguments_); + name_.InternalSwap(&other->name_); + implementations_.InternalSwap(&other->implementations_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, ordered_) + + sizeof(FunctionSignature_Aggregate::ordered_) + - PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, id_)>( + reinterpret_cast(&id_), + reinterpret_cast(&other->id_)); + swap(final_variable_behavior_, other->final_variable_behavior_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Aggregate::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[3]); +} + +// =================================================================== + +class FunctionSignature_Window::_Internal { + public: + static const ::io::substrait::Extensions_FunctionId& id(const FunctionSignature_Window* msg); + static const ::io::substrait::FunctionSignature_Description& description(const FunctionSignature_Window* msg); + static const ::io::substrait::DerivationExpression& intermediate_type(const FunctionSignature_Window* msg); + static const ::io::substrait::DerivationExpression& output_type(const FunctionSignature_Window* msg); + static const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Window* msg); + static const ::io::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Window* msg); +}; + +const ::io::substrait::Extensions_FunctionId& +FunctionSignature_Window::_Internal::id(const FunctionSignature_Window* msg) { + return *msg->id_; +} +const ::io::substrait::FunctionSignature_Description& +FunctionSignature_Window::_Internal::description(const FunctionSignature_Window* msg) { + return *msg->description_; +} +const ::io::substrait::DerivationExpression& +FunctionSignature_Window::_Internal::intermediate_type(const FunctionSignature_Window* msg) { + return *msg->intermediate_type_; +} +const ::io::substrait::DerivationExpression& +FunctionSignature_Window::_Internal::output_type(const FunctionSignature_Window* msg) { + return *msg->output_type_; +} +const ::io::substrait::FunctionSignature_FinalArgVariadic& +FunctionSignature_Window::_Internal::variadic(const FunctionSignature_Window* msg) { + return *msg->final_variable_behavior_.variadic_; +} +const ::io::substrait::FunctionSignature_FinalArgNormal& +FunctionSignature_Window::_Internal::normal(const FunctionSignature_Window* msg) { + return *msg->final_variable_behavior_.normal_; +} +void FunctionSignature_Window::clear_id() { + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; +} +void FunctionSignature_Window::clear_intermediate_type() { + if (GetArena() == nullptr && intermediate_type_ != nullptr) { + delete intermediate_type_; + } + intermediate_type_ = nullptr; +} +void FunctionSignature_Window::clear_output_type() { + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; +} +void FunctionSignature_Window::set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_final_variable_behavior(); + if (variadic) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variadic); + if (message_arena != submessage_arena) { + variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variadic, submessage_arena); + } + set_has_variadic(); + final_variable_behavior_.variadic_ = variadic; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.variadic) +} +void FunctionSignature_Window::set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_final_variable_behavior(); + if (normal) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(normal); + if (message_arena != submessage_arena) { + normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, normal, submessage_arena); + } + set_has_normal(); + final_variable_behavior_.normal_ = normal; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.normal) +} +FunctionSignature_Window::FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + arguments_(arena), + name_(arena), + implementations_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Window) +} +FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Window& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + arguments_(from.arguments_), + name_(from.name_), + implementations_(from.implementations_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_id()) { + id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); + } else { + id_ = nullptr; + } + if (from._internal_has_description()) { + description_ = new ::io::substrait::FunctionSignature_Description(*from.description_); + } else { + description_ = nullptr; + } + if (from._internal_has_intermediate_type()) { + intermediate_type_ = new ::io::substrait::DerivationExpression(*from.intermediate_type_); + } else { + intermediate_type_ = nullptr; + } + if (from._internal_has_output_type()) { + output_type_ = new ::io::substrait::DerivationExpression(*from.output_type_); + } else { + output_type_ = nullptr; + } + ::memcpy(&deterministic_, &from.deterministic_, + static_cast(reinterpret_cast(&max_set_) - + reinterpret_cast(&deterministic_)) + sizeof(max_set_)); + clear_has_final_variable_behavior(); + switch (from.final_variable_behavior_case()) { + case kVariadic: { + _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + break; + } + case kNormal: { + _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Window) +} + +void FunctionSignature_Window::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&id_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&max_set_) - + reinterpret_cast(&id_)) + sizeof(max_set_)); +clear_has_final_variable_behavior(); +} + +FunctionSignature_Window::~FunctionSignature_Window() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Window) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_Window::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete id_; + if (this != internal_default_instance()) delete description_; + if (this != internal_default_instance()) delete intermediate_type_; + if (this != internal_default_instance()) delete output_type_; + if (has_final_variable_behavior()) { + clear_final_variable_behavior(); + } +} + +void FunctionSignature_Window::ArenaDtor(void* object) { + FunctionSignature_Window* _this = reinterpret_cast< FunctionSignature_Window* >(object); + (void)_this; +} +void FunctionSignature_Window::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_Window::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_Window::clear_final_variable_behavior() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.FunctionSignature.Window) + switch (final_variable_behavior_case()) { + case kVariadic: { + if (GetArena() == nullptr) { + delete final_variable_behavior_.variadic_; + } + break; + } + case kNormal: { + if (GetArena() == nullptr) { + delete final_variable_behavior_.normal_; + } + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } + _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; +} + + +void FunctionSignature_Window::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Window) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + arguments_.Clear(); + name_.Clear(); + implementations_.Clear(); + if (GetArena() == nullptr && id_ != nullptr) { + delete id_; + } + id_ = nullptr; + if (GetArena() == nullptr && description_ != nullptr) { + delete description_; + } + description_ = nullptr; + if (GetArena() == nullptr && intermediate_type_ != nullptr) { + delete intermediate_type_; + } + intermediate_type_ = nullptr; + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; + ::memset(&deterministic_, 0, static_cast( + reinterpret_cast(&max_set_) - + reinterpret_cast(&deterministic_)) + sizeof(max_set_)); + clear_final_variable_behavior(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Extensions.FunctionId id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_arguments(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // repeated string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Window.name")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.Description description = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool deterministic = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool session_dependent = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression intermediate_type = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression output_type = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool ordered = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) { + ordered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 max_set = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) { + max_set_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.Window.WindowType window_type = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_window_type(static_cast<::io::substrait::FunctionSignature_Window_WindowType>(val)); + } else goto handle_unusual; + continue; + // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + case 15: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_implementations(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.FinalArgNormal normal = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Window) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::id(this), target, stream); + } + + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_arguments_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_arguments(i), target, stream); + } + + // repeated string name = 3; + for (int i = 0, n = this->_internal_name_size(); i < n; i++) { + const auto& s = this->_internal_name(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.FunctionSignature.Window.name"); + target = stream->WriteString(3, s, target); + } + + // .io.substrait.FunctionSignature.Description description = 4; + if (this->has_description()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::description(this), target, stream); + } + + // bool deterministic = 7; + if (this->deterministic() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target); + } + + // bool session_dependent = 8; + if (this->session_dependent() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); + } + + // .io.substrait.DerivationExpression intermediate_type = 9; + if (this->has_intermediate_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::intermediate_type(this), target, stream); + } + + // .io.substrait.DerivationExpression output_type = 10; + if (this->has_output_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::output_type(this), target, stream); + } + + // bool ordered = 11; + if (this->ordered() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(11, this->_internal_ordered(), target); + } + + // uint64 max_set = 12; + if (this->max_set() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target); + } + + // .io.substrait.FunctionSignature.Window.WindowType window_type = 14; + if (this->window_type() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 14, this->_internal_window_type(), target); + } + + // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + for (unsigned int i = 0, + n = static_cast(this->_internal_implementations_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(15, this->_internal_implementations(i), target, stream); + } + + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 16; + if (_internal_has_variadic()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 16, _Internal::variadic(this), target, stream); + } + + // .io.substrait.FunctionSignature.FinalArgNormal normal = 17; + if (_internal_has_normal()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 17, _Internal::normal(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Window) + return target; +} + +size_t FunctionSignature_Window::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Window) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + total_size += 1UL * this->_internal_arguments_size(); + for (const auto& msg : this->arguments_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated string name = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(name_.size()); + for (int i = 0, n = name_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + name_.Get(i)); + } + + // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + total_size += 1UL * this->_internal_implementations_size(); + for (const auto& msg : this->implementations_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Extensions.FunctionId id = 1; + if (this->has_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *id_); + } + + // .io.substrait.FunctionSignature.Description description = 4; + if (this->has_description()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *description_); + } + + // .io.substrait.DerivationExpression intermediate_type = 9; + if (this->has_intermediate_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *intermediate_type_); + } + + // .io.substrait.DerivationExpression output_type = 10; + if (this->has_output_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *output_type_); + } + + // bool deterministic = 7; + if (this->deterministic() != 0) { + total_size += 1 + 1; + } + + // bool session_dependent = 8; + if (this->session_dependent() != 0) { + total_size += 1 + 1; + } + + // bool ordered = 11; + if (this->ordered() != 0) { + total_size += 1 + 1; + } + + // .io.substrait.FunctionSignature.Window.WindowType window_type = 14; + if (this->window_type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_window_type()); + } + + // uint64 max_set = 12; + if (this->max_set() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_max_set()); + } + + switch (final_variable_behavior_case()) { + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 16; + case kVariadic: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *final_variable_behavior_.variadic_); + break; + } + // .io.substrait.FunctionSignature.FinalArgNormal normal = 17; + case kNormal: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *final_variable_behavior_.normal_); + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_Window::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Window) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_Window* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Window) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Window) + MergeFrom(*source); + } +} + +void FunctionSignature_Window::MergeFrom(const FunctionSignature_Window& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Window) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + arguments_.MergeFrom(from.arguments_); + name_.MergeFrom(from.name_); + implementations_.MergeFrom(from.implementations_); + if (from.has_id()) { + _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); + } + if (from.has_description()) { + _internal_mutable_description()->::io::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); + } + if (from.has_intermediate_type()) { + _internal_mutable_intermediate_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_intermediate_type()); + } + if (from.has_output_type()) { + _internal_mutable_output_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); + } + if (from.deterministic() != 0) { + _internal_set_deterministic(from._internal_deterministic()); + } + if (from.session_dependent() != 0) { + _internal_set_session_dependent(from._internal_session_dependent()); + } + if (from.ordered() != 0) { + _internal_set_ordered(from._internal_ordered()); + } + if (from.window_type() != 0) { + _internal_set_window_type(from._internal_window_type()); + } + if (from.max_set() != 0) { + _internal_set_max_set(from._internal_max_set()); + } + switch (from.final_variable_behavior_case()) { + case kVariadic: { + _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + break; + } + case kNormal: { + _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + break; + } + case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { + break; + } + } +} + +void FunctionSignature_Window::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Window) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_Window::CopyFrom(const FunctionSignature_Window& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Window) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_Window::IsInitialized() const { + return true; +} + +void FunctionSignature_Window::InternalSwap(FunctionSignature_Window* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + arguments_.InternalSwap(&other->arguments_); + name_.InternalSwap(&other->name_); + implementations_.InternalSwap(&other->implementations_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, max_set_) + + sizeof(FunctionSignature_Window::max_set_) + - PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, id_)>( + reinterpret_cast(&id_), + reinterpret_cast(&other->id_)); + swap(final_variable_behavior_, other->final_variable_behavior_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Window::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[4]); +} + +// =================================================================== + +class FunctionSignature_Description::_Internal { + public: +}; + +FunctionSignature_Description::FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Description) +} +FunctionSignature_Description::FunctionSignature_Description(const FunctionSignature_Description& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + language_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_language().empty()) { + language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_language(), + GetArena()); + } + body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_body().empty()) { + body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_body(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Description) +} + +void FunctionSignature_Description::SharedCtor() { +language_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +FunctionSignature_Description::~FunctionSignature_Description() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Description) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_Description::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + language_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + body_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void FunctionSignature_Description::ArenaDtor(void* object) { + FunctionSignature_Description* _this = reinterpret_cast< FunctionSignature_Description* >(object); + (void)_this; +} +void FunctionSignature_Description::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_Description::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_Description::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Description) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + language_.ClearToEmpty(); + body_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_Description::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string language = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_language(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Description.language")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string body = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_body(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Description.body")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Description::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Description) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string language = 1; + if (this->language().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_language().data(), static_cast(this->_internal_language().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.FunctionSignature.Description.language"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_language(), target); + } + + // string body = 2; + if (this->body().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_body().data(), static_cast(this->_internal_body().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.FunctionSignature.Description.body"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_body(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Description) + return target; +} + +size_t FunctionSignature_Description::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Description) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string language = 1; + if (this->language().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_language()); + } + + // string body = 2; + if (this->body().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_body()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_Description::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Description) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_Description* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Description) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Description) + MergeFrom(*source); + } +} + +void FunctionSignature_Description::MergeFrom(const FunctionSignature_Description& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Description) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.language().size() > 0) { + _internal_set_language(from._internal_language()); + } + if (from.body().size() > 0) { + _internal_set_body(from._internal_body()); + } +} + +void FunctionSignature_Description::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Description) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_Description::CopyFrom(const FunctionSignature_Description& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Description) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_Description::IsInitialized() const { + return true; +} + +void FunctionSignature_Description::InternalSwap(FunctionSignature_Description* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + language_.Swap(&other->language_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + body_.Swap(&other->body_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Description::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[5]); +} + +// =================================================================== + +class FunctionSignature_Implementation::_Internal { + public: +}; + +FunctionSignature_Implementation::FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Implementation) +} +FunctionSignature_Implementation::FunctionSignature_Implementation(const FunctionSignature_Implementation& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_uri().empty()) { + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), + GetArena()); + } + type_ = from.type_; + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Implementation) +} + +void FunctionSignature_Implementation::SharedCtor() { +uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +type_ = 0; +} + +FunctionSignature_Implementation::~FunctionSignature_Implementation() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Implementation) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_Implementation::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void FunctionSignature_Implementation::ArenaDtor(void* object) { + FunctionSignature_Implementation* _this = reinterpret_cast< FunctionSignature_Implementation* >(object); + (void)_this; +} +void FunctionSignature_Implementation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_Implementation::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_Implementation::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Implementation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + uri_.ClearToEmpty(); + type_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_Implementation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.FunctionSignature.Implementation.Type type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_type(static_cast<::io::substrait::FunctionSignature_Implementation_Type>(val)); + } else goto handle_unusual; + continue; + // string uri = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_uri(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Implementation.uri")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Implementation::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Implementation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.FunctionSignature.Implementation.Type type = 1; + if (this->type() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_type(), target); + } + + // string uri = 2; + if (this->uri().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_uri().data(), static_cast(this->_internal_uri().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.FunctionSignature.Implementation.uri"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_uri(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Implementation) + return target; +} + +size_t FunctionSignature_Implementation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Implementation) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string uri = 2; + if (this->uri().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_uri()); + } + + // .io.substrait.FunctionSignature.Implementation.Type type = 1; + if (this->type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_Implementation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Implementation) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_Implementation* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Implementation) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Implementation) + MergeFrom(*source); + } +} + +void FunctionSignature_Implementation::MergeFrom(const FunctionSignature_Implementation& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Implementation) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.uri().size() > 0) { + _internal_set_uri(from._internal_uri()); + } + if (from.type() != 0) { + _internal_set_type(from._internal_type()); + } +} + +void FunctionSignature_Implementation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Implementation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_Implementation::CopyFrom(const FunctionSignature_Implementation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Implementation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_Implementation::IsInitialized() const { + return true; +} + +void FunctionSignature_Implementation::InternalSwap(FunctionSignature_Implementation* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + uri_.Swap(&other->uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(type_, other->type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Implementation::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[6]); +} + +// =================================================================== + +class FunctionSignature_Argument_ValueArgument::_Internal { + public: + static const ::io::substrait::ParameterizedType& type(const FunctionSignature_Argument_ValueArgument* msg); +}; + +const ::io::substrait::ParameterizedType& +FunctionSignature_Argument_ValueArgument::_Internal::type(const FunctionSignature_Argument_ValueArgument* msg) { + return *msg->type_; +} +void FunctionSignature_Argument_ValueArgument::clear_type() { + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; +} +FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Argument.ValueArgument) +} +FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(const FunctionSignature_Argument_ValueArgument& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_type()) { + type_ = new ::io::substrait::ParameterizedType(*from.type_); + } else { + type_ = nullptr; + } + constant_ = from.constant_; + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Argument.ValueArgument) +} + +void FunctionSignature_Argument_ValueArgument::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&constant_) - + reinterpret_cast(&type_)) + sizeof(constant_)); +} + +FunctionSignature_Argument_ValueArgument::~FunctionSignature_Argument_ValueArgument() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Argument.ValueArgument) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_Argument_ValueArgument::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete type_; +} + +void FunctionSignature_Argument_ValueArgument::ArenaDtor(void* object) { + FunctionSignature_Argument_ValueArgument* _this = reinterpret_cast< FunctionSignature_Argument_ValueArgument* >(object); + (void)_this; +} +void FunctionSignature_Argument_ValueArgument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_Argument_ValueArgument::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_Argument_ValueArgument::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Argument.ValueArgument) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; + constant_ = false; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_Argument_ValueArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ParameterizedType type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool constant = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + constant_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_ValueArgument::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Argument.ValueArgument) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ParameterizedType type = 1; + if (this->has_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::type(this), target, stream); + } + + // bool constant = 2; + if (this->constant() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_constant(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Argument.ValueArgument) + return target; +} + +size_t FunctionSignature_Argument_ValueArgument::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Argument.ValueArgument) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ParameterizedType type = 1; + if (this->has_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_); + } + + // bool constant = 2; + if (this->constant() != 0) { + total_size += 1 + 1; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_Argument_ValueArgument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Argument.ValueArgument) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_Argument_ValueArgument* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Argument.ValueArgument) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Argument.ValueArgument) + MergeFrom(*source); + } +} + +void FunctionSignature_Argument_ValueArgument::MergeFrom(const FunctionSignature_Argument_ValueArgument& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Argument.ValueArgument) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_type()) { + _internal_mutable_type()->::io::substrait::ParameterizedType::MergeFrom(from._internal_type()); + } + if (from.constant() != 0) { + _internal_set_constant(from._internal_constant()); + } +} + +void FunctionSignature_Argument_ValueArgument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Argument.ValueArgument) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_Argument_ValueArgument::CopyFrom(const FunctionSignature_Argument_ValueArgument& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Argument.ValueArgument) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_Argument_ValueArgument::IsInitialized() const { + return true; +} + +void FunctionSignature_Argument_ValueArgument::InternalSwap(FunctionSignature_Argument_ValueArgument* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FunctionSignature_Argument_ValueArgument, constant_) + + sizeof(FunctionSignature_Argument_ValueArgument::constant_) + - PROTOBUF_FIELD_OFFSET(FunctionSignature_Argument_ValueArgument, type_)>( + reinterpret_cast(&type_), + reinterpret_cast(&other->type_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_ValueArgument::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[7]); +} + +// =================================================================== + +class FunctionSignature_Argument_TypeArgument::_Internal { + public: + static const ::io::substrait::ParameterizedType& type(const FunctionSignature_Argument_TypeArgument* msg); +}; + +const ::io::substrait::ParameterizedType& +FunctionSignature_Argument_TypeArgument::_Internal::type(const FunctionSignature_Argument_TypeArgument* msg) { + return *msg->type_; +} +void FunctionSignature_Argument_TypeArgument::clear_type() { + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; +} +FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Argument.TypeArgument) +} +FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(const FunctionSignature_Argument_TypeArgument& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_type()) { + type_ = new ::io::substrait::ParameterizedType(*from.type_); + } else { + type_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Argument.TypeArgument) +} + +void FunctionSignature_Argument_TypeArgument::SharedCtor() { +type_ = nullptr; +} + +FunctionSignature_Argument_TypeArgument::~FunctionSignature_Argument_TypeArgument() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Argument.TypeArgument) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_Argument_TypeArgument::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete type_; +} + +void FunctionSignature_Argument_TypeArgument::ArenaDtor(void* object) { + FunctionSignature_Argument_TypeArgument* _this = reinterpret_cast< FunctionSignature_Argument_TypeArgument* >(object); + (void)_this; +} +void FunctionSignature_Argument_TypeArgument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_Argument_TypeArgument::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_Argument_TypeArgument::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Argument.TypeArgument) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_Argument_TypeArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ParameterizedType type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_TypeArgument::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Argument.TypeArgument) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ParameterizedType type = 1; + if (this->has_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::type(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Argument.TypeArgument) + return target; +} + +size_t FunctionSignature_Argument_TypeArgument::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Argument.TypeArgument) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ParameterizedType type = 1; + if (this->has_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_Argument_TypeArgument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Argument.TypeArgument) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_Argument_TypeArgument* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Argument.TypeArgument) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Argument.TypeArgument) + MergeFrom(*source); + } +} + +void FunctionSignature_Argument_TypeArgument::MergeFrom(const FunctionSignature_Argument_TypeArgument& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Argument.TypeArgument) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_type()) { + _internal_mutable_type()->::io::substrait::ParameterizedType::MergeFrom(from._internal_type()); + } +} + +void FunctionSignature_Argument_TypeArgument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Argument.TypeArgument) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_Argument_TypeArgument::CopyFrom(const FunctionSignature_Argument_TypeArgument& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Argument.TypeArgument) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_Argument_TypeArgument::IsInitialized() const { + return true; +} + +void FunctionSignature_Argument_TypeArgument::InternalSwap(FunctionSignature_Argument_TypeArgument* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(type_, other->type_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_TypeArgument::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[8]); +} + +// =================================================================== + +class FunctionSignature_Argument_EnumArgument::_Internal { + public: +}; + +FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + options_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Argument.EnumArgument) +} +FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(const FunctionSignature_Argument_EnumArgument& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + options_(from.options_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + optional_ = from.optional_; + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Argument.EnumArgument) +} + +void FunctionSignature_Argument_EnumArgument::SharedCtor() { +optional_ = false; +} + +FunctionSignature_Argument_EnumArgument::~FunctionSignature_Argument_EnumArgument() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Argument.EnumArgument) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_Argument_EnumArgument::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void FunctionSignature_Argument_EnumArgument::ArenaDtor(void* object) { + FunctionSignature_Argument_EnumArgument* _this = reinterpret_cast< FunctionSignature_Argument_EnumArgument* >(object); + (void)_this; +} +void FunctionSignature_Argument_EnumArgument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_Argument_EnumArgument::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_Argument_EnumArgument::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Argument.EnumArgument) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + options_.Clear(); + optional_ = false; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_Argument_EnumArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string options = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_options(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Argument.EnumArgument.options")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // bool optional = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + optional_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_EnumArgument::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Argument.EnumArgument) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string options = 1; + for (int i = 0, n = this->_internal_options_size(); i < n; i++) { + const auto& s = this->_internal_options(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.FunctionSignature.Argument.EnumArgument.options"); + target = stream->WriteString(1, s, target); + } + + // bool optional = 2; + if (this->optional() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_optional(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Argument.EnumArgument) + return target; +} + +size_t FunctionSignature_Argument_EnumArgument::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Argument.EnumArgument) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string options = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(options_.size()); + for (int i = 0, n = options_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + options_.Get(i)); + } + + // bool optional = 2; + if (this->optional() != 0) { + total_size += 1 + 1; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_Argument_EnumArgument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Argument.EnumArgument) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_Argument_EnumArgument* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Argument.EnumArgument) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Argument.EnumArgument) + MergeFrom(*source); + } +} + +void FunctionSignature_Argument_EnumArgument::MergeFrom(const FunctionSignature_Argument_EnumArgument& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Argument.EnumArgument) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + options_.MergeFrom(from.options_); + if (from.optional() != 0) { + _internal_set_optional(from._internal_optional()); + } +} + +void FunctionSignature_Argument_EnumArgument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Argument.EnumArgument) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_Argument_EnumArgument::CopyFrom(const FunctionSignature_Argument_EnumArgument& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Argument.EnumArgument) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_Argument_EnumArgument::IsInitialized() const { + return true; +} + +void FunctionSignature_Argument_EnumArgument::InternalSwap(FunctionSignature_Argument_EnumArgument* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + options_.InternalSwap(&other->options_); + swap(optional_, other->optional_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_EnumArgument::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[9]); +} + +// =================================================================== + +class FunctionSignature_Argument::_Internal { + public: + static const ::io::substrait::FunctionSignature_Argument_ValueArgument& value(const FunctionSignature_Argument* msg); + static const ::io::substrait::FunctionSignature_Argument_TypeArgument& type(const FunctionSignature_Argument* msg); + static const ::io::substrait::FunctionSignature_Argument_EnumArgument& enum_(const FunctionSignature_Argument* msg); +}; + +const ::io::substrait::FunctionSignature_Argument_ValueArgument& +FunctionSignature_Argument::_Internal::value(const FunctionSignature_Argument* msg) { + return *msg->argument_kind_.value_; +} +const ::io::substrait::FunctionSignature_Argument_TypeArgument& +FunctionSignature_Argument::_Internal::type(const FunctionSignature_Argument* msg) { + return *msg->argument_kind_.type_; +} +const ::io::substrait::FunctionSignature_Argument_EnumArgument& +FunctionSignature_Argument::_Internal::enum_(const FunctionSignature_Argument* msg) { + return *msg->argument_kind_.enum__; +} +void FunctionSignature_Argument::set_allocated_value(::io::substrait::FunctionSignature_Argument_ValueArgument* value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_argument_kind(); + if (value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + if (message_arena != submessage_arena) { + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); + } + set_has_value(); + argument_kind_.value_ = value; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.value) +} +void FunctionSignature_Argument::set_allocated_type(::io::substrait::FunctionSignature_Argument_TypeArgument* type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_argument_kind(); + if (type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type); + if (message_arena != submessage_arena) { + type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type, submessage_arena); + } + set_has_type(); + argument_kind_.type_ = type; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.type) +} +void FunctionSignature_Argument::set_allocated_enum_(::io::substrait::FunctionSignature_Argument_EnumArgument* enum_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_argument_kind(); + if (enum_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(enum_); + if (message_arena != submessage_arena) { + enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, enum_, submessage_arena); + } + set_has_enum_(); + argument_kind_.enum__ = enum_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.enum) +} +FunctionSignature_Argument::FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Argument) +} +FunctionSignature_Argument::FunctionSignature_Argument(const FunctionSignature_Argument& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); + } + clear_has_argument_kind(); + switch (from.argument_kind_case()) { + case kValue: { + _internal_mutable_value()->::io::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value()); + break; + } + case kType: { + _internal_mutable_type()->::io::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type()); + break; + } + case kEnum: { + _internal_mutable_enum_()->::io::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_()); + break; + } + case ARGUMENT_KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Argument) +} + +void FunctionSignature_Argument::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +clear_has_argument_kind(); +} + +FunctionSignature_Argument::~FunctionSignature_Argument() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Argument) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature_Argument::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (has_argument_kind()) { + clear_argument_kind(); + } +} + +void FunctionSignature_Argument::ArenaDtor(void* object) { + FunctionSignature_Argument* _this = reinterpret_cast< FunctionSignature_Argument* >(object); + (void)_this; +} +void FunctionSignature_Argument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature_Argument::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature_Argument::clear_argument_kind() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.FunctionSignature.Argument) + switch (argument_kind_case()) { + case kValue: { + if (GetArena() == nullptr) { + delete argument_kind_.value_; + } + break; + } + case kType: { + if (GetArena() == nullptr) { + delete argument_kind_.type_; + } + break; + } + case kEnum: { + if (GetArena() == nullptr) { + delete argument_kind_.enum__; + } + break; + } + case ARGUMENT_KIND_NOT_SET: { + break; + } + } + _oneof_case_[0] = ARGUMENT_KIND_NOT_SET; +} + + +void FunctionSignature_Argument::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Argument) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmpty(); + clear_argument_kind(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature_Argument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Argument.name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.Argument.ValueArgument value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.Argument.TypeArgument type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FunctionSignature.Argument.EnumArgument enum = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Argument) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string name = 1; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.FunctionSignature.Argument.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // .io.substrait.FunctionSignature.Argument.ValueArgument value = 2; + if (_internal_has_value()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::value(this), target, stream); + } + + // .io.substrait.FunctionSignature.Argument.TypeArgument type = 3; + if (_internal_has_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::type(this), target, stream); + } + + // .io.substrait.FunctionSignature.Argument.EnumArgument enum = 4; + if (_internal_has_enum_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::enum_(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Argument) + return target; +} + +size_t FunctionSignature_Argument::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Argument) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 1; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + switch (argument_kind_case()) { + // .io.substrait.FunctionSignature.Argument.ValueArgument value = 2; + case kValue: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *argument_kind_.value_); + break; + } + // .io.substrait.FunctionSignature.Argument.TypeArgument type = 3; + case kType: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *argument_kind_.type_); + break; + } + // .io.substrait.FunctionSignature.Argument.EnumArgument enum = 4; + case kEnum: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *argument_kind_.enum__); + break; + } + case ARGUMENT_KIND_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature_Argument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Argument) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature_Argument* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Argument) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Argument) + MergeFrom(*source); + } +} + +void FunctionSignature_Argument::MergeFrom(const FunctionSignature_Argument& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Argument) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } + switch (from.argument_kind_case()) { + case kValue: { + _internal_mutable_value()->::io::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value()); + break; + } + case kType: { + _internal_mutable_type()->::io::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type()); + break; + } + case kEnum: { + _internal_mutable_enum_()->::io::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_()); + break; + } + case ARGUMENT_KIND_NOT_SET: { + break; + } + } +} + +void FunctionSignature_Argument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Argument) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature_Argument::CopyFrom(const FunctionSignature_Argument& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Argument) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature_Argument::IsInitialized() const { + return true; +} + +void FunctionSignature_Argument::InternalSwap(FunctionSignature_Argument* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(argument_kind_, other->argument_kind_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[10]); +} + +// =================================================================== + +class FunctionSignature::_Internal { + public: +}; + +FunctionSignature::FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature) +} +FunctionSignature::FunctionSignature(const FunctionSignature& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature) +} + +void FunctionSignature::SharedCtor() { +} + +FunctionSignature::~FunctionSignature() { + // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FunctionSignature::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void FunctionSignature::ArenaDtor(void* object) { + FunctionSignature* _this = reinterpret_cast< FunctionSignature* >(object); + (void)_this; +} +void FunctionSignature::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FunctionSignature::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FunctionSignature::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FunctionSignature::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature) + return target; +} + +size_t FunctionSignature::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FunctionSignature::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature) + GOOGLE_DCHECK_NE(&from, this); + const FunctionSignature* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature) + MergeFrom(*source); + } +} + +void FunctionSignature::MergeFrom(const FunctionSignature& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +void FunctionSignature::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FunctionSignature::CopyFrom(const FunctionSignature& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FunctionSignature::IsInitialized() const { + return true; +} + +void FunctionSignature::InternalSwap(FunctionSignature* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, + file_level_metadata_function_2eproto[11]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgVariadic >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_FinalArgVariadic >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgNormal >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_FinalArgNormal >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Scalar >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Scalar >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Aggregate >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Aggregate >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Window >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Window >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Description >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Description >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Implementation >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Implementation >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_ValueArgument >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Argument_ValueArgument >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_TypeArgument >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Argument_TypeArgument >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_EnumArgument >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Argument_EnumArgument >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Argument >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/function.pb.h b/cpp/src/generated/substrait/function.pb.h new file mode 100644 index 00000000000..22add5bf953 --- /dev/null +++ b/cpp/src/generated/substrait/function.pb.h @@ -0,0 +1,5605 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: function.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_function_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_function_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +#include "type.pb.h" +#include "parameterized_types.pb.h" +#include "type_expressions.pb.h" +#include "extensions.pb.h" +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_function_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_function_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_function_2eproto; +namespace io { +namespace substrait { +class FunctionSignature; +struct FunctionSignatureDefaultTypeInternal; +extern FunctionSignatureDefaultTypeInternal _FunctionSignature_default_instance_; +class FunctionSignature_Aggregate; +struct FunctionSignature_AggregateDefaultTypeInternal; +extern FunctionSignature_AggregateDefaultTypeInternal _FunctionSignature_Aggregate_default_instance_; +class FunctionSignature_Argument; +struct FunctionSignature_ArgumentDefaultTypeInternal; +extern FunctionSignature_ArgumentDefaultTypeInternal _FunctionSignature_Argument_default_instance_; +class FunctionSignature_Argument_EnumArgument; +struct FunctionSignature_Argument_EnumArgumentDefaultTypeInternal; +extern FunctionSignature_Argument_EnumArgumentDefaultTypeInternal _FunctionSignature_Argument_EnumArgument_default_instance_; +class FunctionSignature_Argument_TypeArgument; +struct FunctionSignature_Argument_TypeArgumentDefaultTypeInternal; +extern FunctionSignature_Argument_TypeArgumentDefaultTypeInternal _FunctionSignature_Argument_TypeArgument_default_instance_; +class FunctionSignature_Argument_ValueArgument; +struct FunctionSignature_Argument_ValueArgumentDefaultTypeInternal; +extern FunctionSignature_Argument_ValueArgumentDefaultTypeInternal _FunctionSignature_Argument_ValueArgument_default_instance_; +class FunctionSignature_Description; +struct FunctionSignature_DescriptionDefaultTypeInternal; +extern FunctionSignature_DescriptionDefaultTypeInternal _FunctionSignature_Description_default_instance_; +class FunctionSignature_FinalArgNormal; +struct FunctionSignature_FinalArgNormalDefaultTypeInternal; +extern FunctionSignature_FinalArgNormalDefaultTypeInternal _FunctionSignature_FinalArgNormal_default_instance_; +class FunctionSignature_FinalArgVariadic; +struct FunctionSignature_FinalArgVariadicDefaultTypeInternal; +extern FunctionSignature_FinalArgVariadicDefaultTypeInternal _FunctionSignature_FinalArgVariadic_default_instance_; +class FunctionSignature_Implementation; +struct FunctionSignature_ImplementationDefaultTypeInternal; +extern FunctionSignature_ImplementationDefaultTypeInternal _FunctionSignature_Implementation_default_instance_; +class FunctionSignature_Scalar; +struct FunctionSignature_ScalarDefaultTypeInternal; +extern FunctionSignature_ScalarDefaultTypeInternal _FunctionSignature_Scalar_default_instance_; +class FunctionSignature_Window; +struct FunctionSignature_WindowDefaultTypeInternal; +extern FunctionSignature_WindowDefaultTypeInternal _FunctionSignature_Window_default_instance_; +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::FunctionSignature* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature>(Arena*); +template<> ::io::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Aggregate>(Arena*); +template<> ::io::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Argument>(Arena*); +template<> ::io::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Argument_EnumArgument>(Arena*); +template<> ::io::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Argument_TypeArgument>(Arena*); +template<> ::io::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Argument_ValueArgument>(Arena*); +template<> ::io::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Description>(Arena*); +template<> ::io::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_FinalArgNormal>(Arena*); +template<> ::io::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_FinalArgVariadic>(Arena*); +template<> ::io::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Implementation>(Arena*); +template<> ::io::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Scalar>(Arena*); +template<> ::io::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Window>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace io { +namespace substrait { + +enum FunctionSignature_FinalArgVariadic_ParameterConsistency : int { + FunctionSignature_FinalArgVariadic_ParameterConsistency_UNKNOWN = 0, + FunctionSignature_FinalArgVariadic_ParameterConsistency_CONSISTENT = 1, + FunctionSignature_FinalArgVariadic_ParameterConsistency_INCONSISTENT = 2, + FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value); +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN = FunctionSignature_FinalArgVariadic_ParameterConsistency_UNKNOWN; +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX = FunctionSignature_FinalArgVariadic_ParameterConsistency_INCONSISTENT; +constexpr int FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_ARRAYSIZE = FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(); +template +inline const std::string& FunctionSignature_FinalArgVariadic_ParameterConsistency_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function FunctionSignature_FinalArgVariadic_ParameterConsistency_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(), enum_t_value); +} +inline bool FunctionSignature_FinalArgVariadic_ParameterConsistency_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_FinalArgVariadic_ParameterConsistency* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(), name, value); +} +enum FunctionSignature_Window_WindowType : int { + FunctionSignature_Window_WindowType_UNKNOWN = 0, + FunctionSignature_Window_WindowType_STREAMING = 1, + FunctionSignature_Window_WindowType_PARTITION = 2, + FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool FunctionSignature_Window_WindowType_IsValid(int value); +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MIN = FunctionSignature_Window_WindowType_UNKNOWN; +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MAX = FunctionSignature_Window_WindowType_PARTITION; +constexpr int FunctionSignature_Window_WindowType_WindowType_ARRAYSIZE = FunctionSignature_Window_WindowType_WindowType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor(); +template +inline const std::string& FunctionSignature_Window_WindowType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function FunctionSignature_Window_WindowType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + FunctionSignature_Window_WindowType_descriptor(), enum_t_value); +} +inline bool FunctionSignature_Window_WindowType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_Window_WindowType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + FunctionSignature_Window_WindowType_descriptor(), name, value); +} +enum FunctionSignature_Implementation_Type : int { + FunctionSignature_Implementation_Type_UNKNOWN = 0, + FunctionSignature_Implementation_Type_WEB_ASSEMBLY = 1, + FunctionSignature_Implementation_Type_TRINO_JAR = 2, + FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool FunctionSignature_Implementation_Type_IsValid(int value); +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MIN = FunctionSignature_Implementation_Type_UNKNOWN; +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MAX = FunctionSignature_Implementation_Type_TRINO_JAR; +constexpr int FunctionSignature_Implementation_Type_Type_ARRAYSIZE = FunctionSignature_Implementation_Type_Type_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor(); +template +inline const std::string& FunctionSignature_Implementation_Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function FunctionSignature_Implementation_Type_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + FunctionSignature_Implementation_Type_descriptor(), enum_t_value); +} +inline bool FunctionSignature_Implementation_Type_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_Implementation_Type* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + FunctionSignature_Implementation_Type_descriptor(), name, value); +} +// =================================================================== + +class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.FinalArgVariadic) */ { + public: + inline FunctionSignature_FinalArgVariadic() : FunctionSignature_FinalArgVariadic(nullptr) {} + ~FunctionSignature_FinalArgVariadic() override; + explicit constexpr FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_FinalArgVariadic(const FunctionSignature_FinalArgVariadic& from); + FunctionSignature_FinalArgVariadic(FunctionSignature_FinalArgVariadic&& from) noexcept + : FunctionSignature_FinalArgVariadic() { + *this = ::std::move(from); + } + + inline FunctionSignature_FinalArgVariadic& operator=(const FunctionSignature_FinalArgVariadic& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_FinalArgVariadic& operator=(FunctionSignature_FinalArgVariadic&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_FinalArgVariadic& default_instance() { + return *internal_default_instance(); + } + static inline const FunctionSignature_FinalArgVariadic* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_FinalArgVariadic_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(FunctionSignature_FinalArgVariadic& a, FunctionSignature_FinalArgVariadic& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_FinalArgVariadic* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_FinalArgVariadic* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_FinalArgVariadic* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_FinalArgVariadic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_FinalArgVariadic& from); + void MergeFrom(const FunctionSignature_FinalArgVariadic& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_FinalArgVariadic* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.FinalArgVariadic"; + } + protected: + explicit FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef FunctionSignature_FinalArgVariadic_ParameterConsistency ParameterConsistency; + static constexpr ParameterConsistency UNKNOWN = + FunctionSignature_FinalArgVariadic_ParameterConsistency_UNKNOWN; + static constexpr ParameterConsistency CONSISTENT = + FunctionSignature_FinalArgVariadic_ParameterConsistency_CONSISTENT; + static constexpr ParameterConsistency INCONSISTENT = + FunctionSignature_FinalArgVariadic_ParameterConsistency_INCONSISTENT; + static inline bool ParameterConsistency_IsValid(int value) { + return FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(value); + } + static constexpr ParameterConsistency ParameterConsistency_MIN = + FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN; + static constexpr ParameterConsistency ParameterConsistency_MAX = + FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX; + static constexpr int ParameterConsistency_ARRAYSIZE = + FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + ParameterConsistency_descriptor() { + return FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(); + } + template + static inline const std::string& ParameterConsistency_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ParameterConsistency_Name."); + return FunctionSignature_FinalArgVariadic_ParameterConsistency_Name(enum_t_value); + } + static inline bool ParameterConsistency_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + ParameterConsistency* value) { + return FunctionSignature_FinalArgVariadic_ParameterConsistency_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kMinArgsFieldNumber = 1, + kMaxArgsFieldNumber = 2, + kConsistencyFieldNumber = 3, + }; + // int64 min_args = 1; + void clear_min_args(); + ::PROTOBUF_NAMESPACE_ID::int64 min_args() const; + void set_min_args(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_min_args() const; + void _internal_set_min_args(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // int64 max_args = 2; + void clear_max_args(); + ::PROTOBUF_NAMESPACE_ID::int64 max_args() const; + void set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_args() const; + void _internal_set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // .io.substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; + void clear_consistency(); + ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency consistency() const; + void set_consistency(::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value); + private: + ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency _internal_consistency() const; + void _internal_set_consistency(::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.FinalArgVariadic) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::int64 min_args_; + ::PROTOBUF_NAMESPACE_ID::int64 max_args_; + int consistency_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature_FinalArgNormal PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.FinalArgNormal) */ { + public: + inline FunctionSignature_FinalArgNormal() : FunctionSignature_FinalArgNormal(nullptr) {} + ~FunctionSignature_FinalArgNormal() override; + explicit constexpr FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_FinalArgNormal(const FunctionSignature_FinalArgNormal& from); + FunctionSignature_FinalArgNormal(FunctionSignature_FinalArgNormal&& from) noexcept + : FunctionSignature_FinalArgNormal() { + *this = ::std::move(from); + } + + inline FunctionSignature_FinalArgNormal& operator=(const FunctionSignature_FinalArgNormal& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_FinalArgNormal& operator=(FunctionSignature_FinalArgNormal&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_FinalArgNormal& default_instance() { + return *internal_default_instance(); + } + static inline const FunctionSignature_FinalArgNormal* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_FinalArgNormal_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(FunctionSignature_FinalArgNormal& a, FunctionSignature_FinalArgNormal& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_FinalArgNormal* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_FinalArgNormal* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_FinalArgNormal* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_FinalArgNormal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_FinalArgNormal& from); + void MergeFrom(const FunctionSignature_FinalArgNormal& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_FinalArgNormal* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.FinalArgNormal"; + } + protected: + explicit FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.FinalArgNormal) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature_Scalar PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Scalar) */ { + public: + inline FunctionSignature_Scalar() : FunctionSignature_Scalar(nullptr) {} + ~FunctionSignature_Scalar() override; + explicit constexpr FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_Scalar(const FunctionSignature_Scalar& from); + FunctionSignature_Scalar(FunctionSignature_Scalar&& from) noexcept + : FunctionSignature_Scalar() { + *this = ::std::move(from); + } + + inline FunctionSignature_Scalar& operator=(const FunctionSignature_Scalar& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_Scalar& operator=(FunctionSignature_Scalar&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_Scalar& default_instance() { + return *internal_default_instance(); + } + enum FinalVariableBehaviorCase { + kVariadic = 10, + kNormal = 11, + FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0, + }; + + static inline const FunctionSignature_Scalar* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_Scalar_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(FunctionSignature_Scalar& a, FunctionSignature_Scalar& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_Scalar* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_Scalar* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_Scalar* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_Scalar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_Scalar& from); + void MergeFrom(const FunctionSignature_Scalar& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_Scalar* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.Scalar"; + } + protected: + explicit FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kArgumentsFieldNumber = 2, + kNameFieldNumber = 3, + kImplementationsFieldNumber = 12, + kIdFieldNumber = 1, + kDescriptionFieldNumber = 4, + kOutputTypeFieldNumber = 9, + kDeterministicFieldNumber = 7, + kSessionDependentFieldNumber = 8, + kVariadicFieldNumber = 10, + kNormalFieldNumber = 11, + }; + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + int arguments_size() const; + private: + int _internal_arguments_size() const; + public: + void clear_arguments(); + ::io::substrait::FunctionSignature_Argument* mutable_arguments(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* + mutable_arguments(); + private: + const ::io::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; + ::io::substrait::FunctionSignature_Argument* _internal_add_arguments(); + public: + const ::io::substrait::FunctionSignature_Argument& arguments(int index) const; + ::io::substrait::FunctionSignature_Argument* add_arguments(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& + arguments() const; + + // repeated string name = 3; + int name_size() const; + private: + int _internal_name_size() const; + public: + void clear_name(); + const std::string& name(int index) const; + std::string* mutable_name(int index); + void set_name(int index, const std::string& value); + void set_name(int index, std::string&& value); + void set_name(int index, const char* value); + void set_name(int index, const char* value, size_t size); + std::string* add_name(); + void add_name(const std::string& value); + void add_name(std::string&& value); + void add_name(const char* value); + void add_name(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& name() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_name(); + private: + const std::string& _internal_name(int index) const; + std::string* _internal_add_name(); + public: + + // repeated .io.substrait.FunctionSignature.Implementation implementations = 12; + int implementations_size() const; + private: + int _internal_implementations_size() const; + public: + void clear_implementations(); + ::io::substrait::FunctionSignature_Implementation* mutable_implementations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* + mutable_implementations(); + private: + const ::io::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; + ::io::substrait::FunctionSignature_Implementation* _internal_add_implementations(); + public: + const ::io::substrait::FunctionSignature_Implementation& implementations(int index) const; + ::io::substrait::FunctionSignature_Implementation* add_implementations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& + implementations() const; + + // .io.substrait.Extensions.FunctionId id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const ::io::substrait::Extensions_FunctionId& id() const; + ::io::substrait::Extensions_FunctionId* release_id(); + ::io::substrait::Extensions_FunctionId* mutable_id(); + void set_allocated_id(::io::substrait::Extensions_FunctionId* id); + private: + const ::io::substrait::Extensions_FunctionId& _internal_id() const; + ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); + public: + void unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id); + ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); + + // .io.substrait.FunctionSignature.Description description = 4; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const ::io::substrait::FunctionSignature_Description& description() const; + ::io::substrait::FunctionSignature_Description* release_description(); + ::io::substrait::FunctionSignature_Description* mutable_description(); + void set_allocated_description(::io::substrait::FunctionSignature_Description* description); + private: + const ::io::substrait::FunctionSignature_Description& _internal_description() const; + ::io::substrait::FunctionSignature_Description* _internal_mutable_description(); + public: + void unsafe_arena_set_allocated_description( + ::io::substrait::FunctionSignature_Description* description); + ::io::substrait::FunctionSignature_Description* unsafe_arena_release_description(); + + // .io.substrait.DerivationExpression output_type = 9; + bool has_output_type() const; + private: + bool _internal_has_output_type() const; + public: + void clear_output_type(); + const ::io::substrait::DerivationExpression& output_type() const; + ::io::substrait::DerivationExpression* release_output_type(); + ::io::substrait::DerivationExpression* mutable_output_type(); + void set_allocated_output_type(::io::substrait::DerivationExpression* output_type); + private: + const ::io::substrait::DerivationExpression& _internal_output_type() const; + ::io::substrait::DerivationExpression* _internal_mutable_output_type(); + public: + void unsafe_arena_set_allocated_output_type( + ::io::substrait::DerivationExpression* output_type); + ::io::substrait::DerivationExpression* unsafe_arena_release_output_type(); + + // bool deterministic = 7; + void clear_deterministic(); + bool deterministic() const; + void set_deterministic(bool value); + private: + bool _internal_deterministic() const; + void _internal_set_deterministic(bool value); + public: + + // bool session_dependent = 8; + void clear_session_dependent(); + bool session_dependent() const; + void set_session_dependent(bool value); + private: + bool _internal_session_dependent() const; + void _internal_set_session_dependent(bool value); + public: + + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + bool has_variadic() const; + private: + bool _internal_has_variadic() const; + public: + void clear_variadic(); + const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic() const; + ::io::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); + ::io::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); + void set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic); + private: + const ::io::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; + ::io::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); + public: + void unsafe_arena_set_allocated_variadic( + ::io::substrait::FunctionSignature_FinalArgVariadic* variadic); + ::io::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); + + // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + bool has_normal() const; + private: + bool _internal_has_normal() const; + public: + void clear_normal(); + const ::io::substrait::FunctionSignature_FinalArgNormal& normal() const; + ::io::substrait::FunctionSignature_FinalArgNormal* release_normal(); + ::io::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); + void set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal); + private: + const ::io::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; + ::io::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); + public: + void unsafe_arena_set_allocated_normal( + ::io::substrait::FunctionSignature_FinalArgNormal* normal); + ::io::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); + + void clear_final_variable_behavior(); + FinalVariableBehaviorCase final_variable_behavior_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Scalar) + private: + class _Internal; + void set_has_variadic(); + void set_has_normal(); + + inline bool has_final_variable_behavior() const; + inline void clear_has_final_variable_behavior(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument > arguments_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField name_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation > implementations_; + ::io::substrait::Extensions_FunctionId* id_; + ::io::substrait::FunctionSignature_Description* description_; + ::io::substrait::DerivationExpression* output_type_; + bool deterministic_; + bool session_dependent_; + union FinalVariableBehaviorUnion { + constexpr FinalVariableBehaviorUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::FunctionSignature_FinalArgVariadic* variadic_; + ::io::substrait::FunctionSignature_FinalArgNormal* normal_; + } final_variable_behavior_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature_Aggregate PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Aggregate) */ { + public: + inline FunctionSignature_Aggregate() : FunctionSignature_Aggregate(nullptr) {} + ~FunctionSignature_Aggregate() override; + explicit constexpr FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from); + FunctionSignature_Aggregate(FunctionSignature_Aggregate&& from) noexcept + : FunctionSignature_Aggregate() { + *this = ::std::move(from); + } + + inline FunctionSignature_Aggregate& operator=(const FunctionSignature_Aggregate& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_Aggregate& operator=(FunctionSignature_Aggregate&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_Aggregate& default_instance() { + return *internal_default_instance(); + } + enum FinalVariableBehaviorCase { + kVariadic = 10, + kNormal = 11, + FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0, + }; + + static inline const FunctionSignature_Aggregate* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_Aggregate_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(FunctionSignature_Aggregate& a, FunctionSignature_Aggregate& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_Aggregate* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_Aggregate* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_Aggregate* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_Aggregate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_Aggregate& from); + void MergeFrom(const FunctionSignature_Aggregate& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_Aggregate* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.Aggregate"; + } + protected: + explicit FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kArgumentsFieldNumber = 2, + kNameFieldNumber = 3, + kImplementationsFieldNumber = 15, + kIdFieldNumber = 1, + kDescriptionFieldNumber = 4, + kOutputTypeFieldNumber = 9, + kIntermediateTypeFieldNumber = 13, + kMaxSetFieldNumber = 12, + kDeterministicFieldNumber = 7, + kSessionDependentFieldNumber = 8, + kOrderedFieldNumber = 14, + kVariadicFieldNumber = 10, + kNormalFieldNumber = 11, + }; + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + int arguments_size() const; + private: + int _internal_arguments_size() const; + public: + void clear_arguments(); + ::io::substrait::FunctionSignature_Argument* mutable_arguments(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* + mutable_arguments(); + private: + const ::io::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; + ::io::substrait::FunctionSignature_Argument* _internal_add_arguments(); + public: + const ::io::substrait::FunctionSignature_Argument& arguments(int index) const; + ::io::substrait::FunctionSignature_Argument* add_arguments(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& + arguments() const; + + // repeated string name = 3; + int name_size() const; + private: + int _internal_name_size() const; + public: + void clear_name(); + const std::string& name(int index) const; + std::string* mutable_name(int index); + void set_name(int index, const std::string& value); + void set_name(int index, std::string&& value); + void set_name(int index, const char* value); + void set_name(int index, const char* value, size_t size); + std::string* add_name(); + void add_name(const std::string& value); + void add_name(std::string&& value); + void add_name(const char* value); + void add_name(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& name() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_name(); + private: + const std::string& _internal_name(int index) const; + std::string* _internal_add_name(); + public: + + // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + int implementations_size() const; + private: + int _internal_implementations_size() const; + public: + void clear_implementations(); + ::io::substrait::FunctionSignature_Implementation* mutable_implementations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* + mutable_implementations(); + private: + const ::io::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; + ::io::substrait::FunctionSignature_Implementation* _internal_add_implementations(); + public: + const ::io::substrait::FunctionSignature_Implementation& implementations(int index) const; + ::io::substrait::FunctionSignature_Implementation* add_implementations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& + implementations() const; + + // .io.substrait.Extensions.FunctionId id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const ::io::substrait::Extensions_FunctionId& id() const; + ::io::substrait::Extensions_FunctionId* release_id(); + ::io::substrait::Extensions_FunctionId* mutable_id(); + void set_allocated_id(::io::substrait::Extensions_FunctionId* id); + private: + const ::io::substrait::Extensions_FunctionId& _internal_id() const; + ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); + public: + void unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id); + ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); + + // .io.substrait.FunctionSignature.Description description = 4; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const ::io::substrait::FunctionSignature_Description& description() const; + ::io::substrait::FunctionSignature_Description* release_description(); + ::io::substrait::FunctionSignature_Description* mutable_description(); + void set_allocated_description(::io::substrait::FunctionSignature_Description* description); + private: + const ::io::substrait::FunctionSignature_Description& _internal_description() const; + ::io::substrait::FunctionSignature_Description* _internal_mutable_description(); + public: + void unsafe_arena_set_allocated_description( + ::io::substrait::FunctionSignature_Description* description); + ::io::substrait::FunctionSignature_Description* unsafe_arena_release_description(); + + // .io.substrait.DerivationExpression output_type = 9; + bool has_output_type() const; + private: + bool _internal_has_output_type() const; + public: + void clear_output_type(); + const ::io::substrait::DerivationExpression& output_type() const; + ::io::substrait::DerivationExpression* release_output_type(); + ::io::substrait::DerivationExpression* mutable_output_type(); + void set_allocated_output_type(::io::substrait::DerivationExpression* output_type); + private: + const ::io::substrait::DerivationExpression& _internal_output_type() const; + ::io::substrait::DerivationExpression* _internal_mutable_output_type(); + public: + void unsafe_arena_set_allocated_output_type( + ::io::substrait::DerivationExpression* output_type); + ::io::substrait::DerivationExpression* unsafe_arena_release_output_type(); + + // .io.substrait.Type intermediate_type = 13; + bool has_intermediate_type() const; + private: + bool _internal_has_intermediate_type() const; + public: + void clear_intermediate_type(); + const ::io::substrait::Type& intermediate_type() const; + ::io::substrait::Type* release_intermediate_type(); + ::io::substrait::Type* mutable_intermediate_type(); + void set_allocated_intermediate_type(::io::substrait::Type* intermediate_type); + private: + const ::io::substrait::Type& _internal_intermediate_type() const; + ::io::substrait::Type* _internal_mutable_intermediate_type(); + public: + void unsafe_arena_set_allocated_intermediate_type( + ::io::substrait::Type* intermediate_type); + ::io::substrait::Type* unsafe_arena_release_intermediate_type(); + + // uint64 max_set = 12; + void clear_max_set(); + ::PROTOBUF_NAMESPACE_ID::uint64 max_set() const; + void set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_max_set() const; + void _internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // bool deterministic = 7; + void clear_deterministic(); + bool deterministic() const; + void set_deterministic(bool value); + private: + bool _internal_deterministic() const; + void _internal_set_deterministic(bool value); + public: + + // bool session_dependent = 8; + void clear_session_dependent(); + bool session_dependent() const; + void set_session_dependent(bool value); + private: + bool _internal_session_dependent() const; + void _internal_set_session_dependent(bool value); + public: + + // bool ordered = 14; + void clear_ordered(); + bool ordered() const; + void set_ordered(bool value); + private: + bool _internal_ordered() const; + void _internal_set_ordered(bool value); + public: + + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + bool has_variadic() const; + private: + bool _internal_has_variadic() const; + public: + void clear_variadic(); + const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic() const; + ::io::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); + ::io::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); + void set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic); + private: + const ::io::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; + ::io::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); + public: + void unsafe_arena_set_allocated_variadic( + ::io::substrait::FunctionSignature_FinalArgVariadic* variadic); + ::io::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); + + // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + bool has_normal() const; + private: + bool _internal_has_normal() const; + public: + void clear_normal(); + const ::io::substrait::FunctionSignature_FinalArgNormal& normal() const; + ::io::substrait::FunctionSignature_FinalArgNormal* release_normal(); + ::io::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); + void set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal); + private: + const ::io::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; + ::io::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); + public: + void unsafe_arena_set_allocated_normal( + ::io::substrait::FunctionSignature_FinalArgNormal* normal); + ::io::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); + + void clear_final_variable_behavior(); + FinalVariableBehaviorCase final_variable_behavior_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Aggregate) + private: + class _Internal; + void set_has_variadic(); + void set_has_normal(); + + inline bool has_final_variable_behavior() const; + inline void clear_has_final_variable_behavior(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument > arguments_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField name_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation > implementations_; + ::io::substrait::Extensions_FunctionId* id_; + ::io::substrait::FunctionSignature_Description* description_; + ::io::substrait::DerivationExpression* output_type_; + ::io::substrait::Type* intermediate_type_; + ::PROTOBUF_NAMESPACE_ID::uint64 max_set_; + bool deterministic_; + bool session_dependent_; + bool ordered_; + union FinalVariableBehaviorUnion { + constexpr FinalVariableBehaviorUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::FunctionSignature_FinalArgVariadic* variadic_; + ::io::substrait::FunctionSignature_FinalArgNormal* normal_; + } final_variable_behavior_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature_Window PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Window) */ { + public: + inline FunctionSignature_Window() : FunctionSignature_Window(nullptr) {} + ~FunctionSignature_Window() override; + explicit constexpr FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_Window(const FunctionSignature_Window& from); + FunctionSignature_Window(FunctionSignature_Window&& from) noexcept + : FunctionSignature_Window() { + *this = ::std::move(from); + } + + inline FunctionSignature_Window& operator=(const FunctionSignature_Window& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_Window& operator=(FunctionSignature_Window&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_Window& default_instance() { + return *internal_default_instance(); + } + enum FinalVariableBehaviorCase { + kVariadic = 16, + kNormal = 17, + FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0, + }; + + static inline const FunctionSignature_Window* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_Window_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(FunctionSignature_Window& a, FunctionSignature_Window& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_Window* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_Window* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_Window* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_Window* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_Window& from); + void MergeFrom(const FunctionSignature_Window& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_Window* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.Window"; + } + protected: + explicit FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef FunctionSignature_Window_WindowType WindowType; + static constexpr WindowType UNKNOWN = + FunctionSignature_Window_WindowType_UNKNOWN; + static constexpr WindowType STREAMING = + FunctionSignature_Window_WindowType_STREAMING; + static constexpr WindowType PARTITION = + FunctionSignature_Window_WindowType_PARTITION; + static inline bool WindowType_IsValid(int value) { + return FunctionSignature_Window_WindowType_IsValid(value); + } + static constexpr WindowType WindowType_MIN = + FunctionSignature_Window_WindowType_WindowType_MIN; + static constexpr WindowType WindowType_MAX = + FunctionSignature_Window_WindowType_WindowType_MAX; + static constexpr int WindowType_ARRAYSIZE = + FunctionSignature_Window_WindowType_WindowType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + WindowType_descriptor() { + return FunctionSignature_Window_WindowType_descriptor(); + } + template + static inline const std::string& WindowType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function WindowType_Name."); + return FunctionSignature_Window_WindowType_Name(enum_t_value); + } + static inline bool WindowType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + WindowType* value) { + return FunctionSignature_Window_WindowType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kArgumentsFieldNumber = 2, + kNameFieldNumber = 3, + kImplementationsFieldNumber = 15, + kIdFieldNumber = 1, + kDescriptionFieldNumber = 4, + kIntermediateTypeFieldNumber = 9, + kOutputTypeFieldNumber = 10, + kDeterministicFieldNumber = 7, + kSessionDependentFieldNumber = 8, + kOrderedFieldNumber = 11, + kWindowTypeFieldNumber = 14, + kMaxSetFieldNumber = 12, + kVariadicFieldNumber = 16, + kNormalFieldNumber = 17, + }; + // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + int arguments_size() const; + private: + int _internal_arguments_size() const; + public: + void clear_arguments(); + ::io::substrait::FunctionSignature_Argument* mutable_arguments(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* + mutable_arguments(); + private: + const ::io::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; + ::io::substrait::FunctionSignature_Argument* _internal_add_arguments(); + public: + const ::io::substrait::FunctionSignature_Argument& arguments(int index) const; + ::io::substrait::FunctionSignature_Argument* add_arguments(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& + arguments() const; + + // repeated string name = 3; + int name_size() const; + private: + int _internal_name_size() const; + public: + void clear_name(); + const std::string& name(int index) const; + std::string* mutable_name(int index); + void set_name(int index, const std::string& value); + void set_name(int index, std::string&& value); + void set_name(int index, const char* value); + void set_name(int index, const char* value, size_t size); + std::string* add_name(); + void add_name(const std::string& value); + void add_name(std::string&& value); + void add_name(const char* value); + void add_name(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& name() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_name(); + private: + const std::string& _internal_name(int index) const; + std::string* _internal_add_name(); + public: + + // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + int implementations_size() const; + private: + int _internal_implementations_size() const; + public: + void clear_implementations(); + ::io::substrait::FunctionSignature_Implementation* mutable_implementations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* + mutable_implementations(); + private: + const ::io::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; + ::io::substrait::FunctionSignature_Implementation* _internal_add_implementations(); + public: + const ::io::substrait::FunctionSignature_Implementation& implementations(int index) const; + ::io::substrait::FunctionSignature_Implementation* add_implementations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& + implementations() const; + + // .io.substrait.Extensions.FunctionId id = 1; + bool has_id() const; + private: + bool _internal_has_id() const; + public: + void clear_id(); + const ::io::substrait::Extensions_FunctionId& id() const; + ::io::substrait::Extensions_FunctionId* release_id(); + ::io::substrait::Extensions_FunctionId* mutable_id(); + void set_allocated_id(::io::substrait::Extensions_FunctionId* id); + private: + const ::io::substrait::Extensions_FunctionId& _internal_id() const; + ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); + public: + void unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id); + ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); + + // .io.substrait.FunctionSignature.Description description = 4; + bool has_description() const; + private: + bool _internal_has_description() const; + public: + void clear_description(); + const ::io::substrait::FunctionSignature_Description& description() const; + ::io::substrait::FunctionSignature_Description* release_description(); + ::io::substrait::FunctionSignature_Description* mutable_description(); + void set_allocated_description(::io::substrait::FunctionSignature_Description* description); + private: + const ::io::substrait::FunctionSignature_Description& _internal_description() const; + ::io::substrait::FunctionSignature_Description* _internal_mutable_description(); + public: + void unsafe_arena_set_allocated_description( + ::io::substrait::FunctionSignature_Description* description); + ::io::substrait::FunctionSignature_Description* unsafe_arena_release_description(); + + // .io.substrait.DerivationExpression intermediate_type = 9; + bool has_intermediate_type() const; + private: + bool _internal_has_intermediate_type() const; + public: + void clear_intermediate_type(); + const ::io::substrait::DerivationExpression& intermediate_type() const; + ::io::substrait::DerivationExpression* release_intermediate_type(); + ::io::substrait::DerivationExpression* mutable_intermediate_type(); + void set_allocated_intermediate_type(::io::substrait::DerivationExpression* intermediate_type); + private: + const ::io::substrait::DerivationExpression& _internal_intermediate_type() const; + ::io::substrait::DerivationExpression* _internal_mutable_intermediate_type(); + public: + void unsafe_arena_set_allocated_intermediate_type( + ::io::substrait::DerivationExpression* intermediate_type); + ::io::substrait::DerivationExpression* unsafe_arena_release_intermediate_type(); + + // .io.substrait.DerivationExpression output_type = 10; + bool has_output_type() const; + private: + bool _internal_has_output_type() const; + public: + void clear_output_type(); + const ::io::substrait::DerivationExpression& output_type() const; + ::io::substrait::DerivationExpression* release_output_type(); + ::io::substrait::DerivationExpression* mutable_output_type(); + void set_allocated_output_type(::io::substrait::DerivationExpression* output_type); + private: + const ::io::substrait::DerivationExpression& _internal_output_type() const; + ::io::substrait::DerivationExpression* _internal_mutable_output_type(); + public: + void unsafe_arena_set_allocated_output_type( + ::io::substrait::DerivationExpression* output_type); + ::io::substrait::DerivationExpression* unsafe_arena_release_output_type(); + + // bool deterministic = 7; + void clear_deterministic(); + bool deterministic() const; + void set_deterministic(bool value); + private: + bool _internal_deterministic() const; + void _internal_set_deterministic(bool value); + public: + + // bool session_dependent = 8; + void clear_session_dependent(); + bool session_dependent() const; + void set_session_dependent(bool value); + private: + bool _internal_session_dependent() const; + void _internal_set_session_dependent(bool value); + public: + + // bool ordered = 11; + void clear_ordered(); + bool ordered() const; + void set_ordered(bool value); + private: + bool _internal_ordered() const; + void _internal_set_ordered(bool value); + public: + + // .io.substrait.FunctionSignature.Window.WindowType window_type = 14; + void clear_window_type(); + ::io::substrait::FunctionSignature_Window_WindowType window_type() const; + void set_window_type(::io::substrait::FunctionSignature_Window_WindowType value); + private: + ::io::substrait::FunctionSignature_Window_WindowType _internal_window_type() const; + void _internal_set_window_type(::io::substrait::FunctionSignature_Window_WindowType value); + public: + + // uint64 max_set = 12; + void clear_max_set(); + ::PROTOBUF_NAMESPACE_ID::uint64 max_set() const; + void set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_max_set() const; + void _internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 16; + bool has_variadic() const; + private: + bool _internal_has_variadic() const; + public: + void clear_variadic(); + const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic() const; + ::io::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); + ::io::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); + void set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic); + private: + const ::io::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; + ::io::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); + public: + void unsafe_arena_set_allocated_variadic( + ::io::substrait::FunctionSignature_FinalArgVariadic* variadic); + ::io::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); + + // .io.substrait.FunctionSignature.FinalArgNormal normal = 17; + bool has_normal() const; + private: + bool _internal_has_normal() const; + public: + void clear_normal(); + const ::io::substrait::FunctionSignature_FinalArgNormal& normal() const; + ::io::substrait::FunctionSignature_FinalArgNormal* release_normal(); + ::io::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); + void set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal); + private: + const ::io::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; + ::io::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); + public: + void unsafe_arena_set_allocated_normal( + ::io::substrait::FunctionSignature_FinalArgNormal* normal); + ::io::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); + + void clear_final_variable_behavior(); + FinalVariableBehaviorCase final_variable_behavior_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Window) + private: + class _Internal; + void set_has_variadic(); + void set_has_normal(); + + inline bool has_final_variable_behavior() const; + inline void clear_has_final_variable_behavior(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument > arguments_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField name_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation > implementations_; + ::io::substrait::Extensions_FunctionId* id_; + ::io::substrait::FunctionSignature_Description* description_; + ::io::substrait::DerivationExpression* intermediate_type_; + ::io::substrait::DerivationExpression* output_type_; + bool deterministic_; + bool session_dependent_; + bool ordered_; + int window_type_; + ::PROTOBUF_NAMESPACE_ID::uint64 max_set_; + union FinalVariableBehaviorUnion { + constexpr FinalVariableBehaviorUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::FunctionSignature_FinalArgVariadic* variadic_; + ::io::substrait::FunctionSignature_FinalArgNormal* normal_; + } final_variable_behavior_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature_Description PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Description) */ { + public: + inline FunctionSignature_Description() : FunctionSignature_Description(nullptr) {} + ~FunctionSignature_Description() override; + explicit constexpr FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_Description(const FunctionSignature_Description& from); + FunctionSignature_Description(FunctionSignature_Description&& from) noexcept + : FunctionSignature_Description() { + *this = ::std::move(from); + } + + inline FunctionSignature_Description& operator=(const FunctionSignature_Description& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_Description& operator=(FunctionSignature_Description&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_Description& default_instance() { + return *internal_default_instance(); + } + static inline const FunctionSignature_Description* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_Description_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(FunctionSignature_Description& a, FunctionSignature_Description& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_Description* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_Description* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_Description* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_Description* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_Description& from); + void MergeFrom(const FunctionSignature_Description& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_Description* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.Description"; + } + protected: + explicit FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLanguageFieldNumber = 1, + kBodyFieldNumber = 2, + }; + // string language = 1; + void clear_language(); + const std::string& language() const; + template + void set_language(ArgT0&& arg0, ArgT... args); + std::string* mutable_language(); + std::string* release_language(); + void set_allocated_language(std::string* language); + private: + const std::string& _internal_language() const; + void _internal_set_language(const std::string& value); + std::string* _internal_mutable_language(); + public: + + // string body = 2; + void clear_body(); + const std::string& body() const; + template + void set_body(ArgT0&& arg0, ArgT... args); + std::string* mutable_body(); + std::string* release_body(); + void set_allocated_body(std::string* body); + private: + const std::string& _internal_body() const; + void _internal_set_body(const std::string& value); + std::string* _internal_mutable_body(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Description) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr language_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature_Implementation PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Implementation) */ { + public: + inline FunctionSignature_Implementation() : FunctionSignature_Implementation(nullptr) {} + ~FunctionSignature_Implementation() override; + explicit constexpr FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_Implementation(const FunctionSignature_Implementation& from); + FunctionSignature_Implementation(FunctionSignature_Implementation&& from) noexcept + : FunctionSignature_Implementation() { + *this = ::std::move(from); + } + + inline FunctionSignature_Implementation& operator=(const FunctionSignature_Implementation& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_Implementation& operator=(FunctionSignature_Implementation&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_Implementation& default_instance() { + return *internal_default_instance(); + } + static inline const FunctionSignature_Implementation* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_Implementation_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(FunctionSignature_Implementation& a, FunctionSignature_Implementation& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_Implementation* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_Implementation* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_Implementation* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_Implementation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_Implementation& from); + void MergeFrom(const FunctionSignature_Implementation& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_Implementation* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.Implementation"; + } + protected: + explicit FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef FunctionSignature_Implementation_Type Type; + static constexpr Type UNKNOWN = + FunctionSignature_Implementation_Type_UNKNOWN; + static constexpr Type WEB_ASSEMBLY = + FunctionSignature_Implementation_Type_WEB_ASSEMBLY; + static constexpr Type TRINO_JAR = + FunctionSignature_Implementation_Type_TRINO_JAR; + static inline bool Type_IsValid(int value) { + return FunctionSignature_Implementation_Type_IsValid(value); + } + static constexpr Type Type_MIN = + FunctionSignature_Implementation_Type_Type_MIN; + static constexpr Type Type_MAX = + FunctionSignature_Implementation_Type_Type_MAX; + static constexpr int Type_ARRAYSIZE = + FunctionSignature_Implementation_Type_Type_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Type_descriptor() { + return FunctionSignature_Implementation_Type_descriptor(); + } + template + static inline const std::string& Type_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Type_Name."); + return FunctionSignature_Implementation_Type_Name(enum_t_value); + } + static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Type* value) { + return FunctionSignature_Implementation_Type_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kUriFieldNumber = 2, + kTypeFieldNumber = 1, + }; + // string uri = 2; + void clear_uri(); + const std::string& uri() const; + template + void set_uri(ArgT0&& arg0, ArgT... args); + std::string* mutable_uri(); + std::string* release_uri(); + void set_allocated_uri(std::string* uri); + private: + const std::string& _internal_uri() const; + void _internal_set_uri(const std::string& value); + std::string* _internal_mutable_uri(); + public: + + // .io.substrait.FunctionSignature.Implementation.Type type = 1; + void clear_type(); + ::io::substrait::FunctionSignature_Implementation_Type type() const; + void set_type(::io::substrait::FunctionSignature_Implementation_Type value); + private: + ::io::substrait::FunctionSignature_Implementation_Type _internal_type() const; + void _internal_set_type(::io::substrait::FunctionSignature_Implementation_Type value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Implementation) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; + int type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Argument.ValueArgument) */ { + public: + inline FunctionSignature_Argument_ValueArgument() : FunctionSignature_Argument_ValueArgument(nullptr) {} + ~FunctionSignature_Argument_ValueArgument() override; + explicit constexpr FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_Argument_ValueArgument(const FunctionSignature_Argument_ValueArgument& from); + FunctionSignature_Argument_ValueArgument(FunctionSignature_Argument_ValueArgument&& from) noexcept + : FunctionSignature_Argument_ValueArgument() { + *this = ::std::move(from); + } + + inline FunctionSignature_Argument_ValueArgument& operator=(const FunctionSignature_Argument_ValueArgument& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_Argument_ValueArgument& operator=(FunctionSignature_Argument_ValueArgument&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_Argument_ValueArgument& default_instance() { + return *internal_default_instance(); + } + static inline const FunctionSignature_Argument_ValueArgument* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_Argument_ValueArgument_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(FunctionSignature_Argument_ValueArgument& a, FunctionSignature_Argument_ValueArgument& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_Argument_ValueArgument* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_Argument_ValueArgument* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_Argument_ValueArgument* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_Argument_ValueArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_Argument_ValueArgument& from); + void MergeFrom(const FunctionSignature_Argument_ValueArgument& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_Argument_ValueArgument* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.Argument.ValueArgument"; + } + protected: + explicit FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTypeFieldNumber = 1, + kConstantFieldNumber = 2, + }; + // .io.substrait.ParameterizedType type = 1; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + const ::io::substrait::ParameterizedType& type() const; + ::io::substrait::ParameterizedType* release_type(); + ::io::substrait::ParameterizedType* mutable_type(); + void set_allocated_type(::io::substrait::ParameterizedType* type); + private: + const ::io::substrait::ParameterizedType& _internal_type() const; + ::io::substrait::ParameterizedType* _internal_mutable_type(); + public: + void unsafe_arena_set_allocated_type( + ::io::substrait::ParameterizedType* type); + ::io::substrait::ParameterizedType* unsafe_arena_release_type(); + + // bool constant = 2; + void clear_constant(); + bool constant() const; + void set_constant(bool value); + private: + bool _internal_constant() const; + void _internal_set_constant(bool value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Argument.ValueArgument) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ParameterizedType* type_; + bool constant_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature_Argument_TypeArgument PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Argument.TypeArgument) */ { + public: + inline FunctionSignature_Argument_TypeArgument() : FunctionSignature_Argument_TypeArgument(nullptr) {} + ~FunctionSignature_Argument_TypeArgument() override; + explicit constexpr FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_Argument_TypeArgument(const FunctionSignature_Argument_TypeArgument& from); + FunctionSignature_Argument_TypeArgument(FunctionSignature_Argument_TypeArgument&& from) noexcept + : FunctionSignature_Argument_TypeArgument() { + *this = ::std::move(from); + } + + inline FunctionSignature_Argument_TypeArgument& operator=(const FunctionSignature_Argument_TypeArgument& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_Argument_TypeArgument& operator=(FunctionSignature_Argument_TypeArgument&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_Argument_TypeArgument& default_instance() { + return *internal_default_instance(); + } + static inline const FunctionSignature_Argument_TypeArgument* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_Argument_TypeArgument_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(FunctionSignature_Argument_TypeArgument& a, FunctionSignature_Argument_TypeArgument& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_Argument_TypeArgument* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_Argument_TypeArgument* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_Argument_TypeArgument* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_Argument_TypeArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_Argument_TypeArgument& from); + void MergeFrom(const FunctionSignature_Argument_TypeArgument& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_Argument_TypeArgument* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.Argument.TypeArgument"; + } + protected: + explicit FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTypeFieldNumber = 1, + }; + // .io.substrait.ParameterizedType type = 1; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + const ::io::substrait::ParameterizedType& type() const; + ::io::substrait::ParameterizedType* release_type(); + ::io::substrait::ParameterizedType* mutable_type(); + void set_allocated_type(::io::substrait::ParameterizedType* type); + private: + const ::io::substrait::ParameterizedType& _internal_type() const; + ::io::substrait::ParameterizedType* _internal_mutable_type(); + public: + void unsafe_arena_set_allocated_type( + ::io::substrait::ParameterizedType* type); + ::io::substrait::ParameterizedType* unsafe_arena_release_type(); + + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Argument.TypeArgument) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ParameterizedType* type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature_Argument_EnumArgument PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Argument.EnumArgument) */ { + public: + inline FunctionSignature_Argument_EnumArgument() : FunctionSignature_Argument_EnumArgument(nullptr) {} + ~FunctionSignature_Argument_EnumArgument() override; + explicit constexpr FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_Argument_EnumArgument(const FunctionSignature_Argument_EnumArgument& from); + FunctionSignature_Argument_EnumArgument(FunctionSignature_Argument_EnumArgument&& from) noexcept + : FunctionSignature_Argument_EnumArgument() { + *this = ::std::move(from); + } + + inline FunctionSignature_Argument_EnumArgument& operator=(const FunctionSignature_Argument_EnumArgument& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_Argument_EnumArgument& operator=(FunctionSignature_Argument_EnumArgument&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_Argument_EnumArgument& default_instance() { + return *internal_default_instance(); + } + static inline const FunctionSignature_Argument_EnumArgument* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_Argument_EnumArgument_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(FunctionSignature_Argument_EnumArgument& a, FunctionSignature_Argument_EnumArgument& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_Argument_EnumArgument* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_Argument_EnumArgument* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_Argument_EnumArgument* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_Argument_EnumArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_Argument_EnumArgument& from); + void MergeFrom(const FunctionSignature_Argument_EnumArgument& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_Argument_EnumArgument* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.Argument.EnumArgument"; + } + protected: + explicit FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOptionsFieldNumber = 1, + kOptionalFieldNumber = 2, + }; + // repeated string options = 1; + int options_size() const; + private: + int _internal_options_size() const; + public: + void clear_options(); + const std::string& options(int index) const; + std::string* mutable_options(int index); + void set_options(int index, const std::string& value); + void set_options(int index, std::string&& value); + void set_options(int index, const char* value); + void set_options(int index, const char* value, size_t size); + std::string* add_options(); + void add_options(const std::string& value); + void add_options(std::string&& value); + void add_options(const char* value); + void add_options(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& options() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_options(); + private: + const std::string& _internal_options(int index) const; + std::string* _internal_add_options(); + public: + + // bool optional = 2; + void clear_optional(); + bool optional() const; + void set_optional(bool value); + private: + bool _internal_optional() const; + void _internal_set_optional(bool value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Argument.EnumArgument) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField options_; + bool optional_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature_Argument PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Argument) */ { + public: + inline FunctionSignature_Argument() : FunctionSignature_Argument(nullptr) {} + ~FunctionSignature_Argument() override; + explicit constexpr FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature_Argument(const FunctionSignature_Argument& from); + FunctionSignature_Argument(FunctionSignature_Argument&& from) noexcept + : FunctionSignature_Argument() { + *this = ::std::move(from); + } + + inline FunctionSignature_Argument& operator=(const FunctionSignature_Argument& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature_Argument& operator=(FunctionSignature_Argument&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature_Argument& default_instance() { + return *internal_default_instance(); + } + enum ArgumentKindCase { + kValue = 2, + kType = 3, + kEnum = 4, + ARGUMENT_KIND_NOT_SET = 0, + }; + + static inline const FunctionSignature_Argument* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_Argument_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(FunctionSignature_Argument& a, FunctionSignature_Argument& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature_Argument* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature_Argument* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature_Argument* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature_Argument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature_Argument& from); + void MergeFrom(const FunctionSignature_Argument& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature_Argument* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature.Argument"; + } + protected: + explicit FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef FunctionSignature_Argument_ValueArgument ValueArgument; + typedef FunctionSignature_Argument_TypeArgument TypeArgument; + typedef FunctionSignature_Argument_EnumArgument EnumArgument; + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kValueFieldNumber = 2, + kTypeFieldNumber = 3, + kEnumFieldNumber = 4, + }; + // string name = 1; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // .io.substrait.FunctionSignature.Argument.ValueArgument value = 2; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + const ::io::substrait::FunctionSignature_Argument_ValueArgument& value() const; + ::io::substrait::FunctionSignature_Argument_ValueArgument* release_value(); + ::io::substrait::FunctionSignature_Argument_ValueArgument* mutable_value(); + void set_allocated_value(::io::substrait::FunctionSignature_Argument_ValueArgument* value); + private: + const ::io::substrait::FunctionSignature_Argument_ValueArgument& _internal_value() const; + ::io::substrait::FunctionSignature_Argument_ValueArgument* _internal_mutable_value(); + public: + void unsafe_arena_set_allocated_value( + ::io::substrait::FunctionSignature_Argument_ValueArgument* value); + ::io::substrait::FunctionSignature_Argument_ValueArgument* unsafe_arena_release_value(); + + // .io.substrait.FunctionSignature.Argument.TypeArgument type = 3; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + const ::io::substrait::FunctionSignature_Argument_TypeArgument& type() const; + ::io::substrait::FunctionSignature_Argument_TypeArgument* release_type(); + ::io::substrait::FunctionSignature_Argument_TypeArgument* mutable_type(); + void set_allocated_type(::io::substrait::FunctionSignature_Argument_TypeArgument* type); + private: + const ::io::substrait::FunctionSignature_Argument_TypeArgument& _internal_type() const; + ::io::substrait::FunctionSignature_Argument_TypeArgument* _internal_mutable_type(); + public: + void unsafe_arena_set_allocated_type( + ::io::substrait::FunctionSignature_Argument_TypeArgument* type); + ::io::substrait::FunctionSignature_Argument_TypeArgument* unsafe_arena_release_type(); + + // .io.substrait.FunctionSignature.Argument.EnumArgument enum = 4; + bool has_enum_() const; + private: + bool _internal_has_enum_() const; + public: + void clear_enum_(); + const ::io::substrait::FunctionSignature_Argument_EnumArgument& enum_() const; + ::io::substrait::FunctionSignature_Argument_EnumArgument* release_enum_(); + ::io::substrait::FunctionSignature_Argument_EnumArgument* mutable_enum_(); + void set_allocated_enum_(::io::substrait::FunctionSignature_Argument_EnumArgument* enum_); + private: + const ::io::substrait::FunctionSignature_Argument_EnumArgument& _internal_enum_() const; + ::io::substrait::FunctionSignature_Argument_EnumArgument* _internal_mutable_enum_(); + public: + void unsafe_arena_set_allocated_enum_( + ::io::substrait::FunctionSignature_Argument_EnumArgument* enum_); + ::io::substrait::FunctionSignature_Argument_EnumArgument* unsafe_arena_release_enum_(); + + void clear_argument_kind(); + ArgumentKindCase argument_kind_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Argument) + private: + class _Internal; + void set_has_value(); + void set_has_type(); + void set_has_enum_(); + + inline bool has_argument_kind() const; + inline void clear_has_argument_kind(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + union ArgumentKindUnion { + constexpr ArgumentKindUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::FunctionSignature_Argument_ValueArgument* value_; + ::io::substrait::FunctionSignature_Argument_TypeArgument* type_; + ::io::substrait::FunctionSignature_Argument_EnumArgument* enum__; + } argument_kind_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_function_2eproto; +}; +// ------------------------------------------------------------------- + +class FunctionSignature PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature) */ { + public: + inline FunctionSignature() : FunctionSignature(nullptr) {} + ~FunctionSignature() override; + explicit constexpr FunctionSignature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FunctionSignature(const FunctionSignature& from); + FunctionSignature(FunctionSignature&& from) noexcept + : FunctionSignature() { + *this = ::std::move(from); + } + + inline FunctionSignature& operator=(const FunctionSignature& from) { + CopyFrom(from); + return *this; + } + inline FunctionSignature& operator=(FunctionSignature&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FunctionSignature& default_instance() { + return *internal_default_instance(); + } + static inline const FunctionSignature* internal_default_instance() { + return reinterpret_cast( + &_FunctionSignature_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(FunctionSignature& a, FunctionSignature& b) { + a.Swap(&b); + } + inline void Swap(FunctionSignature* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FunctionSignature* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FunctionSignature* New() const final { + return CreateMaybeMessage(nullptr); + } + + FunctionSignature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FunctionSignature& from); + void MergeFrom(const FunctionSignature& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FunctionSignature* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FunctionSignature"; + } + protected: + explicit FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef FunctionSignature_FinalArgVariadic FinalArgVariadic; + typedef FunctionSignature_FinalArgNormal FinalArgNormal; + typedef FunctionSignature_Scalar Scalar; + typedef FunctionSignature_Aggregate Aggregate; + typedef FunctionSignature_Window Window; + typedef FunctionSignature_Description Description; + typedef FunctionSignature_Implementation Implementation; + typedef FunctionSignature_Argument Argument; + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_function_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// FunctionSignature_FinalArgVariadic + +// int64 min_args = 1; +inline void FunctionSignature_FinalArgVariadic::clear_min_args() { + min_args_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::_internal_min_args() const { + return min_args_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::min_args() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.FinalArgVariadic.min_args) + return _internal_min_args(); +} +inline void FunctionSignature_FinalArgVariadic::_internal_set_min_args(::PROTOBUF_NAMESPACE_ID::int64 value) { + + min_args_ = value; +} +inline void FunctionSignature_FinalArgVariadic::set_min_args(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_min_args(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.FinalArgVariadic.min_args) +} + +// int64 max_args = 2; +inline void FunctionSignature_FinalArgVariadic::clear_max_args() { + max_args_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::_internal_max_args() const { + return max_args_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::max_args() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.FinalArgVariadic.max_args) + return _internal_max_args(); +} +inline void FunctionSignature_FinalArgVariadic::_internal_set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value) { + + max_args_ = value; +} +inline void FunctionSignature_FinalArgVariadic::set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_max_args(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.FinalArgVariadic.max_args) +} + +// .io.substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; +inline void FunctionSignature_FinalArgVariadic::clear_consistency() { + consistency_ = 0; +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::_internal_consistency() const { + return static_cast< ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency >(consistency_); +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::consistency() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.FinalArgVariadic.consistency) + return _internal_consistency(); +} +inline void FunctionSignature_FinalArgVariadic::_internal_set_consistency(::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) { + + consistency_ = value; +} +inline void FunctionSignature_FinalArgVariadic::set_consistency(::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) { + _internal_set_consistency(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.FinalArgVariadic.consistency) +} + +// ------------------------------------------------------------------- + +// FunctionSignature_FinalArgNormal + +// ------------------------------------------------------------------- + +// FunctionSignature_Scalar + +// .io.substrait.Extensions.FunctionId id = 1; +inline bool FunctionSignature_Scalar::_internal_has_id() const { + return this != internal_default_instance() && id_ != nullptr; +} +inline bool FunctionSignature_Scalar::has_id() const { + return _internal_has_id(); +} +inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Scalar::_internal_id() const { + const ::io::substrait::Extensions_FunctionId* p = id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_FunctionId_default_instance_); +} +inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Scalar::id() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.id) + return _internal_id(); +} +inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + id_ = id; + if (id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Scalar.id) +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Scalar::release_id() { + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Scalar::unsafe_arena_release_id() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Scalar.id) + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Scalar::_internal_mutable_id() { + + if (id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); + id_ = p; + } + return id_; +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Scalar::mutable_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.id) + return _internal_mutable_id(); +} +inline void FunctionSignature_Scalar::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + if (id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); + if (message_arena != submessage_arena) { + id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, id, submessage_arena); + } + + } else { + + } + id_ = id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Scalar.id) +} + +// repeated .io.substrait.FunctionSignature.Argument arguments = 2; +inline int FunctionSignature_Scalar::_internal_arguments_size() const { + return arguments_.size(); +} +inline int FunctionSignature_Scalar::arguments_size() const { + return _internal_arguments_size(); +} +inline void FunctionSignature_Scalar::clear_arguments() { + arguments_.Clear(); +} +inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::mutable_arguments(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.arguments) + return arguments_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* +FunctionSignature_Scalar::mutable_arguments() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Scalar.arguments) + return &arguments_; +} +inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::_internal_arguments(int index) const { + return arguments_.Get(index); +} +inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::arguments(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.arguments) + return _internal_arguments(index); +} +inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::_internal_add_arguments() { + return arguments_.Add(); +} +inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::add_arguments() { + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Scalar.arguments) + return _internal_add_arguments(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& +FunctionSignature_Scalar::arguments() const { + // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Scalar.arguments) + return arguments_; +} + +// repeated string name = 3; +inline int FunctionSignature_Scalar::_internal_name_size() const { + return name_.size(); +} +inline int FunctionSignature_Scalar::name_size() const { + return _internal_name_size(); +} +inline void FunctionSignature_Scalar::clear_name() { + name_.Clear(); +} +inline std::string* FunctionSignature_Scalar::add_name() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.FunctionSignature.Scalar.name) + return _internal_add_name(); +} +inline const std::string& FunctionSignature_Scalar::_internal_name(int index) const { + return name_.Get(index); +} +inline const std::string& FunctionSignature_Scalar::name(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.name) + return _internal_name(index); +} +inline std::string* FunctionSignature_Scalar::mutable_name(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.name) + return name_.Mutable(index); +} +inline void FunctionSignature_Scalar::set_name(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Scalar.name) + name_.Mutable(index)->assign(value); +} +inline void FunctionSignature_Scalar::set_name(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Scalar.name) + name_.Mutable(index)->assign(std::move(value)); +} +inline void FunctionSignature_Scalar::set_name(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + name_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.FunctionSignature.Scalar.name) +} +inline void FunctionSignature_Scalar::set_name(int index, const char* value, size_t size) { + name_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.FunctionSignature.Scalar.name) +} +inline std::string* FunctionSignature_Scalar::_internal_add_name() { + return name_.Add(); +} +inline void FunctionSignature_Scalar::add_name(const std::string& value) { + name_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Scalar.name) +} +inline void FunctionSignature_Scalar::add_name(std::string&& value) { + name_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Scalar.name) +} +inline void FunctionSignature_Scalar::add_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + name_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.FunctionSignature.Scalar.name) +} +inline void FunctionSignature_Scalar::add_name(const char* value, size_t size) { + name_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.FunctionSignature.Scalar.name) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +FunctionSignature_Scalar::name() const { + // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Scalar.name) + return name_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +FunctionSignature_Scalar::mutable_name() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Scalar.name) + return &name_; +} + +// .io.substrait.FunctionSignature.Description description = 4; +inline bool FunctionSignature_Scalar::_internal_has_description() const { + return this != internal_default_instance() && description_ != nullptr; +} +inline bool FunctionSignature_Scalar::has_description() const { + return _internal_has_description(); +} +inline void FunctionSignature_Scalar::clear_description() { + if (GetArena() == nullptr && description_ != nullptr) { + delete description_; + } + description_ = nullptr; +} +inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Scalar::_internal_description() const { + const ::io::substrait::FunctionSignature_Description* p = description_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_FunctionSignature_Description_default_instance_); +} +inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Scalar::description() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.description) + return _internal_description(); +} +inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_description( + ::io::substrait::FunctionSignature_Description* description) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); + } + description_ = description; + if (description) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Scalar.description) +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Scalar::release_description() { + + ::io::substrait::FunctionSignature_Description* temp = description_; + description_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Scalar::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Scalar.description) + + ::io::substrait::FunctionSignature_Description* temp = description_; + description_ = nullptr; + return temp; +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Scalar::_internal_mutable_description() { + + if (description_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::FunctionSignature_Description>(GetArena()); + description_ = p; + } + return description_; +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Scalar::mutable_description() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.description) + return _internal_mutable_description(); +} +inline void FunctionSignature_Scalar::set_allocated_description(::io::substrait::FunctionSignature_Description* description) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete description_; + } + if (description) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(description); + if (message_arena != submessage_arena) { + description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, description, submessage_arena); + } + + } else { + + } + description_ = description; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Scalar.description) +} + +// bool deterministic = 7; +inline void FunctionSignature_Scalar::clear_deterministic() { + deterministic_ = false; +} +inline bool FunctionSignature_Scalar::_internal_deterministic() const { + return deterministic_; +} +inline bool FunctionSignature_Scalar::deterministic() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.deterministic) + return _internal_deterministic(); +} +inline void FunctionSignature_Scalar::_internal_set_deterministic(bool value) { + + deterministic_ = value; +} +inline void FunctionSignature_Scalar::set_deterministic(bool value) { + _internal_set_deterministic(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Scalar.deterministic) +} + +// bool session_dependent = 8; +inline void FunctionSignature_Scalar::clear_session_dependent() { + session_dependent_ = false; +} +inline bool FunctionSignature_Scalar::_internal_session_dependent() const { + return session_dependent_; +} +inline bool FunctionSignature_Scalar::session_dependent() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.session_dependent) + return _internal_session_dependent(); +} +inline void FunctionSignature_Scalar::_internal_set_session_dependent(bool value) { + + session_dependent_ = value; +} +inline void FunctionSignature_Scalar::set_session_dependent(bool value) { + _internal_set_session_dependent(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Scalar.session_dependent) +} + +// .io.substrait.DerivationExpression output_type = 9; +inline bool FunctionSignature_Scalar::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; +} +inline bool FunctionSignature_Scalar::has_output_type() const { + return _internal_has_output_type(); +} +inline const ::io::substrait::DerivationExpression& FunctionSignature_Scalar::_internal_output_type() const { + const ::io::substrait::DerivationExpression* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& FunctionSignature_Scalar::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.output_type) + return _internal_output_type(); +} +inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_output_type( + ::io::substrait::DerivationExpression* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + output_type_ = output_type; + if (output_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Scalar.output_type) +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Scalar::release_output_type() { + + ::io::substrait::DerivationExpression* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Scalar::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Scalar.output_type) + + ::io::substrait::DerivationExpression* temp = output_type_; + output_type_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Scalar::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + output_type_ = p; + } + return output_type_; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Scalar::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.output_type) + return _internal_mutable_output_type(); +} +inline void FunctionSignature_Scalar::set_allocated_output_type(::io::substrait::DerivationExpression* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); + } + + } else { + + } + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Scalar.output_type) +} + +// .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; +inline bool FunctionSignature_Scalar::_internal_has_variadic() const { + return final_variable_behavior_case() == kVariadic; +} +inline bool FunctionSignature_Scalar::has_variadic() const { + return _internal_has_variadic(); +} +inline void FunctionSignature_Scalar::set_has_variadic() { + _oneof_case_[0] = kVariadic; +} +inline void FunctionSignature_Scalar::clear_variadic() { + if (_internal_has_variadic()) { + if (GetArena() == nullptr) { + delete final_variable_behavior_.variadic_; + } + clear_has_final_variable_behavior(); + } +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::release_variadic() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Scalar.variadic) + if (_internal_has_variadic()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + final_variable_behavior_.variadic_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::_internal_variadic() const { + return _internal_has_variadic() + ? *final_variable_behavior_.variadic_ + : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgVariadic&>(::io::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); +} +inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::variadic() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.variadic) + return _internal_variadic(); +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::unsafe_arena_release_variadic() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Scalar.variadic) + if (_internal_has_variadic()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + final_variable_behavior_.variadic_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { + clear_final_variable_behavior(); + if (variadic) { + set_has_variadic(); + final_variable_behavior_.variadic_ = variadic; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Scalar.variadic) +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::_internal_mutable_variadic() { + if (!_internal_has_variadic()) { + clear_final_variable_behavior(); + set_has_variadic(); + final_variable_behavior_.variadic_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); + } + return final_variable_behavior_.variadic_; +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::mutable_variadic() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.variadic) + return _internal_mutable_variadic(); +} + +// .io.substrait.FunctionSignature.FinalArgNormal normal = 11; +inline bool FunctionSignature_Scalar::_internal_has_normal() const { + return final_variable_behavior_case() == kNormal; +} +inline bool FunctionSignature_Scalar::has_normal() const { + return _internal_has_normal(); +} +inline void FunctionSignature_Scalar::set_has_normal() { + _oneof_case_[0] = kNormal; +} +inline void FunctionSignature_Scalar::clear_normal() { + if (_internal_has_normal()) { + if (GetArena() == nullptr) { + delete final_variable_behavior_.normal_; + } + clear_has_final_variable_behavior(); + } +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::release_normal() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Scalar.normal) + if (_internal_has_normal()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + final_variable_behavior_.normal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::_internal_normal() const { + return _internal_has_normal() + ? *final_variable_behavior_.normal_ + : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgNormal&>(::io::substrait::_FunctionSignature_FinalArgNormal_default_instance_); +} +inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::normal() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.normal) + return _internal_normal(); +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::unsafe_arena_release_normal() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Scalar.normal) + if (_internal_has_normal()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + final_variable_behavior_.normal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { + clear_final_variable_behavior(); + if (normal) { + set_has_normal(); + final_variable_behavior_.normal_ = normal; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Scalar.normal) +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::_internal_mutable_normal() { + if (!_internal_has_normal()) { + clear_final_variable_behavior(); + set_has_normal(); + final_variable_behavior_.normal_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgNormal >(GetArena()); + } + return final_variable_behavior_.normal_; +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::mutable_normal() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.normal) + return _internal_mutable_normal(); +} + +// repeated .io.substrait.FunctionSignature.Implementation implementations = 12; +inline int FunctionSignature_Scalar::_internal_implementations_size() const { + return implementations_.size(); +} +inline int FunctionSignature_Scalar::implementations_size() const { + return _internal_implementations_size(); +} +inline void FunctionSignature_Scalar::clear_implementations() { + implementations_.Clear(); +} +inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::mutable_implementations(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.implementations) + return implementations_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* +FunctionSignature_Scalar::mutable_implementations() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Scalar.implementations) + return &implementations_; +} +inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::_internal_implementations(int index) const { + return implementations_.Get(index); +} +inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::implementations(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.implementations) + return _internal_implementations(index); +} +inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::_internal_add_implementations() { + return implementations_.Add(); +} +inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::add_implementations() { + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Scalar.implementations) + return _internal_add_implementations(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& +FunctionSignature_Scalar::implementations() const { + // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Scalar.implementations) + return implementations_; +} + +inline bool FunctionSignature_Scalar::has_final_variable_behavior() const { + return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET; +} +inline void FunctionSignature_Scalar::clear_has_final_variable_behavior() { + _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; +} +inline FunctionSignature_Scalar::FinalVariableBehaviorCase FunctionSignature_Scalar::final_variable_behavior_case() const { + return FunctionSignature_Scalar::FinalVariableBehaviorCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// FunctionSignature_Aggregate + +// .io.substrait.Extensions.FunctionId id = 1; +inline bool FunctionSignature_Aggregate::_internal_has_id() const { + return this != internal_default_instance() && id_ != nullptr; +} +inline bool FunctionSignature_Aggregate::has_id() const { + return _internal_has_id(); +} +inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Aggregate::_internal_id() const { + const ::io::substrait::Extensions_FunctionId* p = id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_FunctionId_default_instance_); +} +inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Aggregate::id() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.id) + return _internal_id(); +} +inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + id_ = id; + if (id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.id) +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Aggregate::release_id() { + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Aggregate::unsafe_arena_release_id() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.id) + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Aggregate::_internal_mutable_id() { + + if (id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); + id_ = p; + } + return id_; +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Aggregate::mutable_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.id) + return _internal_mutable_id(); +} +inline void FunctionSignature_Aggregate::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + if (id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); + if (message_arena != submessage_arena) { + id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, id, submessage_arena); + } + + } else { + + } + id_ = id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.id) +} + +// repeated .io.substrait.FunctionSignature.Argument arguments = 2; +inline int FunctionSignature_Aggregate::_internal_arguments_size() const { + return arguments_.size(); +} +inline int FunctionSignature_Aggregate::arguments_size() const { + return _internal_arguments_size(); +} +inline void FunctionSignature_Aggregate::clear_arguments() { + arguments_.Clear(); +} +inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::mutable_arguments(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.arguments) + return arguments_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* +FunctionSignature_Aggregate::mutable_arguments() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Aggregate.arguments) + return &arguments_; +} +inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::_internal_arguments(int index) const { + return arguments_.Get(index); +} +inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::arguments(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.arguments) + return _internal_arguments(index); +} +inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::_internal_add_arguments() { + return arguments_.Add(); +} +inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::add_arguments() { + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Aggregate.arguments) + return _internal_add_arguments(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& +FunctionSignature_Aggregate::arguments() const { + // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Aggregate.arguments) + return arguments_; +} + +// repeated string name = 3; +inline int FunctionSignature_Aggregate::_internal_name_size() const { + return name_.size(); +} +inline int FunctionSignature_Aggregate::name_size() const { + return _internal_name_size(); +} +inline void FunctionSignature_Aggregate::clear_name() { + name_.Clear(); +} +inline std::string* FunctionSignature_Aggregate::add_name() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.FunctionSignature.Aggregate.name) + return _internal_add_name(); +} +inline const std::string& FunctionSignature_Aggregate::_internal_name(int index) const { + return name_.Get(index); +} +inline const std::string& FunctionSignature_Aggregate::name(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.name) + return _internal_name(index); +} +inline std::string* FunctionSignature_Aggregate::mutable_name(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.name) + return name_.Mutable(index); +} +inline void FunctionSignature_Aggregate::set_name(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.name) + name_.Mutable(index)->assign(value); +} +inline void FunctionSignature_Aggregate::set_name(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.name) + name_.Mutable(index)->assign(std::move(value)); +} +inline void FunctionSignature_Aggregate::set_name(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + name_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.FunctionSignature.Aggregate.name) +} +inline void FunctionSignature_Aggregate::set_name(int index, const char* value, size_t size) { + name_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.FunctionSignature.Aggregate.name) +} +inline std::string* FunctionSignature_Aggregate::_internal_add_name() { + return name_.Add(); +} +inline void FunctionSignature_Aggregate::add_name(const std::string& value) { + name_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Aggregate.name) +} +inline void FunctionSignature_Aggregate::add_name(std::string&& value) { + name_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Aggregate.name) +} +inline void FunctionSignature_Aggregate::add_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + name_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.FunctionSignature.Aggregate.name) +} +inline void FunctionSignature_Aggregate::add_name(const char* value, size_t size) { + name_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.FunctionSignature.Aggregate.name) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +FunctionSignature_Aggregate::name() const { + // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Aggregate.name) + return name_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +FunctionSignature_Aggregate::mutable_name() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Aggregate.name) + return &name_; +} + +// .io.substrait.FunctionSignature.Description description = 4; +inline bool FunctionSignature_Aggregate::_internal_has_description() const { + return this != internal_default_instance() && description_ != nullptr; +} +inline bool FunctionSignature_Aggregate::has_description() const { + return _internal_has_description(); +} +inline void FunctionSignature_Aggregate::clear_description() { + if (GetArena() == nullptr && description_ != nullptr) { + delete description_; + } + description_ = nullptr; +} +inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::_internal_description() const { + const ::io::substrait::FunctionSignature_Description* p = description_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_FunctionSignature_Description_default_instance_); +} +inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::description() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.description) + return _internal_description(); +} +inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_description( + ::io::substrait::FunctionSignature_Description* description) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); + } + description_ = description; + if (description) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.description) +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::release_description() { + + ::io::substrait::FunctionSignature_Description* temp = description_; + description_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.description) + + ::io::substrait::FunctionSignature_Description* temp = description_; + description_ = nullptr; + return temp; +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::_internal_mutable_description() { + + if (description_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::FunctionSignature_Description>(GetArena()); + description_ = p; + } + return description_; +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::mutable_description() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.description) + return _internal_mutable_description(); +} +inline void FunctionSignature_Aggregate::set_allocated_description(::io::substrait::FunctionSignature_Description* description) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete description_; + } + if (description) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(description); + if (message_arena != submessage_arena) { + description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, description, submessage_arena); + } + + } else { + + } + description_ = description; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.description) +} + +// bool deterministic = 7; +inline void FunctionSignature_Aggregate::clear_deterministic() { + deterministic_ = false; +} +inline bool FunctionSignature_Aggregate::_internal_deterministic() const { + return deterministic_; +} +inline bool FunctionSignature_Aggregate::deterministic() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.deterministic) + return _internal_deterministic(); +} +inline void FunctionSignature_Aggregate::_internal_set_deterministic(bool value) { + + deterministic_ = value; +} +inline void FunctionSignature_Aggregate::set_deterministic(bool value) { + _internal_set_deterministic(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.deterministic) +} + +// bool session_dependent = 8; +inline void FunctionSignature_Aggregate::clear_session_dependent() { + session_dependent_ = false; +} +inline bool FunctionSignature_Aggregate::_internal_session_dependent() const { + return session_dependent_; +} +inline bool FunctionSignature_Aggregate::session_dependent() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.session_dependent) + return _internal_session_dependent(); +} +inline void FunctionSignature_Aggregate::_internal_set_session_dependent(bool value) { + + session_dependent_ = value; +} +inline void FunctionSignature_Aggregate::set_session_dependent(bool value) { + _internal_set_session_dependent(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.session_dependent) +} + +// .io.substrait.DerivationExpression output_type = 9; +inline bool FunctionSignature_Aggregate::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; +} +inline bool FunctionSignature_Aggregate::has_output_type() const { + return _internal_has_output_type(); +} +inline const ::io::substrait::DerivationExpression& FunctionSignature_Aggregate::_internal_output_type() const { + const ::io::substrait::DerivationExpression* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& FunctionSignature_Aggregate::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.output_type) + return _internal_output_type(); +} +inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_output_type( + ::io::substrait::DerivationExpression* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + output_type_ = output_type; + if (output_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.output_type) +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Aggregate::release_output_type() { + + ::io::substrait::DerivationExpression* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Aggregate::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.output_type) + + ::io::substrait::DerivationExpression* temp = output_type_; + output_type_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Aggregate::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + output_type_ = p; + } + return output_type_; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Aggregate::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.output_type) + return _internal_mutable_output_type(); +} +inline void FunctionSignature_Aggregate::set_allocated_output_type(::io::substrait::DerivationExpression* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); + } + + } else { + + } + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.output_type) +} + +// .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; +inline bool FunctionSignature_Aggregate::_internal_has_variadic() const { + return final_variable_behavior_case() == kVariadic; +} +inline bool FunctionSignature_Aggregate::has_variadic() const { + return _internal_has_variadic(); +} +inline void FunctionSignature_Aggregate::set_has_variadic() { + _oneof_case_[0] = kVariadic; +} +inline void FunctionSignature_Aggregate::clear_variadic() { + if (_internal_has_variadic()) { + if (GetArena() == nullptr) { + delete final_variable_behavior_.variadic_; + } + clear_has_final_variable_behavior(); + } +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::release_variadic() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.variadic) + if (_internal_has_variadic()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + final_variable_behavior_.variadic_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::_internal_variadic() const { + return _internal_has_variadic() + ? *final_variable_behavior_.variadic_ + : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgVariadic&>(::io::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); +} +inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::variadic() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.variadic) + return _internal_variadic(); +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::unsafe_arena_release_variadic() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Aggregate.variadic) + if (_internal_has_variadic()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + final_variable_behavior_.variadic_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { + clear_final_variable_behavior(); + if (variadic) { + set_has_variadic(); + final_variable_behavior_.variadic_ = variadic; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.variadic) +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::_internal_mutable_variadic() { + if (!_internal_has_variadic()) { + clear_final_variable_behavior(); + set_has_variadic(); + final_variable_behavior_.variadic_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); + } + return final_variable_behavior_.variadic_; +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::mutable_variadic() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.variadic) + return _internal_mutable_variadic(); +} + +// .io.substrait.FunctionSignature.FinalArgNormal normal = 11; +inline bool FunctionSignature_Aggregate::_internal_has_normal() const { + return final_variable_behavior_case() == kNormal; +} +inline bool FunctionSignature_Aggregate::has_normal() const { + return _internal_has_normal(); +} +inline void FunctionSignature_Aggregate::set_has_normal() { + _oneof_case_[0] = kNormal; +} +inline void FunctionSignature_Aggregate::clear_normal() { + if (_internal_has_normal()) { + if (GetArena() == nullptr) { + delete final_variable_behavior_.normal_; + } + clear_has_final_variable_behavior(); + } +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::release_normal() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.normal) + if (_internal_has_normal()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + final_variable_behavior_.normal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::_internal_normal() const { + return _internal_has_normal() + ? *final_variable_behavior_.normal_ + : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgNormal&>(::io::substrait::_FunctionSignature_FinalArgNormal_default_instance_); +} +inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::normal() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.normal) + return _internal_normal(); +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::unsafe_arena_release_normal() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Aggregate.normal) + if (_internal_has_normal()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + final_variable_behavior_.normal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { + clear_final_variable_behavior(); + if (normal) { + set_has_normal(); + final_variable_behavior_.normal_ = normal; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.normal) +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::_internal_mutable_normal() { + if (!_internal_has_normal()) { + clear_final_variable_behavior(); + set_has_normal(); + final_variable_behavior_.normal_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgNormal >(GetArena()); + } + return final_variable_behavior_.normal_; +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::mutable_normal() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.normal) + return _internal_mutable_normal(); +} + +// bool ordered = 14; +inline void FunctionSignature_Aggregate::clear_ordered() { + ordered_ = false; +} +inline bool FunctionSignature_Aggregate::_internal_ordered() const { + return ordered_; +} +inline bool FunctionSignature_Aggregate::ordered() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.ordered) + return _internal_ordered(); +} +inline void FunctionSignature_Aggregate::_internal_set_ordered(bool value) { + + ordered_ = value; +} +inline void FunctionSignature_Aggregate::set_ordered(bool value) { + _internal_set_ordered(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.ordered) +} + +// uint64 max_set = 12; +inline void FunctionSignature_Aggregate::clear_max_set() { + max_set_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Aggregate::_internal_max_set() const { + return max_set_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Aggregate::max_set() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.max_set) + return _internal_max_set(); +} +inline void FunctionSignature_Aggregate::_internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + max_set_ = value; +} +inline void FunctionSignature_Aggregate::set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_max_set(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.max_set) +} + +// .io.substrait.Type intermediate_type = 13; +inline bool FunctionSignature_Aggregate::_internal_has_intermediate_type() const { + return this != internal_default_instance() && intermediate_type_ != nullptr; +} +inline bool FunctionSignature_Aggregate::has_intermediate_type() const { + return _internal_has_intermediate_type(); +} +inline const ::io::substrait::Type& FunctionSignature_Aggregate::_internal_intermediate_type() const { + const ::io::substrait::Type* p = intermediate_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& FunctionSignature_Aggregate::intermediate_type() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.intermediate_type) + return _internal_intermediate_type(); +} +inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_intermediate_type( + ::io::substrait::Type* intermediate_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); + } + intermediate_type_ = intermediate_type; + if (intermediate_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.intermediate_type) +} +inline ::io::substrait::Type* FunctionSignature_Aggregate::release_intermediate_type() { + + ::io::substrait::Type* temp = intermediate_type_; + intermediate_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* FunctionSignature_Aggregate::unsafe_arena_release_intermediate_type() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.intermediate_type) + + ::io::substrait::Type* temp = intermediate_type_; + intermediate_type_ = nullptr; + return temp; +} +inline ::io::substrait::Type* FunctionSignature_Aggregate::_internal_mutable_intermediate_type() { + + if (intermediate_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + intermediate_type_ = p; + } + return intermediate_type_; +} +inline ::io::substrait::Type* FunctionSignature_Aggregate::mutable_intermediate_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.intermediate_type) + return _internal_mutable_intermediate_type(); +} +inline void FunctionSignature_Aggregate::set_allocated_intermediate_type(::io::substrait::Type* intermediate_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); + } + if (intermediate_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type)->GetArena(); + if (message_arena != submessage_arena) { + intermediate_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, intermediate_type, submessage_arena); + } + + } else { + + } + intermediate_type_ = intermediate_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.intermediate_type) +} + +// repeated .io.substrait.FunctionSignature.Implementation implementations = 15; +inline int FunctionSignature_Aggregate::_internal_implementations_size() const { + return implementations_.size(); +} +inline int FunctionSignature_Aggregate::implementations_size() const { + return _internal_implementations_size(); +} +inline void FunctionSignature_Aggregate::clear_implementations() { + implementations_.Clear(); +} +inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::mutable_implementations(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.implementations) + return implementations_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* +FunctionSignature_Aggregate::mutable_implementations() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Aggregate.implementations) + return &implementations_; +} +inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::_internal_implementations(int index) const { + return implementations_.Get(index); +} +inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::implementations(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.implementations) + return _internal_implementations(index); +} +inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::_internal_add_implementations() { + return implementations_.Add(); +} +inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::add_implementations() { + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Aggregate.implementations) + return _internal_add_implementations(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& +FunctionSignature_Aggregate::implementations() const { + // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Aggregate.implementations) + return implementations_; +} + +inline bool FunctionSignature_Aggregate::has_final_variable_behavior() const { + return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET; +} +inline void FunctionSignature_Aggregate::clear_has_final_variable_behavior() { + _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; +} +inline FunctionSignature_Aggregate::FinalVariableBehaviorCase FunctionSignature_Aggregate::final_variable_behavior_case() const { + return FunctionSignature_Aggregate::FinalVariableBehaviorCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// FunctionSignature_Window + +// .io.substrait.Extensions.FunctionId id = 1; +inline bool FunctionSignature_Window::_internal_has_id() const { + return this != internal_default_instance() && id_ != nullptr; +} +inline bool FunctionSignature_Window::has_id() const { + return _internal_has_id(); +} +inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Window::_internal_id() const { + const ::io::substrait::Extensions_FunctionId* p = id_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Extensions_FunctionId_default_instance_); +} +inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Window::id() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.id) + return _internal_id(); +} +inline void FunctionSignature_Window::unsafe_arena_set_allocated_id( + ::io::substrait::Extensions_FunctionId* id) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + id_ = id; + if (id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.id) +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Window::release_id() { + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Window::unsafe_arena_release_id() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.id) + + ::io::substrait::Extensions_FunctionId* temp = id_; + id_ = nullptr; + return temp; +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Window::_internal_mutable_id() { + + if (id_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); + id_ = p; + } + return id_; +} +inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Window::mutable_id() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.id) + return _internal_mutable_id(); +} +inline void FunctionSignature_Window::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + } + if (id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); + if (message_arena != submessage_arena) { + id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, id, submessage_arena); + } + + } else { + + } + id_ = id; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.id) +} + +// repeated .io.substrait.FunctionSignature.Argument arguments = 2; +inline int FunctionSignature_Window::_internal_arguments_size() const { + return arguments_.size(); +} +inline int FunctionSignature_Window::arguments_size() const { + return _internal_arguments_size(); +} +inline void FunctionSignature_Window::clear_arguments() { + arguments_.Clear(); +} +inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Window::mutable_arguments(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.arguments) + return arguments_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* +FunctionSignature_Window::mutable_arguments() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Window.arguments) + return &arguments_; +} +inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Window::_internal_arguments(int index) const { + return arguments_.Get(index); +} +inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Window::arguments(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.arguments) + return _internal_arguments(index); +} +inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Window::_internal_add_arguments() { + return arguments_.Add(); +} +inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Window::add_arguments() { + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Window.arguments) + return _internal_add_arguments(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& +FunctionSignature_Window::arguments() const { + // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Window.arguments) + return arguments_; +} + +// repeated string name = 3; +inline int FunctionSignature_Window::_internal_name_size() const { + return name_.size(); +} +inline int FunctionSignature_Window::name_size() const { + return _internal_name_size(); +} +inline void FunctionSignature_Window::clear_name() { + name_.Clear(); +} +inline std::string* FunctionSignature_Window::add_name() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.FunctionSignature.Window.name) + return _internal_add_name(); +} +inline const std::string& FunctionSignature_Window::_internal_name(int index) const { + return name_.Get(index); +} +inline const std::string& FunctionSignature_Window::name(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.name) + return _internal_name(index); +} +inline std::string* FunctionSignature_Window::mutable_name(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.name) + return name_.Mutable(index); +} +inline void FunctionSignature_Window::set_name(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.name) + name_.Mutable(index)->assign(value); +} +inline void FunctionSignature_Window::set_name(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.name) + name_.Mutable(index)->assign(std::move(value)); +} +inline void FunctionSignature_Window::set_name(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + name_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.FunctionSignature.Window.name) +} +inline void FunctionSignature_Window::set_name(int index, const char* value, size_t size) { + name_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.FunctionSignature.Window.name) +} +inline std::string* FunctionSignature_Window::_internal_add_name() { + return name_.Add(); +} +inline void FunctionSignature_Window::add_name(const std::string& value) { + name_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Window.name) +} +inline void FunctionSignature_Window::add_name(std::string&& value) { + name_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Window.name) +} +inline void FunctionSignature_Window::add_name(const char* value) { + GOOGLE_DCHECK(value != nullptr); + name_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.FunctionSignature.Window.name) +} +inline void FunctionSignature_Window::add_name(const char* value, size_t size) { + name_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.FunctionSignature.Window.name) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +FunctionSignature_Window::name() const { + // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Window.name) + return name_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +FunctionSignature_Window::mutable_name() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Window.name) + return &name_; +} + +// .io.substrait.FunctionSignature.Description description = 4; +inline bool FunctionSignature_Window::_internal_has_description() const { + return this != internal_default_instance() && description_ != nullptr; +} +inline bool FunctionSignature_Window::has_description() const { + return _internal_has_description(); +} +inline void FunctionSignature_Window::clear_description() { + if (GetArena() == nullptr && description_ != nullptr) { + delete description_; + } + description_ = nullptr; +} +inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Window::_internal_description() const { + const ::io::substrait::FunctionSignature_Description* p = description_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_FunctionSignature_Description_default_instance_); +} +inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Window::description() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.description) + return _internal_description(); +} +inline void FunctionSignature_Window::unsafe_arena_set_allocated_description( + ::io::substrait::FunctionSignature_Description* description) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); + } + description_ = description; + if (description) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.description) +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Window::release_description() { + + ::io::substrait::FunctionSignature_Description* temp = description_; + description_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Window::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.description) + + ::io::substrait::FunctionSignature_Description* temp = description_; + description_ = nullptr; + return temp; +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Window::_internal_mutable_description() { + + if (description_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::FunctionSignature_Description>(GetArena()); + description_ = p; + } + return description_; +} +inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Window::mutable_description() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.description) + return _internal_mutable_description(); +} +inline void FunctionSignature_Window::set_allocated_description(::io::substrait::FunctionSignature_Description* description) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete description_; + } + if (description) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(description); + if (message_arena != submessage_arena) { + description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, description, submessage_arena); + } + + } else { + + } + description_ = description; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.description) +} + +// bool deterministic = 7; +inline void FunctionSignature_Window::clear_deterministic() { + deterministic_ = false; +} +inline bool FunctionSignature_Window::_internal_deterministic() const { + return deterministic_; +} +inline bool FunctionSignature_Window::deterministic() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.deterministic) + return _internal_deterministic(); +} +inline void FunctionSignature_Window::_internal_set_deterministic(bool value) { + + deterministic_ = value; +} +inline void FunctionSignature_Window::set_deterministic(bool value) { + _internal_set_deterministic(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.deterministic) +} + +// bool session_dependent = 8; +inline void FunctionSignature_Window::clear_session_dependent() { + session_dependent_ = false; +} +inline bool FunctionSignature_Window::_internal_session_dependent() const { + return session_dependent_; +} +inline bool FunctionSignature_Window::session_dependent() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.session_dependent) + return _internal_session_dependent(); +} +inline void FunctionSignature_Window::_internal_set_session_dependent(bool value) { + + session_dependent_ = value; +} +inline void FunctionSignature_Window::set_session_dependent(bool value) { + _internal_set_session_dependent(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.session_dependent) +} + +// .io.substrait.DerivationExpression intermediate_type = 9; +inline bool FunctionSignature_Window::_internal_has_intermediate_type() const { + return this != internal_default_instance() && intermediate_type_ != nullptr; +} +inline bool FunctionSignature_Window::has_intermediate_type() const { + return _internal_has_intermediate_type(); +} +inline const ::io::substrait::DerivationExpression& FunctionSignature_Window::_internal_intermediate_type() const { + const ::io::substrait::DerivationExpression* p = intermediate_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& FunctionSignature_Window::intermediate_type() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.intermediate_type) + return _internal_intermediate_type(); +} +inline void FunctionSignature_Window::unsafe_arena_set_allocated_intermediate_type( + ::io::substrait::DerivationExpression* intermediate_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); + } + intermediate_type_ = intermediate_type; + if (intermediate_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.intermediate_type) +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Window::release_intermediate_type() { + + ::io::substrait::DerivationExpression* temp = intermediate_type_; + intermediate_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_intermediate_type() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.intermediate_type) + + ::io::substrait::DerivationExpression* temp = intermediate_type_; + intermediate_type_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_intermediate_type() { + + if (intermediate_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + intermediate_type_ = p; + } + return intermediate_type_; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Window::mutable_intermediate_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.intermediate_type) + return _internal_mutable_intermediate_type(); +} +inline void FunctionSignature_Window::set_allocated_intermediate_type(::io::substrait::DerivationExpression* intermediate_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); + } + if (intermediate_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type)->GetArena(); + if (message_arena != submessage_arena) { + intermediate_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, intermediate_type, submessage_arena); + } + + } else { + + } + intermediate_type_ = intermediate_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.intermediate_type) +} + +// .io.substrait.DerivationExpression output_type = 10; +inline bool FunctionSignature_Window::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; +} +inline bool FunctionSignature_Window::has_output_type() const { + return _internal_has_output_type(); +} +inline const ::io::substrait::DerivationExpression& FunctionSignature_Window::_internal_output_type() const { + const ::io::substrait::DerivationExpression* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& FunctionSignature_Window::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.output_type) + return _internal_output_type(); +} +inline void FunctionSignature_Window::unsafe_arena_set_allocated_output_type( + ::io::substrait::DerivationExpression* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + output_type_ = output_type; + if (output_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.output_type) +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Window::release_output_type() { + + ::io::substrait::DerivationExpression* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.output_type) + + ::io::substrait::DerivationExpression* temp = output_type_; + output_type_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + output_type_ = p; + } + return output_type_; +} +inline ::io::substrait::DerivationExpression* FunctionSignature_Window::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.output_type) + return _internal_mutable_output_type(); +} +inline void FunctionSignature_Window::set_allocated_output_type(::io::substrait::DerivationExpression* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); + } + + } else { + + } + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.output_type) +} + +// .io.substrait.FunctionSignature.FinalArgVariadic variadic = 16; +inline bool FunctionSignature_Window::_internal_has_variadic() const { + return final_variable_behavior_case() == kVariadic; +} +inline bool FunctionSignature_Window::has_variadic() const { + return _internal_has_variadic(); +} +inline void FunctionSignature_Window::set_has_variadic() { + _oneof_case_[0] = kVariadic; +} +inline void FunctionSignature_Window::clear_variadic() { + if (_internal_has_variadic()) { + if (GetArena() == nullptr) { + delete final_variable_behavior_.variadic_; + } + clear_has_final_variable_behavior(); + } +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::release_variadic() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.variadic) + if (_internal_has_variadic()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + final_variable_behavior_.variadic_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::_internal_variadic() const { + return _internal_has_variadic() + ? *final_variable_behavior_.variadic_ + : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgVariadic&>(::io::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); +} +inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::variadic() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.variadic) + return _internal_variadic(); +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::unsafe_arena_release_variadic() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Window.variadic) + if (_internal_has_variadic()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + final_variable_behavior_.variadic_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FunctionSignature_Window::unsafe_arena_set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { + clear_final_variable_behavior(); + if (variadic) { + set_has_variadic(); + final_variable_behavior_.variadic_ = variadic; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.variadic) +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::_internal_mutable_variadic() { + if (!_internal_has_variadic()) { + clear_final_variable_behavior(); + set_has_variadic(); + final_variable_behavior_.variadic_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); + } + return final_variable_behavior_.variadic_; +} +inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::mutable_variadic() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.variadic) + return _internal_mutable_variadic(); +} + +// .io.substrait.FunctionSignature.FinalArgNormal normal = 17; +inline bool FunctionSignature_Window::_internal_has_normal() const { + return final_variable_behavior_case() == kNormal; +} +inline bool FunctionSignature_Window::has_normal() const { + return _internal_has_normal(); +} +inline void FunctionSignature_Window::set_has_normal() { + _oneof_case_[0] = kNormal; +} +inline void FunctionSignature_Window::clear_normal() { + if (_internal_has_normal()) { + if (GetArena() == nullptr) { + delete final_variable_behavior_.normal_; + } + clear_has_final_variable_behavior(); + } +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::release_normal() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.normal) + if (_internal_has_normal()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + final_variable_behavior_.normal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::_internal_normal() const { + return _internal_has_normal() + ? *final_variable_behavior_.normal_ + : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgNormal&>(::io::substrait::_FunctionSignature_FinalArgNormal_default_instance_); +} +inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::normal() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.normal) + return _internal_normal(); +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::unsafe_arena_release_normal() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Window.normal) + if (_internal_has_normal()) { + clear_has_final_variable_behavior(); + ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + final_variable_behavior_.normal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FunctionSignature_Window::unsafe_arena_set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { + clear_final_variable_behavior(); + if (normal) { + set_has_normal(); + final_variable_behavior_.normal_ = normal; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.normal) +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::_internal_mutable_normal() { + if (!_internal_has_normal()) { + clear_final_variable_behavior(); + set_has_normal(); + final_variable_behavior_.normal_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgNormal >(GetArena()); + } + return final_variable_behavior_.normal_; +} +inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::mutable_normal() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.normal) + return _internal_mutable_normal(); +} + +// bool ordered = 11; +inline void FunctionSignature_Window::clear_ordered() { + ordered_ = false; +} +inline bool FunctionSignature_Window::_internal_ordered() const { + return ordered_; +} +inline bool FunctionSignature_Window::ordered() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.ordered) + return _internal_ordered(); +} +inline void FunctionSignature_Window::_internal_set_ordered(bool value) { + + ordered_ = value; +} +inline void FunctionSignature_Window::set_ordered(bool value) { + _internal_set_ordered(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.ordered) +} + +// uint64 max_set = 12; +inline void FunctionSignature_Window::clear_max_set() { + max_set_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Window::_internal_max_set() const { + return max_set_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Window::max_set() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.max_set) + return _internal_max_set(); +} +inline void FunctionSignature_Window::_internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + max_set_ = value; +} +inline void FunctionSignature_Window::set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_max_set(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.max_set) +} + +// .io.substrait.FunctionSignature.Window.WindowType window_type = 14; +inline void FunctionSignature_Window::clear_window_type() { + window_type_ = 0; +} +inline ::io::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::_internal_window_type() const { + return static_cast< ::io::substrait::FunctionSignature_Window_WindowType >(window_type_); +} +inline ::io::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::window_type() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.window_type) + return _internal_window_type(); +} +inline void FunctionSignature_Window::_internal_set_window_type(::io::substrait::FunctionSignature_Window_WindowType value) { + + window_type_ = value; +} +inline void FunctionSignature_Window::set_window_type(::io::substrait::FunctionSignature_Window_WindowType value) { + _internal_set_window_type(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.window_type) +} + +// repeated .io.substrait.FunctionSignature.Implementation implementations = 15; +inline int FunctionSignature_Window::_internal_implementations_size() const { + return implementations_.size(); +} +inline int FunctionSignature_Window::implementations_size() const { + return _internal_implementations_size(); +} +inline void FunctionSignature_Window::clear_implementations() { + implementations_.Clear(); +} +inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Window::mutable_implementations(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.implementations) + return implementations_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* +FunctionSignature_Window::mutable_implementations() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Window.implementations) + return &implementations_; +} +inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Window::_internal_implementations(int index) const { + return implementations_.Get(index); +} +inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Window::implementations(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.implementations) + return _internal_implementations(index); +} +inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Window::_internal_add_implementations() { + return implementations_.Add(); +} +inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Window::add_implementations() { + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Window.implementations) + return _internal_add_implementations(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& +FunctionSignature_Window::implementations() const { + // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Window.implementations) + return implementations_; +} + +inline bool FunctionSignature_Window::has_final_variable_behavior() const { + return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET; +} +inline void FunctionSignature_Window::clear_has_final_variable_behavior() { + _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; +} +inline FunctionSignature_Window::FinalVariableBehaviorCase FunctionSignature_Window::final_variable_behavior_case() const { + return FunctionSignature_Window::FinalVariableBehaviorCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// FunctionSignature_Description + +// string language = 1; +inline void FunctionSignature_Description::clear_language() { + language_.ClearToEmpty(); +} +inline const std::string& FunctionSignature_Description::language() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Description.language) + return _internal_language(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void FunctionSignature_Description::set_language(ArgT0&& arg0, ArgT... args) { + + language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Description.language) +} +inline std::string* FunctionSignature_Description::mutable_language() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Description.language) + return _internal_mutable_language(); +} +inline const std::string& FunctionSignature_Description::_internal_language() const { + return language_.Get(); +} +inline void FunctionSignature_Description::_internal_set_language(const std::string& value) { + + language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* FunctionSignature_Description::_internal_mutable_language() { + + return language_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* FunctionSignature_Description::release_language() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Description.language) + return language_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void FunctionSignature_Description::set_allocated_language(std::string* language) { + if (language != nullptr) { + + } else { + + } + language_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), language, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Description.language) +} + +// string body = 2; +inline void FunctionSignature_Description::clear_body() { + body_.ClearToEmpty(); +} +inline const std::string& FunctionSignature_Description::body() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Description.body) + return _internal_body(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void FunctionSignature_Description::set_body(ArgT0&& arg0, ArgT... args) { + + body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Description.body) +} +inline std::string* FunctionSignature_Description::mutable_body() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Description.body) + return _internal_mutable_body(); +} +inline const std::string& FunctionSignature_Description::_internal_body() const { + return body_.Get(); +} +inline void FunctionSignature_Description::_internal_set_body(const std::string& value) { + + body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* FunctionSignature_Description::_internal_mutable_body() { + + return body_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* FunctionSignature_Description::release_body() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Description.body) + return body_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void FunctionSignature_Description::set_allocated_body(std::string* body) { + if (body != nullptr) { + + } else { + + } + body_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), body, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Description.body) +} + +// ------------------------------------------------------------------- + +// FunctionSignature_Implementation + +// .io.substrait.FunctionSignature.Implementation.Type type = 1; +inline void FunctionSignature_Implementation::clear_type() { + type_ = 0; +} +inline ::io::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::_internal_type() const { + return static_cast< ::io::substrait::FunctionSignature_Implementation_Type >(type_); +} +inline ::io::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::type() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Implementation.type) + return _internal_type(); +} +inline void FunctionSignature_Implementation::_internal_set_type(::io::substrait::FunctionSignature_Implementation_Type value) { + + type_ = value; +} +inline void FunctionSignature_Implementation::set_type(::io::substrait::FunctionSignature_Implementation_Type value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Implementation.type) +} + +// string uri = 2; +inline void FunctionSignature_Implementation::clear_uri() { + uri_.ClearToEmpty(); +} +inline const std::string& FunctionSignature_Implementation::uri() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Implementation.uri) + return _internal_uri(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void FunctionSignature_Implementation::set_uri(ArgT0&& arg0, ArgT... args) { + + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Implementation.uri) +} +inline std::string* FunctionSignature_Implementation::mutable_uri() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Implementation.uri) + return _internal_mutable_uri(); +} +inline const std::string& FunctionSignature_Implementation::_internal_uri() const { + return uri_.Get(); +} +inline void FunctionSignature_Implementation::_internal_set_uri(const std::string& value) { + + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* FunctionSignature_Implementation::_internal_mutable_uri() { + + return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* FunctionSignature_Implementation::release_uri() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Implementation.uri) + return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void FunctionSignature_Implementation::set_allocated_uri(std::string* uri) { + if (uri != nullptr) { + + } else { + + } + uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Implementation.uri) +} + +// ------------------------------------------------------------------- + +// FunctionSignature_Argument_ValueArgument + +// .io.substrait.ParameterizedType type = 1; +inline bool FunctionSignature_Argument_ValueArgument::_internal_has_type() const { + return this != internal_default_instance() && type_ != nullptr; +} +inline bool FunctionSignature_Argument_ValueArgument::has_type() const { + return _internal_has_type(); +} +inline const ::io::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::_internal_type() const { + const ::io::substrait::ParameterizedType* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_default_instance_); +} +inline const ::io::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::type() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.ValueArgument.type) + return _internal_type(); +} +inline void FunctionSignature_Argument_ValueArgument::unsafe_arena_set_allocated_type( + ::io::substrait::ParameterizedType* type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); + } + type_ = type; + if (type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Argument.ValueArgument.type) +} +inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::release_type() { + + ::io::substrait::ParameterizedType* temp = type_; + type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.ValueArgument.type) + + ::io::substrait::ParameterizedType* temp = type_; + type_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::_internal_mutable_type() { + + if (type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType>(GetArena()); + type_ = p; + } + return type_; +} +inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::mutable_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.ValueArgument.type) + return _internal_mutable_type(); +} +inline void FunctionSignature_Argument_ValueArgument::set_allocated_type(::io::substrait::ParameterizedType* type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); + } + if (type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)->GetArena(); + if (message_arena != submessage_arena) { + type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type, submessage_arena); + } + + } else { + + } + type_ = type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.ValueArgument.type) +} + +// bool constant = 2; +inline void FunctionSignature_Argument_ValueArgument::clear_constant() { + constant_ = false; +} +inline bool FunctionSignature_Argument_ValueArgument::_internal_constant() const { + return constant_; +} +inline bool FunctionSignature_Argument_ValueArgument::constant() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.ValueArgument.constant) + return _internal_constant(); +} +inline void FunctionSignature_Argument_ValueArgument::_internal_set_constant(bool value) { + + constant_ = value; +} +inline void FunctionSignature_Argument_ValueArgument::set_constant(bool value) { + _internal_set_constant(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Argument.ValueArgument.constant) +} + +// ------------------------------------------------------------------- + +// FunctionSignature_Argument_TypeArgument + +// .io.substrait.ParameterizedType type = 1; +inline bool FunctionSignature_Argument_TypeArgument::_internal_has_type() const { + return this != internal_default_instance() && type_ != nullptr; +} +inline bool FunctionSignature_Argument_TypeArgument::has_type() const { + return _internal_has_type(); +} +inline const ::io::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::_internal_type() const { + const ::io::substrait::ParameterizedType* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_default_instance_); +} +inline const ::io::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::type() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.TypeArgument.type) + return _internal_type(); +} +inline void FunctionSignature_Argument_TypeArgument::unsafe_arena_set_allocated_type( + ::io::substrait::ParameterizedType* type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); + } + type_ = type; + if (type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Argument.TypeArgument.type) +} +inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::release_type() { + + ::io::substrait::ParameterizedType* temp = type_; + type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.TypeArgument.type) + + ::io::substrait::ParameterizedType* temp = type_; + type_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::_internal_mutable_type() { + + if (type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType>(GetArena()); + type_ = p; + } + return type_; +} +inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::mutable_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.TypeArgument.type) + return _internal_mutable_type(); +} +inline void FunctionSignature_Argument_TypeArgument::set_allocated_type(::io::substrait::ParameterizedType* type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); + } + if (type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)->GetArena(); + if (message_arena != submessage_arena) { + type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type, submessage_arena); + } + + } else { + + } + type_ = type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.TypeArgument.type) +} + +// ------------------------------------------------------------------- + +// FunctionSignature_Argument_EnumArgument + +// repeated string options = 1; +inline int FunctionSignature_Argument_EnumArgument::_internal_options_size() const { + return options_.size(); +} +inline int FunctionSignature_Argument_EnumArgument::options_size() const { + return _internal_options_size(); +} +inline void FunctionSignature_Argument_EnumArgument::clear_options() { + options_.Clear(); +} +inline std::string* FunctionSignature_Argument_EnumArgument::add_options() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.FunctionSignature.Argument.EnumArgument.options) + return _internal_add_options(); +} +inline const std::string& FunctionSignature_Argument_EnumArgument::_internal_options(int index) const { + return options_.Get(index); +} +inline const std::string& FunctionSignature_Argument_EnumArgument::options(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.EnumArgument.options) + return _internal_options(index); +} +inline std::string* FunctionSignature_Argument_EnumArgument::mutable_options(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.EnumArgument.options) + return options_.Mutable(index); +} +inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Argument.EnumArgument.options) + options_.Mutable(index)->assign(value); +} +inline void FunctionSignature_Argument_EnumArgument::set_options(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Argument.EnumArgument.options) + options_.Mutable(index)->assign(std::move(value)); +} +inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + options_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.FunctionSignature.Argument.EnumArgument.options) +} +inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value, size_t size) { + options_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.FunctionSignature.Argument.EnumArgument.options) +} +inline std::string* FunctionSignature_Argument_EnumArgument::_internal_add_options() { + return options_.Add(); +} +inline void FunctionSignature_Argument_EnumArgument::add_options(const std::string& value) { + options_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Argument.EnumArgument.options) +} +inline void FunctionSignature_Argument_EnumArgument::add_options(std::string&& value) { + options_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Argument.EnumArgument.options) +} +inline void FunctionSignature_Argument_EnumArgument::add_options(const char* value) { + GOOGLE_DCHECK(value != nullptr); + options_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.FunctionSignature.Argument.EnumArgument.options) +} +inline void FunctionSignature_Argument_EnumArgument::add_options(const char* value, size_t size) { + options_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.FunctionSignature.Argument.EnumArgument.options) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +FunctionSignature_Argument_EnumArgument::options() const { + // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Argument.EnumArgument.options) + return options_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +FunctionSignature_Argument_EnumArgument::mutable_options() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Argument.EnumArgument.options) + return &options_; +} + +// bool optional = 2; +inline void FunctionSignature_Argument_EnumArgument::clear_optional() { + optional_ = false; +} +inline bool FunctionSignature_Argument_EnumArgument::_internal_optional() const { + return optional_; +} +inline bool FunctionSignature_Argument_EnumArgument::optional() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.EnumArgument.optional) + return _internal_optional(); +} +inline void FunctionSignature_Argument_EnumArgument::_internal_set_optional(bool value) { + + optional_ = value; +} +inline void FunctionSignature_Argument_EnumArgument::set_optional(bool value) { + _internal_set_optional(value); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Argument.EnumArgument.optional) +} + +// ------------------------------------------------------------------- + +// FunctionSignature_Argument + +// string name = 1; +inline void FunctionSignature_Argument::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& FunctionSignature_Argument::name() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.name) + return _internal_name(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void FunctionSignature_Argument::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Argument.name) +} +inline std::string* FunctionSignature_Argument::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.name) + return _internal_mutable_name(); +} +inline const std::string& FunctionSignature_Argument::_internal_name() const { + return name_.Get(); +} +inline void FunctionSignature_Argument::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* FunctionSignature_Argument::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* FunctionSignature_Argument::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void FunctionSignature_Argument::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.name) +} + +// .io.substrait.FunctionSignature.Argument.ValueArgument value = 2; +inline bool FunctionSignature_Argument::_internal_has_value() const { + return argument_kind_case() == kValue; +} +inline bool FunctionSignature_Argument::has_value() const { + return _internal_has_value(); +} +inline void FunctionSignature_Argument::set_has_value() { + _oneof_case_[0] = kValue; +} +inline void FunctionSignature_Argument::clear_value() { + if (_internal_has_value()) { + if (GetArena() == nullptr) { + delete argument_kind_.value_; + } + clear_has_argument_kind(); + } +} +inline ::io::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::release_value() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.value) + if (_internal_has_value()) { + clear_has_argument_kind(); + ::io::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + argument_kind_.value_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::_internal_value() const { + return _internal_has_value() + ? *argument_kind_.value_ + : reinterpret_cast< ::io::substrait::FunctionSignature_Argument_ValueArgument&>(::io::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_); +} +inline const ::io::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::value() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.value) + return _internal_value(); +} +inline ::io::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Argument.value) + if (_internal_has_value()) { + clear_has_argument_kind(); + ::io::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_; + argument_kind_.value_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FunctionSignature_Argument::unsafe_arena_set_allocated_value(::io::substrait::FunctionSignature_Argument_ValueArgument* value) { + clear_argument_kind(); + if (value) { + set_has_value(); + argument_kind_.value_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Argument.value) +} +inline ::io::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::_internal_mutable_value() { + if (!_internal_has_value()) { + clear_argument_kind(); + set_has_value(); + argument_kind_.value_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_ValueArgument >(GetArena()); + } + return argument_kind_.value_; +} +inline ::io::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.value) + return _internal_mutable_value(); +} + +// .io.substrait.FunctionSignature.Argument.TypeArgument type = 3; +inline bool FunctionSignature_Argument::_internal_has_type() const { + return argument_kind_case() == kType; +} +inline bool FunctionSignature_Argument::has_type() const { + return _internal_has_type(); +} +inline void FunctionSignature_Argument::set_has_type() { + _oneof_case_[0] = kType; +} +inline void FunctionSignature_Argument::clear_type() { + if (_internal_has_type()) { + if (GetArena() == nullptr) { + delete argument_kind_.type_; + } + clear_has_argument_kind(); + } +} +inline ::io::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::release_type() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.type) + if (_internal_has_type()) { + clear_has_argument_kind(); + ::io::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + argument_kind_.type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::_internal_type() const { + return _internal_has_type() + ? *argument_kind_.type_ + : reinterpret_cast< ::io::substrait::FunctionSignature_Argument_TypeArgument&>(::io::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_); +} +inline const ::io::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::type() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.type) + return _internal_type(); +} +inline ::io::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Argument.type) + if (_internal_has_type()) { + clear_has_argument_kind(); + ::io::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_; + argument_kind_.type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FunctionSignature_Argument::unsafe_arena_set_allocated_type(::io::substrait::FunctionSignature_Argument_TypeArgument* type) { + clear_argument_kind(); + if (type) { + set_has_type(); + argument_kind_.type_ = type; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Argument.type) +} +inline ::io::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::_internal_mutable_type() { + if (!_internal_has_type()) { + clear_argument_kind(); + set_has_type(); + argument_kind_.type_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_TypeArgument >(GetArena()); + } + return argument_kind_.type_; +} +inline ::io::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::mutable_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.type) + return _internal_mutable_type(); +} + +// .io.substrait.FunctionSignature.Argument.EnumArgument enum = 4; +inline bool FunctionSignature_Argument::_internal_has_enum_() const { + return argument_kind_case() == kEnum; +} +inline bool FunctionSignature_Argument::has_enum_() const { + return _internal_has_enum_(); +} +inline void FunctionSignature_Argument::set_has_enum_() { + _oneof_case_[0] = kEnum; +} +inline void FunctionSignature_Argument::clear_enum_() { + if (_internal_has_enum_()) { + if (GetArena() == nullptr) { + delete argument_kind_.enum__; + } + clear_has_argument_kind(); + } +} +inline ::io::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::release_enum_() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.enum) + if (_internal_has_enum_()) { + clear_has_argument_kind(); + ::io::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + argument_kind_.enum__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::_internal_enum_() const { + return _internal_has_enum_() + ? *argument_kind_.enum__ + : reinterpret_cast< ::io::substrait::FunctionSignature_Argument_EnumArgument&>(::io::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_); +} +inline const ::io::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::enum_() const { + // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.enum) + return _internal_enum_(); +} +inline ::io::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::unsafe_arena_release_enum_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Argument.enum) + if (_internal_has_enum_()) { + clear_has_argument_kind(); + ::io::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__; + argument_kind_.enum__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FunctionSignature_Argument::unsafe_arena_set_allocated_enum_(::io::substrait::FunctionSignature_Argument_EnumArgument* enum_) { + clear_argument_kind(); + if (enum_) { + set_has_enum_(); + argument_kind_.enum__ = enum_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Argument.enum) +} +inline ::io::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::_internal_mutable_enum_() { + if (!_internal_has_enum_()) { + clear_argument_kind(); + set_has_enum_(); + argument_kind_.enum__ = CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_EnumArgument >(GetArena()); + } + return argument_kind_.enum__; +} +inline ::io::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::mutable_enum_() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.enum) + return _internal_mutable_enum_(); +} + +inline bool FunctionSignature_Argument::has_argument_kind() const { + return argument_kind_case() != ARGUMENT_KIND_NOT_SET; +} +inline void FunctionSignature_Argument::clear_has_argument_kind() { + _oneof_case_[0] = ARGUMENT_KIND_NOT_SET; +} +inline FunctionSignature_Argument::ArgumentKindCase FunctionSignature_Argument::argument_kind_case() const { + return FunctionSignature_Argument::ArgumentKindCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// FunctionSignature + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace substrait +} // namespace io + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>() { + return ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(); +} +template <> struct is_proto_enum< ::io::substrait::FunctionSignature_Window_WindowType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::FunctionSignature_Window_WindowType>() { + return ::io::substrait::FunctionSignature_Window_WindowType_descriptor(); +} +template <> struct is_proto_enum< ::io::substrait::FunctionSignature_Implementation_Type> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::FunctionSignature_Implementation_Type>() { + return ::io::substrait::FunctionSignature_Implementation_Type_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_function_2eproto diff --git a/cpp/src/generated/substrait/parameterized_types.pb.cc b/cpp/src/generated/substrait/parameterized_types.pb.cc new file mode 100644 index 00000000000..22abc72ed2d --- /dev/null +++ b/cpp/src/generated/substrait/parameterized_types.pb.cc @@ -0,0 +1,5564 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: parameterized_types.proto + +#include "parameterized_types.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace io { +namespace substrait { +constexpr ParameterizedType_TypeParameter::ParameterizedType_TypeParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : bounds_() + , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct ParameterizedType_TypeParameterDefaultTypeInternal { + constexpr ParameterizedType_TypeParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_TypeParameterDefaultTypeInternal() {} + union { + ParameterizedType_TypeParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_TypeParameterDefaultTypeInternal _ParameterizedType_TypeParameter_default_instance_; +constexpr ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , range_start_inclusive_(nullptr) + , range_end_exclusive_(nullptr){} +struct ParameterizedType_IntegerParameterDefaultTypeInternal { + constexpr ParameterizedType_IntegerParameterDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_IntegerParameterDefaultTypeInternal() {} + union { + ParameterizedType_IntegerParameter _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_IntegerParameterDefaultTypeInternal _ParameterizedType_IntegerParameter_default_instance_; +constexpr ParameterizedType_NullableInteger::ParameterizedType_NullableInteger( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : value_(PROTOBUF_LONGLONG(0)){} +struct ParameterizedType_NullableIntegerDefaultTypeInternal { + constexpr ParameterizedType_NullableIntegerDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_NullableIntegerDefaultTypeInternal() {} + union { + ParameterizedType_NullableInteger _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_NullableIntegerDefaultTypeInternal _ParameterizedType_NullableInteger_default_instance_; +constexpr ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : length_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct ParameterizedType_ParameterizedFixedCharDefaultTypeInternal { + constexpr ParameterizedType_ParameterizedFixedCharDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_ParameterizedFixedCharDefaultTypeInternal() {} + union { + ParameterizedType_ParameterizedFixedChar _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedFixedCharDefaultTypeInternal _ParameterizedType_ParameterizedFixedChar_default_instance_; +constexpr ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : length_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct ParameterizedType_ParameterizedVarCharDefaultTypeInternal { + constexpr ParameterizedType_ParameterizedVarCharDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_ParameterizedVarCharDefaultTypeInternal() {} + union { + ParameterizedType_ParameterizedVarChar _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedVarCharDefaultTypeInternal _ParameterizedType_ParameterizedVarChar_default_instance_; +constexpr ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : length_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal { + constexpr ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal() {} + union { + ParameterizedType_ParameterizedFixedBinary _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal _ParameterizedType_ParameterizedFixedBinary_default_instance_; +constexpr ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : scale_(nullptr) + , precision_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct ParameterizedType_ParameterizedDecimalDefaultTypeInternal { + constexpr ParameterizedType_ParameterizedDecimalDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_ParameterizedDecimalDefaultTypeInternal() {} + union { + ParameterizedType_ParameterizedDecimal _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedDecimalDefaultTypeInternal _ParameterizedType_ParameterizedDecimal_default_instance_; +constexpr ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : types_() + , variation_(nullptr) + , nullability_(0) +{} +struct ParameterizedType_ParameterizedStructDefaultTypeInternal { + constexpr ParameterizedType_ParameterizedStructDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_ParameterizedStructDefaultTypeInternal() {} + union { + ParameterizedType_ParameterizedStruct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedStructDefaultTypeInternal _ParameterizedType_ParameterizedStruct_default_instance_; +constexpr ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : names_() + , struct__(nullptr){} +struct ParameterizedType_ParameterizedNamedStructDefaultTypeInternal { + constexpr ParameterizedType_ParameterizedNamedStructDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_ParameterizedNamedStructDefaultTypeInternal() {} + union { + ParameterizedType_ParameterizedNamedStruct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedNamedStructDefaultTypeInternal _ParameterizedType_ParameterizedNamedStruct_default_instance_; +constexpr ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : type_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct ParameterizedType_ParameterizedListDefaultTypeInternal { + constexpr ParameterizedType_ParameterizedListDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_ParameterizedListDefaultTypeInternal() {} + union { + ParameterizedType_ParameterizedList _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedListDefaultTypeInternal _ParameterizedType_ParameterizedList_default_instance_; +constexpr ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : key_(nullptr) + , value_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct ParameterizedType_ParameterizedMapDefaultTypeInternal { + constexpr ParameterizedType_ParameterizedMapDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_ParameterizedMapDefaultTypeInternal() {} + union { + ParameterizedType_ParameterizedMap _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedMapDefaultTypeInternal _ParameterizedType_ParameterizedMap_default_instance_; +constexpr ParameterizedType_IntegerOption::ParameterizedType_IntegerOption( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct ParameterizedType_IntegerOptionDefaultTypeInternal { + constexpr ParameterizedType_IntegerOptionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedType_IntegerOptionDefaultTypeInternal() {} + union { + ParameterizedType_IntegerOption _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_IntegerOptionDefaultTypeInternal _ParameterizedType_IntegerOption_default_instance_; +constexpr ParameterizedType::ParameterizedType( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct ParameterizedTypeDefaultTypeInternal { + constexpr ParameterizedTypeDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ParameterizedTypeDefaultTypeInternal() {} + union { + ParameterizedType _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedTypeDefaultTypeInternal _ParameterizedType_default_instance_; +} // namespace substrait +} // namespace io +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_parameterized_5ftypes_2eproto[13]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_parameterized_5ftypes_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_parameterized_5ftypes_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_parameterized_5ftypes_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_TypeParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_TypeParameter, name_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_TypeParameter, bounds_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerParameter, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerParameter, name_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerParameter, range_start_inclusive_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerParameter, range_end_exclusive_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_NullableInteger, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_NullableInteger, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, length_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, length_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, length_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, scale_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, precision_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, types_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedNamedStruct, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedNamedStruct, names_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedNamedStruct, struct__), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, key_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, value_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerOption, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerOption, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerOption, integer_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType, kind_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::io::substrait::ParameterizedType_TypeParameter)}, + { 7, -1, sizeof(::io::substrait::ParameterizedType_IntegerParameter)}, + { 15, -1, sizeof(::io::substrait::ParameterizedType_NullableInteger)}, + { 21, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedFixedChar)}, + { 29, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedVarChar)}, + { 37, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedFixedBinary)}, + { 45, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedDecimal)}, + { 54, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedStruct)}, + { 62, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedNamedStruct)}, + { 69, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedList)}, + { 77, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedMap)}, + { 86, -1, sizeof(::io::substrait::ParameterizedType_IntegerOption)}, + { 94, -1, sizeof(::io::substrait::ParameterizedType)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_ParameterizedType_TypeParameter_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_IntegerParameter_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_NullableInteger_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedStruct_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedNamedStruct_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedList_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedMap_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_IntegerOption_default_instance_), + reinterpret_cast(&::io::substrait::_ParameterizedType_default_instance_), +}; + +const char descriptor_table_protodef_parameterized_5ftypes_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\031parameterized_types.proto\022\014io.substrai" + "t\032\ntype.proto\032\020extensions.proto\"\363\031\n\021Para" + "meterizedType\022*\n\004bool\030\001 \001(\0132\032.io.substra" + "it.Type.BooleanH\000\022#\n\002i8\030\002 \001(\0132\025.io.subst" + "rait.Type.I8H\000\022%\n\003i16\030\003 \001(\0132\026.io.substra" + "it.Type.I16H\000\022%\n\003i32\030\005 \001(\0132\026.io.substrai" + "t.Type.I32H\000\022%\n\003i64\030\007 \001(\0132\026.io.substrait" + ".Type.I64H\000\022\'\n\004fp32\030\n \001(\0132\027.io.substrait" + ".Type.FP32H\000\022\'\n\004fp64\030\013 \001(\0132\027.io.substrai" + "t.Type.FP64H\000\022+\n\006string\030\014 \001(\0132\031.io.subst" + "rait.Type.StringH\000\022+\n\006binary\030\r \001(\0132\031.io." + "substrait.Type.BinaryH\000\0221\n\ttimestamp\030\016 \001" + "(\0132\034.io.substrait.Type.TimestampH\000\022\'\n\004da" + "te\030\020 \001(\0132\027.io.substrait.Type.DateH\000\022\'\n\004t" + "ime\030\021 \001(\0132\027.io.substrait.Type.TimeH\000\0228\n\r" + "interval_year\030\023 \001(\0132\037.io.substrait.Type." + "IntervalYearH\000\0226\n\014interval_day\030\024 \001(\0132\036.i" + "o.substrait.Type.IntervalDayH\000\0226\n\014timest" + "amp_tz\030\035 \001(\0132\036.io.substrait.Type.Timesta" + "mpTZH\000\022\'\n\004uuid\030 \001(\0132\027.io.substrait.Type" + ".UUIDH\000\022L\n\nfixed_char\030\025 \001(\01326.io.substra" + "it.ParameterizedType.ParameterizedFixedC" + "harH\000\022G\n\007varchar\030\026 \001(\01324.io.substrait.Pa" + "rameterizedType.ParameterizedVarCharH\000\022P" + "\n\014fixed_binary\030\027 \001(\01328.io.substrait.Para" + "meterizedType.ParameterizedFixedBinaryH\000" + "\022G\n\007decimal\030\030 \001(\01324.io.substrait.Paramet" + "erizedType.ParameterizedDecimalH\000\022E\n\006str" + "uct\030\031 \001(\01323.io.substrait.ParameterizedTy" + "pe.ParameterizedStructH\000\022A\n\004list\030\033 \001(\01321" + ".io.substrait.ParameterizedType.Paramete" + "rizedListH\000\022\?\n\003map\030\034 \001(\01320.io.substrait." + "ParameterizedType.ParameterizedMapH\000\0227\n\014" + "user_defined\030\037 \001(\0132\037.io.substrait.Extens" + "ions.TypeIdH\000\022G\n\016type_parameter\030! \001(\0132-." + "io.substrait.ParameterizedType.TypeParam" + "eterH\000\032N\n\rTypeParameter\022\014\n\004name\030\001 \001(\t\022/\n" + "\006bounds\030\002 \003(\0132\037.io.substrait.Parameteriz" + "edType\032\276\001\n\020IntegerParameter\022\014\n\004name\030\001 \001(" + "\t\022N\n\025range_start_inclusive\030\002 \001(\0132/.io.su" + "bstrait.ParameterizedType.NullableIntege" + "r\022L\n\023range_end_exclusive\030\003 \001(\0132/.io.subs" + "trait.ParameterizedType.NullableInteger\032" + " \n\017NullableInteger\022\r\n\005value\030\001 \001(\003\032\275\001\n\026Pa" + "rameterizedFixedChar\022=\n\006length\030\001 \001(\0132-.i" + "o.substrait.ParameterizedType.IntegerOpt" + "ion\022/\n\tvariation\030\002 \001(\0132\034.io.substrait.Ty" + "pe.Variation\0223\n\013nullability\030\003 \001(\0162\036.io.s" + "ubstrait.Type.Nullability\032\273\001\n\024Parameteri" + "zedVarChar\022=\n\006length\030\001 \001(\0132-.io.substrai" + "t.ParameterizedType.IntegerOption\022/\n\tvar" + "iation\030\002 \001(\0132\034.io.substrait.Type.Variati" + "on\0223\n\013nullability\030\003 \001(\0162\036.io.substrait.T" + "ype.Nullability\032\277\001\n\030ParameterizedFixedBi" + "nary\022=\n\006length\030\001 \001(\0132-.io.substrait.Para" + "meterizedType.IntegerOption\022/\n\tvariation" + "\030\002 \001(\0132\034.io.substrait.Type.Variation\0223\n\013" + "nullability\030\003 \001(\0162\036.io.substrait.Type.Nu" + "llability\032\374\001\n\024ParameterizedDecimal\022<\n\005sc" + "ale\030\001 \001(\0132-.io.substrait.ParameterizedTy" + "pe.IntegerOption\022@\n\tprecision\030\002 \001(\0132-.io" + ".substrait.ParameterizedType.IntegerOpti" + "on\022/\n\tvariation\030\003 \001(\0132\034.io.substrait.Typ" + "e.Variation\0223\n\013nullability\030\004 \001(\0162\036.io.su" + "bstrait.Type.Nullability\032\253\001\n\023Parameteriz" + "edStruct\022.\n\005types\030\001 \003(\0132\037.io.substrait.P" + "arameterizedType\022/\n\tvariation\030\002 \001(\0132\034.io" + ".substrait.Type.Variation\0223\n\013nullability" + "\030\003 \001(\0162\036.io.substrait.Type.Nullability\032n" + "\n\030ParameterizedNamedStruct\022\r\n\005names\030\001 \003(" + "\t\022C\n\006struct\030\002 \001(\01323.io.substrait.Paramet" + "erizedType.ParameterizedStruct\032\250\001\n\021Param" + "eterizedList\022-\n\004type\030\001 \001(\0132\037.io.substrai" + "t.ParameterizedType\022/\n\tvariation\030\002 \001(\0132\034" + ".io.substrait.Type.Variation\0223\n\013nullabil" + "ity\030\003 \001(\0162\036.io.substrait.Type.Nullabilit" + "y\032\326\001\n\020ParameterizedMap\022,\n\003key\030\001 \001(\0132\037.io" + ".substrait.ParameterizedType\022.\n\005value\030\002 " + "\001(\0132\037.io.substrait.ParameterizedType\022/\n\t" + "variation\030\003 \001(\0132\034.io.substrait.Type.Vari" + "ation\0223\n\013nullability\030\004 \001(\0162\036.io.substrai" + "t.Type.Nullability\032y\n\rIntegerOption\022\021\n\007l" + "iteral\030\001 \001(\005H\000\022E\n\tparameter\030\002 \001(\01320.io.s" + "ubstrait.ParameterizedType.IntegerParame" + "terH\000B\016\n\014integer_typeB\006\n\004kindB\027P\001\252\002\022Subs" + "trait.Protobufb\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_parameterized_5ftypes_2eproto_deps[2] = { + &::descriptor_table_extensions_2eproto, + &::descriptor_table_type_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_parameterized_5ftypes_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_parameterized_5ftypes_2eproto = { + false, false, 3422, descriptor_table_protodef_parameterized_5ftypes_2eproto, "parameterized_types.proto", + &descriptor_table_parameterized_5ftypes_2eproto_once, descriptor_table_parameterized_5ftypes_2eproto_deps, 2, 13, + schemas, file_default_instances, TableStruct_parameterized_5ftypes_2eproto::offsets, + file_level_metadata_parameterized_5ftypes_2eproto, file_level_enum_descriptors_parameterized_5ftypes_2eproto, file_level_service_descriptors_parameterized_5ftypes_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_parameterized_5ftypes_2eproto_getter() { + return &descriptor_table_parameterized_5ftypes_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_parameterized_5ftypes_2eproto(&descriptor_table_parameterized_5ftypes_2eproto); +namespace io { +namespace substrait { + +// =================================================================== + +class ParameterizedType_TypeParameter::_Internal { + public: +}; + +ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + bounds_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.TypeParameter) +} +ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(const ParameterizedType_TypeParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + bounds_(from.bounds_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.TypeParameter) +} + +void ParameterizedType_TypeParameter::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +ParameterizedType_TypeParameter::~ParameterizedType_TypeParameter() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.TypeParameter) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_TypeParameter::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void ParameterizedType_TypeParameter::ArenaDtor(void* object) { + ParameterizedType_TypeParameter* _this = reinterpret_cast< ParameterizedType_TypeParameter* >(object); + (void)_this; +} +void ParameterizedType_TypeParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_TypeParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_TypeParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.TypeParameter) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + bounds_.Clear(); + name_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_TypeParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ParameterizedType.TypeParameter.name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.ParameterizedType bounds = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_bounds(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_TypeParameter::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.TypeParameter) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string name = 1; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.ParameterizedType.TypeParameter.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // repeated .io.substrait.ParameterizedType bounds = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_bounds_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_bounds(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.TypeParameter) + return target; +} + +size_t ParameterizedType_TypeParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.TypeParameter) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.ParameterizedType bounds = 2; + total_size += 1UL * this->_internal_bounds_size(); + for (const auto& msg : this->bounds_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // string name = 1; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_TypeParameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.TypeParameter) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_TypeParameter* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.TypeParameter) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.TypeParameter) + MergeFrom(*source); + } +} + +void ParameterizedType_TypeParameter::MergeFrom(const ParameterizedType_TypeParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.TypeParameter) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + bounds_.MergeFrom(from.bounds_); + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } +} + +void ParameterizedType_TypeParameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.TypeParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_TypeParameter::CopyFrom(const ParameterizedType_TypeParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.TypeParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_TypeParameter::IsInitialized() const { + return true; +} + +void ParameterizedType_TypeParameter::InternalSwap(ParameterizedType_TypeParameter* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + bounds_.InternalSwap(&other->bounds_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_TypeParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[0]); +} + +// =================================================================== + +class ParameterizedType_IntegerParameter::_Internal { + public: + static const ::io::substrait::ParameterizedType_NullableInteger& range_start_inclusive(const ParameterizedType_IntegerParameter* msg); + static const ::io::substrait::ParameterizedType_NullableInteger& range_end_exclusive(const ParameterizedType_IntegerParameter* msg); +}; + +const ::io::substrait::ParameterizedType_NullableInteger& +ParameterizedType_IntegerParameter::_Internal::range_start_inclusive(const ParameterizedType_IntegerParameter* msg) { + return *msg->range_start_inclusive_; +} +const ::io::substrait::ParameterizedType_NullableInteger& +ParameterizedType_IntegerParameter::_Internal::range_end_exclusive(const ParameterizedType_IntegerParameter* msg) { + return *msg->range_end_exclusive_; +} +ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.IntegerParameter) +} +ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(const ParameterizedType_IntegerParameter& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); + } + if (from._internal_has_range_start_inclusive()) { + range_start_inclusive_ = new ::io::substrait::ParameterizedType_NullableInteger(*from.range_start_inclusive_); + } else { + range_start_inclusive_ = nullptr; + } + if (from._internal_has_range_end_exclusive()) { + range_end_exclusive_ = new ::io::substrait::ParameterizedType_NullableInteger(*from.range_end_exclusive_); + } else { + range_end_exclusive_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.IntegerParameter) +} + +void ParameterizedType_IntegerParameter::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&range_start_inclusive_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&range_end_exclusive_) - + reinterpret_cast(&range_start_inclusive_)) + sizeof(range_end_exclusive_)); +} + +ParameterizedType_IntegerParameter::~ParameterizedType_IntegerParameter() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.IntegerParameter) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_IntegerParameter::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete range_start_inclusive_; + if (this != internal_default_instance()) delete range_end_exclusive_; +} + +void ParameterizedType_IntegerParameter::ArenaDtor(void* object) { + ParameterizedType_IntegerParameter* _this = reinterpret_cast< ParameterizedType_IntegerParameter* >(object); + (void)_this; +} +void ParameterizedType_IntegerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_IntegerParameter::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_IntegerParameter::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.IntegerParameter) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmpty(); + if (GetArena() == nullptr && range_start_inclusive_ != nullptr) { + delete range_start_inclusive_; + } + range_start_inclusive_ = nullptr; + if (GetArena() == nullptr && range_end_exclusive_ != nullptr) { + delete range_end_exclusive_; + } + range_end_exclusive_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_IntegerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ParameterizedType.IntegerParameter.name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_range_start_inclusive(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_range_end_exclusive(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerParameter::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.IntegerParameter) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string name = 1; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.ParameterizedType.IntegerParameter.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // .io.substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; + if (this->has_range_start_inclusive()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::range_start_inclusive(this), target, stream); + } + + // .io.substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; + if (this->has_range_end_exclusive()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::range_end_exclusive(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.IntegerParameter) + return target; +} + +size_t ParameterizedType_IntegerParameter::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.IntegerParameter) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 1; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // .io.substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; + if (this->has_range_start_inclusive()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *range_start_inclusive_); + } + + // .io.substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; + if (this->has_range_end_exclusive()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *range_end_exclusive_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_IntegerParameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.IntegerParameter) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_IntegerParameter* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.IntegerParameter) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.IntegerParameter) + MergeFrom(*source); + } +} + +void ParameterizedType_IntegerParameter::MergeFrom(const ParameterizedType_IntegerParameter& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.IntegerParameter) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } + if (from.has_range_start_inclusive()) { + _internal_mutable_range_start_inclusive()->::io::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_start_inclusive()); + } + if (from.has_range_end_exclusive()) { + _internal_mutable_range_end_exclusive()->::io::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_end_exclusive()); + } +} + +void ParameterizedType_IntegerParameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.IntegerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_IntegerParameter::CopyFrom(const ParameterizedType_IntegerParameter& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.IntegerParameter) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_IntegerParameter::IsInitialized() const { + return true; +} + +void ParameterizedType_IntegerParameter::InternalSwap(ParameterizedType_IntegerParameter* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ParameterizedType_IntegerParameter, range_end_exclusive_) + + sizeof(ParameterizedType_IntegerParameter::range_end_exclusive_) + - PROTOBUF_FIELD_OFFSET(ParameterizedType_IntegerParameter, range_start_inclusive_)>( + reinterpret_cast(&range_start_inclusive_), + reinterpret_cast(&other->range_start_inclusive_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_IntegerParameter::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[1]); +} + +// =================================================================== + +class ParameterizedType_NullableInteger::_Internal { + public: +}; + +ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.NullableInteger) +} +ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(const ParameterizedType_NullableInteger& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + value_ = from.value_; + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.NullableInteger) +} + +void ParameterizedType_NullableInteger::SharedCtor() { +value_ = PROTOBUF_LONGLONG(0); +} + +ParameterizedType_NullableInteger::~ParameterizedType_NullableInteger() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.NullableInteger) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_NullableInteger::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void ParameterizedType_NullableInteger::ArenaDtor(void* object) { + ParameterizedType_NullableInteger* _this = reinterpret_cast< ParameterizedType_NullableInteger* >(object); + (void)_this; +} +void ParameterizedType_NullableInteger::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_NullableInteger::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_NullableInteger::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.NullableInteger) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + value_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_NullableInteger::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int64 value = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_NullableInteger::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.NullableInteger) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 value = 1; + if (this->value() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_value(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.NullableInteger) + return target; +} + +size_t ParameterizedType_NullableInteger::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.NullableInteger) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 value = 1; + if (this->value() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_value()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_NullableInteger::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.NullableInteger) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_NullableInteger* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.NullableInteger) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.NullableInteger) + MergeFrom(*source); + } +} + +void ParameterizedType_NullableInteger::MergeFrom(const ParameterizedType_NullableInteger& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.NullableInteger) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.value() != 0) { + _internal_set_value(from._internal_value()); + } +} + +void ParameterizedType_NullableInteger::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.NullableInteger) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_NullableInteger::CopyFrom(const ParameterizedType_NullableInteger& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.NullableInteger) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_NullableInteger::IsInitialized() const { + return true; +} + +void ParameterizedType_NullableInteger::InternalSwap(ParameterizedType_NullableInteger* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(value_, other->value_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_NullableInteger::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[2]); +} + +// =================================================================== + +class ParameterizedType_ParameterizedFixedChar::_Internal { + public: + static const ::io::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedChar* msg); + static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedFixedChar* msg); +}; + +const ::io::substrait::ParameterizedType_IntegerOption& +ParameterizedType_ParameterizedFixedChar::_Internal::length(const ParameterizedType_ParameterizedFixedChar* msg) { + return *msg->length_; +} +const ::io::substrait::Type_Variation& +ParameterizedType_ParameterizedFixedChar::_Internal::variation(const ParameterizedType_ParameterizedFixedChar* msg) { + return *msg->variation_; +} +void ParameterizedType_ParameterizedFixedChar::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedFixedChar) +} +ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(const ParameterizedType_ParameterizedFixedChar& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_length()) { + length_ = new ::io::substrait::ParameterizedType_IntegerOption(*from.length_); + } else { + length_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedFixedChar) +} + +void ParameterizedType_ParameterizedFixedChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); +} + +ParameterizedType_ParameterizedFixedChar::~ParameterizedType_ParameterizedFixedChar() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedFixedChar) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_ParameterizedFixedChar::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete length_; + if (this != internal_default_instance()) delete variation_; +} + +void ParameterizedType_ParameterizedFixedChar::ArenaDtor(void* object) { + ParameterizedType_ParameterizedFixedChar* _this = reinterpret_cast< ParameterizedType_ParameterizedFixedChar* >(object); + (void)_this; +} +void ParameterizedType_ParameterizedFixedChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_ParameterizedFixedChar::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_ParameterizedFixedChar::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedFixedChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_ParameterizedFixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ParameterizedType.IntegerOption length = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedChar::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedFixedChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ParameterizedType.IntegerOption length = 1; + if (this->has_length()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::length(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedFixedChar) + return target; +} + +size_t ParameterizedType_ParameterizedFixedChar::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedFixedChar) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ParameterizedType.IntegerOption length = 1; + if (this->has_length()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *length_); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_ParameterizedFixedChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedFixedChar) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_ParameterizedFixedChar* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedFixedChar) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedFixedChar) + MergeFrom(*source); + } +} + +void ParameterizedType_ParameterizedFixedChar::MergeFrom(const ParameterizedType_ParameterizedFixedChar& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedFixedChar) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_length()) { + _internal_mutable_length()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void ParameterizedType_ParameterizedFixedChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedFixedChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_ParameterizedFixedChar::CopyFrom(const ParameterizedType_ParameterizedFixedChar& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedFixedChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_ParameterizedFixedChar::IsInitialized() const { + return true; +} + +void ParameterizedType_ParameterizedFixedChar::InternalSwap(ParameterizedType_ParameterizedFixedChar* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedChar, nullability_) + + sizeof(ParameterizedType_ParameterizedFixedChar::nullability_) + - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedChar, length_)>( + reinterpret_cast(&length_), + reinterpret_cast(&other->length_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedFixedChar::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[3]); +} + +// =================================================================== + +class ParameterizedType_ParameterizedVarChar::_Internal { + public: + static const ::io::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedVarChar* msg); + static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedVarChar* msg); +}; + +const ::io::substrait::ParameterizedType_IntegerOption& +ParameterizedType_ParameterizedVarChar::_Internal::length(const ParameterizedType_ParameterizedVarChar* msg) { + return *msg->length_; +} +const ::io::substrait::Type_Variation& +ParameterizedType_ParameterizedVarChar::_Internal::variation(const ParameterizedType_ParameterizedVarChar* msg) { + return *msg->variation_; +} +void ParameterizedType_ParameterizedVarChar::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedVarChar) +} +ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(const ParameterizedType_ParameterizedVarChar& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_length()) { + length_ = new ::io::substrait::ParameterizedType_IntegerOption(*from.length_); + } else { + length_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedVarChar) +} + +void ParameterizedType_ParameterizedVarChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); +} + +ParameterizedType_ParameterizedVarChar::~ParameterizedType_ParameterizedVarChar() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedVarChar) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_ParameterizedVarChar::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete length_; + if (this != internal_default_instance()) delete variation_; +} + +void ParameterizedType_ParameterizedVarChar::ArenaDtor(void* object) { + ParameterizedType_ParameterizedVarChar* _this = reinterpret_cast< ParameterizedType_ParameterizedVarChar* >(object); + (void)_this; +} +void ParameterizedType_ParameterizedVarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_ParameterizedVarChar::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_ParameterizedVarChar::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedVarChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_ParameterizedVarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ParameterizedType.IntegerOption length = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedVarChar::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedVarChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ParameterizedType.IntegerOption length = 1; + if (this->has_length()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::length(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedVarChar) + return target; +} + +size_t ParameterizedType_ParameterizedVarChar::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedVarChar) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ParameterizedType.IntegerOption length = 1; + if (this->has_length()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *length_); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_ParameterizedVarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedVarChar) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_ParameterizedVarChar* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedVarChar) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedVarChar) + MergeFrom(*source); + } +} + +void ParameterizedType_ParameterizedVarChar::MergeFrom(const ParameterizedType_ParameterizedVarChar& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedVarChar) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_length()) { + _internal_mutable_length()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void ParameterizedType_ParameterizedVarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedVarChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_ParameterizedVarChar::CopyFrom(const ParameterizedType_ParameterizedVarChar& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedVarChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_ParameterizedVarChar::IsInitialized() const { + return true; +} + +void ParameterizedType_ParameterizedVarChar::InternalSwap(ParameterizedType_ParameterizedVarChar* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedVarChar, nullability_) + + sizeof(ParameterizedType_ParameterizedVarChar::nullability_) + - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedVarChar, length_)>( + reinterpret_cast(&length_), + reinterpret_cast(&other->length_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedVarChar::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[4]); +} + +// =================================================================== + +class ParameterizedType_ParameterizedFixedBinary::_Internal { + public: + static const ::io::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedBinary* msg); + static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedFixedBinary* msg); +}; + +const ::io::substrait::ParameterizedType_IntegerOption& +ParameterizedType_ParameterizedFixedBinary::_Internal::length(const ParameterizedType_ParameterizedFixedBinary* msg) { + return *msg->length_; +} +const ::io::substrait::Type_Variation& +ParameterizedType_ParameterizedFixedBinary::_Internal::variation(const ParameterizedType_ParameterizedFixedBinary* msg) { + return *msg->variation_; +} +void ParameterizedType_ParameterizedFixedBinary::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedFixedBinary) +} +ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(const ParameterizedType_ParameterizedFixedBinary& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_length()) { + length_ = new ::io::substrait::ParameterizedType_IntegerOption(*from.length_); + } else { + length_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedFixedBinary) +} + +void ParameterizedType_ParameterizedFixedBinary::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); +} + +ParameterizedType_ParameterizedFixedBinary::~ParameterizedType_ParameterizedFixedBinary() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedFixedBinary) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_ParameterizedFixedBinary::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete length_; + if (this != internal_default_instance()) delete variation_; +} + +void ParameterizedType_ParameterizedFixedBinary::ArenaDtor(void* object) { + ParameterizedType_ParameterizedFixedBinary* _this = reinterpret_cast< ParameterizedType_ParameterizedFixedBinary* >(object); + (void)_this; +} +void ParameterizedType_ParameterizedFixedBinary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_ParameterizedFixedBinary::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_ParameterizedFixedBinary::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_ParameterizedFixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ParameterizedType.IntegerOption length = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedBinary::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ParameterizedType.IntegerOption length = 1; + if (this->has_length()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::length(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedFixedBinary) + return target; +} + +size_t ParameterizedType_ParameterizedFixedBinary::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ParameterizedType.IntegerOption length = 1; + if (this->has_length()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *length_); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_ParameterizedFixedBinary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_ParameterizedFixedBinary* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedFixedBinary) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedFixedBinary) + MergeFrom(*source); + } +} + +void ParameterizedType_ParameterizedFixedBinary::MergeFrom(const ParameterizedType_ParameterizedFixedBinary& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_length()) { + _internal_mutable_length()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void ParameterizedType_ParameterizedFixedBinary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_ParameterizedFixedBinary::CopyFrom(const ParameterizedType_ParameterizedFixedBinary& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_ParameterizedFixedBinary::IsInitialized() const { + return true; +} + +void ParameterizedType_ParameterizedFixedBinary::InternalSwap(ParameterizedType_ParameterizedFixedBinary* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedBinary, nullability_) + + sizeof(ParameterizedType_ParameterizedFixedBinary::nullability_) + - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedBinary, length_)>( + reinterpret_cast(&length_), + reinterpret_cast(&other->length_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedFixedBinary::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[5]); +} + +// =================================================================== + +class ParameterizedType_ParameterizedDecimal::_Internal { + public: + static const ::io::substrait::ParameterizedType_IntegerOption& scale(const ParameterizedType_ParameterizedDecimal* msg); + static const ::io::substrait::ParameterizedType_IntegerOption& precision(const ParameterizedType_ParameterizedDecimal* msg); + static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedDecimal* msg); +}; + +const ::io::substrait::ParameterizedType_IntegerOption& +ParameterizedType_ParameterizedDecimal::_Internal::scale(const ParameterizedType_ParameterizedDecimal* msg) { + return *msg->scale_; +} +const ::io::substrait::ParameterizedType_IntegerOption& +ParameterizedType_ParameterizedDecimal::_Internal::precision(const ParameterizedType_ParameterizedDecimal* msg) { + return *msg->precision_; +} +const ::io::substrait::Type_Variation& +ParameterizedType_ParameterizedDecimal::_Internal::variation(const ParameterizedType_ParameterizedDecimal* msg) { + return *msg->variation_; +} +void ParameterizedType_ParameterizedDecimal::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedDecimal) +} +ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(const ParameterizedType_ParameterizedDecimal& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_scale()) { + scale_ = new ::io::substrait::ParameterizedType_IntegerOption(*from.scale_); + } else { + scale_ = nullptr; + } + if (from._internal_has_precision()) { + precision_ = new ::io::substrait::ParameterizedType_IntegerOption(*from.precision_); + } else { + precision_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedDecimal) +} + +void ParameterizedType_ParameterizedDecimal::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&scale_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&scale_)) + sizeof(nullability_)); +} + +ParameterizedType_ParameterizedDecimal::~ParameterizedType_ParameterizedDecimal() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedDecimal) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_ParameterizedDecimal::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete scale_; + if (this != internal_default_instance()) delete precision_; + if (this != internal_default_instance()) delete variation_; +} + +void ParameterizedType_ParameterizedDecimal::ArenaDtor(void* object) { + ParameterizedType_ParameterizedDecimal* _this = reinterpret_cast< ParameterizedType_ParameterizedDecimal* >(object); + (void)_this; +} +void ParameterizedType_ParameterizedDecimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_ParameterizedDecimal::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_ParameterizedDecimal::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedDecimal) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && scale_ != nullptr) { + delete scale_; + } + scale_ = nullptr; + if (GetArena() == nullptr && precision_ != nullptr) { + delete precision_; + } + precision_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_ParameterizedDecimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ParameterizedType.IntegerOption scale = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.IntegerOption precision = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedDecimal::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedDecimal) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ParameterizedType.IntegerOption scale = 1; + if (this->has_scale()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::scale(this), target, stream); + } + + // .io.substrait.ParameterizedType.IntegerOption precision = 2; + if (this->has_precision()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::precision(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedDecimal) + return target; +} + +size_t ParameterizedType_ParameterizedDecimal::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedDecimal) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ParameterizedType.IntegerOption scale = 1; + if (this->has_scale()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *scale_); + } + + // .io.substrait.ParameterizedType.IntegerOption precision = 2; + if (this->has_precision()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *precision_); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_ParameterizedDecimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedDecimal) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_ParameterizedDecimal* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedDecimal) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedDecimal) + MergeFrom(*source); + } +} + +void ParameterizedType_ParameterizedDecimal::MergeFrom(const ParameterizedType_ParameterizedDecimal& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedDecimal) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_scale()) { + _internal_mutable_scale()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_scale()); + } + if (from.has_precision()) { + _internal_mutable_precision()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_precision()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void ParameterizedType_ParameterizedDecimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedDecimal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_ParameterizedDecimal::CopyFrom(const ParameterizedType_ParameterizedDecimal& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedDecimal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_ParameterizedDecimal::IsInitialized() const { + return true; +} + +void ParameterizedType_ParameterizedDecimal::InternalSwap(ParameterizedType_ParameterizedDecimal* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedDecimal, nullability_) + + sizeof(ParameterizedType_ParameterizedDecimal::nullability_) + - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedDecimal, scale_)>( + reinterpret_cast(&scale_), + reinterpret_cast(&other->scale_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedDecimal::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[6]); +} + +// =================================================================== + +class ParameterizedType_ParameterizedStruct::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedStruct* msg); +}; + +const ::io::substrait::Type_Variation& +ParameterizedType_ParameterizedStruct::_Internal::variation(const ParameterizedType_ParameterizedStruct* msg) { + return *msg->variation_; +} +void ParameterizedType_ParameterizedStruct::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + types_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedStruct) +} +ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(const ParameterizedType_ParameterizedStruct& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + types_(from.types_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedStruct) +} + +void ParameterizedType_ParameterizedStruct::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +ParameterizedType_ParameterizedStruct::~ParameterizedType_ParameterizedStruct() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedStruct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_ParameterizedStruct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void ParameterizedType_ParameterizedStruct::ArenaDtor(void* object) { + ParameterizedType_ParameterizedStruct* _this = reinterpret_cast< ParameterizedType_ParameterizedStruct* >(object); + (void)_this; +} +void ParameterizedType_ParameterizedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_ParameterizedStruct::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_ParameterizedStruct::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + types_.Clear(); + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_ParameterizedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.ParameterizedType types = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_types(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedStruct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.ParameterizedType types = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_types_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_types(i), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedStruct) + return target; +} + +size_t ParameterizedType_ParameterizedStruct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedStruct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.ParameterizedType types = 1; + total_size += 1UL * this->_internal_types_size(); + for (const auto& msg : this->types_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_ParameterizedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedStruct) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_ParameterizedStruct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedStruct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedStruct) + MergeFrom(*source); + } +} + +void ParameterizedType_ParameterizedStruct::MergeFrom(const ParameterizedType_ParameterizedStruct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedStruct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + types_.MergeFrom(from.types_); + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void ParameterizedType_ParameterizedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_ParameterizedStruct::CopyFrom(const ParameterizedType_ParameterizedStruct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_ParameterizedStruct::IsInitialized() const { + return true; +} + +void ParameterizedType_ParameterizedStruct::InternalSwap(ParameterizedType_ParameterizedStruct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + types_.InternalSwap(&other->types_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedStruct, nullability_) + + sizeof(ParameterizedType_ParameterizedStruct::nullability_) + - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedStruct, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedStruct::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[7]); +} + +// =================================================================== + +class ParameterizedType_ParameterizedNamedStruct::_Internal { + public: + static const ::io::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType_ParameterizedNamedStruct* msg); +}; + +const ::io::substrait::ParameterizedType_ParameterizedStruct& +ParameterizedType_ParameterizedNamedStruct::_Internal::struct_(const ParameterizedType_ParameterizedNamedStruct* msg) { + return *msg->struct__; +} +ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + names_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedNamedStruct) +} +ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(const ParameterizedType_ParameterizedNamedStruct& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + names_(from.names_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_struct_()) { + struct__ = new ::io::substrait::ParameterizedType_ParameterizedStruct(*from.struct__); + } else { + struct__ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedNamedStruct) +} + +void ParameterizedType_ParameterizedNamedStruct::SharedCtor() { +struct__ = nullptr; +} + +ParameterizedType_ParameterizedNamedStruct::~ParameterizedType_ParameterizedNamedStruct() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedNamedStruct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_ParameterizedNamedStruct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete struct__; +} + +void ParameterizedType_ParameterizedNamedStruct::ArenaDtor(void* object) { + ParameterizedType_ParameterizedNamedStruct* _this = reinterpret_cast< ParameterizedType_ParameterizedNamedStruct* >(object); + (void)_this; +} +void ParameterizedType_ParameterizedNamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_ParameterizedNamedStruct::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_ParameterizedNamedStruct::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + names_.Clear(); + if (GetArena() == nullptr && struct__ != nullptr) { + delete struct__; + } + struct__ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_ParameterizedNamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string names = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_names(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ParameterizedType.ParameterizedNamedStruct.names")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.ParameterizedStruct struct = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedNamedStruct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string names = 1; + for (int i = 0, n = this->_internal_names_size(); i < n; i++) { + const auto& s = this->_internal_names(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.ParameterizedType.ParameterizedNamedStruct.names"); + target = stream->WriteString(1, s, target); + } + + // .io.substrait.ParameterizedType.ParameterizedStruct struct = 2; + if (this->has_struct_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::struct_(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedNamedStruct) + return target; +} + +size_t ParameterizedType_ParameterizedNamedStruct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string names = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); + for (int i = 0, n = names_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + names_.Get(i)); + } + + // .io.substrait.ParameterizedType.ParameterizedStruct struct = 2; + if (this->has_struct_()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *struct__); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_ParameterizedNamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_ParameterizedNamedStruct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedNamedStruct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedNamedStruct) + MergeFrom(*source); + } +} + +void ParameterizedType_ParameterizedNamedStruct::MergeFrom(const ParameterizedType_ParameterizedNamedStruct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + names_.MergeFrom(from.names_); + if (from.has_struct_()) { + _internal_mutable_struct_()->::io::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); + } +} + +void ParameterizedType_ParameterizedNamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_ParameterizedNamedStruct::CopyFrom(const ParameterizedType_ParameterizedNamedStruct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_ParameterizedNamedStruct::IsInitialized() const { + return true; +} + +void ParameterizedType_ParameterizedNamedStruct::InternalSwap(ParameterizedType_ParameterizedNamedStruct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + names_.InternalSwap(&other->names_); + swap(struct__, other->struct__); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedNamedStruct::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[8]); +} + +// =================================================================== + +class ParameterizedType_ParameterizedList::_Internal { + public: + static const ::io::substrait::ParameterizedType& type(const ParameterizedType_ParameterizedList* msg); + static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedList* msg); +}; + +const ::io::substrait::ParameterizedType& +ParameterizedType_ParameterizedList::_Internal::type(const ParameterizedType_ParameterizedList* msg) { + return *msg->type_; +} +const ::io::substrait::Type_Variation& +ParameterizedType_ParameterizedList::_Internal::variation(const ParameterizedType_ParameterizedList* msg) { + return *msg->variation_; +} +void ParameterizedType_ParameterizedList::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedList) +} +ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(const ParameterizedType_ParameterizedList& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_type()) { + type_ = new ::io::substrait::ParameterizedType(*from.type_); + } else { + type_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedList) +} + +void ParameterizedType_ParameterizedList::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_)) + sizeof(nullability_)); +} + +ParameterizedType_ParameterizedList::~ParameterizedType_ParameterizedList() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedList) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_ParameterizedList::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete type_; + if (this != internal_default_instance()) delete variation_; +} + +void ParameterizedType_ParameterizedList::ArenaDtor(void* object) { + ParameterizedType_ParameterizedList* _this = reinterpret_cast< ParameterizedType_ParameterizedList* >(object); + (void)_this; +} +void ParameterizedType_ParameterizedList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_ParameterizedList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_ParameterizedList::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_ParameterizedList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ParameterizedType type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedList::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ParameterizedType type = 1; + if (this->has_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::type(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedList) + return target; +} + +size_t ParameterizedType_ParameterizedList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedList) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ParameterizedType type = 1; + if (this->has_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_ParameterizedList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedList) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_ParameterizedList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedList) + MergeFrom(*source); + } +} + +void ParameterizedType_ParameterizedList::MergeFrom(const ParameterizedType_ParameterizedList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_type()) { + _internal_mutable_type()->::io::substrait::ParameterizedType::MergeFrom(from._internal_type()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void ParameterizedType_ParameterizedList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_ParameterizedList::CopyFrom(const ParameterizedType_ParameterizedList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_ParameterizedList::IsInitialized() const { + return true; +} + +void ParameterizedType_ParameterizedList::InternalSwap(ParameterizedType_ParameterizedList* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedList, nullability_) + + sizeof(ParameterizedType_ParameterizedList::nullability_) + - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedList, type_)>( + reinterpret_cast(&type_), + reinterpret_cast(&other->type_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedList::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[9]); +} + +// =================================================================== + +class ParameterizedType_ParameterizedMap::_Internal { + public: + static const ::io::substrait::ParameterizedType& key(const ParameterizedType_ParameterizedMap* msg); + static const ::io::substrait::ParameterizedType& value(const ParameterizedType_ParameterizedMap* msg); + static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedMap* msg); +}; + +const ::io::substrait::ParameterizedType& +ParameterizedType_ParameterizedMap::_Internal::key(const ParameterizedType_ParameterizedMap* msg) { + return *msg->key_; +} +const ::io::substrait::ParameterizedType& +ParameterizedType_ParameterizedMap::_Internal::value(const ParameterizedType_ParameterizedMap* msg) { + return *msg->value_; +} +const ::io::substrait::Type_Variation& +ParameterizedType_ParameterizedMap::_Internal::variation(const ParameterizedType_ParameterizedMap* msg) { + return *msg->variation_; +} +void ParameterizedType_ParameterizedMap::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedMap) +} +ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(const ParameterizedType_ParameterizedMap& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_key()) { + key_ = new ::io::substrait::ParameterizedType(*from.key_); + } else { + key_ = nullptr; + } + if (from._internal_has_value()) { + value_ = new ::io::substrait::ParameterizedType(*from.value_); + } else { + value_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedMap) +} + +void ParameterizedType_ParameterizedMap::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&key_)) + sizeof(nullability_)); +} + +ParameterizedType_ParameterizedMap::~ParameterizedType_ParameterizedMap() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedMap) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_ParameterizedMap::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete key_; + if (this != internal_default_instance()) delete value_; + if (this != internal_default_instance()) delete variation_; +} + +void ParameterizedType_ParameterizedMap::ArenaDtor(void* object) { + ParameterizedType_ParameterizedMap* _this = reinterpret_cast< ParameterizedType_ParameterizedMap* >(object); + (void)_this; +} +void ParameterizedType_ParameterizedMap::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_ParameterizedMap::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_ParameterizedMap::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedMap) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && key_ != nullptr) { + delete key_; + } + key_ = nullptr; + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_ParameterizedMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ParameterizedType key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedMap::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedMap) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ParameterizedType key = 1; + if (this->has_key()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::key(this), target, stream); + } + + // .io.substrait.ParameterizedType value = 2; + if (this->has_value()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::value(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedMap) + return target; +} + +size_t ParameterizedType_ParameterizedMap::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedMap) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ParameterizedType key = 1; + if (this->has_key()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *key_); + } + + // .io.substrait.ParameterizedType value = 2; + if (this->has_value()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_ParameterizedMap::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedMap) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_ParameterizedMap* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedMap) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedMap) + MergeFrom(*source); + } +} + +void ParameterizedType_ParameterizedMap::MergeFrom(const ParameterizedType_ParameterizedMap& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedMap) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_key()) { + _internal_mutable_key()->::io::substrait::ParameterizedType::MergeFrom(from._internal_key()); + } + if (from.has_value()) { + _internal_mutable_value()->::io::substrait::ParameterizedType::MergeFrom(from._internal_value()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void ParameterizedType_ParameterizedMap::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedMap) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_ParameterizedMap::CopyFrom(const ParameterizedType_ParameterizedMap& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedMap) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_ParameterizedMap::IsInitialized() const { + return true; +} + +void ParameterizedType_ParameterizedMap::InternalSwap(ParameterizedType_ParameterizedMap* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedMap, nullability_) + + sizeof(ParameterizedType_ParameterizedMap::nullability_) + - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedMap, key_)>( + reinterpret_cast(&key_), + reinterpret_cast(&other->key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedMap::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[10]); +} + +// =================================================================== + +class ParameterizedType_IntegerOption::_Internal { + public: + static const ::io::substrait::ParameterizedType_IntegerParameter& parameter(const ParameterizedType_IntegerOption* msg); +}; + +const ::io::substrait::ParameterizedType_IntegerParameter& +ParameterizedType_IntegerOption::_Internal::parameter(const ParameterizedType_IntegerOption* msg) { + return *msg->integer_type_.parameter_; +} +void ParameterizedType_IntegerOption::set_allocated_parameter(::io::substrait::ParameterizedType_IntegerParameter* parameter) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_integer_type(); + if (parameter) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(parameter); + if (message_arena != submessage_arena) { + parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, parameter, submessage_arena); + } + set_has_parameter(); + integer_type_.parameter_ = parameter; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.IntegerOption.parameter) +} +ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.IntegerOption) +} +ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(const ParameterizedType_IntegerOption& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_integer_type(); + switch (from.integer_type_case()) { + case kLiteral: { + _internal_set_literal(from._internal_literal()); + break; + } + case kParameter: { + _internal_mutable_parameter()->::io::substrait::ParameterizedType_IntegerParameter::MergeFrom(from._internal_parameter()); + break; + } + case INTEGER_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.IntegerOption) +} + +void ParameterizedType_IntegerOption::SharedCtor() { +clear_has_integer_type(); +} + +ParameterizedType_IntegerOption::~ParameterizedType_IntegerOption() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.IntegerOption) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType_IntegerOption::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_integer_type()) { + clear_integer_type(); + } +} + +void ParameterizedType_IntegerOption::ArenaDtor(void* object) { + ParameterizedType_IntegerOption* _this = reinterpret_cast< ParameterizedType_IntegerOption* >(object); + (void)_this; +} +void ParameterizedType_IntegerOption::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType_IntegerOption::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType_IntegerOption::clear_integer_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.ParameterizedType.IntegerOption) + switch (integer_type_case()) { + case kLiteral: { + // No need to clear + break; + } + case kParameter: { + if (GetArena() == nullptr) { + delete integer_type_.parameter_; + } + break; + } + case INTEGER_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = INTEGER_TYPE_NOT_SET; +} + + +void ParameterizedType_IntegerOption::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.IntegerOption) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_integer_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType_IntegerOption::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 literal = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _internal_set_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.IntegerParameter parameter = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_parameter(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerOption::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.IntegerOption) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 literal = 1; + if (_internal_has_literal()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_literal(), target); + } + + // .io.substrait.ParameterizedType.IntegerParameter parameter = 2; + if (_internal_has_parameter()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::parameter(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.IntegerOption) + return target; +} + +size_t ParameterizedType_IntegerOption::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.IntegerOption) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (integer_type_case()) { + // int32 literal = 1; + case kLiteral: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_literal()); + break; + } + // .io.substrait.ParameterizedType.IntegerParameter parameter = 2; + case kParameter: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *integer_type_.parameter_); + break; + } + case INTEGER_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType_IntegerOption::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.IntegerOption) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType_IntegerOption* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.IntegerOption) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.IntegerOption) + MergeFrom(*source); + } +} + +void ParameterizedType_IntegerOption::MergeFrom(const ParameterizedType_IntegerOption& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.IntegerOption) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.integer_type_case()) { + case kLiteral: { + _internal_set_literal(from._internal_literal()); + break; + } + case kParameter: { + _internal_mutable_parameter()->::io::substrait::ParameterizedType_IntegerParameter::MergeFrom(from._internal_parameter()); + break; + } + case INTEGER_TYPE_NOT_SET: { + break; + } + } +} + +void ParameterizedType_IntegerOption::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.IntegerOption) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType_IntegerOption::CopyFrom(const ParameterizedType_IntegerOption& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.IntegerOption) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType_IntegerOption::IsInitialized() const { + return true; +} + +void ParameterizedType_IntegerOption::InternalSwap(ParameterizedType_IntegerOption* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(integer_type_, other->integer_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_IntegerOption::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[11]); +} + +// =================================================================== + +class ParameterizedType::_Internal { + public: + static const ::io::substrait::Type_Boolean& bool_(const ParameterizedType* msg); + static const ::io::substrait::Type_I8& i8(const ParameterizedType* msg); + static const ::io::substrait::Type_I16& i16(const ParameterizedType* msg); + static const ::io::substrait::Type_I32& i32(const ParameterizedType* msg); + static const ::io::substrait::Type_I64& i64(const ParameterizedType* msg); + static const ::io::substrait::Type_FP32& fp32(const ParameterizedType* msg); + static const ::io::substrait::Type_FP64& fp64(const ParameterizedType* msg); + static const ::io::substrait::Type_String& string(const ParameterizedType* msg); + static const ::io::substrait::Type_Binary& binary(const ParameterizedType* msg); + static const ::io::substrait::Type_Timestamp& timestamp(const ParameterizedType* msg); + static const ::io::substrait::Type_Date& date(const ParameterizedType* msg); + static const ::io::substrait::Type_Time& time(const ParameterizedType* msg); + static const ::io::substrait::Type_IntervalYear& interval_year(const ParameterizedType* msg); + static const ::io::substrait::Type_IntervalDay& interval_day(const ParameterizedType* msg); + static const ::io::substrait::Type_TimestampTZ& timestamp_tz(const ParameterizedType* msg); + static const ::io::substrait::Type_UUID& uuid(const ParameterizedType* msg); + static const ::io::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char(const ParameterizedType* msg); + static const ::io::substrait::ParameterizedType_ParameterizedVarChar& varchar(const ParameterizedType* msg); + static const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary(const ParameterizedType* msg); + static const ::io::substrait::ParameterizedType_ParameterizedDecimal& decimal(const ParameterizedType* msg); + static const ::io::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType* msg); + static const ::io::substrait::ParameterizedType_ParameterizedList& list(const ParameterizedType* msg); + static const ::io::substrait::ParameterizedType_ParameterizedMap& map(const ParameterizedType* msg); + static const ::io::substrait::Extensions_TypeId& user_defined(const ParameterizedType* msg); + static const ::io::substrait::ParameterizedType_TypeParameter& type_parameter(const ParameterizedType* msg); +}; + +const ::io::substrait::Type_Boolean& +ParameterizedType::_Internal::bool_(const ParameterizedType* msg) { + return *msg->kind_.bool__; +} +const ::io::substrait::Type_I8& +ParameterizedType::_Internal::i8(const ParameterizedType* msg) { + return *msg->kind_.i8_; +} +const ::io::substrait::Type_I16& +ParameterizedType::_Internal::i16(const ParameterizedType* msg) { + return *msg->kind_.i16_; +} +const ::io::substrait::Type_I32& +ParameterizedType::_Internal::i32(const ParameterizedType* msg) { + return *msg->kind_.i32_; +} +const ::io::substrait::Type_I64& +ParameterizedType::_Internal::i64(const ParameterizedType* msg) { + return *msg->kind_.i64_; +} +const ::io::substrait::Type_FP32& +ParameterizedType::_Internal::fp32(const ParameterizedType* msg) { + return *msg->kind_.fp32_; +} +const ::io::substrait::Type_FP64& +ParameterizedType::_Internal::fp64(const ParameterizedType* msg) { + return *msg->kind_.fp64_; +} +const ::io::substrait::Type_String& +ParameterizedType::_Internal::string(const ParameterizedType* msg) { + return *msg->kind_.string_; +} +const ::io::substrait::Type_Binary& +ParameterizedType::_Internal::binary(const ParameterizedType* msg) { + return *msg->kind_.binary_; +} +const ::io::substrait::Type_Timestamp& +ParameterizedType::_Internal::timestamp(const ParameterizedType* msg) { + return *msg->kind_.timestamp_; +} +const ::io::substrait::Type_Date& +ParameterizedType::_Internal::date(const ParameterizedType* msg) { + return *msg->kind_.date_; +} +const ::io::substrait::Type_Time& +ParameterizedType::_Internal::time(const ParameterizedType* msg) { + return *msg->kind_.time_; +} +const ::io::substrait::Type_IntervalYear& +ParameterizedType::_Internal::interval_year(const ParameterizedType* msg) { + return *msg->kind_.interval_year_; +} +const ::io::substrait::Type_IntervalDay& +ParameterizedType::_Internal::interval_day(const ParameterizedType* msg) { + return *msg->kind_.interval_day_; +} +const ::io::substrait::Type_TimestampTZ& +ParameterizedType::_Internal::timestamp_tz(const ParameterizedType* msg) { + return *msg->kind_.timestamp_tz_; +} +const ::io::substrait::Type_UUID& +ParameterizedType::_Internal::uuid(const ParameterizedType* msg) { + return *msg->kind_.uuid_; +} +const ::io::substrait::ParameterizedType_ParameterizedFixedChar& +ParameterizedType::_Internal::fixed_char(const ParameterizedType* msg) { + return *msg->kind_.fixed_char_; +} +const ::io::substrait::ParameterizedType_ParameterizedVarChar& +ParameterizedType::_Internal::varchar(const ParameterizedType* msg) { + return *msg->kind_.varchar_; +} +const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& +ParameterizedType::_Internal::fixed_binary(const ParameterizedType* msg) { + return *msg->kind_.fixed_binary_; +} +const ::io::substrait::ParameterizedType_ParameterizedDecimal& +ParameterizedType::_Internal::decimal(const ParameterizedType* msg) { + return *msg->kind_.decimal_; +} +const ::io::substrait::ParameterizedType_ParameterizedStruct& +ParameterizedType::_Internal::struct_(const ParameterizedType* msg) { + return *msg->kind_.struct__; +} +const ::io::substrait::ParameterizedType_ParameterizedList& +ParameterizedType::_Internal::list(const ParameterizedType* msg) { + return *msg->kind_.list_; +} +const ::io::substrait::ParameterizedType_ParameterizedMap& +ParameterizedType::_Internal::map(const ParameterizedType* msg) { + return *msg->kind_.map_; +} +const ::io::substrait::Extensions_TypeId& +ParameterizedType::_Internal::user_defined(const ParameterizedType* msg) { + return *msg->kind_.user_defined_; +} +const ::io::substrait::ParameterizedType_TypeParameter& +ParameterizedType::_Internal::type_parameter(const ParameterizedType* msg) { + return *msg->kind_.type_parameter_; +} +void ParameterizedType::set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (bool_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_)->GetArena(); + if (message_arena != submessage_arena) { + bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bool_, submessage_arena); + } + set_has_bool_(); + kind_.bool__ = bool_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.bool) +} +void ParameterizedType::clear_bool_() { + if (_internal_has_bool_()) { + if (GetArena() == nullptr) { + delete kind_.bool__; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_i8(::io::substrait::Type_I8* i8) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i8) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8)->GetArena(); + if (message_arena != submessage_arena) { + i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i8, submessage_arena); + } + set_has_i8(); + kind_.i8_ = i8; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.i8) +} +void ParameterizedType::clear_i8() { + if (_internal_has_i8()) { + if (GetArena() == nullptr) { + delete kind_.i8_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_i16(::io::substrait::Type_I16* i16) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i16) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16)->GetArena(); + if (message_arena != submessage_arena) { + i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i16, submessage_arena); + } + set_has_i16(); + kind_.i16_ = i16; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.i16) +} +void ParameterizedType::clear_i16() { + if (_internal_has_i16()) { + if (GetArena() == nullptr) { + delete kind_.i16_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_i32(::io::substrait::Type_I32* i32) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i32) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32)->GetArena(); + if (message_arena != submessage_arena) { + i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i32, submessage_arena); + } + set_has_i32(); + kind_.i32_ = i32; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.i32) +} +void ParameterizedType::clear_i32() { + if (_internal_has_i32()) { + if (GetArena() == nullptr) { + delete kind_.i32_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_i64(::io::substrait::Type_I64* i64) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i64) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64)->GetArena(); + if (message_arena != submessage_arena) { + i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i64, submessage_arena); + } + set_has_i64(); + kind_.i64_ = i64; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.i64) +} +void ParameterizedType::clear_i64() { + if (_internal_has_i64()) { + if (GetArena() == nullptr) { + delete kind_.i64_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_fp32(::io::substrait::Type_FP32* fp32) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fp32) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32)->GetArena(); + if (message_arena != submessage_arena) { + fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fp32, submessage_arena); + } + set_has_fp32(); + kind_.fp32_ = fp32; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.fp32) +} +void ParameterizedType::clear_fp32() { + if (_internal_has_fp32()) { + if (GetArena() == nullptr) { + delete kind_.fp32_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_fp64(::io::substrait::Type_FP64* fp64) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fp64) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64)->GetArena(); + if (message_arena != submessage_arena) { + fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fp64, submessage_arena); + } + set_has_fp64(); + kind_.fp64_ = fp64; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.fp64) +} +void ParameterizedType::clear_fp64() { + if (_internal_has_fp64()) { + if (GetArena() == nullptr) { + delete kind_.fp64_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_string(::io::substrait::Type_String* string) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (string) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string)->GetArena(); + if (message_arena != submessage_arena) { + string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, string, submessage_arena); + } + set_has_string(); + kind_.string_ = string; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.string) +} +void ParameterizedType::clear_string() { + if (_internal_has_string()) { + if (GetArena() == nullptr) { + delete kind_.string_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_binary(::io::substrait::Type_Binary* binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary)->GetArena(); + if (message_arena != submessage_arena) { + binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, binary, submessage_arena); + } + set_has_binary(); + kind_.binary_ = binary; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.binary) +} +void ParameterizedType::clear_binary() { + if (_internal_has_binary()) { + if (GetArena() == nullptr) { + delete kind_.binary_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (timestamp) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp)->GetArena(); + if (message_arena != submessage_arena) { + timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, timestamp, submessage_arena); + } + set_has_timestamp(); + kind_.timestamp_ = timestamp; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.timestamp) +} +void ParameterizedType::clear_timestamp() { + if (_internal_has_timestamp()) { + if (GetArena() == nullptr) { + delete kind_.timestamp_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_date(::io::substrait::Type_Date* date) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (date) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date)->GetArena(); + if (message_arena != submessage_arena) { + date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, date, submessage_arena); + } + set_has_date(); + kind_.date_ = date; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.date) +} +void ParameterizedType::clear_date() { + if (_internal_has_date()) { + if (GetArena() == nullptr) { + delete kind_.date_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_time(::io::substrait::Type_Time* time) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (time) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time)->GetArena(); + if (message_arena != submessage_arena) { + time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, time, submessage_arena); + } + set_has_time(); + kind_.time_ = time; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.time) +} +void ParameterizedType::clear_time() { + if (_internal_has_time()) { + if (GetArena() == nullptr) { + delete kind_.time_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (interval_year) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year)->GetArena(); + if (message_arena != submessage_arena) { + interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interval_year, submessage_arena); + } + set_has_interval_year(); + kind_.interval_year_ = interval_year; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.interval_year) +} +void ParameterizedType::clear_interval_year() { + if (_internal_has_interval_year()) { + if (GetArena() == nullptr) { + delete kind_.interval_year_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (interval_day) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day)->GetArena(); + if (message_arena != submessage_arena) { + interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interval_day, submessage_arena); + } + set_has_interval_day(); + kind_.interval_day_ = interval_day; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.interval_day) +} +void ParameterizedType::clear_interval_day() { + if (_internal_has_interval_day()) { + if (GetArena() == nullptr) { + delete kind_.interval_day_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (timestamp_tz) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz)->GetArena(); + if (message_arena != submessage_arena) { + timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, timestamp_tz, submessage_arena); + } + set_has_timestamp_tz(); + kind_.timestamp_tz_ = timestamp_tz; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.timestamp_tz) +} +void ParameterizedType::clear_timestamp_tz() { + if (_internal_has_timestamp_tz()) { + if (GetArena() == nullptr) { + delete kind_.timestamp_tz_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_uuid(::io::substrait::Type_UUID* uuid) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (uuid) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid)->GetArena(); + if (message_arena != submessage_arena) { + uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, uuid, submessage_arena); + } + set_has_uuid(); + kind_.uuid_ = uuid; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.uuid) +} +void ParameterizedType::clear_uuid() { + if (_internal_has_uuid()) { + if (GetArena() == nullptr) { + delete kind_.uuid_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_fixed_char(::io::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fixed_char) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_char); + if (message_arena != submessage_arena) { + fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fixed_char, submessage_arena); + } + set_has_fixed_char(); + kind_.fixed_char_ = fixed_char; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.fixed_char) +} +void ParameterizedType::set_allocated_varchar(::io::substrait::ParameterizedType_ParameterizedVarChar* varchar) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (varchar) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(varchar); + if (message_arena != submessage_arena) { + varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, varchar, submessage_arena); + } + set_has_varchar(); + kind_.varchar_ = varchar; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.varchar) +} +void ParameterizedType::set_allocated_fixed_binary(::io::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fixed_binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_binary); + if (message_arena != submessage_arena) { + fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fixed_binary, submessage_arena); + } + set_has_fixed_binary(); + kind_.fixed_binary_ = fixed_binary; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.fixed_binary) +} +void ParameterizedType::set_allocated_decimal(::io::substrait::ParameterizedType_ParameterizedDecimal* decimal) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (decimal) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(decimal); + if (message_arena != submessage_arena) { + decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, decimal, submessage_arena); + } + set_has_decimal(); + kind_.decimal_ = decimal; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.decimal) +} +void ParameterizedType::set_allocated_struct_(::io::substrait::ParameterizedType_ParameterizedStruct* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + set_has_struct_(); + kind_.struct__ = struct_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.struct) +} +void ParameterizedType::set_allocated_list(::io::substrait::ParameterizedType_ParameterizedList* list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + if (message_arena != submessage_arena) { + list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, list, submessage_arena); + } + set_has_list(); + kind_.list_ = list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.list) +} +void ParameterizedType::set_allocated_map(::io::substrait::ParameterizedType_ParameterizedMap* map) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (map) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + if (message_arena != submessage_arena) { + map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map, submessage_arena); + } + set_has_map(); + kind_.map_ = map; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.map) +} +void ParameterizedType::set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (user_defined) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(user_defined)->GetArena(); + if (message_arena != submessage_arena) { + user_defined = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, user_defined, submessage_arena); + } + set_has_user_defined(); + kind_.user_defined_ = user_defined; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.user_defined) +} +void ParameterizedType::clear_user_defined() { + if (_internal_has_user_defined()) { + if (GetArena() == nullptr) { + delete kind_.user_defined_; + } + clear_has_kind(); + } +} +void ParameterizedType::set_allocated_type_parameter(::io::substrait::ParameterizedType_TypeParameter* type_parameter) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (type_parameter) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_parameter); + if (message_arena != submessage_arena) { + type_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type_parameter, submessage_arena); + } + set_has_type_parameter(); + kind_.type_parameter_ = type_parameter; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.type_parameter) +} +ParameterizedType::ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType) +} +ParameterizedType::ParameterizedType(const ParameterizedType& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_kind(); + switch (from.kind_case()) { + case kBool: { + _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + break; + } + case kI8: { + _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + break; + } + case kI16: { + _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + break; + } + case kI32: { + _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + break; + } + case kI64: { + _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + break; + } + case kFp32: { + _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + break; + } + case kFp64: { + _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + break; + } + case kString: { + _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + break; + } + case kBinary: { + _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + break; + } + case kTimestamp: { + _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + break; + } + case kDate: { + _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + break; + } + case kTime: { + _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + break; + } + case kIntervalYear: { + _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + break; + } + case kIntervalDay: { + _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + break; + } + case kTimestampTz: { + _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + break; + } + case kUuid: { + _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + break; + } + case kFixedChar: { + _internal_mutable_fixed_char()->::io::substrait::ParameterizedType_ParameterizedFixedChar::MergeFrom(from._internal_fixed_char()); + break; + } + case kVarchar: { + _internal_mutable_varchar()->::io::substrait::ParameterizedType_ParameterizedVarChar::MergeFrom(from._internal_varchar()); + break; + } + case kFixedBinary: { + _internal_mutable_fixed_binary()->::io::substrait::ParameterizedType_ParameterizedFixedBinary::MergeFrom(from._internal_fixed_binary()); + break; + } + case kDecimal: { + _internal_mutable_decimal()->::io::substrait::ParameterizedType_ParameterizedDecimal::MergeFrom(from._internal_decimal()); + break; + } + case kStruct: { + _internal_mutable_struct_()->::io::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::ParameterizedType_ParameterizedList::MergeFrom(from._internal_list()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map()); + break; + } + case kUserDefined: { + _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + break; + } + case kTypeParameter: { + _internal_mutable_type_parameter()->::io::substrait::ParameterizedType_TypeParameter::MergeFrom(from._internal_type_parameter()); + break; + } + case KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType) +} + +void ParameterizedType::SharedCtor() { +clear_has_kind(); +} + +ParameterizedType::~ParameterizedType() { + // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ParameterizedType::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_kind()) { + clear_kind(); + } +} + +void ParameterizedType::ArenaDtor(void* object) { + ParameterizedType* _this = reinterpret_cast< ParameterizedType* >(object); + (void)_this; +} +void ParameterizedType::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ParameterizedType::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ParameterizedType::clear_kind() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.ParameterizedType) + switch (kind_case()) { + case kBool: { + if (GetArena() == nullptr) { + delete kind_.bool__; + } + break; + } + case kI8: { + if (GetArena() == nullptr) { + delete kind_.i8_; + } + break; + } + case kI16: { + if (GetArena() == nullptr) { + delete kind_.i16_; + } + break; + } + case kI32: { + if (GetArena() == nullptr) { + delete kind_.i32_; + } + break; + } + case kI64: { + if (GetArena() == nullptr) { + delete kind_.i64_; + } + break; + } + case kFp32: { + if (GetArena() == nullptr) { + delete kind_.fp32_; + } + break; + } + case kFp64: { + if (GetArena() == nullptr) { + delete kind_.fp64_; + } + break; + } + case kString: { + if (GetArena() == nullptr) { + delete kind_.string_; + } + break; + } + case kBinary: { + if (GetArena() == nullptr) { + delete kind_.binary_; + } + break; + } + case kTimestamp: { + if (GetArena() == nullptr) { + delete kind_.timestamp_; + } + break; + } + case kDate: { + if (GetArena() == nullptr) { + delete kind_.date_; + } + break; + } + case kTime: { + if (GetArena() == nullptr) { + delete kind_.time_; + } + break; + } + case kIntervalYear: { + if (GetArena() == nullptr) { + delete kind_.interval_year_; + } + break; + } + case kIntervalDay: { + if (GetArena() == nullptr) { + delete kind_.interval_day_; + } + break; + } + case kTimestampTz: { + if (GetArena() == nullptr) { + delete kind_.timestamp_tz_; + } + break; + } + case kUuid: { + if (GetArena() == nullptr) { + delete kind_.uuid_; + } + break; + } + case kFixedChar: { + if (GetArena() == nullptr) { + delete kind_.fixed_char_; + } + break; + } + case kVarchar: { + if (GetArena() == nullptr) { + delete kind_.varchar_; + } + break; + } + case kFixedBinary: { + if (GetArena() == nullptr) { + delete kind_.fixed_binary_; + } + break; + } + case kDecimal: { + if (GetArena() == nullptr) { + delete kind_.decimal_; + } + break; + } + case kStruct: { + if (GetArena() == nullptr) { + delete kind_.struct__; + } + break; + } + case kList: { + if (GetArena() == nullptr) { + delete kind_.list_; + } + break; + } + case kMap: { + if (GetArena() == nullptr) { + delete kind_.map_; + } + break; + } + case kUserDefined: { + if (GetArena() == nullptr) { + delete kind_.user_defined_; + } + break; + } + case kTypeParameter: { + if (GetArena() == nullptr) { + delete kind_.type_parameter_; + } + break; + } + case KIND_NOT_SET: { + break; + } + } + _oneof_case_[0] = KIND_NOT_SET; +} + + +void ParameterizedType::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_kind(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ParameterizedType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Boolean bool = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I8 i8 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I16 i16 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I32 i32 = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I64 i64 = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.FP32 fp32 = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.FP64 fp64 = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.String string = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Binary binary = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Timestamp timestamp = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Date date = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Time time = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.IntervalYear interval_year = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.IntervalDay interval_day = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { + ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { + ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.ParameterizedVarChar varchar = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.ParameterizedDecimal decimal = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.ParameterizedStruct struct = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.ParameterizedList list = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) { + ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.ParameterizedMap map = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { + ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { + ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Extensions.TypeId user_defined = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) { + ptr = ctx->ParseMessage(_internal_mutable_user_defined(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.UUID uuid = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { + ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; + case 33: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_type_parameter(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Boolean bool = 1; + if (_internal_has_bool_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::bool_(this), target, stream); + } + + // .io.substrait.Type.I8 i8 = 2; + if (_internal_has_i8()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::i8(this), target, stream); + } + + // .io.substrait.Type.I16 i16 = 3; + if (_internal_has_i16()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::i16(this), target, stream); + } + + // .io.substrait.Type.I32 i32 = 5; + if (_internal_has_i32()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::i32(this), target, stream); + } + + // .io.substrait.Type.I64 i64 = 7; + if (_internal_has_i64()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::i64(this), target, stream); + } + + // .io.substrait.Type.FP32 fp32 = 10; + if (_internal_has_fp32()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::fp32(this), target, stream); + } + + // .io.substrait.Type.FP64 fp64 = 11; + if (_internal_has_fp64()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::fp64(this), target, stream); + } + + // .io.substrait.Type.String string = 12; + if (_internal_has_string()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 12, _Internal::string(this), target, stream); + } + + // .io.substrait.Type.Binary binary = 13; + if (_internal_has_binary()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 13, _Internal::binary(this), target, stream); + } + + // .io.substrait.Type.Timestamp timestamp = 14; + if (_internal_has_timestamp()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 14, _Internal::timestamp(this), target, stream); + } + + // .io.substrait.Type.Date date = 16; + if (_internal_has_date()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 16, _Internal::date(this), target, stream); + } + + // .io.substrait.Type.Time time = 17; + if (_internal_has_time()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 17, _Internal::time(this), target, stream); + } + + // .io.substrait.Type.IntervalYear interval_year = 19; + if (_internal_has_interval_year()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 19, _Internal::interval_year(this), target, stream); + } + + // .io.substrait.Type.IntervalDay interval_day = 20; + if (_internal_has_interval_day()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 20, _Internal::interval_day(this), target, stream); + } + + // .io.substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; + if (_internal_has_fixed_char()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 21, _Internal::fixed_char(this), target, stream); + } + + // .io.substrait.ParameterizedType.ParameterizedVarChar varchar = 22; + if (_internal_has_varchar()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 22, _Internal::varchar(this), target, stream); + } + + // .io.substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; + if (_internal_has_fixed_binary()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 23, _Internal::fixed_binary(this), target, stream); + } + + // .io.substrait.ParameterizedType.ParameterizedDecimal decimal = 24; + if (_internal_has_decimal()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 24, _Internal::decimal(this), target, stream); + } + + // .io.substrait.ParameterizedType.ParameterizedStruct struct = 25; + if (_internal_has_struct_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 25, _Internal::struct_(this), target, stream); + } + + // .io.substrait.ParameterizedType.ParameterizedList list = 27; + if (_internal_has_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 27, _Internal::list(this), target, stream); + } + + // .io.substrait.ParameterizedType.ParameterizedMap map = 28; + if (_internal_has_map()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 28, _Internal::map(this), target, stream); + } + + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + if (_internal_has_timestamp_tz()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 29, _Internal::timestamp_tz(this), target, stream); + } + + // .io.substrait.Extensions.TypeId user_defined = 31; + if (_internal_has_user_defined()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 31, _Internal::user_defined(this), target, stream); + } + + // .io.substrait.Type.UUID uuid = 32; + if (_internal_has_uuid()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 32, _Internal::uuid(this), target, stream); + } + + // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; + if (_internal_has_type_parameter()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 33, _Internal::type_parameter(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType) + return target; +} + +size_t ParameterizedType::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (kind_case()) { + // .io.substrait.Type.Boolean bool = 1; + case kBool: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.bool__); + break; + } + // .io.substrait.Type.I8 i8 = 2; + case kI8: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i8_); + break; + } + // .io.substrait.Type.I16 i16 = 3; + case kI16: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i16_); + break; + } + // .io.substrait.Type.I32 i32 = 5; + case kI32: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i32_); + break; + } + // .io.substrait.Type.I64 i64 = 7; + case kI64: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i64_); + break; + } + // .io.substrait.Type.FP32 fp32 = 10; + case kFp32: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fp32_); + break; + } + // .io.substrait.Type.FP64 fp64 = 11; + case kFp64: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fp64_); + break; + } + // .io.substrait.Type.String string = 12; + case kString: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.string_); + break; + } + // .io.substrait.Type.Binary binary = 13; + case kBinary: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.binary_); + break; + } + // .io.substrait.Type.Timestamp timestamp = 14; + case kTimestamp: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.timestamp_); + break; + } + // .io.substrait.Type.Date date = 16; + case kDate: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.date_); + break; + } + // .io.substrait.Type.Time time = 17; + case kTime: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.time_); + break; + } + // .io.substrait.Type.IntervalYear interval_year = 19; + case kIntervalYear: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.interval_year_); + break; + } + // .io.substrait.Type.IntervalDay interval_day = 20; + case kIntervalDay: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.interval_day_); + break; + } + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + case kTimestampTz: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.timestamp_tz_); + break; + } + // .io.substrait.Type.UUID uuid = 32; + case kUuid: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.uuid_); + break; + } + // .io.substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; + case kFixedChar: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fixed_char_); + break; + } + // .io.substrait.ParameterizedType.ParameterizedVarChar varchar = 22; + case kVarchar: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.varchar_); + break; + } + // .io.substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; + case kFixedBinary: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fixed_binary_); + break; + } + // .io.substrait.ParameterizedType.ParameterizedDecimal decimal = 24; + case kDecimal: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.decimal_); + break; + } + // .io.substrait.ParameterizedType.ParameterizedStruct struct = 25; + case kStruct: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.struct__); + break; + } + // .io.substrait.ParameterizedType.ParameterizedList list = 27; + case kList: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.list_); + break; + } + // .io.substrait.ParameterizedType.ParameterizedMap map = 28; + case kMap: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.map_); + break; + } + // .io.substrait.Extensions.TypeId user_defined = 31; + case kUserDefined: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.user_defined_); + break; + } + // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; + case kTypeParameter: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.type_parameter_); + break; + } + case KIND_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ParameterizedType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType) + GOOGLE_DCHECK_NE(&from, this); + const ParameterizedType* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType) + MergeFrom(*source); + } +} + +void ParameterizedType::MergeFrom(const ParameterizedType& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.kind_case()) { + case kBool: { + _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + break; + } + case kI8: { + _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + break; + } + case kI16: { + _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + break; + } + case kI32: { + _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + break; + } + case kI64: { + _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + break; + } + case kFp32: { + _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + break; + } + case kFp64: { + _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + break; + } + case kString: { + _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + break; + } + case kBinary: { + _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + break; + } + case kTimestamp: { + _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + break; + } + case kDate: { + _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + break; + } + case kTime: { + _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + break; + } + case kIntervalYear: { + _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + break; + } + case kIntervalDay: { + _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + break; + } + case kTimestampTz: { + _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + break; + } + case kUuid: { + _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + break; + } + case kFixedChar: { + _internal_mutable_fixed_char()->::io::substrait::ParameterizedType_ParameterizedFixedChar::MergeFrom(from._internal_fixed_char()); + break; + } + case kVarchar: { + _internal_mutable_varchar()->::io::substrait::ParameterizedType_ParameterizedVarChar::MergeFrom(from._internal_varchar()); + break; + } + case kFixedBinary: { + _internal_mutable_fixed_binary()->::io::substrait::ParameterizedType_ParameterizedFixedBinary::MergeFrom(from._internal_fixed_binary()); + break; + } + case kDecimal: { + _internal_mutable_decimal()->::io::substrait::ParameterizedType_ParameterizedDecimal::MergeFrom(from._internal_decimal()); + break; + } + case kStruct: { + _internal_mutable_struct_()->::io::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::ParameterizedType_ParameterizedList::MergeFrom(from._internal_list()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map()); + break; + } + case kUserDefined: { + _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + break; + } + case kTypeParameter: { + _internal_mutable_type_parameter()->::io::substrait::ParameterizedType_TypeParameter::MergeFrom(from._internal_type_parameter()); + break; + } + case KIND_NOT_SET: { + break; + } + } +} + +void ParameterizedType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ParameterizedType::CopyFrom(const ParameterizedType& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ParameterizedType::IsInitialized() const { + return true; +} + +void ParameterizedType::InternalSwap(ParameterizedType* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(kind_, other->kind_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, + file_level_metadata_parameterized_5ftypes_2eproto[12]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_TypeParameter* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_TypeParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_TypeParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_IntegerParameter* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_IntegerParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_IntegerParameter >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_NullableInteger* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_NullableInteger >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_NullableInteger >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedFixedChar* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedFixedChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedFixedChar >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedVarChar* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedVarChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedVarChar >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedFixedBinary* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedFixedBinary >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedFixedBinary >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedDecimal* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedDecimal >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedDecimal >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedStruct* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedStruct >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedNamedStruct* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedNamedStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedNamedStruct >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedList* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedList >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedList >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedMap* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedMap >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedMap >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_IntegerOption* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_IntegerOption >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_IntegerOption >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/parameterized_types.pb.h b/cpp/src/generated/substrait/parameterized_types.pb.h new file mode 100644 index 00000000000..ea4edcee94e --- /dev/null +++ b/cpp/src/generated/substrait/parameterized_types.pb.h @@ -0,0 +1,6624 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: parameterized_types.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_parameterized_5ftypes_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_parameterized_5ftypes_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include "type.pb.h" +#include "extensions.pb.h" +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_parameterized_5ftypes_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_parameterized_5ftypes_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[13] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_parameterized_5ftypes_2eproto; +namespace io { +namespace substrait { +class ParameterizedType; +struct ParameterizedTypeDefaultTypeInternal; +extern ParameterizedTypeDefaultTypeInternal _ParameterizedType_default_instance_; +class ParameterizedType_IntegerOption; +struct ParameterizedType_IntegerOptionDefaultTypeInternal; +extern ParameterizedType_IntegerOptionDefaultTypeInternal _ParameterizedType_IntegerOption_default_instance_; +class ParameterizedType_IntegerParameter; +struct ParameterizedType_IntegerParameterDefaultTypeInternal; +extern ParameterizedType_IntegerParameterDefaultTypeInternal _ParameterizedType_IntegerParameter_default_instance_; +class ParameterizedType_NullableInteger; +struct ParameterizedType_NullableIntegerDefaultTypeInternal; +extern ParameterizedType_NullableIntegerDefaultTypeInternal _ParameterizedType_NullableInteger_default_instance_; +class ParameterizedType_ParameterizedDecimal; +struct ParameterizedType_ParameterizedDecimalDefaultTypeInternal; +extern ParameterizedType_ParameterizedDecimalDefaultTypeInternal _ParameterizedType_ParameterizedDecimal_default_instance_; +class ParameterizedType_ParameterizedFixedBinary; +struct ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal; +extern ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal _ParameterizedType_ParameterizedFixedBinary_default_instance_; +class ParameterizedType_ParameterizedFixedChar; +struct ParameterizedType_ParameterizedFixedCharDefaultTypeInternal; +extern ParameterizedType_ParameterizedFixedCharDefaultTypeInternal _ParameterizedType_ParameterizedFixedChar_default_instance_; +class ParameterizedType_ParameterizedList; +struct ParameterizedType_ParameterizedListDefaultTypeInternal; +extern ParameterizedType_ParameterizedListDefaultTypeInternal _ParameterizedType_ParameterizedList_default_instance_; +class ParameterizedType_ParameterizedMap; +struct ParameterizedType_ParameterizedMapDefaultTypeInternal; +extern ParameterizedType_ParameterizedMapDefaultTypeInternal _ParameterizedType_ParameterizedMap_default_instance_; +class ParameterizedType_ParameterizedNamedStruct; +struct ParameterizedType_ParameterizedNamedStructDefaultTypeInternal; +extern ParameterizedType_ParameterizedNamedStructDefaultTypeInternal _ParameterizedType_ParameterizedNamedStruct_default_instance_; +class ParameterizedType_ParameterizedStruct; +struct ParameterizedType_ParameterizedStructDefaultTypeInternal; +extern ParameterizedType_ParameterizedStructDefaultTypeInternal _ParameterizedType_ParameterizedStruct_default_instance_; +class ParameterizedType_ParameterizedVarChar; +struct ParameterizedType_ParameterizedVarCharDefaultTypeInternal; +extern ParameterizedType_ParameterizedVarCharDefaultTypeInternal _ParameterizedType_ParameterizedVarChar_default_instance_; +class ParameterizedType_TypeParameter; +struct ParameterizedType_TypeParameterDefaultTypeInternal; +extern ParameterizedType_TypeParameterDefaultTypeInternal _ParameterizedType_TypeParameter_default_instance_; +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::ParameterizedType* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType>(Arena*); +template<> ::io::substrait::ParameterizedType_IntegerOption* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(Arena*); +template<> ::io::substrait::ParameterizedType_IntegerParameter* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerParameter>(Arena*); +template<> ::io::substrait::ParameterizedType_NullableInteger* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_NullableInteger>(Arena*); +template<> ::io::substrait::ParameterizedType_ParameterizedDecimal* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedDecimal>(Arena*); +template<> ::io::substrait::ParameterizedType_ParameterizedFixedBinary* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedFixedBinary>(Arena*); +template<> ::io::substrait::ParameterizedType_ParameterizedFixedChar* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedFixedChar>(Arena*); +template<> ::io::substrait::ParameterizedType_ParameterizedList* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedList>(Arena*); +template<> ::io::substrait::ParameterizedType_ParameterizedMap* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedMap>(Arena*); +template<> ::io::substrait::ParameterizedType_ParameterizedNamedStruct* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedNamedStruct>(Arena*); +template<> ::io::substrait::ParameterizedType_ParameterizedStruct* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedStruct>(Arena*); +template<> ::io::substrait::ParameterizedType_ParameterizedVarChar* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedVarChar>(Arena*); +template<> ::io::substrait::ParameterizedType_TypeParameter* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_TypeParameter>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace io { +namespace substrait { + +// =================================================================== + +class ParameterizedType_TypeParameter PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.TypeParameter) */ { + public: + inline ParameterizedType_TypeParameter() : ParameterizedType_TypeParameter(nullptr) {} + ~ParameterizedType_TypeParameter() override; + explicit constexpr ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_TypeParameter(const ParameterizedType_TypeParameter& from); + ParameterizedType_TypeParameter(ParameterizedType_TypeParameter&& from) noexcept + : ParameterizedType_TypeParameter() { + *this = ::std::move(from); + } + + inline ParameterizedType_TypeParameter& operator=(const ParameterizedType_TypeParameter& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_TypeParameter& operator=(ParameterizedType_TypeParameter&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_TypeParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_TypeParameter* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_TypeParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(ParameterizedType_TypeParameter& a, ParameterizedType_TypeParameter& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_TypeParameter* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_TypeParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_TypeParameter* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_TypeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_TypeParameter& from); + void MergeFrom(const ParameterizedType_TypeParameter& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_TypeParameter* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.TypeParameter"; + } + protected: + explicit ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kBoundsFieldNumber = 2, + kNameFieldNumber = 1, + }; + // repeated .io.substrait.ParameterizedType bounds = 2; + int bounds_size() const; + private: + int _internal_bounds_size() const; + public: + void clear_bounds(); + ::io::substrait::ParameterizedType* mutable_bounds(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >* + mutable_bounds(); + private: + const ::io::substrait::ParameterizedType& _internal_bounds(int index) const; + ::io::substrait::ParameterizedType* _internal_add_bounds(); + public: + const ::io::substrait::ParameterizedType& bounds(int index) const; + ::io::substrait::ParameterizedType* add_bounds(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >& + bounds() const; + + // string name = 1; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.TypeParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType > bounds_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_IntegerParameter PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.IntegerParameter) */ { + public: + inline ParameterizedType_IntegerParameter() : ParameterizedType_IntegerParameter(nullptr) {} + ~ParameterizedType_IntegerParameter() override; + explicit constexpr ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_IntegerParameter(const ParameterizedType_IntegerParameter& from); + ParameterizedType_IntegerParameter(ParameterizedType_IntegerParameter&& from) noexcept + : ParameterizedType_IntegerParameter() { + *this = ::std::move(from); + } + + inline ParameterizedType_IntegerParameter& operator=(const ParameterizedType_IntegerParameter& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_IntegerParameter& operator=(ParameterizedType_IntegerParameter&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_IntegerParameter& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_IntegerParameter* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_IntegerParameter_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(ParameterizedType_IntegerParameter& a, ParameterizedType_IntegerParameter& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_IntegerParameter* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_IntegerParameter* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_IntegerParameter* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_IntegerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_IntegerParameter& from); + void MergeFrom(const ParameterizedType_IntegerParameter& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_IntegerParameter* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.IntegerParameter"; + } + protected: + explicit ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kRangeStartInclusiveFieldNumber = 2, + kRangeEndExclusiveFieldNumber = 3, + }; + // string name = 1; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // .io.substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; + bool has_range_start_inclusive() const; + private: + bool _internal_has_range_start_inclusive() const; + public: + void clear_range_start_inclusive(); + const ::io::substrait::ParameterizedType_NullableInteger& range_start_inclusive() const; + ::io::substrait::ParameterizedType_NullableInteger* release_range_start_inclusive(); + ::io::substrait::ParameterizedType_NullableInteger* mutable_range_start_inclusive(); + void set_allocated_range_start_inclusive(::io::substrait::ParameterizedType_NullableInteger* range_start_inclusive); + private: + const ::io::substrait::ParameterizedType_NullableInteger& _internal_range_start_inclusive() const; + ::io::substrait::ParameterizedType_NullableInteger* _internal_mutable_range_start_inclusive(); + public: + void unsafe_arena_set_allocated_range_start_inclusive( + ::io::substrait::ParameterizedType_NullableInteger* range_start_inclusive); + ::io::substrait::ParameterizedType_NullableInteger* unsafe_arena_release_range_start_inclusive(); + + // .io.substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; + bool has_range_end_exclusive() const; + private: + bool _internal_has_range_end_exclusive() const; + public: + void clear_range_end_exclusive(); + const ::io::substrait::ParameterizedType_NullableInteger& range_end_exclusive() const; + ::io::substrait::ParameterizedType_NullableInteger* release_range_end_exclusive(); + ::io::substrait::ParameterizedType_NullableInteger* mutable_range_end_exclusive(); + void set_allocated_range_end_exclusive(::io::substrait::ParameterizedType_NullableInteger* range_end_exclusive); + private: + const ::io::substrait::ParameterizedType_NullableInteger& _internal_range_end_exclusive() const; + ::io::substrait::ParameterizedType_NullableInteger* _internal_mutable_range_end_exclusive(); + public: + void unsafe_arena_set_allocated_range_end_exclusive( + ::io::substrait::ParameterizedType_NullableInteger* range_end_exclusive); + ::io::substrait::ParameterizedType_NullableInteger* unsafe_arena_release_range_end_exclusive(); + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.IntegerParameter) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::io::substrait::ParameterizedType_NullableInteger* range_start_inclusive_; + ::io::substrait::ParameterizedType_NullableInteger* range_end_exclusive_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_NullableInteger PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.NullableInteger) */ { + public: + inline ParameterizedType_NullableInteger() : ParameterizedType_NullableInteger(nullptr) {} + ~ParameterizedType_NullableInteger() override; + explicit constexpr ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_NullableInteger(const ParameterizedType_NullableInteger& from); + ParameterizedType_NullableInteger(ParameterizedType_NullableInteger&& from) noexcept + : ParameterizedType_NullableInteger() { + *this = ::std::move(from); + } + + inline ParameterizedType_NullableInteger& operator=(const ParameterizedType_NullableInteger& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_NullableInteger& operator=(ParameterizedType_NullableInteger&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_NullableInteger& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_NullableInteger* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_NullableInteger_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(ParameterizedType_NullableInteger& a, ParameterizedType_NullableInteger& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_NullableInteger* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_NullableInteger* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_NullableInteger* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_NullableInteger* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_NullableInteger& from); + void MergeFrom(const ParameterizedType_NullableInteger& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_NullableInteger* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.NullableInteger"; + } + protected: + explicit ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kValueFieldNumber = 1, + }; + // int64 value = 1; + void clear_value(); + ::PROTOBUF_NAMESPACE_ID::int64 value() const; + void set_value(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_value() const; + void _internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.NullableInteger) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::int64 value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedFixedChar) */ { + public: + inline ParameterizedType_ParameterizedFixedChar() : ParameterizedType_ParameterizedFixedChar(nullptr) {} + ~ParameterizedType_ParameterizedFixedChar() override; + explicit constexpr ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_ParameterizedFixedChar(const ParameterizedType_ParameterizedFixedChar& from); + ParameterizedType_ParameterizedFixedChar(ParameterizedType_ParameterizedFixedChar&& from) noexcept + : ParameterizedType_ParameterizedFixedChar() { + *this = ::std::move(from); + } + + inline ParameterizedType_ParameterizedFixedChar& operator=(const ParameterizedType_ParameterizedFixedChar& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_ParameterizedFixedChar& operator=(ParameterizedType_ParameterizedFixedChar&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_ParameterizedFixedChar& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_ParameterizedFixedChar* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_ParameterizedFixedChar_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(ParameterizedType_ParameterizedFixedChar& a, ParameterizedType_ParameterizedFixedChar& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_ParameterizedFixedChar* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_ParameterizedFixedChar* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_ParameterizedFixedChar* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_ParameterizedFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_ParameterizedFixedChar& from); + void MergeFrom(const ParameterizedType_ParameterizedFixedChar& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_ParameterizedFixedChar* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.ParameterizedFixedChar"; + } + protected: + explicit ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLengthFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.ParameterizedType.IntegerOption length = 1; + bool has_length() const; + private: + bool _internal_has_length() const; + public: + void clear_length(); + const ::io::substrait::ParameterizedType_IntegerOption& length() const; + ::io::substrait::ParameterizedType_IntegerOption* release_length(); + ::io::substrait::ParameterizedType_IntegerOption* mutable_length(); + void set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length); + private: + const ::io::substrait::ParameterizedType_IntegerOption& _internal_length() const; + ::io::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); + public: + void unsafe_arena_set_allocated_length( + ::io::substrait::ParameterizedType_IntegerOption* length); + ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedFixedChar) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ParameterizedType_IntegerOption* length_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedVarChar) */ { + public: + inline ParameterizedType_ParameterizedVarChar() : ParameterizedType_ParameterizedVarChar(nullptr) {} + ~ParameterizedType_ParameterizedVarChar() override; + explicit constexpr ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_ParameterizedVarChar(const ParameterizedType_ParameterizedVarChar& from); + ParameterizedType_ParameterizedVarChar(ParameterizedType_ParameterizedVarChar&& from) noexcept + : ParameterizedType_ParameterizedVarChar() { + *this = ::std::move(from); + } + + inline ParameterizedType_ParameterizedVarChar& operator=(const ParameterizedType_ParameterizedVarChar& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_ParameterizedVarChar& operator=(ParameterizedType_ParameterizedVarChar&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_ParameterizedVarChar& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_ParameterizedVarChar* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_ParameterizedVarChar_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(ParameterizedType_ParameterizedVarChar& a, ParameterizedType_ParameterizedVarChar& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_ParameterizedVarChar* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_ParameterizedVarChar* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_ParameterizedVarChar* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_ParameterizedVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_ParameterizedVarChar& from); + void MergeFrom(const ParameterizedType_ParameterizedVarChar& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_ParameterizedVarChar* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.ParameterizedVarChar"; + } + protected: + explicit ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLengthFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.ParameterizedType.IntegerOption length = 1; + bool has_length() const; + private: + bool _internal_has_length() const; + public: + void clear_length(); + const ::io::substrait::ParameterizedType_IntegerOption& length() const; + ::io::substrait::ParameterizedType_IntegerOption* release_length(); + ::io::substrait::ParameterizedType_IntegerOption* mutable_length(); + void set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length); + private: + const ::io::substrait::ParameterizedType_IntegerOption& _internal_length() const; + ::io::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); + public: + void unsafe_arena_set_allocated_length( + ::io::substrait::ParameterizedType_IntegerOption* length); + ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedVarChar) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ParameterizedType_IntegerOption* length_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedFixedBinary) */ { + public: + inline ParameterizedType_ParameterizedFixedBinary() : ParameterizedType_ParameterizedFixedBinary(nullptr) {} + ~ParameterizedType_ParameterizedFixedBinary() override; + explicit constexpr ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_ParameterizedFixedBinary(const ParameterizedType_ParameterizedFixedBinary& from); + ParameterizedType_ParameterizedFixedBinary(ParameterizedType_ParameterizedFixedBinary&& from) noexcept + : ParameterizedType_ParameterizedFixedBinary() { + *this = ::std::move(from); + } + + inline ParameterizedType_ParameterizedFixedBinary& operator=(const ParameterizedType_ParameterizedFixedBinary& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_ParameterizedFixedBinary& operator=(ParameterizedType_ParameterizedFixedBinary&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_ParameterizedFixedBinary& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_ParameterizedFixedBinary* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_ParameterizedFixedBinary_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(ParameterizedType_ParameterizedFixedBinary& a, ParameterizedType_ParameterizedFixedBinary& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_ParameterizedFixedBinary* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_ParameterizedFixedBinary* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_ParameterizedFixedBinary* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_ParameterizedFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_ParameterizedFixedBinary& from); + void MergeFrom(const ParameterizedType_ParameterizedFixedBinary& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_ParameterizedFixedBinary* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.ParameterizedFixedBinary"; + } + protected: + explicit ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLengthFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.ParameterizedType.IntegerOption length = 1; + bool has_length() const; + private: + bool _internal_has_length() const; + public: + void clear_length(); + const ::io::substrait::ParameterizedType_IntegerOption& length() const; + ::io::substrait::ParameterizedType_IntegerOption* release_length(); + ::io::substrait::ParameterizedType_IntegerOption* mutable_length(); + void set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length); + private: + const ::io::substrait::ParameterizedType_IntegerOption& _internal_length() const; + ::io::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); + public: + void unsafe_arena_set_allocated_length( + ::io::substrait::ParameterizedType_IntegerOption* length); + ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedFixedBinary) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ParameterizedType_IntegerOption* length_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedDecimal) */ { + public: + inline ParameterizedType_ParameterizedDecimal() : ParameterizedType_ParameterizedDecimal(nullptr) {} + ~ParameterizedType_ParameterizedDecimal() override; + explicit constexpr ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_ParameterizedDecimal(const ParameterizedType_ParameterizedDecimal& from); + ParameterizedType_ParameterizedDecimal(ParameterizedType_ParameterizedDecimal&& from) noexcept + : ParameterizedType_ParameterizedDecimal() { + *this = ::std::move(from); + } + + inline ParameterizedType_ParameterizedDecimal& operator=(const ParameterizedType_ParameterizedDecimal& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_ParameterizedDecimal& operator=(ParameterizedType_ParameterizedDecimal&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_ParameterizedDecimal& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_ParameterizedDecimal* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_ParameterizedDecimal_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(ParameterizedType_ParameterizedDecimal& a, ParameterizedType_ParameterizedDecimal& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_ParameterizedDecimal* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_ParameterizedDecimal* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_ParameterizedDecimal* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_ParameterizedDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_ParameterizedDecimal& from); + void MergeFrom(const ParameterizedType_ParameterizedDecimal& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_ParameterizedDecimal* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.ParameterizedDecimal"; + } + protected: + explicit ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kScaleFieldNumber = 1, + kPrecisionFieldNumber = 2, + kVariationFieldNumber = 3, + kNullabilityFieldNumber = 4, + }; + // .io.substrait.ParameterizedType.IntegerOption scale = 1; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + const ::io::substrait::ParameterizedType_IntegerOption& scale() const; + ::io::substrait::ParameterizedType_IntegerOption* release_scale(); + ::io::substrait::ParameterizedType_IntegerOption* mutable_scale(); + void set_allocated_scale(::io::substrait::ParameterizedType_IntegerOption* scale); + private: + const ::io::substrait::ParameterizedType_IntegerOption& _internal_scale() const; + ::io::substrait::ParameterizedType_IntegerOption* _internal_mutable_scale(); + public: + void unsafe_arena_set_allocated_scale( + ::io::substrait::ParameterizedType_IntegerOption* scale); + ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_scale(); + + // .io.substrait.ParameterizedType.IntegerOption precision = 2; + bool has_precision() const; + private: + bool _internal_has_precision() const; + public: + void clear_precision(); + const ::io::substrait::ParameterizedType_IntegerOption& precision() const; + ::io::substrait::ParameterizedType_IntegerOption* release_precision(); + ::io::substrait::ParameterizedType_IntegerOption* mutable_precision(); + void set_allocated_precision(::io::substrait::ParameterizedType_IntegerOption* precision); + private: + const ::io::substrait::ParameterizedType_IntegerOption& _internal_precision() const; + ::io::substrait::ParameterizedType_IntegerOption* _internal_mutable_precision(); + public: + void unsafe_arena_set_allocated_precision( + ::io::substrait::ParameterizedType_IntegerOption* precision); + ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_precision(); + + // .io.substrait.Type.Variation variation = 3; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 4; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedDecimal) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ParameterizedType_IntegerOption* scale_; + ::io::substrait::ParameterizedType_IntegerOption* precision_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedStruct) */ { + public: + inline ParameterizedType_ParameterizedStruct() : ParameterizedType_ParameterizedStruct(nullptr) {} + ~ParameterizedType_ParameterizedStruct() override; + explicit constexpr ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_ParameterizedStruct(const ParameterizedType_ParameterizedStruct& from); + ParameterizedType_ParameterizedStruct(ParameterizedType_ParameterizedStruct&& from) noexcept + : ParameterizedType_ParameterizedStruct() { + *this = ::std::move(from); + } + + inline ParameterizedType_ParameterizedStruct& operator=(const ParameterizedType_ParameterizedStruct& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_ParameterizedStruct& operator=(ParameterizedType_ParameterizedStruct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_ParameterizedStruct& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_ParameterizedStruct* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_ParameterizedStruct_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(ParameterizedType_ParameterizedStruct& a, ParameterizedType_ParameterizedStruct& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_ParameterizedStruct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_ParameterizedStruct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_ParameterizedStruct* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_ParameterizedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_ParameterizedStruct& from); + void MergeFrom(const ParameterizedType_ParameterizedStruct& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_ParameterizedStruct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.ParameterizedStruct"; + } + protected: + explicit ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTypesFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // repeated .io.substrait.ParameterizedType types = 1; + int types_size() const; + private: + int _internal_types_size() const; + public: + void clear_types(); + ::io::substrait::ParameterizedType* mutable_types(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >* + mutable_types(); + private: + const ::io::substrait::ParameterizedType& _internal_types(int index) const; + ::io::substrait::ParameterizedType* _internal_add_types(); + public: + const ::io::substrait::ParameterizedType& types(int index) const; + ::io::substrait::ParameterizedType* add_types(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >& + types() const; + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedStruct) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType > types_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedNamedStruct) */ { + public: + inline ParameterizedType_ParameterizedNamedStruct() : ParameterizedType_ParameterizedNamedStruct(nullptr) {} + ~ParameterizedType_ParameterizedNamedStruct() override; + explicit constexpr ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_ParameterizedNamedStruct(const ParameterizedType_ParameterizedNamedStruct& from); + ParameterizedType_ParameterizedNamedStruct(ParameterizedType_ParameterizedNamedStruct&& from) noexcept + : ParameterizedType_ParameterizedNamedStruct() { + *this = ::std::move(from); + } + + inline ParameterizedType_ParameterizedNamedStruct& operator=(const ParameterizedType_ParameterizedNamedStruct& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_ParameterizedNamedStruct& operator=(ParameterizedType_ParameterizedNamedStruct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_ParameterizedNamedStruct& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_ParameterizedNamedStruct* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_ParameterizedNamedStruct_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(ParameterizedType_ParameterizedNamedStruct& a, ParameterizedType_ParameterizedNamedStruct& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_ParameterizedNamedStruct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_ParameterizedNamedStruct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_ParameterizedNamedStruct* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_ParameterizedNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_ParameterizedNamedStruct& from); + void MergeFrom(const ParameterizedType_ParameterizedNamedStruct& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_ParameterizedNamedStruct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.ParameterizedNamedStruct"; + } + protected: + explicit ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNamesFieldNumber = 1, + kStructFieldNumber = 2, + }; + // repeated string names = 1; + int names_size() const; + private: + int _internal_names_size() const; + public: + void clear_names(); + const std::string& names(int index) const; + std::string* mutable_names(int index); + void set_names(int index, const std::string& value); + void set_names(int index, std::string&& value); + void set_names(int index, const char* value); + void set_names(int index, const char* value, size_t size); + std::string* add_names(); + void add_names(const std::string& value); + void add_names(std::string&& value); + void add_names(const char* value); + void add_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); + private: + const std::string& _internal_names(int index) const; + std::string* _internal_add_names(); + public: + + // .io.substrait.ParameterizedType.ParameterizedStruct struct = 2; + bool has_struct_() const; + private: + bool _internal_has_struct_() const; + public: + void clear_struct_(); + const ::io::substrait::ParameterizedType_ParameterizedStruct& struct_() const; + ::io::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); + ::io::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_(); + void set_allocated_struct_(::io::substrait::ParameterizedType_ParameterizedStruct* struct_); + private: + const ::io::substrait::ParameterizedType_ParameterizedStruct& _internal_struct_() const; + ::io::substrait::ParameterizedType_ParameterizedStruct* _internal_mutable_struct_(); + public: + void unsafe_arena_set_allocated_struct_( + ::io::substrait::ParameterizedType_ParameterizedStruct* struct_); + ::io::substrait::ParameterizedType_ParameterizedStruct* unsafe_arena_release_struct_(); + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedNamedStruct) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; + ::io::substrait::ParameterizedType_ParameterizedStruct* struct__; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_ParameterizedList PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedList) */ { + public: + inline ParameterizedType_ParameterizedList() : ParameterizedType_ParameterizedList(nullptr) {} + ~ParameterizedType_ParameterizedList() override; + explicit constexpr ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_ParameterizedList(const ParameterizedType_ParameterizedList& from); + ParameterizedType_ParameterizedList(ParameterizedType_ParameterizedList&& from) noexcept + : ParameterizedType_ParameterizedList() { + *this = ::std::move(from); + } + + inline ParameterizedType_ParameterizedList& operator=(const ParameterizedType_ParameterizedList& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_ParameterizedList& operator=(ParameterizedType_ParameterizedList&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_ParameterizedList& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_ParameterizedList* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_ParameterizedList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(ParameterizedType_ParameterizedList& a, ParameterizedType_ParameterizedList& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_ParameterizedList* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_ParameterizedList* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_ParameterizedList* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_ParameterizedList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_ParameterizedList& from); + void MergeFrom(const ParameterizedType_ParameterizedList& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_ParameterizedList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.ParameterizedList"; + } + protected: + explicit ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTypeFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.ParameterizedType type = 1; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + const ::io::substrait::ParameterizedType& type() const; + ::io::substrait::ParameterizedType* release_type(); + ::io::substrait::ParameterizedType* mutable_type(); + void set_allocated_type(::io::substrait::ParameterizedType* type); + private: + const ::io::substrait::ParameterizedType& _internal_type() const; + ::io::substrait::ParameterizedType* _internal_mutable_type(); + public: + void unsafe_arena_set_allocated_type( + ::io::substrait::ParameterizedType* type); + ::io::substrait::ParameterizedType* unsafe_arena_release_type(); + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedList) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ParameterizedType* type_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedMap) */ { + public: + inline ParameterizedType_ParameterizedMap() : ParameterizedType_ParameterizedMap(nullptr) {} + ~ParameterizedType_ParameterizedMap() override; + explicit constexpr ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_ParameterizedMap(const ParameterizedType_ParameterizedMap& from); + ParameterizedType_ParameterizedMap(ParameterizedType_ParameterizedMap&& from) noexcept + : ParameterizedType_ParameterizedMap() { + *this = ::std::move(from); + } + + inline ParameterizedType_ParameterizedMap& operator=(const ParameterizedType_ParameterizedMap& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_ParameterizedMap& operator=(ParameterizedType_ParameterizedMap&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_ParameterizedMap& default_instance() { + return *internal_default_instance(); + } + static inline const ParameterizedType_ParameterizedMap* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_ParameterizedMap_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(ParameterizedType_ParameterizedMap& a, ParameterizedType_ParameterizedMap& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_ParameterizedMap* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_ParameterizedMap* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_ParameterizedMap* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_ParameterizedMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_ParameterizedMap& from); + void MergeFrom(const ParameterizedType_ParameterizedMap& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_ParameterizedMap* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.ParameterizedMap"; + } + protected: + explicit ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + kVariationFieldNumber = 3, + kNullabilityFieldNumber = 4, + }; + // .io.substrait.ParameterizedType key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::io::substrait::ParameterizedType& key() const; + ::io::substrait::ParameterizedType* release_key(); + ::io::substrait::ParameterizedType* mutable_key(); + void set_allocated_key(::io::substrait::ParameterizedType* key); + private: + const ::io::substrait::ParameterizedType& _internal_key() const; + ::io::substrait::ParameterizedType* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::io::substrait::ParameterizedType* key); + ::io::substrait::ParameterizedType* unsafe_arena_release_key(); + + // .io.substrait.ParameterizedType value = 2; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + const ::io::substrait::ParameterizedType& value() const; + ::io::substrait::ParameterizedType* release_value(); + ::io::substrait::ParameterizedType* mutable_value(); + void set_allocated_value(::io::substrait::ParameterizedType* value); + private: + const ::io::substrait::ParameterizedType& _internal_value() const; + ::io::substrait::ParameterizedType* _internal_mutable_value(); + public: + void unsafe_arena_set_allocated_value( + ::io::substrait::ParameterizedType* value); + ::io::substrait::ParameterizedType* unsafe_arena_release_value(); + + // .io.substrait.Type.Variation variation = 3; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 4; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedMap) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ParameterizedType* key_; + ::io::substrait::ParameterizedType* value_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType_IntegerOption PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.IntegerOption) */ { + public: + inline ParameterizedType_IntegerOption() : ParameterizedType_IntegerOption(nullptr) {} + ~ParameterizedType_IntegerOption() override; + explicit constexpr ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType_IntegerOption(const ParameterizedType_IntegerOption& from); + ParameterizedType_IntegerOption(ParameterizedType_IntegerOption&& from) noexcept + : ParameterizedType_IntegerOption() { + *this = ::std::move(from); + } + + inline ParameterizedType_IntegerOption& operator=(const ParameterizedType_IntegerOption& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType_IntegerOption& operator=(ParameterizedType_IntegerOption&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType_IntegerOption& default_instance() { + return *internal_default_instance(); + } + enum IntegerTypeCase { + kLiteral = 1, + kParameter = 2, + INTEGER_TYPE_NOT_SET = 0, + }; + + static inline const ParameterizedType_IntegerOption* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_IntegerOption_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(ParameterizedType_IntegerOption& a, ParameterizedType_IntegerOption& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType_IntegerOption* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType_IntegerOption* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType_IntegerOption* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType_IntegerOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType_IntegerOption& from); + void MergeFrom(const ParameterizedType_IntegerOption& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType_IntegerOption* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType.IntegerOption"; + } + protected: + explicit ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLiteralFieldNumber = 1, + kParameterFieldNumber = 2, + }; + // int32 literal = 1; + bool has_literal() const; + private: + bool _internal_has_literal() const; + public: + void clear_literal(); + ::PROTOBUF_NAMESPACE_ID::int32 literal() const; + void set_literal(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_literal() const; + void _internal_set_literal(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // .io.substrait.ParameterizedType.IntegerParameter parameter = 2; + bool has_parameter() const; + private: + bool _internal_has_parameter() const; + public: + void clear_parameter(); + const ::io::substrait::ParameterizedType_IntegerParameter& parameter() const; + ::io::substrait::ParameterizedType_IntegerParameter* release_parameter(); + ::io::substrait::ParameterizedType_IntegerParameter* mutable_parameter(); + void set_allocated_parameter(::io::substrait::ParameterizedType_IntegerParameter* parameter); + private: + const ::io::substrait::ParameterizedType_IntegerParameter& _internal_parameter() const; + ::io::substrait::ParameterizedType_IntegerParameter* _internal_mutable_parameter(); + public: + void unsafe_arena_set_allocated_parameter( + ::io::substrait::ParameterizedType_IntegerParameter* parameter); + ::io::substrait::ParameterizedType_IntegerParameter* unsafe_arena_release_parameter(); + + void clear_integer_type(); + IntegerTypeCase integer_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.IntegerOption) + private: + class _Internal; + void set_has_literal(); + void set_has_parameter(); + + inline bool has_integer_type() const; + inline void clear_has_integer_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union IntegerTypeUnion { + constexpr IntegerTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::int32 literal_; + ::io::substrait::ParameterizedType_IntegerParameter* parameter_; + } integer_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// ------------------------------------------------------------------- + +class ParameterizedType PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType) */ { + public: + inline ParameterizedType() : ParameterizedType(nullptr) {} + ~ParameterizedType() override; + explicit constexpr ParameterizedType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ParameterizedType(const ParameterizedType& from); + ParameterizedType(ParameterizedType&& from) noexcept + : ParameterizedType() { + *this = ::std::move(from); + } + + inline ParameterizedType& operator=(const ParameterizedType& from) { + CopyFrom(from); + return *this; + } + inline ParameterizedType& operator=(ParameterizedType&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ParameterizedType& default_instance() { + return *internal_default_instance(); + } + enum KindCase { + kBool = 1, + kI8 = 2, + kI16 = 3, + kI32 = 5, + kI64 = 7, + kFp32 = 10, + kFp64 = 11, + kString = 12, + kBinary = 13, + kTimestamp = 14, + kDate = 16, + kTime = 17, + kIntervalYear = 19, + kIntervalDay = 20, + kTimestampTz = 29, + kUuid = 32, + kFixedChar = 21, + kVarchar = 22, + kFixedBinary = 23, + kDecimal = 24, + kStruct = 25, + kList = 27, + kMap = 28, + kUserDefined = 31, + kTypeParameter = 33, + KIND_NOT_SET = 0, + }; + + static inline const ParameterizedType* internal_default_instance() { + return reinterpret_cast( + &_ParameterizedType_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(ParameterizedType& a, ParameterizedType& b) { + a.Swap(&b); + } + inline void Swap(ParameterizedType* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ParameterizedType* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ParameterizedType* New() const final { + return CreateMaybeMessage(nullptr); + } + + ParameterizedType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ParameterizedType& from); + void MergeFrom(const ParameterizedType& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ParameterizedType* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ParameterizedType"; + } + protected: + explicit ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ParameterizedType_TypeParameter TypeParameter; + typedef ParameterizedType_IntegerParameter IntegerParameter; + typedef ParameterizedType_NullableInteger NullableInteger; + typedef ParameterizedType_ParameterizedFixedChar ParameterizedFixedChar; + typedef ParameterizedType_ParameterizedVarChar ParameterizedVarChar; + typedef ParameterizedType_ParameterizedFixedBinary ParameterizedFixedBinary; + typedef ParameterizedType_ParameterizedDecimal ParameterizedDecimal; + typedef ParameterizedType_ParameterizedStruct ParameterizedStruct; + typedef ParameterizedType_ParameterizedNamedStruct ParameterizedNamedStruct; + typedef ParameterizedType_ParameterizedList ParameterizedList; + typedef ParameterizedType_ParameterizedMap ParameterizedMap; + typedef ParameterizedType_IntegerOption IntegerOption; + + // accessors ------------------------------------------------------- + + enum : int { + kBoolFieldNumber = 1, + kI8FieldNumber = 2, + kI16FieldNumber = 3, + kI32FieldNumber = 5, + kI64FieldNumber = 7, + kFp32FieldNumber = 10, + kFp64FieldNumber = 11, + kStringFieldNumber = 12, + kBinaryFieldNumber = 13, + kTimestampFieldNumber = 14, + kDateFieldNumber = 16, + kTimeFieldNumber = 17, + kIntervalYearFieldNumber = 19, + kIntervalDayFieldNumber = 20, + kTimestampTzFieldNumber = 29, + kUuidFieldNumber = 32, + kFixedCharFieldNumber = 21, + kVarcharFieldNumber = 22, + kFixedBinaryFieldNumber = 23, + kDecimalFieldNumber = 24, + kStructFieldNumber = 25, + kListFieldNumber = 27, + kMapFieldNumber = 28, + kUserDefinedFieldNumber = 31, + kTypeParameterFieldNumber = 33, + }; + // .io.substrait.Type.Boolean bool = 1; + bool has_bool_() const; + private: + bool _internal_has_bool_() const; + public: + void clear_bool_(); + const ::io::substrait::Type_Boolean& bool_() const; + ::io::substrait::Type_Boolean* release_bool_(); + ::io::substrait::Type_Boolean* mutable_bool_(); + void set_allocated_bool_(::io::substrait::Type_Boolean* bool_); + private: + const ::io::substrait::Type_Boolean& _internal_bool_() const; + ::io::substrait::Type_Boolean* _internal_mutable_bool_(); + public: + void unsafe_arena_set_allocated_bool_( + ::io::substrait::Type_Boolean* bool_); + ::io::substrait::Type_Boolean* unsafe_arena_release_bool_(); + + // .io.substrait.Type.I8 i8 = 2; + bool has_i8() const; + private: + bool _internal_has_i8() const; + public: + void clear_i8(); + const ::io::substrait::Type_I8& i8() const; + ::io::substrait::Type_I8* release_i8(); + ::io::substrait::Type_I8* mutable_i8(); + void set_allocated_i8(::io::substrait::Type_I8* i8); + private: + const ::io::substrait::Type_I8& _internal_i8() const; + ::io::substrait::Type_I8* _internal_mutable_i8(); + public: + void unsafe_arena_set_allocated_i8( + ::io::substrait::Type_I8* i8); + ::io::substrait::Type_I8* unsafe_arena_release_i8(); + + // .io.substrait.Type.I16 i16 = 3; + bool has_i16() const; + private: + bool _internal_has_i16() const; + public: + void clear_i16(); + const ::io::substrait::Type_I16& i16() const; + ::io::substrait::Type_I16* release_i16(); + ::io::substrait::Type_I16* mutable_i16(); + void set_allocated_i16(::io::substrait::Type_I16* i16); + private: + const ::io::substrait::Type_I16& _internal_i16() const; + ::io::substrait::Type_I16* _internal_mutable_i16(); + public: + void unsafe_arena_set_allocated_i16( + ::io::substrait::Type_I16* i16); + ::io::substrait::Type_I16* unsafe_arena_release_i16(); + + // .io.substrait.Type.I32 i32 = 5; + bool has_i32() const; + private: + bool _internal_has_i32() const; + public: + void clear_i32(); + const ::io::substrait::Type_I32& i32() const; + ::io::substrait::Type_I32* release_i32(); + ::io::substrait::Type_I32* mutable_i32(); + void set_allocated_i32(::io::substrait::Type_I32* i32); + private: + const ::io::substrait::Type_I32& _internal_i32() const; + ::io::substrait::Type_I32* _internal_mutable_i32(); + public: + void unsafe_arena_set_allocated_i32( + ::io::substrait::Type_I32* i32); + ::io::substrait::Type_I32* unsafe_arena_release_i32(); + + // .io.substrait.Type.I64 i64 = 7; + bool has_i64() const; + private: + bool _internal_has_i64() const; + public: + void clear_i64(); + const ::io::substrait::Type_I64& i64() const; + ::io::substrait::Type_I64* release_i64(); + ::io::substrait::Type_I64* mutable_i64(); + void set_allocated_i64(::io::substrait::Type_I64* i64); + private: + const ::io::substrait::Type_I64& _internal_i64() const; + ::io::substrait::Type_I64* _internal_mutable_i64(); + public: + void unsafe_arena_set_allocated_i64( + ::io::substrait::Type_I64* i64); + ::io::substrait::Type_I64* unsafe_arena_release_i64(); + + // .io.substrait.Type.FP32 fp32 = 10; + bool has_fp32() const; + private: + bool _internal_has_fp32() const; + public: + void clear_fp32(); + const ::io::substrait::Type_FP32& fp32() const; + ::io::substrait::Type_FP32* release_fp32(); + ::io::substrait::Type_FP32* mutable_fp32(); + void set_allocated_fp32(::io::substrait::Type_FP32* fp32); + private: + const ::io::substrait::Type_FP32& _internal_fp32() const; + ::io::substrait::Type_FP32* _internal_mutable_fp32(); + public: + void unsafe_arena_set_allocated_fp32( + ::io::substrait::Type_FP32* fp32); + ::io::substrait::Type_FP32* unsafe_arena_release_fp32(); + + // .io.substrait.Type.FP64 fp64 = 11; + bool has_fp64() const; + private: + bool _internal_has_fp64() const; + public: + void clear_fp64(); + const ::io::substrait::Type_FP64& fp64() const; + ::io::substrait::Type_FP64* release_fp64(); + ::io::substrait::Type_FP64* mutable_fp64(); + void set_allocated_fp64(::io::substrait::Type_FP64* fp64); + private: + const ::io::substrait::Type_FP64& _internal_fp64() const; + ::io::substrait::Type_FP64* _internal_mutable_fp64(); + public: + void unsafe_arena_set_allocated_fp64( + ::io::substrait::Type_FP64* fp64); + ::io::substrait::Type_FP64* unsafe_arena_release_fp64(); + + // .io.substrait.Type.String string = 12; + bool has_string() const; + private: + bool _internal_has_string() const; + public: + void clear_string(); + const ::io::substrait::Type_String& string() const; + ::io::substrait::Type_String* release_string(); + ::io::substrait::Type_String* mutable_string(); + void set_allocated_string(::io::substrait::Type_String* string); + private: + const ::io::substrait::Type_String& _internal_string() const; + ::io::substrait::Type_String* _internal_mutable_string(); + public: + void unsafe_arena_set_allocated_string( + ::io::substrait::Type_String* string); + ::io::substrait::Type_String* unsafe_arena_release_string(); + + // .io.substrait.Type.Binary binary = 13; + bool has_binary() const; + private: + bool _internal_has_binary() const; + public: + void clear_binary(); + const ::io::substrait::Type_Binary& binary() const; + ::io::substrait::Type_Binary* release_binary(); + ::io::substrait::Type_Binary* mutable_binary(); + void set_allocated_binary(::io::substrait::Type_Binary* binary); + private: + const ::io::substrait::Type_Binary& _internal_binary() const; + ::io::substrait::Type_Binary* _internal_mutable_binary(); + public: + void unsafe_arena_set_allocated_binary( + ::io::substrait::Type_Binary* binary); + ::io::substrait::Type_Binary* unsafe_arena_release_binary(); + + // .io.substrait.Type.Timestamp timestamp = 14; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + const ::io::substrait::Type_Timestamp& timestamp() const; + ::io::substrait::Type_Timestamp* release_timestamp(); + ::io::substrait::Type_Timestamp* mutable_timestamp(); + void set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp); + private: + const ::io::substrait::Type_Timestamp& _internal_timestamp() const; + ::io::substrait::Type_Timestamp* _internal_mutable_timestamp(); + public: + void unsafe_arena_set_allocated_timestamp( + ::io::substrait::Type_Timestamp* timestamp); + ::io::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); + + // .io.substrait.Type.Date date = 16; + bool has_date() const; + private: + bool _internal_has_date() const; + public: + void clear_date(); + const ::io::substrait::Type_Date& date() const; + ::io::substrait::Type_Date* release_date(); + ::io::substrait::Type_Date* mutable_date(); + void set_allocated_date(::io::substrait::Type_Date* date); + private: + const ::io::substrait::Type_Date& _internal_date() const; + ::io::substrait::Type_Date* _internal_mutable_date(); + public: + void unsafe_arena_set_allocated_date( + ::io::substrait::Type_Date* date); + ::io::substrait::Type_Date* unsafe_arena_release_date(); + + // .io.substrait.Type.Time time = 17; + bool has_time() const; + private: + bool _internal_has_time() const; + public: + void clear_time(); + const ::io::substrait::Type_Time& time() const; + ::io::substrait::Type_Time* release_time(); + ::io::substrait::Type_Time* mutable_time(); + void set_allocated_time(::io::substrait::Type_Time* time); + private: + const ::io::substrait::Type_Time& _internal_time() const; + ::io::substrait::Type_Time* _internal_mutable_time(); + public: + void unsafe_arena_set_allocated_time( + ::io::substrait::Type_Time* time); + ::io::substrait::Type_Time* unsafe_arena_release_time(); + + // .io.substrait.Type.IntervalYear interval_year = 19; + bool has_interval_year() const; + private: + bool _internal_has_interval_year() const; + public: + void clear_interval_year(); + const ::io::substrait::Type_IntervalYear& interval_year() const; + ::io::substrait::Type_IntervalYear* release_interval_year(); + ::io::substrait::Type_IntervalYear* mutable_interval_year(); + void set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year); + private: + const ::io::substrait::Type_IntervalYear& _internal_interval_year() const; + ::io::substrait::Type_IntervalYear* _internal_mutable_interval_year(); + public: + void unsafe_arena_set_allocated_interval_year( + ::io::substrait::Type_IntervalYear* interval_year); + ::io::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); + + // .io.substrait.Type.IntervalDay interval_day = 20; + bool has_interval_day() const; + private: + bool _internal_has_interval_day() const; + public: + void clear_interval_day(); + const ::io::substrait::Type_IntervalDay& interval_day() const; + ::io::substrait::Type_IntervalDay* release_interval_day(); + ::io::substrait::Type_IntervalDay* mutable_interval_day(); + void set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day); + private: + const ::io::substrait::Type_IntervalDay& _internal_interval_day() const; + ::io::substrait::Type_IntervalDay* _internal_mutable_interval_day(); + public: + void unsafe_arena_set_allocated_interval_day( + ::io::substrait::Type_IntervalDay* interval_day); + ::io::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); + + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + bool has_timestamp_tz() const; + private: + bool _internal_has_timestamp_tz() const; + public: + void clear_timestamp_tz(); + const ::io::substrait::Type_TimestampTZ& timestamp_tz() const; + ::io::substrait::Type_TimestampTZ* release_timestamp_tz(); + ::io::substrait::Type_TimestampTZ* mutable_timestamp_tz(); + void set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz); + private: + const ::io::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; + ::io::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); + public: + void unsafe_arena_set_allocated_timestamp_tz( + ::io::substrait::Type_TimestampTZ* timestamp_tz); + ::io::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); + + // .io.substrait.Type.UUID uuid = 32; + bool has_uuid() const; + private: + bool _internal_has_uuid() const; + public: + void clear_uuid(); + const ::io::substrait::Type_UUID& uuid() const; + ::io::substrait::Type_UUID* release_uuid(); + ::io::substrait::Type_UUID* mutable_uuid(); + void set_allocated_uuid(::io::substrait::Type_UUID* uuid); + private: + const ::io::substrait::Type_UUID& _internal_uuid() const; + ::io::substrait::Type_UUID* _internal_mutable_uuid(); + public: + void unsafe_arena_set_allocated_uuid( + ::io::substrait::Type_UUID* uuid); + ::io::substrait::Type_UUID* unsafe_arena_release_uuid(); + + // .io.substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; + bool has_fixed_char() const; + private: + bool _internal_has_fixed_char() const; + public: + void clear_fixed_char(); + const ::io::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char() const; + ::io::substrait::ParameterizedType_ParameterizedFixedChar* release_fixed_char(); + ::io::substrait::ParameterizedType_ParameterizedFixedChar* mutable_fixed_char(); + void set_allocated_fixed_char(::io::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char); + private: + const ::io::substrait::ParameterizedType_ParameterizedFixedChar& _internal_fixed_char() const; + ::io::substrait::ParameterizedType_ParameterizedFixedChar* _internal_mutable_fixed_char(); + public: + void unsafe_arena_set_allocated_fixed_char( + ::io::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char); + ::io::substrait::ParameterizedType_ParameterizedFixedChar* unsafe_arena_release_fixed_char(); + + // .io.substrait.ParameterizedType.ParameterizedVarChar varchar = 22; + bool has_varchar() const; + private: + bool _internal_has_varchar() const; + public: + void clear_varchar(); + const ::io::substrait::ParameterizedType_ParameterizedVarChar& varchar() const; + ::io::substrait::ParameterizedType_ParameterizedVarChar* release_varchar(); + ::io::substrait::ParameterizedType_ParameterizedVarChar* mutable_varchar(); + void set_allocated_varchar(::io::substrait::ParameterizedType_ParameterizedVarChar* varchar); + private: + const ::io::substrait::ParameterizedType_ParameterizedVarChar& _internal_varchar() const; + ::io::substrait::ParameterizedType_ParameterizedVarChar* _internal_mutable_varchar(); + public: + void unsafe_arena_set_allocated_varchar( + ::io::substrait::ParameterizedType_ParameterizedVarChar* varchar); + ::io::substrait::ParameterizedType_ParameterizedVarChar* unsafe_arena_release_varchar(); + + // .io.substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; + bool has_fixed_binary() const; + private: + bool _internal_has_fixed_binary() const; + public: + void clear_fixed_binary(); + const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary() const; + ::io::substrait::ParameterizedType_ParameterizedFixedBinary* release_fixed_binary(); + ::io::substrait::ParameterizedType_ParameterizedFixedBinary* mutable_fixed_binary(); + void set_allocated_fixed_binary(::io::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary); + private: + const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& _internal_fixed_binary() const; + ::io::substrait::ParameterizedType_ParameterizedFixedBinary* _internal_mutable_fixed_binary(); + public: + void unsafe_arena_set_allocated_fixed_binary( + ::io::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary); + ::io::substrait::ParameterizedType_ParameterizedFixedBinary* unsafe_arena_release_fixed_binary(); + + // .io.substrait.ParameterizedType.ParameterizedDecimal decimal = 24; + bool has_decimal() const; + private: + bool _internal_has_decimal() const; + public: + void clear_decimal(); + const ::io::substrait::ParameterizedType_ParameterizedDecimal& decimal() const; + ::io::substrait::ParameterizedType_ParameterizedDecimal* release_decimal(); + ::io::substrait::ParameterizedType_ParameterizedDecimal* mutable_decimal(); + void set_allocated_decimal(::io::substrait::ParameterizedType_ParameterizedDecimal* decimal); + private: + const ::io::substrait::ParameterizedType_ParameterizedDecimal& _internal_decimal() const; + ::io::substrait::ParameterizedType_ParameterizedDecimal* _internal_mutable_decimal(); + public: + void unsafe_arena_set_allocated_decimal( + ::io::substrait::ParameterizedType_ParameterizedDecimal* decimal); + ::io::substrait::ParameterizedType_ParameterizedDecimal* unsafe_arena_release_decimal(); + + // .io.substrait.ParameterizedType.ParameterizedStruct struct = 25; + bool has_struct_() const; + private: + bool _internal_has_struct_() const; + public: + void clear_struct_(); + const ::io::substrait::ParameterizedType_ParameterizedStruct& struct_() const; + ::io::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); + ::io::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_(); + void set_allocated_struct_(::io::substrait::ParameterizedType_ParameterizedStruct* struct_); + private: + const ::io::substrait::ParameterizedType_ParameterizedStruct& _internal_struct_() const; + ::io::substrait::ParameterizedType_ParameterizedStruct* _internal_mutable_struct_(); + public: + void unsafe_arena_set_allocated_struct_( + ::io::substrait::ParameterizedType_ParameterizedStruct* struct_); + ::io::substrait::ParameterizedType_ParameterizedStruct* unsafe_arena_release_struct_(); + + // .io.substrait.ParameterizedType.ParameterizedList list = 27; + bool has_list() const; + private: + bool _internal_has_list() const; + public: + void clear_list(); + const ::io::substrait::ParameterizedType_ParameterizedList& list() const; + ::io::substrait::ParameterizedType_ParameterizedList* release_list(); + ::io::substrait::ParameterizedType_ParameterizedList* mutable_list(); + void set_allocated_list(::io::substrait::ParameterizedType_ParameterizedList* list); + private: + const ::io::substrait::ParameterizedType_ParameterizedList& _internal_list() const; + ::io::substrait::ParameterizedType_ParameterizedList* _internal_mutable_list(); + public: + void unsafe_arena_set_allocated_list( + ::io::substrait::ParameterizedType_ParameterizedList* list); + ::io::substrait::ParameterizedType_ParameterizedList* unsafe_arena_release_list(); + + // .io.substrait.ParameterizedType.ParameterizedMap map = 28; + bool has_map() const; + private: + bool _internal_has_map() const; + public: + void clear_map(); + const ::io::substrait::ParameterizedType_ParameterizedMap& map() const; + ::io::substrait::ParameterizedType_ParameterizedMap* release_map(); + ::io::substrait::ParameterizedType_ParameterizedMap* mutable_map(); + void set_allocated_map(::io::substrait::ParameterizedType_ParameterizedMap* map); + private: + const ::io::substrait::ParameterizedType_ParameterizedMap& _internal_map() const; + ::io::substrait::ParameterizedType_ParameterizedMap* _internal_mutable_map(); + public: + void unsafe_arena_set_allocated_map( + ::io::substrait::ParameterizedType_ParameterizedMap* map); + ::io::substrait::ParameterizedType_ParameterizedMap* unsafe_arena_release_map(); + + // .io.substrait.Extensions.TypeId user_defined = 31; + bool has_user_defined() const; + private: + bool _internal_has_user_defined() const; + public: + void clear_user_defined(); + const ::io::substrait::Extensions_TypeId& user_defined() const; + ::io::substrait::Extensions_TypeId* release_user_defined(); + ::io::substrait::Extensions_TypeId* mutable_user_defined(); + void set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined); + private: + const ::io::substrait::Extensions_TypeId& _internal_user_defined() const; + ::io::substrait::Extensions_TypeId* _internal_mutable_user_defined(); + public: + void unsafe_arena_set_allocated_user_defined( + ::io::substrait::Extensions_TypeId* user_defined); + ::io::substrait::Extensions_TypeId* unsafe_arena_release_user_defined(); + + // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; + bool has_type_parameter() const; + private: + bool _internal_has_type_parameter() const; + public: + void clear_type_parameter(); + const ::io::substrait::ParameterizedType_TypeParameter& type_parameter() const; + ::io::substrait::ParameterizedType_TypeParameter* release_type_parameter(); + ::io::substrait::ParameterizedType_TypeParameter* mutable_type_parameter(); + void set_allocated_type_parameter(::io::substrait::ParameterizedType_TypeParameter* type_parameter); + private: + const ::io::substrait::ParameterizedType_TypeParameter& _internal_type_parameter() const; + ::io::substrait::ParameterizedType_TypeParameter* _internal_mutable_type_parameter(); + public: + void unsafe_arena_set_allocated_type_parameter( + ::io::substrait::ParameterizedType_TypeParameter* type_parameter); + ::io::substrait::ParameterizedType_TypeParameter* unsafe_arena_release_type_parameter(); + + void clear_kind(); + KindCase kind_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType) + private: + class _Internal; + void set_has_bool_(); + void set_has_i8(); + void set_has_i16(); + void set_has_i32(); + void set_has_i64(); + void set_has_fp32(); + void set_has_fp64(); + void set_has_string(); + void set_has_binary(); + void set_has_timestamp(); + void set_has_date(); + void set_has_time(); + void set_has_interval_year(); + void set_has_interval_day(); + void set_has_timestamp_tz(); + void set_has_uuid(); + void set_has_fixed_char(); + void set_has_varchar(); + void set_has_fixed_binary(); + void set_has_decimal(); + void set_has_struct_(); + void set_has_list(); + void set_has_map(); + void set_has_user_defined(); + void set_has_type_parameter(); + + inline bool has_kind() const; + inline void clear_has_kind(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union KindUnion { + constexpr KindUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Type_Boolean* bool__; + ::io::substrait::Type_I8* i8_; + ::io::substrait::Type_I16* i16_; + ::io::substrait::Type_I32* i32_; + ::io::substrait::Type_I64* i64_; + ::io::substrait::Type_FP32* fp32_; + ::io::substrait::Type_FP64* fp64_; + ::io::substrait::Type_String* string_; + ::io::substrait::Type_Binary* binary_; + ::io::substrait::Type_Timestamp* timestamp_; + ::io::substrait::Type_Date* date_; + ::io::substrait::Type_Time* time_; + ::io::substrait::Type_IntervalYear* interval_year_; + ::io::substrait::Type_IntervalDay* interval_day_; + ::io::substrait::Type_TimestampTZ* timestamp_tz_; + ::io::substrait::Type_UUID* uuid_; + ::io::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char_; + ::io::substrait::ParameterizedType_ParameterizedVarChar* varchar_; + ::io::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary_; + ::io::substrait::ParameterizedType_ParameterizedDecimal* decimal_; + ::io::substrait::ParameterizedType_ParameterizedStruct* struct__; + ::io::substrait::ParameterizedType_ParameterizedList* list_; + ::io::substrait::ParameterizedType_ParameterizedMap* map_; + ::io::substrait::Extensions_TypeId* user_defined_; + ::io::substrait::ParameterizedType_TypeParameter* type_parameter_; + } kind_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_parameterized_5ftypes_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ParameterizedType_TypeParameter + +// string name = 1; +inline void ParameterizedType_TypeParameter::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& ParameterizedType_TypeParameter::name() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.TypeParameter.name) + return _internal_name(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void ParameterizedType_TypeParameter::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.TypeParameter.name) +} +inline std::string* ParameterizedType_TypeParameter::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.TypeParameter.name) + return _internal_mutable_name(); +} +inline const std::string& ParameterizedType_TypeParameter::_internal_name() const { + return name_.Get(); +} +inline void ParameterizedType_TypeParameter::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* ParameterizedType_TypeParameter::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* ParameterizedType_TypeParameter::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.TypeParameter.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ParameterizedType_TypeParameter::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.TypeParameter.name) +} + +// repeated .io.substrait.ParameterizedType bounds = 2; +inline int ParameterizedType_TypeParameter::_internal_bounds_size() const { + return bounds_.size(); +} +inline int ParameterizedType_TypeParameter::bounds_size() const { + return _internal_bounds_size(); +} +inline void ParameterizedType_TypeParameter::clear_bounds() { + bounds_.Clear(); +} +inline ::io::substrait::ParameterizedType* ParameterizedType_TypeParameter::mutable_bounds(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.TypeParameter.bounds) + return bounds_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >* +ParameterizedType_TypeParameter::mutable_bounds() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ParameterizedType.TypeParameter.bounds) + return &bounds_; +} +inline const ::io::substrait::ParameterizedType& ParameterizedType_TypeParameter::_internal_bounds(int index) const { + return bounds_.Get(index); +} +inline const ::io::substrait::ParameterizedType& ParameterizedType_TypeParameter::bounds(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.TypeParameter.bounds) + return _internal_bounds(index); +} +inline ::io::substrait::ParameterizedType* ParameterizedType_TypeParameter::_internal_add_bounds() { + return bounds_.Add(); +} +inline ::io::substrait::ParameterizedType* ParameterizedType_TypeParameter::add_bounds() { + // @@protoc_insertion_point(field_add:io.substrait.ParameterizedType.TypeParameter.bounds) + return _internal_add_bounds(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >& +ParameterizedType_TypeParameter::bounds() const { + // @@protoc_insertion_point(field_list:io.substrait.ParameterizedType.TypeParameter.bounds) + return bounds_; +} + +// ------------------------------------------------------------------- + +// ParameterizedType_IntegerParameter + +// string name = 1; +inline void ParameterizedType_IntegerParameter::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& ParameterizedType_IntegerParameter::name() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.IntegerParameter.name) + return _internal_name(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void ParameterizedType_IntegerParameter::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.IntegerParameter.name) +} +inline std::string* ParameterizedType_IntegerParameter::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.IntegerParameter.name) + return _internal_mutable_name(); +} +inline const std::string& ParameterizedType_IntegerParameter::_internal_name() const { + return name_.Get(); +} +inline void ParameterizedType_IntegerParameter::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* ParameterizedType_IntegerParameter::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* ParameterizedType_IntegerParameter::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.IntegerParameter.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ParameterizedType_IntegerParameter::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.IntegerParameter.name) +} + +// .io.substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; +inline bool ParameterizedType_IntegerParameter::_internal_has_range_start_inclusive() const { + return this != internal_default_instance() && range_start_inclusive_ != nullptr; +} +inline bool ParameterizedType_IntegerParameter::has_range_start_inclusive() const { + return _internal_has_range_start_inclusive(); +} +inline void ParameterizedType_IntegerParameter::clear_range_start_inclusive() { + if (GetArena() == nullptr && range_start_inclusive_ != nullptr) { + delete range_start_inclusive_; + } + range_start_inclusive_ = nullptr; +} +inline const ::io::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_internal_range_start_inclusive() const { + const ::io::substrait::ParameterizedType_NullableInteger* p = range_start_inclusive_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_NullableInteger_default_instance_); +} +inline const ::io::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::range_start_inclusive() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.IntegerParameter.range_start_inclusive) + return _internal_range_start_inclusive(); +} +inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range_start_inclusive( + ::io::substrait::ParameterizedType_NullableInteger* range_start_inclusive) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(range_start_inclusive_); + } + range_start_inclusive_ = range_start_inclusive; + if (range_start_inclusive) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.IntegerParameter.range_start_inclusive) +} +inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::release_range_start_inclusive() { + + ::io::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_; + range_start_inclusive_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_start_inclusive() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.IntegerParameter.range_start_inclusive) + + ::io::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_; + range_start_inclusive_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_start_inclusive() { + + if (range_start_inclusive_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_NullableInteger>(GetArena()); + range_start_inclusive_ = p; + } + return range_start_inclusive_; +} +inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_start_inclusive() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.IntegerParameter.range_start_inclusive) + return _internal_mutable_range_start_inclusive(); +} +inline void ParameterizedType_IntegerParameter::set_allocated_range_start_inclusive(::io::substrait::ParameterizedType_NullableInteger* range_start_inclusive) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete range_start_inclusive_; + } + if (range_start_inclusive) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(range_start_inclusive); + if (message_arena != submessage_arena) { + range_start_inclusive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, range_start_inclusive, submessage_arena); + } + + } else { + + } + range_start_inclusive_ = range_start_inclusive; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.IntegerParameter.range_start_inclusive) +} + +// .io.substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; +inline bool ParameterizedType_IntegerParameter::_internal_has_range_end_exclusive() const { + return this != internal_default_instance() && range_end_exclusive_ != nullptr; +} +inline bool ParameterizedType_IntegerParameter::has_range_end_exclusive() const { + return _internal_has_range_end_exclusive(); +} +inline void ParameterizedType_IntegerParameter::clear_range_end_exclusive() { + if (GetArena() == nullptr && range_end_exclusive_ != nullptr) { + delete range_end_exclusive_; + } + range_end_exclusive_ = nullptr; +} +inline const ::io::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_internal_range_end_exclusive() const { + const ::io::substrait::ParameterizedType_NullableInteger* p = range_end_exclusive_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_NullableInteger_default_instance_); +} +inline const ::io::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::range_end_exclusive() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.IntegerParameter.range_end_exclusive) + return _internal_range_end_exclusive(); +} +inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range_end_exclusive( + ::io::substrait::ParameterizedType_NullableInteger* range_end_exclusive) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(range_end_exclusive_); + } + range_end_exclusive_ = range_end_exclusive; + if (range_end_exclusive) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.IntegerParameter.range_end_exclusive) +} +inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::release_range_end_exclusive() { + + ::io::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_; + range_end_exclusive_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_end_exclusive() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.IntegerParameter.range_end_exclusive) + + ::io::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_; + range_end_exclusive_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_end_exclusive() { + + if (range_end_exclusive_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_NullableInteger>(GetArena()); + range_end_exclusive_ = p; + } + return range_end_exclusive_; +} +inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_end_exclusive() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.IntegerParameter.range_end_exclusive) + return _internal_mutable_range_end_exclusive(); +} +inline void ParameterizedType_IntegerParameter::set_allocated_range_end_exclusive(::io::substrait::ParameterizedType_NullableInteger* range_end_exclusive) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete range_end_exclusive_; + } + if (range_end_exclusive) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(range_end_exclusive); + if (message_arena != submessage_arena) { + range_end_exclusive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, range_end_exclusive, submessage_arena); + } + + } else { + + } + range_end_exclusive_ = range_end_exclusive; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.IntegerParameter.range_end_exclusive) +} + +// ------------------------------------------------------------------- + +// ParameterizedType_NullableInteger + +// int64 value = 1; +inline void ParameterizedType_NullableInteger::clear_value() { + value_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ParameterizedType_NullableInteger::_internal_value() const { + return value_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 ParameterizedType_NullableInteger::value() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.NullableInteger.value) + return _internal_value(); +} +inline void ParameterizedType_NullableInteger::_internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + + value_ = value; +} +inline void ParameterizedType_NullableInteger::set_value(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_value(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.NullableInteger.value) +} + +// ------------------------------------------------------------------- + +// ParameterizedType_ParameterizedFixedChar + +// .io.substrait.ParameterizedType.IntegerOption length = 1; +inline bool ParameterizedType_ParameterizedFixedChar::_internal_has_length() const { + return this != internal_default_instance() && length_ != nullptr; +} +inline bool ParameterizedType_ParameterizedFixedChar::has_length() const { + return _internal_has_length(); +} +inline void ParameterizedType_ParameterizedFixedChar::clear_length() { + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; +} +inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::_internal_length() const { + const ::io::substrait::ParameterizedType_IntegerOption* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_IntegerOption_default_instance_); +} +inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::length() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedChar.length) + return _internal_length(); +} +inline void ParameterizedType_ParameterizedFixedChar::unsafe_arena_set_allocated_length( + ::io::substrait::ParameterizedType_IntegerOption* length) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); + } + length_ = length; + if (length) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedChar.length) +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::release_length() { + + ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + length_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedFixedChar.length) + + ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + length_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::_internal_mutable_length() { + + if (length_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(GetArena()); + length_ = p; + } + return length_; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::mutable_length() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedFixedChar.length) + return _internal_mutable_length(); +} +inline void ParameterizedType_ParameterizedFixedChar::set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete length_; + } + if (length) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + if (message_arena != submessage_arena) { + length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, length, submessage_arena); + } + + } else { + + } + length_ = length; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedChar.length) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool ParameterizedType_ParameterizedFixedChar::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool ParameterizedType_ParameterizedFixedChar::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedFixedChar::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedFixedChar::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedChar.variation) + return _internal_variation(); +} +inline void ParameterizedType_ParameterizedFixedChar::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedChar.variation) +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedChar::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedChar::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedFixedChar.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedChar::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedChar::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedFixedChar.variation) + return _internal_mutable_variation(); +} +inline void ParameterizedType_ParameterizedFixedChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedChar.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void ParameterizedType_ParameterizedFixedChar::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedFixedChar::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedFixedChar::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedChar.nullability) + return _internal_nullability(); +} +inline void ParameterizedType_ParameterizedFixedChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void ParameterizedType_ParameterizedFixedChar::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedFixedChar.nullability) +} + +// ------------------------------------------------------------------- + +// ParameterizedType_ParameterizedVarChar + +// .io.substrait.ParameterizedType.IntegerOption length = 1; +inline bool ParameterizedType_ParameterizedVarChar::_internal_has_length() const { + return this != internal_default_instance() && length_ != nullptr; +} +inline bool ParameterizedType_ParameterizedVarChar::has_length() const { + return _internal_has_length(); +} +inline void ParameterizedType_ParameterizedVarChar::clear_length() { + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; +} +inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::_internal_length() const { + const ::io::substrait::ParameterizedType_IntegerOption* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_IntegerOption_default_instance_); +} +inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::length() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedVarChar.length) + return _internal_length(); +} +inline void ParameterizedType_ParameterizedVarChar::unsafe_arena_set_allocated_length( + ::io::substrait::ParameterizedType_IntegerOption* length) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); + } + length_ = length; + if (length) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedVarChar.length) +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::release_length() { + + ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + length_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedVarChar.length) + + ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + length_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::_internal_mutable_length() { + + if (length_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(GetArena()); + length_ = p; + } + return length_; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::mutable_length() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedVarChar.length) + return _internal_mutable_length(); +} +inline void ParameterizedType_ParameterizedVarChar::set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete length_; + } + if (length) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + if (message_arena != submessage_arena) { + length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, length, submessage_arena); + } + + } else { + + } + length_ = length; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedVarChar.length) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool ParameterizedType_ParameterizedVarChar::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool ParameterizedType_ParameterizedVarChar::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedVarChar::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedVarChar::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedVarChar.variation) + return _internal_variation(); +} +inline void ParameterizedType_ParameterizedVarChar::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedVarChar.variation) +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedVarChar::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedVarChar::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedVarChar.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedVarChar::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedVarChar::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedVarChar.variation) + return _internal_mutable_variation(); +} +inline void ParameterizedType_ParameterizedVarChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedVarChar.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void ParameterizedType_ParameterizedVarChar::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedVarChar::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedVarChar::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedVarChar.nullability) + return _internal_nullability(); +} +inline void ParameterizedType_ParameterizedVarChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void ParameterizedType_ParameterizedVarChar::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedVarChar.nullability) +} + +// ------------------------------------------------------------------- + +// ParameterizedType_ParameterizedFixedBinary + +// .io.substrait.ParameterizedType.IntegerOption length = 1; +inline bool ParameterizedType_ParameterizedFixedBinary::_internal_has_length() const { + return this != internal_default_instance() && length_ != nullptr; +} +inline bool ParameterizedType_ParameterizedFixedBinary::has_length() const { + return _internal_has_length(); +} +inline void ParameterizedType_ParameterizedFixedBinary::clear_length() { + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; +} +inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::_internal_length() const { + const ::io::substrait::ParameterizedType_IntegerOption* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_IntegerOption_default_instance_); +} +inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::length() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) + return _internal_length(); +} +inline void ParameterizedType_ParameterizedFixedBinary::unsafe_arena_set_allocated_length( + ::io::substrait::ParameterizedType_IntegerOption* length) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); + } + length_ = length; + if (length) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::release_length() { + + ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + length_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) + + ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + length_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::_internal_mutable_length() { + + if (length_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(GetArena()); + length_ = p; + } + return length_; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::mutable_length() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) + return _internal_mutable_length(); +} +inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete length_; + } + if (length) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + if (message_arena != submessage_arena) { + length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, length, submessage_arena); + } + + } else { + + } + length_ = length; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool ParameterizedType_ParameterizedFixedBinary::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool ParameterizedType_ParameterizedFixedBinary::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedFixedBinary::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedFixedBinary::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation) + return _internal_variation(); +} +inline void ParameterizedType_ParameterizedFixedBinary::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation) +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedBinary::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedBinary::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedBinary::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedBinary::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation) + return _internal_mutable_variation(); +} +inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void ParameterizedType_ParameterizedFixedBinary::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedFixedBinary::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedFixedBinary::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedBinary.nullability) + return _internal_nullability(); +} +inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void ParameterizedType_ParameterizedFixedBinary::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedFixedBinary.nullability) +} + +// ------------------------------------------------------------------- + +// ParameterizedType_ParameterizedDecimal + +// .io.substrait.ParameterizedType.IntegerOption scale = 1; +inline bool ParameterizedType_ParameterizedDecimal::_internal_has_scale() const { + return this != internal_default_instance() && scale_ != nullptr; +} +inline bool ParameterizedType_ParameterizedDecimal::has_scale() const { + return _internal_has_scale(); +} +inline void ParameterizedType_ParameterizedDecimal::clear_scale() { + if (GetArena() == nullptr && scale_ != nullptr) { + delete scale_; + } + scale_ = nullptr; +} +inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_internal_scale() const { + const ::io::substrait::ParameterizedType_IntegerOption* p = scale_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_IntegerOption_default_instance_); +} +inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::scale() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedDecimal.scale) + return _internal_scale(); +} +inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_scale( + ::io::substrait::ParameterizedType_IntegerOption* scale) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_); + } + scale_ = scale; + if (scale) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.scale) +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::release_scale() { + + ::io::substrait::ParameterizedType_IntegerOption* temp = scale_; + scale_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_scale() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedDecimal.scale) + + ::io::substrait::ParameterizedType_IntegerOption* temp = scale_; + scale_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_scale() { + + if (scale_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(GetArena()); + scale_ = p; + } + return scale_; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_scale() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedDecimal.scale) + return _internal_mutable_scale(); +} +inline void ParameterizedType_ParameterizedDecimal::set_allocated_scale(::io::substrait::ParameterizedType_IntegerOption* scale) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete scale_; + } + if (scale) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(scale); + if (message_arena != submessage_arena) { + scale = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, scale, submessage_arena); + } + + } else { + + } + scale_ = scale; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.scale) +} + +// .io.substrait.ParameterizedType.IntegerOption precision = 2; +inline bool ParameterizedType_ParameterizedDecimal::_internal_has_precision() const { + return this != internal_default_instance() && precision_ != nullptr; +} +inline bool ParameterizedType_ParameterizedDecimal::has_precision() const { + return _internal_has_precision(); +} +inline void ParameterizedType_ParameterizedDecimal::clear_precision() { + if (GetArena() == nullptr && precision_ != nullptr) { + delete precision_; + } + precision_ = nullptr; +} +inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_internal_precision() const { + const ::io::substrait::ParameterizedType_IntegerOption* p = precision_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_IntegerOption_default_instance_); +} +inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::precision() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedDecimal.precision) + return _internal_precision(); +} +inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_precision( + ::io::substrait::ParameterizedType_IntegerOption* precision) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_); + } + precision_ = precision; + if (precision) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.precision) +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::release_precision() { + + ::io::substrait::ParameterizedType_IntegerOption* temp = precision_; + precision_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_precision() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedDecimal.precision) + + ::io::substrait::ParameterizedType_IntegerOption* temp = precision_; + precision_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_precision() { + + if (precision_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(GetArena()); + precision_ = p; + } + return precision_; +} +inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_precision() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedDecimal.precision) + return _internal_mutable_precision(); +} +inline void ParameterizedType_ParameterizedDecimal::set_allocated_precision(::io::substrait::ParameterizedType_IntegerOption* precision) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete precision_; + } + if (precision) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(precision); + if (message_arena != submessage_arena) { + precision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, precision, submessage_arena); + } + + } else { + + } + precision_ = precision; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.precision) +} + +// .io.substrait.Type.Variation variation = 3; +inline bool ParameterizedType_ParameterizedDecimal::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool ParameterizedType_ParameterizedDecimal::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedDecimal::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedDecimal::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedDecimal.variation) + return _internal_variation(); +} +inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.variation) +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedDecimal::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedDecimal.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedDecimal::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedDecimal::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedDecimal.variation) + return _internal_mutable_variation(); +} +inline void ParameterizedType_ParameterizedDecimal::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.variation) +} + +// .io.substrait.Type.Nullability nullability = 4; +inline void ParameterizedType_ParameterizedDecimal::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedDecimal::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedDecimal::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedDecimal.nullability) + return _internal_nullability(); +} +inline void ParameterizedType_ParameterizedDecimal::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void ParameterizedType_ParameterizedDecimal::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedDecimal.nullability) +} + +// ------------------------------------------------------------------- + +// ParameterizedType_ParameterizedStruct + +// repeated .io.substrait.ParameterizedType types = 1; +inline int ParameterizedType_ParameterizedStruct::_internal_types_size() const { + return types_.size(); +} +inline int ParameterizedType_ParameterizedStruct::types_size() const { + return _internal_types_size(); +} +inline void ParameterizedType_ParameterizedStruct::clear_types() { + types_.Clear(); +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::mutable_types(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedStruct.types) + return types_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >* +ParameterizedType_ParameterizedStruct::mutable_types() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ParameterizedType.ParameterizedStruct.types) + return &types_; +} +inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedStruct::_internal_types(int index) const { + return types_.Get(index); +} +inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedStruct::types(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedStruct.types) + return _internal_types(index); +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::_internal_add_types() { + return types_.Add(); +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::add_types() { + // @@protoc_insertion_point(field_add:io.substrait.ParameterizedType.ParameterizedStruct.types) + return _internal_add_types(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >& +ParameterizedType_ParameterizedStruct::types() const { + // @@protoc_insertion_point(field_list:io.substrait.ParameterizedType.ParameterizedStruct.types) + return types_; +} + +// .io.substrait.Type.Variation variation = 2; +inline bool ParameterizedType_ParameterizedStruct::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool ParameterizedType_ParameterizedStruct::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedStruct::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedStruct::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedStruct.variation) + return _internal_variation(); +} +inline void ParameterizedType_ParameterizedStruct::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedStruct.variation) +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedStruct::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedStruct::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedStruct.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedStruct::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedStruct::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedStruct.variation) + return _internal_mutable_variation(); +} +inline void ParameterizedType_ParameterizedStruct::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedStruct.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void ParameterizedType_ParameterizedStruct::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedStruct::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedStruct::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedStruct.nullability) + return _internal_nullability(); +} +inline void ParameterizedType_ParameterizedStruct::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void ParameterizedType_ParameterizedStruct::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedStruct.nullability) +} + +// ------------------------------------------------------------------- + +// ParameterizedType_ParameterizedNamedStruct + +// repeated string names = 1; +inline int ParameterizedType_ParameterizedNamedStruct::_internal_names_size() const { + return names_.size(); +} +inline int ParameterizedType_ParameterizedNamedStruct::names_size() const { + return _internal_names_size(); +} +inline void ParameterizedType_ParameterizedNamedStruct::clear_names() { + names_.Clear(); +} +inline std::string* ParameterizedType_ParameterizedNamedStruct::add_names() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + return _internal_add_names(); +} +inline const std::string& ParameterizedType_ParameterizedNamedStruct::_internal_names(int index) const { + return names_.Get(index); +} +inline const std::string& ParameterizedType_ParameterizedNamedStruct::names(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + return _internal_names(index); +} +inline std::string* ParameterizedType_ParameterizedNamedStruct::mutable_names(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + return names_.Mutable(index); +} +inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + names_.Mutable(index)->assign(value); +} +inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + names_.Mutable(index)->assign(std::move(value)); +} +inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) +} +inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const char* value, size_t size) { + names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) +} +inline std::string* ParameterizedType_ParameterizedNamedStruct::_internal_add_names() { + return names_.Add(); +} +inline void ParameterizedType_ParameterizedNamedStruct::add_names(const std::string& value) { + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) +} +inline void ParameterizedType_ParameterizedNamedStruct::add_names(std::string&& value) { + names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) +} +inline void ParameterizedType_ParameterizedNamedStruct::add_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) +} +inline void ParameterizedType_ParameterizedNamedStruct::add_names(const char* value, size_t size) { + names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +ParameterizedType_ParameterizedNamedStruct::names() const { + // @@protoc_insertion_point(field_list:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +ParameterizedType_ParameterizedNamedStruct::mutable_names() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + return &names_; +} + +// .io.substrait.ParameterizedType.ParameterizedStruct struct = 2; +inline bool ParameterizedType_ParameterizedNamedStruct::_internal_has_struct_() const { + return this != internal_default_instance() && struct__ != nullptr; +} +inline bool ParameterizedType_ParameterizedNamedStruct::has_struct_() const { + return _internal_has_struct_(); +} +inline void ParameterizedType_ParameterizedNamedStruct::clear_struct_() { + if (GetArena() == nullptr && struct__ != nullptr) { + delete struct__; + } + struct__ = nullptr; +} +inline const ::io::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::_internal_struct_() const { + const ::io::substrait::ParameterizedType_ParameterizedStruct* p = struct__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_ParameterizedStruct_default_instance_); +} +inline const ::io::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedNamedStruct.struct) + return _internal_struct_(); +} +inline void ParameterizedType_ParameterizedNamedStruct::unsafe_arena_set_allocated_struct_( + ::io::substrait::ParameterizedType_ParameterizedStruct* struct_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); + } + struct__ = struct_; + if (struct_) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedNamedStruct.struct) +} +inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::release_struct_() { + + ::io::substrait::ParameterizedType_ParameterizedStruct* temp = struct__; + struct__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedNamedStruct.struct) + + ::io::substrait::ParameterizedType_ParameterizedStruct* temp = struct__; + struct__ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::_internal_mutable_struct_() { + + if (struct__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedStruct>(GetArena()); + struct__ = p; + } + return struct__; +} +inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedNamedStruct.struct) + return _internal_mutable_struct_(); +} +inline void ParameterizedType_ParameterizedNamedStruct::set_allocated_struct_(::io::substrait::ParameterizedType_ParameterizedStruct* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete struct__; + } + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + + } else { + + } + struct__ = struct_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedNamedStruct.struct) +} + +// ------------------------------------------------------------------- + +// ParameterizedType_ParameterizedList + +// .io.substrait.ParameterizedType type = 1; +inline bool ParameterizedType_ParameterizedList::_internal_has_type() const { + return this != internal_default_instance() && type_ != nullptr; +} +inline bool ParameterizedType_ParameterizedList::has_type() const { + return _internal_has_type(); +} +inline void ParameterizedType_ParameterizedList::clear_type() { + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; +} +inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedList::_internal_type() const { + const ::io::substrait::ParameterizedType* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_default_instance_); +} +inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedList::type() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedList.type) + return _internal_type(); +} +inline void ParameterizedType_ParameterizedList::unsafe_arena_set_allocated_type( + ::io::substrait::ParameterizedType* type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); + } + type_ = type; + if (type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedList.type) +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedList::release_type() { + + ::io::substrait::ParameterizedType* temp = type_; + type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedList::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedList.type) + + ::io::substrait::ParameterizedType* temp = type_; + type_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedList::_internal_mutable_type() { + + if (type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType>(GetArena()); + type_ = p; + } + return type_; +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedList::mutable_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedList.type) + return _internal_mutable_type(); +} +inline void ParameterizedType_ParameterizedList::set_allocated_type(::io::substrait::ParameterizedType* type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete type_; + } + if (type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type); + if (message_arena != submessage_arena) { + type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type, submessage_arena); + } + + } else { + + } + type_ = type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedList.type) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool ParameterizedType_ParameterizedList::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool ParameterizedType_ParameterizedList::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedList::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedList::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedList.variation) + return _internal_variation(); +} +inline void ParameterizedType_ParameterizedList::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedList.variation) +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedList::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedList::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedList.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedList::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedList::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedList.variation) + return _internal_mutable_variation(); +} +inline void ParameterizedType_ParameterizedList::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedList.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void ParameterizedType_ParameterizedList::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedList::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedList::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedList.nullability) + return _internal_nullability(); +} +inline void ParameterizedType_ParameterizedList::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void ParameterizedType_ParameterizedList::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedList.nullability) +} + +// ------------------------------------------------------------------- + +// ParameterizedType_ParameterizedMap + +// .io.substrait.ParameterizedType key = 1; +inline bool ParameterizedType_ParameterizedMap::_internal_has_key() const { + return this != internal_default_instance() && key_ != nullptr; +} +inline bool ParameterizedType_ParameterizedMap::has_key() const { + return _internal_has_key(); +} +inline void ParameterizedType_ParameterizedMap::clear_key() { + if (GetArena() == nullptr && key_ != nullptr) { + delete key_; + } + key_ = nullptr; +} +inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_internal_key() const { + const ::io::substrait::ParameterizedType* p = key_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_default_instance_); +} +inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::key() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedMap.key) + return _internal_key(); +} +inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_key( + ::io::substrait::ParameterizedType* key) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); + } + key_ = key; + if (key) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.key) +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::release_key() { + + ::io::substrait::ParameterizedType* temp = key_; + key_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedMap.key) + + ::io::substrait::ParameterizedType* temp = key_; + key_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_key() { + + if (key_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType>(GetArena()); + key_ = p; + } + return key_; +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedMap.key) + return _internal_mutable_key(); +} +inline void ParameterizedType_ParameterizedMap::set_allocated_key(::io::substrait::ParameterizedType* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + + } else { + + } + key_ = key; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.key) +} + +// .io.substrait.ParameterizedType value = 2; +inline bool ParameterizedType_ParameterizedMap::_internal_has_value() const { + return this != internal_default_instance() && value_ != nullptr; +} +inline bool ParameterizedType_ParameterizedMap::has_value() const { + return _internal_has_value(); +} +inline void ParameterizedType_ParameterizedMap::clear_value() { + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; +} +inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_internal_value() const { + const ::io::substrait::ParameterizedType* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ParameterizedType_default_instance_); +} +inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::value() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedMap.value) + return _internal_value(); +} +inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_value( + ::io::substrait::ParameterizedType* value) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); + } + value_ = value; + if (value) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.value) +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::release_value() { + + ::io::substrait::ParameterizedType* temp = value_; + value_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedMap.value) + + ::io::substrait::ParameterizedType* temp = value_; + value_ = nullptr; + return temp; +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_value() { + + if (value_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType>(GetArena()); + value_ = p; + } + return value_; +} +inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedMap.value) + return _internal_mutable_value(); +} +inline void ParameterizedType_ParameterizedMap::set_allocated_value(::io::substrait::ParameterizedType* value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete value_; + } + if (value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + if (message_arena != submessage_arena) { + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); + } + + } else { + + } + value_ = value; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.value) +} + +// .io.substrait.Type.Variation variation = 3; +inline bool ParameterizedType_ParameterizedMap::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool ParameterizedType_ParameterizedMap::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedMap::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedMap::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedMap.variation) + return _internal_variation(); +} +inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.variation) +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedMap::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedMap::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedMap.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedMap::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedMap::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedMap.variation) + return _internal_mutable_variation(); +} +inline void ParameterizedType_ParameterizedMap::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.variation) +} + +// .io.substrait.Type.Nullability nullability = 4; +inline void ParameterizedType_ParameterizedMap::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedMap::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedMap::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedMap.nullability) + return _internal_nullability(); +} +inline void ParameterizedType_ParameterizedMap::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void ParameterizedType_ParameterizedMap::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedMap.nullability) +} + +// ------------------------------------------------------------------- + +// ParameterizedType_IntegerOption + +// int32 literal = 1; +inline bool ParameterizedType_IntegerOption::_internal_has_literal() const { + return integer_type_case() == kLiteral; +} +inline bool ParameterizedType_IntegerOption::has_literal() const { + return _internal_has_literal(); +} +inline void ParameterizedType_IntegerOption::set_has_literal() { + _oneof_case_[0] = kLiteral; +} +inline void ParameterizedType_IntegerOption::clear_literal() { + if (_internal_has_literal()) { + integer_type_.literal_ = 0; + clear_has_integer_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ParameterizedType_IntegerOption::_internal_literal() const { + if (_internal_has_literal()) { + return integer_type_.literal_; + } + return 0; +} +inline void ParameterizedType_IntegerOption::_internal_set_literal(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!_internal_has_literal()) { + clear_integer_type(); + set_has_literal(); + } + integer_type_.literal_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ParameterizedType_IntegerOption::literal() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.IntegerOption.literal) + return _internal_literal(); +} +inline void ParameterizedType_IntegerOption::set_literal(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_literal(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.IntegerOption.literal) +} + +// .io.substrait.ParameterizedType.IntegerParameter parameter = 2; +inline bool ParameterizedType_IntegerOption::_internal_has_parameter() const { + return integer_type_case() == kParameter; +} +inline bool ParameterizedType_IntegerOption::has_parameter() const { + return _internal_has_parameter(); +} +inline void ParameterizedType_IntegerOption::set_has_parameter() { + _oneof_case_[0] = kParameter; +} +inline void ParameterizedType_IntegerOption::clear_parameter() { + if (_internal_has_parameter()) { + if (GetArena() == nullptr) { + delete integer_type_.parameter_; + } + clear_has_integer_type(); + } +} +inline ::io::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::release_parameter() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.IntegerOption.parameter) + if (_internal_has_parameter()) { + clear_has_integer_type(); + ::io::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + integer_type_.parameter_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::_internal_parameter() const { + return _internal_has_parameter() + ? *integer_type_.parameter_ + : reinterpret_cast< ::io::substrait::ParameterizedType_IntegerParameter&>(::io::substrait::_ParameterizedType_IntegerParameter_default_instance_); +} +inline const ::io::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::parameter() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.IntegerOption.parameter) + return _internal_parameter(); +} +inline ::io::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::unsafe_arena_release_parameter() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.IntegerOption.parameter) + if (_internal_has_parameter()) { + clear_has_integer_type(); + ::io::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_; + integer_type_.parameter_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType_IntegerOption::unsafe_arena_set_allocated_parameter(::io::substrait::ParameterizedType_IntegerParameter* parameter) { + clear_integer_type(); + if (parameter) { + set_has_parameter(); + integer_type_.parameter_ = parameter; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.IntegerOption.parameter) +} +inline ::io::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::_internal_mutable_parameter() { + if (!_internal_has_parameter()) { + clear_integer_type(); + set_has_parameter(); + integer_type_.parameter_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_IntegerParameter >(GetArena()); + } + return integer_type_.parameter_; +} +inline ::io::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::mutable_parameter() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.IntegerOption.parameter) + return _internal_mutable_parameter(); +} + +inline bool ParameterizedType_IntegerOption::has_integer_type() const { + return integer_type_case() != INTEGER_TYPE_NOT_SET; +} +inline void ParameterizedType_IntegerOption::clear_has_integer_type() { + _oneof_case_[0] = INTEGER_TYPE_NOT_SET; +} +inline ParameterizedType_IntegerOption::IntegerTypeCase ParameterizedType_IntegerOption::integer_type_case() const { + return ParameterizedType_IntegerOption::IntegerTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// ParameterizedType + +// .io.substrait.Type.Boolean bool = 1; +inline bool ParameterizedType::_internal_has_bool_() const { + return kind_case() == kBool; +} +inline bool ParameterizedType::has_bool_() const { + return _internal_has_bool_(); +} +inline void ParameterizedType::set_has_bool_() { + _oneof_case_[0] = kBool; +} +inline ::io::substrait::Type_Boolean* ParameterizedType::release_bool_() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.bool) + if (_internal_has_bool_()) { + clear_has_kind(); + ::io::substrait::Type_Boolean* temp = kind_.bool__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.bool__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Boolean& ParameterizedType::_internal_bool_() const { + return _internal_has_bool_() + ? *kind_.bool__ + : reinterpret_cast< ::io::substrait::Type_Boolean&>(::io::substrait::_Type_Boolean_default_instance_); +} +inline const ::io::substrait::Type_Boolean& ParameterizedType::bool_() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.bool) + return _internal_bool_(); +} +inline ::io::substrait::Type_Boolean* ParameterizedType::unsafe_arena_release_bool_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.bool) + if (_internal_has_bool_()) { + clear_has_kind(); + ::io::substrait::Type_Boolean* temp = kind_.bool__; + kind_.bool__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { + clear_kind(); + if (bool_) { + set_has_bool_(); + kind_.bool__ = bool_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.bool) +} +inline ::io::substrait::Type_Boolean* ParameterizedType::_internal_mutable_bool_() { + if (!_internal_has_bool_()) { + clear_kind(); + set_has_bool_(); + kind_.bool__ = CreateMaybeMessage< ::io::substrait::Type_Boolean >(GetArena()); + } + return kind_.bool__; +} +inline ::io::substrait::Type_Boolean* ParameterizedType::mutable_bool_() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.bool) + return _internal_mutable_bool_(); +} + +// .io.substrait.Type.I8 i8 = 2; +inline bool ParameterizedType::_internal_has_i8() const { + return kind_case() == kI8; +} +inline bool ParameterizedType::has_i8() const { + return _internal_has_i8(); +} +inline void ParameterizedType::set_has_i8() { + _oneof_case_[0] = kI8; +} +inline ::io::substrait::Type_I8* ParameterizedType::release_i8() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.i8) + if (_internal_has_i8()) { + clear_has_kind(); + ::io::substrait::Type_I8* temp = kind_.i8_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i8_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I8& ParameterizedType::_internal_i8() const { + return _internal_has_i8() + ? *kind_.i8_ + : reinterpret_cast< ::io::substrait::Type_I8&>(::io::substrait::_Type_I8_default_instance_); +} +inline const ::io::substrait::Type_I8& ParameterizedType::i8() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.i8) + return _internal_i8(); +} +inline ::io::substrait::Type_I8* ParameterizedType::unsafe_arena_release_i8() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.i8) + if (_internal_has_i8()) { + clear_has_kind(); + ::io::substrait::Type_I8* temp = kind_.i8_; + kind_.i8_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_i8(::io::substrait::Type_I8* i8) { + clear_kind(); + if (i8) { + set_has_i8(); + kind_.i8_ = i8; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.i8) +} +inline ::io::substrait::Type_I8* ParameterizedType::_internal_mutable_i8() { + if (!_internal_has_i8()) { + clear_kind(); + set_has_i8(); + kind_.i8_ = CreateMaybeMessage< ::io::substrait::Type_I8 >(GetArena()); + } + return kind_.i8_; +} +inline ::io::substrait::Type_I8* ParameterizedType::mutable_i8() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.i8) + return _internal_mutable_i8(); +} + +// .io.substrait.Type.I16 i16 = 3; +inline bool ParameterizedType::_internal_has_i16() const { + return kind_case() == kI16; +} +inline bool ParameterizedType::has_i16() const { + return _internal_has_i16(); +} +inline void ParameterizedType::set_has_i16() { + _oneof_case_[0] = kI16; +} +inline ::io::substrait::Type_I16* ParameterizedType::release_i16() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.i16) + if (_internal_has_i16()) { + clear_has_kind(); + ::io::substrait::Type_I16* temp = kind_.i16_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i16_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I16& ParameterizedType::_internal_i16() const { + return _internal_has_i16() + ? *kind_.i16_ + : reinterpret_cast< ::io::substrait::Type_I16&>(::io::substrait::_Type_I16_default_instance_); +} +inline const ::io::substrait::Type_I16& ParameterizedType::i16() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.i16) + return _internal_i16(); +} +inline ::io::substrait::Type_I16* ParameterizedType::unsafe_arena_release_i16() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.i16) + if (_internal_has_i16()) { + clear_has_kind(); + ::io::substrait::Type_I16* temp = kind_.i16_; + kind_.i16_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_i16(::io::substrait::Type_I16* i16) { + clear_kind(); + if (i16) { + set_has_i16(); + kind_.i16_ = i16; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.i16) +} +inline ::io::substrait::Type_I16* ParameterizedType::_internal_mutable_i16() { + if (!_internal_has_i16()) { + clear_kind(); + set_has_i16(); + kind_.i16_ = CreateMaybeMessage< ::io::substrait::Type_I16 >(GetArena()); + } + return kind_.i16_; +} +inline ::io::substrait::Type_I16* ParameterizedType::mutable_i16() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.i16) + return _internal_mutable_i16(); +} + +// .io.substrait.Type.I32 i32 = 5; +inline bool ParameterizedType::_internal_has_i32() const { + return kind_case() == kI32; +} +inline bool ParameterizedType::has_i32() const { + return _internal_has_i32(); +} +inline void ParameterizedType::set_has_i32() { + _oneof_case_[0] = kI32; +} +inline ::io::substrait::Type_I32* ParameterizedType::release_i32() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.i32) + if (_internal_has_i32()) { + clear_has_kind(); + ::io::substrait::Type_I32* temp = kind_.i32_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I32& ParameterizedType::_internal_i32() const { + return _internal_has_i32() + ? *kind_.i32_ + : reinterpret_cast< ::io::substrait::Type_I32&>(::io::substrait::_Type_I32_default_instance_); +} +inline const ::io::substrait::Type_I32& ParameterizedType::i32() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.i32) + return _internal_i32(); +} +inline ::io::substrait::Type_I32* ParameterizedType::unsafe_arena_release_i32() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.i32) + if (_internal_has_i32()) { + clear_has_kind(); + ::io::substrait::Type_I32* temp = kind_.i32_; + kind_.i32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_i32(::io::substrait::Type_I32* i32) { + clear_kind(); + if (i32) { + set_has_i32(); + kind_.i32_ = i32; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.i32) +} +inline ::io::substrait::Type_I32* ParameterizedType::_internal_mutable_i32() { + if (!_internal_has_i32()) { + clear_kind(); + set_has_i32(); + kind_.i32_ = CreateMaybeMessage< ::io::substrait::Type_I32 >(GetArena()); + } + return kind_.i32_; +} +inline ::io::substrait::Type_I32* ParameterizedType::mutable_i32() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.i32) + return _internal_mutable_i32(); +} + +// .io.substrait.Type.I64 i64 = 7; +inline bool ParameterizedType::_internal_has_i64() const { + return kind_case() == kI64; +} +inline bool ParameterizedType::has_i64() const { + return _internal_has_i64(); +} +inline void ParameterizedType::set_has_i64() { + _oneof_case_[0] = kI64; +} +inline ::io::substrait::Type_I64* ParameterizedType::release_i64() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.i64) + if (_internal_has_i64()) { + clear_has_kind(); + ::io::substrait::Type_I64* temp = kind_.i64_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I64& ParameterizedType::_internal_i64() const { + return _internal_has_i64() + ? *kind_.i64_ + : reinterpret_cast< ::io::substrait::Type_I64&>(::io::substrait::_Type_I64_default_instance_); +} +inline const ::io::substrait::Type_I64& ParameterizedType::i64() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.i64) + return _internal_i64(); +} +inline ::io::substrait::Type_I64* ParameterizedType::unsafe_arena_release_i64() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.i64) + if (_internal_has_i64()) { + clear_has_kind(); + ::io::substrait::Type_I64* temp = kind_.i64_; + kind_.i64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_i64(::io::substrait::Type_I64* i64) { + clear_kind(); + if (i64) { + set_has_i64(); + kind_.i64_ = i64; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.i64) +} +inline ::io::substrait::Type_I64* ParameterizedType::_internal_mutable_i64() { + if (!_internal_has_i64()) { + clear_kind(); + set_has_i64(); + kind_.i64_ = CreateMaybeMessage< ::io::substrait::Type_I64 >(GetArena()); + } + return kind_.i64_; +} +inline ::io::substrait::Type_I64* ParameterizedType::mutable_i64() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.i64) + return _internal_mutable_i64(); +} + +// .io.substrait.Type.FP32 fp32 = 10; +inline bool ParameterizedType::_internal_has_fp32() const { + return kind_case() == kFp32; +} +inline bool ParameterizedType::has_fp32() const { + return _internal_has_fp32(); +} +inline void ParameterizedType::set_has_fp32() { + _oneof_case_[0] = kFp32; +} +inline ::io::substrait::Type_FP32* ParameterizedType::release_fp32() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.fp32) + if (_internal_has_fp32()) { + clear_has_kind(); + ::io::substrait::Type_FP32* temp = kind_.fp32_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fp32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_FP32& ParameterizedType::_internal_fp32() const { + return _internal_has_fp32() + ? *kind_.fp32_ + : reinterpret_cast< ::io::substrait::Type_FP32&>(::io::substrait::_Type_FP32_default_instance_); +} +inline const ::io::substrait::Type_FP32& ParameterizedType::fp32() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.fp32) + return _internal_fp32(); +} +inline ::io::substrait::Type_FP32* ParameterizedType::unsafe_arena_release_fp32() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.fp32) + if (_internal_has_fp32()) { + clear_has_kind(); + ::io::substrait::Type_FP32* temp = kind_.fp32_; + kind_.fp32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_fp32(::io::substrait::Type_FP32* fp32) { + clear_kind(); + if (fp32) { + set_has_fp32(); + kind_.fp32_ = fp32; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.fp32) +} +inline ::io::substrait::Type_FP32* ParameterizedType::_internal_mutable_fp32() { + if (!_internal_has_fp32()) { + clear_kind(); + set_has_fp32(); + kind_.fp32_ = CreateMaybeMessage< ::io::substrait::Type_FP32 >(GetArena()); + } + return kind_.fp32_; +} +inline ::io::substrait::Type_FP32* ParameterizedType::mutable_fp32() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.fp32) + return _internal_mutable_fp32(); +} + +// .io.substrait.Type.FP64 fp64 = 11; +inline bool ParameterizedType::_internal_has_fp64() const { + return kind_case() == kFp64; +} +inline bool ParameterizedType::has_fp64() const { + return _internal_has_fp64(); +} +inline void ParameterizedType::set_has_fp64() { + _oneof_case_[0] = kFp64; +} +inline ::io::substrait::Type_FP64* ParameterizedType::release_fp64() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.fp64) + if (_internal_has_fp64()) { + clear_has_kind(); + ::io::substrait::Type_FP64* temp = kind_.fp64_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fp64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_FP64& ParameterizedType::_internal_fp64() const { + return _internal_has_fp64() + ? *kind_.fp64_ + : reinterpret_cast< ::io::substrait::Type_FP64&>(::io::substrait::_Type_FP64_default_instance_); +} +inline const ::io::substrait::Type_FP64& ParameterizedType::fp64() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.fp64) + return _internal_fp64(); +} +inline ::io::substrait::Type_FP64* ParameterizedType::unsafe_arena_release_fp64() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.fp64) + if (_internal_has_fp64()) { + clear_has_kind(); + ::io::substrait::Type_FP64* temp = kind_.fp64_; + kind_.fp64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_fp64(::io::substrait::Type_FP64* fp64) { + clear_kind(); + if (fp64) { + set_has_fp64(); + kind_.fp64_ = fp64; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.fp64) +} +inline ::io::substrait::Type_FP64* ParameterizedType::_internal_mutable_fp64() { + if (!_internal_has_fp64()) { + clear_kind(); + set_has_fp64(); + kind_.fp64_ = CreateMaybeMessage< ::io::substrait::Type_FP64 >(GetArena()); + } + return kind_.fp64_; +} +inline ::io::substrait::Type_FP64* ParameterizedType::mutable_fp64() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.fp64) + return _internal_mutable_fp64(); +} + +// .io.substrait.Type.String string = 12; +inline bool ParameterizedType::_internal_has_string() const { + return kind_case() == kString; +} +inline bool ParameterizedType::has_string() const { + return _internal_has_string(); +} +inline void ParameterizedType::set_has_string() { + _oneof_case_[0] = kString; +} +inline ::io::substrait::Type_String* ParameterizedType::release_string() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.string) + if (_internal_has_string()) { + clear_has_kind(); + ::io::substrait::Type_String* temp = kind_.string_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.string_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_String& ParameterizedType::_internal_string() const { + return _internal_has_string() + ? *kind_.string_ + : reinterpret_cast< ::io::substrait::Type_String&>(::io::substrait::_Type_String_default_instance_); +} +inline const ::io::substrait::Type_String& ParameterizedType::string() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.string) + return _internal_string(); +} +inline ::io::substrait::Type_String* ParameterizedType::unsafe_arena_release_string() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.string) + if (_internal_has_string()) { + clear_has_kind(); + ::io::substrait::Type_String* temp = kind_.string_; + kind_.string_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_string(::io::substrait::Type_String* string) { + clear_kind(); + if (string) { + set_has_string(); + kind_.string_ = string; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.string) +} +inline ::io::substrait::Type_String* ParameterizedType::_internal_mutable_string() { + if (!_internal_has_string()) { + clear_kind(); + set_has_string(); + kind_.string_ = CreateMaybeMessage< ::io::substrait::Type_String >(GetArena()); + } + return kind_.string_; +} +inline ::io::substrait::Type_String* ParameterizedType::mutable_string() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.string) + return _internal_mutable_string(); +} + +// .io.substrait.Type.Binary binary = 13; +inline bool ParameterizedType::_internal_has_binary() const { + return kind_case() == kBinary; +} +inline bool ParameterizedType::has_binary() const { + return _internal_has_binary(); +} +inline void ParameterizedType::set_has_binary() { + _oneof_case_[0] = kBinary; +} +inline ::io::substrait::Type_Binary* ParameterizedType::release_binary() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.binary) + if (_internal_has_binary()) { + clear_has_kind(); + ::io::substrait::Type_Binary* temp = kind_.binary_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Binary& ParameterizedType::_internal_binary() const { + return _internal_has_binary() + ? *kind_.binary_ + : reinterpret_cast< ::io::substrait::Type_Binary&>(::io::substrait::_Type_Binary_default_instance_); +} +inline const ::io::substrait::Type_Binary& ParameterizedType::binary() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.binary) + return _internal_binary(); +} +inline ::io::substrait::Type_Binary* ParameterizedType::unsafe_arena_release_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.binary) + if (_internal_has_binary()) { + clear_has_kind(); + ::io::substrait::Type_Binary* temp = kind_.binary_; + kind_.binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_binary(::io::substrait::Type_Binary* binary) { + clear_kind(); + if (binary) { + set_has_binary(); + kind_.binary_ = binary; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.binary) +} +inline ::io::substrait::Type_Binary* ParameterizedType::_internal_mutable_binary() { + if (!_internal_has_binary()) { + clear_kind(); + set_has_binary(); + kind_.binary_ = CreateMaybeMessage< ::io::substrait::Type_Binary >(GetArena()); + } + return kind_.binary_; +} +inline ::io::substrait::Type_Binary* ParameterizedType::mutable_binary() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.binary) + return _internal_mutable_binary(); +} + +// .io.substrait.Type.Timestamp timestamp = 14; +inline bool ParameterizedType::_internal_has_timestamp() const { + return kind_case() == kTimestamp; +} +inline bool ParameterizedType::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void ParameterizedType::set_has_timestamp() { + _oneof_case_[0] = kTimestamp; +} +inline ::io::substrait::Type_Timestamp* ParameterizedType::release_timestamp() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.timestamp) + if (_internal_has_timestamp()) { + clear_has_kind(); + ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.timestamp_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Timestamp& ParameterizedType::_internal_timestamp() const { + return _internal_has_timestamp() + ? *kind_.timestamp_ + : reinterpret_cast< ::io::substrait::Type_Timestamp&>(::io::substrait::_Type_Timestamp_default_instance_); +} +inline const ::io::substrait::Type_Timestamp& ParameterizedType::timestamp() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.timestamp) + return _internal_timestamp(); +} +inline ::io::substrait::Type_Timestamp* ParameterizedType::unsafe_arena_release_timestamp() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.timestamp) + if (_internal_has_timestamp()) { + clear_has_kind(); + ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + kind_.timestamp_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { + clear_kind(); + if (timestamp) { + set_has_timestamp(); + kind_.timestamp_ = timestamp; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.timestamp) +} +inline ::io::substrait::Type_Timestamp* ParameterizedType::_internal_mutable_timestamp() { + if (!_internal_has_timestamp()) { + clear_kind(); + set_has_timestamp(); + kind_.timestamp_ = CreateMaybeMessage< ::io::substrait::Type_Timestamp >(GetArena()); + } + return kind_.timestamp_; +} +inline ::io::substrait::Type_Timestamp* ParameterizedType::mutable_timestamp() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.timestamp) + return _internal_mutable_timestamp(); +} + +// .io.substrait.Type.Date date = 16; +inline bool ParameterizedType::_internal_has_date() const { + return kind_case() == kDate; +} +inline bool ParameterizedType::has_date() const { + return _internal_has_date(); +} +inline void ParameterizedType::set_has_date() { + _oneof_case_[0] = kDate; +} +inline ::io::substrait::Type_Date* ParameterizedType::release_date() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.date) + if (_internal_has_date()) { + clear_has_kind(); + ::io::substrait::Type_Date* temp = kind_.date_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.date_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Date& ParameterizedType::_internal_date() const { + return _internal_has_date() + ? *kind_.date_ + : reinterpret_cast< ::io::substrait::Type_Date&>(::io::substrait::_Type_Date_default_instance_); +} +inline const ::io::substrait::Type_Date& ParameterizedType::date() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.date) + return _internal_date(); +} +inline ::io::substrait::Type_Date* ParameterizedType::unsafe_arena_release_date() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.date) + if (_internal_has_date()) { + clear_has_kind(); + ::io::substrait::Type_Date* temp = kind_.date_; + kind_.date_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_date(::io::substrait::Type_Date* date) { + clear_kind(); + if (date) { + set_has_date(); + kind_.date_ = date; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.date) +} +inline ::io::substrait::Type_Date* ParameterizedType::_internal_mutable_date() { + if (!_internal_has_date()) { + clear_kind(); + set_has_date(); + kind_.date_ = CreateMaybeMessage< ::io::substrait::Type_Date >(GetArena()); + } + return kind_.date_; +} +inline ::io::substrait::Type_Date* ParameterizedType::mutable_date() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.date) + return _internal_mutable_date(); +} + +// .io.substrait.Type.Time time = 17; +inline bool ParameterizedType::_internal_has_time() const { + return kind_case() == kTime; +} +inline bool ParameterizedType::has_time() const { + return _internal_has_time(); +} +inline void ParameterizedType::set_has_time() { + _oneof_case_[0] = kTime; +} +inline ::io::substrait::Type_Time* ParameterizedType::release_time() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.time) + if (_internal_has_time()) { + clear_has_kind(); + ::io::substrait::Type_Time* temp = kind_.time_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.time_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Time& ParameterizedType::_internal_time() const { + return _internal_has_time() + ? *kind_.time_ + : reinterpret_cast< ::io::substrait::Type_Time&>(::io::substrait::_Type_Time_default_instance_); +} +inline const ::io::substrait::Type_Time& ParameterizedType::time() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.time) + return _internal_time(); +} +inline ::io::substrait::Type_Time* ParameterizedType::unsafe_arena_release_time() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.time) + if (_internal_has_time()) { + clear_has_kind(); + ::io::substrait::Type_Time* temp = kind_.time_; + kind_.time_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_time(::io::substrait::Type_Time* time) { + clear_kind(); + if (time) { + set_has_time(); + kind_.time_ = time; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.time) +} +inline ::io::substrait::Type_Time* ParameterizedType::_internal_mutable_time() { + if (!_internal_has_time()) { + clear_kind(); + set_has_time(); + kind_.time_ = CreateMaybeMessage< ::io::substrait::Type_Time >(GetArena()); + } + return kind_.time_; +} +inline ::io::substrait::Type_Time* ParameterizedType::mutable_time() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.time) + return _internal_mutable_time(); +} + +// .io.substrait.Type.IntervalYear interval_year = 19; +inline bool ParameterizedType::_internal_has_interval_year() const { + return kind_case() == kIntervalYear; +} +inline bool ParameterizedType::has_interval_year() const { + return _internal_has_interval_year(); +} +inline void ParameterizedType::set_has_interval_year() { + _oneof_case_[0] = kIntervalYear; +} +inline ::io::substrait::Type_IntervalYear* ParameterizedType::release_interval_year() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.interval_year) + if (_internal_has_interval_year()) { + clear_has_kind(); + ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.interval_year_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_IntervalYear& ParameterizedType::_internal_interval_year() const { + return _internal_has_interval_year() + ? *kind_.interval_year_ + : reinterpret_cast< ::io::substrait::Type_IntervalYear&>(::io::substrait::_Type_IntervalYear_default_instance_); +} +inline const ::io::substrait::Type_IntervalYear& ParameterizedType::interval_year() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.interval_year) + return _internal_interval_year(); +} +inline ::io::substrait::Type_IntervalYear* ParameterizedType::unsafe_arena_release_interval_year() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.interval_year) + if (_internal_has_interval_year()) { + clear_has_kind(); + ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + kind_.interval_year_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { + clear_kind(); + if (interval_year) { + set_has_interval_year(); + kind_.interval_year_ = interval_year; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.interval_year) +} +inline ::io::substrait::Type_IntervalYear* ParameterizedType::_internal_mutable_interval_year() { + if (!_internal_has_interval_year()) { + clear_kind(); + set_has_interval_year(); + kind_.interval_year_ = CreateMaybeMessage< ::io::substrait::Type_IntervalYear >(GetArena()); + } + return kind_.interval_year_; +} +inline ::io::substrait::Type_IntervalYear* ParameterizedType::mutable_interval_year() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.interval_year) + return _internal_mutable_interval_year(); +} + +// .io.substrait.Type.IntervalDay interval_day = 20; +inline bool ParameterizedType::_internal_has_interval_day() const { + return kind_case() == kIntervalDay; +} +inline bool ParameterizedType::has_interval_day() const { + return _internal_has_interval_day(); +} +inline void ParameterizedType::set_has_interval_day() { + _oneof_case_[0] = kIntervalDay; +} +inline ::io::substrait::Type_IntervalDay* ParameterizedType::release_interval_day() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.interval_day) + if (_internal_has_interval_day()) { + clear_has_kind(); + ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.interval_day_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_IntervalDay& ParameterizedType::_internal_interval_day() const { + return _internal_has_interval_day() + ? *kind_.interval_day_ + : reinterpret_cast< ::io::substrait::Type_IntervalDay&>(::io::substrait::_Type_IntervalDay_default_instance_); +} +inline const ::io::substrait::Type_IntervalDay& ParameterizedType::interval_day() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.interval_day) + return _internal_interval_day(); +} +inline ::io::substrait::Type_IntervalDay* ParameterizedType::unsafe_arena_release_interval_day() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.interval_day) + if (_internal_has_interval_day()) { + clear_has_kind(); + ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + kind_.interval_day_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { + clear_kind(); + if (interval_day) { + set_has_interval_day(); + kind_.interval_day_ = interval_day; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.interval_day) +} +inline ::io::substrait::Type_IntervalDay* ParameterizedType::_internal_mutable_interval_day() { + if (!_internal_has_interval_day()) { + clear_kind(); + set_has_interval_day(); + kind_.interval_day_ = CreateMaybeMessage< ::io::substrait::Type_IntervalDay >(GetArena()); + } + return kind_.interval_day_; +} +inline ::io::substrait::Type_IntervalDay* ParameterizedType::mutable_interval_day() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.interval_day) + return _internal_mutable_interval_day(); +} + +// .io.substrait.Type.TimestampTZ timestamp_tz = 29; +inline bool ParameterizedType::_internal_has_timestamp_tz() const { + return kind_case() == kTimestampTz; +} +inline bool ParameterizedType::has_timestamp_tz() const { + return _internal_has_timestamp_tz(); +} +inline void ParameterizedType::set_has_timestamp_tz() { + _oneof_case_[0] = kTimestampTz; +} +inline ::io::substrait::Type_TimestampTZ* ParameterizedType::release_timestamp_tz() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.timestamp_tz) + if (_internal_has_timestamp_tz()) { + clear_has_kind(); + ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.timestamp_tz_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_TimestampTZ& ParameterizedType::_internal_timestamp_tz() const { + return _internal_has_timestamp_tz() + ? *kind_.timestamp_tz_ + : reinterpret_cast< ::io::substrait::Type_TimestampTZ&>(::io::substrait::_Type_TimestampTZ_default_instance_); +} +inline const ::io::substrait::Type_TimestampTZ& ParameterizedType::timestamp_tz() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.timestamp_tz) + return _internal_timestamp_tz(); +} +inline ::io::substrait::Type_TimestampTZ* ParameterizedType::unsafe_arena_release_timestamp_tz() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.timestamp_tz) + if (_internal_has_timestamp_tz()) { + clear_has_kind(); + ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + kind_.timestamp_tz_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { + clear_kind(); + if (timestamp_tz) { + set_has_timestamp_tz(); + kind_.timestamp_tz_ = timestamp_tz; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.timestamp_tz) +} +inline ::io::substrait::Type_TimestampTZ* ParameterizedType::_internal_mutable_timestamp_tz() { + if (!_internal_has_timestamp_tz()) { + clear_kind(); + set_has_timestamp_tz(); + kind_.timestamp_tz_ = CreateMaybeMessage< ::io::substrait::Type_TimestampTZ >(GetArena()); + } + return kind_.timestamp_tz_; +} +inline ::io::substrait::Type_TimestampTZ* ParameterizedType::mutable_timestamp_tz() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.timestamp_tz) + return _internal_mutable_timestamp_tz(); +} + +// .io.substrait.Type.UUID uuid = 32; +inline bool ParameterizedType::_internal_has_uuid() const { + return kind_case() == kUuid; +} +inline bool ParameterizedType::has_uuid() const { + return _internal_has_uuid(); +} +inline void ParameterizedType::set_has_uuid() { + _oneof_case_[0] = kUuid; +} +inline ::io::substrait::Type_UUID* ParameterizedType::release_uuid() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.uuid) + if (_internal_has_uuid()) { + clear_has_kind(); + ::io::substrait::Type_UUID* temp = kind_.uuid_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.uuid_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_UUID& ParameterizedType::_internal_uuid() const { + return _internal_has_uuid() + ? *kind_.uuid_ + : reinterpret_cast< ::io::substrait::Type_UUID&>(::io::substrait::_Type_UUID_default_instance_); +} +inline const ::io::substrait::Type_UUID& ParameterizedType::uuid() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.uuid) + return _internal_uuid(); +} +inline ::io::substrait::Type_UUID* ParameterizedType::unsafe_arena_release_uuid() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.uuid) + if (_internal_has_uuid()) { + clear_has_kind(); + ::io::substrait::Type_UUID* temp = kind_.uuid_; + kind_.uuid_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_uuid(::io::substrait::Type_UUID* uuid) { + clear_kind(); + if (uuid) { + set_has_uuid(); + kind_.uuid_ = uuid; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.uuid) +} +inline ::io::substrait::Type_UUID* ParameterizedType::_internal_mutable_uuid() { + if (!_internal_has_uuid()) { + clear_kind(); + set_has_uuid(); + kind_.uuid_ = CreateMaybeMessage< ::io::substrait::Type_UUID >(GetArena()); + } + return kind_.uuid_; +} +inline ::io::substrait::Type_UUID* ParameterizedType::mutable_uuid() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.uuid) + return _internal_mutable_uuid(); +} + +// .io.substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; +inline bool ParameterizedType::_internal_has_fixed_char() const { + return kind_case() == kFixedChar; +} +inline bool ParameterizedType::has_fixed_char() const { + return _internal_has_fixed_char(); +} +inline void ParameterizedType::set_has_fixed_char() { + _oneof_case_[0] = kFixedChar; +} +inline void ParameterizedType::clear_fixed_char() { + if (_internal_has_fixed_char()) { + if (GetArena() == nullptr) { + delete kind_.fixed_char_; + } + clear_has_kind(); + } +} +inline ::io::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::release_fixed_char() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.fixed_char) + if (_internal_has_fixed_char()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fixed_char_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::_internal_fixed_char() const { + return _internal_has_fixed_char() + ? *kind_.fixed_char_ + : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedFixedChar&>(::io::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_); +} +inline const ::io::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::fixed_char() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.fixed_char) + return _internal_fixed_char(); +} +inline ::io::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::unsafe_arena_release_fixed_char() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.fixed_char) + if (_internal_has_fixed_char()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_; + kind_.fixed_char_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_fixed_char(::io::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) { + clear_kind(); + if (fixed_char) { + set_has_fixed_char(); + kind_.fixed_char_ = fixed_char; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.fixed_char) +} +inline ::io::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::_internal_mutable_fixed_char() { + if (!_internal_has_fixed_char()) { + clear_kind(); + set_has_fixed_char(); + kind_.fixed_char_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedFixedChar >(GetArena()); + } + return kind_.fixed_char_; +} +inline ::io::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::mutable_fixed_char() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.fixed_char) + return _internal_mutable_fixed_char(); +} + +// .io.substrait.ParameterizedType.ParameterizedVarChar varchar = 22; +inline bool ParameterizedType::_internal_has_varchar() const { + return kind_case() == kVarchar; +} +inline bool ParameterizedType::has_varchar() const { + return _internal_has_varchar(); +} +inline void ParameterizedType::set_has_varchar() { + _oneof_case_[0] = kVarchar; +} +inline void ParameterizedType::clear_varchar() { + if (_internal_has_varchar()) { + if (GetArena() == nullptr) { + delete kind_.varchar_; + } + clear_has_kind(); + } +} +inline ::io::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::release_varchar() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.varchar) + if (_internal_has_varchar()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.varchar_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::_internal_varchar() const { + return _internal_has_varchar() + ? *kind_.varchar_ + : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedVarChar&>(::io::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_); +} +inline const ::io::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::varchar() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.varchar) + return _internal_varchar(); +} +inline ::io::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::unsafe_arena_release_varchar() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.varchar) + if (_internal_has_varchar()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_; + kind_.varchar_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_varchar(::io::substrait::ParameterizedType_ParameterizedVarChar* varchar) { + clear_kind(); + if (varchar) { + set_has_varchar(); + kind_.varchar_ = varchar; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.varchar) +} +inline ::io::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::_internal_mutable_varchar() { + if (!_internal_has_varchar()) { + clear_kind(); + set_has_varchar(); + kind_.varchar_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedVarChar >(GetArena()); + } + return kind_.varchar_; +} +inline ::io::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::mutable_varchar() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.varchar) + return _internal_mutable_varchar(); +} + +// .io.substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; +inline bool ParameterizedType::_internal_has_fixed_binary() const { + return kind_case() == kFixedBinary; +} +inline bool ParameterizedType::has_fixed_binary() const { + return _internal_has_fixed_binary(); +} +inline void ParameterizedType::set_has_fixed_binary() { + _oneof_case_[0] = kFixedBinary; +} +inline void ParameterizedType::clear_fixed_binary() { + if (_internal_has_fixed_binary()) { + if (GetArena() == nullptr) { + delete kind_.fixed_binary_; + } + clear_has_kind(); + } +} +inline ::io::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::release_fixed_binary() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.fixed_binary) + if (_internal_has_fixed_binary()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fixed_binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::_internal_fixed_binary() const { + return _internal_has_fixed_binary() + ? *kind_.fixed_binary_ + : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedFixedBinary&>(::io::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_); +} +inline const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::fixed_binary() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.fixed_binary) + return _internal_fixed_binary(); +} +inline ::io::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::unsafe_arena_release_fixed_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.fixed_binary) + if (_internal_has_fixed_binary()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_; + kind_.fixed_binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_fixed_binary(::io::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) { + clear_kind(); + if (fixed_binary) { + set_has_fixed_binary(); + kind_.fixed_binary_ = fixed_binary; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.fixed_binary) +} +inline ::io::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::_internal_mutable_fixed_binary() { + if (!_internal_has_fixed_binary()) { + clear_kind(); + set_has_fixed_binary(); + kind_.fixed_binary_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedFixedBinary >(GetArena()); + } + return kind_.fixed_binary_; +} +inline ::io::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::mutable_fixed_binary() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.fixed_binary) + return _internal_mutable_fixed_binary(); +} + +// .io.substrait.ParameterizedType.ParameterizedDecimal decimal = 24; +inline bool ParameterizedType::_internal_has_decimal() const { + return kind_case() == kDecimal; +} +inline bool ParameterizedType::has_decimal() const { + return _internal_has_decimal(); +} +inline void ParameterizedType::set_has_decimal() { + _oneof_case_[0] = kDecimal; +} +inline void ParameterizedType::clear_decimal() { + if (_internal_has_decimal()) { + if (GetArena() == nullptr) { + delete kind_.decimal_; + } + clear_has_kind(); + } +} +inline ::io::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::release_decimal() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.decimal) + if (_internal_has_decimal()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.decimal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::_internal_decimal() const { + return _internal_has_decimal() + ? *kind_.decimal_ + : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedDecimal&>(::io::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_); +} +inline const ::io::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::decimal() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.decimal) + return _internal_decimal(); +} +inline ::io::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::unsafe_arena_release_decimal() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.decimal) + if (_internal_has_decimal()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_; + kind_.decimal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_decimal(::io::substrait::ParameterizedType_ParameterizedDecimal* decimal) { + clear_kind(); + if (decimal) { + set_has_decimal(); + kind_.decimal_ = decimal; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.decimal) +} +inline ::io::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::_internal_mutable_decimal() { + if (!_internal_has_decimal()) { + clear_kind(); + set_has_decimal(); + kind_.decimal_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedDecimal >(GetArena()); + } + return kind_.decimal_; +} +inline ::io::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::mutable_decimal() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.decimal) + return _internal_mutable_decimal(); +} + +// .io.substrait.ParameterizedType.ParameterizedStruct struct = 25; +inline bool ParameterizedType::_internal_has_struct_() const { + return kind_case() == kStruct; +} +inline bool ParameterizedType::has_struct_() const { + return _internal_has_struct_(); +} +inline void ParameterizedType::set_has_struct_() { + _oneof_case_[0] = kStruct; +} +inline void ParameterizedType::clear_struct_() { + if (_internal_has_struct_()) { + if (GetArena() == nullptr) { + delete kind_.struct__; + } + clear_has_kind(); + } +} +inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.struct) + if (_internal_has_struct_()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::_internal_struct_() const { + return _internal_has_struct_() + ? *kind_.struct__ + : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedStruct&>(::io::substrait::_ParameterizedType_ParameterizedStruct_default_instance_); +} +inline const ::io::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.struct) + return _internal_struct_(); +} +inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.struct) + if (_internal_has_struct_()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__; + kind_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_struct_(::io::substrait::ParameterizedType_ParameterizedStruct* struct_) { + clear_kind(); + if (struct_) { + set_has_struct_(); + kind_.struct__ = struct_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.struct) +} +inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::_internal_mutable_struct_() { + if (!_internal_has_struct_()) { + clear_kind(); + set_has_struct_(); + kind_.struct__ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedStruct >(GetArena()); + } + return kind_.struct__; +} +inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.struct) + return _internal_mutable_struct_(); +} + +// .io.substrait.ParameterizedType.ParameterizedList list = 27; +inline bool ParameterizedType::_internal_has_list() const { + return kind_case() == kList; +} +inline bool ParameterizedType::has_list() const { + return _internal_has_list(); +} +inline void ParameterizedType::set_has_list() { + _oneof_case_[0] = kList; +} +inline void ParameterizedType::clear_list() { + if (_internal_has_list()) { + if (GetArena() == nullptr) { + delete kind_.list_; + } + clear_has_kind(); + } +} +inline ::io::substrait::ParameterizedType_ParameterizedList* ParameterizedType::release_list() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.list) + if (_internal_has_list()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ParameterizedType_ParameterizedList& ParameterizedType::_internal_list() const { + return _internal_has_list() + ? *kind_.list_ + : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedList&>(::io::substrait::_ParameterizedType_ParameterizedList_default_instance_); +} +inline const ::io::substrait::ParameterizedType_ParameterizedList& ParameterizedType::list() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.list) + return _internal_list(); +} +inline ::io::substrait::ParameterizedType_ParameterizedList* ParameterizedType::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.list) + if (_internal_has_list()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_; + kind_.list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_list(::io::substrait::ParameterizedType_ParameterizedList* list) { + clear_kind(); + if (list) { + set_has_list(); + kind_.list_ = list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.list) +} +inline ::io::substrait::ParameterizedType_ParameterizedList* ParameterizedType::_internal_mutable_list() { + if (!_internal_has_list()) { + clear_kind(); + set_has_list(); + kind_.list_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedList >(GetArena()); + } + return kind_.list_; +} +inline ::io::substrait::ParameterizedType_ParameterizedList* ParameterizedType::mutable_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.list) + return _internal_mutable_list(); +} + +// .io.substrait.ParameterizedType.ParameterizedMap map = 28; +inline bool ParameterizedType::_internal_has_map() const { + return kind_case() == kMap; +} +inline bool ParameterizedType::has_map() const { + return _internal_has_map(); +} +inline void ParameterizedType::set_has_map() { + _oneof_case_[0] = kMap; +} +inline void ParameterizedType::clear_map() { + if (_internal_has_map()) { + if (GetArena() == nullptr) { + delete kind_.map_; + } + clear_has_kind(); + } +} +inline ::io::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::release_map() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.map) + if (_internal_has_map()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::_internal_map() const { + return _internal_has_map() + ? *kind_.map_ + : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedMap&>(::io::substrait::_ParameterizedType_ParameterizedMap_default_instance_); +} +inline const ::io::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::map() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.map) + return _internal_map(); +} +inline ::io::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.map) + if (_internal_has_map()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_; + kind_.map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_map(::io::substrait::ParameterizedType_ParameterizedMap* map) { + clear_kind(); + if (map) { + set_has_map(); + kind_.map_ = map; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.map) +} +inline ::io::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::_internal_mutable_map() { + if (!_internal_has_map()) { + clear_kind(); + set_has_map(); + kind_.map_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedMap >(GetArena()); + } + return kind_.map_; +} +inline ::io::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::mutable_map() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.map) + return _internal_mutable_map(); +} + +// .io.substrait.Extensions.TypeId user_defined = 31; +inline bool ParameterizedType::_internal_has_user_defined() const { + return kind_case() == kUserDefined; +} +inline bool ParameterizedType::has_user_defined() const { + return _internal_has_user_defined(); +} +inline void ParameterizedType::set_has_user_defined() { + _oneof_case_[0] = kUserDefined; +} +inline ::io::substrait::Extensions_TypeId* ParameterizedType::release_user_defined() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.user_defined) + if (_internal_has_user_defined()) { + clear_has_kind(); + ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.user_defined_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Extensions_TypeId& ParameterizedType::_internal_user_defined() const { + return _internal_has_user_defined() + ? *kind_.user_defined_ + : reinterpret_cast< ::io::substrait::Extensions_TypeId&>(::io::substrait::_Extensions_TypeId_default_instance_); +} +inline const ::io::substrait::Extensions_TypeId& ParameterizedType::user_defined() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.user_defined) + return _internal_user_defined(); +} +inline ::io::substrait::Extensions_TypeId* ParameterizedType::unsafe_arena_release_user_defined() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.user_defined) + if (_internal_has_user_defined()) { + clear_has_kind(); + ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; + kind_.user_defined_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { + clear_kind(); + if (user_defined) { + set_has_user_defined(); + kind_.user_defined_ = user_defined; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.user_defined) +} +inline ::io::substrait::Extensions_TypeId* ParameterizedType::_internal_mutable_user_defined() { + if (!_internal_has_user_defined()) { + clear_kind(); + set_has_user_defined(); + kind_.user_defined_ = CreateMaybeMessage< ::io::substrait::Extensions_TypeId >(GetArena()); + } + return kind_.user_defined_; +} +inline ::io::substrait::Extensions_TypeId* ParameterizedType::mutable_user_defined() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.user_defined) + return _internal_mutable_user_defined(); +} + +// .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; +inline bool ParameterizedType::_internal_has_type_parameter() const { + return kind_case() == kTypeParameter; +} +inline bool ParameterizedType::has_type_parameter() const { + return _internal_has_type_parameter(); +} +inline void ParameterizedType::set_has_type_parameter() { + _oneof_case_[0] = kTypeParameter; +} +inline void ParameterizedType::clear_type_parameter() { + if (_internal_has_type_parameter()) { + if (GetArena() == nullptr) { + delete kind_.type_parameter_; + } + clear_has_kind(); + } +} +inline ::io::substrait::ParameterizedType_TypeParameter* ParameterizedType::release_type_parameter() { + // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.type_parameter) + if (_internal_has_type_parameter()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.type_parameter_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ParameterizedType_TypeParameter& ParameterizedType::_internal_type_parameter() const { + return _internal_has_type_parameter() + ? *kind_.type_parameter_ + : reinterpret_cast< ::io::substrait::ParameterizedType_TypeParameter&>(::io::substrait::_ParameterizedType_TypeParameter_default_instance_); +} +inline const ::io::substrait::ParameterizedType_TypeParameter& ParameterizedType::type_parameter() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.type_parameter) + return _internal_type_parameter(); +} +inline ::io::substrait::ParameterizedType_TypeParameter* ParameterizedType::unsafe_arena_release_type_parameter() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.type_parameter) + if (_internal_has_type_parameter()) { + clear_has_kind(); + ::io::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_; + kind_.type_parameter_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ParameterizedType::unsafe_arena_set_allocated_type_parameter(::io::substrait::ParameterizedType_TypeParameter* type_parameter) { + clear_kind(); + if (type_parameter) { + set_has_type_parameter(); + kind_.type_parameter_ = type_parameter; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.type_parameter) +} +inline ::io::substrait::ParameterizedType_TypeParameter* ParameterizedType::_internal_mutable_type_parameter() { + if (!_internal_has_type_parameter()) { + clear_kind(); + set_has_type_parameter(); + kind_.type_parameter_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_TypeParameter >(GetArena()); + } + return kind_.type_parameter_; +} +inline ::io::substrait::ParameterizedType_TypeParameter* ParameterizedType::mutable_type_parameter() { + // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.type_parameter) + return _internal_mutable_type_parameter(); +} + +inline bool ParameterizedType::has_kind() const { + return kind_case() != KIND_NOT_SET; +} +inline void ParameterizedType::clear_has_kind() { + _oneof_case_[0] = KIND_NOT_SET; +} +inline ParameterizedType::KindCase ParameterizedType::kind_case() const { + return ParameterizedType::KindCase(_oneof_case_[0]); +} +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace substrait +} // namespace io + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_parameterized_5ftypes_2eproto diff --git a/cpp/src/generated/substrait/plan.pb.cc b/cpp/src/generated/substrait/plan.pb.cc new file mode 100644 index 00000000000..f0b88d69829 --- /dev/null +++ b/cpp/src/generated/substrait/plan.pb.cc @@ -0,0 +1,366 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: plan.proto + +#include "plan.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace io { +namespace substrait { +constexpr Plan::Plan( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : extensions_() + , mappings_() + , relations_(){} +struct PlanDefaultTypeInternal { + constexpr PlanDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PlanDefaultTypeInternal() {} + union { + Plan _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PlanDefaultTypeInternal _Plan_default_instance_; +} // namespace substrait +} // namespace io +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_plan_2eproto[1]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_plan_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_plan_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_plan_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, extensions_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, mappings_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, relations_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::io::substrait::Plan)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_Plan_default_instance_), +}; + +const char descriptor_table_protodef_plan_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\nplan.proto\022\014io.substrait\032\017relations.pr" + "oto\032\020extensions.proto\"\230\001\n\004Plan\0226\n\nextens" + "ions\030\001 \003(\0132\".io.substrait.Extensions.Ext" + "ension\0222\n\010mappings\030\002 \003(\0132 .io.substrait." + "Extensions.Mapping\022$\n\trelations\030\003 \003(\0132\021." + "io.substrait.RelB\027P\001\252\002\022Substrait.Protobu" + "fb\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_plan_2eproto_deps[2] = { + &::descriptor_table_extensions_2eproto, + &::descriptor_table_relations_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_plan_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_plan_2eproto = { + false, false, 249, descriptor_table_protodef_plan_2eproto, "plan.proto", + &descriptor_table_plan_2eproto_once, descriptor_table_plan_2eproto_deps, 2, 1, + schemas, file_default_instances, TableStruct_plan_2eproto::offsets, + file_level_metadata_plan_2eproto, file_level_enum_descriptors_plan_2eproto, file_level_service_descriptors_plan_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_plan_2eproto_getter() { + return &descriptor_table_plan_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_plan_2eproto(&descriptor_table_plan_2eproto); +namespace io { +namespace substrait { + +// =================================================================== + +class Plan::_Internal { + public: +}; + +void Plan::clear_extensions() { + extensions_.Clear(); +} +void Plan::clear_mappings() { + mappings_.Clear(); +} +void Plan::clear_relations() { + relations_.Clear(); +} +Plan::Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + extensions_(arena), + mappings_(arena), + relations_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Plan) +} +Plan::Plan(const Plan& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + extensions_(from.extensions_), + mappings_(from.mappings_), + relations_(from.relations_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Plan) +} + +void Plan::SharedCtor() { +} + +Plan::~Plan() { + // @@protoc_insertion_point(destructor:io.substrait.Plan) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Plan::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Plan::ArenaDtor(void* object) { + Plan* _this = reinterpret_cast< Plan* >(object); + (void)_this; +} +void Plan::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Plan::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Plan::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Plan) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + extensions_.Clear(); + mappings_.Clear(); + relations_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Extensions.Extension extensions = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_extensions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Extensions.Mapping mappings = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_mappings(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Rel relations = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_relations(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Plan) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Extensions.Extension extensions = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_extensions_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_extensions(i), target, stream); + } + + // repeated .io.substrait.Extensions.Mapping mappings = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_mappings_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_mappings(i), target, stream); + } + + // repeated .io.substrait.Rel relations = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_relations_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_relations(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Plan) + return target; +} + +size_t Plan::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Plan) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Extensions.Extension extensions = 1; + total_size += 1UL * this->_internal_extensions_size(); + for (const auto& msg : this->extensions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .io.substrait.Extensions.Mapping mappings = 2; + total_size += 1UL * this->_internal_mappings_size(); + for (const auto& msg : this->mappings_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .io.substrait.Rel relations = 3; + total_size += 1UL * this->_internal_relations_size(); + for (const auto& msg : this->relations_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Plan::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Plan) + GOOGLE_DCHECK_NE(&from, this); + const Plan* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Plan) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Plan) + MergeFrom(*source); + } +} + +void Plan::MergeFrom(const Plan& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Plan) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + extensions_.MergeFrom(from.extensions_); + mappings_.MergeFrom(from.mappings_); + relations_.MergeFrom(from.relations_); +} + +void Plan::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Plan) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Plan::CopyFrom(const Plan& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Plan) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Plan::IsInitialized() const { + return true; +} + +void Plan::InternalSwap(Plan* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + extensions_.InternalSwap(&other->extensions_); + mappings_.InternalSwap(&other->mappings_); + relations_.InternalSwap(&other->relations_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Plan::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once, + file_level_metadata_plan_2eproto[0]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::Plan* Arena::CreateMaybeMessage< ::io::substrait::Plan >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Plan >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/plan.pb.h b/cpp/src/generated/substrait/plan.pb.h new file mode 100644 index 00000000000..285766c9116 --- /dev/null +++ b/cpp/src/generated/substrait/plan.pb.h @@ -0,0 +1,382 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: plan.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_plan_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_plan_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include "relations.pb.h" +#include "extensions.pb.h" +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_plan_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_plan_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_plan_2eproto; +namespace io { +namespace substrait { +class Plan; +struct PlanDefaultTypeInternal; +extern PlanDefaultTypeInternal _Plan_default_instance_; +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::Plan* Arena::CreateMaybeMessage<::io::substrait::Plan>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace io { +namespace substrait { + +// =================================================================== + +class Plan PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Plan) */ { + public: + inline Plan() : Plan(nullptr) {} + ~Plan() override; + explicit constexpr Plan(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Plan(const Plan& from); + Plan(Plan&& from) noexcept + : Plan() { + *this = ::std::move(from); + } + + inline Plan& operator=(const Plan& from) { + CopyFrom(from); + return *this; + } + inline Plan& operator=(Plan&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Plan& default_instance() { + return *internal_default_instance(); + } + static inline const Plan* internal_default_instance() { + return reinterpret_cast( + &_Plan_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Plan& a, Plan& b) { + a.Swap(&b); + } + inline void Swap(Plan* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Plan* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Plan* New() const final { + return CreateMaybeMessage(nullptr); + } + + Plan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Plan& from); + void MergeFrom(const Plan& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Plan* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Plan"; + } + protected: + explicit Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kExtensionsFieldNumber = 1, + kMappingsFieldNumber = 2, + kRelationsFieldNumber = 3, + }; + // repeated .io.substrait.Extensions.Extension extensions = 1; + int extensions_size() const; + private: + int _internal_extensions_size() const; + public: + void clear_extensions(); + ::io::substrait::Extensions_Extension* mutable_extensions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Extension >* + mutable_extensions(); + private: + const ::io::substrait::Extensions_Extension& _internal_extensions(int index) const; + ::io::substrait::Extensions_Extension* _internal_add_extensions(); + public: + const ::io::substrait::Extensions_Extension& extensions(int index) const; + ::io::substrait::Extensions_Extension* add_extensions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Extension >& + extensions() const; + + // repeated .io.substrait.Extensions.Mapping mappings = 2; + int mappings_size() const; + private: + int _internal_mappings_size() const; + public: + void clear_mappings(); + ::io::substrait::Extensions_Mapping* mutable_mappings(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping >* + mutable_mappings(); + private: + const ::io::substrait::Extensions_Mapping& _internal_mappings(int index) const; + ::io::substrait::Extensions_Mapping* _internal_add_mappings(); + public: + const ::io::substrait::Extensions_Mapping& mappings(int index) const; + ::io::substrait::Extensions_Mapping* add_mappings(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping >& + mappings() const; + + // repeated .io.substrait.Rel relations = 3; + int relations_size() const; + private: + int _internal_relations_size() const; + public: + void clear_relations(); + ::io::substrait::Rel* mutable_relations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* + mutable_relations(); + private: + const ::io::substrait::Rel& _internal_relations(int index) const; + ::io::substrait::Rel* _internal_add_relations(); + public: + const ::io::substrait::Rel& relations(int index) const; + ::io::substrait::Rel* add_relations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& + relations() const; + + // @@protoc_insertion_point(class_scope:io.substrait.Plan) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Extension > extensions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping > mappings_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel > relations_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_plan_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Plan + +// repeated .io.substrait.Extensions.Extension extensions = 1; +inline int Plan::_internal_extensions_size() const { + return extensions_.size(); +} +inline int Plan::extensions_size() const { + return _internal_extensions_size(); +} +inline ::io::substrait::Extensions_Extension* Plan::mutable_extensions(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Plan.extensions) + return extensions_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Extension >* +Plan::mutable_extensions() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.extensions) + return &extensions_; +} +inline const ::io::substrait::Extensions_Extension& Plan::_internal_extensions(int index) const { + return extensions_.Get(index); +} +inline const ::io::substrait::Extensions_Extension& Plan::extensions(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Plan.extensions) + return _internal_extensions(index); +} +inline ::io::substrait::Extensions_Extension* Plan::_internal_add_extensions() { + return extensions_.Add(); +} +inline ::io::substrait::Extensions_Extension* Plan::add_extensions() { + // @@protoc_insertion_point(field_add:io.substrait.Plan.extensions) + return _internal_add_extensions(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Extension >& +Plan::extensions() const { + // @@protoc_insertion_point(field_list:io.substrait.Plan.extensions) + return extensions_; +} + +// repeated .io.substrait.Extensions.Mapping mappings = 2; +inline int Plan::_internal_mappings_size() const { + return mappings_.size(); +} +inline int Plan::mappings_size() const { + return _internal_mappings_size(); +} +inline ::io::substrait::Extensions_Mapping* Plan::mutable_mappings(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Plan.mappings) + return mappings_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping >* +Plan::mutable_mappings() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.mappings) + return &mappings_; +} +inline const ::io::substrait::Extensions_Mapping& Plan::_internal_mappings(int index) const { + return mappings_.Get(index); +} +inline const ::io::substrait::Extensions_Mapping& Plan::mappings(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Plan.mappings) + return _internal_mappings(index); +} +inline ::io::substrait::Extensions_Mapping* Plan::_internal_add_mappings() { + return mappings_.Add(); +} +inline ::io::substrait::Extensions_Mapping* Plan::add_mappings() { + // @@protoc_insertion_point(field_add:io.substrait.Plan.mappings) + return _internal_add_mappings(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping >& +Plan::mappings() const { + // @@protoc_insertion_point(field_list:io.substrait.Plan.mappings) + return mappings_; +} + +// repeated .io.substrait.Rel relations = 3; +inline int Plan::_internal_relations_size() const { + return relations_.size(); +} +inline int Plan::relations_size() const { + return _internal_relations_size(); +} +inline ::io::substrait::Rel* Plan::mutable_relations(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Plan.relations) + return relations_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* +Plan::mutable_relations() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.relations) + return &relations_; +} +inline const ::io::substrait::Rel& Plan::_internal_relations(int index) const { + return relations_.Get(index); +} +inline const ::io::substrait::Rel& Plan::relations(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Plan.relations) + return _internal_relations(index); +} +inline ::io::substrait::Rel* Plan::_internal_add_relations() { + return relations_.Add(); +} +inline ::io::substrait::Rel* Plan::add_relations() { + // @@protoc_insertion_point(field_add:io.substrait.Plan.relations) + return _internal_add_relations(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& +Plan::relations() const { + // @@protoc_insertion_point(field_list:io.substrait.Plan.relations) + return relations_; +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) + +} // namespace substrait +} // namespace io + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_plan_2eproto diff --git a/cpp/src/generated/substrait/relations.pb.cc b/cpp/src/generated/substrait/relations.pb.cc new file mode 100644 index 00000000000..624e490f57c --- /dev/null +++ b/cpp/src/generated/substrait/relations.pb.cc @@ -0,0 +1,7127 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: relations.proto + +#include "relations.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace io { +namespace substrait { +constexpr RelCommon_Direct::RelCommon_Direct( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct RelCommon_DirectDefaultTypeInternal { + constexpr RelCommon_DirectDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~RelCommon_DirectDefaultTypeInternal() {} + union { + RelCommon_Direct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_DirectDefaultTypeInternal _RelCommon_Direct_default_instance_; +constexpr RelCommon_Emit::RelCommon_Emit( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : output_mapping_() + , _output_mapping_cached_byte_size_(){} +struct RelCommon_EmitDefaultTypeInternal { + constexpr RelCommon_EmitDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~RelCommon_EmitDefaultTypeInternal() {} + union { + RelCommon_Emit _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_EmitDefaultTypeInternal _RelCommon_Emit_default_instance_; +constexpr RelCommon_Hint_Stats::RelCommon_Hint_Stats( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : row_count_(0) + , record_size_(0){} +struct RelCommon_Hint_StatsDefaultTypeInternal { + constexpr RelCommon_Hint_StatsDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~RelCommon_Hint_StatsDefaultTypeInternal() {} + union { + RelCommon_Hint_Stats _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_StatsDefaultTypeInternal _RelCommon_Hint_Stats_default_instance_; +constexpr RelCommon_Hint_HintKeyValue::RelCommon_Hint_HintKeyValue( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct RelCommon_Hint_HintKeyValueDefaultTypeInternal { + constexpr RelCommon_Hint_HintKeyValueDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~RelCommon_Hint_HintKeyValueDefaultTypeInternal() {} + union { + RelCommon_Hint_HintKeyValue _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_HintKeyValueDefaultTypeInternal _RelCommon_Hint_HintKeyValue_default_instance_; +constexpr RelCommon_Hint::RelCommon_Hint( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : hint_key_values_() + , stats_(nullptr){} +struct RelCommon_HintDefaultTypeInternal { + constexpr RelCommon_HintDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~RelCommon_HintDefaultTypeInternal() {} + union { + RelCommon_Hint _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_HintDefaultTypeInternal _RelCommon_Hint_default_instance_; +constexpr RelCommon_RuntimeConstraint::RelCommon_RuntimeConstraint( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct RelCommon_RuntimeConstraintDefaultTypeInternal { + constexpr RelCommon_RuntimeConstraintDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~RelCommon_RuntimeConstraintDefaultTypeInternal() {} + union { + RelCommon_RuntimeConstraint _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_RuntimeConstraintDefaultTypeInternal _RelCommon_RuntimeConstraint_default_instance_; +constexpr RelCommon::RelCommon( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : hint_(nullptr) + , constraint_(nullptr) + , _oneof_case_{}{} +struct RelCommonDefaultTypeInternal { + constexpr RelCommonDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~RelCommonDefaultTypeInternal() {} + union { + RelCommon _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommonDefaultTypeInternal _RelCommon_default_instance_; +constexpr ReadRel_NamedTable::ReadRel_NamedTable( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : names_(){} +struct ReadRel_NamedTableDefaultTypeInternal { + constexpr ReadRel_NamedTableDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReadRel_NamedTableDefaultTypeInternal() {} + union { + ReadRel_NamedTable _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_NamedTableDefaultTypeInternal _ReadRel_NamedTable_default_instance_; +constexpr ReadRel_VirtualTable::ReadRel_VirtualTable( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : values_(){} +struct ReadRel_VirtualTableDefaultTypeInternal { + constexpr ReadRel_VirtualTableDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReadRel_VirtualTableDefaultTypeInternal() {} + union { + ReadRel_VirtualTable _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_VirtualTableDefaultTypeInternal _ReadRel_VirtualTable_default_instance_; +constexpr ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : format_(0) + + , _oneof_case_{}{} +struct ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal { + constexpr ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal() {} + union { + ReadRel_LocalFiles_FileOrFiles _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal _ReadRel_LocalFiles_FileOrFiles_default_instance_; +constexpr ReadRel_LocalFiles::ReadRel_LocalFiles( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : items_(){} +struct ReadRel_LocalFilesDefaultTypeInternal { + constexpr ReadRel_LocalFilesDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReadRel_LocalFilesDefaultTypeInternal() {} + union { + ReadRel_LocalFiles _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_LocalFilesDefaultTypeInternal _ReadRel_LocalFiles_default_instance_; +constexpr ReadRel::ReadRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : common_(nullptr) + , base_schema_(nullptr) + , filter_(nullptr) + , projection_(nullptr) + , _oneof_case_{}{} +struct ReadRelDefaultTypeInternal { + constexpr ReadRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReadRelDefaultTypeInternal() {} + union { + ReadRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRelDefaultTypeInternal _ReadRel_default_instance_; +constexpr ProjectRel::ProjectRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : expressions_() + , common_(nullptr) + , input_(nullptr){} +struct ProjectRelDefaultTypeInternal { + constexpr ProjectRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ProjectRelDefaultTypeInternal() {} + union { + ProjectRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ProjectRelDefaultTypeInternal _ProjectRel_default_instance_; +constexpr JoinRel::JoinRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : common_(nullptr) + , left_(nullptr) + , right_(nullptr) + , expression_(nullptr) + , post_join_filter_(nullptr) + , type_(0) +{} +struct JoinRelDefaultTypeInternal { + constexpr JoinRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~JoinRelDefaultTypeInternal() {} + union { + JoinRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT JoinRelDefaultTypeInternal _JoinRel_default_instance_; +constexpr FetchRel::FetchRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : common_(nullptr) + , input_(nullptr) + , offset_(PROTOBUF_LONGLONG(0)) + , count_(PROTOBUF_LONGLONG(0)){} +struct FetchRelDefaultTypeInternal { + constexpr FetchRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FetchRelDefaultTypeInternal() {} + union { + FetchRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FetchRelDefaultTypeInternal _FetchRel_default_instance_; +constexpr AggregateRel_Grouping::AggregateRel_Grouping( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : input_fields_() + , _input_fields_cached_byte_size_(){} +struct AggregateRel_GroupingDefaultTypeInternal { + constexpr AggregateRel_GroupingDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AggregateRel_GroupingDefaultTypeInternal() {} + union { + AggregateRel_Grouping _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRel_GroupingDefaultTypeInternal _AggregateRel_Grouping_default_instance_; +constexpr AggregateRel_Measure::AggregateRel_Measure( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : measure_(nullptr){} +struct AggregateRel_MeasureDefaultTypeInternal { + constexpr AggregateRel_MeasureDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AggregateRel_MeasureDefaultTypeInternal() {} + union { + AggregateRel_Measure _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRel_MeasureDefaultTypeInternal _AggregateRel_Measure_default_instance_; +constexpr AggregateRel::AggregateRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : groupings_() + , measures_() + , common_(nullptr) + , input_(nullptr) + , phase_(0) +{} +struct AggregateRelDefaultTypeInternal { + constexpr AggregateRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AggregateRelDefaultTypeInternal() {} + union { + AggregateRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRelDefaultTypeInternal _AggregateRel_default_instance_; +constexpr SortRel::SortRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : sorts_() + , common_(nullptr) + , input_(nullptr){} +struct SortRelDefaultTypeInternal { + constexpr SortRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SortRelDefaultTypeInternal() {} + union { + SortRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SortRelDefaultTypeInternal _SortRel_default_instance_; +constexpr FilterRel::FilterRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : common_(nullptr) + , input_(nullptr) + , condition_(nullptr){} +struct FilterRelDefaultTypeInternal { + constexpr FilterRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FilterRelDefaultTypeInternal() {} + union { + FilterRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FilterRelDefaultTypeInternal _FilterRel_default_instance_; +constexpr SetRel::SetRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : inputs_() + , common_(nullptr) + , op_(0) +{} +struct SetRelDefaultTypeInternal { + constexpr SetRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SetRelDefaultTypeInternal() {} + union { + SetRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SetRelDefaultTypeInternal _SetRel_default_instance_; +constexpr Rel::Rel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct RelDefaultTypeInternal { + constexpr RelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~RelDefaultTypeInternal() {} + union { + Rel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelDefaultTypeInternal _Rel_default_instance_; +} // namespace substrait +} // namespace io +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_relations_2eproto[22]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_relations_2eproto[3]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_relations_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Direct, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Emit, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Emit, output_mapping_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_Stats, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_Stats, row_count_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_Stats, record_size_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_HintKeyValue, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_HintKeyValue, key_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_HintKeyValue, value_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, hint_key_values_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, stats_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_RuntimeConstraint, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, hint_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, constraint_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, kind_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_NamedTable, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_NamedTable, names_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_VirtualTable, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_VirtualTable, values_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, format_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, path_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles, items_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, base_schema_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, filter_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, projection_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, read_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, input_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, expressions_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, left_), + PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, right_), + PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, expression_), + PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, post_join_filter_), + PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, input_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, offset_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, count_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Grouping, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Grouping, input_fields_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Measure, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Measure, measure_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, input_), + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, groupings_), + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, measures_), + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, phase_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, input_), + PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, sorts_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, input_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, condition_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, inputs_), + PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, op_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Rel, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Rel, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Rel, RelType_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::io::substrait::RelCommon_Direct)}, + { 5, -1, sizeof(::io::substrait::RelCommon_Emit)}, + { 11, -1, sizeof(::io::substrait::RelCommon_Hint_Stats)}, + { 18, -1, sizeof(::io::substrait::RelCommon_Hint_HintKeyValue)}, + { 25, -1, sizeof(::io::substrait::RelCommon_Hint)}, + { 32, -1, sizeof(::io::substrait::RelCommon_RuntimeConstraint)}, + { 37, -1, sizeof(::io::substrait::RelCommon)}, + { 47, -1, sizeof(::io::substrait::ReadRel_NamedTable)}, + { 53, -1, sizeof(::io::substrait::ReadRel_VirtualTable)}, + { 59, -1, sizeof(::io::substrait::ReadRel_LocalFiles_FileOrFiles)}, + { 68, -1, sizeof(::io::substrait::ReadRel_LocalFiles)}, + { 74, -1, sizeof(::io::substrait::ReadRel)}, + { 87, -1, sizeof(::io::substrait::ProjectRel)}, + { 95, -1, sizeof(::io::substrait::JoinRel)}, + { 106, -1, sizeof(::io::substrait::FetchRel)}, + { 115, -1, sizeof(::io::substrait::AggregateRel_Grouping)}, + { 121, -1, sizeof(::io::substrait::AggregateRel_Measure)}, + { 127, -1, sizeof(::io::substrait::AggregateRel)}, + { 137, -1, sizeof(::io::substrait::SortRel)}, + { 145, -1, sizeof(::io::substrait::FilterRel)}, + { 153, -1, sizeof(::io::substrait::SetRel)}, + { 161, -1, sizeof(::io::substrait::Rel)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_RelCommon_Direct_default_instance_), + reinterpret_cast(&::io::substrait::_RelCommon_Emit_default_instance_), + reinterpret_cast(&::io::substrait::_RelCommon_Hint_Stats_default_instance_), + reinterpret_cast(&::io::substrait::_RelCommon_Hint_HintKeyValue_default_instance_), + reinterpret_cast(&::io::substrait::_RelCommon_Hint_default_instance_), + reinterpret_cast(&::io::substrait::_RelCommon_RuntimeConstraint_default_instance_), + reinterpret_cast(&::io::substrait::_RelCommon_default_instance_), + reinterpret_cast(&::io::substrait::_ReadRel_NamedTable_default_instance_), + reinterpret_cast(&::io::substrait::_ReadRel_VirtualTable_default_instance_), + reinterpret_cast(&::io::substrait::_ReadRel_LocalFiles_FileOrFiles_default_instance_), + reinterpret_cast(&::io::substrait::_ReadRel_LocalFiles_default_instance_), + reinterpret_cast(&::io::substrait::_ReadRel_default_instance_), + reinterpret_cast(&::io::substrait::_ProjectRel_default_instance_), + reinterpret_cast(&::io::substrait::_JoinRel_default_instance_), + reinterpret_cast(&::io::substrait::_FetchRel_default_instance_), + reinterpret_cast(&::io::substrait::_AggregateRel_Grouping_default_instance_), + reinterpret_cast(&::io::substrait::_AggregateRel_Measure_default_instance_), + reinterpret_cast(&::io::substrait::_AggregateRel_default_instance_), + reinterpret_cast(&::io::substrait::_SortRel_default_instance_), + reinterpret_cast(&::io::substrait::_FilterRel_default_instance_), + reinterpret_cast(&::io::substrait::_SetRel_default_instance_), + reinterpret_cast(&::io::substrait::_Rel_default_instance_), +}; + +const char descriptor_table_protodef_relations_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\017relations.proto\022\014io.substrait\032\ntype.pr" + "oto\032\020expression.proto\032\017selection.proto\"\372" + "\003\n\tRelCommon\0220\n\006direct\030\001 \001(\0132\036.io.substr" + "ait.RelCommon.DirectH\000\022,\n\004emit\030\002 \001(\0132\034.i" + "o.substrait.RelCommon.EmitH\000\022*\n\004hint\030\003 \001" + "(\0132\034.io.substrait.RelCommon.Hint\022=\n\ncons" + "traint\030\004 \001(\0132).io.substrait.RelCommon.Ru" + "ntimeConstraint\032\010\n\006Direct\032\036\n\004Emit\022\026\n\016out" + "put_mapping\030\001 \003(\005\032\332\001\n\004Hint\022B\n\017hint_key_v" + "alues\030\001 \003(\0132).io.substrait.RelCommon.Hin" + "t.HintKeyValue\0221\n\005stats\030\002 \001(\0132\".io.subst" + "rait.RelCommon.Hint.Stats\032/\n\005Stats\022\021\n\tro" + "w_count\030\001 \001(\001\022\023\n\013record_size\030\002 \001(\001\032*\n\014Hi" + "ntKeyValue\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\014\032\023" + "\n\021RuntimeConstraintB\006\n\004kind\"\344\005\n\007ReadRel\022" + "\'\n\006common\030\001 \001(\0132\027.io.substrait.RelCommon" + "\0223\n\013base_schema\030\002 \001(\0132\036.io.substrait.Typ" + "e.NamedStruct\022(\n\006filter\030\003 \001(\0132\030.io.subst" + "rait.Expression\0220\n\nprojection\030\004 \001(\0132\034.io" + ".substrait.MaskExpression\022;\n\rvirtual_tab" + "le\030\005 \001(\0132\".io.substrait.ReadRel.VirtualT" + "ableH\000\0227\n\013local_files\030\006 \001(\0132 .io.substra" + "it.ReadRel.LocalFilesH\000\0227\n\013named_table\030\007" + " \001(\0132 .io.substrait.ReadRel.NamedTableH\000" + "\032\033\n\nNamedTable\022\r\n\005names\030\001 \003(\t\032G\n\014Virtual" + "Table\0227\n\006values\030\001 \003(\0132\'.io.substrait.Exp" + "ression.Literal.Struct\032\374\001\n\nLocalFiles\022;\n" + "\005items\030\001 \003(\0132,.io.substrait.ReadRel.Loca" + "lFiles.FileOrFiles\032\260\001\n\013FileOrFiles\022\022\n\010ur" + "i_path\030\001 \001(\tH\000\022\027\n\ruri_path_glob\030\002 \001(\tH\000\022" + "C\n\006format\030\003 \001(\01623.io.substrait.ReadRel.L" + "ocalFiles.FileOrFiles.Format\"\"\n\006Format\022\013" + "\n\007UNKNOWN\020\000\022\013\n\007PARQUET\020\001B\013\n\tpath_typeB\013\n" + "\tread_type\"\206\001\n\nProjectRel\022\'\n\006common\030\001 \001(" + "\0132\027.io.substrait.RelCommon\022 \n\005input\030\002 \001(" + "\0132\021.io.substrait.Rel\022-\n\013expressions\030\003 \003(" + "\0132\030.io.substrait.Expression\"\311\002\n\007JoinRel\022" + "\'\n\006common\030\001 \001(\0132\027.io.substrait.RelCommon" + "\022\037\n\004left\030\002 \001(\0132\021.io.substrait.Rel\022 \n\005rig" + "ht\030\003 \001(\0132\021.io.substrait.Rel\022,\n\nexpressio" + "n\030\004 \001(\0132\030.io.substrait.Expression\0222\n\020pos" + "t_join_filter\030\005 \001(\0132\030.io.substrait.Expre" + "ssion\022,\n\004type\030\006 \001(\0162\036.io.substrait.JoinR" + "el.JoinType\"B\n\010JoinType\022\013\n\007UNKNOWN\020\000\022\t\n\005" + "INNER\020\001\022\t\n\005OUTER\020\002\022\010\n\004LEFT\020\003\022\t\n\005RIGHT\020\004\"" + "t\n\010FetchRel\022\'\n\006common\030\001 \001(\0132\027.io.substra" + "it.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.substra" + "it.Rel\022\016\n\006offset\030\003 \001(\003\022\r\n\005count\030\004 \001(\003\"\353\002" + "\n\014AggregateRel\022\'\n\006common\030\001 \001(\0132\027.io.subs" + "trait.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.subs" + "trait.Rel\0226\n\tgroupings\030\003 \003(\0132#.io.substr" + "ait.AggregateRel.Grouping\0224\n\010measures\030\004 " + "\003(\0132\".io.substrait.AggregateRel.Measure\022" + "8\n\005phase\030\005 \001(\0162).io.substrait.Expression" + ".AggregationPhase\032 \n\010Grouping\022\024\n\014input_f" + "ields\030\001 \003(\005\032F\n\007Measure\022;\n\007measure\030\001 \001(\0132" + "*.io.substrait.Expression.AggregateFunct" + "ion\"\207\001\n\007SortRel\022\'\n\006common\030\001 \001(\0132\027.io.sub" + "strait.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.sub" + "strait.Rel\0221\n\005sorts\030\003 \003(\0132\".io.substrait" + ".Expression.SortField\"\203\001\n\tFilterRel\022\'\n\006c" + "ommon\030\001 \001(\0132\027.io.substrait.RelCommon\022 \n\005" + "input\030\002 \001(\0132\021.io.substrait.Rel\022+\n\tcondit" + "ion\030\003 \001(\0132\030.io.substrait.Expression\"\222\002\n\006" + "SetRel\022\'\n\006common\030\001 \001(\0132\027.io.substrait.Re" + "lCommon\022!\n\006inputs\030\002 \003(\0132\021.io.substrait.R" + "el\022&\n\002op\030\003 \001(\0162\032.io.substrait.SetRel.Set" + "Op\"\223\001\n\005SetOp\022\013\n\007UNKNOWN\020\000\022\021\n\rMINUS_PRIMA" + "RY\020\001\022\022\n\016MINUS_MULTISET\020\002\022\030\n\024INTERSECTION" + "_PRIMARY\020\003\022\031\n\025INTERSECTION_MULTISET\020\004\022\022\n" + "\016UNION_DISTINCT\020\005\022\r\n\tUNION_ALL\020\006\"\334\002\n\003Rel" + "\022%\n\004read\030\001 \001(\0132\025.io.substrait.ReadRelH\000\022" + ")\n\006filter\030\002 \001(\0132\027.io.substrait.FilterRel" + "H\000\022\'\n\005fetch\030\003 \001(\0132\026.io.substrait.FetchRe" + "lH\000\022/\n\taggregate\030\004 \001(\0132\032.io.substrait.Ag" + "gregateRelH\000\022%\n\004sort\030\005 \001(\0132\025.io.substrai" + "t.SortRelH\000\022%\n\004join\030\006 \001(\0132\025.io.substrait" + ".JoinRelH\000\022+\n\007project\030\007 \001(\0132\030.io.substra" + "it.ProjectRelH\000\022#\n\003set\030\010 \001(\0132\024.io.substr" + "ait.SetRelH\000B\t\n\007RelTypeB\027P\001\252\002\022Substrait." + "Protobufb\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_relations_2eproto_deps[3] = { + &::descriptor_table_expression_2eproto, + &::descriptor_table_selection_2eproto, + &::descriptor_table_type_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_relations_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_relations_2eproto = { + false, false, 3216, descriptor_table_protodef_relations_2eproto, "relations.proto", + &descriptor_table_relations_2eproto_once, descriptor_table_relations_2eproto_deps, 3, 22, + schemas, file_default_instances, TableStruct_relations_2eproto::offsets, + file_level_metadata_relations_2eproto, file_level_enum_descriptors_relations_2eproto, file_level_service_descriptors_relations_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_relations_2eproto_getter() { + return &descriptor_table_relations_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_relations_2eproto(&descriptor_table_relations_2eproto); +namespace io { +namespace substrait { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_Format_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_relations_2eproto); + return file_level_enum_descriptors_relations_2eproto[0]; +} +bool ReadRel_LocalFiles_FileOrFiles_Format_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::UNKNOWN; +constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::PARQUET; +constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::Format_MIN; +constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::Format_MAX; +constexpr int ReadRel_LocalFiles_FileOrFiles::Format_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_relations_2eproto); + return file_level_enum_descriptors_relations_2eproto[1]; +} +bool JoinRel_JoinType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr JoinRel_JoinType JoinRel::UNKNOWN; +constexpr JoinRel_JoinType JoinRel::INNER; +constexpr JoinRel_JoinType JoinRel::OUTER; +constexpr JoinRel_JoinType JoinRel::LEFT; +constexpr JoinRel_JoinType JoinRel::RIGHT; +constexpr JoinRel_JoinType JoinRel::JoinType_MIN; +constexpr JoinRel_JoinType JoinRel::JoinType_MAX; +constexpr int JoinRel::JoinType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetRel_SetOp_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_relations_2eproto); + return file_level_enum_descriptors_relations_2eproto[2]; +} +bool SetRel_SetOp_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr SetRel_SetOp SetRel::UNKNOWN; +constexpr SetRel_SetOp SetRel::MINUS_PRIMARY; +constexpr SetRel_SetOp SetRel::MINUS_MULTISET; +constexpr SetRel_SetOp SetRel::INTERSECTION_PRIMARY; +constexpr SetRel_SetOp SetRel::INTERSECTION_MULTISET; +constexpr SetRel_SetOp SetRel::UNION_DISTINCT; +constexpr SetRel_SetOp SetRel::UNION_ALL; +constexpr SetRel_SetOp SetRel::SetOp_MIN; +constexpr SetRel_SetOp SetRel::SetOp_MAX; +constexpr int SetRel::SetOp_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) + +// =================================================================== + +class RelCommon_Direct::_Internal { + public: +}; + +RelCommon_Direct::RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Direct) +} +RelCommon_Direct::RelCommon_Direct(const RelCommon_Direct& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Direct) +} + +void RelCommon_Direct::SharedCtor() { +} + +RelCommon_Direct::~RelCommon_Direct() { + // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Direct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void RelCommon_Direct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void RelCommon_Direct::ArenaDtor(void* object) { + RelCommon_Direct* _this = reinterpret_cast< RelCommon_Direct* >(object); + (void)_this; +} +void RelCommon_Direct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void RelCommon_Direct::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void RelCommon_Direct::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Direct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RelCommon_Direct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Direct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Direct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Direct) + return target; +} + +size_t RelCommon_Direct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Direct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RelCommon_Direct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Direct) + GOOGLE_DCHECK_NE(&from, this); + const RelCommon_Direct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Direct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Direct) + MergeFrom(*source); + } +} + +void RelCommon_Direct::MergeFrom(const RelCommon_Direct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Direct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +void RelCommon_Direct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Direct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RelCommon_Direct::CopyFrom(const RelCommon_Direct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Direct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RelCommon_Direct::IsInitialized() const { + return true; +} + +void RelCommon_Direct::InternalSwap(RelCommon_Direct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Direct::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[0]); +} + +// =================================================================== + +class RelCommon_Emit::_Internal { + public: +}; + +RelCommon_Emit::RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + output_mapping_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Emit) +} +RelCommon_Emit::RelCommon_Emit(const RelCommon_Emit& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + output_mapping_(from.output_mapping_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Emit) +} + +void RelCommon_Emit::SharedCtor() { +} + +RelCommon_Emit::~RelCommon_Emit() { + // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Emit) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void RelCommon_Emit::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void RelCommon_Emit::ArenaDtor(void* object) { + RelCommon_Emit* _this = reinterpret_cast< RelCommon_Emit* >(object); + (void)_this; +} +void RelCommon_Emit::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void RelCommon_Emit::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void RelCommon_Emit::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Emit) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + output_mapping_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RelCommon_Emit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated int32 output_mapping = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_output_mapping(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8) { + _internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Emit::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Emit) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int32 output_mapping = 1; + { + int byte_size = _output_mapping_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 1, _internal_output_mapping(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Emit) + return target; +} + +size_t RelCommon_Emit::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Emit) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int32 output_mapping = 1; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->output_mapping_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _output_mapping_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RelCommon_Emit::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Emit) + GOOGLE_DCHECK_NE(&from, this); + const RelCommon_Emit* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Emit) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Emit) + MergeFrom(*source); + } +} + +void RelCommon_Emit::MergeFrom(const RelCommon_Emit& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Emit) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + output_mapping_.MergeFrom(from.output_mapping_); +} + +void RelCommon_Emit::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Emit) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RelCommon_Emit::CopyFrom(const RelCommon_Emit& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Emit) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RelCommon_Emit::IsInitialized() const { + return true; +} + +void RelCommon_Emit::InternalSwap(RelCommon_Emit* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + output_mapping_.InternalSwap(&other->output_mapping_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Emit::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[1]); +} + +// =================================================================== + +class RelCommon_Hint_Stats::_Internal { + public: +}; + +RelCommon_Hint_Stats::RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Hint.Stats) +} +RelCommon_Hint_Stats::RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&row_count_, &from.row_count_, + static_cast(reinterpret_cast(&record_size_) - + reinterpret_cast(&row_count_)) + sizeof(record_size_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Hint.Stats) +} + +void RelCommon_Hint_Stats::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&row_count_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&record_size_) - + reinterpret_cast(&row_count_)) + sizeof(record_size_)); +} + +RelCommon_Hint_Stats::~RelCommon_Hint_Stats() { + // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Hint.Stats) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void RelCommon_Hint_Stats::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void RelCommon_Hint_Stats::ArenaDtor(void* object) { + RelCommon_Hint_Stats* _this = reinterpret_cast< RelCommon_Hint_Stats* >(object); + (void)_this; +} +void RelCommon_Hint_Stats::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void RelCommon_Hint_Stats::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void RelCommon_Hint_Stats::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Hint.Stats) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&row_count_, 0, static_cast( + reinterpret_cast(&record_size_) - + reinterpret_cast(&row_count_)) + sizeof(record_size_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RelCommon_Hint_Stats::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // double row_count = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) { + row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + // double record_size = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) { + record_size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_Stats::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Hint.Stats) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // double row_count = 1; + if (!(this->row_count() <= 0 && this->row_count() >= 0)) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_row_count(), target); + } + + // double record_size = 2; + if (!(this->record_size() <= 0 && this->record_size() >= 0)) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_record_size(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Hint.Stats) + return target; +} + +size_t RelCommon_Hint_Stats::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Hint.Stats) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // double row_count = 1; + if (!(this->row_count() <= 0 && this->row_count() >= 0)) { + total_size += 1 + 8; + } + + // double record_size = 2; + if (!(this->record_size() <= 0 && this->record_size() >= 0)) { + total_size += 1 + 8; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RelCommon_Hint_Stats::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Hint.Stats) + GOOGLE_DCHECK_NE(&from, this); + const RelCommon_Hint_Stats* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Hint.Stats) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Hint.Stats) + MergeFrom(*source); + } +} + +void RelCommon_Hint_Stats::MergeFrom(const RelCommon_Hint_Stats& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Hint.Stats) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (!(from.row_count() <= 0 && from.row_count() >= 0)) { + _internal_set_row_count(from._internal_row_count()); + } + if (!(from.record_size() <= 0 && from.record_size() >= 0)) { + _internal_set_record_size(from._internal_record_size()); + } +} + +void RelCommon_Hint_Stats::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Hint.Stats) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RelCommon_Hint_Stats::CopyFrom(const RelCommon_Hint_Stats& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Hint.Stats) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RelCommon_Hint_Stats::IsInitialized() const { + return true; +} + +void RelCommon_Hint_Stats::InternalSwap(RelCommon_Hint_Stats* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(RelCommon_Hint_Stats, record_size_) + + sizeof(RelCommon_Hint_Stats::record_size_) + - PROTOBUF_FIELD_OFFSET(RelCommon_Hint_Stats, row_count_)>( + reinterpret_cast(&row_count_), + reinterpret_cast(&other->row_count_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_Stats::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[2]); +} + +// =================================================================== + +class RelCommon_Hint_HintKeyValue::_Internal { + public: +}; + +RelCommon_Hint_HintKeyValue::RelCommon_Hint_HintKeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Hint.HintKeyValue) +} +RelCommon_Hint_HintKeyValue::RelCommon_Hint_HintKeyValue(const RelCommon_Hint_HintKeyValue& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_key().empty()) { + key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_key(), + GetArena()); + } + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_value().empty()) { + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Hint.HintKeyValue) +} + +void RelCommon_Hint_HintKeyValue::SharedCtor() { +key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +RelCommon_Hint_HintKeyValue::~RelCommon_Hint_HintKeyValue() { + // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Hint.HintKeyValue) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void RelCommon_Hint_HintKeyValue::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void RelCommon_Hint_HintKeyValue::ArenaDtor(void* object) { + RelCommon_Hint_HintKeyValue* _this = reinterpret_cast< RelCommon_Hint_HintKeyValue* >(object); + (void)_this; +} +void RelCommon_Hint_HintKeyValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void RelCommon_Hint_HintKeyValue::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void RelCommon_Hint_HintKeyValue::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Hint.HintKeyValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + key_.ClearToEmpty(); + value_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RelCommon_Hint_HintKeyValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_key(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.RelCommon.Hint.HintKeyValue.key")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_value(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_HintKeyValue::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Hint.HintKeyValue) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string key = 1; + if (this->key().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_key().data(), static_cast(this->_internal_key().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.RelCommon.Hint.HintKeyValue.key"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_key(), target); + } + + // bytes value = 2; + if (this->value().size() > 0) { + target = stream->WriteBytesMaybeAliased( + 2, this->_internal_value(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Hint.HintKeyValue) + return target; +} + +size_t RelCommon_Hint_HintKeyValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Hint.HintKeyValue) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string key = 1; + if (this->key().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_key()); + } + + // bytes value = 2; + if (this->value().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_value()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RelCommon_Hint_HintKeyValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Hint.HintKeyValue) + GOOGLE_DCHECK_NE(&from, this); + const RelCommon_Hint_HintKeyValue* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Hint.HintKeyValue) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Hint.HintKeyValue) + MergeFrom(*source); + } +} + +void RelCommon_Hint_HintKeyValue::MergeFrom(const RelCommon_Hint_HintKeyValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Hint.HintKeyValue) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.key().size() > 0) { + _internal_set_key(from._internal_key()); + } + if (from.value().size() > 0) { + _internal_set_value(from._internal_value()); + } +} + +void RelCommon_Hint_HintKeyValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Hint.HintKeyValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RelCommon_Hint_HintKeyValue::CopyFrom(const RelCommon_Hint_HintKeyValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Hint.HintKeyValue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RelCommon_Hint_HintKeyValue::IsInitialized() const { + return true; +} + +void RelCommon_Hint_HintKeyValue::InternalSwap(RelCommon_Hint_HintKeyValue* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_HintKeyValue::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[3]); +} + +// =================================================================== + +class RelCommon_Hint::_Internal { + public: + static const ::io::substrait::RelCommon_Hint_Stats& stats(const RelCommon_Hint* msg); +}; + +const ::io::substrait::RelCommon_Hint_Stats& +RelCommon_Hint::_Internal::stats(const RelCommon_Hint* msg) { + return *msg->stats_; +} +RelCommon_Hint::RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + hint_key_values_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Hint) +} +RelCommon_Hint::RelCommon_Hint(const RelCommon_Hint& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + hint_key_values_(from.hint_key_values_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_stats()) { + stats_ = new ::io::substrait::RelCommon_Hint_Stats(*from.stats_); + } else { + stats_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Hint) +} + +void RelCommon_Hint::SharedCtor() { +stats_ = nullptr; +} + +RelCommon_Hint::~RelCommon_Hint() { + // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Hint) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void RelCommon_Hint::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete stats_; +} + +void RelCommon_Hint::ArenaDtor(void* object) { + RelCommon_Hint* _this = reinterpret_cast< RelCommon_Hint* >(object); + (void)_this; +} +void RelCommon_Hint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void RelCommon_Hint::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void RelCommon_Hint::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Hint) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + hint_key_values_.Clear(); + if (GetArena() == nullptr && stats_ != nullptr) { + delete stats_; + } + stats_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RelCommon_Hint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.RelCommon.Hint.HintKeyValue hint_key_values = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_hint_key_values(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.RelCommon.Hint.Stats stats = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_stats(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Hint) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.RelCommon.Hint.HintKeyValue hint_key_values = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_hint_key_values_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_hint_key_values(i), target, stream); + } + + // .io.substrait.RelCommon.Hint.Stats stats = 2; + if (this->has_stats()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::stats(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Hint) + return target; +} + +size_t RelCommon_Hint::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Hint) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.RelCommon.Hint.HintKeyValue hint_key_values = 1; + total_size += 1UL * this->_internal_hint_key_values_size(); + for (const auto& msg : this->hint_key_values_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.RelCommon.Hint.Stats stats = 2; + if (this->has_stats()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *stats_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RelCommon_Hint::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Hint) + GOOGLE_DCHECK_NE(&from, this); + const RelCommon_Hint* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Hint) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Hint) + MergeFrom(*source); + } +} + +void RelCommon_Hint::MergeFrom(const RelCommon_Hint& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Hint) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + hint_key_values_.MergeFrom(from.hint_key_values_); + if (from.has_stats()) { + _internal_mutable_stats()->::io::substrait::RelCommon_Hint_Stats::MergeFrom(from._internal_stats()); + } +} + +void RelCommon_Hint::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Hint) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RelCommon_Hint::CopyFrom(const RelCommon_Hint& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Hint) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RelCommon_Hint::IsInitialized() const { + return true; +} + +void RelCommon_Hint::InternalSwap(RelCommon_Hint* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + hint_key_values_.InternalSwap(&other->hint_key_values_); + swap(stats_, other->stats_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[4]); +} + +// =================================================================== + +class RelCommon_RuntimeConstraint::_Internal { + public: +}; + +RelCommon_RuntimeConstraint::RelCommon_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.RuntimeConstraint) +} +RelCommon_RuntimeConstraint::RelCommon_RuntimeConstraint(const RelCommon_RuntimeConstraint& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.RuntimeConstraint) +} + +void RelCommon_RuntimeConstraint::SharedCtor() { +} + +RelCommon_RuntimeConstraint::~RelCommon_RuntimeConstraint() { + // @@protoc_insertion_point(destructor:io.substrait.RelCommon.RuntimeConstraint) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void RelCommon_RuntimeConstraint::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void RelCommon_RuntimeConstraint::ArenaDtor(void* object) { + RelCommon_RuntimeConstraint* _this = reinterpret_cast< RelCommon_RuntimeConstraint* >(object); + (void)_this; +} +void RelCommon_RuntimeConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void RelCommon_RuntimeConstraint::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void RelCommon_RuntimeConstraint::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.RuntimeConstraint) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RelCommon_RuntimeConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_RuntimeConstraint::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.RuntimeConstraint) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.RuntimeConstraint) + return target; +} + +size_t RelCommon_RuntimeConstraint::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.RuntimeConstraint) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RelCommon_RuntimeConstraint::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.RuntimeConstraint) + GOOGLE_DCHECK_NE(&from, this); + const RelCommon_RuntimeConstraint* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.RuntimeConstraint) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.RuntimeConstraint) + MergeFrom(*source); + } +} + +void RelCommon_RuntimeConstraint::MergeFrom(const RelCommon_RuntimeConstraint& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.RuntimeConstraint) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +void RelCommon_RuntimeConstraint::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.RuntimeConstraint) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RelCommon_RuntimeConstraint::CopyFrom(const RelCommon_RuntimeConstraint& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.RuntimeConstraint) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RelCommon_RuntimeConstraint::IsInitialized() const { + return true; +} + +void RelCommon_RuntimeConstraint::InternalSwap(RelCommon_RuntimeConstraint* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_RuntimeConstraint::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[5]); +} + +// =================================================================== + +class RelCommon::_Internal { + public: + static const ::io::substrait::RelCommon_Direct& direct(const RelCommon* msg); + static const ::io::substrait::RelCommon_Emit& emit(const RelCommon* msg); + static const ::io::substrait::RelCommon_Hint& hint(const RelCommon* msg); + static const ::io::substrait::RelCommon_RuntimeConstraint& constraint(const RelCommon* msg); +}; + +const ::io::substrait::RelCommon_Direct& +RelCommon::_Internal::direct(const RelCommon* msg) { + return *msg->kind_.direct_; +} +const ::io::substrait::RelCommon_Emit& +RelCommon::_Internal::emit(const RelCommon* msg) { + return *msg->kind_.emit_; +} +const ::io::substrait::RelCommon_Hint& +RelCommon::_Internal::hint(const RelCommon* msg) { + return *msg->hint_; +} +const ::io::substrait::RelCommon_RuntimeConstraint& +RelCommon::_Internal::constraint(const RelCommon* msg) { + return *msg->constraint_; +} +void RelCommon::set_allocated_direct(::io::substrait::RelCommon_Direct* direct) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (direct) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(direct); + if (message_arena != submessage_arena) { + direct = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, direct, submessage_arena); + } + set_has_direct(); + kind_.direct_ = direct; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.direct) +} +void RelCommon::set_allocated_emit(::io::substrait::RelCommon_Emit* emit) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (emit) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(emit); + if (message_arena != submessage_arena) { + emit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, emit, submessage_arena); + } + set_has_emit(); + kind_.emit_ = emit; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.emit) +} +RelCommon::RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon) +} +RelCommon::RelCommon(const RelCommon& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_hint()) { + hint_ = new ::io::substrait::RelCommon_Hint(*from.hint_); + } else { + hint_ = nullptr; + } + if (from._internal_has_constraint()) { + constraint_ = new ::io::substrait::RelCommon_RuntimeConstraint(*from.constraint_); + } else { + constraint_ = nullptr; + } + clear_has_kind(); + switch (from.kind_case()) { + case kDirect: { + _internal_mutable_direct()->::io::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); + break; + } + case kEmit: { + _internal_mutable_emit()->::io::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); + break; + } + case KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon) +} + +void RelCommon::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&hint_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&constraint_) - + reinterpret_cast(&hint_)) + sizeof(constraint_)); +clear_has_kind(); +} + +RelCommon::~RelCommon() { + // @@protoc_insertion_point(destructor:io.substrait.RelCommon) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void RelCommon::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete hint_; + if (this != internal_default_instance()) delete constraint_; + if (has_kind()) { + clear_kind(); + } +} + +void RelCommon::ArenaDtor(void* object) { + RelCommon* _this = reinterpret_cast< RelCommon* >(object); + (void)_this; +} +void RelCommon::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void RelCommon::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void RelCommon::clear_kind() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.RelCommon) + switch (kind_case()) { + case kDirect: { + if (GetArena() == nullptr) { + delete kind_.direct_; + } + break; + } + case kEmit: { + if (GetArena() == nullptr) { + delete kind_.emit_; + } + break; + } + case KIND_NOT_SET: { + break; + } + } + _oneof_case_[0] = KIND_NOT_SET; +} + + +void RelCommon::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && hint_ != nullptr) { + delete hint_; + } + hint_ = nullptr; + if (GetArena() == nullptr && constraint_ != nullptr) { + delete constraint_; + } + constraint_ = nullptr; + clear_kind(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* RelCommon::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon.Direct direct = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_direct(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.RelCommon.Emit emit = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_emit(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.RelCommon.Hint hint = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_hint(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.RelCommon.RuntimeConstraint constraint = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_constraint(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* RelCommon::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon.Direct direct = 1; + if (_internal_has_direct()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::direct(this), target, stream); + } + + // .io.substrait.RelCommon.Emit emit = 2; + if (_internal_has_emit()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::emit(this), target, stream); + } + + // .io.substrait.RelCommon.Hint hint = 3; + if (this->has_hint()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::hint(this), target, stream); + } + + // .io.substrait.RelCommon.RuntimeConstraint constraint = 4; + if (this->has_constraint()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::constraint(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon) + return target; +} + +size_t RelCommon::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.RelCommon.Hint hint = 3; + if (this->has_hint()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *hint_); + } + + // .io.substrait.RelCommon.RuntimeConstraint constraint = 4; + if (this->has_constraint()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *constraint_); + } + + switch (kind_case()) { + // .io.substrait.RelCommon.Direct direct = 1; + case kDirect: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.direct_); + break; + } + // .io.substrait.RelCommon.Emit emit = 2; + case kEmit: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.emit_); + break; + } + case KIND_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void RelCommon::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon) + GOOGLE_DCHECK_NE(&from, this); + const RelCommon* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon) + MergeFrom(*source); + } +} + +void RelCommon::MergeFrom(const RelCommon& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_hint()) { + _internal_mutable_hint()->::io::substrait::RelCommon_Hint::MergeFrom(from._internal_hint()); + } + if (from.has_constraint()) { + _internal_mutable_constraint()->::io::substrait::RelCommon_RuntimeConstraint::MergeFrom(from._internal_constraint()); + } + switch (from.kind_case()) { + case kDirect: { + _internal_mutable_direct()->::io::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); + break; + } + case kEmit: { + _internal_mutable_emit()->::io::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); + break; + } + case KIND_NOT_SET: { + break; + } + } +} + +void RelCommon::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void RelCommon::CopyFrom(const RelCommon& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool RelCommon::IsInitialized() const { + return true; +} + +void RelCommon::InternalSwap(RelCommon* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(RelCommon, constraint_) + + sizeof(RelCommon::constraint_) + - PROTOBUF_FIELD_OFFSET(RelCommon, hint_)>( + reinterpret_cast(&hint_), + reinterpret_cast(&other->hint_)); + swap(kind_, other->kind_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata RelCommon::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[6]); +} + +// =================================================================== + +class ReadRel_NamedTable::_Internal { + public: +}; + +ReadRel_NamedTable::ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + names_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.NamedTable) +} +ReadRel_NamedTable::ReadRel_NamedTable(const ReadRel_NamedTable& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + names_(from.names_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.NamedTable) +} + +void ReadRel_NamedTable::SharedCtor() { +} + +ReadRel_NamedTable::~ReadRel_NamedTable() { + // @@protoc_insertion_point(destructor:io.substrait.ReadRel.NamedTable) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReadRel_NamedTable::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void ReadRel_NamedTable::ArenaDtor(void* object) { + ReadRel_NamedTable* _this = reinterpret_cast< ReadRel_NamedTable* >(object); + (void)_this; +} +void ReadRel_NamedTable::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReadRel_NamedTable::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReadRel_NamedTable::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel.NamedTable) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + names_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReadRel_NamedTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string names = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_names(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReadRel.NamedTable.names")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_NamedTable::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel.NamedTable) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string names = 1; + for (int i = 0, n = this->_internal_names_size(); i < n; i++) { + const auto& s = this->_internal_names(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.ReadRel.NamedTable.names"); + target = stream->WriteString(1, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel.NamedTable) + return target; +} + +size_t ReadRel_NamedTable::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel.NamedTable) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string names = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); + for (int i = 0, n = names_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + names_.Get(i)); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReadRel_NamedTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel.NamedTable) + GOOGLE_DCHECK_NE(&from, this); + const ReadRel_NamedTable* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel.NamedTable) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel.NamedTable) + MergeFrom(*source); + } +} + +void ReadRel_NamedTable::MergeFrom(const ReadRel_NamedTable& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel.NamedTable) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + names_.MergeFrom(from.names_); +} + +void ReadRel_NamedTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel.NamedTable) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReadRel_NamedTable::CopyFrom(const ReadRel_NamedTable& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel.NamedTable) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReadRel_NamedTable::IsInitialized() const { + return true; +} + +void ReadRel_NamedTable::InternalSwap(ReadRel_NamedTable* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + names_.InternalSwap(&other->names_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_NamedTable::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[7]); +} + +// =================================================================== + +class ReadRel_VirtualTable::_Internal { + public: +}; + +void ReadRel_VirtualTable::clear_values() { + values_.Clear(); +} +ReadRel_VirtualTable::ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + values_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.VirtualTable) +} +ReadRel_VirtualTable::ReadRel_VirtualTable(const ReadRel_VirtualTable& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + values_(from.values_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.VirtualTable) +} + +void ReadRel_VirtualTable::SharedCtor() { +} + +ReadRel_VirtualTable::~ReadRel_VirtualTable() { + // @@protoc_insertion_point(destructor:io.substrait.ReadRel.VirtualTable) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReadRel_VirtualTable::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void ReadRel_VirtualTable::ArenaDtor(void* object) { + ReadRel_VirtualTable* _this = reinterpret_cast< ReadRel_VirtualTable* >(object); + (void)_this; +} +void ReadRel_VirtualTable::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReadRel_VirtualTable::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReadRel_VirtualTable::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel.VirtualTable) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + values_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReadRel_VirtualTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression.Literal.Struct values = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_values(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_VirtualTable::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel.VirtualTable) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression.Literal.Struct values = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_values_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_values(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel.VirtualTable) + return target; +} + +size_t ReadRel_VirtualTable::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel.VirtualTable) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression.Literal.Struct values = 1; + total_size += 1UL * this->_internal_values_size(); + for (const auto& msg : this->values_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReadRel_VirtualTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel.VirtualTable) + GOOGLE_DCHECK_NE(&from, this); + const ReadRel_VirtualTable* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel.VirtualTable) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel.VirtualTable) + MergeFrom(*source); + } +} + +void ReadRel_VirtualTable::MergeFrom(const ReadRel_VirtualTable& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel.VirtualTable) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + values_.MergeFrom(from.values_); +} + +void ReadRel_VirtualTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel.VirtualTable) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReadRel_VirtualTable::CopyFrom(const ReadRel_VirtualTable& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel.VirtualTable) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReadRel_VirtualTable::IsInitialized() const { + return true; +} + +void ReadRel_VirtualTable::InternalSwap(ReadRel_VirtualTable* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + values_.InternalSwap(&other->values_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_VirtualTable::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[8]); +} + +// =================================================================== + +class ReadRel_LocalFiles_FileOrFiles::_Internal { + public: +}; + +ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) +} +ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + format_ = from.format_; + clear_has_path_type(); + switch (from.path_type_case()) { + case kUriPath: { + _internal_set_uri_path(from._internal_uri_path()); + break; + } + case kUriPathGlob: { + _internal_set_uri_path_glob(from._internal_uri_path_glob()); + break; + } + case PATH_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) +} + +void ReadRel_LocalFiles_FileOrFiles::SharedCtor() { +format_ = 0; +clear_has_path_type(); +} + +ReadRel_LocalFiles_FileOrFiles::~ReadRel_LocalFiles_FileOrFiles() { + // @@protoc_insertion_point(destructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReadRel_LocalFiles_FileOrFiles::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_path_type()) { + clear_path_type(); + } +} + +void ReadRel_LocalFiles_FileOrFiles::ArenaDtor(void* object) { + ReadRel_LocalFiles_FileOrFiles* _this = reinterpret_cast< ReadRel_LocalFiles_FileOrFiles* >(object); + (void)_this; +} +void ReadRel_LocalFiles_FileOrFiles::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReadRel_LocalFiles_FileOrFiles::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReadRel_LocalFiles_FileOrFiles::clear_path_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) + switch (path_type_case()) { + case kUriPath: { + path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kUriPathGlob: { + path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case PATH_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = PATH_TYPE_NOT_SET; +} + + +void ReadRel_LocalFiles_FileOrFiles::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + format_ = 0; + clear_path_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReadRel_LocalFiles_FileOrFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string uri_path = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_uri_path(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string uri_path_glob = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_uri_path_glob(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_format(static_cast<::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles_FileOrFiles::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string uri_path = 1; + if (_internal_has_uri_path()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_uri_path().data(), static_cast(this->_internal_uri_path().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_uri_path(), target); + } + + // string uri_path_glob = 2; + if (_internal_has_uri_path_glob()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_uri_path_glob().data(), static_cast(this->_internal_uri_path_glob().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_uri_path_glob(), target); + } + + // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 3; + if (this->format() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_format(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel.LocalFiles.FileOrFiles) + return target; +} + +size_t ReadRel_LocalFiles_FileOrFiles::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 3; + if (this->format() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_format()); + } + + switch (path_type_case()) { + // string uri_path = 1; + case kUriPath: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_uri_path()); + break; + } + // string uri_path_glob = 2; + case kUriPathGlob: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_uri_path_glob()); + break; + } + case PATH_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) + GOOGLE_DCHECK_NE(&from, this); + const ReadRel_LocalFiles_FileOrFiles* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel.LocalFiles.FileOrFiles) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel.LocalFiles.FileOrFiles) + MergeFrom(*source); + } +} + +void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ReadRel_LocalFiles_FileOrFiles& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.format() != 0) { + _internal_set_format(from._internal_format()); + } + switch (from.path_type_case()) { + case kUriPath: { + _internal_set_uri_path(from._internal_uri_path()); + break; + } + case kUriPathGlob: { + _internal_set_uri_path_glob(from._internal_uri_path_glob()); + break; + } + case PATH_TYPE_NOT_SET: { + break; + } + } +} + +void ReadRel_LocalFiles_FileOrFiles::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReadRel_LocalFiles_FileOrFiles::CopyFrom(const ReadRel_LocalFiles_FileOrFiles& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReadRel_LocalFiles_FileOrFiles::IsInitialized() const { + return true; +} + +void ReadRel_LocalFiles_FileOrFiles::InternalSwap(ReadRel_LocalFiles_FileOrFiles* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(format_, other->format_); + swap(path_type_, other->path_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles_FileOrFiles::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[9]); +} + +// =================================================================== + +class ReadRel_LocalFiles::_Internal { + public: +}; + +ReadRel_LocalFiles::ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + items_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.LocalFiles) +} +ReadRel_LocalFiles::ReadRel_LocalFiles(const ReadRel_LocalFiles& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + items_(from.items_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.LocalFiles) +} + +void ReadRel_LocalFiles::SharedCtor() { +} + +ReadRel_LocalFiles::~ReadRel_LocalFiles() { + // @@protoc_insertion_point(destructor:io.substrait.ReadRel.LocalFiles) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReadRel_LocalFiles::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void ReadRel_LocalFiles::ArenaDtor(void* object) { + ReadRel_LocalFiles* _this = reinterpret_cast< ReadRel_LocalFiles* >(object); + (void)_this; +} +void ReadRel_LocalFiles::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReadRel_LocalFiles::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReadRel_LocalFiles::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel.LocalFiles) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + items_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReadRel_LocalFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_items(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel.LocalFiles) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_items_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_items(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel.LocalFiles) + return target; +} + +size_t ReadRel_LocalFiles::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel.LocalFiles) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; + total_size += 1UL * this->_internal_items_size(); + for (const auto& msg : this->items_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReadRel_LocalFiles::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel.LocalFiles) + GOOGLE_DCHECK_NE(&from, this); + const ReadRel_LocalFiles* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel.LocalFiles) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel.LocalFiles) + MergeFrom(*source); + } +} + +void ReadRel_LocalFiles::MergeFrom(const ReadRel_LocalFiles& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel.LocalFiles) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + items_.MergeFrom(from.items_); +} + +void ReadRel_LocalFiles::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel.LocalFiles) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReadRel_LocalFiles::CopyFrom(const ReadRel_LocalFiles& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel.LocalFiles) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReadRel_LocalFiles::IsInitialized() const { + return true; +} + +void ReadRel_LocalFiles::InternalSwap(ReadRel_LocalFiles* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + items_.InternalSwap(&other->items_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[10]); +} + +// =================================================================== + +class ReadRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const ReadRel* msg); + static const ::io::substrait::Type_NamedStruct& base_schema(const ReadRel* msg); + static const ::io::substrait::Expression& filter(const ReadRel* msg); + static const ::io::substrait::MaskExpression& projection(const ReadRel* msg); + static const ::io::substrait::ReadRel_VirtualTable& virtual_table(const ReadRel* msg); + static const ::io::substrait::ReadRel_LocalFiles& local_files(const ReadRel* msg); + static const ::io::substrait::ReadRel_NamedTable& named_table(const ReadRel* msg); +}; + +const ::io::substrait::RelCommon& +ReadRel::_Internal::common(const ReadRel* msg) { + return *msg->common_; +} +const ::io::substrait::Type_NamedStruct& +ReadRel::_Internal::base_schema(const ReadRel* msg) { + return *msg->base_schema_; +} +const ::io::substrait::Expression& +ReadRel::_Internal::filter(const ReadRel* msg) { + return *msg->filter_; +} +const ::io::substrait::MaskExpression& +ReadRel::_Internal::projection(const ReadRel* msg) { + return *msg->projection_; +} +const ::io::substrait::ReadRel_VirtualTable& +ReadRel::_Internal::virtual_table(const ReadRel* msg) { + return *msg->read_type_.virtual_table_; +} +const ::io::substrait::ReadRel_LocalFiles& +ReadRel::_Internal::local_files(const ReadRel* msg) { + return *msg->read_type_.local_files_; +} +const ::io::substrait::ReadRel_NamedTable& +ReadRel::_Internal::named_table(const ReadRel* msg) { + return *msg->read_type_.named_table_; +} +void ReadRel::clear_base_schema() { + if (GetArena() == nullptr && base_schema_ != nullptr) { + delete base_schema_; + } + base_schema_ = nullptr; +} +void ReadRel::clear_filter() { + if (GetArena() == nullptr && filter_ != nullptr) { + delete filter_; + } + filter_ = nullptr; +} +void ReadRel::clear_projection() { + if (GetArena() == nullptr && projection_ != nullptr) { + delete projection_; + } + projection_ = nullptr; +} +void ReadRel::set_allocated_virtual_table(::io::substrait::ReadRel_VirtualTable* virtual_table) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_read_type(); + if (virtual_table) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(virtual_table); + if (message_arena != submessage_arena) { + virtual_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, virtual_table, submessage_arena); + } + set_has_virtual_table(); + read_type_.virtual_table_ = virtual_table; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.virtual_table) +} +void ReadRel::set_allocated_local_files(::io::substrait::ReadRel_LocalFiles* local_files) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_read_type(); + if (local_files) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(local_files); + if (message_arena != submessage_arena) { + local_files = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, local_files, submessage_arena); + } + set_has_local_files(); + read_type_.local_files_ = local_files; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.local_files) +} +void ReadRel::set_allocated_named_table(::io::substrait::ReadRel_NamedTable* named_table) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_read_type(); + if (named_table) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(named_table); + if (message_arena != submessage_arena) { + named_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, named_table, submessage_arena); + } + set_has_named_table(); + read_type_.named_table_ = named_table; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.named_table) +} +ReadRel::ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel) +} +ReadRel::ReadRel(const ReadRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_base_schema()) { + base_schema_ = new ::io::substrait::Type_NamedStruct(*from.base_schema_); + } else { + base_schema_ = nullptr; + } + if (from._internal_has_filter()) { + filter_ = new ::io::substrait::Expression(*from.filter_); + } else { + filter_ = nullptr; + } + if (from._internal_has_projection()) { + projection_ = new ::io::substrait::MaskExpression(*from.projection_); + } else { + projection_ = nullptr; + } + clear_has_read_type(); + switch (from.read_type_case()) { + case kVirtualTable: { + _internal_mutable_virtual_table()->::io::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table()); + break; + } + case kLocalFiles: { + _internal_mutable_local_files()->::io::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files()); + break; + } + case kNamedTable: { + _internal_mutable_named_table()->::io::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table()); + break; + } + case READ_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel) +} + +void ReadRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&projection_) - + reinterpret_cast(&common_)) + sizeof(projection_)); +clear_has_read_type(); +} + +ReadRel::~ReadRel() { + // @@protoc_insertion_point(destructor:io.substrait.ReadRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReadRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete base_schema_; + if (this != internal_default_instance()) delete filter_; + if (this != internal_default_instance()) delete projection_; + if (has_read_type()) { + clear_read_type(); + } +} + +void ReadRel::ArenaDtor(void* object) { + ReadRel* _this = reinterpret_cast< ReadRel* >(object); + (void)_this; +} +void ReadRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReadRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReadRel::clear_read_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.ReadRel) + switch (read_type_case()) { + case kVirtualTable: { + if (GetArena() == nullptr) { + delete read_type_.virtual_table_; + } + break; + } + case kLocalFiles: { + if (GetArena() == nullptr) { + delete read_type_.local_files_; + } + break; + } + case kNamedTable: { + if (GetArena() == nullptr) { + delete read_type_.named_table_; + } + break; + } + case READ_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = READ_TYPE_NOT_SET; +} + + +void ReadRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && base_schema_ != nullptr) { + delete base_schema_; + } + base_schema_ = nullptr; + if (GetArena() == nullptr && filter_ != nullptr) { + delete filter_; + } + filter_ = nullptr; + if (GetArena() == nullptr && projection_ != nullptr) { + delete projection_; + } + projection_ = nullptr; + clear_read_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReadRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.NamedStruct base_schema = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_base_schema(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression filter = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.MaskExpression projection = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_projection(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReadRel.VirtualTable virtual_table = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_virtual_table(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReadRel.LocalFiles local_files = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_local_files(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReadRel.NamedTable named_table = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_named_table(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // .io.substrait.Type.NamedStruct base_schema = 2; + if (this->has_base_schema()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::base_schema(this), target, stream); + } + + // .io.substrait.Expression filter = 3; + if (this->has_filter()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::filter(this), target, stream); + } + + // .io.substrait.MaskExpression projection = 4; + if (this->has_projection()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::projection(this), target, stream); + } + + // .io.substrait.ReadRel.VirtualTable virtual_table = 5; + if (_internal_has_virtual_table()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::virtual_table(this), target, stream); + } + + // .io.substrait.ReadRel.LocalFiles local_files = 6; + if (_internal_has_local_files()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::local_files(this), target, stream); + } + + // .io.substrait.ReadRel.NamedTable named_table = 7; + if (_internal_has_named_table()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::named_table(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel) + return target; +} + +size_t ReadRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .io.substrait.Type.NamedStruct base_schema = 2; + if (this->has_base_schema()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *base_schema_); + } + + // .io.substrait.Expression filter = 3; + if (this->has_filter()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *filter_); + } + + // .io.substrait.MaskExpression projection = 4; + if (this->has_projection()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *projection_); + } + + switch (read_type_case()) { + // .io.substrait.ReadRel.VirtualTable virtual_table = 5; + case kVirtualTable: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *read_type_.virtual_table_); + break; + } + // .io.substrait.ReadRel.LocalFiles local_files = 6; + case kLocalFiles: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *read_type_.local_files_); + break; + } + // .io.substrait.ReadRel.NamedTable named_table = 7; + case kNamedTable: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *read_type_.named_table_); + break; + } + case READ_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReadRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel) + GOOGLE_DCHECK_NE(&from, this); + const ReadRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel) + MergeFrom(*source); + } +} + +void ReadRel::MergeFrom(const ReadRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_base_schema()) { + _internal_mutable_base_schema()->::io::substrait::Type_NamedStruct::MergeFrom(from._internal_base_schema()); + } + if (from.has_filter()) { + _internal_mutable_filter()->::io::substrait::Expression::MergeFrom(from._internal_filter()); + } + if (from.has_projection()) { + _internal_mutable_projection()->::io::substrait::MaskExpression::MergeFrom(from._internal_projection()); + } + switch (from.read_type_case()) { + case kVirtualTable: { + _internal_mutable_virtual_table()->::io::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table()); + break; + } + case kLocalFiles: { + _internal_mutable_local_files()->::io::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files()); + break; + } + case kNamedTable: { + _internal_mutable_named_table()->::io::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table()); + break; + } + case READ_TYPE_NOT_SET: { + break; + } + } +} + +void ReadRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReadRel::CopyFrom(const ReadRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReadRel::IsInitialized() const { + return true; +} + +void ReadRel::InternalSwap(ReadRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ReadRel, projection_) + + sizeof(ReadRel::projection_) + - PROTOBUF_FIELD_OFFSET(ReadRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); + swap(read_type_, other->read_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReadRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[11]); +} + +// =================================================================== + +class ProjectRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const ProjectRel* msg); + static const ::io::substrait::Rel& input(const ProjectRel* msg); +}; + +const ::io::substrait::RelCommon& +ProjectRel::_Internal::common(const ProjectRel* msg) { + return *msg->common_; +} +const ::io::substrait::Rel& +ProjectRel::_Internal::input(const ProjectRel* msg) { + return *msg->input_; +} +void ProjectRel::clear_expressions() { + expressions_.Clear(); +} +ProjectRel::ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + expressions_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ProjectRel) +} +ProjectRel::ProjectRel(const ProjectRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + expressions_(from.expressions_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_input()) { + input_ = new ::io::substrait::Rel(*from.input_); + } else { + input_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ProjectRel) +} + +void ProjectRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&input_) - + reinterpret_cast(&common_)) + sizeof(input_)); +} + +ProjectRel::~ProjectRel() { + // @@protoc_insertion_point(destructor:io.substrait.ProjectRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ProjectRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete input_; +} + +void ProjectRel::ArenaDtor(void* object) { + ProjectRel* _this = reinterpret_cast< ProjectRel* >(object); + (void)_this; +} +void ProjectRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ProjectRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ProjectRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ProjectRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + expressions_.Clear(); + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ProjectRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Rel input = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression expressions = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_expressions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ProjectRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ProjectRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::input(this), target, stream); + } + + // repeated .io.substrait.Expression expressions = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_expressions_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_expressions(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ProjectRel) + return target; +} + +size_t ProjectRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ProjectRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression expressions = 3; + total_size += 1UL * this->_internal_expressions_size(); + for (const auto& msg : this->expressions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *input_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ProjectRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ProjectRel) + GOOGLE_DCHECK_NE(&from, this); + const ProjectRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ProjectRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ProjectRel) + MergeFrom(*source); + } +} + +void ProjectRel::MergeFrom(const ProjectRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ProjectRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + expressions_.MergeFrom(from.expressions_); + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_input()) { + _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + } +} + +void ProjectRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ProjectRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ProjectRel::CopyFrom(const ProjectRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ProjectRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ProjectRel::IsInitialized() const { + return true; +} + +void ProjectRel::InternalSwap(ProjectRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + expressions_.InternalSwap(&other->expressions_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ProjectRel, input_) + + sizeof(ProjectRel::input_) + - PROTOBUF_FIELD_OFFSET(ProjectRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ProjectRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[12]); +} + +// =================================================================== + +class JoinRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const JoinRel* msg); + static const ::io::substrait::Rel& left(const JoinRel* msg); + static const ::io::substrait::Rel& right(const JoinRel* msg); + static const ::io::substrait::Expression& expression(const JoinRel* msg); + static const ::io::substrait::Expression& post_join_filter(const JoinRel* msg); +}; + +const ::io::substrait::RelCommon& +JoinRel::_Internal::common(const JoinRel* msg) { + return *msg->common_; +} +const ::io::substrait::Rel& +JoinRel::_Internal::left(const JoinRel* msg) { + return *msg->left_; +} +const ::io::substrait::Rel& +JoinRel::_Internal::right(const JoinRel* msg) { + return *msg->right_; +} +const ::io::substrait::Expression& +JoinRel::_Internal::expression(const JoinRel* msg) { + return *msg->expression_; +} +const ::io::substrait::Expression& +JoinRel::_Internal::post_join_filter(const JoinRel* msg) { + return *msg->post_join_filter_; +} +void JoinRel::clear_expression() { + if (GetArena() == nullptr && expression_ != nullptr) { + delete expression_; + } + expression_ = nullptr; +} +void JoinRel::clear_post_join_filter() { + if (GetArena() == nullptr && post_join_filter_ != nullptr) { + delete post_join_filter_; + } + post_join_filter_ = nullptr; +} +JoinRel::JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.JoinRel) +} +JoinRel::JoinRel(const JoinRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_left()) { + left_ = new ::io::substrait::Rel(*from.left_); + } else { + left_ = nullptr; + } + if (from._internal_has_right()) { + right_ = new ::io::substrait::Rel(*from.right_); + } else { + right_ = nullptr; + } + if (from._internal_has_expression()) { + expression_ = new ::io::substrait::Expression(*from.expression_); + } else { + expression_ = nullptr; + } + if (from._internal_has_post_join_filter()) { + post_join_filter_ = new ::io::substrait::Expression(*from.post_join_filter_); + } else { + post_join_filter_ = nullptr; + } + type_ = from.type_; + // @@protoc_insertion_point(copy_constructor:io.substrait.JoinRel) +} + +void JoinRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&type_) - + reinterpret_cast(&common_)) + sizeof(type_)); +} + +JoinRel::~JoinRel() { + // @@protoc_insertion_point(destructor:io.substrait.JoinRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void JoinRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete left_; + if (this != internal_default_instance()) delete right_; + if (this != internal_default_instance()) delete expression_; + if (this != internal_default_instance()) delete post_join_filter_; +} + +void JoinRel::ArenaDtor(void* object) { + JoinRel* _this = reinterpret_cast< JoinRel* >(object); + (void)_this; +} +void JoinRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void JoinRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void JoinRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.JoinRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && left_ != nullptr) { + delete left_; + } + left_ = nullptr; + if (GetArena() == nullptr && right_ != nullptr) { + delete right_; + } + right_ = nullptr; + if (GetArena() == nullptr && expression_ != nullptr) { + delete expression_; + } + expression_ = nullptr; + if (GetArena() == nullptr && post_join_filter_ != nullptr) { + delete post_join_filter_; + } + post_join_filter_ = nullptr; + type_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* JoinRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Rel left = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_left(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Rel right = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_right(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression expression = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression post_join_filter = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_post_join_filter(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.JoinRel.JoinType type = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_type(static_cast<::io::substrait::JoinRel_JoinType>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.JoinRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // .io.substrait.Rel left = 2; + if (this->has_left()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::left(this), target, stream); + } + + // .io.substrait.Rel right = 3; + if (this->has_right()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::right(this), target, stream); + } + + // .io.substrait.Expression expression = 4; + if (this->has_expression()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::expression(this), target, stream); + } + + // .io.substrait.Expression post_join_filter = 5; + if (this->has_post_join_filter()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::post_join_filter(this), target, stream); + } + + // .io.substrait.JoinRel.JoinType type = 6; + if (this->type() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 6, this->_internal_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.JoinRel) + return target; +} + +size_t JoinRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.JoinRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .io.substrait.Rel left = 2; + if (this->has_left()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *left_); + } + + // .io.substrait.Rel right = 3; + if (this->has_right()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *right_); + } + + // .io.substrait.Expression expression = 4; + if (this->has_expression()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *expression_); + } + + // .io.substrait.Expression post_join_filter = 5; + if (this->has_post_join_filter()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *post_join_filter_); + } + + // .io.substrait.JoinRel.JoinType type = 6; + if (this->type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void JoinRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.JoinRel) + GOOGLE_DCHECK_NE(&from, this); + const JoinRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.JoinRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.JoinRel) + MergeFrom(*source); + } +} + +void JoinRel::MergeFrom(const JoinRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.JoinRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_left()) { + _internal_mutable_left()->::io::substrait::Rel::MergeFrom(from._internal_left()); + } + if (from.has_right()) { + _internal_mutable_right()->::io::substrait::Rel::MergeFrom(from._internal_right()); + } + if (from.has_expression()) { + _internal_mutable_expression()->::io::substrait::Expression::MergeFrom(from._internal_expression()); + } + if (from.has_post_join_filter()) { + _internal_mutable_post_join_filter()->::io::substrait::Expression::MergeFrom(from._internal_post_join_filter()); + } + if (from.type() != 0) { + _internal_set_type(from._internal_type()); + } +} + +void JoinRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.JoinRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void JoinRel::CopyFrom(const JoinRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.JoinRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool JoinRel::IsInitialized() const { + return true; +} + +void JoinRel::InternalSwap(JoinRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(JoinRel, type_) + + sizeof(JoinRel::type_) + - PROTOBUF_FIELD_OFFSET(JoinRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata JoinRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[13]); +} + +// =================================================================== + +class FetchRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const FetchRel* msg); + static const ::io::substrait::Rel& input(const FetchRel* msg); +}; + +const ::io::substrait::RelCommon& +FetchRel::_Internal::common(const FetchRel* msg) { + return *msg->common_; +} +const ::io::substrait::Rel& +FetchRel::_Internal::input(const FetchRel* msg) { + return *msg->input_; +} +FetchRel::FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FetchRel) +} +FetchRel::FetchRel(const FetchRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_input()) { + input_ = new ::io::substrait::Rel(*from.input_); + } else { + input_ = nullptr; + } + ::memcpy(&offset_, &from.offset_, + static_cast(reinterpret_cast(&count_) - + reinterpret_cast(&offset_)) + sizeof(count_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.FetchRel) +} + +void FetchRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&count_) - + reinterpret_cast(&common_)) + sizeof(count_)); +} + +FetchRel::~FetchRel() { + // @@protoc_insertion_point(destructor:io.substrait.FetchRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FetchRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete input_; +} + +void FetchRel::ArenaDtor(void* object) { + FetchRel* _this = reinterpret_cast< FetchRel* >(object); + (void)_this; +} +void FetchRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FetchRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FetchRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FetchRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; + ::memset(&offset_, 0, static_cast( + reinterpret_cast(&count_) - + reinterpret_cast(&offset_)) + sizeof(count_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FetchRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Rel input = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 offset = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 count = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FetchRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FetchRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::input(this), target, stream); + } + + // int64 offset = 3; + if (this->offset() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_offset(), target); + } + + // int64 count = 4; + if (this->count() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_count(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FetchRel) + return target; +} + +size_t FetchRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FetchRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *input_); + } + + // int64 offset = 3; + if (this->offset() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_offset()); + } + + // int64 count = 4; + if (this->count() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_count()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FetchRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FetchRel) + GOOGLE_DCHECK_NE(&from, this); + const FetchRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FetchRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FetchRel) + MergeFrom(*source); + } +} + +void FetchRel::MergeFrom(const FetchRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FetchRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_input()) { + _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + } + if (from.offset() != 0) { + _internal_set_offset(from._internal_offset()); + } + if (from.count() != 0) { + _internal_set_count(from._internal_count()); + } +} + +void FetchRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FetchRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FetchRel::CopyFrom(const FetchRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FetchRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FetchRel::IsInitialized() const { + return true; +} + +void FetchRel::InternalSwap(FetchRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FetchRel, count_) + + sizeof(FetchRel::count_) + - PROTOBUF_FIELD_OFFSET(FetchRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FetchRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[14]); +} + +// =================================================================== + +class AggregateRel_Grouping::_Internal { + public: +}; + +AggregateRel_Grouping::AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + input_fields_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.AggregateRel.Grouping) +} +AggregateRel_Grouping::AggregateRel_Grouping(const AggregateRel_Grouping& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + input_fields_(from.input_fields_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.AggregateRel.Grouping) +} + +void AggregateRel_Grouping::SharedCtor() { +} + +AggregateRel_Grouping::~AggregateRel_Grouping() { + // @@protoc_insertion_point(destructor:io.substrait.AggregateRel.Grouping) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void AggregateRel_Grouping::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void AggregateRel_Grouping::ArenaDtor(void* object) { + AggregateRel_Grouping* _this = reinterpret_cast< AggregateRel_Grouping* >(object); + (void)_this; +} +void AggregateRel_Grouping::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void AggregateRel_Grouping::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void AggregateRel_Grouping::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.AggregateRel.Grouping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + input_fields_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* AggregateRel_Grouping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated int32 input_fields = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_input_fields(), ptr, ctx); + CHK_(ptr); + } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8) { + _internal_add_input_fields(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Grouping::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.AggregateRel.Grouping) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated int32 input_fields = 1; + { + int byte_size = _input_fields_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt32Packed( + 1, _internal_input_fields(), byte_size, target); + } + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.AggregateRel.Grouping) + return target; +} + +size_t AggregateRel_Grouping::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.AggregateRel.Grouping) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated int32 input_fields = 1; + { + size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + Int32Size(this->input_fields_); + if (data_size > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); + _input_fields_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AggregateRel_Grouping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.AggregateRel.Grouping) + GOOGLE_DCHECK_NE(&from, this); + const AggregateRel_Grouping* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.AggregateRel.Grouping) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.AggregateRel.Grouping) + MergeFrom(*source); + } +} + +void AggregateRel_Grouping::MergeFrom(const AggregateRel_Grouping& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.AggregateRel.Grouping) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + input_fields_.MergeFrom(from.input_fields_); +} + +void AggregateRel_Grouping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.AggregateRel.Grouping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AggregateRel_Grouping::CopyFrom(const AggregateRel_Grouping& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.AggregateRel.Grouping) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AggregateRel_Grouping::IsInitialized() const { + return true; +} + +void AggregateRel_Grouping::InternalSwap(AggregateRel_Grouping* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + input_fields_.InternalSwap(&other->input_fields_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Grouping::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[15]); +} + +// =================================================================== + +class AggregateRel_Measure::_Internal { + public: + static const ::io::substrait::Expression_AggregateFunction& measure(const AggregateRel_Measure* msg); +}; + +const ::io::substrait::Expression_AggregateFunction& +AggregateRel_Measure::_Internal::measure(const AggregateRel_Measure* msg) { + return *msg->measure_; +} +void AggregateRel_Measure::clear_measure() { + if (GetArena() == nullptr && measure_ != nullptr) { + delete measure_; + } + measure_ = nullptr; +} +AggregateRel_Measure::AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.AggregateRel.Measure) +} +AggregateRel_Measure::AggregateRel_Measure(const AggregateRel_Measure& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_measure()) { + measure_ = new ::io::substrait::Expression_AggregateFunction(*from.measure_); + } else { + measure_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.AggregateRel.Measure) +} + +void AggregateRel_Measure::SharedCtor() { +measure_ = nullptr; +} + +AggregateRel_Measure::~AggregateRel_Measure() { + // @@protoc_insertion_point(destructor:io.substrait.AggregateRel.Measure) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void AggregateRel_Measure::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete measure_; +} + +void AggregateRel_Measure::ArenaDtor(void* object) { + AggregateRel_Measure* _this = reinterpret_cast< AggregateRel_Measure* >(object); + (void)_this; +} +void AggregateRel_Measure::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void AggregateRel_Measure::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void AggregateRel_Measure::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.AggregateRel.Measure) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && measure_ != nullptr) { + delete measure_; + } + measure_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* AggregateRel_Measure::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.AggregateFunction measure = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_measure(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Measure::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.AggregateRel.Measure) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.AggregateFunction measure = 1; + if (this->has_measure()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::measure(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.AggregateRel.Measure) + return target; +} + +size_t AggregateRel_Measure::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.AggregateRel.Measure) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression.AggregateFunction measure = 1; + if (this->has_measure()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *measure_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AggregateRel_Measure::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.AggregateRel.Measure) + GOOGLE_DCHECK_NE(&from, this); + const AggregateRel_Measure* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.AggregateRel.Measure) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.AggregateRel.Measure) + MergeFrom(*source); + } +} + +void AggregateRel_Measure::MergeFrom(const AggregateRel_Measure& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.AggregateRel.Measure) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_measure()) { + _internal_mutable_measure()->::io::substrait::Expression_AggregateFunction::MergeFrom(from._internal_measure()); + } +} + +void AggregateRel_Measure::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.AggregateRel.Measure) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AggregateRel_Measure::CopyFrom(const AggregateRel_Measure& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.AggregateRel.Measure) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AggregateRel_Measure::IsInitialized() const { + return true; +} + +void AggregateRel_Measure::InternalSwap(AggregateRel_Measure* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(measure_, other->measure_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Measure::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[16]); +} + +// =================================================================== + +class AggregateRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const AggregateRel* msg); + static const ::io::substrait::Rel& input(const AggregateRel* msg); +}; + +const ::io::substrait::RelCommon& +AggregateRel::_Internal::common(const AggregateRel* msg) { + return *msg->common_; +} +const ::io::substrait::Rel& +AggregateRel::_Internal::input(const AggregateRel* msg) { + return *msg->input_; +} +AggregateRel::AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + groupings_(arena), + measures_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.AggregateRel) +} +AggregateRel::AggregateRel(const AggregateRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + groupings_(from.groupings_), + measures_(from.measures_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_input()) { + input_ = new ::io::substrait::Rel(*from.input_); + } else { + input_ = nullptr; + } + phase_ = from.phase_; + // @@protoc_insertion_point(copy_constructor:io.substrait.AggregateRel) +} + +void AggregateRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&phase_) - + reinterpret_cast(&common_)) + sizeof(phase_)); +} + +AggregateRel::~AggregateRel() { + // @@protoc_insertion_point(destructor:io.substrait.AggregateRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void AggregateRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete input_; +} + +void AggregateRel::ArenaDtor(void* object) { + AggregateRel* _this = reinterpret_cast< AggregateRel* >(object); + (void)_this; +} +void AggregateRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void AggregateRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void AggregateRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.AggregateRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + groupings_.Clear(); + measures_.Clear(); + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; + phase_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Rel input = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.AggregateRel.Grouping groupings = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_groupings(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // repeated .io.substrait.AggregateRel.Measure measures = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_measures(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.AggregationPhase phase = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_phase(static_cast<::io::substrait::Expression_AggregationPhase>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.AggregateRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::input(this), target, stream); + } + + // repeated .io.substrait.AggregateRel.Grouping groupings = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_groupings_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_groupings(i), target, stream); + } + + // repeated .io.substrait.AggregateRel.Measure measures = 4; + for (unsigned int i = 0, + n = static_cast(this->_internal_measures_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(4, this->_internal_measures(i), target, stream); + } + + // .io.substrait.Expression.AggregationPhase phase = 5; + if (this->phase() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 5, this->_internal_phase(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.AggregateRel) + return target; +} + +size_t AggregateRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.AggregateRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.AggregateRel.Grouping groupings = 3; + total_size += 1UL * this->_internal_groupings_size(); + for (const auto& msg : this->groupings_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .io.substrait.AggregateRel.Measure measures = 4; + total_size += 1UL * this->_internal_measures_size(); + for (const auto& msg : this->measures_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *input_); + } + + // .io.substrait.Expression.AggregationPhase phase = 5; + if (this->phase() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AggregateRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.AggregateRel) + GOOGLE_DCHECK_NE(&from, this); + const AggregateRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.AggregateRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.AggregateRel) + MergeFrom(*source); + } +} + +void AggregateRel::MergeFrom(const AggregateRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.AggregateRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + groupings_.MergeFrom(from.groupings_); + measures_.MergeFrom(from.measures_); + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_input()) { + _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + } + if (from.phase() != 0) { + _internal_set_phase(from._internal_phase()); + } +} + +void AggregateRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.AggregateRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AggregateRel::CopyFrom(const AggregateRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.AggregateRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AggregateRel::IsInitialized() const { + return true; +} + +void AggregateRel::InternalSwap(AggregateRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + groupings_.InternalSwap(&other->groupings_); + measures_.InternalSwap(&other->measures_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(AggregateRel, phase_) + + sizeof(AggregateRel::phase_) + - PROTOBUF_FIELD_OFFSET(AggregateRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[17]); +} + +// =================================================================== + +class SortRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const SortRel* msg); + static const ::io::substrait::Rel& input(const SortRel* msg); +}; + +const ::io::substrait::RelCommon& +SortRel::_Internal::common(const SortRel* msg) { + return *msg->common_; +} +const ::io::substrait::Rel& +SortRel::_Internal::input(const SortRel* msg) { + return *msg->input_; +} +void SortRel::clear_sorts() { + sorts_.Clear(); +} +SortRel::SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + sorts_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.SortRel) +} +SortRel::SortRel(const SortRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + sorts_(from.sorts_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_input()) { + input_ = new ::io::substrait::Rel(*from.input_); + } else { + input_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.SortRel) +} + +void SortRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&input_) - + reinterpret_cast(&common_)) + sizeof(input_)); +} + +SortRel::~SortRel() { + // @@protoc_insertion_point(destructor:io.substrait.SortRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SortRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete input_; +} + +void SortRel::ArenaDtor(void* object) { + SortRel* _this = reinterpret_cast< SortRel* >(object); + (void)_this; +} +void SortRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SortRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SortRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.SortRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + sorts_.Clear(); + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SortRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Rel input = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression.SortField sorts = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_sorts(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.SortRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::input(this), target, stream); + } + + // repeated .io.substrait.Expression.SortField sorts = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_sorts_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_sorts(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.SortRel) + return target; +} + +size_t SortRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.SortRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression.SortField sorts = 3; + total_size += 1UL * this->_internal_sorts_size(); + for (const auto& msg : this->sorts_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *input_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SortRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.SortRel) + GOOGLE_DCHECK_NE(&from, this); + const SortRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.SortRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.SortRel) + MergeFrom(*source); + } +} + +void SortRel::MergeFrom(const SortRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.SortRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + sorts_.MergeFrom(from.sorts_); + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_input()) { + _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + } +} + +void SortRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.SortRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SortRel::CopyFrom(const SortRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.SortRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SortRel::IsInitialized() const { + return true; +} + +void SortRel::InternalSwap(SortRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + sorts_.InternalSwap(&other->sorts_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SortRel, input_) + + sizeof(SortRel::input_) + - PROTOBUF_FIELD_OFFSET(SortRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SortRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[18]); +} + +// =================================================================== + +class FilterRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const FilterRel* msg); + static const ::io::substrait::Rel& input(const FilterRel* msg); + static const ::io::substrait::Expression& condition(const FilterRel* msg); +}; + +const ::io::substrait::RelCommon& +FilterRel::_Internal::common(const FilterRel* msg) { + return *msg->common_; +} +const ::io::substrait::Rel& +FilterRel::_Internal::input(const FilterRel* msg) { + return *msg->input_; +} +const ::io::substrait::Expression& +FilterRel::_Internal::condition(const FilterRel* msg) { + return *msg->condition_; +} +void FilterRel::clear_condition() { + if (GetArena() == nullptr && condition_ != nullptr) { + delete condition_; + } + condition_ = nullptr; +} +FilterRel::FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FilterRel) +} +FilterRel::FilterRel(const FilterRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_input()) { + input_ = new ::io::substrait::Rel(*from.input_); + } else { + input_ = nullptr; + } + if (from._internal_has_condition()) { + condition_ = new ::io::substrait::Expression(*from.condition_); + } else { + condition_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.FilterRel) +} + +void FilterRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&condition_) - + reinterpret_cast(&common_)) + sizeof(condition_)); +} + +FilterRel::~FilterRel() { + // @@protoc_insertion_point(destructor:io.substrait.FilterRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FilterRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete input_; + if (this != internal_default_instance()) delete condition_; +} + +void FilterRel::ArenaDtor(void* object) { + FilterRel* _this = reinterpret_cast< FilterRel* >(object); + (void)_this; +} +void FilterRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FilterRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FilterRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FilterRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; + if (GetArena() == nullptr && condition_ != nullptr) { + delete condition_; + } + condition_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FilterRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Rel input = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression condition = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_condition(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FilterRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::input(this), target, stream); + } + + // .io.substrait.Expression condition = 3; + if (this->has_condition()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::condition(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FilterRel) + return target; +} + +size_t FilterRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FilterRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *input_); + } + + // .io.substrait.Expression condition = 3; + if (this->has_condition()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *condition_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FilterRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FilterRel) + GOOGLE_DCHECK_NE(&from, this); + const FilterRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FilterRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FilterRel) + MergeFrom(*source); + } +} + +void FilterRel::MergeFrom(const FilterRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FilterRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_input()) { + _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + } + if (from.has_condition()) { + _internal_mutable_condition()->::io::substrait::Expression::MergeFrom(from._internal_condition()); + } +} + +void FilterRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FilterRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FilterRel::CopyFrom(const FilterRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FilterRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FilterRel::IsInitialized() const { + return true; +} + +void FilterRel::InternalSwap(FilterRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FilterRel, condition_) + + sizeof(FilterRel::condition_) + - PROTOBUF_FIELD_OFFSET(FilterRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FilterRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[19]); +} + +// =================================================================== + +class SetRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const SetRel* msg); +}; + +const ::io::substrait::RelCommon& +SetRel::_Internal::common(const SetRel* msg) { + return *msg->common_; +} +SetRel::SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + inputs_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.SetRel) +} +SetRel::SetRel(const SetRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + inputs_(from.inputs_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + op_ = from.op_; + // @@protoc_insertion_point(copy_constructor:io.substrait.SetRel) +} + +void SetRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&op_) - + reinterpret_cast(&common_)) + sizeof(op_)); +} + +SetRel::~SetRel() { + // @@protoc_insertion_point(destructor:io.substrait.SetRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SetRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; +} + +void SetRel::ArenaDtor(void* object) { + SetRel* _this = reinterpret_cast< SetRel* >(object); + (void)_this; +} +void SetRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SetRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SetRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.SetRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + inputs_.Clear(); + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + op_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Rel inputs = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_inputs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.SetRel.SetOp op = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_op(static_cast<::io::substrait::SetRel_SetOp>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SetRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.SetRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // repeated .io.substrait.Rel inputs = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_inputs_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_inputs(i), target, stream); + } + + // .io.substrait.SetRel.SetOp op = 3; + if (this->op() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_op(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.SetRel) + return target; +} + +size_t SetRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.SetRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Rel inputs = 2; + total_size += 1UL * this->_internal_inputs_size(); + for (const auto& msg : this->inputs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .io.substrait.SetRel.SetOp op = 3; + if (this->op() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SetRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.SetRel) + GOOGLE_DCHECK_NE(&from, this); + const SetRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.SetRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.SetRel) + MergeFrom(*source); + } +} + +void SetRel::MergeFrom(const SetRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.SetRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + inputs_.MergeFrom(from.inputs_); + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.op() != 0) { + _internal_set_op(from._internal_op()); + } +} + +void SetRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.SetRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SetRel::CopyFrom(const SetRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.SetRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SetRel::IsInitialized() const { + return true; +} + +void SetRel::InternalSwap(SetRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + inputs_.InternalSwap(&other->inputs_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SetRel, op_) + + sizeof(SetRel::op_) + - PROTOBUF_FIELD_OFFSET(SetRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SetRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[20]); +} + +// =================================================================== + +class Rel::_Internal { + public: + static const ::io::substrait::ReadRel& read(const Rel* msg); + static const ::io::substrait::FilterRel& filter(const Rel* msg); + static const ::io::substrait::FetchRel& fetch(const Rel* msg); + static const ::io::substrait::AggregateRel& aggregate(const Rel* msg); + static const ::io::substrait::SortRel& sort(const Rel* msg); + static const ::io::substrait::JoinRel& join(const Rel* msg); + static const ::io::substrait::ProjectRel& project(const Rel* msg); + static const ::io::substrait::SetRel& set(const Rel* msg); +}; + +const ::io::substrait::ReadRel& +Rel::_Internal::read(const Rel* msg) { + return *msg->RelType_.read_; +} +const ::io::substrait::FilterRel& +Rel::_Internal::filter(const Rel* msg) { + return *msg->RelType_.filter_; +} +const ::io::substrait::FetchRel& +Rel::_Internal::fetch(const Rel* msg) { + return *msg->RelType_.fetch_; +} +const ::io::substrait::AggregateRel& +Rel::_Internal::aggregate(const Rel* msg) { + return *msg->RelType_.aggregate_; +} +const ::io::substrait::SortRel& +Rel::_Internal::sort(const Rel* msg) { + return *msg->RelType_.sort_; +} +const ::io::substrait::JoinRel& +Rel::_Internal::join(const Rel* msg) { + return *msg->RelType_.join_; +} +const ::io::substrait::ProjectRel& +Rel::_Internal::project(const Rel* msg) { + return *msg->RelType_.project_; +} +const ::io::substrait::SetRel& +Rel::_Internal::set(const Rel* msg) { + return *msg->RelType_.set_; +} +void Rel::set_allocated_read(::io::substrait::ReadRel* read) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (read) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(read); + if (message_arena != submessage_arena) { + read = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, read, submessage_arena); + } + set_has_read(); + RelType_.read_ = read; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.read) +} +void Rel::set_allocated_filter(::io::substrait::FilterRel* filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(filter); + if (message_arena != submessage_arena) { + filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, filter, submessage_arena); + } + set_has_filter(); + RelType_.filter_ = filter; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.filter) +} +void Rel::set_allocated_fetch(::io::substrait::FetchRel* fetch) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (fetch) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fetch); + if (message_arena != submessage_arena) { + fetch = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fetch, submessage_arena); + } + set_has_fetch(); + RelType_.fetch_ = fetch; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.fetch) +} +void Rel::set_allocated_aggregate(::io::substrait::AggregateRel* aggregate) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (aggregate) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(aggregate); + if (message_arena != submessage_arena) { + aggregate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, aggregate, submessage_arena); + } + set_has_aggregate(); + RelType_.aggregate_ = aggregate; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.aggregate) +} +void Rel::set_allocated_sort(::io::substrait::SortRel* sort) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (sort) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sort); + if (message_arena != submessage_arena) { + sort = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, sort, submessage_arena); + } + set_has_sort(); + RelType_.sort_ = sort; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.sort) +} +void Rel::set_allocated_join(::io::substrait::JoinRel* join) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (join) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(join); + if (message_arena != submessage_arena) { + join = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, join, submessage_arena); + } + set_has_join(); + RelType_.join_ = join; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.join) +} +void Rel::set_allocated_project(::io::substrait::ProjectRel* project) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (project) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(project); + if (message_arena != submessage_arena) { + project = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, project, submessage_arena); + } + set_has_project(); + RelType_.project_ = project; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.project) +} +void Rel::set_allocated_set(::io::substrait::SetRel* set) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (set) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(set); + if (message_arena != submessage_arena) { + set = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, set, submessage_arena); + } + set_has_set(); + RelType_.set_ = set; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.set) +} +Rel::Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Rel) +} +Rel::Rel(const Rel& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_RelType(); + switch (from.RelType_case()) { + case kRead: { + _internal_mutable_read()->::io::substrait::ReadRel::MergeFrom(from._internal_read()); + break; + } + case kFilter: { + _internal_mutable_filter()->::io::substrait::FilterRel::MergeFrom(from._internal_filter()); + break; + } + case kFetch: { + _internal_mutable_fetch()->::io::substrait::FetchRel::MergeFrom(from._internal_fetch()); + break; + } + case kAggregate: { + _internal_mutable_aggregate()->::io::substrait::AggregateRel::MergeFrom(from._internal_aggregate()); + break; + } + case kSort: { + _internal_mutable_sort()->::io::substrait::SortRel::MergeFrom(from._internal_sort()); + break; + } + case kJoin: { + _internal_mutable_join()->::io::substrait::JoinRel::MergeFrom(from._internal_join()); + break; + } + case kProject: { + _internal_mutable_project()->::io::substrait::ProjectRel::MergeFrom(from._internal_project()); + break; + } + case kSet: { + _internal_mutable_set()->::io::substrait::SetRel::MergeFrom(from._internal_set()); + break; + } + case RELTYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Rel) +} + +void Rel::SharedCtor() { +clear_has_RelType(); +} + +Rel::~Rel() { + // @@protoc_insertion_point(destructor:io.substrait.Rel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Rel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_RelType()) { + clear_RelType(); + } +} + +void Rel::ArenaDtor(void* object) { + Rel* _this = reinterpret_cast< Rel* >(object); + (void)_this; +} +void Rel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Rel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Rel::clear_RelType() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Rel) + switch (RelType_case()) { + case kRead: { + if (GetArena() == nullptr) { + delete RelType_.read_; + } + break; + } + case kFilter: { + if (GetArena() == nullptr) { + delete RelType_.filter_; + } + break; + } + case kFetch: { + if (GetArena() == nullptr) { + delete RelType_.fetch_; + } + break; + } + case kAggregate: { + if (GetArena() == nullptr) { + delete RelType_.aggregate_; + } + break; + } + case kSort: { + if (GetArena() == nullptr) { + delete RelType_.sort_; + } + break; + } + case kJoin: { + if (GetArena() == nullptr) { + delete RelType_.join_; + } + break; + } + case kProject: { + if (GetArena() == nullptr) { + delete RelType_.project_; + } + break; + } + case kSet: { + if (GetArena() == nullptr) { + delete RelType_.set_; + } + break; + } + case RELTYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = RELTYPE_NOT_SET; +} + + +void Rel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Rel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_RelType(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Rel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ReadRel read = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_read(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FilterRel filter = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.FetchRel fetch = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_fetch(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.AggregateRel aggregate = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_aggregate(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.SortRel sort = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_sort(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.JoinRel join = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_join(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ProjectRel project = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_project(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.SetRel set = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_set(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Rel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ReadRel read = 1; + if (_internal_has_read()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::read(this), target, stream); + } + + // .io.substrait.FilterRel filter = 2; + if (_internal_has_filter()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::filter(this), target, stream); + } + + // .io.substrait.FetchRel fetch = 3; + if (_internal_has_fetch()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::fetch(this), target, stream); + } + + // .io.substrait.AggregateRel aggregate = 4; + if (_internal_has_aggregate()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::aggregate(this), target, stream); + } + + // .io.substrait.SortRel sort = 5; + if (_internal_has_sort()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::sort(this), target, stream); + } + + // .io.substrait.JoinRel join = 6; + if (_internal_has_join()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::join(this), target, stream); + } + + // .io.substrait.ProjectRel project = 7; + if (_internal_has_project()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::project(this), target, stream); + } + + // .io.substrait.SetRel set = 8; + if (_internal_has_set()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::set(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Rel) + return target; +} + +size_t Rel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Rel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (RelType_case()) { + // .io.substrait.ReadRel read = 1; + case kRead: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.read_); + break; + } + // .io.substrait.FilterRel filter = 2; + case kFilter: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.filter_); + break; + } + // .io.substrait.FetchRel fetch = 3; + case kFetch: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.fetch_); + break; + } + // .io.substrait.AggregateRel aggregate = 4; + case kAggregate: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.aggregate_); + break; + } + // .io.substrait.SortRel sort = 5; + case kSort: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.sort_); + break; + } + // .io.substrait.JoinRel join = 6; + case kJoin: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.join_); + break; + } + // .io.substrait.ProjectRel project = 7; + case kProject: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.project_); + break; + } + // .io.substrait.SetRel set = 8; + case kSet: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.set_); + break; + } + case RELTYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Rel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Rel) + GOOGLE_DCHECK_NE(&from, this); + const Rel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Rel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Rel) + MergeFrom(*source); + } +} + +void Rel::MergeFrom(const Rel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Rel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.RelType_case()) { + case kRead: { + _internal_mutable_read()->::io::substrait::ReadRel::MergeFrom(from._internal_read()); + break; + } + case kFilter: { + _internal_mutable_filter()->::io::substrait::FilterRel::MergeFrom(from._internal_filter()); + break; + } + case kFetch: { + _internal_mutable_fetch()->::io::substrait::FetchRel::MergeFrom(from._internal_fetch()); + break; + } + case kAggregate: { + _internal_mutable_aggregate()->::io::substrait::AggregateRel::MergeFrom(from._internal_aggregate()); + break; + } + case kSort: { + _internal_mutable_sort()->::io::substrait::SortRel::MergeFrom(from._internal_sort()); + break; + } + case kJoin: { + _internal_mutable_join()->::io::substrait::JoinRel::MergeFrom(from._internal_join()); + break; + } + case kProject: { + _internal_mutable_project()->::io::substrait::ProjectRel::MergeFrom(from._internal_project()); + break; + } + case kSet: { + _internal_mutable_set()->::io::substrait::SetRel::MergeFrom(from._internal_set()); + break; + } + case RELTYPE_NOT_SET: { + break; + } + } +} + +void Rel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Rel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Rel::CopyFrom(const Rel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Rel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Rel::IsInitialized() const { + return true; +} + +void Rel::InternalSwap(Rel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(RelType_, other->RelType_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Rel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[21]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Direct* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Direct >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Direct >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Emit* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Emit >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Emit >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Hint_Stats >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Hint_Stats >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Hint_HintKeyValue* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Hint_HintKeyValue >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Hint_HintKeyValue >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Hint* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Hint >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Hint >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_RuntimeConstraint* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_RuntimeConstraint >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::RelCommon_RuntimeConstraint >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon* Arena::CreateMaybeMessage< ::io::substrait::RelCommon >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::RelCommon >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_NamedTable >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReadRel_NamedTable >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_VirtualTable >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReadRel_VirtualTable >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_LocalFiles >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReadRel_LocalFiles >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel* Arena::CreateMaybeMessage< ::io::substrait::ReadRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReadRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ProjectRel* Arena::CreateMaybeMessage< ::io::substrait::ProjectRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ProjectRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::JoinRel* Arena::CreateMaybeMessage< ::io::substrait::JoinRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::JoinRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FetchRel* Arena::CreateMaybeMessage< ::io::substrait::FetchRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FetchRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage< ::io::substrait::AggregateRel_Grouping >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::AggregateRel_Grouping >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage< ::io::substrait::AggregateRel_Measure >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::AggregateRel_Measure >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::AggregateRel* Arena::CreateMaybeMessage< ::io::substrait::AggregateRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::AggregateRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::SortRel* Arena::CreateMaybeMessage< ::io::substrait::SortRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::SortRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FilterRel* Arena::CreateMaybeMessage< ::io::substrait::FilterRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FilterRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::SetRel* Arena::CreateMaybeMessage< ::io::substrait::SetRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::SetRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Rel* Arena::CreateMaybeMessage< ::io::substrait::Rel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Rel >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/relations.pb.h b/cpp/src/generated/substrait/relations.pb.h new file mode 100644 index 00000000000..f3bc61b48e9 --- /dev/null +++ b/cpp/src/generated/substrait/relations.pb.h @@ -0,0 +1,8315 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: relations.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_relations_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_relations_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +#include "type.pb.h" +#include "expression.pb.h" +#include "selection.pb.h" +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_relations_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_relations_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[22] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_relations_2eproto; +namespace io { +namespace substrait { +class AggregateRel; +struct AggregateRelDefaultTypeInternal; +extern AggregateRelDefaultTypeInternal _AggregateRel_default_instance_; +class AggregateRel_Grouping; +struct AggregateRel_GroupingDefaultTypeInternal; +extern AggregateRel_GroupingDefaultTypeInternal _AggregateRel_Grouping_default_instance_; +class AggregateRel_Measure; +struct AggregateRel_MeasureDefaultTypeInternal; +extern AggregateRel_MeasureDefaultTypeInternal _AggregateRel_Measure_default_instance_; +class FetchRel; +struct FetchRelDefaultTypeInternal; +extern FetchRelDefaultTypeInternal _FetchRel_default_instance_; +class FilterRel; +struct FilterRelDefaultTypeInternal; +extern FilterRelDefaultTypeInternal _FilterRel_default_instance_; +class JoinRel; +struct JoinRelDefaultTypeInternal; +extern JoinRelDefaultTypeInternal _JoinRel_default_instance_; +class ProjectRel; +struct ProjectRelDefaultTypeInternal; +extern ProjectRelDefaultTypeInternal _ProjectRel_default_instance_; +class ReadRel; +struct ReadRelDefaultTypeInternal; +extern ReadRelDefaultTypeInternal _ReadRel_default_instance_; +class ReadRel_LocalFiles; +struct ReadRel_LocalFilesDefaultTypeInternal; +extern ReadRel_LocalFilesDefaultTypeInternal _ReadRel_LocalFiles_default_instance_; +class ReadRel_LocalFiles_FileOrFiles; +struct ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal; +extern ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal _ReadRel_LocalFiles_FileOrFiles_default_instance_; +class ReadRel_NamedTable; +struct ReadRel_NamedTableDefaultTypeInternal; +extern ReadRel_NamedTableDefaultTypeInternal _ReadRel_NamedTable_default_instance_; +class ReadRel_VirtualTable; +struct ReadRel_VirtualTableDefaultTypeInternal; +extern ReadRel_VirtualTableDefaultTypeInternal _ReadRel_VirtualTable_default_instance_; +class Rel; +struct RelDefaultTypeInternal; +extern RelDefaultTypeInternal _Rel_default_instance_; +class RelCommon; +struct RelCommonDefaultTypeInternal; +extern RelCommonDefaultTypeInternal _RelCommon_default_instance_; +class RelCommon_Direct; +struct RelCommon_DirectDefaultTypeInternal; +extern RelCommon_DirectDefaultTypeInternal _RelCommon_Direct_default_instance_; +class RelCommon_Emit; +struct RelCommon_EmitDefaultTypeInternal; +extern RelCommon_EmitDefaultTypeInternal _RelCommon_Emit_default_instance_; +class RelCommon_Hint; +struct RelCommon_HintDefaultTypeInternal; +extern RelCommon_HintDefaultTypeInternal _RelCommon_Hint_default_instance_; +class RelCommon_Hint_HintKeyValue; +struct RelCommon_Hint_HintKeyValueDefaultTypeInternal; +extern RelCommon_Hint_HintKeyValueDefaultTypeInternal _RelCommon_Hint_HintKeyValue_default_instance_; +class RelCommon_Hint_Stats; +struct RelCommon_Hint_StatsDefaultTypeInternal; +extern RelCommon_Hint_StatsDefaultTypeInternal _RelCommon_Hint_Stats_default_instance_; +class RelCommon_RuntimeConstraint; +struct RelCommon_RuntimeConstraintDefaultTypeInternal; +extern RelCommon_RuntimeConstraintDefaultTypeInternal _RelCommon_RuntimeConstraint_default_instance_; +class SetRel; +struct SetRelDefaultTypeInternal; +extern SetRelDefaultTypeInternal _SetRel_default_instance_; +class SortRel; +struct SortRelDefaultTypeInternal; +extern SortRelDefaultTypeInternal _SortRel_default_instance_; +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::AggregateRel* Arena::CreateMaybeMessage<::io::substrait::AggregateRel>(Arena*); +template<> ::io::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage<::io::substrait::AggregateRel_Grouping>(Arena*); +template<> ::io::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage<::io::substrait::AggregateRel_Measure>(Arena*); +template<> ::io::substrait::FetchRel* Arena::CreateMaybeMessage<::io::substrait::FetchRel>(Arena*); +template<> ::io::substrait::FilterRel* Arena::CreateMaybeMessage<::io::substrait::FilterRel>(Arena*); +template<> ::io::substrait::JoinRel* Arena::CreateMaybeMessage<::io::substrait::JoinRel>(Arena*); +template<> ::io::substrait::ProjectRel* Arena::CreateMaybeMessage<::io::substrait::ProjectRel>(Arena*); +template<> ::io::substrait::ReadRel* Arena::CreateMaybeMessage<::io::substrait::ReadRel>(Arena*); +template<> ::io::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage<::io::substrait::ReadRel_LocalFiles>(Arena*); +template<> ::io::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage<::io::substrait::ReadRel_LocalFiles_FileOrFiles>(Arena*); +template<> ::io::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage<::io::substrait::ReadRel_NamedTable>(Arena*); +template<> ::io::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage<::io::substrait::ReadRel_VirtualTable>(Arena*); +template<> ::io::substrait::Rel* Arena::CreateMaybeMessage<::io::substrait::Rel>(Arena*); +template<> ::io::substrait::RelCommon* Arena::CreateMaybeMessage<::io::substrait::RelCommon>(Arena*); +template<> ::io::substrait::RelCommon_Direct* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Direct>(Arena*); +template<> ::io::substrait::RelCommon_Emit* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Emit>(Arena*); +template<> ::io::substrait::RelCommon_Hint* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Hint>(Arena*); +template<> ::io::substrait::RelCommon_Hint_HintKeyValue* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Hint_HintKeyValue>(Arena*); +template<> ::io::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Hint_Stats>(Arena*); +template<> ::io::substrait::RelCommon_RuntimeConstraint* Arena::CreateMaybeMessage<::io::substrait::RelCommon_RuntimeConstraint>(Arena*); +template<> ::io::substrait::SetRel* Arena::CreateMaybeMessage<::io::substrait::SetRel>(Arena*); +template<> ::io::substrait::SortRel* Arena::CreateMaybeMessage<::io::substrait::SortRel>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace io { +namespace substrait { + +enum ReadRel_LocalFiles_FileOrFiles_Format : int { + ReadRel_LocalFiles_FileOrFiles_Format_UNKNOWN = 0, + ReadRel_LocalFiles_FileOrFiles_Format_PARQUET = 1, + ReadRel_LocalFiles_FileOrFiles_Format_ReadRel_LocalFiles_FileOrFiles_Format_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + ReadRel_LocalFiles_FileOrFiles_Format_ReadRel_LocalFiles_FileOrFiles_Format_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool ReadRel_LocalFiles_FileOrFiles_Format_IsValid(int value); +constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles_Format_Format_MIN = ReadRel_LocalFiles_FileOrFiles_Format_UNKNOWN; +constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles_Format_Format_MAX = ReadRel_LocalFiles_FileOrFiles_Format_PARQUET; +constexpr int ReadRel_LocalFiles_FileOrFiles_Format_Format_ARRAYSIZE = ReadRel_LocalFiles_FileOrFiles_Format_Format_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_Format_descriptor(); +template +inline const std::string& ReadRel_LocalFiles_FileOrFiles_Format_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function ReadRel_LocalFiles_FileOrFiles_Format_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + ReadRel_LocalFiles_FileOrFiles_Format_descriptor(), enum_t_value); +} +inline bool ReadRel_LocalFiles_FileOrFiles_Format_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReadRel_LocalFiles_FileOrFiles_Format* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ReadRel_LocalFiles_FileOrFiles_Format_descriptor(), name, value); +} +enum JoinRel_JoinType : int { + JoinRel_JoinType_UNKNOWN = 0, + JoinRel_JoinType_INNER = 1, + JoinRel_JoinType_OUTER = 2, + JoinRel_JoinType_LEFT = 3, + JoinRel_JoinType_RIGHT = 4, + JoinRel_JoinType_JoinRel_JoinType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + JoinRel_JoinType_JoinRel_JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool JoinRel_JoinType_IsValid(int value); +constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MIN = JoinRel_JoinType_UNKNOWN; +constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MAX = JoinRel_JoinType_RIGHT; +constexpr int JoinRel_JoinType_JoinType_ARRAYSIZE = JoinRel_JoinType_JoinType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor(); +template +inline const std::string& JoinRel_JoinType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function JoinRel_JoinType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + JoinRel_JoinType_descriptor(), enum_t_value); +} +inline bool JoinRel_JoinType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JoinRel_JoinType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + JoinRel_JoinType_descriptor(), name, value); +} +enum SetRel_SetOp : int { + SetRel_SetOp_UNKNOWN = 0, + SetRel_SetOp_MINUS_PRIMARY = 1, + SetRel_SetOp_MINUS_MULTISET = 2, + SetRel_SetOp_INTERSECTION_PRIMARY = 3, + SetRel_SetOp_INTERSECTION_MULTISET = 4, + SetRel_SetOp_UNION_DISTINCT = 5, + SetRel_SetOp_UNION_ALL = 6, + SetRel_SetOp_SetRel_SetOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + SetRel_SetOp_SetRel_SetOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool SetRel_SetOp_IsValid(int value); +constexpr SetRel_SetOp SetRel_SetOp_SetOp_MIN = SetRel_SetOp_UNKNOWN; +constexpr SetRel_SetOp SetRel_SetOp_SetOp_MAX = SetRel_SetOp_UNION_ALL; +constexpr int SetRel_SetOp_SetOp_ARRAYSIZE = SetRel_SetOp_SetOp_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetRel_SetOp_descriptor(); +template +inline const std::string& SetRel_SetOp_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SetRel_SetOp_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + SetRel_SetOp_descriptor(), enum_t_value); +} +inline bool SetRel_SetOp_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SetRel_SetOp* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SetRel_SetOp_descriptor(), name, value); +} +// =================================================================== + +class RelCommon_Direct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Direct) */ { + public: + inline RelCommon_Direct() : RelCommon_Direct(nullptr) {} + ~RelCommon_Direct() override; + explicit constexpr RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RelCommon_Direct(const RelCommon_Direct& from); + RelCommon_Direct(RelCommon_Direct&& from) noexcept + : RelCommon_Direct() { + *this = ::std::move(from); + } + + inline RelCommon_Direct& operator=(const RelCommon_Direct& from) { + CopyFrom(from); + return *this; + } + inline RelCommon_Direct& operator=(RelCommon_Direct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 RelCommon_Direct& default_instance() { + return *internal_default_instance(); + } + static inline const RelCommon_Direct* internal_default_instance() { + return reinterpret_cast( + &_RelCommon_Direct_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(RelCommon_Direct& a, RelCommon_Direct& b) { + a.Swap(&b); + } + inline void Swap(RelCommon_Direct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RelCommon_Direct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RelCommon_Direct* New() const final { + return CreateMaybeMessage(nullptr); + } + + RelCommon_Direct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RelCommon_Direct& from); + void MergeFrom(const RelCommon_Direct& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RelCommon_Direct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.RelCommon.Direct"; + } + protected: + explicit RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Direct) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class RelCommon_Emit PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Emit) */ { + public: + inline RelCommon_Emit() : RelCommon_Emit(nullptr) {} + ~RelCommon_Emit() override; + explicit constexpr RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RelCommon_Emit(const RelCommon_Emit& from); + RelCommon_Emit(RelCommon_Emit&& from) noexcept + : RelCommon_Emit() { + *this = ::std::move(from); + } + + inline RelCommon_Emit& operator=(const RelCommon_Emit& from) { + CopyFrom(from); + return *this; + } + inline RelCommon_Emit& operator=(RelCommon_Emit&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 RelCommon_Emit& default_instance() { + return *internal_default_instance(); + } + static inline const RelCommon_Emit* internal_default_instance() { + return reinterpret_cast( + &_RelCommon_Emit_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(RelCommon_Emit& a, RelCommon_Emit& b) { + a.Swap(&b); + } + inline void Swap(RelCommon_Emit* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RelCommon_Emit* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RelCommon_Emit* New() const final { + return CreateMaybeMessage(nullptr); + } + + RelCommon_Emit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RelCommon_Emit& from); + void MergeFrom(const RelCommon_Emit& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RelCommon_Emit* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.RelCommon.Emit"; + } + protected: + explicit RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOutputMappingFieldNumber = 1, + }; + // repeated int32 output_mapping = 1; + int output_mapping_size() const; + private: + int _internal_output_mapping_size() const; + public: + void clear_output_mapping(); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_output_mapping(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + _internal_output_mapping() const; + void _internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + _internal_mutable_output_mapping(); + public: + ::PROTOBUF_NAMESPACE_ID::int32 output_mapping(int index) const; + void set_output_mapping(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); + void add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + output_mapping() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + mutable_output_mapping(); + + // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Emit) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > output_mapping_; + mutable std::atomic _output_mapping_cached_byte_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class RelCommon_Hint_Stats PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Hint.Stats) */ { + public: + inline RelCommon_Hint_Stats() : RelCommon_Hint_Stats(nullptr) {} + ~RelCommon_Hint_Stats() override; + explicit constexpr RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from); + RelCommon_Hint_Stats(RelCommon_Hint_Stats&& from) noexcept + : RelCommon_Hint_Stats() { + *this = ::std::move(from); + } + + inline RelCommon_Hint_Stats& operator=(const RelCommon_Hint_Stats& from) { + CopyFrom(from); + return *this; + } + inline RelCommon_Hint_Stats& operator=(RelCommon_Hint_Stats&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 RelCommon_Hint_Stats& default_instance() { + return *internal_default_instance(); + } + static inline const RelCommon_Hint_Stats* internal_default_instance() { + return reinterpret_cast( + &_RelCommon_Hint_Stats_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(RelCommon_Hint_Stats& a, RelCommon_Hint_Stats& b) { + a.Swap(&b); + } + inline void Swap(RelCommon_Hint_Stats* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RelCommon_Hint_Stats* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RelCommon_Hint_Stats* New() const final { + return CreateMaybeMessage(nullptr); + } + + RelCommon_Hint_Stats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RelCommon_Hint_Stats& from); + void MergeFrom(const RelCommon_Hint_Stats& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RelCommon_Hint_Stats* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.RelCommon.Hint.Stats"; + } + protected: + explicit RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRowCountFieldNumber = 1, + kRecordSizeFieldNumber = 2, + }; + // double row_count = 1; + void clear_row_count(); + double row_count() const; + void set_row_count(double value); + private: + double _internal_row_count() const; + void _internal_set_row_count(double value); + public: + + // double record_size = 2; + void clear_record_size(); + double record_size() const; + void set_record_size(double value); + private: + double _internal_record_size() const; + void _internal_set_record_size(double value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Hint.Stats) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + double row_count_; + double record_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class RelCommon_Hint_HintKeyValue PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Hint.HintKeyValue) */ { + public: + inline RelCommon_Hint_HintKeyValue() : RelCommon_Hint_HintKeyValue(nullptr) {} + ~RelCommon_Hint_HintKeyValue() override; + explicit constexpr RelCommon_Hint_HintKeyValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RelCommon_Hint_HintKeyValue(const RelCommon_Hint_HintKeyValue& from); + RelCommon_Hint_HintKeyValue(RelCommon_Hint_HintKeyValue&& from) noexcept + : RelCommon_Hint_HintKeyValue() { + *this = ::std::move(from); + } + + inline RelCommon_Hint_HintKeyValue& operator=(const RelCommon_Hint_HintKeyValue& from) { + CopyFrom(from); + return *this; + } + inline RelCommon_Hint_HintKeyValue& operator=(RelCommon_Hint_HintKeyValue&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 RelCommon_Hint_HintKeyValue& default_instance() { + return *internal_default_instance(); + } + static inline const RelCommon_Hint_HintKeyValue* internal_default_instance() { + return reinterpret_cast( + &_RelCommon_Hint_HintKeyValue_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(RelCommon_Hint_HintKeyValue& a, RelCommon_Hint_HintKeyValue& b) { + a.Swap(&b); + } + inline void Swap(RelCommon_Hint_HintKeyValue* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RelCommon_Hint_HintKeyValue* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RelCommon_Hint_HintKeyValue* New() const final { + return CreateMaybeMessage(nullptr); + } + + RelCommon_Hint_HintKeyValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RelCommon_Hint_HintKeyValue& from); + void MergeFrom(const RelCommon_Hint_HintKeyValue& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RelCommon_Hint_HintKeyValue* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.RelCommon.Hint.HintKeyValue"; + } + protected: + explicit RelCommon_Hint_HintKeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + }; + // string key = 1; + void clear_key(); + const std::string& key() const; + template + void set_key(ArgT0&& arg0, ArgT... args); + std::string* mutable_key(); + std::string* release_key(); + void set_allocated_key(std::string* key); + private: + const std::string& _internal_key() const; + void _internal_set_key(const std::string& value); + std::string* _internal_mutable_key(); + public: + + // bytes value = 2; + void clear_value(); + const std::string& value() const; + template + void set_value(ArgT0&& arg0, ArgT... args); + std::string* mutable_value(); + std::string* release_value(); + void set_allocated_value(std::string* value); + private: + const std::string& _internal_value() const; + void _internal_set_value(const std::string& value); + std::string* _internal_mutable_value(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Hint.HintKeyValue) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class RelCommon_Hint PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Hint) */ { + public: + inline RelCommon_Hint() : RelCommon_Hint(nullptr) {} + ~RelCommon_Hint() override; + explicit constexpr RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RelCommon_Hint(const RelCommon_Hint& from); + RelCommon_Hint(RelCommon_Hint&& from) noexcept + : RelCommon_Hint() { + *this = ::std::move(from); + } + + inline RelCommon_Hint& operator=(const RelCommon_Hint& from) { + CopyFrom(from); + return *this; + } + inline RelCommon_Hint& operator=(RelCommon_Hint&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 RelCommon_Hint& default_instance() { + return *internal_default_instance(); + } + static inline const RelCommon_Hint* internal_default_instance() { + return reinterpret_cast( + &_RelCommon_Hint_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(RelCommon_Hint& a, RelCommon_Hint& b) { + a.Swap(&b); + } + inline void Swap(RelCommon_Hint* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RelCommon_Hint* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RelCommon_Hint* New() const final { + return CreateMaybeMessage(nullptr); + } + + RelCommon_Hint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RelCommon_Hint& from); + void MergeFrom(const RelCommon_Hint& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RelCommon_Hint* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.RelCommon.Hint"; + } + protected: + explicit RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef RelCommon_Hint_Stats Stats; + typedef RelCommon_Hint_HintKeyValue HintKeyValue; + + // accessors ------------------------------------------------------- + + enum : int { + kHintKeyValuesFieldNumber = 1, + kStatsFieldNumber = 2, + }; + // repeated .io.substrait.RelCommon.Hint.HintKeyValue hint_key_values = 1; + int hint_key_values_size() const; + private: + int _internal_hint_key_values_size() const; + public: + void clear_hint_key_values(); + ::io::substrait::RelCommon_Hint_HintKeyValue* mutable_hint_key_values(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::RelCommon_Hint_HintKeyValue >* + mutable_hint_key_values(); + private: + const ::io::substrait::RelCommon_Hint_HintKeyValue& _internal_hint_key_values(int index) const; + ::io::substrait::RelCommon_Hint_HintKeyValue* _internal_add_hint_key_values(); + public: + const ::io::substrait::RelCommon_Hint_HintKeyValue& hint_key_values(int index) const; + ::io::substrait::RelCommon_Hint_HintKeyValue* add_hint_key_values(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::RelCommon_Hint_HintKeyValue >& + hint_key_values() const; + + // .io.substrait.RelCommon.Hint.Stats stats = 2; + bool has_stats() const; + private: + bool _internal_has_stats() const; + public: + void clear_stats(); + const ::io::substrait::RelCommon_Hint_Stats& stats() const; + ::io::substrait::RelCommon_Hint_Stats* release_stats(); + ::io::substrait::RelCommon_Hint_Stats* mutable_stats(); + void set_allocated_stats(::io::substrait::RelCommon_Hint_Stats* stats); + private: + const ::io::substrait::RelCommon_Hint_Stats& _internal_stats() const; + ::io::substrait::RelCommon_Hint_Stats* _internal_mutable_stats(); + public: + void unsafe_arena_set_allocated_stats( + ::io::substrait::RelCommon_Hint_Stats* stats); + ::io::substrait::RelCommon_Hint_Stats* unsafe_arena_release_stats(); + + // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Hint) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::RelCommon_Hint_HintKeyValue > hint_key_values_; + ::io::substrait::RelCommon_Hint_Stats* stats_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class RelCommon_RuntimeConstraint PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.RuntimeConstraint) */ { + public: + inline RelCommon_RuntimeConstraint() : RelCommon_RuntimeConstraint(nullptr) {} + ~RelCommon_RuntimeConstraint() override; + explicit constexpr RelCommon_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RelCommon_RuntimeConstraint(const RelCommon_RuntimeConstraint& from); + RelCommon_RuntimeConstraint(RelCommon_RuntimeConstraint&& from) noexcept + : RelCommon_RuntimeConstraint() { + *this = ::std::move(from); + } + + inline RelCommon_RuntimeConstraint& operator=(const RelCommon_RuntimeConstraint& from) { + CopyFrom(from); + return *this; + } + inline RelCommon_RuntimeConstraint& operator=(RelCommon_RuntimeConstraint&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 RelCommon_RuntimeConstraint& default_instance() { + return *internal_default_instance(); + } + static inline const RelCommon_RuntimeConstraint* internal_default_instance() { + return reinterpret_cast( + &_RelCommon_RuntimeConstraint_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(RelCommon_RuntimeConstraint& a, RelCommon_RuntimeConstraint& b) { + a.Swap(&b); + } + inline void Swap(RelCommon_RuntimeConstraint* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RelCommon_RuntimeConstraint* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RelCommon_RuntimeConstraint* New() const final { + return CreateMaybeMessage(nullptr); + } + + RelCommon_RuntimeConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RelCommon_RuntimeConstraint& from); + void MergeFrom(const RelCommon_RuntimeConstraint& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RelCommon_RuntimeConstraint* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.RelCommon.RuntimeConstraint"; + } + protected: + explicit RelCommon_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.RuntimeConstraint) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class RelCommon PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon) */ { + public: + inline RelCommon() : RelCommon(nullptr) {} + ~RelCommon() override; + explicit constexpr RelCommon(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RelCommon(const RelCommon& from); + RelCommon(RelCommon&& from) noexcept + : RelCommon() { + *this = ::std::move(from); + } + + inline RelCommon& operator=(const RelCommon& from) { + CopyFrom(from); + return *this; + } + inline RelCommon& operator=(RelCommon&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 RelCommon& default_instance() { + return *internal_default_instance(); + } + enum KindCase { + kDirect = 1, + kEmit = 2, + KIND_NOT_SET = 0, + }; + + static inline const RelCommon* internal_default_instance() { + return reinterpret_cast( + &_RelCommon_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(RelCommon& a, RelCommon& b) { + a.Swap(&b); + } + inline void Swap(RelCommon* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RelCommon* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RelCommon* New() const final { + return CreateMaybeMessage(nullptr); + } + + RelCommon* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RelCommon& from); + void MergeFrom(const RelCommon& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RelCommon* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.RelCommon"; + } + protected: + explicit RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef RelCommon_Direct Direct; + typedef RelCommon_Emit Emit; + typedef RelCommon_Hint Hint; + typedef RelCommon_RuntimeConstraint RuntimeConstraint; + + // accessors ------------------------------------------------------- + + enum : int { + kHintFieldNumber = 3, + kConstraintFieldNumber = 4, + kDirectFieldNumber = 1, + kEmitFieldNumber = 2, + }; + // .io.substrait.RelCommon.Hint hint = 3; + bool has_hint() const; + private: + bool _internal_has_hint() const; + public: + void clear_hint(); + const ::io::substrait::RelCommon_Hint& hint() const; + ::io::substrait::RelCommon_Hint* release_hint(); + ::io::substrait::RelCommon_Hint* mutable_hint(); + void set_allocated_hint(::io::substrait::RelCommon_Hint* hint); + private: + const ::io::substrait::RelCommon_Hint& _internal_hint() const; + ::io::substrait::RelCommon_Hint* _internal_mutable_hint(); + public: + void unsafe_arena_set_allocated_hint( + ::io::substrait::RelCommon_Hint* hint); + ::io::substrait::RelCommon_Hint* unsafe_arena_release_hint(); + + // .io.substrait.RelCommon.RuntimeConstraint constraint = 4; + bool has_constraint() const; + private: + bool _internal_has_constraint() const; + public: + void clear_constraint(); + const ::io::substrait::RelCommon_RuntimeConstraint& constraint() const; + ::io::substrait::RelCommon_RuntimeConstraint* release_constraint(); + ::io::substrait::RelCommon_RuntimeConstraint* mutable_constraint(); + void set_allocated_constraint(::io::substrait::RelCommon_RuntimeConstraint* constraint); + private: + const ::io::substrait::RelCommon_RuntimeConstraint& _internal_constraint() const; + ::io::substrait::RelCommon_RuntimeConstraint* _internal_mutable_constraint(); + public: + void unsafe_arena_set_allocated_constraint( + ::io::substrait::RelCommon_RuntimeConstraint* constraint); + ::io::substrait::RelCommon_RuntimeConstraint* unsafe_arena_release_constraint(); + + // .io.substrait.RelCommon.Direct direct = 1; + bool has_direct() const; + private: + bool _internal_has_direct() const; + public: + void clear_direct(); + const ::io::substrait::RelCommon_Direct& direct() const; + ::io::substrait::RelCommon_Direct* release_direct(); + ::io::substrait::RelCommon_Direct* mutable_direct(); + void set_allocated_direct(::io::substrait::RelCommon_Direct* direct); + private: + const ::io::substrait::RelCommon_Direct& _internal_direct() const; + ::io::substrait::RelCommon_Direct* _internal_mutable_direct(); + public: + void unsafe_arena_set_allocated_direct( + ::io::substrait::RelCommon_Direct* direct); + ::io::substrait::RelCommon_Direct* unsafe_arena_release_direct(); + + // .io.substrait.RelCommon.Emit emit = 2; + bool has_emit() const; + private: + bool _internal_has_emit() const; + public: + void clear_emit(); + const ::io::substrait::RelCommon_Emit& emit() const; + ::io::substrait::RelCommon_Emit* release_emit(); + ::io::substrait::RelCommon_Emit* mutable_emit(); + void set_allocated_emit(::io::substrait::RelCommon_Emit* emit); + private: + const ::io::substrait::RelCommon_Emit& _internal_emit() const; + ::io::substrait::RelCommon_Emit* _internal_mutable_emit(); + public: + void unsafe_arena_set_allocated_emit( + ::io::substrait::RelCommon_Emit* emit); + ::io::substrait::RelCommon_Emit* unsafe_arena_release_emit(); + + void clear_kind(); + KindCase kind_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.RelCommon) + private: + class _Internal; + void set_has_direct(); + void set_has_emit(); + + inline bool has_kind() const; + inline void clear_has_kind(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::RelCommon_Hint* hint_; + ::io::substrait::RelCommon_RuntimeConstraint* constraint_; + union KindUnion { + constexpr KindUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::RelCommon_Direct* direct_; + ::io::substrait::RelCommon_Emit* emit_; + } kind_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class ReadRel_NamedTable PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.NamedTable) */ { + public: + inline ReadRel_NamedTable() : ReadRel_NamedTable(nullptr) {} + ~ReadRel_NamedTable() override; + explicit constexpr ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReadRel_NamedTable(const ReadRel_NamedTable& from); + ReadRel_NamedTable(ReadRel_NamedTable&& from) noexcept + : ReadRel_NamedTable() { + *this = ::std::move(from); + } + + inline ReadRel_NamedTable& operator=(const ReadRel_NamedTable& from) { + CopyFrom(from); + return *this; + } + inline ReadRel_NamedTable& operator=(ReadRel_NamedTable&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReadRel_NamedTable& default_instance() { + return *internal_default_instance(); + } + static inline const ReadRel_NamedTable* internal_default_instance() { + return reinterpret_cast( + &_ReadRel_NamedTable_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(ReadRel_NamedTable& a, ReadRel_NamedTable& b) { + a.Swap(&b); + } + inline void Swap(ReadRel_NamedTable* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReadRel_NamedTable* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReadRel_NamedTable* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReadRel_NamedTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReadRel_NamedTable& from); + void MergeFrom(const ReadRel_NamedTable& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReadRel_NamedTable* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReadRel.NamedTable"; + } + protected: + explicit ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNamesFieldNumber = 1, + }; + // repeated string names = 1; + int names_size() const; + private: + int _internal_names_size() const; + public: + void clear_names(); + const std::string& names(int index) const; + std::string* mutable_names(int index); + void set_names(int index, const std::string& value); + void set_names(int index, std::string&& value); + void set_names(int index, const char* value); + void set_names(int index, const char* value, size_t size); + std::string* add_names(); + void add_names(const std::string& value); + void add_names(std::string&& value); + void add_names(const char* value); + void add_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); + private: + const std::string& _internal_names(int index) const; + std::string* _internal_add_names(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.NamedTable) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class ReadRel_VirtualTable PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.VirtualTable) */ { + public: + inline ReadRel_VirtualTable() : ReadRel_VirtualTable(nullptr) {} + ~ReadRel_VirtualTable() override; + explicit constexpr ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReadRel_VirtualTable(const ReadRel_VirtualTable& from); + ReadRel_VirtualTable(ReadRel_VirtualTable&& from) noexcept + : ReadRel_VirtualTable() { + *this = ::std::move(from); + } + + inline ReadRel_VirtualTable& operator=(const ReadRel_VirtualTable& from) { + CopyFrom(from); + return *this; + } + inline ReadRel_VirtualTable& operator=(ReadRel_VirtualTable&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReadRel_VirtualTable& default_instance() { + return *internal_default_instance(); + } + static inline const ReadRel_VirtualTable* internal_default_instance() { + return reinterpret_cast( + &_ReadRel_VirtualTable_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(ReadRel_VirtualTable& a, ReadRel_VirtualTable& b) { + a.Swap(&b); + } + inline void Swap(ReadRel_VirtualTable* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReadRel_VirtualTable* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReadRel_VirtualTable* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReadRel_VirtualTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReadRel_VirtualTable& from); + void MergeFrom(const ReadRel_VirtualTable& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReadRel_VirtualTable* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReadRel.VirtualTable"; + } + protected: + explicit ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kValuesFieldNumber = 1, + }; + // repeated .io.substrait.Expression.Literal.Struct values = 1; + int values_size() const; + private: + int _internal_values_size() const; + public: + void clear_values(); + ::io::substrait::Expression_Literal_Struct* mutable_values(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >* + mutable_values(); + private: + const ::io::substrait::Expression_Literal_Struct& _internal_values(int index) const; + ::io::substrait::Expression_Literal_Struct* _internal_add_values(); + public: + const ::io::substrait::Expression_Literal_Struct& values(int index) const; + ::io::substrait::Expression_Literal_Struct* add_values(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >& + values() const; + + // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.VirtualTable) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct > values_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.LocalFiles.FileOrFiles) */ { + public: + inline ReadRel_LocalFiles_FileOrFiles() : ReadRel_LocalFiles_FileOrFiles(nullptr) {} + ~ReadRel_LocalFiles_FileOrFiles() override; + explicit constexpr ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from); + ReadRel_LocalFiles_FileOrFiles(ReadRel_LocalFiles_FileOrFiles&& from) noexcept + : ReadRel_LocalFiles_FileOrFiles() { + *this = ::std::move(from); + } + + inline ReadRel_LocalFiles_FileOrFiles& operator=(const ReadRel_LocalFiles_FileOrFiles& from) { + CopyFrom(from); + return *this; + } + inline ReadRel_LocalFiles_FileOrFiles& operator=(ReadRel_LocalFiles_FileOrFiles&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReadRel_LocalFiles_FileOrFiles& default_instance() { + return *internal_default_instance(); + } + enum PathTypeCase { + kUriPath = 1, + kUriPathGlob = 2, + PATH_TYPE_NOT_SET = 0, + }; + + static inline const ReadRel_LocalFiles_FileOrFiles* internal_default_instance() { + return reinterpret_cast( + &_ReadRel_LocalFiles_FileOrFiles_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(ReadRel_LocalFiles_FileOrFiles& a, ReadRel_LocalFiles_FileOrFiles& b) { + a.Swap(&b); + } + inline void Swap(ReadRel_LocalFiles_FileOrFiles* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReadRel_LocalFiles_FileOrFiles* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReadRel_LocalFiles_FileOrFiles* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReadRel_LocalFiles_FileOrFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReadRel_LocalFiles_FileOrFiles& from); + void MergeFrom(const ReadRel_LocalFiles_FileOrFiles& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReadRel_LocalFiles_FileOrFiles* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReadRel.LocalFiles.FileOrFiles"; + } + protected: + explicit ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ReadRel_LocalFiles_FileOrFiles_Format Format; + static constexpr Format UNKNOWN = + ReadRel_LocalFiles_FileOrFiles_Format_UNKNOWN; + static constexpr Format PARQUET = + ReadRel_LocalFiles_FileOrFiles_Format_PARQUET; + static inline bool Format_IsValid(int value) { + return ReadRel_LocalFiles_FileOrFiles_Format_IsValid(value); + } + static constexpr Format Format_MIN = + ReadRel_LocalFiles_FileOrFiles_Format_Format_MIN; + static constexpr Format Format_MAX = + ReadRel_LocalFiles_FileOrFiles_Format_Format_MAX; + static constexpr int Format_ARRAYSIZE = + ReadRel_LocalFiles_FileOrFiles_Format_Format_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Format_descriptor() { + return ReadRel_LocalFiles_FileOrFiles_Format_descriptor(); + } + template + static inline const std::string& Format_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Format_Name."); + return ReadRel_LocalFiles_FileOrFiles_Format_Name(enum_t_value); + } + static inline bool Format_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Format* value) { + return ReadRel_LocalFiles_FileOrFiles_Format_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kFormatFieldNumber = 3, + kUriPathFieldNumber = 1, + kUriPathGlobFieldNumber = 2, + }; + // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 3; + void clear_format(); + ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format format() const; + void set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value); + private: + ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format _internal_format() const; + void _internal_set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value); + public: + + // string uri_path = 1; + bool has_uri_path() const; + private: + bool _internal_has_uri_path() const; + public: + void clear_uri_path(); + const std::string& uri_path() const; + template + void set_uri_path(ArgT0&& arg0, ArgT... args); + std::string* mutable_uri_path(); + std::string* release_uri_path(); + void set_allocated_uri_path(std::string* uri_path); + private: + const std::string& _internal_uri_path() const; + void _internal_set_uri_path(const std::string& value); + std::string* _internal_mutable_uri_path(); + public: + + // string uri_path_glob = 2; + bool has_uri_path_glob() const; + private: + bool _internal_has_uri_path_glob() const; + public: + void clear_uri_path_glob(); + const std::string& uri_path_glob() const; + template + void set_uri_path_glob(ArgT0&& arg0, ArgT... args); + std::string* mutable_uri_path_glob(); + std::string* release_uri_path_glob(); + void set_allocated_uri_path_glob(std::string* uri_path_glob); + private: + const std::string& _internal_uri_path_glob() const; + void _internal_set_uri_path_glob(const std::string& value); + std::string* _internal_mutable_uri_path_glob(); + public: + + void clear_path_type(); + PathTypeCase path_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.LocalFiles.FileOrFiles) + private: + class _Internal; + void set_has_uri_path(); + void set_has_uri_path_glob(); + + inline bool has_path_type() const; + inline void clear_has_path_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + int format_; + union PathTypeUnion { + constexpr PathTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_path_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_path_glob_; + } path_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class ReadRel_LocalFiles PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.LocalFiles) */ { + public: + inline ReadRel_LocalFiles() : ReadRel_LocalFiles(nullptr) {} + ~ReadRel_LocalFiles() override; + explicit constexpr ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReadRel_LocalFiles(const ReadRel_LocalFiles& from); + ReadRel_LocalFiles(ReadRel_LocalFiles&& from) noexcept + : ReadRel_LocalFiles() { + *this = ::std::move(from); + } + + inline ReadRel_LocalFiles& operator=(const ReadRel_LocalFiles& from) { + CopyFrom(from); + return *this; + } + inline ReadRel_LocalFiles& operator=(ReadRel_LocalFiles&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReadRel_LocalFiles& default_instance() { + return *internal_default_instance(); + } + static inline const ReadRel_LocalFiles* internal_default_instance() { + return reinterpret_cast( + &_ReadRel_LocalFiles_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(ReadRel_LocalFiles& a, ReadRel_LocalFiles& b) { + a.Swap(&b); + } + inline void Swap(ReadRel_LocalFiles* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReadRel_LocalFiles* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReadRel_LocalFiles* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReadRel_LocalFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReadRel_LocalFiles& from); + void MergeFrom(const ReadRel_LocalFiles& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReadRel_LocalFiles* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReadRel.LocalFiles"; + } + protected: + explicit ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ReadRel_LocalFiles_FileOrFiles FileOrFiles; + + // accessors ------------------------------------------------------- + + enum : int { + kItemsFieldNumber = 1, + }; + // repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; + int items_size() const; + private: + int _internal_items_size() const; + public: + void clear_items(); + ::io::substrait::ReadRel_LocalFiles_FileOrFiles* mutable_items(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >* + mutable_items(); + private: + const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& _internal_items(int index) const; + ::io::substrait::ReadRel_LocalFiles_FileOrFiles* _internal_add_items(); + public: + const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& items(int index) const; + ::io::substrait::ReadRel_LocalFiles_FileOrFiles* add_items(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >& + items() const; + + // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.LocalFiles) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles > items_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class ReadRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel) */ { + public: + inline ReadRel() : ReadRel(nullptr) {} + ~ReadRel() override; + explicit constexpr ReadRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReadRel(const ReadRel& from); + ReadRel(ReadRel&& from) noexcept + : ReadRel() { + *this = ::std::move(from); + } + + inline ReadRel& operator=(const ReadRel& from) { + CopyFrom(from); + return *this; + } + inline ReadRel& operator=(ReadRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReadRel& default_instance() { + return *internal_default_instance(); + } + enum ReadTypeCase { + kVirtualTable = 5, + kLocalFiles = 6, + kNamedTable = 7, + READ_TYPE_NOT_SET = 0, + }; + + static inline const ReadRel* internal_default_instance() { + return reinterpret_cast( + &_ReadRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(ReadRel& a, ReadRel& b) { + a.Swap(&b); + } + inline void Swap(ReadRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReadRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReadRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReadRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReadRel& from); + void MergeFrom(const ReadRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReadRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReadRel"; + } + protected: + explicit ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ReadRel_NamedTable NamedTable; + typedef ReadRel_VirtualTable VirtualTable; + typedef ReadRel_LocalFiles LocalFiles; + + // accessors ------------------------------------------------------- + + enum : int { + kCommonFieldNumber = 1, + kBaseSchemaFieldNumber = 2, + kFilterFieldNumber = 3, + kProjectionFieldNumber = 4, + kVirtualTableFieldNumber = 5, + kLocalFilesFieldNumber = 6, + kNamedTableFieldNumber = 7, + }; + // .io.substrait.RelCommon common = 1; + bool has_common() const; + private: + bool _internal_has_common() const; + public: + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); + private: + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); + public: + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); + + // .io.substrait.Type.NamedStruct base_schema = 2; + bool has_base_schema() const; + private: + bool _internal_has_base_schema() const; + public: + void clear_base_schema(); + const ::io::substrait::Type_NamedStruct& base_schema() const; + ::io::substrait::Type_NamedStruct* release_base_schema(); + ::io::substrait::Type_NamedStruct* mutable_base_schema(); + void set_allocated_base_schema(::io::substrait::Type_NamedStruct* base_schema); + private: + const ::io::substrait::Type_NamedStruct& _internal_base_schema() const; + ::io::substrait::Type_NamedStruct* _internal_mutable_base_schema(); + public: + void unsafe_arena_set_allocated_base_schema( + ::io::substrait::Type_NamedStruct* base_schema); + ::io::substrait::Type_NamedStruct* unsafe_arena_release_base_schema(); + + // .io.substrait.Expression filter = 3; + bool has_filter() const; + private: + bool _internal_has_filter() const; + public: + void clear_filter(); + const ::io::substrait::Expression& filter() const; + ::io::substrait::Expression* release_filter(); + ::io::substrait::Expression* mutable_filter(); + void set_allocated_filter(::io::substrait::Expression* filter); + private: + const ::io::substrait::Expression& _internal_filter() const; + ::io::substrait::Expression* _internal_mutable_filter(); + public: + void unsafe_arena_set_allocated_filter( + ::io::substrait::Expression* filter); + ::io::substrait::Expression* unsafe_arena_release_filter(); + + // .io.substrait.MaskExpression projection = 4; + bool has_projection() const; + private: + bool _internal_has_projection() const; + public: + void clear_projection(); + const ::io::substrait::MaskExpression& projection() const; + ::io::substrait::MaskExpression* release_projection(); + ::io::substrait::MaskExpression* mutable_projection(); + void set_allocated_projection(::io::substrait::MaskExpression* projection); + private: + const ::io::substrait::MaskExpression& _internal_projection() const; + ::io::substrait::MaskExpression* _internal_mutable_projection(); + public: + void unsafe_arena_set_allocated_projection( + ::io::substrait::MaskExpression* projection); + ::io::substrait::MaskExpression* unsafe_arena_release_projection(); + + // .io.substrait.ReadRel.VirtualTable virtual_table = 5; + bool has_virtual_table() const; + private: + bool _internal_has_virtual_table() const; + public: + void clear_virtual_table(); + const ::io::substrait::ReadRel_VirtualTable& virtual_table() const; + ::io::substrait::ReadRel_VirtualTable* release_virtual_table(); + ::io::substrait::ReadRel_VirtualTable* mutable_virtual_table(); + void set_allocated_virtual_table(::io::substrait::ReadRel_VirtualTable* virtual_table); + private: + const ::io::substrait::ReadRel_VirtualTable& _internal_virtual_table() const; + ::io::substrait::ReadRel_VirtualTable* _internal_mutable_virtual_table(); + public: + void unsafe_arena_set_allocated_virtual_table( + ::io::substrait::ReadRel_VirtualTable* virtual_table); + ::io::substrait::ReadRel_VirtualTable* unsafe_arena_release_virtual_table(); + + // .io.substrait.ReadRel.LocalFiles local_files = 6; + bool has_local_files() const; + private: + bool _internal_has_local_files() const; + public: + void clear_local_files(); + const ::io::substrait::ReadRel_LocalFiles& local_files() const; + ::io::substrait::ReadRel_LocalFiles* release_local_files(); + ::io::substrait::ReadRel_LocalFiles* mutable_local_files(); + void set_allocated_local_files(::io::substrait::ReadRel_LocalFiles* local_files); + private: + const ::io::substrait::ReadRel_LocalFiles& _internal_local_files() const; + ::io::substrait::ReadRel_LocalFiles* _internal_mutable_local_files(); + public: + void unsafe_arena_set_allocated_local_files( + ::io::substrait::ReadRel_LocalFiles* local_files); + ::io::substrait::ReadRel_LocalFiles* unsafe_arena_release_local_files(); + + // .io.substrait.ReadRel.NamedTable named_table = 7; + bool has_named_table() const; + private: + bool _internal_has_named_table() const; + public: + void clear_named_table(); + const ::io::substrait::ReadRel_NamedTable& named_table() const; + ::io::substrait::ReadRel_NamedTable* release_named_table(); + ::io::substrait::ReadRel_NamedTable* mutable_named_table(); + void set_allocated_named_table(::io::substrait::ReadRel_NamedTable* named_table); + private: + const ::io::substrait::ReadRel_NamedTable& _internal_named_table() const; + ::io::substrait::ReadRel_NamedTable* _internal_mutable_named_table(); + public: + void unsafe_arena_set_allocated_named_table( + ::io::substrait::ReadRel_NamedTable* named_table); + ::io::substrait::ReadRel_NamedTable* unsafe_arena_release_named_table(); + + void clear_read_type(); + ReadTypeCase read_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.ReadRel) + private: + class _Internal; + void set_has_virtual_table(); + void set_has_local_files(); + void set_has_named_table(); + + inline bool has_read_type() const; + inline void clear_has_read_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::RelCommon* common_; + ::io::substrait::Type_NamedStruct* base_schema_; + ::io::substrait::Expression* filter_; + ::io::substrait::MaskExpression* projection_; + union ReadTypeUnion { + constexpr ReadTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::ReadRel_VirtualTable* virtual_table_; + ::io::substrait::ReadRel_LocalFiles* local_files_; + ::io::substrait::ReadRel_NamedTable* named_table_; + } read_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class ProjectRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ProjectRel) */ { + public: + inline ProjectRel() : ProjectRel(nullptr) {} + ~ProjectRel() override; + explicit constexpr ProjectRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ProjectRel(const ProjectRel& from); + ProjectRel(ProjectRel&& from) noexcept + : ProjectRel() { + *this = ::std::move(from); + } + + inline ProjectRel& operator=(const ProjectRel& from) { + CopyFrom(from); + return *this; + } + inline ProjectRel& operator=(ProjectRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ProjectRel& default_instance() { + return *internal_default_instance(); + } + static inline const ProjectRel* internal_default_instance() { + return reinterpret_cast( + &_ProjectRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(ProjectRel& a, ProjectRel& b) { + a.Swap(&b); + } + inline void Swap(ProjectRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ProjectRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ProjectRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + ProjectRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ProjectRel& from); + void MergeFrom(const ProjectRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ProjectRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ProjectRel"; + } + protected: + explicit ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kExpressionsFieldNumber = 3, + kCommonFieldNumber = 1, + kInputFieldNumber = 2, + }; + // repeated .io.substrait.Expression expressions = 3; + int expressions_size() const; + private: + int _internal_expressions_size() const; + public: + void clear_expressions(); + ::io::substrait::Expression* mutable_expressions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + mutable_expressions(); + private: + const ::io::substrait::Expression& _internal_expressions(int index) const; + ::io::substrait::Expression* _internal_add_expressions(); + public: + const ::io::substrait::Expression& expressions(int index) const; + ::io::substrait::Expression* add_expressions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + expressions() const; + + // .io.substrait.RelCommon common = 1; + bool has_common() const; + private: + bool _internal_has_common() const; + public: + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); + private: + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); + public: + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); + + // .io.substrait.Rel input = 2; + bool has_input() const; + private: + bool _internal_has_input() const; + public: + void clear_input(); + const ::io::substrait::Rel& input() const; + ::io::substrait::Rel* release_input(); + ::io::substrait::Rel* mutable_input(); + void set_allocated_input(::io::substrait::Rel* input); + private: + const ::io::substrait::Rel& _internal_input() const; + ::io::substrait::Rel* _internal_mutable_input(); + public: + void unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input); + ::io::substrait::Rel* unsafe_arena_release_input(); + + // @@protoc_insertion_point(class_scope:io.substrait.ProjectRel) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > expressions_; + ::io::substrait::RelCommon* common_; + ::io::substrait::Rel* input_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class JoinRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.JoinRel) */ { + public: + inline JoinRel() : JoinRel(nullptr) {} + ~JoinRel() override; + explicit constexpr JoinRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + JoinRel(const JoinRel& from); + JoinRel(JoinRel&& from) noexcept + : JoinRel() { + *this = ::std::move(from); + } + + inline JoinRel& operator=(const JoinRel& from) { + CopyFrom(from); + return *this; + } + inline JoinRel& operator=(JoinRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 JoinRel& default_instance() { + return *internal_default_instance(); + } + static inline const JoinRel* internal_default_instance() { + return reinterpret_cast( + &_JoinRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(JoinRel& a, JoinRel& b) { + a.Swap(&b); + } + inline void Swap(JoinRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(JoinRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline JoinRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + JoinRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const JoinRel& from); + void MergeFrom(const JoinRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(JoinRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.JoinRel"; + } + protected: + explicit JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef JoinRel_JoinType JoinType; + static constexpr JoinType UNKNOWN = + JoinRel_JoinType_UNKNOWN; + static constexpr JoinType INNER = + JoinRel_JoinType_INNER; + static constexpr JoinType OUTER = + JoinRel_JoinType_OUTER; + static constexpr JoinType LEFT = + JoinRel_JoinType_LEFT; + static constexpr JoinType RIGHT = + JoinRel_JoinType_RIGHT; + static inline bool JoinType_IsValid(int value) { + return JoinRel_JoinType_IsValid(value); + } + static constexpr JoinType JoinType_MIN = + JoinRel_JoinType_JoinType_MIN; + static constexpr JoinType JoinType_MAX = + JoinRel_JoinType_JoinType_MAX; + static constexpr int JoinType_ARRAYSIZE = + JoinRel_JoinType_JoinType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + JoinType_descriptor() { + return JoinRel_JoinType_descriptor(); + } + template + static inline const std::string& JoinType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function JoinType_Name."); + return JoinRel_JoinType_Name(enum_t_value); + } + static inline bool JoinType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + JoinType* value) { + return JoinRel_JoinType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kCommonFieldNumber = 1, + kLeftFieldNumber = 2, + kRightFieldNumber = 3, + kExpressionFieldNumber = 4, + kPostJoinFilterFieldNumber = 5, + kTypeFieldNumber = 6, + }; + // .io.substrait.RelCommon common = 1; + bool has_common() const; + private: + bool _internal_has_common() const; + public: + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); + private: + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); + public: + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); + + // .io.substrait.Rel left = 2; + bool has_left() const; + private: + bool _internal_has_left() const; + public: + void clear_left(); + const ::io::substrait::Rel& left() const; + ::io::substrait::Rel* release_left(); + ::io::substrait::Rel* mutable_left(); + void set_allocated_left(::io::substrait::Rel* left); + private: + const ::io::substrait::Rel& _internal_left() const; + ::io::substrait::Rel* _internal_mutable_left(); + public: + void unsafe_arena_set_allocated_left( + ::io::substrait::Rel* left); + ::io::substrait::Rel* unsafe_arena_release_left(); + + // .io.substrait.Rel right = 3; + bool has_right() const; + private: + bool _internal_has_right() const; + public: + void clear_right(); + const ::io::substrait::Rel& right() const; + ::io::substrait::Rel* release_right(); + ::io::substrait::Rel* mutable_right(); + void set_allocated_right(::io::substrait::Rel* right); + private: + const ::io::substrait::Rel& _internal_right() const; + ::io::substrait::Rel* _internal_mutable_right(); + public: + void unsafe_arena_set_allocated_right( + ::io::substrait::Rel* right); + ::io::substrait::Rel* unsafe_arena_release_right(); + + // .io.substrait.Expression expression = 4; + bool has_expression() const; + private: + bool _internal_has_expression() const; + public: + void clear_expression(); + const ::io::substrait::Expression& expression() const; + ::io::substrait::Expression* release_expression(); + ::io::substrait::Expression* mutable_expression(); + void set_allocated_expression(::io::substrait::Expression* expression); + private: + const ::io::substrait::Expression& _internal_expression() const; + ::io::substrait::Expression* _internal_mutable_expression(); + public: + void unsafe_arena_set_allocated_expression( + ::io::substrait::Expression* expression); + ::io::substrait::Expression* unsafe_arena_release_expression(); + + // .io.substrait.Expression post_join_filter = 5; + bool has_post_join_filter() const; + private: + bool _internal_has_post_join_filter() const; + public: + void clear_post_join_filter(); + const ::io::substrait::Expression& post_join_filter() const; + ::io::substrait::Expression* release_post_join_filter(); + ::io::substrait::Expression* mutable_post_join_filter(); + void set_allocated_post_join_filter(::io::substrait::Expression* post_join_filter); + private: + const ::io::substrait::Expression& _internal_post_join_filter() const; + ::io::substrait::Expression* _internal_mutable_post_join_filter(); + public: + void unsafe_arena_set_allocated_post_join_filter( + ::io::substrait::Expression* post_join_filter); + ::io::substrait::Expression* unsafe_arena_release_post_join_filter(); + + // .io.substrait.JoinRel.JoinType type = 6; + void clear_type(); + ::io::substrait::JoinRel_JoinType type() const; + void set_type(::io::substrait::JoinRel_JoinType value); + private: + ::io::substrait::JoinRel_JoinType _internal_type() const; + void _internal_set_type(::io::substrait::JoinRel_JoinType value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.JoinRel) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::RelCommon* common_; + ::io::substrait::Rel* left_; + ::io::substrait::Rel* right_; + ::io::substrait::Expression* expression_; + ::io::substrait::Expression* post_join_filter_; + int type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class FetchRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FetchRel) */ { + public: + inline FetchRel() : FetchRel(nullptr) {} + ~FetchRel() override; + explicit constexpr FetchRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FetchRel(const FetchRel& from); + FetchRel(FetchRel&& from) noexcept + : FetchRel() { + *this = ::std::move(from); + } + + inline FetchRel& operator=(const FetchRel& from) { + CopyFrom(from); + return *this; + } + inline FetchRel& operator=(FetchRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FetchRel& default_instance() { + return *internal_default_instance(); + } + static inline const FetchRel* internal_default_instance() { + return reinterpret_cast( + &_FetchRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(FetchRel& a, FetchRel& b) { + a.Swap(&b); + } + inline void Swap(FetchRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FetchRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FetchRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + FetchRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FetchRel& from); + void MergeFrom(const FetchRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FetchRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FetchRel"; + } + protected: + explicit FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCommonFieldNumber = 1, + kInputFieldNumber = 2, + kOffsetFieldNumber = 3, + kCountFieldNumber = 4, + }; + // .io.substrait.RelCommon common = 1; + bool has_common() const; + private: + bool _internal_has_common() const; + public: + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); + private: + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); + public: + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); + + // .io.substrait.Rel input = 2; + bool has_input() const; + private: + bool _internal_has_input() const; + public: + void clear_input(); + const ::io::substrait::Rel& input() const; + ::io::substrait::Rel* release_input(); + ::io::substrait::Rel* mutable_input(); + void set_allocated_input(::io::substrait::Rel* input); + private: + const ::io::substrait::Rel& _internal_input() const; + ::io::substrait::Rel* _internal_mutable_input(); + public: + void unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input); + ::io::substrait::Rel* unsafe_arena_release_input(); + + // int64 offset = 3; + void clear_offset(); + ::PROTOBUF_NAMESPACE_ID::int64 offset() const; + void set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_offset() const; + void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // int64 count = 4; + void clear_count(); + ::PROTOBUF_NAMESPACE_ID::int64 count() const; + void set_count(::PROTOBUF_NAMESPACE_ID::int64 value); + private: + ::PROTOBUF_NAMESPACE_ID::int64 _internal_count() const; + void _internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.FetchRel) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::RelCommon* common_; + ::io::substrait::Rel* input_; + ::PROTOBUF_NAMESPACE_ID::int64 offset_; + ::PROTOBUF_NAMESPACE_ID::int64 count_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class AggregateRel_Grouping PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.AggregateRel.Grouping) */ { + public: + inline AggregateRel_Grouping() : AggregateRel_Grouping(nullptr) {} + ~AggregateRel_Grouping() override; + explicit constexpr AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AggregateRel_Grouping(const AggregateRel_Grouping& from); + AggregateRel_Grouping(AggregateRel_Grouping&& from) noexcept + : AggregateRel_Grouping() { + *this = ::std::move(from); + } + + inline AggregateRel_Grouping& operator=(const AggregateRel_Grouping& from) { + CopyFrom(from); + return *this; + } + inline AggregateRel_Grouping& operator=(AggregateRel_Grouping&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 AggregateRel_Grouping& default_instance() { + return *internal_default_instance(); + } + static inline const AggregateRel_Grouping* internal_default_instance() { + return reinterpret_cast( + &_AggregateRel_Grouping_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(AggregateRel_Grouping& a, AggregateRel_Grouping& b) { + a.Swap(&b); + } + inline void Swap(AggregateRel_Grouping* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AggregateRel_Grouping* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline AggregateRel_Grouping* New() const final { + return CreateMaybeMessage(nullptr); + } + + AggregateRel_Grouping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const AggregateRel_Grouping& from); + void MergeFrom(const AggregateRel_Grouping& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(AggregateRel_Grouping* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.AggregateRel.Grouping"; + } + protected: + explicit AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kInputFieldsFieldNumber = 1, + }; + // repeated int32 input_fields = 1; + int input_fields_size() const; + private: + int _internal_input_fields_size() const; + public: + void clear_input_fields(); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_input_fields(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + _internal_input_fields() const; + void _internal_add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + _internal_mutable_input_fields(); + public: + ::PROTOBUF_NAMESPACE_ID::int32 input_fields(int index) const; + void set_input_fields(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); + void add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + input_fields() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + mutable_input_fields(); + + // @@protoc_insertion_point(class_scope:io.substrait.AggregateRel.Grouping) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > input_fields_; + mutable std::atomic _input_fields_cached_byte_size_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class AggregateRel_Measure PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.AggregateRel.Measure) */ { + public: + inline AggregateRel_Measure() : AggregateRel_Measure(nullptr) {} + ~AggregateRel_Measure() override; + explicit constexpr AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AggregateRel_Measure(const AggregateRel_Measure& from); + AggregateRel_Measure(AggregateRel_Measure&& from) noexcept + : AggregateRel_Measure() { + *this = ::std::move(from); + } + + inline AggregateRel_Measure& operator=(const AggregateRel_Measure& from) { + CopyFrom(from); + return *this; + } + inline AggregateRel_Measure& operator=(AggregateRel_Measure&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 AggregateRel_Measure& default_instance() { + return *internal_default_instance(); + } + static inline const AggregateRel_Measure* internal_default_instance() { + return reinterpret_cast( + &_AggregateRel_Measure_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(AggregateRel_Measure& a, AggregateRel_Measure& b) { + a.Swap(&b); + } + inline void Swap(AggregateRel_Measure* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AggregateRel_Measure* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline AggregateRel_Measure* New() const final { + return CreateMaybeMessage(nullptr); + } + + AggregateRel_Measure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const AggregateRel_Measure& from); + void MergeFrom(const AggregateRel_Measure& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(AggregateRel_Measure* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.AggregateRel.Measure"; + } + protected: + explicit AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMeasureFieldNumber = 1, + }; + // .io.substrait.Expression.AggregateFunction measure = 1; + bool has_measure() const; + private: + bool _internal_has_measure() const; + public: + void clear_measure(); + const ::io::substrait::Expression_AggregateFunction& measure() const; + ::io::substrait::Expression_AggregateFunction* release_measure(); + ::io::substrait::Expression_AggregateFunction* mutable_measure(); + void set_allocated_measure(::io::substrait::Expression_AggregateFunction* measure); + private: + const ::io::substrait::Expression_AggregateFunction& _internal_measure() const; + ::io::substrait::Expression_AggregateFunction* _internal_mutable_measure(); + public: + void unsafe_arena_set_allocated_measure( + ::io::substrait::Expression_AggregateFunction* measure); + ::io::substrait::Expression_AggregateFunction* unsafe_arena_release_measure(); + + // @@protoc_insertion_point(class_scope:io.substrait.AggregateRel.Measure) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression_AggregateFunction* measure_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class AggregateRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.AggregateRel) */ { + public: + inline AggregateRel() : AggregateRel(nullptr) {} + ~AggregateRel() override; + explicit constexpr AggregateRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AggregateRel(const AggregateRel& from); + AggregateRel(AggregateRel&& from) noexcept + : AggregateRel() { + *this = ::std::move(from); + } + + inline AggregateRel& operator=(const AggregateRel& from) { + CopyFrom(from); + return *this; + } + inline AggregateRel& operator=(AggregateRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 AggregateRel& default_instance() { + return *internal_default_instance(); + } + static inline const AggregateRel* internal_default_instance() { + return reinterpret_cast( + &_AggregateRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(AggregateRel& a, AggregateRel& b) { + a.Swap(&b); + } + inline void Swap(AggregateRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AggregateRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline AggregateRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + AggregateRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const AggregateRel& from); + void MergeFrom(const AggregateRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(AggregateRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.AggregateRel"; + } + protected: + explicit AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef AggregateRel_Grouping Grouping; + typedef AggregateRel_Measure Measure; + + // accessors ------------------------------------------------------- + + enum : int { + kGroupingsFieldNumber = 3, + kMeasuresFieldNumber = 4, + kCommonFieldNumber = 1, + kInputFieldNumber = 2, + kPhaseFieldNumber = 5, + }; + // repeated .io.substrait.AggregateRel.Grouping groupings = 3; + int groupings_size() const; + private: + int _internal_groupings_size() const; + public: + void clear_groupings(); + ::io::substrait::AggregateRel_Grouping* mutable_groupings(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >* + mutable_groupings(); + private: + const ::io::substrait::AggregateRel_Grouping& _internal_groupings(int index) const; + ::io::substrait::AggregateRel_Grouping* _internal_add_groupings(); + public: + const ::io::substrait::AggregateRel_Grouping& groupings(int index) const; + ::io::substrait::AggregateRel_Grouping* add_groupings(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >& + groupings() const; + + // repeated .io.substrait.AggregateRel.Measure measures = 4; + int measures_size() const; + private: + int _internal_measures_size() const; + public: + void clear_measures(); + ::io::substrait::AggregateRel_Measure* mutable_measures(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >* + mutable_measures(); + private: + const ::io::substrait::AggregateRel_Measure& _internal_measures(int index) const; + ::io::substrait::AggregateRel_Measure* _internal_add_measures(); + public: + const ::io::substrait::AggregateRel_Measure& measures(int index) const; + ::io::substrait::AggregateRel_Measure* add_measures(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >& + measures() const; + + // .io.substrait.RelCommon common = 1; + bool has_common() const; + private: + bool _internal_has_common() const; + public: + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); + private: + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); + public: + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); + + // .io.substrait.Rel input = 2; + bool has_input() const; + private: + bool _internal_has_input() const; + public: + void clear_input(); + const ::io::substrait::Rel& input() const; + ::io::substrait::Rel* release_input(); + ::io::substrait::Rel* mutable_input(); + void set_allocated_input(::io::substrait::Rel* input); + private: + const ::io::substrait::Rel& _internal_input() const; + ::io::substrait::Rel* _internal_mutable_input(); + public: + void unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input); + ::io::substrait::Rel* unsafe_arena_release_input(); + + // .io.substrait.Expression.AggregationPhase phase = 5; + void clear_phase(); + ::io::substrait::Expression_AggregationPhase phase() const; + void set_phase(::io::substrait::Expression_AggregationPhase value); + private: + ::io::substrait::Expression_AggregationPhase _internal_phase() const; + void _internal_set_phase(::io::substrait::Expression_AggregationPhase value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.AggregateRel) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping > groupings_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure > measures_; + ::io::substrait::RelCommon* common_; + ::io::substrait::Rel* input_; + int phase_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class SortRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.SortRel) */ { + public: + inline SortRel() : SortRel(nullptr) {} + ~SortRel() override; + explicit constexpr SortRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SortRel(const SortRel& from); + SortRel(SortRel&& from) noexcept + : SortRel() { + *this = ::std::move(from); + } + + inline SortRel& operator=(const SortRel& from) { + CopyFrom(from); + return *this; + } + inline SortRel& operator=(SortRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 SortRel& default_instance() { + return *internal_default_instance(); + } + static inline const SortRel* internal_default_instance() { + return reinterpret_cast( + &_SortRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(SortRel& a, SortRel& b) { + a.Swap(&b); + } + inline void Swap(SortRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SortRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SortRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + SortRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SortRel& from); + void MergeFrom(const SortRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SortRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.SortRel"; + } + protected: + explicit SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kSortsFieldNumber = 3, + kCommonFieldNumber = 1, + kInputFieldNumber = 2, + }; + // repeated .io.substrait.Expression.SortField sorts = 3; + int sorts_size() const; + private: + int _internal_sorts_size() const; + public: + void clear_sorts(); + ::io::substrait::Expression_SortField* mutable_sorts(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* + mutable_sorts(); + private: + const ::io::substrait::Expression_SortField& _internal_sorts(int index) const; + ::io::substrait::Expression_SortField* _internal_add_sorts(); + public: + const ::io::substrait::Expression_SortField& sorts(int index) const; + ::io::substrait::Expression_SortField* add_sorts(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& + sorts() const; + + // .io.substrait.RelCommon common = 1; + bool has_common() const; + private: + bool _internal_has_common() const; + public: + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); + private: + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); + public: + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); + + // .io.substrait.Rel input = 2; + bool has_input() const; + private: + bool _internal_has_input() const; + public: + void clear_input(); + const ::io::substrait::Rel& input() const; + ::io::substrait::Rel* release_input(); + ::io::substrait::Rel* mutable_input(); + void set_allocated_input(::io::substrait::Rel* input); + private: + const ::io::substrait::Rel& _internal_input() const; + ::io::substrait::Rel* _internal_mutable_input(); + public: + void unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input); + ::io::substrait::Rel* unsafe_arena_release_input(); + + // @@protoc_insertion_point(class_scope:io.substrait.SortRel) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField > sorts_; + ::io::substrait::RelCommon* common_; + ::io::substrait::Rel* input_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class FilterRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FilterRel) */ { + public: + inline FilterRel() : FilterRel(nullptr) {} + ~FilterRel() override; + explicit constexpr FilterRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FilterRel(const FilterRel& from); + FilterRel(FilterRel&& from) noexcept + : FilterRel() { + *this = ::std::move(from); + } + + inline FilterRel& operator=(const FilterRel& from) { + CopyFrom(from); + return *this; + } + inline FilterRel& operator=(FilterRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FilterRel& default_instance() { + return *internal_default_instance(); + } + static inline const FilterRel* internal_default_instance() { + return reinterpret_cast( + &_FilterRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(FilterRel& a, FilterRel& b) { + a.Swap(&b); + } + inline void Swap(FilterRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FilterRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FilterRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + FilterRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FilterRel& from); + void MergeFrom(const FilterRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FilterRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FilterRel"; + } + protected: + explicit FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCommonFieldNumber = 1, + kInputFieldNumber = 2, + kConditionFieldNumber = 3, + }; + // .io.substrait.RelCommon common = 1; + bool has_common() const; + private: + bool _internal_has_common() const; + public: + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); + private: + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); + public: + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); + + // .io.substrait.Rel input = 2; + bool has_input() const; + private: + bool _internal_has_input() const; + public: + void clear_input(); + const ::io::substrait::Rel& input() const; + ::io::substrait::Rel* release_input(); + ::io::substrait::Rel* mutable_input(); + void set_allocated_input(::io::substrait::Rel* input); + private: + const ::io::substrait::Rel& _internal_input() const; + ::io::substrait::Rel* _internal_mutable_input(); + public: + void unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input); + ::io::substrait::Rel* unsafe_arena_release_input(); + + // .io.substrait.Expression condition = 3; + bool has_condition() const; + private: + bool _internal_has_condition() const; + public: + void clear_condition(); + const ::io::substrait::Expression& condition() const; + ::io::substrait::Expression* release_condition(); + ::io::substrait::Expression* mutable_condition(); + void set_allocated_condition(::io::substrait::Expression* condition); + private: + const ::io::substrait::Expression& _internal_condition() const; + ::io::substrait::Expression* _internal_mutable_condition(); + public: + void unsafe_arena_set_allocated_condition( + ::io::substrait::Expression* condition); + ::io::substrait::Expression* unsafe_arena_release_condition(); + + // @@protoc_insertion_point(class_scope:io.substrait.FilterRel) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::RelCommon* common_; + ::io::substrait::Rel* input_; + ::io::substrait::Expression* condition_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class SetRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.SetRel) */ { + public: + inline SetRel() : SetRel(nullptr) {} + ~SetRel() override; + explicit constexpr SetRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SetRel(const SetRel& from); + SetRel(SetRel&& from) noexcept + : SetRel() { + *this = ::std::move(from); + } + + inline SetRel& operator=(const SetRel& from) { + CopyFrom(from); + return *this; + } + inline SetRel& operator=(SetRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 SetRel& default_instance() { + return *internal_default_instance(); + } + static inline const SetRel* internal_default_instance() { + return reinterpret_cast( + &_SetRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(SetRel& a, SetRel& b) { + a.Swap(&b); + } + inline void Swap(SetRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SetRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + SetRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SetRel& from); + void MergeFrom(const SetRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SetRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.SetRel"; + } + protected: + explicit SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef SetRel_SetOp SetOp; + static constexpr SetOp UNKNOWN = + SetRel_SetOp_UNKNOWN; + static constexpr SetOp MINUS_PRIMARY = + SetRel_SetOp_MINUS_PRIMARY; + static constexpr SetOp MINUS_MULTISET = + SetRel_SetOp_MINUS_MULTISET; + static constexpr SetOp INTERSECTION_PRIMARY = + SetRel_SetOp_INTERSECTION_PRIMARY; + static constexpr SetOp INTERSECTION_MULTISET = + SetRel_SetOp_INTERSECTION_MULTISET; + static constexpr SetOp UNION_DISTINCT = + SetRel_SetOp_UNION_DISTINCT; + static constexpr SetOp UNION_ALL = + SetRel_SetOp_UNION_ALL; + static inline bool SetOp_IsValid(int value) { + return SetRel_SetOp_IsValid(value); + } + static constexpr SetOp SetOp_MIN = + SetRel_SetOp_SetOp_MIN; + static constexpr SetOp SetOp_MAX = + SetRel_SetOp_SetOp_MAX; + static constexpr int SetOp_ARRAYSIZE = + SetRel_SetOp_SetOp_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + SetOp_descriptor() { + return SetRel_SetOp_descriptor(); + } + template + static inline const std::string& SetOp_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SetOp_Name."); + return SetRel_SetOp_Name(enum_t_value); + } + static inline bool SetOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + SetOp* value) { + return SetRel_SetOp_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kInputsFieldNumber = 2, + kCommonFieldNumber = 1, + kOpFieldNumber = 3, + }; + // repeated .io.substrait.Rel inputs = 2; + int inputs_size() const; + private: + int _internal_inputs_size() const; + public: + void clear_inputs(); + ::io::substrait::Rel* mutable_inputs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* + mutable_inputs(); + private: + const ::io::substrait::Rel& _internal_inputs(int index) const; + ::io::substrait::Rel* _internal_add_inputs(); + public: + const ::io::substrait::Rel& inputs(int index) const; + ::io::substrait::Rel* add_inputs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& + inputs() const; + + // .io.substrait.RelCommon common = 1; + bool has_common() const; + private: + bool _internal_has_common() const; + public: + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); + private: + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); + public: + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); + + // .io.substrait.SetRel.SetOp op = 3; + void clear_op(); + ::io::substrait::SetRel_SetOp op() const; + void set_op(::io::substrait::SetRel_SetOp value); + private: + ::io::substrait::SetRel_SetOp _internal_op() const; + void _internal_set_op(::io::substrait::SetRel_SetOp value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.SetRel) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel > inputs_; + ::io::substrait::RelCommon* common_; + int op_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class Rel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Rel) */ { + public: + inline Rel() : Rel(nullptr) {} + ~Rel() override; + explicit constexpr Rel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Rel(const Rel& from); + Rel(Rel&& from) noexcept + : Rel() { + *this = ::std::move(from); + } + + inline Rel& operator=(const Rel& from) { + CopyFrom(from); + return *this; + } + inline Rel& operator=(Rel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Rel& default_instance() { + return *internal_default_instance(); + } + enum RelTypeCase { + kRead = 1, + kFilter = 2, + kFetch = 3, + kAggregate = 4, + kSort = 5, + kJoin = 6, + kProject = 7, + kSet = 8, + RELTYPE_NOT_SET = 0, + }; + + static inline const Rel* internal_default_instance() { + return reinterpret_cast( + &_Rel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 21; + + friend void swap(Rel& a, Rel& b) { + a.Swap(&b); + } + inline void Swap(Rel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Rel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Rel* New() const final { + return CreateMaybeMessage(nullptr); + } + + Rel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Rel& from); + void MergeFrom(const Rel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Rel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Rel"; + } + protected: + explicit Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kReadFieldNumber = 1, + kFilterFieldNumber = 2, + kFetchFieldNumber = 3, + kAggregateFieldNumber = 4, + kSortFieldNumber = 5, + kJoinFieldNumber = 6, + kProjectFieldNumber = 7, + kSetFieldNumber = 8, + }; + // .io.substrait.ReadRel read = 1; + bool has_read() const; + private: + bool _internal_has_read() const; + public: + void clear_read(); + const ::io::substrait::ReadRel& read() const; + ::io::substrait::ReadRel* release_read(); + ::io::substrait::ReadRel* mutable_read(); + void set_allocated_read(::io::substrait::ReadRel* read); + private: + const ::io::substrait::ReadRel& _internal_read() const; + ::io::substrait::ReadRel* _internal_mutable_read(); + public: + void unsafe_arena_set_allocated_read( + ::io::substrait::ReadRel* read); + ::io::substrait::ReadRel* unsafe_arena_release_read(); + + // .io.substrait.FilterRel filter = 2; + bool has_filter() const; + private: + bool _internal_has_filter() const; + public: + void clear_filter(); + const ::io::substrait::FilterRel& filter() const; + ::io::substrait::FilterRel* release_filter(); + ::io::substrait::FilterRel* mutable_filter(); + void set_allocated_filter(::io::substrait::FilterRel* filter); + private: + const ::io::substrait::FilterRel& _internal_filter() const; + ::io::substrait::FilterRel* _internal_mutable_filter(); + public: + void unsafe_arena_set_allocated_filter( + ::io::substrait::FilterRel* filter); + ::io::substrait::FilterRel* unsafe_arena_release_filter(); + + // .io.substrait.FetchRel fetch = 3; + bool has_fetch() const; + private: + bool _internal_has_fetch() const; + public: + void clear_fetch(); + const ::io::substrait::FetchRel& fetch() const; + ::io::substrait::FetchRel* release_fetch(); + ::io::substrait::FetchRel* mutable_fetch(); + void set_allocated_fetch(::io::substrait::FetchRel* fetch); + private: + const ::io::substrait::FetchRel& _internal_fetch() const; + ::io::substrait::FetchRel* _internal_mutable_fetch(); + public: + void unsafe_arena_set_allocated_fetch( + ::io::substrait::FetchRel* fetch); + ::io::substrait::FetchRel* unsafe_arena_release_fetch(); + + // .io.substrait.AggregateRel aggregate = 4; + bool has_aggregate() const; + private: + bool _internal_has_aggregate() const; + public: + void clear_aggregate(); + const ::io::substrait::AggregateRel& aggregate() const; + ::io::substrait::AggregateRel* release_aggregate(); + ::io::substrait::AggregateRel* mutable_aggregate(); + void set_allocated_aggregate(::io::substrait::AggregateRel* aggregate); + private: + const ::io::substrait::AggregateRel& _internal_aggregate() const; + ::io::substrait::AggregateRel* _internal_mutable_aggregate(); + public: + void unsafe_arena_set_allocated_aggregate( + ::io::substrait::AggregateRel* aggregate); + ::io::substrait::AggregateRel* unsafe_arena_release_aggregate(); + + // .io.substrait.SortRel sort = 5; + bool has_sort() const; + private: + bool _internal_has_sort() const; + public: + void clear_sort(); + const ::io::substrait::SortRel& sort() const; + ::io::substrait::SortRel* release_sort(); + ::io::substrait::SortRel* mutable_sort(); + void set_allocated_sort(::io::substrait::SortRel* sort); + private: + const ::io::substrait::SortRel& _internal_sort() const; + ::io::substrait::SortRel* _internal_mutable_sort(); + public: + void unsafe_arena_set_allocated_sort( + ::io::substrait::SortRel* sort); + ::io::substrait::SortRel* unsafe_arena_release_sort(); + + // .io.substrait.JoinRel join = 6; + bool has_join() const; + private: + bool _internal_has_join() const; + public: + void clear_join(); + const ::io::substrait::JoinRel& join() const; + ::io::substrait::JoinRel* release_join(); + ::io::substrait::JoinRel* mutable_join(); + void set_allocated_join(::io::substrait::JoinRel* join); + private: + const ::io::substrait::JoinRel& _internal_join() const; + ::io::substrait::JoinRel* _internal_mutable_join(); + public: + void unsafe_arena_set_allocated_join( + ::io::substrait::JoinRel* join); + ::io::substrait::JoinRel* unsafe_arena_release_join(); + + // .io.substrait.ProjectRel project = 7; + bool has_project() const; + private: + bool _internal_has_project() const; + public: + void clear_project(); + const ::io::substrait::ProjectRel& project() const; + ::io::substrait::ProjectRel* release_project(); + ::io::substrait::ProjectRel* mutable_project(); + void set_allocated_project(::io::substrait::ProjectRel* project); + private: + const ::io::substrait::ProjectRel& _internal_project() const; + ::io::substrait::ProjectRel* _internal_mutable_project(); + public: + void unsafe_arena_set_allocated_project( + ::io::substrait::ProjectRel* project); + ::io::substrait::ProjectRel* unsafe_arena_release_project(); + + // .io.substrait.SetRel set = 8; + bool has_set() const; + private: + bool _internal_has_set() const; + public: + void clear_set(); + const ::io::substrait::SetRel& set() const; + ::io::substrait::SetRel* release_set(); + ::io::substrait::SetRel* mutable_set(); + void set_allocated_set(::io::substrait::SetRel* set); + private: + const ::io::substrait::SetRel& _internal_set() const; + ::io::substrait::SetRel* _internal_mutable_set(); + public: + void unsafe_arena_set_allocated_set( + ::io::substrait::SetRel* set); + ::io::substrait::SetRel* unsafe_arena_release_set(); + + void clear_RelType(); + RelTypeCase RelType_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Rel) + private: + class _Internal; + void set_has_read(); + void set_has_filter(); + void set_has_fetch(); + void set_has_aggregate(); + void set_has_sort(); + void set_has_join(); + void set_has_project(); + void set_has_set(); + + inline bool has_RelType() const; + inline void clear_has_RelType(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union RelTypeUnion { + constexpr RelTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::ReadRel* read_; + ::io::substrait::FilterRel* filter_; + ::io::substrait::FetchRel* fetch_; + ::io::substrait::AggregateRel* aggregate_; + ::io::substrait::SortRel* sort_; + ::io::substrait::JoinRel* join_; + ::io::substrait::ProjectRel* project_; + ::io::substrait::SetRel* set_; + } RelType_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_relations_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// RelCommon_Direct + +// ------------------------------------------------------------------- + +// RelCommon_Emit + +// repeated int32 output_mapping = 1; +inline int RelCommon_Emit::_internal_output_mapping_size() const { + return output_mapping_.size(); +} +inline int RelCommon_Emit::output_mapping_size() const { + return _internal_output_mapping_size(); +} +inline void RelCommon_Emit::clear_output_mapping() { + output_mapping_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 RelCommon_Emit::_internal_output_mapping(int index) const { + return output_mapping_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 RelCommon_Emit::output_mapping(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Emit.output_mapping) + return _internal_output_mapping(index); +} +inline void RelCommon_Emit::set_output_mapping(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { + output_mapping_.Set(index, value); + // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Emit.output_mapping) +} +inline void RelCommon_Emit::_internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value) { + output_mapping_.Add(value); +} +inline void RelCommon_Emit::add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_add_output_mapping(value); + // @@protoc_insertion_point(field_add:io.substrait.RelCommon.Emit.output_mapping) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +RelCommon_Emit::_internal_output_mapping() const { + return output_mapping_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +RelCommon_Emit::output_mapping() const { + // @@protoc_insertion_point(field_list:io.substrait.RelCommon.Emit.output_mapping) + return _internal_output_mapping(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +RelCommon_Emit::_internal_mutable_output_mapping() { + return &output_mapping_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +RelCommon_Emit::mutable_output_mapping() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.RelCommon.Emit.output_mapping) + return _internal_mutable_output_mapping(); +} + +// ------------------------------------------------------------------- + +// RelCommon_Hint_Stats + +// double row_count = 1; +inline void RelCommon_Hint_Stats::clear_row_count() { + row_count_ = 0; +} +inline double RelCommon_Hint_Stats::_internal_row_count() const { + return row_count_; +} +inline double RelCommon_Hint_Stats::row_count() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.Stats.row_count) + return _internal_row_count(); +} +inline void RelCommon_Hint_Stats::_internal_set_row_count(double value) { + + row_count_ = value; +} +inline void RelCommon_Hint_Stats::set_row_count(double value) { + _internal_set_row_count(value); + // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.Stats.row_count) +} + +// double record_size = 2; +inline void RelCommon_Hint_Stats::clear_record_size() { + record_size_ = 0; +} +inline double RelCommon_Hint_Stats::_internal_record_size() const { + return record_size_; +} +inline double RelCommon_Hint_Stats::record_size() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.Stats.record_size) + return _internal_record_size(); +} +inline void RelCommon_Hint_Stats::_internal_set_record_size(double value) { + + record_size_ = value; +} +inline void RelCommon_Hint_Stats::set_record_size(double value) { + _internal_set_record_size(value); + // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.Stats.record_size) +} + +// ------------------------------------------------------------------- + +// RelCommon_Hint_HintKeyValue + +// string key = 1; +inline void RelCommon_Hint_HintKeyValue::clear_key() { + key_.ClearToEmpty(); +} +inline const std::string& RelCommon_Hint_HintKeyValue::key() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.HintKeyValue.key) + return _internal_key(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void RelCommon_Hint_HintKeyValue::set_key(ArgT0&& arg0, ArgT... args) { + + key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.HintKeyValue.key) +} +inline std::string* RelCommon_Hint_HintKeyValue::mutable_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.HintKeyValue.key) + return _internal_mutable_key(); +} +inline const std::string& RelCommon_Hint_HintKeyValue::_internal_key() const { + return key_.Get(); +} +inline void RelCommon_Hint_HintKeyValue::_internal_set_key(const std::string& value) { + + key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* RelCommon_Hint_HintKeyValue::_internal_mutable_key() { + + return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* RelCommon_Hint_HintKeyValue::release_key() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.HintKeyValue.key) + return key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void RelCommon_Hint_HintKeyValue::set_allocated_key(std::string* key) { + if (key != nullptr) { + + } else { + + } + key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.HintKeyValue.key) +} + +// bytes value = 2; +inline void RelCommon_Hint_HintKeyValue::clear_value() { + value_.ClearToEmpty(); +} +inline const std::string& RelCommon_Hint_HintKeyValue::value() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.HintKeyValue.value) + return _internal_value(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void RelCommon_Hint_HintKeyValue::set_value(ArgT0&& arg0, ArgT... args) { + + value_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.HintKeyValue.value) +} +inline std::string* RelCommon_Hint_HintKeyValue::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.HintKeyValue.value) + return _internal_mutable_value(); +} +inline const std::string& RelCommon_Hint_HintKeyValue::_internal_value() const { + return value_.Get(); +} +inline void RelCommon_Hint_HintKeyValue::_internal_set_value(const std::string& value) { + + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* RelCommon_Hint_HintKeyValue::_internal_mutable_value() { + + return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* RelCommon_Hint_HintKeyValue::release_value() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.HintKeyValue.value) + return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void RelCommon_Hint_HintKeyValue::set_allocated_value(std::string* value) { + if (value != nullptr) { + + } else { + + } + value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.HintKeyValue.value) +} + +// ------------------------------------------------------------------- + +// RelCommon_Hint + +// repeated .io.substrait.RelCommon.Hint.HintKeyValue hint_key_values = 1; +inline int RelCommon_Hint::_internal_hint_key_values_size() const { + return hint_key_values_.size(); +} +inline int RelCommon_Hint::hint_key_values_size() const { + return _internal_hint_key_values_size(); +} +inline void RelCommon_Hint::clear_hint_key_values() { + hint_key_values_.Clear(); +} +inline ::io::substrait::RelCommon_Hint_HintKeyValue* RelCommon_Hint::mutable_hint_key_values(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.hint_key_values) + return hint_key_values_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::RelCommon_Hint_HintKeyValue >* +RelCommon_Hint::mutable_hint_key_values() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.RelCommon.Hint.hint_key_values) + return &hint_key_values_; +} +inline const ::io::substrait::RelCommon_Hint_HintKeyValue& RelCommon_Hint::_internal_hint_key_values(int index) const { + return hint_key_values_.Get(index); +} +inline const ::io::substrait::RelCommon_Hint_HintKeyValue& RelCommon_Hint::hint_key_values(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.hint_key_values) + return _internal_hint_key_values(index); +} +inline ::io::substrait::RelCommon_Hint_HintKeyValue* RelCommon_Hint::_internal_add_hint_key_values() { + return hint_key_values_.Add(); +} +inline ::io::substrait::RelCommon_Hint_HintKeyValue* RelCommon_Hint::add_hint_key_values() { + // @@protoc_insertion_point(field_add:io.substrait.RelCommon.Hint.hint_key_values) + return _internal_add_hint_key_values(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::RelCommon_Hint_HintKeyValue >& +RelCommon_Hint::hint_key_values() const { + // @@protoc_insertion_point(field_list:io.substrait.RelCommon.Hint.hint_key_values) + return hint_key_values_; +} + +// .io.substrait.RelCommon.Hint.Stats stats = 2; +inline bool RelCommon_Hint::_internal_has_stats() const { + return this != internal_default_instance() && stats_ != nullptr; +} +inline bool RelCommon_Hint::has_stats() const { + return _internal_has_stats(); +} +inline void RelCommon_Hint::clear_stats() { + if (GetArena() == nullptr && stats_ != nullptr) { + delete stats_; + } + stats_ = nullptr; +} +inline const ::io::substrait::RelCommon_Hint_Stats& RelCommon_Hint::_internal_stats() const { + const ::io::substrait::RelCommon_Hint_Stats* p = stats_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_Hint_Stats_default_instance_); +} +inline const ::io::substrait::RelCommon_Hint_Stats& RelCommon_Hint::stats() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.stats) + return _internal_stats(); +} +inline void RelCommon_Hint::unsafe_arena_set_allocated_stats( + ::io::substrait::RelCommon_Hint_Stats* stats) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(stats_); + } + stats_ = stats; + if (stats) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.stats) +} +inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::release_stats() { + + ::io::substrait::RelCommon_Hint_Stats* temp = stats_; + stats_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::unsafe_arena_release_stats() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.stats) + + ::io::substrait::RelCommon_Hint_Stats* temp = stats_; + stats_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::_internal_mutable_stats() { + + if (stats_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon_Hint_Stats>(GetArena()); + stats_ = p; + } + return stats_; +} +inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::mutable_stats() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.stats) + return _internal_mutable_stats(); +} +inline void RelCommon_Hint::set_allocated_stats(::io::substrait::RelCommon_Hint_Stats* stats) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete stats_; + } + if (stats) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(stats); + if (message_arena != submessage_arena) { + stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, stats, submessage_arena); + } + + } else { + + } + stats_ = stats; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.stats) +} + +// ------------------------------------------------------------------- + +// RelCommon_RuntimeConstraint + +// ------------------------------------------------------------------- + +// RelCommon + +// .io.substrait.RelCommon.Direct direct = 1; +inline bool RelCommon::_internal_has_direct() const { + return kind_case() == kDirect; +} +inline bool RelCommon::has_direct() const { + return _internal_has_direct(); +} +inline void RelCommon::set_has_direct() { + _oneof_case_[0] = kDirect; +} +inline void RelCommon::clear_direct() { + if (_internal_has_direct()) { + if (GetArena() == nullptr) { + delete kind_.direct_; + } + clear_has_kind(); + } +} +inline ::io::substrait::RelCommon_Direct* RelCommon::release_direct() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.direct) + if (_internal_has_direct()) { + clear_has_kind(); + ::io::substrait::RelCommon_Direct* temp = kind_.direct_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.direct_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::RelCommon_Direct& RelCommon::_internal_direct() const { + return _internal_has_direct() + ? *kind_.direct_ + : reinterpret_cast< ::io::substrait::RelCommon_Direct&>(::io::substrait::_RelCommon_Direct_default_instance_); +} +inline const ::io::substrait::RelCommon_Direct& RelCommon::direct() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.direct) + return _internal_direct(); +} +inline ::io::substrait::RelCommon_Direct* RelCommon::unsafe_arena_release_direct() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.RelCommon.direct) + if (_internal_has_direct()) { + clear_has_kind(); + ::io::substrait::RelCommon_Direct* temp = kind_.direct_; + kind_.direct_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void RelCommon::unsafe_arena_set_allocated_direct(::io::substrait::RelCommon_Direct* direct) { + clear_kind(); + if (direct) { + set_has_direct(); + kind_.direct_ = direct; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.direct) +} +inline ::io::substrait::RelCommon_Direct* RelCommon::_internal_mutable_direct() { + if (!_internal_has_direct()) { + clear_kind(); + set_has_direct(); + kind_.direct_ = CreateMaybeMessage< ::io::substrait::RelCommon_Direct >(GetArena()); + } + return kind_.direct_; +} +inline ::io::substrait::RelCommon_Direct* RelCommon::mutable_direct() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.direct) + return _internal_mutable_direct(); +} + +// .io.substrait.RelCommon.Emit emit = 2; +inline bool RelCommon::_internal_has_emit() const { + return kind_case() == kEmit; +} +inline bool RelCommon::has_emit() const { + return _internal_has_emit(); +} +inline void RelCommon::set_has_emit() { + _oneof_case_[0] = kEmit; +} +inline void RelCommon::clear_emit() { + if (_internal_has_emit()) { + if (GetArena() == nullptr) { + delete kind_.emit_; + } + clear_has_kind(); + } +} +inline ::io::substrait::RelCommon_Emit* RelCommon::release_emit() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.emit) + if (_internal_has_emit()) { + clear_has_kind(); + ::io::substrait::RelCommon_Emit* temp = kind_.emit_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.emit_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::RelCommon_Emit& RelCommon::_internal_emit() const { + return _internal_has_emit() + ? *kind_.emit_ + : reinterpret_cast< ::io::substrait::RelCommon_Emit&>(::io::substrait::_RelCommon_Emit_default_instance_); +} +inline const ::io::substrait::RelCommon_Emit& RelCommon::emit() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.emit) + return _internal_emit(); +} +inline ::io::substrait::RelCommon_Emit* RelCommon::unsafe_arena_release_emit() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.RelCommon.emit) + if (_internal_has_emit()) { + clear_has_kind(); + ::io::substrait::RelCommon_Emit* temp = kind_.emit_; + kind_.emit_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void RelCommon::unsafe_arena_set_allocated_emit(::io::substrait::RelCommon_Emit* emit) { + clear_kind(); + if (emit) { + set_has_emit(); + kind_.emit_ = emit; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.emit) +} +inline ::io::substrait::RelCommon_Emit* RelCommon::_internal_mutable_emit() { + if (!_internal_has_emit()) { + clear_kind(); + set_has_emit(); + kind_.emit_ = CreateMaybeMessage< ::io::substrait::RelCommon_Emit >(GetArena()); + } + return kind_.emit_; +} +inline ::io::substrait::RelCommon_Emit* RelCommon::mutable_emit() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.emit) + return _internal_mutable_emit(); +} + +// .io.substrait.RelCommon.Hint hint = 3; +inline bool RelCommon::_internal_has_hint() const { + return this != internal_default_instance() && hint_ != nullptr; +} +inline bool RelCommon::has_hint() const { + return _internal_has_hint(); +} +inline void RelCommon::clear_hint() { + if (GetArena() == nullptr && hint_ != nullptr) { + delete hint_; + } + hint_ = nullptr; +} +inline const ::io::substrait::RelCommon_Hint& RelCommon::_internal_hint() const { + const ::io::substrait::RelCommon_Hint* p = hint_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_Hint_default_instance_); +} +inline const ::io::substrait::RelCommon_Hint& RelCommon::hint() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.hint) + return _internal_hint(); +} +inline void RelCommon::unsafe_arena_set_allocated_hint( + ::io::substrait::RelCommon_Hint* hint) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hint_); + } + hint_ = hint; + if (hint) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.hint) +} +inline ::io::substrait::RelCommon_Hint* RelCommon::release_hint() { + + ::io::substrait::RelCommon_Hint* temp = hint_; + hint_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon_Hint* RelCommon::unsafe_arena_release_hint() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.hint) + + ::io::substrait::RelCommon_Hint* temp = hint_; + hint_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon_Hint* RelCommon::_internal_mutable_hint() { + + if (hint_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon_Hint>(GetArena()); + hint_ = p; + } + return hint_; +} +inline ::io::substrait::RelCommon_Hint* RelCommon::mutable_hint() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.hint) + return _internal_mutable_hint(); +} +inline void RelCommon::set_allocated_hint(::io::substrait::RelCommon_Hint* hint) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete hint_; + } + if (hint) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(hint); + if (message_arena != submessage_arena) { + hint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hint, submessage_arena); + } + + } else { + + } + hint_ = hint; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.hint) +} + +// .io.substrait.RelCommon.RuntimeConstraint constraint = 4; +inline bool RelCommon::_internal_has_constraint() const { + return this != internal_default_instance() && constraint_ != nullptr; +} +inline bool RelCommon::has_constraint() const { + return _internal_has_constraint(); +} +inline void RelCommon::clear_constraint() { + if (GetArena() == nullptr && constraint_ != nullptr) { + delete constraint_; + } + constraint_ = nullptr; +} +inline const ::io::substrait::RelCommon_RuntimeConstraint& RelCommon::_internal_constraint() const { + const ::io::substrait::RelCommon_RuntimeConstraint* p = constraint_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_RuntimeConstraint_default_instance_); +} +inline const ::io::substrait::RelCommon_RuntimeConstraint& RelCommon::constraint() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.constraint) + return _internal_constraint(); +} +inline void RelCommon::unsafe_arena_set_allocated_constraint( + ::io::substrait::RelCommon_RuntimeConstraint* constraint) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(constraint_); + } + constraint_ = constraint; + if (constraint) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.constraint) +} +inline ::io::substrait::RelCommon_RuntimeConstraint* RelCommon::release_constraint() { + + ::io::substrait::RelCommon_RuntimeConstraint* temp = constraint_; + constraint_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon_RuntimeConstraint* RelCommon::unsafe_arena_release_constraint() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.constraint) + + ::io::substrait::RelCommon_RuntimeConstraint* temp = constraint_; + constraint_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon_RuntimeConstraint* RelCommon::_internal_mutable_constraint() { + + if (constraint_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon_RuntimeConstraint>(GetArena()); + constraint_ = p; + } + return constraint_; +} +inline ::io::substrait::RelCommon_RuntimeConstraint* RelCommon::mutable_constraint() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.constraint) + return _internal_mutable_constraint(); +} +inline void RelCommon::set_allocated_constraint(::io::substrait::RelCommon_RuntimeConstraint* constraint) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete constraint_; + } + if (constraint) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(constraint); + if (message_arena != submessage_arena) { + constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, constraint, submessage_arena); + } + + } else { + + } + constraint_ = constraint; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.constraint) +} + +inline bool RelCommon::has_kind() const { + return kind_case() != KIND_NOT_SET; +} +inline void RelCommon::clear_has_kind() { + _oneof_case_[0] = KIND_NOT_SET; +} +inline RelCommon::KindCase RelCommon::kind_case() const { + return RelCommon::KindCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// ReadRel_NamedTable + +// repeated string names = 1; +inline int ReadRel_NamedTable::_internal_names_size() const { + return names_.size(); +} +inline int ReadRel_NamedTable::names_size() const { + return _internal_names_size(); +} +inline void ReadRel_NamedTable::clear_names() { + names_.Clear(); +} +inline std::string* ReadRel_NamedTable::add_names() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.ReadRel.NamedTable.names) + return _internal_add_names(); +} +inline const std::string& ReadRel_NamedTable::_internal_names(int index) const { + return names_.Get(index); +} +inline const std::string& ReadRel_NamedTable::names(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.NamedTable.names) + return _internal_names(index); +} +inline std::string* ReadRel_NamedTable::mutable_names(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.NamedTable.names) + return names_.Mutable(index); +} +inline void ReadRel_NamedTable::set_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.NamedTable.names) + names_.Mutable(index)->assign(value); +} +inline void ReadRel_NamedTable::set_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.NamedTable.names) + names_.Mutable(index)->assign(std::move(value)); +} +inline void ReadRel_NamedTable::set_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.ReadRel.NamedTable.names) +} +inline void ReadRel_NamedTable::set_names(int index, const char* value, size_t size) { + names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.ReadRel.NamedTable.names) +} +inline std::string* ReadRel_NamedTable::_internal_add_names() { + return names_.Add(); +} +inline void ReadRel_NamedTable::add_names(const std::string& value) { + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.ReadRel.NamedTable.names) +} +inline void ReadRel_NamedTable::add_names(std::string&& value) { + names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.ReadRel.NamedTable.names) +} +inline void ReadRel_NamedTable::add_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.ReadRel.NamedTable.names) +} +inline void ReadRel_NamedTable::add_names(const char* value, size_t size) { + names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.ReadRel.NamedTable.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +ReadRel_NamedTable::names() const { + // @@protoc_insertion_point(field_list:io.substrait.ReadRel.NamedTable.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +ReadRel_NamedTable::mutable_names() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.NamedTable.names) + return &names_; +} + +// ------------------------------------------------------------------- + +// ReadRel_VirtualTable + +// repeated .io.substrait.Expression.Literal.Struct values = 1; +inline int ReadRel_VirtualTable::_internal_values_size() const { + return values_.size(); +} +inline int ReadRel_VirtualTable::values_size() const { + return _internal_values_size(); +} +inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::mutable_values(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.VirtualTable.values) + return values_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >* +ReadRel_VirtualTable::mutable_values() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.VirtualTable.values) + return &values_; +} +inline const ::io::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::_internal_values(int index) const { + return values_.Get(index); +} +inline const ::io::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::values(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.VirtualTable.values) + return _internal_values(index); +} +inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::_internal_add_values() { + return values_.Add(); +} +inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::add_values() { + // @@protoc_insertion_point(field_add:io.substrait.ReadRel.VirtualTable.values) + return _internal_add_values(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >& +ReadRel_VirtualTable::values() const { + // @@protoc_insertion_point(field_list:io.substrait.ReadRel.VirtualTable.values) + return values_; +} + +// ------------------------------------------------------------------- + +// ReadRel_LocalFiles_FileOrFiles + +// string uri_path = 1; +inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_path() const { + return path_type_case() == kUriPath; +} +inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_path() const { + return _internal_has_uri_path(); +} +inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path() { + _oneof_case_[0] = kUriPath; +} +inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path() { + if (_internal_has_uri_path()) { + path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_path_type(); + } +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + return _internal_uri_path(); +} +template +inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_uri_path()) { + clear_path_type(); + set_has_uri_path(); + path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + return _internal_mutable_uri_path(); +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path() const { + if (_internal_has_uri_path()) { + return path_type_.uri_path_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path(const std::string& value) { + if (!_internal_has_uri_path()) { + clear_path_type(); + set_has_uri_path(); + path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path() { + if (!_internal_has_uri_path()) { + clear_path_type(); + set_has_uri_path(); + path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return path_type_.uri_path_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + if (_internal_has_uri_path()) { + clear_has_path_type(); + return path_type_.uri_path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path(std::string* uri_path) { + if (has_path_type()) { + clear_path_type(); + } + if (uri_path != nullptr) { + set_has_uri_path(); + path_type_.uri_path_.UnsafeSetDefault(uri_path); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(uri_path); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) +} + +// string uri_path_glob = 2; +inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_path_glob() const { + return path_type_case() == kUriPathGlob; +} +inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_path_glob() const { + return _internal_has_uri_path_glob(); +} +inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path_glob() { + _oneof_case_[0] = kUriPathGlob; +} +inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path_glob() { + if (_internal_has_uri_path_glob()) { + path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_path_type(); + } +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path_glob() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + return _internal_uri_path_glob(); +} +template +inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path_glob(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_uri_path_glob()) { + clear_path_type(); + set_has_uri_path_glob(); + path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path_glob() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + return _internal_mutable_uri_path_glob(); +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path_glob() const { + if (_internal_has_uri_path_glob()) { + return path_type_.uri_path_glob_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path_glob(const std::string& value) { + if (!_internal_has_uri_path_glob()) { + clear_path_type(); + set_has_uri_path_glob(); + path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path_glob() { + if (!_internal_has_uri_path_glob()) { + clear_path_type(); + set_has_uri_path_glob(); + path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return path_type_.uri_path_glob_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path_glob() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + if (_internal_has_uri_path_glob()) { + clear_has_path_type(); + return path_type_.uri_path_glob_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path_glob(std::string* uri_path_glob) { + if (has_path_type()) { + clear_path_type(); + } + if (uri_path_glob != nullptr) { + set_has_uri_path_glob(); + path_type_.uri_path_glob_.UnsafeSetDefault(uri_path_glob); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(uri_path_glob); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) +} + +// .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 3; +inline void ReadRel_LocalFiles_FileOrFiles::clear_format() { + format_ = 0; +} +inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::_internal_format() const { + return static_cast< ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format >(format_); +} +inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::format() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.format) + return _internal_format(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value) { + + format_ = value; +} +inline void ReadRel_LocalFiles_FileOrFiles::set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value) { + _internal_set_format(value); + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.format) +} + +inline bool ReadRel_LocalFiles_FileOrFiles::has_path_type() const { + return path_type_case() != PATH_TYPE_NOT_SET; +} +inline void ReadRel_LocalFiles_FileOrFiles::clear_has_path_type() { + _oneof_case_[0] = PATH_TYPE_NOT_SET; +} +inline ReadRel_LocalFiles_FileOrFiles::PathTypeCase ReadRel_LocalFiles_FileOrFiles::path_type_case() const { + return ReadRel_LocalFiles_FileOrFiles::PathTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// ReadRel_LocalFiles + +// repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; +inline int ReadRel_LocalFiles::_internal_items_size() const { + return items_.size(); +} +inline int ReadRel_LocalFiles::items_size() const { + return _internal_items_size(); +} +inline void ReadRel_LocalFiles::clear_items() { + items_.Clear(); +} +inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::mutable_items(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.items) + return items_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >* +ReadRel_LocalFiles::mutable_items() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.LocalFiles.items) + return &items_; +} +inline const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::_internal_items(int index) const { + return items_.Get(index); +} +inline const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::items(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.items) + return _internal_items(index); +} +inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::_internal_add_items() { + return items_.Add(); +} +inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::add_items() { + // @@protoc_insertion_point(field_add:io.substrait.ReadRel.LocalFiles.items) + return _internal_add_items(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >& +ReadRel_LocalFiles::items() const { + // @@protoc_insertion_point(field_list:io.substrait.ReadRel.LocalFiles.items) + return items_; +} + +// ------------------------------------------------------------------- + +// ReadRel + +// .io.substrait.RelCommon common = 1; +inline bool ReadRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; +} +inline bool ReadRel::has_common() const { + return _internal_has_common(); +} +inline void ReadRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; +} +inline const ::io::substrait::RelCommon& ReadRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); +} +inline const ::io::substrait::RelCommon& ReadRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.common) + return _internal_common(); +} +inline void ReadRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + } + common_ = common; + if (common) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.common) +} +inline ::io::substrait::RelCommon* ReadRel::release_common() { + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon* ReadRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.common) + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon* ReadRel::_internal_mutable_common() { + + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; + } + return common_; +} +inline ::io::substrait::RelCommon* ReadRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.common) + return _internal_mutable_common(); +} +inline void ReadRel::set_allocated_common(::io::substrait::RelCommon* common) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete common_; + } + if (common) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + if (message_arena != submessage_arena) { + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); + } + + } else { + + } + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.common) +} + +// .io.substrait.Type.NamedStruct base_schema = 2; +inline bool ReadRel::_internal_has_base_schema() const { + return this != internal_default_instance() && base_schema_ != nullptr; +} +inline bool ReadRel::has_base_schema() const { + return _internal_has_base_schema(); +} +inline const ::io::substrait::Type_NamedStruct& ReadRel::_internal_base_schema() const { + const ::io::substrait::Type_NamedStruct* p = base_schema_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_NamedStruct_default_instance_); +} +inline const ::io::substrait::Type_NamedStruct& ReadRel::base_schema() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.base_schema) + return _internal_base_schema(); +} +inline void ReadRel::unsafe_arena_set_allocated_base_schema( + ::io::substrait::Type_NamedStruct* base_schema) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); + } + base_schema_ = base_schema; + if (base_schema) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.base_schema) +} +inline ::io::substrait::Type_NamedStruct* ReadRel::release_base_schema() { + + ::io::substrait::Type_NamedStruct* temp = base_schema_; + base_schema_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_NamedStruct* ReadRel::unsafe_arena_release_base_schema() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.base_schema) + + ::io::substrait::Type_NamedStruct* temp = base_schema_; + base_schema_ = nullptr; + return temp; +} +inline ::io::substrait::Type_NamedStruct* ReadRel::_internal_mutable_base_schema() { + + if (base_schema_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_NamedStruct>(GetArena()); + base_schema_ = p; + } + return base_schema_; +} +inline ::io::substrait::Type_NamedStruct* ReadRel::mutable_base_schema() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.base_schema) + return _internal_mutable_base_schema(); +} +inline void ReadRel::set_allocated_base_schema(::io::substrait::Type_NamedStruct* base_schema) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); + } + if (base_schema) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema)->GetArena(); + if (message_arena != submessage_arena) { + base_schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, base_schema, submessage_arena); + } + + } else { + + } + base_schema_ = base_schema; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.base_schema) +} + +// .io.substrait.Expression filter = 3; +inline bool ReadRel::_internal_has_filter() const { + return this != internal_default_instance() && filter_ != nullptr; +} +inline bool ReadRel::has_filter() const { + return _internal_has_filter(); +} +inline const ::io::substrait::Expression& ReadRel::_internal_filter() const { + const ::io::substrait::Expression* p = filter_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& ReadRel::filter() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.filter) + return _internal_filter(); +} +inline void ReadRel::unsafe_arena_set_allocated_filter( + ::io::substrait::Expression* filter) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); + } + filter_ = filter; + if (filter) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.filter) +} +inline ::io::substrait::Expression* ReadRel::release_filter() { + + ::io::substrait::Expression* temp = filter_; + filter_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* ReadRel::unsafe_arena_release_filter() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.filter) + + ::io::substrait::Expression* temp = filter_; + filter_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* ReadRel::_internal_mutable_filter() { + + if (filter_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + filter_ = p; + } + return filter_; +} +inline ::io::substrait::Expression* ReadRel::mutable_filter() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.filter) + return _internal_mutable_filter(); +} +inline void ReadRel::set_allocated_filter(::io::substrait::Expression* filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); + } + if (filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter)->GetArena(); + if (message_arena != submessage_arena) { + filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, filter, submessage_arena); + } + + } else { + + } + filter_ = filter; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.filter) +} + +// .io.substrait.MaskExpression projection = 4; +inline bool ReadRel::_internal_has_projection() const { + return this != internal_default_instance() && projection_ != nullptr; +} +inline bool ReadRel::has_projection() const { + return _internal_has_projection(); +} +inline const ::io::substrait::MaskExpression& ReadRel::_internal_projection() const { + const ::io::substrait::MaskExpression* p = projection_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_MaskExpression_default_instance_); +} +inline const ::io::substrait::MaskExpression& ReadRel::projection() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.projection) + return _internal_projection(); +} +inline void ReadRel::unsafe_arena_set_allocated_projection( + ::io::substrait::MaskExpression* projection) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); + } + projection_ = projection; + if (projection) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.projection) +} +inline ::io::substrait::MaskExpression* ReadRel::release_projection() { + + ::io::substrait::MaskExpression* temp = projection_; + projection_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::MaskExpression* ReadRel::unsafe_arena_release_projection() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.projection) + + ::io::substrait::MaskExpression* temp = projection_; + projection_ = nullptr; + return temp; +} +inline ::io::substrait::MaskExpression* ReadRel::_internal_mutable_projection() { + + if (projection_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::MaskExpression>(GetArena()); + projection_ = p; + } + return projection_; +} +inline ::io::substrait::MaskExpression* ReadRel::mutable_projection() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.projection) + return _internal_mutable_projection(); +} +inline void ReadRel::set_allocated_projection(::io::substrait::MaskExpression* projection) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); + } + if (projection) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection)->GetArena(); + if (message_arena != submessage_arena) { + projection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, projection, submessage_arena); + } + + } else { + + } + projection_ = projection; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.projection) +} + +// .io.substrait.ReadRel.VirtualTable virtual_table = 5; +inline bool ReadRel::_internal_has_virtual_table() const { + return read_type_case() == kVirtualTable; +} +inline bool ReadRel::has_virtual_table() const { + return _internal_has_virtual_table(); +} +inline void ReadRel::set_has_virtual_table() { + _oneof_case_[0] = kVirtualTable; +} +inline void ReadRel::clear_virtual_table() { + if (_internal_has_virtual_table()) { + if (GetArena() == nullptr) { + delete read_type_.virtual_table_; + } + clear_has_read_type(); + } +} +inline ::io::substrait::ReadRel_VirtualTable* ReadRel::release_virtual_table() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.virtual_table) + if (_internal_has_virtual_table()) { + clear_has_read_type(); + ::io::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + read_type_.virtual_table_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReadRel_VirtualTable& ReadRel::_internal_virtual_table() const { + return _internal_has_virtual_table() + ? *read_type_.virtual_table_ + : reinterpret_cast< ::io::substrait::ReadRel_VirtualTable&>(::io::substrait::_ReadRel_VirtualTable_default_instance_); +} +inline const ::io::substrait::ReadRel_VirtualTable& ReadRel::virtual_table() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.virtual_table) + return _internal_virtual_table(); +} +inline ::io::substrait::ReadRel_VirtualTable* ReadRel::unsafe_arena_release_virtual_table() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.virtual_table) + if (_internal_has_virtual_table()) { + clear_has_read_type(); + ::io::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; + read_type_.virtual_table_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ReadRel::unsafe_arena_set_allocated_virtual_table(::io::substrait::ReadRel_VirtualTable* virtual_table) { + clear_read_type(); + if (virtual_table) { + set_has_virtual_table(); + read_type_.virtual_table_ = virtual_table; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.virtual_table) +} +inline ::io::substrait::ReadRel_VirtualTable* ReadRel::_internal_mutable_virtual_table() { + if (!_internal_has_virtual_table()) { + clear_read_type(); + set_has_virtual_table(); + read_type_.virtual_table_ = CreateMaybeMessage< ::io::substrait::ReadRel_VirtualTable >(GetArena()); + } + return read_type_.virtual_table_; +} +inline ::io::substrait::ReadRel_VirtualTable* ReadRel::mutable_virtual_table() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.virtual_table) + return _internal_mutable_virtual_table(); +} + +// .io.substrait.ReadRel.LocalFiles local_files = 6; +inline bool ReadRel::_internal_has_local_files() const { + return read_type_case() == kLocalFiles; +} +inline bool ReadRel::has_local_files() const { + return _internal_has_local_files(); +} +inline void ReadRel::set_has_local_files() { + _oneof_case_[0] = kLocalFiles; +} +inline void ReadRel::clear_local_files() { + if (_internal_has_local_files()) { + if (GetArena() == nullptr) { + delete read_type_.local_files_; + } + clear_has_read_type(); + } +} +inline ::io::substrait::ReadRel_LocalFiles* ReadRel::release_local_files() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.local_files) + if (_internal_has_local_files()) { + clear_has_read_type(); + ::io::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + read_type_.local_files_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReadRel_LocalFiles& ReadRel::_internal_local_files() const { + return _internal_has_local_files() + ? *read_type_.local_files_ + : reinterpret_cast< ::io::substrait::ReadRel_LocalFiles&>(::io::substrait::_ReadRel_LocalFiles_default_instance_); +} +inline const ::io::substrait::ReadRel_LocalFiles& ReadRel::local_files() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.local_files) + return _internal_local_files(); +} +inline ::io::substrait::ReadRel_LocalFiles* ReadRel::unsafe_arena_release_local_files() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.local_files) + if (_internal_has_local_files()) { + clear_has_read_type(); + ::io::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; + read_type_.local_files_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ReadRel::unsafe_arena_set_allocated_local_files(::io::substrait::ReadRel_LocalFiles* local_files) { + clear_read_type(); + if (local_files) { + set_has_local_files(); + read_type_.local_files_ = local_files; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.local_files) +} +inline ::io::substrait::ReadRel_LocalFiles* ReadRel::_internal_mutable_local_files() { + if (!_internal_has_local_files()) { + clear_read_type(); + set_has_local_files(); + read_type_.local_files_ = CreateMaybeMessage< ::io::substrait::ReadRel_LocalFiles >(GetArena()); + } + return read_type_.local_files_; +} +inline ::io::substrait::ReadRel_LocalFiles* ReadRel::mutable_local_files() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.local_files) + return _internal_mutable_local_files(); +} + +// .io.substrait.ReadRel.NamedTable named_table = 7; +inline bool ReadRel::_internal_has_named_table() const { + return read_type_case() == kNamedTable; +} +inline bool ReadRel::has_named_table() const { + return _internal_has_named_table(); +} +inline void ReadRel::set_has_named_table() { + _oneof_case_[0] = kNamedTable; +} +inline void ReadRel::clear_named_table() { + if (_internal_has_named_table()) { + if (GetArena() == nullptr) { + delete read_type_.named_table_; + } + clear_has_read_type(); + } +} +inline ::io::substrait::ReadRel_NamedTable* ReadRel::release_named_table() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.named_table) + if (_internal_has_named_table()) { + clear_has_read_type(); + ::io::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + read_type_.named_table_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReadRel_NamedTable& ReadRel::_internal_named_table() const { + return _internal_has_named_table() + ? *read_type_.named_table_ + : reinterpret_cast< ::io::substrait::ReadRel_NamedTable&>(::io::substrait::_ReadRel_NamedTable_default_instance_); +} +inline const ::io::substrait::ReadRel_NamedTable& ReadRel::named_table() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.named_table) + return _internal_named_table(); +} +inline ::io::substrait::ReadRel_NamedTable* ReadRel::unsafe_arena_release_named_table() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.named_table) + if (_internal_has_named_table()) { + clear_has_read_type(); + ::io::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; + read_type_.named_table_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ReadRel::unsafe_arena_set_allocated_named_table(::io::substrait::ReadRel_NamedTable* named_table) { + clear_read_type(); + if (named_table) { + set_has_named_table(); + read_type_.named_table_ = named_table; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.named_table) +} +inline ::io::substrait::ReadRel_NamedTable* ReadRel::_internal_mutable_named_table() { + if (!_internal_has_named_table()) { + clear_read_type(); + set_has_named_table(); + read_type_.named_table_ = CreateMaybeMessage< ::io::substrait::ReadRel_NamedTable >(GetArena()); + } + return read_type_.named_table_; +} +inline ::io::substrait::ReadRel_NamedTable* ReadRel::mutable_named_table() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.named_table) + return _internal_mutable_named_table(); +} + +inline bool ReadRel::has_read_type() const { + return read_type_case() != READ_TYPE_NOT_SET; +} +inline void ReadRel::clear_has_read_type() { + _oneof_case_[0] = READ_TYPE_NOT_SET; +} +inline ReadRel::ReadTypeCase ReadRel::read_type_case() const { + return ReadRel::ReadTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// ProjectRel + +// .io.substrait.RelCommon common = 1; +inline bool ProjectRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; +} +inline bool ProjectRel::has_common() const { + return _internal_has_common(); +} +inline void ProjectRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; +} +inline const ::io::substrait::RelCommon& ProjectRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); +} +inline const ::io::substrait::RelCommon& ProjectRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.common) + return _internal_common(); +} +inline void ProjectRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + } + common_ = common; + if (common) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ProjectRel.common) +} +inline ::io::substrait::RelCommon* ProjectRel::release_common() { + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon* ProjectRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.ProjectRel.common) + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon* ProjectRel::_internal_mutable_common() { + + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; + } + return common_; +} +inline ::io::substrait::RelCommon* ProjectRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.common) + return _internal_mutable_common(); +} +inline void ProjectRel::set_allocated_common(::io::substrait::RelCommon* common) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete common_; + } + if (common) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + if (message_arena != submessage_arena) { + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); + } + + } else { + + } + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ProjectRel.common) +} + +// .io.substrait.Rel input = 2; +inline bool ProjectRel::_internal_has_input() const { + return this != internal_default_instance() && input_ != nullptr; +} +inline bool ProjectRel::has_input() const { + return _internal_has_input(); +} +inline void ProjectRel::clear_input() { + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; +} +inline const ::io::substrait::Rel& ProjectRel::_internal_input() const { + const ::io::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); +} +inline const ::io::substrait::Rel& ProjectRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.input) + return _internal_input(); +} +inline void ProjectRel::unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); + } + input_ = input; + if (input) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ProjectRel.input) +} +inline ::io::substrait::Rel* ProjectRel::release_input() { + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Rel* ProjectRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.ProjectRel.input) + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + return temp; +} +inline ::io::substrait::Rel* ProjectRel::_internal_mutable_input() { + + if (input_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + input_ = p; + } + return input_; +} +inline ::io::substrait::Rel* ProjectRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.input) + return _internal_mutable_input(); +} +inline void ProjectRel::set_allocated_input(::io::substrait::Rel* input) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete input_; + } + if (input) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + if (message_arena != submessage_arena) { + input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input, submessage_arena); + } + + } else { + + } + input_ = input; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ProjectRel.input) +} + +// repeated .io.substrait.Expression expressions = 3; +inline int ProjectRel::_internal_expressions_size() const { + return expressions_.size(); +} +inline int ProjectRel::expressions_size() const { + return _internal_expressions_size(); +} +inline ::io::substrait::Expression* ProjectRel::mutable_expressions(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.expressions) + return expressions_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +ProjectRel::mutable_expressions() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ProjectRel.expressions) + return &expressions_; +} +inline const ::io::substrait::Expression& ProjectRel::_internal_expressions(int index) const { + return expressions_.Get(index); +} +inline const ::io::substrait::Expression& ProjectRel::expressions(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.expressions) + return _internal_expressions(index); +} +inline ::io::substrait::Expression* ProjectRel::_internal_add_expressions() { + return expressions_.Add(); +} +inline ::io::substrait::Expression* ProjectRel::add_expressions() { + // @@protoc_insertion_point(field_add:io.substrait.ProjectRel.expressions) + return _internal_add_expressions(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +ProjectRel::expressions() const { + // @@protoc_insertion_point(field_list:io.substrait.ProjectRel.expressions) + return expressions_; +} + +// ------------------------------------------------------------------- + +// JoinRel + +// .io.substrait.RelCommon common = 1; +inline bool JoinRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; +} +inline bool JoinRel::has_common() const { + return _internal_has_common(); +} +inline void JoinRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; +} +inline const ::io::substrait::RelCommon& JoinRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); +} +inline const ::io::substrait::RelCommon& JoinRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.common) + return _internal_common(); +} +inline void JoinRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + } + common_ = common; + if (common) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.common) +} +inline ::io::substrait::RelCommon* JoinRel::release_common() { + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon* JoinRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.common) + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon* JoinRel::_internal_mutable_common() { + + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; + } + return common_; +} +inline ::io::substrait::RelCommon* JoinRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.common) + return _internal_mutable_common(); +} +inline void JoinRel::set_allocated_common(::io::substrait::RelCommon* common) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete common_; + } + if (common) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + if (message_arena != submessage_arena) { + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); + } + + } else { + + } + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.common) +} + +// .io.substrait.Rel left = 2; +inline bool JoinRel::_internal_has_left() const { + return this != internal_default_instance() && left_ != nullptr; +} +inline bool JoinRel::has_left() const { + return _internal_has_left(); +} +inline void JoinRel::clear_left() { + if (GetArena() == nullptr && left_ != nullptr) { + delete left_; + } + left_ = nullptr; +} +inline const ::io::substrait::Rel& JoinRel::_internal_left() const { + const ::io::substrait::Rel* p = left_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); +} +inline const ::io::substrait::Rel& JoinRel::left() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.left) + return _internal_left(); +} +inline void JoinRel::unsafe_arena_set_allocated_left( + ::io::substrait::Rel* left) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(left_); + } + left_ = left; + if (left) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.left) +} +inline ::io::substrait::Rel* JoinRel::release_left() { + + ::io::substrait::Rel* temp = left_; + left_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Rel* JoinRel::unsafe_arena_release_left() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.left) + + ::io::substrait::Rel* temp = left_; + left_ = nullptr; + return temp; +} +inline ::io::substrait::Rel* JoinRel::_internal_mutable_left() { + + if (left_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + left_ = p; + } + return left_; +} +inline ::io::substrait::Rel* JoinRel::mutable_left() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.left) + return _internal_mutable_left(); +} +inline void JoinRel::set_allocated_left(::io::substrait::Rel* left) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete left_; + } + if (left) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(left); + if (message_arena != submessage_arena) { + left = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, left, submessage_arena); + } + + } else { + + } + left_ = left; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.left) +} + +// .io.substrait.Rel right = 3; +inline bool JoinRel::_internal_has_right() const { + return this != internal_default_instance() && right_ != nullptr; +} +inline bool JoinRel::has_right() const { + return _internal_has_right(); +} +inline void JoinRel::clear_right() { + if (GetArena() == nullptr && right_ != nullptr) { + delete right_; + } + right_ = nullptr; +} +inline const ::io::substrait::Rel& JoinRel::_internal_right() const { + const ::io::substrait::Rel* p = right_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); +} +inline const ::io::substrait::Rel& JoinRel::right() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.right) + return _internal_right(); +} +inline void JoinRel::unsafe_arena_set_allocated_right( + ::io::substrait::Rel* right) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(right_); + } + right_ = right; + if (right) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.right) +} +inline ::io::substrait::Rel* JoinRel::release_right() { + + ::io::substrait::Rel* temp = right_; + right_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Rel* JoinRel::unsafe_arena_release_right() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.right) + + ::io::substrait::Rel* temp = right_; + right_ = nullptr; + return temp; +} +inline ::io::substrait::Rel* JoinRel::_internal_mutable_right() { + + if (right_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + right_ = p; + } + return right_; +} +inline ::io::substrait::Rel* JoinRel::mutable_right() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.right) + return _internal_mutable_right(); +} +inline void JoinRel::set_allocated_right(::io::substrait::Rel* right) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete right_; + } + if (right) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(right); + if (message_arena != submessage_arena) { + right = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, right, submessage_arena); + } + + } else { + + } + right_ = right; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.right) +} + +// .io.substrait.Expression expression = 4; +inline bool JoinRel::_internal_has_expression() const { + return this != internal_default_instance() && expression_ != nullptr; +} +inline bool JoinRel::has_expression() const { + return _internal_has_expression(); +} +inline const ::io::substrait::Expression& JoinRel::_internal_expression() const { + const ::io::substrait::Expression* p = expression_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& JoinRel::expression() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.expression) + return _internal_expression(); +} +inline void JoinRel::unsafe_arena_set_allocated_expression( + ::io::substrait::Expression* expression) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); + } + expression_ = expression; + if (expression) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.expression) +} +inline ::io::substrait::Expression* JoinRel::release_expression() { + + ::io::substrait::Expression* temp = expression_; + expression_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* JoinRel::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.expression) + + ::io::substrait::Expression* temp = expression_; + expression_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* JoinRel::_internal_mutable_expression() { + + if (expression_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + expression_ = p; + } + return expression_; +} +inline ::io::substrait::Expression* JoinRel::mutable_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.expression) + return _internal_mutable_expression(); +} +inline void JoinRel::set_allocated_expression(::io::substrait::Expression* expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); + } + if (expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression)->GetArena(); + if (message_arena != submessage_arena) { + expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expression, submessage_arena); + } + + } else { + + } + expression_ = expression; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.expression) +} + +// .io.substrait.Expression post_join_filter = 5; +inline bool JoinRel::_internal_has_post_join_filter() const { + return this != internal_default_instance() && post_join_filter_ != nullptr; +} +inline bool JoinRel::has_post_join_filter() const { + return _internal_has_post_join_filter(); +} +inline const ::io::substrait::Expression& JoinRel::_internal_post_join_filter() const { + const ::io::substrait::Expression* p = post_join_filter_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& JoinRel::post_join_filter() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.post_join_filter) + return _internal_post_join_filter(); +} +inline void JoinRel::unsafe_arena_set_allocated_post_join_filter( + ::io::substrait::Expression* post_join_filter) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); + } + post_join_filter_ = post_join_filter; + if (post_join_filter) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.post_join_filter) +} +inline ::io::substrait::Expression* JoinRel::release_post_join_filter() { + + ::io::substrait::Expression* temp = post_join_filter_; + post_join_filter_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* JoinRel::unsafe_arena_release_post_join_filter() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.post_join_filter) + + ::io::substrait::Expression* temp = post_join_filter_; + post_join_filter_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* JoinRel::_internal_mutable_post_join_filter() { + + if (post_join_filter_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + post_join_filter_ = p; + } + return post_join_filter_; +} +inline ::io::substrait::Expression* JoinRel::mutable_post_join_filter() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.post_join_filter) + return _internal_mutable_post_join_filter(); +} +inline void JoinRel::set_allocated_post_join_filter(::io::substrait::Expression* post_join_filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); + } + if (post_join_filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter)->GetArena(); + if (message_arena != submessage_arena) { + post_join_filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, post_join_filter, submessage_arena); + } + + } else { + + } + post_join_filter_ = post_join_filter; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.post_join_filter) +} + +// .io.substrait.JoinRel.JoinType type = 6; +inline void JoinRel::clear_type() { + type_ = 0; +} +inline ::io::substrait::JoinRel_JoinType JoinRel::_internal_type() const { + return static_cast< ::io::substrait::JoinRel_JoinType >(type_); +} +inline ::io::substrait::JoinRel_JoinType JoinRel::type() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.type) + return _internal_type(); +} +inline void JoinRel::_internal_set_type(::io::substrait::JoinRel_JoinType value) { + + type_ = value; +} +inline void JoinRel::set_type(::io::substrait::JoinRel_JoinType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:io.substrait.JoinRel.type) +} + +// ------------------------------------------------------------------- + +// FetchRel + +// .io.substrait.RelCommon common = 1; +inline bool FetchRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; +} +inline bool FetchRel::has_common() const { + return _internal_has_common(); +} +inline void FetchRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; +} +inline const ::io::substrait::RelCommon& FetchRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); +} +inline const ::io::substrait::RelCommon& FetchRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.FetchRel.common) + return _internal_common(); +} +inline void FetchRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + } + common_ = common; + if (common) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FetchRel.common) +} +inline ::io::substrait::RelCommon* FetchRel::release_common() { + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon* FetchRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.FetchRel.common) + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon* FetchRel::_internal_mutable_common() { + + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; + } + return common_; +} +inline ::io::substrait::RelCommon* FetchRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.FetchRel.common) + return _internal_mutable_common(); +} +inline void FetchRel::set_allocated_common(::io::substrait::RelCommon* common) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete common_; + } + if (common) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + if (message_arena != submessage_arena) { + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); + } + + } else { + + } + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FetchRel.common) +} + +// .io.substrait.Rel input = 2; +inline bool FetchRel::_internal_has_input() const { + return this != internal_default_instance() && input_ != nullptr; +} +inline bool FetchRel::has_input() const { + return _internal_has_input(); +} +inline void FetchRel::clear_input() { + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; +} +inline const ::io::substrait::Rel& FetchRel::_internal_input() const { + const ::io::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); +} +inline const ::io::substrait::Rel& FetchRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.FetchRel.input) + return _internal_input(); +} +inline void FetchRel::unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); + } + input_ = input; + if (input) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FetchRel.input) +} +inline ::io::substrait::Rel* FetchRel::release_input() { + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Rel* FetchRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.FetchRel.input) + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + return temp; +} +inline ::io::substrait::Rel* FetchRel::_internal_mutable_input() { + + if (input_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + input_ = p; + } + return input_; +} +inline ::io::substrait::Rel* FetchRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.FetchRel.input) + return _internal_mutable_input(); +} +inline void FetchRel::set_allocated_input(::io::substrait::Rel* input) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete input_; + } + if (input) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + if (message_arena != submessage_arena) { + input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input, submessage_arena); + } + + } else { + + } + input_ = input; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FetchRel.input) +} + +// int64 offset = 3; +inline void FetchRel::clear_offset() { + offset_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::_internal_offset() const { + return offset_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::offset() const { + // @@protoc_insertion_point(field_get:io.substrait.FetchRel.offset) + return _internal_offset(); +} +inline void FetchRel::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + + offset_ = value; +} +inline void FetchRel::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:io.substrait.FetchRel.offset) +} + +// int64 count = 4; +inline void FetchRel::clear_count() { + count_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::_internal_count() const { + return count_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::count() const { + // @@protoc_insertion_point(field_get:io.substrait.FetchRel.count) + return _internal_count(); +} +inline void FetchRel::_internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { + + count_ = value; +} +inline void FetchRel::set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_count(value); + // @@protoc_insertion_point(field_set:io.substrait.FetchRel.count) +} + +// ------------------------------------------------------------------- + +// AggregateRel_Grouping + +// repeated int32 input_fields = 1; +inline int AggregateRel_Grouping::_internal_input_fields_size() const { + return input_fields_.size(); +} +inline int AggregateRel_Grouping::input_fields_size() const { + return _internal_input_fields_size(); +} +inline void AggregateRel_Grouping::clear_input_fields() { + input_fields_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 AggregateRel_Grouping::_internal_input_fields(int index) const { + return input_fields_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 AggregateRel_Grouping::input_fields(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.Grouping.input_fields) + return _internal_input_fields(index); +} +inline void AggregateRel_Grouping::set_input_fields(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { + input_fields_.Set(index, value); + // @@protoc_insertion_point(field_set:io.substrait.AggregateRel.Grouping.input_fields) +} +inline void AggregateRel_Grouping::_internal_add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value) { + input_fields_.Add(value); +} +inline void AggregateRel_Grouping::add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_add_input_fields(value); + // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.Grouping.input_fields) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +AggregateRel_Grouping::_internal_input_fields() const { + return input_fields_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +AggregateRel_Grouping::input_fields() const { + // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.Grouping.input_fields) + return _internal_input_fields(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +AggregateRel_Grouping::_internal_mutable_input_fields() { + return &input_fields_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +AggregateRel_Grouping::mutable_input_fields() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.Grouping.input_fields) + return _internal_mutable_input_fields(); +} + +// ------------------------------------------------------------------- + +// AggregateRel_Measure + +// .io.substrait.Expression.AggregateFunction measure = 1; +inline bool AggregateRel_Measure::_internal_has_measure() const { + return this != internal_default_instance() && measure_ != nullptr; +} +inline bool AggregateRel_Measure::has_measure() const { + return _internal_has_measure(); +} +inline const ::io::substrait::Expression_AggregateFunction& AggregateRel_Measure::_internal_measure() const { + const ::io::substrait::Expression_AggregateFunction* p = measure_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_AggregateFunction_default_instance_); +} +inline const ::io::substrait::Expression_AggregateFunction& AggregateRel_Measure::measure() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.Measure.measure) + return _internal_measure(); +} +inline void AggregateRel_Measure::unsafe_arena_set_allocated_measure( + ::io::substrait::Expression_AggregateFunction* measure) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); + } + measure_ = measure; + if (measure) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.Measure.measure) +} +inline ::io::substrait::Expression_AggregateFunction* AggregateRel_Measure::release_measure() { + + ::io::substrait::Expression_AggregateFunction* temp = measure_; + measure_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression_AggregateFunction* AggregateRel_Measure::unsafe_arena_release_measure() { + // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.Measure.measure) + + ::io::substrait::Expression_AggregateFunction* temp = measure_; + measure_ = nullptr; + return temp; +} +inline ::io::substrait::Expression_AggregateFunction* AggregateRel_Measure::_internal_mutable_measure() { + + if (measure_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_AggregateFunction>(GetArena()); + measure_ = p; + } + return measure_; +} +inline ::io::substrait::Expression_AggregateFunction* AggregateRel_Measure::mutable_measure() { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.Measure.measure) + return _internal_mutable_measure(); +} +inline void AggregateRel_Measure::set_allocated_measure(::io::substrait::Expression_AggregateFunction* measure) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); + } + if (measure) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure)->GetArena(); + if (message_arena != submessage_arena) { + measure = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, measure, submessage_arena); + } + + } else { + + } + measure_ = measure; + // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.Measure.measure) +} + +// ------------------------------------------------------------------- + +// AggregateRel + +// .io.substrait.RelCommon common = 1; +inline bool AggregateRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; +} +inline bool AggregateRel::has_common() const { + return _internal_has_common(); +} +inline void AggregateRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; +} +inline const ::io::substrait::RelCommon& AggregateRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); +} +inline const ::io::substrait::RelCommon& AggregateRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.common) + return _internal_common(); +} +inline void AggregateRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + } + common_ = common; + if (common) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.common) +} +inline ::io::substrait::RelCommon* AggregateRel::release_common() { + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon* AggregateRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.common) + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon* AggregateRel::_internal_mutable_common() { + + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; + } + return common_; +} +inline ::io::substrait::RelCommon* AggregateRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.common) + return _internal_mutable_common(); +} +inline void AggregateRel::set_allocated_common(::io::substrait::RelCommon* common) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete common_; + } + if (common) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + if (message_arena != submessage_arena) { + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); + } + + } else { + + } + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.common) +} + +// .io.substrait.Rel input = 2; +inline bool AggregateRel::_internal_has_input() const { + return this != internal_default_instance() && input_ != nullptr; +} +inline bool AggregateRel::has_input() const { + return _internal_has_input(); +} +inline void AggregateRel::clear_input() { + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; +} +inline const ::io::substrait::Rel& AggregateRel::_internal_input() const { + const ::io::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); +} +inline const ::io::substrait::Rel& AggregateRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.input) + return _internal_input(); +} +inline void AggregateRel::unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); + } + input_ = input; + if (input) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.input) +} +inline ::io::substrait::Rel* AggregateRel::release_input() { + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Rel* AggregateRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.input) + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + return temp; +} +inline ::io::substrait::Rel* AggregateRel::_internal_mutable_input() { + + if (input_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + input_ = p; + } + return input_; +} +inline ::io::substrait::Rel* AggregateRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.input) + return _internal_mutable_input(); +} +inline void AggregateRel::set_allocated_input(::io::substrait::Rel* input) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete input_; + } + if (input) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + if (message_arena != submessage_arena) { + input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input, submessage_arena); + } + + } else { + + } + input_ = input; + // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.input) +} + +// repeated .io.substrait.AggregateRel.Grouping groupings = 3; +inline int AggregateRel::_internal_groupings_size() const { + return groupings_.size(); +} +inline int AggregateRel::groupings_size() const { + return _internal_groupings_size(); +} +inline void AggregateRel::clear_groupings() { + groupings_.Clear(); +} +inline ::io::substrait::AggregateRel_Grouping* AggregateRel::mutable_groupings(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.groupings) + return groupings_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >* +AggregateRel::mutable_groupings() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.groupings) + return &groupings_; +} +inline const ::io::substrait::AggregateRel_Grouping& AggregateRel::_internal_groupings(int index) const { + return groupings_.Get(index); +} +inline const ::io::substrait::AggregateRel_Grouping& AggregateRel::groupings(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.groupings) + return _internal_groupings(index); +} +inline ::io::substrait::AggregateRel_Grouping* AggregateRel::_internal_add_groupings() { + return groupings_.Add(); +} +inline ::io::substrait::AggregateRel_Grouping* AggregateRel::add_groupings() { + // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.groupings) + return _internal_add_groupings(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >& +AggregateRel::groupings() const { + // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.groupings) + return groupings_; +} + +// repeated .io.substrait.AggregateRel.Measure measures = 4; +inline int AggregateRel::_internal_measures_size() const { + return measures_.size(); +} +inline int AggregateRel::measures_size() const { + return _internal_measures_size(); +} +inline void AggregateRel::clear_measures() { + measures_.Clear(); +} +inline ::io::substrait::AggregateRel_Measure* AggregateRel::mutable_measures(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.measures) + return measures_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >* +AggregateRel::mutable_measures() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.measures) + return &measures_; +} +inline const ::io::substrait::AggregateRel_Measure& AggregateRel::_internal_measures(int index) const { + return measures_.Get(index); +} +inline const ::io::substrait::AggregateRel_Measure& AggregateRel::measures(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.measures) + return _internal_measures(index); +} +inline ::io::substrait::AggregateRel_Measure* AggregateRel::_internal_add_measures() { + return measures_.Add(); +} +inline ::io::substrait::AggregateRel_Measure* AggregateRel::add_measures() { + // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.measures) + return _internal_add_measures(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >& +AggregateRel::measures() const { + // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.measures) + return measures_; +} + +// .io.substrait.Expression.AggregationPhase phase = 5; +inline void AggregateRel::clear_phase() { + phase_ = 0; +} +inline ::io::substrait::Expression_AggregationPhase AggregateRel::_internal_phase() const { + return static_cast< ::io::substrait::Expression_AggregationPhase >(phase_); +} +inline ::io::substrait::Expression_AggregationPhase AggregateRel::phase() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.phase) + return _internal_phase(); +} +inline void AggregateRel::_internal_set_phase(::io::substrait::Expression_AggregationPhase value) { + + phase_ = value; +} +inline void AggregateRel::set_phase(::io::substrait::Expression_AggregationPhase value) { + _internal_set_phase(value); + // @@protoc_insertion_point(field_set:io.substrait.AggregateRel.phase) +} + +// ------------------------------------------------------------------- + +// SortRel + +// .io.substrait.RelCommon common = 1; +inline bool SortRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; +} +inline bool SortRel::has_common() const { + return _internal_has_common(); +} +inline void SortRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; +} +inline const ::io::substrait::RelCommon& SortRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); +} +inline const ::io::substrait::RelCommon& SortRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.SortRel.common) + return _internal_common(); +} +inline void SortRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + } + common_ = common; + if (common) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortRel.common) +} +inline ::io::substrait::RelCommon* SortRel::release_common() { + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon* SortRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.SortRel.common) + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon* SortRel::_internal_mutable_common() { + + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; + } + return common_; +} +inline ::io::substrait::RelCommon* SortRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.common) + return _internal_mutable_common(); +} +inline void SortRel::set_allocated_common(::io::substrait::RelCommon* common) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete common_; + } + if (common) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + if (message_arena != submessage_arena) { + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); + } + + } else { + + } + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.SortRel.common) +} + +// .io.substrait.Rel input = 2; +inline bool SortRel::_internal_has_input() const { + return this != internal_default_instance() && input_ != nullptr; +} +inline bool SortRel::has_input() const { + return _internal_has_input(); +} +inline void SortRel::clear_input() { + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; +} +inline const ::io::substrait::Rel& SortRel::_internal_input() const { + const ::io::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); +} +inline const ::io::substrait::Rel& SortRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.SortRel.input) + return _internal_input(); +} +inline void SortRel::unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); + } + input_ = input; + if (input) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortRel.input) +} +inline ::io::substrait::Rel* SortRel::release_input() { + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Rel* SortRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.SortRel.input) + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + return temp; +} +inline ::io::substrait::Rel* SortRel::_internal_mutable_input() { + + if (input_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + input_ = p; + } + return input_; +} +inline ::io::substrait::Rel* SortRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.input) + return _internal_mutable_input(); +} +inline void SortRel::set_allocated_input(::io::substrait::Rel* input) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete input_; + } + if (input) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + if (message_arena != submessage_arena) { + input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input, submessage_arena); + } + + } else { + + } + input_ = input; + // @@protoc_insertion_point(field_set_allocated:io.substrait.SortRel.input) +} + +// repeated .io.substrait.Expression.SortField sorts = 3; +inline int SortRel::_internal_sorts_size() const { + return sorts_.size(); +} +inline int SortRel::sorts_size() const { + return _internal_sorts_size(); +} +inline ::io::substrait::Expression_SortField* SortRel::mutable_sorts(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.sorts) + return sorts_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* +SortRel::mutable_sorts() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.SortRel.sorts) + return &sorts_; +} +inline const ::io::substrait::Expression_SortField& SortRel::_internal_sorts(int index) const { + return sorts_.Get(index); +} +inline const ::io::substrait::Expression_SortField& SortRel::sorts(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.SortRel.sorts) + return _internal_sorts(index); +} +inline ::io::substrait::Expression_SortField* SortRel::_internal_add_sorts() { + return sorts_.Add(); +} +inline ::io::substrait::Expression_SortField* SortRel::add_sorts() { + // @@protoc_insertion_point(field_add:io.substrait.SortRel.sorts) + return _internal_add_sorts(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& +SortRel::sorts() const { + // @@protoc_insertion_point(field_list:io.substrait.SortRel.sorts) + return sorts_; +} + +// ------------------------------------------------------------------- + +// FilterRel + +// .io.substrait.RelCommon common = 1; +inline bool FilterRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; +} +inline bool FilterRel::has_common() const { + return _internal_has_common(); +} +inline void FilterRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; +} +inline const ::io::substrait::RelCommon& FilterRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); +} +inline const ::io::substrait::RelCommon& FilterRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.FilterRel.common) + return _internal_common(); +} +inline void FilterRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + } + common_ = common; + if (common) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.common) +} +inline ::io::substrait::RelCommon* FilterRel::release_common() { + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon* FilterRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.FilterRel.common) + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon* FilterRel::_internal_mutable_common() { + + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; + } + return common_; +} +inline ::io::substrait::RelCommon* FilterRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.common) + return _internal_mutable_common(); +} +inline void FilterRel::set_allocated_common(::io::substrait::RelCommon* common) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete common_; + } + if (common) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + if (message_arena != submessage_arena) { + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); + } + + } else { + + } + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.common) +} + +// .io.substrait.Rel input = 2; +inline bool FilterRel::_internal_has_input() const { + return this != internal_default_instance() && input_ != nullptr; +} +inline bool FilterRel::has_input() const { + return _internal_has_input(); +} +inline void FilterRel::clear_input() { + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; +} +inline const ::io::substrait::Rel& FilterRel::_internal_input() const { + const ::io::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); +} +inline const ::io::substrait::Rel& FilterRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.FilterRel.input) + return _internal_input(); +} +inline void FilterRel::unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); + } + input_ = input; + if (input) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.input) +} +inline ::io::substrait::Rel* FilterRel::release_input() { + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Rel* FilterRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.FilterRel.input) + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + return temp; +} +inline ::io::substrait::Rel* FilterRel::_internal_mutable_input() { + + if (input_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + input_ = p; + } + return input_; +} +inline ::io::substrait::Rel* FilterRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.input) + return _internal_mutable_input(); +} +inline void FilterRel::set_allocated_input(::io::substrait::Rel* input) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete input_; + } + if (input) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + if (message_arena != submessage_arena) { + input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input, submessage_arena); + } + + } else { + + } + input_ = input; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.input) +} + +// .io.substrait.Expression condition = 3; +inline bool FilterRel::_internal_has_condition() const { + return this != internal_default_instance() && condition_ != nullptr; +} +inline bool FilterRel::has_condition() const { + return _internal_has_condition(); +} +inline const ::io::substrait::Expression& FilterRel::_internal_condition() const { + const ::io::substrait::Expression* p = condition_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& FilterRel::condition() const { + // @@protoc_insertion_point(field_get:io.substrait.FilterRel.condition) + return _internal_condition(); +} +inline void FilterRel::unsafe_arena_set_allocated_condition( + ::io::substrait::Expression* condition) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); + } + condition_ = condition; + if (condition) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.condition) +} +inline ::io::substrait::Expression* FilterRel::release_condition() { + + ::io::substrait::Expression* temp = condition_; + condition_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* FilterRel::unsafe_arena_release_condition() { + // @@protoc_insertion_point(field_release:io.substrait.FilterRel.condition) + + ::io::substrait::Expression* temp = condition_; + condition_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* FilterRel::_internal_mutable_condition() { + + if (condition_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + condition_ = p; + } + return condition_; +} +inline ::io::substrait::Expression* FilterRel::mutable_condition() { + // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.condition) + return _internal_mutable_condition(); +} +inline void FilterRel::set_allocated_condition(::io::substrait::Expression* condition) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); + } + if (condition) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition)->GetArena(); + if (message_arena != submessage_arena) { + condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, condition, submessage_arena); + } + + } else { + + } + condition_ = condition; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.condition) +} + +// ------------------------------------------------------------------- + +// SetRel + +// .io.substrait.RelCommon common = 1; +inline bool SetRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; +} +inline bool SetRel::has_common() const { + return _internal_has_common(); +} +inline void SetRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; +} +inline const ::io::substrait::RelCommon& SetRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); +} +inline const ::io::substrait::RelCommon& SetRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.SetRel.common) + return _internal_common(); +} +inline void SetRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + } + common_ = common; + if (common) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SetRel.common) +} +inline ::io::substrait::RelCommon* SetRel::release_common() { + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon* SetRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.SetRel.common) + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon* SetRel::_internal_mutable_common() { + + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; + } + return common_; +} +inline ::io::substrait::RelCommon* SetRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.SetRel.common) + return _internal_mutable_common(); +} +inline void SetRel::set_allocated_common(::io::substrait::RelCommon* common) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete common_; + } + if (common) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + if (message_arena != submessage_arena) { + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); + } + + } else { + + } + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.SetRel.common) +} + +// repeated .io.substrait.Rel inputs = 2; +inline int SetRel::_internal_inputs_size() const { + return inputs_.size(); +} +inline int SetRel::inputs_size() const { + return _internal_inputs_size(); +} +inline void SetRel::clear_inputs() { + inputs_.Clear(); +} +inline ::io::substrait::Rel* SetRel::mutable_inputs(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.SetRel.inputs) + return inputs_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* +SetRel::mutable_inputs() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.SetRel.inputs) + return &inputs_; +} +inline const ::io::substrait::Rel& SetRel::_internal_inputs(int index) const { + return inputs_.Get(index); +} +inline const ::io::substrait::Rel& SetRel::inputs(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.SetRel.inputs) + return _internal_inputs(index); +} +inline ::io::substrait::Rel* SetRel::_internal_add_inputs() { + return inputs_.Add(); +} +inline ::io::substrait::Rel* SetRel::add_inputs() { + // @@protoc_insertion_point(field_add:io.substrait.SetRel.inputs) + return _internal_add_inputs(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& +SetRel::inputs() const { + // @@protoc_insertion_point(field_list:io.substrait.SetRel.inputs) + return inputs_; +} + +// .io.substrait.SetRel.SetOp op = 3; +inline void SetRel::clear_op() { + op_ = 0; +} +inline ::io::substrait::SetRel_SetOp SetRel::_internal_op() const { + return static_cast< ::io::substrait::SetRel_SetOp >(op_); +} +inline ::io::substrait::SetRel_SetOp SetRel::op() const { + // @@protoc_insertion_point(field_get:io.substrait.SetRel.op) + return _internal_op(); +} +inline void SetRel::_internal_set_op(::io::substrait::SetRel_SetOp value) { + + op_ = value; +} +inline void SetRel::set_op(::io::substrait::SetRel_SetOp value) { + _internal_set_op(value); + // @@protoc_insertion_point(field_set:io.substrait.SetRel.op) +} + +// ------------------------------------------------------------------- + +// Rel + +// .io.substrait.ReadRel read = 1; +inline bool Rel::_internal_has_read() const { + return RelType_case() == kRead; +} +inline bool Rel::has_read() const { + return _internal_has_read(); +} +inline void Rel::set_has_read() { + _oneof_case_[0] = kRead; +} +inline void Rel::clear_read() { + if (_internal_has_read()) { + if (GetArena() == nullptr) { + delete RelType_.read_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::ReadRel* Rel::release_read() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.read) + if (_internal_has_read()) { + clear_has_RelType(); + ::io::substrait::ReadRel* temp = RelType_.read_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.read_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReadRel& Rel::_internal_read() const { + return _internal_has_read() + ? *RelType_.read_ + : reinterpret_cast< ::io::substrait::ReadRel&>(::io::substrait::_ReadRel_default_instance_); +} +inline const ::io::substrait::ReadRel& Rel::read() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.read) + return _internal_read(); +} +inline ::io::substrait::ReadRel* Rel::unsafe_arena_release_read() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.read) + if (_internal_has_read()) { + clear_has_RelType(); + ::io::substrait::ReadRel* temp = RelType_.read_; + RelType_.read_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_read(::io::substrait::ReadRel* read) { + clear_RelType(); + if (read) { + set_has_read(); + RelType_.read_ = read; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.read) +} +inline ::io::substrait::ReadRel* Rel::_internal_mutable_read() { + if (!_internal_has_read()) { + clear_RelType(); + set_has_read(); + RelType_.read_ = CreateMaybeMessage< ::io::substrait::ReadRel >(GetArena()); + } + return RelType_.read_; +} +inline ::io::substrait::ReadRel* Rel::mutable_read() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.read) + return _internal_mutable_read(); +} + +// .io.substrait.FilterRel filter = 2; +inline bool Rel::_internal_has_filter() const { + return RelType_case() == kFilter; +} +inline bool Rel::has_filter() const { + return _internal_has_filter(); +} +inline void Rel::set_has_filter() { + _oneof_case_[0] = kFilter; +} +inline void Rel::clear_filter() { + if (_internal_has_filter()) { + if (GetArena() == nullptr) { + delete RelType_.filter_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::FilterRel* Rel::release_filter() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.filter) + if (_internal_has_filter()) { + clear_has_RelType(); + ::io::substrait::FilterRel* temp = RelType_.filter_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.filter_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FilterRel& Rel::_internal_filter() const { + return _internal_has_filter() + ? *RelType_.filter_ + : reinterpret_cast< ::io::substrait::FilterRel&>(::io::substrait::_FilterRel_default_instance_); +} +inline const ::io::substrait::FilterRel& Rel::filter() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.filter) + return _internal_filter(); +} +inline ::io::substrait::FilterRel* Rel::unsafe_arena_release_filter() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.filter) + if (_internal_has_filter()) { + clear_has_RelType(); + ::io::substrait::FilterRel* temp = RelType_.filter_; + RelType_.filter_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_filter(::io::substrait::FilterRel* filter) { + clear_RelType(); + if (filter) { + set_has_filter(); + RelType_.filter_ = filter; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.filter) +} +inline ::io::substrait::FilterRel* Rel::_internal_mutable_filter() { + if (!_internal_has_filter()) { + clear_RelType(); + set_has_filter(); + RelType_.filter_ = CreateMaybeMessage< ::io::substrait::FilterRel >(GetArena()); + } + return RelType_.filter_; +} +inline ::io::substrait::FilterRel* Rel::mutable_filter() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.filter) + return _internal_mutable_filter(); +} + +// .io.substrait.FetchRel fetch = 3; +inline bool Rel::_internal_has_fetch() const { + return RelType_case() == kFetch; +} +inline bool Rel::has_fetch() const { + return _internal_has_fetch(); +} +inline void Rel::set_has_fetch() { + _oneof_case_[0] = kFetch; +} +inline void Rel::clear_fetch() { + if (_internal_has_fetch()) { + if (GetArena() == nullptr) { + delete RelType_.fetch_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::FetchRel* Rel::release_fetch() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.fetch) + if (_internal_has_fetch()) { + clear_has_RelType(); + ::io::substrait::FetchRel* temp = RelType_.fetch_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.fetch_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::FetchRel& Rel::_internal_fetch() const { + return _internal_has_fetch() + ? *RelType_.fetch_ + : reinterpret_cast< ::io::substrait::FetchRel&>(::io::substrait::_FetchRel_default_instance_); +} +inline const ::io::substrait::FetchRel& Rel::fetch() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.fetch) + return _internal_fetch(); +} +inline ::io::substrait::FetchRel* Rel::unsafe_arena_release_fetch() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.fetch) + if (_internal_has_fetch()) { + clear_has_RelType(); + ::io::substrait::FetchRel* temp = RelType_.fetch_; + RelType_.fetch_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_fetch(::io::substrait::FetchRel* fetch) { + clear_RelType(); + if (fetch) { + set_has_fetch(); + RelType_.fetch_ = fetch; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.fetch) +} +inline ::io::substrait::FetchRel* Rel::_internal_mutable_fetch() { + if (!_internal_has_fetch()) { + clear_RelType(); + set_has_fetch(); + RelType_.fetch_ = CreateMaybeMessage< ::io::substrait::FetchRel >(GetArena()); + } + return RelType_.fetch_; +} +inline ::io::substrait::FetchRel* Rel::mutable_fetch() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.fetch) + return _internal_mutable_fetch(); +} + +// .io.substrait.AggregateRel aggregate = 4; +inline bool Rel::_internal_has_aggregate() const { + return RelType_case() == kAggregate; +} +inline bool Rel::has_aggregate() const { + return _internal_has_aggregate(); +} +inline void Rel::set_has_aggregate() { + _oneof_case_[0] = kAggregate; +} +inline void Rel::clear_aggregate() { + if (_internal_has_aggregate()) { + if (GetArena() == nullptr) { + delete RelType_.aggregate_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::AggregateRel* Rel::release_aggregate() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.aggregate) + if (_internal_has_aggregate()) { + clear_has_RelType(); + ::io::substrait::AggregateRel* temp = RelType_.aggregate_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.aggregate_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::AggregateRel& Rel::_internal_aggregate() const { + return _internal_has_aggregate() + ? *RelType_.aggregate_ + : reinterpret_cast< ::io::substrait::AggregateRel&>(::io::substrait::_AggregateRel_default_instance_); +} +inline const ::io::substrait::AggregateRel& Rel::aggregate() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.aggregate) + return _internal_aggregate(); +} +inline ::io::substrait::AggregateRel* Rel::unsafe_arena_release_aggregate() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.aggregate) + if (_internal_has_aggregate()) { + clear_has_RelType(); + ::io::substrait::AggregateRel* temp = RelType_.aggregate_; + RelType_.aggregate_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_aggregate(::io::substrait::AggregateRel* aggregate) { + clear_RelType(); + if (aggregate) { + set_has_aggregate(); + RelType_.aggregate_ = aggregate; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.aggregate) +} +inline ::io::substrait::AggregateRel* Rel::_internal_mutable_aggregate() { + if (!_internal_has_aggregate()) { + clear_RelType(); + set_has_aggregate(); + RelType_.aggregate_ = CreateMaybeMessage< ::io::substrait::AggregateRel >(GetArena()); + } + return RelType_.aggregate_; +} +inline ::io::substrait::AggregateRel* Rel::mutable_aggregate() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.aggregate) + return _internal_mutable_aggregate(); +} + +// .io.substrait.SortRel sort = 5; +inline bool Rel::_internal_has_sort() const { + return RelType_case() == kSort; +} +inline bool Rel::has_sort() const { + return _internal_has_sort(); +} +inline void Rel::set_has_sort() { + _oneof_case_[0] = kSort; +} +inline void Rel::clear_sort() { + if (_internal_has_sort()) { + if (GetArena() == nullptr) { + delete RelType_.sort_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::SortRel* Rel::release_sort() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.sort) + if (_internal_has_sort()) { + clear_has_RelType(); + ::io::substrait::SortRel* temp = RelType_.sort_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.sort_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::SortRel& Rel::_internal_sort() const { + return _internal_has_sort() + ? *RelType_.sort_ + : reinterpret_cast< ::io::substrait::SortRel&>(::io::substrait::_SortRel_default_instance_); +} +inline const ::io::substrait::SortRel& Rel::sort() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.sort) + return _internal_sort(); +} +inline ::io::substrait::SortRel* Rel::unsafe_arena_release_sort() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.sort) + if (_internal_has_sort()) { + clear_has_RelType(); + ::io::substrait::SortRel* temp = RelType_.sort_; + RelType_.sort_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_sort(::io::substrait::SortRel* sort) { + clear_RelType(); + if (sort) { + set_has_sort(); + RelType_.sort_ = sort; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.sort) +} +inline ::io::substrait::SortRel* Rel::_internal_mutable_sort() { + if (!_internal_has_sort()) { + clear_RelType(); + set_has_sort(); + RelType_.sort_ = CreateMaybeMessage< ::io::substrait::SortRel >(GetArena()); + } + return RelType_.sort_; +} +inline ::io::substrait::SortRel* Rel::mutable_sort() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.sort) + return _internal_mutable_sort(); +} + +// .io.substrait.JoinRel join = 6; +inline bool Rel::_internal_has_join() const { + return RelType_case() == kJoin; +} +inline bool Rel::has_join() const { + return _internal_has_join(); +} +inline void Rel::set_has_join() { + _oneof_case_[0] = kJoin; +} +inline void Rel::clear_join() { + if (_internal_has_join()) { + if (GetArena() == nullptr) { + delete RelType_.join_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::JoinRel* Rel::release_join() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.join) + if (_internal_has_join()) { + clear_has_RelType(); + ::io::substrait::JoinRel* temp = RelType_.join_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.join_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::JoinRel& Rel::_internal_join() const { + return _internal_has_join() + ? *RelType_.join_ + : reinterpret_cast< ::io::substrait::JoinRel&>(::io::substrait::_JoinRel_default_instance_); +} +inline const ::io::substrait::JoinRel& Rel::join() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.join) + return _internal_join(); +} +inline ::io::substrait::JoinRel* Rel::unsafe_arena_release_join() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.join) + if (_internal_has_join()) { + clear_has_RelType(); + ::io::substrait::JoinRel* temp = RelType_.join_; + RelType_.join_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_join(::io::substrait::JoinRel* join) { + clear_RelType(); + if (join) { + set_has_join(); + RelType_.join_ = join; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.join) +} +inline ::io::substrait::JoinRel* Rel::_internal_mutable_join() { + if (!_internal_has_join()) { + clear_RelType(); + set_has_join(); + RelType_.join_ = CreateMaybeMessage< ::io::substrait::JoinRel >(GetArena()); + } + return RelType_.join_; +} +inline ::io::substrait::JoinRel* Rel::mutable_join() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.join) + return _internal_mutable_join(); +} + +// .io.substrait.ProjectRel project = 7; +inline bool Rel::_internal_has_project() const { + return RelType_case() == kProject; +} +inline bool Rel::has_project() const { + return _internal_has_project(); +} +inline void Rel::set_has_project() { + _oneof_case_[0] = kProject; +} +inline void Rel::clear_project() { + if (_internal_has_project()) { + if (GetArena() == nullptr) { + delete RelType_.project_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::ProjectRel* Rel::release_project() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.project) + if (_internal_has_project()) { + clear_has_RelType(); + ::io::substrait::ProjectRel* temp = RelType_.project_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.project_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ProjectRel& Rel::_internal_project() const { + return _internal_has_project() + ? *RelType_.project_ + : reinterpret_cast< ::io::substrait::ProjectRel&>(::io::substrait::_ProjectRel_default_instance_); +} +inline const ::io::substrait::ProjectRel& Rel::project() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.project) + return _internal_project(); +} +inline ::io::substrait::ProjectRel* Rel::unsafe_arena_release_project() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.project) + if (_internal_has_project()) { + clear_has_RelType(); + ::io::substrait::ProjectRel* temp = RelType_.project_; + RelType_.project_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_project(::io::substrait::ProjectRel* project) { + clear_RelType(); + if (project) { + set_has_project(); + RelType_.project_ = project; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.project) +} +inline ::io::substrait::ProjectRel* Rel::_internal_mutable_project() { + if (!_internal_has_project()) { + clear_RelType(); + set_has_project(); + RelType_.project_ = CreateMaybeMessage< ::io::substrait::ProjectRel >(GetArena()); + } + return RelType_.project_; +} +inline ::io::substrait::ProjectRel* Rel::mutable_project() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.project) + return _internal_mutable_project(); +} + +// .io.substrait.SetRel set = 8; +inline bool Rel::_internal_has_set() const { + return RelType_case() == kSet; +} +inline bool Rel::has_set() const { + return _internal_has_set(); +} +inline void Rel::set_has_set() { + _oneof_case_[0] = kSet; +} +inline void Rel::clear_set() { + if (_internal_has_set()) { + if (GetArena() == nullptr) { + delete RelType_.set_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::SetRel* Rel::release_set() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.set) + if (_internal_has_set()) { + clear_has_RelType(); + ::io::substrait::SetRel* temp = RelType_.set_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.set_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::SetRel& Rel::_internal_set() const { + return _internal_has_set() + ? *RelType_.set_ + : reinterpret_cast< ::io::substrait::SetRel&>(::io::substrait::_SetRel_default_instance_); +} +inline const ::io::substrait::SetRel& Rel::set() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.set) + return _internal_set(); +} +inline ::io::substrait::SetRel* Rel::unsafe_arena_release_set() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.set) + if (_internal_has_set()) { + clear_has_RelType(); + ::io::substrait::SetRel* temp = RelType_.set_; + RelType_.set_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_set(::io::substrait::SetRel* set) { + clear_RelType(); + if (set) { + set_has_set(); + RelType_.set_ = set; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.set) +} +inline ::io::substrait::SetRel* Rel::_internal_mutable_set() { + if (!_internal_has_set()) { + clear_RelType(); + set_has_set(); + RelType_.set_ = CreateMaybeMessage< ::io::substrait::SetRel >(GetArena()); + } + return RelType_.set_; +} +inline ::io::substrait::SetRel* Rel::mutable_set() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.set) + return _internal_mutable_set(); +} + +inline bool Rel::has_RelType() const { + return RelType_case() != RELTYPE_NOT_SET; +} +inline void Rel::clear_has_RelType() { + _oneof_case_[0] = RELTYPE_NOT_SET; +} +inline Rel::RelTypeCase Rel::RelType_case() const { + return Rel::RelTypeCase(_oneof_case_[0]); +} +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace substrait +} // namespace io + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format>() { + return ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format_descriptor(); +} +template <> struct is_proto_enum< ::io::substrait::JoinRel_JoinType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::JoinRel_JoinType>() { + return ::io::substrait::JoinRel_JoinType_descriptor(); +} +template <> struct is_proto_enum< ::io::substrait::SetRel_SetOp> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::SetRel_SetOp>() { + return ::io::substrait::SetRel_SetOp_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_relations_2eproto diff --git a/cpp/src/generated/substrait/selection.pb.cc b/cpp/src/generated/substrait/selection.pb.cc new file mode 100644 index 00000000000..b72534670dc --- /dev/null +++ b/cpp/src/generated/substrait/selection.pb.cc @@ -0,0 +1,5326 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: selection.proto + +#include "selection.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace io { +namespace substrait { +constexpr ReferenceSegment_MapKey::ReferenceSegment_MapKey( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : map_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , child_(nullptr){} +struct ReferenceSegment_MapKeyDefaultTypeInternal { + constexpr ReferenceSegment_MapKeyDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReferenceSegment_MapKeyDefaultTypeInternal() {} + union { + ReferenceSegment_MapKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegment_MapKeyDefaultTypeInternal _ReferenceSegment_MapKey_default_instance_; +constexpr ReferenceSegment_MapKeyExpression::ReferenceSegment_MapKeyExpression( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : map_key_expression_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , child_(nullptr){} +struct ReferenceSegment_MapKeyExpressionDefaultTypeInternal { + constexpr ReferenceSegment_MapKeyExpressionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReferenceSegment_MapKeyExpressionDefaultTypeInternal() {} + union { + ReferenceSegment_MapKeyExpression _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegment_MapKeyExpressionDefaultTypeInternal _ReferenceSegment_MapKeyExpression_default_instance_; +constexpr ReferenceSegment_StructField::ReferenceSegment_StructField( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : child_(nullptr) + , field_(0){} +struct ReferenceSegment_StructFieldDefaultTypeInternal { + constexpr ReferenceSegment_StructFieldDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReferenceSegment_StructFieldDefaultTypeInternal() {} + union { + ReferenceSegment_StructField _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegment_StructFieldDefaultTypeInternal _ReferenceSegment_StructField_default_instance_; +constexpr ReferenceSegment_ListElement::ReferenceSegment_ListElement( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : child_(nullptr) + , offset_(0){} +struct ReferenceSegment_ListElementDefaultTypeInternal { + constexpr ReferenceSegment_ListElementDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReferenceSegment_ListElementDefaultTypeInternal() {} + union { + ReferenceSegment_ListElement _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegment_ListElementDefaultTypeInternal _ReferenceSegment_ListElement_default_instance_; +constexpr ReferenceSegment_ListRange::ReferenceSegment_ListRange( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : child_(nullptr) + , start_(0) + , end_(0){} +struct ReferenceSegment_ListRangeDefaultTypeInternal { + constexpr ReferenceSegment_ListRangeDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReferenceSegment_ListRangeDefaultTypeInternal() {} + union { + ReferenceSegment_ListRange _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegment_ListRangeDefaultTypeInternal _ReferenceSegment_ListRange_default_instance_; +constexpr ReferenceSegment::ReferenceSegment( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct ReferenceSegmentDefaultTypeInternal { + constexpr ReferenceSegmentDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReferenceSegmentDefaultTypeInternal() {} + union { + ReferenceSegment _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegmentDefaultTypeInternal _ReferenceSegment_default_instance_; +constexpr MaskExpression_Select::MaskExpression_Select( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct MaskExpression_SelectDefaultTypeInternal { + constexpr MaskExpression_SelectDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpression_SelectDefaultTypeInternal() {} + union { + MaskExpression_Select _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_SelectDefaultTypeInternal _MaskExpression_Select_default_instance_; +constexpr MaskExpression_StructSelect::MaskExpression_StructSelect( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : struct_items_(){} +struct MaskExpression_StructSelectDefaultTypeInternal { + constexpr MaskExpression_StructSelectDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpression_StructSelectDefaultTypeInternal() {} + union { + MaskExpression_StructSelect _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_StructSelectDefaultTypeInternal _MaskExpression_StructSelect_default_instance_; +constexpr MaskExpression_StructItem::MaskExpression_StructItem( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : child_(nullptr) + , field_(0){} +struct MaskExpression_StructItemDefaultTypeInternal { + constexpr MaskExpression_StructItemDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpression_StructItemDefaultTypeInternal() {} + union { + MaskExpression_StructItem _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_StructItemDefaultTypeInternal _MaskExpression_StructItem_default_instance_; +constexpr MaskExpression_ListSelect_ListSelectItem_ListElement::MaskExpression_ListSelect_ListSelectItem_ListElement( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : field_(0){} +struct MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal { + constexpr MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal() {} + union { + MaskExpression_ListSelect_ListSelectItem_ListElement _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_; +constexpr MaskExpression_ListSelect_ListSelectItem_ListSlice::MaskExpression_ListSelect_ListSelectItem_ListSlice( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : start_(0) + , end_(0){} +struct MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal { + constexpr MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal() {} + union { + MaskExpression_ListSelect_ListSelectItem_ListSlice _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_; +constexpr MaskExpression_ListSelect_ListSelectItem::MaskExpression_ListSelect_ListSelectItem( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal { + constexpr MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal() {} + union { + MaskExpression_ListSelect_ListSelectItem _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_default_instance_; +constexpr MaskExpression_ListSelect::MaskExpression_ListSelect( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : selection_() + , child_(nullptr){} +struct MaskExpression_ListSelectDefaultTypeInternal { + constexpr MaskExpression_ListSelectDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpression_ListSelectDefaultTypeInternal() {} + union { + MaskExpression_ListSelect _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_ListSelectDefaultTypeInternal _MaskExpression_ListSelect_default_instance_; +constexpr MaskExpression_MapSelect_MapKey::MaskExpression_MapSelect_MapKey( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : map_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct MaskExpression_MapSelect_MapKeyDefaultTypeInternal { + constexpr MaskExpression_MapSelect_MapKeyDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpression_MapSelect_MapKeyDefaultTypeInternal() {} + union { + MaskExpression_MapSelect_MapKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_MapSelect_MapKeyDefaultTypeInternal _MaskExpression_MapSelect_MapKey_default_instance_; +constexpr MaskExpression_MapSelect_MapKeyExpression::MaskExpression_MapSelect_MapKeyExpression( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : map_key_expression_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal { + constexpr MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal() {} + union { + MaskExpression_MapSelect_MapKeyExpression _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _MaskExpression_MapSelect_MapKeyExpression_default_instance_; +constexpr MaskExpression_MapSelect::MaskExpression_MapSelect( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : child_(nullptr) + , _oneof_case_{}{} +struct MaskExpression_MapSelectDefaultTypeInternal { + constexpr MaskExpression_MapSelectDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpression_MapSelectDefaultTypeInternal() {} + union { + MaskExpression_MapSelect _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_MapSelectDefaultTypeInternal _MaskExpression_MapSelect_default_instance_; +constexpr MaskExpression::MaskExpression( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : select_(nullptr) + , maintain_singular_struct_(false){} +struct MaskExpressionDefaultTypeInternal { + constexpr MaskExpressionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~MaskExpressionDefaultTypeInternal() {} + union { + MaskExpression _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpressionDefaultTypeInternal _MaskExpression_default_instance_; +constexpr FieldReference::FieldReference( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct FieldReferenceDefaultTypeInternal { + constexpr FieldReferenceDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~FieldReferenceDefaultTypeInternal() {} + union { + FieldReference _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FieldReferenceDefaultTypeInternal _FieldReference_default_instance_; +} // namespace substrait +} // namespace io +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_selection_2eproto[18]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_selection_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_selection_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_selection_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKey, map_key_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKey, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKeyExpression, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKeyExpression, map_key_expression_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKeyExpression, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_StructField, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_StructField, field_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_StructField, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListElement, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListElement, offset_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListElement, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListRange, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListRange, start_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListRange, end_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListRange, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment, reference_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_Select, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_Select, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_Select, type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_StructSelect, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_StructSelect, struct_items_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_StructItem, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_StructItem, field_), + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_StructItem, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement, field_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice, start_), + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice, end_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem, type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect, selection_), + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect_MapKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect_MapKey, map_key_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect_MapKeyExpression, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect_MapKeyExpression, map_key_expression_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect, child_), + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect, select_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression, select_), + PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression, maintain_singular_struct_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FieldReference, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::FieldReference, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::FieldReference, reference_type_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::io::substrait::ReferenceSegment_MapKey)}, + { 7, -1, sizeof(::io::substrait::ReferenceSegment_MapKeyExpression)}, + { 14, -1, sizeof(::io::substrait::ReferenceSegment_StructField)}, + { 21, -1, sizeof(::io::substrait::ReferenceSegment_ListElement)}, + { 28, -1, sizeof(::io::substrait::ReferenceSegment_ListRange)}, + { 36, -1, sizeof(::io::substrait::ReferenceSegment)}, + { 47, -1, sizeof(::io::substrait::MaskExpression_Select)}, + { 56, -1, sizeof(::io::substrait::MaskExpression_StructSelect)}, + { 62, -1, sizeof(::io::substrait::MaskExpression_StructItem)}, + { 69, -1, sizeof(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement)}, + { 75, -1, sizeof(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice)}, + { 82, -1, sizeof(::io::substrait::MaskExpression_ListSelect_ListSelectItem)}, + { 90, -1, sizeof(::io::substrait::MaskExpression_ListSelect)}, + { 97, -1, sizeof(::io::substrait::MaskExpression_MapSelect_MapKey)}, + { 103, -1, sizeof(::io::substrait::MaskExpression_MapSelect_MapKeyExpression)}, + { 109, -1, sizeof(::io::substrait::MaskExpression_MapSelect)}, + { 118, -1, sizeof(::io::substrait::MaskExpression)}, + { 125, -1, sizeof(::io::substrait::FieldReference)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_ReferenceSegment_MapKey_default_instance_), + reinterpret_cast(&::io::substrait::_ReferenceSegment_MapKeyExpression_default_instance_), + reinterpret_cast(&::io::substrait::_ReferenceSegment_StructField_default_instance_), + reinterpret_cast(&::io::substrait::_ReferenceSegment_ListElement_default_instance_), + reinterpret_cast(&::io::substrait::_ReferenceSegment_ListRange_default_instance_), + reinterpret_cast(&::io::substrait::_ReferenceSegment_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_Select_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_StructSelect_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_StructItem_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_ListSelect_ListSelectItem_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_ListSelect_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_MapSelect_MapKey_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_MapSelect_MapKeyExpression_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_MapSelect_default_instance_), + reinterpret_cast(&::io::substrait::_MaskExpression_default_instance_), + reinterpret_cast(&::io::substrait::_FieldReference_default_instance_), +}; + +const char descriptor_table_protodef_selection_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\017selection.proto\022\014io.substrait\"\211\006\n\020Refe" + "renceSegment\0228\n\007map_key\030\001 \001(\0132%.io.subst" + "rait.ReferenceSegment.MapKeyH\000\022E\n\nexpres" + "sion\030\002 \001(\0132/.io.substrait.ReferenceSegme" + "nt.MapKeyExpressionH\000\022B\n\014struct_field\030\003 " + "\001(\0132*.io.substrait.ReferenceSegment.Stru" + "ctFieldH\000\022B\n\014list_element\030\004 \001(\0132*.io.sub" + "strait.ReferenceSegment.ListElementH\000\022>\n" + "\nlist_range\030\005 \001(\0132(.io.substrait.Referen" + "ceSegment.ListRangeH\000\032H\n\006MapKey\022\017\n\007map_k" + "ey\030\001 \001(\t\022-\n\005child\030\002 \001(\0132\036.io.substrait.R" + "eferenceSegment\032]\n\020MapKeyExpression\022\032\n\022m" + "ap_key_expression\030\001 \001(\t\022-\n\005child\030\002 \001(\0132\036" + ".io.substrait.ReferenceSegment\032K\n\013Struct" + "Field\022\r\n\005field\030\001 \001(\005\022-\n\005child\030\002 \001(\0132\036.io" + ".substrait.ReferenceSegment\032L\n\013ListEleme" + "nt\022\016\n\006offset\030\001 \001(\005\022-\n\005child\030\002 \001(\0132\036.io.s" + "ubstrait.ReferenceSegment\032V\n\tListRange\022\r" + "\n\005start\030\001 \001(\005\022\013\n\003end\030\002 \001(\005\022-\n\005child\030\003 \001(" + "\0132\036.io.substrait.ReferenceSegmentB\020\n\016ref" + "erence_type\"\210\t\n\016MaskExpression\0229\n\006select" + "\030\001 \001(\0132).io.substrait.MaskExpression.Str" + "uctSelect\022 \n\030maintain_singular_struct\030\002 " + "\001(\010\032\275\001\n\006Select\022;\n\006struct\030\001 \001(\0132).io.subs" + "trait.MaskExpression.StructSelectH\000\0227\n\004l" + "ist\030\002 \001(\0132\'.io.substrait.MaskExpression." + "ListSelectH\000\0225\n\003map\030\003 \001(\0132&.io.substrait" + ".MaskExpression.MapSelectH\000B\006\n\004type\032M\n\014S" + "tructSelect\022=\n\014struct_items\030\001 \003(\0132\'.io.s" + "ubstrait.MaskExpression.StructItem\032O\n\nSt" + "ructItem\022\r\n\005field\030\001 \001(\005\0222\n\005child\030\002 \001(\0132#" + ".io.substrait.MaskExpression.Select\032\224\003\n\n" + "ListSelect\022I\n\tselection\030\001 \003(\01326.io.subst" + "rait.MaskExpression.ListSelect.ListSelec" + "tItem\0222\n\005child\030\002 \001(\0132#.io.substrait.Mask" + "Expression.Select\032\206\002\n\016ListSelectItem\022R\n\004" + "item\030\001 \001(\0132B.io.substrait.MaskExpression" + ".ListSelect.ListSelectItem.ListElementH\000" + "\022Q\n\005slice\030\002 \001(\0132@.io.substrait.MaskExpre" + "ssion.ListSelect.ListSelectItem.ListSlic" + "eH\000\032\034\n\013ListElement\022\r\n\005field\030\001 \001(\005\032\'\n\tLis" + "tSlice\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002 \001(\005B\006\n\004ty" + "pe\032\241\002\n\tMapSelect\022<\n\003key\030\001 \001(\0132-.io.subst" + "rait.MaskExpression.MapSelect.MapKeyH\000\022M" + "\n\nexpression\030\002 \001(\01327.io.substrait.MaskEx" + "pression.MapSelect.MapKeyExpressionH\000\0222\n" + "\005child\030\003 \001(\0132#.io.substrait.MaskExpressi" + "on.Select\032\031\n\006MapKey\022\017\n\007map_key\030\001 \001(\t\032.\n\020" + "MapKeyExpression\022\032\n\022map_key_expression\030\001" + " \001(\tB\010\n\006select\"\230\001\n\016FieldReference\022:\n\020dir" + "ect_reference\030\001 \001(\0132\036.io.substrait.Refer" + "enceSegmentH\000\0228\n\020masked_reference\030\002 \001(\0132" + "\034.io.substrait.MaskExpressionH\000B\020\n\016refer" + "ence_typeB\027P\001\252\002\022Substrait.Protobufb\006prot" + "o3" + ; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_selection_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_selection_2eproto = { + false, false, 2162, descriptor_table_protodef_selection_2eproto, "selection.proto", + &descriptor_table_selection_2eproto_once, nullptr, 0, 18, + schemas, file_default_instances, TableStruct_selection_2eproto::offsets, + file_level_metadata_selection_2eproto, file_level_enum_descriptors_selection_2eproto, file_level_service_descriptors_selection_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_selection_2eproto_getter() { + return &descriptor_table_selection_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_selection_2eproto(&descriptor_table_selection_2eproto); +namespace io { +namespace substrait { + +// =================================================================== + +class ReferenceSegment_MapKey::_Internal { + public: + static const ::io::substrait::ReferenceSegment& child(const ReferenceSegment_MapKey* msg); +}; + +const ::io::substrait::ReferenceSegment& +ReferenceSegment_MapKey::_Internal::child(const ReferenceSegment_MapKey* msg) { + return *msg->child_; +} +ReferenceSegment_MapKey::ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment.MapKey) +} +ReferenceSegment_MapKey::ReferenceSegment_MapKey(const ReferenceSegment_MapKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_map_key().empty()) { + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key(), + GetArena()); + } + if (from._internal_has_child()) { + child_ = new ::io::substrait::ReferenceSegment(*from.child_); + } else { + child_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment.MapKey) +} + +void ReferenceSegment_MapKey::SharedCtor() { +map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +child_ = nullptr; +} + +ReferenceSegment_MapKey::~ReferenceSegment_MapKey() { + // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment.MapKey) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReferenceSegment_MapKey::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + map_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete child_; +} + +void ReferenceSegment_MapKey::ArenaDtor(void* object) { + ReferenceSegment_MapKey* _this = reinterpret_cast< ReferenceSegment_MapKey* >(object); + (void)_this; +} +void ReferenceSegment_MapKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReferenceSegment_MapKey::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReferenceSegment_MapKey::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment.MapKey) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + map_key_.ClearToEmpty(); + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReferenceSegment_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string map_key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_map_key(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReferenceSegment.MapKey.map_key")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReferenceSegment child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment_MapKey::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment.MapKey) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string map_key = 1; + if (this->map_key().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_map_key().data(), static_cast(this->_internal_map_key().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.ReferenceSegment.MapKey.map_key"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_map_key(), target); + } + + // .io.substrait.ReferenceSegment child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment.MapKey) + return target; +} + +size_t ReferenceSegment_MapKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment.MapKey) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string map_key = 1; + if (this->map_key().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_map_key()); + } + + // .io.substrait.ReferenceSegment child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReferenceSegment_MapKey::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment.MapKey) + GOOGLE_DCHECK_NE(&from, this); + const ReferenceSegment_MapKey* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment.MapKey) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment.MapKey) + MergeFrom(*source); + } +} + +void ReferenceSegment_MapKey::MergeFrom(const ReferenceSegment_MapKey& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment.MapKey) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.map_key().size() > 0) { + _internal_set_map_key(from._internal_map_key()); + } + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_child()); + } +} + +void ReferenceSegment_MapKey::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment.MapKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReferenceSegment_MapKey::CopyFrom(const ReferenceSegment_MapKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment.MapKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReferenceSegment_MapKey::IsInitialized() const { + return true; +} + +void ReferenceSegment_MapKey::InternalSwap(ReferenceSegment_MapKey* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + map_key_.Swap(&other->map_key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(child_, other->child_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment_MapKey::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[0]); +} + +// =================================================================== + +class ReferenceSegment_MapKeyExpression::_Internal { + public: + static const ::io::substrait::ReferenceSegment& child(const ReferenceSegment_MapKeyExpression* msg); +}; + +const ::io::substrait::ReferenceSegment& +ReferenceSegment_MapKeyExpression::_Internal::child(const ReferenceSegment_MapKeyExpression* msg) { + return *msg->child_; +} +ReferenceSegment_MapKeyExpression::ReferenceSegment_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment.MapKeyExpression) +} +ReferenceSegment_MapKeyExpression::ReferenceSegment_MapKeyExpression(const ReferenceSegment_MapKeyExpression& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_map_key_expression().empty()) { + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key_expression(), + GetArena()); + } + if (from._internal_has_child()) { + child_ = new ::io::substrait::ReferenceSegment(*from.child_); + } else { + child_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment.MapKeyExpression) +} + +void ReferenceSegment_MapKeyExpression::SharedCtor() { +map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +child_ = nullptr; +} + +ReferenceSegment_MapKeyExpression::~ReferenceSegment_MapKeyExpression() { + // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment.MapKeyExpression) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReferenceSegment_MapKeyExpression::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + map_key_expression_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete child_; +} + +void ReferenceSegment_MapKeyExpression::ArenaDtor(void* object) { + ReferenceSegment_MapKeyExpression* _this = reinterpret_cast< ReferenceSegment_MapKeyExpression* >(object); + (void)_this; +} +void ReferenceSegment_MapKeyExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReferenceSegment_MapKeyExpression::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReferenceSegment_MapKeyExpression::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment.MapKeyExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + map_key_expression_.ClearToEmpty(); + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReferenceSegment_MapKeyExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string map_key_expression = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_map_key_expression(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReferenceSegment child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment_MapKeyExpression::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment.MapKeyExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string map_key_expression = 1; + if (this->map_key_expression().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_map_key_expression().data(), static_cast(this->_internal_map_key_expression().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_map_key_expression(), target); + } + + // .io.substrait.ReferenceSegment child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment.MapKeyExpression) + return target; +} + +size_t ReferenceSegment_MapKeyExpression::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment.MapKeyExpression) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string map_key_expression = 1; + if (this->map_key_expression().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_map_key_expression()); + } + + // .io.substrait.ReferenceSegment child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReferenceSegment_MapKeyExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment.MapKeyExpression) + GOOGLE_DCHECK_NE(&from, this); + const ReferenceSegment_MapKeyExpression* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment.MapKeyExpression) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment.MapKeyExpression) + MergeFrom(*source); + } +} + +void ReferenceSegment_MapKeyExpression::MergeFrom(const ReferenceSegment_MapKeyExpression& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment.MapKeyExpression) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.map_key_expression().size() > 0) { + _internal_set_map_key_expression(from._internal_map_key_expression()); + } + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_child()); + } +} + +void ReferenceSegment_MapKeyExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment.MapKeyExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReferenceSegment_MapKeyExpression::CopyFrom(const ReferenceSegment_MapKeyExpression& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment.MapKeyExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReferenceSegment_MapKeyExpression::IsInitialized() const { + return true; +} + +void ReferenceSegment_MapKeyExpression::InternalSwap(ReferenceSegment_MapKeyExpression* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + map_key_expression_.Swap(&other->map_key_expression_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(child_, other->child_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment_MapKeyExpression::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[1]); +} + +// =================================================================== + +class ReferenceSegment_StructField::_Internal { + public: + static const ::io::substrait::ReferenceSegment& child(const ReferenceSegment_StructField* msg); +}; + +const ::io::substrait::ReferenceSegment& +ReferenceSegment_StructField::_Internal::child(const ReferenceSegment_StructField* msg) { + return *msg->child_; +} +ReferenceSegment_StructField::ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment.StructField) +} +ReferenceSegment_StructField::ReferenceSegment_StructField(const ReferenceSegment_StructField& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::ReferenceSegment(*from.child_); + } else { + child_ = nullptr; + } + field_ = from.field_; + // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment.StructField) +} + +void ReferenceSegment_StructField::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&child_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&field_) - + reinterpret_cast(&child_)) + sizeof(field_)); +} + +ReferenceSegment_StructField::~ReferenceSegment_StructField() { + // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment.StructField) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReferenceSegment_StructField::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; +} + +void ReferenceSegment_StructField::ArenaDtor(void* object) { + ReferenceSegment_StructField* _this = reinterpret_cast< ReferenceSegment_StructField* >(object); + (void)_this; +} +void ReferenceSegment_StructField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReferenceSegment_StructField::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReferenceSegment_StructField::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment.StructField) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + field_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReferenceSegment_StructField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 field = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReferenceSegment child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment_StructField::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment.StructField) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 field = 1; + if (this->field() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); + } + + // .io.substrait.ReferenceSegment child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment.StructField) + return target; +} + +size_t ReferenceSegment_StructField::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment.StructField) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ReferenceSegment child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + // int32 field = 1; + if (this->field() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_field()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReferenceSegment_StructField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment.StructField) + GOOGLE_DCHECK_NE(&from, this); + const ReferenceSegment_StructField* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment.StructField) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment.StructField) + MergeFrom(*source); + } +} + +void ReferenceSegment_StructField::MergeFrom(const ReferenceSegment_StructField& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment.StructField) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_child()); + } + if (from.field() != 0) { + _internal_set_field(from._internal_field()); + } +} + +void ReferenceSegment_StructField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment.StructField) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReferenceSegment_StructField::CopyFrom(const ReferenceSegment_StructField& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment.StructField) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReferenceSegment_StructField::IsInitialized() const { + return true; +} + +void ReferenceSegment_StructField::InternalSwap(ReferenceSegment_StructField* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ReferenceSegment_StructField, field_) + + sizeof(ReferenceSegment_StructField::field_) + - PROTOBUF_FIELD_OFFSET(ReferenceSegment_StructField, child_)>( + reinterpret_cast(&child_), + reinterpret_cast(&other->child_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment_StructField::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[2]); +} + +// =================================================================== + +class ReferenceSegment_ListElement::_Internal { + public: + static const ::io::substrait::ReferenceSegment& child(const ReferenceSegment_ListElement* msg); +}; + +const ::io::substrait::ReferenceSegment& +ReferenceSegment_ListElement::_Internal::child(const ReferenceSegment_ListElement* msg) { + return *msg->child_; +} +ReferenceSegment_ListElement::ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment.ListElement) +} +ReferenceSegment_ListElement::ReferenceSegment_ListElement(const ReferenceSegment_ListElement& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::ReferenceSegment(*from.child_); + } else { + child_ = nullptr; + } + offset_ = from.offset_; + // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment.ListElement) +} + +void ReferenceSegment_ListElement::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&child_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&offset_) - + reinterpret_cast(&child_)) + sizeof(offset_)); +} + +ReferenceSegment_ListElement::~ReferenceSegment_ListElement() { + // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment.ListElement) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReferenceSegment_ListElement::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; +} + +void ReferenceSegment_ListElement::ArenaDtor(void* object) { + ReferenceSegment_ListElement* _this = reinterpret_cast< ReferenceSegment_ListElement* >(object); + (void)_this; +} +void ReferenceSegment_ListElement::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReferenceSegment_ListElement::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReferenceSegment_ListElement::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment.ListElement) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + offset_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReferenceSegment_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 offset = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReferenceSegment child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment_ListElement::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment.ListElement) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 offset = 1; + if (this->offset() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_offset(), target); + } + + // .io.substrait.ReferenceSegment child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment.ListElement) + return target; +} + +size_t ReferenceSegment_ListElement::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment.ListElement) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ReferenceSegment child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + // int32 offset = 1; + if (this->offset() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_offset()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReferenceSegment_ListElement::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment.ListElement) + GOOGLE_DCHECK_NE(&from, this); + const ReferenceSegment_ListElement* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment.ListElement) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment.ListElement) + MergeFrom(*source); + } +} + +void ReferenceSegment_ListElement::MergeFrom(const ReferenceSegment_ListElement& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment.ListElement) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_child()); + } + if (from.offset() != 0) { + _internal_set_offset(from._internal_offset()); + } +} + +void ReferenceSegment_ListElement::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment.ListElement) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReferenceSegment_ListElement::CopyFrom(const ReferenceSegment_ListElement& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment.ListElement) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReferenceSegment_ListElement::IsInitialized() const { + return true; +} + +void ReferenceSegment_ListElement::InternalSwap(ReferenceSegment_ListElement* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ReferenceSegment_ListElement, offset_) + + sizeof(ReferenceSegment_ListElement::offset_) + - PROTOBUF_FIELD_OFFSET(ReferenceSegment_ListElement, child_)>( + reinterpret_cast(&child_), + reinterpret_cast(&other->child_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment_ListElement::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[3]); +} + +// =================================================================== + +class ReferenceSegment_ListRange::_Internal { + public: + static const ::io::substrait::ReferenceSegment& child(const ReferenceSegment_ListRange* msg); +}; + +const ::io::substrait::ReferenceSegment& +ReferenceSegment_ListRange::_Internal::child(const ReferenceSegment_ListRange* msg) { + return *msg->child_; +} +ReferenceSegment_ListRange::ReferenceSegment_ListRange(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment.ListRange) +} +ReferenceSegment_ListRange::ReferenceSegment_ListRange(const ReferenceSegment_ListRange& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::ReferenceSegment(*from.child_); + } else { + child_ = nullptr; + } + ::memcpy(&start_, &from.start_, + static_cast(reinterpret_cast(&end_) - + reinterpret_cast(&start_)) + sizeof(end_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment.ListRange) +} + +void ReferenceSegment_ListRange::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&child_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&end_) - + reinterpret_cast(&child_)) + sizeof(end_)); +} + +ReferenceSegment_ListRange::~ReferenceSegment_ListRange() { + // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment.ListRange) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReferenceSegment_ListRange::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; +} + +void ReferenceSegment_ListRange::ArenaDtor(void* object) { + ReferenceSegment_ListRange* _this = reinterpret_cast< ReferenceSegment_ListRange* >(object); + (void)_this; +} +void ReferenceSegment_ListRange::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReferenceSegment_ListRange::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReferenceSegment_ListRange::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment.ListRange) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + ::memset(&start_, 0, static_cast( + reinterpret_cast(&end_) - + reinterpret_cast(&start_)) + sizeof(end_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReferenceSegment_ListRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 start = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 end = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReferenceSegment child = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment_ListRange::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment.ListRange) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 start = 1; + if (this->start() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_start(), target); + } + + // int32 end = 2; + if (this->end() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end(), target); + } + + // .io.substrait.ReferenceSegment child = 3; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment.ListRange) + return target; +} + +size_t ReferenceSegment_ListRange::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment.ListRange) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.ReferenceSegment child = 3; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + // int32 start = 1; + if (this->start() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_start()); + } + + // int32 end = 2; + if (this->end() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_end()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReferenceSegment_ListRange::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment.ListRange) + GOOGLE_DCHECK_NE(&from, this); + const ReferenceSegment_ListRange* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment.ListRange) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment.ListRange) + MergeFrom(*source); + } +} + +void ReferenceSegment_ListRange::MergeFrom(const ReferenceSegment_ListRange& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment.ListRange) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_child()); + } + if (from.start() != 0) { + _internal_set_start(from._internal_start()); + } + if (from.end() != 0) { + _internal_set_end(from._internal_end()); + } +} + +void ReferenceSegment_ListRange::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment.ListRange) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReferenceSegment_ListRange::CopyFrom(const ReferenceSegment_ListRange& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment.ListRange) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReferenceSegment_ListRange::IsInitialized() const { + return true; +} + +void ReferenceSegment_ListRange::InternalSwap(ReferenceSegment_ListRange* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ReferenceSegment_ListRange, end_) + + sizeof(ReferenceSegment_ListRange::end_) + - PROTOBUF_FIELD_OFFSET(ReferenceSegment_ListRange, child_)>( + reinterpret_cast(&child_), + reinterpret_cast(&other->child_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment_ListRange::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[4]); +} + +// =================================================================== + +class ReferenceSegment::_Internal { + public: + static const ::io::substrait::ReferenceSegment_MapKey& map_key(const ReferenceSegment* msg); + static const ::io::substrait::ReferenceSegment_MapKeyExpression& expression(const ReferenceSegment* msg); + static const ::io::substrait::ReferenceSegment_StructField& struct_field(const ReferenceSegment* msg); + static const ::io::substrait::ReferenceSegment_ListElement& list_element(const ReferenceSegment* msg); + static const ::io::substrait::ReferenceSegment_ListRange& list_range(const ReferenceSegment* msg); +}; + +const ::io::substrait::ReferenceSegment_MapKey& +ReferenceSegment::_Internal::map_key(const ReferenceSegment* msg) { + return *msg->reference_type_.map_key_; +} +const ::io::substrait::ReferenceSegment_MapKeyExpression& +ReferenceSegment::_Internal::expression(const ReferenceSegment* msg) { + return *msg->reference_type_.expression_; +} +const ::io::substrait::ReferenceSegment_StructField& +ReferenceSegment::_Internal::struct_field(const ReferenceSegment* msg) { + return *msg->reference_type_.struct_field_; +} +const ::io::substrait::ReferenceSegment_ListElement& +ReferenceSegment::_Internal::list_element(const ReferenceSegment* msg) { + return *msg->reference_type_.list_element_; +} +const ::io::substrait::ReferenceSegment_ListRange& +ReferenceSegment::_Internal::list_range(const ReferenceSegment* msg) { + return *msg->reference_type_.list_range_; +} +void ReferenceSegment::set_allocated_map_key(::io::substrait::ReferenceSegment_MapKey* map_key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (map_key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map_key); + if (message_arena != submessage_arena) { + map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map_key, submessage_arena); + } + set_has_map_key(); + reference_type_.map_key_ = map_key; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.map_key) +} +void ReferenceSegment::set_allocated_expression(::io::substrait::ReferenceSegment_MapKeyExpression* expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expression); + if (message_arena != submessage_arena) { + expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expression, submessage_arena); + } + set_has_expression(); + reference_type_.expression_ = expression; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.expression) +} +void ReferenceSegment::set_allocated_struct_field(::io::substrait::ReferenceSegment_StructField* struct_field) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (struct_field) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_field); + if (message_arena != submessage_arena) { + struct_field = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_field, submessage_arena); + } + set_has_struct_field(); + reference_type_.struct_field_ = struct_field; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.struct_field) +} +void ReferenceSegment::set_allocated_list_element(::io::substrait::ReferenceSegment_ListElement* list_element) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (list_element) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list_element); + if (message_arena != submessage_arena) { + list_element = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, list_element, submessage_arena); + } + set_has_list_element(); + reference_type_.list_element_ = list_element; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.list_element) +} +void ReferenceSegment::set_allocated_list_range(::io::substrait::ReferenceSegment_ListRange* list_range) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (list_range) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list_range); + if (message_arena != submessage_arena) { + list_range = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, list_range, submessage_arena); + } + set_has_list_range(); + reference_type_.list_range_ = list_range; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.list_range) +} +ReferenceSegment::ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment) +} +ReferenceSegment::ReferenceSegment(const ReferenceSegment& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_reference_type(); + switch (from.reference_type_case()) { + case kMapKey: { + _internal_mutable_map_key()->::io::substrait::ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); + break; + } + case kExpression: { + _internal_mutable_expression()->::io::substrait::ReferenceSegment_MapKeyExpression::MergeFrom(from._internal_expression()); + break; + } + case kStructField: { + _internal_mutable_struct_field()->::io::substrait::ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); + break; + } + case kListElement: { + _internal_mutable_list_element()->::io::substrait::ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); + break; + } + case kListRange: { + _internal_mutable_list_range()->::io::substrait::ReferenceSegment_ListRange::MergeFrom(from._internal_list_range()); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment) +} + +void ReferenceSegment::SharedCtor() { +clear_has_reference_type(); +} + +ReferenceSegment::~ReferenceSegment() { + // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReferenceSegment::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_reference_type()) { + clear_reference_type(); + } +} + +void ReferenceSegment::ArenaDtor(void* object) { + ReferenceSegment* _this = reinterpret_cast< ReferenceSegment* >(object); + (void)_this; +} +void ReferenceSegment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReferenceSegment::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReferenceSegment::clear_reference_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.ReferenceSegment) + switch (reference_type_case()) { + case kMapKey: { + if (GetArena() == nullptr) { + delete reference_type_.map_key_; + } + break; + } + case kExpression: { + if (GetArena() == nullptr) { + delete reference_type_.expression_; + } + break; + } + case kStructField: { + if (GetArena() == nullptr) { + delete reference_type_.struct_field_; + } + break; + } + case kListElement: { + if (GetArena() == nullptr) { + delete reference_type_.list_element_; + } + break; + } + case kListRange: { + if (GetArena() == nullptr) { + delete reference_type_.list_range_; + } + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; +} + + +void ReferenceSegment::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_reference_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReferenceSegment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ReferenceSegment.MapKey map_key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReferenceSegment.MapKeyExpression expression = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReferenceSegment.StructField struct_field = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_field(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReferenceSegment.ListElement list_element = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_list_element(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReferenceSegment.ListRange list_range = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_list_range(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ReferenceSegment.MapKey map_key = 1; + if (_internal_has_map_key()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::map_key(this), target, stream); + } + + // .io.substrait.ReferenceSegment.MapKeyExpression expression = 2; + if (_internal_has_expression()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::expression(this), target, stream); + } + + // .io.substrait.ReferenceSegment.StructField struct_field = 3; + if (_internal_has_struct_field()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::struct_field(this), target, stream); + } + + // .io.substrait.ReferenceSegment.ListElement list_element = 4; + if (_internal_has_list_element()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::list_element(this), target, stream); + } + + // .io.substrait.ReferenceSegment.ListRange list_range = 5; + if (_internal_has_list_range()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::list_range(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment) + return target; +} + +size_t ReferenceSegment::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (reference_type_case()) { + // .io.substrait.ReferenceSegment.MapKey map_key = 1; + case kMapKey: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.map_key_); + break; + } + // .io.substrait.ReferenceSegment.MapKeyExpression expression = 2; + case kExpression: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.expression_); + break; + } + // .io.substrait.ReferenceSegment.StructField struct_field = 3; + case kStructField: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.struct_field_); + break; + } + // .io.substrait.ReferenceSegment.ListElement list_element = 4; + case kListElement: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.list_element_); + break; + } + // .io.substrait.ReferenceSegment.ListRange list_range = 5; + case kListRange: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.list_range_); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReferenceSegment::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment) + GOOGLE_DCHECK_NE(&from, this); + const ReferenceSegment* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment) + MergeFrom(*source); + } +} + +void ReferenceSegment::MergeFrom(const ReferenceSegment& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.reference_type_case()) { + case kMapKey: { + _internal_mutable_map_key()->::io::substrait::ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); + break; + } + case kExpression: { + _internal_mutable_expression()->::io::substrait::ReferenceSegment_MapKeyExpression::MergeFrom(from._internal_expression()); + break; + } + case kStructField: { + _internal_mutable_struct_field()->::io::substrait::ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); + break; + } + case kListElement: { + _internal_mutable_list_element()->::io::substrait::ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); + break; + } + case kListRange: { + _internal_mutable_list_range()->::io::substrait::ReferenceSegment_ListRange::MergeFrom(from._internal_list_range()); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } +} + +void ReferenceSegment::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReferenceSegment::CopyFrom(const ReferenceSegment& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReferenceSegment::IsInitialized() const { + return true; +} + +void ReferenceSegment::InternalSwap(ReferenceSegment* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(reference_type_, other->reference_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[5]); +} + +// =================================================================== + +class MaskExpression_Select::_Internal { + public: + static const ::io::substrait::MaskExpression_StructSelect& struct_(const MaskExpression_Select* msg); + static const ::io::substrait::MaskExpression_ListSelect& list(const MaskExpression_Select* msg); + static const ::io::substrait::MaskExpression_MapSelect& map(const MaskExpression_Select* msg); +}; + +const ::io::substrait::MaskExpression_StructSelect& +MaskExpression_Select::_Internal::struct_(const MaskExpression_Select* msg) { + return *msg->type_.struct__; +} +const ::io::substrait::MaskExpression_ListSelect& +MaskExpression_Select::_Internal::list(const MaskExpression_Select* msg) { + return *msg->type_.list_; +} +const ::io::substrait::MaskExpression_MapSelect& +MaskExpression_Select::_Internal::map(const MaskExpression_Select* msg) { + return *msg->type_.map_; +} +void MaskExpression_Select::set_allocated_struct_(::io::substrait::MaskExpression_StructSelect* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_type(); + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + set_has_struct_(); + type_.struct__ = struct_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.Select.struct) +} +void MaskExpression_Select::set_allocated_list(::io::substrait::MaskExpression_ListSelect* list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_type(); + if (list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + if (message_arena != submessage_arena) { + list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, list, submessage_arena); + } + set_has_list(); + type_.list_ = list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.Select.list) +} +void MaskExpression_Select::set_allocated_map(::io::substrait::MaskExpression_MapSelect* map) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_type(); + if (map) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + if (message_arena != submessage_arena) { + map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map, submessage_arena); + } + set_has_map(); + type_.map_ = map; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.Select.map) +} +MaskExpression_Select::MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.Select) +} +MaskExpression_Select::MaskExpression_Select(const MaskExpression_Select& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_type(); + switch (from.type_case()) { + case kStruct: { + _internal_mutable_struct_()->::io::substrait::MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::MaskExpression_ListSelect::MergeFrom(from._internal_list()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::MaskExpression_MapSelect::MergeFrom(from._internal_map()); + break; + } + case TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.Select) +} + +void MaskExpression_Select::SharedCtor() { +clear_has_type(); +} + +MaskExpression_Select::~MaskExpression_Select() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.Select) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression_Select::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_type()) { + clear_type(); + } +} + +void MaskExpression_Select::ArenaDtor(void* object) { + MaskExpression_Select* _this = reinterpret_cast< MaskExpression_Select* >(object); + (void)_this; +} +void MaskExpression_Select::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression_Select::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression_Select::clear_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.MaskExpression.Select) + switch (type_case()) { + case kStruct: { + if (GetArena() == nullptr) { + delete type_.struct__; + } + break; + } + case kList: { + if (GetArena() == nullptr) { + delete type_.list_; + } + break; + } + case kMap: { + if (GetArena() == nullptr) { + delete type_.map_; + } + break; + } + case TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = TYPE_NOT_SET; +} + + +void MaskExpression_Select::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.Select) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression_Select::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.MaskExpression.StructSelect struct = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.MaskExpression.ListSelect list = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.MaskExpression.MapSelect map = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_Select::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.Select) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.MaskExpression.StructSelect struct = 1; + if (_internal_has_struct_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::struct_(this), target, stream); + } + + // .io.substrait.MaskExpression.ListSelect list = 2; + if (_internal_has_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::list(this), target, stream); + } + + // .io.substrait.MaskExpression.MapSelect map = 3; + if (_internal_has_map()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::map(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.Select) + return target; +} + +size_t MaskExpression_Select::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.Select) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (type_case()) { + // .io.substrait.MaskExpression.StructSelect struct = 1; + case kStruct: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_.struct__); + break; + } + // .io.substrait.MaskExpression.ListSelect list = 2; + case kList: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_.list_); + break; + } + // .io.substrait.MaskExpression.MapSelect map = 3; + case kMap: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_.map_); + break; + } + case TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression_Select::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.Select) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression_Select* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.Select) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.Select) + MergeFrom(*source); + } +} + +void MaskExpression_Select::MergeFrom(const MaskExpression_Select& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.Select) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.type_case()) { + case kStruct: { + _internal_mutable_struct_()->::io::substrait::MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::MaskExpression_ListSelect::MergeFrom(from._internal_list()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::MaskExpression_MapSelect::MergeFrom(from._internal_map()); + break; + } + case TYPE_NOT_SET: { + break; + } + } +} + +void MaskExpression_Select::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.Select) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression_Select::CopyFrom(const MaskExpression_Select& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.Select) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression_Select::IsInitialized() const { + return true; +} + +void MaskExpression_Select::InternalSwap(MaskExpression_Select* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(type_, other->type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_Select::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[6]); +} + +// =================================================================== + +class MaskExpression_StructSelect::_Internal { + public: +}; + +MaskExpression_StructSelect::MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + struct_items_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.StructSelect) +} +MaskExpression_StructSelect::MaskExpression_StructSelect(const MaskExpression_StructSelect& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + struct_items_(from.struct_items_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.StructSelect) +} + +void MaskExpression_StructSelect::SharedCtor() { +} + +MaskExpression_StructSelect::~MaskExpression_StructSelect() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.StructSelect) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression_StructSelect::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void MaskExpression_StructSelect::ArenaDtor(void* object) { + MaskExpression_StructSelect* _this = reinterpret_cast< MaskExpression_StructSelect* >(object); + (void)_this; +} +void MaskExpression_StructSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression_StructSelect::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression_StructSelect::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.StructSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + struct_items_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression_StructSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.MaskExpression.StructItem struct_items = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_struct_items(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_StructSelect::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.StructSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.MaskExpression.StructItem struct_items = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_struct_items_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_struct_items(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.StructSelect) + return target; +} + +size_t MaskExpression_StructSelect::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.StructSelect) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.MaskExpression.StructItem struct_items = 1; + total_size += 1UL * this->_internal_struct_items_size(); + for (const auto& msg : this->struct_items_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression_StructSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.StructSelect) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression_StructSelect* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.StructSelect) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.StructSelect) + MergeFrom(*source); + } +} + +void MaskExpression_StructSelect::MergeFrom(const MaskExpression_StructSelect& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.StructSelect) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + struct_items_.MergeFrom(from.struct_items_); +} + +void MaskExpression_StructSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.StructSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression_StructSelect::CopyFrom(const MaskExpression_StructSelect& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.StructSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression_StructSelect::IsInitialized() const { + return true; +} + +void MaskExpression_StructSelect::InternalSwap(MaskExpression_StructSelect* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + struct_items_.InternalSwap(&other->struct_items_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_StructSelect::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[7]); +} + +// =================================================================== + +class MaskExpression_StructItem::_Internal { + public: + static const ::io::substrait::MaskExpression_Select& child(const MaskExpression_StructItem* msg); +}; + +const ::io::substrait::MaskExpression_Select& +MaskExpression_StructItem::_Internal::child(const MaskExpression_StructItem* msg) { + return *msg->child_; +} +MaskExpression_StructItem::MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.StructItem) +} +MaskExpression_StructItem::MaskExpression_StructItem(const MaskExpression_StructItem& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::MaskExpression_Select(*from.child_); + } else { + child_ = nullptr; + } + field_ = from.field_; + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.StructItem) +} + +void MaskExpression_StructItem::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&child_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&field_) - + reinterpret_cast(&child_)) + sizeof(field_)); +} + +MaskExpression_StructItem::~MaskExpression_StructItem() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.StructItem) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression_StructItem::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; +} + +void MaskExpression_StructItem::ArenaDtor(void* object) { + MaskExpression_StructItem* _this = reinterpret_cast< MaskExpression_StructItem* >(object); + (void)_this; +} +void MaskExpression_StructItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression_StructItem::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression_StructItem::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.StructItem) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + field_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression_StructItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 field = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.MaskExpression.Select child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_StructItem::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.StructItem) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 field = 1; + if (this->field() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); + } + + // .io.substrait.MaskExpression.Select child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.StructItem) + return target; +} + +size_t MaskExpression_StructItem::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.StructItem) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.MaskExpression.Select child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + // int32 field = 1; + if (this->field() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_field()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression_StructItem::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.StructItem) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression_StructItem* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.StructItem) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.StructItem) + MergeFrom(*source); + } +} + +void MaskExpression_StructItem::MergeFrom(const MaskExpression_StructItem& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.StructItem) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::MaskExpression_Select::MergeFrom(from._internal_child()); + } + if (from.field() != 0) { + _internal_set_field(from._internal_field()); + } +} + +void MaskExpression_StructItem::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.StructItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression_StructItem::CopyFrom(const MaskExpression_StructItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.StructItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression_StructItem::IsInitialized() const { + return true; +} + +void MaskExpression_StructItem::InternalSwap(MaskExpression_StructItem* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MaskExpression_StructItem, field_) + + sizeof(MaskExpression_StructItem::field_) + - PROTOBUF_FIELD_OFFSET(MaskExpression_StructItem, child_)>( + reinterpret_cast(&child_), + reinterpret_cast(&other->child_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_StructItem::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[8]); +} + +// =================================================================== + +class MaskExpression_ListSelect_ListSelectItem_ListElement::_Internal { + public: +}; + +MaskExpression_ListSelect_ListSelectItem_ListElement::MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) +} +MaskExpression_ListSelect_ListSelectItem_ListElement::MaskExpression_ListSelect_ListSelectItem_ListElement(const MaskExpression_ListSelect_ListSelectItem_ListElement& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + field_ = from.field_; + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) +} + +void MaskExpression_ListSelect_ListSelectItem_ListElement::SharedCtor() { +field_ = 0; +} + +MaskExpression_ListSelect_ListSelectItem_ListElement::~MaskExpression_ListSelect_ListSelectItem_ListElement() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression_ListSelect_ListSelectItem_ListElement::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void MaskExpression_ListSelect_ListSelectItem_ListElement::ArenaDtor(void* object) { + MaskExpression_ListSelect_ListSelectItem_ListElement* _this = reinterpret_cast< MaskExpression_ListSelect_ListSelectItem_ListElement* >(object); + (void)_this; +} +void MaskExpression_ListSelect_ListSelectItem_ListElement::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression_ListSelect_ListSelectItem_ListElement::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression_ListSelect_ListSelectItem_ListElement::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + field_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 field = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 field = 1; + if (this->field() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + return target; +} + +size_t MaskExpression_ListSelect_ListSelectItem_ListElement::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 field = 1; + if (this->field() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_field()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression_ListSelect_ListSelectItem_ListElement* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + MergeFrom(*source); + } +} + +void MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const MaskExpression_ListSelect_ListSelectItem_ListElement& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.field() != 0) { + _internal_set_field(from._internal_field()); + } +} + +void MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const MaskExpression_ListSelect_ListSelectItem_ListElement& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression_ListSelect_ListSelectItem_ListElement::IsInitialized() const { + return true; +} + +void MaskExpression_ListSelect_ListSelectItem_ListElement::InternalSwap(MaskExpression_ListSelect_ListSelectItem_ListElement* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(field_, other->field_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_ListSelect_ListSelectItem_ListElement::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[9]); +} + +// =================================================================== + +class MaskExpression_ListSelect_ListSelectItem_ListSlice::_Internal { + public: +}; + +MaskExpression_ListSelect_ListSelectItem_ListSlice::MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) +} +MaskExpression_ListSelect_ListSelectItem_ListSlice::MaskExpression_ListSelect_ListSelectItem_ListSlice(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&start_, &from.start_, + static_cast(reinterpret_cast(&end_) - + reinterpret_cast(&start_)) + sizeof(end_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) +} + +void MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&start_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&end_) - + reinterpret_cast(&start_)) + sizeof(end_)); +} + +MaskExpression_ListSelect_ListSelectItem_ListSlice::~MaskExpression_ListSelect_ListSelectItem_ListSlice() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void MaskExpression_ListSelect_ListSelectItem_ListSlice::ArenaDtor(void* object) { + MaskExpression_ListSelect_ListSelectItem_ListSlice* _this = reinterpret_cast< MaskExpression_ListSelect_ListSelectItem_ListSlice* >(object); + (void)_this; +} +void MaskExpression_ListSelect_ListSelectItem_ListSlice::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression_ListSelect_ListSelectItem_ListSlice::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression_ListSelect_ListSelectItem_ListSlice::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&start_, 0, static_cast( + reinterpret_cast(&end_) - + reinterpret_cast(&start_)) + sizeof(end_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 start = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 end = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 start = 1; + if (this->start() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_start(), target); + } + + // int32 end = 2; + if (this->end() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + return target; +} + +size_t MaskExpression_ListSelect_ListSelectItem_ListSlice::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 start = 1; + if (this->start() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_start()); + } + + // int32 end = 2; + if (this->end() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_end()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression_ListSelect_ListSelectItem_ListSlice* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + MergeFrom(*source); + } +} + +void MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.start() != 0) { + _internal_set_start(from._internal_start()); + } + if (from.end() != 0) { + _internal_set_end(from._internal_end()); + } +} + +void MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression_ListSelect_ListSelectItem_ListSlice::IsInitialized() const { + return true; +} + +void MaskExpression_ListSelect_ListSelectItem_ListSlice::InternalSwap(MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MaskExpression_ListSelect_ListSelectItem_ListSlice, end_) + + sizeof(MaskExpression_ListSelect_ListSelectItem_ListSlice::end_) + - PROTOBUF_FIELD_OFFSET(MaskExpression_ListSelect_ListSelectItem_ListSlice, start_)>( + reinterpret_cast(&start_), + reinterpret_cast(&other->start_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_ListSelect_ListSelectItem_ListSlice::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[10]); +} + +// =================================================================== + +class MaskExpression_ListSelect_ListSelectItem::_Internal { + public: + static const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& item(const MaskExpression_ListSelect_ListSelectItem* msg); + static const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& slice(const MaskExpression_ListSelect_ListSelectItem* msg); +}; + +const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& +MaskExpression_ListSelect_ListSelectItem::_Internal::item(const MaskExpression_ListSelect_ListSelectItem* msg) { + return *msg->type_.item_; +} +const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& +MaskExpression_ListSelect_ListSelectItem::_Internal::slice(const MaskExpression_ListSelect_ListSelectItem* msg) { + return *msg->type_.slice_; +} +void MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* item) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_type(); + if (item) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(item); + if (message_arena != submessage_arena) { + item = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, item, submessage_arena); + } + set_has_item(); + type_.item_ = item; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) +} +void MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_type(); + if (slice) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(slice); + if (message_arena != submessage_arena) { + slice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, slice, submessage_arena); + } + set_has_slice(); + type_.slice_ = slice; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) +} +MaskExpression_ListSelect_ListSelectItem::MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem) +} +MaskExpression_ListSelect_ListSelectItem::MaskExpression_ListSelect_ListSelectItem(const MaskExpression_ListSelect_ListSelectItem& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_type(); + switch (from.type_case()) { + case kItem: { + _internal_mutable_item()->::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); + break; + } + case kSlice: { + _internal_mutable_slice()->::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); + break; + } + case TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem) +} + +void MaskExpression_ListSelect_ListSelectItem::SharedCtor() { +clear_has_type(); +} + +MaskExpression_ListSelect_ListSelectItem::~MaskExpression_ListSelect_ListSelectItem() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.ListSelect.ListSelectItem) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression_ListSelect_ListSelectItem::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_type()) { + clear_type(); + } +} + +void MaskExpression_ListSelect_ListSelectItem::ArenaDtor(void* object) { + MaskExpression_ListSelect_ListSelectItem* _this = reinterpret_cast< MaskExpression_ListSelect_ListSelectItem* >(object); + (void)_this; +} +void MaskExpression_ListSelect_ListSelectItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression_ListSelect_ListSelectItem::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression_ListSelect_ListSelectItem::clear_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) + switch (type_case()) { + case kItem: { + if (GetArena() == nullptr) { + delete type_.item_; + } + break; + } + case kSlice: { + if (GetArena() == nullptr) { + delete type_.slice_; + } + break; + } + case TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = TYPE_NOT_SET; +} + + +void MaskExpression_ListSelect_ListSelectItem::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression_ListSelect_ListSelectItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_item(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_slice(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_ListSelect_ListSelectItem::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + if (_internal_has_item()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::item(this), target, stream); + } + + // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + if (_internal_has_slice()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::slice(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.ListSelect.ListSelectItem) + return target; +} + +size_t MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (type_case()) { + // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + case kItem: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_.item_); + break; + } + // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + case kSlice: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_.slice_); + break; + } + case TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression_ListSelect_ListSelectItem::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression_ListSelect_ListSelectItem* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.ListSelect.ListSelectItem) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.ListSelect.ListSelectItem) + MergeFrom(*source); + } +} + +void MaskExpression_ListSelect_ListSelectItem::MergeFrom(const MaskExpression_ListSelect_ListSelectItem& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.type_case()) { + case kItem: { + _internal_mutable_item()->::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); + break; + } + case kSlice: { + _internal_mutable_slice()->::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); + break; + } + case TYPE_NOT_SET: { + break; + } + } +} + +void MaskExpression_ListSelect_ListSelectItem::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression_ListSelect_ListSelectItem::CopyFrom(const MaskExpression_ListSelect_ListSelectItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression_ListSelect_ListSelectItem::IsInitialized() const { + return true; +} + +void MaskExpression_ListSelect_ListSelectItem::InternalSwap(MaskExpression_ListSelect_ListSelectItem* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(type_, other->type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_ListSelect_ListSelectItem::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[11]); +} + +// =================================================================== + +class MaskExpression_ListSelect::_Internal { + public: + static const ::io::substrait::MaskExpression_Select& child(const MaskExpression_ListSelect* msg); +}; + +const ::io::substrait::MaskExpression_Select& +MaskExpression_ListSelect::_Internal::child(const MaskExpression_ListSelect* msg) { + return *msg->child_; +} +MaskExpression_ListSelect::MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + selection_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.ListSelect) +} +MaskExpression_ListSelect::MaskExpression_ListSelect(const MaskExpression_ListSelect& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + selection_(from.selection_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::MaskExpression_Select(*from.child_); + } else { + child_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.ListSelect) +} + +void MaskExpression_ListSelect::SharedCtor() { +child_ = nullptr; +} + +MaskExpression_ListSelect::~MaskExpression_ListSelect() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.ListSelect) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression_ListSelect::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; +} + +void MaskExpression_ListSelect::ArenaDtor(void* object) { + MaskExpression_ListSelect* _this = reinterpret_cast< MaskExpression_ListSelect* >(object); + (void)_this; +} +void MaskExpression_ListSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression_ListSelect::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression_ListSelect::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.ListSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + selection_.Clear(); + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression_ListSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.MaskExpression.ListSelect.ListSelectItem selection = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_selection(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.MaskExpression.Select child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_ListSelect::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.ListSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.MaskExpression.ListSelect.ListSelectItem selection = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_selection_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_selection(i), target, stream); + } + + // .io.substrait.MaskExpression.Select child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.ListSelect) + return target; +} + +size_t MaskExpression_ListSelect::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.ListSelect) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.MaskExpression.ListSelect.ListSelectItem selection = 1; + total_size += 1UL * this->_internal_selection_size(); + for (const auto& msg : this->selection_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.MaskExpression.Select child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression_ListSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.ListSelect) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression_ListSelect* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.ListSelect) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.ListSelect) + MergeFrom(*source); + } +} + +void MaskExpression_ListSelect::MergeFrom(const MaskExpression_ListSelect& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.ListSelect) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + selection_.MergeFrom(from.selection_); + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::MaskExpression_Select::MergeFrom(from._internal_child()); + } +} + +void MaskExpression_ListSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.ListSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression_ListSelect::CopyFrom(const MaskExpression_ListSelect& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.ListSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression_ListSelect::IsInitialized() const { + return true; +} + +void MaskExpression_ListSelect::InternalSwap(MaskExpression_ListSelect* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + selection_.InternalSwap(&other->selection_); + swap(child_, other->child_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_ListSelect::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[12]); +} + +// =================================================================== + +class MaskExpression_MapSelect_MapKey::_Internal { + public: +}; + +MaskExpression_MapSelect_MapKey::MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.MapSelect.MapKey) +} +MaskExpression_MapSelect_MapKey::MaskExpression_MapSelect_MapKey(const MaskExpression_MapSelect_MapKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_map_key().empty()) { + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.MapSelect.MapKey) +} + +void MaskExpression_MapSelect_MapKey::SharedCtor() { +map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +MaskExpression_MapSelect_MapKey::~MaskExpression_MapSelect_MapKey() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.MapSelect.MapKey) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression_MapSelect_MapKey::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + map_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void MaskExpression_MapSelect_MapKey::ArenaDtor(void* object) { + MaskExpression_MapSelect_MapKey* _this = reinterpret_cast< MaskExpression_MapSelect_MapKey* >(object); + (void)_this; +} +void MaskExpression_MapSelect_MapKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression_MapSelect_MapKey::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression_MapSelect_MapKey::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.MapSelect.MapKey) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + map_key_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression_MapSelect_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string map_key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_map_key(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.MaskExpression.MapSelect.MapKey.map_key")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_MapSelect_MapKey::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.MapSelect.MapKey) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string map_key = 1; + if (this->map_key().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_map_key().data(), static_cast(this->_internal_map_key().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.MaskExpression.MapSelect.MapKey.map_key"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_map_key(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.MapSelect.MapKey) + return target; +} + +size_t MaskExpression_MapSelect_MapKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.MapSelect.MapKey) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string map_key = 1; + if (this->map_key().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_map_key()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression_MapSelect_MapKey::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.MapSelect.MapKey) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression_MapSelect_MapKey* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.MapSelect.MapKey) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.MapSelect.MapKey) + MergeFrom(*source); + } +} + +void MaskExpression_MapSelect_MapKey::MergeFrom(const MaskExpression_MapSelect_MapKey& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.MapSelect.MapKey) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.map_key().size() > 0) { + _internal_set_map_key(from._internal_map_key()); + } +} + +void MaskExpression_MapSelect_MapKey::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.MapSelect.MapKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression_MapSelect_MapKey::CopyFrom(const MaskExpression_MapSelect_MapKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.MapSelect.MapKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression_MapSelect_MapKey::IsInitialized() const { + return true; +} + +void MaskExpression_MapSelect_MapKey::InternalSwap(MaskExpression_MapSelect_MapKey* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + map_key_.Swap(&other->map_key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_MapSelect_MapKey::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[13]); +} + +// =================================================================== + +class MaskExpression_MapSelect_MapKeyExpression::_Internal { + public: +}; + +MaskExpression_MapSelect_MapKeyExpression::MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.MapSelect.MapKeyExpression) +} +MaskExpression_MapSelect_MapKeyExpression::MaskExpression_MapSelect_MapKeyExpression(const MaskExpression_MapSelect_MapKeyExpression& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_map_key_expression().empty()) { + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key_expression(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.MapSelect.MapKeyExpression) +} + +void MaskExpression_MapSelect_MapKeyExpression::SharedCtor() { +map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +MaskExpression_MapSelect_MapKeyExpression::~MaskExpression_MapSelect_MapKeyExpression() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression_MapSelect_MapKeyExpression::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + map_key_expression_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void MaskExpression_MapSelect_MapKeyExpression::ArenaDtor(void* object) { + MaskExpression_MapSelect_MapKeyExpression* _this = reinterpret_cast< MaskExpression_MapSelect_MapKeyExpression* >(object); + (void)_this; +} +void MaskExpression_MapSelect_MapKeyExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression_MapSelect_MapKeyExpression::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression_MapSelect_MapKeyExpression::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + map_key_expression_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression_MapSelect_MapKeyExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string map_key_expression = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_map_key_expression(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_MapSelect_MapKeyExpression::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string map_key_expression = 1; + if (this->map_key_expression().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_map_key_expression().data(), static_cast(this->_internal_map_key_expression().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_map_key_expression(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + return target; +} + +size_t MaskExpression_MapSelect_MapKeyExpression::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string map_key_expression = 1; + if (this->map_key_expression().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_map_key_expression()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression_MapSelect_MapKeyExpression* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + MergeFrom(*source); + } +} + +void MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const MaskExpression_MapSelect_MapKeyExpression& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.map_key_expression().size() > 0) { + _internal_set_map_key_expression(from._internal_map_key_expression()); + } +} + +void MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const MaskExpression_MapSelect_MapKeyExpression& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression_MapSelect_MapKeyExpression::IsInitialized() const { + return true; +} + +void MaskExpression_MapSelect_MapKeyExpression::InternalSwap(MaskExpression_MapSelect_MapKeyExpression* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + map_key_expression_.Swap(&other->map_key_expression_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_MapSelect_MapKeyExpression::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[14]); +} + +// =================================================================== + +class MaskExpression_MapSelect::_Internal { + public: + static const ::io::substrait::MaskExpression_MapSelect_MapKey& key(const MaskExpression_MapSelect* msg); + static const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& expression(const MaskExpression_MapSelect* msg); + static const ::io::substrait::MaskExpression_Select& child(const MaskExpression_MapSelect* msg); +}; + +const ::io::substrait::MaskExpression_MapSelect_MapKey& +MaskExpression_MapSelect::_Internal::key(const MaskExpression_MapSelect* msg) { + return *msg->select_.key_; +} +const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& +MaskExpression_MapSelect::_Internal::expression(const MaskExpression_MapSelect* msg) { + return *msg->select_.expression_; +} +const ::io::substrait::MaskExpression_Select& +MaskExpression_MapSelect::_Internal::child(const MaskExpression_MapSelect* msg) { + return *msg->child_; +} +void MaskExpression_MapSelect::set_allocated_key(::io::substrait::MaskExpression_MapSelect_MapKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_select(); + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + set_has_key(); + select_.key_ = key; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.MapSelect.key) +} +void MaskExpression_MapSelect::set_allocated_expression(::io::substrait::MaskExpression_MapSelect_MapKeyExpression* expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_select(); + if (expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expression); + if (message_arena != submessage_arena) { + expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expression, submessage_arena); + } + set_has_expression(); + select_.expression_ = expression; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.MapSelect.expression) +} +MaskExpression_MapSelect::MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.MapSelect) +} +MaskExpression_MapSelect::MaskExpression_MapSelect(const MaskExpression_MapSelect& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::MaskExpression_Select(*from.child_); + } else { + child_ = nullptr; + } + clear_has_select(); + switch (from.select_case()) { + case kKey: { + _internal_mutable_key()->::io::substrait::MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); + break; + } + case kExpression: { + _internal_mutable_expression()->::io::substrait::MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); + break; + } + case SELECT_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.MapSelect) +} + +void MaskExpression_MapSelect::SharedCtor() { +child_ = nullptr; +clear_has_select(); +} + +MaskExpression_MapSelect::~MaskExpression_MapSelect() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.MapSelect) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression_MapSelect::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; + if (has_select()) { + clear_select(); + } +} + +void MaskExpression_MapSelect::ArenaDtor(void* object) { + MaskExpression_MapSelect* _this = reinterpret_cast< MaskExpression_MapSelect* >(object); + (void)_this; +} +void MaskExpression_MapSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression_MapSelect::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression_MapSelect::clear_select() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.MaskExpression.MapSelect) + switch (select_case()) { + case kKey: { + if (GetArena() == nullptr) { + delete select_.key_; + } + break; + } + case kExpression: { + if (GetArena() == nullptr) { + delete select_.expression_; + } + break; + } + case SELECT_NOT_SET: { + break; + } + } + _oneof_case_[0] = SELECT_NOT_SET; +} + + +void MaskExpression_MapSelect::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.MapSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + clear_select(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression_MapSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.MaskExpression.MapSelect.MapKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.MaskExpression.MapSelect.MapKeyExpression expression = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.MaskExpression.Select child = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_MapSelect::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.MapSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.MaskExpression.MapSelect.MapKey key = 1; + if (_internal_has_key()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::key(this), target, stream); + } + + // .io.substrait.MaskExpression.MapSelect.MapKeyExpression expression = 2; + if (_internal_has_expression()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::expression(this), target, stream); + } + + // .io.substrait.MaskExpression.Select child = 3; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.MapSelect) + return target; +} + +size_t MaskExpression_MapSelect::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.MapSelect) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.MaskExpression.Select child = 3; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + switch (select_case()) { + // .io.substrait.MaskExpression.MapSelect.MapKey key = 1; + case kKey: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *select_.key_); + break; + } + // .io.substrait.MaskExpression.MapSelect.MapKeyExpression expression = 2; + case kExpression: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *select_.expression_); + break; + } + case SELECT_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression_MapSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.MapSelect) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression_MapSelect* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.MapSelect) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.MapSelect) + MergeFrom(*source); + } +} + +void MaskExpression_MapSelect::MergeFrom(const MaskExpression_MapSelect& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.MapSelect) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::MaskExpression_Select::MergeFrom(from._internal_child()); + } + switch (from.select_case()) { + case kKey: { + _internal_mutable_key()->::io::substrait::MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); + break; + } + case kExpression: { + _internal_mutable_expression()->::io::substrait::MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); + break; + } + case SELECT_NOT_SET: { + break; + } + } +} + +void MaskExpression_MapSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.MapSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression_MapSelect::CopyFrom(const MaskExpression_MapSelect& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.MapSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression_MapSelect::IsInitialized() const { + return true; +} + +void MaskExpression_MapSelect::InternalSwap(MaskExpression_MapSelect* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(child_, other->child_); + swap(select_, other->select_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_MapSelect::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[15]); +} + +// =================================================================== + +class MaskExpression::_Internal { + public: + static const ::io::substrait::MaskExpression_StructSelect& select(const MaskExpression* msg); +}; + +const ::io::substrait::MaskExpression_StructSelect& +MaskExpression::_Internal::select(const MaskExpression* msg) { + return *msg->select_; +} +MaskExpression::MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression) +} +MaskExpression::MaskExpression(const MaskExpression& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_select()) { + select_ = new ::io::substrait::MaskExpression_StructSelect(*from.select_); + } else { + select_ = nullptr; + } + maintain_singular_struct_ = from.maintain_singular_struct_; + // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression) +} + +void MaskExpression::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&select_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&maintain_singular_struct_) - + reinterpret_cast(&select_)) + sizeof(maintain_singular_struct_)); +} + +MaskExpression::~MaskExpression() { + // @@protoc_insertion_point(destructor:io.substrait.MaskExpression) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void MaskExpression::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete select_; +} + +void MaskExpression::ArenaDtor(void* object) { + MaskExpression* _this = reinterpret_cast< MaskExpression* >(object); + (void)_this; +} +void MaskExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void MaskExpression::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void MaskExpression::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && select_ != nullptr) { + delete select_; + } + select_ = nullptr; + maintain_singular_struct_ = false; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* MaskExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.MaskExpression.StructSelect select = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_select(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool maintain_singular_struct = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + maintain_singular_struct_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.MaskExpression.StructSelect select = 1; + if (this->has_select()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::select(this), target, stream); + } + + // bool maintain_singular_struct = 2; + if (this->maintain_singular_struct() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_maintain_singular_struct(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression) + return target; +} + +size_t MaskExpression::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.MaskExpression.StructSelect select = 1; + if (this->has_select()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *select_); + } + + // bool maintain_singular_struct = 2; + if (this->maintain_singular_struct() != 0) { + total_size += 1 + 1; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void MaskExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression) + GOOGLE_DCHECK_NE(&from, this); + const MaskExpression* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression) + MergeFrom(*source); + } +} + +void MaskExpression::MergeFrom(const MaskExpression& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_select()) { + _internal_mutable_select()->::io::substrait::MaskExpression_StructSelect::MergeFrom(from._internal_select()); + } + if (from.maintain_singular_struct() != 0) { + _internal_set_maintain_singular_struct(from._internal_maintain_singular_struct()); + } +} + +void MaskExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void MaskExpression::CopyFrom(const MaskExpression& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool MaskExpression::IsInitialized() const { + return true; +} + +void MaskExpression::InternalSwap(MaskExpression* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(MaskExpression, maintain_singular_struct_) + + sizeof(MaskExpression::maintain_singular_struct_) + - PROTOBUF_FIELD_OFFSET(MaskExpression, select_)>( + reinterpret_cast(&select_), + reinterpret_cast(&other->select_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[16]); +} + +// =================================================================== + +class FieldReference::_Internal { + public: + static const ::io::substrait::ReferenceSegment& direct_reference(const FieldReference* msg); + static const ::io::substrait::MaskExpression& masked_reference(const FieldReference* msg); +}; + +const ::io::substrait::ReferenceSegment& +FieldReference::_Internal::direct_reference(const FieldReference* msg) { + return *msg->reference_type_.direct_reference_; +} +const ::io::substrait::MaskExpression& +FieldReference::_Internal::masked_reference(const FieldReference* msg) { + return *msg->reference_type_.masked_reference_; +} +void FieldReference::set_allocated_direct_reference(::io::substrait::ReferenceSegment* direct_reference) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (direct_reference) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(direct_reference); + if (message_arena != submessage_arena) { + direct_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, direct_reference, submessage_arena); + } + set_has_direct_reference(); + reference_type_.direct_reference_ = direct_reference; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FieldReference.direct_reference) +} +void FieldReference::set_allocated_masked_reference(::io::substrait::MaskExpression* masked_reference) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (masked_reference) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(masked_reference); + if (message_arena != submessage_arena) { + masked_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, masked_reference, submessage_arena); + } + set_has_masked_reference(); + reference_type_.masked_reference_ = masked_reference; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.FieldReference.masked_reference) +} +FieldReference::FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.FieldReference) +} +FieldReference::FieldReference(const FieldReference& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_reference_type(); + switch (from.reference_type_case()) { + case kDirectReference: { + _internal_mutable_direct_reference()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_direct_reference()); + break; + } + case kMaskedReference: { + _internal_mutable_masked_reference()->::io::substrait::MaskExpression::MergeFrom(from._internal_masked_reference()); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.FieldReference) +} + +void FieldReference::SharedCtor() { +clear_has_reference_type(); +} + +FieldReference::~FieldReference() { + // @@protoc_insertion_point(destructor:io.substrait.FieldReference) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void FieldReference::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_reference_type()) { + clear_reference_type(); + } +} + +void FieldReference::ArenaDtor(void* object) { + FieldReference* _this = reinterpret_cast< FieldReference* >(object); + (void)_this; +} +void FieldReference::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void FieldReference::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void FieldReference::clear_reference_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.FieldReference) + switch (reference_type_case()) { + case kDirectReference: { + if (GetArena() == nullptr) { + delete reference_type_.direct_reference_; + } + break; + } + case kMaskedReference: { + if (GetArena() == nullptr) { + delete reference_type_.masked_reference_; + } + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; +} + + +void FieldReference::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.FieldReference) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_reference_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FieldReference::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.ReferenceSegment direct_reference = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_direct_reference(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.MaskExpression masked_reference = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_masked_reference(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* FieldReference::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FieldReference) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.ReferenceSegment direct_reference = 1; + if (_internal_has_direct_reference()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::direct_reference(this), target, stream); + } + + // .io.substrait.MaskExpression masked_reference = 2; + if (_internal_has_masked_reference()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::masked_reference(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FieldReference) + return target; +} + +size_t FieldReference::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.FieldReference) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (reference_type_case()) { + // .io.substrait.ReferenceSegment direct_reference = 1; + case kDirectReference: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.direct_reference_); + break; + } + // .io.substrait.MaskExpression masked_reference = 2; + case kMaskedReference: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.masked_reference_); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void FieldReference::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FieldReference) + GOOGLE_DCHECK_NE(&from, this); + const FieldReference* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FieldReference) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FieldReference) + MergeFrom(*source); + } +} + +void FieldReference::MergeFrom(const FieldReference& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FieldReference) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.reference_type_case()) { + case kDirectReference: { + _internal_mutable_direct_reference()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_direct_reference()); + break; + } + case kMaskedReference: { + _internal_mutable_masked_reference()->::io::substrait::MaskExpression::MergeFrom(from._internal_masked_reference()); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } +} + +void FieldReference::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FieldReference) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FieldReference::CopyFrom(const FieldReference& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FieldReference) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FieldReference::IsInitialized() const { + return true; +} + +void FieldReference::InternalSwap(FieldReference* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(reference_type_, other->reference_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FieldReference::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, + file_level_metadata_selection_2eproto[17]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment_MapKey* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment_MapKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment_MapKey >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment_MapKeyExpression* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment_MapKeyExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment_MapKeyExpression >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment_StructField* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment_StructField >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment_StructField >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment_ListElement* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment_ListElement >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment_ListElement >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment_ListRange* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment_ListRange >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment_ListRange >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_Select* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_Select >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_Select >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_StructSelect* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_StructSelect >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_StructSelect >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_StructItem* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_StructItem >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_StructItem >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_ListSelect* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_ListSelect >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect_MapKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_MapSelect_MapKey >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect_MapKeyExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_MapSelect_MapKeyExpression >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_MapSelect* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_MapSelect >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::MaskExpression >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::FieldReference* Arena::CreateMaybeMessage< ::io::substrait::FieldReference >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::FieldReference >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/selection.pb.h b/cpp/src/generated/substrait/selection.pb.h new file mode 100644 index 00000000000..63e123fa6a2 --- /dev/null +++ b/cpp/src/generated/substrait/selection.pb.h @@ -0,0 +1,5460 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: selection.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_selection_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_selection_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_selection_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_selection_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[18] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_selection_2eproto; +namespace io { +namespace substrait { +class FieldReference; +struct FieldReferenceDefaultTypeInternal; +extern FieldReferenceDefaultTypeInternal _FieldReference_default_instance_; +class MaskExpression; +struct MaskExpressionDefaultTypeInternal; +extern MaskExpressionDefaultTypeInternal _MaskExpression_default_instance_; +class MaskExpression_ListSelect; +struct MaskExpression_ListSelectDefaultTypeInternal; +extern MaskExpression_ListSelectDefaultTypeInternal _MaskExpression_ListSelect_default_instance_; +class MaskExpression_ListSelect_ListSelectItem; +struct MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal; +extern MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_default_instance_; +class MaskExpression_ListSelect_ListSelectItem_ListElement; +struct MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal; +extern MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_; +class MaskExpression_ListSelect_ListSelectItem_ListSlice; +struct MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal; +extern MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_; +class MaskExpression_MapSelect; +struct MaskExpression_MapSelectDefaultTypeInternal; +extern MaskExpression_MapSelectDefaultTypeInternal _MaskExpression_MapSelect_default_instance_; +class MaskExpression_MapSelect_MapKey; +struct MaskExpression_MapSelect_MapKeyDefaultTypeInternal; +extern MaskExpression_MapSelect_MapKeyDefaultTypeInternal _MaskExpression_MapSelect_MapKey_default_instance_; +class MaskExpression_MapSelect_MapKeyExpression; +struct MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal; +extern MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _MaskExpression_MapSelect_MapKeyExpression_default_instance_; +class MaskExpression_Select; +struct MaskExpression_SelectDefaultTypeInternal; +extern MaskExpression_SelectDefaultTypeInternal _MaskExpression_Select_default_instance_; +class MaskExpression_StructItem; +struct MaskExpression_StructItemDefaultTypeInternal; +extern MaskExpression_StructItemDefaultTypeInternal _MaskExpression_StructItem_default_instance_; +class MaskExpression_StructSelect; +struct MaskExpression_StructSelectDefaultTypeInternal; +extern MaskExpression_StructSelectDefaultTypeInternal _MaskExpression_StructSelect_default_instance_; +class ReferenceSegment; +struct ReferenceSegmentDefaultTypeInternal; +extern ReferenceSegmentDefaultTypeInternal _ReferenceSegment_default_instance_; +class ReferenceSegment_ListElement; +struct ReferenceSegment_ListElementDefaultTypeInternal; +extern ReferenceSegment_ListElementDefaultTypeInternal _ReferenceSegment_ListElement_default_instance_; +class ReferenceSegment_ListRange; +struct ReferenceSegment_ListRangeDefaultTypeInternal; +extern ReferenceSegment_ListRangeDefaultTypeInternal _ReferenceSegment_ListRange_default_instance_; +class ReferenceSegment_MapKey; +struct ReferenceSegment_MapKeyDefaultTypeInternal; +extern ReferenceSegment_MapKeyDefaultTypeInternal _ReferenceSegment_MapKey_default_instance_; +class ReferenceSegment_MapKeyExpression; +struct ReferenceSegment_MapKeyExpressionDefaultTypeInternal; +extern ReferenceSegment_MapKeyExpressionDefaultTypeInternal _ReferenceSegment_MapKeyExpression_default_instance_; +class ReferenceSegment_StructField; +struct ReferenceSegment_StructFieldDefaultTypeInternal; +extern ReferenceSegment_StructFieldDefaultTypeInternal _ReferenceSegment_StructField_default_instance_; +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::FieldReference* Arena::CreateMaybeMessage<::io::substrait::FieldReference>(Arena*); +template<> ::io::substrait::MaskExpression* Arena::CreateMaybeMessage<::io::substrait::MaskExpression>(Arena*); +template<> ::io::substrait::MaskExpression_ListSelect* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_ListSelect>(Arena*); +template<> ::io::substrait::MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_ListSelect_ListSelectItem>(Arena*); +template<> ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement>(Arena*); +template<> ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice>(Arena*); +template<> ::io::substrait::MaskExpression_MapSelect* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_MapSelect>(Arena*); +template<> ::io::substrait::MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_MapSelect_MapKey>(Arena*); +template<> ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_MapSelect_MapKeyExpression>(Arena*); +template<> ::io::substrait::MaskExpression_Select* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_Select>(Arena*); +template<> ::io::substrait::MaskExpression_StructItem* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_StructItem>(Arena*); +template<> ::io::substrait::MaskExpression_StructSelect* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_StructSelect>(Arena*); +template<> ::io::substrait::ReferenceSegment* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment>(Arena*); +template<> ::io::substrait::ReferenceSegment_ListElement* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment_ListElement>(Arena*); +template<> ::io::substrait::ReferenceSegment_ListRange* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment_ListRange>(Arena*); +template<> ::io::substrait::ReferenceSegment_MapKey* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment_MapKey>(Arena*); +template<> ::io::substrait::ReferenceSegment_MapKeyExpression* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment_MapKeyExpression>(Arena*); +template<> ::io::substrait::ReferenceSegment_StructField* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment_StructField>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace io { +namespace substrait { + +// =================================================================== + +class ReferenceSegment_MapKey PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment.MapKey) */ { + public: + inline ReferenceSegment_MapKey() : ReferenceSegment_MapKey(nullptr) {} + ~ReferenceSegment_MapKey() override; + explicit constexpr ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReferenceSegment_MapKey(const ReferenceSegment_MapKey& from); + ReferenceSegment_MapKey(ReferenceSegment_MapKey&& from) noexcept + : ReferenceSegment_MapKey() { + *this = ::std::move(from); + } + + inline ReferenceSegment_MapKey& operator=(const ReferenceSegment_MapKey& from) { + CopyFrom(from); + return *this; + } + inline ReferenceSegment_MapKey& operator=(ReferenceSegment_MapKey&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReferenceSegment_MapKey& default_instance() { + return *internal_default_instance(); + } + static inline const ReferenceSegment_MapKey* internal_default_instance() { + return reinterpret_cast( + &_ReferenceSegment_MapKey_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(ReferenceSegment_MapKey& a, ReferenceSegment_MapKey& b) { + a.Swap(&b); + } + inline void Swap(ReferenceSegment_MapKey* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReferenceSegment_MapKey* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReferenceSegment_MapKey* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReferenceSegment_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReferenceSegment_MapKey& from); + void MergeFrom(const ReferenceSegment_MapKey& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReferenceSegment_MapKey* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReferenceSegment.MapKey"; + } + protected: + explicit ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMapKeyFieldNumber = 1, + kChildFieldNumber = 2, + }; + // string map_key = 1; + void clear_map_key(); + const std::string& map_key() const; + template + void set_map_key(ArgT0&& arg0, ArgT... args); + std::string* mutable_map_key(); + std::string* release_map_key(); + void set_allocated_map_key(std::string* map_key); + private: + const std::string& _internal_map_key() const; + void _internal_set_map_key(const std::string& value); + std::string* _internal_mutable_map_key(); + public: + + // .io.substrait.ReferenceSegment child = 2; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::ReferenceSegment& child() const; + ::io::substrait::ReferenceSegment* release_child(); + ::io::substrait::ReferenceSegment* mutable_child(); + void set_allocated_child(::io::substrait::ReferenceSegment* child); + private: + const ::io::substrait::ReferenceSegment& _internal_child() const; + ::io::substrait::ReferenceSegment* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::ReferenceSegment* child); + ::io::substrait::ReferenceSegment* unsafe_arena_release_child(); + + // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment.MapKey) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_; + ::io::substrait::ReferenceSegment* child_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class ReferenceSegment_MapKeyExpression PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment.MapKeyExpression) */ { + public: + inline ReferenceSegment_MapKeyExpression() : ReferenceSegment_MapKeyExpression(nullptr) {} + ~ReferenceSegment_MapKeyExpression() override; + explicit constexpr ReferenceSegment_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReferenceSegment_MapKeyExpression(const ReferenceSegment_MapKeyExpression& from); + ReferenceSegment_MapKeyExpression(ReferenceSegment_MapKeyExpression&& from) noexcept + : ReferenceSegment_MapKeyExpression() { + *this = ::std::move(from); + } + + inline ReferenceSegment_MapKeyExpression& operator=(const ReferenceSegment_MapKeyExpression& from) { + CopyFrom(from); + return *this; + } + inline ReferenceSegment_MapKeyExpression& operator=(ReferenceSegment_MapKeyExpression&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReferenceSegment_MapKeyExpression& default_instance() { + return *internal_default_instance(); + } + static inline const ReferenceSegment_MapKeyExpression* internal_default_instance() { + return reinterpret_cast( + &_ReferenceSegment_MapKeyExpression_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(ReferenceSegment_MapKeyExpression& a, ReferenceSegment_MapKeyExpression& b) { + a.Swap(&b); + } + inline void Swap(ReferenceSegment_MapKeyExpression* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReferenceSegment_MapKeyExpression* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReferenceSegment_MapKeyExpression* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReferenceSegment_MapKeyExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReferenceSegment_MapKeyExpression& from); + void MergeFrom(const ReferenceSegment_MapKeyExpression& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReferenceSegment_MapKeyExpression* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReferenceSegment.MapKeyExpression"; + } + protected: + explicit ReferenceSegment_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMapKeyExpressionFieldNumber = 1, + kChildFieldNumber = 2, + }; + // string map_key_expression = 1; + void clear_map_key_expression(); + const std::string& map_key_expression() const; + template + void set_map_key_expression(ArgT0&& arg0, ArgT... args); + std::string* mutable_map_key_expression(); + std::string* release_map_key_expression(); + void set_allocated_map_key_expression(std::string* map_key_expression); + private: + const std::string& _internal_map_key_expression() const; + void _internal_set_map_key_expression(const std::string& value); + std::string* _internal_mutable_map_key_expression(); + public: + + // .io.substrait.ReferenceSegment child = 2; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::ReferenceSegment& child() const; + ::io::substrait::ReferenceSegment* release_child(); + ::io::substrait::ReferenceSegment* mutable_child(); + void set_allocated_child(::io::substrait::ReferenceSegment* child); + private: + const ::io::substrait::ReferenceSegment& _internal_child() const; + ::io::substrait::ReferenceSegment* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::ReferenceSegment* child); + ::io::substrait::ReferenceSegment* unsafe_arena_release_child(); + + // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment.MapKeyExpression) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_expression_; + ::io::substrait::ReferenceSegment* child_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class ReferenceSegment_StructField PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment.StructField) */ { + public: + inline ReferenceSegment_StructField() : ReferenceSegment_StructField(nullptr) {} + ~ReferenceSegment_StructField() override; + explicit constexpr ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReferenceSegment_StructField(const ReferenceSegment_StructField& from); + ReferenceSegment_StructField(ReferenceSegment_StructField&& from) noexcept + : ReferenceSegment_StructField() { + *this = ::std::move(from); + } + + inline ReferenceSegment_StructField& operator=(const ReferenceSegment_StructField& from) { + CopyFrom(from); + return *this; + } + inline ReferenceSegment_StructField& operator=(ReferenceSegment_StructField&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReferenceSegment_StructField& default_instance() { + return *internal_default_instance(); + } + static inline const ReferenceSegment_StructField* internal_default_instance() { + return reinterpret_cast( + &_ReferenceSegment_StructField_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(ReferenceSegment_StructField& a, ReferenceSegment_StructField& b) { + a.Swap(&b); + } + inline void Swap(ReferenceSegment_StructField* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReferenceSegment_StructField* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReferenceSegment_StructField* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReferenceSegment_StructField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReferenceSegment_StructField& from); + void MergeFrom(const ReferenceSegment_StructField& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReferenceSegment_StructField* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReferenceSegment.StructField"; + } + protected: + explicit ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChildFieldNumber = 2, + kFieldFieldNumber = 1, + }; + // .io.substrait.ReferenceSegment child = 2; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::ReferenceSegment& child() const; + ::io::substrait::ReferenceSegment* release_child(); + ::io::substrait::ReferenceSegment* mutable_child(); + void set_allocated_child(::io::substrait::ReferenceSegment* child); + private: + const ::io::substrait::ReferenceSegment& _internal_child() const; + ::io::substrait::ReferenceSegment* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::ReferenceSegment* child); + ::io::substrait::ReferenceSegment* unsafe_arena_release_child(); + + // int32 field = 1; + void clear_field(); + ::PROTOBUF_NAMESPACE_ID::int32 field() const; + void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; + void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment.StructField) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ReferenceSegment* child_; + ::PROTOBUF_NAMESPACE_ID::int32 field_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class ReferenceSegment_ListElement PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment.ListElement) */ { + public: + inline ReferenceSegment_ListElement() : ReferenceSegment_ListElement(nullptr) {} + ~ReferenceSegment_ListElement() override; + explicit constexpr ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReferenceSegment_ListElement(const ReferenceSegment_ListElement& from); + ReferenceSegment_ListElement(ReferenceSegment_ListElement&& from) noexcept + : ReferenceSegment_ListElement() { + *this = ::std::move(from); + } + + inline ReferenceSegment_ListElement& operator=(const ReferenceSegment_ListElement& from) { + CopyFrom(from); + return *this; + } + inline ReferenceSegment_ListElement& operator=(ReferenceSegment_ListElement&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReferenceSegment_ListElement& default_instance() { + return *internal_default_instance(); + } + static inline const ReferenceSegment_ListElement* internal_default_instance() { + return reinterpret_cast( + &_ReferenceSegment_ListElement_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(ReferenceSegment_ListElement& a, ReferenceSegment_ListElement& b) { + a.Swap(&b); + } + inline void Swap(ReferenceSegment_ListElement* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReferenceSegment_ListElement* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReferenceSegment_ListElement* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReferenceSegment_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReferenceSegment_ListElement& from); + void MergeFrom(const ReferenceSegment_ListElement& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReferenceSegment_ListElement* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReferenceSegment.ListElement"; + } + protected: + explicit ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChildFieldNumber = 2, + kOffsetFieldNumber = 1, + }; + // .io.substrait.ReferenceSegment child = 2; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::ReferenceSegment& child() const; + ::io::substrait::ReferenceSegment* release_child(); + ::io::substrait::ReferenceSegment* mutable_child(); + void set_allocated_child(::io::substrait::ReferenceSegment* child); + private: + const ::io::substrait::ReferenceSegment& _internal_child() const; + ::io::substrait::ReferenceSegment* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::ReferenceSegment* child); + ::io::substrait::ReferenceSegment* unsafe_arena_release_child(); + + // int32 offset = 1; + void clear_offset(); + ::PROTOBUF_NAMESPACE_ID::int32 offset() const; + void set_offset(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_offset() const; + void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment.ListElement) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ReferenceSegment* child_; + ::PROTOBUF_NAMESPACE_ID::int32 offset_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class ReferenceSegment_ListRange PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment.ListRange) */ { + public: + inline ReferenceSegment_ListRange() : ReferenceSegment_ListRange(nullptr) {} + ~ReferenceSegment_ListRange() override; + explicit constexpr ReferenceSegment_ListRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReferenceSegment_ListRange(const ReferenceSegment_ListRange& from); + ReferenceSegment_ListRange(ReferenceSegment_ListRange&& from) noexcept + : ReferenceSegment_ListRange() { + *this = ::std::move(from); + } + + inline ReferenceSegment_ListRange& operator=(const ReferenceSegment_ListRange& from) { + CopyFrom(from); + return *this; + } + inline ReferenceSegment_ListRange& operator=(ReferenceSegment_ListRange&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReferenceSegment_ListRange& default_instance() { + return *internal_default_instance(); + } + static inline const ReferenceSegment_ListRange* internal_default_instance() { + return reinterpret_cast( + &_ReferenceSegment_ListRange_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(ReferenceSegment_ListRange& a, ReferenceSegment_ListRange& b) { + a.Swap(&b); + } + inline void Swap(ReferenceSegment_ListRange* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReferenceSegment_ListRange* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReferenceSegment_ListRange* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReferenceSegment_ListRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReferenceSegment_ListRange& from); + void MergeFrom(const ReferenceSegment_ListRange& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReferenceSegment_ListRange* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReferenceSegment.ListRange"; + } + protected: + explicit ReferenceSegment_ListRange(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChildFieldNumber = 3, + kStartFieldNumber = 1, + kEndFieldNumber = 2, + }; + // .io.substrait.ReferenceSegment child = 3; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::ReferenceSegment& child() const; + ::io::substrait::ReferenceSegment* release_child(); + ::io::substrait::ReferenceSegment* mutable_child(); + void set_allocated_child(::io::substrait::ReferenceSegment* child); + private: + const ::io::substrait::ReferenceSegment& _internal_child() const; + ::io::substrait::ReferenceSegment* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::ReferenceSegment* child); + ::io::substrait::ReferenceSegment* unsafe_arena_release_child(); + + // int32 start = 1; + void clear_start(); + ::PROTOBUF_NAMESPACE_ID::int32 start() const; + void set_start(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_start() const; + void _internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // int32 end = 2; + void clear_end(); + ::PROTOBUF_NAMESPACE_ID::int32 end() const; + void set_end(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const; + void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment.ListRange) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::ReferenceSegment* child_; + ::PROTOBUF_NAMESPACE_ID::int32 start_; + ::PROTOBUF_NAMESPACE_ID::int32 end_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class ReferenceSegment PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment) */ { + public: + inline ReferenceSegment() : ReferenceSegment(nullptr) {} + ~ReferenceSegment() override; + explicit constexpr ReferenceSegment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReferenceSegment(const ReferenceSegment& from); + ReferenceSegment(ReferenceSegment&& from) noexcept + : ReferenceSegment() { + *this = ::std::move(from); + } + + inline ReferenceSegment& operator=(const ReferenceSegment& from) { + CopyFrom(from); + return *this; + } + inline ReferenceSegment& operator=(ReferenceSegment&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReferenceSegment& default_instance() { + return *internal_default_instance(); + } + enum ReferenceTypeCase { + kMapKey = 1, + kExpression = 2, + kStructField = 3, + kListElement = 4, + kListRange = 5, + REFERENCE_TYPE_NOT_SET = 0, + }; + + static inline const ReferenceSegment* internal_default_instance() { + return reinterpret_cast( + &_ReferenceSegment_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(ReferenceSegment& a, ReferenceSegment& b) { + a.Swap(&b); + } + inline void Swap(ReferenceSegment* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReferenceSegment* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReferenceSegment* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReferenceSegment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReferenceSegment& from); + void MergeFrom(const ReferenceSegment& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReferenceSegment* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReferenceSegment"; + } + protected: + explicit ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef ReferenceSegment_MapKey MapKey; + typedef ReferenceSegment_MapKeyExpression MapKeyExpression; + typedef ReferenceSegment_StructField StructField; + typedef ReferenceSegment_ListElement ListElement; + typedef ReferenceSegment_ListRange ListRange; + + // accessors ------------------------------------------------------- + + enum : int { + kMapKeyFieldNumber = 1, + kExpressionFieldNumber = 2, + kStructFieldFieldNumber = 3, + kListElementFieldNumber = 4, + kListRangeFieldNumber = 5, + }; + // .io.substrait.ReferenceSegment.MapKey map_key = 1; + bool has_map_key() const; + private: + bool _internal_has_map_key() const; + public: + void clear_map_key(); + const ::io::substrait::ReferenceSegment_MapKey& map_key() const; + ::io::substrait::ReferenceSegment_MapKey* release_map_key(); + ::io::substrait::ReferenceSegment_MapKey* mutable_map_key(); + void set_allocated_map_key(::io::substrait::ReferenceSegment_MapKey* map_key); + private: + const ::io::substrait::ReferenceSegment_MapKey& _internal_map_key() const; + ::io::substrait::ReferenceSegment_MapKey* _internal_mutable_map_key(); + public: + void unsafe_arena_set_allocated_map_key( + ::io::substrait::ReferenceSegment_MapKey* map_key); + ::io::substrait::ReferenceSegment_MapKey* unsafe_arena_release_map_key(); + + // .io.substrait.ReferenceSegment.MapKeyExpression expression = 2; + bool has_expression() const; + private: + bool _internal_has_expression() const; + public: + void clear_expression(); + const ::io::substrait::ReferenceSegment_MapKeyExpression& expression() const; + ::io::substrait::ReferenceSegment_MapKeyExpression* release_expression(); + ::io::substrait::ReferenceSegment_MapKeyExpression* mutable_expression(); + void set_allocated_expression(::io::substrait::ReferenceSegment_MapKeyExpression* expression); + private: + const ::io::substrait::ReferenceSegment_MapKeyExpression& _internal_expression() const; + ::io::substrait::ReferenceSegment_MapKeyExpression* _internal_mutable_expression(); + public: + void unsafe_arena_set_allocated_expression( + ::io::substrait::ReferenceSegment_MapKeyExpression* expression); + ::io::substrait::ReferenceSegment_MapKeyExpression* unsafe_arena_release_expression(); + + // .io.substrait.ReferenceSegment.StructField struct_field = 3; + bool has_struct_field() const; + private: + bool _internal_has_struct_field() const; + public: + void clear_struct_field(); + const ::io::substrait::ReferenceSegment_StructField& struct_field() const; + ::io::substrait::ReferenceSegment_StructField* release_struct_field(); + ::io::substrait::ReferenceSegment_StructField* mutable_struct_field(); + void set_allocated_struct_field(::io::substrait::ReferenceSegment_StructField* struct_field); + private: + const ::io::substrait::ReferenceSegment_StructField& _internal_struct_field() const; + ::io::substrait::ReferenceSegment_StructField* _internal_mutable_struct_field(); + public: + void unsafe_arena_set_allocated_struct_field( + ::io::substrait::ReferenceSegment_StructField* struct_field); + ::io::substrait::ReferenceSegment_StructField* unsafe_arena_release_struct_field(); + + // .io.substrait.ReferenceSegment.ListElement list_element = 4; + bool has_list_element() const; + private: + bool _internal_has_list_element() const; + public: + void clear_list_element(); + const ::io::substrait::ReferenceSegment_ListElement& list_element() const; + ::io::substrait::ReferenceSegment_ListElement* release_list_element(); + ::io::substrait::ReferenceSegment_ListElement* mutable_list_element(); + void set_allocated_list_element(::io::substrait::ReferenceSegment_ListElement* list_element); + private: + const ::io::substrait::ReferenceSegment_ListElement& _internal_list_element() const; + ::io::substrait::ReferenceSegment_ListElement* _internal_mutable_list_element(); + public: + void unsafe_arena_set_allocated_list_element( + ::io::substrait::ReferenceSegment_ListElement* list_element); + ::io::substrait::ReferenceSegment_ListElement* unsafe_arena_release_list_element(); + + // .io.substrait.ReferenceSegment.ListRange list_range = 5; + bool has_list_range() const; + private: + bool _internal_has_list_range() const; + public: + void clear_list_range(); + const ::io::substrait::ReferenceSegment_ListRange& list_range() const; + ::io::substrait::ReferenceSegment_ListRange* release_list_range(); + ::io::substrait::ReferenceSegment_ListRange* mutable_list_range(); + void set_allocated_list_range(::io::substrait::ReferenceSegment_ListRange* list_range); + private: + const ::io::substrait::ReferenceSegment_ListRange& _internal_list_range() const; + ::io::substrait::ReferenceSegment_ListRange* _internal_mutable_list_range(); + public: + void unsafe_arena_set_allocated_list_range( + ::io::substrait::ReferenceSegment_ListRange* list_range); + ::io::substrait::ReferenceSegment_ListRange* unsafe_arena_release_list_range(); + + void clear_reference_type(); + ReferenceTypeCase reference_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment) + private: + class _Internal; + void set_has_map_key(); + void set_has_expression(); + void set_has_struct_field(); + void set_has_list_element(); + void set_has_list_range(); + + inline bool has_reference_type() const; + inline void clear_has_reference_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union ReferenceTypeUnion { + constexpr ReferenceTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::ReferenceSegment_MapKey* map_key_; + ::io::substrait::ReferenceSegment_MapKeyExpression* expression_; + ::io::substrait::ReferenceSegment_StructField* struct_field_; + ::io::substrait::ReferenceSegment_ListElement* list_element_; + ::io::substrait::ReferenceSegment_ListRange* list_range_; + } reference_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression_Select PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.Select) */ { + public: + inline MaskExpression_Select() : MaskExpression_Select(nullptr) {} + ~MaskExpression_Select() override; + explicit constexpr MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression_Select(const MaskExpression_Select& from); + MaskExpression_Select(MaskExpression_Select&& from) noexcept + : MaskExpression_Select() { + *this = ::std::move(from); + } + + inline MaskExpression_Select& operator=(const MaskExpression_Select& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression_Select& operator=(MaskExpression_Select&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression_Select& default_instance() { + return *internal_default_instance(); + } + enum TypeCase { + kStruct = 1, + kList = 2, + kMap = 3, + TYPE_NOT_SET = 0, + }; + + static inline const MaskExpression_Select* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_Select_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(MaskExpression_Select& a, MaskExpression_Select& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression_Select* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression_Select* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression_Select* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression_Select* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression_Select& from); + void MergeFrom(const MaskExpression_Select& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression_Select* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression.Select"; + } + protected: + explicit MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStructFieldNumber = 1, + kListFieldNumber = 2, + kMapFieldNumber = 3, + }; + // .io.substrait.MaskExpression.StructSelect struct = 1; + bool has_struct_() const; + private: + bool _internal_has_struct_() const; + public: + void clear_struct_(); + const ::io::substrait::MaskExpression_StructSelect& struct_() const; + ::io::substrait::MaskExpression_StructSelect* release_struct_(); + ::io::substrait::MaskExpression_StructSelect* mutable_struct_(); + void set_allocated_struct_(::io::substrait::MaskExpression_StructSelect* struct_); + private: + const ::io::substrait::MaskExpression_StructSelect& _internal_struct_() const; + ::io::substrait::MaskExpression_StructSelect* _internal_mutable_struct_(); + public: + void unsafe_arena_set_allocated_struct_( + ::io::substrait::MaskExpression_StructSelect* struct_); + ::io::substrait::MaskExpression_StructSelect* unsafe_arena_release_struct_(); + + // .io.substrait.MaskExpression.ListSelect list = 2; + bool has_list() const; + private: + bool _internal_has_list() const; + public: + void clear_list(); + const ::io::substrait::MaskExpression_ListSelect& list() const; + ::io::substrait::MaskExpression_ListSelect* release_list(); + ::io::substrait::MaskExpression_ListSelect* mutable_list(); + void set_allocated_list(::io::substrait::MaskExpression_ListSelect* list); + private: + const ::io::substrait::MaskExpression_ListSelect& _internal_list() const; + ::io::substrait::MaskExpression_ListSelect* _internal_mutable_list(); + public: + void unsafe_arena_set_allocated_list( + ::io::substrait::MaskExpression_ListSelect* list); + ::io::substrait::MaskExpression_ListSelect* unsafe_arena_release_list(); + + // .io.substrait.MaskExpression.MapSelect map = 3; + bool has_map() const; + private: + bool _internal_has_map() const; + public: + void clear_map(); + const ::io::substrait::MaskExpression_MapSelect& map() const; + ::io::substrait::MaskExpression_MapSelect* release_map(); + ::io::substrait::MaskExpression_MapSelect* mutable_map(); + void set_allocated_map(::io::substrait::MaskExpression_MapSelect* map); + private: + const ::io::substrait::MaskExpression_MapSelect& _internal_map() const; + ::io::substrait::MaskExpression_MapSelect* _internal_mutable_map(); + public: + void unsafe_arena_set_allocated_map( + ::io::substrait::MaskExpression_MapSelect* map); + ::io::substrait::MaskExpression_MapSelect* unsafe_arena_release_map(); + + void clear_type(); + TypeCase type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.Select) + private: + class _Internal; + void set_has_struct_(); + void set_has_list(); + void set_has_map(); + + inline bool has_type() const; + inline void clear_has_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union TypeUnion { + constexpr TypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::MaskExpression_StructSelect* struct__; + ::io::substrait::MaskExpression_ListSelect* list_; + ::io::substrait::MaskExpression_MapSelect* map_; + } type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression_StructSelect PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.StructSelect) */ { + public: + inline MaskExpression_StructSelect() : MaskExpression_StructSelect(nullptr) {} + ~MaskExpression_StructSelect() override; + explicit constexpr MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression_StructSelect(const MaskExpression_StructSelect& from); + MaskExpression_StructSelect(MaskExpression_StructSelect&& from) noexcept + : MaskExpression_StructSelect() { + *this = ::std::move(from); + } + + inline MaskExpression_StructSelect& operator=(const MaskExpression_StructSelect& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression_StructSelect& operator=(MaskExpression_StructSelect&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression_StructSelect& default_instance() { + return *internal_default_instance(); + } + static inline const MaskExpression_StructSelect* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_StructSelect_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(MaskExpression_StructSelect& a, MaskExpression_StructSelect& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression_StructSelect* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression_StructSelect* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression_StructSelect* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression_StructSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression_StructSelect& from); + void MergeFrom(const MaskExpression_StructSelect& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression_StructSelect* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression.StructSelect"; + } + protected: + explicit MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStructItemsFieldNumber = 1, + }; + // repeated .io.substrait.MaskExpression.StructItem struct_items = 1; + int struct_items_size() const; + private: + int _internal_struct_items_size() const; + public: + void clear_struct_items(); + ::io::substrait::MaskExpression_StructItem* mutable_struct_items(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_StructItem >* + mutable_struct_items(); + private: + const ::io::substrait::MaskExpression_StructItem& _internal_struct_items(int index) const; + ::io::substrait::MaskExpression_StructItem* _internal_add_struct_items(); + public: + const ::io::substrait::MaskExpression_StructItem& struct_items(int index) const; + ::io::substrait::MaskExpression_StructItem* add_struct_items(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_StructItem >& + struct_items() const; + + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.StructSelect) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_StructItem > struct_items_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression_StructItem PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.StructItem) */ { + public: + inline MaskExpression_StructItem() : MaskExpression_StructItem(nullptr) {} + ~MaskExpression_StructItem() override; + explicit constexpr MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression_StructItem(const MaskExpression_StructItem& from); + MaskExpression_StructItem(MaskExpression_StructItem&& from) noexcept + : MaskExpression_StructItem() { + *this = ::std::move(from); + } + + inline MaskExpression_StructItem& operator=(const MaskExpression_StructItem& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression_StructItem& operator=(MaskExpression_StructItem&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression_StructItem& default_instance() { + return *internal_default_instance(); + } + static inline const MaskExpression_StructItem* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_StructItem_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(MaskExpression_StructItem& a, MaskExpression_StructItem& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression_StructItem* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression_StructItem* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression_StructItem* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression_StructItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression_StructItem& from); + void MergeFrom(const MaskExpression_StructItem& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression_StructItem* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression.StructItem"; + } + protected: + explicit MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChildFieldNumber = 2, + kFieldFieldNumber = 1, + }; + // .io.substrait.MaskExpression.Select child = 2; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::MaskExpression_Select& child() const; + ::io::substrait::MaskExpression_Select* release_child(); + ::io::substrait::MaskExpression_Select* mutable_child(); + void set_allocated_child(::io::substrait::MaskExpression_Select* child); + private: + const ::io::substrait::MaskExpression_Select& _internal_child() const; + ::io::substrait::MaskExpression_Select* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::MaskExpression_Select* child); + ::io::substrait::MaskExpression_Select* unsafe_arena_release_child(); + + // int32 field = 1; + void clear_field(); + ::PROTOBUF_NAMESPACE_ID::int32 field() const; + void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; + void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.StructItem) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::MaskExpression_Select* child_; + ::PROTOBUF_NAMESPACE_ID::int32 field_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) */ { + public: + inline MaskExpression_ListSelect_ListSelectItem_ListElement() : MaskExpression_ListSelect_ListSelectItem_ListElement(nullptr) {} + ~MaskExpression_ListSelect_ListSelectItem_ListElement() override; + explicit constexpr MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression_ListSelect_ListSelectItem_ListElement(const MaskExpression_ListSelect_ListSelectItem_ListElement& from); + MaskExpression_ListSelect_ListSelectItem_ListElement(MaskExpression_ListSelect_ListSelectItem_ListElement&& from) noexcept + : MaskExpression_ListSelect_ListSelectItem_ListElement() { + *this = ::std::move(from); + } + + inline MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(const MaskExpression_ListSelect_ListSelectItem_ListElement& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(MaskExpression_ListSelect_ListSelectItem_ListElement&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression_ListSelect_ListSelectItem_ListElement& default_instance() { + return *internal_default_instance(); + } + static inline const MaskExpression_ListSelect_ListSelectItem_ListElement* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(MaskExpression_ListSelect_ListSelectItem_ListElement& a, MaskExpression_ListSelect_ListSelectItem_ListElement& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression_ListSelect_ListSelectItem_ListElement* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression_ListSelect_ListSelectItem_ListElement* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression_ListSelect_ListSelectItem_ListElement* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression_ListSelect_ListSelectItem_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression_ListSelect_ListSelectItem_ListElement& from); + void MergeFrom(const MaskExpression_ListSelect_ListSelectItem_ListElement& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression_ListSelect_ListSelectItem_ListElement* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement"; + } + protected: + explicit MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFieldFieldNumber = 1, + }; + // int32 field = 1; + void clear_field(); + ::PROTOBUF_NAMESPACE_ID::int32 field() const; + void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; + void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::int32 field_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) */ { + public: + inline MaskExpression_ListSelect_ListSelectItem_ListSlice() : MaskExpression_ListSelect_ListSelectItem_ListSlice(nullptr) {} + ~MaskExpression_ListSelect_ListSelectItem_ListSlice() override; + explicit constexpr MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression_ListSelect_ListSelectItem_ListSlice(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from); + MaskExpression_ListSelect_ListSelectItem_ListSlice(MaskExpression_ListSelect_ListSelectItem_ListSlice&& from) noexcept + : MaskExpression_ListSelect_ListSelectItem_ListSlice() { + *this = ::std::move(from); + } + + inline MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(MaskExpression_ListSelect_ListSelectItem_ListSlice&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression_ListSelect_ListSelectItem_ListSlice& default_instance() { + return *internal_default_instance(); + } + static inline const MaskExpression_ListSelect_ListSelectItem_ListSlice* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(MaskExpression_ListSelect_ListSelectItem_ListSlice& a, MaskExpression_ListSelect_ListSelectItem_ListSlice& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression_ListSelect_ListSelectItem_ListSlice* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression_ListSelect_ListSelectItem_ListSlice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from); + void MergeFrom(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression_ListSelect_ListSelectItem_ListSlice* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice"; + } + protected: + explicit MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStartFieldNumber = 1, + kEndFieldNumber = 2, + }; + // int32 start = 1; + void clear_start(); + ::PROTOBUF_NAMESPACE_ID::int32 start() const; + void set_start(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_start() const; + void _internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // int32 end = 2; + void clear_end(); + ::PROTOBUF_NAMESPACE_ID::int32 end() const; + void set_end(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const; + void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::int32 start_; + ::PROTOBUF_NAMESPACE_ID::int32 end_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.ListSelect.ListSelectItem) */ { + public: + inline MaskExpression_ListSelect_ListSelectItem() : MaskExpression_ListSelect_ListSelectItem(nullptr) {} + ~MaskExpression_ListSelect_ListSelectItem() override; + explicit constexpr MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression_ListSelect_ListSelectItem(const MaskExpression_ListSelect_ListSelectItem& from); + MaskExpression_ListSelect_ListSelectItem(MaskExpression_ListSelect_ListSelectItem&& from) noexcept + : MaskExpression_ListSelect_ListSelectItem() { + *this = ::std::move(from); + } + + inline MaskExpression_ListSelect_ListSelectItem& operator=(const MaskExpression_ListSelect_ListSelectItem& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression_ListSelect_ListSelectItem& operator=(MaskExpression_ListSelect_ListSelectItem&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression_ListSelect_ListSelectItem& default_instance() { + return *internal_default_instance(); + } + enum TypeCase { + kItem = 1, + kSlice = 2, + TYPE_NOT_SET = 0, + }; + + static inline const MaskExpression_ListSelect_ListSelectItem* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_ListSelect_ListSelectItem_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(MaskExpression_ListSelect_ListSelectItem& a, MaskExpression_ListSelect_ListSelectItem& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression_ListSelect_ListSelectItem* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression_ListSelect_ListSelectItem* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression_ListSelect_ListSelectItem* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression_ListSelect_ListSelectItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression_ListSelect_ListSelectItem& from); + void MergeFrom(const MaskExpression_ListSelect_ListSelectItem& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression_ListSelect_ListSelectItem* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression.ListSelect.ListSelectItem"; + } + protected: + explicit MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef MaskExpression_ListSelect_ListSelectItem_ListElement ListElement; + typedef MaskExpression_ListSelect_ListSelectItem_ListSlice ListSlice; + + // accessors ------------------------------------------------------- + + enum : int { + kItemFieldNumber = 1, + kSliceFieldNumber = 2, + }; + // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + bool has_item() const; + private: + bool _internal_has_item() const; + public: + void clear_item(); + const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& item() const; + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* release_item(); + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* mutable_item(); + void set_allocated_item(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* item); + private: + const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& _internal_item() const; + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* _internal_mutable_item(); + public: + void unsafe_arena_set_allocated_item( + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* item); + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* unsafe_arena_release_item(); + + // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + bool has_slice() const; + private: + bool _internal_has_slice() const; + public: + void clear_slice(); + const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& slice() const; + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* release_slice(); + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* mutable_slice(); + void set_allocated_slice(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); + private: + const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& _internal_slice() const; + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* _internal_mutable_slice(); + public: + void unsafe_arena_set_allocated_slice( + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* unsafe_arena_release_slice(); + + void clear_type(); + TypeCase type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.ListSelect.ListSelectItem) + private: + class _Internal; + void set_has_item(); + void set_has_slice(); + + inline bool has_type() const; + inline void clear_has_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union TypeUnion { + constexpr TypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* item_; + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* slice_; + } type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression_ListSelect PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.ListSelect) */ { + public: + inline MaskExpression_ListSelect() : MaskExpression_ListSelect(nullptr) {} + ~MaskExpression_ListSelect() override; + explicit constexpr MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression_ListSelect(const MaskExpression_ListSelect& from); + MaskExpression_ListSelect(MaskExpression_ListSelect&& from) noexcept + : MaskExpression_ListSelect() { + *this = ::std::move(from); + } + + inline MaskExpression_ListSelect& operator=(const MaskExpression_ListSelect& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression_ListSelect& operator=(MaskExpression_ListSelect&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression_ListSelect& default_instance() { + return *internal_default_instance(); + } + static inline const MaskExpression_ListSelect* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_ListSelect_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(MaskExpression_ListSelect& a, MaskExpression_ListSelect& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression_ListSelect* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression_ListSelect* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression_ListSelect* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression_ListSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression_ListSelect& from); + void MergeFrom(const MaskExpression_ListSelect& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression_ListSelect* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression.ListSelect"; + } + protected: + explicit MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef MaskExpression_ListSelect_ListSelectItem ListSelectItem; + + // accessors ------------------------------------------------------- + + enum : int { + kSelectionFieldNumber = 1, + kChildFieldNumber = 2, + }; + // repeated .io.substrait.MaskExpression.ListSelect.ListSelectItem selection = 1; + int selection_size() const; + private: + int _internal_selection_size() const; + public: + void clear_selection(); + ::io::substrait::MaskExpression_ListSelect_ListSelectItem* mutable_selection(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >* + mutable_selection(); + private: + const ::io::substrait::MaskExpression_ListSelect_ListSelectItem& _internal_selection(int index) const; + ::io::substrait::MaskExpression_ListSelect_ListSelectItem* _internal_add_selection(); + public: + const ::io::substrait::MaskExpression_ListSelect_ListSelectItem& selection(int index) const; + ::io::substrait::MaskExpression_ListSelect_ListSelectItem* add_selection(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >& + selection() const; + + // .io.substrait.MaskExpression.Select child = 2; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::MaskExpression_Select& child() const; + ::io::substrait::MaskExpression_Select* release_child(); + ::io::substrait::MaskExpression_Select* mutable_child(); + void set_allocated_child(::io::substrait::MaskExpression_Select* child); + private: + const ::io::substrait::MaskExpression_Select& _internal_child() const; + ::io::substrait::MaskExpression_Select* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::MaskExpression_Select* child); + ::io::substrait::MaskExpression_Select* unsafe_arena_release_child(); + + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.ListSelect) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_ListSelect_ListSelectItem > selection_; + ::io::substrait::MaskExpression_Select* child_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.MapSelect.MapKey) */ { + public: + inline MaskExpression_MapSelect_MapKey() : MaskExpression_MapSelect_MapKey(nullptr) {} + ~MaskExpression_MapSelect_MapKey() override; + explicit constexpr MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression_MapSelect_MapKey(const MaskExpression_MapSelect_MapKey& from); + MaskExpression_MapSelect_MapKey(MaskExpression_MapSelect_MapKey&& from) noexcept + : MaskExpression_MapSelect_MapKey() { + *this = ::std::move(from); + } + + inline MaskExpression_MapSelect_MapKey& operator=(const MaskExpression_MapSelect_MapKey& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression_MapSelect_MapKey& operator=(MaskExpression_MapSelect_MapKey&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression_MapSelect_MapKey& default_instance() { + return *internal_default_instance(); + } + static inline const MaskExpression_MapSelect_MapKey* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_MapSelect_MapKey_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(MaskExpression_MapSelect_MapKey& a, MaskExpression_MapSelect_MapKey& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression_MapSelect_MapKey* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression_MapSelect_MapKey* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression_MapSelect_MapKey* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression_MapSelect_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression_MapSelect_MapKey& from); + void MergeFrom(const MaskExpression_MapSelect_MapKey& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression_MapSelect_MapKey* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression.MapSelect.MapKey"; + } + protected: + explicit MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMapKeyFieldNumber = 1, + }; + // string map_key = 1; + void clear_map_key(); + const std::string& map_key() const; + template + void set_map_key(ArgT0&& arg0, ArgT... args); + std::string* mutable_map_key(); + std::string* release_map_key(); + void set_allocated_map_key(std::string* map_key); + private: + const std::string& _internal_map_key() const; + void _internal_set_map_key(const std::string& value); + std::string* _internal_mutable_map_key(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.MapSelect.MapKey) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.MapSelect.MapKeyExpression) */ { + public: + inline MaskExpression_MapSelect_MapKeyExpression() : MaskExpression_MapSelect_MapKeyExpression(nullptr) {} + ~MaskExpression_MapSelect_MapKeyExpression() override; + explicit constexpr MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression_MapSelect_MapKeyExpression(const MaskExpression_MapSelect_MapKeyExpression& from); + MaskExpression_MapSelect_MapKeyExpression(MaskExpression_MapSelect_MapKeyExpression&& from) noexcept + : MaskExpression_MapSelect_MapKeyExpression() { + *this = ::std::move(from); + } + + inline MaskExpression_MapSelect_MapKeyExpression& operator=(const MaskExpression_MapSelect_MapKeyExpression& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression_MapSelect_MapKeyExpression& operator=(MaskExpression_MapSelect_MapKeyExpression&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression_MapSelect_MapKeyExpression& default_instance() { + return *internal_default_instance(); + } + static inline const MaskExpression_MapSelect_MapKeyExpression* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_MapSelect_MapKeyExpression_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(MaskExpression_MapSelect_MapKeyExpression& a, MaskExpression_MapSelect_MapKeyExpression& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression_MapSelect_MapKeyExpression* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression_MapSelect_MapKeyExpression* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression_MapSelect_MapKeyExpression* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression_MapSelect_MapKeyExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression_MapSelect_MapKeyExpression& from); + void MergeFrom(const MaskExpression_MapSelect_MapKeyExpression& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression_MapSelect_MapKeyExpression* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression.MapSelect.MapKeyExpression"; + } + protected: + explicit MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMapKeyExpressionFieldNumber = 1, + }; + // string map_key_expression = 1; + void clear_map_key_expression(); + const std::string& map_key_expression() const; + template + void set_map_key_expression(ArgT0&& arg0, ArgT... args); + std::string* mutable_map_key_expression(); + std::string* release_map_key_expression(); + void set_allocated_map_key_expression(std::string* map_key_expression); + private: + const std::string& _internal_map_key_expression() const; + void _internal_set_map_key_expression(const std::string& value); + std::string* _internal_mutable_map_key_expression(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.MapSelect.MapKeyExpression) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_expression_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression_MapSelect PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.MapSelect) */ { + public: + inline MaskExpression_MapSelect() : MaskExpression_MapSelect(nullptr) {} + ~MaskExpression_MapSelect() override; + explicit constexpr MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression_MapSelect(const MaskExpression_MapSelect& from); + MaskExpression_MapSelect(MaskExpression_MapSelect&& from) noexcept + : MaskExpression_MapSelect() { + *this = ::std::move(from); + } + + inline MaskExpression_MapSelect& operator=(const MaskExpression_MapSelect& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression_MapSelect& operator=(MaskExpression_MapSelect&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression_MapSelect& default_instance() { + return *internal_default_instance(); + } + enum SelectCase { + kKey = 1, + kExpression = 2, + SELECT_NOT_SET = 0, + }; + + static inline const MaskExpression_MapSelect* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_MapSelect_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(MaskExpression_MapSelect& a, MaskExpression_MapSelect& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression_MapSelect* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression_MapSelect* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression_MapSelect* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression_MapSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression_MapSelect& from); + void MergeFrom(const MaskExpression_MapSelect& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression_MapSelect* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression.MapSelect"; + } + protected: + explicit MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef MaskExpression_MapSelect_MapKey MapKey; + typedef MaskExpression_MapSelect_MapKeyExpression MapKeyExpression; + + // accessors ------------------------------------------------------- + + enum : int { + kChildFieldNumber = 3, + kKeyFieldNumber = 1, + kExpressionFieldNumber = 2, + }; + // .io.substrait.MaskExpression.Select child = 3; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::MaskExpression_Select& child() const; + ::io::substrait::MaskExpression_Select* release_child(); + ::io::substrait::MaskExpression_Select* mutable_child(); + void set_allocated_child(::io::substrait::MaskExpression_Select* child); + private: + const ::io::substrait::MaskExpression_Select& _internal_child() const; + ::io::substrait::MaskExpression_Select* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::MaskExpression_Select* child); + ::io::substrait::MaskExpression_Select* unsafe_arena_release_child(); + + // .io.substrait.MaskExpression.MapSelect.MapKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::io::substrait::MaskExpression_MapSelect_MapKey& key() const; + ::io::substrait::MaskExpression_MapSelect_MapKey* release_key(); + ::io::substrait::MaskExpression_MapSelect_MapKey* mutable_key(); + void set_allocated_key(::io::substrait::MaskExpression_MapSelect_MapKey* key); + private: + const ::io::substrait::MaskExpression_MapSelect_MapKey& _internal_key() const; + ::io::substrait::MaskExpression_MapSelect_MapKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::io::substrait::MaskExpression_MapSelect_MapKey* key); + ::io::substrait::MaskExpression_MapSelect_MapKey* unsafe_arena_release_key(); + + // .io.substrait.MaskExpression.MapSelect.MapKeyExpression expression = 2; + bool has_expression() const; + private: + bool _internal_has_expression() const; + public: + void clear_expression(); + const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& expression() const; + ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* release_expression(); + ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* mutable_expression(); + void set_allocated_expression(::io::substrait::MaskExpression_MapSelect_MapKeyExpression* expression); + private: + const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& _internal_expression() const; + ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* _internal_mutable_expression(); + public: + void unsafe_arena_set_allocated_expression( + ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* expression); + ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* unsafe_arena_release_expression(); + + void clear_select(); + SelectCase select_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.MapSelect) + private: + class _Internal; + void set_has_key(); + void set_has_expression(); + + inline bool has_select() const; + inline void clear_has_select(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::MaskExpression_Select* child_; + union SelectUnion { + constexpr SelectUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::MaskExpression_MapSelect_MapKey* key_; + ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* expression_; + } select_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class MaskExpression PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression) */ { + public: + inline MaskExpression() : MaskExpression(nullptr) {} + ~MaskExpression() override; + explicit constexpr MaskExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + MaskExpression(const MaskExpression& from); + MaskExpression(MaskExpression&& from) noexcept + : MaskExpression() { + *this = ::std::move(from); + } + + inline MaskExpression& operator=(const MaskExpression& from) { + CopyFrom(from); + return *this; + } + inline MaskExpression& operator=(MaskExpression&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 MaskExpression& default_instance() { + return *internal_default_instance(); + } + static inline const MaskExpression* internal_default_instance() { + return reinterpret_cast( + &_MaskExpression_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(MaskExpression& a, MaskExpression& b) { + a.Swap(&b); + } + inline void Swap(MaskExpression* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MaskExpression* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline MaskExpression* New() const final { + return CreateMaybeMessage(nullptr); + } + + MaskExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const MaskExpression& from); + void MergeFrom(const MaskExpression& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(MaskExpression* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.MaskExpression"; + } + protected: + explicit MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef MaskExpression_Select Select; + typedef MaskExpression_StructSelect StructSelect; + typedef MaskExpression_StructItem StructItem; + typedef MaskExpression_ListSelect ListSelect; + typedef MaskExpression_MapSelect MapSelect; + + // accessors ------------------------------------------------------- + + enum : int { + kSelectFieldNumber = 1, + kMaintainSingularStructFieldNumber = 2, + }; + // .io.substrait.MaskExpression.StructSelect select = 1; + bool has_select() const; + private: + bool _internal_has_select() const; + public: + void clear_select(); + const ::io::substrait::MaskExpression_StructSelect& select() const; + ::io::substrait::MaskExpression_StructSelect* release_select(); + ::io::substrait::MaskExpression_StructSelect* mutable_select(); + void set_allocated_select(::io::substrait::MaskExpression_StructSelect* select); + private: + const ::io::substrait::MaskExpression_StructSelect& _internal_select() const; + ::io::substrait::MaskExpression_StructSelect* _internal_mutable_select(); + public: + void unsafe_arena_set_allocated_select( + ::io::substrait::MaskExpression_StructSelect* select); + ::io::substrait::MaskExpression_StructSelect* unsafe_arena_release_select(); + + // bool maintain_singular_struct = 2; + void clear_maintain_singular_struct(); + bool maintain_singular_struct() const; + void set_maintain_singular_struct(bool value); + private: + bool _internal_maintain_singular_struct() const; + void _internal_set_maintain_singular_struct(bool value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::MaskExpression_StructSelect* select_; + bool maintain_singular_struct_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_selection_2eproto; +}; +// ------------------------------------------------------------------- + +class FieldReference PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FieldReference) */ { + public: + inline FieldReference() : FieldReference(nullptr) {} + ~FieldReference() override; + explicit constexpr FieldReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FieldReference(const FieldReference& from); + FieldReference(FieldReference&& from) noexcept + : FieldReference() { + *this = ::std::move(from); + } + + inline FieldReference& operator=(const FieldReference& from) { + CopyFrom(from); + return *this; + } + inline FieldReference& operator=(FieldReference&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 FieldReference& default_instance() { + return *internal_default_instance(); + } + enum ReferenceTypeCase { + kDirectReference = 1, + kMaskedReference = 2, + REFERENCE_TYPE_NOT_SET = 0, + }; + + static inline const FieldReference* internal_default_instance() { + return reinterpret_cast( + &_FieldReference_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(FieldReference& a, FieldReference& b) { + a.Swap(&b); + } + inline void Swap(FieldReference* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FieldReference* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline FieldReference* New() const final { + return CreateMaybeMessage(nullptr); + } + + FieldReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const FieldReference& from); + void MergeFrom(const FieldReference& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FieldReference* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.FieldReference"; + } + protected: + explicit FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDirectReferenceFieldNumber = 1, + kMaskedReferenceFieldNumber = 2, + }; + // .io.substrait.ReferenceSegment direct_reference = 1; + bool has_direct_reference() const; + private: + bool _internal_has_direct_reference() const; + public: + void clear_direct_reference(); + const ::io::substrait::ReferenceSegment& direct_reference() const; + ::io::substrait::ReferenceSegment* release_direct_reference(); + ::io::substrait::ReferenceSegment* mutable_direct_reference(); + void set_allocated_direct_reference(::io::substrait::ReferenceSegment* direct_reference); + private: + const ::io::substrait::ReferenceSegment& _internal_direct_reference() const; + ::io::substrait::ReferenceSegment* _internal_mutable_direct_reference(); + public: + void unsafe_arena_set_allocated_direct_reference( + ::io::substrait::ReferenceSegment* direct_reference); + ::io::substrait::ReferenceSegment* unsafe_arena_release_direct_reference(); + + // .io.substrait.MaskExpression masked_reference = 2; + bool has_masked_reference() const; + private: + bool _internal_has_masked_reference() const; + public: + void clear_masked_reference(); + const ::io::substrait::MaskExpression& masked_reference() const; + ::io::substrait::MaskExpression* release_masked_reference(); + ::io::substrait::MaskExpression* mutable_masked_reference(); + void set_allocated_masked_reference(::io::substrait::MaskExpression* masked_reference); + private: + const ::io::substrait::MaskExpression& _internal_masked_reference() const; + ::io::substrait::MaskExpression* _internal_mutable_masked_reference(); + public: + void unsafe_arena_set_allocated_masked_reference( + ::io::substrait::MaskExpression* masked_reference); + ::io::substrait::MaskExpression* unsafe_arena_release_masked_reference(); + + void clear_reference_type(); + ReferenceTypeCase reference_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.FieldReference) + private: + class _Internal; + void set_has_direct_reference(); + void set_has_masked_reference(); + + inline bool has_reference_type() const; + inline void clear_has_reference_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union ReferenceTypeUnion { + constexpr ReferenceTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::ReferenceSegment* direct_reference_; + ::io::substrait::MaskExpression* masked_reference_; + } reference_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_selection_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ReferenceSegment_MapKey + +// string map_key = 1; +inline void ReferenceSegment_MapKey::clear_map_key() { + map_key_.ClearToEmpty(); +} +inline const std::string& ReferenceSegment_MapKey::map_key() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.MapKey.map_key) + return _internal_map_key(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void ReferenceSegment_MapKey::set_map_key(ArgT0&& arg0, ArgT... args) { + + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.MapKey.map_key) +} +inline std::string* ReferenceSegment_MapKey::mutable_map_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.MapKey.map_key) + return _internal_mutable_map_key(); +} +inline const std::string& ReferenceSegment_MapKey::_internal_map_key() const { + return map_key_.Get(); +} +inline void ReferenceSegment_MapKey::_internal_set_map_key(const std::string& value) { + + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* ReferenceSegment_MapKey::_internal_mutable_map_key() { + + return map_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* ReferenceSegment_MapKey::release_map_key() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.MapKey.map_key) + return map_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ReferenceSegment_MapKey::set_allocated_map_key(std::string* map_key) { + if (map_key != nullptr) { + + } else { + + } + map_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.MapKey.map_key) +} + +// .io.substrait.ReferenceSegment child = 2; +inline bool ReferenceSegment_MapKey::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; +} +inline bool ReferenceSegment_MapKey::has_child() const { + return _internal_has_child(); +} +inline void ReferenceSegment_MapKey::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; +} +inline const ::io::substrait::ReferenceSegment& ReferenceSegment_MapKey::_internal_child() const { + const ::io::substrait::ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ReferenceSegment_default_instance_); +} +inline const ::io::substrait::ReferenceSegment& ReferenceSegment_MapKey::child() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.MapKey.child) + return _internal_child(); +} +inline void ReferenceSegment_MapKey::unsafe_arena_set_allocated_child( + ::io::substrait::ReferenceSegment* child) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); + } + child_ = child; + if (child) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.MapKey.child) +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKey::release_child() { + + ::io::substrait::ReferenceSegment* temp = child_; + child_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKey::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.MapKey.child) + + ::io::substrait::ReferenceSegment* temp = child_; + child_ = nullptr; + return temp; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKey::_internal_mutable_child() { + + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ReferenceSegment>(GetArena()); + child_ = p; + } + return child_; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKey::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.MapKey.child) + return _internal_mutable_child(); +} +inline void ReferenceSegment_MapKey::set_allocated_child(::io::substrait::ReferenceSegment* child) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete child_; + } + if (child) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + if (message_arena != submessage_arena) { + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); + } + + } else { + + } + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.MapKey.child) +} + +// ------------------------------------------------------------------- + +// ReferenceSegment_MapKeyExpression + +// string map_key_expression = 1; +inline void ReferenceSegment_MapKeyExpression::clear_map_key_expression() { + map_key_expression_.ClearToEmpty(); +} +inline const std::string& ReferenceSegment_MapKeyExpression::map_key_expression() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression) + return _internal_map_key_expression(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void ReferenceSegment_MapKeyExpression::set_map_key_expression(ArgT0&& arg0, ArgT... args) { + + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression) +} +inline std::string* ReferenceSegment_MapKeyExpression::mutable_map_key_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression) + return _internal_mutable_map_key_expression(); +} +inline const std::string& ReferenceSegment_MapKeyExpression::_internal_map_key_expression() const { + return map_key_expression_.Get(); +} +inline void ReferenceSegment_MapKeyExpression::_internal_set_map_key_expression(const std::string& value) { + + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* ReferenceSegment_MapKeyExpression::_internal_mutable_map_key_expression() { + + return map_key_expression_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* ReferenceSegment_MapKeyExpression::release_map_key_expression() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression) + return map_key_expression_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void ReferenceSegment_MapKeyExpression::set_allocated_map_key_expression(std::string* map_key_expression) { + if (map_key_expression != nullptr) { + + } else { + + } + map_key_expression_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key_expression, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression) +} + +// .io.substrait.ReferenceSegment child = 2; +inline bool ReferenceSegment_MapKeyExpression::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; +} +inline bool ReferenceSegment_MapKeyExpression::has_child() const { + return _internal_has_child(); +} +inline void ReferenceSegment_MapKeyExpression::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; +} +inline const ::io::substrait::ReferenceSegment& ReferenceSegment_MapKeyExpression::_internal_child() const { + const ::io::substrait::ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ReferenceSegment_default_instance_); +} +inline const ::io::substrait::ReferenceSegment& ReferenceSegment_MapKeyExpression::child() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.MapKeyExpression.child) + return _internal_child(); +} +inline void ReferenceSegment_MapKeyExpression::unsafe_arena_set_allocated_child( + ::io::substrait::ReferenceSegment* child) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); + } + child_ = child; + if (child) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.MapKeyExpression.child) +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKeyExpression::release_child() { + + ::io::substrait::ReferenceSegment* temp = child_; + child_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKeyExpression::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.MapKeyExpression.child) + + ::io::substrait::ReferenceSegment* temp = child_; + child_ = nullptr; + return temp; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKeyExpression::_internal_mutable_child() { + + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ReferenceSegment>(GetArena()); + child_ = p; + } + return child_; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKeyExpression::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.MapKeyExpression.child) + return _internal_mutable_child(); +} +inline void ReferenceSegment_MapKeyExpression::set_allocated_child(::io::substrait::ReferenceSegment* child) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete child_; + } + if (child) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + if (message_arena != submessage_arena) { + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); + } + + } else { + + } + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.MapKeyExpression.child) +} + +// ------------------------------------------------------------------- + +// ReferenceSegment_StructField + +// int32 field = 1; +inline void ReferenceSegment_StructField::clear_field() { + field_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_StructField::_internal_field() const { + return field_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_StructField::field() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.StructField.field) + return _internal_field(); +} +inline void ReferenceSegment_StructField::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + + field_ = value; +} +inline void ReferenceSegment_StructField::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_field(value); + // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.StructField.field) +} + +// .io.substrait.ReferenceSegment child = 2; +inline bool ReferenceSegment_StructField::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; +} +inline bool ReferenceSegment_StructField::has_child() const { + return _internal_has_child(); +} +inline void ReferenceSegment_StructField::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; +} +inline const ::io::substrait::ReferenceSegment& ReferenceSegment_StructField::_internal_child() const { + const ::io::substrait::ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ReferenceSegment_default_instance_); +} +inline const ::io::substrait::ReferenceSegment& ReferenceSegment_StructField::child() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.StructField.child) + return _internal_child(); +} +inline void ReferenceSegment_StructField::unsafe_arena_set_allocated_child( + ::io::substrait::ReferenceSegment* child) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); + } + child_ = child; + if (child) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.StructField.child) +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_StructField::release_child() { + + ::io::substrait::ReferenceSegment* temp = child_; + child_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_StructField::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.StructField.child) + + ::io::substrait::ReferenceSegment* temp = child_; + child_ = nullptr; + return temp; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_StructField::_internal_mutable_child() { + + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ReferenceSegment>(GetArena()); + child_ = p; + } + return child_; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_StructField::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.StructField.child) + return _internal_mutable_child(); +} +inline void ReferenceSegment_StructField::set_allocated_child(::io::substrait::ReferenceSegment* child) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete child_; + } + if (child) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + if (message_arena != submessage_arena) { + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); + } + + } else { + + } + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.StructField.child) +} + +// ------------------------------------------------------------------- + +// ReferenceSegment_ListElement + +// int32 offset = 1; +inline void ReferenceSegment_ListElement::clear_offset() { + offset_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListElement::_internal_offset() const { + return offset_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListElement::offset() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.ListElement.offset) + return _internal_offset(); +} +inline void ReferenceSegment_ListElement::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) { + + offset_ = value; +} +inline void ReferenceSegment_ListElement::set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.ListElement.offset) +} + +// .io.substrait.ReferenceSegment child = 2; +inline bool ReferenceSegment_ListElement::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; +} +inline bool ReferenceSegment_ListElement::has_child() const { + return _internal_has_child(); +} +inline void ReferenceSegment_ListElement::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; +} +inline const ::io::substrait::ReferenceSegment& ReferenceSegment_ListElement::_internal_child() const { + const ::io::substrait::ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ReferenceSegment_default_instance_); +} +inline const ::io::substrait::ReferenceSegment& ReferenceSegment_ListElement::child() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.ListElement.child) + return _internal_child(); +} +inline void ReferenceSegment_ListElement::unsafe_arena_set_allocated_child( + ::io::substrait::ReferenceSegment* child) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); + } + child_ = child; + if (child) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.ListElement.child) +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListElement::release_child() { + + ::io::substrait::ReferenceSegment* temp = child_; + child_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListElement::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.ListElement.child) + + ::io::substrait::ReferenceSegment* temp = child_; + child_ = nullptr; + return temp; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListElement::_internal_mutable_child() { + + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ReferenceSegment>(GetArena()); + child_ = p; + } + return child_; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListElement::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.ListElement.child) + return _internal_mutable_child(); +} +inline void ReferenceSegment_ListElement::set_allocated_child(::io::substrait::ReferenceSegment* child) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete child_; + } + if (child) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + if (message_arena != submessage_arena) { + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); + } + + } else { + + } + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.ListElement.child) +} + +// ------------------------------------------------------------------- + +// ReferenceSegment_ListRange + +// int32 start = 1; +inline void ReferenceSegment_ListRange::clear_start() { + start_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListRange::_internal_start() const { + return start_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListRange::start() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.ListRange.start) + return _internal_start(); +} +inline void ReferenceSegment_ListRange::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { + + start_ = value; +} +inline void ReferenceSegment_ListRange::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_start(value); + // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.ListRange.start) +} + +// int32 end = 2; +inline void ReferenceSegment_ListRange::clear_end() { + end_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListRange::_internal_end() const { + return end_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListRange::end() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.ListRange.end) + return _internal_end(); +} +inline void ReferenceSegment_ListRange::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { + + end_ = value; +} +inline void ReferenceSegment_ListRange::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_end(value); + // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.ListRange.end) +} + +// .io.substrait.ReferenceSegment child = 3; +inline bool ReferenceSegment_ListRange::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; +} +inline bool ReferenceSegment_ListRange::has_child() const { + return _internal_has_child(); +} +inline void ReferenceSegment_ListRange::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; +} +inline const ::io::substrait::ReferenceSegment& ReferenceSegment_ListRange::_internal_child() const { + const ::io::substrait::ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_ReferenceSegment_default_instance_); +} +inline const ::io::substrait::ReferenceSegment& ReferenceSegment_ListRange::child() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.ListRange.child) + return _internal_child(); +} +inline void ReferenceSegment_ListRange::unsafe_arena_set_allocated_child( + ::io::substrait::ReferenceSegment* child) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); + } + child_ = child; + if (child) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.ListRange.child) +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListRange::release_child() { + + ::io::substrait::ReferenceSegment* temp = child_; + child_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListRange::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.ListRange.child) + + ::io::substrait::ReferenceSegment* temp = child_; + child_ = nullptr; + return temp; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListRange::_internal_mutable_child() { + + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::ReferenceSegment>(GetArena()); + child_ = p; + } + return child_; +} +inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListRange::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.ListRange.child) + return _internal_mutable_child(); +} +inline void ReferenceSegment_ListRange::set_allocated_child(::io::substrait::ReferenceSegment* child) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete child_; + } + if (child) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + if (message_arena != submessage_arena) { + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); + } + + } else { + + } + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.ListRange.child) +} + +// ------------------------------------------------------------------- + +// ReferenceSegment + +// .io.substrait.ReferenceSegment.MapKey map_key = 1; +inline bool ReferenceSegment::_internal_has_map_key() const { + return reference_type_case() == kMapKey; +} +inline bool ReferenceSegment::has_map_key() const { + return _internal_has_map_key(); +} +inline void ReferenceSegment::set_has_map_key() { + _oneof_case_[0] = kMapKey; +} +inline void ReferenceSegment::clear_map_key() { + if (_internal_has_map_key()) { + if (GetArena() == nullptr) { + delete reference_type_.map_key_; + } + clear_has_reference_type(); + } +} +inline ::io::substrait::ReferenceSegment_MapKey* ReferenceSegment::release_map_key() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.map_key) + if (_internal_has_map_key()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment_MapKey* temp = reference_type_.map_key_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.map_key_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReferenceSegment_MapKey& ReferenceSegment::_internal_map_key() const { + return _internal_has_map_key() + ? *reference_type_.map_key_ + : reinterpret_cast< ::io::substrait::ReferenceSegment_MapKey&>(::io::substrait::_ReferenceSegment_MapKey_default_instance_); +} +inline const ::io::substrait::ReferenceSegment_MapKey& ReferenceSegment::map_key() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.map_key) + return _internal_map_key(); +} +inline ::io::substrait::ReferenceSegment_MapKey* ReferenceSegment::unsafe_arena_release_map_key() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReferenceSegment.map_key) + if (_internal_has_map_key()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment_MapKey* temp = reference_type_.map_key_; + reference_type_.map_key_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ReferenceSegment::unsafe_arena_set_allocated_map_key(::io::substrait::ReferenceSegment_MapKey* map_key) { + clear_reference_type(); + if (map_key) { + set_has_map_key(); + reference_type_.map_key_ = map_key; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.map_key) +} +inline ::io::substrait::ReferenceSegment_MapKey* ReferenceSegment::_internal_mutable_map_key() { + if (!_internal_has_map_key()) { + clear_reference_type(); + set_has_map_key(); + reference_type_.map_key_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment_MapKey >(GetArena()); + } + return reference_type_.map_key_; +} +inline ::io::substrait::ReferenceSegment_MapKey* ReferenceSegment::mutable_map_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.map_key) + return _internal_mutable_map_key(); +} + +// .io.substrait.ReferenceSegment.MapKeyExpression expression = 2; +inline bool ReferenceSegment::_internal_has_expression() const { + return reference_type_case() == kExpression; +} +inline bool ReferenceSegment::has_expression() const { + return _internal_has_expression(); +} +inline void ReferenceSegment::set_has_expression() { + _oneof_case_[0] = kExpression; +} +inline void ReferenceSegment::clear_expression() { + if (_internal_has_expression()) { + if (GetArena() == nullptr) { + delete reference_type_.expression_; + } + clear_has_reference_type(); + } +} +inline ::io::substrait::ReferenceSegment_MapKeyExpression* ReferenceSegment::release_expression() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.expression) + if (_internal_has_expression()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment_MapKeyExpression* temp = reference_type_.expression_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.expression_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReferenceSegment_MapKeyExpression& ReferenceSegment::_internal_expression() const { + return _internal_has_expression() + ? *reference_type_.expression_ + : reinterpret_cast< ::io::substrait::ReferenceSegment_MapKeyExpression&>(::io::substrait::_ReferenceSegment_MapKeyExpression_default_instance_); +} +inline const ::io::substrait::ReferenceSegment_MapKeyExpression& ReferenceSegment::expression() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.expression) + return _internal_expression(); +} +inline ::io::substrait::ReferenceSegment_MapKeyExpression* ReferenceSegment::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReferenceSegment.expression) + if (_internal_has_expression()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment_MapKeyExpression* temp = reference_type_.expression_; + reference_type_.expression_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ReferenceSegment::unsafe_arena_set_allocated_expression(::io::substrait::ReferenceSegment_MapKeyExpression* expression) { + clear_reference_type(); + if (expression) { + set_has_expression(); + reference_type_.expression_ = expression; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.expression) +} +inline ::io::substrait::ReferenceSegment_MapKeyExpression* ReferenceSegment::_internal_mutable_expression() { + if (!_internal_has_expression()) { + clear_reference_type(); + set_has_expression(); + reference_type_.expression_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment_MapKeyExpression >(GetArena()); + } + return reference_type_.expression_; +} +inline ::io::substrait::ReferenceSegment_MapKeyExpression* ReferenceSegment::mutable_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.expression) + return _internal_mutable_expression(); +} + +// .io.substrait.ReferenceSegment.StructField struct_field = 3; +inline bool ReferenceSegment::_internal_has_struct_field() const { + return reference_type_case() == kStructField; +} +inline bool ReferenceSegment::has_struct_field() const { + return _internal_has_struct_field(); +} +inline void ReferenceSegment::set_has_struct_field() { + _oneof_case_[0] = kStructField; +} +inline void ReferenceSegment::clear_struct_field() { + if (_internal_has_struct_field()) { + if (GetArena() == nullptr) { + delete reference_type_.struct_field_; + } + clear_has_reference_type(); + } +} +inline ::io::substrait::ReferenceSegment_StructField* ReferenceSegment::release_struct_field() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.struct_field) + if (_internal_has_struct_field()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment_StructField* temp = reference_type_.struct_field_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.struct_field_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReferenceSegment_StructField& ReferenceSegment::_internal_struct_field() const { + return _internal_has_struct_field() + ? *reference_type_.struct_field_ + : reinterpret_cast< ::io::substrait::ReferenceSegment_StructField&>(::io::substrait::_ReferenceSegment_StructField_default_instance_); +} +inline const ::io::substrait::ReferenceSegment_StructField& ReferenceSegment::struct_field() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.struct_field) + return _internal_struct_field(); +} +inline ::io::substrait::ReferenceSegment_StructField* ReferenceSegment::unsafe_arena_release_struct_field() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReferenceSegment.struct_field) + if (_internal_has_struct_field()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment_StructField* temp = reference_type_.struct_field_; + reference_type_.struct_field_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ReferenceSegment::unsafe_arena_set_allocated_struct_field(::io::substrait::ReferenceSegment_StructField* struct_field) { + clear_reference_type(); + if (struct_field) { + set_has_struct_field(); + reference_type_.struct_field_ = struct_field; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.struct_field) +} +inline ::io::substrait::ReferenceSegment_StructField* ReferenceSegment::_internal_mutable_struct_field() { + if (!_internal_has_struct_field()) { + clear_reference_type(); + set_has_struct_field(); + reference_type_.struct_field_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment_StructField >(GetArena()); + } + return reference_type_.struct_field_; +} +inline ::io::substrait::ReferenceSegment_StructField* ReferenceSegment::mutable_struct_field() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.struct_field) + return _internal_mutable_struct_field(); +} + +// .io.substrait.ReferenceSegment.ListElement list_element = 4; +inline bool ReferenceSegment::_internal_has_list_element() const { + return reference_type_case() == kListElement; +} +inline bool ReferenceSegment::has_list_element() const { + return _internal_has_list_element(); +} +inline void ReferenceSegment::set_has_list_element() { + _oneof_case_[0] = kListElement; +} +inline void ReferenceSegment::clear_list_element() { + if (_internal_has_list_element()) { + if (GetArena() == nullptr) { + delete reference_type_.list_element_; + } + clear_has_reference_type(); + } +} +inline ::io::substrait::ReferenceSegment_ListElement* ReferenceSegment::release_list_element() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.list_element) + if (_internal_has_list_element()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment_ListElement* temp = reference_type_.list_element_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.list_element_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReferenceSegment_ListElement& ReferenceSegment::_internal_list_element() const { + return _internal_has_list_element() + ? *reference_type_.list_element_ + : reinterpret_cast< ::io::substrait::ReferenceSegment_ListElement&>(::io::substrait::_ReferenceSegment_ListElement_default_instance_); +} +inline const ::io::substrait::ReferenceSegment_ListElement& ReferenceSegment::list_element() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.list_element) + return _internal_list_element(); +} +inline ::io::substrait::ReferenceSegment_ListElement* ReferenceSegment::unsafe_arena_release_list_element() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReferenceSegment.list_element) + if (_internal_has_list_element()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment_ListElement* temp = reference_type_.list_element_; + reference_type_.list_element_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ReferenceSegment::unsafe_arena_set_allocated_list_element(::io::substrait::ReferenceSegment_ListElement* list_element) { + clear_reference_type(); + if (list_element) { + set_has_list_element(); + reference_type_.list_element_ = list_element; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.list_element) +} +inline ::io::substrait::ReferenceSegment_ListElement* ReferenceSegment::_internal_mutable_list_element() { + if (!_internal_has_list_element()) { + clear_reference_type(); + set_has_list_element(); + reference_type_.list_element_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment_ListElement >(GetArena()); + } + return reference_type_.list_element_; +} +inline ::io::substrait::ReferenceSegment_ListElement* ReferenceSegment::mutable_list_element() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.list_element) + return _internal_mutable_list_element(); +} + +// .io.substrait.ReferenceSegment.ListRange list_range = 5; +inline bool ReferenceSegment::_internal_has_list_range() const { + return reference_type_case() == kListRange; +} +inline bool ReferenceSegment::has_list_range() const { + return _internal_has_list_range(); +} +inline void ReferenceSegment::set_has_list_range() { + _oneof_case_[0] = kListRange; +} +inline void ReferenceSegment::clear_list_range() { + if (_internal_has_list_range()) { + if (GetArena() == nullptr) { + delete reference_type_.list_range_; + } + clear_has_reference_type(); + } +} +inline ::io::substrait::ReferenceSegment_ListRange* ReferenceSegment::release_list_range() { + // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.list_range) + if (_internal_has_list_range()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment_ListRange* temp = reference_type_.list_range_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.list_range_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReferenceSegment_ListRange& ReferenceSegment::_internal_list_range() const { + return _internal_has_list_range() + ? *reference_type_.list_range_ + : reinterpret_cast< ::io::substrait::ReferenceSegment_ListRange&>(::io::substrait::_ReferenceSegment_ListRange_default_instance_); +} +inline const ::io::substrait::ReferenceSegment_ListRange& ReferenceSegment::list_range() const { + // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.list_range) + return _internal_list_range(); +} +inline ::io::substrait::ReferenceSegment_ListRange* ReferenceSegment::unsafe_arena_release_list_range() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReferenceSegment.list_range) + if (_internal_has_list_range()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment_ListRange* temp = reference_type_.list_range_; + reference_type_.list_range_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ReferenceSegment::unsafe_arena_set_allocated_list_range(::io::substrait::ReferenceSegment_ListRange* list_range) { + clear_reference_type(); + if (list_range) { + set_has_list_range(); + reference_type_.list_range_ = list_range; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.list_range) +} +inline ::io::substrait::ReferenceSegment_ListRange* ReferenceSegment::_internal_mutable_list_range() { + if (!_internal_has_list_range()) { + clear_reference_type(); + set_has_list_range(); + reference_type_.list_range_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment_ListRange >(GetArena()); + } + return reference_type_.list_range_; +} +inline ::io::substrait::ReferenceSegment_ListRange* ReferenceSegment::mutable_list_range() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.list_range) + return _internal_mutable_list_range(); +} + +inline bool ReferenceSegment::has_reference_type() const { + return reference_type_case() != REFERENCE_TYPE_NOT_SET; +} +inline void ReferenceSegment::clear_has_reference_type() { + _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; +} +inline ReferenceSegment::ReferenceTypeCase ReferenceSegment::reference_type_case() const { + return ReferenceSegment::ReferenceTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// MaskExpression_Select + +// .io.substrait.MaskExpression.StructSelect struct = 1; +inline bool MaskExpression_Select::_internal_has_struct_() const { + return type_case() == kStruct; +} +inline bool MaskExpression_Select::has_struct_() const { + return _internal_has_struct_(); +} +inline void MaskExpression_Select::set_has_struct_() { + _oneof_case_[0] = kStruct; +} +inline void MaskExpression_Select::clear_struct_() { + if (_internal_has_struct_()) { + if (GetArena() == nullptr) { + delete type_.struct__; + } + clear_has_type(); + } +} +inline ::io::substrait::MaskExpression_StructSelect* MaskExpression_Select::release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.Select.struct) + if (_internal_has_struct_()) { + clear_has_type(); + ::io::substrait::MaskExpression_StructSelect* temp = type_.struct__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + type_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::MaskExpression_StructSelect& MaskExpression_Select::_internal_struct_() const { + return _internal_has_struct_() + ? *type_.struct__ + : reinterpret_cast< ::io::substrait::MaskExpression_StructSelect&>(::io::substrait::_MaskExpression_StructSelect_default_instance_); +} +inline const ::io::substrait::MaskExpression_StructSelect& MaskExpression_Select::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.Select.struct) + return _internal_struct_(); +} +inline ::io::substrait::MaskExpression_StructSelect* MaskExpression_Select::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.Select.struct) + if (_internal_has_struct_()) { + clear_has_type(); + ::io::substrait::MaskExpression_StructSelect* temp = type_.struct__; + type_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MaskExpression_Select::unsafe_arena_set_allocated_struct_(::io::substrait::MaskExpression_StructSelect* struct_) { + clear_type(); + if (struct_) { + set_has_struct_(); + type_.struct__ = struct_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.Select.struct) +} +inline ::io::substrait::MaskExpression_StructSelect* MaskExpression_Select::_internal_mutable_struct_() { + if (!_internal_has_struct_()) { + clear_type(); + set_has_struct_(); + type_.struct__ = CreateMaybeMessage< ::io::substrait::MaskExpression_StructSelect >(GetArena()); + } + return type_.struct__; +} +inline ::io::substrait::MaskExpression_StructSelect* MaskExpression_Select::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.Select.struct) + return _internal_mutable_struct_(); +} + +// .io.substrait.MaskExpression.ListSelect list = 2; +inline bool MaskExpression_Select::_internal_has_list() const { + return type_case() == kList; +} +inline bool MaskExpression_Select::has_list() const { + return _internal_has_list(); +} +inline void MaskExpression_Select::set_has_list() { + _oneof_case_[0] = kList; +} +inline void MaskExpression_Select::clear_list() { + if (_internal_has_list()) { + if (GetArena() == nullptr) { + delete type_.list_; + } + clear_has_type(); + } +} +inline ::io::substrait::MaskExpression_ListSelect* MaskExpression_Select::release_list() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.Select.list) + if (_internal_has_list()) { + clear_has_type(); + ::io::substrait::MaskExpression_ListSelect* temp = type_.list_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + type_.list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::MaskExpression_ListSelect& MaskExpression_Select::_internal_list() const { + return _internal_has_list() + ? *type_.list_ + : reinterpret_cast< ::io::substrait::MaskExpression_ListSelect&>(::io::substrait::_MaskExpression_ListSelect_default_instance_); +} +inline const ::io::substrait::MaskExpression_ListSelect& MaskExpression_Select::list() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.Select.list) + return _internal_list(); +} +inline ::io::substrait::MaskExpression_ListSelect* MaskExpression_Select::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.Select.list) + if (_internal_has_list()) { + clear_has_type(); + ::io::substrait::MaskExpression_ListSelect* temp = type_.list_; + type_.list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MaskExpression_Select::unsafe_arena_set_allocated_list(::io::substrait::MaskExpression_ListSelect* list) { + clear_type(); + if (list) { + set_has_list(); + type_.list_ = list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.Select.list) +} +inline ::io::substrait::MaskExpression_ListSelect* MaskExpression_Select::_internal_mutable_list() { + if (!_internal_has_list()) { + clear_type(); + set_has_list(); + type_.list_ = CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect >(GetArena()); + } + return type_.list_; +} +inline ::io::substrait::MaskExpression_ListSelect* MaskExpression_Select::mutable_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.Select.list) + return _internal_mutable_list(); +} + +// .io.substrait.MaskExpression.MapSelect map = 3; +inline bool MaskExpression_Select::_internal_has_map() const { + return type_case() == kMap; +} +inline bool MaskExpression_Select::has_map() const { + return _internal_has_map(); +} +inline void MaskExpression_Select::set_has_map() { + _oneof_case_[0] = kMap; +} +inline void MaskExpression_Select::clear_map() { + if (_internal_has_map()) { + if (GetArena() == nullptr) { + delete type_.map_; + } + clear_has_type(); + } +} +inline ::io::substrait::MaskExpression_MapSelect* MaskExpression_Select::release_map() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.Select.map) + if (_internal_has_map()) { + clear_has_type(); + ::io::substrait::MaskExpression_MapSelect* temp = type_.map_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + type_.map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::MaskExpression_MapSelect& MaskExpression_Select::_internal_map() const { + return _internal_has_map() + ? *type_.map_ + : reinterpret_cast< ::io::substrait::MaskExpression_MapSelect&>(::io::substrait::_MaskExpression_MapSelect_default_instance_); +} +inline const ::io::substrait::MaskExpression_MapSelect& MaskExpression_Select::map() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.Select.map) + return _internal_map(); +} +inline ::io::substrait::MaskExpression_MapSelect* MaskExpression_Select::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.Select.map) + if (_internal_has_map()) { + clear_has_type(); + ::io::substrait::MaskExpression_MapSelect* temp = type_.map_; + type_.map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MaskExpression_Select::unsafe_arena_set_allocated_map(::io::substrait::MaskExpression_MapSelect* map) { + clear_type(); + if (map) { + set_has_map(); + type_.map_ = map; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.Select.map) +} +inline ::io::substrait::MaskExpression_MapSelect* MaskExpression_Select::_internal_mutable_map() { + if (!_internal_has_map()) { + clear_type(); + set_has_map(); + type_.map_ = CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect >(GetArena()); + } + return type_.map_; +} +inline ::io::substrait::MaskExpression_MapSelect* MaskExpression_Select::mutable_map() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.Select.map) + return _internal_mutable_map(); +} + +inline bool MaskExpression_Select::has_type() const { + return type_case() != TYPE_NOT_SET; +} +inline void MaskExpression_Select::clear_has_type() { + _oneof_case_[0] = TYPE_NOT_SET; +} +inline MaskExpression_Select::TypeCase MaskExpression_Select::type_case() const { + return MaskExpression_Select::TypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// MaskExpression_StructSelect + +// repeated .io.substrait.MaskExpression.StructItem struct_items = 1; +inline int MaskExpression_StructSelect::_internal_struct_items_size() const { + return struct_items_.size(); +} +inline int MaskExpression_StructSelect::struct_items_size() const { + return _internal_struct_items_size(); +} +inline void MaskExpression_StructSelect::clear_struct_items() { + struct_items_.Clear(); +} +inline ::io::substrait::MaskExpression_StructItem* MaskExpression_StructSelect::mutable_struct_items(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.StructSelect.struct_items) + return struct_items_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_StructItem >* +MaskExpression_StructSelect::mutable_struct_items() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.MaskExpression.StructSelect.struct_items) + return &struct_items_; +} +inline const ::io::substrait::MaskExpression_StructItem& MaskExpression_StructSelect::_internal_struct_items(int index) const { + return struct_items_.Get(index); +} +inline const ::io::substrait::MaskExpression_StructItem& MaskExpression_StructSelect::struct_items(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.StructSelect.struct_items) + return _internal_struct_items(index); +} +inline ::io::substrait::MaskExpression_StructItem* MaskExpression_StructSelect::_internal_add_struct_items() { + return struct_items_.Add(); +} +inline ::io::substrait::MaskExpression_StructItem* MaskExpression_StructSelect::add_struct_items() { + // @@protoc_insertion_point(field_add:io.substrait.MaskExpression.StructSelect.struct_items) + return _internal_add_struct_items(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_StructItem >& +MaskExpression_StructSelect::struct_items() const { + // @@protoc_insertion_point(field_list:io.substrait.MaskExpression.StructSelect.struct_items) + return struct_items_; +} + +// ------------------------------------------------------------------- + +// MaskExpression_StructItem + +// int32 field = 1; +inline void MaskExpression_StructItem::clear_field() { + field_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_StructItem::_internal_field() const { + return field_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_StructItem::field() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.StructItem.field) + return _internal_field(); +} +inline void MaskExpression_StructItem::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + + field_ = value; +} +inline void MaskExpression_StructItem::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_field(value); + // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.StructItem.field) +} + +// .io.substrait.MaskExpression.Select child = 2; +inline bool MaskExpression_StructItem::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; +} +inline bool MaskExpression_StructItem::has_child() const { + return _internal_has_child(); +} +inline void MaskExpression_StructItem::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; +} +inline const ::io::substrait::MaskExpression_Select& MaskExpression_StructItem::_internal_child() const { + const ::io::substrait::MaskExpression_Select* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_MaskExpression_Select_default_instance_); +} +inline const ::io::substrait::MaskExpression_Select& MaskExpression_StructItem::child() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.StructItem.child) + return _internal_child(); +} +inline void MaskExpression_StructItem::unsafe_arena_set_allocated_child( + ::io::substrait::MaskExpression_Select* child) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); + } + child_ = child; + if (child) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.StructItem.child) +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_StructItem::release_child() { + + ::io::substrait::MaskExpression_Select* temp = child_; + child_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_StructItem::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.StructItem.child) + + ::io::substrait::MaskExpression_Select* temp = child_; + child_ = nullptr; + return temp; +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_StructItem::_internal_mutable_child() { + + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::MaskExpression_Select>(GetArena()); + child_ = p; + } + return child_; +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_StructItem::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.StructItem.child) + return _internal_mutable_child(); +} +inline void MaskExpression_StructItem::set_allocated_child(::io::substrait::MaskExpression_Select* child) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete child_; + } + if (child) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + if (message_arena != submessage_arena) { + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); + } + + } else { + + } + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.StructItem.child) +} + +// ------------------------------------------------------------------- + +// MaskExpression_ListSelect_ListSelectItem_ListElement + +// int32 field = 1; +inline void MaskExpression_ListSelect_ListSelectItem_ListElement::clear_field() { + field_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_field() const { + return field_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListElement::field() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement.field) + return _internal_field(); +} +inline void MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + + field_ = value; +} +inline void MaskExpression_ListSelect_ListSelectItem_ListElement::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_field(value); + // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement.field) +} + +// ------------------------------------------------------------------- + +// MaskExpression_ListSelect_ListSelectItem_ListSlice + +// int32 start = 1; +inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_start() { + start_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_start() const { + return start_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListSlice::start() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) + return _internal_start(); +} +inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { + + start_ = value; +} +inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_start(value); + // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) +} + +// int32 end = 2; +inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_end() { + end_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_end() const { + return end_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListSlice::end() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) + return _internal_end(); +} +inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { + + end_ = value; +} +inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_end(value); + // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) +} + +// ------------------------------------------------------------------- + +// MaskExpression_ListSelect_ListSelectItem + +// .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; +inline bool MaskExpression_ListSelect_ListSelectItem::_internal_has_item() const { + return type_case() == kItem; +} +inline bool MaskExpression_ListSelect_ListSelectItem::has_item() const { + return _internal_has_item(); +} +inline void MaskExpression_ListSelect_ListSelectItem::set_has_item() { + _oneof_case_[0] = kItem; +} +inline void MaskExpression_ListSelect_ListSelectItem::clear_item() { + if (_internal_has_item()) { + if (GetArena() == nullptr) { + delete type_.item_; + } + clear_has_type(); + } +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* MaskExpression_ListSelect_ListSelectItem::release_item() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) + if (_internal_has_item()) { + clear_has_type(); + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + type_.item_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& MaskExpression_ListSelect_ListSelectItem::_internal_item() const { + return _internal_has_item() + ? *type_.item_ + : reinterpret_cast< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement&>(::io::substrait::_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_); +} +inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& MaskExpression_ListSelect_ListSelectItem::item() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) + return _internal_item(); +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_item() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) + if (_internal_has_item()) { + clear_has_type(); + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; + type_.item_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_item(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* item) { + clear_type(); + if (item) { + set_has_item(); + type_.item_ = item; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* MaskExpression_ListSelect_ListSelectItem::_internal_mutable_item() { + if (!_internal_has_item()) { + clear_type(); + set_has_item(); + type_.item_ = CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement >(GetArena()); + } + return type_.item_; +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* MaskExpression_ListSelect_ListSelectItem::mutable_item() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) + return _internal_mutable_item(); +} + +// .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; +inline bool MaskExpression_ListSelect_ListSelectItem::_internal_has_slice() const { + return type_case() == kSlice; +} +inline bool MaskExpression_ListSelect_ListSelectItem::has_slice() const { + return _internal_has_slice(); +} +inline void MaskExpression_ListSelect_ListSelectItem::set_has_slice() { + _oneof_case_[0] = kSlice; +} +inline void MaskExpression_ListSelect_ListSelectItem::clear_slice() { + if (_internal_has_slice()) { + if (GetArena() == nullptr) { + delete type_.slice_; + } + clear_has_type(); + } +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* MaskExpression_ListSelect_ListSelectItem::release_slice() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) + if (_internal_has_slice()) { + clear_has_type(); + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + type_.slice_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& MaskExpression_ListSelect_ListSelectItem::_internal_slice() const { + return _internal_has_slice() + ? *type_.slice_ + : reinterpret_cast< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice&>(::io::substrait::_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_); +} +inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& MaskExpression_ListSelect_ListSelectItem::slice() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) + return _internal_slice(); +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_slice() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) + if (_internal_has_slice()) { + clear_has_type(); + ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; + type_.slice_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_slice(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { + clear_type(); + if (slice) { + set_has_slice(); + type_.slice_ = slice; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* MaskExpression_ListSelect_ListSelectItem::_internal_mutable_slice() { + if (!_internal_has_slice()) { + clear_type(); + set_has_slice(); + type_.slice_ = CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice >(GetArena()); + } + return type_.slice_; +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* MaskExpression_ListSelect_ListSelectItem::mutable_slice() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) + return _internal_mutable_slice(); +} + +inline bool MaskExpression_ListSelect_ListSelectItem::has_type() const { + return type_case() != TYPE_NOT_SET; +} +inline void MaskExpression_ListSelect_ListSelectItem::clear_has_type() { + _oneof_case_[0] = TYPE_NOT_SET; +} +inline MaskExpression_ListSelect_ListSelectItem::TypeCase MaskExpression_ListSelect_ListSelectItem::type_case() const { + return MaskExpression_ListSelect_ListSelectItem::TypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// MaskExpression_ListSelect + +// repeated .io.substrait.MaskExpression.ListSelect.ListSelectItem selection = 1; +inline int MaskExpression_ListSelect::_internal_selection_size() const { + return selection_.size(); +} +inline int MaskExpression_ListSelect::selection_size() const { + return _internal_selection_size(); +} +inline void MaskExpression_ListSelect::clear_selection() { + selection_.Clear(); +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem* MaskExpression_ListSelect::mutable_selection(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.ListSelect.selection) + return selection_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >* +MaskExpression_ListSelect::mutable_selection() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.MaskExpression.ListSelect.selection) + return &selection_; +} +inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem& MaskExpression_ListSelect::_internal_selection(int index) const { + return selection_.Get(index); +} +inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem& MaskExpression_ListSelect::selection(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.selection) + return _internal_selection(index); +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem* MaskExpression_ListSelect::_internal_add_selection() { + return selection_.Add(); +} +inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem* MaskExpression_ListSelect::add_selection() { + // @@protoc_insertion_point(field_add:io.substrait.MaskExpression.ListSelect.selection) + return _internal_add_selection(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >& +MaskExpression_ListSelect::selection() const { + // @@protoc_insertion_point(field_list:io.substrait.MaskExpression.ListSelect.selection) + return selection_; +} + +// .io.substrait.MaskExpression.Select child = 2; +inline bool MaskExpression_ListSelect::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; +} +inline bool MaskExpression_ListSelect::has_child() const { + return _internal_has_child(); +} +inline void MaskExpression_ListSelect::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; +} +inline const ::io::substrait::MaskExpression_Select& MaskExpression_ListSelect::_internal_child() const { + const ::io::substrait::MaskExpression_Select* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_MaskExpression_Select_default_instance_); +} +inline const ::io::substrait::MaskExpression_Select& MaskExpression_ListSelect::child() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.child) + return _internal_child(); +} +inline void MaskExpression_ListSelect::unsafe_arena_set_allocated_child( + ::io::substrait::MaskExpression_Select* child) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); + } + child_ = child; + if (child) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.ListSelect.child) +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_ListSelect::release_child() { + + ::io::substrait::MaskExpression_Select* temp = child_; + child_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_ListSelect::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.ListSelect.child) + + ::io::substrait::MaskExpression_Select* temp = child_; + child_ = nullptr; + return temp; +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_ListSelect::_internal_mutable_child() { + + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::MaskExpression_Select>(GetArena()); + child_ = p; + } + return child_; +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_ListSelect::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.ListSelect.child) + return _internal_mutable_child(); +} +inline void MaskExpression_ListSelect::set_allocated_child(::io::substrait::MaskExpression_Select* child) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete child_; + } + if (child) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + if (message_arena != submessage_arena) { + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); + } + + } else { + + } + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.ListSelect.child) +} + +// ------------------------------------------------------------------- + +// MaskExpression_MapSelect_MapKey + +// string map_key = 1; +inline void MaskExpression_MapSelect_MapKey::clear_map_key() { + map_key_.ClearToEmpty(); +} +inline const std::string& MaskExpression_MapSelect_MapKey::map_key() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.MapSelect.MapKey.map_key) + return _internal_map_key(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void MaskExpression_MapSelect_MapKey::set_map_key(ArgT0&& arg0, ArgT... args) { + + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.MapSelect.MapKey.map_key) +} +inline std::string* MaskExpression_MapSelect_MapKey::mutable_map_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.MapSelect.MapKey.map_key) + return _internal_mutable_map_key(); +} +inline const std::string& MaskExpression_MapSelect_MapKey::_internal_map_key() const { + return map_key_.Get(); +} +inline void MaskExpression_MapSelect_MapKey::_internal_set_map_key(const std::string& value) { + + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* MaskExpression_MapSelect_MapKey::_internal_mutable_map_key() { + + return map_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* MaskExpression_MapSelect_MapKey::release_map_key() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.MapSelect.MapKey.map_key) + return map_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void MaskExpression_MapSelect_MapKey::set_allocated_map_key(std::string* map_key) { + if (map_key != nullptr) { + + } else { + + } + map_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.MapSelect.MapKey.map_key) +} + +// ------------------------------------------------------------------- + +// MaskExpression_MapSelect_MapKeyExpression + +// string map_key_expression = 1; +inline void MaskExpression_MapSelect_MapKeyExpression::clear_map_key_expression() { + map_key_expression_.ClearToEmpty(); +} +inline const std::string& MaskExpression_MapSelect_MapKeyExpression::map_key_expression() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + return _internal_map_key_expression(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void MaskExpression_MapSelect_MapKeyExpression::set_map_key_expression(ArgT0&& arg0, ArgT... args) { + + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) +} +inline std::string* MaskExpression_MapSelect_MapKeyExpression::mutable_map_key_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + return _internal_mutable_map_key_expression(); +} +inline const std::string& MaskExpression_MapSelect_MapKeyExpression::_internal_map_key_expression() const { + return map_key_expression_.Get(); +} +inline void MaskExpression_MapSelect_MapKeyExpression::_internal_set_map_key_expression(const std::string& value) { + + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* MaskExpression_MapSelect_MapKeyExpression::_internal_mutable_map_key_expression() { + + return map_key_expression_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* MaskExpression_MapSelect_MapKeyExpression::release_map_key_expression() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + return map_key_expression_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void MaskExpression_MapSelect_MapKeyExpression::set_allocated_map_key_expression(std::string* map_key_expression) { + if (map_key_expression != nullptr) { + + } else { + + } + map_key_expression_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key_expression, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) +} + +// ------------------------------------------------------------------- + +// MaskExpression_MapSelect + +// .io.substrait.MaskExpression.MapSelect.MapKey key = 1; +inline bool MaskExpression_MapSelect::_internal_has_key() const { + return select_case() == kKey; +} +inline bool MaskExpression_MapSelect::has_key() const { + return _internal_has_key(); +} +inline void MaskExpression_MapSelect::set_has_key() { + _oneof_case_[0] = kKey; +} +inline void MaskExpression_MapSelect::clear_key() { + if (_internal_has_key()) { + if (GetArena() == nullptr) { + delete select_.key_; + } + clear_has_select(); + } +} +inline ::io::substrait::MaskExpression_MapSelect_MapKey* MaskExpression_MapSelect::release_key() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.MapSelect.key) + if (_internal_has_key()) { + clear_has_select(); + ::io::substrait::MaskExpression_MapSelect_MapKey* temp = select_.key_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + select_.key_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::MaskExpression_MapSelect_MapKey& MaskExpression_MapSelect::_internal_key() const { + return _internal_has_key() + ? *select_.key_ + : reinterpret_cast< ::io::substrait::MaskExpression_MapSelect_MapKey&>(::io::substrait::_MaskExpression_MapSelect_MapKey_default_instance_); +} +inline const ::io::substrait::MaskExpression_MapSelect_MapKey& MaskExpression_MapSelect::key() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.MapSelect.key) + return _internal_key(); +} +inline ::io::substrait::MaskExpression_MapSelect_MapKey* MaskExpression_MapSelect::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.MapSelect.key) + if (_internal_has_key()) { + clear_has_select(); + ::io::substrait::MaskExpression_MapSelect_MapKey* temp = select_.key_; + select_.key_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MaskExpression_MapSelect::unsafe_arena_set_allocated_key(::io::substrait::MaskExpression_MapSelect_MapKey* key) { + clear_select(); + if (key) { + set_has_key(); + select_.key_ = key; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.MapSelect.key) +} +inline ::io::substrait::MaskExpression_MapSelect_MapKey* MaskExpression_MapSelect::_internal_mutable_key() { + if (!_internal_has_key()) { + clear_select(); + set_has_key(); + select_.key_ = CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect_MapKey >(GetArena()); + } + return select_.key_; +} +inline ::io::substrait::MaskExpression_MapSelect_MapKey* MaskExpression_MapSelect::mutable_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.MapSelect.key) + return _internal_mutable_key(); +} + +// .io.substrait.MaskExpression.MapSelect.MapKeyExpression expression = 2; +inline bool MaskExpression_MapSelect::_internal_has_expression() const { + return select_case() == kExpression; +} +inline bool MaskExpression_MapSelect::has_expression() const { + return _internal_has_expression(); +} +inline void MaskExpression_MapSelect::set_has_expression() { + _oneof_case_[0] = kExpression; +} +inline void MaskExpression_MapSelect::clear_expression() { + if (_internal_has_expression()) { + if (GetArena() == nullptr) { + delete select_.expression_; + } + clear_has_select(); + } +} +inline ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* MaskExpression_MapSelect::release_expression() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.MapSelect.expression) + if (_internal_has_expression()) { + clear_has_select(); + ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + select_.expression_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& MaskExpression_MapSelect::_internal_expression() const { + return _internal_has_expression() + ? *select_.expression_ + : reinterpret_cast< ::io::substrait::MaskExpression_MapSelect_MapKeyExpression&>(::io::substrait::_MaskExpression_MapSelect_MapKeyExpression_default_instance_); +} +inline const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& MaskExpression_MapSelect::expression() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.MapSelect.expression) + return _internal_expression(); +} +inline ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* MaskExpression_MapSelect::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.MapSelect.expression) + if (_internal_has_expression()) { + clear_has_select(); + ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; + select_.expression_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void MaskExpression_MapSelect::unsafe_arena_set_allocated_expression(::io::substrait::MaskExpression_MapSelect_MapKeyExpression* expression) { + clear_select(); + if (expression) { + set_has_expression(); + select_.expression_ = expression; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.MapSelect.expression) +} +inline ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* MaskExpression_MapSelect::_internal_mutable_expression() { + if (!_internal_has_expression()) { + clear_select(); + set_has_expression(); + select_.expression_ = CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect_MapKeyExpression >(GetArena()); + } + return select_.expression_; +} +inline ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* MaskExpression_MapSelect::mutable_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.MapSelect.expression) + return _internal_mutable_expression(); +} + +// .io.substrait.MaskExpression.Select child = 3; +inline bool MaskExpression_MapSelect::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; +} +inline bool MaskExpression_MapSelect::has_child() const { + return _internal_has_child(); +} +inline void MaskExpression_MapSelect::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; +} +inline const ::io::substrait::MaskExpression_Select& MaskExpression_MapSelect::_internal_child() const { + const ::io::substrait::MaskExpression_Select* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_MaskExpression_Select_default_instance_); +} +inline const ::io::substrait::MaskExpression_Select& MaskExpression_MapSelect::child() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.MapSelect.child) + return _internal_child(); +} +inline void MaskExpression_MapSelect::unsafe_arena_set_allocated_child( + ::io::substrait::MaskExpression_Select* child) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); + } + child_ = child; + if (child) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.MapSelect.child) +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_MapSelect::release_child() { + + ::io::substrait::MaskExpression_Select* temp = child_; + child_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_MapSelect::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.MapSelect.child) + + ::io::substrait::MaskExpression_Select* temp = child_; + child_ = nullptr; + return temp; +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_MapSelect::_internal_mutable_child() { + + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::MaskExpression_Select>(GetArena()); + child_ = p; + } + return child_; +} +inline ::io::substrait::MaskExpression_Select* MaskExpression_MapSelect::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.MapSelect.child) + return _internal_mutable_child(); +} +inline void MaskExpression_MapSelect::set_allocated_child(::io::substrait::MaskExpression_Select* child) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete child_; + } + if (child) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + if (message_arena != submessage_arena) { + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); + } + + } else { + + } + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.MapSelect.child) +} + +inline bool MaskExpression_MapSelect::has_select() const { + return select_case() != SELECT_NOT_SET; +} +inline void MaskExpression_MapSelect::clear_has_select() { + _oneof_case_[0] = SELECT_NOT_SET; +} +inline MaskExpression_MapSelect::SelectCase MaskExpression_MapSelect::select_case() const { + return MaskExpression_MapSelect::SelectCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// MaskExpression + +// .io.substrait.MaskExpression.StructSelect select = 1; +inline bool MaskExpression::_internal_has_select() const { + return this != internal_default_instance() && select_ != nullptr; +} +inline bool MaskExpression::has_select() const { + return _internal_has_select(); +} +inline void MaskExpression::clear_select() { + if (GetArena() == nullptr && select_ != nullptr) { + delete select_; + } + select_ = nullptr; +} +inline const ::io::substrait::MaskExpression_StructSelect& MaskExpression::_internal_select() const { + const ::io::substrait::MaskExpression_StructSelect* p = select_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_MaskExpression_StructSelect_default_instance_); +} +inline const ::io::substrait::MaskExpression_StructSelect& MaskExpression::select() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.select) + return _internal_select(); +} +inline void MaskExpression::unsafe_arena_set_allocated_select( + ::io::substrait::MaskExpression_StructSelect* select) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(select_); + } + select_ = select; + if (select) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.select) +} +inline ::io::substrait::MaskExpression_StructSelect* MaskExpression::release_select() { + + ::io::substrait::MaskExpression_StructSelect* temp = select_; + select_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::MaskExpression_StructSelect* MaskExpression::unsafe_arena_release_select() { + // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.select) + + ::io::substrait::MaskExpression_StructSelect* temp = select_; + select_ = nullptr; + return temp; +} +inline ::io::substrait::MaskExpression_StructSelect* MaskExpression::_internal_mutable_select() { + + if (select_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::MaskExpression_StructSelect>(GetArena()); + select_ = p; + } + return select_; +} +inline ::io::substrait::MaskExpression_StructSelect* MaskExpression::mutable_select() { + // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.select) + return _internal_mutable_select(); +} +inline void MaskExpression::set_allocated_select(::io::substrait::MaskExpression_StructSelect* select) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete select_; + } + if (select) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(select); + if (message_arena != submessage_arena) { + select = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, select, submessage_arena); + } + + } else { + + } + select_ = select; + // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.select) +} + +// bool maintain_singular_struct = 2; +inline void MaskExpression::clear_maintain_singular_struct() { + maintain_singular_struct_ = false; +} +inline bool MaskExpression::_internal_maintain_singular_struct() const { + return maintain_singular_struct_; +} +inline bool MaskExpression::maintain_singular_struct() const { + // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.maintain_singular_struct) + return _internal_maintain_singular_struct(); +} +inline void MaskExpression::_internal_set_maintain_singular_struct(bool value) { + + maintain_singular_struct_ = value; +} +inline void MaskExpression::set_maintain_singular_struct(bool value) { + _internal_set_maintain_singular_struct(value); + // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.maintain_singular_struct) +} + +// ------------------------------------------------------------------- + +// FieldReference + +// .io.substrait.ReferenceSegment direct_reference = 1; +inline bool FieldReference::_internal_has_direct_reference() const { + return reference_type_case() == kDirectReference; +} +inline bool FieldReference::has_direct_reference() const { + return _internal_has_direct_reference(); +} +inline void FieldReference::set_has_direct_reference() { + _oneof_case_[0] = kDirectReference; +} +inline void FieldReference::clear_direct_reference() { + if (_internal_has_direct_reference()) { + if (GetArena() == nullptr) { + delete reference_type_.direct_reference_; + } + clear_has_reference_type(); + } +} +inline ::io::substrait::ReferenceSegment* FieldReference::release_direct_reference() { + // @@protoc_insertion_point(field_release:io.substrait.FieldReference.direct_reference) + if (_internal_has_direct_reference()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment* temp = reference_type_.direct_reference_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.direct_reference_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReferenceSegment& FieldReference::_internal_direct_reference() const { + return _internal_has_direct_reference() + ? *reference_type_.direct_reference_ + : reinterpret_cast< ::io::substrait::ReferenceSegment&>(::io::substrait::_ReferenceSegment_default_instance_); +} +inline const ::io::substrait::ReferenceSegment& FieldReference::direct_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.FieldReference.direct_reference) + return _internal_direct_reference(); +} +inline ::io::substrait::ReferenceSegment* FieldReference::unsafe_arena_release_direct_reference() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FieldReference.direct_reference) + if (_internal_has_direct_reference()) { + clear_has_reference_type(); + ::io::substrait::ReferenceSegment* temp = reference_type_.direct_reference_; + reference_type_.direct_reference_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FieldReference::unsafe_arena_set_allocated_direct_reference(::io::substrait::ReferenceSegment* direct_reference) { + clear_reference_type(); + if (direct_reference) { + set_has_direct_reference(); + reference_type_.direct_reference_ = direct_reference; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FieldReference.direct_reference) +} +inline ::io::substrait::ReferenceSegment* FieldReference::_internal_mutable_direct_reference() { + if (!_internal_has_direct_reference()) { + clear_reference_type(); + set_has_direct_reference(); + reference_type_.direct_reference_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment >(GetArena()); + } + return reference_type_.direct_reference_; +} +inline ::io::substrait::ReferenceSegment* FieldReference::mutable_direct_reference() { + // @@protoc_insertion_point(field_mutable:io.substrait.FieldReference.direct_reference) + return _internal_mutable_direct_reference(); +} + +// .io.substrait.MaskExpression masked_reference = 2; +inline bool FieldReference::_internal_has_masked_reference() const { + return reference_type_case() == kMaskedReference; +} +inline bool FieldReference::has_masked_reference() const { + return _internal_has_masked_reference(); +} +inline void FieldReference::set_has_masked_reference() { + _oneof_case_[0] = kMaskedReference; +} +inline void FieldReference::clear_masked_reference() { + if (_internal_has_masked_reference()) { + if (GetArena() == nullptr) { + delete reference_type_.masked_reference_; + } + clear_has_reference_type(); + } +} +inline ::io::substrait::MaskExpression* FieldReference::release_masked_reference() { + // @@protoc_insertion_point(field_release:io.substrait.FieldReference.masked_reference) + if (_internal_has_masked_reference()) { + clear_has_reference_type(); + ::io::substrait::MaskExpression* temp = reference_type_.masked_reference_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.masked_reference_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::MaskExpression& FieldReference::_internal_masked_reference() const { + return _internal_has_masked_reference() + ? *reference_type_.masked_reference_ + : reinterpret_cast< ::io::substrait::MaskExpression&>(::io::substrait::_MaskExpression_default_instance_); +} +inline const ::io::substrait::MaskExpression& FieldReference::masked_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.FieldReference.masked_reference) + return _internal_masked_reference(); +} +inline ::io::substrait::MaskExpression* FieldReference::unsafe_arena_release_masked_reference() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FieldReference.masked_reference) + if (_internal_has_masked_reference()) { + clear_has_reference_type(); + ::io::substrait::MaskExpression* temp = reference_type_.masked_reference_; + reference_type_.masked_reference_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FieldReference::unsafe_arena_set_allocated_masked_reference(::io::substrait::MaskExpression* masked_reference) { + clear_reference_type(); + if (masked_reference) { + set_has_masked_reference(); + reference_type_.masked_reference_ = masked_reference; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FieldReference.masked_reference) +} +inline ::io::substrait::MaskExpression* FieldReference::_internal_mutable_masked_reference() { + if (!_internal_has_masked_reference()) { + clear_reference_type(); + set_has_masked_reference(); + reference_type_.masked_reference_ = CreateMaybeMessage< ::io::substrait::MaskExpression >(GetArena()); + } + return reference_type_.masked_reference_; +} +inline ::io::substrait::MaskExpression* FieldReference::mutable_masked_reference() { + // @@protoc_insertion_point(field_mutable:io.substrait.FieldReference.masked_reference) + return _internal_mutable_masked_reference(); +} + +inline bool FieldReference::has_reference_type() const { + return reference_type_case() != REFERENCE_TYPE_NOT_SET; +} +inline void FieldReference::clear_has_reference_type() { + _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; +} +inline FieldReference::ReferenceTypeCase FieldReference::reference_type_case() const { + return FieldReference::ReferenceTypeCase(_oneof_case_[0]); +} +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace substrait +} // namespace io + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_selection_2eproto diff --git a/cpp/src/generated/substrait/type.pb.cc b/cpp/src/generated/substrait/type.pb.cc new file mode 100644 index 00000000000..8f487a02a85 --- /dev/null +++ b/cpp/src/generated/substrait/type.pb.cc @@ -0,0 +1,8700 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: type.proto + +#include "type.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace io { +namespace substrait { +constexpr Type_Boolean::Type_Boolean( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_BooleanDefaultTypeInternal { + constexpr Type_BooleanDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_BooleanDefaultTypeInternal() {} + union { + Type_Boolean _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_BooleanDefaultTypeInternal _Type_Boolean_default_instance_; +constexpr Type_I8::Type_I8( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_I8DefaultTypeInternal { + constexpr Type_I8DefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_I8DefaultTypeInternal() {} + union { + Type_I8 _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I8DefaultTypeInternal _Type_I8_default_instance_; +constexpr Type_I16::Type_I16( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_I16DefaultTypeInternal { + constexpr Type_I16DefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_I16DefaultTypeInternal() {} + union { + Type_I16 _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I16DefaultTypeInternal _Type_I16_default_instance_; +constexpr Type_I32::Type_I32( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_I32DefaultTypeInternal { + constexpr Type_I32DefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_I32DefaultTypeInternal() {} + union { + Type_I32 _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I32DefaultTypeInternal _Type_I32_default_instance_; +constexpr Type_I64::Type_I64( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_I64DefaultTypeInternal { + constexpr Type_I64DefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_I64DefaultTypeInternal() {} + union { + Type_I64 _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I64DefaultTypeInternal _Type_I64_default_instance_; +constexpr Type_FP32::Type_FP32( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_FP32DefaultTypeInternal { + constexpr Type_FP32DefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_FP32DefaultTypeInternal() {} + union { + Type_FP32 _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FP32DefaultTypeInternal _Type_FP32_default_instance_; +constexpr Type_FP64::Type_FP64( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_FP64DefaultTypeInternal { + constexpr Type_FP64DefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_FP64DefaultTypeInternal() {} + union { + Type_FP64 _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FP64DefaultTypeInternal _Type_FP64_default_instance_; +constexpr Type_String::Type_String( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_StringDefaultTypeInternal { + constexpr Type_StringDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_StringDefaultTypeInternal() {} + union { + Type_String _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_StringDefaultTypeInternal _Type_String_default_instance_; +constexpr Type_Binary::Type_Binary( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_BinaryDefaultTypeInternal { + constexpr Type_BinaryDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_BinaryDefaultTypeInternal() {} + union { + Type_Binary _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_BinaryDefaultTypeInternal _Type_Binary_default_instance_; +constexpr Type_Timestamp::Type_Timestamp( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_TimestampDefaultTypeInternal { + constexpr Type_TimestampDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_TimestampDefaultTypeInternal() {} + union { + Type_Timestamp _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimestampDefaultTypeInternal _Type_Timestamp_default_instance_; +constexpr Type_Date::Type_Date( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_DateDefaultTypeInternal { + constexpr Type_DateDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_DateDefaultTypeInternal() {} + union { + Type_Date _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_DateDefaultTypeInternal _Type_Date_default_instance_; +constexpr Type_Time::Type_Time( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_TimeDefaultTypeInternal { + constexpr Type_TimeDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_TimeDefaultTypeInternal() {} + union { + Type_Time _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimeDefaultTypeInternal _Type_Time_default_instance_; +constexpr Type_TimestampTZ::Type_TimestampTZ( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_TimestampTZDefaultTypeInternal { + constexpr Type_TimestampTZDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_TimestampTZDefaultTypeInternal() {} + union { + Type_TimestampTZ _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimestampTZDefaultTypeInternal _Type_TimestampTZ_default_instance_; +constexpr Type_IntervalYear::Type_IntervalYear( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_IntervalYearDefaultTypeInternal { + constexpr Type_IntervalYearDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_IntervalYearDefaultTypeInternal() {} + union { + Type_IntervalYear _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_IntervalYearDefaultTypeInternal _Type_IntervalYear_default_instance_; +constexpr Type_IntervalDay::Type_IntervalDay( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_IntervalDayDefaultTypeInternal { + constexpr Type_IntervalDayDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_IntervalDayDefaultTypeInternal() {} + union { + Type_IntervalDay _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_IntervalDayDefaultTypeInternal _Type_IntervalDay_default_instance_; +constexpr Type_UUID::Type_UUID( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , nullability_(0) +{} +struct Type_UUIDDefaultTypeInternal { + constexpr Type_UUIDDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_UUIDDefaultTypeInternal() {} + union { + Type_UUID _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_UUIDDefaultTypeInternal _Type_UUID_default_instance_; +constexpr Type_FixedChar::Type_FixedChar( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , length_(0) + , nullability_(0) +{} +struct Type_FixedCharDefaultTypeInternal { + constexpr Type_FixedCharDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_FixedCharDefaultTypeInternal() {} + union { + Type_FixedChar _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FixedCharDefaultTypeInternal _Type_FixedChar_default_instance_; +constexpr Type_VarChar::Type_VarChar( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , length_(0) + , nullability_(0) +{} +struct Type_VarCharDefaultTypeInternal { + constexpr Type_VarCharDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_VarCharDefaultTypeInternal() {} + union { + Type_VarChar _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_VarCharDefaultTypeInternal _Type_VarChar_default_instance_; +constexpr Type_FixedBinary::Type_FixedBinary( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , length_(0) + , nullability_(0) +{} +struct Type_FixedBinaryDefaultTypeInternal { + constexpr Type_FixedBinaryDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_FixedBinaryDefaultTypeInternal() {} + union { + Type_FixedBinary _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FixedBinaryDefaultTypeInternal _Type_FixedBinary_default_instance_; +constexpr Type_Decimal::Type_Decimal( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : variation_(nullptr) + , scale_(0) + , precision_(0) + , nullability_(0) +{} +struct Type_DecimalDefaultTypeInternal { + constexpr Type_DecimalDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_DecimalDefaultTypeInternal() {} + union { + Type_Decimal _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_DecimalDefaultTypeInternal _Type_Decimal_default_instance_; +constexpr Type_Struct::Type_Struct( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : types_() + , variation_(nullptr) + , nullability_(0) +{} +struct Type_StructDefaultTypeInternal { + constexpr Type_StructDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_StructDefaultTypeInternal() {} + union { + Type_Struct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_StructDefaultTypeInternal _Type_Struct_default_instance_; +constexpr Type_NamedStruct::Type_NamedStruct( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : names_() + , struct__(nullptr){} +struct Type_NamedStructDefaultTypeInternal { + constexpr Type_NamedStructDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_NamedStructDefaultTypeInternal() {} + union { + Type_NamedStruct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_NamedStructDefaultTypeInternal _Type_NamedStruct_default_instance_; +constexpr Type_List::Type_List( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : type_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct Type_ListDefaultTypeInternal { + constexpr Type_ListDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_ListDefaultTypeInternal() {} + union { + Type_List _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_ListDefaultTypeInternal _Type_List_default_instance_; +constexpr Type_Map::Type_Map( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : key_(nullptr) + , value_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct Type_MapDefaultTypeInternal { + constexpr Type_MapDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_MapDefaultTypeInternal() {} + union { + Type_Map _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_MapDefaultTypeInternal _Type_Map_default_instance_; +constexpr Type_Variation::Type_Variation( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , organization_(0){} +struct Type_VariationDefaultTypeInternal { + constexpr Type_VariationDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Type_VariationDefaultTypeInternal() {} + union { + Type_Variation _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_VariationDefaultTypeInternal _Type_Variation_default_instance_; +constexpr Type::Type( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct TypeDefaultTypeInternal { + constexpr TypeDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~TypeDefaultTypeInternal() {} + union { + Type _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TypeDefaultTypeInternal _Type_default_instance_; +} // namespace substrait +} // namespace io +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_type_2eproto[26]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_type_2eproto[1]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_type_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Boolean, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Boolean, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Boolean, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I8, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I8, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I8, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I16, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I16, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I16, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I32, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I32, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I32, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I64, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I64, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I64, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP32, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP32, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP32, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP64, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP64, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP64, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_String, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_String, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_String, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Binary, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Binary, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Binary, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Timestamp, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Timestamp, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Timestamp, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Date, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Date, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Date, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Time, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Time, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Time, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_TimestampTZ, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_TimestampTZ, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_TimestampTZ, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalYear, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalYear, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalYear, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalDay, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalDay, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalDay, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_UUID, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_UUID, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_UUID, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, length_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, length_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, length_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, scale_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, precision_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, types_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_NamedStruct, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_NamedStruct, names_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_NamedStruct, struct__), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, key_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, value_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Variation, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Variation, organization_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Variation, name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Type, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Type, kind_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::io::substrait::Type_Boolean)}, + { 7, -1, sizeof(::io::substrait::Type_I8)}, + { 14, -1, sizeof(::io::substrait::Type_I16)}, + { 21, -1, sizeof(::io::substrait::Type_I32)}, + { 28, -1, sizeof(::io::substrait::Type_I64)}, + { 35, -1, sizeof(::io::substrait::Type_FP32)}, + { 42, -1, sizeof(::io::substrait::Type_FP64)}, + { 49, -1, sizeof(::io::substrait::Type_String)}, + { 56, -1, sizeof(::io::substrait::Type_Binary)}, + { 63, -1, sizeof(::io::substrait::Type_Timestamp)}, + { 70, -1, sizeof(::io::substrait::Type_Date)}, + { 77, -1, sizeof(::io::substrait::Type_Time)}, + { 84, -1, sizeof(::io::substrait::Type_TimestampTZ)}, + { 91, -1, sizeof(::io::substrait::Type_IntervalYear)}, + { 98, -1, sizeof(::io::substrait::Type_IntervalDay)}, + { 105, -1, sizeof(::io::substrait::Type_UUID)}, + { 112, -1, sizeof(::io::substrait::Type_FixedChar)}, + { 120, -1, sizeof(::io::substrait::Type_VarChar)}, + { 128, -1, sizeof(::io::substrait::Type_FixedBinary)}, + { 136, -1, sizeof(::io::substrait::Type_Decimal)}, + { 145, -1, sizeof(::io::substrait::Type_Struct)}, + { 153, -1, sizeof(::io::substrait::Type_NamedStruct)}, + { 160, -1, sizeof(::io::substrait::Type_List)}, + { 168, -1, sizeof(::io::substrait::Type_Map)}, + { 177, -1, sizeof(::io::substrait::Type_Variation)}, + { 184, -1, sizeof(::io::substrait::Type)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_Type_Boolean_default_instance_), + reinterpret_cast(&::io::substrait::_Type_I8_default_instance_), + reinterpret_cast(&::io::substrait::_Type_I16_default_instance_), + reinterpret_cast(&::io::substrait::_Type_I32_default_instance_), + reinterpret_cast(&::io::substrait::_Type_I64_default_instance_), + reinterpret_cast(&::io::substrait::_Type_FP32_default_instance_), + reinterpret_cast(&::io::substrait::_Type_FP64_default_instance_), + reinterpret_cast(&::io::substrait::_Type_String_default_instance_), + reinterpret_cast(&::io::substrait::_Type_Binary_default_instance_), + reinterpret_cast(&::io::substrait::_Type_Timestamp_default_instance_), + reinterpret_cast(&::io::substrait::_Type_Date_default_instance_), + reinterpret_cast(&::io::substrait::_Type_Time_default_instance_), + reinterpret_cast(&::io::substrait::_Type_TimestampTZ_default_instance_), + reinterpret_cast(&::io::substrait::_Type_IntervalYear_default_instance_), + reinterpret_cast(&::io::substrait::_Type_IntervalDay_default_instance_), + reinterpret_cast(&::io::substrait::_Type_UUID_default_instance_), + reinterpret_cast(&::io::substrait::_Type_FixedChar_default_instance_), + reinterpret_cast(&::io::substrait::_Type_VarChar_default_instance_), + reinterpret_cast(&::io::substrait::_Type_FixedBinary_default_instance_), + reinterpret_cast(&::io::substrait::_Type_Decimal_default_instance_), + reinterpret_cast(&::io::substrait::_Type_Struct_default_instance_), + reinterpret_cast(&::io::substrait::_Type_NamedStruct_default_instance_), + reinterpret_cast(&::io::substrait::_Type_List_default_instance_), + reinterpret_cast(&::io::substrait::_Type_Map_default_instance_), + reinterpret_cast(&::io::substrait::_Type_Variation_default_instance_), + reinterpret_cast(&::io::substrait::_Type_default_instance_), +}; + +const char descriptor_table_protodef_type_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\ntype.proto\022\014io.substrait\032\020extensions.p" + "roto\"\360\037\n\004Type\022*\n\004bool\030\001 \001(\0132\032.io.substra" + "it.Type.BooleanH\000\022#\n\002i8\030\002 \001(\0132\025.io.subst" + "rait.Type.I8H\000\022%\n\003i16\030\003 \001(\0132\026.io.substra" + "it.Type.I16H\000\022%\n\003i32\030\005 \001(\0132\026.io.substrai" + "t.Type.I32H\000\022%\n\003i64\030\007 \001(\0132\026.io.substrait" + ".Type.I64H\000\022\'\n\004fp32\030\n \001(\0132\027.io.substrait" + ".Type.FP32H\000\022\'\n\004fp64\030\013 \001(\0132\027.io.substrai" + "t.Type.FP64H\000\022+\n\006string\030\014 \001(\0132\031.io.subst" + "rait.Type.StringH\000\022+\n\006binary\030\r \001(\0132\031.io." + "substrait.Type.BinaryH\000\0221\n\ttimestamp\030\016 \001" + "(\0132\034.io.substrait.Type.TimestampH\000\022\'\n\004da" + "te\030\020 \001(\0132\027.io.substrait.Type.DateH\000\022\'\n\004t" + "ime\030\021 \001(\0132\027.io.substrait.Type.TimeH\000\0228\n\r" + "interval_year\030\023 \001(\0132\037.io.substrait.Type." + "IntervalYearH\000\0226\n\014interval_day\030\024 \001(\0132\036.i" + "o.substrait.Type.IntervalDayH\000\0226\n\014timest" + "amp_tz\030\035 \001(\0132\036.io.substrait.Type.Timesta" + "mpTZH\000\022\'\n\004uuid\030 \001(\0132\027.io.substrait.Type" + ".UUIDH\000\0222\n\nfixed_char\030\025 \001(\0132\034.io.substra" + "it.Type.FixedCharH\000\022-\n\007varchar\030\026 \001(\0132\032.i" + "o.substrait.Type.VarCharH\000\0226\n\014fixed_bina" + "ry\030\027 \001(\0132\036.io.substrait.Type.FixedBinary" + "H\000\022-\n\007decimal\030\030 \001(\0132\032.io.substrait.Type." + "DecimalH\000\022+\n\006struct\030\031 \001(\0132\031.io.substrait" + ".Type.StructH\000\022\'\n\004list\030\033 \001(\0132\027.io.substr" + "ait.Type.ListH\000\022%\n\003map\030\034 \001(\0132\026.io.substr" + "ait.Type.MapH\000\0227\n\014user_defined\030\037 \001(\0132\037.i" + "o.substrait.Extensions.TypeIdH\000\032o\n\007Boole" + "an\022/\n\tvariation\030\001 \001(\0132\034.io.substrait.Typ" + "e.Variation\0223\n\013nullability\030\002 \001(\0162\036.io.su" + "bstrait.Type.Nullability\032j\n\002I8\022/\n\tvariat" + "ion\030\001 \001(\0132\034.io.substrait.Type.Variation\022" + "3\n\013nullability\030\002 \001(\0162\036.io.substrait.Type" + ".Nullability\032k\n\003I16\022/\n\tvariation\030\001 \001(\0132\034" + ".io.substrait.Type.Variation\0223\n\013nullabil" + "ity\030\002 \001(\0162\036.io.substrait.Type.Nullabilit" + "y\032k\n\003I32\022/\n\tvariation\030\001 \001(\0132\034.io.substra" + "it.Type.Variation\0223\n\013nullability\030\002 \001(\0162\036" + ".io.substrait.Type.Nullability\032k\n\003I64\022/\n" + "\tvariation\030\001 \001(\0132\034.io.substrait.Type.Var" + "iation\0223\n\013nullability\030\002 \001(\0162\036.io.substra" + "it.Type.Nullability\032l\n\004FP32\022/\n\tvariation" + "\030\001 \001(\0132\034.io.substrait.Type.Variation\0223\n\013" + "nullability\030\002 \001(\0162\036.io.substrait.Type.Nu" + "llability\032l\n\004FP64\022/\n\tvariation\030\001 \001(\0132\034.i" + "o.substrait.Type.Variation\0223\n\013nullabilit" + "y\030\002 \001(\0162\036.io.substrait.Type.Nullability\032" + "n\n\006String\022/\n\tvariation\030\001 \001(\0132\034.io.substr" + "ait.Type.Variation\0223\n\013nullability\030\002 \001(\0162" + "\036.io.substrait.Type.Nullability\032n\n\006Binar" + "y\022/\n\tvariation\030\001 \001(\0132\034.io.substrait.Type" + ".Variation\0223\n\013nullability\030\002 \001(\0162\036.io.sub" + "strait.Type.Nullability\032q\n\tTimestamp\022/\n\t" + "variation\030\001 \001(\0132\034.io.substrait.Type.Vari" + "ation\0223\n\013nullability\030\002 \001(\0162\036.io.substrai" + "t.Type.Nullability\032l\n\004Date\022/\n\tvariation\030" + "\001 \001(\0132\034.io.substrait.Type.Variation\0223\n\013n" + "ullability\030\002 \001(\0162\036.io.substrait.Type.Nul" + "lability\032l\n\004Time\022/\n\tvariation\030\001 \001(\0132\034.io" + ".substrait.Type.Variation\0223\n\013nullability" + "\030\002 \001(\0162\036.io.substrait.Type.Nullability\032s" + "\n\013TimestampTZ\022/\n\tvariation\030\001 \001(\0132\034.io.su" + "bstrait.Type.Variation\0223\n\013nullability\030\002 " + "\001(\0162\036.io.substrait.Type.Nullability\032t\n\014I" + "ntervalYear\022/\n\tvariation\030\001 \001(\0132\034.io.subs" + "trait.Type.Variation\0223\n\013nullability\030\002 \001(" + "\0162\036.io.substrait.Type.Nullability\032s\n\013Int" + "ervalDay\022/\n\tvariation\030\001 \001(\0132\034.io.substra" + "it.Type.Variation\0223\n\013nullability\030\002 \001(\0162\036" + ".io.substrait.Type.Nullability\032l\n\004UUID\022/" + "\n\tvariation\030\001 \001(\0132\034.io.substrait.Type.Va" + "riation\0223\n\013nullability\030\002 \001(\0162\036.io.substr" + "ait.Type.Nullability\032\201\001\n\tFixedChar\022\016\n\006le" + "ngth\030\001 \001(\005\022/\n\tvariation\030\002 \001(\0132\034.io.subst" + "rait.Type.Variation\0223\n\013nullability\030\003 \001(\016" + "2\036.io.substrait.Type.Nullability\032\177\n\007VarC" + "har\022\016\n\006length\030\001 \001(\005\022/\n\tvariation\030\002 \001(\0132\034" + ".io.substrait.Type.Variation\0223\n\013nullabil" + "ity\030\003 \001(\0162\036.io.substrait.Type.Nullabilit" + "y\032\203\001\n\013FixedBinary\022\016\n\006length\030\001 \001(\005\022/\n\tvar" + "iation\030\002 \001(\0132\034.io.substrait.Type.Variati" + "on\0223\n\013nullability\030\003 \001(\0162\036.io.substrait.T" + "ype.Nullability\032\221\001\n\007Decimal\022\r\n\005scale\030\001 \001" + "(\005\022\021\n\tprecision\030\002 \001(\005\022/\n\tvariation\030\003 \001(\013" + "2\034.io.substrait.Type.Variation\0223\n\013nullab" + "ility\030\004 \001(\0162\036.io.substrait.Type.Nullabil" + "ity\032\221\001\n\006Struct\022!\n\005types\030\001 \003(\0132\022.io.subst" + "rait.Type\022/\n\tvariation\030\002 \001(\0132\034.io.substr" + "ait.Type.Variation\0223\n\013nullability\030\003 \001(\0162" + "\036.io.substrait.Type.Nullability\032G\n\013Named" + "Struct\022\r\n\005names\030\001 \003(\t\022)\n\006struct\030\002 \001(\0132\031." + "io.substrait.Type.Struct\032\216\001\n\004List\022 \n\004typ" + "e\030\001 \001(\0132\022.io.substrait.Type\022/\n\tvariation" + "\030\002 \001(\0132\034.io.substrait.Type.Variation\0223\n\013" + "nullability\030\003 \001(\0162\036.io.substrait.Type.Nu" + "llability\032\257\001\n\003Map\022\037\n\003key\030\001 \001(\0132\022.io.subs" + "trait.Type\022!\n\005value\030\002 \001(\0132\022.io.substrait" + ".Type\022/\n\tvariation\030\003 \001(\0132\034.io.substrait." + "Type.Variation\0223\n\013nullability\030\004 \001(\0162\036.io" + ".substrait.Type.Nullability\032/\n\tVariation" + "\022\024\n\014organization\030\001 \001(\005\022\014\n\004name\030\002 \001(\t\")\n\013" + "Nullability\022\014\n\010NULLABLE\020\000\022\014\n\010REQUIRED\020\001B" + "\006\n\004kindB\027P\001\252\002\022Substrait.Protobufb\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_type_2eproto_deps[1] = { + &::descriptor_table_extensions_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_type_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_2eproto = { + false, false, 4160, descriptor_table_protodef_type_2eproto, "type.proto", + &descriptor_table_type_2eproto_once, descriptor_table_type_2eproto_deps, 1, 26, + schemas, file_default_instances, TableStruct_type_2eproto::offsets, + file_level_metadata_type_2eproto, file_level_enum_descriptors_type_2eproto, file_level_service_descriptors_type_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_type_2eproto_getter() { + return &descriptor_table_type_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_type_2eproto(&descriptor_table_type_2eproto); +namespace io { +namespace substrait { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_Nullability_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_type_2eproto); + return file_level_enum_descriptors_type_2eproto[0]; +} +bool Type_Nullability_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr Type_Nullability Type::NULLABLE; +constexpr Type_Nullability Type::REQUIRED; +constexpr Type_Nullability Type::Nullability_MIN; +constexpr Type_Nullability Type::Nullability_MAX; +constexpr int Type::Nullability_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) + +// =================================================================== + +class Type_Boolean::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_Boolean* msg); +}; + +const ::io::substrait::Type_Variation& +Type_Boolean::_Internal::variation(const Type_Boolean* msg) { + return *msg->variation_; +} +Type_Boolean::Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Boolean) +} +Type_Boolean::Type_Boolean(const Type_Boolean& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Boolean) +} + +void Type_Boolean::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_Boolean::~Type_Boolean() { + // @@protoc_insertion_point(destructor:io.substrait.Type.Boolean) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_Boolean::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_Boolean::ArenaDtor(void* object) { + Type_Boolean* _this = reinterpret_cast< Type_Boolean* >(object); + (void)_this; +} +void Type_Boolean::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_Boolean::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_Boolean::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Boolean) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_Boolean::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_Boolean::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Boolean) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Boolean) + return target; +} + +size_t Type_Boolean::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Boolean) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_Boolean::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Boolean) + GOOGLE_DCHECK_NE(&from, this); + const Type_Boolean* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Boolean) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Boolean) + MergeFrom(*source); + } +} + +void Type_Boolean::MergeFrom(const Type_Boolean& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Boolean) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_Boolean::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Boolean) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_Boolean::CopyFrom(const Type_Boolean& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Boolean) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_Boolean::IsInitialized() const { + return true; +} + +void Type_Boolean::InternalSwap(Type_Boolean* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_Boolean, nullability_) + + sizeof(Type_Boolean::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_Boolean, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_Boolean::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[0]); +} + +// =================================================================== + +class Type_I8::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_I8* msg); +}; + +const ::io::substrait::Type_Variation& +Type_I8::_Internal::variation(const Type_I8* msg) { + return *msg->variation_; +} +Type_I8::Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.I8) +} +Type_I8::Type_I8(const Type_I8& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I8) +} + +void Type_I8::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_I8::~Type_I8() { + // @@protoc_insertion_point(destructor:io.substrait.Type.I8) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_I8::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_I8::ArenaDtor(void* object) { + Type_I8* _this = reinterpret_cast< Type_I8* >(object); + (void)_this; +} +void Type_I8::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_I8::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_I8::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.I8) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_I8::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_I8::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.I8) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.I8) + return target; +} + +size_t Type_I8::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.I8) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_I8::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.I8) + GOOGLE_DCHECK_NE(&from, this); + const Type_I8* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.I8) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.I8) + MergeFrom(*source); + } +} + +void Type_I8::MergeFrom(const Type_I8& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.I8) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_I8::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.I8) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_I8::CopyFrom(const Type_I8& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.I8) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_I8::IsInitialized() const { + return true; +} + +void Type_I8::InternalSwap(Type_I8* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_I8, nullability_) + + sizeof(Type_I8::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_I8, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_I8::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[1]); +} + +// =================================================================== + +class Type_I16::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_I16* msg); +}; + +const ::io::substrait::Type_Variation& +Type_I16::_Internal::variation(const Type_I16* msg) { + return *msg->variation_; +} +Type_I16::Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.I16) +} +Type_I16::Type_I16(const Type_I16& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I16) +} + +void Type_I16::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_I16::~Type_I16() { + // @@protoc_insertion_point(destructor:io.substrait.Type.I16) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_I16::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_I16::ArenaDtor(void* object) { + Type_I16* _this = reinterpret_cast< Type_I16* >(object); + (void)_this; +} +void Type_I16::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_I16::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_I16::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.I16) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_I16::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_I16::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.I16) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.I16) + return target; +} + +size_t Type_I16::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.I16) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_I16::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.I16) + GOOGLE_DCHECK_NE(&from, this); + const Type_I16* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.I16) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.I16) + MergeFrom(*source); + } +} + +void Type_I16::MergeFrom(const Type_I16& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.I16) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_I16::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.I16) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_I16::CopyFrom(const Type_I16& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.I16) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_I16::IsInitialized() const { + return true; +} + +void Type_I16::InternalSwap(Type_I16* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_I16, nullability_) + + sizeof(Type_I16::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_I16, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_I16::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[2]); +} + +// =================================================================== + +class Type_I32::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_I32* msg); +}; + +const ::io::substrait::Type_Variation& +Type_I32::_Internal::variation(const Type_I32* msg) { + return *msg->variation_; +} +Type_I32::Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.I32) +} +Type_I32::Type_I32(const Type_I32& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I32) +} + +void Type_I32::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_I32::~Type_I32() { + // @@protoc_insertion_point(destructor:io.substrait.Type.I32) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_I32::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_I32::ArenaDtor(void* object) { + Type_I32* _this = reinterpret_cast< Type_I32* >(object); + (void)_this; +} +void Type_I32::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_I32::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_I32::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.I32) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_I32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_I32::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.I32) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.I32) + return target; +} + +size_t Type_I32::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.I32) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_I32::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.I32) + GOOGLE_DCHECK_NE(&from, this); + const Type_I32* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.I32) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.I32) + MergeFrom(*source); + } +} + +void Type_I32::MergeFrom(const Type_I32& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.I32) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_I32::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.I32) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_I32::CopyFrom(const Type_I32& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.I32) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_I32::IsInitialized() const { + return true; +} + +void Type_I32::InternalSwap(Type_I32* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_I32, nullability_) + + sizeof(Type_I32::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_I32, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_I32::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[3]); +} + +// =================================================================== + +class Type_I64::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_I64* msg); +}; + +const ::io::substrait::Type_Variation& +Type_I64::_Internal::variation(const Type_I64* msg) { + return *msg->variation_; +} +Type_I64::Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.I64) +} +Type_I64::Type_I64(const Type_I64& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I64) +} + +void Type_I64::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_I64::~Type_I64() { + // @@protoc_insertion_point(destructor:io.substrait.Type.I64) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_I64::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_I64::ArenaDtor(void* object) { + Type_I64* _this = reinterpret_cast< Type_I64* >(object); + (void)_this; +} +void Type_I64::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_I64::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_I64::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.I64) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_I64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_I64::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.I64) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.I64) + return target; +} + +size_t Type_I64::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.I64) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_I64::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.I64) + GOOGLE_DCHECK_NE(&from, this); + const Type_I64* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.I64) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.I64) + MergeFrom(*source); + } +} + +void Type_I64::MergeFrom(const Type_I64& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.I64) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_I64::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.I64) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_I64::CopyFrom(const Type_I64& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.I64) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_I64::IsInitialized() const { + return true; +} + +void Type_I64::InternalSwap(Type_I64* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_I64, nullability_) + + sizeof(Type_I64::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_I64, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_I64::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[4]); +} + +// =================================================================== + +class Type_FP32::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_FP32* msg); +}; + +const ::io::substrait::Type_Variation& +Type_FP32::_Internal::variation(const Type_FP32* msg) { + return *msg->variation_; +} +Type_FP32::Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.FP32) +} +Type_FP32::Type_FP32(const Type_FP32& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.FP32) +} + +void Type_FP32::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_FP32::~Type_FP32() { + // @@protoc_insertion_point(destructor:io.substrait.Type.FP32) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_FP32::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_FP32::ArenaDtor(void* object) { + Type_FP32* _this = reinterpret_cast< Type_FP32* >(object); + (void)_this; +} +void Type_FP32::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_FP32::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_FP32::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.FP32) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_FP32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_FP32::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.FP32) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.FP32) + return target; +} + +size_t Type_FP32::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.FP32) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_FP32::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.FP32) + GOOGLE_DCHECK_NE(&from, this); + const Type_FP32* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.FP32) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.FP32) + MergeFrom(*source); + } +} + +void Type_FP32::MergeFrom(const Type_FP32& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.FP32) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_FP32::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.FP32) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_FP32::CopyFrom(const Type_FP32& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.FP32) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_FP32::IsInitialized() const { + return true; +} + +void Type_FP32::InternalSwap(Type_FP32* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_FP32, nullability_) + + sizeof(Type_FP32::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_FP32, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_FP32::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[5]); +} + +// =================================================================== + +class Type_FP64::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_FP64* msg); +}; + +const ::io::substrait::Type_Variation& +Type_FP64::_Internal::variation(const Type_FP64* msg) { + return *msg->variation_; +} +Type_FP64::Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.FP64) +} +Type_FP64::Type_FP64(const Type_FP64& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.FP64) +} + +void Type_FP64::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_FP64::~Type_FP64() { + // @@protoc_insertion_point(destructor:io.substrait.Type.FP64) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_FP64::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_FP64::ArenaDtor(void* object) { + Type_FP64* _this = reinterpret_cast< Type_FP64* >(object); + (void)_this; +} +void Type_FP64::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_FP64::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_FP64::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.FP64) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_FP64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_FP64::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.FP64) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.FP64) + return target; +} + +size_t Type_FP64::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.FP64) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_FP64::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.FP64) + GOOGLE_DCHECK_NE(&from, this); + const Type_FP64* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.FP64) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.FP64) + MergeFrom(*source); + } +} + +void Type_FP64::MergeFrom(const Type_FP64& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.FP64) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_FP64::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.FP64) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_FP64::CopyFrom(const Type_FP64& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.FP64) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_FP64::IsInitialized() const { + return true; +} + +void Type_FP64::InternalSwap(Type_FP64* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_FP64, nullability_) + + sizeof(Type_FP64::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_FP64, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_FP64::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[6]); +} + +// =================================================================== + +class Type_String::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_String* msg); +}; + +const ::io::substrait::Type_Variation& +Type_String::_Internal::variation(const Type_String* msg) { + return *msg->variation_; +} +Type_String::Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.String) +} +Type_String::Type_String(const Type_String& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.String) +} + +void Type_String::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_String::~Type_String() { + // @@protoc_insertion_point(destructor:io.substrait.Type.String) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_String::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_String::ArenaDtor(void* object) { + Type_String* _this = reinterpret_cast< Type_String* >(object); + (void)_this; +} +void Type_String::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_String::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_String::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.String) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_String::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_String::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.String) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.String) + return target; +} + +size_t Type_String::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.String) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_String::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.String) + GOOGLE_DCHECK_NE(&from, this); + const Type_String* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.String) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.String) + MergeFrom(*source); + } +} + +void Type_String::MergeFrom(const Type_String& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.String) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_String::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.String) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_String::CopyFrom(const Type_String& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.String) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_String::IsInitialized() const { + return true; +} + +void Type_String::InternalSwap(Type_String* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_String, nullability_) + + sizeof(Type_String::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_String, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_String::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[7]); +} + +// =================================================================== + +class Type_Binary::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_Binary* msg); +}; + +const ::io::substrait::Type_Variation& +Type_Binary::_Internal::variation(const Type_Binary* msg) { + return *msg->variation_; +} +Type_Binary::Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Binary) +} +Type_Binary::Type_Binary(const Type_Binary& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Binary) +} + +void Type_Binary::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_Binary::~Type_Binary() { + // @@protoc_insertion_point(destructor:io.substrait.Type.Binary) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_Binary::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_Binary::ArenaDtor(void* object) { + Type_Binary* _this = reinterpret_cast< Type_Binary* >(object); + (void)_this; +} +void Type_Binary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_Binary::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_Binary::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Binary) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_Binary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_Binary::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Binary) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Binary) + return target; +} + +size_t Type_Binary::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Binary) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_Binary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Binary) + GOOGLE_DCHECK_NE(&from, this); + const Type_Binary* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Binary) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Binary) + MergeFrom(*source); + } +} + +void Type_Binary::MergeFrom(const Type_Binary& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Binary) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_Binary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Binary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_Binary::CopyFrom(const Type_Binary& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Binary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_Binary::IsInitialized() const { + return true; +} + +void Type_Binary::InternalSwap(Type_Binary* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_Binary, nullability_) + + sizeof(Type_Binary::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_Binary, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_Binary::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[8]); +} + +// =================================================================== + +class Type_Timestamp::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_Timestamp* msg); +}; + +const ::io::substrait::Type_Variation& +Type_Timestamp::_Internal::variation(const Type_Timestamp* msg) { + return *msg->variation_; +} +Type_Timestamp::Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Timestamp) +} +Type_Timestamp::Type_Timestamp(const Type_Timestamp& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Timestamp) +} + +void Type_Timestamp::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_Timestamp::~Type_Timestamp() { + // @@protoc_insertion_point(destructor:io.substrait.Type.Timestamp) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_Timestamp::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_Timestamp::ArenaDtor(void* object) { + Type_Timestamp* _this = reinterpret_cast< Type_Timestamp* >(object); + (void)_this; +} +void Type_Timestamp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_Timestamp::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_Timestamp::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Timestamp) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_Timestamp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_Timestamp::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Timestamp) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Timestamp) + return target; +} + +size_t Type_Timestamp::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Timestamp) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_Timestamp::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Timestamp) + GOOGLE_DCHECK_NE(&from, this); + const Type_Timestamp* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Timestamp) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Timestamp) + MergeFrom(*source); + } +} + +void Type_Timestamp::MergeFrom(const Type_Timestamp& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Timestamp) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_Timestamp::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Timestamp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_Timestamp::CopyFrom(const Type_Timestamp& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Timestamp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_Timestamp::IsInitialized() const { + return true; +} + +void Type_Timestamp::InternalSwap(Type_Timestamp* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_Timestamp, nullability_) + + sizeof(Type_Timestamp::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_Timestamp, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_Timestamp::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[9]); +} + +// =================================================================== + +class Type_Date::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_Date* msg); +}; + +const ::io::substrait::Type_Variation& +Type_Date::_Internal::variation(const Type_Date* msg) { + return *msg->variation_; +} +Type_Date::Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Date) +} +Type_Date::Type_Date(const Type_Date& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Date) +} + +void Type_Date::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_Date::~Type_Date() { + // @@protoc_insertion_point(destructor:io.substrait.Type.Date) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_Date::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_Date::ArenaDtor(void* object) { + Type_Date* _this = reinterpret_cast< Type_Date* >(object); + (void)_this; +} +void Type_Date::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_Date::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_Date::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Date) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_Date::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_Date::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Date) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Date) + return target; +} + +size_t Type_Date::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Date) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_Date::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Date) + GOOGLE_DCHECK_NE(&from, this); + const Type_Date* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Date) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Date) + MergeFrom(*source); + } +} + +void Type_Date::MergeFrom(const Type_Date& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Date) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_Date::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Date) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_Date::CopyFrom(const Type_Date& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Date) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_Date::IsInitialized() const { + return true; +} + +void Type_Date::InternalSwap(Type_Date* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_Date, nullability_) + + sizeof(Type_Date::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_Date, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_Date::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[10]); +} + +// =================================================================== + +class Type_Time::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_Time* msg); +}; + +const ::io::substrait::Type_Variation& +Type_Time::_Internal::variation(const Type_Time* msg) { + return *msg->variation_; +} +Type_Time::Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Time) +} +Type_Time::Type_Time(const Type_Time& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Time) +} + +void Type_Time::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_Time::~Type_Time() { + // @@protoc_insertion_point(destructor:io.substrait.Type.Time) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_Time::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_Time::ArenaDtor(void* object) { + Type_Time* _this = reinterpret_cast< Type_Time* >(object); + (void)_this; +} +void Type_Time::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_Time::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_Time::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Time) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_Time::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_Time::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Time) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Time) + return target; +} + +size_t Type_Time::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Time) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_Time::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Time) + GOOGLE_DCHECK_NE(&from, this); + const Type_Time* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Time) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Time) + MergeFrom(*source); + } +} + +void Type_Time::MergeFrom(const Type_Time& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Time) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_Time::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Time) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_Time::CopyFrom(const Type_Time& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Time) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_Time::IsInitialized() const { + return true; +} + +void Type_Time::InternalSwap(Type_Time* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_Time, nullability_) + + sizeof(Type_Time::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_Time, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_Time::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[11]); +} + +// =================================================================== + +class Type_TimestampTZ::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_TimestampTZ* msg); +}; + +const ::io::substrait::Type_Variation& +Type_TimestampTZ::_Internal::variation(const Type_TimestampTZ* msg) { + return *msg->variation_; +} +Type_TimestampTZ::Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.TimestampTZ) +} +Type_TimestampTZ::Type_TimestampTZ(const Type_TimestampTZ& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.TimestampTZ) +} + +void Type_TimestampTZ::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_TimestampTZ::~Type_TimestampTZ() { + // @@protoc_insertion_point(destructor:io.substrait.Type.TimestampTZ) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_TimestampTZ::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_TimestampTZ::ArenaDtor(void* object) { + Type_TimestampTZ* _this = reinterpret_cast< Type_TimestampTZ* >(object); + (void)_this; +} +void Type_TimestampTZ::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_TimestampTZ::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_TimestampTZ::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.TimestampTZ) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_TimestampTZ::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_TimestampTZ::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.TimestampTZ) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.TimestampTZ) + return target; +} + +size_t Type_TimestampTZ::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.TimestampTZ) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_TimestampTZ::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.TimestampTZ) + GOOGLE_DCHECK_NE(&from, this); + const Type_TimestampTZ* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.TimestampTZ) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.TimestampTZ) + MergeFrom(*source); + } +} + +void Type_TimestampTZ::MergeFrom(const Type_TimestampTZ& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.TimestampTZ) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_TimestampTZ::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.TimestampTZ) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_TimestampTZ::CopyFrom(const Type_TimestampTZ& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.TimestampTZ) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_TimestampTZ::IsInitialized() const { + return true; +} + +void Type_TimestampTZ::InternalSwap(Type_TimestampTZ* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_TimestampTZ, nullability_) + + sizeof(Type_TimestampTZ::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_TimestampTZ, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_TimestampTZ::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[12]); +} + +// =================================================================== + +class Type_IntervalYear::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_IntervalYear* msg); +}; + +const ::io::substrait::Type_Variation& +Type_IntervalYear::_Internal::variation(const Type_IntervalYear* msg) { + return *msg->variation_; +} +Type_IntervalYear::Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.IntervalYear) +} +Type_IntervalYear::Type_IntervalYear(const Type_IntervalYear& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.IntervalYear) +} + +void Type_IntervalYear::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_IntervalYear::~Type_IntervalYear() { + // @@protoc_insertion_point(destructor:io.substrait.Type.IntervalYear) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_IntervalYear::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_IntervalYear::ArenaDtor(void* object) { + Type_IntervalYear* _this = reinterpret_cast< Type_IntervalYear* >(object); + (void)_this; +} +void Type_IntervalYear::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_IntervalYear::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_IntervalYear::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.IntervalYear) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_IntervalYear::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalYear::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.IntervalYear) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.IntervalYear) + return target; +} + +size_t Type_IntervalYear::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.IntervalYear) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_IntervalYear::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.IntervalYear) + GOOGLE_DCHECK_NE(&from, this); + const Type_IntervalYear* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.IntervalYear) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.IntervalYear) + MergeFrom(*source); + } +} + +void Type_IntervalYear::MergeFrom(const Type_IntervalYear& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.IntervalYear) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_IntervalYear::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.IntervalYear) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_IntervalYear::CopyFrom(const Type_IntervalYear& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.IntervalYear) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_IntervalYear::IsInitialized() const { + return true; +} + +void Type_IntervalYear::InternalSwap(Type_IntervalYear* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_IntervalYear, nullability_) + + sizeof(Type_IntervalYear::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_IntervalYear, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalYear::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[13]); +} + +// =================================================================== + +class Type_IntervalDay::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_IntervalDay* msg); +}; + +const ::io::substrait::Type_Variation& +Type_IntervalDay::_Internal::variation(const Type_IntervalDay* msg) { + return *msg->variation_; +} +Type_IntervalDay::Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.IntervalDay) +} +Type_IntervalDay::Type_IntervalDay(const Type_IntervalDay& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.IntervalDay) +} + +void Type_IntervalDay::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_IntervalDay::~Type_IntervalDay() { + // @@protoc_insertion_point(destructor:io.substrait.Type.IntervalDay) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_IntervalDay::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_IntervalDay::ArenaDtor(void* object) { + Type_IntervalDay* _this = reinterpret_cast< Type_IntervalDay* >(object); + (void)_this; +} +void Type_IntervalDay::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_IntervalDay::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_IntervalDay::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.IntervalDay) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_IntervalDay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalDay::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.IntervalDay) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.IntervalDay) + return target; +} + +size_t Type_IntervalDay::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.IntervalDay) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_IntervalDay::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.IntervalDay) + GOOGLE_DCHECK_NE(&from, this); + const Type_IntervalDay* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.IntervalDay) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.IntervalDay) + MergeFrom(*source); + } +} + +void Type_IntervalDay::MergeFrom(const Type_IntervalDay& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.IntervalDay) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_IntervalDay::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.IntervalDay) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_IntervalDay::CopyFrom(const Type_IntervalDay& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.IntervalDay) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_IntervalDay::IsInitialized() const { + return true; +} + +void Type_IntervalDay::InternalSwap(Type_IntervalDay* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_IntervalDay, nullability_) + + sizeof(Type_IntervalDay::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_IntervalDay, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalDay::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[14]); +} + +// =================================================================== + +class Type_UUID::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_UUID* msg); +}; + +const ::io::substrait::Type_Variation& +Type_UUID::_Internal::variation(const Type_UUID* msg) { + return *msg->variation_; +} +Type_UUID::Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.UUID) +} +Type_UUID::Type_UUID(const Type_UUID& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.UUID) +} + +void Type_UUID::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_UUID::~Type_UUID() { + // @@protoc_insertion_point(destructor:io.substrait.Type.UUID) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_UUID::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_UUID::ArenaDtor(void* object) { + Type_UUID* _this = reinterpret_cast< Type_UUID* >(object); + (void)_this; +} +void Type_UUID::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_UUID::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_UUID::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.UUID) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_UUID::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Variation variation = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_UUID::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.UUID) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.UUID) + return target; +} + +size_t Type_UUID::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.UUID) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 1; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 2; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_UUID::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.UUID) + GOOGLE_DCHECK_NE(&from, this); + const Type_UUID* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.UUID) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.UUID) + MergeFrom(*source); + } +} + +void Type_UUID::MergeFrom(const Type_UUID& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.UUID) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_UUID::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.UUID) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_UUID::CopyFrom(const Type_UUID& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.UUID) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_UUID::IsInitialized() const { + return true; +} + +void Type_UUID::InternalSwap(Type_UUID* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_UUID, nullability_) + + sizeof(Type_UUID::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_UUID, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_UUID::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[15]); +} + +// =================================================================== + +class Type_FixedChar::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_FixedChar* msg); +}; + +const ::io::substrait::Type_Variation& +Type_FixedChar::_Internal::variation(const Type_FixedChar* msg) { + return *msg->variation_; +} +Type_FixedChar::Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.FixedChar) +} +Type_FixedChar::Type_FixedChar(const Type_FixedChar& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + ::memcpy(&length_, &from.length_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.FixedChar) +} + +void Type_FixedChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_FixedChar::~Type_FixedChar() { + // @@protoc_insertion_point(destructor:io.substrait.Type.FixedChar) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_FixedChar::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_FixedChar::ArenaDtor(void* object) { + Type_FixedChar* _this = reinterpret_cast< Type_FixedChar* >(object); + (void)_this; +} +void Type_FixedChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_FixedChar::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_FixedChar::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.FixedChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + ::memset(&length_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_FixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 length = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedChar::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.FixedChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 length = 1; + if (this->length() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.FixedChar) + return target; +} + +size_t Type_FixedChar::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.FixedChar) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // int32 length = 1; + if (this->length() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_length()); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_FixedChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.FixedChar) + GOOGLE_DCHECK_NE(&from, this); + const Type_FixedChar* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.FixedChar) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.FixedChar) + MergeFrom(*source); + } +} + +void Type_FixedChar::MergeFrom(const Type_FixedChar& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.FixedChar) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.length() != 0) { + _internal_set_length(from._internal_length()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_FixedChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.FixedChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_FixedChar::CopyFrom(const Type_FixedChar& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.FixedChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_FixedChar::IsInitialized() const { + return true; +} + +void Type_FixedChar::InternalSwap(Type_FixedChar* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_FixedChar, nullability_) + + sizeof(Type_FixedChar::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_FixedChar, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedChar::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[16]); +} + +// =================================================================== + +class Type_VarChar::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_VarChar* msg); +}; + +const ::io::substrait::Type_Variation& +Type_VarChar::_Internal::variation(const Type_VarChar* msg) { + return *msg->variation_; +} +Type_VarChar::Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.VarChar) +} +Type_VarChar::Type_VarChar(const Type_VarChar& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + ::memcpy(&length_, &from.length_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.VarChar) +} + +void Type_VarChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_VarChar::~Type_VarChar() { + // @@protoc_insertion_point(destructor:io.substrait.Type.VarChar) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_VarChar::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_VarChar::ArenaDtor(void* object) { + Type_VarChar* _this = reinterpret_cast< Type_VarChar* >(object); + (void)_this; +} +void Type_VarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_VarChar::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_VarChar::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.VarChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + ::memset(&length_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 length = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_VarChar::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.VarChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 length = 1; + if (this->length() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.VarChar) + return target; +} + +size_t Type_VarChar::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.VarChar) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // int32 length = 1; + if (this->length() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_length()); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_VarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.VarChar) + GOOGLE_DCHECK_NE(&from, this); + const Type_VarChar* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.VarChar) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.VarChar) + MergeFrom(*source); + } +} + +void Type_VarChar::MergeFrom(const Type_VarChar& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.VarChar) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.length() != 0) { + _internal_set_length(from._internal_length()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_VarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.VarChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_VarChar::CopyFrom(const Type_VarChar& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.VarChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_VarChar::IsInitialized() const { + return true; +} + +void Type_VarChar::InternalSwap(Type_VarChar* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_VarChar, nullability_) + + sizeof(Type_VarChar::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_VarChar, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_VarChar::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[17]); +} + +// =================================================================== + +class Type_FixedBinary::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_FixedBinary* msg); +}; + +const ::io::substrait::Type_Variation& +Type_FixedBinary::_Internal::variation(const Type_FixedBinary* msg) { + return *msg->variation_; +} +Type_FixedBinary::Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.FixedBinary) +} +Type_FixedBinary::Type_FixedBinary(const Type_FixedBinary& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + ::memcpy(&length_, &from.length_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.FixedBinary) +} + +void Type_FixedBinary::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_FixedBinary::~Type_FixedBinary() { + // @@protoc_insertion_point(destructor:io.substrait.Type.FixedBinary) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_FixedBinary::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_FixedBinary::ArenaDtor(void* object) { + Type_FixedBinary* _this = reinterpret_cast< Type_FixedBinary* >(object); + (void)_this; +} +void Type_FixedBinary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_FixedBinary::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_FixedBinary::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.FixedBinary) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + ::memset(&length_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_FixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 length = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedBinary::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.FixedBinary) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 length = 1; + if (this->length() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.FixedBinary) + return target; +} + +size_t Type_FixedBinary::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.FixedBinary) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // int32 length = 1; + if (this->length() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_length()); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_FixedBinary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.FixedBinary) + GOOGLE_DCHECK_NE(&from, this); + const Type_FixedBinary* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.FixedBinary) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.FixedBinary) + MergeFrom(*source); + } +} + +void Type_FixedBinary::MergeFrom(const Type_FixedBinary& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.FixedBinary) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.length() != 0) { + _internal_set_length(from._internal_length()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_FixedBinary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.FixedBinary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_FixedBinary::CopyFrom(const Type_FixedBinary& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.FixedBinary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_FixedBinary::IsInitialized() const { + return true; +} + +void Type_FixedBinary::InternalSwap(Type_FixedBinary* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_FixedBinary, nullability_) + + sizeof(Type_FixedBinary::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_FixedBinary, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedBinary::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[18]); +} + +// =================================================================== + +class Type_Decimal::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_Decimal* msg); +}; + +const ::io::substrait::Type_Variation& +Type_Decimal::_Internal::variation(const Type_Decimal* msg) { + return *msg->variation_; +} +Type_Decimal::Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Decimal) +} +Type_Decimal::Type_Decimal(const Type_Decimal& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + ::memcpy(&scale_, &from.scale_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&scale_)) + sizeof(nullability_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Decimal) +} + +void Type_Decimal::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_Decimal::~Type_Decimal() { + // @@protoc_insertion_point(destructor:io.substrait.Type.Decimal) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_Decimal::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_Decimal::ArenaDtor(void* object) { + Type_Decimal* _this = reinterpret_cast< Type_Decimal* >(object); + (void)_this; +} +void Type_Decimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_Decimal::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_Decimal::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Decimal) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + ::memset(&scale_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&scale_)) + sizeof(nullability_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 scale = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 precision = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_Decimal::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Decimal) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 scale = 1; + if (this->scale() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_scale(), target); + } + + // int32 precision = 2; + if (this->precision() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_precision(), target); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Decimal) + return target; +} + +size_t Type_Decimal::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Decimal) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // int32 scale = 1; + if (this->scale() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_scale()); + } + + // int32 precision = 2; + if (this->precision() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_precision()); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_Decimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Decimal) + GOOGLE_DCHECK_NE(&from, this); + const Type_Decimal* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Decimal) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Decimal) + MergeFrom(*source); + } +} + +void Type_Decimal::MergeFrom(const Type_Decimal& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Decimal) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.scale() != 0) { + _internal_set_scale(from._internal_scale()); + } + if (from.precision() != 0) { + _internal_set_precision(from._internal_precision()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_Decimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Decimal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_Decimal::CopyFrom(const Type_Decimal& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Decimal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_Decimal::IsInitialized() const { + return true; +} + +void Type_Decimal::InternalSwap(Type_Decimal* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_Decimal, nullability_) + + sizeof(Type_Decimal::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_Decimal, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_Decimal::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[19]); +} + +// =================================================================== + +class Type_Struct::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const Type_Struct* msg); +}; + +const ::io::substrait::Type_Variation& +Type_Struct::_Internal::variation(const Type_Struct* msg) { + return *msg->variation_; +} +Type_Struct::Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + types_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Struct) +} +Type_Struct::Type_Struct(const Type_Struct& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + types_(from.types_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Struct) +} + +void Type_Struct::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +Type_Struct::~Type_Struct() { + // @@protoc_insertion_point(destructor:io.substrait.Type.Struct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_Struct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void Type_Struct::ArenaDtor(void* object) { + Type_Struct* _this = reinterpret_cast< Type_Struct* >(object); + (void)_this; +} +void Type_Struct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_Struct::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_Struct::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Struct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + types_.Clear(); + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Type types = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_types(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_Struct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Struct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Type types = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_types_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_types(i), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Struct) + return target; +} + +size_t Type_Struct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Struct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Type types = 1; + total_size += 1UL * this->_internal_types_size(); + for (const auto& msg : this->types_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_Struct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Struct) + GOOGLE_DCHECK_NE(&from, this); + const Type_Struct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Struct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Struct) + MergeFrom(*source); + } +} + +void Type_Struct::MergeFrom(const Type_Struct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Struct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + types_.MergeFrom(from.types_); + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_Struct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Struct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_Struct::CopyFrom(const Type_Struct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Struct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_Struct::IsInitialized() const { + return true; +} + +void Type_Struct::InternalSwap(Type_Struct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + types_.InternalSwap(&other->types_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_Struct, nullability_) + + sizeof(Type_Struct::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_Struct, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_Struct::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[20]); +} + +// =================================================================== + +class Type_NamedStruct::_Internal { + public: + static const ::io::substrait::Type_Struct& struct_(const Type_NamedStruct* msg); +}; + +const ::io::substrait::Type_Struct& +Type_NamedStruct::_Internal::struct_(const Type_NamedStruct* msg) { + return *msg->struct__; +} +Type_NamedStruct::Type_NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + names_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.NamedStruct) +} +Type_NamedStruct::Type_NamedStruct(const Type_NamedStruct& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + names_(from.names_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_struct_()) { + struct__ = new ::io::substrait::Type_Struct(*from.struct__); + } else { + struct__ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.NamedStruct) +} + +void Type_NamedStruct::SharedCtor() { +struct__ = nullptr; +} + +Type_NamedStruct::~Type_NamedStruct() { + // @@protoc_insertion_point(destructor:io.substrait.Type.NamedStruct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_NamedStruct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete struct__; +} + +void Type_NamedStruct::ArenaDtor(void* object) { + Type_NamedStruct* _this = reinterpret_cast< Type_NamedStruct* >(object); + (void)_this; +} +void Type_NamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_NamedStruct::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_NamedStruct::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.NamedStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + names_.Clear(); + if (GetArena() == nullptr && struct__ != nullptr) { + delete struct__; + } + struct__ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_NamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string names = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_names(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Type.NamedStruct.names")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Struct struct = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_NamedStruct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.NamedStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string names = 1; + for (int i = 0, n = this->_internal_names_size(); i < n; i++) { + const auto& s = this->_internal_names(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Type.NamedStruct.names"); + target = stream->WriteString(1, s, target); + } + + // .io.substrait.Type.Struct struct = 2; + if (this->has_struct_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::struct_(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.NamedStruct) + return target; +} + +size_t Type_NamedStruct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.NamedStruct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string names = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); + for (int i = 0, n = names_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + names_.Get(i)); + } + + // .io.substrait.Type.Struct struct = 2; + if (this->has_struct_()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *struct__); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_NamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.NamedStruct) + GOOGLE_DCHECK_NE(&from, this); + const Type_NamedStruct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.NamedStruct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.NamedStruct) + MergeFrom(*source); + } +} + +void Type_NamedStruct::MergeFrom(const Type_NamedStruct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.NamedStruct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + names_.MergeFrom(from.names_); + if (from.has_struct_()) { + _internal_mutable_struct_()->::io::substrait::Type_Struct::MergeFrom(from._internal_struct_()); + } +} + +void Type_NamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.NamedStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_NamedStruct::CopyFrom(const Type_NamedStruct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.NamedStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_NamedStruct::IsInitialized() const { + return true; +} + +void Type_NamedStruct::InternalSwap(Type_NamedStruct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + names_.InternalSwap(&other->names_); + swap(struct__, other->struct__); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_NamedStruct::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[21]); +} + +// =================================================================== + +class Type_List::_Internal { + public: + static const ::io::substrait::Type& type(const Type_List* msg); + static const ::io::substrait::Type_Variation& variation(const Type_List* msg); +}; + +const ::io::substrait::Type& +Type_List::_Internal::type(const Type_List* msg) { + return *msg->type_; +} +const ::io::substrait::Type_Variation& +Type_List::_Internal::variation(const Type_List* msg) { + return *msg->variation_; +} +Type_List::Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.List) +} +Type_List::Type_List(const Type_List& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_type()) { + type_ = new ::io::substrait::Type(*from.type_); + } else { + type_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.List) +} + +void Type_List::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_)) + sizeof(nullability_)); +} + +Type_List::~Type_List() { + // @@protoc_insertion_point(destructor:io.substrait.Type.List) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_List::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete type_; + if (this != internal_default_instance()) delete variation_; +} + +void Type_List::ArenaDtor(void* object) { + Type_List* _this = reinterpret_cast< Type_List* >(object); + (void)_this; +} +void Type_List::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_List::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_List::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.List) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_List::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.List) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type type = 1; + if (this->has_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::type(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.List) + return target; +} + +size_t Type_List::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.List) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type type = 1; + if (this->has_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_List::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.List) + GOOGLE_DCHECK_NE(&from, this); + const Type_List* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.List) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.List) + MergeFrom(*source); + } +} + +void Type_List::MergeFrom(const Type_List& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.List) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_type()) { + _internal_mutable_type()->::io::substrait::Type::MergeFrom(from._internal_type()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_List::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.List) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_List::CopyFrom(const Type_List& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.List) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_List::IsInitialized() const { + return true; +} + +void Type_List::InternalSwap(Type_List* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_List, nullability_) + + sizeof(Type_List::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_List, type_)>( + reinterpret_cast(&type_), + reinterpret_cast(&other->type_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_List::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[22]); +} + +// =================================================================== + +class Type_Map::_Internal { + public: + static const ::io::substrait::Type& key(const Type_Map* msg); + static const ::io::substrait::Type& value(const Type_Map* msg); + static const ::io::substrait::Type_Variation& variation(const Type_Map* msg); +}; + +const ::io::substrait::Type& +Type_Map::_Internal::key(const Type_Map* msg) { + return *msg->key_; +} +const ::io::substrait::Type& +Type_Map::_Internal::value(const Type_Map* msg) { + return *msg->value_; +} +const ::io::substrait::Type_Variation& +Type_Map::_Internal::variation(const Type_Map* msg) { + return *msg->variation_; +} +Type_Map::Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Map) +} +Type_Map::Type_Map(const Type_Map& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_key()) { + key_ = new ::io::substrait::Type(*from.key_); + } else { + key_ = nullptr; + } + if (from._internal_has_value()) { + value_ = new ::io::substrait::Type(*from.value_); + } else { + value_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Map) +} + +void Type_Map::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&key_)) + sizeof(nullability_)); +} + +Type_Map::~Type_Map() { + // @@protoc_insertion_point(destructor:io.substrait.Type.Map) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_Map::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete key_; + if (this != internal_default_instance()) delete value_; + if (this != internal_default_instance()) delete variation_; +} + +void Type_Map::ArenaDtor(void* object) { + Type_Map* _this = reinterpret_cast< Type_Map* >(object); + (void)_this; +} +void Type_Map::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_Map::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_Map::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Map) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && key_ != nullptr) { + delete key_; + } + key_ = nullptr; + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_Map::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Map) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type key = 1; + if (this->has_key()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::key(this), target, stream); + } + + // .io.substrait.Type value = 2; + if (this->has_value()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::value(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Map) + return target; +} + +size_t Type_Map::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Map) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Type key = 1; + if (this->has_key()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *key_); + } + + // .io.substrait.Type value = 2; + if (this->has_value()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_Map::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Map) + GOOGLE_DCHECK_NE(&from, this); + const Type_Map* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Map) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Map) + MergeFrom(*source); + } +} + +void Type_Map::MergeFrom(const Type_Map& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Map) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_key()) { + _internal_mutable_key()->::io::substrait::Type::MergeFrom(from._internal_key()); + } + if (from.has_value()) { + _internal_mutable_value()->::io::substrait::Type::MergeFrom(from._internal_value()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void Type_Map::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Map) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_Map::CopyFrom(const Type_Map& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Map) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_Map::IsInitialized() const { + return true; +} + +void Type_Map::InternalSwap(Type_Map* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_Map, nullability_) + + sizeof(Type_Map::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_Map, key_)>( + reinterpret_cast(&key_), + reinterpret_cast(&other->key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_Map::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[23]); +} + +// =================================================================== + +class Type_Variation::_Internal { + public: +}; + +Type_Variation::Type_Variation(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Variation) +} +Type_Variation::Type_Variation(const Type_Variation& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); + } + organization_ = from.organization_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Variation) +} + +void Type_Variation::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +organization_ = 0; +} + +Type_Variation::~Type_Variation() { + // @@protoc_insertion_point(destructor:io.substrait.Type.Variation) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type_Variation::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Type_Variation::ArenaDtor(void* object) { + Type_Variation* _this = reinterpret_cast< Type_Variation* >(object); + (void)_this; +} +void Type_Variation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type_Variation::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type_Variation::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Variation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmpty(); + organization_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type_Variation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 organization = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + organization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Type.Variation.name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type_Variation::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Variation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 organization = 1; + if (this->organization() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_organization(), target); + } + + // string name = 2; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Type.Variation.name"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Variation) + return target; +} + +size_t Type_Variation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Variation) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 2; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // int32 organization = 1; + if (this->organization() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_organization()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type_Variation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Variation) + GOOGLE_DCHECK_NE(&from, this); + const Type_Variation* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Variation) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Variation) + MergeFrom(*source); + } +} + +void Type_Variation::MergeFrom(const Type_Variation& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Variation) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } + if (from.organization() != 0) { + _internal_set_organization(from._internal_organization()); + } +} + +void Type_Variation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Variation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type_Variation::CopyFrom(const Type_Variation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Variation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type_Variation::IsInitialized() const { + return true; +} + +void Type_Variation::InternalSwap(Type_Variation* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(organization_, other->organization_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type_Variation::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[24]); +} + +// =================================================================== + +class Type::_Internal { + public: + static const ::io::substrait::Type_Boolean& bool_(const Type* msg); + static const ::io::substrait::Type_I8& i8(const Type* msg); + static const ::io::substrait::Type_I16& i16(const Type* msg); + static const ::io::substrait::Type_I32& i32(const Type* msg); + static const ::io::substrait::Type_I64& i64(const Type* msg); + static const ::io::substrait::Type_FP32& fp32(const Type* msg); + static const ::io::substrait::Type_FP64& fp64(const Type* msg); + static const ::io::substrait::Type_String& string(const Type* msg); + static const ::io::substrait::Type_Binary& binary(const Type* msg); + static const ::io::substrait::Type_Timestamp& timestamp(const Type* msg); + static const ::io::substrait::Type_Date& date(const Type* msg); + static const ::io::substrait::Type_Time& time(const Type* msg); + static const ::io::substrait::Type_IntervalYear& interval_year(const Type* msg); + static const ::io::substrait::Type_IntervalDay& interval_day(const Type* msg); + static const ::io::substrait::Type_TimestampTZ& timestamp_tz(const Type* msg); + static const ::io::substrait::Type_UUID& uuid(const Type* msg); + static const ::io::substrait::Type_FixedChar& fixed_char(const Type* msg); + static const ::io::substrait::Type_VarChar& varchar(const Type* msg); + static const ::io::substrait::Type_FixedBinary& fixed_binary(const Type* msg); + static const ::io::substrait::Type_Decimal& decimal(const Type* msg); + static const ::io::substrait::Type_Struct& struct_(const Type* msg); + static const ::io::substrait::Type_List& list(const Type* msg); + static const ::io::substrait::Type_Map& map(const Type* msg); + static const ::io::substrait::Extensions_TypeId& user_defined(const Type* msg); +}; + +const ::io::substrait::Type_Boolean& +Type::_Internal::bool_(const Type* msg) { + return *msg->kind_.bool__; +} +const ::io::substrait::Type_I8& +Type::_Internal::i8(const Type* msg) { + return *msg->kind_.i8_; +} +const ::io::substrait::Type_I16& +Type::_Internal::i16(const Type* msg) { + return *msg->kind_.i16_; +} +const ::io::substrait::Type_I32& +Type::_Internal::i32(const Type* msg) { + return *msg->kind_.i32_; +} +const ::io::substrait::Type_I64& +Type::_Internal::i64(const Type* msg) { + return *msg->kind_.i64_; +} +const ::io::substrait::Type_FP32& +Type::_Internal::fp32(const Type* msg) { + return *msg->kind_.fp32_; +} +const ::io::substrait::Type_FP64& +Type::_Internal::fp64(const Type* msg) { + return *msg->kind_.fp64_; +} +const ::io::substrait::Type_String& +Type::_Internal::string(const Type* msg) { + return *msg->kind_.string_; +} +const ::io::substrait::Type_Binary& +Type::_Internal::binary(const Type* msg) { + return *msg->kind_.binary_; +} +const ::io::substrait::Type_Timestamp& +Type::_Internal::timestamp(const Type* msg) { + return *msg->kind_.timestamp_; +} +const ::io::substrait::Type_Date& +Type::_Internal::date(const Type* msg) { + return *msg->kind_.date_; +} +const ::io::substrait::Type_Time& +Type::_Internal::time(const Type* msg) { + return *msg->kind_.time_; +} +const ::io::substrait::Type_IntervalYear& +Type::_Internal::interval_year(const Type* msg) { + return *msg->kind_.interval_year_; +} +const ::io::substrait::Type_IntervalDay& +Type::_Internal::interval_day(const Type* msg) { + return *msg->kind_.interval_day_; +} +const ::io::substrait::Type_TimestampTZ& +Type::_Internal::timestamp_tz(const Type* msg) { + return *msg->kind_.timestamp_tz_; +} +const ::io::substrait::Type_UUID& +Type::_Internal::uuid(const Type* msg) { + return *msg->kind_.uuid_; +} +const ::io::substrait::Type_FixedChar& +Type::_Internal::fixed_char(const Type* msg) { + return *msg->kind_.fixed_char_; +} +const ::io::substrait::Type_VarChar& +Type::_Internal::varchar(const Type* msg) { + return *msg->kind_.varchar_; +} +const ::io::substrait::Type_FixedBinary& +Type::_Internal::fixed_binary(const Type* msg) { + return *msg->kind_.fixed_binary_; +} +const ::io::substrait::Type_Decimal& +Type::_Internal::decimal(const Type* msg) { + return *msg->kind_.decimal_; +} +const ::io::substrait::Type_Struct& +Type::_Internal::struct_(const Type* msg) { + return *msg->kind_.struct__; +} +const ::io::substrait::Type_List& +Type::_Internal::list(const Type* msg) { + return *msg->kind_.list_; +} +const ::io::substrait::Type_Map& +Type::_Internal::map(const Type* msg) { + return *msg->kind_.map_; +} +const ::io::substrait::Extensions_TypeId& +Type::_Internal::user_defined(const Type* msg) { + return *msg->kind_.user_defined_; +} +void Type::set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (bool_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(bool_); + if (message_arena != submessage_arena) { + bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bool_, submessage_arena); + } + set_has_bool_(); + kind_.bool__ = bool_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.bool) +} +void Type::set_allocated_i8(::io::substrait::Type_I8* i8) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i8) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(i8); + if (message_arena != submessage_arena) { + i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i8, submessage_arena); + } + set_has_i8(); + kind_.i8_ = i8; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.i8) +} +void Type::set_allocated_i16(::io::substrait::Type_I16* i16) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i16) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(i16); + if (message_arena != submessage_arena) { + i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i16, submessage_arena); + } + set_has_i16(); + kind_.i16_ = i16; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.i16) +} +void Type::set_allocated_i32(::io::substrait::Type_I32* i32) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i32) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(i32); + if (message_arena != submessage_arena) { + i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i32, submessage_arena); + } + set_has_i32(); + kind_.i32_ = i32; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.i32) +} +void Type::set_allocated_i64(::io::substrait::Type_I64* i64) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i64) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(i64); + if (message_arena != submessage_arena) { + i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i64, submessage_arena); + } + set_has_i64(); + kind_.i64_ = i64; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.i64) +} +void Type::set_allocated_fp32(::io::substrait::Type_FP32* fp32) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fp32) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fp32); + if (message_arena != submessage_arena) { + fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fp32, submessage_arena); + } + set_has_fp32(); + kind_.fp32_ = fp32; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.fp32) +} +void Type::set_allocated_fp64(::io::substrait::Type_FP64* fp64) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fp64) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fp64); + if (message_arena != submessage_arena) { + fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fp64, submessage_arena); + } + set_has_fp64(); + kind_.fp64_ = fp64; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.fp64) +} +void Type::set_allocated_string(::io::substrait::Type_String* string) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (string) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(string); + if (message_arena != submessage_arena) { + string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, string, submessage_arena); + } + set_has_string(); + kind_.string_ = string; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.string) +} +void Type::set_allocated_binary(::io::substrait::Type_Binary* binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(binary); + if (message_arena != submessage_arena) { + binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, binary, submessage_arena); + } + set_has_binary(); + kind_.binary_ = binary; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.binary) +} +void Type::set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (timestamp) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(timestamp); + if (message_arena != submessage_arena) { + timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, timestamp, submessage_arena); + } + set_has_timestamp(); + kind_.timestamp_ = timestamp; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.timestamp) +} +void Type::set_allocated_date(::io::substrait::Type_Date* date) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (date) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(date); + if (message_arena != submessage_arena) { + date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, date, submessage_arena); + } + set_has_date(); + kind_.date_ = date; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.date) +} +void Type::set_allocated_time(::io::substrait::Type_Time* time) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (time) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(time); + if (message_arena != submessage_arena) { + time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, time, submessage_arena); + } + set_has_time(); + kind_.time_ = time; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.time) +} +void Type::set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (interval_year) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_year); + if (message_arena != submessage_arena) { + interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interval_year, submessage_arena); + } + set_has_interval_year(); + kind_.interval_year_ = interval_year; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.interval_year) +} +void Type::set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (interval_day) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_day); + if (message_arena != submessage_arena) { + interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interval_day, submessage_arena); + } + set_has_interval_day(); + kind_.interval_day_ = interval_day; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.interval_day) +} +void Type::set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (timestamp_tz) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(timestamp_tz); + if (message_arena != submessage_arena) { + timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, timestamp_tz, submessage_arena); + } + set_has_timestamp_tz(); + kind_.timestamp_tz_ = timestamp_tz; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.timestamp_tz) +} +void Type::set_allocated_uuid(::io::substrait::Type_UUID* uuid) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (uuid) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(uuid); + if (message_arena != submessage_arena) { + uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, uuid, submessage_arena); + } + set_has_uuid(); + kind_.uuid_ = uuid; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.uuid) +} +void Type::set_allocated_fixed_char(::io::substrait::Type_FixedChar* fixed_char) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fixed_char) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_char); + if (message_arena != submessage_arena) { + fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fixed_char, submessage_arena); + } + set_has_fixed_char(); + kind_.fixed_char_ = fixed_char; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.fixed_char) +} +void Type::set_allocated_varchar(::io::substrait::Type_VarChar* varchar) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (varchar) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(varchar); + if (message_arena != submessage_arena) { + varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, varchar, submessage_arena); + } + set_has_varchar(); + kind_.varchar_ = varchar; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.varchar) +} +void Type::set_allocated_fixed_binary(::io::substrait::Type_FixedBinary* fixed_binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fixed_binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_binary); + if (message_arena != submessage_arena) { + fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fixed_binary, submessage_arena); + } + set_has_fixed_binary(); + kind_.fixed_binary_ = fixed_binary; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.fixed_binary) +} +void Type::set_allocated_decimal(::io::substrait::Type_Decimal* decimal) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (decimal) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(decimal); + if (message_arena != submessage_arena) { + decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, decimal, submessage_arena); + } + set_has_decimal(); + kind_.decimal_ = decimal; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.decimal) +} +void Type::set_allocated_struct_(::io::substrait::Type_Struct* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + set_has_struct_(); + kind_.struct__ = struct_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.struct) +} +void Type::set_allocated_list(::io::substrait::Type_List* list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + if (message_arena != submessage_arena) { + list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, list, submessage_arena); + } + set_has_list(); + kind_.list_ = list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.list) +} +void Type::set_allocated_map(::io::substrait::Type_Map* map) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (map) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + if (message_arena != submessage_arena) { + map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map, submessage_arena); + } + set_has_map(); + kind_.map_ = map; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.map) +} +void Type::set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (user_defined) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(user_defined)->GetArena(); + if (message_arena != submessage_arena) { + user_defined = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, user_defined, submessage_arena); + } + set_has_user_defined(); + kind_.user_defined_ = user_defined; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.user_defined) +} +void Type::clear_user_defined() { + if (_internal_has_user_defined()) { + if (GetArena() == nullptr) { + delete kind_.user_defined_; + } + clear_has_kind(); + } +} +Type::Type(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Type) +} +Type::Type(const Type& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_kind(); + switch (from.kind_case()) { + case kBool: { + _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + break; + } + case kI8: { + _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + break; + } + case kI16: { + _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + break; + } + case kI32: { + _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + break; + } + case kI64: { + _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + break; + } + case kFp32: { + _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + break; + } + case kFp64: { + _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + break; + } + case kString: { + _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + break; + } + case kBinary: { + _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + break; + } + case kTimestamp: { + _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + break; + } + case kDate: { + _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + break; + } + case kTime: { + _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + break; + } + case kIntervalYear: { + _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + break; + } + case kIntervalDay: { + _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + break; + } + case kTimestampTz: { + _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + break; + } + case kUuid: { + _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + break; + } + case kFixedChar: { + _internal_mutable_fixed_char()->::io::substrait::Type_FixedChar::MergeFrom(from._internal_fixed_char()); + break; + } + case kVarchar: { + _internal_mutable_varchar()->::io::substrait::Type_VarChar::MergeFrom(from._internal_varchar()); + break; + } + case kFixedBinary: { + _internal_mutable_fixed_binary()->::io::substrait::Type_FixedBinary::MergeFrom(from._internal_fixed_binary()); + break; + } + case kDecimal: { + _internal_mutable_decimal()->::io::substrait::Type_Decimal::MergeFrom(from._internal_decimal()); + break; + } + case kStruct: { + _internal_mutable_struct_()->::io::substrait::Type_Struct::MergeFrom(from._internal_struct_()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::Type_List::MergeFrom(from._internal_list()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::Type_Map::MergeFrom(from._internal_map()); + break; + } + case kUserDefined: { + _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + break; + } + case KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Type) +} + +void Type::SharedCtor() { +clear_has_kind(); +} + +Type::~Type() { + // @@protoc_insertion_point(destructor:io.substrait.Type) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Type::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_kind()) { + clear_kind(); + } +} + +void Type::ArenaDtor(void* object) { + Type* _this = reinterpret_cast< Type* >(object); + (void)_this; +} +void Type::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Type::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Type::clear_kind() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Type) + switch (kind_case()) { + case kBool: { + if (GetArena() == nullptr) { + delete kind_.bool__; + } + break; + } + case kI8: { + if (GetArena() == nullptr) { + delete kind_.i8_; + } + break; + } + case kI16: { + if (GetArena() == nullptr) { + delete kind_.i16_; + } + break; + } + case kI32: { + if (GetArena() == nullptr) { + delete kind_.i32_; + } + break; + } + case kI64: { + if (GetArena() == nullptr) { + delete kind_.i64_; + } + break; + } + case kFp32: { + if (GetArena() == nullptr) { + delete kind_.fp32_; + } + break; + } + case kFp64: { + if (GetArena() == nullptr) { + delete kind_.fp64_; + } + break; + } + case kString: { + if (GetArena() == nullptr) { + delete kind_.string_; + } + break; + } + case kBinary: { + if (GetArena() == nullptr) { + delete kind_.binary_; + } + break; + } + case kTimestamp: { + if (GetArena() == nullptr) { + delete kind_.timestamp_; + } + break; + } + case kDate: { + if (GetArena() == nullptr) { + delete kind_.date_; + } + break; + } + case kTime: { + if (GetArena() == nullptr) { + delete kind_.time_; + } + break; + } + case kIntervalYear: { + if (GetArena() == nullptr) { + delete kind_.interval_year_; + } + break; + } + case kIntervalDay: { + if (GetArena() == nullptr) { + delete kind_.interval_day_; + } + break; + } + case kTimestampTz: { + if (GetArena() == nullptr) { + delete kind_.timestamp_tz_; + } + break; + } + case kUuid: { + if (GetArena() == nullptr) { + delete kind_.uuid_; + } + break; + } + case kFixedChar: { + if (GetArena() == nullptr) { + delete kind_.fixed_char_; + } + break; + } + case kVarchar: { + if (GetArena() == nullptr) { + delete kind_.varchar_; + } + break; + } + case kFixedBinary: { + if (GetArena() == nullptr) { + delete kind_.fixed_binary_; + } + break; + } + case kDecimal: { + if (GetArena() == nullptr) { + delete kind_.decimal_; + } + break; + } + case kStruct: { + if (GetArena() == nullptr) { + delete kind_.struct__; + } + break; + } + case kList: { + if (GetArena() == nullptr) { + delete kind_.list_; + } + break; + } + case kMap: { + if (GetArena() == nullptr) { + delete kind_.map_; + } + break; + } + case kUserDefined: { + if (GetArena() == nullptr) { + delete kind_.user_defined_; + } + break; + } + case KIND_NOT_SET: { + break; + } + } + _oneof_case_[0] = KIND_NOT_SET; +} + + +void Type::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Type) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_kind(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Type::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Boolean bool = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I8 i8 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I16 i16 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I32 i32 = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I64 i64 = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.FP32 fp32 = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.FP64 fp64 = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.String string = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Binary binary = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Timestamp timestamp = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Date date = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Time time = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.IntervalYear interval_year = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.IntervalDay interval_day = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { + ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.FixedChar fixed_char = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { + ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.VarChar varchar = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.FixedBinary fixed_binary = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Decimal decimal = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Struct struct = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.List list = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) { + ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Map map = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { + ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { + ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Extensions.TypeId user_defined = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) { + ptr = ctx->ParseMessage(_internal_mutable_user_defined(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.UUID uuid = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { + ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Boolean bool = 1; + if (_internal_has_bool_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::bool_(this), target, stream); + } + + // .io.substrait.Type.I8 i8 = 2; + if (_internal_has_i8()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::i8(this), target, stream); + } + + // .io.substrait.Type.I16 i16 = 3; + if (_internal_has_i16()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::i16(this), target, stream); + } + + // .io.substrait.Type.I32 i32 = 5; + if (_internal_has_i32()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::i32(this), target, stream); + } + + // .io.substrait.Type.I64 i64 = 7; + if (_internal_has_i64()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::i64(this), target, stream); + } + + // .io.substrait.Type.FP32 fp32 = 10; + if (_internal_has_fp32()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::fp32(this), target, stream); + } + + // .io.substrait.Type.FP64 fp64 = 11; + if (_internal_has_fp64()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::fp64(this), target, stream); + } + + // .io.substrait.Type.String string = 12; + if (_internal_has_string()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 12, _Internal::string(this), target, stream); + } + + // .io.substrait.Type.Binary binary = 13; + if (_internal_has_binary()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 13, _Internal::binary(this), target, stream); + } + + // .io.substrait.Type.Timestamp timestamp = 14; + if (_internal_has_timestamp()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 14, _Internal::timestamp(this), target, stream); + } + + // .io.substrait.Type.Date date = 16; + if (_internal_has_date()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 16, _Internal::date(this), target, stream); + } + + // .io.substrait.Type.Time time = 17; + if (_internal_has_time()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 17, _Internal::time(this), target, stream); + } + + // .io.substrait.Type.IntervalYear interval_year = 19; + if (_internal_has_interval_year()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 19, _Internal::interval_year(this), target, stream); + } + + // .io.substrait.Type.IntervalDay interval_day = 20; + if (_internal_has_interval_day()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 20, _Internal::interval_day(this), target, stream); + } + + // .io.substrait.Type.FixedChar fixed_char = 21; + if (_internal_has_fixed_char()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 21, _Internal::fixed_char(this), target, stream); + } + + // .io.substrait.Type.VarChar varchar = 22; + if (_internal_has_varchar()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 22, _Internal::varchar(this), target, stream); + } + + // .io.substrait.Type.FixedBinary fixed_binary = 23; + if (_internal_has_fixed_binary()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 23, _Internal::fixed_binary(this), target, stream); + } + + // .io.substrait.Type.Decimal decimal = 24; + if (_internal_has_decimal()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 24, _Internal::decimal(this), target, stream); + } + + // .io.substrait.Type.Struct struct = 25; + if (_internal_has_struct_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 25, _Internal::struct_(this), target, stream); + } + + // .io.substrait.Type.List list = 27; + if (_internal_has_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 27, _Internal::list(this), target, stream); + } + + // .io.substrait.Type.Map map = 28; + if (_internal_has_map()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 28, _Internal::map(this), target, stream); + } + + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + if (_internal_has_timestamp_tz()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 29, _Internal::timestamp_tz(this), target, stream); + } + + // .io.substrait.Extensions.TypeId user_defined = 31; + if (_internal_has_user_defined()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 31, _Internal::user_defined(this), target, stream); + } + + // .io.substrait.Type.UUID uuid = 32; + if (_internal_has_uuid()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 32, _Internal::uuid(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type) + return target; +} + +size_t Type::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (kind_case()) { + // .io.substrait.Type.Boolean bool = 1; + case kBool: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.bool__); + break; + } + // .io.substrait.Type.I8 i8 = 2; + case kI8: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i8_); + break; + } + // .io.substrait.Type.I16 i16 = 3; + case kI16: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i16_); + break; + } + // .io.substrait.Type.I32 i32 = 5; + case kI32: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i32_); + break; + } + // .io.substrait.Type.I64 i64 = 7; + case kI64: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i64_); + break; + } + // .io.substrait.Type.FP32 fp32 = 10; + case kFp32: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fp32_); + break; + } + // .io.substrait.Type.FP64 fp64 = 11; + case kFp64: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fp64_); + break; + } + // .io.substrait.Type.String string = 12; + case kString: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.string_); + break; + } + // .io.substrait.Type.Binary binary = 13; + case kBinary: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.binary_); + break; + } + // .io.substrait.Type.Timestamp timestamp = 14; + case kTimestamp: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.timestamp_); + break; + } + // .io.substrait.Type.Date date = 16; + case kDate: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.date_); + break; + } + // .io.substrait.Type.Time time = 17; + case kTime: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.time_); + break; + } + // .io.substrait.Type.IntervalYear interval_year = 19; + case kIntervalYear: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.interval_year_); + break; + } + // .io.substrait.Type.IntervalDay interval_day = 20; + case kIntervalDay: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.interval_day_); + break; + } + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + case kTimestampTz: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.timestamp_tz_); + break; + } + // .io.substrait.Type.UUID uuid = 32; + case kUuid: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.uuid_); + break; + } + // .io.substrait.Type.FixedChar fixed_char = 21; + case kFixedChar: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fixed_char_); + break; + } + // .io.substrait.Type.VarChar varchar = 22; + case kVarchar: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.varchar_); + break; + } + // .io.substrait.Type.FixedBinary fixed_binary = 23; + case kFixedBinary: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fixed_binary_); + break; + } + // .io.substrait.Type.Decimal decimal = 24; + case kDecimal: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.decimal_); + break; + } + // .io.substrait.Type.Struct struct = 25; + case kStruct: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.struct__); + break; + } + // .io.substrait.Type.List list = 27; + case kList: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.list_); + break; + } + // .io.substrait.Type.Map map = 28; + case kMap: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.map_); + break; + } + // .io.substrait.Extensions.TypeId user_defined = 31; + case kUserDefined: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.user_defined_); + break; + } + case KIND_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Type::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type) + GOOGLE_DCHECK_NE(&from, this); + const Type* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type) + MergeFrom(*source); + } +} + +void Type::MergeFrom(const Type& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.kind_case()) { + case kBool: { + _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + break; + } + case kI8: { + _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + break; + } + case kI16: { + _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + break; + } + case kI32: { + _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + break; + } + case kI64: { + _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + break; + } + case kFp32: { + _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + break; + } + case kFp64: { + _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + break; + } + case kString: { + _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + break; + } + case kBinary: { + _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + break; + } + case kTimestamp: { + _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + break; + } + case kDate: { + _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + break; + } + case kTime: { + _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + break; + } + case kIntervalYear: { + _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + break; + } + case kIntervalDay: { + _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + break; + } + case kTimestampTz: { + _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + break; + } + case kUuid: { + _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + break; + } + case kFixedChar: { + _internal_mutable_fixed_char()->::io::substrait::Type_FixedChar::MergeFrom(from._internal_fixed_char()); + break; + } + case kVarchar: { + _internal_mutable_varchar()->::io::substrait::Type_VarChar::MergeFrom(from._internal_varchar()); + break; + } + case kFixedBinary: { + _internal_mutable_fixed_binary()->::io::substrait::Type_FixedBinary::MergeFrom(from._internal_fixed_binary()); + break; + } + case kDecimal: { + _internal_mutable_decimal()->::io::substrait::Type_Decimal::MergeFrom(from._internal_decimal()); + break; + } + case kStruct: { + _internal_mutable_struct_()->::io::substrait::Type_Struct::MergeFrom(from._internal_struct_()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::Type_List::MergeFrom(from._internal_list()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::Type_Map::MergeFrom(from._internal_map()); + break; + } + case kUserDefined: { + _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + break; + } + case KIND_NOT_SET: { + break; + } + } +} + +void Type::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Type::CopyFrom(const Type& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Type::IsInitialized() const { + return true; +} + +void Type::InternalSwap(Type* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(kind_, other->kind_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Type::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[25]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::Type_Boolean* Arena::CreateMaybeMessage< ::io::substrait::Type_Boolean >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_Boolean >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_I8* Arena::CreateMaybeMessage< ::io::substrait::Type_I8 >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_I8 >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_I16* Arena::CreateMaybeMessage< ::io::substrait::Type_I16 >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_I16 >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_I32* Arena::CreateMaybeMessage< ::io::substrait::Type_I32 >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_I32 >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_I64* Arena::CreateMaybeMessage< ::io::substrait::Type_I64 >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_I64 >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_FP32* Arena::CreateMaybeMessage< ::io::substrait::Type_FP32 >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_FP32 >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_FP64* Arena::CreateMaybeMessage< ::io::substrait::Type_FP64 >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_FP64 >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_String* Arena::CreateMaybeMessage< ::io::substrait::Type_String >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_String >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_Binary* Arena::CreateMaybeMessage< ::io::substrait::Type_Binary >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_Binary >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_Timestamp* Arena::CreateMaybeMessage< ::io::substrait::Type_Timestamp >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_Timestamp >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_Date* Arena::CreateMaybeMessage< ::io::substrait::Type_Date >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_Date >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_Time* Arena::CreateMaybeMessage< ::io::substrait::Type_Time >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_Time >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage< ::io::substrait::Type_TimestampTZ >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_TimestampTZ >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_IntervalYear* Arena::CreateMaybeMessage< ::io::substrait::Type_IntervalYear >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_IntervalYear >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_IntervalDay* Arena::CreateMaybeMessage< ::io::substrait::Type_IntervalDay >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_IntervalDay >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_UUID* Arena::CreateMaybeMessage< ::io::substrait::Type_UUID >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_UUID >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_FixedChar* Arena::CreateMaybeMessage< ::io::substrait::Type_FixedChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_FixedChar >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_VarChar* Arena::CreateMaybeMessage< ::io::substrait::Type_VarChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_VarChar >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_FixedBinary* Arena::CreateMaybeMessage< ::io::substrait::Type_FixedBinary >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_FixedBinary >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_Decimal* Arena::CreateMaybeMessage< ::io::substrait::Type_Decimal >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_Decimal >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_Struct* Arena::CreateMaybeMessage< ::io::substrait::Type_Struct >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_Struct >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_NamedStruct* Arena::CreateMaybeMessage< ::io::substrait::Type_NamedStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_NamedStruct >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_List* Arena::CreateMaybeMessage< ::io::substrait::Type_List >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_List >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_Map* Arena::CreateMaybeMessage< ::io::substrait::Type_Map >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_Map >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type_Variation* Arena::CreateMaybeMessage< ::io::substrait::Type_Variation >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type_Variation >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Type* Arena::CreateMaybeMessage< ::io::substrait::Type >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Type >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/type.pb.h b/cpp/src/generated/substrait/type.pb.h new file mode 100644 index 00000000000..d751cfdbb74 --- /dev/null +++ b/cpp/src/generated/substrait/type.pb.h @@ -0,0 +1,9751 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: type.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_type_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_type_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +#include "extensions.pb.h" +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_type_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_type_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[26] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_2eproto; +namespace io { +namespace substrait { +class Type; +struct TypeDefaultTypeInternal; +extern TypeDefaultTypeInternal _Type_default_instance_; +class Type_Binary; +struct Type_BinaryDefaultTypeInternal; +extern Type_BinaryDefaultTypeInternal _Type_Binary_default_instance_; +class Type_Boolean; +struct Type_BooleanDefaultTypeInternal; +extern Type_BooleanDefaultTypeInternal _Type_Boolean_default_instance_; +class Type_Date; +struct Type_DateDefaultTypeInternal; +extern Type_DateDefaultTypeInternal _Type_Date_default_instance_; +class Type_Decimal; +struct Type_DecimalDefaultTypeInternal; +extern Type_DecimalDefaultTypeInternal _Type_Decimal_default_instance_; +class Type_FP32; +struct Type_FP32DefaultTypeInternal; +extern Type_FP32DefaultTypeInternal _Type_FP32_default_instance_; +class Type_FP64; +struct Type_FP64DefaultTypeInternal; +extern Type_FP64DefaultTypeInternal _Type_FP64_default_instance_; +class Type_FixedBinary; +struct Type_FixedBinaryDefaultTypeInternal; +extern Type_FixedBinaryDefaultTypeInternal _Type_FixedBinary_default_instance_; +class Type_FixedChar; +struct Type_FixedCharDefaultTypeInternal; +extern Type_FixedCharDefaultTypeInternal _Type_FixedChar_default_instance_; +class Type_I16; +struct Type_I16DefaultTypeInternal; +extern Type_I16DefaultTypeInternal _Type_I16_default_instance_; +class Type_I32; +struct Type_I32DefaultTypeInternal; +extern Type_I32DefaultTypeInternal _Type_I32_default_instance_; +class Type_I64; +struct Type_I64DefaultTypeInternal; +extern Type_I64DefaultTypeInternal _Type_I64_default_instance_; +class Type_I8; +struct Type_I8DefaultTypeInternal; +extern Type_I8DefaultTypeInternal _Type_I8_default_instance_; +class Type_IntervalDay; +struct Type_IntervalDayDefaultTypeInternal; +extern Type_IntervalDayDefaultTypeInternal _Type_IntervalDay_default_instance_; +class Type_IntervalYear; +struct Type_IntervalYearDefaultTypeInternal; +extern Type_IntervalYearDefaultTypeInternal _Type_IntervalYear_default_instance_; +class Type_List; +struct Type_ListDefaultTypeInternal; +extern Type_ListDefaultTypeInternal _Type_List_default_instance_; +class Type_Map; +struct Type_MapDefaultTypeInternal; +extern Type_MapDefaultTypeInternal _Type_Map_default_instance_; +class Type_NamedStruct; +struct Type_NamedStructDefaultTypeInternal; +extern Type_NamedStructDefaultTypeInternal _Type_NamedStruct_default_instance_; +class Type_String; +struct Type_StringDefaultTypeInternal; +extern Type_StringDefaultTypeInternal _Type_String_default_instance_; +class Type_Struct; +struct Type_StructDefaultTypeInternal; +extern Type_StructDefaultTypeInternal _Type_Struct_default_instance_; +class Type_Time; +struct Type_TimeDefaultTypeInternal; +extern Type_TimeDefaultTypeInternal _Type_Time_default_instance_; +class Type_Timestamp; +struct Type_TimestampDefaultTypeInternal; +extern Type_TimestampDefaultTypeInternal _Type_Timestamp_default_instance_; +class Type_TimestampTZ; +struct Type_TimestampTZDefaultTypeInternal; +extern Type_TimestampTZDefaultTypeInternal _Type_TimestampTZ_default_instance_; +class Type_UUID; +struct Type_UUIDDefaultTypeInternal; +extern Type_UUIDDefaultTypeInternal _Type_UUID_default_instance_; +class Type_VarChar; +struct Type_VarCharDefaultTypeInternal; +extern Type_VarCharDefaultTypeInternal _Type_VarChar_default_instance_; +class Type_Variation; +struct Type_VariationDefaultTypeInternal; +extern Type_VariationDefaultTypeInternal _Type_Variation_default_instance_; +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::Type* Arena::CreateMaybeMessage<::io::substrait::Type>(Arena*); +template<> ::io::substrait::Type_Binary* Arena::CreateMaybeMessage<::io::substrait::Type_Binary>(Arena*); +template<> ::io::substrait::Type_Boolean* Arena::CreateMaybeMessage<::io::substrait::Type_Boolean>(Arena*); +template<> ::io::substrait::Type_Date* Arena::CreateMaybeMessage<::io::substrait::Type_Date>(Arena*); +template<> ::io::substrait::Type_Decimal* Arena::CreateMaybeMessage<::io::substrait::Type_Decimal>(Arena*); +template<> ::io::substrait::Type_FP32* Arena::CreateMaybeMessage<::io::substrait::Type_FP32>(Arena*); +template<> ::io::substrait::Type_FP64* Arena::CreateMaybeMessage<::io::substrait::Type_FP64>(Arena*); +template<> ::io::substrait::Type_FixedBinary* Arena::CreateMaybeMessage<::io::substrait::Type_FixedBinary>(Arena*); +template<> ::io::substrait::Type_FixedChar* Arena::CreateMaybeMessage<::io::substrait::Type_FixedChar>(Arena*); +template<> ::io::substrait::Type_I16* Arena::CreateMaybeMessage<::io::substrait::Type_I16>(Arena*); +template<> ::io::substrait::Type_I32* Arena::CreateMaybeMessage<::io::substrait::Type_I32>(Arena*); +template<> ::io::substrait::Type_I64* Arena::CreateMaybeMessage<::io::substrait::Type_I64>(Arena*); +template<> ::io::substrait::Type_I8* Arena::CreateMaybeMessage<::io::substrait::Type_I8>(Arena*); +template<> ::io::substrait::Type_IntervalDay* Arena::CreateMaybeMessage<::io::substrait::Type_IntervalDay>(Arena*); +template<> ::io::substrait::Type_IntervalYear* Arena::CreateMaybeMessage<::io::substrait::Type_IntervalYear>(Arena*); +template<> ::io::substrait::Type_List* Arena::CreateMaybeMessage<::io::substrait::Type_List>(Arena*); +template<> ::io::substrait::Type_Map* Arena::CreateMaybeMessage<::io::substrait::Type_Map>(Arena*); +template<> ::io::substrait::Type_NamedStruct* Arena::CreateMaybeMessage<::io::substrait::Type_NamedStruct>(Arena*); +template<> ::io::substrait::Type_String* Arena::CreateMaybeMessage<::io::substrait::Type_String>(Arena*); +template<> ::io::substrait::Type_Struct* Arena::CreateMaybeMessage<::io::substrait::Type_Struct>(Arena*); +template<> ::io::substrait::Type_Time* Arena::CreateMaybeMessage<::io::substrait::Type_Time>(Arena*); +template<> ::io::substrait::Type_Timestamp* Arena::CreateMaybeMessage<::io::substrait::Type_Timestamp>(Arena*); +template<> ::io::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage<::io::substrait::Type_TimestampTZ>(Arena*); +template<> ::io::substrait::Type_UUID* Arena::CreateMaybeMessage<::io::substrait::Type_UUID>(Arena*); +template<> ::io::substrait::Type_VarChar* Arena::CreateMaybeMessage<::io::substrait::Type_VarChar>(Arena*); +template<> ::io::substrait::Type_Variation* Arena::CreateMaybeMessage<::io::substrait::Type_Variation>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace io { +namespace substrait { + +enum Type_Nullability : int { + Type_Nullability_NULLABLE = 0, + Type_Nullability_REQUIRED = 1, + Type_Nullability_Type_Nullability_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + Type_Nullability_Type_Nullability_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool Type_Nullability_IsValid(int value); +constexpr Type_Nullability Type_Nullability_Nullability_MIN = Type_Nullability_NULLABLE; +constexpr Type_Nullability Type_Nullability_Nullability_MAX = Type_Nullability_REQUIRED; +constexpr int Type_Nullability_Nullability_ARRAYSIZE = Type_Nullability_Nullability_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_Nullability_descriptor(); +template +inline const std::string& Type_Nullability_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Type_Nullability_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + Type_Nullability_descriptor(), enum_t_value); +} +inline bool Type_Nullability_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Type_Nullability* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + Type_Nullability_descriptor(), name, value); +} +// =================================================================== + +class Type_Boolean PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Boolean) */ { + public: + inline Type_Boolean() : Type_Boolean(nullptr) {} + ~Type_Boolean() override; + explicit constexpr Type_Boolean(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_Boolean(const Type_Boolean& from); + Type_Boolean(Type_Boolean&& from) noexcept + : Type_Boolean() { + *this = ::std::move(from); + } + + inline Type_Boolean& operator=(const Type_Boolean& from) { + CopyFrom(from); + return *this; + } + inline Type_Boolean& operator=(Type_Boolean&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_Boolean& default_instance() { + return *internal_default_instance(); + } + static inline const Type_Boolean* internal_default_instance() { + return reinterpret_cast( + &_Type_Boolean_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Type_Boolean& a, Type_Boolean& b) { + a.Swap(&b); + } + inline void Swap(Type_Boolean* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_Boolean* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_Boolean* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_Boolean* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_Boolean& from); + void MergeFrom(const Type_Boolean& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_Boolean* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.Boolean"; + } + protected: + explicit Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.Boolean) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_I8 PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.I8) */ { + public: + inline Type_I8() : Type_I8(nullptr) {} + ~Type_I8() override; + explicit constexpr Type_I8(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_I8(const Type_I8& from); + Type_I8(Type_I8&& from) noexcept + : Type_I8() { + *this = ::std::move(from); + } + + inline Type_I8& operator=(const Type_I8& from) { + CopyFrom(from); + return *this; + } + inline Type_I8& operator=(Type_I8&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_I8& default_instance() { + return *internal_default_instance(); + } + static inline const Type_I8* internal_default_instance() { + return reinterpret_cast( + &_Type_I8_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(Type_I8& a, Type_I8& b) { + a.Swap(&b); + } + inline void Swap(Type_I8* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_I8* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_I8* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_I8* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_I8& from); + void MergeFrom(const Type_I8& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_I8* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.I8"; + } + protected: + explicit Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.I8) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_I16 PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.I16) */ { + public: + inline Type_I16() : Type_I16(nullptr) {} + ~Type_I16() override; + explicit constexpr Type_I16(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_I16(const Type_I16& from); + Type_I16(Type_I16&& from) noexcept + : Type_I16() { + *this = ::std::move(from); + } + + inline Type_I16& operator=(const Type_I16& from) { + CopyFrom(from); + return *this; + } + inline Type_I16& operator=(Type_I16&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_I16& default_instance() { + return *internal_default_instance(); + } + static inline const Type_I16* internal_default_instance() { + return reinterpret_cast( + &_Type_I16_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(Type_I16& a, Type_I16& b) { + a.Swap(&b); + } + inline void Swap(Type_I16* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_I16* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_I16* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_I16* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_I16& from); + void MergeFrom(const Type_I16& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_I16* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.I16"; + } + protected: + explicit Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.I16) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_I32 PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.I32) */ { + public: + inline Type_I32() : Type_I32(nullptr) {} + ~Type_I32() override; + explicit constexpr Type_I32(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_I32(const Type_I32& from); + Type_I32(Type_I32&& from) noexcept + : Type_I32() { + *this = ::std::move(from); + } + + inline Type_I32& operator=(const Type_I32& from) { + CopyFrom(from); + return *this; + } + inline Type_I32& operator=(Type_I32&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_I32& default_instance() { + return *internal_default_instance(); + } + static inline const Type_I32* internal_default_instance() { + return reinterpret_cast( + &_Type_I32_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(Type_I32& a, Type_I32& b) { + a.Swap(&b); + } + inline void Swap(Type_I32* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_I32* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_I32* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_I32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_I32& from); + void MergeFrom(const Type_I32& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_I32* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.I32"; + } + protected: + explicit Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.I32) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_I64 PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.I64) */ { + public: + inline Type_I64() : Type_I64(nullptr) {} + ~Type_I64() override; + explicit constexpr Type_I64(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_I64(const Type_I64& from); + Type_I64(Type_I64&& from) noexcept + : Type_I64() { + *this = ::std::move(from); + } + + inline Type_I64& operator=(const Type_I64& from) { + CopyFrom(from); + return *this; + } + inline Type_I64& operator=(Type_I64&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_I64& default_instance() { + return *internal_default_instance(); + } + static inline const Type_I64* internal_default_instance() { + return reinterpret_cast( + &_Type_I64_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(Type_I64& a, Type_I64& b) { + a.Swap(&b); + } + inline void Swap(Type_I64* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_I64* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_I64* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_I64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_I64& from); + void MergeFrom(const Type_I64& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_I64* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.I64"; + } + protected: + explicit Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.I64) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_FP32 PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.FP32) */ { + public: + inline Type_FP32() : Type_FP32(nullptr) {} + ~Type_FP32() override; + explicit constexpr Type_FP32(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_FP32(const Type_FP32& from); + Type_FP32(Type_FP32&& from) noexcept + : Type_FP32() { + *this = ::std::move(from); + } + + inline Type_FP32& operator=(const Type_FP32& from) { + CopyFrom(from); + return *this; + } + inline Type_FP32& operator=(Type_FP32&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_FP32& default_instance() { + return *internal_default_instance(); + } + static inline const Type_FP32* internal_default_instance() { + return reinterpret_cast( + &_Type_FP32_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(Type_FP32& a, Type_FP32& b) { + a.Swap(&b); + } + inline void Swap(Type_FP32* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_FP32* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_FP32* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_FP32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_FP32& from); + void MergeFrom(const Type_FP32& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_FP32* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.FP32"; + } + protected: + explicit Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.FP32) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_FP64 PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.FP64) */ { + public: + inline Type_FP64() : Type_FP64(nullptr) {} + ~Type_FP64() override; + explicit constexpr Type_FP64(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_FP64(const Type_FP64& from); + Type_FP64(Type_FP64&& from) noexcept + : Type_FP64() { + *this = ::std::move(from); + } + + inline Type_FP64& operator=(const Type_FP64& from) { + CopyFrom(from); + return *this; + } + inline Type_FP64& operator=(Type_FP64&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_FP64& default_instance() { + return *internal_default_instance(); + } + static inline const Type_FP64* internal_default_instance() { + return reinterpret_cast( + &_Type_FP64_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(Type_FP64& a, Type_FP64& b) { + a.Swap(&b); + } + inline void Swap(Type_FP64* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_FP64* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_FP64* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_FP64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_FP64& from); + void MergeFrom(const Type_FP64& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_FP64* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.FP64"; + } + protected: + explicit Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.FP64) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_String PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.String) */ { + public: + inline Type_String() : Type_String(nullptr) {} + ~Type_String() override; + explicit constexpr Type_String(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_String(const Type_String& from); + Type_String(Type_String&& from) noexcept + : Type_String() { + *this = ::std::move(from); + } + + inline Type_String& operator=(const Type_String& from) { + CopyFrom(from); + return *this; + } + inline Type_String& operator=(Type_String&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_String& default_instance() { + return *internal_default_instance(); + } + static inline const Type_String* internal_default_instance() { + return reinterpret_cast( + &_Type_String_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(Type_String& a, Type_String& b) { + a.Swap(&b); + } + inline void Swap(Type_String* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_String* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_String* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_String* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_String& from); + void MergeFrom(const Type_String& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_String* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.String"; + } + protected: + explicit Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.String) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_Binary PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Binary) */ { + public: + inline Type_Binary() : Type_Binary(nullptr) {} + ~Type_Binary() override; + explicit constexpr Type_Binary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_Binary(const Type_Binary& from); + Type_Binary(Type_Binary&& from) noexcept + : Type_Binary() { + *this = ::std::move(from); + } + + inline Type_Binary& operator=(const Type_Binary& from) { + CopyFrom(from); + return *this; + } + inline Type_Binary& operator=(Type_Binary&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_Binary& default_instance() { + return *internal_default_instance(); + } + static inline const Type_Binary* internal_default_instance() { + return reinterpret_cast( + &_Type_Binary_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(Type_Binary& a, Type_Binary& b) { + a.Swap(&b); + } + inline void Swap(Type_Binary* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_Binary* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_Binary* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_Binary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_Binary& from); + void MergeFrom(const Type_Binary& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_Binary* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.Binary"; + } + protected: + explicit Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.Binary) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_Timestamp PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Timestamp) */ { + public: + inline Type_Timestamp() : Type_Timestamp(nullptr) {} + ~Type_Timestamp() override; + explicit constexpr Type_Timestamp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_Timestamp(const Type_Timestamp& from); + Type_Timestamp(Type_Timestamp&& from) noexcept + : Type_Timestamp() { + *this = ::std::move(from); + } + + inline Type_Timestamp& operator=(const Type_Timestamp& from) { + CopyFrom(from); + return *this; + } + inline Type_Timestamp& operator=(Type_Timestamp&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_Timestamp& default_instance() { + return *internal_default_instance(); + } + static inline const Type_Timestamp* internal_default_instance() { + return reinterpret_cast( + &_Type_Timestamp_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(Type_Timestamp& a, Type_Timestamp& b) { + a.Swap(&b); + } + inline void Swap(Type_Timestamp* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_Timestamp* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_Timestamp* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_Timestamp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_Timestamp& from); + void MergeFrom(const Type_Timestamp& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_Timestamp* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.Timestamp"; + } + protected: + explicit Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.Timestamp) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_Date PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Date) */ { + public: + inline Type_Date() : Type_Date(nullptr) {} + ~Type_Date() override; + explicit constexpr Type_Date(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_Date(const Type_Date& from); + Type_Date(Type_Date&& from) noexcept + : Type_Date() { + *this = ::std::move(from); + } + + inline Type_Date& operator=(const Type_Date& from) { + CopyFrom(from); + return *this; + } + inline Type_Date& operator=(Type_Date&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_Date& default_instance() { + return *internal_default_instance(); + } + static inline const Type_Date* internal_default_instance() { + return reinterpret_cast( + &_Type_Date_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(Type_Date& a, Type_Date& b) { + a.Swap(&b); + } + inline void Swap(Type_Date* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_Date* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_Date* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_Date* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_Date& from); + void MergeFrom(const Type_Date& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_Date* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.Date"; + } + protected: + explicit Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.Date) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_Time PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Time) */ { + public: + inline Type_Time() : Type_Time(nullptr) {} + ~Type_Time() override; + explicit constexpr Type_Time(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_Time(const Type_Time& from); + Type_Time(Type_Time&& from) noexcept + : Type_Time() { + *this = ::std::move(from); + } + + inline Type_Time& operator=(const Type_Time& from) { + CopyFrom(from); + return *this; + } + inline Type_Time& operator=(Type_Time&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_Time& default_instance() { + return *internal_default_instance(); + } + static inline const Type_Time* internal_default_instance() { + return reinterpret_cast( + &_Type_Time_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(Type_Time& a, Type_Time& b) { + a.Swap(&b); + } + inline void Swap(Type_Time* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_Time* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_Time* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_Time* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_Time& from); + void MergeFrom(const Type_Time& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_Time* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.Time"; + } + protected: + explicit Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.Time) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_TimestampTZ PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.TimestampTZ) */ { + public: + inline Type_TimestampTZ() : Type_TimestampTZ(nullptr) {} + ~Type_TimestampTZ() override; + explicit constexpr Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_TimestampTZ(const Type_TimestampTZ& from); + Type_TimestampTZ(Type_TimestampTZ&& from) noexcept + : Type_TimestampTZ() { + *this = ::std::move(from); + } + + inline Type_TimestampTZ& operator=(const Type_TimestampTZ& from) { + CopyFrom(from); + return *this; + } + inline Type_TimestampTZ& operator=(Type_TimestampTZ&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_TimestampTZ& default_instance() { + return *internal_default_instance(); + } + static inline const Type_TimestampTZ* internal_default_instance() { + return reinterpret_cast( + &_Type_TimestampTZ_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(Type_TimestampTZ& a, Type_TimestampTZ& b) { + a.Swap(&b); + } + inline void Swap(Type_TimestampTZ* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_TimestampTZ* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_TimestampTZ* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_TimestampTZ* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_TimestampTZ& from); + void MergeFrom(const Type_TimestampTZ& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_TimestampTZ* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.TimestampTZ"; + } + protected: + explicit Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.TimestampTZ) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_IntervalYear PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.IntervalYear) */ { + public: + inline Type_IntervalYear() : Type_IntervalYear(nullptr) {} + ~Type_IntervalYear() override; + explicit constexpr Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_IntervalYear(const Type_IntervalYear& from); + Type_IntervalYear(Type_IntervalYear&& from) noexcept + : Type_IntervalYear() { + *this = ::std::move(from); + } + + inline Type_IntervalYear& operator=(const Type_IntervalYear& from) { + CopyFrom(from); + return *this; + } + inline Type_IntervalYear& operator=(Type_IntervalYear&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_IntervalYear& default_instance() { + return *internal_default_instance(); + } + static inline const Type_IntervalYear* internal_default_instance() { + return reinterpret_cast( + &_Type_IntervalYear_default_instance_); + } + static constexpr int kIndexInFileMessages = + 13; + + friend void swap(Type_IntervalYear& a, Type_IntervalYear& b) { + a.Swap(&b); + } + inline void Swap(Type_IntervalYear* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_IntervalYear* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_IntervalYear* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_IntervalYear* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_IntervalYear& from); + void MergeFrom(const Type_IntervalYear& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_IntervalYear* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.IntervalYear"; + } + protected: + explicit Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.IntervalYear) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_IntervalDay PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.IntervalDay) */ { + public: + inline Type_IntervalDay() : Type_IntervalDay(nullptr) {} + ~Type_IntervalDay() override; + explicit constexpr Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_IntervalDay(const Type_IntervalDay& from); + Type_IntervalDay(Type_IntervalDay&& from) noexcept + : Type_IntervalDay() { + *this = ::std::move(from); + } + + inline Type_IntervalDay& operator=(const Type_IntervalDay& from) { + CopyFrom(from); + return *this; + } + inline Type_IntervalDay& operator=(Type_IntervalDay&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_IntervalDay& default_instance() { + return *internal_default_instance(); + } + static inline const Type_IntervalDay* internal_default_instance() { + return reinterpret_cast( + &_Type_IntervalDay_default_instance_); + } + static constexpr int kIndexInFileMessages = + 14; + + friend void swap(Type_IntervalDay& a, Type_IntervalDay& b) { + a.Swap(&b); + } + inline void Swap(Type_IntervalDay* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_IntervalDay* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_IntervalDay* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_IntervalDay* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_IntervalDay& from); + void MergeFrom(const Type_IntervalDay& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_IntervalDay* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.IntervalDay"; + } + protected: + explicit Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.IntervalDay) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_UUID PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.UUID) */ { + public: + inline Type_UUID() : Type_UUID(nullptr) {} + ~Type_UUID() override; + explicit constexpr Type_UUID(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_UUID(const Type_UUID& from); + Type_UUID(Type_UUID&& from) noexcept + : Type_UUID() { + *this = ::std::move(from); + } + + inline Type_UUID& operator=(const Type_UUID& from) { + CopyFrom(from); + return *this; + } + inline Type_UUID& operator=(Type_UUID&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_UUID& default_instance() { + return *internal_default_instance(); + } + static inline const Type_UUID* internal_default_instance() { + return reinterpret_cast( + &_Type_UUID_default_instance_); + } + static constexpr int kIndexInFileMessages = + 15; + + friend void swap(Type_UUID& a, Type_UUID& b) { + a.Swap(&b); + } + inline void Swap(Type_UUID* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_UUID* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_UUID* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_UUID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_UUID& from); + void MergeFrom(const Type_UUID& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_UUID* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.UUID"; + } + protected: + explicit Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 1, + kNullabilityFieldNumber = 2, + }; + // .io.substrait.Type.Variation variation = 1; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 2; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.UUID) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_FixedChar PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.FixedChar) */ { + public: + inline Type_FixedChar() : Type_FixedChar(nullptr) {} + ~Type_FixedChar() override; + explicit constexpr Type_FixedChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_FixedChar(const Type_FixedChar& from); + Type_FixedChar(Type_FixedChar&& from) noexcept + : Type_FixedChar() { + *this = ::std::move(from); + } + + inline Type_FixedChar& operator=(const Type_FixedChar& from) { + CopyFrom(from); + return *this; + } + inline Type_FixedChar& operator=(Type_FixedChar&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_FixedChar& default_instance() { + return *internal_default_instance(); + } + static inline const Type_FixedChar* internal_default_instance() { + return reinterpret_cast( + &_Type_FixedChar_default_instance_); + } + static constexpr int kIndexInFileMessages = + 16; + + friend void swap(Type_FixedChar& a, Type_FixedChar& b) { + a.Swap(&b); + } + inline void Swap(Type_FixedChar* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_FixedChar* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_FixedChar* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_FixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_FixedChar& from); + void MergeFrom(const Type_FixedChar& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_FixedChar* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.FixedChar"; + } + protected: + explicit Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 2, + kLengthFieldNumber = 1, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // int32 length = 1; + void clear_length(); + ::PROTOBUF_NAMESPACE_ID::int32 length() const; + void set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_length() const; + void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.FixedChar) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::int32 length_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_VarChar PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.VarChar) */ { + public: + inline Type_VarChar() : Type_VarChar(nullptr) {} + ~Type_VarChar() override; + explicit constexpr Type_VarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_VarChar(const Type_VarChar& from); + Type_VarChar(Type_VarChar&& from) noexcept + : Type_VarChar() { + *this = ::std::move(from); + } + + inline Type_VarChar& operator=(const Type_VarChar& from) { + CopyFrom(from); + return *this; + } + inline Type_VarChar& operator=(Type_VarChar&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_VarChar& default_instance() { + return *internal_default_instance(); + } + static inline const Type_VarChar* internal_default_instance() { + return reinterpret_cast( + &_Type_VarChar_default_instance_); + } + static constexpr int kIndexInFileMessages = + 17; + + friend void swap(Type_VarChar& a, Type_VarChar& b) { + a.Swap(&b); + } + inline void Swap(Type_VarChar* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_VarChar* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_VarChar* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_VarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_VarChar& from); + void MergeFrom(const Type_VarChar& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_VarChar* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.VarChar"; + } + protected: + explicit Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 2, + kLengthFieldNumber = 1, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // int32 length = 1; + void clear_length(); + ::PROTOBUF_NAMESPACE_ID::int32 length() const; + void set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_length() const; + void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.VarChar) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::int32 length_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_FixedBinary PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.FixedBinary) */ { + public: + inline Type_FixedBinary() : Type_FixedBinary(nullptr) {} + ~Type_FixedBinary() override; + explicit constexpr Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_FixedBinary(const Type_FixedBinary& from); + Type_FixedBinary(Type_FixedBinary&& from) noexcept + : Type_FixedBinary() { + *this = ::std::move(from); + } + + inline Type_FixedBinary& operator=(const Type_FixedBinary& from) { + CopyFrom(from); + return *this; + } + inline Type_FixedBinary& operator=(Type_FixedBinary&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_FixedBinary& default_instance() { + return *internal_default_instance(); + } + static inline const Type_FixedBinary* internal_default_instance() { + return reinterpret_cast( + &_Type_FixedBinary_default_instance_); + } + static constexpr int kIndexInFileMessages = + 18; + + friend void swap(Type_FixedBinary& a, Type_FixedBinary& b) { + a.Swap(&b); + } + inline void Swap(Type_FixedBinary* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_FixedBinary* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_FixedBinary* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_FixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_FixedBinary& from); + void MergeFrom(const Type_FixedBinary& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_FixedBinary* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.FixedBinary"; + } + protected: + explicit Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 2, + kLengthFieldNumber = 1, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // int32 length = 1; + void clear_length(); + ::PROTOBUF_NAMESPACE_ID::int32 length() const; + void set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_length() const; + void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.FixedBinary) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::int32 length_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_Decimal PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Decimal) */ { + public: + inline Type_Decimal() : Type_Decimal(nullptr) {} + ~Type_Decimal() override; + explicit constexpr Type_Decimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_Decimal(const Type_Decimal& from); + Type_Decimal(Type_Decimal&& from) noexcept + : Type_Decimal() { + *this = ::std::move(from); + } + + inline Type_Decimal& operator=(const Type_Decimal& from) { + CopyFrom(from); + return *this; + } + inline Type_Decimal& operator=(Type_Decimal&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_Decimal& default_instance() { + return *internal_default_instance(); + } + static inline const Type_Decimal* internal_default_instance() { + return reinterpret_cast( + &_Type_Decimal_default_instance_); + } + static constexpr int kIndexInFileMessages = + 19; + + friend void swap(Type_Decimal& a, Type_Decimal& b) { + a.Swap(&b); + } + inline void Swap(Type_Decimal* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_Decimal* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_Decimal* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_Decimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_Decimal& from); + void MergeFrom(const Type_Decimal& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_Decimal* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.Decimal"; + } + protected: + explicit Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kVariationFieldNumber = 3, + kScaleFieldNumber = 1, + kPrecisionFieldNumber = 2, + kNullabilityFieldNumber = 4, + }; + // .io.substrait.Type.Variation variation = 3; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // int32 scale = 1; + void clear_scale(); + ::PROTOBUF_NAMESPACE_ID::int32 scale() const; + void set_scale(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_scale() const; + void _internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // int32 precision = 2; + void clear_precision(); + ::PROTOBUF_NAMESPACE_ID::int32 precision() const; + void set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_precision() const; + void _internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // .io.substrait.Type.Nullability nullability = 4; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.Decimal) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::int32 scale_; + ::PROTOBUF_NAMESPACE_ID::int32 precision_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_Struct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Struct) */ { + public: + inline Type_Struct() : Type_Struct(nullptr) {} + ~Type_Struct() override; + explicit constexpr Type_Struct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_Struct(const Type_Struct& from); + Type_Struct(Type_Struct&& from) noexcept + : Type_Struct() { + *this = ::std::move(from); + } + + inline Type_Struct& operator=(const Type_Struct& from) { + CopyFrom(from); + return *this; + } + inline Type_Struct& operator=(Type_Struct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_Struct& default_instance() { + return *internal_default_instance(); + } + static inline const Type_Struct* internal_default_instance() { + return reinterpret_cast( + &_Type_Struct_default_instance_); + } + static constexpr int kIndexInFileMessages = + 20; + + friend void swap(Type_Struct& a, Type_Struct& b) { + a.Swap(&b); + } + inline void Swap(Type_Struct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_Struct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_Struct* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_Struct& from); + void MergeFrom(const Type_Struct& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_Struct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.Struct"; + } + protected: + explicit Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTypesFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // repeated .io.substrait.Type types = 1; + int types_size() const; + private: + int _internal_types_size() const; + public: + void clear_types(); + ::io::substrait::Type* mutable_types(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type >* + mutable_types(); + private: + const ::io::substrait::Type& _internal_types(int index) const; + ::io::substrait::Type* _internal_add_types(); + public: + const ::io::substrait::Type& types(int index) const; + ::io::substrait::Type* add_types(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type >& + types() const; + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.Struct) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type > types_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_NamedStruct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.NamedStruct) */ { + public: + inline Type_NamedStruct() : Type_NamedStruct(nullptr) {} + ~Type_NamedStruct() override; + explicit constexpr Type_NamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_NamedStruct(const Type_NamedStruct& from); + Type_NamedStruct(Type_NamedStruct&& from) noexcept + : Type_NamedStruct() { + *this = ::std::move(from); + } + + inline Type_NamedStruct& operator=(const Type_NamedStruct& from) { + CopyFrom(from); + return *this; + } + inline Type_NamedStruct& operator=(Type_NamedStruct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_NamedStruct& default_instance() { + return *internal_default_instance(); + } + static inline const Type_NamedStruct* internal_default_instance() { + return reinterpret_cast( + &_Type_NamedStruct_default_instance_); + } + static constexpr int kIndexInFileMessages = + 21; + + friend void swap(Type_NamedStruct& a, Type_NamedStruct& b) { + a.Swap(&b); + } + inline void Swap(Type_NamedStruct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_NamedStruct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_NamedStruct* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_NamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_NamedStruct& from); + void MergeFrom(const Type_NamedStruct& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_NamedStruct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.NamedStruct"; + } + protected: + explicit Type_NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNamesFieldNumber = 1, + kStructFieldNumber = 2, + }; + // repeated string names = 1; + int names_size() const; + private: + int _internal_names_size() const; + public: + void clear_names(); + const std::string& names(int index) const; + std::string* mutable_names(int index); + void set_names(int index, const std::string& value); + void set_names(int index, std::string&& value); + void set_names(int index, const char* value); + void set_names(int index, const char* value, size_t size); + std::string* add_names(); + void add_names(const std::string& value); + void add_names(std::string&& value); + void add_names(const char* value); + void add_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); + private: + const std::string& _internal_names(int index) const; + std::string* _internal_add_names(); + public: + + // .io.substrait.Type.Struct struct = 2; + bool has_struct_() const; + private: + bool _internal_has_struct_() const; + public: + void clear_struct_(); + const ::io::substrait::Type_Struct& struct_() const; + ::io::substrait::Type_Struct* release_struct_(); + ::io::substrait::Type_Struct* mutable_struct_(); + void set_allocated_struct_(::io::substrait::Type_Struct* struct_); + private: + const ::io::substrait::Type_Struct& _internal_struct_() const; + ::io::substrait::Type_Struct* _internal_mutable_struct_(); + public: + void unsafe_arena_set_allocated_struct_( + ::io::substrait::Type_Struct* struct_); + ::io::substrait::Type_Struct* unsafe_arena_release_struct_(); + + // @@protoc_insertion_point(class_scope:io.substrait.Type.NamedStruct) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; + ::io::substrait::Type_Struct* struct__; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_List PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.List) */ { + public: + inline Type_List() : Type_List(nullptr) {} + ~Type_List() override; + explicit constexpr Type_List(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_List(const Type_List& from); + Type_List(Type_List&& from) noexcept + : Type_List() { + *this = ::std::move(from); + } + + inline Type_List& operator=(const Type_List& from) { + CopyFrom(from); + return *this; + } + inline Type_List& operator=(Type_List&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_List& default_instance() { + return *internal_default_instance(); + } + static inline const Type_List* internal_default_instance() { + return reinterpret_cast( + &_Type_List_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(Type_List& a, Type_List& b) { + a.Swap(&b); + } + inline void Swap(Type_List* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_List* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_List* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_List& from); + void MergeFrom(const Type_List& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_List* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.List"; + } + protected: + explicit Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTypeFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.Type type = 1; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + const ::io::substrait::Type& type() const; + ::io::substrait::Type* release_type(); + ::io::substrait::Type* mutable_type(); + void set_allocated_type(::io::substrait::Type* type); + private: + const ::io::substrait::Type& _internal_type() const; + ::io::substrait::Type* _internal_mutable_type(); + public: + void unsafe_arena_set_allocated_type( + ::io::substrait::Type* type); + ::io::substrait::Type* unsafe_arena_release_type(); + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.List) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type* type_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_Map PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Map) */ { + public: + inline Type_Map() : Type_Map(nullptr) {} + ~Type_Map() override; + explicit constexpr Type_Map(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_Map(const Type_Map& from); + Type_Map(Type_Map&& from) noexcept + : Type_Map() { + *this = ::std::move(from); + } + + inline Type_Map& operator=(const Type_Map& from) { + CopyFrom(from); + return *this; + } + inline Type_Map& operator=(Type_Map&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_Map& default_instance() { + return *internal_default_instance(); + } + static inline const Type_Map* internal_default_instance() { + return reinterpret_cast( + &_Type_Map_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; + + friend void swap(Type_Map& a, Type_Map& b) { + a.Swap(&b); + } + inline void Swap(Type_Map* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_Map* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_Map* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_Map& from); + void MergeFrom(const Type_Map& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_Map* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.Map"; + } + protected: + explicit Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + kVariationFieldNumber = 3, + kNullabilityFieldNumber = 4, + }; + // .io.substrait.Type key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::io::substrait::Type& key() const; + ::io::substrait::Type* release_key(); + ::io::substrait::Type* mutable_key(); + void set_allocated_key(::io::substrait::Type* key); + private: + const ::io::substrait::Type& _internal_key() const; + ::io::substrait::Type* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::io::substrait::Type* key); + ::io::substrait::Type* unsafe_arena_release_key(); + + // .io.substrait.Type value = 2; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + const ::io::substrait::Type& value() const; + ::io::substrait::Type* release_value(); + ::io::substrait::Type* mutable_value(); + void set_allocated_value(::io::substrait::Type* value); + private: + const ::io::substrait::Type& _internal_value() const; + ::io::substrait::Type* _internal_mutable_value(); + public: + void unsafe_arena_set_allocated_value( + ::io::substrait::Type* value); + ::io::substrait::Type* unsafe_arena_release_value(); + + // .io.substrait.Type.Variation variation = 3; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 4; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.Map) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Type* key_; + ::io::substrait::Type* value_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type_Variation PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Variation) */ { + public: + inline Type_Variation() : Type_Variation(nullptr) {} + ~Type_Variation() override; + explicit constexpr Type_Variation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type_Variation(const Type_Variation& from); + Type_Variation(Type_Variation&& from) noexcept + : Type_Variation() { + *this = ::std::move(from); + } + + inline Type_Variation& operator=(const Type_Variation& from) { + CopyFrom(from); + return *this; + } + inline Type_Variation& operator=(Type_Variation&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type_Variation& default_instance() { + return *internal_default_instance(); + } + static inline const Type_Variation* internal_default_instance() { + return reinterpret_cast( + &_Type_Variation_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(Type_Variation& a, Type_Variation& b) { + a.Swap(&b); + } + inline void Swap(Type_Variation* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type_Variation* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type_Variation* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type_Variation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type_Variation& from); + void MergeFrom(const Type_Variation& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type_Variation* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type.Variation"; + } + protected: + explicit Type_Variation(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 2, + kOrganizationFieldNumber = 1, + }; + // string name = 2; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // int32 organization = 1; + void clear_organization(); + ::PROTOBUF_NAMESPACE_ID::int32 organization() const; + void set_organization(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_organization() const; + void _internal_set_organization(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Type.Variation) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::int32 organization_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// ------------------------------------------------------------------- + +class Type PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type) */ { + public: + inline Type() : Type(nullptr) {} + ~Type() override; + explicit constexpr Type(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Type(const Type& from); + Type(Type&& from) noexcept + : Type() { + *this = ::std::move(from); + } + + inline Type& operator=(const Type& from) { + CopyFrom(from); + return *this; + } + inline Type& operator=(Type&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Type& default_instance() { + return *internal_default_instance(); + } + enum KindCase { + kBool = 1, + kI8 = 2, + kI16 = 3, + kI32 = 5, + kI64 = 7, + kFp32 = 10, + kFp64 = 11, + kString = 12, + kBinary = 13, + kTimestamp = 14, + kDate = 16, + kTime = 17, + kIntervalYear = 19, + kIntervalDay = 20, + kTimestampTz = 29, + kUuid = 32, + kFixedChar = 21, + kVarchar = 22, + kFixedBinary = 23, + kDecimal = 24, + kStruct = 25, + kList = 27, + kMap = 28, + kUserDefined = 31, + KIND_NOT_SET = 0, + }; + + static inline const Type* internal_default_instance() { + return reinterpret_cast( + &_Type_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(Type& a, Type& b) { + a.Swap(&b); + } + inline void Swap(Type* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Type* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Type* New() const final { + return CreateMaybeMessage(nullptr); + } + + Type* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Type& from); + void MergeFrom(const Type& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Type* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Type"; + } + protected: + explicit Type(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Type_Boolean Boolean; + typedef Type_I8 I8; + typedef Type_I16 I16; + typedef Type_I32 I32; + typedef Type_I64 I64; + typedef Type_FP32 FP32; + typedef Type_FP64 FP64; + typedef Type_String String; + typedef Type_Binary Binary; + typedef Type_Timestamp Timestamp; + typedef Type_Date Date; + typedef Type_Time Time; + typedef Type_TimestampTZ TimestampTZ; + typedef Type_IntervalYear IntervalYear; + typedef Type_IntervalDay IntervalDay; + typedef Type_UUID UUID; + typedef Type_FixedChar FixedChar; + typedef Type_VarChar VarChar; + typedef Type_FixedBinary FixedBinary; + typedef Type_Decimal Decimal; + typedef Type_Struct Struct; + typedef Type_NamedStruct NamedStruct; + typedef Type_List List; + typedef Type_Map Map; + typedef Type_Variation Variation; + + typedef Type_Nullability Nullability; + static constexpr Nullability NULLABLE = + Type_Nullability_NULLABLE; + static constexpr Nullability REQUIRED = + Type_Nullability_REQUIRED; + static inline bool Nullability_IsValid(int value) { + return Type_Nullability_IsValid(value); + } + static constexpr Nullability Nullability_MIN = + Type_Nullability_Nullability_MIN; + static constexpr Nullability Nullability_MAX = + Type_Nullability_Nullability_MAX; + static constexpr int Nullability_ARRAYSIZE = + Type_Nullability_Nullability_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + Nullability_descriptor() { + return Type_Nullability_descriptor(); + } + template + static inline const std::string& Nullability_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function Nullability_Name."); + return Type_Nullability_Name(enum_t_value); + } + static inline bool Nullability_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + Nullability* value) { + return Type_Nullability_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kBoolFieldNumber = 1, + kI8FieldNumber = 2, + kI16FieldNumber = 3, + kI32FieldNumber = 5, + kI64FieldNumber = 7, + kFp32FieldNumber = 10, + kFp64FieldNumber = 11, + kStringFieldNumber = 12, + kBinaryFieldNumber = 13, + kTimestampFieldNumber = 14, + kDateFieldNumber = 16, + kTimeFieldNumber = 17, + kIntervalYearFieldNumber = 19, + kIntervalDayFieldNumber = 20, + kTimestampTzFieldNumber = 29, + kUuidFieldNumber = 32, + kFixedCharFieldNumber = 21, + kVarcharFieldNumber = 22, + kFixedBinaryFieldNumber = 23, + kDecimalFieldNumber = 24, + kStructFieldNumber = 25, + kListFieldNumber = 27, + kMapFieldNumber = 28, + kUserDefinedFieldNumber = 31, + }; + // .io.substrait.Type.Boolean bool = 1; + bool has_bool_() const; + private: + bool _internal_has_bool_() const; + public: + void clear_bool_(); + const ::io::substrait::Type_Boolean& bool_() const; + ::io::substrait::Type_Boolean* release_bool_(); + ::io::substrait::Type_Boolean* mutable_bool_(); + void set_allocated_bool_(::io::substrait::Type_Boolean* bool_); + private: + const ::io::substrait::Type_Boolean& _internal_bool_() const; + ::io::substrait::Type_Boolean* _internal_mutable_bool_(); + public: + void unsafe_arena_set_allocated_bool_( + ::io::substrait::Type_Boolean* bool_); + ::io::substrait::Type_Boolean* unsafe_arena_release_bool_(); + + // .io.substrait.Type.I8 i8 = 2; + bool has_i8() const; + private: + bool _internal_has_i8() const; + public: + void clear_i8(); + const ::io::substrait::Type_I8& i8() const; + ::io::substrait::Type_I8* release_i8(); + ::io::substrait::Type_I8* mutable_i8(); + void set_allocated_i8(::io::substrait::Type_I8* i8); + private: + const ::io::substrait::Type_I8& _internal_i8() const; + ::io::substrait::Type_I8* _internal_mutable_i8(); + public: + void unsafe_arena_set_allocated_i8( + ::io::substrait::Type_I8* i8); + ::io::substrait::Type_I8* unsafe_arena_release_i8(); + + // .io.substrait.Type.I16 i16 = 3; + bool has_i16() const; + private: + bool _internal_has_i16() const; + public: + void clear_i16(); + const ::io::substrait::Type_I16& i16() const; + ::io::substrait::Type_I16* release_i16(); + ::io::substrait::Type_I16* mutable_i16(); + void set_allocated_i16(::io::substrait::Type_I16* i16); + private: + const ::io::substrait::Type_I16& _internal_i16() const; + ::io::substrait::Type_I16* _internal_mutable_i16(); + public: + void unsafe_arena_set_allocated_i16( + ::io::substrait::Type_I16* i16); + ::io::substrait::Type_I16* unsafe_arena_release_i16(); + + // .io.substrait.Type.I32 i32 = 5; + bool has_i32() const; + private: + bool _internal_has_i32() const; + public: + void clear_i32(); + const ::io::substrait::Type_I32& i32() const; + ::io::substrait::Type_I32* release_i32(); + ::io::substrait::Type_I32* mutable_i32(); + void set_allocated_i32(::io::substrait::Type_I32* i32); + private: + const ::io::substrait::Type_I32& _internal_i32() const; + ::io::substrait::Type_I32* _internal_mutable_i32(); + public: + void unsafe_arena_set_allocated_i32( + ::io::substrait::Type_I32* i32); + ::io::substrait::Type_I32* unsafe_arena_release_i32(); + + // .io.substrait.Type.I64 i64 = 7; + bool has_i64() const; + private: + bool _internal_has_i64() const; + public: + void clear_i64(); + const ::io::substrait::Type_I64& i64() const; + ::io::substrait::Type_I64* release_i64(); + ::io::substrait::Type_I64* mutable_i64(); + void set_allocated_i64(::io::substrait::Type_I64* i64); + private: + const ::io::substrait::Type_I64& _internal_i64() const; + ::io::substrait::Type_I64* _internal_mutable_i64(); + public: + void unsafe_arena_set_allocated_i64( + ::io::substrait::Type_I64* i64); + ::io::substrait::Type_I64* unsafe_arena_release_i64(); + + // .io.substrait.Type.FP32 fp32 = 10; + bool has_fp32() const; + private: + bool _internal_has_fp32() const; + public: + void clear_fp32(); + const ::io::substrait::Type_FP32& fp32() const; + ::io::substrait::Type_FP32* release_fp32(); + ::io::substrait::Type_FP32* mutable_fp32(); + void set_allocated_fp32(::io::substrait::Type_FP32* fp32); + private: + const ::io::substrait::Type_FP32& _internal_fp32() const; + ::io::substrait::Type_FP32* _internal_mutable_fp32(); + public: + void unsafe_arena_set_allocated_fp32( + ::io::substrait::Type_FP32* fp32); + ::io::substrait::Type_FP32* unsafe_arena_release_fp32(); + + // .io.substrait.Type.FP64 fp64 = 11; + bool has_fp64() const; + private: + bool _internal_has_fp64() const; + public: + void clear_fp64(); + const ::io::substrait::Type_FP64& fp64() const; + ::io::substrait::Type_FP64* release_fp64(); + ::io::substrait::Type_FP64* mutable_fp64(); + void set_allocated_fp64(::io::substrait::Type_FP64* fp64); + private: + const ::io::substrait::Type_FP64& _internal_fp64() const; + ::io::substrait::Type_FP64* _internal_mutable_fp64(); + public: + void unsafe_arena_set_allocated_fp64( + ::io::substrait::Type_FP64* fp64); + ::io::substrait::Type_FP64* unsafe_arena_release_fp64(); + + // .io.substrait.Type.String string = 12; + bool has_string() const; + private: + bool _internal_has_string() const; + public: + void clear_string(); + const ::io::substrait::Type_String& string() const; + ::io::substrait::Type_String* release_string(); + ::io::substrait::Type_String* mutable_string(); + void set_allocated_string(::io::substrait::Type_String* string); + private: + const ::io::substrait::Type_String& _internal_string() const; + ::io::substrait::Type_String* _internal_mutable_string(); + public: + void unsafe_arena_set_allocated_string( + ::io::substrait::Type_String* string); + ::io::substrait::Type_String* unsafe_arena_release_string(); + + // .io.substrait.Type.Binary binary = 13; + bool has_binary() const; + private: + bool _internal_has_binary() const; + public: + void clear_binary(); + const ::io::substrait::Type_Binary& binary() const; + ::io::substrait::Type_Binary* release_binary(); + ::io::substrait::Type_Binary* mutable_binary(); + void set_allocated_binary(::io::substrait::Type_Binary* binary); + private: + const ::io::substrait::Type_Binary& _internal_binary() const; + ::io::substrait::Type_Binary* _internal_mutable_binary(); + public: + void unsafe_arena_set_allocated_binary( + ::io::substrait::Type_Binary* binary); + ::io::substrait::Type_Binary* unsafe_arena_release_binary(); + + // .io.substrait.Type.Timestamp timestamp = 14; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + const ::io::substrait::Type_Timestamp& timestamp() const; + ::io::substrait::Type_Timestamp* release_timestamp(); + ::io::substrait::Type_Timestamp* mutable_timestamp(); + void set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp); + private: + const ::io::substrait::Type_Timestamp& _internal_timestamp() const; + ::io::substrait::Type_Timestamp* _internal_mutable_timestamp(); + public: + void unsafe_arena_set_allocated_timestamp( + ::io::substrait::Type_Timestamp* timestamp); + ::io::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); + + // .io.substrait.Type.Date date = 16; + bool has_date() const; + private: + bool _internal_has_date() const; + public: + void clear_date(); + const ::io::substrait::Type_Date& date() const; + ::io::substrait::Type_Date* release_date(); + ::io::substrait::Type_Date* mutable_date(); + void set_allocated_date(::io::substrait::Type_Date* date); + private: + const ::io::substrait::Type_Date& _internal_date() const; + ::io::substrait::Type_Date* _internal_mutable_date(); + public: + void unsafe_arena_set_allocated_date( + ::io::substrait::Type_Date* date); + ::io::substrait::Type_Date* unsafe_arena_release_date(); + + // .io.substrait.Type.Time time = 17; + bool has_time() const; + private: + bool _internal_has_time() const; + public: + void clear_time(); + const ::io::substrait::Type_Time& time() const; + ::io::substrait::Type_Time* release_time(); + ::io::substrait::Type_Time* mutable_time(); + void set_allocated_time(::io::substrait::Type_Time* time); + private: + const ::io::substrait::Type_Time& _internal_time() const; + ::io::substrait::Type_Time* _internal_mutable_time(); + public: + void unsafe_arena_set_allocated_time( + ::io::substrait::Type_Time* time); + ::io::substrait::Type_Time* unsafe_arena_release_time(); + + // .io.substrait.Type.IntervalYear interval_year = 19; + bool has_interval_year() const; + private: + bool _internal_has_interval_year() const; + public: + void clear_interval_year(); + const ::io::substrait::Type_IntervalYear& interval_year() const; + ::io::substrait::Type_IntervalYear* release_interval_year(); + ::io::substrait::Type_IntervalYear* mutable_interval_year(); + void set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year); + private: + const ::io::substrait::Type_IntervalYear& _internal_interval_year() const; + ::io::substrait::Type_IntervalYear* _internal_mutable_interval_year(); + public: + void unsafe_arena_set_allocated_interval_year( + ::io::substrait::Type_IntervalYear* interval_year); + ::io::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); + + // .io.substrait.Type.IntervalDay interval_day = 20; + bool has_interval_day() const; + private: + bool _internal_has_interval_day() const; + public: + void clear_interval_day(); + const ::io::substrait::Type_IntervalDay& interval_day() const; + ::io::substrait::Type_IntervalDay* release_interval_day(); + ::io::substrait::Type_IntervalDay* mutable_interval_day(); + void set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day); + private: + const ::io::substrait::Type_IntervalDay& _internal_interval_day() const; + ::io::substrait::Type_IntervalDay* _internal_mutable_interval_day(); + public: + void unsafe_arena_set_allocated_interval_day( + ::io::substrait::Type_IntervalDay* interval_day); + ::io::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); + + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + bool has_timestamp_tz() const; + private: + bool _internal_has_timestamp_tz() const; + public: + void clear_timestamp_tz(); + const ::io::substrait::Type_TimestampTZ& timestamp_tz() const; + ::io::substrait::Type_TimestampTZ* release_timestamp_tz(); + ::io::substrait::Type_TimestampTZ* mutable_timestamp_tz(); + void set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz); + private: + const ::io::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; + ::io::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); + public: + void unsafe_arena_set_allocated_timestamp_tz( + ::io::substrait::Type_TimestampTZ* timestamp_tz); + ::io::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); + + // .io.substrait.Type.UUID uuid = 32; + bool has_uuid() const; + private: + bool _internal_has_uuid() const; + public: + void clear_uuid(); + const ::io::substrait::Type_UUID& uuid() const; + ::io::substrait::Type_UUID* release_uuid(); + ::io::substrait::Type_UUID* mutable_uuid(); + void set_allocated_uuid(::io::substrait::Type_UUID* uuid); + private: + const ::io::substrait::Type_UUID& _internal_uuid() const; + ::io::substrait::Type_UUID* _internal_mutable_uuid(); + public: + void unsafe_arena_set_allocated_uuid( + ::io::substrait::Type_UUID* uuid); + ::io::substrait::Type_UUID* unsafe_arena_release_uuid(); + + // .io.substrait.Type.FixedChar fixed_char = 21; + bool has_fixed_char() const; + private: + bool _internal_has_fixed_char() const; + public: + void clear_fixed_char(); + const ::io::substrait::Type_FixedChar& fixed_char() const; + ::io::substrait::Type_FixedChar* release_fixed_char(); + ::io::substrait::Type_FixedChar* mutable_fixed_char(); + void set_allocated_fixed_char(::io::substrait::Type_FixedChar* fixed_char); + private: + const ::io::substrait::Type_FixedChar& _internal_fixed_char() const; + ::io::substrait::Type_FixedChar* _internal_mutable_fixed_char(); + public: + void unsafe_arena_set_allocated_fixed_char( + ::io::substrait::Type_FixedChar* fixed_char); + ::io::substrait::Type_FixedChar* unsafe_arena_release_fixed_char(); + + // .io.substrait.Type.VarChar varchar = 22; + bool has_varchar() const; + private: + bool _internal_has_varchar() const; + public: + void clear_varchar(); + const ::io::substrait::Type_VarChar& varchar() const; + ::io::substrait::Type_VarChar* release_varchar(); + ::io::substrait::Type_VarChar* mutable_varchar(); + void set_allocated_varchar(::io::substrait::Type_VarChar* varchar); + private: + const ::io::substrait::Type_VarChar& _internal_varchar() const; + ::io::substrait::Type_VarChar* _internal_mutable_varchar(); + public: + void unsafe_arena_set_allocated_varchar( + ::io::substrait::Type_VarChar* varchar); + ::io::substrait::Type_VarChar* unsafe_arena_release_varchar(); + + // .io.substrait.Type.FixedBinary fixed_binary = 23; + bool has_fixed_binary() const; + private: + bool _internal_has_fixed_binary() const; + public: + void clear_fixed_binary(); + const ::io::substrait::Type_FixedBinary& fixed_binary() const; + ::io::substrait::Type_FixedBinary* release_fixed_binary(); + ::io::substrait::Type_FixedBinary* mutable_fixed_binary(); + void set_allocated_fixed_binary(::io::substrait::Type_FixedBinary* fixed_binary); + private: + const ::io::substrait::Type_FixedBinary& _internal_fixed_binary() const; + ::io::substrait::Type_FixedBinary* _internal_mutable_fixed_binary(); + public: + void unsafe_arena_set_allocated_fixed_binary( + ::io::substrait::Type_FixedBinary* fixed_binary); + ::io::substrait::Type_FixedBinary* unsafe_arena_release_fixed_binary(); + + // .io.substrait.Type.Decimal decimal = 24; + bool has_decimal() const; + private: + bool _internal_has_decimal() const; + public: + void clear_decimal(); + const ::io::substrait::Type_Decimal& decimal() const; + ::io::substrait::Type_Decimal* release_decimal(); + ::io::substrait::Type_Decimal* mutable_decimal(); + void set_allocated_decimal(::io::substrait::Type_Decimal* decimal); + private: + const ::io::substrait::Type_Decimal& _internal_decimal() const; + ::io::substrait::Type_Decimal* _internal_mutable_decimal(); + public: + void unsafe_arena_set_allocated_decimal( + ::io::substrait::Type_Decimal* decimal); + ::io::substrait::Type_Decimal* unsafe_arena_release_decimal(); + + // .io.substrait.Type.Struct struct = 25; + bool has_struct_() const; + private: + bool _internal_has_struct_() const; + public: + void clear_struct_(); + const ::io::substrait::Type_Struct& struct_() const; + ::io::substrait::Type_Struct* release_struct_(); + ::io::substrait::Type_Struct* mutable_struct_(); + void set_allocated_struct_(::io::substrait::Type_Struct* struct_); + private: + const ::io::substrait::Type_Struct& _internal_struct_() const; + ::io::substrait::Type_Struct* _internal_mutable_struct_(); + public: + void unsafe_arena_set_allocated_struct_( + ::io::substrait::Type_Struct* struct_); + ::io::substrait::Type_Struct* unsafe_arena_release_struct_(); + + // .io.substrait.Type.List list = 27; + bool has_list() const; + private: + bool _internal_has_list() const; + public: + void clear_list(); + const ::io::substrait::Type_List& list() const; + ::io::substrait::Type_List* release_list(); + ::io::substrait::Type_List* mutable_list(); + void set_allocated_list(::io::substrait::Type_List* list); + private: + const ::io::substrait::Type_List& _internal_list() const; + ::io::substrait::Type_List* _internal_mutable_list(); + public: + void unsafe_arena_set_allocated_list( + ::io::substrait::Type_List* list); + ::io::substrait::Type_List* unsafe_arena_release_list(); + + // .io.substrait.Type.Map map = 28; + bool has_map() const; + private: + bool _internal_has_map() const; + public: + void clear_map(); + const ::io::substrait::Type_Map& map() const; + ::io::substrait::Type_Map* release_map(); + ::io::substrait::Type_Map* mutable_map(); + void set_allocated_map(::io::substrait::Type_Map* map); + private: + const ::io::substrait::Type_Map& _internal_map() const; + ::io::substrait::Type_Map* _internal_mutable_map(); + public: + void unsafe_arena_set_allocated_map( + ::io::substrait::Type_Map* map); + ::io::substrait::Type_Map* unsafe_arena_release_map(); + + // .io.substrait.Extensions.TypeId user_defined = 31; + bool has_user_defined() const; + private: + bool _internal_has_user_defined() const; + public: + void clear_user_defined(); + const ::io::substrait::Extensions_TypeId& user_defined() const; + ::io::substrait::Extensions_TypeId* release_user_defined(); + ::io::substrait::Extensions_TypeId* mutable_user_defined(); + void set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined); + private: + const ::io::substrait::Extensions_TypeId& _internal_user_defined() const; + ::io::substrait::Extensions_TypeId* _internal_mutable_user_defined(); + public: + void unsafe_arena_set_allocated_user_defined( + ::io::substrait::Extensions_TypeId* user_defined); + ::io::substrait::Extensions_TypeId* unsafe_arena_release_user_defined(); + + void clear_kind(); + KindCase kind_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Type) + private: + class _Internal; + void set_has_bool_(); + void set_has_i8(); + void set_has_i16(); + void set_has_i32(); + void set_has_i64(); + void set_has_fp32(); + void set_has_fp64(); + void set_has_string(); + void set_has_binary(); + void set_has_timestamp(); + void set_has_date(); + void set_has_time(); + void set_has_interval_year(); + void set_has_interval_day(); + void set_has_timestamp_tz(); + void set_has_uuid(); + void set_has_fixed_char(); + void set_has_varchar(); + void set_has_fixed_binary(); + void set_has_decimal(); + void set_has_struct_(); + void set_has_list(); + void set_has_map(); + void set_has_user_defined(); + + inline bool has_kind() const; + inline void clear_has_kind(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union KindUnion { + constexpr KindUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Type_Boolean* bool__; + ::io::substrait::Type_I8* i8_; + ::io::substrait::Type_I16* i16_; + ::io::substrait::Type_I32* i32_; + ::io::substrait::Type_I64* i64_; + ::io::substrait::Type_FP32* fp32_; + ::io::substrait::Type_FP64* fp64_; + ::io::substrait::Type_String* string_; + ::io::substrait::Type_Binary* binary_; + ::io::substrait::Type_Timestamp* timestamp_; + ::io::substrait::Type_Date* date_; + ::io::substrait::Type_Time* time_; + ::io::substrait::Type_IntervalYear* interval_year_; + ::io::substrait::Type_IntervalDay* interval_day_; + ::io::substrait::Type_TimestampTZ* timestamp_tz_; + ::io::substrait::Type_UUID* uuid_; + ::io::substrait::Type_FixedChar* fixed_char_; + ::io::substrait::Type_VarChar* varchar_; + ::io::substrait::Type_FixedBinary* fixed_binary_; + ::io::substrait::Type_Decimal* decimal_; + ::io::substrait::Type_Struct* struct__; + ::io::substrait::Type_List* list_; + ::io::substrait::Type_Map* map_; + ::io::substrait::Extensions_TypeId* user_defined_; + } kind_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_type_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Type_Boolean + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_Boolean::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_Boolean::has_variation() const { + return _internal_has_variation(); +} +inline void Type_Boolean::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_Boolean::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_Boolean::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Boolean.variation) + return _internal_variation(); +} +inline void Type_Boolean::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Boolean.variation) +} +inline ::io::substrait::Type_Variation* Type_Boolean::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_Boolean::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Boolean.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_Boolean::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_Boolean::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Boolean.variation) + return _internal_mutable_variation(); +} +inline void Type_Boolean::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Boolean.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_Boolean::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_Boolean::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_Boolean::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Boolean.nullability) + return _internal_nullability(); +} +inline void Type_Boolean::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_Boolean::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Boolean.nullability) +} + +// ------------------------------------------------------------------- + +// Type_I8 + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_I8::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_I8::has_variation() const { + return _internal_has_variation(); +} +inline void Type_I8::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_I8::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_I8::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I8.variation) + return _internal_variation(); +} +inline void Type_I8::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.I8.variation) +} +inline ::io::substrait::Type_Variation* Type_I8::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_I8::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.I8.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_I8::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_I8::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.I8.variation) + return _internal_mutable_variation(); +} +inline void Type_I8::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.I8.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_I8::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_I8::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_I8::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I8.nullability) + return _internal_nullability(); +} +inline void Type_I8::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_I8::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.I8.nullability) +} + +// ------------------------------------------------------------------- + +// Type_I16 + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_I16::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_I16::has_variation() const { + return _internal_has_variation(); +} +inline void Type_I16::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_I16::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_I16::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I16.variation) + return _internal_variation(); +} +inline void Type_I16::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.I16.variation) +} +inline ::io::substrait::Type_Variation* Type_I16::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_I16::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.I16.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_I16::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_I16::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.I16.variation) + return _internal_mutable_variation(); +} +inline void Type_I16::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.I16.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_I16::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_I16::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_I16::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I16.nullability) + return _internal_nullability(); +} +inline void Type_I16::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_I16::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.I16.nullability) +} + +// ------------------------------------------------------------------- + +// Type_I32 + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_I32::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_I32::has_variation() const { + return _internal_has_variation(); +} +inline void Type_I32::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_I32::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_I32::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I32.variation) + return _internal_variation(); +} +inline void Type_I32::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.I32.variation) +} +inline ::io::substrait::Type_Variation* Type_I32::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_I32::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.I32.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_I32::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_I32::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.I32.variation) + return _internal_mutable_variation(); +} +inline void Type_I32::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.I32.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_I32::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_I32::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_I32::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I32.nullability) + return _internal_nullability(); +} +inline void Type_I32::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_I32::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.I32.nullability) +} + +// ------------------------------------------------------------------- + +// Type_I64 + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_I64::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_I64::has_variation() const { + return _internal_has_variation(); +} +inline void Type_I64::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_I64::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_I64::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I64.variation) + return _internal_variation(); +} +inline void Type_I64::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.I64.variation) +} +inline ::io::substrait::Type_Variation* Type_I64::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_I64::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.I64.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_I64::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_I64::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.I64.variation) + return _internal_mutable_variation(); +} +inline void Type_I64::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.I64.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_I64::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_I64::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_I64::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I64.nullability) + return _internal_nullability(); +} +inline void Type_I64::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_I64::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.I64.nullability) +} + +// ------------------------------------------------------------------- + +// Type_FP32 + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_FP32::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_FP32::has_variation() const { + return _internal_has_variation(); +} +inline void Type_FP32::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_FP32::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_FP32::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FP32.variation) + return _internal_variation(); +} +inline void Type_FP32::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.FP32.variation) +} +inline ::io::substrait::Type_Variation* Type_FP32::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_FP32::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.FP32.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_FP32::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_FP32::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.FP32.variation) + return _internal_mutable_variation(); +} +inline void Type_FP32::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.FP32.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_FP32::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_FP32::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_FP32::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FP32.nullability) + return _internal_nullability(); +} +inline void Type_FP32::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_FP32::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.FP32.nullability) +} + +// ------------------------------------------------------------------- + +// Type_FP64 + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_FP64::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_FP64::has_variation() const { + return _internal_has_variation(); +} +inline void Type_FP64::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_FP64::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_FP64::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FP64.variation) + return _internal_variation(); +} +inline void Type_FP64::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.FP64.variation) +} +inline ::io::substrait::Type_Variation* Type_FP64::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_FP64::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.FP64.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_FP64::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_FP64::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.FP64.variation) + return _internal_mutable_variation(); +} +inline void Type_FP64::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.FP64.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_FP64::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_FP64::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_FP64::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FP64.nullability) + return _internal_nullability(); +} +inline void Type_FP64::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_FP64::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.FP64.nullability) +} + +// ------------------------------------------------------------------- + +// Type_String + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_String::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_String::has_variation() const { + return _internal_has_variation(); +} +inline void Type_String::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_String::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_String::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.String.variation) + return _internal_variation(); +} +inline void Type_String::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.String.variation) +} +inline ::io::substrait::Type_Variation* Type_String::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_String::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.String.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_String::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_String::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.String.variation) + return _internal_mutable_variation(); +} +inline void Type_String::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.String.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_String::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_String::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_String::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.String.nullability) + return _internal_nullability(); +} +inline void Type_String::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_String::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.String.nullability) +} + +// ------------------------------------------------------------------- + +// Type_Binary + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_Binary::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_Binary::has_variation() const { + return _internal_has_variation(); +} +inline void Type_Binary::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_Binary::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_Binary::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Binary.variation) + return _internal_variation(); +} +inline void Type_Binary::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Binary.variation) +} +inline ::io::substrait::Type_Variation* Type_Binary::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_Binary::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Binary.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_Binary::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_Binary::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Binary.variation) + return _internal_mutable_variation(); +} +inline void Type_Binary::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Binary.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_Binary::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_Binary::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_Binary::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Binary.nullability) + return _internal_nullability(); +} +inline void Type_Binary::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_Binary::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Binary.nullability) +} + +// ------------------------------------------------------------------- + +// Type_Timestamp + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_Timestamp::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_Timestamp::has_variation() const { + return _internal_has_variation(); +} +inline void Type_Timestamp::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_Timestamp::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_Timestamp::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Timestamp.variation) + return _internal_variation(); +} +inline void Type_Timestamp::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Timestamp.variation) +} +inline ::io::substrait::Type_Variation* Type_Timestamp::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_Timestamp::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Timestamp.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_Timestamp::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_Timestamp::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Timestamp.variation) + return _internal_mutable_variation(); +} +inline void Type_Timestamp::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Timestamp.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_Timestamp::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_Timestamp::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_Timestamp::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Timestamp.nullability) + return _internal_nullability(); +} +inline void Type_Timestamp::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_Timestamp::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Timestamp.nullability) +} + +// ------------------------------------------------------------------- + +// Type_Date + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_Date::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_Date::has_variation() const { + return _internal_has_variation(); +} +inline void Type_Date::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_Date::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_Date::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Date.variation) + return _internal_variation(); +} +inline void Type_Date::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Date.variation) +} +inline ::io::substrait::Type_Variation* Type_Date::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_Date::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Date.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_Date::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_Date::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Date.variation) + return _internal_mutable_variation(); +} +inline void Type_Date::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Date.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_Date::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_Date::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_Date::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Date.nullability) + return _internal_nullability(); +} +inline void Type_Date::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_Date::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Date.nullability) +} + +// ------------------------------------------------------------------- + +// Type_Time + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_Time::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_Time::has_variation() const { + return _internal_has_variation(); +} +inline void Type_Time::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_Time::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_Time::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Time.variation) + return _internal_variation(); +} +inline void Type_Time::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Time.variation) +} +inline ::io::substrait::Type_Variation* Type_Time::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_Time::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Time.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_Time::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_Time::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Time.variation) + return _internal_mutable_variation(); +} +inline void Type_Time::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Time.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_Time::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_Time::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_Time::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Time.nullability) + return _internal_nullability(); +} +inline void Type_Time::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_Time::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Time.nullability) +} + +// ------------------------------------------------------------------- + +// Type_TimestampTZ + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_TimestampTZ::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_TimestampTZ::has_variation() const { + return _internal_has_variation(); +} +inline void Type_TimestampTZ::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_TimestampTZ::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_TimestampTZ::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.TimestampTZ.variation) + return _internal_variation(); +} +inline void Type_TimestampTZ::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.TimestampTZ.variation) +} +inline ::io::substrait::Type_Variation* Type_TimestampTZ::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_TimestampTZ::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.TimestampTZ.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_TimestampTZ::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_TimestampTZ::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.TimestampTZ.variation) + return _internal_mutable_variation(); +} +inline void Type_TimestampTZ::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.TimestampTZ.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_TimestampTZ::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_TimestampTZ::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_TimestampTZ::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.TimestampTZ.nullability) + return _internal_nullability(); +} +inline void Type_TimestampTZ::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_TimestampTZ::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.TimestampTZ.nullability) +} + +// ------------------------------------------------------------------- + +// Type_IntervalYear + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_IntervalYear::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_IntervalYear::has_variation() const { + return _internal_has_variation(); +} +inline void Type_IntervalYear::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_IntervalYear::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_IntervalYear::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalYear.variation) + return _internal_variation(); +} +inline void Type_IntervalYear::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.IntervalYear.variation) +} +inline ::io::substrait::Type_Variation* Type_IntervalYear::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_IntervalYear::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.IntervalYear.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_IntervalYear::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_IntervalYear::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.IntervalYear.variation) + return _internal_mutable_variation(); +} +inline void Type_IntervalYear::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.IntervalYear.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_IntervalYear::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_IntervalYear::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_IntervalYear::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalYear.nullability) + return _internal_nullability(); +} +inline void Type_IntervalYear::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_IntervalYear::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.IntervalYear.nullability) +} + +// ------------------------------------------------------------------- + +// Type_IntervalDay + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_IntervalDay::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_IntervalDay::has_variation() const { + return _internal_has_variation(); +} +inline void Type_IntervalDay::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_IntervalDay::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_IntervalDay::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalDay.variation) + return _internal_variation(); +} +inline void Type_IntervalDay::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.IntervalDay.variation) +} +inline ::io::substrait::Type_Variation* Type_IntervalDay::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_IntervalDay::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.IntervalDay.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_IntervalDay::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_IntervalDay::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.IntervalDay.variation) + return _internal_mutable_variation(); +} +inline void Type_IntervalDay::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.IntervalDay.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_IntervalDay::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_IntervalDay::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_IntervalDay::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalDay.nullability) + return _internal_nullability(); +} +inline void Type_IntervalDay::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_IntervalDay::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.IntervalDay.nullability) +} + +// ------------------------------------------------------------------- + +// Type_UUID + +// .io.substrait.Type.Variation variation = 1; +inline bool Type_UUID::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_UUID::has_variation() const { + return _internal_has_variation(); +} +inline void Type_UUID::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_UUID::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_UUID::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.UUID.variation) + return _internal_variation(); +} +inline void Type_UUID::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.UUID.variation) +} +inline ::io::substrait::Type_Variation* Type_UUID::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_UUID::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.UUID.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_UUID::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_UUID::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.UUID.variation) + return _internal_mutable_variation(); +} +inline void Type_UUID::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.UUID.variation) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_UUID::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_UUID::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_UUID::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.UUID.nullability) + return _internal_nullability(); +} +inline void Type_UUID::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_UUID::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.UUID.nullability) +} + +// ------------------------------------------------------------------- + +// Type_FixedChar + +// int32 length = 1; +inline void Type_FixedChar::clear_length() { + length_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedChar::_internal_length() const { + return length_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedChar::length() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FixedChar.length) + return _internal_length(); +} +inline void Type_FixedChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { + + length_ = value; +} +inline void Type_FixedChar::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_length(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.FixedChar.length) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool Type_FixedChar::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_FixedChar::has_variation() const { + return _internal_has_variation(); +} +inline void Type_FixedChar::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_FixedChar::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_FixedChar::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FixedChar.variation) + return _internal_variation(); +} +inline void Type_FixedChar::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.FixedChar.variation) +} +inline ::io::substrait::Type_Variation* Type_FixedChar::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_FixedChar::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.FixedChar.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_FixedChar::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_FixedChar::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.FixedChar.variation) + return _internal_mutable_variation(); +} +inline void Type_FixedChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.FixedChar.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void Type_FixedChar::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_FixedChar::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_FixedChar::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FixedChar.nullability) + return _internal_nullability(); +} +inline void Type_FixedChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_FixedChar::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.FixedChar.nullability) +} + +// ------------------------------------------------------------------- + +// Type_VarChar + +// int32 length = 1; +inline void Type_VarChar::clear_length() { + length_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_VarChar::_internal_length() const { + return length_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_VarChar::length() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.VarChar.length) + return _internal_length(); +} +inline void Type_VarChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { + + length_ = value; +} +inline void Type_VarChar::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_length(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.VarChar.length) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool Type_VarChar::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_VarChar::has_variation() const { + return _internal_has_variation(); +} +inline void Type_VarChar::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_VarChar::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_VarChar::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.VarChar.variation) + return _internal_variation(); +} +inline void Type_VarChar::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.VarChar.variation) +} +inline ::io::substrait::Type_Variation* Type_VarChar::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_VarChar::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.VarChar.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_VarChar::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_VarChar::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.VarChar.variation) + return _internal_mutable_variation(); +} +inline void Type_VarChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.VarChar.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void Type_VarChar::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_VarChar::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_VarChar::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.VarChar.nullability) + return _internal_nullability(); +} +inline void Type_VarChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_VarChar::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.VarChar.nullability) +} + +// ------------------------------------------------------------------- + +// Type_FixedBinary + +// int32 length = 1; +inline void Type_FixedBinary::clear_length() { + length_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedBinary::_internal_length() const { + return length_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedBinary::length() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FixedBinary.length) + return _internal_length(); +} +inline void Type_FixedBinary::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { + + length_ = value; +} +inline void Type_FixedBinary::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_length(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.FixedBinary.length) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool Type_FixedBinary::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_FixedBinary::has_variation() const { + return _internal_has_variation(); +} +inline void Type_FixedBinary::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_FixedBinary::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_FixedBinary::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FixedBinary.variation) + return _internal_variation(); +} +inline void Type_FixedBinary::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.FixedBinary.variation) +} +inline ::io::substrait::Type_Variation* Type_FixedBinary::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_FixedBinary::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.FixedBinary.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_FixedBinary::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_FixedBinary::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.FixedBinary.variation) + return _internal_mutable_variation(); +} +inline void Type_FixedBinary::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.FixedBinary.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void Type_FixedBinary::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_FixedBinary::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_FixedBinary::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FixedBinary.nullability) + return _internal_nullability(); +} +inline void Type_FixedBinary::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_FixedBinary::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.FixedBinary.nullability) +} + +// ------------------------------------------------------------------- + +// Type_Decimal + +// int32 scale = 1; +inline void Type_Decimal::clear_scale() { + scale_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::_internal_scale() const { + return scale_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::scale() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Decimal.scale) + return _internal_scale(); +} +inline void Type_Decimal::_internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { + + scale_ = value; +} +inline void Type_Decimal::set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Decimal.scale) +} + +// int32 precision = 2; +inline void Type_Decimal::clear_precision() { + precision_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::_internal_precision() const { + return precision_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::precision() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Decimal.precision) + return _internal_precision(); +} +inline void Type_Decimal::_internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { + + precision_ = value; +} +inline void Type_Decimal::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_precision(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Decimal.precision) +} + +// .io.substrait.Type.Variation variation = 3; +inline bool Type_Decimal::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_Decimal::has_variation() const { + return _internal_has_variation(); +} +inline void Type_Decimal::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_Decimal::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_Decimal::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Decimal.variation) + return _internal_variation(); +} +inline void Type_Decimal::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Decimal.variation) +} +inline ::io::substrait::Type_Variation* Type_Decimal::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_Decimal::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Decimal.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_Decimal::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_Decimal::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Decimal.variation) + return _internal_mutable_variation(); +} +inline void Type_Decimal::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Decimal.variation) +} + +// .io.substrait.Type.Nullability nullability = 4; +inline void Type_Decimal::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_Decimal::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_Decimal::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Decimal.nullability) + return _internal_nullability(); +} +inline void Type_Decimal::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_Decimal::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Decimal.nullability) +} + +// ------------------------------------------------------------------- + +// Type_Struct + +// repeated .io.substrait.Type types = 1; +inline int Type_Struct::_internal_types_size() const { + return types_.size(); +} +inline int Type_Struct::types_size() const { + return _internal_types_size(); +} +inline void Type_Struct::clear_types() { + types_.Clear(); +} +inline ::io::substrait::Type* Type_Struct::mutable_types(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Struct.types) + return types_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type >* +Type_Struct::mutable_types() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Type.Struct.types) + return &types_; +} +inline const ::io::substrait::Type& Type_Struct::_internal_types(int index) const { + return types_.Get(index); +} +inline const ::io::substrait::Type& Type_Struct::types(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Struct.types) + return _internal_types(index); +} +inline ::io::substrait::Type* Type_Struct::_internal_add_types() { + return types_.Add(); +} +inline ::io::substrait::Type* Type_Struct::add_types() { + // @@protoc_insertion_point(field_add:io.substrait.Type.Struct.types) + return _internal_add_types(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type >& +Type_Struct::types() const { + // @@protoc_insertion_point(field_list:io.substrait.Type.Struct.types) + return types_; +} + +// .io.substrait.Type.Variation variation = 2; +inline bool Type_Struct::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_Struct::has_variation() const { + return _internal_has_variation(); +} +inline void Type_Struct::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_Struct::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_Struct::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Struct.variation) + return _internal_variation(); +} +inline void Type_Struct::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Struct.variation) +} +inline ::io::substrait::Type_Variation* Type_Struct::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_Struct::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Struct.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_Struct::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_Struct::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Struct.variation) + return _internal_mutable_variation(); +} +inline void Type_Struct::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Struct.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void Type_Struct::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_Struct::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_Struct::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Struct.nullability) + return _internal_nullability(); +} +inline void Type_Struct::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_Struct::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Struct.nullability) +} + +// ------------------------------------------------------------------- + +// Type_NamedStruct + +// repeated string names = 1; +inline int Type_NamedStruct::_internal_names_size() const { + return names_.size(); +} +inline int Type_NamedStruct::names_size() const { + return _internal_names_size(); +} +inline void Type_NamedStruct::clear_names() { + names_.Clear(); +} +inline std::string* Type_NamedStruct::add_names() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Type.NamedStruct.names) + return _internal_add_names(); +} +inline const std::string& Type_NamedStruct::_internal_names(int index) const { + return names_.Get(index); +} +inline const std::string& Type_NamedStruct::names(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Type.NamedStruct.names) + return _internal_names(index); +} +inline std::string* Type_NamedStruct::mutable_names(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.NamedStruct.names) + return names_.Mutable(index); +} +inline void Type_NamedStruct::set_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Type.NamedStruct.names) + names_.Mutable(index)->assign(value); +} +inline void Type_NamedStruct::set_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Type.NamedStruct.names) + names_.Mutable(index)->assign(std::move(value)); +} +inline void Type_NamedStruct::set_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Type.NamedStruct.names) +} +inline void Type_NamedStruct::set_names(int index, const char* value, size_t size) { + names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Type.NamedStruct.names) +} +inline std::string* Type_NamedStruct::_internal_add_names() { + return names_.Add(); +} +inline void Type_NamedStruct::add_names(const std::string& value) { + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Type.NamedStruct.names) +} +inline void Type_NamedStruct::add_names(std::string&& value) { + names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Type.NamedStruct.names) +} +inline void Type_NamedStruct::add_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Type.NamedStruct.names) +} +inline void Type_NamedStruct::add_names(const char* value, size_t size) { + names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Type.NamedStruct.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Type_NamedStruct::names() const { + // @@protoc_insertion_point(field_list:io.substrait.Type.NamedStruct.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Type_NamedStruct::mutable_names() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Type.NamedStruct.names) + return &names_; +} + +// .io.substrait.Type.Struct struct = 2; +inline bool Type_NamedStruct::_internal_has_struct_() const { + return this != internal_default_instance() && struct__ != nullptr; +} +inline bool Type_NamedStruct::has_struct_() const { + return _internal_has_struct_(); +} +inline void Type_NamedStruct::clear_struct_() { + if (GetArena() == nullptr && struct__ != nullptr) { + delete struct__; + } + struct__ = nullptr; +} +inline const ::io::substrait::Type_Struct& Type_NamedStruct::_internal_struct_() const { + const ::io::substrait::Type_Struct* p = struct__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Struct_default_instance_); +} +inline const ::io::substrait::Type_Struct& Type_NamedStruct::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.NamedStruct.struct) + return _internal_struct_(); +} +inline void Type_NamedStruct::unsafe_arena_set_allocated_struct_( + ::io::substrait::Type_Struct* struct_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); + } + struct__ = struct_; + if (struct_) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.NamedStruct.struct) +} +inline ::io::substrait::Type_Struct* Type_NamedStruct::release_struct_() { + + ::io::substrait::Type_Struct* temp = struct__; + struct__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Struct* Type_NamedStruct::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.Type.NamedStruct.struct) + + ::io::substrait::Type_Struct* temp = struct__; + struct__ = nullptr; + return temp; +} +inline ::io::substrait::Type_Struct* Type_NamedStruct::_internal_mutable_struct_() { + + if (struct__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Struct>(GetArena()); + struct__ = p; + } + return struct__; +} +inline ::io::substrait::Type_Struct* Type_NamedStruct::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.NamedStruct.struct) + return _internal_mutable_struct_(); +} +inline void Type_NamedStruct::set_allocated_struct_(::io::substrait::Type_Struct* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete struct__; + } + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + + } else { + + } + struct__ = struct_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.NamedStruct.struct) +} + +// ------------------------------------------------------------------- + +// Type_List + +// .io.substrait.Type type = 1; +inline bool Type_List::_internal_has_type() const { + return this != internal_default_instance() && type_ != nullptr; +} +inline bool Type_List::has_type() const { + return _internal_has_type(); +} +inline void Type_List::clear_type() { + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; +} +inline const ::io::substrait::Type& Type_List::_internal_type() const { + const ::io::substrait::Type* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Type_List::type() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.List.type) + return _internal_type(); +} +inline void Type_List::unsafe_arena_set_allocated_type( + ::io::substrait::Type* type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); + } + type_ = type; + if (type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.List.type) +} +inline ::io::substrait::Type* Type_List::release_type() { + + ::io::substrait::Type* temp = type_; + type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* Type_List::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:io.substrait.Type.List.type) + + ::io::substrait::Type* temp = type_; + type_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Type_List::_internal_mutable_type() { + + if (type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + type_ = p; + } + return type_; +} +inline ::io::substrait::Type* Type_List::mutable_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.List.type) + return _internal_mutable_type(); +} +inline void Type_List::set_allocated_type(::io::substrait::Type* type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete type_; + } + if (type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type); + if (message_arena != submessage_arena) { + type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type, submessage_arena); + } + + } else { + + } + type_ = type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.List.type) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool Type_List::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_List::has_variation() const { + return _internal_has_variation(); +} +inline void Type_List::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_List::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_List::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.List.variation) + return _internal_variation(); +} +inline void Type_List::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.List.variation) +} +inline ::io::substrait::Type_Variation* Type_List::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_List::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.List.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_List::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_List::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.List.variation) + return _internal_mutable_variation(); +} +inline void Type_List::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.List.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void Type_List::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_List::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_List::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.List.nullability) + return _internal_nullability(); +} +inline void Type_List::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_List::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.List.nullability) +} + +// ------------------------------------------------------------------- + +// Type_Map + +// .io.substrait.Type key = 1; +inline bool Type_Map::_internal_has_key() const { + return this != internal_default_instance() && key_ != nullptr; +} +inline bool Type_Map::has_key() const { + return _internal_has_key(); +} +inline void Type_Map::clear_key() { + if (GetArena() == nullptr && key_ != nullptr) { + delete key_; + } + key_ = nullptr; +} +inline const ::io::substrait::Type& Type_Map::_internal_key() const { + const ::io::substrait::Type* p = key_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Type_Map::key() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Map.key) + return _internal_key(); +} +inline void Type_Map::unsafe_arena_set_allocated_key( + ::io::substrait::Type* key) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); + } + key_ = key; + if (key) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Map.key) +} +inline ::io::substrait::Type* Type_Map::release_key() { + + ::io::substrait::Type* temp = key_; + key_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* Type_Map::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Map.key) + + ::io::substrait::Type* temp = key_; + key_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Type_Map::_internal_mutable_key() { + + if (key_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + key_ = p; + } + return key_; +} +inline ::io::substrait::Type* Type_Map::mutable_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Map.key) + return _internal_mutable_key(); +} +inline void Type_Map::set_allocated_key(::io::substrait::Type* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + + } else { + + } + key_ = key; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Map.key) +} + +// .io.substrait.Type value = 2; +inline bool Type_Map::_internal_has_value() const { + return this != internal_default_instance() && value_ != nullptr; +} +inline bool Type_Map::has_value() const { + return _internal_has_value(); +} +inline void Type_Map::clear_value() { + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; +} +inline const ::io::substrait::Type& Type_Map::_internal_value() const { + const ::io::substrait::Type* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Type_Map::value() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Map.value) + return _internal_value(); +} +inline void Type_Map::unsafe_arena_set_allocated_value( + ::io::substrait::Type* value) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); + } + value_ = value; + if (value) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Map.value) +} +inline ::io::substrait::Type* Type_Map::release_value() { + + ::io::substrait::Type* temp = value_; + value_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* Type_Map::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Map.value) + + ::io::substrait::Type* temp = value_; + value_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Type_Map::_internal_mutable_value() { + + if (value_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + value_ = p; + } + return value_; +} +inline ::io::substrait::Type* Type_Map::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Map.value) + return _internal_mutable_value(); +} +inline void Type_Map::set_allocated_value(::io::substrait::Type* value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete value_; + } + if (value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + if (message_arena != submessage_arena) { + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); + } + + } else { + + } + value_ = value; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Map.value) +} + +// .io.substrait.Type.Variation variation = 3; +inline bool Type_Map::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool Type_Map::has_variation() const { + return _internal_has_variation(); +} +inline void Type_Map::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +inline const ::io::substrait::Type_Variation& Type_Map::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& Type_Map::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Map.variation) + return _internal_variation(); +} +inline void Type_Map::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Map.variation) +} +inline ::io::substrait::Type_Variation* Type_Map::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* Type_Map::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Map.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* Type_Map::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* Type_Map::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Map.variation) + return _internal_mutable_variation(); +} +inline void Type_Map::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete variation_; + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Map.variation) +} + +// .io.substrait.Type.Nullability nullability = 4; +inline void Type_Map::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_Map::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability Type_Map::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Map.nullability) + return _internal_nullability(); +} +inline void Type_Map::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void Type_Map::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Map.nullability) +} + +// ------------------------------------------------------------------- + +// Type_Variation + +// int32 organization = 1; +inline void Type_Variation::clear_organization() { + organization_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Variation::_internal_organization() const { + return organization_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Variation::organization() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Variation.organization) + return _internal_organization(); +} +inline void Type_Variation::_internal_set_organization(::PROTOBUF_NAMESPACE_ID::int32 value) { + + organization_ = value; +} +inline void Type_Variation::set_organization(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_organization(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Variation.organization) +} + +// string name = 2; +inline void Type_Variation::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& Type_Variation::name() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Variation.name) + return _internal_name(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Type_Variation::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Type.Variation.name) +} +inline std::string* Type_Variation::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.Variation.name) + return _internal_mutable_name(); +} +inline const std::string& Type_Variation::_internal_name() const { + return name_.Get(); +} +inline void Type_Variation::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Type_Variation::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Type_Variation::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.Type.Variation.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Type_Variation::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Variation.name) +} + +// ------------------------------------------------------------------- + +// Type + +// .io.substrait.Type.Boolean bool = 1; +inline bool Type::_internal_has_bool_() const { + return kind_case() == kBool; +} +inline bool Type::has_bool_() const { + return _internal_has_bool_(); +} +inline void Type::set_has_bool_() { + _oneof_case_[0] = kBool; +} +inline void Type::clear_bool_() { + if (_internal_has_bool_()) { + if (GetArena() == nullptr) { + delete kind_.bool__; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_Boolean* Type::release_bool_() { + // @@protoc_insertion_point(field_release:io.substrait.Type.bool) + if (_internal_has_bool_()) { + clear_has_kind(); + ::io::substrait::Type_Boolean* temp = kind_.bool__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.bool__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Boolean& Type::_internal_bool_() const { + return _internal_has_bool_() + ? *kind_.bool__ + : reinterpret_cast< ::io::substrait::Type_Boolean&>(::io::substrait::_Type_Boolean_default_instance_); +} +inline const ::io::substrait::Type_Boolean& Type::bool_() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.bool) + return _internal_bool_(); +} +inline ::io::substrait::Type_Boolean* Type::unsafe_arena_release_bool_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.bool) + if (_internal_has_bool_()) { + clear_has_kind(); + ::io::substrait::Type_Boolean* temp = kind_.bool__; + kind_.bool__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { + clear_kind(); + if (bool_) { + set_has_bool_(); + kind_.bool__ = bool_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.bool) +} +inline ::io::substrait::Type_Boolean* Type::_internal_mutable_bool_() { + if (!_internal_has_bool_()) { + clear_kind(); + set_has_bool_(); + kind_.bool__ = CreateMaybeMessage< ::io::substrait::Type_Boolean >(GetArena()); + } + return kind_.bool__; +} +inline ::io::substrait::Type_Boolean* Type::mutable_bool_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.bool) + return _internal_mutable_bool_(); +} + +// .io.substrait.Type.I8 i8 = 2; +inline bool Type::_internal_has_i8() const { + return kind_case() == kI8; +} +inline bool Type::has_i8() const { + return _internal_has_i8(); +} +inline void Type::set_has_i8() { + _oneof_case_[0] = kI8; +} +inline void Type::clear_i8() { + if (_internal_has_i8()) { + if (GetArena() == nullptr) { + delete kind_.i8_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_I8* Type::release_i8() { + // @@protoc_insertion_point(field_release:io.substrait.Type.i8) + if (_internal_has_i8()) { + clear_has_kind(); + ::io::substrait::Type_I8* temp = kind_.i8_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i8_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I8& Type::_internal_i8() const { + return _internal_has_i8() + ? *kind_.i8_ + : reinterpret_cast< ::io::substrait::Type_I8&>(::io::substrait::_Type_I8_default_instance_); +} +inline const ::io::substrait::Type_I8& Type::i8() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.i8) + return _internal_i8(); +} +inline ::io::substrait::Type_I8* Type::unsafe_arena_release_i8() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.i8) + if (_internal_has_i8()) { + clear_has_kind(); + ::io::substrait::Type_I8* temp = kind_.i8_; + kind_.i8_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_i8(::io::substrait::Type_I8* i8) { + clear_kind(); + if (i8) { + set_has_i8(); + kind_.i8_ = i8; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.i8) +} +inline ::io::substrait::Type_I8* Type::_internal_mutable_i8() { + if (!_internal_has_i8()) { + clear_kind(); + set_has_i8(); + kind_.i8_ = CreateMaybeMessage< ::io::substrait::Type_I8 >(GetArena()); + } + return kind_.i8_; +} +inline ::io::substrait::Type_I8* Type::mutable_i8() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.i8) + return _internal_mutable_i8(); +} + +// .io.substrait.Type.I16 i16 = 3; +inline bool Type::_internal_has_i16() const { + return kind_case() == kI16; +} +inline bool Type::has_i16() const { + return _internal_has_i16(); +} +inline void Type::set_has_i16() { + _oneof_case_[0] = kI16; +} +inline void Type::clear_i16() { + if (_internal_has_i16()) { + if (GetArena() == nullptr) { + delete kind_.i16_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_I16* Type::release_i16() { + // @@protoc_insertion_point(field_release:io.substrait.Type.i16) + if (_internal_has_i16()) { + clear_has_kind(); + ::io::substrait::Type_I16* temp = kind_.i16_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i16_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I16& Type::_internal_i16() const { + return _internal_has_i16() + ? *kind_.i16_ + : reinterpret_cast< ::io::substrait::Type_I16&>(::io::substrait::_Type_I16_default_instance_); +} +inline const ::io::substrait::Type_I16& Type::i16() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.i16) + return _internal_i16(); +} +inline ::io::substrait::Type_I16* Type::unsafe_arena_release_i16() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.i16) + if (_internal_has_i16()) { + clear_has_kind(); + ::io::substrait::Type_I16* temp = kind_.i16_; + kind_.i16_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_i16(::io::substrait::Type_I16* i16) { + clear_kind(); + if (i16) { + set_has_i16(); + kind_.i16_ = i16; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.i16) +} +inline ::io::substrait::Type_I16* Type::_internal_mutable_i16() { + if (!_internal_has_i16()) { + clear_kind(); + set_has_i16(); + kind_.i16_ = CreateMaybeMessage< ::io::substrait::Type_I16 >(GetArena()); + } + return kind_.i16_; +} +inline ::io::substrait::Type_I16* Type::mutable_i16() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.i16) + return _internal_mutable_i16(); +} + +// .io.substrait.Type.I32 i32 = 5; +inline bool Type::_internal_has_i32() const { + return kind_case() == kI32; +} +inline bool Type::has_i32() const { + return _internal_has_i32(); +} +inline void Type::set_has_i32() { + _oneof_case_[0] = kI32; +} +inline void Type::clear_i32() { + if (_internal_has_i32()) { + if (GetArena() == nullptr) { + delete kind_.i32_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_I32* Type::release_i32() { + // @@protoc_insertion_point(field_release:io.substrait.Type.i32) + if (_internal_has_i32()) { + clear_has_kind(); + ::io::substrait::Type_I32* temp = kind_.i32_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I32& Type::_internal_i32() const { + return _internal_has_i32() + ? *kind_.i32_ + : reinterpret_cast< ::io::substrait::Type_I32&>(::io::substrait::_Type_I32_default_instance_); +} +inline const ::io::substrait::Type_I32& Type::i32() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.i32) + return _internal_i32(); +} +inline ::io::substrait::Type_I32* Type::unsafe_arena_release_i32() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.i32) + if (_internal_has_i32()) { + clear_has_kind(); + ::io::substrait::Type_I32* temp = kind_.i32_; + kind_.i32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_i32(::io::substrait::Type_I32* i32) { + clear_kind(); + if (i32) { + set_has_i32(); + kind_.i32_ = i32; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.i32) +} +inline ::io::substrait::Type_I32* Type::_internal_mutable_i32() { + if (!_internal_has_i32()) { + clear_kind(); + set_has_i32(); + kind_.i32_ = CreateMaybeMessage< ::io::substrait::Type_I32 >(GetArena()); + } + return kind_.i32_; +} +inline ::io::substrait::Type_I32* Type::mutable_i32() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.i32) + return _internal_mutable_i32(); +} + +// .io.substrait.Type.I64 i64 = 7; +inline bool Type::_internal_has_i64() const { + return kind_case() == kI64; +} +inline bool Type::has_i64() const { + return _internal_has_i64(); +} +inline void Type::set_has_i64() { + _oneof_case_[0] = kI64; +} +inline void Type::clear_i64() { + if (_internal_has_i64()) { + if (GetArena() == nullptr) { + delete kind_.i64_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_I64* Type::release_i64() { + // @@protoc_insertion_point(field_release:io.substrait.Type.i64) + if (_internal_has_i64()) { + clear_has_kind(); + ::io::substrait::Type_I64* temp = kind_.i64_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I64& Type::_internal_i64() const { + return _internal_has_i64() + ? *kind_.i64_ + : reinterpret_cast< ::io::substrait::Type_I64&>(::io::substrait::_Type_I64_default_instance_); +} +inline const ::io::substrait::Type_I64& Type::i64() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.i64) + return _internal_i64(); +} +inline ::io::substrait::Type_I64* Type::unsafe_arena_release_i64() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.i64) + if (_internal_has_i64()) { + clear_has_kind(); + ::io::substrait::Type_I64* temp = kind_.i64_; + kind_.i64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_i64(::io::substrait::Type_I64* i64) { + clear_kind(); + if (i64) { + set_has_i64(); + kind_.i64_ = i64; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.i64) +} +inline ::io::substrait::Type_I64* Type::_internal_mutable_i64() { + if (!_internal_has_i64()) { + clear_kind(); + set_has_i64(); + kind_.i64_ = CreateMaybeMessage< ::io::substrait::Type_I64 >(GetArena()); + } + return kind_.i64_; +} +inline ::io::substrait::Type_I64* Type::mutable_i64() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.i64) + return _internal_mutable_i64(); +} + +// .io.substrait.Type.FP32 fp32 = 10; +inline bool Type::_internal_has_fp32() const { + return kind_case() == kFp32; +} +inline bool Type::has_fp32() const { + return _internal_has_fp32(); +} +inline void Type::set_has_fp32() { + _oneof_case_[0] = kFp32; +} +inline void Type::clear_fp32() { + if (_internal_has_fp32()) { + if (GetArena() == nullptr) { + delete kind_.fp32_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_FP32* Type::release_fp32() { + // @@protoc_insertion_point(field_release:io.substrait.Type.fp32) + if (_internal_has_fp32()) { + clear_has_kind(); + ::io::substrait::Type_FP32* temp = kind_.fp32_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fp32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_FP32& Type::_internal_fp32() const { + return _internal_has_fp32() + ? *kind_.fp32_ + : reinterpret_cast< ::io::substrait::Type_FP32&>(::io::substrait::_Type_FP32_default_instance_); +} +inline const ::io::substrait::Type_FP32& Type::fp32() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.fp32) + return _internal_fp32(); +} +inline ::io::substrait::Type_FP32* Type::unsafe_arena_release_fp32() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.fp32) + if (_internal_has_fp32()) { + clear_has_kind(); + ::io::substrait::Type_FP32* temp = kind_.fp32_; + kind_.fp32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_fp32(::io::substrait::Type_FP32* fp32) { + clear_kind(); + if (fp32) { + set_has_fp32(); + kind_.fp32_ = fp32; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.fp32) +} +inline ::io::substrait::Type_FP32* Type::_internal_mutable_fp32() { + if (!_internal_has_fp32()) { + clear_kind(); + set_has_fp32(); + kind_.fp32_ = CreateMaybeMessage< ::io::substrait::Type_FP32 >(GetArena()); + } + return kind_.fp32_; +} +inline ::io::substrait::Type_FP32* Type::mutable_fp32() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.fp32) + return _internal_mutable_fp32(); +} + +// .io.substrait.Type.FP64 fp64 = 11; +inline bool Type::_internal_has_fp64() const { + return kind_case() == kFp64; +} +inline bool Type::has_fp64() const { + return _internal_has_fp64(); +} +inline void Type::set_has_fp64() { + _oneof_case_[0] = kFp64; +} +inline void Type::clear_fp64() { + if (_internal_has_fp64()) { + if (GetArena() == nullptr) { + delete kind_.fp64_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_FP64* Type::release_fp64() { + // @@protoc_insertion_point(field_release:io.substrait.Type.fp64) + if (_internal_has_fp64()) { + clear_has_kind(); + ::io::substrait::Type_FP64* temp = kind_.fp64_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fp64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_FP64& Type::_internal_fp64() const { + return _internal_has_fp64() + ? *kind_.fp64_ + : reinterpret_cast< ::io::substrait::Type_FP64&>(::io::substrait::_Type_FP64_default_instance_); +} +inline const ::io::substrait::Type_FP64& Type::fp64() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.fp64) + return _internal_fp64(); +} +inline ::io::substrait::Type_FP64* Type::unsafe_arena_release_fp64() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.fp64) + if (_internal_has_fp64()) { + clear_has_kind(); + ::io::substrait::Type_FP64* temp = kind_.fp64_; + kind_.fp64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_fp64(::io::substrait::Type_FP64* fp64) { + clear_kind(); + if (fp64) { + set_has_fp64(); + kind_.fp64_ = fp64; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.fp64) +} +inline ::io::substrait::Type_FP64* Type::_internal_mutable_fp64() { + if (!_internal_has_fp64()) { + clear_kind(); + set_has_fp64(); + kind_.fp64_ = CreateMaybeMessage< ::io::substrait::Type_FP64 >(GetArena()); + } + return kind_.fp64_; +} +inline ::io::substrait::Type_FP64* Type::mutable_fp64() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.fp64) + return _internal_mutable_fp64(); +} + +// .io.substrait.Type.String string = 12; +inline bool Type::_internal_has_string() const { + return kind_case() == kString; +} +inline bool Type::has_string() const { + return _internal_has_string(); +} +inline void Type::set_has_string() { + _oneof_case_[0] = kString; +} +inline void Type::clear_string() { + if (_internal_has_string()) { + if (GetArena() == nullptr) { + delete kind_.string_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_String* Type::release_string() { + // @@protoc_insertion_point(field_release:io.substrait.Type.string) + if (_internal_has_string()) { + clear_has_kind(); + ::io::substrait::Type_String* temp = kind_.string_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.string_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_String& Type::_internal_string() const { + return _internal_has_string() + ? *kind_.string_ + : reinterpret_cast< ::io::substrait::Type_String&>(::io::substrait::_Type_String_default_instance_); +} +inline const ::io::substrait::Type_String& Type::string() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.string) + return _internal_string(); +} +inline ::io::substrait::Type_String* Type::unsafe_arena_release_string() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.string) + if (_internal_has_string()) { + clear_has_kind(); + ::io::substrait::Type_String* temp = kind_.string_; + kind_.string_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_string(::io::substrait::Type_String* string) { + clear_kind(); + if (string) { + set_has_string(); + kind_.string_ = string; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.string) +} +inline ::io::substrait::Type_String* Type::_internal_mutable_string() { + if (!_internal_has_string()) { + clear_kind(); + set_has_string(); + kind_.string_ = CreateMaybeMessage< ::io::substrait::Type_String >(GetArena()); + } + return kind_.string_; +} +inline ::io::substrait::Type_String* Type::mutable_string() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.string) + return _internal_mutable_string(); +} + +// .io.substrait.Type.Binary binary = 13; +inline bool Type::_internal_has_binary() const { + return kind_case() == kBinary; +} +inline bool Type::has_binary() const { + return _internal_has_binary(); +} +inline void Type::set_has_binary() { + _oneof_case_[0] = kBinary; +} +inline void Type::clear_binary() { + if (_internal_has_binary()) { + if (GetArena() == nullptr) { + delete kind_.binary_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_Binary* Type::release_binary() { + // @@protoc_insertion_point(field_release:io.substrait.Type.binary) + if (_internal_has_binary()) { + clear_has_kind(); + ::io::substrait::Type_Binary* temp = kind_.binary_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Binary& Type::_internal_binary() const { + return _internal_has_binary() + ? *kind_.binary_ + : reinterpret_cast< ::io::substrait::Type_Binary&>(::io::substrait::_Type_Binary_default_instance_); +} +inline const ::io::substrait::Type_Binary& Type::binary() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.binary) + return _internal_binary(); +} +inline ::io::substrait::Type_Binary* Type::unsafe_arena_release_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.binary) + if (_internal_has_binary()) { + clear_has_kind(); + ::io::substrait::Type_Binary* temp = kind_.binary_; + kind_.binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_binary(::io::substrait::Type_Binary* binary) { + clear_kind(); + if (binary) { + set_has_binary(); + kind_.binary_ = binary; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.binary) +} +inline ::io::substrait::Type_Binary* Type::_internal_mutable_binary() { + if (!_internal_has_binary()) { + clear_kind(); + set_has_binary(); + kind_.binary_ = CreateMaybeMessage< ::io::substrait::Type_Binary >(GetArena()); + } + return kind_.binary_; +} +inline ::io::substrait::Type_Binary* Type::mutable_binary() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.binary) + return _internal_mutable_binary(); +} + +// .io.substrait.Type.Timestamp timestamp = 14; +inline bool Type::_internal_has_timestamp() const { + return kind_case() == kTimestamp; +} +inline bool Type::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void Type::set_has_timestamp() { + _oneof_case_[0] = kTimestamp; +} +inline void Type::clear_timestamp() { + if (_internal_has_timestamp()) { + if (GetArena() == nullptr) { + delete kind_.timestamp_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_Timestamp* Type::release_timestamp() { + // @@protoc_insertion_point(field_release:io.substrait.Type.timestamp) + if (_internal_has_timestamp()) { + clear_has_kind(); + ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.timestamp_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Timestamp& Type::_internal_timestamp() const { + return _internal_has_timestamp() + ? *kind_.timestamp_ + : reinterpret_cast< ::io::substrait::Type_Timestamp&>(::io::substrait::_Type_Timestamp_default_instance_); +} +inline const ::io::substrait::Type_Timestamp& Type::timestamp() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.timestamp) + return _internal_timestamp(); +} +inline ::io::substrait::Type_Timestamp* Type::unsafe_arena_release_timestamp() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.timestamp) + if (_internal_has_timestamp()) { + clear_has_kind(); + ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + kind_.timestamp_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { + clear_kind(); + if (timestamp) { + set_has_timestamp(); + kind_.timestamp_ = timestamp; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.timestamp) +} +inline ::io::substrait::Type_Timestamp* Type::_internal_mutable_timestamp() { + if (!_internal_has_timestamp()) { + clear_kind(); + set_has_timestamp(); + kind_.timestamp_ = CreateMaybeMessage< ::io::substrait::Type_Timestamp >(GetArena()); + } + return kind_.timestamp_; +} +inline ::io::substrait::Type_Timestamp* Type::mutable_timestamp() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.timestamp) + return _internal_mutable_timestamp(); +} + +// .io.substrait.Type.Date date = 16; +inline bool Type::_internal_has_date() const { + return kind_case() == kDate; +} +inline bool Type::has_date() const { + return _internal_has_date(); +} +inline void Type::set_has_date() { + _oneof_case_[0] = kDate; +} +inline void Type::clear_date() { + if (_internal_has_date()) { + if (GetArena() == nullptr) { + delete kind_.date_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_Date* Type::release_date() { + // @@protoc_insertion_point(field_release:io.substrait.Type.date) + if (_internal_has_date()) { + clear_has_kind(); + ::io::substrait::Type_Date* temp = kind_.date_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.date_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Date& Type::_internal_date() const { + return _internal_has_date() + ? *kind_.date_ + : reinterpret_cast< ::io::substrait::Type_Date&>(::io::substrait::_Type_Date_default_instance_); +} +inline const ::io::substrait::Type_Date& Type::date() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.date) + return _internal_date(); +} +inline ::io::substrait::Type_Date* Type::unsafe_arena_release_date() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.date) + if (_internal_has_date()) { + clear_has_kind(); + ::io::substrait::Type_Date* temp = kind_.date_; + kind_.date_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_date(::io::substrait::Type_Date* date) { + clear_kind(); + if (date) { + set_has_date(); + kind_.date_ = date; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.date) +} +inline ::io::substrait::Type_Date* Type::_internal_mutable_date() { + if (!_internal_has_date()) { + clear_kind(); + set_has_date(); + kind_.date_ = CreateMaybeMessage< ::io::substrait::Type_Date >(GetArena()); + } + return kind_.date_; +} +inline ::io::substrait::Type_Date* Type::mutable_date() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.date) + return _internal_mutable_date(); +} + +// .io.substrait.Type.Time time = 17; +inline bool Type::_internal_has_time() const { + return kind_case() == kTime; +} +inline bool Type::has_time() const { + return _internal_has_time(); +} +inline void Type::set_has_time() { + _oneof_case_[0] = kTime; +} +inline void Type::clear_time() { + if (_internal_has_time()) { + if (GetArena() == nullptr) { + delete kind_.time_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_Time* Type::release_time() { + // @@protoc_insertion_point(field_release:io.substrait.Type.time) + if (_internal_has_time()) { + clear_has_kind(); + ::io::substrait::Type_Time* temp = kind_.time_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.time_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Time& Type::_internal_time() const { + return _internal_has_time() + ? *kind_.time_ + : reinterpret_cast< ::io::substrait::Type_Time&>(::io::substrait::_Type_Time_default_instance_); +} +inline const ::io::substrait::Type_Time& Type::time() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.time) + return _internal_time(); +} +inline ::io::substrait::Type_Time* Type::unsafe_arena_release_time() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.time) + if (_internal_has_time()) { + clear_has_kind(); + ::io::substrait::Type_Time* temp = kind_.time_; + kind_.time_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_time(::io::substrait::Type_Time* time) { + clear_kind(); + if (time) { + set_has_time(); + kind_.time_ = time; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.time) +} +inline ::io::substrait::Type_Time* Type::_internal_mutable_time() { + if (!_internal_has_time()) { + clear_kind(); + set_has_time(); + kind_.time_ = CreateMaybeMessage< ::io::substrait::Type_Time >(GetArena()); + } + return kind_.time_; +} +inline ::io::substrait::Type_Time* Type::mutable_time() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.time) + return _internal_mutable_time(); +} + +// .io.substrait.Type.IntervalYear interval_year = 19; +inline bool Type::_internal_has_interval_year() const { + return kind_case() == kIntervalYear; +} +inline bool Type::has_interval_year() const { + return _internal_has_interval_year(); +} +inline void Type::set_has_interval_year() { + _oneof_case_[0] = kIntervalYear; +} +inline void Type::clear_interval_year() { + if (_internal_has_interval_year()) { + if (GetArena() == nullptr) { + delete kind_.interval_year_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_IntervalYear* Type::release_interval_year() { + // @@protoc_insertion_point(field_release:io.substrait.Type.interval_year) + if (_internal_has_interval_year()) { + clear_has_kind(); + ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.interval_year_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_IntervalYear& Type::_internal_interval_year() const { + return _internal_has_interval_year() + ? *kind_.interval_year_ + : reinterpret_cast< ::io::substrait::Type_IntervalYear&>(::io::substrait::_Type_IntervalYear_default_instance_); +} +inline const ::io::substrait::Type_IntervalYear& Type::interval_year() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.interval_year) + return _internal_interval_year(); +} +inline ::io::substrait::Type_IntervalYear* Type::unsafe_arena_release_interval_year() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.interval_year) + if (_internal_has_interval_year()) { + clear_has_kind(); + ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + kind_.interval_year_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { + clear_kind(); + if (interval_year) { + set_has_interval_year(); + kind_.interval_year_ = interval_year; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.interval_year) +} +inline ::io::substrait::Type_IntervalYear* Type::_internal_mutable_interval_year() { + if (!_internal_has_interval_year()) { + clear_kind(); + set_has_interval_year(); + kind_.interval_year_ = CreateMaybeMessage< ::io::substrait::Type_IntervalYear >(GetArena()); + } + return kind_.interval_year_; +} +inline ::io::substrait::Type_IntervalYear* Type::mutable_interval_year() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.interval_year) + return _internal_mutable_interval_year(); +} + +// .io.substrait.Type.IntervalDay interval_day = 20; +inline bool Type::_internal_has_interval_day() const { + return kind_case() == kIntervalDay; +} +inline bool Type::has_interval_day() const { + return _internal_has_interval_day(); +} +inline void Type::set_has_interval_day() { + _oneof_case_[0] = kIntervalDay; +} +inline void Type::clear_interval_day() { + if (_internal_has_interval_day()) { + if (GetArena() == nullptr) { + delete kind_.interval_day_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_IntervalDay* Type::release_interval_day() { + // @@protoc_insertion_point(field_release:io.substrait.Type.interval_day) + if (_internal_has_interval_day()) { + clear_has_kind(); + ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.interval_day_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_IntervalDay& Type::_internal_interval_day() const { + return _internal_has_interval_day() + ? *kind_.interval_day_ + : reinterpret_cast< ::io::substrait::Type_IntervalDay&>(::io::substrait::_Type_IntervalDay_default_instance_); +} +inline const ::io::substrait::Type_IntervalDay& Type::interval_day() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.interval_day) + return _internal_interval_day(); +} +inline ::io::substrait::Type_IntervalDay* Type::unsafe_arena_release_interval_day() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.interval_day) + if (_internal_has_interval_day()) { + clear_has_kind(); + ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + kind_.interval_day_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { + clear_kind(); + if (interval_day) { + set_has_interval_day(); + kind_.interval_day_ = interval_day; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.interval_day) +} +inline ::io::substrait::Type_IntervalDay* Type::_internal_mutable_interval_day() { + if (!_internal_has_interval_day()) { + clear_kind(); + set_has_interval_day(); + kind_.interval_day_ = CreateMaybeMessage< ::io::substrait::Type_IntervalDay >(GetArena()); + } + return kind_.interval_day_; +} +inline ::io::substrait::Type_IntervalDay* Type::mutable_interval_day() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.interval_day) + return _internal_mutable_interval_day(); +} + +// .io.substrait.Type.TimestampTZ timestamp_tz = 29; +inline bool Type::_internal_has_timestamp_tz() const { + return kind_case() == kTimestampTz; +} +inline bool Type::has_timestamp_tz() const { + return _internal_has_timestamp_tz(); +} +inline void Type::set_has_timestamp_tz() { + _oneof_case_[0] = kTimestampTz; +} +inline void Type::clear_timestamp_tz() { + if (_internal_has_timestamp_tz()) { + if (GetArena() == nullptr) { + delete kind_.timestamp_tz_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_TimestampTZ* Type::release_timestamp_tz() { + // @@protoc_insertion_point(field_release:io.substrait.Type.timestamp_tz) + if (_internal_has_timestamp_tz()) { + clear_has_kind(); + ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.timestamp_tz_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_TimestampTZ& Type::_internal_timestamp_tz() const { + return _internal_has_timestamp_tz() + ? *kind_.timestamp_tz_ + : reinterpret_cast< ::io::substrait::Type_TimestampTZ&>(::io::substrait::_Type_TimestampTZ_default_instance_); +} +inline const ::io::substrait::Type_TimestampTZ& Type::timestamp_tz() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.timestamp_tz) + return _internal_timestamp_tz(); +} +inline ::io::substrait::Type_TimestampTZ* Type::unsafe_arena_release_timestamp_tz() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.timestamp_tz) + if (_internal_has_timestamp_tz()) { + clear_has_kind(); + ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + kind_.timestamp_tz_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { + clear_kind(); + if (timestamp_tz) { + set_has_timestamp_tz(); + kind_.timestamp_tz_ = timestamp_tz; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.timestamp_tz) +} +inline ::io::substrait::Type_TimestampTZ* Type::_internal_mutable_timestamp_tz() { + if (!_internal_has_timestamp_tz()) { + clear_kind(); + set_has_timestamp_tz(); + kind_.timestamp_tz_ = CreateMaybeMessage< ::io::substrait::Type_TimestampTZ >(GetArena()); + } + return kind_.timestamp_tz_; +} +inline ::io::substrait::Type_TimestampTZ* Type::mutable_timestamp_tz() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.timestamp_tz) + return _internal_mutable_timestamp_tz(); +} + +// .io.substrait.Type.UUID uuid = 32; +inline bool Type::_internal_has_uuid() const { + return kind_case() == kUuid; +} +inline bool Type::has_uuid() const { + return _internal_has_uuid(); +} +inline void Type::set_has_uuid() { + _oneof_case_[0] = kUuid; +} +inline void Type::clear_uuid() { + if (_internal_has_uuid()) { + if (GetArena() == nullptr) { + delete kind_.uuid_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_UUID* Type::release_uuid() { + // @@protoc_insertion_point(field_release:io.substrait.Type.uuid) + if (_internal_has_uuid()) { + clear_has_kind(); + ::io::substrait::Type_UUID* temp = kind_.uuid_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.uuid_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_UUID& Type::_internal_uuid() const { + return _internal_has_uuid() + ? *kind_.uuid_ + : reinterpret_cast< ::io::substrait::Type_UUID&>(::io::substrait::_Type_UUID_default_instance_); +} +inline const ::io::substrait::Type_UUID& Type::uuid() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.uuid) + return _internal_uuid(); +} +inline ::io::substrait::Type_UUID* Type::unsafe_arena_release_uuid() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.uuid) + if (_internal_has_uuid()) { + clear_has_kind(); + ::io::substrait::Type_UUID* temp = kind_.uuid_; + kind_.uuid_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_uuid(::io::substrait::Type_UUID* uuid) { + clear_kind(); + if (uuid) { + set_has_uuid(); + kind_.uuid_ = uuid; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.uuid) +} +inline ::io::substrait::Type_UUID* Type::_internal_mutable_uuid() { + if (!_internal_has_uuid()) { + clear_kind(); + set_has_uuid(); + kind_.uuid_ = CreateMaybeMessage< ::io::substrait::Type_UUID >(GetArena()); + } + return kind_.uuid_; +} +inline ::io::substrait::Type_UUID* Type::mutable_uuid() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.uuid) + return _internal_mutable_uuid(); +} + +// .io.substrait.Type.FixedChar fixed_char = 21; +inline bool Type::_internal_has_fixed_char() const { + return kind_case() == kFixedChar; +} +inline bool Type::has_fixed_char() const { + return _internal_has_fixed_char(); +} +inline void Type::set_has_fixed_char() { + _oneof_case_[0] = kFixedChar; +} +inline void Type::clear_fixed_char() { + if (_internal_has_fixed_char()) { + if (GetArena() == nullptr) { + delete kind_.fixed_char_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_FixedChar* Type::release_fixed_char() { + // @@protoc_insertion_point(field_release:io.substrait.Type.fixed_char) + if (_internal_has_fixed_char()) { + clear_has_kind(); + ::io::substrait::Type_FixedChar* temp = kind_.fixed_char_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fixed_char_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_FixedChar& Type::_internal_fixed_char() const { + return _internal_has_fixed_char() + ? *kind_.fixed_char_ + : reinterpret_cast< ::io::substrait::Type_FixedChar&>(::io::substrait::_Type_FixedChar_default_instance_); +} +inline const ::io::substrait::Type_FixedChar& Type::fixed_char() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.fixed_char) + return _internal_fixed_char(); +} +inline ::io::substrait::Type_FixedChar* Type::unsafe_arena_release_fixed_char() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.fixed_char) + if (_internal_has_fixed_char()) { + clear_has_kind(); + ::io::substrait::Type_FixedChar* temp = kind_.fixed_char_; + kind_.fixed_char_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_fixed_char(::io::substrait::Type_FixedChar* fixed_char) { + clear_kind(); + if (fixed_char) { + set_has_fixed_char(); + kind_.fixed_char_ = fixed_char; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.fixed_char) +} +inline ::io::substrait::Type_FixedChar* Type::_internal_mutable_fixed_char() { + if (!_internal_has_fixed_char()) { + clear_kind(); + set_has_fixed_char(); + kind_.fixed_char_ = CreateMaybeMessage< ::io::substrait::Type_FixedChar >(GetArena()); + } + return kind_.fixed_char_; +} +inline ::io::substrait::Type_FixedChar* Type::mutable_fixed_char() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.fixed_char) + return _internal_mutable_fixed_char(); +} + +// .io.substrait.Type.VarChar varchar = 22; +inline bool Type::_internal_has_varchar() const { + return kind_case() == kVarchar; +} +inline bool Type::has_varchar() const { + return _internal_has_varchar(); +} +inline void Type::set_has_varchar() { + _oneof_case_[0] = kVarchar; +} +inline void Type::clear_varchar() { + if (_internal_has_varchar()) { + if (GetArena() == nullptr) { + delete kind_.varchar_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_VarChar* Type::release_varchar() { + // @@protoc_insertion_point(field_release:io.substrait.Type.varchar) + if (_internal_has_varchar()) { + clear_has_kind(); + ::io::substrait::Type_VarChar* temp = kind_.varchar_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.varchar_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_VarChar& Type::_internal_varchar() const { + return _internal_has_varchar() + ? *kind_.varchar_ + : reinterpret_cast< ::io::substrait::Type_VarChar&>(::io::substrait::_Type_VarChar_default_instance_); +} +inline const ::io::substrait::Type_VarChar& Type::varchar() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.varchar) + return _internal_varchar(); +} +inline ::io::substrait::Type_VarChar* Type::unsafe_arena_release_varchar() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.varchar) + if (_internal_has_varchar()) { + clear_has_kind(); + ::io::substrait::Type_VarChar* temp = kind_.varchar_; + kind_.varchar_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_varchar(::io::substrait::Type_VarChar* varchar) { + clear_kind(); + if (varchar) { + set_has_varchar(); + kind_.varchar_ = varchar; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.varchar) +} +inline ::io::substrait::Type_VarChar* Type::_internal_mutable_varchar() { + if (!_internal_has_varchar()) { + clear_kind(); + set_has_varchar(); + kind_.varchar_ = CreateMaybeMessage< ::io::substrait::Type_VarChar >(GetArena()); + } + return kind_.varchar_; +} +inline ::io::substrait::Type_VarChar* Type::mutable_varchar() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.varchar) + return _internal_mutable_varchar(); +} + +// .io.substrait.Type.FixedBinary fixed_binary = 23; +inline bool Type::_internal_has_fixed_binary() const { + return kind_case() == kFixedBinary; +} +inline bool Type::has_fixed_binary() const { + return _internal_has_fixed_binary(); +} +inline void Type::set_has_fixed_binary() { + _oneof_case_[0] = kFixedBinary; +} +inline void Type::clear_fixed_binary() { + if (_internal_has_fixed_binary()) { + if (GetArena() == nullptr) { + delete kind_.fixed_binary_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_FixedBinary* Type::release_fixed_binary() { + // @@protoc_insertion_point(field_release:io.substrait.Type.fixed_binary) + if (_internal_has_fixed_binary()) { + clear_has_kind(); + ::io::substrait::Type_FixedBinary* temp = kind_.fixed_binary_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fixed_binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_FixedBinary& Type::_internal_fixed_binary() const { + return _internal_has_fixed_binary() + ? *kind_.fixed_binary_ + : reinterpret_cast< ::io::substrait::Type_FixedBinary&>(::io::substrait::_Type_FixedBinary_default_instance_); +} +inline const ::io::substrait::Type_FixedBinary& Type::fixed_binary() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.fixed_binary) + return _internal_fixed_binary(); +} +inline ::io::substrait::Type_FixedBinary* Type::unsafe_arena_release_fixed_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.fixed_binary) + if (_internal_has_fixed_binary()) { + clear_has_kind(); + ::io::substrait::Type_FixedBinary* temp = kind_.fixed_binary_; + kind_.fixed_binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_fixed_binary(::io::substrait::Type_FixedBinary* fixed_binary) { + clear_kind(); + if (fixed_binary) { + set_has_fixed_binary(); + kind_.fixed_binary_ = fixed_binary; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.fixed_binary) +} +inline ::io::substrait::Type_FixedBinary* Type::_internal_mutable_fixed_binary() { + if (!_internal_has_fixed_binary()) { + clear_kind(); + set_has_fixed_binary(); + kind_.fixed_binary_ = CreateMaybeMessage< ::io::substrait::Type_FixedBinary >(GetArena()); + } + return kind_.fixed_binary_; +} +inline ::io::substrait::Type_FixedBinary* Type::mutable_fixed_binary() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.fixed_binary) + return _internal_mutable_fixed_binary(); +} + +// .io.substrait.Type.Decimal decimal = 24; +inline bool Type::_internal_has_decimal() const { + return kind_case() == kDecimal; +} +inline bool Type::has_decimal() const { + return _internal_has_decimal(); +} +inline void Type::set_has_decimal() { + _oneof_case_[0] = kDecimal; +} +inline void Type::clear_decimal() { + if (_internal_has_decimal()) { + if (GetArena() == nullptr) { + delete kind_.decimal_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_Decimal* Type::release_decimal() { + // @@protoc_insertion_point(field_release:io.substrait.Type.decimal) + if (_internal_has_decimal()) { + clear_has_kind(); + ::io::substrait::Type_Decimal* temp = kind_.decimal_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.decimal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Decimal& Type::_internal_decimal() const { + return _internal_has_decimal() + ? *kind_.decimal_ + : reinterpret_cast< ::io::substrait::Type_Decimal&>(::io::substrait::_Type_Decimal_default_instance_); +} +inline const ::io::substrait::Type_Decimal& Type::decimal() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.decimal) + return _internal_decimal(); +} +inline ::io::substrait::Type_Decimal* Type::unsafe_arena_release_decimal() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.decimal) + if (_internal_has_decimal()) { + clear_has_kind(); + ::io::substrait::Type_Decimal* temp = kind_.decimal_; + kind_.decimal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_decimal(::io::substrait::Type_Decimal* decimal) { + clear_kind(); + if (decimal) { + set_has_decimal(); + kind_.decimal_ = decimal; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.decimal) +} +inline ::io::substrait::Type_Decimal* Type::_internal_mutable_decimal() { + if (!_internal_has_decimal()) { + clear_kind(); + set_has_decimal(); + kind_.decimal_ = CreateMaybeMessage< ::io::substrait::Type_Decimal >(GetArena()); + } + return kind_.decimal_; +} +inline ::io::substrait::Type_Decimal* Type::mutable_decimal() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.decimal) + return _internal_mutable_decimal(); +} + +// .io.substrait.Type.Struct struct = 25; +inline bool Type::_internal_has_struct_() const { + return kind_case() == kStruct; +} +inline bool Type::has_struct_() const { + return _internal_has_struct_(); +} +inline void Type::set_has_struct_() { + _oneof_case_[0] = kStruct; +} +inline void Type::clear_struct_() { + if (_internal_has_struct_()) { + if (GetArena() == nullptr) { + delete kind_.struct__; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_Struct* Type::release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.Type.struct) + if (_internal_has_struct_()) { + clear_has_kind(); + ::io::substrait::Type_Struct* temp = kind_.struct__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Struct& Type::_internal_struct_() const { + return _internal_has_struct_() + ? *kind_.struct__ + : reinterpret_cast< ::io::substrait::Type_Struct&>(::io::substrait::_Type_Struct_default_instance_); +} +inline const ::io::substrait::Type_Struct& Type::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.struct) + return _internal_struct_(); +} +inline ::io::substrait::Type_Struct* Type::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.struct) + if (_internal_has_struct_()) { + clear_has_kind(); + ::io::substrait::Type_Struct* temp = kind_.struct__; + kind_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_struct_(::io::substrait::Type_Struct* struct_) { + clear_kind(); + if (struct_) { + set_has_struct_(); + kind_.struct__ = struct_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.struct) +} +inline ::io::substrait::Type_Struct* Type::_internal_mutable_struct_() { + if (!_internal_has_struct_()) { + clear_kind(); + set_has_struct_(); + kind_.struct__ = CreateMaybeMessage< ::io::substrait::Type_Struct >(GetArena()); + } + return kind_.struct__; +} +inline ::io::substrait::Type_Struct* Type::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.struct) + return _internal_mutable_struct_(); +} + +// .io.substrait.Type.List list = 27; +inline bool Type::_internal_has_list() const { + return kind_case() == kList; +} +inline bool Type::has_list() const { + return _internal_has_list(); +} +inline void Type::set_has_list() { + _oneof_case_[0] = kList; +} +inline void Type::clear_list() { + if (_internal_has_list()) { + if (GetArena() == nullptr) { + delete kind_.list_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_List* Type::release_list() { + // @@protoc_insertion_point(field_release:io.substrait.Type.list) + if (_internal_has_list()) { + clear_has_kind(); + ::io::substrait::Type_List* temp = kind_.list_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_List& Type::_internal_list() const { + return _internal_has_list() + ? *kind_.list_ + : reinterpret_cast< ::io::substrait::Type_List&>(::io::substrait::_Type_List_default_instance_); +} +inline const ::io::substrait::Type_List& Type::list() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.list) + return _internal_list(); +} +inline ::io::substrait::Type_List* Type::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.list) + if (_internal_has_list()) { + clear_has_kind(); + ::io::substrait::Type_List* temp = kind_.list_; + kind_.list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_list(::io::substrait::Type_List* list) { + clear_kind(); + if (list) { + set_has_list(); + kind_.list_ = list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.list) +} +inline ::io::substrait::Type_List* Type::_internal_mutable_list() { + if (!_internal_has_list()) { + clear_kind(); + set_has_list(); + kind_.list_ = CreateMaybeMessage< ::io::substrait::Type_List >(GetArena()); + } + return kind_.list_; +} +inline ::io::substrait::Type_List* Type::mutable_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.list) + return _internal_mutable_list(); +} + +// .io.substrait.Type.Map map = 28; +inline bool Type::_internal_has_map() const { + return kind_case() == kMap; +} +inline bool Type::has_map() const { + return _internal_has_map(); +} +inline void Type::set_has_map() { + _oneof_case_[0] = kMap; +} +inline void Type::clear_map() { + if (_internal_has_map()) { + if (GetArena() == nullptr) { + delete kind_.map_; + } + clear_has_kind(); + } +} +inline ::io::substrait::Type_Map* Type::release_map() { + // @@protoc_insertion_point(field_release:io.substrait.Type.map) + if (_internal_has_map()) { + clear_has_kind(); + ::io::substrait::Type_Map* temp = kind_.map_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Map& Type::_internal_map() const { + return _internal_has_map() + ? *kind_.map_ + : reinterpret_cast< ::io::substrait::Type_Map&>(::io::substrait::_Type_Map_default_instance_); +} +inline const ::io::substrait::Type_Map& Type::map() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.map) + return _internal_map(); +} +inline ::io::substrait::Type_Map* Type::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.map) + if (_internal_has_map()) { + clear_has_kind(); + ::io::substrait::Type_Map* temp = kind_.map_; + kind_.map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_map(::io::substrait::Type_Map* map) { + clear_kind(); + if (map) { + set_has_map(); + kind_.map_ = map; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.map) +} +inline ::io::substrait::Type_Map* Type::_internal_mutable_map() { + if (!_internal_has_map()) { + clear_kind(); + set_has_map(); + kind_.map_ = CreateMaybeMessage< ::io::substrait::Type_Map >(GetArena()); + } + return kind_.map_; +} +inline ::io::substrait::Type_Map* Type::mutable_map() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.map) + return _internal_mutable_map(); +} + +// .io.substrait.Extensions.TypeId user_defined = 31; +inline bool Type::_internal_has_user_defined() const { + return kind_case() == kUserDefined; +} +inline bool Type::has_user_defined() const { + return _internal_has_user_defined(); +} +inline void Type::set_has_user_defined() { + _oneof_case_[0] = kUserDefined; +} +inline ::io::substrait::Extensions_TypeId* Type::release_user_defined() { + // @@protoc_insertion_point(field_release:io.substrait.Type.user_defined) + if (_internal_has_user_defined()) { + clear_has_kind(); + ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.user_defined_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Extensions_TypeId& Type::_internal_user_defined() const { + return _internal_has_user_defined() + ? *kind_.user_defined_ + : reinterpret_cast< ::io::substrait::Extensions_TypeId&>(::io::substrait::_Extensions_TypeId_default_instance_); +} +inline const ::io::substrait::Extensions_TypeId& Type::user_defined() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.user_defined) + return _internal_user_defined(); +} +inline ::io::substrait::Extensions_TypeId* Type::unsafe_arena_release_user_defined() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.user_defined) + if (_internal_has_user_defined()) { + clear_has_kind(); + ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; + kind_.user_defined_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Type::unsafe_arena_set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { + clear_kind(); + if (user_defined) { + set_has_user_defined(); + kind_.user_defined_ = user_defined; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.user_defined) +} +inline ::io::substrait::Extensions_TypeId* Type::_internal_mutable_user_defined() { + if (!_internal_has_user_defined()) { + clear_kind(); + set_has_user_defined(); + kind_.user_defined_ = CreateMaybeMessage< ::io::substrait::Extensions_TypeId >(GetArena()); + } + return kind_.user_defined_; +} +inline ::io::substrait::Extensions_TypeId* Type::mutable_user_defined() { + // @@protoc_insertion_point(field_mutable:io.substrait.Type.user_defined) + return _internal_mutable_user_defined(); +} + +inline bool Type::has_kind() const { + return kind_case() != KIND_NOT_SET; +} +inline void Type::clear_has_kind() { + _oneof_case_[0] = KIND_NOT_SET; +} +inline Type::KindCase Type::kind_case() const { + return Type::KindCase(_oneof_case_[0]); +} +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace substrait +} // namespace io + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::io::substrait::Type_Nullability> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::Type_Nullability>() { + return ::io::substrait::Type_Nullability_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_type_2eproto diff --git a/cpp/src/generated/substrait/type_expressions.pb.cc b/cpp/src/generated/substrait/type_expressions.pb.cc new file mode 100644 index 00000000000..295a00ef1e9 --- /dev/null +++ b/cpp/src/generated/substrait/type_expressions.pb.cc @@ -0,0 +1,5656 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: type_expressions.proto + +#include "type_expressions.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace io { +namespace substrait { +constexpr DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : length_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct DerivationExpression_ExpressionFixedCharDefaultTypeInternal { + constexpr DerivationExpression_ExpressionFixedCharDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_ExpressionFixedCharDefaultTypeInternal() {} + union { + DerivationExpression_ExpressionFixedChar _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionFixedCharDefaultTypeInternal _DerivationExpression_ExpressionFixedChar_default_instance_; +constexpr DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : length_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct DerivationExpression_ExpressionVarCharDefaultTypeInternal { + constexpr DerivationExpression_ExpressionVarCharDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_ExpressionVarCharDefaultTypeInternal() {} + union { + DerivationExpression_ExpressionVarChar _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionVarCharDefaultTypeInternal _DerivationExpression_ExpressionVarChar_default_instance_; +constexpr DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : length_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal { + constexpr DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal() {} + union { + DerivationExpression_ExpressionFixedBinary _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal _DerivationExpression_ExpressionFixedBinary_default_instance_; +constexpr DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : scale_(nullptr) + , precision_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct DerivationExpression_ExpressionDecimalDefaultTypeInternal { + constexpr DerivationExpression_ExpressionDecimalDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_ExpressionDecimalDefaultTypeInternal() {} + union { + DerivationExpression_ExpressionDecimal _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionDecimalDefaultTypeInternal _DerivationExpression_ExpressionDecimal_default_instance_; +constexpr DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : types_() + , variation_(nullptr) + , nullability_(0) +{} +struct DerivationExpression_ExpressionStructDefaultTypeInternal { + constexpr DerivationExpression_ExpressionStructDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_ExpressionStructDefaultTypeInternal() {} + union { + DerivationExpression_ExpressionStruct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionStructDefaultTypeInternal _DerivationExpression_ExpressionStruct_default_instance_; +constexpr DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : names_() + , struct__(nullptr){} +struct DerivationExpression_ExpressionNamedStructDefaultTypeInternal { + constexpr DerivationExpression_ExpressionNamedStructDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_ExpressionNamedStructDefaultTypeInternal() {} + union { + DerivationExpression_ExpressionNamedStruct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionNamedStructDefaultTypeInternal _DerivationExpression_ExpressionNamedStruct_default_instance_; +constexpr DerivationExpression_ExpressionList::DerivationExpression_ExpressionList( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : type_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct DerivationExpression_ExpressionListDefaultTypeInternal { + constexpr DerivationExpression_ExpressionListDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_ExpressionListDefaultTypeInternal() {} + union { + DerivationExpression_ExpressionList _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionListDefaultTypeInternal _DerivationExpression_ExpressionList_default_instance_; +constexpr DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : key_(nullptr) + , value_(nullptr) + , variation_(nullptr) + , nullability_(0) +{} +struct DerivationExpression_ExpressionMapDefaultTypeInternal { + constexpr DerivationExpression_ExpressionMapDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_ExpressionMapDefaultTypeInternal() {} + union { + DerivationExpression_ExpressionMap _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionMapDefaultTypeInternal _DerivationExpression_ExpressionMap_default_instance_; +constexpr DerivationExpression_IfElse::DerivationExpression_IfElse( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : if_condition_(nullptr) + , if_return_(nullptr) + , else_return_(nullptr){} +struct DerivationExpression_IfElseDefaultTypeInternal { + constexpr DerivationExpression_IfElseDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_IfElseDefaultTypeInternal() {} + union { + DerivationExpression_IfElse _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_IfElseDefaultTypeInternal _DerivationExpression_IfElse_default_instance_; +constexpr DerivationExpression_UnaryOp::DerivationExpression_UnaryOp( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : arg_(nullptr) + , op_type_(0) +{} +struct DerivationExpression_UnaryOpDefaultTypeInternal { + constexpr DerivationExpression_UnaryOpDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_UnaryOpDefaultTypeInternal() {} + union { + DerivationExpression_UnaryOp _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_UnaryOpDefaultTypeInternal _DerivationExpression_UnaryOp_default_instance_; +constexpr DerivationExpression_BinaryOp::DerivationExpression_BinaryOp( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : arg1_(nullptr) + , arg2_(nullptr) + , op_type_(0) +{} +struct DerivationExpression_BinaryOpDefaultTypeInternal { + constexpr DerivationExpression_BinaryOpDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_BinaryOpDefaultTypeInternal() {} + union { + DerivationExpression_BinaryOp _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_BinaryOpDefaultTypeInternal _DerivationExpression_BinaryOp_default_instance_; +constexpr DerivationExpression::DerivationExpression( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct DerivationExpressionDefaultTypeInternal { + constexpr DerivationExpressionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpressionDefaultTypeInternal() {} + union { + DerivationExpression _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpressionDefaultTypeInternal _DerivationExpression_default_instance_; +} // namespace substrait +} // namespace io +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_type_5fexpressions_2eproto[12]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_type_5fexpressions_2eproto[2]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_type_5fexpressions_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, length_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, length_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, length_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, scale_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, precision_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, types_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionNamedStruct, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionNamedStruct, names_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionNamedStruct, struct__), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, key_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, value_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, nullability_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_IfElse, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_IfElse, if_condition_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_IfElse, if_return_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_IfElse, else_return_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_UnaryOp, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_UnaryOp, op_type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_UnaryOp, arg_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_BinaryOp, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_BinaryOp, op_type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_BinaryOp, arg1_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_BinaryOp, arg2_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression, kind_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::io::substrait::DerivationExpression_ExpressionFixedChar)}, + { 8, -1, sizeof(::io::substrait::DerivationExpression_ExpressionVarChar)}, + { 16, -1, sizeof(::io::substrait::DerivationExpression_ExpressionFixedBinary)}, + { 24, -1, sizeof(::io::substrait::DerivationExpression_ExpressionDecimal)}, + { 33, -1, sizeof(::io::substrait::DerivationExpression_ExpressionStruct)}, + { 41, -1, sizeof(::io::substrait::DerivationExpression_ExpressionNamedStruct)}, + { 48, -1, sizeof(::io::substrait::DerivationExpression_ExpressionList)}, + { 56, -1, sizeof(::io::substrait::DerivationExpression_ExpressionMap)}, + { 65, -1, sizeof(::io::substrait::DerivationExpression_IfElse)}, + { 73, -1, sizeof(::io::substrait::DerivationExpression_UnaryOp)}, + { 80, -1, sizeof(::io::substrait::DerivationExpression_BinaryOp)}, + { 88, -1, sizeof(::io::substrait::DerivationExpression)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionVarChar_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionDecimal_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionStruct_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionNamedStruct_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionList_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionMap_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_IfElse_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_UnaryOp_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_BinaryOp_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_default_instance_), +}; + +const char descriptor_table_protodef_type_5fexpressions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\026type_expressions.proto\022\014io.substrait\032\n" + "type.proto\032\020extensions.proto\"\217\035\n\024Derivat" + "ionExpression\022*\n\004bool\030\001 \001(\0132\032.io.substra" + "it.Type.BooleanH\000\022#\n\002i8\030\002 \001(\0132\025.io.subst" + "rait.Type.I8H\000\022%\n\003i16\030\003 \001(\0132\026.io.substra" + "it.Type.I16H\000\022%\n\003i32\030\005 \001(\0132\026.io.substrai" + "t.Type.I32H\000\022%\n\003i64\030\007 \001(\0132\026.io.substrait" + ".Type.I64H\000\022\'\n\004fp32\030\n \001(\0132\027.io.substrait" + ".Type.FP32H\000\022\'\n\004fp64\030\013 \001(\0132\027.io.substrai" + "t.Type.FP64H\000\022+\n\006string\030\014 \001(\0132\031.io.subst" + "rait.Type.StringH\000\022+\n\006binary\030\r \001(\0132\031.io." + "substrait.Type.BinaryH\000\0221\n\ttimestamp\030\016 \001" + "(\0132\034.io.substrait.Type.TimestampH\000\022\'\n\004da" + "te\030\020 \001(\0132\027.io.substrait.Type.DateH\000\022\'\n\004t" + "ime\030\021 \001(\0132\027.io.substrait.Type.TimeH\000\0228\n\r" + "interval_year\030\023 \001(\0132\037.io.substrait.Type." + "IntervalYearH\000\0226\n\014interval_day\030\024 \001(\0132\036.i" + "o.substrait.Type.IntervalDayH\000\0226\n\014timest" + "amp_tz\030\035 \001(\0132\036.io.substrait.Type.Timesta" + "mpTZH\000\022\'\n\004uuid\030 \001(\0132\027.io.substrait.Type" + ".UUIDH\000\022L\n\nfixed_char\030\025 \001(\01326.io.substra" + "it.DerivationExpression.ExpressionFixedC" + "harH\000\022G\n\007varchar\030\026 \001(\01324.io.substrait.De" + "rivationExpression.ExpressionVarCharH\000\022P" + "\n\014fixed_binary\030\027 \001(\01328.io.substrait.Deri" + "vationExpression.ExpressionFixedBinaryH\000" + "\022G\n\007decimal\030\030 \001(\01324.io.substrait.Derivat" + "ionExpression.ExpressionDecimalH\000\022E\n\006str" + "uct\030\031 \001(\01323.io.substrait.DerivationExpre" + "ssion.ExpressionStructH\000\022A\n\004list\030\033 \001(\01321" + ".io.substrait.DerivationExpression.Expre" + "ssionListH\000\022\?\n\003map\030\034 \001(\01320.io.substrait." + "DerivationExpression.ExpressionMapH\000\0227\n\014" + "user_defined\030\037 \001(\0132\037.io.substrait.Extens" + "ions.TypeIdH\000\022\035\n\023type_parameter_name\030! \001" + "(\tH\000\022 \n\026integer_parameter_name\030\" \001(\tH\000\022\031" + "\n\017integer_literal\030# \001(\005H\000\022>\n\010unary_op\030$ " + "\001(\0132*.io.substrait.DerivationExpression." + "UnaryOpH\000\022@\n\tbinary_op\030% \001(\0132+.io.substr" + "ait.DerivationExpression.BinaryOpH\000\022<\n\007i" + "f_else\030& \001(\0132).io.substrait.DerivationEx" + "pression.IfElseH\000\032\257\001\n\023ExpressionFixedCha" + "r\0222\n\006length\030\001 \001(\0132\".io.substrait.Derivat" + "ionExpression\022/\n\tvariation\030\002 \001(\0132\034.io.su" + "bstrait.Type.Variation\0223\n\013nullability\030\003 " + "\001(\0162\036.io.substrait.Type.Nullability\032\255\001\n\021" + "ExpressionVarChar\0222\n\006length\030\001 \001(\0132\".io.s" + "ubstrait.DerivationExpression\022/\n\tvariati" + "on\030\002 \001(\0132\034.io.substrait.Type.Variation\0223" + "\n\013nullability\030\003 \001(\0162\036.io.substrait.Type." + "Nullability\032\261\001\n\025ExpressionFixedBinary\0222\n" + "\006length\030\001 \001(\0132\".io.substrait.DerivationE" + "xpression\022/\n\tvariation\030\002 \001(\0132\034.io.substr" + "ait.Type.Variation\0223\n\013nullability\030\003 \001(\0162" + "\036.io.substrait.Type.Nullability\032\343\001\n\021Expr" + "essionDecimal\0221\n\005scale\030\001 \001(\0132\".io.substr" + "ait.DerivationExpression\0225\n\tprecision\030\002 " + "\001(\0132\".io.substrait.DerivationExpression\022" + "/\n\tvariation\030\003 \001(\0132\034.io.substrait.Type.V" + "ariation\0223\n\013nullability\030\004 \001(\0162\036.io.subst" + "rait.Type.Nullability\032\253\001\n\020ExpressionStru" + "ct\0221\n\005types\030\001 \003(\0132\".io.substrait.Derivat" + "ionExpression\022/\n\tvariation\030\002 \001(\0132\034.io.su" + "bstrait.Type.Variation\0223\n\013nullability\030\003 " + "\001(\0162\036.io.substrait.Type.Nullability\032k\n\025E" + "xpressionNamedStruct\022\r\n\005names\030\001 \003(\t\022C\n\006s" + "truct\030\002 \001(\01323.io.substrait.DerivationExp" + "ression.ExpressionStruct\032\250\001\n\016ExpressionL" + "ist\0220\n\004type\030\001 \001(\0132\".io.substrait.Derivat" + "ionExpression\022/\n\tvariation\030\002 \001(\0132\034.io.su" + "bstrait.Type.Variation\0223\n\013nullability\030\003 " + "\001(\0162\036.io.substrait.Type.Nullability\032\331\001\n\r" + "ExpressionMap\022/\n\003key\030\001 \001(\0132\".io.substrai" + "t.DerivationExpression\0221\n\005value\030\002 \001(\0132\"." + "io.substrait.DerivationExpression\022/\n\tvar" + "iation\030\003 \001(\0132\034.io.substrait.Type.Variati" + "on\0223\n\013nullability\030\004 \001(\0162\036.io.substrait.T" + "ype.Nullability\032\262\001\n\006IfElse\0228\n\014if_conditi" + "on\030\001 \001(\0132\".io.substrait.DerivationExpres" + "sion\0225\n\tif_return\030\002 \001(\0132\".io.substrait.D" + "erivationExpression\0227\n\013else_return\030\003 \001(\013" + "2\".io.substrait.DerivationExpression\032\246\001\n" + "\007UnaryOp\022B\n\007op_type\030\001 \001(\01621.io.substrait" + ".DerivationExpression.UnaryOp.OpType\022/\n\003" + "arg\030\002 \001(\0132\".io.substrait.DerivationExpre" + "ssion\"&\n\006OpType\022\013\n\007UNKNOWN\020\000\022\017\n\013BOOLEAN_" + "NOT\020\001\032\326\002\n\010BinaryOp\022C\n\007op_type\030\001 \001(\01622.io" + ".substrait.DerivationExpression.BinaryOp" + ".OpType\0220\n\004arg1\030\002 \001(\0132\".io.substrait.Der" + "ivationExpression\0220\n\004arg2\030\003 \001(\0132\".io.sub" + "strait.DerivationExpression\"\240\001\n\006OpType\022\013" + "\n\007UNKNOWN\020\000\022\010\n\004PLUS\020\001\022\t\n\005MINUS\020\002\022\014\n\010MULT" + "IPLY\020\003\022\n\n\006DIVIDE\020\004\022\007\n\003MIN\020\005\022\007\n\003MAX\020\006\022\020\n\014" + "GREATER_THAN\020\007\022\r\n\tLESS_THAN\020\010\022\007\n\003AND\020\t\022\006" + "\n\002OR\020\n\022\n\n\006EQUALS\020\013\022\n\n\006COVERS\020\014B\006\n\004kindB\027" + "P\001\252\002\022Substrait.Protobufb\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_type_5fexpressions_2eproto_deps[2] = { + &::descriptor_table_extensions_2eproto, + &::descriptor_table_type_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_type_5fexpressions_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_5fexpressions_2eproto = { + false, false, 3831, descriptor_table_protodef_type_5fexpressions_2eproto, "type_expressions.proto", + &descriptor_table_type_5fexpressions_2eproto_once, descriptor_table_type_5fexpressions_2eproto_deps, 2, 12, + schemas, file_default_instances, TableStruct_type_5fexpressions_2eproto::offsets, + file_level_metadata_type_5fexpressions_2eproto, file_level_enum_descriptors_type_5fexpressions_2eproto, file_level_service_descriptors_type_5fexpressions_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_type_5fexpressions_2eproto_getter() { + return &descriptor_table_type_5fexpressions_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_type_5fexpressions_2eproto(&descriptor_table_type_5fexpressions_2eproto); +namespace io { +namespace substrait { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_OpType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_type_5fexpressions_2eproto); + return file_level_enum_descriptors_type_5fexpressions_2eproto[0]; +} +bool DerivationExpression_UnaryOp_OpType_IsValid(int value) { + switch (value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::UNKNOWN; +constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::BOOLEAN_NOT; +constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::OpType_MIN; +constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::OpType_MAX; +constexpr int DerivationExpression_UnaryOp::OpType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_OpType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_type_5fexpressions_2eproto); + return file_level_enum_descriptors_type_5fexpressions_2eproto[1]; +} +bool DerivationExpression_BinaryOp_OpType_IsValid(int value) { + switch (value) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + case 10: + case 11: + case 12: + return true; + default: + return false; + } +} + +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::UNKNOWN; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::PLUS; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::MINUS; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::MULTIPLY; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::DIVIDE; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::MIN; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::MAX; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::GREATER_THAN; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::LESS_THAN; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::AND; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::OR; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::EQUALS; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::COVERS; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::OpType_MIN; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::OpType_MAX; +constexpr int DerivationExpression_BinaryOp::OpType_ARRAYSIZE; +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) + +// =================================================================== + +class DerivationExpression_ExpressionFixedChar::_Internal { + public: + static const ::io::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedChar* msg); + static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionFixedChar* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_ExpressionFixedChar::_Internal::length(const DerivationExpression_ExpressionFixedChar* msg) { + return *msg->length_; +} +const ::io::substrait::Type_Variation& +DerivationExpression_ExpressionFixedChar::_Internal::variation(const DerivationExpression_ExpressionFixedChar* msg) { + return *msg->variation_; +} +void DerivationExpression_ExpressionFixedChar::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionFixedChar) +} +DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(const DerivationExpression_ExpressionFixedChar& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_length()) { + length_ = new ::io::substrait::DerivationExpression(*from.length_); + } else { + length_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionFixedChar) +} + +void DerivationExpression_ExpressionFixedChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); +} + +DerivationExpression_ExpressionFixedChar::~DerivationExpression_ExpressionFixedChar() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionFixedChar) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_ExpressionFixedChar::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete length_; + if (this != internal_default_instance()) delete variation_; +} + +void DerivationExpression_ExpressionFixedChar::ArenaDtor(void* object) { + DerivationExpression_ExpressionFixedChar* _this = reinterpret_cast< DerivationExpression_ExpressionFixedChar* >(object); + (void)_this; +} +void DerivationExpression_ExpressionFixedChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_ExpressionFixedChar::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_ExpressionFixedChar::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionFixedChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_ExpressionFixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.DerivationExpression length = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedChar::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionFixedChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.DerivationExpression length = 1; + if (this->has_length()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::length(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionFixedChar) + return target; +} + +size_t DerivationExpression_ExpressionFixedChar::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionFixedChar) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.DerivationExpression length = 1; + if (this->has_length()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *length_); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_ExpressionFixedChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionFixedChar) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_ExpressionFixedChar* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionFixedChar) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionFixedChar) + MergeFrom(*source); + } +} + +void DerivationExpression_ExpressionFixedChar::MergeFrom(const DerivationExpression_ExpressionFixedChar& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionFixedChar) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_length()) { + _internal_mutable_length()->::io::substrait::DerivationExpression::MergeFrom(from._internal_length()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void DerivationExpression_ExpressionFixedChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionFixedChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_ExpressionFixedChar::CopyFrom(const DerivationExpression_ExpressionFixedChar& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionFixedChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_ExpressionFixedChar::IsInitialized() const { + return true; +} + +void DerivationExpression_ExpressionFixedChar::InternalSwap(DerivationExpression_ExpressionFixedChar* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedChar, nullability_) + + sizeof(DerivationExpression_ExpressionFixedChar::nullability_) + - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedChar, length_)>( + reinterpret_cast(&length_), + reinterpret_cast(&other->length_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedChar::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[0]); +} + +// =================================================================== + +class DerivationExpression_ExpressionVarChar::_Internal { + public: + static const ::io::substrait::DerivationExpression& length(const DerivationExpression_ExpressionVarChar* msg); + static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionVarChar* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_ExpressionVarChar::_Internal::length(const DerivationExpression_ExpressionVarChar* msg) { + return *msg->length_; +} +const ::io::substrait::Type_Variation& +DerivationExpression_ExpressionVarChar::_Internal::variation(const DerivationExpression_ExpressionVarChar* msg) { + return *msg->variation_; +} +void DerivationExpression_ExpressionVarChar::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionVarChar) +} +DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(const DerivationExpression_ExpressionVarChar& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_length()) { + length_ = new ::io::substrait::DerivationExpression(*from.length_); + } else { + length_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionVarChar) +} + +void DerivationExpression_ExpressionVarChar::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); +} + +DerivationExpression_ExpressionVarChar::~DerivationExpression_ExpressionVarChar() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionVarChar) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_ExpressionVarChar::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete length_; + if (this != internal_default_instance()) delete variation_; +} + +void DerivationExpression_ExpressionVarChar::ArenaDtor(void* object) { + DerivationExpression_ExpressionVarChar* _this = reinterpret_cast< DerivationExpression_ExpressionVarChar* >(object); + (void)_this; +} +void DerivationExpression_ExpressionVarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_ExpressionVarChar::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_ExpressionVarChar::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionVarChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_ExpressionVarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.DerivationExpression length = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionVarChar::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionVarChar) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.DerivationExpression length = 1; + if (this->has_length()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::length(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionVarChar) + return target; +} + +size_t DerivationExpression_ExpressionVarChar::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionVarChar) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.DerivationExpression length = 1; + if (this->has_length()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *length_); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_ExpressionVarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionVarChar) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_ExpressionVarChar* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionVarChar) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionVarChar) + MergeFrom(*source); + } +} + +void DerivationExpression_ExpressionVarChar::MergeFrom(const DerivationExpression_ExpressionVarChar& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionVarChar) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_length()) { + _internal_mutable_length()->::io::substrait::DerivationExpression::MergeFrom(from._internal_length()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void DerivationExpression_ExpressionVarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionVarChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_ExpressionVarChar::CopyFrom(const DerivationExpression_ExpressionVarChar& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionVarChar) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_ExpressionVarChar::IsInitialized() const { + return true; +} + +void DerivationExpression_ExpressionVarChar::InternalSwap(DerivationExpression_ExpressionVarChar* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionVarChar, nullability_) + + sizeof(DerivationExpression_ExpressionVarChar::nullability_) + - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionVarChar, length_)>( + reinterpret_cast(&length_), + reinterpret_cast(&other->length_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionVarChar::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[1]); +} + +// =================================================================== + +class DerivationExpression_ExpressionFixedBinary::_Internal { + public: + static const ::io::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedBinary* msg); + static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionFixedBinary* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_ExpressionFixedBinary::_Internal::length(const DerivationExpression_ExpressionFixedBinary* msg) { + return *msg->length_; +} +const ::io::substrait::Type_Variation& +DerivationExpression_ExpressionFixedBinary::_Internal::variation(const DerivationExpression_ExpressionFixedBinary* msg) { + return *msg->variation_; +} +void DerivationExpression_ExpressionFixedBinary::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionFixedBinary) +} +DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(const DerivationExpression_ExpressionFixedBinary& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_length()) { + length_ = new ::io::substrait::DerivationExpression(*from.length_); + } else { + length_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionFixedBinary) +} + +void DerivationExpression_ExpressionFixedBinary::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&length_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&length_)) + sizeof(nullability_)); +} + +DerivationExpression_ExpressionFixedBinary::~DerivationExpression_ExpressionFixedBinary() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionFixedBinary) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_ExpressionFixedBinary::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete length_; + if (this != internal_default_instance()) delete variation_; +} + +void DerivationExpression_ExpressionFixedBinary::ArenaDtor(void* object) { + DerivationExpression_ExpressionFixedBinary* _this = reinterpret_cast< DerivationExpression_ExpressionFixedBinary* >(object); + (void)_this; +} +void DerivationExpression_ExpressionFixedBinary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_ExpressionFixedBinary::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_ExpressionFixedBinary::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionFixedBinary) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_ExpressionFixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.DerivationExpression length = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedBinary::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionFixedBinary) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.DerivationExpression length = 1; + if (this->has_length()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::length(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionFixedBinary) + return target; +} + +size_t DerivationExpression_ExpressionFixedBinary::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionFixedBinary) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.DerivationExpression length = 1; + if (this->has_length()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *length_); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_ExpressionFixedBinary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionFixedBinary) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_ExpressionFixedBinary* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionFixedBinary) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionFixedBinary) + MergeFrom(*source); + } +} + +void DerivationExpression_ExpressionFixedBinary::MergeFrom(const DerivationExpression_ExpressionFixedBinary& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionFixedBinary) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_length()) { + _internal_mutable_length()->::io::substrait::DerivationExpression::MergeFrom(from._internal_length()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void DerivationExpression_ExpressionFixedBinary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionFixedBinary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_ExpressionFixedBinary::CopyFrom(const DerivationExpression_ExpressionFixedBinary& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionFixedBinary) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_ExpressionFixedBinary::IsInitialized() const { + return true; +} + +void DerivationExpression_ExpressionFixedBinary::InternalSwap(DerivationExpression_ExpressionFixedBinary* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedBinary, nullability_) + + sizeof(DerivationExpression_ExpressionFixedBinary::nullability_) + - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedBinary, length_)>( + reinterpret_cast(&length_), + reinterpret_cast(&other->length_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedBinary::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[2]); +} + +// =================================================================== + +class DerivationExpression_ExpressionDecimal::_Internal { + public: + static const ::io::substrait::DerivationExpression& scale(const DerivationExpression_ExpressionDecimal* msg); + static const ::io::substrait::DerivationExpression& precision(const DerivationExpression_ExpressionDecimal* msg); + static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionDecimal* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_ExpressionDecimal::_Internal::scale(const DerivationExpression_ExpressionDecimal* msg) { + return *msg->scale_; +} +const ::io::substrait::DerivationExpression& +DerivationExpression_ExpressionDecimal::_Internal::precision(const DerivationExpression_ExpressionDecimal* msg) { + return *msg->precision_; +} +const ::io::substrait::Type_Variation& +DerivationExpression_ExpressionDecimal::_Internal::variation(const DerivationExpression_ExpressionDecimal* msg) { + return *msg->variation_; +} +void DerivationExpression_ExpressionDecimal::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionDecimal) +} +DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(const DerivationExpression_ExpressionDecimal& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_scale()) { + scale_ = new ::io::substrait::DerivationExpression(*from.scale_); + } else { + scale_ = nullptr; + } + if (from._internal_has_precision()) { + precision_ = new ::io::substrait::DerivationExpression(*from.precision_); + } else { + precision_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionDecimal) +} + +void DerivationExpression_ExpressionDecimal::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&scale_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&scale_)) + sizeof(nullability_)); +} + +DerivationExpression_ExpressionDecimal::~DerivationExpression_ExpressionDecimal() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionDecimal) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_ExpressionDecimal::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete scale_; + if (this != internal_default_instance()) delete precision_; + if (this != internal_default_instance()) delete variation_; +} + +void DerivationExpression_ExpressionDecimal::ArenaDtor(void* object) { + DerivationExpression_ExpressionDecimal* _this = reinterpret_cast< DerivationExpression_ExpressionDecimal* >(object); + (void)_this; +} +void DerivationExpression_ExpressionDecimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_ExpressionDecimal::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_ExpressionDecimal::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionDecimal) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && scale_ != nullptr) { + delete scale_; + } + scale_ = nullptr; + if (GetArena() == nullptr && precision_ != nullptr) { + delete precision_; + } + precision_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_ExpressionDecimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.DerivationExpression scale = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression precision = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionDecimal::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionDecimal) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.DerivationExpression scale = 1; + if (this->has_scale()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::scale(this), target, stream); + } + + // .io.substrait.DerivationExpression precision = 2; + if (this->has_precision()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::precision(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionDecimal) + return target; +} + +size_t DerivationExpression_ExpressionDecimal::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionDecimal) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.DerivationExpression scale = 1; + if (this->has_scale()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *scale_); + } + + // .io.substrait.DerivationExpression precision = 2; + if (this->has_precision()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *precision_); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_ExpressionDecimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionDecimal) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_ExpressionDecimal* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionDecimal) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionDecimal) + MergeFrom(*source); + } +} + +void DerivationExpression_ExpressionDecimal::MergeFrom(const DerivationExpression_ExpressionDecimal& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionDecimal) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_scale()) { + _internal_mutable_scale()->::io::substrait::DerivationExpression::MergeFrom(from._internal_scale()); + } + if (from.has_precision()) { + _internal_mutable_precision()->::io::substrait::DerivationExpression::MergeFrom(from._internal_precision()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void DerivationExpression_ExpressionDecimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionDecimal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_ExpressionDecimal::CopyFrom(const DerivationExpression_ExpressionDecimal& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionDecimal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_ExpressionDecimal::IsInitialized() const { + return true; +} + +void DerivationExpression_ExpressionDecimal::InternalSwap(DerivationExpression_ExpressionDecimal* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionDecimal, nullability_) + + sizeof(DerivationExpression_ExpressionDecimal::nullability_) + - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionDecimal, scale_)>( + reinterpret_cast(&scale_), + reinterpret_cast(&other->scale_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionDecimal::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[3]); +} + +// =================================================================== + +class DerivationExpression_ExpressionStruct::_Internal { + public: + static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionStruct* msg); +}; + +const ::io::substrait::Type_Variation& +DerivationExpression_ExpressionStruct::_Internal::variation(const DerivationExpression_ExpressionStruct* msg) { + return *msg->variation_; +} +void DerivationExpression_ExpressionStruct::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + types_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionStruct) +} +DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(const DerivationExpression_ExpressionStruct& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + types_(from.types_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionStruct) +} + +void DerivationExpression_ExpressionStruct::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&variation_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_)) + sizeof(nullability_)); +} + +DerivationExpression_ExpressionStruct::~DerivationExpression_ExpressionStruct() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionStruct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_ExpressionStruct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete variation_; +} + +void DerivationExpression_ExpressionStruct::ArenaDtor(void* object) { + DerivationExpression_ExpressionStruct* _this = reinterpret_cast< DerivationExpression_ExpressionStruct* >(object); + (void)_this; +} +void DerivationExpression_ExpressionStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_ExpressionStruct::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_ExpressionStruct::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + types_.Clear(); + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_ExpressionStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.DerivationExpression types = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_types(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionStruct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.DerivationExpression types = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_types_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_types(i), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionStruct) + return target; +} + +size_t DerivationExpression_ExpressionStruct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionStruct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.DerivationExpression types = 1; + total_size += 1UL * this->_internal_types_size(); + for (const auto& msg : this->types_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_ExpressionStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionStruct) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_ExpressionStruct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionStruct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionStruct) + MergeFrom(*source); + } +} + +void DerivationExpression_ExpressionStruct::MergeFrom(const DerivationExpression_ExpressionStruct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionStruct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + types_.MergeFrom(from.types_); + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void DerivationExpression_ExpressionStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_ExpressionStruct::CopyFrom(const DerivationExpression_ExpressionStruct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_ExpressionStruct::IsInitialized() const { + return true; +} + +void DerivationExpression_ExpressionStruct::InternalSwap(DerivationExpression_ExpressionStruct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + types_.InternalSwap(&other->types_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, nullability_) + + sizeof(DerivationExpression_ExpressionStruct::nullability_) + - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, variation_)>( + reinterpret_cast(&variation_), + reinterpret_cast(&other->variation_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionStruct::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[4]); +} + +// =================================================================== + +class DerivationExpression_ExpressionNamedStruct::_Internal { + public: + static const ::io::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression_ExpressionNamedStruct* msg); +}; + +const ::io::substrait::DerivationExpression_ExpressionStruct& +DerivationExpression_ExpressionNamedStruct::_Internal::struct_(const DerivationExpression_ExpressionNamedStruct* msg) { + return *msg->struct__; +} +DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + names_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionNamedStruct) +} +DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(const DerivationExpression_ExpressionNamedStruct& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + names_(from.names_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_struct_()) { + struct__ = new ::io::substrait::DerivationExpression_ExpressionStruct(*from.struct__); + } else { + struct__ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionNamedStruct) +} + +void DerivationExpression_ExpressionNamedStruct::SharedCtor() { +struct__ = nullptr; +} + +DerivationExpression_ExpressionNamedStruct::~DerivationExpression_ExpressionNamedStruct() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionNamedStruct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_ExpressionNamedStruct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete struct__; +} + +void DerivationExpression_ExpressionNamedStruct::ArenaDtor(void* object) { + DerivationExpression_ExpressionNamedStruct* _this = reinterpret_cast< DerivationExpression_ExpressionNamedStruct* >(object); + (void)_this; +} +void DerivationExpression_ExpressionNamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_ExpressionNamedStruct::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_ExpressionNamedStruct::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionNamedStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + names_.Clear(); + if (GetArena() == nullptr && struct__ != nullptr) { + delete struct__; + } + struct__ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_ExpressionNamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string names = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_names(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.DerivationExpression.ExpressionNamedStruct.names")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.ExpressionStruct struct = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionNamedStruct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionNamedStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string names = 1; + for (int i = 0, n = this->_internal_names_size(); i < n; i++) { + const auto& s = this->_internal_names(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.DerivationExpression.ExpressionNamedStruct.names"); + target = stream->WriteString(1, s, target); + } + + // .io.substrait.DerivationExpression.ExpressionStruct struct = 2; + if (this->has_struct_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::struct_(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionNamedStruct) + return target; +} + +size_t DerivationExpression_ExpressionNamedStruct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionNamedStruct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string names = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); + for (int i = 0, n = names_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + names_.Get(i)); + } + + // .io.substrait.DerivationExpression.ExpressionStruct struct = 2; + if (this->has_struct_()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *struct__); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_ExpressionNamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionNamedStruct) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_ExpressionNamedStruct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionNamedStruct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionNamedStruct) + MergeFrom(*source); + } +} + +void DerivationExpression_ExpressionNamedStruct::MergeFrom(const DerivationExpression_ExpressionNamedStruct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionNamedStruct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + names_.MergeFrom(from.names_); + if (from.has_struct_()) { + _internal_mutable_struct_()->::io::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); + } +} + +void DerivationExpression_ExpressionNamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionNamedStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_ExpressionNamedStruct::CopyFrom(const DerivationExpression_ExpressionNamedStruct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionNamedStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_ExpressionNamedStruct::IsInitialized() const { + return true; +} + +void DerivationExpression_ExpressionNamedStruct::InternalSwap(DerivationExpression_ExpressionNamedStruct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + names_.InternalSwap(&other->names_); + swap(struct__, other->struct__); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionNamedStruct::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[5]); +} + +// =================================================================== + +class DerivationExpression_ExpressionList::_Internal { + public: + static const ::io::substrait::DerivationExpression& type(const DerivationExpression_ExpressionList* msg); + static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionList* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_ExpressionList::_Internal::type(const DerivationExpression_ExpressionList* msg) { + return *msg->type_; +} +const ::io::substrait::Type_Variation& +DerivationExpression_ExpressionList::_Internal::variation(const DerivationExpression_ExpressionList* msg) { + return *msg->variation_; +} +void DerivationExpression_ExpressionList::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionList) +} +DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(const DerivationExpression_ExpressionList& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_type()) { + type_ = new ::io::substrait::DerivationExpression(*from.type_); + } else { + type_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionList) +} + +void DerivationExpression_ExpressionList::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_)) + sizeof(nullability_)); +} + +DerivationExpression_ExpressionList::~DerivationExpression_ExpressionList() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionList) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_ExpressionList::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete type_; + if (this != internal_default_instance()) delete variation_; +} + +void DerivationExpression_ExpressionList::ArenaDtor(void* object) { + DerivationExpression_ExpressionList* _this = reinterpret_cast< DerivationExpression_ExpressionList* >(object); + (void)_this; +} +void DerivationExpression_ExpressionList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_ExpressionList::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_ExpressionList::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_ExpressionList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.DerivationExpression type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionList::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionList) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.DerivationExpression type = 1; + if (this->has_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::type(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionList) + return target; +} + +size_t DerivationExpression_ExpressionList::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionList) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.DerivationExpression type = 1; + if (this->has_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_); + } + + // .io.substrait.Type.Variation variation = 2; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 3; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_ExpressionList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionList) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_ExpressionList* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionList) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionList) + MergeFrom(*source); + } +} + +void DerivationExpression_ExpressionList::MergeFrom(const DerivationExpression_ExpressionList& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionList) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_type()) { + _internal_mutable_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_type()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void DerivationExpression_ExpressionList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_ExpressionList::CopyFrom(const DerivationExpression_ExpressionList& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionList) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_ExpressionList::IsInitialized() const { + return true; +} + +void DerivationExpression_ExpressionList::InternalSwap(DerivationExpression_ExpressionList* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionList, nullability_) + + sizeof(DerivationExpression_ExpressionList::nullability_) + - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionList, type_)>( + reinterpret_cast(&type_), + reinterpret_cast(&other->type_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionList::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[6]); +} + +// =================================================================== + +class DerivationExpression_ExpressionMap::_Internal { + public: + static const ::io::substrait::DerivationExpression& key(const DerivationExpression_ExpressionMap* msg); + static const ::io::substrait::DerivationExpression& value(const DerivationExpression_ExpressionMap* msg); + static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionMap* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_ExpressionMap::_Internal::key(const DerivationExpression_ExpressionMap* msg) { + return *msg->key_; +} +const ::io::substrait::DerivationExpression& +DerivationExpression_ExpressionMap::_Internal::value(const DerivationExpression_ExpressionMap* msg) { + return *msg->value_; +} +const ::io::substrait::Type_Variation& +DerivationExpression_ExpressionMap::_Internal::variation(const DerivationExpression_ExpressionMap* msg) { + return *msg->variation_; +} +void DerivationExpression_ExpressionMap::clear_variation() { + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; +} +DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionMap) +} +DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(const DerivationExpression_ExpressionMap& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_key()) { + key_ = new ::io::substrait::DerivationExpression(*from.key_); + } else { + key_ = nullptr; + } + if (from._internal_has_value()) { + value_ = new ::io::substrait::DerivationExpression(*from.value_); + } else { + value_ = nullptr; + } + if (from._internal_has_variation()) { + variation_ = new ::io::substrait::Type_Variation(*from.variation_); + } else { + variation_ = nullptr; + } + nullability_ = from.nullability_; + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionMap) +} + +void DerivationExpression_ExpressionMap::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&key_)) + sizeof(nullability_)); +} + +DerivationExpression_ExpressionMap::~DerivationExpression_ExpressionMap() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionMap) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_ExpressionMap::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete key_; + if (this != internal_default_instance()) delete value_; + if (this != internal_default_instance()) delete variation_; +} + +void DerivationExpression_ExpressionMap::ArenaDtor(void* object) { + DerivationExpression_ExpressionMap* _this = reinterpret_cast< DerivationExpression_ExpressionMap* >(object); + (void)_this; +} +void DerivationExpression_ExpressionMap::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_ExpressionMap::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_ExpressionMap::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionMap) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && key_ != nullptr) { + delete key_; + } + key_ = nullptr; + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; + if (GetArena() == nullptr && variation_ != nullptr) { + delete variation_; + } + variation_ = nullptr; + nullability_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_ExpressionMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.DerivationExpression key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression value = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Variation variation = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Nullability nullability = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionMap::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionMap) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.DerivationExpression key = 1; + if (this->has_key()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::key(this), target, stream); + } + + // .io.substrait.DerivationExpression value = 2; + if (this->has_value()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::value(this), target, stream); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::variation(this), target, stream); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_nullability(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionMap) + return target; +} + +size_t DerivationExpression_ExpressionMap::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionMap) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.DerivationExpression key = 1; + if (this->has_key()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *key_); + } + + // .io.substrait.DerivationExpression value = 2; + if (this->has_value()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_); + } + + // .io.substrait.Type.Variation variation = 3; + if (this->has_variation()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *variation_); + } + + // .io.substrait.Type.Nullability nullability = 4; + if (this->nullability() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_ExpressionMap::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionMap) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_ExpressionMap* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionMap) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionMap) + MergeFrom(*source); + } +} + +void DerivationExpression_ExpressionMap::MergeFrom(const DerivationExpression_ExpressionMap& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionMap) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_key()) { + _internal_mutable_key()->::io::substrait::DerivationExpression::MergeFrom(from._internal_key()); + } + if (from.has_value()) { + _internal_mutable_value()->::io::substrait::DerivationExpression::MergeFrom(from._internal_value()); + } + if (from.has_variation()) { + _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); + } +} + +void DerivationExpression_ExpressionMap::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionMap) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_ExpressionMap::CopyFrom(const DerivationExpression_ExpressionMap& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionMap) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_ExpressionMap::IsInitialized() const { + return true; +} + +void DerivationExpression_ExpressionMap::InternalSwap(DerivationExpression_ExpressionMap* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionMap, nullability_) + + sizeof(DerivationExpression_ExpressionMap::nullability_) + - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionMap, key_)>( + reinterpret_cast(&key_), + reinterpret_cast(&other->key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionMap::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[7]); +} + +// =================================================================== + +class DerivationExpression_IfElse::_Internal { + public: + static const ::io::substrait::DerivationExpression& if_condition(const DerivationExpression_IfElse* msg); + static const ::io::substrait::DerivationExpression& if_return(const DerivationExpression_IfElse* msg); + static const ::io::substrait::DerivationExpression& else_return(const DerivationExpression_IfElse* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_IfElse::_Internal::if_condition(const DerivationExpression_IfElse* msg) { + return *msg->if_condition_; +} +const ::io::substrait::DerivationExpression& +DerivationExpression_IfElse::_Internal::if_return(const DerivationExpression_IfElse* msg) { + return *msg->if_return_; +} +const ::io::substrait::DerivationExpression& +DerivationExpression_IfElse::_Internal::else_return(const DerivationExpression_IfElse* msg) { + return *msg->else_return_; +} +DerivationExpression_IfElse::DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.IfElse) +} +DerivationExpression_IfElse::DerivationExpression_IfElse(const DerivationExpression_IfElse& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_if_condition()) { + if_condition_ = new ::io::substrait::DerivationExpression(*from.if_condition_); + } else { + if_condition_ = nullptr; + } + if (from._internal_has_if_return()) { + if_return_ = new ::io::substrait::DerivationExpression(*from.if_return_); + } else { + if_return_ = nullptr; + } + if (from._internal_has_else_return()) { + else_return_ = new ::io::substrait::DerivationExpression(*from.else_return_); + } else { + else_return_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.IfElse) +} + +void DerivationExpression_IfElse::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&if_condition_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&else_return_) - + reinterpret_cast(&if_condition_)) + sizeof(else_return_)); +} + +DerivationExpression_IfElse::~DerivationExpression_IfElse() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.IfElse) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_IfElse::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete if_condition_; + if (this != internal_default_instance()) delete if_return_; + if (this != internal_default_instance()) delete else_return_; +} + +void DerivationExpression_IfElse::ArenaDtor(void* object) { + DerivationExpression_IfElse* _this = reinterpret_cast< DerivationExpression_IfElse* >(object); + (void)_this; +} +void DerivationExpression_IfElse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_IfElse::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_IfElse::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.IfElse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && if_condition_ != nullptr) { + delete if_condition_; + } + if_condition_ = nullptr; + if (GetArena() == nullptr && if_return_ != nullptr) { + delete if_return_; + } + if_return_ = nullptr; + if (GetArena() == nullptr && else_return_ != nullptr) { + delete else_return_; + } + else_return_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_IfElse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.DerivationExpression if_condition = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_if_condition(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression if_return = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_if_return(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression else_return = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_else_return(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_IfElse::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.IfElse) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.DerivationExpression if_condition = 1; + if (this->has_if_condition()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::if_condition(this), target, stream); + } + + // .io.substrait.DerivationExpression if_return = 2; + if (this->has_if_return()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::if_return(this), target, stream); + } + + // .io.substrait.DerivationExpression else_return = 3; + if (this->has_else_return()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::else_return(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.IfElse) + return target; +} + +size_t DerivationExpression_IfElse::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.IfElse) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.DerivationExpression if_condition = 1; + if (this->has_if_condition()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *if_condition_); + } + + // .io.substrait.DerivationExpression if_return = 2; + if (this->has_if_return()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *if_return_); + } + + // .io.substrait.DerivationExpression else_return = 3; + if (this->has_else_return()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *else_return_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_IfElse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.IfElse) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_IfElse* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.IfElse) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.IfElse) + MergeFrom(*source); + } +} + +void DerivationExpression_IfElse::MergeFrom(const DerivationExpression_IfElse& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.IfElse) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_if_condition()) { + _internal_mutable_if_condition()->::io::substrait::DerivationExpression::MergeFrom(from._internal_if_condition()); + } + if (from.has_if_return()) { + _internal_mutable_if_return()->::io::substrait::DerivationExpression::MergeFrom(from._internal_if_return()); + } + if (from.has_else_return()) { + _internal_mutable_else_return()->::io::substrait::DerivationExpression::MergeFrom(from._internal_else_return()); + } +} + +void DerivationExpression_IfElse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.IfElse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_IfElse::CopyFrom(const DerivationExpression_IfElse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.IfElse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_IfElse::IsInitialized() const { + return true; +} + +void DerivationExpression_IfElse::InternalSwap(DerivationExpression_IfElse* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DerivationExpression_IfElse, else_return_) + + sizeof(DerivationExpression_IfElse::else_return_) + - PROTOBUF_FIELD_OFFSET(DerivationExpression_IfElse, if_condition_)>( + reinterpret_cast(&if_condition_), + reinterpret_cast(&other->if_condition_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_IfElse::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[8]); +} + +// =================================================================== + +class DerivationExpression_UnaryOp::_Internal { + public: + static const ::io::substrait::DerivationExpression& arg(const DerivationExpression_UnaryOp* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_UnaryOp::_Internal::arg(const DerivationExpression_UnaryOp* msg) { + return *msg->arg_; +} +DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.UnaryOp) +} +DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(const DerivationExpression_UnaryOp& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_arg()) { + arg_ = new ::io::substrait::DerivationExpression(*from.arg_); + } else { + arg_ = nullptr; + } + op_type_ = from.op_type_; + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.UnaryOp) +} + +void DerivationExpression_UnaryOp::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&arg_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&op_type_) - + reinterpret_cast(&arg_)) + sizeof(op_type_)); +} + +DerivationExpression_UnaryOp::~DerivationExpression_UnaryOp() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.UnaryOp) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_UnaryOp::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete arg_; +} + +void DerivationExpression_UnaryOp::ArenaDtor(void* object) { + DerivationExpression_UnaryOp* _this = reinterpret_cast< DerivationExpression_UnaryOp* >(object); + (void)_this; +} +void DerivationExpression_UnaryOp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_UnaryOp::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_UnaryOp::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.UnaryOp) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && arg_ != nullptr) { + delete arg_; + } + arg_ = nullptr; + op_type_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_UnaryOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.DerivationExpression.UnaryOp.OpType op_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_op_type(static_cast<::io::substrait::DerivationExpression_UnaryOp_OpType>(val)); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression arg = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_arg(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_UnaryOp::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.UnaryOp) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.DerivationExpression.UnaryOp.OpType op_type = 1; + if (this->op_type() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_op_type(), target); + } + + // .io.substrait.DerivationExpression arg = 2; + if (this->has_arg()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::arg(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.UnaryOp) + return target; +} + +size_t DerivationExpression_UnaryOp::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.UnaryOp) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.DerivationExpression arg = 2; + if (this->has_arg()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *arg_); + } + + // .io.substrait.DerivationExpression.UnaryOp.OpType op_type = 1; + if (this->op_type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_UnaryOp::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.UnaryOp) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_UnaryOp* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.UnaryOp) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.UnaryOp) + MergeFrom(*source); + } +} + +void DerivationExpression_UnaryOp::MergeFrom(const DerivationExpression_UnaryOp& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.UnaryOp) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_arg()) { + _internal_mutable_arg()->::io::substrait::DerivationExpression::MergeFrom(from._internal_arg()); + } + if (from.op_type() != 0) { + _internal_set_op_type(from._internal_op_type()); + } +} + +void DerivationExpression_UnaryOp::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.UnaryOp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_UnaryOp::CopyFrom(const DerivationExpression_UnaryOp& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.UnaryOp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_UnaryOp::IsInitialized() const { + return true; +} + +void DerivationExpression_UnaryOp::InternalSwap(DerivationExpression_UnaryOp* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DerivationExpression_UnaryOp, op_type_) + + sizeof(DerivationExpression_UnaryOp::op_type_) + - PROTOBUF_FIELD_OFFSET(DerivationExpression_UnaryOp, arg_)>( + reinterpret_cast(&arg_), + reinterpret_cast(&other->arg_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_UnaryOp::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[9]); +} + +// =================================================================== + +class DerivationExpression_BinaryOp::_Internal { + public: + static const ::io::substrait::DerivationExpression& arg1(const DerivationExpression_BinaryOp* msg); + static const ::io::substrait::DerivationExpression& arg2(const DerivationExpression_BinaryOp* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_BinaryOp::_Internal::arg1(const DerivationExpression_BinaryOp* msg) { + return *msg->arg1_; +} +const ::io::substrait::DerivationExpression& +DerivationExpression_BinaryOp::_Internal::arg2(const DerivationExpression_BinaryOp* msg) { + return *msg->arg2_; +} +DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.BinaryOp) +} +DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(const DerivationExpression_BinaryOp& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_arg1()) { + arg1_ = new ::io::substrait::DerivationExpression(*from.arg1_); + } else { + arg1_ = nullptr; + } + if (from._internal_has_arg2()) { + arg2_ = new ::io::substrait::DerivationExpression(*from.arg2_); + } else { + arg2_ = nullptr; + } + op_type_ = from.op_type_; + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.BinaryOp) +} + +void DerivationExpression_BinaryOp::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&arg1_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&op_type_) - + reinterpret_cast(&arg1_)) + sizeof(op_type_)); +} + +DerivationExpression_BinaryOp::~DerivationExpression_BinaryOp() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.BinaryOp) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_BinaryOp::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete arg1_; + if (this != internal_default_instance()) delete arg2_; +} + +void DerivationExpression_BinaryOp::ArenaDtor(void* object) { + DerivationExpression_BinaryOp* _this = reinterpret_cast< DerivationExpression_BinaryOp* >(object); + (void)_this; +} +void DerivationExpression_BinaryOp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_BinaryOp::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_BinaryOp::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.BinaryOp) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && arg1_ != nullptr) { + delete arg1_; + } + arg1_ = nullptr; + if (GetArena() == nullptr && arg2_ != nullptr) { + delete arg2_; + } + arg2_ = nullptr; + op_type_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_BinaryOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.DerivationExpression.BinaryOp.OpType op_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_op_type(static_cast<::io::substrait::DerivationExpression_BinaryOp_OpType>(val)); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression arg1 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_arg1(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression arg2 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_arg2(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_BinaryOp::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.BinaryOp) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.DerivationExpression.BinaryOp.OpType op_type = 1; + if (this->op_type() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 1, this->_internal_op_type(), target); + } + + // .io.substrait.DerivationExpression arg1 = 2; + if (this->has_arg1()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::arg1(this), target, stream); + } + + // .io.substrait.DerivationExpression arg2 = 3; + if (this->has_arg2()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::arg2(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.BinaryOp) + return target; +} + +size_t DerivationExpression_BinaryOp::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.BinaryOp) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.DerivationExpression arg1 = 2; + if (this->has_arg1()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *arg1_); + } + + // .io.substrait.DerivationExpression arg2 = 3; + if (this->has_arg2()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *arg2_); + } + + // .io.substrait.DerivationExpression.BinaryOp.OpType op_type = 1; + if (this->op_type() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_BinaryOp::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.BinaryOp) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_BinaryOp* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.BinaryOp) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.BinaryOp) + MergeFrom(*source); + } +} + +void DerivationExpression_BinaryOp::MergeFrom(const DerivationExpression_BinaryOp& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.BinaryOp) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_arg1()) { + _internal_mutable_arg1()->::io::substrait::DerivationExpression::MergeFrom(from._internal_arg1()); + } + if (from.has_arg2()) { + _internal_mutable_arg2()->::io::substrait::DerivationExpression::MergeFrom(from._internal_arg2()); + } + if (from.op_type() != 0) { + _internal_set_op_type(from._internal_op_type()); + } +} + +void DerivationExpression_BinaryOp::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.BinaryOp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_BinaryOp::CopyFrom(const DerivationExpression_BinaryOp& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.BinaryOp) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_BinaryOp::IsInitialized() const { + return true; +} + +void DerivationExpression_BinaryOp::InternalSwap(DerivationExpression_BinaryOp* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(DerivationExpression_BinaryOp, op_type_) + + sizeof(DerivationExpression_BinaryOp::op_type_) + - PROTOBUF_FIELD_OFFSET(DerivationExpression_BinaryOp, arg1_)>( + reinterpret_cast(&arg1_), + reinterpret_cast(&other->arg1_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_BinaryOp::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[10]); +} + +// =================================================================== + +class DerivationExpression::_Internal { + public: + static const ::io::substrait::Type_Boolean& bool_(const DerivationExpression* msg); + static const ::io::substrait::Type_I8& i8(const DerivationExpression* msg); + static const ::io::substrait::Type_I16& i16(const DerivationExpression* msg); + static const ::io::substrait::Type_I32& i32(const DerivationExpression* msg); + static const ::io::substrait::Type_I64& i64(const DerivationExpression* msg); + static const ::io::substrait::Type_FP32& fp32(const DerivationExpression* msg); + static const ::io::substrait::Type_FP64& fp64(const DerivationExpression* msg); + static const ::io::substrait::Type_String& string(const DerivationExpression* msg); + static const ::io::substrait::Type_Binary& binary(const DerivationExpression* msg); + static const ::io::substrait::Type_Timestamp& timestamp(const DerivationExpression* msg); + static const ::io::substrait::Type_Date& date(const DerivationExpression* msg); + static const ::io::substrait::Type_Time& time(const DerivationExpression* msg); + static const ::io::substrait::Type_IntervalYear& interval_year(const DerivationExpression* msg); + static const ::io::substrait::Type_IntervalDay& interval_day(const DerivationExpression* msg); + static const ::io::substrait::Type_TimestampTZ& timestamp_tz(const DerivationExpression* msg); + static const ::io::substrait::Type_UUID& uuid(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_ExpressionFixedChar& fixed_char(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_ExpressionVarChar& varchar(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_ExpressionDecimal& decimal(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_ExpressionList& list(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_ExpressionMap& map(const DerivationExpression* msg); + static const ::io::substrait::Extensions_TypeId& user_defined(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_UnaryOp& unary_op(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_BinaryOp& binary_op(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_IfElse& if_else(const DerivationExpression* msg); +}; + +const ::io::substrait::Type_Boolean& +DerivationExpression::_Internal::bool_(const DerivationExpression* msg) { + return *msg->kind_.bool__; +} +const ::io::substrait::Type_I8& +DerivationExpression::_Internal::i8(const DerivationExpression* msg) { + return *msg->kind_.i8_; +} +const ::io::substrait::Type_I16& +DerivationExpression::_Internal::i16(const DerivationExpression* msg) { + return *msg->kind_.i16_; +} +const ::io::substrait::Type_I32& +DerivationExpression::_Internal::i32(const DerivationExpression* msg) { + return *msg->kind_.i32_; +} +const ::io::substrait::Type_I64& +DerivationExpression::_Internal::i64(const DerivationExpression* msg) { + return *msg->kind_.i64_; +} +const ::io::substrait::Type_FP32& +DerivationExpression::_Internal::fp32(const DerivationExpression* msg) { + return *msg->kind_.fp32_; +} +const ::io::substrait::Type_FP64& +DerivationExpression::_Internal::fp64(const DerivationExpression* msg) { + return *msg->kind_.fp64_; +} +const ::io::substrait::Type_String& +DerivationExpression::_Internal::string(const DerivationExpression* msg) { + return *msg->kind_.string_; +} +const ::io::substrait::Type_Binary& +DerivationExpression::_Internal::binary(const DerivationExpression* msg) { + return *msg->kind_.binary_; +} +const ::io::substrait::Type_Timestamp& +DerivationExpression::_Internal::timestamp(const DerivationExpression* msg) { + return *msg->kind_.timestamp_; +} +const ::io::substrait::Type_Date& +DerivationExpression::_Internal::date(const DerivationExpression* msg) { + return *msg->kind_.date_; +} +const ::io::substrait::Type_Time& +DerivationExpression::_Internal::time(const DerivationExpression* msg) { + return *msg->kind_.time_; +} +const ::io::substrait::Type_IntervalYear& +DerivationExpression::_Internal::interval_year(const DerivationExpression* msg) { + return *msg->kind_.interval_year_; +} +const ::io::substrait::Type_IntervalDay& +DerivationExpression::_Internal::interval_day(const DerivationExpression* msg) { + return *msg->kind_.interval_day_; +} +const ::io::substrait::Type_TimestampTZ& +DerivationExpression::_Internal::timestamp_tz(const DerivationExpression* msg) { + return *msg->kind_.timestamp_tz_; +} +const ::io::substrait::Type_UUID& +DerivationExpression::_Internal::uuid(const DerivationExpression* msg) { + return *msg->kind_.uuid_; +} +const ::io::substrait::DerivationExpression_ExpressionFixedChar& +DerivationExpression::_Internal::fixed_char(const DerivationExpression* msg) { + return *msg->kind_.fixed_char_; +} +const ::io::substrait::DerivationExpression_ExpressionVarChar& +DerivationExpression::_Internal::varchar(const DerivationExpression* msg) { + return *msg->kind_.varchar_; +} +const ::io::substrait::DerivationExpression_ExpressionFixedBinary& +DerivationExpression::_Internal::fixed_binary(const DerivationExpression* msg) { + return *msg->kind_.fixed_binary_; +} +const ::io::substrait::DerivationExpression_ExpressionDecimal& +DerivationExpression::_Internal::decimal(const DerivationExpression* msg) { + return *msg->kind_.decimal_; +} +const ::io::substrait::DerivationExpression_ExpressionStruct& +DerivationExpression::_Internal::struct_(const DerivationExpression* msg) { + return *msg->kind_.struct__; +} +const ::io::substrait::DerivationExpression_ExpressionList& +DerivationExpression::_Internal::list(const DerivationExpression* msg) { + return *msg->kind_.list_; +} +const ::io::substrait::DerivationExpression_ExpressionMap& +DerivationExpression::_Internal::map(const DerivationExpression* msg) { + return *msg->kind_.map_; +} +const ::io::substrait::Extensions_TypeId& +DerivationExpression::_Internal::user_defined(const DerivationExpression* msg) { + return *msg->kind_.user_defined_; +} +const ::io::substrait::DerivationExpression_UnaryOp& +DerivationExpression::_Internal::unary_op(const DerivationExpression* msg) { + return *msg->kind_.unary_op_; +} +const ::io::substrait::DerivationExpression_BinaryOp& +DerivationExpression::_Internal::binary_op(const DerivationExpression* msg) { + return *msg->kind_.binary_op_; +} +const ::io::substrait::DerivationExpression_IfElse& +DerivationExpression::_Internal::if_else(const DerivationExpression* msg) { + return *msg->kind_.if_else_; +} +void DerivationExpression::set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (bool_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_)->GetArena(); + if (message_arena != submessage_arena) { + bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, bool_, submessage_arena); + } + set_has_bool_(); + kind_.bool__ = bool_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.bool) +} +void DerivationExpression::clear_bool_() { + if (_internal_has_bool_()) { + if (GetArena() == nullptr) { + delete kind_.bool__; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_i8(::io::substrait::Type_I8* i8) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i8) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8)->GetArena(); + if (message_arena != submessage_arena) { + i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i8, submessage_arena); + } + set_has_i8(); + kind_.i8_ = i8; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.i8) +} +void DerivationExpression::clear_i8() { + if (_internal_has_i8()) { + if (GetArena() == nullptr) { + delete kind_.i8_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_i16(::io::substrait::Type_I16* i16) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i16) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16)->GetArena(); + if (message_arena != submessage_arena) { + i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i16, submessage_arena); + } + set_has_i16(); + kind_.i16_ = i16; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.i16) +} +void DerivationExpression::clear_i16() { + if (_internal_has_i16()) { + if (GetArena() == nullptr) { + delete kind_.i16_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_i32(::io::substrait::Type_I32* i32) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i32) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32)->GetArena(); + if (message_arena != submessage_arena) { + i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i32, submessage_arena); + } + set_has_i32(); + kind_.i32_ = i32; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.i32) +} +void DerivationExpression::clear_i32() { + if (_internal_has_i32()) { + if (GetArena() == nullptr) { + delete kind_.i32_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_i64(::io::substrait::Type_I64* i64) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (i64) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64)->GetArena(); + if (message_arena != submessage_arena) { + i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, i64, submessage_arena); + } + set_has_i64(); + kind_.i64_ = i64; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.i64) +} +void DerivationExpression::clear_i64() { + if (_internal_has_i64()) { + if (GetArena() == nullptr) { + delete kind_.i64_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_fp32(::io::substrait::Type_FP32* fp32) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fp32) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32)->GetArena(); + if (message_arena != submessage_arena) { + fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fp32, submessage_arena); + } + set_has_fp32(); + kind_.fp32_ = fp32; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.fp32) +} +void DerivationExpression::clear_fp32() { + if (_internal_has_fp32()) { + if (GetArena() == nullptr) { + delete kind_.fp32_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_fp64(::io::substrait::Type_FP64* fp64) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fp64) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64)->GetArena(); + if (message_arena != submessage_arena) { + fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fp64, submessage_arena); + } + set_has_fp64(); + kind_.fp64_ = fp64; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.fp64) +} +void DerivationExpression::clear_fp64() { + if (_internal_has_fp64()) { + if (GetArena() == nullptr) { + delete kind_.fp64_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_string(::io::substrait::Type_String* string) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (string) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string)->GetArena(); + if (message_arena != submessage_arena) { + string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, string, submessage_arena); + } + set_has_string(); + kind_.string_ = string; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.string) +} +void DerivationExpression::clear_string() { + if (_internal_has_string()) { + if (GetArena() == nullptr) { + delete kind_.string_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_binary(::io::substrait::Type_Binary* binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary)->GetArena(); + if (message_arena != submessage_arena) { + binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, binary, submessage_arena); + } + set_has_binary(); + kind_.binary_ = binary; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.binary) +} +void DerivationExpression::clear_binary() { + if (_internal_has_binary()) { + if (GetArena() == nullptr) { + delete kind_.binary_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (timestamp) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp)->GetArena(); + if (message_arena != submessage_arena) { + timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, timestamp, submessage_arena); + } + set_has_timestamp(); + kind_.timestamp_ = timestamp; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.timestamp) +} +void DerivationExpression::clear_timestamp() { + if (_internal_has_timestamp()) { + if (GetArena() == nullptr) { + delete kind_.timestamp_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_date(::io::substrait::Type_Date* date) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (date) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date)->GetArena(); + if (message_arena != submessage_arena) { + date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, date, submessage_arena); + } + set_has_date(); + kind_.date_ = date; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.date) +} +void DerivationExpression::clear_date() { + if (_internal_has_date()) { + if (GetArena() == nullptr) { + delete kind_.date_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_time(::io::substrait::Type_Time* time) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (time) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time)->GetArena(); + if (message_arena != submessage_arena) { + time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, time, submessage_arena); + } + set_has_time(); + kind_.time_ = time; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.time) +} +void DerivationExpression::clear_time() { + if (_internal_has_time()) { + if (GetArena() == nullptr) { + delete kind_.time_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (interval_year) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year)->GetArena(); + if (message_arena != submessage_arena) { + interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interval_year, submessage_arena); + } + set_has_interval_year(); + kind_.interval_year_ = interval_year; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.interval_year) +} +void DerivationExpression::clear_interval_year() { + if (_internal_has_interval_year()) { + if (GetArena() == nullptr) { + delete kind_.interval_year_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (interval_day) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day)->GetArena(); + if (message_arena != submessage_arena) { + interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interval_day, submessage_arena); + } + set_has_interval_day(); + kind_.interval_day_ = interval_day; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.interval_day) +} +void DerivationExpression::clear_interval_day() { + if (_internal_has_interval_day()) { + if (GetArena() == nullptr) { + delete kind_.interval_day_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (timestamp_tz) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz)->GetArena(); + if (message_arena != submessage_arena) { + timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, timestamp_tz, submessage_arena); + } + set_has_timestamp_tz(); + kind_.timestamp_tz_ = timestamp_tz; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.timestamp_tz) +} +void DerivationExpression::clear_timestamp_tz() { + if (_internal_has_timestamp_tz()) { + if (GetArena() == nullptr) { + delete kind_.timestamp_tz_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_uuid(::io::substrait::Type_UUID* uuid) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (uuid) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid)->GetArena(); + if (message_arena != submessage_arena) { + uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, uuid, submessage_arena); + } + set_has_uuid(); + kind_.uuid_ = uuid; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.uuid) +} +void DerivationExpression::clear_uuid() { + if (_internal_has_uuid()) { + if (GetArena() == nullptr) { + delete kind_.uuid_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_fixed_char(::io::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fixed_char) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_char); + if (message_arena != submessage_arena) { + fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fixed_char, submessage_arena); + } + set_has_fixed_char(); + kind_.fixed_char_ = fixed_char; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.fixed_char) +} +void DerivationExpression::set_allocated_varchar(::io::substrait::DerivationExpression_ExpressionVarChar* varchar) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (varchar) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(varchar); + if (message_arena != submessage_arena) { + varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, varchar, submessage_arena); + } + set_has_varchar(); + kind_.varchar_ = varchar; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.varchar) +} +void DerivationExpression::set_allocated_fixed_binary(::io::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (fixed_binary) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_binary); + if (message_arena != submessage_arena) { + fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, fixed_binary, submessage_arena); + } + set_has_fixed_binary(); + kind_.fixed_binary_ = fixed_binary; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.fixed_binary) +} +void DerivationExpression::set_allocated_decimal(::io::substrait::DerivationExpression_ExpressionDecimal* decimal) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (decimal) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(decimal); + if (message_arena != submessage_arena) { + decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, decimal, submessage_arena); + } + set_has_decimal(); + kind_.decimal_ = decimal; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.decimal) +} +void DerivationExpression::set_allocated_struct_(::io::substrait::DerivationExpression_ExpressionStruct* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + set_has_struct_(); + kind_.struct__ = struct_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.struct) +} +void DerivationExpression::set_allocated_list(::io::substrait::DerivationExpression_ExpressionList* list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + if (message_arena != submessage_arena) { + list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, list, submessage_arena); + } + set_has_list(); + kind_.list_ = list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.list) +} +void DerivationExpression::set_allocated_map(::io::substrait::DerivationExpression_ExpressionMap* map) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (map) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + if (message_arena != submessage_arena) { + map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map, submessage_arena); + } + set_has_map(); + kind_.map_ = map; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.map) +} +void DerivationExpression::set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (user_defined) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(user_defined)->GetArena(); + if (message_arena != submessage_arena) { + user_defined = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, user_defined, submessage_arena); + } + set_has_user_defined(); + kind_.user_defined_ = user_defined; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.user_defined) +} +void DerivationExpression::clear_user_defined() { + if (_internal_has_user_defined()) { + if (GetArena() == nullptr) { + delete kind_.user_defined_; + } + clear_has_kind(); + } +} +void DerivationExpression::set_allocated_unary_op(::io::substrait::DerivationExpression_UnaryOp* unary_op) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (unary_op) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(unary_op); + if (message_arena != submessage_arena) { + unary_op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, unary_op, submessage_arena); + } + set_has_unary_op(); + kind_.unary_op_ = unary_op; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.unary_op) +} +void DerivationExpression::set_allocated_binary_op(::io::substrait::DerivationExpression_BinaryOp* binary_op) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (binary_op) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(binary_op); + if (message_arena != submessage_arena) { + binary_op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, binary_op, submessage_arena); + } + set_has_binary_op(); + kind_.binary_op_ = binary_op; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.binary_op) +} +void DerivationExpression::set_allocated_if_else(::io::substrait::DerivationExpression_IfElse* if_else) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (if_else) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_else); + if (message_arena != submessage_arena) { + if_else = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, if_else, submessage_arena); + } + set_has_if_else(); + kind_.if_else_ = if_else; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.if_else) +} +DerivationExpression::DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression) +} +DerivationExpression::DerivationExpression(const DerivationExpression& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_kind(); + switch (from.kind_case()) { + case kBool: { + _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + break; + } + case kI8: { + _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + break; + } + case kI16: { + _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + break; + } + case kI32: { + _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + break; + } + case kI64: { + _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + break; + } + case kFp32: { + _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + break; + } + case kFp64: { + _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + break; + } + case kString: { + _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + break; + } + case kBinary: { + _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + break; + } + case kTimestamp: { + _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + break; + } + case kDate: { + _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + break; + } + case kTime: { + _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + break; + } + case kIntervalYear: { + _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + break; + } + case kIntervalDay: { + _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + break; + } + case kTimestampTz: { + _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + break; + } + case kUuid: { + _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + break; + } + case kFixedChar: { + _internal_mutable_fixed_char()->::io::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char()); + break; + } + case kVarchar: { + _internal_mutable_varchar()->::io::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar()); + break; + } + case kFixedBinary: { + _internal_mutable_fixed_binary()->::io::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary()); + break; + } + case kDecimal: { + _internal_mutable_decimal()->::io::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal()); + break; + } + case kStruct: { + _internal_mutable_struct_()->::io::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map()); + break; + } + case kUserDefined: { + _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + break; + } + case kTypeParameterName: { + _internal_set_type_parameter_name(from._internal_type_parameter_name()); + break; + } + case kIntegerParameterName: { + _internal_set_integer_parameter_name(from._internal_integer_parameter_name()); + break; + } + case kIntegerLiteral: { + _internal_set_integer_literal(from._internal_integer_literal()); + break; + } + case kUnaryOp: { + _internal_mutable_unary_op()->::io::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op()); + break; + } + case kBinaryOp: { + _internal_mutable_binary_op()->::io::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op()); + break; + } + case kIfElse: { + _internal_mutable_if_else()->::io::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else()); + break; + } + case KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression) +} + +void DerivationExpression::SharedCtor() { +clear_has_kind(); +} + +DerivationExpression::~DerivationExpression() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_kind()) { + clear_kind(); + } +} + +void DerivationExpression::ArenaDtor(void* object) { + DerivationExpression* _this = reinterpret_cast< DerivationExpression* >(object); + (void)_this; +} +void DerivationExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression::clear_kind() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.DerivationExpression) + switch (kind_case()) { + case kBool: { + if (GetArena() == nullptr) { + delete kind_.bool__; + } + break; + } + case kI8: { + if (GetArena() == nullptr) { + delete kind_.i8_; + } + break; + } + case kI16: { + if (GetArena() == nullptr) { + delete kind_.i16_; + } + break; + } + case kI32: { + if (GetArena() == nullptr) { + delete kind_.i32_; + } + break; + } + case kI64: { + if (GetArena() == nullptr) { + delete kind_.i64_; + } + break; + } + case kFp32: { + if (GetArena() == nullptr) { + delete kind_.fp32_; + } + break; + } + case kFp64: { + if (GetArena() == nullptr) { + delete kind_.fp64_; + } + break; + } + case kString: { + if (GetArena() == nullptr) { + delete kind_.string_; + } + break; + } + case kBinary: { + if (GetArena() == nullptr) { + delete kind_.binary_; + } + break; + } + case kTimestamp: { + if (GetArena() == nullptr) { + delete kind_.timestamp_; + } + break; + } + case kDate: { + if (GetArena() == nullptr) { + delete kind_.date_; + } + break; + } + case kTime: { + if (GetArena() == nullptr) { + delete kind_.time_; + } + break; + } + case kIntervalYear: { + if (GetArena() == nullptr) { + delete kind_.interval_year_; + } + break; + } + case kIntervalDay: { + if (GetArena() == nullptr) { + delete kind_.interval_day_; + } + break; + } + case kTimestampTz: { + if (GetArena() == nullptr) { + delete kind_.timestamp_tz_; + } + break; + } + case kUuid: { + if (GetArena() == nullptr) { + delete kind_.uuid_; + } + break; + } + case kFixedChar: { + if (GetArena() == nullptr) { + delete kind_.fixed_char_; + } + break; + } + case kVarchar: { + if (GetArena() == nullptr) { + delete kind_.varchar_; + } + break; + } + case kFixedBinary: { + if (GetArena() == nullptr) { + delete kind_.fixed_binary_; + } + break; + } + case kDecimal: { + if (GetArena() == nullptr) { + delete kind_.decimal_; + } + break; + } + case kStruct: { + if (GetArena() == nullptr) { + delete kind_.struct__; + } + break; + } + case kList: { + if (GetArena() == nullptr) { + delete kind_.list_; + } + break; + } + case kMap: { + if (GetArena() == nullptr) { + delete kind_.map_; + } + break; + } + case kUserDefined: { + if (GetArena() == nullptr) { + delete kind_.user_defined_; + } + break; + } + case kTypeParameterName: { + kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kIntegerParameterName: { + kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kIntegerLiteral: { + // No need to clear + break; + } + case kUnaryOp: { + if (GetArena() == nullptr) { + delete kind_.unary_op_; + } + break; + } + case kBinaryOp: { + if (GetArena() == nullptr) { + delete kind_.binary_op_; + } + break; + } + case kIfElse: { + if (GetArena() == nullptr) { + delete kind_.if_else_; + } + break; + } + case KIND_NOT_SET: { + break; + } + } + _oneof_case_[0] = KIND_NOT_SET; +} + + +void DerivationExpression::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_kind(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Type.Boolean bool = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I8 i8 = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I16 i16 = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I32 i32 = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.I64 i64 = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.FP32 fp32 = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.FP64 fp64 = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.String string = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Binary binary = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Timestamp timestamp = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { + ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Date date = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { + ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Time time = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { + ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.IntervalYear interval_year = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.IntervalDay interval_day = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { + ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { + ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.ExpressionVarChar varchar = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { + ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.ExpressionDecimal decimal = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.ExpressionStruct struct = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.ExpressionList list = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) { + ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.ExpressionMap map = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { + ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { + ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Extensions.TypeId user_defined = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) { + ptr = ctx->ParseMessage(_internal_mutable_user_defined(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type.UUID uuid = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { + ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string type_parameter_name = 33; + case 33: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_type_parameter_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.DerivationExpression.type_parameter_name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string integer_parameter_name = 34; + case 34: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_integer_parameter_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.DerivationExpression.integer_parameter_name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 integer_literal = 35; + case 35: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.UnaryOp unary_op = 36; + case 36: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_unary_op(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.BinaryOp binary_op = 37; + case 37: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_binary_op(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression.IfElse if_else = 38; + case 38: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_if_else(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Type.Boolean bool = 1; + if (_internal_has_bool_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::bool_(this), target, stream); + } + + // .io.substrait.Type.I8 i8 = 2; + if (_internal_has_i8()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::i8(this), target, stream); + } + + // .io.substrait.Type.I16 i16 = 3; + if (_internal_has_i16()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::i16(this), target, stream); + } + + // .io.substrait.Type.I32 i32 = 5; + if (_internal_has_i32()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::i32(this), target, stream); + } + + // .io.substrait.Type.I64 i64 = 7; + if (_internal_has_i64()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::i64(this), target, stream); + } + + // .io.substrait.Type.FP32 fp32 = 10; + if (_internal_has_fp32()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::fp32(this), target, stream); + } + + // .io.substrait.Type.FP64 fp64 = 11; + if (_internal_has_fp64()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::fp64(this), target, stream); + } + + // .io.substrait.Type.String string = 12; + if (_internal_has_string()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 12, _Internal::string(this), target, stream); + } + + // .io.substrait.Type.Binary binary = 13; + if (_internal_has_binary()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 13, _Internal::binary(this), target, stream); + } + + // .io.substrait.Type.Timestamp timestamp = 14; + if (_internal_has_timestamp()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 14, _Internal::timestamp(this), target, stream); + } + + // .io.substrait.Type.Date date = 16; + if (_internal_has_date()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 16, _Internal::date(this), target, stream); + } + + // .io.substrait.Type.Time time = 17; + if (_internal_has_time()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 17, _Internal::time(this), target, stream); + } + + // .io.substrait.Type.IntervalYear interval_year = 19; + if (_internal_has_interval_year()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 19, _Internal::interval_year(this), target, stream); + } + + // .io.substrait.Type.IntervalDay interval_day = 20; + if (_internal_has_interval_day()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 20, _Internal::interval_day(this), target, stream); + } + + // .io.substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; + if (_internal_has_fixed_char()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 21, _Internal::fixed_char(this), target, stream); + } + + // .io.substrait.DerivationExpression.ExpressionVarChar varchar = 22; + if (_internal_has_varchar()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 22, _Internal::varchar(this), target, stream); + } + + // .io.substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; + if (_internal_has_fixed_binary()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 23, _Internal::fixed_binary(this), target, stream); + } + + // .io.substrait.DerivationExpression.ExpressionDecimal decimal = 24; + if (_internal_has_decimal()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 24, _Internal::decimal(this), target, stream); + } + + // .io.substrait.DerivationExpression.ExpressionStruct struct = 25; + if (_internal_has_struct_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 25, _Internal::struct_(this), target, stream); + } + + // .io.substrait.DerivationExpression.ExpressionList list = 27; + if (_internal_has_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 27, _Internal::list(this), target, stream); + } + + // .io.substrait.DerivationExpression.ExpressionMap map = 28; + if (_internal_has_map()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 28, _Internal::map(this), target, stream); + } + + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + if (_internal_has_timestamp_tz()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 29, _Internal::timestamp_tz(this), target, stream); + } + + // .io.substrait.Extensions.TypeId user_defined = 31; + if (_internal_has_user_defined()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 31, _Internal::user_defined(this), target, stream); + } + + // .io.substrait.Type.UUID uuid = 32; + if (_internal_has_uuid()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 32, _Internal::uuid(this), target, stream); + } + + // string type_parameter_name = 33; + if (_internal_has_type_parameter_name()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_type_parameter_name().data(), static_cast(this->_internal_type_parameter_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.DerivationExpression.type_parameter_name"); + target = stream->WriteStringMaybeAliased( + 33, this->_internal_type_parameter_name(), target); + } + + // string integer_parameter_name = 34; + if (_internal_has_integer_parameter_name()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_integer_parameter_name().data(), static_cast(this->_internal_integer_parameter_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.DerivationExpression.integer_parameter_name"); + target = stream->WriteStringMaybeAliased( + 34, this->_internal_integer_parameter_name(), target); + } + + // int32 integer_literal = 35; + if (_internal_has_integer_literal()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(35, this->_internal_integer_literal(), target); + } + + // .io.substrait.DerivationExpression.UnaryOp unary_op = 36; + if (_internal_has_unary_op()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 36, _Internal::unary_op(this), target, stream); + } + + // .io.substrait.DerivationExpression.BinaryOp binary_op = 37; + if (_internal_has_binary_op()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 37, _Internal::binary_op(this), target, stream); + } + + // .io.substrait.DerivationExpression.IfElse if_else = 38; + if (_internal_has_if_else()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 38, _Internal::if_else(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression) + return target; +} + +size_t DerivationExpression::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (kind_case()) { + // .io.substrait.Type.Boolean bool = 1; + case kBool: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.bool__); + break; + } + // .io.substrait.Type.I8 i8 = 2; + case kI8: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i8_); + break; + } + // .io.substrait.Type.I16 i16 = 3; + case kI16: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i16_); + break; + } + // .io.substrait.Type.I32 i32 = 5; + case kI32: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i32_); + break; + } + // .io.substrait.Type.I64 i64 = 7; + case kI64: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.i64_); + break; + } + // .io.substrait.Type.FP32 fp32 = 10; + case kFp32: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fp32_); + break; + } + // .io.substrait.Type.FP64 fp64 = 11; + case kFp64: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fp64_); + break; + } + // .io.substrait.Type.String string = 12; + case kString: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.string_); + break; + } + // .io.substrait.Type.Binary binary = 13; + case kBinary: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.binary_); + break; + } + // .io.substrait.Type.Timestamp timestamp = 14; + case kTimestamp: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.timestamp_); + break; + } + // .io.substrait.Type.Date date = 16; + case kDate: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.date_); + break; + } + // .io.substrait.Type.Time time = 17; + case kTime: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.time_); + break; + } + // .io.substrait.Type.IntervalYear interval_year = 19; + case kIntervalYear: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.interval_year_); + break; + } + // .io.substrait.Type.IntervalDay interval_day = 20; + case kIntervalDay: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.interval_day_); + break; + } + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + case kTimestampTz: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.timestamp_tz_); + break; + } + // .io.substrait.Type.UUID uuid = 32; + case kUuid: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.uuid_); + break; + } + // .io.substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; + case kFixedChar: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fixed_char_); + break; + } + // .io.substrait.DerivationExpression.ExpressionVarChar varchar = 22; + case kVarchar: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.varchar_); + break; + } + // .io.substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; + case kFixedBinary: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.fixed_binary_); + break; + } + // .io.substrait.DerivationExpression.ExpressionDecimal decimal = 24; + case kDecimal: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.decimal_); + break; + } + // .io.substrait.DerivationExpression.ExpressionStruct struct = 25; + case kStruct: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.struct__); + break; + } + // .io.substrait.DerivationExpression.ExpressionList list = 27; + case kList: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.list_); + break; + } + // .io.substrait.DerivationExpression.ExpressionMap map = 28; + case kMap: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.map_); + break; + } + // .io.substrait.Extensions.TypeId user_defined = 31; + case kUserDefined: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.user_defined_); + break; + } + // string type_parameter_name = 33; + case kTypeParameterName: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_type_parameter_name()); + break; + } + // string integer_parameter_name = 34; + case kIntegerParameterName: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_integer_parameter_name()); + break; + } + // int32 integer_literal = 35; + case kIntegerLiteral: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_integer_literal()); + break; + } + // .io.substrait.DerivationExpression.UnaryOp unary_op = 36; + case kUnaryOp: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.unary_op_); + break; + } + // .io.substrait.DerivationExpression.BinaryOp binary_op = 37; + case kBinaryOp: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.binary_op_); + break; + } + // .io.substrait.DerivationExpression.IfElse if_else = 38; + case kIfElse: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.if_else_); + break; + } + case KIND_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression) + MergeFrom(*source); + } +} + +void DerivationExpression::MergeFrom(const DerivationExpression& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.kind_case()) { + case kBool: { + _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + break; + } + case kI8: { + _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + break; + } + case kI16: { + _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + break; + } + case kI32: { + _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + break; + } + case kI64: { + _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + break; + } + case kFp32: { + _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + break; + } + case kFp64: { + _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + break; + } + case kString: { + _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + break; + } + case kBinary: { + _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + break; + } + case kTimestamp: { + _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + break; + } + case kDate: { + _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + break; + } + case kTime: { + _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + break; + } + case kIntervalYear: { + _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + break; + } + case kIntervalDay: { + _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + break; + } + case kTimestampTz: { + _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + break; + } + case kUuid: { + _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + break; + } + case kFixedChar: { + _internal_mutable_fixed_char()->::io::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char()); + break; + } + case kVarchar: { + _internal_mutable_varchar()->::io::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar()); + break; + } + case kFixedBinary: { + _internal_mutable_fixed_binary()->::io::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary()); + break; + } + case kDecimal: { + _internal_mutable_decimal()->::io::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal()); + break; + } + case kStruct: { + _internal_mutable_struct_()->::io::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map()); + break; + } + case kUserDefined: { + _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + break; + } + case kTypeParameterName: { + _internal_set_type_parameter_name(from._internal_type_parameter_name()); + break; + } + case kIntegerParameterName: { + _internal_set_integer_parameter_name(from._internal_integer_parameter_name()); + break; + } + case kIntegerLiteral: { + _internal_set_integer_literal(from._internal_integer_literal()); + break; + } + case kUnaryOp: { + _internal_mutable_unary_op()->::io::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op()); + break; + } + case kBinaryOp: { + _internal_mutable_binary_op()->::io::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op()); + break; + } + case kIfElse: { + _internal_mutable_if_else()->::io::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else()); + break; + } + case KIND_NOT_SET: { + break; + } + } +} + +void DerivationExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression::CopyFrom(const DerivationExpression& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression::IsInitialized() const { + return true; +} + +void DerivationExpression::InternalSwap(DerivationExpression* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(kind_, other->kind_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[11]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionFixedChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionFixedChar >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionVarChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionVarChar >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionFixedBinary >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionFixedBinary >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionDecimal >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionDecimal >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionStruct >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionNamedStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionNamedStruct >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionList >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionList >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionMap >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionMap >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_IfElse >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_IfElse >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_UnaryOp >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_UnaryOp >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_BinaryOp >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_BinaryOp >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/type_expressions.pb.h b/cpp/src/generated/substrait/type_expressions.pb.h new file mode 100644 index 00000000000..ec27b93e51b --- /dev/null +++ b/cpp/src/generated/substrait/type_expressions.pb.h @@ -0,0 +1,7191 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: type_expressions.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_type_5fexpressions_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_type_5fexpressions_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +#include "type.pb.h" +#include "extensions.pb.h" +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_type_5fexpressions_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_type_5fexpressions_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_5fexpressions_2eproto; +namespace io { +namespace substrait { +class DerivationExpression; +struct DerivationExpressionDefaultTypeInternal; +extern DerivationExpressionDefaultTypeInternal _DerivationExpression_default_instance_; +class DerivationExpression_BinaryOp; +struct DerivationExpression_BinaryOpDefaultTypeInternal; +extern DerivationExpression_BinaryOpDefaultTypeInternal _DerivationExpression_BinaryOp_default_instance_; +class DerivationExpression_ExpressionDecimal; +struct DerivationExpression_ExpressionDecimalDefaultTypeInternal; +extern DerivationExpression_ExpressionDecimalDefaultTypeInternal _DerivationExpression_ExpressionDecimal_default_instance_; +class DerivationExpression_ExpressionFixedBinary; +struct DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal; +extern DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal _DerivationExpression_ExpressionFixedBinary_default_instance_; +class DerivationExpression_ExpressionFixedChar; +struct DerivationExpression_ExpressionFixedCharDefaultTypeInternal; +extern DerivationExpression_ExpressionFixedCharDefaultTypeInternal _DerivationExpression_ExpressionFixedChar_default_instance_; +class DerivationExpression_ExpressionList; +struct DerivationExpression_ExpressionListDefaultTypeInternal; +extern DerivationExpression_ExpressionListDefaultTypeInternal _DerivationExpression_ExpressionList_default_instance_; +class DerivationExpression_ExpressionMap; +struct DerivationExpression_ExpressionMapDefaultTypeInternal; +extern DerivationExpression_ExpressionMapDefaultTypeInternal _DerivationExpression_ExpressionMap_default_instance_; +class DerivationExpression_ExpressionNamedStruct; +struct DerivationExpression_ExpressionNamedStructDefaultTypeInternal; +extern DerivationExpression_ExpressionNamedStructDefaultTypeInternal _DerivationExpression_ExpressionNamedStruct_default_instance_; +class DerivationExpression_ExpressionStruct; +struct DerivationExpression_ExpressionStructDefaultTypeInternal; +extern DerivationExpression_ExpressionStructDefaultTypeInternal _DerivationExpression_ExpressionStruct_default_instance_; +class DerivationExpression_ExpressionVarChar; +struct DerivationExpression_ExpressionVarCharDefaultTypeInternal; +extern DerivationExpression_ExpressionVarCharDefaultTypeInternal _DerivationExpression_ExpressionVarChar_default_instance_; +class DerivationExpression_IfElse; +struct DerivationExpression_IfElseDefaultTypeInternal; +extern DerivationExpression_IfElseDefaultTypeInternal _DerivationExpression_IfElse_default_instance_; +class DerivationExpression_UnaryOp; +struct DerivationExpression_UnaryOpDefaultTypeInternal; +extern DerivationExpression_UnaryOpDefaultTypeInternal _DerivationExpression_UnaryOp_default_instance_; +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::DerivationExpression* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression>(Arena*); +template<> ::io::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_BinaryOp>(Arena*); +template<> ::io::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionDecimal>(Arena*); +template<> ::io::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionFixedBinary>(Arena*); +template<> ::io::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionFixedChar>(Arena*); +template<> ::io::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionList>(Arena*); +template<> ::io::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionMap>(Arena*); +template<> ::io::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionNamedStruct>(Arena*); +template<> ::io::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionStruct>(Arena*); +template<> ::io::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionVarChar>(Arena*); +template<> ::io::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_IfElse>(Arena*); +template<> ::io::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_UnaryOp>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace io { +namespace substrait { + +enum DerivationExpression_UnaryOp_OpType : int { + DerivationExpression_UnaryOp_OpType_UNKNOWN = 0, + DerivationExpression_UnaryOp_OpType_BOOLEAN_NOT = 1, + DerivationExpression_UnaryOp_OpType_DerivationExpression_UnaryOp_OpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + DerivationExpression_UnaryOp_OpType_DerivationExpression_UnaryOp_OpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool DerivationExpression_UnaryOp_OpType_IsValid(int value); +constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp_OpType_OpType_MIN = DerivationExpression_UnaryOp_OpType_UNKNOWN; +constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp_OpType_OpType_MAX = DerivationExpression_UnaryOp_OpType_BOOLEAN_NOT; +constexpr int DerivationExpression_UnaryOp_OpType_OpType_ARRAYSIZE = DerivationExpression_UnaryOp_OpType_OpType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_OpType_descriptor(); +template +inline const std::string& DerivationExpression_UnaryOp_OpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DerivationExpression_UnaryOp_OpType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + DerivationExpression_UnaryOp_OpType_descriptor(), enum_t_value); +} +inline bool DerivationExpression_UnaryOp_OpType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_UnaryOp_OpType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DerivationExpression_UnaryOp_OpType_descriptor(), name, value); +} +enum DerivationExpression_BinaryOp_OpType : int { + DerivationExpression_BinaryOp_OpType_UNKNOWN = 0, + DerivationExpression_BinaryOp_OpType_PLUS = 1, + DerivationExpression_BinaryOp_OpType_MINUS = 2, + DerivationExpression_BinaryOp_OpType_MULTIPLY = 3, + DerivationExpression_BinaryOp_OpType_DIVIDE = 4, + DerivationExpression_BinaryOp_OpType_MIN = 5, + DerivationExpression_BinaryOp_OpType_MAX = 6, + DerivationExpression_BinaryOp_OpType_GREATER_THAN = 7, + DerivationExpression_BinaryOp_OpType_LESS_THAN = 8, + DerivationExpression_BinaryOp_OpType_AND = 9, + DerivationExpression_BinaryOp_OpType_OR = 10, + DerivationExpression_BinaryOp_OpType_EQUALS = 11, + DerivationExpression_BinaryOp_OpType_COVERS = 12, + DerivationExpression_BinaryOp_OpType_DerivationExpression_BinaryOp_OpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + DerivationExpression_BinaryOp_OpType_DerivationExpression_BinaryOp_OpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +}; +bool DerivationExpression_BinaryOp_OpType_IsValid(int value); +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp_OpType_OpType_MIN = DerivationExpression_BinaryOp_OpType_UNKNOWN; +constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp_OpType_OpType_MAX = DerivationExpression_BinaryOp_OpType_COVERS; +constexpr int DerivationExpression_BinaryOp_OpType_OpType_ARRAYSIZE = DerivationExpression_BinaryOp_OpType_OpType_MAX + 1; + +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_OpType_descriptor(); +template +inline const std::string& DerivationExpression_BinaryOp_OpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function DerivationExpression_BinaryOp_OpType_Name."); + return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( + DerivationExpression_BinaryOp_OpType_descriptor(), enum_t_value); +} +inline bool DerivationExpression_BinaryOp_OpType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_BinaryOp_OpType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DerivationExpression_BinaryOp_OpType_descriptor(), name, value); +} +// =================================================================== + +class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionFixedChar) */ { + public: + inline DerivationExpression_ExpressionFixedChar() : DerivationExpression_ExpressionFixedChar(nullptr) {} + ~DerivationExpression_ExpressionFixedChar() override; + explicit constexpr DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_ExpressionFixedChar(const DerivationExpression_ExpressionFixedChar& from); + DerivationExpression_ExpressionFixedChar(DerivationExpression_ExpressionFixedChar&& from) noexcept + : DerivationExpression_ExpressionFixedChar() { + *this = ::std::move(from); + } + + inline DerivationExpression_ExpressionFixedChar& operator=(const DerivationExpression_ExpressionFixedChar& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_ExpressionFixedChar& operator=(DerivationExpression_ExpressionFixedChar&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_ExpressionFixedChar& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_ExpressionFixedChar* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_ExpressionFixedChar_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(DerivationExpression_ExpressionFixedChar& a, DerivationExpression_ExpressionFixedChar& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_ExpressionFixedChar* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_ExpressionFixedChar* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_ExpressionFixedChar* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_ExpressionFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_ExpressionFixedChar& from); + void MergeFrom(const DerivationExpression_ExpressionFixedChar& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_ExpressionFixedChar* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.ExpressionFixedChar"; + } + protected: + explicit DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLengthFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.DerivationExpression length = 1; + bool has_length() const; + private: + bool _internal_has_length() const; + public: + void clear_length(); + const ::io::substrait::DerivationExpression& length() const; + ::io::substrait::DerivationExpression* release_length(); + ::io::substrait::DerivationExpression* mutable_length(); + void set_allocated_length(::io::substrait::DerivationExpression* length); + private: + const ::io::substrait::DerivationExpression& _internal_length() const; + ::io::substrait::DerivationExpression* _internal_mutable_length(); + public: + void unsafe_arena_set_allocated_length( + ::io::substrait::DerivationExpression* length); + ::io::substrait::DerivationExpression* unsafe_arena_release_length(); + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionFixedChar) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::DerivationExpression* length_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionVarChar) */ { + public: + inline DerivationExpression_ExpressionVarChar() : DerivationExpression_ExpressionVarChar(nullptr) {} + ~DerivationExpression_ExpressionVarChar() override; + explicit constexpr DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_ExpressionVarChar(const DerivationExpression_ExpressionVarChar& from); + DerivationExpression_ExpressionVarChar(DerivationExpression_ExpressionVarChar&& from) noexcept + : DerivationExpression_ExpressionVarChar() { + *this = ::std::move(from); + } + + inline DerivationExpression_ExpressionVarChar& operator=(const DerivationExpression_ExpressionVarChar& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_ExpressionVarChar& operator=(DerivationExpression_ExpressionVarChar&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_ExpressionVarChar& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_ExpressionVarChar* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_ExpressionVarChar_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(DerivationExpression_ExpressionVarChar& a, DerivationExpression_ExpressionVarChar& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_ExpressionVarChar* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_ExpressionVarChar* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_ExpressionVarChar* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_ExpressionVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_ExpressionVarChar& from); + void MergeFrom(const DerivationExpression_ExpressionVarChar& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_ExpressionVarChar* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.ExpressionVarChar"; + } + protected: + explicit DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLengthFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.DerivationExpression length = 1; + bool has_length() const; + private: + bool _internal_has_length() const; + public: + void clear_length(); + const ::io::substrait::DerivationExpression& length() const; + ::io::substrait::DerivationExpression* release_length(); + ::io::substrait::DerivationExpression* mutable_length(); + void set_allocated_length(::io::substrait::DerivationExpression* length); + private: + const ::io::substrait::DerivationExpression& _internal_length() const; + ::io::substrait::DerivationExpression* _internal_mutable_length(); + public: + void unsafe_arena_set_allocated_length( + ::io::substrait::DerivationExpression* length); + ::io::substrait::DerivationExpression* unsafe_arena_release_length(); + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionVarChar) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::DerivationExpression* length_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionFixedBinary) */ { + public: + inline DerivationExpression_ExpressionFixedBinary() : DerivationExpression_ExpressionFixedBinary(nullptr) {} + ~DerivationExpression_ExpressionFixedBinary() override; + explicit constexpr DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_ExpressionFixedBinary(const DerivationExpression_ExpressionFixedBinary& from); + DerivationExpression_ExpressionFixedBinary(DerivationExpression_ExpressionFixedBinary&& from) noexcept + : DerivationExpression_ExpressionFixedBinary() { + *this = ::std::move(from); + } + + inline DerivationExpression_ExpressionFixedBinary& operator=(const DerivationExpression_ExpressionFixedBinary& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_ExpressionFixedBinary& operator=(DerivationExpression_ExpressionFixedBinary&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_ExpressionFixedBinary& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_ExpressionFixedBinary* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_ExpressionFixedBinary_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(DerivationExpression_ExpressionFixedBinary& a, DerivationExpression_ExpressionFixedBinary& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_ExpressionFixedBinary* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_ExpressionFixedBinary* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_ExpressionFixedBinary* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_ExpressionFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_ExpressionFixedBinary& from); + void MergeFrom(const DerivationExpression_ExpressionFixedBinary& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_ExpressionFixedBinary* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.ExpressionFixedBinary"; + } + protected: + explicit DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kLengthFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.DerivationExpression length = 1; + bool has_length() const; + private: + bool _internal_has_length() const; + public: + void clear_length(); + const ::io::substrait::DerivationExpression& length() const; + ::io::substrait::DerivationExpression* release_length(); + ::io::substrait::DerivationExpression* mutable_length(); + void set_allocated_length(::io::substrait::DerivationExpression* length); + private: + const ::io::substrait::DerivationExpression& _internal_length() const; + ::io::substrait::DerivationExpression* _internal_mutable_length(); + public: + void unsafe_arena_set_allocated_length( + ::io::substrait::DerivationExpression* length); + ::io::substrait::DerivationExpression* unsafe_arena_release_length(); + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionFixedBinary) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::DerivationExpression* length_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionDecimal) */ { + public: + inline DerivationExpression_ExpressionDecimal() : DerivationExpression_ExpressionDecimal(nullptr) {} + ~DerivationExpression_ExpressionDecimal() override; + explicit constexpr DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_ExpressionDecimal(const DerivationExpression_ExpressionDecimal& from); + DerivationExpression_ExpressionDecimal(DerivationExpression_ExpressionDecimal&& from) noexcept + : DerivationExpression_ExpressionDecimal() { + *this = ::std::move(from); + } + + inline DerivationExpression_ExpressionDecimal& operator=(const DerivationExpression_ExpressionDecimal& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_ExpressionDecimal& operator=(DerivationExpression_ExpressionDecimal&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_ExpressionDecimal& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_ExpressionDecimal* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_ExpressionDecimal_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(DerivationExpression_ExpressionDecimal& a, DerivationExpression_ExpressionDecimal& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_ExpressionDecimal* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_ExpressionDecimal* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_ExpressionDecimal* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_ExpressionDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_ExpressionDecimal& from); + void MergeFrom(const DerivationExpression_ExpressionDecimal& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_ExpressionDecimal* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.ExpressionDecimal"; + } + protected: + explicit DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kScaleFieldNumber = 1, + kPrecisionFieldNumber = 2, + kVariationFieldNumber = 3, + kNullabilityFieldNumber = 4, + }; + // .io.substrait.DerivationExpression scale = 1; + bool has_scale() const; + private: + bool _internal_has_scale() const; + public: + void clear_scale(); + const ::io::substrait::DerivationExpression& scale() const; + ::io::substrait::DerivationExpression* release_scale(); + ::io::substrait::DerivationExpression* mutable_scale(); + void set_allocated_scale(::io::substrait::DerivationExpression* scale); + private: + const ::io::substrait::DerivationExpression& _internal_scale() const; + ::io::substrait::DerivationExpression* _internal_mutable_scale(); + public: + void unsafe_arena_set_allocated_scale( + ::io::substrait::DerivationExpression* scale); + ::io::substrait::DerivationExpression* unsafe_arena_release_scale(); + + // .io.substrait.DerivationExpression precision = 2; + bool has_precision() const; + private: + bool _internal_has_precision() const; + public: + void clear_precision(); + const ::io::substrait::DerivationExpression& precision() const; + ::io::substrait::DerivationExpression* release_precision(); + ::io::substrait::DerivationExpression* mutable_precision(); + void set_allocated_precision(::io::substrait::DerivationExpression* precision); + private: + const ::io::substrait::DerivationExpression& _internal_precision() const; + ::io::substrait::DerivationExpression* _internal_mutable_precision(); + public: + void unsafe_arena_set_allocated_precision( + ::io::substrait::DerivationExpression* precision); + ::io::substrait::DerivationExpression* unsafe_arena_release_precision(); + + // .io.substrait.Type.Variation variation = 3; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 4; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionDecimal) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::DerivationExpression* scale_; + ::io::substrait::DerivationExpression* precision_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionStruct) */ { + public: + inline DerivationExpression_ExpressionStruct() : DerivationExpression_ExpressionStruct(nullptr) {} + ~DerivationExpression_ExpressionStruct() override; + explicit constexpr DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_ExpressionStruct(const DerivationExpression_ExpressionStruct& from); + DerivationExpression_ExpressionStruct(DerivationExpression_ExpressionStruct&& from) noexcept + : DerivationExpression_ExpressionStruct() { + *this = ::std::move(from); + } + + inline DerivationExpression_ExpressionStruct& operator=(const DerivationExpression_ExpressionStruct& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_ExpressionStruct& operator=(DerivationExpression_ExpressionStruct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_ExpressionStruct& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_ExpressionStruct* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_ExpressionStruct_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(DerivationExpression_ExpressionStruct& a, DerivationExpression_ExpressionStruct& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_ExpressionStruct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_ExpressionStruct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_ExpressionStruct* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_ExpressionStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_ExpressionStruct& from); + void MergeFrom(const DerivationExpression_ExpressionStruct& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_ExpressionStruct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.ExpressionStruct"; + } + protected: + explicit DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTypesFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // repeated .io.substrait.DerivationExpression types = 1; + int types_size() const; + private: + int _internal_types_size() const; + public: + void clear_types(); + ::io::substrait::DerivationExpression* mutable_types(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression >* + mutable_types(); + private: + const ::io::substrait::DerivationExpression& _internal_types(int index) const; + ::io::substrait::DerivationExpression* _internal_add_types(); + public: + const ::io::substrait::DerivationExpression& types(int index) const; + ::io::substrait::DerivationExpression* add_types(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression >& + types() const; + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionStruct) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression > types_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionNamedStruct) */ { + public: + inline DerivationExpression_ExpressionNamedStruct() : DerivationExpression_ExpressionNamedStruct(nullptr) {} + ~DerivationExpression_ExpressionNamedStruct() override; + explicit constexpr DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_ExpressionNamedStruct(const DerivationExpression_ExpressionNamedStruct& from); + DerivationExpression_ExpressionNamedStruct(DerivationExpression_ExpressionNamedStruct&& from) noexcept + : DerivationExpression_ExpressionNamedStruct() { + *this = ::std::move(from); + } + + inline DerivationExpression_ExpressionNamedStruct& operator=(const DerivationExpression_ExpressionNamedStruct& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_ExpressionNamedStruct& operator=(DerivationExpression_ExpressionNamedStruct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_ExpressionNamedStruct& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_ExpressionNamedStruct* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_ExpressionNamedStruct_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(DerivationExpression_ExpressionNamedStruct& a, DerivationExpression_ExpressionNamedStruct& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_ExpressionNamedStruct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_ExpressionNamedStruct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_ExpressionNamedStruct* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_ExpressionNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_ExpressionNamedStruct& from); + void MergeFrom(const DerivationExpression_ExpressionNamedStruct& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_ExpressionNamedStruct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.ExpressionNamedStruct"; + } + protected: + explicit DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNamesFieldNumber = 1, + kStructFieldNumber = 2, + }; + // repeated string names = 1; + int names_size() const; + private: + int _internal_names_size() const; + public: + void clear_names(); + const std::string& names(int index) const; + std::string* mutable_names(int index); + void set_names(int index, const std::string& value); + void set_names(int index, std::string&& value); + void set_names(int index, const char* value); + void set_names(int index, const char* value, size_t size); + std::string* add_names(); + void add_names(const std::string& value); + void add_names(std::string&& value); + void add_names(const char* value); + void add_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); + private: + const std::string& _internal_names(int index) const; + std::string* _internal_add_names(); + public: + + // .io.substrait.DerivationExpression.ExpressionStruct struct = 2; + bool has_struct_() const; + private: + bool _internal_has_struct_() const; + public: + void clear_struct_(); + const ::io::substrait::DerivationExpression_ExpressionStruct& struct_() const; + ::io::substrait::DerivationExpression_ExpressionStruct* release_struct_(); + ::io::substrait::DerivationExpression_ExpressionStruct* mutable_struct_(); + void set_allocated_struct_(::io::substrait::DerivationExpression_ExpressionStruct* struct_); + private: + const ::io::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const; + ::io::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_(); + public: + void unsafe_arena_set_allocated_struct_( + ::io::substrait::DerivationExpression_ExpressionStruct* struct_); + ::io::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_(); + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionNamedStruct) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; + ::io::substrait::DerivationExpression_ExpressionStruct* struct__; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_ExpressionList PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionList) */ { + public: + inline DerivationExpression_ExpressionList() : DerivationExpression_ExpressionList(nullptr) {} + ~DerivationExpression_ExpressionList() override; + explicit constexpr DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_ExpressionList(const DerivationExpression_ExpressionList& from); + DerivationExpression_ExpressionList(DerivationExpression_ExpressionList&& from) noexcept + : DerivationExpression_ExpressionList() { + *this = ::std::move(from); + } + + inline DerivationExpression_ExpressionList& operator=(const DerivationExpression_ExpressionList& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_ExpressionList& operator=(DerivationExpression_ExpressionList&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_ExpressionList& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_ExpressionList* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_ExpressionList_default_instance_); + } + static constexpr int kIndexInFileMessages = + 6; + + friend void swap(DerivationExpression_ExpressionList& a, DerivationExpression_ExpressionList& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_ExpressionList* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_ExpressionList* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_ExpressionList* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_ExpressionList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_ExpressionList& from); + void MergeFrom(const DerivationExpression_ExpressionList& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_ExpressionList* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.ExpressionList"; + } + protected: + explicit DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kTypeFieldNumber = 1, + kVariationFieldNumber = 2, + kNullabilityFieldNumber = 3, + }; + // .io.substrait.DerivationExpression type = 1; + bool has_type() const; + private: + bool _internal_has_type() const; + public: + void clear_type(); + const ::io::substrait::DerivationExpression& type() const; + ::io::substrait::DerivationExpression* release_type(); + ::io::substrait::DerivationExpression* mutable_type(); + void set_allocated_type(::io::substrait::DerivationExpression* type); + private: + const ::io::substrait::DerivationExpression& _internal_type() const; + ::io::substrait::DerivationExpression* _internal_mutable_type(); + public: + void unsafe_arena_set_allocated_type( + ::io::substrait::DerivationExpression* type); + ::io::substrait::DerivationExpression* unsafe_arena_release_type(); + + // .io.substrait.Type.Variation variation = 2; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 3; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionList) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::DerivationExpression* type_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_ExpressionMap PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionMap) */ { + public: + inline DerivationExpression_ExpressionMap() : DerivationExpression_ExpressionMap(nullptr) {} + ~DerivationExpression_ExpressionMap() override; + explicit constexpr DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_ExpressionMap(const DerivationExpression_ExpressionMap& from); + DerivationExpression_ExpressionMap(DerivationExpression_ExpressionMap&& from) noexcept + : DerivationExpression_ExpressionMap() { + *this = ::std::move(from); + } + + inline DerivationExpression_ExpressionMap& operator=(const DerivationExpression_ExpressionMap& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_ExpressionMap& operator=(DerivationExpression_ExpressionMap&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_ExpressionMap& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_ExpressionMap* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_ExpressionMap_default_instance_); + } + static constexpr int kIndexInFileMessages = + 7; + + friend void swap(DerivationExpression_ExpressionMap& a, DerivationExpression_ExpressionMap& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_ExpressionMap* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_ExpressionMap* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_ExpressionMap* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_ExpressionMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_ExpressionMap& from); + void MergeFrom(const DerivationExpression_ExpressionMap& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_ExpressionMap* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.ExpressionMap"; + } + protected: + explicit DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kKeyFieldNumber = 1, + kValueFieldNumber = 2, + kVariationFieldNumber = 3, + kNullabilityFieldNumber = 4, + }; + // .io.substrait.DerivationExpression key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::io::substrait::DerivationExpression& key() const; + ::io::substrait::DerivationExpression* release_key(); + ::io::substrait::DerivationExpression* mutable_key(); + void set_allocated_key(::io::substrait::DerivationExpression* key); + private: + const ::io::substrait::DerivationExpression& _internal_key() const; + ::io::substrait::DerivationExpression* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::io::substrait::DerivationExpression* key); + ::io::substrait::DerivationExpression* unsafe_arena_release_key(); + + // .io.substrait.DerivationExpression value = 2; + bool has_value() const; + private: + bool _internal_has_value() const; + public: + void clear_value(); + const ::io::substrait::DerivationExpression& value() const; + ::io::substrait::DerivationExpression* release_value(); + ::io::substrait::DerivationExpression* mutable_value(); + void set_allocated_value(::io::substrait::DerivationExpression* value); + private: + const ::io::substrait::DerivationExpression& _internal_value() const; + ::io::substrait::DerivationExpression* _internal_mutable_value(); + public: + void unsafe_arena_set_allocated_value( + ::io::substrait::DerivationExpression* value); + ::io::substrait::DerivationExpression* unsafe_arena_release_value(); + + // .io.substrait.Type.Variation variation = 3; + bool has_variation() const; + private: + bool _internal_has_variation() const; + public: + void clear_variation(); + const ::io::substrait::Type_Variation& variation() const; + ::io::substrait::Type_Variation* release_variation(); + ::io::substrait::Type_Variation* mutable_variation(); + void set_allocated_variation(::io::substrait::Type_Variation* variation); + private: + const ::io::substrait::Type_Variation& _internal_variation() const; + ::io::substrait::Type_Variation* _internal_mutable_variation(); + public: + void unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation); + ::io::substrait::Type_Variation* unsafe_arena_release_variation(); + + // .io.substrait.Type.Nullability nullability = 4; + void clear_nullability(); + ::io::substrait::Type_Nullability nullability() const; + void set_nullability(::io::substrait::Type_Nullability value); + private: + ::io::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::io::substrait::Type_Nullability value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionMap) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::DerivationExpression* key_; + ::io::substrait::DerivationExpression* value_; + ::io::substrait::Type_Variation* variation_; + int nullability_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_IfElse PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.IfElse) */ { + public: + inline DerivationExpression_IfElse() : DerivationExpression_IfElse(nullptr) {} + ~DerivationExpression_IfElse() override; + explicit constexpr DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_IfElse(const DerivationExpression_IfElse& from); + DerivationExpression_IfElse(DerivationExpression_IfElse&& from) noexcept + : DerivationExpression_IfElse() { + *this = ::std::move(from); + } + + inline DerivationExpression_IfElse& operator=(const DerivationExpression_IfElse& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_IfElse& operator=(DerivationExpression_IfElse&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_IfElse& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_IfElse* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_IfElse_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(DerivationExpression_IfElse& a, DerivationExpression_IfElse& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_IfElse* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_IfElse* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_IfElse* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_IfElse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_IfElse& from); + void MergeFrom(const DerivationExpression_IfElse& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_IfElse* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.IfElse"; + } + protected: + explicit DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kIfConditionFieldNumber = 1, + kIfReturnFieldNumber = 2, + kElseReturnFieldNumber = 3, + }; + // .io.substrait.DerivationExpression if_condition = 1; + bool has_if_condition() const; + private: + bool _internal_has_if_condition() const; + public: + void clear_if_condition(); + const ::io::substrait::DerivationExpression& if_condition() const; + ::io::substrait::DerivationExpression* release_if_condition(); + ::io::substrait::DerivationExpression* mutable_if_condition(); + void set_allocated_if_condition(::io::substrait::DerivationExpression* if_condition); + private: + const ::io::substrait::DerivationExpression& _internal_if_condition() const; + ::io::substrait::DerivationExpression* _internal_mutable_if_condition(); + public: + void unsafe_arena_set_allocated_if_condition( + ::io::substrait::DerivationExpression* if_condition); + ::io::substrait::DerivationExpression* unsafe_arena_release_if_condition(); + + // .io.substrait.DerivationExpression if_return = 2; + bool has_if_return() const; + private: + bool _internal_has_if_return() const; + public: + void clear_if_return(); + const ::io::substrait::DerivationExpression& if_return() const; + ::io::substrait::DerivationExpression* release_if_return(); + ::io::substrait::DerivationExpression* mutable_if_return(); + void set_allocated_if_return(::io::substrait::DerivationExpression* if_return); + private: + const ::io::substrait::DerivationExpression& _internal_if_return() const; + ::io::substrait::DerivationExpression* _internal_mutable_if_return(); + public: + void unsafe_arena_set_allocated_if_return( + ::io::substrait::DerivationExpression* if_return); + ::io::substrait::DerivationExpression* unsafe_arena_release_if_return(); + + // .io.substrait.DerivationExpression else_return = 3; + bool has_else_return() const; + private: + bool _internal_has_else_return() const; + public: + void clear_else_return(); + const ::io::substrait::DerivationExpression& else_return() const; + ::io::substrait::DerivationExpression* release_else_return(); + ::io::substrait::DerivationExpression* mutable_else_return(); + void set_allocated_else_return(::io::substrait::DerivationExpression* else_return); + private: + const ::io::substrait::DerivationExpression& _internal_else_return() const; + ::io::substrait::DerivationExpression* _internal_mutable_else_return(); + public: + void unsafe_arena_set_allocated_else_return( + ::io::substrait::DerivationExpression* else_return); + ::io::substrait::DerivationExpression* unsafe_arena_release_else_return(); + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.IfElse) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::DerivationExpression* if_condition_; + ::io::substrait::DerivationExpression* if_return_; + ::io::substrait::DerivationExpression* else_return_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_UnaryOp PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.UnaryOp) */ { + public: + inline DerivationExpression_UnaryOp() : DerivationExpression_UnaryOp(nullptr) {} + ~DerivationExpression_UnaryOp() override; + explicit constexpr DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_UnaryOp(const DerivationExpression_UnaryOp& from); + DerivationExpression_UnaryOp(DerivationExpression_UnaryOp&& from) noexcept + : DerivationExpression_UnaryOp() { + *this = ::std::move(from); + } + + inline DerivationExpression_UnaryOp& operator=(const DerivationExpression_UnaryOp& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_UnaryOp& operator=(DerivationExpression_UnaryOp&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_UnaryOp& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_UnaryOp* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_UnaryOp_default_instance_); + } + static constexpr int kIndexInFileMessages = + 9; + + friend void swap(DerivationExpression_UnaryOp& a, DerivationExpression_UnaryOp& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_UnaryOp* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_UnaryOp* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_UnaryOp* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_UnaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_UnaryOp& from); + void MergeFrom(const DerivationExpression_UnaryOp& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_UnaryOp* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.UnaryOp"; + } + protected: + explicit DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef DerivationExpression_UnaryOp_OpType OpType; + static constexpr OpType UNKNOWN = + DerivationExpression_UnaryOp_OpType_UNKNOWN; + static constexpr OpType BOOLEAN_NOT = + DerivationExpression_UnaryOp_OpType_BOOLEAN_NOT; + static inline bool OpType_IsValid(int value) { + return DerivationExpression_UnaryOp_OpType_IsValid(value); + } + static constexpr OpType OpType_MIN = + DerivationExpression_UnaryOp_OpType_OpType_MIN; + static constexpr OpType OpType_MAX = + DerivationExpression_UnaryOp_OpType_OpType_MAX; + static constexpr int OpType_ARRAYSIZE = + DerivationExpression_UnaryOp_OpType_OpType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + OpType_descriptor() { + return DerivationExpression_UnaryOp_OpType_descriptor(); + } + template + static inline const std::string& OpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OpType_Name."); + return DerivationExpression_UnaryOp_OpType_Name(enum_t_value); + } + static inline bool OpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + OpType* value) { + return DerivationExpression_UnaryOp_OpType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kArgFieldNumber = 2, + kOpTypeFieldNumber = 1, + }; + // .io.substrait.DerivationExpression arg = 2; + bool has_arg() const; + private: + bool _internal_has_arg() const; + public: + void clear_arg(); + const ::io::substrait::DerivationExpression& arg() const; + ::io::substrait::DerivationExpression* release_arg(); + ::io::substrait::DerivationExpression* mutable_arg(); + void set_allocated_arg(::io::substrait::DerivationExpression* arg); + private: + const ::io::substrait::DerivationExpression& _internal_arg() const; + ::io::substrait::DerivationExpression* _internal_mutable_arg(); + public: + void unsafe_arena_set_allocated_arg( + ::io::substrait::DerivationExpression* arg); + ::io::substrait::DerivationExpression* unsafe_arena_release_arg(); + + // .io.substrait.DerivationExpression.UnaryOp.OpType op_type = 1; + void clear_op_type(); + ::io::substrait::DerivationExpression_UnaryOp_OpType op_type() const; + void set_op_type(::io::substrait::DerivationExpression_UnaryOp_OpType value); + private: + ::io::substrait::DerivationExpression_UnaryOp_OpType _internal_op_type() const; + void _internal_set_op_type(::io::substrait::DerivationExpression_UnaryOp_OpType value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.UnaryOp) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::DerivationExpression* arg_; + int op_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_BinaryOp PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.BinaryOp) */ { + public: + inline DerivationExpression_BinaryOp() : DerivationExpression_BinaryOp(nullptr) {} + ~DerivationExpression_BinaryOp() override; + explicit constexpr DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_BinaryOp(const DerivationExpression_BinaryOp& from); + DerivationExpression_BinaryOp(DerivationExpression_BinaryOp&& from) noexcept + : DerivationExpression_BinaryOp() { + *this = ::std::move(from); + } + + inline DerivationExpression_BinaryOp& operator=(const DerivationExpression_BinaryOp& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_BinaryOp& operator=(DerivationExpression_BinaryOp&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_BinaryOp& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_BinaryOp* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_BinaryOp_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(DerivationExpression_BinaryOp& a, DerivationExpression_BinaryOp& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_BinaryOp* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_BinaryOp* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_BinaryOp* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_BinaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_BinaryOp& from); + void MergeFrom(const DerivationExpression_BinaryOp& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_BinaryOp* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.BinaryOp"; + } + protected: + explicit DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef DerivationExpression_BinaryOp_OpType OpType; + static constexpr OpType UNKNOWN = + DerivationExpression_BinaryOp_OpType_UNKNOWN; + static constexpr OpType PLUS = + DerivationExpression_BinaryOp_OpType_PLUS; + static constexpr OpType MINUS = + DerivationExpression_BinaryOp_OpType_MINUS; + static constexpr OpType MULTIPLY = + DerivationExpression_BinaryOp_OpType_MULTIPLY; + static constexpr OpType DIVIDE = + DerivationExpression_BinaryOp_OpType_DIVIDE; + static constexpr OpType MIN = + DerivationExpression_BinaryOp_OpType_MIN; + static constexpr OpType MAX = + DerivationExpression_BinaryOp_OpType_MAX; + static constexpr OpType GREATER_THAN = + DerivationExpression_BinaryOp_OpType_GREATER_THAN; + static constexpr OpType LESS_THAN = + DerivationExpression_BinaryOp_OpType_LESS_THAN; + static constexpr OpType AND = + DerivationExpression_BinaryOp_OpType_AND; + static constexpr OpType OR = + DerivationExpression_BinaryOp_OpType_OR; + static constexpr OpType EQUALS = + DerivationExpression_BinaryOp_OpType_EQUALS; + static constexpr OpType COVERS = + DerivationExpression_BinaryOp_OpType_COVERS; + static inline bool OpType_IsValid(int value) { + return DerivationExpression_BinaryOp_OpType_IsValid(value); + } + static constexpr OpType OpType_MIN = + DerivationExpression_BinaryOp_OpType_OpType_MIN; + static constexpr OpType OpType_MAX = + DerivationExpression_BinaryOp_OpType_OpType_MAX; + static constexpr int OpType_ARRAYSIZE = + DerivationExpression_BinaryOp_OpType_OpType_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + OpType_descriptor() { + return DerivationExpression_BinaryOp_OpType_descriptor(); + } + template + static inline const std::string& OpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function OpType_Name."); + return DerivationExpression_BinaryOp_OpType_Name(enum_t_value); + } + static inline bool OpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + OpType* value) { + return DerivationExpression_BinaryOp_OpType_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kArg1FieldNumber = 2, + kArg2FieldNumber = 3, + kOpTypeFieldNumber = 1, + }; + // .io.substrait.DerivationExpression arg1 = 2; + bool has_arg1() const; + private: + bool _internal_has_arg1() const; + public: + void clear_arg1(); + const ::io::substrait::DerivationExpression& arg1() const; + ::io::substrait::DerivationExpression* release_arg1(); + ::io::substrait::DerivationExpression* mutable_arg1(); + void set_allocated_arg1(::io::substrait::DerivationExpression* arg1); + private: + const ::io::substrait::DerivationExpression& _internal_arg1() const; + ::io::substrait::DerivationExpression* _internal_mutable_arg1(); + public: + void unsafe_arena_set_allocated_arg1( + ::io::substrait::DerivationExpression* arg1); + ::io::substrait::DerivationExpression* unsafe_arena_release_arg1(); + + // .io.substrait.DerivationExpression arg2 = 3; + bool has_arg2() const; + private: + bool _internal_has_arg2() const; + public: + void clear_arg2(); + const ::io::substrait::DerivationExpression& arg2() const; + ::io::substrait::DerivationExpression* release_arg2(); + ::io::substrait::DerivationExpression* mutable_arg2(); + void set_allocated_arg2(::io::substrait::DerivationExpression* arg2); + private: + const ::io::substrait::DerivationExpression& _internal_arg2() const; + ::io::substrait::DerivationExpression* _internal_mutable_arg2(); + public: + void unsafe_arena_set_allocated_arg2( + ::io::substrait::DerivationExpression* arg2); + ::io::substrait::DerivationExpression* unsafe_arena_release_arg2(); + + // .io.substrait.DerivationExpression.BinaryOp.OpType op_type = 1; + void clear_op_type(); + ::io::substrait::DerivationExpression_BinaryOp_OpType op_type() const; + void set_op_type(::io::substrait::DerivationExpression_BinaryOp_OpType value); + private: + ::io::substrait::DerivationExpression_BinaryOp_OpType _internal_op_type() const; + void _internal_set_op_type(::io::substrait::DerivationExpression_BinaryOp_OpType value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.BinaryOp) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::DerivationExpression* arg1_; + ::io::substrait::DerivationExpression* arg2_; + int op_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression) */ { + public: + inline DerivationExpression() : DerivationExpression(nullptr) {} + ~DerivationExpression() override; + explicit constexpr DerivationExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression(const DerivationExpression& from); + DerivationExpression(DerivationExpression&& from) noexcept + : DerivationExpression() { + *this = ::std::move(from); + } + + inline DerivationExpression& operator=(const DerivationExpression& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression& operator=(DerivationExpression&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression& default_instance() { + return *internal_default_instance(); + } + enum KindCase { + kBool = 1, + kI8 = 2, + kI16 = 3, + kI32 = 5, + kI64 = 7, + kFp32 = 10, + kFp64 = 11, + kString = 12, + kBinary = 13, + kTimestamp = 14, + kDate = 16, + kTime = 17, + kIntervalYear = 19, + kIntervalDay = 20, + kTimestampTz = 29, + kUuid = 32, + kFixedChar = 21, + kVarchar = 22, + kFixedBinary = 23, + kDecimal = 24, + kStruct = 25, + kList = 27, + kMap = 28, + kUserDefined = 31, + kTypeParameterName = 33, + kIntegerParameterName = 34, + kIntegerLiteral = 35, + kUnaryOp = 36, + kBinaryOp = 37, + kIfElse = 38, + KIND_NOT_SET = 0, + }; + + static inline const DerivationExpression* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(DerivationExpression& a, DerivationExpression& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression& from); + void MergeFrom(const DerivationExpression& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression"; + } + protected: + explicit DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef DerivationExpression_ExpressionFixedChar ExpressionFixedChar; + typedef DerivationExpression_ExpressionVarChar ExpressionVarChar; + typedef DerivationExpression_ExpressionFixedBinary ExpressionFixedBinary; + typedef DerivationExpression_ExpressionDecimal ExpressionDecimal; + typedef DerivationExpression_ExpressionStruct ExpressionStruct; + typedef DerivationExpression_ExpressionNamedStruct ExpressionNamedStruct; + typedef DerivationExpression_ExpressionList ExpressionList; + typedef DerivationExpression_ExpressionMap ExpressionMap; + typedef DerivationExpression_IfElse IfElse; + typedef DerivationExpression_UnaryOp UnaryOp; + typedef DerivationExpression_BinaryOp BinaryOp; + + // accessors ------------------------------------------------------- + + enum : int { + kBoolFieldNumber = 1, + kI8FieldNumber = 2, + kI16FieldNumber = 3, + kI32FieldNumber = 5, + kI64FieldNumber = 7, + kFp32FieldNumber = 10, + kFp64FieldNumber = 11, + kStringFieldNumber = 12, + kBinaryFieldNumber = 13, + kTimestampFieldNumber = 14, + kDateFieldNumber = 16, + kTimeFieldNumber = 17, + kIntervalYearFieldNumber = 19, + kIntervalDayFieldNumber = 20, + kTimestampTzFieldNumber = 29, + kUuidFieldNumber = 32, + kFixedCharFieldNumber = 21, + kVarcharFieldNumber = 22, + kFixedBinaryFieldNumber = 23, + kDecimalFieldNumber = 24, + kStructFieldNumber = 25, + kListFieldNumber = 27, + kMapFieldNumber = 28, + kUserDefinedFieldNumber = 31, + kTypeParameterNameFieldNumber = 33, + kIntegerParameterNameFieldNumber = 34, + kIntegerLiteralFieldNumber = 35, + kUnaryOpFieldNumber = 36, + kBinaryOpFieldNumber = 37, + kIfElseFieldNumber = 38, + }; + // .io.substrait.Type.Boolean bool = 1; + bool has_bool_() const; + private: + bool _internal_has_bool_() const; + public: + void clear_bool_(); + const ::io::substrait::Type_Boolean& bool_() const; + ::io::substrait::Type_Boolean* release_bool_(); + ::io::substrait::Type_Boolean* mutable_bool_(); + void set_allocated_bool_(::io::substrait::Type_Boolean* bool_); + private: + const ::io::substrait::Type_Boolean& _internal_bool_() const; + ::io::substrait::Type_Boolean* _internal_mutable_bool_(); + public: + void unsafe_arena_set_allocated_bool_( + ::io::substrait::Type_Boolean* bool_); + ::io::substrait::Type_Boolean* unsafe_arena_release_bool_(); + + // .io.substrait.Type.I8 i8 = 2; + bool has_i8() const; + private: + bool _internal_has_i8() const; + public: + void clear_i8(); + const ::io::substrait::Type_I8& i8() const; + ::io::substrait::Type_I8* release_i8(); + ::io::substrait::Type_I8* mutable_i8(); + void set_allocated_i8(::io::substrait::Type_I8* i8); + private: + const ::io::substrait::Type_I8& _internal_i8() const; + ::io::substrait::Type_I8* _internal_mutable_i8(); + public: + void unsafe_arena_set_allocated_i8( + ::io::substrait::Type_I8* i8); + ::io::substrait::Type_I8* unsafe_arena_release_i8(); + + // .io.substrait.Type.I16 i16 = 3; + bool has_i16() const; + private: + bool _internal_has_i16() const; + public: + void clear_i16(); + const ::io::substrait::Type_I16& i16() const; + ::io::substrait::Type_I16* release_i16(); + ::io::substrait::Type_I16* mutable_i16(); + void set_allocated_i16(::io::substrait::Type_I16* i16); + private: + const ::io::substrait::Type_I16& _internal_i16() const; + ::io::substrait::Type_I16* _internal_mutable_i16(); + public: + void unsafe_arena_set_allocated_i16( + ::io::substrait::Type_I16* i16); + ::io::substrait::Type_I16* unsafe_arena_release_i16(); + + // .io.substrait.Type.I32 i32 = 5; + bool has_i32() const; + private: + bool _internal_has_i32() const; + public: + void clear_i32(); + const ::io::substrait::Type_I32& i32() const; + ::io::substrait::Type_I32* release_i32(); + ::io::substrait::Type_I32* mutable_i32(); + void set_allocated_i32(::io::substrait::Type_I32* i32); + private: + const ::io::substrait::Type_I32& _internal_i32() const; + ::io::substrait::Type_I32* _internal_mutable_i32(); + public: + void unsafe_arena_set_allocated_i32( + ::io::substrait::Type_I32* i32); + ::io::substrait::Type_I32* unsafe_arena_release_i32(); + + // .io.substrait.Type.I64 i64 = 7; + bool has_i64() const; + private: + bool _internal_has_i64() const; + public: + void clear_i64(); + const ::io::substrait::Type_I64& i64() const; + ::io::substrait::Type_I64* release_i64(); + ::io::substrait::Type_I64* mutable_i64(); + void set_allocated_i64(::io::substrait::Type_I64* i64); + private: + const ::io::substrait::Type_I64& _internal_i64() const; + ::io::substrait::Type_I64* _internal_mutable_i64(); + public: + void unsafe_arena_set_allocated_i64( + ::io::substrait::Type_I64* i64); + ::io::substrait::Type_I64* unsafe_arena_release_i64(); + + // .io.substrait.Type.FP32 fp32 = 10; + bool has_fp32() const; + private: + bool _internal_has_fp32() const; + public: + void clear_fp32(); + const ::io::substrait::Type_FP32& fp32() const; + ::io::substrait::Type_FP32* release_fp32(); + ::io::substrait::Type_FP32* mutable_fp32(); + void set_allocated_fp32(::io::substrait::Type_FP32* fp32); + private: + const ::io::substrait::Type_FP32& _internal_fp32() const; + ::io::substrait::Type_FP32* _internal_mutable_fp32(); + public: + void unsafe_arena_set_allocated_fp32( + ::io::substrait::Type_FP32* fp32); + ::io::substrait::Type_FP32* unsafe_arena_release_fp32(); + + // .io.substrait.Type.FP64 fp64 = 11; + bool has_fp64() const; + private: + bool _internal_has_fp64() const; + public: + void clear_fp64(); + const ::io::substrait::Type_FP64& fp64() const; + ::io::substrait::Type_FP64* release_fp64(); + ::io::substrait::Type_FP64* mutable_fp64(); + void set_allocated_fp64(::io::substrait::Type_FP64* fp64); + private: + const ::io::substrait::Type_FP64& _internal_fp64() const; + ::io::substrait::Type_FP64* _internal_mutable_fp64(); + public: + void unsafe_arena_set_allocated_fp64( + ::io::substrait::Type_FP64* fp64); + ::io::substrait::Type_FP64* unsafe_arena_release_fp64(); + + // .io.substrait.Type.String string = 12; + bool has_string() const; + private: + bool _internal_has_string() const; + public: + void clear_string(); + const ::io::substrait::Type_String& string() const; + ::io::substrait::Type_String* release_string(); + ::io::substrait::Type_String* mutable_string(); + void set_allocated_string(::io::substrait::Type_String* string); + private: + const ::io::substrait::Type_String& _internal_string() const; + ::io::substrait::Type_String* _internal_mutable_string(); + public: + void unsafe_arena_set_allocated_string( + ::io::substrait::Type_String* string); + ::io::substrait::Type_String* unsafe_arena_release_string(); + + // .io.substrait.Type.Binary binary = 13; + bool has_binary() const; + private: + bool _internal_has_binary() const; + public: + void clear_binary(); + const ::io::substrait::Type_Binary& binary() const; + ::io::substrait::Type_Binary* release_binary(); + ::io::substrait::Type_Binary* mutable_binary(); + void set_allocated_binary(::io::substrait::Type_Binary* binary); + private: + const ::io::substrait::Type_Binary& _internal_binary() const; + ::io::substrait::Type_Binary* _internal_mutable_binary(); + public: + void unsafe_arena_set_allocated_binary( + ::io::substrait::Type_Binary* binary); + ::io::substrait::Type_Binary* unsafe_arena_release_binary(); + + // .io.substrait.Type.Timestamp timestamp = 14; + bool has_timestamp() const; + private: + bool _internal_has_timestamp() const; + public: + void clear_timestamp(); + const ::io::substrait::Type_Timestamp& timestamp() const; + ::io::substrait::Type_Timestamp* release_timestamp(); + ::io::substrait::Type_Timestamp* mutable_timestamp(); + void set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp); + private: + const ::io::substrait::Type_Timestamp& _internal_timestamp() const; + ::io::substrait::Type_Timestamp* _internal_mutable_timestamp(); + public: + void unsafe_arena_set_allocated_timestamp( + ::io::substrait::Type_Timestamp* timestamp); + ::io::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); + + // .io.substrait.Type.Date date = 16; + bool has_date() const; + private: + bool _internal_has_date() const; + public: + void clear_date(); + const ::io::substrait::Type_Date& date() const; + ::io::substrait::Type_Date* release_date(); + ::io::substrait::Type_Date* mutable_date(); + void set_allocated_date(::io::substrait::Type_Date* date); + private: + const ::io::substrait::Type_Date& _internal_date() const; + ::io::substrait::Type_Date* _internal_mutable_date(); + public: + void unsafe_arena_set_allocated_date( + ::io::substrait::Type_Date* date); + ::io::substrait::Type_Date* unsafe_arena_release_date(); + + // .io.substrait.Type.Time time = 17; + bool has_time() const; + private: + bool _internal_has_time() const; + public: + void clear_time(); + const ::io::substrait::Type_Time& time() const; + ::io::substrait::Type_Time* release_time(); + ::io::substrait::Type_Time* mutable_time(); + void set_allocated_time(::io::substrait::Type_Time* time); + private: + const ::io::substrait::Type_Time& _internal_time() const; + ::io::substrait::Type_Time* _internal_mutable_time(); + public: + void unsafe_arena_set_allocated_time( + ::io::substrait::Type_Time* time); + ::io::substrait::Type_Time* unsafe_arena_release_time(); + + // .io.substrait.Type.IntervalYear interval_year = 19; + bool has_interval_year() const; + private: + bool _internal_has_interval_year() const; + public: + void clear_interval_year(); + const ::io::substrait::Type_IntervalYear& interval_year() const; + ::io::substrait::Type_IntervalYear* release_interval_year(); + ::io::substrait::Type_IntervalYear* mutable_interval_year(); + void set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year); + private: + const ::io::substrait::Type_IntervalYear& _internal_interval_year() const; + ::io::substrait::Type_IntervalYear* _internal_mutable_interval_year(); + public: + void unsafe_arena_set_allocated_interval_year( + ::io::substrait::Type_IntervalYear* interval_year); + ::io::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); + + // .io.substrait.Type.IntervalDay interval_day = 20; + bool has_interval_day() const; + private: + bool _internal_has_interval_day() const; + public: + void clear_interval_day(); + const ::io::substrait::Type_IntervalDay& interval_day() const; + ::io::substrait::Type_IntervalDay* release_interval_day(); + ::io::substrait::Type_IntervalDay* mutable_interval_day(); + void set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day); + private: + const ::io::substrait::Type_IntervalDay& _internal_interval_day() const; + ::io::substrait::Type_IntervalDay* _internal_mutable_interval_day(); + public: + void unsafe_arena_set_allocated_interval_day( + ::io::substrait::Type_IntervalDay* interval_day); + ::io::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); + + // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + bool has_timestamp_tz() const; + private: + bool _internal_has_timestamp_tz() const; + public: + void clear_timestamp_tz(); + const ::io::substrait::Type_TimestampTZ& timestamp_tz() const; + ::io::substrait::Type_TimestampTZ* release_timestamp_tz(); + ::io::substrait::Type_TimestampTZ* mutable_timestamp_tz(); + void set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz); + private: + const ::io::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; + ::io::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); + public: + void unsafe_arena_set_allocated_timestamp_tz( + ::io::substrait::Type_TimestampTZ* timestamp_tz); + ::io::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); + + // .io.substrait.Type.UUID uuid = 32; + bool has_uuid() const; + private: + bool _internal_has_uuid() const; + public: + void clear_uuid(); + const ::io::substrait::Type_UUID& uuid() const; + ::io::substrait::Type_UUID* release_uuid(); + ::io::substrait::Type_UUID* mutable_uuid(); + void set_allocated_uuid(::io::substrait::Type_UUID* uuid); + private: + const ::io::substrait::Type_UUID& _internal_uuid() const; + ::io::substrait::Type_UUID* _internal_mutable_uuid(); + public: + void unsafe_arena_set_allocated_uuid( + ::io::substrait::Type_UUID* uuid); + ::io::substrait::Type_UUID* unsafe_arena_release_uuid(); + + // .io.substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; + bool has_fixed_char() const; + private: + bool _internal_has_fixed_char() const; + public: + void clear_fixed_char(); + const ::io::substrait::DerivationExpression_ExpressionFixedChar& fixed_char() const; + ::io::substrait::DerivationExpression_ExpressionFixedChar* release_fixed_char(); + ::io::substrait::DerivationExpression_ExpressionFixedChar* mutable_fixed_char(); + void set_allocated_fixed_char(::io::substrait::DerivationExpression_ExpressionFixedChar* fixed_char); + private: + const ::io::substrait::DerivationExpression_ExpressionFixedChar& _internal_fixed_char() const; + ::io::substrait::DerivationExpression_ExpressionFixedChar* _internal_mutable_fixed_char(); + public: + void unsafe_arena_set_allocated_fixed_char( + ::io::substrait::DerivationExpression_ExpressionFixedChar* fixed_char); + ::io::substrait::DerivationExpression_ExpressionFixedChar* unsafe_arena_release_fixed_char(); + + // .io.substrait.DerivationExpression.ExpressionVarChar varchar = 22; + bool has_varchar() const; + private: + bool _internal_has_varchar() const; + public: + void clear_varchar(); + const ::io::substrait::DerivationExpression_ExpressionVarChar& varchar() const; + ::io::substrait::DerivationExpression_ExpressionVarChar* release_varchar(); + ::io::substrait::DerivationExpression_ExpressionVarChar* mutable_varchar(); + void set_allocated_varchar(::io::substrait::DerivationExpression_ExpressionVarChar* varchar); + private: + const ::io::substrait::DerivationExpression_ExpressionVarChar& _internal_varchar() const; + ::io::substrait::DerivationExpression_ExpressionVarChar* _internal_mutable_varchar(); + public: + void unsafe_arena_set_allocated_varchar( + ::io::substrait::DerivationExpression_ExpressionVarChar* varchar); + ::io::substrait::DerivationExpression_ExpressionVarChar* unsafe_arena_release_varchar(); + + // .io.substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; + bool has_fixed_binary() const; + private: + bool _internal_has_fixed_binary() const; + public: + void clear_fixed_binary(); + const ::io::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary() const; + ::io::substrait::DerivationExpression_ExpressionFixedBinary* release_fixed_binary(); + ::io::substrait::DerivationExpression_ExpressionFixedBinary* mutable_fixed_binary(); + void set_allocated_fixed_binary(::io::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary); + private: + const ::io::substrait::DerivationExpression_ExpressionFixedBinary& _internal_fixed_binary() const; + ::io::substrait::DerivationExpression_ExpressionFixedBinary* _internal_mutable_fixed_binary(); + public: + void unsafe_arena_set_allocated_fixed_binary( + ::io::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary); + ::io::substrait::DerivationExpression_ExpressionFixedBinary* unsafe_arena_release_fixed_binary(); + + // .io.substrait.DerivationExpression.ExpressionDecimal decimal = 24; + bool has_decimal() const; + private: + bool _internal_has_decimal() const; + public: + void clear_decimal(); + const ::io::substrait::DerivationExpression_ExpressionDecimal& decimal() const; + ::io::substrait::DerivationExpression_ExpressionDecimal* release_decimal(); + ::io::substrait::DerivationExpression_ExpressionDecimal* mutable_decimal(); + void set_allocated_decimal(::io::substrait::DerivationExpression_ExpressionDecimal* decimal); + private: + const ::io::substrait::DerivationExpression_ExpressionDecimal& _internal_decimal() const; + ::io::substrait::DerivationExpression_ExpressionDecimal* _internal_mutable_decimal(); + public: + void unsafe_arena_set_allocated_decimal( + ::io::substrait::DerivationExpression_ExpressionDecimal* decimal); + ::io::substrait::DerivationExpression_ExpressionDecimal* unsafe_arena_release_decimal(); + + // .io.substrait.DerivationExpression.ExpressionStruct struct = 25; + bool has_struct_() const; + private: + bool _internal_has_struct_() const; + public: + void clear_struct_(); + const ::io::substrait::DerivationExpression_ExpressionStruct& struct_() const; + ::io::substrait::DerivationExpression_ExpressionStruct* release_struct_(); + ::io::substrait::DerivationExpression_ExpressionStruct* mutable_struct_(); + void set_allocated_struct_(::io::substrait::DerivationExpression_ExpressionStruct* struct_); + private: + const ::io::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const; + ::io::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_(); + public: + void unsafe_arena_set_allocated_struct_( + ::io::substrait::DerivationExpression_ExpressionStruct* struct_); + ::io::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_(); + + // .io.substrait.DerivationExpression.ExpressionList list = 27; + bool has_list() const; + private: + bool _internal_has_list() const; + public: + void clear_list(); + const ::io::substrait::DerivationExpression_ExpressionList& list() const; + ::io::substrait::DerivationExpression_ExpressionList* release_list(); + ::io::substrait::DerivationExpression_ExpressionList* mutable_list(); + void set_allocated_list(::io::substrait::DerivationExpression_ExpressionList* list); + private: + const ::io::substrait::DerivationExpression_ExpressionList& _internal_list() const; + ::io::substrait::DerivationExpression_ExpressionList* _internal_mutable_list(); + public: + void unsafe_arena_set_allocated_list( + ::io::substrait::DerivationExpression_ExpressionList* list); + ::io::substrait::DerivationExpression_ExpressionList* unsafe_arena_release_list(); + + // .io.substrait.DerivationExpression.ExpressionMap map = 28; + bool has_map() const; + private: + bool _internal_has_map() const; + public: + void clear_map(); + const ::io::substrait::DerivationExpression_ExpressionMap& map() const; + ::io::substrait::DerivationExpression_ExpressionMap* release_map(); + ::io::substrait::DerivationExpression_ExpressionMap* mutable_map(); + void set_allocated_map(::io::substrait::DerivationExpression_ExpressionMap* map); + private: + const ::io::substrait::DerivationExpression_ExpressionMap& _internal_map() const; + ::io::substrait::DerivationExpression_ExpressionMap* _internal_mutable_map(); + public: + void unsafe_arena_set_allocated_map( + ::io::substrait::DerivationExpression_ExpressionMap* map); + ::io::substrait::DerivationExpression_ExpressionMap* unsafe_arena_release_map(); + + // .io.substrait.Extensions.TypeId user_defined = 31; + bool has_user_defined() const; + private: + bool _internal_has_user_defined() const; + public: + void clear_user_defined(); + const ::io::substrait::Extensions_TypeId& user_defined() const; + ::io::substrait::Extensions_TypeId* release_user_defined(); + ::io::substrait::Extensions_TypeId* mutable_user_defined(); + void set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined); + private: + const ::io::substrait::Extensions_TypeId& _internal_user_defined() const; + ::io::substrait::Extensions_TypeId* _internal_mutable_user_defined(); + public: + void unsafe_arena_set_allocated_user_defined( + ::io::substrait::Extensions_TypeId* user_defined); + ::io::substrait::Extensions_TypeId* unsafe_arena_release_user_defined(); + + // string type_parameter_name = 33; + bool has_type_parameter_name() const; + private: + bool _internal_has_type_parameter_name() const; + public: + void clear_type_parameter_name(); + const std::string& type_parameter_name() const; + template + void set_type_parameter_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_type_parameter_name(); + std::string* release_type_parameter_name(); + void set_allocated_type_parameter_name(std::string* type_parameter_name); + private: + const std::string& _internal_type_parameter_name() const; + void _internal_set_type_parameter_name(const std::string& value); + std::string* _internal_mutable_type_parameter_name(); + public: + + // string integer_parameter_name = 34; + bool has_integer_parameter_name() const; + private: + bool _internal_has_integer_parameter_name() const; + public: + void clear_integer_parameter_name(); + const std::string& integer_parameter_name() const; + template + void set_integer_parameter_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_integer_parameter_name(); + std::string* release_integer_parameter_name(); + void set_allocated_integer_parameter_name(std::string* integer_parameter_name); + private: + const std::string& _internal_integer_parameter_name() const; + void _internal_set_integer_parameter_name(const std::string& value); + std::string* _internal_mutable_integer_parameter_name(); + public: + + // int32 integer_literal = 35; + bool has_integer_literal() const; + private: + bool _internal_has_integer_literal() const; + public: + void clear_integer_literal(); + ::PROTOBUF_NAMESPACE_ID::int32 integer_literal() const; + void set_integer_literal(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_integer_literal() const; + void _internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // .io.substrait.DerivationExpression.UnaryOp unary_op = 36; + bool has_unary_op() const; + private: + bool _internal_has_unary_op() const; + public: + void clear_unary_op(); + const ::io::substrait::DerivationExpression_UnaryOp& unary_op() const; + ::io::substrait::DerivationExpression_UnaryOp* release_unary_op(); + ::io::substrait::DerivationExpression_UnaryOp* mutable_unary_op(); + void set_allocated_unary_op(::io::substrait::DerivationExpression_UnaryOp* unary_op); + private: + const ::io::substrait::DerivationExpression_UnaryOp& _internal_unary_op() const; + ::io::substrait::DerivationExpression_UnaryOp* _internal_mutable_unary_op(); + public: + void unsafe_arena_set_allocated_unary_op( + ::io::substrait::DerivationExpression_UnaryOp* unary_op); + ::io::substrait::DerivationExpression_UnaryOp* unsafe_arena_release_unary_op(); + + // .io.substrait.DerivationExpression.BinaryOp binary_op = 37; + bool has_binary_op() const; + private: + bool _internal_has_binary_op() const; + public: + void clear_binary_op(); + const ::io::substrait::DerivationExpression_BinaryOp& binary_op() const; + ::io::substrait::DerivationExpression_BinaryOp* release_binary_op(); + ::io::substrait::DerivationExpression_BinaryOp* mutable_binary_op(); + void set_allocated_binary_op(::io::substrait::DerivationExpression_BinaryOp* binary_op); + private: + const ::io::substrait::DerivationExpression_BinaryOp& _internal_binary_op() const; + ::io::substrait::DerivationExpression_BinaryOp* _internal_mutable_binary_op(); + public: + void unsafe_arena_set_allocated_binary_op( + ::io::substrait::DerivationExpression_BinaryOp* binary_op); + ::io::substrait::DerivationExpression_BinaryOp* unsafe_arena_release_binary_op(); + + // .io.substrait.DerivationExpression.IfElse if_else = 38; + bool has_if_else() const; + private: + bool _internal_has_if_else() const; + public: + void clear_if_else(); + const ::io::substrait::DerivationExpression_IfElse& if_else() const; + ::io::substrait::DerivationExpression_IfElse* release_if_else(); + ::io::substrait::DerivationExpression_IfElse* mutable_if_else(); + void set_allocated_if_else(::io::substrait::DerivationExpression_IfElse* if_else); + private: + const ::io::substrait::DerivationExpression_IfElse& _internal_if_else() const; + ::io::substrait::DerivationExpression_IfElse* _internal_mutable_if_else(); + public: + void unsafe_arena_set_allocated_if_else( + ::io::substrait::DerivationExpression_IfElse* if_else); + ::io::substrait::DerivationExpression_IfElse* unsafe_arena_release_if_else(); + + void clear_kind(); + KindCase kind_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression) + private: + class _Internal; + void set_has_bool_(); + void set_has_i8(); + void set_has_i16(); + void set_has_i32(); + void set_has_i64(); + void set_has_fp32(); + void set_has_fp64(); + void set_has_string(); + void set_has_binary(); + void set_has_timestamp(); + void set_has_date(); + void set_has_time(); + void set_has_interval_year(); + void set_has_interval_day(); + void set_has_timestamp_tz(); + void set_has_uuid(); + void set_has_fixed_char(); + void set_has_varchar(); + void set_has_fixed_binary(); + void set_has_decimal(); + void set_has_struct_(); + void set_has_list(); + void set_has_map(); + void set_has_user_defined(); + void set_has_type_parameter_name(); + void set_has_integer_parameter_name(); + void set_has_integer_literal(); + void set_has_unary_op(); + void set_has_binary_op(); + void set_has_if_else(); + + inline bool has_kind() const; + inline void clear_has_kind(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union KindUnion { + constexpr KindUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Type_Boolean* bool__; + ::io::substrait::Type_I8* i8_; + ::io::substrait::Type_I16* i16_; + ::io::substrait::Type_I32* i32_; + ::io::substrait::Type_I64* i64_; + ::io::substrait::Type_FP32* fp32_; + ::io::substrait::Type_FP64* fp64_; + ::io::substrait::Type_String* string_; + ::io::substrait::Type_Binary* binary_; + ::io::substrait::Type_Timestamp* timestamp_; + ::io::substrait::Type_Date* date_; + ::io::substrait::Type_Time* time_; + ::io::substrait::Type_IntervalYear* interval_year_; + ::io::substrait::Type_IntervalDay* interval_day_; + ::io::substrait::Type_TimestampTZ* timestamp_tz_; + ::io::substrait::Type_UUID* uuid_; + ::io::substrait::DerivationExpression_ExpressionFixedChar* fixed_char_; + ::io::substrait::DerivationExpression_ExpressionVarChar* varchar_; + ::io::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary_; + ::io::substrait::DerivationExpression_ExpressionDecimal* decimal_; + ::io::substrait::DerivationExpression_ExpressionStruct* struct__; + ::io::substrait::DerivationExpression_ExpressionList* list_; + ::io::substrait::DerivationExpression_ExpressionMap* map_; + ::io::substrait::Extensions_TypeId* user_defined_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_parameter_name_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr integer_parameter_name_; + ::PROTOBUF_NAMESPACE_ID::int32 integer_literal_; + ::io::substrait::DerivationExpression_UnaryOp* unary_op_; + ::io::substrait::DerivationExpression_BinaryOp* binary_op_; + ::io::substrait::DerivationExpression_IfElse* if_else_; + } kind_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// DerivationExpression_ExpressionFixedChar + +// .io.substrait.DerivationExpression length = 1; +inline bool DerivationExpression_ExpressionFixedChar::_internal_has_length() const { + return this != internal_default_instance() && length_ != nullptr; +} +inline bool DerivationExpression_ExpressionFixedChar::has_length() const { + return _internal_has_length(); +} +inline void DerivationExpression_ExpressionFixedChar::clear_length() { + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::_internal_length() const { + const ::io::substrait::DerivationExpression* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::length() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedChar.length) + return _internal_length(); +} +inline void DerivationExpression_ExpressionFixedChar::unsafe_arena_set_allocated_length( + ::io::substrait::DerivationExpression* length) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); + } + length_ = length; + if (length) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionFixedChar.length) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::release_length() { + + ::io::substrait::DerivationExpression* temp = length_; + length_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionFixedChar.length) + + ::io::substrait::DerivationExpression* temp = length_; + length_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::_internal_mutable_length() { + + if (length_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + length_ = p; + } + return length_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::mutable_length() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionFixedChar.length) + return _internal_mutable_length(); +} +inline void DerivationExpression_ExpressionFixedChar::set_allocated_length(::io::substrait::DerivationExpression* length) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete length_; + } + if (length) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + if (message_arena != submessage_arena) { + length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, length, submessage_arena); + } + + } else { + + } + length_ = length; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionFixedChar.length) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool DerivationExpression_ExpressionFixedChar::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool DerivationExpression_ExpressionFixedChar::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionFixedChar::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionFixedChar::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedChar.variation) + return _internal_variation(); +} +inline void DerivationExpression_ExpressionFixedChar::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionFixedChar.variation) +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedChar::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedChar::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionFixedChar.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedChar::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedChar::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionFixedChar.variation) + return _internal_mutable_variation(); +} +inline void DerivationExpression_ExpressionFixedChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionFixedChar.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void DerivationExpression_ExpressionFixedChar::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedChar.nullability) + return _internal_nullability(); +} +inline void DerivationExpression_ExpressionFixedChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void DerivationExpression_ExpressionFixedChar::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionFixedChar.nullability) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_ExpressionVarChar + +// .io.substrait.DerivationExpression length = 1; +inline bool DerivationExpression_ExpressionVarChar::_internal_has_length() const { + return this != internal_default_instance() && length_ != nullptr; +} +inline bool DerivationExpression_ExpressionVarChar::has_length() const { + return _internal_has_length(); +} +inline void DerivationExpression_ExpressionVarChar::clear_length() { + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::_internal_length() const { + const ::io::substrait::DerivationExpression* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::length() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionVarChar.length) + return _internal_length(); +} +inline void DerivationExpression_ExpressionVarChar::unsafe_arena_set_allocated_length( + ::io::substrait::DerivationExpression* length) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); + } + length_ = length; + if (length) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionVarChar.length) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::release_length() { + + ::io::substrait::DerivationExpression* temp = length_; + length_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionVarChar.length) + + ::io::substrait::DerivationExpression* temp = length_; + length_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::_internal_mutable_length() { + + if (length_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + length_ = p; + } + return length_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::mutable_length() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionVarChar.length) + return _internal_mutable_length(); +} +inline void DerivationExpression_ExpressionVarChar::set_allocated_length(::io::substrait::DerivationExpression* length) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete length_; + } + if (length) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + if (message_arena != submessage_arena) { + length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, length, submessage_arena); + } + + } else { + + } + length_ = length; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionVarChar.length) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool DerivationExpression_ExpressionVarChar::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool DerivationExpression_ExpressionVarChar::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionVarChar::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionVarChar::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionVarChar.variation) + return _internal_variation(); +} +inline void DerivationExpression_ExpressionVarChar::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionVarChar.variation) +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionVarChar::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionVarChar::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionVarChar.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionVarChar::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionVarChar::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionVarChar.variation) + return _internal_mutable_variation(); +} +inline void DerivationExpression_ExpressionVarChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionVarChar.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void DerivationExpression_ExpressionVarChar::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionVarChar.nullability) + return _internal_nullability(); +} +inline void DerivationExpression_ExpressionVarChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void DerivationExpression_ExpressionVarChar::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionVarChar.nullability) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_ExpressionFixedBinary + +// .io.substrait.DerivationExpression length = 1; +inline bool DerivationExpression_ExpressionFixedBinary::_internal_has_length() const { + return this != internal_default_instance() && length_ != nullptr; +} +inline bool DerivationExpression_ExpressionFixedBinary::has_length() const { + return _internal_has_length(); +} +inline void DerivationExpression_ExpressionFixedBinary::clear_length() { + if (GetArena() == nullptr && length_ != nullptr) { + delete length_; + } + length_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::_internal_length() const { + const ::io::substrait::DerivationExpression* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::length() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedBinary.length) + return _internal_length(); +} +inline void DerivationExpression_ExpressionFixedBinary::unsafe_arena_set_allocated_length( + ::io::substrait::DerivationExpression* length) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); + } + length_ = length; + if (length) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionFixedBinary.length) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::release_length() { + + ::io::substrait::DerivationExpression* temp = length_; + length_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionFixedBinary.length) + + ::io::substrait::DerivationExpression* temp = length_; + length_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::_internal_mutable_length() { + + if (length_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + length_ = p; + } + return length_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::mutable_length() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionFixedBinary.length) + return _internal_mutable_length(); +} +inline void DerivationExpression_ExpressionFixedBinary::set_allocated_length(::io::substrait::DerivationExpression* length) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete length_; + } + if (length) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + if (message_arena != submessage_arena) { + length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, length, submessage_arena); + } + + } else { + + } + length_ = length; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionFixedBinary.length) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool DerivationExpression_ExpressionFixedBinary::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool DerivationExpression_ExpressionFixedBinary::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionFixedBinary::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionFixedBinary::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedBinary.variation) + return _internal_variation(); +} +inline void DerivationExpression_ExpressionFixedBinary::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionFixedBinary.variation) +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedBinary::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedBinary::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionFixedBinary.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedBinary::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedBinary::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionFixedBinary.variation) + return _internal_mutable_variation(); +} +inline void DerivationExpression_ExpressionFixedBinary::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionFixedBinary.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void DerivationExpression_ExpressionFixedBinary::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedBinary.nullability) + return _internal_nullability(); +} +inline void DerivationExpression_ExpressionFixedBinary::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void DerivationExpression_ExpressionFixedBinary::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionFixedBinary.nullability) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_ExpressionDecimal + +// .io.substrait.DerivationExpression scale = 1; +inline bool DerivationExpression_ExpressionDecimal::_internal_has_scale() const { + return this != internal_default_instance() && scale_ != nullptr; +} +inline bool DerivationExpression_ExpressionDecimal::has_scale() const { + return _internal_has_scale(); +} +inline void DerivationExpression_ExpressionDecimal::clear_scale() { + if (GetArena() == nullptr && scale_ != nullptr) { + delete scale_; + } + scale_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_scale() const { + const ::io::substrait::DerivationExpression* p = scale_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::scale() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionDecimal.scale) + return _internal_scale(); +} +inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_scale( + ::io::substrait::DerivationExpression* scale) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_); + } + scale_ = scale; + if (scale) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.scale) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_scale() { + + ::io::substrait::DerivationExpression* temp = scale_; + scale_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_scale() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionDecimal.scale) + + ::io::substrait::DerivationExpression* temp = scale_; + scale_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_scale() { + + if (scale_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + scale_ = p; + } + return scale_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_scale() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionDecimal.scale) + return _internal_mutable_scale(); +} +inline void DerivationExpression_ExpressionDecimal::set_allocated_scale(::io::substrait::DerivationExpression* scale) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete scale_; + } + if (scale) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(scale); + if (message_arena != submessage_arena) { + scale = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, scale, submessage_arena); + } + + } else { + + } + scale_ = scale; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.scale) +} + +// .io.substrait.DerivationExpression precision = 2; +inline bool DerivationExpression_ExpressionDecimal::_internal_has_precision() const { + return this != internal_default_instance() && precision_ != nullptr; +} +inline bool DerivationExpression_ExpressionDecimal::has_precision() const { + return _internal_has_precision(); +} +inline void DerivationExpression_ExpressionDecimal::clear_precision() { + if (GetArena() == nullptr && precision_ != nullptr) { + delete precision_; + } + precision_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_precision() const { + const ::io::substrait::DerivationExpression* p = precision_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::precision() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionDecimal.precision) + return _internal_precision(); +} +inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_precision( + ::io::substrait::DerivationExpression* precision) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_); + } + precision_ = precision; + if (precision) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.precision) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_precision() { + + ::io::substrait::DerivationExpression* temp = precision_; + precision_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_precision() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionDecimal.precision) + + ::io::substrait::DerivationExpression* temp = precision_; + precision_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_precision() { + + if (precision_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + precision_ = p; + } + return precision_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_precision() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionDecimal.precision) + return _internal_mutable_precision(); +} +inline void DerivationExpression_ExpressionDecimal::set_allocated_precision(::io::substrait::DerivationExpression* precision) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete precision_; + } + if (precision) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(precision); + if (message_arena != submessage_arena) { + precision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, precision, submessage_arena); + } + + } else { + + } + precision_ = precision; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.precision) +} + +// .io.substrait.Type.Variation variation = 3; +inline bool DerivationExpression_ExpressionDecimal::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool DerivationExpression_ExpressionDecimal::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionDecimal::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionDecimal::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionDecimal.variation) + return _internal_variation(); +} +inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.variation) +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionDecimal::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionDecimal::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionDecimal.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionDecimal::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionDecimal::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionDecimal.variation) + return _internal_mutable_variation(); +} +inline void DerivationExpression_ExpressionDecimal::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.variation) +} + +// .io.substrait.Type.Nullability nullability = 4; +inline void DerivationExpression_ExpressionDecimal::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionDecimal.nullability) + return _internal_nullability(); +} +inline void DerivationExpression_ExpressionDecimal::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void DerivationExpression_ExpressionDecimal::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionDecimal.nullability) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_ExpressionStruct + +// repeated .io.substrait.DerivationExpression types = 1; +inline int DerivationExpression_ExpressionStruct::_internal_types_size() const { + return types_.size(); +} +inline int DerivationExpression_ExpressionStruct::types_size() const { + return _internal_types_size(); +} +inline void DerivationExpression_ExpressionStruct::clear_types() { + types_.Clear(); +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::mutable_types(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionStruct.types) + return types_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression >* +DerivationExpression_ExpressionStruct::mutable_types() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.DerivationExpression.ExpressionStruct.types) + return &types_; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::_internal_types(int index) const { + return types_.Get(index); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::types(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionStruct.types) + return _internal_types(index); +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::_internal_add_types() { + return types_.Add(); +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::add_types() { + // @@protoc_insertion_point(field_add:io.substrait.DerivationExpression.ExpressionStruct.types) + return _internal_add_types(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression >& +DerivationExpression_ExpressionStruct::types() const { + // @@protoc_insertion_point(field_list:io.substrait.DerivationExpression.ExpressionStruct.types) + return types_; +} + +// .io.substrait.Type.Variation variation = 2; +inline bool DerivationExpression_ExpressionStruct::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool DerivationExpression_ExpressionStruct::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionStruct::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionStruct::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionStruct.variation) + return _internal_variation(); +} +inline void DerivationExpression_ExpressionStruct::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionStruct.variation) +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionStruct::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionStruct::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionStruct.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionStruct::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionStruct::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionStruct.variation) + return _internal_mutable_variation(); +} +inline void DerivationExpression_ExpressionStruct::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionStruct.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void DerivationExpression_ExpressionStruct::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionStruct::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionStruct::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionStruct.nullability) + return _internal_nullability(); +} +inline void DerivationExpression_ExpressionStruct::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void DerivationExpression_ExpressionStruct::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionStruct.nullability) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_ExpressionNamedStruct + +// repeated string names = 1; +inline int DerivationExpression_ExpressionNamedStruct::_internal_names_size() const { + return names_.size(); +} +inline int DerivationExpression_ExpressionNamedStruct::names_size() const { + return _internal_names_size(); +} +inline void DerivationExpression_ExpressionNamedStruct::clear_names() { + names_.Clear(); +} +inline std::string* DerivationExpression_ExpressionNamedStruct::add_names() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + return _internal_add_names(); +} +inline const std::string& DerivationExpression_ExpressionNamedStruct::_internal_names(int index) const { + return names_.Get(index); +} +inline const std::string& DerivationExpression_ExpressionNamedStruct::names(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + return _internal_names(index); +} +inline std::string* DerivationExpression_ExpressionNamedStruct::mutable_names(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + return names_.Mutable(index); +} +inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + names_.Mutable(index)->assign(value); +} +inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + names_.Mutable(index)->assign(std::move(value)); +} +inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.DerivationExpression.ExpressionNamedStruct.names) +} +inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value, size_t size) { + names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.DerivationExpression.ExpressionNamedStruct.names) +} +inline std::string* DerivationExpression_ExpressionNamedStruct::_internal_add_names() { + return names_.Add(); +} +inline void DerivationExpression_ExpressionNamedStruct::add_names(const std::string& value) { + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.DerivationExpression.ExpressionNamedStruct.names) +} +inline void DerivationExpression_ExpressionNamedStruct::add_names(std::string&& value) { + names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.DerivationExpression.ExpressionNamedStruct.names) +} +inline void DerivationExpression_ExpressionNamedStruct::add_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.DerivationExpression.ExpressionNamedStruct.names) +} +inline void DerivationExpression_ExpressionNamedStruct::add_names(const char* value, size_t size) { + names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.DerivationExpression.ExpressionNamedStruct.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +DerivationExpression_ExpressionNamedStruct::names() const { + // @@protoc_insertion_point(field_list:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +DerivationExpression_ExpressionNamedStruct::mutable_names() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + return &names_; +} + +// .io.substrait.DerivationExpression.ExpressionStruct struct = 2; +inline bool DerivationExpression_ExpressionNamedStruct::_internal_has_struct_() const { + return this != internal_default_instance() && struct__ != nullptr; +} +inline bool DerivationExpression_ExpressionNamedStruct::has_struct_() const { + return _internal_has_struct_(); +} +inline void DerivationExpression_ExpressionNamedStruct::clear_struct_() { + if (GetArena() == nullptr && struct__ != nullptr) { + delete struct__; + } + struct__ = nullptr; +} +inline const ::io::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::_internal_struct_() const { + const ::io::substrait::DerivationExpression_ExpressionStruct* p = struct__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_ExpressionStruct_default_instance_); +} +inline const ::io::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionNamedStruct.struct) + return _internal_struct_(); +} +inline void DerivationExpression_ExpressionNamedStruct::unsafe_arena_set_allocated_struct_( + ::io::substrait::DerivationExpression_ExpressionStruct* struct_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); + } + struct__ = struct_; + if (struct_) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionNamedStruct.struct) +} +inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::release_struct_() { + + ::io::substrait::DerivationExpression_ExpressionStruct* temp = struct__; + struct__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionNamedStruct.struct) + + ::io::substrait::DerivationExpression_ExpressionStruct* temp = struct__; + struct__ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::_internal_mutable_struct_() { + + if (struct__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionStruct>(GetArena()); + struct__ = p; + } + return struct__; +} +inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionNamedStruct.struct) + return _internal_mutable_struct_(); +} +inline void DerivationExpression_ExpressionNamedStruct::set_allocated_struct_(::io::substrait::DerivationExpression_ExpressionStruct* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete struct__; + } + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + + } else { + + } + struct__ = struct_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionNamedStruct.struct) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_ExpressionList + +// .io.substrait.DerivationExpression type = 1; +inline bool DerivationExpression_ExpressionList::_internal_has_type() const { + return this != internal_default_instance() && type_ != nullptr; +} +inline bool DerivationExpression_ExpressionList::has_type() const { + return _internal_has_type(); +} +inline void DerivationExpression_ExpressionList::clear_type() { + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionList::_internal_type() const { + const ::io::substrait::DerivationExpression* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionList::type() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionList.type) + return _internal_type(); +} +inline void DerivationExpression_ExpressionList::unsafe_arena_set_allocated_type( + ::io::substrait::DerivationExpression* type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); + } + type_ = type; + if (type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionList.type) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionList::release_type() { + + ::io::substrait::DerivationExpression* temp = type_; + type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionList::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionList.type) + + ::io::substrait::DerivationExpression* temp = type_; + type_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionList::_internal_mutable_type() { + + if (type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + type_ = p; + } + return type_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionList::mutable_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionList.type) + return _internal_mutable_type(); +} +inline void DerivationExpression_ExpressionList::set_allocated_type(::io::substrait::DerivationExpression* type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete type_; + } + if (type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type); + if (message_arena != submessage_arena) { + type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type, submessage_arena); + } + + } else { + + } + type_ = type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionList.type) +} + +// .io.substrait.Type.Variation variation = 2; +inline bool DerivationExpression_ExpressionList::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool DerivationExpression_ExpressionList::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionList::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionList::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionList.variation) + return _internal_variation(); +} +inline void DerivationExpression_ExpressionList::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionList.variation) +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionList::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionList::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionList.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionList::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionList::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionList.variation) + return _internal_mutable_variation(); +} +inline void DerivationExpression_ExpressionList::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionList.variation) +} + +// .io.substrait.Type.Nullability nullability = 3; +inline void DerivationExpression_ExpressionList::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionList::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionList::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionList.nullability) + return _internal_nullability(); +} +inline void DerivationExpression_ExpressionList::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void DerivationExpression_ExpressionList::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionList.nullability) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_ExpressionMap + +// .io.substrait.DerivationExpression key = 1; +inline bool DerivationExpression_ExpressionMap::_internal_has_key() const { + return this != internal_default_instance() && key_ != nullptr; +} +inline bool DerivationExpression_ExpressionMap::has_key() const { + return _internal_has_key(); +} +inline void DerivationExpression_ExpressionMap::clear_key() { + if (GetArena() == nullptr && key_ != nullptr) { + delete key_; + } + key_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_key() const { + const ::io::substrait::DerivationExpression* p = key_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionMap::key() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionMap.key) + return _internal_key(); +} +inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_key( + ::io::substrait::DerivationExpression* key) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); + } + key_ = key; + if (key) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionMap.key) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_key() { + + ::io::substrait::DerivationExpression* temp = key_; + key_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionMap.key) + + ::io::substrait::DerivationExpression* temp = key_; + key_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_key() { + + if (key_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + key_ = p; + } + return key_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionMap.key) + return _internal_mutable_key(); +} +inline void DerivationExpression_ExpressionMap::set_allocated_key(::io::substrait::DerivationExpression* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + + } else { + + } + key_ = key; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionMap.key) +} + +// .io.substrait.DerivationExpression value = 2; +inline bool DerivationExpression_ExpressionMap::_internal_has_value() const { + return this != internal_default_instance() && value_ != nullptr; +} +inline bool DerivationExpression_ExpressionMap::has_value() const { + return _internal_has_value(); +} +inline void DerivationExpression_ExpressionMap::clear_value() { + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_value() const { + const ::io::substrait::DerivationExpression* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionMap::value() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionMap.value) + return _internal_value(); +} +inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_value( + ::io::substrait::DerivationExpression* value) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); + } + value_ = value; + if (value) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionMap.value) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_value() { + + ::io::substrait::DerivationExpression* temp = value_; + value_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionMap.value) + + ::io::substrait::DerivationExpression* temp = value_; + value_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_value() { + + if (value_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + value_ = p; + } + return value_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionMap.value) + return _internal_mutable_value(); +} +inline void DerivationExpression_ExpressionMap::set_allocated_value(::io::substrait::DerivationExpression* value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete value_; + } + if (value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + if (message_arena != submessage_arena) { + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); + } + + } else { + + } + value_ = value; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionMap.value) +} + +// .io.substrait.Type.Variation variation = 3; +inline bool DerivationExpression_ExpressionMap::_internal_has_variation() const { + return this != internal_default_instance() && variation_ != nullptr; +} +inline bool DerivationExpression_ExpressionMap::has_variation() const { + return _internal_has_variation(); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionMap::_internal_variation() const { + const ::io::substrait::Type_Variation* p = variation_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Variation_default_instance_); +} +inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionMap::variation() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionMap.variation) + return _internal_variation(); +} +inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_variation( + ::io::substrait::Type_Variation* variation) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + variation_ = variation; + if (variation) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionMap.variation) +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionMap::release_variation() { + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionMap::unsafe_arena_release_variation() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionMap.variation) + + ::io::substrait::Type_Variation* temp = variation_; + variation_ = nullptr; + return temp; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionMap::_internal_mutable_variation() { + + if (variation_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); + variation_ = p; + } + return variation_; +} +inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionMap::mutable_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionMap.variation) + return _internal_mutable_variation(); +} +inline void DerivationExpression_ExpressionMap::set_allocated_variation(::io::substrait::Type_Variation* variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + } + if (variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); + if (message_arena != submessage_arena) { + variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, variation, submessage_arena); + } + + } else { + + } + variation_ = variation; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionMap.variation) +} + +// .io.substrait.Type.Nullability nullability = 4; +inline void DerivationExpression_ExpressionMap::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionMap::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); +} +inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionMap::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionMap.nullability) + return _internal_nullability(); +} +inline void DerivationExpression_ExpressionMap::_internal_set_nullability(::io::substrait::Type_Nullability value) { + + nullability_ = value; +} +inline void DerivationExpression_ExpressionMap::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionMap.nullability) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_IfElse + +// .io.substrait.DerivationExpression if_condition = 1; +inline bool DerivationExpression_IfElse::_internal_has_if_condition() const { + return this != internal_default_instance() && if_condition_ != nullptr; +} +inline bool DerivationExpression_IfElse::has_if_condition() const { + return _internal_has_if_condition(); +} +inline void DerivationExpression_IfElse::clear_if_condition() { + if (GetArena() == nullptr && if_condition_ != nullptr) { + delete if_condition_; + } + if_condition_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_condition() const { + const ::io::substrait::DerivationExpression* p = if_condition_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::if_condition() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.IfElse.if_condition) + return _internal_if_condition(); +} +inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_condition( + ::io::substrait::DerivationExpression* if_condition) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_condition_); + } + if_condition_ = if_condition; + if (if_condition) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.IfElse.if_condition) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_condition() { + + ::io::substrait::DerivationExpression* temp = if_condition_; + if_condition_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_condition() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.IfElse.if_condition) + + ::io::substrait::DerivationExpression* temp = if_condition_; + if_condition_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_condition() { + + if (if_condition_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + if_condition_ = p; + } + return if_condition_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_condition() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.IfElse.if_condition) + return _internal_mutable_if_condition(); +} +inline void DerivationExpression_IfElse::set_allocated_if_condition(::io::substrait::DerivationExpression* if_condition) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete if_condition_; + } + if (if_condition) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_condition); + if (message_arena != submessage_arena) { + if_condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, if_condition, submessage_arena); + } + + } else { + + } + if_condition_ = if_condition; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.IfElse.if_condition) +} + +// .io.substrait.DerivationExpression if_return = 2; +inline bool DerivationExpression_IfElse::_internal_has_if_return() const { + return this != internal_default_instance() && if_return_ != nullptr; +} +inline bool DerivationExpression_IfElse::has_if_return() const { + return _internal_has_if_return(); +} +inline void DerivationExpression_IfElse::clear_if_return() { + if (GetArena() == nullptr && if_return_ != nullptr) { + delete if_return_; + } + if_return_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_return() const { + const ::io::substrait::DerivationExpression* p = if_return_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::if_return() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.IfElse.if_return) + return _internal_if_return(); +} +inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_return( + ::io::substrait::DerivationExpression* if_return) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_return_); + } + if_return_ = if_return; + if (if_return) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.IfElse.if_return) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_return() { + + ::io::substrait::DerivationExpression* temp = if_return_; + if_return_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_return() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.IfElse.if_return) + + ::io::substrait::DerivationExpression* temp = if_return_; + if_return_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_return() { + + if (if_return_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + if_return_ = p; + } + return if_return_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_return() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.IfElse.if_return) + return _internal_mutable_if_return(); +} +inline void DerivationExpression_IfElse::set_allocated_if_return(::io::substrait::DerivationExpression* if_return) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete if_return_; + } + if (if_return) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_return); + if (message_arena != submessage_arena) { + if_return = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, if_return, submessage_arena); + } + + } else { + + } + if_return_ = if_return; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.IfElse.if_return) +} + +// .io.substrait.DerivationExpression else_return = 3; +inline bool DerivationExpression_IfElse::_internal_has_else_return() const { + return this != internal_default_instance() && else_return_ != nullptr; +} +inline bool DerivationExpression_IfElse::has_else_return() const { + return _internal_has_else_return(); +} +inline void DerivationExpression_IfElse::clear_else_return() { + if (GetArena() == nullptr && else_return_ != nullptr) { + delete else_return_; + } + else_return_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_else_return() const { + const ::io::substrait::DerivationExpression* p = else_return_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::else_return() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.IfElse.else_return) + return _internal_else_return(); +} +inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_else_return( + ::io::substrait::DerivationExpression* else_return) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else_return_); + } + else_return_ = else_return; + if (else_return) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.IfElse.else_return) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::release_else_return() { + + ::io::substrait::DerivationExpression* temp = else_return_; + else_return_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_else_return() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.IfElse.else_return) + + ::io::substrait::DerivationExpression* temp = else_return_; + else_return_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_else_return() { + + if (else_return_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + else_return_ = p; + } + return else_return_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_else_return() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.IfElse.else_return) + return _internal_mutable_else_return(); +} +inline void DerivationExpression_IfElse::set_allocated_else_return(::io::substrait::DerivationExpression* else_return) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete else_return_; + } + if (else_return) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(else_return); + if (message_arena != submessage_arena) { + else_return = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, else_return, submessage_arena); + } + + } else { + + } + else_return_ = else_return; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.IfElse.else_return) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_UnaryOp + +// .io.substrait.DerivationExpression.UnaryOp.OpType op_type = 1; +inline void DerivationExpression_UnaryOp::clear_op_type() { + op_type_ = 0; +} +inline ::io::substrait::DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::_internal_op_type() const { + return static_cast< ::io::substrait::DerivationExpression_UnaryOp_OpType >(op_type_); +} +inline ::io::substrait::DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::op_type() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.UnaryOp.op_type) + return _internal_op_type(); +} +inline void DerivationExpression_UnaryOp::_internal_set_op_type(::io::substrait::DerivationExpression_UnaryOp_OpType value) { + + op_type_ = value; +} +inline void DerivationExpression_UnaryOp::set_op_type(::io::substrait::DerivationExpression_UnaryOp_OpType value) { + _internal_set_op_type(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.UnaryOp.op_type) +} + +// .io.substrait.DerivationExpression arg = 2; +inline bool DerivationExpression_UnaryOp::_internal_has_arg() const { + return this != internal_default_instance() && arg_ != nullptr; +} +inline bool DerivationExpression_UnaryOp::has_arg() const { + return _internal_has_arg(); +} +inline void DerivationExpression_UnaryOp::clear_arg() { + if (GetArena() == nullptr && arg_ != nullptr) { + delete arg_; + } + arg_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_UnaryOp::_internal_arg() const { + const ::io::substrait::DerivationExpression* p = arg_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_UnaryOp::arg() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.UnaryOp.arg) + return _internal_arg(); +} +inline void DerivationExpression_UnaryOp::unsafe_arena_set_allocated_arg( + ::io::substrait::DerivationExpression* arg) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_); + } + arg_ = arg; + if (arg) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.UnaryOp.arg) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_UnaryOp::release_arg() { + + ::io::substrait::DerivationExpression* temp = arg_; + arg_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_UnaryOp::unsafe_arena_release_arg() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.UnaryOp.arg) + + ::io::substrait::DerivationExpression* temp = arg_; + arg_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_UnaryOp::_internal_mutable_arg() { + + if (arg_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + arg_ = p; + } + return arg_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_UnaryOp::mutable_arg() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.UnaryOp.arg) + return _internal_mutable_arg(); +} +inline void DerivationExpression_UnaryOp::set_allocated_arg(::io::substrait::DerivationExpression* arg) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete arg_; + } + if (arg) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg); + if (message_arena != submessage_arena) { + arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, arg, submessage_arena); + } + + } else { + + } + arg_ = arg; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.UnaryOp.arg) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_BinaryOp + +// .io.substrait.DerivationExpression.BinaryOp.OpType op_type = 1; +inline void DerivationExpression_BinaryOp::clear_op_type() { + op_type_ = 0; +} +inline ::io::substrait::DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::_internal_op_type() const { + return static_cast< ::io::substrait::DerivationExpression_BinaryOp_OpType >(op_type_); +} +inline ::io::substrait::DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::op_type() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.BinaryOp.op_type) + return _internal_op_type(); +} +inline void DerivationExpression_BinaryOp::_internal_set_op_type(::io::substrait::DerivationExpression_BinaryOp_OpType value) { + + op_type_ = value; +} +inline void DerivationExpression_BinaryOp::set_op_type(::io::substrait::DerivationExpression_BinaryOp_OpType value) { + _internal_set_op_type(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.BinaryOp.op_type) +} + +// .io.substrait.DerivationExpression arg1 = 2; +inline bool DerivationExpression_BinaryOp::_internal_has_arg1() const { + return this != internal_default_instance() && arg1_ != nullptr; +} +inline bool DerivationExpression_BinaryOp::has_arg1() const { + return _internal_has_arg1(); +} +inline void DerivationExpression_BinaryOp::clear_arg1() { + if (GetArena() == nullptr && arg1_ != nullptr) { + delete arg1_; + } + arg1_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg1() const { + const ::io::substrait::DerivationExpression* p = arg1_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg1() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.BinaryOp.arg1) + return _internal_arg1(); +} +inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg1( + ::io::substrait::DerivationExpression* arg1) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg1_); + } + arg1_ = arg1; + if (arg1) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.BinaryOp.arg1) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg1() { + + ::io::substrait::DerivationExpression* temp = arg1_; + arg1_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg1() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.BinaryOp.arg1) + + ::io::substrait::DerivationExpression* temp = arg1_; + arg1_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg1() { + + if (arg1_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + arg1_ = p; + } + return arg1_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg1() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.BinaryOp.arg1) + return _internal_mutable_arg1(); +} +inline void DerivationExpression_BinaryOp::set_allocated_arg1(::io::substrait::DerivationExpression* arg1) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete arg1_; + } + if (arg1) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg1); + if (message_arena != submessage_arena) { + arg1 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, arg1, submessage_arena); + } + + } else { + + } + arg1_ = arg1; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.BinaryOp.arg1) +} + +// .io.substrait.DerivationExpression arg2 = 3; +inline bool DerivationExpression_BinaryOp::_internal_has_arg2() const { + return this != internal_default_instance() && arg2_ != nullptr; +} +inline bool DerivationExpression_BinaryOp::has_arg2() const { + return _internal_has_arg2(); +} +inline void DerivationExpression_BinaryOp::clear_arg2() { + if (GetArena() == nullptr && arg2_ != nullptr) { + delete arg2_; + } + arg2_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg2() const { + const ::io::substrait::DerivationExpression* p = arg2_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg2() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.BinaryOp.arg2) + return _internal_arg2(); +} +inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg2( + ::io::substrait::DerivationExpression* arg2) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg2_); + } + arg2_ = arg2; + if (arg2) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.BinaryOp.arg2) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg2() { + + ::io::substrait::DerivationExpression* temp = arg2_; + arg2_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg2() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.BinaryOp.arg2) + + ::io::substrait::DerivationExpression* temp = arg2_; + arg2_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg2() { + + if (arg2_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + arg2_ = p; + } + return arg2_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg2() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.BinaryOp.arg2) + return _internal_mutable_arg2(); +} +inline void DerivationExpression_BinaryOp::set_allocated_arg2(::io::substrait::DerivationExpression* arg2) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete arg2_; + } + if (arg2) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg2); + if (message_arena != submessage_arena) { + arg2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, arg2, submessage_arena); + } + + } else { + + } + arg2_ = arg2; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.BinaryOp.arg2) +} + +// ------------------------------------------------------------------- + +// DerivationExpression + +// .io.substrait.Type.Boolean bool = 1; +inline bool DerivationExpression::_internal_has_bool_() const { + return kind_case() == kBool; +} +inline bool DerivationExpression::has_bool_() const { + return _internal_has_bool_(); +} +inline void DerivationExpression::set_has_bool_() { + _oneof_case_[0] = kBool; +} +inline ::io::substrait::Type_Boolean* DerivationExpression::release_bool_() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.bool) + if (_internal_has_bool_()) { + clear_has_kind(); + ::io::substrait::Type_Boolean* temp = kind_.bool__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.bool__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Boolean& DerivationExpression::_internal_bool_() const { + return _internal_has_bool_() + ? *kind_.bool__ + : reinterpret_cast< ::io::substrait::Type_Boolean&>(::io::substrait::_Type_Boolean_default_instance_); +} +inline const ::io::substrait::Type_Boolean& DerivationExpression::bool_() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.bool) + return _internal_bool_(); +} +inline ::io::substrait::Type_Boolean* DerivationExpression::unsafe_arena_release_bool_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.bool) + if (_internal_has_bool_()) { + clear_has_kind(); + ::io::substrait::Type_Boolean* temp = kind_.bool__; + kind_.bool__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { + clear_kind(); + if (bool_) { + set_has_bool_(); + kind_.bool__ = bool_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.bool) +} +inline ::io::substrait::Type_Boolean* DerivationExpression::_internal_mutable_bool_() { + if (!_internal_has_bool_()) { + clear_kind(); + set_has_bool_(); + kind_.bool__ = CreateMaybeMessage< ::io::substrait::Type_Boolean >(GetArena()); + } + return kind_.bool__; +} +inline ::io::substrait::Type_Boolean* DerivationExpression::mutable_bool_() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.bool) + return _internal_mutable_bool_(); +} + +// .io.substrait.Type.I8 i8 = 2; +inline bool DerivationExpression::_internal_has_i8() const { + return kind_case() == kI8; +} +inline bool DerivationExpression::has_i8() const { + return _internal_has_i8(); +} +inline void DerivationExpression::set_has_i8() { + _oneof_case_[0] = kI8; +} +inline ::io::substrait::Type_I8* DerivationExpression::release_i8() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.i8) + if (_internal_has_i8()) { + clear_has_kind(); + ::io::substrait::Type_I8* temp = kind_.i8_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i8_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I8& DerivationExpression::_internal_i8() const { + return _internal_has_i8() + ? *kind_.i8_ + : reinterpret_cast< ::io::substrait::Type_I8&>(::io::substrait::_Type_I8_default_instance_); +} +inline const ::io::substrait::Type_I8& DerivationExpression::i8() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.i8) + return _internal_i8(); +} +inline ::io::substrait::Type_I8* DerivationExpression::unsafe_arena_release_i8() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.i8) + if (_internal_has_i8()) { + clear_has_kind(); + ::io::substrait::Type_I8* temp = kind_.i8_; + kind_.i8_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_i8(::io::substrait::Type_I8* i8) { + clear_kind(); + if (i8) { + set_has_i8(); + kind_.i8_ = i8; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.i8) +} +inline ::io::substrait::Type_I8* DerivationExpression::_internal_mutable_i8() { + if (!_internal_has_i8()) { + clear_kind(); + set_has_i8(); + kind_.i8_ = CreateMaybeMessage< ::io::substrait::Type_I8 >(GetArena()); + } + return kind_.i8_; +} +inline ::io::substrait::Type_I8* DerivationExpression::mutable_i8() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.i8) + return _internal_mutable_i8(); +} + +// .io.substrait.Type.I16 i16 = 3; +inline bool DerivationExpression::_internal_has_i16() const { + return kind_case() == kI16; +} +inline bool DerivationExpression::has_i16() const { + return _internal_has_i16(); +} +inline void DerivationExpression::set_has_i16() { + _oneof_case_[0] = kI16; +} +inline ::io::substrait::Type_I16* DerivationExpression::release_i16() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.i16) + if (_internal_has_i16()) { + clear_has_kind(); + ::io::substrait::Type_I16* temp = kind_.i16_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i16_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I16& DerivationExpression::_internal_i16() const { + return _internal_has_i16() + ? *kind_.i16_ + : reinterpret_cast< ::io::substrait::Type_I16&>(::io::substrait::_Type_I16_default_instance_); +} +inline const ::io::substrait::Type_I16& DerivationExpression::i16() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.i16) + return _internal_i16(); +} +inline ::io::substrait::Type_I16* DerivationExpression::unsafe_arena_release_i16() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.i16) + if (_internal_has_i16()) { + clear_has_kind(); + ::io::substrait::Type_I16* temp = kind_.i16_; + kind_.i16_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_i16(::io::substrait::Type_I16* i16) { + clear_kind(); + if (i16) { + set_has_i16(); + kind_.i16_ = i16; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.i16) +} +inline ::io::substrait::Type_I16* DerivationExpression::_internal_mutable_i16() { + if (!_internal_has_i16()) { + clear_kind(); + set_has_i16(); + kind_.i16_ = CreateMaybeMessage< ::io::substrait::Type_I16 >(GetArena()); + } + return kind_.i16_; +} +inline ::io::substrait::Type_I16* DerivationExpression::mutable_i16() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.i16) + return _internal_mutable_i16(); +} + +// .io.substrait.Type.I32 i32 = 5; +inline bool DerivationExpression::_internal_has_i32() const { + return kind_case() == kI32; +} +inline bool DerivationExpression::has_i32() const { + return _internal_has_i32(); +} +inline void DerivationExpression::set_has_i32() { + _oneof_case_[0] = kI32; +} +inline ::io::substrait::Type_I32* DerivationExpression::release_i32() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.i32) + if (_internal_has_i32()) { + clear_has_kind(); + ::io::substrait::Type_I32* temp = kind_.i32_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I32& DerivationExpression::_internal_i32() const { + return _internal_has_i32() + ? *kind_.i32_ + : reinterpret_cast< ::io::substrait::Type_I32&>(::io::substrait::_Type_I32_default_instance_); +} +inline const ::io::substrait::Type_I32& DerivationExpression::i32() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.i32) + return _internal_i32(); +} +inline ::io::substrait::Type_I32* DerivationExpression::unsafe_arena_release_i32() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.i32) + if (_internal_has_i32()) { + clear_has_kind(); + ::io::substrait::Type_I32* temp = kind_.i32_; + kind_.i32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_i32(::io::substrait::Type_I32* i32) { + clear_kind(); + if (i32) { + set_has_i32(); + kind_.i32_ = i32; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.i32) +} +inline ::io::substrait::Type_I32* DerivationExpression::_internal_mutable_i32() { + if (!_internal_has_i32()) { + clear_kind(); + set_has_i32(); + kind_.i32_ = CreateMaybeMessage< ::io::substrait::Type_I32 >(GetArena()); + } + return kind_.i32_; +} +inline ::io::substrait::Type_I32* DerivationExpression::mutable_i32() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.i32) + return _internal_mutable_i32(); +} + +// .io.substrait.Type.I64 i64 = 7; +inline bool DerivationExpression::_internal_has_i64() const { + return kind_case() == kI64; +} +inline bool DerivationExpression::has_i64() const { + return _internal_has_i64(); +} +inline void DerivationExpression::set_has_i64() { + _oneof_case_[0] = kI64; +} +inline ::io::substrait::Type_I64* DerivationExpression::release_i64() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.i64) + if (_internal_has_i64()) { + clear_has_kind(); + ::io::substrait::Type_I64* temp = kind_.i64_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.i64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_I64& DerivationExpression::_internal_i64() const { + return _internal_has_i64() + ? *kind_.i64_ + : reinterpret_cast< ::io::substrait::Type_I64&>(::io::substrait::_Type_I64_default_instance_); +} +inline const ::io::substrait::Type_I64& DerivationExpression::i64() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.i64) + return _internal_i64(); +} +inline ::io::substrait::Type_I64* DerivationExpression::unsafe_arena_release_i64() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.i64) + if (_internal_has_i64()) { + clear_has_kind(); + ::io::substrait::Type_I64* temp = kind_.i64_; + kind_.i64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_i64(::io::substrait::Type_I64* i64) { + clear_kind(); + if (i64) { + set_has_i64(); + kind_.i64_ = i64; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.i64) +} +inline ::io::substrait::Type_I64* DerivationExpression::_internal_mutable_i64() { + if (!_internal_has_i64()) { + clear_kind(); + set_has_i64(); + kind_.i64_ = CreateMaybeMessage< ::io::substrait::Type_I64 >(GetArena()); + } + return kind_.i64_; +} +inline ::io::substrait::Type_I64* DerivationExpression::mutable_i64() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.i64) + return _internal_mutable_i64(); +} + +// .io.substrait.Type.FP32 fp32 = 10; +inline bool DerivationExpression::_internal_has_fp32() const { + return kind_case() == kFp32; +} +inline bool DerivationExpression::has_fp32() const { + return _internal_has_fp32(); +} +inline void DerivationExpression::set_has_fp32() { + _oneof_case_[0] = kFp32; +} +inline ::io::substrait::Type_FP32* DerivationExpression::release_fp32() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.fp32) + if (_internal_has_fp32()) { + clear_has_kind(); + ::io::substrait::Type_FP32* temp = kind_.fp32_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fp32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_FP32& DerivationExpression::_internal_fp32() const { + return _internal_has_fp32() + ? *kind_.fp32_ + : reinterpret_cast< ::io::substrait::Type_FP32&>(::io::substrait::_Type_FP32_default_instance_); +} +inline const ::io::substrait::Type_FP32& DerivationExpression::fp32() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.fp32) + return _internal_fp32(); +} +inline ::io::substrait::Type_FP32* DerivationExpression::unsafe_arena_release_fp32() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.fp32) + if (_internal_has_fp32()) { + clear_has_kind(); + ::io::substrait::Type_FP32* temp = kind_.fp32_; + kind_.fp32_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_fp32(::io::substrait::Type_FP32* fp32) { + clear_kind(); + if (fp32) { + set_has_fp32(); + kind_.fp32_ = fp32; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.fp32) +} +inline ::io::substrait::Type_FP32* DerivationExpression::_internal_mutable_fp32() { + if (!_internal_has_fp32()) { + clear_kind(); + set_has_fp32(); + kind_.fp32_ = CreateMaybeMessage< ::io::substrait::Type_FP32 >(GetArena()); + } + return kind_.fp32_; +} +inline ::io::substrait::Type_FP32* DerivationExpression::mutable_fp32() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.fp32) + return _internal_mutable_fp32(); +} + +// .io.substrait.Type.FP64 fp64 = 11; +inline bool DerivationExpression::_internal_has_fp64() const { + return kind_case() == kFp64; +} +inline bool DerivationExpression::has_fp64() const { + return _internal_has_fp64(); +} +inline void DerivationExpression::set_has_fp64() { + _oneof_case_[0] = kFp64; +} +inline ::io::substrait::Type_FP64* DerivationExpression::release_fp64() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.fp64) + if (_internal_has_fp64()) { + clear_has_kind(); + ::io::substrait::Type_FP64* temp = kind_.fp64_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fp64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_FP64& DerivationExpression::_internal_fp64() const { + return _internal_has_fp64() + ? *kind_.fp64_ + : reinterpret_cast< ::io::substrait::Type_FP64&>(::io::substrait::_Type_FP64_default_instance_); +} +inline const ::io::substrait::Type_FP64& DerivationExpression::fp64() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.fp64) + return _internal_fp64(); +} +inline ::io::substrait::Type_FP64* DerivationExpression::unsafe_arena_release_fp64() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.fp64) + if (_internal_has_fp64()) { + clear_has_kind(); + ::io::substrait::Type_FP64* temp = kind_.fp64_; + kind_.fp64_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_fp64(::io::substrait::Type_FP64* fp64) { + clear_kind(); + if (fp64) { + set_has_fp64(); + kind_.fp64_ = fp64; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.fp64) +} +inline ::io::substrait::Type_FP64* DerivationExpression::_internal_mutable_fp64() { + if (!_internal_has_fp64()) { + clear_kind(); + set_has_fp64(); + kind_.fp64_ = CreateMaybeMessage< ::io::substrait::Type_FP64 >(GetArena()); + } + return kind_.fp64_; +} +inline ::io::substrait::Type_FP64* DerivationExpression::mutable_fp64() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.fp64) + return _internal_mutable_fp64(); +} + +// .io.substrait.Type.String string = 12; +inline bool DerivationExpression::_internal_has_string() const { + return kind_case() == kString; +} +inline bool DerivationExpression::has_string() const { + return _internal_has_string(); +} +inline void DerivationExpression::set_has_string() { + _oneof_case_[0] = kString; +} +inline ::io::substrait::Type_String* DerivationExpression::release_string() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.string) + if (_internal_has_string()) { + clear_has_kind(); + ::io::substrait::Type_String* temp = kind_.string_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.string_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_String& DerivationExpression::_internal_string() const { + return _internal_has_string() + ? *kind_.string_ + : reinterpret_cast< ::io::substrait::Type_String&>(::io::substrait::_Type_String_default_instance_); +} +inline const ::io::substrait::Type_String& DerivationExpression::string() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.string) + return _internal_string(); +} +inline ::io::substrait::Type_String* DerivationExpression::unsafe_arena_release_string() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.string) + if (_internal_has_string()) { + clear_has_kind(); + ::io::substrait::Type_String* temp = kind_.string_; + kind_.string_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_string(::io::substrait::Type_String* string) { + clear_kind(); + if (string) { + set_has_string(); + kind_.string_ = string; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.string) +} +inline ::io::substrait::Type_String* DerivationExpression::_internal_mutable_string() { + if (!_internal_has_string()) { + clear_kind(); + set_has_string(); + kind_.string_ = CreateMaybeMessage< ::io::substrait::Type_String >(GetArena()); + } + return kind_.string_; +} +inline ::io::substrait::Type_String* DerivationExpression::mutable_string() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.string) + return _internal_mutable_string(); +} + +// .io.substrait.Type.Binary binary = 13; +inline bool DerivationExpression::_internal_has_binary() const { + return kind_case() == kBinary; +} +inline bool DerivationExpression::has_binary() const { + return _internal_has_binary(); +} +inline void DerivationExpression::set_has_binary() { + _oneof_case_[0] = kBinary; +} +inline ::io::substrait::Type_Binary* DerivationExpression::release_binary() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.binary) + if (_internal_has_binary()) { + clear_has_kind(); + ::io::substrait::Type_Binary* temp = kind_.binary_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Binary& DerivationExpression::_internal_binary() const { + return _internal_has_binary() + ? *kind_.binary_ + : reinterpret_cast< ::io::substrait::Type_Binary&>(::io::substrait::_Type_Binary_default_instance_); +} +inline const ::io::substrait::Type_Binary& DerivationExpression::binary() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.binary) + return _internal_binary(); +} +inline ::io::substrait::Type_Binary* DerivationExpression::unsafe_arena_release_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.binary) + if (_internal_has_binary()) { + clear_has_kind(); + ::io::substrait::Type_Binary* temp = kind_.binary_; + kind_.binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_binary(::io::substrait::Type_Binary* binary) { + clear_kind(); + if (binary) { + set_has_binary(); + kind_.binary_ = binary; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.binary) +} +inline ::io::substrait::Type_Binary* DerivationExpression::_internal_mutable_binary() { + if (!_internal_has_binary()) { + clear_kind(); + set_has_binary(); + kind_.binary_ = CreateMaybeMessage< ::io::substrait::Type_Binary >(GetArena()); + } + return kind_.binary_; +} +inline ::io::substrait::Type_Binary* DerivationExpression::mutable_binary() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.binary) + return _internal_mutable_binary(); +} + +// .io.substrait.Type.Timestamp timestamp = 14; +inline bool DerivationExpression::_internal_has_timestamp() const { + return kind_case() == kTimestamp; +} +inline bool DerivationExpression::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void DerivationExpression::set_has_timestamp() { + _oneof_case_[0] = kTimestamp; +} +inline ::io::substrait::Type_Timestamp* DerivationExpression::release_timestamp() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.timestamp) + if (_internal_has_timestamp()) { + clear_has_kind(); + ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.timestamp_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Timestamp& DerivationExpression::_internal_timestamp() const { + return _internal_has_timestamp() + ? *kind_.timestamp_ + : reinterpret_cast< ::io::substrait::Type_Timestamp&>(::io::substrait::_Type_Timestamp_default_instance_); +} +inline const ::io::substrait::Type_Timestamp& DerivationExpression::timestamp() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.timestamp) + return _internal_timestamp(); +} +inline ::io::substrait::Type_Timestamp* DerivationExpression::unsafe_arena_release_timestamp() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.timestamp) + if (_internal_has_timestamp()) { + clear_has_kind(); + ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + kind_.timestamp_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { + clear_kind(); + if (timestamp) { + set_has_timestamp(); + kind_.timestamp_ = timestamp; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.timestamp) +} +inline ::io::substrait::Type_Timestamp* DerivationExpression::_internal_mutable_timestamp() { + if (!_internal_has_timestamp()) { + clear_kind(); + set_has_timestamp(); + kind_.timestamp_ = CreateMaybeMessage< ::io::substrait::Type_Timestamp >(GetArena()); + } + return kind_.timestamp_; +} +inline ::io::substrait::Type_Timestamp* DerivationExpression::mutable_timestamp() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.timestamp) + return _internal_mutable_timestamp(); +} + +// .io.substrait.Type.Date date = 16; +inline bool DerivationExpression::_internal_has_date() const { + return kind_case() == kDate; +} +inline bool DerivationExpression::has_date() const { + return _internal_has_date(); +} +inline void DerivationExpression::set_has_date() { + _oneof_case_[0] = kDate; +} +inline ::io::substrait::Type_Date* DerivationExpression::release_date() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.date) + if (_internal_has_date()) { + clear_has_kind(); + ::io::substrait::Type_Date* temp = kind_.date_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.date_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Date& DerivationExpression::_internal_date() const { + return _internal_has_date() + ? *kind_.date_ + : reinterpret_cast< ::io::substrait::Type_Date&>(::io::substrait::_Type_Date_default_instance_); +} +inline const ::io::substrait::Type_Date& DerivationExpression::date() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.date) + return _internal_date(); +} +inline ::io::substrait::Type_Date* DerivationExpression::unsafe_arena_release_date() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.date) + if (_internal_has_date()) { + clear_has_kind(); + ::io::substrait::Type_Date* temp = kind_.date_; + kind_.date_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_date(::io::substrait::Type_Date* date) { + clear_kind(); + if (date) { + set_has_date(); + kind_.date_ = date; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.date) +} +inline ::io::substrait::Type_Date* DerivationExpression::_internal_mutable_date() { + if (!_internal_has_date()) { + clear_kind(); + set_has_date(); + kind_.date_ = CreateMaybeMessage< ::io::substrait::Type_Date >(GetArena()); + } + return kind_.date_; +} +inline ::io::substrait::Type_Date* DerivationExpression::mutable_date() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.date) + return _internal_mutable_date(); +} + +// .io.substrait.Type.Time time = 17; +inline bool DerivationExpression::_internal_has_time() const { + return kind_case() == kTime; +} +inline bool DerivationExpression::has_time() const { + return _internal_has_time(); +} +inline void DerivationExpression::set_has_time() { + _oneof_case_[0] = kTime; +} +inline ::io::substrait::Type_Time* DerivationExpression::release_time() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.time) + if (_internal_has_time()) { + clear_has_kind(); + ::io::substrait::Type_Time* temp = kind_.time_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.time_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_Time& DerivationExpression::_internal_time() const { + return _internal_has_time() + ? *kind_.time_ + : reinterpret_cast< ::io::substrait::Type_Time&>(::io::substrait::_Type_Time_default_instance_); +} +inline const ::io::substrait::Type_Time& DerivationExpression::time() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.time) + return _internal_time(); +} +inline ::io::substrait::Type_Time* DerivationExpression::unsafe_arena_release_time() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.time) + if (_internal_has_time()) { + clear_has_kind(); + ::io::substrait::Type_Time* temp = kind_.time_; + kind_.time_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_time(::io::substrait::Type_Time* time) { + clear_kind(); + if (time) { + set_has_time(); + kind_.time_ = time; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.time) +} +inline ::io::substrait::Type_Time* DerivationExpression::_internal_mutable_time() { + if (!_internal_has_time()) { + clear_kind(); + set_has_time(); + kind_.time_ = CreateMaybeMessage< ::io::substrait::Type_Time >(GetArena()); + } + return kind_.time_; +} +inline ::io::substrait::Type_Time* DerivationExpression::mutable_time() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.time) + return _internal_mutable_time(); +} + +// .io.substrait.Type.IntervalYear interval_year = 19; +inline bool DerivationExpression::_internal_has_interval_year() const { + return kind_case() == kIntervalYear; +} +inline bool DerivationExpression::has_interval_year() const { + return _internal_has_interval_year(); +} +inline void DerivationExpression::set_has_interval_year() { + _oneof_case_[0] = kIntervalYear; +} +inline ::io::substrait::Type_IntervalYear* DerivationExpression::release_interval_year() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.interval_year) + if (_internal_has_interval_year()) { + clear_has_kind(); + ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.interval_year_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_IntervalYear& DerivationExpression::_internal_interval_year() const { + return _internal_has_interval_year() + ? *kind_.interval_year_ + : reinterpret_cast< ::io::substrait::Type_IntervalYear&>(::io::substrait::_Type_IntervalYear_default_instance_); +} +inline const ::io::substrait::Type_IntervalYear& DerivationExpression::interval_year() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.interval_year) + return _internal_interval_year(); +} +inline ::io::substrait::Type_IntervalYear* DerivationExpression::unsafe_arena_release_interval_year() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.interval_year) + if (_internal_has_interval_year()) { + clear_has_kind(); + ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + kind_.interval_year_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { + clear_kind(); + if (interval_year) { + set_has_interval_year(); + kind_.interval_year_ = interval_year; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.interval_year) +} +inline ::io::substrait::Type_IntervalYear* DerivationExpression::_internal_mutable_interval_year() { + if (!_internal_has_interval_year()) { + clear_kind(); + set_has_interval_year(); + kind_.interval_year_ = CreateMaybeMessage< ::io::substrait::Type_IntervalYear >(GetArena()); + } + return kind_.interval_year_; +} +inline ::io::substrait::Type_IntervalYear* DerivationExpression::mutable_interval_year() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.interval_year) + return _internal_mutable_interval_year(); +} + +// .io.substrait.Type.IntervalDay interval_day = 20; +inline bool DerivationExpression::_internal_has_interval_day() const { + return kind_case() == kIntervalDay; +} +inline bool DerivationExpression::has_interval_day() const { + return _internal_has_interval_day(); +} +inline void DerivationExpression::set_has_interval_day() { + _oneof_case_[0] = kIntervalDay; +} +inline ::io::substrait::Type_IntervalDay* DerivationExpression::release_interval_day() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.interval_day) + if (_internal_has_interval_day()) { + clear_has_kind(); + ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.interval_day_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_IntervalDay& DerivationExpression::_internal_interval_day() const { + return _internal_has_interval_day() + ? *kind_.interval_day_ + : reinterpret_cast< ::io::substrait::Type_IntervalDay&>(::io::substrait::_Type_IntervalDay_default_instance_); +} +inline const ::io::substrait::Type_IntervalDay& DerivationExpression::interval_day() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.interval_day) + return _internal_interval_day(); +} +inline ::io::substrait::Type_IntervalDay* DerivationExpression::unsafe_arena_release_interval_day() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.interval_day) + if (_internal_has_interval_day()) { + clear_has_kind(); + ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + kind_.interval_day_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { + clear_kind(); + if (interval_day) { + set_has_interval_day(); + kind_.interval_day_ = interval_day; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.interval_day) +} +inline ::io::substrait::Type_IntervalDay* DerivationExpression::_internal_mutable_interval_day() { + if (!_internal_has_interval_day()) { + clear_kind(); + set_has_interval_day(); + kind_.interval_day_ = CreateMaybeMessage< ::io::substrait::Type_IntervalDay >(GetArena()); + } + return kind_.interval_day_; +} +inline ::io::substrait::Type_IntervalDay* DerivationExpression::mutable_interval_day() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.interval_day) + return _internal_mutable_interval_day(); +} + +// .io.substrait.Type.TimestampTZ timestamp_tz = 29; +inline bool DerivationExpression::_internal_has_timestamp_tz() const { + return kind_case() == kTimestampTz; +} +inline bool DerivationExpression::has_timestamp_tz() const { + return _internal_has_timestamp_tz(); +} +inline void DerivationExpression::set_has_timestamp_tz() { + _oneof_case_[0] = kTimestampTz; +} +inline ::io::substrait::Type_TimestampTZ* DerivationExpression::release_timestamp_tz() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.timestamp_tz) + if (_internal_has_timestamp_tz()) { + clear_has_kind(); + ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.timestamp_tz_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_TimestampTZ& DerivationExpression::_internal_timestamp_tz() const { + return _internal_has_timestamp_tz() + ? *kind_.timestamp_tz_ + : reinterpret_cast< ::io::substrait::Type_TimestampTZ&>(::io::substrait::_Type_TimestampTZ_default_instance_); +} +inline const ::io::substrait::Type_TimestampTZ& DerivationExpression::timestamp_tz() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.timestamp_tz) + return _internal_timestamp_tz(); +} +inline ::io::substrait::Type_TimestampTZ* DerivationExpression::unsafe_arena_release_timestamp_tz() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.timestamp_tz) + if (_internal_has_timestamp_tz()) { + clear_has_kind(); + ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + kind_.timestamp_tz_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { + clear_kind(); + if (timestamp_tz) { + set_has_timestamp_tz(); + kind_.timestamp_tz_ = timestamp_tz; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.timestamp_tz) +} +inline ::io::substrait::Type_TimestampTZ* DerivationExpression::_internal_mutable_timestamp_tz() { + if (!_internal_has_timestamp_tz()) { + clear_kind(); + set_has_timestamp_tz(); + kind_.timestamp_tz_ = CreateMaybeMessage< ::io::substrait::Type_TimestampTZ >(GetArena()); + } + return kind_.timestamp_tz_; +} +inline ::io::substrait::Type_TimestampTZ* DerivationExpression::mutable_timestamp_tz() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.timestamp_tz) + return _internal_mutable_timestamp_tz(); +} + +// .io.substrait.Type.UUID uuid = 32; +inline bool DerivationExpression::_internal_has_uuid() const { + return kind_case() == kUuid; +} +inline bool DerivationExpression::has_uuid() const { + return _internal_has_uuid(); +} +inline void DerivationExpression::set_has_uuid() { + _oneof_case_[0] = kUuid; +} +inline ::io::substrait::Type_UUID* DerivationExpression::release_uuid() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.uuid) + if (_internal_has_uuid()) { + clear_has_kind(); + ::io::substrait::Type_UUID* temp = kind_.uuid_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.uuid_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Type_UUID& DerivationExpression::_internal_uuid() const { + return _internal_has_uuid() + ? *kind_.uuid_ + : reinterpret_cast< ::io::substrait::Type_UUID&>(::io::substrait::_Type_UUID_default_instance_); +} +inline const ::io::substrait::Type_UUID& DerivationExpression::uuid() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.uuid) + return _internal_uuid(); +} +inline ::io::substrait::Type_UUID* DerivationExpression::unsafe_arena_release_uuid() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.uuid) + if (_internal_has_uuid()) { + clear_has_kind(); + ::io::substrait::Type_UUID* temp = kind_.uuid_; + kind_.uuid_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_uuid(::io::substrait::Type_UUID* uuid) { + clear_kind(); + if (uuid) { + set_has_uuid(); + kind_.uuid_ = uuid; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.uuid) +} +inline ::io::substrait::Type_UUID* DerivationExpression::_internal_mutable_uuid() { + if (!_internal_has_uuid()) { + clear_kind(); + set_has_uuid(); + kind_.uuid_ = CreateMaybeMessage< ::io::substrait::Type_UUID >(GetArena()); + } + return kind_.uuid_; +} +inline ::io::substrait::Type_UUID* DerivationExpression::mutable_uuid() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.uuid) + return _internal_mutable_uuid(); +} + +// .io.substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; +inline bool DerivationExpression::_internal_has_fixed_char() const { + return kind_case() == kFixedChar; +} +inline bool DerivationExpression::has_fixed_char() const { + return _internal_has_fixed_char(); +} +inline void DerivationExpression::set_has_fixed_char() { + _oneof_case_[0] = kFixedChar; +} +inline void DerivationExpression::clear_fixed_char() { + if (_internal_has_fixed_char()) { + if (GetArena() == nullptr) { + delete kind_.fixed_char_; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::release_fixed_char() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.fixed_char) + if (_internal_has_fixed_char()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fixed_char_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::_internal_fixed_char() const { + return _internal_has_fixed_char() + ? *kind_.fixed_char_ + : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionFixedChar&>(::io::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_); +} +inline const ::io::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::fixed_char() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.fixed_char) + return _internal_fixed_char(); +} +inline ::io::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::unsafe_arena_release_fixed_char() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.fixed_char) + if (_internal_has_fixed_char()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_; + kind_.fixed_char_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_fixed_char(::io::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) { + clear_kind(); + if (fixed_char) { + set_has_fixed_char(); + kind_.fixed_char_ = fixed_char; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.fixed_char) +} +inline ::io::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::_internal_mutable_fixed_char() { + if (!_internal_has_fixed_char()) { + clear_kind(); + set_has_fixed_char(); + kind_.fixed_char_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionFixedChar >(GetArena()); + } + return kind_.fixed_char_; +} +inline ::io::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::mutable_fixed_char() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.fixed_char) + return _internal_mutable_fixed_char(); +} + +// .io.substrait.DerivationExpression.ExpressionVarChar varchar = 22; +inline bool DerivationExpression::_internal_has_varchar() const { + return kind_case() == kVarchar; +} +inline bool DerivationExpression::has_varchar() const { + return _internal_has_varchar(); +} +inline void DerivationExpression::set_has_varchar() { + _oneof_case_[0] = kVarchar; +} +inline void DerivationExpression::clear_varchar() { + if (_internal_has_varchar()) { + if (GetArena() == nullptr) { + delete kind_.varchar_; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::release_varchar() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.varchar) + if (_internal_has_varchar()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.varchar_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::_internal_varchar() const { + return _internal_has_varchar() + ? *kind_.varchar_ + : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionVarChar&>(::io::substrait::_DerivationExpression_ExpressionVarChar_default_instance_); +} +inline const ::io::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::varchar() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.varchar) + return _internal_varchar(); +} +inline ::io::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::unsafe_arena_release_varchar() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.varchar) + if (_internal_has_varchar()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_; + kind_.varchar_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_varchar(::io::substrait::DerivationExpression_ExpressionVarChar* varchar) { + clear_kind(); + if (varchar) { + set_has_varchar(); + kind_.varchar_ = varchar; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.varchar) +} +inline ::io::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::_internal_mutable_varchar() { + if (!_internal_has_varchar()) { + clear_kind(); + set_has_varchar(); + kind_.varchar_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionVarChar >(GetArena()); + } + return kind_.varchar_; +} +inline ::io::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::mutable_varchar() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.varchar) + return _internal_mutable_varchar(); +} + +// .io.substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; +inline bool DerivationExpression::_internal_has_fixed_binary() const { + return kind_case() == kFixedBinary; +} +inline bool DerivationExpression::has_fixed_binary() const { + return _internal_has_fixed_binary(); +} +inline void DerivationExpression::set_has_fixed_binary() { + _oneof_case_[0] = kFixedBinary; +} +inline void DerivationExpression::clear_fixed_binary() { + if (_internal_has_fixed_binary()) { + if (GetArena() == nullptr) { + delete kind_.fixed_binary_; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::release_fixed_binary() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.fixed_binary) + if (_internal_has_fixed_binary()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.fixed_binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::_internal_fixed_binary() const { + return _internal_has_fixed_binary() + ? *kind_.fixed_binary_ + : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionFixedBinary&>(::io::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_); +} +inline const ::io::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::fixed_binary() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.fixed_binary) + return _internal_fixed_binary(); +} +inline ::io::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::unsafe_arena_release_fixed_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.fixed_binary) + if (_internal_has_fixed_binary()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_; + kind_.fixed_binary_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_fixed_binary(::io::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) { + clear_kind(); + if (fixed_binary) { + set_has_fixed_binary(); + kind_.fixed_binary_ = fixed_binary; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.fixed_binary) +} +inline ::io::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::_internal_mutable_fixed_binary() { + if (!_internal_has_fixed_binary()) { + clear_kind(); + set_has_fixed_binary(); + kind_.fixed_binary_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionFixedBinary >(GetArena()); + } + return kind_.fixed_binary_; +} +inline ::io::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::mutable_fixed_binary() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.fixed_binary) + return _internal_mutable_fixed_binary(); +} + +// .io.substrait.DerivationExpression.ExpressionDecimal decimal = 24; +inline bool DerivationExpression::_internal_has_decimal() const { + return kind_case() == kDecimal; +} +inline bool DerivationExpression::has_decimal() const { + return _internal_has_decimal(); +} +inline void DerivationExpression::set_has_decimal() { + _oneof_case_[0] = kDecimal; +} +inline void DerivationExpression::clear_decimal() { + if (_internal_has_decimal()) { + if (GetArena() == nullptr) { + delete kind_.decimal_; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::release_decimal() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.decimal) + if (_internal_has_decimal()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.decimal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::_internal_decimal() const { + return _internal_has_decimal() + ? *kind_.decimal_ + : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionDecimal&>(::io::substrait::_DerivationExpression_ExpressionDecimal_default_instance_); +} +inline const ::io::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::decimal() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.decimal) + return _internal_decimal(); +} +inline ::io::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::unsafe_arena_release_decimal() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.decimal) + if (_internal_has_decimal()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_; + kind_.decimal_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_decimal(::io::substrait::DerivationExpression_ExpressionDecimal* decimal) { + clear_kind(); + if (decimal) { + set_has_decimal(); + kind_.decimal_ = decimal; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.decimal) +} +inline ::io::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::_internal_mutable_decimal() { + if (!_internal_has_decimal()) { + clear_kind(); + set_has_decimal(); + kind_.decimal_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionDecimal >(GetArena()); + } + return kind_.decimal_; +} +inline ::io::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::mutable_decimal() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.decimal) + return _internal_mutable_decimal(); +} + +// .io.substrait.DerivationExpression.ExpressionStruct struct = 25; +inline bool DerivationExpression::_internal_has_struct_() const { + return kind_case() == kStruct; +} +inline bool DerivationExpression::has_struct_() const { + return _internal_has_struct_(); +} +inline void DerivationExpression::set_has_struct_() { + _oneof_case_[0] = kStruct; +} +inline void DerivationExpression::clear_struct_() { + if (_internal_has_struct_()) { + if (GetArena() == nullptr) { + delete kind_.struct__; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.struct) + if (_internal_has_struct_()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::_internal_struct_() const { + return _internal_has_struct_() + ? *kind_.struct__ + : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionStruct&>(::io::substrait::_DerivationExpression_ExpressionStruct_default_instance_); +} +inline const ::io::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.struct) + return _internal_struct_(); +} +inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.struct) + if (_internal_has_struct_()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__; + kind_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_struct_(::io::substrait::DerivationExpression_ExpressionStruct* struct_) { + clear_kind(); + if (struct_) { + set_has_struct_(); + kind_.struct__ = struct_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.struct) +} +inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::_internal_mutable_struct_() { + if (!_internal_has_struct_()) { + clear_kind(); + set_has_struct_(); + kind_.struct__ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionStruct >(GetArena()); + } + return kind_.struct__; +} +inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.struct) + return _internal_mutable_struct_(); +} + +// .io.substrait.DerivationExpression.ExpressionList list = 27; +inline bool DerivationExpression::_internal_has_list() const { + return kind_case() == kList; +} +inline bool DerivationExpression::has_list() const { + return _internal_has_list(); +} +inline void DerivationExpression::set_has_list() { + _oneof_case_[0] = kList; +} +inline void DerivationExpression::clear_list() { + if (_internal_has_list()) { + if (GetArena() == nullptr) { + delete kind_.list_; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_ExpressionList* DerivationExpression::release_list() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.list) + if (_internal_has_list()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionList* temp = kind_.list_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_ExpressionList& DerivationExpression::_internal_list() const { + return _internal_has_list() + ? *kind_.list_ + : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionList&>(::io::substrait::_DerivationExpression_ExpressionList_default_instance_); +} +inline const ::io::substrait::DerivationExpression_ExpressionList& DerivationExpression::list() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.list) + return _internal_list(); +} +inline ::io::substrait::DerivationExpression_ExpressionList* DerivationExpression::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.list) + if (_internal_has_list()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionList* temp = kind_.list_; + kind_.list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_list(::io::substrait::DerivationExpression_ExpressionList* list) { + clear_kind(); + if (list) { + set_has_list(); + kind_.list_ = list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.list) +} +inline ::io::substrait::DerivationExpression_ExpressionList* DerivationExpression::_internal_mutable_list() { + if (!_internal_has_list()) { + clear_kind(); + set_has_list(); + kind_.list_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionList >(GetArena()); + } + return kind_.list_; +} +inline ::io::substrait::DerivationExpression_ExpressionList* DerivationExpression::mutable_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.list) + return _internal_mutable_list(); +} + +// .io.substrait.DerivationExpression.ExpressionMap map = 28; +inline bool DerivationExpression::_internal_has_map() const { + return kind_case() == kMap; +} +inline bool DerivationExpression::has_map() const { + return _internal_has_map(); +} +inline void DerivationExpression::set_has_map() { + _oneof_case_[0] = kMap; +} +inline void DerivationExpression::clear_map() { + if (_internal_has_map()) { + if (GetArena() == nullptr) { + delete kind_.map_; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_ExpressionMap* DerivationExpression::release_map() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.map) + if (_internal_has_map()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_ExpressionMap& DerivationExpression::_internal_map() const { + return _internal_has_map() + ? *kind_.map_ + : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionMap&>(::io::substrait::_DerivationExpression_ExpressionMap_default_instance_); +} +inline const ::io::substrait::DerivationExpression_ExpressionMap& DerivationExpression::map() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.map) + return _internal_map(); +} +inline ::io::substrait::DerivationExpression_ExpressionMap* DerivationExpression::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.map) + if (_internal_has_map()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_; + kind_.map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_map(::io::substrait::DerivationExpression_ExpressionMap* map) { + clear_kind(); + if (map) { + set_has_map(); + kind_.map_ = map; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.map) +} +inline ::io::substrait::DerivationExpression_ExpressionMap* DerivationExpression::_internal_mutable_map() { + if (!_internal_has_map()) { + clear_kind(); + set_has_map(); + kind_.map_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionMap >(GetArena()); + } + return kind_.map_; +} +inline ::io::substrait::DerivationExpression_ExpressionMap* DerivationExpression::mutable_map() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.map) + return _internal_mutable_map(); +} + +// .io.substrait.Extensions.TypeId user_defined = 31; +inline bool DerivationExpression::_internal_has_user_defined() const { + return kind_case() == kUserDefined; +} +inline bool DerivationExpression::has_user_defined() const { + return _internal_has_user_defined(); +} +inline void DerivationExpression::set_has_user_defined() { + _oneof_case_[0] = kUserDefined; +} +inline ::io::substrait::Extensions_TypeId* DerivationExpression::release_user_defined() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.user_defined) + if (_internal_has_user_defined()) { + clear_has_kind(); + ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.user_defined_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Extensions_TypeId& DerivationExpression::_internal_user_defined() const { + return _internal_has_user_defined() + ? *kind_.user_defined_ + : reinterpret_cast< ::io::substrait::Extensions_TypeId&>(::io::substrait::_Extensions_TypeId_default_instance_); +} +inline const ::io::substrait::Extensions_TypeId& DerivationExpression::user_defined() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.user_defined) + return _internal_user_defined(); +} +inline ::io::substrait::Extensions_TypeId* DerivationExpression::unsafe_arena_release_user_defined() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.user_defined) + if (_internal_has_user_defined()) { + clear_has_kind(); + ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; + kind_.user_defined_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { + clear_kind(); + if (user_defined) { + set_has_user_defined(); + kind_.user_defined_ = user_defined; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.user_defined) +} +inline ::io::substrait::Extensions_TypeId* DerivationExpression::_internal_mutable_user_defined() { + if (!_internal_has_user_defined()) { + clear_kind(); + set_has_user_defined(); + kind_.user_defined_ = CreateMaybeMessage< ::io::substrait::Extensions_TypeId >(GetArena()); + } + return kind_.user_defined_; +} +inline ::io::substrait::Extensions_TypeId* DerivationExpression::mutable_user_defined() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.user_defined) + return _internal_mutable_user_defined(); +} + +// string type_parameter_name = 33; +inline bool DerivationExpression::_internal_has_type_parameter_name() const { + return kind_case() == kTypeParameterName; +} +inline bool DerivationExpression::has_type_parameter_name() const { + return _internal_has_type_parameter_name(); +} +inline void DerivationExpression::set_has_type_parameter_name() { + _oneof_case_[0] = kTypeParameterName; +} +inline void DerivationExpression::clear_type_parameter_name() { + if (_internal_has_type_parameter_name()) { + kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_kind(); + } +} +inline const std::string& DerivationExpression::type_parameter_name() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.type_parameter_name) + return _internal_type_parameter_name(); +} +template +inline void DerivationExpression::set_type_parameter_name(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_type_parameter_name()) { + clear_kind(); + set_has_type_parameter_name(); + kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.type_parameter_name) +} +inline std::string* DerivationExpression::mutable_type_parameter_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.type_parameter_name) + return _internal_mutable_type_parameter_name(); +} +inline const std::string& DerivationExpression::_internal_type_parameter_name() const { + if (_internal_has_type_parameter_name()) { + return kind_.type_parameter_name_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void DerivationExpression::_internal_set_type_parameter_name(const std::string& value) { + if (!_internal_has_type_parameter_name()) { + clear_kind(); + set_has_type_parameter_name(); + kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* DerivationExpression::_internal_mutable_type_parameter_name() { + if (!_internal_has_type_parameter_name()) { + clear_kind(); + set_has_type_parameter_name(); + kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return kind_.type_parameter_name_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* DerivationExpression::release_type_parameter_name() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.type_parameter_name) + if (_internal_has_type_parameter_name()) { + clear_has_kind(); + return kind_.type_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void DerivationExpression::set_allocated_type_parameter_name(std::string* type_parameter_name) { + if (has_kind()) { + clear_kind(); + } + if (type_parameter_name != nullptr) { + set_has_type_parameter_name(); + kind_.type_parameter_name_.UnsafeSetDefault(type_parameter_name); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(type_parameter_name); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.type_parameter_name) +} + +// string integer_parameter_name = 34; +inline bool DerivationExpression::_internal_has_integer_parameter_name() const { + return kind_case() == kIntegerParameterName; +} +inline bool DerivationExpression::has_integer_parameter_name() const { + return _internal_has_integer_parameter_name(); +} +inline void DerivationExpression::set_has_integer_parameter_name() { + _oneof_case_[0] = kIntegerParameterName; +} +inline void DerivationExpression::clear_integer_parameter_name() { + if (_internal_has_integer_parameter_name()) { + kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_kind(); + } +} +inline const std::string& DerivationExpression::integer_parameter_name() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.integer_parameter_name) + return _internal_integer_parameter_name(); +} +template +inline void DerivationExpression::set_integer_parameter_name(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_integer_parameter_name()) { + clear_kind(); + set_has_integer_parameter_name(); + kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.integer_parameter_name) +} +inline std::string* DerivationExpression::mutable_integer_parameter_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.integer_parameter_name) + return _internal_mutable_integer_parameter_name(); +} +inline const std::string& DerivationExpression::_internal_integer_parameter_name() const { + if (_internal_has_integer_parameter_name()) { + return kind_.integer_parameter_name_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void DerivationExpression::_internal_set_integer_parameter_name(const std::string& value) { + if (!_internal_has_integer_parameter_name()) { + clear_kind(); + set_has_integer_parameter_name(); + kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* DerivationExpression::_internal_mutable_integer_parameter_name() { + if (!_internal_has_integer_parameter_name()) { + clear_kind(); + set_has_integer_parameter_name(); + kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return kind_.integer_parameter_name_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* DerivationExpression::release_integer_parameter_name() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.integer_parameter_name) + if (_internal_has_integer_parameter_name()) { + clear_has_kind(); + return kind_.integer_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void DerivationExpression::set_allocated_integer_parameter_name(std::string* integer_parameter_name) { + if (has_kind()) { + clear_kind(); + } + if (integer_parameter_name != nullptr) { + set_has_integer_parameter_name(); + kind_.integer_parameter_name_.UnsafeSetDefault(integer_parameter_name); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(integer_parameter_name); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.integer_parameter_name) +} + +// int32 integer_literal = 35; +inline bool DerivationExpression::_internal_has_integer_literal() const { + return kind_case() == kIntegerLiteral; +} +inline bool DerivationExpression::has_integer_literal() const { + return _internal_has_integer_literal(); +} +inline void DerivationExpression::set_has_integer_literal() { + _oneof_case_[0] = kIntegerLiteral; +} +inline void DerivationExpression::clear_integer_literal() { + if (_internal_has_integer_literal()) { + kind_.integer_literal_ = 0; + clear_has_kind(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 DerivationExpression::_internal_integer_literal() const { + if (_internal_has_integer_literal()) { + return kind_.integer_literal_; + } + return 0; +} +inline void DerivationExpression::_internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!_internal_has_integer_literal()) { + clear_kind(); + set_has_integer_literal(); + } + kind_.integer_literal_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 DerivationExpression::integer_literal() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.integer_literal) + return _internal_integer_literal(); +} +inline void DerivationExpression::set_integer_literal(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_integer_literal(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.integer_literal) +} + +// .io.substrait.DerivationExpression.UnaryOp unary_op = 36; +inline bool DerivationExpression::_internal_has_unary_op() const { + return kind_case() == kUnaryOp; +} +inline bool DerivationExpression::has_unary_op() const { + return _internal_has_unary_op(); +} +inline void DerivationExpression::set_has_unary_op() { + _oneof_case_[0] = kUnaryOp; +} +inline void DerivationExpression::clear_unary_op() { + if (_internal_has_unary_op()) { + if (GetArena() == nullptr) { + delete kind_.unary_op_; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_UnaryOp* DerivationExpression::release_unary_op() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.unary_op) + if (_internal_has_unary_op()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.unary_op_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_UnaryOp& DerivationExpression::_internal_unary_op() const { + return _internal_has_unary_op() + ? *kind_.unary_op_ + : reinterpret_cast< ::io::substrait::DerivationExpression_UnaryOp&>(::io::substrait::_DerivationExpression_UnaryOp_default_instance_); +} +inline const ::io::substrait::DerivationExpression_UnaryOp& DerivationExpression::unary_op() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.unary_op) + return _internal_unary_op(); +} +inline ::io::substrait::DerivationExpression_UnaryOp* DerivationExpression::unsafe_arena_release_unary_op() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.unary_op) + if (_internal_has_unary_op()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_; + kind_.unary_op_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_unary_op(::io::substrait::DerivationExpression_UnaryOp* unary_op) { + clear_kind(); + if (unary_op) { + set_has_unary_op(); + kind_.unary_op_ = unary_op; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.unary_op) +} +inline ::io::substrait::DerivationExpression_UnaryOp* DerivationExpression::_internal_mutable_unary_op() { + if (!_internal_has_unary_op()) { + clear_kind(); + set_has_unary_op(); + kind_.unary_op_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_UnaryOp >(GetArena()); + } + return kind_.unary_op_; +} +inline ::io::substrait::DerivationExpression_UnaryOp* DerivationExpression::mutable_unary_op() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.unary_op) + return _internal_mutable_unary_op(); +} + +// .io.substrait.DerivationExpression.BinaryOp binary_op = 37; +inline bool DerivationExpression::_internal_has_binary_op() const { + return kind_case() == kBinaryOp; +} +inline bool DerivationExpression::has_binary_op() const { + return _internal_has_binary_op(); +} +inline void DerivationExpression::set_has_binary_op() { + _oneof_case_[0] = kBinaryOp; +} +inline void DerivationExpression::clear_binary_op() { + if (_internal_has_binary_op()) { + if (GetArena() == nullptr) { + delete kind_.binary_op_; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_BinaryOp* DerivationExpression::release_binary_op() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.binary_op) + if (_internal_has_binary_op()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.binary_op_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_BinaryOp& DerivationExpression::_internal_binary_op() const { + return _internal_has_binary_op() + ? *kind_.binary_op_ + : reinterpret_cast< ::io::substrait::DerivationExpression_BinaryOp&>(::io::substrait::_DerivationExpression_BinaryOp_default_instance_); +} +inline const ::io::substrait::DerivationExpression_BinaryOp& DerivationExpression::binary_op() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.binary_op) + return _internal_binary_op(); +} +inline ::io::substrait::DerivationExpression_BinaryOp* DerivationExpression::unsafe_arena_release_binary_op() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.binary_op) + if (_internal_has_binary_op()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_; + kind_.binary_op_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_binary_op(::io::substrait::DerivationExpression_BinaryOp* binary_op) { + clear_kind(); + if (binary_op) { + set_has_binary_op(); + kind_.binary_op_ = binary_op; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.binary_op) +} +inline ::io::substrait::DerivationExpression_BinaryOp* DerivationExpression::_internal_mutable_binary_op() { + if (!_internal_has_binary_op()) { + clear_kind(); + set_has_binary_op(); + kind_.binary_op_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_BinaryOp >(GetArena()); + } + return kind_.binary_op_; +} +inline ::io::substrait::DerivationExpression_BinaryOp* DerivationExpression::mutable_binary_op() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.binary_op) + return _internal_mutable_binary_op(); +} + +// .io.substrait.DerivationExpression.IfElse if_else = 38; +inline bool DerivationExpression::_internal_has_if_else() const { + return kind_case() == kIfElse; +} +inline bool DerivationExpression::has_if_else() const { + return _internal_has_if_else(); +} +inline void DerivationExpression::set_has_if_else() { + _oneof_case_[0] = kIfElse; +} +inline void DerivationExpression::clear_if_else() { + if (_internal_has_if_else()) { + if (GetArena() == nullptr) { + delete kind_.if_else_; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_IfElse* DerivationExpression::release_if_else() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.if_else) + if (_internal_has_if_else()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_IfElse* temp = kind_.if_else_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.if_else_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_IfElse& DerivationExpression::_internal_if_else() const { + return _internal_has_if_else() + ? *kind_.if_else_ + : reinterpret_cast< ::io::substrait::DerivationExpression_IfElse&>(::io::substrait::_DerivationExpression_IfElse_default_instance_); +} +inline const ::io::substrait::DerivationExpression_IfElse& DerivationExpression::if_else() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.if_else) + return _internal_if_else(); +} +inline ::io::substrait::DerivationExpression_IfElse* DerivationExpression::unsafe_arena_release_if_else() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.if_else) + if (_internal_has_if_else()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_IfElse* temp = kind_.if_else_; + kind_.if_else_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_if_else(::io::substrait::DerivationExpression_IfElse* if_else) { + clear_kind(); + if (if_else) { + set_has_if_else(); + kind_.if_else_ = if_else; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.if_else) +} +inline ::io::substrait::DerivationExpression_IfElse* DerivationExpression::_internal_mutable_if_else() { + if (!_internal_has_if_else()) { + clear_kind(); + set_has_if_else(); + kind_.if_else_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_IfElse >(GetArena()); + } + return kind_.if_else_; +} +inline ::io::substrait::DerivationExpression_IfElse* DerivationExpression::mutable_if_else() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.if_else) + return _internal_mutable_if_else(); +} + +inline bool DerivationExpression::has_kind() const { + return kind_case() != KIND_NOT_SET; +} +inline void DerivationExpression::clear_has_kind() { + _oneof_case_[0] = KIND_NOT_SET; +} +inline DerivationExpression::KindCase DerivationExpression::kind_case() const { + return DerivationExpression::KindCase(_oneof_case_[0]); +} +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace substrait +} // namespace io + +PROTOBUF_NAMESPACE_OPEN + +template <> struct is_proto_enum< ::io::substrait::DerivationExpression_UnaryOp_OpType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::DerivationExpression_UnaryOp_OpType>() { + return ::io::substrait::DerivationExpression_UnaryOp_OpType_descriptor(); +} +template <> struct is_proto_enum< ::io::substrait::DerivationExpression_BinaryOp_OpType> : ::std::true_type {}; +template <> +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::DerivationExpression_BinaryOp_OpType>() { + return ::io::substrait::DerivationExpression_BinaryOp_OpType_descriptor(); +} + +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_type_5fexpressions_2eproto diff --git a/dev/archery/archery/cli.py b/dev/archery/archery/cli.py index d8eeb7bab0e..dbe0b5c4bda 100644 --- a/dev/archery/archery/cli.py +++ b/dev/archery/archery/cli.py @@ -118,6 +118,12 @@ def _apply_options(cmd, options): @cpp_toolchain_options @click.option("--build-type", default=None, type=build_type, help="CMake's CMAKE_BUILD_TYPE") +@click.option("--build-static", default=True, type=BOOL, + help="Build static libraries") +@click.option("--build-shared", default=True, type=BOOL, + help="Build shared libraries") +@click.option("--build-unity", default=True, type=BOOL, + help="Use CMAKE_UNITY_BUILD") @click.option("--warn-level", default="production", type=warn_level_type, help="Controls compiler warnings -W(no-)error.") @click.option("--use-gold-linker", default=True, type=BOOL, diff --git a/dev/archery/archery/lang/cpp.py b/dev/archery/archery/lang/cpp.py index cf25ba871b5..4ece6ec829b 100644 --- a/dev/archery/archery/lang/cpp.py +++ b/dev/archery/archery/lang/cpp.py @@ -42,7 +42,7 @@ def __init__(self, cc=None, cxx=None, cxx_flags=None, build_type=None, warn_level=None, cpp_package_prefix=None, install_prefix=None, use_conda=None, - build_static=False, build_shared=True, build_unity=True, + build_static=True, build_shared=True, build_unity=True, # tests & examples with_tests=None, with_benchmarks=None, with_examples=None, with_integration=None, From 906aacfd46cacef40f2241e66b8045803fa62620 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 12 Nov 2021 16:22:51 -0500 Subject: [PATCH 002/113] add conversion of types and a basic roundtrip test --- cpp/src/arrow/engine/CMakeLists.txt | 3 +- cpp/src/arrow/engine/engine_test.cc | 33 ++ cpp/src/arrow/engine/protocol_internal.cc | 445 ++++++++++++++++++ cpp/src/arrow/engine/protocol_internal.h | 65 +++ .../engine/simple_extension_type_internal.h | 180 +++++++ cpp/src/arrow/engine/substrait_consumer.cc | 34 +- cpp/src/arrow/engine/substrait_consumer.h | 16 + cpp/src/arrow/type.h | 2 +- 8 files changed, 765 insertions(+), 13 deletions(-) create mode 100644 cpp/src/arrow/engine/protocol_internal.cc create mode 100644 cpp/src/arrow/engine/protocol_internal.h create mode 100644 cpp/src/arrow/engine/simple_extension_type_internal.h diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 445dec04559..0c5d61bdb38 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -26,7 +26,8 @@ set(ARROW_ENGINE_LINK_LIBS ${ARROW_PROTOBUF_LIBPROTOBUF}) #endif() set(ARROW_ENGINE_SRCS - substrait_consumer.cc) + substrait_consumer.cc + protocol_internal.cc) set(SUBSTRAIT_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait") set(SUBSTRAIT_GEN_DIR "${ARROW_SOURCE_DIR}/src/generated/substrait") diff --git a/cpp/src/arrow/engine/engine_test.cc b/cpp/src/arrow/engine/engine_test.cc index b248758bc12..1e995719324 100644 --- a/cpp/src/arrow/engine/engine_test.cc +++ b/cpp/src/arrow/engine/engine_test.cc @@ -14,3 +14,36 @@ // KIND, either express or implied. See the License for the // specific language governing permissions and limitations // under the License. + +#include "arrow/engine/substrait_consumer.h" + +#include + +#include "arrow/testing/gtest_util.h" + +namespace arrow { +namespace engine { + +TEST(SubstraitConsumption, BasicTypeRoundTrip) { + for (auto type : { + boolean(), + int8(), + int16(), + int32(), + int64(), + float32(), + float64(), + struct_({ + field("", int64()), + field("", list(utf8())), + }), + }) { + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type)); + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized)); + ASSERT_EQ(*roundtripped, *type); + } +} + +} // namespace engine +} // namespace arrow + diff --git a/cpp/src/arrow/engine/protocol_internal.cc b/cpp/src/arrow/engine/protocol_internal.cc new file mode 100644 index 00000000000..f07b3b85a3e --- /dev/null +++ b/cpp/src/arrow/engine/protocol_internal.cc @@ -0,0 +1,445 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "arrow/engine/protocol_internal.h" + +#include + +#include "arrow/engine/simple_extension_type_internal.h" +#include "arrow/type.h" +#include "arrow/util/logging.h" +#include "arrow/visitor_inline.h" + +#include "arrow/util/make_unique.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" +#include "google/protobuf/message_lite.h" + +namespace arrow { +namespace engine { + +Status ParseFromBufferImpl(const Buffer& buf, const std::string& full_name, + google::protobuf::Message* message) { + google::protobuf::io::ArrayInputStream buf_stream{buf.data(), + static_cast(buf.size())}; + + if (message->ParseFromZeroCopyStream(&buf_stream)) { + return Status::OK(); + } + return Status::IOError("ParseFromZeroCopyStream failed for ", full_name); +} + +namespace { + +template +Status CheckVariation(const TypeMessage& type) { + if (!type.has_variation()) return Status::OK(); + return Status::NotImplemented("Type.Variation for ", type.DebugString()); +} + +template +bool IsNullable(const TypeMessage& type) { + return type.nullability() == st::Type_Nullability_NULLABLE; +} + +template +Result, bool>> FromProtoImpl(const TypeMessage& type, + A&&... args) { + RETURN_NOT_OK(CheckVariation(type)); + + return std::make_pair(std::static_pointer_cast( + std::make_shared(std::forward(args)...)), + IsNullable(type)); +} + +template +Result FieldsFromProto( + int size, const Types& types, + const Names* names = static_cast(nullptr)) { + FieldVector fields(size); + for (int i = 0; i < size; ++i) { + ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(types[i])); + + std::string name = names ? std::move((*names)[i]) : ""; + fields[i] = + field(std::move(name), std::move(type_nullable.first), type_nullable.second); + } + return fields; +} + +template +static Result, bool>> +SimpleExtensionTypeFromProtoImpl(const TypeMessage& type, + typename ExtType::ParamsType params) { + RETURN_NOT_OK(CheckVariation(type)); + ARROW_ASSIGN_OR_RAISE(auto ext_type, ExtType::Make(std::move(params))) + return std::make_pair(std::move(ext_type), IsNullable(type)); +} + +constexpr util::string_view kUuidExtensionName = "uuid"; +struct UuidExtensionParams {}; +Result> UuidGetStorage(const UuidExtensionParams&) { + return fixed_size_binary(16); +} +static auto kUuidExtensionParamsProperties = internal::MakeProperties(); + +using UuidType = SimpleExtensionType; + +constexpr util::string_view kFixedCharExtensionName = "fixed_char"; +struct FixedCharExtensionParams { + int32_t length; +}; +Result> FixedCharGetStorage( + const FixedCharExtensionParams& params) { + return fixed_size_binary(params.length); +} +static auto kFixedCharExtensionParamsProperties = internal::MakeProperties( + internal::DataMember("length", &FixedCharExtensionParams::length)); + +using FixedCharType = + SimpleExtensionType; + +constexpr util::string_view kVarCharExtensionName = "varchar"; +struct VarCharExtensionParams { + int32_t length; +}; +Result> VarCharGetStorage(const VarCharExtensionParams&) { + return utf8(); +} +static auto kVarCharExtensionParamsProperties = internal::MakeProperties( + internal::DataMember("length", &VarCharExtensionParams::length)); + +using VarCharType = + SimpleExtensionType; + +} // namespace + +Result, bool>> FromProto(const st::Type& type) { + switch (type.kind_case()) { + case st::Type::KindCase::kBool: + return FromProtoImpl(type.bool_()); + + case st::Type::KindCase::kI8: + return FromProtoImpl(type.i8()); + case st::Type::KindCase::kI16: + return FromProtoImpl(type.i16()); + case st::Type::KindCase::kI32: + return FromProtoImpl(type.i32()); + case st::Type::KindCase::kI64: + return FromProtoImpl(type.i64()); + + case st::Type::KindCase::kFp32: + return FromProtoImpl(type.fp32()); + case st::Type::KindCase::kFp64: + return FromProtoImpl(type.fp64()); + + case st::Type::KindCase::kString: + return FromProtoImpl(type.string()); + case st::Type::KindCase::kBinary: + return FromProtoImpl(type.binary()); + + case st::Type::KindCase::kTimestamp: + return FromProtoImpl(type.timestamp(), TimeUnit::MICRO); + case st::Type::KindCase::kTimestampTz: + return FromProtoImpl(type.timestamp_tz(), TimeUnit::MICRO, "UTC"); + case st::Type::KindCase::kDate: + return FromProtoImpl(type.date()); + case st::Type::KindCase::kTime: + return FromProtoImpl(type.time(), TimeUnit::MICRO); + + case st::Type::KindCase::kIntervalYear: + // None of MonthIntervalType, DayTimeIntervalType, MonthDayNanoIntervalType + // corresponds; none has a year field. Lossy conversion to MonthIntervalType + // would be possible... + break; + + case st::Type::KindCase::kIntervalDay: + // Documentation is inconsistent; the precision of the sub-day interval is described + // as microsecond in simple_logical_types.md but IntervalDayToSecond has the field + // `int32 seconds`. At microsecond precision it's minimally necessary to store all + // values in the range `[0,24*60*60*1000_000)` in order to express all possible + // sub-day intervals, but this is not possible for 32 bit integers. + // + // Possible fixes: amend that field to `int64 milliseconds`, then this type can be + // converted to MonthDayNanoIntervalType (months will always be 0). + // : amend documentation to claim only second precision, then this + // type can be converted to DayTimeIntervalType (milliseconds % 1000 + // will always be 0). + break; + + case st::Type::KindCase::kUuid: + return SimpleExtensionTypeFromProtoImpl(type.uuid(), {}); + + case st::Type::KindCase::kFixedChar: + // need extension type to mark utf-8 constraint + return SimpleExtensionTypeFromProtoImpl( + type.fixed_char(), {type.fixed_char().length()}); + + case st::Type::KindCase::kVarchar: + // need extension type to hold type.varchar().length() constraint + return SimpleExtensionTypeFromProtoImpl(type.varchar(), + {type.varchar().length()}); + + case st::Type::KindCase::kFixedBinary: + return FromProtoImpl(type.fixed_binary(), + type.fixed_binary().length()); + + case st::Type::KindCase::kDecimal: { + const auto& decimal = type.decimal(); + return FromProtoImpl(decimal, decimal.precision(), decimal.scale()); + } + + case st::Type::KindCase::kStruct: { + const auto& struct_ = type.struct_(); + + ARROW_ASSIGN_OR_RAISE(auto fields, + FieldsFromProto(struct_.types_size(), struct_.types())); + + return FromProtoImpl(struct_, std::move(fields)); + } + + // NamedStruct is not currently enumerated in KindCase. This block of dead code is + // here just to verify that it can be compiled. + // case st::Type::KindCase::kNamedStruct: { + if (false) { + // const st::Type::NamedStruct& named_struct = type.named_struct(); + st::Type::NamedStruct named_struct; + + if (named_struct.has_struct_()) { + return Status::Invalid( + "While converting ", type.DebugString(), + " no anonymous struct type was provided to which to names " + "could be attached."); + } + const auto& struct_ = named_struct.struct_(); + RETURN_NOT_OK(CheckVariation(struct_)); + + if (struct_.types_size() != named_struct.names_size()) { + return Status::Invalid("While converting ", type.DebugString(), " received ", + struct_.types_size(), " types but ", + named_struct.names_size(), " names."); + } + + ARROW_ASSIGN_OR_RAISE(auto fields, + FieldsFromProto(struct_.types_size(), struct_.types(), + &named_struct.names())); + + return std::make_pair(arrow::struct_(std::move(fields)), IsNullable(struct_)); + } + + case st::Type::KindCase::kList: { + const auto& list = type.list(); + + if (!list.has_type()) { + return Status::Invalid( + "While converting to ListType encountered a missing item type in ", + list.DebugString()); + } + + ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(list.type())); + return FromProtoImpl( + list, field("item", std::move(type_nullable.first), type_nullable.second)); + } + + case st::Type::KindCase::kMap: { + const auto& map = type.map(); + + static const std::array kMissing = {"key and value", "value", "key", + nullptr}; + if (auto missing = kMissing[map.has_key() + map.has_value() * 2]) { + return Status::Invalid("While converting to MapType encountered missing ", + missing, " type in ", map.DebugString()); + } + + ARROW_ASSIGN_OR_RAISE(auto key_nullable, FromProto(map.key())); + ARROW_ASSIGN_OR_RAISE(auto value_nullable, FromProto(map.value())); + + if (key_nullable.second) { + return Status::Invalid( + "While converting to MapType encountered nullable key field in ", + map.DebugString()); + } + + return FromProtoImpl( + map, std::move(key_nullable.first), + field("value", std::move(value_nullable.first), value_nullable.second)); + } + + default: + break; + } + + return Status::NotImplemented("conversion to arrow::DataType from ", + type.DebugString()); +} + +struct ToProtoImpl { + Status Visit(const NullType& t) { return NotImplemented(t); } + + Status Visit(const BooleanType& t) { return SetWith(&st::Type::set_allocated_bool_); } + + Status Visit(const Int8Type& t) { return SetWith(&st::Type::set_allocated_i8); } + Status Visit(const Int16Type& t) { return SetWith(&st::Type::set_allocated_i16); } + Status Visit(const Int32Type& t) { return SetWith(&st::Type::set_allocated_i32); } + Status Visit(const Int64Type& t) { return SetWith(&st::Type::set_allocated_i64); } + + Status Visit(const UInt8Type& t) { return NotImplemented(t); } + Status Visit(const UInt16Type& t) { return NotImplemented(t); } + Status Visit(const UInt32Type& t) { return NotImplemented(t); } + Status Visit(const UInt64Type& t) { return NotImplemented(t); } + + Status Visit(const HalfFloatType& t) { return NotImplemented(t); } + Status Visit(const FloatType& t) { return SetWith(&st::Type::set_allocated_fp32); } + Status Visit(const DoubleType& t) { return SetWith(&st::Type::set_allocated_fp64); } + + Status Visit(const StringType& t) { return SetWith(&st::Type::set_allocated_string); } + Status Visit(const BinaryType& t) { return SetWith(&st::Type::set_allocated_binary); } + + Status Visit(const FixedSizeBinaryType& t) { + SetWithThen(&st::Type::set_allocated_fixed_binary)->set_length(t.byte_width()); + return Status::OK(); + } + + Status Visit(const Date32Type& t) { return NotImplemented(t); } + Status Visit(const Date64Type& t) { return SetWith(&st::Type::set_allocated_date); } + + Status Visit(const TimestampType& t) { + if (t.unit() != TimeUnit::MICRO) return NotImplemented(t); + if (t.timezone() == "") return SetWith(&st::Type::set_allocated_timestamp); + if (t.timezone() == "UTC") return SetWith(&st::Type::set_allocated_timestamp_tz); + return NotImplemented(t); + } + + Status Visit(const Time32Type& t) { return NotImplemented(t); } + Status Visit(const Time64Type& t) { + if (t.unit() != TimeUnit::MICRO) return NotImplemented(t); + return SetWith(&st::Type::set_allocated_time); + } + + Status Visit(const MonthIntervalType& t) { return NotImplemented(t); } + Status Visit(const DayTimeIntervalType& t) { return NotImplemented(t); } + + Status Visit(const Decimal128Type& t) { + auto dec = SetWithThen(&st::Type::set_allocated_decimal); + dec->set_precision(t.precision()); + dec->set_scale(t.scale()); + return Status::OK(); + } + Status Visit(const Decimal256Type& t) { return NotImplemented(t); } + + Status Visit(const ListType& t) { + ARROW_ASSIGN_OR_RAISE(auto type, + ToProto(*t.value_type(), t.value_field()->nullable())); + SetWithThen(&st::Type::set_allocated_list)->set_allocated_type(type.release()); + return Status::OK(); + } + + Status Visit(const StructType& t) { + auto types = SetWithThen(&st::Type::set_allocated_struct_)->mutable_types(); + + types->Reserve(t.num_fields()); + + for (const auto& field : t.fields()) { + ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*field->type(), field->nullable())); + types->AddAllocated(type.release()); + } + return Status::OK(); + } + + Status Visit(const SparseUnionType& t) { return NotImplemented(t); } + Status Visit(const DenseUnionType& t) { return NotImplemented(t); } + Status Visit(const DictionaryType& t) { return NotImplemented(t); } + + Status Visit(const MapType& t) { + auto map = SetWithThen(&st::Type::set_allocated_map); + + ARROW_ASSIGN_OR_RAISE(auto key, ToProto(*t.key_type())); + map->set_allocated_key(key.release()); + + ARROW_ASSIGN_OR_RAISE(auto value, + ToProto(*t.value_type(), t.value_field()->nullable())); + map->set_allocated_value(value.release()); + + return Status::OK(); + } + + Status Visit(const ExtensionType& t) { + auto ext_name = t.extension_name(); + + if (auto params = UuidType::GetIf(t)) { + return SetWith(&st::Type::set_allocated_uuid); + } + + if (auto params = FixedCharType::GetIf(t)) { + SetWithThen(&st::Type::set_allocated_fixed_char)->set_length(params->length); + return Status::OK(); + } + + if (auto params = VarCharType::GetIf(t)) { + SetWithThen(&st::Type::set_allocated_varchar)->set_length(params->length); + return Status::OK(); + } + + return NotImplemented(t); + } + + Status Visit(const FixedSizeListType& t) { return NotImplemented(t); } + Status Visit(const DurationType& t) { return NotImplemented(t); } + Status Visit(const LargeStringType& t) { return NotImplemented(t); } + Status Visit(const LargeBinaryType& t) { return NotImplemented(t); } + Status Visit(const LargeListType& t) { return NotImplemented(t); } + Status Visit(const MonthDayNanoIntervalType& t) { return NotImplemented(t); } + + template + Sub* SetWithThen(void (st::Type::*set_allocated_sub)(Sub*)) { + auto sub = internal::make_unique(); + sub->set_nullability(nullable_ ? st::Type_Nullability_NULLABLE + : st::Type_Nullability_REQUIRED); + + auto out = sub.get(); + (type_->*set_allocated_sub)(sub.release()); + return out; + } + + template + Status SetWith(void (st::Type::*set_allocated_sub)(Sub*)) { + return SetWithThen(set_allocated_sub), Status::OK(); + } + + Status NotImplemented(const DataType& t) { + return Status::NotImplemented("conversion to substrait::Type from ", t.ToString()); + } + + Status operator()(const DataType& type) { return VisitTypeInline(type, this); } + + st::Type* type_; + bool nullable_; +}; + +Result> ToProto(const DataType& type, bool nullable) { + auto out = internal::make_unique(); + RETURN_NOT_OK((ToProtoImpl{out.get(), nullable})(type)); + return std::move(out); +} + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/protocol_internal.h b/cpp/src/arrow/engine/protocol_internal.h new file mode 100644 index 00000000000..fe00a220f12 --- /dev/null +++ b/cpp/src/arrow/engine/protocol_internal.h @@ -0,0 +1,65 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// This API is EXPERIMENTAL. + +#pragma once + +#include +#include + +#include "arrow/buffer.h" +#include "arrow/engine/visibility.h" +#include "arrow/result.h" +#include "arrow/status.h" +#include "arrow/type_fwd.h" + +#include "generated/substrait/plan.pb.h" // IWYU pragma: export + +namespace st = io::substrait; + +namespace google { +namespace protobuf { + +class Message; + +} // namespace protobuf +} // namespace google + +namespace arrow { +namespace engine { + +ARROW_ENGINE_EXPORT +Status ParseFromBufferImpl(const Buffer& buf, const std::string& full_name, + google::protobuf::Message* message); + +template +Result ParseFromBuffer(const Buffer& buf) { + Message message; + ARROW_RETURN_NOT_OK( + ParseFromBufferImpl(buf, Message::descriptor()->full_name(), &message)); + return message; +} + +ARROW_ENGINE_EXPORT +Result, bool>> FromProto(const st::Type&); + +ARROW_ENGINE_EXPORT +Result> ToProto(const DataType&, bool nullable = true); + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/simple_extension_type_internal.h b/cpp/src/arrow/engine/simple_extension_type_internal.h new file mode 100644 index 00000000000..fb392a9e5b3 --- /dev/null +++ b/cpp/src/arrow/engine/simple_extension_type_internal.h @@ -0,0 +1,180 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#pragma once + +#include +#include +#include +#include + +#include "arrow/extension_type.h" +#include "arrow/util/logging.h" +#include "arrow/util/optional.h" +#include "arrow/util/reflection_internal.h" +#include "arrow/util/string.h" + +namespace arrow { +namespace engine { + +template > GetStorage(const Params&)> +class SimpleExtensionType : public ExtensionType { + public: + using ParamsType = Params; + + explicit SimpleExtensionType(std::shared_ptr storage_type, Params params = {}) + : ExtensionType(std::move(storage_type)), params_(std::move(params)) {} + + static Result> Make(Params params = {}) { + ARROW_ASSIGN_OR_RAISE(auto storage_type, GetStorage(params)); + return std::make_shared(std::move(storage_type), + std::move(params)); + } + + static const Params* GetIf(const ExtensionType& type) { + if (type.extension_name() != kExtensionName) return nullptr; + + return &internal::checked_cast(type).params_; + } + + std::string extension_name() const override { return kExtensionName.to_string(); } + + struct ExtensionEqualsImpl { + ExtensionEqualsImpl(const Params& l, const Params& r) : left_(l), right_(r) { + kProperties.ForEach(*this); + } + + template + void operator()(const Property& prop, size_t i) { + equal_ &= prop.get(left_) == prop.get(right_); + } + + const Params& left_; + const Params& right_; + bool equal_ = true; + }; + bool ExtensionEquals(const ExtensionType& other) const override { + if (kExtensionName != other.extension_name()) return false; + const auto& other_params = static_cast(other).params_; + return ExtensionEqualsImpl(params_, other_params).equal_; + } + + std::shared_ptr MakeArray(std::shared_ptr data) const override { + DCHECK_EQ(data->type->id(), Type::EXTENSION); + DCHECK_EQ(static_cast(*data->type).extension_name(), + kExtensionName); + return std::make_shared(data); + } + + struct DeserializeImpl { + explicit DeserializeImpl(util::string_view repr) { + Init(kExtensionName, repr, kProperties.size()); + kProperties.ForEach(*this); + } + + void Fail() { params_ = util::nullopt; } + + void Init(util::string_view class_name, util::string_view repr, + size_t num_properties) { + if (!repr.starts_with(class_name)) return Fail(); + + repr = repr.substr(class_name.size()); + if (repr.empty()) return Fail(); + if (repr.front() != '{') return Fail(); + if (repr.back() != '}') return Fail(); + + repr = repr.substr(1, repr.size() - 2); + members_ = internal::SplitString(repr, ','); + if (members_.size() != num_properties) return Fail(); + } + + template + void operator()(const Property& prop, size_t i) { + if (!params_) return; + + auto first_colon = members_[i].find_first_of(':'); + if (first_colon == util::string_view::npos) return Fail(); + + auto name = members_[i].substr(0, first_colon); + if (name != prop.name()) return Fail(); + + auto value_repr = members_[i].substr(first_colon + 1); + typename Property::Type value; + try { + std::stringstream ss(value_repr.to_string()); + ss >> value; + if (!ss.eof()) return Fail(); + } catch (...) { + return Fail(); + } + prop.set(&*params_, std::move(value)); + } + + util::optional params_; + std::vector members_; + }; + Result> Deserialize( + std::shared_ptr storage_type, + const std::string& serialized) const override { + if (auto params = DeserializeImpl(serialized).params_) { + ARROW_ASSIGN_OR_RAISE(auto expected, GetStorage(*params)); + + if (!storage_type->Equals(expected)) { + return Status::Invalid("Invalid storage type for ", kExtensionName, ": ", + storage_type->ToString(), " (expected ", + expected->ToString(), ")"); + } + + return std::make_shared(std::move(storage_type), + std::move(*params)); + } + + return Status::Invalid("Could not parse parameters for extension type ", + extension_name(), " from ", serialized); + } + + struct SerializeImpl { + explicit SerializeImpl(const Params& params) + : params_(params), members_(kProperties.size()) { + kProperties.ForEach(*this); + } + + template + void operator()(const Property& prop, size_t i) { + std::stringstream ss; + ss << prop.name() << ":" << prop.get(params_); + members_[i] = ss.str(); + } + + std::string Finish() { + return kExtensionName.to_string() + "{" + internal::JoinStrings(members_, ",") + + "}"; + } + + const Params& params_; + std::vector members_; + }; + std::string Serialize() const override { return SerializeImpl(params_).Finish(); } + + private: + Params params_; +}; + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait_consumer.cc b/cpp/src/arrow/engine/substrait_consumer.cc index f42312dc30a..ed201512448 100644 --- a/cpp/src/arrow/engine/substrait_consumer.cc +++ b/cpp/src/arrow/engine/substrait_consumer.cc @@ -17,26 +17,38 @@ #include "arrow/engine/substrait_consumer.h" +#include "arrow/engine/protocol_internal.h" #include "arrow/util/string_view.h" -#include "google/protobuf/io/zero_copy_stream_impl_lite.h" - -#include "generated/substrait/plan.pb.h" - -namespace st = io::substrait; namespace arrow { namespace engine { +Result Convert(const st::Rel& relation) { + return Status::NotImplemented(""); +} + Result> ConvertPlan(const Buffer& buf) { - st::Plan plan; + ARROW_ASSIGN_OR_RAISE(auto plan, ParseFromBuffer(buf)); - google::protobuf::io::ArrayInputStream istream{buf.data(), - static_cast(buf.size())}; - if (!plan.ParseFromZeroCopyStream(&istream)) { - return Status::Invalid("Not a valid plan"); + std::vector decls; + for (const auto& relation : plan.relations()) { + ARROW_ASSIGN_OR_RAISE(auto decl, Convert(relation)); + decls.push_back(std::move(decl)); } - return Status::NotImplemented(""); + return decls; +} + +Result> DeserializeType(const Buffer& buf) { + ARROW_ASSIGN_OR_RAISE(auto type, ParseFromBuffer(buf)); + ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(type)); + return std::move(type_nullable.first); +} + +Result> SerializeType(const DataType& type) { + ARROW_ASSIGN_OR_RAISE(auto st_type, ToProto(type)); + std::string serialized = st_type->SerializeAsString(); + return Buffer::FromString(std::move(serialized)); } } // namespace engine diff --git a/cpp/src/arrow/engine/substrait_consumer.h b/cpp/src/arrow/engine/substrait_consumer.h index e4c6c4b46ee..57bab4ffde2 100644 --- a/cpp/src/arrow/engine/substrait_consumer.h +++ b/cpp/src/arrow/engine/substrait_consumer.h @@ -32,5 +32,21 @@ namespace engine { ARROW_ENGINE_EXPORT Result> ConvertPlan(const Buffer&); +ARROW_ENGINE_EXPORT +Result> DeserializeType(const Buffer&); + +ARROW_ENGINE_EXPORT +Result> SerializeType(const DataType&); + +// TODO(bkietz) +ARROW_ENGINE_EXPORT +std::shared_ptr uuid(); + +ARROW_ENGINE_EXPORT +std::shared_ptr fixed_char(); + +ARROW_ENGINE_EXPORT +std::shared_ptr varchar(); + } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h index 4c439841ba2..b3427413180 100644 --- a/cpp/src/arrow/type.h +++ b/cpp/src/arrow/type.h @@ -817,7 +817,7 @@ class ARROW_EXPORT Decimal256Type : public DecimalType { class ARROW_EXPORT BaseListType : public NestedType { public: using NestedType::NestedType; - std::shared_ptr value_field() const { return children_[0]; } + const std::shared_ptr& value_field() const { return children_[0]; } std::shared_ptr value_type() const { return children_[0]->type(); } }; From 5fc6c34e82be1b2027c3cdcf667df90214111609 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Mon, 15 Nov 2021 10:18:53 -0500 Subject: [PATCH 003/113] reorganize to engine/substrait/{proto}_internal.cc,h --- cpp/src/arrow/engine/CMakeLists.txt | 9 +- .../engine/simple_extension_type_internal.h | 19 +-- .../arrow/engine/substrait/extension_types.cc | 99 +++++++++++++ .../arrow/engine/substrait/extension_types.h | 55 ++++++++ .../serde.cc} | 35 ++++- .../serde.h} | 8 +- .../serde_test.cc} | 2 +- .../type_internal.cc} | 133 ++++++------------ .../type_internal.h} | 26 +--- 9 files changed, 252 insertions(+), 134 deletions(-) create mode 100644 cpp/src/arrow/engine/substrait/extension_types.cc create mode 100644 cpp/src/arrow/engine/substrait/extension_types.h rename cpp/src/arrow/engine/{substrait_consumer.cc => substrait/serde.cc} (64%) rename cpp/src/arrow/engine/{substrait_consumer.h => substrait/serde.h} (90%) rename cpp/src/arrow/engine/{engine_test.cc => substrait/serde_test.cc} (97%) rename cpp/src/arrow/engine/{protocol_internal.cc => substrait/type_internal.cc} (77%) rename cpp/src/arrow/engine/{protocol_internal.h => substrait/type_internal.h} (65%) diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 0c5d61bdb38..30ab4a47429 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -26,8 +26,9 @@ set(ARROW_ENGINE_LINK_LIBS ${ARROW_PROTOBUF_LIBPROTOBUF}) #endif() set(ARROW_ENGINE_SRCS - substrait_consumer.cc - protocol_internal.cc) + substrait/extension_types.cc + substrait/serde.cc + substrait/type_internal.cc) set(SUBSTRAIT_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait") set(SUBSTRAIT_GEN_DIR "${ARROW_SOURCE_DIR}/src/generated/substrait") @@ -98,7 +99,9 @@ else() list(APPEND ARROW_ENGINE_TEST_LINK_LIBS arrow_engine_shared) endif() -add_arrow_test(engine_test +add_arrow_test(substrait_test + SOURCES + substrait/serde_test.cc EXTRA_LINK_LIBS ${ARROW_ENGINE_TEST_LINK_LIBS} PREFIX diff --git a/cpp/src/arrow/engine/simple_extension_type_internal.h b/cpp/src/arrow/engine/simple_extension_type_internal.h index fb392a9e5b3..a236ba6eb49 100644 --- a/cpp/src/arrow/engine/simple_extension_type_internal.h +++ b/cpp/src/arrow/engine/simple_extension_type_internal.h @@ -33,7 +33,7 @@ namespace engine { template > GetStorage(const Params&)> + std::shared_ptr GetStorage(const Params&)> class SimpleExtensionType : public ExtensionType { public: using ParamsType = Params; @@ -41,14 +41,17 @@ class SimpleExtensionType : public ExtensionType { explicit SimpleExtensionType(std::shared_ptr storage_type, Params params = {}) : ExtensionType(std::move(storage_type)), params_(std::move(params)) {} - static Result> Make(Params params = {}) { - ARROW_ASSIGN_OR_RAISE(auto storage_type, GetStorage(params)); + static std::shared_ptr Make(Params params) { + auto storage_type = GetStorage(params); return std::make_shared(std::move(storage_type), std::move(params)); } - static const Params* GetIf(const ExtensionType& type) { - if (type.extension_name() != kExtensionName) return nullptr; + static const Params* GetIf(const DataType& type) { + if (type.id() != Type::EXTENSION) return nullptr; + + const auto& ext_type = internal::checked_cast(type); + if (ext_type.extension_name() != kExtensionName) return nullptr; return &internal::checked_cast(type).params_; } @@ -133,12 +136,10 @@ class SimpleExtensionType : public ExtensionType { std::shared_ptr storage_type, const std::string& serialized) const override { if (auto params = DeserializeImpl(serialized).params_) { - ARROW_ASSIGN_OR_RAISE(auto expected, GetStorage(*params)); - - if (!storage_type->Equals(expected)) { + if (!storage_type->Equals(GetStorage(*params))) { return Status::Invalid("Invalid storage type for ", kExtensionName, ": ", storage_type->ToString(), " (expected ", - expected->ToString(), ")"); + GetStorage(*params)->ToString(), ")"); } return std::make_shared(std::move(storage_type), diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc new file mode 100644 index 00000000000..a98277fe5da --- /dev/null +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -0,0 +1,99 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "arrow/engine/substrait/extension_types.h" + +#include "arrow/engine/simple_extension_type_internal.h" + +namespace arrow { +namespace engine { +namespace { + +constexpr util::string_view kUuidExtensionName = "uuid"; +struct UuidExtensionParams {}; +std::shared_ptr UuidGetStorage(const UuidExtensionParams&) { + return fixed_size_binary(16); +} +static auto kUuidExtensionParamsProperties = internal::MakeProperties(); + +using UuidType = SimpleExtensionType; + +constexpr util::string_view kFixedCharExtensionName = "fixed_char"; +struct FixedCharExtensionParams { + int32_t length; +}; +std::shared_ptr FixedCharGetStorage(const FixedCharExtensionParams& params) { + return fixed_size_binary(params.length); +} +static auto kFixedCharExtensionParamsProperties = internal::MakeProperties( + internal::DataMember("length", &FixedCharExtensionParams::length)); + +using FixedCharType = + SimpleExtensionType; + +constexpr util::string_view kVarCharExtensionName = "varchar"; +struct VarCharExtensionParams { + int32_t length; +}; +std::shared_ptr VarCharGetStorage(const VarCharExtensionParams&) { + return utf8(); +} +static auto kVarCharExtensionParamsProperties = internal::MakeProperties( + internal::DataMember("length", &VarCharExtensionParams::length)); + +using VarCharType = + SimpleExtensionType; + +} // namespace + +std::shared_ptr uuid() { return UuidType::Make({}); } + +std::shared_ptr fixed_char(int32_t length) { + return FixedCharType::Make({length}); +} + +std::shared_ptr varchar(int32_t length) { return VarCharType::Make({length}); } + +bool UnwrapUuid(const DataType& t) { + if (auto params = UuidType::GetIf(t)) { + return true; + } + return false; +} + +util::optional UnwrapFixedChar(const DataType& t) { + if (auto params = FixedCharType::GetIf(t)) { + return params->length; + } + return util::nullopt; +} + +util::optional UnwrapVarChar(const DataType& t) { + if (auto params = VarCharType::GetIf(t)) { + return params->length; + } + return util::nullopt; +} + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h new file mode 100644 index 00000000000..94838d9770e --- /dev/null +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -0,0 +1,55 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// This API is EXPERIMENTAL. + +#pragma once + +#include + +#include "arrow/buffer.h" +#include "arrow/compute/exec/exec_plan.h" +#include "arrow/engine/visibility.h" +#include "arrow/result.h" +#include "arrow/util/optional.h" + +namespace arrow { +namespace engine { + +ARROW_ENGINE_EXPORT +std::shared_ptr uuid(); + +ARROW_ENGINE_EXPORT +std::shared_ptr fixed_char(int32_t length); + +ARROW_ENGINE_EXPORT +std::shared_ptr varchar(int32_t length); + +/// Return true if t is Uuid, otherwise false +ARROW_ENGINE_EXPORT +bool UnwrapUuid(const DataType&); + +/// Return FixedChar length if t is FixedChar, otherwise nullopt +ARROW_ENGINE_EXPORT +util::optional UnwrapFixedChar(const DataType&); + +/// Return Varchar (max) length if t is VarChar, otherwise nullopt +ARROW_ENGINE_EXPORT +util::optional UnwrapVarChar(const DataType& t); + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait_consumer.cc b/cpp/src/arrow/engine/substrait/serde.cc similarity index 64% rename from cpp/src/arrow/engine/substrait_consumer.cc rename to cpp/src/arrow/engine/substrait/serde.cc index ed201512448..4d6055b8bf5 100644 --- a/cpp/src/arrow/engine/substrait_consumer.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -15,14 +15,45 @@ // specific language governing permissions and limitations // under the License. -#include "arrow/engine/substrait_consumer.h" +#include "arrow/engine/substrait/serde.h" -#include "arrow/engine/protocol_internal.h" +#include "arrow/engine/substrait/type_internal.h" #include "arrow/util/string_view.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" +#include "google/protobuf/message.h" + +#include "generated/substrait/plan.pb.h" + +namespace google { +namespace protobuf { + +class Message; + +} // namespace protobuf +} // namespace google namespace arrow { namespace engine { +Status ParseFromBufferImpl(const Buffer& buf, const std::string& full_name, + google::protobuf::Message* message) { + google::protobuf::io::ArrayInputStream buf_stream{buf.data(), + static_cast(buf.size())}; + + if (message->ParseFromZeroCopyStream(&buf_stream)) { + return Status::OK(); + } + return Status::IOError("ParseFromZeroCopyStream failed for ", full_name); +} + +template +Result ParseFromBuffer(const Buffer& buf) { + Message message; + ARROW_RETURN_NOT_OK( + ParseFromBufferImpl(buf, Message::descriptor()->full_name(), &message)); + return message; +} + Result Convert(const st::Rel& relation) { return Status::NotImplemented(""); } diff --git a/cpp/src/arrow/engine/substrait_consumer.h b/cpp/src/arrow/engine/substrait/serde.h similarity index 90% rename from cpp/src/arrow/engine/substrait_consumer.h rename to cpp/src/arrow/engine/substrait/serde.h index 57bab4ffde2..495567b8533 100644 --- a/cpp/src/arrow/engine/substrait_consumer.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -38,15 +38,11 @@ Result> DeserializeType(const Buffer&); ARROW_ENGINE_EXPORT Result> SerializeType(const DataType&); -// TODO(bkietz) ARROW_ENGINE_EXPORT -std::shared_ptr uuid(); +Result DeserializeExpression(const Buffer&); ARROW_ENGINE_EXPORT -std::shared_ptr fixed_char(); - -ARROW_ENGINE_EXPORT -std::shared_ptr varchar(); +Result> SerializeExpression(const compute::Expression&); } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/engine_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc similarity index 97% rename from cpp/src/arrow/engine/engine_test.cc rename to cpp/src/arrow/engine/substrait/serde_test.cc index 1e995719324..7c1c2257ae8 100644 --- a/cpp/src/arrow/engine/engine_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -15,7 +15,7 @@ // specific language governing permissions and limitations // under the License. -#include "arrow/engine/substrait_consumer.h" +#include "arrow/engine/substrait/serde.h" #include diff --git a/cpp/src/arrow/engine/protocol_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc similarity index 77% rename from cpp/src/arrow/engine/protocol_internal.cc rename to cpp/src/arrow/engine/substrait/type_internal.cc index f07b3b85a3e..49b8d5503ca 100644 --- a/cpp/src/arrow/engine/protocol_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -15,33 +15,23 @@ // specific language governing permissions and limitations // under the License. -#include "arrow/engine/protocol_internal.h" +#include "arrow/engine/substrait/type_internal.h" +#include #include -#include "arrow/engine/simple_extension_type_internal.h" +#include "arrow/buffer.h" +#include "arrow/engine/substrait/extension_types.h" +#include "arrow/result.h" +#include "arrow/status.h" #include "arrow/type.h" #include "arrow/util/logging.h" -#include "arrow/visitor_inline.h" - #include "arrow/util/make_unique.h" -#include "google/protobuf/io/zero_copy_stream_impl_lite.h" -#include "google/protobuf/message_lite.h" +#include "arrow/visitor_inline.h" namespace arrow { namespace engine { -Status ParseFromBufferImpl(const Buffer& buf, const std::string& full_name, - google::protobuf::Message* message) { - google::protobuf::io::ArrayInputStream buf_stream{buf.data(), - static_cast(buf.size())}; - - if (message->ParseFromZeroCopyStream(&buf_stream)) { - return Status::OK(); - } - return Status::IOError("ParseFromZeroCopyStream failed for ", full_name); -} - namespace { template @@ -65,6 +55,16 @@ Result, bool>> FromProtoImpl(const TypeMessa IsNullable(type)); } +template +Result, bool>> FromProtoImpl( + const TypeMessage& type, std::shared_ptr type_factory(A...), A&&... args) { + RETURN_NOT_OK(CheckVariation(type)); + + return std::make_pair( + std::static_pointer_cast(type_factory(std::forward(args)...)), + IsNullable(type)); +} + template Result FieldsFromProto( int size, const Types& types, @@ -80,56 +80,7 @@ Result FieldsFromProto( return fields; } -template -static Result, bool>> -SimpleExtensionTypeFromProtoImpl(const TypeMessage& type, - typename ExtType::ParamsType params) { - RETURN_NOT_OK(CheckVariation(type)); - ARROW_ASSIGN_OR_RAISE(auto ext_type, ExtType::Make(std::move(params))) - return std::make_pair(std::move(ext_type), IsNullable(type)); -} - -constexpr util::string_view kUuidExtensionName = "uuid"; -struct UuidExtensionParams {}; -Result> UuidGetStorage(const UuidExtensionParams&) { - return fixed_size_binary(16); -} -static auto kUuidExtensionParamsProperties = internal::MakeProperties(); - -using UuidType = SimpleExtensionType; - -constexpr util::string_view kFixedCharExtensionName = "fixed_char"; -struct FixedCharExtensionParams { - int32_t length; -}; -Result> FixedCharGetStorage( - const FixedCharExtensionParams& params) { - return fixed_size_binary(params.length); -} -static auto kFixedCharExtensionParamsProperties = internal::MakeProperties( - internal::DataMember("length", &FixedCharExtensionParams::length)); - -using FixedCharType = - SimpleExtensionType; - -constexpr util::string_view kVarCharExtensionName = "varchar"; -struct VarCharExtensionParams { - int32_t length; -}; -Result> VarCharGetStorage(const VarCharExtensionParams&) { - return utf8(); -} -static auto kVarCharExtensionParamsProperties = internal::MakeProperties( - internal::DataMember("length", &VarCharExtensionParams::length)); - -using VarCharType = - SimpleExtensionType; +static const std::string kTimestampTzTimezoneString = "UTC"; } // namespace @@ -160,7 +111,8 @@ Result, bool>> FromProto(const st::Type& typ case st::Type::KindCase::kTimestamp: return FromProtoImpl(type.timestamp(), TimeUnit::MICRO); case st::Type::KindCase::kTimestampTz: - return FromProtoImpl(type.timestamp_tz(), TimeUnit::MICRO, "UTC"); + return FromProtoImpl(type.timestamp_tz(), TimeUnit::MICRO, + kTimestampTzTimezoneString); case st::Type::KindCase::kDate: return FromProtoImpl(type.date()); case st::Type::KindCase::kTime: @@ -173,31 +125,30 @@ Result, bool>> FromProto(const st::Type& typ break; case st::Type::KindCase::kIntervalDay: - // Documentation is inconsistent; the precision of the sub-day interval is described - // as microsecond in simple_logical_types.md but IntervalDayToSecond has the field - // `int32 seconds`. At microsecond precision it's minimally necessary to store all - // values in the range `[0,24*60*60*1000_000)` in order to express all possible - // sub-day intervals, but this is not possible for 32 bit integers. + // Documentation is inconsistent; the precision of the sub-day interval is + // described as microsecond in simple_logical_types.md but IntervalDayToSecond has + // the field `int32 seconds`. At microsecond precision it's minimally necessary to + // store all values in the range `[0,24*60*60*1000_000)` in order to express all + // possible sub-day intervals, but this is not possible for 32 bit integers. // // Possible fixes: amend that field to `int64 milliseconds`, then this type can be - // converted to MonthDayNanoIntervalType (months will always be 0). + // converted to MonthDayNanoIntervalType (months will always be + // 0). // : amend documentation to claim only second precision, then this - // type can be converted to DayTimeIntervalType (milliseconds % 1000 - // will always be 0). + // type can be converted to DayTimeIntervalType (milliseconds % + // 1000 will always be 0). break; case st::Type::KindCase::kUuid: - return SimpleExtensionTypeFromProtoImpl(type.uuid(), {}); + return FromProtoImpl(type.uuid(), uuid); case st::Type::KindCase::kFixedChar: // need extension type to mark utf-8 constraint - return SimpleExtensionTypeFromProtoImpl( - type.fixed_char(), {type.fixed_char().length()}); + return FromProtoImpl(type.fixed_char(), fixed_char, type.fixed_char().length()); case st::Type::KindCase::kVarchar: // need extension type to hold type.varchar().length() constraint - return SimpleExtensionTypeFromProtoImpl(type.varchar(), - {type.varchar().length()}); + return FromProtoImpl(type.varchar(), varchar, type.varchar().length()); case st::Type::KindCase::kFixedBinary: return FromProtoImpl(type.fixed_binary(), @@ -324,8 +275,14 @@ struct ToProtoImpl { Status Visit(const TimestampType& t) { if (t.unit() != TimeUnit::MICRO) return NotImplemented(t); - if (t.timezone() == "") return SetWith(&st::Type::set_allocated_timestamp); - if (t.timezone() == "UTC") return SetWith(&st::Type::set_allocated_timestamp_tz); + + if (t.timezone() == "") { + return SetWith(&st::Type::set_allocated_timestamp); + } + if (t.timezone() == kTimestampTzTimezoneString) { + return SetWith(&st::Type::set_allocated_timestamp_tz); + } + return NotImplemented(t); } @@ -385,17 +342,17 @@ struct ToProtoImpl { Status Visit(const ExtensionType& t) { auto ext_name = t.extension_name(); - if (auto params = UuidType::GetIf(t)) { + if (UnwrapUuid(t)) { return SetWith(&st::Type::set_allocated_uuid); } - if (auto params = FixedCharType::GetIf(t)) { - SetWithThen(&st::Type::set_allocated_fixed_char)->set_length(params->length); + if (auto length = UnwrapFixedChar(t)) { + SetWithThen(&st::Type::set_allocated_fixed_char)->set_length(*length); return Status::OK(); } - if (auto params = VarCharType::GetIf(t)) { - SetWithThen(&st::Type::set_allocated_varchar)->set_length(params->length); + if (auto length = UnwrapVarChar(t)) { + SetWithThen(&st::Type::set_allocated_varchar)->set_length(*length); return Status::OK(); } diff --git a/cpp/src/arrow/engine/protocol_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h similarity index 65% rename from cpp/src/arrow/engine/protocol_internal.h rename to cpp/src/arrow/engine/substrait/type_internal.h index fe00a220f12..d15f5b15b51 100644 --- a/cpp/src/arrow/engine/protocol_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -19,42 +19,18 @@ #pragma once -#include #include -#include "arrow/buffer.h" #include "arrow/engine/visibility.h" -#include "arrow/result.h" -#include "arrow/status.h" #include "arrow/type_fwd.h" -#include "generated/substrait/plan.pb.h" // IWYU pragma: export +#include "generated/substrait/type.pb.h" // IWYU pragma: export namespace st = io::substrait; -namespace google { -namespace protobuf { - -class Message; - -} // namespace protobuf -} // namespace google - namespace arrow { namespace engine { -ARROW_ENGINE_EXPORT -Status ParseFromBufferImpl(const Buffer& buf, const std::string& full_name, - google::protobuf::Message* message); - -template -Result ParseFromBuffer(const Buffer& buf) { - Message message; - ARROW_RETURN_NOT_OK( - ParseFromBufferImpl(buf, Message::descriptor()->full_name(), &message)); - return message; -} - ARROW_ENGINE_EXPORT Result, bool>> FromProto(const st::Type&); From 151cf729b809a5df3cc5d1a99916925c164842cf Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Mon, 15 Nov 2021 13:27:18 -0500 Subject: [PATCH 004/113] add basic literal conversions --- cpp/src/arrow/array/builder_base.h | 23 + cpp/src/arrow/engine/CMakeLists.txt | 1 + .../engine/substrait/expression_internal.cc | 427 ++++++++++++++++++ .../engine/substrait/expression_internal.h | 48 ++ .../arrow/engine/substrait/extension_types.h | 4 + cpp/src/arrow/engine/substrait/serde.cc | 12 + cpp/src/arrow/engine/substrait/serde_test.cc | 79 +++- .../arrow/engine/substrait/type_internal.cc | 75 +-- .../arrow/engine/substrait/type_internal.h | 2 + cpp/src/arrow/scalar.h | 4 +- cpp/src/arrow/testing/matchers.h | 2 +- 11 files changed, 639 insertions(+), 38 deletions(-) create mode 100644 cpp/src/arrow/engine/substrait/expression_internal.cc create mode 100644 cpp/src/arrow/engine/substrait/expression_internal.h diff --git a/cpp/src/arrow/array/builder_base.h b/cpp/src/arrow/array/builder_base.h index a513bf0f4ab..4b0e0147cea 100644 --- a/cpp/src/arrow/array/builder_base.h +++ b/cpp/src/arrow/array/builder_base.h @@ -28,6 +28,7 @@ #include "arrow/array/array_primitive.h" #include "arrow/buffer.h" #include "arrow/buffer_builder.h" +#include "arrow/result.h" #include "arrow/status.h" #include "arrow/type_fwd.h" #include "arrow/util/macros.h" @@ -286,6 +287,13 @@ ARROW_EXPORT Status MakeBuilder(MemoryPool* pool, const std::shared_ptr& type, std::unique_ptr* out); +inline Result> MakeBuilder( + const std::shared_ptr& type, MemoryPool* pool = default_memory_pool()) { + std::unique_ptr out; + ARROW_RETURN_NOT_OK(MakeBuilder(pool, type, &out)); + return std::move(out); +} + /// \brief Construct an empty ArrayBuilder corresponding to the data /// type, where any top-level or nested dictionary builders return the /// exact index type specified by the type. @@ -293,6 +301,13 @@ ARROW_EXPORT Status MakeBuilderExactIndex(MemoryPool* pool, const std::shared_ptr& type, std::unique_ptr* out); +inline Result> MakeBuilderExactIndex( + const std::shared_ptr& type, MemoryPool* pool = default_memory_pool()) { + std::unique_ptr out; + ARROW_RETURN_NOT_OK(MakeBuilderExactIndex(pool, type, &out)); + return std::move(out); +} + /// \brief Construct an empty DictionaryBuilder initialized optionally /// with a pre-existing dictionary /// \param[in] pool the MemoryPool to use for allocations @@ -304,4 +319,12 @@ Status MakeDictionaryBuilder(MemoryPool* pool, const std::shared_ptr& const std::shared_ptr& dictionary, std::unique_ptr* out); +inline Result> MakeDictionaryBuilder( + const std::shared_ptr& type, const std::shared_ptr& dictionary, + MemoryPool* pool = default_memory_pool()) { + std::unique_ptr out; + ARROW_RETURN_NOT_OK(MakeDictionaryBuilder(pool, type, dictionary, &out)); + return std::move(out); +} + } // namespace arrow diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 30ab4a47429..c9d7251bd60 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -26,6 +26,7 @@ set(ARROW_ENGINE_LINK_LIBS ${ARROW_PROTOBUF_LIBPROTOBUF}) #endif() set(ARROW_ENGINE_SRCS + substrait/expression_internal.cc substrait/extension_types.cc substrait/serde.cc substrait/type_internal.cc) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc new file mode 100644 index 00000000000..472b36ace49 --- /dev/null +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -0,0 +1,427 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// This API is EXPERIMENTAL. + +#include "arrow/engine/substrait/expression_internal.h" + +#include + +#include "arrow/builder.h" +#include "arrow/compute/exec/expression.h" +#include "arrow/engine/substrait/extension_types.h" +#include "arrow/engine/substrait/type_internal.h" +#include "arrow/engine/visibility.h" +#include "arrow/result.h" +#include "arrow/status.h" + +#include "arrow/util/make_unique.h" +#include "generated/substrait/expression.pb.h" // IWYU pragma: export + +namespace st = io::substrait; + +namespace arrow { +namespace engine { +namespace { + +std::shared_ptr FixedSizeBinaryScalarFromBytes( + const std::string& bytes) { + auto buf = Buffer::FromString(bytes); + auto type = fixed_size_binary(static_cast(buf->size())); + return std::make_shared(std::move(buf), std::move(type)); +} + +} // namespace + +Result FromProto(const st::Expression& expr) { + switch (expr.rex_type_case()) { + case st::Expression::kLiteral: { + ARROW_ASSIGN_OR_RAISE(auto datum, FromProto(expr.literal())); + return compute::literal(std::move(datum)); + } + + default: + break; + } + + return Status::NotImplemented("conversion to arrow::compute::Expression from ", + expr.DebugString()); +} + +Result FromProto(const st::Expression::Literal& lit) { + switch (lit.literal_type_case()) { + case st::Expression::Literal::kBoolean: + return Datum(lit.boolean()); + + case st::Expression::Literal::kI8: + return Datum(static_cast(lit.i8())); + case st::Expression::Literal::kI16: + return Datum(static_cast(lit.i16())); + case st::Expression::Literal::kI32: + return Datum(static_cast(lit.i32())); + case st::Expression::Literal::kI64: + return Datum(static_cast(lit.i64())); + + case st::Expression::Literal::kFp32: + return Datum(lit.fp32()); + case st::Expression::Literal::kFp64: + return Datum(lit.fp64()); + + case st::Expression::Literal::kString: + return Datum(lit.string()); + case st::Expression::Literal::kBinary: + return Datum(std::make_shared(Buffer::FromString(lit.binary()))); + + case st::Expression::Literal::kTimestamp: + return Datum(std::make_shared( + static_cast(lit.timestamp()), TimeUnit::MICRO)); + + case st::Expression::Literal::kTimestampTz: + return Datum(std::make_shared( + static_cast(lit.timestamp_tz()), TimeUnit::MICRO, + TimestampTzTimezoneString())); + + case st::Expression::Literal::kDate: + return Datum(std::make_shared(static_cast(lit.date()))); + case st::Expression::Literal::kTime: + return Datum(std::make_shared(static_cast(lit.time()), + TimeUnit::MICRO)); + + case st::Expression::Literal::kIntervalYearToMonth: + case st::Expression::Literal::kIntervalDayToSecond: + break; + + case st::Expression::Literal::kUuid: + return Datum(std::make_shared( + FixedSizeBinaryScalarFromBytes(lit.uuid()), uuid())); + + case st::Expression::Literal::kFixedChar: + return Datum(std::make_shared( + FixedSizeBinaryScalarFromBytes(lit.fixed_char()), + fixed_char(static_cast(lit.fixed_char().size())))); + + case st::Expression::Literal::kVarChar: + // FIXME + // There's no way to determine VarChar.length from the literal + break; + + case st::Expression::Literal::kFixedBinary: + return Datum(FixedSizeBinaryScalarFromBytes(lit.fixed_char())); + + case st::Expression::Literal::kDecimal: + if (lit.decimal().size() != sizeof(Decimal128)) { + return Status::Invalid("Decimal literal had ", lit.decimal().size(), + " bytes (expected ", sizeof(Decimal128), ")"); + } + + // FIXME + // It's not clear how these bytes should be interpreted... + // Furthermore, there's no way to determine scale or precision + break; + + case st::Expression::Literal::kStruct: { + const auto& struct_ = lit.struct_(); + + ScalarVector fields(struct_.fields_size()); + std::vector field_names(fields.size(), ""); + for (size_t i = 0; i < fields.size(); ++i) { + ARROW_ASSIGN_OR_RAISE(auto field, FromProto(struct_.fields(i))); + DCHECK(field.is_scalar()); + fields.push_back(field.scalar()); + } + ARROW_ASSIGN_OR_RAISE( + auto scalar, StructScalar::Make(std::move(fields), std::move(field_names))); + return Datum(std::move(scalar)); + } + + // case st::Expression::Literal::kNamedStruct: + + case st::Expression::Literal::kList: { + const auto& list = lit.list(); + + // FIXME + // No way to determine list value type for empty list literals + DCHECK_NE(list.values_size(), 0); + + ScalarVector values(list.values_size()); + for (size_t i = 0; i < values.size(); ++i) { + ARROW_ASSIGN_OR_RAISE(auto value, FromProto(list.values(i))); + DCHECK(value.is_scalar()); + values.push_back(value.scalar()); + } + + ARROW_ASSIGN_OR_RAISE(auto builder, MakeBuilder(values[0]->type)); + RETURN_NOT_OK(builder->AppendScalars(values)); + ARROW_ASSIGN_OR_RAISE(auto arr, builder->Finish()); + return Datum(std::make_shared(std::move(arr))); + } + + case st::Expression::Literal::kMap: { + const auto& map = lit.map(); + + // FIXME + // No way to determine list value type for empty list literals + DCHECK_NE(map.key_values_size(), 0); + + ScalarVector keys(map.key_values_size()), values(map.key_values_size()); + for (size_t i = 0; i < values.size(); ++i) { + const auto& kv = map.key_values(i); + + static const std::array kMissing = {"key and value", "value", + "key", nullptr}; + if (auto missing = kMissing[kv.has_key() + kv.has_value() * 2]) { + return Status::Invalid("While converting to MapScalar encountered missing ", + missing, " in ", map.DebugString()); + } + ARROW_ASSIGN_OR_RAISE(auto key, FromProto(kv.key())); + ARROW_ASSIGN_OR_RAISE(auto value, FromProto(kv.value())); + + DCHECK(key.is_scalar()); + DCHECK(value.is_scalar()); + + keys.push_back(key.scalar()); + values.push_back(value.scalar()); + } + + ARROW_ASSIGN_OR_RAISE(auto key_builder, MakeBuilder(keys[0]->type)); + ARROW_ASSIGN_OR_RAISE(auto value_builder, MakeBuilder(keys[0]->type)); + RETURN_NOT_OK(key_builder->AppendScalars(keys)); + RETURN_NOT_OK(value_builder->AppendScalars(values)); + ARROW_ASSIGN_OR_RAISE(auto key_arr, key_builder->Finish()); + ARROW_ASSIGN_OR_RAISE(auto value_arr, value_builder->Finish()); + ARROW_ASSIGN_OR_RAISE( + auto kv_arr, + StructArray::Make(ArrayVector{std::move(key_arr), std::move(value_arr)}, + std::vector{"key", "value"})); + return Datum(std::make_shared(std::move(kv_arr))); + } + + case st::Expression::Literal::kNull: { + ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(lit.null())); + if (!type_nullable.second) { + return Status::Invalid("Null literal ", lit.DebugString(), + " is of non-nullable type"); + } + + return Datum(MakeNullScalar(std::move(type_nullable.first))); + } + + default: + break; + } + + return Status::NotImplemented("conversion to arrow::Datum from ", lit.DebugString()); +} + +namespace { +struct ToProtoImpl { + Status Visit(const NullScalar& s) { return NotImplemented(s); } + + using Lit = st::Expression::Literal; + + template + Status Primitive(void (st::Expression::Literal::*set)(Arg), + const PrimitiveScalar& primitive_scalar) { + (type_->*set)(static_cast(primitive_scalar.value)); + return Status::OK(); + } + + template + Status FromBuffer(void (st::Expression::Literal::*set)(std::string&&), + const ScalarWithBufferValue& scalar_with_buffer) { + (type_->*set)(util::string_view{*scalar_with_buffer.value}.to_string()); + return Status::OK(); + } + + Status Visit(const BooleanScalar& s) { return Primitive(&Lit::set_boolean, s); } + + Status Visit(const Int8Scalar& s) { return Primitive(&Lit::set_i8, s); } + Status Visit(const Int16Scalar& s) { return Primitive(&Lit::set_i16, s); } + Status Visit(const Int32Scalar& s) { return Primitive(&Lit::set_i32, s); } + Status Visit(const Int64Scalar& s) { return Primitive(&Lit::set_i64, s); } + + Status Visit(const UInt8Scalar& s) { return NotImplemented(s); } + Status Visit(const UInt16Scalar& s) { return NotImplemented(s); } + Status Visit(const UInt32Scalar& s) { return NotImplemented(s); } + Status Visit(const UInt64Scalar& s) { return NotImplemented(s); } + + Status Visit(const HalfFloatScalar& s) { return NotImplemented(s); } + Status Visit(const FloatScalar& s) { return Primitive(&Lit::set_fp32, s); } + Status Visit(const DoubleScalar& s) { return Primitive(&Lit::set_fp64, s); } + + Status Visit(const StringScalar& s) { return FromBuffer(&Lit::set_string, s); } + Status Visit(const BinaryScalar& s) { return FromBuffer(&Lit::set_binary, s); } + + Status Visit(const FixedSizeBinaryScalar& s) { + return FromBuffer(&Lit::set_fixed_binary, s); + } + + Status Visit(const Date32Scalar& s) { return Primitive(&Lit::set_date, s); } + Status Visit(const Date64Scalar& s) { return NotImplemented(s); } + + Status Visit(const TimestampScalar& s) { + const auto& t = internal::checked_cast(*s.type); + + if (t.unit() != TimeUnit::MICRO) return NotImplemented(s); + + if (t.timezone() == "") return Primitive(&Lit::set_timestamp, s); + + if (t.timezone() == TimestampTzTimezoneString()) { + return Primitive(&Lit::set_timestamp_tz, s); + } + + return NotImplemented(s); + } + + Status Visit(const Time32Scalar& s) { return NotImplemented(s); } + Status Visit(const Time64Scalar& s) { + if (internal::checked_cast(*s.type).unit() != TimeUnit::MICRO) { + return NotImplemented(s); + } + return Primitive(&Lit::set_time, s); + } + + Status Visit(const MonthIntervalScalar& s) { return NotImplemented(s); } + Status Visit(const DayTimeIntervalScalar& s) { return NotImplemented(s); } + + Status Visit(const Decimal128Scalar& s) { return NotImplemented(s); } + Status Visit(const Decimal256Scalar& s) { return NotImplemented(s); } + + Status Visit(const ListScalar& s) { + type_->set_allocated_list(new Lit::List()); + + auto values = type_->mutable_list()->mutable_values(); + values->Reserve(static_cast(s.value->length())); + + for (int64_t i = 0; i < s.value->length(); ++i) { + ARROW_ASSIGN_OR_RAISE(auto scalar, s.value->GetScalar(i)); + ARROW_ASSIGN_OR_RAISE(auto lit, ToProto(Datum(std::move(scalar)))); + values->AddAllocated(lit.release()); + } + return Status::OK(); + } + + Status Visit(const StructScalar& s) { + type_->set_allocated_struct_(new Lit::Struct()); + + auto fields = type_->mutable_struct_()->mutable_fields(); + fields->Reserve(static_cast(s.value.size())); + + for (Datum field : s.value) { + ARROW_ASSIGN_OR_RAISE(auto lit, ToProto(field)); + fields->AddAllocated(lit.release()); + } + return Status::OK(); + } + + Status Visit(const SparseUnionScalar& s) { return NotImplemented(s); } + Status Visit(const DenseUnionScalar& s) { return NotImplemented(s); } + Status Visit(const DictionaryScalar& s) { return NotImplemented(s); } + + Status Visit(const MapScalar& s) { + type_->set_allocated_map(new Lit::Map()); + + const auto& kv_arr = internal::checked_cast(*s.value); + + auto key_values = type_->mutable_map()->mutable_key_values(); + key_values->Reserve(static_cast(kv_arr.length())); + + for (int64_t i = 0; i < s.value->length(); ++i) { + auto kv = internal::make_unique(); + + ARROW_ASSIGN_OR_RAISE(Datum key_scalar, kv_arr.field(0)->GetScalar(i)); + ARROW_ASSIGN_OR_RAISE(auto key, ToProto(key_scalar)); + kv->set_allocated_key(key.release()); + + ARROW_ASSIGN_OR_RAISE(Datum value_scalar, kv_arr.field(1)->GetScalar(i)); + ARROW_ASSIGN_OR_RAISE(auto value, ToProto(value_scalar)); + kv->set_allocated_value(value.release()); + + key_values->AddAllocated(kv.release()); + } + return Status::OK(); + } + + Status Visit(const ExtensionScalar& s) { + if (UnwrapUuid(*s.type)) { + return FromBuffer(&Lit::set_uuid, + internal::checked_cast(*s.value)); + } + + if (UnwrapFixedChar(*s.type)) { + return FromBuffer(&Lit::set_uuid, + internal::checked_cast(*s.value)); + } + + if (UnwrapVarChar(*s.type)) { + return FromBuffer(&Lit::set_uuid, + internal::checked_cast(*s.value)); + } + + return NotImplemented(s); + } + + Status Visit(const FixedSizeListScalar& s) { return NotImplemented(s); } + Status Visit(const DurationScalar& s) { return NotImplemented(s); } + Status Visit(const LargeStringScalar& s) { return NotImplemented(s); } + Status Visit(const LargeBinaryScalar& s) { return NotImplemented(s); } + Status Visit(const LargeListScalar& s) { return NotImplemented(s); } + Status Visit(const MonthDayNanoIntervalScalar& s) { return NotImplemented(s); } + + Status NotImplemented(const Scalar& s) { + return Status::NotImplemented("conversion to substrait::Expression::Literal from ", + s.ToString()); + } + + Status operator()(const Scalar& scalar) { return VisitScalarInline(scalar, this); } + + st::Expression::Literal* type_; +}; +} // namespace + +Result> ToProto(const Datum& datum) { + if (!datum.is_scalar()) { + return Status::NotImplemented("representing ", datum.ToString(), + " as a substrait::Expression::Literal"); + } + + auto out = internal::make_unique(); + + if (datum.scalar()->is_valid) { + RETURN_NOT_OK((ToProtoImpl{out.get()})(*datum.scalar())); + } else { + ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*datum.type())); + out->set_allocated_null(type.release()); + } + + return std::move(out); +} + +Result> ToProto(const compute::Expression& expr) { + if (auto datum = expr.literal()) { + ARROW_ASSIGN_OR_RAISE(auto literal, ToProto(*datum)); + auto out = internal::make_unique(); + out->set_allocated_literal(literal.release()); + return std::move(out); + } + + return Status::NotImplemented("conversion to substrait::Expression from ", + expr.ToString()); +} + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/expression_internal.h b/cpp/src/arrow/engine/substrait/expression_internal.h new file mode 100644 index 00000000000..6fef22f45e6 --- /dev/null +++ b/cpp/src/arrow/engine/substrait/expression_internal.h @@ -0,0 +1,48 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// This API is EXPERIMENTAL. + +#pragma once + +#include + +#include "arrow/compute/type_fwd.h" +#include "arrow/engine/visibility.h" +#include "arrow/type_fwd.h" + +#include "generated/substrait/expression.pb.h" // IWYU pragma: export + +namespace st = io::substrait; + +namespace arrow { +namespace engine { + +ARROW_ENGINE_EXPORT +Result FromProto(const st::Expression&); + +ARROW_ENGINE_EXPORT +Result> ToProto(const compute::Expression&); + +ARROW_ENGINE_EXPORT +Result FromProto(const st::Expression::Literal&); + +ARROW_ENGINE_EXPORT +Result> ToProto(const Datum&); + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index 94838d9770e..34ffbeaa222 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -30,6 +30,10 @@ namespace arrow { namespace engine { +// uuid, fixed_char, and varchar are provided as first-class types by substrait +// but do not appear in the arrow type system. The following arrow::ExtensionTypes +// are provided to wrap them. + ARROW_ENGINE_EXPORT std::shared_ptr uuid(); diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc index 4d6055b8bf5..081f55a9d50 100644 --- a/cpp/src/arrow/engine/substrait/serde.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -17,6 +17,7 @@ #include "arrow/engine/substrait/serde.h" +#include "arrow/engine/substrait/expression_internal.h" #include "arrow/engine/substrait/type_internal.h" #include "arrow/util/string_view.h" #include "google/protobuf/io/zero_copy_stream_impl_lite.h" @@ -82,5 +83,16 @@ Result> SerializeType(const DataType& type) { return Buffer::FromString(std::move(serialized)); } +Result DeserializeExpression(const Buffer& buf) { + ARROW_ASSIGN_OR_RAISE(auto expr, ParseFromBuffer(buf)); + return FromProto(expr); +} + +Result> SerializeExpression(const compute::Expression& expr) { + ARROW_ASSIGN_OR_RAISE(auto st_expr, ToProto(expr)); + std::string serialized = st_expr->SerializeAsString(); + return Buffer::FromString(std::move(serialized)); +} + } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 7c1c2257ae8..5a9fbcbeff0 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -19,31 +19,108 @@ #include +#include "arrow/engine/substrait/extension_types.h" #include "arrow/testing/gtest_util.h" +#include "arrow/testing/matchers.h" namespace arrow { namespace engine { -TEST(SubstraitConsumption, BasicTypeRoundTrip) { +TEST(Substrait, BasicTypeRoundTrip) { for (auto type : { boolean(), + int8(), int16(), int32(), int64(), + float32(), float64(), + + date32(), + timestamp(TimeUnit::MICRO), + timestamp(TimeUnit::MICRO, "UTC"), + time64(TimeUnit::MICRO), + + decimal128(27, 5), + struct_({ field("", int64()), field("", list(utf8())), }), + + uuid(), + fixed_char(32), + varchar(1024), }) { + ARROW_SCOPED_TRACE(type->ToString()); ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type)); ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized)); ASSERT_EQ(*roundtripped, *type); } } +TEST(Substrait, UnsupportedTypes) { + for (auto type : { + uint8(), + uint16(), + uint32(), + uint64(), + + float16(), + + date64(), + timestamp(TimeUnit::SECOND), + timestamp(TimeUnit::NANO), + timestamp(TimeUnit::MICRO, "New York"), + time32(TimeUnit::SECOND), + time32(TimeUnit::MILLI), + time64(TimeUnit::NANO), + month_interval(), + day_time_interval(), + + decimal256(76, 67), + + sparse_union({field("i8", int8()), field("f32", float32())}), + dense_union({field("i8", int8()), field("f32", float32())}), + dictionary(int32(), utf8()), + + fixed_size_list(float16(), 3), + + duration(TimeUnit::MICRO), + + large_utf8(), + large_binary(), + large_list(utf8()), + + month_day_nano_interval(), + }) { + ARROW_SCOPED_TRACE(type->ToString()); + ASSERT_THAT(SerializeType(*type), Raises(StatusCode::NotImplemented)); + } +} + +TEST(Substrait, BasicLiteralRoundTrip) { + for (Datum datum : { + Datum(true), + + Datum(int8_t(34)), + Datum(int16_t(34)), + Datum(int32_t(34)), + Datum(int64_t(34)), + + Datum(3.5F), + Datum(7.125), + }) { + ARROW_SCOPED_TRACE(datum.scalar()->ToString()); + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(compute::literal(datum))); + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized)); + ASSERT_TRUE(roundtripped.literal()); + ASSERT_THAT(*roundtripped.literal(), DataEq(datum)); + } +} + } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 49b8d5503ca..fec01705782 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -31,7 +31,6 @@ namespace arrow { namespace engine { - namespace { template @@ -80,51 +79,59 @@ Result FieldsFromProto( return fields; } -static const std::string kTimestampTzTimezoneString = "UTC"; - } // namespace Result, bool>> FromProto(const st::Type& type) { switch (type.kind_case()) { - case st::Type::KindCase::kBool: + case st::Type::kBool: return FromProtoImpl(type.bool_()); - case st::Type::KindCase::kI8: + case st::Type::kI8: return FromProtoImpl(type.i8()); - case st::Type::KindCase::kI16: + case st::Type::kI16: return FromProtoImpl(type.i16()); - case st::Type::KindCase::kI32: + case st::Type::kI32: return FromProtoImpl(type.i32()); - case st::Type::KindCase::kI64: + case st::Type::kI64: return FromProtoImpl(type.i64()); - case st::Type::KindCase::kFp32: + case st::Type::kFp32: return FromProtoImpl(type.fp32()); - case st::Type::KindCase::kFp64: + case st::Type::kFp64: return FromProtoImpl(type.fp64()); - case st::Type::KindCase::kString: + case st::Type::kString: return FromProtoImpl(type.string()); - case st::Type::KindCase::kBinary: + case st::Type::kBinary: return FromProtoImpl(type.binary()); - case st::Type::KindCase::kTimestamp: + case st::Type::kTimestamp: return FromProtoImpl(type.timestamp(), TimeUnit::MICRO); - case st::Type::KindCase::kTimestampTz: + case st::Type::kTimestampTz: return FromProtoImpl(type.timestamp_tz(), TimeUnit::MICRO, - kTimestampTzTimezoneString); - case st::Type::KindCase::kDate: - return FromProtoImpl(type.date()); - case st::Type::KindCase::kTime: + TimestampTzTimezoneString()); + case st::Type::kDate: + // FIXME + // Substrait uses uint32_t to store dates, and further restricts the allowed + // range of dates to [1000-01-01..9999-12-31]. Does this mean the value should + // be interpreted as an offset from 1000-01-01 instead of the epoch? Or should + // the value be signed instead? + // Furthermore, simple_logical_types.md states that the equivalent arrow type + // is Date64 (which measures milliseconds rather than days). Is that incorrect? + return FromProtoImpl(type.date()); + + case st::Type::kTime: return FromProtoImpl(type.time(), TimeUnit::MICRO); - case st::Type::KindCase::kIntervalYear: + case st::Type::kIntervalYear: + // FIXME // None of MonthIntervalType, DayTimeIntervalType, MonthDayNanoIntervalType // corresponds; none has a year field. Lossy conversion to MonthIntervalType // would be possible... break; - case st::Type::KindCase::kIntervalDay: + case st::Type::kIntervalDay: + // FIXME // Documentation is inconsistent; the precision of the sub-day interval is // described as microsecond in simple_logical_types.md but IntervalDayToSecond has // the field `int32 seconds`. At microsecond precision it's minimally necessary to @@ -139,27 +146,27 @@ Result, bool>> FromProto(const st::Type& typ // 1000 will always be 0). break; - case st::Type::KindCase::kUuid: + case st::Type::kUuid: return FromProtoImpl(type.uuid(), uuid); - case st::Type::KindCase::kFixedChar: + case st::Type::kFixedChar: // need extension type to mark utf-8 constraint return FromProtoImpl(type.fixed_char(), fixed_char, type.fixed_char().length()); - case st::Type::KindCase::kVarchar: + case st::Type::kVarchar: // need extension type to hold type.varchar().length() constraint return FromProtoImpl(type.varchar(), varchar, type.varchar().length()); - case st::Type::KindCase::kFixedBinary: + case st::Type::kFixedBinary: return FromProtoImpl(type.fixed_binary(), type.fixed_binary().length()); - case st::Type::KindCase::kDecimal: { + case st::Type::kDecimal: { const auto& decimal = type.decimal(); return FromProtoImpl(decimal, decimal.precision(), decimal.scale()); } - case st::Type::KindCase::kStruct: { + case st::Type::kStruct: { const auto& struct_ = type.struct_(); ARROW_ASSIGN_OR_RAISE(auto fields, @@ -170,7 +177,7 @@ Result, bool>> FromProto(const st::Type& typ // NamedStruct is not currently enumerated in KindCase. This block of dead code is // here just to verify that it can be compiled. - // case st::Type::KindCase::kNamedStruct: { + // case st::Type::kNamedStruct: { if (false) { // const st::Type::NamedStruct& named_struct = type.named_struct(); st::Type::NamedStruct named_struct; @@ -197,7 +204,7 @@ Result, bool>> FromProto(const st::Type& typ return std::make_pair(arrow::struct_(std::move(fields)), IsNullable(struct_)); } - case st::Type::KindCase::kList: { + case st::Type::kList: { const auto& list = type.list(); if (!list.has_type()) { @@ -211,7 +218,7 @@ Result, bool>> FromProto(const st::Type& typ list, field("item", std::move(type_nullable.first), type_nullable.second)); } - case st::Type::KindCase::kMap: { + case st::Type::kMap: { const auto& map = type.map(); static const std::array kMissing = {"key and value", "value", "key", @@ -243,6 +250,7 @@ Result, bool>> FromProto(const st::Type& typ type.DebugString()); } +namespace { struct ToProtoImpl { Status Visit(const NullType& t) { return NotImplemented(t); } @@ -270,8 +278,8 @@ struct ToProtoImpl { return Status::OK(); } - Status Visit(const Date32Type& t) { return NotImplemented(t); } - Status Visit(const Date64Type& t) { return SetWith(&st::Type::set_allocated_date); } + Status Visit(const Date32Type& t) { return SetWith(&st::Type::set_allocated_date); } + Status Visit(const Date64Type& t) { return NotImplemented(t); } Status Visit(const TimestampType& t) { if (t.unit() != TimeUnit::MICRO) return NotImplemented(t); @@ -279,7 +287,7 @@ struct ToProtoImpl { if (t.timezone() == "") { return SetWith(&st::Type::set_allocated_timestamp); } - if (t.timezone() == kTimestampTzTimezoneString) { + if (t.timezone() == TimestampTzTimezoneString()) { return SetWith(&st::Type::set_allocated_timestamp_tz); } @@ -340,8 +348,6 @@ struct ToProtoImpl { } Status Visit(const ExtensionType& t) { - auto ext_name = t.extension_name(); - if (UnwrapUuid(t)) { return SetWith(&st::Type::set_allocated_uuid); } @@ -391,6 +397,7 @@ struct ToProtoImpl { st::Type* type_; bool nullable_; }; +} // namespace Result> ToProto(const DataType& type, bool nullable) { auto out = internal::make_unique(); diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h index d15f5b15b51..67b370b213a 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -37,5 +37,7 @@ Result, bool>> FromProto(const st::Type&); ARROW_ENGINE_EXPORT Result> ToProto(const DataType&, bool nullable = true); +inline std::string TimestampTzTimezoneString() { return "UTC"; } + } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h index 9df3e3c74e3..a4cda58b87b 100644 --- a/cpp/src/arrow/scalar.h +++ b/cpp/src/arrow/scalar.h @@ -345,8 +345,8 @@ struct ARROW_EXPORT TimestampScalar : public TemporalScalar { using TemporalScalar::TemporalScalar; TimestampScalar(typename TemporalScalar::ValueType value, - TimeUnit::type unit) - : TimestampScalar(std::move(value), timestamp(unit)) {} + TimeUnit::type unit, std::string tz = "") + : TimestampScalar(std::move(value), timestamp(unit, std::move(tz))) {} }; template diff --git a/cpp/src/arrow/testing/matchers.h b/cpp/src/arrow/testing/matchers.h index ddfe60f1740..2bd6864b1d3 100644 --- a/cpp/src/arrow/testing/matchers.h +++ b/cpp/src/arrow/testing/matchers.h @@ -303,7 +303,7 @@ class DataEqMatcher { const bool match = boxed == expected_; *listener << "whose value "; - PrintTo(boxed, listener->stream()); + if (listener->IsInterested()) PrintTo(boxed, listener->stream()); *listener << (match ? " matches" : " doesn't match"); return match; } From 1cf679bd33dce739209253826f46911690069205 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Tue, 16 Nov 2021 11:33:00 -0500 Subject: [PATCH 005/113] don't rely on Datum::type in DataEq matcher --- cpp/src/arrow/testing/matchers.h | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/cpp/src/arrow/testing/matchers.h b/cpp/src/arrow/testing/matchers.h index 2bd6864b1d3..998e45e3078 100644 --- a/cpp/src/arrow/testing/matchers.h +++ b/cpp/src/arrow/testing/matchers.h @@ -295,10 +295,18 @@ class DataEqMatcher { return false; } - if (*boxed.type() != *expected_.type()) { - *listener << "whose DataType " << boxed.type()->ToString() << " doesn't match " - << expected_.type()->ToString(); - return false; + if (const auto& boxed_type = boxed.type()) { + if (*boxed_type != *expected_.type()) { + *listener << "whose DataType " << boxed_type->ToString() << " doesn't match " + << expected_.type()->ToString(); + return false; + } + } else if (const auto& boxed_schema = boxed.schema()) { + if (*boxed_schema != *expected_.schema()) { + *listener << "whose Schema " << boxed_schema->ToString() << " doesn't match " + << expected_.schema()->ToString(); + return false; + } } const bool match = boxed == expected_; From 6dce17bc3d238aa775dff91bd719bff70df928c2 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Thu, 18 Nov 2021 15:18:40 -0500 Subject: [PATCH 006/113] add substrait_gen_verify, allow configurable substrait repo and tag --- cpp/cmake_modules/DefineOptions.cmake | 6 ++++++ cpp/src/arrow/engine/CMakeLists.txt | 17 +++++++++++++++-- 2 files changed, 21 insertions(+), 2 deletions(-) diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake index a74e53b6e0f..0b731c5348d 100644 --- a/cpp/cmake_modules/DefineOptions.cmake +++ b/cpp/cmake_modules/DefineOptions.cmake @@ -480,6 +480,12 @@ advised that if this is enabled 'install' will fail silently on components;\ that have not been built" OFF) + set(ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT + "https://github.com/substrait-io/substrait 9e84da55393a24953ed9f9869fa423f86f4860f7") + define_option_string(ARROW_SUBSTRAIT_REPO_AND_TAG + "Custom 'repository_url tag' for generating substrait accessors" + "${ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT}") + option(ARROW_BUILD_CONFIG_SUMMARY_JSON "Summarize build configuration in a JSON file" ON) endif() diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index c9d7251bd60..553f13ce701 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -43,9 +43,17 @@ set(SUBSTRAIT_PROTOS expression type type_expressions) +string(FIND "${ARROW_SUBSTRAIT_REPO_AND_TAG}" " " TAG_START) +if(TAG_START EQUAL -1) + message(FATAL_ERROR "Cannot parse ARROW_SUBSTRAIT_REPO_AND_TAG='${ARROW_SUBSTRAIT_REPO_AND_TAG}'") +endif() +string(SUBSTRING "${ARROW_SUBSTRAIT_REPO_AND_TAG}" 0 ${TAG_START} ARROW_SUBSTRAIT_REPO) +string(SUBSTRING "${ARROW_SUBSTRAIT_REPO_AND_TAG}" ${TAG_START} -1 ARROW_SUBSTRAIT_TAG) +string(STRIP "${ARROW_SUBSTRAIT_TAG}" ARROW_SUBSTRAIT_TAG) + externalproject_add(substrait_ep - GIT_REPOSITORY "https://github.com/substrait-io/substrait" - GIT_TAG "9e84da55393a24953ed9f9869fa423f86f4860f7" + GIT_REPOSITORY "${ARROW_SUBSTRAIT_REPO}" + GIT_TAG "${ARROW_SUBSTRAIT_TAG}" SOURCE_DIR "${SUBSTRAIT_DIR}" CONFIGURE_COMMAND "" BUILD_COMMAND "" @@ -69,6 +77,11 @@ endforeach() add_custom_target(substrait_gen ALL DEPENDS ${SUBSTRAIT_PROTO_GEN_ALL}) +find_package(Git) +add_custom_target(substrait_gen_verify + COMMAND ${GIT_EXECUTABLE} diff --quiet ${SUBSTRAIT_GEN_DIR} + DEPENDS substrait_gen) + add_arrow_lib(arrow_engine CMAKE_PACKAGE_NAME ArrowEngine From 53c7c7dc44a025cd3ed7afba4df3e6ad0a885045 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 19 Nov 2021 11:07:46 -0500 Subject: [PATCH 007/113] Expose NamedStruct<=>Schema serde --- cpp/src/arrow/engine/substrait/serde.cc | 11 +++ cpp/src/arrow/engine/substrait/serde.h | 6 ++ .../arrow/engine/substrait/type_internal.cc | 81 ++++++++++++------- .../arrow/engine/substrait/type_internal.h | 6 ++ 4 files changed, 76 insertions(+), 28 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc index 081f55a9d50..2c4304c4e79 100644 --- a/cpp/src/arrow/engine/substrait/serde.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -71,6 +71,17 @@ Result> ConvertPlan(const Buffer& buf) { return decls; } +Result> DeserializeSchema(const Buffer& buf) { + ARROW_ASSIGN_OR_RAISE(auto named_struct, ParseFromBuffer(buf)); + return FromProto(named_struct); +} + +Result> SerializeSchema(const Schema& schema) { + ARROW_ASSIGN_OR_RAISE(auto named_struct, ToProto(schema)); + std::string serialized = named_struct->SerializeAsString(); + return Buffer::FromString(std::move(serialized)); +} + Result> DeserializeType(const Buffer& buf) { ARROW_ASSIGN_OR_RAISE(auto type, ParseFromBuffer(buf)); ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(type)); diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index 495567b8533..4fb4b8d5438 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -38,6 +38,12 @@ Result> DeserializeType(const Buffer&); ARROW_ENGINE_EXPORT Result> SerializeType(const DataType&); +ARROW_ENGINE_EXPORT +Result> DeserializeSchema(const Buffer&); + +ARROW_ENGINE_EXPORT +Result> SerializeSchema(const Schema&); + ARROW_ENGINE_EXPORT Result DeserializeExpression(const Buffer&); diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index fec01705782..bc95a4edb88 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -175,34 +175,7 @@ Result, bool>> FromProto(const st::Type& typ return FromProtoImpl(struct_, std::move(fields)); } - // NamedStruct is not currently enumerated in KindCase. This block of dead code is - // here just to verify that it can be compiled. - // case st::Type::kNamedStruct: { - if (false) { - // const st::Type::NamedStruct& named_struct = type.named_struct(); - st::Type::NamedStruct named_struct; - - if (named_struct.has_struct_()) { - return Status::Invalid( - "While converting ", type.DebugString(), - " no anonymous struct type was provided to which to names " - "could be attached."); - } - const auto& struct_ = named_struct.struct_(); - RETURN_NOT_OK(CheckVariation(struct_)); - - if (struct_.types_size() != named_struct.names_size()) { - return Status::Invalid("While converting ", type.DebugString(), " received ", - struct_.types_size(), " types but ", - named_struct.names_size(), " names."); - } - - ARROW_ASSIGN_OR_RAISE(auto fields, - FieldsFromProto(struct_.types_size(), struct_.types(), - &named_struct.names())); - - return std::make_pair(arrow::struct_(std::move(fields)), IsNullable(struct_)); - } + // NOTE: NamedStruct is not enumerated in KindCase. case st::Type::kList: { const auto& list = type.list(); @@ -250,6 +223,27 @@ Result, bool>> FromProto(const st::Type& typ type.DebugString()); } +Result> FromProto(const st::Type::NamedStruct& named_struct) { + if (named_struct.has_struct_()) { + return Status::Invalid("While converting ", named_struct.DebugString(), + " no anonymous struct type was provided to which to names " + "could be attached."); + } + const auto& struct_ = named_struct.struct_(); + RETURN_NOT_OK(CheckVariation(struct_)); + + if (struct_.types_size() != named_struct.names_size()) { + return Status::Invalid("While converting ", named_struct.DebugString(), " received ", + struct_.types_size(), " types but ", named_struct.names_size(), + " names."); + } + + ARROW_ASSIGN_OR_RAISE( + auto fields, + FieldsFromProto(struct_.types_size(), struct_.types(), &named_struct.names())); + return schema(std::move(fields)); +} + namespace { struct ToProtoImpl { Status Visit(const NullType& t) { return NotImplemented(t); } @@ -324,6 +318,12 @@ struct ToProtoImpl { types->Reserve(t.num_fields()); for (const auto& field : t.fields()) { + if (field->name() != "") { + return Status::Invalid("substrait::Type::Struct does not support named fields"); + } + if (field->metadata() != nullptr) { + return Status::Invalid("substrait::Type::Struct does not support field metadata"); + } ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*field->type(), field->nullable())); types->AddAllocated(type.release()); } @@ -405,5 +405,30 @@ Result> ToProto(const DataType& type, bool nullable) { return std::move(out); } +Result> ToProto(const Schema& schema) { + auto named_struct = internal::make_unique(); + auto names = named_struct->mutable_names(); + names->Reserve(schema.num_fields()); + + auto struct_ = internal::make_unique(); + auto types = struct_->mutable_types(); + types->Reserve(schema.num_fields()); + + for (const auto& field : schema.fields()) { + *names->Add() = field->name(); + + if (field->metadata() != nullptr) { + return Status::Invalid( + "substrait::Type::NamedStruct does not support field metadata"); + } + + ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*field->type(), field->nullable())); + types->AddAllocated(type.release()); + } + + named_struct->set_allocated_struct_(struct_.release()); + return std::move(named_struct); +} + } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h index 67b370b213a..167ff1e0601 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -37,6 +37,12 @@ Result, bool>> FromProto(const st::Type&); ARROW_ENGINE_EXPORT Result> ToProto(const DataType&, bool nullable = true); +ARROW_ENGINE_EXPORT +Result> FromProto(const st::Type::NamedStruct&); + +ARROW_ENGINE_EXPORT +Result> ToProto(const Schema&); + inline std::string TimestampTzTimezoneString() { return "UTC"; } } // namespace engine From cd919f36977d089dadc206002f23201d48dd6b4f Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Mon, 22 Nov 2021 12:12:53 -0500 Subject: [PATCH 008/113] add if_else <-> IfThen conversion --- cpp/src/arrow/engine/CMakeLists.txt | 28 ++-- .../engine/substrait/expression_internal.cc | 153 +++++++++++++++++- .../engine/substrait/expression_internal.h | 3 + cpp/src/arrow/engine/substrait/serde_test.cc | 95 ++++++++++- 4 files changed, 262 insertions(+), 17 deletions(-) diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 553f13ce701..33dd6e56ca1 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -61,24 +61,28 @@ externalproject_add(substrait_ep set(SUBSTRAIT_PROTO_GEN_ALL) foreach(SUBSTRAIT_PROTO ${SUBSTRAIT_PROTOS}) - set(SUBSTRAIT_PROTO_GEN "${SUBSTRAIT_GEN_DIR}/${SUBSTRAIT_PROTO}.pb.cc") - - set_source_files_properties(${SUBSTRAIT_PROTO_GEN} PROPERTIES GENERATED TRUE) - add_custom_command(OUTPUT ${SUBSTRAIT_PROTO_GEN} - COMMAND ${ARROW_PROTOBUF_PROTOC} - "-I${SUBSTRAIT_DIR}/binary" - "--cpp_out=${SUBSTRAIT_GEN_DIR}" - "${SUBSTRAIT_PROTO}.proto" - DEPENDS ${PROTO_DEPENDS} substrait_ep) - - list(APPEND ARROW_ENGINE_SRCS ${SUBSTRAIT_PROTO_GEN}) - list(APPEND SUBSTRAIT_PROTO_GEN_ALL ${SUBSTRAIT_PROTO_GEN}) + set(SUBSTRAIT_PROTO_GEN "${SUBSTRAIT_GEN_DIR}/${SUBSTRAIT_PROTO}.pb") + + foreach(EXT h cc) + set_source_files_properties("${SUBSTRAIT_PROTO_GEN}.${EXT}" PROPERTIES GENERATED TRUE) + add_custom_command(OUTPUT "${SUBSTRAIT_PROTO_GEN}.${EXT}" + COMMAND ${ARROW_PROTOBUF_PROTOC} + "-I${SUBSTRAIT_DIR}/binary" + "--cpp_out=${SUBSTRAIT_GEN_DIR}" + "${SUBSTRAIT_PROTO}.proto" + DEPENDS ${PROTO_DEPENDS} substrait_ep) + list(APPEND SUBSTRAIT_PROTO_GEN_ALL "${SUBSTRAIT_PROTO_GEN}.${EXT}") + endforeach() + + list(APPEND ARROW_ENGINE_SRCS "${SUBSTRAIT_PROTO_GEN}.cc") endforeach() add_custom_target(substrait_gen ALL DEPENDS ${SUBSTRAIT_PROTO_GEN_ALL}) find_package(Git) add_custom_target(substrait_gen_verify + COMMENT "Verifying that generated substrait accessors are consistent with \ + ARROW_SUBSTRAIT_REPO_AND_TAG='${ARROW_SUBSTRAIT_REPO_AND_TAG}'" COMMAND ${GIT_EXECUTABLE} diff --quiet ${SUBSTRAIT_GEN_DIR} DEPENDS substrait_gen) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 472b36ace49..bdf09a1196c 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -22,7 +22,9 @@ #include #include "arrow/builder.h" +#include "arrow/compute/cast.h" #include "arrow/compute/exec/expression.h" +#include "arrow/compute/exec/expression_internal.h" #include "arrow/engine/substrait/extension_types.h" #include "arrow/engine/substrait/type_internal.h" #include "arrow/engine/visibility.h" @@ -54,6 +56,21 @@ Result FromProto(const st::Expression& expr) { return compute::literal(std::move(datum)); } + case st::Expression::kSelection: + if (!expr.selection().has_direct_reference()) break; + return FromProto(expr.selection().direct_reference()); + + case st::Expression::kIfThen: { + const auto& if_then = expr.if_then(); + if (!if_then.has_else_()) break; + if (if_then.ifs_size() != 1) break; + ARROW_ASSIGN_OR_RAISE(auto if_, FromProto(if_then.ifs(0).if_())); + ARROW_ASSIGN_OR_RAISE(auto then, FromProto(if_then.ifs(0).then())); + ARROW_ASSIGN_OR_RAISE(auto else_, FromProto(if_then.else_())); + return compute::call("if_else", + {std::move(if_), std::move(then), std::move(else_)}); + } + default: break; } @@ -62,6 +79,39 @@ Result FromProto(const st::Expression& expr) { expr.DebugString()); } +Result FromProto(const st::ReferenceSegment& ref) { + switch (ref.reference_type_case()) { + case st::ReferenceSegment::kStructField: { + FieldRef out(ref.struct_field().field()); + + if (ref.struct_field().has_child()) { + ARROW_ASSIGN_OR_RAISE(auto child, FromProto(ref.struct_field().child())); + auto child_ref = child.field_ref(); + if (!child_ref) break; + out = FieldRef(std::move(out), *child_ref); + } + + return compute::field_ref(std::move(out)); + } + + case st::ReferenceSegment::kListElement: { + if (ref.list_element().has_child()) { + ARROW_ASSIGN_OR_RAISE(auto child, FromProto(ref.list_element().child())); + return compute::call( + "list_element", + {std::move(child), compute::literal(ref.list_element().offset())}); + } + break; + } + + default: + break; + } + + return Status::NotImplemented("conversion to arrow::compute::Expression from ", + ref.DebugString()); +} + Result FromProto(const st::Expression::Literal& lit) { switch (lit.literal_type_case()) { case st::Expression::Literal::kBoolean: @@ -148,8 +198,6 @@ Result FromProto(const st::Expression::Literal& lit) { return Datum(std::move(scalar)); } - // case st::Expression::Literal::kNamedStruct: - case st::Expression::Literal::kList: { const auto& list = lit.list(); @@ -412,6 +460,10 @@ Result> ToProto(const Datum& datum) { } Result> ToProto(const compute::Expression& expr) { + if (!expr.IsBound()) { + return Status::Invalid("ToProto requires a bound Expression"); + } + if (auto datum = expr.literal()) { ARROW_ASSIGN_OR_RAISE(auto literal, ToProto(*datum)); auto out = internal::make_unique(); @@ -419,6 +471,103 @@ Result> ToProto(const compute::Expression& expr) return std::move(out); } + if (auto param = expr.parameter()) { + DCHECK(!param->indices.empty()); + std::unique_ptr ref_segment; + + for (auto it = param->indices.rbegin(); it != param->indices.rend(); ++it) { + auto struct_field = internal::make_unique(); + + if (ref_segment) { + struct_field->set_allocated_child(ref_segment.release()); + } + struct_field->set_field(*it); + + ref_segment = internal::make_unique(); + ref_segment->set_allocated_struct_field(struct_field.release()); + } + + auto field_ref = internal::make_unique(); + field_ref->set_allocated_direct_reference(ref_segment.release()); + + auto out = internal::make_unique(); + out->set_allocated_selection(field_ref.release()); + return std::move(out); + } + + auto call = CallNotNull(expr); + + // convert all arguments first + std::vector> arguments(call->arguments.size()); + for (size_t i = 0; i < arguments.size(); ++i) { + ARROW_ASSIGN_OR_RAISE(arguments[i], ToProto(call->arguments[i])); + } + + if (call->function_name == "list_element") { + // catch the special case of calls convertible to a ListElement + if (arguments[0]->has_selection() && + arguments[0]->selection().has_direct_reference()) { + if (arguments[1]->has_literal() && arguments[1]->literal().has_i32()) { + auto list_element = internal::make_unique(); + + list_element->set_allocated_child( + arguments[0]->mutable_selection()->release_direct_reference()); + list_element->set_offset(arguments[1]->literal().i32()); + + auto ref_segment = internal::make_unique(); + ref_segment->set_allocated_list_element(list_element.release()); + + auto field_ref = internal::make_unique(); + field_ref->set_allocated_direct_reference(ref_segment.release()); + + auto out = std::move(arguments[0]); // reuse an emptied st::Expression + out->set_allocated_selection(field_ref.release()); + return std::move(out); + } + } + } + + if (call->function_name == "if_else") { + // catch the special case of calls convertible to IfThen + auto if_clause = internal::make_unique(); + if_clause->set_allocated_if_(arguments[0].release()); + if_clause->set_allocated_then(arguments[1].release()); + + auto if_then = internal::make_unique(); + if_then->mutable_ifs()->AddAllocated(if_clause.release()); + if_then->set_allocated_else_(arguments[2].release()); + + auto out = internal::make_unique(); + out->set_allocated_if_then(if_then.release()); + return std::move(out); + } + + // other expression types dive into extensions immediately + /* + if (call->function_name == "case_when") { + auto conditions = call->arguments[0].call(); + if (conditions && conditions->function_name == "make_struct") { + // catch the special case of calls convertible to SwitchExpression + auto switch_ = internal::make_unique(); + + for (auto& cond : conditions->arguments) { + auto if_value = + internal::make_unique(); + if_value->set_allocated_if_(arguments[0].release()); + if_value->set_allocated_then(arguments[1].release()); + + switch_->mutable_ifs()->AddAllocated(if_value.release()); + } + + switch_->set_allocated_else_(arguments[2].release()); + + auto out = std::move(arguments[0]); // reuse an emptied st::Expression + out->set_allocated_switch_expression(switch_.release()); + return std::move(out); + } + } + */ + return Status::NotImplemented("conversion to substrait::Expression from ", expr.ToString()); } diff --git a/cpp/src/arrow/engine/substrait/expression_internal.h b/cpp/src/arrow/engine/substrait/expression_internal.h index 6fef22f45e6..b8a9a366d4f 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.h +++ b/cpp/src/arrow/engine/substrait/expression_internal.h @@ -35,6 +35,9 @@ namespace engine { ARROW_ENGINE_EXPORT Result FromProto(const st::Expression&); +ARROW_ENGINE_EXPORT +Result FromProto(const st::ReferenceSegment&); + ARROW_ENGINE_EXPORT Result> ToProto(const compute::Expression&); diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 5a9fbcbeff0..5b8d2dac7e0 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -19,6 +19,7 @@ #include +#include "arrow/compute/exec/expression_internal.h" #include "arrow/engine/substrait/extension_types.h" #include "arrow/testing/gtest_util.h" #include "arrow/testing/matchers.h" @@ -26,6 +27,47 @@ namespace arrow { namespace engine { +const std::shared_ptr kBoringSchema = schema({ + field("bool", boolean()), + field("i8", int8()), + field("i32", int32()), + field("i32_req", int32(), /*nullable=*/false), + field("u32", uint32()), + field("i64", int64()), + field("f32", float32()), + field("f32_req", float32(), /*nullable=*/false), + field("f64", float64()), + field("date64", date64()), + field("str", utf8()), + field("struct_i32_str", struct_({ + field("i32", int32()), + field("str", utf8()), + })), + field("dict_str", dictionary(int32(), utf8())), + field("dict_i32", dictionary(int32(), int32())), + field("ts_ns", timestamp(TimeUnit::NANO)), +}); + +// map to an index-only field reference +inline FieldRef BoringRef(FieldRef ref) { + auto path = *ref.FindOne(*kBoringSchema); + return {std::move(path)}; +} + +inline compute::Expression UseBoringRefs(const compute::Expression& expr) { + if (expr.literal()) return expr; + + if (auto ref = expr.field_ref()) { + return compute::field_ref(*ref->FindOne(*kBoringSchema)); + } + + auto modified_call = *CallNotNull(expr); + for (auto& arg : modified_call.arguments) { + arg = UseBoringRefs(arg); + } + return compute::Expression{std::move(modified_call)}; +} + TEST(Substrait, BasicTypeRoundTrip) { for (auto type : { boolean(), @@ -57,7 +99,7 @@ TEST(Substrait, BasicTypeRoundTrip) { ARROW_SCOPED_TRACE(type->ToString()); ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type)); ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized)); - ASSERT_EQ(*roundtripped, *type); + EXPECT_EQ(*roundtripped, *type); } } @@ -97,7 +139,7 @@ TEST(Substrait, UnsupportedTypes) { month_day_nano_interval(), }) { ARROW_SCOPED_TRACE(type->ToString()); - ASSERT_THAT(SerializeType(*type), Raises(StatusCode::NotImplemented)); + EXPECT_THAT(SerializeType(*type), Raises(StatusCode::NotImplemented)); } } @@ -117,7 +159,54 @@ TEST(Substrait, BasicLiteralRoundTrip) { ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(compute::literal(datum))); ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized)); ASSERT_TRUE(roundtripped.literal()); - ASSERT_THAT(*roundtripped.literal(), DataEq(datum)); + EXPECT_THAT(*roundtripped.literal(), DataEq(datum)); + } +} + +TEST(Substrait, FieldRefRoundTrip) { + for (FieldRef ref : { + // by name + FieldRef("i32"), + FieldRef("ts_ns"), + FieldRef("struct_i32_str"), + + // by index + FieldRef(0), + FieldRef(1), + FieldRef(kBoringSchema->num_fields() - 1), + FieldRef(kBoringSchema->GetFieldIndex("struct_i32_str")), + + // nested + FieldRef("struct_i32_str", "i32"), + FieldRef(kBoringSchema->GetFieldIndex("struct_i32_str"), 1), + }) { + ARROW_SCOPED_TRACE(ref.ToString()); + ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized)); + ASSERT_TRUE(roundtripped.field_ref()); + + ASSERT_OK_AND_ASSIGN(auto expected, ref.FindOne(*kBoringSchema)); + ASSERT_OK_AND_ASSIGN(auto actual, roundtripped.field_ref()->FindOne(*kBoringSchema)); + EXPECT_EQ(actual.indices(), expected.indices()); + } +} + +TEST(Substrait, CallSpecialCaseRoundTrip) { + for (compute::Expression expr : { + compute::call("if_else", + { + compute::literal(true), + compute::field_ref({"struct_i32_str", 1}), + compute::field_ref("str"), + }), + }) { + ARROW_SCOPED_TRACE(expr.ToString()); + ASSERT_OK_AND_ASSIGN(expr, expr.Bind(*kBoringSchema)); + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized)); + ASSERT_OK_AND_ASSIGN(roundtripped, roundtripped.Bind(*kBoringSchema)); + EXPECT_EQ(UseBoringRefs(roundtripped), UseBoringRefs(expr)); } } From c079359c2a16ea7dcc2f13d9fb866da97feb6833 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Tue, 30 Nov 2021 17:30:11 -0500 Subject: [PATCH 009/113] rebase, catch up to changes in substrait --- cpp/cmake_modules/DefineOptions.cmake | 2 +- cpp/src/arrow/engine/CMakeLists.txt | 6 +- .../engine/substrait/expression_internal.cc | 247 +- .../engine/substrait/expression_internal.h | 3 - .../arrow/engine/substrait/extension_types.cc | 1 + .../arrow/engine/substrait/extension_types.h | 3 +- .../arrow/engine/substrait/type_internal.cc | 15 +- .../arrow/engine/substrait/type_internal.h | 4 +- .../generated/substrait/capabilities.pb.cc | 706 + cpp/src/generated/substrait/capabilities.pb.h | 964 + cpp/src/generated/substrait/expression.pb.cc | 11982 +++++++++--- cpp/src/generated/substrait/expression.pb.h | 15665 +++++++++++----- cpp/src/generated/substrait/extensions.pb.cc | 2776 +-- cpp/src/generated/substrait/extensions.pb.h | 2848 +-- cpp/src/generated/substrait/function.pb.cc | 432 +- cpp/src/generated/substrait/function.pb.h | 443 +- .../substrait/parameterized_types.pb.cc | 660 +- .../substrait/parameterized_types.pb.h | 863 +- cpp/src/generated/substrait/plan.pb.cc | 534 +- cpp/src/generated/substrait/plan.pb.h | 714 +- cpp/src/generated/substrait/relations.pb.cc | 3798 +++- cpp/src/generated/substrait/relations.pb.h | 8438 ++++++--- cpp/src/generated/substrait/selection.pb.cc | 5326 ------ cpp/src/generated/substrait/selection.pb.h | 5460 ------ cpp/src/generated/substrait/type.pb.cc | 2567 +-- cpp/src/generated/substrait/type.pb.h | 3811 +--- .../substrait/type_expressions.pb.cc | 1281 +- .../generated/substrait/type_expressions.pb.h | 1551 +- 28 files changed, 37598 insertions(+), 33502 deletions(-) create mode 100644 cpp/src/generated/substrait/capabilities.pb.cc create mode 100644 cpp/src/generated/substrait/capabilities.pb.h delete mode 100644 cpp/src/generated/substrait/selection.pb.cc delete mode 100644 cpp/src/generated/substrait/selection.pb.h diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake index 0b731c5348d..cc24c90f8ff 100644 --- a/cpp/cmake_modules/DefineOptions.cmake +++ b/cpp/cmake_modules/DefineOptions.cmake @@ -481,7 +481,7 @@ that have not been built" OFF) set(ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT - "https://github.com/substrait-io/substrait 9e84da55393a24953ed9f9869fa423f86f4860f7") + "https://github.com/substrait-io/substrait 30e77cad10a33f861e82993ba7295aed5a7923e5") define_option_string(ARROW_SUBSTRAIT_REPO_AND_TAG "Custom 'repository_url tag' for generating substrait accessors" "${ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT}") diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 33dd6e56ca1..2471216d7d2 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -33,13 +33,13 @@ set(ARROW_ENGINE_SRCS set(SUBSTRAIT_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait") set(SUBSTRAIT_GEN_DIR "${ARROW_SOURCE_DIR}/src/generated/substrait") -set(SUBSTRAIT_PROTOS expression +set(SUBSTRAIT_PROTOS capabilities + expression extensions function parameterized_types plan relations - selection type type_expressions) @@ -69,7 +69,7 @@ foreach(SUBSTRAIT_PROTO ${SUBSTRAIT_PROTOS}) COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${SUBSTRAIT_DIR}/binary" "--cpp_out=${SUBSTRAIT_GEN_DIR}" - "${SUBSTRAIT_PROTO}.proto" + "${SUBSTRAIT_DIR}/binary/${SUBSTRAIT_PROTO}.proto" DEPENDS ${PROTO_DEPENDS} substrait_ep) list(APPEND SUBSTRAIT_PROTO_GEN_ALL "${SUBSTRAIT_PROTO_GEN}.${EXT}") endforeach() diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index bdf09a1196c..b2b6eb7fea4 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -56,9 +56,51 @@ Result FromProto(const st::Expression& expr) { return compute::literal(std::move(datum)); } - case st::Expression::kSelection: + case st::Expression::kSelection: { if (!expr.selection().has_direct_reference()) break; - return FromProto(expr.selection().direct_reference()); + + util::optional root_expr; + if (expr.selection().has_expression()) { + ARROW_ASSIGN_OR_RAISE(*root_expr, FromProto(expr.selection().expression())); + } + + const auto& ref = expr.selection().direct_reference(); + switch (ref.reference_type_case()) { + case st::Expression::ReferenceSegment::kStructField: { + if (ref.struct_field().has_child()) break; + + FieldRef out(ref.struct_field().field()); + + if (root_expr) { + if (auto root_ref = root_expr->field_ref()) { + out = FieldRef(std::move(out), *root_ref); + } else { + // FIXME add field_ref compute function to handle + // field references into expressions + break; + } + } + return compute::field_ref(std::move(out)); + } + + case st::Expression::ReferenceSegment::kListElement: { + if (ref.list_element().has_child()) break; + if (!root_expr) { + return Status::Invalid( + "substrait::ListElement cannot take a Relation as an argument"); + } + + return compute::call( + "list_element", + {std::move(*root_expr), compute::literal(ref.list_element().offset())}); + break; + } + + default: + break; + } + break; + } case st::Expression::kIfThen: { const auto& if_then = expr.if_then(); @@ -79,39 +121,6 @@ Result FromProto(const st::Expression& expr) { expr.DebugString()); } -Result FromProto(const st::ReferenceSegment& ref) { - switch (ref.reference_type_case()) { - case st::ReferenceSegment::kStructField: { - FieldRef out(ref.struct_field().field()); - - if (ref.struct_field().has_child()) { - ARROW_ASSIGN_OR_RAISE(auto child, FromProto(ref.struct_field().child())); - auto child_ref = child.field_ref(); - if (!child_ref) break; - out = FieldRef(std::move(out), *child_ref); - } - - return compute::field_ref(std::move(out)); - } - - case st::ReferenceSegment::kListElement: { - if (ref.list_element().has_child()) { - ARROW_ASSIGN_OR_RAISE(auto child, FromProto(ref.list_element().child())); - return compute::call( - "list_element", - {std::move(child), compute::literal(ref.list_element().offset())}); - } - break; - } - - default: - break; - } - - return Status::NotImplemented("conversion to arrow::compute::Expression from ", - ref.DebugString()); -} - Result FromProto(const st::Expression::Literal& lit) { switch (lit.literal_type_case()) { case st::Expression::Literal::kBoolean: @@ -165,23 +174,29 @@ Result FromProto(const st::Expression::Literal& lit) { fixed_char(static_cast(lit.fixed_char().size())))); case st::Expression::Literal::kVarChar: - // FIXME - // There's no way to determine VarChar.length from the literal - break; + return Datum(std::make_shared( + std::make_shared(lit.var_char().value()), + varchar(static_cast(lit.var_char().length())))); case st::Expression::Literal::kFixedBinary: return Datum(FixedSizeBinaryScalarFromBytes(lit.fixed_char())); - case st::Expression::Literal::kDecimal: - if (lit.decimal().size() != sizeof(Decimal128)) { - return Status::Invalid("Decimal literal had ", lit.decimal().size(), + case st::Expression::Literal::kDecimal: { + if (lit.decimal().value().size() != sizeof(Decimal128)) { + return Status::Invalid("Decimal literal had ", lit.decimal().value().size(), " bytes (expected ", sizeof(Decimal128), ")"); } - // FIXME - // It's not clear how these bytes should be interpreted... - // Furthermore, there's no way to determine scale or precision - break; + Decimal128 value; + std::memcpy(value.mutable_native_endian_bytes(), lit.decimal().value().data(), + sizeof(Decimal128)); +#if !ARROW_LITTLE_ENDIAN + std::reverse(value.mutable_native_endian_bytes(), + value.mutable_native_endian_bytes() + sizeof(Decimal128)); +#endif + auto type = decimal128(lit.decimal().precision(), lit.decimal().scale()); + return Datum(std::make_shared(value, std::move(type))); + } case st::Expression::Literal::kStruct: { const auto& struct_ = lit.struct_(); @@ -200,19 +215,33 @@ Result FromProto(const st::Expression::Literal& lit) { case st::Expression::Literal::kList: { const auto& list = lit.list(); + if (list.values_size() == 0 && !list.has_element_type()) { + return Status::Invalid( + "substrait::Expression::Literal::List had no values and no element_type"); + } - // FIXME - // No way to determine list value type for empty list literals - DCHECK_NE(list.values_size(), 0); + std::shared_ptr element_type; + if (list.has_element_type()) { + ARROW_ASSIGN_OR_RAISE(std::tie(element_type, std::ignore), + FromProto(list.element_type())); + } ScalarVector values(list.values_size()); for (size_t i = 0; i < values.size(); ++i) { ARROW_ASSIGN_OR_RAISE(auto value, FromProto(list.values(i))); DCHECK(value.is_scalar()); values.push_back(value.scalar()); + if (element_type) { + if (!value.type()->Equals(*element_type)) { + return Status::Invalid(list.DebugString(), + " has a value whose type doesn't match element_type"); + } + } else { + element_type = value.type(); + } } - ARROW_ASSIGN_OR_RAISE(auto builder, MakeBuilder(values[0]->type)); + ARROW_ASSIGN_OR_RAISE(auto builder, MakeBuilder(element_type)); RETURN_NOT_OK(builder->AppendScalars(values)); ARROW_ASSIGN_OR_RAISE(auto arr, builder->Finish()); return Datum(std::make_shared(std::move(arr))); @@ -220,10 +249,20 @@ Result FromProto(const st::Expression::Literal& lit) { case st::Expression::Literal::kMap: { const auto& map = lit.map(); + if (map.key_values_size() == 0 && !(map.has_key_type() && map.has_value_type())) { + return Status::Invalid( + "substrait::Expression::Literal::Map had no key_values and no key_type or " + "values_type"); + } - // FIXME - // No way to determine list value type for empty list literals - DCHECK_NE(map.key_values_size(), 0); + std::shared_ptr key_type, value_type; + if (map.has_key_type()) { + ARROW_ASSIGN_OR_RAISE(std::tie(key_type, std::ignore), FromProto(map.key_type())); + } + if (map.has_value_type()) { + ARROW_ASSIGN_OR_RAISE(std::tie(value_type, std::ignore), + FromProto(map.value_type())); + } ScalarVector keys(map.key_values_size()), values(map.key_values_size()); for (size_t i = 0; i < values.size(); ++i) { @@ -243,10 +282,28 @@ Result FromProto(const st::Expression::Literal& lit) { keys.push_back(key.scalar()); values.push_back(value.scalar()); + + if (key_type) { + if (!key.type()->Equals(*key_type)) { + return Status::Invalid(map.DebugString(), + " has a key whose type doesn't match key_type"); + } + } else { + key_type = value.type(); + } + + if (value_type) { + if (!value.type()->Equals(*value_type)) { + return Status::Invalid(map.DebugString(), + " has a value whose type doesn't match value_type"); + } + } else { + value_type = value.type(); + } } - ARROW_ASSIGN_OR_RAISE(auto key_builder, MakeBuilder(keys[0]->type)); - ARROW_ASSIGN_OR_RAISE(auto value_builder, MakeBuilder(keys[0]->type)); + ARROW_ASSIGN_OR_RAISE(auto key_builder, MakeBuilder(key_type)); + ARROW_ASSIGN_OR_RAISE(auto value_builder, MakeBuilder(value_type)); RETURN_NOT_OK(key_builder->AppendScalars(keys)); RETURN_NOT_OK(value_builder->AppendScalars(values)); ARROW_ASSIGN_OR_RAISE(auto key_arr, key_builder->Finish()); @@ -472,27 +529,32 @@ Result> ToProto(const compute::Expression& expr) } if (auto param = expr.parameter()) { - DCHECK(!param->indices.empty()); - std::unique_ptr ref_segment; + /* + DCHECK(!param->indices.empty()); + for (int i : param->indices) { + } - for (auto it = param->indices.rbegin(); it != param->indices.rend(); ++it) { - auto struct_field = internal::make_unique(); + std::unique_ptr ref_segment; - if (ref_segment) { - struct_field->set_allocated_child(ref_segment.release()); - } - struct_field->set_field(*it); + for (auto it = param->indices.rbegin(); it != param->indices.rend(); ++it) { + auto struct_field = internal::make_unique(); - ref_segment = internal::make_unique(); - ref_segment->set_allocated_struct_field(struct_field.release()); - } + if (ref_segment) { + struct_field->set_allocated_child(ref_segment.release()); + } + struct_field->set_field(*it); - auto field_ref = internal::make_unique(); - field_ref->set_allocated_direct_reference(ref_segment.release()); + ref_segment = internal::make_unique(); + ref_segment->set_allocated_struct_field(struct_field.release()); + } - auto out = internal::make_unique(); - out->set_allocated_selection(field_ref.release()); - return std::move(out); + auto field_ref = internal::make_unique(); + field_ref->set_allocated_direct_reference(ref_segment.release()); + + auto out = internal::make_unique(); + out->set_allocated_selection(field_ref.release()); + return std::move(out); + */ } auto call = CallNotNull(expr); @@ -504,27 +566,30 @@ Result> ToProto(const compute::Expression& expr) } if (call->function_name == "list_element") { - // catch the special case of calls convertible to a ListElement - if (arguments[0]->has_selection() && - arguments[0]->selection().has_direct_reference()) { - if (arguments[1]->has_literal() && arguments[1]->literal().has_i32()) { - auto list_element = internal::make_unique(); - - list_element->set_allocated_child( - arguments[0]->mutable_selection()->release_direct_reference()); - list_element->set_offset(arguments[1]->literal().i32()); - - auto ref_segment = internal::make_unique(); - ref_segment->set_allocated_list_element(list_element.release()); - - auto field_ref = internal::make_unique(); - field_ref->set_allocated_direct_reference(ref_segment.release()); - - auto out = std::move(arguments[0]); // reuse an emptied st::Expression - out->set_allocated_selection(field_ref.release()); - return std::move(out); - } - } + /* + // catch the special case of calls convertible to a ListElement + if (arguments[0]->has_selection() && + arguments[0]->selection().has_direct_reference()) { + if (arguments[1]->has_literal() && arguments[1]->literal().has_i32()) { + auto list_element = + internal::make_unique(); + + list_element->set_allocated_child( + arguments[0]->mutable_selection()->release_direct_reference()); + list_element->set_offset(arguments[1]->literal().i32()); + + auto ref_segment = internal::make_unique(); + ref_segment->set_allocated_list_element(list_element.release()); + + auto field_ref = internal::make_unique(); + field_ref->set_allocated_direct_reference(ref_segment.release()); + + auto out = std::move(arguments[0]); // reuse an emptied st::Expression + out->set_allocated_selection(field_ref.release()); + return std::move(out); + } + } + */ } if (call->function_name == "if_else") { diff --git a/cpp/src/arrow/engine/substrait/expression_internal.h b/cpp/src/arrow/engine/substrait/expression_internal.h index b8a9a366d4f..6fef22f45e6 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.h +++ b/cpp/src/arrow/engine/substrait/expression_internal.h @@ -35,9 +35,6 @@ namespace engine { ARROW_ENGINE_EXPORT Result FromProto(const st::Expression&); -ARROW_ENGINE_EXPORT -Result FromProto(const st::ReferenceSegment&); - ARROW_ENGINE_EXPORT Result> ToProto(const compute::Expression&); diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index a98277fe5da..fc4ce36a03e 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -18,6 +18,7 @@ #include "arrow/engine/substrait/extension_types.h" #include "arrow/engine/simple_extension_type_internal.h" +#include "arrow/util/string_view.h" namespace arrow { namespace engine { diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index 34ffbeaa222..6deeb95337a 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -22,9 +22,8 @@ #include #include "arrow/buffer.h" -#include "arrow/compute/exec/exec_plan.h" #include "arrow/engine/visibility.h" -#include "arrow/result.h" +#include "arrow/type_fwd.h" #include "arrow/util/optional.h" namespace arrow { diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index bc95a4edb88..8cf5da3fe63 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -35,8 +35,8 @@ namespace { template Status CheckVariation(const TypeMessage& type) { - if (!type.has_variation()) return Status::OK(); - return Status::NotImplemented("Type.Variation for ", type.DebugString()); + if (type.type_variation_reference() != 0) return Status::OK(); + return Status::NotImplemented("Type variations for ", type.DebugString()); } template @@ -175,8 +175,6 @@ Result, bool>> FromProto(const st::Type& typ return FromProtoImpl(struct_, std::move(fields)); } - // NOTE: NamedStruct is not enumerated in KindCase. - case st::Type::kList: { const auto& list = type.list(); @@ -223,7 +221,7 @@ Result, bool>> FromProto(const st::Type& typ type.DebugString()); } -Result> FromProto(const st::Type::NamedStruct& named_struct) { +Result> FromProto(const st::NamedStruct& named_struct) { if (named_struct.has_struct_()) { return Status::Invalid("While converting ", named_struct.DebugString(), " no anonymous struct type was provided to which to names " @@ -405,8 +403,8 @@ Result> ToProto(const DataType& type, bool nullable) { return std::move(out); } -Result> ToProto(const Schema& schema) { - auto named_struct = internal::make_unique(); +Result> ToProto(const Schema& schema) { + auto named_struct = internal::make_unique(); auto names = named_struct->mutable_names(); names->Reserve(schema.num_fields()); @@ -418,8 +416,7 @@ Result> ToProto(const Schema& schema) { *names->Add() = field->name(); if (field->metadata() != nullptr) { - return Status::Invalid( - "substrait::Type::NamedStruct does not support field metadata"); + return Status::Invalid("substrait::NamedStruct does not support field metadata"); } ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*field->type(), field->nullable())); diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h index 167ff1e0601..73420619cd4 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -38,10 +38,10 @@ ARROW_ENGINE_EXPORT Result> ToProto(const DataType&, bool nullable = true); ARROW_ENGINE_EXPORT -Result> FromProto(const st::Type::NamedStruct&); +Result> FromProto(const st::NamedStruct&); ARROW_ENGINE_EXPORT -Result> ToProto(const Schema&); +Result> ToProto(const Schema&); inline std::string TimestampTzTimezoneString() { return "UTC"; } diff --git a/cpp/src/generated/substrait/capabilities.pb.cc b/cpp/src/generated/substrait/capabilities.pb.cc new file mode 100644 index 00000000000..d8597d5c5b8 --- /dev/null +++ b/cpp/src/generated/substrait/capabilities.pb.cc @@ -0,0 +1,706 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: capabilities.proto + +#include "capabilities.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace io { +namespace substrait { +constexpr Capabilities_SimpleExtension::Capabilities_SimpleExtension( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : function_keys_() + , type_keys_() + , type_variation_keys_() + , uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct Capabilities_SimpleExtensionDefaultTypeInternal { + constexpr Capabilities_SimpleExtensionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Capabilities_SimpleExtensionDefaultTypeInternal() {} + union { + Capabilities_SimpleExtension _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Capabilities_SimpleExtensionDefaultTypeInternal _Capabilities_SimpleExtension_default_instance_; +constexpr Capabilities::Capabilities( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : substrait_versions_() + , advanced_extension_type_urls_() + , simple_extensions_(){} +struct CapabilitiesDefaultTypeInternal { + constexpr CapabilitiesDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~CapabilitiesDefaultTypeInternal() {} + union { + Capabilities _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CapabilitiesDefaultTypeInternal _Capabilities_default_instance_; +} // namespace substrait +} // namespace io +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_capabilities_2eproto[2]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_capabilities_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_capabilities_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_capabilities_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities_SimpleExtension, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities_SimpleExtension, uri_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities_SimpleExtension, function_keys_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities_SimpleExtension, type_keys_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities_SimpleExtension, type_variation_keys_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities, substrait_versions_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities, advanced_extension_type_urls_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities, simple_extensions_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::io::substrait::Capabilities_SimpleExtension)}, + { 9, -1, sizeof(::io::substrait::Capabilities)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_Capabilities_SimpleExtension_default_instance_), + reinterpret_cast(&::io::substrait::_Capabilities_default_instance_), +}; + +const char descriptor_table_protodef_capabilities_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\022capabilities.proto\022\014io.substrait\"\376\001\n\014C" + "apabilities\022\032\n\022substrait_versions\030\001 \003(\t\022" + "$\n\034advanced_extension_type_urls\030\002 \003(\t\022E\n" + "\021simple_extensions\030\003 \003(\0132*.io.substrait." + "Capabilities.SimpleExtension\032e\n\017SimpleEx" + "tension\022\013\n\003uri\030\001 \001(\t\022\025\n\rfunction_keys\030\002 " + "\003(\t\022\021\n\ttype_keys\030\003 \003(\t\022\033\n\023type_variation" + "_keys\030\004 \003(\tB.\n\025io.substrait.protobufP\001\252\002" + "\022Substrait.Protobufb\006proto3" + ; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_capabilities_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_capabilities_2eproto = { + false, false, 347, descriptor_table_protodef_capabilities_2eproto, "capabilities.proto", + &descriptor_table_capabilities_2eproto_once, nullptr, 0, 2, + schemas, file_default_instances, TableStruct_capabilities_2eproto::offsets, + file_level_metadata_capabilities_2eproto, file_level_enum_descriptors_capabilities_2eproto, file_level_service_descriptors_capabilities_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_capabilities_2eproto_getter() { + return &descriptor_table_capabilities_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_capabilities_2eproto(&descriptor_table_capabilities_2eproto); +namespace io { +namespace substrait { + +// =================================================================== + +class Capabilities_SimpleExtension::_Internal { + public: +}; + +Capabilities_SimpleExtension::Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + function_keys_(arena), + type_keys_(arena), + type_variation_keys_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Capabilities.SimpleExtension) +} +Capabilities_SimpleExtension::Capabilities_SimpleExtension(const Capabilities_SimpleExtension& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + function_keys_(from.function_keys_), + type_keys_(from.type_keys_), + type_variation_keys_(from.type_variation_keys_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_uri().empty()) { + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Capabilities.SimpleExtension) +} + +void Capabilities_SimpleExtension::SharedCtor() { +uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Capabilities_SimpleExtension::~Capabilities_SimpleExtension() { + // @@protoc_insertion_point(destructor:io.substrait.Capabilities.SimpleExtension) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Capabilities_SimpleExtension::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Capabilities_SimpleExtension::ArenaDtor(void* object) { + Capabilities_SimpleExtension* _this = reinterpret_cast< Capabilities_SimpleExtension* >(object); + (void)_this; +} +void Capabilities_SimpleExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Capabilities_SimpleExtension::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Capabilities_SimpleExtension::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Capabilities.SimpleExtension) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + function_keys_.Clear(); + type_keys_.Clear(); + type_variation_keys_.Clear(); + uri_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string uri = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_uri(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.SimpleExtension.uri")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string function_keys = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_function_keys(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.SimpleExtension.function_keys")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // repeated string type_keys = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_type_keys(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.SimpleExtension.type_keys")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + // repeated string type_variation_keys = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_type_variation_keys(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.SimpleExtension.type_variation_keys")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Capabilities_SimpleExtension::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Capabilities.SimpleExtension) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string uri = 1; + if (this->uri().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_uri().data(), static_cast(this->_internal_uri().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Capabilities.SimpleExtension.uri"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_uri(), target); + } + + // repeated string function_keys = 2; + for (int i = 0, n = this->_internal_function_keys_size(); i < n; i++) { + const auto& s = this->_internal_function_keys(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Capabilities.SimpleExtension.function_keys"); + target = stream->WriteString(2, s, target); + } + + // repeated string type_keys = 3; + for (int i = 0, n = this->_internal_type_keys_size(); i < n; i++) { + const auto& s = this->_internal_type_keys(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Capabilities.SimpleExtension.type_keys"); + target = stream->WriteString(3, s, target); + } + + // repeated string type_variation_keys = 4; + for (int i = 0, n = this->_internal_type_variation_keys_size(); i < n; i++) { + const auto& s = this->_internal_type_variation_keys(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Capabilities.SimpleExtension.type_variation_keys"); + target = stream->WriteString(4, s, target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Capabilities.SimpleExtension) + return target; +} + +size_t Capabilities_SimpleExtension::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Capabilities.SimpleExtension) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string function_keys = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(function_keys_.size()); + for (int i = 0, n = function_keys_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + function_keys_.Get(i)); + } + + // repeated string type_keys = 3; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(type_keys_.size()); + for (int i = 0, n = type_keys_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + type_keys_.Get(i)); + } + + // repeated string type_variation_keys = 4; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(type_variation_keys_.size()); + for (int i = 0, n = type_variation_keys_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + type_variation_keys_.Get(i)); + } + + // string uri = 1; + if (this->uri().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_uri()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Capabilities_SimpleExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Capabilities.SimpleExtension) + GOOGLE_DCHECK_NE(&from, this); + const Capabilities_SimpleExtension* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Capabilities.SimpleExtension) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Capabilities.SimpleExtension) + MergeFrom(*source); + } +} + +void Capabilities_SimpleExtension::MergeFrom(const Capabilities_SimpleExtension& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Capabilities.SimpleExtension) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + function_keys_.MergeFrom(from.function_keys_); + type_keys_.MergeFrom(from.type_keys_); + type_variation_keys_.MergeFrom(from.type_variation_keys_); + if (from.uri().size() > 0) { + _internal_set_uri(from._internal_uri()); + } +} + +void Capabilities_SimpleExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Capabilities.SimpleExtension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Capabilities_SimpleExtension::CopyFrom(const Capabilities_SimpleExtension& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Capabilities.SimpleExtension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Capabilities_SimpleExtension::IsInitialized() const { + return true; +} + +void Capabilities_SimpleExtension::InternalSwap(Capabilities_SimpleExtension* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + function_keys_.InternalSwap(&other->function_keys_); + type_keys_.InternalSwap(&other->type_keys_); + type_variation_keys_.InternalSwap(&other->type_variation_keys_); + uri_.Swap(&other->uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Capabilities_SimpleExtension::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_capabilities_2eproto_getter, &descriptor_table_capabilities_2eproto_once, + file_level_metadata_capabilities_2eproto[0]); +} + +// =================================================================== + +class Capabilities::_Internal { + public: +}; + +Capabilities::Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + substrait_versions_(arena), + advanced_extension_type_urls_(arena), + simple_extensions_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Capabilities) +} +Capabilities::Capabilities(const Capabilities& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + substrait_versions_(from.substrait_versions_), + advanced_extension_type_urls_(from.advanced_extension_type_urls_), + simple_extensions_(from.simple_extensions_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Capabilities) +} + +void Capabilities::SharedCtor() { +} + +Capabilities::~Capabilities() { + // @@protoc_insertion_point(destructor:io.substrait.Capabilities) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Capabilities::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Capabilities::ArenaDtor(void* object) { + Capabilities* _this = reinterpret_cast< Capabilities* >(object); + (void)_this; +} +void Capabilities::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Capabilities::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Capabilities::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Capabilities) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + substrait_versions_.Clear(); + advanced_extension_type_urls_.Clear(); + simple_extensions_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Capabilities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string substrait_versions = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_substrait_versions(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.substrait_versions")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // repeated string advanced_extension_type_urls = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_advanced_extension_type_urls(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.advanced_extension_type_urls")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Capabilities.SimpleExtension simple_extensions = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_simple_extensions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Capabilities::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Capabilities) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string substrait_versions = 1; + for (int i = 0, n = this->_internal_substrait_versions_size(); i < n; i++) { + const auto& s = this->_internal_substrait_versions(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Capabilities.substrait_versions"); + target = stream->WriteString(1, s, target); + } + + // repeated string advanced_extension_type_urls = 2; + for (int i = 0, n = this->_internal_advanced_extension_type_urls_size(); i < n; i++) { + const auto& s = this->_internal_advanced_extension_type_urls(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Capabilities.advanced_extension_type_urls"); + target = stream->WriteString(2, s, target); + } + + // repeated .io.substrait.Capabilities.SimpleExtension simple_extensions = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_simple_extensions_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, this->_internal_simple_extensions(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Capabilities) + return target; +} + +size_t Capabilities::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Capabilities) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string substrait_versions = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(substrait_versions_.size()); + for (int i = 0, n = substrait_versions_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + substrait_versions_.Get(i)); + } + + // repeated string advanced_extension_type_urls = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(advanced_extension_type_urls_.size()); + for (int i = 0, n = advanced_extension_type_urls_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + advanced_extension_type_urls_.Get(i)); + } + + // repeated .io.substrait.Capabilities.SimpleExtension simple_extensions = 3; + total_size += 1UL * this->_internal_simple_extensions_size(); + for (const auto& msg : this->simple_extensions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Capabilities::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Capabilities) + GOOGLE_DCHECK_NE(&from, this); + const Capabilities* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Capabilities) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Capabilities) + MergeFrom(*source); + } +} + +void Capabilities::MergeFrom(const Capabilities& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Capabilities) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + substrait_versions_.MergeFrom(from.substrait_versions_); + advanced_extension_type_urls_.MergeFrom(from.advanced_extension_type_urls_); + simple_extensions_.MergeFrom(from.simple_extensions_); +} + +void Capabilities::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Capabilities) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Capabilities::CopyFrom(const Capabilities& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Capabilities) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Capabilities::IsInitialized() const { + return true; +} + +void Capabilities::InternalSwap(Capabilities* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + substrait_versions_.InternalSwap(&other->substrait_versions_); + advanced_extension_type_urls_.InternalSwap(&other->advanced_extension_type_urls_); + simple_extensions_.InternalSwap(&other->simple_extensions_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Capabilities::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_capabilities_2eproto_getter, &descriptor_table_capabilities_2eproto_once, + file_level_metadata_capabilities_2eproto[1]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::Capabilities_SimpleExtension* Arena::CreateMaybeMessage< ::io::substrait::Capabilities_SimpleExtension >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Capabilities_SimpleExtension >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Capabilities* Arena::CreateMaybeMessage< ::io::substrait::Capabilities >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Capabilities >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/capabilities.pb.h b/cpp/src/generated/substrait/capabilities.pb.h new file mode 100644 index 00000000000..c9232b22d8e --- /dev/null +++ b/cpp/src/generated/substrait/capabilities.pb.h @@ -0,0 +1,964 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: capabilities.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_capabilities_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_capabilities_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_capabilities_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_capabilities_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_capabilities_2eproto; +namespace io { +namespace substrait { +class Capabilities; +struct CapabilitiesDefaultTypeInternal; +extern CapabilitiesDefaultTypeInternal _Capabilities_default_instance_; +class Capabilities_SimpleExtension; +struct Capabilities_SimpleExtensionDefaultTypeInternal; +extern Capabilities_SimpleExtensionDefaultTypeInternal _Capabilities_SimpleExtension_default_instance_; +} // namespace substrait +} // namespace io +PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::Capabilities* Arena::CreateMaybeMessage<::io::substrait::Capabilities>(Arena*); +template<> ::io::substrait::Capabilities_SimpleExtension* Arena::CreateMaybeMessage<::io::substrait::Capabilities_SimpleExtension>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace io { +namespace substrait { + +// =================================================================== + +class Capabilities_SimpleExtension PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Capabilities.SimpleExtension) */ { + public: + inline Capabilities_SimpleExtension() : Capabilities_SimpleExtension(nullptr) {} + ~Capabilities_SimpleExtension() override; + explicit constexpr Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Capabilities_SimpleExtension(const Capabilities_SimpleExtension& from); + Capabilities_SimpleExtension(Capabilities_SimpleExtension&& from) noexcept + : Capabilities_SimpleExtension() { + *this = ::std::move(from); + } + + inline Capabilities_SimpleExtension& operator=(const Capabilities_SimpleExtension& from) { + CopyFrom(from); + return *this; + } + inline Capabilities_SimpleExtension& operator=(Capabilities_SimpleExtension&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Capabilities_SimpleExtension& default_instance() { + return *internal_default_instance(); + } + static inline const Capabilities_SimpleExtension* internal_default_instance() { + return reinterpret_cast( + &_Capabilities_SimpleExtension_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(Capabilities_SimpleExtension& a, Capabilities_SimpleExtension& b) { + a.Swap(&b); + } + inline void Swap(Capabilities_SimpleExtension* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Capabilities_SimpleExtension* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Capabilities_SimpleExtension* New() const final { + return CreateMaybeMessage(nullptr); + } + + Capabilities_SimpleExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Capabilities_SimpleExtension& from); + void MergeFrom(const Capabilities_SimpleExtension& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Capabilities_SimpleExtension* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Capabilities.SimpleExtension"; + } + protected: + explicit Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFunctionKeysFieldNumber = 2, + kTypeKeysFieldNumber = 3, + kTypeVariationKeysFieldNumber = 4, + kUriFieldNumber = 1, + }; + // repeated string function_keys = 2; + int function_keys_size() const; + private: + int _internal_function_keys_size() const; + public: + void clear_function_keys(); + const std::string& function_keys(int index) const; + std::string* mutable_function_keys(int index); + void set_function_keys(int index, const std::string& value); + void set_function_keys(int index, std::string&& value); + void set_function_keys(int index, const char* value); + void set_function_keys(int index, const char* value, size_t size); + std::string* add_function_keys(); + void add_function_keys(const std::string& value); + void add_function_keys(std::string&& value); + void add_function_keys(const char* value); + void add_function_keys(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& function_keys() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_function_keys(); + private: + const std::string& _internal_function_keys(int index) const; + std::string* _internal_add_function_keys(); + public: + + // repeated string type_keys = 3; + int type_keys_size() const; + private: + int _internal_type_keys_size() const; + public: + void clear_type_keys(); + const std::string& type_keys(int index) const; + std::string* mutable_type_keys(int index); + void set_type_keys(int index, const std::string& value); + void set_type_keys(int index, std::string&& value); + void set_type_keys(int index, const char* value); + void set_type_keys(int index, const char* value, size_t size); + std::string* add_type_keys(); + void add_type_keys(const std::string& value); + void add_type_keys(std::string&& value); + void add_type_keys(const char* value); + void add_type_keys(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& type_keys() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_type_keys(); + private: + const std::string& _internal_type_keys(int index) const; + std::string* _internal_add_type_keys(); + public: + + // repeated string type_variation_keys = 4; + int type_variation_keys_size() const; + private: + int _internal_type_variation_keys_size() const; + public: + void clear_type_variation_keys(); + const std::string& type_variation_keys(int index) const; + std::string* mutable_type_variation_keys(int index); + void set_type_variation_keys(int index, const std::string& value); + void set_type_variation_keys(int index, std::string&& value); + void set_type_variation_keys(int index, const char* value); + void set_type_variation_keys(int index, const char* value, size_t size); + std::string* add_type_variation_keys(); + void add_type_variation_keys(const std::string& value); + void add_type_variation_keys(std::string&& value); + void add_type_variation_keys(const char* value); + void add_type_variation_keys(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& type_variation_keys() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_type_variation_keys(); + private: + const std::string& _internal_type_variation_keys(int index) const; + std::string* _internal_add_type_variation_keys(); + public: + + // string uri = 1; + void clear_uri(); + const std::string& uri() const; + template + void set_uri(ArgT0&& arg0, ArgT... args); + std::string* mutable_uri(); + std::string* release_uri(); + void set_allocated_uri(std::string* uri); + private: + const std::string& _internal_uri() const; + void _internal_set_uri(const std::string& value); + std::string* _internal_mutable_uri(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Capabilities.SimpleExtension) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField function_keys_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField type_keys_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField type_variation_keys_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_capabilities_2eproto; +}; +// ------------------------------------------------------------------- + +class Capabilities PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Capabilities) */ { + public: + inline Capabilities() : Capabilities(nullptr) {} + ~Capabilities() override; + explicit constexpr Capabilities(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Capabilities(const Capabilities& from); + Capabilities(Capabilities&& from) noexcept + : Capabilities() { + *this = ::std::move(from); + } + + inline Capabilities& operator=(const Capabilities& from) { + CopyFrom(from); + return *this; + } + inline Capabilities& operator=(Capabilities&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Capabilities& default_instance() { + return *internal_default_instance(); + } + static inline const Capabilities* internal_default_instance() { + return reinterpret_cast( + &_Capabilities_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(Capabilities& a, Capabilities& b) { + a.Swap(&b); + } + inline void Swap(Capabilities* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Capabilities* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Capabilities* New() const final { + return CreateMaybeMessage(nullptr); + } + + Capabilities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Capabilities& from); + void MergeFrom(const Capabilities& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Capabilities* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Capabilities"; + } + protected: + explicit Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Capabilities_SimpleExtension SimpleExtension; + + // accessors ------------------------------------------------------- + + enum : int { + kSubstraitVersionsFieldNumber = 1, + kAdvancedExtensionTypeUrlsFieldNumber = 2, + kSimpleExtensionsFieldNumber = 3, + }; + // repeated string substrait_versions = 1; + int substrait_versions_size() const; + private: + int _internal_substrait_versions_size() const; + public: + void clear_substrait_versions(); + const std::string& substrait_versions(int index) const; + std::string* mutable_substrait_versions(int index); + void set_substrait_versions(int index, const std::string& value); + void set_substrait_versions(int index, std::string&& value); + void set_substrait_versions(int index, const char* value); + void set_substrait_versions(int index, const char* value, size_t size); + std::string* add_substrait_versions(); + void add_substrait_versions(const std::string& value); + void add_substrait_versions(std::string&& value); + void add_substrait_versions(const char* value); + void add_substrait_versions(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& substrait_versions() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_substrait_versions(); + private: + const std::string& _internal_substrait_versions(int index) const; + std::string* _internal_add_substrait_versions(); + public: + + // repeated string advanced_extension_type_urls = 2; + int advanced_extension_type_urls_size() const; + private: + int _internal_advanced_extension_type_urls_size() const; + public: + void clear_advanced_extension_type_urls(); + const std::string& advanced_extension_type_urls(int index) const; + std::string* mutable_advanced_extension_type_urls(int index); + void set_advanced_extension_type_urls(int index, const std::string& value); + void set_advanced_extension_type_urls(int index, std::string&& value); + void set_advanced_extension_type_urls(int index, const char* value); + void set_advanced_extension_type_urls(int index, const char* value, size_t size); + std::string* add_advanced_extension_type_urls(); + void add_advanced_extension_type_urls(const std::string& value); + void add_advanced_extension_type_urls(std::string&& value); + void add_advanced_extension_type_urls(const char* value); + void add_advanced_extension_type_urls(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& advanced_extension_type_urls() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_advanced_extension_type_urls(); + private: + const std::string& _internal_advanced_extension_type_urls(int index) const; + std::string* _internal_add_advanced_extension_type_urls(); + public: + + // repeated .io.substrait.Capabilities.SimpleExtension simple_extensions = 3; + int simple_extensions_size() const; + private: + int _internal_simple_extensions_size() const; + public: + void clear_simple_extensions(); + ::io::substrait::Capabilities_SimpleExtension* mutable_simple_extensions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Capabilities_SimpleExtension >* + mutable_simple_extensions(); + private: + const ::io::substrait::Capabilities_SimpleExtension& _internal_simple_extensions(int index) const; + ::io::substrait::Capabilities_SimpleExtension* _internal_add_simple_extensions(); + public: + const ::io::substrait::Capabilities_SimpleExtension& simple_extensions(int index) const; + ::io::substrait::Capabilities_SimpleExtension* add_simple_extensions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Capabilities_SimpleExtension >& + simple_extensions() const; + + // @@protoc_insertion_point(class_scope:io.substrait.Capabilities) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField substrait_versions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField advanced_extension_type_urls_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Capabilities_SimpleExtension > simple_extensions_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_capabilities_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Capabilities_SimpleExtension + +// string uri = 1; +inline void Capabilities_SimpleExtension::clear_uri() { + uri_.ClearToEmpty(); +} +inline const std::string& Capabilities_SimpleExtension::uri() const { + // @@protoc_insertion_point(field_get:io.substrait.Capabilities.SimpleExtension.uri) + return _internal_uri(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Capabilities_SimpleExtension::set_uri(ArgT0&& arg0, ArgT... args) { + + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.uri) +} +inline std::string* Capabilities_SimpleExtension::mutable_uri() { + // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.SimpleExtension.uri) + return _internal_mutable_uri(); +} +inline const std::string& Capabilities_SimpleExtension::_internal_uri() const { + return uri_.Get(); +} +inline void Capabilities_SimpleExtension::_internal_set_uri(const std::string& value) { + + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Capabilities_SimpleExtension::_internal_mutable_uri() { + + return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Capabilities_SimpleExtension::release_uri() { + // @@protoc_insertion_point(field_release:io.substrait.Capabilities.SimpleExtension.uri) + return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Capabilities_SimpleExtension::set_allocated_uri(std::string* uri) { + if (uri != nullptr) { + + } else { + + } + uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Capabilities.SimpleExtension.uri) +} + +// repeated string function_keys = 2; +inline int Capabilities_SimpleExtension::_internal_function_keys_size() const { + return function_keys_.size(); +} +inline int Capabilities_SimpleExtension::function_keys_size() const { + return _internal_function_keys_size(); +} +inline void Capabilities_SimpleExtension::clear_function_keys() { + function_keys_.Clear(); +} +inline std::string* Capabilities_SimpleExtension::add_function_keys() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Capabilities.SimpleExtension.function_keys) + return _internal_add_function_keys(); +} +inline const std::string& Capabilities_SimpleExtension::_internal_function_keys(int index) const { + return function_keys_.Get(index); +} +inline const std::string& Capabilities_SimpleExtension::function_keys(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Capabilities.SimpleExtension.function_keys) + return _internal_function_keys(index); +} +inline std::string* Capabilities_SimpleExtension::mutable_function_keys(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.SimpleExtension.function_keys) + return function_keys_.Mutable(index); +} +inline void Capabilities_SimpleExtension::set_function_keys(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.function_keys) + function_keys_.Mutable(index)->assign(value); +} +inline void Capabilities_SimpleExtension::set_function_keys(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.function_keys) + function_keys_.Mutable(index)->assign(std::move(value)); +} +inline void Capabilities_SimpleExtension::set_function_keys(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + function_keys_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Capabilities.SimpleExtension.function_keys) +} +inline void Capabilities_SimpleExtension::set_function_keys(int index, const char* value, size_t size) { + function_keys_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Capabilities.SimpleExtension.function_keys) +} +inline std::string* Capabilities_SimpleExtension::_internal_add_function_keys() { + return function_keys_.Add(); +} +inline void Capabilities_SimpleExtension::add_function_keys(const std::string& value) { + function_keys_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.function_keys) +} +inline void Capabilities_SimpleExtension::add_function_keys(std::string&& value) { + function_keys_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.function_keys) +} +inline void Capabilities_SimpleExtension::add_function_keys(const char* value) { + GOOGLE_DCHECK(value != nullptr); + function_keys_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Capabilities.SimpleExtension.function_keys) +} +inline void Capabilities_SimpleExtension::add_function_keys(const char* value, size_t size) { + function_keys_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Capabilities.SimpleExtension.function_keys) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Capabilities_SimpleExtension::function_keys() const { + // @@protoc_insertion_point(field_list:io.substrait.Capabilities.SimpleExtension.function_keys) + return function_keys_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Capabilities_SimpleExtension::mutable_function_keys() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.SimpleExtension.function_keys) + return &function_keys_; +} + +// repeated string type_keys = 3; +inline int Capabilities_SimpleExtension::_internal_type_keys_size() const { + return type_keys_.size(); +} +inline int Capabilities_SimpleExtension::type_keys_size() const { + return _internal_type_keys_size(); +} +inline void Capabilities_SimpleExtension::clear_type_keys() { + type_keys_.Clear(); +} +inline std::string* Capabilities_SimpleExtension::add_type_keys() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Capabilities.SimpleExtension.type_keys) + return _internal_add_type_keys(); +} +inline const std::string& Capabilities_SimpleExtension::_internal_type_keys(int index) const { + return type_keys_.Get(index); +} +inline const std::string& Capabilities_SimpleExtension::type_keys(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Capabilities.SimpleExtension.type_keys) + return _internal_type_keys(index); +} +inline std::string* Capabilities_SimpleExtension::mutable_type_keys(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.SimpleExtension.type_keys) + return type_keys_.Mutable(index); +} +inline void Capabilities_SimpleExtension::set_type_keys(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.type_keys) + type_keys_.Mutable(index)->assign(value); +} +inline void Capabilities_SimpleExtension::set_type_keys(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.type_keys) + type_keys_.Mutable(index)->assign(std::move(value)); +} +inline void Capabilities_SimpleExtension::set_type_keys(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + type_keys_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Capabilities.SimpleExtension.type_keys) +} +inline void Capabilities_SimpleExtension::set_type_keys(int index, const char* value, size_t size) { + type_keys_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Capabilities.SimpleExtension.type_keys) +} +inline std::string* Capabilities_SimpleExtension::_internal_add_type_keys() { + return type_keys_.Add(); +} +inline void Capabilities_SimpleExtension::add_type_keys(const std::string& value) { + type_keys_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.type_keys) +} +inline void Capabilities_SimpleExtension::add_type_keys(std::string&& value) { + type_keys_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.type_keys) +} +inline void Capabilities_SimpleExtension::add_type_keys(const char* value) { + GOOGLE_DCHECK(value != nullptr); + type_keys_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Capabilities.SimpleExtension.type_keys) +} +inline void Capabilities_SimpleExtension::add_type_keys(const char* value, size_t size) { + type_keys_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Capabilities.SimpleExtension.type_keys) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Capabilities_SimpleExtension::type_keys() const { + // @@protoc_insertion_point(field_list:io.substrait.Capabilities.SimpleExtension.type_keys) + return type_keys_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Capabilities_SimpleExtension::mutable_type_keys() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.SimpleExtension.type_keys) + return &type_keys_; +} + +// repeated string type_variation_keys = 4; +inline int Capabilities_SimpleExtension::_internal_type_variation_keys_size() const { + return type_variation_keys_.size(); +} +inline int Capabilities_SimpleExtension::type_variation_keys_size() const { + return _internal_type_variation_keys_size(); +} +inline void Capabilities_SimpleExtension::clear_type_variation_keys() { + type_variation_keys_.Clear(); +} +inline std::string* Capabilities_SimpleExtension::add_type_variation_keys() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + return _internal_add_type_variation_keys(); +} +inline const std::string& Capabilities_SimpleExtension::_internal_type_variation_keys(int index) const { + return type_variation_keys_.Get(index); +} +inline const std::string& Capabilities_SimpleExtension::type_variation_keys(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + return _internal_type_variation_keys(index); +} +inline std::string* Capabilities_SimpleExtension::mutable_type_variation_keys(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + return type_variation_keys_.Mutable(index); +} +inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + type_variation_keys_.Mutable(index)->assign(value); +} +inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + type_variation_keys_.Mutable(index)->assign(std::move(value)); +} +inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + type_variation_keys_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Capabilities.SimpleExtension.type_variation_keys) +} +inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const char* value, size_t size) { + type_variation_keys_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Capabilities.SimpleExtension.type_variation_keys) +} +inline std::string* Capabilities_SimpleExtension::_internal_add_type_variation_keys() { + return type_variation_keys_.Add(); +} +inline void Capabilities_SimpleExtension::add_type_variation_keys(const std::string& value) { + type_variation_keys_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.type_variation_keys) +} +inline void Capabilities_SimpleExtension::add_type_variation_keys(std::string&& value) { + type_variation_keys_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.type_variation_keys) +} +inline void Capabilities_SimpleExtension::add_type_variation_keys(const char* value) { + GOOGLE_DCHECK(value != nullptr); + type_variation_keys_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Capabilities.SimpleExtension.type_variation_keys) +} +inline void Capabilities_SimpleExtension::add_type_variation_keys(const char* value, size_t size) { + type_variation_keys_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Capabilities.SimpleExtension.type_variation_keys) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Capabilities_SimpleExtension::type_variation_keys() const { + // @@protoc_insertion_point(field_list:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + return type_variation_keys_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Capabilities_SimpleExtension::mutable_type_variation_keys() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + return &type_variation_keys_; +} + +// ------------------------------------------------------------------- + +// Capabilities + +// repeated string substrait_versions = 1; +inline int Capabilities::_internal_substrait_versions_size() const { + return substrait_versions_.size(); +} +inline int Capabilities::substrait_versions_size() const { + return _internal_substrait_versions_size(); +} +inline void Capabilities::clear_substrait_versions() { + substrait_versions_.Clear(); +} +inline std::string* Capabilities::add_substrait_versions() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Capabilities.substrait_versions) + return _internal_add_substrait_versions(); +} +inline const std::string& Capabilities::_internal_substrait_versions(int index) const { + return substrait_versions_.Get(index); +} +inline const std::string& Capabilities::substrait_versions(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Capabilities.substrait_versions) + return _internal_substrait_versions(index); +} +inline std::string* Capabilities::mutable_substrait_versions(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.substrait_versions) + return substrait_versions_.Mutable(index); +} +inline void Capabilities::set_substrait_versions(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.substrait_versions) + substrait_versions_.Mutable(index)->assign(value); +} +inline void Capabilities::set_substrait_versions(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.substrait_versions) + substrait_versions_.Mutable(index)->assign(std::move(value)); +} +inline void Capabilities::set_substrait_versions(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + substrait_versions_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Capabilities.substrait_versions) +} +inline void Capabilities::set_substrait_versions(int index, const char* value, size_t size) { + substrait_versions_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Capabilities.substrait_versions) +} +inline std::string* Capabilities::_internal_add_substrait_versions() { + return substrait_versions_.Add(); +} +inline void Capabilities::add_substrait_versions(const std::string& value) { + substrait_versions_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.substrait_versions) +} +inline void Capabilities::add_substrait_versions(std::string&& value) { + substrait_versions_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.substrait_versions) +} +inline void Capabilities::add_substrait_versions(const char* value) { + GOOGLE_DCHECK(value != nullptr); + substrait_versions_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Capabilities.substrait_versions) +} +inline void Capabilities::add_substrait_versions(const char* value, size_t size) { + substrait_versions_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Capabilities.substrait_versions) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Capabilities::substrait_versions() const { + // @@protoc_insertion_point(field_list:io.substrait.Capabilities.substrait_versions) + return substrait_versions_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Capabilities::mutable_substrait_versions() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.substrait_versions) + return &substrait_versions_; +} + +// repeated string advanced_extension_type_urls = 2; +inline int Capabilities::_internal_advanced_extension_type_urls_size() const { + return advanced_extension_type_urls_.size(); +} +inline int Capabilities::advanced_extension_type_urls_size() const { + return _internal_advanced_extension_type_urls_size(); +} +inline void Capabilities::clear_advanced_extension_type_urls() { + advanced_extension_type_urls_.Clear(); +} +inline std::string* Capabilities::add_advanced_extension_type_urls() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Capabilities.advanced_extension_type_urls) + return _internal_add_advanced_extension_type_urls(); +} +inline const std::string& Capabilities::_internal_advanced_extension_type_urls(int index) const { + return advanced_extension_type_urls_.Get(index); +} +inline const std::string& Capabilities::advanced_extension_type_urls(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Capabilities.advanced_extension_type_urls) + return _internal_advanced_extension_type_urls(index); +} +inline std::string* Capabilities::mutable_advanced_extension_type_urls(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.advanced_extension_type_urls) + return advanced_extension_type_urls_.Mutable(index); +} +inline void Capabilities::set_advanced_extension_type_urls(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.advanced_extension_type_urls) + advanced_extension_type_urls_.Mutable(index)->assign(value); +} +inline void Capabilities::set_advanced_extension_type_urls(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Capabilities.advanced_extension_type_urls) + advanced_extension_type_urls_.Mutable(index)->assign(std::move(value)); +} +inline void Capabilities::set_advanced_extension_type_urls(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + advanced_extension_type_urls_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Capabilities.advanced_extension_type_urls) +} +inline void Capabilities::set_advanced_extension_type_urls(int index, const char* value, size_t size) { + advanced_extension_type_urls_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Capabilities.advanced_extension_type_urls) +} +inline std::string* Capabilities::_internal_add_advanced_extension_type_urls() { + return advanced_extension_type_urls_.Add(); +} +inline void Capabilities::add_advanced_extension_type_urls(const std::string& value) { + advanced_extension_type_urls_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.advanced_extension_type_urls) +} +inline void Capabilities::add_advanced_extension_type_urls(std::string&& value) { + advanced_extension_type_urls_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.advanced_extension_type_urls) +} +inline void Capabilities::add_advanced_extension_type_urls(const char* value) { + GOOGLE_DCHECK(value != nullptr); + advanced_extension_type_urls_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Capabilities.advanced_extension_type_urls) +} +inline void Capabilities::add_advanced_extension_type_urls(const char* value, size_t size) { + advanced_extension_type_urls_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Capabilities.advanced_extension_type_urls) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Capabilities::advanced_extension_type_urls() const { + // @@protoc_insertion_point(field_list:io.substrait.Capabilities.advanced_extension_type_urls) + return advanced_extension_type_urls_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Capabilities::mutable_advanced_extension_type_urls() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.advanced_extension_type_urls) + return &advanced_extension_type_urls_; +} + +// repeated .io.substrait.Capabilities.SimpleExtension simple_extensions = 3; +inline int Capabilities::_internal_simple_extensions_size() const { + return simple_extensions_.size(); +} +inline int Capabilities::simple_extensions_size() const { + return _internal_simple_extensions_size(); +} +inline void Capabilities::clear_simple_extensions() { + simple_extensions_.Clear(); +} +inline ::io::substrait::Capabilities_SimpleExtension* Capabilities::mutable_simple_extensions(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.simple_extensions) + return simple_extensions_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Capabilities_SimpleExtension >* +Capabilities::mutable_simple_extensions() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.simple_extensions) + return &simple_extensions_; +} +inline const ::io::substrait::Capabilities_SimpleExtension& Capabilities::_internal_simple_extensions(int index) const { + return simple_extensions_.Get(index); +} +inline const ::io::substrait::Capabilities_SimpleExtension& Capabilities::simple_extensions(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Capabilities.simple_extensions) + return _internal_simple_extensions(index); +} +inline ::io::substrait::Capabilities_SimpleExtension* Capabilities::_internal_add_simple_extensions() { + return simple_extensions_.Add(); +} +inline ::io::substrait::Capabilities_SimpleExtension* Capabilities::add_simple_extensions() { + // @@protoc_insertion_point(field_add:io.substrait.Capabilities.simple_extensions) + return _internal_add_simple_extensions(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Capabilities_SimpleExtension >& +Capabilities::simple_extensions() const { + // @@protoc_insertion_point(field_list:io.substrait.Capabilities.simple_extensions) + return simple_extensions_; +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace substrait +} // namespace io + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_capabilities_2eproto diff --git a/cpp/src/generated/substrait/expression.pb.cc b/cpp/src/generated/substrait/expression.pb.cc index 7f9cf3a7983..33b42139e64 100644 --- a/cpp/src/generated/substrait/expression.pb.cc +++ b/cpp/src/generated/substrait/expression.pb.cc @@ -41,6 +41,33 @@ struct Expression_EnumDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EnumDefaultTypeInternal _Expression_Enum_default_instance_; +constexpr Expression_Literal_VarChar::Expression_Literal_VarChar( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , length_(0u){} +struct Expression_Literal_VarCharDefaultTypeInternal { + constexpr Expression_Literal_VarCharDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_Literal_VarCharDefaultTypeInternal() {} + union { + Expression_Literal_VarChar _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_VarCharDefaultTypeInternal _Expression_Literal_VarChar_default_instance_; +constexpr Expression_Literal_Decimal::Expression_Literal_Decimal( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , precision_(0) + , scale_(0){} +struct Expression_Literal_DecimalDefaultTypeInternal { + constexpr Expression_Literal_DecimalDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_Literal_DecimalDefaultTypeInternal() {} + union { + Expression_Literal_Decimal _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_DecimalDefaultTypeInternal _Expression_Literal_Decimal_default_instance_; constexpr Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : key_(nullptr) @@ -56,7 +83,9 @@ struct Expression_Literal_Map_KeyValueDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_Map_KeyValueDefaultTypeInternal _Expression_Literal_Map_KeyValue_default_instance_; constexpr Expression_Literal_Map::Expression_Literal_Map( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : key_values_(){} + : key_values_() + , key_type_(nullptr) + , value_type_(nullptr){} struct Expression_Literal_MapDefaultTypeInternal { constexpr Expression_Literal_MapDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -106,7 +135,8 @@ struct Expression_Literal_StructDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_StructDefaultTypeInternal _Expression_Literal_Struct_default_instance_; constexpr Expression_Literal_List::Expression_Literal_List( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : values_(){} + : values_() + , element_type_(nullptr){} struct Expression_Literal_ListDefaultTypeInternal { constexpr Expression_Literal_ListDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -118,7 +148,8 @@ struct Expression_Literal_ListDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_ListDefaultTypeInternal _Expression_Literal_List_default_instance_; constexpr Expression_Literal::Expression_Literal( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} + : nullable_(false) + , _oneof_case_{}{} struct Expression_LiteralDefaultTypeInternal { constexpr Expression_LiteralDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -131,8 +162,8 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_LiteralDefaultTypeIn constexpr Expression_ScalarFunction::Expression_ScalarFunction( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : args_() - , id_(nullptr) - , output_type_(nullptr){} + , output_type_(nullptr) + , function_reference_(0u){} struct Expression_ScalarFunctionDefaultTypeInternal { constexpr Expression_ScalarFunctionDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -142,23 +173,6 @@ struct Expression_ScalarFunctionDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ScalarFunctionDefaultTypeInternal _Expression_ScalarFunction_default_instance_; -constexpr Expression_AggregateFunction::Expression_AggregateFunction( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : args_() - , sorts_() - , id_(nullptr) - , output_type_(nullptr) - , phase_(0) -{} -struct Expression_AggregateFunctionDefaultTypeInternal { - constexpr Expression_AggregateFunctionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_AggregateFunctionDefaultTypeInternal() {} - union { - Expression_AggregateFunction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_AggregateFunctionDefaultTypeInternal _Expression_AggregateFunction_default_instance_; constexpr Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : offset_(PROTOBUF_LONGLONG(0)){} @@ -222,10 +236,10 @@ constexpr Expression_WindowFunction::Expression_WindowFunction( : partitions_() , sorts_() , args_() - , id_(nullptr) , upper_bound_(nullptr) , lower_bound_(nullptr) , output_type_(nullptr) + , function_reference_(0u) , phase_(0) {} struct Expression_WindowFunctionDefaultTypeInternal { @@ -237,19 +251,6 @@ struct Expression_WindowFunctionDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunctionDefaultTypeInternal _Expression_WindowFunction_default_instance_; -constexpr Expression_SortField::Expression_SortField( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : expr_(nullptr) - , _oneof_case_{}{} -struct Expression_SortFieldDefaultTypeInternal { - constexpr Expression_SortFieldDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_SortFieldDefaultTypeInternal() {} - union { - Expression_SortField _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SortFieldDefaultTypeInternal _Expression_SortField_default_instance_; constexpr Expression_IfThen_IfClause::Expression_IfThen_IfClause( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : if__(nullptr) @@ -276,6 +277,19 @@ struct Expression_IfThenDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_IfThenDefaultTypeInternal _Expression_IfThen_default_instance_; +constexpr Expression_Cast::Expression_Cast( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : type_(nullptr) + , input_(nullptr){} +struct Expression_CastDefaultTypeInternal { + constexpr Expression_CastDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_CastDefaultTypeInternal() {} + union { + Expression_Cast _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_CastDefaultTypeInternal _Expression_Cast_default_instance_; constexpr Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : if__(nullptr) @@ -380,6 +394,217 @@ struct Expression_EmbeddedFunctionDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunctionDefaultTypeInternal _Expression_EmbeddedFunction_default_instance_; +constexpr Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : map_key_(nullptr) + , child_(nullptr){} +struct Expression_ReferenceSegment_MapKeyDefaultTypeInternal { + constexpr Expression_ReferenceSegment_MapKeyDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_ReferenceSegment_MapKeyDefaultTypeInternal() {} + union { + Expression_ReferenceSegment_MapKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_MapKeyDefaultTypeInternal _Expression_ReferenceSegment_MapKey_default_instance_; +constexpr Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : child_(nullptr) + , field_(0){} +struct Expression_ReferenceSegment_StructFieldDefaultTypeInternal { + constexpr Expression_ReferenceSegment_StructFieldDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_ReferenceSegment_StructFieldDefaultTypeInternal() {} + union { + Expression_ReferenceSegment_StructField _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_StructFieldDefaultTypeInternal _Expression_ReferenceSegment_StructField_default_instance_; +constexpr Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : child_(nullptr) + , offset_(0){} +struct Expression_ReferenceSegment_ListElementDefaultTypeInternal { + constexpr Expression_ReferenceSegment_ListElementDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_ReferenceSegment_ListElementDefaultTypeInternal() {} + union { + Expression_ReferenceSegment_ListElement _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_ListElementDefaultTypeInternal _Expression_ReferenceSegment_ListElement_default_instance_; +constexpr Expression_ReferenceSegment::Expression_ReferenceSegment( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct Expression_ReferenceSegmentDefaultTypeInternal { + constexpr Expression_ReferenceSegmentDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_ReferenceSegmentDefaultTypeInternal() {} + union { + Expression_ReferenceSegment _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegmentDefaultTypeInternal _Expression_ReferenceSegment_default_instance_; +constexpr Expression_MaskExpression_Select::Expression_MaskExpression_Select( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct Expression_MaskExpression_SelectDefaultTypeInternal { + constexpr Expression_MaskExpression_SelectDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpression_SelectDefaultTypeInternal() {} + union { + Expression_MaskExpression_Select _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_SelectDefaultTypeInternal _Expression_MaskExpression_Select_default_instance_; +constexpr Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : struct_items_(){} +struct Expression_MaskExpression_StructSelectDefaultTypeInternal { + constexpr Expression_MaskExpression_StructSelectDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpression_StructSelectDefaultTypeInternal() {} + union { + Expression_MaskExpression_StructSelect _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_StructSelectDefaultTypeInternal _Expression_MaskExpression_StructSelect_default_instance_; +constexpr Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : child_(nullptr) + , field_(0){} +struct Expression_MaskExpression_StructItemDefaultTypeInternal { + constexpr Expression_MaskExpression_StructItemDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpression_StructItemDefaultTypeInternal() {} + union { + Expression_MaskExpression_StructItem _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_StructItemDefaultTypeInternal _Expression_MaskExpression_StructItem_default_instance_; +constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : field_(0){} +struct Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal { + constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal() {} + union { + Expression_MaskExpression_ListSelect_ListSelectItem_ListElement _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_; +constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : start_(0) + , end_(0){} +struct Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal { + constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal() {} + union { + Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_; +constexpr Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal { + constexpr Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal() {} + union { + Expression_MaskExpression_ListSelect_ListSelectItem _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_; +constexpr Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : selection_() + , child_(nullptr){} +struct Expression_MaskExpression_ListSelectDefaultTypeInternal { + constexpr Expression_MaskExpression_ListSelectDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpression_ListSelectDefaultTypeInternal() {} + union { + Expression_MaskExpression_ListSelect _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelectDefaultTypeInternal _Expression_MaskExpression_ListSelect_default_instance_; +constexpr Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : map_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal { + constexpr Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal() {} + union { + Expression_MaskExpression_MapSelect_MapKey _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKey_default_instance_; +constexpr Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : map_key_expression_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} +struct Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal { + constexpr Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal() {} + union { + Expression_MaskExpression_MapSelect_MapKeyExpression _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_; +constexpr Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : child_(nullptr) + , _oneof_case_{}{} +struct Expression_MaskExpression_MapSelectDefaultTypeInternal { + constexpr Expression_MaskExpression_MapSelectDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpression_MapSelectDefaultTypeInternal() {} + union { + Expression_MaskExpression_MapSelect _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelectDefaultTypeInternal _Expression_MaskExpression_MapSelect_default_instance_; +constexpr Expression_MaskExpression::Expression_MaskExpression( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : select_(nullptr) + , maintain_singular_struct_(false){} +struct Expression_MaskExpressionDefaultTypeInternal { + constexpr Expression_MaskExpressionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_MaskExpressionDefaultTypeInternal() {} + union { + Expression_MaskExpression _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpressionDefaultTypeInternal _Expression_MaskExpression_default_instance_; +constexpr Expression_FieldReference_RootReference::Expression_FieldReference_RootReference( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} +struct Expression_FieldReference_RootReferenceDefaultTypeInternal { + constexpr Expression_FieldReference_RootReferenceDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_FieldReference_RootReferenceDefaultTypeInternal() {} + union { + Expression_FieldReference_RootReference _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_FieldReference_RootReferenceDefaultTypeInternal _Expression_FieldReference_RootReference_default_instance_; +constexpr Expression_FieldReference::Expression_FieldReference( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct Expression_FieldReferenceDefaultTypeInternal { + constexpr Expression_FieldReferenceDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~Expression_FieldReferenceDefaultTypeInternal() {} + union { + Expression_FieldReference _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_FieldReferenceDefaultTypeInternal _Expression_FieldReference_default_instance_; constexpr Expression::Expression( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : _oneof_case_{}{} @@ -392,9 +617,39 @@ struct ExpressionDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExpressionDefaultTypeInternal _Expression_default_instance_; +constexpr SortField::SortField( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : expr_(nullptr) + , _oneof_case_{}{} +struct SortFieldDefaultTypeInternal { + constexpr SortFieldDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SortFieldDefaultTypeInternal() {} + union { + SortField _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SortFieldDefaultTypeInternal _SortField_default_instance_; +constexpr AggregateFunction::AggregateFunction( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : args_() + , sorts_() + , output_type_(nullptr) + , function_reference_(0u) + , phase_(0) +{} +struct AggregateFunctionDefaultTypeInternal { + constexpr AggregateFunctionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AggregateFunctionDefaultTypeInternal() {} + union { + AggregateFunction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateFunctionDefaultTypeInternal _AggregateFunction_default_instance_; } // namespace substrait } // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_expression_2eproto[29]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_expression_2eproto[49]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_expression_2eproto[2]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_expression_2eproto = nullptr; @@ -413,6 +668,21 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Enum, enum_kind_), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_VarChar, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_VarChar, value_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_VarChar, length_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Decimal, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Decimal, value_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Decimal, precision_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Decimal, scale_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map_KeyValue, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ @@ -425,6 +695,8 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map, key_values_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map, key_type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map, value_type_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalYearToMonth, _internal_metadata_), ~0u, // no _extensions_ @@ -451,6 +723,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_List, values_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_List, element_type_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal, _internal_metadata_), ~0u, // no _extensions_ @@ -480,26 +753,17 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal, nullable_), PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal, literal_type_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, function_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, args_), PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, output_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, id_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, args_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, sorts_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, phase_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_AggregateFunction, output_type_), - ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Preceding, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ @@ -536,7 +800,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, id_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, function_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, partitions_), PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, sorts_), PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, upper_bound_), @@ -545,15 +809,6 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, output_type_), PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, args_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SortField, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SortField, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SortField, expr_), - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SortField, sort_kind_), - ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen_IfClause, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ @@ -568,6 +823,13 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen, ifs_), PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen, else__), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Cast, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Cast, type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Cast, input_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression_IfValue, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ @@ -626,6 +888,130 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, kind_), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_MapKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_MapKey, map_key_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_MapKey, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_StructField, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_StructField, field_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_StructField, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_ListElement, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_ListElement, offset_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_ListElement, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment, reference_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_Select, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_Select, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_Select, type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_StructSelect, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_StructSelect, struct_items_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_StructItem, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_StructItem, field_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_StructItem, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, field_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, start_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect, selection_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect, child_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect_MapKey, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect_MapKey, map_key_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, map_key_expression_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect, child_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect, select_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression, select_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression, maintain_singular_struct_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_FieldReference_RootReference, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_FieldReference, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_FieldReference, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_FieldReference, reference_type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_FieldReference, root_type_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::io::substrait::Expression, _oneof_case_[0]), @@ -639,43 +1025,85 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::io::substrait::Expression, rex_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::SortField, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::SortField, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::SortField, expr_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::SortField, sort_kind_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, function_reference_), + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, args_), + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, sorts_), + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, phase_), + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, output_type_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::io::substrait::Expression_Enum_Empty)}, { 5, -1, sizeof(::io::substrait::Expression_Enum)}, - { 13, -1, sizeof(::io::substrait::Expression_Literal_Map_KeyValue)}, - { 20, -1, sizeof(::io::substrait::Expression_Literal_Map)}, - { 26, -1, sizeof(::io::substrait::Expression_Literal_IntervalYearToMonth)}, - { 33, -1, sizeof(::io::substrait::Expression_Literal_IntervalDayToSecond)}, - { 40, -1, sizeof(::io::substrait::Expression_Literal_Struct)}, - { 46, -1, sizeof(::io::substrait::Expression_Literal_List)}, - { 52, -1, sizeof(::io::substrait::Expression_Literal)}, - { 82, -1, sizeof(::io::substrait::Expression_ScalarFunction)}, - { 90, -1, sizeof(::io::substrait::Expression_AggregateFunction)}, - { 100, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Preceding)}, - { 106, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Following)}, - { 112, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_CurrentRow)}, - { 117, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Unbounded)}, - { 122, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound)}, - { 132, -1, sizeof(::io::substrait::Expression_WindowFunction)}, - { 145, -1, sizeof(::io::substrait::Expression_SortField)}, + { 13, -1, sizeof(::io::substrait::Expression_Literal_VarChar)}, + { 20, -1, sizeof(::io::substrait::Expression_Literal_Decimal)}, + { 28, -1, sizeof(::io::substrait::Expression_Literal_Map_KeyValue)}, + { 35, -1, sizeof(::io::substrait::Expression_Literal_Map)}, + { 43, -1, sizeof(::io::substrait::Expression_Literal_IntervalYearToMonth)}, + { 50, -1, sizeof(::io::substrait::Expression_Literal_IntervalDayToSecond)}, + { 57, -1, sizeof(::io::substrait::Expression_Literal_Struct)}, + { 63, -1, sizeof(::io::substrait::Expression_Literal_List)}, + { 70, -1, sizeof(::io::substrait::Expression_Literal)}, + { 101, -1, sizeof(::io::substrait::Expression_ScalarFunction)}, + { 109, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Preceding)}, + { 115, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Following)}, + { 121, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_CurrentRow)}, + { 126, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Unbounded)}, + { 131, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound)}, + { 141, -1, sizeof(::io::substrait::Expression_WindowFunction)}, { 154, -1, sizeof(::io::substrait::Expression_IfThen_IfClause)}, { 161, -1, sizeof(::io::substrait::Expression_IfThen)}, - { 168, -1, sizeof(::io::substrait::Expression_SwitchExpression_IfValue)}, - { 175, -1, sizeof(::io::substrait::Expression_SwitchExpression)}, - { 182, -1, sizeof(::io::substrait::Expression_SingularOrList)}, - { 189, -1, sizeof(::io::substrait::Expression_MultiOrList_Record)}, - { 195, -1, sizeof(::io::substrait::Expression_MultiOrList)}, - { 202, -1, sizeof(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction)}, - { 209, -1, sizeof(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction)}, - { 216, -1, sizeof(::io::substrait::Expression_EmbeddedFunction)}, - { 226, -1, sizeof(::io::substrait::Expression)}, + { 168, -1, sizeof(::io::substrait::Expression_Cast)}, + { 175, -1, sizeof(::io::substrait::Expression_SwitchExpression_IfValue)}, + { 182, -1, sizeof(::io::substrait::Expression_SwitchExpression)}, + { 189, -1, sizeof(::io::substrait::Expression_SingularOrList)}, + { 196, -1, sizeof(::io::substrait::Expression_MultiOrList_Record)}, + { 202, -1, sizeof(::io::substrait::Expression_MultiOrList)}, + { 209, -1, sizeof(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction)}, + { 216, -1, sizeof(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction)}, + { 223, -1, sizeof(::io::substrait::Expression_EmbeddedFunction)}, + { 233, -1, sizeof(::io::substrait::Expression_ReferenceSegment_MapKey)}, + { 240, -1, sizeof(::io::substrait::Expression_ReferenceSegment_StructField)}, + { 247, -1, sizeof(::io::substrait::Expression_ReferenceSegment_ListElement)}, + { 254, -1, sizeof(::io::substrait::Expression_ReferenceSegment)}, + { 263, -1, sizeof(::io::substrait::Expression_MaskExpression_Select)}, + { 272, -1, sizeof(::io::substrait::Expression_MaskExpression_StructSelect)}, + { 278, -1, sizeof(::io::substrait::Expression_MaskExpression_StructItem)}, + { 285, -1, sizeof(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement)}, + { 291, -1, sizeof(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice)}, + { 298, -1, sizeof(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem)}, + { 306, -1, sizeof(::io::substrait::Expression_MaskExpression_ListSelect)}, + { 313, -1, sizeof(::io::substrait::Expression_MaskExpression_MapSelect_MapKey)}, + { 319, -1, sizeof(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression)}, + { 325, -1, sizeof(::io::substrait::Expression_MaskExpression_MapSelect)}, + { 334, -1, sizeof(::io::substrait::Expression_MaskExpression)}, + { 341, -1, sizeof(::io::substrait::Expression_FieldReference_RootReference)}, + { 346, -1, sizeof(::io::substrait::Expression_FieldReference)}, + { 357, -1, sizeof(::io::substrait::Expression)}, + { 373, -1, sizeof(::io::substrait::SortField)}, + { 382, -1, sizeof(::io::substrait::AggregateFunction)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { reinterpret_cast(&::io::substrait::_Expression_Enum_Empty_default_instance_), reinterpret_cast(&::io::substrait::_Expression_Enum_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Literal_VarChar_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Literal_Decimal_default_instance_), reinterpret_cast(&::io::substrait::_Expression_Literal_Map_KeyValue_default_instance_), reinterpret_cast(&::io::substrait::_Expression_Literal_Map_default_instance_), reinterpret_cast(&::io::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_), @@ -684,16 +1112,15 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::io::substrait::_Expression_Literal_List_default_instance_), reinterpret_cast(&::io::substrait::_Expression_Literal_default_instance_), reinterpret_cast(&::io::substrait::_Expression_ScalarFunction_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_AggregateFunction_default_instance_), reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_), reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_Following_default_instance_), reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_), reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_), reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_default_instance_), reinterpret_cast(&::io::substrait::_Expression_WindowFunction_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_SortField_default_instance_), reinterpret_cast(&::io::substrait::_Expression_IfThen_IfClause_default_instance_), reinterpret_cast(&::io::substrait::_Expression_IfThen_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_Cast_default_instance_), reinterpret_cast(&::io::substrait::_Expression_SwitchExpression_IfValue_default_instance_), reinterpret_cast(&::io::substrait::_Expression_SwitchExpression_default_instance_), reinterpret_cast(&::io::substrait::_Expression_SingularOrList_default_instance_), @@ -702,141 +1129,220 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::io::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_), reinterpret_cast(&::io::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_), reinterpret_cast(&::io::substrait::_Expression_EmbeddedFunction_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_ReferenceSegment_MapKey_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_ReferenceSegment_StructField_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_ReferenceSegment_ListElement_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_ReferenceSegment_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_Select_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_StructSelect_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_StructItem_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_ListSelect_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_MapSelect_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_MaskExpression_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_FieldReference_RootReference_default_instance_), + reinterpret_cast(&::io::substrait::_Expression_FieldReference_default_instance_), reinterpret_cast(&::io::substrait::_Expression_default_instance_), + reinterpret_cast(&::io::substrait::_SortField_default_instance_), + reinterpret_cast(&::io::substrait::_AggregateFunction_default_instance_), }; const char descriptor_table_protodef_expression_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\020expression.proto\022\014io.substrait\032\ntype.p" - "roto\032\017selection.proto\032\020extensions.proto\"" - "\316$\n\nExpression\0223\n\007literal\030\001 \001(\0132 .io.sub" - "strait.Expression.LiteralH\000\0221\n\tselection" - "\030\002 \001(\0132\034.io.substrait.FieldReferenceH\000\022B" - "\n\017scalar_function\030\003 \001(\0132\'.io.substrait.E" - "xpression.ScalarFunctionH\000\022B\n\017window_fun" - "ction\030\005 \001(\0132\'.io.substrait.Expression.Wi" - "ndowFunctionH\000\0222\n\007if_then\030\006 \001(\0132\037.io.sub" - "strait.Expression.IfThenH\000\022F\n\021switch_exp" - "ression\030\007 \001(\0132).io.substrait.Expression." - "SwitchExpressionH\000\022C\n\020singular_or_list\030\010" - " \001(\0132\'.io.substrait.Expression.SingularO" - "rListH\000\022=\n\rmulti_or_list\030\t \001(\0132$.io.subs" - "trait.Expression.MultiOrListH\000\022-\n\004enum\030\n" - " \001(\0132\035.io.substrait.Expression.EnumH\000\032m\n" - "\004Enum\022\023\n\tspecified\030\001 \001(\tH\000\022:\n\013unspecifie" - "d\030\002 \001(\0132#.io.substrait.Expression.Enum.E" - "mptyH\000\032\007\n\005EmptyB\013\n\tenum_kind\032\361\010\n\007Literal" - "\022\021\n\007boolean\030\001 \001(\010H\000\022\014\n\002i8\030\002 \001(\005H\000\022\r\n\003i16" - "\030\003 \001(\005H\000\022\r\n\003i32\030\005 \001(\005H\000\022\r\n\003i64\030\007 \001(\003H\000\022\016" - "\n\004fp32\030\n \001(\002H\000\022\016\n\004fp64\030\013 \001(\001H\000\022\020\n\006string" - "\030\014 \001(\tH\000\022\020\n\006binary\030\r \001(\014H\000\022\023\n\ttimestamp\030" - "\016 \001(\006H\000\022\016\n\004date\030\020 \001(\007H\000\022\016\n\004time\030\021 \001(\004H\000\022" - "V\n\026interval_year_to_month\030\023 \001(\01324.io.sub" - "strait.Expression.Literal.IntervalYearTo" - "MonthH\000\022V\n\026interval_day_to_second\030\024 \001(\0132" - "4.io.substrait.Expression.Literal.Interv" - "alDayToSecondH\000\022\024\n\nfixed_char\030\025 \001(\tH\000\022\022\n" - "\010var_char\030\026 \001(\tH\000\022\026\n\014fixed_binary\030\027 \001(\014H" - "\000\022\021\n\007decimal\030\030 \001(\014H\000\0229\n\006struct\030\031 \001(\0132\'.i" - "o.substrait.Expression.Literal.StructH\000\022" - "3\n\003map\030\032 \001(\0132$.io.substrait.Expression.L" - "iteral.MapH\000\022\026\n\014timestamp_tz\030\033 \001(\006H\000\022\016\n\004" - "uuid\030\034 \001(\014H\000\022\"\n\004null\030\035 \001(\0132\022.io.substrai" - "t.TypeH\000\0225\n\004list\030\036 \001(\0132%.io.substrait.Ex" - "pression.Literal.ListH\000\032\264\001\n\003Map\022A\n\nkey_v" - "alues\030\001 \003(\0132-.io.substrait.Expression.Li" - "teral.Map.KeyValue\032j\n\010KeyValue\022-\n\003key\030\001 " - "\001(\0132 .io.substrait.Expression.Literal\022/\n" - "\005value\030\002 \001(\0132 .io.substrait.Expression.L" - "iteral\0324\n\023IntervalYearToMonth\022\r\n\005years\030\001" - " \001(\005\022\016\n\006months\030\002 \001(\005\0324\n\023IntervalDayToSec" - "ond\022\014\n\004days\030\001 \001(\005\022\017\n\007seconds\030\002 \001(\005\032:\n\006St" - "ruct\0220\n\006fields\030\001 \003(\0132 .io.substrait.Expr" - "ession.Literal\0328\n\004List\0220\n\006values\030\001 \003(\0132 " - ".io.substrait.Expression.LiteralB\016\n\014lite" - "ral_type\032\222\001\n\016ScalarFunction\022/\n\002id\030\001 \001(\0132" - "#.io.substrait.Extensions.FunctionId\022&\n\004" - "args\030\002 \003(\0132\030.io.substrait.Expression\022\'\n\013" - "output_type\030\003 \001(\0132\022.io.substrait.Type\032\202\002" - "\n\021AggregateFunction\022/\n\002id\030\001 \001(\0132#.io.sub" - "strait.Extensions.FunctionId\022&\n\004args\030\002 \003" - "(\0132\030.io.substrait.Expression\0221\n\005sorts\030\003 " - "\003(\0132\".io.substrait.Expression.SortField\022" - "8\n\005phase\030\004 \001(\0162).io.substrait.Expression" - ".AggregationPhase\022\'\n\013output_type\030\005 \001(\0132\022" - ".io.substrait.Type\032\327\006\n\016WindowFunction\022/\n" - "\002id\030\001 \001(\0132#.io.substrait.Extensions.Func" - "tionId\022,\n\npartitions\030\002 \003(\0132\030.io.substrai" - "t.Expression\0221\n\005sorts\030\003 \003(\0132\".io.substra" - "it.Expression.SortField\022B\n\013upper_bound\030\004" - " \001(\0132-.io.substrait.Expression.WindowFun" - "ction.Bound\022B\n\013lower_bound\030\005 \001(\0132-.io.su" - "bstrait.Expression.WindowFunction.Bound\022" - "8\n\005phase\030\006 \001(\0162).io.substrait.Expression" - ".AggregationPhase\022\'\n\013output_type\030\007 \001(\0132\022" - ".io.substrait.Type\022&\n\004args\030\010 \003(\0132\030.io.su" - "bstrait.Expression\032\237\003\n\005Bound\022L\n\tprecedin" - "g\030\001 \001(\01327.io.substrait.Expression.Window" - "Function.Bound.PrecedingH\000\022L\n\tfollowing\030" - "\002 \001(\01327.io.substrait.Expression.WindowFu" - "nction.Bound.FollowingH\000\022O\n\013current_row\030" - "\003 \001(\01328.io.substrait.Expression.WindowFu" - "nction.Bound.CurrentRowH\000\022L\n\tunbounded\030\004" - " \001(\01327.io.substrait.Expression.WindowFun" - "ction.Bound.UnboundedH\000\032\033\n\tPreceding\022\016\n\006" - "offset\030\001 \001(\003\032\033\n\tFollowing\022\016\n\006offset\030\001 \001(" - "\003\032\014\n\nCurrentRow\032\013\n\tUnboundedB\006\n\004kind\032\314\002\n" - "\tSortField\022&\n\004expr\030\001 \001(\0132\030.io.substrait." - "Expression\022E\n\tdirection\030\002 \001(\01620.io.subst" - "rait.Expression.SortField.SortDirectionH" - "\000\022B\n\023comparison_function\030\003 \001(\0132#.io.subs" - "trait.Extensions.FunctionIdH\000\"\177\n\rSortDir" - "ection\022\013\n\007UNKNOWN\020\000\022\023\n\017ASC_NULLS_FIRST\020\001" - "\022\022\n\016ASC_NULLS_LAST\020\002\022\024\n\020DESC_NULLS_FIRST" - "\020\003\022\023\n\017DESC_NULLS_LAST\020\004\022\r\n\tCLUSTERED\020\005B\013" - "\n\tsort_kind\032\301\001\n\006IfThen\0225\n\003ifs\030\001 \003(\0132(.io" - ".substrait.Expression.IfThen.IfClause\022&\n" - "\004else\030\002 \001(\0132\030.io.substrait.Expression\032X\n" - "\010IfClause\022$\n\002if\030\001 \001(\0132\030.io.substrait.Exp" - "ression\022&\n\004then\030\002 \001(\0132\030.io.substrait.Exp" - "ression\032\323\001\n\020SwitchExpression\022>\n\003ifs\030\001 \003(" - "\01321.io.substrait.Expression.SwitchExpres" - "sion.IfValue\022&\n\004else\030\002 \001(\0132\030.io.substrai" - "t.Expression\032W\n\007IfValue\022$\n\002if\030\001 \001(\0132\030.io" - ".substrait.Expression\022&\n\004then\030\002 \001(\0132\030.io" - ".substrait.Expression\032d\n\016SingularOrList\022" - "\'\n\005value\030\001 \001(\0132\030.io.substrait.Expression" - "\022)\n\007options\030\002 \003(\0132\030.io.substrait.Express" - "ion\032\250\001\n\013MultiOrList\022\'\n\005value\030\001 \003(\0132\030.io." - "substrait.Expression\022<\n\007options\030\002 \003(\0132+." - "io.substrait.Expression.MultiOrList.Reco" - "rd\0322\n\006Record\022(\n\006fields\030\001 \003(\0132\030.io.substr" - "ait.Expression\032\257\003\n\020EmbeddedFunction\022+\n\ta" - "rguments\030\001 \003(\0132\030.io.substrait.Expression" - "\022\'\n\013output_type\030\002 \001(\0132\022.io.substrait.Typ" - "e\022`\n\026python_pickle_function\030\003 \001(\0132>.io.s" - "ubstrait.Expression.EmbeddedFunction.Pyt" - "honPickleFunctionH\000\022^\n\025web_assembly_func" - "tion\030\004 \001(\0132=.io.substrait.Expression.Emb" - "eddedFunction.WebAssemblyFunctionH\000\032>\n\024P" - "ythonPickleFunction\022\020\n\010function\030\001 \001(\014\022\024\n" - "\014prerequisite\030\002 \003(\t\032;\n\023WebAssemblyFuncti" - "on\022\016\n\006script\030\001 \001(\014\022\024\n\014prerequisite\030\002 \003(\t" - "B\006\n\004kind\"\221\001\n\020AggregationPhase\022\013\n\007UNKNOWN" - "\020\000\022\033\n\027INITIAL_TO_INTERMEDIATE\020\001\022 \n\034INTER" - "MEDIATE_TO_INTERMEDIATE\020\002\022\025\n\021INITIAL_TO_" - "RESULT\020\003\022\032\n\026INTERMEDIATE_TO_RESULT\020\004B\n\n\010" - "rex_typeB\027P\001\252\002\022Substrait.Protobufb\006proto" - "3" + "roto\"\2323\n\nExpression\0223\n\007literal\030\001 \001(\0132 .i" + "o.substrait.Expression.LiteralH\000\022<\n\tsele" + "ction\030\002 \001(\0132\'.io.substrait.Expression.Fi" + "eldReferenceH\000\022B\n\017scalar_function\030\003 \001(\0132" + "\'.io.substrait.Expression.ScalarFunction" + "H\000\022B\n\017window_function\030\005 \001(\0132\'.io.substra" + "it.Expression.WindowFunctionH\000\0222\n\007if_the" + "n\030\006 \001(\0132\037.io.substrait.Expression.IfThen" + "H\000\022F\n\021switch_expression\030\007 \001(\0132).io.subst" + "rait.Expression.SwitchExpressionH\000\022C\n\020si" + "ngular_or_list\030\010 \001(\0132\'.io.substrait.Expr" + "ession.SingularOrListH\000\022=\n\rmulti_or_list" + "\030\t \001(\0132$.io.substrait.Expression.MultiOr" + "ListH\000\022-\n\004enum\030\n \001(\0132\035.io.substrait.Expr" + "ession.EnumH\000\022-\n\004cast\030\013 \001(\0132\035.io.substra" + "it.Expression.CastH\000\032m\n\004Enum\022\023\n\tspecifie" + "d\030\001 \001(\tH\000\022:\n\013unspecified\030\002 \001(\0132#.io.subs" + "trait.Expression.Enum.EmptyH\000\032\007\n\005EmptyB\013" + "\n\tenum_kind\032\265\013\n\007Literal\022\021\n\007boolean\030\001 \001(\010" + "H\000\022\014\n\002i8\030\002 \001(\005H\000\022\r\n\003i16\030\003 \001(\005H\000\022\r\n\003i32\030\005" + " \001(\005H\000\022\r\n\003i64\030\007 \001(\003H\000\022\016\n\004fp32\030\n \001(\002H\000\022\016\n" + "\004fp64\030\013 \001(\001H\000\022\020\n\006string\030\014 \001(\tH\000\022\020\n\006binar" + "y\030\r \001(\014H\000\022\023\n\ttimestamp\030\016 \001(\003H\000\022\016\n\004date\030\020" + " \001(\003H\000\022\016\n\004time\030\021 \001(\003H\000\022V\n\026interval_year_" + "to_month\030\023 \001(\01324.io.substrait.Expression" + ".Literal.IntervalYearToMonthH\000\022V\n\026interv" + "al_day_to_second\030\024 \001(\01324.io.substrait.Ex" + "pression.Literal.IntervalDayToSecondH\000\022\024" + "\n\nfixed_char\030\025 \001(\tH\000\022<\n\010var_char\030\026 \001(\0132(" + ".io.substrait.Expression.Literal.VarChar" + "H\000\022\026\n\014fixed_binary\030\027 \001(\014H\000\022;\n\007decimal\030\030 " + "\001(\0132(.io.substrait.Expression.Literal.De" + "cimalH\000\0229\n\006struct\030\031 \001(\0132\'.io.substrait.E" + "xpression.Literal.StructH\000\0223\n\003map\030\032 \001(\0132" + "$.io.substrait.Expression.Literal.MapH\000\022" + "\026\n\014timestamp_tz\030\033 \001(\003H\000\022\016\n\004uuid\030\034 \001(\014H\000\022" + "\"\n\004null\030\035 \001(\0132\022.io.substrait.TypeH\000\0225\n\004l" + "ist\030\036 \001(\0132%.io.substrait.Expression.Lite" + "ral.ListH\000\022\020\n\010nullable\0302 \001(\010\032(\n\007VarChar\022" + "\r\n\005value\030\001 \001(\t\022\016\n\006length\030\002 \001(\r\032:\n\007Decima" + "l\022\r\n\005value\030\001 \001(\014\022\021\n\tprecision\030\002 \001(\005\022\r\n\005s" + "cale\030\003 \001(\005\032\202\002\n\003Map\022A\n\nkey_values\030\001 \003(\0132-" + ".io.substrait.Expression.Literal.Map.Key" + "Value\022$\n\010key_type\030\002 \001(\0132\022.io.substrait.T" + "ype\022&\n\nvalue_type\030\003 \001(\0132\022.io.substrait.T" + "ype\032j\n\010KeyValue\022-\n\003key\030\001 \001(\0132 .io.substr" + "ait.Expression.Literal\022/\n\005value\030\002 \001(\0132 ." + "io.substrait.Expression.Literal\0324\n\023Inter" + "valYearToMonth\022\r\n\005years\030\001 \001(\005\022\016\n\006months\030" + "\002 \001(\005\0324\n\023IntervalDayToSecond\022\014\n\004days\030\001 \001" + "(\005\022\017\n\007seconds\030\002 \001(\005\032:\n\006Struct\0220\n\006fields\030" + "\001 \003(\0132 .io.substrait.Expression.Literal\032" + "b\n\004List\0220\n\006values\030\001 \003(\0132 .io.substrait.E" + "xpression.Literal\022(\n\014element_type\030\002 \001(\0132" + "\022.io.substrait.TypeB\016\n\014literal_type\032}\n\016S" + "calarFunction\022\032\n\022function_reference\030\001 \001(" + "\r\022&\n\004args\030\002 \003(\0132\030.io.substrait.Expressio" + "n\022\'\n\013output_type\030\003 \001(\0132\022.io.substrait.Ty" + "pe\032\254\006\n\016WindowFunction\022\032\n\022function_refere" + "nce\030\001 \001(\r\022,\n\npartitions\030\002 \003(\0132\030.io.subst" + "rait.Expression\022&\n\005sorts\030\003 \003(\0132\027.io.subs" + "trait.SortField\022B\n\013upper_bound\030\004 \001(\0132-.i" + "o.substrait.Expression.WindowFunction.Bo" + "und\022B\n\013lower_bound\030\005 \001(\0132-.io.substrait." + "Expression.WindowFunction.Bound\022-\n\005phase" + "\030\006 \001(\0162\036.io.substrait.AggregationPhase\022\'" + "\n\013output_type\030\007 \001(\0132\022.io.substrait.Type\022" + "&\n\004args\030\010 \003(\0132\030.io.substrait.Expression\032" + "\237\003\n\005Bound\022L\n\tpreceding\030\001 \001(\01327.io.substr" + "ait.Expression.WindowFunction.Bound.Prec" + "edingH\000\022L\n\tfollowing\030\002 \001(\01327.io.substrai" + "t.Expression.WindowFunction.Bound.Follow" + "ingH\000\022O\n\013current_row\030\003 \001(\01328.io.substrai" + "t.Expression.WindowFunction.Bound.Curren" + "tRowH\000\022L\n\tunbounded\030\004 \001(\01327.io.substrait" + ".Expression.WindowFunction.Bound.Unbound" + "edH\000\032\033\n\tPreceding\022\016\n\006offset\030\001 \001(\003\032\033\n\tFol" + "lowing\022\016\n\006offset\030\001 \001(\003\032\014\n\nCurrentRow\032\013\n\t" + "UnboundedB\006\n\004kind\032\301\001\n\006IfThen\0225\n\003ifs\030\001 \003(" + "\0132(.io.substrait.Expression.IfThen.IfCla" + "use\022&\n\004else\030\002 \001(\0132\030.io.substrait.Express" + "ion\032X\n\010IfClause\022$\n\002if\030\001 \001(\0132\030.io.substra" + "it.Expression\022&\n\004then\030\002 \001(\0132\030.io.substra" + "it.Expression\032Q\n\004Cast\022 \n\004type\030\001 \001(\0132\022.io" + ".substrait.Type\022\'\n\005input\030\002 \001(\0132\030.io.subs" + "trait.Expression\032\333\001\n\020SwitchExpression\022>\n" + "\003ifs\030\001 \003(\01321.io.substrait.Expression.Swi" + "tchExpression.IfValue\022&\n\004else\030\002 \001(\0132\030.io" + ".substrait.Expression\032_\n\007IfValue\022,\n\002if\030\001" + " \001(\0132 .io.substrait.Expression.Literal\022&" + "\n\004then\030\002 \001(\0132\030.io.substrait.Expression\032d" + "\n\016SingularOrList\022\'\n\005value\030\001 \001(\0132\030.io.sub" + "strait.Expression\022)\n\007options\030\002 \003(\0132\030.io." + "substrait.Expression\032\250\001\n\013MultiOrList\022\'\n\005" + "value\030\001 \003(\0132\030.io.substrait.Expression\022<\n" + "\007options\030\002 \003(\0132+.io.substrait.Expression" + ".MultiOrList.Record\0322\n\006Record\022(\n\006fields\030" + "\001 \003(\0132\030.io.substrait.Expression\032\257\003\n\020Embe" + "ddedFunction\022+\n\targuments\030\001 \003(\0132\030.io.sub" + "strait.Expression\022\'\n\013output_type\030\002 \001(\0132\022" + ".io.substrait.Type\022`\n\026python_pickle_func" + "tion\030\003 \001(\0132>.io.substrait.Expression.Emb" + "eddedFunction.PythonPickleFunctionH\000\022^\n\025" + "web_assembly_function\030\004 \001(\0132=.io.substra" + "it.Expression.EmbeddedFunction.WebAssemb" + "lyFunctionH\000\032>\n\024PythonPickleFunction\022\020\n\010" + "function\030\001 \001(\014\022\024\n\014prerequisite\030\002 \003(\t\032;\n\023" + "WebAssemblyFunction\022\016\n\006script\030\001 \001(\014\022\024\n\014p" + "rerequisite\030\002 \003(\tB\006\n\004kind\032\257\004\n\020ReferenceS" + "egment\022C\n\007map_key\030\001 \001(\01320.io.substrait.E" + "xpression.ReferenceSegment.MapKeyH\000\022M\n\014s" + "truct_field\030\002 \001(\01325.io.substrait.Express" + "ion.ReferenceSegment.StructFieldH\000\022M\n\014li" + "st_element\030\003 \001(\01325.io.substrait.Expressi" + "on.ReferenceSegment.ListElementH\000\032u\n\006Map" + "Key\0221\n\007map_key\030\001 \001(\0132 .io.substrait.Expr" + "ession.Literal\0228\n\005child\030\002 \001(\0132).io.subst" + "rait.Expression.ReferenceSegment\032V\n\013Stru" + "ctField\022\r\n\005field\030\001 \001(\005\0228\n\005child\030\002 \001(\0132)." + "io.substrait.Expression.ReferenceSegment" + "\032W\n\013ListElement\022\016\n\006offset\030\001 \001(\005\0228\n\005child" + "\030\002 \001(\0132).io.substrait.Expression.Referen" + "ceSegmentB\020\n\016reference_type\032\227\n\n\016MaskExpr" + "ession\022D\n\006select\030\001 \001(\01324.io.substrait.Ex" + "pression.MaskExpression.StructSelect\022 \n\030" + "maintain_singular_struct\030\002 \001(\010\032\336\001\n\006Selec" + "t\022F\n\006struct\030\001 \001(\01324.io.substrait.Express" + "ion.MaskExpression.StructSelectH\000\022B\n\004lis" + "t\030\002 \001(\01322.io.substrait.Expression.MaskEx" + "pression.ListSelectH\000\022@\n\003map\030\003 \001(\01321.io." + "substrait.Expression.MaskExpression.MapS" + "electH\000B\006\n\004type\032X\n\014StructSelect\022H\n\014struc" + "t_items\030\001 \003(\01322.io.substrait.Expression." + "MaskExpression.StructItem\032Z\n\nStructItem\022" + "\r\n\005field\030\001 \001(\005\022=\n\005child\030\002 \001(\0132..io.subst" + "rait.Expression.MaskExpression.Select\032\300\003" + "\n\nListSelect\022T\n\tselection\030\001 \003(\0132A.io.sub" + "strait.Expression.MaskExpression.ListSel" + "ect.ListSelectItem\022=\n\005child\030\002 \001(\0132..io.s" + "ubstrait.Expression.MaskExpression.Selec" + "t\032\234\002\n\016ListSelectItem\022]\n\004item\030\001 \001(\0132M.io." + "substrait.Expression.MaskExpression.List" + "Select.ListSelectItem.ListElementH\000\022\\\n\005s" + "lice\030\002 \001(\0132K.io.substrait.Expression.Mas" + "kExpression.ListSelect.ListSelectItem.Li" + "stSliceH\000\032\034\n\013ListElement\022\r\n\005field\030\001 \001(\005\032" + "\'\n\tListSlice\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002 \001(\005" + "B\006\n\004type\032\302\002\n\tMapSelect\022G\n\003key\030\001 \001(\01328.io" + ".substrait.Expression.MaskExpression.Map" + "Select.MapKeyH\000\022X\n\nexpression\030\002 \001(\0132B.io" + ".substrait.Expression.MaskExpression.Map" + "Select.MapKeyExpressionH\000\022=\n\005child\030\003 \001(\013" + "2..io.substrait.Expression.MaskExpressio" + "n.Select\032\031\n\006MapKey\022\017\n\007map_key\030\001 \001(\t\032.\n\020M" + "apKeyExpression\022\032\n\022map_key_expression\030\001 " + "\001(\tB\010\n\006select\032\315\002\n\016FieldReference\022E\n\020dire" + "ct_reference\030\001 \001(\0132).io.substrait.Expres" + "sion.ReferenceSegmentH\000\022C\n\020masked_refere" + "nce\030\002 \001(\0132\'.io.substrait.Expression.Mask" + "ExpressionH\000\022.\n\nexpression\030\003 \001(\0132\030.io.su" + "bstrait.ExpressionH\001\022O\n\016root_reference\030\004" + " \001(\01325.io.substrait.Expression.FieldRefe" + "rence.RootReferenceH\001\032\017\n\rRootReferenceB\020" + "\n\016reference_typeB\013\n\troot_typeB\n\n\010rex_typ" + "e\"\246\002\n\tSortField\022&\n\004expr\030\001 \001(\0132\030.io.subst" + "rait.Expression\022:\n\tdirection\030\002 \001(\0162%.io." + "substrait.SortField.SortDirectionH\000\022\'\n\035c" + "omparison_function_reference\030\003 \001(\rH\000\"\177\n\r" + "SortDirection\022\013\n\007UNKNOWN\020\000\022\023\n\017ASC_NULLS_" + "FIRST\020\001\022\022\n\016ASC_NULLS_LAST\020\002\022\024\n\020DESC_NULL" + "S_FIRST\020\003\022\023\n\017DESC_NULLS_LAST\020\004\022\r\n\tCLUSTE" + "RED\020\005B\013\n\tsort_kind\"\327\001\n\021AggregateFunction" + "\022\032\n\022function_reference\030\001 \001(\r\022&\n\004args\030\002 \003" + "(\0132\030.io.substrait.Expression\022&\n\005sorts\030\003 " + "\003(\0132\027.io.substrait.SortField\022-\n\005phase\030\004 " + "\001(\0162\036.io.substrait.AggregationPhase\022\'\n\013o" + "utput_type\030\005 \001(\0132\022.io.substrait.Type*\221\001\n" + "\020AggregationPhase\022\013\n\007UNKNOWN\020\000\022\033\n\027INITIA" + "L_TO_INTERMEDIATE\020\001\022 \n\034INTERMEDIATE_TO_I" + "NTERMEDIATE\020\002\022\025\n\021INITIAL_TO_RESULT\020\003\022\032\n\026" + "INTERMEDIATE_TO_RESULT\020\004B+\n\022io.substrait" + ".protoP\001\252\002\022Substrait.Protobufb\006proto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_expression_2eproto_deps[3] = { - &::descriptor_table_extensions_2eproto, - &::descriptor_table_selection_2eproto, +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_expression_2eproto_deps[1] = { &::descriptor_table_type_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_expression_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_expression_2eproto = { - false, false, 4801, descriptor_table_protodef_expression_2eproto, "expression.proto", - &descriptor_table_expression_2eproto_once, descriptor_table_expression_2eproto_deps, 3, 29, + false, false, 7317, descriptor_table_protodef_expression_2eproto, "expression.proto", + &descriptor_table_expression_2eproto_once, descriptor_table_expression_2eproto_deps, 1, 49, schemas, file_default_instances, TableStruct_expression_2eproto::offsets, file_level_metadata_expression_2eproto, file_level_enum_descriptors_expression_2eproto, file_level_service_descriptors_expression_2eproto, }; @@ -848,11 +1354,11 @@ PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_expression_2eproto(&descriptor_table_expression_2eproto); namespace io { namespace substrait { -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_SortField_SortDirection_descriptor() { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortField_SortDirection_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_expression_2eproto); return file_level_enum_descriptors_expression_2eproto[0]; } -bool Expression_SortField_SortDirection_IsValid(int value) { +bool SortField_SortDirection_IsValid(int value) { switch (value) { case 0: case 1: @@ -867,21 +1373,21 @@ bool Expression_SortField_SortDirection_IsValid(int value) { } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr Expression_SortField_SortDirection Expression_SortField::UNKNOWN; -constexpr Expression_SortField_SortDirection Expression_SortField::ASC_NULLS_FIRST; -constexpr Expression_SortField_SortDirection Expression_SortField::ASC_NULLS_LAST; -constexpr Expression_SortField_SortDirection Expression_SortField::DESC_NULLS_FIRST; -constexpr Expression_SortField_SortDirection Expression_SortField::DESC_NULLS_LAST; -constexpr Expression_SortField_SortDirection Expression_SortField::CLUSTERED; -constexpr Expression_SortField_SortDirection Expression_SortField::SortDirection_MIN; -constexpr Expression_SortField_SortDirection Expression_SortField::SortDirection_MAX; -constexpr int Expression_SortField::SortDirection_ARRAYSIZE; +constexpr SortField_SortDirection SortField::UNKNOWN; +constexpr SortField_SortDirection SortField::ASC_NULLS_FIRST; +constexpr SortField_SortDirection SortField::ASC_NULLS_LAST; +constexpr SortField_SortDirection SortField::DESC_NULLS_FIRST; +constexpr SortField_SortDirection SortField::DESC_NULLS_LAST; +constexpr SortField_SortDirection SortField::CLUSTERED; +constexpr SortField_SortDirection SortField::SortDirection_MIN; +constexpr SortField_SortDirection SortField::SortDirection_MAX; +constexpr int SortField::SortDirection_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_AggregationPhase_descriptor() { +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggregationPhase_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_expression_2eproto); return file_level_enum_descriptors_expression_2eproto[1]; } -bool Expression_AggregationPhase_IsValid(int value) { +bool AggregationPhase_IsValid(int value) { switch (value) { case 0: case 1: @@ -894,16 +1400,6 @@ bool Expression_AggregationPhase_IsValid(int value) { } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr Expression_AggregationPhase Expression::UNKNOWN; -constexpr Expression_AggregationPhase Expression::INITIAL_TO_INTERMEDIATE; -constexpr Expression_AggregationPhase Expression::INTERMEDIATE_TO_INTERMEDIATE; -constexpr Expression_AggregationPhase Expression::INITIAL_TO_RESULT; -constexpr Expression_AggregationPhase Expression::INTERMEDIATE_TO_RESULT; -constexpr Expression_AggregationPhase Expression::AggregationPhase_MIN; -constexpr Expression_AggregationPhase Expression::AggregationPhase_MAX; -constexpr int Expression::AggregationPhase_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) // =================================================================== @@ -1356,105 +1852,84 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum::GetMetadata() const { // =================================================================== -class Expression_Literal_Map_KeyValue::_Internal { +class Expression_Literal_VarChar::_Internal { public: - static const ::io::substrait::Expression_Literal& key(const Expression_Literal_Map_KeyValue* msg); - static const ::io::substrait::Expression_Literal& value(const Expression_Literal_Map_KeyValue* msg); }; -const ::io::substrait::Expression_Literal& -Expression_Literal_Map_KeyValue::_Internal::key(const Expression_Literal_Map_KeyValue* msg) { - return *msg->key_; -} -const ::io::substrait::Expression_Literal& -Expression_Literal_Map_KeyValue::_Internal::value(const Expression_Literal_Map_KeyValue* msg) { - return *msg->value_; -} -Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena) +Expression_Literal_VarChar::Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.VarChar) } -Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from) +Expression_Literal_VarChar::Expression_Literal_VarChar(const Expression_Literal_VarChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key()) { - key_ = new ::io::substrait::Expression_Literal(*from.key_); - } else { - key_ = nullptr; - } - if (from._internal_has_value()) { - value_ = new ::io::substrait::Expression_Literal(*from.value_); - } else { - value_ = nullptr; + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_value().empty()) { + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), + GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Map.KeyValue) + length_ = from.length_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.VarChar) } -void Expression_Literal_Map_KeyValue::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&key_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&value_) - - reinterpret_cast(&key_)) + sizeof(value_)); +void Expression_Literal_VarChar::SharedCtor() { +value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +length_ = 0u; } -Expression_Literal_Map_KeyValue::~Expression_Literal_Map_KeyValue() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Map.KeyValue) +Expression_Literal_VarChar::~Expression_Literal_VarChar() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.VarChar) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_Map_KeyValue::SharedDtor() { +void Expression_Literal_VarChar::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete key_; - if (this != internal_default_instance()) delete value_; + value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -void Expression_Literal_Map_KeyValue::ArenaDtor(void* object) { - Expression_Literal_Map_KeyValue* _this = reinterpret_cast< Expression_Literal_Map_KeyValue* >(object); +void Expression_Literal_VarChar::ArenaDtor(void* object) { + Expression_Literal_VarChar* _this = reinterpret_cast< Expression_Literal_VarChar* >(object); (void)_this; } -void Expression_Literal_Map_KeyValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void Expression_Literal_VarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_Literal_Map_KeyValue::SetCachedSize(int size) const { +void Expression_Literal_VarChar::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression_Literal_Map_KeyValue::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Map.KeyValue) +void Expression_Literal_VarChar::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.VarChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && key_ != nullptr) { - delete key_; - } - key_ = nullptr; - if (GetArena() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; + value_.ClearToEmpty(); + length_ = 0u; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_Literal_Map_KeyValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_Literal_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.Literal key = 1; + // string value = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + auto str = _internal_mutable_value(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.VarChar.value")); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Literal value = 2; + // uint32 length = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1481,56 +1956,56 @@ const char* Expression_Literal_Map_KeyValue::_InternalParse(const char* ptr, ::P #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map_KeyValue::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_VarChar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.VarChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.Literal key = 1; - if (this->has_key()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::key(this), target, stream); + // string value = 1; + if (this->value().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_value().data(), static_cast(this->_internal_value().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.Literal.VarChar.value"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_value(), target); } - // .io.substrait.Expression.Literal value = 2; - if (this->has_value()) { + // uint32 length = 2; + if (this->length() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::value(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_length(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.VarChar) return target; } -size_t Expression_Literal_Map_KeyValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Map.KeyValue) +size_t Expression_Literal_VarChar::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.VarChar) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression.Literal key = 1; - if (this->has_key()) { + // string value = 1; + if (this->value().size() > 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *key_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_value()); } - // .io.substrait.Expression.Literal value = 2; - if (this->has_value()) { + // uint32 length = 2; + if (this->length() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *value_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_length()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1542,66 +2017,62 @@ size_t Expression_Literal_Map_KeyValue::ByteSizeLong() const { return total_size; } -void Expression_Literal_Map_KeyValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Map.KeyValue) +void Expression_Literal_VarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.VarChar) GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_Map_KeyValue* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Expression_Literal_VarChar* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.VarChar) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.VarChar) MergeFrom(*source); } } -void Expression_Literal_Map_KeyValue::MergeFrom(const Expression_Literal_Map_KeyValue& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Map.KeyValue) +void Expression_Literal_VarChar::MergeFrom(const Expression_Literal_VarChar& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.VarChar) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_key()) { - _internal_mutable_key()->::io::substrait::Expression_Literal::MergeFrom(from._internal_key()); + if (from.value().size() > 0) { + _internal_set_value(from._internal_value()); } - if (from.has_value()) { - _internal_mutable_value()->::io::substrait::Expression_Literal::MergeFrom(from._internal_value()); + if (from.length() != 0) { + _internal_set_length(from._internal_length()); } } -void Expression_Literal_Map_KeyValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Map.KeyValue) +void Expression_Literal_VarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.VarChar) if (&from == this) return; Clear(); MergeFrom(from); } -void Expression_Literal_Map_KeyValue::CopyFrom(const Expression_Literal_Map_KeyValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Map.KeyValue) +void Expression_Literal_VarChar::CopyFrom(const Expression_Literal_VarChar& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.VarChar) if (&from == this) return; Clear(); MergeFrom(from); } -bool Expression_Literal_Map_KeyValue::IsInitialized() const { +bool Expression_Literal_VarChar::IsInitialized() const { return true; } -void Expression_Literal_Map_KeyValue::InternalSwap(Expression_Literal_Map_KeyValue* other) { +void Expression_Literal_VarChar::InternalSwap(Expression_Literal_VarChar* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, value_) - + sizeof(Expression_Literal_Map_KeyValue::value_) - - PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, key_)>( - reinterpret_cast(&key_), - reinterpret_cast(&other->key_)); + value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(length_, other->length_); } -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map_KeyValue::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_VarChar::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, file_level_metadata_expression_2eproto[2]); @@ -1609,73 +2080,98 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map_KeyValue::GetMetadata() // =================================================================== -class Expression_Literal_Map::_Internal { +class Expression_Literal_Decimal::_Internal { public: }; -Expression_Literal_Map::Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - key_values_(arena) { +Expression_Literal_Decimal::Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Decimal) } -Expression_Literal_Map::Expression_Literal_Map(const Expression_Literal_Map& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - key_values_(from.key_values_) { +Expression_Literal_Decimal::Expression_Literal_Decimal(const Expression_Literal_Decimal& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Map) + value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_value().empty()) { + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), + GetArena()); + } + ::memcpy(&precision_, &from.precision_, + static_cast(reinterpret_cast(&scale_) - + reinterpret_cast(&precision_)) + sizeof(scale_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Decimal) } -void Expression_Literal_Map::SharedCtor() { +void Expression_Literal_Decimal::SharedCtor() { +value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&precision_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&scale_) - + reinterpret_cast(&precision_)) + sizeof(scale_)); } -Expression_Literal_Map::~Expression_Literal_Map() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Map) +Expression_Literal_Decimal::~Expression_Literal_Decimal() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Decimal) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_Map::SharedDtor() { +void Expression_Literal_Decimal::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); + value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -void Expression_Literal_Map::ArenaDtor(void* object) { - Expression_Literal_Map* _this = reinterpret_cast< Expression_Literal_Map* >(object); +void Expression_Literal_Decimal::ArenaDtor(void* object) { + Expression_Literal_Decimal* _this = reinterpret_cast< Expression_Literal_Decimal* >(object); (void)_this; } -void Expression_Literal_Map::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void Expression_Literal_Decimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_Literal_Map::SetCachedSize(int size) const { +void Expression_Literal_Decimal::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression_Literal_Map::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Map) +void Expression_Literal_Decimal::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Decimal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - key_values_.Clear(); + value_.ClearToEmpty(); + ::memset(&precision_, 0, static_cast( + reinterpret_cast(&scale_) - + reinterpret_cast(&precision_)) + sizeof(scale_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_Literal_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + // bytes value = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_key_values(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + auto str = _internal_mutable_value(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 precision = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 scale = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); } else goto handle_unusual; continue; default: { @@ -1701,41 +2197,65 @@ const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_N #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Decimal::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Decimal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_key_values_size()); i < n; i++) { + // bytes value = 1; + if (this->value().size() > 0) { + target = stream->WriteBytesMaybeAliased( + 1, this->_internal_value(), target); + } + + // int32 precision = 2; + if (this->precision() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_key_values(i), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_precision(), target); + } + + // int32 scale = 3; + if (this->scale() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_scale(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Decimal) return target; } -size_t Expression_Literal_Map::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Map) +size_t Expression_Literal_Decimal::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Decimal) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; - total_size += 1UL * this->_internal_key_values_size(); - for (const auto& msg : this->key_values_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + // bytes value = 1; + if (this->value().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_value()); + } + + // int32 precision = 2; + if (this->precision() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_precision()); + } + + // int32 scale = 3; + if (this->scale() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_scale()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1747,56 +2267,70 @@ size_t Expression_Literal_Map::ByteSizeLong() const { return total_size; } -void Expression_Literal_Map::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Map) +void Expression_Literal_Decimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Decimal) GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_Map* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Expression_Literal_Decimal* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Decimal) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Decimal) MergeFrom(*source); } } -void Expression_Literal_Map::MergeFrom(const Expression_Literal_Map& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Map) +void Expression_Literal_Decimal::MergeFrom(const Expression_Literal_Decimal& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Decimal) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - key_values_.MergeFrom(from.key_values_); + if (from.value().size() > 0) { + _internal_set_value(from._internal_value()); + } + if (from.precision() != 0) { + _internal_set_precision(from._internal_precision()); + } + if (from.scale() != 0) { + _internal_set_scale(from._internal_scale()); + } } -void Expression_Literal_Map::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Map) +void Expression_Literal_Decimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Decimal) if (&from == this) return; Clear(); MergeFrom(from); } -void Expression_Literal_Map::CopyFrom(const Expression_Literal_Map& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Map) +void Expression_Literal_Decimal::CopyFrom(const Expression_Literal_Decimal& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Decimal) if (&from == this) return; Clear(); MergeFrom(from); } -bool Expression_Literal_Map::IsInitialized() const { +bool Expression_Literal_Decimal::IsInitialized() const { return true; } -void Expression_Literal_Map::InternalSwap(Expression_Literal_Map* other) { +void Expression_Literal_Decimal::InternalSwap(Expression_Literal_Decimal* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - key_values_.InternalSwap(&other->key_values_); + value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_Literal_Decimal, scale_) + + sizeof(Expression_Literal_Decimal::scale_) + - PROTOBUF_FIELD_OFFSET(Expression_Literal_Decimal, precision_)>( + reinterpret_cast(&precision_), + reinterpret_cast(&other->precision_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Decimal::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, file_level_metadata_expression_2eproto[3]); @@ -1804,81 +2338,105 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map::GetMetadata() const { // =================================================================== -class Expression_Literal_IntervalYearToMonth::_Internal { +class Expression_Literal_Map_KeyValue::_Internal { public: + static const ::io::substrait::Expression_Literal& key(const Expression_Literal_Map_KeyValue* msg); + static const ::io::substrait::Expression_Literal& value(const Expression_Literal_Map_KeyValue* msg); }; -Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena) +const ::io::substrait::Expression_Literal& +Expression_Literal_Map_KeyValue::_Internal::key(const Expression_Literal_Map_KeyValue* msg) { + return *msg->key_; +} +const ::io::substrait::Expression_Literal& +Expression_Literal_Map_KeyValue::_Internal::value(const Expression_Literal_Map_KeyValue* msg) { + return *msg->value_; +} +Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Map.KeyValue) } -Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from) +Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&years_, &from.years_, - static_cast(reinterpret_cast(&months_) - - reinterpret_cast(&years_)) + sizeof(months_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.IntervalYearToMonth) + if (from._internal_has_key()) { + key_ = new ::io::substrait::Expression_Literal(*from.key_); + } else { + key_ = nullptr; + } + if (from._internal_has_value()) { + value_ = new ::io::substrait::Expression_Literal(*from.value_); + } else { + value_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Map.KeyValue) } -void Expression_Literal_IntervalYearToMonth::SharedCtor() { +void Expression_Literal_Map_KeyValue::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&years_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&months_) - - reinterpret_cast(&years_)) + sizeof(months_)); + reinterpret_cast(&key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&value_) - + reinterpret_cast(&key_)) + sizeof(value_)); } -Expression_Literal_IntervalYearToMonth::~Expression_Literal_IntervalYearToMonth() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.IntervalYearToMonth) +Expression_Literal_Map_KeyValue::~Expression_Literal_Map_KeyValue() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Map.KeyValue) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_IntervalYearToMonth::SharedDtor() { +void Expression_Literal_Map_KeyValue::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete key_; + if (this != internal_default_instance()) delete value_; } -void Expression_Literal_IntervalYearToMonth::ArenaDtor(void* object) { - Expression_Literal_IntervalYearToMonth* _this = reinterpret_cast< Expression_Literal_IntervalYearToMonth* >(object); +void Expression_Literal_Map_KeyValue::ArenaDtor(void* object) { + Expression_Literal_Map_KeyValue* _this = reinterpret_cast< Expression_Literal_Map_KeyValue* >(object); (void)_this; } -void Expression_Literal_IntervalYearToMonth::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void Expression_Literal_Map_KeyValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_Literal_IntervalYearToMonth::SetCachedSize(int size) const { +void Expression_Literal_Map_KeyValue::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression_Literal_IntervalYearToMonth::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.IntervalYearToMonth) +void Expression_Literal_Map_KeyValue::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Map.KeyValue) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - ::memset(&years_, 0, static_cast( - reinterpret_cast(&months_) - - reinterpret_cast(&years_)) + sizeof(months_)); + if (GetArena() == nullptr && key_ != nullptr) { + delete key_; + } + key_ = nullptr; + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_Literal_IntervalYearToMonth::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_Literal_Map_KeyValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // int32 years = 1; + // .io.substrait.Expression.Literal key = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - years_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // int32 months = 2; + // .io.substrait.Expression.Literal value = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - months_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1905,52 +2463,56 @@ const char* Expression_Literal_IntervalYearToMonth::_InternalParse(const char* p #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalYearToMonth::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map_KeyValue::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Map.KeyValue) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // int32 years = 1; - if (this->years() != 0) { + // .io.substrait.Expression.Literal key = 1; + if (this->has_key()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_years(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::key(this), target, stream); } - // int32 months = 2; - if (this->months() != 0) { + // .io.substrait.Expression.Literal value = 2; + if (this->has_value()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_months(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::value(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Map.KeyValue) return target; } -size_t Expression_Literal_IntervalYearToMonth::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.IntervalYearToMonth) +size_t Expression_Literal_Map_KeyValue::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Map.KeyValue) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // int32 years = 1; - if (this->years() != 0) { + // .io.substrait.Expression.Literal key = 1; + if (this->has_key()) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_years()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *key_); } - // int32 months = 2; - if (this->months() != 0) { + // .io.substrait.Expression.Literal value = 2; + if (this->has_value()) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_months()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1962,66 +2524,66 @@ size_t Expression_Literal_IntervalYearToMonth::ByteSizeLong() const { return total_size; } -void Expression_Literal_IntervalYearToMonth::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) +void Expression_Literal_Map_KeyValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Map.KeyValue) GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_IntervalYearToMonth* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Expression_Literal_Map_KeyValue* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Map.KeyValue) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Map.KeyValue) MergeFrom(*source); } } -void Expression_Literal_IntervalYearToMonth::MergeFrom(const Expression_Literal_IntervalYearToMonth& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) +void Expression_Literal_Map_KeyValue::MergeFrom(const Expression_Literal_Map_KeyValue& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Map.KeyValue) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.years() != 0) { - _internal_set_years(from._internal_years()); + if (from.has_key()) { + _internal_mutable_key()->::io::substrait::Expression_Literal::MergeFrom(from._internal_key()); } - if (from.months() != 0) { - _internal_set_months(from._internal_months()); + if (from.has_value()) { + _internal_mutable_value()->::io::substrait::Expression_Literal::MergeFrom(from._internal_value()); } } -void Expression_Literal_IntervalYearToMonth::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) +void Expression_Literal_Map_KeyValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Map.KeyValue) if (&from == this) return; Clear(); MergeFrom(from); } -void Expression_Literal_IntervalYearToMonth::CopyFrom(const Expression_Literal_IntervalYearToMonth& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) +void Expression_Literal_Map_KeyValue::CopyFrom(const Expression_Literal_Map_KeyValue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Map.KeyValue) if (&from == this) return; Clear(); MergeFrom(from); } -bool Expression_Literal_IntervalYearToMonth::IsInitialized() const { +bool Expression_Literal_Map_KeyValue::IsInitialized() const { return true; } -void Expression_Literal_IntervalYearToMonth::InternalSwap(Expression_Literal_IntervalYearToMonth* other) { +void Expression_Literal_Map_KeyValue::InternalSwap(Expression_Literal_Map_KeyValue* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, months_) - + sizeof(Expression_Literal_IntervalYearToMonth::months_) - - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, years_)>( - reinterpret_cast(&years_), - reinterpret_cast(&other->years_)); + PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, value_) + + sizeof(Expression_Literal_Map_KeyValue::value_) + - PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, key_)>( + reinterpret_cast(&key_), + reinterpret_cast(&other->key_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalYearToMonth::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map_KeyValue::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, file_level_metadata_expression_2eproto[4]); @@ -2029,81 +2591,132 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalYearToMonth::GetMet // =================================================================== -class Expression_Literal_IntervalDayToSecond::_Internal { +class Expression_Literal_Map::_Internal { public: + static const ::io::substrait::Type& key_type(const Expression_Literal_Map* msg); + static const ::io::substrait::Type& value_type(const Expression_Literal_Map* msg); }; -Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +const ::io::substrait::Type& +Expression_Literal_Map::_Internal::key_type(const Expression_Literal_Map* msg) { + return *msg->key_type_; +} +const ::io::substrait::Type& +Expression_Literal_Map::_Internal::value_type(const Expression_Literal_Map* msg) { + return *msg->value_type_; +} +void Expression_Literal_Map::clear_key_type() { + if (GetArena() == nullptr && key_type_ != nullptr) { + delete key_type_; + } + key_type_ = nullptr; +} +void Expression_Literal_Map::clear_value_type() { + if (GetArena() == nullptr && value_type_ != nullptr) { + delete value_type_; + } + value_type_ = nullptr; +} +Expression_Literal_Map::Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + key_values_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Map) } -Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { +Expression_Literal_Map::Expression_Literal_Map(const Expression_Literal_Map& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + key_values_(from.key_values_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&days_, &from.days_, - static_cast(reinterpret_cast(&seconds_) - - reinterpret_cast(&days_)) + sizeof(seconds_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.IntervalDayToSecond) + if (from._internal_has_key_type()) { + key_type_ = new ::io::substrait::Type(*from.key_type_); + } else { + key_type_ = nullptr; + } + if (from._internal_has_value_type()) { + value_type_ = new ::io::substrait::Type(*from.value_type_); + } else { + value_type_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Map) } -void Expression_Literal_IntervalDayToSecond::SharedCtor() { +void Expression_Literal_Map::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&days_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&seconds_) - - reinterpret_cast(&days_)) + sizeof(seconds_)); + reinterpret_cast(&key_type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&value_type_) - + reinterpret_cast(&key_type_)) + sizeof(value_type_)); } -Expression_Literal_IntervalDayToSecond::~Expression_Literal_IntervalDayToSecond() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.IntervalDayToSecond) +Expression_Literal_Map::~Expression_Literal_Map() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Map) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_IntervalDayToSecond::SharedDtor() { +void Expression_Literal_Map::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete key_type_; + if (this != internal_default_instance()) delete value_type_; } -void Expression_Literal_IntervalDayToSecond::ArenaDtor(void* object) { - Expression_Literal_IntervalDayToSecond* _this = reinterpret_cast< Expression_Literal_IntervalDayToSecond* >(object); +void Expression_Literal_Map::ArenaDtor(void* object) { + Expression_Literal_Map* _this = reinterpret_cast< Expression_Literal_Map* >(object); (void)_this; } -void Expression_Literal_IntervalDayToSecond::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void Expression_Literal_Map::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_Literal_IntervalDayToSecond::SetCachedSize(int size) const { +void Expression_Literal_Map::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression_Literal_IntervalDayToSecond::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.IntervalDayToSecond) +void Expression_Literal_Map::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Map) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - ::memset(&days_, 0, static_cast( - reinterpret_cast(&seconds_) - - reinterpret_cast(&days_)) + sizeof(seconds_)); + key_values_.Clear(); + if (GetArena() == nullptr && key_type_ != nullptr) { + delete key_type_; + } + key_type_ = nullptr; + if (GetArena() == nullptr && value_type_ != nullptr) { + delete value_type_; + } + value_type_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_Literal_IntervalDayToSecond::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // int32 days = 1; + // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - days_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_key_values(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // int32 seconds = 2; + // .io.substrait.Type key_type = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_key_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type value_type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_value_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -2130,52 +2743,71 @@ const char* Expression_Literal_IntervalDayToSecond::_InternalParse(const char* p #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalDayToSecond::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Map) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // int32 days = 1; - if (this->days() != 0) { + // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_key_values_size()); i < n; i++) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_days(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_key_values(i), target, stream); } - // int32 seconds = 2; - if (this->seconds() != 0) { + // .io.substrait.Type key_type = 2; + if (this->has_key_type()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_seconds(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::key_type(this), target, stream); + } + + // .io.substrait.Type value_type = 3; + if (this->has_value_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::value_type(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Map) return target; } -size_t Expression_Literal_IntervalDayToSecond::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.IntervalDayToSecond) +size_t Expression_Literal_Map::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Map) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // int32 days = 1; - if (this->days() != 0) { + // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + total_size += 1UL * this->_internal_key_values_size(); + for (const auto& msg : this->key_values_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Type key_type = 2; + if (this->has_key_type()) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_days()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *key_type_); } - // int32 seconds = 2; - if (this->seconds() != 0) { + // .io.substrait.Type value_type = 3; + if (this->has_value_type()) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_seconds()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *value_type_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -2187,66 +2819,68 @@ size_t Expression_Literal_IntervalDayToSecond::ByteSizeLong() const { return total_size; } -void Expression_Literal_IntervalDayToSecond::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) +void Expression_Literal_Map::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Map) GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_IntervalDayToSecond* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Expression_Literal_Map* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Map) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Map) MergeFrom(*source); } } -void Expression_Literal_IntervalDayToSecond::MergeFrom(const Expression_Literal_IntervalDayToSecond& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) +void Expression_Literal_Map::MergeFrom(const Expression_Literal_Map& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Map) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.days() != 0) { - _internal_set_days(from._internal_days()); + key_values_.MergeFrom(from.key_values_); + if (from.has_key_type()) { + _internal_mutable_key_type()->::io::substrait::Type::MergeFrom(from._internal_key_type()); } - if (from.seconds() != 0) { - _internal_set_seconds(from._internal_seconds()); + if (from.has_value_type()) { + _internal_mutable_value_type()->::io::substrait::Type::MergeFrom(from._internal_value_type()); } } -void Expression_Literal_IntervalDayToSecond::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) +void Expression_Literal_Map::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Map) if (&from == this) return; Clear(); MergeFrom(from); } -void Expression_Literal_IntervalDayToSecond::CopyFrom(const Expression_Literal_IntervalDayToSecond& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) +void Expression_Literal_Map::CopyFrom(const Expression_Literal_Map& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Map) if (&from == this) return; Clear(); MergeFrom(from); } -bool Expression_Literal_IntervalDayToSecond::IsInitialized() const { +bool Expression_Literal_Map::IsInitialized() const { return true; } -void Expression_Literal_IntervalDayToSecond::InternalSwap(Expression_Literal_IntervalDayToSecond* other) { +void Expression_Literal_Map::InternalSwap(Expression_Literal_Map* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + key_values_.InternalSwap(&other->key_values_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, seconds_) - + sizeof(Expression_Literal_IntervalDayToSecond::seconds_) - - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, days_)>( - reinterpret_cast(&days_), - reinterpret_cast(&other->days_)); + PROTOBUF_FIELD_OFFSET(Expression_Literal_Map, value_type_) + + sizeof(Expression_Literal_Map::value_type_) + - PROTOBUF_FIELD_OFFSET(Expression_Literal_Map, key_type_)>( + reinterpret_cast(&key_type_), + reinterpret_cast(&other->key_type_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalDayToSecond::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, file_level_metadata_expression_2eproto[5]); @@ -2254,73 +2888,82 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalDayToSecond::GetMet // =================================================================== -class Expression_Literal_Struct::_Internal { +class Expression_Literal_IntervalYearToMonth::_Internal { public: }; -Expression_Literal_Struct::Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - fields_(arena) { +Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.IntervalYearToMonth) } -Expression_Literal_Struct::Expression_Literal_Struct(const Expression_Literal_Struct& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - fields_(from.fields_) { +Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Struct) + ::memcpy(&years_, &from.years_, + static_cast(reinterpret_cast(&months_) - + reinterpret_cast(&years_)) + sizeof(months_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.IntervalYearToMonth) } -void Expression_Literal_Struct::SharedCtor() { +void Expression_Literal_IntervalYearToMonth::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&years_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&months_) - + reinterpret_cast(&years_)) + sizeof(months_)); } -Expression_Literal_Struct::~Expression_Literal_Struct() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Struct) +Expression_Literal_IntervalYearToMonth::~Expression_Literal_IntervalYearToMonth() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.IntervalYearToMonth) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_Struct::SharedDtor() { +void Expression_Literal_IntervalYearToMonth::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); } -void Expression_Literal_Struct::ArenaDtor(void* object) { - Expression_Literal_Struct* _this = reinterpret_cast< Expression_Literal_Struct* >(object); +void Expression_Literal_IntervalYearToMonth::ArenaDtor(void* object) { + Expression_Literal_IntervalYearToMonth* _this = reinterpret_cast< Expression_Literal_IntervalYearToMonth* >(object); (void)_this; } -void Expression_Literal_Struct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void Expression_Literal_IntervalYearToMonth::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_Literal_Struct::SetCachedSize(int size) const { +void Expression_Literal_IntervalYearToMonth::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression_Literal_Struct::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Struct) +void Expression_Literal_IntervalYearToMonth::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.IntervalYearToMonth) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - fields_.Clear(); + ::memset(&years_, 0, static_cast( + reinterpret_cast(&months_) - + reinterpret_cast(&years_)) + sizeof(months_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_Literal_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_Literal_IntervalYearToMonth::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.Literal fields = 1; + // int32 years = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_fields(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + years_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 months = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + months_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); } else goto handle_unusual; continue; default: { @@ -2346,41 +2989,52 @@ const char* Expression_Literal_Struct::_InternalParse(const char* ptr, ::PROTOBU #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Struct::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalYearToMonth::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.IntervalYearToMonth) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal fields = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_fields_size()); i < n; i++) { + // int32 years = 1; + if (this->years() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_fields(i), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_years(), target); + } + + // int32 months = 2; + if (this->months() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_months(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.IntervalYearToMonth) return target; } -size_t Expression_Literal_Struct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Struct) +size_t Expression_Literal_IntervalYearToMonth::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.IntervalYearToMonth) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal fields = 1; - total_size += 1UL * this->_internal_fields_size(); - for (const auto& msg : this->fields_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + // int32 years = 1; + if (this->years() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_years()); + } + + // int32 months = 2; + if (this->months() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_months()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -2392,56 +3046,66 @@ size_t Expression_Literal_Struct::ByteSizeLong() const { return total_size; } -void Expression_Literal_Struct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Struct) +void Expression_Literal_IntervalYearToMonth::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_Struct* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Expression_Literal_IntervalYearToMonth* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.IntervalYearToMonth) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.IntervalYearToMonth) MergeFrom(*source); } } -void Expression_Literal_Struct::MergeFrom(const Expression_Literal_Struct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Struct) +void Expression_Literal_IntervalYearToMonth::MergeFrom(const Expression_Literal_IntervalYearToMonth& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - fields_.MergeFrom(from.fields_); + if (from.years() != 0) { + _internal_set_years(from._internal_years()); + } + if (from.months() != 0) { + _internal_set_months(from._internal_months()); + } } -void Expression_Literal_Struct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Struct) +void Expression_Literal_IntervalYearToMonth::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) if (&from == this) return; Clear(); MergeFrom(from); } -void Expression_Literal_Struct::CopyFrom(const Expression_Literal_Struct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Struct) +void Expression_Literal_IntervalYearToMonth::CopyFrom(const Expression_Literal_IntervalYearToMonth& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) if (&from == this) return; Clear(); MergeFrom(from); } -bool Expression_Literal_Struct::IsInitialized() const { +bool Expression_Literal_IntervalYearToMonth::IsInitialized() const { return true; } -void Expression_Literal_Struct::InternalSwap(Expression_Literal_Struct* other) { +void Expression_Literal_IntervalYearToMonth::InternalSwap(Expression_Literal_IntervalYearToMonth* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - fields_.InternalSwap(&other->fields_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, months_) + + sizeof(Expression_Literal_IntervalYearToMonth::months_) + - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, years_)>( + reinterpret_cast(&years_), + reinterpret_cast(&other->years_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Struct::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalYearToMonth::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, file_level_metadata_expression_2eproto[6]); @@ -2449,78 +3113,87 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Struct::GetMetadata() const // =================================================================== -class Expression_Literal_List::_Internal { +class Expression_Literal_IntervalDayToSecond::_Internal { public: }; -Expression_Literal_List::Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - values_(arena) { +Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.IntervalDayToSecond) } -Expression_Literal_List::Expression_Literal_List(const Expression_Literal_List& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - values_(from.values_) { +Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.List) + ::memcpy(&days_, &from.days_, + static_cast(reinterpret_cast(&seconds_) - + reinterpret_cast(&days_)) + sizeof(seconds_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.IntervalDayToSecond) } -void Expression_Literal_List::SharedCtor() { +void Expression_Literal_IntervalDayToSecond::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&days_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&seconds_) - + reinterpret_cast(&days_)) + sizeof(seconds_)); } -Expression_Literal_List::~Expression_Literal_List() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.List) +Expression_Literal_IntervalDayToSecond::~Expression_Literal_IntervalDayToSecond() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.IntervalDayToSecond) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_List::SharedDtor() { +void Expression_Literal_IntervalDayToSecond::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); } -void Expression_Literal_List::ArenaDtor(void* object) { - Expression_Literal_List* _this = reinterpret_cast< Expression_Literal_List* >(object); +void Expression_Literal_IntervalDayToSecond::ArenaDtor(void* object) { + Expression_Literal_IntervalDayToSecond* _this = reinterpret_cast< Expression_Literal_IntervalDayToSecond* >(object); (void)_this; } -void Expression_Literal_List::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void Expression_Literal_IntervalDayToSecond::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_Literal_List::SetCachedSize(int size) const { +void Expression_Literal_IntervalDayToSecond::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression_Literal_List::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.List) +void Expression_Literal_IntervalDayToSecond::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.IntervalDayToSecond) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - values_.Clear(); + ::memset(&days_, 0, static_cast( + reinterpret_cast(&seconds_) - + reinterpret_cast(&days_)) + sizeof(seconds_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_Literal_IntervalDayToSecond::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.Literal values = 1; + // int32 days = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_values(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + days_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); } else goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { + // int32 seconds = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); ctx->SetLastTag(tag); goto success; @@ -2541,41 +3214,52 @@ const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_ #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_List::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalDayToSecond::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.IntervalDayToSecond) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal values = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_values_size()); i < n; i++) { + // int32 days = 1; + if (this->days() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_values(i), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_days(), target); + } + + // int32 seconds = 2; + if (this->seconds() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_seconds(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.IntervalDayToSecond) return target; } -size_t Expression_Literal_List::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.List) +size_t Expression_Literal_IntervalDayToSecond::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.IntervalDayToSecond) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal values = 1; - total_size += 1UL * this->_internal_values_size(); - for (const auto& msg : this->values_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + // int32 days = 1; + if (this->days() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_days()); + } + + // int32 seconds = 2; + if (this->seconds() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_seconds()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -2587,56 +3271,66 @@ size_t Expression_Literal_List::ByteSizeLong() const { return total_size; } -void Expression_Literal_List::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.List) +void Expression_Literal_IntervalDayToSecond::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_List* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Expression_Literal_IntervalDayToSecond* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.IntervalDayToSecond) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.IntervalDayToSecond) MergeFrom(*source); } } -void Expression_Literal_List::MergeFrom(const Expression_Literal_List& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.List) +void Expression_Literal_IntervalDayToSecond::MergeFrom(const Expression_Literal_IntervalDayToSecond& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - values_.MergeFrom(from.values_); + if (from.days() != 0) { + _internal_set_days(from._internal_days()); + } + if (from.seconds() != 0) { + _internal_set_seconds(from._internal_seconds()); + } } -void Expression_Literal_List::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.List) +void Expression_Literal_IntervalDayToSecond::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) if (&from == this) return; Clear(); MergeFrom(from); } -void Expression_Literal_List::CopyFrom(const Expression_Literal_List& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.List) +void Expression_Literal_IntervalDayToSecond::CopyFrom(const Expression_Literal_IntervalDayToSecond& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) if (&from == this) return; Clear(); MergeFrom(from); } -bool Expression_Literal_List::IsInitialized() const { +bool Expression_Literal_IntervalDayToSecond::IsInitialized() const { return true; } -void Expression_Literal_List::InternalSwap(Expression_Literal_List* other) { +void Expression_Literal_IntervalDayToSecond::InternalSwap(Expression_Literal_IntervalDayToSecond* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - values_.InternalSwap(&other->values_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, seconds_) + + sizeof(Expression_Literal_IntervalDayToSecond::seconds_) + - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, days_)>( + reinterpret_cast(&days_), + reinterpret_cast(&other->days_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_List::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalDayToSecond::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, file_level_metadata_expression_2eproto[7]); @@ -2644,603 +3338,310 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_List::GetMetadata() const { // =================================================================== -class Expression_Literal::_Internal { +class Expression_Literal_Struct::_Internal { public: - static const ::io::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month(const Expression_Literal* msg); - static const ::io::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second(const Expression_Literal* msg); - static const ::io::substrait::Expression_Literal_Struct& struct_(const Expression_Literal* msg); - static const ::io::substrait::Expression_Literal_Map& map(const Expression_Literal* msg); - static const ::io::substrait::Type& null(const Expression_Literal* msg); - static const ::io::substrait::Expression_Literal_List& list(const Expression_Literal* msg); }; -const ::io::substrait::Expression_Literal_IntervalYearToMonth& -Expression_Literal::_Internal::interval_year_to_month(const Expression_Literal* msg) { - return *msg->literal_type_.interval_year_to_month_; +Expression_Literal_Struct::Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + fields_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Struct) } -const ::io::substrait::Expression_Literal_IntervalDayToSecond& -Expression_Literal::_Internal::interval_day_to_second(const Expression_Literal* msg) { - return *msg->literal_type_.interval_day_to_second_; +Expression_Literal_Struct::Expression_Literal_Struct(const Expression_Literal_Struct& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + fields_(from.fields_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Struct) } -const ::io::substrait::Expression_Literal_Struct& -Expression_Literal::_Internal::struct_(const Expression_Literal* msg) { - return *msg->literal_type_.struct__; + +void Expression_Literal_Struct::SharedCtor() { } -const ::io::substrait::Expression_Literal_Map& -Expression_Literal::_Internal::map(const Expression_Literal* msg) { - return *msg->literal_type_.map_; + +Expression_Literal_Struct::~Expression_Literal_Struct() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Struct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const ::io::substrait::Type& -Expression_Literal::_Internal::null(const Expression_Literal* msg) { - return *msg->literal_type_.null_; + +void Expression_Literal_Struct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); } -const ::io::substrait::Expression_Literal_List& -Expression_Literal::_Internal::list(const Expression_Literal* msg) { - return *msg->literal_type_.list_; + +void Expression_Literal_Struct::ArenaDtor(void* object) { + Expression_Literal_Struct* _this = reinterpret_cast< Expression_Literal_Struct* >(object); + (void)_this; } -void Expression_Literal::set_allocated_interval_year_to_month(::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_literal_type(); - if (interval_year_to_month) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_year_to_month); - if (message_arena != submessage_arena) { - interval_year_to_month = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interval_year_to_month, submessage_arena); - } - set_has_interval_year_to_month(); - literal_type_.interval_year_to_month_ = interval_year_to_month; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.interval_year_to_month) +void Expression_Literal_Struct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_Literal::set_allocated_interval_day_to_second(::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_literal_type(); - if (interval_day_to_second) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_day_to_second); - if (message_arena != submessage_arena) { - interval_day_to_second = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interval_day_to_second, submessage_arena); - } - set_has_interval_day_to_second(); - literal_type_.interval_day_to_second_ = interval_day_to_second; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.interval_day_to_second) +void Expression_Literal_Struct::SetCachedSize(int size) const { + _cached_size_.Set(size); } -void Expression_Literal::set_allocated_struct_(::io::substrait::Expression_Literal_Struct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_literal_type(); - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - set_has_struct_(); - literal_type_.struct__ = struct_; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.struct) + +void Expression_Literal_Struct::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Struct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + fields_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal::set_allocated_map(::io::substrait::Expression_Literal_Map* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_literal_type(); - if (map) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); - if (message_arena != submessage_arena) { - map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, map, submessage_arena); - } - set_has_map(); - literal_type_.map_ = map; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.map) + +const char* Expression_Literal_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression.Literal fields = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_fields(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ } -void Expression_Literal::set_allocated_null(::io::substrait::Type* null) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_literal_type(); - if (null) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(null)->GetArena(); - if (message_arena != submessage_arena) { - null = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, null, submessage_arena); - } - set_has_null(); - literal_type_.null_ = null; + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Struct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Struct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression.Literal fields = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_fields_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_fields(i), target, stream); } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.null) -} -void Expression_Literal::clear_null() { - if (_internal_has_null()) { - if (GetArena() == nullptr) { - delete literal_type_.null_; - } - clear_has_literal_type(); + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Struct) + return target; } -void Expression_Literal::set_allocated_list(::io::substrait::Expression_Literal_List* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_literal_type(); - if (list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); - if (message_arena != submessage_arena) { - list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, list, submessage_arena); - } - set_has_list(); - literal_type_.list_ = list; + +size_t Expression_Literal_Struct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Struct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression.Literal fields = 1; + total_size += 1UL * this->_internal_fields_size(); + for (const auto& msg : this->fields_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.list) -} -Expression_Literal::Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal) + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; } -Expression_Literal::Expression_Literal(const Expression_Literal& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_literal_type(); - switch (from.literal_type_case()) { - case kBoolean: { - _internal_set_boolean(from._internal_boolean()); - break; - } - case kI8: { - _internal_set_i8(from._internal_i8()); - break; - } - case kI16: { - _internal_set_i16(from._internal_i16()); - break; - } - case kI32: { - _internal_set_i32(from._internal_i32()); - break; - } - case kI64: { - _internal_set_i64(from._internal_i64()); - break; - } - case kFp32: { - _internal_set_fp32(from._internal_fp32()); - break; - } - case kFp64: { - _internal_set_fp64(from._internal_fp64()); - break; - } - case kString: { - _internal_set_string(from._internal_string()); - break; - } - case kBinary: { - _internal_set_binary(from._internal_binary()); - break; - } - case kTimestamp: { - _internal_set_timestamp(from._internal_timestamp()); - break; - } - case kDate: { - _internal_set_date(from._internal_date()); - break; - } - case kTime: { - _internal_set_time(from._internal_time()); - break; - } - case kIntervalYearToMonth: { - _internal_mutable_interval_year_to_month()->::io::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); - break; - } - case kIntervalDayToSecond: { - _internal_mutable_interval_day_to_second()->::io::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); - break; - } - case kFixedChar: { - _internal_set_fixed_char(from._internal_fixed_char()); - break; - } - case kVarChar: { - _internal_set_var_char(from._internal_var_char()); - break; - } - case kFixedBinary: { - _internal_set_fixed_binary(from._internal_fixed_binary()); - break; - } - case kDecimal: { - _internal_set_decimal(from._internal_decimal()); - break; - } - case kStruct: { - _internal_mutable_struct_()->::io::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); - break; - } - case kMap: { - _internal_mutable_map()->::io::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); - break; - } - case kTimestampTz: { - _internal_set_timestamp_tz(from._internal_timestamp_tz()); - break; - } - case kUuid: { - _internal_set_uuid(from._internal_uuid()); - break; - } - case kNull: { - _internal_mutable_null()->::io::substrait::Type::MergeFrom(from._internal_null()); - break; - } - case kList: { - _internal_mutable_list()->::io::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); - break; - } - case LITERAL_TYPE_NOT_SET: { - break; - } + +void Expression_Literal_Struct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Struct) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Literal_Struct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Struct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Struct) + MergeFrom(*source); } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal) } -void Expression_Literal::SharedCtor() { -clear_has_literal_type(); +void Expression_Literal_Struct::MergeFrom(const Expression_Literal_Struct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Struct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + fields_.MergeFrom(from.fields_); } -Expression_Literal::~Expression_Literal() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +void Expression_Literal_Struct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Struct) + if (&from == this) return; + Clear(); + MergeFrom(from); } -void Expression_Literal::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (has_literal_type()) { - clear_literal_type(); - } +void Expression_Literal_Struct::CopyFrom(const Expression_Literal_Struct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Struct) + if (&from == this) return; + Clear(); + MergeFrom(from); } -void Expression_Literal::ArenaDtor(void* object) { - Expression_Literal* _this = reinterpret_cast< Expression_Literal* >(object); - (void)_this; +bool Expression_Literal_Struct::IsInitialized() const { + return true; } -void Expression_Literal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { + +void Expression_Literal_Struct::InternalSwap(Expression_Literal_Struct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + fields_.InternalSwap(&other->fields_); } -void Expression_Literal::SetCachedSize(int size) const { - _cached_size_.Set(size); + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Struct::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[8]); } -void Expression_Literal::clear_literal_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.Literal) - switch (literal_type_case()) { - case kBoolean: { - // No need to clear - break; - } - case kI8: { - // No need to clear - break; - } - case kI16: { - // No need to clear - break; - } - case kI32: { - // No need to clear - break; - } - case kI64: { - // No need to clear - break; - } - case kFp32: { - // No need to clear - break; - } - case kFp64: { - // No need to clear - break; - } - case kString: { - literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - break; - } - case kBinary: { - literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - break; - } - case kTimestamp: { - // No need to clear - break; - } - case kDate: { - // No need to clear - break; - } - case kTime: { - // No need to clear - break; - } - case kIntervalYearToMonth: { - if (GetArena() == nullptr) { - delete literal_type_.interval_year_to_month_; - } - break; - } - case kIntervalDayToSecond: { - if (GetArena() == nullptr) { - delete literal_type_.interval_day_to_second_; - } - break; - } - case kFixedChar: { - literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - break; - } - case kVarChar: { - literal_type_.var_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - break; - } - case kFixedBinary: { - literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - break; - } - case kDecimal: { - literal_type_.decimal_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - break; - } - case kStruct: { - if (GetArena() == nullptr) { - delete literal_type_.struct__; - } - break; - } - case kMap: { - if (GetArena() == nullptr) { - delete literal_type_.map_; - } - break; - } - case kTimestampTz: { - // No need to clear - break; - } - case kUuid: { - literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - break; - } - case kNull: { - if (GetArena() == nullptr) { - delete literal_type_.null_; - } - break; - } - case kList: { - if (GetArena() == nullptr) { - delete literal_type_.list_; - } - break; - } - case LITERAL_TYPE_NOT_SET: { - break; - } +// =================================================================== + +class Expression_Literal_List::_Internal { + public: + static const ::io::substrait::Type& element_type(const Expression_Literal_List* msg); +}; + +const ::io::substrait::Type& +Expression_Literal_List::_Internal::element_type(const Expression_Literal_List* msg) { + return *msg->element_type_; +} +void Expression_Literal_List::clear_element_type() { + if (GetArena() == nullptr && element_type_ != nullptr) { + delete element_type_; } - _oneof_case_[0] = LITERAL_TYPE_NOT_SET; + element_type_ = nullptr; +} +Expression_Literal_List::Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + values_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.List) +} +Expression_Literal_List::Expression_Literal_List(const Expression_Literal_List& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + values_(from.values_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_element_type()) { + element_type_ = new ::io::substrait::Type(*from.element_type_); + } else { + element_type_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.List) } +void Expression_Literal_List::SharedCtor() { +element_type_ = nullptr; +} -void Expression_Literal::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal) +Expression_Literal_List::~Expression_Literal_List() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.List) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Literal_List::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete element_type_; +} + +void Expression_Literal_List::ArenaDtor(void* object) { + Expression_Literal_List* _this = reinterpret_cast< Expression_Literal_List* >(object); + (void)_this; +} +void Expression_Literal_List::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Literal_List::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_Literal_List::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.List) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - clear_literal_type(); + values_.Clear(); + if (GetArena() == nullptr && element_type_ != nullptr) { + delete element_type_; + } + element_type_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // bool boolean = 1; + // repeated .io.substrait.Expression.Literal values = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - _internal_set_boolean(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_values(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // int32 i8 = 2; + // .io.substrait.Type element_type = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - _internal_set_i8(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else goto handle_unusual; - continue; - // int32 i16 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - _internal_set_i16(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else goto handle_unusual; - continue; - // int32 i32 = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { - _internal_set_i32(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else goto handle_unusual; - continue; - // int64 i64 = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { - _internal_set_i64(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else goto handle_unusual; - continue; - // float fp32 = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 85)) { - _internal_set_fp32(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); - ptr += sizeof(float); - } else goto handle_unusual; - continue; - // double fp64 = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 89)) { - _internal_set_fp64(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); - ptr += sizeof(double); - } else goto handle_unusual; - continue; - // string string = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { - auto str = _internal_mutable_string(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.string")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // bytes binary = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { - auto str = _internal_mutable_binary(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else goto handle_unusual; - continue; - // fixed64 timestamp = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 113)) { - _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr)); - ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint64); - } else goto handle_unusual; - continue; - // fixed32 date = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 133)) { - _internal_set_date(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint32>(ptr)); - ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint32); - } else goto handle_unusual; - continue; - // uint64 time = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) { - _internal_set_time(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { - ptr = ctx->ParseMessage(_internal_mutable_interval_year_to_month(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_element_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { - ptr = ctx->ParseMessage(_internal_mutable_interval_day_to_second(), ptr); + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { CHK_(ptr); - } else goto handle_unusual; - continue; - // string fixed_char = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { - auto str = _internal_mutable_fixed_char(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.fixed_char")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // string var_char = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { - auto str = _internal_mutable_var_char(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.var_char")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // bytes fixed_binary = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { - auto str = _internal_mutable_fixed_binary(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else goto handle_unusual; - continue; - // bytes decimal = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { - auto str = _internal_mutable_decimal(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Expression.Literal.Struct struct = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Expression.Literal.Map map = 26; - case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) { - ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // fixed64 timestamp_tz = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 217)) { - _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::PROTOBUF_NAMESPACE_ID::uint64>(ptr)); - ptr += sizeof(::PROTOBUF_NAMESPACE_ID::uint64); - } else goto handle_unusual; - continue; - // bytes uuid = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { - auto str = _internal_mutable_uuid(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Type null = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { - ptr = ctx->ParseMessage(_internal_mutable_null(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Expression.Literal.List list = 30; - case 30: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 242)) { - ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); continue; } } // switch @@ -3253,650 +3654,762 @@ const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMES #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_List::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.List) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // bool boolean = 1; - if (_internal_has_boolean()) { + // repeated .io.substrait.Expression.Literal values = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_values_size()); i < n; i++) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_boolean(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_values(i), target, stream); } - // int32 i8 = 2; - if (_internal_has_i8()) { + // .io.substrait.Type element_type = 2; + if (this->has_element_type()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_i8(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::element_type(this), target, stream); } - // int32 i16 = 3; - if (_internal_has_i16()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_i16(), target); + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.List) + return target; +} - // int32 i32 = 5; - if (_internal_has_i32()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_i32(), target); - } +size_t Expression_Literal_List::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.List) + size_t total_size = 0; - // int64 i64 = 7; - if (_internal_has_i64()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_i64(), target); - } + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; - // float fp32 = 10; - if (_internal_has_fp32()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_fp32(), target); + // repeated .io.substrait.Expression.Literal values = 1; + total_size += 1UL * this->_internal_values_size(); + for (const auto& msg : this->values_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // double fp64 = 11; - if (_internal_has_fp64()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(11, this->_internal_fp64(), target); + // .io.substrait.Type element_type = 2; + if (this->has_element_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *element_type_); } - // string string = 12; - if (_internal_has_string()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_string().data(), static_cast(this->_internal_string().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.Literal.string"); - target = stream->WriteStringMaybeAliased( - 12, this->_internal_string(), target); + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} - // bytes binary = 13; - if (_internal_has_binary()) { - target = stream->WriteBytesMaybeAliased( - 13, this->_internal_binary(), target); +void Expression_Literal_List::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.List) + GOOGLE_DCHECK_NE(&from, this); + const Expression_Literal_List* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.List) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.List) + MergeFrom(*source); } +} - // fixed64 timestamp = 14; - if (_internal_has_timestamp()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed64ToArray(14, this->_internal_timestamp(), target); - } +void Expression_Literal_List::MergeFrom(const Expression_Literal_List& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.List) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; - // fixed32 date = 16; - if (_internal_has_date()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed32ToArray(16, this->_internal_date(), target); + values_.MergeFrom(from.values_); + if (from.has_element_type()) { + _internal_mutable_element_type()->::io::substrait::Type::MergeFrom(from._internal_element_type()); } +} - // uint64 time = 17; - if (_internal_has_time()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(17, this->_internal_time(), target); - } +void Expression_Literal_List::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.List) + if (&from == this) return; + Clear(); + MergeFrom(from); +} - // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; - if (_internal_has_interval_year_to_month()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 19, _Internal::interval_year_to_month(this), target, stream); - } +void Expression_Literal_List::CopyFrom(const Expression_Literal_List& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.List) + if (&from == this) return; + Clear(); + MergeFrom(from); +} - // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; - if (_internal_has_interval_day_to_second()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 20, _Internal::interval_day_to_second(this), target, stream); - } +bool Expression_Literal_List::IsInitialized() const { + return true; +} - // string fixed_char = 21; - if (_internal_has_fixed_char()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_fixed_char().data(), static_cast(this->_internal_fixed_char().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.Literal.fixed_char"); - target = stream->WriteStringMaybeAliased( - 21, this->_internal_fixed_char(), target); - } +void Expression_Literal_List::InternalSwap(Expression_Literal_List* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + values_.InternalSwap(&other->values_); + swap(element_type_, other->element_type_); +} - // string var_char = 22; - if (_internal_has_var_char()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_var_char().data(), static_cast(this->_internal_var_char().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.Literal.var_char"); - target = stream->WriteStringMaybeAliased( - 22, this->_internal_var_char(), target); - } +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_List::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[9]); +} - // bytes fixed_binary = 23; - if (_internal_has_fixed_binary()) { - target = stream->WriteBytesMaybeAliased( - 23, this->_internal_fixed_binary(), target); - } +// =================================================================== - // bytes decimal = 24; - if (_internal_has_decimal()) { - target = stream->WriteBytesMaybeAliased( - 24, this->_internal_decimal(), target); - } +class Expression_Literal::_Internal { + public: + static const ::io::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month(const Expression_Literal* msg); + static const ::io::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second(const Expression_Literal* msg); + static const ::io::substrait::Expression_Literal_VarChar& var_char(const Expression_Literal* msg); + static const ::io::substrait::Expression_Literal_Decimal& decimal(const Expression_Literal* msg); + static const ::io::substrait::Expression_Literal_Struct& struct_(const Expression_Literal* msg); + static const ::io::substrait::Expression_Literal_Map& map(const Expression_Literal* msg); + static const ::io::substrait::Type& null(const Expression_Literal* msg); + static const ::io::substrait::Expression_Literal_List& list(const Expression_Literal* msg); +}; - // .io.substrait.Expression.Literal.Struct struct = 25; - if (_internal_has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 25, _Internal::struct_(this), target, stream); +const ::io::substrait::Expression_Literal_IntervalYearToMonth& +Expression_Literal::_Internal::interval_year_to_month(const Expression_Literal* msg) { + return *msg->literal_type_.interval_year_to_month_; +} +const ::io::substrait::Expression_Literal_IntervalDayToSecond& +Expression_Literal::_Internal::interval_day_to_second(const Expression_Literal* msg) { + return *msg->literal_type_.interval_day_to_second_; +} +const ::io::substrait::Expression_Literal_VarChar& +Expression_Literal::_Internal::var_char(const Expression_Literal* msg) { + return *msg->literal_type_.var_char_; +} +const ::io::substrait::Expression_Literal_Decimal& +Expression_Literal::_Internal::decimal(const Expression_Literal* msg) { + return *msg->literal_type_.decimal_; +} +const ::io::substrait::Expression_Literal_Struct& +Expression_Literal::_Internal::struct_(const Expression_Literal* msg) { + return *msg->literal_type_.struct__; +} +const ::io::substrait::Expression_Literal_Map& +Expression_Literal::_Internal::map(const Expression_Literal* msg) { + return *msg->literal_type_.map_; +} +const ::io::substrait::Type& +Expression_Literal::_Internal::null(const Expression_Literal* msg) { + return *msg->literal_type_.null_; +} +const ::io::substrait::Expression_Literal_List& +Expression_Literal::_Internal::list(const Expression_Literal* msg) { + return *msg->literal_type_.list_; +} +void Expression_Literal::set_allocated_interval_year_to_month(::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (interval_year_to_month) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_year_to_month); + if (message_arena != submessage_arena) { + interval_year_to_month = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interval_year_to_month, submessage_arena); + } + set_has_interval_year_to_month(); + literal_type_.interval_year_to_month_ = interval_year_to_month; } - - // .io.substrait.Expression.Literal.Map map = 26; - if (_internal_has_map()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 26, _Internal::map(this), target, stream); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.interval_year_to_month) +} +void Expression_Literal::set_allocated_interval_day_to_second(::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (interval_day_to_second) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_day_to_second); + if (message_arena != submessage_arena) { + interval_day_to_second = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, interval_day_to_second, submessage_arena); + } + set_has_interval_day_to_second(); + literal_type_.interval_day_to_second_ = interval_day_to_second; } - - // fixed64 timestamp_tz = 27; - if (_internal_has_timestamp_tz()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFixed64ToArray(27, this->_internal_timestamp_tz(), target); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.interval_day_to_second) +} +void Expression_Literal::set_allocated_var_char(::io::substrait::Expression_Literal_VarChar* var_char) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (var_char) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(var_char); + if (message_arena != submessage_arena) { + var_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, var_char, submessage_arena); + } + set_has_var_char(); + literal_type_.var_char_ = var_char; } - - // bytes uuid = 28; - if (_internal_has_uuid()) { - target = stream->WriteBytesMaybeAliased( - 28, this->_internal_uuid(), target); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.var_char) +} +void Expression_Literal::set_allocated_decimal(::io::substrait::Expression_Literal_Decimal* decimal) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (decimal) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(decimal); + if (message_arena != submessage_arena) { + decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, decimal, submessage_arena); + } + set_has_decimal(); + literal_type_.decimal_ = decimal; } - - // .io.substrait.Type null = 29; - if (_internal_has_null()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 29, _Internal::null(this), target, stream); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.decimal) +} +void Expression_Literal::set_allocated_struct_(::io::substrait::Expression_Literal_Struct* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + set_has_struct_(); + literal_type_.struct__ = struct_; } - - // .io.substrait.Expression.Literal.List list = 30; - if (_internal_has_list()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 30, _Internal::list(this), target, stream); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.struct) +} +void Expression_Literal::set_allocated_map(::io::substrait::Expression_Literal_Map* map) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (map) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + if (message_arena != submessage_arena) { + map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map, submessage_arena); + } + set_has_map(); + literal_type_.map_ = map; } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.map) +} +void Expression_Literal::set_allocated_null(::io::substrait::Type* null) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (null) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(null)->GetArena(); + if (message_arena != submessage_arena) { + null = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, null, submessage_arena); + } + set_has_null(); + literal_type_.null_ = null; } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal) - return target; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.null) } - -size_t Expression_Literal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (literal_type_case()) { - // bool boolean = 1; +void Expression_Literal::clear_null() { + if (_internal_has_null()) { + if (GetArena() == nullptr) { + delete literal_type_.null_; + } + clear_has_literal_type(); + } +} +void Expression_Literal::set_allocated_list(::io::substrait::Expression_Literal_List* list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + if (message_arena != submessage_arena) { + list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, list, submessage_arena); + } + set_has_list(); + literal_type_.list_ = list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.list) +} +Expression_Literal::Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal) +} +Expression_Literal::Expression_Literal(const Expression_Literal& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + nullable_ = from.nullable_; + clear_has_literal_type(); + switch (from.literal_type_case()) { case kBoolean: { - total_size += 1 + 1; + _internal_set_boolean(from._internal_boolean()); break; } - // int32 i8 = 2; case kI8: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_i8()); + _internal_set_i8(from._internal_i8()); break; } - // int32 i16 = 3; case kI16: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_i16()); + _internal_set_i16(from._internal_i16()); break; } - // int32 i32 = 5; case kI32: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_i32()); + _internal_set_i32(from._internal_i32()); break; } - // int64 i64 = 7; case kI64: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_i64()); + _internal_set_i64(from._internal_i64()); break; } - // float fp32 = 10; case kFp32: { - total_size += 1 + 4; + _internal_set_fp32(from._internal_fp32()); break; } - // double fp64 = 11; case kFp64: { - total_size += 1 + 8; + _internal_set_fp64(from._internal_fp64()); break; } - // string string = 12; case kString: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_string()); + _internal_set_string(from._internal_string()); break; } - // bytes binary = 13; case kBinary: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_binary()); + _internal_set_binary(from._internal_binary()); break; } - // fixed64 timestamp = 14; case kTimestamp: { - total_size += 1 + 8; + _internal_set_timestamp(from._internal_timestamp()); break; } - // fixed32 date = 16; case kDate: { - total_size += 2 + 4; + _internal_set_date(from._internal_date()); break; } - // uint64 time = 17; case kTime: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( - this->_internal_time()); + _internal_set_time(from._internal_time()); break; } - // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; case kIntervalYearToMonth: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.interval_year_to_month_); + _internal_mutable_interval_year_to_month()->::io::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); break; } - // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; case kIntervalDayToSecond: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.interval_day_to_second_); + _internal_mutable_interval_day_to_second()->::io::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); break; } - // string fixed_char = 21; case kFixedChar: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_fixed_char()); + _internal_set_fixed_char(from._internal_fixed_char()); break; } - // string var_char = 22; case kVarChar: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_var_char()); + _internal_mutable_var_char()->::io::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char()); break; } - // bytes fixed_binary = 23; case kFixedBinary: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fixed_binary()); + _internal_set_fixed_binary(from._internal_fixed_binary()); break; } - // bytes decimal = 24; case kDecimal: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_decimal()); + _internal_mutable_decimal()->::io::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal()); break; } - // .io.substrait.Expression.Literal.Struct struct = 25; case kStruct: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.struct__); + _internal_mutable_struct_()->::io::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); break; } - // .io.substrait.Expression.Literal.Map map = 26; case kMap: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.map_); + _internal_mutable_map()->::io::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); break; } - // fixed64 timestamp_tz = 27; case kTimestampTz: { - total_size += 2 + 8; + _internal_set_timestamp_tz(from._internal_timestamp_tz()); break; } - // bytes uuid = 28; case kUuid: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_uuid()); + _internal_set_uuid(from._internal_uuid()); break; } - // .io.substrait.Type null = 29; case kNull: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.null_); + _internal_mutable_null()->::io::substrait::Type::MergeFrom(from._internal_null()); break; } - // .io.substrait.Expression.Literal.List list = 30; case kList: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.list_); + _internal_mutable_list()->::io::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); break; } case LITERAL_TYPE_NOT_SET: { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal) } -void Expression_Literal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal) - MergeFrom(*source); +void Expression_Literal::SharedCtor() { +nullable_ = false; +clear_has_literal_type(); +} + +Expression_Literal::~Expression_Literal() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_Literal::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_literal_type()) { + clear_literal_type(); } } -void Expression_Literal::MergeFrom(const Expression_Literal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; +void Expression_Literal::ArenaDtor(void* object) { + Expression_Literal* _this = reinterpret_cast< Expression_Literal* >(object); + (void)_this; +} +void Expression_Literal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_Literal::SetCachedSize(int size) const { + _cached_size_.Set(size); +} - switch (from.literal_type_case()) { +void Expression_Literal::clear_literal_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.Literal) + switch (literal_type_case()) { case kBoolean: { - _internal_set_boolean(from._internal_boolean()); + // No need to clear break; } case kI8: { - _internal_set_i8(from._internal_i8()); + // No need to clear break; } case kI16: { - _internal_set_i16(from._internal_i16()); + // No need to clear break; } case kI32: { - _internal_set_i32(from._internal_i32()); + // No need to clear break; } case kI64: { - _internal_set_i64(from._internal_i64()); + // No need to clear break; } case kFp32: { - _internal_set_fp32(from._internal_fp32()); + // No need to clear break; } case kFp64: { - _internal_set_fp64(from._internal_fp64()); + // No need to clear break; } case kString: { - _internal_set_string(from._internal_string()); + literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } case kBinary: { - _internal_set_binary(from._internal_binary()); + literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } case kTimestamp: { - _internal_set_timestamp(from._internal_timestamp()); + // No need to clear break; } case kDate: { - _internal_set_date(from._internal_date()); + // No need to clear break; } case kTime: { - _internal_set_time(from._internal_time()); + // No need to clear break; } case kIntervalYearToMonth: { - _internal_mutable_interval_year_to_month()->::io::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); + if (GetArena() == nullptr) { + delete literal_type_.interval_year_to_month_; + } break; } case kIntervalDayToSecond: { - _internal_mutable_interval_day_to_second()->::io::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); + if (GetArena() == nullptr) { + delete literal_type_.interval_day_to_second_; + } break; } case kFixedChar: { - _internal_set_fixed_char(from._internal_fixed_char()); + literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } case kVarChar: { - _internal_set_var_char(from._internal_var_char()); + if (GetArena() == nullptr) { + delete literal_type_.var_char_; + } break; } case kFixedBinary: { - _internal_set_fixed_binary(from._internal_fixed_binary()); + literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } case kDecimal: { - _internal_set_decimal(from._internal_decimal()); + if (GetArena() == nullptr) { + delete literal_type_.decimal_; + } break; } case kStruct: { - _internal_mutable_struct_()->::io::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); + if (GetArena() == nullptr) { + delete literal_type_.struct__; + } break; } case kMap: { - _internal_mutable_map()->::io::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); + if (GetArena() == nullptr) { + delete literal_type_.map_; + } break; } case kTimestampTz: { - _internal_set_timestamp_tz(from._internal_timestamp_tz()); + // No need to clear break; } case kUuid: { - _internal_set_uuid(from._internal_uuid()); + literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } case kNull: { - _internal_mutable_null()->::io::substrait::Type::MergeFrom(from._internal_null()); + if (GetArena() == nullptr) { + delete literal_type_.null_; + } break; } case kList: { - _internal_mutable_list()->::io::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); + if (GetArena() == nullptr) { + delete literal_type_.list_; + } break; } case LITERAL_TYPE_NOT_SET: { break; } } + _oneof_case_[0] = LITERAL_TYPE_NOT_SET; } -void Expression_Literal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Expression_Literal::CopyFrom(const Expression_Literal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Literal::IsInitialized() const { - return true; -} - -void Expression_Literal::InternalSwap(Expression_Literal* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(literal_type_, other->literal_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[8]); -} - -// =================================================================== - -class Expression_ScalarFunction::_Internal { - public: - static const ::io::substrait::Extensions_FunctionId& id(const Expression_ScalarFunction* msg); - static const ::io::substrait::Type& output_type(const Expression_ScalarFunction* msg); -}; - -const ::io::substrait::Extensions_FunctionId& -Expression_ScalarFunction::_Internal::id(const Expression_ScalarFunction* msg) { - return *msg->id_; -} -const ::io::substrait::Type& -Expression_ScalarFunction::_Internal::output_type(const Expression_ScalarFunction* msg) { - return *msg->output_type_; -} -void Expression_ScalarFunction::clear_id() { - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; -} -void Expression_ScalarFunction::clear_output_type() { - if (GetArena() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; -} -Expression_ScalarFunction::Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - args_(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ScalarFunction) -} -Expression_ScalarFunction::Expression_ScalarFunction(const Expression_ScalarFunction& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - args_(from.args_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_id()) { - id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); - } else { - id_ = nullptr; - } - if (from._internal_has_output_type()) { - output_type_ = new ::io::substrait::Type(*from.output_type_); - } else { - output_type_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ScalarFunction) -} - -void Expression_ScalarFunction::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&id_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&output_type_) - - reinterpret_cast(&id_)) + sizeof(output_type_)); -} - -Expression_ScalarFunction::~Expression_ScalarFunction() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.ScalarFunction) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Expression_ScalarFunction::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete id_; - if (this != internal_default_instance()) delete output_type_; -} - -void Expression_ScalarFunction::ArenaDtor(void* object) { - Expression_ScalarFunction* _this = reinterpret_cast< Expression_ScalarFunction* >(object); - (void)_this; -} -void Expression_ScalarFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_ScalarFunction::SetCachedSize(int size) const { - _cached_size_.Set(size); -} -void Expression_ScalarFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ScalarFunction) +void Expression_Literal::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - args_.Clear(); - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; - if (GetArena() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; + nullable_ = false; + clear_literal_type(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Extensions.FunctionId id = 1; + // bool boolean = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + _internal_set_boolean(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Expression args = 2; + // int32 i8 = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_args(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + _internal_set_i8(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type output_type = 3; + // int32 i16 = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _internal_set_i16(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 i32 = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { + _internal_set_i32(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 i64 = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + _internal_set_i64(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // float fp32 = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 85)) { + _internal_set_fp32(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(float); + } else goto handle_unusual; + continue; + // double fp64 = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 89)) { + _internal_set_fp64(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); + ptr += sizeof(double); + } else goto handle_unusual; + continue; + // string string = 12; + case 12: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + auto str = _internal_mutable_string(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.string")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes binary = 13; + case 13: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + auto str = _internal_mutable_binary(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 timestamp = 14; + case 14: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) { + _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 date = 16; + case 16: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 128)) { + _internal_set_date(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 time = 17; + case 17: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) { + _internal_set_time(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + case 19: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { + ptr = ctx->ParseMessage(_internal_mutable_interval_year_to_month(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + case 20: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { + ptr = ctx->ParseMessage(_internal_mutable_interval_day_to_second(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string fixed_char = 21; + case 21: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { + auto str = _internal_mutable_fixed_char(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.fixed_char")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.VarChar var_char = 22; + case 22: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { + ptr = ctx->ParseMessage(_internal_mutable_var_char(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes fixed_binary = 23; + case 23: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { + auto str = _internal_mutable_fixed_binary(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.Decimal decimal = 24; + case 24: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { + ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.Struct struct = 25; + case 25: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.Map map = 26; + case 26: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) { + ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int64 timestamp_tz = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 216)) { + _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bytes uuid = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { + auto str = _internal_mutable_uuid(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Type null = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { + ptr = ctx->ParseMessage(_internal_mutable_null(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Literal.List list = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 242)) { + ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool nullable = 50; + case 50: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) { + nullable_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -3923,423 +4436,374 @@ const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBU #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_ScalarFunction::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ScalarFunction) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { + // bool boolean = 1; + if (_internal_has_boolean()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::id(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_boolean(), target); } - // repeated .io.substrait.Expression args = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_args_size()); i < n; i++) { + // int32 i8 = 2; + if (_internal_has_i8()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_args(i), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_i8(), target); } - // .io.substrait.Type output_type = 3; - if (this->has_output_type()) { + // int32 i16 = 3; + if (_internal_has_i16()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::output_type(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_i16(), target); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + // int32 i32 = 5; + if (_internal_has_i32()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_i32(), target); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ScalarFunction) - return target; -} -size_t Expression_ScalarFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ScalarFunction) - size_t total_size = 0; + // int64 i64 = 7; + if (_internal_has_i64()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_i64(), target); + } - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; + // float fp32 = 10; + if (_internal_has_fp32()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_fp32(), target); + } - // repeated .io.substrait.Expression args = 2; - total_size += 1UL * this->_internal_args_size(); - for (const auto& msg : this->args_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + // double fp64 = 11; + if (_internal_has_fp64()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(11, this->_internal_fp64(), target); } - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *id_); + // string string = 12; + if (_internal_has_string()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_string().data(), static_cast(this->_internal_string().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.Literal.string"); + target = stream->WriteStringMaybeAliased( + 12, this->_internal_string(), target); } - // .io.substrait.Type output_type = 3; - if (this->has_output_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *output_type_); + // bytes binary = 13; + if (_internal_has_binary()) { + target = stream->WriteBytesMaybeAliased( + 13, this->_internal_binary(), target); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); + // int64 timestamp = 14; + if (_internal_has_timestamp()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(14, this->_internal_timestamp(), target); } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} -void Expression_ScalarFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ScalarFunction) - GOOGLE_DCHECK_NE(&from, this); - const Expression_ScalarFunction* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ScalarFunction) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ScalarFunction) - MergeFrom(*source); + // int64 date = 16; + if (_internal_has_date()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(16, this->_internal_date(), target); } -} - -void Expression_ScalarFunction::MergeFrom(const Expression_ScalarFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ScalarFunction) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - args_.MergeFrom(from.args_); - if (from.has_id()) { - _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); - } - if (from.has_output_type()) { - _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + // int64 time = 17; + if (_internal_has_time()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(17, this->_internal_time(), target); } -} - -void Expression_ScalarFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ScalarFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -void Expression_ScalarFunction::CopyFrom(const Expression_ScalarFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ScalarFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_ScalarFunction::IsInitialized() const { - return true; -} - -void Expression_ScalarFunction::InternalSwap(Expression_ScalarFunction* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - args_.InternalSwap(&other->args_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, output_type_) - + sizeof(Expression_ScalarFunction::output_type_) - - PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, id_)>( - reinterpret_cast(&id_), - reinterpret_cast(&other->id_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_ScalarFunction::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[9]); -} - -// =================================================================== - -class Expression_AggregateFunction::_Internal { - public: - static const ::io::substrait::Extensions_FunctionId& id(const Expression_AggregateFunction* msg); - static const ::io::substrait::Type& output_type(const Expression_AggregateFunction* msg); -}; - -const ::io::substrait::Extensions_FunctionId& -Expression_AggregateFunction::_Internal::id(const Expression_AggregateFunction* msg) { - return *msg->id_; -} -const ::io::substrait::Type& -Expression_AggregateFunction::_Internal::output_type(const Expression_AggregateFunction* msg) { - return *msg->output_type_; -} -void Expression_AggregateFunction::clear_id() { - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; -} -void Expression_AggregateFunction::clear_output_type() { - if (GetArena() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; -} -Expression_AggregateFunction::Expression_AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - args_(arena), - sorts_(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.AggregateFunction) -} -Expression_AggregateFunction::Expression_AggregateFunction(const Expression_AggregateFunction& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - args_(from.args_), - sorts_(from.sorts_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_id()) { - id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); - } else { - id_ = nullptr; - } - if (from._internal_has_output_type()) { - output_type_ = new ::io::substrait::Type(*from.output_type_); - } else { - output_type_ = nullptr; + // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + if (_internal_has_interval_year_to_month()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 19, _Internal::interval_year_to_month(this), target, stream); } - phase_ = from.phase_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.AggregateFunction) -} - -void Expression_AggregateFunction::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&id_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&phase_) - - reinterpret_cast(&id_)) + sizeof(phase_)); -} - -Expression_AggregateFunction::~Expression_AggregateFunction() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.AggregateFunction) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Expression_AggregateFunction::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete id_; - if (this != internal_default_instance()) delete output_type_; -} - -void Expression_AggregateFunction::ArenaDtor(void* object) { - Expression_AggregateFunction* _this = reinterpret_cast< Expression_AggregateFunction* >(object); - (void)_this; -} -void Expression_AggregateFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_AggregateFunction::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_AggregateFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.AggregateFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - args_.Clear(); - sorts_.Clear(); - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; + // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + if (_internal_has_interval_day_to_second()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 20, _Internal::interval_day_to_second(this), target, stream); } - id_ = nullptr; - if (GetArena() == nullptr && output_type_ != nullptr) { - delete output_type_; + + // string fixed_char = 21; + if (_internal_has_fixed_char()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_fixed_char().data(), static_cast(this->_internal_fixed_char().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.Literal.fixed_char"); + target = stream->WriteStringMaybeAliased( + 21, this->_internal_fixed_char(), target); } - output_type_ = nullptr; - phase_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} -const char* Expression_AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .io.substrait.Extensions.FunctionId id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // repeated .io.substrait.Expression args = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_args(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; - continue; - // repeated .io.substrait.Expression.SortField sorts = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_sorts(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; - continue; - // .io.substrait.Expression.AggregationPhase phase = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_phase(static_cast<::io::substrait::Expression_AggregationPhase>(val)); - } else goto handle_unusual; - continue; - // .io.substrait.Type output_type = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} + // .io.substrait.Expression.Literal.VarChar var_char = 22; + if (_internal_has_var_char()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 22, _Internal::var_char(this), target, stream); + } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_AggregateFunction::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.AggregateFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; + // bytes fixed_binary = 23; + if (_internal_has_fixed_binary()) { + target = stream->WriteBytesMaybeAliased( + 23, this->_internal_fixed_binary(), target); + } - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { + // .io.substrait.Expression.Literal.Decimal decimal = 24; + if (_internal_has_decimal()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 1, _Internal::id(this), target, stream); + 24, _Internal::decimal(this), target, stream); } - // repeated .io.substrait.Expression args = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_args_size()); i < n; i++) { + // .io.substrait.Expression.Literal.Struct struct = 25; + if (_internal_has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_args(i), target, stream); + InternalWriteMessage( + 25, _Internal::struct_(this), target, stream); } - // repeated .io.substrait.Expression.SortField sorts = 3; - for (unsigned int i = 0, - n = static_cast(this->_internal_sorts_size()); i < n; i++) { + // .io.substrait.Expression.Literal.Map map = 26; + if (_internal_has_map()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, this->_internal_sorts(i), target, stream); + InternalWriteMessage( + 26, _Internal::map(this), target, stream); } - // .io.substrait.Expression.AggregationPhase phase = 4; - if (this->phase() != 0) { + // int64 timestamp_tz = 27; + if (_internal_has_timestamp_tz()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 4, this->_internal_phase(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(27, this->_internal_timestamp_tz(), target); } - // .io.substrait.Type output_type = 5; - if (this->has_output_type()) { + // bytes uuid = 28; + if (_internal_has_uuid()) { + target = stream->WriteBytesMaybeAliased( + 28, this->_internal_uuid(), target); + } + + // .io.substrait.Type null = 29; + if (_internal_has_null()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 5, _Internal::output_type(this), target, stream); + 29, _Internal::null(this), target, stream); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.AggregateFunction) + // .io.substrait.Expression.Literal.List list = 30; + if (_internal_has_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 30, _Internal::list(this), target, stream); + } + + // bool nullable = 50; + if (this->nullable() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(50, this->_internal_nullable(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal) return target; } -size_t Expression_AggregateFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.AggregateFunction) +size_t Expression_Literal::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression args = 2; - total_size += 1UL * this->_internal_args_size(); - for (const auto& msg : this->args_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .io.substrait.Expression.SortField sorts = 3; - total_size += 1UL * this->_internal_sorts_size(); - for (const auto& msg : this->sorts_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *id_); - } - - // .io.substrait.Type output_type = 5; - if (this->has_output_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *output_type_); + // bool nullable = 50; + if (this->nullable() != 0) { + total_size += 2 + 1; } - // .io.substrait.Expression.AggregationPhase phase = 4; - if (this->phase() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); + switch (literal_type_case()) { + // bool boolean = 1; + case kBoolean: { + total_size += 1 + 1; + break; + } + // int32 i8 = 2; + case kI8: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_i8()); + break; + } + // int32 i16 = 3; + case kI16: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_i16()); + break; + } + // int32 i32 = 5; + case kI32: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_i32()); + break; + } + // int64 i64 = 7; + case kI64: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_i64()); + break; + } + // float fp32 = 10; + case kFp32: { + total_size += 1 + 4; + break; + } + // double fp64 = 11; + case kFp64: { + total_size += 1 + 8; + break; + } + // string string = 12; + case kString: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_string()); + break; + } + // bytes binary = 13; + case kBinary: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_binary()); + break; + } + // int64 timestamp = 14; + case kTimestamp: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_timestamp()); + break; + } + // int64 date = 16; + case kDate: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_date()); + break; + } + // int64 time = 17; + case kTime: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_time()); + break; + } + // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + case kIntervalYearToMonth: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.interval_year_to_month_); + break; + } + // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + case kIntervalDayToSecond: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.interval_day_to_second_); + break; + } + // string fixed_char = 21; + case kFixedChar: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_fixed_char()); + break; + } + // .io.substrait.Expression.Literal.VarChar var_char = 22; + case kVarChar: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.var_char_); + break; + } + // bytes fixed_binary = 23; + case kFixedBinary: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_fixed_binary()); + break; + } + // .io.substrait.Expression.Literal.Decimal decimal = 24; + case kDecimal: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.decimal_); + break; + } + // .io.substrait.Expression.Literal.Struct struct = 25; + case kStruct: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.struct__); + break; + } + // .io.substrait.Expression.Literal.Map map = 26; + case kMap: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.map_); + break; + } + // int64 timestamp_tz = 27; + case kTimestampTz: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_timestamp_tz()); + break; + } + // bytes uuid = 28; + case kUuid: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( + this->_internal_uuid()); + break; + } + // .io.substrait.Type null = 29; + case kNull: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.null_); + break; + } + // .io.substrait.Expression.Literal.List list = 30; + case kList: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.list_); + break; + } + case LITERAL_TYPE_NOT_SET: { + break; + } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -4349,141 +4813,275 @@ size_t Expression_AggregateFunction::ByteSizeLong() const { return total_size; } -void Expression_AggregateFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.AggregateFunction) +void Expression_Literal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal) GOOGLE_DCHECK_NE(&from, this); - const Expression_AggregateFunction* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Expression_Literal* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.AggregateFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.AggregateFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal) MergeFrom(*source); } } -void Expression_AggregateFunction::MergeFrom(const Expression_AggregateFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.AggregateFunction) +void Expression_Literal::MergeFrom(const Expression_Literal& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - args_.MergeFrom(from.args_); - sorts_.MergeFrom(from.sorts_); - if (from.has_id()) { - _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); - } - if (from.has_output_type()) { - _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + if (from.nullable() != 0) { + _internal_set_nullable(from._internal_nullable()); } - if (from.phase() != 0) { - _internal_set_phase(from._internal_phase()); - } -} - -void Expression_AggregateFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.AggregateFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Expression_AggregateFunction::CopyFrom(const Expression_AggregateFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.AggregateFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_AggregateFunction::IsInitialized() const { - return true; -} - -void Expression_AggregateFunction::InternalSwap(Expression_AggregateFunction* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - args_.InternalSwap(&other->args_); - sorts_.InternalSwap(&other->sorts_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_AggregateFunction, phase_) - + sizeof(Expression_AggregateFunction::phase_) - - PROTOBUF_FIELD_OFFSET(Expression_AggregateFunction, id_)>( - reinterpret_cast(&id_), - reinterpret_cast(&other->id_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_AggregateFunction::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[10]); -} - -// =================================================================== - -class Expression_WindowFunction_Bound_Preceding::_Internal { - public: -}; - -Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound.Preceding) -} -Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { + switch (from.literal_type_case()) { + case kBoolean: { + _internal_set_boolean(from._internal_boolean()); + break; + } + case kI8: { + _internal_set_i8(from._internal_i8()); + break; + } + case kI16: { + _internal_set_i16(from._internal_i16()); + break; + } + case kI32: { + _internal_set_i32(from._internal_i32()); + break; + } + case kI64: { + _internal_set_i64(from._internal_i64()); + break; + } + case kFp32: { + _internal_set_fp32(from._internal_fp32()); + break; + } + case kFp64: { + _internal_set_fp64(from._internal_fp64()); + break; + } + case kString: { + _internal_set_string(from._internal_string()); + break; + } + case kBinary: { + _internal_set_binary(from._internal_binary()); + break; + } + case kTimestamp: { + _internal_set_timestamp(from._internal_timestamp()); + break; + } + case kDate: { + _internal_set_date(from._internal_date()); + break; + } + case kTime: { + _internal_set_time(from._internal_time()); + break; + } + case kIntervalYearToMonth: { + _internal_mutable_interval_year_to_month()->::io::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); + break; + } + case kIntervalDayToSecond: { + _internal_mutable_interval_day_to_second()->::io::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); + break; + } + case kFixedChar: { + _internal_set_fixed_char(from._internal_fixed_char()); + break; + } + case kVarChar: { + _internal_mutable_var_char()->::io::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char()); + break; + } + case kFixedBinary: { + _internal_set_fixed_binary(from._internal_fixed_binary()); + break; + } + case kDecimal: { + _internal_mutable_decimal()->::io::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal()); + break; + } + case kStruct: { + _internal_mutable_struct_()->::io::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); + break; + } + case kTimestampTz: { + _internal_set_timestamp_tz(from._internal_timestamp_tz()); + break; + } + case kUuid: { + _internal_set_uuid(from._internal_uuid()); + break; + } + case kNull: { + _internal_mutable_null()->::io::substrait::Type::MergeFrom(from._internal_null()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); + break; + } + case LITERAL_TYPE_NOT_SET: { + break; + } + } +} + +void Expression_Literal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_Literal::CopyFrom(const Expression_Literal& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_Literal::IsInitialized() const { + return true; +} + +void Expression_Literal::InternalSwap(Expression_Literal* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(nullable_, other->nullable_); + swap(literal_type_, other->literal_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[10]); +} + +// =================================================================== + +class Expression_ScalarFunction::_Internal { + public: + static const ::io::substrait::Type& output_type(const Expression_ScalarFunction* msg); +}; + +const ::io::substrait::Type& +Expression_ScalarFunction::_Internal::output_type(const Expression_ScalarFunction* msg) { + return *msg->output_type_; +} +void Expression_ScalarFunction::clear_output_type() { + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; +} +Expression_ScalarFunction::Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + args_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ScalarFunction) +} +Expression_ScalarFunction::Expression_ScalarFunction(const Expression_ScalarFunction& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + args_(from.args_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - offset_ = from.offset_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound.Preceding) + if (from._internal_has_output_type()) { + output_type_ = new ::io::substrait::Type(*from.output_type_); + } else { + output_type_ = nullptr; + } + function_reference_ = from.function_reference_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ScalarFunction) } -void Expression_WindowFunction_Bound_Preceding::SharedCtor() { -offset_ = PROTOBUF_LONGLONG(0); +void Expression_ScalarFunction::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&output_type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&function_reference_) - + reinterpret_cast(&output_type_)) + sizeof(function_reference_)); } -Expression_WindowFunction_Bound_Preceding::~Expression_WindowFunction_Bound_Preceding() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound.Preceding) +Expression_ScalarFunction::~Expression_ScalarFunction() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.ScalarFunction) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_WindowFunction_Bound_Preceding::SharedDtor() { +void Expression_ScalarFunction::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete output_type_; } -void Expression_WindowFunction_Bound_Preceding::ArenaDtor(void* object) { - Expression_WindowFunction_Bound_Preceding* _this = reinterpret_cast< Expression_WindowFunction_Bound_Preceding* >(object); +void Expression_ScalarFunction::ArenaDtor(void* object) { + Expression_ScalarFunction* _this = reinterpret_cast< Expression_ScalarFunction* >(object); (void)_this; } -void Expression_WindowFunction_Bound_Preceding::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void Expression_ScalarFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_WindowFunction_Bound_Preceding::SetCachedSize(int size) const { +void Expression_ScalarFunction::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression_WindowFunction_Bound_Preceding::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound.Preceding) +void Expression_ScalarFunction::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ScalarFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - offset_ = PROTOBUF_LONGLONG(0); + args_.Clear(); + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; + function_reference_ = 0u; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_WindowFunction_Bound_Preceding::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // int64 offset = 1; + // uint32 function_reference = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Expression args = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_args(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Type output_type = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -4510,42 +5108,272 @@ const char* Expression_WindowFunction_Bound_Preceding::_InternalParse(const char #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Preceding::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_ScalarFunction::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ScalarFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // int64 offset = 1; - if (this->offset() != 0) { + // uint32 function_reference = 1; + if (this->function_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); + } + + // repeated .io.substrait.Expression args = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_args_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_args(i), target, stream); + } + + // .io.substrait.Type output_type = 3; + if (this->has_output_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::output_type(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound.Preceding) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ScalarFunction) return target; } -size_t Expression_WindowFunction_Bound_Preceding::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound.Preceding) +size_t Expression_ScalarFunction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ScalarFunction) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // int64 offset = 1; - if (this->offset() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_offset()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + // repeated .io.substrait.Expression args = 2; + total_size += 1UL * this->_internal_args_size(); + for (const auto& msg : this->args_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Type output_type = 3; + if (this->has_output_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *output_type_); + } + + // uint32 function_reference = 1; + if (this->function_reference() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_function_reference()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_ScalarFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ScalarFunction) + GOOGLE_DCHECK_NE(&from, this); + const Expression_ScalarFunction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ScalarFunction) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ScalarFunction) + MergeFrom(*source); + } +} + +void Expression_ScalarFunction::MergeFrom(const Expression_ScalarFunction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ScalarFunction) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + args_.MergeFrom(from.args_); + if (from.has_output_type()) { + _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + } + if (from.function_reference() != 0) { + _internal_set_function_reference(from._internal_function_reference()); + } +} + +void Expression_ScalarFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ScalarFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_ScalarFunction::CopyFrom(const Expression_ScalarFunction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ScalarFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_ScalarFunction::IsInitialized() const { + return true; +} + +void Expression_ScalarFunction::InternalSwap(Expression_ScalarFunction* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + args_.InternalSwap(&other->args_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, function_reference_) + + sizeof(Expression_ScalarFunction::function_reference_) + - PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, output_type_)>( + reinterpret_cast(&output_type_), + reinterpret_cast(&other->output_type_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_ScalarFunction::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[11]); +} + +// =================================================================== + +class Expression_WindowFunction_Bound_Preceding::_Internal { + public: +}; + +Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound.Preceding) +} +Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + offset_ = from.offset_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound.Preceding) +} + +void Expression_WindowFunction_Bound_Preceding::SharedCtor() { +offset_ = PROTOBUF_LONGLONG(0); +} + +Expression_WindowFunction_Bound_Preceding::~Expression_WindowFunction_Bound_Preceding() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound.Preceding) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_WindowFunction_Bound_Preceding::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_WindowFunction_Bound_Preceding::ArenaDtor(void* object) { + Expression_WindowFunction_Bound_Preceding* _this = reinterpret_cast< Expression_WindowFunction_Bound_Preceding* >(object); + (void)_this; +} +void Expression_WindowFunction_Bound_Preceding::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_WindowFunction_Bound_Preceding::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_WindowFunction_Bound_Preceding::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + offset_ = PROTOBUF_LONGLONG(0); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_WindowFunction_Bound_Preceding::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int64 offset = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Preceding::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int64 offset = 1; + if (this->offset() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound.Preceding) + return target; +} + +size_t Expression_WindowFunction_Bound_Preceding::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int64 offset = 1; + if (this->offset() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + this->_internal_offset()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); } @@ -4608,7 +5436,7 @@ void Expression_WindowFunction_Bound_Preceding::InternalSwap(Expression_WindowFu ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Preceding::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[11]); + file_level_metadata_expression_2eproto[12]); } // =================================================================== @@ -4798,7 +5626,7 @@ void Expression_WindowFunction_Bound_Following::InternalSwap(Expression_WindowFu ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Following::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[12]); + file_level_metadata_expression_2eproto[13]); } // =================================================================== @@ -4956,7 +5784,7 @@ void Expression_WindowFunction_Bound_CurrentRow::InternalSwap(Expression_WindowF ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_CurrentRow::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[13]); + file_level_metadata_expression_2eproto[14]); } // =================================================================== @@ -5114,7 +5942,7 @@ void Expression_WindowFunction_Bound_Unbounded::InternalSwap(Expression_WindowFu ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Unbounded::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[14]); + file_level_metadata_expression_2eproto[15]); } // =================================================================== @@ -5535,23 +6363,18 @@ void Expression_WindowFunction_Bound::InternalSwap(Expression_WindowFunction_Bou ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[15]); + file_level_metadata_expression_2eproto[16]); } // =================================================================== class Expression_WindowFunction::_Internal { public: - static const ::io::substrait::Extensions_FunctionId& id(const Expression_WindowFunction* msg); static const ::io::substrait::Expression_WindowFunction_Bound& upper_bound(const Expression_WindowFunction* msg); static const ::io::substrait::Expression_WindowFunction_Bound& lower_bound(const Expression_WindowFunction* msg); static const ::io::substrait::Type& output_type(const Expression_WindowFunction* msg); }; -const ::io::substrait::Extensions_FunctionId& -Expression_WindowFunction::_Internal::id(const Expression_WindowFunction* msg) { - return *msg->id_; -} const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_Internal::upper_bound(const Expression_WindowFunction* msg) { return *msg->upper_bound_; @@ -5564,12 +6387,6 @@ const ::io::substrait::Type& Expression_WindowFunction::_Internal::output_type(const Expression_WindowFunction* msg) { return *msg->output_type_; } -void Expression_WindowFunction::clear_id() { - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; -} void Expression_WindowFunction::clear_output_type() { if (GetArena() == nullptr && output_type_ != nullptr) { delete output_type_; @@ -5591,11 +6408,6 @@ Expression_WindowFunction::Expression_WindowFunction(const Expression_WindowFunc sorts_(from.sorts_), args_(from.args_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_id()) { - id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); - } else { - id_ = nullptr; - } if (from._internal_has_upper_bound()) { upper_bound_ = new ::io::substrait::Expression_WindowFunction_Bound(*from.upper_bound_); } else { @@ -5611,15 +6423,17 @@ Expression_WindowFunction::Expression_WindowFunction(const Expression_WindowFunc } else { output_type_ = nullptr; } - phase_ = from.phase_; + ::memcpy(&function_reference_, &from.function_reference_, + static_cast(reinterpret_cast(&phase_) - + reinterpret_cast(&function_reference_)) + sizeof(phase_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction) } void Expression_WindowFunction::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&id_) - reinterpret_cast(this)), + reinterpret_cast(&upper_bound_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&phase_) - - reinterpret_cast(&id_)) + sizeof(phase_)); + reinterpret_cast(&upper_bound_)) + sizeof(phase_)); } Expression_WindowFunction::~Expression_WindowFunction() { @@ -5630,7 +6444,6 @@ Expression_WindowFunction::~Expression_WindowFunction() { void Expression_WindowFunction::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete id_; if (this != internal_default_instance()) delete upper_bound_; if (this != internal_default_instance()) delete lower_bound_; if (this != internal_default_instance()) delete output_type_; @@ -5655,10 +6468,6 @@ void Expression_WindowFunction::Clear() { partitions_.Clear(); sorts_.Clear(); args_.Clear(); - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; if (GetArena() == nullptr && upper_bound_ != nullptr) { delete upper_bound_; } @@ -5671,7 +6480,9 @@ void Expression_WindowFunction::Clear() { delete output_type_; } output_type_ = nullptr; - phase_ = 0; + ::memset(&function_reference_, 0, static_cast( + reinterpret_cast(&phase_) - + reinterpret_cast(&function_reference_)) + sizeof(phase_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5681,10 +6492,10 @@ const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Extensions.FunctionId id = 1; + // uint32 function_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -5700,7 +6511,7 @@ const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBU } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // repeated .io.substrait.Expression.SortField sorts = 3; + // repeated .io.substrait.SortField sorts = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; @@ -5726,12 +6537,12 @@ const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBU CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.AggregationPhase phase = 6; + // .io.substrait.AggregationPhase phase = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_phase(static_cast<::io::substrait::Expression_AggregationPhase>(val)); + _internal_set_phase(static_cast<::io::substrait::AggregationPhase>(val)); } else goto handle_unusual; continue; // .io.substrait.Type output_type = 7; @@ -5782,12 +6593,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { + // uint32 function_reference = 1; + if (this->function_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::id(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); } // repeated .io.substrait.Expression partitions = 2; @@ -5798,7 +6607,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( InternalWriteMessage(2, this->_internal_partitions(i), target, stream); } - // repeated .io.substrait.Expression.SortField sorts = 3; + // repeated .io.substrait.SortField sorts = 3; for (unsigned int i = 0, n = static_cast(this->_internal_sorts_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -5822,7 +6631,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( 5, _Internal::lower_bound(this), target, stream); } - // .io.substrait.Expression.AggregationPhase phase = 6; + // .io.substrait.AggregationPhase phase = 6; if (this->phase() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -5868,7 +6677,7 @@ size_t Expression_WindowFunction::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.Expression.SortField sorts = 3; + // repeated .io.substrait.SortField sorts = 3; total_size += 1UL * this->_internal_sorts_size(); for (const auto& msg : this->sorts_) { total_size += @@ -5882,13 +6691,6 @@ size_t Expression_WindowFunction::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *id_); - } - // .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; if (this->has_upper_bound()) { total_size += 1 + @@ -5910,7 +6712,14 @@ size_t Expression_WindowFunction::ByteSizeLong() const { *output_type_); } - // .io.substrait.Expression.AggregationPhase phase = 6; + // uint32 function_reference = 1; + if (this->function_reference() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_function_reference()); + } + + // .io.substrait.AggregationPhase phase = 6; if (this->phase() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); @@ -5950,9 +6759,6 @@ void Expression_WindowFunction::MergeFrom(const Expression_WindowFunction& from) partitions_.MergeFrom(from.partitions_); sorts_.MergeFrom(from.sorts_); args_.MergeFrom(from.args_); - if (from.has_id()) { - _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); - } if (from.has_upper_bound()) { _internal_mutable_upper_bound()->::io::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_upper_bound()); } @@ -5962,6 +6768,9 @@ void Expression_WindowFunction::MergeFrom(const Expression_WindowFunction& from) if (from.has_output_type()) { _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); } + if (from.function_reference() != 0) { + _internal_set_function_reference(from._internal_function_reference()); + } if (from.phase() != 0) { _internal_set_phase(from._internal_phase()); } @@ -5994,176 +6803,118 @@ void Expression_WindowFunction::InternalSwap(Expression_WindowFunction* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, phase_) + sizeof(Expression_WindowFunction::phase_) - - PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, id_)>( - reinterpret_cast(&id_), - reinterpret_cast(&other->id_)); + - PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, upper_bound_)>( + reinterpret_cast(&upper_bound_), + reinterpret_cast(&other->upper_bound_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[16]); + file_level_metadata_expression_2eproto[17]); } // =================================================================== -class Expression_SortField::_Internal { +class Expression_IfThen_IfClause::_Internal { public: - static const ::io::substrait::Expression& expr(const Expression_SortField* msg); - static const ::io::substrait::Extensions_FunctionId& comparison_function(const Expression_SortField* msg); + static const ::io::substrait::Expression& if_(const Expression_IfThen_IfClause* msg); + static const ::io::substrait::Expression& then(const Expression_IfThen_IfClause* msg); }; const ::io::substrait::Expression& -Expression_SortField::_Internal::expr(const Expression_SortField* msg) { - return *msg->expr_; +Expression_IfThen_IfClause::_Internal::if_(const Expression_IfThen_IfClause* msg) { + return *msg->if__; } -const ::io::substrait::Extensions_FunctionId& -Expression_SortField::_Internal::comparison_function(const Expression_SortField* msg) { - return *msg->sort_kind_.comparison_function_; +const ::io::substrait::Expression& +Expression_IfThen_IfClause::_Internal::then(const Expression_IfThen_IfClause* msg) { + return *msg->then_; } -void Expression_SortField::set_allocated_comparison_function(::io::substrait::Extensions_FunctionId* comparison_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_sort_kind(); - if (comparison_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(comparison_function)->GetArena(); - if (message_arena != submessage_arena) { - comparison_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, comparison_function, submessage_arena); - } - set_has_comparison_function(); - sort_kind_.comparison_function_ = comparison_function; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SortField.comparison_function) -} -void Expression_SortField::clear_comparison_function() { - if (_internal_has_comparison_function()) { - if (GetArena() == nullptr) { - delete sort_kind_.comparison_function_; - } - clear_has_sort_kind(); - } -} -Expression_SortField::Expression_SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena) +Expression_IfThen_IfClause::Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.SortField) + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.IfThen.IfClause) } -Expression_SortField::Expression_SortField(const Expression_SortField& from) +Expression_IfThen_IfClause::Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_expr()) { - expr_ = new ::io::substrait::Expression(*from.expr_); + if (from._internal_has_if_()) { + if__ = new ::io::substrait::Expression(*from.if__); } else { - expr_ = nullptr; + if__ = nullptr; } - clear_has_sort_kind(); - switch (from.sort_kind_case()) { - case kDirection: { - _internal_set_direction(from._internal_direction()); - break; - } - case kComparisonFunction: { - _internal_mutable_comparison_function()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_comparison_function()); - break; - } - case SORT_KIND_NOT_SET: { - break; - } + if (from._internal_has_then()) { + then_ = new ::io::substrait::Expression(*from.then_); + } else { + then_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.SortField) + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.IfThen.IfClause) } -void Expression_SortField::SharedCtor() { -expr_ = nullptr; -clear_has_sort_kind(); +void Expression_IfThen_IfClause::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&if__) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&then_) - + reinterpret_cast(&if__)) + sizeof(then_)); } -Expression_SortField::~Expression_SortField() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.SortField) +Expression_IfThen_IfClause::~Expression_IfThen_IfClause() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.IfThen.IfClause) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_SortField::SharedDtor() { +void Expression_IfThen_IfClause::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete expr_; - if (has_sort_kind()) { - clear_sort_kind(); - } + if (this != internal_default_instance()) delete if__; + if (this != internal_default_instance()) delete then_; } -void Expression_SortField::ArenaDtor(void* object) { - Expression_SortField* _this = reinterpret_cast< Expression_SortField* >(object); +void Expression_IfThen_IfClause::ArenaDtor(void* object) { + Expression_IfThen_IfClause* _this = reinterpret_cast< Expression_IfThen_IfClause* >(object); (void)_this; } -void Expression_SortField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void Expression_IfThen_IfClause::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_SortField::SetCachedSize(int size) const { +void Expression_IfThen_IfClause::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression_SortField::clear_sort_kind() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.SortField) - switch (sort_kind_case()) { - case kDirection: { - // No need to clear - break; - } - case kComparisonFunction: { - if (GetArena() == nullptr) { - delete sort_kind_.comparison_function_; - } - break; - } - case SORT_KIND_NOT_SET: { - break; - } - } - _oneof_case_[0] = SORT_KIND_NOT_SET; -} - - -void Expression_SortField::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.SortField) +void Expression_IfThen_IfClause::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.IfThen.IfClause) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && expr_ != nullptr) { - delete expr_; + if (GetArena() == nullptr && if__ != nullptr) { + delete if__; } - expr_ = nullptr; - clear_sort_kind(); + if__ = nullptr; + if (GetArena() == nullptr && then_ != nullptr) { + delete then_; + } + then_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_SortField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_IfThen_IfClause::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression expr = 1; + // .io.substrait.Expression if = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_expr(), ptr); + ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.SortField.SortDirection direction = 2; + // .io.substrait.Expression then = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_direction(static_cast<::io::substrait::Expression_SortField_SortDirection>(val)); - } else goto handle_unusual; - continue; - // .io.substrait.Extensions.FunctionId comparison_function = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_comparison_function(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_then(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -6190,76 +6941,58 @@ const char* Expression_SortField::_InternalParse(const char* ptr, ::PROTOBUF_NAM #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_SortField::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen_IfClause::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.SortField) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.IfThen.IfClause) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression expr = 1; - if (this->has_expr()) { + // .io.substrait.Expression if = 1; + if (this->has_if_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 1, _Internal::expr(this), target, stream); - } - - // .io.substrait.Expression.SortField.SortDirection direction = 2; - if (_internal_has_direction()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_direction(), target); + 1, _Internal::if_(this), target, stream); } - // .io.substrait.Extensions.FunctionId comparison_function = 3; - if (_internal_has_comparison_function()) { + // .io.substrait.Expression then = 2; + if (this->has_then()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 3, _Internal::comparison_function(this), target, stream); + 2, _Internal::then(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.SortField) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.IfThen.IfClause) return target; } -size_t Expression_SortField::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.SortField) +size_t Expression_IfThen_IfClause::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.IfThen.IfClause) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression expr = 1; - if (this->has_expr()) { + // .io.substrait.Expression if = 1; + if (this->has_if_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *expr_); + *if__); } - switch (sort_kind_case()) { - // .io.substrait.Expression.SortField.SortDirection direction = 2; - case kDirection: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_direction()); - break; - } - // .io.substrait.Extensions.FunctionId comparison_function = 3; - case kComparisonFunction: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *sort_kind_.comparison_function_); - break; - } - case SORT_KIND_NOT_SET: { - break; - } + // .io.substrait.Expression then = 2; + if (this->has_then()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *then_); } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -6269,179 +7002,162 @@ size_t Expression_SortField::ByteSizeLong() const { return total_size; } -void Expression_SortField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.SortField) +void Expression_IfThen_IfClause::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.IfThen.IfClause) GOOGLE_DCHECK_NE(&from, this); - const Expression_SortField* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Expression_IfThen_IfClause* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.SortField) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.IfThen.IfClause) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.SortField) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.IfThen.IfClause) MergeFrom(*source); } } -void Expression_SortField::MergeFrom(const Expression_SortField& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.SortField) +void Expression_IfThen_IfClause::MergeFrom(const Expression_IfThen_IfClause& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.IfThen.IfClause) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_expr()) { - _internal_mutable_expr()->::io::substrait::Expression::MergeFrom(from._internal_expr()); + if (from.has_if_()) { + _internal_mutable_if_()->::io::substrait::Expression::MergeFrom(from._internal_if_()); } - switch (from.sort_kind_case()) { - case kDirection: { - _internal_set_direction(from._internal_direction()); - break; - } - case kComparisonFunction: { - _internal_mutable_comparison_function()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_comparison_function()); - break; - } - case SORT_KIND_NOT_SET: { - break; - } + if (from.has_then()) { + _internal_mutable_then()->::io::substrait::Expression::MergeFrom(from._internal_then()); } } -void Expression_SortField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.SortField) +void Expression_IfThen_IfClause::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.IfThen.IfClause) if (&from == this) return; Clear(); MergeFrom(from); } -void Expression_SortField::CopyFrom(const Expression_SortField& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.SortField) +void Expression_IfThen_IfClause::CopyFrom(const Expression_IfThen_IfClause& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.IfThen.IfClause) if (&from == this) return; Clear(); MergeFrom(from); } -bool Expression_SortField::IsInitialized() const { +bool Expression_IfThen_IfClause::IsInitialized() const { return true; } -void Expression_SortField::InternalSwap(Expression_SortField* other) { +void Expression_IfThen_IfClause::InternalSwap(Expression_IfThen_IfClause* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(expr_, other->expr_); - swap(sort_kind_, other->sort_kind_); - swap(_oneof_case_[0], other->_oneof_case_[0]); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, then_) + + sizeof(Expression_IfThen_IfClause::then_) + - PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, if__)>( + reinterpret_cast(&if__), + reinterpret_cast(&other->if__)); } -::PROTOBUF_NAMESPACE_ID::Metadata Expression_SortField::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen_IfClause::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[17]); + file_level_metadata_expression_2eproto[18]); } // =================================================================== -class Expression_IfThen_IfClause::_Internal { +class Expression_IfThen::_Internal { public: - static const ::io::substrait::Expression& if_(const Expression_IfThen_IfClause* msg); - static const ::io::substrait::Expression& then(const Expression_IfThen_IfClause* msg); + static const ::io::substrait::Expression& else_(const Expression_IfThen* msg); }; const ::io::substrait::Expression& -Expression_IfThen_IfClause::_Internal::if_(const Expression_IfThen_IfClause* msg) { - return *msg->if__; -} -const ::io::substrait::Expression& -Expression_IfThen_IfClause::_Internal::then(const Expression_IfThen_IfClause* msg) { - return *msg->then_; +Expression_IfThen::_Internal::else_(const Expression_IfThen* msg) { + return *msg->else__; } -Expression_IfThen_IfClause::Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_IfThen::Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + ifs_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.IfThen) } -Expression_IfThen_IfClause::Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { +Expression_IfThen::Expression_IfThen(const Expression_IfThen& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + ifs_(from.ifs_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_if_()) { - if__ = new ::io::substrait::Expression(*from.if__); - } else { - if__ = nullptr; - } - if (from._internal_has_then()) { - then_ = new ::io::substrait::Expression(*from.then_); + if (from._internal_has_else_()) { + else__ = new ::io::substrait::Expression(*from.else__); } else { - then_ = nullptr; + else__ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.IfThen) } -void Expression_IfThen_IfClause::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&if__) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&then_) - - reinterpret_cast(&if__)) + sizeof(then_)); +void Expression_IfThen::SharedCtor() { +else__ = nullptr; } -Expression_IfThen_IfClause::~Expression_IfThen_IfClause() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.IfThen.IfClause) +Expression_IfThen::~Expression_IfThen() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.IfThen) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_IfThen_IfClause::SharedDtor() { +void Expression_IfThen::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete if__; - if (this != internal_default_instance()) delete then_; + if (this != internal_default_instance()) delete else__; } -void Expression_IfThen_IfClause::ArenaDtor(void* object) { - Expression_IfThen_IfClause* _this = reinterpret_cast< Expression_IfThen_IfClause* >(object); +void Expression_IfThen::ArenaDtor(void* object) { + Expression_IfThen* _this = reinterpret_cast< Expression_IfThen* >(object); (void)_this; } -void Expression_IfThen_IfClause::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void Expression_IfThen::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_IfThen_IfClause::SetCachedSize(int size) const { +void Expression_IfThen::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression_IfThen_IfClause::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.IfThen.IfClause) +void Expression_IfThen::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.IfThen) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && if__ != nullptr) { - delete if__; + ifs_.Clear(); + if (GetArena() == nullptr && else__ != nullptr) { + delete else__; } - if__ = nullptr; - if (GetArena() == nullptr && then_ != nullptr) { - delete then_; - } - then_ = nullptr; + else__ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_IfThen_IfClause::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression if = 1; + // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); - CHK_(ptr); + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_ifs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Expression then = 2; + // .io.substrait.Expression else = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_then(), ptr); + ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -6468,56 +7184,56 @@ const char* Expression_IfThen_IfClause::_InternalParse(const char* ptr, ::PROTOB #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen_IfClause::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.IfThen) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression if = 1; - if (this->has_if_()) { + // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_ifs_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::if_(this), target, stream); + InternalWriteMessage(1, this->_internal_ifs(i), target, stream); } - // .io.substrait.Expression then = 2; - if (this->has_then()) { + // .io.substrait.Expression else = 2; + if (this->has_else_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 2, _Internal::then(this), target, stream); + 2, _Internal::else_(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.IfThen) return target; } -size_t Expression_IfThen_IfClause::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.IfThen.IfClause) +size_t Expression_IfThen::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.IfThen) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression if = 1; - if (this->has_if_()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *if__); + // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + total_size += 1UL * this->_internal_ifs_size(); + for (const auto& msg : this->ifs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Expression then = 2; - if (this->has_then()) { + // .io.substrait.Expression else = 2; + if (this->has_else_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *then_); + *else__); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -6529,162 +7245,172 @@ size_t Expression_IfThen_IfClause::ByteSizeLong() const { return total_size; } -void Expression_IfThen_IfClause::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.IfThen.IfClause) +void Expression_IfThen::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.IfThen) GOOGLE_DCHECK_NE(&from, this); - const Expression_IfThen_IfClause* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Expression_IfThen* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.IfThen) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.IfThen) MergeFrom(*source); } } -void Expression_IfThen_IfClause::MergeFrom(const Expression_IfThen_IfClause& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.IfThen.IfClause) +void Expression_IfThen::MergeFrom(const Expression_IfThen& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.IfThen) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_if_()) { - _internal_mutable_if_()->::io::substrait::Expression::MergeFrom(from._internal_if_()); - } - if (from.has_then()) { - _internal_mutable_then()->::io::substrait::Expression::MergeFrom(from._internal_then()); + ifs_.MergeFrom(from.ifs_); + if (from.has_else_()) { + _internal_mutable_else_()->::io::substrait::Expression::MergeFrom(from._internal_else_()); } } -void Expression_IfThen_IfClause::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.IfThen.IfClause) +void Expression_IfThen::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.IfThen) if (&from == this) return; Clear(); MergeFrom(from); } -void Expression_IfThen_IfClause::CopyFrom(const Expression_IfThen_IfClause& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.IfThen.IfClause) +void Expression_IfThen::CopyFrom(const Expression_IfThen& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.IfThen) if (&from == this) return; Clear(); MergeFrom(from); } -bool Expression_IfThen_IfClause::IsInitialized() const { +bool Expression_IfThen::IsInitialized() const { return true; } -void Expression_IfThen_IfClause::InternalSwap(Expression_IfThen_IfClause* other) { +void Expression_IfThen::InternalSwap(Expression_IfThen* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, then_) - + sizeof(Expression_IfThen_IfClause::then_) - - PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, if__)>( - reinterpret_cast(&if__), - reinterpret_cast(&other->if__)); + ifs_.InternalSwap(&other->ifs_); + swap(else__, other->else__); } -::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen_IfClause::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[18]); + file_level_metadata_expression_2eproto[19]); } // =================================================================== -class Expression_IfThen::_Internal { +class Expression_Cast::_Internal { public: - static const ::io::substrait::Expression& else_(const Expression_IfThen* msg); + static const ::io::substrait::Type& type(const Expression_Cast* msg); + static const ::io::substrait::Expression& input(const Expression_Cast* msg); }; +const ::io::substrait::Type& +Expression_Cast::_Internal::type(const Expression_Cast* msg) { + return *msg->type_; +} const ::io::substrait::Expression& -Expression_IfThen::_Internal::else_(const Expression_IfThen* msg) { - return *msg->else__; +Expression_Cast::_Internal::input(const Expression_Cast* msg) { + return *msg->input_; } -Expression_IfThen::Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - ifs_(arena) { +void Expression_Cast::clear_type() { + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; + } + type_ = nullptr; +} +Expression_Cast::Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Cast) } -Expression_IfThen::Expression_IfThen(const Expression_IfThen& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - ifs_(from.ifs_) { +Expression_Cast::Expression_Cast(const Expression_Cast& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_else_()) { - else__ = new ::io::substrait::Expression(*from.else__); + if (from._internal_has_type()) { + type_ = new ::io::substrait::Type(*from.type_); } else { - else__ = nullptr; + type_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.IfThen) + if (from._internal_has_input()) { + input_ = new ::io::substrait::Expression(*from.input_); + } else { + input_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Cast) } -void Expression_IfThen::SharedCtor() { -else__ = nullptr; +void Expression_Cast::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&input_) - + reinterpret_cast(&type_)) + sizeof(input_)); } -Expression_IfThen::~Expression_IfThen() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.IfThen) +Expression_Cast::~Expression_Cast() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.Cast) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_IfThen::SharedDtor() { +void Expression_Cast::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete else__; + if (this != internal_default_instance()) delete type_; + if (this != internal_default_instance()) delete input_; } -void Expression_IfThen::ArenaDtor(void* object) { - Expression_IfThen* _this = reinterpret_cast< Expression_IfThen* >(object); +void Expression_Cast::ArenaDtor(void* object) { + Expression_Cast* _this = reinterpret_cast< Expression_Cast* >(object); (void)_this; } -void Expression_IfThen::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void Expression_Cast::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression_IfThen::SetCachedSize(int size) const { +void Expression_Cast::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression_IfThen::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.IfThen) +void Expression_Cast::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Cast) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - ifs_.Clear(); - if (GetArena() == nullptr && else__ != nullptr) { - delete else__; + if (GetArena() == nullptr && type_ != nullptr) { + delete type_; } - else__ = nullptr; + type_ = nullptr; + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* Expression_Cast::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + // .io.substrait.Type type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_ifs(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); + CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression else = 2; + // .io.substrait.Expression input = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr); + ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -6711,56 +7437,56 @@ const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* Expression_Cast::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Cast) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_ifs_size()); i < n; i++) { + // .io.substrait.Type type = 1; + if (this->has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_ifs(i), target, stream); + InternalWriteMessage( + 1, _Internal::type(this), target, stream); } - // .io.substrait.Expression else = 2; - if (this->has_else_()) { + // .io.substrait.Expression input = 2; + if (this->has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 2, _Internal::else_(this), target, stream); + 2, _Internal::input(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Cast) return target; } -size_t Expression_IfThen::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.IfThen) +size_t Expression_Cast::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Cast) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; - total_size += 1UL * this->_internal_ifs_size(); - for (const auto& msg : this->ifs_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + // .io.substrait.Type type = 1; + if (this->has_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_); } - // .io.substrait.Expression else = 2; - if (this->has_else_()) { + // .io.substrait.Expression input = 2; + if (this->has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *else__); + *input_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -6772,74 +7498,80 @@ size_t Expression_IfThen::ByteSizeLong() const { return total_size; } -void Expression_IfThen::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.IfThen) +void Expression_Cast::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Cast) GOOGLE_DCHECK_NE(&from, this); - const Expression_IfThen* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Expression_Cast* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Cast) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Cast) MergeFrom(*source); } } -void Expression_IfThen::MergeFrom(const Expression_IfThen& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.IfThen) +void Expression_Cast::MergeFrom(const Expression_Cast& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Cast) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - ifs_.MergeFrom(from.ifs_); - if (from.has_else_()) { - _internal_mutable_else_()->::io::substrait::Expression::MergeFrom(from._internal_else_()); + if (from.has_type()) { + _internal_mutable_type()->::io::substrait::Type::MergeFrom(from._internal_type()); + } + if (from.has_input()) { + _internal_mutable_input()->::io::substrait::Expression::MergeFrom(from._internal_input()); } } -void Expression_IfThen::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.IfThen) +void Expression_Cast::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Cast) if (&from == this) return; Clear(); MergeFrom(from); } -void Expression_IfThen::CopyFrom(const Expression_IfThen& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.IfThen) +void Expression_Cast::CopyFrom(const Expression_Cast& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Cast) if (&from == this) return; Clear(); MergeFrom(from); } -bool Expression_IfThen::IsInitialized() const { +bool Expression_Cast::IsInitialized() const { return true; } -void Expression_IfThen::InternalSwap(Expression_IfThen* other) { +void Expression_Cast::InternalSwap(Expression_Cast* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ifs_.InternalSwap(&other->ifs_); - swap(else__, other->else__); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_Cast, input_) + + sizeof(Expression_Cast::input_) + - PROTOBUF_FIELD_OFFSET(Expression_Cast, type_)>( + reinterpret_cast(&type_), + reinterpret_cast(&other->type_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata Expression_Cast::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[19]); + file_level_metadata_expression_2eproto[20]); } // =================================================================== class Expression_SwitchExpression_IfValue::_Internal { public: - static const ::io::substrait::Expression& if_(const Expression_SwitchExpression_IfValue* msg); + static const ::io::substrait::Expression_Literal& if_(const Expression_SwitchExpression_IfValue* msg); static const ::io::substrait::Expression& then(const Expression_SwitchExpression_IfValue* msg); }; -const ::io::substrait::Expression& +const ::io::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::_Internal::if_(const Expression_SwitchExpression_IfValue* msg) { return *msg->if__; } @@ -6857,7 +7589,7 @@ Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(const E : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_if_()) { - if__ = new ::io::substrait::Expression(*from.if__); + if__ = new ::io::substrait::Expression_Literal(*from.if__); } else { if__ = nullptr; } @@ -6921,7 +7653,7 @@ const char* Expression_SwitchExpression_IfValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression if = 1; + // .io.substrait.Expression.Literal if = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); @@ -6964,7 +7696,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression_IfValue::_InternalSe ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression if = 1; + // .io.substrait.Expression.Literal if = 1; if (this->has_if_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6996,7 +7728,7 @@ size_t Expression_SwitchExpression_IfValue::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression if = 1; + // .io.substrait.Expression.Literal if = 1; if (this->has_if_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -7042,7 +7774,7 @@ void Expression_SwitchExpression_IfValue::MergeFrom(const Expression_SwitchExpre (void) cached_has_bits; if (from.has_if_()) { - _internal_mutable_if_()->::io::substrait::Expression::MergeFrom(from._internal_if_()); + _internal_mutable_if_()->::io::substrait::Expression_Literal::MergeFrom(from._internal_if_()); } if (from.has_then()) { _internal_mutable_then()->::io::substrait::Expression::MergeFrom(from._internal_then()); @@ -7081,7 +7813,7 @@ void Expression_SwitchExpression_IfValue::InternalSwap(Expression_SwitchExpressi ::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression_IfValue::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[20]); + file_level_metadata_expression_2eproto[21]); } // =================================================================== @@ -7318,7 +8050,7 @@ void Expression_SwitchExpression::InternalSwap(Expression_SwitchExpression* othe ::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[21]); + file_level_metadata_expression_2eproto[22]); } // =================================================================== @@ -7555,7 +8287,7 @@ void Expression_SingularOrList::InternalSwap(Expression_SingularOrList* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_SingularOrList::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[22]); + file_level_metadata_expression_2eproto[23]); } // =================================================================== @@ -7750,7 +8482,7 @@ void Expression_MultiOrList_Record::InternalSwap(Expression_MultiOrList_Record* ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList_Record::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[23]); + file_level_metadata_expression_2eproto[24]); } // =================================================================== @@ -7977,7 +8709,7 @@ void Expression_MultiOrList::InternalSwap(Expression_MultiOrList* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[24]); + file_level_metadata_expression_2eproto[25]); } // =================================================================== @@ -8210,7 +8942,7 @@ void Expression_EmbeddedFunction_PythonPickleFunction::InternalSwap(Expression_E ::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_PythonPickleFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[25]); + file_level_metadata_expression_2eproto[26]); } // =================================================================== @@ -8443,7 +9175,7 @@ void Expression_EmbeddedFunction_WebAssemblyFunction::InternalSwap(Expression_Em ::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_WebAssemblyFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[26]); + file_level_metadata_expression_2eproto[27]); } // =================================================================== @@ -8832,220 +9564,5149 @@ void Expression_EmbeddedFunction::InternalSwap(Expression_EmbeddedFunction* othe ::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[27]); + file_level_metadata_expression_2eproto[28]); } // =================================================================== -class Expression::_Internal { +class Expression_ReferenceSegment_MapKey::_Internal { public: - static const ::io::substrait::Expression_Literal& literal(const Expression* msg); - static const ::io::substrait::FieldReference& selection(const Expression* msg); - static const ::io::substrait::Expression_ScalarFunction& scalar_function(const Expression* msg); - static const ::io::substrait::Expression_WindowFunction& window_function(const Expression* msg); - static const ::io::substrait::Expression_IfThen& if_then(const Expression* msg); - static const ::io::substrait::Expression_SwitchExpression& switch_expression(const Expression* msg); - static const ::io::substrait::Expression_SingularOrList& singular_or_list(const Expression* msg); - static const ::io::substrait::Expression_MultiOrList& multi_or_list(const Expression* msg); - static const ::io::substrait::Expression_Enum& enum_(const Expression* msg); + static const ::io::substrait::Expression_Literal& map_key(const Expression_ReferenceSegment_MapKey* msg); + static const ::io::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_MapKey* msg); }; const ::io::substrait::Expression_Literal& -Expression::_Internal::literal(const Expression* msg) { - return *msg->rex_type_.literal_; -} -const ::io::substrait::FieldReference& -Expression::_Internal::selection(const Expression* msg) { - return *msg->rex_type_.selection_; +Expression_ReferenceSegment_MapKey::_Internal::map_key(const Expression_ReferenceSegment_MapKey* msg) { + return *msg->map_key_; } -const ::io::substrait::Expression_ScalarFunction& -Expression::_Internal::scalar_function(const Expression* msg) { - return *msg->rex_type_.scalar_function_; +const ::io::substrait::Expression_ReferenceSegment& +Expression_ReferenceSegment_MapKey::_Internal::child(const Expression_ReferenceSegment_MapKey* msg) { + return *msg->child_; } -const ::io::substrait::Expression_WindowFunction& -Expression::_Internal::window_function(const Expression* msg) { - return *msg->rex_type_.window_function_; +Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ReferenceSegment.MapKey) } -const ::io::substrait::Expression_IfThen& -Expression::_Internal::if_then(const Expression* msg) { - return *msg->rex_type_.if_then_; +Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(const Expression_ReferenceSegment_MapKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_map_key()) { + map_key_ = new ::io::substrait::Expression_Literal(*from.map_key_); + } else { + map_key_ = nullptr; + } + if (from._internal_has_child()) { + child_ = new ::io::substrait::Expression_ReferenceSegment(*from.child_); + } else { + child_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ReferenceSegment.MapKey) } -const ::io::substrait::Expression_SwitchExpression& -Expression::_Internal::switch_expression(const Expression* msg) { - return *msg->rex_type_.switch_expression_; + +void Expression_ReferenceSegment_MapKey::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&map_key_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&child_) - + reinterpret_cast(&map_key_)) + sizeof(child_)); } -const ::io::substrait::Expression_SingularOrList& -Expression::_Internal::singular_or_list(const Expression* msg) { - return *msg->rex_type_.singular_or_list_; + +Expression_ReferenceSegment_MapKey::~Expression_ReferenceSegment_MapKey() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.ReferenceSegment.MapKey) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const ::io::substrait::Expression_MultiOrList& -Expression::_Internal::multi_or_list(const Expression* msg) { - return *msg->rex_type_.multi_or_list_; + +void Expression_ReferenceSegment_MapKey::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete map_key_; + if (this != internal_default_instance()) delete child_; } -const ::io::substrait::Expression_Enum& -Expression::_Internal::enum_(const Expression* msg) { - return *msg->rex_type_.enum__; + +void Expression_ReferenceSegment_MapKey::ArenaDtor(void* object) { + Expression_ReferenceSegment_MapKey* _this = reinterpret_cast< Expression_ReferenceSegment_MapKey* >(object); + (void)_this; } -void Expression::set_allocated_literal(::io::substrait::Expression_Literal* literal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_rex_type(); - if (literal) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(literal); - if (message_arena != submessage_arena) { - literal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, literal, submessage_arena); - } - set_has_literal(); - rex_type_.literal_ = literal; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.literal) +void Expression_ReferenceSegment_MapKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression::set_allocated_selection(::io::substrait::FieldReference* selection) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_rex_type(); - if (selection) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(selection)->GetArena(); - if (message_arena != submessage_arena) { - selection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, selection, submessage_arena); - } - set_has_selection(); - rex_type_.selection_ = selection; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.selection) +void Expression_ReferenceSegment_MapKey::SetCachedSize(int size) const { + _cached_size_.Set(size); } -void Expression::clear_selection() { - if (_internal_has_selection()) { - if (GetArena() == nullptr) { - delete rex_type_.selection_; - } - clear_has_rex_type(); + +void Expression_ReferenceSegment_MapKey::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ReferenceSegment.MapKey) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && map_key_ != nullptr) { + delete map_key_; } -} -void Expression::set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_rex_type(); - if (scalar_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(scalar_function); - if (message_arena != submessage_arena) { - scalar_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, scalar_function, submessage_arena); - } - set_has_scalar_function(); - rex_type_.scalar_function_ = scalar_function; + map_key_ = nullptr; + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.scalar_function) + child_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression::set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_rex_type(); - if (window_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(window_function); - if (message_arena != submessage_arena) { - window_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, window_function, submessage_arena); - } - set_has_window_function(); - rex_type_.window_function_ = window_function; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.window_function) + +const char* Expression_ReferenceSegment_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.Literal map_key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.ReferenceSegment child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ } -void Expression::set_allocated_if_then(::io::substrait::Expression_IfThen* if_then) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_rex_type(); - if (if_then) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_then); - if (message_arena != submessage_arena) { - if_then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, if_then, submessage_arena); - } - set_has_if_then(); - rex_type_.if_then_ = if_then; + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_MapKey::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ReferenceSegment.MapKey) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.Literal map_key = 1; + if (this->has_map_key()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::map_key(this), target, stream); } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.if_then) -} -void Expression::set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_rex_type(); - if (switch_expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(switch_expression); - if (message_arena != submessage_arena) { - switch_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, switch_expression, submessage_arena); - } - set_has_switch_expression(); - rex_type_.switch_expression_ = switch_expression; + + // .io.substrait.Expression.ReferenceSegment child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.switch_expression) + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ReferenceSegment.MapKey) + return target; } -void Expression::set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_rex_type(); - if (singular_or_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(singular_or_list); - if (message_arena != submessage_arena) { - singular_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, singular_or_list, submessage_arena); - } - set_has_singular_or_list(); - rex_type_.singular_or_list_ = singular_or_list; + +size_t Expression_ReferenceSegment_MapKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ReferenceSegment.MapKey) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression.Literal map_key = 1; + if (this->has_map_key()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *map_key_); } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.singular_or_list) + + // .io.substrait.Expression.ReferenceSegment child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; } -void Expression::set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_rex_type(); - if (multi_or_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(multi_or_list); - if (message_arena != submessage_arena) { - multi_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, multi_or_list, submessage_arena); - } - set_has_multi_or_list(); - rex_type_.multi_or_list_ = multi_or_list; + +void Expression_ReferenceSegment_MapKey::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ReferenceSegment.MapKey) + GOOGLE_DCHECK_NE(&from, this); + const Expression_ReferenceSegment_MapKey* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ReferenceSegment.MapKey) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ReferenceSegment.MapKey) + MergeFrom(*source); } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.multi_or_list) } -void Expression::set_allocated_enum_(::io::substrait::Expression_Enum* enum_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_rex_type(); - if (enum_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(enum_); - if (message_arena != submessage_arena) { - enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, enum_, submessage_arena); - } - set_has_enum_(); - rex_type_.enum__ = enum_; + +void Expression_ReferenceSegment_MapKey::MergeFrom(const Expression_ReferenceSegment_MapKey& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ReferenceSegment.MapKey) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_map_key()) { + _internal_mutable_map_key()->::io::substrait::Expression_Literal::MergeFrom(from._internal_map_key()); } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.enum) + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); + } +} + +void Expression_ReferenceSegment_MapKey::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ReferenceSegment.MapKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_ReferenceSegment_MapKey::CopyFrom(const Expression_ReferenceSegment_MapKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ReferenceSegment.MapKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_ReferenceSegment_MapKey::IsInitialized() const { + return true; +} + +void Expression_ReferenceSegment_MapKey::InternalSwap(Expression_ReferenceSegment_MapKey* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_MapKey, child_) + + sizeof(Expression_ReferenceSegment_MapKey::child_) + - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_MapKey, map_key_)>( + reinterpret_cast(&map_key_), + reinterpret_cast(&other->map_key_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_MapKey::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[29]); +} + +// =================================================================== + +class Expression_ReferenceSegment_StructField::_Internal { + public: + static const ::io::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_StructField* msg); +}; + +const ::io::substrait::Expression_ReferenceSegment& +Expression_ReferenceSegment_StructField::_Internal::child(const Expression_ReferenceSegment_StructField* msg) { + return *msg->child_; +} +Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ReferenceSegment.StructField) +} +Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(const Expression_ReferenceSegment_StructField& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::Expression_ReferenceSegment(*from.child_); + } else { + child_ = nullptr; + } + field_ = from.field_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ReferenceSegment.StructField) +} + +void Expression_ReferenceSegment_StructField::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&child_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&field_) - + reinterpret_cast(&child_)) + sizeof(field_)); +} + +Expression_ReferenceSegment_StructField::~Expression_ReferenceSegment_StructField() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.ReferenceSegment.StructField) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_ReferenceSegment_StructField::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; +} + +void Expression_ReferenceSegment_StructField::ArenaDtor(void* object) { + Expression_ReferenceSegment_StructField* _this = reinterpret_cast< Expression_ReferenceSegment_StructField* >(object); + (void)_this; +} +void Expression_ReferenceSegment_StructField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_ReferenceSegment_StructField::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_ReferenceSegment_StructField::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ReferenceSegment.StructField) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + field_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_ReferenceSegment_StructField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 field = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.ReferenceSegment child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_StructField::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ReferenceSegment.StructField) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 field = 1; + if (this->field() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); + } + + // .io.substrait.Expression.ReferenceSegment child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ReferenceSegment.StructField) + return target; +} + +size_t Expression_ReferenceSegment_StructField::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ReferenceSegment.StructField) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression.ReferenceSegment child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + // int32 field = 1; + if (this->field() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_field()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_ReferenceSegment_StructField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ReferenceSegment.StructField) + GOOGLE_DCHECK_NE(&from, this); + const Expression_ReferenceSegment_StructField* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ReferenceSegment.StructField) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ReferenceSegment.StructField) + MergeFrom(*source); + } +} + +void Expression_ReferenceSegment_StructField::MergeFrom(const Expression_ReferenceSegment_StructField& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ReferenceSegment.StructField) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); + } + if (from.field() != 0) { + _internal_set_field(from._internal_field()); + } +} + +void Expression_ReferenceSegment_StructField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ReferenceSegment.StructField) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_ReferenceSegment_StructField::CopyFrom(const Expression_ReferenceSegment_StructField& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ReferenceSegment.StructField) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_ReferenceSegment_StructField::IsInitialized() const { + return true; +} + +void Expression_ReferenceSegment_StructField::InternalSwap(Expression_ReferenceSegment_StructField* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_StructField, field_) + + sizeof(Expression_ReferenceSegment_StructField::field_) + - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_StructField, child_)>( + reinterpret_cast(&child_), + reinterpret_cast(&other->child_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_StructField::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[30]); +} + +// =================================================================== + +class Expression_ReferenceSegment_ListElement::_Internal { + public: + static const ::io::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_ListElement* msg); +}; + +const ::io::substrait::Expression_ReferenceSegment& +Expression_ReferenceSegment_ListElement::_Internal::child(const Expression_ReferenceSegment_ListElement* msg) { + return *msg->child_; +} +Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ReferenceSegment.ListElement) +} +Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(const Expression_ReferenceSegment_ListElement& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::Expression_ReferenceSegment(*from.child_); + } else { + child_ = nullptr; + } + offset_ = from.offset_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ReferenceSegment.ListElement) +} + +void Expression_ReferenceSegment_ListElement::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&child_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&offset_) - + reinterpret_cast(&child_)) + sizeof(offset_)); +} + +Expression_ReferenceSegment_ListElement::~Expression_ReferenceSegment_ListElement() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.ReferenceSegment.ListElement) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_ReferenceSegment_ListElement::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; +} + +void Expression_ReferenceSegment_ListElement::ArenaDtor(void* object) { + Expression_ReferenceSegment_ListElement* _this = reinterpret_cast< Expression_ReferenceSegment_ListElement* >(object); + (void)_this; +} +void Expression_ReferenceSegment_ListElement::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_ReferenceSegment_ListElement::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_ReferenceSegment_ListElement::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ReferenceSegment.ListElement) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + offset_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_ReferenceSegment_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 offset = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.ReferenceSegment child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_ListElement::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ReferenceSegment.ListElement) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 offset = 1; + if (this->offset() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_offset(), target); + } + + // .io.substrait.Expression.ReferenceSegment child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ReferenceSegment.ListElement) + return target; +} + +size_t Expression_ReferenceSegment_ListElement::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ReferenceSegment.ListElement) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression.ReferenceSegment child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + // int32 offset = 1; + if (this->offset() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_offset()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_ReferenceSegment_ListElement::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ReferenceSegment.ListElement) + GOOGLE_DCHECK_NE(&from, this); + const Expression_ReferenceSegment_ListElement* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ReferenceSegment.ListElement) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ReferenceSegment.ListElement) + MergeFrom(*source); + } +} + +void Expression_ReferenceSegment_ListElement::MergeFrom(const Expression_ReferenceSegment_ListElement& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ReferenceSegment.ListElement) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); + } + if (from.offset() != 0) { + _internal_set_offset(from._internal_offset()); + } +} + +void Expression_ReferenceSegment_ListElement::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ReferenceSegment.ListElement) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_ReferenceSegment_ListElement::CopyFrom(const Expression_ReferenceSegment_ListElement& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ReferenceSegment.ListElement) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_ReferenceSegment_ListElement::IsInitialized() const { + return true; +} + +void Expression_ReferenceSegment_ListElement::InternalSwap(Expression_ReferenceSegment_ListElement* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_ListElement, offset_) + + sizeof(Expression_ReferenceSegment_ListElement::offset_) + - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_ListElement, child_)>( + reinterpret_cast(&child_), + reinterpret_cast(&other->child_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_ListElement::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[31]); +} + +// =================================================================== + +class Expression_ReferenceSegment::_Internal { + public: + static const ::io::substrait::Expression_ReferenceSegment_MapKey& map_key(const Expression_ReferenceSegment* msg); + static const ::io::substrait::Expression_ReferenceSegment_StructField& struct_field(const Expression_ReferenceSegment* msg); + static const ::io::substrait::Expression_ReferenceSegment_ListElement& list_element(const Expression_ReferenceSegment* msg); +}; + +const ::io::substrait::Expression_ReferenceSegment_MapKey& +Expression_ReferenceSegment::_Internal::map_key(const Expression_ReferenceSegment* msg) { + return *msg->reference_type_.map_key_; +} +const ::io::substrait::Expression_ReferenceSegment_StructField& +Expression_ReferenceSegment::_Internal::struct_field(const Expression_ReferenceSegment* msg) { + return *msg->reference_type_.struct_field_; +} +const ::io::substrait::Expression_ReferenceSegment_ListElement& +Expression_ReferenceSegment::_Internal::list_element(const Expression_ReferenceSegment* msg) { + return *msg->reference_type_.list_element_; +} +void Expression_ReferenceSegment::set_allocated_map_key(::io::substrait::Expression_ReferenceSegment_MapKey* map_key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (map_key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map_key); + if (message_arena != submessage_arena) { + map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map_key, submessage_arena); + } + set_has_map_key(); + reference_type_.map_key_ = map_key; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.map_key) +} +void Expression_ReferenceSegment::set_allocated_struct_field(::io::substrait::Expression_ReferenceSegment_StructField* struct_field) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (struct_field) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_field); + if (message_arena != submessage_arena) { + struct_field = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_field, submessage_arena); + } + set_has_struct_field(); + reference_type_.struct_field_ = struct_field; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.struct_field) +} +void Expression_ReferenceSegment::set_allocated_list_element(::io::substrait::Expression_ReferenceSegment_ListElement* list_element) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (list_element) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list_element); + if (message_arena != submessage_arena) { + list_element = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, list_element, submessage_arena); + } + set_has_list_element(); + reference_type_.list_element_ = list_element; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.list_element) +} +Expression_ReferenceSegment::Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ReferenceSegment) +} +Expression_ReferenceSegment::Expression_ReferenceSegment(const Expression_ReferenceSegment& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_reference_type(); + switch (from.reference_type_case()) { + case kMapKey: { + _internal_mutable_map_key()->::io::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); + break; + } + case kStructField: { + _internal_mutable_struct_field()->::io::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); + break; + } + case kListElement: { + _internal_mutable_list_element()->::io::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ReferenceSegment) +} + +void Expression_ReferenceSegment::SharedCtor() { +clear_has_reference_type(); +} + +Expression_ReferenceSegment::~Expression_ReferenceSegment() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.ReferenceSegment) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_ReferenceSegment::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_reference_type()) { + clear_reference_type(); + } +} + +void Expression_ReferenceSegment::ArenaDtor(void* object) { + Expression_ReferenceSegment* _this = reinterpret_cast< Expression_ReferenceSegment* >(object); + (void)_this; +} +void Expression_ReferenceSegment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_ReferenceSegment::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_ReferenceSegment::clear_reference_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.ReferenceSegment) + switch (reference_type_case()) { + case kMapKey: { + if (GetArena() == nullptr) { + delete reference_type_.map_key_; + } + break; + } + case kStructField: { + if (GetArena() == nullptr) { + delete reference_type_.struct_field_; + } + break; + } + case kListElement: { + if (GetArena() == nullptr) { + delete reference_type_.list_element_; + } + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; +} + + +void Expression_ReferenceSegment::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ReferenceSegment) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_reference_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_ReferenceSegment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.ReferenceSegment.MapKey map_key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.ReferenceSegment.StructField struct_field = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_field(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.ReferenceSegment.ListElement list_element = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_list_element(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ReferenceSegment) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.ReferenceSegment.MapKey map_key = 1; + if (_internal_has_map_key()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::map_key(this), target, stream); + } + + // .io.substrait.Expression.ReferenceSegment.StructField struct_field = 2; + if (_internal_has_struct_field()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::struct_field(this), target, stream); + } + + // .io.substrait.Expression.ReferenceSegment.ListElement list_element = 3; + if (_internal_has_list_element()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::list_element(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ReferenceSegment) + return target; +} + +size_t Expression_ReferenceSegment::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ReferenceSegment) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (reference_type_case()) { + // .io.substrait.Expression.ReferenceSegment.MapKey map_key = 1; + case kMapKey: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.map_key_); + break; + } + // .io.substrait.Expression.ReferenceSegment.StructField struct_field = 2; + case kStructField: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.struct_field_); + break; + } + // .io.substrait.Expression.ReferenceSegment.ListElement list_element = 3; + case kListElement: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.list_element_); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_ReferenceSegment::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ReferenceSegment) + GOOGLE_DCHECK_NE(&from, this); + const Expression_ReferenceSegment* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ReferenceSegment) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ReferenceSegment) + MergeFrom(*source); + } +} + +void Expression_ReferenceSegment::MergeFrom(const Expression_ReferenceSegment& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ReferenceSegment) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.reference_type_case()) { + case kMapKey: { + _internal_mutable_map_key()->::io::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); + break; + } + case kStructField: { + _internal_mutable_struct_field()->::io::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); + break; + } + case kListElement: { + _internal_mutable_list_element()->::io::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } +} + +void Expression_ReferenceSegment::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ReferenceSegment) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_ReferenceSegment::CopyFrom(const Expression_ReferenceSegment& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ReferenceSegment) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_ReferenceSegment::IsInitialized() const { + return true; +} + +void Expression_ReferenceSegment::InternalSwap(Expression_ReferenceSegment* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(reference_type_, other->reference_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[32]); +} + +// =================================================================== + +class Expression_MaskExpression_Select::_Internal { + public: + static const ::io::substrait::Expression_MaskExpression_StructSelect& struct_(const Expression_MaskExpression_Select* msg); + static const ::io::substrait::Expression_MaskExpression_ListSelect& list(const Expression_MaskExpression_Select* msg); + static const ::io::substrait::Expression_MaskExpression_MapSelect& map(const Expression_MaskExpression_Select* msg); +}; + +const ::io::substrait::Expression_MaskExpression_StructSelect& +Expression_MaskExpression_Select::_Internal::struct_(const Expression_MaskExpression_Select* msg) { + return *msg->type_.struct__; +} +const ::io::substrait::Expression_MaskExpression_ListSelect& +Expression_MaskExpression_Select::_Internal::list(const Expression_MaskExpression_Select* msg) { + return *msg->type_.list_; +} +const ::io::substrait::Expression_MaskExpression_MapSelect& +Expression_MaskExpression_Select::_Internal::map(const Expression_MaskExpression_Select* msg) { + return *msg->type_.map_; +} +void Expression_MaskExpression_Select::set_allocated_struct_(::io::substrait::Expression_MaskExpression_StructSelect* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_type(); + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + set_has_struct_(); + type_.struct__ = struct_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.Select.struct) +} +void Expression_MaskExpression_Select::set_allocated_list(::io::substrait::Expression_MaskExpression_ListSelect* list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_type(); + if (list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + if (message_arena != submessage_arena) { + list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, list, submessage_arena); + } + set_has_list(); + type_.list_ = list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.Select.list) +} +void Expression_MaskExpression_Select::set_allocated_map(::io::substrait::Expression_MaskExpression_MapSelect* map) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_type(); + if (map) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + if (message_arena != submessage_arena) { + map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map, submessage_arena); + } + set_has_map(); + type_.map_ = map; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.Select.map) +} +Expression_MaskExpression_Select::Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.Select) +} +Expression_MaskExpression_Select::Expression_MaskExpression_Select(const Expression_MaskExpression_Select& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_type(); + switch (from.type_case()) { + case kStruct: { + _internal_mutable_struct_()->::io::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map()); + break; + } + case TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.Select) +} + +void Expression_MaskExpression_Select::SharedCtor() { +clear_has_type(); +} + +Expression_MaskExpression_Select::~Expression_MaskExpression_Select() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.Select) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression_Select::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_type()) { + clear_type(); + } +} + +void Expression_MaskExpression_Select::ArenaDtor(void* object) { + Expression_MaskExpression_Select* _this = reinterpret_cast< Expression_MaskExpression_Select* >(object); + (void)_this; +} +void Expression_MaskExpression_Select::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression_Select::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression_Select::clear_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.MaskExpression.Select) + switch (type_case()) { + case kStruct: { + if (GetArena() == nullptr) { + delete type_.struct__; + } + break; + } + case kList: { + if (GetArena() == nullptr) { + delete type_.list_; + } + break; + } + case kMap: { + if (GetArena() == nullptr) { + delete type_.map_; + } + break; + } + case TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = TYPE_NOT_SET; +} + + +void Expression_MaskExpression_Select::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.Select) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression_Select::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.MaskExpression.StructSelect struct = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.MaskExpression.ListSelect list = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.MaskExpression.MapSelect map = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_Select::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.Select) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.MaskExpression.StructSelect struct = 1; + if (_internal_has_struct_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::struct_(this), target, stream); + } + + // .io.substrait.Expression.MaskExpression.ListSelect list = 2; + if (_internal_has_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::list(this), target, stream); + } + + // .io.substrait.Expression.MaskExpression.MapSelect map = 3; + if (_internal_has_map()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::map(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.Select) + return target; +} + +size_t Expression_MaskExpression_Select::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.Select) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (type_case()) { + // .io.substrait.Expression.MaskExpression.StructSelect struct = 1; + case kStruct: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_.struct__); + break; + } + // .io.substrait.Expression.MaskExpression.ListSelect list = 2; + case kList: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_.list_); + break; + } + // .io.substrait.Expression.MaskExpression.MapSelect map = 3; + case kMap: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_.map_); + break; + } + case TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression_Select::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.Select) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression_Select* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.Select) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.Select) + MergeFrom(*source); + } +} + +void Expression_MaskExpression_Select::MergeFrom(const Expression_MaskExpression_Select& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.Select) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.type_case()) { + case kStruct: { + _internal_mutable_struct_()->::io::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); + break; + } + case kList: { + _internal_mutable_list()->::io::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list()); + break; + } + case kMap: { + _internal_mutable_map()->::io::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map()); + break; + } + case TYPE_NOT_SET: { + break; + } + } +} + +void Expression_MaskExpression_Select::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.Select) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression_Select::CopyFrom(const Expression_MaskExpression_Select& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.Select) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression_Select::IsInitialized() const { + return true; +} + +void Expression_MaskExpression_Select::InternalSwap(Expression_MaskExpression_Select* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(type_, other->type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_Select::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[33]); +} + +// =================================================================== + +class Expression_MaskExpression_StructSelect::_Internal { + public: +}; + +Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + struct_items_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.StructSelect) +} +Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(const Expression_MaskExpression_StructSelect& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + struct_items_(from.struct_items_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.StructSelect) +} + +void Expression_MaskExpression_StructSelect::SharedCtor() { +} + +Expression_MaskExpression_StructSelect::~Expression_MaskExpression_StructSelect() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.StructSelect) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression_StructSelect::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_MaskExpression_StructSelect::ArenaDtor(void* object) { + Expression_MaskExpression_StructSelect* _this = reinterpret_cast< Expression_MaskExpression_StructSelect* >(object); + (void)_this; +} +void Expression_MaskExpression_StructSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression_StructSelect::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression_StructSelect::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.StructSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + struct_items_.Clear(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression_StructSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression.MaskExpression.StructItem struct_items = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_struct_items(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_StructSelect::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.StructSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression.MaskExpression.StructItem struct_items = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_struct_items_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_struct_items(i), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.StructSelect) + return target; +} + +size_t Expression_MaskExpression_StructSelect::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.StructSelect) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression.MaskExpression.StructItem struct_items = 1; + total_size += 1UL * this->_internal_struct_items_size(); + for (const auto& msg : this->struct_items_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression_StructSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.StructSelect) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression_StructSelect* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.StructSelect) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.StructSelect) + MergeFrom(*source); + } +} + +void Expression_MaskExpression_StructSelect::MergeFrom(const Expression_MaskExpression_StructSelect& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.StructSelect) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + struct_items_.MergeFrom(from.struct_items_); +} + +void Expression_MaskExpression_StructSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.StructSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression_StructSelect::CopyFrom(const Expression_MaskExpression_StructSelect& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.StructSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression_StructSelect::IsInitialized() const { + return true; +} + +void Expression_MaskExpression_StructSelect::InternalSwap(Expression_MaskExpression_StructSelect* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + struct_items_.InternalSwap(&other->struct_items_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_StructSelect::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[34]); +} + +// =================================================================== + +class Expression_MaskExpression_StructItem::_Internal { + public: + static const ::io::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_StructItem* msg); +}; + +const ::io::substrait::Expression_MaskExpression_Select& +Expression_MaskExpression_StructItem::_Internal::child(const Expression_MaskExpression_StructItem* msg) { + return *msg->child_; +} +Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.StructItem) +} +Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(const Expression_MaskExpression_StructItem& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::Expression_MaskExpression_Select(*from.child_); + } else { + child_ = nullptr; + } + field_ = from.field_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.StructItem) +} + +void Expression_MaskExpression_StructItem::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&child_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&field_) - + reinterpret_cast(&child_)) + sizeof(field_)); +} + +Expression_MaskExpression_StructItem::~Expression_MaskExpression_StructItem() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.StructItem) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression_StructItem::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; +} + +void Expression_MaskExpression_StructItem::ArenaDtor(void* object) { + Expression_MaskExpression_StructItem* _this = reinterpret_cast< Expression_MaskExpression_StructItem* >(object); + (void)_this; +} +void Expression_MaskExpression_StructItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression_StructItem::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression_StructItem::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.StructItem) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + field_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression_StructItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 field = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.MaskExpression.Select child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_StructItem::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.StructItem) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 field = 1; + if (this->field() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); + } + + // .io.substrait.Expression.MaskExpression.Select child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.StructItem) + return target; +} + +size_t Expression_MaskExpression_StructItem::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.StructItem) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression.MaskExpression.Select child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + // int32 field = 1; + if (this->field() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_field()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression_StructItem::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.StructItem) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression_StructItem* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.StructItem) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.StructItem) + MergeFrom(*source); + } +} + +void Expression_MaskExpression_StructItem::MergeFrom(const Expression_MaskExpression_StructItem& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.StructItem) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); + } + if (from.field() != 0) { + _internal_set_field(from._internal_field()); + } +} + +void Expression_MaskExpression_StructItem::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.StructItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression_StructItem::CopyFrom(const Expression_MaskExpression_StructItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.StructItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression_StructItem::IsInitialized() const { + return true; +} + +void Expression_MaskExpression_StructItem::InternalSwap(Expression_MaskExpression_StructItem* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_StructItem, field_) + + sizeof(Expression_MaskExpression_StructItem::field_) + - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_StructItem, child_)>( + reinterpret_cast(&child_), + reinterpret_cast(&other->child_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_StructItem::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[35]); +} + +// =================================================================== + +class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_Internal { + public: +}; + +Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) +} +Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + field_ = from.field_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedCtor() { +field_ = 0; +} + +Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::~Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ArenaDtor(void* object) { + Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _this = reinterpret_cast< Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* >(object); + (void)_this; +} +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + field_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 field = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 field = 1; + if (this->field() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + return target; +} + +size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 field = 1; + if (this->field() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_field()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + MergeFrom(*source); + } +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.field() != 0) { + _internal_set_field(from._internal_field()); + } +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::IsInitialized() const { + return true; +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(field_, other->field_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[36]); +} + +// =================================================================== + +class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_Internal { + public: +}; + +Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) +} +Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::memcpy(&start_, &from.start_, + static_cast(reinterpret_cast(&end_) - + reinterpret_cast(&start_)) + sizeof(end_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&start_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&end_) - + reinterpret_cast(&start_)) + sizeof(end_)); +} + +Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::~Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ArenaDtor(void* object) { + Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _this = reinterpret_cast< Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* >(object); + (void)_this; +} +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&start_, 0, static_cast( + reinterpret_cast(&end_) - + reinterpret_cast(&start_)) + sizeof(end_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // int32 start = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // int32 end = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // int32 start = 1; + if (this->start() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_start(), target); + } + + // int32 end = 2; + if (this->end() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + return target; +} + +size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // int32 start = 1; + if (this->start() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_start()); + } + + // int32 end = 2; + if (this->end() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_end()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + MergeFrom(*source); + } +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.start() != 0) { + _internal_set_start(from._internal_start()); + } + if (from.end() != 0) { + _internal_set_end(from._internal_end()); + } +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::IsInitialized() const { + return true; +} + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_) + + sizeof(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::end_) + - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, start_)>( + reinterpret_cast(&start_), + reinterpret_cast(&other->start_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[37]); +} + +// =================================================================== + +class Expression_MaskExpression_ListSelect_ListSelectItem::_Internal { + public: + static const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg); + static const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg); +}; + +const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& +Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg) { + return *msg->type_.item_; +} +const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& +Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg) { + return *msg->type_.slice_; +} +void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_type(); + if (item) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(item); + if (message_arena != submessage_arena) { + item = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, item, submessage_arena); + } + set_has_item(); + type_.item_ = item; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) +} +void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_type(); + if (slice) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(slice); + if (message_arena != submessage_arena) { + slice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, slice, submessage_arena); + } + set_has_slice(); + type_.slice_ = slice; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) +} +Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) +} +Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(const Expression_MaskExpression_ListSelect_ListSelectItem& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_type(); + switch (from.type_case()) { + case kItem: { + _internal_mutable_item()->::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); + break; + } + case kSlice: { + _internal_mutable_slice()->::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); + break; + } + case TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) +} + +void Expression_MaskExpression_ListSelect_ListSelectItem::SharedCtor() { +clear_has_type(); +} + +Expression_MaskExpression_ListSelect_ListSelectItem::~Expression_MaskExpression_ListSelect_ListSelectItem() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_type()) { + clear_type(); + } +} + +void Expression_MaskExpression_ListSelect_ListSelectItem::ArenaDtor(void* object) { + Expression_MaskExpression_ListSelect_ListSelectItem* _this = reinterpret_cast< Expression_MaskExpression_ListSelect_ListSelectItem* >(object); + (void)_this; +} +void Expression_MaskExpression_ListSelect_ListSelectItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression_ListSelect_ListSelectItem::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem::clear_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + switch (type_case()) { + case kItem: { + if (GetArena() == nullptr) { + delete type_.item_; + } + break; + } + case kSlice: { + if (GetArena() == nullptr) { + delete type_.slice_; + } + break; + } + case TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = TYPE_NOT_SET; +} + + +void Expression_MaskExpression_ListSelect_ListSelectItem::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_item(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_slice(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + if (_internal_has_item()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::item(this), target, stream); + } + + // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + if (_internal_has_slice()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::slice(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + return target; +} + +size_t Expression_MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (type_case()) { + // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + case kItem: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_.item_); + break; + } + // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + case kSlice: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *type_.slice_); + break; + } + case TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression_ListSelect_ListSelectItem* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + MergeFrom(*source); + } +} + +void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.type_case()) { + case kItem: { + _internal_mutable_item()->::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); + break; + } + case kSlice: { + _internal_mutable_slice()->::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); + break; + } + case TYPE_NOT_SET: { + break; + } + } +} + +void Expression_MaskExpression_ListSelect_ListSelectItem::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression_ListSelect_ListSelectItem::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression_ListSelect_ListSelectItem::IsInitialized() const { + return true; +} + +void Expression_MaskExpression_ListSelect_ListSelectItem::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(type_, other->type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[38]); +} + +// =================================================================== + +class Expression_MaskExpression_ListSelect::_Internal { + public: + static const ::io::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_ListSelect* msg); +}; + +const ::io::substrait::Expression_MaskExpression_Select& +Expression_MaskExpression_ListSelect::_Internal::child(const Expression_MaskExpression_ListSelect* msg) { + return *msg->child_; +} +Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + selection_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.ListSelect) +} +Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(const Expression_MaskExpression_ListSelect& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + selection_(from.selection_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::Expression_MaskExpression_Select(*from.child_); + } else { + child_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.ListSelect) +} + +void Expression_MaskExpression_ListSelect::SharedCtor() { +child_ = nullptr; +} + +Expression_MaskExpression_ListSelect::~Expression_MaskExpression_ListSelect() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.ListSelect) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression_ListSelect::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; +} + +void Expression_MaskExpression_ListSelect::ArenaDtor(void* object) { + Expression_MaskExpression_ListSelect* _this = reinterpret_cast< Expression_MaskExpression_ListSelect* >(object); + (void)_this; +} +void Expression_MaskExpression_ListSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression_ListSelect::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression_ListSelect::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.ListSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + selection_.Clear(); + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression_ListSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_selection(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.MaskExpression.Select child = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.ListSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_selection_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_selection(i), target, stream); + } + + // .io.substrait.Expression.MaskExpression.Select child = 2; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.ListSelect) + return target; +} + +size_t Expression_MaskExpression_ListSelect::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.ListSelect) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; + total_size += 1UL * this->_internal_selection_size(); + for (const auto& msg : this->selection_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Expression.MaskExpression.Select child = 2; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression_ListSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression_ListSelect* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.ListSelect) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.ListSelect) + MergeFrom(*source); + } +} + +void Expression_MaskExpression_ListSelect::MergeFrom(const Expression_MaskExpression_ListSelect& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + selection_.MergeFrom(from.selection_); + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); + } +} + +void Expression_MaskExpression_ListSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression_ListSelect::CopyFrom(const Expression_MaskExpression_ListSelect& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression_ListSelect::IsInitialized() const { + return true; +} + +void Expression_MaskExpression_ListSelect::InternalSwap(Expression_MaskExpression_ListSelect* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + selection_.InternalSwap(&other->selection_); + swap(child_, other->child_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[39]); +} + +// =================================================================== + +class Expression_MaskExpression_MapSelect_MapKey::_Internal { + public: +}; + +Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.MapSelect.MapKey) +} +Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(const Expression_MaskExpression_MapSelect_MapKey& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_map_key().empty()) { + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.MapSelect.MapKey) +} + +void Expression_MaskExpression_MapSelect_MapKey::SharedCtor() { +map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Expression_MaskExpression_MapSelect_MapKey::~Expression_MaskExpression_MapSelect_MapKey() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression_MapSelect_MapKey::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + map_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Expression_MaskExpression_MapSelect_MapKey::ArenaDtor(void* object) { + Expression_MaskExpression_MapSelect_MapKey* _this = reinterpret_cast< Expression_MaskExpression_MapSelect_MapKey* >(object); + (void)_this; +} +void Expression_MaskExpression_MapSelect_MapKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression_MapSelect_MapKey::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression_MapSelect_MapKey::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + map_key_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression_MapSelect_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string map_key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_map_key(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect_MapKey::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string map_key = 1; + if (this->map_key().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_map_key().data(), static_cast(this->_internal_map_key().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_map_key(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + return target; +} + +size_t Expression_MaskExpression_MapSelect_MapKey::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string map_key = 1; + if (this->map_key().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_map_key()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression_MapSelect_MapKey::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression_MapSelect_MapKey* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + MergeFrom(*source); + } +} + +void Expression_MaskExpression_MapSelect_MapKey::MergeFrom(const Expression_MaskExpression_MapSelect_MapKey& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.map_key().size() > 0) { + _internal_set_map_key(from._internal_map_key()); + } +} + +void Expression_MaskExpression_MapSelect_MapKey::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression_MapSelect_MapKey::CopyFrom(const Expression_MaskExpression_MapSelect_MapKey& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression_MapSelect_MapKey::IsInitialized() const { + return true; +} + +void Expression_MaskExpression_MapSelect_MapKey::InternalSwap(Expression_MaskExpression_MapSelect_MapKey* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + map_key_.Swap(&other->map_key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKey::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[40]); +} + +// =================================================================== + +class Expression_MaskExpression_MapSelect_MapKeyExpression::_Internal { + public: +}; + +Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) +} +Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_map_key_expression().empty()) { + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key_expression(), + GetArena()); + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) +} + +void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedCtor() { +map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +Expression_MaskExpression_MapSelect_MapKeyExpression::~Expression_MaskExpression_MapSelect_MapKeyExpression() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + map_key_expression_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void Expression_MaskExpression_MapSelect_MapKeyExpression::ArenaDtor(void* object) { + Expression_MaskExpression_MapSelect_MapKeyExpression* _this = reinterpret_cast< Expression_MaskExpression_MapSelect_MapKeyExpression* >(object); + (void)_this; +} +void Expression_MaskExpression_MapSelect_MapKeyExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression_MapSelect_MapKeyExpression::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression_MapSelect_MapKeyExpression::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + map_key_expression_.ClearToEmpty(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string map_key_expression = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_map_key_expression(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string map_key_expression = 1; + if (this->map_key_expression().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_map_key_expression().data(), static_cast(this->_internal_map_key_expression().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_map_key_expression(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + return target; +} + +size_t Expression_MaskExpression_MapSelect_MapKeyExpression::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string map_key_expression = 1; + if (this->map_key_expression().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_map_key_expression()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression_MapSelect_MapKeyExpression* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + MergeFrom(*source); + } +} + +void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.map_key_expression().size() > 0) { + _internal_set_map_key_expression(from._internal_map_key_expression()); + } +} + +void Expression_MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression_MapSelect_MapKeyExpression::IsInitialized() const { + return true; +} + +void Expression_MaskExpression_MapSelect_MapKeyExpression::InternalSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + map_key_expression_.Swap(&other->map_key_expression_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKeyExpression::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[41]); +} + +// =================================================================== + +class Expression_MaskExpression_MapSelect::_Internal { + public: + static const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& key(const Expression_MaskExpression_MapSelect* msg); + static const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression(const Expression_MaskExpression_MapSelect* msg); + static const ::io::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_MapSelect* msg); +}; + +const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& +Expression_MaskExpression_MapSelect::_Internal::key(const Expression_MaskExpression_MapSelect* msg) { + return *msg->select_.key_; +} +const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& +Expression_MaskExpression_MapSelect::_Internal::expression(const Expression_MaskExpression_MapSelect* msg) { + return *msg->select_.expression_; +} +const ::io::substrait::Expression_MaskExpression_Select& +Expression_MaskExpression_MapSelect::_Internal::child(const Expression_MaskExpression_MapSelect* msg) { + return *msg->child_; +} +void Expression_MaskExpression_MapSelect::set_allocated_key(::io::substrait::Expression_MaskExpression_MapSelect_MapKey* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_select(); + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + set_has_key(); + select_.key_ = key; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.key) +} +void Expression_MaskExpression_MapSelect::set_allocated_expression(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_select(); + if (expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expression); + if (message_arena != submessage_arena) { + expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expression, submessage_arena); + } + set_has_expression(); + select_.expression_ = expression; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.expression) +} +Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.MapSelect) +} +Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(const Expression_MaskExpression_MapSelect& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_child()) { + child_ = new ::io::substrait::Expression_MaskExpression_Select(*from.child_); + } else { + child_ = nullptr; + } + clear_has_select(); + switch (from.select_case()) { + case kKey: { + _internal_mutable_key()->::io::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); + break; + } + case kExpression: { + _internal_mutable_expression()->::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); + break; + } + case SELECT_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.MapSelect) +} + +void Expression_MaskExpression_MapSelect::SharedCtor() { +child_ = nullptr; +clear_has_select(); +} + +Expression_MaskExpression_MapSelect::~Expression_MaskExpression_MapSelect() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.MapSelect) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression_MapSelect::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete child_; + if (has_select()) { + clear_select(); + } +} + +void Expression_MaskExpression_MapSelect::ArenaDtor(void* object) { + Expression_MaskExpression_MapSelect* _this = reinterpret_cast< Expression_MaskExpression_MapSelect* >(object); + (void)_this; +} +void Expression_MaskExpression_MapSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression_MapSelect::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression_MapSelect::clear_select() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.MaskExpression.MapSelect) + switch (select_case()) { + case kKey: { + if (GetArena() == nullptr) { + delete select_.key_; + } + break; + } + case kExpression: { + if (GetArena() == nullptr) { + delete select_.expression_; + } + break; + } + case SELECT_NOT_SET: { + break; + } + } + _oneof_case_[0] = SELECT_NOT_SET; +} + + +void Expression_MaskExpression_MapSelect::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.MapSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; + clear_select(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression_MapSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.MaskExpression.Select child = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.MapSelect) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; + if (_internal_has_key()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::key(this), target, stream); + } + + // .io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; + if (_internal_has_expression()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::expression(this), target, stream); + } + + // .io.substrait.Expression.MaskExpression.Select child = 3; + if (this->has_child()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::child(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.MapSelect) + return target; +} + +size_t Expression_MaskExpression_MapSelect::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.MapSelect) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression.MaskExpression.Select child = 3; + if (this->has_child()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *child_); + } + + switch (select_case()) { + // .io.substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; + case kKey: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *select_.key_); + break; + } + // .io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; + case kExpression: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *select_.expression_); + break; + } + case SELECT_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression_MapSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression_MapSelect* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.MapSelect) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.MapSelect) + MergeFrom(*source); + } +} + +void Expression_MaskExpression_MapSelect::MergeFrom(const Expression_MaskExpression_MapSelect& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_child()) { + _internal_mutable_child()->::io::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); + } + switch (from.select_case()) { + case kKey: { + _internal_mutable_key()->::io::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); + break; + } + case kExpression: { + _internal_mutable_expression()->::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); + break; + } + case SELECT_NOT_SET: { + break; + } + } +} + +void Expression_MaskExpression_MapSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression_MapSelect::CopyFrom(const Expression_MaskExpression_MapSelect& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression_MapSelect::IsInitialized() const { + return true; +} + +void Expression_MaskExpression_MapSelect::InternalSwap(Expression_MaskExpression_MapSelect* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(child_, other->child_); + swap(select_, other->select_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[42]); +} + +// =================================================================== + +class Expression_MaskExpression::_Internal { + public: + static const ::io::substrait::Expression_MaskExpression_StructSelect& select(const Expression_MaskExpression* msg); +}; + +const ::io::substrait::Expression_MaskExpression_StructSelect& +Expression_MaskExpression::_Internal::select(const Expression_MaskExpression* msg) { + return *msg->select_; +} +Expression_MaskExpression::Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression) +} +Expression_MaskExpression::Expression_MaskExpression(const Expression_MaskExpression& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_select()) { + select_ = new ::io::substrait::Expression_MaskExpression_StructSelect(*from.select_); + } else { + select_ = nullptr; + } + maintain_singular_struct_ = from.maintain_singular_struct_; + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression) +} + +void Expression_MaskExpression::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&select_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&maintain_singular_struct_) - + reinterpret_cast(&select_)) + sizeof(maintain_singular_struct_)); +} + +Expression_MaskExpression::~Expression_MaskExpression() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_MaskExpression::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete select_; +} + +void Expression_MaskExpression::ArenaDtor(void* object) { + Expression_MaskExpression* _this = reinterpret_cast< Expression_MaskExpression* >(object); + (void)_this; +} +void Expression_MaskExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_MaskExpression::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_MaskExpression::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && select_ != nullptr) { + delete select_; + } + select_ = nullptr; + maintain_singular_struct_ = false; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_MaskExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.MaskExpression.StructSelect select = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_select(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // bool maintain_singular_struct = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + maintain_singular_struct_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.MaskExpression.StructSelect select = 1; + if (this->has_select()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::select(this), target, stream); + } + + // bool maintain_singular_struct = 2; + if (this->maintain_singular_struct() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_maintain_singular_struct(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression) + return target; +} + +size_t Expression_MaskExpression::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression.MaskExpression.StructSelect select = 1; + if (this->has_select()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *select_); + } + + // bool maintain_singular_struct = 2; + if (this->maintain_singular_struct() != 0) { + total_size += 1 + 1; + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_MaskExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression) + GOOGLE_DCHECK_NE(&from, this); + const Expression_MaskExpression* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression) + MergeFrom(*source); + } +} + +void Expression_MaskExpression::MergeFrom(const Expression_MaskExpression& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_select()) { + _internal_mutable_select()->::io::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_select()); + } + if (from.maintain_singular_struct() != 0) { + _internal_set_maintain_singular_struct(from._internal_maintain_singular_struct()); + } +} + +void Expression_MaskExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_MaskExpression::CopyFrom(const Expression_MaskExpression& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_MaskExpression::IsInitialized() const { + return true; +} + +void Expression_MaskExpression::InternalSwap(Expression_MaskExpression* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Expression_MaskExpression, maintain_singular_struct_) + + sizeof(Expression_MaskExpression::maintain_singular_struct_) + - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression, select_)>( + reinterpret_cast(&select_), + reinterpret_cast(&other->select_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[43]); +} + +// =================================================================== + +class Expression_FieldReference_RootReference::_Internal { + public: +}; + +Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.FieldReference.RootReference) +} +Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(const Expression_FieldReference_RootReference& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.FieldReference.RootReference) +} + +void Expression_FieldReference_RootReference::SharedCtor() { +} + +Expression_FieldReference_RootReference::~Expression_FieldReference_RootReference() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.FieldReference.RootReference) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_FieldReference_RootReference::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); +} + +void Expression_FieldReference_RootReference::ArenaDtor(void* object) { + Expression_FieldReference_RootReference* _this = reinterpret_cast< Expression_FieldReference_RootReference* >(object); + (void)_this; +} +void Expression_FieldReference_RootReference::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_FieldReference_RootReference::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_FieldReference_RootReference::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.FieldReference.RootReference) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_FieldReference_RootReference::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference_RootReference::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.FieldReference.RootReference) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.FieldReference.RootReference) + return target; +} + +size_t Expression_FieldReference_RootReference::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.FieldReference.RootReference) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_FieldReference_RootReference::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.FieldReference.RootReference) + GOOGLE_DCHECK_NE(&from, this); + const Expression_FieldReference_RootReference* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.FieldReference.RootReference) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.FieldReference.RootReference) + MergeFrom(*source); + } +} + +void Expression_FieldReference_RootReference::MergeFrom(const Expression_FieldReference_RootReference& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.FieldReference.RootReference) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + +} + +void Expression_FieldReference_RootReference::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.FieldReference.RootReference) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_FieldReference_RootReference::CopyFrom(const Expression_FieldReference_RootReference& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.FieldReference.RootReference) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_FieldReference_RootReference::IsInitialized() const { + return true; +} + +void Expression_FieldReference_RootReference::InternalSwap(Expression_FieldReference_RootReference* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference_RootReference::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[44]); +} + +// =================================================================== + +class Expression_FieldReference::_Internal { + public: + static const ::io::substrait::Expression_ReferenceSegment& direct_reference(const Expression_FieldReference* msg); + static const ::io::substrait::Expression_MaskExpression& masked_reference(const Expression_FieldReference* msg); + static const ::io::substrait::Expression& expression(const Expression_FieldReference* msg); + static const ::io::substrait::Expression_FieldReference_RootReference& root_reference(const Expression_FieldReference* msg); +}; + +const ::io::substrait::Expression_ReferenceSegment& +Expression_FieldReference::_Internal::direct_reference(const Expression_FieldReference* msg) { + return *msg->reference_type_.direct_reference_; +} +const ::io::substrait::Expression_MaskExpression& +Expression_FieldReference::_Internal::masked_reference(const Expression_FieldReference* msg) { + return *msg->reference_type_.masked_reference_; +} +const ::io::substrait::Expression& +Expression_FieldReference::_Internal::expression(const Expression_FieldReference* msg) { + return *msg->root_type_.expression_; +} +const ::io::substrait::Expression_FieldReference_RootReference& +Expression_FieldReference::_Internal::root_reference(const Expression_FieldReference* msg) { + return *msg->root_type_.root_reference_; +} +void Expression_FieldReference::set_allocated_direct_reference(::io::substrait::Expression_ReferenceSegment* direct_reference) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (direct_reference) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(direct_reference); + if (message_arena != submessage_arena) { + direct_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, direct_reference, submessage_arena); + } + set_has_direct_reference(); + reference_type_.direct_reference_ = direct_reference; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.FieldReference.direct_reference) +} +void Expression_FieldReference::set_allocated_masked_reference(::io::substrait::Expression_MaskExpression* masked_reference) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_reference_type(); + if (masked_reference) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(masked_reference); + if (message_arena != submessage_arena) { + masked_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, masked_reference, submessage_arena); + } + set_has_masked_reference(); + reference_type_.masked_reference_ = masked_reference; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.FieldReference.masked_reference) +} +void Expression_FieldReference::set_allocated_expression(::io::substrait::Expression* expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_root_type(); + if (expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expression); + if (message_arena != submessage_arena) { + expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expression, submessage_arena); + } + set_has_expression(); + root_type_.expression_ = expression; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.FieldReference.expression) +} +void Expression_FieldReference::set_allocated_root_reference(::io::substrait::Expression_FieldReference_RootReference* root_reference) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_root_type(); + if (root_reference) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(root_reference); + if (message_arena != submessage_arena) { + root_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, root_reference, submessage_arena); + } + set_has_root_reference(); + root_type_.root_reference_ = root_reference; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.FieldReference.root_reference) +} +Expression_FieldReference::Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.FieldReference) +} +Expression_FieldReference::Expression_FieldReference(const Expression_FieldReference& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_reference_type(); + switch (from.reference_type_case()) { + case kDirectReference: { + _internal_mutable_direct_reference()->::io::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference()); + break; + } + case kMaskedReference: { + _internal_mutable_masked_reference()->::io::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference()); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + clear_has_root_type(); + switch (from.root_type_case()) { + case kExpression: { + _internal_mutable_expression()->::io::substrait::Expression::MergeFrom(from._internal_expression()); + break; + } + case kRootReference: { + _internal_mutable_root_reference()->::io::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference()); + break; + } + case ROOT_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.FieldReference) +} + +void Expression_FieldReference::SharedCtor() { +clear_has_reference_type(); +clear_has_root_type(); +} + +Expression_FieldReference::~Expression_FieldReference() { + // @@protoc_insertion_point(destructor:io.substrait.Expression.FieldReference) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression_FieldReference::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_reference_type()) { + clear_reference_type(); + } + if (has_root_type()) { + clear_root_type(); + } +} + +void Expression_FieldReference::ArenaDtor(void* object) { + Expression_FieldReference* _this = reinterpret_cast< Expression_FieldReference* >(object); + (void)_this; +} +void Expression_FieldReference::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression_FieldReference::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression_FieldReference::clear_reference_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.FieldReference) + switch (reference_type_case()) { + case kDirectReference: { + if (GetArena() == nullptr) { + delete reference_type_.direct_reference_; + } + break; + } + case kMaskedReference: { + if (GetArena() == nullptr) { + delete reference_type_.masked_reference_; + } + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; +} + +void Expression_FieldReference::clear_root_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.FieldReference) + switch (root_type_case()) { + case kExpression: { + if (GetArena() == nullptr) { + delete root_type_.expression_; + } + break; + } + case kRootReference: { + if (GetArena() == nullptr) { + delete root_type_.root_reference_; + } + break; + } + case ROOT_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[1] = ROOT_TYPE_NOT_SET; +} + + +void Expression_FieldReference::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.FieldReference) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_reference_type(); + clear_root_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression_FieldReference::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.ReferenceSegment direct_reference = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_direct_reference(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.MaskExpression masked_reference = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_masked_reference(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression expression = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.FieldReference.RootReference root_reference = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_root_reference(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.FieldReference) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.ReferenceSegment direct_reference = 1; + if (_internal_has_direct_reference()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::direct_reference(this), target, stream); + } + + // .io.substrait.Expression.MaskExpression masked_reference = 2; + if (_internal_has_masked_reference()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::masked_reference(this), target, stream); + } + + // .io.substrait.Expression expression = 3; + if (_internal_has_expression()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::expression(this), target, stream); + } + + // .io.substrait.Expression.FieldReference.RootReference root_reference = 4; + if (_internal_has_root_reference()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::root_reference(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.FieldReference) + return target; +} + +size_t Expression_FieldReference::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.FieldReference) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (reference_type_case()) { + // .io.substrait.Expression.ReferenceSegment direct_reference = 1; + case kDirectReference: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.direct_reference_); + break; + } + // .io.substrait.Expression.MaskExpression masked_reference = 2; + case kMaskedReference: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *reference_type_.masked_reference_); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + switch (root_type_case()) { + // .io.substrait.Expression expression = 3; + case kExpression: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *root_type_.expression_); + break; + } + // .io.substrait.Expression.FieldReference.RootReference root_reference = 4; + case kRootReference: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *root_type_.root_reference_); + break; + } + case ROOT_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void Expression_FieldReference::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.FieldReference) + GOOGLE_DCHECK_NE(&from, this); + const Expression_FieldReference* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.FieldReference) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.FieldReference) + MergeFrom(*source); + } +} + +void Expression_FieldReference::MergeFrom(const Expression_FieldReference& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.FieldReference) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.reference_type_case()) { + case kDirectReference: { + _internal_mutable_direct_reference()->::io::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference()); + break; + } + case kMaskedReference: { + _internal_mutable_masked_reference()->::io::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference()); + break; + } + case REFERENCE_TYPE_NOT_SET: { + break; + } + } + switch (from.root_type_case()) { + case kExpression: { + _internal_mutable_expression()->::io::substrait::Expression::MergeFrom(from._internal_expression()); + break; + } + case kRootReference: { + _internal_mutable_root_reference()->::io::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference()); + break; + } + case ROOT_TYPE_NOT_SET: { + break; + } + } +} + +void Expression_FieldReference::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.FieldReference) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression_FieldReference::CopyFrom(const Expression_FieldReference& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.FieldReference) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression_FieldReference::IsInitialized() const { + return true; +} + +void Expression_FieldReference::InternalSwap(Expression_FieldReference* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(reference_type_, other->reference_type_); + swap(root_type_, other->root_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); + swap(_oneof_case_[1], other->_oneof_case_[1]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[45]); +} + +// =================================================================== + +class Expression::_Internal { + public: + static const ::io::substrait::Expression_Literal& literal(const Expression* msg); + static const ::io::substrait::Expression_FieldReference& selection(const Expression* msg); + static const ::io::substrait::Expression_ScalarFunction& scalar_function(const Expression* msg); + static const ::io::substrait::Expression_WindowFunction& window_function(const Expression* msg); + static const ::io::substrait::Expression_IfThen& if_then(const Expression* msg); + static const ::io::substrait::Expression_SwitchExpression& switch_expression(const Expression* msg); + static const ::io::substrait::Expression_SingularOrList& singular_or_list(const Expression* msg); + static const ::io::substrait::Expression_MultiOrList& multi_or_list(const Expression* msg); + static const ::io::substrait::Expression_Enum& enum_(const Expression* msg); + static const ::io::substrait::Expression_Cast& cast(const Expression* msg); +}; + +const ::io::substrait::Expression_Literal& +Expression::_Internal::literal(const Expression* msg) { + return *msg->rex_type_.literal_; +} +const ::io::substrait::Expression_FieldReference& +Expression::_Internal::selection(const Expression* msg) { + return *msg->rex_type_.selection_; +} +const ::io::substrait::Expression_ScalarFunction& +Expression::_Internal::scalar_function(const Expression* msg) { + return *msg->rex_type_.scalar_function_; +} +const ::io::substrait::Expression_WindowFunction& +Expression::_Internal::window_function(const Expression* msg) { + return *msg->rex_type_.window_function_; +} +const ::io::substrait::Expression_IfThen& +Expression::_Internal::if_then(const Expression* msg) { + return *msg->rex_type_.if_then_; +} +const ::io::substrait::Expression_SwitchExpression& +Expression::_Internal::switch_expression(const Expression* msg) { + return *msg->rex_type_.switch_expression_; +} +const ::io::substrait::Expression_SingularOrList& +Expression::_Internal::singular_or_list(const Expression* msg) { + return *msg->rex_type_.singular_or_list_; +} +const ::io::substrait::Expression_MultiOrList& +Expression::_Internal::multi_or_list(const Expression* msg) { + return *msg->rex_type_.multi_or_list_; +} +const ::io::substrait::Expression_Enum& +Expression::_Internal::enum_(const Expression* msg) { + return *msg->rex_type_.enum__; +} +const ::io::substrait::Expression_Cast& +Expression::_Internal::cast(const Expression* msg) { + return *msg->rex_type_.cast_; +} +void Expression::set_allocated_literal(::io::substrait::Expression_Literal* literal) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (literal) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(literal); + if (message_arena != submessage_arena) { + literal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, literal, submessage_arena); + } + set_has_literal(); + rex_type_.literal_ = literal; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.literal) +} +void Expression::set_allocated_selection(::io::substrait::Expression_FieldReference* selection) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (selection) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(selection); + if (message_arena != submessage_arena) { + selection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, selection, submessage_arena); + } + set_has_selection(); + rex_type_.selection_ = selection; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.selection) +} +void Expression::set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (scalar_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(scalar_function); + if (message_arena != submessage_arena) { + scalar_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, scalar_function, submessage_arena); + } + set_has_scalar_function(); + rex_type_.scalar_function_ = scalar_function; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.scalar_function) +} +void Expression::set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (window_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(window_function); + if (message_arena != submessage_arena) { + window_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, window_function, submessage_arena); + } + set_has_window_function(); + rex_type_.window_function_ = window_function; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.window_function) +} +void Expression::set_allocated_if_then(::io::substrait::Expression_IfThen* if_then) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (if_then) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_then); + if (message_arena != submessage_arena) { + if_then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, if_then, submessage_arena); + } + set_has_if_then(); + rex_type_.if_then_ = if_then; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.if_then) +} +void Expression::set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (switch_expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(switch_expression); + if (message_arena != submessage_arena) { + switch_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, switch_expression, submessage_arena); + } + set_has_switch_expression(); + rex_type_.switch_expression_ = switch_expression; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.switch_expression) +} +void Expression::set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (singular_or_list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(singular_or_list); + if (message_arena != submessage_arena) { + singular_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, singular_or_list, submessage_arena); + } + set_has_singular_or_list(); + rex_type_.singular_or_list_ = singular_or_list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.singular_or_list) +} +void Expression::set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (multi_or_list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(multi_or_list); + if (message_arena != submessage_arena) { + multi_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, multi_or_list, submessage_arena); + } + set_has_multi_or_list(); + rex_type_.multi_or_list_ = multi_or_list; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.multi_or_list) +} +void Expression::set_allocated_enum_(::io::substrait::Expression_Enum* enum_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (enum_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(enum_); + if (message_arena != submessage_arena) { + enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, enum_, submessage_arena); + } + set_has_enum_(); + rex_type_.enum__ = enum_; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.enum) +} +void Expression::set_allocated_cast(::io::substrait::Expression_Cast* cast) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_rex_type(); + if (cast) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(cast); + if (message_arena != submessage_arena) { + cast = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, cast, submessage_arena); + } + set_has_cast(); + rex_type_.cast_ = cast; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.cast) +} +Expression::Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.Expression) +} +Expression::Expression(const Expression& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_rex_type(); + switch (from.rex_type_case()) { + case kLiteral: { + _internal_mutable_literal()->::io::substrait::Expression_Literal::MergeFrom(from._internal_literal()); + break; + } + case kSelection: { + _internal_mutable_selection()->::io::substrait::Expression_FieldReference::MergeFrom(from._internal_selection()); + break; + } + case kScalarFunction: { + _internal_mutable_scalar_function()->::io::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function()); + break; + } + case kWindowFunction: { + _internal_mutable_window_function()->::io::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function()); + break; + } + case kIfThen: { + _internal_mutable_if_then()->::io::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); + break; + } + case kSwitchExpression: { + _internal_mutable_switch_expression()->::io::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); + break; + } + case kSingularOrList: { + _internal_mutable_singular_or_list()->::io::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); + break; + } + case kMultiOrList: { + _internal_mutable_multi_or_list()->::io::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); + break; + } + case kEnum: { + _internal_mutable_enum_()->::io::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); + break; + } + case kCast: { + _internal_mutable_cast()->::io::substrait::Expression_Cast::MergeFrom(from._internal_cast()); + break; + } + case REX_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.Expression) +} + +void Expression::SharedCtor() { +clear_has_rex_type(); +} + +Expression::~Expression() { + // @@protoc_insertion_point(destructor:io.substrait.Expression) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void Expression::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_rex_type()) { + clear_rex_type(); + } +} + +void Expression::ArenaDtor(void* object) { + Expression* _this = reinterpret_cast< Expression* >(object); + (void)_this; +} +void Expression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void Expression::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void Expression::clear_rex_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression) + switch (rex_type_case()) { + case kLiteral: { + if (GetArena() == nullptr) { + delete rex_type_.literal_; + } + break; + } + case kSelection: { + if (GetArena() == nullptr) { + delete rex_type_.selection_; + } + break; + } + case kScalarFunction: { + if (GetArena() == nullptr) { + delete rex_type_.scalar_function_; + } + break; + } + case kWindowFunction: { + if (GetArena() == nullptr) { + delete rex_type_.window_function_; + } + break; + } + case kIfThen: { + if (GetArena() == nullptr) { + delete rex_type_.if_then_; + } + break; + } + case kSwitchExpression: { + if (GetArena() == nullptr) { + delete rex_type_.switch_expression_; + } + break; + } + case kSingularOrList: { + if (GetArena() == nullptr) { + delete rex_type_.singular_or_list_; + } + break; + } + case kMultiOrList: { + if (GetArena() == nullptr) { + delete rex_type_.multi_or_list_; + } + break; + } + case kEnum: { + if (GetArena() == nullptr) { + delete rex_type_.enum__; + } + break; + } + case kCast: { + if (GetArena() == nullptr) { + delete rex_type_.cast_; + } + break; + } + case REX_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = REX_TYPE_NOT_SET; +} + + +void Expression::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.Expression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_rex_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* Expression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression.Literal literal = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_literal(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.FieldReference selection = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_selection(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.ScalarFunction scalar_function = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_scalar_function(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.WindowFunction window_function = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_window_function(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.IfThen if_then = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + ptr = ctx->ParseMessage(_internal_mutable_if_then(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.SwitchExpression switch_expression = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_switch_expression(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.SingularOrList singular_or_list = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_singular_or_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.MultiOrList multi_or_list = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_multi_or_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Enum enum = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Expression.Cast cast = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_cast(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression.Literal literal = 1; + if (_internal_has_literal()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::literal(this), target, stream); + } + + // .io.substrait.Expression.FieldReference selection = 2; + if (_internal_has_selection()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::selection(this), target, stream); + } + + // .io.substrait.Expression.ScalarFunction scalar_function = 3; + if (_internal_has_scalar_function()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::scalar_function(this), target, stream); + } + + // .io.substrait.Expression.WindowFunction window_function = 5; + if (_internal_has_window_function()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 5, _Internal::window_function(this), target, stream); + } + + // .io.substrait.Expression.IfThen if_then = 6; + if (_internal_has_if_then()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 6, _Internal::if_then(this), target, stream); + } + + // .io.substrait.Expression.SwitchExpression switch_expression = 7; + if (_internal_has_switch_expression()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 7, _Internal::switch_expression(this), target, stream); + } + + // .io.substrait.Expression.SingularOrList singular_or_list = 8; + if (_internal_has_singular_or_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::singular_or_list(this), target, stream); + } + + // .io.substrait.Expression.MultiOrList multi_or_list = 9; + if (_internal_has_multi_or_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::multi_or_list(this), target, stream); + } + + // .io.substrait.Expression.Enum enum = 10; + if (_internal_has_enum_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::enum_(this), target, stream); + } + + // .io.substrait.Expression.Cast cast = 11; + if (_internal_has_cast()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::cast(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression) + return target; +} + +size_t Expression::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (rex_type_case()) { + // .io.substrait.Expression.Literal literal = 1; + case kLiteral: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.literal_); + break; + } + // .io.substrait.Expression.FieldReference selection = 2; + case kSelection: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.selection_); + break; + } + // .io.substrait.Expression.ScalarFunction scalar_function = 3; + case kScalarFunction: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.scalar_function_); + break; + } + // .io.substrait.Expression.WindowFunction window_function = 5; + case kWindowFunction: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.window_function_); + break; + } + // .io.substrait.Expression.IfThen if_then = 6; + case kIfThen: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.if_then_); + break; + } + // .io.substrait.Expression.SwitchExpression switch_expression = 7; + case kSwitchExpression: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.switch_expression_); + break; + } + // .io.substrait.Expression.SingularOrList singular_or_list = 8; + case kSingularOrList: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.singular_or_list_); + break; + } + // .io.substrait.Expression.MultiOrList multi_or_list = 9; + case kMultiOrList: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.multi_or_list_); + break; + } + // .io.substrait.Expression.Enum enum = 10; + case kEnum: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.enum__); + break; + } + // .io.substrait.Expression.Cast cast = 11; + case kCast: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *rex_type_.cast_); + break; + } + case REX_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; } -Expression::Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression) + +void Expression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression) + GOOGLE_DCHECK_NE(&from, this); + const Expression* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression) + MergeFrom(*source); + } } -Expression::Expression(const Expression& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { + +void Expression::MergeFrom(const Expression& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression) + GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_rex_type(); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + switch (from.rex_type_case()) { case kLiteral: { _internal_mutable_literal()->::io::substrait::Expression_Literal::MergeFrom(from._internal_literal()); break; } case kSelection: { - _internal_mutable_selection()->::io::substrait::FieldReference::MergeFrom(from._internal_selection()); + _internal_mutable_selection()->::io::substrait::Expression_FieldReference::MergeFrom(from._internal_selection()); break; } case kScalarFunction: { @@ -9060,197 +14721,503 @@ Expression::Expression(const Expression& from) _internal_mutable_if_then()->::io::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); break; } - case kSwitchExpression: { - _internal_mutable_switch_expression()->::io::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); + case kSwitchExpression: { + _internal_mutable_switch_expression()->::io::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); + break; + } + case kSingularOrList: { + _internal_mutable_singular_or_list()->::io::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); + break; + } + case kMultiOrList: { + _internal_mutable_multi_or_list()->::io::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); + break; + } + case kEnum: { + _internal_mutable_enum_()->::io::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); + break; + } + case kCast: { + _internal_mutable_cast()->::io::substrait::Expression_Cast::MergeFrom(from._internal_cast()); + break; + } + case REX_TYPE_NOT_SET: { + break; + } + } +} + +void Expression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void Expression::CopyFrom(const Expression& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool Expression::IsInitialized() const { + return true; +} + +void Expression::InternalSwap(Expression* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(rex_type_, other->rex_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata Expression::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[46]); +} + +// =================================================================== + +class SortField::_Internal { + public: + static const ::io::substrait::Expression& expr(const SortField* msg); +}; + +const ::io::substrait::Expression& +SortField::_Internal::expr(const SortField* msg) { + return *msg->expr_; +} +SortField::SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.SortField) +} +SortField::SortField(const SortField& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_expr()) { + expr_ = new ::io::substrait::Expression(*from.expr_); + } else { + expr_ = nullptr; + } + clear_has_sort_kind(); + switch (from.sort_kind_case()) { + case kDirection: { + _internal_set_direction(from._internal_direction()); + break; + } + case kComparisonFunctionReference: { + _internal_set_comparison_function_reference(from._internal_comparison_function_reference()); + break; + } + case SORT_KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.SortField) +} + +void SortField::SharedCtor() { +expr_ = nullptr; +clear_has_sort_kind(); +} + +SortField::~SortField() { + // @@protoc_insertion_point(destructor:io.substrait.SortField) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SortField::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete expr_; + if (has_sort_kind()) { + clear_sort_kind(); + } +} + +void SortField::ArenaDtor(void* object) { + SortField* _this = reinterpret_cast< SortField* >(object); + (void)_this; +} +void SortField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SortField::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SortField::clear_sort_kind() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.SortField) + switch (sort_kind_case()) { + case kDirection: { + // No need to clear + break; + } + case kComparisonFunctionReference: { + // No need to clear + break; + } + case SORT_KIND_NOT_SET: { + break; + } + } + _oneof_case_[0] = SORT_KIND_NOT_SET; +} + + +void SortField::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.SortField) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && expr_ != nullptr) { + delete expr_; + } + expr_ = nullptr; + clear_sort_kind(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SortField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Expression expr = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_expr(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.SortField.SortDirection direction = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_direction(static_cast<::io::substrait::SortField_SortDirection>(val)); + } else goto handle_unusual; + continue; + // uint32 comparison_function_reference = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + _internal_set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SortField::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.SortField) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Expression expr = 1; + if (this->has_expr()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::expr(this), target, stream); + } + + // .io.substrait.SortField.SortDirection direction = 2; + if (_internal_has_direction()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 2, this->_internal_direction(), target); + } + + // uint32 comparison_function_reference = 3; + if (_internal_has_comparison_function_reference()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_comparison_function_reference(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.SortField) + return target; +} + +size_t SortField::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.SortField) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.Expression expr = 1; + if (this->has_expr()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *expr_); + } + + switch (sort_kind_case()) { + // .io.substrait.SortField.SortDirection direction = 2; + case kDirection: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_direction()); + break; + } + // uint32 comparison_function_reference = 3; + case kComparisonFunctionReference: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_comparison_function_reference()); break; } - case kSingularOrList: { - _internal_mutable_singular_or_list()->::io::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); + case SORT_KIND_NOT_SET: { break; } - case kMultiOrList: { - _internal_mutable_multi_or_list()->::io::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SortField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.SortField) + GOOGLE_DCHECK_NE(&from, this); + const SortField* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.SortField) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.SortField) + MergeFrom(*source); + } +} + +void SortField::MergeFrom(const SortField& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.SortField) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_expr()) { + _internal_mutable_expr()->::io::substrait::Expression::MergeFrom(from._internal_expr()); + } + switch (from.sort_kind_case()) { + case kDirection: { + _internal_set_direction(from._internal_direction()); break; } - case kEnum: { - _internal_mutable_enum_()->::io::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); + case kComparisonFunctionReference: { + _internal_set_comparison_function_reference(from._internal_comparison_function_reference()); break; } - case REX_TYPE_NOT_SET: { + case SORT_KIND_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression) } -void Expression::SharedCtor() { -clear_has_rex_type(); +void SortField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.SortField) + if (&from == this) return; + Clear(); + MergeFrom(from); } -Expression::~Expression() { - // @@protoc_insertion_point(destructor:io.substrait.Expression) +void SortField::CopyFrom(const SortField& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.SortField) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SortField::IsInitialized() const { + return true; +} + +void SortField::InternalSwap(SortField* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(expr_, other->expr_); + swap(sort_kind_, other->sort_kind_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SortField::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, + file_level_metadata_expression_2eproto[47]); +} + +// =================================================================== + +class AggregateFunction::_Internal { + public: + static const ::io::substrait::Type& output_type(const AggregateFunction* msg); +}; + +const ::io::substrait::Type& +AggregateFunction::_Internal::output_type(const AggregateFunction* msg) { + return *msg->output_type_; +} +void AggregateFunction::clear_output_type() { + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; +} +AggregateFunction::AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + args_(arena), + sorts_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.AggregateFunction) +} +AggregateFunction::AggregateFunction(const AggregateFunction& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + args_(from.args_), + sorts_(from.sorts_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_output_type()) { + output_type_ = new ::io::substrait::Type(*from.output_type_); + } else { + output_type_ = nullptr; + } + ::memcpy(&function_reference_, &from.function_reference_, + static_cast(reinterpret_cast(&phase_) - + reinterpret_cast(&function_reference_)) + sizeof(phase_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.AggregateFunction) +} + +void AggregateFunction::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&output_type_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&phase_) - + reinterpret_cast(&output_type_)) + sizeof(phase_)); +} + +AggregateFunction::~AggregateFunction() { + // @@protoc_insertion_point(destructor:io.substrait.AggregateFunction) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression::SharedDtor() { +void AggregateFunction::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (has_rex_type()) { - clear_rex_type(); - } + if (this != internal_default_instance()) delete output_type_; } -void Expression::ArenaDtor(void* object) { - Expression* _this = reinterpret_cast< Expression* >(object); +void AggregateFunction::ArenaDtor(void* object) { + AggregateFunction* _this = reinterpret_cast< AggregateFunction* >(object); (void)_this; } -void Expression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void AggregateFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Expression::SetCachedSize(int size) const { +void AggregateFunction::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Expression::clear_rex_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression) - switch (rex_type_case()) { - case kLiteral: { - if (GetArena() == nullptr) { - delete rex_type_.literal_; - } - break; - } - case kSelection: { - if (GetArena() == nullptr) { - delete rex_type_.selection_; - } - break; - } - case kScalarFunction: { - if (GetArena() == nullptr) { - delete rex_type_.scalar_function_; - } - break; - } - case kWindowFunction: { - if (GetArena() == nullptr) { - delete rex_type_.window_function_; - } - break; - } - case kIfThen: { - if (GetArena() == nullptr) { - delete rex_type_.if_then_; - } - break; - } - case kSwitchExpression: { - if (GetArena() == nullptr) { - delete rex_type_.switch_expression_; - } - break; - } - case kSingularOrList: { - if (GetArena() == nullptr) { - delete rex_type_.singular_or_list_; - } - break; - } - case kMultiOrList: { - if (GetArena() == nullptr) { - delete rex_type_.multi_or_list_; - } - break; - } - case kEnum: { - if (GetArena() == nullptr) { - delete rex_type_.enum__; - } - break; - } - case REX_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = REX_TYPE_NOT_SET; -} - - -void Expression::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression) +void AggregateFunction::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.AggregateFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - clear_rex_type(); + args_.Clear(); + sorts_.Clear(); + if (GetArena() == nullptr && output_type_ != nullptr) { + delete output_type_; + } + output_type_ = nullptr; + ::memset(&function_reference_, 0, static_cast( + reinterpret_cast(&phase_) - + reinterpret_cast(&function_reference_)) + sizeof(phase_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Expression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.Literal literal = 1; + // uint32 function_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_literal(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FieldReference selection = 2; + // repeated .io.substrait.Expression args = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_selection(), ptr); - CHK_(ptr); + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_args(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Expression.ScalarFunction scalar_function = 3; + // repeated .io.substrait.SortField sorts = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_scalar_function(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Expression.WindowFunction window_function = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_window_function(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Expression.IfThen if_then = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_if_then(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Expression.SwitchExpression switch_expression = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_switch_expression(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Expression.SingularOrList singular_or_list = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_singular_or_list(), ptr); - CHK_(ptr); + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_sorts(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Expression.MultiOrList multi_or_list = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_multi_or_list(), ptr); + // .io.substrait.AggregationPhase phase = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); + _internal_set_phase(static_cast<::io::substrait::AggregationPhase>(val)); } else goto handle_unusual; continue; - // .io.substrait.Expression.Enum enum = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr); + // .io.substrait.Type output_type = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -9277,168 +15244,99 @@ const char* Expression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* AggregateFunction::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.AggregateFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.Literal literal = 1; - if (_internal_has_literal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::literal(this), target, stream); - } - - // .io.substrait.FieldReference selection = 2; - if (_internal_has_selection()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::selection(this), target, stream); - } - - // .io.substrait.Expression.ScalarFunction scalar_function = 3; - if (_internal_has_scalar_function()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::scalar_function(this), target, stream); - } - - // .io.substrait.Expression.WindowFunction window_function = 5; - if (_internal_has_window_function()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::window_function(this), target, stream); - } - - // .io.substrait.Expression.IfThen if_then = 6; - if (_internal_has_if_then()) { + // uint32 function_reference = 1; + if (this->function_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 6, _Internal::if_then(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); } - // .io.substrait.Expression.SwitchExpression switch_expression = 7; - if (_internal_has_switch_expression()) { + // repeated .io.substrait.Expression args = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_args_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 7, _Internal::switch_expression(this), target, stream); + InternalWriteMessage(2, this->_internal_args(i), target, stream); } - // .io.substrait.Expression.SingularOrList singular_or_list = 8; - if (_internal_has_singular_or_list()) { + // repeated .io.substrait.SortField sorts = 3; + for (unsigned int i = 0, + n = static_cast(this->_internal_sorts_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 8, _Internal::singular_or_list(this), target, stream); + InternalWriteMessage(3, this->_internal_sorts(i), target, stream); } - // .io.substrait.Expression.MultiOrList multi_or_list = 9; - if (_internal_has_multi_or_list()) { + // .io.substrait.AggregationPhase phase = 4; + if (this->phase() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 9, _Internal::multi_or_list(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 4, this->_internal_phase(), target); } - // .io.substrait.Expression.Enum enum = 10; - if (_internal_has_enum_()) { + // .io.substrait.Type output_type = 5; + if (this->has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 10, _Internal::enum_(this), target, stream); + 5, _Internal::output_type(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.AggregateFunction) return target; } -size_t Expression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression) +size_t AggregateFunction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.AggregateFunction) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - switch (rex_type_case()) { - // .io.substrait.Expression.Literal literal = 1; - case kLiteral: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.literal_); - break; - } - // .io.substrait.FieldReference selection = 2; - case kSelection: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.selection_); - break; - } - // .io.substrait.Expression.ScalarFunction scalar_function = 3; - case kScalarFunction: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.scalar_function_); - break; - } - // .io.substrait.Expression.WindowFunction window_function = 5; - case kWindowFunction: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.window_function_); - break; - } - // .io.substrait.Expression.IfThen if_then = 6; - case kIfThen: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.if_then_); - break; - } - // .io.substrait.Expression.SwitchExpression switch_expression = 7; - case kSwitchExpression: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.switch_expression_); - break; - } - // .io.substrait.Expression.SingularOrList singular_or_list = 8; - case kSingularOrList: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.singular_or_list_); - break; - } - // .io.substrait.Expression.MultiOrList multi_or_list = 9; - case kMultiOrList: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.multi_or_list_); - break; - } - // .io.substrait.Expression.Enum enum = 10; - case kEnum: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.enum__); - break; - } - case REX_TYPE_NOT_SET: { - break; - } + // repeated .io.substrait.Expression args = 2; + total_size += 1UL * this->_internal_args_size(); + for (const auto& msg : this->args_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // repeated .io.substrait.SortField sorts = 3; + total_size += 1UL * this->_internal_sorts_size(); + for (const auto& msg : this->sorts_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.Type output_type = 5; + if (this->has_output_type()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *output_type_); + } + + // uint32 function_reference = 1; + if (this->function_reference() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_function_reference()); + } + + // .io.substrait.AggregationPhase phase = 4; + if (this->phase() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -9448,100 +15346,76 @@ size_t Expression::ByteSizeLong() const { return total_size; } -void Expression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression) +void AggregateFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.AggregateFunction) GOOGLE_DCHECK_NE(&from, this); - const Expression* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const AggregateFunction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.AggregateFunction) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.AggregateFunction) MergeFrom(*source); } } -void Expression::MergeFrom(const Expression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression) +void AggregateFunction::MergeFrom(const AggregateFunction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.AggregateFunction) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - switch (from.rex_type_case()) { - case kLiteral: { - _internal_mutable_literal()->::io::substrait::Expression_Literal::MergeFrom(from._internal_literal()); - break; - } - case kSelection: { - _internal_mutable_selection()->::io::substrait::FieldReference::MergeFrom(from._internal_selection()); - break; - } - case kScalarFunction: { - _internal_mutable_scalar_function()->::io::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function()); - break; - } - case kWindowFunction: { - _internal_mutable_window_function()->::io::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function()); - break; - } - case kIfThen: { - _internal_mutable_if_then()->::io::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); - break; - } - case kSwitchExpression: { - _internal_mutable_switch_expression()->::io::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); - break; - } - case kSingularOrList: { - _internal_mutable_singular_or_list()->::io::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); - break; - } - case kMultiOrList: { - _internal_mutable_multi_or_list()->::io::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); - break; - } - case kEnum: { - _internal_mutable_enum_()->::io::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); - break; - } - case REX_TYPE_NOT_SET: { - break; - } + args_.MergeFrom(from.args_); + sorts_.MergeFrom(from.sorts_); + if (from.has_output_type()) { + _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + } + if (from.function_reference() != 0) { + _internal_set_function_reference(from._internal_function_reference()); + } + if (from.phase() != 0) { + _internal_set_phase(from._internal_phase()); } } -void Expression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression) +void AggregateFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.AggregateFunction) if (&from == this) return; Clear(); MergeFrom(from); } -void Expression::CopyFrom(const Expression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression) +void AggregateFunction::CopyFrom(const AggregateFunction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.AggregateFunction) if (&from == this) return; Clear(); MergeFrom(from); } -bool Expression::IsInitialized() const { +bool AggregateFunction::IsInitialized() const { return true; } -void Expression::InternalSwap(Expression* other) { +void AggregateFunction::InternalSwap(AggregateFunction* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(rex_type_, other->rex_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); + args_.InternalSwap(&other->args_); + sorts_.InternalSwap(&other->sorts_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(AggregateFunction, phase_) + + sizeof(AggregateFunction::phase_) + - PROTOBUF_FIELD_OFFSET(AggregateFunction, output_type_)>( + reinterpret_cast(&output_type_), + reinterpret_cast(&other->output_type_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Expression::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata AggregateFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[28]); + file_level_metadata_expression_2eproto[48]); } // @@protoc_insertion_point(namespace_scope) @@ -9554,6 +15428,12 @@ template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Enum_Empty* Arena::Crea template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Enum* Arena::CreateMaybeMessage< ::io::substrait::Expression_Enum >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Expression_Enum >(arena); } +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_VarChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_VarChar >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_Decimal >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_Decimal >(arena); +} template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_Map_KeyValue >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_Map_KeyValue >(arena); } @@ -9578,9 +15458,6 @@ template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal* Arena::CreateM template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_ScalarFunction >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Expression_ScalarFunction >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_AggregateFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_AggregateFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_AggregateFunction >(arena); -} template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Preceding >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound_Preceding >(arena); } @@ -9599,15 +15476,15 @@ template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound* A template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_SortField* Arena::CreateMaybeMessage< ::io::substrait::Expression_SortField >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_SortField >(arena); -} template<> PROTOBUF_NOINLINE ::io::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage< ::io::substrait::Expression_IfThen_IfClause >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Expression_IfThen_IfClause >(arena); } template<> PROTOBUF_NOINLINE ::io::substrait::Expression_IfThen* Arena::CreateMaybeMessage< ::io::substrait::Expression_IfThen >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Expression_IfThen >(arena); } +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Cast* Arena::CreateMaybeMessage< ::io::substrait::Expression_Cast >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_Cast >(arena); +} template<> PROTOBUF_NOINLINE ::io::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage< ::io::substrait::Expression_SwitchExpression_IfValue >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Expression_SwitchExpression_IfValue >(arena); } @@ -9632,9 +15509,66 @@ template<> PROTOBUF_NOINLINE ::io::substrait::Expression_EmbeddedFunction_WebAss template<> PROTOBUF_NOINLINE ::io::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Expression_EmbeddedFunction >(arena); } +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_MapKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_ReferenceSegment_MapKey >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_StructField >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_ReferenceSegment_StructField >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_ListElement >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_ReferenceSegment_ListElement >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_ReferenceSegment >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_Select >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_Select >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_StructSelect >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_StructSelect >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_StructItem >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_StructItem >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_ListSelect >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect_MapKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_MapSelect_MapKey >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_MapSelect >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage< ::io::substrait::Expression_FieldReference_RootReference >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_FieldReference_RootReference >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::Expression_FieldReference* Arena::CreateMaybeMessage< ::io::substrait::Expression_FieldReference >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::Expression_FieldReference >(arena); +} template<> PROTOBUF_NOINLINE ::io::substrait::Expression* Arena::CreateMaybeMessage< ::io::substrait::Expression >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Expression >(arena); } +template<> PROTOBUF_NOINLINE ::io::substrait::SortField* Arena::CreateMaybeMessage< ::io::substrait::SortField >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::SortField >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::AggregateFunction* Arena::CreateMaybeMessage< ::io::substrait::AggregateFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::AggregateFunction >(arena); +} PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) diff --git a/cpp/src/generated/substrait/expression.pb.h b/cpp/src/generated/substrait/expression.pb.h index edc27212bbc..4791ae494c5 100644 --- a/cpp/src/generated/substrait/expression.pb.h +++ b/cpp/src/generated/substrait/expression.pb.h @@ -33,8 +33,6 @@ #include #include #include "type.pb.h" -#include "selection.pb.h" -#include "extensions.pb.h" // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_expression_2eproto @@ -50,7 +48,7 @@ struct TableStruct_expression_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[29] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[49] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -59,12 +57,15 @@ struct TableStruct_expression_2eproto { extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_expression_2eproto; namespace io { namespace substrait { +class AggregateFunction; +struct AggregateFunctionDefaultTypeInternal; +extern AggregateFunctionDefaultTypeInternal _AggregateFunction_default_instance_; class Expression; struct ExpressionDefaultTypeInternal; extern ExpressionDefaultTypeInternal _Expression_default_instance_; -class Expression_AggregateFunction; -struct Expression_AggregateFunctionDefaultTypeInternal; -extern Expression_AggregateFunctionDefaultTypeInternal _Expression_AggregateFunction_default_instance_; +class Expression_Cast; +struct Expression_CastDefaultTypeInternal; +extern Expression_CastDefaultTypeInternal _Expression_Cast_default_instance_; class Expression_EmbeddedFunction; struct Expression_EmbeddedFunctionDefaultTypeInternal; extern Expression_EmbeddedFunctionDefaultTypeInternal _Expression_EmbeddedFunction_default_instance_; @@ -80,6 +81,12 @@ extern Expression_EnumDefaultTypeInternal _Expression_Enum_default_instance_; class Expression_Enum_Empty; struct Expression_Enum_EmptyDefaultTypeInternal; extern Expression_Enum_EmptyDefaultTypeInternal _Expression_Enum_Empty_default_instance_; +class Expression_FieldReference; +struct Expression_FieldReferenceDefaultTypeInternal; +extern Expression_FieldReferenceDefaultTypeInternal _Expression_FieldReference_default_instance_; +class Expression_FieldReference_RootReference; +struct Expression_FieldReference_RootReferenceDefaultTypeInternal; +extern Expression_FieldReference_RootReferenceDefaultTypeInternal _Expression_FieldReference_RootReference_default_instance_; class Expression_IfThen; struct Expression_IfThenDefaultTypeInternal; extern Expression_IfThenDefaultTypeInternal _Expression_IfThen_default_instance_; @@ -89,6 +96,9 @@ extern Expression_IfThen_IfClauseDefaultTypeInternal _Expression_IfThen_IfClause class Expression_Literal; struct Expression_LiteralDefaultTypeInternal; extern Expression_LiteralDefaultTypeInternal _Expression_Literal_default_instance_; +class Expression_Literal_Decimal; +struct Expression_Literal_DecimalDefaultTypeInternal; +extern Expression_Literal_DecimalDefaultTypeInternal _Expression_Literal_Decimal_default_instance_; class Expression_Literal_IntervalDayToSecond; struct Expression_Literal_IntervalDayToSecondDefaultTypeInternal; extern Expression_Literal_IntervalDayToSecondDefaultTypeInternal _Expression_Literal_IntervalDayToSecond_default_instance_; @@ -107,21 +117,66 @@ extern Expression_Literal_Map_KeyValueDefaultTypeInternal _Expression_Literal_Ma class Expression_Literal_Struct; struct Expression_Literal_StructDefaultTypeInternal; extern Expression_Literal_StructDefaultTypeInternal _Expression_Literal_Struct_default_instance_; +class Expression_Literal_VarChar; +struct Expression_Literal_VarCharDefaultTypeInternal; +extern Expression_Literal_VarCharDefaultTypeInternal _Expression_Literal_VarChar_default_instance_; +class Expression_MaskExpression; +struct Expression_MaskExpressionDefaultTypeInternal; +extern Expression_MaskExpressionDefaultTypeInternal _Expression_MaskExpression_default_instance_; +class Expression_MaskExpression_ListSelect; +struct Expression_MaskExpression_ListSelectDefaultTypeInternal; +extern Expression_MaskExpression_ListSelectDefaultTypeInternal _Expression_MaskExpression_ListSelect_default_instance_; +class Expression_MaskExpression_ListSelect_ListSelectItem; +struct Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal; +extern Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_; +class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement; +struct Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal; +extern Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_; +class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice; +struct Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal; +extern Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_; +class Expression_MaskExpression_MapSelect; +struct Expression_MaskExpression_MapSelectDefaultTypeInternal; +extern Expression_MaskExpression_MapSelectDefaultTypeInternal _Expression_MaskExpression_MapSelect_default_instance_; +class Expression_MaskExpression_MapSelect_MapKey; +struct Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal; +extern Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKey_default_instance_; +class Expression_MaskExpression_MapSelect_MapKeyExpression; +struct Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal; +extern Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_; +class Expression_MaskExpression_Select; +struct Expression_MaskExpression_SelectDefaultTypeInternal; +extern Expression_MaskExpression_SelectDefaultTypeInternal _Expression_MaskExpression_Select_default_instance_; +class Expression_MaskExpression_StructItem; +struct Expression_MaskExpression_StructItemDefaultTypeInternal; +extern Expression_MaskExpression_StructItemDefaultTypeInternal _Expression_MaskExpression_StructItem_default_instance_; +class Expression_MaskExpression_StructSelect; +struct Expression_MaskExpression_StructSelectDefaultTypeInternal; +extern Expression_MaskExpression_StructSelectDefaultTypeInternal _Expression_MaskExpression_StructSelect_default_instance_; class Expression_MultiOrList; struct Expression_MultiOrListDefaultTypeInternal; extern Expression_MultiOrListDefaultTypeInternal _Expression_MultiOrList_default_instance_; class Expression_MultiOrList_Record; struct Expression_MultiOrList_RecordDefaultTypeInternal; extern Expression_MultiOrList_RecordDefaultTypeInternal _Expression_MultiOrList_Record_default_instance_; +class Expression_ReferenceSegment; +struct Expression_ReferenceSegmentDefaultTypeInternal; +extern Expression_ReferenceSegmentDefaultTypeInternal _Expression_ReferenceSegment_default_instance_; +class Expression_ReferenceSegment_ListElement; +struct Expression_ReferenceSegment_ListElementDefaultTypeInternal; +extern Expression_ReferenceSegment_ListElementDefaultTypeInternal _Expression_ReferenceSegment_ListElement_default_instance_; +class Expression_ReferenceSegment_MapKey; +struct Expression_ReferenceSegment_MapKeyDefaultTypeInternal; +extern Expression_ReferenceSegment_MapKeyDefaultTypeInternal _Expression_ReferenceSegment_MapKey_default_instance_; +class Expression_ReferenceSegment_StructField; +struct Expression_ReferenceSegment_StructFieldDefaultTypeInternal; +extern Expression_ReferenceSegment_StructFieldDefaultTypeInternal _Expression_ReferenceSegment_StructField_default_instance_; class Expression_ScalarFunction; struct Expression_ScalarFunctionDefaultTypeInternal; extern Expression_ScalarFunctionDefaultTypeInternal _Expression_ScalarFunction_default_instance_; class Expression_SingularOrList; struct Expression_SingularOrListDefaultTypeInternal; extern Expression_SingularOrListDefaultTypeInternal _Expression_SingularOrList_default_instance_; -class Expression_SortField; -struct Expression_SortFieldDefaultTypeInternal; -extern Expression_SortFieldDefaultTypeInternal _Expression_SortField_default_instance_; class Expression_SwitchExpression; struct Expression_SwitchExpressionDefaultTypeInternal; extern Expression_SwitchExpressionDefaultTypeInternal _Expression_SwitchExpression_default_instance_; @@ -146,30 +201,52 @@ extern Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal _Expression_ class Expression_WindowFunction_Bound_Unbounded; struct Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal; extern Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal _Expression_WindowFunction_Bound_Unbounded_default_instance_; +class SortField; +struct SortFieldDefaultTypeInternal; +extern SortFieldDefaultTypeInternal _SortField_default_instance_; } // namespace substrait } // namespace io PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::AggregateFunction* Arena::CreateMaybeMessage<::io::substrait::AggregateFunction>(Arena*); template<> ::io::substrait::Expression* Arena::CreateMaybeMessage<::io::substrait::Expression>(Arena*); -template<> ::io::substrait::Expression_AggregateFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_AggregateFunction>(Arena*); +template<> ::io::substrait::Expression_Cast* Arena::CreateMaybeMessage<::io::substrait::Expression_Cast>(Arena*); template<> ::io::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_EmbeddedFunction>(Arena*); template<> ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction>(Arena*); template<> ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction>(Arena*); template<> ::io::substrait::Expression_Enum* Arena::CreateMaybeMessage<::io::substrait::Expression_Enum>(Arena*); template<> ::io::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage<::io::substrait::Expression_Enum_Empty>(Arena*); +template<> ::io::substrait::Expression_FieldReference* Arena::CreateMaybeMessage<::io::substrait::Expression_FieldReference>(Arena*); +template<> ::io::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage<::io::substrait::Expression_FieldReference_RootReference>(Arena*); template<> ::io::substrait::Expression_IfThen* Arena::CreateMaybeMessage<::io::substrait::Expression_IfThen>(Arena*); template<> ::io::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage<::io::substrait::Expression_IfThen_IfClause>(Arena*); template<> ::io::substrait::Expression_Literal* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal>(Arena*); +template<> ::io::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Decimal>(Arena*); template<> ::io::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_IntervalDayToSecond>(Arena*); template<> ::io::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_IntervalYearToMonth>(Arena*); template<> ::io::substrait::Expression_Literal_List* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_List>(Arena*); template<> ::io::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Map>(Arena*); template<> ::io::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Map_KeyValue>(Arena*); template<> ::io::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Struct>(Arena*); +template<> ::io::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_VarChar>(Arena*); +template<> ::io::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression>(Arena*); +template<> ::io::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_ListSelect>(Arena*); +template<> ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem>(Arena*); +template<> ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement>(Arena*); +template<> ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice>(Arena*); +template<> ::io::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_MapSelect>(Arena*); +template<> ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_MapSelect_MapKey>(Arena*); +template<> ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression>(Arena*); +template<> ::io::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_Select>(Arena*); +template<> ::io::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_StructItem>(Arena*); +template<> ::io::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_StructSelect>(Arena*); template<> ::io::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage<::io::substrait::Expression_MultiOrList>(Arena*); template<> ::io::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage<::io::substrait::Expression_MultiOrList_Record>(Arena*); +template<> ::io::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment>(Arena*); +template<> ::io::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment_ListElement>(Arena*); +template<> ::io::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment_MapKey>(Arena*); +template<> ::io::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment_StructField>(Arena*); template<> ::io::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_ScalarFunction>(Arena*); template<> ::io::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage<::io::substrait::Expression_SingularOrList>(Arena*); -template<> ::io::substrait::Expression_SortField* Arena::CreateMaybeMessage<::io::substrait::Expression_SortField>(Arena*); template<> ::io::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage<::io::substrait::Expression_SwitchExpression>(Arena*); template<> ::io::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage<::io::substrait::Expression_SwitchExpression_IfValue>(Arena*); template<> ::io::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction>(Arena*); @@ -178,66 +255,67 @@ template<> ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::C template<> ::io::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_Following>(Arena*); template<> ::io::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_Preceding>(Arena*); template<> ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_Unbounded>(Arena*); +template<> ::io::substrait::SortField* Arena::CreateMaybeMessage<::io::substrait::SortField>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace io { namespace substrait { -enum Expression_SortField_SortDirection : int { - Expression_SortField_SortDirection_UNKNOWN = 0, - Expression_SortField_SortDirection_ASC_NULLS_FIRST = 1, - Expression_SortField_SortDirection_ASC_NULLS_LAST = 2, - Expression_SortField_SortDirection_DESC_NULLS_FIRST = 3, - Expression_SortField_SortDirection_DESC_NULLS_LAST = 4, - Expression_SortField_SortDirection_CLUSTERED = 5, - Expression_SortField_SortDirection_Expression_SortField_SortDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - Expression_SortField_SortDirection_Expression_SortField_SortDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +enum SortField_SortDirection : int { + SortField_SortDirection_UNKNOWN = 0, + SortField_SortDirection_ASC_NULLS_FIRST = 1, + SortField_SortDirection_ASC_NULLS_LAST = 2, + SortField_SortDirection_DESC_NULLS_FIRST = 3, + SortField_SortDirection_DESC_NULLS_LAST = 4, + SortField_SortDirection_CLUSTERED = 5, + SortField_SortDirection_SortField_SortDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + SortField_SortDirection_SortField_SortDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; -bool Expression_SortField_SortDirection_IsValid(int value); -constexpr Expression_SortField_SortDirection Expression_SortField_SortDirection_SortDirection_MIN = Expression_SortField_SortDirection_UNKNOWN; -constexpr Expression_SortField_SortDirection Expression_SortField_SortDirection_SortDirection_MAX = Expression_SortField_SortDirection_CLUSTERED; -constexpr int Expression_SortField_SortDirection_SortDirection_ARRAYSIZE = Expression_SortField_SortDirection_SortDirection_MAX + 1; +bool SortField_SortDirection_IsValid(int value); +constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MIN = SortField_SortDirection_UNKNOWN; +constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MAX = SortField_SortDirection_CLUSTERED; +constexpr int SortField_SortDirection_SortDirection_ARRAYSIZE = SortField_SortDirection_SortDirection_MAX + 1; -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_SortField_SortDirection_descriptor(); +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortField_SortDirection_descriptor(); template -inline const std::string& Expression_SortField_SortDirection_Name(T enum_t_value) { - static_assert(::std::is_same::value || +inline const std::string& SortField_SortDirection_Name(T enum_t_value) { + static_assert(::std::is_same::value || ::std::is_integral::value, - "Incorrect type passed to function Expression_SortField_SortDirection_Name."); + "Incorrect type passed to function SortField_SortDirection_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Expression_SortField_SortDirection_descriptor(), enum_t_value); -} -inline bool Expression_SortField_SortDirection_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Expression_SortField_SortDirection* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Expression_SortField_SortDirection_descriptor(), name, value); -} -enum Expression_AggregationPhase : int { - Expression_AggregationPhase_UNKNOWN = 0, - Expression_AggregationPhase_INITIAL_TO_INTERMEDIATE = 1, - Expression_AggregationPhase_INTERMEDIATE_TO_INTERMEDIATE = 2, - Expression_AggregationPhase_INITIAL_TO_RESULT = 3, - Expression_AggregationPhase_INTERMEDIATE_TO_RESULT = 4, - Expression_AggregationPhase_Expression_AggregationPhase_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - Expression_AggregationPhase_Expression_AggregationPhase_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + SortField_SortDirection_descriptor(), enum_t_value); +} +inline bool SortField_SortDirection_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SortField_SortDirection* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + SortField_SortDirection_descriptor(), name, value); +} +enum AggregationPhase : int { + UNKNOWN = 0, + INITIAL_TO_INTERMEDIATE = 1, + INTERMEDIATE_TO_INTERMEDIATE = 2, + INITIAL_TO_RESULT = 3, + INTERMEDIATE_TO_RESULT = 4, + AggregationPhase_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + AggregationPhase_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; -bool Expression_AggregationPhase_IsValid(int value); -constexpr Expression_AggregationPhase Expression_AggregationPhase_AggregationPhase_MIN = Expression_AggregationPhase_UNKNOWN; -constexpr Expression_AggregationPhase Expression_AggregationPhase_AggregationPhase_MAX = Expression_AggregationPhase_INTERMEDIATE_TO_RESULT; -constexpr int Expression_AggregationPhase_AggregationPhase_ARRAYSIZE = Expression_AggregationPhase_AggregationPhase_MAX + 1; +bool AggregationPhase_IsValid(int value); +constexpr AggregationPhase AggregationPhase_MIN = UNKNOWN; +constexpr AggregationPhase AggregationPhase_MAX = INTERMEDIATE_TO_RESULT; +constexpr int AggregationPhase_ARRAYSIZE = AggregationPhase_MAX + 1; -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Expression_AggregationPhase_descriptor(); +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggregationPhase_descriptor(); template -inline const std::string& Expression_AggregationPhase_Name(T enum_t_value) { - static_assert(::std::is_same::value || +inline const std::string& AggregationPhase_Name(T enum_t_value) { + static_assert(::std::is_same::value || ::std::is_integral::value, - "Incorrect type passed to function Expression_AggregationPhase_Name."); + "Incorrect type passed to function AggregationPhase_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Expression_AggregationPhase_descriptor(), enum_t_value); + AggregationPhase_descriptor(), enum_t_value); } -inline bool Expression_AggregationPhase_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Expression_AggregationPhase* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Expression_AggregationPhase_descriptor(), name, value); +inline bool AggregationPhase_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AggregationPhase* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + AggregationPhase_descriptor(), name, value); } // =================================================================== @@ -540,6 +618,311 @@ class Expression_Enum PROTOBUF_FINAL : }; // ------------------------------------------------------------------- +class Expression_Literal_VarChar PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.VarChar) */ { + public: + inline Expression_Literal_VarChar() : Expression_Literal_VarChar(nullptr) {} + ~Expression_Literal_VarChar() override; + explicit constexpr Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Literal_VarChar(const Expression_Literal_VarChar& from); + Expression_Literal_VarChar(Expression_Literal_VarChar&& from) noexcept + : Expression_Literal_VarChar() { + *this = ::std::move(from); + } + + inline Expression_Literal_VarChar& operator=(const Expression_Literal_VarChar& from) { + CopyFrom(from); + return *this; + } + inline Expression_Literal_VarChar& operator=(Expression_Literal_VarChar&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Literal_VarChar& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_Literal_VarChar* internal_default_instance() { + return reinterpret_cast( + &_Expression_Literal_VarChar_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(Expression_Literal_VarChar& a, Expression_Literal_VarChar& b) { + a.Swap(&b); + } + inline void Swap(Expression_Literal_VarChar* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Literal_VarChar* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Literal_VarChar* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Literal_VarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Literal_VarChar& from); + void MergeFrom(const Expression_Literal_VarChar& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Literal_VarChar* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Literal.VarChar"; + } + protected: + explicit Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kValueFieldNumber = 1, + kLengthFieldNumber = 2, + }; + // string value = 1; + void clear_value(); + const std::string& value() const; + template + void set_value(ArgT0&& arg0, ArgT... args); + std::string* mutable_value(); + std::string* release_value(); + void set_allocated_value(std::string* value); + private: + const std::string& _internal_value() const; + void _internal_set_value(const std::string& value); + std::string* _internal_mutable_value(); + public: + + // uint32 length = 2; + void clear_length(); + ::PROTOBUF_NAMESPACE_ID::uint32 length() const; + void set_length(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_length() const; + void _internal_set_length(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.VarChar) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; + ::PROTOBUF_NAMESPACE_ID::uint32 length_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_Literal_Decimal PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.Decimal) */ { + public: + inline Expression_Literal_Decimal() : Expression_Literal_Decimal(nullptr) {} + ~Expression_Literal_Decimal() override; + explicit constexpr Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_Literal_Decimal(const Expression_Literal_Decimal& from); + Expression_Literal_Decimal(Expression_Literal_Decimal&& from) noexcept + : Expression_Literal_Decimal() { + *this = ::std::move(from); + } + + inline Expression_Literal_Decimal& operator=(const Expression_Literal_Decimal& from) { + CopyFrom(from); + return *this; + } + inline Expression_Literal_Decimal& operator=(Expression_Literal_Decimal&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_Literal_Decimal& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_Literal_Decimal* internal_default_instance() { + return reinterpret_cast( + &_Expression_Literal_Decimal_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(Expression_Literal_Decimal& a, Expression_Literal_Decimal& b) { + a.Swap(&b); + } + inline void Swap(Expression_Literal_Decimal* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_Literal_Decimal* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_Literal_Decimal* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_Literal_Decimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_Literal_Decimal& from); + void MergeFrom(const Expression_Literal_Decimal& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_Literal_Decimal* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.Literal.Decimal"; + } + protected: + explicit Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kValueFieldNumber = 1, + kPrecisionFieldNumber = 2, + kScaleFieldNumber = 3, + }; + // bytes value = 1; + void clear_value(); + const std::string& value() const; + template + void set_value(ArgT0&& arg0, ArgT... args); + std::string* mutable_value(); + std::string* release_value(); + void set_allocated_value(std::string* value); + private: + const std::string& _internal_value() const; + void _internal_set_value(const std::string& value); + std::string* _internal_mutable_value(); + public: + + // int32 precision = 2; + void clear_precision(); + ::PROTOBUF_NAMESPACE_ID::int32 precision() const; + void set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_precision() const; + void _internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // int32 scale = 3; + void clear_scale(); + ::PROTOBUF_NAMESPACE_ID::int32 scale() const; + void set_scale(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_scale() const; + void _internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.Decimal) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; + ::PROTOBUF_NAMESPACE_ID::int32 precision_; + ::PROTOBUF_NAMESPACE_ID::int32 scale_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.Map.KeyValue) */ { public: @@ -583,7 +966,7 @@ class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : &_Expression_Literal_Map_KeyValue_default_instance_); } static constexpr int kIndexInFileMessages = - 2; + 4; friend void swap(Expression_Literal_Map_KeyValue& a, Expression_Literal_Map_KeyValue& b) { a.Swap(&b); @@ -743,7 +1126,7 @@ class Expression_Literal_Map PROTOBUF_FINAL : &_Expression_Literal_Map_default_instance_); } static constexpr int kIndexInFileMessages = - 3; + 5; friend void swap(Expression_Literal_Map& a, Expression_Literal_Map& b) { a.Swap(&b); @@ -810,6 +1193,8 @@ class Expression_Literal_Map PROTOBUF_FINAL : enum : int { kKeyValuesFieldNumber = 1, + kKeyTypeFieldNumber = 2, + kValueTypeFieldNumber = 3, }; // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; int key_values_size() const; @@ -829,6 +1214,42 @@ class Expression_Literal_Map PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >& key_values() const; + // .io.substrait.Type key_type = 2; + bool has_key_type() const; + private: + bool _internal_has_key_type() const; + public: + void clear_key_type(); + const ::io::substrait::Type& key_type() const; + ::io::substrait::Type* release_key_type(); + ::io::substrait::Type* mutable_key_type(); + void set_allocated_key_type(::io::substrait::Type* key_type); + private: + const ::io::substrait::Type& _internal_key_type() const; + ::io::substrait::Type* _internal_mutable_key_type(); + public: + void unsafe_arena_set_allocated_key_type( + ::io::substrait::Type* key_type); + ::io::substrait::Type* unsafe_arena_release_key_type(); + + // .io.substrait.Type value_type = 3; + bool has_value_type() const; + private: + bool _internal_has_value_type() const; + public: + void clear_value_type(); + const ::io::substrait::Type& value_type() const; + ::io::substrait::Type* release_value_type(); + ::io::substrait::Type* mutable_value_type(); + void set_allocated_value_type(::io::substrait::Type* value_type); + private: + const ::io::substrait::Type& _internal_value_type() const; + ::io::substrait::Type* _internal_mutable_value_type(); + public: + void unsafe_arena_set_allocated_value_type( + ::io::substrait::Type* value_type); + ::io::substrait::Type* unsafe_arena_release_value_type(); + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.Map) private: class _Internal; @@ -837,6 +1258,8 @@ class Expression_Literal_Map PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue > key_values_; + ::io::substrait::Type* key_type_; + ::io::substrait::Type* value_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_expression_2eproto; }; @@ -885,7 +1308,7 @@ class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : &_Expression_Literal_IntervalYearToMonth_default_instance_); } static constexpr int kIndexInFileMessages = - 4; + 6; friend void swap(Expression_Literal_IntervalYearToMonth& a, Expression_Literal_IntervalYearToMonth& b) { a.Swap(&b); @@ -1027,7 +1450,7 @@ class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : &_Expression_Literal_IntervalDayToSecond_default_instance_); } static constexpr int kIndexInFileMessages = - 5; + 7; friend void swap(Expression_Literal_IntervalDayToSecond& a, Expression_Literal_IntervalDayToSecond& b) { a.Swap(&b); @@ -1169,7 +1592,7 @@ class Expression_Literal_Struct PROTOBUF_FINAL : &_Expression_Literal_Struct_default_instance_); } static constexpr int kIndexInFileMessages = - 6; + 8; friend void swap(Expression_Literal_Struct& a, Expression_Literal_Struct& b) { a.Swap(&b); @@ -1309,7 +1732,7 @@ class Expression_Literal_List PROTOBUF_FINAL : &_Expression_Literal_List_default_instance_); } static constexpr int kIndexInFileMessages = - 7; + 9; friend void swap(Expression_Literal_List& a, Expression_Literal_List& b) { a.Swap(&b); @@ -1374,6 +1797,7 @@ class Expression_Literal_List PROTOBUF_FINAL : enum : int { kValuesFieldNumber = 1, + kElementTypeFieldNumber = 2, }; // repeated .io.substrait.Expression.Literal values = 1; int values_size() const; @@ -1393,6 +1817,24 @@ class Expression_Literal_List PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& values() const; + // .io.substrait.Type element_type = 2; + bool has_element_type() const; + private: + bool _internal_has_element_type() const; + public: + void clear_element_type(); + const ::io::substrait::Type& element_type() const; + ::io::substrait::Type* release_element_type(); + ::io::substrait::Type* mutable_element_type(); + void set_allocated_element_type(::io::substrait::Type* element_type); + private: + const ::io::substrait::Type& _internal_element_type() const; + ::io::substrait::Type* _internal_mutable_element_type(); + public: + void unsafe_arena_set_allocated_element_type( + ::io::substrait::Type* element_type); + ::io::substrait::Type* unsafe_arena_release_element_type(); + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.List) private: class _Internal; @@ -1401,6 +1843,7 @@ class Expression_Literal_List PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal > values_; + ::io::substrait::Type* element_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_expression_2eproto; }; @@ -1477,7 +1920,7 @@ class Expression_Literal PROTOBUF_FINAL : &_Expression_Literal_default_instance_); } static constexpr int kIndexInFileMessages = - 8; + 10; friend void swap(Expression_Literal& a, Expression_Literal& b) { a.Swap(&b); @@ -1538,6 +1981,8 @@ class Expression_Literal PROTOBUF_FINAL : // nested types ---------------------------------------------------- + typedef Expression_Literal_VarChar VarChar; + typedef Expression_Literal_Decimal Decimal; typedef Expression_Literal_Map Map; typedef Expression_Literal_IntervalYearToMonth IntervalYearToMonth; typedef Expression_Literal_IntervalDayToSecond IntervalDayToSecond; @@ -1547,6 +1992,7 @@ class Expression_Literal PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { + kNullableFieldNumber = 50, kBooleanFieldNumber = 1, kI8FieldNumber = 2, kI16FieldNumber = 3, @@ -1572,6 +2018,15 @@ class Expression_Literal PROTOBUF_FINAL : kNullFieldNumber = 29, kListFieldNumber = 30, }; + // bool nullable = 50; + void clear_nullable(); + bool nullable() const; + void set_nullable(bool value); + private: + bool _internal_nullable() const; + void _internal_set_nullable(bool value); + public: + // bool boolean = 1; bool has_boolean() const; private: @@ -1699,43 +2154,43 @@ class Expression_Literal PROTOBUF_FINAL : std::string* _internal_mutable_binary(); public: - // fixed64 timestamp = 14; + // int64 timestamp = 14; bool has_timestamp() const; private: bool _internal_has_timestamp() const; public: void clear_timestamp(); - ::PROTOBUF_NAMESPACE_ID::uint64 timestamp() const; - void set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + ::PROTOBUF_NAMESPACE_ID::int64 timestamp() const; + void set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value); private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_timestamp() const; - void _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value); + ::PROTOBUF_NAMESPACE_ID::int64 _internal_timestamp() const; + void _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value); public: - // fixed32 date = 16; + // int64 date = 16; bool has_date() const; private: bool _internal_has_date() const; public: void clear_date(); - ::PROTOBUF_NAMESPACE_ID::uint32 date() const; - void set_date(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::int64 date() const; + void set_date(::PROTOBUF_NAMESPACE_ID::int64 value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_date() const; - void _internal_set_date(::PROTOBUF_NAMESPACE_ID::uint32 value); + ::PROTOBUF_NAMESPACE_ID::int64 _internal_date() const; + void _internal_set_date(::PROTOBUF_NAMESPACE_ID::int64 value); public: - // uint64 time = 17; + // int64 time = 17; bool has_time() const; private: bool _internal_has_time() const; public: void clear_time(); - ::PROTOBUF_NAMESPACE_ID::uint64 time() const; - void set_time(::PROTOBUF_NAMESPACE_ID::uint64 value); + ::PROTOBUF_NAMESPACE_ID::int64 time() const; + void set_time(::PROTOBUF_NAMESPACE_ID::int64 value); private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_time() const; - void _internal_set_time(::PROTOBUF_NAMESPACE_ID::uint64 value); + ::PROTOBUF_NAMESPACE_ID::int64 _internal_time() const; + void _internal_set_time(::PROTOBUF_NAMESPACE_ID::int64 value); public: // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; @@ -1792,23 +2247,23 @@ class Expression_Literal PROTOBUF_FINAL : std::string* _internal_mutable_fixed_char(); public: - // string var_char = 22; + // .io.substrait.Expression.Literal.VarChar var_char = 22; bool has_var_char() const; private: bool _internal_has_var_char() const; public: void clear_var_char(); - const std::string& var_char() const; - template - void set_var_char(ArgT0&& arg0, ArgT... args); - std::string* mutable_var_char(); - std::string* release_var_char(); - void set_allocated_var_char(std::string* var_char); + const ::io::substrait::Expression_Literal_VarChar& var_char() const; + ::io::substrait::Expression_Literal_VarChar* release_var_char(); + ::io::substrait::Expression_Literal_VarChar* mutable_var_char(); + void set_allocated_var_char(::io::substrait::Expression_Literal_VarChar* var_char); private: - const std::string& _internal_var_char() const; - void _internal_set_var_char(const std::string& value); - std::string* _internal_mutable_var_char(); + const ::io::substrait::Expression_Literal_VarChar& _internal_var_char() const; + ::io::substrait::Expression_Literal_VarChar* _internal_mutable_var_char(); public: + void unsafe_arena_set_allocated_var_char( + ::io::substrait::Expression_Literal_VarChar* var_char); + ::io::substrait::Expression_Literal_VarChar* unsafe_arena_release_var_char(); // bytes fixed_binary = 23; bool has_fixed_binary() const; @@ -1828,23 +2283,23 @@ class Expression_Literal PROTOBUF_FINAL : std::string* _internal_mutable_fixed_binary(); public: - // bytes decimal = 24; + // .io.substrait.Expression.Literal.Decimal decimal = 24; bool has_decimal() const; private: bool _internal_has_decimal() const; public: void clear_decimal(); - const std::string& decimal() const; - template - void set_decimal(ArgT0&& arg0, ArgT... args); - std::string* mutable_decimal(); - std::string* release_decimal(); - void set_allocated_decimal(std::string* decimal); + const ::io::substrait::Expression_Literal_Decimal& decimal() const; + ::io::substrait::Expression_Literal_Decimal* release_decimal(); + ::io::substrait::Expression_Literal_Decimal* mutable_decimal(); + void set_allocated_decimal(::io::substrait::Expression_Literal_Decimal* decimal); private: - const std::string& _internal_decimal() const; - void _internal_set_decimal(const std::string& value); - std::string* _internal_mutable_decimal(); + const ::io::substrait::Expression_Literal_Decimal& _internal_decimal() const; + ::io::substrait::Expression_Literal_Decimal* _internal_mutable_decimal(); public: + void unsafe_arena_set_allocated_decimal( + ::io::substrait::Expression_Literal_Decimal* decimal); + ::io::substrait::Expression_Literal_Decimal* unsafe_arena_release_decimal(); // .io.substrait.Expression.Literal.Struct struct = 25; bool has_struct_() const; @@ -1882,17 +2337,17 @@ class Expression_Literal PROTOBUF_FINAL : ::io::substrait::Expression_Literal_Map* map); ::io::substrait::Expression_Literal_Map* unsafe_arena_release_map(); - // fixed64 timestamp_tz = 27; + // int64 timestamp_tz = 27; bool has_timestamp_tz() const; private: bool _internal_has_timestamp_tz() const; public: void clear_timestamp_tz(); - ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_tz() const; - void set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::uint64 value); + ::PROTOBUF_NAMESPACE_ID::int64 timestamp_tz() const; + void set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::int64 value); private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_timestamp_tz() const; - void _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::uint64 value); + ::PROTOBUF_NAMESPACE_ID::int64 _internal_timestamp_tz() const; + void _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::int64 value); public: // bytes uuid = 28; @@ -1985,6 +2440,7 @@ class Expression_Literal PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; + bool nullable_; union LiteralTypeUnion { constexpr LiteralTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; @@ -1997,18 +2453,18 @@ class Expression_Literal PROTOBUF_FINAL : double fp64_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_; - ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_; - ::PROTOBUF_NAMESPACE_ID::uint32 date_; - ::PROTOBUF_NAMESPACE_ID::uint64 time_; + ::PROTOBUF_NAMESPACE_ID::int64 timestamp_; + ::PROTOBUF_NAMESPACE_ID::int64 date_; + ::PROTOBUF_NAMESPACE_ID::int64 time_; ::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month_; ::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_char_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr var_char_; + ::io::substrait::Expression_Literal_VarChar* var_char_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_binary_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr decimal_; + ::io::substrait::Expression_Literal_Decimal* decimal_; ::io::substrait::Expression_Literal_Struct* struct__; ::io::substrait::Expression_Literal_Map* map_; - ::PROTOBUF_NAMESPACE_ID::uint64 timestamp_tz_; + ::PROTOBUF_NAMESPACE_ID::int64 timestamp_tz_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uuid_; ::io::substrait::Type* null_; ::io::substrait::Expression_Literal_List* list_; @@ -2063,7 +2519,7 @@ class Expression_ScalarFunction PROTOBUF_FINAL : &_Expression_ScalarFunction_default_instance_); } static constexpr int kIndexInFileMessages = - 9; + 11; friend void swap(Expression_ScalarFunction& a, Expression_ScalarFunction& b) { a.Swap(&b); @@ -2128,8 +2584,8 @@ class Expression_ScalarFunction PROTOBUF_FINAL : enum : int { kArgsFieldNumber = 2, - kIdFieldNumber = 1, kOutputTypeFieldNumber = 3, + kFunctionReferenceFieldNumber = 1, }; // repeated .io.substrait.Expression args = 2; int args_size() const; @@ -2149,24 +2605,6 @@ class Expression_ScalarFunction PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& args() const; - // .io.substrait.Extensions.FunctionId id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const ::io::substrait::Extensions_FunctionId& id() const; - ::io::substrait::Extensions_FunctionId* release_id(); - ::io::substrait::Extensions_FunctionId* mutable_id(); - void set_allocated_id(::io::substrait::Extensions_FunctionId* id); - private: - const ::io::substrait::Extensions_FunctionId& _internal_id() const; - ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); - public: - void unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id); - ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); - // .io.substrait.Type output_type = 3; bool has_output_type() const; private: @@ -2185,6 +2623,15 @@ class Expression_ScalarFunction PROTOBUF_FINAL : ::io::substrait::Type* output_type); ::io::substrait::Type* unsafe_arena_release_output_type(); + // uint32 function_reference = 1; + void clear_function_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 function_reference() const; + void set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_function_reference() const; + void _internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + // @@protoc_insertion_point(class_scope:io.substrait.Expression.ScalarFunction) private: class _Internal; @@ -2193,230 +2640,19 @@ class Expression_ScalarFunction PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > args_; - ::io::substrait::Extensions_FunctionId* id_; ::io::substrait::Type* output_type_; + ::PROTOBUF_NAMESPACE_ID::uint32 function_reference_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_expression_2eproto; }; // ------------------------------------------------------------------- -class Expression_AggregateFunction PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.AggregateFunction) */ { +class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound.Preceding) */ { public: - inline Expression_AggregateFunction() : Expression_AggregateFunction(nullptr) {} - ~Expression_AggregateFunction() override; - explicit constexpr Expression_AggregateFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_AggregateFunction(const Expression_AggregateFunction& from); - Expression_AggregateFunction(Expression_AggregateFunction&& from) noexcept - : Expression_AggregateFunction() { - *this = ::std::move(from); - } - - inline Expression_AggregateFunction& operator=(const Expression_AggregateFunction& from) { - CopyFrom(from); - return *this; - } - inline Expression_AggregateFunction& operator=(Expression_AggregateFunction&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 Expression_AggregateFunction& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_AggregateFunction* internal_default_instance() { - return reinterpret_cast( - &_Expression_AggregateFunction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(Expression_AggregateFunction& a, Expression_AggregateFunction& b) { - a.Swap(&b); - } - inline void Swap(Expression_AggregateFunction* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Expression_AggregateFunction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline Expression_AggregateFunction* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_AggregateFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Expression_AggregateFunction& from); - void MergeFrom(const Expression_AggregateFunction& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_AggregateFunction* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.AggregateFunction"; - } - protected: - explicit Expression_AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kArgsFieldNumber = 2, - kSortsFieldNumber = 3, - kIdFieldNumber = 1, - kOutputTypeFieldNumber = 5, - kPhaseFieldNumber = 4, - }; - // repeated .io.substrait.Expression args = 2; - int args_size() const; - private: - int _internal_args_size() const; - public: - void clear_args(); - ::io::substrait::Expression* mutable_args(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* - mutable_args(); - private: - const ::io::substrait::Expression& _internal_args(int index) const; - ::io::substrait::Expression* _internal_add_args(); - public: - const ::io::substrait::Expression& args(int index) const; - ::io::substrait::Expression* add_args(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& - args() const; - - // repeated .io.substrait.Expression.SortField sorts = 3; - int sorts_size() const; - private: - int _internal_sorts_size() const; - public: - void clear_sorts(); - ::io::substrait::Expression_SortField* mutable_sorts(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* - mutable_sorts(); - private: - const ::io::substrait::Expression_SortField& _internal_sorts(int index) const; - ::io::substrait::Expression_SortField* _internal_add_sorts(); - public: - const ::io::substrait::Expression_SortField& sorts(int index) const; - ::io::substrait::Expression_SortField* add_sorts(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& - sorts() const; - - // .io.substrait.Extensions.FunctionId id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const ::io::substrait::Extensions_FunctionId& id() const; - ::io::substrait::Extensions_FunctionId* release_id(); - ::io::substrait::Extensions_FunctionId* mutable_id(); - void set_allocated_id(::io::substrait::Extensions_FunctionId* id); - private: - const ::io::substrait::Extensions_FunctionId& _internal_id() const; - ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); - public: - void unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id); - ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); - - // .io.substrait.Type output_type = 5; - bool has_output_type() const; - private: - bool _internal_has_output_type() const; - public: - void clear_output_type(); - const ::io::substrait::Type& output_type() const; - ::io::substrait::Type* release_output_type(); - ::io::substrait::Type* mutable_output_type(); - void set_allocated_output_type(::io::substrait::Type* output_type); - private: - const ::io::substrait::Type& _internal_output_type() const; - ::io::substrait::Type* _internal_mutable_output_type(); - public: - void unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type); - ::io::substrait::Type* unsafe_arena_release_output_type(); - - // .io.substrait.Expression.AggregationPhase phase = 4; - void clear_phase(); - ::io::substrait::Expression_AggregationPhase phase() const; - void set_phase(::io::substrait::Expression_AggregationPhase value); - private: - ::io::substrait::Expression_AggregationPhase _internal_phase() const; - void _internal_set_phase(::io::substrait::Expression_AggregationPhase value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.Expression.AggregateFunction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > args_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField > sorts_; - ::io::substrait::Extensions_FunctionId* id_; - ::io::substrait::Type* output_type_; - int phase_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound.Preceding) */ { - public: - inline Expression_WindowFunction_Bound_Preceding() : Expression_WindowFunction_Bound_Preceding(nullptr) {} - ~Expression_WindowFunction_Bound_Preceding() override; - explicit constexpr Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline Expression_WindowFunction_Bound_Preceding() : Expression_WindowFunction_Bound_Preceding(nullptr) {} + ~Expression_WindowFunction_Bound_Preceding() override; + explicit constexpr Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from); Expression_WindowFunction_Bound_Preceding(Expression_WindowFunction_Bound_Preceding&& from) noexcept @@ -2454,7 +2690,7 @@ class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : &_Expression_WindowFunction_Bound_Preceding_default_instance_); } static constexpr int kIndexInFileMessages = - 11; + 12; friend void swap(Expression_WindowFunction_Bound_Preceding& a, Expression_WindowFunction_Bound_Preceding& b) { a.Swap(&b); @@ -2585,7 +2821,7 @@ class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : &_Expression_WindowFunction_Bound_Following_default_instance_); } static constexpr int kIndexInFileMessages = - 12; + 13; friend void swap(Expression_WindowFunction_Bound_Following& a, Expression_WindowFunction_Bound_Following& b) { a.Swap(&b); @@ -2716,7 +2952,7 @@ class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : &_Expression_WindowFunction_Bound_CurrentRow_default_instance_); } static constexpr int kIndexInFileMessages = - 13; + 14; friend void swap(Expression_WindowFunction_Bound_CurrentRow& a, Expression_WindowFunction_Bound_CurrentRow& b) { a.Swap(&b); @@ -2834,7 +3070,7 @@ class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : &_Expression_WindowFunction_Bound_Unbounded_default_instance_); } static constexpr int kIndexInFileMessages = - 14; + 15; friend void swap(Expression_WindowFunction_Bound_Unbounded& a, Expression_WindowFunction_Bound_Unbounded& b) { a.Swap(&b); @@ -2960,7 +3196,7 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : &_Expression_WindowFunction_Bound_default_instance_); } static constexpr int kIndexInFileMessages = - 15; + 16; friend void swap(Expression_WindowFunction_Bound& a, Expression_WindowFunction_Bound& b) { a.Swap(&b); @@ -3180,7 +3416,7 @@ class Expression_WindowFunction PROTOBUF_FINAL : &_Expression_WindowFunction_default_instance_); } static constexpr int kIndexInFileMessages = - 16; + 17; friend void swap(Expression_WindowFunction& a, Expression_WindowFunction& b) { a.Swap(&b); @@ -3249,10 +3485,10 @@ class Expression_WindowFunction PROTOBUF_FINAL : kPartitionsFieldNumber = 2, kSortsFieldNumber = 3, kArgsFieldNumber = 8, - kIdFieldNumber = 1, kUpperBoundFieldNumber = 4, kLowerBoundFieldNumber = 5, kOutputTypeFieldNumber = 7, + kFunctionReferenceFieldNumber = 1, kPhaseFieldNumber = 6, }; // repeated .io.substrait.Expression partitions = 2; @@ -3273,22 +3509,22 @@ class Expression_WindowFunction PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& partitions() const; - // repeated .io.substrait.Expression.SortField sorts = 3; + // repeated .io.substrait.SortField sorts = 3; int sorts_size() const; private: int _internal_sorts_size() const; public: void clear_sorts(); - ::io::substrait::Expression_SortField* mutable_sorts(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* + ::io::substrait::SortField* mutable_sorts(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* mutable_sorts(); private: - const ::io::substrait::Expression_SortField& _internal_sorts(int index) const; - ::io::substrait::Expression_SortField* _internal_add_sorts(); + const ::io::substrait::SortField& _internal_sorts(int index) const; + ::io::substrait::SortField* _internal_add_sorts(); public: - const ::io::substrait::Expression_SortField& sorts(int index) const; - ::io::substrait::Expression_SortField* add_sorts(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& + const ::io::substrait::SortField& sorts(int index) const; + ::io::substrait::SortField* add_sorts(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& sorts() const; // repeated .io.substrait.Expression args = 8; @@ -3309,24 +3545,6 @@ class Expression_WindowFunction PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& args() const; - // .io.substrait.Extensions.FunctionId id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const ::io::substrait::Extensions_FunctionId& id() const; - ::io::substrait::Extensions_FunctionId* release_id(); - ::io::substrait::Extensions_FunctionId* mutable_id(); - void set_allocated_id(::io::substrait::Extensions_FunctionId* id); - private: - const ::io::substrait::Extensions_FunctionId& _internal_id() const; - ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); - public: - void unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id); - ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); - // .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; bool has_upper_bound() const; private: @@ -3381,13 +3599,22 @@ class Expression_WindowFunction PROTOBUF_FINAL : ::io::substrait::Type* output_type); ::io::substrait::Type* unsafe_arena_release_output_type(); - // .io.substrait.Expression.AggregationPhase phase = 6; + // uint32 function_reference = 1; + void clear_function_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 function_reference() const; + void set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_function_reference() const; + void _internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // .io.substrait.AggregationPhase phase = 6; void clear_phase(); - ::io::substrait::Expression_AggregationPhase phase() const; - void set_phase(::io::substrait::Expression_AggregationPhase value); + ::io::substrait::AggregationPhase phase() const; + void set_phase(::io::substrait::AggregationPhase value); private: - ::io::substrait::Expression_AggregationPhase _internal_phase() const; - void _internal_set_phase(::io::substrait::Expression_AggregationPhase value); + ::io::substrait::AggregationPhase _internal_phase() const; + void _internal_set_phase(::io::substrait::AggregationPhase value); public: // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction) @@ -3398,36 +3625,36 @@ class Expression_WindowFunction PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > partitions_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField > sorts_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField > sorts_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > args_; - ::io::substrait::Extensions_FunctionId* id_; ::io::substrait::Expression_WindowFunction_Bound* upper_bound_; ::io::substrait::Expression_WindowFunction_Bound* lower_bound_; ::io::substrait::Type* output_type_; + ::PROTOBUF_NAMESPACE_ID::uint32 function_reference_; int phase_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_expression_2eproto; }; // ------------------------------------------------------------------- -class Expression_SortField PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.SortField) */ { +class Expression_IfThen_IfClause PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.IfThen.IfClause) */ { public: - inline Expression_SortField() : Expression_SortField(nullptr) {} - ~Expression_SortField() override; - explicit constexpr Expression_SortField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline Expression_IfThen_IfClause() : Expression_IfThen_IfClause(nullptr) {} + ~Expression_IfThen_IfClause() override; + explicit constexpr Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Expression_SortField(const Expression_SortField& from); - Expression_SortField(Expression_SortField&& from) noexcept - : Expression_SortField() { + Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from); + Expression_IfThen_IfClause(Expression_IfThen_IfClause&& from) noexcept + : Expression_IfThen_IfClause() { *this = ::std::move(from); } - inline Expression_SortField& operator=(const Expression_SortField& from) { + inline Expression_IfThen_IfClause& operator=(const Expression_IfThen_IfClause& from) { CopyFrom(from); return *this; } - inline Expression_SortField& operator=(Expression_SortField&& from) noexcept { + inline Expression_IfThen_IfClause& operator=(Expression_IfThen_IfClause&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -3445,26 +3672,20 @@ class Expression_SortField PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Expression_SortField& default_instance() { + static const Expression_IfThen_IfClause& default_instance() { return *internal_default_instance(); } - enum SortKindCase { - kDirection = 2, - kComparisonFunction = 3, - SORT_KIND_NOT_SET = 0, - }; - - static inline const Expression_SortField* internal_default_instance() { - return reinterpret_cast( - &_Expression_SortField_default_instance_); + static inline const Expression_IfThen_IfClause* internal_default_instance() { + return reinterpret_cast( + &_Expression_IfThen_IfClause_default_instance_); } static constexpr int kIndexInFileMessages = - 17; + 18; - friend void swap(Expression_SortField& a, Expression_SortField& b) { + friend void swap(Expression_IfThen_IfClause& a, Expression_IfThen_IfClause& b) { a.Swap(&b); } - inline void Swap(Expression_SortField* other) { + inline void Swap(Expression_IfThen_IfClause* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -3472,7 +3693,7 @@ class Expression_SortField PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Expression_SortField* other) { + void UnsafeArenaSwap(Expression_IfThen_IfClause* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3480,17 +3701,17 @@ class Expression_SortField PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Expression_SortField* New() const final { - return CreateMaybeMessage(nullptr); + inline Expression_IfThen_IfClause* New() const final { + return CreateMaybeMessage(nullptr); } - Expression_SortField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + Expression_IfThen_IfClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Expression_SortField& from); - void MergeFrom(const Expression_SortField& from); + void CopyFrom(const Expression_IfThen_IfClause& from); + void MergeFrom(const Expression_IfThen_IfClause& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -3504,13 +3725,13 @@ class Expression_SortField PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Expression_SortField* other); + void InternalSwap(Expression_IfThen_IfClause* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.SortField"; + return "io.substrait.Expression.IfThen.IfClause"; } protected: - explicit Expression_SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3520,146 +3741,80 @@ class Expression_SortField PROTOBUF_FINAL : // nested types ---------------------------------------------------- - typedef Expression_SortField_SortDirection SortDirection; - static constexpr SortDirection UNKNOWN = - Expression_SortField_SortDirection_UNKNOWN; - static constexpr SortDirection ASC_NULLS_FIRST = - Expression_SortField_SortDirection_ASC_NULLS_FIRST; - static constexpr SortDirection ASC_NULLS_LAST = - Expression_SortField_SortDirection_ASC_NULLS_LAST; - static constexpr SortDirection DESC_NULLS_FIRST = - Expression_SortField_SortDirection_DESC_NULLS_FIRST; - static constexpr SortDirection DESC_NULLS_LAST = - Expression_SortField_SortDirection_DESC_NULLS_LAST; - static constexpr SortDirection CLUSTERED = - Expression_SortField_SortDirection_CLUSTERED; - static inline bool SortDirection_IsValid(int value) { - return Expression_SortField_SortDirection_IsValid(value); - } - static constexpr SortDirection SortDirection_MIN = - Expression_SortField_SortDirection_SortDirection_MIN; - static constexpr SortDirection SortDirection_MAX = - Expression_SortField_SortDirection_SortDirection_MAX; - static constexpr int SortDirection_ARRAYSIZE = - Expression_SortField_SortDirection_SortDirection_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - SortDirection_descriptor() { - return Expression_SortField_SortDirection_descriptor(); - } - template - static inline const std::string& SortDirection_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function SortDirection_Name."); - return Expression_SortField_SortDirection_Name(enum_t_value); - } - static inline bool SortDirection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - SortDirection* value) { - return Expression_SortField_SortDirection_Parse(name, value); - } - // accessors ------------------------------------------------------- enum : int { - kExprFieldNumber = 1, - kDirectionFieldNumber = 2, - kComparisonFunctionFieldNumber = 3, + kIfFieldNumber = 1, + kThenFieldNumber = 2, }; - // .io.substrait.Expression expr = 1; - bool has_expr() const; - private: - bool _internal_has_expr() const; - public: - void clear_expr(); - const ::io::substrait::Expression& expr() const; - ::io::substrait::Expression* release_expr(); - ::io::substrait::Expression* mutable_expr(); - void set_allocated_expr(::io::substrait::Expression* expr); + // .io.substrait.Expression if = 1; + bool has_if_() const; private: - const ::io::substrait::Expression& _internal_expr() const; - ::io::substrait::Expression* _internal_mutable_expr(); + bool _internal_has_if_() const; public: - void unsafe_arena_set_allocated_expr( - ::io::substrait::Expression* expr); - ::io::substrait::Expression* unsafe_arena_release_expr(); - - // .io.substrait.Expression.SortField.SortDirection direction = 2; - bool has_direction() const; - private: - bool _internal_has_direction() const; - public: - void clear_direction(); - ::io::substrait::Expression_SortField_SortDirection direction() const; - void set_direction(::io::substrait::Expression_SortField_SortDirection value); + void clear_if_(); + const ::io::substrait::Expression& if_() const; + ::io::substrait::Expression* release_if_(); + ::io::substrait::Expression* mutable_if_(); + void set_allocated_if_(::io::substrait::Expression* if_); private: - ::io::substrait::Expression_SortField_SortDirection _internal_direction() const; - void _internal_set_direction(::io::substrait::Expression_SortField_SortDirection value); + const ::io::substrait::Expression& _internal_if_() const; + ::io::substrait::Expression* _internal_mutable_if_(); public: + void unsafe_arena_set_allocated_if_( + ::io::substrait::Expression* if_); + ::io::substrait::Expression* unsafe_arena_release_if_(); - // .io.substrait.Extensions.FunctionId comparison_function = 3; - bool has_comparison_function() const; + // .io.substrait.Expression then = 2; + bool has_then() const; private: - bool _internal_has_comparison_function() const; + bool _internal_has_then() const; public: - void clear_comparison_function(); - const ::io::substrait::Extensions_FunctionId& comparison_function() const; - ::io::substrait::Extensions_FunctionId* release_comparison_function(); - ::io::substrait::Extensions_FunctionId* mutable_comparison_function(); - void set_allocated_comparison_function(::io::substrait::Extensions_FunctionId* comparison_function); + void clear_then(); + const ::io::substrait::Expression& then() const; + ::io::substrait::Expression* release_then(); + ::io::substrait::Expression* mutable_then(); + void set_allocated_then(::io::substrait::Expression* then); private: - const ::io::substrait::Extensions_FunctionId& _internal_comparison_function() const; - ::io::substrait::Extensions_FunctionId* _internal_mutable_comparison_function(); + const ::io::substrait::Expression& _internal_then() const; + ::io::substrait::Expression* _internal_mutable_then(); public: - void unsafe_arena_set_allocated_comparison_function( - ::io::substrait::Extensions_FunctionId* comparison_function); - ::io::substrait::Extensions_FunctionId* unsafe_arena_release_comparison_function(); + void unsafe_arena_set_allocated_then( + ::io::substrait::Expression* then); + ::io::substrait::Expression* unsafe_arena_release_then(); - void clear_sort_kind(); - SortKindCase sort_kind_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.SortField) + // @@protoc_insertion_point(class_scope:io.substrait.Expression.IfThen.IfClause) private: class _Internal; - void set_has_direction(); - void set_has_comparison_function(); - - inline bool has_sort_kind() const; - inline void clear_has_sort_kind(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression* expr_; - union SortKindUnion { - constexpr SortKindUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - int direction_; - ::io::substrait::Extensions_FunctionId* comparison_function_; - } sort_kind_; + ::io::substrait::Expression* if__; + ::io::substrait::Expression* then_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; }; // ------------------------------------------------------------------- -class Expression_IfThen_IfClause PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.IfThen.IfClause) */ { +class Expression_IfThen PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.IfThen) */ { public: - inline Expression_IfThen_IfClause() : Expression_IfThen_IfClause(nullptr) {} - ~Expression_IfThen_IfClause() override; - explicit constexpr Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline Expression_IfThen() : Expression_IfThen(nullptr) {} + ~Expression_IfThen() override; + explicit constexpr Expression_IfThen(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from); - Expression_IfThen_IfClause(Expression_IfThen_IfClause&& from) noexcept - : Expression_IfThen_IfClause() { + Expression_IfThen(const Expression_IfThen& from); + Expression_IfThen(Expression_IfThen&& from) noexcept + : Expression_IfThen() { *this = ::std::move(from); } - inline Expression_IfThen_IfClause& operator=(const Expression_IfThen_IfClause& from) { + inline Expression_IfThen& operator=(const Expression_IfThen& from) { CopyFrom(from); return *this; } - inline Expression_IfThen_IfClause& operator=(Expression_IfThen_IfClause&& from) noexcept { + inline Expression_IfThen& operator=(Expression_IfThen&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -3677,20 +3832,20 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Expression_IfThen_IfClause& default_instance() { + static const Expression_IfThen& default_instance() { return *internal_default_instance(); } - static inline const Expression_IfThen_IfClause* internal_default_instance() { - return reinterpret_cast( - &_Expression_IfThen_IfClause_default_instance_); + static inline const Expression_IfThen* internal_default_instance() { + return reinterpret_cast( + &_Expression_IfThen_default_instance_); } static constexpr int kIndexInFileMessages = - 18; + 19; - friend void swap(Expression_IfThen_IfClause& a, Expression_IfThen_IfClause& b) { + friend void swap(Expression_IfThen& a, Expression_IfThen& b) { a.Swap(&b); } - inline void Swap(Expression_IfThen_IfClause* other) { + inline void Swap(Expression_IfThen* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -3698,7 +3853,7 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Expression_IfThen_IfClause* other) { + void UnsafeArenaSwap(Expression_IfThen* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3706,17 +3861,17 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Expression_IfThen_IfClause* New() const final { - return CreateMaybeMessage(nullptr); + inline Expression_IfThen* New() const final { + return CreateMaybeMessage(nullptr); } - Expression_IfThen_IfClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + Expression_IfThen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Expression_IfThen_IfClause& from); - void MergeFrom(const Expression_IfThen_IfClause& from); + void CopyFrom(const Expression_IfThen& from); + void MergeFrom(const Expression_IfThen& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -3730,13 +3885,13 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Expression_IfThen_IfClause* other); + void InternalSwap(Expression_IfThen* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.IfThen.IfClause"; + return "io.substrait.Expression.IfThen"; } protected: - explicit Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3746,80 +3901,82 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : // nested types ---------------------------------------------------- + typedef Expression_IfThen_IfClause IfClause; + // accessors ------------------------------------------------------- enum : int { - kIfFieldNumber = 1, - kThenFieldNumber = 2, + kIfsFieldNumber = 1, + kElseFieldNumber = 2, }; - // .io.substrait.Expression if = 1; - bool has_if_() const; + // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + int ifs_size() const; private: - bool _internal_has_if_() const; + int _internal_ifs_size() const; public: - void clear_if_(); - const ::io::substrait::Expression& if_() const; - ::io::substrait::Expression* release_if_(); - ::io::substrait::Expression* mutable_if_(); - void set_allocated_if_(::io::substrait::Expression* if_); + void clear_ifs(); + ::io::substrait::Expression_IfThen_IfClause* mutable_ifs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >* + mutable_ifs(); private: - const ::io::substrait::Expression& _internal_if_() const; - ::io::substrait::Expression* _internal_mutable_if_(); + const ::io::substrait::Expression_IfThen_IfClause& _internal_ifs(int index) const; + ::io::substrait::Expression_IfThen_IfClause* _internal_add_ifs(); public: - void unsafe_arena_set_allocated_if_( - ::io::substrait::Expression* if_); - ::io::substrait::Expression* unsafe_arena_release_if_(); + const ::io::substrait::Expression_IfThen_IfClause& ifs(int index) const; + ::io::substrait::Expression_IfThen_IfClause* add_ifs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >& + ifs() const; - // .io.substrait.Expression then = 2; - bool has_then() const; + // .io.substrait.Expression else = 2; + bool has_else_() const; private: - bool _internal_has_then() const; + bool _internal_has_else_() const; public: - void clear_then(); - const ::io::substrait::Expression& then() const; - ::io::substrait::Expression* release_then(); - ::io::substrait::Expression* mutable_then(); - void set_allocated_then(::io::substrait::Expression* then); + void clear_else_(); + const ::io::substrait::Expression& else_() const; + ::io::substrait::Expression* release_else_(); + ::io::substrait::Expression* mutable_else_(); + void set_allocated_else_(::io::substrait::Expression* else_); private: - const ::io::substrait::Expression& _internal_then() const; - ::io::substrait::Expression* _internal_mutable_then(); + const ::io::substrait::Expression& _internal_else_() const; + ::io::substrait::Expression* _internal_mutable_else_(); public: - void unsafe_arena_set_allocated_then( - ::io::substrait::Expression* then); - ::io::substrait::Expression* unsafe_arena_release_then(); + void unsafe_arena_set_allocated_else_( + ::io::substrait::Expression* else_); + ::io::substrait::Expression* unsafe_arena_release_else_(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(class_scope:io.substrait.Expression.IfThen) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression* if__; - ::io::substrait::Expression* then_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause > ifs_; + ::io::substrait::Expression* else__; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_expression_2eproto; }; // ------------------------------------------------------------------- -class Expression_IfThen PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.IfThen) */ { +class Expression_Cast PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Cast) */ { public: - inline Expression_IfThen() : Expression_IfThen(nullptr) {} - ~Expression_IfThen() override; - explicit constexpr Expression_IfThen(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline Expression_Cast() : Expression_Cast(nullptr) {} + ~Expression_Cast() override; + explicit constexpr Expression_Cast(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Expression_IfThen(const Expression_IfThen& from); - Expression_IfThen(Expression_IfThen&& from) noexcept - : Expression_IfThen() { + Expression_Cast(const Expression_Cast& from); + Expression_Cast(Expression_Cast&& from) noexcept + : Expression_Cast() { *this = ::std::move(from); } - inline Expression_IfThen& operator=(const Expression_IfThen& from) { + inline Expression_Cast& operator=(const Expression_Cast& from) { CopyFrom(from); return *this; } - inline Expression_IfThen& operator=(Expression_IfThen&& from) noexcept { + inline Expression_Cast& operator=(Expression_Cast&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -3837,20 +3994,20 @@ class Expression_IfThen PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Expression_IfThen& default_instance() { + static const Expression_Cast& default_instance() { return *internal_default_instance(); } - static inline const Expression_IfThen* internal_default_instance() { - return reinterpret_cast( - &_Expression_IfThen_default_instance_); + static inline const Expression_Cast* internal_default_instance() { + return reinterpret_cast( + &_Expression_Cast_default_instance_); } static constexpr int kIndexInFileMessages = - 19; + 20; - friend void swap(Expression_IfThen& a, Expression_IfThen& b) { + friend void swap(Expression_Cast& a, Expression_Cast& b) { a.Swap(&b); } - inline void Swap(Expression_IfThen* other) { + inline void Swap(Expression_Cast* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -3858,7 +4015,7 @@ class Expression_IfThen PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Expression_IfThen* other) { + void UnsafeArenaSwap(Expression_Cast* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3866,17 +4023,17 @@ class Expression_IfThen PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Expression_IfThen* New() const final { - return CreateMaybeMessage(nullptr); + inline Expression_Cast* New() const final { + return CreateMaybeMessage(nullptr); } - Expression_IfThen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + Expression_Cast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Expression_IfThen& from); - void MergeFrom(const Expression_IfThen& from); + void CopyFrom(const Expression_Cast& from); + void MergeFrom(const Expression_Cast& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -3890,13 +4047,13 @@ class Expression_IfThen PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Expression_IfThen* other); + void InternalSwap(Expression_Cast* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.IfThen"; + return "io.substrait.Expression.Cast"; } protected: - explicit Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3906,59 +4063,57 @@ class Expression_IfThen PROTOBUF_FINAL : // nested types ---------------------------------------------------- - typedef Expression_IfThen_IfClause IfClause; - // accessors ------------------------------------------------------- enum : int { - kIfsFieldNumber = 1, - kElseFieldNumber = 2, + kTypeFieldNumber = 1, + kInputFieldNumber = 2, }; - // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; - int ifs_size() const; + // .io.substrait.Type type = 1; + bool has_type() const; private: - int _internal_ifs_size() const; + bool _internal_has_type() const; public: - void clear_ifs(); - ::io::substrait::Expression_IfThen_IfClause* mutable_ifs(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >* - mutable_ifs(); + void clear_type(); + const ::io::substrait::Type& type() const; + ::io::substrait::Type* release_type(); + ::io::substrait::Type* mutable_type(); + void set_allocated_type(::io::substrait::Type* type); private: - const ::io::substrait::Expression_IfThen_IfClause& _internal_ifs(int index) const; - ::io::substrait::Expression_IfThen_IfClause* _internal_add_ifs(); + const ::io::substrait::Type& _internal_type() const; + ::io::substrait::Type* _internal_mutable_type(); public: - const ::io::substrait::Expression_IfThen_IfClause& ifs(int index) const; - ::io::substrait::Expression_IfThen_IfClause* add_ifs(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >& - ifs() const; + void unsafe_arena_set_allocated_type( + ::io::substrait::Type* type); + ::io::substrait::Type* unsafe_arena_release_type(); - // .io.substrait.Expression else = 2; - bool has_else_() const; + // .io.substrait.Expression input = 2; + bool has_input() const; private: - bool _internal_has_else_() const; + bool _internal_has_input() const; public: - void clear_else_(); - const ::io::substrait::Expression& else_() const; - ::io::substrait::Expression* release_else_(); - ::io::substrait::Expression* mutable_else_(); - void set_allocated_else_(::io::substrait::Expression* else_); + void clear_input(); + const ::io::substrait::Expression& input() const; + ::io::substrait::Expression* release_input(); + ::io::substrait::Expression* mutable_input(); + void set_allocated_input(::io::substrait::Expression* input); private: - const ::io::substrait::Expression& _internal_else_() const; - ::io::substrait::Expression* _internal_mutable_else_(); + const ::io::substrait::Expression& _internal_input() const; + ::io::substrait::Expression* _internal_mutable_input(); public: - void unsafe_arena_set_allocated_else_( - ::io::substrait::Expression* else_); - ::io::substrait::Expression* unsafe_arena_release_else_(); + void unsafe_arena_set_allocated_input( + ::io::substrait::Expression* input); + ::io::substrait::Expression* unsafe_arena_release_input(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(class_scope:io.substrait.Expression.Cast) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause > ifs_; - ::io::substrait::Expression* else__; + ::io::substrait::Type* type_; + ::io::substrait::Expression* input_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_expression_2eproto; }; @@ -4007,7 +4162,7 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : &_Expression_SwitchExpression_IfValue_default_instance_); } static constexpr int kIndexInFileMessages = - 20; + 21; friend void swap(Expression_SwitchExpression_IfValue& a, Expression_SwitchExpression_IfValue& b) { a.Swap(&b); @@ -4074,23 +4229,23 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : kIfFieldNumber = 1, kThenFieldNumber = 2, }; - // .io.substrait.Expression if = 1; + // .io.substrait.Expression.Literal if = 1; bool has_if_() const; private: bool _internal_has_if_() const; public: void clear_if_(); - const ::io::substrait::Expression& if_() const; - ::io::substrait::Expression* release_if_(); - ::io::substrait::Expression* mutable_if_(); - void set_allocated_if_(::io::substrait::Expression* if_); + const ::io::substrait::Expression_Literal& if_() const; + ::io::substrait::Expression_Literal* release_if_(); + ::io::substrait::Expression_Literal* mutable_if_(); + void set_allocated_if_(::io::substrait::Expression_Literal* if_); private: - const ::io::substrait::Expression& _internal_if_() const; - ::io::substrait::Expression* _internal_mutable_if_(); + const ::io::substrait::Expression_Literal& _internal_if_() const; + ::io::substrait::Expression_Literal* _internal_mutable_if_(); public: void unsafe_arena_set_allocated_if_( - ::io::substrait::Expression* if_); - ::io::substrait::Expression* unsafe_arena_release_if_(); + ::io::substrait::Expression_Literal* if_); + ::io::substrait::Expression_Literal* unsafe_arena_release_if_(); // .io.substrait.Expression then = 2; bool has_then() const; @@ -4117,7 +4272,7 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression* if__; + ::io::substrait::Expression_Literal* if__; ::io::substrait::Expression* then_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_expression_2eproto; @@ -4167,7 +4322,7 @@ class Expression_SwitchExpression PROTOBUF_FINAL : &_Expression_SwitchExpression_default_instance_); } static constexpr int kIndexInFileMessages = - 21; + 22; friend void swap(Expression_SwitchExpression& a, Expression_SwitchExpression& b) { a.Swap(&b); @@ -4329,7 +4484,7 @@ class Expression_SingularOrList PROTOBUF_FINAL : &_Expression_SingularOrList_default_instance_); } static constexpr int kIndexInFileMessages = - 22; + 23; friend void swap(Expression_SingularOrList& a, Expression_SingularOrList& b) { a.Swap(&b); @@ -4489,7 +4644,7 @@ class Expression_MultiOrList_Record PROTOBUF_FINAL : &_Expression_MultiOrList_Record_default_instance_); } static constexpr int kIndexInFileMessages = - 23; + 24; friend void swap(Expression_MultiOrList_Record& a, Expression_MultiOrList_Record& b) { a.Swap(&b); @@ -4629,7 +4784,7 @@ class Expression_MultiOrList PROTOBUF_FINAL : &_Expression_MultiOrList_default_instance_); } static constexpr int kIndexInFileMessages = - 24; + 25; friend void swap(Expression_MultiOrList& a, Expression_MultiOrList& b) { a.Swap(&b); @@ -4791,7 +4946,7 @@ class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : &_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_); } static constexpr int kIndexInFileMessages = - 25; + 26; friend void swap(Expression_EmbeddedFunction_PythonPickleFunction& a, Expression_EmbeddedFunction_PythonPickleFunction& b) { a.Swap(&b); @@ -4953,7 +5108,7 @@ class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : &_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_); } static constexpr int kIndexInFileMessages = - 26; + 27; friend void swap(Expression_EmbeddedFunction_WebAssemblyFunction& a, Expression_EmbeddedFunction_WebAssemblyFunction& b) { a.Swap(&b); @@ -5121,7 +5276,7 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : &_Expression_EmbeddedFunction_default_instance_); } static constexpr int kIndexInFileMessages = - 27; + 28; friend void swap(Expression_EmbeddedFunction& a, Expression_EmbeddedFunction& b) { a.Swap(&b); @@ -5294,24 +5449,24 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression) */ { +class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.ReferenceSegment.MapKey) */ { public: - inline Expression() : Expression(nullptr) {} - ~Expression() override; - explicit constexpr Expression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline Expression_ReferenceSegment_MapKey() : Expression_ReferenceSegment_MapKey(nullptr) {} + ~Expression_ReferenceSegment_MapKey() override; + explicit constexpr Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Expression(const Expression& from); - Expression(Expression&& from) noexcept - : Expression() { + Expression_ReferenceSegment_MapKey(const Expression_ReferenceSegment_MapKey& from); + Expression_ReferenceSegment_MapKey(Expression_ReferenceSegment_MapKey&& from) noexcept + : Expression_ReferenceSegment_MapKey() { *this = ::std::move(from); } - inline Expression& operator=(const Expression& from) { + inline Expression_ReferenceSegment_MapKey& operator=(const Expression_ReferenceSegment_MapKey& from) { CopyFrom(from); return *this; } - inline Expression& operator=(Expression&& from) noexcept { + inline Expression_ReferenceSegment_MapKey& operator=(Expression_ReferenceSegment_MapKey&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -5329,33 +5484,20 @@ class Expression PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Expression& default_instance() { + static const Expression_ReferenceSegment_MapKey& default_instance() { return *internal_default_instance(); } - enum RexTypeCase { - kLiteral = 1, - kSelection = 2, - kScalarFunction = 3, - kWindowFunction = 5, - kIfThen = 6, - kSwitchExpression = 7, - kSingularOrList = 8, - kMultiOrList = 9, - kEnum = 10, - REX_TYPE_NOT_SET = 0, - }; - - static inline const Expression* internal_default_instance() { - return reinterpret_cast( - &_Expression_default_instance_); + static inline const Expression_ReferenceSegment_MapKey* internal_default_instance() { + return reinterpret_cast( + &_Expression_ReferenceSegment_MapKey_default_instance_); } static constexpr int kIndexInFileMessages = - 28; + 29; - friend void swap(Expression& a, Expression& b) { + friend void swap(Expression_ReferenceSegment_MapKey& a, Expression_ReferenceSegment_MapKey& b) { a.Swap(&b); } - inline void Swap(Expression* other) { + inline void Swap(Expression_ReferenceSegment_MapKey* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -5363,7 +5505,7 @@ class Expression PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Expression* other) { + void UnsafeArenaSwap(Expression_ReferenceSegment_MapKey* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -5371,17 +5513,17 @@ class Expression PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Expression* New() const final { - return CreateMaybeMessage(nullptr); + inline Expression_ReferenceSegment_MapKey* New() const final { + return CreateMaybeMessage(nullptr); } - Expression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + Expression_ReferenceSegment_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Expression& from); - void MergeFrom(const Expression& from); + void CopyFrom(const Expression_ReferenceSegment_MapKey& from); + void MergeFrom(const Expression_ReferenceSegment_MapKey& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -5395,13 +5537,13 @@ class Expression PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Expression* other); + void InternalSwap(Expression_ReferenceSegment_MapKey* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression"; + return "io.substrait.Expression.ReferenceSegment.MapKey"; } protected: - explicit Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -5411,5761 +5553,11510 @@ class Expression PROTOBUF_FINAL : // nested types ---------------------------------------------------- - typedef Expression_Enum Enum; - typedef Expression_Literal Literal; - typedef Expression_ScalarFunction ScalarFunction; - typedef Expression_AggregateFunction AggregateFunction; - typedef Expression_WindowFunction WindowFunction; - typedef Expression_SortField SortField; - typedef Expression_IfThen IfThen; - typedef Expression_SwitchExpression SwitchExpression; - typedef Expression_SingularOrList SingularOrList; - typedef Expression_MultiOrList MultiOrList; - typedef Expression_EmbeddedFunction EmbeddedFunction; - - typedef Expression_AggregationPhase AggregationPhase; - static constexpr AggregationPhase UNKNOWN = - Expression_AggregationPhase_UNKNOWN; - static constexpr AggregationPhase INITIAL_TO_INTERMEDIATE = - Expression_AggregationPhase_INITIAL_TO_INTERMEDIATE; - static constexpr AggregationPhase INTERMEDIATE_TO_INTERMEDIATE = - Expression_AggregationPhase_INTERMEDIATE_TO_INTERMEDIATE; - static constexpr AggregationPhase INITIAL_TO_RESULT = - Expression_AggregationPhase_INITIAL_TO_RESULT; - static constexpr AggregationPhase INTERMEDIATE_TO_RESULT = - Expression_AggregationPhase_INTERMEDIATE_TO_RESULT; - static inline bool AggregationPhase_IsValid(int value) { - return Expression_AggregationPhase_IsValid(value); - } - static constexpr AggregationPhase AggregationPhase_MIN = - Expression_AggregationPhase_AggregationPhase_MIN; - static constexpr AggregationPhase AggregationPhase_MAX = - Expression_AggregationPhase_AggregationPhase_MAX; - static constexpr int AggregationPhase_ARRAYSIZE = - Expression_AggregationPhase_AggregationPhase_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - AggregationPhase_descriptor() { - return Expression_AggregationPhase_descriptor(); - } - template - static inline const std::string& AggregationPhase_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function AggregationPhase_Name."); - return Expression_AggregationPhase_Name(enum_t_value); - } - static inline bool AggregationPhase_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - AggregationPhase* value) { - return Expression_AggregationPhase_Parse(name, value); - } - // accessors ------------------------------------------------------- enum : int { - kLiteralFieldNumber = 1, - kSelectionFieldNumber = 2, - kScalarFunctionFieldNumber = 3, - kWindowFunctionFieldNumber = 5, - kIfThenFieldNumber = 6, - kSwitchExpressionFieldNumber = 7, - kSingularOrListFieldNumber = 8, - kMultiOrListFieldNumber = 9, - kEnumFieldNumber = 10, + kMapKeyFieldNumber = 1, + kChildFieldNumber = 2, }; - // .io.substrait.Expression.Literal literal = 1; - bool has_literal() const; + // .io.substrait.Expression.Literal map_key = 1; + bool has_map_key() const; private: - bool _internal_has_literal() const; + bool _internal_has_map_key() const; public: - void clear_literal(); - const ::io::substrait::Expression_Literal& literal() const; - ::io::substrait::Expression_Literal* release_literal(); - ::io::substrait::Expression_Literal* mutable_literal(); - void set_allocated_literal(::io::substrait::Expression_Literal* literal); + void clear_map_key(); + const ::io::substrait::Expression_Literal& map_key() const; + ::io::substrait::Expression_Literal* release_map_key(); + ::io::substrait::Expression_Literal* mutable_map_key(); + void set_allocated_map_key(::io::substrait::Expression_Literal* map_key); private: - const ::io::substrait::Expression_Literal& _internal_literal() const; - ::io::substrait::Expression_Literal* _internal_mutable_literal(); + const ::io::substrait::Expression_Literal& _internal_map_key() const; + ::io::substrait::Expression_Literal* _internal_mutable_map_key(); public: - void unsafe_arena_set_allocated_literal( - ::io::substrait::Expression_Literal* literal); - ::io::substrait::Expression_Literal* unsafe_arena_release_literal(); + void unsafe_arena_set_allocated_map_key( + ::io::substrait::Expression_Literal* map_key); + ::io::substrait::Expression_Literal* unsafe_arena_release_map_key(); - // .io.substrait.FieldReference selection = 2; - bool has_selection() const; + // .io.substrait.Expression.ReferenceSegment child = 2; + bool has_child() const; private: - bool _internal_has_selection() const; + bool _internal_has_child() const; public: - void clear_selection(); - const ::io::substrait::FieldReference& selection() const; - ::io::substrait::FieldReference* release_selection(); - ::io::substrait::FieldReference* mutable_selection(); - void set_allocated_selection(::io::substrait::FieldReference* selection); + void clear_child(); + const ::io::substrait::Expression_ReferenceSegment& child() const; + ::io::substrait::Expression_ReferenceSegment* release_child(); + ::io::substrait::Expression_ReferenceSegment* mutable_child(); + void set_allocated_child(::io::substrait::Expression_ReferenceSegment* child); private: - const ::io::substrait::FieldReference& _internal_selection() const; - ::io::substrait::FieldReference* _internal_mutable_selection(); + const ::io::substrait::Expression_ReferenceSegment& _internal_child() const; + ::io::substrait::Expression_ReferenceSegment* _internal_mutable_child(); public: - void unsafe_arena_set_allocated_selection( - ::io::substrait::FieldReference* selection); - ::io::substrait::FieldReference* unsafe_arena_release_selection(); + void unsafe_arena_set_allocated_child( + ::io::substrait::Expression_ReferenceSegment* child); + ::io::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); - // .io.substrait.Expression.ScalarFunction scalar_function = 3; - bool has_scalar_function() const; - private: - bool _internal_has_scalar_function() const; - public: - void clear_scalar_function(); - const ::io::substrait::Expression_ScalarFunction& scalar_function() const; - ::io::substrait::Expression_ScalarFunction* release_scalar_function(); - ::io::substrait::Expression_ScalarFunction* mutable_scalar_function(); - void set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function); - private: - const ::io::substrait::Expression_ScalarFunction& _internal_scalar_function() const; - ::io::substrait::Expression_ScalarFunction* _internal_mutable_scalar_function(); - public: - void unsafe_arena_set_allocated_scalar_function( - ::io::substrait::Expression_ScalarFunction* scalar_function); - ::io::substrait::Expression_ScalarFunction* unsafe_arena_release_scalar_function(); + // @@protoc_insertion_point(class_scope:io.substrait.Expression.ReferenceSegment.MapKey) + private: + class _Internal; - // .io.substrait.Expression.WindowFunction window_function = 5; - bool has_window_function() const; - private: - bool _internal_has_window_function() const; - public: - void clear_window_function(); - const ::io::substrait::Expression_WindowFunction& window_function() const; - ::io::substrait::Expression_WindowFunction* release_window_function(); - ::io::substrait::Expression_WindowFunction* mutable_window_function(); - void set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function); - private: - const ::io::substrait::Expression_WindowFunction& _internal_window_function() const; - ::io::substrait::Expression_WindowFunction* _internal_mutable_window_function(); - public: - void unsafe_arena_set_allocated_window_function( - ::io::substrait::Expression_WindowFunction* window_function); - ::io::substrait::Expression_WindowFunction* unsafe_arena_release_window_function(); + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression_Literal* map_key_; + ::io::substrait::Expression_ReferenceSegment* child_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- - // .io.substrait.Expression.IfThen if_then = 6; - bool has_if_then() const; - private: - bool _internal_has_if_then() const; - public: - void clear_if_then(); - const ::io::substrait::Expression_IfThen& if_then() const; - ::io::substrait::Expression_IfThen* release_if_then(); - ::io::substrait::Expression_IfThen* mutable_if_then(); - void set_allocated_if_then(::io::substrait::Expression_IfThen* if_then); - private: - const ::io::substrait::Expression_IfThen& _internal_if_then() const; - ::io::substrait::Expression_IfThen* _internal_mutable_if_then(); - public: - void unsafe_arena_set_allocated_if_then( - ::io::substrait::Expression_IfThen* if_then); - ::io::substrait::Expression_IfThen* unsafe_arena_release_if_then(); +class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.ReferenceSegment.StructField) */ { + public: + inline Expression_ReferenceSegment_StructField() : Expression_ReferenceSegment_StructField(nullptr) {} + ~Expression_ReferenceSegment_StructField() override; + explicit constexpr Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_ReferenceSegment_StructField(const Expression_ReferenceSegment_StructField& from); + Expression_ReferenceSegment_StructField(Expression_ReferenceSegment_StructField&& from) noexcept + : Expression_ReferenceSegment_StructField() { + *this = ::std::move(from); + } + + inline Expression_ReferenceSegment_StructField& operator=(const Expression_ReferenceSegment_StructField& from) { + CopyFrom(from); + return *this; + } + inline Expression_ReferenceSegment_StructField& operator=(Expression_ReferenceSegment_StructField&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_ReferenceSegment_StructField& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_ReferenceSegment_StructField* internal_default_instance() { + return reinterpret_cast( + &_Expression_ReferenceSegment_StructField_default_instance_); + } + static constexpr int kIndexInFileMessages = + 30; + + friend void swap(Expression_ReferenceSegment_StructField& a, Expression_ReferenceSegment_StructField& b) { + a.Swap(&b); + } + inline void Swap(Expression_ReferenceSegment_StructField* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_ReferenceSegment_StructField* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_ReferenceSegment_StructField* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_ReferenceSegment_StructField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_ReferenceSegment_StructField& from); + void MergeFrom(const Expression_ReferenceSegment_StructField& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } - // .io.substrait.Expression.SwitchExpression switch_expression = 7; - bool has_switch_expression() const; private: - bool _internal_has_switch_expression() const; - public: - void clear_switch_expression(); - const ::io::substrait::Expression_SwitchExpression& switch_expression() const; - ::io::substrait::Expression_SwitchExpression* release_switch_expression(); - ::io::substrait::Expression_SwitchExpression* mutable_switch_expression(); - void set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression); + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_ReferenceSegment_StructField* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.ReferenceSegment.StructField"; + } + protected: + explicit Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: - const ::io::substrait::Expression_SwitchExpression& _internal_switch_expression() const; - ::io::substrait::Expression_SwitchExpression* _internal_mutable_switch_expression(); + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: - void unsafe_arena_set_allocated_switch_expression( - ::io::substrait::Expression_SwitchExpression* switch_expression); - ::io::substrait::Expression_SwitchExpression* unsafe_arena_release_switch_expression(); - // .io.substrait.Expression.SingularOrList singular_or_list = 8; - bool has_singular_or_list() const; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChildFieldNumber = 2, + kFieldFieldNumber = 1, + }; + // .io.substrait.Expression.ReferenceSegment child = 2; + bool has_child() const; private: - bool _internal_has_singular_or_list() const; + bool _internal_has_child() const; public: - void clear_singular_or_list(); - const ::io::substrait::Expression_SingularOrList& singular_or_list() const; - ::io::substrait::Expression_SingularOrList* release_singular_or_list(); - ::io::substrait::Expression_SingularOrList* mutable_singular_or_list(); - void set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list); + void clear_child(); + const ::io::substrait::Expression_ReferenceSegment& child() const; + ::io::substrait::Expression_ReferenceSegment* release_child(); + ::io::substrait::Expression_ReferenceSegment* mutable_child(); + void set_allocated_child(::io::substrait::Expression_ReferenceSegment* child); private: - const ::io::substrait::Expression_SingularOrList& _internal_singular_or_list() const; - ::io::substrait::Expression_SingularOrList* _internal_mutable_singular_or_list(); + const ::io::substrait::Expression_ReferenceSegment& _internal_child() const; + ::io::substrait::Expression_ReferenceSegment* _internal_mutable_child(); public: - void unsafe_arena_set_allocated_singular_or_list( - ::io::substrait::Expression_SingularOrList* singular_or_list); - ::io::substrait::Expression_SingularOrList* unsafe_arena_release_singular_or_list(); - - // .io.substrait.Expression.MultiOrList multi_or_list = 9; - bool has_multi_or_list() const; + void unsafe_arena_set_allocated_child( + ::io::substrait::Expression_ReferenceSegment* child); + ::io::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); + + // int32 field = 1; + void clear_field(); + ::PROTOBUF_NAMESPACE_ID::int32 field() const; + void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); private: - bool _internal_has_multi_or_list() const; + ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; + void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); public: - void clear_multi_or_list(); - const ::io::substrait::Expression_MultiOrList& multi_or_list() const; - ::io::substrait::Expression_MultiOrList* release_multi_or_list(); - ::io::substrait::Expression_MultiOrList* mutable_multi_or_list(); - void set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list); - private: - const ::io::substrait::Expression_MultiOrList& _internal_multi_or_list() const; - ::io::substrait::Expression_MultiOrList* _internal_mutable_multi_or_list(); + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.ReferenceSegment.StructField) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression_ReferenceSegment* child_; + ::PROTOBUF_NAMESPACE_ID::int32 field_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.ReferenceSegment.ListElement) */ { + public: + inline Expression_ReferenceSegment_ListElement() : Expression_ReferenceSegment_ListElement(nullptr) {} + ~Expression_ReferenceSegment_ListElement() override; + explicit constexpr Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_ReferenceSegment_ListElement(const Expression_ReferenceSegment_ListElement& from); + Expression_ReferenceSegment_ListElement(Expression_ReferenceSegment_ListElement&& from) noexcept + : Expression_ReferenceSegment_ListElement() { + *this = ::std::move(from); + } + + inline Expression_ReferenceSegment_ListElement& operator=(const Expression_ReferenceSegment_ListElement& from) { + CopyFrom(from); + return *this; + } + inline Expression_ReferenceSegment_ListElement& operator=(Expression_ReferenceSegment_ListElement&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_ReferenceSegment_ListElement& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_ReferenceSegment_ListElement* internal_default_instance() { + return reinterpret_cast( + &_Expression_ReferenceSegment_ListElement_default_instance_); + } + static constexpr int kIndexInFileMessages = + 31; + + friend void swap(Expression_ReferenceSegment_ListElement& a, Expression_ReferenceSegment_ListElement& b) { + a.Swap(&b); + } + inline void Swap(Expression_ReferenceSegment_ListElement* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_ReferenceSegment_ListElement* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_ReferenceSegment_ListElement* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_ReferenceSegment_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_ReferenceSegment_ListElement& from); + void MergeFrom(const Expression_ReferenceSegment_ListElement& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_ReferenceSegment_ListElement* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.ReferenceSegment.ListElement"; + } + protected: + explicit Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: - void unsafe_arena_set_allocated_multi_or_list( - ::io::substrait::Expression_MultiOrList* multi_or_list); - ::io::substrait::Expression_MultiOrList* unsafe_arena_release_multi_or_list(); - // .io.substrait.Expression.Enum enum = 10; - bool has_enum_() const; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChildFieldNumber = 2, + kOffsetFieldNumber = 1, + }; + // .io.substrait.Expression.ReferenceSegment child = 2; + bool has_child() const; private: - bool _internal_has_enum_() const; + bool _internal_has_child() const; public: - void clear_enum_(); - const ::io::substrait::Expression_Enum& enum_() const; - ::io::substrait::Expression_Enum* release_enum_(); - ::io::substrait::Expression_Enum* mutable_enum_(); - void set_allocated_enum_(::io::substrait::Expression_Enum* enum_); + void clear_child(); + const ::io::substrait::Expression_ReferenceSegment& child() const; + ::io::substrait::Expression_ReferenceSegment* release_child(); + ::io::substrait::Expression_ReferenceSegment* mutable_child(); + void set_allocated_child(::io::substrait::Expression_ReferenceSegment* child); private: - const ::io::substrait::Expression_Enum& _internal_enum_() const; - ::io::substrait::Expression_Enum* _internal_mutable_enum_(); + const ::io::substrait::Expression_ReferenceSegment& _internal_child() const; + ::io::substrait::Expression_ReferenceSegment* _internal_mutable_child(); public: - void unsafe_arena_set_allocated_enum_( - ::io::substrait::Expression_Enum* enum_); - ::io::substrait::Expression_Enum* unsafe_arena_release_enum_(); + void unsafe_arena_set_allocated_child( + ::io::substrait::Expression_ReferenceSegment* child); + ::io::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); - void clear_rex_type(); - RexTypeCase rex_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression) + // int32 offset = 1; + void clear_offset(); + ::PROTOBUF_NAMESPACE_ID::int32 offset() const; + void set_offset(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_offset() const; + void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.ReferenceSegment.ListElement) private: class _Internal; - void set_has_literal(); - void set_has_selection(); - void set_has_scalar_function(); - void set_has_window_function(); - void set_has_if_then(); - void set_has_switch_expression(); - void set_has_singular_or_list(); - void set_has_multi_or_list(); - void set_has_enum_(); - inline bool has_rex_type() const; - inline void clear_has_rex_type(); + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression_ReferenceSegment* child_; + ::PROTOBUF_NAMESPACE_ID::int32 offset_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_ReferenceSegment PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.ReferenceSegment) */ { + public: + inline Expression_ReferenceSegment() : Expression_ReferenceSegment(nullptr) {} + ~Expression_ReferenceSegment() override; + explicit constexpr Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_ReferenceSegment(const Expression_ReferenceSegment& from); + Expression_ReferenceSegment(Expression_ReferenceSegment&& from) noexcept + : Expression_ReferenceSegment() { + *this = ::std::move(from); + } + + inline Expression_ReferenceSegment& operator=(const Expression_ReferenceSegment& from) { + CopyFrom(from); + return *this; + } + inline Expression_ReferenceSegment& operator=(Expression_ReferenceSegment&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_ReferenceSegment& default_instance() { + return *internal_default_instance(); + } + enum ReferenceTypeCase { + kMapKey = 1, + kStructField = 2, + kListElement = 3, + REFERENCE_TYPE_NOT_SET = 0, + }; + + static inline const Expression_ReferenceSegment* internal_default_instance() { + return reinterpret_cast( + &_Expression_ReferenceSegment_default_instance_); + } + static constexpr int kIndexInFileMessages = + 32; + + friend void swap(Expression_ReferenceSegment& a, Expression_ReferenceSegment& b) { + a.Swap(&b); + } + inline void Swap(Expression_ReferenceSegment* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_ReferenceSegment* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_ReferenceSegment* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_ReferenceSegment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_ReferenceSegment& from); + void MergeFrom(const Expression_ReferenceSegment& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_ReferenceSegment* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.ReferenceSegment"; + } + protected: + explicit Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_ReferenceSegment_MapKey MapKey; + typedef Expression_ReferenceSegment_StructField StructField; + typedef Expression_ReferenceSegment_ListElement ListElement; + + // accessors ------------------------------------------------------- + + enum : int { + kMapKeyFieldNumber = 1, + kStructFieldFieldNumber = 2, + kListElementFieldNumber = 3, + }; + // .io.substrait.Expression.ReferenceSegment.MapKey map_key = 1; + bool has_map_key() const; + private: + bool _internal_has_map_key() const; + public: + void clear_map_key(); + const ::io::substrait::Expression_ReferenceSegment_MapKey& map_key() const; + ::io::substrait::Expression_ReferenceSegment_MapKey* release_map_key(); + ::io::substrait::Expression_ReferenceSegment_MapKey* mutable_map_key(); + void set_allocated_map_key(::io::substrait::Expression_ReferenceSegment_MapKey* map_key); + private: + const ::io::substrait::Expression_ReferenceSegment_MapKey& _internal_map_key() const; + ::io::substrait::Expression_ReferenceSegment_MapKey* _internal_mutable_map_key(); + public: + void unsafe_arena_set_allocated_map_key( + ::io::substrait::Expression_ReferenceSegment_MapKey* map_key); + ::io::substrait::Expression_ReferenceSegment_MapKey* unsafe_arena_release_map_key(); + + // .io.substrait.Expression.ReferenceSegment.StructField struct_field = 2; + bool has_struct_field() const; + private: + bool _internal_has_struct_field() const; + public: + void clear_struct_field(); + const ::io::substrait::Expression_ReferenceSegment_StructField& struct_field() const; + ::io::substrait::Expression_ReferenceSegment_StructField* release_struct_field(); + ::io::substrait::Expression_ReferenceSegment_StructField* mutable_struct_field(); + void set_allocated_struct_field(::io::substrait::Expression_ReferenceSegment_StructField* struct_field); + private: + const ::io::substrait::Expression_ReferenceSegment_StructField& _internal_struct_field() const; + ::io::substrait::Expression_ReferenceSegment_StructField* _internal_mutable_struct_field(); + public: + void unsafe_arena_set_allocated_struct_field( + ::io::substrait::Expression_ReferenceSegment_StructField* struct_field); + ::io::substrait::Expression_ReferenceSegment_StructField* unsafe_arena_release_struct_field(); + + // .io.substrait.Expression.ReferenceSegment.ListElement list_element = 3; + bool has_list_element() const; + private: + bool _internal_has_list_element() const; + public: + void clear_list_element(); + const ::io::substrait::Expression_ReferenceSegment_ListElement& list_element() const; + ::io::substrait::Expression_ReferenceSegment_ListElement* release_list_element(); + ::io::substrait::Expression_ReferenceSegment_ListElement* mutable_list_element(); + void set_allocated_list_element(::io::substrait::Expression_ReferenceSegment_ListElement* list_element); + private: + const ::io::substrait::Expression_ReferenceSegment_ListElement& _internal_list_element() const; + ::io::substrait::Expression_ReferenceSegment_ListElement* _internal_mutable_list_element(); + public: + void unsafe_arena_set_allocated_list_element( + ::io::substrait::Expression_ReferenceSegment_ListElement* list_element); + ::io::substrait::Expression_ReferenceSegment_ListElement* unsafe_arena_release_list_element(); + + void clear_reference_type(); + ReferenceTypeCase reference_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression.ReferenceSegment) + private: + class _Internal; + void set_has_map_key(); + void set_has_struct_field(); + void set_has_list_element(); + + inline bool has_reference_type() const; + inline void clear_has_reference_type(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - union RexTypeUnion { - constexpr RexTypeUnion() : _constinit_{} {} + union ReferenceTypeUnion { + constexpr ReferenceTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Expression_Literal* literal_; - ::io::substrait::FieldReference* selection_; - ::io::substrait::Expression_ScalarFunction* scalar_function_; - ::io::substrait::Expression_WindowFunction* window_function_; - ::io::substrait::Expression_IfThen* if_then_; - ::io::substrait::Expression_SwitchExpression* switch_expression_; - ::io::substrait::Expression_SingularOrList* singular_or_list_; - ::io::substrait::Expression_MultiOrList* multi_or_list_; - ::io::substrait::Expression_Enum* enum__; - } rex_type_; + ::io::substrait::Expression_ReferenceSegment_MapKey* map_key_; + ::io::substrait::Expression_ReferenceSegment_StructField* struct_field_; + ::io::substrait::Expression_ReferenceSegment_ListElement* list_element_; + } reference_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; friend struct ::TableStruct_expression_2eproto; }; -// =================================================================== +// ------------------------------------------------------------------- +class Expression_MaskExpression_Select PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.Select) */ { + public: + inline Expression_MaskExpression_Select() : Expression_MaskExpression_Select(nullptr) {} + ~Expression_MaskExpression_Select() override; + explicit constexpr Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); -// =================================================================== + Expression_MaskExpression_Select(const Expression_MaskExpression_Select& from); + Expression_MaskExpression_Select(Expression_MaskExpression_Select&& from) noexcept + : Expression_MaskExpression_Select() { + *this = ::std::move(from); + } -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// Expression_Enum_Empty + inline Expression_MaskExpression_Select& operator=(const Expression_MaskExpression_Select& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression_Select& operator=(Expression_MaskExpression_Select&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression_Select& default_instance() { + return *internal_default_instance(); + } + enum TypeCase { + kStruct = 1, + kList = 2, + kMap = 3, + TYPE_NOT_SET = 0, + }; + + static inline const Expression_MaskExpression_Select* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_Select_default_instance_); + } + static constexpr int kIndexInFileMessages = + 33; + + friend void swap(Expression_MaskExpression_Select& a, Expression_MaskExpression_Select& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression_Select* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression_Select* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression_Select* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression_Select* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression_Select& from); + void MergeFrom(const Expression_MaskExpression_Select& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression_Select* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression.Select"; + } + protected: + explicit Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStructFieldNumber = 1, + kListFieldNumber = 2, + kMapFieldNumber = 3, + }; + // .io.substrait.Expression.MaskExpression.StructSelect struct = 1; + bool has_struct_() const; + private: + bool _internal_has_struct_() const; + public: + void clear_struct_(); + const ::io::substrait::Expression_MaskExpression_StructSelect& struct_() const; + ::io::substrait::Expression_MaskExpression_StructSelect* release_struct_(); + ::io::substrait::Expression_MaskExpression_StructSelect* mutable_struct_(); + void set_allocated_struct_(::io::substrait::Expression_MaskExpression_StructSelect* struct_); + private: + const ::io::substrait::Expression_MaskExpression_StructSelect& _internal_struct_() const; + ::io::substrait::Expression_MaskExpression_StructSelect* _internal_mutable_struct_(); + public: + void unsafe_arena_set_allocated_struct_( + ::io::substrait::Expression_MaskExpression_StructSelect* struct_); + ::io::substrait::Expression_MaskExpression_StructSelect* unsafe_arena_release_struct_(); + + // .io.substrait.Expression.MaskExpression.ListSelect list = 2; + bool has_list() const; + private: + bool _internal_has_list() const; + public: + void clear_list(); + const ::io::substrait::Expression_MaskExpression_ListSelect& list() const; + ::io::substrait::Expression_MaskExpression_ListSelect* release_list(); + ::io::substrait::Expression_MaskExpression_ListSelect* mutable_list(); + void set_allocated_list(::io::substrait::Expression_MaskExpression_ListSelect* list); + private: + const ::io::substrait::Expression_MaskExpression_ListSelect& _internal_list() const; + ::io::substrait::Expression_MaskExpression_ListSelect* _internal_mutable_list(); + public: + void unsafe_arena_set_allocated_list( + ::io::substrait::Expression_MaskExpression_ListSelect* list); + ::io::substrait::Expression_MaskExpression_ListSelect* unsafe_arena_release_list(); + + // .io.substrait.Expression.MaskExpression.MapSelect map = 3; + bool has_map() const; + private: + bool _internal_has_map() const; + public: + void clear_map(); + const ::io::substrait::Expression_MaskExpression_MapSelect& map() const; + ::io::substrait::Expression_MaskExpression_MapSelect* release_map(); + ::io::substrait::Expression_MaskExpression_MapSelect* mutable_map(); + void set_allocated_map(::io::substrait::Expression_MaskExpression_MapSelect* map); + private: + const ::io::substrait::Expression_MaskExpression_MapSelect& _internal_map() const; + ::io::substrait::Expression_MaskExpression_MapSelect* _internal_mutable_map(); + public: + void unsafe_arena_set_allocated_map( + ::io::substrait::Expression_MaskExpression_MapSelect* map); + ::io::substrait::Expression_MaskExpression_MapSelect* unsafe_arena_release_map(); + + void clear_type(); + TypeCase type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.Select) + private: + class _Internal; + void set_has_struct_(); + void set_has_list(); + void set_has_map(); + + inline bool has_type() const; + inline void clear_has_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union TypeUnion { + constexpr TypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Expression_MaskExpression_StructSelect* struct__; + ::io::substrait::Expression_MaskExpression_ListSelect* list_; + ::io::substrait::Expression_MaskExpression_MapSelect* map_; + } type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MaskExpression_StructSelect PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.StructSelect) */ { + public: + inline Expression_MaskExpression_StructSelect() : Expression_MaskExpression_StructSelect(nullptr) {} + ~Expression_MaskExpression_StructSelect() override; + explicit constexpr Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MaskExpression_StructSelect(const Expression_MaskExpression_StructSelect& from); + Expression_MaskExpression_StructSelect(Expression_MaskExpression_StructSelect&& from) noexcept + : Expression_MaskExpression_StructSelect() { + *this = ::std::move(from); + } + + inline Expression_MaskExpression_StructSelect& operator=(const Expression_MaskExpression_StructSelect& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression_StructSelect& operator=(Expression_MaskExpression_StructSelect&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression_StructSelect& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_MaskExpression_StructSelect* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_StructSelect_default_instance_); + } + static constexpr int kIndexInFileMessages = + 34; + + friend void swap(Expression_MaskExpression_StructSelect& a, Expression_MaskExpression_StructSelect& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression_StructSelect* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression_StructSelect* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression_StructSelect* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression_StructSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression_StructSelect& from); + void MergeFrom(const Expression_MaskExpression_StructSelect& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression_StructSelect* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression.StructSelect"; + } + protected: + explicit Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStructItemsFieldNumber = 1, + }; + // repeated .io.substrait.Expression.MaskExpression.StructItem struct_items = 1; + int struct_items_size() const; + private: + int _internal_struct_items_size() const; + public: + void clear_struct_items(); + ::io::substrait::Expression_MaskExpression_StructItem* mutable_struct_items(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_StructItem >* + mutable_struct_items(); + private: + const ::io::substrait::Expression_MaskExpression_StructItem& _internal_struct_items(int index) const; + ::io::substrait::Expression_MaskExpression_StructItem* _internal_add_struct_items(); + public: + const ::io::substrait::Expression_MaskExpression_StructItem& struct_items(int index) const; + ::io::substrait::Expression_MaskExpression_StructItem* add_struct_items(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_StructItem >& + struct_items() const; + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.StructSelect) + private: + class _Internal; + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_StructItem > struct_items_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; // ------------------------------------------------------------------- -// Expression_Enum +class Expression_MaskExpression_StructItem PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.StructItem) */ { + public: + inline Expression_MaskExpression_StructItem() : Expression_MaskExpression_StructItem(nullptr) {} + ~Expression_MaskExpression_StructItem() override; + explicit constexpr Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MaskExpression_StructItem(const Expression_MaskExpression_StructItem& from); + Expression_MaskExpression_StructItem(Expression_MaskExpression_StructItem&& from) noexcept + : Expression_MaskExpression_StructItem() { + *this = ::std::move(from); + } + + inline Expression_MaskExpression_StructItem& operator=(const Expression_MaskExpression_StructItem& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression_StructItem& operator=(Expression_MaskExpression_StructItem&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression_StructItem& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_MaskExpression_StructItem* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_StructItem_default_instance_); + } + static constexpr int kIndexInFileMessages = + 35; + + friend void swap(Expression_MaskExpression_StructItem& a, Expression_MaskExpression_StructItem& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression_StructItem* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression_StructItem* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression_StructItem* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression_StructItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression_StructItem& from); + void MergeFrom(const Expression_MaskExpression_StructItem& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression_StructItem* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression.StructItem"; + } + protected: + explicit Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kChildFieldNumber = 2, + kFieldFieldNumber = 1, + }; + // .io.substrait.Expression.MaskExpression.Select child = 2; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::Expression_MaskExpression_Select& child() const; + ::io::substrait::Expression_MaskExpression_Select* release_child(); + ::io::substrait::Expression_MaskExpression_Select* mutable_child(); + void set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child); + private: + const ::io::substrait::Expression_MaskExpression_Select& _internal_child() const; + ::io::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::Expression_MaskExpression_Select* child); + ::io::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); + + // int32 field = 1; + void clear_field(); + ::PROTOBUF_NAMESPACE_ID::int32 field() const; + void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; + void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.StructItem) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression_MaskExpression_Select* child_; + ::PROTOBUF_NAMESPACE_ID::int32 field_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) */ { + public: + inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() : Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(nullptr) {} + ~Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() override; + explicit constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from); + Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&& from) noexcept + : Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() { + *this = ::std::move(from); + } + + inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_); + } + static constexpr int kIndexInFileMessages = + 36; + + friend void swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& a, Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from); + void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement"; + } + protected: + explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFieldFieldNumber = 1, + }; + // int32 field = 1; + void clear_field(); + ::PROTOBUF_NAMESPACE_ID::int32 field() const; + void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; + void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::int32 field_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) */ { + public: + inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() : Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(nullptr) {} + ~Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() override; + explicit constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from); + Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&& from) noexcept + : Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() { + *this = ::std::move(from); + } + + inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_); + } + static constexpr int kIndexInFileMessages = + 37; + + friend void swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& a, Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from); + void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice"; + } + protected: + explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kStartFieldNumber = 1, + kEndFieldNumber = 2, + }; + // int32 start = 1; + void clear_start(); + ::PROTOBUF_NAMESPACE_ID::int32 start() const; + void set_start(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_start() const; + void _internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // int32 end = 2; + void clear_end(); + ::PROTOBUF_NAMESPACE_ID::int32 end() const; + void set_end(::PROTOBUF_NAMESPACE_ID::int32 value); + private: + ::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const; + void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::int32 start_; + ::PROTOBUF_NAMESPACE_ID::int32 end_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) */ { + public: + inline Expression_MaskExpression_ListSelect_ListSelectItem() : Expression_MaskExpression_ListSelect_ListSelectItem(nullptr) {} + ~Expression_MaskExpression_ListSelect_ListSelectItem() override; + explicit constexpr Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MaskExpression_ListSelect_ListSelectItem(const Expression_MaskExpression_ListSelect_ListSelectItem& from); + Expression_MaskExpression_ListSelect_ListSelectItem(Expression_MaskExpression_ListSelect_ListSelectItem&& from) noexcept + : Expression_MaskExpression_ListSelect_ListSelectItem() { + *this = ::std::move(from); + } + + inline Expression_MaskExpression_ListSelect_ListSelectItem& operator=(const Expression_MaskExpression_ListSelect_ListSelectItem& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression_ListSelect_ListSelectItem& operator=(Expression_MaskExpression_ListSelect_ListSelectItem&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression_ListSelect_ListSelectItem& default_instance() { + return *internal_default_instance(); + } + enum TypeCase { + kItem = 1, + kSlice = 2, + TYPE_NOT_SET = 0, + }; + + static inline const Expression_MaskExpression_ListSelect_ListSelectItem* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_); + } + static constexpr int kIndexInFileMessages = + 38; + + friend void swap(Expression_MaskExpression_ListSelect_ListSelectItem& a, Expression_MaskExpression_ListSelect_ListSelectItem& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression_ListSelect_ListSelectItem* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression_ListSelect_ListSelectItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from); + void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem"; + } + protected: + explicit Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_MaskExpression_ListSelect_ListSelectItem_ListElement ListElement; + typedef Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice ListSlice; + + // accessors ------------------------------------------------------- + + enum : int { + kItemFieldNumber = 1, + kSliceFieldNumber = 2, + }; + // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + bool has_item() const; + private: + bool _internal_has_item() const; + public: + void clear_item(); + const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item() const; + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* release_item(); + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* mutable_item(); + void set_allocated_item(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item); + private: + const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& _internal_item() const; + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _internal_mutable_item(); + public: + void unsafe_arena_set_allocated_item( + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item); + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* unsafe_arena_release_item(); + + // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + bool has_slice() const; + private: + bool _internal_has_slice() const; + public: + void clear_slice(); + const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice() const; + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* release_slice(); + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* mutable_slice(); + void set_allocated_slice(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); + private: + const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& _internal_slice() const; + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _internal_mutable_slice(); + public: + void unsafe_arena_set_allocated_slice( + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* unsafe_arena_release_slice(); + + void clear_type(); + TypeCase type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + private: + class _Internal; + void set_has_item(); + void set_has_slice(); + + inline bool has_type() const; + inline void clear_has_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union TypeUnion { + constexpr TypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item_; + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice_; + } type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MaskExpression_ListSelect PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.ListSelect) */ { + public: + inline Expression_MaskExpression_ListSelect() : Expression_MaskExpression_ListSelect(nullptr) {} + ~Expression_MaskExpression_ListSelect() override; + explicit constexpr Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MaskExpression_ListSelect(const Expression_MaskExpression_ListSelect& from); + Expression_MaskExpression_ListSelect(Expression_MaskExpression_ListSelect&& from) noexcept + : Expression_MaskExpression_ListSelect() { + *this = ::std::move(from); + } + + inline Expression_MaskExpression_ListSelect& operator=(const Expression_MaskExpression_ListSelect& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression_ListSelect& operator=(Expression_MaskExpression_ListSelect&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression_ListSelect& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_MaskExpression_ListSelect* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_ListSelect_default_instance_); + } + static constexpr int kIndexInFileMessages = + 39; + + friend void swap(Expression_MaskExpression_ListSelect& a, Expression_MaskExpression_ListSelect& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression_ListSelect* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression_ListSelect* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression_ListSelect* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression_ListSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression_ListSelect& from); + void MergeFrom(const Expression_MaskExpression_ListSelect& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression_ListSelect* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression.ListSelect"; + } + protected: + explicit Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_MaskExpression_ListSelect_ListSelectItem ListSelectItem; + + // accessors ------------------------------------------------------- + + enum : int { + kSelectionFieldNumber = 1, + kChildFieldNumber = 2, + }; + // repeated .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; + int selection_size() const; + private: + int _internal_selection_size() const; + public: + void clear_selection(); + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* mutable_selection(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >* + mutable_selection(); + private: + const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& _internal_selection(int index) const; + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* _internal_add_selection(); + public: + const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& selection(int index) const; + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* add_selection(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >& + selection() const; + + // .io.substrait.Expression.MaskExpression.Select child = 2; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::Expression_MaskExpression_Select& child() const; + ::io::substrait::Expression_MaskExpression_Select* release_child(); + ::io::substrait::Expression_MaskExpression_Select* mutable_child(); + void set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child); + private: + const ::io::substrait::Expression_MaskExpression_Select& _internal_child() const; + ::io::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::Expression_MaskExpression_Select* child); + ::io::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.ListSelect) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem > selection_; + ::io::substrait::Expression_MaskExpression_Select* child_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.MapSelect.MapKey) */ { + public: + inline Expression_MaskExpression_MapSelect_MapKey() : Expression_MaskExpression_MapSelect_MapKey(nullptr) {} + ~Expression_MaskExpression_MapSelect_MapKey() override; + explicit constexpr Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MaskExpression_MapSelect_MapKey(const Expression_MaskExpression_MapSelect_MapKey& from); + Expression_MaskExpression_MapSelect_MapKey(Expression_MaskExpression_MapSelect_MapKey&& from) noexcept + : Expression_MaskExpression_MapSelect_MapKey() { + *this = ::std::move(from); + } + + inline Expression_MaskExpression_MapSelect_MapKey& operator=(const Expression_MaskExpression_MapSelect_MapKey& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression_MapSelect_MapKey& operator=(Expression_MaskExpression_MapSelect_MapKey&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression_MapSelect_MapKey& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_MaskExpression_MapSelect_MapKey* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_MapSelect_MapKey_default_instance_); + } + static constexpr int kIndexInFileMessages = + 40; + + friend void swap(Expression_MaskExpression_MapSelect_MapKey& a, Expression_MaskExpression_MapSelect_MapKey& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression_MapSelect_MapKey* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression_MapSelect_MapKey* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression_MapSelect_MapKey* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression_MapSelect_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression_MapSelect_MapKey& from); + void MergeFrom(const Expression_MaskExpression_MapSelect_MapKey& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression_MapSelect_MapKey* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression.MapSelect.MapKey"; + } + protected: + explicit Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMapKeyFieldNumber = 1, + }; + // string map_key = 1; + void clear_map_key(); + const std::string& map_key() const; + template + void set_map_key(ArgT0&& arg0, ArgT... args); + std::string* mutable_map_key(); + std::string* release_map_key(); + void set_allocated_map_key(std::string* map_key); + private: + const std::string& _internal_map_key() const; + void _internal_set_map_key(const std::string& value); + std::string* _internal_mutable_map_key(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) */ { + public: + inline Expression_MaskExpression_MapSelect_MapKeyExpression() : Expression_MaskExpression_MapSelect_MapKeyExpression(nullptr) {} + ~Expression_MaskExpression_MapSelect_MapKeyExpression() override; + explicit constexpr Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MaskExpression_MapSelect_MapKeyExpression(const Expression_MaskExpression_MapSelect_MapKeyExpression& from); + Expression_MaskExpression_MapSelect_MapKeyExpression(Expression_MaskExpression_MapSelect_MapKeyExpression&& from) noexcept + : Expression_MaskExpression_MapSelect_MapKeyExpression() { + *this = ::std::move(from); + } + + inline Expression_MaskExpression_MapSelect_MapKeyExpression& operator=(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression_MapSelect_MapKeyExpression& operator=(Expression_MaskExpression_MapSelect_MapKeyExpression&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression_MapSelect_MapKeyExpression& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_MaskExpression_MapSelect_MapKeyExpression* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_); + } + static constexpr int kIndexInFileMessages = + 41; + + friend void swap(Expression_MaskExpression_MapSelect_MapKeyExpression& a, Expression_MaskExpression_MapSelect_MapKeyExpression& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression_MapSelect_MapKeyExpression* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression_MapSelect_MapKeyExpression* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression_MapSelect_MapKeyExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from); + void MergeFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression"; + } + protected: + explicit Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kMapKeyExpressionFieldNumber = 1, + }; + // string map_key_expression = 1; + void clear_map_key_expression(); + const std::string& map_key_expression() const; + template + void set_map_key_expression(ArgT0&& arg0, ArgT... args); + std::string* mutable_map_key_expression(); + std::string* release_map_key_expression(); + void set_allocated_map_key_expression(std::string* map_key_expression); + private: + const std::string& _internal_map_key_expression() const; + void _internal_set_map_key_expression(const std::string& value); + std::string* _internal_mutable_map_key_expression(); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_expression_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.MapSelect) */ { + public: + inline Expression_MaskExpression_MapSelect() : Expression_MaskExpression_MapSelect(nullptr) {} + ~Expression_MaskExpression_MapSelect() override; + explicit constexpr Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MaskExpression_MapSelect(const Expression_MaskExpression_MapSelect& from); + Expression_MaskExpression_MapSelect(Expression_MaskExpression_MapSelect&& from) noexcept + : Expression_MaskExpression_MapSelect() { + *this = ::std::move(from); + } + + inline Expression_MaskExpression_MapSelect& operator=(const Expression_MaskExpression_MapSelect& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression_MapSelect& operator=(Expression_MaskExpression_MapSelect&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression_MapSelect& default_instance() { + return *internal_default_instance(); + } + enum SelectCase { + kKey = 1, + kExpression = 2, + SELECT_NOT_SET = 0, + }; + + static inline const Expression_MaskExpression_MapSelect* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_MapSelect_default_instance_); + } + static constexpr int kIndexInFileMessages = + 42; + + friend void swap(Expression_MaskExpression_MapSelect& a, Expression_MaskExpression_MapSelect& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression_MapSelect* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression_MapSelect* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression_MapSelect* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression_MapSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression_MapSelect& from); + void MergeFrom(const Expression_MaskExpression_MapSelect& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression_MapSelect* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression.MapSelect"; + } + protected: + explicit Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_MaskExpression_MapSelect_MapKey MapKey; + typedef Expression_MaskExpression_MapSelect_MapKeyExpression MapKeyExpression; + + // accessors ------------------------------------------------------- + + enum : int { + kChildFieldNumber = 3, + kKeyFieldNumber = 1, + kExpressionFieldNumber = 2, + }; + // .io.substrait.Expression.MaskExpression.Select child = 3; + bool has_child() const; + private: + bool _internal_has_child() const; + public: + void clear_child(); + const ::io::substrait::Expression_MaskExpression_Select& child() const; + ::io::substrait::Expression_MaskExpression_Select* release_child(); + ::io::substrait::Expression_MaskExpression_Select* mutable_child(); + void set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child); + private: + const ::io::substrait::Expression_MaskExpression_Select& _internal_child() const; + ::io::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); + public: + void unsafe_arena_set_allocated_child( + ::io::substrait::Expression_MaskExpression_Select* child); + ::io::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); + + // .io.substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; + bool has_key() const; + private: + bool _internal_has_key() const; + public: + void clear_key(); + const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& key() const; + ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* release_key(); + ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* mutable_key(); + void set_allocated_key(::io::substrait::Expression_MaskExpression_MapSelect_MapKey* key); + private: + const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& _internal_key() const; + ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* _internal_mutable_key(); + public: + void unsafe_arena_set_allocated_key( + ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* key); + ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* unsafe_arena_release_key(); + + // .io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; + bool has_expression() const; + private: + bool _internal_has_expression() const; + public: + void clear_expression(); + const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression() const; + ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* release_expression(); + ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* mutable_expression(); + void set_allocated_expression(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression); + private: + const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& _internal_expression() const; + ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* _internal_mutable_expression(); + public: + void unsafe_arena_set_allocated_expression( + ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression); + ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* unsafe_arena_release_expression(); + + void clear_select(); + SelectCase select_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.MapSelect) + private: + class _Internal; + void set_has_key(); + void set_has_expression(); + + inline bool has_select() const; + inline void clear_has_select(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression_MaskExpression_Select* child_; + union SelectUnion { + constexpr SelectUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* key_; + ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression_; + } select_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_MaskExpression PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression) */ { + public: + inline Expression_MaskExpression() : Expression_MaskExpression(nullptr) {} + ~Expression_MaskExpression() override; + explicit constexpr Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_MaskExpression(const Expression_MaskExpression& from); + Expression_MaskExpression(Expression_MaskExpression&& from) noexcept + : Expression_MaskExpression() { + *this = ::std::move(from); + } + + inline Expression_MaskExpression& operator=(const Expression_MaskExpression& from) { + CopyFrom(from); + return *this; + } + inline Expression_MaskExpression& operator=(Expression_MaskExpression&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_MaskExpression& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_MaskExpression* internal_default_instance() { + return reinterpret_cast( + &_Expression_MaskExpression_default_instance_); + } + static constexpr int kIndexInFileMessages = + 43; + + friend void swap(Expression_MaskExpression& a, Expression_MaskExpression& b) { + a.Swap(&b); + } + inline void Swap(Expression_MaskExpression* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_MaskExpression* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_MaskExpression* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_MaskExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_MaskExpression& from); + void MergeFrom(const Expression_MaskExpression& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_MaskExpression* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.MaskExpression"; + } + protected: + explicit Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_MaskExpression_Select Select; + typedef Expression_MaskExpression_StructSelect StructSelect; + typedef Expression_MaskExpression_StructItem StructItem; + typedef Expression_MaskExpression_ListSelect ListSelect; + typedef Expression_MaskExpression_MapSelect MapSelect; + + // accessors ------------------------------------------------------- + + enum : int { + kSelectFieldNumber = 1, + kMaintainSingularStructFieldNumber = 2, + }; + // .io.substrait.Expression.MaskExpression.StructSelect select = 1; + bool has_select() const; + private: + bool _internal_has_select() const; + public: + void clear_select(); + const ::io::substrait::Expression_MaskExpression_StructSelect& select() const; + ::io::substrait::Expression_MaskExpression_StructSelect* release_select(); + ::io::substrait::Expression_MaskExpression_StructSelect* mutable_select(); + void set_allocated_select(::io::substrait::Expression_MaskExpression_StructSelect* select); + private: + const ::io::substrait::Expression_MaskExpression_StructSelect& _internal_select() const; + ::io::substrait::Expression_MaskExpression_StructSelect* _internal_mutable_select(); + public: + void unsafe_arena_set_allocated_select( + ::io::substrait::Expression_MaskExpression_StructSelect* select); + ::io::substrait::Expression_MaskExpression_StructSelect* unsafe_arena_release_select(); + + // bool maintain_singular_struct = 2; + void clear_maintain_singular_struct(); + bool maintain_singular_struct() const; + void set_maintain_singular_struct(bool value); + private: + bool _internal_maintain_singular_struct() const; + void _internal_set_maintain_singular_struct(bool value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression_MaskExpression_StructSelect* select_; + bool maintain_singular_struct_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_FieldReference_RootReference PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.FieldReference.RootReference) */ { + public: + inline Expression_FieldReference_RootReference() : Expression_FieldReference_RootReference(nullptr) {} + ~Expression_FieldReference_RootReference() override; + explicit constexpr Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_FieldReference_RootReference(const Expression_FieldReference_RootReference& from); + Expression_FieldReference_RootReference(Expression_FieldReference_RootReference&& from) noexcept + : Expression_FieldReference_RootReference() { + *this = ::std::move(from); + } + + inline Expression_FieldReference_RootReference& operator=(const Expression_FieldReference_RootReference& from) { + CopyFrom(from); + return *this; + } + inline Expression_FieldReference_RootReference& operator=(Expression_FieldReference_RootReference&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_FieldReference_RootReference& default_instance() { + return *internal_default_instance(); + } + static inline const Expression_FieldReference_RootReference* internal_default_instance() { + return reinterpret_cast( + &_Expression_FieldReference_RootReference_default_instance_); + } + static constexpr int kIndexInFileMessages = + 44; + + friend void swap(Expression_FieldReference_RootReference& a, Expression_FieldReference_RootReference& b) { + a.Swap(&b); + } + inline void Swap(Expression_FieldReference_RootReference* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_FieldReference_RootReference* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_FieldReference_RootReference* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_FieldReference_RootReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_FieldReference_RootReference& from); + void MergeFrom(const Expression_FieldReference_RootReference& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_FieldReference_RootReference* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.FieldReference.RootReference"; + } + protected: + explicit Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // @@protoc_insertion_point(class_scope:io.substrait.Expression.FieldReference.RootReference) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression_FieldReference PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.FieldReference) */ { + public: + inline Expression_FieldReference() : Expression_FieldReference(nullptr) {} + ~Expression_FieldReference() override; + explicit constexpr Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression_FieldReference(const Expression_FieldReference& from); + Expression_FieldReference(Expression_FieldReference&& from) noexcept + : Expression_FieldReference() { + *this = ::std::move(from); + } + + inline Expression_FieldReference& operator=(const Expression_FieldReference& from) { + CopyFrom(from); + return *this; + } + inline Expression_FieldReference& operator=(Expression_FieldReference&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression_FieldReference& default_instance() { + return *internal_default_instance(); + } + enum ReferenceTypeCase { + kDirectReference = 1, + kMaskedReference = 2, + REFERENCE_TYPE_NOT_SET = 0, + }; + + enum RootTypeCase { + kExpression = 3, + kRootReference = 4, + ROOT_TYPE_NOT_SET = 0, + }; + + static inline const Expression_FieldReference* internal_default_instance() { + return reinterpret_cast( + &_Expression_FieldReference_default_instance_); + } + static constexpr int kIndexInFileMessages = + 45; + + friend void swap(Expression_FieldReference& a, Expression_FieldReference& b) { + a.Swap(&b); + } + inline void Swap(Expression_FieldReference* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression_FieldReference* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression_FieldReference* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression_FieldReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression_FieldReference& from); + void MergeFrom(const Expression_FieldReference& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression_FieldReference* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression.FieldReference"; + } + protected: + explicit Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_FieldReference_RootReference RootReference; + + // accessors ------------------------------------------------------- + + enum : int { + kDirectReferenceFieldNumber = 1, + kMaskedReferenceFieldNumber = 2, + kExpressionFieldNumber = 3, + kRootReferenceFieldNumber = 4, + }; + // .io.substrait.Expression.ReferenceSegment direct_reference = 1; + bool has_direct_reference() const; + private: + bool _internal_has_direct_reference() const; + public: + void clear_direct_reference(); + const ::io::substrait::Expression_ReferenceSegment& direct_reference() const; + ::io::substrait::Expression_ReferenceSegment* release_direct_reference(); + ::io::substrait::Expression_ReferenceSegment* mutable_direct_reference(); + void set_allocated_direct_reference(::io::substrait::Expression_ReferenceSegment* direct_reference); + private: + const ::io::substrait::Expression_ReferenceSegment& _internal_direct_reference() const; + ::io::substrait::Expression_ReferenceSegment* _internal_mutable_direct_reference(); + public: + void unsafe_arena_set_allocated_direct_reference( + ::io::substrait::Expression_ReferenceSegment* direct_reference); + ::io::substrait::Expression_ReferenceSegment* unsafe_arena_release_direct_reference(); + + // .io.substrait.Expression.MaskExpression masked_reference = 2; + bool has_masked_reference() const; + private: + bool _internal_has_masked_reference() const; + public: + void clear_masked_reference(); + const ::io::substrait::Expression_MaskExpression& masked_reference() const; + ::io::substrait::Expression_MaskExpression* release_masked_reference(); + ::io::substrait::Expression_MaskExpression* mutable_masked_reference(); + void set_allocated_masked_reference(::io::substrait::Expression_MaskExpression* masked_reference); + private: + const ::io::substrait::Expression_MaskExpression& _internal_masked_reference() const; + ::io::substrait::Expression_MaskExpression* _internal_mutable_masked_reference(); + public: + void unsafe_arena_set_allocated_masked_reference( + ::io::substrait::Expression_MaskExpression* masked_reference); + ::io::substrait::Expression_MaskExpression* unsafe_arena_release_masked_reference(); + + // .io.substrait.Expression expression = 3; + bool has_expression() const; + private: + bool _internal_has_expression() const; + public: + void clear_expression(); + const ::io::substrait::Expression& expression() const; + ::io::substrait::Expression* release_expression(); + ::io::substrait::Expression* mutable_expression(); + void set_allocated_expression(::io::substrait::Expression* expression); + private: + const ::io::substrait::Expression& _internal_expression() const; + ::io::substrait::Expression* _internal_mutable_expression(); + public: + void unsafe_arena_set_allocated_expression( + ::io::substrait::Expression* expression); + ::io::substrait::Expression* unsafe_arena_release_expression(); + + // .io.substrait.Expression.FieldReference.RootReference root_reference = 4; + bool has_root_reference() const; + private: + bool _internal_has_root_reference() const; + public: + void clear_root_reference(); + const ::io::substrait::Expression_FieldReference_RootReference& root_reference() const; + ::io::substrait::Expression_FieldReference_RootReference* release_root_reference(); + ::io::substrait::Expression_FieldReference_RootReference* mutable_root_reference(); + void set_allocated_root_reference(::io::substrait::Expression_FieldReference_RootReference* root_reference); + private: + const ::io::substrait::Expression_FieldReference_RootReference& _internal_root_reference() const; + ::io::substrait::Expression_FieldReference_RootReference* _internal_mutable_root_reference(); + public: + void unsafe_arena_set_allocated_root_reference( + ::io::substrait::Expression_FieldReference_RootReference* root_reference); + ::io::substrait::Expression_FieldReference_RootReference* unsafe_arena_release_root_reference(); + + void clear_reference_type(); + ReferenceTypeCase reference_type_case() const; + void clear_root_type(); + RootTypeCase root_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression.FieldReference) + private: + class _Internal; + void set_has_direct_reference(); + void set_has_masked_reference(); + void set_has_expression(); + void set_has_root_reference(); + + inline bool has_reference_type() const; + inline void clear_has_reference_type(); + + inline bool has_root_type() const; + inline void clear_has_root_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union ReferenceTypeUnion { + constexpr ReferenceTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Expression_ReferenceSegment* direct_reference_; + ::io::substrait::Expression_MaskExpression* masked_reference_; + } reference_type_; + union RootTypeUnion { + constexpr RootTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Expression* expression_; + ::io::substrait::Expression_FieldReference_RootReference* root_reference_; + } root_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class Expression PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression) */ { + public: + inline Expression() : Expression(nullptr) {} + ~Expression() override; + explicit constexpr Expression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Expression(const Expression& from); + Expression(Expression&& from) noexcept + : Expression() { + *this = ::std::move(from); + } + + inline Expression& operator=(const Expression& from) { + CopyFrom(from); + return *this; + } + inline Expression& operator=(Expression&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Expression& default_instance() { + return *internal_default_instance(); + } + enum RexTypeCase { + kLiteral = 1, + kSelection = 2, + kScalarFunction = 3, + kWindowFunction = 5, + kIfThen = 6, + kSwitchExpression = 7, + kSingularOrList = 8, + kMultiOrList = 9, + kEnum = 10, + kCast = 11, + REX_TYPE_NOT_SET = 0, + }; + + static inline const Expression* internal_default_instance() { + return reinterpret_cast( + &_Expression_default_instance_); + } + static constexpr int kIndexInFileMessages = + 46; + + friend void swap(Expression& a, Expression& b) { + a.Swap(&b); + } + inline void Swap(Expression* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Expression* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Expression* New() const final { + return CreateMaybeMessage(nullptr); + } + + Expression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Expression& from); + void MergeFrom(const Expression& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Expression* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Expression"; + } + protected: + explicit Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef Expression_Enum Enum; + typedef Expression_Literal Literal; + typedef Expression_ScalarFunction ScalarFunction; + typedef Expression_WindowFunction WindowFunction; + typedef Expression_IfThen IfThen; + typedef Expression_Cast Cast; + typedef Expression_SwitchExpression SwitchExpression; + typedef Expression_SingularOrList SingularOrList; + typedef Expression_MultiOrList MultiOrList; + typedef Expression_EmbeddedFunction EmbeddedFunction; + typedef Expression_ReferenceSegment ReferenceSegment; + typedef Expression_MaskExpression MaskExpression; + typedef Expression_FieldReference FieldReference; + + // accessors ------------------------------------------------------- + + enum : int { + kLiteralFieldNumber = 1, + kSelectionFieldNumber = 2, + kScalarFunctionFieldNumber = 3, + kWindowFunctionFieldNumber = 5, + kIfThenFieldNumber = 6, + kSwitchExpressionFieldNumber = 7, + kSingularOrListFieldNumber = 8, + kMultiOrListFieldNumber = 9, + kEnumFieldNumber = 10, + kCastFieldNumber = 11, + }; + // .io.substrait.Expression.Literal literal = 1; + bool has_literal() const; + private: + bool _internal_has_literal() const; + public: + void clear_literal(); + const ::io::substrait::Expression_Literal& literal() const; + ::io::substrait::Expression_Literal* release_literal(); + ::io::substrait::Expression_Literal* mutable_literal(); + void set_allocated_literal(::io::substrait::Expression_Literal* literal); + private: + const ::io::substrait::Expression_Literal& _internal_literal() const; + ::io::substrait::Expression_Literal* _internal_mutable_literal(); + public: + void unsafe_arena_set_allocated_literal( + ::io::substrait::Expression_Literal* literal); + ::io::substrait::Expression_Literal* unsafe_arena_release_literal(); + + // .io.substrait.Expression.FieldReference selection = 2; + bool has_selection() const; + private: + bool _internal_has_selection() const; + public: + void clear_selection(); + const ::io::substrait::Expression_FieldReference& selection() const; + ::io::substrait::Expression_FieldReference* release_selection(); + ::io::substrait::Expression_FieldReference* mutable_selection(); + void set_allocated_selection(::io::substrait::Expression_FieldReference* selection); + private: + const ::io::substrait::Expression_FieldReference& _internal_selection() const; + ::io::substrait::Expression_FieldReference* _internal_mutable_selection(); + public: + void unsafe_arena_set_allocated_selection( + ::io::substrait::Expression_FieldReference* selection); + ::io::substrait::Expression_FieldReference* unsafe_arena_release_selection(); + + // .io.substrait.Expression.ScalarFunction scalar_function = 3; + bool has_scalar_function() const; + private: + bool _internal_has_scalar_function() const; + public: + void clear_scalar_function(); + const ::io::substrait::Expression_ScalarFunction& scalar_function() const; + ::io::substrait::Expression_ScalarFunction* release_scalar_function(); + ::io::substrait::Expression_ScalarFunction* mutable_scalar_function(); + void set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function); + private: + const ::io::substrait::Expression_ScalarFunction& _internal_scalar_function() const; + ::io::substrait::Expression_ScalarFunction* _internal_mutable_scalar_function(); + public: + void unsafe_arena_set_allocated_scalar_function( + ::io::substrait::Expression_ScalarFunction* scalar_function); + ::io::substrait::Expression_ScalarFunction* unsafe_arena_release_scalar_function(); + + // .io.substrait.Expression.WindowFunction window_function = 5; + bool has_window_function() const; + private: + bool _internal_has_window_function() const; + public: + void clear_window_function(); + const ::io::substrait::Expression_WindowFunction& window_function() const; + ::io::substrait::Expression_WindowFunction* release_window_function(); + ::io::substrait::Expression_WindowFunction* mutable_window_function(); + void set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function); + private: + const ::io::substrait::Expression_WindowFunction& _internal_window_function() const; + ::io::substrait::Expression_WindowFunction* _internal_mutable_window_function(); + public: + void unsafe_arena_set_allocated_window_function( + ::io::substrait::Expression_WindowFunction* window_function); + ::io::substrait::Expression_WindowFunction* unsafe_arena_release_window_function(); + + // .io.substrait.Expression.IfThen if_then = 6; + bool has_if_then() const; + private: + bool _internal_has_if_then() const; + public: + void clear_if_then(); + const ::io::substrait::Expression_IfThen& if_then() const; + ::io::substrait::Expression_IfThen* release_if_then(); + ::io::substrait::Expression_IfThen* mutable_if_then(); + void set_allocated_if_then(::io::substrait::Expression_IfThen* if_then); + private: + const ::io::substrait::Expression_IfThen& _internal_if_then() const; + ::io::substrait::Expression_IfThen* _internal_mutable_if_then(); + public: + void unsafe_arena_set_allocated_if_then( + ::io::substrait::Expression_IfThen* if_then); + ::io::substrait::Expression_IfThen* unsafe_arena_release_if_then(); + + // .io.substrait.Expression.SwitchExpression switch_expression = 7; + bool has_switch_expression() const; + private: + bool _internal_has_switch_expression() const; + public: + void clear_switch_expression(); + const ::io::substrait::Expression_SwitchExpression& switch_expression() const; + ::io::substrait::Expression_SwitchExpression* release_switch_expression(); + ::io::substrait::Expression_SwitchExpression* mutable_switch_expression(); + void set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression); + private: + const ::io::substrait::Expression_SwitchExpression& _internal_switch_expression() const; + ::io::substrait::Expression_SwitchExpression* _internal_mutable_switch_expression(); + public: + void unsafe_arena_set_allocated_switch_expression( + ::io::substrait::Expression_SwitchExpression* switch_expression); + ::io::substrait::Expression_SwitchExpression* unsafe_arena_release_switch_expression(); + + // .io.substrait.Expression.SingularOrList singular_or_list = 8; + bool has_singular_or_list() const; + private: + bool _internal_has_singular_or_list() const; + public: + void clear_singular_or_list(); + const ::io::substrait::Expression_SingularOrList& singular_or_list() const; + ::io::substrait::Expression_SingularOrList* release_singular_or_list(); + ::io::substrait::Expression_SingularOrList* mutable_singular_or_list(); + void set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list); + private: + const ::io::substrait::Expression_SingularOrList& _internal_singular_or_list() const; + ::io::substrait::Expression_SingularOrList* _internal_mutable_singular_or_list(); + public: + void unsafe_arena_set_allocated_singular_or_list( + ::io::substrait::Expression_SingularOrList* singular_or_list); + ::io::substrait::Expression_SingularOrList* unsafe_arena_release_singular_or_list(); + + // .io.substrait.Expression.MultiOrList multi_or_list = 9; + bool has_multi_or_list() const; + private: + bool _internal_has_multi_or_list() const; + public: + void clear_multi_or_list(); + const ::io::substrait::Expression_MultiOrList& multi_or_list() const; + ::io::substrait::Expression_MultiOrList* release_multi_or_list(); + ::io::substrait::Expression_MultiOrList* mutable_multi_or_list(); + void set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list); + private: + const ::io::substrait::Expression_MultiOrList& _internal_multi_or_list() const; + ::io::substrait::Expression_MultiOrList* _internal_mutable_multi_or_list(); + public: + void unsafe_arena_set_allocated_multi_or_list( + ::io::substrait::Expression_MultiOrList* multi_or_list); + ::io::substrait::Expression_MultiOrList* unsafe_arena_release_multi_or_list(); + + // .io.substrait.Expression.Enum enum = 10; + bool has_enum_() const; + private: + bool _internal_has_enum_() const; + public: + void clear_enum_(); + const ::io::substrait::Expression_Enum& enum_() const; + ::io::substrait::Expression_Enum* release_enum_(); + ::io::substrait::Expression_Enum* mutable_enum_(); + void set_allocated_enum_(::io::substrait::Expression_Enum* enum_); + private: + const ::io::substrait::Expression_Enum& _internal_enum_() const; + ::io::substrait::Expression_Enum* _internal_mutable_enum_(); + public: + void unsafe_arena_set_allocated_enum_( + ::io::substrait::Expression_Enum* enum_); + ::io::substrait::Expression_Enum* unsafe_arena_release_enum_(); + + // .io.substrait.Expression.Cast cast = 11; + bool has_cast() const; + private: + bool _internal_has_cast() const; + public: + void clear_cast(); + const ::io::substrait::Expression_Cast& cast() const; + ::io::substrait::Expression_Cast* release_cast(); + ::io::substrait::Expression_Cast* mutable_cast(); + void set_allocated_cast(::io::substrait::Expression_Cast* cast); + private: + const ::io::substrait::Expression_Cast& _internal_cast() const; + ::io::substrait::Expression_Cast* _internal_mutable_cast(); + public: + void unsafe_arena_set_allocated_cast( + ::io::substrait::Expression_Cast* cast); + ::io::substrait::Expression_Cast* unsafe_arena_release_cast(); + + void clear_rex_type(); + RexTypeCase rex_type_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Expression) + private: + class _Internal; + void set_has_literal(); + void set_has_selection(); + void set_has_scalar_function(); + void set_has_window_function(); + void set_has_if_then(); + void set_has_switch_expression(); + void set_has_singular_or_list(); + void set_has_multi_or_list(); + void set_has_enum_(); + void set_has_cast(); + + inline bool has_rex_type() const; + inline void clear_has_rex_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union RexTypeUnion { + constexpr RexTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Expression_Literal* literal_; + ::io::substrait::Expression_FieldReference* selection_; + ::io::substrait::Expression_ScalarFunction* scalar_function_; + ::io::substrait::Expression_WindowFunction* window_function_; + ::io::substrait::Expression_IfThen* if_then_; + ::io::substrait::Expression_SwitchExpression* switch_expression_; + ::io::substrait::Expression_SingularOrList* singular_or_list_; + ::io::substrait::Expression_MultiOrList* multi_or_list_; + ::io::substrait::Expression_Enum* enum__; + ::io::substrait::Expression_Cast* cast_; + } rex_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class SortField PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.SortField) */ { + public: + inline SortField() : SortField(nullptr) {} + ~SortField() override; + explicit constexpr SortField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SortField(const SortField& from); + SortField(SortField&& from) noexcept + : SortField() { + *this = ::std::move(from); + } + + inline SortField& operator=(const SortField& from) { + CopyFrom(from); + return *this; + } + inline SortField& operator=(SortField&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 SortField& default_instance() { + return *internal_default_instance(); + } + enum SortKindCase { + kDirection = 2, + kComparisonFunctionReference = 3, + SORT_KIND_NOT_SET = 0, + }; + + static inline const SortField* internal_default_instance() { + return reinterpret_cast( + &_SortField_default_instance_); + } + static constexpr int kIndexInFileMessages = + 47; + + friend void swap(SortField& a, SortField& b) { + a.Swap(&b); + } + inline void Swap(SortField* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SortField* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SortField* New() const final { + return CreateMaybeMessage(nullptr); + } + + SortField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SortField& from); + void MergeFrom(const SortField& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SortField* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.SortField"; + } + protected: + explicit SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef SortField_SortDirection SortDirection; + static constexpr SortDirection UNKNOWN = + SortField_SortDirection_UNKNOWN; + static constexpr SortDirection ASC_NULLS_FIRST = + SortField_SortDirection_ASC_NULLS_FIRST; + static constexpr SortDirection ASC_NULLS_LAST = + SortField_SortDirection_ASC_NULLS_LAST; + static constexpr SortDirection DESC_NULLS_FIRST = + SortField_SortDirection_DESC_NULLS_FIRST; + static constexpr SortDirection DESC_NULLS_LAST = + SortField_SortDirection_DESC_NULLS_LAST; + static constexpr SortDirection CLUSTERED = + SortField_SortDirection_CLUSTERED; + static inline bool SortDirection_IsValid(int value) { + return SortField_SortDirection_IsValid(value); + } + static constexpr SortDirection SortDirection_MIN = + SortField_SortDirection_SortDirection_MIN; + static constexpr SortDirection SortDirection_MAX = + SortField_SortDirection_SortDirection_MAX; + static constexpr int SortDirection_ARRAYSIZE = + SortField_SortDirection_SortDirection_ARRAYSIZE; + static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* + SortDirection_descriptor() { + return SortField_SortDirection_descriptor(); + } + template + static inline const std::string& SortDirection_Name(T enum_t_value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to function SortDirection_Name."); + return SortField_SortDirection_Name(enum_t_value); + } + static inline bool SortDirection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + SortDirection* value) { + return SortField_SortDirection_Parse(name, value); + } + + // accessors ------------------------------------------------------- + + enum : int { + kExprFieldNumber = 1, + kDirectionFieldNumber = 2, + kComparisonFunctionReferenceFieldNumber = 3, + }; + // .io.substrait.Expression expr = 1; + bool has_expr() const; + private: + bool _internal_has_expr() const; + public: + void clear_expr(); + const ::io::substrait::Expression& expr() const; + ::io::substrait::Expression* release_expr(); + ::io::substrait::Expression* mutable_expr(); + void set_allocated_expr(::io::substrait::Expression* expr); + private: + const ::io::substrait::Expression& _internal_expr() const; + ::io::substrait::Expression* _internal_mutable_expr(); + public: + void unsafe_arena_set_allocated_expr( + ::io::substrait::Expression* expr); + ::io::substrait::Expression* unsafe_arena_release_expr(); + + // .io.substrait.SortField.SortDirection direction = 2; + bool has_direction() const; + private: + bool _internal_has_direction() const; + public: + void clear_direction(); + ::io::substrait::SortField_SortDirection direction() const; + void set_direction(::io::substrait::SortField_SortDirection value); + private: + ::io::substrait::SortField_SortDirection _internal_direction() const; + void _internal_set_direction(::io::substrait::SortField_SortDirection value); + public: + + // uint32 comparison_function_reference = 3; + bool has_comparison_function_reference() const; + private: + bool _internal_has_comparison_function_reference() const; + public: + void clear_comparison_function_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 comparison_function_reference() const; + void set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_comparison_function_reference() const; + void _internal_set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + void clear_sort_kind(); + SortKindCase sort_kind_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.SortField) + private: + class _Internal; + void set_has_direction(); + void set_has_comparison_function_reference(); + + inline bool has_sort_kind() const; + inline void clear_has_sort_kind(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::Expression* expr_; + union SortKindUnion { + constexpr SortKindUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + int direction_; + ::PROTOBUF_NAMESPACE_ID::uint32 comparison_function_reference_; + } sort_kind_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_expression_2eproto; +}; +// ------------------------------------------------------------------- + +class AggregateFunction PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.AggregateFunction) */ { + public: + inline AggregateFunction() : AggregateFunction(nullptr) {} + ~AggregateFunction() override; + explicit constexpr AggregateFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AggregateFunction(const AggregateFunction& from); + AggregateFunction(AggregateFunction&& from) noexcept + : AggregateFunction() { + *this = ::std::move(from); + } + + inline AggregateFunction& operator=(const AggregateFunction& from) { + CopyFrom(from); + return *this; + } + inline AggregateFunction& operator=(AggregateFunction&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 AggregateFunction& default_instance() { + return *internal_default_instance(); + } + static inline const AggregateFunction* internal_default_instance() { + return reinterpret_cast( + &_AggregateFunction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 48; + + friend void swap(AggregateFunction& a, AggregateFunction& b) { + a.Swap(&b); + } + inline void Swap(AggregateFunction* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AggregateFunction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline AggregateFunction* New() const final { + return CreateMaybeMessage(nullptr); + } + + AggregateFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const AggregateFunction& from); + void MergeFrom(const AggregateFunction& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(AggregateFunction* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.AggregateFunction"; + } + protected: + explicit AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kArgsFieldNumber = 2, + kSortsFieldNumber = 3, + kOutputTypeFieldNumber = 5, + kFunctionReferenceFieldNumber = 1, + kPhaseFieldNumber = 4, + }; + // repeated .io.substrait.Expression args = 2; + int args_size() const; + private: + int _internal_args_size() const; + public: + void clear_args(); + ::io::substrait::Expression* mutable_args(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + mutable_args(); + private: + const ::io::substrait::Expression& _internal_args(int index) const; + ::io::substrait::Expression* _internal_add_args(); + public: + const ::io::substrait::Expression& args(int index) const; + ::io::substrait::Expression* add_args(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + args() const; + + // repeated .io.substrait.SortField sorts = 3; + int sorts_size() const; + private: + int _internal_sorts_size() const; + public: + void clear_sorts(); + ::io::substrait::SortField* mutable_sorts(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* + mutable_sorts(); + private: + const ::io::substrait::SortField& _internal_sorts(int index) const; + ::io::substrait::SortField* _internal_add_sorts(); + public: + const ::io::substrait::SortField& sorts(int index) const; + ::io::substrait::SortField* add_sorts(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& + sorts() const; + + // .io.substrait.Type output_type = 5; + bool has_output_type() const; + private: + bool _internal_has_output_type() const; + public: + void clear_output_type(); + const ::io::substrait::Type& output_type() const; + ::io::substrait::Type* release_output_type(); + ::io::substrait::Type* mutable_output_type(); + void set_allocated_output_type(::io::substrait::Type* output_type); + private: + const ::io::substrait::Type& _internal_output_type() const; + ::io::substrait::Type* _internal_mutable_output_type(); + public: + void unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type); + ::io::substrait::Type* unsafe_arena_release_output_type(); + + // uint32 function_reference = 1; + void clear_function_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 function_reference() const; + void set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_function_reference() const; + void _internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // .io.substrait.AggregationPhase phase = 4; + void clear_phase(); + ::io::substrait::AggregationPhase phase() const; + void set_phase(::io::substrait::AggregationPhase value); + private: + ::io::substrait::AggregationPhase _internal_phase() const; + void _internal_set_phase(::io::substrait::AggregationPhase value); + public: + + // @@protoc_insertion_point(class_scope:io.substrait.AggregateFunction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > args_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField > sorts_; + ::io::substrait::Type* output_type_; + ::PROTOBUF_NAMESPACE_ID::uint32 function_reference_; + int phase_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_expression_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Expression_Enum_Empty + +// ------------------------------------------------------------------- + +// Expression_Enum + +// string specified = 1; +inline bool Expression_Enum::_internal_has_specified() const { + return enum_kind_case() == kSpecified; +} +inline bool Expression_Enum::has_specified() const { + return _internal_has_specified(); +} +inline void Expression_Enum::set_has_specified() { + _oneof_case_[0] = kSpecified; +} +inline void Expression_Enum::clear_specified() { + if (_internal_has_specified()) { + enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_enum_kind(); + } +} +inline const std::string& Expression_Enum::specified() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Enum.specified) + return _internal_specified(); +} +template +inline void Expression_Enum::set_specified(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_specified()) { + clear_enum_kind(); + set_has_specified(); + enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Enum.specified) +} +inline std::string* Expression_Enum::mutable_specified() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Enum.specified) + return _internal_mutable_specified(); +} +inline const std::string& Expression_Enum::_internal_specified() const { + if (_internal_has_specified()) { + return enum_kind_.specified_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Enum::_internal_set_specified(const std::string& value) { + if (!_internal_has_specified()) { + clear_enum_kind(); + set_has_specified(); + enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Enum::_internal_mutable_specified() { + if (!_internal_has_specified()) { + clear_enum_kind(); + set_has_specified(); + enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return enum_kind_.specified_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Enum::release_specified() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Enum.specified) + if (_internal_has_specified()) { + clear_has_enum_kind(); + return enum_kind_.specified_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Enum::set_allocated_specified(std::string* specified) { + if (has_enum_kind()) { + clear_enum_kind(); + } + if (specified != nullptr) { + set_has_specified(); + enum_kind_.specified_.UnsafeSetDefault(specified); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(specified); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Enum.specified) +} + +// .io.substrait.Expression.Enum.Empty unspecified = 2; +inline bool Expression_Enum::_internal_has_unspecified() const { + return enum_kind_case() == kUnspecified; +} +inline bool Expression_Enum::has_unspecified() const { + return _internal_has_unspecified(); +} +inline void Expression_Enum::set_has_unspecified() { + _oneof_case_[0] = kUnspecified; +} +inline void Expression_Enum::clear_unspecified() { + if (_internal_has_unspecified()) { + if (GetArena() == nullptr) { + delete enum_kind_.unspecified_; + } + clear_has_enum_kind(); + } +} +inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::release_unspecified() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Enum.unspecified) + if (_internal_has_unspecified()) { + clear_has_enum_kind(); + ::io::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + enum_kind_.unspecified_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Enum_Empty& Expression_Enum::_internal_unspecified() const { + return _internal_has_unspecified() + ? *enum_kind_.unspecified_ + : reinterpret_cast< ::io::substrait::Expression_Enum_Empty&>(::io::substrait::_Expression_Enum_Empty_default_instance_); +} +inline const ::io::substrait::Expression_Enum_Empty& Expression_Enum::unspecified() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Enum.unspecified) + return _internal_unspecified(); +} +inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::unsafe_arena_release_unspecified() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Enum.unspecified) + if (_internal_has_unspecified()) { + clear_has_enum_kind(); + ::io::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; + enum_kind_.unspecified_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Enum::unsafe_arena_set_allocated_unspecified(::io::substrait::Expression_Enum_Empty* unspecified) { + clear_enum_kind(); + if (unspecified) { + set_has_unspecified(); + enum_kind_.unspecified_ = unspecified; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Enum.unspecified) +} +inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::_internal_mutable_unspecified() { + if (!_internal_has_unspecified()) { + clear_enum_kind(); + set_has_unspecified(); + enum_kind_.unspecified_ = CreateMaybeMessage< ::io::substrait::Expression_Enum_Empty >(GetArena()); + } + return enum_kind_.unspecified_; +} +inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::mutable_unspecified() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Enum.unspecified) + return _internal_mutable_unspecified(); +} + +inline bool Expression_Enum::has_enum_kind() const { + return enum_kind_case() != ENUM_KIND_NOT_SET; +} +inline void Expression_Enum::clear_has_enum_kind() { + _oneof_case_[0] = ENUM_KIND_NOT_SET; +} +inline Expression_Enum::EnumKindCase Expression_Enum::enum_kind_case() const { + return Expression_Enum::EnumKindCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Expression_Literal_VarChar + +// string value = 1; +inline void Expression_Literal_VarChar::clear_value() { + value_.ClearToEmpty(); +} +inline const std::string& Expression_Literal_VarChar::value() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.VarChar.value) + return _internal_value(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Expression_Literal_VarChar::set_value(ArgT0&& arg0, ArgT... args) { + + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.VarChar.value) +} +inline std::string* Expression_Literal_VarChar::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.VarChar.value) + return _internal_mutable_value(); +} +inline const std::string& Expression_Literal_VarChar::_internal_value() const { + return value_.Get(); +} +inline void Expression_Literal_VarChar::_internal_set_value(const std::string& value) { + + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal_VarChar::_internal_mutable_value() { + + return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal_VarChar::release_value() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.VarChar.value) + return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Expression_Literal_VarChar::set_allocated_value(std::string* value) { + if (value != nullptr) { + + } else { + + } + value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.VarChar.value) +} + +// uint32 length = 2; +inline void Expression_Literal_VarChar::clear_length() { + length_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_Literal_VarChar::_internal_length() const { + return length_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_Literal_VarChar::length() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.VarChar.length) + return _internal_length(); +} +inline void Expression_Literal_VarChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + length_ = value; +} +inline void Expression_Literal_VarChar::set_length(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_length(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.VarChar.length) +} + +// ------------------------------------------------------------------- + +// Expression_Literal_Decimal + +// bytes value = 1; +inline void Expression_Literal_Decimal::clear_value() { + value_.ClearToEmpty(); +} +inline const std::string& Expression_Literal_Decimal::value() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Decimal.value) + return _internal_value(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Expression_Literal_Decimal::set_value(ArgT0&& arg0, ArgT... args) { + + value_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.Decimal.value) +} +inline std::string* Expression_Literal_Decimal::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Decimal.value) + return _internal_mutable_value(); +} +inline const std::string& Expression_Literal_Decimal::_internal_value() const { + return value_.Get(); +} +inline void Expression_Literal_Decimal::_internal_set_value(const std::string& value) { + + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal_Decimal::_internal_mutable_value() { + + return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal_Decimal::release_value() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Decimal.value) + return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Expression_Literal_Decimal::set_allocated_value(std::string* value) { + if (value != nullptr) { + + } else { + + } + value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Decimal.value) +} + +// int32 precision = 2; +inline void Expression_Literal_Decimal::clear_precision() { + precision_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::_internal_precision() const { + return precision_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::precision() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Decimal.precision) + return _internal_precision(); +} +inline void Expression_Literal_Decimal::_internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { + + precision_ = value; +} +inline void Expression_Literal_Decimal::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_precision(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.Decimal.precision) +} + +// int32 scale = 3; +inline void Expression_Literal_Decimal::clear_scale() { + scale_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::_internal_scale() const { + return scale_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::scale() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Decimal.scale) + return _internal_scale(); +} +inline void Expression_Literal_Decimal::_internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { + + scale_ = value; +} +inline void Expression_Literal_Decimal::set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_scale(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.Decimal.scale) +} + +// ------------------------------------------------------------------- + +// Expression_Literal_Map_KeyValue + +// .io.substrait.Expression.Literal key = 1; +inline bool Expression_Literal_Map_KeyValue::_internal_has_key() const { + return this != internal_default_instance() && key_ != nullptr; +} +inline bool Expression_Literal_Map_KeyValue::has_key() const { + return _internal_has_key(); +} +inline void Expression_Literal_Map_KeyValue::clear_key() { + if (GetArena() == nullptr && key_ != nullptr) { + delete key_; + } + key_ = nullptr; +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_key() const { + const ::io::substrait::Expression_Literal* p = key_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_Literal_default_instance_); +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::key() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.KeyValue.key) + return _internal_key(); +} +inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_key( + ::io::substrait::Expression_Literal* key) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); + } + key_ = key; + if (key) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.key) +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_key() { + + ::io::substrait::Expression_Literal* temp = key_; + key_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.KeyValue.key) + + ::io::substrait::Expression_Literal* temp = key_; + key_ = nullptr; + return temp; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_key() { + + if (key_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); + key_ = p; + } + return key_; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.KeyValue.key) + return _internal_mutable_key(); +} +inline void Expression_Literal_Map_KeyValue::set_allocated_key(::io::substrait::Expression_Literal* key) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete key_; + } + if (key) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + if (message_arena != submessage_arena) { + key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key, submessage_arena); + } + + } else { + + } + key_ = key; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.key) +} + +// .io.substrait.Expression.Literal value = 2; +inline bool Expression_Literal_Map_KeyValue::_internal_has_value() const { + return this != internal_default_instance() && value_ != nullptr; +} +inline bool Expression_Literal_Map_KeyValue::has_value() const { + return _internal_has_value(); +} +inline void Expression_Literal_Map_KeyValue::clear_value() { + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_value() const { + const ::io::substrait::Expression_Literal* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_Literal_default_instance_); +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::value() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.KeyValue.value) + return _internal_value(); +} +inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_value( + ::io::substrait::Expression_Literal* value) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); + } + value_ = value; + if (value) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.value) +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_value() { + + ::io::substrait::Expression_Literal* temp = value_; + value_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.KeyValue.value) + + ::io::substrait::Expression_Literal* temp = value_; + value_ = nullptr; + return temp; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_value() { + + if (value_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); + value_ = p; + } + return value_; +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.KeyValue.value) + return _internal_mutable_value(); +} +inline void Expression_Literal_Map_KeyValue::set_allocated_value(::io::substrait::Expression_Literal* value) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete value_; + } + if (value) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + if (message_arena != submessage_arena) { + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); + } + + } else { + + } + value_ = value; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.value) +} + +// ------------------------------------------------------------------- + +// Expression_Literal_Map + +// repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; +inline int Expression_Literal_Map::_internal_key_values_size() const { + return key_values_.size(); +} +inline int Expression_Literal_Map::key_values_size() const { + return _internal_key_values_size(); +} +inline void Expression_Literal_Map::clear_key_values() { + key_values_.Clear(); +} +inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::mutable_key_values(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.key_values) + return key_values_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >* +Expression_Literal_Map::mutable_key_values() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.Map.key_values) + return &key_values_; +} +inline const ::io::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::_internal_key_values(int index) const { + return key_values_.Get(index); +} +inline const ::io::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::key_values(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.key_values) + return _internal_key_values(index); +} +inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::_internal_add_key_values() { + return key_values_.Add(); +} +inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::add_key_values() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.Map.key_values) + return _internal_add_key_values(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >& +Expression_Literal_Map::key_values() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.Map.key_values) + return key_values_; +} + +// .io.substrait.Type key_type = 2; +inline bool Expression_Literal_Map::_internal_has_key_type() const { + return this != internal_default_instance() && key_type_ != nullptr; +} +inline bool Expression_Literal_Map::has_key_type() const { + return _internal_has_key_type(); +} +inline const ::io::substrait::Type& Expression_Literal_Map::_internal_key_type() const { + const ::io::substrait::Type* p = key_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Expression_Literal_Map::key_type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.key_type) + return _internal_key_type(); +} +inline void Expression_Literal_Map::unsafe_arena_set_allocated_key_type( + ::io::substrait::Type* key_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_type_); + } + key_type_ = key_type; + if (key_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.key_type) +} +inline ::io::substrait::Type* Expression_Literal_Map::release_key_type() { + + ::io::substrait::Type* temp = key_type_; + key_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* Expression_Literal_Map::unsafe_arena_release_key_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.key_type) + + ::io::substrait::Type* temp = key_type_; + key_type_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Expression_Literal_Map::_internal_mutable_key_type() { + + if (key_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + key_type_ = p; + } + return key_type_; +} +inline ::io::substrait::Type* Expression_Literal_Map::mutable_key_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.key_type) + return _internal_mutable_key_type(); +} +inline void Expression_Literal_Map::set_allocated_key_type(::io::substrait::Type* key_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_type_); + } + if (key_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_type)->GetArena(); + if (message_arena != submessage_arena) { + key_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, key_type, submessage_arena); + } + + } else { + + } + key_type_ = key_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.key_type) +} + +// .io.substrait.Type value_type = 3; +inline bool Expression_Literal_Map::_internal_has_value_type() const { + return this != internal_default_instance() && value_type_ != nullptr; +} +inline bool Expression_Literal_Map::has_value_type() const { + return _internal_has_value_type(); +} +inline const ::io::substrait::Type& Expression_Literal_Map::_internal_value_type() const { + const ::io::substrait::Type* p = value_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Expression_Literal_Map::value_type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.value_type) + return _internal_value_type(); +} +inline void Expression_Literal_Map::unsafe_arena_set_allocated_value_type( + ::io::substrait::Type* value_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_type_); + } + value_type_ = value_type; + if (value_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.value_type) +} +inline ::io::substrait::Type* Expression_Literal_Map::release_value_type() { + + ::io::substrait::Type* temp = value_type_; + value_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* Expression_Literal_Map::unsafe_arena_release_value_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.value_type) + + ::io::substrait::Type* temp = value_type_; + value_type_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Expression_Literal_Map::_internal_mutable_value_type() { + + if (value_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + value_type_ = p; + } + return value_type_; +} +inline ::io::substrait::Type* Expression_Literal_Map::mutable_value_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.value_type) + return _internal_mutable_value_type(); +} +inline void Expression_Literal_Map::set_allocated_value_type(::io::substrait::Type* value_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_type_); + } + if (value_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_type)->GetArena(); + if (message_arena != submessage_arena) { + value_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value_type, submessage_arena); + } + + } else { + + } + value_type_ = value_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.value_type) +} + +// ------------------------------------------------------------------- + +// Expression_Literal_IntervalYearToMonth + +// int32 years = 1; +inline void Expression_Literal_IntervalYearToMonth::clear_years() { + years_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::_internal_years() const { + return years_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::years() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalYearToMonth.years) + return _internal_years(); +} +inline void Expression_Literal_IntervalYearToMonth::_internal_set_years(::PROTOBUF_NAMESPACE_ID::int32 value) { + + years_ = value; +} +inline void Expression_Literal_IntervalYearToMonth::set_years(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_years(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalYearToMonth.years) +} + +// int32 months = 2; +inline void Expression_Literal_IntervalYearToMonth::clear_months() { + months_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::_internal_months() const { + return months_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::months() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalYearToMonth.months) + return _internal_months(); +} +inline void Expression_Literal_IntervalYearToMonth::_internal_set_months(::PROTOBUF_NAMESPACE_ID::int32 value) { + + months_ = value; +} +inline void Expression_Literal_IntervalYearToMonth::set_months(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_months(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalYearToMonth.months) +} + +// ------------------------------------------------------------------- + +// Expression_Literal_IntervalDayToSecond + +// int32 days = 1; +inline void Expression_Literal_IntervalDayToSecond::clear_days() { + days_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::_internal_days() const { + return days_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::days() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalDayToSecond.days) + return _internal_days(); +} +inline void Expression_Literal_IntervalDayToSecond::_internal_set_days(::PROTOBUF_NAMESPACE_ID::int32 value) { + + days_ = value; +} +inline void Expression_Literal_IntervalDayToSecond::set_days(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_days(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalDayToSecond.days) +} + +// int32 seconds = 2; +inline void Expression_Literal_IntervalDayToSecond::clear_seconds() { + seconds_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::_internal_seconds() const { + return seconds_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::seconds() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalDayToSecond.seconds) + return _internal_seconds(); +} +inline void Expression_Literal_IntervalDayToSecond::_internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value) { + + seconds_ = value; +} +inline void Expression_Literal_IntervalDayToSecond::set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_seconds(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalDayToSecond.seconds) +} + +// ------------------------------------------------------------------- + +// Expression_Literal_Struct + +// repeated .io.substrait.Expression.Literal fields = 1; +inline int Expression_Literal_Struct::_internal_fields_size() const { + return fields_.size(); +} +inline int Expression_Literal_Struct::fields_size() const { + return _internal_fields_size(); +} +inline void Expression_Literal_Struct::clear_fields() { + fields_.Clear(); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::mutable_fields(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Struct.fields) + return fields_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* +Expression_Literal_Struct::mutable_fields() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.Struct.fields) + return &fields_; +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Struct::_internal_fields(int index) const { + return fields_.Get(index); +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_Struct::fields(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Struct.fields) + return _internal_fields(index); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::_internal_add_fields() { + return fields_.Add(); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::add_fields() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.Struct.fields) + return _internal_add_fields(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& +Expression_Literal_Struct::fields() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.Struct.fields) + return fields_; +} + +// ------------------------------------------------------------------- + +// Expression_Literal_List + +// repeated .io.substrait.Expression.Literal values = 1; +inline int Expression_Literal_List::_internal_values_size() const { + return values_.size(); +} +inline int Expression_Literal_List::values_size() const { + return _internal_values_size(); +} +inline void Expression_Literal_List::clear_values() { + values_.Clear(); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_List::mutable_values(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.List.values) + return values_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* +Expression_Literal_List::mutable_values() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.List.values) + return &values_; +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_List::_internal_values(int index) const { + return values_.Get(index); +} +inline const ::io::substrait::Expression_Literal& Expression_Literal_List::values(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.List.values) + return _internal_values(index); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_List::_internal_add_values() { + return values_.Add(); +} +inline ::io::substrait::Expression_Literal* Expression_Literal_List::add_values() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.List.values) + return _internal_add_values(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& +Expression_Literal_List::values() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.List.values) + return values_; +} + +// .io.substrait.Type element_type = 2; +inline bool Expression_Literal_List::_internal_has_element_type() const { + return this != internal_default_instance() && element_type_ != nullptr; +} +inline bool Expression_Literal_List::has_element_type() const { + return _internal_has_element_type(); +} +inline const ::io::substrait::Type& Expression_Literal_List::_internal_element_type() const { + const ::io::substrait::Type* p = element_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); +} +inline const ::io::substrait::Type& Expression_Literal_List::element_type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.List.element_type) + return _internal_element_type(); +} +inline void Expression_Literal_List::unsafe_arena_set_allocated_element_type( + ::io::substrait::Type* element_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(element_type_); + } + element_type_ = element_type; + if (element_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.List.element_type) +} +inline ::io::substrait::Type* Expression_Literal_List::release_element_type() { + + ::io::substrait::Type* temp = element_type_; + element_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type* Expression_Literal_List::unsafe_arena_release_element_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.List.element_type) + + ::io::substrait::Type* temp = element_type_; + element_type_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Expression_Literal_List::_internal_mutable_element_type() { + + if (element_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + element_type_ = p; + } + return element_type_; +} +inline ::io::substrait::Type* Expression_Literal_List::mutable_element_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.List.element_type) + return _internal_mutable_element_type(); +} +inline void Expression_Literal_List::set_allocated_element_type(::io::substrait::Type* element_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(element_type_); + } + if (element_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(element_type)->GetArena(); + if (message_arena != submessage_arena) { + element_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, element_type, submessage_arena); + } + + } else { + + } + element_type_ = element_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.List.element_type) +} + +// ------------------------------------------------------------------- + +// Expression_Literal + +// bool boolean = 1; +inline bool Expression_Literal::_internal_has_boolean() const { + return literal_type_case() == kBoolean; +} +inline bool Expression_Literal::has_boolean() const { + return _internal_has_boolean(); +} +inline void Expression_Literal::set_has_boolean() { + _oneof_case_[0] = kBoolean; +} +inline void Expression_Literal::clear_boolean() { + if (_internal_has_boolean()) { + literal_type_.boolean_ = false; + clear_has_literal_type(); + } +} +inline bool Expression_Literal::_internal_boolean() const { + if (_internal_has_boolean()) { + return literal_type_.boolean_; + } + return false; +} +inline void Expression_Literal::_internal_set_boolean(bool value) { + if (!_internal_has_boolean()) { + clear_literal_type(); + set_has_boolean(); + } + literal_type_.boolean_ = value; +} +inline bool Expression_Literal::boolean() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.boolean) + return _internal_boolean(); +} +inline void Expression_Literal::set_boolean(bool value) { + _internal_set_boolean(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.boolean) +} + +// int32 i8 = 2; +inline bool Expression_Literal::_internal_has_i8() const { + return literal_type_case() == kI8; +} +inline bool Expression_Literal::has_i8() const { + return _internal_has_i8(); +} +inline void Expression_Literal::set_has_i8() { + _oneof_case_[0] = kI8; +} +inline void Expression_Literal::clear_i8() { + if (_internal_has_i8()) { + literal_type_.i8_ = 0; + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i8() const { + if (_internal_has_i8()) { + return literal_type_.i8_; + } + return 0; +} +inline void Expression_Literal::_internal_set_i8(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!_internal_has_i8()) { + clear_literal_type(); + set_has_i8(); + } + literal_type_.i8_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i8() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i8) + return _internal_i8(); +} +inline void Expression_Literal::set_i8(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_i8(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i8) +} + +// int32 i16 = 3; +inline bool Expression_Literal::_internal_has_i16() const { + return literal_type_case() == kI16; +} +inline bool Expression_Literal::has_i16() const { + return _internal_has_i16(); +} +inline void Expression_Literal::set_has_i16() { + _oneof_case_[0] = kI16; +} +inline void Expression_Literal::clear_i16() { + if (_internal_has_i16()) { + literal_type_.i16_ = 0; + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i16() const { + if (_internal_has_i16()) { + return literal_type_.i16_; + } + return 0; +} +inline void Expression_Literal::_internal_set_i16(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!_internal_has_i16()) { + clear_literal_type(); + set_has_i16(); + } + literal_type_.i16_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i16() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i16) + return _internal_i16(); +} +inline void Expression_Literal::set_i16(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_i16(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i16) +} + +// int32 i32 = 5; +inline bool Expression_Literal::_internal_has_i32() const { + return literal_type_case() == kI32; +} +inline bool Expression_Literal::has_i32() const { + return _internal_has_i32(); +} +inline void Expression_Literal::set_has_i32() { + _oneof_case_[0] = kI32; +} +inline void Expression_Literal::clear_i32() { + if (_internal_has_i32()) { + literal_type_.i32_ = 0; + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i32() const { + if (_internal_has_i32()) { + return literal_type_.i32_; + } + return 0; +} +inline void Expression_Literal::_internal_set_i32(::PROTOBUF_NAMESPACE_ID::int32 value) { + if (!_internal_has_i32()) { + clear_literal_type(); + set_has_i32(); + } + literal_type_.i32_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i32() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i32) + return _internal_i32(); +} +inline void Expression_Literal::set_i32(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_i32(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i32) +} + +// int64 i64 = 7; +inline bool Expression_Literal::_internal_has_i64() const { + return literal_type_case() == kI64; +} +inline bool Expression_Literal::has_i64() const { + return _internal_has_i64(); +} +inline void Expression_Literal::set_has_i64() { + _oneof_case_[0] = kI64; +} +inline void Expression_Literal::clear_i64() { + if (_internal_has_i64()) { + literal_type_.i64_ = PROTOBUF_LONGLONG(0); + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_i64() const { + if (_internal_has_i64()) { + return literal_type_.i64_; + } + return PROTOBUF_LONGLONG(0); +} +inline void Expression_Literal::_internal_set_i64(::PROTOBUF_NAMESPACE_ID::int64 value) { + if (!_internal_has_i64()) { + clear_literal_type(); + set_has_i64(); + } + literal_type_.i64_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::i64() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i64) + return _internal_i64(); +} +inline void Expression_Literal::set_i64(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_i64(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i64) +} + +// float fp32 = 10; +inline bool Expression_Literal::_internal_has_fp32() const { + return literal_type_case() == kFp32; +} +inline bool Expression_Literal::has_fp32() const { + return _internal_has_fp32(); +} +inline void Expression_Literal::set_has_fp32() { + _oneof_case_[0] = kFp32; +} +inline void Expression_Literal::clear_fp32() { + if (_internal_has_fp32()) { + literal_type_.fp32_ = 0; + clear_has_literal_type(); + } +} +inline float Expression_Literal::_internal_fp32() const { + if (_internal_has_fp32()) { + return literal_type_.fp32_; + } + return 0; +} +inline void Expression_Literal::_internal_set_fp32(float value) { + if (!_internal_has_fp32()) { + clear_literal_type(); + set_has_fp32(); + } + literal_type_.fp32_ = value; +} +inline float Expression_Literal::fp32() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fp32) + return _internal_fp32(); +} +inline void Expression_Literal::set_fp32(float value) { + _internal_set_fp32(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fp32) +} + +// double fp64 = 11; +inline bool Expression_Literal::_internal_has_fp64() const { + return literal_type_case() == kFp64; +} +inline bool Expression_Literal::has_fp64() const { + return _internal_has_fp64(); +} +inline void Expression_Literal::set_has_fp64() { + _oneof_case_[0] = kFp64; +} +inline void Expression_Literal::clear_fp64() { + if (_internal_has_fp64()) { + literal_type_.fp64_ = 0; + clear_has_literal_type(); + } +} +inline double Expression_Literal::_internal_fp64() const { + if (_internal_has_fp64()) { + return literal_type_.fp64_; + } + return 0; +} +inline void Expression_Literal::_internal_set_fp64(double value) { + if (!_internal_has_fp64()) { + clear_literal_type(); + set_has_fp64(); + } + literal_type_.fp64_ = value; +} +inline double Expression_Literal::fp64() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fp64) + return _internal_fp64(); +} +inline void Expression_Literal::set_fp64(double value) { + _internal_set_fp64(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fp64) +} + +// string string = 12; +inline bool Expression_Literal::_internal_has_string() const { + return literal_type_case() == kString; +} +inline bool Expression_Literal::has_string() const { + return _internal_has_string(); +} +inline void Expression_Literal::set_has_string() { + _oneof_case_[0] = kString; +} +inline void Expression_Literal::clear_string() { + if (_internal_has_string()) { + literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } +} +inline const std::string& Expression_Literal::string() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.string) + return _internal_string(); +} +template +inline void Expression_Literal::set_string(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_string()) { + clear_literal_type(); + set_has_string(); + literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.string) +} +inline std::string* Expression_Literal::mutable_string() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.string) + return _internal_mutable_string(); +} +inline const std::string& Expression_Literal::_internal_string() const { + if (_internal_has_string()) { + return literal_type_.string_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Literal::_internal_set_string(const std::string& value) { + if (!_internal_has_string()) { + clear_literal_type(); + set_has_string(); + literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal::_internal_mutable_string() { + if (!_internal_has_string()) { + clear_literal_type(); + set_has_string(); + literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.string_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal::release_string() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.string) + if (_internal_has_string()) { + clear_has_literal_type(); + return literal_type_.string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Literal::set_allocated_string(std::string* string) { + if (has_literal_type()) { + clear_literal_type(); + } + if (string != nullptr) { + set_has_string(); + literal_type_.string_.UnsafeSetDefault(string); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(string); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.string) +} + +// bytes binary = 13; +inline bool Expression_Literal::_internal_has_binary() const { + return literal_type_case() == kBinary; +} +inline bool Expression_Literal::has_binary() const { + return _internal_has_binary(); +} +inline void Expression_Literal::set_has_binary() { + _oneof_case_[0] = kBinary; +} +inline void Expression_Literal::clear_binary() { + if (_internal_has_binary()) { + literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } +} +inline const std::string& Expression_Literal::binary() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.binary) + return _internal_binary(); +} +template +inline void Expression_Literal::set_binary(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_binary()) { + clear_literal_type(); + set_has_binary(); + literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.binary) +} +inline std::string* Expression_Literal::mutable_binary() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.binary) + return _internal_mutable_binary(); +} +inline const std::string& Expression_Literal::_internal_binary() const { + if (_internal_has_binary()) { + return literal_type_.binary_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Literal::_internal_set_binary(const std::string& value) { + if (!_internal_has_binary()) { + clear_literal_type(); + set_has_binary(); + literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal::_internal_mutable_binary() { + if (!_internal_has_binary()) { + clear_literal_type(); + set_has_binary(); + literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.binary_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal::release_binary() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.binary) + if (_internal_has_binary()) { + clear_has_literal_type(); + return literal_type_.binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Literal::set_allocated_binary(std::string* binary) { + if (has_literal_type()) { + clear_literal_type(); + } + if (binary != nullptr) { + set_has_binary(); + literal_type_.binary_.UnsafeSetDefault(binary); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(binary); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.binary) +} + +// int64 timestamp = 14; +inline bool Expression_Literal::_internal_has_timestamp() const { + return literal_type_case() == kTimestamp; +} +inline bool Expression_Literal::has_timestamp() const { + return _internal_has_timestamp(); +} +inline void Expression_Literal::set_has_timestamp() { + _oneof_case_[0] = kTimestamp; +} +inline void Expression_Literal::clear_timestamp() { + if (_internal_has_timestamp()) { + literal_type_.timestamp_ = PROTOBUF_LONGLONG(0); + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_timestamp() const { + if (_internal_has_timestamp()) { + return literal_type_.timestamp_; + } + return PROTOBUF_LONGLONG(0); +} +inline void Expression_Literal::_internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value) { + if (!_internal_has_timestamp()) { + clear_literal_type(); + set_has_timestamp(); + } + literal_type_.timestamp_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::timestamp() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.timestamp) + return _internal_timestamp(); +} +inline void Expression_Literal::set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_timestamp(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.timestamp) +} + +// int64 date = 16; +inline bool Expression_Literal::_internal_has_date() const { + return literal_type_case() == kDate; +} +inline bool Expression_Literal::has_date() const { + return _internal_has_date(); +} +inline void Expression_Literal::set_has_date() { + _oneof_case_[0] = kDate; +} +inline void Expression_Literal::clear_date() { + if (_internal_has_date()) { + literal_type_.date_ = PROTOBUF_LONGLONG(0); + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_date() const { + if (_internal_has_date()) { + return literal_type_.date_; + } + return PROTOBUF_LONGLONG(0); +} +inline void Expression_Literal::_internal_set_date(::PROTOBUF_NAMESPACE_ID::int64 value) { + if (!_internal_has_date()) { + clear_literal_type(); + set_has_date(); + } + literal_type_.date_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::date() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.date) + return _internal_date(); +} +inline void Expression_Literal::set_date(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_date(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.date) +} + +// int64 time = 17; +inline bool Expression_Literal::_internal_has_time() const { + return literal_type_case() == kTime; +} +inline bool Expression_Literal::has_time() const { + return _internal_has_time(); +} +inline void Expression_Literal::set_has_time() { + _oneof_case_[0] = kTime; +} +inline void Expression_Literal::clear_time() { + if (_internal_has_time()) { + literal_type_.time_ = PROTOBUF_LONGLONG(0); + clear_has_literal_type(); + } +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_time() const { + if (_internal_has_time()) { + return literal_type_.time_; + } + return PROTOBUF_LONGLONG(0); +} +inline void Expression_Literal::_internal_set_time(::PROTOBUF_NAMESPACE_ID::int64 value) { + if (!_internal_has_time()) { + clear_literal_type(); + set_has_time(); + } + literal_type_.time_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::time() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.time) + return _internal_time(); +} +inline void Expression_Literal::set_time(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_time(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.time) +} + +// .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; +inline bool Expression_Literal::_internal_has_interval_year_to_month() const { + return literal_type_case() == kIntervalYearToMonth; +} +inline bool Expression_Literal::has_interval_year_to_month() const { + return _internal_has_interval_year_to_month(); +} +inline void Expression_Literal::set_has_interval_year_to_month() { + _oneof_case_[0] = kIntervalYearToMonth; +} +inline void Expression_Literal::clear_interval_year_to_month() { + if (_internal_has_interval_year_to_month()) { + if (GetArena() == nullptr) { + delete literal_type_.interval_year_to_month_; + } + clear_has_literal_type(); + } +} +inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::release_interval_year_to_month() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.interval_year_to_month) + if (_internal_has_interval_year_to_month()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.interval_year_to_month_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::_internal_interval_year_to_month() const { + return _internal_has_interval_year_to_month() + ? *literal_type_.interval_year_to_month_ + : reinterpret_cast< ::io::substrait::Expression_Literal_IntervalYearToMonth&>(::io::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_); +} +inline const ::io::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::interval_year_to_month() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.interval_year_to_month) + return _internal_interval_year_to_month(); +} +inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::unsafe_arena_release_interval_year_to_month() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.interval_year_to_month) + if (_internal_has_interval_year_to_month()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; + literal_type_.interval_year_to_month_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_interval_year_to_month(::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { + clear_literal_type(); + if (interval_year_to_month) { + set_has_interval_year_to_month(); + literal_type_.interval_year_to_month_ = interval_year_to_month; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.interval_year_to_month) +} +inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::_internal_mutable_interval_year_to_month() { + if (!_internal_has_interval_year_to_month()) { + clear_literal_type(); + set_has_interval_year_to_month(); + literal_type_.interval_year_to_month_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalYearToMonth >(GetArena()); + } + return literal_type_.interval_year_to_month_; +} +inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::mutable_interval_year_to_month() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.interval_year_to_month) + return _internal_mutable_interval_year_to_month(); +} + +// .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; +inline bool Expression_Literal::_internal_has_interval_day_to_second() const { + return literal_type_case() == kIntervalDayToSecond; +} +inline bool Expression_Literal::has_interval_day_to_second() const { + return _internal_has_interval_day_to_second(); +} +inline void Expression_Literal::set_has_interval_day_to_second() { + _oneof_case_[0] = kIntervalDayToSecond; +} +inline void Expression_Literal::clear_interval_day_to_second() { + if (_internal_has_interval_day_to_second()) { + if (GetArena() == nullptr) { + delete literal_type_.interval_day_to_second_; + } + clear_has_literal_type(); + } +} +inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::release_interval_day_to_second() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.interval_day_to_second) + if (_internal_has_interval_day_to_second()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.interval_day_to_second_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::_internal_interval_day_to_second() const { + return _internal_has_interval_day_to_second() + ? *literal_type_.interval_day_to_second_ + : reinterpret_cast< ::io::substrait::Expression_Literal_IntervalDayToSecond&>(::io::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_); +} +inline const ::io::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::interval_day_to_second() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.interval_day_to_second) + return _internal_interval_day_to_second(); +} +inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::unsafe_arena_release_interval_day_to_second() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.interval_day_to_second) + if (_internal_has_interval_day_to_second()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; + literal_type_.interval_day_to_second_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_interval_day_to_second(::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { + clear_literal_type(); + if (interval_day_to_second) { + set_has_interval_day_to_second(); + literal_type_.interval_day_to_second_ = interval_day_to_second; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.interval_day_to_second) +} +inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::_internal_mutable_interval_day_to_second() { + if (!_internal_has_interval_day_to_second()) { + clear_literal_type(); + set_has_interval_day_to_second(); + literal_type_.interval_day_to_second_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalDayToSecond >(GetArena()); + } + return literal_type_.interval_day_to_second_; +} +inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::mutable_interval_day_to_second() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.interval_day_to_second) + return _internal_mutable_interval_day_to_second(); +} + +// string fixed_char = 21; +inline bool Expression_Literal::_internal_has_fixed_char() const { + return literal_type_case() == kFixedChar; +} +inline bool Expression_Literal::has_fixed_char() const { + return _internal_has_fixed_char(); +} +inline void Expression_Literal::set_has_fixed_char() { + _oneof_case_[0] = kFixedChar; +} +inline void Expression_Literal::clear_fixed_char() { + if (_internal_has_fixed_char()) { + literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } +} +inline const std::string& Expression_Literal::fixed_char() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fixed_char) + return _internal_fixed_char(); +} +template +inline void Expression_Literal::set_fixed_char(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_fixed_char()) { + clear_literal_type(); + set_has_fixed_char(); + literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fixed_char) +} +inline std::string* Expression_Literal::mutable_fixed_char() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.fixed_char) + return _internal_mutable_fixed_char(); +} +inline const std::string& Expression_Literal::_internal_fixed_char() const { + if (_internal_has_fixed_char()) { + return literal_type_.fixed_char_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void Expression_Literal::_internal_set_fixed_char(const std::string& value) { + if (!_internal_has_fixed_char()) { + clear_literal_type(); + set_has_fixed_char(); + literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_Literal::_internal_mutable_fixed_char() { + if (!_internal_has_fixed_char()) { + clear_literal_type(); + set_has_fixed_char(); + literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.fixed_char_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_Literal::release_fixed_char() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.fixed_char) + if (_internal_has_fixed_char()) { + clear_has_literal_type(); + return literal_type_.fixed_char_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void Expression_Literal::set_allocated_fixed_char(std::string* fixed_char) { + if (has_literal_type()) { + clear_literal_type(); + } + if (fixed_char != nullptr) { + set_has_fixed_char(); + literal_type_.fixed_char_.UnsafeSetDefault(fixed_char); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(fixed_char); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.fixed_char) +} + +// .io.substrait.Expression.Literal.VarChar var_char = 22; +inline bool Expression_Literal::_internal_has_var_char() const { + return literal_type_case() == kVarChar; +} +inline bool Expression_Literal::has_var_char() const { + return _internal_has_var_char(); +} +inline void Expression_Literal::set_has_var_char() { + _oneof_case_[0] = kVarChar; +} +inline void Expression_Literal::clear_var_char() { + if (_internal_has_var_char()) { + if (GetArena() == nullptr) { + delete literal_type_.var_char_; + } + clear_has_literal_type(); + } +} +inline ::io::substrait::Expression_Literal_VarChar* Expression_Literal::release_var_char() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.var_char) + if (_internal_has_var_char()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.var_char_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Expression_Literal_VarChar& Expression_Literal::_internal_var_char() const { + return _internal_has_var_char() + ? *literal_type_.var_char_ + : reinterpret_cast< ::io::substrait::Expression_Literal_VarChar&>(::io::substrait::_Expression_Literal_VarChar_default_instance_); +} +inline const ::io::substrait::Expression_Literal_VarChar& Expression_Literal::var_char() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.var_char) + return _internal_var_char(); +} +inline ::io::substrait::Expression_Literal_VarChar* Expression_Literal::unsafe_arena_release_var_char() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.var_char) + if (_internal_has_var_char()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_; + literal_type_.var_char_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_var_char(::io::substrait::Expression_Literal_VarChar* var_char) { + clear_literal_type(); + if (var_char) { + set_has_var_char(); + literal_type_.var_char_ = var_char; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.var_char) +} +inline ::io::substrait::Expression_Literal_VarChar* Expression_Literal::_internal_mutable_var_char() { + if (!_internal_has_var_char()) { + clear_literal_type(); + set_has_var_char(); + literal_type_.var_char_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_VarChar >(GetArena()); + } + return literal_type_.var_char_; +} +inline ::io::substrait::Expression_Literal_VarChar* Expression_Literal::mutable_var_char() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.var_char) + return _internal_mutable_var_char(); +} -// string specified = 1; -inline bool Expression_Enum::_internal_has_specified() const { - return enum_kind_case() == kSpecified; +// bytes fixed_binary = 23; +inline bool Expression_Literal::_internal_has_fixed_binary() const { + return literal_type_case() == kFixedBinary; } -inline bool Expression_Enum::has_specified() const { - return _internal_has_specified(); +inline bool Expression_Literal::has_fixed_binary() const { + return _internal_has_fixed_binary(); } -inline void Expression_Enum::set_has_specified() { - _oneof_case_[0] = kSpecified; +inline void Expression_Literal::set_has_fixed_binary() { + _oneof_case_[0] = kFixedBinary; } -inline void Expression_Enum::clear_specified() { - if (_internal_has_specified()) { - enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - clear_has_enum_kind(); +inline void Expression_Literal::clear_fixed_binary() { + if (_internal_has_fixed_binary()) { + literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); } } -inline const std::string& Expression_Enum::specified() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Enum.specified) - return _internal_specified(); +inline const std::string& Expression_Literal::fixed_binary() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fixed_binary) + return _internal_fixed_binary(); } template -inline void Expression_Enum::set_specified(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_specified()) { - clear_enum_kind(); - set_has_specified(); - enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline void Expression_Literal::set_fixed_binary(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_fixed_binary()) { + clear_literal_type(); + set_has_fixed_binary(); + literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Enum.specified) + literal_type_.fixed_binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fixed_binary) } -inline std::string* Expression_Enum::mutable_specified() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Enum.specified) - return _internal_mutable_specified(); +inline std::string* Expression_Literal::mutable_fixed_binary() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.fixed_binary) + return _internal_mutable_fixed_binary(); } -inline const std::string& Expression_Enum::_internal_specified() const { - if (_internal_has_specified()) { - return enum_kind_.specified_.Get(); +inline const std::string& Expression_Literal::_internal_fixed_binary() const { + if (_internal_has_fixed_binary()) { + return literal_type_.fixed_binary_.Get(); } return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } -inline void Expression_Enum::_internal_set_specified(const std::string& value) { - if (!_internal_has_specified()) { - clear_enum_kind(); - set_has_specified(); - enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline void Expression_Literal::_internal_set_fixed_binary(const std::string& value) { + if (!_internal_has_fixed_binary()) { + clear_literal_type(); + set_has_fixed_binary(); + literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + literal_type_.fixed_binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline std::string* Expression_Enum::_internal_mutable_specified() { - if (!_internal_has_specified()) { - clear_enum_kind(); - set_has_specified(); - enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline std::string* Expression_Literal::_internal_mutable_fixed_binary() { + if (!_internal_has_fixed_binary()) { + clear_literal_type(); + set_has_fixed_binary(); + literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - return enum_kind_.specified_.Mutable( + return literal_type_.fixed_binary_.Mutable( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* Expression_Enum::release_specified() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Enum.specified) - if (_internal_has_specified()) { - clear_has_enum_kind(); - return enum_kind_.specified_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline std::string* Expression_Literal::release_fixed_binary() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.fixed_binary) + if (_internal_has_fixed_binary()) { + clear_has_literal_type(); + return literal_type_.fixed_binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } else { return nullptr; } } -inline void Expression_Enum::set_allocated_specified(std::string* specified) { - if (has_enum_kind()) { - clear_enum_kind(); +inline void Expression_Literal::set_allocated_fixed_binary(std::string* fixed_binary) { + if (has_literal_type()) { + clear_literal_type(); } - if (specified != nullptr) { - set_has_specified(); - enum_kind_.specified_.UnsafeSetDefault(specified); + if (fixed_binary != nullptr) { + set_has_fixed_binary(); + literal_type_.fixed_binary_.UnsafeSetDefault(fixed_binary); ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); if (arena != nullptr) { - arena->Own(specified); + arena->Own(fixed_binary); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Enum.specified) + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.fixed_binary) } -// .io.substrait.Expression.Enum.Empty unspecified = 2; -inline bool Expression_Enum::_internal_has_unspecified() const { - return enum_kind_case() == kUnspecified; +// .io.substrait.Expression.Literal.Decimal decimal = 24; +inline bool Expression_Literal::_internal_has_decimal() const { + return literal_type_case() == kDecimal; } -inline bool Expression_Enum::has_unspecified() const { - return _internal_has_unspecified(); +inline bool Expression_Literal::has_decimal() const { + return _internal_has_decimal(); } -inline void Expression_Enum::set_has_unspecified() { - _oneof_case_[0] = kUnspecified; +inline void Expression_Literal::set_has_decimal() { + _oneof_case_[0] = kDecimal; } -inline void Expression_Enum::clear_unspecified() { - if (_internal_has_unspecified()) { +inline void Expression_Literal::clear_decimal() { + if (_internal_has_decimal()) { if (GetArena() == nullptr) { - delete enum_kind_.unspecified_; + delete literal_type_.decimal_; } - clear_has_enum_kind(); + clear_has_literal_type(); } } -inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::release_unspecified() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Enum.unspecified) - if (_internal_has_unspecified()) { - clear_has_enum_kind(); - ::io::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; +inline ::io::substrait::Expression_Literal_Decimal* Expression_Literal::release_decimal() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.decimal) + if (_internal_has_decimal()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - enum_kind_.unspecified_ = nullptr; + literal_type_.decimal_ = nullptr; return temp; } else { return nullptr; - } -} -inline const ::io::substrait::Expression_Enum_Empty& Expression_Enum::_internal_unspecified() const { - return _internal_has_unspecified() - ? *enum_kind_.unspecified_ - : reinterpret_cast< ::io::substrait::Expression_Enum_Empty&>(::io::substrait::_Expression_Enum_Empty_default_instance_); + } } -inline const ::io::substrait::Expression_Enum_Empty& Expression_Enum::unspecified() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Enum.unspecified) - return _internal_unspecified(); +inline const ::io::substrait::Expression_Literal_Decimal& Expression_Literal::_internal_decimal() const { + return _internal_has_decimal() + ? *literal_type_.decimal_ + : reinterpret_cast< ::io::substrait::Expression_Literal_Decimal&>(::io::substrait::_Expression_Literal_Decimal_default_instance_); } -inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::unsafe_arena_release_unspecified() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Enum.unspecified) - if (_internal_has_unspecified()) { - clear_has_enum_kind(); - ::io::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; - enum_kind_.unspecified_ = nullptr; +inline const ::io::substrait::Expression_Literal_Decimal& Expression_Literal::decimal() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.decimal) + return _internal_decimal(); +} +inline ::io::substrait::Expression_Literal_Decimal* Expression_Literal::unsafe_arena_release_decimal() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.decimal) + if (_internal_has_decimal()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_; + literal_type_.decimal_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_Enum::unsafe_arena_set_allocated_unspecified(::io::substrait::Expression_Enum_Empty* unspecified) { - clear_enum_kind(); - if (unspecified) { - set_has_unspecified(); - enum_kind_.unspecified_ = unspecified; +inline void Expression_Literal::unsafe_arena_set_allocated_decimal(::io::substrait::Expression_Literal_Decimal* decimal) { + clear_literal_type(); + if (decimal) { + set_has_decimal(); + literal_type_.decimal_ = decimal; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Enum.unspecified) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.decimal) } -inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::_internal_mutable_unspecified() { - if (!_internal_has_unspecified()) { - clear_enum_kind(); - set_has_unspecified(); - enum_kind_.unspecified_ = CreateMaybeMessage< ::io::substrait::Expression_Enum_Empty >(GetArena()); +inline ::io::substrait::Expression_Literal_Decimal* Expression_Literal::_internal_mutable_decimal() { + if (!_internal_has_decimal()) { + clear_literal_type(); + set_has_decimal(); + literal_type_.decimal_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_Decimal >(GetArena()); } - return enum_kind_.unspecified_; + return literal_type_.decimal_; } -inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::mutable_unspecified() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Enum.unspecified) - return _internal_mutable_unspecified(); +inline ::io::substrait::Expression_Literal_Decimal* Expression_Literal::mutable_decimal() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.decimal) + return _internal_mutable_decimal(); } -inline bool Expression_Enum::has_enum_kind() const { - return enum_kind_case() != ENUM_KIND_NOT_SET; -} -inline void Expression_Enum::clear_has_enum_kind() { - _oneof_case_[0] = ENUM_KIND_NOT_SET; +// .io.substrait.Expression.Literal.Struct struct = 25; +inline bool Expression_Literal::_internal_has_struct_() const { + return literal_type_case() == kStruct; } -inline Expression_Enum::EnumKindCase Expression_Enum::enum_kind_case() const { - return Expression_Enum::EnumKindCase(_oneof_case_[0]); +inline bool Expression_Literal::has_struct_() const { + return _internal_has_struct_(); } -// ------------------------------------------------------------------- - -// Expression_Literal_Map_KeyValue - -// .io.substrait.Expression.Literal key = 1; -inline bool Expression_Literal_Map_KeyValue::_internal_has_key() const { - return this != internal_default_instance() && key_ != nullptr; +inline void Expression_Literal::set_has_struct_() { + _oneof_case_[0] = kStruct; } -inline bool Expression_Literal_Map_KeyValue::has_key() const { - return _internal_has_key(); +inline void Expression_Literal::clear_struct_() { + if (_internal_has_struct_()) { + if (GetArena() == nullptr) { + delete literal_type_.struct__; + } + clear_has_literal_type(); + } } -inline void Expression_Literal_Map_KeyValue::clear_key() { - if (GetArena() == nullptr && key_ != nullptr) { - delete key_; +inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.struct) + if (_internal_has_struct_()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.struct__ = nullptr; + return temp; + } else { + return nullptr; } - key_ = nullptr; } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_key() const { - const ::io::substrait::Expression_Literal* p = key_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_Literal_default_instance_); +inline const ::io::substrait::Expression_Literal_Struct& Expression_Literal::_internal_struct_() const { + return _internal_has_struct_() + ? *literal_type_.struct__ + : reinterpret_cast< ::io::substrait::Expression_Literal_Struct&>(::io::substrait::_Expression_Literal_Struct_default_instance_); } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::key() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.KeyValue.key) - return _internal_key(); +inline const ::io::substrait::Expression_Literal_Struct& Expression_Literal::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.struct) + return _internal_struct_(); } -inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_key( - ::io::substrait::Expression_Literal* key) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); - } - key_ = key; - if (key) { - +inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.struct) + if (_internal_has_struct_()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; + literal_type_.struct__ = nullptr; + return temp; } else { - + return nullptr; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.key) } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_key() { - - ::io::substrait::Expression_Literal* temp = key_; - key_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); +inline void Expression_Literal::unsafe_arena_set_allocated_struct_(::io::substrait::Expression_Literal_Struct* struct_) { + clear_literal_type(); + if (struct_) { + set_has_struct_(); + literal_type_.struct__ = struct_; } - return temp; -} -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.KeyValue.key) - - ::io::substrait::Expression_Literal* temp = key_; - key_ = nullptr; - return temp; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.struct) } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_key() { - - if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); - key_ = p; +inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::_internal_mutable_struct_() { + if (!_internal_has_struct_()) { + clear_literal_type(); + set_has_struct_(); + literal_type_.struct__ = CreateMaybeMessage< ::io::substrait::Expression_Literal_Struct >(GetArena()); } - return key_; -} -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.KeyValue.key) - return _internal_mutable_key(); + return literal_type_.struct__; } -inline void Expression_Literal_Map_KeyValue::set_allocated_key(::io::substrait::Expression_Literal* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - - } else { - - } - key_ = key; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.key) +inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.struct) + return _internal_mutable_struct_(); } -// .io.substrait.Expression.Literal value = 2; -inline bool Expression_Literal_Map_KeyValue::_internal_has_value() const { - return this != internal_default_instance() && value_ != nullptr; -} -inline bool Expression_Literal_Map_KeyValue::has_value() const { - return _internal_has_value(); -} -inline void Expression_Literal_Map_KeyValue::clear_value() { - if (GetArena() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; +// .io.substrait.Expression.Literal.Map map = 26; +inline bool Expression_Literal::_internal_has_map() const { + return literal_type_case() == kMap; } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_value() const { - const ::io::substrait::Expression_Literal* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_Literal_default_instance_); +inline bool Expression_Literal::has_map() const { + return _internal_has_map(); } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::value() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.KeyValue.value) - return _internal_value(); +inline void Expression_Literal::set_has_map() { + _oneof_case_[0] = kMap; } -inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_value( - ::io::substrait::Expression_Literal* value) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); +inline void Expression_Literal::clear_map() { + if (_internal_has_map()) { + if (GetArena() == nullptr) { + delete literal_type_.map_; + } + clear_has_literal_type(); } - value_ = value; - if (value) { - +} +inline ::io::substrait::Expression_Literal_Map* Expression_Literal::release_map() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.map) + if (_internal_has_map()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_Map* temp = literal_type_.map_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.map_ = nullptr; + return temp; } else { - + return nullptr; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.value) } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_value() { - - ::io::substrait::Expression_Literal* temp = value_; - value_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline const ::io::substrait::Expression_Literal_Map& Expression_Literal::_internal_map() const { + return _internal_has_map() + ? *literal_type_.map_ + : reinterpret_cast< ::io::substrait::Expression_Literal_Map&>(::io::substrait::_Expression_Literal_Map_default_instance_); } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.KeyValue.value) - - ::io::substrait::Expression_Literal* temp = value_; - value_ = nullptr; - return temp; +inline const ::io::substrait::Expression_Literal_Map& Expression_Literal::map() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.map) + return _internal_map(); } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_value() { - - if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); - value_ = p; +inline ::io::substrait::Expression_Literal_Map* Expression_Literal::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.map) + if (_internal_has_map()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_Map* temp = literal_type_.map_; + literal_type_.map_ = nullptr; + return temp; + } else { + return nullptr; } - return value_; -} -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.KeyValue.value) - return _internal_mutable_value(); } -inline void Expression_Literal_Map_KeyValue::set_allocated_value(::io::substrait::Expression_Literal* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete value_; +inline void Expression_Literal::unsafe_arena_set_allocated_map(::io::substrait::Expression_Literal_Map* map) { + clear_literal_type(); + if (map) { + set_has_map(); + literal_type_.map_ = map; } - if (value) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); - if (message_arena != submessage_arena) { - value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value, submessage_arena); - } - - } else { - + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.map) +} +inline ::io::substrait::Expression_Literal_Map* Expression_Literal::_internal_mutable_map() { + if (!_internal_has_map()) { + clear_literal_type(); + set_has_map(); + literal_type_.map_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_Map >(GetArena()); } - value_ = value; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.value) + return literal_type_.map_; +} +inline ::io::substrait::Expression_Literal_Map* Expression_Literal::mutable_map() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.map) + return _internal_mutable_map(); } -// ------------------------------------------------------------------- - -// Expression_Literal_Map - -// repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; -inline int Expression_Literal_Map::_internal_key_values_size() const { - return key_values_.size(); +// int64 timestamp_tz = 27; +inline bool Expression_Literal::_internal_has_timestamp_tz() const { + return literal_type_case() == kTimestampTz; } -inline int Expression_Literal_Map::key_values_size() const { - return _internal_key_values_size(); +inline bool Expression_Literal::has_timestamp_tz() const { + return _internal_has_timestamp_tz(); } -inline void Expression_Literal_Map::clear_key_values() { - key_values_.Clear(); +inline void Expression_Literal::set_has_timestamp_tz() { + _oneof_case_[0] = kTimestampTz; } -inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::mutable_key_values(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.key_values) - return key_values_.Mutable(index); +inline void Expression_Literal::clear_timestamp_tz() { + if (_internal_has_timestamp_tz()) { + literal_type_.timestamp_tz_ = PROTOBUF_LONGLONG(0); + clear_has_literal_type(); + } } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >* -Expression_Literal_Map::mutable_key_values() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.Map.key_values) - return &key_values_; +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_timestamp_tz() const { + if (_internal_has_timestamp_tz()) { + return literal_type_.timestamp_tz_; + } + return PROTOBUF_LONGLONG(0); } -inline const ::io::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::_internal_key_values(int index) const { - return key_values_.Get(index); +inline void Expression_Literal::_internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::int64 value) { + if (!_internal_has_timestamp_tz()) { + clear_literal_type(); + set_has_timestamp_tz(); + } + literal_type_.timestamp_tz_ = value; } -inline const ::io::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::key_values(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.key_values) - return _internal_key_values(index); +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::timestamp_tz() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.timestamp_tz) + return _internal_timestamp_tz(); } -inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::_internal_add_key_values() { - return key_values_.Add(); +inline void Expression_Literal::set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_timestamp_tz(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.timestamp_tz) } -inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::add_key_values() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.Map.key_values) - return _internal_add_key_values(); + +// bytes uuid = 28; +inline bool Expression_Literal::_internal_has_uuid() const { + return literal_type_case() == kUuid; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >& -Expression_Literal_Map::key_values() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.Map.key_values) - return key_values_; +inline bool Expression_Literal::has_uuid() const { + return _internal_has_uuid(); } - -// ------------------------------------------------------------------- - -// Expression_Literal_IntervalYearToMonth - -// int32 years = 1; -inline void Expression_Literal_IntervalYearToMonth::clear_years() { - years_ = 0; +inline void Expression_Literal::set_has_uuid() { + _oneof_case_[0] = kUuid; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::_internal_years() const { - return years_; +inline void Expression_Literal::clear_uuid() { + if (_internal_has_uuid()) { + literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_literal_type(); + } } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::years() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalYearToMonth.years) - return _internal_years(); +inline const std::string& Expression_Literal::uuid() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.uuid) + return _internal_uuid(); } -inline void Expression_Literal_IntervalYearToMonth::_internal_set_years(::PROTOBUF_NAMESPACE_ID::int32 value) { - - years_ = value; +template +inline void Expression_Literal::set_uuid(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_uuid()) { + clear_literal_type(); + set_has_uuid(); + literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.uuid_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.uuid) } -inline void Expression_Literal_IntervalYearToMonth::set_years(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_years(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalYearToMonth.years) +inline std::string* Expression_Literal::mutable_uuid() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.uuid) + return _internal_mutable_uuid(); } - -// int32 months = 2; -inline void Expression_Literal_IntervalYearToMonth::clear_months() { - months_ = 0; +inline const std::string& Expression_Literal::_internal_uuid() const { + if (_internal_has_uuid()) { + return literal_type_.uuid_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::_internal_months() const { - return months_; +inline void Expression_Literal::_internal_set_uuid(const std::string& value) { + if (!_internal_has_uuid()) { + clear_literal_type(); + set_has_uuid(); + literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + literal_type_.uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::months() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalYearToMonth.months) - return _internal_months(); +inline std::string* Expression_Literal::_internal_mutable_uuid() { + if (!_internal_has_uuid()) { + clear_literal_type(); + set_has_uuid(); + literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return literal_type_.uuid_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline void Expression_Literal_IntervalYearToMonth::_internal_set_months(::PROTOBUF_NAMESPACE_ID::int32 value) { - - months_ = value; +inline std::string* Expression_Literal::release_uuid() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.uuid) + if (_internal_has_uuid()) { + clear_has_literal_type(); + return literal_type_.uuid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } } -inline void Expression_Literal_IntervalYearToMonth::set_months(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_months(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalYearToMonth.months) +inline void Expression_Literal::set_allocated_uuid(std::string* uuid) { + if (has_literal_type()) { + clear_literal_type(); + } + if (uuid != nullptr) { + set_has_uuid(); + literal_type_.uuid_.UnsafeSetDefault(uuid); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(uuid); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.uuid) } -// ------------------------------------------------------------------- - -// Expression_Literal_IntervalDayToSecond - -// int32 days = 1; -inline void Expression_Literal_IntervalDayToSecond::clear_days() { - days_ = 0; +// .io.substrait.Type null = 29; +inline bool Expression_Literal::_internal_has_null() const { + return literal_type_case() == kNull; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::_internal_days() const { - return days_; +inline bool Expression_Literal::has_null() const { + return _internal_has_null(); } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::days() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalDayToSecond.days) - return _internal_days(); +inline void Expression_Literal::set_has_null() { + _oneof_case_[0] = kNull; } -inline void Expression_Literal_IntervalDayToSecond::_internal_set_days(::PROTOBUF_NAMESPACE_ID::int32 value) { - - days_ = value; +inline ::io::substrait::Type* Expression_Literal::release_null() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.null) + if (_internal_has_null()) { + clear_has_literal_type(); + ::io::substrait::Type* temp = literal_type_.null_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.null_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline void Expression_Literal_IntervalDayToSecond::set_days(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_days(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalDayToSecond.days) +inline const ::io::substrait::Type& Expression_Literal::_internal_null() const { + return _internal_has_null() + ? *literal_type_.null_ + : reinterpret_cast< ::io::substrait::Type&>(::io::substrait::_Type_default_instance_); } - -// int32 seconds = 2; -inline void Expression_Literal_IntervalDayToSecond::clear_seconds() { - seconds_ = 0; +inline const ::io::substrait::Type& Expression_Literal::null() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.null) + return _internal_null(); } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::_internal_seconds() const { - return seconds_; +inline ::io::substrait::Type* Expression_Literal::unsafe_arena_release_null() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.null) + if (_internal_has_null()) { + clear_has_literal_type(); + ::io::substrait::Type* temp = literal_type_.null_; + literal_type_.null_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::seconds() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalDayToSecond.seconds) - return _internal_seconds(); +inline void Expression_Literal::unsafe_arena_set_allocated_null(::io::substrait::Type* null) { + clear_literal_type(); + if (null) { + set_has_null(); + literal_type_.null_ = null; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.null) } -inline void Expression_Literal_IntervalDayToSecond::_internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value) { - - seconds_ = value; +inline ::io::substrait::Type* Expression_Literal::_internal_mutable_null() { + if (!_internal_has_null()) { + clear_literal_type(); + set_has_null(); + literal_type_.null_ = CreateMaybeMessage< ::io::substrait::Type >(GetArena()); + } + return literal_type_.null_; } -inline void Expression_Literal_IntervalDayToSecond::set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_seconds(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalDayToSecond.seconds) +inline ::io::substrait::Type* Expression_Literal::mutable_null() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.null) + return _internal_mutable_null(); } -// ------------------------------------------------------------------- - -// Expression_Literal_Struct - -// repeated .io.substrait.Expression.Literal fields = 1; -inline int Expression_Literal_Struct::_internal_fields_size() const { - return fields_.size(); -} -inline int Expression_Literal_Struct::fields_size() const { - return _internal_fields_size(); +// .io.substrait.Expression.Literal.List list = 30; +inline bool Expression_Literal::_internal_has_list() const { + return literal_type_case() == kList; } -inline void Expression_Literal_Struct::clear_fields() { - fields_.Clear(); +inline bool Expression_Literal::has_list() const { + return _internal_has_list(); } -inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::mutable_fields(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Struct.fields) - return fields_.Mutable(index); +inline void Expression_Literal::set_has_list() { + _oneof_case_[0] = kList; } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* -Expression_Literal_Struct::mutable_fields() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.Struct.fields) - return &fields_; +inline void Expression_Literal::clear_list() { + if (_internal_has_list()) { + if (GetArena() == nullptr) { + delete literal_type_.list_; + } + clear_has_literal_type(); + } } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Struct::_internal_fields(int index) const { - return fields_.Get(index); +inline ::io::substrait::Expression_Literal_List* Expression_Literal::release_list() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.list) + if (_internal_has_list()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_List* temp = literal_type_.list_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.list_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Struct::fields(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Struct.fields) - return _internal_fields(index); +inline const ::io::substrait::Expression_Literal_List& Expression_Literal::_internal_list() const { + return _internal_has_list() + ? *literal_type_.list_ + : reinterpret_cast< ::io::substrait::Expression_Literal_List&>(::io::substrait::_Expression_Literal_List_default_instance_); } -inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::_internal_add_fields() { - return fields_.Add(); +inline const ::io::substrait::Expression_Literal_List& Expression_Literal::list() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.list) + return _internal_list(); } -inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::add_fields() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.Struct.fields) - return _internal_add_fields(); +inline ::io::substrait::Expression_Literal_List* Expression_Literal::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.list) + if (_internal_has_list()) { + clear_has_literal_type(); + ::io::substrait::Expression_Literal_List* temp = literal_type_.list_; + literal_type_.list_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& -Expression_Literal_Struct::fields() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.Struct.fields) - return fields_; +inline void Expression_Literal::unsafe_arena_set_allocated_list(::io::substrait::Expression_Literal_List* list) { + clear_literal_type(); + if (list) { + set_has_list(); + literal_type_.list_ = list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.list) } - -// ------------------------------------------------------------------- - -// Expression_Literal_List - -// repeated .io.substrait.Expression.Literal values = 1; -inline int Expression_Literal_List::_internal_values_size() const { - return values_.size(); +inline ::io::substrait::Expression_Literal_List* Expression_Literal::_internal_mutable_list() { + if (!_internal_has_list()) { + clear_literal_type(); + set_has_list(); + literal_type_.list_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_List >(GetArena()); + } + return literal_type_.list_; } -inline int Expression_Literal_List::values_size() const { - return _internal_values_size(); +inline ::io::substrait::Expression_Literal_List* Expression_Literal::mutable_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.list) + return _internal_mutable_list(); } -inline void Expression_Literal_List::clear_values() { - values_.Clear(); + +// bool nullable = 50; +inline void Expression_Literal::clear_nullable() { + nullable_ = false; } -inline ::io::substrait::Expression_Literal* Expression_Literal_List::mutable_values(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.List.values) - return values_.Mutable(index); +inline bool Expression_Literal::_internal_nullable() const { + return nullable_; } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* -Expression_Literal_List::mutable_values() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.List.values) - return &values_; +inline bool Expression_Literal::nullable() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.nullable) + return _internal_nullable(); } -inline const ::io::substrait::Expression_Literal& Expression_Literal_List::_internal_values(int index) const { - return values_.Get(index); +inline void Expression_Literal::_internal_set_nullable(bool value) { + + nullable_ = value; } -inline const ::io::substrait::Expression_Literal& Expression_Literal_List::values(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.List.values) - return _internal_values(index); +inline void Expression_Literal::set_nullable(bool value) { + _internal_set_nullable(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.nullable) } -inline ::io::substrait::Expression_Literal* Expression_Literal_List::_internal_add_values() { - return values_.Add(); + +inline bool Expression_Literal::has_literal_type() const { + return literal_type_case() != LITERAL_TYPE_NOT_SET; } -inline ::io::substrait::Expression_Literal* Expression_Literal_List::add_values() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.List.values) - return _internal_add_values(); +inline void Expression_Literal::clear_has_literal_type() { + _oneof_case_[0] = LITERAL_TYPE_NOT_SET; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& -Expression_Literal_List::values() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.List.values) - return values_; +inline Expression_Literal::LiteralTypeCase Expression_Literal::literal_type_case() const { + return Expression_Literal::LiteralTypeCase(_oneof_case_[0]); } - // ------------------------------------------------------------------- -// Expression_Literal +// Expression_ScalarFunction -// bool boolean = 1; -inline bool Expression_Literal::_internal_has_boolean() const { - return literal_type_case() == kBoolean; -} -inline bool Expression_Literal::has_boolean() const { - return _internal_has_boolean(); +// uint32 function_reference = 1; +inline void Expression_ScalarFunction::clear_function_reference() { + function_reference_ = 0u; } -inline void Expression_Literal::set_has_boolean() { - _oneof_case_[0] = kBoolean; -} -inline void Expression_Literal::clear_boolean() { - if (_internal_has_boolean()) { - literal_type_.boolean_ = false; - clear_has_literal_type(); - } +inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_ScalarFunction::_internal_function_reference() const { + return function_reference_; } -inline bool Expression_Literal::_internal_boolean() const { - if (_internal_has_boolean()) { - return literal_type_.boolean_; - } - return false; -} -inline void Expression_Literal::_internal_set_boolean(bool value) { - if (!_internal_has_boolean()) { - clear_literal_type(); - set_has_boolean(); - } - literal_type_.boolean_ = value; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_ScalarFunction::function_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.function_reference) + return _internal_function_reference(); } -inline bool Expression_Literal::boolean() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.boolean) - return _internal_boolean(); +inline void Expression_ScalarFunction::_internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + function_reference_ = value; } -inline void Expression_Literal::set_boolean(bool value) { - _internal_set_boolean(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.boolean) +inline void Expression_ScalarFunction::set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_function_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.ScalarFunction.function_reference) } -// int32 i8 = 2; -inline bool Expression_Literal::_internal_has_i8() const { - return literal_type_case() == kI8; +// repeated .io.substrait.Expression args = 2; +inline int Expression_ScalarFunction::_internal_args_size() const { + return args_.size(); } -inline bool Expression_Literal::has_i8() const { - return _internal_has_i8(); +inline int Expression_ScalarFunction::args_size() const { + return _internal_args_size(); } -inline void Expression_Literal::set_has_i8() { - _oneof_case_[0] = kI8; +inline void Expression_ScalarFunction::clear_args() { + args_.Clear(); } -inline void Expression_Literal::clear_i8() { - if (_internal_has_i8()) { - literal_type_.i8_ = 0; - clear_has_literal_type(); - } +inline ::io::substrait::Expression* Expression_ScalarFunction::mutable_args(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ScalarFunction.args) + return args_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i8() const { - if (_internal_has_i8()) { - return literal_type_.i8_; - } - return 0; +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_ScalarFunction::mutable_args() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.ScalarFunction.args) + return &args_; } -inline void Expression_Literal::_internal_set_i8(::PROTOBUF_NAMESPACE_ID::int32 value) { - if (!_internal_has_i8()) { - clear_literal_type(); - set_has_i8(); - } - literal_type_.i8_ = value; +inline const ::io::substrait::Expression& Expression_ScalarFunction::_internal_args(int index) const { + return args_.Get(index); } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i8() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i8) - return _internal_i8(); +inline const ::io::substrait::Expression& Expression_ScalarFunction::args(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.args) + return _internal_args(index); } -inline void Expression_Literal::set_i8(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_i8(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i8) +inline ::io::substrait::Expression* Expression_ScalarFunction::_internal_add_args() { + return args_.Add(); +} +inline ::io::substrait::Expression* Expression_ScalarFunction::add_args() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.ScalarFunction.args) + return _internal_add_args(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_ScalarFunction::args() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.ScalarFunction.args) + return args_; } -// int32 i16 = 3; -inline bool Expression_Literal::_internal_has_i16() const { - return literal_type_case() == kI16; +// .io.substrait.Type output_type = 3; +inline bool Expression_ScalarFunction::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; } -inline bool Expression_Literal::has_i16() const { - return _internal_has_i16(); +inline bool Expression_ScalarFunction::has_output_type() const { + return _internal_has_output_type(); } -inline void Expression_Literal::set_has_i16() { - _oneof_case_[0] = kI16; +inline const ::io::substrait::Type& Expression_ScalarFunction::_internal_output_type() const { + const ::io::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); } -inline void Expression_Literal::clear_i16() { - if (_internal_has_i16()) { - literal_type_.i16_ = 0; - clear_has_literal_type(); +inline const ::io::substrait::Type& Expression_ScalarFunction::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.output_type) + return _internal_output_type(); +} +inline void Expression_ScalarFunction::unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + output_type_ = output_type; + if (output_type) { + + } else { + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ScalarFunction.output_type) } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i16() const { - if (_internal_has_i16()) { - return literal_type_.i16_; +inline ::io::substrait::Type* Expression_ScalarFunction::release_output_type() { + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - return 0; + return temp; } -inline void Expression_Literal::_internal_set_i16(::PROTOBUF_NAMESPACE_ID::int32 value) { - if (!_internal_has_i16()) { - clear_literal_type(); - set_has_i16(); +inline ::io::substrait::Type* Expression_ScalarFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.ScalarFunction.output_type) + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + return temp; +} +inline ::io::substrait::Type* Expression_ScalarFunction::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + output_type_ = p; } - literal_type_.i16_ = value; + return output_type_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i16() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i16) - return _internal_i16(); +inline ::io::substrait::Type* Expression_ScalarFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ScalarFunction.output_type) + return _internal_mutable_output_type(); } -inline void Expression_Literal::set_i16(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_i16(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i16) +inline void Expression_ScalarFunction::set_allocated_output_type(::io::substrait::Type* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); + } + + } else { + + } + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ScalarFunction.output_type) } -// int32 i32 = 5; -inline bool Expression_Literal::_internal_has_i32() const { - return literal_type_case() == kI32; +// ------------------------------------------------------------------- + +// Expression_WindowFunction_Bound_Preceding + +// int64 offset = 1; +inline void Expression_WindowFunction_Bound_Preceding::clear_offset() { + offset_ = PROTOBUF_LONGLONG(0); } -inline bool Expression_Literal::has_i32() const { - return _internal_has_i32(); +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Preceding::_internal_offset() const { + return offset_; } -inline void Expression_Literal::set_has_i32() { - _oneof_case_[0] = kI32; +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Preceding::offset() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.Preceding.offset) + return _internal_offset(); } -inline void Expression_Literal::clear_i32() { - if (_internal_has_i32()) { - literal_type_.i32_ = 0; - clear_has_literal_type(); - } +inline void Expression_WindowFunction_Bound_Preceding::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + + offset_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i32() const { - if (_internal_has_i32()) { - return literal_type_.i32_; - } - return 0; +inline void Expression_WindowFunction_Bound_Preceding::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.Bound.Preceding.offset) } -inline void Expression_Literal::_internal_set_i32(::PROTOBUF_NAMESPACE_ID::int32 value) { - if (!_internal_has_i32()) { - clear_literal_type(); - set_has_i32(); - } - literal_type_.i32_ = value; + +// ------------------------------------------------------------------- + +// Expression_WindowFunction_Bound_Following + +// int64 offset = 1; +inline void Expression_WindowFunction_Bound_Following::clear_offset() { + offset_ = PROTOBUF_LONGLONG(0); } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i32() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i32) - return _internal_i32(); +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Following::_internal_offset() const { + return offset_; } -inline void Expression_Literal::set_i32(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_i32(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i32) +inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Following::offset() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.Following.offset) + return _internal_offset(); +} +inline void Expression_WindowFunction_Bound_Following::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + + offset_ = value; +} +inline void Expression_WindowFunction_Bound_Following::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.Bound.Following.offset) } -// int64 i64 = 7; -inline bool Expression_Literal::_internal_has_i64() const { - return literal_type_case() == kI64; +// ------------------------------------------------------------------- + +// Expression_WindowFunction_Bound_CurrentRow + +// ------------------------------------------------------------------- + +// Expression_WindowFunction_Bound_Unbounded + +// ------------------------------------------------------------------- + +// Expression_WindowFunction_Bound + +// .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; +inline bool Expression_WindowFunction_Bound::_internal_has_preceding() const { + return kind_case() == kPreceding; } -inline bool Expression_Literal::has_i64() const { - return _internal_has_i64(); +inline bool Expression_WindowFunction_Bound::has_preceding() const { + return _internal_has_preceding(); } -inline void Expression_Literal::set_has_i64() { - _oneof_case_[0] = kI64; +inline void Expression_WindowFunction_Bound::set_has_preceding() { + _oneof_case_[0] = kPreceding; } -inline void Expression_Literal::clear_i64() { - if (_internal_has_i64()) { - literal_type_.i64_ = PROTOBUF_LONGLONG(0); - clear_has_literal_type(); +inline void Expression_WindowFunction_Bound::clear_preceding() { + if (_internal_has_preceding()) { + if (GetArena() == nullptr) { + delete kind_.preceding_; + } + clear_has_kind(); } } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_i64() const { - if (_internal_has_i64()) { - return literal_type_.i64_; +inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::release_preceding() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.preceding) + if (_internal_has_preceding()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.preceding_ = nullptr; + return temp; + } else { + return nullptr; } - return PROTOBUF_LONGLONG(0); } -inline void Expression_Literal::_internal_set_i64(::PROTOBUF_NAMESPACE_ID::int64 value) { - if (!_internal_has_i64()) { - clear_literal_type(); - set_has_i64(); +inline const ::io::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::_internal_preceding() const { + return _internal_has_preceding() + ? *kind_.preceding_ + : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Preceding&>(::io::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::preceding() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.preceding) + return _internal_preceding(); +} +inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::unsafe_arena_release_preceding() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.preceding) + if (_internal_has_preceding()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; + kind_.preceding_ = nullptr; + return temp; + } else { + return nullptr; } - literal_type_.i64_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::i64() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i64) - return _internal_i64(); +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_preceding(::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { + clear_kind(); + if (preceding) { + set_has_preceding(); + kind_.preceding_ = preceding; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.preceding) +} +inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::_internal_mutable_preceding() { + if (!_internal_has_preceding()) { + clear_kind(); + set_has_preceding(); + kind_.preceding_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Preceding >(GetArena()); + } + return kind_.preceding_; } -inline void Expression_Literal::set_i64(::PROTOBUF_NAMESPACE_ID::int64 value) { - _internal_set_i64(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i64) +inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::mutable_preceding() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.preceding) + return _internal_mutable_preceding(); } -// float fp32 = 10; -inline bool Expression_Literal::_internal_has_fp32() const { - return literal_type_case() == kFp32; +// .io.substrait.Expression.WindowFunction.Bound.Following following = 2; +inline bool Expression_WindowFunction_Bound::_internal_has_following() const { + return kind_case() == kFollowing; } -inline bool Expression_Literal::has_fp32() const { - return _internal_has_fp32(); +inline bool Expression_WindowFunction_Bound::has_following() const { + return _internal_has_following(); } -inline void Expression_Literal::set_has_fp32() { - _oneof_case_[0] = kFp32; +inline void Expression_WindowFunction_Bound::set_has_following() { + _oneof_case_[0] = kFollowing; } -inline void Expression_Literal::clear_fp32() { - if (_internal_has_fp32()) { - literal_type_.fp32_ = 0; - clear_has_literal_type(); +inline void Expression_WindowFunction_Bound::clear_following() { + if (_internal_has_following()) { + if (GetArena() == nullptr) { + delete kind_.following_; + } + clear_has_kind(); } } -inline float Expression_Literal::_internal_fp32() const { - if (_internal_has_fp32()) { - return literal_type_.fp32_; +inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::release_following() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.following) + if (_internal_has_following()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.following_ = nullptr; + return temp; + } else { + return nullptr; } - return 0; } -inline void Expression_Literal::_internal_set_fp32(float value) { - if (!_internal_has_fp32()) { - clear_literal_type(); - set_has_fp32(); +inline const ::io::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::_internal_following() const { + return _internal_has_following() + ? *kind_.following_ + : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Following&>(::io::substrait::_Expression_WindowFunction_Bound_Following_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::following() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.following) + return _internal_following(); +} +inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::unsafe_arena_release_following() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.following) + if (_internal_has_following()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; + kind_.following_ = nullptr; + return temp; + } else { + return nullptr; } - literal_type_.fp32_ = value; } -inline float Expression_Literal::fp32() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fp32) - return _internal_fp32(); +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_following(::io::substrait::Expression_WindowFunction_Bound_Following* following) { + clear_kind(); + if (following) { + set_has_following(); + kind_.following_ = following; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.following) } -inline void Expression_Literal::set_fp32(float value) { - _internal_set_fp32(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fp32) +inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::_internal_mutable_following() { + if (!_internal_has_following()) { + clear_kind(); + set_has_following(); + kind_.following_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Following >(GetArena()); + } + return kind_.following_; } - -// double fp64 = 11; -inline bool Expression_Literal::_internal_has_fp64() const { - return literal_type_case() == kFp64; +inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::mutable_following() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.following) + return _internal_mutable_following(); } -inline bool Expression_Literal::has_fp64() const { - return _internal_has_fp64(); + +// .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; +inline bool Expression_WindowFunction_Bound::_internal_has_current_row() const { + return kind_case() == kCurrentRow; } -inline void Expression_Literal::set_has_fp64() { - _oneof_case_[0] = kFp64; +inline bool Expression_WindowFunction_Bound::has_current_row() const { + return _internal_has_current_row(); } -inline void Expression_Literal::clear_fp64() { - if (_internal_has_fp64()) { - literal_type_.fp64_ = 0; - clear_has_literal_type(); - } +inline void Expression_WindowFunction_Bound::set_has_current_row() { + _oneof_case_[0] = kCurrentRow; } -inline double Expression_Literal::_internal_fp64() const { - if (_internal_has_fp64()) { - return literal_type_.fp64_; +inline void Expression_WindowFunction_Bound::clear_current_row() { + if (_internal_has_current_row()) { + if (GetArena() == nullptr) { + delete kind_.current_row_; + } + clear_has_kind(); } - return 0; } -inline void Expression_Literal::_internal_set_fp64(double value) { - if (!_internal_has_fp64()) { - clear_literal_type(); - set_has_fp64(); +inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::release_current_row() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.current_row) + if (_internal_has_current_row()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.current_row_ = nullptr; + return temp; + } else { + return nullptr; } - literal_type_.fp64_ = value; -} -inline double Expression_Literal::fp64() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fp64) - return _internal_fp64(); } -inline void Expression_Literal::set_fp64(double value) { - _internal_set_fp64(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fp64) +inline const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::_internal_current_row() const { + return _internal_has_current_row() + ? *kind_.current_row_ + : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow&>(::io::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_); } - -// string string = 12; -inline bool Expression_Literal::_internal_has_string() const { - return literal_type_case() == kString; +inline const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::current_row() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.current_row) + return _internal_current_row(); } -inline bool Expression_Literal::has_string() const { - return _internal_has_string(); +inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::unsafe_arena_release_current_row() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.current_row) + if (_internal_has_current_row()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; + kind_.current_row_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline void Expression_Literal::set_has_string() { - _oneof_case_[0] = kString; +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_current_row(::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { + clear_kind(); + if (current_row) { + set_has_current_row(); + kind_.current_row_ = current_row; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.current_row) } -inline void Expression_Literal::clear_string() { - if (_internal_has_string()) { - literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - clear_has_literal_type(); +inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::_internal_mutable_current_row() { + if (!_internal_has_current_row()) { + clear_kind(); + set_has_current_row(); + kind_.current_row_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow >(GetArena()); } + return kind_.current_row_; } -inline const std::string& Expression_Literal::string() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.string) - return _internal_string(); +inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::mutable_current_row() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.current_row) + return _internal_mutable_current_row(); } -template -inline void Expression_Literal::set_string(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_string()) { - clear_literal_type(); - set_has_string(); - literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.string) + +// .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; +inline bool Expression_WindowFunction_Bound::_internal_has_unbounded() const { + return kind_case() == kUnbounded; } -inline std::string* Expression_Literal::mutable_string() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.string) - return _internal_mutable_string(); +inline bool Expression_WindowFunction_Bound::has_unbounded() const { + return _internal_has_unbounded(); } -inline const std::string& Expression_Literal::_internal_string() const { - if (_internal_has_string()) { - return literal_type_.string_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +inline void Expression_WindowFunction_Bound::set_has_unbounded() { + _oneof_case_[0] = kUnbounded; } -inline void Expression_Literal::_internal_set_string(const std::string& value) { - if (!_internal_has_string()) { - clear_literal_type(); - set_has_string(); - literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline void Expression_WindowFunction_Bound::clear_unbounded() { + if (_internal_has_unbounded()) { + if (GetArena() == nullptr) { + delete kind_.unbounded_; + } + clear_has_kind(); } - literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline std::string* Expression_Literal::_internal_mutable_string() { - if (!_internal_has_string()) { - clear_literal_type(); - set_has_string(); - literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::release_unbounded() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.unbounded) + if (_internal_has_unbounded()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.unbounded_ = nullptr; + return temp; + } else { + return nullptr; } - return literal_type_.string_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* Expression_Literal::release_string() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.string) - if (_internal_has_string()) { - clear_has_literal_type(); - return literal_type_.string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::_internal_unbounded() const { + return _internal_has_unbounded() + ? *kind_.unbounded_ + : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Unbounded&>(::io::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::unbounded() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.unbounded) + return _internal_unbounded(); +} +inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::unsafe_arena_release_unbounded() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.unbounded) + if (_internal_has_unbounded()) { + clear_has_kind(); + ::io::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; + kind_.unbounded_ = nullptr; + return temp; } else { return nullptr; } } -inline void Expression_Literal::set_allocated_string(std::string* string) { - if (has_literal_type()) { - clear_literal_type(); +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_unbounded(::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { + clear_kind(); + if (unbounded) { + set_has_unbounded(); + kind_.unbounded_ = unbounded; } - if (string != nullptr) { - set_has_string(); - literal_type_.string_.UnsafeSetDefault(string); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); - if (arena != nullptr) { - arena->Own(string); - } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.unbounded) +} +inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::_internal_mutable_unbounded() { + if (!_internal_has_unbounded()) { + clear_kind(); + set_has_unbounded(); + kind_.unbounded_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Unbounded >(GetArena()); } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.string) + return kind_.unbounded_; +} +inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::mutable_unbounded() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.unbounded) + return _internal_mutable_unbounded(); } -// bytes binary = 13; -inline bool Expression_Literal::_internal_has_binary() const { - return literal_type_case() == kBinary; +inline bool Expression_WindowFunction_Bound::has_kind() const { + return kind_case() != KIND_NOT_SET; } -inline bool Expression_Literal::has_binary() const { - return _internal_has_binary(); +inline void Expression_WindowFunction_Bound::clear_has_kind() { + _oneof_case_[0] = KIND_NOT_SET; } -inline void Expression_Literal::set_has_binary() { - _oneof_case_[0] = kBinary; +inline Expression_WindowFunction_Bound::KindCase Expression_WindowFunction_Bound::kind_case() const { + return Expression_WindowFunction_Bound::KindCase(_oneof_case_[0]); } -inline void Expression_Literal::clear_binary() { - if (_internal_has_binary()) { - literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - clear_has_literal_type(); - } +// ------------------------------------------------------------------- + +// Expression_WindowFunction + +// uint32 function_reference = 1; +inline void Expression_WindowFunction::clear_function_reference() { + function_reference_ = 0u; } -inline const std::string& Expression_Literal::binary() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.binary) - return _internal_binary(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_WindowFunction::_internal_function_reference() const { + return function_reference_; } -template -inline void Expression_Literal::set_binary(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_binary()) { - clear_literal_type(); - set_has_binary(); - literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.binary) +inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_WindowFunction::function_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.function_reference) + return _internal_function_reference(); } -inline std::string* Expression_Literal::mutable_binary() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.binary) - return _internal_mutable_binary(); +inline void Expression_WindowFunction::_internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + function_reference_ = value; } -inline const std::string& Expression_Literal::_internal_binary() const { - if (_internal_has_binary()) { - return literal_type_.binary_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +inline void Expression_WindowFunction::set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_function_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.function_reference) } -inline void Expression_Literal::_internal_set_binary(const std::string& value) { - if (!_internal_has_binary()) { - clear_literal_type(); - set_has_binary(); - literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + +// repeated .io.substrait.Expression partitions = 2; +inline int Expression_WindowFunction::_internal_partitions_size() const { + return partitions_.size(); } -inline std::string* Expression_Literal::_internal_mutable_binary() { - if (!_internal_has_binary()) { - clear_literal_type(); - set_has_binary(); - literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return literal_type_.binary_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline int Expression_WindowFunction::partitions_size() const { + return _internal_partitions_size(); } -inline std::string* Expression_Literal::release_binary() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.binary) - if (_internal_has_binary()) { - clear_has_literal_type(); - return literal_type_.binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - } else { - return nullptr; - } +inline void Expression_WindowFunction::clear_partitions() { + partitions_.Clear(); } -inline void Expression_Literal::set_allocated_binary(std::string* binary) { - if (has_literal_type()) { - clear_literal_type(); - } - if (binary != nullptr) { - set_has_binary(); - literal_type_.binary_.UnsafeSetDefault(binary); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); - if (arena != nullptr) { - arena->Own(binary); - } - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.binary) +inline ::io::substrait::Expression* Expression_WindowFunction::mutable_partitions(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.partitions) + return partitions_.Mutable(index); } - -// fixed64 timestamp = 14; -inline bool Expression_Literal::_internal_has_timestamp() const { - return literal_type_case() == kTimestamp; +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_WindowFunction::mutable_partitions() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.partitions) + return &partitions_; } -inline bool Expression_Literal::has_timestamp() const { - return _internal_has_timestamp(); +inline const ::io::substrait::Expression& Expression_WindowFunction::_internal_partitions(int index) const { + return partitions_.Get(index); } -inline void Expression_Literal::set_has_timestamp() { - _oneof_case_[0] = kTimestamp; +inline const ::io::substrait::Expression& Expression_WindowFunction::partitions(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.partitions) + return _internal_partitions(index); } -inline void Expression_Literal::clear_timestamp() { - if (_internal_has_timestamp()) { - literal_type_.timestamp_ = PROTOBUF_ULONGLONG(0); - clear_has_literal_type(); - } +inline ::io::substrait::Expression* Expression_WindowFunction::_internal_add_partitions() { + return partitions_.Add(); } -inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::_internal_timestamp() const { - if (_internal_has_timestamp()) { - return literal_type_.timestamp_; - } - return PROTOBUF_ULONGLONG(0); +inline ::io::substrait::Expression* Expression_WindowFunction::add_partitions() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.partitions) + return _internal_add_partitions(); } -inline void Expression_Literal::_internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { - if (!_internal_has_timestamp()) { - clear_literal_type(); - set_has_timestamp(); - } - literal_type_.timestamp_ = value; +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_WindowFunction::partitions() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.partitions) + return partitions_; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::timestamp() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.timestamp) - return _internal_timestamp(); + +// repeated .io.substrait.SortField sorts = 3; +inline int Expression_WindowFunction::_internal_sorts_size() const { + return sorts_.size(); } -inline void Expression_Literal::set_timestamp(::PROTOBUF_NAMESPACE_ID::uint64 value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.timestamp) +inline int Expression_WindowFunction::sorts_size() const { + return _internal_sorts_size(); } - -// fixed32 date = 16; -inline bool Expression_Literal::_internal_has_date() const { - return literal_type_case() == kDate; +inline void Expression_WindowFunction::clear_sorts() { + sorts_.Clear(); } -inline bool Expression_Literal::has_date() const { - return _internal_has_date(); +inline ::io::substrait::SortField* Expression_WindowFunction::mutable_sorts(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.sorts) + return sorts_.Mutable(index); } -inline void Expression_Literal::set_has_date() { - _oneof_case_[0] = kDate; +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* +Expression_WindowFunction::mutable_sorts() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.sorts) + return &sorts_; } -inline void Expression_Literal::clear_date() { - if (_internal_has_date()) { - literal_type_.date_ = 0u; - clear_has_literal_type(); - } +inline const ::io::substrait::SortField& Expression_WindowFunction::_internal_sorts(int index) const { + return sorts_.Get(index); } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_Literal::_internal_date() const { - if (_internal_has_date()) { - return literal_type_.date_; - } - return 0u; +inline const ::io::substrait::SortField& Expression_WindowFunction::sorts(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.sorts) + return _internal_sorts(index); } -inline void Expression_Literal::_internal_set_date(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (!_internal_has_date()) { - clear_literal_type(); - set_has_date(); - } - literal_type_.date_ = value; +inline ::io::substrait::SortField* Expression_WindowFunction::_internal_add_sorts() { + return sorts_.Add(); } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_Literal::date() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.date) - return _internal_date(); +inline ::io::substrait::SortField* Expression_WindowFunction::add_sorts() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.sorts) + return _internal_add_sorts(); } -inline void Expression_Literal::set_date(::PROTOBUF_NAMESPACE_ID::uint32 value) { - _internal_set_date(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.date) +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& +Expression_WindowFunction::sorts() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.sorts) + return sorts_; } -// uint64 time = 17; -inline bool Expression_Literal::_internal_has_time() const { - return literal_type_case() == kTime; -} -inline bool Expression_Literal::has_time() const { - return _internal_has_time(); +// .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; +inline bool Expression_WindowFunction::_internal_has_upper_bound() const { + return this != internal_default_instance() && upper_bound_ != nullptr; } -inline void Expression_Literal::set_has_time() { - _oneof_case_[0] = kTime; +inline bool Expression_WindowFunction::has_upper_bound() const { + return _internal_has_upper_bound(); } -inline void Expression_Literal::clear_time() { - if (_internal_has_time()) { - literal_type_.time_ = PROTOBUF_ULONGLONG(0); - clear_has_literal_type(); +inline void Expression_WindowFunction::clear_upper_bound() { + if (GetArena() == nullptr && upper_bound_ != nullptr) { + delete upper_bound_; } + upper_bound_ = nullptr; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::_internal_time() const { - if (_internal_has_time()) { - return literal_type_.time_; +inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_upper_bound() const { + const ::io::substrait::Expression_WindowFunction_Bound* p = upper_bound_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_WindowFunction_Bound_default_instance_); +} +inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::upper_bound() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.upper_bound) + return _internal_upper_bound(); +} +inline void Expression_WindowFunction::unsafe_arena_set_allocated_upper_bound( + ::io::substrait::Expression_WindowFunction_Bound* upper_bound) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(upper_bound_); } - return PROTOBUF_ULONGLONG(0); -} -inline void Expression_Literal::_internal_set_time(::PROTOBUF_NAMESPACE_ID::uint64 value) { - if (!_internal_has_time()) { - clear_literal_type(); - set_has_time(); + upper_bound_ = upper_bound; + if (upper_bound) { + + } else { + } - literal_type_.time_ = value; -} -inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::time() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.time) - return _internal_time(); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.upper_bound) } -inline void Expression_Literal::set_time(::PROTOBUF_NAMESPACE_ID::uint64 value) { - _internal_set_time(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.time) +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_upper_bound() { + + ::io::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; + upper_bound_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } - -// .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; -inline bool Expression_Literal::_internal_has_interval_year_to_month() const { - return literal_type_case() == kIntervalYearToMonth; +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_upper_bound() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.upper_bound) + + ::io::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; + upper_bound_ = nullptr; + return temp; } -inline bool Expression_Literal::has_interval_year_to_month() const { - return _internal_has_interval_year_to_month(); +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_upper_bound() { + + if (upper_bound_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound>(GetArena()); + upper_bound_ = p; + } + return upper_bound_; } -inline void Expression_Literal::set_has_interval_year_to_month() { - _oneof_case_[0] = kIntervalYearToMonth; +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_upper_bound() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.upper_bound) + return _internal_mutable_upper_bound(); } -inline void Expression_Literal::clear_interval_year_to_month() { - if (_internal_has_interval_year_to_month()) { - if (GetArena() == nullptr) { - delete literal_type_.interval_year_to_month_; - } - clear_has_literal_type(); +inline void Expression_WindowFunction::set_allocated_upper_bound(::io::substrait::Expression_WindowFunction_Bound* upper_bound) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete upper_bound_; } -} -inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::release_interval_year_to_month() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.interval_year_to_month) - if (_internal_has_interval_year_to_month()) { - clear_has_literal_type(); - ::io::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (upper_bound) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(upper_bound); + if (message_arena != submessage_arena) { + upper_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, upper_bound, submessage_arena); } - literal_type_.interval_year_to_month_ = nullptr; - return temp; + } else { - return nullptr; + } + upper_bound_ = upper_bound; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.upper_bound) } -inline const ::io::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::_internal_interval_year_to_month() const { - return _internal_has_interval_year_to_month() - ? *literal_type_.interval_year_to_month_ - : reinterpret_cast< ::io::substrait::Expression_Literal_IntervalYearToMonth&>(::io::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_); + +// .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; +inline bool Expression_WindowFunction::_internal_has_lower_bound() const { + return this != internal_default_instance() && lower_bound_ != nullptr; } -inline const ::io::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::interval_year_to_month() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.interval_year_to_month) - return _internal_interval_year_to_month(); +inline bool Expression_WindowFunction::has_lower_bound() const { + return _internal_has_lower_bound(); } -inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::unsafe_arena_release_interval_year_to_month() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.interval_year_to_month) - if (_internal_has_interval_year_to_month()) { - clear_has_literal_type(); - ::io::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; - literal_type_.interval_year_to_month_ = nullptr; - return temp; - } else { - return nullptr; +inline void Expression_WindowFunction::clear_lower_bound() { + if (GetArena() == nullptr && lower_bound_ != nullptr) { + delete lower_bound_; } + lower_bound_ = nullptr; } -inline void Expression_Literal::unsafe_arena_set_allocated_interval_year_to_month(::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { - clear_literal_type(); - if (interval_year_to_month) { - set_has_interval_year_to_month(); - literal_type_.interval_year_to_month_ = interval_year_to_month; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.interval_year_to_month) +inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_lower_bound() const { + const ::io::substrait::Expression_WindowFunction_Bound* p = lower_bound_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_WindowFunction_Bound_default_instance_); } -inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::_internal_mutable_interval_year_to_month() { - if (!_internal_has_interval_year_to_month()) { - clear_literal_type(); - set_has_interval_year_to_month(); - literal_type_.interval_year_to_month_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalYearToMonth >(GetArena()); +inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::lower_bound() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.lower_bound) + return _internal_lower_bound(); +} +inline void Expression_WindowFunction::unsafe_arena_set_allocated_lower_bound( + ::io::substrait::Expression_WindowFunction_Bound* lower_bound) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lower_bound_); } - return literal_type_.interval_year_to_month_; + lower_bound_ = lower_bound; + if (lower_bound) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.lower_bound) } -inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::mutable_interval_year_to_month() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.interval_year_to_month) - return _internal_mutable_interval_year_to_month(); +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_lower_bound() { + + ::io::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; + lower_bound_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } - -// .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; -inline bool Expression_Literal::_internal_has_interval_day_to_second() const { - return literal_type_case() == kIntervalDayToSecond; +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_lower_bound() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.lower_bound) + + ::io::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; + lower_bound_ = nullptr; + return temp; } -inline bool Expression_Literal::has_interval_day_to_second() const { - return _internal_has_interval_day_to_second(); +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_lower_bound() { + + if (lower_bound_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound>(GetArena()); + lower_bound_ = p; + } + return lower_bound_; } -inline void Expression_Literal::set_has_interval_day_to_second() { - _oneof_case_[0] = kIntervalDayToSecond; +inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_lower_bound() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.lower_bound) + return _internal_mutable_lower_bound(); } -inline void Expression_Literal::clear_interval_day_to_second() { - if (_internal_has_interval_day_to_second()) { - if (GetArena() == nullptr) { - delete literal_type_.interval_day_to_second_; - } - clear_has_literal_type(); +inline void Expression_WindowFunction::set_allocated_lower_bound(::io::substrait::Expression_WindowFunction_Bound* lower_bound) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete lower_bound_; } -} -inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::release_interval_day_to_second() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.interval_day_to_second) - if (_internal_has_interval_day_to_second()) { - clear_has_literal_type(); - ::io::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (lower_bound) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lower_bound); + if (message_arena != submessage_arena) { + lower_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, lower_bound, submessage_arena); } - literal_type_.interval_day_to_second_ = nullptr; - return temp; + } else { - return nullptr; + } + lower_bound_ = lower_bound; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.lower_bound) } -inline const ::io::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::_internal_interval_day_to_second() const { - return _internal_has_interval_day_to_second() - ? *literal_type_.interval_day_to_second_ - : reinterpret_cast< ::io::substrait::Expression_Literal_IntervalDayToSecond&>(::io::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_); -} -inline const ::io::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::interval_day_to_second() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.interval_day_to_second) - return _internal_interval_day_to_second(); + +// .io.substrait.AggregationPhase phase = 6; +inline void Expression_WindowFunction::clear_phase() { + phase_ = 0; } -inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::unsafe_arena_release_interval_day_to_second() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.interval_day_to_second) - if (_internal_has_interval_day_to_second()) { - clear_has_literal_type(); - ::io::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; - literal_type_.interval_day_to_second_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::io::substrait::AggregationPhase Expression_WindowFunction::_internal_phase() const { + return static_cast< ::io::substrait::AggregationPhase >(phase_); } -inline void Expression_Literal::unsafe_arena_set_allocated_interval_day_to_second(::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { - clear_literal_type(); - if (interval_day_to_second) { - set_has_interval_day_to_second(); - literal_type_.interval_day_to_second_ = interval_day_to_second; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.interval_day_to_second) +inline ::io::substrait::AggregationPhase Expression_WindowFunction::phase() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.phase) + return _internal_phase(); } -inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::_internal_mutable_interval_day_to_second() { - if (!_internal_has_interval_day_to_second()) { - clear_literal_type(); - set_has_interval_day_to_second(); - literal_type_.interval_day_to_second_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalDayToSecond >(GetArena()); - } - return literal_type_.interval_day_to_second_; +inline void Expression_WindowFunction::_internal_set_phase(::io::substrait::AggregationPhase value) { + + phase_ = value; } -inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::mutable_interval_day_to_second() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.interval_day_to_second) - return _internal_mutable_interval_day_to_second(); +inline void Expression_WindowFunction::set_phase(::io::substrait::AggregationPhase value) { + _internal_set_phase(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.phase) } -// string fixed_char = 21; -inline bool Expression_Literal::_internal_has_fixed_char() const { - return literal_type_case() == kFixedChar; -} -inline bool Expression_Literal::has_fixed_char() const { - return _internal_has_fixed_char(); +// .io.substrait.Type output_type = 7; +inline bool Expression_WindowFunction::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; } -inline void Expression_Literal::set_has_fixed_char() { - _oneof_case_[0] = kFixedChar; +inline bool Expression_WindowFunction::has_output_type() const { + return _internal_has_output_type(); } -inline void Expression_Literal::clear_fixed_char() { - if (_internal_has_fixed_char()) { - literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - clear_has_literal_type(); - } +inline const ::io::substrait::Type& Expression_WindowFunction::_internal_output_type() const { + const ::io::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); } -inline const std::string& Expression_Literal::fixed_char() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fixed_char) - return _internal_fixed_char(); +inline const ::io::substrait::Type& Expression_WindowFunction::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.output_type) + return _internal_output_type(); } -template -inline void Expression_Literal::set_fixed_char(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_fixed_char()) { - clear_literal_type(); - set_has_fixed_char(); - literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline void Expression_WindowFunction::unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } - literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fixed_char) -} -inline std::string* Expression_Literal::mutable_fixed_char() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.fixed_char) - return _internal_mutable_fixed_char(); -} -inline const std::string& Expression_Literal::_internal_fixed_char() const { - if (_internal_has_fixed_char()) { - return literal_type_.fixed_char_.Get(); + output_type_ = output_type; + if (output_type) { + + } else { + } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.output_type) } -inline void Expression_Literal::_internal_set_fixed_char(const std::string& value) { - if (!_internal_has_fixed_char()) { - clear_literal_type(); - set_has_fixed_char(); - literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline ::io::substrait::Type* Expression_WindowFunction::release_output_type() { + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + return temp; } -inline std::string* Expression_Literal::_internal_mutable_fixed_char() { - if (!_internal_has_fixed_char()) { - clear_literal_type(); - set_has_fixed_char(); - literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return literal_type_.fixed_char_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline ::io::substrait::Type* Expression_WindowFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.output_type) + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + return temp; } -inline std::string* Expression_Literal::release_fixed_char() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.fixed_char) - if (_internal_has_fixed_char()) { - clear_has_literal_type(); - return literal_type_.fixed_char_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - } else { - return nullptr; +inline ::io::substrait::Type* Expression_WindowFunction::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + output_type_ = p; } + return output_type_; } -inline void Expression_Literal::set_allocated_fixed_char(std::string* fixed_char) { - if (has_literal_type()) { - clear_literal_type(); +inline ::io::substrait::Type* Expression_WindowFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.output_type) + return _internal_mutable_output_type(); +} +inline void Expression_WindowFunction::set_allocated_output_type(::io::substrait::Type* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } - if (fixed_char != nullptr) { - set_has_fixed_char(); - literal_type_.fixed_char_.UnsafeSetDefault(fixed_char); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); - if (arena != nullptr) { - arena->Own(fixed_char); + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); } + + } else { + } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.fixed_char) + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.output_type) } -// string var_char = 22; -inline bool Expression_Literal::_internal_has_var_char() const { - return literal_type_case() == kVarChar; +// repeated .io.substrait.Expression args = 8; +inline int Expression_WindowFunction::_internal_args_size() const { + return args_.size(); } -inline bool Expression_Literal::has_var_char() const { - return _internal_has_var_char(); +inline int Expression_WindowFunction::args_size() const { + return _internal_args_size(); } -inline void Expression_Literal::set_has_var_char() { - _oneof_case_[0] = kVarChar; +inline void Expression_WindowFunction::clear_args() { + args_.Clear(); } -inline void Expression_Literal::clear_var_char() { - if (_internal_has_var_char()) { - literal_type_.var_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - clear_has_literal_type(); - } +inline ::io::substrait::Expression* Expression_WindowFunction::mutable_args(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.args) + return args_.Mutable(index); } -inline const std::string& Expression_Literal::var_char() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.var_char) - return _internal_var_char(); +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_WindowFunction::mutable_args() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.args) + return &args_; } -template -inline void Expression_Literal::set_var_char(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_var_char()) { - clear_literal_type(); - set_has_var_char(); - literal_type_.var_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.var_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.var_char) +inline const ::io::substrait::Expression& Expression_WindowFunction::_internal_args(int index) const { + return args_.Get(index); } -inline std::string* Expression_Literal::mutable_var_char() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.var_char) - return _internal_mutable_var_char(); +inline const ::io::substrait::Expression& Expression_WindowFunction::args(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.args) + return _internal_args(index); } -inline const std::string& Expression_Literal::_internal_var_char() const { - if (_internal_has_var_char()) { - return literal_type_.var_char_.Get(); +inline ::io::substrait::Expression* Expression_WindowFunction::_internal_add_args() { + return args_.Add(); +} +inline ::io::substrait::Expression* Expression_WindowFunction::add_args() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.args) + return _internal_add_args(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_WindowFunction::args() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.args) + return args_; +} + +// ------------------------------------------------------------------- + +// Expression_IfThen_IfClause + +// .io.substrait.Expression if = 1; +inline bool Expression_IfThen_IfClause::_internal_has_if_() const { + return this != internal_default_instance() && if__ != nullptr; +} +inline bool Expression_IfThen_IfClause::has_if_() const { + return _internal_has_if_(); +} +inline void Expression_IfThen_IfClause::clear_if_() { + if (GetArena() == nullptr && if__ != nullptr) { + delete if__; } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); + if__ = nullptr; } -inline void Expression_Literal::_internal_set_var_char(const std::string& value) { - if (!_internal_has_var_char()) { - clear_literal_type(); - set_has_var_char(); - literal_type_.var_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline const ::io::substrait::Expression& Expression_IfThen_IfClause::_internal_if_() const { + const ::io::substrait::Expression* p = if__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_IfThen_IfClause::if_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.IfClause.if) + return _internal_if_(); +} +inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_if_( + ::io::substrait::Expression* if_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); + } + if__ = if_; + if (if_) { + + } else { + } - literal_type_.var_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.IfClause.if) } -inline std::string* Expression_Literal::_internal_mutable_var_char() { - if (!_internal_has_var_char()) { - clear_literal_type(); - set_has_var_char(); - literal_type_.var_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline ::io::substrait::Expression* Expression_IfThen_IfClause::release_if_() { + + ::io::substrait::Expression* temp = if__; + if__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - return literal_type_.var_char_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return temp; } -inline std::string* Expression_Literal::release_var_char() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.var_char) - if (_internal_has_var_char()) { - clear_has_literal_type(); - return literal_type_.var_char_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - } else { - return nullptr; +inline ::io::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_if_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.IfClause.if) + + ::io::substrait::Expression* temp = if__; + if__ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_if_() { + + if (if__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + if__ = p; } + return if__; } -inline void Expression_Literal::set_allocated_var_char(std::string* var_char) { - if (has_literal_type()) { - clear_literal_type(); +inline ::io::substrait::Expression* Expression_IfThen_IfClause::mutable_if_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.IfClause.if) + return _internal_mutable_if_(); +} +inline void Expression_IfThen_IfClause::set_allocated_if_(::io::substrait::Expression* if_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete if__; } - if (var_char != nullptr) { - set_has_var_char(); - literal_type_.var_char_.UnsafeSetDefault(var_char); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); - if (arena != nullptr) { - arena->Own(var_char); + if (if_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_); + if (message_arena != submessage_arena) { + if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, if_, submessage_arena); } + + } else { + } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.var_char) + if__ = if_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.IfClause.if) } -// bytes fixed_binary = 23; -inline bool Expression_Literal::_internal_has_fixed_binary() const { - return literal_type_case() == kFixedBinary; -} -inline bool Expression_Literal::has_fixed_binary() const { - return _internal_has_fixed_binary(); +// .io.substrait.Expression then = 2; +inline bool Expression_IfThen_IfClause::_internal_has_then() const { + return this != internal_default_instance() && then_ != nullptr; } -inline void Expression_Literal::set_has_fixed_binary() { - _oneof_case_[0] = kFixedBinary; +inline bool Expression_IfThen_IfClause::has_then() const { + return _internal_has_then(); } -inline void Expression_Literal::clear_fixed_binary() { - if (_internal_has_fixed_binary()) { - literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - clear_has_literal_type(); +inline void Expression_IfThen_IfClause::clear_then() { + if (GetArena() == nullptr && then_ != nullptr) { + delete then_; } + then_ = nullptr; } -inline const std::string& Expression_Literal::fixed_binary() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fixed_binary) - return _internal_fixed_binary(); -} -template -inline void Expression_Literal::set_fixed_binary(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_fixed_binary()) { - clear_literal_type(); - set_has_fixed_binary(); - literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.fixed_binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fixed_binary) +inline const ::io::substrait::Expression& Expression_IfThen_IfClause::_internal_then() const { + const ::io::substrait::Expression* p = then_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); } -inline std::string* Expression_Literal::mutable_fixed_binary() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.fixed_binary) - return _internal_mutable_fixed_binary(); +inline const ::io::substrait::Expression& Expression_IfThen_IfClause::then() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.IfClause.then) + return _internal_then(); } -inline const std::string& Expression_Literal::_internal_fixed_binary() const { - if (_internal_has_fixed_binary()) { - return literal_type_.fixed_binary_.Get(); +inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_then( + ::io::substrait::Expression* then) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Expression_Literal::_internal_set_fixed_binary(const std::string& value) { - if (!_internal_has_fixed_binary()) { - clear_literal_type(); - set_has_fixed_binary(); - literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + then_ = then; + if (then) { + + } else { + } - literal_type_.fixed_binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.IfClause.then) } -inline std::string* Expression_Literal::_internal_mutable_fixed_binary() { - if (!_internal_has_fixed_binary()) { - clear_literal_type(); - set_has_fixed_binary(); - literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline ::io::substrait::Expression* Expression_IfThen_IfClause::release_then() { + + ::io::substrait::Expression* temp = then_; + then_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - return literal_type_.fixed_binary_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return temp; } -inline std::string* Expression_Literal::release_fixed_binary() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.fixed_binary) - if (_internal_has_fixed_binary()) { - clear_has_literal_type(); - return literal_type_.fixed_binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - } else { - return nullptr; +inline ::io::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_then() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.IfClause.then) + + ::io::substrait::Expression* temp = then_; + then_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_then() { + + if (then_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + then_ = p; } + return then_; } -inline void Expression_Literal::set_allocated_fixed_binary(std::string* fixed_binary) { - if (has_literal_type()) { - clear_literal_type(); +inline ::io::substrait::Expression* Expression_IfThen_IfClause::mutable_then() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.IfClause.then) + return _internal_mutable_then(); +} +inline void Expression_IfThen_IfClause::set_allocated_then(::io::substrait::Expression* then) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete then_; } - if (fixed_binary != nullptr) { - set_has_fixed_binary(); - literal_type_.fixed_binary_.UnsafeSetDefault(fixed_binary); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); - if (arena != nullptr) { - arena->Own(fixed_binary); + if (then) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(then); + if (message_arena != submessage_arena) { + then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, then, submessage_arena); } + + } else { + } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.fixed_binary) + then_ = then; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.IfClause.then) } -// bytes decimal = 24; -inline bool Expression_Literal::_internal_has_decimal() const { - return literal_type_case() == kDecimal; -} -inline bool Expression_Literal::has_decimal() const { - return _internal_has_decimal(); -} -inline void Expression_Literal::set_has_decimal() { - _oneof_case_[0] = kDecimal; +// ------------------------------------------------------------------- + +// Expression_IfThen + +// repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; +inline int Expression_IfThen::_internal_ifs_size() const { + return ifs_.size(); } -inline void Expression_Literal::clear_decimal() { - if (_internal_has_decimal()) { - literal_type_.decimal_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - clear_has_literal_type(); - } +inline int Expression_IfThen::ifs_size() const { + return _internal_ifs_size(); } -inline const std::string& Expression_Literal::decimal() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.decimal) - return _internal_decimal(); +inline void Expression_IfThen::clear_ifs() { + ifs_.Clear(); } -template -inline void Expression_Literal::set_decimal(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_decimal()) { - clear_literal_type(); - set_has_decimal(); - literal_type_.decimal_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.decimal_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.decimal) +inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::mutable_ifs(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.ifs) + return ifs_.Mutable(index); } -inline std::string* Expression_Literal::mutable_decimal() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.decimal) - return _internal_mutable_decimal(); +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >* +Expression_IfThen::mutable_ifs() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.IfThen.ifs) + return &ifs_; } -inline const std::string& Expression_Literal::_internal_decimal() const { - if (_internal_has_decimal()) { - return literal_type_.decimal_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +inline const ::io::substrait::Expression_IfThen_IfClause& Expression_IfThen::_internal_ifs(int index) const { + return ifs_.Get(index); } -inline void Expression_Literal::_internal_set_decimal(const std::string& value) { - if (!_internal_has_decimal()) { - clear_literal_type(); - set_has_decimal(); - literal_type_.decimal_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.decimal_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline const ::io::substrait::Expression_IfThen_IfClause& Expression_IfThen::ifs(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.ifs) + return _internal_ifs(index); } -inline std::string* Expression_Literal::_internal_mutable_decimal() { - if (!_internal_has_decimal()) { - clear_literal_type(); - set_has_decimal(); - literal_type_.decimal_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return literal_type_.decimal_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::_internal_add_ifs() { + return ifs_.Add(); } -inline std::string* Expression_Literal::release_decimal() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.decimal) - if (_internal_has_decimal()) { - clear_has_literal_type(); - return literal_type_.decimal_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - } else { - return nullptr; - } +inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::add_ifs() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.IfThen.ifs) + return _internal_add_ifs(); } -inline void Expression_Literal::set_allocated_decimal(std::string* decimal) { - if (has_literal_type()) { - clear_literal_type(); - } - if (decimal != nullptr) { - set_has_decimal(); - literal_type_.decimal_.UnsafeSetDefault(decimal); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); - if (arena != nullptr) { - arena->Own(decimal); - } - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.decimal) +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >& +Expression_IfThen::ifs() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.IfThen.ifs) + return ifs_; } -// .io.substrait.Expression.Literal.Struct struct = 25; -inline bool Expression_Literal::_internal_has_struct_() const { - return literal_type_case() == kStruct; -} -inline bool Expression_Literal::has_struct_() const { - return _internal_has_struct_(); +// .io.substrait.Expression else = 2; +inline bool Expression_IfThen::_internal_has_else_() const { + return this != internal_default_instance() && else__ != nullptr; } -inline void Expression_Literal::set_has_struct_() { - _oneof_case_[0] = kStruct; +inline bool Expression_IfThen::has_else_() const { + return _internal_has_else_(); } -inline void Expression_Literal::clear_struct_() { - if (_internal_has_struct_()) { - if (GetArena() == nullptr) { - delete literal_type_.struct__; - } - clear_has_literal_type(); +inline void Expression_IfThen::clear_else_() { + if (GetArena() == nullptr && else__ != nullptr) { + delete else__; } + else__ = nullptr; } -inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.struct) - if (_internal_has_struct_()) { - clear_has_literal_type(); - ::io::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.struct__ = nullptr; - return temp; +inline const ::io::substrait::Expression& Expression_IfThen::_internal_else_() const { + const ::io::substrait::Expression* p = else__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_IfThen::else_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.else) + return _internal_else_(); +} +inline void Expression_IfThen::unsafe_arena_set_allocated_else_( + ::io::substrait::Expression* else_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); + } + else__ = else_; + if (else_) { + } else { - return nullptr; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.else) } -inline const ::io::substrait::Expression_Literal_Struct& Expression_Literal::_internal_struct_() const { - return _internal_has_struct_() - ? *literal_type_.struct__ - : reinterpret_cast< ::io::substrait::Expression_Literal_Struct&>(::io::substrait::_Expression_Literal_Struct_default_instance_); +inline ::io::substrait::Expression* Expression_IfThen::release_else_() { + + ::io::substrait::Expression* temp = else__; + else__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline const ::io::substrait::Expression_Literal_Struct& Expression_Literal::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.struct) - return _internal_struct_(); +inline ::io::substrait::Expression* Expression_IfThen::unsafe_arena_release_else_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.else) + + ::io::substrait::Expression* temp = else__; + else__ = nullptr; + return temp; } -inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.struct) - if (_internal_has_struct_()) { - clear_has_literal_type(); - ::io::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; - literal_type_.struct__ = nullptr; - return temp; - } else { - return nullptr; +inline ::io::substrait::Expression* Expression_IfThen::_internal_mutable_else_() { + + if (else__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + else__ = p; } + return else__; } -inline void Expression_Literal::unsafe_arena_set_allocated_struct_(::io::substrait::Expression_Literal_Struct* struct_) { - clear_literal_type(); - if (struct_) { - set_has_struct_(); - literal_type_.struct__ = struct_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.struct) +inline ::io::substrait::Expression* Expression_IfThen::mutable_else_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.else) + return _internal_mutable_else_(); } -inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::_internal_mutable_struct_() { - if (!_internal_has_struct_()) { - clear_literal_type(); - set_has_struct_(); - literal_type_.struct__ = CreateMaybeMessage< ::io::substrait::Expression_Literal_Struct >(GetArena()); +inline void Expression_IfThen::set_allocated_else_(::io::substrait::Expression* else_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete else__; } - return literal_type_.struct__; -} -inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.struct) - return _internal_mutable_struct_(); + if (else_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(else_); + if (message_arena != submessage_arena) { + else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, else_, submessage_arena); + } + + } else { + + } + else__ = else_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.else) } -// .io.substrait.Expression.Literal.Map map = 26; -inline bool Expression_Literal::_internal_has_map() const { - return literal_type_case() == kMap; +// ------------------------------------------------------------------- + +// Expression_Cast + +// .io.substrait.Type type = 1; +inline bool Expression_Cast::_internal_has_type() const { + return this != internal_default_instance() && type_ != nullptr; } -inline bool Expression_Literal::has_map() const { - return _internal_has_map(); +inline bool Expression_Cast::has_type() const { + return _internal_has_type(); } -inline void Expression_Literal::set_has_map() { - _oneof_case_[0] = kMap; +inline const ::io::substrait::Type& Expression_Cast::_internal_type() const { + const ::io::substrait::Type* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); } -inline void Expression_Literal::clear_map() { - if (_internal_has_map()) { - if (GetArena() == nullptr) { - delete literal_type_.map_; - } - clear_has_literal_type(); - } +inline const ::io::substrait::Type& Expression_Cast::type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Cast.type) + return _internal_type(); } -inline ::io::substrait::Expression_Literal_Map* Expression_Literal::release_map() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.map) - if (_internal_has_map()) { - clear_has_literal_type(); - ::io::substrait::Expression_Literal_Map* temp = literal_type_.map_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.map_ = nullptr; - return temp; +inline void Expression_Cast::unsafe_arena_set_allocated_type( + ::io::substrait::Type* type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); + } + type_ = type; + if (type) { + } else { - return nullptr; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Cast.type) } -inline const ::io::substrait::Expression_Literal_Map& Expression_Literal::_internal_map() const { - return _internal_has_map() - ? *literal_type_.map_ - : reinterpret_cast< ::io::substrait::Expression_Literal_Map&>(::io::substrait::_Expression_Literal_Map_default_instance_); +inline ::io::substrait::Type* Expression_Cast::release_type() { + + ::io::substrait::Type* temp = type_; + type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline const ::io::substrait::Expression_Literal_Map& Expression_Literal::map() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.map) - return _internal_map(); +inline ::io::substrait::Type* Expression_Cast::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Cast.type) + + ::io::substrait::Type* temp = type_; + type_ = nullptr; + return temp; } -inline ::io::substrait::Expression_Literal_Map* Expression_Literal::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.map) - if (_internal_has_map()) { - clear_has_literal_type(); - ::io::substrait::Expression_Literal_Map* temp = literal_type_.map_; - literal_type_.map_ = nullptr; - return temp; - } else { - return nullptr; +inline ::io::substrait::Type* Expression_Cast::_internal_mutable_type() { + + if (type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + type_ = p; } + return type_; } -inline void Expression_Literal::unsafe_arena_set_allocated_map(::io::substrait::Expression_Literal_Map* map) { - clear_literal_type(); - if (map) { - set_has_map(); - literal_type_.map_ = map; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.map) +inline ::io::substrait::Type* Expression_Cast::mutable_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Cast.type) + return _internal_mutable_type(); } -inline ::io::substrait::Expression_Literal_Map* Expression_Literal::_internal_mutable_map() { - if (!_internal_has_map()) { - clear_literal_type(); - set_has_map(); - literal_type_.map_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_Map >(GetArena()); +inline void Expression_Cast::set_allocated_type(::io::substrait::Type* type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } - return literal_type_.map_; -} -inline ::io::substrait::Expression_Literal_Map* Expression_Literal::mutable_map() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.map) - return _internal_mutable_map(); + if (type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)->GetArena(); + if (message_arena != submessage_arena) { + type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, type, submessage_arena); + } + + } else { + + } + type_ = type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Cast.type) } -// fixed64 timestamp_tz = 27; -inline bool Expression_Literal::_internal_has_timestamp_tz() const { - return literal_type_case() == kTimestampTz; +// .io.substrait.Expression input = 2; +inline bool Expression_Cast::_internal_has_input() const { + return this != internal_default_instance() && input_ != nullptr; } -inline bool Expression_Literal::has_timestamp_tz() const { - return _internal_has_timestamp_tz(); +inline bool Expression_Cast::has_input() const { + return _internal_has_input(); } -inline void Expression_Literal::set_has_timestamp_tz() { - _oneof_case_[0] = kTimestampTz; +inline void Expression_Cast::clear_input() { + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; } -inline void Expression_Literal::clear_timestamp_tz() { - if (_internal_has_timestamp_tz()) { - literal_type_.timestamp_tz_ = PROTOBUF_ULONGLONG(0); - clear_has_literal_type(); +inline const ::io::substrait::Expression& Expression_Cast::_internal_input() const { + const ::io::substrait::Expression* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_Cast::input() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.Cast.input) + return _internal_input(); +} +inline void Expression_Cast::unsafe_arena_set_allocated_input( + ::io::substrait::Expression* input) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); + } + input_ = input; + if (input) { + + } else { + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Cast.input) } -inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::_internal_timestamp_tz() const { - if (_internal_has_timestamp_tz()) { - return literal_type_.timestamp_tz_; +inline ::io::substrait::Expression* Expression_Cast::release_input() { + + ::io::substrait::Expression* temp = input_; + input_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - return PROTOBUF_ULONGLONG(0); + return temp; } -inline void Expression_Literal::_internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::uint64 value) { - if (!_internal_has_timestamp_tz()) { - clear_literal_type(); - set_has_timestamp_tz(); +inline ::io::substrait::Expression* Expression_Cast::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.Cast.input) + + ::io::substrait::Expression* temp = input_; + input_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_Cast::_internal_mutable_input() { + + if (input_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + input_ = p; } - literal_type_.timestamp_tz_ = value; + return input_; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 Expression_Literal::timestamp_tz() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.timestamp_tz) - return _internal_timestamp_tz(); +inline ::io::substrait::Expression* Expression_Cast::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Cast.input) + return _internal_mutable_input(); } -inline void Expression_Literal::set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::uint64 value) { - _internal_set_timestamp_tz(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.timestamp_tz) +inline void Expression_Cast::set_allocated_input(::io::substrait::Expression* input) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete input_; + } + if (input) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + if (message_arena != submessage_arena) { + input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input, submessage_arena); + } + + } else { + + } + input_ = input; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Cast.input) } -// bytes uuid = 28; -inline bool Expression_Literal::_internal_has_uuid() const { - return literal_type_case() == kUuid; -} -inline bool Expression_Literal::has_uuid() const { - return _internal_has_uuid(); +// ------------------------------------------------------------------- + +// Expression_SwitchExpression_IfValue + +// .io.substrait.Expression.Literal if = 1; +inline bool Expression_SwitchExpression_IfValue::_internal_has_if_() const { + return this != internal_default_instance() && if__ != nullptr; } -inline void Expression_Literal::set_has_uuid() { - _oneof_case_[0] = kUuid; +inline bool Expression_SwitchExpression_IfValue::has_if_() const { + return _internal_has_if_(); } -inline void Expression_Literal::clear_uuid() { - if (_internal_has_uuid()) { - literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - clear_has_literal_type(); +inline void Expression_SwitchExpression_IfValue::clear_if_() { + if (GetArena() == nullptr && if__ != nullptr) { + delete if__; } + if__ = nullptr; } -inline const std::string& Expression_Literal::uuid() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.uuid) - return _internal_uuid(); -} -template -inline void Expression_Literal::set_uuid(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_uuid()) { - clear_literal_type(); - set_has_uuid(); - literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.uuid_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.uuid) +inline const ::io::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::_internal_if_() const { + const ::io::substrait::Expression_Literal* p = if__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_Literal_default_instance_); } -inline std::string* Expression_Literal::mutable_uuid() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.uuid) - return _internal_mutable_uuid(); +inline const ::io::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::if_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.IfValue.if) + return _internal_if_(); } -inline const std::string& Expression_Literal::_internal_uuid() const { - if (_internal_has_uuid()) { - return literal_type_.uuid_.Get(); +inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_if_( + ::io::substrait::Expression_Literal* if_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Expression_Literal::_internal_set_uuid(const std::string& value) { - if (!_internal_has_uuid()) { - clear_literal_type(); - set_has_uuid(); - literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if__ = if_; + if (if_) { + + } else { + } - literal_type_.uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.if) } -inline std::string* Expression_Literal::_internal_mutable_uuid() { - if (!_internal_has_uuid()) { - clear_literal_type(); - set_has_uuid(); - literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline ::io::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::release_if_() { + + ::io::substrait::Expression_Literal* temp = if__; + if__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - return literal_type_.uuid_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return temp; } -inline std::string* Expression_Literal::release_uuid() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.uuid) - if (_internal_has_uuid()) { - clear_has_literal_type(); - return literal_type_.uuid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - } else { - return nullptr; +inline ::io::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::unsafe_arena_release_if_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.IfValue.if) + + ::io::substrait::Expression_Literal* temp = if__; + if__ = nullptr; + return temp; +} +inline ::io::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::_internal_mutable_if_() { + + if (if__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); + if__ = p; } + return if__; } -inline void Expression_Literal::set_allocated_uuid(std::string* uuid) { - if (has_literal_type()) { - clear_literal_type(); +inline ::io::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::mutable_if_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.IfValue.if) + return _internal_mutable_if_(); +} +inline void Expression_SwitchExpression_IfValue::set_allocated_if_(::io::substrait::Expression_Literal* if_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete if__; } - if (uuid != nullptr) { - set_has_uuid(); - literal_type_.uuid_.UnsafeSetDefault(uuid); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); - if (arena != nullptr) { - arena->Own(uuid); + if (if_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_); + if (message_arena != submessage_arena) { + if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, if_, submessage_arena); } + + } else { + } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.uuid) + if__ = if_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.if) } -// .io.substrait.Type null = 29; -inline bool Expression_Literal::_internal_has_null() const { - return literal_type_case() == kNull; -} -inline bool Expression_Literal::has_null() const { - return _internal_has_null(); +// .io.substrait.Expression then = 2; +inline bool Expression_SwitchExpression_IfValue::_internal_has_then() const { + return this != internal_default_instance() && then_ != nullptr; } -inline void Expression_Literal::set_has_null() { - _oneof_case_[0] = kNull; +inline bool Expression_SwitchExpression_IfValue::has_then() const { + return _internal_has_then(); } -inline ::io::substrait::Type* Expression_Literal::release_null() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.null) - if (_internal_has_null()) { - clear_has_literal_type(); - ::io::substrait::Type* temp = literal_type_.null_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.null_ = nullptr; - return temp; - } else { - return nullptr; +inline void Expression_SwitchExpression_IfValue::clear_then() { + if (GetArena() == nullptr && then_ != nullptr) { + delete then_; } + then_ = nullptr; } -inline const ::io::substrait::Type& Expression_Literal::_internal_null() const { - return _internal_has_null() - ? *literal_type_.null_ - : reinterpret_cast< ::io::substrait::Type&>(::io::substrait::_Type_default_instance_); +inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::_internal_then() const { + const ::io::substrait::Expression* p = then_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Type& Expression_Literal::null() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.null) - return _internal_null(); +inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::then() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.IfValue.then) + return _internal_then(); } -inline ::io::substrait::Type* Expression_Literal::unsafe_arena_release_null() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.null) - if (_internal_has_null()) { - clear_has_literal_type(); - ::io::substrait::Type* temp = literal_type_.null_; - literal_type_.null_ = nullptr; - return temp; +inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_then( + ::io::substrait::Expression* then) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); + } + then_ = then; + if (then) { + } else { - return nullptr; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.then) } -inline void Expression_Literal::unsafe_arena_set_allocated_null(::io::substrait::Type* null) { - clear_literal_type(); - if (null) { - set_has_null(); - literal_type_.null_ = null; +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::release_then() { + + ::io::substrait::Expression* temp = then_; + then_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.null) + return temp; } -inline ::io::substrait::Type* Expression_Literal::_internal_mutable_null() { - if (!_internal_has_null()) { - clear_literal_type(); - set_has_null(); - literal_type_.null_ = CreateMaybeMessage< ::io::substrait::Type >(GetArena()); +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_arena_release_then() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.IfValue.then) + + ::io::substrait::Expression* temp = then_; + then_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::_internal_mutable_then() { + + if (then_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + then_ = p; } - return literal_type_.null_; + return then_; } -inline ::io::substrait::Type* Expression_Literal::mutable_null() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.null) - return _internal_mutable_null(); +inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::mutable_then() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.IfValue.then) + return _internal_mutable_then(); +} +inline void Expression_SwitchExpression_IfValue::set_allocated_then(::io::substrait::Expression* then) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete then_; + } + if (then) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(then); + if (message_arena != submessage_arena) { + then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, then, submessage_arena); + } + + } else { + + } + then_ = then; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.then) } -// .io.substrait.Expression.Literal.List list = 30; -inline bool Expression_Literal::_internal_has_list() const { - return literal_type_case() == kList; +// ------------------------------------------------------------------- + +// Expression_SwitchExpression + +// repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; +inline int Expression_SwitchExpression::_internal_ifs_size() const { + return ifs_.size(); } -inline bool Expression_Literal::has_list() const { - return _internal_has_list(); +inline int Expression_SwitchExpression::ifs_size() const { + return _internal_ifs_size(); } -inline void Expression_Literal::set_has_list() { - _oneof_case_[0] = kList; +inline void Expression_SwitchExpression::clear_ifs() { + ifs_.Clear(); } -inline void Expression_Literal::clear_list() { - if (_internal_has_list()) { - if (GetArena() == nullptr) { - delete literal_type_.list_; - } - clear_has_literal_type(); - } +inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::mutable_ifs(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.ifs) + return ifs_.Mutable(index); } -inline ::io::substrait::Expression_Literal_List* Expression_Literal::release_list() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.list) - if (_internal_has_list()) { - clear_has_literal_type(); - ::io::substrait::Expression_Literal_List* temp = literal_type_.list_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.list_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >* +Expression_SwitchExpression::mutable_ifs() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.SwitchExpression.ifs) + return &ifs_; +} +inline const ::io::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::_internal_ifs(int index) const { + return ifs_.Get(index); +} +inline const ::io::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::ifs(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.ifs) + return _internal_ifs(index); +} +inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::_internal_add_ifs() { + return ifs_.Add(); +} +inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::add_ifs() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.SwitchExpression.ifs) + return _internal_add_ifs(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >& +Expression_SwitchExpression::ifs() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.SwitchExpression.ifs) + return ifs_; } -inline const ::io::substrait::Expression_Literal_List& Expression_Literal::_internal_list() const { - return _internal_has_list() - ? *literal_type_.list_ - : reinterpret_cast< ::io::substrait::Expression_Literal_List&>(::io::substrait::_Expression_Literal_List_default_instance_); + +// .io.substrait.Expression else = 2; +inline bool Expression_SwitchExpression::_internal_has_else_() const { + return this != internal_default_instance() && else__ != nullptr; } -inline const ::io::substrait::Expression_Literal_List& Expression_Literal::list() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.list) - return _internal_list(); +inline bool Expression_SwitchExpression::has_else_() const { + return _internal_has_else_(); } -inline ::io::substrait::Expression_Literal_List* Expression_Literal::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.list) - if (_internal_has_list()) { - clear_has_literal_type(); - ::io::substrait::Expression_Literal_List* temp = literal_type_.list_; - literal_type_.list_ = nullptr; - return temp; - } else { - return nullptr; +inline void Expression_SwitchExpression::clear_else_() { + if (GetArena() == nullptr && else__ != nullptr) { + delete else__; } + else__ = nullptr; } -inline void Expression_Literal::unsafe_arena_set_allocated_list(::io::substrait::Expression_Literal_List* list) { - clear_literal_type(); - if (list) { - set_has_list(); - literal_type_.list_ = list; +inline const ::io::substrait::Expression& Expression_SwitchExpression::_internal_else_() const { + const ::io::substrait::Expression* p = else__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& Expression_SwitchExpression::else_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.else) + return _internal_else_(); +} +inline void Expression_SwitchExpression::unsafe_arena_set_allocated_else_( + ::io::substrait::Expression* else_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.list) + else__ = else_; + if (else_) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.else) } -inline ::io::substrait::Expression_Literal_List* Expression_Literal::_internal_mutable_list() { - if (!_internal_has_list()) { - clear_literal_type(); - set_has_list(); - literal_type_.list_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_List >(GetArena()); +inline ::io::substrait::Expression* Expression_SwitchExpression::release_else_() { + + ::io::substrait::Expression* temp = else__; + else__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - return literal_type_.list_; + return temp; } -inline ::io::substrait::Expression_Literal_List* Expression_Literal::mutable_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.list) - return _internal_mutable_list(); +inline ::io::substrait::Expression* Expression_SwitchExpression::unsafe_arena_release_else_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.else) + + ::io::substrait::Expression* temp = else__; + else__ = nullptr; + return temp; } - -inline bool Expression_Literal::has_literal_type() const { - return literal_type_case() != LITERAL_TYPE_NOT_SET; +inline ::io::substrait::Expression* Expression_SwitchExpression::_internal_mutable_else_() { + + if (else__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + else__ = p; + } + return else__; } -inline void Expression_Literal::clear_has_literal_type() { - _oneof_case_[0] = LITERAL_TYPE_NOT_SET; +inline ::io::substrait::Expression* Expression_SwitchExpression::mutable_else_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.else) + return _internal_mutable_else_(); } -inline Expression_Literal::LiteralTypeCase Expression_Literal::literal_type_case() const { - return Expression_Literal::LiteralTypeCase(_oneof_case_[0]); +inline void Expression_SwitchExpression::set_allocated_else_(::io::substrait::Expression* else_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete else__; + } + if (else_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(else_); + if (message_arena != submessage_arena) { + else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, else_, submessage_arena); + } + + } else { + + } + else__ = else_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.else) } + // ------------------------------------------------------------------- -// Expression_ScalarFunction +// Expression_SingularOrList -// .io.substrait.Extensions.FunctionId id = 1; -inline bool Expression_ScalarFunction::_internal_has_id() const { - return this != internal_default_instance() && id_ != nullptr; +// .io.substrait.Expression value = 1; +inline bool Expression_SingularOrList::_internal_has_value() const { + return this != internal_default_instance() && value_ != nullptr; +} +inline bool Expression_SingularOrList::has_value() const { + return _internal_has_value(); } -inline bool Expression_ScalarFunction::has_id() const { - return _internal_has_id(); +inline void Expression_SingularOrList::clear_value() { + if (GetArena() == nullptr && value_ != nullptr) { + delete value_; + } + value_ = nullptr; } -inline const ::io::substrait::Extensions_FunctionId& Expression_ScalarFunction::_internal_id() const { - const ::io::substrait::Extensions_FunctionId* p = id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_FunctionId_default_instance_); +inline const ::io::substrait::Expression& Expression_SingularOrList::_internal_value() const { + const ::io::substrait::Expression* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Extensions_FunctionId& Expression_ScalarFunction::id() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.id) - return _internal_id(); +inline const ::io::substrait::Expression& Expression_SingularOrList::value() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SingularOrList.value) + return _internal_value(); } -inline void Expression_ScalarFunction::unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id) { +inline void Expression_SingularOrList::unsafe_arena_set_allocated_value( + ::io::substrait::Expression* value) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } - id_ = id; - if (id) { + value_ = value; + if (value) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ScalarFunction.id) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SingularOrList.value) } -inline ::io::substrait::Extensions_FunctionId* Expression_ScalarFunction::release_id() { +inline ::io::substrait::Expression* Expression_SingularOrList::release_value() { - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; + ::io::substrait::Expression* temp = value_; + value_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Extensions_FunctionId* Expression_ScalarFunction::unsafe_arena_release_id() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.ScalarFunction.id) +inline ::io::substrait::Expression* Expression_SingularOrList::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.SingularOrList.value) - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; + ::io::substrait::Expression* temp = value_; + value_ = nullptr; return temp; } -inline ::io::substrait::Extensions_FunctionId* Expression_ScalarFunction::_internal_mutable_id() { +inline ::io::substrait::Expression* Expression_SingularOrList::_internal_mutable_value() { - if (id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); - id_ = p; + if (value_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + value_ = p; } - return id_; + return value_; } -inline ::io::substrait::Extensions_FunctionId* Expression_ScalarFunction::mutable_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ScalarFunction.id) - return _internal_mutable_id(); +inline ::io::substrait::Expression* Expression_SingularOrList::mutable_value() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SingularOrList.value) + return _internal_mutable_value(); } -inline void Expression_ScalarFunction::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { +inline void Expression_SingularOrList::set_allocated_value(::io::substrait::Expression* value) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + delete value_; } - if (id) { + if (value) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); if (message_arena != submessage_arena) { - id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, id, submessage_arena); + value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, value, submessage_arena); } } else { } - id_ = id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ScalarFunction.id) + value_ = value; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SingularOrList.value) } -// repeated .io.substrait.Expression args = 2; -inline int Expression_ScalarFunction::_internal_args_size() const { - return args_.size(); +// repeated .io.substrait.Expression options = 2; +inline int Expression_SingularOrList::_internal_options_size() const { + return options_.size(); } -inline int Expression_ScalarFunction::args_size() const { - return _internal_args_size(); +inline int Expression_SingularOrList::options_size() const { + return _internal_options_size(); +} +inline void Expression_SingularOrList::clear_options() { + options_.Clear(); +} +inline ::io::substrait::Expression* Expression_SingularOrList::mutable_options(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SingularOrList.options) + return options_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_SingularOrList::mutable_options() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.SingularOrList.options) + return &options_; +} +inline const ::io::substrait::Expression& Expression_SingularOrList::_internal_options(int index) const { + return options_.Get(index); +} +inline const ::io::substrait::Expression& Expression_SingularOrList::options(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.SingularOrList.options) + return _internal_options(index); +} +inline ::io::substrait::Expression* Expression_SingularOrList::_internal_add_options() { + return options_.Add(); +} +inline ::io::substrait::Expression* Expression_SingularOrList::add_options() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.SingularOrList.options) + return _internal_add_options(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_SingularOrList::options() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.SingularOrList.options) + return options_; +} + +// ------------------------------------------------------------------- + +// Expression_MultiOrList_Record + +// repeated .io.substrait.Expression fields = 1; +inline int Expression_MultiOrList_Record::_internal_fields_size() const { + return fields_.size(); +} +inline int Expression_MultiOrList_Record::fields_size() const { + return _internal_fields_size(); +} +inline void Expression_MultiOrList_Record::clear_fields() { + fields_.Clear(); +} +inline ::io::substrait::Expression* Expression_MultiOrList_Record::mutable_fields(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.Record.fields) + return fields_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_MultiOrList_Record::mutable_fields() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.Record.fields) + return &fields_; +} +inline const ::io::substrait::Expression& Expression_MultiOrList_Record::_internal_fields(int index) const { + return fields_.Get(index); +} +inline const ::io::substrait::Expression& Expression_MultiOrList_Record::fields(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.Record.fields) + return _internal_fields(index); +} +inline ::io::substrait::Expression* Expression_MultiOrList_Record::_internal_add_fields() { + return fields_.Add(); +} +inline ::io::substrait::Expression* Expression_MultiOrList_Record::add_fields() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.Record.fields) + return _internal_add_fields(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_MultiOrList_Record::fields() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.Record.fields) + return fields_; +} + +// ------------------------------------------------------------------- + +// Expression_MultiOrList + +// repeated .io.substrait.Expression value = 1; +inline int Expression_MultiOrList::_internal_value_size() const { + return value_.size(); +} +inline int Expression_MultiOrList::value_size() const { + return _internal_value_size(); } -inline void Expression_ScalarFunction::clear_args() { - args_.Clear(); +inline void Expression_MultiOrList::clear_value() { + value_.Clear(); } -inline ::io::substrait::Expression* Expression_ScalarFunction::mutable_args(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ScalarFunction.args) - return args_.Mutable(index); +inline ::io::substrait::Expression* Expression_MultiOrList::mutable_value(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.value) + return value_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* -Expression_ScalarFunction::mutable_args() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.ScalarFunction.args) - return &args_; +Expression_MultiOrList::mutable_value() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.value) + return &value_; } -inline const ::io::substrait::Expression& Expression_ScalarFunction::_internal_args(int index) const { - return args_.Get(index); +inline const ::io::substrait::Expression& Expression_MultiOrList::_internal_value(int index) const { + return value_.Get(index); } -inline const ::io::substrait::Expression& Expression_ScalarFunction::args(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.args) - return _internal_args(index); +inline const ::io::substrait::Expression& Expression_MultiOrList::value(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.value) + return _internal_value(index); } -inline ::io::substrait::Expression* Expression_ScalarFunction::_internal_add_args() { - return args_.Add(); +inline ::io::substrait::Expression* Expression_MultiOrList::_internal_add_value() { + return value_.Add(); } -inline ::io::substrait::Expression* Expression_ScalarFunction::add_args() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.ScalarFunction.args) - return _internal_add_args(); +inline ::io::substrait::Expression* Expression_MultiOrList::add_value() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.value) + return _internal_add_value(); } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& -Expression_ScalarFunction::args() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.ScalarFunction.args) - return args_; +Expression_MultiOrList::value() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.value) + return value_; } -// .io.substrait.Type output_type = 3; -inline bool Expression_ScalarFunction::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; +// repeated .io.substrait.Expression.MultiOrList.Record options = 2; +inline int Expression_MultiOrList::_internal_options_size() const { + return options_.size(); } -inline bool Expression_ScalarFunction::has_output_type() const { - return _internal_has_output_type(); +inline int Expression_MultiOrList::options_size() const { + return _internal_options_size(); } -inline const ::io::substrait::Type& Expression_ScalarFunction::_internal_output_type() const { - const ::io::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline void Expression_MultiOrList::clear_options() { + options_.Clear(); } -inline const ::io::substrait::Type& Expression_ScalarFunction::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.output_type) - return _internal_output_type(); +inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::mutable_options(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.options) + return options_.Mutable(index); } -inline void Expression_ScalarFunction::unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - output_type_ = output_type; - if (output_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ScalarFunction.output_type) +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >* +Expression_MultiOrList::mutable_options() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.options) + return &options_; } -inline ::io::substrait::Type* Expression_ScalarFunction::release_output_type() { - - ::io::substrait::Type* temp = output_type_; - output_type_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline const ::io::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::_internal_options(int index) const { + return options_.Get(index); } -inline ::io::substrait::Type* Expression_ScalarFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.ScalarFunction.output_type) - - ::io::substrait::Type* temp = output_type_; - output_type_ = nullptr; - return temp; +inline const ::io::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::options(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.options) + return _internal_options(index); } -inline ::io::substrait::Type* Expression_ScalarFunction::_internal_mutable_output_type() { - - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); - output_type_ = p; - } - return output_type_; +inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::_internal_add_options() { + return options_.Add(); } -inline ::io::substrait::Type* Expression_ScalarFunction::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ScalarFunction.output_type) - return _internal_mutable_output_type(); +inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::add_options() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.options) + return _internal_add_options(); } -inline void Expression_ScalarFunction::set_allocated_output_type(::io::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - if (output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); - if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); - } - - } else { - - } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ScalarFunction.output_type) +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >& +Expression_MultiOrList::options() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.options) + return options_; } // ------------------------------------------------------------------- -// Expression_AggregateFunction +// Expression_EmbeddedFunction_PythonPickleFunction -// .io.substrait.Extensions.FunctionId id = 1; -inline bool Expression_AggregateFunction::_internal_has_id() const { - return this != internal_default_instance() && id_ != nullptr; -} -inline bool Expression_AggregateFunction::has_id() const { - return _internal_has_id(); +// bytes function = 1; +inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_function() { + function_.ClearToEmpty(); } -inline const ::io::substrait::Extensions_FunctionId& Expression_AggregateFunction::_internal_id() const { - const ::io::substrait::Extensions_FunctionId* p = id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_FunctionId_default_instance_); +inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + return _internal_function(); } -inline const ::io::substrait::Extensions_FunctionId& Expression_AggregateFunction::id() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.AggregateFunction.id) - return _internal_id(); +template +PROTOBUF_ALWAYS_INLINE +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_function(ArgT0&& arg0, ArgT... args) { + + function_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) } -inline void Expression_AggregateFunction::unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); - } - id_ = id; - if (id) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.AggregateFunction.id) +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + return _internal_mutable_function(); } -inline ::io::substrait::Extensions_FunctionId* Expression_AggregateFunction::release_id() { - - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_function() const { + return function_.Get(); } -inline ::io::substrait::Extensions_FunctionId* Expression_AggregateFunction::unsafe_arena_release_id() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.AggregateFunction.id) +inline void Expression_EmbeddedFunction_PythonPickleFunction::_internal_set_function(const std::string& value) { - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; - return temp; + function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline ::io::substrait::Extensions_FunctionId* Expression_AggregateFunction::_internal_mutable_id() { +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_mutable_function() { - if (id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); - id_ = p; - } - return id_; + return function_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline ::io::substrait::Extensions_FunctionId* Expression_AggregateFunction::mutable_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.AggregateFunction.id) - return _internal_mutable_id(); +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::release_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + return function_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void Expression_AggregateFunction::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); - } - if (id) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); - if (message_arena != submessage_arena) { - id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, id, submessage_arena); - } +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_allocated_function(std::string* function) { + if (function != nullptr) { } else { } - id_ = id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.AggregateFunction.id) + function_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), function, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) } -// repeated .io.substrait.Expression args = 2; -inline int Expression_AggregateFunction::_internal_args_size() const { - return args_.size(); -} -inline int Expression_AggregateFunction::args_size() const { - return _internal_args_size(); -} -inline void Expression_AggregateFunction::clear_args() { - args_.Clear(); -} -inline ::io::substrait::Expression* Expression_AggregateFunction::mutable_args(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.AggregateFunction.args) - return args_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* -Expression_AggregateFunction::mutable_args() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.AggregateFunction.args) - return &args_; -} -inline const ::io::substrait::Expression& Expression_AggregateFunction::_internal_args(int index) const { - return args_.Get(index); -} -inline const ::io::substrait::Expression& Expression_AggregateFunction::args(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.AggregateFunction.args) - return _internal_args(index); -} -inline ::io::substrait::Expression* Expression_AggregateFunction::_internal_add_args() { - return args_.Add(); +// repeated string prerequisite = 2; +inline int Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite_size() const { + return prerequisite_.size(); } -inline ::io::substrait::Expression* Expression_AggregateFunction::add_args() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.AggregateFunction.args) - return _internal_add_args(); +inline int Expression_EmbeddedFunction_PythonPickleFunction::prerequisite_size() const { + return _internal_prerequisite_size(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& -Expression_AggregateFunction::args() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.AggregateFunction.args) - return args_; +inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_prerequisite() { + prerequisite_.Clear(); } - -// repeated .io.substrait.Expression.SortField sorts = 3; -inline int Expression_AggregateFunction::_internal_sorts_size() const { - return sorts_.size(); +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return _internal_add_prerequisite(); } -inline int Expression_AggregateFunction::sorts_size() const { - return _internal_sorts_size(); +inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite(int index) const { + return prerequisite_.Get(index); } -inline void Expression_AggregateFunction::clear_sorts() { - sorts_.Clear(); +inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::prerequisite(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return _internal_prerequisite(index); } -inline ::io::substrait::Expression_SortField* Expression_AggregateFunction::mutable_sorts(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.AggregateFunction.sorts) - return sorts_.Mutable(index); +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return prerequisite_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* -Expression_AggregateFunction::mutable_sorts() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.AggregateFunction.sorts) - return &sorts_; +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + prerequisite_.Mutable(index)->assign(value); } -inline const ::io::substrait::Expression_SortField& Expression_AggregateFunction::_internal_sorts(int index) const { - return sorts_.Get(index); +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + prerequisite_.Mutable(index)->assign(std::move(value)); } -inline const ::io::substrait::Expression_SortField& Expression_AggregateFunction::sorts(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.AggregateFunction.sorts) - return _internal_sorts(index); +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + prerequisite_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } -inline ::io::substrait::Expression_SortField* Expression_AggregateFunction::_internal_add_sorts() { - return sorts_.Add(); +inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value, size_t size) { + prerequisite_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } -inline ::io::substrait::Expression_SortField* Expression_AggregateFunction::add_sorts() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.AggregateFunction.sorts) - return _internal_add_sorts(); +inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_add_prerequisite() { + return prerequisite_.Add(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& -Expression_AggregateFunction::sorts() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.AggregateFunction.sorts) - return sorts_; +inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const std::string& value) { + prerequisite_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } - -// .io.substrait.Expression.AggregationPhase phase = 4; -inline void Expression_AggregateFunction::clear_phase() { - phase_ = 0; +inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(std::string&& value) { + prerequisite_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } -inline ::io::substrait::Expression_AggregationPhase Expression_AggregateFunction::_internal_phase() const { - return static_cast< ::io::substrait::Expression_AggregationPhase >(phase_); +inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value) { + GOOGLE_DCHECK(value != nullptr); + prerequisite_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } -inline ::io::substrait::Expression_AggregationPhase Expression_AggregateFunction::phase() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.AggregateFunction.phase) - return _internal_phase(); +inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value, size_t size) { + prerequisite_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } -inline void Expression_AggregateFunction::_internal_set_phase(::io::substrait::Expression_AggregationPhase value) { - - phase_ = value; +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Expression_EmbeddedFunction_PythonPickleFunction::prerequisite() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return prerequisite_; } -inline void Expression_AggregateFunction::set_phase(::io::substrait::Expression_AggregationPhase value) { - _internal_set_phase(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.AggregateFunction.phase) +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + return &prerequisite_; } -// .io.substrait.Type output_type = 5; -inline bool Expression_AggregateFunction::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; -} -inline bool Expression_AggregateFunction::has_output_type() const { - return _internal_has_output_type(); +// ------------------------------------------------------------------- + +// Expression_EmbeddedFunction_WebAssemblyFunction + +// bytes script = 1; +inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_script() { + script_.ClearToEmpty(); } -inline const ::io::substrait::Type& Expression_AggregateFunction::_internal_output_type() const { - const ::io::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::script() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + return _internal_script(); } -inline const ::io::substrait::Type& Expression_AggregateFunction::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.AggregateFunction.output_type) - return _internal_output_type(); +template +PROTOBUF_ALWAYS_INLINE +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_script(ArgT0&& arg0, ArgT... args) { + + script_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) } -inline void Expression_AggregateFunction::unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - output_type_ = output_type; - if (output_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.AggregateFunction.output_type) +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_script() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + return _internal_mutable_script(); } -inline ::io::substrait::Type* Expression_AggregateFunction::release_output_type() { - - ::io::substrait::Type* temp = output_type_; - output_type_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_script() const { + return script_.Get(); } -inline ::io::substrait::Type* Expression_AggregateFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.AggregateFunction.output_type) +inline void Expression_EmbeddedFunction_WebAssemblyFunction::_internal_set_script(const std::string& value) { - ::io::substrait::Type* temp = output_type_; - output_type_ = nullptr; - return temp; + script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline ::io::substrait::Type* Expression_AggregateFunction::_internal_mutable_output_type() { +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_mutable_script() { - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); - output_type_ = p; - } - return output_type_; + return script_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline ::io::substrait::Type* Expression_AggregateFunction::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.AggregateFunction.output_type) - return _internal_mutable_output_type(); +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::release_script() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + return script_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void Expression_AggregateFunction::set_allocated_output_type(::io::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - if (output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); - if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); - } +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_allocated_script(std::string* script) { + if (script != nullptr) { } else { } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.AggregateFunction.output_type) + script_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), script, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) } -// ------------------------------------------------------------------- - -// Expression_WindowFunction_Bound_Preceding - -// int64 offset = 1; -inline void Expression_WindowFunction_Bound_Preceding::clear_offset() { - offset_ = PROTOBUF_LONGLONG(0); +// repeated string prerequisite = 2; +inline int Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite_size() const { + return prerequisite_.size(); } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Preceding::_internal_offset() const { - return offset_; +inline int Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite_size() const { + return _internal_prerequisite_size(); } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Preceding::offset() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.Preceding.offset) - return _internal_offset(); +inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_prerequisite() { + prerequisite_.Clear(); } -inline void Expression_WindowFunction_Bound_Preceding::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { - - offset_ = value; +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return _internal_add_prerequisite(); } -inline void Expression_WindowFunction_Bound_Preceding::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { - _internal_set_offset(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.Bound.Preceding.offset) +inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite(int index) const { + return prerequisite_.Get(index); } - -// ------------------------------------------------------------------- - -// Expression_WindowFunction_Bound_Following - -// int64 offset = 1; -inline void Expression_WindowFunction_Bound_Following::clear_offset() { - offset_ = PROTOBUF_LONGLONG(0); +inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return _internal_prerequisite(index); } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Following::_internal_offset() const { - return offset_; +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return prerequisite_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Following::offset() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.Following.offset) - return _internal_offset(); +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + prerequisite_.Mutable(index)->assign(value); } -inline void Expression_WindowFunction_Bound_Following::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { - - offset_ = value; +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + prerequisite_.Mutable(index)->assign(std::move(value)); } -inline void Expression_WindowFunction_Bound_Following::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { - _internal_set_offset(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.Bound.Following.offset) +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + prerequisite_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value, size_t size) { + prerequisite_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_add_prerequisite() { + return prerequisite_.Add(); +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const std::string& value) { + prerequisite_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(std::string&& value) { + prerequisite_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value) { + GOOGLE_DCHECK(value != nullptr); + prerequisite_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value, size_t size) { + prerequisite_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return prerequisite_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + return &prerequisite_; } // ------------------------------------------------------------------- -// Expression_WindowFunction_Bound_CurrentRow - -// ------------------------------------------------------------------- - -// Expression_WindowFunction_Bound_Unbounded - -// ------------------------------------------------------------------- - -// Expression_WindowFunction_Bound +// Expression_EmbeddedFunction -// .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; -inline bool Expression_WindowFunction_Bound::_internal_has_preceding() const { - return kind_case() == kPreceding; -} -inline bool Expression_WindowFunction_Bound::has_preceding() const { - return _internal_has_preceding(); +// repeated .io.substrait.Expression arguments = 1; +inline int Expression_EmbeddedFunction::_internal_arguments_size() const { + return arguments_.size(); } -inline void Expression_WindowFunction_Bound::set_has_preceding() { - _oneof_case_[0] = kPreceding; +inline int Expression_EmbeddedFunction::arguments_size() const { + return _internal_arguments_size(); } -inline void Expression_WindowFunction_Bound::clear_preceding() { - if (_internal_has_preceding()) { - if (GetArena() == nullptr) { - delete kind_.preceding_; - } - clear_has_kind(); - } +inline void Expression_EmbeddedFunction::clear_arguments() { + arguments_.Clear(); } -inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::release_preceding() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.preceding) - if (_internal_has_preceding()) { - clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.preceding_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::io::substrait::Expression* Expression_EmbeddedFunction::mutable_arguments(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.arguments) + return arguments_.Mutable(index); } -inline const ::io::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::_internal_preceding() const { - return _internal_has_preceding() - ? *kind_.preceding_ - : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Preceding&>(::io::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_); +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +Expression_EmbeddedFunction::mutable_arguments() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.arguments) + return &arguments_; } -inline const ::io::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::preceding() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.preceding) - return _internal_preceding(); +inline const ::io::substrait::Expression& Expression_EmbeddedFunction::_internal_arguments(int index) const { + return arguments_.Get(index); } -inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::unsafe_arena_release_preceding() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.preceding) - if (_internal_has_preceding()) { - clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; - kind_.preceding_ = nullptr; - return temp; - } else { - return nullptr; - } +inline const ::io::substrait::Expression& Expression_EmbeddedFunction::arguments(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.arguments) + return _internal_arguments(index); } -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_preceding(::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { - clear_kind(); - if (preceding) { - set_has_preceding(); - kind_.preceding_ = preceding; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.preceding) +inline ::io::substrait::Expression* Expression_EmbeddedFunction::_internal_add_arguments() { + return arguments_.Add(); } -inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::_internal_mutable_preceding() { - if (!_internal_has_preceding()) { - clear_kind(); - set_has_preceding(); - kind_.preceding_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Preceding >(GetArena()); - } - return kind_.preceding_; +inline ::io::substrait::Expression* Expression_EmbeddedFunction::add_arguments() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.arguments) + return _internal_add_arguments(); } -inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::mutable_preceding() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.preceding) - return _internal_mutable_preceding(); +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +Expression_EmbeddedFunction::arguments() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.arguments) + return arguments_; } -// .io.substrait.Expression.WindowFunction.Bound.Following following = 2; -inline bool Expression_WindowFunction_Bound::_internal_has_following() const { - return kind_case() == kFollowing; +// .io.substrait.Type output_type = 2; +inline bool Expression_EmbeddedFunction::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; } -inline bool Expression_WindowFunction_Bound::has_following() const { - return _internal_has_following(); +inline bool Expression_EmbeddedFunction::has_output_type() const { + return _internal_has_output_type(); } -inline void Expression_WindowFunction_Bound::set_has_following() { - _oneof_case_[0] = kFollowing; +inline const ::io::substrait::Type& Expression_EmbeddedFunction::_internal_output_type() const { + const ::io::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); } -inline void Expression_WindowFunction_Bound::clear_following() { - if (_internal_has_following()) { - if (GetArena() == nullptr) { - delete kind_.following_; - } - clear_has_kind(); - } +inline const ::io::substrait::Type& Expression_EmbeddedFunction::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.output_type) + return _internal_output_type(); } -inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::release_following() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.following) - if (_internal_has_following()) { - clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.following_ = nullptr; - return temp; +inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + output_type_ = output_type; + if (output_type) { + } else { - return nullptr; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.output_type) } -inline const ::io::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::_internal_following() const { - return _internal_has_following() - ? *kind_.following_ - : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Following&>(::io::substrait::_Expression_WindowFunction_Bound_Following_default_instance_); +inline ::io::substrait::Type* Expression_EmbeddedFunction::release_output_type() { + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline const ::io::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::following() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.following) - return _internal_following(); +inline ::io::substrait::Type* Expression_EmbeddedFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.output_type) + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + return temp; } -inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::unsafe_arena_release_following() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.following) - if (_internal_has_following()) { - clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; - kind_.following_ = nullptr; - return temp; - } else { - return nullptr; +inline ::io::substrait::Type* Expression_EmbeddedFunction::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + output_type_ = p; } + return output_type_; } -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_following(::io::substrait::Expression_WindowFunction_Bound_Following* following) { - clear_kind(); - if (following) { - set_has_following(); - kind_.following_ = following; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.following) +inline ::io::substrait::Type* Expression_EmbeddedFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.output_type) + return _internal_mutable_output_type(); } -inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::_internal_mutable_following() { - if (!_internal_has_following()) { - clear_kind(); - set_has_following(); - kind_.following_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Following >(GetArena()); +inline void Expression_EmbeddedFunction::set_allocated_output_type(::io::substrait::Type* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } - return kind_.following_; -} -inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::mutable_following() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.following) - return _internal_mutable_following(); + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); + } + + } else { + + } + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.output_type) } -// .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; -inline bool Expression_WindowFunction_Bound::_internal_has_current_row() const { - return kind_case() == kCurrentRow; +// .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; +inline bool Expression_EmbeddedFunction::_internal_has_python_pickle_function() const { + return kind_case() == kPythonPickleFunction; } -inline bool Expression_WindowFunction_Bound::has_current_row() const { - return _internal_has_current_row(); +inline bool Expression_EmbeddedFunction::has_python_pickle_function() const { + return _internal_has_python_pickle_function(); } -inline void Expression_WindowFunction_Bound::set_has_current_row() { - _oneof_case_[0] = kCurrentRow; +inline void Expression_EmbeddedFunction::set_has_python_pickle_function() { + _oneof_case_[0] = kPythonPickleFunction; } -inline void Expression_WindowFunction_Bound::clear_current_row() { - if (_internal_has_current_row()) { +inline void Expression_EmbeddedFunction::clear_python_pickle_function() { + if (_internal_has_python_pickle_function()) { if (GetArena() == nullptr) { - delete kind_.current_row_; + delete kind_.python_pickle_function_; } clear_has_kind(); } } -inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::release_current_row() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.current_row) - if (_internal_has_current_row()) { +inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::release_python_pickle_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + if (_internal_has_python_pickle_function()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; + ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - kind_.current_row_ = nullptr; + kind_.python_pickle_function_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::_internal_current_row() const { - return _internal_has_current_row() - ? *kind_.current_row_ - : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow&>(::io::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_); +inline const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::_internal_python_pickle_function() const { + return _internal_has_python_pickle_function() + ? *kind_.python_pickle_function_ + : reinterpret_cast< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction&>(::io::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::current_row() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.current_row) - return _internal_current_row(); +inline const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::python_pickle_function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + return _internal_python_pickle_function(); } -inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::unsafe_arena_release_current_row() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.current_row) - if (_internal_has_current_row()) { +inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::unsafe_arena_release_python_pickle_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + if (_internal_has_python_pickle_function()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; - kind_.current_row_ = nullptr; + ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; + kind_.python_pickle_function_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_current_row(::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { +inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_python_pickle_function(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { clear_kind(); - if (current_row) { - set_has_current_row(); - kind_.current_row_ = current_row; + if (python_pickle_function) { + set_has_python_pickle_function(); + kind_.python_pickle_function_ = python_pickle_function; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.current_row) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.python_pickle_function) } -inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::_internal_mutable_current_row() { - if (!_internal_has_current_row()) { +inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::_internal_mutable_python_pickle_function() { + if (!_internal_has_python_pickle_function()) { clear_kind(); - set_has_current_row(); - kind_.current_row_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow >(GetArena()); + set_has_python_pickle_function(); + kind_.python_pickle_function_ = CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(GetArena()); } - return kind_.current_row_; + return kind_.python_pickle_function_; } -inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::mutable_current_row() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.current_row) - return _internal_mutable_current_row(); +inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::mutable_python_pickle_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + return _internal_mutable_python_pickle_function(); } -// .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; -inline bool Expression_WindowFunction_Bound::_internal_has_unbounded() const { - return kind_case() == kUnbounded; -} -inline bool Expression_WindowFunction_Bound::has_unbounded() const { - return _internal_has_unbounded(); +// .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; +inline bool Expression_EmbeddedFunction::_internal_has_web_assembly_function() const { + return kind_case() == kWebAssemblyFunction; } -inline void Expression_WindowFunction_Bound::set_has_unbounded() { - _oneof_case_[0] = kUnbounded; +inline bool Expression_EmbeddedFunction::has_web_assembly_function() const { + return _internal_has_web_assembly_function(); } -inline void Expression_WindowFunction_Bound::clear_unbounded() { - if (_internal_has_unbounded()) { +inline void Expression_EmbeddedFunction::set_has_web_assembly_function() { + _oneof_case_[0] = kWebAssemblyFunction; +} +inline void Expression_EmbeddedFunction::clear_web_assembly_function() { + if (_internal_has_web_assembly_function()) { if (GetArena() == nullptr) { - delete kind_.unbounded_; + delete kind_.web_assembly_function_; } clear_has_kind(); } } -inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::release_unbounded() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.unbounded) - if (_internal_has_unbounded()) { +inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::release_web_assembly_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + if (_internal_has_web_assembly_function()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; + ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - kind_.unbounded_ = nullptr; + kind_.web_assembly_function_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::_internal_unbounded() const { - return _internal_has_unbounded() - ? *kind_.unbounded_ - : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Unbounded&>(::io::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_); +inline const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::_internal_web_assembly_function() const { + return _internal_has_web_assembly_function() + ? *kind_.web_assembly_function_ + : reinterpret_cast< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction&>(::io::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::unbounded() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.unbounded) - return _internal_unbounded(); +inline const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::web_assembly_function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + return _internal_web_assembly_function(); } -inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::unsafe_arena_release_unbounded() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.unbounded) - if (_internal_has_unbounded()) { +inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::unsafe_arena_release_web_assembly_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + if (_internal_has_web_assembly_function()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; - kind_.unbounded_ = nullptr; + ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; + kind_.web_assembly_function_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_unbounded(::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { +inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_web_assembly_function(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { clear_kind(); - if (unbounded) { - set_has_unbounded(); - kind_.unbounded_ = unbounded; + if (web_assembly_function) { + set_has_web_assembly_function(); + kind_.web_assembly_function_ = web_assembly_function; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.unbounded) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.web_assembly_function) } -inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::_internal_mutable_unbounded() { - if (!_internal_has_unbounded()) { +inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::_internal_mutable_web_assembly_function() { + if (!_internal_has_web_assembly_function()) { clear_kind(); - set_has_unbounded(); - kind_.unbounded_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Unbounded >(GetArena()); + set_has_web_assembly_function(); + kind_.web_assembly_function_ = CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(GetArena()); } - return kind_.unbounded_; + return kind_.web_assembly_function_; } -inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::mutable_unbounded() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.unbounded) - return _internal_mutable_unbounded(); +inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::mutable_web_assembly_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + return _internal_mutable_web_assembly_function(); } -inline bool Expression_WindowFunction_Bound::has_kind() const { +inline bool Expression_EmbeddedFunction::has_kind() const { return kind_case() != KIND_NOT_SET; } -inline void Expression_WindowFunction_Bound::clear_has_kind() { +inline void Expression_EmbeddedFunction::clear_has_kind() { _oneof_case_[0] = KIND_NOT_SET; } -inline Expression_WindowFunction_Bound::KindCase Expression_WindowFunction_Bound::kind_case() const { - return Expression_WindowFunction_Bound::KindCase(_oneof_case_[0]); +inline Expression_EmbeddedFunction::KindCase Expression_EmbeddedFunction::kind_case() const { + return Expression_EmbeddedFunction::KindCase(_oneof_case_[0]); } // ------------------------------------------------------------------- -// Expression_WindowFunction +// Expression_ReferenceSegment_MapKey -// .io.substrait.Extensions.FunctionId id = 1; -inline bool Expression_WindowFunction::_internal_has_id() const { - return this != internal_default_instance() && id_ != nullptr; +// .io.substrait.Expression.Literal map_key = 1; +inline bool Expression_ReferenceSegment_MapKey::_internal_has_map_key() const { + return this != internal_default_instance() && map_key_ != nullptr; } -inline bool Expression_WindowFunction::has_id() const { - return _internal_has_id(); +inline bool Expression_ReferenceSegment_MapKey::has_map_key() const { + return _internal_has_map_key(); +} +inline void Expression_ReferenceSegment_MapKey::clear_map_key() { + if (GetArena() == nullptr && map_key_ != nullptr) { + delete map_key_; + } + map_key_ = nullptr; } -inline const ::io::substrait::Extensions_FunctionId& Expression_WindowFunction::_internal_id() const { - const ::io::substrait::Extensions_FunctionId* p = id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_FunctionId_default_instance_); +inline const ::io::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::_internal_map_key() const { + const ::io::substrait::Expression_Literal* p = map_key_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_Literal_default_instance_); } -inline const ::io::substrait::Extensions_FunctionId& Expression_WindowFunction::id() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.id) - return _internal_id(); +inline const ::io::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::map_key() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.MapKey.map_key) + return _internal_map_key(); } -inline void Expression_WindowFunction::unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id) { +inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_map_key( + ::io::substrait::Expression_Literal* map_key) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_key_); } - id_ = id; - if (id) { + map_key_ = map_key; + if (map_key) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.id) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.MapKey.map_key) } -inline ::io::substrait::Extensions_FunctionId* Expression_WindowFunction::release_id() { +inline ::io::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::release_map_key() { - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; + ::io::substrait::Expression_Literal* temp = map_key_; + map_key_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Extensions_FunctionId* Expression_WindowFunction::unsafe_arena_release_id() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.id) +inline ::io::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::unsafe_arena_release_map_key() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.MapKey.map_key) - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; + ::io::substrait::Expression_Literal* temp = map_key_; + map_key_ = nullptr; return temp; } -inline ::io::substrait::Extensions_FunctionId* Expression_WindowFunction::_internal_mutable_id() { +inline ::io::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::_internal_mutable_map_key() { - if (id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); - id_ = p; + if (map_key_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); + map_key_ = p; } - return id_; + return map_key_; } -inline ::io::substrait::Extensions_FunctionId* Expression_WindowFunction::mutable_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.id) - return _internal_mutable_id(); +inline ::io::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::mutable_map_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.MapKey.map_key) + return _internal_mutable_map_key(); } -inline void Expression_WindowFunction::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { +inline void Expression_ReferenceSegment_MapKey::set_allocated_map_key(::io::substrait::Expression_Literal* map_key) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); + delete map_key_; } - if (id) { + if (map_key) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map_key); if (message_arena != submessage_arena) { - id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, id, submessage_arena); + map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, map_key, submessage_arena); } } else { } - id_ = id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.id) -} - -// repeated .io.substrait.Expression partitions = 2; -inline int Expression_WindowFunction::_internal_partitions_size() const { - return partitions_.size(); -} -inline int Expression_WindowFunction::partitions_size() const { - return _internal_partitions_size(); -} -inline void Expression_WindowFunction::clear_partitions() { - partitions_.Clear(); -} -inline ::io::substrait::Expression* Expression_WindowFunction::mutable_partitions(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.partitions) - return partitions_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* -Expression_WindowFunction::mutable_partitions() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.partitions) - return &partitions_; -} -inline const ::io::substrait::Expression& Expression_WindowFunction::_internal_partitions(int index) const { - return partitions_.Get(index); -} -inline const ::io::substrait::Expression& Expression_WindowFunction::partitions(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.partitions) - return _internal_partitions(index); -} -inline ::io::substrait::Expression* Expression_WindowFunction::_internal_add_partitions() { - return partitions_.Add(); -} -inline ::io::substrait::Expression* Expression_WindowFunction::add_partitions() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.partitions) - return _internal_add_partitions(); -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& -Expression_WindowFunction::partitions() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.partitions) - return partitions_; -} - -// repeated .io.substrait.Expression.SortField sorts = 3; -inline int Expression_WindowFunction::_internal_sorts_size() const { - return sorts_.size(); -} -inline int Expression_WindowFunction::sorts_size() const { - return _internal_sorts_size(); -} -inline void Expression_WindowFunction::clear_sorts() { - sorts_.Clear(); -} -inline ::io::substrait::Expression_SortField* Expression_WindowFunction::mutable_sorts(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.sorts) - return sorts_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* -Expression_WindowFunction::mutable_sorts() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.sorts) - return &sorts_; -} -inline const ::io::substrait::Expression_SortField& Expression_WindowFunction::_internal_sorts(int index) const { - return sorts_.Get(index); -} -inline const ::io::substrait::Expression_SortField& Expression_WindowFunction::sorts(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.sorts) - return _internal_sorts(index); -} -inline ::io::substrait::Expression_SortField* Expression_WindowFunction::_internal_add_sorts() { - return sorts_.Add(); -} -inline ::io::substrait::Expression_SortField* Expression_WindowFunction::add_sorts() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.sorts) - return _internal_add_sorts(); -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& -Expression_WindowFunction::sorts() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.sorts) - return sorts_; + map_key_ = map_key; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.MapKey.map_key) } -// .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; -inline bool Expression_WindowFunction::_internal_has_upper_bound() const { - return this != internal_default_instance() && upper_bound_ != nullptr; +// .io.substrait.Expression.ReferenceSegment child = 2; +inline bool Expression_ReferenceSegment_MapKey::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; } -inline bool Expression_WindowFunction::has_upper_bound() const { - return _internal_has_upper_bound(); +inline bool Expression_ReferenceSegment_MapKey::has_child() const { + return _internal_has_child(); } -inline void Expression_WindowFunction::clear_upper_bound() { - if (GetArena() == nullptr && upper_bound_ != nullptr) { - delete upper_bound_; +inline void Expression_ReferenceSegment_MapKey::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; } - upper_bound_ = nullptr; + child_ = nullptr; } -inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_upper_bound() const { - const ::io::substrait::Expression_WindowFunction_Bound* p = upper_bound_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_WindowFunction_Bound_default_instance_); +inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::_internal_child() const { + const ::io::substrait::Expression_ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_ReferenceSegment_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::upper_bound() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.upper_bound) - return _internal_upper_bound(); +inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::child() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.MapKey.child) + return _internal_child(); } -inline void Expression_WindowFunction::unsafe_arena_set_allocated_upper_bound( - ::io::substrait::Expression_WindowFunction_Bound* upper_bound) { +inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_child( + ::io::substrait::Expression_ReferenceSegment* child) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(upper_bound_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } - upper_bound_ = upper_bound; - if (upper_bound) { + child_ = child; + if (child) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.upper_bound) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.MapKey.child) } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_upper_bound() { +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::release_child() { - ::io::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; - upper_bound_ = nullptr; + ::io::substrait::Expression_ReferenceSegment* temp = child_; + child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_upper_bound() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.upper_bound) +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.MapKey.child) - ::io::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; - upper_bound_ = nullptr; + ::io::substrait::Expression_ReferenceSegment* temp = child_; + child_ = nullptr; return temp; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_upper_bound() { +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::_internal_mutable_child() { - if (upper_bound_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound>(GetArena()); - upper_bound_ = p; + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment>(GetArena()); + child_ = p; } - return upper_bound_; + return child_; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_upper_bound() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.upper_bound) - return _internal_mutable_upper_bound(); +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.MapKey.child) + return _internal_mutable_child(); } -inline void Expression_WindowFunction::set_allocated_upper_bound(::io::substrait::Expression_WindowFunction_Bound* upper_bound) { +inline void Expression_ReferenceSegment_MapKey::set_allocated_child(::io::substrait::Expression_ReferenceSegment* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete upper_bound_; + delete child_; } - if (upper_bound) { + if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(upper_bound); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); if (message_arena != submessage_arena) { - upper_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, upper_bound, submessage_arena); + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); } } else { } - upper_bound_ = upper_bound; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.upper_bound) + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.MapKey.child) } -// .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; -inline bool Expression_WindowFunction::_internal_has_lower_bound() const { - return this != internal_default_instance() && lower_bound_ != nullptr; +// ------------------------------------------------------------------- + +// Expression_ReferenceSegment_StructField + +// int32 field = 1; +inline void Expression_ReferenceSegment_StructField::clear_field() { + field_ = 0; } -inline bool Expression_WindowFunction::has_lower_bound() const { - return _internal_has_lower_bound(); +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_StructField::_internal_field() const { + return field_; } -inline void Expression_WindowFunction::clear_lower_bound() { - if (GetArena() == nullptr && lower_bound_ != nullptr) { - delete lower_bound_; +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_StructField::field() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.StructField.field) + return _internal_field(); +} +inline void Expression_ReferenceSegment_StructField::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + + field_ = value; +} +inline void Expression_ReferenceSegment_StructField::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_field(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.ReferenceSegment.StructField.field) +} + +// .io.substrait.Expression.ReferenceSegment child = 2; +inline bool Expression_ReferenceSegment_StructField::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; +} +inline bool Expression_ReferenceSegment_StructField::has_child() const { + return _internal_has_child(); +} +inline void Expression_ReferenceSegment_StructField::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; } - lower_bound_ = nullptr; + child_ = nullptr; } -inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_lower_bound() const { - const ::io::substrait::Expression_WindowFunction_Bound* p = lower_bound_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_WindowFunction_Bound_default_instance_); +inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::_internal_child() const { + const ::io::substrait::Expression_ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_ReferenceSegment_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::lower_bound() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.lower_bound) - return _internal_lower_bound(); +inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::child() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.StructField.child) + return _internal_child(); } -inline void Expression_WindowFunction::unsafe_arena_set_allocated_lower_bound( - ::io::substrait::Expression_WindowFunction_Bound* lower_bound) { +inline void Expression_ReferenceSegment_StructField::unsafe_arena_set_allocated_child( + ::io::substrait::Expression_ReferenceSegment* child) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lower_bound_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } - lower_bound_ = lower_bound; - if (lower_bound) { + child_ = child; + if (child) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.lower_bound) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.StructField.child) } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_lower_bound() { +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::release_child() { - ::io::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; - lower_bound_ = nullptr; + ::io::substrait::Expression_ReferenceSegment* temp = child_; + child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_lower_bound() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.lower_bound) +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.StructField.child) - ::io::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; - lower_bound_ = nullptr; + ::io::substrait::Expression_ReferenceSegment* temp = child_; + child_ = nullptr; return temp; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_lower_bound() { +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::_internal_mutable_child() { - if (lower_bound_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound>(GetArena()); - lower_bound_ = p; + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment>(GetArena()); + child_ = p; } - return lower_bound_; + return child_; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_lower_bound() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.lower_bound) - return _internal_mutable_lower_bound(); +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.StructField.child) + return _internal_mutable_child(); } -inline void Expression_WindowFunction::set_allocated_lower_bound(::io::substrait::Expression_WindowFunction_Bound* lower_bound) { +inline void Expression_ReferenceSegment_StructField::set_allocated_child(::io::substrait::Expression_ReferenceSegment* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete lower_bound_; + delete child_; } - if (lower_bound) { + if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lower_bound); - if (message_arena != submessage_arena) { - lower_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, lower_bound, submessage_arena); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + if (message_arena != submessage_arena) { + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); } } else { } - lower_bound_ = lower_bound; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.lower_bound) + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.StructField.child) } -// .io.substrait.Expression.AggregationPhase phase = 6; -inline void Expression_WindowFunction::clear_phase() { - phase_ = 0; +// ------------------------------------------------------------------- + +// Expression_ReferenceSegment_ListElement + +// int32 offset = 1; +inline void Expression_ReferenceSegment_ListElement::clear_offset() { + offset_ = 0; } -inline ::io::substrait::Expression_AggregationPhase Expression_WindowFunction::_internal_phase() const { - return static_cast< ::io::substrait::Expression_AggregationPhase >(phase_); +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_ListElement::_internal_offset() const { + return offset_; } -inline ::io::substrait::Expression_AggregationPhase Expression_WindowFunction::phase() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.phase) - return _internal_phase(); +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_ListElement::offset() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.ListElement.offset) + return _internal_offset(); } -inline void Expression_WindowFunction::_internal_set_phase(::io::substrait::Expression_AggregationPhase value) { +inline void Expression_ReferenceSegment_ListElement::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) { - phase_ = value; + offset_ = value; } -inline void Expression_WindowFunction::set_phase(::io::substrait::Expression_AggregationPhase value) { - _internal_set_phase(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.phase) +inline void Expression_ReferenceSegment_ListElement::set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.ReferenceSegment.ListElement.offset) } -// .io.substrait.Type output_type = 7; -inline bool Expression_WindowFunction::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; +// .io.substrait.Expression.ReferenceSegment child = 2; +inline bool Expression_ReferenceSegment_ListElement::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; } -inline bool Expression_WindowFunction::has_output_type() const { - return _internal_has_output_type(); +inline bool Expression_ReferenceSegment_ListElement::has_child() const { + return _internal_has_child(); } -inline const ::io::substrait::Type& Expression_WindowFunction::_internal_output_type() const { - const ::io::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline void Expression_ReferenceSegment_ListElement::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; + } + child_ = nullptr; } -inline const ::io::substrait::Type& Expression_WindowFunction::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.output_type) - return _internal_output_type(); +inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::_internal_child() const { + const ::io::substrait::Expression_ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_ReferenceSegment_default_instance_); } -inline void Expression_WindowFunction::unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type) { +inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::child() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.ListElement.child) + return _internal_child(); +} +inline void Expression_ReferenceSegment_ListElement::unsafe_arena_set_allocated_child( + ::io::substrait::Expression_ReferenceSegment* child) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } - output_type_ = output_type; - if (output_type) { + child_ = child; + if (child) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.output_type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.ListElement.child) } -inline ::io::substrait::Type* Expression_WindowFunction::release_output_type() { +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::release_child() { - ::io::substrait::Type* temp = output_type_; - output_type_ = nullptr; + ::io::substrait::Expression_ReferenceSegment* temp = child_; + child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type* Expression_WindowFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.output_type) +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.ListElement.child) - ::io::substrait::Type* temp = output_type_; - output_type_ = nullptr; + ::io::substrait::Expression_ReferenceSegment* temp = child_; + child_ = nullptr; return temp; } -inline ::io::substrait::Type* Expression_WindowFunction::_internal_mutable_output_type() { +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::_internal_mutable_child() { - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); - output_type_ = p; + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment>(GetArena()); + child_ = p; } - return output_type_; + return child_; } -inline ::io::substrait::Type* Expression_WindowFunction::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.output_type) - return _internal_mutable_output_type(); +inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.ListElement.child) + return _internal_mutable_child(); } -inline void Expression_WindowFunction::set_allocated_output_type(::io::substrait::Type* output_type) { +inline void Expression_ReferenceSegment_ListElement::set_allocated_child(::io::substrait::Expression_ReferenceSegment* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + delete child_; } - if (output_type) { + if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); } } else { } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.output_type) + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.ListElement.child) } -// repeated .io.substrait.Expression args = 8; -inline int Expression_WindowFunction::_internal_args_size() const { - return args_.size(); +// ------------------------------------------------------------------- + +// Expression_ReferenceSegment + +// .io.substrait.Expression.ReferenceSegment.MapKey map_key = 1; +inline bool Expression_ReferenceSegment::_internal_has_map_key() const { + return reference_type_case() == kMapKey; } -inline int Expression_WindowFunction::args_size() const { - return _internal_args_size(); +inline bool Expression_ReferenceSegment::has_map_key() const { + return _internal_has_map_key(); } -inline void Expression_WindowFunction::clear_args() { - args_.Clear(); +inline void Expression_ReferenceSegment::set_has_map_key() { + _oneof_case_[0] = kMapKey; } -inline ::io::substrait::Expression* Expression_WindowFunction::mutable_args(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.args) - return args_.Mutable(index); +inline void Expression_ReferenceSegment::clear_map_key() { + if (_internal_has_map_key()) { + if (GetArena() == nullptr) { + delete reference_type_.map_key_; + } + clear_has_reference_type(); + } } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* -Expression_WindowFunction::mutable_args() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.args) - return &args_; +inline ::io::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::release_map_key() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.map_key) + if (_internal_has_map_key()) { + clear_has_reference_type(); + ::io::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.map_key_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline const ::io::substrait::Expression& Expression_WindowFunction::_internal_args(int index) const { - return args_.Get(index); +inline const ::io::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::_internal_map_key() const { + return _internal_has_map_key() + ? *reference_type_.map_key_ + : reinterpret_cast< ::io::substrait::Expression_ReferenceSegment_MapKey&>(::io::substrait::_Expression_ReferenceSegment_MapKey_default_instance_); } -inline const ::io::substrait::Expression& Expression_WindowFunction::args(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.args) - return _internal_args(index); +inline const ::io::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::map_key() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.map_key) + return _internal_map_key(); } -inline ::io::substrait::Expression* Expression_WindowFunction::_internal_add_args() { - return args_.Add(); +inline ::io::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::unsafe_arena_release_map_key() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.ReferenceSegment.map_key) + if (_internal_has_map_key()) { + clear_has_reference_type(); + ::io::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_; + reference_type_.map_key_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline ::io::substrait::Expression* Expression_WindowFunction::add_args() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.args) - return _internal_add_args(); +inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_map_key(::io::substrait::Expression_ReferenceSegment_MapKey* map_key) { + clear_reference_type(); + if (map_key) { + set_has_map_key(); + reference_type_.map_key_ = map_key; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.map_key) } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& -Expression_WindowFunction::args() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.args) - return args_; +inline ::io::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::_internal_mutable_map_key() { + if (!_internal_has_map_key()) { + clear_reference_type(); + set_has_map_key(); + reference_type_.map_key_ = CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_MapKey >(GetArena()); + } + return reference_type_.map_key_; +} +inline ::io::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::mutable_map_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.map_key) + return _internal_mutable_map_key(); } -// ------------------------------------------------------------------- - -// Expression_SortField - -// .io.substrait.Expression expr = 1; -inline bool Expression_SortField::_internal_has_expr() const { - return this != internal_default_instance() && expr_ != nullptr; +// .io.substrait.Expression.ReferenceSegment.StructField struct_field = 2; +inline bool Expression_ReferenceSegment::_internal_has_struct_field() const { + return reference_type_case() == kStructField; } -inline bool Expression_SortField::has_expr() const { - return _internal_has_expr(); +inline bool Expression_ReferenceSegment::has_struct_field() const { + return _internal_has_struct_field(); } -inline void Expression_SortField::clear_expr() { - if (GetArena() == nullptr && expr_ != nullptr) { - delete expr_; +inline void Expression_ReferenceSegment::set_has_struct_field() { + _oneof_case_[0] = kStructField; +} +inline void Expression_ReferenceSegment::clear_struct_field() { + if (_internal_has_struct_field()) { + if (GetArena() == nullptr) { + delete reference_type_.struct_field_; + } + clear_has_reference_type(); } - expr_ = nullptr; } -inline const ::io::substrait::Expression& Expression_SortField::_internal_expr() const { - const ::io::substrait::Expression* p = expr_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline ::io::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::release_struct_field() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.struct_field) + if (_internal_has_struct_field()) { + clear_has_reference_type(); + ::io::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.struct_field_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline const ::io::substrait::Expression& Expression_SortField::expr() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SortField.expr) - return _internal_expr(); +inline const ::io::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::_internal_struct_field() const { + return _internal_has_struct_field() + ? *reference_type_.struct_field_ + : reinterpret_cast< ::io::substrait::Expression_ReferenceSegment_StructField&>(::io::substrait::_Expression_ReferenceSegment_StructField_default_instance_); } -inline void Expression_SortField::unsafe_arena_set_allocated_expr( - ::io::substrait::Expression* expr) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_); +inline const ::io::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::struct_field() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.struct_field) + return _internal_struct_field(); +} +inline ::io::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::unsafe_arena_release_struct_field() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.ReferenceSegment.struct_field) + if (_internal_has_struct_field()) { + clear_has_reference_type(); + ::io::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_; + reference_type_.struct_field_ = nullptr; + return temp; + } else { + return nullptr; } - expr_ = expr; - if (expr) { - +} +inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_struct_field(::io::substrait::Expression_ReferenceSegment_StructField* struct_field) { + clear_reference_type(); + if (struct_field) { + set_has_struct_field(); + reference_type_.struct_field_ = struct_field; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.struct_field) +} +inline ::io::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::_internal_mutable_struct_field() { + if (!_internal_has_struct_field()) { + clear_reference_type(); + set_has_struct_field(); + reference_type_.struct_field_ = CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_StructField >(GetArena()); + } + return reference_type_.struct_field_; +} +inline ::io::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::mutable_struct_field() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.struct_field) + return _internal_mutable_struct_field(); +} + +// .io.substrait.Expression.ReferenceSegment.ListElement list_element = 3; +inline bool Expression_ReferenceSegment::_internal_has_list_element() const { + return reference_type_case() == kListElement; +} +inline bool Expression_ReferenceSegment::has_list_element() const { + return _internal_has_list_element(); +} +inline void Expression_ReferenceSegment::set_has_list_element() { + _oneof_case_[0] = kListElement; +} +inline void Expression_ReferenceSegment::clear_list_element() { + if (_internal_has_list_element()) { + if (GetArena() == nullptr) { + delete reference_type_.list_element_; + } + clear_has_reference_type(); + } +} +inline ::io::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::release_list_element() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.list_element) + if (_internal_has_list_element()) { + clear_has_reference_type(); + ::io::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.list_element_ = nullptr; + return temp; } else { - + return nullptr; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SortField.expr) } -inline ::io::substrait::Expression* Expression_SortField::release_expr() { - - ::io::substrait::Expression* temp = expr_; - expr_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); +inline const ::io::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::_internal_list_element() const { + return _internal_has_list_element() + ? *reference_type_.list_element_ + : reinterpret_cast< ::io::substrait::Expression_ReferenceSegment_ListElement&>(::io::substrait::_Expression_ReferenceSegment_ListElement_default_instance_); +} +inline const ::io::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::list_element() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.list_element) + return _internal_list_element(); +} +inline ::io::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::unsafe_arena_release_list_element() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.ReferenceSegment.list_element) + if (_internal_has_list_element()) { + clear_has_reference_type(); + ::io::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_; + reference_type_.list_element_ = nullptr; + return temp; + } else { + return nullptr; } - return temp; } -inline ::io::substrait::Expression* Expression_SortField::unsafe_arena_release_expr() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.SortField.expr) - - ::io::substrait::Expression* temp = expr_; - expr_ = nullptr; - return temp; +inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_list_element(::io::substrait::Expression_ReferenceSegment_ListElement* list_element) { + clear_reference_type(); + if (list_element) { + set_has_list_element(); + reference_type_.list_element_ = list_element; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.list_element) } -inline ::io::substrait::Expression* Expression_SortField::_internal_mutable_expr() { - - if (expr_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - expr_ = p; +inline ::io::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::_internal_mutable_list_element() { + if (!_internal_has_list_element()) { + clear_reference_type(); + set_has_list_element(); + reference_type_.list_element_ = CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_ListElement >(GetArena()); } - return expr_; + return reference_type_.list_element_; } -inline ::io::substrait::Expression* Expression_SortField::mutable_expr() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SortField.expr) - return _internal_mutable_expr(); +inline ::io::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::mutable_list_element() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.list_element) + return _internal_mutable_list_element(); } -inline void Expression_SortField::set_allocated_expr(::io::substrait::Expression* expr) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete expr_; + +inline bool Expression_ReferenceSegment::has_reference_type() const { + return reference_type_case() != REFERENCE_TYPE_NOT_SET; +} +inline void Expression_ReferenceSegment::clear_has_reference_type() { + _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; +} +inline Expression_ReferenceSegment::ReferenceTypeCase Expression_ReferenceSegment::reference_type_case() const { + return Expression_ReferenceSegment::ReferenceTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// Expression_MaskExpression_Select + +// .io.substrait.Expression.MaskExpression.StructSelect struct = 1; +inline bool Expression_MaskExpression_Select::_internal_has_struct_() const { + return type_case() == kStruct; +} +inline bool Expression_MaskExpression_Select::has_struct_() const { + return _internal_has_struct_(); +} +inline void Expression_MaskExpression_Select::set_has_struct_() { + _oneof_case_[0] = kStruct; +} +inline void Expression_MaskExpression_Select::clear_struct_() { + if (_internal_has_struct_()) { + if (GetArena() == nullptr) { + delete type_.struct__; + } + clear_has_type(); } - if (expr) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expr); - if (message_arena != submessage_arena) { - expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, expr, submessage_arena); +} +inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.Select.struct) + if (_internal_has_struct_()) { + clear_has_type(); + ::io::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - + type_.struct__ = nullptr; + return temp; } else { - + return nullptr; } - expr_ = expr; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SortField.expr) +} +inline const ::io::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::_internal_struct_() const { + return _internal_has_struct_() + ? *type_.struct__ + : reinterpret_cast< ::io::substrait::Expression_MaskExpression_StructSelect&>(::io::substrait::_Expression_MaskExpression_StructSelect_default_instance_); +} +inline const ::io::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.Select.struct) + return _internal_struct_(); +} +inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.Select.struct) + if (_internal_has_struct_()) { + clear_has_type(); + ::io::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__; + type_.struct__ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_struct_(::io::substrait::Expression_MaskExpression_StructSelect* struct_) { + clear_type(); + if (struct_) { + set_has_struct_(); + type_.struct__ = struct_; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.Select.struct) +} +inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::_internal_mutable_struct_() { + if (!_internal_has_struct_()) { + clear_type(); + set_has_struct_(); + type_.struct__ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_StructSelect >(GetArena()); + } + return type_.struct__; +} +inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.Select.struct) + return _internal_mutable_struct_(); } -// .io.substrait.Expression.SortField.SortDirection direction = 2; -inline bool Expression_SortField::_internal_has_direction() const { - return sort_kind_case() == kDirection; +// .io.substrait.Expression.MaskExpression.ListSelect list = 2; +inline bool Expression_MaskExpression_Select::_internal_has_list() const { + return type_case() == kList; } -inline bool Expression_SortField::has_direction() const { - return _internal_has_direction(); +inline bool Expression_MaskExpression_Select::has_list() const { + return _internal_has_list(); } -inline void Expression_SortField::set_has_direction() { - _oneof_case_[0] = kDirection; +inline void Expression_MaskExpression_Select::set_has_list() { + _oneof_case_[0] = kList; } -inline void Expression_SortField::clear_direction() { - if (_internal_has_direction()) { - sort_kind_.direction_ = 0; - clear_has_sort_kind(); +inline void Expression_MaskExpression_Select::clear_list() { + if (_internal_has_list()) { + if (GetArena() == nullptr) { + delete type_.list_; + } + clear_has_type(); + } +} +inline ::io::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::release_list() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.Select.list) + if (_internal_has_list()) { + clear_has_type(); + ::io::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + type_.list_ = nullptr; + return temp; + } else { + return nullptr; } } -inline ::io::substrait::Expression_SortField_SortDirection Expression_SortField::_internal_direction() const { - if (_internal_has_direction()) { - return static_cast< ::io::substrait::Expression_SortField_SortDirection >(sort_kind_.direction_); +inline const ::io::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::_internal_list() const { + return _internal_has_list() + ? *type_.list_ + : reinterpret_cast< ::io::substrait::Expression_MaskExpression_ListSelect&>(::io::substrait::_Expression_MaskExpression_ListSelect_default_instance_); +} +inline const ::io::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::list() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.Select.list) + return _internal_list(); +} +inline ::io::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.Select.list) + if (_internal_has_list()) { + clear_has_type(); + ::io::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_; + type_.list_ = nullptr; + return temp; + } else { + return nullptr; } - return static_cast< ::io::substrait::Expression_SortField_SortDirection >(0); } -inline ::io::substrait::Expression_SortField_SortDirection Expression_SortField::direction() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SortField.direction) - return _internal_direction(); +inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_list(::io::substrait::Expression_MaskExpression_ListSelect* list) { + clear_type(); + if (list) { + set_has_list(); + type_.list_ = list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.Select.list) } -inline void Expression_SortField::_internal_set_direction(::io::substrait::Expression_SortField_SortDirection value) { - if (!_internal_has_direction()) { - clear_sort_kind(); - set_has_direction(); +inline ::io::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::_internal_mutable_list() { + if (!_internal_has_list()) { + clear_type(); + set_has_list(); + type_.list_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect >(GetArena()); } - sort_kind_.direction_ = value; + return type_.list_; } -inline void Expression_SortField::set_direction(::io::substrait::Expression_SortField_SortDirection value) { - // @@protoc_insertion_point(field_set:io.substrait.Expression.SortField.direction) - _internal_set_direction(value); +inline ::io::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::mutable_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.Select.list) + return _internal_mutable_list(); } -// .io.substrait.Extensions.FunctionId comparison_function = 3; -inline bool Expression_SortField::_internal_has_comparison_function() const { - return sort_kind_case() == kComparisonFunction; +// .io.substrait.Expression.MaskExpression.MapSelect map = 3; +inline bool Expression_MaskExpression_Select::_internal_has_map() const { + return type_case() == kMap; } -inline bool Expression_SortField::has_comparison_function() const { - return _internal_has_comparison_function(); +inline bool Expression_MaskExpression_Select::has_map() const { + return _internal_has_map(); } -inline void Expression_SortField::set_has_comparison_function() { - _oneof_case_[0] = kComparisonFunction; +inline void Expression_MaskExpression_Select::set_has_map() { + _oneof_case_[0] = kMap; } -inline ::io::substrait::Extensions_FunctionId* Expression_SortField::release_comparison_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.SortField.comparison_function) - if (_internal_has_comparison_function()) { - clear_has_sort_kind(); - ::io::substrait::Extensions_FunctionId* temp = sort_kind_.comparison_function_; +inline void Expression_MaskExpression_Select::clear_map() { + if (_internal_has_map()) { + if (GetArena() == nullptr) { + delete type_.map_; + } + clear_has_type(); + } +} +inline ::io::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::release_map() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.Select.map) + if (_internal_has_map()) { + clear_has_type(); + ::io::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - sort_kind_.comparison_function_ = nullptr; + type_.map_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Extensions_FunctionId& Expression_SortField::_internal_comparison_function() const { - return _internal_has_comparison_function() - ? *sort_kind_.comparison_function_ - : reinterpret_cast< ::io::substrait::Extensions_FunctionId&>(::io::substrait::_Extensions_FunctionId_default_instance_); +inline const ::io::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::_internal_map() const { + return _internal_has_map() + ? *type_.map_ + : reinterpret_cast< ::io::substrait::Expression_MaskExpression_MapSelect&>(::io::substrait::_Expression_MaskExpression_MapSelect_default_instance_); } -inline const ::io::substrait::Extensions_FunctionId& Expression_SortField::comparison_function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SortField.comparison_function) - return _internal_comparison_function(); +inline const ::io::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::map() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.Select.map) + return _internal_map(); } -inline ::io::substrait::Extensions_FunctionId* Expression_SortField::unsafe_arena_release_comparison_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.SortField.comparison_function) - if (_internal_has_comparison_function()) { - clear_has_sort_kind(); - ::io::substrait::Extensions_FunctionId* temp = sort_kind_.comparison_function_; - sort_kind_.comparison_function_ = nullptr; +inline ::io::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.Select.map) + if (_internal_has_map()) { + clear_has_type(); + ::io::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_; + type_.map_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_SortField::unsafe_arena_set_allocated_comparison_function(::io::substrait::Extensions_FunctionId* comparison_function) { - clear_sort_kind(); - if (comparison_function) { - set_has_comparison_function(); - sort_kind_.comparison_function_ = comparison_function; +inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_map(::io::substrait::Expression_MaskExpression_MapSelect* map) { + clear_type(); + if (map) { + set_has_map(); + type_.map_ = map; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SortField.comparison_function) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.Select.map) } -inline ::io::substrait::Extensions_FunctionId* Expression_SortField::_internal_mutable_comparison_function() { - if (!_internal_has_comparison_function()) { - clear_sort_kind(); - set_has_comparison_function(); - sort_kind_.comparison_function_ = CreateMaybeMessage< ::io::substrait::Extensions_FunctionId >(GetArena()); +inline ::io::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::_internal_mutable_map() { + if (!_internal_has_map()) { + clear_type(); + set_has_map(); + type_.map_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect >(GetArena()); } - return sort_kind_.comparison_function_; + return type_.map_; } -inline ::io::substrait::Extensions_FunctionId* Expression_SortField::mutable_comparison_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SortField.comparison_function) - return _internal_mutable_comparison_function(); +inline ::io::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::mutable_map() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.Select.map) + return _internal_mutable_map(); } -inline bool Expression_SortField::has_sort_kind() const { - return sort_kind_case() != SORT_KIND_NOT_SET; +inline bool Expression_MaskExpression_Select::has_type() const { + return type_case() != TYPE_NOT_SET; } -inline void Expression_SortField::clear_has_sort_kind() { - _oneof_case_[0] = SORT_KIND_NOT_SET; +inline void Expression_MaskExpression_Select::clear_has_type() { + _oneof_case_[0] = TYPE_NOT_SET; } -inline Expression_SortField::SortKindCase Expression_SortField::sort_kind_case() const { - return Expression_SortField::SortKindCase(_oneof_case_[0]); +inline Expression_MaskExpression_Select::TypeCase Expression_MaskExpression_Select::type_case() const { + return Expression_MaskExpression_Select::TypeCase(_oneof_case_[0]); } // ------------------------------------------------------------------- -// Expression_IfThen_IfClause +// Expression_MaskExpression_StructSelect -// .io.substrait.Expression if = 1; -inline bool Expression_IfThen_IfClause::_internal_has_if_() const { - return this != internal_default_instance() && if__ != nullptr; +// repeated .io.substrait.Expression.MaskExpression.StructItem struct_items = 1; +inline int Expression_MaskExpression_StructSelect::_internal_struct_items_size() const { + return struct_items_.size(); } -inline bool Expression_IfThen_IfClause::has_if_() const { - return _internal_has_if_(); +inline int Expression_MaskExpression_StructSelect::struct_items_size() const { + return _internal_struct_items_size(); } -inline void Expression_IfThen_IfClause::clear_if_() { - if (GetArena() == nullptr && if__ != nullptr) { - delete if__; +inline void Expression_MaskExpression_StructSelect::clear_struct_items() { + struct_items_.Clear(); +} +inline ::io::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::mutable_struct_items(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.StructSelect.struct_items) + return struct_items_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_StructItem >* +Expression_MaskExpression_StructSelect::mutable_struct_items() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MaskExpression.StructSelect.struct_items) + return &struct_items_; +} +inline const ::io::substrait::Expression_MaskExpression_StructItem& Expression_MaskExpression_StructSelect::_internal_struct_items(int index) const { + return struct_items_.Get(index); +} +inline const ::io::substrait::Expression_MaskExpression_StructItem& Expression_MaskExpression_StructSelect::struct_items(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.StructSelect.struct_items) + return _internal_struct_items(index); +} +inline ::io::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::_internal_add_struct_items() { + return struct_items_.Add(); +} +inline ::io::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::add_struct_items() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.MaskExpression.StructSelect.struct_items) + return _internal_add_struct_items(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_StructItem >& +Expression_MaskExpression_StructSelect::struct_items() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.MaskExpression.StructSelect.struct_items) + return struct_items_; +} + +// ------------------------------------------------------------------- + +// Expression_MaskExpression_StructItem + +// int32 field = 1; +inline void Expression_MaskExpression_StructItem::clear_field() { + field_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_StructItem::_internal_field() const { + return field_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_StructItem::field() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.StructItem.field) + return _internal_field(); +} +inline void Expression_MaskExpression_StructItem::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + + field_ = value; +} +inline void Expression_MaskExpression_StructItem::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_field(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.StructItem.field) +} + +// .io.substrait.Expression.MaskExpression.Select child = 2; +inline bool Expression_MaskExpression_StructItem::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; +} +inline bool Expression_MaskExpression_StructItem::has_child() const { + return _internal_has_child(); +} +inline void Expression_MaskExpression_StructItem::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; } - if__ = nullptr; + child_ = nullptr; } -inline const ::io::substrait::Expression& Expression_IfThen_IfClause::_internal_if_() const { - const ::io::substrait::Expression* p = if__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::_internal_child() const { + const ::io::substrait::Expression_MaskExpression_Select* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_MaskExpression_Select_default_instance_); } -inline const ::io::substrait::Expression& Expression_IfThen_IfClause::if_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.IfClause.if) - return _internal_if_(); +inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::child() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.StructItem.child) + return _internal_child(); } -inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_if_( - ::io::substrait::Expression* if_) { +inline void Expression_MaskExpression_StructItem::unsafe_arena_set_allocated_child( + ::io::substrait::Expression_MaskExpression_Select* child) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } - if__ = if_; - if (if_) { + child_ = child; + if (child) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.IfClause.if) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.StructItem.child) } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::release_if_() { +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::release_child() { - ::io::substrait::Expression* temp = if__; - if__ = nullptr; + ::io::substrait::Expression_MaskExpression_Select* temp = child_; + child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_if_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.IfClause.if) +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.StructItem.child) - ::io::substrait::Expression* temp = if__; - if__ = nullptr; + ::io::substrait::Expression_MaskExpression_Select* temp = child_; + child_ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_if_() { +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::_internal_mutable_child() { - if (if__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - if__ = p; + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_MaskExpression_Select>(GetArena()); + child_ = p; } - return if__; + return child_; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::mutable_if_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.IfClause.if) - return _internal_mutable_if_(); +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.StructItem.child) + return _internal_mutable_child(); } -inline void Expression_IfThen_IfClause::set_allocated_if_(::io::substrait::Expression* if_) { +inline void Expression_MaskExpression_StructItem::set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete if__; + delete child_; } - if (if_) { + if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); if (message_arena != submessage_arena) { - if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, if_, submessage_arena); + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); } } else { } - if__ = if_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.IfClause.if) + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.StructItem.child) } -// .io.substrait.Expression then = 2; -inline bool Expression_IfThen_IfClause::_internal_has_then() const { - return this != internal_default_instance() && then_ != nullptr; +// ------------------------------------------------------------------- + +// Expression_MaskExpression_ListSelect_ListSelectItem_ListElement + +// int32 field = 1; +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::clear_field() { + field_ = 0; } -inline bool Expression_IfThen_IfClause::has_then() const { - return _internal_has_then(); +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_field() const { + return field_; } -inline void Expression_IfThen_IfClause::clear_then() { - if (GetArena() == nullptr && then_ != nullptr) { - delete then_; - } - then_ = nullptr; +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::field() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field) + return _internal_field(); } -inline const ::io::substrait::Expression& Expression_IfThen_IfClause::_internal_then() const { - const ::io::substrait::Expression* p = then_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + + field_ = value; } -inline const ::io::substrait::Expression& Expression_IfThen_IfClause::then() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.IfClause.then) - return _internal_then(); +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_field(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field) } -inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_then( - ::io::substrait::Expression* then) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); + +// ------------------------------------------------------------------- + +// Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice + +// int32 start = 1; +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_start() { + start_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_start() const { + return start_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::start() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) + return _internal_start(); +} +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { + + start_ = value; +} +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_start(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) +} + +// int32 end = 2; +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_end() { + end_ = 0; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_end() const { + return end_; +} +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::end() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) + return _internal_end(); +} +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { + + end_ = value; +} +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_set_end(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) +} + +// ------------------------------------------------------------------- + +// Expression_MaskExpression_ListSelect_ListSelectItem + +// .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; +inline bool Expression_MaskExpression_ListSelect_ListSelectItem::_internal_has_item() const { + return type_case() == kItem; +} +inline bool Expression_MaskExpression_ListSelect_ListSelectItem::has_item() const { + return _internal_has_item(); +} +inline void Expression_MaskExpression_ListSelect_ListSelectItem::set_has_item() { + _oneof_case_[0] = kItem; +} +inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_item() { + if (_internal_has_item()) { + if (GetArena() == nullptr) { + delete type_.item_; + } + clear_has_type(); } - then_ = then; - if (then) { - +} +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::release_item() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) + if (_internal_has_item()) { + clear_has_type(); + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + type_.item_ = nullptr; + return temp; } else { - + return nullptr; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.IfClause.then) } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::release_then() { - - ::io::substrait::Expression* temp = then_; - then_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); +inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::_internal_item() const { + return _internal_has_item() + ? *type_.item_ + : reinterpret_cast< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&>(::io::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_); +} +inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::item() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) + return _internal_item(); +} +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_item() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) + if (_internal_has_item()) { + clear_has_type(); + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; + type_.item_ = nullptr; + return temp; + } else { + return nullptr; } - return temp; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_then() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.IfClause.then) - - ::io::substrait::Expression* temp = then_; - then_ = nullptr; - return temp; +inline void Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_item(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) { + clear_type(); + if (item) { + set_has_item(); + type_.item_ = item; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_then() { - - if (then_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - then_ = p; +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::_internal_mutable_item() { + if (!_internal_has_item()) { + clear_type(); + set_has_item(); + type_.item_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(GetArena()); } - return then_; + return type_.item_; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::mutable_then() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.IfClause.then) - return _internal_mutable_then(); +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_item() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) + return _internal_mutable_item(); } -inline void Expression_IfThen_IfClause::set_allocated_then(::io::substrait::Expression* then) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete then_; + +// .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; +inline bool Expression_MaskExpression_ListSelect_ListSelectItem::_internal_has_slice() const { + return type_case() == kSlice; +} +inline bool Expression_MaskExpression_ListSelect_ListSelectItem::has_slice() const { + return _internal_has_slice(); +} +inline void Expression_MaskExpression_ListSelect_ListSelectItem::set_has_slice() { + _oneof_case_[0] = kSlice; +} +inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_slice() { + if (_internal_has_slice()) { + if (GetArena() == nullptr) { + delete type_.slice_; + } + clear_has_type(); } - if (then) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(then); - if (message_arena != submessage_arena) { - then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, then, submessage_arena); +} +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::release_slice() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) + if (_internal_has_slice()) { + clear_has_type(); + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - + type_.slice_ = nullptr; + return temp; } else { - + return nullptr; } - then_ = then; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.IfClause.then) +} +inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::_internal_slice() const { + return _internal_has_slice() + ? *type_.slice_ + : reinterpret_cast< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&>(::io::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_); +} +inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::slice() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) + return _internal_slice(); +} +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_slice() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) + if (_internal_has_slice()) { + clear_has_type(); + ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; + type_.slice_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_slice(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { + clear_type(); + if (slice) { + set_has_slice(); + type_.slice_ = slice; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) +} +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::_internal_mutable_slice() { + if (!_internal_has_slice()) { + clear_type(); + set_has_slice(); + type_.slice_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(GetArena()); + } + return type_.slice_; +} +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_slice() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) + return _internal_mutable_slice(); } +inline bool Expression_MaskExpression_ListSelect_ListSelectItem::has_type() const { + return type_case() != TYPE_NOT_SET; +} +inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_has_type() { + _oneof_case_[0] = TYPE_NOT_SET; +} +inline Expression_MaskExpression_ListSelect_ListSelectItem::TypeCase Expression_MaskExpression_ListSelect_ListSelectItem::type_case() const { + return Expression_MaskExpression_ListSelect_ListSelectItem::TypeCase(_oneof_case_[0]); +} // ------------------------------------------------------------------- -// Expression_IfThen +// Expression_MaskExpression_ListSelect -// repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; -inline int Expression_IfThen::_internal_ifs_size() const { - return ifs_.size(); +// repeated .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; +inline int Expression_MaskExpression_ListSelect::_internal_selection_size() const { + return selection_.size(); } -inline int Expression_IfThen::ifs_size() const { - return _internal_ifs_size(); +inline int Expression_MaskExpression_ListSelect::selection_size() const { + return _internal_selection_size(); } -inline void Expression_IfThen::clear_ifs() { - ifs_.Clear(); +inline void Expression_MaskExpression_ListSelect::clear_selection() { + selection_.Clear(); } -inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::mutable_ifs(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.ifs) - return ifs_.Mutable(index); +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::mutable_selection(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.ListSelect.selection) + return selection_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >* -Expression_IfThen::mutable_ifs() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.IfThen.ifs) - return &ifs_; +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >* +Expression_MaskExpression_ListSelect::mutable_selection() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MaskExpression.ListSelect.selection) + return &selection_; } -inline const ::io::substrait::Expression_IfThen_IfClause& Expression_IfThen::_internal_ifs(int index) const { - return ifs_.Get(index); +inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& Expression_MaskExpression_ListSelect::_internal_selection(int index) const { + return selection_.Get(index); } -inline const ::io::substrait::Expression_IfThen_IfClause& Expression_IfThen::ifs(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.ifs) - return _internal_ifs(index); +inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& Expression_MaskExpression_ListSelect::selection(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.selection) + return _internal_selection(index); } -inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::_internal_add_ifs() { - return ifs_.Add(); +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::_internal_add_selection() { + return selection_.Add(); } -inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::add_ifs() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.IfThen.ifs) - return _internal_add_ifs(); +inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::add_selection() { + // @@protoc_insertion_point(field_add:io.substrait.Expression.MaskExpression.ListSelect.selection) + return _internal_add_selection(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >& -Expression_IfThen::ifs() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.IfThen.ifs) - return ifs_; +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >& +Expression_MaskExpression_ListSelect::selection() const { + // @@protoc_insertion_point(field_list:io.substrait.Expression.MaskExpression.ListSelect.selection) + return selection_; } -// .io.substrait.Expression else = 2; -inline bool Expression_IfThen::_internal_has_else_() const { - return this != internal_default_instance() && else__ != nullptr; +// .io.substrait.Expression.MaskExpression.Select child = 2; +inline bool Expression_MaskExpression_ListSelect::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; } -inline bool Expression_IfThen::has_else_() const { - return _internal_has_else_(); +inline bool Expression_MaskExpression_ListSelect::has_child() const { + return _internal_has_child(); } -inline void Expression_IfThen::clear_else_() { - if (GetArena() == nullptr && else__ != nullptr) { - delete else__; +inline void Expression_MaskExpression_ListSelect::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; } - else__ = nullptr; + child_ = nullptr; } -inline const ::io::substrait::Expression& Expression_IfThen::_internal_else_() const { - const ::io::substrait::Expression* p = else__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::_internal_child() const { + const ::io::substrait::Expression_MaskExpression_Select* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_MaskExpression_Select_default_instance_); } -inline const ::io::substrait::Expression& Expression_IfThen::else_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.else) - return _internal_else_(); +inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::child() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.child) + return _internal_child(); } -inline void Expression_IfThen::unsafe_arena_set_allocated_else_( - ::io::substrait::Expression* else_) { +inline void Expression_MaskExpression_ListSelect::unsafe_arena_set_allocated_child( + ::io::substrait::Expression_MaskExpression_Select* child) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } - else__ = else_; - if (else_) { + child_ = child; + if (child) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.else) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.child) } -inline ::io::substrait::Expression* Expression_IfThen::release_else_() { +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::release_child() { - ::io::substrait::Expression* temp = else__; - else__ = nullptr; + ::io::substrait::Expression_MaskExpression_Select* temp = child_; + child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_IfThen::unsafe_arena_release_else_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.else) +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.ListSelect.child) - ::io::substrait::Expression* temp = else__; - else__ = nullptr; + ::io::substrait::Expression_MaskExpression_Select* temp = child_; + child_ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_IfThen::_internal_mutable_else_() { +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::_internal_mutable_child() { - if (else__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - else__ = p; + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_MaskExpression_Select>(GetArena()); + child_ = p; } - return else__; + return child_; } -inline ::io::substrait::Expression* Expression_IfThen::mutable_else_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.else) - return _internal_mutable_else_(); +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.ListSelect.child) + return _internal_mutable_child(); } -inline void Expression_IfThen::set_allocated_else_(::io::substrait::Expression* else_) { +inline void Expression_MaskExpression_ListSelect::set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete else__; + delete child_; } - if (else_) { + if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(else_); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); if (message_arena != submessage_arena) { - else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, else_, submessage_arena); + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); } } else { } - else__ = else_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.else) + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.child) } // ------------------------------------------------------------------- -// Expression_SwitchExpression_IfValue +// Expression_MaskExpression_MapSelect_MapKey -// .io.substrait.Expression if = 1; -inline bool Expression_SwitchExpression_IfValue::_internal_has_if_() const { - return this != internal_default_instance() && if__ != nullptr; +// string map_key = 1; +inline void Expression_MaskExpression_MapSelect_MapKey::clear_map_key() { + map_key_.ClearToEmpty(); } -inline bool Expression_SwitchExpression_IfValue::has_if_() const { - return _internal_has_if_(); +inline const std::string& Expression_MaskExpression_MapSelect_MapKey::map_key() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) + return _internal_map_key(); } -inline void Expression_SwitchExpression_IfValue::clear_if_() { - if (GetArena() == nullptr && if__ != nullptr) { - delete if__; - } - if__ = nullptr; +template +PROTOBUF_ALWAYS_INLINE +inline void Expression_MaskExpression_MapSelect_MapKey::set_map_key(ArgT0&& arg0, ArgT... args) { + + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) } -inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::_internal_if_() const { - const ::io::substrait::Expression* p = if__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline std::string* Expression_MaskExpression_MapSelect_MapKey::mutable_map_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) + return _internal_mutable_map_key(); } -inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::if_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.IfValue.if) - return _internal_if_(); +inline const std::string& Expression_MaskExpression_MapSelect_MapKey::_internal_map_key() const { + return map_key_.Get(); } -inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_if_( - ::io::substrait::Expression* if_) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); - } - if__ = if_; - if (if_) { +inline void Expression_MaskExpression_MapSelect_MapKey::_internal_set_map_key(const std::string& value) { + + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* Expression_MaskExpression_MapSelect_MapKey::_internal_mutable_map_key() { + + return map_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* Expression_MaskExpression_MapSelect_MapKey::release_map_key() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) + return map_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void Expression_MaskExpression_MapSelect_MapKey::set_allocated_map_key(std::string* map_key) { + if (map_key != nullptr) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.if) + map_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::release_if_() { - - ::io::substrait::Expression* temp = if__; - if__ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; + +// ------------------------------------------------------------------- + +// Expression_MaskExpression_MapSelect_MapKeyExpression + +// string map_key_expression = 1; +inline void Expression_MaskExpression_MapSelect_MapKeyExpression::clear_map_key_expression() { + map_key_expression_.ClearToEmpty(); } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_arena_release_if_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.IfValue.if) +inline const std::string& Expression_MaskExpression_MapSelect_MapKeyExpression::map_key_expression() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + return _internal_map_key_expression(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void Expression_MaskExpression_MapSelect_MapKeyExpression::set_map_key_expression(ArgT0&& arg0, ArgT... args) { + + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) +} +inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::mutable_map_key_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + return _internal_mutable_map_key_expression(); +} +inline const std::string& Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_map_key_expression() const { + return map_key_expression_.Get(); +} +inline void Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_set_map_key_expression(const std::string& value) { - ::io::substrait::Expression* temp = if__; - if__ = nullptr; - return temp; + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::_internal_mutable_if_() { +inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_mutable_map_key_expression() { - if (if__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - if__ = p; - } - return if__; + return map_key_expression_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::mutable_if_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.IfValue.if) - return _internal_mutable_if_(); +inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::release_map_key_expression() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + return map_key_expression_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void Expression_SwitchExpression_IfValue::set_allocated_if_(::io::substrait::Expression* if_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete if__; - } - if (if_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_); - if (message_arena != submessage_arena) { - if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, if_, submessage_arena); - } +inline void Expression_MaskExpression_MapSelect_MapKeyExpression::set_allocated_map_key_expression(std::string* map_key_expression) { + if (map_key_expression != nullptr) { } else { } - if__ = if_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.if) + map_key_expression_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key_expression, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) } -// .io.substrait.Expression then = 2; -inline bool Expression_SwitchExpression_IfValue::_internal_has_then() const { - return this != internal_default_instance() && then_ != nullptr; -} -inline bool Expression_SwitchExpression_IfValue::has_then() const { - return _internal_has_then(); -} -inline void Expression_SwitchExpression_IfValue::clear_then() { - if (GetArena() == nullptr && then_ != nullptr) { - delete then_; - } - then_ = nullptr; +// ------------------------------------------------------------------- + +// Expression_MaskExpression_MapSelect + +// .io.substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; +inline bool Expression_MaskExpression_MapSelect::_internal_has_key() const { + return select_case() == kKey; } -inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::_internal_then() const { - const ::io::substrait::Expression* p = then_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline bool Expression_MaskExpression_MapSelect::has_key() const { + return _internal_has_key(); } -inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::then() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.IfValue.then) - return _internal_then(); +inline void Expression_MaskExpression_MapSelect::set_has_key() { + _oneof_case_[0] = kKey; } -inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_then( - ::io::substrait::Expression* then) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); +inline void Expression_MaskExpression_MapSelect::clear_key() { + if (_internal_has_key()) { + if (GetArena() == nullptr) { + delete select_.key_; + } + clear_has_select(); } - then_ = then; - if (then) { - +} +inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::release_key() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.MapSelect.key) + if (_internal_has_key()) { + clear_has_select(); + ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + select_.key_ = nullptr; + return temp; } else { - + return nullptr; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.then) } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::release_then() { - - ::io::substrait::Expression* temp = then_; - then_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::_internal_key() const { + return _internal_has_key() + ? *select_.key_ + : reinterpret_cast< ::io::substrait::Expression_MaskExpression_MapSelect_MapKey&>(::io::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_); } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_arena_release_then() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.IfValue.then) - - ::io::substrait::Expression* temp = then_; - then_ = nullptr; - return temp; +inline const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::key() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.MapSelect.key) + return _internal_key(); } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::_internal_mutable_then() { - - if (then_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - then_ = p; +inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.MapSelect.key) + if (_internal_has_key()) { + clear_has_select(); + ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_; + select_.key_ = nullptr; + return temp; + } else { + return nullptr; } - return then_; -} -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::mutable_then() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.IfValue.then) - return _internal_mutable_then(); } -inline void Expression_SwitchExpression_IfValue::set_allocated_then(::io::substrait::Expression* then) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete then_; +inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_key(::io::substrait::Expression_MaskExpression_MapSelect_MapKey* key) { + clear_select(); + if (key) { + set_has_key(); + select_.key_ = key; } - if (then) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(then); - if (message_arena != submessage_arena) { - then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, then, submessage_arena); - } - - } else { - + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.key) +} +inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::_internal_mutable_key() { + if (!_internal_has_key()) { + clear_select(); + set_has_key(); + select_.key_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect_MapKey >(GetArena()); } - then_ = then; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.then) + return select_.key_; +} +inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::mutable_key() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.MapSelect.key) + return _internal_mutable_key(); } -// ------------------------------------------------------------------- - -// Expression_SwitchExpression - -// repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; -inline int Expression_SwitchExpression::_internal_ifs_size() const { - return ifs_.size(); +// .io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; +inline bool Expression_MaskExpression_MapSelect::_internal_has_expression() const { + return select_case() == kExpression; } -inline int Expression_SwitchExpression::ifs_size() const { - return _internal_ifs_size(); +inline bool Expression_MaskExpression_MapSelect::has_expression() const { + return _internal_has_expression(); } -inline void Expression_SwitchExpression::clear_ifs() { - ifs_.Clear(); +inline void Expression_MaskExpression_MapSelect::set_has_expression() { + _oneof_case_[0] = kExpression; } -inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::mutable_ifs(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.ifs) - return ifs_.Mutable(index); +inline void Expression_MaskExpression_MapSelect::clear_expression() { + if (_internal_has_expression()) { + if (GetArena() == nullptr) { + delete select_.expression_; + } + clear_has_select(); + } } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >* -Expression_SwitchExpression::mutable_ifs() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.SwitchExpression.ifs) - return &ifs_; +inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::release_expression() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.MapSelect.expression) + if (_internal_has_expression()) { + clear_has_select(); + ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + select_.expression_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline const ::io::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::_internal_ifs(int index) const { - return ifs_.Get(index); +inline const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::_internal_expression() const { + return _internal_has_expression() + ? *select_.expression_ + : reinterpret_cast< ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression&>(::io::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_); } -inline const ::io::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::ifs(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.ifs) - return _internal_ifs(index); +inline const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::expression() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.MapSelect.expression) + return _internal_expression(); +} +inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.MapSelect.expression) + if (_internal_has_expression()) { + clear_has_select(); + ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; + select_.expression_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::_internal_add_ifs() { - return ifs_.Add(); +inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_expression(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) { + clear_select(); + if (expression) { + set_has_expression(); + select_.expression_ = expression; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.expression) } -inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::add_ifs() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.SwitchExpression.ifs) - return _internal_add_ifs(); +inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::_internal_mutable_expression() { + if (!_internal_has_expression()) { + clear_select(); + set_has_expression(); + select_.expression_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(GetArena()); + } + return select_.expression_; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >& -Expression_SwitchExpression::ifs() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.SwitchExpression.ifs) - return ifs_; +inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::mutable_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.MapSelect.expression) + return _internal_mutable_expression(); } -// .io.substrait.Expression else = 2; -inline bool Expression_SwitchExpression::_internal_has_else_() const { - return this != internal_default_instance() && else__ != nullptr; +// .io.substrait.Expression.MaskExpression.Select child = 3; +inline bool Expression_MaskExpression_MapSelect::_internal_has_child() const { + return this != internal_default_instance() && child_ != nullptr; } -inline bool Expression_SwitchExpression::has_else_() const { - return _internal_has_else_(); +inline bool Expression_MaskExpression_MapSelect::has_child() const { + return _internal_has_child(); } -inline void Expression_SwitchExpression::clear_else_() { - if (GetArena() == nullptr && else__ != nullptr) { - delete else__; +inline void Expression_MaskExpression_MapSelect::clear_child() { + if (GetArena() == nullptr && child_ != nullptr) { + delete child_; } - else__ = nullptr; + child_ = nullptr; } -inline const ::io::substrait::Expression& Expression_SwitchExpression::_internal_else_() const { - const ::io::substrait::Expression* p = else__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::_internal_child() const { + const ::io::substrait::Expression_MaskExpression_Select* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_MaskExpression_Select_default_instance_); } -inline const ::io::substrait::Expression& Expression_SwitchExpression::else_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.else) - return _internal_else_(); +inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::child() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.MapSelect.child) + return _internal_child(); } -inline void Expression_SwitchExpression::unsafe_arena_set_allocated_else_( - ::io::substrait::Expression* else_) { +inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_child( + ::io::substrait::Expression_MaskExpression_Select* child) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } - else__ = else_; - if (else_) { + child_ = child; + if (child) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.else) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.child) } -inline ::io::substrait::Expression* Expression_SwitchExpression::release_else_() { +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::release_child() { - ::io::substrait::Expression* temp = else__; - else__ = nullptr; + ::io::substrait::Expression_MaskExpression_Select* temp = child_; + child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_SwitchExpression::unsafe_arena_release_else_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.else) +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.MapSelect.child) - ::io::substrait::Expression* temp = else__; - else__ = nullptr; + ::io::substrait::Expression_MaskExpression_Select* temp = child_; + child_ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_SwitchExpression::_internal_mutable_else_() { +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::_internal_mutable_child() { - if (else__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - else__ = p; + if (child_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_MaskExpression_Select>(GetArena()); + child_ = p; } - return else__; + return child_; } -inline ::io::substrait::Expression* Expression_SwitchExpression::mutable_else_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.else) - return _internal_mutable_else_(); +inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::mutable_child() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.MapSelect.child) + return _internal_mutable_child(); } -inline void Expression_SwitchExpression::set_allocated_else_(::io::substrait::Expression* else_) { +inline void Expression_MaskExpression_MapSelect::set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete else__; + delete child_; } - if (else_) { + if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(else_); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); if (message_arena != submessage_arena) { - else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, else_, submessage_arena); + child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, child, submessage_arena); } } else { } - else__ = else_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.else) + child_ = child; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.child) } +inline bool Expression_MaskExpression_MapSelect::has_select() const { + return select_case() != SELECT_NOT_SET; +} +inline void Expression_MaskExpression_MapSelect::clear_has_select() { + _oneof_case_[0] = SELECT_NOT_SET; +} +inline Expression_MaskExpression_MapSelect::SelectCase Expression_MaskExpression_MapSelect::select_case() const { + return Expression_MaskExpression_MapSelect::SelectCase(_oneof_case_[0]); +} // ------------------------------------------------------------------- -// Expression_SingularOrList +// Expression_MaskExpression -// .io.substrait.Expression value = 1; -inline bool Expression_SingularOrList::_internal_has_value() const { - return this != internal_default_instance() && value_ != nullptr; +// .io.substrait.Expression.MaskExpression.StructSelect select = 1; +inline bool Expression_MaskExpression::_internal_has_select() const { + return this != internal_default_instance() && select_ != nullptr; } -inline bool Expression_SingularOrList::has_value() const { - return _internal_has_value(); +inline bool Expression_MaskExpression::has_select() const { + return _internal_has_select(); } -inline void Expression_SingularOrList::clear_value() { - if (GetArena() == nullptr && value_ != nullptr) { - delete value_; +inline void Expression_MaskExpression::clear_select() { + if (GetArena() == nullptr && select_ != nullptr) { + delete select_; } - value_ = nullptr; + select_ = nullptr; } -inline const ::io::substrait::Expression& Expression_SingularOrList::_internal_value() const { - const ::io::substrait::Expression* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::io::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::_internal_select() const { + const ::io::substrait::Expression_MaskExpression_StructSelect* p = select_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_MaskExpression_StructSelect_default_instance_); } -inline const ::io::substrait::Expression& Expression_SingularOrList::value() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SingularOrList.value) - return _internal_value(); +inline const ::io::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::select() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.select) + return _internal_select(); } -inline void Expression_SingularOrList::unsafe_arena_set_allocated_value( - ::io::substrait::Expression* value) { +inline void Expression_MaskExpression::unsafe_arena_set_allocated_select( + ::io::substrait::Expression_MaskExpression_StructSelect* select) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(select_); } - value_ = value; - if (value) { + select_ = select; + if (select) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SingularOrList.value) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.select) } -inline ::io::substrait::Expression* Expression_SingularOrList::release_value() { +inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::release_select() { - ::io::substrait::Expression* temp = value_; - value_ = nullptr; + ::io::substrait::Expression_MaskExpression_StructSelect* temp = select_; + select_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_SingularOrList::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.SingularOrList.value) +inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::unsafe_arena_release_select() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.select) - ::io::substrait::Expression* temp = value_; - value_ = nullptr; + ::io::substrait::Expression_MaskExpression_StructSelect* temp = select_; + select_ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_SingularOrList::_internal_mutable_value() { +inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::_internal_mutable_select() { - if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - value_ = p; + if (select_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_MaskExpression_StructSelect>(GetArena()); + select_ = p; } - return value_; + return select_; } -inline ::io::substrait::Expression* Expression_SingularOrList::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SingularOrList.value) - return _internal_mutable_value(); +inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::mutable_select() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.select) + return _internal_mutable_select(); } -inline void Expression_SingularOrList::set_allocated_value(::io::substrait::Expression* value) { +inline void Expression_MaskExpression::set_allocated_select(::io::substrait::Expression_MaskExpression_StructSelect* select) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete value_; + delete select_; } - if (value) { + if (select) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(select); if (message_arena != submessage_arena) { - value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value, submessage_arena); + select = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, select, submessage_arena); } } else { } - value_ = value; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SingularOrList.value) + select_ = select; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.select) } -// repeated .io.substrait.Expression options = 2; -inline int Expression_SingularOrList::_internal_options_size() const { - return options_.size(); -} -inline int Expression_SingularOrList::options_size() const { - return _internal_options_size(); -} -inline void Expression_SingularOrList::clear_options() { - options_.Clear(); -} -inline ::io::substrait::Expression* Expression_SingularOrList::mutable_options(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SingularOrList.options) - return options_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* -Expression_SingularOrList::mutable_options() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.SingularOrList.options) - return &options_; -} -inline const ::io::substrait::Expression& Expression_SingularOrList::_internal_options(int index) const { - return options_.Get(index); +// bool maintain_singular_struct = 2; +inline void Expression_MaskExpression::clear_maintain_singular_struct() { + maintain_singular_struct_ = false; } -inline const ::io::substrait::Expression& Expression_SingularOrList::options(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SingularOrList.options) - return _internal_options(index); +inline bool Expression_MaskExpression::_internal_maintain_singular_struct() const { + return maintain_singular_struct_; } -inline ::io::substrait::Expression* Expression_SingularOrList::_internal_add_options() { - return options_.Add(); +inline bool Expression_MaskExpression::maintain_singular_struct() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.maintain_singular_struct) + return _internal_maintain_singular_struct(); } -inline ::io::substrait::Expression* Expression_SingularOrList::add_options() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.SingularOrList.options) - return _internal_add_options(); +inline void Expression_MaskExpression::_internal_set_maintain_singular_struct(bool value) { + + maintain_singular_struct_ = value; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& -Expression_SingularOrList::options() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.SingularOrList.options) - return options_; +inline void Expression_MaskExpression::set_maintain_singular_struct(bool value) { + _internal_set_maintain_singular_struct(value); + // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.maintain_singular_struct) } // ------------------------------------------------------------------- -// Expression_MultiOrList_Record - -// repeated .io.substrait.Expression fields = 1; -inline int Expression_MultiOrList_Record::_internal_fields_size() const { - return fields_.size(); -} -inline int Expression_MultiOrList_Record::fields_size() const { - return _internal_fields_size(); -} -inline void Expression_MultiOrList_Record::clear_fields() { - fields_.Clear(); -} -inline ::io::substrait::Expression* Expression_MultiOrList_Record::mutable_fields(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.Record.fields) - return fields_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* -Expression_MultiOrList_Record::mutable_fields() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.Record.fields) - return &fields_; -} -inline const ::io::substrait::Expression& Expression_MultiOrList_Record::_internal_fields(int index) const { - return fields_.Get(index); -} -inline const ::io::substrait::Expression& Expression_MultiOrList_Record::fields(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.Record.fields) - return _internal_fields(index); -} -inline ::io::substrait::Expression* Expression_MultiOrList_Record::_internal_add_fields() { - return fields_.Add(); -} -inline ::io::substrait::Expression* Expression_MultiOrList_Record::add_fields() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.Record.fields) - return _internal_add_fields(); -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& -Expression_MultiOrList_Record::fields() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.Record.fields) - return fields_; -} +// Expression_FieldReference_RootReference // ------------------------------------------------------------------- -// Expression_MultiOrList - -// repeated .io.substrait.Expression value = 1; -inline int Expression_MultiOrList::_internal_value_size() const { - return value_.size(); -} -inline int Expression_MultiOrList::value_size() const { - return _internal_value_size(); -} -inline void Expression_MultiOrList::clear_value() { - value_.Clear(); -} -inline ::io::substrait::Expression* Expression_MultiOrList::mutable_value(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.value) - return value_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* -Expression_MultiOrList::mutable_value() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.value) - return &value_; -} -inline const ::io::substrait::Expression& Expression_MultiOrList::_internal_value(int index) const { - return value_.Get(index); -} -inline const ::io::substrait::Expression& Expression_MultiOrList::value(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.value) - return _internal_value(index); -} -inline ::io::substrait::Expression* Expression_MultiOrList::_internal_add_value() { - return value_.Add(); -} -inline ::io::substrait::Expression* Expression_MultiOrList::add_value() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.value) - return _internal_add_value(); -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& -Expression_MultiOrList::value() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.value) - return value_; -} +// Expression_FieldReference -// repeated .io.substrait.Expression.MultiOrList.Record options = 2; -inline int Expression_MultiOrList::_internal_options_size() const { - return options_.size(); -} -inline int Expression_MultiOrList::options_size() const { - return _internal_options_size(); -} -inline void Expression_MultiOrList::clear_options() { - options_.Clear(); -} -inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::mutable_options(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.options) - return options_.Mutable(index); +// .io.substrait.Expression.ReferenceSegment direct_reference = 1; +inline bool Expression_FieldReference::_internal_has_direct_reference() const { + return reference_type_case() == kDirectReference; } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >* -Expression_MultiOrList::mutable_options() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.options) - return &options_; +inline bool Expression_FieldReference::has_direct_reference() const { + return _internal_has_direct_reference(); } -inline const ::io::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::_internal_options(int index) const { - return options_.Get(index); +inline void Expression_FieldReference::set_has_direct_reference() { + _oneof_case_[0] = kDirectReference; } -inline const ::io::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::options(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.options) - return _internal_options(index); +inline void Expression_FieldReference::clear_direct_reference() { + if (_internal_has_direct_reference()) { + if (GetArena() == nullptr) { + delete reference_type_.direct_reference_; + } + clear_has_reference_type(); + } } -inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::_internal_add_options() { - return options_.Add(); +inline ::io::substrait::Expression_ReferenceSegment* Expression_FieldReference::release_direct_reference() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.FieldReference.direct_reference) + if (_internal_has_direct_reference()) { + clear_has_reference_type(); + ::io::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.direct_reference_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::add_options() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.options) - return _internal_add_options(); +inline const ::io::substrait::Expression_ReferenceSegment& Expression_FieldReference::_internal_direct_reference() const { + return _internal_has_direct_reference() + ? *reference_type_.direct_reference_ + : reinterpret_cast< ::io::substrait::Expression_ReferenceSegment&>(::io::substrait::_Expression_ReferenceSegment_default_instance_); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >& -Expression_MultiOrList::options() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.options) - return options_; +inline const ::io::substrait::Expression_ReferenceSegment& Expression_FieldReference::direct_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.FieldReference.direct_reference) + return _internal_direct_reference(); } - -// ------------------------------------------------------------------- - -// Expression_EmbeddedFunction_PythonPickleFunction - -// bytes function = 1; -inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_function() { - function_.ClearToEmpty(); +inline ::io::substrait::Expression_ReferenceSegment* Expression_FieldReference::unsafe_arena_release_direct_reference() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.FieldReference.direct_reference) + if (_internal_has_direct_reference()) { + clear_has_reference_type(); + ::io::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_; + reference_type_.direct_reference_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) - return _internal_function(); +inline void Expression_FieldReference::unsafe_arena_set_allocated_direct_reference(::io::substrait::Expression_ReferenceSegment* direct_reference) { + clear_reference_type(); + if (direct_reference) { + set_has_direct_reference(); + reference_type_.direct_reference_ = direct_reference; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.FieldReference.direct_reference) } -template -PROTOBUF_ALWAYS_INLINE -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_function(ArgT0&& arg0, ArgT... args) { - - function_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) +inline ::io::substrait::Expression_ReferenceSegment* Expression_FieldReference::_internal_mutable_direct_reference() { + if (!_internal_has_direct_reference()) { + clear_reference_type(); + set_has_direct_reference(); + reference_type_.direct_reference_ = CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment >(GetArena()); + } + return reference_type_.direct_reference_; } -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) - return _internal_mutable_function(); +inline ::io::substrait::Expression_ReferenceSegment* Expression_FieldReference::mutable_direct_reference() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.FieldReference.direct_reference) + return _internal_mutable_direct_reference(); } -inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_function() const { - return function_.Get(); + +// .io.substrait.Expression.MaskExpression masked_reference = 2; +inline bool Expression_FieldReference::_internal_has_masked_reference() const { + return reference_type_case() == kMaskedReference; } -inline void Expression_EmbeddedFunction_PythonPickleFunction::_internal_set_function(const std::string& value) { - - function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline bool Expression_FieldReference::has_masked_reference() const { + return _internal_has_masked_reference(); } -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_mutable_function() { - - return function_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline void Expression_FieldReference::set_has_masked_reference() { + _oneof_case_[0] = kMaskedReference; } -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::release_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) - return function_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline void Expression_FieldReference::clear_masked_reference() { + if (_internal_has_masked_reference()) { + if (GetArena() == nullptr) { + delete reference_type_.masked_reference_; + } + clear_has_reference_type(); + } } -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_allocated_function(std::string* function) { - if (function != nullptr) { - +inline ::io::substrait::Expression_MaskExpression* Expression_FieldReference::release_masked_reference() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.FieldReference.masked_reference) + if (_internal_has_masked_reference()) { + clear_has_reference_type(); + ::io::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + reference_type_.masked_reference_ = nullptr; + return temp; } else { - + return nullptr; } - function_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), function, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) -} - -// repeated string prerequisite = 2; -inline int Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite_size() const { - return prerequisite_.size(); } -inline int Expression_EmbeddedFunction_PythonPickleFunction::prerequisite_size() const { - return _internal_prerequisite_size(); +inline const ::io::substrait::Expression_MaskExpression& Expression_FieldReference::_internal_masked_reference() const { + return _internal_has_masked_reference() + ? *reference_type_.masked_reference_ + : reinterpret_cast< ::io::substrait::Expression_MaskExpression&>(::io::substrait::_Expression_MaskExpression_default_instance_); } -inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_prerequisite() { - prerequisite_.Clear(); +inline const ::io::substrait::Expression_MaskExpression& Expression_FieldReference::masked_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.FieldReference.masked_reference) + return _internal_masked_reference(); } -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return _internal_add_prerequisite(); +inline ::io::substrait::Expression_MaskExpression* Expression_FieldReference::unsafe_arena_release_masked_reference() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.FieldReference.masked_reference) + if (_internal_has_masked_reference()) { + clear_has_reference_type(); + ::io::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_; + reference_type_.masked_reference_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite(int index) const { - return prerequisite_.Get(index); +inline void Expression_FieldReference::unsafe_arena_set_allocated_masked_reference(::io::substrait::Expression_MaskExpression* masked_reference) { + clear_reference_type(); + if (masked_reference) { + set_has_masked_reference(); + reference_type_.masked_reference_ = masked_reference; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.FieldReference.masked_reference) } -inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::prerequisite(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return _internal_prerequisite(index); +inline ::io::substrait::Expression_MaskExpression* Expression_FieldReference::_internal_mutable_masked_reference() { + if (!_internal_has_masked_reference()) { + clear_reference_type(); + set_has_masked_reference(); + reference_type_.masked_reference_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression >(GetArena()); + } + return reference_type_.masked_reference_; } -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return prerequisite_.Mutable(index); +inline ::io::substrait::Expression_MaskExpression* Expression_FieldReference::mutable_masked_reference() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.FieldReference.masked_reference) + return _internal_mutable_masked_reference(); } -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - prerequisite_.Mutable(index)->assign(value); + +// .io.substrait.Expression expression = 3; +inline bool Expression_FieldReference::_internal_has_expression() const { + return root_type_case() == kExpression; } -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - prerequisite_.Mutable(index)->assign(std::move(value)); +inline bool Expression_FieldReference::has_expression() const { + return _internal_has_expression(); } -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - prerequisite_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +inline void Expression_FieldReference::set_has_expression() { + _oneof_case_[1] = kExpression; } -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value, size_t size) { - prerequisite_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +inline void Expression_FieldReference::clear_expression() { + if (_internal_has_expression()) { + if (GetArena() == nullptr) { + delete root_type_.expression_; + } + clear_has_root_type(); + } } -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_add_prerequisite() { - return prerequisite_.Add(); +inline ::io::substrait::Expression* Expression_FieldReference::release_expression() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.FieldReference.expression) + if (_internal_has_expression()) { + clear_has_root_type(); + ::io::substrait::Expression* temp = root_type_.expression_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + root_type_.expression_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const std::string& value) { - prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +inline const ::io::substrait::Expression& Expression_FieldReference::_internal_expression() const { + return _internal_has_expression() + ? *root_type_.expression_ + : reinterpret_cast< ::io::substrait::Expression&>(::io::substrait::_Expression_default_instance_); } -inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(std::string&& value) { - prerequisite_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +inline const ::io::substrait::Expression& Expression_FieldReference::expression() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.FieldReference.expression) + return _internal_expression(); } -inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value) { - GOOGLE_DCHECK(value != nullptr); - prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +inline ::io::substrait::Expression* Expression_FieldReference::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.FieldReference.expression) + if (_internal_has_expression()) { + clear_has_root_type(); + ::io::substrait::Expression* temp = root_type_.expression_; + root_type_.expression_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value, size_t size) { - prerequisite_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) +inline void Expression_FieldReference::unsafe_arena_set_allocated_expression(::io::substrait::Expression* expression) { + clear_root_type(); + if (expression) { + set_has_expression(); + root_type_.expression_ = expression; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.FieldReference.expression) } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Expression_EmbeddedFunction_PythonPickleFunction::prerequisite() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return prerequisite_; +inline ::io::substrait::Expression* Expression_FieldReference::_internal_mutable_expression() { + if (!_internal_has_expression()) { + clear_root_type(); + set_has_expression(); + root_type_.expression_ = CreateMaybeMessage< ::io::substrait::Expression >(GetArena()); + } + return root_type_.expression_; } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return &prerequisite_; +inline ::io::substrait::Expression* Expression_FieldReference::mutable_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.FieldReference.expression) + return _internal_mutable_expression(); } -// ------------------------------------------------------------------- - -// Expression_EmbeddedFunction_WebAssemblyFunction - -// bytes script = 1; -inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_script() { - script_.ClearToEmpty(); -} -inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::script() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) - return _internal_script(); +// .io.substrait.Expression.FieldReference.RootReference root_reference = 4; +inline bool Expression_FieldReference::_internal_has_root_reference() const { + return root_type_case() == kRootReference; } -template -PROTOBUF_ALWAYS_INLINE -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_script(ArgT0&& arg0, ArgT... args) { - - script_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) +inline bool Expression_FieldReference::has_root_reference() const { + return _internal_has_root_reference(); } -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_script() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) - return _internal_mutable_script(); +inline void Expression_FieldReference::set_has_root_reference() { + _oneof_case_[1] = kRootReference; } -inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_script() const { - return script_.Get(); +inline void Expression_FieldReference::clear_root_reference() { + if (_internal_has_root_reference()) { + if (GetArena() == nullptr) { + delete root_type_.root_reference_; + } + clear_has_root_type(); + } } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::_internal_set_script(const std::string& value) { - - script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline ::io::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::release_root_reference() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.FieldReference.root_reference) + if (_internal_has_root_reference()) { + clear_has_root_type(); + ::io::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + root_type_.root_reference_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_mutable_script() { - - return script_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline const ::io::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::_internal_root_reference() const { + return _internal_has_root_reference() + ? *root_type_.root_reference_ + : reinterpret_cast< ::io::substrait::Expression_FieldReference_RootReference&>(::io::substrait::_Expression_FieldReference_RootReference_default_instance_); } -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::release_script() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) - return script_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline const ::io::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::root_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.FieldReference.root_reference) + return _internal_root_reference(); } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_allocated_script(std::string* script) { - if (script != nullptr) { - +inline ::io::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::unsafe_arena_release_root_reference() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.FieldReference.root_reference) + if (_internal_has_root_reference()) { + clear_has_root_type(); + ::io::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_; + root_type_.root_reference_ = nullptr; + return temp; } else { - + return nullptr; } - script_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), script, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) } - -// repeated string prerequisite = 2; -inline int Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite_size() const { - return prerequisite_.size(); +inline void Expression_FieldReference::unsafe_arena_set_allocated_root_reference(::io::substrait::Expression_FieldReference_RootReference* root_reference) { + clear_root_type(); + if (root_reference) { + set_has_root_reference(); + root_type_.root_reference_ = root_reference; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.FieldReference.root_reference) } -inline int Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite_size() const { - return _internal_prerequisite_size(); +inline ::io::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::_internal_mutable_root_reference() { + if (!_internal_has_root_reference()) { + clear_root_type(); + set_has_root_reference(); + root_type_.root_reference_ = CreateMaybeMessage< ::io::substrait::Expression_FieldReference_RootReference >(GetArena()); + } + return root_type_.root_reference_; } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_prerequisite() { - prerequisite_.Clear(); +inline ::io::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::mutable_root_reference() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.FieldReference.root_reference) + return _internal_mutable_root_reference(); } -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return _internal_add_prerequisite(); + +inline bool Expression_FieldReference::has_reference_type() const { + return reference_type_case() != REFERENCE_TYPE_NOT_SET; } -inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite(int index) const { - return prerequisite_.Get(index); +inline void Expression_FieldReference::clear_has_reference_type() { + _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; } -inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return _internal_prerequisite(index); +inline bool Expression_FieldReference::has_root_type() const { + return root_type_case() != ROOT_TYPE_NOT_SET; } -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return prerequisite_.Mutable(index); +inline void Expression_FieldReference::clear_has_root_type() { + _oneof_case_[1] = ROOT_TYPE_NOT_SET; } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - prerequisite_.Mutable(index)->assign(value); +inline Expression_FieldReference::ReferenceTypeCase Expression_FieldReference::reference_type_case() const { + return Expression_FieldReference::ReferenceTypeCase(_oneof_case_[0]); } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - prerequisite_.Mutable(index)->assign(std::move(value)); +inline Expression_FieldReference::RootTypeCase Expression_FieldReference::root_type_case() const { + return Expression_FieldReference::RootTypeCase(_oneof_case_[1]); } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - prerequisite_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +// ------------------------------------------------------------------- + +// Expression + +// .io.substrait.Expression.Literal literal = 1; +inline bool Expression::_internal_has_literal() const { + return rex_type_case() == kLiteral; } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value, size_t size) { - prerequisite_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +inline bool Expression::has_literal() const { + return _internal_has_literal(); } -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_add_prerequisite() { - return prerequisite_.Add(); +inline void Expression::set_has_literal() { + _oneof_case_[0] = kLiteral; +} +inline void Expression::clear_literal() { + if (_internal_has_literal()) { + if (GetArena() == nullptr) { + delete rex_type_.literal_; + } + clear_has_rex_type(); + } +} +inline ::io::substrait::Expression_Literal* Expression::release_literal() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.literal) + if (_internal_has_literal()) { + clear_has_rex_type(); + ::io::substrait::Expression_Literal* temp = rex_type_.literal_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.literal_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const std::string& value) { - prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +inline const ::io::substrait::Expression_Literal& Expression::_internal_literal() const { + return _internal_has_literal() + ? *rex_type_.literal_ + : reinterpret_cast< ::io::substrait::Expression_Literal&>(::io::substrait::_Expression_Literal_default_instance_); } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(std::string&& value) { - prerequisite_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +inline const ::io::substrait::Expression_Literal& Expression::literal() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.literal) + return _internal_literal(); } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value) { - GOOGLE_DCHECK(value != nullptr); - prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +inline ::io::substrait::Expression_Literal* Expression::unsafe_arena_release_literal() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.literal) + if (_internal_has_literal()) { + clear_has_rex_type(); + ::io::substrait::Expression_Literal* temp = rex_type_.literal_; + rex_type_.literal_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value, size_t size) { - prerequisite_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) +inline void Expression::unsafe_arena_set_allocated_literal(::io::substrait::Expression_Literal* literal) { + clear_rex_type(); + if (literal) { + set_has_literal(); + rex_type_.literal_ = literal; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.literal) } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return prerequisite_; +inline ::io::substrait::Expression_Literal* Expression::_internal_mutable_literal() { + if (!_internal_has_literal()) { + clear_rex_type(); + set_has_literal(); + rex_type_.literal_ = CreateMaybeMessage< ::io::substrait::Expression_Literal >(GetArena()); + } + return rex_type_.literal_; } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return &prerequisite_; +inline ::io::substrait::Expression_Literal* Expression::mutable_literal() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.literal) + return _internal_mutable_literal(); } -// ------------------------------------------------------------------- - -// Expression_EmbeddedFunction - -// repeated .io.substrait.Expression arguments = 1; -inline int Expression_EmbeddedFunction::_internal_arguments_size() const { - return arguments_.size(); +// .io.substrait.Expression.FieldReference selection = 2; +inline bool Expression::_internal_has_selection() const { + return rex_type_case() == kSelection; } -inline int Expression_EmbeddedFunction::arguments_size() const { - return _internal_arguments_size(); +inline bool Expression::has_selection() const { + return _internal_has_selection(); } -inline void Expression_EmbeddedFunction::clear_arguments() { - arguments_.Clear(); +inline void Expression::set_has_selection() { + _oneof_case_[0] = kSelection; } -inline ::io::substrait::Expression* Expression_EmbeddedFunction::mutable_arguments(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.arguments) - return arguments_.Mutable(index); +inline void Expression::clear_selection() { + if (_internal_has_selection()) { + if (GetArena() == nullptr) { + delete rex_type_.selection_; + } + clear_has_rex_type(); + } } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* -Expression_EmbeddedFunction::mutable_arguments() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.arguments) - return &arguments_; +inline ::io::substrait::Expression_FieldReference* Expression::release_selection() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.selection) + if (_internal_has_selection()) { + clear_has_rex_type(); + ::io::substrait::Expression_FieldReference* temp = rex_type_.selection_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.selection_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline const ::io::substrait::Expression& Expression_EmbeddedFunction::_internal_arguments(int index) const { - return arguments_.Get(index); +inline const ::io::substrait::Expression_FieldReference& Expression::_internal_selection() const { + return _internal_has_selection() + ? *rex_type_.selection_ + : reinterpret_cast< ::io::substrait::Expression_FieldReference&>(::io::substrait::_Expression_FieldReference_default_instance_); } -inline const ::io::substrait::Expression& Expression_EmbeddedFunction::arguments(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.arguments) - return _internal_arguments(index); +inline const ::io::substrait::Expression_FieldReference& Expression::selection() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.selection) + return _internal_selection(); } -inline ::io::substrait::Expression* Expression_EmbeddedFunction::_internal_add_arguments() { - return arguments_.Add(); +inline ::io::substrait::Expression_FieldReference* Expression::unsafe_arena_release_selection() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.selection) + if (_internal_has_selection()) { + clear_has_rex_type(); + ::io::substrait::Expression_FieldReference* temp = rex_type_.selection_; + rex_type_.selection_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline ::io::substrait::Expression* Expression_EmbeddedFunction::add_arguments() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.arguments) - return _internal_add_arguments(); +inline void Expression::unsafe_arena_set_allocated_selection(::io::substrait::Expression_FieldReference* selection) { + clear_rex_type(); + if (selection) { + set_has_selection(); + rex_type_.selection_ = selection; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.selection) } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& -Expression_EmbeddedFunction::arguments() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.arguments) - return arguments_; +inline ::io::substrait::Expression_FieldReference* Expression::_internal_mutable_selection() { + if (!_internal_has_selection()) { + clear_rex_type(); + set_has_selection(); + rex_type_.selection_ = CreateMaybeMessage< ::io::substrait::Expression_FieldReference >(GetArena()); + } + return rex_type_.selection_; } - -// .io.substrait.Type output_type = 2; -inline bool Expression_EmbeddedFunction::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; +inline ::io::substrait::Expression_FieldReference* Expression::mutable_selection() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.selection) + return _internal_mutable_selection(); } -inline bool Expression_EmbeddedFunction::has_output_type() const { - return _internal_has_output_type(); + +// .io.substrait.Expression.ScalarFunction scalar_function = 3; +inline bool Expression::_internal_has_scalar_function() const { + return rex_type_case() == kScalarFunction; } -inline const ::io::substrait::Type& Expression_EmbeddedFunction::_internal_output_type() const { - const ::io::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline bool Expression::has_scalar_function() const { + return _internal_has_scalar_function(); } -inline const ::io::substrait::Type& Expression_EmbeddedFunction::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.output_type) - return _internal_output_type(); +inline void Expression::set_has_scalar_function() { + _oneof_case_[0] = kScalarFunction; } -inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); +inline void Expression::clear_scalar_function() { + if (_internal_has_scalar_function()) { + if (GetArena() == nullptr) { + delete rex_type_.scalar_function_; + } + clear_has_rex_type(); } - output_type_ = output_type; - if (output_type) { - +} +inline ::io::substrait::Expression_ScalarFunction* Expression::release_scalar_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.scalar_function) + if (_internal_has_scalar_function()) { + clear_has_rex_type(); + ::io::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + rex_type_.scalar_function_ = nullptr; + return temp; } else { - + return nullptr; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.output_type) } -inline ::io::substrait::Type* Expression_EmbeddedFunction::release_output_type() { - - ::io::substrait::Type* temp = output_type_; - output_type_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline const ::io::substrait::Expression_ScalarFunction& Expression::_internal_scalar_function() const { + return _internal_has_scalar_function() + ? *rex_type_.scalar_function_ + : reinterpret_cast< ::io::substrait::Expression_ScalarFunction&>(::io::substrait::_Expression_ScalarFunction_default_instance_); } -inline ::io::substrait::Type* Expression_EmbeddedFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.output_type) - - ::io::substrait::Type* temp = output_type_; - output_type_ = nullptr; - return temp; +inline const ::io::substrait::Expression_ScalarFunction& Expression::scalar_function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.scalar_function) + return _internal_scalar_function(); } -inline ::io::substrait::Type* Expression_EmbeddedFunction::_internal_mutable_output_type() { - - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); - output_type_ = p; +inline ::io::substrait::Expression_ScalarFunction* Expression::unsafe_arena_release_scalar_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.scalar_function) + if (_internal_has_scalar_function()) { + clear_has_rex_type(); + ::io::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; + rex_type_.scalar_function_ = nullptr; + return temp; + } else { + return nullptr; } - return output_type_; -} -inline ::io::substrait::Type* Expression_EmbeddedFunction::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.output_type) - return _internal_mutable_output_type(); } -inline void Expression_EmbeddedFunction::set_allocated_output_type(::io::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); +inline void Expression::unsafe_arena_set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function) { + clear_rex_type(); + if (scalar_function) { + set_has_scalar_function(); + rex_type_.scalar_function_ = scalar_function; } - if (output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); - if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); - } - - } else { - + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.scalar_function) +} +inline ::io::substrait::Expression_ScalarFunction* Expression::_internal_mutable_scalar_function() { + if (!_internal_has_scalar_function()) { + clear_rex_type(); + set_has_scalar_function(); + rex_type_.scalar_function_ = CreateMaybeMessage< ::io::substrait::Expression_ScalarFunction >(GetArena()); } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.output_type) + return rex_type_.scalar_function_; +} +inline ::io::substrait::Expression_ScalarFunction* Expression::mutable_scalar_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.scalar_function) + return _internal_mutable_scalar_function(); } -// .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; -inline bool Expression_EmbeddedFunction::_internal_has_python_pickle_function() const { - return kind_case() == kPythonPickleFunction; +// .io.substrait.Expression.WindowFunction window_function = 5; +inline bool Expression::_internal_has_window_function() const { + return rex_type_case() == kWindowFunction; } -inline bool Expression_EmbeddedFunction::has_python_pickle_function() const { - return _internal_has_python_pickle_function(); +inline bool Expression::has_window_function() const { + return _internal_has_window_function(); } -inline void Expression_EmbeddedFunction::set_has_python_pickle_function() { - _oneof_case_[0] = kPythonPickleFunction; +inline void Expression::set_has_window_function() { + _oneof_case_[0] = kWindowFunction; } -inline void Expression_EmbeddedFunction::clear_python_pickle_function() { - if (_internal_has_python_pickle_function()) { +inline void Expression::clear_window_function() { + if (_internal_has_window_function()) { if (GetArena() == nullptr) { - delete kind_.python_pickle_function_; + delete rex_type_.window_function_; } - clear_has_kind(); + clear_has_rex_type(); } } -inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::release_python_pickle_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.python_pickle_function) - if (_internal_has_python_pickle_function()) { - clear_has_kind(); - ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; +inline ::io::substrait::Expression_WindowFunction* Expression::release_window_function() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.window_function) + if (_internal_has_window_function()) { + clear_has_rex_type(); + ::io::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - kind_.python_pickle_function_ = nullptr; + rex_type_.window_function_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::_internal_python_pickle_function() const { - return _internal_has_python_pickle_function() - ? *kind_.python_pickle_function_ - : reinterpret_cast< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction&>(::io::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_); +inline const ::io::substrait::Expression_WindowFunction& Expression::_internal_window_function() const { + return _internal_has_window_function() + ? *rex_type_.window_function_ + : reinterpret_cast< ::io::substrait::Expression_WindowFunction&>(::io::substrait::_Expression_WindowFunction_default_instance_); } -inline const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::python_pickle_function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.python_pickle_function) - return _internal_python_pickle_function(); +inline const ::io::substrait::Expression_WindowFunction& Expression::window_function() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.window_function) + return _internal_window_function(); } -inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::unsafe_arena_release_python_pickle_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.EmbeddedFunction.python_pickle_function) - if (_internal_has_python_pickle_function()) { - clear_has_kind(); - ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; - kind_.python_pickle_function_ = nullptr; +inline ::io::substrait::Expression_WindowFunction* Expression::unsafe_arena_release_window_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.window_function) + if (_internal_has_window_function()) { + clear_has_rex_type(); + ::io::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; + rex_type_.window_function_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_python_pickle_function(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { - clear_kind(); - if (python_pickle_function) { - set_has_python_pickle_function(); - kind_.python_pickle_function_ = python_pickle_function; +inline void Expression::unsafe_arena_set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function) { + clear_rex_type(); + if (window_function) { + set_has_window_function(); + rex_type_.window_function_ = window_function; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.window_function) } -inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::_internal_mutable_python_pickle_function() { - if (!_internal_has_python_pickle_function()) { - clear_kind(); - set_has_python_pickle_function(); - kind_.python_pickle_function_ = CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(GetArena()); +inline ::io::substrait::Expression_WindowFunction* Expression::_internal_mutable_window_function() { + if (!_internal_has_window_function()) { + clear_rex_type(); + set_has_window_function(); + rex_type_.window_function_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction >(GetArena()); } - return kind_.python_pickle_function_; + return rex_type_.window_function_; } -inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::mutable_python_pickle_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.python_pickle_function) - return _internal_mutable_python_pickle_function(); +inline ::io::substrait::Expression_WindowFunction* Expression::mutable_window_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.window_function) + return _internal_mutable_window_function(); } -// .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; -inline bool Expression_EmbeddedFunction::_internal_has_web_assembly_function() const { - return kind_case() == kWebAssemblyFunction; +// .io.substrait.Expression.IfThen if_then = 6; +inline bool Expression::_internal_has_if_then() const { + return rex_type_case() == kIfThen; } -inline bool Expression_EmbeddedFunction::has_web_assembly_function() const { - return _internal_has_web_assembly_function(); +inline bool Expression::has_if_then() const { + return _internal_has_if_then(); } -inline void Expression_EmbeddedFunction::set_has_web_assembly_function() { - _oneof_case_[0] = kWebAssemblyFunction; +inline void Expression::set_has_if_then() { + _oneof_case_[0] = kIfThen; } -inline void Expression_EmbeddedFunction::clear_web_assembly_function() { - if (_internal_has_web_assembly_function()) { +inline void Expression::clear_if_then() { + if (_internal_has_if_then()) { if (GetArena() == nullptr) { - delete kind_.web_assembly_function_; + delete rex_type_.if_then_; } - clear_has_kind(); + clear_has_rex_type(); } } -inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::release_web_assembly_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.web_assembly_function) - if (_internal_has_web_assembly_function()) { - clear_has_kind(); - ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; +inline ::io::substrait::Expression_IfThen* Expression::release_if_then() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.if_then) + if (_internal_has_if_then()) { + clear_has_rex_type(); + ::io::substrait::Expression_IfThen* temp = rex_type_.if_then_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - kind_.web_assembly_function_ = nullptr; + rex_type_.if_then_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::_internal_web_assembly_function() const { - return _internal_has_web_assembly_function() - ? *kind_.web_assembly_function_ - : reinterpret_cast< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction&>(::io::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_); +inline const ::io::substrait::Expression_IfThen& Expression::_internal_if_then() const { + return _internal_has_if_then() + ? *rex_type_.if_then_ + : reinterpret_cast< ::io::substrait::Expression_IfThen&>(::io::substrait::_Expression_IfThen_default_instance_); } -inline const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::web_assembly_function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.web_assembly_function) - return _internal_web_assembly_function(); +inline const ::io::substrait::Expression_IfThen& Expression::if_then() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.if_then) + return _internal_if_then(); } -inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::unsafe_arena_release_web_assembly_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.EmbeddedFunction.web_assembly_function) - if (_internal_has_web_assembly_function()) { - clear_has_kind(); - ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; - kind_.web_assembly_function_ = nullptr; +inline ::io::substrait::Expression_IfThen* Expression::unsafe_arena_release_if_then() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.if_then) + if (_internal_has_if_then()) { + clear_has_rex_type(); + ::io::substrait::Expression_IfThen* temp = rex_type_.if_then_; + rex_type_.if_then_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_web_assembly_function(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { - clear_kind(); - if (web_assembly_function) { - set_has_web_assembly_function(); - kind_.web_assembly_function_ = web_assembly_function; +inline void Expression::unsafe_arena_set_allocated_if_then(::io::substrait::Expression_IfThen* if_then) { + clear_rex_type(); + if (if_then) { + set_has_if_then(); + rex_type_.if_then_ = if_then; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.if_then) } -inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::_internal_mutable_web_assembly_function() { - if (!_internal_has_web_assembly_function()) { - clear_kind(); - set_has_web_assembly_function(); - kind_.web_assembly_function_ = CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(GetArena()); +inline ::io::substrait::Expression_IfThen* Expression::_internal_mutable_if_then() { + if (!_internal_has_if_then()) { + clear_rex_type(); + set_has_if_then(); + rex_type_.if_then_ = CreateMaybeMessage< ::io::substrait::Expression_IfThen >(GetArena()); } - return kind_.web_assembly_function_; -} -inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::mutable_web_assembly_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.web_assembly_function) - return _internal_mutable_web_assembly_function(); -} - -inline bool Expression_EmbeddedFunction::has_kind() const { - return kind_case() != KIND_NOT_SET; -} -inline void Expression_EmbeddedFunction::clear_has_kind() { - _oneof_case_[0] = KIND_NOT_SET; + return rex_type_.if_then_; } -inline Expression_EmbeddedFunction::KindCase Expression_EmbeddedFunction::kind_case() const { - return Expression_EmbeddedFunction::KindCase(_oneof_case_[0]); +inline ::io::substrait::Expression_IfThen* Expression::mutable_if_then() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.if_then) + return _internal_mutable_if_then(); } -// ------------------------------------------------------------------- - -// Expression -// .io.substrait.Expression.Literal literal = 1; -inline bool Expression::_internal_has_literal() const { - return rex_type_case() == kLiteral; +// .io.substrait.Expression.SwitchExpression switch_expression = 7; +inline bool Expression::_internal_has_switch_expression() const { + return rex_type_case() == kSwitchExpression; } -inline bool Expression::has_literal() const { - return _internal_has_literal(); +inline bool Expression::has_switch_expression() const { + return _internal_has_switch_expression(); } -inline void Expression::set_has_literal() { - _oneof_case_[0] = kLiteral; +inline void Expression::set_has_switch_expression() { + _oneof_case_[0] = kSwitchExpression; } -inline void Expression::clear_literal() { - if (_internal_has_literal()) { +inline void Expression::clear_switch_expression() { + if (_internal_has_switch_expression()) { if (GetArena() == nullptr) { - delete rex_type_.literal_; + delete rex_type_.switch_expression_; } clear_has_rex_type(); } } -inline ::io::substrait::Expression_Literal* Expression::release_literal() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.literal) - if (_internal_has_literal()) { +inline ::io::substrait::Expression_SwitchExpression* Expression::release_switch_expression() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.switch_expression) + if (_internal_has_switch_expression()) { clear_has_rex_type(); - ::io::substrait::Expression_Literal* temp = rex_type_.literal_; + ::io::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - rex_type_.literal_ = nullptr; + rex_type_.switch_expression_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Expression_Literal& Expression::_internal_literal() const { - return _internal_has_literal() - ? *rex_type_.literal_ - : reinterpret_cast< ::io::substrait::Expression_Literal&>(::io::substrait::_Expression_Literal_default_instance_); +inline const ::io::substrait::Expression_SwitchExpression& Expression::_internal_switch_expression() const { + return _internal_has_switch_expression() + ? *rex_type_.switch_expression_ + : reinterpret_cast< ::io::substrait::Expression_SwitchExpression&>(::io::substrait::_Expression_SwitchExpression_default_instance_); } -inline const ::io::substrait::Expression_Literal& Expression::literal() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.literal) - return _internal_literal(); +inline const ::io::substrait::Expression_SwitchExpression& Expression::switch_expression() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.switch_expression) + return _internal_switch_expression(); } -inline ::io::substrait::Expression_Literal* Expression::unsafe_arena_release_literal() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.literal) - if (_internal_has_literal()) { +inline ::io::substrait::Expression_SwitchExpression* Expression::unsafe_arena_release_switch_expression() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.switch_expression) + if (_internal_has_switch_expression()) { clear_has_rex_type(); - ::io::substrait::Expression_Literal* temp = rex_type_.literal_; - rex_type_.literal_ = nullptr; + ::io::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; + rex_type_.switch_expression_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_literal(::io::substrait::Expression_Literal* literal) { +inline void Expression::unsafe_arena_set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression) { clear_rex_type(); - if (literal) { - set_has_literal(); - rex_type_.literal_ = literal; + if (switch_expression) { + set_has_switch_expression(); + rex_type_.switch_expression_ = switch_expression; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.literal) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.switch_expression) } -inline ::io::substrait::Expression_Literal* Expression::_internal_mutable_literal() { - if (!_internal_has_literal()) { +inline ::io::substrait::Expression_SwitchExpression* Expression::_internal_mutable_switch_expression() { + if (!_internal_has_switch_expression()) { clear_rex_type(); - set_has_literal(); - rex_type_.literal_ = CreateMaybeMessage< ::io::substrait::Expression_Literal >(GetArena()); + set_has_switch_expression(); + rex_type_.switch_expression_ = CreateMaybeMessage< ::io::substrait::Expression_SwitchExpression >(GetArena()); } - return rex_type_.literal_; + return rex_type_.switch_expression_; } -inline ::io::substrait::Expression_Literal* Expression::mutable_literal() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.literal) - return _internal_mutable_literal(); +inline ::io::substrait::Expression_SwitchExpression* Expression::mutable_switch_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.switch_expression) + return _internal_mutable_switch_expression(); } -// .io.substrait.FieldReference selection = 2; -inline bool Expression::_internal_has_selection() const { - return rex_type_case() == kSelection; +// .io.substrait.Expression.SingularOrList singular_or_list = 8; +inline bool Expression::_internal_has_singular_or_list() const { + return rex_type_case() == kSingularOrList; } -inline bool Expression::has_selection() const { - return _internal_has_selection(); +inline bool Expression::has_singular_or_list() const { + return _internal_has_singular_or_list(); } -inline void Expression::set_has_selection() { - _oneof_case_[0] = kSelection; +inline void Expression::set_has_singular_or_list() { + _oneof_case_[0] = kSingularOrList; } -inline ::io::substrait::FieldReference* Expression::release_selection() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.selection) - if (_internal_has_selection()) { +inline void Expression::clear_singular_or_list() { + if (_internal_has_singular_or_list()) { + if (GetArena() == nullptr) { + delete rex_type_.singular_or_list_; + } + clear_has_rex_type(); + } +} +inline ::io::substrait::Expression_SingularOrList* Expression::release_singular_or_list() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.singular_or_list) + if (_internal_has_singular_or_list()) { clear_has_rex_type(); - ::io::substrait::FieldReference* temp = rex_type_.selection_; + ::io::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - rex_type_.selection_ = nullptr; + rex_type_.singular_or_list_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::FieldReference& Expression::_internal_selection() const { - return _internal_has_selection() - ? *rex_type_.selection_ - : reinterpret_cast< ::io::substrait::FieldReference&>(::io::substrait::_FieldReference_default_instance_); +inline const ::io::substrait::Expression_SingularOrList& Expression::_internal_singular_or_list() const { + return _internal_has_singular_or_list() + ? *rex_type_.singular_or_list_ + : reinterpret_cast< ::io::substrait::Expression_SingularOrList&>(::io::substrait::_Expression_SingularOrList_default_instance_); } -inline const ::io::substrait::FieldReference& Expression::selection() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.selection) - return _internal_selection(); +inline const ::io::substrait::Expression_SingularOrList& Expression::singular_or_list() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.singular_or_list) + return _internal_singular_or_list(); } -inline ::io::substrait::FieldReference* Expression::unsafe_arena_release_selection() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.selection) - if (_internal_has_selection()) { +inline ::io::substrait::Expression_SingularOrList* Expression::unsafe_arena_release_singular_or_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.singular_or_list) + if (_internal_has_singular_or_list()) { clear_has_rex_type(); - ::io::substrait::FieldReference* temp = rex_type_.selection_; - rex_type_.selection_ = nullptr; + ::io::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; + rex_type_.singular_or_list_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_selection(::io::substrait::FieldReference* selection) { +inline void Expression::unsafe_arena_set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list) { clear_rex_type(); - if (selection) { - set_has_selection(); - rex_type_.selection_ = selection; + if (singular_or_list) { + set_has_singular_or_list(); + rex_type_.singular_or_list_ = singular_or_list; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.selection) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.singular_or_list) } -inline ::io::substrait::FieldReference* Expression::_internal_mutable_selection() { - if (!_internal_has_selection()) { +inline ::io::substrait::Expression_SingularOrList* Expression::_internal_mutable_singular_or_list() { + if (!_internal_has_singular_or_list()) { clear_rex_type(); - set_has_selection(); - rex_type_.selection_ = CreateMaybeMessage< ::io::substrait::FieldReference >(GetArena()); + set_has_singular_or_list(); + rex_type_.singular_or_list_ = CreateMaybeMessage< ::io::substrait::Expression_SingularOrList >(GetArena()); } - return rex_type_.selection_; + return rex_type_.singular_or_list_; } -inline ::io::substrait::FieldReference* Expression::mutable_selection() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.selection) - return _internal_mutable_selection(); +inline ::io::substrait::Expression_SingularOrList* Expression::mutable_singular_or_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.singular_or_list) + return _internal_mutable_singular_or_list(); } -// .io.substrait.Expression.ScalarFunction scalar_function = 3; -inline bool Expression::_internal_has_scalar_function() const { - return rex_type_case() == kScalarFunction; +// .io.substrait.Expression.MultiOrList multi_or_list = 9; +inline bool Expression::_internal_has_multi_or_list() const { + return rex_type_case() == kMultiOrList; } -inline bool Expression::has_scalar_function() const { - return _internal_has_scalar_function(); +inline bool Expression::has_multi_or_list() const { + return _internal_has_multi_or_list(); } -inline void Expression::set_has_scalar_function() { - _oneof_case_[0] = kScalarFunction; +inline void Expression::set_has_multi_or_list() { + _oneof_case_[0] = kMultiOrList; } -inline void Expression::clear_scalar_function() { - if (_internal_has_scalar_function()) { +inline void Expression::clear_multi_or_list() { + if (_internal_has_multi_or_list()) { if (GetArena() == nullptr) { - delete rex_type_.scalar_function_; + delete rex_type_.multi_or_list_; } clear_has_rex_type(); } } -inline ::io::substrait::Expression_ScalarFunction* Expression::release_scalar_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.scalar_function) - if (_internal_has_scalar_function()) { +inline ::io::substrait::Expression_MultiOrList* Expression::release_multi_or_list() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.multi_or_list) + if (_internal_has_multi_or_list()) { clear_has_rex_type(); - ::io::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; + ::io::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - rex_type_.scalar_function_ = nullptr; + rex_type_.multi_or_list_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Expression_ScalarFunction& Expression::_internal_scalar_function() const { - return _internal_has_scalar_function() - ? *rex_type_.scalar_function_ - : reinterpret_cast< ::io::substrait::Expression_ScalarFunction&>(::io::substrait::_Expression_ScalarFunction_default_instance_); +inline const ::io::substrait::Expression_MultiOrList& Expression::_internal_multi_or_list() const { + return _internal_has_multi_or_list() + ? *rex_type_.multi_or_list_ + : reinterpret_cast< ::io::substrait::Expression_MultiOrList&>(::io::substrait::_Expression_MultiOrList_default_instance_); } -inline const ::io::substrait::Expression_ScalarFunction& Expression::scalar_function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.scalar_function) - return _internal_scalar_function(); +inline const ::io::substrait::Expression_MultiOrList& Expression::multi_or_list() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.multi_or_list) + return _internal_multi_or_list(); } -inline ::io::substrait::Expression_ScalarFunction* Expression::unsafe_arena_release_scalar_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.scalar_function) - if (_internal_has_scalar_function()) { +inline ::io::substrait::Expression_MultiOrList* Expression::unsafe_arena_release_multi_or_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.multi_or_list) + if (_internal_has_multi_or_list()) { clear_has_rex_type(); - ::io::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; - rex_type_.scalar_function_ = nullptr; + ::io::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; + rex_type_.multi_or_list_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function) { +inline void Expression::unsafe_arena_set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list) { clear_rex_type(); - if (scalar_function) { - set_has_scalar_function(); - rex_type_.scalar_function_ = scalar_function; + if (multi_or_list) { + set_has_multi_or_list(); + rex_type_.multi_or_list_ = multi_or_list; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.scalar_function) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.multi_or_list) } -inline ::io::substrait::Expression_ScalarFunction* Expression::_internal_mutable_scalar_function() { - if (!_internal_has_scalar_function()) { +inline ::io::substrait::Expression_MultiOrList* Expression::_internal_mutable_multi_or_list() { + if (!_internal_has_multi_or_list()) { clear_rex_type(); - set_has_scalar_function(); - rex_type_.scalar_function_ = CreateMaybeMessage< ::io::substrait::Expression_ScalarFunction >(GetArena()); + set_has_multi_or_list(); + rex_type_.multi_or_list_ = CreateMaybeMessage< ::io::substrait::Expression_MultiOrList >(GetArena()); } - return rex_type_.scalar_function_; + return rex_type_.multi_or_list_; } -inline ::io::substrait::Expression_ScalarFunction* Expression::mutable_scalar_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.scalar_function) - return _internal_mutable_scalar_function(); +inline ::io::substrait::Expression_MultiOrList* Expression::mutable_multi_or_list() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.multi_or_list) + return _internal_mutable_multi_or_list(); } -// .io.substrait.Expression.WindowFunction window_function = 5; -inline bool Expression::_internal_has_window_function() const { - return rex_type_case() == kWindowFunction; +// .io.substrait.Expression.Enum enum = 10; +inline bool Expression::_internal_has_enum_() const { + return rex_type_case() == kEnum; } -inline bool Expression::has_window_function() const { - return _internal_has_window_function(); +inline bool Expression::has_enum_() const { + return _internal_has_enum_(); } -inline void Expression::set_has_window_function() { - _oneof_case_[0] = kWindowFunction; +inline void Expression::set_has_enum_() { + _oneof_case_[0] = kEnum; } -inline void Expression::clear_window_function() { - if (_internal_has_window_function()) { +inline void Expression::clear_enum_() { + if (_internal_has_enum_()) { if (GetArena() == nullptr) { - delete rex_type_.window_function_; + delete rex_type_.enum__; } clear_has_rex_type(); } } -inline ::io::substrait::Expression_WindowFunction* Expression::release_window_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.window_function) - if (_internal_has_window_function()) { +inline ::io::substrait::Expression_Enum* Expression::release_enum_() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.enum) + if (_internal_has_enum_()) { clear_has_rex_type(); - ::io::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; + ::io::substrait::Expression_Enum* temp = rex_type_.enum__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - rex_type_.window_function_ = nullptr; + rex_type_.enum__ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Expression_WindowFunction& Expression::_internal_window_function() const { - return _internal_has_window_function() - ? *rex_type_.window_function_ - : reinterpret_cast< ::io::substrait::Expression_WindowFunction&>(::io::substrait::_Expression_WindowFunction_default_instance_); +inline const ::io::substrait::Expression_Enum& Expression::_internal_enum_() const { + return _internal_has_enum_() + ? *rex_type_.enum__ + : reinterpret_cast< ::io::substrait::Expression_Enum&>(::io::substrait::_Expression_Enum_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction& Expression::window_function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.window_function) - return _internal_window_function(); +inline const ::io::substrait::Expression_Enum& Expression::enum_() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.enum) + return _internal_enum_(); } -inline ::io::substrait::Expression_WindowFunction* Expression::unsafe_arena_release_window_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.window_function) - if (_internal_has_window_function()) { +inline ::io::substrait::Expression_Enum* Expression::unsafe_arena_release_enum_() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.enum) + if (_internal_has_enum_()) { clear_has_rex_type(); - ::io::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; - rex_type_.window_function_ = nullptr; + ::io::substrait::Expression_Enum* temp = rex_type_.enum__; + rex_type_.enum__ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function) { +inline void Expression::unsafe_arena_set_allocated_enum_(::io::substrait::Expression_Enum* enum_) { clear_rex_type(); - if (window_function) { - set_has_window_function(); - rex_type_.window_function_ = window_function; + if (enum_) { + set_has_enum_(); + rex_type_.enum__ = enum_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.window_function) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.enum) } -inline ::io::substrait::Expression_WindowFunction* Expression::_internal_mutable_window_function() { - if (!_internal_has_window_function()) { +inline ::io::substrait::Expression_Enum* Expression::_internal_mutable_enum_() { + if (!_internal_has_enum_()) { clear_rex_type(); - set_has_window_function(); - rex_type_.window_function_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction >(GetArena()); + set_has_enum_(); + rex_type_.enum__ = CreateMaybeMessage< ::io::substrait::Expression_Enum >(GetArena()); } - return rex_type_.window_function_; -} -inline ::io::substrait::Expression_WindowFunction* Expression::mutable_window_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.window_function) - return _internal_mutable_window_function(); + return rex_type_.enum__; } - -// .io.substrait.Expression.IfThen if_then = 6; -inline bool Expression::_internal_has_if_then() const { - return rex_type_case() == kIfThen; +inline ::io::substrait::Expression_Enum* Expression::mutable_enum_() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.enum) + return _internal_mutable_enum_(); } -inline bool Expression::has_if_then() const { - return _internal_has_if_then(); + +// .io.substrait.Expression.Cast cast = 11; +inline bool Expression::_internal_has_cast() const { + return rex_type_case() == kCast; } -inline void Expression::set_has_if_then() { - _oneof_case_[0] = kIfThen; +inline bool Expression::has_cast() const { + return _internal_has_cast(); } -inline void Expression::clear_if_then() { - if (_internal_has_if_then()) { +inline void Expression::set_has_cast() { + _oneof_case_[0] = kCast; +} +inline void Expression::clear_cast() { + if (_internal_has_cast()) { if (GetArena() == nullptr) { - delete rex_type_.if_then_; + delete rex_type_.cast_; } clear_has_rex_type(); } } -inline ::io::substrait::Expression_IfThen* Expression::release_if_then() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.if_then) - if (_internal_has_if_then()) { +inline ::io::substrait::Expression_Cast* Expression::release_cast() { + // @@protoc_insertion_point(field_release:io.substrait.Expression.cast) + if (_internal_has_cast()) { clear_has_rex_type(); - ::io::substrait::Expression_IfThen* temp = rex_type_.if_then_; + ::io::substrait::Expression_Cast* temp = rex_type_.cast_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - rex_type_.if_then_ = nullptr; + rex_type_.cast_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Expression_IfThen& Expression::_internal_if_then() const { - return _internal_has_if_then() - ? *rex_type_.if_then_ - : reinterpret_cast< ::io::substrait::Expression_IfThen&>(::io::substrait::_Expression_IfThen_default_instance_); +inline const ::io::substrait::Expression_Cast& Expression::_internal_cast() const { + return _internal_has_cast() + ? *rex_type_.cast_ + : reinterpret_cast< ::io::substrait::Expression_Cast&>(::io::substrait::_Expression_Cast_default_instance_); } -inline const ::io::substrait::Expression_IfThen& Expression::if_then() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.if_then) - return _internal_if_then(); +inline const ::io::substrait::Expression_Cast& Expression::cast() const { + // @@protoc_insertion_point(field_get:io.substrait.Expression.cast) + return _internal_cast(); } -inline ::io::substrait::Expression_IfThen* Expression::unsafe_arena_release_if_then() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.if_then) - if (_internal_has_if_then()) { +inline ::io::substrait::Expression_Cast* Expression::unsafe_arena_release_cast() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.cast) + if (_internal_has_cast()) { clear_has_rex_type(); - ::io::substrait::Expression_IfThen* temp = rex_type_.if_then_; - rex_type_.if_then_ = nullptr; + ::io::substrait::Expression_Cast* temp = rex_type_.cast_; + rex_type_.cast_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_if_then(::io::substrait::Expression_IfThen* if_then) { +inline void Expression::unsafe_arena_set_allocated_cast(::io::substrait::Expression_Cast* cast) { clear_rex_type(); - if (if_then) { - set_has_if_then(); - rex_type_.if_then_ = if_then; + if (cast) { + set_has_cast(); + rex_type_.cast_ = cast; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.if_then) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.cast) } -inline ::io::substrait::Expression_IfThen* Expression::_internal_mutable_if_then() { - if (!_internal_has_if_then()) { +inline ::io::substrait::Expression_Cast* Expression::_internal_mutable_cast() { + if (!_internal_has_cast()) { clear_rex_type(); - set_has_if_then(); - rex_type_.if_then_ = CreateMaybeMessage< ::io::substrait::Expression_IfThen >(GetArena()); + set_has_cast(); + rex_type_.cast_ = CreateMaybeMessage< ::io::substrait::Expression_Cast >(GetArena()); } - return rex_type_.if_then_; + return rex_type_.cast_; } -inline ::io::substrait::Expression_IfThen* Expression::mutable_if_then() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.if_then) - return _internal_mutable_if_then(); +inline ::io::substrait::Expression_Cast* Expression::mutable_cast() { + // @@protoc_insertion_point(field_mutable:io.substrait.Expression.cast) + return _internal_mutable_cast(); } -// .io.substrait.Expression.SwitchExpression switch_expression = 7; -inline bool Expression::_internal_has_switch_expression() const { - return rex_type_case() == kSwitchExpression; +inline bool Expression::has_rex_type() const { + return rex_type_case() != REX_TYPE_NOT_SET; } -inline bool Expression::has_switch_expression() const { - return _internal_has_switch_expression(); +inline void Expression::clear_has_rex_type() { + _oneof_case_[0] = REX_TYPE_NOT_SET; } -inline void Expression::set_has_switch_expression() { - _oneof_case_[0] = kSwitchExpression; +inline Expression::RexTypeCase Expression::rex_type_case() const { + return Expression::RexTypeCase(_oneof_case_[0]); } -inline void Expression::clear_switch_expression() { - if (_internal_has_switch_expression()) { - if (GetArena() == nullptr) { - delete rex_type_.switch_expression_; - } - clear_has_rex_type(); +// ------------------------------------------------------------------- + +// SortField + +// .io.substrait.Expression expr = 1; +inline bool SortField::_internal_has_expr() const { + return this != internal_default_instance() && expr_ != nullptr; +} +inline bool SortField::has_expr() const { + return _internal_has_expr(); +} +inline void SortField::clear_expr() { + if (GetArena() == nullptr && expr_ != nullptr) { + delete expr_; } + expr_ = nullptr; } -inline ::io::substrait::Expression_SwitchExpression* Expression::release_switch_expression() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.switch_expression) - if (_internal_has_switch_expression()) { - clear_has_rex_type(); - ::io::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.switch_expression_ = nullptr; - return temp; +inline const ::io::substrait::Expression& SortField::_internal_expr() const { + const ::io::substrait::Expression* p = expr_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& SortField::expr() const { + // @@protoc_insertion_point(field_get:io.substrait.SortField.expr) + return _internal_expr(); +} +inline void SortField::unsafe_arena_set_allocated_expr( + ::io::substrait::Expression* expr) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_); + } + expr_ = expr; + if (expr) { + } else { - return nullptr; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortField.expr) } -inline const ::io::substrait::Expression_SwitchExpression& Expression::_internal_switch_expression() const { - return _internal_has_switch_expression() - ? *rex_type_.switch_expression_ - : reinterpret_cast< ::io::substrait::Expression_SwitchExpression&>(::io::substrait::_Expression_SwitchExpression_default_instance_); +inline ::io::substrait::Expression* SortField::release_expr() { + + ::io::substrait::Expression* temp = expr_; + expr_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline const ::io::substrait::Expression_SwitchExpression& Expression::switch_expression() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.switch_expression) - return _internal_switch_expression(); +inline ::io::substrait::Expression* SortField::unsafe_arena_release_expr() { + // @@protoc_insertion_point(field_release:io.substrait.SortField.expr) + + ::io::substrait::Expression* temp = expr_; + expr_ = nullptr; + return temp; } -inline ::io::substrait::Expression_SwitchExpression* Expression::unsafe_arena_release_switch_expression() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.switch_expression) - if (_internal_has_switch_expression()) { - clear_has_rex_type(); - ::io::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; - rex_type_.switch_expression_ = nullptr; - return temp; +inline ::io::substrait::Expression* SortField::_internal_mutable_expr() { + + if (expr_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + expr_ = p; + } + return expr_; +} +inline ::io::substrait::Expression* SortField::mutable_expr() { + // @@protoc_insertion_point(field_mutable:io.substrait.SortField.expr) + return _internal_mutable_expr(); +} +inline void SortField::set_allocated_expr(::io::substrait::Expression* expr) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete expr_; + } + if (expr) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expr); + if (message_arena != submessage_arena) { + expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expr, submessage_arena); + } + } else { - return nullptr; + } + expr_ = expr; + // @@protoc_insertion_point(field_set_allocated:io.substrait.SortField.expr) } -inline void Expression::unsafe_arena_set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression) { - clear_rex_type(); - if (switch_expression) { - set_has_switch_expression(); - rex_type_.switch_expression_ = switch_expression; + +// .io.substrait.SortField.SortDirection direction = 2; +inline bool SortField::_internal_has_direction() const { + return sort_kind_case() == kDirection; +} +inline bool SortField::has_direction() const { + return _internal_has_direction(); +} +inline void SortField::set_has_direction() { + _oneof_case_[0] = kDirection; +} +inline void SortField::clear_direction() { + if (_internal_has_direction()) { + sort_kind_.direction_ = 0; + clear_has_sort_kind(); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.switch_expression) } -inline ::io::substrait::Expression_SwitchExpression* Expression::_internal_mutable_switch_expression() { - if (!_internal_has_switch_expression()) { - clear_rex_type(); - set_has_switch_expression(); - rex_type_.switch_expression_ = CreateMaybeMessage< ::io::substrait::Expression_SwitchExpression >(GetArena()); +inline ::io::substrait::SortField_SortDirection SortField::_internal_direction() const { + if (_internal_has_direction()) { + return static_cast< ::io::substrait::SortField_SortDirection >(sort_kind_.direction_); } - return rex_type_.switch_expression_; + return static_cast< ::io::substrait::SortField_SortDirection >(0); } -inline ::io::substrait::Expression_SwitchExpression* Expression::mutable_switch_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.switch_expression) - return _internal_mutable_switch_expression(); +inline ::io::substrait::SortField_SortDirection SortField::direction() const { + // @@protoc_insertion_point(field_get:io.substrait.SortField.direction) + return _internal_direction(); +} +inline void SortField::_internal_set_direction(::io::substrait::SortField_SortDirection value) { + if (!_internal_has_direction()) { + clear_sort_kind(); + set_has_direction(); + } + sort_kind_.direction_ = value; +} +inline void SortField::set_direction(::io::substrait::SortField_SortDirection value) { + // @@protoc_insertion_point(field_set:io.substrait.SortField.direction) + _internal_set_direction(value); } -// .io.substrait.Expression.SingularOrList singular_or_list = 8; -inline bool Expression::_internal_has_singular_or_list() const { - return rex_type_case() == kSingularOrList; +// uint32 comparison_function_reference = 3; +inline bool SortField::_internal_has_comparison_function_reference() const { + return sort_kind_case() == kComparisonFunctionReference; } -inline bool Expression::has_singular_or_list() const { - return _internal_has_singular_or_list(); +inline bool SortField::has_comparison_function_reference() const { + return _internal_has_comparison_function_reference(); } -inline void Expression::set_has_singular_or_list() { - _oneof_case_[0] = kSingularOrList; +inline void SortField::set_has_comparison_function_reference() { + _oneof_case_[0] = kComparisonFunctionReference; } -inline void Expression::clear_singular_or_list() { - if (_internal_has_singular_or_list()) { - if (GetArena() == nullptr) { - delete rex_type_.singular_or_list_; - } - clear_has_rex_type(); +inline void SortField::clear_comparison_function_reference() { + if (_internal_has_comparison_function_reference()) { + sort_kind_.comparison_function_reference_ = 0u; + clear_has_sort_kind(); } } -inline ::io::substrait::Expression_SingularOrList* Expression::release_singular_or_list() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.singular_or_list) - if (_internal_has_singular_or_list()) { - clear_has_rex_type(); - ::io::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.singular_or_list_ = nullptr; - return temp; - } else { - return nullptr; +inline ::PROTOBUF_NAMESPACE_ID::uint32 SortField::_internal_comparison_function_reference() const { + if (_internal_has_comparison_function_reference()) { + return sort_kind_.comparison_function_reference_; } + return 0u; } -inline const ::io::substrait::Expression_SingularOrList& Expression::_internal_singular_or_list() const { - return _internal_has_singular_or_list() - ? *rex_type_.singular_or_list_ - : reinterpret_cast< ::io::substrait::Expression_SingularOrList&>(::io::substrait::_Expression_SingularOrList_default_instance_); +inline void SortField::_internal_set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + if (!_internal_has_comparison_function_reference()) { + clear_sort_kind(); + set_has_comparison_function_reference(); + } + sort_kind_.comparison_function_reference_ = value; } -inline const ::io::substrait::Expression_SingularOrList& Expression::singular_or_list() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.singular_or_list) - return _internal_singular_or_list(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 SortField::comparison_function_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.SortField.comparison_function_reference) + return _internal_comparison_function_reference(); } -inline ::io::substrait::Expression_SingularOrList* Expression::unsafe_arena_release_singular_or_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.singular_or_list) - if (_internal_has_singular_or_list()) { - clear_has_rex_type(); - ::io::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; - rex_type_.singular_or_list_ = nullptr; - return temp; - } else { - return nullptr; - } +inline void SortField::set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_comparison_function_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.SortField.comparison_function_reference) +} + +inline bool SortField::has_sort_kind() const { + return sort_kind_case() != SORT_KIND_NOT_SET; +} +inline void SortField::clear_has_sort_kind() { + _oneof_case_[0] = SORT_KIND_NOT_SET; +} +inline SortField::SortKindCase SortField::sort_kind_case() const { + return SortField::SortKindCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// AggregateFunction + +// uint32 function_reference = 1; +inline void AggregateFunction::clear_function_reference() { + function_reference_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 AggregateFunction::_internal_function_reference() const { + return function_reference_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 AggregateFunction::function_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateFunction.function_reference) + return _internal_function_reference(); +} +inline void AggregateFunction::_internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + function_reference_ = value; +} +inline void AggregateFunction::set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_function_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.AggregateFunction.function_reference) +} + +// repeated .io.substrait.Expression args = 2; +inline int AggregateFunction::_internal_args_size() const { + return args_.size(); +} +inline int AggregateFunction::args_size() const { + return _internal_args_size(); +} +inline void AggregateFunction::clear_args() { + args_.Clear(); +} +inline ::io::substrait::Expression* AggregateFunction::mutable_args(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateFunction.args) + return args_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +AggregateFunction::mutable_args() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateFunction.args) + return &args_; +} +inline const ::io::substrait::Expression& AggregateFunction::_internal_args(int index) const { + return args_.Get(index); +} +inline const ::io::substrait::Expression& AggregateFunction::args(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateFunction.args) + return _internal_args(index); } -inline void Expression::unsafe_arena_set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list) { - clear_rex_type(); - if (singular_or_list) { - set_has_singular_or_list(); - rex_type_.singular_or_list_ = singular_or_list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.singular_or_list) +inline ::io::substrait::Expression* AggregateFunction::_internal_add_args() { + return args_.Add(); } -inline ::io::substrait::Expression_SingularOrList* Expression::_internal_mutable_singular_or_list() { - if (!_internal_has_singular_or_list()) { - clear_rex_type(); - set_has_singular_or_list(); - rex_type_.singular_or_list_ = CreateMaybeMessage< ::io::substrait::Expression_SingularOrList >(GetArena()); - } - return rex_type_.singular_or_list_; +inline ::io::substrait::Expression* AggregateFunction::add_args() { + // @@protoc_insertion_point(field_add:io.substrait.AggregateFunction.args) + return _internal_add_args(); } -inline ::io::substrait::Expression_SingularOrList* Expression::mutable_singular_or_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.singular_or_list) - return _internal_mutable_singular_or_list(); +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +AggregateFunction::args() const { + // @@protoc_insertion_point(field_list:io.substrait.AggregateFunction.args) + return args_; } -// .io.substrait.Expression.MultiOrList multi_or_list = 9; -inline bool Expression::_internal_has_multi_or_list() const { - return rex_type_case() == kMultiOrList; -} -inline bool Expression::has_multi_or_list() const { - return _internal_has_multi_or_list(); +// repeated .io.substrait.SortField sorts = 3; +inline int AggregateFunction::_internal_sorts_size() const { + return sorts_.size(); } -inline void Expression::set_has_multi_or_list() { - _oneof_case_[0] = kMultiOrList; +inline int AggregateFunction::sorts_size() const { + return _internal_sorts_size(); } -inline void Expression::clear_multi_or_list() { - if (_internal_has_multi_or_list()) { - if (GetArena() == nullptr) { - delete rex_type_.multi_or_list_; - } - clear_has_rex_type(); - } +inline void AggregateFunction::clear_sorts() { + sorts_.Clear(); } -inline ::io::substrait::Expression_MultiOrList* Expression::release_multi_or_list() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.multi_or_list) - if (_internal_has_multi_or_list()) { - clear_has_rex_type(); - ::io::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.multi_or_list_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::io::substrait::SortField* AggregateFunction::mutable_sorts(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateFunction.sorts) + return sorts_.Mutable(index); } -inline const ::io::substrait::Expression_MultiOrList& Expression::_internal_multi_or_list() const { - return _internal_has_multi_or_list() - ? *rex_type_.multi_or_list_ - : reinterpret_cast< ::io::substrait::Expression_MultiOrList&>(::io::substrait::_Expression_MultiOrList_default_instance_); +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* +AggregateFunction::mutable_sorts() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateFunction.sorts) + return &sorts_; } -inline const ::io::substrait::Expression_MultiOrList& Expression::multi_or_list() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.multi_or_list) - return _internal_multi_or_list(); +inline const ::io::substrait::SortField& AggregateFunction::_internal_sorts(int index) const { + return sorts_.Get(index); } -inline ::io::substrait::Expression_MultiOrList* Expression::unsafe_arena_release_multi_or_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.multi_or_list) - if (_internal_has_multi_or_list()) { - clear_has_rex_type(); - ::io::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; - rex_type_.multi_or_list_ = nullptr; - return temp; - } else { - return nullptr; - } +inline const ::io::substrait::SortField& AggregateFunction::sorts(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateFunction.sorts) + return _internal_sorts(index); } -inline void Expression::unsafe_arena_set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list) { - clear_rex_type(); - if (multi_or_list) { - set_has_multi_or_list(); - rex_type_.multi_or_list_ = multi_or_list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.multi_or_list) +inline ::io::substrait::SortField* AggregateFunction::_internal_add_sorts() { + return sorts_.Add(); } -inline ::io::substrait::Expression_MultiOrList* Expression::_internal_mutable_multi_or_list() { - if (!_internal_has_multi_or_list()) { - clear_rex_type(); - set_has_multi_or_list(); - rex_type_.multi_or_list_ = CreateMaybeMessage< ::io::substrait::Expression_MultiOrList >(GetArena()); - } - return rex_type_.multi_or_list_; +inline ::io::substrait::SortField* AggregateFunction::add_sorts() { + // @@protoc_insertion_point(field_add:io.substrait.AggregateFunction.sorts) + return _internal_add_sorts(); } -inline ::io::substrait::Expression_MultiOrList* Expression::mutable_multi_or_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.multi_or_list) - return _internal_mutable_multi_or_list(); +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& +AggregateFunction::sorts() const { + // @@protoc_insertion_point(field_list:io.substrait.AggregateFunction.sorts) + return sorts_; } -// .io.substrait.Expression.Enum enum = 10; -inline bool Expression::_internal_has_enum_() const { - return rex_type_case() == kEnum; +// .io.substrait.AggregationPhase phase = 4; +inline void AggregateFunction::clear_phase() { + phase_ = 0; } -inline bool Expression::has_enum_() const { - return _internal_has_enum_(); +inline ::io::substrait::AggregationPhase AggregateFunction::_internal_phase() const { + return static_cast< ::io::substrait::AggregationPhase >(phase_); } -inline void Expression::set_has_enum_() { - _oneof_case_[0] = kEnum; +inline ::io::substrait::AggregationPhase AggregateFunction::phase() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateFunction.phase) + return _internal_phase(); } -inline void Expression::clear_enum_() { - if (_internal_has_enum_()) { - if (GetArena() == nullptr) { - delete rex_type_.enum__; - } - clear_has_rex_type(); - } +inline void AggregateFunction::_internal_set_phase(::io::substrait::AggregationPhase value) { + + phase_ = value; } -inline ::io::substrait::Expression_Enum* Expression::release_enum_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.enum) - if (_internal_has_enum_()) { - clear_has_rex_type(); - ::io::substrait::Expression_Enum* temp = rex_type_.enum__; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.enum__ = nullptr; - return temp; - } else { - return nullptr; - } +inline void AggregateFunction::set_phase(::io::substrait::AggregationPhase value) { + _internal_set_phase(value); + // @@protoc_insertion_point(field_set:io.substrait.AggregateFunction.phase) } -inline const ::io::substrait::Expression_Enum& Expression::_internal_enum_() const { - return _internal_has_enum_() - ? *rex_type_.enum__ - : reinterpret_cast< ::io::substrait::Expression_Enum&>(::io::substrait::_Expression_Enum_default_instance_); + +// .io.substrait.Type output_type = 5; +inline bool AggregateFunction::_internal_has_output_type() const { + return this != internal_default_instance() && output_type_ != nullptr; } -inline const ::io::substrait::Expression_Enum& Expression::enum_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.enum) - return _internal_enum_(); +inline bool AggregateFunction::has_output_type() const { + return _internal_has_output_type(); } -inline ::io::substrait::Expression_Enum* Expression::unsafe_arena_release_enum_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.enum) - if (_internal_has_enum_()) { - clear_has_rex_type(); - ::io::substrait::Expression_Enum* temp = rex_type_.enum__; - rex_type_.enum__ = nullptr; - return temp; - } else { - return nullptr; - } +inline const ::io::substrait::Type& AggregateFunction::_internal_output_type() const { + const ::io::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_default_instance_); } -inline void Expression::unsafe_arena_set_allocated_enum_(::io::substrait::Expression_Enum* enum_) { - clear_rex_type(); - if (enum_) { - set_has_enum_(); - rex_type_.enum__ = enum_; +inline const ::io::substrait::Type& AggregateFunction::output_type() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateFunction.output_type) + return _internal_output_type(); +} +inline void AggregateFunction::unsafe_arena_set_allocated_output_type( + ::io::substrait::Type* output_type) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.enum) + output_type_ = output_type; + if (output_type) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateFunction.output_type) } -inline ::io::substrait::Expression_Enum* Expression::_internal_mutable_enum_() { - if (!_internal_has_enum_()) { - clear_rex_type(); - set_has_enum_(); - rex_type_.enum__ = CreateMaybeMessage< ::io::substrait::Expression_Enum >(GetArena()); +inline ::io::substrait::Type* AggregateFunction::release_output_type() { + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - return rex_type_.enum__; + return temp; } -inline ::io::substrait::Expression_Enum* Expression::mutable_enum_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.enum) - return _internal_mutable_enum_(); +inline ::io::substrait::Type* AggregateFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:io.substrait.AggregateFunction.output_type) + + ::io::substrait::Type* temp = output_type_; + output_type_ = nullptr; + return temp; } - -inline bool Expression::has_rex_type() const { - return rex_type_case() != REX_TYPE_NOT_SET; +inline ::io::substrait::Type* AggregateFunction::_internal_mutable_output_type() { + + if (output_type_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + output_type_ = p; + } + return output_type_; } -inline void Expression::clear_has_rex_type() { - _oneof_case_[0] = REX_TYPE_NOT_SET; +inline ::io::substrait::Type* AggregateFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateFunction.output_type) + return _internal_mutable_output_type(); } -inline Expression::RexTypeCase Expression::rex_type_case() const { - return Expression::RexTypeCase(_oneof_case_[0]); +inline void AggregateFunction::set_allocated_output_type(::io::substrait::Type* output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); + } + if (output_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + if (message_arena != submessage_arena) { + output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, output_type, submessage_arena); + } + + } else { + + } + output_type_ = output_type; + // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateFunction.output_type) } + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -11225,6 +17116,46 @@ inline Expression::RexTypeCase Expression::rex_type_case() const { // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) @@ -11233,15 +17164,15 @@ inline Expression::RexTypeCase Expression::rex_type_case() const { PROTOBUF_NAMESPACE_OPEN -template <> struct is_proto_enum< ::io::substrait::Expression_SortField_SortDirection> : ::std::true_type {}; +template <> struct is_proto_enum< ::io::substrait::SortField_SortDirection> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::Expression_SortField_SortDirection>() { - return ::io::substrait::Expression_SortField_SortDirection_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::SortField_SortDirection>() { + return ::io::substrait::SortField_SortDirection_descriptor(); } -template <> struct is_proto_enum< ::io::substrait::Expression_AggregationPhase> : ::std::true_type {}; +template <> struct is_proto_enum< ::io::substrait::AggregationPhase> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::Expression_AggregationPhase>() { - return ::io::substrait::Expression_AggregationPhase_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::AggregationPhase>() { + return ::io::substrait::AggregationPhase_descriptor(); } PROTOBUF_NAMESPACE_CLOSE diff --git a/cpp/src/generated/substrait/extensions.pb.cc b/cpp/src/generated/substrait/extensions.pb.cc index 4e3db173880..a5d7c540cf2 100644 --- a/cpp/src/generated/substrait/extensions.pb.cc +++ b/cpp/src/generated/substrait/extensions.pb.cc @@ -18,289 +18,194 @@ PROTOBUF_PRAGMA_INIT_SEG namespace io { namespace substrait { -constexpr Extensions_Extension_TypeExtension::Extensions_Extension_TypeExtension( +namespace extensions { +constexpr SimpleExtensionURI::SimpleExtensionURI( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : git_uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct Extensions_Extension_TypeExtensionDefaultTypeInternal { - constexpr Extensions_Extension_TypeExtensionDefaultTypeInternal() + : uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , extension_uri_anchor_(0u){} +struct SimpleExtensionURIDefaultTypeInternal { + constexpr SimpleExtensionURIDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Extensions_Extension_TypeExtensionDefaultTypeInternal() {} + ~SimpleExtensionURIDefaultTypeInternal() {} union { - Extensions_Extension_TypeExtension _instance; + SimpleExtensionURI _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_Extension_TypeExtensionDefaultTypeInternal _Extensions_Extension_TypeExtension_default_instance_; -constexpr Extensions_Extension_FunctionExtension::Extensions_Extension_FunctionExtension( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : git_uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct Extensions_Extension_FunctionExtensionDefaultTypeInternal { - constexpr Extensions_Extension_FunctionExtensionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Extensions_Extension_FunctionExtensionDefaultTypeInternal() {} - union { - Extensions_Extension_FunctionExtension _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_Extension_FunctionExtensionDefaultTypeInternal _Extensions_Extension_FunctionExtension_default_instance_; -constexpr Extensions_Extension::Extensions_Extension( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : extension_id_(nullptr) - , _oneof_case_{}{} -struct Extensions_ExtensionDefaultTypeInternal { - constexpr Extensions_ExtensionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Extensions_ExtensionDefaultTypeInternal() {} - union { - Extensions_Extension _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_ExtensionDefaultTypeInternal _Extensions_Extension_default_instance_; -constexpr Extensions_Mapping_TypeMapping::Extensions_Mapping_TypeMapping( +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionURIDefaultTypeInternal _SimpleExtensionURI_default_instance_; +constexpr SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , type_id_(nullptr) - , extension_id_(nullptr){} -struct Extensions_Mapping_TypeMappingDefaultTypeInternal { - constexpr Extensions_Mapping_TypeMappingDefaultTypeInternal() + , extension_uri_reference_(0u) + , type_anchor_(0u){} +struct SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal { + constexpr SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Extensions_Mapping_TypeMappingDefaultTypeInternal() {} + ~SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal() {} union { - Extensions_Mapping_TypeMapping _instance; + SimpleExtensionDeclaration_ExtensionType _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_Mapping_TypeMappingDefaultTypeInternal _Extensions_Mapping_TypeMapping_default_instance_; -constexpr Extensions_Mapping_FunctionMapping_Option::Extensions_Mapping_FunctionMapping_Option( +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionType_default_instance_; +constexpr SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal { - constexpr Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal() + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , extension_uri_pointer_(0u) + , type_variation_anchor_(0u){} +struct SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal { + constexpr SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal() {} + ~SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal() {} union { - Extensions_Mapping_FunctionMapping_Option _instance; + SimpleExtensionDeclaration_ExtensionTypeVariation _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal _Extensions_Mapping_FunctionMapping_Option_default_instance_; -constexpr Extensions_Mapping_FunctionMapping::Extensions_Mapping_FunctionMapping( +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_; +constexpr SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : options_() - , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , function_id_(nullptr) - , extension_id_(nullptr){} -struct Extensions_Mapping_FunctionMappingDefaultTypeInternal { - constexpr Extensions_Mapping_FunctionMappingDefaultTypeInternal() + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , extension_uri_pointer_(0u) + , function_anchor_(0u){} +struct SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal { + constexpr SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Extensions_Mapping_FunctionMappingDefaultTypeInternal() {} + ~SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal() {} union { - Extensions_Mapping_FunctionMapping _instance; + SimpleExtensionDeclaration_ExtensionFunction _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_Mapping_FunctionMappingDefaultTypeInternal _Extensions_Mapping_FunctionMapping_default_instance_; -constexpr Extensions_Mapping::Extensions_Mapping( +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionFunction_default_instance_; +constexpr SimpleExtensionDeclaration::SimpleExtensionDeclaration( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : _oneof_case_{}{} -struct Extensions_MappingDefaultTypeInternal { - constexpr Extensions_MappingDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Extensions_MappingDefaultTypeInternal() {} - union { - Extensions_Mapping _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_MappingDefaultTypeInternal _Extensions_Mapping_default_instance_; -constexpr Extensions_ExtensionId::Extensions_ExtensionId( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : id_(0u){} -struct Extensions_ExtensionIdDefaultTypeInternal { - constexpr Extensions_ExtensionIdDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Extensions_ExtensionIdDefaultTypeInternal() {} - union { - Extensions_ExtensionId _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_ExtensionIdDefaultTypeInternal _Extensions_ExtensionId_default_instance_; -constexpr Extensions_FunctionId::Extensions_FunctionId( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : id_(PROTOBUF_ULONGLONG(0)){} -struct Extensions_FunctionIdDefaultTypeInternal { - constexpr Extensions_FunctionIdDefaultTypeInternal() +struct SimpleExtensionDeclarationDefaultTypeInternal { + constexpr SimpleExtensionDeclarationDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Extensions_FunctionIdDefaultTypeInternal() {} + ~SimpleExtensionDeclarationDefaultTypeInternal() {} union { - Extensions_FunctionId _instance; + SimpleExtensionDeclaration _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_FunctionIdDefaultTypeInternal _Extensions_FunctionId_default_instance_; -constexpr Extensions_TypeId::Extensions_TypeId( +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclarationDefaultTypeInternal _SimpleExtensionDeclaration_default_instance_; +constexpr AdvancedExtension::AdvancedExtension( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : id_(PROTOBUF_ULONGLONG(0)){} -struct Extensions_TypeIdDefaultTypeInternal { - constexpr Extensions_TypeIdDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Extensions_TypeIdDefaultTypeInternal() {} - union { - Extensions_TypeId _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Extensions_TypeIdDefaultTypeInternal _Extensions_TypeId_default_instance_; -constexpr Extensions::Extensions( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} -struct ExtensionsDefaultTypeInternal { - constexpr ExtensionsDefaultTypeInternal() + : optimization_(nullptr) + , enhancement_(nullptr){} +struct AdvancedExtensionDefaultTypeInternal { + constexpr AdvancedExtensionDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ExtensionsDefaultTypeInternal() {} + ~AdvancedExtensionDefaultTypeInternal() {} union { - Extensions _instance; + AdvancedExtension _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionsDefaultTypeInternal _Extensions_default_instance_; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AdvancedExtensionDefaultTypeInternal _AdvancedExtension_default_instance_; +} // namespace extensions } // namespace substrait } // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_extensions_2eproto[11]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_extensions_2eproto[6]; static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_extensions_2eproto = nullptr; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_extensions_2eproto = nullptr; const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_extensions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension_TypeExtension, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension_TypeExtension, git_uri_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension_FunctionExtension, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionURI, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension_FunctionExtension, git_uri_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension, extension_id_), - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Extension, extension_type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionURI, extension_uri_anchor_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionURI, uri_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_TypeMapping, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_TypeMapping, type_id_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_TypeMapping, extension_id_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_TypeMapping, name_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, type_anchor_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, name_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping_Option, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping_Option, key_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping_Option, value_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_pointer_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, name_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping, function_id_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping, extension_id_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping, name_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping_FunctionMapping, options_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, extension_uri_pointer_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, function_anchor_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, name_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_Mapping, mapping_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_ExtensionId, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_ExtensionId, id_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_FunctionId, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_FunctionId, id_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_TypeId, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions_TypeId, id_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration, mapping_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Extensions, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::AdvancedExtension, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::AdvancedExtension, optimization_), + PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::AdvancedExtension, enhancement_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::Extensions_Extension_TypeExtension)}, - { 6, -1, sizeof(::io::substrait::Extensions_Extension_FunctionExtension)}, - { 12, -1, sizeof(::io::substrait::Extensions_Extension)}, - { 21, -1, sizeof(::io::substrait::Extensions_Mapping_TypeMapping)}, - { 29, -1, sizeof(::io::substrait::Extensions_Mapping_FunctionMapping_Option)}, - { 36, -1, sizeof(::io::substrait::Extensions_Mapping_FunctionMapping)}, - { 45, -1, sizeof(::io::substrait::Extensions_Mapping)}, - { 53, -1, sizeof(::io::substrait::Extensions_ExtensionId)}, - { 59, -1, sizeof(::io::substrait::Extensions_FunctionId)}, - { 65, -1, sizeof(::io::substrait::Extensions_TypeId)}, - { 71, -1, sizeof(::io::substrait::Extensions)}, + { 0, -1, sizeof(::io::substrait::extensions::SimpleExtensionURI)}, + { 7, -1, sizeof(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType)}, + { 15, -1, sizeof(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation)}, + { 23, -1, sizeof(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction)}, + { 31, -1, sizeof(::io::substrait::extensions::SimpleExtensionDeclaration)}, + { 40, -1, sizeof(::io::substrait::extensions::AdvancedExtension)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::_Extensions_Extension_TypeExtension_default_instance_), - reinterpret_cast(&::io::substrait::_Extensions_Extension_FunctionExtension_default_instance_), - reinterpret_cast(&::io::substrait::_Extensions_Extension_default_instance_), - reinterpret_cast(&::io::substrait::_Extensions_Mapping_TypeMapping_default_instance_), - reinterpret_cast(&::io::substrait::_Extensions_Mapping_FunctionMapping_Option_default_instance_), - reinterpret_cast(&::io::substrait::_Extensions_Mapping_FunctionMapping_default_instance_), - reinterpret_cast(&::io::substrait::_Extensions_Mapping_default_instance_), - reinterpret_cast(&::io::substrait::_Extensions_ExtensionId_default_instance_), - reinterpret_cast(&::io::substrait::_Extensions_FunctionId_default_instance_), - reinterpret_cast(&::io::substrait::_Extensions_TypeId_default_instance_), - reinterpret_cast(&::io::substrait::_Extensions_default_instance_), + reinterpret_cast(&::io::substrait::extensions::_SimpleExtensionURI_default_instance_), + reinterpret_cast(&::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_), + reinterpret_cast(&::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_), + reinterpret_cast(&::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_), + reinterpret_cast(&::io::substrait::extensions::_SimpleExtensionDeclaration_default_instance_), + reinterpret_cast(&::io::substrait::extensions::_AdvancedExtension_default_instance_), }; const char descriptor_table_protodef_extensions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\020extensions.proto\022\014io.substrait\"\337\007\n\nExt" - "ensions\032\301\002\n\tExtension\022:\n\014extension_id\030\001 " - "\001(\0132$.io.substrait.Extensions.ExtensionI" - "d\022J\n\016type_extension\030\002 \001(\01320.io.substrait" - ".Extensions.Extension.TypeExtensionH\000\022R\n" - "\022function_extension\030\003 \001(\01324.io.substrait" - ".Extensions.Extension.FunctionExtensionH" - "\000\032 \n\rTypeExtension\022\017\n\007git_uri\030\001 \001(\t\032$\n\021F" - "unctionExtension\022\017\n\007git_uri\030\001 \001(\tB\020\n\016ext" - "ension_type\032\301\004\n\007Mapping\022D\n\014type_mapping\030" - "\001 \001(\0132,.io.substrait.Extensions.Mapping." - "TypeMappingH\000\022L\n\020function_mapping\030\002 \001(\0132" - "0.io.substrait.Extensions.Mapping.Functi" - "onMappingH\000\032\211\001\n\013TypeMapping\0220\n\007type_id\030\001" - " \001(\0132\037.io.substrait.Extensions.TypeId\022:\n" - "\014extension_id\030\002 \001(\0132$.io.substrait.Exten" - "sions.ExtensionId\022\014\n\004name\030\003 \001(\t\032\205\002\n\017Func" - "tionMapping\0228\n\013function_id\030\001 \001(\0132#.io.su" - "bstrait.Extensions.FunctionId\022:\n\014extensi" - "on_id\030\002 \001(\0132$.io.substrait.Extensions.Ex" - "tensionId\022\014\n\004name\030\003 \001(\t\022H\n\007options\030\005 \003(\013" - "27.io.substrait.Extensions.Mapping.Funct" - "ionMapping.Option\032$\n\006Option\022\013\n\003key\030\001 \001(\t" - "\022\r\n\005value\030\002 \001(\tB\016\n\014mapping_type\032\031\n\013Exten" - "sionId\022\n\n\002id\030\001 \001(\r\032\030\n\nFunctionId\022\n\n\002id\030\001" - " \001(\004\032\024\n\006TypeId\022\n\n\002id\030\001 \001(\004B\027P\001\252\002\022Substra" - "it.Protobufb\006proto3" + "\n\020extensions.proto\022\027io.substrait.extensi" + "ons\032\031google/protobuf/any.proto\"\?\n\022Simple" + "ExtensionURI\022\034\n\024extension_uri_anchor\030\001 \001" + "(\r\022\013\n\003uri\030\002 \001(\t\"\364\004\n\032SimpleExtensionDecla" + "ration\022[\n\016extension_type\030\001 \001(\0132A.io.subs" + "trait.extensions.SimpleExtensionDeclarat" + "ion.ExtensionTypeH\000\022n\n\030extension_type_va" + "riation\030\002 \001(\0132J.io.substrait.extensions." + "SimpleExtensionDeclaration.ExtensionType" + "VariationH\000\022c\n\022extension_function\030\003 \001(\0132" + "E.io.substrait.extensions.SimpleExtensio" + "nDeclaration.ExtensionFunctionH\000\032S\n\rExte" + "nsionType\022\037\n\027extension_uri_reference\030\001 \001" + "(\r\022\023\n\013type_anchor\030\002 \001(\r\022\014\n\004name\030\003 \001(\t\032d\n" + "\026ExtensionTypeVariation\022\035\n\025extension_uri" + "_pointer\030\001 \001(\r\022\035\n\025type_variation_anchor\030" + "\002 \001(\r\022\014\n\004name\030\003 \001(\t\032Y\n\021ExtensionFunction" + "\022\035\n\025extension_uri_pointer\030\001 \001(\r\022\027\n\017funct" + "ion_anchor\030\002 \001(\r\022\014\n\004name\030\003 \001(\tB\016\n\014mappin" + "g_type\"j\n\021AdvancedExtension\022*\n\014optimizat" + "ion\030\001 \001(\0132\024.google.protobuf.Any\022)\n\013enhan" + "cement\030\002 \001(\0132\024.google.protobuf.AnyB+\n\022io" + ".substrait.protoP\001\252\002\022Substrait.Protobufb" + "\006proto3" ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_extensions_2eproto_deps[1] = { + &::descriptor_table_google_2fprotobuf_2fany_2eproto, +}; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_extensions_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_extensions_2eproto = { - false, false, 1059, descriptor_table_protodef_extensions_2eproto, "extensions.proto", - &descriptor_table_extensions_2eproto_once, nullptr, 0, 11, + false, false, 927, descriptor_table_protodef_extensions_2eproto, "extensions.proto", + &descriptor_table_extensions_2eproto_once, descriptor_table_extensions_2eproto_deps, 1, 6, schemas, file_default_instances, TableStruct_extensions_2eproto::offsets, file_level_metadata_extensions_2eproto, file_level_enum_descriptors_extensions_2eproto, file_level_service_descriptors_extensions_2eproto, }; @@ -312,77 +217,88 @@ PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_extensions_2eproto(&descriptor_table_extensions_2eproto); namespace io { namespace substrait { +namespace extensions { // =================================================================== -class Extensions_Extension_TypeExtension::_Internal { +class SimpleExtensionURI::_Internal { public: }; -Extensions_Extension_TypeExtension::Extensions_Extension_TypeExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena) +SimpleExtensionURI::SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Extension.TypeExtension) + // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.SimpleExtensionURI) } -Extensions_Extension_TypeExtension::Extensions_Extension_TypeExtension(const Extensions_Extension_TypeExtension& from) +SimpleExtensionURI::SimpleExtensionURI(const SimpleExtensionURI& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - git_uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_git_uri().empty()) { - git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_git_uri(), + uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_uri().empty()) { + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Extension.TypeExtension) + extension_uri_anchor_ = from.extension_uri_anchor_; + // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.SimpleExtensionURI) } -void Extensions_Extension_TypeExtension::SharedCtor() { -git_uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void SimpleExtensionURI::SharedCtor() { +uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +extension_uri_anchor_ = 0u; } -Extensions_Extension_TypeExtension::~Extensions_Extension_TypeExtension() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions.Extension.TypeExtension) +SimpleExtensionURI::~SimpleExtensionURI() { + // @@protoc_insertion_point(destructor:io.substrait.extensions.SimpleExtensionURI) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Extensions_Extension_TypeExtension::SharedDtor() { +void SimpleExtensionURI::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - git_uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -void Extensions_Extension_TypeExtension::ArenaDtor(void* object) { - Extensions_Extension_TypeExtension* _this = reinterpret_cast< Extensions_Extension_TypeExtension* >(object); +void SimpleExtensionURI::ArenaDtor(void* object) { + SimpleExtensionURI* _this = reinterpret_cast< SimpleExtensionURI* >(object); (void)_this; } -void Extensions_Extension_TypeExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void SimpleExtensionURI::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Extensions_Extension_TypeExtension::SetCachedSize(int size) const { +void SimpleExtensionURI::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Extensions_Extension_TypeExtension::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Extension.TypeExtension) +void SimpleExtensionURI::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.SimpleExtensionURI) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - git_uri_.ClearToEmpty(); + uri_.ClearToEmpty(); + extension_uri_anchor_ = 0u; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Extensions_Extension_TypeExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* SimpleExtensionURI::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // string git_uri = 1; + // uint32 extension_uri_anchor = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_git_uri(); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + extension_uri_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string uri = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_uri(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Extension.TypeExtension.git_uri")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.extensions.SimpleExtensionURI.uri")); CHK_(ptr); } else goto handle_unusual; continue; @@ -409,43 +325,56 @@ const char* Extensions_Extension_TypeExtension::_InternalParse(const char* ptr, #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Extension_TypeExtension::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionURI::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Extension.TypeExtension) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.SimpleExtensionURI) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string git_uri = 1; - if (this->git_uri().size() > 0) { + // uint32 extension_uri_anchor = 1; + if (this->extension_uri_anchor() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_anchor(), target); + } + + // string uri = 2; + if (this->uri().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_git_uri().data(), static_cast(this->_internal_git_uri().length()), + this->_internal_uri().data(), static_cast(this->_internal_uri().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Extensions.Extension.TypeExtension.git_uri"); + "io.substrait.extensions.SimpleExtensionURI.uri"); target = stream->WriteStringMaybeAliased( - 1, this->_internal_git_uri(), target); + 2, this->_internal_uri(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Extension.TypeExtension) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.SimpleExtensionURI) return target; } -size_t Extensions_Extension_TypeExtension::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Extension.TypeExtension) +size_t SimpleExtensionURI::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.SimpleExtensionURI) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string git_uri = 1; - if (this->git_uri().size() > 0) { + // string uri = 2; + if (this->uri().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_git_uri()); + this->_internal_uri()); + } + + // uint32 extension_uri_anchor = 1; + if (this->extension_uri_anchor() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_extension_uri_anchor()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -457,58 +386,62 @@ size_t Extensions_Extension_TypeExtension::ByteSizeLong() const { return total_size; } -void Extensions_Extension_TypeExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Extension.TypeExtension) +void SimpleExtensionURI::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.SimpleExtensionURI) GOOGLE_DCHECK_NE(&from, this); - const Extensions_Extension_TypeExtension* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const SimpleExtensionURI* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Extension.TypeExtension) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.SimpleExtensionURI) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Extension.TypeExtension) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.SimpleExtensionURI) MergeFrom(*source); } } -void Extensions_Extension_TypeExtension::MergeFrom(const Extensions_Extension_TypeExtension& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Extension.TypeExtension) +void SimpleExtensionURI::MergeFrom(const SimpleExtensionURI& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.SimpleExtensionURI) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.git_uri().size() > 0) { - _internal_set_git_uri(from._internal_git_uri()); + if (from.uri().size() > 0) { + _internal_set_uri(from._internal_uri()); + } + if (from.extension_uri_anchor() != 0) { + _internal_set_extension_uri_anchor(from._internal_extension_uri_anchor()); } } -void Extensions_Extension_TypeExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Extension.TypeExtension) +void SimpleExtensionURI::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.SimpleExtensionURI) if (&from == this) return; Clear(); MergeFrom(from); } -void Extensions_Extension_TypeExtension::CopyFrom(const Extensions_Extension_TypeExtension& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Extension.TypeExtension) +void SimpleExtensionURI::CopyFrom(const SimpleExtensionURI& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.SimpleExtensionURI) if (&from == this) return; Clear(); MergeFrom(from); } -bool Extensions_Extension_TypeExtension::IsInitialized() const { +bool SimpleExtensionURI::IsInitialized() const { return true; } -void Extensions_Extension_TypeExtension::InternalSwap(Extensions_Extension_TypeExtension* other) { +void SimpleExtensionURI::InternalSwap(SimpleExtensionURI* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - git_uri_.Swap(&other->git_uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + uri_.Swap(&other->uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(extension_uri_anchor_, other->extension_uri_anchor_); } -::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Extension_TypeExtension::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionURI::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, file_level_metadata_extensions_2eproto[0]); @@ -516,74 +449,98 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Extension_TypeExtension::GetMetadat // =================================================================== -class Extensions_Extension_FunctionExtension::_Internal { +class SimpleExtensionDeclaration_ExtensionType::_Internal { public: }; -Extensions_Extension_FunctionExtension::Extensions_Extension_FunctionExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena) +SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Extension.FunctionExtension) + // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) } -Extensions_Extension_FunctionExtension::Extensions_Extension_FunctionExtension(const Extensions_Extension_FunctionExtension& from) +SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - git_uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_git_uri().empty()) { - git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_git_uri(), + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Extension.FunctionExtension) + ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, + static_cast(reinterpret_cast(&type_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) } -void Extensions_Extension_FunctionExtension::SharedCtor() { -git_uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void SimpleExtensionDeclaration_ExtensionType::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&type_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); } -Extensions_Extension_FunctionExtension::~Extensions_Extension_FunctionExtension() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions.Extension.FunctionExtension) +SimpleExtensionDeclaration_ExtensionType::~SimpleExtensionDeclaration_ExtensionType() { + // @@protoc_insertion_point(destructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Extensions_Extension_FunctionExtension::SharedDtor() { +void SimpleExtensionDeclaration_ExtensionType::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - git_uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -void Extensions_Extension_FunctionExtension::ArenaDtor(void* object) { - Extensions_Extension_FunctionExtension* _this = reinterpret_cast< Extensions_Extension_FunctionExtension* >(object); +void SimpleExtensionDeclaration_ExtensionType::ArenaDtor(void* object) { + SimpleExtensionDeclaration_ExtensionType* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionType* >(object); (void)_this; } -void Extensions_Extension_FunctionExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void SimpleExtensionDeclaration_ExtensionType::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Extensions_Extension_FunctionExtension::SetCachedSize(int size) const { +void SimpleExtensionDeclaration_ExtensionType::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Extensions_Extension_FunctionExtension::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Extension.FunctionExtension) +void SimpleExtensionDeclaration_ExtensionType::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - git_uri_.ClearToEmpty(); + name_.ClearToEmpty(); + ::memset(&extension_uri_reference_, 0, static_cast( + reinterpret_cast(&type_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Extensions_Extension_FunctionExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* SimpleExtensionDeclaration_ExtensionType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // string git_uri = 1; + // uint32 extension_uri_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_git_uri(); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint32 type_anchor = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + type_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Extension.FunctionExtension.git_uri")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name")); CHK_(ptr); } else goto handle_unusual; continue; @@ -610,43 +567,69 @@ const char* Extensions_Extension_FunctionExtension::_InternalParse(const char* p #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Extension_FunctionExtension::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionType::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Extension.FunctionExtension) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string git_uri = 1; - if (this->git_uri().size() > 0) { + // uint32 extension_uri_reference = 1; + if (this->extension_uri_reference() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); + } + + // uint32 type_anchor = 2; + if (this->type_anchor() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_anchor(), target); + } + + // string name = 3; + if (this->name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_git_uri().data(), static_cast(this->_internal_git_uri().length()), + this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Extensions.Extension.FunctionExtension.git_uri"); + "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name"); target = stream->WriteStringMaybeAliased( - 1, this->_internal_git_uri(), target); + 3, this->_internal_name(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Extension.FunctionExtension) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) return target; } -size_t Extensions_Extension_FunctionExtension::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Extension.FunctionExtension) +size_t SimpleExtensionDeclaration_ExtensionType::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string git_uri = 1; - if (this->git_uri().size() > 0) { + // string name = 3; + if (this->name().size() > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_git_uri()); + this->_internal_name()); + } + + // uint32 extension_uri_reference = 1; + if (this->extension_uri_reference() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_extension_uri_reference()); + } + + // uint32 type_anchor = 2; + if (this->type_anchor() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_anchor()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -658,58 +641,70 @@ size_t Extensions_Extension_FunctionExtension::ByteSizeLong() const { return total_size; } -void Extensions_Extension_FunctionExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Extension.FunctionExtension) +void SimpleExtensionDeclaration_ExtensionType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) GOOGLE_DCHECK_NE(&from, this); - const Extensions_Extension_FunctionExtension* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const SimpleExtensionDeclaration_ExtensionType* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Extension.FunctionExtension) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Extension.FunctionExtension) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) MergeFrom(*source); } } -void Extensions_Extension_FunctionExtension::MergeFrom(const Extensions_Extension_FunctionExtension& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Extension.FunctionExtension) +void SimpleExtensionDeclaration_ExtensionType::MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.git_uri().size() > 0) { - _internal_set_git_uri(from._internal_git_uri()); + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } + if (from.extension_uri_reference() != 0) { + _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); + } + if (from.type_anchor() != 0) { + _internal_set_type_anchor(from._internal_type_anchor()); } } -void Extensions_Extension_FunctionExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Extension.FunctionExtension) +void SimpleExtensionDeclaration_ExtensionType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) if (&from == this) return; Clear(); MergeFrom(from); } -void Extensions_Extension_FunctionExtension::CopyFrom(const Extensions_Extension_FunctionExtension& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Extension.FunctionExtension) +void SimpleExtensionDeclaration_ExtensionType::CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) if (&from == this) return; Clear(); MergeFrom(from); } -bool Extensions_Extension_FunctionExtension::IsInitialized() const { +bool SimpleExtensionDeclaration_ExtensionType::IsInitialized() const { return true; } -void Extensions_Extension_FunctionExtension::InternalSwap(Extensions_Extension_FunctionExtension* other) { +void SimpleExtensionDeclaration_ExtensionType::InternalSwap(SimpleExtensionDeclaration_ExtensionType* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - git_uri_.Swap(&other->git_uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, type_anchor_) + + sizeof(SimpleExtensionDeclaration_ExtensionType::type_anchor_) + - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_)>( + reinterpret_cast(&extension_uri_reference_), + reinterpret_cast(&other->extension_uri_reference_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Extension_FunctionExtension::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionType::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, file_level_metadata_extensions_2eproto[1]); @@ -717,176 +712,98 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Extension_FunctionExtension::GetMet // =================================================================== -class Extensions_Extension::_Internal { +class SimpleExtensionDeclaration_ExtensionTypeVariation::_Internal { public: - static const ::io::substrait::Extensions_ExtensionId& extension_id(const Extensions_Extension* msg); - static const ::io::substrait::Extensions_Extension_TypeExtension& type_extension(const Extensions_Extension* msg); - static const ::io::substrait::Extensions_Extension_FunctionExtension& function_extension(const Extensions_Extension* msg); }; -const ::io::substrait::Extensions_ExtensionId& -Extensions_Extension::_Internal::extension_id(const Extensions_Extension* msg) { - return *msg->extension_id_; -} -const ::io::substrait::Extensions_Extension_TypeExtension& -Extensions_Extension::_Internal::type_extension(const Extensions_Extension* msg) { - return *msg->extension_type_.type_extension_; -} -const ::io::substrait::Extensions_Extension_FunctionExtension& -Extensions_Extension::_Internal::function_extension(const Extensions_Extension* msg) { - return *msg->extension_type_.function_extension_; -} -void Extensions_Extension::set_allocated_type_extension(::io::substrait::Extensions_Extension_TypeExtension* type_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_extension_type(); - if (type_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_extension); - if (message_arena != submessage_arena) { - type_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type_extension, submessage_arena); - } - set_has_type_extension(); - extension_type_.type_extension_ = type_extension; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Extension.type_extension) -} -void Extensions_Extension::set_allocated_function_extension(::io::substrait::Extensions_Extension_FunctionExtension* function_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_extension_type(); - if (function_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(function_extension); - if (message_arena != submessage_arena) { - function_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, function_extension, submessage_arena); - } - set_has_function_extension(); - extension_type_.function_extension_ = function_extension; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Extension.function_extension) -} -Extensions_Extension::Extensions_Extension(::PROTOBUF_NAMESPACE_ID::Arena* arena) +SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Extension) + // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) } -Extensions_Extension::Extensions_Extension(const Extensions_Extension& from) +SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_extension_id()) { - extension_id_ = new ::io::substrait::Extensions_ExtensionId(*from.extension_id_); - } else { - extension_id_ = nullptr; - } - clear_has_extension_type(); - switch (from.extension_type_case()) { - case kTypeExtension: { - _internal_mutable_type_extension()->::io::substrait::Extensions_Extension_TypeExtension::MergeFrom(from._internal_type_extension()); - break; - } - case kFunctionExtension: { - _internal_mutable_function_extension()->::io::substrait::Extensions_Extension_FunctionExtension::MergeFrom(from._internal_function_extension()); - break; - } - case EXTENSION_TYPE_NOT_SET: { - break; - } + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Extension) + ::memcpy(&extension_uri_pointer_, &from.extension_uri_pointer_, + static_cast(reinterpret_cast(&type_variation_anchor_) - + reinterpret_cast(&extension_uri_pointer_)) + sizeof(type_variation_anchor_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) } -void Extensions_Extension::SharedCtor() { -extension_id_ = nullptr; -clear_has_extension_type(); +void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&extension_uri_pointer_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&type_variation_anchor_) - + reinterpret_cast(&extension_uri_pointer_)) + sizeof(type_variation_anchor_)); } -Extensions_Extension::~Extensions_Extension() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions.Extension) +SimpleExtensionDeclaration_ExtensionTypeVariation::~SimpleExtensionDeclaration_ExtensionTypeVariation() { + // @@protoc_insertion_point(destructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Extensions_Extension::SharedDtor() { +void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete extension_id_; - if (has_extension_type()) { - clear_extension_type(); - } + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } -void Extensions_Extension::ArenaDtor(void* object) { - Extensions_Extension* _this = reinterpret_cast< Extensions_Extension* >(object); +void SimpleExtensionDeclaration_ExtensionTypeVariation::ArenaDtor(void* object) { + SimpleExtensionDeclaration_ExtensionTypeVariation* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionTypeVariation* >(object); (void)_this; } -void Extensions_Extension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void SimpleExtensionDeclaration_ExtensionTypeVariation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Extensions_Extension::SetCachedSize(int size) const { +void SimpleExtensionDeclaration_ExtensionTypeVariation::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Extensions_Extension::clear_extension_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Extensions.Extension) - switch (extension_type_case()) { - case kTypeExtension: { - if (GetArena() == nullptr) { - delete extension_type_.type_extension_; - } - break; - } - case kFunctionExtension: { - if (GetArena() == nullptr) { - delete extension_type_.function_extension_; - } - break; - } - case EXTENSION_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = EXTENSION_TYPE_NOT_SET; -} - - -void Extensions_Extension::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Extension) +void SimpleExtensionDeclaration_ExtensionTypeVariation::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && extension_id_ != nullptr) { - delete extension_id_; - } - extension_id_ = nullptr; - clear_extension_type(); + name_.ClearToEmpty(); + ::memset(&extension_uri_pointer_, 0, static_cast( + reinterpret_cast(&type_variation_anchor_) - + reinterpret_cast(&extension_uri_pointer_)) + sizeof(type_variation_anchor_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Extensions_Extension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Extensions.ExtensionId extension_id = 1; + // uint32 extension_uri_pointer = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_id(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + extension_uri_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Extensions.Extension.TypeExtension type_extension = 2; + // uint32 type_variation_anchor = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_type_extension(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + type_variation_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Extensions.Extension.FunctionExtension function_extension = 3; + // string name = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_function_extension(), ptr); + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name")); CHK_(ptr); } else goto handle_unusual; continue; @@ -913,78 +830,71 @@ const char* Extensions_Extension::_InternalParse(const char* ptr, ::PROTOBUF_NAM #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Extension::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Extension) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Extensions.ExtensionId extension_id = 1; - if (this->has_extension_id()) { + // uint32 extension_uri_pointer = 1; + if (this->extension_uri_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::extension_id(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_pointer(), target); } - // .io.substrait.Extensions.Extension.TypeExtension type_extension = 2; - if (_internal_has_type_extension()) { + // uint32 type_variation_anchor = 2; + if (this->type_variation_anchor() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::type_extension(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_anchor(), target); } - // .io.substrait.Extensions.Extension.FunctionExtension function_extension = 3; - if (_internal_has_function_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::function_extension(this), target, stream); + // string name = 3; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Extension) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) return target; } -size_t Extensions_Extension::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Extension) +size_t SimpleExtensionDeclaration_ExtensionTypeVariation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Extensions.ExtensionId extension_id = 1; - if (this->has_extension_id()) { + // string name = 3; + if (this->name().size() > 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *extension_id_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); } - switch (extension_type_case()) { - // .io.substrait.Extensions.Extension.TypeExtension type_extension = 2; - case kTypeExtension: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *extension_type_.type_extension_); - break; - } - // .io.substrait.Extensions.Extension.FunctionExtension function_extension = 3; - case kFunctionExtension: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *extension_type_.function_extension_); - break; - } - case EXTENSION_TYPE_NOT_SET: { - break; - } + // uint32 extension_uri_pointer = 1; + if (this->extension_uri_pointer() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_extension_uri_pointer()); + } + + // uint32 type_variation_anchor = 2; + if (this->type_variation_anchor() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_anchor()); } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -994,73 +904,70 @@ size_t Extensions_Extension::ByteSizeLong() const { return total_size; } -void Extensions_Extension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Extension) +void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) GOOGLE_DCHECK_NE(&from, this); - const Extensions_Extension* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const SimpleExtensionDeclaration_ExtensionTypeVariation* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Extension) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Extension) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) MergeFrom(*source); } } -void Extensions_Extension::MergeFrom(const Extensions_Extension& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Extension) +void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_extension_id()) { - _internal_mutable_extension_id()->::io::substrait::Extensions_ExtensionId::MergeFrom(from._internal_extension_id()); + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); } - switch (from.extension_type_case()) { - case kTypeExtension: { - _internal_mutable_type_extension()->::io::substrait::Extensions_Extension_TypeExtension::MergeFrom(from._internal_type_extension()); - break; - } - case kFunctionExtension: { - _internal_mutable_function_extension()->::io::substrait::Extensions_Extension_FunctionExtension::MergeFrom(from._internal_function_extension()); - break; - } - case EXTENSION_TYPE_NOT_SET: { - break; - } + if (from.extension_uri_pointer() != 0) { + _internal_set_extension_uri_pointer(from._internal_extension_uri_pointer()); + } + if (from.type_variation_anchor() != 0) { + _internal_set_type_variation_anchor(from._internal_type_variation_anchor()); } } -void Extensions_Extension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Extension) +void SimpleExtensionDeclaration_ExtensionTypeVariation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) if (&from == this) return; Clear(); MergeFrom(from); } -void Extensions_Extension::CopyFrom(const Extensions_Extension& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Extension) +void SimpleExtensionDeclaration_ExtensionTypeVariation::CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) if (&from == this) return; Clear(); MergeFrom(from); } -bool Extensions_Extension::IsInitialized() const { +bool SimpleExtensionDeclaration_ExtensionTypeVariation::IsInitialized() const { return true; } -void Extensions_Extension::InternalSwap(Extensions_Extension* other) { +void SimpleExtensionDeclaration_ExtensionTypeVariation::InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(extension_id_, other->extension_id_); - swap(extension_type_, other->extension_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_) + + sizeof(SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor_) + - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_pointer_)>( + reinterpret_cast(&extension_uri_pointer_), + reinterpret_cast(&other->extension_uri_pointer_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Extension::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionTypeVariation::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, file_level_metadata_extensions_2eproto[2]); @@ -1068,27 +975,17 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Extension::GetMetadata() const { // =================================================================== -class Extensions_Mapping_TypeMapping::_Internal { +class SimpleExtensionDeclaration_ExtensionFunction::_Internal { public: - static const ::io::substrait::Extensions_TypeId& type_id(const Extensions_Mapping_TypeMapping* msg); - static const ::io::substrait::Extensions_ExtensionId& extension_id(const Extensions_Mapping_TypeMapping* msg); }; -const ::io::substrait::Extensions_TypeId& -Extensions_Mapping_TypeMapping::_Internal::type_id(const Extensions_Mapping_TypeMapping* msg) { - return *msg->type_id_; -} -const ::io::substrait::Extensions_ExtensionId& -Extensions_Mapping_TypeMapping::_Internal::extension_id(const Extensions_Mapping_TypeMapping* msg) { - return *msg->extension_id_; -} -Extensions_Mapping_TypeMapping::Extensions_Mapping_TypeMapping(::PROTOBUF_NAMESPACE_ID::Arena* arena) +SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Mapping.TypeMapping) + // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) } -Extensions_Mapping_TypeMapping::Extensions_Mapping_TypeMapping(const Extensions_Mapping_TypeMapping& from) +SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); @@ -1096,85 +993,71 @@ Extensions_Mapping_TypeMapping::Extensions_Mapping_TypeMapping(const Extensions_ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), GetArena()); } - if (from._internal_has_type_id()) { - type_id_ = new ::io::substrait::Extensions_TypeId(*from.type_id_); - } else { - type_id_ = nullptr; - } - if (from._internal_has_extension_id()) { - extension_id_ = new ::io::substrait::Extensions_ExtensionId(*from.extension_id_); - } else { - extension_id_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Mapping.TypeMapping) + ::memcpy(&extension_uri_pointer_, &from.extension_uri_pointer_, + static_cast(reinterpret_cast(&function_anchor_) - + reinterpret_cast(&extension_uri_pointer_)) + sizeof(function_anchor_)); + // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) } -void Extensions_Mapping_TypeMapping::SharedCtor() { +void SimpleExtensionDeclaration_ExtensionFunction::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_id_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&extension_id_) - - reinterpret_cast(&type_id_)) + sizeof(extension_id_)); + reinterpret_cast(&extension_uri_pointer_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&function_anchor_) - + reinterpret_cast(&extension_uri_pointer_)) + sizeof(function_anchor_)); } -Extensions_Mapping_TypeMapping::~Extensions_Mapping_TypeMapping() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions.Mapping.TypeMapping) +SimpleExtensionDeclaration_ExtensionFunction::~SimpleExtensionDeclaration_ExtensionFunction() { + // @@protoc_insertion_point(destructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Extensions_Mapping_TypeMapping::SharedDtor() { +void SimpleExtensionDeclaration_ExtensionFunction::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (this != internal_default_instance()) delete type_id_; - if (this != internal_default_instance()) delete extension_id_; } -void Extensions_Mapping_TypeMapping::ArenaDtor(void* object) { - Extensions_Mapping_TypeMapping* _this = reinterpret_cast< Extensions_Mapping_TypeMapping* >(object); +void SimpleExtensionDeclaration_ExtensionFunction::ArenaDtor(void* object) { + SimpleExtensionDeclaration_ExtensionFunction* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionFunction* >(object); (void)_this; } -void Extensions_Mapping_TypeMapping::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void SimpleExtensionDeclaration_ExtensionFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Extensions_Mapping_TypeMapping::SetCachedSize(int size) const { +void SimpleExtensionDeclaration_ExtensionFunction::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Extensions_Mapping_TypeMapping::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Mapping.TypeMapping) +void SimpleExtensionDeclaration_ExtensionFunction::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; name_.ClearToEmpty(); - if (GetArena() == nullptr && type_id_ != nullptr) { - delete type_id_; - } - type_id_ = nullptr; - if (GetArena() == nullptr && extension_id_ != nullptr) { - delete extension_id_; - } - extension_id_ = nullptr; + ::memset(&extension_uri_pointer_, 0, static_cast( + reinterpret_cast(&function_anchor_) - + reinterpret_cast(&extension_uri_pointer_)) + sizeof(function_anchor_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Extensions_Mapping_TypeMapping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* SimpleExtensionDeclaration_ExtensionFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Extensions.TypeId type_id = 1; + // uint32 extension_uri_pointer = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_type_id(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + extension_uri_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Extensions.ExtensionId extension_id = 2; + // uint32 function_anchor = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_id(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + function_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1183,7 +1066,7 @@ const char* Extensions_Mapping_TypeMapping::_InternalParse(const char* ptr, ::PR if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Mapping.TypeMapping.name")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name")); CHK_(ptr); } else goto handle_unusual; continue; @@ -1210,26 +1093,22 @@ const char* Extensions_Mapping_TypeMapping::_InternalParse(const char* ptr, ::PR #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Mapping_TypeMapping::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionFunction::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Mapping.TypeMapping) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Extensions.TypeId type_id = 1; - if (this->has_type_id()) { + // uint32 extension_uri_pointer = 1; + if (this->extension_uri_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::type_id(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_pointer(), target); } - // .io.substrait.Extensions.ExtensionId extension_id = 2; - if (this->has_extension_id()) { + // uint32 function_anchor = 2; + if (this->function_anchor() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::extension_id(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_function_anchor(), target); } // string name = 3; @@ -1237,7 +1116,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Mapping_TypeMapping::_InternalSeriali ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Extensions.Mapping.TypeMapping.name"); + "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name"); target = stream->WriteStringMaybeAliased( 3, this->_internal_name(), target); } @@ -1246,12 +1125,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Mapping_TypeMapping::_InternalSeriali target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Mapping.TypeMapping) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) return target; } -size_t Extensions_Mapping_TypeMapping::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Mapping.TypeMapping) +size_t SimpleExtensionDeclaration_ExtensionFunction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1265,18 +1144,18 @@ size_t Extensions_Mapping_TypeMapping::ByteSizeLong() const { this->_internal_name()); } - // .io.substrait.Extensions.TypeId type_id = 1; - if (this->has_type_id()) { + // uint32 extension_uri_pointer = 1; + if (this->extension_uri_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_id_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_extension_uri_pointer()); } - // .io.substrait.Extensions.ExtensionId extension_id = 2; - if (this->has_extension_id()) { + // uint32 function_anchor = 2; + if (this->function_anchor() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *extension_id_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_function_anchor()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1288,23 +1167,23 @@ size_t Extensions_Mapping_TypeMapping::ByteSizeLong() const { return total_size; } -void Extensions_Mapping_TypeMapping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Mapping.TypeMapping) +void SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) GOOGLE_DCHECK_NE(&from, this); - const Extensions_Mapping_TypeMapping* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const SimpleExtensionDeclaration_ExtensionFunction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Mapping.TypeMapping) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Mapping.TypeMapping) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) MergeFrom(*source); } } -void Extensions_Mapping_TypeMapping::MergeFrom(const Extensions_Mapping_TypeMapping& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Mapping.TypeMapping) +void SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1313,45 +1192,45 @@ void Extensions_Mapping_TypeMapping::MergeFrom(const Extensions_Mapping_TypeMapp if (from.name().size() > 0) { _internal_set_name(from._internal_name()); } - if (from.has_type_id()) { - _internal_mutable_type_id()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_type_id()); + if (from.extension_uri_pointer() != 0) { + _internal_set_extension_uri_pointer(from._internal_extension_uri_pointer()); } - if (from.has_extension_id()) { - _internal_mutable_extension_id()->::io::substrait::Extensions_ExtensionId::MergeFrom(from._internal_extension_id()); + if (from.function_anchor() != 0) { + _internal_set_function_anchor(from._internal_function_anchor()); } } -void Extensions_Mapping_TypeMapping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Mapping.TypeMapping) +void SimpleExtensionDeclaration_ExtensionFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) if (&from == this) return; Clear(); MergeFrom(from); } -void Extensions_Mapping_TypeMapping::CopyFrom(const Extensions_Mapping_TypeMapping& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Mapping.TypeMapping) +void SimpleExtensionDeclaration_ExtensionFunction::CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) if (&from == this) return; Clear(); MergeFrom(from); } -bool Extensions_Mapping_TypeMapping::IsInitialized() const { +bool SimpleExtensionDeclaration_ExtensionFunction::IsInitialized() const { return true; } -void Extensions_Mapping_TypeMapping::InternalSwap(Extensions_Mapping_TypeMapping* other) { +void SimpleExtensionDeclaration_ExtensionFunction::InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Extensions_Mapping_TypeMapping, extension_id_) - + sizeof(Extensions_Mapping_TypeMapping::extension_id_) - - PROTOBUF_FIELD_OFFSET(Extensions_Mapping_TypeMapping, type_id_)>( - reinterpret_cast(&type_id_), - reinterpret_cast(&other->type_id_)); + PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, function_anchor_) + + sizeof(SimpleExtensionDeclaration_ExtensionFunction::function_anchor_) + - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, extension_uri_pointer_)>( + reinterpret_cast(&extension_uri_pointer_), + reinterpret_cast(&other->extension_uri_pointer_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Mapping_TypeMapping::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, file_level_metadata_extensions_2eproto[3]); @@ -1359,91 +1238,190 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Mapping_TypeMapping::GetMetadata() // =================================================================== -class Extensions_Mapping_FunctionMapping_Option::_Internal { +class SimpleExtensionDeclaration::_Internal { public: + static const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type(const SimpleExtensionDeclaration* msg); + static const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation(const SimpleExtensionDeclaration* msg); + static const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function(const SimpleExtensionDeclaration* msg); }; -Extensions_Mapping_FunctionMapping_Option::Extensions_Mapping_FunctionMapping_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena) +const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& +SimpleExtensionDeclaration::_Internal::extension_type(const SimpleExtensionDeclaration* msg) { + return *msg->mapping_type_.extension_type_; +} +const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& +SimpleExtensionDeclaration::_Internal::extension_type_variation(const SimpleExtensionDeclaration* msg) { + return *msg->mapping_type_.extension_type_variation_; +} +const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& +SimpleExtensionDeclaration::_Internal::extension_function(const SimpleExtensionDeclaration* msg) { + return *msg->mapping_type_.extension_function_; +} +void SimpleExtensionDeclaration::set_allocated_extension_type(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_mapping_type(); + if (extension_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_type); + if (message_arena != submessage_arena) { + extension_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_type, submessage_arena); + } + set_has_extension_type(); + mapping_type_.extension_type_ = extension_type; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) +} +void SimpleExtensionDeclaration::set_allocated_extension_type_variation(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_mapping_type(); + if (extension_type_variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_type_variation); + if (message_arena != submessage_arena) { + extension_type_variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_type_variation, submessage_arena); + } + set_has_extension_type_variation(); + mapping_type_.extension_type_variation_ = extension_type_variation; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) +} +void SimpleExtensionDeclaration::set_allocated_extension_function(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_mapping_type(); + if (extension_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_function); + if (message_arena != submessage_arena) { + extension_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_function, submessage_arena); + } + set_has_extension_function(); + mapping_type_.extension_function_ = extension_function; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) +} +SimpleExtensionDeclaration::SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Mapping.FunctionMapping.Option) + // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.SimpleExtensionDeclaration) } -Extensions_Mapping_FunctionMapping_Option::Extensions_Mapping_FunctionMapping_Option(const Extensions_Mapping_FunctionMapping_Option& from) +SimpleExtensionDeclaration::SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_key().empty()) { - key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_key(), - GetArena()); - } - value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_value().empty()) { - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), - GetArena()); + clear_has_mapping_type(); + switch (from.mapping_type_case()) { + case kExtensionType: { + _internal_mutable_extension_type()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType::MergeFrom(from._internal_extension_type()); + break; + } + case kExtensionTypeVariation: { + _internal_mutable_extension_type_variation()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(from._internal_extension_type_variation()); + break; + } + case kExtensionFunction: { + _internal_mutable_extension_function()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(from._internal_extension_function()); + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Mapping.FunctionMapping.Option) + // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.SimpleExtensionDeclaration) } -void Extensions_Mapping_FunctionMapping_Option::SharedCtor() { -key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void SimpleExtensionDeclaration::SharedCtor() { +clear_has_mapping_type(); } -Extensions_Mapping_FunctionMapping_Option::~Extensions_Mapping_FunctionMapping_Option() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions.Mapping.FunctionMapping.Option) +SimpleExtensionDeclaration::~SimpleExtensionDeclaration() { + // @@protoc_insertion_point(destructor:io.substrait.extensions.SimpleExtensionDeclaration) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Extensions_Mapping_FunctionMapping_Option::SharedDtor() { +void SimpleExtensionDeclaration::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (has_mapping_type()) { + clear_mapping_type(); + } } -void Extensions_Mapping_FunctionMapping_Option::ArenaDtor(void* object) { - Extensions_Mapping_FunctionMapping_Option* _this = reinterpret_cast< Extensions_Mapping_FunctionMapping_Option* >(object); +void SimpleExtensionDeclaration::ArenaDtor(void* object) { + SimpleExtensionDeclaration* _this = reinterpret_cast< SimpleExtensionDeclaration* >(object); (void)_this; } -void Extensions_Mapping_FunctionMapping_Option::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void SimpleExtensionDeclaration::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Extensions_Mapping_FunctionMapping_Option::SetCachedSize(int size) const { +void SimpleExtensionDeclaration::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Extensions_Mapping_FunctionMapping_Option::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) +void SimpleExtensionDeclaration::clear_mapping_type() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.extensions.SimpleExtensionDeclaration) + switch (mapping_type_case()) { + case kExtensionType: { + if (GetArena() == nullptr) { + delete mapping_type_.extension_type_; + } + break; + } + case kExtensionTypeVariation: { + if (GetArena() == nullptr) { + delete mapping_type_.extension_type_variation_; + } + break; + } + case kExtensionFunction: { + if (GetArena() == nullptr) { + delete mapping_type_.extension_function_; + } + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = MAPPING_TYPE_NOT_SET; +} + + +void SimpleExtensionDeclaration::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.SimpleExtensionDeclaration) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - key_.ClearToEmpty(); - value_.ClearToEmpty(); + clear_mapping_type(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Extensions_Mapping_FunctionMapping_Option::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* SimpleExtensionDeclaration::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // string key = 1; + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_key(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Mapping.FunctionMapping.Option.key")); + ptr = ctx->ParseMessage(_internal_mutable_extension_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // string value = 2; + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_value(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Mapping.FunctionMapping.Option.value")); + ptr = ctx->ParseMessage(_internal_mutable_extension_type_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_function(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1470,62 +1448,78 @@ const char* Extensions_Mapping_FunctionMapping_Option::_InternalParse(const char #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Mapping_FunctionMapping_Option::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.SimpleExtensionDeclaration) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string key = 1; - if (this->key().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_key().data(), static_cast(this->_internal_key().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Extensions.Mapping.FunctionMapping.Option.key"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_key(), target); + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; + if (_internal_has_extension_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::extension_type(this), target, stream); } - // string value = 2; - if (this->value().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_value().data(), static_cast(this->_internal_value().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Extensions.Mapping.FunctionMapping.Option.value"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_value(), target); + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; + if (_internal_has_extension_type_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::extension_type_variation(this), target, stream); + } + + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; + if (_internal_has_extension_function()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::extension_function(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Mapping.FunctionMapping.Option) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.SimpleExtensionDeclaration) return target; } -size_t Extensions_Mapping_FunctionMapping_Option::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) +size_t SimpleExtensionDeclaration::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.SimpleExtensionDeclaration) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string key = 1; - if (this->key().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_key()); - } - - // string value = 2; - if (this->value().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_value()); + switch (mapping_type_case()) { + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; + case kExtensionType: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mapping_type_.extension_type_); + break; + } + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; + case kExtensionTypeVariation: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mapping_type_.extension_type_variation_); + break; + } + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; + case kExtensionFunction: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mapping_type_.extension_function_); + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -1535,62 +1529,73 @@ size_t Extensions_Mapping_FunctionMapping_Option::ByteSizeLong() const { return total_size; } -void Extensions_Mapping_FunctionMapping_Option::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) +void SimpleExtensionDeclaration::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration) GOOGLE_DCHECK_NE(&from, this); - const Extensions_Mapping_FunctionMapping_Option* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const SimpleExtensionDeclaration* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Mapping.FunctionMapping.Option) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.SimpleExtensionDeclaration) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Mapping.FunctionMapping.Option) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.SimpleExtensionDeclaration) MergeFrom(*source); } } -void Extensions_Mapping_FunctionMapping_Option::MergeFrom(const Extensions_Mapping_FunctionMapping_Option& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) +void SimpleExtensionDeclaration::MergeFrom(const SimpleExtensionDeclaration& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.key().size() > 0) { - _internal_set_key(from._internal_key()); - } - if (from.value().size() > 0) { - _internal_set_value(from._internal_value()); + switch (from.mapping_type_case()) { + case kExtensionType: { + _internal_mutable_extension_type()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType::MergeFrom(from._internal_extension_type()); + break; + } + case kExtensionTypeVariation: { + _internal_mutable_extension_type_variation()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(from._internal_extension_type_variation()); + break; + } + case kExtensionFunction: { + _internal_mutable_extension_function()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(from._internal_extension_function()); + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } } } -void Extensions_Mapping_FunctionMapping_Option::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) +void SimpleExtensionDeclaration::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration) if (&from == this) return; Clear(); MergeFrom(from); } -void Extensions_Mapping_FunctionMapping_Option::CopyFrom(const Extensions_Mapping_FunctionMapping_Option& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Mapping.FunctionMapping.Option) +void SimpleExtensionDeclaration::CopyFrom(const SimpleExtensionDeclaration& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration) if (&from == this) return; Clear(); MergeFrom(from); } -bool Extensions_Mapping_FunctionMapping_Option::IsInitialized() const { +bool SimpleExtensionDeclaration::IsInitialized() const { return true; } -void Extensions_Mapping_FunctionMapping_Option::InternalSwap(Extensions_Mapping_FunctionMapping_Option* other) { +void SimpleExtensionDeclaration::InternalSwap(SimpleExtensionDeclaration* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(mapping_type_, other->mapping_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); } -::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Mapping_FunctionMapping_Option::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, file_level_metadata_extensions_2eproto[4]); @@ -1598,140 +1603,120 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Mapping_FunctionMapping_Option::Get // =================================================================== -class Extensions_Mapping_FunctionMapping::_Internal { +class AdvancedExtension::_Internal { public: - static const ::io::substrait::Extensions_FunctionId& function_id(const Extensions_Mapping_FunctionMapping* msg); - static const ::io::substrait::Extensions_ExtensionId& extension_id(const Extensions_Mapping_FunctionMapping* msg); + static const PROTOBUF_NAMESPACE_ID::Any& optimization(const AdvancedExtension* msg); + static const PROTOBUF_NAMESPACE_ID::Any& enhancement(const AdvancedExtension* msg); }; -const ::io::substrait::Extensions_FunctionId& -Extensions_Mapping_FunctionMapping::_Internal::function_id(const Extensions_Mapping_FunctionMapping* msg) { - return *msg->function_id_; +const PROTOBUF_NAMESPACE_ID::Any& +AdvancedExtension::_Internal::optimization(const AdvancedExtension* msg) { + return *msg->optimization_; +} +const PROTOBUF_NAMESPACE_ID::Any& +AdvancedExtension::_Internal::enhancement(const AdvancedExtension* msg) { + return *msg->enhancement_; } -const ::io::substrait::Extensions_ExtensionId& -Extensions_Mapping_FunctionMapping::_Internal::extension_id(const Extensions_Mapping_FunctionMapping* msg) { - return *msg->extension_id_; +void AdvancedExtension::clear_optimization() { + if (GetArena() == nullptr && optimization_ != nullptr) { + delete optimization_; + } + optimization_ = nullptr; +} +void AdvancedExtension::clear_enhancement() { + if (GetArena() == nullptr && enhancement_ != nullptr) { + delete enhancement_; + } + enhancement_ = nullptr; } -Extensions_Mapping_FunctionMapping::Extensions_Mapping_FunctionMapping(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - options_(arena) { +AdvancedExtension::AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Mapping.FunctionMapping) + // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.AdvancedExtension) } -Extensions_Mapping_FunctionMapping::Extensions_Mapping_FunctionMapping(const Extensions_Mapping_FunctionMapping& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - options_(from.options_) { +AdvancedExtension::AdvancedExtension(const AdvancedExtension& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); - } - if (from._internal_has_function_id()) { - function_id_ = new ::io::substrait::Extensions_FunctionId(*from.function_id_); + if (from._internal_has_optimization()) { + optimization_ = new PROTOBUF_NAMESPACE_ID::Any(*from.optimization_); } else { - function_id_ = nullptr; + optimization_ = nullptr; } - if (from._internal_has_extension_id()) { - extension_id_ = new ::io::substrait::Extensions_ExtensionId(*from.extension_id_); + if (from._internal_has_enhancement()) { + enhancement_ = new PROTOBUF_NAMESPACE_ID::Any(*from.enhancement_); } else { - extension_id_ = nullptr; + enhancement_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Mapping.FunctionMapping) + // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.AdvancedExtension) } -void Extensions_Mapping_FunctionMapping::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void AdvancedExtension::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&function_id_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&extension_id_) - - reinterpret_cast(&function_id_)) + sizeof(extension_id_)); + reinterpret_cast(&optimization_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&enhancement_) - + reinterpret_cast(&optimization_)) + sizeof(enhancement_)); } -Extensions_Mapping_FunctionMapping::~Extensions_Mapping_FunctionMapping() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions.Mapping.FunctionMapping) +AdvancedExtension::~AdvancedExtension() { + // @@protoc_insertion_point(destructor:io.substrait.extensions.AdvancedExtension) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Extensions_Mapping_FunctionMapping::SharedDtor() { +void AdvancedExtension::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (this != internal_default_instance()) delete function_id_; - if (this != internal_default_instance()) delete extension_id_; + if (this != internal_default_instance()) delete optimization_; + if (this != internal_default_instance()) delete enhancement_; } -void Extensions_Mapping_FunctionMapping::ArenaDtor(void* object) { - Extensions_Mapping_FunctionMapping* _this = reinterpret_cast< Extensions_Mapping_FunctionMapping* >(object); +void AdvancedExtension::ArenaDtor(void* object) { + AdvancedExtension* _this = reinterpret_cast< AdvancedExtension* >(object); (void)_this; } -void Extensions_Mapping_FunctionMapping::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void AdvancedExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void Extensions_Mapping_FunctionMapping::SetCachedSize(int size) const { +void AdvancedExtension::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Extensions_Mapping_FunctionMapping::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Mapping.FunctionMapping) +void AdvancedExtension::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.AdvancedExtension) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - options_.Clear(); - name_.ClearToEmpty(); - if (GetArena() == nullptr && function_id_ != nullptr) { - delete function_id_; + if (GetArena() == nullptr && optimization_ != nullptr) { + delete optimization_; } - function_id_ = nullptr; - if (GetArena() == nullptr && extension_id_ != nullptr) { - delete extension_id_; + optimization_ = nullptr; + if (GetArena() == nullptr && enhancement_ != nullptr) { + delete enhancement_; } - extension_id_ = nullptr; + enhancement_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* Extensions_Mapping_FunctionMapping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* AdvancedExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Extensions.FunctionId function_id = 1; + // .google.protobuf.Any optimization = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_function_id(), ptr); + ptr = ctx->ParseMessage(_internal_mutable_optimization(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Extensions.ExtensionId extension_id = 2; + // .google.protobuf.Any enhancement = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_id(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Extensions.Mapping.FunctionMapping.name")); + ptr = ctx->ParseMessage(_internal_mutable_enhancement(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Extensions.Mapping.FunctionMapping.Option options = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_options(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); - } else goto handle_unusual; - continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -1755,88 +1740,56 @@ const char* Extensions_Mapping_FunctionMapping::_InternalParse(const char* ptr, #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Mapping_FunctionMapping::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* AdvancedExtension::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Mapping.FunctionMapping) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.AdvancedExtension) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Extensions.FunctionId function_id = 1; - if (this->has_function_id()) { + // .google.protobuf.Any optimization = 1; + if (this->has_optimization()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 1, _Internal::function_id(this), target, stream); + 1, _Internal::optimization(this), target, stream); } - // .io.substrait.Extensions.ExtensionId extension_id = 2; - if (this->has_extension_id()) { + // .google.protobuf.Any enhancement = 2; + if (this->has_enhancement()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 2, _Internal::extension_id(this), target, stream); - } - - // string name = 3; - if (this->name().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Extensions.Mapping.FunctionMapping.name"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_name(), target); - } - - // repeated .io.substrait.Extensions.Mapping.FunctionMapping.Option options = 5; - for (unsigned int i = 0, - n = static_cast(this->_internal_options_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(5, this->_internal_options(i), target, stream); + 2, _Internal::enhancement(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Mapping.FunctionMapping) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.AdvancedExtension) return target; } -size_t Extensions_Mapping_FunctionMapping::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Mapping.FunctionMapping) +size_t AdvancedExtension::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.AdvancedExtension) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Extensions.Mapping.FunctionMapping.Option options = 5; - total_size += 1UL * this->_internal_options_size(); - for (const auto& msg : this->options_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // string name = 3; - if (this->name().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // .io.substrait.Extensions.FunctionId function_id = 1; - if (this->has_function_id()) { + // .google.protobuf.Any optimization = 1; + if (this->has_optimization()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *function_id_); + *optimization_); } - // .io.substrait.Extensions.ExtensionId extension_id = 2; - if (this->has_extension_id()) { + // .google.protobuf.Any enhancement = 2; + if (this->has_enhancement()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *extension_id_); + *enhancement_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1848,1150 +1801,93 @@ size_t Extensions_Mapping_FunctionMapping::ByteSizeLong() const { return total_size; } -void Extensions_Mapping_FunctionMapping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Mapping.FunctionMapping) +void AdvancedExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.AdvancedExtension) GOOGLE_DCHECK_NE(&from, this); - const Extensions_Mapping_FunctionMapping* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const AdvancedExtension* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Mapping.FunctionMapping) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.AdvancedExtension) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Mapping.FunctionMapping) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.AdvancedExtension) MergeFrom(*source); } } -void Extensions_Mapping_FunctionMapping::MergeFrom(const Extensions_Mapping_FunctionMapping& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Mapping.FunctionMapping) +void AdvancedExtension::MergeFrom(const AdvancedExtension& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.AdvancedExtension) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - options_.MergeFrom(from.options_); - if (from.name().size() > 0) { - _internal_set_name(from._internal_name()); - } - if (from.has_function_id()) { - _internal_mutable_function_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_function_id()); + if (from.has_optimization()) { + _internal_mutable_optimization()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_optimization()); } - if (from.has_extension_id()) { - _internal_mutable_extension_id()->::io::substrait::Extensions_ExtensionId::MergeFrom(from._internal_extension_id()); + if (from.has_enhancement()) { + _internal_mutable_enhancement()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_enhancement()); } } -void Extensions_Mapping_FunctionMapping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Mapping.FunctionMapping) +void AdvancedExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.AdvancedExtension) if (&from == this) return; Clear(); MergeFrom(from); } -void Extensions_Mapping_FunctionMapping::CopyFrom(const Extensions_Mapping_FunctionMapping& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Mapping.FunctionMapping) +void AdvancedExtension::CopyFrom(const AdvancedExtension& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.AdvancedExtension) if (&from == this) return; Clear(); MergeFrom(from); } -bool Extensions_Mapping_FunctionMapping::IsInitialized() const { +bool AdvancedExtension::IsInitialized() const { return true; } -void Extensions_Mapping_FunctionMapping::InternalSwap(Extensions_Mapping_FunctionMapping* other) { +void AdvancedExtension::InternalSwap(AdvancedExtension* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - options_.InternalSwap(&other->options_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Extensions_Mapping_FunctionMapping, extension_id_) - + sizeof(Extensions_Mapping_FunctionMapping::extension_id_) - - PROTOBUF_FIELD_OFFSET(Extensions_Mapping_FunctionMapping, function_id_)>( - reinterpret_cast(&function_id_), - reinterpret_cast(&other->function_id_)); + PROTOBUF_FIELD_OFFSET(AdvancedExtension, enhancement_) + + sizeof(AdvancedExtension::enhancement_) + - PROTOBUF_FIELD_OFFSET(AdvancedExtension, optimization_)>( + reinterpret_cast(&optimization_), + reinterpret_cast(&other->optimization_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Mapping_FunctionMapping::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata AdvancedExtension::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, file_level_metadata_extensions_2eproto[5]); } -// =================================================================== - -class Extensions_Mapping::_Internal { - public: - static const ::io::substrait::Extensions_Mapping_TypeMapping& type_mapping(const Extensions_Mapping* msg); - static const ::io::substrait::Extensions_Mapping_FunctionMapping& function_mapping(const Extensions_Mapping* msg); -}; - -const ::io::substrait::Extensions_Mapping_TypeMapping& -Extensions_Mapping::_Internal::type_mapping(const Extensions_Mapping* msg) { - return *msg->mapping_type_.type_mapping_; -} -const ::io::substrait::Extensions_Mapping_FunctionMapping& -Extensions_Mapping::_Internal::function_mapping(const Extensions_Mapping* msg) { - return *msg->mapping_type_.function_mapping_; -} -void Extensions_Mapping::set_allocated_type_mapping(::io::substrait::Extensions_Mapping_TypeMapping* type_mapping) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_mapping_type(); - if (type_mapping) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_mapping); - if (message_arena != submessage_arena) { - type_mapping = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type_mapping, submessage_arena); - } - set_has_type_mapping(); - mapping_type_.type_mapping_ = type_mapping; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.type_mapping) -} -void Extensions_Mapping::set_allocated_function_mapping(::io::substrait::Extensions_Mapping_FunctionMapping* function_mapping) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_mapping_type(); - if (function_mapping) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(function_mapping); - if (message_arena != submessage_arena) { - function_mapping = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, function_mapping, submessage_arena); - } - set_has_function_mapping(); - mapping_type_.function_mapping_ = function_mapping; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.function_mapping) -} -Extensions_Mapping::Extensions_Mapping(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.Mapping) -} -Extensions_Mapping::Extensions_Mapping(const Extensions_Mapping& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_mapping_type(); - switch (from.mapping_type_case()) { - case kTypeMapping: { - _internal_mutable_type_mapping()->::io::substrait::Extensions_Mapping_TypeMapping::MergeFrom(from._internal_type_mapping()); - break; - } - case kFunctionMapping: { - _internal_mutable_function_mapping()->::io::substrait::Extensions_Mapping_FunctionMapping::MergeFrom(from._internal_function_mapping()); - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.Mapping) -} - -void Extensions_Mapping::SharedCtor() { -clear_has_mapping_type(); -} - -Extensions_Mapping::~Extensions_Mapping() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions.Mapping) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Extensions_Mapping::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (has_mapping_type()) { - clear_mapping_type(); - } -} - -void Extensions_Mapping::ArenaDtor(void* object) { - Extensions_Mapping* _this = reinterpret_cast< Extensions_Mapping* >(object); - (void)_this; -} -void Extensions_Mapping::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Extensions_Mapping::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Extensions_Mapping::clear_mapping_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Extensions.Mapping) - switch (mapping_type_case()) { - case kTypeMapping: { - if (GetArena() == nullptr) { - delete mapping_type_.type_mapping_; - } - break; - } - case kFunctionMapping: { - if (GetArena() == nullptr) { - delete mapping_type_.function_mapping_; - } - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = MAPPING_TYPE_NOT_SET; -} - - -void Extensions_Mapping::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.Mapping) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_mapping_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Extensions_Mapping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .io.substrait.Extensions.Mapping.TypeMapping type_mapping = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_type_mapping(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Extensions.Mapping.FunctionMapping function_mapping = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_function_mapping(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Extensions_Mapping::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.Mapping) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .io.substrait.Extensions.Mapping.TypeMapping type_mapping = 1; - if (_internal_has_type_mapping()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::type_mapping(this), target, stream); - } - - // .io.substrait.Extensions.Mapping.FunctionMapping function_mapping = 2; - if (_internal_has_function_mapping()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::function_mapping(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.Mapping) - return target; -} - -size_t Extensions_Mapping::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.Mapping) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (mapping_type_case()) { - // .io.substrait.Extensions.Mapping.TypeMapping type_mapping = 1; - case kTypeMapping: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *mapping_type_.type_mapping_); - break; - } - // .io.substrait.Extensions.Mapping.FunctionMapping function_mapping = 2; - case kFunctionMapping: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *mapping_type_.function_mapping_); - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void Extensions_Mapping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.Mapping) - GOOGLE_DCHECK_NE(&from, this); - const Extensions_Mapping* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.Mapping) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.Mapping) - MergeFrom(*source); - } -} - -void Extensions_Mapping::MergeFrom(const Extensions_Mapping& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.Mapping) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.mapping_type_case()) { - case kTypeMapping: { - _internal_mutable_type_mapping()->::io::substrait::Extensions_Mapping_TypeMapping::MergeFrom(from._internal_type_mapping()); - break; - } - case kFunctionMapping: { - _internal_mutable_function_mapping()->::io::substrait::Extensions_Mapping_FunctionMapping::MergeFrom(from._internal_function_mapping()); - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } -} - -void Extensions_Mapping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.Mapping) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Extensions_Mapping::CopyFrom(const Extensions_Mapping& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.Mapping) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Extensions_Mapping::IsInitialized() const { - return true; -} - -void Extensions_Mapping::InternalSwap(Extensions_Mapping* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(mapping_type_, other->mapping_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Extensions_Mapping::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[6]); -} - -// =================================================================== - -class Extensions_ExtensionId::_Internal { - public: -}; - -Extensions_ExtensionId::Extensions_ExtensionId(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.ExtensionId) -} -Extensions_ExtensionId::Extensions_ExtensionId(const Extensions_ExtensionId& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - id_ = from.id_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.ExtensionId) -} - -void Extensions_ExtensionId::SharedCtor() { -id_ = 0u; -} - -Extensions_ExtensionId::~Extensions_ExtensionId() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions.ExtensionId) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Extensions_ExtensionId::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void Extensions_ExtensionId::ArenaDtor(void* object) { - Extensions_ExtensionId* _this = reinterpret_cast< Extensions_ExtensionId* >(object); - (void)_this; -} -void Extensions_ExtensionId::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Extensions_ExtensionId::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Extensions_ExtensionId::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.ExtensionId) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - id_ = 0u; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Extensions_ExtensionId::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Extensions_ExtensionId::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.ExtensionId) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 id = 1; - if (this->id() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.ExtensionId) - return target; -} - -size_t Extensions_ExtensionId::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.ExtensionId) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 id = 1; - if (this->id() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_id()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void Extensions_ExtensionId::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.ExtensionId) - GOOGLE_DCHECK_NE(&from, this); - const Extensions_ExtensionId* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.ExtensionId) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.ExtensionId) - MergeFrom(*source); - } -} - -void Extensions_ExtensionId::MergeFrom(const Extensions_ExtensionId& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.ExtensionId) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.id() != 0) { - _internal_set_id(from._internal_id()); - } -} - -void Extensions_ExtensionId::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.ExtensionId) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Extensions_ExtensionId::CopyFrom(const Extensions_ExtensionId& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.ExtensionId) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Extensions_ExtensionId::IsInitialized() const { - return true; -} - -void Extensions_ExtensionId::InternalSwap(Extensions_ExtensionId* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(id_, other->id_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Extensions_ExtensionId::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[7]); -} - -// =================================================================== - -class Extensions_FunctionId::_Internal { - public: -}; - -Extensions_FunctionId::Extensions_FunctionId(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.FunctionId) -} -Extensions_FunctionId::Extensions_FunctionId(const Extensions_FunctionId& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - id_ = from.id_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.FunctionId) -} - -void Extensions_FunctionId::SharedCtor() { -id_ = PROTOBUF_ULONGLONG(0); -} - -Extensions_FunctionId::~Extensions_FunctionId() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions.FunctionId) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Extensions_FunctionId::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void Extensions_FunctionId::ArenaDtor(void* object) { - Extensions_FunctionId* _this = reinterpret_cast< Extensions_FunctionId* >(object); - (void)_this; -} -void Extensions_FunctionId::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Extensions_FunctionId::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Extensions_FunctionId::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.FunctionId) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - id_ = PROTOBUF_ULONGLONG(0); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Extensions_FunctionId::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint64 id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Extensions_FunctionId::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.FunctionId) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint64 id = 1; - if (this->id() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.FunctionId) - return target; -} - -size_t Extensions_FunctionId::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.FunctionId) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint64 id = 1; - if (this->id() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( - this->_internal_id()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void Extensions_FunctionId::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.FunctionId) - GOOGLE_DCHECK_NE(&from, this); - const Extensions_FunctionId* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.FunctionId) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.FunctionId) - MergeFrom(*source); - } -} - -void Extensions_FunctionId::MergeFrom(const Extensions_FunctionId& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.FunctionId) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.id() != 0) { - _internal_set_id(from._internal_id()); - } -} - -void Extensions_FunctionId::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.FunctionId) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Extensions_FunctionId::CopyFrom(const Extensions_FunctionId& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.FunctionId) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Extensions_FunctionId::IsInitialized() const { - return true; -} - -void Extensions_FunctionId::InternalSwap(Extensions_FunctionId* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(id_, other->id_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Extensions_FunctionId::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[8]); -} - -// =================================================================== - -class Extensions_TypeId::_Internal { - public: -}; - -Extensions_TypeId::Extensions_TypeId(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions.TypeId) -} -Extensions_TypeId::Extensions_TypeId(const Extensions_TypeId& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - id_ = from.id_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions.TypeId) -} - -void Extensions_TypeId::SharedCtor() { -id_ = PROTOBUF_ULONGLONG(0); -} - -Extensions_TypeId::~Extensions_TypeId() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions.TypeId) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Extensions_TypeId::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void Extensions_TypeId::ArenaDtor(void* object) { - Extensions_TypeId* _this = reinterpret_cast< Extensions_TypeId* >(object); - (void)_this; -} -void Extensions_TypeId::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Extensions_TypeId::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Extensions_TypeId::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions.TypeId) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - id_ = PROTOBUF_ULONGLONG(0); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Extensions_TypeId::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint64 id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Extensions_TypeId::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions.TypeId) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint64 id = 1; - if (this->id() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions.TypeId) - return target; -} - -size_t Extensions_TypeId::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions.TypeId) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint64 id = 1; - if (this->id() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( - this->_internal_id()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void Extensions_TypeId::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions.TypeId) - GOOGLE_DCHECK_NE(&from, this); - const Extensions_TypeId* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions.TypeId) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions.TypeId) - MergeFrom(*source); - } -} - -void Extensions_TypeId::MergeFrom(const Extensions_TypeId& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions.TypeId) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.id() != 0) { - _internal_set_id(from._internal_id()); - } -} - -void Extensions_TypeId::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions.TypeId) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Extensions_TypeId::CopyFrom(const Extensions_TypeId& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions.TypeId) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Extensions_TypeId::IsInitialized() const { - return true; -} - -void Extensions_TypeId::InternalSwap(Extensions_TypeId* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(id_, other->id_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Extensions_TypeId::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[9]); -} - -// =================================================================== - -class Extensions::_Internal { - public: -}; - -Extensions::Extensions(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Extensions) -} -Extensions::Extensions(const Extensions& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Extensions) -} - -void Extensions::SharedCtor() { -} - -Extensions::~Extensions() { - // @@protoc_insertion_point(destructor:io.substrait.Extensions) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Extensions::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void Extensions::ArenaDtor(void* object) { - Extensions* _this = reinterpret_cast< Extensions* >(object); - (void)_this; -} -void Extensions::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Extensions::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Extensions::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Extensions) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Extensions::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Extensions::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Extensions) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Extensions) - return target; -} - -size_t Extensions::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Extensions) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void Extensions::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Extensions) - GOOGLE_DCHECK_NE(&from, this); - const Extensions* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Extensions) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Extensions) - MergeFrom(*source); - } -} - -void Extensions::MergeFrom(const Extensions& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Extensions) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - -} - -void Extensions::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Extensions) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Extensions::CopyFrom(const Extensions& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Extensions) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Extensions::IsInitialized() const { - return true; -} - -void Extensions::InternalSwap(Extensions* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Extensions::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[10]); -} - // @@protoc_insertion_point(namespace_scope) +} // namespace extensions } // namespace substrait } // namespace io PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Extension_TypeExtension* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Extension_TypeExtension >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions_Extension_TypeExtension >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Extension_FunctionExtension* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Extension_FunctionExtension >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions_Extension_FunctionExtension >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Extension* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Extension >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions_Extension >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Mapping_TypeMapping* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Mapping_TypeMapping >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions_Mapping_TypeMapping >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Mapping_FunctionMapping_Option* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Mapping_FunctionMapping* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Mapping_FunctionMapping >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions_Mapping_FunctionMapping >(arena); +template<> PROTOBUF_NOINLINE ::io::substrait::extensions::SimpleExtensionURI* Arena::CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionURI >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::extensions::SimpleExtensionURI >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_Mapping* Arena::CreateMaybeMessage< ::io::substrait::Extensions_Mapping >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions_Mapping >(arena); +template<> PROTOBUF_NOINLINE ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Arena::CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_ExtensionId* Arena::CreateMaybeMessage< ::io::substrait::Extensions_ExtensionId >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions_ExtensionId >(arena); +template<> PROTOBUF_NOINLINE ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* Arena::CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_FunctionId* Arena::CreateMaybeMessage< ::io::substrait::Extensions_FunctionId >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions_FunctionId >(arena); +template<> PROTOBUF_NOINLINE ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Arena::CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions_TypeId* Arena::CreateMaybeMessage< ::io::substrait::Extensions_TypeId >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions_TypeId >(arena); +template<> PROTOBUF_NOINLINE ::io::substrait::extensions::SimpleExtensionDeclaration* Arena::CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::extensions::SimpleExtensionDeclaration >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Extensions* Arena::CreateMaybeMessage< ::io::substrait::Extensions >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Extensions >(arena); +template<> PROTOBUF_NOINLINE ::io::substrait::extensions::AdvancedExtension* Arena::CreateMaybeMessage< ::io::substrait::extensions::AdvancedExtension >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::extensions::AdvancedExtension >(arena); } PROTOBUF_NAMESPACE_CLOSE diff --git a/cpp/src/generated/substrait/extensions.pb.h b/cpp/src/generated/substrait/extensions.pb.h index 6fa99bc7d29..977bfa80603 100644 --- a/cpp/src/generated/substrait/extensions.pb.h +++ b/cpp/src/generated/substrait/extensions.pb.h @@ -31,6 +31,7 @@ #include // IWYU pragma: export #include // IWYU pragma: export #include +#include // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_extensions_2eproto @@ -46,7 +47,7 @@ struct TableStruct_extensions_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[11] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -55,77 +56,60 @@ struct TableStruct_extensions_2eproto { extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_extensions_2eproto; namespace io { namespace substrait { -class Extensions; -struct ExtensionsDefaultTypeInternal; -extern ExtensionsDefaultTypeInternal _Extensions_default_instance_; -class Extensions_Extension; -struct Extensions_ExtensionDefaultTypeInternal; -extern Extensions_ExtensionDefaultTypeInternal _Extensions_Extension_default_instance_; -class Extensions_ExtensionId; -struct Extensions_ExtensionIdDefaultTypeInternal; -extern Extensions_ExtensionIdDefaultTypeInternal _Extensions_ExtensionId_default_instance_; -class Extensions_Extension_FunctionExtension; -struct Extensions_Extension_FunctionExtensionDefaultTypeInternal; -extern Extensions_Extension_FunctionExtensionDefaultTypeInternal _Extensions_Extension_FunctionExtension_default_instance_; -class Extensions_Extension_TypeExtension; -struct Extensions_Extension_TypeExtensionDefaultTypeInternal; -extern Extensions_Extension_TypeExtensionDefaultTypeInternal _Extensions_Extension_TypeExtension_default_instance_; -class Extensions_FunctionId; -struct Extensions_FunctionIdDefaultTypeInternal; -extern Extensions_FunctionIdDefaultTypeInternal _Extensions_FunctionId_default_instance_; -class Extensions_Mapping; -struct Extensions_MappingDefaultTypeInternal; -extern Extensions_MappingDefaultTypeInternal _Extensions_Mapping_default_instance_; -class Extensions_Mapping_FunctionMapping; -struct Extensions_Mapping_FunctionMappingDefaultTypeInternal; -extern Extensions_Mapping_FunctionMappingDefaultTypeInternal _Extensions_Mapping_FunctionMapping_default_instance_; -class Extensions_Mapping_FunctionMapping_Option; -struct Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal; -extern Extensions_Mapping_FunctionMapping_OptionDefaultTypeInternal _Extensions_Mapping_FunctionMapping_Option_default_instance_; -class Extensions_Mapping_TypeMapping; -struct Extensions_Mapping_TypeMappingDefaultTypeInternal; -extern Extensions_Mapping_TypeMappingDefaultTypeInternal _Extensions_Mapping_TypeMapping_default_instance_; -class Extensions_TypeId; -struct Extensions_TypeIdDefaultTypeInternal; -extern Extensions_TypeIdDefaultTypeInternal _Extensions_TypeId_default_instance_; +namespace extensions { +class AdvancedExtension; +struct AdvancedExtensionDefaultTypeInternal; +extern AdvancedExtensionDefaultTypeInternal _AdvancedExtension_default_instance_; +class SimpleExtensionDeclaration; +struct SimpleExtensionDeclarationDefaultTypeInternal; +extern SimpleExtensionDeclarationDefaultTypeInternal _SimpleExtensionDeclaration_default_instance_; +class SimpleExtensionDeclaration_ExtensionFunction; +struct SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal; +extern SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionFunction_default_instance_; +class SimpleExtensionDeclaration_ExtensionType; +struct SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal; +extern SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionType_default_instance_; +class SimpleExtensionDeclaration_ExtensionTypeVariation; +struct SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal; +extern SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_; +class SimpleExtensionURI; +struct SimpleExtensionURIDefaultTypeInternal; +extern SimpleExtensionURIDefaultTypeInternal _SimpleExtensionURI_default_instance_; +} // namespace extensions } // namespace substrait } // namespace io PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::Extensions* Arena::CreateMaybeMessage<::io::substrait::Extensions>(Arena*); -template<> ::io::substrait::Extensions_Extension* Arena::CreateMaybeMessage<::io::substrait::Extensions_Extension>(Arena*); -template<> ::io::substrait::Extensions_ExtensionId* Arena::CreateMaybeMessage<::io::substrait::Extensions_ExtensionId>(Arena*); -template<> ::io::substrait::Extensions_Extension_FunctionExtension* Arena::CreateMaybeMessage<::io::substrait::Extensions_Extension_FunctionExtension>(Arena*); -template<> ::io::substrait::Extensions_Extension_TypeExtension* Arena::CreateMaybeMessage<::io::substrait::Extensions_Extension_TypeExtension>(Arena*); -template<> ::io::substrait::Extensions_FunctionId* Arena::CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(Arena*); -template<> ::io::substrait::Extensions_Mapping* Arena::CreateMaybeMessage<::io::substrait::Extensions_Mapping>(Arena*); -template<> ::io::substrait::Extensions_Mapping_FunctionMapping* Arena::CreateMaybeMessage<::io::substrait::Extensions_Mapping_FunctionMapping>(Arena*); -template<> ::io::substrait::Extensions_Mapping_FunctionMapping_Option* Arena::CreateMaybeMessage<::io::substrait::Extensions_Mapping_FunctionMapping_Option>(Arena*); -template<> ::io::substrait::Extensions_Mapping_TypeMapping* Arena::CreateMaybeMessage<::io::substrait::Extensions_Mapping_TypeMapping>(Arena*); -template<> ::io::substrait::Extensions_TypeId* Arena::CreateMaybeMessage<::io::substrait::Extensions_TypeId>(Arena*); +template<> ::io::substrait::extensions::AdvancedExtension* Arena::CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(Arena*); +template<> ::io::substrait::extensions::SimpleExtensionDeclaration* Arena::CreateMaybeMessage<::io::substrait::extensions::SimpleExtensionDeclaration>(Arena*); +template<> ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Arena::CreateMaybeMessage<::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction>(Arena*); +template<> ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Arena::CreateMaybeMessage<::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType>(Arena*); +template<> ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* Arena::CreateMaybeMessage<::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation>(Arena*); +template<> ::io::substrait::extensions::SimpleExtensionURI* Arena::CreateMaybeMessage<::io::substrait::extensions::SimpleExtensionURI>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace io { namespace substrait { +namespace extensions { // =================================================================== -class Extensions_Extension_TypeExtension PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Extension.TypeExtension) */ { +class SimpleExtensionURI PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.SimpleExtensionURI) */ { public: - inline Extensions_Extension_TypeExtension() : Extensions_Extension_TypeExtension(nullptr) {} - ~Extensions_Extension_TypeExtension() override; - explicit constexpr Extensions_Extension_TypeExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline SimpleExtensionURI() : SimpleExtensionURI(nullptr) {} + ~SimpleExtensionURI() override; + explicit constexpr SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Extensions_Extension_TypeExtension(const Extensions_Extension_TypeExtension& from); - Extensions_Extension_TypeExtension(Extensions_Extension_TypeExtension&& from) noexcept - : Extensions_Extension_TypeExtension() { + SimpleExtensionURI(const SimpleExtensionURI& from); + SimpleExtensionURI(SimpleExtensionURI&& from) noexcept + : SimpleExtensionURI() { *this = ::std::move(from); } - inline Extensions_Extension_TypeExtension& operator=(const Extensions_Extension_TypeExtension& from) { + inline SimpleExtensionURI& operator=(const SimpleExtensionURI& from) { CopyFrom(from); return *this; } - inline Extensions_Extension_TypeExtension& operator=(Extensions_Extension_TypeExtension&& from) noexcept { + inline SimpleExtensionURI& operator=(SimpleExtensionURI&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -143,20 +127,20 @@ class Extensions_Extension_TypeExtension PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Extensions_Extension_TypeExtension& default_instance() { + static const SimpleExtensionURI& default_instance() { return *internal_default_instance(); } - static inline const Extensions_Extension_TypeExtension* internal_default_instance() { - return reinterpret_cast( - &_Extensions_Extension_TypeExtension_default_instance_); + static inline const SimpleExtensionURI* internal_default_instance() { + return reinterpret_cast( + &_SimpleExtensionURI_default_instance_); } static constexpr int kIndexInFileMessages = 0; - friend void swap(Extensions_Extension_TypeExtension& a, Extensions_Extension_TypeExtension& b) { + friend void swap(SimpleExtensionURI& a, SimpleExtensionURI& b) { a.Swap(&b); } - inline void Swap(Extensions_Extension_TypeExtension* other) { + inline void Swap(SimpleExtensionURI* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -164,7 +148,7 @@ class Extensions_Extension_TypeExtension PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Extensions_Extension_TypeExtension* other) { + void UnsafeArenaSwap(SimpleExtensionURI* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -172,17 +156,17 @@ class Extensions_Extension_TypeExtension PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Extensions_Extension_TypeExtension* New() const final { - return CreateMaybeMessage(nullptr); + inline SimpleExtensionURI* New() const final { + return CreateMaybeMessage(nullptr); } - Extensions_Extension_TypeExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + SimpleExtensionURI* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions_Extension_TypeExtension& from); - void MergeFrom(const Extensions_Extension_TypeExtension& from); + void CopyFrom(const SimpleExtensionURI& from); + void MergeFrom(const SimpleExtensionURI& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -196,13 +180,13 @@ class Extensions_Extension_TypeExtension PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Extensions_Extension_TypeExtension* other); + void InternalSwap(SimpleExtensionURI* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions.Extension.TypeExtension"; + return "io.substrait.extensions.SimpleExtensionURI"; } protected: - explicit Extensions_Extension_TypeExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -215,189 +199,64 @@ class Extensions_Extension_TypeExtension PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kGitUriFieldNumber = 1, + kUriFieldNumber = 2, + kExtensionUriAnchorFieldNumber = 1, }; - // string git_uri = 1; - void clear_git_uri(); - const std::string& git_uri() const; + // string uri = 2; + void clear_uri(); + const std::string& uri() const; template - void set_git_uri(ArgT0&& arg0, ArgT... args); - std::string* mutable_git_uri(); - std::string* release_git_uri(); - void set_allocated_git_uri(std::string* git_uri); + void set_uri(ArgT0&& arg0, ArgT... args); + std::string* mutable_uri(); + std::string* release_uri(); + void set_allocated_uri(std::string* uri); private: - const std::string& _internal_git_uri() const; - void _internal_set_git_uri(const std::string& value); - std::string* _internal_mutable_git_uri(); + const std::string& _internal_uri() const; + void _internal_set_uri(const std::string& value); + std::string* _internal_mutable_uri(); public: - // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Extension.TypeExtension) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr git_uri_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_extensions_2eproto; -}; -// ------------------------------------------------------------------- - -class Extensions_Extension_FunctionExtension PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Extension.FunctionExtension) */ { - public: - inline Extensions_Extension_FunctionExtension() : Extensions_Extension_FunctionExtension(nullptr) {} - ~Extensions_Extension_FunctionExtension() override; - explicit constexpr Extensions_Extension_FunctionExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Extensions_Extension_FunctionExtension(const Extensions_Extension_FunctionExtension& from); - Extensions_Extension_FunctionExtension(Extensions_Extension_FunctionExtension&& from) noexcept - : Extensions_Extension_FunctionExtension() { - *this = ::std::move(from); - } - - inline Extensions_Extension_FunctionExtension& operator=(const Extensions_Extension_FunctionExtension& from) { - CopyFrom(from); - return *this; - } - inline Extensions_Extension_FunctionExtension& operator=(Extensions_Extension_FunctionExtension&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 Extensions_Extension_FunctionExtension& default_instance() { - return *internal_default_instance(); - } - static inline const Extensions_Extension_FunctionExtension* internal_default_instance() { - return reinterpret_cast( - &_Extensions_Extension_FunctionExtension_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(Extensions_Extension_FunctionExtension& a, Extensions_Extension_FunctionExtension& b) { - a.Swap(&b); - } - inline void Swap(Extensions_Extension_FunctionExtension* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Extensions_Extension_FunctionExtension* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline Extensions_Extension_FunctionExtension* New() const final { - return CreateMaybeMessage(nullptr); - } - - Extensions_Extension_FunctionExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions_Extension_FunctionExtension& from); - void MergeFrom(const Extensions_Extension_FunctionExtension& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Extensions_Extension_FunctionExtension* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions.Extension.FunctionExtension"; - } - protected: - explicit Extensions_Extension_FunctionExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); + // uint32 extension_uri_anchor = 1; + void clear_extension_uri_anchor(); + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_anchor() const; + void set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kGitUriFieldNumber = 1, - }; - // string git_uri = 1; - void clear_git_uri(); - const std::string& git_uri() const; - template - void set_git_uri(ArgT0&& arg0, ArgT... args); - std::string* mutable_git_uri(); - std::string* release_git_uri(); - void set_allocated_git_uri(std::string* git_uri); - private: - const std::string& _internal_git_uri() const; - void _internal_set_git_uri(const std::string& value); - std::string* _internal_mutable_git_uri(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_anchor() const; + void _internal_set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Extension.FunctionExtension) + // @@protoc_insertion_point(class_scope:io.substrait.extensions.SimpleExtensionURI) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr git_uri_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_anchor_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_extensions_2eproto; }; // ------------------------------------------------------------------- -class Extensions_Extension PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Extension) */ { +class SimpleExtensionDeclaration_ExtensionType PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) */ { public: - inline Extensions_Extension() : Extensions_Extension(nullptr) {} - ~Extensions_Extension() override; - explicit constexpr Extensions_Extension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline SimpleExtensionDeclaration_ExtensionType() : SimpleExtensionDeclaration_ExtensionType(nullptr) {} + ~SimpleExtensionDeclaration_ExtensionType() override; + explicit constexpr SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Extensions_Extension(const Extensions_Extension& from); - Extensions_Extension(Extensions_Extension&& from) noexcept - : Extensions_Extension() { + SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from); + SimpleExtensionDeclaration_ExtensionType(SimpleExtensionDeclaration_ExtensionType&& from) noexcept + : SimpleExtensionDeclaration_ExtensionType() { *this = ::std::move(from); } - inline Extensions_Extension& operator=(const Extensions_Extension& from) { + inline SimpleExtensionDeclaration_ExtensionType& operator=(const SimpleExtensionDeclaration_ExtensionType& from) { CopyFrom(from); return *this; } - inline Extensions_Extension& operator=(Extensions_Extension&& from) noexcept { + inline SimpleExtensionDeclaration_ExtensionType& operator=(SimpleExtensionDeclaration_ExtensionType&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -415,26 +274,20 @@ class Extensions_Extension PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Extensions_Extension& default_instance() { + static const SimpleExtensionDeclaration_ExtensionType& default_instance() { return *internal_default_instance(); } - enum ExtensionTypeCase { - kTypeExtension = 2, - kFunctionExtension = 3, - EXTENSION_TYPE_NOT_SET = 0, - }; - - static inline const Extensions_Extension* internal_default_instance() { - return reinterpret_cast( - &_Extensions_Extension_default_instance_); + static inline const SimpleExtensionDeclaration_ExtensionType* internal_default_instance() { + return reinterpret_cast( + &_SimpleExtensionDeclaration_ExtensionType_default_instance_); } static constexpr int kIndexInFileMessages = - 2; + 1; - friend void swap(Extensions_Extension& a, Extensions_Extension& b) { + friend void swap(SimpleExtensionDeclaration_ExtensionType& a, SimpleExtensionDeclaration_ExtensionType& b) { a.Swap(&b); } - inline void Swap(Extensions_Extension* other) { + inline void Swap(SimpleExtensionDeclaration_ExtensionType* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -442,7 +295,7 @@ class Extensions_Extension PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Extensions_Extension* other) { + void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionType* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -450,17 +303,17 @@ class Extensions_Extension PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Extensions_Extension* New() const final { - return CreateMaybeMessage(nullptr); + inline SimpleExtensionDeclaration_ExtensionType* New() const final { + return CreateMaybeMessage(nullptr); } - Extensions_Extension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + SimpleExtensionDeclaration_ExtensionType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions_Extension& from); - void MergeFrom(const Extensions_Extension& from); + void CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from); + void MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -474,13 +327,13 @@ class Extensions_Extension PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Extensions_Extension* other); + void InternalSwap(SimpleExtensionDeclaration_ExtensionType* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions.Extension"; + return "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType"; } protected: - explicit Extensions_Extension(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -490,116 +343,78 @@ class Extensions_Extension PROTOBUF_FINAL : // nested types ---------------------------------------------------- - typedef Extensions_Extension_TypeExtension TypeExtension; - typedef Extensions_Extension_FunctionExtension FunctionExtension; - // accessors ------------------------------------------------------- enum : int { - kExtensionIdFieldNumber = 1, - kTypeExtensionFieldNumber = 2, - kFunctionExtensionFieldNumber = 3, + kNameFieldNumber = 3, + kExtensionUriReferenceFieldNumber = 1, + kTypeAnchorFieldNumber = 2, }; - // .io.substrait.Extensions.ExtensionId extension_id = 1; - bool has_extension_id() const; - private: - bool _internal_has_extension_id() const; - public: - void clear_extension_id(); - const ::io::substrait::Extensions_ExtensionId& extension_id() const; - ::io::substrait::Extensions_ExtensionId* release_extension_id(); - ::io::substrait::Extensions_ExtensionId* mutable_extension_id(); - void set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id); + // string name = 3; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); private: - const ::io::substrait::Extensions_ExtensionId& _internal_extension_id() const; - ::io::substrait::Extensions_ExtensionId* _internal_mutable_extension_id(); + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); public: - void unsafe_arena_set_allocated_extension_id( - ::io::substrait::Extensions_ExtensionId* extension_id); - ::io::substrait::Extensions_ExtensionId* unsafe_arena_release_extension_id(); - // .io.substrait.Extensions.Extension.TypeExtension type_extension = 2; - bool has_type_extension() const; - private: - bool _internal_has_type_extension() const; - public: - void clear_type_extension(); - const ::io::substrait::Extensions_Extension_TypeExtension& type_extension() const; - ::io::substrait::Extensions_Extension_TypeExtension* release_type_extension(); - ::io::substrait::Extensions_Extension_TypeExtension* mutable_type_extension(); - void set_allocated_type_extension(::io::substrait::Extensions_Extension_TypeExtension* type_extension); + // uint32 extension_uri_reference = 1; + void clear_extension_uri_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference() const; + void set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Extensions_Extension_TypeExtension& _internal_type_extension() const; - ::io::substrait::Extensions_Extension_TypeExtension* _internal_mutable_type_extension(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_reference() const; + void _internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_type_extension( - ::io::substrait::Extensions_Extension_TypeExtension* type_extension); - ::io::substrait::Extensions_Extension_TypeExtension* unsafe_arena_release_type_extension(); - // .io.substrait.Extensions.Extension.FunctionExtension function_extension = 3; - bool has_function_extension() const; - private: - bool _internal_has_function_extension() const; - public: - void clear_function_extension(); - const ::io::substrait::Extensions_Extension_FunctionExtension& function_extension() const; - ::io::substrait::Extensions_Extension_FunctionExtension* release_function_extension(); - ::io::substrait::Extensions_Extension_FunctionExtension* mutable_function_extension(); - void set_allocated_function_extension(::io::substrait::Extensions_Extension_FunctionExtension* function_extension); + // uint32 type_anchor = 2; + void clear_type_anchor(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_anchor() const; + void set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Extensions_Extension_FunctionExtension& _internal_function_extension() const; - ::io::substrait::Extensions_Extension_FunctionExtension* _internal_mutable_function_extension(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_anchor() const; + void _internal_set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_function_extension( - ::io::substrait::Extensions_Extension_FunctionExtension* function_extension); - ::io::substrait::Extensions_Extension_FunctionExtension* unsafe_arena_release_function_extension(); - void clear_extension_type(); - ExtensionTypeCase extension_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Extension) + // @@protoc_insertion_point(class_scope:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) private: class _Internal; - void set_has_type_extension(); - void set_has_function_extension(); - - inline bool has_extension_type() const; - inline void clear_has_extension_type(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Extensions_ExtensionId* extension_id_; - union ExtensionTypeUnion { - constexpr ExtensionTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Extensions_Extension_TypeExtension* type_extension_; - ::io::substrait::Extensions_Extension_FunctionExtension* function_extension_; - } extension_type_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_anchor_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_extensions_2eproto; }; // ------------------------------------------------------------------- -class Extensions_Mapping_TypeMapping PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Mapping.TypeMapping) */ { +class SimpleExtensionDeclaration_ExtensionTypeVariation PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) */ { public: - inline Extensions_Mapping_TypeMapping() : Extensions_Mapping_TypeMapping(nullptr) {} - ~Extensions_Mapping_TypeMapping() override; - explicit constexpr Extensions_Mapping_TypeMapping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline SimpleExtensionDeclaration_ExtensionTypeVariation() : SimpleExtensionDeclaration_ExtensionTypeVariation(nullptr) {} + ~SimpleExtensionDeclaration_ExtensionTypeVariation() override; + explicit constexpr SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Extensions_Mapping_TypeMapping(const Extensions_Mapping_TypeMapping& from); - Extensions_Mapping_TypeMapping(Extensions_Mapping_TypeMapping&& from) noexcept - : Extensions_Mapping_TypeMapping() { + SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); + SimpleExtensionDeclaration_ExtensionTypeVariation(SimpleExtensionDeclaration_ExtensionTypeVariation&& from) noexcept + : SimpleExtensionDeclaration_ExtensionTypeVariation() { *this = ::std::move(from); } - inline Extensions_Mapping_TypeMapping& operator=(const Extensions_Mapping_TypeMapping& from) { + inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { CopyFrom(from); return *this; } - inline Extensions_Mapping_TypeMapping& operator=(Extensions_Mapping_TypeMapping&& from) noexcept { + inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(SimpleExtensionDeclaration_ExtensionTypeVariation&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -617,20 +432,20 @@ class Extensions_Mapping_TypeMapping PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Extensions_Mapping_TypeMapping& default_instance() { + static const SimpleExtensionDeclaration_ExtensionTypeVariation& default_instance() { return *internal_default_instance(); } - static inline const Extensions_Mapping_TypeMapping* internal_default_instance() { - return reinterpret_cast( - &_Extensions_Mapping_TypeMapping_default_instance_); + static inline const SimpleExtensionDeclaration_ExtensionTypeVariation* internal_default_instance() { + return reinterpret_cast( + &_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_); } static constexpr int kIndexInFileMessages = - 3; + 2; - friend void swap(Extensions_Mapping_TypeMapping& a, Extensions_Mapping_TypeMapping& b) { + friend void swap(SimpleExtensionDeclaration_ExtensionTypeVariation& a, SimpleExtensionDeclaration_ExtensionTypeVariation& b) { a.Swap(&b); } - inline void Swap(Extensions_Mapping_TypeMapping* other) { + inline void Swap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -638,7 +453,7 @@ class Extensions_Mapping_TypeMapping PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Extensions_Mapping_TypeMapping* other) { + void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -646,17 +461,17 @@ class Extensions_Mapping_TypeMapping PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Extensions_Mapping_TypeMapping* New() const final { - return CreateMaybeMessage(nullptr); + inline SimpleExtensionDeclaration_ExtensionTypeVariation* New() const final { + return CreateMaybeMessage(nullptr); } - Extensions_Mapping_TypeMapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + SimpleExtensionDeclaration_ExtensionTypeVariation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions_Mapping_TypeMapping& from); - void MergeFrom(const Extensions_Mapping_TypeMapping& from); + void CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); + void MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -670,13 +485,13 @@ class Extensions_Mapping_TypeMapping PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Extensions_Mapping_TypeMapping* other); + void InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions.Mapping.TypeMapping"; + return "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation"; } protected: - explicit Extensions_Mapping_TypeMapping(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -690,8 +505,8 @@ class Extensions_Mapping_TypeMapping PROTOBUF_FINAL : enum : int { kNameFieldNumber = 3, - kTypeIdFieldNumber = 1, - kExtensionIdFieldNumber = 2, + kExtensionUriPointerFieldNumber = 1, + kTypeVariationAnchorFieldNumber = 2, }; // string name = 3; void clear_name(); @@ -707,43 +522,25 @@ class Extensions_Mapping_TypeMapping PROTOBUF_FINAL : std::string* _internal_mutable_name(); public: - // .io.substrait.Extensions.TypeId type_id = 1; - bool has_type_id() const; - private: - bool _internal_has_type_id() const; - public: - void clear_type_id(); - const ::io::substrait::Extensions_TypeId& type_id() const; - ::io::substrait::Extensions_TypeId* release_type_id(); - ::io::substrait::Extensions_TypeId* mutable_type_id(); - void set_allocated_type_id(::io::substrait::Extensions_TypeId* type_id); + // uint32 extension_uri_pointer = 1; + void clear_extension_uri_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_pointer() const; + void set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Extensions_TypeId& _internal_type_id() const; - ::io::substrait::Extensions_TypeId* _internal_mutable_type_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_pointer() const; + void _internal_set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_type_id( - ::io::substrait::Extensions_TypeId* type_id); - ::io::substrait::Extensions_TypeId* unsafe_arena_release_type_id(); - // .io.substrait.Extensions.ExtensionId extension_id = 2; - bool has_extension_id() const; - private: - bool _internal_has_extension_id() const; - public: - void clear_extension_id(); - const ::io::substrait::Extensions_ExtensionId& extension_id() const; - ::io::substrait::Extensions_ExtensionId* release_extension_id(); - ::io::substrait::Extensions_ExtensionId* mutable_extension_id(); - void set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id); + // uint32 type_variation_anchor = 2; + void clear_type_variation_anchor(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_anchor() const; + void set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Extensions_ExtensionId& _internal_extension_id() const; - ::io::substrait::Extensions_ExtensionId* _internal_mutable_extension_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_anchor() const; + void _internal_set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_extension_id( - ::io::substrait::Extensions_ExtensionId* extension_id); - ::io::substrait::Extensions_ExtensionId* unsafe_arena_release_extension_id(); - // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Mapping.TypeMapping) + // @@protoc_insertion_point(class_scope:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) private: class _Internal; @@ -751,183 +548,31 @@ class Extensions_Mapping_TypeMapping PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::io::substrait::Extensions_TypeId* type_id_; - ::io::substrait::Extensions_ExtensionId* extension_id_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_extensions_2eproto; -}; -// ------------------------------------------------------------------- - -class Extensions_Mapping_FunctionMapping_Option PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Mapping.FunctionMapping.Option) */ { - public: - inline Extensions_Mapping_FunctionMapping_Option() : Extensions_Mapping_FunctionMapping_Option(nullptr) {} - ~Extensions_Mapping_FunctionMapping_Option() override; - explicit constexpr Extensions_Mapping_FunctionMapping_Option(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Extensions_Mapping_FunctionMapping_Option(const Extensions_Mapping_FunctionMapping_Option& from); - Extensions_Mapping_FunctionMapping_Option(Extensions_Mapping_FunctionMapping_Option&& from) noexcept - : Extensions_Mapping_FunctionMapping_Option() { - *this = ::std::move(from); - } - - inline Extensions_Mapping_FunctionMapping_Option& operator=(const Extensions_Mapping_FunctionMapping_Option& from) { - CopyFrom(from); - return *this; - } - inline Extensions_Mapping_FunctionMapping_Option& operator=(Extensions_Mapping_FunctionMapping_Option&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 Extensions_Mapping_FunctionMapping_Option& default_instance() { - return *internal_default_instance(); - } - static inline const Extensions_Mapping_FunctionMapping_Option* internal_default_instance() { - return reinterpret_cast( - &_Extensions_Mapping_FunctionMapping_Option_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(Extensions_Mapping_FunctionMapping_Option& a, Extensions_Mapping_FunctionMapping_Option& b) { - a.Swap(&b); - } - inline void Swap(Extensions_Mapping_FunctionMapping_Option* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Extensions_Mapping_FunctionMapping_Option* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline Extensions_Mapping_FunctionMapping_Option* New() const final { - return CreateMaybeMessage(nullptr); - } - - Extensions_Mapping_FunctionMapping_Option* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions_Mapping_FunctionMapping_Option& from); - void MergeFrom(const Extensions_Mapping_FunctionMapping_Option& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Extensions_Mapping_FunctionMapping_Option* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions.Mapping.FunctionMapping.Option"; - } - protected: - explicit Extensions_Mapping_FunctionMapping_Option(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kKeyFieldNumber = 1, - kValueFieldNumber = 2, - }; - // string key = 1; - void clear_key(); - const std::string& key() const; - template - void set_key(ArgT0&& arg0, ArgT... args); - std::string* mutable_key(); - std::string* release_key(); - void set_allocated_key(std::string* key); - private: - const std::string& _internal_key() const; - void _internal_set_key(const std::string& value); - std::string* _internal_mutable_key(); - public: - - // string value = 2; - void clear_value(); - const std::string& value() const; - template - void set_value(ArgT0&& arg0, ArgT... args); - std::string* mutable_value(); - std::string* release_value(); - void set_allocated_value(std::string* value); - private: - const std::string& _internal_value() const; - void _internal_set_value(const std::string& value); - std::string* _internal_mutable_value(); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Mapping.FunctionMapping.Option) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_pointer_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_anchor_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_extensions_2eproto; }; // ------------------------------------------------------------------- -class Extensions_Mapping_FunctionMapping PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Mapping.FunctionMapping) */ { +class SimpleExtensionDeclaration_ExtensionFunction PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) */ { public: - inline Extensions_Mapping_FunctionMapping() : Extensions_Mapping_FunctionMapping(nullptr) {} - ~Extensions_Mapping_FunctionMapping() override; - explicit constexpr Extensions_Mapping_FunctionMapping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline SimpleExtensionDeclaration_ExtensionFunction() : SimpleExtensionDeclaration_ExtensionFunction(nullptr) {} + ~SimpleExtensionDeclaration_ExtensionFunction() override; + explicit constexpr SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Extensions_Mapping_FunctionMapping(const Extensions_Mapping_FunctionMapping& from); - Extensions_Mapping_FunctionMapping(Extensions_Mapping_FunctionMapping&& from) noexcept - : Extensions_Mapping_FunctionMapping() { + SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from); + SimpleExtensionDeclaration_ExtensionFunction(SimpleExtensionDeclaration_ExtensionFunction&& from) noexcept + : SimpleExtensionDeclaration_ExtensionFunction() { *this = ::std::move(from); } - inline Extensions_Mapping_FunctionMapping& operator=(const Extensions_Mapping_FunctionMapping& from) { + inline SimpleExtensionDeclaration_ExtensionFunction& operator=(const SimpleExtensionDeclaration_ExtensionFunction& from) { CopyFrom(from); return *this; } - inline Extensions_Mapping_FunctionMapping& operator=(Extensions_Mapping_FunctionMapping&& from) noexcept { + inline SimpleExtensionDeclaration_ExtensionFunction& operator=(SimpleExtensionDeclaration_ExtensionFunction&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -945,20 +590,20 @@ class Extensions_Mapping_FunctionMapping PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Extensions_Mapping_FunctionMapping& default_instance() { + static const SimpleExtensionDeclaration_ExtensionFunction& default_instance() { return *internal_default_instance(); } - static inline const Extensions_Mapping_FunctionMapping* internal_default_instance() { - return reinterpret_cast( - &_Extensions_Mapping_FunctionMapping_default_instance_); + static inline const SimpleExtensionDeclaration_ExtensionFunction* internal_default_instance() { + return reinterpret_cast( + &_SimpleExtensionDeclaration_ExtensionFunction_default_instance_); } static constexpr int kIndexInFileMessages = - 5; + 3; - friend void swap(Extensions_Mapping_FunctionMapping& a, Extensions_Mapping_FunctionMapping& b) { + friend void swap(SimpleExtensionDeclaration_ExtensionFunction& a, SimpleExtensionDeclaration_ExtensionFunction& b) { a.Swap(&b); } - inline void Swap(Extensions_Mapping_FunctionMapping* other) { + inline void Swap(SimpleExtensionDeclaration_ExtensionFunction* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -966,7 +611,7 @@ class Extensions_Mapping_FunctionMapping PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Extensions_Mapping_FunctionMapping* other) { + void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionFunction* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -974,17 +619,17 @@ class Extensions_Mapping_FunctionMapping PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Extensions_Mapping_FunctionMapping* New() const final { - return CreateMaybeMessage(nullptr); + inline SimpleExtensionDeclaration_ExtensionFunction* New() const final { + return CreateMaybeMessage(nullptr); } - Extensions_Mapping_FunctionMapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + SimpleExtensionDeclaration_ExtensionFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions_Mapping_FunctionMapping& from); - void MergeFrom(const Extensions_Mapping_FunctionMapping& from); + void CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from); + void MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -998,13 +643,13 @@ class Extensions_Mapping_FunctionMapping PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Extensions_Mapping_FunctionMapping* other); + void InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions.Mapping.FunctionMapping"; + return "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction"; } protected: - explicit Extensions_Mapping_FunctionMapping(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1014,34 +659,13 @@ class Extensions_Mapping_FunctionMapping PROTOBUF_FINAL : // nested types ---------------------------------------------------- - typedef Extensions_Mapping_FunctionMapping_Option Option; - // accessors ------------------------------------------------------- enum : int { - kOptionsFieldNumber = 5, kNameFieldNumber = 3, - kFunctionIdFieldNumber = 1, - kExtensionIdFieldNumber = 2, + kExtensionUriPointerFieldNumber = 1, + kFunctionAnchorFieldNumber = 2, }; - // repeated .io.substrait.Extensions.Mapping.FunctionMapping.Option options = 5; - int options_size() const; - private: - int _internal_options_size() const; - public: - void clear_options(); - ::io::substrait::Extensions_Mapping_FunctionMapping_Option* mutable_options(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >* - mutable_options(); - private: - const ::io::substrait::Extensions_Mapping_FunctionMapping_Option& _internal_options(int index) const; - ::io::substrait::Extensions_Mapping_FunctionMapping_Option* _internal_add_options(); - public: - const ::io::substrait::Extensions_Mapping_FunctionMapping_Option& options(int index) const; - ::io::substrait::Extensions_Mapping_FunctionMapping_Option* add_options(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >& - options() const; - // string name = 3; void clear_name(); const std::string& name() const; @@ -1056,76 +680,57 @@ class Extensions_Mapping_FunctionMapping PROTOBUF_FINAL : std::string* _internal_mutable_name(); public: - // .io.substrait.Extensions.FunctionId function_id = 1; - bool has_function_id() const; - private: - bool _internal_has_function_id() const; - public: - void clear_function_id(); - const ::io::substrait::Extensions_FunctionId& function_id() const; - ::io::substrait::Extensions_FunctionId* release_function_id(); - ::io::substrait::Extensions_FunctionId* mutable_function_id(); - void set_allocated_function_id(::io::substrait::Extensions_FunctionId* function_id); + // uint32 extension_uri_pointer = 1; + void clear_extension_uri_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_pointer() const; + void set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Extensions_FunctionId& _internal_function_id() const; - ::io::substrait::Extensions_FunctionId* _internal_mutable_function_id(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_pointer() const; + void _internal_set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_function_id( - ::io::substrait::Extensions_FunctionId* function_id); - ::io::substrait::Extensions_FunctionId* unsafe_arena_release_function_id(); - // .io.substrait.Extensions.ExtensionId extension_id = 2; - bool has_extension_id() const; + // uint32 function_anchor = 2; + void clear_function_anchor(); + ::PROTOBUF_NAMESPACE_ID::uint32 function_anchor() const; + void set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_extension_id() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_function_anchor() const; + void _internal_set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_extension_id(); - const ::io::substrait::Extensions_ExtensionId& extension_id() const; - ::io::substrait::Extensions_ExtensionId* release_extension_id(); - ::io::substrait::Extensions_ExtensionId* mutable_extension_id(); - void set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id); - private: - const ::io::substrait::Extensions_ExtensionId& _internal_extension_id() const; - ::io::substrait::Extensions_ExtensionId* _internal_mutable_extension_id(); - public: - void unsafe_arena_set_allocated_extension_id( - ::io::substrait::Extensions_ExtensionId* extension_id); - ::io::substrait::Extensions_ExtensionId* unsafe_arena_release_extension_id(); - // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Mapping.FunctionMapping) + // @@protoc_insertion_point(class_scope:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping_FunctionMapping_Option > options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::io::substrait::Extensions_FunctionId* function_id_; - ::io::substrait::Extensions_ExtensionId* extension_id_; + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_pointer_; + ::PROTOBUF_NAMESPACE_ID::uint32 function_anchor_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_extensions_2eproto; }; // ------------------------------------------------------------------- -class Extensions_Mapping PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.Mapping) */ { +class SimpleExtensionDeclaration PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.SimpleExtensionDeclaration) */ { public: - inline Extensions_Mapping() : Extensions_Mapping(nullptr) {} - ~Extensions_Mapping() override; - explicit constexpr Extensions_Mapping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline SimpleExtensionDeclaration() : SimpleExtensionDeclaration(nullptr) {} + ~SimpleExtensionDeclaration() override; + explicit constexpr SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Extensions_Mapping(const Extensions_Mapping& from); - Extensions_Mapping(Extensions_Mapping&& from) noexcept - : Extensions_Mapping() { + SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from); + SimpleExtensionDeclaration(SimpleExtensionDeclaration&& from) noexcept + : SimpleExtensionDeclaration() { *this = ::std::move(from); } - inline Extensions_Mapping& operator=(const Extensions_Mapping& from) { + inline SimpleExtensionDeclaration& operator=(const SimpleExtensionDeclaration& from) { CopyFrom(from); return *this; } - inline Extensions_Mapping& operator=(Extensions_Mapping&& from) noexcept { + inline SimpleExtensionDeclaration& operator=(SimpleExtensionDeclaration&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -1143,26 +748,27 @@ class Extensions_Mapping PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Extensions_Mapping& default_instance() { + static const SimpleExtensionDeclaration& default_instance() { return *internal_default_instance(); } enum MappingTypeCase { - kTypeMapping = 1, - kFunctionMapping = 2, + kExtensionType = 1, + kExtensionTypeVariation = 2, + kExtensionFunction = 3, MAPPING_TYPE_NOT_SET = 0, }; - static inline const Extensions_Mapping* internal_default_instance() { - return reinterpret_cast( - &_Extensions_Mapping_default_instance_); + static inline const SimpleExtensionDeclaration* internal_default_instance() { + return reinterpret_cast( + &_SimpleExtensionDeclaration_default_instance_); } static constexpr int kIndexInFileMessages = - 6; + 4; - friend void swap(Extensions_Mapping& a, Extensions_Mapping& b) { + friend void swap(SimpleExtensionDeclaration& a, SimpleExtensionDeclaration& b) { a.Swap(&b); } - inline void Swap(Extensions_Mapping* other) { + inline void Swap(SimpleExtensionDeclaration* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -1170,7 +776,7 @@ class Extensions_Mapping PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Extensions_Mapping* other) { + void UnsafeArenaSwap(SimpleExtensionDeclaration* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1178,17 +784,17 @@ class Extensions_Mapping PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Extensions_Mapping* New() const final { - return CreateMaybeMessage(nullptr); + inline SimpleExtensionDeclaration* New() const final { + return CreateMaybeMessage(nullptr); } - Extensions_Mapping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + SimpleExtensionDeclaration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions_Mapping& from); - void MergeFrom(const Extensions_Mapping& from); + void CopyFrom(const SimpleExtensionDeclaration& from); + void MergeFrom(const SimpleExtensionDeclaration& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -1202,13 +808,13 @@ class Extensions_Mapping PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Extensions_Mapping* other); + void InternalSwap(SimpleExtensionDeclaration* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions.Mapping"; + return "io.substrait.extensions.SimpleExtensionDeclaration"; } protected: - explicit Extensions_Mapping(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1218,58 +824,79 @@ class Extensions_Mapping PROTOBUF_FINAL : // nested types ---------------------------------------------------- - typedef Extensions_Mapping_TypeMapping TypeMapping; - typedef Extensions_Mapping_FunctionMapping FunctionMapping; + typedef SimpleExtensionDeclaration_ExtensionType ExtensionType; + typedef SimpleExtensionDeclaration_ExtensionTypeVariation ExtensionTypeVariation; + typedef SimpleExtensionDeclaration_ExtensionFunction ExtensionFunction; // accessors ------------------------------------------------------- enum : int { - kTypeMappingFieldNumber = 1, - kFunctionMappingFieldNumber = 2, + kExtensionTypeFieldNumber = 1, + kExtensionTypeVariationFieldNumber = 2, + kExtensionFunctionFieldNumber = 3, }; - // .io.substrait.Extensions.Mapping.TypeMapping type_mapping = 1; - bool has_type_mapping() const; + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; + bool has_extension_type() const; + private: + bool _internal_has_extension_type() const; + public: + void clear_extension_type(); + const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type() const; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* release_extension_type(); + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* mutable_extension_type(); + void set_allocated_extension_type(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type); + private: + const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& _internal_extension_type() const; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* _internal_mutable_extension_type(); + public: + void unsafe_arena_set_allocated_extension_type( + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type); + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* unsafe_arena_release_extension_type(); + + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; + bool has_extension_type_variation() const; private: - bool _internal_has_type_mapping() const; + bool _internal_has_extension_type_variation() const; public: - void clear_type_mapping(); - const ::io::substrait::Extensions_Mapping_TypeMapping& type_mapping() const; - ::io::substrait::Extensions_Mapping_TypeMapping* release_type_mapping(); - ::io::substrait::Extensions_Mapping_TypeMapping* mutable_type_mapping(); - void set_allocated_type_mapping(::io::substrait::Extensions_Mapping_TypeMapping* type_mapping); + void clear_extension_type_variation(); + const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation() const; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* release_extension_type_variation(); + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* mutable_extension_type_variation(); + void set_allocated_extension_type_variation(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation); private: - const ::io::substrait::Extensions_Mapping_TypeMapping& _internal_type_mapping() const; - ::io::substrait::Extensions_Mapping_TypeMapping* _internal_mutable_type_mapping(); + const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& _internal_extension_type_variation() const; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* _internal_mutable_extension_type_variation(); public: - void unsafe_arena_set_allocated_type_mapping( - ::io::substrait::Extensions_Mapping_TypeMapping* type_mapping); - ::io::substrait::Extensions_Mapping_TypeMapping* unsafe_arena_release_type_mapping(); + void unsafe_arena_set_allocated_extension_type_variation( + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation); + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* unsafe_arena_release_extension_type_variation(); - // .io.substrait.Extensions.Mapping.FunctionMapping function_mapping = 2; - bool has_function_mapping() const; + // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; + bool has_extension_function() const; private: - bool _internal_has_function_mapping() const; + bool _internal_has_extension_function() const; public: - void clear_function_mapping(); - const ::io::substrait::Extensions_Mapping_FunctionMapping& function_mapping() const; - ::io::substrait::Extensions_Mapping_FunctionMapping* release_function_mapping(); - ::io::substrait::Extensions_Mapping_FunctionMapping* mutable_function_mapping(); - void set_allocated_function_mapping(::io::substrait::Extensions_Mapping_FunctionMapping* function_mapping); + void clear_extension_function(); + const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function() const; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* release_extension_function(); + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* mutable_extension_function(); + void set_allocated_extension_function(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function); private: - const ::io::substrait::Extensions_Mapping_FunctionMapping& _internal_function_mapping() const; - ::io::substrait::Extensions_Mapping_FunctionMapping* _internal_mutable_function_mapping(); + const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& _internal_extension_function() const; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* _internal_mutable_extension_function(); public: - void unsafe_arena_set_allocated_function_mapping( - ::io::substrait::Extensions_Mapping_FunctionMapping* function_mapping); - ::io::substrait::Extensions_Mapping_FunctionMapping* unsafe_arena_release_function_mapping(); + void unsafe_arena_set_allocated_extension_function( + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function); + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* unsafe_arena_release_extension_function(); void clear_mapping_type(); MappingTypeCase mapping_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Extensions.Mapping) + // @@protoc_insertion_point(class_scope:io.substrait.extensions.SimpleExtensionDeclaration) private: class _Internal; - void set_has_type_mapping(); - void set_has_function_mapping(); + void set_has_extension_type(); + void set_has_extension_type_variation(); + void set_has_extension_function(); inline bool has_mapping_type() const; inline void clear_has_mapping_type(); @@ -1280,8 +907,9 @@ class Extensions_Mapping PROTOBUF_FINAL : union MappingTypeUnion { constexpr MappingTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Extensions_Mapping_TypeMapping* type_mapping_; - ::io::substrait::Extensions_Mapping_FunctionMapping* function_mapping_; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type_; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation_; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function_; } mapping_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; @@ -1290,24 +918,24 @@ class Extensions_Mapping PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Extensions_ExtensionId PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.ExtensionId) */ { +class AdvancedExtension PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.AdvancedExtension) */ { public: - inline Extensions_ExtensionId() : Extensions_ExtensionId(nullptr) {} - ~Extensions_ExtensionId() override; - explicit constexpr Extensions_ExtensionId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline AdvancedExtension() : AdvancedExtension(nullptr) {} + ~AdvancedExtension() override; + explicit constexpr AdvancedExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Extensions_ExtensionId(const Extensions_ExtensionId& from); - Extensions_ExtensionId(Extensions_ExtensionId&& from) noexcept - : Extensions_ExtensionId() { + AdvancedExtension(const AdvancedExtension& from); + AdvancedExtension(AdvancedExtension&& from) noexcept + : AdvancedExtension() { *this = ::std::move(from); } - inline Extensions_ExtensionId& operator=(const Extensions_ExtensionId& from) { + inline AdvancedExtension& operator=(const AdvancedExtension& from) { CopyFrom(from); return *this; } - inline Extensions_ExtensionId& operator=(Extensions_ExtensionId&& from) noexcept { + inline AdvancedExtension& operator=(AdvancedExtension&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -1325,20 +953,20 @@ class Extensions_ExtensionId PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Extensions_ExtensionId& default_instance() { + static const AdvancedExtension& default_instance() { return *internal_default_instance(); } - static inline const Extensions_ExtensionId* internal_default_instance() { - return reinterpret_cast( - &_Extensions_ExtensionId_default_instance_); + static inline const AdvancedExtension* internal_default_instance() { + return reinterpret_cast( + &_AdvancedExtension_default_instance_); } static constexpr int kIndexInFileMessages = - 7; + 5; - friend void swap(Extensions_ExtensionId& a, Extensions_ExtensionId& b) { + friend void swap(AdvancedExtension& a, AdvancedExtension& b) { a.Swap(&b); } - inline void Swap(Extensions_ExtensionId* other) { + inline void Swap(AdvancedExtension* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -1346,7 +974,7 @@ class Extensions_ExtensionId PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Extensions_ExtensionId* other) { + void UnsafeArenaSwap(AdvancedExtension* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1354,17 +982,17 @@ class Extensions_ExtensionId PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Extensions_ExtensionId* New() const final { - return CreateMaybeMessage(nullptr); + inline AdvancedExtension* New() const final { + return CreateMaybeMessage(nullptr); } - Extensions_ExtensionId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + AdvancedExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions_ExtensionId& from); - void MergeFrom(const Extensions_ExtensionId& from); + void CopyFrom(const AdvancedExtension& from); + void MergeFrom(const AdvancedExtension& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -1378,13 +1006,13 @@ class Extensions_ExtensionId PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Extensions_ExtensionId* other); + void InternalSwap(AdvancedExtension* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions.ExtensionId"; + return "io.substrait.extensions.AdvancedExtension"; } protected: - explicit Extensions_ExtensionId(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1397,411 +1025,54 @@ class Extensions_ExtensionId PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kIdFieldNumber = 1, + kOptimizationFieldNumber = 1, + kEnhancementFieldNumber = 2, }; - // uint32 id = 1; - void clear_id(); - ::PROTOBUF_NAMESPACE_ID::uint32 id() const; - void set_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + // .google.protobuf.Any optimization = 1; + bool has_optimization() const; private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_id() const; - void _internal_set_id(::PROTOBUF_NAMESPACE_ID::uint32 value); + bool _internal_has_optimization() const; public: + void clear_optimization(); + const PROTOBUF_NAMESPACE_ID::Any& optimization() const; + PROTOBUF_NAMESPACE_ID::Any* release_optimization(); + PROTOBUF_NAMESPACE_ID::Any* mutable_optimization(); + void set_allocated_optimization(PROTOBUF_NAMESPACE_ID::Any* optimization); + private: + const PROTOBUF_NAMESPACE_ID::Any& _internal_optimization() const; + PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_optimization(); + public: + void unsafe_arena_set_allocated_optimization( + PROTOBUF_NAMESPACE_ID::Any* optimization); + PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_optimization(); - // @@protoc_insertion_point(class_scope:io.substrait.Extensions.ExtensionId) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 id_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_extensions_2eproto; -}; -// ------------------------------------------------------------------- - -class Extensions_FunctionId PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.FunctionId) */ { - public: - inline Extensions_FunctionId() : Extensions_FunctionId(nullptr) {} - ~Extensions_FunctionId() override; - explicit constexpr Extensions_FunctionId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Extensions_FunctionId(const Extensions_FunctionId& from); - Extensions_FunctionId(Extensions_FunctionId&& from) noexcept - : Extensions_FunctionId() { - *this = ::std::move(from); - } - - inline Extensions_FunctionId& operator=(const Extensions_FunctionId& from) { - CopyFrom(from); - return *this; - } - inline Extensions_FunctionId& operator=(Extensions_FunctionId&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 Extensions_FunctionId& default_instance() { - return *internal_default_instance(); - } - static inline const Extensions_FunctionId* internal_default_instance() { - return reinterpret_cast( - &_Extensions_FunctionId_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(Extensions_FunctionId& a, Extensions_FunctionId& b) { - a.Swap(&b); - } - inline void Swap(Extensions_FunctionId* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Extensions_FunctionId* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline Extensions_FunctionId* New() const final { - return CreateMaybeMessage(nullptr); - } - - Extensions_FunctionId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions_FunctionId& from); - void MergeFrom(const Extensions_FunctionId& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - + // .google.protobuf.Any enhancement = 2; + bool has_enhancement() const; private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Extensions_FunctionId* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions.FunctionId"; - } - protected: - explicit Extensions_FunctionId(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + bool _internal_has_enhancement() const; public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kIdFieldNumber = 1, - }; - // uint64 id = 1; - void clear_id(); - ::PROTOBUF_NAMESPACE_ID::uint64 id() const; - void set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + void clear_enhancement(); + const PROTOBUF_NAMESPACE_ID::Any& enhancement() const; + PROTOBUF_NAMESPACE_ID::Any* release_enhancement(); + PROTOBUF_NAMESPACE_ID::Any* mutable_enhancement(); + void set_allocated_enhancement(PROTOBUF_NAMESPACE_ID::Any* enhancement); private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_id() const; - void _internal_set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); + const PROTOBUF_NAMESPACE_ID::Any& _internal_enhancement() const; + PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_enhancement(); public: + void unsafe_arena_set_allocated_enhancement( + PROTOBUF_NAMESPACE_ID::Any* enhancement); + PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_enhancement(); - // @@protoc_insertion_point(class_scope:io.substrait.Extensions.FunctionId) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint64 id_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_extensions_2eproto; -}; -// ------------------------------------------------------------------- - -class Extensions_TypeId PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions.TypeId) */ { - public: - inline Extensions_TypeId() : Extensions_TypeId(nullptr) {} - ~Extensions_TypeId() override; - explicit constexpr Extensions_TypeId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Extensions_TypeId(const Extensions_TypeId& from); - Extensions_TypeId(Extensions_TypeId&& from) noexcept - : Extensions_TypeId() { - *this = ::std::move(from); - } - - inline Extensions_TypeId& operator=(const Extensions_TypeId& from) { - CopyFrom(from); - return *this; - } - inline Extensions_TypeId& operator=(Extensions_TypeId&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 Extensions_TypeId& default_instance() { - return *internal_default_instance(); - } - static inline const Extensions_TypeId* internal_default_instance() { - return reinterpret_cast( - &_Extensions_TypeId_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(Extensions_TypeId& a, Extensions_TypeId& b) { - a.Swap(&b); - } - inline void Swap(Extensions_TypeId* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Extensions_TypeId* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline Extensions_TypeId* New() const final { - return CreateMaybeMessage(nullptr); - } - - Extensions_TypeId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions_TypeId& from); - void MergeFrom(const Extensions_TypeId& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Extensions_TypeId* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions.TypeId"; - } - protected: - explicit Extensions_TypeId(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kIdFieldNumber = 1, - }; - // uint64 id = 1; - void clear_id(); - ::PROTOBUF_NAMESPACE_ID::uint64 id() const; - void set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); - private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_id() const; - void _internal_set_id(::PROTOBUF_NAMESPACE_ID::uint64 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.Extensions.TypeId) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint64 id_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_extensions_2eproto; -}; -// ------------------------------------------------------------------- - -class Extensions PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Extensions) */ { - public: - inline Extensions() : Extensions(nullptr) {} - ~Extensions() override; - explicit constexpr Extensions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Extensions(const Extensions& from); - Extensions(Extensions&& from) noexcept - : Extensions() { - *this = ::std::move(from); - } - - inline Extensions& operator=(const Extensions& from) { - CopyFrom(from); - return *this; - } - inline Extensions& operator=(Extensions&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 Extensions& default_instance() { - return *internal_default_instance(); - } - static inline const Extensions* internal_default_instance() { - return reinterpret_cast( - &_Extensions_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(Extensions& a, Extensions& b) { - a.Swap(&b); - } - inline void Swap(Extensions* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Extensions* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline Extensions* New() const final { - return CreateMaybeMessage(nullptr); - } - - Extensions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Extensions& from); - void MergeFrom(const Extensions& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Extensions* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Extensions"; - } - protected: - explicit Extensions(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Extensions_Extension Extension; - typedef Extensions_Mapping Mapping; - typedef Extensions_ExtensionId ExtensionId; - typedef Extensions_FunctionId FunctionId; - typedef Extensions_TypeId TypeId; - - // accessors ------------------------------------------------------- - - // @@protoc_insertion_point(class_scope:io.substrait.Extensions) + // @@protoc_insertion_point(class_scope:io.substrait.extensions.AdvancedExtension) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; + PROTOBUF_NAMESPACE_ID::Any* optimization_; + PROTOBUF_NAMESPACE_ID::Any* enhancement_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_extensions_2eproto; }; @@ -1810,553 +1081,156 @@ class Extensions PROTOBUF_FINAL : // =================================================================== -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// Extensions_Extension_TypeExtension - -// string git_uri = 1; -inline void Extensions_Extension_TypeExtension::clear_git_uri() { - git_uri_.ClearToEmpty(); -} -inline const std::string& Extensions_Extension_TypeExtension::git_uri() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Extension.TypeExtension.git_uri) - return _internal_git_uri(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void Extensions_Extension_TypeExtension::set_git_uri(ArgT0&& arg0, ArgT... args) { - - git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Extensions.Extension.TypeExtension.git_uri) -} -inline std::string* Extensions_Extension_TypeExtension::mutable_git_uri() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Extension.TypeExtension.git_uri) - return _internal_mutable_git_uri(); -} -inline const std::string& Extensions_Extension_TypeExtension::_internal_git_uri() const { - return git_uri_.Get(); -} -inline void Extensions_Extension_TypeExtension::_internal_set_git_uri(const std::string& value) { - - git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* Extensions_Extension_TypeExtension::_internal_mutable_git_uri() { - - return git_uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* Extensions_Extension_TypeExtension::release_git_uri() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Extension.TypeExtension.git_uri) - return git_uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void Extensions_Extension_TypeExtension::set_allocated_git_uri(std::string* git_uri) { - if (git_uri != nullptr) { - - } else { - - } - git_uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), git_uri, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Extension.TypeExtension.git_uri) -} - -// ------------------------------------------------------------------- - -// Extensions_Extension_FunctionExtension - -// string git_uri = 1; -inline void Extensions_Extension_FunctionExtension::clear_git_uri() { - git_uri_.ClearToEmpty(); -} -inline const std::string& Extensions_Extension_FunctionExtension::git_uri() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Extension.FunctionExtension.git_uri) - return _internal_git_uri(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void Extensions_Extension_FunctionExtension::set_git_uri(ArgT0&& arg0, ArgT... args) { - - git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Extensions.Extension.FunctionExtension.git_uri) -} -inline std::string* Extensions_Extension_FunctionExtension::mutable_git_uri() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Extension.FunctionExtension.git_uri) - return _internal_mutable_git_uri(); -} -inline const std::string& Extensions_Extension_FunctionExtension::_internal_git_uri() const { - return git_uri_.Get(); -} -inline void Extensions_Extension_FunctionExtension::_internal_set_git_uri(const std::string& value) { - - git_uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* Extensions_Extension_FunctionExtension::_internal_mutable_git_uri() { - - return git_uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* Extensions_Extension_FunctionExtension::release_git_uri() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Extension.FunctionExtension.git_uri) - return git_uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void Extensions_Extension_FunctionExtension::set_allocated_git_uri(std::string* git_uri) { - if (git_uri != nullptr) { - - } else { - - } - git_uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), git_uri, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Extension.FunctionExtension.git_uri) -} - -// ------------------------------------------------------------------- - -// Extensions_Extension - -// .io.substrait.Extensions.ExtensionId extension_id = 1; -inline bool Extensions_Extension::_internal_has_extension_id() const { - return this != internal_default_instance() && extension_id_ != nullptr; -} -inline bool Extensions_Extension::has_extension_id() const { - return _internal_has_extension_id(); -} -inline void Extensions_Extension::clear_extension_id() { - if (GetArena() == nullptr && extension_id_ != nullptr) { - delete extension_id_; - } - extension_id_ = nullptr; -} -inline const ::io::substrait::Extensions_ExtensionId& Extensions_Extension::_internal_extension_id() const { - const ::io::substrait::Extensions_ExtensionId* p = extension_id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_ExtensionId_default_instance_); -} -inline const ::io::substrait::Extensions_ExtensionId& Extensions_Extension::extension_id() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Extension.extension_id) - return _internal_extension_id(); -} -inline void Extensions_Extension::unsafe_arena_set_allocated_extension_id( - ::io::substrait::Extensions_ExtensionId* extension_id) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(extension_id_); - } - extension_id_ = extension_id; - if (extension_id) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Extension.extension_id) -} -inline ::io::substrait::Extensions_ExtensionId* Extensions_Extension::release_extension_id() { - - ::io::substrait::Extensions_ExtensionId* temp = extension_id_; - extension_id_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Extensions_ExtensionId* Extensions_Extension::unsafe_arena_release_extension_id() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Extension.extension_id) - - ::io::substrait::Extensions_ExtensionId* temp = extension_id_; - extension_id_ = nullptr; - return temp; -} -inline ::io::substrait::Extensions_ExtensionId* Extensions_Extension::_internal_mutable_extension_id() { - - if (extension_id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_ExtensionId>(GetArena()); - extension_id_ = p; - } - return extension_id_; -} -inline ::io::substrait::Extensions_ExtensionId* Extensions_Extension::mutable_extension_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Extension.extension_id) - return _internal_mutable_extension_id(); -} -inline void Extensions_Extension::set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete extension_id_; - } - if (extension_id) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_id); - if (message_arena != submessage_arena) { - extension_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_id, submessage_arena); - } - - } else { - - } - extension_id_ = extension_id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Extension.extension_id) -} - -// .io.substrait.Extensions.Extension.TypeExtension type_extension = 2; -inline bool Extensions_Extension::_internal_has_type_extension() const { - return extension_type_case() == kTypeExtension; -} -inline bool Extensions_Extension::has_type_extension() const { - return _internal_has_type_extension(); -} -inline void Extensions_Extension::set_has_type_extension() { - _oneof_case_[0] = kTypeExtension; -} -inline void Extensions_Extension::clear_type_extension() { - if (_internal_has_type_extension()) { - if (GetArena() == nullptr) { - delete extension_type_.type_extension_; - } - clear_has_extension_type(); - } -} -inline ::io::substrait::Extensions_Extension_TypeExtension* Extensions_Extension::release_type_extension() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Extension.type_extension) - if (_internal_has_type_extension()) { - clear_has_extension_type(); - ::io::substrait::Extensions_Extension_TypeExtension* temp = extension_type_.type_extension_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - extension_type_.type_extension_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::Extensions_Extension_TypeExtension& Extensions_Extension::_internal_type_extension() const { - return _internal_has_type_extension() - ? *extension_type_.type_extension_ - : reinterpret_cast< ::io::substrait::Extensions_Extension_TypeExtension&>(::io::substrait::_Extensions_Extension_TypeExtension_default_instance_); -} -inline const ::io::substrait::Extensions_Extension_TypeExtension& Extensions_Extension::type_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Extension.type_extension) - return _internal_type_extension(); -} -inline ::io::substrait::Extensions_Extension_TypeExtension* Extensions_Extension::unsafe_arena_release_type_extension() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Extensions.Extension.type_extension) - if (_internal_has_type_extension()) { - clear_has_extension_type(); - ::io::substrait::Extensions_Extension_TypeExtension* temp = extension_type_.type_extension_; - extension_type_.type_extension_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Extensions_Extension::unsafe_arena_set_allocated_type_extension(::io::substrait::Extensions_Extension_TypeExtension* type_extension) { - clear_extension_type(); - if (type_extension) { - set_has_type_extension(); - extension_type_.type_extension_ = type_extension; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Extension.type_extension) -} -inline ::io::substrait::Extensions_Extension_TypeExtension* Extensions_Extension::_internal_mutable_type_extension() { - if (!_internal_has_type_extension()) { - clear_extension_type(); - set_has_type_extension(); - extension_type_.type_extension_ = CreateMaybeMessage< ::io::substrait::Extensions_Extension_TypeExtension >(GetArena()); - } - return extension_type_.type_extension_; -} -inline ::io::substrait::Extensions_Extension_TypeExtension* Extensions_Extension::mutable_type_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Extension.type_extension) - return _internal_mutable_type_extension(); -} - -// .io.substrait.Extensions.Extension.FunctionExtension function_extension = 3; -inline bool Extensions_Extension::_internal_has_function_extension() const { - return extension_type_case() == kFunctionExtension; -} -inline bool Extensions_Extension::has_function_extension() const { - return _internal_has_function_extension(); -} -inline void Extensions_Extension::set_has_function_extension() { - _oneof_case_[0] = kFunctionExtension; -} -inline void Extensions_Extension::clear_function_extension() { - if (_internal_has_function_extension()) { - if (GetArena() == nullptr) { - delete extension_type_.function_extension_; - } - clear_has_extension_type(); - } -} -inline ::io::substrait::Extensions_Extension_FunctionExtension* Extensions_Extension::release_function_extension() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Extension.function_extension) - if (_internal_has_function_extension()) { - clear_has_extension_type(); - ::io::substrait::Extensions_Extension_FunctionExtension* temp = extension_type_.function_extension_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - extension_type_.function_extension_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::Extensions_Extension_FunctionExtension& Extensions_Extension::_internal_function_extension() const { - return _internal_has_function_extension() - ? *extension_type_.function_extension_ - : reinterpret_cast< ::io::substrait::Extensions_Extension_FunctionExtension&>(::io::substrait::_Extensions_Extension_FunctionExtension_default_instance_); -} -inline const ::io::substrait::Extensions_Extension_FunctionExtension& Extensions_Extension::function_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Extension.function_extension) - return _internal_function_extension(); -} -inline ::io::substrait::Extensions_Extension_FunctionExtension* Extensions_Extension::unsafe_arena_release_function_extension() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Extensions.Extension.function_extension) - if (_internal_has_function_extension()) { - clear_has_extension_type(); - ::io::substrait::Extensions_Extension_FunctionExtension* temp = extension_type_.function_extension_; - extension_type_.function_extension_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Extensions_Extension::unsafe_arena_set_allocated_function_extension(::io::substrait::Extensions_Extension_FunctionExtension* function_extension) { - clear_extension_type(); - if (function_extension) { - set_has_function_extension(); - extension_type_.function_extension_ = function_extension; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Extension.function_extension) -} -inline ::io::substrait::Extensions_Extension_FunctionExtension* Extensions_Extension::_internal_mutable_function_extension() { - if (!_internal_has_function_extension()) { - clear_extension_type(); - set_has_function_extension(); - extension_type_.function_extension_ = CreateMaybeMessage< ::io::substrait::Extensions_Extension_FunctionExtension >(GetArena()); - } - return extension_type_.function_extension_; -} -inline ::io::substrait::Extensions_Extension_FunctionExtension* Extensions_Extension::mutable_function_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Extension.function_extension) - return _internal_mutable_function_extension(); -} - -inline bool Extensions_Extension::has_extension_type() const { - return extension_type_case() != EXTENSION_TYPE_NOT_SET; +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// SimpleExtensionURI + +// uint32 extension_uri_anchor = 1; +inline void SimpleExtensionURI::clear_extension_uri_anchor() { + extension_uri_anchor_ = 0u; } -inline void Extensions_Extension::clear_has_extension_type() { - _oneof_case_[0] = EXTENSION_TYPE_NOT_SET; +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionURI::_internal_extension_uri_anchor() const { + return extension_uri_anchor_; } -inline Extensions_Extension::ExtensionTypeCase Extensions_Extension::extension_type_case() const { - return Extensions_Extension::ExtensionTypeCase(_oneof_case_[0]); +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionURI::extension_uri_anchor() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionURI.extension_uri_anchor) + return _internal_extension_uri_anchor(); } -// ------------------------------------------------------------------- - -// Extensions_Mapping_TypeMapping - -// .io.substrait.Extensions.TypeId type_id = 1; -inline bool Extensions_Mapping_TypeMapping::_internal_has_type_id() const { - return this != internal_default_instance() && type_id_ != nullptr; +inline void SimpleExtensionURI::_internal_set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + extension_uri_anchor_ = value; } -inline bool Extensions_Mapping_TypeMapping::has_type_id() const { - return _internal_has_type_id(); +inline void SimpleExtensionURI::set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_extension_uri_anchor(value); + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionURI.extension_uri_anchor) } -inline void Extensions_Mapping_TypeMapping::clear_type_id() { - if (GetArena() == nullptr && type_id_ != nullptr) { - delete type_id_; - } - type_id_ = nullptr; + +// string uri = 2; +inline void SimpleExtensionURI::clear_uri() { + uri_.ClearToEmpty(); } -inline const ::io::substrait::Extensions_TypeId& Extensions_Mapping_TypeMapping::_internal_type_id() const { - const ::io::substrait::Extensions_TypeId* p = type_id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_TypeId_default_instance_); +inline const std::string& SimpleExtensionURI::uri() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionURI.uri) + return _internal_uri(); } -inline const ::io::substrait::Extensions_TypeId& Extensions_Mapping_TypeMapping::type_id() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.TypeMapping.type_id) - return _internal_type_id(); +template +PROTOBUF_ALWAYS_INLINE +inline void SimpleExtensionURI::set_uri(ArgT0&& arg0, ArgT... args) { + + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionURI.uri) } -inline void Extensions_Mapping_TypeMapping::unsafe_arena_set_allocated_type_id( - ::io::substrait::Extensions_TypeId* type_id) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_id_); - } - type_id_ = type_id; - if (type_id) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.TypeMapping.type_id) +inline std::string* SimpleExtensionURI::mutable_uri() { + // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionURI.uri) + return _internal_mutable_uri(); } -inline ::io::substrait::Extensions_TypeId* Extensions_Mapping_TypeMapping::release_type_id() { - - ::io::substrait::Extensions_TypeId* temp = type_id_; - type_id_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline const std::string& SimpleExtensionURI::_internal_uri() const { + return uri_.Get(); } -inline ::io::substrait::Extensions_TypeId* Extensions_Mapping_TypeMapping::unsafe_arena_release_type_id() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.TypeMapping.type_id) +inline void SimpleExtensionURI::_internal_set_uri(const std::string& value) { - ::io::substrait::Extensions_TypeId* temp = type_id_; - type_id_ = nullptr; - return temp; + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline ::io::substrait::Extensions_TypeId* Extensions_Mapping_TypeMapping::_internal_mutable_type_id() { +inline std::string* SimpleExtensionURI::_internal_mutable_uri() { - if (type_id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_TypeId>(GetArena()); - type_id_ = p; - } - return type_id_; + return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline ::io::substrait::Extensions_TypeId* Extensions_Mapping_TypeMapping::mutable_type_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.TypeMapping.type_id) - return _internal_mutable_type_id(); +inline std::string* SimpleExtensionURI::release_uri() { + // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionURI.uri) + return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void Extensions_Mapping_TypeMapping::set_allocated_type_id(::io::substrait::Extensions_TypeId* type_id) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete type_id_; - } - if (type_id) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_id); - if (message_arena != submessage_arena) { - type_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type_id, submessage_arena); - } +inline void SimpleExtensionURI::set_allocated_uri(std::string* uri) { + if (uri != nullptr) { } else { } - type_id_ = type_id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.TypeMapping.type_id) + uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionURI.uri) } -// .io.substrait.Extensions.ExtensionId extension_id = 2; -inline bool Extensions_Mapping_TypeMapping::_internal_has_extension_id() const { - return this != internal_default_instance() && extension_id_ != nullptr; +// ------------------------------------------------------------------- + +// SimpleExtensionDeclaration_ExtensionType + +// uint32 extension_uri_reference = 1; +inline void SimpleExtensionDeclaration_ExtensionType::clear_extension_uri_reference() { + extension_uri_reference_ = 0u; } -inline bool Extensions_Mapping_TypeMapping::has_extension_id() const { - return _internal_has_extension_id(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::_internal_extension_uri_reference() const { + return extension_uri_reference_; } -inline void Extensions_Mapping_TypeMapping::clear_extension_id() { - if (GetArena() == nullptr && extension_id_ != nullptr) { - delete extension_id_; - } - extension_id_ = nullptr; +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::extension_uri_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference) + return _internal_extension_uri_reference(); } -inline const ::io::substrait::Extensions_ExtensionId& Extensions_Mapping_TypeMapping::_internal_extension_id() const { - const ::io::substrait::Extensions_ExtensionId* p = extension_id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_ExtensionId_default_instance_); +inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + extension_uri_reference_ = value; } -inline const ::io::substrait::Extensions_ExtensionId& Extensions_Mapping_TypeMapping::extension_id() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.TypeMapping.extension_id) - return _internal_extension_id(); +inline void SimpleExtensionDeclaration_ExtensionType::set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_extension_uri_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference) } -inline void Extensions_Mapping_TypeMapping::unsafe_arena_set_allocated_extension_id( - ::io::substrait::Extensions_ExtensionId* extension_id) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(extension_id_); - } - extension_id_ = extension_id; - if (extension_id) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.TypeMapping.extension_id) + +// uint32 type_anchor = 2; +inline void SimpleExtensionDeclaration_ExtensionType::clear_type_anchor() { + type_anchor_ = 0u; } -inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_TypeMapping::release_extension_id() { - - ::io::substrait::Extensions_ExtensionId* temp = extension_id_; - extension_id_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::_internal_type_anchor() const { + return type_anchor_; } -inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_TypeMapping::unsafe_arena_release_extension_id() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.TypeMapping.extension_id) - - ::io::substrait::Extensions_ExtensionId* temp = extension_id_; - extension_id_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::type_anchor() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor) + return _internal_type_anchor(); } -inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_TypeMapping::_internal_mutable_extension_id() { +inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (extension_id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_ExtensionId>(GetArena()); - extension_id_ = p; - } - return extension_id_; + type_anchor_ = value; } -inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_TypeMapping::mutable_extension_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.TypeMapping.extension_id) - return _internal_mutable_extension_id(); -} -inline void Extensions_Mapping_TypeMapping::set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete extension_id_; - } - if (extension_id) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_id); - if (message_arena != submessage_arena) { - extension_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_id, submessage_arena); - } - - } else { - - } - extension_id_ = extension_id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.TypeMapping.extension_id) +inline void SimpleExtensionDeclaration_ExtensionType::set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_anchor(value); + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor) } // string name = 3; -inline void Extensions_Mapping_TypeMapping::clear_name() { +inline void SimpleExtensionDeclaration_ExtensionType::clear_name() { name_.ClearToEmpty(); } -inline const std::string& Extensions_Mapping_TypeMapping::name() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.TypeMapping.name) +inline const std::string& SimpleExtensionDeclaration_ExtensionType::name() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) return _internal_name(); } template PROTOBUF_ALWAYS_INLINE -inline void Extensions_Mapping_TypeMapping::set_name(ArgT0&& arg0, ArgT... args) { +inline void SimpleExtensionDeclaration_ExtensionType::set_name(ArgT0&& arg0, ArgT... args) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Extensions.Mapping.TypeMapping.name) + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) } -inline std::string* Extensions_Mapping_TypeMapping::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.TypeMapping.name) +inline std::string* SimpleExtensionDeclaration_ExtensionType::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) return _internal_mutable_name(); } -inline const std::string& Extensions_Mapping_TypeMapping::_internal_name() const { +inline const std::string& SimpleExtensionDeclaration_ExtensionType::_internal_name() const { return name_.Get(); } -inline void Extensions_Mapping_TypeMapping::_internal_set_name(const std::string& value) { +inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_name(const std::string& value) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline std::string* Extensions_Mapping_TypeMapping::_internal_mutable_name() { +inline std::string* SimpleExtensionDeclaration_ExtensionType::_internal_mutable_name() { return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* Extensions_Mapping_TypeMapping::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.TypeMapping.name) +inline std::string* SimpleExtensionDeclaration_ExtensionType::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void Extensions_Mapping_TypeMapping::set_allocated_name(std::string* name) { +inline void SimpleExtensionDeclaration_ExtensionType::set_allocated_name(std::string* name) { if (name != nullptr) { } else { @@ -2364,308 +1238,177 @@ inline void Extensions_Mapping_TypeMapping::set_allocated_name(std::string* name } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.TypeMapping.name) + // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) } // ------------------------------------------------------------------- -// Extensions_Mapping_FunctionMapping_Option +// SimpleExtensionDeclaration_ExtensionTypeVariation -// string key = 1; -inline void Extensions_Mapping_FunctionMapping_Option::clear_key() { - key_.ClearToEmpty(); +// uint32 extension_uri_pointer = 1; +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_extension_uri_pointer() { + extension_uri_pointer_ = 0u; } -inline const std::string& Extensions_Mapping_FunctionMapping_Option::key() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.Option.key) - return _internal_key(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_extension_uri_pointer() const { + return extension_uri_pointer_; } -template -PROTOBUF_ALWAYS_INLINE -inline void Extensions_Mapping_FunctionMapping_Option::set_key(ArgT0&& arg0, ArgT... args) { - - key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Extensions.Mapping.FunctionMapping.Option.key) +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::extension_uri_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_pointer) + return _internal_extension_uri_pointer(); } -inline std::string* Extensions_Mapping_FunctionMapping_Option::mutable_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.Option.key) - return _internal_mutable_key(); +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + extension_uri_pointer_ = value; } -inline const std::string& Extensions_Mapping_FunctionMapping_Option::_internal_key() const { - return key_.Get(); +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_extension_uri_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_pointer) } -inline void Extensions_Mapping_FunctionMapping_Option::_internal_set_key(const std::string& value) { - - key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + +// uint32 type_variation_anchor = 2; +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_type_variation_anchor() { + type_variation_anchor_ = 0u; } -inline std::string* Extensions_Mapping_FunctionMapping_Option::_internal_mutable_key() { - - return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_type_variation_anchor() const { + return type_variation_anchor_; } -inline std::string* Extensions_Mapping_FunctionMapping_Option::release_key() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.FunctionMapping.Option.key) - return key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor) + return _internal_type_variation_anchor(); } -inline void Extensions_Mapping_FunctionMapping_Option::set_allocated_key(std::string* key) { - if (key != nullptr) { - - } else { - - } - key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.Option.key) +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + type_variation_anchor_ = value; +} +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_anchor(value); + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor) } -// string value = 2; -inline void Extensions_Mapping_FunctionMapping_Option::clear_value() { - value_.ClearToEmpty(); +// string name = 3; +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_name() { + name_.ClearToEmpty(); } -inline const std::string& Extensions_Mapping_FunctionMapping_Option::value() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.Option.value) - return _internal_value(); +inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::name() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) + return _internal_name(); } template PROTOBUF_ALWAYS_INLINE -inline void Extensions_Mapping_FunctionMapping_Option::set_value(ArgT0&& arg0, ArgT... args) { +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_name(ArgT0&& arg0, ArgT... args) { - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Extensions.Mapping.FunctionMapping.Option.value) + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) } -inline std::string* Extensions_Mapping_FunctionMapping_Option::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.Option.value) - return _internal_mutable_value(); +inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) + return _internal_mutable_name(); } -inline const std::string& Extensions_Mapping_FunctionMapping_Option::_internal_value() const { - return value_.Get(); +inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_name() const { + return name_.Get(); } -inline void Extensions_Mapping_FunctionMapping_Option::_internal_set_value(const std::string& value) { +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_name(const std::string& value) { - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline std::string* Extensions_Mapping_FunctionMapping_Option::_internal_mutable_value() { +inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_mutable_name() { - return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* Extensions_Mapping_FunctionMapping_Option::release_value() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.FunctionMapping.Option.value) - return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void Extensions_Mapping_FunctionMapping_Option::set_allocated_value(std::string* value) { - if (value != nullptr) { +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_allocated_name(std::string* name) { + if (name != nullptr) { } else { } - value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.Option.value) + // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) } // ------------------------------------------------------------------- -// Extensions_Mapping_FunctionMapping +// SimpleExtensionDeclaration_ExtensionFunction -// .io.substrait.Extensions.FunctionId function_id = 1; -inline bool Extensions_Mapping_FunctionMapping::_internal_has_function_id() const { - return this != internal_default_instance() && function_id_ != nullptr; -} -inline bool Extensions_Mapping_FunctionMapping::has_function_id() const { - return _internal_has_function_id(); -} -inline void Extensions_Mapping_FunctionMapping::clear_function_id() { - if (GetArena() == nullptr && function_id_ != nullptr) { - delete function_id_; - } - function_id_ = nullptr; -} -inline const ::io::substrait::Extensions_FunctionId& Extensions_Mapping_FunctionMapping::_internal_function_id() const { - const ::io::substrait::Extensions_FunctionId* p = function_id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_FunctionId_default_instance_); -} -inline const ::io::substrait::Extensions_FunctionId& Extensions_Mapping_FunctionMapping::function_id() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.function_id) - return _internal_function_id(); -} -inline void Extensions_Mapping_FunctionMapping::unsafe_arena_set_allocated_function_id( - ::io::substrait::Extensions_FunctionId* function_id) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(function_id_); - } - function_id_ = function_id; - if (function_id) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.function_id) +// uint32 extension_uri_pointer = 1; +inline void SimpleExtensionDeclaration_ExtensionFunction::clear_extension_uri_pointer() { + extension_uri_pointer_ = 0u; } -inline ::io::substrait::Extensions_FunctionId* Extensions_Mapping_FunctionMapping::release_function_id() { - - ::io::substrait::Extensions_FunctionId* temp = function_id_; - function_id_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::_internal_extension_uri_pointer() const { + return extension_uri_pointer_; } -inline ::io::substrait::Extensions_FunctionId* Extensions_Mapping_FunctionMapping::unsafe_arena_release_function_id() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.FunctionMapping.function_id) - - ::io::substrait::Extensions_FunctionId* temp = function_id_; - function_id_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::extension_uri_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_pointer) + return _internal_extension_uri_pointer(); } -inline ::io::substrait::Extensions_FunctionId* Extensions_Mapping_FunctionMapping::_internal_mutable_function_id() { +inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (function_id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); - function_id_ = p; - } - return function_id_; + extension_uri_pointer_ = value; } -inline ::io::substrait::Extensions_FunctionId* Extensions_Mapping_FunctionMapping::mutable_function_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.function_id) - return _internal_mutable_function_id(); -} -inline void Extensions_Mapping_FunctionMapping::set_allocated_function_id(::io::substrait::Extensions_FunctionId* function_id) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete function_id_; - } - if (function_id) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(function_id); - if (message_arena != submessage_arena) { - function_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, function_id, submessage_arena); - } - - } else { - - } - function_id_ = function_id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.function_id) +inline void SimpleExtensionDeclaration_ExtensionFunction::set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_extension_uri_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_pointer) } -// .io.substrait.Extensions.ExtensionId extension_id = 2; -inline bool Extensions_Mapping_FunctionMapping::_internal_has_extension_id() const { - return this != internal_default_instance() && extension_id_ != nullptr; -} -inline bool Extensions_Mapping_FunctionMapping::has_extension_id() const { - return _internal_has_extension_id(); -} -inline void Extensions_Mapping_FunctionMapping::clear_extension_id() { - if (GetArena() == nullptr && extension_id_ != nullptr) { - delete extension_id_; - } - extension_id_ = nullptr; -} -inline const ::io::substrait::Extensions_ExtensionId& Extensions_Mapping_FunctionMapping::_internal_extension_id() const { - const ::io::substrait::Extensions_ExtensionId* p = extension_id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_ExtensionId_default_instance_); -} -inline const ::io::substrait::Extensions_ExtensionId& Extensions_Mapping_FunctionMapping::extension_id() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.extension_id) - return _internal_extension_id(); -} -inline void Extensions_Mapping_FunctionMapping::unsafe_arena_set_allocated_extension_id( - ::io::substrait::Extensions_ExtensionId* extension_id) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(extension_id_); - } - extension_id_ = extension_id; - if (extension_id) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.extension_id) +// uint32 function_anchor = 2; +inline void SimpleExtensionDeclaration_ExtensionFunction::clear_function_anchor() { + function_anchor_ = 0u; } -inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_FunctionMapping::release_extension_id() { - - ::io::substrait::Extensions_ExtensionId* temp = extension_id_; - extension_id_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::_internal_function_anchor() const { + return function_anchor_; } -inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_FunctionMapping::unsafe_arena_release_extension_id() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.FunctionMapping.extension_id) - - ::io::substrait::Extensions_ExtensionId* temp = extension_id_; - extension_id_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::function_anchor() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor) + return _internal_function_anchor(); } -inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_FunctionMapping::_internal_mutable_extension_id() { +inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (extension_id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_ExtensionId>(GetArena()); - extension_id_ = p; - } - return extension_id_; -} -inline ::io::substrait::Extensions_ExtensionId* Extensions_Mapping_FunctionMapping::mutable_extension_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.extension_id) - return _internal_mutable_extension_id(); + function_anchor_ = value; } -inline void Extensions_Mapping_FunctionMapping::set_allocated_extension_id(::io::substrait::Extensions_ExtensionId* extension_id) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete extension_id_; - } - if (extension_id) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_id); - if (message_arena != submessage_arena) { - extension_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_id, submessage_arena); - } - - } else { - - } - extension_id_ = extension_id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.extension_id) +inline void SimpleExtensionDeclaration_ExtensionFunction::set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_function_anchor(value); + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor) } // string name = 3; -inline void Extensions_Mapping_FunctionMapping::clear_name() { +inline void SimpleExtensionDeclaration_ExtensionFunction::clear_name() { name_.ClearToEmpty(); } -inline const std::string& Extensions_Mapping_FunctionMapping::name() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.name) +inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::name() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) return _internal_name(); } template PROTOBUF_ALWAYS_INLINE -inline void Extensions_Mapping_FunctionMapping::set_name(ArgT0&& arg0, ArgT... args) { +inline void SimpleExtensionDeclaration_ExtensionFunction::set_name(ArgT0&& arg0, ArgT... args) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Extensions.Mapping.FunctionMapping.name) + // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) } -inline std::string* Extensions_Mapping_FunctionMapping::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.name) +inline std::string* SimpleExtensionDeclaration_ExtensionFunction::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) return _internal_mutable_name(); } -inline const std::string& Extensions_Mapping_FunctionMapping::_internal_name() const { +inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::_internal_name() const { return name_.Get(); } -inline void Extensions_Mapping_FunctionMapping::_internal_set_name(const std::string& value) { +inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_name(const std::string& value) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline std::string* Extensions_Mapping_FunctionMapping::_internal_mutable_name() { +inline std::string* SimpleExtensionDeclaration_ExtensionFunction::_internal_mutable_name() { return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline std::string* Extensions_Mapping_FunctionMapping::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.FunctionMapping.name) +inline std::string* SimpleExtensionDeclaration_ExtensionFunction::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline void Extensions_Mapping_FunctionMapping::set_allocated_name(std::string* name) { +inline void SimpleExtensionDeclaration_ExtensionFunction::set_allocated_name(std::string* name) { if (name != nullptr) { } else { @@ -2673,282 +1416,398 @@ inline void Extensions_Mapping_FunctionMapping::set_allocated_name(std::string* } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Extensions.Mapping.FunctionMapping.name) + // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) } -// repeated .io.substrait.Extensions.Mapping.FunctionMapping.Option options = 5; -inline int Extensions_Mapping_FunctionMapping::_internal_options_size() const { - return options_.size(); +// ------------------------------------------------------------------- + +// SimpleExtensionDeclaration + +// .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; +inline bool SimpleExtensionDeclaration::_internal_has_extension_type() const { + return mapping_type_case() == kExtensionType; +} +inline bool SimpleExtensionDeclaration::has_extension_type() const { + return _internal_has_extension_type(); } -inline int Extensions_Mapping_FunctionMapping::options_size() const { - return _internal_options_size(); +inline void SimpleExtensionDeclaration::set_has_extension_type() { + _oneof_case_[0] = kExtensionType; } -inline void Extensions_Mapping_FunctionMapping::clear_options() { - options_.Clear(); +inline void SimpleExtensionDeclaration::clear_extension_type() { + if (_internal_has_extension_type()) { + if (GetArena() == nullptr) { + delete mapping_type_.extension_type_; + } + clear_has_mapping_type(); + } } -inline ::io::substrait::Extensions_Mapping_FunctionMapping_Option* Extensions_Mapping_FunctionMapping::mutable_options(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.FunctionMapping.options) - return options_.Mutable(index); +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::release_extension_type() { + // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) + if (_internal_has_extension_type()) { + clear_has_mapping_type(); + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + mapping_type_.extension_type_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >* -Extensions_Mapping_FunctionMapping::mutable_options() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Extensions.Mapping.FunctionMapping.options) - return &options_; +inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& SimpleExtensionDeclaration::_internal_extension_type() const { + return _internal_has_extension_type() + ? *mapping_type_.extension_type_ + : reinterpret_cast< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType&>(::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_); } -inline const ::io::substrait::Extensions_Mapping_FunctionMapping_Option& Extensions_Mapping_FunctionMapping::_internal_options(int index) const { - return options_.Get(index); +inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& SimpleExtensionDeclaration::extension_type() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) + return _internal_extension_type(); } -inline const ::io::substrait::Extensions_Mapping_FunctionMapping_Option& Extensions_Mapping_FunctionMapping::options(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.FunctionMapping.options) - return _internal_options(index); +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::unsafe_arena_release_extension_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) + if (_internal_has_extension_type()) { + clear_has_mapping_type(); + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_; + mapping_type_.extension_type_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline ::io::substrait::Extensions_Mapping_FunctionMapping_Option* Extensions_Mapping_FunctionMapping::_internal_add_options() { - return options_.Add(); +inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_type(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) { + clear_mapping_type(); + if (extension_type) { + set_has_extension_type(); + mapping_type_.extension_type_ = extension_type; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) } -inline ::io::substrait::Extensions_Mapping_FunctionMapping_Option* Extensions_Mapping_FunctionMapping::add_options() { - // @@protoc_insertion_point(field_add:io.substrait.Extensions.Mapping.FunctionMapping.options) - return _internal_add_options(); +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::_internal_mutable_extension_type() { + if (!_internal_has_extension_type()) { + clear_mapping_type(); + set_has_extension_type(); + mapping_type_.extension_type_ = CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(GetArena()); + } + return mapping_type_.extension_type_; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping_FunctionMapping_Option >& -Extensions_Mapping_FunctionMapping::options() const { - // @@protoc_insertion_point(field_list:io.substrait.Extensions.Mapping.FunctionMapping.options) - return options_; +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::mutable_extension_type() { + // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) + return _internal_mutable_extension_type(); } -// ------------------------------------------------------------------- - -// Extensions_Mapping - -// .io.substrait.Extensions.Mapping.TypeMapping type_mapping = 1; -inline bool Extensions_Mapping::_internal_has_type_mapping() const { - return mapping_type_case() == kTypeMapping; +// .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; +inline bool SimpleExtensionDeclaration::_internal_has_extension_type_variation() const { + return mapping_type_case() == kExtensionTypeVariation; } -inline bool Extensions_Mapping::has_type_mapping() const { - return _internal_has_type_mapping(); +inline bool SimpleExtensionDeclaration::has_extension_type_variation() const { + return _internal_has_extension_type_variation(); } -inline void Extensions_Mapping::set_has_type_mapping() { - _oneof_case_[0] = kTypeMapping; +inline void SimpleExtensionDeclaration::set_has_extension_type_variation() { + _oneof_case_[0] = kExtensionTypeVariation; } -inline void Extensions_Mapping::clear_type_mapping() { - if (_internal_has_type_mapping()) { +inline void SimpleExtensionDeclaration::clear_extension_type_variation() { + if (_internal_has_extension_type_variation()) { if (GetArena() == nullptr) { - delete mapping_type_.type_mapping_; + delete mapping_type_.extension_type_variation_; } clear_has_mapping_type(); } } -inline ::io::substrait::Extensions_Mapping_TypeMapping* Extensions_Mapping::release_type_mapping() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.type_mapping) - if (_internal_has_type_mapping()) { +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::release_extension_type_variation() { + // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) + if (_internal_has_extension_type_variation()) { clear_has_mapping_type(); - ::io::substrait::Extensions_Mapping_TypeMapping* temp = mapping_type_.type_mapping_; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - mapping_type_.type_mapping_ = nullptr; + mapping_type_.extension_type_variation_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Extensions_Mapping_TypeMapping& Extensions_Mapping::_internal_type_mapping() const { - return _internal_has_type_mapping() - ? *mapping_type_.type_mapping_ - : reinterpret_cast< ::io::substrait::Extensions_Mapping_TypeMapping&>(::io::substrait::_Extensions_Mapping_TypeMapping_default_instance_); +inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& SimpleExtensionDeclaration::_internal_extension_type_variation() const { + return _internal_has_extension_type_variation() + ? *mapping_type_.extension_type_variation_ + : reinterpret_cast< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation&>(::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_); } -inline const ::io::substrait::Extensions_Mapping_TypeMapping& Extensions_Mapping::type_mapping() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.type_mapping) - return _internal_type_mapping(); +inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& SimpleExtensionDeclaration::extension_type_variation() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) + return _internal_extension_type_variation(); } -inline ::io::substrait::Extensions_Mapping_TypeMapping* Extensions_Mapping::unsafe_arena_release_type_mapping() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Extensions.Mapping.type_mapping) - if (_internal_has_type_mapping()) { +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::unsafe_arena_release_extension_type_variation() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) + if (_internal_has_extension_type_variation()) { clear_has_mapping_type(); - ::io::substrait::Extensions_Mapping_TypeMapping* temp = mapping_type_.type_mapping_; - mapping_type_.type_mapping_ = nullptr; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_; + mapping_type_.extension_type_variation_ = nullptr; return temp; } else { return nullptr; } } -inline void Extensions_Mapping::unsafe_arena_set_allocated_type_mapping(::io::substrait::Extensions_Mapping_TypeMapping* type_mapping) { +inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_type_variation(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) { clear_mapping_type(); - if (type_mapping) { - set_has_type_mapping(); - mapping_type_.type_mapping_ = type_mapping; + if (extension_type_variation) { + set_has_extension_type_variation(); + mapping_type_.extension_type_variation_ = extension_type_variation; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.type_mapping) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) } -inline ::io::substrait::Extensions_Mapping_TypeMapping* Extensions_Mapping::_internal_mutable_type_mapping() { - if (!_internal_has_type_mapping()) { +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::_internal_mutable_extension_type_variation() { + if (!_internal_has_extension_type_variation()) { clear_mapping_type(); - set_has_type_mapping(); - mapping_type_.type_mapping_ = CreateMaybeMessage< ::io::substrait::Extensions_Mapping_TypeMapping >(GetArena()); + set_has_extension_type_variation(); + mapping_type_.extension_type_variation_ = CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(GetArena()); } - return mapping_type_.type_mapping_; + return mapping_type_.extension_type_variation_; } -inline ::io::substrait::Extensions_Mapping_TypeMapping* Extensions_Mapping::mutable_type_mapping() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.type_mapping) - return _internal_mutable_type_mapping(); +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::mutable_extension_type_variation() { + // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) + return _internal_mutable_extension_type_variation(); } -// .io.substrait.Extensions.Mapping.FunctionMapping function_mapping = 2; -inline bool Extensions_Mapping::_internal_has_function_mapping() const { - return mapping_type_case() == kFunctionMapping; +// .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; +inline bool SimpleExtensionDeclaration::_internal_has_extension_function() const { + return mapping_type_case() == kExtensionFunction; } -inline bool Extensions_Mapping::has_function_mapping() const { - return _internal_has_function_mapping(); +inline bool SimpleExtensionDeclaration::has_extension_function() const { + return _internal_has_extension_function(); } -inline void Extensions_Mapping::set_has_function_mapping() { - _oneof_case_[0] = kFunctionMapping; +inline void SimpleExtensionDeclaration::set_has_extension_function() { + _oneof_case_[0] = kExtensionFunction; } -inline void Extensions_Mapping::clear_function_mapping() { - if (_internal_has_function_mapping()) { +inline void SimpleExtensionDeclaration::clear_extension_function() { + if (_internal_has_extension_function()) { if (GetArena() == nullptr) { - delete mapping_type_.function_mapping_; + delete mapping_type_.extension_function_; } clear_has_mapping_type(); } } -inline ::io::substrait::Extensions_Mapping_FunctionMapping* Extensions_Mapping::release_function_mapping() { - // @@protoc_insertion_point(field_release:io.substrait.Extensions.Mapping.function_mapping) - if (_internal_has_function_mapping()) { +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::release_extension_function() { + // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) + if (_internal_has_extension_function()) { clear_has_mapping_type(); - ::io::substrait::Extensions_Mapping_FunctionMapping* temp = mapping_type_.function_mapping_; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - mapping_type_.function_mapping_ = nullptr; + mapping_type_.extension_function_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Extensions_Mapping_FunctionMapping& Extensions_Mapping::_internal_function_mapping() const { - return _internal_has_function_mapping() - ? *mapping_type_.function_mapping_ - : reinterpret_cast< ::io::substrait::Extensions_Mapping_FunctionMapping&>(::io::substrait::_Extensions_Mapping_FunctionMapping_default_instance_); +inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& SimpleExtensionDeclaration::_internal_extension_function() const { + return _internal_has_extension_function() + ? *mapping_type_.extension_function_ + : reinterpret_cast< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction&>(::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_); } -inline const ::io::substrait::Extensions_Mapping_FunctionMapping& Extensions_Mapping::function_mapping() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.Mapping.function_mapping) - return _internal_function_mapping(); +inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& SimpleExtensionDeclaration::extension_function() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) + return _internal_extension_function(); } -inline ::io::substrait::Extensions_Mapping_FunctionMapping* Extensions_Mapping::unsafe_arena_release_function_mapping() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Extensions.Mapping.function_mapping) - if (_internal_has_function_mapping()) { +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::unsafe_arena_release_extension_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) + if (_internal_has_extension_function()) { clear_has_mapping_type(); - ::io::substrait::Extensions_Mapping_FunctionMapping* temp = mapping_type_.function_mapping_; - mapping_type_.function_mapping_ = nullptr; + ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_; + mapping_type_.extension_function_ = nullptr; return temp; } else { return nullptr; } } -inline void Extensions_Mapping::unsafe_arena_set_allocated_function_mapping(::io::substrait::Extensions_Mapping_FunctionMapping* function_mapping) { +inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_function(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) { clear_mapping_type(); - if (function_mapping) { - set_has_function_mapping(); - mapping_type_.function_mapping_ = function_mapping; + if (extension_function) { + set_has_extension_function(); + mapping_type_.extension_function_ = extension_function; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Extensions.Mapping.function_mapping) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) } -inline ::io::substrait::Extensions_Mapping_FunctionMapping* Extensions_Mapping::_internal_mutable_function_mapping() { - if (!_internal_has_function_mapping()) { +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::_internal_mutable_extension_function() { + if (!_internal_has_extension_function()) { clear_mapping_type(); - set_has_function_mapping(); - mapping_type_.function_mapping_ = CreateMaybeMessage< ::io::substrait::Extensions_Mapping_FunctionMapping >(GetArena()); + set_has_extension_function(); + mapping_type_.extension_function_ = CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(GetArena()); } - return mapping_type_.function_mapping_; + return mapping_type_.extension_function_; } -inline ::io::substrait::Extensions_Mapping_FunctionMapping* Extensions_Mapping::mutable_function_mapping() { - // @@protoc_insertion_point(field_mutable:io.substrait.Extensions.Mapping.function_mapping) - return _internal_mutable_function_mapping(); +inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::mutable_extension_function() { + // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) + return _internal_mutable_extension_function(); } -inline bool Extensions_Mapping::has_mapping_type() const { +inline bool SimpleExtensionDeclaration::has_mapping_type() const { return mapping_type_case() != MAPPING_TYPE_NOT_SET; } -inline void Extensions_Mapping::clear_has_mapping_type() { +inline void SimpleExtensionDeclaration::clear_has_mapping_type() { _oneof_case_[0] = MAPPING_TYPE_NOT_SET; } -inline Extensions_Mapping::MappingTypeCase Extensions_Mapping::mapping_type_case() const { - return Extensions_Mapping::MappingTypeCase(_oneof_case_[0]); +inline SimpleExtensionDeclaration::MappingTypeCase SimpleExtensionDeclaration::mapping_type_case() const { + return SimpleExtensionDeclaration::MappingTypeCase(_oneof_case_[0]); } // ------------------------------------------------------------------- -// Extensions_ExtensionId +// AdvancedExtension -// uint32 id = 1; -inline void Extensions_ExtensionId::clear_id() { - id_ = 0u; +// .google.protobuf.Any optimization = 1; +inline bool AdvancedExtension::_internal_has_optimization() const { + return this != internal_default_instance() && optimization_ != nullptr; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Extensions_ExtensionId::_internal_id() const { - return id_; +inline bool AdvancedExtension::has_optimization() const { + return _internal_has_optimization(); } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Extensions_ExtensionId::id() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.ExtensionId.id) - return _internal_id(); +inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_optimization() const { + const PROTOBUF_NAMESPACE_ID::Any* p = optimization_; + return p != nullptr ? *p : reinterpret_cast( + PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } -inline void Extensions_ExtensionId::_internal_set_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { - - id_ = value; -} -inline void Extensions_ExtensionId::set_id(::PROTOBUF_NAMESPACE_ID::uint32 value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:io.substrait.Extensions.ExtensionId.id) +inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::optimization() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.AdvancedExtension.optimization) + return _internal_optimization(); } - -// ------------------------------------------------------------------- - -// Extensions_FunctionId - -// uint64 id = 1; -inline void Extensions_FunctionId::clear_id() { - id_ = PROTOBUF_ULONGLONG(0); +inline void AdvancedExtension::unsafe_arena_set_allocated_optimization( + PROTOBUF_NAMESPACE_ID::Any* optimization) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_); + } + optimization_ = optimization; + if (optimization) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.extensions.AdvancedExtension.optimization) } -inline ::PROTOBUF_NAMESPACE_ID::uint64 Extensions_FunctionId::_internal_id() const { - return id_; +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_optimization() { + + PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; + optimization_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 Extensions_FunctionId::id() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.FunctionId.id) - return _internal_id(); +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_optimization() { + // @@protoc_insertion_point(field_release:io.substrait.extensions.AdvancedExtension.optimization) + + PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; + optimization_ = nullptr; + return temp; } -inline void Extensions_FunctionId::_internal_set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_optimization() { - id_ = value; + if (optimization_ == nullptr) { + auto* p = CreateMaybeMessage(GetArena()); + optimization_ = p; + } + return optimization_; } -inline void Extensions_FunctionId::set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:io.substrait.Extensions.FunctionId.id) +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_optimization() { + // @@protoc_insertion_point(field_mutable:io.substrait.extensions.AdvancedExtension.optimization) + return _internal_mutable_optimization(); +} +inline void AdvancedExtension::set_allocated_optimization(PROTOBUF_NAMESPACE_ID::Any* optimization) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_); + } + if (optimization) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization)->GetArena(); + if (message_arena != submessage_arena) { + optimization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, optimization, submessage_arena); + } + + } else { + + } + optimization_ = optimization; + // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.AdvancedExtension.optimization) } -// ------------------------------------------------------------------- - -// Extensions_TypeId - -// uint64 id = 1; -inline void Extensions_TypeId::clear_id() { - id_ = PROTOBUF_ULONGLONG(0); +// .google.protobuf.Any enhancement = 2; +inline bool AdvancedExtension::_internal_has_enhancement() const { + return this != internal_default_instance() && enhancement_ != nullptr; +} +inline bool AdvancedExtension::has_enhancement() const { + return _internal_has_enhancement(); +} +inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_enhancement() const { + const PROTOBUF_NAMESPACE_ID::Any* p = enhancement_; + return p != nullptr ? *p : reinterpret_cast( + PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +} +inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::enhancement() const { + // @@protoc_insertion_point(field_get:io.substrait.extensions.AdvancedExtension.enhancement) + return _internal_enhancement(); +} +inline void AdvancedExtension::unsafe_arena_set_allocated_enhancement( + PROTOBUF_NAMESPACE_ID::Any* enhancement) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_); + } + enhancement_ = enhancement; + if (enhancement) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.extensions.AdvancedExtension.enhancement) } -inline ::PROTOBUF_NAMESPACE_ID::uint64 Extensions_TypeId::_internal_id() const { - return id_; +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_enhancement() { + + PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; + enhancement_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 Extensions_TypeId::id() const { - // @@protoc_insertion_point(field_get:io.substrait.Extensions.TypeId.id) - return _internal_id(); +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_enhancement() { + // @@protoc_insertion_point(field_release:io.substrait.extensions.AdvancedExtension.enhancement) + + PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; + enhancement_ = nullptr; + return temp; } -inline void Extensions_TypeId::_internal_set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_enhancement() { - id_ = value; + if (enhancement_ == nullptr) { + auto* p = CreateMaybeMessage(GetArena()); + enhancement_ = p; + } + return enhancement_; } -inline void Extensions_TypeId::set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:io.substrait.Extensions.TypeId.id) +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_enhancement() { + // @@protoc_insertion_point(field_mutable:io.substrait.extensions.AdvancedExtension.enhancement) + return _internal_mutable_enhancement(); +} +inline void AdvancedExtension::set_allocated_enhancement(PROTOBUF_NAMESPACE_ID::Any* enhancement) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_); + } + if (enhancement) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement)->GetArena(); + if (message_arena != submessage_arena) { + enhancement = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, enhancement, submessage_arena); + } + + } else { + + } + enhancement_ = enhancement; + // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.AdvancedExtension.enhancement) } - -// ------------------------------------------------------------------- - -// Extensions #ifdef __GNUC__ #pragma GCC diagnostic pop @@ -2963,19 +1822,10 @@ inline void Extensions_TypeId::set_id(::PROTOBUF_NAMESPACE_ID::uint64 value) { // ------------------------------------------------------------------- -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - // @@protoc_insertion_point(namespace_scope) +} // namespace extensions } // namespace substrait } // namespace io diff --git a/cpp/src/generated/substrait/function.pb.cc b/cpp/src/generated/substrait/function.pb.cc index f3ba8054b1d..6e561b86474 100644 --- a/cpp/src/generated/substrait/function.pb.cc +++ b/cpp/src/generated/substrait/function.pb.cc @@ -49,7 +49,6 @@ constexpr FunctionSignature_Scalar::FunctionSignature_Scalar( : arguments_() , name_() , implementations_() - , id_(nullptr) , description_(nullptr) , output_type_(nullptr) , deterministic_(false) @@ -67,16 +66,15 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ScalarDefault constexpr FunctionSignature_Aggregate::FunctionSignature_Aggregate( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : arguments_() - , name_() , implementations_() - , id_(nullptr) + , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) , description_(nullptr) , output_type_(nullptr) , intermediate_type_(nullptr) - , max_set_(PROTOBUF_ULONGLONG(0)) , deterministic_(false) , session_dependent_(false) , ordered_(false) + , max_set_(PROTOBUF_ULONGLONG(0)) , _oneof_case_{}{} struct FunctionSignature_AggregateDefaultTypeInternal { constexpr FunctionSignature_AggregateDefaultTypeInternal() @@ -92,7 +90,6 @@ constexpr FunctionSignature_Window::FunctionSignature_Window( : arguments_() , name_() , implementations_() - , id_(nullptr) , description_(nullptr) , intermediate_type_(nullptr) , output_type_(nullptr) @@ -226,7 +223,6 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_function_2eproto::offsets[] PR ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, id_), PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, arguments_), PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, name_), PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, description_), @@ -242,7 +238,6 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_function_2eproto::offsets[] PR ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, id_), PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, arguments_), PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, name_), PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, description_), @@ -261,7 +256,6 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_function_2eproto::offsets[] PR ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, id_), PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, arguments_), PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, name_), PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, description_), @@ -330,15 +324,15 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 0, -1, sizeof(::io::substrait::FunctionSignature_FinalArgVariadic)}, { 8, -1, sizeof(::io::substrait::FunctionSignature_FinalArgNormal)}, { 13, -1, sizeof(::io::substrait::FunctionSignature_Scalar)}, - { 29, -1, sizeof(::io::substrait::FunctionSignature_Aggregate)}, - { 48, -1, sizeof(::io::substrait::FunctionSignature_Window)}, - { 68, -1, sizeof(::io::substrait::FunctionSignature_Description)}, - { 75, -1, sizeof(::io::substrait::FunctionSignature_Implementation)}, - { 82, -1, sizeof(::io::substrait::FunctionSignature_Argument_ValueArgument)}, - { 89, -1, sizeof(::io::substrait::FunctionSignature_Argument_TypeArgument)}, - { 95, -1, sizeof(::io::substrait::FunctionSignature_Argument_EnumArgument)}, - { 102, -1, sizeof(::io::substrait::FunctionSignature_Argument)}, - { 112, -1, sizeof(::io::substrait::FunctionSignature)}, + { 28, -1, sizeof(::io::substrait::FunctionSignature_Aggregate)}, + { 46, -1, sizeof(::io::substrait::FunctionSignature_Window)}, + { 65, -1, sizeof(::io::substrait::FunctionSignature_Description)}, + { 72, -1, sizeof(::io::substrait::FunctionSignature_Implementation)}, + { 79, -1, sizeof(::io::substrait::FunctionSignature_Argument_ValueArgument)}, + { 86, -1, sizeof(::io::substrait::FunctionSignature_Argument_TypeArgument)}, + { 92, -1, sizeof(::io::substrait::FunctionSignature_Argument_EnumArgument)}, + { 99, -1, sizeof(::io::substrait::FunctionSignature_Argument)}, + { 109, -1, sizeof(::io::substrait::FunctionSignature)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -359,91 +353,86 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = const char descriptor_table_protodef_function_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\016function.proto\022\014io.substrait\032\ntype.pro" "to\032\031parameterized_types.proto\032\026type_expr" - "essions.proto\032\020extensions.proto\"\246\026\n\021Func" - "tionSignature\032\331\001\n\020FinalArgVariadic\022\020\n\010mi" - "n_args\030\001 \001(\003\022\020\n\010max_args\030\002 \001(\003\022Z\n\013consis" - "tency\030\003 \001(\0162E.io.substrait.FunctionSigna" - "ture.FinalArgVariadic.ParameterConsisten" - "cy\"E\n\024ParameterConsistency\022\013\n\007UNKNOWN\020\000\022" - "\016\n\nCONSISTENT\020\001\022\020\n\014INCONSISTENT\020\002\032\020\n\016Fin" - "alArgNormal\032\235\004\n\006Scalar\022/\n\002id\030\001 \001(\0132#.io." - "substrait.Extensions.FunctionId\022;\n\targum" - "ents\030\002 \003(\0132(.io.substrait.FunctionSignat" - "ure.Argument\022\014\n\004name\030\003 \003(\t\022@\n\013descriptio" - "n\030\004 \001(\0132+.io.substrait.FunctionSignature" - ".Description\022\025\n\rdeterministic\030\007 \001(\010\022\031\n\021s" - "ession_dependent\030\010 \001(\010\0227\n\013output_type\030\t " - "\001(\0132\".io.substrait.DerivationExpression\022" - "D\n\010variadic\030\n \001(\01320.io.substrait.Functio" - "nSignature.FinalArgVariadicH\000\022@\n\006normal\030" - "\013 \001(\0132..io.substrait.FunctionSignature.F" - "inalArgNormalH\000\022G\n\017implementations\030\014 \003(\013" - "2..io.substrait.FunctionSignature.Implem" - "entationB\031\n\027final_variable_behavior\032\361\004\n\t" - "Aggregate\022/\n\002id\030\001 \001(\0132#.io.substrait.Ext" - "ensions.FunctionId\022;\n\targuments\030\002 \003(\0132(." - "io.substrait.FunctionSignature.Argument\022" - "\014\n\004name\030\003 \003(\t\022@\n\013description\030\004 \001(\0132+.io." - "substrait.FunctionSignature.Description\022" - "\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_depend" - "ent\030\010 \001(\010\0227\n\013output_type\030\t \001(\0132\".io.subs" - "trait.DerivationExpression\022D\n\010variadic\030\n" - " \001(\01320.io.substrait.FunctionSignature.Fi" - "nalArgVariadicH\000\022@\n\006normal\030\013 \001(\0132..io.su" - "bstrait.FunctionSignature.FinalArgNormal" - "H\000\022\017\n\007ordered\030\016 \001(\010\022\017\n\007max_set\030\014 \001(\004\022-\n\021" - "intermediate_type\030\r \001(\0132\022.io.substrait.T" - "ype\022G\n\017implementations\030\017 \003(\0132..io.substr" - "ait.FunctionSignature.ImplementationB\031\n\027" - "final_variable_behavior\032\377\005\n\006Window\022/\n\002id" - "\030\001 \001(\0132#.io.substrait.Extensions.Functio" - "nId\022;\n\targuments\030\002 \003(\0132(.io.substrait.Fu" - "nctionSignature.Argument\022\014\n\004name\030\003 \003(\t\022@" - "\n\013description\030\004 \001(\0132+.io.substrait.Funct" - "ionSignature.Description\022\025\n\rdeterministi" - "c\030\007 \001(\010\022\031\n\021session_dependent\030\010 \001(\010\022=\n\021in" - "termediate_type\030\t \001(\0132\".io.substrait.Der" - "ivationExpression\0227\n\013output_type\030\n \001(\0132\"" - ".io.substrait.DerivationExpression\022D\n\010va" - "riadic\030\020 \001(\01320.io.substrait.FunctionSign" - "ature.FinalArgVariadicH\000\022@\n\006normal\030\021 \001(\013" - "2..io.substrait.FunctionSignature.FinalA" - "rgNormalH\000\022\017\n\007ordered\030\013 \001(\010\022\017\n\007max_set\030\014" - " \001(\004\022F\n\013window_type\030\016 \001(\01621.io.substrait" - ".FunctionSignature.Window.WindowType\022G\n\017" - "implementations\030\017 \003(\0132..io.substrait.Fun" - "ctionSignature.Implementation\"7\n\nWindowT" - "ype\022\013\n\007UNKNOWN\020\000\022\r\n\tSTREAMING\020\001\022\r\n\tPARTI" - "TION\020\002B\031\n\027final_variable_behavior\032-\n\013Des" - "cription\022\020\n\010language\030\001 \001(\t\022\014\n\004body\030\002 \001(\t" - "\032\226\001\n\016Implementation\022A\n\004type\030\001 \001(\01623.io.s" - "ubstrait.FunctionSignature.Implementatio" - "n.Type\022\013\n\003uri\030\002 \001(\t\"4\n\004Type\022\013\n\007UNKNOWN\020\000" - "\022\020\n\014WEB_ASSEMBLY\020\001\022\r\n\tTRINO_JAR\020\002\032\304\003\n\010Ar" - "gument\022\014\n\004name\030\001 \001(\t\022G\n\005value\030\002 \001(\01326.io" - ".substrait.FunctionSignature.Argument.Va" - "lueArgumentH\000\022E\n\004type\030\003 \001(\01325.io.substra" - "it.FunctionSignature.Argument.TypeArgume" - "ntH\000\022E\n\004enum\030\004 \001(\01325.io.substrait.Functi" - "onSignature.Argument.EnumArgumentH\000\032P\n\rV" - "alueArgument\022-\n\004type\030\001 \001(\0132\037.io.substrai" - "t.ParameterizedType\022\020\n\010constant\030\002 \001(\010\032=\n" - "\014TypeArgument\022-\n\004type\030\001 \001(\0132\037.io.substra" - "it.ParameterizedType\0321\n\014EnumArgument\022\017\n\007" - "options\030\001 \003(\t\022\020\n\010optional\030\002 \001(\010B\017\n\rargum" - "ent_kindB\027P\001\252\002\022Substrait.Protobufb\006proto" - "3" + "essions.proto\"\223\025\n\021FunctionSignature\032\331\001\n\020" + "FinalArgVariadic\022\020\n\010min_args\030\001 \001(\003\022\020\n\010ma" + "x_args\030\002 \001(\003\022Z\n\013consistency\030\003 \001(\0162E.io.s" + "ubstrait.FunctionSignature.FinalArgVaria" + "dic.ParameterConsistency\"E\n\024ParameterCon" + "sistency\022\013\n\007UNKNOWN\020\000\022\016\n\nCONSISTENT\020\001\022\020\n" + "\014INCONSISTENT\020\002\032\020\n\016FinalArgNormal\032\354\003\n\006Sc" + "alar\022;\n\targuments\030\002 \003(\0132(.io.substrait.F" + "unctionSignature.Argument\022\014\n\004name\030\003 \003(\t\022" + "@\n\013description\030\004 \001(\0132+.io.substrait.Func" + "tionSignature.Description\022\025\n\rdeterminist" + "ic\030\007 \001(\010\022\031\n\021session_dependent\030\010 \001(\010\0227\n\013o" + "utput_type\030\t \001(\0132\".io.substrait.Derivati" + "onExpression\022D\n\010variadic\030\n \001(\01320.io.subs" + "trait.FunctionSignature.FinalArgVariadic" + "H\000\022@\n\006normal\030\013 \001(\0132..io.substrait.Functi" + "onSignature.FinalArgNormalH\000\022G\n\017implemen" + "tations\030\014 \003(\0132..io.substrait.FunctionSig" + "nature.ImplementationB\031\n\027final_variable_" + "behavior\032\300\004\n\tAggregate\022;\n\targuments\030\002 \003(" + "\0132(.io.substrait.FunctionSignature.Argum" + "ent\022\014\n\004name\030\003 \001(\t\022@\n\013description\030\004 \001(\0132+" + ".io.substrait.FunctionSignature.Descript" + "ion\022\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_de" + "pendent\030\010 \001(\010\0227\n\013output_type\030\t \001(\0132\".io." + "substrait.DerivationExpression\022D\n\010variad" + "ic\030\n \001(\01320.io.substrait.FunctionSignatur" + "e.FinalArgVariadicH\000\022@\n\006normal\030\013 \001(\0132..i" + "o.substrait.FunctionSignature.FinalArgNo" + "rmalH\000\022\017\n\007ordered\030\016 \001(\010\022\017\n\007max_set\030\014 \001(\004" + "\022-\n\021intermediate_type\030\r \001(\0132\022.io.substra" + "it.Type\022G\n\017implementations\030\017 \003(\0132..io.su" + "bstrait.FunctionSignature.Implementation" + "B\031\n\027final_variable_behavior\032\316\005\n\006Window\022;" + "\n\targuments\030\002 \003(\0132(.io.substrait.Functio" + "nSignature.Argument\022\014\n\004name\030\003 \003(\t\022@\n\013des" + "cription\030\004 \001(\0132+.io.substrait.FunctionSi" + "gnature.Description\022\025\n\rdeterministic\030\007 \001" + "(\010\022\031\n\021session_dependent\030\010 \001(\010\022=\n\021interme" + "diate_type\030\t \001(\0132\".io.substrait.Derivati" + "onExpression\0227\n\013output_type\030\n \001(\0132\".io.s" + "ubstrait.DerivationExpression\022D\n\010variadi" + "c\030\020 \001(\01320.io.substrait.FunctionSignature" + ".FinalArgVariadicH\000\022@\n\006normal\030\021 \001(\0132..io" + ".substrait.FunctionSignature.FinalArgNor" + "malH\000\022\017\n\007ordered\030\013 \001(\010\022\017\n\007max_set\030\014 \001(\004\022" + "F\n\013window_type\030\016 \001(\01621.io.substrait.Func" + "tionSignature.Window.WindowType\022G\n\017imple" + "mentations\030\017 \003(\0132..io.substrait.Function" + "Signature.Implementation\"7\n\nWindowType\022\013" + "\n\007UNKNOWN\020\000\022\r\n\tSTREAMING\020\001\022\r\n\tPARTITION\020" + "\002B\031\n\027final_variable_behavior\032-\n\013Descript" + "ion\022\020\n\010language\030\001 \001(\t\022\014\n\004body\030\002 \001(\t\032\226\001\n\016" + "Implementation\022A\n\004type\030\001 \001(\01623.io.substr" + "ait.FunctionSignature.Implementation.Typ" + "e\022\013\n\003uri\030\002 \001(\t\"4\n\004Type\022\013\n\007UNKNOWN\020\000\022\020\n\014W" + "EB_ASSEMBLY\020\001\022\r\n\tTRINO_JAR\020\002\032\304\003\n\010Argumen" + "t\022\014\n\004name\030\001 \001(\t\022G\n\005value\030\002 \001(\01326.io.subs" + "trait.FunctionSignature.Argument.ValueAr" + "gumentH\000\022E\n\004type\030\003 \001(\01325.io.substrait.Fu" + "nctionSignature.Argument.TypeArgumentH\000\022" + "E\n\004enum\030\004 \001(\01325.io.substrait.FunctionSig" + "nature.Argument.EnumArgumentH\000\032P\n\rValueA" + "rgument\022-\n\004type\030\001 \001(\0132\037.io.substrait.Par" + "ameterizedType\022\020\n\010constant\030\002 \001(\010\032=\n\014Type" + "Argument\022-\n\004type\030\001 \001(\0132\037.io.substrait.Pa" + "rameterizedType\0321\n\014EnumArgument\022\017\n\007optio" + "ns\030\001 \003(\t\022\020\n\010optional\030\002 \001(\010B\017\n\rargument_k" + "indB+\n\022io.substrait.protoP\001\252\002\022Substrait." + "Protobufb\006proto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_function_2eproto_deps[4] = { - &::descriptor_table_extensions_2eproto, +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_function_2eproto_deps[3] = { &::descriptor_table_parameterized_5ftypes_2eproto, &::descriptor_table_type_2eproto, &::descriptor_table_type_5fexpressions_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_function_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_function_2eproto = { - false, false, 3001, descriptor_table_protodef_function_2eproto, "function.proto", - &descriptor_table_function_2eproto_once, descriptor_table_function_2eproto_deps, 4, 12, + false, false, 2856, descriptor_table_protodef_function_2eproto, "function.proto", + &descriptor_table_function_2eproto_once, descriptor_table_function_2eproto_deps, 3, 12, schemas, file_default_instances, TableStruct_function_2eproto::offsets, file_level_metadata_function_2eproto, file_level_enum_descriptors_function_2eproto, file_level_service_descriptors_function_2eproto, }; @@ -936,17 +925,12 @@ ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgNormal::GetMetadata( class FunctionSignature_Scalar::_Internal { public: - static const ::io::substrait::Extensions_FunctionId& id(const FunctionSignature_Scalar* msg); static const ::io::substrait::FunctionSignature_Description& description(const FunctionSignature_Scalar* msg); static const ::io::substrait::DerivationExpression& output_type(const FunctionSignature_Scalar* msg); static const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Scalar* msg); static const ::io::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Scalar* msg); }; -const ::io::substrait::Extensions_FunctionId& -FunctionSignature_Scalar::_Internal::id(const FunctionSignature_Scalar* msg) { - return *msg->id_; -} const ::io::substrait::FunctionSignature_Description& FunctionSignature_Scalar::_Internal::description(const FunctionSignature_Scalar* msg) { return *msg->description_; @@ -963,12 +947,6 @@ const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::_Internal::normal(const FunctionSignature_Scalar* msg) { return *msg->final_variable_behavior_.normal_; } -void FunctionSignature_Scalar::clear_id() { - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; -} void FunctionSignature_Scalar::clear_output_type() { if (GetArena() == nullptr && output_type_ != nullptr) { delete output_type_; @@ -1020,11 +998,6 @@ FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scala name_(from.name_), implementations_(from.implementations_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_id()) { - id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); - } else { - id_ = nullptr; - } if (from._internal_has_description()) { description_ = new ::io::substrait::FunctionSignature_Description(*from.description_); } else { @@ -1057,9 +1030,9 @@ FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scala void FunctionSignature_Scalar::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&id_) - reinterpret_cast(this)), + reinterpret_cast(&description_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&session_dependent_) - - reinterpret_cast(&id_)) + sizeof(session_dependent_)); + reinterpret_cast(&description_)) + sizeof(session_dependent_)); clear_has_final_variable_behavior(); } @@ -1071,7 +1044,6 @@ FunctionSignature_Scalar::~FunctionSignature_Scalar() { void FunctionSignature_Scalar::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete id_; if (this != internal_default_instance()) delete description_; if (this != internal_default_instance()) delete output_type_; if (has_final_variable_behavior()) { @@ -1121,10 +1093,6 @@ void FunctionSignature_Scalar::Clear() { arguments_.Clear(); name_.Clear(); implementations_.Clear(); - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; if (GetArena() == nullptr && description_ != nullptr) { delete description_; } @@ -1146,13 +1114,6 @@ const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Extensions.FunctionId id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; // repeated .io.substrait.FunctionSignature.Argument arguments = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { @@ -1262,14 +1223,6 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::id(this), target, stream); - } - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; for (unsigned int i = 0, n = static_cast(this->_internal_arguments_size()); i < n; i++) { @@ -1378,13 +1331,6 @@ size_t FunctionSignature_Scalar::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *id_); - } - // .io.substrait.FunctionSignature.Description description = 4; if (this->has_description()) { total_size += 1 + @@ -1462,9 +1408,6 @@ void FunctionSignature_Scalar::MergeFrom(const FunctionSignature_Scalar& from) { arguments_.MergeFrom(from.arguments_); name_.MergeFrom(from.name_); implementations_.MergeFrom(from.implementations_); - if (from.has_id()) { - _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); - } if (from.has_description()) { _internal_mutable_description()->::io::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); } @@ -1519,9 +1462,9 @@ void FunctionSignature_Scalar::InternalSwap(FunctionSignature_Scalar* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, session_dependent_) + sizeof(FunctionSignature_Scalar::session_dependent_) - - PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, id_)>( - reinterpret_cast(&id_), - reinterpret_cast(&other->id_)); + - PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, description_)>( + reinterpret_cast(&description_), + reinterpret_cast(&other->description_)); swap(final_variable_behavior_, other->final_variable_behavior_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -1536,7 +1479,6 @@ ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Scalar::GetMetadata() const class FunctionSignature_Aggregate::_Internal { public: - static const ::io::substrait::Extensions_FunctionId& id(const FunctionSignature_Aggregate* msg); static const ::io::substrait::FunctionSignature_Description& description(const FunctionSignature_Aggregate* msg); static const ::io::substrait::DerivationExpression& output_type(const FunctionSignature_Aggregate* msg); static const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Aggregate* msg); @@ -1544,10 +1486,6 @@ class FunctionSignature_Aggregate::_Internal { static const ::io::substrait::Type& intermediate_type(const FunctionSignature_Aggregate* msg); }; -const ::io::substrait::Extensions_FunctionId& -FunctionSignature_Aggregate::_Internal::id(const FunctionSignature_Aggregate* msg) { - return *msg->id_; -} const ::io::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::_Internal::description(const FunctionSignature_Aggregate* msg) { return *msg->description_; @@ -1568,12 +1506,6 @@ const ::io::substrait::Type& FunctionSignature_Aggregate::_Internal::intermediate_type(const FunctionSignature_Aggregate* msg) { return *msg->intermediate_type_; } -void FunctionSignature_Aggregate::clear_id() { - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; -} void FunctionSignature_Aggregate::clear_output_type() { if (GetArena() == nullptr && output_type_ != nullptr) { delete output_type_; @@ -1619,7 +1551,6 @@ void FunctionSignature_Aggregate::clear_intermediate_type() { FunctionSignature_Aggregate::FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), arguments_(arena), - name_(arena), implementations_(arena) { SharedCtor(); RegisterArenaDtor(arena); @@ -1628,13 +1559,12 @@ FunctionSignature_Aggregate::FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from) : ::PROTOBUF_NAMESPACE_ID::Message(), arguments_(from.arguments_), - name_(from.name_), implementations_(from.implementations_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_id()) { - id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); - } else { - id_ = nullptr; + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); } if (from._internal_has_description()) { description_ = new ::io::substrait::FunctionSignature_Description(*from.description_); @@ -1651,9 +1581,9 @@ FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature } else { intermediate_type_ = nullptr; } - ::memcpy(&max_set_, &from.max_set_, - static_cast(reinterpret_cast(&ordered_) - - reinterpret_cast(&max_set_)) + sizeof(ordered_)); + ::memcpy(&deterministic_, &from.deterministic_, + static_cast(reinterpret_cast(&max_set_) - + reinterpret_cast(&deterministic_)) + sizeof(max_set_)); clear_has_final_variable_behavior(); switch (from.final_variable_behavior_case()) { case kVariadic: { @@ -1672,10 +1602,11 @@ FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature } void FunctionSignature_Aggregate::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&id_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&ordered_) - - reinterpret_cast(&id_)) + sizeof(ordered_)); + reinterpret_cast(&description_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&max_set_) - + reinterpret_cast(&description_)) + sizeof(max_set_)); clear_has_final_variable_behavior(); } @@ -1687,7 +1618,7 @@ FunctionSignature_Aggregate::~FunctionSignature_Aggregate() { void FunctionSignature_Aggregate::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete id_; + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete description_; if (this != internal_default_instance()) delete output_type_; if (this != internal_default_instance()) delete intermediate_type_; @@ -1736,12 +1667,8 @@ void FunctionSignature_Aggregate::Clear() { (void) cached_has_bits; arguments_.Clear(); - name_.Clear(); implementations_.Clear(); - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; + name_.ClearToEmpty(); if (GetArena() == nullptr && description_ != nullptr) { delete description_; } @@ -1754,9 +1681,9 @@ void FunctionSignature_Aggregate::Clear() { delete intermediate_type_; } intermediate_type_ = nullptr; - ::memset(&max_set_, 0, static_cast( - reinterpret_cast(&ordered_) - - reinterpret_cast(&max_set_)) + sizeof(ordered_)); + ::memset(&deterministic_, 0, static_cast( + reinterpret_cast(&max_set_) - + reinterpret_cast(&deterministic_)) + sizeof(max_set_)); clear_final_variable_behavior(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1767,13 +1694,6 @@ const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Extensions.FunctionId id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; // repeated .io.substrait.FunctionSignature.Argument arguments = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { @@ -1786,18 +1706,13 @@ const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTO } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // repeated string name = 3; + // string name = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Aggregate.name")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Aggregate.name")); + CHK_(ptr); } else goto handle_unusual; continue; // .io.substrait.FunctionSignature.Description description = 4; @@ -1904,14 +1819,6 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::id(this), target, stream); - } - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; for (unsigned int i = 0, n = static_cast(this->_internal_arguments_size()); i < n; i++) { @@ -1920,14 +1827,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( InternalWriteMessage(2, this->_internal_arguments(i), target, stream); } - // repeated string name = 3; - for (int i = 0, n = this->_internal_name_size(); i < n; i++) { - const auto& s = this->_internal_name(i); + // string name = 3; + if (this->name().size() > 0) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), + this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, "io.substrait.FunctionSignature.Aggregate.name"); - target = stream->WriteString(3, s, target); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); } // .io.substrait.FunctionSignature.Description description = 4; @@ -2025,14 +1932,6 @@ size_t FunctionSignature_Aggregate::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated string name = 3; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(name_.size()); - for (int i = 0, n = name_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - name_.Get(i)); - } - // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; total_size += 1UL * this->_internal_implementations_size(); for (const auto& msg : this->implementations_) { @@ -2040,11 +1939,11 @@ size_t FunctionSignature_Aggregate::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { + // string name = 3; + if (this->name().size() > 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *id_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); } // .io.substrait.FunctionSignature.Description description = 4; @@ -2068,13 +1967,6 @@ size_t FunctionSignature_Aggregate::ByteSizeLong() const { *intermediate_type_); } - // uint64 max_set = 12; - if (this->max_set() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( - this->_internal_max_set()); - } - // bool deterministic = 7; if (this->deterministic() != 0) { total_size += 1 + 1; @@ -2090,6 +1982,13 @@ size_t FunctionSignature_Aggregate::ByteSizeLong() const { total_size += 1 + 1; } + // uint64 max_set = 12; + if (this->max_set() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_max_set()); + } + switch (final_variable_behavior_case()) { // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; case kVariadic: { @@ -2141,10 +2040,9 @@ void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& f (void) cached_has_bits; arguments_.MergeFrom(from.arguments_); - name_.MergeFrom(from.name_); implementations_.MergeFrom(from.implementations_); - if (from.has_id()) { - _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); } if (from.has_description()) { _internal_mutable_description()->::io::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); @@ -2155,9 +2053,6 @@ void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& f if (from.has_intermediate_type()) { _internal_mutable_intermediate_type()->::io::substrait::Type::MergeFrom(from._internal_intermediate_type()); } - if (from.max_set() != 0) { - _internal_set_max_set(from._internal_max_set()); - } if (from.deterministic() != 0) { _internal_set_deterministic(from._internal_deterministic()); } @@ -2167,6 +2062,9 @@ void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& f if (from.ordered() != 0) { _internal_set_ordered(from._internal_ordered()); } + if (from.max_set() != 0) { + _internal_set_max_set(from._internal_max_set()); + } switch (from.final_variable_behavior_case()) { case kVariadic: { _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); @@ -2204,14 +2102,14 @@ void FunctionSignature_Aggregate::InternalSwap(FunctionSignature_Aggregate* othe using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); arguments_.InternalSwap(&other->arguments_); - name_.InternalSwap(&other->name_); implementations_.InternalSwap(&other->implementations_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, ordered_) - + sizeof(FunctionSignature_Aggregate::ordered_) - - PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, id_)>( - reinterpret_cast(&id_), - reinterpret_cast(&other->id_)); + PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, max_set_) + + sizeof(FunctionSignature_Aggregate::max_set_) + - PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, description_)>( + reinterpret_cast(&description_), + reinterpret_cast(&other->description_)); swap(final_variable_behavior_, other->final_variable_behavior_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -2226,7 +2124,6 @@ ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Aggregate::GetMetadata() con class FunctionSignature_Window::_Internal { public: - static const ::io::substrait::Extensions_FunctionId& id(const FunctionSignature_Window* msg); static const ::io::substrait::FunctionSignature_Description& description(const FunctionSignature_Window* msg); static const ::io::substrait::DerivationExpression& intermediate_type(const FunctionSignature_Window* msg); static const ::io::substrait::DerivationExpression& output_type(const FunctionSignature_Window* msg); @@ -2234,10 +2131,6 @@ class FunctionSignature_Window::_Internal { static const ::io::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Window* msg); }; -const ::io::substrait::Extensions_FunctionId& -FunctionSignature_Window::_Internal::id(const FunctionSignature_Window* msg) { - return *msg->id_; -} const ::io::substrait::FunctionSignature_Description& FunctionSignature_Window::_Internal::description(const FunctionSignature_Window* msg) { return *msg->description_; @@ -2258,12 +2151,6 @@ const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::_Internal::normal(const FunctionSignature_Window* msg) { return *msg->final_variable_behavior_.normal_; } -void FunctionSignature_Window::clear_id() { - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; -} void FunctionSignature_Window::clear_intermediate_type() { if (GetArena() == nullptr && intermediate_type_ != nullptr) { delete intermediate_type_; @@ -2321,11 +2208,6 @@ FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Windo name_(from.name_), implementations_(from.implementations_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_id()) { - id_ = new ::io::substrait::Extensions_FunctionId(*from.id_); - } else { - id_ = nullptr; - } if (from._internal_has_description()) { description_ = new ::io::substrait::FunctionSignature_Description(*from.description_); } else { @@ -2363,9 +2245,9 @@ FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Windo void FunctionSignature_Window::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&id_) - reinterpret_cast(this)), + reinterpret_cast(&description_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&max_set_) - - reinterpret_cast(&id_)) + sizeof(max_set_)); + reinterpret_cast(&description_)) + sizeof(max_set_)); clear_has_final_variable_behavior(); } @@ -2377,7 +2259,6 @@ FunctionSignature_Window::~FunctionSignature_Window() { void FunctionSignature_Window::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete id_; if (this != internal_default_instance()) delete description_; if (this != internal_default_instance()) delete intermediate_type_; if (this != internal_default_instance()) delete output_type_; @@ -2428,10 +2309,6 @@ void FunctionSignature_Window::Clear() { arguments_.Clear(); name_.Clear(); implementations_.Clear(); - if (GetArena() == nullptr && id_ != nullptr) { - delete id_; - } - id_ = nullptr; if (GetArena() == nullptr && description_ != nullptr) { delete description_; } @@ -2457,13 +2334,6 @@ const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Extensions.FunctionId id = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_id(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; // repeated .io.substrait.FunctionSignature.Argument arguments = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { @@ -2602,14 +2472,6 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::id(this), target, stream); - } - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; for (unsigned int i = 0, n = static_cast(this->_internal_arguments_size()); i < n; i++) { @@ -2745,13 +2607,6 @@ size_t FunctionSignature_Window::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Extensions.FunctionId id = 1; - if (this->has_id()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *id_); - } - // .io.substrait.FunctionSignature.Description description = 4; if (this->has_description()) { total_size += 1 + @@ -2854,9 +2709,6 @@ void FunctionSignature_Window::MergeFrom(const FunctionSignature_Window& from) { arguments_.MergeFrom(from.arguments_); name_.MergeFrom(from.name_); implementations_.MergeFrom(from.implementations_); - if (from.has_id()) { - _internal_mutable_id()->::io::substrait::Extensions_FunctionId::MergeFrom(from._internal_id()); - } if (from.has_description()) { _internal_mutable_description()->::io::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); } @@ -2923,9 +2775,9 @@ void FunctionSignature_Window::InternalSwap(FunctionSignature_Window* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, max_set_) + sizeof(FunctionSignature_Window::max_set_) - - PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, id_)>( - reinterpret_cast(&id_), - reinterpret_cast(&other->id_)); + - PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, description_)>( + reinterpret_cast(&description_), + reinterpret_cast(&other->description_)); swap(final_variable_behavior_, other->final_variable_behavior_); swap(_oneof_case_[0], other->_oneof_case_[0]); } diff --git a/cpp/src/generated/substrait/function.pb.h b/cpp/src/generated/substrait/function.pb.h index 22add5bf953..319f5e995f6 100644 --- a/cpp/src/generated/substrait/function.pb.h +++ b/cpp/src/generated/substrait/function.pb.h @@ -35,7 +35,6 @@ #include "type.pb.h" #include "parameterized_types.pb.h" #include "type_expressions.pb.h" -#include "extensions.pb.h" // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_function_2eproto @@ -614,7 +613,6 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : kArgumentsFieldNumber = 2, kNameFieldNumber = 3, kImplementationsFieldNumber = 12, - kIdFieldNumber = 1, kDescriptionFieldNumber = 4, kOutputTypeFieldNumber = 9, kDeterministicFieldNumber = 7, @@ -682,24 +680,6 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& implementations() const; - // .io.substrait.Extensions.FunctionId id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const ::io::substrait::Extensions_FunctionId& id() const; - ::io::substrait::Extensions_FunctionId* release_id(); - ::io::substrait::Extensions_FunctionId* mutable_id(); - void set_allocated_id(::io::substrait::Extensions_FunctionId* id); - private: - const ::io::substrait::Extensions_FunctionId& _internal_id() const; - ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); - public: - void unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id); - ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); - // .io.substrait.FunctionSignature.Description description = 4; bool has_description() const; private: @@ -807,7 +787,6 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument > arguments_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField name_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation > implementations_; - ::io::substrait::Extensions_FunctionId* id_; ::io::substrait::FunctionSignature_Description* description_; ::io::substrait::DerivationExpression* output_type_; bool deterministic_; @@ -939,16 +918,15 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : enum : int { kArgumentsFieldNumber = 2, - kNameFieldNumber = 3, kImplementationsFieldNumber = 15, - kIdFieldNumber = 1, + kNameFieldNumber = 3, kDescriptionFieldNumber = 4, kOutputTypeFieldNumber = 9, kIntermediateTypeFieldNumber = 13, - kMaxSetFieldNumber = 12, kDeterministicFieldNumber = 7, kSessionDependentFieldNumber = 8, kOrderedFieldNumber = 14, + kMaxSetFieldNumber = 12, kVariadicFieldNumber = 10, kNormalFieldNumber = 11, }; @@ -970,30 +948,6 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& arguments() const; - // repeated string name = 3; - int name_size() const; - private: - int _internal_name_size() const; - public: - void clear_name(); - const std::string& name(int index) const; - std::string* mutable_name(int index); - void set_name(int index, const std::string& value); - void set_name(int index, std::string&& value); - void set_name(int index, const char* value); - void set_name(int index, const char* value, size_t size); - std::string* add_name(); - void add_name(const std::string& value); - void add_name(std::string&& value); - void add_name(const char* value); - void add_name(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& name() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_name(); - private: - const std::string& _internal_name(int index) const; - std::string* _internal_add_name(); - public: - // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; int implementations_size() const; private: @@ -1012,23 +966,19 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& implementations() const; - // .io.substrait.Extensions.FunctionId id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const ::io::substrait::Extensions_FunctionId& id() const; - ::io::substrait::Extensions_FunctionId* release_id(); - ::io::substrait::Extensions_FunctionId* mutable_id(); - void set_allocated_id(::io::substrait::Extensions_FunctionId* id); + // string name = 3; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); private: - const ::io::substrait::Extensions_FunctionId& _internal_id() const; - ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); public: - void unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id); - ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); // .io.substrait.FunctionSignature.Description description = 4; bool has_description() const; @@ -1084,15 +1034,6 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : ::io::substrait::Type* intermediate_type); ::io::substrait::Type* unsafe_arena_release_intermediate_type(); - // uint64 max_set = 12; - void clear_max_set(); - ::PROTOBUF_NAMESPACE_ID::uint64 max_set() const; - void set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); - private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_max_set() const; - void _internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); - public: - // bool deterministic = 7; void clear_deterministic(); bool deterministic() const; @@ -1120,6 +1061,15 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : void _internal_set_ordered(bool value); public: + // uint64 max_set = 12; + void clear_max_set(); + ::PROTOBUF_NAMESPACE_ID::uint64 max_set() const; + void set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_max_set() const; + void _internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; bool has_variadic() const; private: @@ -1171,16 +1121,15 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument > arguments_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField name_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation > implementations_; - ::io::substrait::Extensions_FunctionId* id_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; ::io::substrait::FunctionSignature_Description* description_; ::io::substrait::DerivationExpression* output_type_; ::io::substrait::Type* intermediate_type_; - ::PROTOBUF_NAMESPACE_ID::uint64 max_set_; bool deterministic_; bool session_dependent_; bool ordered_; + ::PROTOBUF_NAMESPACE_ID::uint64 max_set_; union FinalVariableBehaviorUnion { constexpr FinalVariableBehaviorUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; @@ -1342,7 +1291,6 @@ class FunctionSignature_Window PROTOBUF_FINAL : kArgumentsFieldNumber = 2, kNameFieldNumber = 3, kImplementationsFieldNumber = 15, - kIdFieldNumber = 1, kDescriptionFieldNumber = 4, kIntermediateTypeFieldNumber = 9, kOutputTypeFieldNumber = 10, @@ -1414,24 +1362,6 @@ class FunctionSignature_Window PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& implementations() const; - // .io.substrait.Extensions.FunctionId id = 1; - bool has_id() const; - private: - bool _internal_has_id() const; - public: - void clear_id(); - const ::io::substrait::Extensions_FunctionId& id() const; - ::io::substrait::Extensions_FunctionId* release_id(); - ::io::substrait::Extensions_FunctionId* mutable_id(); - void set_allocated_id(::io::substrait::Extensions_FunctionId* id); - private: - const ::io::substrait::Extensions_FunctionId& _internal_id() const; - ::io::substrait::Extensions_FunctionId* _internal_mutable_id(); - public: - void unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id); - ::io::substrait::Extensions_FunctionId* unsafe_arena_release_id(); - // .io.substrait.FunctionSignature.Description description = 4; bool has_description() const; private: @@ -1584,7 +1514,6 @@ class FunctionSignature_Window PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument > arguments_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField name_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation > implementations_; - ::io::substrait::Extensions_FunctionId* id_; ::io::substrait::FunctionSignature_Description* description_; ::io::substrait::DerivationExpression* intermediate_type_; ::io::substrait::DerivationExpression* output_type_; @@ -2810,83 +2739,6 @@ inline void FunctionSignature_FinalArgVariadic::set_consistency(::io::substrait: // FunctionSignature_Scalar -// .io.substrait.Extensions.FunctionId id = 1; -inline bool FunctionSignature_Scalar::_internal_has_id() const { - return this != internal_default_instance() && id_ != nullptr; -} -inline bool FunctionSignature_Scalar::has_id() const { - return _internal_has_id(); -} -inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Scalar::_internal_id() const { - const ::io::substrait::Extensions_FunctionId* p = id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_FunctionId_default_instance_); -} -inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Scalar::id() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.id) - return _internal_id(); -} -inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); - } - id_ = id; - if (id) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Scalar.id) -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Scalar::release_id() { - - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Scalar::unsafe_arena_release_id() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Scalar.id) - - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; - return temp; -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Scalar::_internal_mutable_id() { - - if (id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); - id_ = p; - } - return id_; -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Scalar::mutable_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.id) - return _internal_mutable_id(); -} -inline void FunctionSignature_Scalar::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); - } - if (id) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); - if (message_arena != submessage_arena) { - id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, id, submessage_arena); - } - - } else { - - } - id_ = id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Scalar.id) -} - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; inline int FunctionSignature_Scalar::_internal_arguments_size() const { return arguments_.size(); @@ -3398,83 +3250,6 @@ inline FunctionSignature_Scalar::FinalVariableBehaviorCase FunctionSignature_Sca // FunctionSignature_Aggregate -// .io.substrait.Extensions.FunctionId id = 1; -inline bool FunctionSignature_Aggregate::_internal_has_id() const { - return this != internal_default_instance() && id_ != nullptr; -} -inline bool FunctionSignature_Aggregate::has_id() const { - return _internal_has_id(); -} -inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Aggregate::_internal_id() const { - const ::io::substrait::Extensions_FunctionId* p = id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_FunctionId_default_instance_); -} -inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Aggregate::id() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.id) - return _internal_id(); -} -inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); - } - id_ = id; - if (id) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.id) -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Aggregate::release_id() { - - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Aggregate::unsafe_arena_release_id() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.id) - - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; - return temp; -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Aggregate::_internal_mutable_id() { - - if (id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); - id_ = p; - } - return id_; -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Aggregate::mutable_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.id) - return _internal_mutable_id(); -} -inline void FunctionSignature_Aggregate::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); - } - if (id) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); - if (message_arena != submessage_arena) { - id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, id, submessage_arena); - } - - } else { - - } - id_ = id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.id) -} - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; inline int FunctionSignature_Aggregate::_internal_arguments_size() const { return arguments_.size(); @@ -3514,78 +3289,49 @@ FunctionSignature_Aggregate::arguments() const { return arguments_; } -// repeated string name = 3; -inline int FunctionSignature_Aggregate::_internal_name_size() const { - return name_.size(); -} -inline int FunctionSignature_Aggregate::name_size() const { - return _internal_name_size(); -} +// string name = 3; inline void FunctionSignature_Aggregate::clear_name() { - name_.Clear(); -} -inline std::string* FunctionSignature_Aggregate::add_name() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.FunctionSignature.Aggregate.name) - return _internal_add_name(); -} -inline const std::string& FunctionSignature_Aggregate::_internal_name(int index) const { - return name_.Get(index); + name_.ClearToEmpty(); } -inline const std::string& FunctionSignature_Aggregate::name(int index) const { +inline const std::string& FunctionSignature_Aggregate::name() const { // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.name) - return _internal_name(index); -} -inline std::string* FunctionSignature_Aggregate::mutable_name(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.name) - return name_.Mutable(index); -} -inline void FunctionSignature_Aggregate::set_name(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.name) - name_.Mutable(index)->assign(value); + return _internal_name(); } -inline void FunctionSignature_Aggregate::set_name(int index, std::string&& value) { +template +PROTOBUF_ALWAYS_INLINE +inline void FunctionSignature_Aggregate::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.name) - name_.Mutable(index)->assign(std::move(value)); -} -inline void FunctionSignature_Aggregate::set_name(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - name_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.FunctionSignature.Aggregate.name) -} -inline void FunctionSignature_Aggregate::set_name(int index, const char* value, size_t size) { - name_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.FunctionSignature.Aggregate.name) } -inline std::string* FunctionSignature_Aggregate::_internal_add_name() { - return name_.Add(); -} -inline void FunctionSignature_Aggregate::add_name(const std::string& value) { - name_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Aggregate.name) +inline std::string* FunctionSignature_Aggregate::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.name) + return _internal_mutable_name(); } -inline void FunctionSignature_Aggregate::add_name(std::string&& value) { - name_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Aggregate.name) +inline const std::string& FunctionSignature_Aggregate::_internal_name() const { + return name_.Get(); } -inline void FunctionSignature_Aggregate::add_name(const char* value) { - GOOGLE_DCHECK(value != nullptr); - name_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.FunctionSignature.Aggregate.name) +inline void FunctionSignature_Aggregate::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); } -inline void FunctionSignature_Aggregate::add_name(const char* value, size_t size) { - name_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.FunctionSignature.Aggregate.name) +inline std::string* FunctionSignature_Aggregate::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -FunctionSignature_Aggregate::name() const { - // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Aggregate.name) - return name_; +inline std::string* FunctionSignature_Aggregate::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -FunctionSignature_Aggregate::mutable_name() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Aggregate.name) - return &name_; +inline void FunctionSignature_Aggregate::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.name) } // .io.substrait.FunctionSignature.Description description = 4; @@ -4103,83 +3849,6 @@ inline FunctionSignature_Aggregate::FinalVariableBehaviorCase FunctionSignature_ // FunctionSignature_Window -// .io.substrait.Extensions.FunctionId id = 1; -inline bool FunctionSignature_Window::_internal_has_id() const { - return this != internal_default_instance() && id_ != nullptr; -} -inline bool FunctionSignature_Window::has_id() const { - return _internal_has_id(); -} -inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Window::_internal_id() const { - const ::io::substrait::Extensions_FunctionId* p = id_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Extensions_FunctionId_default_instance_); -} -inline const ::io::substrait::Extensions_FunctionId& FunctionSignature_Window::id() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.id) - return _internal_id(); -} -inline void FunctionSignature_Window::unsafe_arena_set_allocated_id( - ::io::substrait::Extensions_FunctionId* id) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); - } - id_ = id; - if (id) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.id) -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Window::release_id() { - - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Window::unsafe_arena_release_id() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.id) - - ::io::substrait::Extensions_FunctionId* temp = id_; - id_ = nullptr; - return temp; -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Window::_internal_mutable_id() { - - if (id_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Extensions_FunctionId>(GetArena()); - id_ = p; - } - return id_; -} -inline ::io::substrait::Extensions_FunctionId* FunctionSignature_Window::mutable_id() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.id) - return _internal_mutable_id(); -} -inline void FunctionSignature_Window::set_allocated_id(::io::substrait::Extensions_FunctionId* id) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_); - } - if (id) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id)->GetArena(); - if (message_arena != submessage_arena) { - id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, id, submessage_arena); - } - - } else { - - } - id_ = id; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.id) -} - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; inline int FunctionSignature_Window::_internal_arguments_size() const { return arguments_.size(); diff --git a/cpp/src/generated/substrait/parameterized_types.pb.cc b/cpp/src/generated/substrait/parameterized_types.pb.cc index 22abc72ed2d..c3e21d41a7d 100644 --- a/cpp/src/generated/substrait/parameterized_types.pb.cc +++ b/cpp/src/generated/substrait/parameterized_types.pb.cc @@ -60,7 +60,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_NullableInteg constexpr ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : length_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct ParameterizedType_ParameterizedFixedCharDefaultTypeInternal { @@ -75,7 +75,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_Parameterized constexpr ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : length_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct ParameterizedType_ParameterizedVarCharDefaultTypeInternal { @@ -90,7 +90,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_Parameterized constexpr ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : length_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal { @@ -106,7 +106,7 @@ constexpr ParameterizedType_ParameterizedDecimal::ParameterizedType_Parameterize ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : scale_(nullptr) , precision_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct ParameterizedType_ParameterizedDecimalDefaultTypeInternal { @@ -121,7 +121,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_Parameterized constexpr ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : types_() - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct ParameterizedType_ParameterizedStructDefaultTypeInternal { @@ -149,7 +149,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_Parameterized constexpr ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : type_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct ParameterizedType_ParameterizedListDefaultTypeInternal { @@ -165,7 +165,7 @@ constexpr ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : key_(nullptr) , value_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct ParameterizedType_ParameterizedMapDefaultTypeInternal { @@ -235,7 +235,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_parameterized_5ftypes_2eproto: ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, _internal_metadata_), @@ -243,7 +243,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_parameterized_5ftypes_2eproto: ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, _internal_metadata_), @@ -251,7 +251,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_parameterized_5ftypes_2eproto: ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, _internal_metadata_), @@ -260,7 +260,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_parameterized_5ftypes_2eproto: ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, scale_), PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, precision_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, _internal_metadata_), @@ -268,7 +268,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_parameterized_5ftypes_2eproto: ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, types_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedNamedStruct, _internal_metadata_), @@ -283,7 +283,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_parameterized_5ftypes_2eproto: ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, _internal_metadata_), @@ -292,7 +292,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_parameterized_5ftypes_2eproto: ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, key_), PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, value_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerOption, _internal_metadata_), @@ -368,100 +368,95 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = const char descriptor_table_protodef_parameterized_5ftypes_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\031parameterized_types.proto\022\014io.substrai" - "t\032\ntype.proto\032\020extensions.proto\"\363\031\n\021Para" - "meterizedType\022*\n\004bool\030\001 \001(\0132\032.io.substra" - "it.Type.BooleanH\000\022#\n\002i8\030\002 \001(\0132\025.io.subst" - "rait.Type.I8H\000\022%\n\003i16\030\003 \001(\0132\026.io.substra" - "it.Type.I16H\000\022%\n\003i32\030\005 \001(\0132\026.io.substrai" - "t.Type.I32H\000\022%\n\003i64\030\007 \001(\0132\026.io.substrait" - ".Type.I64H\000\022\'\n\004fp32\030\n \001(\0132\027.io.substrait" - ".Type.FP32H\000\022\'\n\004fp64\030\013 \001(\0132\027.io.substrai" - "t.Type.FP64H\000\022+\n\006string\030\014 \001(\0132\031.io.subst" - "rait.Type.StringH\000\022+\n\006binary\030\r \001(\0132\031.io." - "substrait.Type.BinaryH\000\0221\n\ttimestamp\030\016 \001" - "(\0132\034.io.substrait.Type.TimestampH\000\022\'\n\004da" - "te\030\020 \001(\0132\027.io.substrait.Type.DateH\000\022\'\n\004t" - "ime\030\021 \001(\0132\027.io.substrait.Type.TimeH\000\0228\n\r" - "interval_year\030\023 \001(\0132\037.io.substrait.Type." - "IntervalYearH\000\0226\n\014interval_day\030\024 \001(\0132\036.i" - "o.substrait.Type.IntervalDayH\000\0226\n\014timest" - "amp_tz\030\035 \001(\0132\036.io.substrait.Type.Timesta" - "mpTZH\000\022\'\n\004uuid\030 \001(\0132\027.io.substrait.Type" - ".UUIDH\000\022L\n\nfixed_char\030\025 \001(\01326.io.substra" - "it.ParameterizedType.ParameterizedFixedC" - "harH\000\022G\n\007varchar\030\026 \001(\01324.io.substrait.Pa" - "rameterizedType.ParameterizedVarCharH\000\022P" - "\n\014fixed_binary\030\027 \001(\01328.io.substrait.Para" - "meterizedType.ParameterizedFixedBinaryH\000" - "\022G\n\007decimal\030\030 \001(\01324.io.substrait.Paramet" - "erizedType.ParameterizedDecimalH\000\022E\n\006str" - "uct\030\031 \001(\01323.io.substrait.ParameterizedTy" - "pe.ParameterizedStructH\000\022A\n\004list\030\033 \001(\01321" - ".io.substrait.ParameterizedType.Paramete" - "rizedListH\000\022\?\n\003map\030\034 \001(\01320.io.substrait." - "ParameterizedType.ParameterizedMapH\000\0227\n\014" - "user_defined\030\037 \001(\0132\037.io.substrait.Extens" - "ions.TypeIdH\000\022G\n\016type_parameter\030! \001(\0132-." - "io.substrait.ParameterizedType.TypeParam" - "eterH\000\032N\n\rTypeParameter\022\014\n\004name\030\001 \001(\t\022/\n" - "\006bounds\030\002 \003(\0132\037.io.substrait.Parameteriz" - "edType\032\276\001\n\020IntegerParameter\022\014\n\004name\030\001 \001(" - "\t\022N\n\025range_start_inclusive\030\002 \001(\0132/.io.su" - "bstrait.ParameterizedType.NullableIntege" - "r\022L\n\023range_end_exclusive\030\003 \001(\0132/.io.subs" - "trait.ParameterizedType.NullableInteger\032" - " \n\017NullableInteger\022\r\n\005value\030\001 \001(\003\032\275\001\n\026Pa" - "rameterizedFixedChar\022=\n\006length\030\001 \001(\0132-.i" - "o.substrait.ParameterizedType.IntegerOpt" - "ion\022/\n\tvariation\030\002 \001(\0132\034.io.substrait.Ty" - "pe.Variation\0223\n\013nullability\030\003 \001(\0162\036.io.s" - "ubstrait.Type.Nullability\032\273\001\n\024Parameteri" - "zedVarChar\022=\n\006length\030\001 \001(\0132-.io.substrai" - "t.ParameterizedType.IntegerOption\022/\n\tvar" - "iation\030\002 \001(\0132\034.io.substrait.Type.Variati" - "on\0223\n\013nullability\030\003 \001(\0162\036.io.substrait.T" - "ype.Nullability\032\277\001\n\030ParameterizedFixedBi" - "nary\022=\n\006length\030\001 \001(\0132-.io.substrait.Para" - "meterizedType.IntegerOption\022/\n\tvariation" - "\030\002 \001(\0132\034.io.substrait.Type.Variation\0223\n\013" - "nullability\030\003 \001(\0162\036.io.substrait.Type.Nu" - "llability\032\374\001\n\024ParameterizedDecimal\022<\n\005sc" - "ale\030\001 \001(\0132-.io.substrait.ParameterizedTy" - "pe.IntegerOption\022@\n\tprecision\030\002 \001(\0132-.io" - ".substrait.ParameterizedType.IntegerOpti" - "on\022/\n\tvariation\030\003 \001(\0132\034.io.substrait.Typ" - "e.Variation\0223\n\013nullability\030\004 \001(\0162\036.io.su" - "bstrait.Type.Nullability\032\253\001\n\023Parameteriz" - "edStruct\022.\n\005types\030\001 \003(\0132\037.io.substrait.P" - "arameterizedType\022/\n\tvariation\030\002 \001(\0132\034.io" - ".substrait.Type.Variation\0223\n\013nullability" - "\030\003 \001(\0162\036.io.substrait.Type.Nullability\032n" - "\n\030ParameterizedNamedStruct\022\r\n\005names\030\001 \003(" - "\t\022C\n\006struct\030\002 \001(\01323.io.substrait.Paramet" - "erizedType.ParameterizedStruct\032\250\001\n\021Param" - "eterizedList\022-\n\004type\030\001 \001(\0132\037.io.substrai" - "t.ParameterizedType\022/\n\tvariation\030\002 \001(\0132\034" - ".io.substrait.Type.Variation\0223\n\013nullabil" - "ity\030\003 \001(\0162\036.io.substrait.Type.Nullabilit" - "y\032\326\001\n\020ParameterizedMap\022,\n\003key\030\001 \001(\0132\037.io" - ".substrait.ParameterizedType\022.\n\005value\030\002 " - "\001(\0132\037.io.substrait.ParameterizedType\022/\n\t" - "variation\030\003 \001(\0132\034.io.substrait.Type.Vari" - "ation\0223\n\013nullability\030\004 \001(\0162\036.io.substrai" - "t.Type.Nullability\032y\n\rIntegerOption\022\021\n\007l" - "iteral\030\001 \001(\005H\000\022E\n\tparameter\030\002 \001(\01320.io.s" - "ubstrait.ParameterizedType.IntegerParame" - "terH\000B\016\n\014integer_typeB\006\n\004kindB\027P\001\252\002\022Subs" - "trait.Protobufb\006proto3" + "t\032\ntype.proto\"\300\030\n\021ParameterizedType\022*\n\004b" + "ool\030\001 \001(\0132\032.io.substrait.Type.BooleanH\000\022" + "#\n\002i8\030\002 \001(\0132\025.io.substrait.Type.I8H\000\022%\n\003" + "i16\030\003 \001(\0132\026.io.substrait.Type.I16H\000\022%\n\003i" + "32\030\005 \001(\0132\026.io.substrait.Type.I32H\000\022%\n\003i6" + "4\030\007 \001(\0132\026.io.substrait.Type.I64H\000\022\'\n\004fp3" + "2\030\n \001(\0132\027.io.substrait.Type.FP32H\000\022\'\n\004fp" + "64\030\013 \001(\0132\027.io.substrait.Type.FP64H\000\022+\n\006s" + "tring\030\014 \001(\0132\031.io.substrait.Type.StringH\000" + "\022+\n\006binary\030\r \001(\0132\031.io.substrait.Type.Bin" + "aryH\000\0221\n\ttimestamp\030\016 \001(\0132\034.io.substrait." + "Type.TimestampH\000\022\'\n\004date\030\020 \001(\0132\027.io.subs" + "trait.Type.DateH\000\022\'\n\004time\030\021 \001(\0132\027.io.sub" + "strait.Type.TimeH\000\0228\n\rinterval_year\030\023 \001(" + "\0132\037.io.substrait.Type.IntervalYearH\000\0226\n\014" + "interval_day\030\024 \001(\0132\036.io.substrait.Type.I" + "ntervalDayH\000\0226\n\014timestamp_tz\030\035 \001(\0132\036.io." + "substrait.Type.TimestampTZH\000\022\'\n\004uuid\030 \001" + "(\0132\027.io.substrait.Type.UUIDH\000\022L\n\nfixed_c" + "har\030\025 \001(\01326.io.substrait.ParameterizedTy" + "pe.ParameterizedFixedCharH\000\022G\n\007varchar\030\026" + " \001(\01324.io.substrait.ParameterizedType.Pa" + "rameterizedVarCharH\000\022P\n\014fixed_binary\030\027 \001" + "(\01328.io.substrait.ParameterizedType.Para" + "meterizedFixedBinaryH\000\022G\n\007decimal\030\030 \001(\0132" + "4.io.substrait.ParameterizedType.Paramet" + "erizedDecimalH\000\022E\n\006struct\030\031 \001(\01323.io.sub" + "strait.ParameterizedType.ParameterizedSt" + "ructH\000\022A\n\004list\030\033 \001(\01321.io.substrait.Para" + "meterizedType.ParameterizedListH\000\022\?\n\003map" + "\030\034 \001(\01320.io.substrait.ParameterizedType." + "ParameterizedMapH\000\022\036\n\024user_defined_point" + "er\030\037 \001(\rH\000\022G\n\016type_parameter\030! \001(\0132-.io." + "substrait.ParameterizedType.TypeParamete" + "rH\000\032N\n\rTypeParameter\022\014\n\004name\030\001 \001(\t\022/\n\006bo" + "unds\030\002 \003(\0132\037.io.substrait.ParameterizedT" + "ype\032\276\001\n\020IntegerParameter\022\014\n\004name\030\001 \001(\t\022N" + "\n\025range_start_inclusive\030\002 \001(\0132/.io.subst" + "rait.ParameterizedType.NullableInteger\022L" + "\n\023range_end_exclusive\030\003 \001(\0132/.io.substra" + "it.ParameterizedType.NullableInteger\032 \n\017" + "NullableInteger\022\r\n\005value\030\001 \001(\003\032\247\001\n\026Param" + "eterizedFixedChar\022=\n\006length\030\001 \001(\0132-.io.s" + "ubstrait.ParameterizedType.IntegerOption" + "\022\031\n\021variation_pointer\030\002 \001(\r\0223\n\013nullabili" + "ty\030\003 \001(\0162\036.io.substrait.Type.Nullability" + "\032\245\001\n\024ParameterizedVarChar\022=\n\006length\030\001 \001(" + "\0132-.io.substrait.ParameterizedType.Integ" + "erOption\022\031\n\021variation_pointer\030\002 \001(\r\0223\n\013n" + "ullability\030\003 \001(\0162\036.io.substrait.Type.Nul" + "lability\032\251\001\n\030ParameterizedFixedBinary\022=\n" + "\006length\030\001 \001(\0132-.io.substrait.Parameteriz" + "edType.IntegerOption\022\031\n\021variation_pointe" + "r\030\002 \001(\r\0223\n\013nullability\030\003 \001(\0162\036.io.substr" + "ait.Type.Nullability\032\346\001\n\024ParameterizedDe" + "cimal\022<\n\005scale\030\001 \001(\0132-.io.substrait.Para" + "meterizedType.IntegerOption\022@\n\tprecision" + "\030\002 \001(\0132-.io.substrait.ParameterizedType." + "IntegerOption\022\031\n\021variation_pointer\030\003 \001(\r" + "\0223\n\013nullability\030\004 \001(\0162\036.io.substrait.Typ" + "e.Nullability\032\225\001\n\023ParameterizedStruct\022.\n" + "\005types\030\001 \003(\0132\037.io.substrait.Parameterize" + "dType\022\031\n\021variation_pointer\030\002 \001(\r\0223\n\013null" + "ability\030\003 \001(\0162\036.io.substrait.Type.Nullab" + "ility\032n\n\030ParameterizedNamedStruct\022\r\n\005nam" + "es\030\001 \003(\t\022C\n\006struct\030\002 \001(\01323.io.substrait." + "ParameterizedType.ParameterizedStruct\032\222\001" + "\n\021ParameterizedList\022-\n\004type\030\001 \001(\0132\037.io.s" + "ubstrait.ParameterizedType\022\031\n\021variation_" + "pointer\030\002 \001(\r\0223\n\013nullability\030\003 \001(\0162\036.io." + "substrait.Type.Nullability\032\300\001\n\020Parameter" + "izedMap\022,\n\003key\030\001 \001(\0132\037.io.substrait.Para" + "meterizedType\022.\n\005value\030\002 \001(\0132\037.io.substr" + "ait.ParameterizedType\022\031\n\021variation_point" + "er\030\003 \001(\r\0223\n\013nullability\030\004 \001(\0162\036.io.subst" + "rait.Type.Nullability\032y\n\rIntegerOption\022\021" + "\n\007literal\030\001 \001(\005H\000\022E\n\tparameter\030\002 \001(\01320.i" + "o.substrait.ParameterizedType.IntegerPar" + "ameterH\000B\016\n\014integer_typeB\006\n\004kindB+\n\022io.s" + "ubstrait.protoP\001\252\002\022Substrait.Protobufb\006p" + "roto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_parameterized_5ftypes_2eproto_deps[2] = { - &::descriptor_table_extensions_2eproto, +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_parameterized_5ftypes_2eproto_deps[1] = { &::descriptor_table_type_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_parameterized_5ftypes_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_parameterized_5ftypes_2eproto = { - false, false, 3422, descriptor_table_protodef_parameterized_5ftypes_2eproto, "parameterized_types.proto", - &descriptor_table_parameterized_5ftypes_2eproto_once, descriptor_table_parameterized_5ftypes_2eproto_deps, 2, 13, + false, false, 3245, descriptor_table_protodef_parameterized_5ftypes_2eproto, "parameterized_types.proto", + &descriptor_table_parameterized_5ftypes_2eproto_once, descriptor_table_parameterized_5ftypes_2eproto_deps, 1, 13, schemas, file_default_instances, TableStruct_parameterized_5ftypes_2eproto::offsets, file_level_metadata_parameterized_5ftypes_2eproto, file_level_enum_descriptors_parameterized_5ftypes_2eproto, file_level_service_descriptors_parameterized_5ftypes_2eproto, }; @@ -1193,23 +1188,12 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_NullableInteger::GetMetadata class ParameterizedType_ParameterizedFixedChar::_Internal { public: static const ::io::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedChar* msg); - static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedFixedChar* msg); }; const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::_Internal::length(const ParameterizedType_ParameterizedFixedChar* msg) { return *msg->length_; } -const ::io::substrait::Type_Variation& -ParameterizedType_ParameterizedFixedChar::_Internal::variation(const ParameterizedType_ParameterizedFixedChar* msg) { - return *msg->variation_; -} -void ParameterizedType_ParameterizedFixedChar::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1224,12 +1208,9 @@ ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedCh } else { length_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedFixedChar) } @@ -1249,7 +1230,6 @@ ParameterizedType_ParameterizedFixedChar::~ParameterizedType_ParameterizedFixedC void ParameterizedType_ParameterizedFixedChar::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete length_; - if (this != internal_default_instance()) delete variation_; } void ParameterizedType_ParameterizedFixedChar::ArenaDtor(void* object) { @@ -1272,11 +1252,9 @@ void ParameterizedType_ParameterizedFixedChar::Clear() { delete length_; } length_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1293,10 +1271,10 @@ const char* ParameterizedType_ParameterizedFixedChar::_InternalParse(const char* CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1345,12 +1323,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedChar::_Inter 1, _Internal::length(this), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -1383,11 +1359,11 @@ size_t ParameterizedType_ParameterizedFixedChar::ByteSizeLong() const { *length_); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 3; @@ -1430,8 +1406,8 @@ void ParameterizedType_ParameterizedFixedChar::MergeFrom(const ParameterizedType if (from.has_length()) { _internal_mutable_length()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1478,23 +1454,12 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedFixedChar::GetM class ParameterizedType_ParameterizedVarChar::_Internal { public: static const ::io::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedVarChar* msg); - static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedVarChar* msg); }; const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::_Internal::length(const ParameterizedType_ParameterizedVarChar* msg) { return *msg->length_; } -const ::io::substrait::Type_Variation& -ParameterizedType_ParameterizedVarChar::_Internal::variation(const ParameterizedType_ParameterizedVarChar* msg) { - return *msg->variation_; -} -void ParameterizedType_ParameterizedVarChar::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1509,12 +1474,9 @@ ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(c } else { length_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedVarChar) } @@ -1534,7 +1496,6 @@ ParameterizedType_ParameterizedVarChar::~ParameterizedType_ParameterizedVarChar( void ParameterizedType_ParameterizedVarChar::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete length_; - if (this != internal_default_instance()) delete variation_; } void ParameterizedType_ParameterizedVarChar::ArenaDtor(void* object) { @@ -1557,11 +1518,9 @@ void ParameterizedType_ParameterizedVarChar::Clear() { delete length_; } length_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1578,10 +1537,10 @@ const char* ParameterizedType_ParameterizedVarChar::_InternalParse(const char* p CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1630,12 +1589,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedVarChar::_Interna 1, _Internal::length(this), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -1668,11 +1625,11 @@ size_t ParameterizedType_ParameterizedVarChar::ByteSizeLong() const { *length_); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 3; @@ -1715,8 +1672,8 @@ void ParameterizedType_ParameterizedVarChar::MergeFrom(const ParameterizedType_P if (from.has_length()) { _internal_mutable_length()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1763,23 +1720,12 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedVarChar::GetMet class ParameterizedType_ParameterizedFixedBinary::_Internal { public: static const ::io::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedBinary* msg); - static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedFixedBinary* msg); }; const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::_Internal::length(const ParameterizedType_ParameterizedFixedBinary* msg) { return *msg->length_; } -const ::io::substrait::Type_Variation& -ParameterizedType_ParameterizedFixedBinary::_Internal::variation(const ParameterizedType_ParameterizedFixedBinary* msg) { - return *msg->variation_; -} -void ParameterizedType_ParameterizedFixedBinary::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1794,12 +1740,9 @@ ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixed } else { length_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedFixedBinary) } @@ -1819,7 +1762,6 @@ ParameterizedType_ParameterizedFixedBinary::~ParameterizedType_ParameterizedFixe void ParameterizedType_ParameterizedFixedBinary::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete length_; - if (this != internal_default_instance()) delete variation_; } void ParameterizedType_ParameterizedFixedBinary::ArenaDtor(void* object) { @@ -1842,11 +1784,9 @@ void ParameterizedType_ParameterizedFixedBinary::Clear() { delete length_; } length_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1863,10 +1803,10 @@ const char* ParameterizedType_ParameterizedFixedBinary::_InternalParse(const cha CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1915,12 +1855,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedBinary::_Int 1, _Internal::length(this), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -1953,11 +1891,11 @@ size_t ParameterizedType_ParameterizedFixedBinary::ByteSizeLong() const { *length_); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 3; @@ -2000,8 +1938,8 @@ void ParameterizedType_ParameterizedFixedBinary::MergeFrom(const ParameterizedTy if (from.has_length()) { _internal_mutable_length()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -2049,7 +1987,6 @@ class ParameterizedType_ParameterizedDecimal::_Internal { public: static const ::io::substrait::ParameterizedType_IntegerOption& scale(const ParameterizedType_ParameterizedDecimal* msg); static const ::io::substrait::ParameterizedType_IntegerOption& precision(const ParameterizedType_ParameterizedDecimal* msg); - static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedDecimal* msg); }; const ::io::substrait::ParameterizedType_IntegerOption& @@ -2060,16 +1997,6 @@ const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_Internal::precision(const ParameterizedType_ParameterizedDecimal* msg) { return *msg->precision_; } -const ::io::substrait::Type_Variation& -ParameterizedType_ParameterizedDecimal::_Internal::variation(const ParameterizedType_ParameterizedDecimal* msg) { - return *msg->variation_; -} -void ParameterizedType_ParameterizedDecimal::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -2089,12 +2016,9 @@ ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(c } else { precision_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedDecimal) } @@ -2115,7 +2039,6 @@ void ParameterizedType_ParameterizedDecimal::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete scale_; if (this != internal_default_instance()) delete precision_; - if (this != internal_default_instance()) delete variation_; } void ParameterizedType_ParameterizedDecimal::ArenaDtor(void* object) { @@ -2142,11 +2065,9 @@ void ParameterizedType_ParameterizedDecimal::Clear() { delete precision_; } precision_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2170,10 +2091,10 @@ const char* ParameterizedType_ParameterizedDecimal::_InternalParse(const char* p CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 3; + // uint32 variation_pointer = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -2230,12 +2151,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedDecimal::_Interna 2, _Internal::precision(this), target, stream); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 variation_pointer = 3; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 4; @@ -2275,11 +2194,11 @@ size_t ParameterizedType_ParameterizedDecimal::ByteSizeLong() const { *precision_); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 variation_pointer = 3; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 4; @@ -2325,8 +2244,8 @@ void ParameterizedType_ParameterizedDecimal::MergeFrom(const ParameterizedType_P if (from.has_precision()) { _internal_mutable_precision()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_precision()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -2372,19 +2291,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedDecimal::GetMet class ParameterizedType_ParameterizedStruct::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedStruct* msg); }; -const ::io::substrait::Type_Variation& -ParameterizedType_ParameterizedStruct::_Internal::variation(const ParameterizedType_ParameterizedStruct* msg) { - return *msg->variation_; -} -void ParameterizedType_ParameterizedStruct::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), types_(arena) { @@ -2396,20 +2304,17 @@ ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(con : ::PROTOBUF_NAMESPACE_ID::Message(), types_(from.types_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedStruct) } void ParameterizedType_ParameterizedStruct::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&variation_pointer_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); } ParameterizedType_ParameterizedStruct::~ParameterizedType_ParameterizedStruct() { @@ -2420,7 +2325,6 @@ ParameterizedType_ParameterizedStruct::~ParameterizedType_ParameterizedStruct() void ParameterizedType_ParameterizedStruct::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void ParameterizedType_ParameterizedStruct::ArenaDtor(void* object) { @@ -2440,11 +2344,9 @@ void ParameterizedType_ParameterizedStruct::Clear() { (void) cached_has_bits; types_.Clear(); - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2466,10 +2368,10 @@ const char* ParameterizedType_ParameterizedStruct::_InternalParse(const char* pt } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -2518,12 +2420,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedStruct::_Internal InternalWriteMessage(1, this->_internal_types(i), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -2556,11 +2456,11 @@ size_t ParameterizedType_ParameterizedStruct::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 3; @@ -2601,8 +2501,8 @@ void ParameterizedType_ParameterizedStruct::MergeFrom(const ParameterizedType_Pa (void) cached_has_bits; types_.MergeFrom(from.types_); - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -2634,9 +2534,9 @@ void ParameterizedType_ParameterizedStruct::InternalSwap(ParameterizedType_Param ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedStruct, nullability_) + sizeof(ParameterizedType_ParameterizedStruct::nullability_) - - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedStruct, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedStruct, variation_pointer_)>( + reinterpret_cast(&variation_pointer_), + reinterpret_cast(&other->variation_pointer_)); } ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedStruct::GetMetadata() const { @@ -2892,23 +2792,12 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedNamedStruct::Ge class ParameterizedType_ParameterizedList::_Internal { public: static const ::io::substrait::ParameterizedType& type(const ParameterizedType_ParameterizedList* msg); - static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedList* msg); }; const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedList::_Internal::type(const ParameterizedType_ParameterizedList* msg) { return *msg->type_; } -const ::io::substrait::Type_Variation& -ParameterizedType_ParameterizedList::_Internal::variation(const ParameterizedType_ParameterizedList* msg) { - return *msg->variation_; -} -void ParameterizedType_ParameterizedList::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -2923,12 +2812,9 @@ ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(const P } else { type_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedList) } @@ -2948,7 +2834,6 @@ ParameterizedType_ParameterizedList::~ParameterizedType_ParameterizedList() { void ParameterizedType_ParameterizedList::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete type_; - if (this != internal_default_instance()) delete variation_; } void ParameterizedType_ParameterizedList::ArenaDtor(void* object) { @@ -2971,11 +2856,9 @@ void ParameterizedType_ParameterizedList::Clear() { delete type_; } type_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2992,10 +2875,10 @@ const char* ParameterizedType_ParameterizedList::_InternalParse(const char* ptr, CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -3044,12 +2927,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedList::_InternalSe 1, _Internal::type(this), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -3082,11 +2963,11 @@ size_t ParameterizedType_ParameterizedList::ByteSizeLong() const { *type_); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 3; @@ -3129,8 +3010,8 @@ void ParameterizedType_ParameterizedList::MergeFrom(const ParameterizedType_Para if (from.has_type()) { _internal_mutable_type()->::io::substrait::ParameterizedType::MergeFrom(from._internal_type()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -3178,7 +3059,6 @@ class ParameterizedType_ParameterizedMap::_Internal { public: static const ::io::substrait::ParameterizedType& key(const ParameterizedType_ParameterizedMap* msg); static const ::io::substrait::ParameterizedType& value(const ParameterizedType_ParameterizedMap* msg); - static const ::io::substrait::Type_Variation& variation(const ParameterizedType_ParameterizedMap* msg); }; const ::io::substrait::ParameterizedType& @@ -3189,16 +3069,6 @@ const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_Internal::value(const ParameterizedType_ParameterizedMap* msg) { return *msg->value_; } -const ::io::substrait::Type_Variation& -ParameterizedType_ParameterizedMap::_Internal::variation(const ParameterizedType_ParameterizedMap* msg) { - return *msg->variation_; -} -void ParameterizedType_ParameterizedMap::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -3218,12 +3088,9 @@ ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(const Par } else { value_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedMap) } @@ -3244,7 +3111,6 @@ void ParameterizedType_ParameterizedMap::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete key_; if (this != internal_default_instance()) delete value_; - if (this != internal_default_instance()) delete variation_; } void ParameterizedType_ParameterizedMap::ArenaDtor(void* object) { @@ -3271,11 +3137,9 @@ void ParameterizedType_ParameterizedMap::Clear() { delete value_; } value_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3299,10 +3163,10 @@ const char* ParameterizedType_ParameterizedMap::_InternalParse(const char* ptr, CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 3; + // uint32 variation_pointer = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -3359,12 +3223,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedMap::_InternalSer 2, _Internal::value(this), target, stream); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 variation_pointer = 3; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 4; @@ -3404,11 +3266,11 @@ size_t ParameterizedType_ParameterizedMap::ByteSizeLong() const { *value_); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 variation_pointer = 3; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 4; @@ -3454,8 +3316,8 @@ void ParameterizedType_ParameterizedMap::MergeFrom(const ParameterizedType_Param if (from.has_value()) { _internal_mutable_value()->::io::substrait::ParameterizedType::MergeFrom(from._internal_value()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -3809,7 +3671,6 @@ class ParameterizedType::_Internal { static const ::io::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType* msg); static const ::io::substrait::ParameterizedType_ParameterizedList& list(const ParameterizedType* msg); static const ::io::substrait::ParameterizedType_ParameterizedMap& map(const ParameterizedType* msg); - static const ::io::substrait::Extensions_TypeId& user_defined(const ParameterizedType* msg); static const ::io::substrait::ParameterizedType_TypeParameter& type_parameter(const ParameterizedType* msg); }; @@ -3905,10 +3766,6 @@ const ::io::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::_Internal::map(const ParameterizedType* msg) { return *msg->kind_.map_; } -const ::io::substrait::Extensions_TypeId& -ParameterizedType::_Internal::user_defined(const ParameterizedType* msg) { - return *msg->kind_.user_defined_; -} const ::io::substrait::ParameterizedType_TypeParameter& ParameterizedType::_Internal::type_parameter(const ParameterizedType* msg) { return *msg->kind_.type_parameter_; @@ -4386,29 +4243,6 @@ void ParameterizedType::set_allocated_map(::io::substrait::ParameterizedType_Par } // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.map) } -void ParameterizedType::set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_kind(); - if (user_defined) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(user_defined)->GetArena(); - if (message_arena != submessage_arena) { - user_defined = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, user_defined, submessage_arena); - } - set_has_user_defined(); - kind_.user_defined_ = user_defined; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.user_defined) -} -void ParameterizedType::clear_user_defined() { - if (_internal_has_user_defined()) { - if (GetArena() == nullptr) { - delete kind_.user_defined_; - } - clear_has_kind(); - } -} void ParameterizedType::set_allocated_type_parameter(::io::substrait::ParameterizedType_TypeParameter* type_parameter) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); @@ -4527,8 +4361,8 @@ ParameterizedType::ParameterizedType(const ParameterizedType& from) _internal_mutable_map()->::io::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map()); break; } - case kUserDefined: { - _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + case kUserDefinedPointer: { + _internal_set_user_defined_pointer(from._internal_user_defined_pointer()); break; } case kTypeParameter: { @@ -4710,10 +4544,8 @@ void ParameterizedType::clear_kind() { } break; } - case kUserDefined: { - if (GetArena() == nullptr) { - delete kind_.user_defined_; - } + case kUserDefinedPointer: { + // No need to clear break; } case kTypeParameter: { @@ -4900,10 +4732,10 @@ const char* ParameterizedType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Extensions.TypeId user_defined = 31; + // uint32 user_defined_pointer = 31; case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) { - ptr = ctx->ParseMessage(_internal_mutable_user_defined(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 248)) { + _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; @@ -5126,12 +4958,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 29, _Internal::timestamp_tz(this), target, stream); } - // .io.substrait.Extensions.TypeId user_defined = 31; - if (_internal_has_user_defined()) { + // uint32 user_defined_pointer = 31; + if (_internal_has_user_defined_pointer()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 31, _Internal::user_defined(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_pointer(), target); } // .io.substrait.Type.UUID uuid = 32; @@ -5328,11 +5158,11 @@ size_t ParameterizedType::ByteSizeLong() const { *kind_.map_); break; } - // .io.substrait.Extensions.TypeId user_defined = 31; - case kUserDefined: { + // uint32 user_defined_pointer = 31; + case kUserDefinedPointer: { total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.user_defined_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_user_defined_pointer()); break; } // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; @@ -5470,8 +5300,8 @@ void ParameterizedType::MergeFrom(const ParameterizedType& from) { _internal_mutable_map()->::io::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map()); break; } - case kUserDefined: { - _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + case kUserDefinedPointer: { + _internal_set_user_defined_pointer(from._internal_user_defined_pointer()); break; } case kTypeParameter: { diff --git a/cpp/src/generated/substrait/parameterized_types.pb.h b/cpp/src/generated/substrait/parameterized_types.pb.h index ea4edcee94e..0b77fd1fe5b 100644 --- a/cpp/src/generated/substrait/parameterized_types.pb.h +++ b/cpp/src/generated/substrait/parameterized_types.pb.h @@ -32,7 +32,6 @@ #include // IWYU pragma: export #include #include "type.pb.h" -#include "extensions.pb.h" // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_parameterized_5ftypes_2eproto @@ -689,7 +688,7 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : enum : int { kLengthFieldNumber = 1, - kVariationFieldNumber = 2, + kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; // .io.substrait.ParameterizedType.IntegerOption length = 1; @@ -710,23 +709,14 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : ::io::substrait::ParameterizedType_IntegerOption* length); ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; + // uint32 variation_pointer = 2; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -745,7 +735,7 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::ParameterizedType_IntegerOption* length_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_parameterized_5ftypes_2eproto; @@ -860,7 +850,7 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : enum : int { kLengthFieldNumber = 1, - kVariationFieldNumber = 2, + kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; // .io.substrait.ParameterizedType.IntegerOption length = 1; @@ -881,23 +871,14 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : ::io::substrait::ParameterizedType_IntegerOption* length); ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 variation_pointer = 2; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -916,7 +897,7 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::ParameterizedType_IntegerOption* length_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_parameterized_5ftypes_2eproto; @@ -1031,7 +1012,7 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : enum : int { kLengthFieldNumber = 1, - kVariationFieldNumber = 2, + kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; // .io.substrait.ParameterizedType.IntegerOption length = 1; @@ -1052,23 +1033,14 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : ::io::substrait::ParameterizedType_IntegerOption* length); ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; + // uint32 variation_pointer = 2; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -1087,7 +1059,7 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::ParameterizedType_IntegerOption* length_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_parameterized_5ftypes_2eproto; @@ -1203,7 +1175,7 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : enum : int { kScaleFieldNumber = 1, kPrecisionFieldNumber = 2, - kVariationFieldNumber = 3, + kVariationPointerFieldNumber = 3, kNullabilityFieldNumber = 4, }; // .io.substrait.ParameterizedType.IntegerOption scale = 1; @@ -1242,23 +1214,14 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : ::io::substrait::ParameterizedType_IntegerOption* precision); ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_precision(); - // .io.substrait.Type.Variation variation = 3; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 variation_pointer = 3; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 4; void clear_nullability(); @@ -1278,7 +1241,7 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : typedef void DestructorSkippable_; ::io::substrait::ParameterizedType_IntegerOption* scale_; ::io::substrait::ParameterizedType_IntegerOption* precision_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_parameterized_5ftypes_2eproto; @@ -1393,7 +1356,7 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : enum : int { kTypesFieldNumber = 1, - kVariationFieldNumber = 2, + kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; // repeated .io.substrait.ParameterizedType types = 1; @@ -1414,23 +1377,14 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >& types() const; - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; + // uint32 variation_pointer = 2; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -1449,7 +1403,7 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType > types_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_parameterized_5ftypes_2eproto; @@ -1730,7 +1684,7 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : enum : int { kTypeFieldNumber = 1, - kVariationFieldNumber = 2, + kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; // .io.substrait.ParameterizedType type = 1; @@ -1751,23 +1705,14 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : ::io::substrait::ParameterizedType* type); ::io::substrait::ParameterizedType* unsafe_arena_release_type(); - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 variation_pointer = 2; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -1786,7 +1731,7 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::ParameterizedType* type_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_parameterized_5ftypes_2eproto; @@ -1902,7 +1847,7 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : enum : int { kKeyFieldNumber = 1, kValueFieldNumber = 2, - kVariationFieldNumber = 3, + kVariationPointerFieldNumber = 3, kNullabilityFieldNumber = 4, }; // .io.substrait.ParameterizedType key = 1; @@ -1941,23 +1886,14 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : ::io::substrait::ParameterizedType* value); ::io::substrait::ParameterizedType* unsafe_arena_release_value(); - // .io.substrait.Type.Variation variation = 3; - bool has_variation() const; + // uint32 variation_pointer = 3; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 4; void clear_nullability(); @@ -1977,7 +1913,7 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : typedef void DestructorSkippable_; ::io::substrait::ParameterizedType* key_; ::io::substrait::ParameterizedType* value_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_parameterized_5ftypes_2eproto; @@ -2220,7 +2156,7 @@ class ParameterizedType PROTOBUF_FINAL : kStruct = 25, kList = 27, kMap = 28, - kUserDefined = 31, + kUserDefinedPointer = 31, kTypeParameter = 33, KIND_NOT_SET = 0, }; @@ -2330,7 +2266,7 @@ class ParameterizedType PROTOBUF_FINAL : kStructFieldNumber = 25, kListFieldNumber = 27, kMapFieldNumber = 28, - kUserDefinedFieldNumber = 31, + kUserDefinedPointerFieldNumber = 31, kTypeParameterFieldNumber = 33, }; // .io.substrait.Type.Boolean bool = 1; @@ -2747,23 +2683,18 @@ class ParameterizedType PROTOBUF_FINAL : ::io::substrait::ParameterizedType_ParameterizedMap* map); ::io::substrait::ParameterizedType_ParameterizedMap* unsafe_arena_release_map(); - // .io.substrait.Extensions.TypeId user_defined = 31; - bool has_user_defined() const; + // uint32 user_defined_pointer = 31; + bool has_user_defined_pointer() const; private: - bool _internal_has_user_defined() const; + bool _internal_has_user_defined_pointer() const; public: - void clear_user_defined(); - const ::io::substrait::Extensions_TypeId& user_defined() const; - ::io::substrait::Extensions_TypeId* release_user_defined(); - ::io::substrait::Extensions_TypeId* mutable_user_defined(); - void set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined); + void clear_user_defined_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_pointer() const; + void set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Extensions_TypeId& _internal_user_defined() const; - ::io::substrait::Extensions_TypeId* _internal_mutable_user_defined(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_user_defined_pointer() const; + void _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_user_defined( - ::io::substrait::Extensions_TypeId* user_defined); - ::io::substrait::Extensions_TypeId* unsafe_arena_release_user_defined(); // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; bool has_type_parameter() const; @@ -2811,7 +2742,7 @@ class ParameterizedType PROTOBUF_FINAL : void set_has_struct_(); void set_has_list(); void set_has_map(); - void set_has_user_defined(); + void set_has_user_defined_pointer(); void set_has_type_parameter(); inline bool has_kind() const; @@ -2846,7 +2777,7 @@ class ParameterizedType PROTOBUF_FINAL : ::io::substrait::ParameterizedType_ParameterizedStruct* struct__; ::io::substrait::ParameterizedType_ParameterizedList* list_; ::io::substrait::ParameterizedType_ParameterizedMap* map_; - ::io::substrait::Extensions_TypeId* user_defined_; + ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_pointer_; ::io::substrait::ParameterizedType_TypeParameter* type_parameter_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; @@ -3275,81 +3206,24 @@ inline void ParameterizedType_ParameterizedFixedChar::set_allocated_length(::io: // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedChar.length) } -// .io.substrait.Type.Variation variation = 2; -inline bool ParameterizedType_ParameterizedFixedChar::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool ParameterizedType_ParameterizedFixedChar::has_variation() const { - return _internal_has_variation(); +// uint32 variation_pointer = 2; +inline void ParameterizedType_ParameterizedFixedChar::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedFixedChar::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedChar::_internal_variation_pointer() const { + return variation_pointer_; } -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedFixedChar::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedChar.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedChar::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer) + return _internal_variation_pointer(); } -inline void ParameterizedType_ParameterizedFixedChar::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedChar.variation) -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedChar::release_variation() { +inline void ParameterizedType_ParameterizedFixedChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedChar::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedFixedChar.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedChar::_internal_mutable_variation() { - - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedChar::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedFixedChar.variation) - return _internal_mutable_variation(); -} -inline void ParameterizedType_ParameterizedFixedChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedChar.variation) +inline void ParameterizedType_ParameterizedFixedChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer) } // .io.substrait.Type.Nullability nullability = 3; @@ -3459,81 +3333,24 @@ inline void ParameterizedType_ParameterizedVarChar::set_allocated_length(::io::s // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedVarChar.length) } -// .io.substrait.Type.Variation variation = 2; -inline bool ParameterizedType_ParameterizedVarChar::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool ParameterizedType_ParameterizedVarChar::has_variation() const { - return _internal_has_variation(); +// uint32 variation_pointer = 2; +inline void ParameterizedType_ParameterizedVarChar::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedVarChar::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedVarChar::_internal_variation_pointer() const { + return variation_pointer_; } -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedVarChar::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedVarChar.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedVarChar::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedVarChar.variation_pointer) + return _internal_variation_pointer(); } -inline void ParameterizedType_ParameterizedVarChar::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedVarChar.variation) -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedVarChar::release_variation() { +inline void ParameterizedType_ParameterizedVarChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedVarChar::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedVarChar.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedVarChar::_internal_mutable_variation() { - - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedVarChar::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedVarChar.variation) - return _internal_mutable_variation(); -} -inline void ParameterizedType_ParameterizedVarChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedVarChar.variation) +inline void ParameterizedType_ParameterizedVarChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedVarChar.variation_pointer) } // .io.substrait.Type.Nullability nullability = 3; @@ -3643,81 +3460,24 @@ inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_length(::i // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) } -// .io.substrait.Type.Variation variation = 2; -inline bool ParameterizedType_ParameterizedFixedBinary::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool ParameterizedType_ParameterizedFixedBinary::has_variation() const { - return _internal_has_variation(); -} -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedFixedBinary::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +// uint32 variation_pointer = 2; +inline void ParameterizedType_ParameterizedFixedBinary::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedFixedBinary::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedBinary::_internal_variation_pointer() const { + return variation_pointer_; } -inline void ParameterizedType_ParameterizedFixedBinary::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation) -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedBinary::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedBinary::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedBinary::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer) + return _internal_variation_pointer(); } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedBinary::_internal_mutable_variation() { +inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedFixedBinary::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation) - return _internal_mutable_variation(); -} -inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation) +inline void ParameterizedType_ParameterizedFixedBinary::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer) } // .io.substrait.Type.Nullability nullability = 3; @@ -3910,81 +3670,24 @@ inline void ParameterizedType_ParameterizedDecimal::set_allocated_precision(::io // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.precision) } -// .io.substrait.Type.Variation variation = 3; -inline bool ParameterizedType_ParameterizedDecimal::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool ParameterizedType_ParameterizedDecimal::has_variation() const { - return _internal_has_variation(); +// uint32 variation_pointer = 3; +inline void ParameterizedType_ParameterizedDecimal::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedDecimal::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedDecimal::_internal_variation_pointer() const { + return variation_pointer_; } -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedDecimal::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedDecimal.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedDecimal::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedDecimal.variation_pointer) + return _internal_variation_pointer(); } -inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.variation) -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedDecimal::release_variation() { +inline void ParameterizedType_ParameterizedDecimal::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedDecimal.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedDecimal::_internal_mutable_variation() { - - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedDecimal::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedDecimal.variation) - return _internal_mutable_variation(); -} -inline void ParameterizedType_ParameterizedDecimal::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.variation) +inline void ParameterizedType_ParameterizedDecimal::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedDecimal.variation_pointer) } // .io.substrait.Type.Nullability nullability = 4; @@ -4050,81 +3753,24 @@ ParameterizedType_ParameterizedStruct::types() const { return types_; } -// .io.substrait.Type.Variation variation = 2; -inline bool ParameterizedType_ParameterizedStruct::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool ParameterizedType_ParameterizedStruct::has_variation() const { - return _internal_has_variation(); -} -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedStruct::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +// uint32 variation_pointer = 2; +inline void ParameterizedType_ParameterizedStruct::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedStruct::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedStruct.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedStruct::_internal_variation_pointer() const { + return variation_pointer_; } -inline void ParameterizedType_ParameterizedStruct::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedStruct.variation) -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedStruct::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedStruct::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedStruct.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedStruct::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedStruct.variation_pointer) + return _internal_variation_pointer(); } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedStruct::_internal_mutable_variation() { +inline void ParameterizedType_ParameterizedStruct::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedStruct::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedStruct.variation) - return _internal_mutable_variation(); -} -inline void ParameterizedType_ParameterizedStruct::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedStruct.variation) +inline void ParameterizedType_ParameterizedStruct::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedStruct.variation_pointer) } // .io.substrait.Type.Nullability nullability = 3; @@ -4395,81 +4041,24 @@ inline void ParameterizedType_ParameterizedList::set_allocated_type(::io::substr // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedList.type) } -// .io.substrait.Type.Variation variation = 2; -inline bool ParameterizedType_ParameterizedList::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool ParameterizedType_ParameterizedList::has_variation() const { - return _internal_has_variation(); -} -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedList::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +// uint32 variation_pointer = 2; +inline void ParameterizedType_ParameterizedList::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedList::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedList.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedList::_internal_variation_pointer() const { + return variation_pointer_; } -inline void ParameterizedType_ParameterizedList::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedList.variation) -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedList::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedList::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedList.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedList::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedList.variation_pointer) + return _internal_variation_pointer(); } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedList::_internal_mutable_variation() { +inline void ParameterizedType_ParameterizedList::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedList::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedList.variation) - return _internal_mutable_variation(); -} -inline void ParameterizedType_ParameterizedList::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedList.variation) +inline void ParameterizedType_ParameterizedList::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedList.variation_pointer) } // .io.substrait.Type.Nullability nullability = 3; @@ -4662,81 +4251,24 @@ inline void ParameterizedType_ParameterizedMap::set_allocated_value(::io::substr // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.value) } -// .io.substrait.Type.Variation variation = 3; -inline bool ParameterizedType_ParameterizedMap::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool ParameterizedType_ParameterizedMap::has_variation() const { - return _internal_has_variation(); -} -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedMap::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +// uint32 variation_pointer = 3; +inline void ParameterizedType_ParameterizedMap::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline const ::io::substrait::Type_Variation& ParameterizedType_ParameterizedMap::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedMap.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedMap::_internal_variation_pointer() const { + return variation_pointer_; } -inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.variation) -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedMap::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedMap::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedMap.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedMap::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedMap.variation_pointer) + return _internal_variation_pointer(); } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedMap::_internal_mutable_variation() { +inline void ParameterizedType_ParameterizedMap::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* ParameterizedType_ParameterizedMap::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedMap.variation) - return _internal_mutable_variation(); -} -inline void ParameterizedType_ParameterizedMap::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.variation) +inline void ParameterizedType_ParameterizedMap::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedMap.variation_pointer) } // .io.substrait.Type.Nullability nullability = 4; @@ -6438,69 +5970,42 @@ inline ::io::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::m return _internal_mutable_map(); } -// .io.substrait.Extensions.TypeId user_defined = 31; -inline bool ParameterizedType::_internal_has_user_defined() const { - return kind_case() == kUserDefined; +// uint32 user_defined_pointer = 31; +inline bool ParameterizedType::_internal_has_user_defined_pointer() const { + return kind_case() == kUserDefinedPointer; } -inline bool ParameterizedType::has_user_defined() const { - return _internal_has_user_defined(); +inline bool ParameterizedType::has_user_defined_pointer() const { + return _internal_has_user_defined_pointer(); } -inline void ParameterizedType::set_has_user_defined() { - _oneof_case_[0] = kUserDefined; +inline void ParameterizedType::set_has_user_defined_pointer() { + _oneof_case_[0] = kUserDefinedPointer; } -inline ::io::substrait::Extensions_TypeId* ParameterizedType::release_user_defined() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.user_defined) - if (_internal_has_user_defined()) { +inline void ParameterizedType::clear_user_defined_pointer() { + if (_internal_has_user_defined_pointer()) { + kind_.user_defined_pointer_ = 0u; clear_has_kind(); - ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.user_defined_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::Extensions_TypeId& ParameterizedType::_internal_user_defined() const { - return _internal_has_user_defined() - ? *kind_.user_defined_ - : reinterpret_cast< ::io::substrait::Extensions_TypeId&>(::io::substrait::_Extensions_TypeId_default_instance_); -} -inline const ::io::substrait::Extensions_TypeId& ParameterizedType::user_defined() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.user_defined) - return _internal_user_defined(); -} -inline ::io::substrait::Extensions_TypeId* ParameterizedType::unsafe_arena_release_user_defined() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.user_defined) - if (_internal_has_user_defined()) { - clear_has_kind(); - ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; - kind_.user_defined_ = nullptr; - return temp; - } else { - return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { - clear_kind(); - if (user_defined) { - set_has_user_defined(); - kind_.user_defined_ = user_defined; +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType::_internal_user_defined_pointer() const { + if (_internal_has_user_defined_pointer()) { + return kind_.user_defined_pointer_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.user_defined) + return 0u; } -inline ::io::substrait::Extensions_TypeId* ParameterizedType::_internal_mutable_user_defined() { - if (!_internal_has_user_defined()) { +inline void ParameterizedType::_internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + if (!_internal_has_user_defined_pointer()) { clear_kind(); - set_has_user_defined(); - kind_.user_defined_ = CreateMaybeMessage< ::io::substrait::Extensions_TypeId >(GetArena()); + set_has_user_defined_pointer(); } - return kind_.user_defined_; + kind_.user_defined_pointer_ = value; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType::user_defined_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.user_defined_pointer) + return _internal_user_defined_pointer(); } -inline ::io::substrait::Extensions_TypeId* ParameterizedType::mutable_user_defined() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.user_defined) - return _internal_mutable_user_defined(); +inline void ParameterizedType::set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_user_defined_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.user_defined_pointer) } // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; diff --git a/cpp/src/generated/substrait/plan.pb.cc b/cpp/src/generated/substrait/plan.pb.cc index f0b88d69829..edfbc2b7747 100644 --- a/cpp/src/generated/substrait/plan.pb.cc +++ b/cpp/src/generated/substrait/plan.pb.cc @@ -18,11 +18,25 @@ PROTOBUF_PRAGMA_INIT_SEG namespace io { namespace substrait { +constexpr PlanRel::PlanRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct PlanRelDefaultTypeInternal { + constexpr PlanRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~PlanRelDefaultTypeInternal() {} + union { + PlanRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PlanRelDefaultTypeInternal _PlanRel_default_instance_; constexpr Plan::Plan( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : extensions_() - , mappings_() - , relations_(){} + : extension_uris_() + , extensions_() + , relations_() + , expected_type_urls_() + , advanced_extensions_(nullptr){} struct PlanDefaultTypeInternal { constexpr PlanDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -34,36 +48,54 @@ struct PlanDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PlanDefaultTypeInternal _Plan_default_instance_; } // namespace substrait } // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_plan_2eproto[1]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_plan_2eproto[2]; static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_plan_2eproto = nullptr; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_plan_2eproto = nullptr; const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_plan_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::PlanRel, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::io::substrait::PlanRel, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::io::substrait::PlanRel, RelType_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, extension_uris_), PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, extensions_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, mappings_), PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, relations_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, advanced_extensions_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, expected_type_urls_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::Plan)}, + { 0, -1, sizeof(::io::substrait::PlanRel)}, + { 8, -1, sizeof(::io::substrait::Plan)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::io::substrait::_PlanRel_default_instance_), reinterpret_cast(&::io::substrait::_Plan_default_instance_), }; const char descriptor_table_protodef_plan_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\nplan.proto\022\014io.substrait\032\017relations.pr" - "oto\032\020extensions.proto\"\230\001\n\004Plan\0226\n\nextens" - "ions\030\001 \003(\0132\".io.substrait.Extensions.Ext" - "ension\0222\n\010mappings\030\002 \003(\0132 .io.substrait." - "Extensions.Mapping\022$\n\trelations\030\003 \003(\0132\021." - "io.substrait.RelB\027P\001\252\002\022Substrait.Protobu" - "fb\006proto3" + "oto\032\020extensions.proto\"]\n\007PlanRel\022 \n\003rel\030" + "\001 \001(\0132\021.io.substrait.RelH\000\022%\n\004root\030\002 \001(\013" + "2\025.io.substrait.RelRootH\000B\t\n\007RelType\"\243\002\n" + "\004Plan\022C\n\016extension_uris\030\001 \003(\0132+.io.subst" + "rait.extensions.SimpleExtensionURI\022G\n\nex" + "tensions\030\002 \003(\01323.io.substrait.extensions" + ".SimpleExtensionDeclaration\022(\n\trelations" + "\030\003 \003(\0132\025.io.substrait.PlanRel\022G\n\023advance" + "d_extensions\030\004 \001(\0132*.io.substrait.extens" + "ions.AdvancedExtension\022\032\n\022expected_type_" + "urls\030\005 \003(\tB+\n\022io.substrait.protoP\001\252\002\022Sub" + "strait.Protobufb\006proto3" ; static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_plan_2eproto_deps[2] = { &::descriptor_table_extensions_2eproto, @@ -71,8 +103,8 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor }; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_plan_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_plan_2eproto = { - false, false, 249, descriptor_table_protodef_plan_2eproto, "plan.proto", - &descriptor_table_plan_2eproto_once, descriptor_table_plan_2eproto_deps, 2, 1, + false, false, 503, descriptor_table_protodef_plan_2eproto, "plan.proto", + &descriptor_table_plan_2eproto_once, descriptor_table_plan_2eproto_deps, 2, 2, schemas, file_default_instances, TableStruct_plan_2eproto::offsets, file_level_metadata_plan_2eproto, file_level_enum_descriptors_plan_2eproto, file_level_service_descriptors_plan_2eproto, }; @@ -87,38 +119,379 @@ namespace substrait { // =================================================================== +class PlanRel::_Internal { + public: + static const ::io::substrait::Rel& rel(const PlanRel* msg); + static const ::io::substrait::RelRoot& root(const PlanRel* msg); +}; + +const ::io::substrait::Rel& +PlanRel::_Internal::rel(const PlanRel* msg) { + return *msg->RelType_.rel_; +} +const ::io::substrait::RelRoot& +PlanRel::_Internal::root(const PlanRel* msg) { + return *msg->RelType_.root_; +} +void PlanRel::set_allocated_rel(::io::substrait::Rel* rel) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (rel) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rel)->GetArena(); + if (message_arena != submessage_arena) { + rel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, rel, submessage_arena); + } + set_has_rel(); + RelType_.rel_ = rel; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.PlanRel.rel) +} +void PlanRel::clear_rel() { + if (_internal_has_rel()) { + if (GetArena() == nullptr) { + delete RelType_.rel_; + } + clear_has_RelType(); + } +} +void PlanRel::set_allocated_root(::io::substrait::RelRoot* root) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (root) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(root)->GetArena(); + if (message_arena != submessage_arena) { + root = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, root, submessage_arena); + } + set_has_root(); + RelType_.root_ = root; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.PlanRel.root) +} +void PlanRel::clear_root() { + if (_internal_has_root()) { + if (GetArena() == nullptr) { + delete RelType_.root_; + } + clear_has_RelType(); + } +} +PlanRel::PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.PlanRel) +} +PlanRel::PlanRel(const PlanRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_RelType(); + switch (from.RelType_case()) { + case kRel: { + _internal_mutable_rel()->::io::substrait::Rel::MergeFrom(from._internal_rel()); + break; + } + case kRoot: { + _internal_mutable_root()->::io::substrait::RelRoot::MergeFrom(from._internal_root()); + break; + } + case RELTYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.PlanRel) +} + +void PlanRel::SharedCtor() { +clear_has_RelType(); +} + +PlanRel::~PlanRel() { + // @@protoc_insertion_point(destructor:io.substrait.PlanRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void PlanRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_RelType()) { + clear_RelType(); + } +} + +void PlanRel::ArenaDtor(void* object) { + PlanRel* _this = reinterpret_cast< PlanRel* >(object); + (void)_this; +} +void PlanRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void PlanRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void PlanRel::clear_RelType() { +// @@protoc_insertion_point(one_of_clear_start:io.substrait.PlanRel) + switch (RelType_case()) { + case kRel: { + if (GetArena() == nullptr) { + delete RelType_.rel_; + } + break; + } + case kRoot: { + if (GetArena() == nullptr) { + delete RelType_.root_; + } + break; + } + case RELTYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = RELTYPE_NOT_SET; +} + + +void PlanRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.PlanRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_RelType(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* PlanRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.Rel rel = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_rel(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.RelRoot root = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_root(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* PlanRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.PlanRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.Rel rel = 1; + if (_internal_has_rel()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::rel(this), target, stream); + } + + // .io.substrait.RelRoot root = 2; + if (_internal_has_root()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::root(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.PlanRel) + return target; +} + +size_t PlanRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.PlanRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (RelType_case()) { + // .io.substrait.Rel rel = 1; + case kRel: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.rel_); + break; + } + // .io.substrait.RelRoot root = 2; + case kRoot: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.root_); + break; + } + case RELTYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void PlanRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.PlanRel) + GOOGLE_DCHECK_NE(&from, this); + const PlanRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.PlanRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.PlanRel) + MergeFrom(*source); + } +} + +void PlanRel::MergeFrom(const PlanRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.PlanRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.RelType_case()) { + case kRel: { + _internal_mutable_rel()->::io::substrait::Rel::MergeFrom(from._internal_rel()); + break; + } + case kRoot: { + _internal_mutable_root()->::io::substrait::RelRoot::MergeFrom(from._internal_root()); + break; + } + case RELTYPE_NOT_SET: { + break; + } + } +} + +void PlanRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.PlanRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PlanRel::CopyFrom(const PlanRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.PlanRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PlanRel::IsInitialized() const { + return true; +} + +void PlanRel::InternalSwap(PlanRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(RelType_, other->RelType_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata PlanRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once, + file_level_metadata_plan_2eproto[0]); +} + +// =================================================================== + class Plan::_Internal { public: + static const ::io::substrait::extensions::AdvancedExtension& advanced_extensions(const Plan* msg); }; +const ::io::substrait::extensions::AdvancedExtension& +Plan::_Internal::advanced_extensions(const Plan* msg) { + return *msg->advanced_extensions_; +} +void Plan::clear_extension_uris() { + extension_uris_.Clear(); +} void Plan::clear_extensions() { extensions_.Clear(); } -void Plan::clear_mappings() { - mappings_.Clear(); -} -void Plan::clear_relations() { - relations_.Clear(); +void Plan::clear_advanced_extensions() { + if (GetArena() == nullptr && advanced_extensions_ != nullptr) { + delete advanced_extensions_; + } + advanced_extensions_ = nullptr; } Plan::Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), + extension_uris_(arena), extensions_(arena), - mappings_(arena), - relations_(arena) { + relations_(arena), + expected_type_urls_(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:io.substrait.Plan) } Plan::Plan(const Plan& from) : ::PROTOBUF_NAMESPACE_ID::Message(), + extension_uris_(from.extension_uris_), extensions_(from.extensions_), - mappings_(from.mappings_), - relations_(from.relations_) { + relations_(from.relations_), + expected_type_urls_(from.expected_type_urls_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_advanced_extensions()) { + advanced_extensions_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extensions_); + } else { + advanced_extensions_ = nullptr; + } // @@protoc_insertion_point(copy_constructor:io.substrait.Plan) } void Plan::SharedCtor() { +advanced_extensions_ = nullptr; } Plan::~Plan() { @@ -129,6 +502,7 @@ Plan::~Plan() { void Plan::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete advanced_extensions_; } void Plan::ArenaDtor(void* object) { @@ -147,9 +521,14 @@ void Plan::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + extension_uris_.Clear(); extensions_.Clear(); - mappings_.Clear(); relations_.Clear(); + expected_type_urls_.Clear(); + if (GetArena() == nullptr && advanced_extensions_ != nullptr) { + delete advanced_extensions_; + } + advanced_extensions_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -159,31 +538,31 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Extensions.Extension extensions = 1; + // repeated .io.substrait.extensions.SimpleExtensionURI extension_uris = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; do { ptr += 1; - ptr = ctx->ParseMessage(_internal_add_extensions(), ptr); + ptr = ctx->ParseMessage(_internal_add_extension_uris(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // repeated .io.substrait.Extensions.Mapping mappings = 2; + // repeated .io.substrait.extensions.SimpleExtensionDeclaration extensions = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; do { ptr += 1; - ptr = ctx->ParseMessage(_internal_add_mappings(), ptr); + ptr = ctx->ParseMessage(_internal_add_extensions(), ptr); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // repeated .io.substrait.Rel relations = 3; + // repeated .io.substrait.PlanRel relations = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; @@ -195,6 +574,27 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; + // .io.substrait.extensions.AdvancedExtension advanced_extensions = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extensions(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated string expected_type_urls = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_expected_type_urls(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Plan.expected_type_urls")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -224,23 +624,23 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Extensions.Extension extensions = 1; + // repeated .io.substrait.extensions.SimpleExtensionURI extension_uris = 1; for (unsigned int i = 0, - n = static_cast(this->_internal_extensions_size()); i < n; i++) { + n = static_cast(this->_internal_extension_uris_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_extensions(i), target, stream); + InternalWriteMessage(1, this->_internal_extension_uris(i), target, stream); } - // repeated .io.substrait.Extensions.Mapping mappings = 2; + // repeated .io.substrait.extensions.SimpleExtensionDeclaration extensions = 2; for (unsigned int i = 0, - n = static_cast(this->_internal_mappings_size()); i < n; i++) { + n = static_cast(this->_internal_extensions_size()); i < n; i++) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_mappings(i), target, stream); + InternalWriteMessage(2, this->_internal_extensions(i), target, stream); } - // repeated .io.substrait.Rel relations = 3; + // repeated .io.substrait.PlanRel relations = 3; for (unsigned int i = 0, n = static_cast(this->_internal_relations_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -248,6 +648,24 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( InternalWriteMessage(3, this->_internal_relations(i), target, stream); } + // .io.substrait.extensions.AdvancedExtension advanced_extensions = 4; + if (this->has_advanced_extensions()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 4, _Internal::advanced_extensions(this), target, stream); + } + + // repeated string expected_type_urls = 5; + for (int i = 0, n = this->_internal_expected_type_urls_size(); i < n; i++) { + const auto& s = this->_internal_expected_type_urls(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.Plan.expected_type_urls"); + target = stream->WriteString(5, s, target); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -264,27 +682,42 @@ size_t Plan::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Extensions.Extension extensions = 1; - total_size += 1UL * this->_internal_extensions_size(); - for (const auto& msg : this->extensions_) { + // repeated .io.substrait.extensions.SimpleExtensionURI extension_uris = 1; + total_size += 1UL * this->_internal_extension_uris_size(); + for (const auto& msg : this->extension_uris_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.Extensions.Mapping mappings = 2; - total_size += 1UL * this->_internal_mappings_size(); - for (const auto& msg : this->mappings_) { + // repeated .io.substrait.extensions.SimpleExtensionDeclaration extensions = 2; + total_size += 1UL * this->_internal_extensions_size(); + for (const auto& msg : this->extensions_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.Rel relations = 3; + // repeated .io.substrait.PlanRel relations = 3; total_size += 1UL * this->_internal_relations_size(); for (const auto& msg : this->relations_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } + // repeated string expected_type_urls = 5; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(expected_type_urls_.size()); + for (int i = 0, n = expected_type_urls_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + expected_type_urls_.Get(i)); + } + + // .io.substrait.extensions.AdvancedExtension advanced_extensions = 4; + if (this->has_advanced_extensions()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extensions_); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -316,9 +749,13 @@ void Plan::MergeFrom(const Plan& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; + extension_uris_.MergeFrom(from.extension_uris_); extensions_.MergeFrom(from.extensions_); - mappings_.MergeFrom(from.mappings_); relations_.MergeFrom(from.relations_); + expected_type_urls_.MergeFrom(from.expected_type_urls_); + if (from.has_advanced_extensions()) { + _internal_mutable_advanced_extensions()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extensions()); + } } void Plan::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { @@ -342,21 +779,26 @@ bool Plan::IsInitialized() const { void Plan::InternalSwap(Plan* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + extension_uris_.InternalSwap(&other->extension_uris_); extensions_.InternalSwap(&other->extensions_); - mappings_.InternalSwap(&other->mappings_); relations_.InternalSwap(&other->relations_); + expected_type_urls_.InternalSwap(&other->expected_type_urls_); + swap(advanced_extensions_, other->advanced_extensions_); } ::PROTOBUF_NAMESPACE_ID::Metadata Plan::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once, - file_level_metadata_plan_2eproto[0]); + file_level_metadata_plan_2eproto[1]); } // @@protoc_insertion_point(namespace_scope) } // namespace substrait } // namespace io PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::io::substrait::PlanRel* Arena::CreateMaybeMessage< ::io::substrait::PlanRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::PlanRel >(arena); +} template<> PROTOBUF_NOINLINE ::io::substrait::Plan* Arena::CreateMaybeMessage< ::io::substrait::Plan >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Plan >(arena); } diff --git a/cpp/src/generated/substrait/plan.pb.h b/cpp/src/generated/substrait/plan.pb.h index 285766c9116..dfbd2528fa7 100644 --- a/cpp/src/generated/substrait/plan.pb.h +++ b/cpp/src/generated/substrait/plan.pb.h @@ -48,7 +48,7 @@ struct TableStruct_plan_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -60,16 +60,199 @@ namespace substrait { class Plan; struct PlanDefaultTypeInternal; extern PlanDefaultTypeInternal _Plan_default_instance_; +class PlanRel; +struct PlanRelDefaultTypeInternal; +extern PlanRelDefaultTypeInternal _PlanRel_default_instance_; } // namespace substrait } // namespace io PROTOBUF_NAMESPACE_OPEN template<> ::io::substrait::Plan* Arena::CreateMaybeMessage<::io::substrait::Plan>(Arena*); +template<> ::io::substrait::PlanRel* Arena::CreateMaybeMessage<::io::substrait::PlanRel>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace io { namespace substrait { // =================================================================== +class PlanRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.PlanRel) */ { + public: + inline PlanRel() : PlanRel(nullptr) {} + ~PlanRel() override; + explicit constexpr PlanRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + PlanRel(const PlanRel& from); + PlanRel(PlanRel&& from) noexcept + : PlanRel() { + *this = ::std::move(from); + } + + inline PlanRel& operator=(const PlanRel& from) { + CopyFrom(from); + return *this; + } + inline PlanRel& operator=(PlanRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 PlanRel& default_instance() { + return *internal_default_instance(); + } + enum RelTypeCase { + kRel = 1, + kRoot = 2, + RELTYPE_NOT_SET = 0, + }; + + static inline const PlanRel* internal_default_instance() { + return reinterpret_cast( + &_PlanRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(PlanRel& a, PlanRel& b) { + a.Swap(&b); + } + inline void Swap(PlanRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PlanRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline PlanRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + PlanRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const PlanRel& from); + void MergeFrom(const PlanRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(PlanRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.PlanRel"; + } + protected: + explicit PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kRelFieldNumber = 1, + kRootFieldNumber = 2, + }; + // .io.substrait.Rel rel = 1; + bool has_rel() const; + private: + bool _internal_has_rel() const; + public: + void clear_rel(); + const ::io::substrait::Rel& rel() const; + ::io::substrait::Rel* release_rel(); + ::io::substrait::Rel* mutable_rel(); + void set_allocated_rel(::io::substrait::Rel* rel); + private: + const ::io::substrait::Rel& _internal_rel() const; + ::io::substrait::Rel* _internal_mutable_rel(); + public: + void unsafe_arena_set_allocated_rel( + ::io::substrait::Rel* rel); + ::io::substrait::Rel* unsafe_arena_release_rel(); + + // .io.substrait.RelRoot root = 2; + bool has_root() const; + private: + bool _internal_has_root() const; + public: + void clear_root(); + const ::io::substrait::RelRoot& root() const; + ::io::substrait::RelRoot* release_root(); + ::io::substrait::RelRoot* mutable_root(); + void set_allocated_root(::io::substrait::RelRoot* root); + private: + const ::io::substrait::RelRoot& _internal_root() const; + ::io::substrait::RelRoot* _internal_mutable_root(); + public: + void unsafe_arena_set_allocated_root( + ::io::substrait::RelRoot* root); + ::io::substrait::RelRoot* unsafe_arena_release_root(); + + void clear_RelType(); + RelTypeCase RelType_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.PlanRel) + private: + class _Internal; + void set_has_rel(); + void set_has_root(); + + inline bool has_RelType() const; + inline void clear_has_RelType(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union RelTypeUnion { + constexpr RelTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::Rel* rel_; + ::io::substrait::RelRoot* root_; + } RelType_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_plan_2eproto; +}; +// ------------------------------------------------------------------- + class Plan PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Plan) */ { public: @@ -113,7 +296,7 @@ class Plan PROTOBUF_FINAL : &_Plan_default_instance_); } static constexpr int kIndexInFileMessages = - 0; + 1; friend void swap(Plan& a, Plan& b) { a.Swap(&b); @@ -177,64 +360,108 @@ class Plan PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kExtensionsFieldNumber = 1, - kMappingsFieldNumber = 2, + kExtensionUrisFieldNumber = 1, + kExtensionsFieldNumber = 2, kRelationsFieldNumber = 3, + kExpectedTypeUrlsFieldNumber = 5, + kAdvancedExtensionsFieldNumber = 4, }; - // repeated .io.substrait.Extensions.Extension extensions = 1; - int extensions_size() const; + // repeated .io.substrait.extensions.SimpleExtensionURI extension_uris = 1; + int extension_uris_size() const; private: - int _internal_extensions_size() const; + int _internal_extension_uris_size() const; public: - void clear_extensions(); - ::io::substrait::Extensions_Extension* mutable_extensions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Extension >* - mutable_extensions(); + void clear_extension_uris(); + ::io::substrait::extensions::SimpleExtensionURI* mutable_extension_uris(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionURI >* + mutable_extension_uris(); private: - const ::io::substrait::Extensions_Extension& _internal_extensions(int index) const; - ::io::substrait::Extensions_Extension* _internal_add_extensions(); + const ::io::substrait::extensions::SimpleExtensionURI& _internal_extension_uris(int index) const; + ::io::substrait::extensions::SimpleExtensionURI* _internal_add_extension_uris(); public: - const ::io::substrait::Extensions_Extension& extensions(int index) const; - ::io::substrait::Extensions_Extension* add_extensions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Extension >& - extensions() const; + const ::io::substrait::extensions::SimpleExtensionURI& extension_uris(int index) const; + ::io::substrait::extensions::SimpleExtensionURI* add_extension_uris(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionURI >& + extension_uris() const; - // repeated .io.substrait.Extensions.Mapping mappings = 2; - int mappings_size() const; + // repeated .io.substrait.extensions.SimpleExtensionDeclaration extensions = 2; + int extensions_size() const; private: - int _internal_mappings_size() const; + int _internal_extensions_size() const; public: - void clear_mappings(); - ::io::substrait::Extensions_Mapping* mutable_mappings(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping >* - mutable_mappings(); + void clear_extensions(); + ::io::substrait::extensions::SimpleExtensionDeclaration* mutable_extensions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionDeclaration >* + mutable_extensions(); private: - const ::io::substrait::Extensions_Mapping& _internal_mappings(int index) const; - ::io::substrait::Extensions_Mapping* _internal_add_mappings(); + const ::io::substrait::extensions::SimpleExtensionDeclaration& _internal_extensions(int index) const; + ::io::substrait::extensions::SimpleExtensionDeclaration* _internal_add_extensions(); public: - const ::io::substrait::Extensions_Mapping& mappings(int index) const; - ::io::substrait::Extensions_Mapping* add_mappings(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping >& - mappings() const; + const ::io::substrait::extensions::SimpleExtensionDeclaration& extensions(int index) const; + ::io::substrait::extensions::SimpleExtensionDeclaration* add_extensions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionDeclaration >& + extensions() const; - // repeated .io.substrait.Rel relations = 3; + // repeated .io.substrait.PlanRel relations = 3; int relations_size() const; private: int _internal_relations_size() const; public: void clear_relations(); - ::io::substrait::Rel* mutable_relations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* + ::io::substrait::PlanRel* mutable_relations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::PlanRel >* mutable_relations(); private: - const ::io::substrait::Rel& _internal_relations(int index) const; - ::io::substrait::Rel* _internal_add_relations(); + const ::io::substrait::PlanRel& _internal_relations(int index) const; + ::io::substrait::PlanRel* _internal_add_relations(); public: - const ::io::substrait::Rel& relations(int index) const; - ::io::substrait::Rel* add_relations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& + const ::io::substrait::PlanRel& relations(int index) const; + ::io::substrait::PlanRel* add_relations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::PlanRel >& relations() const; + // repeated string expected_type_urls = 5; + int expected_type_urls_size() const; + private: + int _internal_expected_type_urls_size() const; + public: + void clear_expected_type_urls(); + const std::string& expected_type_urls(int index) const; + std::string* mutable_expected_type_urls(int index); + void set_expected_type_urls(int index, const std::string& value); + void set_expected_type_urls(int index, std::string&& value); + void set_expected_type_urls(int index, const char* value); + void set_expected_type_urls(int index, const char* value, size_t size); + std::string* add_expected_type_urls(); + void add_expected_type_urls(const std::string& value); + void add_expected_type_urls(std::string&& value); + void add_expected_type_urls(const char* value); + void add_expected_type_urls(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& expected_type_urls() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_expected_type_urls(); + private: + const std::string& _internal_expected_type_urls(int index) const; + std::string* _internal_add_expected_type_urls(); + public: + + // .io.substrait.extensions.AdvancedExtension advanced_extensions = 4; + bool has_advanced_extensions() const; + private: + bool _internal_has_advanced_extensions() const; + public: + void clear_advanced_extensions(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extensions() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extensions(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extensions(); + void set_allocated_advanced_extensions(::io::substrait::extensions::AdvancedExtension* advanced_extensions); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extensions() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extensions(); + public: + void unsafe_arena_set_allocated_advanced_extensions( + ::io::substrait::extensions::AdvancedExtension* advanced_extensions); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extensions(); + // @@protoc_insertion_point(class_scope:io.substrait.Plan) private: class _Internal; @@ -242,9 +469,11 @@ class Plan PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Extension > extensions_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping > mappings_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel > relations_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionURI > extension_uris_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionDeclaration > extensions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::PlanRel > relations_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField expected_type_urls_; + ::io::substrait::extensions::AdvancedExtension* advanced_extensions_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_plan_2eproto; }; @@ -257,119 +486,418 @@ class Plan PROTOBUF_FINAL : #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ +// PlanRel + +// .io.substrait.Rel rel = 1; +inline bool PlanRel::_internal_has_rel() const { + return RelType_case() == kRel; +} +inline bool PlanRel::has_rel() const { + return _internal_has_rel(); +} +inline void PlanRel::set_has_rel() { + _oneof_case_[0] = kRel; +} +inline ::io::substrait::Rel* PlanRel::release_rel() { + // @@protoc_insertion_point(field_release:io.substrait.PlanRel.rel) + if (_internal_has_rel()) { + clear_has_RelType(); + ::io::substrait::Rel* temp = RelType_.rel_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.rel_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::Rel& PlanRel::_internal_rel() const { + return _internal_has_rel() + ? *RelType_.rel_ + : reinterpret_cast< ::io::substrait::Rel&>(::io::substrait::_Rel_default_instance_); +} +inline const ::io::substrait::Rel& PlanRel::rel() const { + // @@protoc_insertion_point(field_get:io.substrait.PlanRel.rel) + return _internal_rel(); +} +inline ::io::substrait::Rel* PlanRel::unsafe_arena_release_rel() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.PlanRel.rel) + if (_internal_has_rel()) { + clear_has_RelType(); + ::io::substrait::Rel* temp = RelType_.rel_; + RelType_.rel_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void PlanRel::unsafe_arena_set_allocated_rel(::io::substrait::Rel* rel) { + clear_RelType(); + if (rel) { + set_has_rel(); + RelType_.rel_ = rel; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.PlanRel.rel) +} +inline ::io::substrait::Rel* PlanRel::_internal_mutable_rel() { + if (!_internal_has_rel()) { + clear_RelType(); + set_has_rel(); + RelType_.rel_ = CreateMaybeMessage< ::io::substrait::Rel >(GetArena()); + } + return RelType_.rel_; +} +inline ::io::substrait::Rel* PlanRel::mutable_rel() { + // @@protoc_insertion_point(field_mutable:io.substrait.PlanRel.rel) + return _internal_mutable_rel(); +} + +// .io.substrait.RelRoot root = 2; +inline bool PlanRel::_internal_has_root() const { + return RelType_case() == kRoot; +} +inline bool PlanRel::has_root() const { + return _internal_has_root(); +} +inline void PlanRel::set_has_root() { + _oneof_case_[0] = kRoot; +} +inline ::io::substrait::RelRoot* PlanRel::release_root() { + // @@protoc_insertion_point(field_release:io.substrait.PlanRel.root) + if (_internal_has_root()) { + clear_has_RelType(); + ::io::substrait::RelRoot* temp = RelType_.root_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.root_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::RelRoot& PlanRel::_internal_root() const { + return _internal_has_root() + ? *RelType_.root_ + : reinterpret_cast< ::io::substrait::RelRoot&>(::io::substrait::_RelRoot_default_instance_); +} +inline const ::io::substrait::RelRoot& PlanRel::root() const { + // @@protoc_insertion_point(field_get:io.substrait.PlanRel.root) + return _internal_root(); +} +inline ::io::substrait::RelRoot* PlanRel::unsafe_arena_release_root() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.PlanRel.root) + if (_internal_has_root()) { + clear_has_RelType(); + ::io::substrait::RelRoot* temp = RelType_.root_; + RelType_.root_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void PlanRel::unsafe_arena_set_allocated_root(::io::substrait::RelRoot* root) { + clear_RelType(); + if (root) { + set_has_root(); + RelType_.root_ = root; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.PlanRel.root) +} +inline ::io::substrait::RelRoot* PlanRel::_internal_mutable_root() { + if (!_internal_has_root()) { + clear_RelType(); + set_has_root(); + RelType_.root_ = CreateMaybeMessage< ::io::substrait::RelRoot >(GetArena()); + } + return RelType_.root_; +} +inline ::io::substrait::RelRoot* PlanRel::mutable_root() { + // @@protoc_insertion_point(field_mutable:io.substrait.PlanRel.root) + return _internal_mutable_root(); +} + +inline bool PlanRel::has_RelType() const { + return RelType_case() != RELTYPE_NOT_SET; +} +inline void PlanRel::clear_has_RelType() { + _oneof_case_[0] = RELTYPE_NOT_SET; +} +inline PlanRel::RelTypeCase PlanRel::RelType_case() const { + return PlanRel::RelTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + // Plan -// repeated .io.substrait.Extensions.Extension extensions = 1; +// repeated .io.substrait.extensions.SimpleExtensionURI extension_uris = 1; +inline int Plan::_internal_extension_uris_size() const { + return extension_uris_.size(); +} +inline int Plan::extension_uris_size() const { + return _internal_extension_uris_size(); +} +inline ::io::substrait::extensions::SimpleExtensionURI* Plan::mutable_extension_uris(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Plan.extension_uris) + return extension_uris_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionURI >* +Plan::mutable_extension_uris() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.extension_uris) + return &extension_uris_; +} +inline const ::io::substrait::extensions::SimpleExtensionURI& Plan::_internal_extension_uris(int index) const { + return extension_uris_.Get(index); +} +inline const ::io::substrait::extensions::SimpleExtensionURI& Plan::extension_uris(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Plan.extension_uris) + return _internal_extension_uris(index); +} +inline ::io::substrait::extensions::SimpleExtensionURI* Plan::_internal_add_extension_uris() { + return extension_uris_.Add(); +} +inline ::io::substrait::extensions::SimpleExtensionURI* Plan::add_extension_uris() { + // @@protoc_insertion_point(field_add:io.substrait.Plan.extension_uris) + return _internal_add_extension_uris(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionURI >& +Plan::extension_uris() const { + // @@protoc_insertion_point(field_list:io.substrait.Plan.extension_uris) + return extension_uris_; +} + +// repeated .io.substrait.extensions.SimpleExtensionDeclaration extensions = 2; inline int Plan::_internal_extensions_size() const { return extensions_.size(); } inline int Plan::extensions_size() const { return _internal_extensions_size(); } -inline ::io::substrait::Extensions_Extension* Plan::mutable_extensions(int index) { +inline ::io::substrait::extensions::SimpleExtensionDeclaration* Plan::mutable_extensions(int index) { // @@protoc_insertion_point(field_mutable:io.substrait.Plan.extensions) return extensions_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Extension >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionDeclaration >* Plan::mutable_extensions() { // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.extensions) return &extensions_; } -inline const ::io::substrait::Extensions_Extension& Plan::_internal_extensions(int index) const { +inline const ::io::substrait::extensions::SimpleExtensionDeclaration& Plan::_internal_extensions(int index) const { return extensions_.Get(index); } -inline const ::io::substrait::Extensions_Extension& Plan::extensions(int index) const { +inline const ::io::substrait::extensions::SimpleExtensionDeclaration& Plan::extensions(int index) const { // @@protoc_insertion_point(field_get:io.substrait.Plan.extensions) return _internal_extensions(index); } -inline ::io::substrait::Extensions_Extension* Plan::_internal_add_extensions() { +inline ::io::substrait::extensions::SimpleExtensionDeclaration* Plan::_internal_add_extensions() { return extensions_.Add(); } -inline ::io::substrait::Extensions_Extension* Plan::add_extensions() { +inline ::io::substrait::extensions::SimpleExtensionDeclaration* Plan::add_extensions() { // @@protoc_insertion_point(field_add:io.substrait.Plan.extensions) return _internal_add_extensions(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Extension >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionDeclaration >& Plan::extensions() const { // @@protoc_insertion_point(field_list:io.substrait.Plan.extensions) return extensions_; } -// repeated .io.substrait.Extensions.Mapping mappings = 2; -inline int Plan::_internal_mappings_size() const { - return mappings_.size(); -} -inline int Plan::mappings_size() const { - return _internal_mappings_size(); -} -inline ::io::substrait::Extensions_Mapping* Plan::mutable_mappings(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Plan.mappings) - return mappings_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping >* -Plan::mutable_mappings() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.mappings) - return &mappings_; -} -inline const ::io::substrait::Extensions_Mapping& Plan::_internal_mappings(int index) const { - return mappings_.Get(index); -} -inline const ::io::substrait::Extensions_Mapping& Plan::mappings(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Plan.mappings) - return _internal_mappings(index); -} -inline ::io::substrait::Extensions_Mapping* Plan::_internal_add_mappings() { - return mappings_.Add(); -} -inline ::io::substrait::Extensions_Mapping* Plan::add_mappings() { - // @@protoc_insertion_point(field_add:io.substrait.Plan.mappings) - return _internal_add_mappings(); -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Extensions_Mapping >& -Plan::mappings() const { - // @@protoc_insertion_point(field_list:io.substrait.Plan.mappings) - return mappings_; -} - -// repeated .io.substrait.Rel relations = 3; +// repeated .io.substrait.PlanRel relations = 3; inline int Plan::_internal_relations_size() const { return relations_.size(); } inline int Plan::relations_size() const { return _internal_relations_size(); } -inline ::io::substrait::Rel* Plan::mutable_relations(int index) { +inline void Plan::clear_relations() { + relations_.Clear(); +} +inline ::io::substrait::PlanRel* Plan::mutable_relations(int index) { // @@protoc_insertion_point(field_mutable:io.substrait.Plan.relations) return relations_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::PlanRel >* Plan::mutable_relations() { // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.relations) return &relations_; } -inline const ::io::substrait::Rel& Plan::_internal_relations(int index) const { +inline const ::io::substrait::PlanRel& Plan::_internal_relations(int index) const { return relations_.Get(index); } -inline const ::io::substrait::Rel& Plan::relations(int index) const { +inline const ::io::substrait::PlanRel& Plan::relations(int index) const { // @@protoc_insertion_point(field_get:io.substrait.Plan.relations) return _internal_relations(index); } -inline ::io::substrait::Rel* Plan::_internal_add_relations() { +inline ::io::substrait::PlanRel* Plan::_internal_add_relations() { return relations_.Add(); } -inline ::io::substrait::Rel* Plan::add_relations() { +inline ::io::substrait::PlanRel* Plan::add_relations() { // @@protoc_insertion_point(field_add:io.substrait.Plan.relations) return _internal_add_relations(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::PlanRel >& Plan::relations() const { // @@protoc_insertion_point(field_list:io.substrait.Plan.relations) return relations_; } +// .io.substrait.extensions.AdvancedExtension advanced_extensions = 4; +inline bool Plan::_internal_has_advanced_extensions() const { + return this != internal_default_instance() && advanced_extensions_ != nullptr; +} +inline bool Plan::has_advanced_extensions() const { + return _internal_has_advanced_extensions(); +} +inline const ::io::substrait::extensions::AdvancedExtension& Plan::_internal_advanced_extensions() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extensions_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& Plan::advanced_extensions() const { + // @@protoc_insertion_point(field_get:io.substrait.Plan.advanced_extensions) + return _internal_advanced_extensions(); +} +inline void Plan::unsafe_arena_set_allocated_advanced_extensions( + ::io::substrait::extensions::AdvancedExtension* advanced_extensions) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions_); + } + advanced_extensions_ = advanced_extensions; + if (advanced_extensions) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Plan.advanced_extensions) +} +inline ::io::substrait::extensions::AdvancedExtension* Plan::release_advanced_extensions() { + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extensions_; + advanced_extensions_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* Plan::unsafe_arena_release_advanced_extensions() { + // @@protoc_insertion_point(field_release:io.substrait.Plan.advanced_extensions) + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extensions_; + advanced_extensions_ = nullptr; + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* Plan::_internal_mutable_advanced_extensions() { + + if (advanced_extensions_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extensions_ = p; + } + return advanced_extensions_; +} +inline ::io::substrait::extensions::AdvancedExtension* Plan::mutable_advanced_extensions() { + // @@protoc_insertion_point(field_mutable:io.substrait.Plan.advanced_extensions) + return _internal_mutable_advanced_extensions(); +} +inline void Plan::set_allocated_advanced_extensions(::io::substrait::extensions::AdvancedExtension* advanced_extensions) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions_); + } + if (advanced_extensions) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions)->GetArena(); + if (message_arena != submessage_arena) { + advanced_extensions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extensions, submessage_arena); + } + + } else { + + } + advanced_extensions_ = advanced_extensions; + // @@protoc_insertion_point(field_set_allocated:io.substrait.Plan.advanced_extensions) +} + +// repeated string expected_type_urls = 5; +inline int Plan::_internal_expected_type_urls_size() const { + return expected_type_urls_.size(); +} +inline int Plan::expected_type_urls_size() const { + return _internal_expected_type_urls_size(); +} +inline void Plan::clear_expected_type_urls() { + expected_type_urls_.Clear(); +} +inline std::string* Plan::add_expected_type_urls() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.Plan.expected_type_urls) + return _internal_add_expected_type_urls(); +} +inline const std::string& Plan::_internal_expected_type_urls(int index) const { + return expected_type_urls_.Get(index); +} +inline const std::string& Plan::expected_type_urls(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.Plan.expected_type_urls) + return _internal_expected_type_urls(index); +} +inline std::string* Plan::mutable_expected_type_urls(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.Plan.expected_type_urls) + return expected_type_urls_.Mutable(index); +} +inline void Plan::set_expected_type_urls(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.Plan.expected_type_urls) + expected_type_urls_.Mutable(index)->assign(value); +} +inline void Plan::set_expected_type_urls(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.Plan.expected_type_urls) + expected_type_urls_.Mutable(index)->assign(std::move(value)); +} +inline void Plan::set_expected_type_urls(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + expected_type_urls_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.Plan.expected_type_urls) +} +inline void Plan::set_expected_type_urls(int index, const char* value, size_t size) { + expected_type_urls_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.Plan.expected_type_urls) +} +inline std::string* Plan::_internal_add_expected_type_urls() { + return expected_type_urls_.Add(); +} +inline void Plan::add_expected_type_urls(const std::string& value) { + expected_type_urls_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.Plan.expected_type_urls) +} +inline void Plan::add_expected_type_urls(std::string&& value) { + expected_type_urls_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.Plan.expected_type_urls) +} +inline void Plan::add_expected_type_urls(const char* value) { + GOOGLE_DCHECK(value != nullptr); + expected_type_urls_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.Plan.expected_type_urls) +} +inline void Plan::add_expected_type_urls(const char* value, size_t size) { + expected_type_urls_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.Plan.expected_type_urls) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +Plan::expected_type_urls() const { + // @@protoc_insertion_point(field_list:io.substrait.Plan.expected_type_urls) + return expected_type_urls_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +Plan::mutable_expected_type_urls() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.expected_type_urls) + return &expected_type_urls_; +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/cpp/src/generated/substrait/relations.pb.cc b/cpp/src/generated/substrait/relations.pb.cc index 624e490f57c..7a44a3bbfa5 100644 --- a/cpp/src/generated/substrait/relations.pb.cc +++ b/cpp/src/generated/substrait/relations.pb.cc @@ -44,7 +44,8 @@ struct RelCommon_EmitDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_EmitDefaultTypeInternal _RelCommon_Emit_default_instance_; constexpr RelCommon_Hint_Stats::RelCommon_Hint_Stats( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : row_count_(0) + : advanced_extension_(nullptr) + , row_count_(0) , record_size_(0){} struct RelCommon_Hint_StatsDefaultTypeInternal { constexpr RelCommon_Hint_StatsDefaultTypeInternal() @@ -55,23 +56,23 @@ struct RelCommon_Hint_StatsDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_StatsDefaultTypeInternal _RelCommon_Hint_Stats_default_instance_; -constexpr RelCommon_Hint_HintKeyValue::RelCommon_Hint_HintKeyValue( +constexpr RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct RelCommon_Hint_HintKeyValueDefaultTypeInternal { - constexpr RelCommon_Hint_HintKeyValueDefaultTypeInternal() + : advanced_extension_(nullptr){} +struct RelCommon_Hint_RuntimeConstraintDefaultTypeInternal { + constexpr RelCommon_Hint_RuntimeConstraintDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~RelCommon_Hint_HintKeyValueDefaultTypeInternal() {} + ~RelCommon_Hint_RuntimeConstraintDefaultTypeInternal() {} union { - RelCommon_Hint_HintKeyValue _instance; + RelCommon_Hint_RuntimeConstraint _instance; }; }; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_HintKeyValueDefaultTypeInternal _RelCommon_Hint_HintKeyValue_default_instance_; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_RuntimeConstraintDefaultTypeInternal _RelCommon_Hint_RuntimeConstraint_default_instance_; constexpr RelCommon_Hint::RelCommon_Hint( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : hint_key_values_() - , stats_(nullptr){} + : stats_(nullptr) + , constraint_(nullptr) + , advanced_extension_(nullptr){} struct RelCommon_HintDefaultTypeInternal { constexpr RelCommon_HintDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -81,21 +82,10 @@ struct RelCommon_HintDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_HintDefaultTypeInternal _RelCommon_Hint_default_instance_; -constexpr RelCommon_RuntimeConstraint::RelCommon_RuntimeConstraint( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} -struct RelCommon_RuntimeConstraintDefaultTypeInternal { - constexpr RelCommon_RuntimeConstraintDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~RelCommon_RuntimeConstraintDefaultTypeInternal() {} - union { - RelCommon_RuntimeConstraint _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_RuntimeConstraintDefaultTypeInternal _RelCommon_RuntimeConstraint_default_instance_; constexpr RelCommon::RelCommon( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : hint_(nullptr) - , constraint_(nullptr) + , advanced_extension_(nullptr) , _oneof_case_{}{} struct RelCommonDefaultTypeInternal { constexpr RelCommonDefaultTypeInternal() @@ -108,7 +98,8 @@ struct RelCommonDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommonDefaultTypeInternal _RelCommon_default_instance_; constexpr ReadRel_NamedTable::ReadRel_NamedTable( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : names_(){} + : names_() + , advanced_extension_(nullptr){} struct ReadRel_NamedTableDefaultTypeInternal { constexpr ReadRel_NamedTableDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -130,6 +121,18 @@ struct ReadRel_VirtualTableDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_VirtualTableDefaultTypeInternal _ReadRel_VirtualTable_default_instance_; +constexpr ReadRel_ExtensionTable::ReadRel_ExtensionTable( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : detail_(nullptr){} +struct ReadRel_ExtensionTableDefaultTypeInternal { + constexpr ReadRel_ExtensionTableDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ReadRel_ExtensionTableDefaultTypeInternal() {} + union { + ReadRel_ExtensionTable _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_ExtensionTableDefaultTypeInternal _ReadRel_ExtensionTable_default_instance_; constexpr ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : format_(0) @@ -146,7 +149,8 @@ struct ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal _ReadRel_LocalFiles_FileOrFiles_default_instance_; constexpr ReadRel_LocalFiles::ReadRel_LocalFiles( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : items_(){} + : items_() + , advanced_extension_(nullptr){} struct ReadRel_LocalFilesDefaultTypeInternal { constexpr ReadRel_LocalFilesDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -162,6 +166,7 @@ constexpr ReadRel::ReadRel( , base_schema_(nullptr) , filter_(nullptr) , projection_(nullptr) + , advanced_extension_(nullptr) , _oneof_case_{}{} struct ReadRelDefaultTypeInternal { constexpr ReadRelDefaultTypeInternal() @@ -176,7 +181,8 @@ constexpr ProjectRel::ProjectRel( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : expressions_() , common_(nullptr) - , input_(nullptr){} + , input_(nullptr) + , advanced_extension_(nullptr){} struct ProjectRelDefaultTypeInternal { constexpr ProjectRelDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -193,6 +199,7 @@ constexpr JoinRel::JoinRel( , right_(nullptr) , expression_(nullptr) , post_join_filter_(nullptr) + , advanced_extension_(nullptr) , type_(0) {} struct JoinRelDefaultTypeInternal { @@ -208,6 +215,7 @@ constexpr FetchRel::FetchRel( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : common_(nullptr) , input_(nullptr) + , advanced_extension_(nullptr) , offset_(PROTOBUF_LONGLONG(0)) , count_(PROTOBUF_LONGLONG(0)){} struct FetchRelDefaultTypeInternal { @@ -234,7 +242,8 @@ struct AggregateRel_GroupingDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRel_GroupingDefaultTypeInternal _AggregateRel_Grouping_default_instance_; constexpr AggregateRel_Measure::AggregateRel_Measure( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : measure_(nullptr){} + : measure_(nullptr) + , filter_(nullptr){} struct AggregateRel_MeasureDefaultTypeInternal { constexpr AggregateRel_MeasureDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -250,8 +259,7 @@ constexpr AggregateRel::AggregateRel( , measures_() , common_(nullptr) , input_(nullptr) - , phase_(0) -{} + , advanced_extension_(nullptr){} struct AggregateRelDefaultTypeInternal { constexpr AggregateRelDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -265,7 +273,8 @@ constexpr SortRel::SortRel( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : sorts_() , common_(nullptr) - , input_(nullptr){} + , input_(nullptr) + , advanced_extension_(nullptr){} struct SortRelDefaultTypeInternal { constexpr SortRelDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -279,7 +288,8 @@ constexpr FilterRel::FilterRel( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : common_(nullptr) , input_(nullptr) - , condition_(nullptr){} + , condition_(nullptr) + , advanced_extension_(nullptr){} struct FilterRelDefaultTypeInternal { constexpr FilterRelDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -293,6 +303,7 @@ constexpr SetRel::SetRel( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : inputs_() , common_(nullptr) + , advanced_extension_(nullptr) , op_(0) {} struct SetRelDefaultTypeInternal { @@ -304,6 +315,60 @@ struct SetRelDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SetRelDefaultTypeInternal _SetRel_default_instance_; +constexpr ExtensionSingleRel::ExtensionSingleRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : common_(nullptr) + , input_(nullptr) + , detail_(nullptr){} +struct ExtensionSingleRelDefaultTypeInternal { + constexpr ExtensionSingleRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ExtensionSingleRelDefaultTypeInternal() {} + union { + ExtensionSingleRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionSingleRelDefaultTypeInternal _ExtensionSingleRel_default_instance_; +constexpr ExtensionLeafRel::ExtensionLeafRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : common_(nullptr) + , detail_(nullptr){} +struct ExtensionLeafRelDefaultTypeInternal { + constexpr ExtensionLeafRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ExtensionLeafRelDefaultTypeInternal() {} + union { + ExtensionLeafRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionLeafRelDefaultTypeInternal _ExtensionLeafRel_default_instance_; +constexpr ExtensionMultiRel::ExtensionMultiRel( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : inputs_() + , common_(nullptr) + , detail_(nullptr){} +struct ExtensionMultiRelDefaultTypeInternal { + constexpr ExtensionMultiRelDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~ExtensionMultiRelDefaultTypeInternal() {} + union { + ExtensionMultiRel _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionMultiRelDefaultTypeInternal _ExtensionMultiRel_default_instance_; +constexpr RelRoot::RelRoot( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : names_() + , input_(nullptr){} +struct RelRootDefaultTypeInternal { + constexpr RelRootDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~RelRootDefaultTypeInternal() {} + union { + RelRoot _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelRootDefaultTypeInternal _RelRoot_default_instance_; constexpr Rel::Rel( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : _oneof_case_{}{} @@ -318,7 +383,7 @@ struct RelDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelDefaultTypeInternal _Rel_default_instance_; } // namespace substrait } // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_relations_2eproto[22]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_relations_2eproto[26]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_relations_2eproto[3]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_relations_2eproto = nullptr; @@ -341,25 +406,21 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_Stats, row_count_), PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_Stats, record_size_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_Stats, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_HintKeyValue, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_RuntimeConstraint, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_HintKeyValue, key_), - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_HintKeyValue, value_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_RuntimeConstraint, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, hint_key_values_), PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, stats_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_RuntimeConstraint, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, constraint_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, _internal_metadata_), ~0u, // no _extensions_ @@ -368,14 +429,15 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, hint_), - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, constraint_), - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, kind_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, emit_kind_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_NamedTable, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_NamedTable, names_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_NamedTable, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_VirtualTable, _internal_metadata_), ~0u, // no _extensions_ @@ -383,12 +445,20 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_VirtualTable, values_), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_ExtensionTable, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_ExtensionTable, detail_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, format_), PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, path_type_), ~0u, // no _has_bits_ @@ -397,6 +467,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles, items_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, _internal_metadata_), ~0u, // no _extensions_ @@ -406,6 +477,8 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, base_schema_), PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, filter_), PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, projection_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, advanced_extension_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -418,6 +491,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, common_), PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, input_), PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, expressions_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, _internal_metadata_), ~0u, // no _extensions_ @@ -429,6 +503,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, expression_), PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, post_join_filter_), PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, type_), + PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, _internal_metadata_), ~0u, // no _extensions_ @@ -438,6 +513,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, input_), PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, offset_), PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, count_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Grouping, _internal_metadata_), ~0u, // no _extensions_ @@ -450,6 +526,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Measure, measure_), + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Measure, filter_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, _internal_metadata_), ~0u, // no _extensions_ @@ -459,7 +536,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, input_), PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, groupings_), PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, measures_), - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, phase_), + PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, _internal_metadata_), ~0u, // no _extensions_ @@ -468,6 +545,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, common_), PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, input_), PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, sorts_), + PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, _internal_metadata_), ~0u, // no _extensions_ @@ -476,6 +554,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, common_), PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, input_), PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, condition_), + PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, _internal_metadata_), ~0u, // no _extensions_ @@ -484,6 +563,37 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, common_), PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, inputs_), PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, op_), + PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, advanced_extension_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionSingleRel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionSingleRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionSingleRel, input_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionSingleRel, detail_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionLeafRel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionLeafRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionLeafRel, detail_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionMultiRel, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionMultiRel, common_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionMultiRel, inputs_), + PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionMultiRel, detail_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelRoot, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::RelRoot, input_), + PROTOBUF_FIELD_OFFSET(::io::substrait::RelRoot, names_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Rel, _internal_metadata_), ~0u, // no _extensions_ @@ -497,43 +607,50 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::io::substrait::Rel, RelType_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::io::substrait::RelCommon_Direct)}, { 5, -1, sizeof(::io::substrait::RelCommon_Emit)}, { 11, -1, sizeof(::io::substrait::RelCommon_Hint_Stats)}, - { 18, -1, sizeof(::io::substrait::RelCommon_Hint_HintKeyValue)}, + { 19, -1, sizeof(::io::substrait::RelCommon_Hint_RuntimeConstraint)}, { 25, -1, sizeof(::io::substrait::RelCommon_Hint)}, - { 32, -1, sizeof(::io::substrait::RelCommon_RuntimeConstraint)}, - { 37, -1, sizeof(::io::substrait::RelCommon)}, - { 47, -1, sizeof(::io::substrait::ReadRel_NamedTable)}, - { 53, -1, sizeof(::io::substrait::ReadRel_VirtualTable)}, - { 59, -1, sizeof(::io::substrait::ReadRel_LocalFiles_FileOrFiles)}, - { 68, -1, sizeof(::io::substrait::ReadRel_LocalFiles)}, - { 74, -1, sizeof(::io::substrait::ReadRel)}, - { 87, -1, sizeof(::io::substrait::ProjectRel)}, - { 95, -1, sizeof(::io::substrait::JoinRel)}, - { 106, -1, sizeof(::io::substrait::FetchRel)}, - { 115, -1, sizeof(::io::substrait::AggregateRel_Grouping)}, - { 121, -1, sizeof(::io::substrait::AggregateRel_Measure)}, - { 127, -1, sizeof(::io::substrait::AggregateRel)}, - { 137, -1, sizeof(::io::substrait::SortRel)}, - { 145, -1, sizeof(::io::substrait::FilterRel)}, - { 153, -1, sizeof(::io::substrait::SetRel)}, - { 161, -1, sizeof(::io::substrait::Rel)}, + { 33, -1, sizeof(::io::substrait::RelCommon)}, + { 43, -1, sizeof(::io::substrait::ReadRel_NamedTable)}, + { 50, -1, sizeof(::io::substrait::ReadRel_VirtualTable)}, + { 56, -1, sizeof(::io::substrait::ReadRel_ExtensionTable)}, + { 62, -1, sizeof(::io::substrait::ReadRel_LocalFiles_FileOrFiles)}, + { 73, -1, sizeof(::io::substrait::ReadRel_LocalFiles)}, + { 80, -1, sizeof(::io::substrait::ReadRel)}, + { 95, -1, sizeof(::io::substrait::ProjectRel)}, + { 104, -1, sizeof(::io::substrait::JoinRel)}, + { 116, -1, sizeof(::io::substrait::FetchRel)}, + { 126, -1, sizeof(::io::substrait::AggregateRel_Grouping)}, + { 132, -1, sizeof(::io::substrait::AggregateRel_Measure)}, + { 139, -1, sizeof(::io::substrait::AggregateRel)}, + { 149, -1, sizeof(::io::substrait::SortRel)}, + { 158, -1, sizeof(::io::substrait::FilterRel)}, + { 167, -1, sizeof(::io::substrait::SetRel)}, + { 176, -1, sizeof(::io::substrait::ExtensionSingleRel)}, + { 184, -1, sizeof(::io::substrait::ExtensionLeafRel)}, + { 191, -1, sizeof(::io::substrait::ExtensionMultiRel)}, + { 199, -1, sizeof(::io::substrait::RelRoot)}, + { 206, -1, sizeof(::io::substrait::Rel)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { reinterpret_cast(&::io::substrait::_RelCommon_Direct_default_instance_), reinterpret_cast(&::io::substrait::_RelCommon_Emit_default_instance_), reinterpret_cast(&::io::substrait::_RelCommon_Hint_Stats_default_instance_), - reinterpret_cast(&::io::substrait::_RelCommon_Hint_HintKeyValue_default_instance_), + reinterpret_cast(&::io::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_), reinterpret_cast(&::io::substrait::_RelCommon_Hint_default_instance_), - reinterpret_cast(&::io::substrait::_RelCommon_RuntimeConstraint_default_instance_), reinterpret_cast(&::io::substrait::_RelCommon_default_instance_), reinterpret_cast(&::io::substrait::_ReadRel_NamedTable_default_instance_), reinterpret_cast(&::io::substrait::_ReadRel_VirtualTable_default_instance_), + reinterpret_cast(&::io::substrait::_ReadRel_ExtensionTable_default_instance_), reinterpret_cast(&::io::substrait::_ReadRel_LocalFiles_FileOrFiles_default_instance_), reinterpret_cast(&::io::substrait::_ReadRel_LocalFiles_default_instance_), reinterpret_cast(&::io::substrait::_ReadRel_default_instance_), @@ -546,101 +663,149 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::io::substrait::_SortRel_default_instance_), reinterpret_cast(&::io::substrait::_FilterRel_default_instance_), reinterpret_cast(&::io::substrait::_SetRel_default_instance_), + reinterpret_cast(&::io::substrait::_ExtensionSingleRel_default_instance_), + reinterpret_cast(&::io::substrait::_ExtensionLeafRel_default_instance_), + reinterpret_cast(&::io::substrait::_ExtensionMultiRel_default_instance_), + reinterpret_cast(&::io::substrait::_RelRoot_default_instance_), reinterpret_cast(&::io::substrait::_Rel_default_instance_), }; const char descriptor_table_protodef_relations_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\017relations.proto\022\014io.substrait\032\ntype.pr" - "oto\032\020expression.proto\032\017selection.proto\"\372" - "\003\n\tRelCommon\0220\n\006direct\030\001 \001(\0132\036.io.substr" - "ait.RelCommon.DirectH\000\022,\n\004emit\030\002 \001(\0132\034.i" - "o.substrait.RelCommon.EmitH\000\022*\n\004hint\030\003 \001" - "(\0132\034.io.substrait.RelCommon.Hint\022=\n\ncons" - "traint\030\004 \001(\0132).io.substrait.RelCommon.Ru" - "ntimeConstraint\032\010\n\006Direct\032\036\n\004Emit\022\026\n\016out" - "put_mapping\030\001 \003(\005\032\332\001\n\004Hint\022B\n\017hint_key_v" - "alues\030\001 \003(\0132).io.substrait.RelCommon.Hin" - "t.HintKeyValue\0221\n\005stats\030\002 \001(\0132\".io.subst" - "rait.RelCommon.Hint.Stats\032/\n\005Stats\022\021\n\tro" - "w_count\030\001 \001(\001\022\023\n\013record_size\030\002 \001(\001\032*\n\014Hi" - "ntKeyValue\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\014\032\023" - "\n\021RuntimeConstraintB\006\n\004kind\"\344\005\n\007ReadRel\022" - "\'\n\006common\030\001 \001(\0132\027.io.substrait.RelCommon" - "\0223\n\013base_schema\030\002 \001(\0132\036.io.substrait.Typ" - "e.NamedStruct\022(\n\006filter\030\003 \001(\0132\030.io.subst" - "rait.Expression\0220\n\nprojection\030\004 \001(\0132\034.io" - ".substrait.MaskExpression\022;\n\rvirtual_tab" - "le\030\005 \001(\0132\".io.substrait.ReadRel.VirtualT" - "ableH\000\0227\n\013local_files\030\006 \001(\0132 .io.substra" - "it.ReadRel.LocalFilesH\000\0227\n\013named_table\030\007" - " \001(\0132 .io.substrait.ReadRel.NamedTableH\000" - "\032\033\n\nNamedTable\022\r\n\005names\030\001 \003(\t\032G\n\014Virtual" - "Table\0227\n\006values\030\001 \003(\0132\'.io.substrait.Exp" - "ression.Literal.Struct\032\374\001\n\nLocalFiles\022;\n" - "\005items\030\001 \003(\0132,.io.substrait.ReadRel.Loca" - "lFiles.FileOrFiles\032\260\001\n\013FileOrFiles\022\022\n\010ur" - "i_path\030\001 \001(\tH\000\022\027\n\ruri_path_glob\030\002 \001(\tH\000\022" - "C\n\006format\030\003 \001(\01623.io.substrait.ReadRel.L" - "ocalFiles.FileOrFiles.Format\"\"\n\006Format\022\013" - "\n\007UNKNOWN\020\000\022\013\n\007PARQUET\020\001B\013\n\tpath_typeB\013\n" - "\tread_type\"\206\001\n\nProjectRel\022\'\n\006common\030\001 \001(" - "\0132\027.io.substrait.RelCommon\022 \n\005input\030\002 \001(" - "\0132\021.io.substrait.Rel\022-\n\013expressions\030\003 \003(" - "\0132\030.io.substrait.Expression\"\311\002\n\007JoinRel\022" - "\'\n\006common\030\001 \001(\0132\027.io.substrait.RelCommon" - "\022\037\n\004left\030\002 \001(\0132\021.io.substrait.Rel\022 \n\005rig" - "ht\030\003 \001(\0132\021.io.substrait.Rel\022,\n\nexpressio" - "n\030\004 \001(\0132\030.io.substrait.Expression\0222\n\020pos" - "t_join_filter\030\005 \001(\0132\030.io.substrait.Expre" - "ssion\022,\n\004type\030\006 \001(\0162\036.io.substrait.JoinR" - "el.JoinType\"B\n\010JoinType\022\013\n\007UNKNOWN\020\000\022\t\n\005" - "INNER\020\001\022\t\n\005OUTER\020\002\022\010\n\004LEFT\020\003\022\t\n\005RIGHT\020\004\"" - "t\n\010FetchRel\022\'\n\006common\030\001 \001(\0132\027.io.substra" - "it.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.substra" - "it.Rel\022\016\n\006offset\030\003 \001(\003\022\r\n\005count\030\004 \001(\003\"\353\002" - "\n\014AggregateRel\022\'\n\006common\030\001 \001(\0132\027.io.subs" - "trait.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.subs" - "trait.Rel\0226\n\tgroupings\030\003 \003(\0132#.io.substr" - "ait.AggregateRel.Grouping\0224\n\010measures\030\004 " - "\003(\0132\".io.substrait.AggregateRel.Measure\022" - "8\n\005phase\030\005 \001(\0162).io.substrait.Expression" - ".AggregationPhase\032 \n\010Grouping\022\024\n\014input_f" - "ields\030\001 \003(\005\032F\n\007Measure\022;\n\007measure\030\001 \001(\0132" - "*.io.substrait.Expression.AggregateFunct" - "ion\"\207\001\n\007SortRel\022\'\n\006common\030\001 \001(\0132\027.io.sub" + "oto\032\020expression.proto\032\020extensions.proto\032" + "\031google/protobuf/any.proto\"\264\005\n\tRelCommon" + "\0220\n\006direct\030\001 \001(\0132\036.io.substrait.RelCommo" + "n.DirectH\000\022,\n\004emit\030\002 \001(\0132\034.io.substrait." + "RelCommon.EmitH\000\022*\n\004hint\030\003 \001(\0132\034.io.subs" + "trait.RelCommon.Hint\022F\n\022advanced_extensi" + "on\030\004 \001(\0132*.io.substrait.extensions.Advan" + "cedExtension\032\010\n\006Direct\032\036\n\004Emit\022\026\n\016output" + "_mapping\030\001 \003(\005\032\233\003\n\004Hint\0221\n\005stats\030\001 \001(\0132\"" + ".io.substrait.RelCommon.Hint.Stats\022B\n\nco" + "nstraint\030\002 \001(\0132..io.substrait.RelCommon." + "Hint.RuntimeConstraint\022F\n\022advanced_exten" + "sion\030\n \001(\0132*.io.substrait.extensions.Adv" + "ancedExtension\032w\n\005Stats\022\021\n\trow_count\030\001 \001" + "(\001\022\023\n\013record_size\030\002 \001(\001\022F\n\022advanced_exte" + "nsion\030\n \001(\0132*.io.substrait.extensions.Ad" + "vancedExtension\032[\n\021RuntimeConstraint\022F\n\022" + "advanced_extension\030\n \001(\0132*.io.substrait." + "extensions.AdvancedExtensionB\013\n\temit_kin" + "d\"\345\010\n\007ReadRel\022\'\n\006common\030\001 \001(\0132\027.io.subst" + "rait.RelCommon\022.\n\013base_schema\030\002 \001(\0132\031.io" + ".substrait.NamedStruct\022(\n\006filter\030\003 \001(\0132\030" + ".io.substrait.Expression\022;\n\nprojection\030\004" + " \001(\0132\'.io.substrait.Expression.MaskExpre" + "ssion\022F\n\022advanced_extension\030\n \001(\0132*.io.s" + "ubstrait.extensions.AdvancedExtension\022;\n" + "\rvirtual_table\030\005 \001(\0132\".io.substrait.Read" + "Rel.VirtualTableH\000\0227\n\013local_files\030\006 \001(\0132" + " .io.substrait.ReadRel.LocalFilesH\000\0227\n\013n" + "amed_table\030\007 \001(\0132 .io.substrait.ReadRel." + "NamedTableH\000\022\?\n\017extension_table\030\010 \001(\0132$." + "io.substrait.ReadRel.ExtensionTableH\000\032c\n" + "\nNamedTable\022\r\n\005names\030\001 \003(\t\022F\n\022advanced_e" + "xtension\030\n \001(\0132*.io.substrait.extensions" + ".AdvancedExtension\032G\n\014VirtualTable\0227\n\006va" + "lues\030\001 \003(\0132\'.io.substrait.Expression.Lit" + "eral.Struct\0326\n\016ExtensionTable\022$\n\006detail\030" + "\001 \001(\0132\024.google.protobuf.Any\032\356\002\n\nLocalFil" + "es\022;\n\005items\030\001 \003(\0132,.io.substrait.ReadRel" + ".LocalFiles.FileOrFiles\022F\n\022advanced_exte" + "nsion\030\n \001(\0132*.io.substrait.extensions.Ad" + "vancedExtension\032\332\001\n\013FileOrFiles\022\022\n\010uri_p" + "ath\030\001 \001(\tH\000\022\027\n\ruri_path_glob\030\002 \001(\tH\000\022\022\n\010" + "uri_file\030\003 \001(\tH\000\022\024\n\nuri_folder\030\004 \001(\tH\000\022C" + "\n\006format\030\005 \001(\01623.io.substrait.ReadRel.Lo" + "calFiles.FileOrFiles.Format\"\"\n\006Format\022\013\n" + "\007UNKNOWN\020\000\022\013\n\007PARQUET\020\001B\013\n\tpath_typeB\013\n\t" + "read_type\"\316\001\n\nProjectRel\022\'\n\006common\030\001 \001(\013" + "2\027.io.substrait.RelCommon\022 \n\005input\030\002 \001(\013" + "2\021.io.substrait.Rel\022-\n\013expressions\030\003 \003(\013" + "2\030.io.substrait.Expression\022F\n\022advanced_e" + "xtension\030\n \001(\0132*.io.substrait.extensions" + ".AdvancedExtension\"\245\003\n\007JoinRel\022\'\n\006common" + "\030\001 \001(\0132\027.io.substrait.RelCommon\022\037\n\004left\030" + "\002 \001(\0132\021.io.substrait.Rel\022 \n\005right\030\003 \001(\0132" + "\021.io.substrait.Rel\022,\n\nexpression\030\004 \001(\0132\030" + ".io.substrait.Expression\0222\n\020post_join_fi" + "lter\030\005 \001(\0132\030.io.substrait.Expression\022,\n\004" + "type\030\006 \001(\0162\036.io.substrait.JoinRel.JoinTy" + "pe\022F\n\022advanced_extension\030\n \001(\0132*.io.subs" + "trait.extensions.AdvancedExtension\"V\n\010Jo" + "inType\022\013\n\007UNKNOWN\020\000\022\t\n\005INNER\020\001\022\t\n\005OUTER\020" + "\002\022\010\n\004LEFT\020\003\022\t\n\005RIGHT\020\004\022\010\n\004SEMI\020\005\022\010\n\004ANTI" + "\020\006\"\274\001\n\010FetchRel\022\'\n\006common\030\001 \001(\0132\027.io.sub" "strait.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.sub" - "strait.Rel\0221\n\005sorts\030\003 \003(\0132\".io.substrait" - ".Expression.SortField\"\203\001\n\tFilterRel\022\'\n\006c" - "ommon\030\001 \001(\0132\027.io.substrait.RelCommon\022 \n\005" - "input\030\002 \001(\0132\021.io.substrait.Rel\022+\n\tcondit" - "ion\030\003 \001(\0132\030.io.substrait.Expression\"\222\002\n\006" - "SetRel\022\'\n\006common\030\001 \001(\0132\027.io.substrait.Re" - "lCommon\022!\n\006inputs\030\002 \003(\0132\021.io.substrait.R" - "el\022&\n\002op\030\003 \001(\0162\032.io.substrait.SetRel.Set" - "Op\"\223\001\n\005SetOp\022\013\n\007UNKNOWN\020\000\022\021\n\rMINUS_PRIMA" - "RY\020\001\022\022\n\016MINUS_MULTISET\020\002\022\030\n\024INTERSECTION" - "_PRIMARY\020\003\022\031\n\025INTERSECTION_MULTISET\020\004\022\022\n" - "\016UNION_DISTINCT\020\005\022\r\n\tUNION_ALL\020\006\"\334\002\n\003Rel" - "\022%\n\004read\030\001 \001(\0132\025.io.substrait.ReadRelH\000\022" - ")\n\006filter\030\002 \001(\0132\027.io.substrait.FilterRel" - "H\000\022\'\n\005fetch\030\003 \001(\0132\026.io.substrait.FetchRe" - "lH\000\022/\n\taggregate\030\004 \001(\0132\032.io.substrait.Ag" - "gregateRelH\000\022%\n\004sort\030\005 \001(\0132\025.io.substrai" - "t.SortRelH\000\022%\n\004join\030\006 \001(\0132\025.io.substrait" - ".JoinRelH\000\022+\n\007project\030\007 \001(\0132\030.io.substra" - "it.ProjectRelH\000\022#\n\003set\030\010 \001(\0132\024.io.substr" - "ait.SetRelH\000B\t\n\007RelTypeB\027P\001\252\002\022Substrait." - "Protobufb\006proto3" + "strait.Rel\022\016\n\006offset\030\003 \001(\003\022\r\n\005count\030\004 \001(" + "\003\022F\n\022advanced_extension\030\n \001(\0132*.io.subst" + "rait.extensions.AdvancedExtension\"\230\003\n\014Ag" + "gregateRel\022\'\n\006common\030\001 \001(\0132\027.io.substrai" + "t.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.substrai" + "t.Rel\0226\n\tgroupings\030\003 \003(\0132#.io.substrait." + "AggregateRel.Grouping\0224\n\010measures\030\004 \003(\0132" + "\".io.substrait.AggregateRel.Measure\022F\n\022a" + "dvanced_extension\030\n \001(\0132*.io.substrait.e" + "xtensions.AdvancedExtension\032 \n\010Grouping\022" + "\024\n\014input_fields\030\001 \003(\005\032e\n\007Measure\0220\n\007meas" + "ure\030\001 \001(\0132\037.io.substrait.AggregateFuncti" + "on\022(\n\006filter\030\002 \001(\0132\030.io.substrait.Expres" + "sion\"\304\001\n\007SortRel\022\'\n\006common\030\001 \001(\0132\027.io.su" + "bstrait.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.su" + "bstrait.Rel\022&\n\005sorts\030\003 \003(\0132\027.io.substrai" + "t.SortField\022F\n\022advanced_extension\030\n \001(\0132" + "*.io.substrait.extensions.AdvancedExtens" + "ion\"\313\001\n\tFilterRel\022\'\n\006common\030\001 \001(\0132\027.io.s" + "ubstrait.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.s" + "ubstrait.Rel\022+\n\tcondition\030\003 \001(\0132\030.io.sub" + "strait.Expression\022F\n\022advanced_extension\030" + "\n \001(\0132*.io.substrait.extensions.Advanced" + "Extension\"\332\002\n\006SetRel\022\'\n\006common\030\001 \001(\0132\027.i" + "o.substrait.RelCommon\022!\n\006inputs\030\002 \003(\0132\021." + "io.substrait.Rel\022&\n\002op\030\003 \001(\0162\032.io.substr" + "ait.SetRel.SetOp\022F\n\022advanced_extension\030\n" + " \001(\0132*.io.substrait.extensions.AdvancedE" + "xtension\"\223\001\n\005SetOp\022\013\n\007UNKNOWN\020\000\022\021\n\rMINUS" + "_PRIMARY\020\001\022\022\n\016MINUS_MULTISET\020\002\022\030\n\024INTERS" + "ECTION_PRIMARY\020\003\022\031\n\025INTERSECTION_MULTISE" + "T\020\004\022\022\n\016UNION_DISTINCT\020\005\022\r\n\tUNION_ALL\020\006\"\205" + "\001\n\022ExtensionSingleRel\022\'\n\006common\030\001 \001(\0132\027." + "io.substrait.RelCommon\022 \n\005input\030\002 \001(\0132\021." + "io.substrait.Rel\022$\n\006detail\030\003 \001(\0132\024.googl" + "e.protobuf.Any\"a\n\020ExtensionLeafRel\022\'\n\006co" + "mmon\030\001 \001(\0132\027.io.substrait.RelCommon\022$\n\006d" + "etail\030\002 \001(\0132\024.google.protobuf.Any\"\205\001\n\021Ex" + "tensionMultiRel\022\'\n\006common\030\001 \001(\0132\027.io.sub" + "strait.RelCommon\022!\n\006inputs\030\002 \003(\0132\021.io.su" + "bstrait.Rel\022$\n\006detail\030\003 \001(\0132\024.google.pro" + "tobuf.Any\":\n\007RelRoot\022 \n\005input\030\001 \001(\0132\021.io" + ".substrait.Rel\022\r\n\005names\030\002 \003(\t\"\220\004\n\003Rel\022%\n" + "\004read\030\001 \001(\0132\025.io.substrait.ReadRelH\000\022)\n\006" + "filter\030\002 \001(\0132\027.io.substrait.FilterRelH\000\022" + "\'\n\005fetch\030\003 \001(\0132\026.io.substrait.FetchRelH\000" + "\022/\n\taggregate\030\004 \001(\0132\032.io.substrait.Aggre" + "gateRelH\000\022%\n\004sort\030\005 \001(\0132\025.io.substrait.S" + "ortRelH\000\022%\n\004join\030\006 \001(\0132\025.io.substrait.Jo" + "inRelH\000\022+\n\007project\030\007 \001(\0132\030.io.substrait." + "ProjectRelH\000\022#\n\003set\030\010 \001(\0132\024.io.substrait" + ".SetRelH\000\022<\n\020extension_single\030\t \001(\0132 .io" + ".substrait.ExtensionSingleRelH\000\022:\n\017exten" + "sion_multi\030\n \001(\0132\037.io.substrait.Extensio" + "nMultiRelH\000\0228\n\016extension_leaf\030\013 \001(\0132\036.io" + ".substrait.ExtensionLeafRelH\000B\t\n\007RelType" + "B+\n\022io.substrait.protoP\001\252\002\022Substrait.Pro" + "tobufb\006proto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_relations_2eproto_deps[3] = { +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_relations_2eproto_deps[4] = { &::descriptor_table_expression_2eproto, - &::descriptor_table_selection_2eproto, + &::descriptor_table_extensions_2eproto, + &::descriptor_table_google_2fprotobuf_2fany_2eproto, &::descriptor_table_type_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_relations_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_relations_2eproto = { - false, false, 3216, descriptor_table_protodef_relations_2eproto, "relations.proto", - &descriptor_table_relations_2eproto_once, descriptor_table_relations_2eproto_deps, 3, 22, + false, false, 4933, descriptor_table_protodef_relations_2eproto, "relations.proto", + &descriptor_table_relations_2eproto_once, descriptor_table_relations_2eproto_deps, 4, 26, schemas, file_default_instances, TableStruct_relations_2eproto::offsets, file_level_metadata_relations_2eproto, file_level_enum_descriptors_relations_2eproto, file_level_service_descriptors_relations_2eproto, }; @@ -684,6 +849,8 @@ bool JoinRel_JoinType_IsValid(int value) { case 2: case 3: case 4: + case 5: + case 6: return true; default: return false; @@ -696,6 +863,8 @@ constexpr JoinRel_JoinType JoinRel::INNER; constexpr JoinRel_JoinType JoinRel::OUTER; constexpr JoinRel_JoinType JoinRel::LEFT; constexpr JoinRel_JoinType JoinRel::RIGHT; +constexpr JoinRel_JoinType JoinRel::SEMI; +constexpr JoinRel_JoinType JoinRel::ANTI; constexpr JoinRel_JoinType JoinRel::JoinType_MIN; constexpr JoinRel_JoinType JoinRel::JoinType_MAX; constexpr int JoinRel::JoinType_ARRAYSIZE; @@ -1096,8 +1265,19 @@ ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Emit::GetMetadata() const { class RelCommon_Hint_Stats::_Internal { public: + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_Stats* msg); }; +const ::io::substrait::extensions::AdvancedExtension& +RelCommon_Hint_Stats::_Internal::advanced_extension(const RelCommon_Hint_Stats* msg) { + return *msg->advanced_extension_; +} +void RelCommon_Hint_Stats::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} RelCommon_Hint_Stats::RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1107,6 +1287,11 @@ RelCommon_Hint_Stats::RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena RelCommon_Hint_Stats::RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } ::memcpy(&row_count_, &from.row_count_, static_cast(reinterpret_cast(&record_size_) - reinterpret_cast(&row_count_)) + sizeof(record_size_)); @@ -1115,9 +1300,9 @@ RelCommon_Hint_Stats::RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from) void RelCommon_Hint_Stats::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&row_count_) - reinterpret_cast(this)), + reinterpret_cast(&advanced_extension_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&record_size_) - - reinterpret_cast(&row_count_)) + sizeof(record_size_)); + reinterpret_cast(&advanced_extension_)) + sizeof(record_size_)); } RelCommon_Hint_Stats::~RelCommon_Hint_Stats() { @@ -1128,6 +1313,7 @@ RelCommon_Hint_Stats::~RelCommon_Hint_Stats() { void RelCommon_Hint_Stats::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete advanced_extension_; } void RelCommon_Hint_Stats::ArenaDtor(void* object) { @@ -1146,6 +1332,10 @@ void RelCommon_Hint_Stats::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; ::memset(&row_count_, 0, static_cast( reinterpret_cast(&record_size_) - reinterpret_cast(&row_count_)) + sizeof(record_size_)); @@ -1172,6 +1362,13 @@ const char* RelCommon_Hint_Stats::_InternalParse(const char* ptr, ::PROTOBUF_NAM ptr += sizeof(double); } else goto handle_unusual; continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -1213,6 +1410,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_Stats::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_record_size(), target); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -1229,6 +1434,13 @@ size_t RelCommon_Hint_Stats::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + // double row_count = 1; if (!(this->row_count() <= 0 && this->row_count() >= 0)) { total_size += 1 + 8; @@ -1270,6 +1482,9 @@ void RelCommon_Hint_Stats::MergeFrom(const RelCommon_Hint_Stats& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + } if (!(from.row_count() <= 0 && from.row_count() >= 0)) { _internal_set_row_count(from._internal_row_count()); } @@ -1302,9 +1517,9 @@ void RelCommon_Hint_Stats::InternalSwap(RelCommon_Hint_Stats* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(RelCommon_Hint_Stats, record_size_) + sizeof(RelCommon_Hint_Stats::record_size_) - - PROTOBUF_FIELD_OFFSET(RelCommon_Hint_Stats, row_count_)>( - reinterpret_cast(&row_count_), - reinterpret_cast(&other->row_count_)); + - PROTOBUF_FIELD_OFFSET(RelCommon_Hint_Stats, advanced_extension_)>( + reinterpret_cast(&advanced_extension_), + reinterpret_cast(&other->advanced_extension_)); } ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_Stats::GetMetadata() const { @@ -1315,90 +1530,86 @@ ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_Stats::GetMetadata() const { // =================================================================== -class RelCommon_Hint_HintKeyValue::_Internal { +class RelCommon_Hint_RuntimeConstraint::_Internal { public: + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg); }; -RelCommon_Hint_HintKeyValue::RelCommon_Hint_HintKeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena) +const ::io::substrait::extensions::AdvancedExtension& +RelCommon_Hint_RuntimeConstraint::_Internal::advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg) { + return *msg->advanced_extension_; +} +void RelCommon_Hint_RuntimeConstraint::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} +RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Hint.HintKeyValue) + // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Hint.RuntimeConstraint) } -RelCommon_Hint_HintKeyValue::RelCommon_Hint_HintKeyValue(const RelCommon_Hint_HintKeyValue& from) +RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(const RelCommon_Hint_RuntimeConstraint& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_key().empty()) { - key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_key(), - GetArena()); - } - value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_value().empty()) { - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), - GetArena()); + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Hint.HintKeyValue) + // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Hint.RuntimeConstraint) } -void RelCommon_Hint_HintKeyValue::SharedCtor() { -key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +void RelCommon_Hint_RuntimeConstraint::SharedCtor() { +advanced_extension_ = nullptr; } -RelCommon_Hint_HintKeyValue::~RelCommon_Hint_HintKeyValue() { - // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Hint.HintKeyValue) +RelCommon_Hint_RuntimeConstraint::~RelCommon_Hint_RuntimeConstraint() { + // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Hint.RuntimeConstraint) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void RelCommon_Hint_HintKeyValue::SharedDtor() { +void RelCommon_Hint_RuntimeConstraint::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete advanced_extension_; } -void RelCommon_Hint_HintKeyValue::ArenaDtor(void* object) { - RelCommon_Hint_HintKeyValue* _this = reinterpret_cast< RelCommon_Hint_HintKeyValue* >(object); +void RelCommon_Hint_RuntimeConstraint::ArenaDtor(void* object) { + RelCommon_Hint_RuntimeConstraint* _this = reinterpret_cast< RelCommon_Hint_RuntimeConstraint* >(object); (void)_this; } -void RelCommon_Hint_HintKeyValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void RelCommon_Hint_RuntimeConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void RelCommon_Hint_HintKeyValue::SetCachedSize(int size) const { +void RelCommon_Hint_RuntimeConstraint::SetCachedSize(int size) const { _cached_size_.Set(size); } -void RelCommon_Hint_HintKeyValue::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Hint.HintKeyValue) +void RelCommon_Hint_RuntimeConstraint::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Hint.RuntimeConstraint) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - key_.ClearToEmpty(); - value_.ClearToEmpty(); + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* RelCommon_Hint_HintKeyValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* RelCommon_Hint_RuntimeConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // string key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_key(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.RelCommon.Hint.HintKeyValue.key")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // bytes value = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_value(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1425,56 +1636,41 @@ const char* RelCommon_Hint_HintKeyValue::_InternalParse(const char* ptr, ::PROTO #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_HintKeyValue::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_RuntimeConstraint::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Hint.HintKeyValue) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Hint.RuntimeConstraint) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // string key = 1; - if (this->key().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_key().data(), static_cast(this->_internal_key().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.RelCommon.Hint.HintKeyValue.key"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_key(), target); - } - - // bytes value = 2; - if (this->value().size() > 0) { - target = stream->WriteBytesMaybeAliased( - 2, this->_internal_value(), target); + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Hint.HintKeyValue) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Hint.RuntimeConstraint) return target; } -size_t RelCommon_Hint_HintKeyValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Hint.HintKeyValue) +size_t RelCommon_Hint_RuntimeConstraint::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Hint.RuntimeConstraint) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // string key = 1; - if (this->key().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_key()); - } - - // bytes value = 2; - if (this->value().size() > 0) { + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_value()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1486,62 +1682,58 @@ size_t RelCommon_Hint_HintKeyValue::ByteSizeLong() const { return total_size; } -void RelCommon_Hint_HintKeyValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Hint.HintKeyValue) +void RelCommon_Hint_RuntimeConstraint::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Hint.RuntimeConstraint) GOOGLE_DCHECK_NE(&from, this); - const RelCommon_Hint_HintKeyValue* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const RelCommon_Hint_RuntimeConstraint* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Hint.HintKeyValue) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Hint.RuntimeConstraint) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Hint.HintKeyValue) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Hint.RuntimeConstraint) MergeFrom(*source); } } -void RelCommon_Hint_HintKeyValue::MergeFrom(const RelCommon_Hint_HintKeyValue& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Hint.HintKeyValue) +void RelCommon_Hint_RuntimeConstraint::MergeFrom(const RelCommon_Hint_RuntimeConstraint& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Hint.RuntimeConstraint) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.key().size() > 0) { - _internal_set_key(from._internal_key()); - } - if (from.value().size() > 0) { - _internal_set_value(from._internal_value()); + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } } -void RelCommon_Hint_HintKeyValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Hint.HintKeyValue) +void RelCommon_Hint_RuntimeConstraint::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Hint.RuntimeConstraint) if (&from == this) return; Clear(); MergeFrom(from); } -void RelCommon_Hint_HintKeyValue::CopyFrom(const RelCommon_Hint_HintKeyValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Hint.HintKeyValue) +void RelCommon_Hint_RuntimeConstraint::CopyFrom(const RelCommon_Hint_RuntimeConstraint& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Hint.RuntimeConstraint) if (&from == this) return; Clear(); MergeFrom(from); } -bool RelCommon_Hint_HintKeyValue::IsInitialized() const { +bool RelCommon_Hint_RuntimeConstraint::IsInitialized() const { return true; } -void RelCommon_Hint_HintKeyValue::InternalSwap(RelCommon_Hint_HintKeyValue* other) { +void RelCommon_Hint_RuntimeConstraint::InternalSwap(RelCommon_Hint_RuntimeConstraint* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - key_.Swap(&other->key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(advanced_extension_, other->advanced_extension_); } -::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_HintKeyValue::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_RuntimeConstraint::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, file_level_metadata_relations_2eproto[3]); @@ -1552,33 +1744,60 @@ ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_HintKeyValue::GetMetadata() con class RelCommon_Hint::_Internal { public: static const ::io::substrait::RelCommon_Hint_Stats& stats(const RelCommon_Hint* msg); + static const ::io::substrait::RelCommon_Hint_RuntimeConstraint& constraint(const RelCommon_Hint* msg); + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint* msg); }; const ::io::substrait::RelCommon_Hint_Stats& RelCommon_Hint::_Internal::stats(const RelCommon_Hint* msg) { return *msg->stats_; } +const ::io::substrait::RelCommon_Hint_RuntimeConstraint& +RelCommon_Hint::_Internal::constraint(const RelCommon_Hint* msg) { + return *msg->constraint_; +} +const ::io::substrait::extensions::AdvancedExtension& +RelCommon_Hint::_Internal::advanced_extension(const RelCommon_Hint* msg) { + return *msg->advanced_extension_; +} +void RelCommon_Hint::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} RelCommon_Hint::RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - hint_key_values_(arena) { + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Hint) } RelCommon_Hint::RelCommon_Hint(const RelCommon_Hint& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - hint_key_values_(from.hint_key_values_) { + : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_stats()) { stats_ = new ::io::substrait::RelCommon_Hint_Stats(*from.stats_); } else { stats_ = nullptr; } + if (from._internal_has_constraint()) { + constraint_ = new ::io::substrait::RelCommon_Hint_RuntimeConstraint(*from.constraint_); + } else { + constraint_ = nullptr; + } + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Hint) } void RelCommon_Hint::SharedCtor() { -stats_ = nullptr; +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&stats_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&stats_)) + sizeof(advanced_extension_)); } RelCommon_Hint::~RelCommon_Hint() { @@ -1590,6 +1809,8 @@ RelCommon_Hint::~RelCommon_Hint() { void RelCommon_Hint::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete stats_; + if (this != internal_default_instance()) delete constraint_; + if (this != internal_default_instance()) delete advanced_extension_; } void RelCommon_Hint::ArenaDtor(void* object) { @@ -1608,11 +1829,18 @@ void RelCommon_Hint::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - hint_key_values_.Clear(); if (GetArena() == nullptr && stats_ != nullptr) { delete stats_; } stats_ = nullptr; + if (GetArena() == nullptr && constraint_ != nullptr) { + delete constraint_; + } + constraint_ = nullptr; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1622,22 +1850,24 @@ const char* RelCommon_Hint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.RelCommon.Hint.HintKeyValue hint_key_values = 1; + // .io.substrait.RelCommon.Hint.Stats stats = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_hint_key_values(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + ptr = ctx->ParseMessage(_internal_mutable_stats(), ptr); + CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.RelCommon.Hint.Stats stats = 2; + // .io.substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_stats(), ptr); + ptr = ctx->ParseMessage(_internal_mutable_constraint(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1670,20 +1900,28 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.RelCommon.Hint.HintKeyValue hint_key_values = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_hint_key_values_size()); i < n; i++) { + // .io.substrait.RelCommon.Hint.Stats stats = 1; + if (this->has_stats()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_hint_key_values(i), target, stream); + InternalWriteMessage( + 1, _Internal::stats(this), target, stream); } - // .io.substrait.RelCommon.Hint.Stats stats = 2; - if (this->has_stats()) { + // .io.substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; + if (this->has_constraint()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::constraint(this), target, stream); + } + + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 2, _Internal::stats(this), target, stream); + 10, _Internal::advanced_extension(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -1702,20 +1940,27 @@ size_t RelCommon_Hint::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.RelCommon.Hint.HintKeyValue hint_key_values = 1; - total_size += 1UL * this->_internal_hint_key_values_size(); - for (const auto& msg : this->hint_key_values_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .io.substrait.RelCommon.Hint.Stats stats = 2; + // .io.substrait.RelCommon.Hint.Stats stats = 1; if (this->has_stats()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *stats_); } + // .io.substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; + if (this->has_constraint()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *constraint_); + } + + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -1747,10 +1992,15 @@ void RelCommon_Hint::MergeFrom(const RelCommon_Hint& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - hint_key_values_.MergeFrom(from.hint_key_values_); if (from.has_stats()) { _internal_mutable_stats()->::io::substrait::RelCommon_Hint_Stats::MergeFrom(from._internal_stats()); } + if (from.has_constraint()) { + _internal_mutable_constraint()->::io::substrait::RelCommon_Hint_RuntimeConstraint::MergeFrom(from._internal_constraint()); + } + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + } } void RelCommon_Hint::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { @@ -1774,8 +2024,12 @@ bool RelCommon_Hint::IsInitialized() const { void RelCommon_Hint::InternalSwap(RelCommon_Hint* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - hint_key_values_.InternalSwap(&other->hint_key_values_); - swap(stats_, other->stats_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(RelCommon_Hint, advanced_extension_) + + sizeof(RelCommon_Hint::advanced_extension_) + - PROTOBUF_FIELD_OFFSET(RelCommon_Hint, stats_)>( + reinterpret_cast(&stats_), + reinterpret_cast(&other->stats_)); } ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint::GetMetadata() const { @@ -1786,264 +2040,112 @@ ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint::GetMetadata() const { // =================================================================== -class RelCommon_RuntimeConstraint::_Internal { +class RelCommon::_Internal { public: + static const ::io::substrait::RelCommon_Direct& direct(const RelCommon* msg); + static const ::io::substrait::RelCommon_Emit& emit(const RelCommon* msg); + static const ::io::substrait::RelCommon_Hint& hint(const RelCommon* msg); + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon* msg); }; -RelCommon_RuntimeConstraint::RelCommon_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena) +const ::io::substrait::RelCommon_Direct& +RelCommon::_Internal::direct(const RelCommon* msg) { + return *msg->emit_kind_.direct_; +} +const ::io::substrait::RelCommon_Emit& +RelCommon::_Internal::emit(const RelCommon* msg) { + return *msg->emit_kind_.emit_; +} +const ::io::substrait::RelCommon_Hint& +RelCommon::_Internal::hint(const RelCommon* msg) { + return *msg->hint_; +} +const ::io::substrait::extensions::AdvancedExtension& +RelCommon::_Internal::advanced_extension(const RelCommon* msg) { + return *msg->advanced_extension_; +} +void RelCommon::set_allocated_direct(::io::substrait::RelCommon_Direct* direct) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_emit_kind(); + if (direct) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(direct); + if (message_arena != submessage_arena) { + direct = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, direct, submessage_arena); + } + set_has_direct(); + emit_kind_.direct_ = direct; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.direct) +} +void RelCommon::set_allocated_emit(::io::substrait::RelCommon_Emit* emit) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_emit_kind(); + if (emit) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(emit); + if (message_arena != submessage_arena) { + emit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, emit, submessage_arena); + } + set_has_emit(); + emit_kind_.emit_ = emit; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.emit) +} +void RelCommon::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} +RelCommon::RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.RuntimeConstraint) + // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon) } -RelCommon_RuntimeConstraint::RelCommon_RuntimeConstraint(const RelCommon_RuntimeConstraint& from) +RelCommon::RelCommon(const RelCommon& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.RuntimeConstraint) + if (from._internal_has_hint()) { + hint_ = new ::io::substrait::RelCommon_Hint(*from.hint_); + } else { + hint_ = nullptr; + } + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } + clear_has_emit_kind(); + switch (from.emit_kind_case()) { + case kDirect: { + _internal_mutable_direct()->::io::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); + break; + } + case kEmit: { + _internal_mutable_emit()->::io::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); + break; + } + case EMIT_KIND_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon) } -void RelCommon_RuntimeConstraint::SharedCtor() { +void RelCommon::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&hint_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&hint_)) + sizeof(advanced_extension_)); +clear_has_emit_kind(); } -RelCommon_RuntimeConstraint::~RelCommon_RuntimeConstraint() { - // @@protoc_insertion_point(destructor:io.substrait.RelCommon.RuntimeConstraint) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void RelCommon_RuntimeConstraint::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void RelCommon_RuntimeConstraint::ArenaDtor(void* object) { - RelCommon_RuntimeConstraint* _this = reinterpret_cast< RelCommon_RuntimeConstraint* >(object); - (void)_this; -} -void RelCommon_RuntimeConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void RelCommon_RuntimeConstraint::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void RelCommon_RuntimeConstraint::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.RuntimeConstraint) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* RelCommon_RuntimeConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_RuntimeConstraint::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.RuntimeConstraint) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.RuntimeConstraint) - return target; -} - -size_t RelCommon_RuntimeConstraint::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.RuntimeConstraint) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void RelCommon_RuntimeConstraint::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.RuntimeConstraint) - GOOGLE_DCHECK_NE(&from, this); - const RelCommon_RuntimeConstraint* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.RuntimeConstraint) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.RuntimeConstraint) - MergeFrom(*source); - } -} - -void RelCommon_RuntimeConstraint::MergeFrom(const RelCommon_RuntimeConstraint& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.RuntimeConstraint) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - -} - -void RelCommon_RuntimeConstraint::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.RuntimeConstraint) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void RelCommon_RuntimeConstraint::CopyFrom(const RelCommon_RuntimeConstraint& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.RuntimeConstraint) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool RelCommon_RuntimeConstraint::IsInitialized() const { - return true; -} - -void RelCommon_RuntimeConstraint::InternalSwap(RelCommon_RuntimeConstraint* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_RuntimeConstraint::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[5]); -} - -// =================================================================== - -class RelCommon::_Internal { - public: - static const ::io::substrait::RelCommon_Direct& direct(const RelCommon* msg); - static const ::io::substrait::RelCommon_Emit& emit(const RelCommon* msg); - static const ::io::substrait::RelCommon_Hint& hint(const RelCommon* msg); - static const ::io::substrait::RelCommon_RuntimeConstraint& constraint(const RelCommon* msg); -}; - -const ::io::substrait::RelCommon_Direct& -RelCommon::_Internal::direct(const RelCommon* msg) { - return *msg->kind_.direct_; -} -const ::io::substrait::RelCommon_Emit& -RelCommon::_Internal::emit(const RelCommon* msg) { - return *msg->kind_.emit_; -} -const ::io::substrait::RelCommon_Hint& -RelCommon::_Internal::hint(const RelCommon* msg) { - return *msg->hint_; -} -const ::io::substrait::RelCommon_RuntimeConstraint& -RelCommon::_Internal::constraint(const RelCommon* msg) { - return *msg->constraint_; -} -void RelCommon::set_allocated_direct(::io::substrait::RelCommon_Direct* direct) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_kind(); - if (direct) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(direct); - if (message_arena != submessage_arena) { - direct = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, direct, submessage_arena); - } - set_has_direct(); - kind_.direct_ = direct; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.direct) -} -void RelCommon::set_allocated_emit(::io::substrait::RelCommon_Emit* emit) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_kind(); - if (emit) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(emit); - if (message_arena != submessage_arena) { - emit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, emit, submessage_arena); - } - set_has_emit(); - kind_.emit_ = emit; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.emit) -} -RelCommon::RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon) -} -RelCommon::RelCommon(const RelCommon& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_hint()) { - hint_ = new ::io::substrait::RelCommon_Hint(*from.hint_); - } else { - hint_ = nullptr; - } - if (from._internal_has_constraint()) { - constraint_ = new ::io::substrait::RelCommon_RuntimeConstraint(*from.constraint_); - } else { - constraint_ = nullptr; - } - clear_has_kind(); - switch (from.kind_case()) { - case kDirect: { - _internal_mutable_direct()->::io::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); - break; - } - case kEmit: { - _internal_mutable_emit()->::io::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); - break; - } - case KIND_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon) -} - -void RelCommon::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&hint_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&constraint_) - - reinterpret_cast(&hint_)) + sizeof(constraint_)); -clear_has_kind(); -} - -RelCommon::~RelCommon() { - // @@protoc_insertion_point(destructor:io.substrait.RelCommon) +RelCommon::~RelCommon() { + // @@protoc_insertion_point(destructor:io.substrait.RelCommon) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2051,9 +2153,9 @@ RelCommon::~RelCommon() { void RelCommon::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete hint_; - if (this != internal_default_instance()) delete constraint_; - if (has_kind()) { - clear_kind(); + if (this != internal_default_instance()) delete advanced_extension_; + if (has_emit_kind()) { + clear_emit_kind(); } } @@ -2067,26 +2169,26 @@ void RelCommon::SetCachedSize(int size) const { _cached_size_.Set(size); } -void RelCommon::clear_kind() { +void RelCommon::clear_emit_kind() { // @@protoc_insertion_point(one_of_clear_start:io.substrait.RelCommon) - switch (kind_case()) { + switch (emit_kind_case()) { case kDirect: { if (GetArena() == nullptr) { - delete kind_.direct_; + delete emit_kind_.direct_; } break; } case kEmit: { if (GetArena() == nullptr) { - delete kind_.emit_; + delete emit_kind_.emit_; } break; } - case KIND_NOT_SET: { + case EMIT_KIND_NOT_SET: { break; } } - _oneof_case_[0] = KIND_NOT_SET; + _oneof_case_[0] = EMIT_KIND_NOT_SET; } @@ -2100,11 +2202,11 @@ void RelCommon::Clear() { delete hint_; } hint_ = nullptr; - if (GetArena() == nullptr && constraint_ != nullptr) { - delete constraint_; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; } - constraint_ = nullptr; - clear_kind(); + advanced_extension_ = nullptr; + clear_emit_kind(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2135,10 +2237,10 @@ const char* RelCommon::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.RelCommon.RuntimeConstraint constraint = 4; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_constraint(), ptr); + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -2195,12 +2297,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon::_InternalSerialize( 3, _Internal::hint(this), target, stream); } - // .io.substrait.RelCommon.RuntimeConstraint constraint = 4; - if (this->has_constraint()) { + // .io.substrait.extensions.AdvancedExtension advanced_extension = 4; + if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 4, _Internal::constraint(this), target, stream); + 4, _Internal::advanced_extension(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -2226,29 +2328,29 @@ size_t RelCommon::ByteSizeLong() const { *hint_); } - // .io.substrait.RelCommon.RuntimeConstraint constraint = 4; - if (this->has_constraint()) { + // .io.substrait.extensions.AdvancedExtension advanced_extension = 4; + if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *constraint_); + *advanced_extension_); } - switch (kind_case()) { + switch (emit_kind_case()) { // .io.substrait.RelCommon.Direct direct = 1; case kDirect: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.direct_); + *emit_kind_.direct_); break; } // .io.substrait.RelCommon.Emit emit = 2; case kEmit: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.emit_); + *emit_kind_.emit_); break; } - case KIND_NOT_SET: { + case EMIT_KIND_NOT_SET: { break; } } @@ -2286,10 +2388,10 @@ void RelCommon::MergeFrom(const RelCommon& from) { if (from.has_hint()) { _internal_mutable_hint()->::io::substrait::RelCommon_Hint::MergeFrom(from._internal_hint()); } - if (from.has_constraint()) { - _internal_mutable_constraint()->::io::substrait::RelCommon_RuntimeConstraint::MergeFrom(from._internal_constraint()); + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } - switch (from.kind_case()) { + switch (from.emit_kind_case()) { case kDirect: { _internal_mutable_direct()->::io::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); break; @@ -2298,7 +2400,7 @@ void RelCommon::MergeFrom(const RelCommon& from) { _internal_mutable_emit()->::io::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); break; } - case KIND_NOT_SET: { + case EMIT_KIND_NOT_SET: { break; } } @@ -2326,27 +2428,38 @@ void RelCommon::InternalSwap(RelCommon* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(RelCommon, constraint_) - + sizeof(RelCommon::constraint_) + PROTOBUF_FIELD_OFFSET(RelCommon, advanced_extension_) + + sizeof(RelCommon::advanced_extension_) - PROTOBUF_FIELD_OFFSET(RelCommon, hint_)>( reinterpret_cast(&hint_), reinterpret_cast(&other->hint_)); - swap(kind_, other->kind_); + swap(emit_kind_, other->emit_kind_); swap(_oneof_case_[0], other->_oneof_case_[0]); } ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[6]); + file_level_metadata_relations_2eproto[5]); } // =================================================================== class ReadRel_NamedTable::_Internal { public: + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_NamedTable* msg); }; +const ::io::substrait::extensions::AdvancedExtension& +ReadRel_NamedTable::_Internal::advanced_extension(const ReadRel_NamedTable* msg) { + return *msg->advanced_extension_; +} +void ReadRel_NamedTable::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} ReadRel_NamedTable::ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), names_(arena) { @@ -2358,10 +2471,16 @@ ReadRel_NamedTable::ReadRel_NamedTable(const ReadRel_NamedTable& from) : ::PROTOBUF_NAMESPACE_ID::Message(), names_(from.names_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.NamedTable) } void ReadRel_NamedTable::SharedCtor() { +advanced_extension_ = nullptr; } ReadRel_NamedTable::~ReadRel_NamedTable() { @@ -2372,6 +2491,7 @@ ReadRel_NamedTable::~ReadRel_NamedTable() { void ReadRel_NamedTable::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete advanced_extension_; } void ReadRel_NamedTable::ArenaDtor(void* object) { @@ -2391,6 +2511,10 @@ void ReadRel_NamedTable::Clear() { (void) cached_has_bits; names_.Clear(); + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2414,6 +2538,13 @@ const char* ReadRel_NamedTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMES } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -2453,6 +2584,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_NamedTable::_InternalSerialize( target = stream->WriteString(1, s, target); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -2477,6 +2616,13 @@ size_t ReadRel_NamedTable::ByteSizeLong() const { names_.Get(i)); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -2509,6 +2655,9 @@ void ReadRel_NamedTable::MergeFrom(const ReadRel_NamedTable& from) { (void) cached_has_bits; names_.MergeFrom(from.names_); + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + } } void ReadRel_NamedTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { @@ -2533,12 +2682,13 @@ void ReadRel_NamedTable::InternalSwap(ReadRel_NamedTable* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); names_.InternalSwap(&other->names_); + swap(advanced_extension_, other->advanced_extension_); } ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_NamedTable::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[7]); + file_level_metadata_relations_2eproto[6]); } // =================================================================== @@ -2736,54 +2886,273 @@ void ReadRel_VirtualTable::InternalSwap(ReadRel_VirtualTable* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_VirtualTable::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[8]); + file_level_metadata_relations_2eproto[7]); } // =================================================================== -class ReadRel_LocalFiles_FileOrFiles::_Internal { +class ReadRel_ExtensionTable::_Internal { public: + static const PROTOBUF_NAMESPACE_ID::Any& detail(const ReadRel_ExtensionTable* msg); }; -ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena) +const PROTOBUF_NAMESPACE_ID::Any& +ReadRel_ExtensionTable::_Internal::detail(const ReadRel_ExtensionTable* msg) { + return *msg->detail_; +} +void ReadRel_ExtensionTable::clear_detail() { + if (GetArena() == nullptr && detail_ != nullptr) { + delete detail_; + } + detail_ = nullptr; +} +ReadRel_ExtensionTable::ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) + // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.ExtensionTable) } -ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from) +ReadRel_ExtensionTable::ReadRel_ExtensionTable(const ReadRel_ExtensionTable& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - format_ = from.format_; - clear_has_path_type(); - switch (from.path_type_case()) { - case kUriPath: { - _internal_set_uri_path(from._internal_uri_path()); - break; - } - case kUriPathGlob: { - _internal_set_uri_path_glob(from._internal_uri_path_glob()); - break; - } - case PATH_TYPE_NOT_SET: { - break; - } + if (from._internal_has_detail()) { + detail_ = new PROTOBUF_NAMESPACE_ID::Any(*from.detail_); + } else { + detail_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) + // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.ExtensionTable) } -void ReadRel_LocalFiles_FileOrFiles::SharedCtor() { -format_ = 0; -clear_has_path_type(); +void ReadRel_ExtensionTable::SharedCtor() { +detail_ = nullptr; } -ReadRel_LocalFiles_FileOrFiles::~ReadRel_LocalFiles_FileOrFiles() { - // @@protoc_insertion_point(destructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) +ReadRel_ExtensionTable::~ReadRel_ExtensionTable() { + // @@protoc_insertion_point(destructor:io.substrait.ReadRel.ExtensionTable) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ReadRel_LocalFiles_FileOrFiles::SharedDtor() { +void ReadRel_ExtensionTable::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete detail_; +} + +void ReadRel_ExtensionTable::ArenaDtor(void* object) { + ReadRel_ExtensionTable* _this = reinterpret_cast< ReadRel_ExtensionTable* >(object); + (void)_this; +} +void ReadRel_ExtensionTable::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ReadRel_ExtensionTable::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ReadRel_ExtensionTable::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel.ExtensionTable) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && detail_ != nullptr) { + delete detail_; + } + detail_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ReadRel_ExtensionTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .google.protobuf.Any detail = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_ExtensionTable::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel.ExtensionTable) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .google.protobuf.Any detail = 1; + if (this->has_detail()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::detail(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel.ExtensionTable) + return target; +} + +size_t ReadRel_ExtensionTable::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel.ExtensionTable) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .google.protobuf.Any detail = 1; + if (this->has_detail()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *detail_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ReadRel_ExtensionTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel.ExtensionTable) + GOOGLE_DCHECK_NE(&from, this); + const ReadRel_ExtensionTable* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel.ExtensionTable) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel.ExtensionTable) + MergeFrom(*source); + } +} + +void ReadRel_ExtensionTable::MergeFrom(const ReadRel_ExtensionTable& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel.ExtensionTable) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_detail()) { + _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); + } +} + +void ReadRel_ExtensionTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel.ExtensionTable) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ReadRel_ExtensionTable::CopyFrom(const ReadRel_ExtensionTable& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel.ExtensionTable) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ReadRel_ExtensionTable::IsInitialized() const { + return true; +} + +void ReadRel_ExtensionTable::InternalSwap(ReadRel_ExtensionTable* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(detail_, other->detail_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_ExtensionTable::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[8]); +} + +// =================================================================== + +class ReadRel_LocalFiles_FileOrFiles::_Internal { + public: +}; + +ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) +} +ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + format_ = from.format_; + clear_has_path_type(); + switch (from.path_type_case()) { + case kUriPath: { + _internal_set_uri_path(from._internal_uri_path()); + break; + } + case kUriPathGlob: { + _internal_set_uri_path_glob(from._internal_uri_path_glob()); + break; + } + case kUriFile: { + _internal_set_uri_file(from._internal_uri_file()); + break; + } + case kUriFolder: { + _internal_set_uri_folder(from._internal_uri_folder()); + break; + } + case PATH_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) +} + +void ReadRel_LocalFiles_FileOrFiles::SharedCtor() { +format_ = 0; +clear_has_path_type(); +} + +ReadRel_LocalFiles_FileOrFiles::~ReadRel_LocalFiles_FileOrFiles() { + // @@protoc_insertion_point(destructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ReadRel_LocalFiles_FileOrFiles::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (has_path_type()) { clear_path_type(); @@ -2811,6 +3180,14 @@ void ReadRel_LocalFiles_FileOrFiles::clear_path_type() { path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); break; } + case kUriFile: { + path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } + case kUriFolder: { + path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + break; + } case PATH_TYPE_NOT_SET: { break; } @@ -2854,9 +3231,27 @@ const char* ReadRel_LocalFiles_FileOrFiles::_InternalParse(const char* ptr, ::PR CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 3; + // string uri_file = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_uri_file(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string uri_folder = 4; + case 4: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + auto str = _internal_mutable_uri_folder(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 5; + case 5: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_format(static_cast<::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format>(val)); @@ -2911,11 +3306,31 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles_FileOrFiles::_InternalSeriali 2, this->_internal_uri_path_glob(), target); } - // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 3; + // string uri_file = 3; + if (_internal_has_uri_file()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_uri_file().data(), static_cast(this->_internal_uri_file().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_uri_file(), target); + } + + // string uri_folder = 4; + if (_internal_has_uri_folder()) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_uri_folder().data(), static_cast(this->_internal_uri_folder().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder"); + target = stream->WriteStringMaybeAliased( + 4, this->_internal_uri_folder(), target); + } + + // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 5; if (this->format() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_format(), target); + 5, this->_internal_format(), target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -2934,7 +3349,7 @@ size_t ReadRel_LocalFiles_FileOrFiles::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 3; + // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 5; if (this->format() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_format()); @@ -2955,6 +3370,20 @@ size_t ReadRel_LocalFiles_FileOrFiles::ByteSizeLong() const { this->_internal_uri_path_glob()); break; } + // string uri_file = 3; + case kUriFile: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_uri_file()); + break; + } + // string uri_folder = 4; + case kUriFolder: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_uri_folder()); + break; + } case PATH_TYPE_NOT_SET: { break; } @@ -3002,6 +3431,14 @@ void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ReadRel_LocalFiles_FileOrFi _internal_set_uri_path_glob(from._internal_uri_path_glob()); break; } + case kUriFile: { + _internal_set_uri_file(from._internal_uri_file()); + break; + } + case kUriFolder: { + _internal_set_uri_folder(from._internal_uri_folder()); + break; + } case PATH_TYPE_NOT_SET: { break; } @@ -3044,8 +3481,19 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles_FileOrFiles::GetMetadata() class ReadRel_LocalFiles::_Internal { public: + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_LocalFiles* msg); }; +const ::io::substrait::extensions::AdvancedExtension& +ReadRel_LocalFiles::_Internal::advanced_extension(const ReadRel_LocalFiles* msg) { + return *msg->advanced_extension_; +} +void ReadRel_LocalFiles::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} ReadRel_LocalFiles::ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), items_(arena) { @@ -3057,10 +3505,16 @@ ReadRel_LocalFiles::ReadRel_LocalFiles(const ReadRel_LocalFiles& from) : ::PROTOBUF_NAMESPACE_ID::Message(), items_(from.items_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.LocalFiles) } void ReadRel_LocalFiles::SharedCtor() { +advanced_extension_ = nullptr; } ReadRel_LocalFiles::~ReadRel_LocalFiles() { @@ -3071,6 +3525,7 @@ ReadRel_LocalFiles::~ReadRel_LocalFiles() { void ReadRel_LocalFiles::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete advanced_extension_; } void ReadRel_LocalFiles::ArenaDtor(void* object) { @@ -3090,6 +3545,10 @@ void ReadRel_LocalFiles::Clear() { (void) cached_has_bits; items_.Clear(); + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3111,6 +3570,13 @@ const char* ReadRel_LocalFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMES } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -3148,6 +3614,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles::_InternalSerialize( InternalWriteMessage(1, this->_internal_items(i), target, stream); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -3171,6 +3645,13 @@ size_t ReadRel_LocalFiles::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -3203,6 +3684,9 @@ void ReadRel_LocalFiles::MergeFrom(const ReadRel_LocalFiles& from) { (void) cached_has_bits; items_.MergeFrom(from.items_); + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + } } void ReadRel_LocalFiles::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { @@ -3227,6 +3711,7 @@ void ReadRel_LocalFiles::InternalSwap(ReadRel_LocalFiles* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); items_.InternalSwap(&other->items_); + swap(advanced_extension_, other->advanced_extension_); } ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles::GetMetadata() const { @@ -3240,19 +3725,21 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles::GetMetadata() const { class ReadRel::_Internal { public: static const ::io::substrait::RelCommon& common(const ReadRel* msg); - static const ::io::substrait::Type_NamedStruct& base_schema(const ReadRel* msg); + static const ::io::substrait::NamedStruct& base_schema(const ReadRel* msg); static const ::io::substrait::Expression& filter(const ReadRel* msg); - static const ::io::substrait::MaskExpression& projection(const ReadRel* msg); + static const ::io::substrait::Expression_MaskExpression& projection(const ReadRel* msg); + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel* msg); static const ::io::substrait::ReadRel_VirtualTable& virtual_table(const ReadRel* msg); static const ::io::substrait::ReadRel_LocalFiles& local_files(const ReadRel* msg); static const ::io::substrait::ReadRel_NamedTable& named_table(const ReadRel* msg); + static const ::io::substrait::ReadRel_ExtensionTable& extension_table(const ReadRel* msg); }; const ::io::substrait::RelCommon& ReadRel::_Internal::common(const ReadRel* msg) { return *msg->common_; } -const ::io::substrait::Type_NamedStruct& +const ::io::substrait::NamedStruct& ReadRel::_Internal::base_schema(const ReadRel* msg) { return *msg->base_schema_; } @@ -3260,10 +3747,14 @@ const ::io::substrait::Expression& ReadRel::_Internal::filter(const ReadRel* msg) { return *msg->filter_; } -const ::io::substrait::MaskExpression& +const ::io::substrait::Expression_MaskExpression& ReadRel::_Internal::projection(const ReadRel* msg) { return *msg->projection_; } +const ::io::substrait::extensions::AdvancedExtension& +ReadRel::_Internal::advanced_extension(const ReadRel* msg) { + return *msg->advanced_extension_; +} const ::io::substrait::ReadRel_VirtualTable& ReadRel::_Internal::virtual_table(const ReadRel* msg) { return *msg->read_type_.virtual_table_; @@ -3276,6 +3767,10 @@ const ::io::substrait::ReadRel_NamedTable& ReadRel::_Internal::named_table(const ReadRel* msg) { return *msg->read_type_.named_table_; } +const ::io::substrait::ReadRel_ExtensionTable& +ReadRel::_Internal::extension_table(const ReadRel* msg) { + return *msg->read_type_.extension_table_; +} void ReadRel::clear_base_schema() { if (GetArena() == nullptr && base_schema_ != nullptr) { delete base_schema_; @@ -3294,6 +3789,12 @@ void ReadRel::clear_projection() { } projection_ = nullptr; } +void ReadRel::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} void ReadRel::set_allocated_virtual_table(::io::substrait::ReadRel_VirtualTable* virtual_table) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_read_type(); @@ -3339,6 +3840,21 @@ void ReadRel::set_allocated_named_table(::io::substrait::ReadRel_NamedTable* nam } // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.named_table) } +void ReadRel::set_allocated_extension_table(::io::substrait::ReadRel_ExtensionTable* extension_table) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_read_type(); + if (extension_table) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_table); + if (message_arena != submessage_arena) { + extension_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_table, submessage_arena); + } + set_has_extension_table(); + read_type_.extension_table_ = extension_table; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.extension_table) +} ReadRel::ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -3354,7 +3870,7 @@ ReadRel::ReadRel(const ReadRel& from) common_ = nullptr; } if (from._internal_has_base_schema()) { - base_schema_ = new ::io::substrait::Type_NamedStruct(*from.base_schema_); + base_schema_ = new ::io::substrait::NamedStruct(*from.base_schema_); } else { base_schema_ = nullptr; } @@ -3364,10 +3880,15 @@ ReadRel::ReadRel(const ReadRel& from) filter_ = nullptr; } if (from._internal_has_projection()) { - projection_ = new ::io::substrait::MaskExpression(*from.projection_); + projection_ = new ::io::substrait::Expression_MaskExpression(*from.projection_); } else { projection_ = nullptr; } + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } clear_has_read_type(); switch (from.read_type_case()) { case kVirtualTable: { @@ -3382,6 +3903,10 @@ ReadRel::ReadRel(const ReadRel& from) _internal_mutable_named_table()->::io::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table()); break; } + case kExtensionTable: { + _internal_mutable_extension_table()->::io::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table()); + break; + } case READ_TYPE_NOT_SET: { break; } @@ -3392,8 +3917,8 @@ ReadRel::ReadRel(const ReadRel& from) void ReadRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&projection_) - - reinterpret_cast(&common_)) + sizeof(projection_)); + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&common_)) + sizeof(advanced_extension_)); clear_has_read_type(); } @@ -3409,6 +3934,7 @@ void ReadRel::SharedDtor() { if (this != internal_default_instance()) delete base_schema_; if (this != internal_default_instance()) delete filter_; if (this != internal_default_instance()) delete projection_; + if (this != internal_default_instance()) delete advanced_extension_; if (has_read_type()) { clear_read_type(); } @@ -3445,6 +3971,12 @@ void ReadRel::clear_read_type() { } break; } + case kExtensionTable: { + if (GetArena() == nullptr) { + delete read_type_.extension_table_; + } + break; + } case READ_TYPE_NOT_SET: { break; } @@ -3475,6 +4007,10 @@ void ReadRel::Clear() { delete projection_; } projection_ = nullptr; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; clear_read_type(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3492,7 +4028,7 @@ const char* ReadRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.NamedStruct base_schema = 2; + // .io.substrait.NamedStruct base_schema = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_base_schema(), ptr); @@ -3506,7 +4042,7 @@ const char* ReadRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.MaskExpression projection = 4; + // .io.substrait.Expression.MaskExpression projection = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_projection(), ptr); @@ -3534,10 +4070,24 @@ const char* ReadRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); } else goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); + // .io.substrait.ReadRel.ExtensionTable extension_table = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_table(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); ctx->SetLastTag(tag); goto success; } @@ -3571,7 +4121,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // .io.substrait.Type.NamedStruct base_schema = 2; + // .io.substrait.NamedStruct base_schema = 2; if (this->has_base_schema()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3587,7 +4137,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 3, _Internal::filter(this), target, stream); } - // .io.substrait.MaskExpression projection = 4; + // .io.substrait.Expression.MaskExpression projection = 4; if (this->has_projection()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3619,6 +4169,22 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 7, _Internal::named_table(this), target, stream); } + // .io.substrait.ReadRel.ExtensionTable extension_table = 8; + if (_internal_has_extension_table()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 8, _Internal::extension_table(this), target, stream); + } + + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -3642,7 +4208,7 @@ size_t ReadRel::ByteSizeLong() const { *common_); } - // .io.substrait.Type.NamedStruct base_schema = 2; + // .io.substrait.NamedStruct base_schema = 2; if (this->has_base_schema()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -3656,13 +4222,20 @@ size_t ReadRel::ByteSizeLong() const { *filter_); } - // .io.substrait.MaskExpression projection = 4; + // .io.substrait.Expression.MaskExpression projection = 4; if (this->has_projection()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *projection_); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + switch (read_type_case()) { // .io.substrait.ReadRel.VirtualTable virtual_table = 5; case kVirtualTable: { @@ -3685,6 +4258,13 @@ size_t ReadRel::ByteSizeLong() const { *read_type_.named_table_); break; } + // .io.substrait.ReadRel.ExtensionTable extension_table = 8; + case kExtensionTable: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *read_type_.extension_table_); + break; + } case READ_TYPE_NOT_SET: { break; } @@ -3724,13 +4304,16 @@ void ReadRel::MergeFrom(const ReadRel& from) { _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_base_schema()) { - _internal_mutable_base_schema()->::io::substrait::Type_NamedStruct::MergeFrom(from._internal_base_schema()); + _internal_mutable_base_schema()->::io::substrait::NamedStruct::MergeFrom(from._internal_base_schema()); } if (from.has_filter()) { _internal_mutable_filter()->::io::substrait::Expression::MergeFrom(from._internal_filter()); } if (from.has_projection()) { - _internal_mutable_projection()->::io::substrait::MaskExpression::MergeFrom(from._internal_projection()); + _internal_mutable_projection()->::io::substrait::Expression_MaskExpression::MergeFrom(from._internal_projection()); + } + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } switch (from.read_type_case()) { case kVirtualTable: { @@ -3745,6 +4328,10 @@ void ReadRel::MergeFrom(const ReadRel& from) { _internal_mutable_named_table()->::io::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table()); break; } + case kExtensionTable: { + _internal_mutable_extension_table()->::io::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table()); + break; + } case READ_TYPE_NOT_SET: { break; } @@ -3773,8 +4360,8 @@ void ReadRel::InternalSwap(ReadRel* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ReadRel, projection_) - + sizeof(ReadRel::projection_) + PROTOBUF_FIELD_OFFSET(ReadRel, advanced_extension_) + + sizeof(ReadRel::advanced_extension_) - PROTOBUF_FIELD_OFFSET(ReadRel, common_)>( reinterpret_cast(&common_), reinterpret_cast(&other->common_)); @@ -3794,6 +4381,7 @@ class ProjectRel::_Internal { public: static const ::io::substrait::RelCommon& common(const ProjectRel* msg); static const ::io::substrait::Rel& input(const ProjectRel* msg); + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const ProjectRel* msg); }; const ::io::substrait::RelCommon& @@ -3804,9 +4392,19 @@ const ::io::substrait::Rel& ProjectRel::_Internal::input(const ProjectRel* msg) { return *msg->input_; } +const ::io::substrait::extensions::AdvancedExtension& +ProjectRel::_Internal::advanced_extension(const ProjectRel* msg) { + return *msg->advanced_extension_; +} void ProjectRel::clear_expressions() { expressions_.Clear(); } +void ProjectRel::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} ProjectRel::ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), expressions_(arena) { @@ -3828,14 +4426,19 @@ ProjectRel::ProjectRel(const ProjectRel& from) } else { input_ = nullptr; } + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } // @@protoc_insertion_point(copy_constructor:io.substrait.ProjectRel) } void ProjectRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&input_) - - reinterpret_cast(&common_)) + sizeof(input_)); + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&common_)) + sizeof(advanced_extension_)); } ProjectRel::~ProjectRel() { @@ -3848,6 +4451,7 @@ void ProjectRel::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; + if (this != internal_default_instance()) delete advanced_extension_; } void ProjectRel::ArenaDtor(void* object) { @@ -3875,6 +4479,10 @@ void ProjectRel::Clear() { delete input_; } input_ = nullptr; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3910,6 +4518,13 @@ const char* ProjectRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -3963,6 +4578,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ProjectRel::_InternalSerialize( InternalWriteMessage(3, this->_internal_expressions(i), target, stream); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -4000,6 +4623,13 @@ size_t ProjectRel::ByteSizeLong() const { *input_); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -4038,6 +4668,9 @@ void ProjectRel::MergeFrom(const ProjectRel& from) { if (from.has_input()) { _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); } + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + } } void ProjectRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { @@ -4063,8 +4696,8 @@ void ProjectRel::InternalSwap(ProjectRel* other) { _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); expressions_.InternalSwap(&other->expressions_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ProjectRel, input_) - + sizeof(ProjectRel::input_) + PROTOBUF_FIELD_OFFSET(ProjectRel, advanced_extension_) + + sizeof(ProjectRel::advanced_extension_) - PROTOBUF_FIELD_OFFSET(ProjectRel, common_)>( reinterpret_cast(&common_), reinterpret_cast(&other->common_)); @@ -4085,6 +4718,7 @@ class JoinRel::_Internal { static const ::io::substrait::Rel& right(const JoinRel* msg); static const ::io::substrait::Expression& expression(const JoinRel* msg); static const ::io::substrait::Expression& post_join_filter(const JoinRel* msg); + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const JoinRel* msg); }; const ::io::substrait::RelCommon& @@ -4107,6 +4741,10 @@ const ::io::substrait::Expression& JoinRel::_Internal::post_join_filter(const JoinRel* msg) { return *msg->post_join_filter_; } +const ::io::substrait::extensions::AdvancedExtension& +JoinRel::_Internal::advanced_extension(const JoinRel* msg) { + return *msg->advanced_extension_; +} void JoinRel::clear_expression() { if (GetArena() == nullptr && expression_ != nullptr) { delete expression_; @@ -4119,6 +4757,12 @@ void JoinRel::clear_post_join_filter() { } post_join_filter_ = nullptr; } +void JoinRel::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} JoinRel::JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -4153,6 +4797,11 @@ JoinRel::JoinRel(const JoinRel& from) } else { post_join_filter_ = nullptr; } + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } type_ = from.type_; // @@protoc_insertion_point(copy_constructor:io.substrait.JoinRel) } @@ -4177,6 +4826,7 @@ void JoinRel::SharedDtor() { if (this != internal_default_instance()) delete right_; if (this != internal_default_instance()) delete expression_; if (this != internal_default_instance()) delete post_join_filter_; + if (this != internal_default_instance()) delete advanced_extension_; } void JoinRel::ArenaDtor(void* object) { @@ -4215,6 +4865,10 @@ void JoinRel::Clear() { delete post_join_filter_; } post_join_filter_ = nullptr; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; type_ = 0; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4268,6 +4922,13 @@ const char* JoinRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in _internal_set_type(static_cast<::io::substrait::JoinRel_JoinType>(val)); } else goto handle_unusual; continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -4344,6 +5005,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( 6, this->_internal_type(), target); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -4395,6 +5064,13 @@ size_t JoinRel::ByteSizeLong() const { *post_join_filter_); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + // .io.substrait.JoinRel.JoinType type = 6; if (this->type() != 0) { total_size += 1 + @@ -4447,6 +5123,9 @@ void JoinRel::MergeFrom(const JoinRel& from) { if (from.has_post_join_filter()) { _internal_mutable_post_join_filter()->::io::substrait::Expression::MergeFrom(from._internal_post_join_filter()); } + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + } if (from.type() != 0) { _internal_set_type(from._internal_type()); } @@ -4493,6 +5172,7 @@ class FetchRel::_Internal { public: static const ::io::substrait::RelCommon& common(const FetchRel* msg); static const ::io::substrait::Rel& input(const FetchRel* msg); + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const FetchRel* msg); }; const ::io::substrait::RelCommon& @@ -4503,6 +5183,16 @@ const ::io::substrait::Rel& FetchRel::_Internal::input(const FetchRel* msg) { return *msg->input_; } +const ::io::substrait::extensions::AdvancedExtension& +FetchRel::_Internal::advanced_extension(const FetchRel* msg) { + return *msg->advanced_extension_; +} +void FetchRel::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} FetchRel::FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -4522,6 +5212,11 @@ FetchRel::FetchRel(const FetchRel& from) } else { input_ = nullptr; } + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } ::memcpy(&offset_, &from.offset_, static_cast(reinterpret_cast(&count_) - reinterpret_cast(&offset_)) + sizeof(count_)); @@ -4545,6 +5240,7 @@ void FetchRel::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; + if (this != internal_default_instance()) delete advanced_extension_; } void FetchRel::ArenaDtor(void* object) { @@ -4571,6 +5267,10 @@ void FetchRel::Clear() { delete input_; } input_ = nullptr; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; ::memset(&offset_, 0, static_cast( reinterpret_cast(&count_) - reinterpret_cast(&offset_)) + sizeof(count_)); @@ -4611,6 +5311,13 @@ const char* FetchRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i CHK_(ptr); } else goto handle_unusual; continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -4668,6 +5375,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FetchRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_count(), target); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -4698,6 +5413,13 @@ size_t FetchRel::ByteSizeLong() const { *input_); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + // int64 offset = 3; if (this->offset() != 0) { total_size += 1 + @@ -4749,6 +5471,9 @@ void FetchRel::MergeFrom(const FetchRel& from) { if (from.has_input()) { _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); } + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + } if (from.offset() != 0) { _internal_set_offset(from._internal_offset()); } @@ -4998,19 +5723,30 @@ ::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Grouping::GetMetadata() const { class AggregateRel_Measure::_Internal { public: - static const ::io::substrait::Expression_AggregateFunction& measure(const AggregateRel_Measure* msg); + static const ::io::substrait::AggregateFunction& measure(const AggregateRel_Measure* msg); + static const ::io::substrait::Expression& filter(const AggregateRel_Measure* msg); }; -const ::io::substrait::Expression_AggregateFunction& +const ::io::substrait::AggregateFunction& AggregateRel_Measure::_Internal::measure(const AggregateRel_Measure* msg) { return *msg->measure_; } +const ::io::substrait::Expression& +AggregateRel_Measure::_Internal::filter(const AggregateRel_Measure* msg) { + return *msg->filter_; +} void AggregateRel_Measure::clear_measure() { if (GetArena() == nullptr && measure_ != nullptr) { delete measure_; } measure_ = nullptr; } +void AggregateRel_Measure::clear_filter() { + if (GetArena() == nullptr && filter_ != nullptr) { + delete filter_; + } + filter_ = nullptr; +} AggregateRel_Measure::AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -5021,15 +5757,23 @@ AggregateRel_Measure::AggregateRel_Measure(const AggregateRel_Measure& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_measure()) { - measure_ = new ::io::substrait::Expression_AggregateFunction(*from.measure_); + measure_ = new ::io::substrait::AggregateFunction(*from.measure_); } else { measure_ = nullptr; } + if (from._internal_has_filter()) { + filter_ = new ::io::substrait::Expression(*from.filter_); + } else { + filter_ = nullptr; + } // @@protoc_insertion_point(copy_constructor:io.substrait.AggregateRel.Measure) } void AggregateRel_Measure::SharedCtor() { -measure_ = nullptr; +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&measure_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&filter_) - + reinterpret_cast(&measure_)) + sizeof(filter_)); } AggregateRel_Measure::~AggregateRel_Measure() { @@ -5041,6 +5785,7 @@ AggregateRel_Measure::~AggregateRel_Measure() { void AggregateRel_Measure::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete measure_; + if (this != internal_default_instance()) delete filter_; } void AggregateRel_Measure::ArenaDtor(void* object) { @@ -5063,6 +5808,10 @@ void AggregateRel_Measure::Clear() { delete measure_; } measure_ = nullptr; + if (GetArena() == nullptr && filter_ != nullptr) { + delete filter_; + } + filter_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5072,13 +5821,20 @@ const char* AggregateRel_Measure::_InternalParse(const char* ptr, ::PROTOBUF_NAM ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.AggregateFunction measure = 1; + // .io.substrait.AggregateFunction measure = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_measure(), ptr); CHK_(ptr); } else goto handle_unusual; continue; + // .io.substrait.Expression filter = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -5108,7 +5864,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Measure::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.AggregateFunction measure = 1; + // .io.substrait.AggregateFunction measure = 1; if (this->has_measure()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5116,6 +5872,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Measure::_InternalSerialize( 1, _Internal::measure(this), target, stream); } + // .io.substrait.Expression filter = 2; + if (this->has_filter()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::filter(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -5132,13 +5896,20 @@ size_t AggregateRel_Measure::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression.AggregateFunction measure = 1; + // .io.substrait.AggregateFunction measure = 1; if (this->has_measure()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *measure_); } + // .io.substrait.Expression filter = 2; + if (this->has_filter()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *filter_); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -5171,7 +5942,10 @@ void AggregateRel_Measure::MergeFrom(const AggregateRel_Measure& from) { (void) cached_has_bits; if (from.has_measure()) { - _internal_mutable_measure()->::io::substrait::Expression_AggregateFunction::MergeFrom(from._internal_measure()); + _internal_mutable_measure()->::io::substrait::AggregateFunction::MergeFrom(from._internal_measure()); + } + if (from.has_filter()) { + _internal_mutable_filter()->::io::substrait::Expression::MergeFrom(from._internal_filter()); } } @@ -5196,7 +5970,12 @@ bool AggregateRel_Measure::IsInitialized() const { void AggregateRel_Measure::InternalSwap(AggregateRel_Measure* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(measure_, other->measure_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(AggregateRel_Measure, filter_) + + sizeof(AggregateRel_Measure::filter_) + - PROTOBUF_FIELD_OFFSET(AggregateRel_Measure, measure_)>( + reinterpret_cast(&measure_), + reinterpret_cast(&other->measure_)); } ::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Measure::GetMetadata() const { @@ -5211,6 +5990,7 @@ class AggregateRel::_Internal { public: static const ::io::substrait::RelCommon& common(const AggregateRel* msg); static const ::io::substrait::Rel& input(const AggregateRel* msg); + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const AggregateRel* msg); }; const ::io::substrait::RelCommon& @@ -5221,6 +6001,16 @@ const ::io::substrait::Rel& AggregateRel::_Internal::input(const AggregateRel* msg) { return *msg->input_; } +const ::io::substrait::extensions::AdvancedExtension& +AggregateRel::_Internal::advanced_extension(const AggregateRel* msg) { + return *msg->advanced_extension_; +} +void AggregateRel::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} AggregateRel::AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), groupings_(arena), @@ -5244,15 +6034,19 @@ AggregateRel::AggregateRel(const AggregateRel& from) } else { input_ = nullptr; } - phase_ = from.phase_; + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } // @@protoc_insertion_point(copy_constructor:io.substrait.AggregateRel) } void AggregateRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&phase_) - - reinterpret_cast(&common_)) + sizeof(phase_)); + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&common_)) + sizeof(advanced_extension_)); } AggregateRel::~AggregateRel() { @@ -5265,6 +6059,7 @@ void AggregateRel::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; + if (this != internal_default_instance()) delete advanced_extension_; } void AggregateRel::ArenaDtor(void* object) { @@ -5293,7 +6088,10 @@ void AggregateRel::Clear() { delete input_; } input_ = nullptr; - phase_ = 0; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5341,12 +6139,11 @@ const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Expression.AggregationPhase phase = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - _internal_set_phase(static_cast<::io::substrait::Expression_AggregationPhase>(val)); } else goto handle_unusual; continue; default: { @@ -5410,11 +6207,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( InternalWriteMessage(4, this->_internal_measures(i), target, stream); } - // .io.substrait.Expression.AggregationPhase phase = 5; - if (this->phase() != 0) { + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 5, this->_internal_phase(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -5461,10 +6259,11 @@ size_t AggregateRel::ByteSizeLong() const { *input_); } - // .io.substrait.Expression.AggregationPhase phase = 5; - if (this->phase() != 0) { + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -5506,8 +6305,8 @@ void AggregateRel::MergeFrom(const AggregateRel& from) { if (from.has_input()) { _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); } - if (from.phase() != 0) { - _internal_set_phase(from._internal_phase()); + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } } @@ -5535,8 +6334,8 @@ void AggregateRel::InternalSwap(AggregateRel* other) { groupings_.InternalSwap(&other->groupings_); measures_.InternalSwap(&other->measures_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(AggregateRel, phase_) - + sizeof(AggregateRel::phase_) + PROTOBUF_FIELD_OFFSET(AggregateRel, advanced_extension_) + + sizeof(AggregateRel::advanced_extension_) - PROTOBUF_FIELD_OFFSET(AggregateRel, common_)>( reinterpret_cast(&common_), reinterpret_cast(&other->common_)); @@ -5554,6 +6353,7 @@ class SortRel::_Internal { public: static const ::io::substrait::RelCommon& common(const SortRel* msg); static const ::io::substrait::Rel& input(const SortRel* msg); + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const SortRel* msg); }; const ::io::substrait::RelCommon& @@ -5564,9 +6364,19 @@ const ::io::substrait::Rel& SortRel::_Internal::input(const SortRel* msg) { return *msg->input_; } +const ::io::substrait::extensions::AdvancedExtension& +SortRel::_Internal::advanced_extension(const SortRel* msg) { + return *msg->advanced_extension_; +} void SortRel::clear_sorts() { sorts_.Clear(); } +void SortRel::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} SortRel::SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), sorts_(arena) { @@ -5588,14 +6398,19 @@ SortRel::SortRel(const SortRel& from) } else { input_ = nullptr; } + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } // @@protoc_insertion_point(copy_constructor:io.substrait.SortRel) } void SortRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&input_) - - reinterpret_cast(&common_)) + sizeof(input_)); + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&common_)) + sizeof(advanced_extension_)); } SortRel::~SortRel() { @@ -5608,6 +6423,7 @@ void SortRel::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; + if (this != internal_default_instance()) delete advanced_extension_; } void SortRel::ArenaDtor(void* object) { @@ -5635,6 +6451,10 @@ void SortRel::Clear() { delete input_; } input_ = nullptr; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5658,7 +6478,7 @@ const char* SortRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Expression.SortField sorts = 3; + // repeated .io.substrait.SortField sorts = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; @@ -5670,6 +6490,13 @@ const char* SortRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -5715,7 +6542,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( 2, _Internal::input(this), target, stream); } - // repeated .io.substrait.Expression.SortField sorts = 3; + // repeated .io.substrait.SortField sorts = 3; for (unsigned int i = 0, n = static_cast(this->_internal_sorts_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -5723,6 +6550,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( InternalWriteMessage(3, this->_internal_sorts(i), target, stream); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -5739,7 +6574,7 @@ size_t SortRel::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.SortField sorts = 3; + // repeated .io.substrait.SortField sorts = 3; total_size += 1UL * this->_internal_sorts_size(); for (const auto& msg : this->sorts_) { total_size += @@ -5760,6 +6595,13 @@ size_t SortRel::ByteSizeLong() const { *input_); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -5798,6 +6640,9 @@ void SortRel::MergeFrom(const SortRel& from) { if (from.has_input()) { _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); } + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + } } void SortRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { @@ -5823,8 +6668,8 @@ void SortRel::InternalSwap(SortRel* other) { _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); sorts_.InternalSwap(&other->sorts_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SortRel, input_) - + sizeof(SortRel::input_) + PROTOBUF_FIELD_OFFSET(SortRel, advanced_extension_) + + sizeof(SortRel::advanced_extension_) - PROTOBUF_FIELD_OFFSET(SortRel, common_)>( reinterpret_cast(&common_), reinterpret_cast(&other->common_)); @@ -5843,6 +6688,7 @@ class FilterRel::_Internal { static const ::io::substrait::RelCommon& common(const FilterRel* msg); static const ::io::substrait::Rel& input(const FilterRel* msg); static const ::io::substrait::Expression& condition(const FilterRel* msg); + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const FilterRel* msg); }; const ::io::substrait::RelCommon& @@ -5857,12 +6703,22 @@ const ::io::substrait::Expression& FilterRel::_Internal::condition(const FilterRel* msg) { return *msg->condition_; } +const ::io::substrait::extensions::AdvancedExtension& +FilterRel::_Internal::advanced_extension(const FilterRel* msg) { + return *msg->advanced_extension_; +} void FilterRel::clear_condition() { if (GetArena() == nullptr && condition_ != nullptr) { delete condition_; } condition_ = nullptr; } +void FilterRel::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} FilterRel::FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -5887,14 +6743,19 @@ FilterRel::FilterRel(const FilterRel& from) } else { condition_ = nullptr; } + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } // @@protoc_insertion_point(copy_constructor:io.substrait.FilterRel) } void FilterRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&condition_) - - reinterpret_cast(&common_)) + sizeof(condition_)); + 0, static_cast(reinterpret_cast(&advanced_extension_) - + reinterpret_cast(&common_)) + sizeof(advanced_extension_)); } FilterRel::~FilterRel() { @@ -5908,6 +6769,7 @@ void FilterRel::SharedDtor() { if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; if (this != internal_default_instance()) delete condition_; + if (this != internal_default_instance()) delete advanced_extension_; } void FilterRel::ArenaDtor(void* object) { @@ -5938,6 +6800,10 @@ void FilterRel::Clear() { delete condition_; } condition_ = nullptr; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5968,6 +6834,13 @@ const char* FilterRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -6021,6 +6894,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( 3, _Internal::condition(this), target, stream); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -6058,6 +6939,13 @@ size_t FilterRel::ByteSizeLong() const { *condition_); } + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -6074,174 +6962,1332 @@ void FilterRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FilterRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FilterRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FilterRel) + MergeFrom(*source); + } +} + +void FilterRel::MergeFrom(const FilterRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FilterRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_input()) { + _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + } + if (from.has_condition()) { + _internal_mutable_condition()->::io::substrait::Expression::MergeFrom(from._internal_condition()); + } + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + } +} + +void FilterRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FilterRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void FilterRel::CopyFrom(const FilterRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FilterRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FilterRel::IsInitialized() const { + return true; +} + +void FilterRel::InternalSwap(FilterRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(FilterRel, advanced_extension_) + + sizeof(FilterRel::advanced_extension_) + - PROTOBUF_FIELD_OFFSET(FilterRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FilterRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[19]); +} + +// =================================================================== + +class SetRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const SetRel* msg); + static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const SetRel* msg); +}; + +const ::io::substrait::RelCommon& +SetRel::_Internal::common(const SetRel* msg) { + return *msg->common_; +} +const ::io::substrait::extensions::AdvancedExtension& +SetRel::_Internal::advanced_extension(const SetRel* msg) { + return *msg->advanced_extension_; +} +void SetRel::clear_advanced_extension() { + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; +} +SetRel::SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + inputs_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.SetRel) +} +SetRel::SetRel(const SetRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + inputs_(from.inputs_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_advanced_extension()) { + advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + } else { + advanced_extension_ = nullptr; + } + op_ = from.op_; + // @@protoc_insertion_point(copy_constructor:io.substrait.SetRel) +} + +void SetRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&op_) - + reinterpret_cast(&common_)) + sizeof(op_)); +} + +SetRel::~SetRel() { + // @@protoc_insertion_point(destructor:io.substrait.SetRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SetRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete advanced_extension_; +} + +void SetRel::ArenaDtor(void* object) { + SetRel* _this = reinterpret_cast< SetRel* >(object); + (void)_this; +} +void SetRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SetRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SetRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.SetRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + inputs_.Clear(); + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && advanced_extension_ != nullptr) { + delete advanced_extension_; + } + advanced_extension_ = nullptr; + op_ = 0; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Rel inputs = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_inputs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.SetRel.SetOp op = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + _internal_set_op(static_cast<::io::substrait::SetRel_SetOp>(val)); + } else goto handle_unusual; + continue; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SetRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.SetRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // repeated .io.substrait.Rel inputs = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_inputs_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_inputs(i), target, stream); + } + + // .io.substrait.SetRel.SetOp op = 3; + if (this->op() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( + 3, this->_internal_op(), target); + } + + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::advanced_extension(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.SetRel) + return target; +} + +size_t SetRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.SetRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Rel inputs = 2; + total_size += 1UL * this->_internal_inputs_size(); + for (const auto& msg : this->inputs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + if (this->has_advanced_extension()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *advanced_extension_); + } + + // .io.substrait.SetRel.SetOp op = 3; + if (this->op() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SetRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.SetRel) + GOOGLE_DCHECK_NE(&from, this); + const SetRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.SetRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.SetRel) + MergeFrom(*source); + } +} + +void SetRel::MergeFrom(const SetRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.SetRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + inputs_.MergeFrom(from.inputs_); + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_advanced_extension()) { + _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + } + if (from.op() != 0) { + _internal_set_op(from._internal_op()); + } +} + +void SetRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.SetRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SetRel::CopyFrom(const SetRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.SetRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SetRel::IsInitialized() const { + return true; +} + +void SetRel::InternalSwap(SetRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + inputs_.InternalSwap(&other->inputs_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SetRel, op_) + + sizeof(SetRel::op_) + - PROTOBUF_FIELD_OFFSET(SetRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SetRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[20]); +} + +// =================================================================== + +class ExtensionSingleRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const ExtensionSingleRel* msg); + static const ::io::substrait::Rel& input(const ExtensionSingleRel* msg); + static const PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionSingleRel* msg); +}; + +const ::io::substrait::RelCommon& +ExtensionSingleRel::_Internal::common(const ExtensionSingleRel* msg) { + return *msg->common_; +} +const ::io::substrait::Rel& +ExtensionSingleRel::_Internal::input(const ExtensionSingleRel* msg) { + return *msg->input_; +} +const PROTOBUF_NAMESPACE_ID::Any& +ExtensionSingleRel::_Internal::detail(const ExtensionSingleRel* msg) { + return *msg->detail_; +} +void ExtensionSingleRel::clear_detail() { + if (GetArena() == nullptr && detail_ != nullptr) { + delete detail_; + } + detail_ = nullptr; +} +ExtensionSingleRel::ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ExtensionSingleRel) +} +ExtensionSingleRel::ExtensionSingleRel(const ExtensionSingleRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_input()) { + input_ = new ::io::substrait::Rel(*from.input_); + } else { + input_ = nullptr; + } + if (from._internal_has_detail()) { + detail_ = new PROTOBUF_NAMESPACE_ID::Any(*from.detail_); + } else { + detail_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ExtensionSingleRel) +} + +void ExtensionSingleRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&detail_) - + reinterpret_cast(&common_)) + sizeof(detail_)); +} + +ExtensionSingleRel::~ExtensionSingleRel() { + // @@protoc_insertion_point(destructor:io.substrait.ExtensionSingleRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ExtensionSingleRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete input_; + if (this != internal_default_instance()) delete detail_; +} + +void ExtensionSingleRel::ArenaDtor(void* object) { + ExtensionSingleRel* _this = reinterpret_cast< ExtensionSingleRel* >(object); + (void)_this; +} +void ExtensionSingleRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ExtensionSingleRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ExtensionSingleRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ExtensionSingleRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; + if (GetArena() == nullptr && detail_ != nullptr) { + delete detail_; + } + detail_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ExtensionSingleRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.Rel input = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .google.protobuf.Any detail = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ExtensionSingleRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ExtensionSingleRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::input(this), target, stream); + } + + // .google.protobuf.Any detail = 3; + if (this->has_detail()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::detail(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ExtensionSingleRel) + return target; +} + +size_t ExtensionSingleRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ExtensionSingleRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .io.substrait.Rel input = 2; + if (this->has_input()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *input_); + } + + // .google.protobuf.Any detail = 3; + if (this->has_detail()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *detail_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ExtensionSingleRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ExtensionSingleRel) + GOOGLE_DCHECK_NE(&from, this); + const ExtensionSingleRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ExtensionSingleRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ExtensionSingleRel) + MergeFrom(*source); + } +} + +void ExtensionSingleRel::MergeFrom(const ExtensionSingleRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ExtensionSingleRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_input()) { + _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + } + if (from.has_detail()) { + _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); + } +} + +void ExtensionSingleRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ExtensionSingleRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ExtensionSingleRel::CopyFrom(const ExtensionSingleRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ExtensionSingleRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ExtensionSingleRel::IsInitialized() const { + return true; +} + +void ExtensionSingleRel::InternalSwap(ExtensionSingleRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ExtensionSingleRel, detail_) + + sizeof(ExtensionSingleRel::detail_) + - PROTOBUF_FIELD_OFFSET(ExtensionSingleRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ExtensionSingleRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[21]); +} + +// =================================================================== + +class ExtensionLeafRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const ExtensionLeafRel* msg); + static const PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionLeafRel* msg); +}; + +const ::io::substrait::RelCommon& +ExtensionLeafRel::_Internal::common(const ExtensionLeafRel* msg) { + return *msg->common_; +} +const PROTOBUF_NAMESPACE_ID::Any& +ExtensionLeafRel::_Internal::detail(const ExtensionLeafRel* msg) { + return *msg->detail_; +} +void ExtensionLeafRel::clear_detail() { + if (GetArena() == nullptr && detail_ != nullptr) { + delete detail_; + } + detail_ = nullptr; +} +ExtensionLeafRel::ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ExtensionLeafRel) +} +ExtensionLeafRel::ExtensionLeafRel(const ExtensionLeafRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_detail()) { + detail_ = new PROTOBUF_NAMESPACE_ID::Any(*from.detail_); + } else { + detail_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ExtensionLeafRel) +} + +void ExtensionLeafRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&detail_) - + reinterpret_cast(&common_)) + sizeof(detail_)); +} + +ExtensionLeafRel::~ExtensionLeafRel() { + // @@protoc_insertion_point(destructor:io.substrait.ExtensionLeafRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ExtensionLeafRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete detail_; +} + +void ExtensionLeafRel::ArenaDtor(void* object) { + ExtensionLeafRel* _this = reinterpret_cast< ExtensionLeafRel* >(object); + (void)_this; +} +void ExtensionLeafRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ExtensionLeafRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ExtensionLeafRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ExtensionLeafRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && detail_ != nullptr) { + delete detail_; + } + detail_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ExtensionLeafRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .google.protobuf.Any detail = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ExtensionLeafRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ExtensionLeafRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // .google.protobuf.Any detail = 2; + if (this->has_detail()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::detail(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ExtensionLeafRel) + return target; +} + +size_t ExtensionLeafRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ExtensionLeafRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .google.protobuf.Any detail = 2; + if (this->has_detail()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *detail_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ExtensionLeafRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ExtensionLeafRel) + GOOGLE_DCHECK_NE(&from, this); + const ExtensionLeafRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ExtensionLeafRel) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ExtensionLeafRel) + MergeFrom(*source); + } +} + +void ExtensionLeafRel::MergeFrom(const ExtensionLeafRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ExtensionLeafRel) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_common()) { + _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + } + if (from.has_detail()) { + _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); + } +} + +void ExtensionLeafRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ExtensionLeafRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void ExtensionLeafRel::CopyFrom(const ExtensionLeafRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ExtensionLeafRel) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ExtensionLeafRel::IsInitialized() const { + return true; +} + +void ExtensionLeafRel::InternalSwap(ExtensionLeafRel* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ExtensionLeafRel, detail_) + + sizeof(ExtensionLeafRel::detail_) + - PROTOBUF_FIELD_OFFSET(ExtensionLeafRel, common_)>( + reinterpret_cast(&common_), + reinterpret_cast(&other->common_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata ExtensionLeafRel::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, + file_level_metadata_relations_2eproto[22]); +} + +// =================================================================== + +class ExtensionMultiRel::_Internal { + public: + static const ::io::substrait::RelCommon& common(const ExtensionMultiRel* msg); + static const PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionMultiRel* msg); +}; + +const ::io::substrait::RelCommon& +ExtensionMultiRel::_Internal::common(const ExtensionMultiRel* msg) { + return *msg->common_; +} +const PROTOBUF_NAMESPACE_ID::Any& +ExtensionMultiRel::_Internal::detail(const ExtensionMultiRel* msg) { + return *msg->detail_; +} +void ExtensionMultiRel::clear_detail() { + if (GetArena() == nullptr && detail_ != nullptr) { + delete detail_; + } + detail_ = nullptr; +} +ExtensionMultiRel::ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + inputs_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.ExtensionMultiRel) +} +ExtensionMultiRel::ExtensionMultiRel(const ExtensionMultiRel& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + inputs_(from.inputs_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_common()) { + common_ = new ::io::substrait::RelCommon(*from.common_); + } else { + common_ = nullptr; + } + if (from._internal_has_detail()) { + detail_ = new PROTOBUF_NAMESPACE_ID::Any(*from.detail_); + } else { + detail_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.ExtensionMultiRel) +} + +void ExtensionMultiRel::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&common_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&detail_) - + reinterpret_cast(&common_)) + sizeof(detail_)); +} + +ExtensionMultiRel::~ExtensionMultiRel() { + // @@protoc_insertion_point(destructor:io.substrait.ExtensionMultiRel) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void ExtensionMultiRel::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete detail_; +} + +void ExtensionMultiRel::ArenaDtor(void* object) { + ExtensionMultiRel* _this = reinterpret_cast< ExtensionMultiRel* >(object); + (void)_this; +} +void ExtensionMultiRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void ExtensionMultiRel::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void ExtensionMultiRel::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.ExtensionMultiRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + inputs_.Clear(); + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; + if (GetArena() == nullptr && detail_ != nullptr) { + delete detail_; + } + detail_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* ExtensionMultiRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .io.substrait.RelCommon common = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // repeated .io.substrait.Rel inputs = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_inputs(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); + } else goto handle_unusual; + continue; + // .google.protobuf.Any detail = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* ExtensionMultiRel::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ExtensionMultiRel) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::common(this), target, stream); + } + + // repeated .io.substrait.Rel inputs = 2; + for (unsigned int i = 0, + n = static_cast(this->_internal_inputs_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(2, this->_internal_inputs(i), target, stream); + } + + // .google.protobuf.Any detail = 3; + if (this->has_detail()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::detail(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ExtensionMultiRel) + return target; +} + +size_t ExtensionMultiRel::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.ExtensionMultiRel) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.Rel inputs = 2; + total_size += 1UL * this->_internal_inputs_size(); + for (const auto& msg : this->inputs_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.RelCommon common = 1; + if (this->has_common()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *common_); + } + + // .google.protobuf.Any detail = 3; + if (this->has_detail()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *detail_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void ExtensionMultiRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ExtensionMultiRel) + GOOGLE_DCHECK_NE(&from, this); + const ExtensionMultiRel* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ExtensionMultiRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FilterRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ExtensionMultiRel) MergeFrom(*source); } } -void FilterRel::MergeFrom(const FilterRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FilterRel) +void ExtensionMultiRel::MergeFrom(const ExtensionMultiRel& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ExtensionMultiRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; + inputs_.MergeFrom(from.inputs_); if (from.has_common()) { _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_input()) { - _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); - } - if (from.has_condition()) { - _internal_mutable_condition()->::io::substrait::Expression::MergeFrom(from._internal_condition()); + if (from.has_detail()) { + _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); } } -void FilterRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FilterRel) +void ExtensionMultiRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ExtensionMultiRel) if (&from == this) return; Clear(); MergeFrom(from); } -void FilterRel::CopyFrom(const FilterRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FilterRel) +void ExtensionMultiRel::CopyFrom(const ExtensionMultiRel& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ExtensionMultiRel) if (&from == this) return; Clear(); MergeFrom(from); } -bool FilterRel::IsInitialized() const { +bool ExtensionMultiRel::IsInitialized() const { return true; } -void FilterRel::InternalSwap(FilterRel* other) { +void ExtensionMultiRel::InternalSwap(ExtensionMultiRel* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + inputs_.InternalSwap(&other->inputs_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(FilterRel, condition_) - + sizeof(FilterRel::condition_) - - PROTOBUF_FIELD_OFFSET(FilterRel, common_)>( + PROTOBUF_FIELD_OFFSET(ExtensionMultiRel, detail_) + + sizeof(ExtensionMultiRel::detail_) + - PROTOBUF_FIELD_OFFSET(ExtensionMultiRel, common_)>( reinterpret_cast(&common_), reinterpret_cast(&other->common_)); } -::PROTOBUF_NAMESPACE_ID::Metadata FilterRel::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata ExtensionMultiRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[19]); + file_level_metadata_relations_2eproto[23]); } // =================================================================== -class SetRel::_Internal { +class RelRoot::_Internal { public: - static const ::io::substrait::RelCommon& common(const SetRel* msg); + static const ::io::substrait::Rel& input(const RelRoot* msg); }; -const ::io::substrait::RelCommon& -SetRel::_Internal::common(const SetRel* msg) { - return *msg->common_; +const ::io::substrait::Rel& +RelRoot::_Internal::input(const RelRoot* msg) { + return *msg->input_; } -SetRel::SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) +RelRoot::RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), - inputs_(arena) { + names_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.SetRel) + // @@protoc_insertion_point(arena_constructor:io.substrait.RelRoot) } -SetRel::SetRel(const SetRel& from) +RelRoot::RelRoot(const RelRoot& from) : ::PROTOBUF_NAMESPACE_ID::Message(), - inputs_(from.inputs_) { + names_(from.names_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + if (from._internal_has_input()) { + input_ = new ::io::substrait::Rel(*from.input_); } else { - common_ = nullptr; + input_ = nullptr; } - op_ = from.op_; - // @@protoc_insertion_point(copy_constructor:io.substrait.SetRel) + // @@protoc_insertion_point(copy_constructor:io.substrait.RelRoot) } -void SetRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&op_) - - reinterpret_cast(&common_)) + sizeof(op_)); +void RelRoot::SharedCtor() { +input_ = nullptr; } -SetRel::~SetRel() { - // @@protoc_insertion_point(destructor:io.substrait.SetRel) +RelRoot::~RelRoot() { + // @@protoc_insertion_point(destructor:io.substrait.RelRoot) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void SetRel::SharedDtor() { +void RelRoot::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete common_; + if (this != internal_default_instance()) delete input_; } -void SetRel::ArenaDtor(void* object) { - SetRel* _this = reinterpret_cast< SetRel* >(object); +void RelRoot::ArenaDtor(void* object) { + RelRoot* _this = reinterpret_cast< RelRoot* >(object); (void)_this; } -void SetRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +void RelRoot::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { } -void SetRel::SetCachedSize(int size) const { +void RelRoot::SetCachedSize(int size) const { _cached_size_.Set(size); } -void SetRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.SetRel) +void RelRoot::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.RelRoot) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - inputs_.Clear(); - if (GetArena() == nullptr && common_ != nullptr) { - delete common_; + names_.Clear(); + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; } - common_ = nullptr; - op_ = 0; + input_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +const char* RelRoot::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .io.substrait.Rel input = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); + ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Rel inputs = 2; + // repeated string names = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; do { ptr += 1; - ptr = ctx->ParseMessage(_internal_add_inputs(), ptr); + auto str = _internal_add_names(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.RelRoot.names")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.SetRel.SetOp op = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_op(static_cast<::io::substrait::SetRel_SetOp>(val)); - } else goto handle_unusual; - continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -6265,69 +8311,59 @@ const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::int #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* SetRel::_InternalSerialize( +::PROTOBUF_NAMESPACE_ID::uint8* RelRoot::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.SetRel) + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelRoot) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; - if (this->has_common()) { + // .io.substrait.Rel input = 1; + if (this->has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // repeated .io.substrait.Rel inputs = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_inputs_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_inputs(i), target, stream); + 1, _Internal::input(this), target, stream); } - // .io.substrait.SetRel.SetOp op = 3; - if (this->op() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_op(), target); + // repeated string names = 2; + for (int i = 0, n = this->_internal_names_size(); i < n; i++) { + const auto& s = this->_internal_names(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.RelRoot.names"); + target = stream->WriteString(2, s, target); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.SetRel) + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelRoot) return target; } -size_t SetRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.SetRel) +size_t RelRoot::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelRoot) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Rel inputs = 2; - total_size += 1UL * this->_internal_inputs_size(); - for (const auto& msg : this->inputs_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + // repeated string names = 2; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); + for (int i = 0, n = names_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + names_.Get(i)); } - // .io.substrait.RelCommon common = 1; - if (this->has_common()) { + // .io.substrait.Rel input = 1; + if (this->has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .io.substrait.SetRel.SetOp op = 3; - if (this->op() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op()); + *input_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -6339,71 +8375,63 @@ size_t SetRel::ByteSizeLong() const { return total_size; } -void SetRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.SetRel) +void RelRoot::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelRoot) GOOGLE_DCHECK_NE(&from, this); - const SetRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const RelRoot* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.SetRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelRoot) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.SetRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelRoot) MergeFrom(*source); } } -void SetRel::MergeFrom(const SetRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.SetRel) +void RelRoot::MergeFrom(const RelRoot& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelRoot) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - inputs_.MergeFrom(from.inputs_); - if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from.op() != 0) { - _internal_set_op(from._internal_op()); + names_.MergeFrom(from.names_); + if (from.has_input()) { + _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); } } -void SetRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.SetRel) +void RelRoot::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelRoot) if (&from == this) return; Clear(); MergeFrom(from); } -void SetRel::CopyFrom(const SetRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.SetRel) +void RelRoot::CopyFrom(const RelRoot& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelRoot) if (&from == this) return; Clear(); MergeFrom(from); } -bool SetRel::IsInitialized() const { +bool RelRoot::IsInitialized() const { return true; } -void SetRel::InternalSwap(SetRel* other) { +void RelRoot::InternalSwap(RelRoot* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - inputs_.InternalSwap(&other->inputs_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SetRel, op_) - + sizeof(SetRel::op_) - - PROTOBUF_FIELD_OFFSET(SetRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); + names_.InternalSwap(&other->names_); + swap(input_, other->input_); } -::PROTOBUF_NAMESPACE_ID::Metadata SetRel::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata RelRoot::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[20]); + file_level_metadata_relations_2eproto[24]); } // =================================================================== @@ -6418,6 +8446,9 @@ class Rel::_Internal { static const ::io::substrait::JoinRel& join(const Rel* msg); static const ::io::substrait::ProjectRel& project(const Rel* msg); static const ::io::substrait::SetRel& set(const Rel* msg); + static const ::io::substrait::ExtensionSingleRel& extension_single(const Rel* msg); + static const ::io::substrait::ExtensionMultiRel& extension_multi(const Rel* msg); + static const ::io::substrait::ExtensionLeafRel& extension_leaf(const Rel* msg); }; const ::io::substrait::ReadRel& @@ -6452,6 +8483,18 @@ const ::io::substrait::SetRel& Rel::_Internal::set(const Rel* msg) { return *msg->RelType_.set_; } +const ::io::substrait::ExtensionSingleRel& +Rel::_Internal::extension_single(const Rel* msg) { + return *msg->RelType_.extension_single_; +} +const ::io::substrait::ExtensionMultiRel& +Rel::_Internal::extension_multi(const Rel* msg) { + return *msg->RelType_.extension_multi_; +} +const ::io::substrait::ExtensionLeafRel& +Rel::_Internal::extension_leaf(const Rel* msg) { + return *msg->RelType_.extension_leaf_; +} void Rel::set_allocated_read(::io::substrait::ReadRel* read) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_RelType(); @@ -6572,6 +8615,51 @@ void Rel::set_allocated_set(::io::substrait::SetRel* set) { } // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.set) } +void Rel::set_allocated_extension_single(::io::substrait::ExtensionSingleRel* extension_single) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (extension_single) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_single); + if (message_arena != submessage_arena) { + extension_single = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_single, submessage_arena); + } + set_has_extension_single(); + RelType_.extension_single_ = extension_single; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.extension_single) +} +void Rel::set_allocated_extension_multi(::io::substrait::ExtensionMultiRel* extension_multi) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (extension_multi) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_multi); + if (message_arena != submessage_arena) { + extension_multi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_multi, submessage_arena); + } + set_has_extension_multi(); + RelType_.extension_multi_ = extension_multi; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.extension_multi) +} +void Rel::set_allocated_extension_leaf(::io::substrait::ExtensionLeafRel* extension_leaf) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_RelType(); + if (extension_leaf) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_leaf); + if (message_arena != submessage_arena) { + extension_leaf = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_leaf, submessage_arena); + } + set_has_extension_leaf(); + RelType_.extension_leaf_ = extension_leaf; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.extension_leaf) +} Rel::Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -6615,6 +8703,18 @@ Rel::Rel(const Rel& from) _internal_mutable_set()->::io::substrait::SetRel::MergeFrom(from._internal_set()); break; } + case kExtensionSingle: { + _internal_mutable_extension_single()->::io::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single()); + break; + } + case kExtensionMulti: { + _internal_mutable_extension_multi()->::io::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi()); + break; + } + case kExtensionLeaf: { + _internal_mutable_extension_leaf()->::io::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf()); + break; + } case RELTYPE_NOT_SET: { break; } @@ -6700,6 +8800,24 @@ void Rel::clear_RelType() { } break; } + case kExtensionSingle: { + if (GetArena() == nullptr) { + delete RelType_.extension_single_; + } + break; + } + case kExtensionMulti: { + if (GetArena() == nullptr) { + delete RelType_.extension_multi_; + } + break; + } + case kExtensionLeaf: { + if (GetArena() == nullptr) { + delete RelType_.extension_leaf_; + } + break; + } case RELTYPE_NOT_SET: { break; } @@ -6780,6 +8898,27 @@ const char* Rel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::intern CHK_(ptr); } else goto handle_unusual; continue; + // .io.substrait.ExtensionSingleRel extension_single = 9; + case 9: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_single(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ExtensionMultiRel extension_multi = 10; + case 10: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_multi(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.ExtensionLeafRel extension_leaf = 11; + case 11: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_leaf(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -6873,6 +9012,30 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 8, _Internal::set(this), target, stream); } + // .io.substrait.ExtensionSingleRel extension_single = 9; + if (_internal_has_extension_single()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 9, _Internal::extension_single(this), target, stream); + } + + // .io.substrait.ExtensionMultiRel extension_multi = 10; + if (_internal_has_extension_multi()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 10, _Internal::extension_multi(this), target, stream); + } + + // .io.substrait.ExtensionLeafRel extension_leaf = 11; + if (_internal_has_extension_leaf()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 11, _Internal::extension_leaf(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -6946,6 +9109,27 @@ size_t Rel::ByteSizeLong() const { *RelType_.set_); break; } + // .io.substrait.ExtensionSingleRel extension_single = 9; + case kExtensionSingle: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.extension_single_); + break; + } + // .io.substrait.ExtensionMultiRel extension_multi = 10; + case kExtensionMulti: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.extension_multi_); + break; + } + // .io.substrait.ExtensionLeafRel extension_leaf = 11; + case kExtensionLeaf: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *RelType_.extension_leaf_); + break; + } case RELTYPE_NOT_SET: { break; } @@ -7014,6 +9198,18 @@ void Rel::MergeFrom(const Rel& from) { _internal_mutable_set()->::io::substrait::SetRel::MergeFrom(from._internal_set()); break; } + case kExtensionSingle: { + _internal_mutable_extension_single()->::io::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single()); + break; + } + case kExtensionMulti: { + _internal_mutable_extension_multi()->::io::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi()); + break; + } + case kExtensionLeaf: { + _internal_mutable_extension_leaf()->::io::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf()); + break; + } case RELTYPE_NOT_SET: { break; } @@ -7048,7 +9244,7 @@ void Rel::InternalSwap(Rel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Rel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[21]); + file_level_metadata_relations_2eproto[25]); } // @@protoc_insertion_point(namespace_scope) @@ -7064,15 +9260,12 @@ template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Emit* Arena::CreateMaybe template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Hint_Stats >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Hint_Stats >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Hint_HintKeyValue* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Hint_HintKeyValue >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Hint_HintKeyValue >(arena); +template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Hint_RuntimeConstraint >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Hint_RuntimeConstraint >(arena); } template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Hint* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Hint >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Hint >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_RuntimeConstraint* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_RuntimeConstraint >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::RelCommon_RuntimeConstraint >(arena); -} template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon* Arena::CreateMaybeMessage< ::io::substrait::RelCommon >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::RelCommon >(arena); } @@ -7082,6 +9275,9 @@ template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_NamedTable* Arena::CreateM template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_VirtualTable >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::ReadRel_VirtualTable >(arena); } +template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_ExtensionTable >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ReadRel_ExtensionTable >(arena); +} template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >(arena); } @@ -7118,6 +9314,18 @@ template<> PROTOBUF_NOINLINE ::io::substrait::FilterRel* Arena::CreateMaybeMessa template<> PROTOBUF_NOINLINE ::io::substrait::SetRel* Arena::CreateMaybeMessage< ::io::substrait::SetRel >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::SetRel >(arena); } +template<> PROTOBUF_NOINLINE ::io::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage< ::io::substrait::ExtensionSingleRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ExtensionSingleRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage< ::io::substrait::ExtensionLeafRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ExtensionLeafRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage< ::io::substrait::ExtensionMultiRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::ExtensionMultiRel >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::RelRoot* Arena::CreateMaybeMessage< ::io::substrait::RelRoot >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::RelRoot >(arena); +} template<> PROTOBUF_NOINLINE ::io::substrait::Rel* Arena::CreateMaybeMessage< ::io::substrait::Rel >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Rel >(arena); } diff --git a/cpp/src/generated/substrait/relations.pb.h b/cpp/src/generated/substrait/relations.pb.h index f3bc61b48e9..2f803d7f678 100644 --- a/cpp/src/generated/substrait/relations.pb.h +++ b/cpp/src/generated/substrait/relations.pb.h @@ -34,7 +34,8 @@ #include #include "type.pb.h" #include "expression.pb.h" -#include "selection.pb.h" +#include "extensions.pb.h" +#include // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_relations_2eproto @@ -50,7 +51,7 @@ struct TableStruct_relations_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[22] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[26] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -68,6 +69,15 @@ extern AggregateRel_GroupingDefaultTypeInternal _AggregateRel_Grouping_default_i class AggregateRel_Measure; struct AggregateRel_MeasureDefaultTypeInternal; extern AggregateRel_MeasureDefaultTypeInternal _AggregateRel_Measure_default_instance_; +class ExtensionLeafRel; +struct ExtensionLeafRelDefaultTypeInternal; +extern ExtensionLeafRelDefaultTypeInternal _ExtensionLeafRel_default_instance_; +class ExtensionMultiRel; +struct ExtensionMultiRelDefaultTypeInternal; +extern ExtensionMultiRelDefaultTypeInternal _ExtensionMultiRel_default_instance_; +class ExtensionSingleRel; +struct ExtensionSingleRelDefaultTypeInternal; +extern ExtensionSingleRelDefaultTypeInternal _ExtensionSingleRel_default_instance_; class FetchRel; struct FetchRelDefaultTypeInternal; extern FetchRelDefaultTypeInternal _FetchRel_default_instance_; @@ -83,6 +93,9 @@ extern ProjectRelDefaultTypeInternal _ProjectRel_default_instance_; class ReadRel; struct ReadRelDefaultTypeInternal; extern ReadRelDefaultTypeInternal _ReadRel_default_instance_; +class ReadRel_ExtensionTable; +struct ReadRel_ExtensionTableDefaultTypeInternal; +extern ReadRel_ExtensionTableDefaultTypeInternal _ReadRel_ExtensionTable_default_instance_; class ReadRel_LocalFiles; struct ReadRel_LocalFilesDefaultTypeInternal; extern ReadRel_LocalFilesDefaultTypeInternal _ReadRel_LocalFiles_default_instance_; @@ -110,15 +123,15 @@ extern RelCommon_EmitDefaultTypeInternal _RelCommon_Emit_default_instance_; class RelCommon_Hint; struct RelCommon_HintDefaultTypeInternal; extern RelCommon_HintDefaultTypeInternal _RelCommon_Hint_default_instance_; -class RelCommon_Hint_HintKeyValue; -struct RelCommon_Hint_HintKeyValueDefaultTypeInternal; -extern RelCommon_Hint_HintKeyValueDefaultTypeInternal _RelCommon_Hint_HintKeyValue_default_instance_; +class RelCommon_Hint_RuntimeConstraint; +struct RelCommon_Hint_RuntimeConstraintDefaultTypeInternal; +extern RelCommon_Hint_RuntimeConstraintDefaultTypeInternal _RelCommon_Hint_RuntimeConstraint_default_instance_; class RelCommon_Hint_Stats; struct RelCommon_Hint_StatsDefaultTypeInternal; extern RelCommon_Hint_StatsDefaultTypeInternal _RelCommon_Hint_Stats_default_instance_; -class RelCommon_RuntimeConstraint; -struct RelCommon_RuntimeConstraintDefaultTypeInternal; -extern RelCommon_RuntimeConstraintDefaultTypeInternal _RelCommon_RuntimeConstraint_default_instance_; +class RelRoot; +struct RelRootDefaultTypeInternal; +extern RelRootDefaultTypeInternal _RelRoot_default_instance_; class SetRel; struct SetRelDefaultTypeInternal; extern SetRelDefaultTypeInternal _SetRel_default_instance_; @@ -131,11 +144,15 @@ PROTOBUF_NAMESPACE_OPEN template<> ::io::substrait::AggregateRel* Arena::CreateMaybeMessage<::io::substrait::AggregateRel>(Arena*); template<> ::io::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage<::io::substrait::AggregateRel_Grouping>(Arena*); template<> ::io::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage<::io::substrait::AggregateRel_Measure>(Arena*); +template<> ::io::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage<::io::substrait::ExtensionLeafRel>(Arena*); +template<> ::io::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage<::io::substrait::ExtensionMultiRel>(Arena*); +template<> ::io::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage<::io::substrait::ExtensionSingleRel>(Arena*); template<> ::io::substrait::FetchRel* Arena::CreateMaybeMessage<::io::substrait::FetchRel>(Arena*); template<> ::io::substrait::FilterRel* Arena::CreateMaybeMessage<::io::substrait::FilterRel>(Arena*); template<> ::io::substrait::JoinRel* Arena::CreateMaybeMessage<::io::substrait::JoinRel>(Arena*); template<> ::io::substrait::ProjectRel* Arena::CreateMaybeMessage<::io::substrait::ProjectRel>(Arena*); template<> ::io::substrait::ReadRel* Arena::CreateMaybeMessage<::io::substrait::ReadRel>(Arena*); +template<> ::io::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage<::io::substrait::ReadRel_ExtensionTable>(Arena*); template<> ::io::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage<::io::substrait::ReadRel_LocalFiles>(Arena*); template<> ::io::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage<::io::substrait::ReadRel_LocalFiles_FileOrFiles>(Arena*); template<> ::io::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage<::io::substrait::ReadRel_NamedTable>(Arena*); @@ -145,9 +162,9 @@ template<> ::io::substrait::RelCommon* Arena::CreateMaybeMessage<::io::substrait template<> ::io::substrait::RelCommon_Direct* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Direct>(Arena*); template<> ::io::substrait::RelCommon_Emit* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Emit>(Arena*); template<> ::io::substrait::RelCommon_Hint* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Hint>(Arena*); -template<> ::io::substrait::RelCommon_Hint_HintKeyValue* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Hint_HintKeyValue>(Arena*); +template<> ::io::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Hint_RuntimeConstraint>(Arena*); template<> ::io::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Hint_Stats>(Arena*); -template<> ::io::substrait::RelCommon_RuntimeConstraint* Arena::CreateMaybeMessage<::io::substrait::RelCommon_RuntimeConstraint>(Arena*); +template<> ::io::substrait::RelRoot* Arena::CreateMaybeMessage<::io::substrait::RelRoot>(Arena*); template<> ::io::substrait::SetRel* Arena::CreateMaybeMessage<::io::substrait::SetRel>(Arena*); template<> ::io::substrait::SortRel* Arena::CreateMaybeMessage<::io::substrait::SortRel>(Arena*); PROTOBUF_NAMESPACE_CLOSE @@ -185,12 +202,14 @@ enum JoinRel_JoinType : int { JoinRel_JoinType_OUTER = 2, JoinRel_JoinType_LEFT = 3, JoinRel_JoinType_RIGHT = 4, + JoinRel_JoinType_SEMI = 5, + JoinRel_JoinType_ANTI = 6, JoinRel_JoinType_JoinRel_JoinType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), JoinRel_JoinType_JoinRel_JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool JoinRel_JoinType_IsValid(int value); constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MIN = JoinRel_JoinType_UNKNOWN; -constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MAX = JoinRel_JoinType_RIGHT; +constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MAX = JoinRel_JoinType_ANTI; constexpr int JoinRel_JoinType_JoinType_ARRAYSIZE = JoinRel_JoinType_JoinType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor(); @@ -609,9 +628,28 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { + kAdvancedExtensionFieldNumber = 10, kRowCountFieldNumber = 1, kRecordSizeFieldNumber = 2, }; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + // double row_count = 1; void clear_row_count(); double row_count() const; @@ -637,6 +675,7 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; double row_count_; double record_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; @@ -644,24 +683,24 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class RelCommon_Hint_HintKeyValue PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Hint.HintKeyValue) */ { +class RelCommon_Hint_RuntimeConstraint PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Hint.RuntimeConstraint) */ { public: - inline RelCommon_Hint_HintKeyValue() : RelCommon_Hint_HintKeyValue(nullptr) {} - ~RelCommon_Hint_HintKeyValue() override; - explicit constexpr RelCommon_Hint_HintKeyValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline RelCommon_Hint_RuntimeConstraint() : RelCommon_Hint_RuntimeConstraint(nullptr) {} + ~RelCommon_Hint_RuntimeConstraint() override; + explicit constexpr RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - RelCommon_Hint_HintKeyValue(const RelCommon_Hint_HintKeyValue& from); - RelCommon_Hint_HintKeyValue(RelCommon_Hint_HintKeyValue&& from) noexcept - : RelCommon_Hint_HintKeyValue() { + RelCommon_Hint_RuntimeConstraint(const RelCommon_Hint_RuntimeConstraint& from); + RelCommon_Hint_RuntimeConstraint(RelCommon_Hint_RuntimeConstraint&& from) noexcept + : RelCommon_Hint_RuntimeConstraint() { *this = ::std::move(from); } - inline RelCommon_Hint_HintKeyValue& operator=(const RelCommon_Hint_HintKeyValue& from) { + inline RelCommon_Hint_RuntimeConstraint& operator=(const RelCommon_Hint_RuntimeConstraint& from) { CopyFrom(from); return *this; } - inline RelCommon_Hint_HintKeyValue& operator=(RelCommon_Hint_HintKeyValue&& from) noexcept { + inline RelCommon_Hint_RuntimeConstraint& operator=(RelCommon_Hint_RuntimeConstraint&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -679,20 +718,20 @@ class RelCommon_Hint_HintKeyValue PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const RelCommon_Hint_HintKeyValue& default_instance() { + static const RelCommon_Hint_RuntimeConstraint& default_instance() { return *internal_default_instance(); } - static inline const RelCommon_Hint_HintKeyValue* internal_default_instance() { - return reinterpret_cast( - &_RelCommon_Hint_HintKeyValue_default_instance_); + static inline const RelCommon_Hint_RuntimeConstraint* internal_default_instance() { + return reinterpret_cast( + &_RelCommon_Hint_RuntimeConstraint_default_instance_); } static constexpr int kIndexInFileMessages = 3; - friend void swap(RelCommon_Hint_HintKeyValue& a, RelCommon_Hint_HintKeyValue& b) { + friend void swap(RelCommon_Hint_RuntimeConstraint& a, RelCommon_Hint_RuntimeConstraint& b) { a.Swap(&b); } - inline void Swap(RelCommon_Hint_HintKeyValue* other) { + inline void Swap(RelCommon_Hint_RuntimeConstraint* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -700,7 +739,7 @@ class RelCommon_Hint_HintKeyValue PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(RelCommon_Hint_HintKeyValue* other) { + void UnsafeArenaSwap(RelCommon_Hint_RuntimeConstraint* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -708,17 +747,17 @@ class RelCommon_Hint_HintKeyValue PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline RelCommon_Hint_HintKeyValue* New() const final { - return CreateMaybeMessage(nullptr); + inline RelCommon_Hint_RuntimeConstraint* New() const final { + return CreateMaybeMessage(nullptr); } - RelCommon_Hint_HintKeyValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + RelCommon_Hint_RuntimeConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const RelCommon_Hint_HintKeyValue& from); - void MergeFrom(const RelCommon_Hint_HintKeyValue& from); + void CopyFrom(const RelCommon_Hint_RuntimeConstraint& from); + void MergeFrom(const RelCommon_Hint_RuntimeConstraint& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -732,13 +771,13 @@ class RelCommon_Hint_HintKeyValue PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(RelCommon_Hint_HintKeyValue* other); + void InternalSwap(RelCommon_Hint_RuntimeConstraint* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.RelCommon.Hint.HintKeyValue"; + return "io.substrait.RelCommon.Hint.RuntimeConstraint"; } protected: - explicit RelCommon_Hint_HintKeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -751,46 +790,34 @@ class RelCommon_Hint_HintKeyValue PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kKeyFieldNumber = 1, - kValueFieldNumber = 2, + kAdvancedExtensionFieldNumber = 10, }; - // string key = 1; - void clear_key(); - const std::string& key() const; - template - void set_key(ArgT0&& arg0, ArgT... args); - std::string* mutable_key(); - std::string* release_key(); - void set_allocated_key(std::string* key); + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; private: - const std::string& _internal_key() const; - void _internal_set_key(const std::string& value); - std::string* _internal_mutable_key(); + bool _internal_has_advanced_extension() const; public: - - // bytes value = 2; - void clear_value(); - const std::string& value() const; - template - void set_value(ArgT0&& arg0, ArgT... args); - std::string* mutable_value(); - std::string* release_value(); - void set_allocated_value(std::string* value); + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); private: - const std::string& _internal_value() const; - void _internal_set_value(const std::string& value); - std::string* _internal_mutable_value(); + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Hint.HintKeyValue) + // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Hint.RuntimeConstraint) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; }; @@ -901,33 +928,16 @@ class RelCommon_Hint PROTOBUF_FINAL : // nested types ---------------------------------------------------- typedef RelCommon_Hint_Stats Stats; - typedef RelCommon_Hint_HintKeyValue HintKeyValue; + typedef RelCommon_Hint_RuntimeConstraint RuntimeConstraint; // accessors ------------------------------------------------------- enum : int { - kHintKeyValuesFieldNumber = 1, - kStatsFieldNumber = 2, + kStatsFieldNumber = 1, + kConstraintFieldNumber = 2, + kAdvancedExtensionFieldNumber = 10, }; - // repeated .io.substrait.RelCommon.Hint.HintKeyValue hint_key_values = 1; - int hint_key_values_size() const; - private: - int _internal_hint_key_values_size() const; - public: - void clear_hint_key_values(); - ::io::substrait::RelCommon_Hint_HintKeyValue* mutable_hint_key_values(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::RelCommon_Hint_HintKeyValue >* - mutable_hint_key_values(); - private: - const ::io::substrait::RelCommon_Hint_HintKeyValue& _internal_hint_key_values(int index) const; - ::io::substrait::RelCommon_Hint_HintKeyValue* _internal_add_hint_key_values(); - public: - const ::io::substrait::RelCommon_Hint_HintKeyValue& hint_key_values(int index) const; - ::io::substrait::RelCommon_Hint_HintKeyValue* add_hint_key_values(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::RelCommon_Hint_HintKeyValue >& - hint_key_values() const; - - // .io.substrait.RelCommon.Hint.Stats stats = 2; + // .io.substrait.RelCommon.Hint.Stats stats = 1; bool has_stats() const; private: bool _internal_has_stats() const; @@ -945,133 +955,52 @@ class RelCommon_Hint PROTOBUF_FINAL : ::io::substrait::RelCommon_Hint_Stats* stats); ::io::substrait::RelCommon_Hint_Stats* unsafe_arena_release_stats(); - // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Hint) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::RelCommon_Hint_HintKeyValue > hint_key_values_; - ::io::substrait::RelCommon_Hint_Stats* stats_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; -}; -// ------------------------------------------------------------------- - -class RelCommon_RuntimeConstraint PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.RuntimeConstraint) */ { - public: - inline RelCommon_RuntimeConstraint() : RelCommon_RuntimeConstraint(nullptr) {} - ~RelCommon_RuntimeConstraint() override; - explicit constexpr RelCommon_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - RelCommon_RuntimeConstraint(const RelCommon_RuntimeConstraint& from); - RelCommon_RuntimeConstraint(RelCommon_RuntimeConstraint&& from) noexcept - : RelCommon_RuntimeConstraint() { - *this = ::std::move(from); - } - - inline RelCommon_RuntimeConstraint& operator=(const RelCommon_RuntimeConstraint& from) { - CopyFrom(from); - return *this; - } - inline RelCommon_RuntimeConstraint& operator=(RelCommon_RuntimeConstraint&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 RelCommon_RuntimeConstraint& default_instance() { - return *internal_default_instance(); - } - static inline const RelCommon_RuntimeConstraint* internal_default_instance() { - return reinterpret_cast( - &_RelCommon_RuntimeConstraint_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(RelCommon_RuntimeConstraint& a, RelCommon_RuntimeConstraint& b) { - a.Swap(&b); - } - inline void Swap(RelCommon_RuntimeConstraint* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(RelCommon_RuntimeConstraint* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline RelCommon_RuntimeConstraint* New() const final { - return CreateMaybeMessage(nullptr); - } - - RelCommon_RuntimeConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const RelCommon_RuntimeConstraint& from); - void MergeFrom(const RelCommon_RuntimeConstraint& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - + // .io.substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; + bool has_constraint() const; private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(RelCommon_RuntimeConstraint* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.RelCommon.RuntimeConstraint"; - } - protected: - explicit RelCommon_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena); + bool _internal_has_constraint() const; + public: + void clear_constraint(); + const ::io::substrait::RelCommon_Hint_RuntimeConstraint& constraint() const; + ::io::substrait::RelCommon_Hint_RuntimeConstraint* release_constraint(); + ::io::substrait::RelCommon_Hint_RuntimeConstraint* mutable_constraint(); + void set_allocated_constraint(::io::substrait::RelCommon_Hint_RuntimeConstraint* constraint); private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + const ::io::substrait::RelCommon_Hint_RuntimeConstraint& _internal_constraint() const; + ::io::substrait::RelCommon_Hint_RuntimeConstraint* _internal_mutable_constraint(); public: + void unsafe_arena_set_allocated_constraint( + ::io::substrait::RelCommon_Hint_RuntimeConstraint* constraint); + ::io::substrait::RelCommon_Hint_RuntimeConstraint* unsafe_arena_release_constraint(); - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.RuntimeConstraint) + // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Hint) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; + ::io::substrait::RelCommon_Hint_Stats* stats_; + ::io::substrait::RelCommon_Hint_RuntimeConstraint* constraint_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; }; @@ -1115,10 +1044,10 @@ class RelCommon PROTOBUF_FINAL : static const RelCommon& default_instance() { return *internal_default_instance(); } - enum KindCase { + enum EmitKindCase { kDirect = 1, kEmit = 2, - KIND_NOT_SET = 0, + EMIT_KIND_NOT_SET = 0, }; static inline const RelCommon* internal_default_instance() { @@ -1126,7 +1055,7 @@ class RelCommon PROTOBUF_FINAL : &_RelCommon_default_instance_); } static constexpr int kIndexInFileMessages = - 6; + 5; friend void swap(RelCommon& a, RelCommon& b) { a.Swap(&b); @@ -1190,13 +1119,12 @@ class RelCommon PROTOBUF_FINAL : typedef RelCommon_Direct Direct; typedef RelCommon_Emit Emit; typedef RelCommon_Hint Hint; - typedef RelCommon_RuntimeConstraint RuntimeConstraint; // accessors ------------------------------------------------------- enum : int { kHintFieldNumber = 3, - kConstraintFieldNumber = 4, + kAdvancedExtensionFieldNumber = 4, kDirectFieldNumber = 1, kEmitFieldNumber = 2, }; @@ -1218,23 +1146,23 @@ class RelCommon PROTOBUF_FINAL : ::io::substrait::RelCommon_Hint* hint); ::io::substrait::RelCommon_Hint* unsafe_arena_release_hint(); - // .io.substrait.RelCommon.RuntimeConstraint constraint = 4; - bool has_constraint() const; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 4; + bool has_advanced_extension() const; private: - bool _internal_has_constraint() const; + bool _internal_has_advanced_extension() const; public: - void clear_constraint(); - const ::io::substrait::RelCommon_RuntimeConstraint& constraint() const; - ::io::substrait::RelCommon_RuntimeConstraint* release_constraint(); - ::io::substrait::RelCommon_RuntimeConstraint* mutable_constraint(); - void set_allocated_constraint(::io::substrait::RelCommon_RuntimeConstraint* constraint); + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::RelCommon_RuntimeConstraint& _internal_constraint() const; - ::io::substrait::RelCommon_RuntimeConstraint* _internal_mutable_constraint(); + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: - void unsafe_arena_set_allocated_constraint( - ::io::substrait::RelCommon_RuntimeConstraint* constraint); - ::io::substrait::RelCommon_RuntimeConstraint* unsafe_arena_release_constraint(); + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); // .io.substrait.RelCommon.Direct direct = 1; bool has_direct() const; @@ -1272,28 +1200,28 @@ class RelCommon PROTOBUF_FINAL : ::io::substrait::RelCommon_Emit* emit); ::io::substrait::RelCommon_Emit* unsafe_arena_release_emit(); - void clear_kind(); - KindCase kind_case() const; + void clear_emit_kind(); + EmitKindCase emit_kind_case() const; // @@protoc_insertion_point(class_scope:io.substrait.RelCommon) private: class _Internal; void set_has_direct(); void set_has_emit(); - inline bool has_kind() const; - inline void clear_has_kind(); + inline bool has_emit_kind() const; + inline void clear_has_emit_kind(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::RelCommon_Hint* hint_; - ::io::substrait::RelCommon_RuntimeConstraint* constraint_; - union KindUnion { - constexpr KindUnion() : _constinit_{} {} + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + union EmitKindUnion { + constexpr EmitKindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::io::substrait::RelCommon_Direct* direct_; ::io::substrait::RelCommon_Emit* emit_; - } kind_; + } emit_kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; @@ -1344,7 +1272,7 @@ class ReadRel_NamedTable PROTOBUF_FINAL : &_ReadRel_NamedTable_default_instance_); } static constexpr int kIndexInFileMessages = - 7; + 6; friend void swap(ReadRel_NamedTable& a, ReadRel_NamedTable& b) { a.Swap(&b); @@ -1409,6 +1337,7 @@ class ReadRel_NamedTable PROTOBUF_FINAL : enum : int { kNamesFieldNumber = 1, + kAdvancedExtensionFieldNumber = 10, }; // repeated string names = 1; int names_size() const; @@ -1434,6 +1363,24 @@ class ReadRel_NamedTable PROTOBUF_FINAL : std::string* _internal_add_names(); public: + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.NamedTable) private: class _Internal; @@ -1442,6 +1389,7 @@ class ReadRel_NamedTable PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; }; @@ -1490,7 +1438,7 @@ class ReadRel_VirtualTable PROTOBUF_FINAL : &_ReadRel_VirtualTable_default_instance_); } static constexpr int kIndexInFileMessages = - 8; + 7; friend void swap(ReadRel_VirtualTable& a, ReadRel_VirtualTable& b) { a.Swap(&b); @@ -1587,6 +1535,146 @@ class ReadRel_VirtualTable PROTOBUF_FINAL : }; // ------------------------------------------------------------------- +class ReadRel_ExtensionTable PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.ExtensionTable) */ { + public: + inline ReadRel_ExtensionTable() : ReadRel_ExtensionTable(nullptr) {} + ~ReadRel_ExtensionTable() override; + explicit constexpr ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + ReadRel_ExtensionTable(const ReadRel_ExtensionTable& from); + ReadRel_ExtensionTable(ReadRel_ExtensionTable&& from) noexcept + : ReadRel_ExtensionTable() { + *this = ::std::move(from); + } + + inline ReadRel_ExtensionTable& operator=(const ReadRel_ExtensionTable& from) { + CopyFrom(from); + return *this; + } + inline ReadRel_ExtensionTable& operator=(ReadRel_ExtensionTable&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ReadRel_ExtensionTable& default_instance() { + return *internal_default_instance(); + } + static inline const ReadRel_ExtensionTable* internal_default_instance() { + return reinterpret_cast( + &_ReadRel_ExtensionTable_default_instance_); + } + static constexpr int kIndexInFileMessages = + 8; + + friend void swap(ReadRel_ExtensionTable& a, ReadRel_ExtensionTable& b) { + a.Swap(&b); + } + inline void Swap(ReadRel_ExtensionTable* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ReadRel_ExtensionTable* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ReadRel_ExtensionTable* New() const final { + return CreateMaybeMessage(nullptr); + } + + ReadRel_ExtensionTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ReadRel_ExtensionTable& from); + void MergeFrom(const ReadRel_ExtensionTable& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ReadRel_ExtensionTable* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ReadRel.ExtensionTable"; + } + protected: + explicit ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kDetailFieldNumber = 1, + }; + // .google.protobuf.Any detail = 1; + bool has_detail() const; + private: + bool _internal_has_detail() const; + public: + void clear_detail(); + const PROTOBUF_NAMESPACE_ID::Any& detail() const; + PROTOBUF_NAMESPACE_ID::Any* release_detail(); + PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); + void set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail); + private: + const PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; + PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); + public: + void unsafe_arena_set_allocated_detail( + PROTOBUF_NAMESPACE_ID::Any* detail); + PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); + + // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.ExtensionTable) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + PROTOBUF_NAMESPACE_ID::Any* detail_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.LocalFiles.FileOrFiles) */ { public: @@ -1628,6 +1716,8 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : enum PathTypeCase { kUriPath = 1, kUriPathGlob = 2, + kUriFile = 3, + kUriFolder = 4, PATH_TYPE_NOT_SET = 0, }; @@ -1730,11 +1820,13 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kFormatFieldNumber = 3, + kFormatFieldNumber = 5, kUriPathFieldNumber = 1, kUriPathGlobFieldNumber = 2, + kUriFileFieldNumber = 3, + kUriFolderFieldNumber = 4, }; - // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 3; + // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 5; void clear_format(); ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format format() const; void set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value); @@ -1779,6 +1871,42 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : std::string* _internal_mutable_uri_path_glob(); public: + // string uri_file = 3; + bool has_uri_file() const; + private: + bool _internal_has_uri_file() const; + public: + void clear_uri_file(); + const std::string& uri_file() const; + template + void set_uri_file(ArgT0&& arg0, ArgT... args); + std::string* mutable_uri_file(); + std::string* release_uri_file(); + void set_allocated_uri_file(std::string* uri_file); + private: + const std::string& _internal_uri_file() const; + void _internal_set_uri_file(const std::string& value); + std::string* _internal_mutable_uri_file(); + public: + + // string uri_folder = 4; + bool has_uri_folder() const; + private: + bool _internal_has_uri_folder() const; + public: + void clear_uri_folder(); + const std::string& uri_folder() const; + template + void set_uri_folder(ArgT0&& arg0, ArgT... args); + std::string* mutable_uri_folder(); + std::string* release_uri_folder(); + void set_allocated_uri_folder(std::string* uri_folder); + private: + const std::string& _internal_uri_folder() const; + void _internal_set_uri_folder(const std::string& value); + std::string* _internal_mutable_uri_folder(); + public: + void clear_path_type(); PathTypeCase path_type_case() const; // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.LocalFiles.FileOrFiles) @@ -1786,6 +1914,8 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : class _Internal; void set_has_uri_path(); void set_has_uri_path_glob(); + void set_has_uri_file(); + void set_has_uri_folder(); inline bool has_path_type() const; inline void clear_has_path_type(); @@ -1799,6 +1929,8 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_path_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_path_glob_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_file_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_folder_; } path_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; @@ -1917,6 +2049,7 @@ class ReadRel_LocalFiles PROTOBUF_FINAL : enum : int { kItemsFieldNumber = 1, + kAdvancedExtensionFieldNumber = 10, }; // repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; int items_size() const; @@ -1936,6 +2069,24 @@ class ReadRel_LocalFiles PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >& items() const; + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.LocalFiles) private: class _Internal; @@ -1944,6 +2095,7 @@ class ReadRel_LocalFiles PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles > items_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; }; @@ -1991,6 +2143,7 @@ class ReadRel PROTOBUF_FINAL : kVirtualTable = 5, kLocalFiles = 6, kNamedTable = 7, + kExtensionTable = 8, READ_TYPE_NOT_SET = 0, }; @@ -2062,6 +2215,7 @@ class ReadRel PROTOBUF_FINAL : typedef ReadRel_NamedTable NamedTable; typedef ReadRel_VirtualTable VirtualTable; + typedef ReadRel_ExtensionTable ExtensionTable; typedef ReadRel_LocalFiles LocalFiles; // accessors ------------------------------------------------------- @@ -2071,9 +2225,11 @@ class ReadRel PROTOBUF_FINAL : kBaseSchemaFieldNumber = 2, kFilterFieldNumber = 3, kProjectionFieldNumber = 4, + kAdvancedExtensionFieldNumber = 10, kVirtualTableFieldNumber = 5, kLocalFilesFieldNumber = 6, kNamedTableFieldNumber = 7, + kExtensionTableFieldNumber = 8, }; // .io.substrait.RelCommon common = 1; bool has_common() const; @@ -2093,23 +2249,23 @@ class ReadRel PROTOBUF_FINAL : ::io::substrait::RelCommon* common); ::io::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.Type.NamedStruct base_schema = 2; + // .io.substrait.NamedStruct base_schema = 2; bool has_base_schema() const; private: bool _internal_has_base_schema() const; public: void clear_base_schema(); - const ::io::substrait::Type_NamedStruct& base_schema() const; - ::io::substrait::Type_NamedStruct* release_base_schema(); - ::io::substrait::Type_NamedStruct* mutable_base_schema(); - void set_allocated_base_schema(::io::substrait::Type_NamedStruct* base_schema); + const ::io::substrait::NamedStruct& base_schema() const; + ::io::substrait::NamedStruct* release_base_schema(); + ::io::substrait::NamedStruct* mutable_base_schema(); + void set_allocated_base_schema(::io::substrait::NamedStruct* base_schema); private: - const ::io::substrait::Type_NamedStruct& _internal_base_schema() const; - ::io::substrait::Type_NamedStruct* _internal_mutable_base_schema(); + const ::io::substrait::NamedStruct& _internal_base_schema() const; + ::io::substrait::NamedStruct* _internal_mutable_base_schema(); public: void unsafe_arena_set_allocated_base_schema( - ::io::substrait::Type_NamedStruct* base_schema); - ::io::substrait::Type_NamedStruct* unsafe_arena_release_base_schema(); + ::io::substrait::NamedStruct* base_schema); + ::io::substrait::NamedStruct* unsafe_arena_release_base_schema(); // .io.substrait.Expression filter = 3; bool has_filter() const; @@ -2129,23 +2285,41 @@ class ReadRel PROTOBUF_FINAL : ::io::substrait::Expression* filter); ::io::substrait::Expression* unsafe_arena_release_filter(); - // .io.substrait.MaskExpression projection = 4; + // .io.substrait.Expression.MaskExpression projection = 4; bool has_projection() const; private: bool _internal_has_projection() const; public: void clear_projection(); - const ::io::substrait::MaskExpression& projection() const; - ::io::substrait::MaskExpression* release_projection(); - ::io::substrait::MaskExpression* mutable_projection(); - void set_allocated_projection(::io::substrait::MaskExpression* projection); + const ::io::substrait::Expression_MaskExpression& projection() const; + ::io::substrait::Expression_MaskExpression* release_projection(); + ::io::substrait::Expression_MaskExpression* mutable_projection(); + void set_allocated_projection(::io::substrait::Expression_MaskExpression* projection); private: - const ::io::substrait::MaskExpression& _internal_projection() const; - ::io::substrait::MaskExpression* _internal_mutable_projection(); + const ::io::substrait::Expression_MaskExpression& _internal_projection() const; + ::io::substrait::Expression_MaskExpression* _internal_mutable_projection(); public: void unsafe_arena_set_allocated_projection( - ::io::substrait::MaskExpression* projection); - ::io::substrait::MaskExpression* unsafe_arena_release_projection(); + ::io::substrait::Expression_MaskExpression* projection); + ::io::substrait::Expression_MaskExpression* unsafe_arena_release_projection(); + + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); // .io.substrait.ReadRel.VirtualTable virtual_table = 5; bool has_virtual_table() const; @@ -2201,6 +2375,24 @@ class ReadRel PROTOBUF_FINAL : ::io::substrait::ReadRel_NamedTable* named_table); ::io::substrait::ReadRel_NamedTable* unsafe_arena_release_named_table(); + // .io.substrait.ReadRel.ExtensionTable extension_table = 8; + bool has_extension_table() const; + private: + bool _internal_has_extension_table() const; + public: + void clear_extension_table(); + const ::io::substrait::ReadRel_ExtensionTable& extension_table() const; + ::io::substrait::ReadRel_ExtensionTable* release_extension_table(); + ::io::substrait::ReadRel_ExtensionTable* mutable_extension_table(); + void set_allocated_extension_table(::io::substrait::ReadRel_ExtensionTable* extension_table); + private: + const ::io::substrait::ReadRel_ExtensionTable& _internal_extension_table() const; + ::io::substrait::ReadRel_ExtensionTable* _internal_mutable_extension_table(); + public: + void unsafe_arena_set_allocated_extension_table( + ::io::substrait::ReadRel_ExtensionTable* extension_table); + ::io::substrait::ReadRel_ExtensionTable* unsafe_arena_release_extension_table(); + void clear_read_type(); ReadTypeCase read_type_case() const; // @@protoc_insertion_point(class_scope:io.substrait.ReadRel) @@ -2209,6 +2401,7 @@ class ReadRel PROTOBUF_FINAL : void set_has_virtual_table(); void set_has_local_files(); void set_has_named_table(); + void set_has_extension_table(); inline bool has_read_type() const; inline void clear_has_read_type(); @@ -2217,15 +2410,17 @@ class ReadRel PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::RelCommon* common_; - ::io::substrait::Type_NamedStruct* base_schema_; + ::io::substrait::NamedStruct* base_schema_; ::io::substrait::Expression* filter_; - ::io::substrait::MaskExpression* projection_; + ::io::substrait::Expression_MaskExpression* projection_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; union ReadTypeUnion { constexpr ReadTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::io::substrait::ReadRel_VirtualTable* virtual_table_; ::io::substrait::ReadRel_LocalFiles* local_files_; ::io::substrait::ReadRel_NamedTable* named_table_; + ::io::substrait::ReadRel_ExtensionTable* extension_table_; } read_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; @@ -2344,6 +2539,7 @@ class ProjectRel PROTOBUF_FINAL : kExpressionsFieldNumber = 3, kCommonFieldNumber = 1, kInputFieldNumber = 2, + kAdvancedExtensionFieldNumber = 10, }; // repeated .io.substrait.Expression expressions = 3; int expressions_size() const; @@ -2399,16 +2595,35 @@ class ProjectRel PROTOBUF_FINAL : ::io::substrait::Rel* input); ::io::substrait::Rel* unsafe_arena_release_input(); - // @@protoc_insertion_point(class_scope:io.substrait.ProjectRel) - private: - class _Internal; - + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + + // @@protoc_insertion_point(class_scope:io.substrait.ProjectRel) + private: + class _Internal; + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > expressions_; ::io::substrait::RelCommon* common_; ::io::substrait::Rel* input_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; }; @@ -2529,6 +2744,10 @@ class JoinRel PROTOBUF_FINAL : JoinRel_JoinType_LEFT; static constexpr JoinType RIGHT = JoinRel_JoinType_RIGHT; + static constexpr JoinType SEMI = + JoinRel_JoinType_SEMI; + static constexpr JoinType ANTI = + JoinRel_JoinType_ANTI; static inline bool JoinType_IsValid(int value) { return JoinRel_JoinType_IsValid(value); } @@ -2562,6 +2781,7 @@ class JoinRel PROTOBUF_FINAL : kRightFieldNumber = 3, kExpressionFieldNumber = 4, kPostJoinFilterFieldNumber = 5, + kAdvancedExtensionFieldNumber = 10, kTypeFieldNumber = 6, }; // .io.substrait.RelCommon common = 1; @@ -2654,6 +2874,24 @@ class JoinRel PROTOBUF_FINAL : ::io::substrait::Expression* post_join_filter); ::io::substrait::Expression* unsafe_arena_release_post_join_filter(); + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + // .io.substrait.JoinRel.JoinType type = 6; void clear_type(); ::io::substrait::JoinRel_JoinType type() const; @@ -2675,6 +2913,7 @@ class JoinRel PROTOBUF_FINAL : ::io::substrait::Rel* right_; ::io::substrait::Expression* expression_; ::io::substrait::Expression* post_join_filter_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; int type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; @@ -2790,6 +3029,7 @@ class FetchRel PROTOBUF_FINAL : enum : int { kCommonFieldNumber = 1, kInputFieldNumber = 2, + kAdvancedExtensionFieldNumber = 10, kOffsetFieldNumber = 3, kCountFieldNumber = 4, }; @@ -2829,6 +3069,24 @@ class FetchRel PROTOBUF_FINAL : ::io::substrait::Rel* input); ::io::substrait::Rel* unsafe_arena_release_input(); + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + // int64 offset = 3; void clear_offset(); ::PROTOBUF_NAMESPACE_ID::int64 offset() const; @@ -2856,6 +3114,7 @@ class FetchRel PROTOBUF_FINAL : typedef void DestructorSkippable_; ::io::substrait::RelCommon* common_; ::io::substrait::Rel* input_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; ::PROTOBUF_NAMESPACE_ID::int64 offset_; ::PROTOBUF_NAMESPACE_ID::int64 count_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; @@ -3116,24 +3375,43 @@ class AggregateRel_Measure PROTOBUF_FINAL : enum : int { kMeasureFieldNumber = 1, + kFilterFieldNumber = 2, }; - // .io.substrait.Expression.AggregateFunction measure = 1; + // .io.substrait.AggregateFunction measure = 1; bool has_measure() const; private: bool _internal_has_measure() const; public: void clear_measure(); - const ::io::substrait::Expression_AggregateFunction& measure() const; - ::io::substrait::Expression_AggregateFunction* release_measure(); - ::io::substrait::Expression_AggregateFunction* mutable_measure(); - void set_allocated_measure(::io::substrait::Expression_AggregateFunction* measure); + const ::io::substrait::AggregateFunction& measure() const; + ::io::substrait::AggregateFunction* release_measure(); + ::io::substrait::AggregateFunction* mutable_measure(); + void set_allocated_measure(::io::substrait::AggregateFunction* measure); private: - const ::io::substrait::Expression_AggregateFunction& _internal_measure() const; - ::io::substrait::Expression_AggregateFunction* _internal_mutable_measure(); + const ::io::substrait::AggregateFunction& _internal_measure() const; + ::io::substrait::AggregateFunction* _internal_mutable_measure(); public: void unsafe_arena_set_allocated_measure( - ::io::substrait::Expression_AggregateFunction* measure); - ::io::substrait::Expression_AggregateFunction* unsafe_arena_release_measure(); + ::io::substrait::AggregateFunction* measure); + ::io::substrait::AggregateFunction* unsafe_arena_release_measure(); + + // .io.substrait.Expression filter = 2; + bool has_filter() const; + private: + bool _internal_has_filter() const; + public: + void clear_filter(); + const ::io::substrait::Expression& filter() const; + ::io::substrait::Expression* release_filter(); + ::io::substrait::Expression* mutable_filter(); + void set_allocated_filter(::io::substrait::Expression* filter); + private: + const ::io::substrait::Expression& _internal_filter() const; + ::io::substrait::Expression* _internal_mutable_filter(); + public: + void unsafe_arena_set_allocated_filter( + ::io::substrait::Expression* filter); + ::io::substrait::Expression* unsafe_arena_release_filter(); // @@protoc_insertion_point(class_scope:io.substrait.AggregateRel.Measure) private: @@ -3142,7 +3420,8 @@ class AggregateRel_Measure PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression_AggregateFunction* measure_; + ::io::substrait::AggregateFunction* measure_; + ::io::substrait::Expression* filter_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; }; @@ -3262,7 +3541,7 @@ class AggregateRel PROTOBUF_FINAL : kMeasuresFieldNumber = 4, kCommonFieldNumber = 1, kInputFieldNumber = 2, - kPhaseFieldNumber = 5, + kAdvancedExtensionFieldNumber = 10, }; // repeated .io.substrait.AggregateRel.Grouping groupings = 3; int groupings_size() const; @@ -3336,14 +3615,23 @@ class AggregateRel PROTOBUF_FINAL : ::io::substrait::Rel* input); ::io::substrait::Rel* unsafe_arena_release_input(); - // .io.substrait.Expression.AggregationPhase phase = 5; - void clear_phase(); - ::io::substrait::Expression_AggregationPhase phase() const; - void set_phase(::io::substrait::Expression_AggregationPhase value); + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); private: - ::io::substrait::Expression_AggregationPhase _internal_phase() const; - void _internal_set_phase(::io::substrait::Expression_AggregationPhase value); + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); // @@protoc_insertion_point(class_scope:io.substrait.AggregateRel) private: @@ -3356,7 +3644,7 @@ class AggregateRel PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure > measures_; ::io::substrait::RelCommon* common_; ::io::substrait::Rel* input_; - int phase_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; }; @@ -3472,23 +3760,24 @@ class SortRel PROTOBUF_FINAL : kSortsFieldNumber = 3, kCommonFieldNumber = 1, kInputFieldNumber = 2, + kAdvancedExtensionFieldNumber = 10, }; - // repeated .io.substrait.Expression.SortField sorts = 3; + // repeated .io.substrait.SortField sorts = 3; int sorts_size() const; private: int _internal_sorts_size() const; public: void clear_sorts(); - ::io::substrait::Expression_SortField* mutable_sorts(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* + ::io::substrait::SortField* mutable_sorts(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* mutable_sorts(); private: - const ::io::substrait::Expression_SortField& _internal_sorts(int index) const; - ::io::substrait::Expression_SortField* _internal_add_sorts(); + const ::io::substrait::SortField& _internal_sorts(int index) const; + ::io::substrait::SortField* _internal_add_sorts(); public: - const ::io::substrait::Expression_SortField& sorts(int index) const; - ::io::substrait::Expression_SortField* add_sorts(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& + const ::io::substrait::SortField& sorts(int index) const; + ::io::substrait::SortField* add_sorts(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& sorts() const; // .io.substrait.RelCommon common = 1; @@ -3527,6 +3816,24 @@ class SortRel PROTOBUF_FINAL : ::io::substrait::Rel* input); ::io::substrait::Rel* unsafe_arena_release_input(); + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + // @@protoc_insertion_point(class_scope:io.substrait.SortRel) private: class _Internal; @@ -3534,9 +3841,10 @@ class SortRel PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField > sorts_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField > sorts_; ::io::substrait::RelCommon* common_; ::io::substrait::Rel* input_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; }; @@ -3652,6 +3960,7 @@ class FilterRel PROTOBUF_FINAL : kCommonFieldNumber = 1, kInputFieldNumber = 2, kConditionFieldNumber = 3, + kAdvancedExtensionFieldNumber = 10, }; // .io.substrait.RelCommon common = 1; bool has_common() const; @@ -3707,6 +4016,24 @@ class FilterRel PROTOBUF_FINAL : ::io::substrait::Expression* condition); ::io::substrait::Expression* unsafe_arena_release_condition(); + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + // @@protoc_insertion_point(class_scope:io.substrait.FilterRel) private: class _Internal; @@ -3717,6 +4044,7 @@ class FilterRel PROTOBUF_FINAL : ::io::substrait::RelCommon* common_; ::io::substrait::Rel* input_; ::io::substrait::Expression* condition_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; }; @@ -3871,6 +4199,7 @@ class SetRel PROTOBUF_FINAL : enum : int { kInputsFieldNumber = 2, kCommonFieldNumber = 1, + kAdvancedExtensionFieldNumber = 10, kOpFieldNumber = 3, }; // repeated .io.substrait.Rel inputs = 2; @@ -3909,6 +4238,24 @@ class SetRel PROTOBUF_FINAL : ::io::substrait::RelCommon* common); ::io::substrait::RelCommon* unsafe_arena_release_common(); + // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + bool has_advanced_extension() const; + private: + bool _internal_has_advanced_extension() const; + public: + void clear_advanced_extension(); + const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + private: + const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + public: + void unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension); + ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + // .io.substrait.SetRel.SetOp op = 3; void clear_op(); ::io::substrait::SetRel_SetOp op() const; @@ -3927,30 +4274,31 @@ class SetRel PROTOBUF_FINAL : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel > inputs_; ::io::substrait::RelCommon* common_; + ::io::substrait::extensions::AdvancedExtension* advanced_extension_; int op_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_relations_2eproto; }; // ------------------------------------------------------------------- -class Rel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Rel) */ { +class ExtensionSingleRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ExtensionSingleRel) */ { public: - inline Rel() : Rel(nullptr) {} - ~Rel() override; - explicit constexpr Rel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline ExtensionSingleRel() : ExtensionSingleRel(nullptr) {} + ~ExtensionSingleRel() override; + explicit constexpr ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Rel(const Rel& from); - Rel(Rel&& from) noexcept - : Rel() { + ExtensionSingleRel(const ExtensionSingleRel& from); + ExtensionSingleRel(ExtensionSingleRel&& from) noexcept + : ExtensionSingleRel() { *this = ::std::move(from); } - inline Rel& operator=(const Rel& from) { + inline ExtensionSingleRel& operator=(const ExtensionSingleRel& from) { CopyFrom(from); return *this; } - inline Rel& operator=(Rel&& from) noexcept { + inline ExtensionSingleRel& operator=(ExtensionSingleRel&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -3968,32 +4316,20 @@ class Rel PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Rel& default_instance() { + static const ExtensionSingleRel& default_instance() { return *internal_default_instance(); } - enum RelTypeCase { - kRead = 1, - kFilter = 2, - kFetch = 3, - kAggregate = 4, - kSort = 5, - kJoin = 6, - kProject = 7, - kSet = 8, - RELTYPE_NOT_SET = 0, - }; - - static inline const Rel* internal_default_instance() { - return reinterpret_cast( - &_Rel_default_instance_); + static inline const ExtensionSingleRel* internal_default_instance() { + return reinterpret_cast( + &_ExtensionSingleRel_default_instance_); } static constexpr int kIndexInFileMessages = 21; - friend void swap(Rel& a, Rel& b) { + friend void swap(ExtensionSingleRel& a, ExtensionSingleRel& b) { a.Swap(&b); } - inline void Swap(Rel* other) { + inline void Swap(ExtensionSingleRel* other) { if (other == this) return; if (GetArena() == other->GetArena()) { InternalSwap(other); @@ -4001,7 +4337,7 @@ class Rel PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Rel* other) { + void UnsafeArenaSwap(ExtensionSingleRel* other) { if (other == this) return; GOOGLE_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4009,17 +4345,17 @@ class Rel PROTOBUF_FINAL : // implements Message ---------------------------------------------- - inline Rel* New() const final { - return CreateMaybeMessage(nullptr); + inline ExtensionSingleRel* New() const final { + return CreateMaybeMessage(nullptr); } - Rel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); + ExtensionSingleRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Rel& from); - void MergeFrom(const Rel& from); + void CopyFrom(const ExtensionSingleRel& from); + void MergeFrom(const ExtensionSingleRel& from); PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; @@ -4033,13 +4369,13 @@ class Rel PROTOBUF_FINAL : inline void SharedCtor(); inline void SharedDtor(); void SetCachedSize(int size) const final; - void InternalSwap(Rel* other); + void InternalSwap(ExtensionSingleRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Rel"; + return "io.substrait.ExtensionSingleRel"; } protected: - explicit Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4052,1780 +4388,4549 @@ class Rel PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kReadFieldNumber = 1, - kFilterFieldNumber = 2, - kFetchFieldNumber = 3, - kAggregateFieldNumber = 4, - kSortFieldNumber = 5, - kJoinFieldNumber = 6, - kProjectFieldNumber = 7, - kSetFieldNumber = 8, + kCommonFieldNumber = 1, + kInputFieldNumber = 2, + kDetailFieldNumber = 3, }; - // .io.substrait.ReadRel read = 1; - bool has_read() const; + // .io.substrait.RelCommon common = 1; + bool has_common() const; private: - bool _internal_has_read() const; + bool _internal_has_common() const; public: - void clear_read(); - const ::io::substrait::ReadRel& read() const; - ::io::substrait::ReadRel* release_read(); - ::io::substrait::ReadRel* mutable_read(); - void set_allocated_read(::io::substrait::ReadRel* read); + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); private: - const ::io::substrait::ReadRel& _internal_read() const; - ::io::substrait::ReadRel* _internal_mutable_read(); + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); public: - void unsafe_arena_set_allocated_read( - ::io::substrait::ReadRel* read); - ::io::substrait::ReadRel* unsafe_arena_release_read(); + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.FilterRel filter = 2; - bool has_filter() const; + // .io.substrait.Rel input = 2; + bool has_input() const; private: - bool _internal_has_filter() const; + bool _internal_has_input() const; public: - void clear_filter(); - const ::io::substrait::FilterRel& filter() const; - ::io::substrait::FilterRel* release_filter(); - ::io::substrait::FilterRel* mutable_filter(); - void set_allocated_filter(::io::substrait::FilterRel* filter); + void clear_input(); + const ::io::substrait::Rel& input() const; + ::io::substrait::Rel* release_input(); + ::io::substrait::Rel* mutable_input(); + void set_allocated_input(::io::substrait::Rel* input); private: - const ::io::substrait::FilterRel& _internal_filter() const; - ::io::substrait::FilterRel* _internal_mutable_filter(); + const ::io::substrait::Rel& _internal_input() const; + ::io::substrait::Rel* _internal_mutable_input(); public: - void unsafe_arena_set_allocated_filter( - ::io::substrait::FilterRel* filter); - ::io::substrait::FilterRel* unsafe_arena_release_filter(); + void unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input); + ::io::substrait::Rel* unsafe_arena_release_input(); - // .io.substrait.FetchRel fetch = 3; - bool has_fetch() const; + // .google.protobuf.Any detail = 3; + bool has_detail() const; private: - bool _internal_has_fetch() const; + bool _internal_has_detail() const; public: - void clear_fetch(); - const ::io::substrait::FetchRel& fetch() const; - ::io::substrait::FetchRel* release_fetch(); - ::io::substrait::FetchRel* mutable_fetch(); - void set_allocated_fetch(::io::substrait::FetchRel* fetch); + void clear_detail(); + const PROTOBUF_NAMESPACE_ID::Any& detail() const; + PROTOBUF_NAMESPACE_ID::Any* release_detail(); + PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); + void set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail); private: - const ::io::substrait::FetchRel& _internal_fetch() const; - ::io::substrait::FetchRel* _internal_mutable_fetch(); + const PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; + PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); public: - void unsafe_arena_set_allocated_fetch( - ::io::substrait::FetchRel* fetch); - ::io::substrait::FetchRel* unsafe_arena_release_fetch(); + void unsafe_arena_set_allocated_detail( + PROTOBUF_NAMESPACE_ID::Any* detail); + PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); - // .io.substrait.AggregateRel aggregate = 4; - bool has_aggregate() const; - private: - bool _internal_has_aggregate() const; - public: - void clear_aggregate(); - const ::io::substrait::AggregateRel& aggregate() const; - ::io::substrait::AggregateRel* release_aggregate(); - ::io::substrait::AggregateRel* mutable_aggregate(); - void set_allocated_aggregate(::io::substrait::AggregateRel* aggregate); - private: - const ::io::substrait::AggregateRel& _internal_aggregate() const; - ::io::substrait::AggregateRel* _internal_mutable_aggregate(); - public: - void unsafe_arena_set_allocated_aggregate( - ::io::substrait::AggregateRel* aggregate); - ::io::substrait::AggregateRel* unsafe_arena_release_aggregate(); + // @@protoc_insertion_point(class_scope:io.substrait.ExtensionSingleRel) + private: + class _Internal; - // .io.substrait.SortRel sort = 5; - bool has_sort() const; - private: - bool _internal_has_sort() const; - public: - void clear_sort(); - const ::io::substrait::SortRel& sort() const; - ::io::substrait::SortRel* release_sort(); - ::io::substrait::SortRel* mutable_sort(); - void set_allocated_sort(::io::substrait::SortRel* sort); - private: - const ::io::substrait::SortRel& _internal_sort() const; - ::io::substrait::SortRel* _internal_mutable_sort(); - public: - void unsafe_arena_set_allocated_sort( - ::io::substrait::SortRel* sort); - ::io::substrait::SortRel* unsafe_arena_release_sort(); + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::io::substrait::RelCommon* common_; + ::io::substrait::Rel* input_; + PROTOBUF_NAMESPACE_ID::Any* detail_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- - // .io.substrait.JoinRel join = 6; - bool has_join() const; - private: - bool _internal_has_join() const; - public: - void clear_join(); - const ::io::substrait::JoinRel& join() const; - ::io::substrait::JoinRel* release_join(); - ::io::substrait::JoinRel* mutable_join(); - void set_allocated_join(::io::substrait::JoinRel* join); - private: - const ::io::substrait::JoinRel& _internal_join() const; - ::io::substrait::JoinRel* _internal_mutable_join(); - public: - void unsafe_arena_set_allocated_join( - ::io::substrait::JoinRel* join); - ::io::substrait::JoinRel* unsafe_arena_release_join(); +class ExtensionLeafRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ExtensionLeafRel) */ { + public: + inline ExtensionLeafRel() : ExtensionLeafRel(nullptr) {} + ~ExtensionLeafRel() override; + explicit constexpr ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - // .io.substrait.ProjectRel project = 7; - bool has_project() const; - private: - bool _internal_has_project() const; - public: - void clear_project(); - const ::io::substrait::ProjectRel& project() const; - ::io::substrait::ProjectRel* release_project(); - ::io::substrait::ProjectRel* mutable_project(); - void set_allocated_project(::io::substrait::ProjectRel* project); - private: - const ::io::substrait::ProjectRel& _internal_project() const; - ::io::substrait::ProjectRel* _internal_mutable_project(); - public: - void unsafe_arena_set_allocated_project( - ::io::substrait::ProjectRel* project); - ::io::substrait::ProjectRel* unsafe_arena_release_project(); + ExtensionLeafRel(const ExtensionLeafRel& from); + ExtensionLeafRel(ExtensionLeafRel&& from) noexcept + : ExtensionLeafRel() { + *this = ::std::move(from); + } + + inline ExtensionLeafRel& operator=(const ExtensionLeafRel& from) { + CopyFrom(from); + return *this; + } + inline ExtensionLeafRel& operator=(ExtensionLeafRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ExtensionLeafRel& default_instance() { + return *internal_default_instance(); + } + static inline const ExtensionLeafRel* internal_default_instance() { + return reinterpret_cast( + &_ExtensionLeafRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 22; + + friend void swap(ExtensionLeafRel& a, ExtensionLeafRel& b) { + a.Swap(&b); + } + inline void Swap(ExtensionLeafRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ExtensionLeafRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline ExtensionLeafRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + ExtensionLeafRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ExtensionLeafRel& from); + void MergeFrom(const ExtensionLeafRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } - // .io.substrait.SetRel set = 8; - bool has_set() const; - private: - bool _internal_has_set() const; - public: - void clear_set(); - const ::io::substrait::SetRel& set() const; - ::io::substrait::SetRel* release_set(); - ::io::substrait::SetRel* mutable_set(); - void set_allocated_set(::io::substrait::SetRel* set); private: - const ::io::substrait::SetRel& _internal_set() const; - ::io::substrait::SetRel* _internal_mutable_set(); + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ExtensionLeafRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ExtensionLeafRel"; + } + protected: + explicit ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: - void unsafe_arena_set_allocated_set( - ::io::substrait::SetRel* set); - ::io::substrait::SetRel* unsafe_arena_release_set(); - void clear_RelType(); - RelTypeCase RelType_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Rel) + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kCommonFieldNumber = 1, + kDetailFieldNumber = 2, + }; + // .io.substrait.RelCommon common = 1; + bool has_common() const; + private: + bool _internal_has_common() const; + public: + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); + private: + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); + public: + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); + + // .google.protobuf.Any detail = 2; + bool has_detail() const; + private: + bool _internal_has_detail() const; + public: + void clear_detail(); + const PROTOBUF_NAMESPACE_ID::Any& detail() const; + PROTOBUF_NAMESPACE_ID::Any* release_detail(); + PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); + void set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail); + private: + const PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; + PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); + public: + void unsafe_arena_set_allocated_detail( + PROTOBUF_NAMESPACE_ID::Any* detail); + PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); + + // @@protoc_insertion_point(class_scope:io.substrait.ExtensionLeafRel) private: class _Internal; - void set_has_read(); - void set_has_filter(); - void set_has_fetch(); - void set_has_aggregate(); - void set_has_sort(); - void set_has_join(); - void set_has_project(); - void set_has_set(); - - inline bool has_RelType() const; - inline void clear_has_RelType(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - union RelTypeUnion { - constexpr RelTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::ReadRel* read_; - ::io::substrait::FilterRel* filter_; - ::io::substrait::FetchRel* fetch_; - ::io::substrait::AggregateRel* aggregate_; - ::io::substrait::SortRel* sort_; - ::io::substrait::JoinRel* join_; - ::io::substrait::ProjectRel* project_; - ::io::substrait::SetRel* set_; - } RelType_; + ::io::substrait::RelCommon* common_; + PROTOBUF_NAMESPACE_ID::Any* detail_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_relations_2eproto; }; -// =================================================================== +// ------------------------------------------------------------------- +class ExtensionMultiRel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ExtensionMultiRel) */ { + public: + inline ExtensionMultiRel() : ExtensionMultiRel(nullptr) {} + ~ExtensionMultiRel() override; + explicit constexpr ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); -// =================================================================== + ExtensionMultiRel(const ExtensionMultiRel& from); + ExtensionMultiRel(ExtensionMultiRel&& from) noexcept + : ExtensionMultiRel() { + *this = ::std::move(from); + } -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// RelCommon_Direct + inline ExtensionMultiRel& operator=(const ExtensionMultiRel& from) { + CopyFrom(from); + return *this; + } + inline ExtensionMultiRel& operator=(ExtensionMultiRel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 ExtensionMultiRel& default_instance() { + return *internal_default_instance(); + } + static inline const ExtensionMultiRel* internal_default_instance() { + return reinterpret_cast( + &_ExtensionMultiRel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 23; -// RelCommon_Emit + friend void swap(ExtensionMultiRel& a, ExtensionMultiRel& b) { + a.Swap(&b); + } + inline void Swap(ExtensionMultiRel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ExtensionMultiRel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } -// repeated int32 output_mapping = 1; -inline int RelCommon_Emit::_internal_output_mapping_size() const { - return output_mapping_.size(); -} -inline int RelCommon_Emit::output_mapping_size() const { - return _internal_output_mapping_size(); -} -inline void RelCommon_Emit::clear_output_mapping() { - output_mapping_.Clear(); -} -inline ::PROTOBUF_NAMESPACE_ID::int32 RelCommon_Emit::_internal_output_mapping(int index) const { - return output_mapping_.Get(index); -} -inline ::PROTOBUF_NAMESPACE_ID::int32 RelCommon_Emit::output_mapping(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Emit.output_mapping) - return _internal_output_mapping(index); -} -inline void RelCommon_Emit::set_output_mapping(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { - output_mapping_.Set(index, value); - // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Emit.output_mapping) -} -inline void RelCommon_Emit::_internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value) { - output_mapping_.Add(value); -} -inline void RelCommon_Emit::add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_add_output_mapping(value); - // @@protoc_insertion_point(field_add:io.substrait.RelCommon.Emit.output_mapping) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& -RelCommon_Emit::_internal_output_mapping() const { - return output_mapping_; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& -RelCommon_Emit::output_mapping() const { - // @@protoc_insertion_point(field_list:io.substrait.RelCommon.Emit.output_mapping) - return _internal_output_mapping(); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* -RelCommon_Emit::_internal_mutable_output_mapping() { - return &output_mapping_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* -RelCommon_Emit::mutable_output_mapping() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.RelCommon.Emit.output_mapping) - return _internal_mutable_output_mapping(); + // implements Message ---------------------------------------------- + + inline ExtensionMultiRel* New() const final { + return CreateMaybeMessage(nullptr); + } + + ExtensionMultiRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const ExtensionMultiRel& from); + void MergeFrom(const ExtensionMultiRel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(ExtensionMultiRel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.ExtensionMultiRel"; + } + protected: + explicit ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kInputsFieldNumber = 2, + kCommonFieldNumber = 1, + kDetailFieldNumber = 3, + }; + // repeated .io.substrait.Rel inputs = 2; + int inputs_size() const; + private: + int _internal_inputs_size() const; + public: + void clear_inputs(); + ::io::substrait::Rel* mutable_inputs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* + mutable_inputs(); + private: + const ::io::substrait::Rel& _internal_inputs(int index) const; + ::io::substrait::Rel* _internal_add_inputs(); + public: + const ::io::substrait::Rel& inputs(int index) const; + ::io::substrait::Rel* add_inputs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& + inputs() const; + + // .io.substrait.RelCommon common = 1; + bool has_common() const; + private: + bool _internal_has_common() const; + public: + void clear_common(); + const ::io::substrait::RelCommon& common() const; + ::io::substrait::RelCommon* release_common(); + ::io::substrait::RelCommon* mutable_common(); + void set_allocated_common(::io::substrait::RelCommon* common); + private: + const ::io::substrait::RelCommon& _internal_common() const; + ::io::substrait::RelCommon* _internal_mutable_common(); + public: + void unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common); + ::io::substrait::RelCommon* unsafe_arena_release_common(); + + // .google.protobuf.Any detail = 3; + bool has_detail() const; + private: + bool _internal_has_detail() const; + public: + void clear_detail(); + const PROTOBUF_NAMESPACE_ID::Any& detail() const; + PROTOBUF_NAMESPACE_ID::Any* release_detail(); + PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); + void set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail); + private: + const PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; + PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); + public: + void unsafe_arena_set_allocated_detail( + PROTOBUF_NAMESPACE_ID::Any* detail); + PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); + + // @@protoc_insertion_point(class_scope:io.substrait.ExtensionMultiRel) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel > inputs_; + ::io::substrait::RelCommon* common_; + PROTOBUF_NAMESPACE_ID::Any* detail_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class RelRoot PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelRoot) */ { + public: + inline RelRoot() : RelRoot(nullptr) {} + ~RelRoot() override; + explicit constexpr RelRoot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + RelRoot(const RelRoot& from); + RelRoot(RelRoot&& from) noexcept + : RelRoot() { + *this = ::std::move(from); + } + + inline RelRoot& operator=(const RelRoot& from) { + CopyFrom(from); + return *this; + } + inline RelRoot& operator=(RelRoot&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 RelRoot& default_instance() { + return *internal_default_instance(); + } + static inline const RelRoot* internal_default_instance() { + return reinterpret_cast( + &_RelRoot_default_instance_); + } + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(RelRoot& a, RelRoot& b) { + a.Swap(&b); + } + inline void Swap(RelRoot* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RelRoot* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline RelRoot* New() const final { + return CreateMaybeMessage(nullptr); + } + + RelRoot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const RelRoot& from); + void MergeFrom(const RelRoot& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(RelRoot* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.RelRoot"; + } + protected: + explicit RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNamesFieldNumber = 2, + kInputFieldNumber = 1, + }; + // repeated string names = 2; + int names_size() const; + private: + int _internal_names_size() const; + public: + void clear_names(); + const std::string& names(int index) const; + std::string* mutable_names(int index); + void set_names(int index, const std::string& value); + void set_names(int index, std::string&& value); + void set_names(int index, const char* value); + void set_names(int index, const char* value, size_t size); + std::string* add_names(); + void add_names(const std::string& value); + void add_names(std::string&& value); + void add_names(const char* value); + void add_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); + private: + const std::string& _internal_names(int index) const; + std::string* _internal_add_names(); + public: + + // .io.substrait.Rel input = 1; + bool has_input() const; + private: + bool _internal_has_input() const; + public: + void clear_input(); + const ::io::substrait::Rel& input() const; + ::io::substrait::Rel* release_input(); + ::io::substrait::Rel* mutable_input(); + void set_allocated_input(::io::substrait::Rel* input); + private: + const ::io::substrait::Rel& _internal_input() const; + ::io::substrait::Rel* _internal_mutable_input(); + public: + void unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input); + ::io::substrait::Rel* unsafe_arena_release_input(); + + // @@protoc_insertion_point(class_scope:io.substrait.RelRoot) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; + ::io::substrait::Rel* input_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_relations_2eproto; +}; +// ------------------------------------------------------------------- + +class Rel PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Rel) */ { + public: + inline Rel() : Rel(nullptr) {} + ~Rel() override; + explicit constexpr Rel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + Rel(const Rel& from); + Rel(Rel&& from) noexcept + : Rel() { + *this = ::std::move(from); + } + + inline Rel& operator=(const Rel& from) { + CopyFrom(from); + return *this; + } + inline Rel& operator=(Rel&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 Rel& default_instance() { + return *internal_default_instance(); + } + enum RelTypeCase { + kRead = 1, + kFilter = 2, + kFetch = 3, + kAggregate = 4, + kSort = 5, + kJoin = 6, + kProject = 7, + kSet = 8, + kExtensionSingle = 9, + kExtensionMulti = 10, + kExtensionLeaf = 11, + RELTYPE_NOT_SET = 0, + }; + + static inline const Rel* internal_default_instance() { + return reinterpret_cast( + &_Rel_default_instance_); + } + static constexpr int kIndexInFileMessages = + 25; + + friend void swap(Rel& a, Rel& b) { + a.Swap(&b); + } + inline void Swap(Rel* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Rel* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline Rel* New() const final { + return CreateMaybeMessage(nullptr); + } + + Rel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const Rel& from); + void MergeFrom(const Rel& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(Rel* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.Rel"; + } + protected: + explicit Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kReadFieldNumber = 1, + kFilterFieldNumber = 2, + kFetchFieldNumber = 3, + kAggregateFieldNumber = 4, + kSortFieldNumber = 5, + kJoinFieldNumber = 6, + kProjectFieldNumber = 7, + kSetFieldNumber = 8, + kExtensionSingleFieldNumber = 9, + kExtensionMultiFieldNumber = 10, + kExtensionLeafFieldNumber = 11, + }; + // .io.substrait.ReadRel read = 1; + bool has_read() const; + private: + bool _internal_has_read() const; + public: + void clear_read(); + const ::io::substrait::ReadRel& read() const; + ::io::substrait::ReadRel* release_read(); + ::io::substrait::ReadRel* mutable_read(); + void set_allocated_read(::io::substrait::ReadRel* read); + private: + const ::io::substrait::ReadRel& _internal_read() const; + ::io::substrait::ReadRel* _internal_mutable_read(); + public: + void unsafe_arena_set_allocated_read( + ::io::substrait::ReadRel* read); + ::io::substrait::ReadRel* unsafe_arena_release_read(); + + // .io.substrait.FilterRel filter = 2; + bool has_filter() const; + private: + bool _internal_has_filter() const; + public: + void clear_filter(); + const ::io::substrait::FilterRel& filter() const; + ::io::substrait::FilterRel* release_filter(); + ::io::substrait::FilterRel* mutable_filter(); + void set_allocated_filter(::io::substrait::FilterRel* filter); + private: + const ::io::substrait::FilterRel& _internal_filter() const; + ::io::substrait::FilterRel* _internal_mutable_filter(); + public: + void unsafe_arena_set_allocated_filter( + ::io::substrait::FilterRel* filter); + ::io::substrait::FilterRel* unsafe_arena_release_filter(); + + // .io.substrait.FetchRel fetch = 3; + bool has_fetch() const; + private: + bool _internal_has_fetch() const; + public: + void clear_fetch(); + const ::io::substrait::FetchRel& fetch() const; + ::io::substrait::FetchRel* release_fetch(); + ::io::substrait::FetchRel* mutable_fetch(); + void set_allocated_fetch(::io::substrait::FetchRel* fetch); + private: + const ::io::substrait::FetchRel& _internal_fetch() const; + ::io::substrait::FetchRel* _internal_mutable_fetch(); + public: + void unsafe_arena_set_allocated_fetch( + ::io::substrait::FetchRel* fetch); + ::io::substrait::FetchRel* unsafe_arena_release_fetch(); + + // .io.substrait.AggregateRel aggregate = 4; + bool has_aggregate() const; + private: + bool _internal_has_aggregate() const; + public: + void clear_aggregate(); + const ::io::substrait::AggregateRel& aggregate() const; + ::io::substrait::AggregateRel* release_aggregate(); + ::io::substrait::AggregateRel* mutable_aggregate(); + void set_allocated_aggregate(::io::substrait::AggregateRel* aggregate); + private: + const ::io::substrait::AggregateRel& _internal_aggregate() const; + ::io::substrait::AggregateRel* _internal_mutable_aggregate(); + public: + void unsafe_arena_set_allocated_aggregate( + ::io::substrait::AggregateRel* aggregate); + ::io::substrait::AggregateRel* unsafe_arena_release_aggregate(); + + // .io.substrait.SortRel sort = 5; + bool has_sort() const; + private: + bool _internal_has_sort() const; + public: + void clear_sort(); + const ::io::substrait::SortRel& sort() const; + ::io::substrait::SortRel* release_sort(); + ::io::substrait::SortRel* mutable_sort(); + void set_allocated_sort(::io::substrait::SortRel* sort); + private: + const ::io::substrait::SortRel& _internal_sort() const; + ::io::substrait::SortRel* _internal_mutable_sort(); + public: + void unsafe_arena_set_allocated_sort( + ::io::substrait::SortRel* sort); + ::io::substrait::SortRel* unsafe_arena_release_sort(); + + // .io.substrait.JoinRel join = 6; + bool has_join() const; + private: + bool _internal_has_join() const; + public: + void clear_join(); + const ::io::substrait::JoinRel& join() const; + ::io::substrait::JoinRel* release_join(); + ::io::substrait::JoinRel* mutable_join(); + void set_allocated_join(::io::substrait::JoinRel* join); + private: + const ::io::substrait::JoinRel& _internal_join() const; + ::io::substrait::JoinRel* _internal_mutable_join(); + public: + void unsafe_arena_set_allocated_join( + ::io::substrait::JoinRel* join); + ::io::substrait::JoinRel* unsafe_arena_release_join(); + + // .io.substrait.ProjectRel project = 7; + bool has_project() const; + private: + bool _internal_has_project() const; + public: + void clear_project(); + const ::io::substrait::ProjectRel& project() const; + ::io::substrait::ProjectRel* release_project(); + ::io::substrait::ProjectRel* mutable_project(); + void set_allocated_project(::io::substrait::ProjectRel* project); + private: + const ::io::substrait::ProjectRel& _internal_project() const; + ::io::substrait::ProjectRel* _internal_mutable_project(); + public: + void unsafe_arena_set_allocated_project( + ::io::substrait::ProjectRel* project); + ::io::substrait::ProjectRel* unsafe_arena_release_project(); + + // .io.substrait.SetRel set = 8; + bool has_set() const; + private: + bool _internal_has_set() const; + public: + void clear_set(); + const ::io::substrait::SetRel& set() const; + ::io::substrait::SetRel* release_set(); + ::io::substrait::SetRel* mutable_set(); + void set_allocated_set(::io::substrait::SetRel* set); + private: + const ::io::substrait::SetRel& _internal_set() const; + ::io::substrait::SetRel* _internal_mutable_set(); + public: + void unsafe_arena_set_allocated_set( + ::io::substrait::SetRel* set); + ::io::substrait::SetRel* unsafe_arena_release_set(); + + // .io.substrait.ExtensionSingleRel extension_single = 9; + bool has_extension_single() const; + private: + bool _internal_has_extension_single() const; + public: + void clear_extension_single(); + const ::io::substrait::ExtensionSingleRel& extension_single() const; + ::io::substrait::ExtensionSingleRel* release_extension_single(); + ::io::substrait::ExtensionSingleRel* mutable_extension_single(); + void set_allocated_extension_single(::io::substrait::ExtensionSingleRel* extension_single); + private: + const ::io::substrait::ExtensionSingleRel& _internal_extension_single() const; + ::io::substrait::ExtensionSingleRel* _internal_mutable_extension_single(); + public: + void unsafe_arena_set_allocated_extension_single( + ::io::substrait::ExtensionSingleRel* extension_single); + ::io::substrait::ExtensionSingleRel* unsafe_arena_release_extension_single(); + + // .io.substrait.ExtensionMultiRel extension_multi = 10; + bool has_extension_multi() const; + private: + bool _internal_has_extension_multi() const; + public: + void clear_extension_multi(); + const ::io::substrait::ExtensionMultiRel& extension_multi() const; + ::io::substrait::ExtensionMultiRel* release_extension_multi(); + ::io::substrait::ExtensionMultiRel* mutable_extension_multi(); + void set_allocated_extension_multi(::io::substrait::ExtensionMultiRel* extension_multi); + private: + const ::io::substrait::ExtensionMultiRel& _internal_extension_multi() const; + ::io::substrait::ExtensionMultiRel* _internal_mutable_extension_multi(); + public: + void unsafe_arena_set_allocated_extension_multi( + ::io::substrait::ExtensionMultiRel* extension_multi); + ::io::substrait::ExtensionMultiRel* unsafe_arena_release_extension_multi(); + + // .io.substrait.ExtensionLeafRel extension_leaf = 11; + bool has_extension_leaf() const; + private: + bool _internal_has_extension_leaf() const; + public: + void clear_extension_leaf(); + const ::io::substrait::ExtensionLeafRel& extension_leaf() const; + ::io::substrait::ExtensionLeafRel* release_extension_leaf(); + ::io::substrait::ExtensionLeafRel* mutable_extension_leaf(); + void set_allocated_extension_leaf(::io::substrait::ExtensionLeafRel* extension_leaf); + private: + const ::io::substrait::ExtensionLeafRel& _internal_extension_leaf() const; + ::io::substrait::ExtensionLeafRel* _internal_mutable_extension_leaf(); + public: + void unsafe_arena_set_allocated_extension_leaf( + ::io::substrait::ExtensionLeafRel* extension_leaf); + ::io::substrait::ExtensionLeafRel* unsafe_arena_release_extension_leaf(); + + void clear_RelType(); + RelTypeCase RelType_case() const; + // @@protoc_insertion_point(class_scope:io.substrait.Rel) + private: + class _Internal; + void set_has_read(); + void set_has_filter(); + void set_has_fetch(); + void set_has_aggregate(); + void set_has_sort(); + void set_has_join(); + void set_has_project(); + void set_has_set(); + void set_has_extension_single(); + void set_has_extension_multi(); + void set_has_extension_leaf(); + + inline bool has_RelType() const; + inline void clear_has_RelType(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union RelTypeUnion { + constexpr RelTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::io::substrait::ReadRel* read_; + ::io::substrait::FilterRel* filter_; + ::io::substrait::FetchRel* fetch_; + ::io::substrait::AggregateRel* aggregate_; + ::io::substrait::SortRel* sort_; + ::io::substrait::JoinRel* join_; + ::io::substrait::ProjectRel* project_; + ::io::substrait::SetRel* set_; + ::io::substrait::ExtensionSingleRel* extension_single_; + ::io::substrait::ExtensionMultiRel* extension_multi_; + ::io::substrait::ExtensionLeafRel* extension_leaf_; + } RelType_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_relations_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// RelCommon_Direct + +// ------------------------------------------------------------------- + +// RelCommon_Emit + +// repeated int32 output_mapping = 1; +inline int RelCommon_Emit::_internal_output_mapping_size() const { + return output_mapping_.size(); +} +inline int RelCommon_Emit::output_mapping_size() const { + return _internal_output_mapping_size(); +} +inline void RelCommon_Emit::clear_output_mapping() { + output_mapping_.Clear(); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 RelCommon_Emit::_internal_output_mapping(int index) const { + return output_mapping_.Get(index); +} +inline ::PROTOBUF_NAMESPACE_ID::int32 RelCommon_Emit::output_mapping(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Emit.output_mapping) + return _internal_output_mapping(index); +} +inline void RelCommon_Emit::set_output_mapping(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { + output_mapping_.Set(index, value); + // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Emit.output_mapping) +} +inline void RelCommon_Emit::_internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value) { + output_mapping_.Add(value); +} +inline void RelCommon_Emit::add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_add_output_mapping(value); + // @@protoc_insertion_point(field_add:io.substrait.RelCommon.Emit.output_mapping) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +RelCommon_Emit::_internal_output_mapping() const { + return output_mapping_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +RelCommon_Emit::output_mapping() const { + // @@protoc_insertion_point(field_list:io.substrait.RelCommon.Emit.output_mapping) + return _internal_output_mapping(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +RelCommon_Emit::_internal_mutable_output_mapping() { + return &output_mapping_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +RelCommon_Emit::mutable_output_mapping() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.RelCommon.Emit.output_mapping) + return _internal_mutable_output_mapping(); +} + +// ------------------------------------------------------------------- + +// RelCommon_Hint_Stats + +// double row_count = 1; +inline void RelCommon_Hint_Stats::clear_row_count() { + row_count_ = 0; +} +inline double RelCommon_Hint_Stats::_internal_row_count() const { + return row_count_; +} +inline double RelCommon_Hint_Stats::row_count() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.Stats.row_count) + return _internal_row_count(); +} +inline void RelCommon_Hint_Stats::_internal_set_row_count(double value) { + + row_count_ = value; +} +inline void RelCommon_Hint_Stats::set_row_count(double value) { + _internal_set_row_count(value); + // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.Stats.row_count) +} + +// double record_size = 2; +inline void RelCommon_Hint_Stats::clear_record_size() { + record_size_ = 0; +} +inline double RelCommon_Hint_Stats::_internal_record_size() const { + return record_size_; +} +inline double RelCommon_Hint_Stats::record_size() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.Stats.record_size) + return _internal_record_size(); +} +inline void RelCommon_Hint_Stats::_internal_set_record_size(double value) { + + record_size_ = value; +} +inline void RelCommon_Hint_Stats::set_record_size(double value) { + _internal_set_record_size(value); + // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.Stats.record_size) +} + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool RelCommon_Hint_Stats::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; +} +inline bool RelCommon_Hint_Stats::has_advanced_extension() const { + return _internal_has_advanced_extension(); +} +inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.Stats.advanced_extension) + return _internal_advanced_extension(); +} +inline void RelCommon_Hint_Stats::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + advanced_extension_ = advanced_extension; + if (advanced_extension) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.Stats.advanced_extension) +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::release_advanced_extension() { + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.Stats.advanced_extension) + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::_internal_mutable_advanced_extension() { + + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; + } + return advanced_extension_; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.Stats.advanced_extension) + return _internal_mutable_advanced_extension(); +} +inline void RelCommon_Hint_Stats::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + if (advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + if (message_arena != submessage_arena) { + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); + } + + } else { + + } + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.Stats.advanced_extension) +} + +// ------------------------------------------------------------------- + +// RelCommon_Hint_RuntimeConstraint + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool RelCommon_Hint_RuntimeConstraint::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; +} +inline bool RelCommon_Hint_RuntimeConstraint::has_advanced_extension() const { + return _internal_has_advanced_extension(); +} +inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) + return _internal_advanced_extension(); +} +inline void RelCommon_Hint_RuntimeConstraint::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + advanced_extension_ = advanced_extension; + if (advanced_extension) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::release_advanced_extension() { + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::_internal_mutable_advanced_extension() { + + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; + } + return advanced_extension_; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) + return _internal_mutable_advanced_extension(); +} +inline void RelCommon_Hint_RuntimeConstraint::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + if (advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + if (message_arena != submessage_arena) { + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); + } + + } else { + + } + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) +} + +// ------------------------------------------------------------------- + +// RelCommon_Hint + +// .io.substrait.RelCommon.Hint.Stats stats = 1; +inline bool RelCommon_Hint::_internal_has_stats() const { + return this != internal_default_instance() && stats_ != nullptr; +} +inline bool RelCommon_Hint::has_stats() const { + return _internal_has_stats(); +} +inline void RelCommon_Hint::clear_stats() { + if (GetArena() == nullptr && stats_ != nullptr) { + delete stats_; + } + stats_ = nullptr; +} +inline const ::io::substrait::RelCommon_Hint_Stats& RelCommon_Hint::_internal_stats() const { + const ::io::substrait::RelCommon_Hint_Stats* p = stats_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_Hint_Stats_default_instance_); +} +inline const ::io::substrait::RelCommon_Hint_Stats& RelCommon_Hint::stats() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.stats) + return _internal_stats(); +} +inline void RelCommon_Hint::unsafe_arena_set_allocated_stats( + ::io::substrait::RelCommon_Hint_Stats* stats) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(stats_); + } + stats_ = stats; + if (stats) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.stats) +} +inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::release_stats() { + + ::io::substrait::RelCommon_Hint_Stats* temp = stats_; + stats_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::unsafe_arena_release_stats() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.stats) + + ::io::substrait::RelCommon_Hint_Stats* temp = stats_; + stats_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::_internal_mutable_stats() { + + if (stats_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon_Hint_Stats>(GetArena()); + stats_ = p; + } + return stats_; +} +inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::mutable_stats() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.stats) + return _internal_mutable_stats(); +} +inline void RelCommon_Hint::set_allocated_stats(::io::substrait::RelCommon_Hint_Stats* stats) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete stats_; + } + if (stats) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(stats); + if (message_arena != submessage_arena) { + stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, stats, submessage_arena); + } + + } else { + + } + stats_ = stats; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.stats) +} + +// .io.substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; +inline bool RelCommon_Hint::_internal_has_constraint() const { + return this != internal_default_instance() && constraint_ != nullptr; +} +inline bool RelCommon_Hint::has_constraint() const { + return _internal_has_constraint(); +} +inline void RelCommon_Hint::clear_constraint() { + if (GetArena() == nullptr && constraint_ != nullptr) { + delete constraint_; + } + constraint_ = nullptr; +} +inline const ::io::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::_internal_constraint() const { + const ::io::substrait::RelCommon_Hint_RuntimeConstraint* p = constraint_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_); +} +inline const ::io::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::constraint() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.constraint) + return _internal_constraint(); +} +inline void RelCommon_Hint::unsafe_arena_set_allocated_constraint( + ::io::substrait::RelCommon_Hint_RuntimeConstraint* constraint) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(constraint_); + } + constraint_ = constraint; + if (constraint) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.constraint) +} +inline ::io::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::release_constraint() { + + ::io::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_; + constraint_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::unsafe_arena_release_constraint() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.constraint) + + ::io::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_; + constraint_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::_internal_mutable_constraint() { + + if (constraint_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon_Hint_RuntimeConstraint>(GetArena()); + constraint_ = p; + } + return constraint_; +} +inline ::io::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::mutable_constraint() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.constraint) + return _internal_mutable_constraint(); +} +inline void RelCommon_Hint::set_allocated_constraint(::io::substrait::RelCommon_Hint_RuntimeConstraint* constraint) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete constraint_; + } + if (constraint) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(constraint); + if (message_arena != submessage_arena) { + constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, constraint, submessage_arena); + } + + } else { + + } + constraint_ = constraint; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.constraint) +} + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool RelCommon_Hint::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; +} +inline bool RelCommon_Hint::has_advanced_extension() const { + return _internal_has_advanced_extension(); +} +inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.advanced_extension) + return _internal_advanced_extension(); +} +inline void RelCommon_Hint::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + advanced_extension_ = advanced_extension; + if (advanced_extension) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.advanced_extension) +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint::release_advanced_extension() { + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.advanced_extension) + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint::_internal_mutable_advanced_extension() { + + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; + } + return advanced_extension_; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.advanced_extension) + return _internal_mutable_advanced_extension(); +} +inline void RelCommon_Hint::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + if (advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + if (message_arena != submessage_arena) { + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); + } + + } else { + + } + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.advanced_extension) +} + +// ------------------------------------------------------------------- + +// RelCommon + +// .io.substrait.RelCommon.Direct direct = 1; +inline bool RelCommon::_internal_has_direct() const { + return emit_kind_case() == kDirect; +} +inline bool RelCommon::has_direct() const { + return _internal_has_direct(); +} +inline void RelCommon::set_has_direct() { + _oneof_case_[0] = kDirect; +} +inline void RelCommon::clear_direct() { + if (_internal_has_direct()) { + if (GetArena() == nullptr) { + delete emit_kind_.direct_; + } + clear_has_emit_kind(); + } +} +inline ::io::substrait::RelCommon_Direct* RelCommon::release_direct() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.direct) + if (_internal_has_direct()) { + clear_has_emit_kind(); + ::io::substrait::RelCommon_Direct* temp = emit_kind_.direct_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + emit_kind_.direct_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::RelCommon_Direct& RelCommon::_internal_direct() const { + return _internal_has_direct() + ? *emit_kind_.direct_ + : reinterpret_cast< ::io::substrait::RelCommon_Direct&>(::io::substrait::_RelCommon_Direct_default_instance_); +} +inline const ::io::substrait::RelCommon_Direct& RelCommon::direct() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.direct) + return _internal_direct(); +} +inline ::io::substrait::RelCommon_Direct* RelCommon::unsafe_arena_release_direct() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.RelCommon.direct) + if (_internal_has_direct()) { + clear_has_emit_kind(); + ::io::substrait::RelCommon_Direct* temp = emit_kind_.direct_; + emit_kind_.direct_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void RelCommon::unsafe_arena_set_allocated_direct(::io::substrait::RelCommon_Direct* direct) { + clear_emit_kind(); + if (direct) { + set_has_direct(); + emit_kind_.direct_ = direct; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.direct) +} +inline ::io::substrait::RelCommon_Direct* RelCommon::_internal_mutable_direct() { + if (!_internal_has_direct()) { + clear_emit_kind(); + set_has_direct(); + emit_kind_.direct_ = CreateMaybeMessage< ::io::substrait::RelCommon_Direct >(GetArena()); + } + return emit_kind_.direct_; +} +inline ::io::substrait::RelCommon_Direct* RelCommon::mutable_direct() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.direct) + return _internal_mutable_direct(); +} + +// .io.substrait.RelCommon.Emit emit = 2; +inline bool RelCommon::_internal_has_emit() const { + return emit_kind_case() == kEmit; +} +inline bool RelCommon::has_emit() const { + return _internal_has_emit(); +} +inline void RelCommon::set_has_emit() { + _oneof_case_[0] = kEmit; +} +inline void RelCommon::clear_emit() { + if (_internal_has_emit()) { + if (GetArena() == nullptr) { + delete emit_kind_.emit_; + } + clear_has_emit_kind(); + } +} +inline ::io::substrait::RelCommon_Emit* RelCommon::release_emit() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.emit) + if (_internal_has_emit()) { + clear_has_emit_kind(); + ::io::substrait::RelCommon_Emit* temp = emit_kind_.emit_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + emit_kind_.emit_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::RelCommon_Emit& RelCommon::_internal_emit() const { + return _internal_has_emit() + ? *emit_kind_.emit_ + : reinterpret_cast< ::io::substrait::RelCommon_Emit&>(::io::substrait::_RelCommon_Emit_default_instance_); +} +inline const ::io::substrait::RelCommon_Emit& RelCommon::emit() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.emit) + return _internal_emit(); +} +inline ::io::substrait::RelCommon_Emit* RelCommon::unsafe_arena_release_emit() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.RelCommon.emit) + if (_internal_has_emit()) { + clear_has_emit_kind(); + ::io::substrait::RelCommon_Emit* temp = emit_kind_.emit_; + emit_kind_.emit_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void RelCommon::unsafe_arena_set_allocated_emit(::io::substrait::RelCommon_Emit* emit) { + clear_emit_kind(); + if (emit) { + set_has_emit(); + emit_kind_.emit_ = emit; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.emit) +} +inline ::io::substrait::RelCommon_Emit* RelCommon::_internal_mutable_emit() { + if (!_internal_has_emit()) { + clear_emit_kind(); + set_has_emit(); + emit_kind_.emit_ = CreateMaybeMessage< ::io::substrait::RelCommon_Emit >(GetArena()); + } + return emit_kind_.emit_; +} +inline ::io::substrait::RelCommon_Emit* RelCommon::mutable_emit() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.emit) + return _internal_mutable_emit(); +} + +// .io.substrait.RelCommon.Hint hint = 3; +inline bool RelCommon::_internal_has_hint() const { + return this != internal_default_instance() && hint_ != nullptr; +} +inline bool RelCommon::has_hint() const { + return _internal_has_hint(); +} +inline void RelCommon::clear_hint() { + if (GetArena() == nullptr && hint_ != nullptr) { + delete hint_; + } + hint_ = nullptr; +} +inline const ::io::substrait::RelCommon_Hint& RelCommon::_internal_hint() const { + const ::io::substrait::RelCommon_Hint* p = hint_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_Hint_default_instance_); +} +inline const ::io::substrait::RelCommon_Hint& RelCommon::hint() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.hint) + return _internal_hint(); +} +inline void RelCommon::unsafe_arena_set_allocated_hint( + ::io::substrait::RelCommon_Hint* hint) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hint_); + } + hint_ = hint; + if (hint) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.hint) +} +inline ::io::substrait::RelCommon_Hint* RelCommon::release_hint() { + + ::io::substrait::RelCommon_Hint* temp = hint_; + hint_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon_Hint* RelCommon::unsafe_arena_release_hint() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.hint) + + ::io::substrait::RelCommon_Hint* temp = hint_; + hint_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon_Hint* RelCommon::_internal_mutable_hint() { + + if (hint_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon_Hint>(GetArena()); + hint_ = p; + } + return hint_; +} +inline ::io::substrait::RelCommon_Hint* RelCommon::mutable_hint() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.hint) + return _internal_mutable_hint(); +} +inline void RelCommon::set_allocated_hint(::io::substrait::RelCommon_Hint* hint) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete hint_; + } + if (hint) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(hint); + if (message_arena != submessage_arena) { + hint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, hint, submessage_arena); + } + + } else { + + } + hint_ = hint; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.hint) +} + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 4; +inline bool RelCommon::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; +} +inline bool RelCommon::has_advanced_extension() const { + return _internal_has_advanced_extension(); +} +inline const ::io::substrait::extensions::AdvancedExtension& RelCommon::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& RelCommon::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.RelCommon.advanced_extension) + return _internal_advanced_extension(); +} +inline void RelCommon::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + advanced_extension_ = advanced_extension; + if (advanced_extension) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.advanced_extension) +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon::release_advanced_extension() { + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.RelCommon.advanced_extension) + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon::_internal_mutable_advanced_extension() { + + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; + } + return advanced_extension_; +} +inline ::io::substrait::extensions::AdvancedExtension* RelCommon::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.advanced_extension) + return _internal_mutable_advanced_extension(); +} +inline void RelCommon::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + if (advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + if (message_arena != submessage_arena) { + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); + } + + } else { + + } + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.advanced_extension) +} + +inline bool RelCommon::has_emit_kind() const { + return emit_kind_case() != EMIT_KIND_NOT_SET; +} +inline void RelCommon::clear_has_emit_kind() { + _oneof_case_[0] = EMIT_KIND_NOT_SET; +} +inline RelCommon::EmitKindCase RelCommon::emit_kind_case() const { + return RelCommon::EmitKindCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// ReadRel_NamedTable + +// repeated string names = 1; +inline int ReadRel_NamedTable::_internal_names_size() const { + return names_.size(); +} +inline int ReadRel_NamedTable::names_size() const { + return _internal_names_size(); +} +inline void ReadRel_NamedTable::clear_names() { + names_.Clear(); +} +inline std::string* ReadRel_NamedTable::add_names() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.ReadRel.NamedTable.names) + return _internal_add_names(); +} +inline const std::string& ReadRel_NamedTable::_internal_names(int index) const { + return names_.Get(index); +} +inline const std::string& ReadRel_NamedTable::names(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.NamedTable.names) + return _internal_names(index); +} +inline std::string* ReadRel_NamedTable::mutable_names(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.NamedTable.names) + return names_.Mutable(index); +} +inline void ReadRel_NamedTable::set_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.NamedTable.names) + names_.Mutable(index)->assign(value); +} +inline void ReadRel_NamedTable::set_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.NamedTable.names) + names_.Mutable(index)->assign(std::move(value)); +} +inline void ReadRel_NamedTable::set_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.ReadRel.NamedTable.names) +} +inline void ReadRel_NamedTable::set_names(int index, const char* value, size_t size) { + names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.ReadRel.NamedTable.names) +} +inline std::string* ReadRel_NamedTable::_internal_add_names() { + return names_.Add(); +} +inline void ReadRel_NamedTable::add_names(const std::string& value) { + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.ReadRel.NamedTable.names) +} +inline void ReadRel_NamedTable::add_names(std::string&& value) { + names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.ReadRel.NamedTable.names) +} +inline void ReadRel_NamedTable::add_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.ReadRel.NamedTable.names) +} +inline void ReadRel_NamedTable::add_names(const char* value, size_t size) { + names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.ReadRel.NamedTable.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +ReadRel_NamedTable::names() const { + // @@protoc_insertion_point(field_list:io.substrait.ReadRel.NamedTable.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +ReadRel_NamedTable::mutable_names() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.NamedTable.names) + return &names_; +} + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool ReadRel_NamedTable::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; +} +inline bool ReadRel_NamedTable::has_advanced_extension() const { + return _internal_has_advanced_extension(); +} +inline const ::io::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.NamedTable.advanced_extension) + return _internal_advanced_extension(); +} +inline void ReadRel_NamedTable::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + advanced_extension_ = advanced_extension; + if (advanced_extension) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.NamedTable.advanced_extension) +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::release_advanced_extension() { + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.NamedTable.advanced_extension) + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::_internal_mutable_advanced_extension() { + + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; + } + return advanced_extension_; +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.NamedTable.advanced_extension) + return _internal_mutable_advanced_extension(); +} +inline void ReadRel_NamedTable::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + if (advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + if (message_arena != submessage_arena) { + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); + } + + } else { + + } + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.NamedTable.advanced_extension) +} + +// ------------------------------------------------------------------- + +// ReadRel_VirtualTable + +// repeated .io.substrait.Expression.Literal.Struct values = 1; +inline int ReadRel_VirtualTable::_internal_values_size() const { + return values_.size(); +} +inline int ReadRel_VirtualTable::values_size() const { + return _internal_values_size(); +} +inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::mutable_values(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.VirtualTable.values) + return values_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >* +ReadRel_VirtualTable::mutable_values() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.VirtualTable.values) + return &values_; +} +inline const ::io::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::_internal_values(int index) const { + return values_.Get(index); +} +inline const ::io::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::values(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.VirtualTable.values) + return _internal_values(index); +} +inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::_internal_add_values() { + return values_.Add(); +} +inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::add_values() { + // @@protoc_insertion_point(field_add:io.substrait.ReadRel.VirtualTable.values) + return _internal_add_values(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >& +ReadRel_VirtualTable::values() const { + // @@protoc_insertion_point(field_list:io.substrait.ReadRel.VirtualTable.values) + return values_; +} + +// ------------------------------------------------------------------- + +// ReadRel_ExtensionTable + +// .google.protobuf.Any detail = 1; +inline bool ReadRel_ExtensionTable::_internal_has_detail() const { + return this != internal_default_instance() && detail_ != nullptr; +} +inline bool ReadRel_ExtensionTable::has_detail() const { + return _internal_has_detail(); +} +inline const PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::_internal_detail() const { + const PROTOBUF_NAMESPACE_ID::Any* p = detail_; + return p != nullptr ? *p : reinterpret_cast( + PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +} +inline const PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::detail() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.ExtensionTable.detail) + return _internal_detail(); +} +inline void ReadRel_ExtensionTable::unsafe_arena_set_allocated_detail( + PROTOBUF_NAMESPACE_ID::Any* detail) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); + } + detail_ = detail; + if (detail) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.ExtensionTable.detail) +} +inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::release_detail() { + + PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + detail_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::unsafe_arena_release_detail() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.ExtensionTable.detail) + + PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + detail_ = nullptr; + return temp; +} +inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::_internal_mutable_detail() { + + if (detail_ == nullptr) { + auto* p = CreateMaybeMessage(GetArena()); + detail_ = p; + } + return detail_; +} +inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::mutable_detail() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.ExtensionTable.detail) + return _internal_mutable_detail(); +} +inline void ReadRel_ExtensionTable::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); + } + if (detail) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)->GetArena(); + if (message_arena != submessage_arena) { + detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, detail, submessage_arena); + } + + } else { + + } + detail_ = detail; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.ExtensionTable.detail) +} + +// ------------------------------------------------------------------- + +// ReadRel_LocalFiles_FileOrFiles + +// string uri_path = 1; +inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_path() const { + return path_type_case() == kUriPath; +} +inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_path() const { + return _internal_has_uri_path(); +} +inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path() { + _oneof_case_[0] = kUriPath; +} +inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path() { + if (_internal_has_uri_path()) { + path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_path_type(); + } +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + return _internal_uri_path(); +} +template +inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_uri_path()) { + clear_path_type(); + set_has_uri_path(); + path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + return _internal_mutable_uri_path(); +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path() const { + if (_internal_has_uri_path()) { + return path_type_.uri_path_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path(const std::string& value) { + if (!_internal_has_uri_path()) { + clear_path_type(); + set_has_uri_path(); + path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path() { + if (!_internal_has_uri_path()) { + clear_path_type(); + set_has_uri_path(); + path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return path_type_.uri_path_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + if (_internal_has_uri_path()) { + clear_has_path_type(); + return path_type_.uri_path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path(std::string* uri_path) { + if (has_path_type()) { + clear_path_type(); + } + if (uri_path != nullptr) { + set_has_uri_path(); + path_type_.uri_path_.UnsafeSetDefault(uri_path); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(uri_path); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) +} + +// string uri_path_glob = 2; +inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_path_glob() const { + return path_type_case() == kUriPathGlob; +} +inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_path_glob() const { + return _internal_has_uri_path_glob(); +} +inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path_glob() { + _oneof_case_[0] = kUriPathGlob; +} +inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path_glob() { + if (_internal_has_uri_path_glob()) { + path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_path_type(); + } +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path_glob() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + return _internal_uri_path_glob(); +} +template +inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path_glob(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_uri_path_glob()) { + clear_path_type(); + set_has_uri_path_glob(); + path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path_glob() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + return _internal_mutable_uri_path_glob(); +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path_glob() const { + if (_internal_has_uri_path_glob()) { + return path_type_.uri_path_glob_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path_glob(const std::string& value) { + if (!_internal_has_uri_path_glob()) { + clear_path_type(); + set_has_uri_path_glob(); + path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path_glob() { + if (!_internal_has_uri_path_glob()) { + clear_path_type(); + set_has_uri_path_glob(); + path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return path_type_.uri_path_glob_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path_glob() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + if (_internal_has_uri_path_glob()) { + clear_has_path_type(); + return path_type_.uri_path_glob_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path_glob(std::string* uri_path_glob) { + if (has_path_type()) { + clear_path_type(); + } + if (uri_path_glob != nullptr) { + set_has_uri_path_glob(); + path_type_.uri_path_glob_.UnsafeSetDefault(uri_path_glob); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(uri_path_glob); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) +} + +// string uri_file = 3; +inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_file() const { + return path_type_case() == kUriFile; +} +inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_file() const { + return _internal_has_uri_file(); +} +inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_file() { + _oneof_case_[0] = kUriFile; +} +inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_file() { + if (_internal_has_uri_file()) { + path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_path_type(); + } +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_file() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) + return _internal_uri_file(); +} +template +inline void ReadRel_LocalFiles_FileOrFiles::set_uri_file(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_uri_file()) { + clear_path_type(); + set_has_uri_file(); + path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_file() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) + return _internal_mutable_uri_file(); +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_file() const { + if (_internal_has_uri_file()) { + return path_type_.uri_file_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_file(const std::string& value) { + if (!_internal_has_uri_file()) { + clear_path_type(); + set_has_uri_file(); + path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_file() { + if (!_internal_has_uri_file()) { + clear_path_type(); + set_has_uri_file(); + path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return path_type_.uri_file_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_file() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) + if (_internal_has_uri_file()) { + clear_has_path_type(); + return path_type_.uri_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_file(std::string* uri_file) { + if (has_path_type()) { + clear_path_type(); + } + if (uri_file != nullptr) { + set_has_uri_file(); + path_type_.uri_file_.UnsafeSetDefault(uri_file); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(uri_file); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) +} + +// string uri_folder = 4; +inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_folder() const { + return path_type_case() == kUriFolder; +} +inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_folder() const { + return _internal_has_uri_folder(); +} +inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_folder() { + _oneof_case_[0] = kUriFolder; +} +inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_folder() { + if (_internal_has_uri_folder()) { + path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + clear_has_path_type(); + } +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_folder() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) + return _internal_uri_folder(); +} +template +inline void ReadRel_LocalFiles_FileOrFiles::set_uri_folder(ArgT0&& arg0, ArgT... args) { + if (!_internal_has_uri_folder()) { + clear_path_type(); + set_has_uri_folder(); + path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_folder() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) + return _internal_mutable_uri_folder(); +} +inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_folder() const { + if (_internal_has_uri_folder()) { + return path_type_.uri_folder_.Get(); + } + return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_folder(const std::string& value) { + if (!_internal_has_uri_folder()) { + clear_path_type(); + set_has_uri_folder(); + path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_folder() { + if (!_internal_has_uri_folder()) { + clear_path_type(); + set_has_uri_folder(); + path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + } + return path_type_.uri_folder_.Mutable( + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_folder() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) + if (_internal_has_uri_folder()) { + clear_has_path_type(); + return path_type_.uri_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + } else { + return nullptr; + } +} +inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_folder(std::string* uri_folder) { + if (has_path_type()) { + clear_path_type(); + } + if (uri_folder != nullptr) { + set_has_uri_folder(); + path_type_.uri_folder_.UnsafeSetDefault(uri_folder); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + if (arena != nullptr) { + arena->Own(uri_folder); + } + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) +} + +// .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 5; +inline void ReadRel_LocalFiles_FileOrFiles::clear_format() { + format_ = 0; +} +inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::_internal_format() const { + return static_cast< ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format >(format_); +} +inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::format() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.format) + return _internal_format(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value) { + + format_ = value; +} +inline void ReadRel_LocalFiles_FileOrFiles::set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value) { + _internal_set_format(value); + // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.format) +} + +inline bool ReadRel_LocalFiles_FileOrFiles::has_path_type() const { + return path_type_case() != PATH_TYPE_NOT_SET; +} +inline void ReadRel_LocalFiles_FileOrFiles::clear_has_path_type() { + _oneof_case_[0] = PATH_TYPE_NOT_SET; +} +inline ReadRel_LocalFiles_FileOrFiles::PathTypeCase ReadRel_LocalFiles_FileOrFiles::path_type_case() const { + return ReadRel_LocalFiles_FileOrFiles::PathTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// ReadRel_LocalFiles + +// repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; +inline int ReadRel_LocalFiles::_internal_items_size() const { + return items_.size(); +} +inline int ReadRel_LocalFiles::items_size() const { + return _internal_items_size(); +} +inline void ReadRel_LocalFiles::clear_items() { + items_.Clear(); +} +inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::mutable_items(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.items) + return items_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >* +ReadRel_LocalFiles::mutable_items() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.LocalFiles.items) + return &items_; +} +inline const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::_internal_items(int index) const { + return items_.Get(index); +} +inline const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::items(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.items) + return _internal_items(index); +} +inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::_internal_add_items() { + return items_.Add(); +} +inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::add_items() { + // @@protoc_insertion_point(field_add:io.substrait.ReadRel.LocalFiles.items) + return _internal_add_items(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >& +ReadRel_LocalFiles::items() const { + // @@protoc_insertion_point(field_list:io.substrait.ReadRel.LocalFiles.items) + return items_; +} + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool ReadRel_LocalFiles::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; +} +inline bool ReadRel_LocalFiles::has_advanced_extension() const { + return _internal_has_advanced_extension(); +} +inline const ::io::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.advanced_extension) + return _internal_advanced_extension(); +} +inline void ReadRel_LocalFiles::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + advanced_extension_ = advanced_extension; + if (advanced_extension) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.LocalFiles.advanced_extension) +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::release_advanced_extension() { + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.advanced_extension) + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::_internal_mutable_advanced_extension() { + + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; + } + return advanced_extension_; +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.advanced_extension) + return _internal_mutable_advanced_extension(); +} +inline void ReadRel_LocalFiles::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + if (advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + if (message_arena != submessage_arena) { + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); + } + + } else { + + } + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.advanced_extension) +} + +// ------------------------------------------------------------------- + +// ReadRel + +// .io.substrait.RelCommon common = 1; +inline bool ReadRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; +} +inline bool ReadRel::has_common() const { + return _internal_has_common(); +} +inline void ReadRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; +} +inline const ::io::substrait::RelCommon& ReadRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); +} +inline const ::io::substrait::RelCommon& ReadRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.common) + return _internal_common(); +} +inline void ReadRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + } + common_ = common; + if (common) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.common) +} +inline ::io::substrait::RelCommon* ReadRel::release_common() { + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::RelCommon* ReadRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.common) + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; + return temp; +} +inline ::io::substrait::RelCommon* ReadRel::_internal_mutable_common() { + + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; + } + return common_; +} +inline ::io::substrait::RelCommon* ReadRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.common) + return _internal_mutable_common(); +} +inline void ReadRel::set_allocated_common(::io::substrait::RelCommon* common) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete common_; + } + if (common) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + if (message_arena != submessage_arena) { + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); + } + + } else { + + } + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.common) +} + +// .io.substrait.NamedStruct base_schema = 2; +inline bool ReadRel::_internal_has_base_schema() const { + return this != internal_default_instance() && base_schema_ != nullptr; +} +inline bool ReadRel::has_base_schema() const { + return _internal_has_base_schema(); +} +inline const ::io::substrait::NamedStruct& ReadRel::_internal_base_schema() const { + const ::io::substrait::NamedStruct* p = base_schema_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_NamedStruct_default_instance_); +} +inline const ::io::substrait::NamedStruct& ReadRel::base_schema() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.base_schema) + return _internal_base_schema(); +} +inline void ReadRel::unsafe_arena_set_allocated_base_schema( + ::io::substrait::NamedStruct* base_schema) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); + } + base_schema_ = base_schema; + if (base_schema) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.base_schema) +} +inline ::io::substrait::NamedStruct* ReadRel::release_base_schema() { + + ::io::substrait::NamedStruct* temp = base_schema_; + base_schema_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::NamedStruct* ReadRel::unsafe_arena_release_base_schema() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.base_schema) + + ::io::substrait::NamedStruct* temp = base_schema_; + base_schema_ = nullptr; + return temp; +} +inline ::io::substrait::NamedStruct* ReadRel::_internal_mutable_base_schema() { + + if (base_schema_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::NamedStruct>(GetArena()); + base_schema_ = p; + } + return base_schema_; +} +inline ::io::substrait::NamedStruct* ReadRel::mutable_base_schema() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.base_schema) + return _internal_mutable_base_schema(); +} +inline void ReadRel::set_allocated_base_schema(::io::substrait::NamedStruct* base_schema) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); + } + if (base_schema) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema)->GetArena(); + if (message_arena != submessage_arena) { + base_schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, base_schema, submessage_arena); + } + + } else { + + } + base_schema_ = base_schema; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.base_schema) +} + +// .io.substrait.Expression filter = 3; +inline bool ReadRel::_internal_has_filter() const { + return this != internal_default_instance() && filter_ != nullptr; +} +inline bool ReadRel::has_filter() const { + return _internal_has_filter(); +} +inline const ::io::substrait::Expression& ReadRel::_internal_filter() const { + const ::io::substrait::Expression* p = filter_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); +} +inline const ::io::substrait::Expression& ReadRel::filter() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.filter) + return _internal_filter(); +} +inline void ReadRel::unsafe_arena_set_allocated_filter( + ::io::substrait::Expression* filter) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); + } + filter_ = filter; + if (filter) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.filter) +} +inline ::io::substrait::Expression* ReadRel::release_filter() { + + ::io::substrait::Expression* temp = filter_; + filter_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression* ReadRel::unsafe_arena_release_filter() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.filter) + + ::io::substrait::Expression* temp = filter_; + filter_ = nullptr; + return temp; +} +inline ::io::substrait::Expression* ReadRel::_internal_mutable_filter() { + + if (filter_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + filter_ = p; + } + return filter_; +} +inline ::io::substrait::Expression* ReadRel::mutable_filter() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.filter) + return _internal_mutable_filter(); +} +inline void ReadRel::set_allocated_filter(::io::substrait::Expression* filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); + } + if (filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter)->GetArena(); + if (message_arena != submessage_arena) { + filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, filter, submessage_arena); + } + + } else { + + } + filter_ = filter; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.filter) +} + +// .io.substrait.Expression.MaskExpression projection = 4; +inline bool ReadRel::_internal_has_projection() const { + return this != internal_default_instance() && projection_ != nullptr; +} +inline bool ReadRel::has_projection() const { + return _internal_has_projection(); +} +inline const ::io::substrait::Expression_MaskExpression& ReadRel::_internal_projection() const { + const ::io::substrait::Expression_MaskExpression* p = projection_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_MaskExpression_default_instance_); +} +inline const ::io::substrait::Expression_MaskExpression& ReadRel::projection() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.projection) + return _internal_projection(); +} +inline void ReadRel::unsafe_arena_set_allocated_projection( + ::io::substrait::Expression_MaskExpression* projection) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); + } + projection_ = projection; + if (projection) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.projection) +} +inline ::io::substrait::Expression_MaskExpression* ReadRel::release_projection() { + + ::io::substrait::Expression_MaskExpression* temp = projection_; + projection_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Expression_MaskExpression* ReadRel::unsafe_arena_release_projection() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.projection) + + ::io::substrait::Expression_MaskExpression* temp = projection_; + projection_ = nullptr; + return temp; +} +inline ::io::substrait::Expression_MaskExpression* ReadRel::_internal_mutable_projection() { + + if (projection_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression_MaskExpression>(GetArena()); + projection_ = p; + } + return projection_; +} +inline ::io::substrait::Expression_MaskExpression* ReadRel::mutable_projection() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.projection) + return _internal_mutable_projection(); +} +inline void ReadRel::set_allocated_projection(::io::substrait::Expression_MaskExpression* projection) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); + } + if (projection) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection)->GetArena(); + if (message_arena != submessage_arena) { + projection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, projection, submessage_arena); + } + + } else { + + } + projection_ = projection; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.projection) +} + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool ReadRel::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; +} +inline bool ReadRel::has_advanced_extension() const { + return _internal_has_advanced_extension(); +} +inline const ::io::substrait::extensions::AdvancedExtension& ReadRel::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& ReadRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.advanced_extension) + return _internal_advanced_extension(); +} +inline void ReadRel::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + advanced_extension_ = advanced_extension; + if (advanced_extension) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.advanced_extension) +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel::release_advanced_extension() { + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.advanced_extension) + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; + return temp; +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel::_internal_mutable_advanced_extension() { + + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; + } + return advanced_extension_; +} +inline ::io::substrait::extensions::AdvancedExtension* ReadRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.advanced_extension) + return _internal_mutable_advanced_extension(); +} +inline void ReadRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); + } + if (advanced_extension) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + if (message_arena != submessage_arena) { + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); + } + + } else { + + } + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.advanced_extension) +} + +// .io.substrait.ReadRel.VirtualTable virtual_table = 5; +inline bool ReadRel::_internal_has_virtual_table() const { + return read_type_case() == kVirtualTable; +} +inline bool ReadRel::has_virtual_table() const { + return _internal_has_virtual_table(); +} +inline void ReadRel::set_has_virtual_table() { + _oneof_case_[0] = kVirtualTable; +} +inline void ReadRel::clear_virtual_table() { + if (_internal_has_virtual_table()) { + if (GetArena() == nullptr) { + delete read_type_.virtual_table_; + } + clear_has_read_type(); + } +} +inline ::io::substrait::ReadRel_VirtualTable* ReadRel::release_virtual_table() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.virtual_table) + if (_internal_has_virtual_table()) { + clear_has_read_type(); + ::io::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + read_type_.virtual_table_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ReadRel_VirtualTable& ReadRel::_internal_virtual_table() const { + return _internal_has_virtual_table() + ? *read_type_.virtual_table_ + : reinterpret_cast< ::io::substrait::ReadRel_VirtualTable&>(::io::substrait::_ReadRel_VirtualTable_default_instance_); +} +inline const ::io::substrait::ReadRel_VirtualTable& ReadRel::virtual_table() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.virtual_table) + return _internal_virtual_table(); +} +inline ::io::substrait::ReadRel_VirtualTable* ReadRel::unsafe_arena_release_virtual_table() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.virtual_table) + if (_internal_has_virtual_table()) { + clear_has_read_type(); + ::io::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; + read_type_.virtual_table_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ReadRel::unsafe_arena_set_allocated_virtual_table(::io::substrait::ReadRel_VirtualTable* virtual_table) { + clear_read_type(); + if (virtual_table) { + set_has_virtual_table(); + read_type_.virtual_table_ = virtual_table; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.virtual_table) +} +inline ::io::substrait::ReadRel_VirtualTable* ReadRel::_internal_mutable_virtual_table() { + if (!_internal_has_virtual_table()) { + clear_read_type(); + set_has_virtual_table(); + read_type_.virtual_table_ = CreateMaybeMessage< ::io::substrait::ReadRel_VirtualTable >(GetArena()); + } + return read_type_.virtual_table_; +} +inline ::io::substrait::ReadRel_VirtualTable* ReadRel::mutable_virtual_table() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.virtual_table) + return _internal_mutable_virtual_table(); } -// ------------------------------------------------------------------- - -// RelCommon_Hint_Stats - -// double row_count = 1; -inline void RelCommon_Hint_Stats::clear_row_count() { - row_count_ = 0; +// .io.substrait.ReadRel.LocalFiles local_files = 6; +inline bool ReadRel::_internal_has_local_files() const { + return read_type_case() == kLocalFiles; } -inline double RelCommon_Hint_Stats::_internal_row_count() const { - return row_count_; +inline bool ReadRel::has_local_files() const { + return _internal_has_local_files(); } -inline double RelCommon_Hint_Stats::row_count() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.Stats.row_count) - return _internal_row_count(); +inline void ReadRel::set_has_local_files() { + _oneof_case_[0] = kLocalFiles; } -inline void RelCommon_Hint_Stats::_internal_set_row_count(double value) { - - row_count_ = value; +inline void ReadRel::clear_local_files() { + if (_internal_has_local_files()) { + if (GetArena() == nullptr) { + delete read_type_.local_files_; + } + clear_has_read_type(); + } } -inline void RelCommon_Hint_Stats::set_row_count(double value) { - _internal_set_row_count(value); - // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.Stats.row_count) +inline ::io::substrait::ReadRel_LocalFiles* ReadRel::release_local_files() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.local_files) + if (_internal_has_local_files()) { + clear_has_read_type(); + ::io::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + read_type_.local_files_ = nullptr; + return temp; + } else { + return nullptr; + } } - -// double record_size = 2; -inline void RelCommon_Hint_Stats::clear_record_size() { - record_size_ = 0; +inline const ::io::substrait::ReadRel_LocalFiles& ReadRel::_internal_local_files() const { + return _internal_has_local_files() + ? *read_type_.local_files_ + : reinterpret_cast< ::io::substrait::ReadRel_LocalFiles&>(::io::substrait::_ReadRel_LocalFiles_default_instance_); } -inline double RelCommon_Hint_Stats::_internal_record_size() const { - return record_size_; +inline const ::io::substrait::ReadRel_LocalFiles& ReadRel::local_files() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.local_files) + return _internal_local_files(); } -inline double RelCommon_Hint_Stats::record_size() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.Stats.record_size) - return _internal_record_size(); +inline ::io::substrait::ReadRel_LocalFiles* ReadRel::unsafe_arena_release_local_files() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.local_files) + if (_internal_has_local_files()) { + clear_has_read_type(); + ::io::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; + read_type_.local_files_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline void RelCommon_Hint_Stats::_internal_set_record_size(double value) { - - record_size_ = value; +inline void ReadRel::unsafe_arena_set_allocated_local_files(::io::substrait::ReadRel_LocalFiles* local_files) { + clear_read_type(); + if (local_files) { + set_has_local_files(); + read_type_.local_files_ = local_files; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.local_files) } -inline void RelCommon_Hint_Stats::set_record_size(double value) { - _internal_set_record_size(value); - // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.Stats.record_size) +inline ::io::substrait::ReadRel_LocalFiles* ReadRel::_internal_mutable_local_files() { + if (!_internal_has_local_files()) { + clear_read_type(); + set_has_local_files(); + read_type_.local_files_ = CreateMaybeMessage< ::io::substrait::ReadRel_LocalFiles >(GetArena()); + } + return read_type_.local_files_; } - -// ------------------------------------------------------------------- - -// RelCommon_Hint_HintKeyValue - -// string key = 1; -inline void RelCommon_Hint_HintKeyValue::clear_key() { - key_.ClearToEmpty(); +inline ::io::substrait::ReadRel_LocalFiles* ReadRel::mutable_local_files() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.local_files) + return _internal_mutable_local_files(); } -inline const std::string& RelCommon_Hint_HintKeyValue::key() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.HintKeyValue.key) - return _internal_key(); + +// .io.substrait.ReadRel.NamedTable named_table = 7; +inline bool ReadRel::_internal_has_named_table() const { + return read_type_case() == kNamedTable; } -template -PROTOBUF_ALWAYS_INLINE -inline void RelCommon_Hint_HintKeyValue::set_key(ArgT0&& arg0, ArgT... args) { - - key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.HintKeyValue.key) +inline bool ReadRel::has_named_table() const { + return _internal_has_named_table(); } -inline std::string* RelCommon_Hint_HintKeyValue::mutable_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.HintKeyValue.key) - return _internal_mutable_key(); +inline void ReadRel::set_has_named_table() { + _oneof_case_[0] = kNamedTable; } -inline const std::string& RelCommon_Hint_HintKeyValue::_internal_key() const { - return key_.Get(); +inline void ReadRel::clear_named_table() { + if (_internal_has_named_table()) { + if (GetArena() == nullptr) { + delete read_type_.named_table_; + } + clear_has_read_type(); + } } -inline void RelCommon_Hint_HintKeyValue::_internal_set_key(const std::string& value) { - - key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline ::io::substrait::ReadRel_NamedTable* ReadRel::release_named_table() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.named_table) + if (_internal_has_named_table()) { + clear_has_read_type(); + ::io::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + read_type_.named_table_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline std::string* RelCommon_Hint_HintKeyValue::_internal_mutable_key() { - - return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline const ::io::substrait::ReadRel_NamedTable& ReadRel::_internal_named_table() const { + return _internal_has_named_table() + ? *read_type_.named_table_ + : reinterpret_cast< ::io::substrait::ReadRel_NamedTable&>(::io::substrait::_ReadRel_NamedTable_default_instance_); } -inline std::string* RelCommon_Hint_HintKeyValue::release_key() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.HintKeyValue.key) - return key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline const ::io::substrait::ReadRel_NamedTable& ReadRel::named_table() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.named_table) + return _internal_named_table(); } -inline void RelCommon_Hint_HintKeyValue::set_allocated_key(std::string* key) { - if (key != nullptr) { - +inline ::io::substrait::ReadRel_NamedTable* ReadRel::unsafe_arena_release_named_table() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.named_table) + if (_internal_has_named_table()) { + clear_has_read_type(); + ::io::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; + read_type_.named_table_ = nullptr; + return temp; } else { - + return nullptr; } - key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.HintKeyValue.key) } - -// bytes value = 2; -inline void RelCommon_Hint_HintKeyValue::clear_value() { - value_.ClearToEmpty(); -} -inline const std::string& RelCommon_Hint_HintKeyValue::value() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.HintKeyValue.value) - return _internal_value(); +inline void ReadRel::unsafe_arena_set_allocated_named_table(::io::substrait::ReadRel_NamedTable* named_table) { + clear_read_type(); + if (named_table) { + set_has_named_table(); + read_type_.named_table_ = named_table; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.named_table) } -template -PROTOBUF_ALWAYS_INLINE -inline void RelCommon_Hint_HintKeyValue::set_value(ArgT0&& arg0, ArgT... args) { - - value_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.HintKeyValue.value) +inline ::io::substrait::ReadRel_NamedTable* ReadRel::_internal_mutable_named_table() { + if (!_internal_has_named_table()) { + clear_read_type(); + set_has_named_table(); + read_type_.named_table_ = CreateMaybeMessage< ::io::substrait::ReadRel_NamedTable >(GetArena()); + } + return read_type_.named_table_; } -inline std::string* RelCommon_Hint_HintKeyValue::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.HintKeyValue.value) - return _internal_mutable_value(); +inline ::io::substrait::ReadRel_NamedTable* ReadRel::mutable_named_table() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.named_table) + return _internal_mutable_named_table(); } -inline const std::string& RelCommon_Hint_HintKeyValue::_internal_value() const { - return value_.Get(); + +// .io.substrait.ReadRel.ExtensionTable extension_table = 8; +inline bool ReadRel::_internal_has_extension_table() const { + return read_type_case() == kExtensionTable; } -inline void RelCommon_Hint_HintKeyValue::_internal_set_value(const std::string& value) { - - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +inline bool ReadRel::has_extension_table() const { + return _internal_has_extension_table(); } -inline std::string* RelCommon_Hint_HintKeyValue::_internal_mutable_value() { - - return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline void ReadRel::set_has_extension_table() { + _oneof_case_[0] = kExtensionTable; } -inline std::string* RelCommon_Hint_HintKeyValue::release_value() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.HintKeyValue.value) - return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +inline void ReadRel::clear_extension_table() { + if (_internal_has_extension_table()) { + if (GetArena() == nullptr) { + delete read_type_.extension_table_; + } + clear_has_read_type(); + } } -inline void RelCommon_Hint_HintKeyValue::set_allocated_value(std::string* value) { - if (value != nullptr) { - +inline ::io::substrait::ReadRel_ExtensionTable* ReadRel::release_extension_table() { + // @@protoc_insertion_point(field_release:io.substrait.ReadRel.extension_table) + if (_internal_has_extension_table()) { + clear_has_read_type(); + ::io::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + read_type_.extension_table_ = nullptr; + return temp; } else { - + return nullptr; } - value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.HintKeyValue.value) -} - -// ------------------------------------------------------------------- - -// RelCommon_Hint - -// repeated .io.substrait.RelCommon.Hint.HintKeyValue hint_key_values = 1; -inline int RelCommon_Hint::_internal_hint_key_values_size() const { - return hint_key_values_.size(); } -inline int RelCommon_Hint::hint_key_values_size() const { - return _internal_hint_key_values_size(); +inline const ::io::substrait::ReadRel_ExtensionTable& ReadRel::_internal_extension_table() const { + return _internal_has_extension_table() + ? *read_type_.extension_table_ + : reinterpret_cast< ::io::substrait::ReadRel_ExtensionTable&>(::io::substrait::_ReadRel_ExtensionTable_default_instance_); } -inline void RelCommon_Hint::clear_hint_key_values() { - hint_key_values_.Clear(); +inline const ::io::substrait::ReadRel_ExtensionTable& ReadRel::extension_table() const { + // @@protoc_insertion_point(field_get:io.substrait.ReadRel.extension_table) + return _internal_extension_table(); } -inline ::io::substrait::RelCommon_Hint_HintKeyValue* RelCommon_Hint::mutable_hint_key_values(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.hint_key_values) - return hint_key_values_.Mutable(index); +inline ::io::substrait::ReadRel_ExtensionTable* ReadRel::unsafe_arena_release_extension_table() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.extension_table) + if (_internal_has_extension_table()) { + clear_has_read_type(); + ::io::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_; + read_type_.extension_table_ = nullptr; + return temp; + } else { + return nullptr; + } } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::RelCommon_Hint_HintKeyValue >* -RelCommon_Hint::mutable_hint_key_values() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.RelCommon.Hint.hint_key_values) - return &hint_key_values_; +inline void ReadRel::unsafe_arena_set_allocated_extension_table(::io::substrait::ReadRel_ExtensionTable* extension_table) { + clear_read_type(); + if (extension_table) { + set_has_extension_table(); + read_type_.extension_table_ = extension_table; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.extension_table) } -inline const ::io::substrait::RelCommon_Hint_HintKeyValue& RelCommon_Hint::_internal_hint_key_values(int index) const { - return hint_key_values_.Get(index); +inline ::io::substrait::ReadRel_ExtensionTable* ReadRel::_internal_mutable_extension_table() { + if (!_internal_has_extension_table()) { + clear_read_type(); + set_has_extension_table(); + read_type_.extension_table_ = CreateMaybeMessage< ::io::substrait::ReadRel_ExtensionTable >(GetArena()); + } + return read_type_.extension_table_; } -inline const ::io::substrait::RelCommon_Hint_HintKeyValue& RelCommon_Hint::hint_key_values(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.hint_key_values) - return _internal_hint_key_values(index); +inline ::io::substrait::ReadRel_ExtensionTable* ReadRel::mutable_extension_table() { + // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.extension_table) + return _internal_mutable_extension_table(); } -inline ::io::substrait::RelCommon_Hint_HintKeyValue* RelCommon_Hint::_internal_add_hint_key_values() { - return hint_key_values_.Add(); + +inline bool ReadRel::has_read_type() const { + return read_type_case() != READ_TYPE_NOT_SET; } -inline ::io::substrait::RelCommon_Hint_HintKeyValue* RelCommon_Hint::add_hint_key_values() { - // @@protoc_insertion_point(field_add:io.substrait.RelCommon.Hint.hint_key_values) - return _internal_add_hint_key_values(); +inline void ReadRel::clear_has_read_type() { + _oneof_case_[0] = READ_TYPE_NOT_SET; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::RelCommon_Hint_HintKeyValue >& -RelCommon_Hint::hint_key_values() const { - // @@protoc_insertion_point(field_list:io.substrait.RelCommon.Hint.hint_key_values) - return hint_key_values_; +inline ReadRel::ReadTypeCase ReadRel::read_type_case() const { + return ReadRel::ReadTypeCase(_oneof_case_[0]); } +// ------------------------------------------------------------------- -// .io.substrait.RelCommon.Hint.Stats stats = 2; -inline bool RelCommon_Hint::_internal_has_stats() const { - return this != internal_default_instance() && stats_ != nullptr; +// ProjectRel + +// .io.substrait.RelCommon common = 1; +inline bool ProjectRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; } -inline bool RelCommon_Hint::has_stats() const { - return _internal_has_stats(); +inline bool ProjectRel::has_common() const { + return _internal_has_common(); } -inline void RelCommon_Hint::clear_stats() { - if (GetArena() == nullptr && stats_ != nullptr) { - delete stats_; +inline void ProjectRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; } - stats_ = nullptr; + common_ = nullptr; } -inline const ::io::substrait::RelCommon_Hint_Stats& RelCommon_Hint::_internal_stats() const { - const ::io::substrait::RelCommon_Hint_Stats* p = stats_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_Hint_Stats_default_instance_); +inline const ::io::substrait::RelCommon& ProjectRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon_Hint_Stats& RelCommon_Hint::stats() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.stats) - return _internal_stats(); +inline const ::io::substrait::RelCommon& ProjectRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.common) + return _internal_common(); } -inline void RelCommon_Hint::unsafe_arena_set_allocated_stats( - ::io::substrait::RelCommon_Hint_Stats* stats) { +inline void ProjectRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(stats_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } - stats_ = stats; - if (stats) { + common_ = common; + if (common) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.stats) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ProjectRel.common) } -inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::release_stats() { - - ::io::substrait::RelCommon_Hint_Stats* temp = stats_; - stats_ = nullptr; +inline ::io::substrait::RelCommon* ProjectRel::release_common() { + + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::unsafe_arena_release_stats() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.stats) +inline ::io::substrait::RelCommon* ProjectRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.ProjectRel.common) - ::io::substrait::RelCommon_Hint_Stats* temp = stats_; - stats_ = nullptr; + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::_internal_mutable_stats() { +inline ::io::substrait::RelCommon* ProjectRel::_internal_mutable_common() { - if (stats_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon_Hint_Stats>(GetArena()); - stats_ = p; + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; } - return stats_; + return common_; } -inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::mutable_stats() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.stats) - return _internal_mutable_stats(); +inline ::io::substrait::RelCommon* ProjectRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.common) + return _internal_mutable_common(); } -inline void RelCommon_Hint::set_allocated_stats(::io::substrait::RelCommon_Hint_Stats* stats) { +inline void ProjectRel::set_allocated_common(::io::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete stats_; + delete common_; } - if (stats) { + if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(stats); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); if (message_arena != submessage_arena) { - stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, stats, submessage_arena); + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); } } else { } - stats_ = stats; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.stats) + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ProjectRel.common) } -// ------------------------------------------------------------------- - -// RelCommon_RuntimeConstraint - -// ------------------------------------------------------------------- - -// RelCommon - -// .io.substrait.RelCommon.Direct direct = 1; -inline bool RelCommon::_internal_has_direct() const { - return kind_case() == kDirect; -} -inline bool RelCommon::has_direct() const { - return _internal_has_direct(); -} -inline void RelCommon::set_has_direct() { - _oneof_case_[0] = kDirect; +// .io.substrait.Rel input = 2; +inline bool ProjectRel::_internal_has_input() const { + return this != internal_default_instance() && input_ != nullptr; } -inline void RelCommon::clear_direct() { - if (_internal_has_direct()) { - if (GetArena() == nullptr) { - delete kind_.direct_; - } - clear_has_kind(); - } +inline bool ProjectRel::has_input() const { + return _internal_has_input(); } -inline ::io::substrait::RelCommon_Direct* RelCommon::release_direct() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.direct) - if (_internal_has_direct()) { - clear_has_kind(); - ::io::substrait::RelCommon_Direct* temp = kind_.direct_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.direct_ = nullptr; - return temp; - } else { - return nullptr; +inline void ProjectRel::clear_input() { + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; } + input_ = nullptr; } -inline const ::io::substrait::RelCommon_Direct& RelCommon::_internal_direct() const { - return _internal_has_direct() - ? *kind_.direct_ - : reinterpret_cast< ::io::substrait::RelCommon_Direct&>(::io::substrait::_RelCommon_Direct_default_instance_); +inline const ::io::substrait::Rel& ProjectRel::_internal_input() const { + const ::io::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); } -inline const ::io::substrait::RelCommon_Direct& RelCommon::direct() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.direct) - return _internal_direct(); +inline const ::io::substrait::Rel& ProjectRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.input) + return _internal_input(); } -inline ::io::substrait::RelCommon_Direct* RelCommon::unsafe_arena_release_direct() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.RelCommon.direct) - if (_internal_has_direct()) { - clear_has_kind(); - ::io::substrait::RelCommon_Direct* temp = kind_.direct_; - kind_.direct_ = nullptr; - return temp; - } else { - return nullptr; +inline void ProjectRel::unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } -} -inline void RelCommon::unsafe_arena_set_allocated_direct(::io::substrait::RelCommon_Direct* direct) { - clear_kind(); - if (direct) { - set_has_direct(); - kind_.direct_ = direct; + input_ = input; + if (input) { + + } else { + } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.direct) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ProjectRel.input) } -inline ::io::substrait::RelCommon_Direct* RelCommon::_internal_mutable_direct() { - if (!_internal_has_direct()) { - clear_kind(); - set_has_direct(); - kind_.direct_ = CreateMaybeMessage< ::io::substrait::RelCommon_Direct >(GetArena()); +inline ::io::substrait::Rel* ProjectRel::release_input() { + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - return kind_.direct_; -} -inline ::io::substrait::RelCommon_Direct* RelCommon::mutable_direct() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.direct) - return _internal_mutable_direct(); + return temp; } - -// .io.substrait.RelCommon.Emit emit = 2; -inline bool RelCommon::_internal_has_emit() const { - return kind_case() == kEmit; +inline ::io::substrait::Rel* ProjectRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.ProjectRel.input) + + ::io::substrait::Rel* temp = input_; + input_ = nullptr; + return temp; } -inline bool RelCommon::has_emit() const { - return _internal_has_emit(); +inline ::io::substrait::Rel* ProjectRel::_internal_mutable_input() { + + if (input_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + input_ = p; + } + return input_; } -inline void RelCommon::set_has_emit() { - _oneof_case_[0] = kEmit; +inline ::io::substrait::Rel* ProjectRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.input) + return _internal_mutable_input(); } -inline void RelCommon::clear_emit() { - if (_internal_has_emit()) { - if (GetArena() == nullptr) { - delete kind_.emit_; - } - clear_has_kind(); +inline void ProjectRel::set_allocated_input(::io::substrait::Rel* input) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete input_; } -} -inline ::io::substrait::RelCommon_Emit* RelCommon::release_emit() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.emit) - if (_internal_has_emit()) { - clear_has_kind(); - ::io::substrait::RelCommon_Emit* temp = kind_.emit_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (input) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + if (message_arena != submessage_arena) { + input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input, submessage_arena); } - kind_.emit_ = nullptr; - return temp; + } else { - return nullptr; + } + input_ = input; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ProjectRel.input) } -inline const ::io::substrait::RelCommon_Emit& RelCommon::_internal_emit() const { - return _internal_has_emit() - ? *kind_.emit_ - : reinterpret_cast< ::io::substrait::RelCommon_Emit&>(::io::substrait::_RelCommon_Emit_default_instance_); + +// repeated .io.substrait.Expression expressions = 3; +inline int ProjectRel::_internal_expressions_size() const { + return expressions_.size(); } -inline const ::io::substrait::RelCommon_Emit& RelCommon::emit() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.emit) - return _internal_emit(); +inline int ProjectRel::expressions_size() const { + return _internal_expressions_size(); } -inline ::io::substrait::RelCommon_Emit* RelCommon::unsafe_arena_release_emit() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.RelCommon.emit) - if (_internal_has_emit()) { - clear_has_kind(); - ::io::substrait::RelCommon_Emit* temp = kind_.emit_; - kind_.emit_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::io::substrait::Expression* ProjectRel::mutable_expressions(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.expressions) + return expressions_.Mutable(index); } -inline void RelCommon::unsafe_arena_set_allocated_emit(::io::substrait::RelCommon_Emit* emit) { - clear_kind(); - if (emit) { - set_has_emit(); - kind_.emit_ = emit; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.emit) +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +ProjectRel::mutable_expressions() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ProjectRel.expressions) + return &expressions_; } -inline ::io::substrait::RelCommon_Emit* RelCommon::_internal_mutable_emit() { - if (!_internal_has_emit()) { - clear_kind(); - set_has_emit(); - kind_.emit_ = CreateMaybeMessage< ::io::substrait::RelCommon_Emit >(GetArena()); - } - return kind_.emit_; +inline const ::io::substrait::Expression& ProjectRel::_internal_expressions(int index) const { + return expressions_.Get(index); } -inline ::io::substrait::RelCommon_Emit* RelCommon::mutable_emit() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.emit) - return _internal_mutable_emit(); +inline const ::io::substrait::Expression& ProjectRel::expressions(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.expressions) + return _internal_expressions(index); } - -// .io.substrait.RelCommon.Hint hint = 3; -inline bool RelCommon::_internal_has_hint() const { - return this != internal_default_instance() && hint_ != nullptr; +inline ::io::substrait::Expression* ProjectRel::_internal_add_expressions() { + return expressions_.Add(); } -inline bool RelCommon::has_hint() const { - return _internal_has_hint(); +inline ::io::substrait::Expression* ProjectRel::add_expressions() { + // @@protoc_insertion_point(field_add:io.substrait.ProjectRel.expressions) + return _internal_add_expressions(); } -inline void RelCommon::clear_hint() { - if (GetArena() == nullptr && hint_ != nullptr) { - delete hint_; - } - hint_ = nullptr; +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +ProjectRel::expressions() const { + // @@protoc_insertion_point(field_list:io.substrait.ProjectRel.expressions) + return expressions_; } -inline const ::io::substrait::RelCommon_Hint& RelCommon::_internal_hint() const { - const ::io::substrait::RelCommon_Hint* p = hint_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_Hint_default_instance_); + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool ProjectRel::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; } -inline const ::io::substrait::RelCommon_Hint& RelCommon::hint() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.hint) - return _internal_hint(); +inline bool ProjectRel::has_advanced_extension() const { + return _internal_has_advanced_extension(); } -inline void RelCommon::unsafe_arena_set_allocated_hint( - ::io::substrait::RelCommon_Hint* hint) { +inline const ::io::substrait::extensions::AdvancedExtension& ProjectRel::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& ProjectRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.advanced_extension) + return _internal_advanced_extension(); +} +inline void ProjectRel::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hint_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - hint_ = hint; - if (hint) { + advanced_extension_ = advanced_extension; + if (advanced_extension) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.hint) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ProjectRel.advanced_extension) } -inline ::io::substrait::RelCommon_Hint* RelCommon::release_hint() { +inline ::io::substrait::extensions::AdvancedExtension* ProjectRel::release_advanced_extension() { - ::io::substrait::RelCommon_Hint* temp = hint_; - hint_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon_Hint* RelCommon::unsafe_arena_release_hint() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.hint) +inline ::io::substrait::extensions::AdvancedExtension* ProjectRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.ProjectRel.advanced_extension) - ::io::substrait::RelCommon_Hint* temp = hint_; - hint_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::RelCommon_Hint* RelCommon::_internal_mutable_hint() { +inline ::io::substrait::extensions::AdvancedExtension* ProjectRel::_internal_mutable_advanced_extension() { - if (hint_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon_Hint>(GetArena()); - hint_ = p; + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; } - return hint_; + return advanced_extension_; } -inline ::io::substrait::RelCommon_Hint* RelCommon::mutable_hint() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.hint) - return _internal_mutable_hint(); +inline ::io::substrait::extensions::AdvancedExtension* ProjectRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.advanced_extension) + return _internal_mutable_advanced_extension(); } -inline void RelCommon::set_allocated_hint(::io::substrait::RelCommon_Hint* hint) { +inline void ProjectRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete hint_; + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - if (hint) { + if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(hint); + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); if (message_arena != submessage_arena) { - hint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, hint, submessage_arena); + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); } } else { } - hint_ = hint; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.hint) + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ProjectRel.advanced_extension) } -// .io.substrait.RelCommon.RuntimeConstraint constraint = 4; -inline bool RelCommon::_internal_has_constraint() const { - return this != internal_default_instance() && constraint_ != nullptr; +// ------------------------------------------------------------------- + +// JoinRel + +// .io.substrait.RelCommon common = 1; +inline bool JoinRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; } -inline bool RelCommon::has_constraint() const { - return _internal_has_constraint(); +inline bool JoinRel::has_common() const { + return _internal_has_common(); } -inline void RelCommon::clear_constraint() { - if (GetArena() == nullptr && constraint_ != nullptr) { - delete constraint_; +inline void JoinRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; } - constraint_ = nullptr; + common_ = nullptr; } -inline const ::io::substrait::RelCommon_RuntimeConstraint& RelCommon::_internal_constraint() const { - const ::io::substrait::RelCommon_RuntimeConstraint* p = constraint_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_RuntimeConstraint_default_instance_); +inline const ::io::substrait::RelCommon& JoinRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon_RuntimeConstraint& RelCommon::constraint() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.constraint) - return _internal_constraint(); +inline const ::io::substrait::RelCommon& JoinRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.common) + return _internal_common(); } -inline void RelCommon::unsafe_arena_set_allocated_constraint( - ::io::substrait::RelCommon_RuntimeConstraint* constraint) { +inline void JoinRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(constraint_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } - constraint_ = constraint; - if (constraint) { + common_ = common; + if (common) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.constraint) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.common) } -inline ::io::substrait::RelCommon_RuntimeConstraint* RelCommon::release_constraint() { +inline ::io::substrait::RelCommon* JoinRel::release_common() { - ::io::substrait::RelCommon_RuntimeConstraint* temp = constraint_; - constraint_ = nullptr; + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon_RuntimeConstraint* RelCommon::unsafe_arena_release_constraint() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.constraint) +inline ::io::substrait::RelCommon* JoinRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.common) - ::io::substrait::RelCommon_RuntimeConstraint* temp = constraint_; - constraint_ = nullptr; + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon_RuntimeConstraint* RelCommon::_internal_mutable_constraint() { +inline ::io::substrait::RelCommon* JoinRel::_internal_mutable_common() { - if (constraint_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon_RuntimeConstraint>(GetArena()); - constraint_ = p; + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; } - return constraint_; + return common_; } -inline ::io::substrait::RelCommon_RuntimeConstraint* RelCommon::mutable_constraint() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.constraint) - return _internal_mutable_constraint(); +inline ::io::substrait::RelCommon* JoinRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.common) + return _internal_mutable_common(); } -inline void RelCommon::set_allocated_constraint(::io::substrait::RelCommon_RuntimeConstraint* constraint) { +inline void JoinRel::set_allocated_common(::io::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete constraint_; + delete common_; } - if (constraint) { + if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(constraint); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); if (message_arena != submessage_arena) { - constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, constraint, submessage_arena); + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); } } else { } - constraint_ = constraint; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.constraint) -} - -inline bool RelCommon::has_kind() const { - return kind_case() != KIND_NOT_SET; -} -inline void RelCommon::clear_has_kind() { - _oneof_case_[0] = KIND_NOT_SET; -} -inline RelCommon::KindCase RelCommon::kind_case() const { - return RelCommon::KindCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// ReadRel_NamedTable - -// repeated string names = 1; -inline int ReadRel_NamedTable::_internal_names_size() const { - return names_.size(); -} -inline int ReadRel_NamedTable::names_size() const { - return _internal_names_size(); -} -inline void ReadRel_NamedTable::clear_names() { - names_.Clear(); -} -inline std::string* ReadRel_NamedTable::add_names() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.ReadRel.NamedTable.names) - return _internal_add_names(); -} -inline const std::string& ReadRel_NamedTable::_internal_names(int index) const { - return names_.Get(index); -} -inline const std::string& ReadRel_NamedTable::names(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.NamedTable.names) - return _internal_names(index); -} -inline std::string* ReadRel_NamedTable::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.NamedTable.names) - return names_.Mutable(index); -} -inline void ReadRel_NamedTable::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.NamedTable.names) - names_.Mutable(index)->assign(value); -} -inline void ReadRel_NamedTable::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.NamedTable.names) - names_.Mutable(index)->assign(std::move(value)); -} -inline void ReadRel_NamedTable::set_names(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.ReadRel.NamedTable.names) -} -inline void ReadRel_NamedTable::set_names(int index, const char* value, size_t size) { - names_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.ReadRel.NamedTable.names) -} -inline std::string* ReadRel_NamedTable::_internal_add_names() { - return names_.Add(); -} -inline void ReadRel_NamedTable::add_names(const std::string& value) { - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.ReadRel.NamedTable.names) -} -inline void ReadRel_NamedTable::add_names(std::string&& value) { - names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.ReadRel.NamedTable.names) -} -inline void ReadRel_NamedTable::add_names(const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.ReadRel.NamedTable.names) -} -inline void ReadRel_NamedTable::add_names(const char* value, size_t size) { - names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.ReadRel.NamedTable.names) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -ReadRel_NamedTable::names() const { - // @@protoc_insertion_point(field_list:io.substrait.ReadRel.NamedTable.names) - return names_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -ReadRel_NamedTable::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.NamedTable.names) - return &names_; + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.common) } -// ------------------------------------------------------------------- - -// ReadRel_VirtualTable - -// repeated .io.substrait.Expression.Literal.Struct values = 1; -inline int ReadRel_VirtualTable::_internal_values_size() const { - return values_.size(); -} -inline int ReadRel_VirtualTable::values_size() const { - return _internal_values_size(); -} -inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::mutable_values(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.VirtualTable.values) - return values_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >* -ReadRel_VirtualTable::mutable_values() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.VirtualTable.values) - return &values_; -} -inline const ::io::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::_internal_values(int index) const { - return values_.Get(index); +// .io.substrait.Rel left = 2; +inline bool JoinRel::_internal_has_left() const { + return this != internal_default_instance() && left_ != nullptr; } -inline const ::io::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::values(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.VirtualTable.values) - return _internal_values(index); +inline bool JoinRel::has_left() const { + return _internal_has_left(); } -inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::_internal_add_values() { - return values_.Add(); +inline void JoinRel::clear_left() { + if (GetArena() == nullptr && left_ != nullptr) { + delete left_; + } + left_ = nullptr; } -inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::add_values() { - // @@protoc_insertion_point(field_add:io.substrait.ReadRel.VirtualTable.values) - return _internal_add_values(); +inline const ::io::substrait::Rel& JoinRel::_internal_left() const { + const ::io::substrait::Rel* p = left_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >& -ReadRel_VirtualTable::values() const { - // @@protoc_insertion_point(field_list:io.substrait.ReadRel.VirtualTable.values) - return values_; +inline const ::io::substrait::Rel& JoinRel::left() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.left) + return _internal_left(); } - -// ------------------------------------------------------------------- - -// ReadRel_LocalFiles_FileOrFiles - -// string uri_path = 1; -inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_path() const { - return path_type_case() == kUriPath; +inline void JoinRel::unsafe_arena_set_allocated_left( + ::io::substrait::Rel* left) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(left_); + } + left_ = left; + if (left) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.left) } -inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_path() const { - return _internal_has_uri_path(); +inline ::io::substrait::Rel* JoinRel::release_left() { + + ::io::substrait::Rel* temp = left_; + left_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path() { - _oneof_case_[0] = kUriPath; +inline ::io::substrait::Rel* JoinRel::unsafe_arena_release_left() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.left) + + ::io::substrait::Rel* temp = left_; + left_ = nullptr; + return temp; } -inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path() { - if (_internal_has_uri_path()) { - path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - clear_has_path_type(); +inline ::io::substrait::Rel* JoinRel::_internal_mutable_left() { + + if (left_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + left_ = p; } + return left_; } -inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) - return _internal_uri_path(); +inline ::io::substrait::Rel* JoinRel::mutable_left() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.left) + return _internal_mutable_left(); } -template -inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_uri_path()) { - clear_path_type(); - set_has_uri_path(); - path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline void JoinRel::set_allocated_left(::io::substrait::Rel* left) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete left_; } - path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + if (left) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(left); + if (message_arena != submessage_arena) { + left = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, left, submessage_arena); + } + + } else { + + } + left_ = left; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.left) } -inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) - return _internal_mutable_uri_path(); + +// .io.substrait.Rel right = 3; +inline bool JoinRel::_internal_has_right() const { + return this != internal_default_instance() && right_ != nullptr; } -inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path() const { - if (_internal_has_uri_path()) { - return path_type_.uri_path_.Get(); +inline bool JoinRel::has_right() const { + return _internal_has_right(); +} +inline void JoinRel::clear_right() { + if (GetArena() == nullptr && right_ != nullptr) { + delete right_; } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); + right_ = nullptr; } -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path(const std::string& value) { - if (!_internal_has_uri_path()) { - clear_path_type(); - set_has_uri_path(); - path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline const ::io::substrait::Rel& JoinRel::_internal_right() const { + const ::io::substrait::Rel* p = right_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); +} +inline const ::io::substrait::Rel& JoinRel::right() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.right) + return _internal_right(); +} +inline void JoinRel::unsafe_arena_set_allocated_right( + ::io::substrait::Rel* right) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(right_); } - path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + right_ = right; + if (right) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.right) } -inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path() { - if (!_internal_has_uri_path()) { - clear_path_type(); - set_has_uri_path(); - path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline ::io::substrait::Rel* JoinRel::release_right() { + + ::io::substrait::Rel* temp = right_; + right_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - return path_type_.uri_path_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return temp; } -inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) - if (_internal_has_uri_path()) { - clear_has_path_type(); - return path_type_.uri_path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - } else { - return nullptr; +inline ::io::substrait::Rel* JoinRel::unsafe_arena_release_right() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.right) + + ::io::substrait::Rel* temp = right_; + right_ = nullptr; + return temp; +} +inline ::io::substrait::Rel* JoinRel::_internal_mutable_right() { + + if (right_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + right_ = p; } + return right_; } -inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path(std::string* uri_path) { - if (has_path_type()) { - clear_path_type(); +inline ::io::substrait::Rel* JoinRel::mutable_right() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.right) + return _internal_mutable_right(); +} +inline void JoinRel::set_allocated_right(::io::substrait::Rel* right) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete right_; } - if (uri_path != nullptr) { - set_has_uri_path(); - path_type_.uri_path_.UnsafeSetDefault(uri_path); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); - if (arena != nullptr) { - arena->Own(uri_path); + if (right) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(right); + if (message_arena != submessage_arena) { + right = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, right, submessage_arena); } + + } else { + } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + right_ = right; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.right) } -// string uri_path_glob = 2; -inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_path_glob() const { - return path_type_case() == kUriPathGlob; -} -inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_path_glob() const { - return _internal_has_uri_path_glob(); +// .io.substrait.Expression expression = 4; +inline bool JoinRel::_internal_has_expression() const { + return this != internal_default_instance() && expression_ != nullptr; } -inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path_glob() { - _oneof_case_[0] = kUriPathGlob; +inline bool JoinRel::has_expression() const { + return _internal_has_expression(); } -inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path_glob() { - if (_internal_has_uri_path_glob()) { - path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); - clear_has_path_type(); - } +inline const ::io::substrait::Expression& JoinRel::_internal_expression() const { + const ::io::substrait::Expression* p = expression_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); } -inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path_glob() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) - return _internal_uri_path_glob(); +inline const ::io::substrait::Expression& JoinRel::expression() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.expression) + return _internal_expression(); } -template -inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path_glob(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_uri_path_glob()) { - clear_path_type(); - set_has_uri_path_glob(); - path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline void JoinRel::unsafe_arena_set_allocated_expression( + ::io::substrait::Expression* expression) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); } - path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path_glob() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) - return _internal_mutable_uri_path_glob(); -} -inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path_glob() const { - if (_internal_has_uri_path_glob()) { - return path_type_.uri_path_glob_.Get(); + expression_ = expression; + if (expression) { + + } else { + } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.expression) } -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path_glob(const std::string& value) { - if (!_internal_has_uri_path_glob()) { - clear_path_type(); - set_has_uri_path_glob(); - path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +inline ::io::substrait::Expression* JoinRel::release_expression() { + + ::io::substrait::Expression* temp = expression_; + expression_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + return temp; } -inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path_glob() { - if (!_internal_has_uri_path_glob()) { - clear_path_type(); - set_has_uri_path_glob(); - path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return path_type_.uri_path_glob_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +inline ::io::substrait::Expression* JoinRel::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.expression) + + ::io::substrait::Expression* temp = expression_; + expression_ = nullptr; + return temp; } -inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path_glob() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) - if (_internal_has_uri_path_glob()) { - clear_has_path_type(); - return path_type_.uri_path_glob_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - } else { - return nullptr; +inline ::io::substrait::Expression* JoinRel::_internal_mutable_expression() { + + if (expression_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + expression_ = p; } + return expression_; } -inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path_glob(std::string* uri_path_glob) { - if (has_path_type()) { - clear_path_type(); +inline ::io::substrait::Expression* JoinRel::mutable_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.expression) + return _internal_mutable_expression(); +} +inline void JoinRel::set_allocated_expression(::io::substrait::Expression* expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); } - if (uri_path_glob != nullptr) { - set_has_uri_path_glob(); - path_type_.uri_path_glob_.UnsafeSetDefault(uri_path_glob); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); - if (arena != nullptr) { - arena->Own(uri_path_glob); + if (expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression)->GetArena(); + if (message_arena != submessage_arena) { + expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expression, submessage_arena); } + + } else { + } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + expression_ = expression; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.expression) } -// .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 3; -inline void ReadRel_LocalFiles_FileOrFiles::clear_format() { - format_ = 0; -} -inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::_internal_format() const { - return static_cast< ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format >(format_); -} -inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::format() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.format) - return _internal_format(); -} -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value) { - - format_ = value; +// .io.substrait.Expression post_join_filter = 5; +inline bool JoinRel::_internal_has_post_join_filter() const { + return this != internal_default_instance() && post_join_filter_ != nullptr; } -inline void ReadRel_LocalFiles_FileOrFiles::set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value) { - _internal_set_format(value); - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.format) +inline bool JoinRel::has_post_join_filter() const { + return _internal_has_post_join_filter(); } - -inline bool ReadRel_LocalFiles_FileOrFiles::has_path_type() const { - return path_type_case() != PATH_TYPE_NOT_SET; +inline const ::io::substrait::Expression& JoinRel::_internal_post_join_filter() const { + const ::io::substrait::Expression* p = post_join_filter_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); } -inline void ReadRel_LocalFiles_FileOrFiles::clear_has_path_type() { - _oneof_case_[0] = PATH_TYPE_NOT_SET; +inline const ::io::substrait::Expression& JoinRel::post_join_filter() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.post_join_filter) + return _internal_post_join_filter(); } -inline ReadRel_LocalFiles_FileOrFiles::PathTypeCase ReadRel_LocalFiles_FileOrFiles::path_type_case() const { - return ReadRel_LocalFiles_FileOrFiles::PathTypeCase(_oneof_case_[0]); +inline void JoinRel::unsafe_arena_set_allocated_post_join_filter( + ::io::substrait::Expression* post_join_filter) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); + } + post_join_filter_ = post_join_filter; + if (post_join_filter) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.post_join_filter) } -// ------------------------------------------------------------------- - -// ReadRel_LocalFiles - -// repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; -inline int ReadRel_LocalFiles::_internal_items_size() const { - return items_.size(); +inline ::io::substrait::Expression* JoinRel::release_post_join_filter() { + + ::io::substrait::Expression* temp = post_join_filter_; + post_join_filter_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline int ReadRel_LocalFiles::items_size() const { - return _internal_items_size(); +inline ::io::substrait::Expression* JoinRel::unsafe_arena_release_post_join_filter() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.post_join_filter) + + ::io::substrait::Expression* temp = post_join_filter_; + post_join_filter_ = nullptr; + return temp; } -inline void ReadRel_LocalFiles::clear_items() { - items_.Clear(); +inline ::io::substrait::Expression* JoinRel::_internal_mutable_post_join_filter() { + + if (post_join_filter_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + post_join_filter_ = p; + } + return post_join_filter_; } -inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::mutable_items(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.items) - return items_.Mutable(index); +inline ::io::substrait::Expression* JoinRel::mutable_post_join_filter() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.post_join_filter) + return _internal_mutable_post_join_filter(); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >* -ReadRel_LocalFiles::mutable_items() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.LocalFiles.items) - return &items_; +inline void JoinRel::set_allocated_post_join_filter(::io::substrait::Expression* post_join_filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); + } + if (post_join_filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter)->GetArena(); + if (message_arena != submessage_arena) { + post_join_filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, post_join_filter, submessage_arena); + } + + } else { + + } + post_join_filter_ = post_join_filter; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.post_join_filter) } -inline const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::_internal_items(int index) const { - return items_.Get(index); + +// .io.substrait.JoinRel.JoinType type = 6; +inline void JoinRel::clear_type() { + type_ = 0; } -inline const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::items(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.items) - return _internal_items(index); +inline ::io::substrait::JoinRel_JoinType JoinRel::_internal_type() const { + return static_cast< ::io::substrait::JoinRel_JoinType >(type_); } -inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::_internal_add_items() { - return items_.Add(); +inline ::io::substrait::JoinRel_JoinType JoinRel::type() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.type) + return _internal_type(); } -inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::add_items() { - // @@protoc_insertion_point(field_add:io.substrait.ReadRel.LocalFiles.items) - return _internal_add_items(); +inline void JoinRel::_internal_set_type(::io::substrait::JoinRel_JoinType value) { + + type_ = value; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >& -ReadRel_LocalFiles::items() const { - // @@protoc_insertion_point(field_list:io.substrait.ReadRel.LocalFiles.items) - return items_; +inline void JoinRel::set_type(::io::substrait::JoinRel_JoinType value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:io.substrait.JoinRel.type) } -// ------------------------------------------------------------------- - -// ReadRel - -// .io.substrait.RelCommon common = 1; -inline bool ReadRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool ReadRel::has_common() const { - return _internal_has_common(); +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool JoinRel::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; } -inline void ReadRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; +inline bool JoinRel::has_advanced_extension() const { + return _internal_has_advanced_extension(); } -inline const ::io::substrait::RelCommon& ReadRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::io::substrait::extensions::AdvancedExtension& JoinRel::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::RelCommon& ReadRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.common) - return _internal_common(); +inline const ::io::substrait::extensions::AdvancedExtension& JoinRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.JoinRel.advanced_extension) + return _internal_advanced_extension(); } -inline void ReadRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { +inline void JoinRel::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - common_ = common; - if (common) { + advanced_extension_ = advanced_extension; + if (advanced_extension) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.advanced_extension) } -inline ::io::substrait::RelCommon* ReadRel::release_common() { +inline ::io::substrait::extensions::AdvancedExtension* JoinRel::release_advanced_extension() { - ::io::substrait::RelCommon* temp = common_; - common_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* ReadRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.common) +inline ::io::substrait::extensions::AdvancedExtension* JoinRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.JoinRel.advanced_extension) - ::io::substrait::RelCommon* temp = common_; - common_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* ReadRel::_internal_mutable_common() { +inline ::io::substrait::extensions::AdvancedExtension* JoinRel::_internal_mutable_advanced_extension() { - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); - common_ = p; + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; } - return common_; + return advanced_extension_; } -inline ::io::substrait::RelCommon* ReadRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.common) - return _internal_mutable_common(); +inline ::io::substrait::extensions::AdvancedExtension* JoinRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.advanced_extension) + return _internal_mutable_advanced_extension(); } -inline void ReadRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void JoinRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete common_; + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - if (common) { + if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); } } else { } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.common) + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.advanced_extension) } -// .io.substrait.Type.NamedStruct base_schema = 2; -inline bool ReadRel::_internal_has_base_schema() const { - return this != internal_default_instance() && base_schema_ != nullptr; +// ------------------------------------------------------------------- + +// FetchRel + +// .io.substrait.RelCommon common = 1; +inline bool FetchRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; } -inline bool ReadRel::has_base_schema() const { - return _internal_has_base_schema(); +inline bool FetchRel::has_common() const { + return _internal_has_common(); } -inline const ::io::substrait::Type_NamedStruct& ReadRel::_internal_base_schema() const { - const ::io::substrait::Type_NamedStruct* p = base_schema_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_NamedStruct_default_instance_); +inline void FetchRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; } -inline const ::io::substrait::Type_NamedStruct& ReadRel::base_schema() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.base_schema) - return _internal_base_schema(); +inline const ::io::substrait::RelCommon& FetchRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); } -inline void ReadRel::unsafe_arena_set_allocated_base_schema( - ::io::substrait::Type_NamedStruct* base_schema) { +inline const ::io::substrait::RelCommon& FetchRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.FetchRel.common) + return _internal_common(); +} +inline void FetchRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } - base_schema_ = base_schema; - if (base_schema) { + common_ = common; + if (common) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.base_schema) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FetchRel.common) } -inline ::io::substrait::Type_NamedStruct* ReadRel::release_base_schema() { +inline ::io::substrait::RelCommon* FetchRel::release_common() { - ::io::substrait::Type_NamedStruct* temp = base_schema_; - base_schema_ = nullptr; + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type_NamedStruct* ReadRel::unsafe_arena_release_base_schema() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.base_schema) +inline ::io::substrait::RelCommon* FetchRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.FetchRel.common) - ::io::substrait::Type_NamedStruct* temp = base_schema_; - base_schema_ = nullptr; + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; return temp; } -inline ::io::substrait::Type_NamedStruct* ReadRel::_internal_mutable_base_schema() { +inline ::io::substrait::RelCommon* FetchRel::_internal_mutable_common() { - if (base_schema_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_NamedStruct>(GetArena()); - base_schema_ = p; + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; } - return base_schema_; + return common_; } -inline ::io::substrait::Type_NamedStruct* ReadRel::mutable_base_schema() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.base_schema) - return _internal_mutable_base_schema(); +inline ::io::substrait::RelCommon* FetchRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.FetchRel.common) + return _internal_mutable_common(); } -inline void ReadRel::set_allocated_base_schema(::io::substrait::Type_NamedStruct* base_schema) { +inline void FetchRel::set_allocated_common(::io::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); + delete common_; } - if (base_schema) { + if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); if (message_arena != submessage_arena) { - base_schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, base_schema, submessage_arena); + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); } } else { } - base_schema_ = base_schema; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.base_schema) + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FetchRel.common) } -// .io.substrait.Expression filter = 3; -inline bool ReadRel::_internal_has_filter() const { - return this != internal_default_instance() && filter_ != nullptr; +// .io.substrait.Rel input = 2; +inline bool FetchRel::_internal_has_input() const { + return this != internal_default_instance() && input_ != nullptr; } -inline bool ReadRel::has_filter() const { - return _internal_has_filter(); +inline bool FetchRel::has_input() const { + return _internal_has_input(); } -inline const ::io::substrait::Expression& ReadRel::_internal_filter() const { - const ::io::substrait::Expression* p = filter_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline void FetchRel::clear_input() { + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; } -inline const ::io::substrait::Expression& ReadRel::filter() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.filter) - return _internal_filter(); +inline const ::io::substrait::Rel& FetchRel::_internal_input() const { + const ::io::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); } -inline void ReadRel::unsafe_arena_set_allocated_filter( - ::io::substrait::Expression* filter) { +inline const ::io::substrait::Rel& FetchRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.FetchRel.input) + return _internal_input(); +} +inline void FetchRel::unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } - filter_ = filter; - if (filter) { + input_ = input; + if (input) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.filter) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FetchRel.input) } -inline ::io::substrait::Expression* ReadRel::release_filter() { +inline ::io::substrait::Rel* FetchRel::release_input() { - ::io::substrait::Expression* temp = filter_; - filter_ = nullptr; + ::io::substrait::Rel* temp = input_; + input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* ReadRel::unsafe_arena_release_filter() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.filter) +inline ::io::substrait::Rel* FetchRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.FetchRel.input) - ::io::substrait::Expression* temp = filter_; - filter_ = nullptr; + ::io::substrait::Rel* temp = input_; + input_ = nullptr; return temp; } -inline ::io::substrait::Expression* ReadRel::_internal_mutable_filter() { +inline ::io::substrait::Rel* FetchRel::_internal_mutable_input() { - if (filter_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - filter_ = p; + if (input_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + input_ = p; } - return filter_; + return input_; } -inline ::io::substrait::Expression* ReadRel::mutable_filter() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.filter) - return _internal_mutable_filter(); +inline ::io::substrait::Rel* FetchRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.FetchRel.input) + return _internal_mutable_input(); } -inline void ReadRel::set_allocated_filter(::io::substrait::Expression* filter) { +inline void FetchRel::set_allocated_input(::io::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); + delete input_; } - if (filter) { + if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); if (message_arena != submessage_arena) { - filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, filter, submessage_arena); + input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input, submessage_arena); } } else { } - filter_ = filter; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.filter) + input_ = input; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FetchRel.input) } -// .io.substrait.MaskExpression projection = 4; -inline bool ReadRel::_internal_has_projection() const { - return this != internal_default_instance() && projection_ != nullptr; +// int64 offset = 3; +inline void FetchRel::clear_offset() { + offset_ = PROTOBUF_LONGLONG(0); } -inline bool ReadRel::has_projection() const { - return _internal_has_projection(); +inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::_internal_offset() const { + return offset_; } -inline const ::io::substrait::MaskExpression& ReadRel::_internal_projection() const { - const ::io::substrait::MaskExpression* p = projection_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_MaskExpression_default_instance_); +inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::offset() const { + // @@protoc_insertion_point(field_get:io.substrait.FetchRel.offset) + return _internal_offset(); } -inline const ::io::substrait::MaskExpression& ReadRel::projection() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.projection) - return _internal_projection(); +inline void FetchRel::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + + offset_ = value; } -inline void ReadRel::unsafe_arena_set_allocated_projection( - ::io::substrait::MaskExpression* projection) { +inline void FetchRel::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_offset(value); + // @@protoc_insertion_point(field_set:io.substrait.FetchRel.offset) +} + +// int64 count = 4; +inline void FetchRel::clear_count() { + count_ = PROTOBUF_LONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::_internal_count() const { + return count_; +} +inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::count() const { + // @@protoc_insertion_point(field_get:io.substrait.FetchRel.count) + return _internal_count(); +} +inline void FetchRel::_internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { + + count_ = value; +} +inline void FetchRel::set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { + _internal_set_count(value); + // @@protoc_insertion_point(field_set:io.substrait.FetchRel.count) +} + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool FetchRel::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; +} +inline bool FetchRel::has_advanced_extension() const { + return _internal_has_advanced_extension(); +} +inline const ::io::substrait::extensions::AdvancedExtension& FetchRel::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& FetchRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.FetchRel.advanced_extension) + return _internal_advanced_extension(); +} +inline void FetchRel::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - projection_ = projection; - if (projection) { + advanced_extension_ = advanced_extension; + if (advanced_extension) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.projection) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FetchRel.advanced_extension) } -inline ::io::substrait::MaskExpression* ReadRel::release_projection() { +inline ::io::substrait::extensions::AdvancedExtension* FetchRel::release_advanced_extension() { - ::io::substrait::MaskExpression* temp = projection_; - projection_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::MaskExpression* ReadRel::unsafe_arena_release_projection() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.projection) +inline ::io::substrait::extensions::AdvancedExtension* FetchRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.FetchRel.advanced_extension) - ::io::substrait::MaskExpression* temp = projection_; - projection_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::MaskExpression* ReadRel::_internal_mutable_projection() { +inline ::io::substrait::extensions::AdvancedExtension* FetchRel::_internal_mutable_advanced_extension() { - if (projection_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::MaskExpression>(GetArena()); - projection_ = p; + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; } - return projection_; + return advanced_extension_; } -inline ::io::substrait::MaskExpression* ReadRel::mutable_projection() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.projection) - return _internal_mutable_projection(); +inline ::io::substrait::extensions::AdvancedExtension* FetchRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.FetchRel.advanced_extension) + return _internal_mutable_advanced_extension(); } -inline void ReadRel::set_allocated_projection(::io::substrait::MaskExpression* projection) { +inline void FetchRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - if (projection) { + if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection)->GetArena(); + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); if (message_arena != submessage_arena) { - projection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, projection, submessage_arena); + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); } } else { } - projection_ = projection; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.projection) + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FetchRel.advanced_extension) } -// .io.substrait.ReadRel.VirtualTable virtual_table = 5; -inline bool ReadRel::_internal_has_virtual_table() const { - return read_type_case() == kVirtualTable; -} -inline bool ReadRel::has_virtual_table() const { - return _internal_has_virtual_table(); -} -inline void ReadRel::set_has_virtual_table() { - _oneof_case_[0] = kVirtualTable; -} -inline void ReadRel::clear_virtual_table() { - if (_internal_has_virtual_table()) { - if (GetArena() == nullptr) { - delete read_type_.virtual_table_; - } - clear_has_read_type(); - } -} -inline ::io::substrait::ReadRel_VirtualTable* ReadRel::release_virtual_table() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.virtual_table) - if (_internal_has_virtual_table()) { - clear_has_read_type(); - ::io::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - read_type_.virtual_table_ = nullptr; - return temp; - } else { - return nullptr; - } +// ------------------------------------------------------------------- + +// AggregateRel_Grouping + +// repeated int32 input_fields = 1; +inline int AggregateRel_Grouping::_internal_input_fields_size() const { + return input_fields_.size(); } -inline const ::io::substrait::ReadRel_VirtualTable& ReadRel::_internal_virtual_table() const { - return _internal_has_virtual_table() - ? *read_type_.virtual_table_ - : reinterpret_cast< ::io::substrait::ReadRel_VirtualTable&>(::io::substrait::_ReadRel_VirtualTable_default_instance_); +inline int AggregateRel_Grouping::input_fields_size() const { + return _internal_input_fields_size(); } -inline const ::io::substrait::ReadRel_VirtualTable& ReadRel::virtual_table() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.virtual_table) - return _internal_virtual_table(); +inline void AggregateRel_Grouping::clear_input_fields() { + input_fields_.Clear(); } -inline ::io::substrait::ReadRel_VirtualTable* ReadRel::unsafe_arena_release_virtual_table() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.virtual_table) - if (_internal_has_virtual_table()) { - clear_has_read_type(); - ::io::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; - read_type_.virtual_table_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::PROTOBUF_NAMESPACE_ID::int32 AggregateRel_Grouping::_internal_input_fields(int index) const { + return input_fields_.Get(index); } -inline void ReadRel::unsafe_arena_set_allocated_virtual_table(::io::substrait::ReadRel_VirtualTable* virtual_table) { - clear_read_type(); - if (virtual_table) { - set_has_virtual_table(); - read_type_.virtual_table_ = virtual_table; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.virtual_table) +inline ::PROTOBUF_NAMESPACE_ID::int32 AggregateRel_Grouping::input_fields(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.Grouping.input_fields) + return _internal_input_fields(index); } -inline ::io::substrait::ReadRel_VirtualTable* ReadRel::_internal_mutable_virtual_table() { - if (!_internal_has_virtual_table()) { - clear_read_type(); - set_has_virtual_table(); - read_type_.virtual_table_ = CreateMaybeMessage< ::io::substrait::ReadRel_VirtualTable >(GetArena()); - } - return read_type_.virtual_table_; +inline void AggregateRel_Grouping::set_input_fields(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { + input_fields_.Set(index, value); + // @@protoc_insertion_point(field_set:io.substrait.AggregateRel.Grouping.input_fields) } -inline ::io::substrait::ReadRel_VirtualTable* ReadRel::mutable_virtual_table() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.virtual_table) - return _internal_mutable_virtual_table(); +inline void AggregateRel_Grouping::_internal_add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value) { + input_fields_.Add(value); } - -// .io.substrait.ReadRel.LocalFiles local_files = 6; -inline bool ReadRel::_internal_has_local_files() const { - return read_type_case() == kLocalFiles; +inline void AggregateRel_Grouping::add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value) { + _internal_add_input_fields(value); + // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.Grouping.input_fields) } -inline bool ReadRel::has_local_files() const { - return _internal_has_local_files(); +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +AggregateRel_Grouping::_internal_input_fields() const { + return input_fields_; } -inline void ReadRel::set_has_local_files() { - _oneof_case_[0] = kLocalFiles; +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +AggregateRel_Grouping::input_fields() const { + // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.Grouping.input_fields) + return _internal_input_fields(); } -inline void ReadRel::clear_local_files() { - if (_internal_has_local_files()) { - if (GetArena() == nullptr) { - delete read_type_.local_files_; - } - clear_has_read_type(); - } +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +AggregateRel_Grouping::_internal_mutable_input_fields() { + return &input_fields_; } -inline ::io::substrait::ReadRel_LocalFiles* ReadRel::release_local_files() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.local_files) - if (_internal_has_local_files()) { - clear_has_read_type(); - ::io::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - read_type_.local_files_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +AggregateRel_Grouping::mutable_input_fields() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.Grouping.input_fields) + return _internal_mutable_input_fields(); } -inline const ::io::substrait::ReadRel_LocalFiles& ReadRel::_internal_local_files() const { - return _internal_has_local_files() - ? *read_type_.local_files_ - : reinterpret_cast< ::io::substrait::ReadRel_LocalFiles&>(::io::substrait::_ReadRel_LocalFiles_default_instance_); + +// ------------------------------------------------------------------- + +// AggregateRel_Measure + +// .io.substrait.AggregateFunction measure = 1; +inline bool AggregateRel_Measure::_internal_has_measure() const { + return this != internal_default_instance() && measure_ != nullptr; } -inline const ::io::substrait::ReadRel_LocalFiles& ReadRel::local_files() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.local_files) - return _internal_local_files(); +inline bool AggregateRel_Measure::has_measure() const { + return _internal_has_measure(); } -inline ::io::substrait::ReadRel_LocalFiles* ReadRel::unsafe_arena_release_local_files() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.local_files) - if (_internal_has_local_files()) { - clear_has_read_type(); - ::io::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; - read_type_.local_files_ = nullptr; - return temp; - } else { - return nullptr; - } +inline const ::io::substrait::AggregateFunction& AggregateRel_Measure::_internal_measure() const { + const ::io::substrait::AggregateFunction* p = measure_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_AggregateFunction_default_instance_); } -inline void ReadRel::unsafe_arena_set_allocated_local_files(::io::substrait::ReadRel_LocalFiles* local_files) { - clear_read_type(); - if (local_files) { - set_has_local_files(); - read_type_.local_files_ = local_files; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.local_files) +inline const ::io::substrait::AggregateFunction& AggregateRel_Measure::measure() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.Measure.measure) + return _internal_measure(); } -inline ::io::substrait::ReadRel_LocalFiles* ReadRel::_internal_mutable_local_files() { - if (!_internal_has_local_files()) { - clear_read_type(); - set_has_local_files(); - read_type_.local_files_ = CreateMaybeMessage< ::io::substrait::ReadRel_LocalFiles >(GetArena()); +inline void AggregateRel_Measure::unsafe_arena_set_allocated_measure( + ::io::substrait::AggregateFunction* measure) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); } - return read_type_.local_files_; + measure_ = measure; + if (measure) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.Measure.measure) } -inline ::io::substrait::ReadRel_LocalFiles* ReadRel::mutable_local_files() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.local_files) - return _internal_mutable_local_files(); +inline ::io::substrait::AggregateFunction* AggregateRel_Measure::release_measure() { + + ::io::substrait::AggregateFunction* temp = measure_; + measure_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } - -// .io.substrait.ReadRel.NamedTable named_table = 7; -inline bool ReadRel::_internal_has_named_table() const { - return read_type_case() == kNamedTable; +inline ::io::substrait::AggregateFunction* AggregateRel_Measure::unsafe_arena_release_measure() { + // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.Measure.measure) + + ::io::substrait::AggregateFunction* temp = measure_; + measure_ = nullptr; + return temp; } -inline bool ReadRel::has_named_table() const { - return _internal_has_named_table(); +inline ::io::substrait::AggregateFunction* AggregateRel_Measure::_internal_mutable_measure() { + + if (measure_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::AggregateFunction>(GetArena()); + measure_ = p; + } + return measure_; } -inline void ReadRel::set_has_named_table() { - _oneof_case_[0] = kNamedTable; +inline ::io::substrait::AggregateFunction* AggregateRel_Measure::mutable_measure() { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.Measure.measure) + return _internal_mutable_measure(); } -inline void ReadRel::clear_named_table() { - if (_internal_has_named_table()) { - if (GetArena() == nullptr) { - delete read_type_.named_table_; - } - clear_has_read_type(); +inline void AggregateRel_Measure::set_allocated_measure(::io::substrait::AggregateFunction* measure) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); } -} -inline ::io::substrait::ReadRel_NamedTable* ReadRel::release_named_table() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.named_table) - if (_internal_has_named_table()) { - clear_has_read_type(); - ::io::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (measure) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure)->GetArena(); + if (message_arena != submessage_arena) { + measure = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, measure, submessage_arena); } - read_type_.named_table_ = nullptr; - return temp; + } else { - return nullptr; + } + measure_ = measure; + // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.Measure.measure) } -inline const ::io::substrait::ReadRel_NamedTable& ReadRel::_internal_named_table() const { - return _internal_has_named_table() - ? *read_type_.named_table_ - : reinterpret_cast< ::io::substrait::ReadRel_NamedTable&>(::io::substrait::_ReadRel_NamedTable_default_instance_); + +// .io.substrait.Expression filter = 2; +inline bool AggregateRel_Measure::_internal_has_filter() const { + return this != internal_default_instance() && filter_ != nullptr; } -inline const ::io::substrait::ReadRel_NamedTable& ReadRel::named_table() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.named_table) - return _internal_named_table(); +inline bool AggregateRel_Measure::has_filter() const { + return _internal_has_filter(); } -inline ::io::substrait::ReadRel_NamedTable* ReadRel::unsafe_arena_release_named_table() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.named_table) - if (_internal_has_named_table()) { - clear_has_read_type(); - ::io::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; - read_type_.named_table_ = nullptr; - return temp; - } else { - return nullptr; - } +inline const ::io::substrait::Expression& AggregateRel_Measure::_internal_filter() const { + const ::io::substrait::Expression* p = filter_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); } -inline void ReadRel::unsafe_arena_set_allocated_named_table(::io::substrait::ReadRel_NamedTable* named_table) { - clear_read_type(); - if (named_table) { - set_has_named_table(); - read_type_.named_table_ = named_table; +inline const ::io::substrait::Expression& AggregateRel_Measure::filter() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.Measure.filter) + return _internal_filter(); +} +inline void AggregateRel_Measure::unsafe_arena_set_allocated_filter( + ::io::substrait::Expression* filter) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.named_table) + filter_ = filter; + if (filter) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.Measure.filter) } -inline ::io::substrait::ReadRel_NamedTable* ReadRel::_internal_mutable_named_table() { - if (!_internal_has_named_table()) { - clear_read_type(); - set_has_named_table(); - read_type_.named_table_ = CreateMaybeMessage< ::io::substrait::ReadRel_NamedTable >(GetArena()); +inline ::io::substrait::Expression* AggregateRel_Measure::release_filter() { + + ::io::substrait::Expression* temp = filter_; + filter_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - return read_type_.named_table_; + return temp; } -inline ::io::substrait::ReadRel_NamedTable* ReadRel::mutable_named_table() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.named_table) - return _internal_mutable_named_table(); +inline ::io::substrait::Expression* AggregateRel_Measure::unsafe_arena_release_filter() { + // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.Measure.filter) + + ::io::substrait::Expression* temp = filter_; + filter_ = nullptr; + return temp; } - -inline bool ReadRel::has_read_type() const { - return read_type_case() != READ_TYPE_NOT_SET; +inline ::io::substrait::Expression* AggregateRel_Measure::_internal_mutable_filter() { + + if (filter_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + filter_ = p; + } + return filter_; } -inline void ReadRel::clear_has_read_type() { - _oneof_case_[0] = READ_TYPE_NOT_SET; +inline ::io::substrait::Expression* AggregateRel_Measure::mutable_filter() { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.Measure.filter) + return _internal_mutable_filter(); } -inline ReadRel::ReadTypeCase ReadRel::read_type_case() const { - return ReadRel::ReadTypeCase(_oneof_case_[0]); +inline void AggregateRel_Measure::set_allocated_filter(::io::substrait::Expression* filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); + } + if (filter) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter)->GetArena(); + if (message_arena != submessage_arena) { + filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, filter, submessage_arena); + } + + } else { + + } + filter_ = filter; + // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.Measure.filter) } + // ------------------------------------------------------------------- -// ProjectRel +// AggregateRel // .io.substrait.RelCommon common = 1; -inline bool ProjectRel::_internal_has_common() const { +inline bool AggregateRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } -inline bool ProjectRel::has_common() const { +inline bool AggregateRel::has_common() const { return _internal_has_common(); } -inline void ProjectRel::clear_common() { +inline void AggregateRel::clear_common() { if (GetArena() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; } -inline const ::io::substrait::RelCommon& ProjectRel::_internal_common() const { +inline const ::io::substrait::RelCommon& AggregateRel::_internal_common() const { const ::io::substrait::RelCommon* p = common_; return p != nullptr ? *p : reinterpret_cast( ::io::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& ProjectRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.common) +inline const ::io::substrait::RelCommon& AggregateRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.common) return _internal_common(); } -inline void ProjectRel::unsafe_arena_set_allocated_common( +inline void AggregateRel::unsafe_arena_set_allocated_common( ::io::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); @@ -5836,9 +8941,9 @@ inline void ProjectRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ProjectRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.common) } -inline ::io::substrait::RelCommon* ProjectRel::release_common() { +inline ::io::substrait::RelCommon* AggregateRel::release_common() { ::io::substrait::RelCommon* temp = common_; common_ = nullptr; @@ -5847,14 +8952,14 @@ inline ::io::substrait::RelCommon* ProjectRel::release_common() { } return temp; } -inline ::io::substrait::RelCommon* ProjectRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.ProjectRel.common) +inline ::io::substrait::RelCommon* AggregateRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.common) ::io::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* ProjectRel::_internal_mutable_common() { +inline ::io::substrait::RelCommon* AggregateRel::_internal_mutable_common() { if (common_ == nullptr) { auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); @@ -5862,11 +8967,11 @@ inline ::io::substrait::RelCommon* ProjectRel::_internal_mutable_common() { } return common_; } -inline ::io::substrait::RelCommon* ProjectRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.common) +inline ::io::substrait::RelCommon* AggregateRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.common) return _internal_mutable_common(); } -inline void ProjectRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void AggregateRel::set_allocated_common(::io::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -5883,32 +8988,32 @@ inline void ProjectRel::set_allocated_common(::io::substrait::RelCommon* common) } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ProjectRel.common) + // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.common) } // .io.substrait.Rel input = 2; -inline bool ProjectRel::_internal_has_input() const { +inline bool AggregateRel::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } -inline bool ProjectRel::has_input() const { +inline bool AggregateRel::has_input() const { return _internal_has_input(); } -inline void ProjectRel::clear_input() { +inline void AggregateRel::clear_input() { if (GetArena() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; } -inline const ::io::substrait::Rel& ProjectRel::_internal_input() const { +inline const ::io::substrait::Rel& AggregateRel::_internal_input() const { const ::io::substrait::Rel* p = input_; return p != nullptr ? *p : reinterpret_cast( ::io::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& ProjectRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.input) +inline const ::io::substrait::Rel& AggregateRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.input) return _internal_input(); } -inline void ProjectRel::unsafe_arena_set_allocated_input( +inline void AggregateRel::unsafe_arena_set_allocated_input( ::io::substrait::Rel* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); @@ -5919,9 +9024,9 @@ inline void ProjectRel::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ProjectRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.input) } -inline ::io::substrait::Rel* ProjectRel::release_input() { +inline ::io::substrait::Rel* AggregateRel::release_input() { ::io::substrait::Rel* temp = input_; input_ = nullptr; @@ -5930,14 +9035,14 @@ inline ::io::substrait::Rel* ProjectRel::release_input() { } return temp; } -inline ::io::substrait::Rel* ProjectRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.ProjectRel.input) +inline ::io::substrait::Rel* AggregateRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.input) ::io::substrait::Rel* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Rel* ProjectRel::_internal_mutable_input() { +inline ::io::substrait::Rel* AggregateRel::_internal_mutable_input() { if (input_ == nullptr) { auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); @@ -5945,11 +9050,11 @@ inline ::io::substrait::Rel* ProjectRel::_internal_mutable_input() { } return input_; } -inline ::io::substrait::Rel* ProjectRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.input) +inline ::io::substrait::Rel* AggregateRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.input) return _internal_mutable_input(); } -inline void ProjectRel::set_allocated_input(::io::substrait::Rel* input) { +inline void AggregateRel::set_allocated_input(::io::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -5966,499 +9071,474 @@ inline void ProjectRel::set_allocated_input(::io::substrait::Rel* input) { } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ProjectRel.input) + // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.input) } -// repeated .io.substrait.Expression expressions = 3; -inline int ProjectRel::_internal_expressions_size() const { - return expressions_.size(); +// repeated .io.substrait.AggregateRel.Grouping groupings = 3; +inline int AggregateRel::_internal_groupings_size() const { + return groupings_.size(); } -inline int ProjectRel::expressions_size() const { - return _internal_expressions_size(); +inline int AggregateRel::groupings_size() const { + return _internal_groupings_size(); } -inline ::io::substrait::Expression* ProjectRel::mutable_expressions(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.expressions) - return expressions_.Mutable(index); +inline void AggregateRel::clear_groupings() { + groupings_.Clear(); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* -ProjectRel::mutable_expressions() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ProjectRel.expressions) - return &expressions_; +inline ::io::substrait::AggregateRel_Grouping* AggregateRel::mutable_groupings(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.groupings) + return groupings_.Mutable(index); } -inline const ::io::substrait::Expression& ProjectRel::_internal_expressions(int index) const { - return expressions_.Get(index); +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >* +AggregateRel::mutable_groupings() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.groupings) + return &groupings_; } -inline const ::io::substrait::Expression& ProjectRel::expressions(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.expressions) - return _internal_expressions(index); +inline const ::io::substrait::AggregateRel_Grouping& AggregateRel::_internal_groupings(int index) const { + return groupings_.Get(index); } -inline ::io::substrait::Expression* ProjectRel::_internal_add_expressions() { - return expressions_.Add(); +inline const ::io::substrait::AggregateRel_Grouping& AggregateRel::groupings(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.groupings) + return _internal_groupings(index); } -inline ::io::substrait::Expression* ProjectRel::add_expressions() { - // @@protoc_insertion_point(field_add:io.substrait.ProjectRel.expressions) - return _internal_add_expressions(); +inline ::io::substrait::AggregateRel_Grouping* AggregateRel::_internal_add_groupings() { + return groupings_.Add(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& -ProjectRel::expressions() const { - // @@protoc_insertion_point(field_list:io.substrait.ProjectRel.expressions) - return expressions_; +inline ::io::substrait::AggregateRel_Grouping* AggregateRel::add_groupings() { + // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.groupings) + return _internal_add_groupings(); } - -// ------------------------------------------------------------------- - -// JoinRel - -// .io.substrait.RelCommon common = 1; -inline bool JoinRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >& +AggregateRel::groupings() const { + // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.groupings) + return groupings_; } -inline bool JoinRel::has_common() const { - return _internal_has_common(); + +// repeated .io.substrait.AggregateRel.Measure measures = 4; +inline int AggregateRel::_internal_measures_size() const { + return measures_.size(); } -inline void JoinRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; +inline int AggregateRel::measures_size() const { + return _internal_measures_size(); } -inline const ::io::substrait::RelCommon& JoinRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline void AggregateRel::clear_measures() { + measures_.Clear(); } -inline const ::io::substrait::RelCommon& JoinRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.common) - return _internal_common(); +inline ::io::substrait::AggregateRel_Measure* AggregateRel::mutable_measures(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.measures) + return measures_.Mutable(index); } -inline void JoinRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.common) +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >* +AggregateRel::mutable_measures() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.measures) + return &measures_; } -inline ::io::substrait::RelCommon* JoinRel::release_common() { - - ::io::substrait::RelCommon* temp = common_; - common_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline const ::io::substrait::AggregateRel_Measure& AggregateRel::_internal_measures(int index) const { + return measures_.Get(index); } -inline ::io::substrait::RelCommon* JoinRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.common) - - ::io::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; +inline const ::io::substrait::AggregateRel_Measure& AggregateRel::measures(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.measures) + return _internal_measures(index); } -inline ::io::substrait::RelCommon* JoinRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); - common_ = p; - } - return common_; +inline ::io::substrait::AggregateRel_Measure* AggregateRel::_internal_add_measures() { + return measures_.Add(); } -inline ::io::substrait::RelCommon* JoinRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.common) - return _internal_mutable_common(); +inline ::io::substrait::AggregateRel_Measure* AggregateRel::add_measures() { + // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.measures) + return _internal_add_measures(); } -inline void JoinRel::set_allocated_common(::io::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.common) +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >& +AggregateRel::measures() const { + // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.measures) + return measures_; } -// .io.substrait.Rel left = 2; -inline bool JoinRel::_internal_has_left() const { - return this != internal_default_instance() && left_ != nullptr; +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool AggregateRel::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; } -inline bool JoinRel::has_left() const { - return _internal_has_left(); -} -inline void JoinRel::clear_left() { - if (GetArena() == nullptr && left_ != nullptr) { - delete left_; - } - left_ = nullptr; +inline bool AggregateRel::has_advanced_extension() const { + return _internal_has_advanced_extension(); } -inline const ::io::substrait::Rel& JoinRel::_internal_left() const { - const ::io::substrait::Rel* p = left_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::io::substrait::extensions::AdvancedExtension& AggregateRel::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::Rel& JoinRel::left() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.left) - return _internal_left(); +inline const ::io::substrait::extensions::AdvancedExtension& AggregateRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.advanced_extension) + return _internal_advanced_extension(); } -inline void JoinRel::unsafe_arena_set_allocated_left( - ::io::substrait::Rel* left) { +inline void AggregateRel::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(left_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - left_ = left; - if (left) { + advanced_extension_ = advanced_extension; + if (advanced_extension) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.left) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.advanced_extension) } -inline ::io::substrait::Rel* JoinRel::release_left() { +inline ::io::substrait::extensions::AdvancedExtension* AggregateRel::release_advanced_extension() { - ::io::substrait::Rel* temp = left_; - left_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* JoinRel::unsafe_arena_release_left() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.left) +inline ::io::substrait::extensions::AdvancedExtension* AggregateRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.advanced_extension) - ::io::substrait::Rel* temp = left_; - left_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::Rel* JoinRel::_internal_mutable_left() { +inline ::io::substrait::extensions::AdvancedExtension* AggregateRel::_internal_mutable_advanced_extension() { - if (left_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); - left_ = p; + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; } - return left_; + return advanced_extension_; } -inline ::io::substrait::Rel* JoinRel::mutable_left() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.left) - return _internal_mutable_left(); +inline ::io::substrait::extensions::AdvancedExtension* AggregateRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.advanced_extension) + return _internal_mutable_advanced_extension(); } -inline void JoinRel::set_allocated_left(::io::substrait::Rel* left) { +inline void AggregateRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete left_; + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - if (left) { + if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(left); + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); if (message_arena != submessage_arena) { - left = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, left, submessage_arena); + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); } } else { } - left_ = left; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.left) + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.advanced_extension) } -// .io.substrait.Rel right = 3; -inline bool JoinRel::_internal_has_right() const { - return this != internal_default_instance() && right_ != nullptr; +// ------------------------------------------------------------------- + +// SortRel + +// .io.substrait.RelCommon common = 1; +inline bool SortRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; } -inline bool JoinRel::has_right() const { - return _internal_has_right(); +inline bool SortRel::has_common() const { + return _internal_has_common(); } -inline void JoinRel::clear_right() { - if (GetArena() == nullptr && right_ != nullptr) { - delete right_; +inline void SortRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; } - right_ = nullptr; + common_ = nullptr; } -inline const ::io::substrait::Rel& JoinRel::_internal_right() const { - const ::io::substrait::Rel* p = right_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::io::substrait::RelCommon& SortRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::Rel& JoinRel::right() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.right) - return _internal_right(); +inline const ::io::substrait::RelCommon& SortRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.SortRel.common) + return _internal_common(); } -inline void JoinRel::unsafe_arena_set_allocated_right( - ::io::substrait::Rel* right) { +inline void SortRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(right_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } - right_ = right; - if (right) { + common_ = common; + if (common) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.right) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortRel.common) } -inline ::io::substrait::Rel* JoinRel::release_right() { +inline ::io::substrait::RelCommon* SortRel::release_common() { - ::io::substrait::Rel* temp = right_; - right_ = nullptr; + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* JoinRel::unsafe_arena_release_right() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.right) +inline ::io::substrait::RelCommon* SortRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.SortRel.common) - ::io::substrait::Rel* temp = right_; - right_ = nullptr; + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; return temp; } -inline ::io::substrait::Rel* JoinRel::_internal_mutable_right() { +inline ::io::substrait::RelCommon* SortRel::_internal_mutable_common() { - if (right_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); - right_ = p; + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; } - return right_; + return common_; } -inline ::io::substrait::Rel* JoinRel::mutable_right() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.right) - return _internal_mutable_right(); +inline ::io::substrait::RelCommon* SortRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.common) + return _internal_mutable_common(); } -inline void JoinRel::set_allocated_right(::io::substrait::Rel* right) { +inline void SortRel::set_allocated_common(::io::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete right_; + delete common_; } - if (right) { + if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(right); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); if (message_arena != submessage_arena) { - right = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, right, submessage_arena); + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); } } else { } - right_ = right; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.right) + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.SortRel.common) } -// .io.substrait.Expression expression = 4; -inline bool JoinRel::_internal_has_expression() const { - return this != internal_default_instance() && expression_ != nullptr; +// .io.substrait.Rel input = 2; +inline bool SortRel::_internal_has_input() const { + return this != internal_default_instance() && input_ != nullptr; } -inline bool JoinRel::has_expression() const { - return _internal_has_expression(); +inline bool SortRel::has_input() const { + return _internal_has_input(); } -inline const ::io::substrait::Expression& JoinRel::_internal_expression() const { - const ::io::substrait::Expression* p = expression_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline void SortRel::clear_input() { + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; + } + input_ = nullptr; } -inline const ::io::substrait::Expression& JoinRel::expression() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.expression) - return _internal_expression(); +inline const ::io::substrait::Rel& SortRel::_internal_input() const { + const ::io::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); } -inline void JoinRel::unsafe_arena_set_allocated_expression( - ::io::substrait::Expression* expression) { +inline const ::io::substrait::Rel& SortRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.SortRel.input) + return _internal_input(); +} +inline void SortRel::unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } - expression_ = expression; - if (expression) { + input_ = input; + if (input) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.expression) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortRel.input) } -inline ::io::substrait::Expression* JoinRel::release_expression() { +inline ::io::substrait::Rel* SortRel::release_input() { - ::io::substrait::Expression* temp = expression_; - expression_ = nullptr; + ::io::substrait::Rel* temp = input_; + input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* JoinRel::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.expression) +inline ::io::substrait::Rel* SortRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.SortRel.input) - ::io::substrait::Expression* temp = expression_; - expression_ = nullptr; + ::io::substrait::Rel* temp = input_; + input_ = nullptr; return temp; } -inline ::io::substrait::Expression* JoinRel::_internal_mutable_expression() { +inline ::io::substrait::Rel* SortRel::_internal_mutable_input() { - if (expression_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - expression_ = p; + if (input_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + input_ = p; } - return expression_; + return input_; } -inline ::io::substrait::Expression* JoinRel::mutable_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.expression) - return _internal_mutable_expression(); +inline ::io::substrait::Rel* SortRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.input) + return _internal_mutable_input(); } -inline void JoinRel::set_allocated_expression(::io::substrait::Expression* expression) { +inline void SortRel::set_allocated_input(::io::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); + delete input_; } - if (expression) { + if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); if (message_arena != submessage_arena) { - expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, expression, submessage_arena); + input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input, submessage_arena); } } else { } - expression_ = expression; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.expression) + input_ = input; + // @@protoc_insertion_point(field_set_allocated:io.substrait.SortRel.input) } -// .io.substrait.Expression post_join_filter = 5; -inline bool JoinRel::_internal_has_post_join_filter() const { - return this != internal_default_instance() && post_join_filter_ != nullptr; +// repeated .io.substrait.SortField sorts = 3; +inline int SortRel::_internal_sorts_size() const { + return sorts_.size(); } -inline bool JoinRel::has_post_join_filter() const { - return _internal_has_post_join_filter(); +inline int SortRel::sorts_size() const { + return _internal_sorts_size(); } -inline const ::io::substrait::Expression& JoinRel::_internal_post_join_filter() const { - const ::io::substrait::Expression* p = post_join_filter_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline ::io::substrait::SortField* SortRel::mutable_sorts(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.sorts) + return sorts_.Mutable(index); } -inline const ::io::substrait::Expression& JoinRel::post_join_filter() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.post_join_filter) - return _internal_post_join_filter(); +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* +SortRel::mutable_sorts() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.SortRel.sorts) + return &sorts_; } -inline void JoinRel::unsafe_arena_set_allocated_post_join_filter( - ::io::substrait::Expression* post_join_filter) { +inline const ::io::substrait::SortField& SortRel::_internal_sorts(int index) const { + return sorts_.Get(index); +} +inline const ::io::substrait::SortField& SortRel::sorts(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.SortRel.sorts) + return _internal_sorts(index); +} +inline ::io::substrait::SortField* SortRel::_internal_add_sorts() { + return sorts_.Add(); +} +inline ::io::substrait::SortField* SortRel::add_sorts() { + // @@protoc_insertion_point(field_add:io.substrait.SortRel.sorts) + return _internal_add_sorts(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& +SortRel::sorts() const { + // @@protoc_insertion_point(field_list:io.substrait.SortRel.sorts) + return sorts_; +} + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool SortRel::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; +} +inline bool SortRel::has_advanced_extension() const { + return _internal_has_advanced_extension(); +} +inline const ::io::substrait::extensions::AdvancedExtension& SortRel::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& SortRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.SortRel.advanced_extension) + return _internal_advanced_extension(); +} +inline void SortRel::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - post_join_filter_ = post_join_filter; - if (post_join_filter) { + advanced_extension_ = advanced_extension; + if (advanced_extension) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.post_join_filter) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortRel.advanced_extension) } -inline ::io::substrait::Expression* JoinRel::release_post_join_filter() { +inline ::io::substrait::extensions::AdvancedExtension* SortRel::release_advanced_extension() { - ::io::substrait::Expression* temp = post_join_filter_; - post_join_filter_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* JoinRel::unsafe_arena_release_post_join_filter() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.post_join_filter) - - ::io::substrait::Expression* temp = post_join_filter_; - post_join_filter_ = nullptr; +inline ::io::substrait::extensions::AdvancedExtension* SortRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.SortRel.advanced_extension) + + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::Expression* JoinRel::_internal_mutable_post_join_filter() { +inline ::io::substrait::extensions::AdvancedExtension* SortRel::_internal_mutable_advanced_extension() { - if (post_join_filter_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - post_join_filter_ = p; + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; } - return post_join_filter_; + return advanced_extension_; } -inline ::io::substrait::Expression* JoinRel::mutable_post_join_filter() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.post_join_filter) - return _internal_mutable_post_join_filter(); +inline ::io::substrait::extensions::AdvancedExtension* SortRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.advanced_extension) + return _internal_mutable_advanced_extension(); } -inline void JoinRel::set_allocated_post_join_filter(::io::substrait::Expression* post_join_filter) { +inline void SortRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - if (post_join_filter) { + if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter)->GetArena(); + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); if (message_arena != submessage_arena) { - post_join_filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, post_join_filter, submessage_arena); + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); } } else { } - post_join_filter_ = post_join_filter; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.post_join_filter) -} - -// .io.substrait.JoinRel.JoinType type = 6; -inline void JoinRel::clear_type() { - type_ = 0; -} -inline ::io::substrait::JoinRel_JoinType JoinRel::_internal_type() const { - return static_cast< ::io::substrait::JoinRel_JoinType >(type_); -} -inline ::io::substrait::JoinRel_JoinType JoinRel::type() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.type) - return _internal_type(); -} -inline void JoinRel::_internal_set_type(::io::substrait::JoinRel_JoinType value) { - - type_ = value; -} -inline void JoinRel::set_type(::io::substrait::JoinRel_JoinType value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:io.substrait.JoinRel.type) + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.SortRel.advanced_extension) } // ------------------------------------------------------------------- -// FetchRel +// FilterRel // .io.substrait.RelCommon common = 1; -inline bool FetchRel::_internal_has_common() const { +inline bool FilterRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } -inline bool FetchRel::has_common() const { +inline bool FilterRel::has_common() const { return _internal_has_common(); } -inline void FetchRel::clear_common() { +inline void FilterRel::clear_common() { if (GetArena() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; } -inline const ::io::substrait::RelCommon& FetchRel::_internal_common() const { +inline const ::io::substrait::RelCommon& FilterRel::_internal_common() const { const ::io::substrait::RelCommon* p = common_; return p != nullptr ? *p : reinterpret_cast( ::io::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& FetchRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.FetchRel.common) +inline const ::io::substrait::RelCommon& FilterRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.FilterRel.common) return _internal_common(); } -inline void FetchRel::unsafe_arena_set_allocated_common( +inline void FilterRel::unsafe_arena_set_allocated_common( ::io::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); @@ -6469,9 +9549,9 @@ inline void FetchRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FetchRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.common) } -inline ::io::substrait::RelCommon* FetchRel::release_common() { +inline ::io::substrait::RelCommon* FilterRel::release_common() { ::io::substrait::RelCommon* temp = common_; common_ = nullptr; @@ -6480,14 +9560,14 @@ inline ::io::substrait::RelCommon* FetchRel::release_common() { } return temp; } -inline ::io::substrait::RelCommon* FetchRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.FetchRel.common) +inline ::io::substrait::RelCommon* FilterRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.FilterRel.common) ::io::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* FetchRel::_internal_mutable_common() { +inline ::io::substrait::RelCommon* FilterRel::_internal_mutable_common() { if (common_ == nullptr) { auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); @@ -6495,11 +9575,11 @@ inline ::io::substrait::RelCommon* FetchRel::_internal_mutable_common() { } return common_; } -inline ::io::substrait::RelCommon* FetchRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.FetchRel.common) +inline ::io::substrait::RelCommon* FilterRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.common) return _internal_mutable_common(); } -inline void FetchRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void FilterRel::set_allocated_common(::io::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -6516,32 +9596,32 @@ inline void FetchRel::set_allocated_common(::io::substrait::RelCommon* common) { } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FetchRel.common) + // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.common) } // .io.substrait.Rel input = 2; -inline bool FetchRel::_internal_has_input() const { +inline bool FilterRel::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } -inline bool FetchRel::has_input() const { +inline bool FilterRel::has_input() const { return _internal_has_input(); } -inline void FetchRel::clear_input() { +inline void FilterRel::clear_input() { if (GetArena() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; } -inline const ::io::substrait::Rel& FetchRel::_internal_input() const { +inline const ::io::substrait::Rel& FilterRel::_internal_input() const { const ::io::substrait::Rel* p = input_; return p != nullptr ? *p : reinterpret_cast( ::io::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& FetchRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.FetchRel.input) +inline const ::io::substrait::Rel& FilterRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.FilterRel.input) return _internal_input(); } -inline void FetchRel::unsafe_arena_set_allocated_input( +inline void FilterRel::unsafe_arena_set_allocated_input( ::io::substrait::Rel* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); @@ -6552,9 +9632,9 @@ inline void FetchRel::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FetchRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.input) } -inline ::io::substrait::Rel* FetchRel::release_input() { +inline ::io::substrait::Rel* FilterRel::release_input() { ::io::substrait::Rel* temp = input_; input_ = nullptr; @@ -6563,14 +9643,14 @@ inline ::io::substrait::Rel* FetchRel::release_input() { } return temp; } -inline ::io::substrait::Rel* FetchRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.FetchRel.input) +inline ::io::substrait::Rel* FilterRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.FilterRel.input) ::io::substrait::Rel* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Rel* FetchRel::_internal_mutable_input() { +inline ::io::substrait::Rel* FilterRel::_internal_mutable_input() { if (input_ == nullptr) { auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); @@ -6578,11 +9658,11 @@ inline ::io::substrait::Rel* FetchRel::_internal_mutable_input() { } return input_; } -inline ::io::substrait::Rel* FetchRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.FetchRel.input) +inline ::io::substrait::Rel* FilterRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.input) return _internal_mutable_input(); } -inline void FetchRel::set_allocated_input(::io::substrait::Rel* input) { +inline void FilterRel::set_allocated_input(::io::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -6599,208 +9679,190 @@ inline void FetchRel::set_allocated_input(::io::substrait::Rel* input) { } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FetchRel.input) + // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.input) } -// int64 offset = 3; -inline void FetchRel::clear_offset() { - offset_ = PROTOBUF_LONGLONG(0); -} -inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::_internal_offset() const { - return offset_; -} -inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::offset() const { - // @@protoc_insertion_point(field_get:io.substrait.FetchRel.offset) - return _internal_offset(); -} -inline void FetchRel::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { - - offset_ = value; +// .io.substrait.Expression condition = 3; +inline bool FilterRel::_internal_has_condition() const { + return this != internal_default_instance() && condition_ != nullptr; } -inline void FetchRel::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { - _internal_set_offset(value); - // @@protoc_insertion_point(field_set:io.substrait.FetchRel.offset) +inline bool FilterRel::has_condition() const { + return _internal_has_condition(); } - -// int64 count = 4; -inline void FetchRel::clear_count() { - count_ = PROTOBUF_LONGLONG(0); +inline const ::io::substrait::Expression& FilterRel::_internal_condition() const { + const ::io::substrait::Expression* p = condition_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Expression_default_instance_); } -inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::_internal_count() const { - return count_; +inline const ::io::substrait::Expression& FilterRel::condition() const { + // @@protoc_insertion_point(field_get:io.substrait.FilterRel.condition) + return _internal_condition(); } -inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::count() const { - // @@protoc_insertion_point(field_get:io.substrait.FetchRel.count) - return _internal_count(); +inline void FilterRel::unsafe_arena_set_allocated_condition( + ::io::substrait::Expression* condition) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); + } + condition_ = condition; + if (condition) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.condition) } -inline void FetchRel::_internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline ::io::substrait::Expression* FilterRel::release_condition() { - count_ = value; -} -inline void FetchRel::set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { - _internal_set_count(value); - // @@protoc_insertion_point(field_set:io.substrait.FetchRel.count) -} - -// ------------------------------------------------------------------- - -// AggregateRel_Grouping - -// repeated int32 input_fields = 1; -inline int AggregateRel_Grouping::_internal_input_fields_size() const { - return input_fields_.size(); -} -inline int AggregateRel_Grouping::input_fields_size() const { - return _internal_input_fields_size(); -} -inline void AggregateRel_Grouping::clear_input_fields() { - input_fields_.Clear(); -} -inline ::PROTOBUF_NAMESPACE_ID::int32 AggregateRel_Grouping::_internal_input_fields(int index) const { - return input_fields_.Get(index); -} -inline ::PROTOBUF_NAMESPACE_ID::int32 AggregateRel_Grouping::input_fields(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.Grouping.input_fields) - return _internal_input_fields(index); -} -inline void AggregateRel_Grouping::set_input_fields(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { - input_fields_.Set(index, value); - // @@protoc_insertion_point(field_set:io.substrait.AggregateRel.Grouping.input_fields) -} -inline void AggregateRel_Grouping::_internal_add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value) { - input_fields_.Add(value); -} -inline void AggregateRel_Grouping::add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_add_input_fields(value); - // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.Grouping.input_fields) + ::io::substrait::Expression* temp = condition_; + condition_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& -AggregateRel_Grouping::_internal_input_fields() const { - return input_fields_; +inline ::io::substrait::Expression* FilterRel::unsafe_arena_release_condition() { + // @@protoc_insertion_point(field_release:io.substrait.FilterRel.condition) + + ::io::substrait::Expression* temp = condition_; + condition_ = nullptr; + return temp; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& -AggregateRel_Grouping::input_fields() const { - // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.Grouping.input_fields) - return _internal_input_fields(); +inline ::io::substrait::Expression* FilterRel::_internal_mutable_condition() { + + if (condition_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + condition_ = p; + } + return condition_; } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* -AggregateRel_Grouping::_internal_mutable_input_fields() { - return &input_fields_; +inline ::io::substrait::Expression* FilterRel::mutable_condition() { + // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.condition) + return _internal_mutable_condition(); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* -AggregateRel_Grouping::mutable_input_fields() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.Grouping.input_fields) - return _internal_mutable_input_fields(); +inline void FilterRel::set_allocated_condition(::io::substrait::Expression* condition) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); + } + if (condition) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition)->GetArena(); + if (message_arena != submessage_arena) { + condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, condition, submessage_arena); + } + + } else { + + } + condition_ = condition; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.condition) } -// ------------------------------------------------------------------- - -// AggregateRel_Measure - -// .io.substrait.Expression.AggregateFunction measure = 1; -inline bool AggregateRel_Measure::_internal_has_measure() const { - return this != internal_default_instance() && measure_ != nullptr; -} -inline bool AggregateRel_Measure::has_measure() const { - return _internal_has_measure(); +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool FilterRel::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; } -inline const ::io::substrait::Expression_AggregateFunction& AggregateRel_Measure::_internal_measure() const { - const ::io::substrait::Expression_AggregateFunction* p = measure_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_AggregateFunction_default_instance_); +inline bool FilterRel::has_advanced_extension() const { + return _internal_has_advanced_extension(); } -inline const ::io::substrait::Expression_AggregateFunction& AggregateRel_Measure::measure() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.Measure.measure) - return _internal_measure(); +inline const ::io::substrait::extensions::AdvancedExtension& FilterRel::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); } -inline void AggregateRel_Measure::unsafe_arena_set_allocated_measure( - ::io::substrait::Expression_AggregateFunction* measure) { +inline const ::io::substrait::extensions::AdvancedExtension& FilterRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.FilterRel.advanced_extension) + return _internal_advanced_extension(); +} +inline void FilterRel::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - measure_ = measure; - if (measure) { + advanced_extension_ = advanced_extension; + if (advanced_extension) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.Measure.measure) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.advanced_extension) } -inline ::io::substrait::Expression_AggregateFunction* AggregateRel_Measure::release_measure() { +inline ::io::substrait::extensions::AdvancedExtension* FilterRel::release_advanced_extension() { - ::io::substrait::Expression_AggregateFunction* temp = measure_; - measure_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_AggregateFunction* AggregateRel_Measure::unsafe_arena_release_measure() { - // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.Measure.measure) +inline ::io::substrait::extensions::AdvancedExtension* FilterRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.FilterRel.advanced_extension) - ::io::substrait::Expression_AggregateFunction* temp = measure_; - measure_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::Expression_AggregateFunction* AggregateRel_Measure::_internal_mutable_measure() { +inline ::io::substrait::extensions::AdvancedExtension* FilterRel::_internal_mutable_advanced_extension() { - if (measure_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_AggregateFunction>(GetArena()); - measure_ = p; + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; } - return measure_; + return advanced_extension_; } -inline ::io::substrait::Expression_AggregateFunction* AggregateRel_Measure::mutable_measure() { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.Measure.measure) - return _internal_mutable_measure(); +inline ::io::substrait::extensions::AdvancedExtension* FilterRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.advanced_extension) + return _internal_mutable_advanced_extension(); } -inline void AggregateRel_Measure::set_allocated_measure(::io::substrait::Expression_AggregateFunction* measure) { +inline void FilterRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - if (measure) { + if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure)->GetArena(); + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); if (message_arena != submessage_arena) { - measure = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, measure, submessage_arena); + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); } } else { } - measure_ = measure; - // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.Measure.measure) + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.advanced_extension) } // ------------------------------------------------------------------- -// AggregateRel +// SetRel // .io.substrait.RelCommon common = 1; -inline bool AggregateRel::_internal_has_common() const { +inline bool SetRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } -inline bool AggregateRel::has_common() const { +inline bool SetRel::has_common() const { return _internal_has_common(); } -inline void AggregateRel::clear_common() { +inline void SetRel::clear_common() { if (GetArena() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; } -inline const ::io::substrait::RelCommon& AggregateRel::_internal_common() const { +inline const ::io::substrait::RelCommon& SetRel::_internal_common() const { const ::io::substrait::RelCommon* p = common_; return p != nullptr ? *p : reinterpret_cast( ::io::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& AggregateRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.common) +inline const ::io::substrait::RelCommon& SetRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.SetRel.common) return _internal_common(); } -inline void AggregateRel::unsafe_arena_set_allocated_common( +inline void SetRel::unsafe_arena_set_allocated_common( ::io::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); @@ -6811,9 +9873,9 @@ inline void AggregateRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SetRel.common) } -inline ::io::substrait::RelCommon* AggregateRel::release_common() { +inline ::io::substrait::RelCommon* SetRel::release_common() { ::io::substrait::RelCommon* temp = common_; common_ = nullptr; @@ -6822,14 +9884,14 @@ inline ::io::substrait::RelCommon* AggregateRel::release_common() { } return temp; } -inline ::io::substrait::RelCommon* AggregateRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.common) +inline ::io::substrait::RelCommon* SetRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.SetRel.common) ::io::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* AggregateRel::_internal_mutable_common() { +inline ::io::substrait::RelCommon* SetRel::_internal_mutable_common() { if (common_ == nullptr) { auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); @@ -6837,11 +9899,11 @@ inline ::io::substrait::RelCommon* AggregateRel::_internal_mutable_common() { } return common_; } -inline ::io::substrait::RelCommon* AggregateRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.common) +inline ::io::substrait::RelCommon* SetRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.SetRel.common) return _internal_mutable_common(); } -inline void AggregateRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void SetRel::set_allocated_common(::io::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -6858,217 +9920,172 @@ inline void AggregateRel::set_allocated_common(::io::substrait::RelCommon* commo } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.common) + // @@protoc_insertion_point(field_set_allocated:io.substrait.SetRel.common) } -// .io.substrait.Rel input = 2; -inline bool AggregateRel::_internal_has_input() const { - return this != internal_default_instance() && input_ != nullptr; +// repeated .io.substrait.Rel inputs = 2; +inline int SetRel::_internal_inputs_size() const { + return inputs_.size(); } -inline bool AggregateRel::has_input() const { - return _internal_has_input(); +inline int SetRel::inputs_size() const { + return _internal_inputs_size(); } -inline void AggregateRel::clear_input() { - if (GetArena() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; +inline void SetRel::clear_inputs() { + inputs_.Clear(); } -inline const ::io::substrait::Rel& AggregateRel::_internal_input() const { - const ::io::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline ::io::substrait::Rel* SetRel::mutable_inputs(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.SetRel.inputs) + return inputs_.Mutable(index); } -inline const ::io::substrait::Rel& AggregateRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.input) - return _internal_input(); +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* +SetRel::mutable_inputs() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.SetRel.inputs) + return &inputs_; } -inline void AggregateRel::unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input) { +inline const ::io::substrait::Rel& SetRel::_internal_inputs(int index) const { + return inputs_.Get(index); +} +inline const ::io::substrait::Rel& SetRel::inputs(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.SetRel.inputs) + return _internal_inputs(index); +} +inline ::io::substrait::Rel* SetRel::_internal_add_inputs() { + return inputs_.Add(); +} +inline ::io::substrait::Rel* SetRel::add_inputs() { + // @@protoc_insertion_point(field_add:io.substrait.SetRel.inputs) + return _internal_add_inputs(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& +SetRel::inputs() const { + // @@protoc_insertion_point(field_list:io.substrait.SetRel.inputs) + return inputs_; +} + +// .io.substrait.SetRel.SetOp op = 3; +inline void SetRel::clear_op() { + op_ = 0; +} +inline ::io::substrait::SetRel_SetOp SetRel::_internal_op() const { + return static_cast< ::io::substrait::SetRel_SetOp >(op_); +} +inline ::io::substrait::SetRel_SetOp SetRel::op() const { + // @@protoc_insertion_point(field_get:io.substrait.SetRel.op) + return _internal_op(); +} +inline void SetRel::_internal_set_op(::io::substrait::SetRel_SetOp value) { + + op_ = value; +} +inline void SetRel::set_op(::io::substrait::SetRel_SetOp value) { + _internal_set_op(value); + // @@protoc_insertion_point(field_set:io.substrait.SetRel.op) +} + +// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +inline bool SetRel::_internal_has_advanced_extension() const { + return this != internal_default_instance() && advanced_extension_ != nullptr; +} +inline bool SetRel::has_advanced_extension() const { + return _internal_has_advanced_extension(); +} +inline const ::io::substrait::extensions::AdvancedExtension& SetRel::_internal_advanced_extension() const { + const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::extensions::_AdvancedExtension_default_instance_); +} +inline const ::io::substrait::extensions::AdvancedExtension& SetRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:io.substrait.SetRel.advanced_extension) + return _internal_advanced_extension(); +} +inline void SetRel::unsafe_arena_set_allocated_advanced_extension( + ::io::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - input_ = input; - if (input) { + advanced_extension_ = advanced_extension; + if (advanced_extension) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SetRel.advanced_extension) } -inline ::io::substrait::Rel* AggregateRel::release_input() { +inline ::io::substrait::extensions::AdvancedExtension* SetRel::release_advanced_extension() { - ::io::substrait::Rel* temp = input_; - input_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* AggregateRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.input) +inline ::io::substrait::extensions::AdvancedExtension* SetRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:io.substrait.SetRel.advanced_extension) - ::io::substrait::Rel* temp = input_; - input_ = nullptr; + ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::Rel* AggregateRel::_internal_mutable_input() { +inline ::io::substrait::extensions::AdvancedExtension* SetRel::_internal_mutable_advanced_extension() { - if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); - input_ = p; + if (advanced_extension_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + advanced_extension_ = p; } - return input_; + return advanced_extension_; } -inline ::io::substrait::Rel* AggregateRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.input) - return _internal_mutable_input(); +inline ::io::substrait::extensions::AdvancedExtension* SetRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:io.substrait.SetRel.advanced_extension) + return _internal_mutable_advanced_extension(); } -inline void AggregateRel::set_allocated_input(::io::substrait::Rel* input) { +inline void SetRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete input_; + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } - if (input) { + if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); if (message_arena != submessage_arena) { - input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, input, submessage_arena); + advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, advanced_extension, submessage_arena); } } else { } - input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.input) -} - -// repeated .io.substrait.AggregateRel.Grouping groupings = 3; -inline int AggregateRel::_internal_groupings_size() const { - return groupings_.size(); -} -inline int AggregateRel::groupings_size() const { - return _internal_groupings_size(); -} -inline void AggregateRel::clear_groupings() { - groupings_.Clear(); -} -inline ::io::substrait::AggregateRel_Grouping* AggregateRel::mutable_groupings(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.groupings) - return groupings_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >* -AggregateRel::mutable_groupings() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.groupings) - return &groupings_; -} -inline const ::io::substrait::AggregateRel_Grouping& AggregateRel::_internal_groupings(int index) const { - return groupings_.Get(index); -} -inline const ::io::substrait::AggregateRel_Grouping& AggregateRel::groupings(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.groupings) - return _internal_groupings(index); -} -inline ::io::substrait::AggregateRel_Grouping* AggregateRel::_internal_add_groupings() { - return groupings_.Add(); -} -inline ::io::substrait::AggregateRel_Grouping* AggregateRel::add_groupings() { - // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.groupings) - return _internal_add_groupings(); -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >& -AggregateRel::groupings() const { - // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.groupings) - return groupings_; -} - -// repeated .io.substrait.AggregateRel.Measure measures = 4; -inline int AggregateRel::_internal_measures_size() const { - return measures_.size(); -} -inline int AggregateRel::measures_size() const { - return _internal_measures_size(); -} -inline void AggregateRel::clear_measures() { - measures_.Clear(); -} -inline ::io::substrait::AggregateRel_Measure* AggregateRel::mutable_measures(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.measures) - return measures_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >* -AggregateRel::mutable_measures() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.measures) - return &measures_; -} -inline const ::io::substrait::AggregateRel_Measure& AggregateRel::_internal_measures(int index) const { - return measures_.Get(index); -} -inline const ::io::substrait::AggregateRel_Measure& AggregateRel::measures(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.measures) - return _internal_measures(index); -} -inline ::io::substrait::AggregateRel_Measure* AggregateRel::_internal_add_measures() { - return measures_.Add(); -} -inline ::io::substrait::AggregateRel_Measure* AggregateRel::add_measures() { - // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.measures) - return _internal_add_measures(); -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >& -AggregateRel::measures() const { - // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.measures) - return measures_; -} - -// .io.substrait.Expression.AggregationPhase phase = 5; -inline void AggregateRel::clear_phase() { - phase_ = 0; -} -inline ::io::substrait::Expression_AggregationPhase AggregateRel::_internal_phase() const { - return static_cast< ::io::substrait::Expression_AggregationPhase >(phase_); -} -inline ::io::substrait::Expression_AggregationPhase AggregateRel::phase() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.phase) - return _internal_phase(); -} -inline void AggregateRel::_internal_set_phase(::io::substrait::Expression_AggregationPhase value) { - - phase_ = value; -} -inline void AggregateRel::set_phase(::io::substrait::Expression_AggregationPhase value) { - _internal_set_phase(value); - // @@protoc_insertion_point(field_set:io.substrait.AggregateRel.phase) + advanced_extension_ = advanced_extension; + // @@protoc_insertion_point(field_set_allocated:io.substrait.SetRel.advanced_extension) } // ------------------------------------------------------------------- -// SortRel +// ExtensionSingleRel // .io.substrait.RelCommon common = 1; -inline bool SortRel::_internal_has_common() const { +inline bool ExtensionSingleRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } -inline bool SortRel::has_common() const { +inline bool ExtensionSingleRel::has_common() const { return _internal_has_common(); } -inline void SortRel::clear_common() { +inline void ExtensionSingleRel::clear_common() { if (GetArena() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; } -inline const ::io::substrait::RelCommon& SortRel::_internal_common() const { +inline const ::io::substrait::RelCommon& ExtensionSingleRel::_internal_common() const { const ::io::substrait::RelCommon* p = common_; return p != nullptr ? *p : reinterpret_cast( ::io::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& SortRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.SortRel.common) +inline const ::io::substrait::RelCommon& ExtensionSingleRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.ExtensionSingleRel.common) return _internal_common(); } -inline void SortRel::unsafe_arena_set_allocated_common( +inline void ExtensionSingleRel::unsafe_arena_set_allocated_common( ::io::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); @@ -7079,9 +10096,9 @@ inline void SortRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionSingleRel.common) } -inline ::io::substrait::RelCommon* SortRel::release_common() { +inline ::io::substrait::RelCommon* ExtensionSingleRel::release_common() { ::io::substrait::RelCommon* temp = common_; common_ = nullptr; @@ -7090,14 +10107,14 @@ inline ::io::substrait::RelCommon* SortRel::release_common() { } return temp; } -inline ::io::substrait::RelCommon* SortRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.SortRel.common) +inline ::io::substrait::RelCommon* ExtensionSingleRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.ExtensionSingleRel.common) ::io::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* SortRel::_internal_mutable_common() { +inline ::io::substrait::RelCommon* ExtensionSingleRel::_internal_mutable_common() { if (common_ == nullptr) { auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); @@ -7105,11 +10122,11 @@ inline ::io::substrait::RelCommon* SortRel::_internal_mutable_common() { } return common_; } -inline ::io::substrait::RelCommon* SortRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.common) +inline ::io::substrait::RelCommon* ExtensionSingleRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionSingleRel.common) return _internal_mutable_common(); } -inline void SortRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void ExtensionSingleRel::set_allocated_common(::io::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -7126,32 +10143,32 @@ inline void SortRel::set_allocated_common(::io::substrait::RelCommon* common) { } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.SortRel.common) + // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionSingleRel.common) } // .io.substrait.Rel input = 2; -inline bool SortRel::_internal_has_input() const { +inline bool ExtensionSingleRel::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } -inline bool SortRel::has_input() const { +inline bool ExtensionSingleRel::has_input() const { return _internal_has_input(); } -inline void SortRel::clear_input() { +inline void ExtensionSingleRel::clear_input() { if (GetArena() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; } -inline const ::io::substrait::Rel& SortRel::_internal_input() const { +inline const ::io::substrait::Rel& ExtensionSingleRel::_internal_input() const { const ::io::substrait::Rel* p = input_; return p != nullptr ? *p : reinterpret_cast( ::io::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& SortRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.SortRel.input) +inline const ::io::substrait::Rel& ExtensionSingleRel::input() const { + // @@protoc_insertion_point(field_get:io.substrait.ExtensionSingleRel.input) return _internal_input(); } -inline void SortRel::unsafe_arena_set_allocated_input( +inline void ExtensionSingleRel::unsafe_arena_set_allocated_input( ::io::substrait::Rel* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); @@ -7162,9 +10179,9 @@ inline void SortRel::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionSingleRel.input) } -inline ::io::substrait::Rel* SortRel::release_input() { +inline ::io::substrait::Rel* ExtensionSingleRel::release_input() { ::io::substrait::Rel* temp = input_; input_ = nullptr; @@ -7173,14 +10190,14 @@ inline ::io::substrait::Rel* SortRel::release_input() { } return temp; } -inline ::io::substrait::Rel* SortRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.SortRel.input) +inline ::io::substrait::Rel* ExtensionSingleRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.ExtensionSingleRel.input) ::io::substrait::Rel* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Rel* SortRel::_internal_mutable_input() { +inline ::io::substrait::Rel* ExtensionSingleRel::_internal_mutable_input() { if (input_ == nullptr) { auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); @@ -7188,11 +10205,11 @@ inline ::io::substrait::Rel* SortRel::_internal_mutable_input() { } return input_; } -inline ::io::substrait::Rel* SortRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.input) +inline ::io::substrait::Rel* ExtensionSingleRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionSingleRel.input) return _internal_mutable_input(); } -inline void SortRel::set_allocated_input(::io::substrait::Rel* input) { +inline void ExtensionSingleRel::set_allocated_input(::io::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -7209,72 +10226,113 @@ inline void SortRel::set_allocated_input(::io::substrait::Rel* input) { } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.SortRel.input) + // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionSingleRel.input) } -// repeated .io.substrait.Expression.SortField sorts = 3; -inline int SortRel::_internal_sorts_size() const { - return sorts_.size(); +// .google.protobuf.Any detail = 3; +inline bool ExtensionSingleRel::_internal_has_detail() const { + return this != internal_default_instance() && detail_ != nullptr; } -inline int SortRel::sorts_size() const { - return _internal_sorts_size(); +inline bool ExtensionSingleRel::has_detail() const { + return _internal_has_detail(); } -inline ::io::substrait::Expression_SortField* SortRel::mutable_sorts(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.sorts) - return sorts_.Mutable(index); +inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::_internal_detail() const { + const PROTOBUF_NAMESPACE_ID::Any* p = detail_; + return p != nullptr ? *p : reinterpret_cast( + PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >* -SortRel::mutable_sorts() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.SortRel.sorts) - return &sorts_; +inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::detail() const { + // @@protoc_insertion_point(field_get:io.substrait.ExtensionSingleRel.detail) + return _internal_detail(); } -inline const ::io::substrait::Expression_SortField& SortRel::_internal_sorts(int index) const { - return sorts_.Get(index); +inline void ExtensionSingleRel::unsafe_arena_set_allocated_detail( + PROTOBUF_NAMESPACE_ID::Any* detail) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); + } + detail_ = detail; + if (detail) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionSingleRel.detail) } -inline const ::io::substrait::Expression_SortField& SortRel::sorts(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.SortRel.sorts) - return _internal_sorts(index); +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::release_detail() { + + PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + detail_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline ::io::substrait::Expression_SortField* SortRel::_internal_add_sorts() { - return sorts_.Add(); +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::unsafe_arena_release_detail() { + // @@protoc_insertion_point(field_release:io.substrait.ExtensionSingleRel.detail) + + PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + detail_ = nullptr; + return temp; } -inline ::io::substrait::Expression_SortField* SortRel::add_sorts() { - // @@protoc_insertion_point(field_add:io.substrait.SortRel.sorts) - return _internal_add_sorts(); +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::_internal_mutable_detail() { + + if (detail_ == nullptr) { + auto* p = CreateMaybeMessage(GetArena()); + detail_ = p; + } + return detail_; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SortField >& -SortRel::sorts() const { - // @@protoc_insertion_point(field_list:io.substrait.SortRel.sorts) - return sorts_; +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::mutable_detail() { + // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionSingleRel.detail) + return _internal_mutable_detail(); +} +inline void ExtensionSingleRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); + } + if (detail) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)->GetArena(); + if (message_arena != submessage_arena) { + detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, detail, submessage_arena); + } + + } else { + + } + detail_ = detail; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionSingleRel.detail) } // ------------------------------------------------------------------- -// FilterRel +// ExtensionLeafRel // .io.substrait.RelCommon common = 1; -inline bool FilterRel::_internal_has_common() const { +inline bool ExtensionLeafRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } -inline bool FilterRel::has_common() const { +inline bool ExtensionLeafRel::has_common() const { return _internal_has_common(); } -inline void FilterRel::clear_common() { +inline void ExtensionLeafRel::clear_common() { if (GetArena() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; } -inline const ::io::substrait::RelCommon& FilterRel::_internal_common() const { +inline const ::io::substrait::RelCommon& ExtensionLeafRel::_internal_common() const { const ::io::substrait::RelCommon* p = common_; return p != nullptr ? *p : reinterpret_cast( ::io::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& FilterRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.FilterRel.common) +inline const ::io::substrait::RelCommon& ExtensionLeafRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.ExtensionLeafRel.common) return _internal_common(); } -inline void FilterRel::unsafe_arena_set_allocated_common( +inline void ExtensionLeafRel::unsafe_arena_set_allocated_common( ::io::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); @@ -7285,9 +10343,9 @@ inline void FilterRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionLeafRel.common) } -inline ::io::substrait::RelCommon* FilterRel::release_common() { +inline ::io::substrait::RelCommon* ExtensionLeafRel::release_common() { ::io::substrait::RelCommon* temp = common_; common_ = nullptr; @@ -7296,14 +10354,14 @@ inline ::io::substrait::RelCommon* FilterRel::release_common() { } return temp; } -inline ::io::substrait::RelCommon* FilterRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.FilterRel.common) +inline ::io::substrait::RelCommon* ExtensionLeafRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.ExtensionLeafRel.common) ::io::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* FilterRel::_internal_mutable_common() { +inline ::io::substrait::RelCommon* ExtensionLeafRel::_internal_mutable_common() { if (common_ == nullptr) { auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); @@ -7311,11 +10369,11 @@ inline ::io::substrait::RelCommon* FilterRel::_internal_mutable_common() { } return common_; } -inline ::io::substrait::RelCommon* FilterRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.common) +inline ::io::substrait::RelCommon* ExtensionLeafRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionLeafRel.common) return _internal_mutable_common(); } -inline void FilterRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void ExtensionLeafRel::set_allocated_common(::io::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -7332,313 +10390,448 @@ inline void FilterRel::set_allocated_common(::io::substrait::RelCommon* common) } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.common) + // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionLeafRel.common) } -// .io.substrait.Rel input = 2; -inline bool FilterRel::_internal_has_input() const { - return this != internal_default_instance() && input_ != nullptr; +// .google.protobuf.Any detail = 2; +inline bool ExtensionLeafRel::_internal_has_detail() const { + return this != internal_default_instance() && detail_ != nullptr; } -inline bool FilterRel::has_input() const { - return _internal_has_input(); +inline bool ExtensionLeafRel::has_detail() const { + return _internal_has_detail(); } -inline void FilterRel::clear_input() { - if (GetArena() == nullptr && input_ != nullptr) { - delete input_; +inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::_internal_detail() const { + const PROTOBUF_NAMESPACE_ID::Any* p = detail_; + return p != nullptr ? *p : reinterpret_cast( + PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +} +inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::detail() const { + // @@protoc_insertion_point(field_get:io.substrait.ExtensionLeafRel.detail) + return _internal_detail(); +} +inline void ExtensionLeafRel::unsafe_arena_set_allocated_detail( + PROTOBUF_NAMESPACE_ID::Any* detail) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } - input_ = nullptr; + detail_ = detail; + if (detail) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionLeafRel.detail) } -inline const ::io::substrait::Rel& FilterRel::_internal_input() const { - const ::io::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::release_detail() { + + PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + detail_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; } -inline const ::io::substrait::Rel& FilterRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.FilterRel.input) - return _internal_input(); +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::unsafe_arena_release_detail() { + // @@protoc_insertion_point(field_release:io.substrait.ExtensionLeafRel.detail) + + PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + detail_ = nullptr; + return temp; } -inline void FilterRel::unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input) { +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::_internal_mutable_detail() { + + if (detail_ == nullptr) { + auto* p = CreateMaybeMessage(GetArena()); + detail_ = p; + } + return detail_; +} +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::mutable_detail() { + // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionLeafRel.detail) + return _internal_mutable_detail(); +} +inline void ExtensionLeafRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); + } + if (detail) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)->GetArena(); + if (message_arena != submessage_arena) { + detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, detail, submessage_arena); + } + + } else { + + } + detail_ = detail; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionLeafRel.detail) +} + +// ------------------------------------------------------------------- + +// ExtensionMultiRel + +// .io.substrait.RelCommon common = 1; +inline bool ExtensionMultiRel::_internal_has_common() const { + return this != internal_default_instance() && common_ != nullptr; +} +inline bool ExtensionMultiRel::has_common() const { + return _internal_has_common(); +} +inline void ExtensionMultiRel::clear_common() { + if (GetArena() == nullptr && common_ != nullptr) { + delete common_; + } + common_ = nullptr; +} +inline const ::io::substrait::RelCommon& ExtensionMultiRel::_internal_common() const { + const ::io::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_RelCommon_default_instance_); +} +inline const ::io::substrait::RelCommon& ExtensionMultiRel::common() const { + // @@protoc_insertion_point(field_get:io.substrait.ExtensionMultiRel.common) + return _internal_common(); +} +inline void ExtensionMultiRel::unsafe_arena_set_allocated_common( + ::io::substrait::RelCommon* common) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } - input_ = input; - if (input) { + common_ = common; + if (common) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionMultiRel.common) } -inline ::io::substrait::Rel* FilterRel::release_input() { +inline ::io::substrait::RelCommon* ExtensionMultiRel::release_common() { - ::io::substrait::Rel* temp = input_; - input_ = nullptr; + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* FilterRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.FilterRel.input) +inline ::io::substrait::RelCommon* ExtensionMultiRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:io.substrait.ExtensionMultiRel.common) - ::io::substrait::Rel* temp = input_; - input_ = nullptr; + ::io::substrait::RelCommon* temp = common_; + common_ = nullptr; return temp; } -inline ::io::substrait::Rel* FilterRel::_internal_mutable_input() { +inline ::io::substrait::RelCommon* ExtensionMultiRel::_internal_mutable_common() { - if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); - input_ = p; + if (common_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + common_ = p; } - return input_; + return common_; } -inline ::io::substrait::Rel* FilterRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.input) - return _internal_mutable_input(); +inline ::io::substrait::RelCommon* ExtensionMultiRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionMultiRel.common) + return _internal_mutable_common(); } -inline void FilterRel::set_allocated_input(::io::substrait::Rel* input) { +inline void ExtensionMultiRel::set_allocated_common(::io::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete input_; + delete common_; } - if (input) { + if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); if (message_arena != submessage_arena) { - input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, input, submessage_arena); + common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, common, submessage_arena); } } else { } - input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.input) + common_ = common; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionMultiRel.common) } -// .io.substrait.Expression condition = 3; -inline bool FilterRel::_internal_has_condition() const { - return this != internal_default_instance() && condition_ != nullptr; +// repeated .io.substrait.Rel inputs = 2; +inline int ExtensionMultiRel::_internal_inputs_size() const { + return inputs_.size(); } -inline bool FilterRel::has_condition() const { - return _internal_has_condition(); +inline int ExtensionMultiRel::inputs_size() const { + return _internal_inputs_size(); } -inline const ::io::substrait::Expression& FilterRel::_internal_condition() const { - const ::io::substrait::Expression* p = condition_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline void ExtensionMultiRel::clear_inputs() { + inputs_.Clear(); } -inline const ::io::substrait::Expression& FilterRel::condition() const { - // @@protoc_insertion_point(field_get:io.substrait.FilterRel.condition) - return _internal_condition(); +inline ::io::substrait::Rel* ExtensionMultiRel::mutable_inputs(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionMultiRel.inputs) + return inputs_.Mutable(index); } -inline void FilterRel::unsafe_arena_set_allocated_condition( - ::io::substrait::Expression* condition) { +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* +ExtensionMultiRel::mutable_inputs() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.ExtensionMultiRel.inputs) + return &inputs_; +} +inline const ::io::substrait::Rel& ExtensionMultiRel::_internal_inputs(int index) const { + return inputs_.Get(index); +} +inline const ::io::substrait::Rel& ExtensionMultiRel::inputs(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.ExtensionMultiRel.inputs) + return _internal_inputs(index); +} +inline ::io::substrait::Rel* ExtensionMultiRel::_internal_add_inputs() { + return inputs_.Add(); +} +inline ::io::substrait::Rel* ExtensionMultiRel::add_inputs() { + // @@protoc_insertion_point(field_add:io.substrait.ExtensionMultiRel.inputs) + return _internal_add_inputs(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& +ExtensionMultiRel::inputs() const { + // @@protoc_insertion_point(field_list:io.substrait.ExtensionMultiRel.inputs) + return inputs_; +} + +// .google.protobuf.Any detail = 3; +inline bool ExtensionMultiRel::_internal_has_detail() const { + return this != internal_default_instance() && detail_ != nullptr; +} +inline bool ExtensionMultiRel::has_detail() const { + return _internal_has_detail(); +} +inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::_internal_detail() const { + const PROTOBUF_NAMESPACE_ID::Any* p = detail_; + return p != nullptr ? *p : reinterpret_cast( + PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +} +inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::detail() const { + // @@protoc_insertion_point(field_get:io.substrait.ExtensionMultiRel.detail) + return _internal_detail(); +} +inline void ExtensionMultiRel::unsafe_arena_set_allocated_detail( + PROTOBUF_NAMESPACE_ID::Any* detail) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } - condition_ = condition; - if (condition) { + detail_ = detail; + if (detail) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.condition) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionMultiRel.detail) } -inline ::io::substrait::Expression* FilterRel::release_condition() { +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::release_detail() { - ::io::substrait::Expression* temp = condition_; - condition_ = nullptr; + PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + detail_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* FilterRel::unsafe_arena_release_condition() { - // @@protoc_insertion_point(field_release:io.substrait.FilterRel.condition) +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::unsafe_arena_release_detail() { + // @@protoc_insertion_point(field_release:io.substrait.ExtensionMultiRel.detail) - ::io::substrait::Expression* temp = condition_; - condition_ = nullptr; + PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + detail_ = nullptr; return temp; } -inline ::io::substrait::Expression* FilterRel::_internal_mutable_condition() { +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::_internal_mutable_detail() { - if (condition_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); - condition_ = p; + if (detail_ == nullptr) { + auto* p = CreateMaybeMessage(GetArena()); + detail_ = p; } - return condition_; + return detail_; } -inline ::io::substrait::Expression* FilterRel::mutable_condition() { - // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.condition) - return _internal_mutable_condition(); +inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::mutable_detail() { + // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionMultiRel.detail) + return _internal_mutable_detail(); } -inline void FilterRel::set_allocated_condition(::io::substrait::Expression* condition) { +inline void ExtensionMultiRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } - if (condition) { + if (detail) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition)->GetArena(); + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)->GetArena(); if (message_arena != submessage_arena) { - condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, condition, submessage_arena); + detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, detail, submessage_arena); } } else { } - condition_ = condition; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.condition) + detail_ = detail; + // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionMultiRel.detail) } // ------------------------------------------------------------------- -// SetRel +// RelRoot -// .io.substrait.RelCommon common = 1; -inline bool SetRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; +// .io.substrait.Rel input = 1; +inline bool RelRoot::_internal_has_input() const { + return this != internal_default_instance() && input_ != nullptr; } -inline bool SetRel::has_common() const { - return _internal_has_common(); +inline bool RelRoot::has_input() const { + return _internal_has_input(); } -inline void SetRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { - delete common_; +inline void RelRoot::clear_input() { + if (GetArena() == nullptr && input_ != nullptr) { + delete input_; } - common_ = nullptr; + input_ = nullptr; } -inline const ::io::substrait::RelCommon& SetRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::io::substrait::Rel& RelRoot::_internal_input() const { + const ::io::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Rel_default_instance_); } -inline const ::io::substrait::RelCommon& SetRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.SetRel.common) - return _internal_common(); +inline const ::io::substrait::Rel& RelRoot::input() const { + // @@protoc_insertion_point(field_get:io.substrait.RelRoot.input) + return _internal_input(); } -inline void SetRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { +inline void RelRoot::unsafe_arena_set_allocated_input( + ::io::substrait::Rel* input) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } - common_ = common; - if (common) { + input_ = input; + if (input) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SetRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelRoot.input) } -inline ::io::substrait::RelCommon* SetRel::release_common() { +inline ::io::substrait::Rel* RelRoot::release_input() { - ::io::substrait::RelCommon* temp = common_; - common_ = nullptr; + ::io::substrait::Rel* temp = input_; + input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* SetRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.SetRel.common) +inline ::io::substrait::Rel* RelRoot::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:io.substrait.RelRoot.input) - ::io::substrait::RelCommon* temp = common_; - common_ = nullptr; + ::io::substrait::Rel* temp = input_; + input_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* SetRel::_internal_mutable_common() { +inline ::io::substrait::Rel* RelRoot::_internal_mutable_input() { - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); - common_ = p; + if (input_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + input_ = p; } - return common_; + return input_; } -inline ::io::substrait::RelCommon* SetRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.SetRel.common) - return _internal_mutable_common(); +inline ::io::substrait::Rel* RelRoot::mutable_input() { + // @@protoc_insertion_point(field_mutable:io.substrait.RelRoot.input) + return _internal_mutable_input(); } -inline void SetRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void RelRoot::set_allocated_input(::io::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete common_; + delete input_; } - if (common) { + if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); + input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, input, submessage_arena); } } else { } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.SetRel.common) + input_ = input; + // @@protoc_insertion_point(field_set_allocated:io.substrait.RelRoot.input) } -// repeated .io.substrait.Rel inputs = 2; -inline int SetRel::_internal_inputs_size() const { - return inputs_.size(); +// repeated string names = 2; +inline int RelRoot::_internal_names_size() const { + return names_.size(); } -inline int SetRel::inputs_size() const { - return _internal_inputs_size(); +inline int RelRoot::names_size() const { + return _internal_names_size(); } -inline void SetRel::clear_inputs() { - inputs_.Clear(); +inline void RelRoot::clear_names() { + names_.Clear(); } -inline ::io::substrait::Rel* SetRel::mutable_inputs(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.SetRel.inputs) - return inputs_.Mutable(index); +inline std::string* RelRoot::add_names() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.RelRoot.names) + return _internal_add_names(); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* -SetRel::mutable_inputs() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.SetRel.inputs) - return &inputs_; +inline const std::string& RelRoot::_internal_names(int index) const { + return names_.Get(index); } -inline const ::io::substrait::Rel& SetRel::_internal_inputs(int index) const { - return inputs_.Get(index); +inline const std::string& RelRoot::names(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.RelRoot.names) + return _internal_names(index); } -inline const ::io::substrait::Rel& SetRel::inputs(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.SetRel.inputs) - return _internal_inputs(index); +inline std::string* RelRoot::mutable_names(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.RelRoot.names) + return names_.Mutable(index); } -inline ::io::substrait::Rel* SetRel::_internal_add_inputs() { - return inputs_.Add(); +inline void RelRoot::set_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.RelRoot.names) + names_.Mutable(index)->assign(value); } -inline ::io::substrait::Rel* SetRel::add_inputs() { - // @@protoc_insertion_point(field_add:io.substrait.SetRel.inputs) - return _internal_add_inputs(); +inline void RelRoot::set_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.RelRoot.names) + names_.Mutable(index)->assign(std::move(value)); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& -SetRel::inputs() const { - // @@protoc_insertion_point(field_list:io.substrait.SetRel.inputs) - return inputs_; +inline void RelRoot::set_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.RelRoot.names) } - -// .io.substrait.SetRel.SetOp op = 3; -inline void SetRel::clear_op() { - op_ = 0; +inline void RelRoot::set_names(int index, const char* value, size_t size) { + names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.RelRoot.names) } -inline ::io::substrait::SetRel_SetOp SetRel::_internal_op() const { - return static_cast< ::io::substrait::SetRel_SetOp >(op_); +inline std::string* RelRoot::_internal_add_names() { + return names_.Add(); } -inline ::io::substrait::SetRel_SetOp SetRel::op() const { - // @@protoc_insertion_point(field_get:io.substrait.SetRel.op) - return _internal_op(); +inline void RelRoot::add_names(const std::string& value) { + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.RelRoot.names) } -inline void SetRel::_internal_set_op(::io::substrait::SetRel_SetOp value) { - - op_ = value; +inline void RelRoot::add_names(std::string&& value) { + names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.RelRoot.names) } -inline void SetRel::set_op(::io::substrait::SetRel_SetOp value) { - _internal_set_op(value); - // @@protoc_insertion_point(field_set:io.substrait.SetRel.op) +inline void RelRoot::add_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.RelRoot.names) +} +inline void RelRoot::add_names(const char* value, size_t size) { + names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.RelRoot.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +RelRoot::names() const { + // @@protoc_insertion_point(field_list:io.substrait.RelRoot.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +RelRoot::mutable_names() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.RelRoot.names) + return &names_; } // ------------------------------------------------------------------- @@ -8229,6 +11422,225 @@ inline ::io::substrait::SetRel* Rel::mutable_set() { return _internal_mutable_set(); } +// .io.substrait.ExtensionSingleRel extension_single = 9; +inline bool Rel::_internal_has_extension_single() const { + return RelType_case() == kExtensionSingle; +} +inline bool Rel::has_extension_single() const { + return _internal_has_extension_single(); +} +inline void Rel::set_has_extension_single() { + _oneof_case_[0] = kExtensionSingle; +} +inline void Rel::clear_extension_single() { + if (_internal_has_extension_single()) { + if (GetArena() == nullptr) { + delete RelType_.extension_single_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::ExtensionSingleRel* Rel::release_extension_single() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.extension_single) + if (_internal_has_extension_single()) { + clear_has_RelType(); + ::io::substrait::ExtensionSingleRel* temp = RelType_.extension_single_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.extension_single_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ExtensionSingleRel& Rel::_internal_extension_single() const { + return _internal_has_extension_single() + ? *RelType_.extension_single_ + : reinterpret_cast< ::io::substrait::ExtensionSingleRel&>(::io::substrait::_ExtensionSingleRel_default_instance_); +} +inline const ::io::substrait::ExtensionSingleRel& Rel::extension_single() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.extension_single) + return _internal_extension_single(); +} +inline ::io::substrait::ExtensionSingleRel* Rel::unsafe_arena_release_extension_single() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.extension_single) + if (_internal_has_extension_single()) { + clear_has_RelType(); + ::io::substrait::ExtensionSingleRel* temp = RelType_.extension_single_; + RelType_.extension_single_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_extension_single(::io::substrait::ExtensionSingleRel* extension_single) { + clear_RelType(); + if (extension_single) { + set_has_extension_single(); + RelType_.extension_single_ = extension_single; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.extension_single) +} +inline ::io::substrait::ExtensionSingleRel* Rel::_internal_mutable_extension_single() { + if (!_internal_has_extension_single()) { + clear_RelType(); + set_has_extension_single(); + RelType_.extension_single_ = CreateMaybeMessage< ::io::substrait::ExtensionSingleRel >(GetArena()); + } + return RelType_.extension_single_; +} +inline ::io::substrait::ExtensionSingleRel* Rel::mutable_extension_single() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.extension_single) + return _internal_mutable_extension_single(); +} + +// .io.substrait.ExtensionMultiRel extension_multi = 10; +inline bool Rel::_internal_has_extension_multi() const { + return RelType_case() == kExtensionMulti; +} +inline bool Rel::has_extension_multi() const { + return _internal_has_extension_multi(); +} +inline void Rel::set_has_extension_multi() { + _oneof_case_[0] = kExtensionMulti; +} +inline void Rel::clear_extension_multi() { + if (_internal_has_extension_multi()) { + if (GetArena() == nullptr) { + delete RelType_.extension_multi_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::ExtensionMultiRel* Rel::release_extension_multi() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.extension_multi) + if (_internal_has_extension_multi()) { + clear_has_RelType(); + ::io::substrait::ExtensionMultiRel* temp = RelType_.extension_multi_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.extension_multi_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ExtensionMultiRel& Rel::_internal_extension_multi() const { + return _internal_has_extension_multi() + ? *RelType_.extension_multi_ + : reinterpret_cast< ::io::substrait::ExtensionMultiRel&>(::io::substrait::_ExtensionMultiRel_default_instance_); +} +inline const ::io::substrait::ExtensionMultiRel& Rel::extension_multi() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.extension_multi) + return _internal_extension_multi(); +} +inline ::io::substrait::ExtensionMultiRel* Rel::unsafe_arena_release_extension_multi() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.extension_multi) + if (_internal_has_extension_multi()) { + clear_has_RelType(); + ::io::substrait::ExtensionMultiRel* temp = RelType_.extension_multi_; + RelType_.extension_multi_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_extension_multi(::io::substrait::ExtensionMultiRel* extension_multi) { + clear_RelType(); + if (extension_multi) { + set_has_extension_multi(); + RelType_.extension_multi_ = extension_multi; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.extension_multi) +} +inline ::io::substrait::ExtensionMultiRel* Rel::_internal_mutable_extension_multi() { + if (!_internal_has_extension_multi()) { + clear_RelType(); + set_has_extension_multi(); + RelType_.extension_multi_ = CreateMaybeMessage< ::io::substrait::ExtensionMultiRel >(GetArena()); + } + return RelType_.extension_multi_; +} +inline ::io::substrait::ExtensionMultiRel* Rel::mutable_extension_multi() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.extension_multi) + return _internal_mutable_extension_multi(); +} + +// .io.substrait.ExtensionLeafRel extension_leaf = 11; +inline bool Rel::_internal_has_extension_leaf() const { + return RelType_case() == kExtensionLeaf; +} +inline bool Rel::has_extension_leaf() const { + return _internal_has_extension_leaf(); +} +inline void Rel::set_has_extension_leaf() { + _oneof_case_[0] = kExtensionLeaf; +} +inline void Rel::clear_extension_leaf() { + if (_internal_has_extension_leaf()) { + if (GetArena() == nullptr) { + delete RelType_.extension_leaf_; + } + clear_has_RelType(); + } +} +inline ::io::substrait::ExtensionLeafRel* Rel::release_extension_leaf() { + // @@protoc_insertion_point(field_release:io.substrait.Rel.extension_leaf) + if (_internal_has_extension_leaf()) { + clear_has_RelType(); + ::io::substrait::ExtensionLeafRel* temp = RelType_.extension_leaf_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + RelType_.extension_leaf_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::ExtensionLeafRel& Rel::_internal_extension_leaf() const { + return _internal_has_extension_leaf() + ? *RelType_.extension_leaf_ + : reinterpret_cast< ::io::substrait::ExtensionLeafRel&>(::io::substrait::_ExtensionLeafRel_default_instance_); +} +inline const ::io::substrait::ExtensionLeafRel& Rel::extension_leaf() const { + // @@protoc_insertion_point(field_get:io.substrait.Rel.extension_leaf) + return _internal_extension_leaf(); +} +inline ::io::substrait::ExtensionLeafRel* Rel::unsafe_arena_release_extension_leaf() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.extension_leaf) + if (_internal_has_extension_leaf()) { + clear_has_RelType(); + ::io::substrait::ExtensionLeafRel* temp = RelType_.extension_leaf_; + RelType_.extension_leaf_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Rel::unsafe_arena_set_allocated_extension_leaf(::io::substrait::ExtensionLeafRel* extension_leaf) { + clear_RelType(); + if (extension_leaf) { + set_has_extension_leaf(); + RelType_.extension_leaf_ = extension_leaf; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.extension_leaf) +} +inline ::io::substrait::ExtensionLeafRel* Rel::_internal_mutable_extension_leaf() { + if (!_internal_has_extension_leaf()) { + clear_RelType(); + set_has_extension_leaf(); + RelType_.extension_leaf_ = CreateMaybeMessage< ::io::substrait::ExtensionLeafRel >(GetArena()); + } + return RelType_.extension_leaf_; +} +inline ::io::substrait::ExtensionLeafRel* Rel::mutable_extension_leaf() { + // @@protoc_insertion_point(field_mutable:io.substrait.Rel.extension_leaf) + return _internal_mutable_extension_leaf(); +} + inline bool Rel::has_RelType() const { return RelType_case() != RELTYPE_NOT_SET; } @@ -8283,6 +11695,14 @@ inline Rel::RelTypeCase Rel::RelType_case() const { // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/cpp/src/generated/substrait/selection.pb.cc b/cpp/src/generated/substrait/selection.pb.cc deleted file mode 100644 index b72534670dc..00000000000 --- a/cpp/src/generated/substrait/selection.pb.cc +++ /dev/null @@ -1,5326 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: selection.proto - -#include "selection.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace io { -namespace substrait { -constexpr ReferenceSegment_MapKey::ReferenceSegment_MapKey( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : map_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , child_(nullptr){} -struct ReferenceSegment_MapKeyDefaultTypeInternal { - constexpr ReferenceSegment_MapKeyDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReferenceSegment_MapKeyDefaultTypeInternal() {} - union { - ReferenceSegment_MapKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegment_MapKeyDefaultTypeInternal _ReferenceSegment_MapKey_default_instance_; -constexpr ReferenceSegment_MapKeyExpression::ReferenceSegment_MapKeyExpression( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : map_key_expression_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , child_(nullptr){} -struct ReferenceSegment_MapKeyExpressionDefaultTypeInternal { - constexpr ReferenceSegment_MapKeyExpressionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReferenceSegment_MapKeyExpressionDefaultTypeInternal() {} - union { - ReferenceSegment_MapKeyExpression _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegment_MapKeyExpressionDefaultTypeInternal _ReferenceSegment_MapKeyExpression_default_instance_; -constexpr ReferenceSegment_StructField::ReferenceSegment_StructField( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : child_(nullptr) - , field_(0){} -struct ReferenceSegment_StructFieldDefaultTypeInternal { - constexpr ReferenceSegment_StructFieldDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReferenceSegment_StructFieldDefaultTypeInternal() {} - union { - ReferenceSegment_StructField _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegment_StructFieldDefaultTypeInternal _ReferenceSegment_StructField_default_instance_; -constexpr ReferenceSegment_ListElement::ReferenceSegment_ListElement( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : child_(nullptr) - , offset_(0){} -struct ReferenceSegment_ListElementDefaultTypeInternal { - constexpr ReferenceSegment_ListElementDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReferenceSegment_ListElementDefaultTypeInternal() {} - union { - ReferenceSegment_ListElement _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegment_ListElementDefaultTypeInternal _ReferenceSegment_ListElement_default_instance_; -constexpr ReferenceSegment_ListRange::ReferenceSegment_ListRange( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : child_(nullptr) - , start_(0) - , end_(0){} -struct ReferenceSegment_ListRangeDefaultTypeInternal { - constexpr ReferenceSegment_ListRangeDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReferenceSegment_ListRangeDefaultTypeInternal() {} - union { - ReferenceSegment_ListRange _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegment_ListRangeDefaultTypeInternal _ReferenceSegment_ListRange_default_instance_; -constexpr ReferenceSegment::ReferenceSegment( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct ReferenceSegmentDefaultTypeInternal { - constexpr ReferenceSegmentDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReferenceSegmentDefaultTypeInternal() {} - union { - ReferenceSegment _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReferenceSegmentDefaultTypeInternal _ReferenceSegment_default_instance_; -constexpr MaskExpression_Select::MaskExpression_Select( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct MaskExpression_SelectDefaultTypeInternal { - constexpr MaskExpression_SelectDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpression_SelectDefaultTypeInternal() {} - union { - MaskExpression_Select _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_SelectDefaultTypeInternal _MaskExpression_Select_default_instance_; -constexpr MaskExpression_StructSelect::MaskExpression_StructSelect( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : struct_items_(){} -struct MaskExpression_StructSelectDefaultTypeInternal { - constexpr MaskExpression_StructSelectDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpression_StructSelectDefaultTypeInternal() {} - union { - MaskExpression_StructSelect _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_StructSelectDefaultTypeInternal _MaskExpression_StructSelect_default_instance_; -constexpr MaskExpression_StructItem::MaskExpression_StructItem( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : child_(nullptr) - , field_(0){} -struct MaskExpression_StructItemDefaultTypeInternal { - constexpr MaskExpression_StructItemDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpression_StructItemDefaultTypeInternal() {} - union { - MaskExpression_StructItem _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_StructItemDefaultTypeInternal _MaskExpression_StructItem_default_instance_; -constexpr MaskExpression_ListSelect_ListSelectItem_ListElement::MaskExpression_ListSelect_ListSelectItem_ListElement( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : field_(0){} -struct MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal { - constexpr MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal() {} - union { - MaskExpression_ListSelect_ListSelectItem_ListElement _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_; -constexpr MaskExpression_ListSelect_ListSelectItem_ListSlice::MaskExpression_ListSelect_ListSelectItem_ListSlice( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : start_(0) - , end_(0){} -struct MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal { - constexpr MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal() {} - union { - MaskExpression_ListSelect_ListSelectItem_ListSlice _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_; -constexpr MaskExpression_ListSelect_ListSelectItem::MaskExpression_ListSelect_ListSelectItem( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal { - constexpr MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal() {} - union { - MaskExpression_ListSelect_ListSelectItem _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_default_instance_; -constexpr MaskExpression_ListSelect::MaskExpression_ListSelect( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : selection_() - , child_(nullptr){} -struct MaskExpression_ListSelectDefaultTypeInternal { - constexpr MaskExpression_ListSelectDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpression_ListSelectDefaultTypeInternal() {} - union { - MaskExpression_ListSelect _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_ListSelectDefaultTypeInternal _MaskExpression_ListSelect_default_instance_; -constexpr MaskExpression_MapSelect_MapKey::MaskExpression_MapSelect_MapKey( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : map_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct MaskExpression_MapSelect_MapKeyDefaultTypeInternal { - constexpr MaskExpression_MapSelect_MapKeyDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpression_MapSelect_MapKeyDefaultTypeInternal() {} - union { - MaskExpression_MapSelect_MapKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_MapSelect_MapKeyDefaultTypeInternal _MaskExpression_MapSelect_MapKey_default_instance_; -constexpr MaskExpression_MapSelect_MapKeyExpression::MaskExpression_MapSelect_MapKeyExpression( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : map_key_expression_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal { - constexpr MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal() {} - union { - MaskExpression_MapSelect_MapKeyExpression _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _MaskExpression_MapSelect_MapKeyExpression_default_instance_; -constexpr MaskExpression_MapSelect::MaskExpression_MapSelect( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : child_(nullptr) - , _oneof_case_{}{} -struct MaskExpression_MapSelectDefaultTypeInternal { - constexpr MaskExpression_MapSelectDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpression_MapSelectDefaultTypeInternal() {} - union { - MaskExpression_MapSelect _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpression_MapSelectDefaultTypeInternal _MaskExpression_MapSelect_default_instance_; -constexpr MaskExpression::MaskExpression( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : select_(nullptr) - , maintain_singular_struct_(false){} -struct MaskExpressionDefaultTypeInternal { - constexpr MaskExpressionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~MaskExpressionDefaultTypeInternal() {} - union { - MaskExpression _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT MaskExpressionDefaultTypeInternal _MaskExpression_default_instance_; -constexpr FieldReference::FieldReference( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct FieldReferenceDefaultTypeInternal { - constexpr FieldReferenceDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FieldReferenceDefaultTypeInternal() {} - union { - FieldReference _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FieldReferenceDefaultTypeInternal _FieldReference_default_instance_; -} // namespace substrait -} // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_selection_2eproto[18]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_selection_2eproto = nullptr; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_selection_2eproto = nullptr; - -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_selection_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKey, map_key_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKey, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKeyExpression, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKeyExpression, map_key_expression_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_MapKeyExpression, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_StructField, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_StructField, field_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_StructField, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListElement, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListElement, offset_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListElement, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListRange, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListRange, start_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListRange, end_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment_ListRange, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::ReferenceSegment, reference_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_Select, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_Select, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_Select, type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_StructSelect, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_StructSelect, struct_items_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_StructItem, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_StructItem, field_), - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_StructItem, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement, field_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice, start_), - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice, end_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect_ListSelectItem, type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect, selection_), - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_ListSelect, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect_MapKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect_MapKey, map_key_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect_MapKeyExpression, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect_MapKeyExpression, map_key_expression_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect, child_), - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression_MapSelect, select_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression, select_), - PROTOBUF_FIELD_OFFSET(::io::substrait::MaskExpression, maintain_singular_struct_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FieldReference, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FieldReference, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::FieldReference, reference_type_), -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::ReferenceSegment_MapKey)}, - { 7, -1, sizeof(::io::substrait::ReferenceSegment_MapKeyExpression)}, - { 14, -1, sizeof(::io::substrait::ReferenceSegment_StructField)}, - { 21, -1, sizeof(::io::substrait::ReferenceSegment_ListElement)}, - { 28, -1, sizeof(::io::substrait::ReferenceSegment_ListRange)}, - { 36, -1, sizeof(::io::substrait::ReferenceSegment)}, - { 47, -1, sizeof(::io::substrait::MaskExpression_Select)}, - { 56, -1, sizeof(::io::substrait::MaskExpression_StructSelect)}, - { 62, -1, sizeof(::io::substrait::MaskExpression_StructItem)}, - { 69, -1, sizeof(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement)}, - { 75, -1, sizeof(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice)}, - { 82, -1, sizeof(::io::substrait::MaskExpression_ListSelect_ListSelectItem)}, - { 90, -1, sizeof(::io::substrait::MaskExpression_ListSelect)}, - { 97, -1, sizeof(::io::substrait::MaskExpression_MapSelect_MapKey)}, - { 103, -1, sizeof(::io::substrait::MaskExpression_MapSelect_MapKeyExpression)}, - { 109, -1, sizeof(::io::substrait::MaskExpression_MapSelect)}, - { 118, -1, sizeof(::io::substrait::MaskExpression)}, - { 125, -1, sizeof(::io::substrait::FieldReference)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::_ReferenceSegment_MapKey_default_instance_), - reinterpret_cast(&::io::substrait::_ReferenceSegment_MapKeyExpression_default_instance_), - reinterpret_cast(&::io::substrait::_ReferenceSegment_StructField_default_instance_), - reinterpret_cast(&::io::substrait::_ReferenceSegment_ListElement_default_instance_), - reinterpret_cast(&::io::substrait::_ReferenceSegment_ListRange_default_instance_), - reinterpret_cast(&::io::substrait::_ReferenceSegment_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_Select_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_StructSelect_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_StructItem_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_ListSelect_ListSelectItem_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_ListSelect_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_MapSelect_MapKey_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_MapSelect_MapKeyExpression_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_MapSelect_default_instance_), - reinterpret_cast(&::io::substrait::_MaskExpression_default_instance_), - reinterpret_cast(&::io::substrait::_FieldReference_default_instance_), -}; - -const char descriptor_table_protodef_selection_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\017selection.proto\022\014io.substrait\"\211\006\n\020Refe" - "renceSegment\0228\n\007map_key\030\001 \001(\0132%.io.subst" - "rait.ReferenceSegment.MapKeyH\000\022E\n\nexpres" - "sion\030\002 \001(\0132/.io.substrait.ReferenceSegme" - "nt.MapKeyExpressionH\000\022B\n\014struct_field\030\003 " - "\001(\0132*.io.substrait.ReferenceSegment.Stru" - "ctFieldH\000\022B\n\014list_element\030\004 \001(\0132*.io.sub" - "strait.ReferenceSegment.ListElementH\000\022>\n" - "\nlist_range\030\005 \001(\0132(.io.substrait.Referen" - "ceSegment.ListRangeH\000\032H\n\006MapKey\022\017\n\007map_k" - "ey\030\001 \001(\t\022-\n\005child\030\002 \001(\0132\036.io.substrait.R" - "eferenceSegment\032]\n\020MapKeyExpression\022\032\n\022m" - "ap_key_expression\030\001 \001(\t\022-\n\005child\030\002 \001(\0132\036" - ".io.substrait.ReferenceSegment\032K\n\013Struct" - "Field\022\r\n\005field\030\001 \001(\005\022-\n\005child\030\002 \001(\0132\036.io" - ".substrait.ReferenceSegment\032L\n\013ListEleme" - "nt\022\016\n\006offset\030\001 \001(\005\022-\n\005child\030\002 \001(\0132\036.io.s" - "ubstrait.ReferenceSegment\032V\n\tListRange\022\r" - "\n\005start\030\001 \001(\005\022\013\n\003end\030\002 \001(\005\022-\n\005child\030\003 \001(" - "\0132\036.io.substrait.ReferenceSegmentB\020\n\016ref" - "erence_type\"\210\t\n\016MaskExpression\0229\n\006select" - "\030\001 \001(\0132).io.substrait.MaskExpression.Str" - "uctSelect\022 \n\030maintain_singular_struct\030\002 " - "\001(\010\032\275\001\n\006Select\022;\n\006struct\030\001 \001(\0132).io.subs" - "trait.MaskExpression.StructSelectH\000\0227\n\004l" - "ist\030\002 \001(\0132\'.io.substrait.MaskExpression." - "ListSelectH\000\0225\n\003map\030\003 \001(\0132&.io.substrait" - ".MaskExpression.MapSelectH\000B\006\n\004type\032M\n\014S" - "tructSelect\022=\n\014struct_items\030\001 \003(\0132\'.io.s" - "ubstrait.MaskExpression.StructItem\032O\n\nSt" - "ructItem\022\r\n\005field\030\001 \001(\005\0222\n\005child\030\002 \001(\0132#" - ".io.substrait.MaskExpression.Select\032\224\003\n\n" - "ListSelect\022I\n\tselection\030\001 \003(\01326.io.subst" - "rait.MaskExpression.ListSelect.ListSelec" - "tItem\0222\n\005child\030\002 \001(\0132#.io.substrait.Mask" - "Expression.Select\032\206\002\n\016ListSelectItem\022R\n\004" - "item\030\001 \001(\0132B.io.substrait.MaskExpression" - ".ListSelect.ListSelectItem.ListElementH\000" - "\022Q\n\005slice\030\002 \001(\0132@.io.substrait.MaskExpre" - "ssion.ListSelect.ListSelectItem.ListSlic" - "eH\000\032\034\n\013ListElement\022\r\n\005field\030\001 \001(\005\032\'\n\tLis" - "tSlice\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002 \001(\005B\006\n\004ty" - "pe\032\241\002\n\tMapSelect\022<\n\003key\030\001 \001(\0132-.io.subst" - "rait.MaskExpression.MapSelect.MapKeyH\000\022M" - "\n\nexpression\030\002 \001(\01327.io.substrait.MaskEx" - "pression.MapSelect.MapKeyExpressionH\000\0222\n" - "\005child\030\003 \001(\0132#.io.substrait.MaskExpressi" - "on.Select\032\031\n\006MapKey\022\017\n\007map_key\030\001 \001(\t\032.\n\020" - "MapKeyExpression\022\032\n\022map_key_expression\030\001" - " \001(\tB\010\n\006select\"\230\001\n\016FieldReference\022:\n\020dir" - "ect_reference\030\001 \001(\0132\036.io.substrait.Refer" - "enceSegmentH\000\0228\n\020masked_reference\030\002 \001(\0132" - "\034.io.substrait.MaskExpressionH\000B\020\n\016refer" - "ence_typeB\027P\001\252\002\022Substrait.Protobufb\006prot" - "o3" - ; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_selection_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_selection_2eproto = { - false, false, 2162, descriptor_table_protodef_selection_2eproto, "selection.proto", - &descriptor_table_selection_2eproto_once, nullptr, 0, 18, - schemas, file_default_instances, TableStruct_selection_2eproto::offsets, - file_level_metadata_selection_2eproto, file_level_enum_descriptors_selection_2eproto, file_level_service_descriptors_selection_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_selection_2eproto_getter() { - return &descriptor_table_selection_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_selection_2eproto(&descriptor_table_selection_2eproto); -namespace io { -namespace substrait { - -// =================================================================== - -class ReferenceSegment_MapKey::_Internal { - public: - static const ::io::substrait::ReferenceSegment& child(const ReferenceSegment_MapKey* msg); -}; - -const ::io::substrait::ReferenceSegment& -ReferenceSegment_MapKey::_Internal::child(const ReferenceSegment_MapKey* msg) { - return *msg->child_; -} -ReferenceSegment_MapKey::ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment.MapKey) -} -ReferenceSegment_MapKey::ReferenceSegment_MapKey(const ReferenceSegment_MapKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_map_key().empty()) { - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key(), - GetArena()); - } - if (from._internal_has_child()) { - child_ = new ::io::substrait::ReferenceSegment(*from.child_); - } else { - child_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment.MapKey) -} - -void ReferenceSegment_MapKey::SharedCtor() { -map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -child_ = nullptr; -} - -ReferenceSegment_MapKey::~ReferenceSegment_MapKey() { - // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment.MapKey) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void ReferenceSegment_MapKey::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - map_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (this != internal_default_instance()) delete child_; -} - -void ReferenceSegment_MapKey::ArenaDtor(void* object) { - ReferenceSegment_MapKey* _this = reinterpret_cast< ReferenceSegment_MapKey* >(object); - (void)_this; -} -void ReferenceSegment_MapKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReferenceSegment_MapKey::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReferenceSegment_MapKey::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment.MapKey) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - map_key_.ClearToEmpty(); - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReferenceSegment_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string map_key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_map_key(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReferenceSegment.MapKey.map_key")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.ReferenceSegment child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment_MapKey::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment.MapKey) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // string map_key = 1; - if (this->map_key().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_map_key().data(), static_cast(this->_internal_map_key().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.ReferenceSegment.MapKey.map_key"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_map_key(), target); - } - - // .io.substrait.ReferenceSegment child = 2; - if (this->has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment.MapKey) - return target; -} - -size_t ReferenceSegment_MapKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment.MapKey) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // string map_key = 1; - if (this->map_key().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_map_key()); - } - - // .io.substrait.ReferenceSegment child = 2; - if (this->has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void ReferenceSegment_MapKey::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment.MapKey) - GOOGLE_DCHECK_NE(&from, this); - const ReferenceSegment_MapKey* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment.MapKey) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment.MapKey) - MergeFrom(*source); - } -} - -void ReferenceSegment_MapKey::MergeFrom(const ReferenceSegment_MapKey& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment.MapKey) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.map_key().size() > 0) { - _internal_set_map_key(from._internal_map_key()); - } - if (from.has_child()) { - _internal_mutable_child()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_child()); - } -} - -void ReferenceSegment_MapKey::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment.MapKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void ReferenceSegment_MapKey::CopyFrom(const ReferenceSegment_MapKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment.MapKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReferenceSegment_MapKey::IsInitialized() const { - return true; -} - -void ReferenceSegment_MapKey::InternalSwap(ReferenceSegment_MapKey* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - map_key_.Swap(&other->map_key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - swap(child_, other->child_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment_MapKey::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[0]); -} - -// =================================================================== - -class ReferenceSegment_MapKeyExpression::_Internal { - public: - static const ::io::substrait::ReferenceSegment& child(const ReferenceSegment_MapKeyExpression* msg); -}; - -const ::io::substrait::ReferenceSegment& -ReferenceSegment_MapKeyExpression::_Internal::child(const ReferenceSegment_MapKeyExpression* msg) { - return *msg->child_; -} -ReferenceSegment_MapKeyExpression::ReferenceSegment_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment.MapKeyExpression) -} -ReferenceSegment_MapKeyExpression::ReferenceSegment_MapKeyExpression(const ReferenceSegment_MapKeyExpression& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_map_key_expression().empty()) { - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key_expression(), - GetArena()); - } - if (from._internal_has_child()) { - child_ = new ::io::substrait::ReferenceSegment(*from.child_); - } else { - child_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment.MapKeyExpression) -} - -void ReferenceSegment_MapKeyExpression::SharedCtor() { -map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -child_ = nullptr; -} - -ReferenceSegment_MapKeyExpression::~ReferenceSegment_MapKeyExpression() { - // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment.MapKeyExpression) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void ReferenceSegment_MapKeyExpression::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - map_key_expression_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (this != internal_default_instance()) delete child_; -} - -void ReferenceSegment_MapKeyExpression::ArenaDtor(void* object) { - ReferenceSegment_MapKeyExpression* _this = reinterpret_cast< ReferenceSegment_MapKeyExpression* >(object); - (void)_this; -} -void ReferenceSegment_MapKeyExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReferenceSegment_MapKeyExpression::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReferenceSegment_MapKeyExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment.MapKeyExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - map_key_expression_.ClearToEmpty(); - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReferenceSegment_MapKeyExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string map_key_expression = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_map_key_expression(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression")); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.ReferenceSegment child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment_MapKeyExpression::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment.MapKeyExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // string map_key_expression = 1; - if (this->map_key_expression().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_map_key_expression().data(), static_cast(this->_internal_map_key_expression().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_map_key_expression(), target); - } - - // .io.substrait.ReferenceSegment child = 2; - if (this->has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment.MapKeyExpression) - return target; -} - -size_t ReferenceSegment_MapKeyExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment.MapKeyExpression) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // string map_key_expression = 1; - if (this->map_key_expression().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_map_key_expression()); - } - - // .io.substrait.ReferenceSegment child = 2; - if (this->has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void ReferenceSegment_MapKeyExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment.MapKeyExpression) - GOOGLE_DCHECK_NE(&from, this); - const ReferenceSegment_MapKeyExpression* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment.MapKeyExpression) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment.MapKeyExpression) - MergeFrom(*source); - } -} - -void ReferenceSegment_MapKeyExpression::MergeFrom(const ReferenceSegment_MapKeyExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment.MapKeyExpression) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.map_key_expression().size() > 0) { - _internal_set_map_key_expression(from._internal_map_key_expression()); - } - if (from.has_child()) { - _internal_mutable_child()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_child()); - } -} - -void ReferenceSegment_MapKeyExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment.MapKeyExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void ReferenceSegment_MapKeyExpression::CopyFrom(const ReferenceSegment_MapKeyExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment.MapKeyExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReferenceSegment_MapKeyExpression::IsInitialized() const { - return true; -} - -void ReferenceSegment_MapKeyExpression::InternalSwap(ReferenceSegment_MapKeyExpression* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - map_key_expression_.Swap(&other->map_key_expression_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - swap(child_, other->child_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment_MapKeyExpression::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[1]); -} - -// =================================================================== - -class ReferenceSegment_StructField::_Internal { - public: - static const ::io::substrait::ReferenceSegment& child(const ReferenceSegment_StructField* msg); -}; - -const ::io::substrait::ReferenceSegment& -ReferenceSegment_StructField::_Internal::child(const ReferenceSegment_StructField* msg) { - return *msg->child_; -} -ReferenceSegment_StructField::ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment.StructField) -} -ReferenceSegment_StructField::ReferenceSegment_StructField(const ReferenceSegment_StructField& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::io::substrait::ReferenceSegment(*from.child_); - } else { - child_ = nullptr; - } - field_ = from.field_; - // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment.StructField) -} - -void ReferenceSegment_StructField::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&child_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&field_) - - reinterpret_cast(&child_)) + sizeof(field_)); -} - -ReferenceSegment_StructField::~ReferenceSegment_StructField() { - // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment.StructField) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void ReferenceSegment_StructField::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete child_; -} - -void ReferenceSegment_StructField::ArenaDtor(void* object) { - ReferenceSegment_StructField* _this = reinterpret_cast< ReferenceSegment_StructField* >(object); - (void)_this; -} -void ReferenceSegment_StructField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReferenceSegment_StructField::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReferenceSegment_StructField::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment.StructField) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - field_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReferenceSegment_StructField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 field = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.ReferenceSegment child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment_StructField::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment.StructField) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 field = 1; - if (this->field() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); - } - - // .io.substrait.ReferenceSegment child = 2; - if (this->has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment.StructField) - return target; -} - -size_t ReferenceSegment_StructField::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment.StructField) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .io.substrait.ReferenceSegment child = 2; - if (this->has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - // int32 field = 1; - if (this->field() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_field()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void ReferenceSegment_StructField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment.StructField) - GOOGLE_DCHECK_NE(&from, this); - const ReferenceSegment_StructField* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment.StructField) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment.StructField) - MergeFrom(*source); - } -} - -void ReferenceSegment_StructField::MergeFrom(const ReferenceSegment_StructField& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment.StructField) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_child()) { - _internal_mutable_child()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_child()); - } - if (from.field() != 0) { - _internal_set_field(from._internal_field()); - } -} - -void ReferenceSegment_StructField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment.StructField) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void ReferenceSegment_StructField::CopyFrom(const ReferenceSegment_StructField& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment.StructField) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReferenceSegment_StructField::IsInitialized() const { - return true; -} - -void ReferenceSegment_StructField::InternalSwap(ReferenceSegment_StructField* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ReferenceSegment_StructField, field_) - + sizeof(ReferenceSegment_StructField::field_) - - PROTOBUF_FIELD_OFFSET(ReferenceSegment_StructField, child_)>( - reinterpret_cast(&child_), - reinterpret_cast(&other->child_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment_StructField::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[2]); -} - -// =================================================================== - -class ReferenceSegment_ListElement::_Internal { - public: - static const ::io::substrait::ReferenceSegment& child(const ReferenceSegment_ListElement* msg); -}; - -const ::io::substrait::ReferenceSegment& -ReferenceSegment_ListElement::_Internal::child(const ReferenceSegment_ListElement* msg) { - return *msg->child_; -} -ReferenceSegment_ListElement::ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment.ListElement) -} -ReferenceSegment_ListElement::ReferenceSegment_ListElement(const ReferenceSegment_ListElement& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::io::substrait::ReferenceSegment(*from.child_); - } else { - child_ = nullptr; - } - offset_ = from.offset_; - // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment.ListElement) -} - -void ReferenceSegment_ListElement::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&child_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&offset_) - - reinterpret_cast(&child_)) + sizeof(offset_)); -} - -ReferenceSegment_ListElement::~ReferenceSegment_ListElement() { - // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment.ListElement) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void ReferenceSegment_ListElement::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete child_; -} - -void ReferenceSegment_ListElement::ArenaDtor(void* object) { - ReferenceSegment_ListElement* _this = reinterpret_cast< ReferenceSegment_ListElement* >(object); - (void)_this; -} -void ReferenceSegment_ListElement::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReferenceSegment_ListElement::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReferenceSegment_ListElement::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment.ListElement) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - offset_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReferenceSegment_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 offset = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.ReferenceSegment child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment_ListElement::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment.ListElement) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 offset = 1; - if (this->offset() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_offset(), target); - } - - // .io.substrait.ReferenceSegment child = 2; - if (this->has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment.ListElement) - return target; -} - -size_t ReferenceSegment_ListElement::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment.ListElement) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .io.substrait.ReferenceSegment child = 2; - if (this->has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - // int32 offset = 1; - if (this->offset() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_offset()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void ReferenceSegment_ListElement::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment.ListElement) - GOOGLE_DCHECK_NE(&from, this); - const ReferenceSegment_ListElement* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment.ListElement) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment.ListElement) - MergeFrom(*source); - } -} - -void ReferenceSegment_ListElement::MergeFrom(const ReferenceSegment_ListElement& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment.ListElement) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_child()) { - _internal_mutable_child()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_child()); - } - if (from.offset() != 0) { - _internal_set_offset(from._internal_offset()); - } -} - -void ReferenceSegment_ListElement::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment.ListElement) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void ReferenceSegment_ListElement::CopyFrom(const ReferenceSegment_ListElement& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment.ListElement) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReferenceSegment_ListElement::IsInitialized() const { - return true; -} - -void ReferenceSegment_ListElement::InternalSwap(ReferenceSegment_ListElement* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ReferenceSegment_ListElement, offset_) - + sizeof(ReferenceSegment_ListElement::offset_) - - PROTOBUF_FIELD_OFFSET(ReferenceSegment_ListElement, child_)>( - reinterpret_cast(&child_), - reinterpret_cast(&other->child_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment_ListElement::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[3]); -} - -// =================================================================== - -class ReferenceSegment_ListRange::_Internal { - public: - static const ::io::substrait::ReferenceSegment& child(const ReferenceSegment_ListRange* msg); -}; - -const ::io::substrait::ReferenceSegment& -ReferenceSegment_ListRange::_Internal::child(const ReferenceSegment_ListRange* msg) { - return *msg->child_; -} -ReferenceSegment_ListRange::ReferenceSegment_ListRange(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment.ListRange) -} -ReferenceSegment_ListRange::ReferenceSegment_ListRange(const ReferenceSegment_ListRange& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::io::substrait::ReferenceSegment(*from.child_); - } else { - child_ = nullptr; - } - ::memcpy(&start_, &from.start_, - static_cast(reinterpret_cast(&end_) - - reinterpret_cast(&start_)) + sizeof(end_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment.ListRange) -} - -void ReferenceSegment_ListRange::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&child_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&end_) - - reinterpret_cast(&child_)) + sizeof(end_)); -} - -ReferenceSegment_ListRange::~ReferenceSegment_ListRange() { - // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment.ListRange) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void ReferenceSegment_ListRange::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete child_; -} - -void ReferenceSegment_ListRange::ArenaDtor(void* object) { - ReferenceSegment_ListRange* _this = reinterpret_cast< ReferenceSegment_ListRange* >(object); - (void)_this; -} -void ReferenceSegment_ListRange::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReferenceSegment_ListRange::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReferenceSegment_ListRange::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment.ListRange) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - ::memset(&start_, 0, static_cast( - reinterpret_cast(&end_) - - reinterpret_cast(&start_)) + sizeof(end_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReferenceSegment_ListRange::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 start = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // int32 end = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.ReferenceSegment child = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment_ListRange::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment.ListRange) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 start = 1; - if (this->start() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_start(), target); - } - - // int32 end = 2; - if (this->end() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end(), target); - } - - // .io.substrait.ReferenceSegment child = 3; - if (this->has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment.ListRange) - return target; -} - -size_t ReferenceSegment_ListRange::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment.ListRange) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .io.substrait.ReferenceSegment child = 3; - if (this->has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - // int32 start = 1; - if (this->start() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_start()); - } - - // int32 end = 2; - if (this->end() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_end()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void ReferenceSegment_ListRange::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment.ListRange) - GOOGLE_DCHECK_NE(&from, this); - const ReferenceSegment_ListRange* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment.ListRange) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment.ListRange) - MergeFrom(*source); - } -} - -void ReferenceSegment_ListRange::MergeFrom(const ReferenceSegment_ListRange& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment.ListRange) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_child()) { - _internal_mutable_child()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_child()); - } - if (from.start() != 0) { - _internal_set_start(from._internal_start()); - } - if (from.end() != 0) { - _internal_set_end(from._internal_end()); - } -} - -void ReferenceSegment_ListRange::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment.ListRange) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void ReferenceSegment_ListRange::CopyFrom(const ReferenceSegment_ListRange& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment.ListRange) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReferenceSegment_ListRange::IsInitialized() const { - return true; -} - -void ReferenceSegment_ListRange::InternalSwap(ReferenceSegment_ListRange* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ReferenceSegment_ListRange, end_) - + sizeof(ReferenceSegment_ListRange::end_) - - PROTOBUF_FIELD_OFFSET(ReferenceSegment_ListRange, child_)>( - reinterpret_cast(&child_), - reinterpret_cast(&other->child_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment_ListRange::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[4]); -} - -// =================================================================== - -class ReferenceSegment::_Internal { - public: - static const ::io::substrait::ReferenceSegment_MapKey& map_key(const ReferenceSegment* msg); - static const ::io::substrait::ReferenceSegment_MapKeyExpression& expression(const ReferenceSegment* msg); - static const ::io::substrait::ReferenceSegment_StructField& struct_field(const ReferenceSegment* msg); - static const ::io::substrait::ReferenceSegment_ListElement& list_element(const ReferenceSegment* msg); - static const ::io::substrait::ReferenceSegment_ListRange& list_range(const ReferenceSegment* msg); -}; - -const ::io::substrait::ReferenceSegment_MapKey& -ReferenceSegment::_Internal::map_key(const ReferenceSegment* msg) { - return *msg->reference_type_.map_key_; -} -const ::io::substrait::ReferenceSegment_MapKeyExpression& -ReferenceSegment::_Internal::expression(const ReferenceSegment* msg) { - return *msg->reference_type_.expression_; -} -const ::io::substrait::ReferenceSegment_StructField& -ReferenceSegment::_Internal::struct_field(const ReferenceSegment* msg) { - return *msg->reference_type_.struct_field_; -} -const ::io::substrait::ReferenceSegment_ListElement& -ReferenceSegment::_Internal::list_element(const ReferenceSegment* msg) { - return *msg->reference_type_.list_element_; -} -const ::io::substrait::ReferenceSegment_ListRange& -ReferenceSegment::_Internal::list_range(const ReferenceSegment* msg) { - return *msg->reference_type_.list_range_; -} -void ReferenceSegment::set_allocated_map_key(::io::substrait::ReferenceSegment_MapKey* map_key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_reference_type(); - if (map_key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map_key); - if (message_arena != submessage_arena) { - map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, map_key, submessage_arena); - } - set_has_map_key(); - reference_type_.map_key_ = map_key; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.map_key) -} -void ReferenceSegment::set_allocated_expression(::io::substrait::ReferenceSegment_MapKeyExpression* expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_reference_type(); - if (expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expression); - if (message_arena != submessage_arena) { - expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, expression, submessage_arena); - } - set_has_expression(); - reference_type_.expression_ = expression; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.expression) -} -void ReferenceSegment::set_allocated_struct_field(::io::substrait::ReferenceSegment_StructField* struct_field) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_reference_type(); - if (struct_field) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_field); - if (message_arena != submessage_arena) { - struct_field = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_field, submessage_arena); - } - set_has_struct_field(); - reference_type_.struct_field_ = struct_field; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.struct_field) -} -void ReferenceSegment::set_allocated_list_element(::io::substrait::ReferenceSegment_ListElement* list_element) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_reference_type(); - if (list_element) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list_element); - if (message_arena != submessage_arena) { - list_element = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, list_element, submessage_arena); - } - set_has_list_element(); - reference_type_.list_element_ = list_element; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.list_element) -} -void ReferenceSegment::set_allocated_list_range(::io::substrait::ReferenceSegment_ListRange* list_range) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_reference_type(); - if (list_range) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list_range); - if (message_arena != submessage_arena) { - list_range = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, list_range, submessage_arena); - } - set_has_list_range(); - reference_type_.list_range_ = list_range; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.list_range) -} -ReferenceSegment::ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReferenceSegment) -} -ReferenceSegment::ReferenceSegment(const ReferenceSegment& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_reference_type(); - switch (from.reference_type_case()) { - case kMapKey: { - _internal_mutable_map_key()->::io::substrait::ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); - break; - } - case kExpression: { - _internal_mutable_expression()->::io::substrait::ReferenceSegment_MapKeyExpression::MergeFrom(from._internal_expression()); - break; - } - case kStructField: { - _internal_mutable_struct_field()->::io::substrait::ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); - break; - } - case kListElement: { - _internal_mutable_list_element()->::io::substrait::ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); - break; - } - case kListRange: { - _internal_mutable_list_range()->::io::substrait::ReferenceSegment_ListRange::MergeFrom(from._internal_list_range()); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:io.substrait.ReferenceSegment) -} - -void ReferenceSegment::SharedCtor() { -clear_has_reference_type(); -} - -ReferenceSegment::~ReferenceSegment() { - // @@protoc_insertion_point(destructor:io.substrait.ReferenceSegment) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void ReferenceSegment::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (has_reference_type()) { - clear_reference_type(); - } -} - -void ReferenceSegment::ArenaDtor(void* object) { - ReferenceSegment* _this = reinterpret_cast< ReferenceSegment* >(object); - (void)_this; -} -void ReferenceSegment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReferenceSegment::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReferenceSegment::clear_reference_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.ReferenceSegment) - switch (reference_type_case()) { - case kMapKey: { - if (GetArena() == nullptr) { - delete reference_type_.map_key_; - } - break; - } - case kExpression: { - if (GetArena() == nullptr) { - delete reference_type_.expression_; - } - break; - } - case kStructField: { - if (GetArena() == nullptr) { - delete reference_type_.struct_field_; - } - break; - } - case kListElement: { - if (GetArena() == nullptr) { - delete reference_type_.list_element_; - } - break; - } - case kListRange: { - if (GetArena() == nullptr) { - delete reference_type_.list_range_; - } - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; -} - - -void ReferenceSegment::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReferenceSegment) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_reference_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReferenceSegment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .io.substrait.ReferenceSegment.MapKey map_key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.ReferenceSegment.MapKeyExpression expression = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.ReferenceSegment.StructField struct_field = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_field(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.ReferenceSegment.ListElement list_element = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_list_element(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.ReferenceSegment.ListRange list_range = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_list_range(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* ReferenceSegment::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReferenceSegment) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .io.substrait.ReferenceSegment.MapKey map_key = 1; - if (_internal_has_map_key()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::map_key(this), target, stream); - } - - // .io.substrait.ReferenceSegment.MapKeyExpression expression = 2; - if (_internal_has_expression()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::expression(this), target, stream); - } - - // .io.substrait.ReferenceSegment.StructField struct_field = 3; - if (_internal_has_struct_field()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::struct_field(this), target, stream); - } - - // .io.substrait.ReferenceSegment.ListElement list_element = 4; - if (_internal_has_list_element()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::list_element(this), target, stream); - } - - // .io.substrait.ReferenceSegment.ListRange list_range = 5; - if (_internal_has_list_range()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::list_range(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReferenceSegment) - return target; -} - -size_t ReferenceSegment::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReferenceSegment) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (reference_type_case()) { - // .io.substrait.ReferenceSegment.MapKey map_key = 1; - case kMapKey: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.map_key_); - break; - } - // .io.substrait.ReferenceSegment.MapKeyExpression expression = 2; - case kExpression: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.expression_); - break; - } - // .io.substrait.ReferenceSegment.StructField struct_field = 3; - case kStructField: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.struct_field_); - break; - } - // .io.substrait.ReferenceSegment.ListElement list_element = 4; - case kListElement: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.list_element_); - break; - } - // .io.substrait.ReferenceSegment.ListRange list_range = 5; - case kListRange: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.list_range_); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void ReferenceSegment::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReferenceSegment) - GOOGLE_DCHECK_NE(&from, this); - const ReferenceSegment* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReferenceSegment) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReferenceSegment) - MergeFrom(*source); - } -} - -void ReferenceSegment::MergeFrom(const ReferenceSegment& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReferenceSegment) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.reference_type_case()) { - case kMapKey: { - _internal_mutable_map_key()->::io::substrait::ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); - break; - } - case kExpression: { - _internal_mutable_expression()->::io::substrait::ReferenceSegment_MapKeyExpression::MergeFrom(from._internal_expression()); - break; - } - case kStructField: { - _internal_mutable_struct_field()->::io::substrait::ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); - break; - } - case kListElement: { - _internal_mutable_list_element()->::io::substrait::ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); - break; - } - case kListRange: { - _internal_mutable_list_range()->::io::substrait::ReferenceSegment_ListRange::MergeFrom(from._internal_list_range()); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } -} - -void ReferenceSegment::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReferenceSegment) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void ReferenceSegment::CopyFrom(const ReferenceSegment& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReferenceSegment) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReferenceSegment::IsInitialized() const { - return true; -} - -void ReferenceSegment::InternalSwap(ReferenceSegment* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(reference_type_, other->reference_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReferenceSegment::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[5]); -} - -// =================================================================== - -class MaskExpression_Select::_Internal { - public: - static const ::io::substrait::MaskExpression_StructSelect& struct_(const MaskExpression_Select* msg); - static const ::io::substrait::MaskExpression_ListSelect& list(const MaskExpression_Select* msg); - static const ::io::substrait::MaskExpression_MapSelect& map(const MaskExpression_Select* msg); -}; - -const ::io::substrait::MaskExpression_StructSelect& -MaskExpression_Select::_Internal::struct_(const MaskExpression_Select* msg) { - return *msg->type_.struct__; -} -const ::io::substrait::MaskExpression_ListSelect& -MaskExpression_Select::_Internal::list(const MaskExpression_Select* msg) { - return *msg->type_.list_; -} -const ::io::substrait::MaskExpression_MapSelect& -MaskExpression_Select::_Internal::map(const MaskExpression_Select* msg) { - return *msg->type_.map_; -} -void MaskExpression_Select::set_allocated_struct_(::io::substrait::MaskExpression_StructSelect* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_type(); - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - set_has_struct_(); - type_.struct__ = struct_; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.Select.struct) -} -void MaskExpression_Select::set_allocated_list(::io::substrait::MaskExpression_ListSelect* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_type(); - if (list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); - if (message_arena != submessage_arena) { - list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, list, submessage_arena); - } - set_has_list(); - type_.list_ = list; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.Select.list) -} -void MaskExpression_Select::set_allocated_map(::io::substrait::MaskExpression_MapSelect* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_type(); - if (map) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); - if (message_arena != submessage_arena) { - map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, map, submessage_arena); - } - set_has_map(); - type_.map_ = map; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.Select.map) -} -MaskExpression_Select::MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.Select) -} -MaskExpression_Select::MaskExpression_Select(const MaskExpression_Select& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_type(); - switch (from.type_case()) { - case kStruct: { - _internal_mutable_struct_()->::io::substrait::MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); - break; - } - case kList: { - _internal_mutable_list()->::io::substrait::MaskExpression_ListSelect::MergeFrom(from._internal_list()); - break; - } - case kMap: { - _internal_mutable_map()->::io::substrait::MaskExpression_MapSelect::MergeFrom(from._internal_map()); - break; - } - case TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.Select) -} - -void MaskExpression_Select::SharedCtor() { -clear_has_type(); -} - -MaskExpression_Select::~MaskExpression_Select() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.Select) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression_Select::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (has_type()) { - clear_type(); - } -} - -void MaskExpression_Select::ArenaDtor(void* object) { - MaskExpression_Select* _this = reinterpret_cast< MaskExpression_Select* >(object); - (void)_this; -} -void MaskExpression_Select::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression_Select::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression_Select::clear_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.MaskExpression.Select) - switch (type_case()) { - case kStruct: { - if (GetArena() == nullptr) { - delete type_.struct__; - } - break; - } - case kList: { - if (GetArena() == nullptr) { - delete type_.list_; - } - break; - } - case kMap: { - if (GetArena() == nullptr) { - delete type_.map_; - } - break; - } - case TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = TYPE_NOT_SET; -} - - -void MaskExpression_Select::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.Select) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression_Select::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .io.substrait.MaskExpression.StructSelect struct = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.MaskExpression.ListSelect list = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.MaskExpression.MapSelect map = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_Select::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.Select) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .io.substrait.MaskExpression.StructSelect struct = 1; - if (_internal_has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::struct_(this), target, stream); - } - - // .io.substrait.MaskExpression.ListSelect list = 2; - if (_internal_has_list()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::list(this), target, stream); - } - - // .io.substrait.MaskExpression.MapSelect map = 3; - if (_internal_has_map()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::map(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.Select) - return target; -} - -size_t MaskExpression_Select::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.Select) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (type_case()) { - // .io.substrait.MaskExpression.StructSelect struct = 1; - case kStruct: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_.struct__); - break; - } - // .io.substrait.MaskExpression.ListSelect list = 2; - case kList: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_.list_); - break; - } - // .io.substrait.MaskExpression.MapSelect map = 3; - case kMap: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_.map_); - break; - } - case TYPE_NOT_SET: { - break; - } - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression_Select::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.Select) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression_Select* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.Select) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.Select) - MergeFrom(*source); - } -} - -void MaskExpression_Select::MergeFrom(const MaskExpression_Select& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.Select) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.type_case()) { - case kStruct: { - _internal_mutable_struct_()->::io::substrait::MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); - break; - } - case kList: { - _internal_mutable_list()->::io::substrait::MaskExpression_ListSelect::MergeFrom(from._internal_list()); - break; - } - case kMap: { - _internal_mutable_map()->::io::substrait::MaskExpression_MapSelect::MergeFrom(from._internal_map()); - break; - } - case TYPE_NOT_SET: { - break; - } - } -} - -void MaskExpression_Select::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.Select) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression_Select::CopyFrom(const MaskExpression_Select& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.Select) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression_Select::IsInitialized() const { - return true; -} - -void MaskExpression_Select::InternalSwap(MaskExpression_Select* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(type_, other->type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_Select::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[6]); -} - -// =================================================================== - -class MaskExpression_StructSelect::_Internal { - public: -}; - -MaskExpression_StructSelect::MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - struct_items_(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.StructSelect) -} -MaskExpression_StructSelect::MaskExpression_StructSelect(const MaskExpression_StructSelect& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - struct_items_(from.struct_items_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.StructSelect) -} - -void MaskExpression_StructSelect::SharedCtor() { -} - -MaskExpression_StructSelect::~MaskExpression_StructSelect() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.StructSelect) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression_StructSelect::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void MaskExpression_StructSelect::ArenaDtor(void* object) { - MaskExpression_StructSelect* _this = reinterpret_cast< MaskExpression_StructSelect* >(object); - (void)_this; -} -void MaskExpression_StructSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression_StructSelect::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression_StructSelect::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.StructSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - struct_items_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression_StructSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .io.substrait.MaskExpression.StructItem struct_items = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_struct_items(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_StructSelect::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.StructSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .io.substrait.MaskExpression.StructItem struct_items = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_struct_items_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_struct_items(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.StructSelect) - return target; -} - -size_t MaskExpression_StructSelect::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.StructSelect) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .io.substrait.MaskExpression.StructItem struct_items = 1; - total_size += 1UL * this->_internal_struct_items_size(); - for (const auto& msg : this->struct_items_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression_StructSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.StructSelect) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression_StructSelect* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.StructSelect) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.StructSelect) - MergeFrom(*source); - } -} - -void MaskExpression_StructSelect::MergeFrom(const MaskExpression_StructSelect& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.StructSelect) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - struct_items_.MergeFrom(from.struct_items_); -} - -void MaskExpression_StructSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.StructSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression_StructSelect::CopyFrom(const MaskExpression_StructSelect& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.StructSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression_StructSelect::IsInitialized() const { - return true; -} - -void MaskExpression_StructSelect::InternalSwap(MaskExpression_StructSelect* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - struct_items_.InternalSwap(&other->struct_items_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_StructSelect::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[7]); -} - -// =================================================================== - -class MaskExpression_StructItem::_Internal { - public: - static const ::io::substrait::MaskExpression_Select& child(const MaskExpression_StructItem* msg); -}; - -const ::io::substrait::MaskExpression_Select& -MaskExpression_StructItem::_Internal::child(const MaskExpression_StructItem* msg) { - return *msg->child_; -} -MaskExpression_StructItem::MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.StructItem) -} -MaskExpression_StructItem::MaskExpression_StructItem(const MaskExpression_StructItem& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::io::substrait::MaskExpression_Select(*from.child_); - } else { - child_ = nullptr; - } - field_ = from.field_; - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.StructItem) -} - -void MaskExpression_StructItem::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&child_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&field_) - - reinterpret_cast(&child_)) + sizeof(field_)); -} - -MaskExpression_StructItem::~MaskExpression_StructItem() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.StructItem) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression_StructItem::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete child_; -} - -void MaskExpression_StructItem::ArenaDtor(void* object) { - MaskExpression_StructItem* _this = reinterpret_cast< MaskExpression_StructItem* >(object); - (void)_this; -} -void MaskExpression_StructItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression_StructItem::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression_StructItem::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.StructItem) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - field_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression_StructItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 field = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.MaskExpression.Select child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_StructItem::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.StructItem) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 field = 1; - if (this->field() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); - } - - // .io.substrait.MaskExpression.Select child = 2; - if (this->has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.StructItem) - return target; -} - -size_t MaskExpression_StructItem::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.StructItem) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .io.substrait.MaskExpression.Select child = 2; - if (this->has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - // int32 field = 1; - if (this->field() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_field()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression_StructItem::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.StructItem) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression_StructItem* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.StructItem) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.StructItem) - MergeFrom(*source); - } -} - -void MaskExpression_StructItem::MergeFrom(const MaskExpression_StructItem& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.StructItem) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_child()) { - _internal_mutable_child()->::io::substrait::MaskExpression_Select::MergeFrom(from._internal_child()); - } - if (from.field() != 0) { - _internal_set_field(from._internal_field()); - } -} - -void MaskExpression_StructItem::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.StructItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression_StructItem::CopyFrom(const MaskExpression_StructItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.StructItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression_StructItem::IsInitialized() const { - return true; -} - -void MaskExpression_StructItem::InternalSwap(MaskExpression_StructItem* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(MaskExpression_StructItem, field_) - + sizeof(MaskExpression_StructItem::field_) - - PROTOBUF_FIELD_OFFSET(MaskExpression_StructItem, child_)>( - reinterpret_cast(&child_), - reinterpret_cast(&other->child_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_StructItem::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[8]); -} - -// =================================================================== - -class MaskExpression_ListSelect_ListSelectItem_ListElement::_Internal { - public: -}; - -MaskExpression_ListSelect_ListSelectItem_ListElement::MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) -} -MaskExpression_ListSelect_ListSelectItem_ListElement::MaskExpression_ListSelect_ListSelectItem_ListElement(const MaskExpression_ListSelect_ListSelectItem_ListElement& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - field_ = from.field_; - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) -} - -void MaskExpression_ListSelect_ListSelectItem_ListElement::SharedCtor() { -field_ = 0; -} - -MaskExpression_ListSelect_ListSelectItem_ListElement::~MaskExpression_ListSelect_ListSelectItem_ListElement() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression_ListSelect_ListSelectItem_ListElement::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void MaskExpression_ListSelect_ListSelectItem_ListElement::ArenaDtor(void* object) { - MaskExpression_ListSelect_ListSelectItem_ListElement* _this = reinterpret_cast< MaskExpression_ListSelect_ListSelectItem_ListElement* >(object); - (void)_this; -} -void MaskExpression_ListSelect_ListSelectItem_ListElement::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression_ListSelect_ListSelectItem_ListElement::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression_ListSelect_ListSelectItem_ListElement::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - field_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 field = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 field = 1; - if (this->field() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - return target; -} - -size_t MaskExpression_ListSelect_ListSelectItem_ListElement::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int32 field = 1; - if (this->field() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_field()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression_ListSelect_ListSelectItem_ListElement* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - MergeFrom(*source); - } -} - -void MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const MaskExpression_ListSelect_ListSelectItem_ListElement& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.field() != 0) { - _internal_set_field(from._internal_field()); - } -} - -void MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const MaskExpression_ListSelect_ListSelectItem_ListElement& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression_ListSelect_ListSelectItem_ListElement::IsInitialized() const { - return true; -} - -void MaskExpression_ListSelect_ListSelectItem_ListElement::InternalSwap(MaskExpression_ListSelect_ListSelectItem_ListElement* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(field_, other->field_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_ListSelect_ListSelectItem_ListElement::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[9]); -} - -// =================================================================== - -class MaskExpression_ListSelect_ListSelectItem_ListSlice::_Internal { - public: -}; - -MaskExpression_ListSelect_ListSelectItem_ListSlice::MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) -} -MaskExpression_ListSelect_ListSelectItem_ListSlice::MaskExpression_ListSelect_ListSelectItem_ListSlice(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&start_, &from.start_, - static_cast(reinterpret_cast(&end_) - - reinterpret_cast(&start_)) + sizeof(end_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) -} - -void MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&start_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&end_) - - reinterpret_cast(&start_)) + sizeof(end_)); -} - -MaskExpression_ListSelect_ListSelectItem_ListSlice::~MaskExpression_ListSelect_ListSelectItem_ListSlice() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void MaskExpression_ListSelect_ListSelectItem_ListSlice::ArenaDtor(void* object) { - MaskExpression_ListSelect_ListSelectItem_ListSlice* _this = reinterpret_cast< MaskExpression_ListSelect_ListSelectItem_ListSlice* >(object); - (void)_this; -} -void MaskExpression_ListSelect_ListSelectItem_ListSlice::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression_ListSelect_ListSelectItem_ListSlice::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression_ListSelect_ListSelectItem_ListSlice::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&start_, 0, static_cast( - reinterpret_cast(&end_) - - reinterpret_cast(&start_)) + sizeof(end_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 start = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // int32 end = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 start = 1; - if (this->start() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_start(), target); - } - - // int32 end = 2; - if (this->end() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - return target; -} - -size_t MaskExpression_ListSelect_ListSelectItem_ListSlice::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int32 start = 1; - if (this->start() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_start()); - } - - // int32 end = 2; - if (this->end() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_end()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression_ListSelect_ListSelectItem_ListSlice* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - MergeFrom(*source); - } -} - -void MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.start() != 0) { - _internal_set_start(from._internal_start()); - } - if (from.end() != 0) { - _internal_set_end(from._internal_end()); - } -} - -void MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression_ListSelect_ListSelectItem_ListSlice::IsInitialized() const { - return true; -} - -void MaskExpression_ListSelect_ListSelectItem_ListSlice::InternalSwap(MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(MaskExpression_ListSelect_ListSelectItem_ListSlice, end_) - + sizeof(MaskExpression_ListSelect_ListSelectItem_ListSlice::end_) - - PROTOBUF_FIELD_OFFSET(MaskExpression_ListSelect_ListSelectItem_ListSlice, start_)>( - reinterpret_cast(&start_), - reinterpret_cast(&other->start_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_ListSelect_ListSelectItem_ListSlice::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[10]); -} - -// =================================================================== - -class MaskExpression_ListSelect_ListSelectItem::_Internal { - public: - static const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& item(const MaskExpression_ListSelect_ListSelectItem* msg); - static const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& slice(const MaskExpression_ListSelect_ListSelectItem* msg); -}; - -const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& -MaskExpression_ListSelect_ListSelectItem::_Internal::item(const MaskExpression_ListSelect_ListSelectItem* msg) { - return *msg->type_.item_; -} -const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& -MaskExpression_ListSelect_ListSelectItem::_Internal::slice(const MaskExpression_ListSelect_ListSelectItem* msg) { - return *msg->type_.slice_; -} -void MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* item) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_type(); - if (item) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(item); - if (message_arena != submessage_arena) { - item = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, item, submessage_arena); - } - set_has_item(); - type_.item_ = item; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) -} -void MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_type(); - if (slice) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(slice); - if (message_arena != submessage_arena) { - slice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, slice, submessage_arena); - } - set_has_slice(); - type_.slice_ = slice; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) -} -MaskExpression_ListSelect_ListSelectItem::MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem) -} -MaskExpression_ListSelect_ListSelectItem::MaskExpression_ListSelect_ListSelectItem(const MaskExpression_ListSelect_ListSelectItem& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_type(); - switch (from.type_case()) { - case kItem: { - _internal_mutable_item()->::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); - break; - } - case kSlice: { - _internal_mutable_slice()->::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); - break; - } - case TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.ListSelect.ListSelectItem) -} - -void MaskExpression_ListSelect_ListSelectItem::SharedCtor() { -clear_has_type(); -} - -MaskExpression_ListSelect_ListSelectItem::~MaskExpression_ListSelect_ListSelectItem() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.ListSelect.ListSelectItem) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression_ListSelect_ListSelectItem::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (has_type()) { - clear_type(); - } -} - -void MaskExpression_ListSelect_ListSelectItem::ArenaDtor(void* object) { - MaskExpression_ListSelect_ListSelectItem* _this = reinterpret_cast< MaskExpression_ListSelect_ListSelectItem* >(object); - (void)_this; -} -void MaskExpression_ListSelect_ListSelectItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression_ListSelect_ListSelectItem::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression_ListSelect_ListSelectItem::clear_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) - switch (type_case()) { - case kItem: { - if (GetArena() == nullptr) { - delete type_.item_; - } - break; - } - case kSlice: { - if (GetArena() == nullptr) { - delete type_.slice_; - } - break; - } - case TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = TYPE_NOT_SET; -} - - -void MaskExpression_ListSelect_ListSelectItem::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression_ListSelect_ListSelectItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_item(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_slice(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_ListSelect_ListSelectItem::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; - if (_internal_has_item()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::item(this), target, stream); - } - - // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; - if (_internal_has_slice()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::slice(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.ListSelect.ListSelectItem) - return target; -} - -size_t MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (type_case()) { - // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; - case kItem: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_.item_); - break; - } - // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; - case kSlice: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_.slice_); - break; - } - case TYPE_NOT_SET: { - break; - } - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression_ListSelect_ListSelectItem::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression_ListSelect_ListSelectItem* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.ListSelect.ListSelectItem) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.ListSelect.ListSelectItem) - MergeFrom(*source); - } -} - -void MaskExpression_ListSelect_ListSelectItem::MergeFrom(const MaskExpression_ListSelect_ListSelectItem& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.type_case()) { - case kItem: { - _internal_mutable_item()->::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); - break; - } - case kSlice: { - _internal_mutable_slice()->::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); - break; - } - case TYPE_NOT_SET: { - break; - } - } -} - -void MaskExpression_ListSelect_ListSelectItem::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression_ListSelect_ListSelectItem::CopyFrom(const MaskExpression_ListSelect_ListSelectItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.ListSelect.ListSelectItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression_ListSelect_ListSelectItem::IsInitialized() const { - return true; -} - -void MaskExpression_ListSelect_ListSelectItem::InternalSwap(MaskExpression_ListSelect_ListSelectItem* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(type_, other->type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_ListSelect_ListSelectItem::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[11]); -} - -// =================================================================== - -class MaskExpression_ListSelect::_Internal { - public: - static const ::io::substrait::MaskExpression_Select& child(const MaskExpression_ListSelect* msg); -}; - -const ::io::substrait::MaskExpression_Select& -MaskExpression_ListSelect::_Internal::child(const MaskExpression_ListSelect* msg) { - return *msg->child_; -} -MaskExpression_ListSelect::MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - selection_(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.ListSelect) -} -MaskExpression_ListSelect::MaskExpression_ListSelect(const MaskExpression_ListSelect& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - selection_(from.selection_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::io::substrait::MaskExpression_Select(*from.child_); - } else { - child_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.ListSelect) -} - -void MaskExpression_ListSelect::SharedCtor() { -child_ = nullptr; -} - -MaskExpression_ListSelect::~MaskExpression_ListSelect() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.ListSelect) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression_ListSelect::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete child_; -} - -void MaskExpression_ListSelect::ArenaDtor(void* object) { - MaskExpression_ListSelect* _this = reinterpret_cast< MaskExpression_ListSelect* >(object); - (void)_this; -} -void MaskExpression_ListSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression_ListSelect::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression_ListSelect::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.ListSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - selection_.Clear(); - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression_ListSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .io.substrait.MaskExpression.ListSelect.ListSelectItem selection = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_selection(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; - continue; - // .io.substrait.MaskExpression.Select child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_ListSelect::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.ListSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .io.substrait.MaskExpression.ListSelect.ListSelectItem selection = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_selection_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_selection(i), target, stream); - } - - // .io.substrait.MaskExpression.Select child = 2; - if (this->has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.ListSelect) - return target; -} - -size_t MaskExpression_ListSelect::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.ListSelect) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .io.substrait.MaskExpression.ListSelect.ListSelectItem selection = 1; - total_size += 1UL * this->_internal_selection_size(); - for (const auto& msg : this->selection_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .io.substrait.MaskExpression.Select child = 2; - if (this->has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression_ListSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.ListSelect) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression_ListSelect* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.ListSelect) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.ListSelect) - MergeFrom(*source); - } -} - -void MaskExpression_ListSelect::MergeFrom(const MaskExpression_ListSelect& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.ListSelect) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - selection_.MergeFrom(from.selection_); - if (from.has_child()) { - _internal_mutable_child()->::io::substrait::MaskExpression_Select::MergeFrom(from._internal_child()); - } -} - -void MaskExpression_ListSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.ListSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression_ListSelect::CopyFrom(const MaskExpression_ListSelect& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.ListSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression_ListSelect::IsInitialized() const { - return true; -} - -void MaskExpression_ListSelect::InternalSwap(MaskExpression_ListSelect* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - selection_.InternalSwap(&other->selection_); - swap(child_, other->child_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_ListSelect::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[12]); -} - -// =================================================================== - -class MaskExpression_MapSelect_MapKey::_Internal { - public: -}; - -MaskExpression_MapSelect_MapKey::MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.MapSelect.MapKey) -} -MaskExpression_MapSelect_MapKey::MaskExpression_MapSelect_MapKey(const MaskExpression_MapSelect_MapKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_map_key().empty()) { - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key(), - GetArena()); - } - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.MapSelect.MapKey) -} - -void MaskExpression_MapSelect_MapKey::SharedCtor() { -map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -MaskExpression_MapSelect_MapKey::~MaskExpression_MapSelect_MapKey() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.MapSelect.MapKey) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression_MapSelect_MapKey::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - map_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void MaskExpression_MapSelect_MapKey::ArenaDtor(void* object) { - MaskExpression_MapSelect_MapKey* _this = reinterpret_cast< MaskExpression_MapSelect_MapKey* >(object); - (void)_this; -} -void MaskExpression_MapSelect_MapKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression_MapSelect_MapKey::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression_MapSelect_MapKey::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.MapSelect.MapKey) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - map_key_.ClearToEmpty(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression_MapSelect_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string map_key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_map_key(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.MaskExpression.MapSelect.MapKey.map_key")); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_MapSelect_MapKey::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.MapSelect.MapKey) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // string map_key = 1; - if (this->map_key().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_map_key().data(), static_cast(this->_internal_map_key().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.MaskExpression.MapSelect.MapKey.map_key"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_map_key(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.MapSelect.MapKey) - return target; -} - -size_t MaskExpression_MapSelect_MapKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.MapSelect.MapKey) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // string map_key = 1; - if (this->map_key().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_map_key()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression_MapSelect_MapKey::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.MapSelect.MapKey) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression_MapSelect_MapKey* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.MapSelect.MapKey) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.MapSelect.MapKey) - MergeFrom(*source); - } -} - -void MaskExpression_MapSelect_MapKey::MergeFrom(const MaskExpression_MapSelect_MapKey& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.MapSelect.MapKey) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.map_key().size() > 0) { - _internal_set_map_key(from._internal_map_key()); - } -} - -void MaskExpression_MapSelect_MapKey::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.MapSelect.MapKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression_MapSelect_MapKey::CopyFrom(const MaskExpression_MapSelect_MapKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.MapSelect.MapKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression_MapSelect_MapKey::IsInitialized() const { - return true; -} - -void MaskExpression_MapSelect_MapKey::InternalSwap(MaskExpression_MapSelect_MapKey* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - map_key_.Swap(&other->map_key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_MapSelect_MapKey::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[13]); -} - -// =================================================================== - -class MaskExpression_MapSelect_MapKeyExpression::_Internal { - public: -}; - -MaskExpression_MapSelect_MapKeyExpression::MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.MapSelect.MapKeyExpression) -} -MaskExpression_MapSelect_MapKeyExpression::MaskExpression_MapSelect_MapKeyExpression(const MaskExpression_MapSelect_MapKeyExpression& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_map_key_expression().empty()) { - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key_expression(), - GetArena()); - } - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.MapSelect.MapKeyExpression) -} - -void MaskExpression_MapSelect_MapKeyExpression::SharedCtor() { -map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -MaskExpression_MapSelect_MapKeyExpression::~MaskExpression_MapSelect_MapKeyExpression() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression_MapSelect_MapKeyExpression::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - map_key_expression_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void MaskExpression_MapSelect_MapKeyExpression::ArenaDtor(void* object) { - MaskExpression_MapSelect_MapKeyExpression* _this = reinterpret_cast< MaskExpression_MapSelect_MapKeyExpression* >(object); - (void)_this; -} -void MaskExpression_MapSelect_MapKeyExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression_MapSelect_MapKeyExpression::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression_MapSelect_MapKeyExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - map_key_expression_.ClearToEmpty(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression_MapSelect_MapKeyExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string map_key_expression = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - auto str = _internal_mutable_map_key_expression(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression")); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_MapSelect_MapKeyExpression::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // string map_key_expression = 1; - if (this->map_key_expression().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_map_key_expression().data(), static_cast(this->_internal_map_key_expression().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_map_key_expression(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - return target; -} - -size_t MaskExpression_MapSelect_MapKeyExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // string map_key_expression = 1; - if (this->map_key_expression().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_map_key_expression()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression_MapSelect_MapKeyExpression* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - MergeFrom(*source); - } -} - -void MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const MaskExpression_MapSelect_MapKeyExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.map_key_expression().size() > 0) { - _internal_set_map_key_expression(from._internal_map_key_expression()); - } -} - -void MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const MaskExpression_MapSelect_MapKeyExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression_MapSelect_MapKeyExpression::IsInitialized() const { - return true; -} - -void MaskExpression_MapSelect_MapKeyExpression::InternalSwap(MaskExpression_MapSelect_MapKeyExpression* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - map_key_expression_.Swap(&other->map_key_expression_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_MapSelect_MapKeyExpression::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[14]); -} - -// =================================================================== - -class MaskExpression_MapSelect::_Internal { - public: - static const ::io::substrait::MaskExpression_MapSelect_MapKey& key(const MaskExpression_MapSelect* msg); - static const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& expression(const MaskExpression_MapSelect* msg); - static const ::io::substrait::MaskExpression_Select& child(const MaskExpression_MapSelect* msg); -}; - -const ::io::substrait::MaskExpression_MapSelect_MapKey& -MaskExpression_MapSelect::_Internal::key(const MaskExpression_MapSelect* msg) { - return *msg->select_.key_; -} -const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& -MaskExpression_MapSelect::_Internal::expression(const MaskExpression_MapSelect* msg) { - return *msg->select_.expression_; -} -const ::io::substrait::MaskExpression_Select& -MaskExpression_MapSelect::_Internal::child(const MaskExpression_MapSelect* msg) { - return *msg->child_; -} -void MaskExpression_MapSelect::set_allocated_key(::io::substrait::MaskExpression_MapSelect_MapKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_select(); - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - set_has_key(); - select_.key_ = key; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.MapSelect.key) -} -void MaskExpression_MapSelect::set_allocated_expression(::io::substrait::MaskExpression_MapSelect_MapKeyExpression* expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_select(); - if (expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expression); - if (message_arena != submessage_arena) { - expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, expression, submessage_arena); - } - set_has_expression(); - select_.expression_ = expression; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.MapSelect.expression) -} -MaskExpression_MapSelect::MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression.MapSelect) -} -MaskExpression_MapSelect::MaskExpression_MapSelect(const MaskExpression_MapSelect& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::io::substrait::MaskExpression_Select(*from.child_); - } else { - child_ = nullptr; - } - clear_has_select(); - switch (from.select_case()) { - case kKey: { - _internal_mutable_key()->::io::substrait::MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); - break; - } - case kExpression: { - _internal_mutable_expression()->::io::substrait::MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); - break; - } - case SELECT_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression.MapSelect) -} - -void MaskExpression_MapSelect::SharedCtor() { -child_ = nullptr; -clear_has_select(); -} - -MaskExpression_MapSelect::~MaskExpression_MapSelect() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression.MapSelect) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression_MapSelect::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete child_; - if (has_select()) { - clear_select(); - } -} - -void MaskExpression_MapSelect::ArenaDtor(void* object) { - MaskExpression_MapSelect* _this = reinterpret_cast< MaskExpression_MapSelect* >(object); - (void)_this; -} -void MaskExpression_MapSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression_MapSelect::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression_MapSelect::clear_select() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.MaskExpression.MapSelect) - switch (select_case()) { - case kKey: { - if (GetArena() == nullptr) { - delete select_.key_; - } - break; - } - case kExpression: { - if (GetArena() == nullptr) { - delete select_.expression_; - } - break; - } - case SELECT_NOT_SET: { - break; - } - } - _oneof_case_[0] = SELECT_NOT_SET; -} - - -void MaskExpression_MapSelect::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression.MapSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - clear_select(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression_MapSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .io.substrait.MaskExpression.MapSelect.MapKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.MaskExpression.MapSelect.MapKeyExpression expression = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.MaskExpression.Select child = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression_MapSelect::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression.MapSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .io.substrait.MaskExpression.MapSelect.MapKey key = 1; - if (_internal_has_key()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::key(this), target, stream); - } - - // .io.substrait.MaskExpression.MapSelect.MapKeyExpression expression = 2; - if (_internal_has_expression()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::expression(this), target, stream); - } - - // .io.substrait.MaskExpression.Select child = 3; - if (this->has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression.MapSelect) - return target; -} - -size_t MaskExpression_MapSelect::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression.MapSelect) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .io.substrait.MaskExpression.Select child = 3; - if (this->has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - switch (select_case()) { - // .io.substrait.MaskExpression.MapSelect.MapKey key = 1; - case kKey: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *select_.key_); - break; - } - // .io.substrait.MaskExpression.MapSelect.MapKeyExpression expression = 2; - case kExpression: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *select_.expression_); - break; - } - case SELECT_NOT_SET: { - break; - } - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression_MapSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression.MapSelect) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression_MapSelect* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression.MapSelect) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression.MapSelect) - MergeFrom(*source); - } -} - -void MaskExpression_MapSelect::MergeFrom(const MaskExpression_MapSelect& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression.MapSelect) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_child()) { - _internal_mutable_child()->::io::substrait::MaskExpression_Select::MergeFrom(from._internal_child()); - } - switch (from.select_case()) { - case kKey: { - _internal_mutable_key()->::io::substrait::MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); - break; - } - case kExpression: { - _internal_mutable_expression()->::io::substrait::MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); - break; - } - case SELECT_NOT_SET: { - break; - } - } -} - -void MaskExpression_MapSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression.MapSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression_MapSelect::CopyFrom(const MaskExpression_MapSelect& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression.MapSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression_MapSelect::IsInitialized() const { - return true; -} - -void MaskExpression_MapSelect::InternalSwap(MaskExpression_MapSelect* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(child_, other->child_); - swap(select_, other->select_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression_MapSelect::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[15]); -} - -// =================================================================== - -class MaskExpression::_Internal { - public: - static const ::io::substrait::MaskExpression_StructSelect& select(const MaskExpression* msg); -}; - -const ::io::substrait::MaskExpression_StructSelect& -MaskExpression::_Internal::select(const MaskExpression* msg) { - return *msg->select_; -} -MaskExpression::MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.MaskExpression) -} -MaskExpression::MaskExpression(const MaskExpression& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_select()) { - select_ = new ::io::substrait::MaskExpression_StructSelect(*from.select_); - } else { - select_ = nullptr; - } - maintain_singular_struct_ = from.maintain_singular_struct_; - // @@protoc_insertion_point(copy_constructor:io.substrait.MaskExpression) -} - -void MaskExpression::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&select_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&maintain_singular_struct_) - - reinterpret_cast(&select_)) + sizeof(maintain_singular_struct_)); -} - -MaskExpression::~MaskExpression() { - // @@protoc_insertion_point(destructor:io.substrait.MaskExpression) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void MaskExpression::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete select_; -} - -void MaskExpression::ArenaDtor(void* object) { - MaskExpression* _this = reinterpret_cast< MaskExpression* >(object); - (void)_this; -} -void MaskExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void MaskExpression::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void MaskExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.MaskExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArena() == nullptr && select_ != nullptr) { - delete select_; - } - select_ = nullptr; - maintain_singular_struct_ = false; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* MaskExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .io.substrait.MaskExpression.StructSelect select = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_select(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // bool maintain_singular_struct = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - maintain_singular_struct_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* MaskExpression::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.MaskExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .io.substrait.MaskExpression.StructSelect select = 1; - if (this->has_select()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::select(this), target, stream); - } - - // bool maintain_singular_struct = 2; - if (this->maintain_singular_struct() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_maintain_singular_struct(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.MaskExpression) - return target; -} - -size_t MaskExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.MaskExpression) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .io.substrait.MaskExpression.StructSelect select = 1; - if (this->has_select()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *select_); - } - - // bool maintain_singular_struct = 2; - if (this->maintain_singular_struct() != 0) { - total_size += 1 + 1; - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void MaskExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.MaskExpression) - GOOGLE_DCHECK_NE(&from, this); - const MaskExpression* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.MaskExpression) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.MaskExpression) - MergeFrom(*source); - } -} - -void MaskExpression::MergeFrom(const MaskExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.MaskExpression) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_select()) { - _internal_mutable_select()->::io::substrait::MaskExpression_StructSelect::MergeFrom(from._internal_select()); - } - if (from.maintain_singular_struct() != 0) { - _internal_set_maintain_singular_struct(from._internal_maintain_singular_struct()); - } -} - -void MaskExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.MaskExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void MaskExpression::CopyFrom(const MaskExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.MaskExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool MaskExpression::IsInitialized() const { - return true; -} - -void MaskExpression::InternalSwap(MaskExpression* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(MaskExpression, maintain_singular_struct_) - + sizeof(MaskExpression::maintain_singular_struct_) - - PROTOBUF_FIELD_OFFSET(MaskExpression, select_)>( - reinterpret_cast(&select_), - reinterpret_cast(&other->select_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata MaskExpression::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[16]); -} - -// =================================================================== - -class FieldReference::_Internal { - public: - static const ::io::substrait::ReferenceSegment& direct_reference(const FieldReference* msg); - static const ::io::substrait::MaskExpression& masked_reference(const FieldReference* msg); -}; - -const ::io::substrait::ReferenceSegment& -FieldReference::_Internal::direct_reference(const FieldReference* msg) { - return *msg->reference_type_.direct_reference_; -} -const ::io::substrait::MaskExpression& -FieldReference::_Internal::masked_reference(const FieldReference* msg) { - return *msg->reference_type_.masked_reference_; -} -void FieldReference::set_allocated_direct_reference(::io::substrait::ReferenceSegment* direct_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_reference_type(); - if (direct_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(direct_reference); - if (message_arena != submessage_arena) { - direct_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, direct_reference, submessage_arena); - } - set_has_direct_reference(); - reference_type_.direct_reference_ = direct_reference; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FieldReference.direct_reference) -} -void FieldReference::set_allocated_masked_reference(::io::substrait::MaskExpression* masked_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_reference_type(); - if (masked_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(masked_reference); - if (message_arena != submessage_arena) { - masked_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, masked_reference, submessage_arena); - } - set_has_masked_reference(); - reference_type_.masked_reference_ = masked_reference; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FieldReference.masked_reference) -} -FieldReference::FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FieldReference) -} -FieldReference::FieldReference(const FieldReference& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_reference_type(); - switch (from.reference_type_case()) { - case kDirectReference: { - _internal_mutable_direct_reference()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_direct_reference()); - break; - } - case kMaskedReference: { - _internal_mutable_masked_reference()->::io::substrait::MaskExpression::MergeFrom(from._internal_masked_reference()); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:io.substrait.FieldReference) -} - -void FieldReference::SharedCtor() { -clear_has_reference_type(); -} - -FieldReference::~FieldReference() { - // @@protoc_insertion_point(destructor:io.substrait.FieldReference) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void FieldReference::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (has_reference_type()) { - clear_reference_type(); - } -} - -void FieldReference::ArenaDtor(void* object) { - FieldReference* _this = reinterpret_cast< FieldReference* >(object); - (void)_this; -} -void FieldReference::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FieldReference::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FieldReference::clear_reference_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.FieldReference) - switch (reference_type_case()) { - case kDirectReference: { - if (GetArena() == nullptr) { - delete reference_type_.direct_reference_; - } - break; - } - case kMaskedReference: { - if (GetArena() == nullptr) { - delete reference_type_.masked_reference_; - } - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; -} - - -void FieldReference::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FieldReference) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_reference_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FieldReference::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .io.substrait.ReferenceSegment direct_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_direct_reference(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.MaskExpression masked_reference = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_masked_reference(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* FieldReference::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FieldReference) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .io.substrait.ReferenceSegment direct_reference = 1; - if (_internal_has_direct_reference()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::direct_reference(this), target, stream); - } - - // .io.substrait.MaskExpression masked_reference = 2; - if (_internal_has_masked_reference()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::masked_reference(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FieldReference) - return target; -} - -size_t FieldReference::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FieldReference) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (reference_type_case()) { - // .io.substrait.ReferenceSegment direct_reference = 1; - case kDirectReference: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.direct_reference_); - break; - } - // .io.substrait.MaskExpression masked_reference = 2; - case kMaskedReference: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.masked_reference_); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void FieldReference::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FieldReference) - GOOGLE_DCHECK_NE(&from, this); - const FieldReference* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FieldReference) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FieldReference) - MergeFrom(*source); - } -} - -void FieldReference::MergeFrom(const FieldReference& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FieldReference) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.reference_type_case()) { - case kDirectReference: { - _internal_mutable_direct_reference()->::io::substrait::ReferenceSegment::MergeFrom(from._internal_direct_reference()); - break; - } - case kMaskedReference: { - _internal_mutable_masked_reference()->::io::substrait::MaskExpression::MergeFrom(from._internal_masked_reference()); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } -} - -void FieldReference::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FieldReference) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void FieldReference::CopyFrom(const FieldReference& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FieldReference) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FieldReference::IsInitialized() const { - return true; -} - -void FieldReference::InternalSwap(FieldReference* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(reference_type_, other->reference_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FieldReference::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_selection_2eproto_getter, &descriptor_table_selection_2eproto_once, - file_level_metadata_selection_2eproto[17]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace substrait -} // namespace io -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment_MapKey* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment_MapKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment_MapKey >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment_MapKeyExpression* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment_MapKeyExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment_MapKeyExpression >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment_StructField* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment_StructField >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment_StructField >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment_ListElement* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment_ListElement >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment_ListElement >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment_ListRange* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment_ListRange >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment_ListRange >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::ReferenceSegment* Arena::CreateMaybeMessage< ::io::substrait::ReferenceSegment >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReferenceSegment >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_Select* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_Select >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_Select >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_StructSelect* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_StructSelect >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_StructSelect >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_StructItem* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_StructItem >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_StructItem >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_ListSelect* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_ListSelect >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect_MapKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_MapSelect_MapKey >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect_MapKeyExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_MapSelect_MapKeyExpression >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression_MapSelect* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression_MapSelect >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::MaskExpression* Arena::CreateMaybeMessage< ::io::substrait::MaskExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::MaskExpression >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::FieldReference* Arena::CreateMaybeMessage< ::io::substrait::FieldReference >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FieldReference >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/selection.pb.h b/cpp/src/generated/substrait/selection.pb.h deleted file mode 100644 index 63e123fa6a2..00000000000 --- a/cpp/src/generated/substrait/selection.pb.h +++ /dev/null @@ -1,5460 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: selection.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_selection_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_selection_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3016000 -#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 3016000 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_selection_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_selection_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[18] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_selection_2eproto; -namespace io { -namespace substrait { -class FieldReference; -struct FieldReferenceDefaultTypeInternal; -extern FieldReferenceDefaultTypeInternal _FieldReference_default_instance_; -class MaskExpression; -struct MaskExpressionDefaultTypeInternal; -extern MaskExpressionDefaultTypeInternal _MaskExpression_default_instance_; -class MaskExpression_ListSelect; -struct MaskExpression_ListSelectDefaultTypeInternal; -extern MaskExpression_ListSelectDefaultTypeInternal _MaskExpression_ListSelect_default_instance_; -class MaskExpression_ListSelect_ListSelectItem; -struct MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal; -extern MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_default_instance_; -class MaskExpression_ListSelect_ListSelectItem_ListElement; -struct MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal; -extern MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_; -class MaskExpression_ListSelect_ListSelectItem_ListSlice; -struct MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal; -extern MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_; -class MaskExpression_MapSelect; -struct MaskExpression_MapSelectDefaultTypeInternal; -extern MaskExpression_MapSelectDefaultTypeInternal _MaskExpression_MapSelect_default_instance_; -class MaskExpression_MapSelect_MapKey; -struct MaskExpression_MapSelect_MapKeyDefaultTypeInternal; -extern MaskExpression_MapSelect_MapKeyDefaultTypeInternal _MaskExpression_MapSelect_MapKey_default_instance_; -class MaskExpression_MapSelect_MapKeyExpression; -struct MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal; -extern MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _MaskExpression_MapSelect_MapKeyExpression_default_instance_; -class MaskExpression_Select; -struct MaskExpression_SelectDefaultTypeInternal; -extern MaskExpression_SelectDefaultTypeInternal _MaskExpression_Select_default_instance_; -class MaskExpression_StructItem; -struct MaskExpression_StructItemDefaultTypeInternal; -extern MaskExpression_StructItemDefaultTypeInternal _MaskExpression_StructItem_default_instance_; -class MaskExpression_StructSelect; -struct MaskExpression_StructSelectDefaultTypeInternal; -extern MaskExpression_StructSelectDefaultTypeInternal _MaskExpression_StructSelect_default_instance_; -class ReferenceSegment; -struct ReferenceSegmentDefaultTypeInternal; -extern ReferenceSegmentDefaultTypeInternal _ReferenceSegment_default_instance_; -class ReferenceSegment_ListElement; -struct ReferenceSegment_ListElementDefaultTypeInternal; -extern ReferenceSegment_ListElementDefaultTypeInternal _ReferenceSegment_ListElement_default_instance_; -class ReferenceSegment_ListRange; -struct ReferenceSegment_ListRangeDefaultTypeInternal; -extern ReferenceSegment_ListRangeDefaultTypeInternal _ReferenceSegment_ListRange_default_instance_; -class ReferenceSegment_MapKey; -struct ReferenceSegment_MapKeyDefaultTypeInternal; -extern ReferenceSegment_MapKeyDefaultTypeInternal _ReferenceSegment_MapKey_default_instance_; -class ReferenceSegment_MapKeyExpression; -struct ReferenceSegment_MapKeyExpressionDefaultTypeInternal; -extern ReferenceSegment_MapKeyExpressionDefaultTypeInternal _ReferenceSegment_MapKeyExpression_default_instance_; -class ReferenceSegment_StructField; -struct ReferenceSegment_StructFieldDefaultTypeInternal; -extern ReferenceSegment_StructFieldDefaultTypeInternal _ReferenceSegment_StructField_default_instance_; -} // namespace substrait -} // namespace io -PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::FieldReference* Arena::CreateMaybeMessage<::io::substrait::FieldReference>(Arena*); -template<> ::io::substrait::MaskExpression* Arena::CreateMaybeMessage<::io::substrait::MaskExpression>(Arena*); -template<> ::io::substrait::MaskExpression_ListSelect* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_ListSelect>(Arena*); -template<> ::io::substrait::MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_ListSelect_ListSelectItem>(Arena*); -template<> ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement>(Arena*); -template<> ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice>(Arena*); -template<> ::io::substrait::MaskExpression_MapSelect* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_MapSelect>(Arena*); -template<> ::io::substrait::MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_MapSelect_MapKey>(Arena*); -template<> ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_MapSelect_MapKeyExpression>(Arena*); -template<> ::io::substrait::MaskExpression_Select* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_Select>(Arena*); -template<> ::io::substrait::MaskExpression_StructItem* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_StructItem>(Arena*); -template<> ::io::substrait::MaskExpression_StructSelect* Arena::CreateMaybeMessage<::io::substrait::MaskExpression_StructSelect>(Arena*); -template<> ::io::substrait::ReferenceSegment* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment>(Arena*); -template<> ::io::substrait::ReferenceSegment_ListElement* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment_ListElement>(Arena*); -template<> ::io::substrait::ReferenceSegment_ListRange* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment_ListRange>(Arena*); -template<> ::io::substrait::ReferenceSegment_MapKey* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment_MapKey>(Arena*); -template<> ::io::substrait::ReferenceSegment_MapKeyExpression* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment_MapKeyExpression>(Arena*); -template<> ::io::substrait::ReferenceSegment_StructField* Arena::CreateMaybeMessage<::io::substrait::ReferenceSegment_StructField>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace io { -namespace substrait { - -// =================================================================== - -class ReferenceSegment_MapKey PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment.MapKey) */ { - public: - inline ReferenceSegment_MapKey() : ReferenceSegment_MapKey(nullptr) {} - ~ReferenceSegment_MapKey() override; - explicit constexpr ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReferenceSegment_MapKey(const ReferenceSegment_MapKey& from); - ReferenceSegment_MapKey(ReferenceSegment_MapKey&& from) noexcept - : ReferenceSegment_MapKey() { - *this = ::std::move(from); - } - - inline ReferenceSegment_MapKey& operator=(const ReferenceSegment_MapKey& from) { - CopyFrom(from); - return *this; - } - inline ReferenceSegment_MapKey& operator=(ReferenceSegment_MapKey&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 ReferenceSegment_MapKey& default_instance() { - return *internal_default_instance(); - } - static inline const ReferenceSegment_MapKey* internal_default_instance() { - return reinterpret_cast( - &_ReferenceSegment_MapKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(ReferenceSegment_MapKey& a, ReferenceSegment_MapKey& b) { - a.Swap(&b); - } - inline void Swap(ReferenceSegment_MapKey* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ReferenceSegment_MapKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline ReferenceSegment_MapKey* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReferenceSegment_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const ReferenceSegment_MapKey& from); - void MergeFrom(const ReferenceSegment_MapKey& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReferenceSegment_MapKey* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReferenceSegment.MapKey"; - } - protected: - explicit ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMapKeyFieldNumber = 1, - kChildFieldNumber = 2, - }; - // string map_key = 1; - void clear_map_key(); - const std::string& map_key() const; - template - void set_map_key(ArgT0&& arg0, ArgT... args); - std::string* mutable_map_key(); - std::string* release_map_key(); - void set_allocated_map_key(std::string* map_key); - private: - const std::string& _internal_map_key() const; - void _internal_set_map_key(const std::string& value); - std::string* _internal_mutable_map_key(); - public: - - // .io.substrait.ReferenceSegment child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::io::substrait::ReferenceSegment& child() const; - ::io::substrait::ReferenceSegment* release_child(); - ::io::substrait::ReferenceSegment* mutable_child(); - void set_allocated_child(::io::substrait::ReferenceSegment* child); - private: - const ::io::substrait::ReferenceSegment& _internal_child() const; - ::io::substrait::ReferenceSegment* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::io::substrait::ReferenceSegment* child); - ::io::substrait::ReferenceSegment* unsafe_arena_release_child(); - - // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment.MapKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_; - ::io::substrait::ReferenceSegment* child_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class ReferenceSegment_MapKeyExpression PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment.MapKeyExpression) */ { - public: - inline ReferenceSegment_MapKeyExpression() : ReferenceSegment_MapKeyExpression(nullptr) {} - ~ReferenceSegment_MapKeyExpression() override; - explicit constexpr ReferenceSegment_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReferenceSegment_MapKeyExpression(const ReferenceSegment_MapKeyExpression& from); - ReferenceSegment_MapKeyExpression(ReferenceSegment_MapKeyExpression&& from) noexcept - : ReferenceSegment_MapKeyExpression() { - *this = ::std::move(from); - } - - inline ReferenceSegment_MapKeyExpression& operator=(const ReferenceSegment_MapKeyExpression& from) { - CopyFrom(from); - return *this; - } - inline ReferenceSegment_MapKeyExpression& operator=(ReferenceSegment_MapKeyExpression&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 ReferenceSegment_MapKeyExpression& default_instance() { - return *internal_default_instance(); - } - static inline const ReferenceSegment_MapKeyExpression* internal_default_instance() { - return reinterpret_cast( - &_ReferenceSegment_MapKeyExpression_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(ReferenceSegment_MapKeyExpression& a, ReferenceSegment_MapKeyExpression& b) { - a.Swap(&b); - } - inline void Swap(ReferenceSegment_MapKeyExpression* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ReferenceSegment_MapKeyExpression* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline ReferenceSegment_MapKeyExpression* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReferenceSegment_MapKeyExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const ReferenceSegment_MapKeyExpression& from); - void MergeFrom(const ReferenceSegment_MapKeyExpression& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReferenceSegment_MapKeyExpression* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReferenceSegment.MapKeyExpression"; - } - protected: - explicit ReferenceSegment_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMapKeyExpressionFieldNumber = 1, - kChildFieldNumber = 2, - }; - // string map_key_expression = 1; - void clear_map_key_expression(); - const std::string& map_key_expression() const; - template - void set_map_key_expression(ArgT0&& arg0, ArgT... args); - std::string* mutable_map_key_expression(); - std::string* release_map_key_expression(); - void set_allocated_map_key_expression(std::string* map_key_expression); - private: - const std::string& _internal_map_key_expression() const; - void _internal_set_map_key_expression(const std::string& value); - std::string* _internal_mutable_map_key_expression(); - public: - - // .io.substrait.ReferenceSegment child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::io::substrait::ReferenceSegment& child() const; - ::io::substrait::ReferenceSegment* release_child(); - ::io::substrait::ReferenceSegment* mutable_child(); - void set_allocated_child(::io::substrait::ReferenceSegment* child); - private: - const ::io::substrait::ReferenceSegment& _internal_child() const; - ::io::substrait::ReferenceSegment* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::io::substrait::ReferenceSegment* child); - ::io::substrait::ReferenceSegment* unsafe_arena_release_child(); - - // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment.MapKeyExpression) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_expression_; - ::io::substrait::ReferenceSegment* child_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class ReferenceSegment_StructField PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment.StructField) */ { - public: - inline ReferenceSegment_StructField() : ReferenceSegment_StructField(nullptr) {} - ~ReferenceSegment_StructField() override; - explicit constexpr ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReferenceSegment_StructField(const ReferenceSegment_StructField& from); - ReferenceSegment_StructField(ReferenceSegment_StructField&& from) noexcept - : ReferenceSegment_StructField() { - *this = ::std::move(from); - } - - inline ReferenceSegment_StructField& operator=(const ReferenceSegment_StructField& from) { - CopyFrom(from); - return *this; - } - inline ReferenceSegment_StructField& operator=(ReferenceSegment_StructField&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 ReferenceSegment_StructField& default_instance() { - return *internal_default_instance(); - } - static inline const ReferenceSegment_StructField* internal_default_instance() { - return reinterpret_cast( - &_ReferenceSegment_StructField_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(ReferenceSegment_StructField& a, ReferenceSegment_StructField& b) { - a.Swap(&b); - } - inline void Swap(ReferenceSegment_StructField* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ReferenceSegment_StructField* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline ReferenceSegment_StructField* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReferenceSegment_StructField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const ReferenceSegment_StructField& from); - void MergeFrom(const ReferenceSegment_StructField& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReferenceSegment_StructField* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReferenceSegment.StructField"; - } - protected: - explicit ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kChildFieldNumber = 2, - kFieldFieldNumber = 1, - }; - // .io.substrait.ReferenceSegment child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::io::substrait::ReferenceSegment& child() const; - ::io::substrait::ReferenceSegment* release_child(); - ::io::substrait::ReferenceSegment* mutable_child(); - void set_allocated_child(::io::substrait::ReferenceSegment* child); - private: - const ::io::substrait::ReferenceSegment& _internal_child() const; - ::io::substrait::ReferenceSegment* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::io::substrait::ReferenceSegment* child); - ::io::substrait::ReferenceSegment* unsafe_arena_release_child(); - - // int32 field = 1; - void clear_field(); - ::PROTOBUF_NAMESPACE_ID::int32 field() const; - void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); - private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; - void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment.StructField) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::io::substrait::ReferenceSegment* child_; - ::PROTOBUF_NAMESPACE_ID::int32 field_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class ReferenceSegment_ListElement PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment.ListElement) */ { - public: - inline ReferenceSegment_ListElement() : ReferenceSegment_ListElement(nullptr) {} - ~ReferenceSegment_ListElement() override; - explicit constexpr ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReferenceSegment_ListElement(const ReferenceSegment_ListElement& from); - ReferenceSegment_ListElement(ReferenceSegment_ListElement&& from) noexcept - : ReferenceSegment_ListElement() { - *this = ::std::move(from); - } - - inline ReferenceSegment_ListElement& operator=(const ReferenceSegment_ListElement& from) { - CopyFrom(from); - return *this; - } - inline ReferenceSegment_ListElement& operator=(ReferenceSegment_ListElement&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 ReferenceSegment_ListElement& default_instance() { - return *internal_default_instance(); - } - static inline const ReferenceSegment_ListElement* internal_default_instance() { - return reinterpret_cast( - &_ReferenceSegment_ListElement_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(ReferenceSegment_ListElement& a, ReferenceSegment_ListElement& b) { - a.Swap(&b); - } - inline void Swap(ReferenceSegment_ListElement* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ReferenceSegment_ListElement* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline ReferenceSegment_ListElement* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReferenceSegment_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const ReferenceSegment_ListElement& from); - void MergeFrom(const ReferenceSegment_ListElement& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReferenceSegment_ListElement* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReferenceSegment.ListElement"; - } - protected: - explicit ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kChildFieldNumber = 2, - kOffsetFieldNumber = 1, - }; - // .io.substrait.ReferenceSegment child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::io::substrait::ReferenceSegment& child() const; - ::io::substrait::ReferenceSegment* release_child(); - ::io::substrait::ReferenceSegment* mutable_child(); - void set_allocated_child(::io::substrait::ReferenceSegment* child); - private: - const ::io::substrait::ReferenceSegment& _internal_child() const; - ::io::substrait::ReferenceSegment* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::io::substrait::ReferenceSegment* child); - ::io::substrait::ReferenceSegment* unsafe_arena_release_child(); - - // int32 offset = 1; - void clear_offset(); - ::PROTOBUF_NAMESPACE_ID::int32 offset() const; - void set_offset(::PROTOBUF_NAMESPACE_ID::int32 value); - private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_offset() const; - void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment.ListElement) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::io::substrait::ReferenceSegment* child_; - ::PROTOBUF_NAMESPACE_ID::int32 offset_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class ReferenceSegment_ListRange PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment.ListRange) */ { - public: - inline ReferenceSegment_ListRange() : ReferenceSegment_ListRange(nullptr) {} - ~ReferenceSegment_ListRange() override; - explicit constexpr ReferenceSegment_ListRange(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReferenceSegment_ListRange(const ReferenceSegment_ListRange& from); - ReferenceSegment_ListRange(ReferenceSegment_ListRange&& from) noexcept - : ReferenceSegment_ListRange() { - *this = ::std::move(from); - } - - inline ReferenceSegment_ListRange& operator=(const ReferenceSegment_ListRange& from) { - CopyFrom(from); - return *this; - } - inline ReferenceSegment_ListRange& operator=(ReferenceSegment_ListRange&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 ReferenceSegment_ListRange& default_instance() { - return *internal_default_instance(); - } - static inline const ReferenceSegment_ListRange* internal_default_instance() { - return reinterpret_cast( - &_ReferenceSegment_ListRange_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(ReferenceSegment_ListRange& a, ReferenceSegment_ListRange& b) { - a.Swap(&b); - } - inline void Swap(ReferenceSegment_ListRange* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ReferenceSegment_ListRange* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline ReferenceSegment_ListRange* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReferenceSegment_ListRange* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const ReferenceSegment_ListRange& from); - void MergeFrom(const ReferenceSegment_ListRange& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReferenceSegment_ListRange* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReferenceSegment.ListRange"; - } - protected: - explicit ReferenceSegment_ListRange(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kChildFieldNumber = 3, - kStartFieldNumber = 1, - kEndFieldNumber = 2, - }; - // .io.substrait.ReferenceSegment child = 3; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::io::substrait::ReferenceSegment& child() const; - ::io::substrait::ReferenceSegment* release_child(); - ::io::substrait::ReferenceSegment* mutable_child(); - void set_allocated_child(::io::substrait::ReferenceSegment* child); - private: - const ::io::substrait::ReferenceSegment& _internal_child() const; - ::io::substrait::ReferenceSegment* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::io::substrait::ReferenceSegment* child); - ::io::substrait::ReferenceSegment* unsafe_arena_release_child(); - - // int32 start = 1; - void clear_start(); - ::PROTOBUF_NAMESPACE_ID::int32 start() const; - void set_start(::PROTOBUF_NAMESPACE_ID::int32 value); - private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_start() const; - void _internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value); - public: - - // int32 end = 2; - void clear_end(); - ::PROTOBUF_NAMESPACE_ID::int32 end() const; - void set_end(::PROTOBUF_NAMESPACE_ID::int32 value); - private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const; - void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment.ListRange) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::io::substrait::ReferenceSegment* child_; - ::PROTOBUF_NAMESPACE_ID::int32 start_; - ::PROTOBUF_NAMESPACE_ID::int32 end_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class ReferenceSegment PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReferenceSegment) */ { - public: - inline ReferenceSegment() : ReferenceSegment(nullptr) {} - ~ReferenceSegment() override; - explicit constexpr ReferenceSegment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReferenceSegment(const ReferenceSegment& from); - ReferenceSegment(ReferenceSegment&& from) noexcept - : ReferenceSegment() { - *this = ::std::move(from); - } - - inline ReferenceSegment& operator=(const ReferenceSegment& from) { - CopyFrom(from); - return *this; - } - inline ReferenceSegment& operator=(ReferenceSegment&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 ReferenceSegment& default_instance() { - return *internal_default_instance(); - } - enum ReferenceTypeCase { - kMapKey = 1, - kExpression = 2, - kStructField = 3, - kListElement = 4, - kListRange = 5, - REFERENCE_TYPE_NOT_SET = 0, - }; - - static inline const ReferenceSegment* internal_default_instance() { - return reinterpret_cast( - &_ReferenceSegment_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(ReferenceSegment& a, ReferenceSegment& b) { - a.Swap(&b); - } - inline void Swap(ReferenceSegment* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ReferenceSegment* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline ReferenceSegment* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReferenceSegment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const ReferenceSegment& from); - void MergeFrom(const ReferenceSegment& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReferenceSegment* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReferenceSegment"; - } - protected: - explicit ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ReferenceSegment_MapKey MapKey; - typedef ReferenceSegment_MapKeyExpression MapKeyExpression; - typedef ReferenceSegment_StructField StructField; - typedef ReferenceSegment_ListElement ListElement; - typedef ReferenceSegment_ListRange ListRange; - - // accessors ------------------------------------------------------- - - enum : int { - kMapKeyFieldNumber = 1, - kExpressionFieldNumber = 2, - kStructFieldFieldNumber = 3, - kListElementFieldNumber = 4, - kListRangeFieldNumber = 5, - }; - // .io.substrait.ReferenceSegment.MapKey map_key = 1; - bool has_map_key() const; - private: - bool _internal_has_map_key() const; - public: - void clear_map_key(); - const ::io::substrait::ReferenceSegment_MapKey& map_key() const; - ::io::substrait::ReferenceSegment_MapKey* release_map_key(); - ::io::substrait::ReferenceSegment_MapKey* mutable_map_key(); - void set_allocated_map_key(::io::substrait::ReferenceSegment_MapKey* map_key); - private: - const ::io::substrait::ReferenceSegment_MapKey& _internal_map_key() const; - ::io::substrait::ReferenceSegment_MapKey* _internal_mutable_map_key(); - public: - void unsafe_arena_set_allocated_map_key( - ::io::substrait::ReferenceSegment_MapKey* map_key); - ::io::substrait::ReferenceSegment_MapKey* unsafe_arena_release_map_key(); - - // .io.substrait.ReferenceSegment.MapKeyExpression expression = 2; - bool has_expression() const; - private: - bool _internal_has_expression() const; - public: - void clear_expression(); - const ::io::substrait::ReferenceSegment_MapKeyExpression& expression() const; - ::io::substrait::ReferenceSegment_MapKeyExpression* release_expression(); - ::io::substrait::ReferenceSegment_MapKeyExpression* mutable_expression(); - void set_allocated_expression(::io::substrait::ReferenceSegment_MapKeyExpression* expression); - private: - const ::io::substrait::ReferenceSegment_MapKeyExpression& _internal_expression() const; - ::io::substrait::ReferenceSegment_MapKeyExpression* _internal_mutable_expression(); - public: - void unsafe_arena_set_allocated_expression( - ::io::substrait::ReferenceSegment_MapKeyExpression* expression); - ::io::substrait::ReferenceSegment_MapKeyExpression* unsafe_arena_release_expression(); - - // .io.substrait.ReferenceSegment.StructField struct_field = 3; - bool has_struct_field() const; - private: - bool _internal_has_struct_field() const; - public: - void clear_struct_field(); - const ::io::substrait::ReferenceSegment_StructField& struct_field() const; - ::io::substrait::ReferenceSegment_StructField* release_struct_field(); - ::io::substrait::ReferenceSegment_StructField* mutable_struct_field(); - void set_allocated_struct_field(::io::substrait::ReferenceSegment_StructField* struct_field); - private: - const ::io::substrait::ReferenceSegment_StructField& _internal_struct_field() const; - ::io::substrait::ReferenceSegment_StructField* _internal_mutable_struct_field(); - public: - void unsafe_arena_set_allocated_struct_field( - ::io::substrait::ReferenceSegment_StructField* struct_field); - ::io::substrait::ReferenceSegment_StructField* unsafe_arena_release_struct_field(); - - // .io.substrait.ReferenceSegment.ListElement list_element = 4; - bool has_list_element() const; - private: - bool _internal_has_list_element() const; - public: - void clear_list_element(); - const ::io::substrait::ReferenceSegment_ListElement& list_element() const; - ::io::substrait::ReferenceSegment_ListElement* release_list_element(); - ::io::substrait::ReferenceSegment_ListElement* mutable_list_element(); - void set_allocated_list_element(::io::substrait::ReferenceSegment_ListElement* list_element); - private: - const ::io::substrait::ReferenceSegment_ListElement& _internal_list_element() const; - ::io::substrait::ReferenceSegment_ListElement* _internal_mutable_list_element(); - public: - void unsafe_arena_set_allocated_list_element( - ::io::substrait::ReferenceSegment_ListElement* list_element); - ::io::substrait::ReferenceSegment_ListElement* unsafe_arena_release_list_element(); - - // .io.substrait.ReferenceSegment.ListRange list_range = 5; - bool has_list_range() const; - private: - bool _internal_has_list_range() const; - public: - void clear_list_range(); - const ::io::substrait::ReferenceSegment_ListRange& list_range() const; - ::io::substrait::ReferenceSegment_ListRange* release_list_range(); - ::io::substrait::ReferenceSegment_ListRange* mutable_list_range(); - void set_allocated_list_range(::io::substrait::ReferenceSegment_ListRange* list_range); - private: - const ::io::substrait::ReferenceSegment_ListRange& _internal_list_range() const; - ::io::substrait::ReferenceSegment_ListRange* _internal_mutable_list_range(); - public: - void unsafe_arena_set_allocated_list_range( - ::io::substrait::ReferenceSegment_ListRange* list_range); - ::io::substrait::ReferenceSegment_ListRange* unsafe_arena_release_list_range(); - - void clear_reference_type(); - ReferenceTypeCase reference_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.ReferenceSegment) - private: - class _Internal; - void set_has_map_key(); - void set_has_expression(); - void set_has_struct_field(); - void set_has_list_element(); - void set_has_list_range(); - - inline bool has_reference_type() const; - inline void clear_has_reference_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union ReferenceTypeUnion { - constexpr ReferenceTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::ReferenceSegment_MapKey* map_key_; - ::io::substrait::ReferenceSegment_MapKeyExpression* expression_; - ::io::substrait::ReferenceSegment_StructField* struct_field_; - ::io::substrait::ReferenceSegment_ListElement* list_element_; - ::io::substrait::ReferenceSegment_ListRange* list_range_; - } reference_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression_Select PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.Select) */ { - public: - inline MaskExpression_Select() : MaskExpression_Select(nullptr) {} - ~MaskExpression_Select() override; - explicit constexpr MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression_Select(const MaskExpression_Select& from); - MaskExpression_Select(MaskExpression_Select&& from) noexcept - : MaskExpression_Select() { - *this = ::std::move(from); - } - - inline MaskExpression_Select& operator=(const MaskExpression_Select& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression_Select& operator=(MaskExpression_Select&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression_Select& default_instance() { - return *internal_default_instance(); - } - enum TypeCase { - kStruct = 1, - kList = 2, - kMap = 3, - TYPE_NOT_SET = 0, - }; - - static inline const MaskExpression_Select* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_Select_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(MaskExpression_Select& a, MaskExpression_Select& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression_Select* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression_Select* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression_Select* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression_Select* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression_Select& from); - void MergeFrom(const MaskExpression_Select& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression_Select* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression.Select"; - } - protected: - explicit MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kStructFieldNumber = 1, - kListFieldNumber = 2, - kMapFieldNumber = 3, - }; - // .io.substrait.MaskExpression.StructSelect struct = 1; - bool has_struct_() const; - private: - bool _internal_has_struct_() const; - public: - void clear_struct_(); - const ::io::substrait::MaskExpression_StructSelect& struct_() const; - ::io::substrait::MaskExpression_StructSelect* release_struct_(); - ::io::substrait::MaskExpression_StructSelect* mutable_struct_(); - void set_allocated_struct_(::io::substrait::MaskExpression_StructSelect* struct_); - private: - const ::io::substrait::MaskExpression_StructSelect& _internal_struct_() const; - ::io::substrait::MaskExpression_StructSelect* _internal_mutable_struct_(); - public: - void unsafe_arena_set_allocated_struct_( - ::io::substrait::MaskExpression_StructSelect* struct_); - ::io::substrait::MaskExpression_StructSelect* unsafe_arena_release_struct_(); - - // .io.substrait.MaskExpression.ListSelect list = 2; - bool has_list() const; - private: - bool _internal_has_list() const; - public: - void clear_list(); - const ::io::substrait::MaskExpression_ListSelect& list() const; - ::io::substrait::MaskExpression_ListSelect* release_list(); - ::io::substrait::MaskExpression_ListSelect* mutable_list(); - void set_allocated_list(::io::substrait::MaskExpression_ListSelect* list); - private: - const ::io::substrait::MaskExpression_ListSelect& _internal_list() const; - ::io::substrait::MaskExpression_ListSelect* _internal_mutable_list(); - public: - void unsafe_arena_set_allocated_list( - ::io::substrait::MaskExpression_ListSelect* list); - ::io::substrait::MaskExpression_ListSelect* unsafe_arena_release_list(); - - // .io.substrait.MaskExpression.MapSelect map = 3; - bool has_map() const; - private: - bool _internal_has_map() const; - public: - void clear_map(); - const ::io::substrait::MaskExpression_MapSelect& map() const; - ::io::substrait::MaskExpression_MapSelect* release_map(); - ::io::substrait::MaskExpression_MapSelect* mutable_map(); - void set_allocated_map(::io::substrait::MaskExpression_MapSelect* map); - private: - const ::io::substrait::MaskExpression_MapSelect& _internal_map() const; - ::io::substrait::MaskExpression_MapSelect* _internal_mutable_map(); - public: - void unsafe_arena_set_allocated_map( - ::io::substrait::MaskExpression_MapSelect* map); - ::io::substrait::MaskExpression_MapSelect* unsafe_arena_release_map(); - - void clear_type(); - TypeCase type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.Select) - private: - class _Internal; - void set_has_struct_(); - void set_has_list(); - void set_has_map(); - - inline bool has_type() const; - inline void clear_has_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union TypeUnion { - constexpr TypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::MaskExpression_StructSelect* struct__; - ::io::substrait::MaskExpression_ListSelect* list_; - ::io::substrait::MaskExpression_MapSelect* map_; - } type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression_StructSelect PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.StructSelect) */ { - public: - inline MaskExpression_StructSelect() : MaskExpression_StructSelect(nullptr) {} - ~MaskExpression_StructSelect() override; - explicit constexpr MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression_StructSelect(const MaskExpression_StructSelect& from); - MaskExpression_StructSelect(MaskExpression_StructSelect&& from) noexcept - : MaskExpression_StructSelect() { - *this = ::std::move(from); - } - - inline MaskExpression_StructSelect& operator=(const MaskExpression_StructSelect& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression_StructSelect& operator=(MaskExpression_StructSelect&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression_StructSelect& default_instance() { - return *internal_default_instance(); - } - static inline const MaskExpression_StructSelect* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_StructSelect_default_instance_); - } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(MaskExpression_StructSelect& a, MaskExpression_StructSelect& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression_StructSelect* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression_StructSelect* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression_StructSelect* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression_StructSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression_StructSelect& from); - void MergeFrom(const MaskExpression_StructSelect& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression_StructSelect* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression.StructSelect"; - } - protected: - explicit MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kStructItemsFieldNumber = 1, - }; - // repeated .io.substrait.MaskExpression.StructItem struct_items = 1; - int struct_items_size() const; - private: - int _internal_struct_items_size() const; - public: - void clear_struct_items(); - ::io::substrait::MaskExpression_StructItem* mutable_struct_items(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_StructItem >* - mutable_struct_items(); - private: - const ::io::substrait::MaskExpression_StructItem& _internal_struct_items(int index) const; - ::io::substrait::MaskExpression_StructItem* _internal_add_struct_items(); - public: - const ::io::substrait::MaskExpression_StructItem& struct_items(int index) const; - ::io::substrait::MaskExpression_StructItem* add_struct_items(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_StructItem >& - struct_items() const; - - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.StructSelect) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_StructItem > struct_items_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression_StructItem PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.StructItem) */ { - public: - inline MaskExpression_StructItem() : MaskExpression_StructItem(nullptr) {} - ~MaskExpression_StructItem() override; - explicit constexpr MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression_StructItem(const MaskExpression_StructItem& from); - MaskExpression_StructItem(MaskExpression_StructItem&& from) noexcept - : MaskExpression_StructItem() { - *this = ::std::move(from); - } - - inline MaskExpression_StructItem& operator=(const MaskExpression_StructItem& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression_StructItem& operator=(MaskExpression_StructItem&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression_StructItem& default_instance() { - return *internal_default_instance(); - } - static inline const MaskExpression_StructItem* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_StructItem_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(MaskExpression_StructItem& a, MaskExpression_StructItem& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression_StructItem* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression_StructItem* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression_StructItem* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression_StructItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression_StructItem& from); - void MergeFrom(const MaskExpression_StructItem& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression_StructItem* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression.StructItem"; - } - protected: - explicit MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kChildFieldNumber = 2, - kFieldFieldNumber = 1, - }; - // .io.substrait.MaskExpression.Select child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::io::substrait::MaskExpression_Select& child() const; - ::io::substrait::MaskExpression_Select* release_child(); - ::io::substrait::MaskExpression_Select* mutable_child(); - void set_allocated_child(::io::substrait::MaskExpression_Select* child); - private: - const ::io::substrait::MaskExpression_Select& _internal_child() const; - ::io::substrait::MaskExpression_Select* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::io::substrait::MaskExpression_Select* child); - ::io::substrait::MaskExpression_Select* unsafe_arena_release_child(); - - // int32 field = 1; - void clear_field(); - ::PROTOBUF_NAMESPACE_ID::int32 field() const; - void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); - private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; - void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.StructItem) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::io::substrait::MaskExpression_Select* child_; - ::PROTOBUF_NAMESPACE_ID::int32 field_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) */ { - public: - inline MaskExpression_ListSelect_ListSelectItem_ListElement() : MaskExpression_ListSelect_ListSelectItem_ListElement(nullptr) {} - ~MaskExpression_ListSelect_ListSelectItem_ListElement() override; - explicit constexpr MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression_ListSelect_ListSelectItem_ListElement(const MaskExpression_ListSelect_ListSelectItem_ListElement& from); - MaskExpression_ListSelect_ListSelectItem_ListElement(MaskExpression_ListSelect_ListSelectItem_ListElement&& from) noexcept - : MaskExpression_ListSelect_ListSelectItem_ListElement() { - *this = ::std::move(from); - } - - inline MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(const MaskExpression_ListSelect_ListSelectItem_ListElement& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(MaskExpression_ListSelect_ListSelectItem_ListElement&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression_ListSelect_ListSelectItem_ListElement& default_instance() { - return *internal_default_instance(); - } - static inline const MaskExpression_ListSelect_ListSelectItem_ListElement* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(MaskExpression_ListSelect_ListSelectItem_ListElement& a, MaskExpression_ListSelect_ListSelectItem_ListElement& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression_ListSelect_ListSelectItem_ListElement* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression_ListSelect_ListSelectItem_ListElement* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression_ListSelect_ListSelectItem_ListElement* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression_ListSelect_ListSelectItem_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression_ListSelect_ListSelectItem_ListElement& from); - void MergeFrom(const MaskExpression_ListSelect_ListSelectItem_ListElement& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression_ListSelect_ListSelectItem_ListElement* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement"; - } - protected: - explicit MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kFieldFieldNumber = 1, - }; - // int32 field = 1; - void clear_field(); - ::PROTOBUF_NAMESPACE_ID::int32 field() const; - void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); - private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; - void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 field_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) */ { - public: - inline MaskExpression_ListSelect_ListSelectItem_ListSlice() : MaskExpression_ListSelect_ListSelectItem_ListSlice(nullptr) {} - ~MaskExpression_ListSelect_ListSelectItem_ListSlice() override; - explicit constexpr MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression_ListSelect_ListSelectItem_ListSlice(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from); - MaskExpression_ListSelect_ListSelectItem_ListSlice(MaskExpression_ListSelect_ListSelectItem_ListSlice&& from) noexcept - : MaskExpression_ListSelect_ListSelectItem_ListSlice() { - *this = ::std::move(from); - } - - inline MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(MaskExpression_ListSelect_ListSelectItem_ListSlice&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression_ListSelect_ListSelectItem_ListSlice& default_instance() { - return *internal_default_instance(); - } - static inline const MaskExpression_ListSelect_ListSelectItem_ListSlice* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(MaskExpression_ListSelect_ListSelectItem_ListSlice& a, MaskExpression_ListSelect_ListSelectItem_ListSlice& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression_ListSelect_ListSelectItem_ListSlice* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression_ListSelect_ListSelectItem_ListSlice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from); - void MergeFrom(const MaskExpression_ListSelect_ListSelectItem_ListSlice& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression_ListSelect_ListSelectItem_ListSlice* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice"; - } - protected: - explicit MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kStartFieldNumber = 1, - kEndFieldNumber = 2, - }; - // int32 start = 1; - void clear_start(); - ::PROTOBUF_NAMESPACE_ID::int32 start() const; - void set_start(::PROTOBUF_NAMESPACE_ID::int32 value); - private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_start() const; - void _internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value); - public: - - // int32 end = 2; - void clear_end(); - ::PROTOBUF_NAMESPACE_ID::int32 end() const; - void set_end(::PROTOBUF_NAMESPACE_ID::int32 value); - private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const; - void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 start_; - ::PROTOBUF_NAMESPACE_ID::int32 end_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.ListSelect.ListSelectItem) */ { - public: - inline MaskExpression_ListSelect_ListSelectItem() : MaskExpression_ListSelect_ListSelectItem(nullptr) {} - ~MaskExpression_ListSelect_ListSelectItem() override; - explicit constexpr MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression_ListSelect_ListSelectItem(const MaskExpression_ListSelect_ListSelectItem& from); - MaskExpression_ListSelect_ListSelectItem(MaskExpression_ListSelect_ListSelectItem&& from) noexcept - : MaskExpression_ListSelect_ListSelectItem() { - *this = ::std::move(from); - } - - inline MaskExpression_ListSelect_ListSelectItem& operator=(const MaskExpression_ListSelect_ListSelectItem& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression_ListSelect_ListSelectItem& operator=(MaskExpression_ListSelect_ListSelectItem&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression_ListSelect_ListSelectItem& default_instance() { - return *internal_default_instance(); - } - enum TypeCase { - kItem = 1, - kSlice = 2, - TYPE_NOT_SET = 0, - }; - - static inline const MaskExpression_ListSelect_ListSelectItem* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_ListSelect_ListSelectItem_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(MaskExpression_ListSelect_ListSelectItem& a, MaskExpression_ListSelect_ListSelectItem& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression_ListSelect_ListSelectItem* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression_ListSelect_ListSelectItem* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression_ListSelect_ListSelectItem* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression_ListSelect_ListSelectItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression_ListSelect_ListSelectItem& from); - void MergeFrom(const MaskExpression_ListSelect_ListSelectItem& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression_ListSelect_ListSelectItem* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression.ListSelect.ListSelectItem"; - } - protected: - explicit MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef MaskExpression_ListSelect_ListSelectItem_ListElement ListElement; - typedef MaskExpression_ListSelect_ListSelectItem_ListSlice ListSlice; - - // accessors ------------------------------------------------------- - - enum : int { - kItemFieldNumber = 1, - kSliceFieldNumber = 2, - }; - // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; - bool has_item() const; - private: - bool _internal_has_item() const; - public: - void clear_item(); - const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& item() const; - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* release_item(); - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* mutable_item(); - void set_allocated_item(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* item); - private: - const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& _internal_item() const; - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* _internal_mutable_item(); - public: - void unsafe_arena_set_allocated_item( - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* item); - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* unsafe_arena_release_item(); - - // .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; - bool has_slice() const; - private: - bool _internal_has_slice() const; - public: - void clear_slice(); - const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& slice() const; - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* release_slice(); - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* mutable_slice(); - void set_allocated_slice(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); - private: - const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& _internal_slice() const; - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* _internal_mutable_slice(); - public: - void unsafe_arena_set_allocated_slice( - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* unsafe_arena_release_slice(); - - void clear_type(); - TypeCase type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.ListSelect.ListSelectItem) - private: - class _Internal; - void set_has_item(); - void set_has_slice(); - - inline bool has_type() const; - inline void clear_has_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union TypeUnion { - constexpr TypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* item_; - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* slice_; - } type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression_ListSelect PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.ListSelect) */ { - public: - inline MaskExpression_ListSelect() : MaskExpression_ListSelect(nullptr) {} - ~MaskExpression_ListSelect() override; - explicit constexpr MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression_ListSelect(const MaskExpression_ListSelect& from); - MaskExpression_ListSelect(MaskExpression_ListSelect&& from) noexcept - : MaskExpression_ListSelect() { - *this = ::std::move(from); - } - - inline MaskExpression_ListSelect& operator=(const MaskExpression_ListSelect& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression_ListSelect& operator=(MaskExpression_ListSelect&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression_ListSelect& default_instance() { - return *internal_default_instance(); - } - static inline const MaskExpression_ListSelect* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_ListSelect_default_instance_); - } - static constexpr int kIndexInFileMessages = - 12; - - friend void swap(MaskExpression_ListSelect& a, MaskExpression_ListSelect& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression_ListSelect* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression_ListSelect* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression_ListSelect* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression_ListSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression_ListSelect& from); - void MergeFrom(const MaskExpression_ListSelect& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression_ListSelect* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression.ListSelect"; - } - protected: - explicit MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef MaskExpression_ListSelect_ListSelectItem ListSelectItem; - - // accessors ------------------------------------------------------- - - enum : int { - kSelectionFieldNumber = 1, - kChildFieldNumber = 2, - }; - // repeated .io.substrait.MaskExpression.ListSelect.ListSelectItem selection = 1; - int selection_size() const; - private: - int _internal_selection_size() const; - public: - void clear_selection(); - ::io::substrait::MaskExpression_ListSelect_ListSelectItem* mutable_selection(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >* - mutable_selection(); - private: - const ::io::substrait::MaskExpression_ListSelect_ListSelectItem& _internal_selection(int index) const; - ::io::substrait::MaskExpression_ListSelect_ListSelectItem* _internal_add_selection(); - public: - const ::io::substrait::MaskExpression_ListSelect_ListSelectItem& selection(int index) const; - ::io::substrait::MaskExpression_ListSelect_ListSelectItem* add_selection(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >& - selection() const; - - // .io.substrait.MaskExpression.Select child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::io::substrait::MaskExpression_Select& child() const; - ::io::substrait::MaskExpression_Select* release_child(); - ::io::substrait::MaskExpression_Select* mutable_child(); - void set_allocated_child(::io::substrait::MaskExpression_Select* child); - private: - const ::io::substrait::MaskExpression_Select& _internal_child() const; - ::io::substrait::MaskExpression_Select* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::io::substrait::MaskExpression_Select* child); - ::io::substrait::MaskExpression_Select* unsafe_arena_release_child(); - - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.ListSelect) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_ListSelect_ListSelectItem > selection_; - ::io::substrait::MaskExpression_Select* child_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.MapSelect.MapKey) */ { - public: - inline MaskExpression_MapSelect_MapKey() : MaskExpression_MapSelect_MapKey(nullptr) {} - ~MaskExpression_MapSelect_MapKey() override; - explicit constexpr MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression_MapSelect_MapKey(const MaskExpression_MapSelect_MapKey& from); - MaskExpression_MapSelect_MapKey(MaskExpression_MapSelect_MapKey&& from) noexcept - : MaskExpression_MapSelect_MapKey() { - *this = ::std::move(from); - } - - inline MaskExpression_MapSelect_MapKey& operator=(const MaskExpression_MapSelect_MapKey& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression_MapSelect_MapKey& operator=(MaskExpression_MapSelect_MapKey&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression_MapSelect_MapKey& default_instance() { - return *internal_default_instance(); - } - static inline const MaskExpression_MapSelect_MapKey* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_MapSelect_MapKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 13; - - friend void swap(MaskExpression_MapSelect_MapKey& a, MaskExpression_MapSelect_MapKey& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression_MapSelect_MapKey* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression_MapSelect_MapKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression_MapSelect_MapKey* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression_MapSelect_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression_MapSelect_MapKey& from); - void MergeFrom(const MaskExpression_MapSelect_MapKey& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression_MapSelect_MapKey* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression.MapSelect.MapKey"; - } - protected: - explicit MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMapKeyFieldNumber = 1, - }; - // string map_key = 1; - void clear_map_key(); - const std::string& map_key() const; - template - void set_map_key(ArgT0&& arg0, ArgT... args); - std::string* mutable_map_key(); - std::string* release_map_key(); - void set_allocated_map_key(std::string* map_key); - private: - const std::string& _internal_map_key() const; - void _internal_set_map_key(const std::string& value); - std::string* _internal_mutable_map_key(); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.MapSelect.MapKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.MapSelect.MapKeyExpression) */ { - public: - inline MaskExpression_MapSelect_MapKeyExpression() : MaskExpression_MapSelect_MapKeyExpression(nullptr) {} - ~MaskExpression_MapSelect_MapKeyExpression() override; - explicit constexpr MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression_MapSelect_MapKeyExpression(const MaskExpression_MapSelect_MapKeyExpression& from); - MaskExpression_MapSelect_MapKeyExpression(MaskExpression_MapSelect_MapKeyExpression&& from) noexcept - : MaskExpression_MapSelect_MapKeyExpression() { - *this = ::std::move(from); - } - - inline MaskExpression_MapSelect_MapKeyExpression& operator=(const MaskExpression_MapSelect_MapKeyExpression& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression_MapSelect_MapKeyExpression& operator=(MaskExpression_MapSelect_MapKeyExpression&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression_MapSelect_MapKeyExpression& default_instance() { - return *internal_default_instance(); - } - static inline const MaskExpression_MapSelect_MapKeyExpression* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_MapSelect_MapKeyExpression_default_instance_); - } - static constexpr int kIndexInFileMessages = - 14; - - friend void swap(MaskExpression_MapSelect_MapKeyExpression& a, MaskExpression_MapSelect_MapKeyExpression& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression_MapSelect_MapKeyExpression* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression_MapSelect_MapKeyExpression* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression_MapSelect_MapKeyExpression* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression_MapSelect_MapKeyExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression_MapSelect_MapKeyExpression& from); - void MergeFrom(const MaskExpression_MapSelect_MapKeyExpression& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression_MapSelect_MapKeyExpression* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression.MapSelect.MapKeyExpression"; - } - protected: - explicit MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kMapKeyExpressionFieldNumber = 1, - }; - // string map_key_expression = 1; - void clear_map_key_expression(); - const std::string& map_key_expression() const; - template - void set_map_key_expression(ArgT0&& arg0, ArgT... args); - std::string* mutable_map_key_expression(); - std::string* release_map_key_expression(); - void set_allocated_map_key_expression(std::string* map_key_expression); - private: - const std::string& _internal_map_key_expression() const; - void _internal_set_map_key_expression(const std::string& value); - std::string* _internal_mutable_map_key_expression(); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.MapSelect.MapKeyExpression) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_expression_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression_MapSelect PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression.MapSelect) */ { - public: - inline MaskExpression_MapSelect() : MaskExpression_MapSelect(nullptr) {} - ~MaskExpression_MapSelect() override; - explicit constexpr MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression_MapSelect(const MaskExpression_MapSelect& from); - MaskExpression_MapSelect(MaskExpression_MapSelect&& from) noexcept - : MaskExpression_MapSelect() { - *this = ::std::move(from); - } - - inline MaskExpression_MapSelect& operator=(const MaskExpression_MapSelect& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression_MapSelect& operator=(MaskExpression_MapSelect&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression_MapSelect& default_instance() { - return *internal_default_instance(); - } - enum SelectCase { - kKey = 1, - kExpression = 2, - SELECT_NOT_SET = 0, - }; - - static inline const MaskExpression_MapSelect* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_MapSelect_default_instance_); - } - static constexpr int kIndexInFileMessages = - 15; - - friend void swap(MaskExpression_MapSelect& a, MaskExpression_MapSelect& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression_MapSelect* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression_MapSelect* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression_MapSelect* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression_MapSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression_MapSelect& from); - void MergeFrom(const MaskExpression_MapSelect& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression_MapSelect* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression.MapSelect"; - } - protected: - explicit MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef MaskExpression_MapSelect_MapKey MapKey; - typedef MaskExpression_MapSelect_MapKeyExpression MapKeyExpression; - - // accessors ------------------------------------------------------- - - enum : int { - kChildFieldNumber = 3, - kKeyFieldNumber = 1, - kExpressionFieldNumber = 2, - }; - // .io.substrait.MaskExpression.Select child = 3; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::io::substrait::MaskExpression_Select& child() const; - ::io::substrait::MaskExpression_Select* release_child(); - ::io::substrait::MaskExpression_Select* mutable_child(); - void set_allocated_child(::io::substrait::MaskExpression_Select* child); - private: - const ::io::substrait::MaskExpression_Select& _internal_child() const; - ::io::substrait::MaskExpression_Select* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::io::substrait::MaskExpression_Select* child); - ::io::substrait::MaskExpression_Select* unsafe_arena_release_child(); - - // .io.substrait.MaskExpression.MapSelect.MapKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::io::substrait::MaskExpression_MapSelect_MapKey& key() const; - ::io::substrait::MaskExpression_MapSelect_MapKey* release_key(); - ::io::substrait::MaskExpression_MapSelect_MapKey* mutable_key(); - void set_allocated_key(::io::substrait::MaskExpression_MapSelect_MapKey* key); - private: - const ::io::substrait::MaskExpression_MapSelect_MapKey& _internal_key() const; - ::io::substrait::MaskExpression_MapSelect_MapKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::io::substrait::MaskExpression_MapSelect_MapKey* key); - ::io::substrait::MaskExpression_MapSelect_MapKey* unsafe_arena_release_key(); - - // .io.substrait.MaskExpression.MapSelect.MapKeyExpression expression = 2; - bool has_expression() const; - private: - bool _internal_has_expression() const; - public: - void clear_expression(); - const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& expression() const; - ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* release_expression(); - ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* mutable_expression(); - void set_allocated_expression(::io::substrait::MaskExpression_MapSelect_MapKeyExpression* expression); - private: - const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& _internal_expression() const; - ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* _internal_mutable_expression(); - public: - void unsafe_arena_set_allocated_expression( - ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* expression); - ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* unsafe_arena_release_expression(); - - void clear_select(); - SelectCase select_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression.MapSelect) - private: - class _Internal; - void set_has_key(); - void set_has_expression(); - - inline bool has_select() const; - inline void clear_has_select(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::io::substrait::MaskExpression_Select* child_; - union SelectUnion { - constexpr SelectUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::MaskExpression_MapSelect_MapKey* key_; - ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* expression_; - } select_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class MaskExpression PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.MaskExpression) */ { - public: - inline MaskExpression() : MaskExpression(nullptr) {} - ~MaskExpression() override; - explicit constexpr MaskExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - MaskExpression(const MaskExpression& from); - MaskExpression(MaskExpression&& from) noexcept - : MaskExpression() { - *this = ::std::move(from); - } - - inline MaskExpression& operator=(const MaskExpression& from) { - CopyFrom(from); - return *this; - } - inline MaskExpression& operator=(MaskExpression&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 MaskExpression& default_instance() { - return *internal_default_instance(); - } - static inline const MaskExpression* internal_default_instance() { - return reinterpret_cast( - &_MaskExpression_default_instance_); - } - static constexpr int kIndexInFileMessages = - 16; - - friend void swap(MaskExpression& a, MaskExpression& b) { - a.Swap(&b); - } - inline void Swap(MaskExpression* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MaskExpression* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline MaskExpression* New() const final { - return CreateMaybeMessage(nullptr); - } - - MaskExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const MaskExpression& from); - void MergeFrom(const MaskExpression& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(MaskExpression* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.MaskExpression"; - } - protected: - explicit MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef MaskExpression_Select Select; - typedef MaskExpression_StructSelect StructSelect; - typedef MaskExpression_StructItem StructItem; - typedef MaskExpression_ListSelect ListSelect; - typedef MaskExpression_MapSelect MapSelect; - - // accessors ------------------------------------------------------- - - enum : int { - kSelectFieldNumber = 1, - kMaintainSingularStructFieldNumber = 2, - }; - // .io.substrait.MaskExpression.StructSelect select = 1; - bool has_select() const; - private: - bool _internal_has_select() const; - public: - void clear_select(); - const ::io::substrait::MaskExpression_StructSelect& select() const; - ::io::substrait::MaskExpression_StructSelect* release_select(); - ::io::substrait::MaskExpression_StructSelect* mutable_select(); - void set_allocated_select(::io::substrait::MaskExpression_StructSelect* select); - private: - const ::io::substrait::MaskExpression_StructSelect& _internal_select() const; - ::io::substrait::MaskExpression_StructSelect* _internal_mutable_select(); - public: - void unsafe_arena_set_allocated_select( - ::io::substrait::MaskExpression_StructSelect* select); - ::io::substrait::MaskExpression_StructSelect* unsafe_arena_release_select(); - - // bool maintain_singular_struct = 2; - void clear_maintain_singular_struct(); - bool maintain_singular_struct() const; - void set_maintain_singular_struct(bool value); - private: - bool _internal_maintain_singular_struct() const; - void _internal_set_maintain_singular_struct(bool value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.MaskExpression) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::io::substrait::MaskExpression_StructSelect* select_; - bool maintain_singular_struct_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_selection_2eproto; -}; -// ------------------------------------------------------------------- - -class FieldReference PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FieldReference) */ { - public: - inline FieldReference() : FieldReference(nullptr) {} - ~FieldReference() override; - explicit constexpr FieldReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FieldReference(const FieldReference& from); - FieldReference(FieldReference&& from) noexcept - : FieldReference() { - *this = ::std::move(from); - } - - inline FieldReference& operator=(const FieldReference& from) { - CopyFrom(from); - return *this; - } - inline FieldReference& operator=(FieldReference&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 FieldReference& default_instance() { - return *internal_default_instance(); - } - enum ReferenceTypeCase { - kDirectReference = 1, - kMaskedReference = 2, - REFERENCE_TYPE_NOT_SET = 0, - }; - - static inline const FieldReference* internal_default_instance() { - return reinterpret_cast( - &_FieldReference_default_instance_); - } - static constexpr int kIndexInFileMessages = - 17; - - friend void swap(FieldReference& a, FieldReference& b) { - a.Swap(&b); - } - inline void Swap(FieldReference* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(FieldReference* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline FieldReference* New() const final { - return CreateMaybeMessage(nullptr); - } - - FieldReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const FieldReference& from); - void MergeFrom(const FieldReference& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FieldReference* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FieldReference"; - } - protected: - explicit FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kDirectReferenceFieldNumber = 1, - kMaskedReferenceFieldNumber = 2, - }; - // .io.substrait.ReferenceSegment direct_reference = 1; - bool has_direct_reference() const; - private: - bool _internal_has_direct_reference() const; - public: - void clear_direct_reference(); - const ::io::substrait::ReferenceSegment& direct_reference() const; - ::io::substrait::ReferenceSegment* release_direct_reference(); - ::io::substrait::ReferenceSegment* mutable_direct_reference(); - void set_allocated_direct_reference(::io::substrait::ReferenceSegment* direct_reference); - private: - const ::io::substrait::ReferenceSegment& _internal_direct_reference() const; - ::io::substrait::ReferenceSegment* _internal_mutable_direct_reference(); - public: - void unsafe_arena_set_allocated_direct_reference( - ::io::substrait::ReferenceSegment* direct_reference); - ::io::substrait::ReferenceSegment* unsafe_arena_release_direct_reference(); - - // .io.substrait.MaskExpression masked_reference = 2; - bool has_masked_reference() const; - private: - bool _internal_has_masked_reference() const; - public: - void clear_masked_reference(); - const ::io::substrait::MaskExpression& masked_reference() const; - ::io::substrait::MaskExpression* release_masked_reference(); - ::io::substrait::MaskExpression* mutable_masked_reference(); - void set_allocated_masked_reference(::io::substrait::MaskExpression* masked_reference); - private: - const ::io::substrait::MaskExpression& _internal_masked_reference() const; - ::io::substrait::MaskExpression* _internal_mutable_masked_reference(); - public: - void unsafe_arena_set_allocated_masked_reference( - ::io::substrait::MaskExpression* masked_reference); - ::io::substrait::MaskExpression* unsafe_arena_release_masked_reference(); - - void clear_reference_type(); - ReferenceTypeCase reference_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.FieldReference) - private: - class _Internal; - void set_has_direct_reference(); - void set_has_masked_reference(); - - inline bool has_reference_type() const; - inline void clear_has_reference_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union ReferenceTypeUnion { - constexpr ReferenceTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::ReferenceSegment* direct_reference_; - ::io::substrait::MaskExpression* masked_reference_; - } reference_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - - friend struct ::TableStruct_selection_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// ReferenceSegment_MapKey - -// string map_key = 1; -inline void ReferenceSegment_MapKey::clear_map_key() { - map_key_.ClearToEmpty(); -} -inline const std::string& ReferenceSegment_MapKey::map_key() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.MapKey.map_key) - return _internal_map_key(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void ReferenceSegment_MapKey::set_map_key(ArgT0&& arg0, ArgT... args) { - - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.MapKey.map_key) -} -inline std::string* ReferenceSegment_MapKey::mutable_map_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.MapKey.map_key) - return _internal_mutable_map_key(); -} -inline const std::string& ReferenceSegment_MapKey::_internal_map_key() const { - return map_key_.Get(); -} -inline void ReferenceSegment_MapKey::_internal_set_map_key(const std::string& value) { - - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* ReferenceSegment_MapKey::_internal_mutable_map_key() { - - return map_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* ReferenceSegment_MapKey::release_map_key() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.MapKey.map_key) - return map_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void ReferenceSegment_MapKey::set_allocated_map_key(std::string* map_key) { - if (map_key != nullptr) { - - } else { - - } - map_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.MapKey.map_key) -} - -// .io.substrait.ReferenceSegment child = 2; -inline bool ReferenceSegment_MapKey::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool ReferenceSegment_MapKey::has_child() const { - return _internal_has_child(); -} -inline void ReferenceSegment_MapKey::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::io::substrait::ReferenceSegment& ReferenceSegment_MapKey::_internal_child() const { - const ::io::substrait::ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ReferenceSegment_default_instance_); -} -inline const ::io::substrait::ReferenceSegment& ReferenceSegment_MapKey::child() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.MapKey.child) - return _internal_child(); -} -inline void ReferenceSegment_MapKey::unsafe_arena_set_allocated_child( - ::io::substrait::ReferenceSegment* child) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.MapKey.child) -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKey::release_child() { - - ::io::substrait::ReferenceSegment* temp = child_; - child_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKey::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.MapKey.child) - - ::io::substrait::ReferenceSegment* temp = child_; - child_ = nullptr; - return temp; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKey::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ReferenceSegment>(GetArena()); - child_ = p; - } - return child_; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKey::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.MapKey.child) - return _internal_mutable_child(); -} -inline void ReferenceSegment_MapKey::set_allocated_child(::io::substrait::ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.MapKey.child) -} - -// ------------------------------------------------------------------- - -// ReferenceSegment_MapKeyExpression - -// string map_key_expression = 1; -inline void ReferenceSegment_MapKeyExpression::clear_map_key_expression() { - map_key_expression_.ClearToEmpty(); -} -inline const std::string& ReferenceSegment_MapKeyExpression::map_key_expression() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression) - return _internal_map_key_expression(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void ReferenceSegment_MapKeyExpression::set_map_key_expression(ArgT0&& arg0, ArgT... args) { - - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression) -} -inline std::string* ReferenceSegment_MapKeyExpression::mutable_map_key_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression) - return _internal_mutable_map_key_expression(); -} -inline const std::string& ReferenceSegment_MapKeyExpression::_internal_map_key_expression() const { - return map_key_expression_.Get(); -} -inline void ReferenceSegment_MapKeyExpression::_internal_set_map_key_expression(const std::string& value) { - - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* ReferenceSegment_MapKeyExpression::_internal_mutable_map_key_expression() { - - return map_key_expression_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* ReferenceSegment_MapKeyExpression::release_map_key_expression() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression) - return map_key_expression_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void ReferenceSegment_MapKeyExpression::set_allocated_map_key_expression(std::string* map_key_expression) { - if (map_key_expression != nullptr) { - - } else { - - } - map_key_expression_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key_expression, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.MapKeyExpression.map_key_expression) -} - -// .io.substrait.ReferenceSegment child = 2; -inline bool ReferenceSegment_MapKeyExpression::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool ReferenceSegment_MapKeyExpression::has_child() const { - return _internal_has_child(); -} -inline void ReferenceSegment_MapKeyExpression::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::io::substrait::ReferenceSegment& ReferenceSegment_MapKeyExpression::_internal_child() const { - const ::io::substrait::ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ReferenceSegment_default_instance_); -} -inline const ::io::substrait::ReferenceSegment& ReferenceSegment_MapKeyExpression::child() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.MapKeyExpression.child) - return _internal_child(); -} -inline void ReferenceSegment_MapKeyExpression::unsafe_arena_set_allocated_child( - ::io::substrait::ReferenceSegment* child) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.MapKeyExpression.child) -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKeyExpression::release_child() { - - ::io::substrait::ReferenceSegment* temp = child_; - child_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKeyExpression::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.MapKeyExpression.child) - - ::io::substrait::ReferenceSegment* temp = child_; - child_ = nullptr; - return temp; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKeyExpression::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ReferenceSegment>(GetArena()); - child_ = p; - } - return child_; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_MapKeyExpression::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.MapKeyExpression.child) - return _internal_mutable_child(); -} -inline void ReferenceSegment_MapKeyExpression::set_allocated_child(::io::substrait::ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.MapKeyExpression.child) -} - -// ------------------------------------------------------------------- - -// ReferenceSegment_StructField - -// int32 field = 1; -inline void ReferenceSegment_StructField::clear_field() { - field_ = 0; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_StructField::_internal_field() const { - return field_; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_StructField::field() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.StructField.field) - return _internal_field(); -} -inline void ReferenceSegment_StructField::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { - - field_ = value; -} -inline void ReferenceSegment_StructField::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_field(value); - // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.StructField.field) -} - -// .io.substrait.ReferenceSegment child = 2; -inline bool ReferenceSegment_StructField::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool ReferenceSegment_StructField::has_child() const { - return _internal_has_child(); -} -inline void ReferenceSegment_StructField::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::io::substrait::ReferenceSegment& ReferenceSegment_StructField::_internal_child() const { - const ::io::substrait::ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ReferenceSegment_default_instance_); -} -inline const ::io::substrait::ReferenceSegment& ReferenceSegment_StructField::child() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.StructField.child) - return _internal_child(); -} -inline void ReferenceSegment_StructField::unsafe_arena_set_allocated_child( - ::io::substrait::ReferenceSegment* child) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.StructField.child) -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_StructField::release_child() { - - ::io::substrait::ReferenceSegment* temp = child_; - child_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_StructField::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.StructField.child) - - ::io::substrait::ReferenceSegment* temp = child_; - child_ = nullptr; - return temp; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_StructField::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ReferenceSegment>(GetArena()); - child_ = p; - } - return child_; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_StructField::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.StructField.child) - return _internal_mutable_child(); -} -inline void ReferenceSegment_StructField::set_allocated_child(::io::substrait::ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.StructField.child) -} - -// ------------------------------------------------------------------- - -// ReferenceSegment_ListElement - -// int32 offset = 1; -inline void ReferenceSegment_ListElement::clear_offset() { - offset_ = 0; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListElement::_internal_offset() const { - return offset_; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListElement::offset() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.ListElement.offset) - return _internal_offset(); -} -inline void ReferenceSegment_ListElement::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) { - - offset_ = value; -} -inline void ReferenceSegment_ListElement::set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_offset(value); - // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.ListElement.offset) -} - -// .io.substrait.ReferenceSegment child = 2; -inline bool ReferenceSegment_ListElement::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool ReferenceSegment_ListElement::has_child() const { - return _internal_has_child(); -} -inline void ReferenceSegment_ListElement::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::io::substrait::ReferenceSegment& ReferenceSegment_ListElement::_internal_child() const { - const ::io::substrait::ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ReferenceSegment_default_instance_); -} -inline const ::io::substrait::ReferenceSegment& ReferenceSegment_ListElement::child() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.ListElement.child) - return _internal_child(); -} -inline void ReferenceSegment_ListElement::unsafe_arena_set_allocated_child( - ::io::substrait::ReferenceSegment* child) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.ListElement.child) -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListElement::release_child() { - - ::io::substrait::ReferenceSegment* temp = child_; - child_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListElement::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.ListElement.child) - - ::io::substrait::ReferenceSegment* temp = child_; - child_ = nullptr; - return temp; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListElement::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ReferenceSegment>(GetArena()); - child_ = p; - } - return child_; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListElement::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.ListElement.child) - return _internal_mutable_child(); -} -inline void ReferenceSegment_ListElement::set_allocated_child(::io::substrait::ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.ListElement.child) -} - -// ------------------------------------------------------------------- - -// ReferenceSegment_ListRange - -// int32 start = 1; -inline void ReferenceSegment_ListRange::clear_start() { - start_ = 0; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListRange::_internal_start() const { - return start_; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListRange::start() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.ListRange.start) - return _internal_start(); -} -inline void ReferenceSegment_ListRange::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { - - start_ = value; -} -inline void ReferenceSegment_ListRange::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_start(value); - // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.ListRange.start) -} - -// int32 end = 2; -inline void ReferenceSegment_ListRange::clear_end() { - end_ = 0; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListRange::_internal_end() const { - return end_; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 ReferenceSegment_ListRange::end() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.ListRange.end) - return _internal_end(); -} -inline void ReferenceSegment_ListRange::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { - - end_ = value; -} -inline void ReferenceSegment_ListRange::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_end(value); - // @@protoc_insertion_point(field_set:io.substrait.ReferenceSegment.ListRange.end) -} - -// .io.substrait.ReferenceSegment child = 3; -inline bool ReferenceSegment_ListRange::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool ReferenceSegment_ListRange::has_child() const { - return _internal_has_child(); -} -inline void ReferenceSegment_ListRange::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::io::substrait::ReferenceSegment& ReferenceSegment_ListRange::_internal_child() const { - const ::io::substrait::ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ReferenceSegment_default_instance_); -} -inline const ::io::substrait::ReferenceSegment& ReferenceSegment_ListRange::child() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.ListRange.child) - return _internal_child(); -} -inline void ReferenceSegment_ListRange::unsafe_arena_set_allocated_child( - ::io::substrait::ReferenceSegment* child) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.ListRange.child) -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListRange::release_child() { - - ::io::substrait::ReferenceSegment* temp = child_; - child_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListRange::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.ListRange.child) - - ::io::substrait::ReferenceSegment* temp = child_; - child_ = nullptr; - return temp; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListRange::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ReferenceSegment>(GetArena()); - child_ = p; - } - return child_; -} -inline ::io::substrait::ReferenceSegment* ReferenceSegment_ListRange::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.ListRange.child) - return _internal_mutable_child(); -} -inline void ReferenceSegment_ListRange::set_allocated_child(::io::substrait::ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReferenceSegment.ListRange.child) -} - -// ------------------------------------------------------------------- - -// ReferenceSegment - -// .io.substrait.ReferenceSegment.MapKey map_key = 1; -inline bool ReferenceSegment::_internal_has_map_key() const { - return reference_type_case() == kMapKey; -} -inline bool ReferenceSegment::has_map_key() const { - return _internal_has_map_key(); -} -inline void ReferenceSegment::set_has_map_key() { - _oneof_case_[0] = kMapKey; -} -inline void ReferenceSegment::clear_map_key() { - if (_internal_has_map_key()) { - if (GetArena() == nullptr) { - delete reference_type_.map_key_; - } - clear_has_reference_type(); - } -} -inline ::io::substrait::ReferenceSegment_MapKey* ReferenceSegment::release_map_key() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.map_key) - if (_internal_has_map_key()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment_MapKey* temp = reference_type_.map_key_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.map_key_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::ReferenceSegment_MapKey& ReferenceSegment::_internal_map_key() const { - return _internal_has_map_key() - ? *reference_type_.map_key_ - : reinterpret_cast< ::io::substrait::ReferenceSegment_MapKey&>(::io::substrait::_ReferenceSegment_MapKey_default_instance_); -} -inline const ::io::substrait::ReferenceSegment_MapKey& ReferenceSegment::map_key() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.map_key) - return _internal_map_key(); -} -inline ::io::substrait::ReferenceSegment_MapKey* ReferenceSegment::unsafe_arena_release_map_key() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReferenceSegment.map_key) - if (_internal_has_map_key()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment_MapKey* temp = reference_type_.map_key_; - reference_type_.map_key_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ReferenceSegment::unsafe_arena_set_allocated_map_key(::io::substrait::ReferenceSegment_MapKey* map_key) { - clear_reference_type(); - if (map_key) { - set_has_map_key(); - reference_type_.map_key_ = map_key; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.map_key) -} -inline ::io::substrait::ReferenceSegment_MapKey* ReferenceSegment::_internal_mutable_map_key() { - if (!_internal_has_map_key()) { - clear_reference_type(); - set_has_map_key(); - reference_type_.map_key_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment_MapKey >(GetArena()); - } - return reference_type_.map_key_; -} -inline ::io::substrait::ReferenceSegment_MapKey* ReferenceSegment::mutable_map_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.map_key) - return _internal_mutable_map_key(); -} - -// .io.substrait.ReferenceSegment.MapKeyExpression expression = 2; -inline bool ReferenceSegment::_internal_has_expression() const { - return reference_type_case() == kExpression; -} -inline bool ReferenceSegment::has_expression() const { - return _internal_has_expression(); -} -inline void ReferenceSegment::set_has_expression() { - _oneof_case_[0] = kExpression; -} -inline void ReferenceSegment::clear_expression() { - if (_internal_has_expression()) { - if (GetArena() == nullptr) { - delete reference_type_.expression_; - } - clear_has_reference_type(); - } -} -inline ::io::substrait::ReferenceSegment_MapKeyExpression* ReferenceSegment::release_expression() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.expression) - if (_internal_has_expression()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment_MapKeyExpression* temp = reference_type_.expression_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.expression_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::ReferenceSegment_MapKeyExpression& ReferenceSegment::_internal_expression() const { - return _internal_has_expression() - ? *reference_type_.expression_ - : reinterpret_cast< ::io::substrait::ReferenceSegment_MapKeyExpression&>(::io::substrait::_ReferenceSegment_MapKeyExpression_default_instance_); -} -inline const ::io::substrait::ReferenceSegment_MapKeyExpression& ReferenceSegment::expression() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.expression) - return _internal_expression(); -} -inline ::io::substrait::ReferenceSegment_MapKeyExpression* ReferenceSegment::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReferenceSegment.expression) - if (_internal_has_expression()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment_MapKeyExpression* temp = reference_type_.expression_; - reference_type_.expression_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ReferenceSegment::unsafe_arena_set_allocated_expression(::io::substrait::ReferenceSegment_MapKeyExpression* expression) { - clear_reference_type(); - if (expression) { - set_has_expression(); - reference_type_.expression_ = expression; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.expression) -} -inline ::io::substrait::ReferenceSegment_MapKeyExpression* ReferenceSegment::_internal_mutable_expression() { - if (!_internal_has_expression()) { - clear_reference_type(); - set_has_expression(); - reference_type_.expression_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment_MapKeyExpression >(GetArena()); - } - return reference_type_.expression_; -} -inline ::io::substrait::ReferenceSegment_MapKeyExpression* ReferenceSegment::mutable_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.expression) - return _internal_mutable_expression(); -} - -// .io.substrait.ReferenceSegment.StructField struct_field = 3; -inline bool ReferenceSegment::_internal_has_struct_field() const { - return reference_type_case() == kStructField; -} -inline bool ReferenceSegment::has_struct_field() const { - return _internal_has_struct_field(); -} -inline void ReferenceSegment::set_has_struct_field() { - _oneof_case_[0] = kStructField; -} -inline void ReferenceSegment::clear_struct_field() { - if (_internal_has_struct_field()) { - if (GetArena() == nullptr) { - delete reference_type_.struct_field_; - } - clear_has_reference_type(); - } -} -inline ::io::substrait::ReferenceSegment_StructField* ReferenceSegment::release_struct_field() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.struct_field) - if (_internal_has_struct_field()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment_StructField* temp = reference_type_.struct_field_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.struct_field_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::ReferenceSegment_StructField& ReferenceSegment::_internal_struct_field() const { - return _internal_has_struct_field() - ? *reference_type_.struct_field_ - : reinterpret_cast< ::io::substrait::ReferenceSegment_StructField&>(::io::substrait::_ReferenceSegment_StructField_default_instance_); -} -inline const ::io::substrait::ReferenceSegment_StructField& ReferenceSegment::struct_field() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.struct_field) - return _internal_struct_field(); -} -inline ::io::substrait::ReferenceSegment_StructField* ReferenceSegment::unsafe_arena_release_struct_field() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReferenceSegment.struct_field) - if (_internal_has_struct_field()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment_StructField* temp = reference_type_.struct_field_; - reference_type_.struct_field_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ReferenceSegment::unsafe_arena_set_allocated_struct_field(::io::substrait::ReferenceSegment_StructField* struct_field) { - clear_reference_type(); - if (struct_field) { - set_has_struct_field(); - reference_type_.struct_field_ = struct_field; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.struct_field) -} -inline ::io::substrait::ReferenceSegment_StructField* ReferenceSegment::_internal_mutable_struct_field() { - if (!_internal_has_struct_field()) { - clear_reference_type(); - set_has_struct_field(); - reference_type_.struct_field_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment_StructField >(GetArena()); - } - return reference_type_.struct_field_; -} -inline ::io::substrait::ReferenceSegment_StructField* ReferenceSegment::mutable_struct_field() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.struct_field) - return _internal_mutable_struct_field(); -} - -// .io.substrait.ReferenceSegment.ListElement list_element = 4; -inline bool ReferenceSegment::_internal_has_list_element() const { - return reference_type_case() == kListElement; -} -inline bool ReferenceSegment::has_list_element() const { - return _internal_has_list_element(); -} -inline void ReferenceSegment::set_has_list_element() { - _oneof_case_[0] = kListElement; -} -inline void ReferenceSegment::clear_list_element() { - if (_internal_has_list_element()) { - if (GetArena() == nullptr) { - delete reference_type_.list_element_; - } - clear_has_reference_type(); - } -} -inline ::io::substrait::ReferenceSegment_ListElement* ReferenceSegment::release_list_element() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.list_element) - if (_internal_has_list_element()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment_ListElement* temp = reference_type_.list_element_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.list_element_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::ReferenceSegment_ListElement& ReferenceSegment::_internal_list_element() const { - return _internal_has_list_element() - ? *reference_type_.list_element_ - : reinterpret_cast< ::io::substrait::ReferenceSegment_ListElement&>(::io::substrait::_ReferenceSegment_ListElement_default_instance_); -} -inline const ::io::substrait::ReferenceSegment_ListElement& ReferenceSegment::list_element() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.list_element) - return _internal_list_element(); -} -inline ::io::substrait::ReferenceSegment_ListElement* ReferenceSegment::unsafe_arena_release_list_element() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReferenceSegment.list_element) - if (_internal_has_list_element()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment_ListElement* temp = reference_type_.list_element_; - reference_type_.list_element_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ReferenceSegment::unsafe_arena_set_allocated_list_element(::io::substrait::ReferenceSegment_ListElement* list_element) { - clear_reference_type(); - if (list_element) { - set_has_list_element(); - reference_type_.list_element_ = list_element; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.list_element) -} -inline ::io::substrait::ReferenceSegment_ListElement* ReferenceSegment::_internal_mutable_list_element() { - if (!_internal_has_list_element()) { - clear_reference_type(); - set_has_list_element(); - reference_type_.list_element_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment_ListElement >(GetArena()); - } - return reference_type_.list_element_; -} -inline ::io::substrait::ReferenceSegment_ListElement* ReferenceSegment::mutable_list_element() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.list_element) - return _internal_mutable_list_element(); -} - -// .io.substrait.ReferenceSegment.ListRange list_range = 5; -inline bool ReferenceSegment::_internal_has_list_range() const { - return reference_type_case() == kListRange; -} -inline bool ReferenceSegment::has_list_range() const { - return _internal_has_list_range(); -} -inline void ReferenceSegment::set_has_list_range() { - _oneof_case_[0] = kListRange; -} -inline void ReferenceSegment::clear_list_range() { - if (_internal_has_list_range()) { - if (GetArena() == nullptr) { - delete reference_type_.list_range_; - } - clear_has_reference_type(); - } -} -inline ::io::substrait::ReferenceSegment_ListRange* ReferenceSegment::release_list_range() { - // @@protoc_insertion_point(field_release:io.substrait.ReferenceSegment.list_range) - if (_internal_has_list_range()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment_ListRange* temp = reference_type_.list_range_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.list_range_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::ReferenceSegment_ListRange& ReferenceSegment::_internal_list_range() const { - return _internal_has_list_range() - ? *reference_type_.list_range_ - : reinterpret_cast< ::io::substrait::ReferenceSegment_ListRange&>(::io::substrait::_ReferenceSegment_ListRange_default_instance_); -} -inline const ::io::substrait::ReferenceSegment_ListRange& ReferenceSegment::list_range() const { - // @@protoc_insertion_point(field_get:io.substrait.ReferenceSegment.list_range) - return _internal_list_range(); -} -inline ::io::substrait::ReferenceSegment_ListRange* ReferenceSegment::unsafe_arena_release_list_range() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReferenceSegment.list_range) - if (_internal_has_list_range()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment_ListRange* temp = reference_type_.list_range_; - reference_type_.list_range_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ReferenceSegment::unsafe_arena_set_allocated_list_range(::io::substrait::ReferenceSegment_ListRange* list_range) { - clear_reference_type(); - if (list_range) { - set_has_list_range(); - reference_type_.list_range_ = list_range; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReferenceSegment.list_range) -} -inline ::io::substrait::ReferenceSegment_ListRange* ReferenceSegment::_internal_mutable_list_range() { - if (!_internal_has_list_range()) { - clear_reference_type(); - set_has_list_range(); - reference_type_.list_range_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment_ListRange >(GetArena()); - } - return reference_type_.list_range_; -} -inline ::io::substrait::ReferenceSegment_ListRange* ReferenceSegment::mutable_list_range() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReferenceSegment.list_range) - return _internal_mutable_list_range(); -} - -inline bool ReferenceSegment::has_reference_type() const { - return reference_type_case() != REFERENCE_TYPE_NOT_SET; -} -inline void ReferenceSegment::clear_has_reference_type() { - _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; -} -inline ReferenceSegment::ReferenceTypeCase ReferenceSegment::reference_type_case() const { - return ReferenceSegment::ReferenceTypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// MaskExpression_Select - -// .io.substrait.MaskExpression.StructSelect struct = 1; -inline bool MaskExpression_Select::_internal_has_struct_() const { - return type_case() == kStruct; -} -inline bool MaskExpression_Select::has_struct_() const { - return _internal_has_struct_(); -} -inline void MaskExpression_Select::set_has_struct_() { - _oneof_case_[0] = kStruct; -} -inline void MaskExpression_Select::clear_struct_() { - if (_internal_has_struct_()) { - if (GetArena() == nullptr) { - delete type_.struct__; - } - clear_has_type(); - } -} -inline ::io::substrait::MaskExpression_StructSelect* MaskExpression_Select::release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.Select.struct) - if (_internal_has_struct_()) { - clear_has_type(); - ::io::substrait::MaskExpression_StructSelect* temp = type_.struct__; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - type_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::MaskExpression_StructSelect& MaskExpression_Select::_internal_struct_() const { - return _internal_has_struct_() - ? *type_.struct__ - : reinterpret_cast< ::io::substrait::MaskExpression_StructSelect&>(::io::substrait::_MaskExpression_StructSelect_default_instance_); -} -inline const ::io::substrait::MaskExpression_StructSelect& MaskExpression_Select::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.Select.struct) - return _internal_struct_(); -} -inline ::io::substrait::MaskExpression_StructSelect* MaskExpression_Select::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.Select.struct) - if (_internal_has_struct_()) { - clear_has_type(); - ::io::substrait::MaskExpression_StructSelect* temp = type_.struct__; - type_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void MaskExpression_Select::unsafe_arena_set_allocated_struct_(::io::substrait::MaskExpression_StructSelect* struct_) { - clear_type(); - if (struct_) { - set_has_struct_(); - type_.struct__ = struct_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.Select.struct) -} -inline ::io::substrait::MaskExpression_StructSelect* MaskExpression_Select::_internal_mutable_struct_() { - if (!_internal_has_struct_()) { - clear_type(); - set_has_struct_(); - type_.struct__ = CreateMaybeMessage< ::io::substrait::MaskExpression_StructSelect >(GetArena()); - } - return type_.struct__; -} -inline ::io::substrait::MaskExpression_StructSelect* MaskExpression_Select::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.Select.struct) - return _internal_mutable_struct_(); -} - -// .io.substrait.MaskExpression.ListSelect list = 2; -inline bool MaskExpression_Select::_internal_has_list() const { - return type_case() == kList; -} -inline bool MaskExpression_Select::has_list() const { - return _internal_has_list(); -} -inline void MaskExpression_Select::set_has_list() { - _oneof_case_[0] = kList; -} -inline void MaskExpression_Select::clear_list() { - if (_internal_has_list()) { - if (GetArena() == nullptr) { - delete type_.list_; - } - clear_has_type(); - } -} -inline ::io::substrait::MaskExpression_ListSelect* MaskExpression_Select::release_list() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.Select.list) - if (_internal_has_list()) { - clear_has_type(); - ::io::substrait::MaskExpression_ListSelect* temp = type_.list_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - type_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::MaskExpression_ListSelect& MaskExpression_Select::_internal_list() const { - return _internal_has_list() - ? *type_.list_ - : reinterpret_cast< ::io::substrait::MaskExpression_ListSelect&>(::io::substrait::_MaskExpression_ListSelect_default_instance_); -} -inline const ::io::substrait::MaskExpression_ListSelect& MaskExpression_Select::list() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.Select.list) - return _internal_list(); -} -inline ::io::substrait::MaskExpression_ListSelect* MaskExpression_Select::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.Select.list) - if (_internal_has_list()) { - clear_has_type(); - ::io::substrait::MaskExpression_ListSelect* temp = type_.list_; - type_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void MaskExpression_Select::unsafe_arena_set_allocated_list(::io::substrait::MaskExpression_ListSelect* list) { - clear_type(); - if (list) { - set_has_list(); - type_.list_ = list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.Select.list) -} -inline ::io::substrait::MaskExpression_ListSelect* MaskExpression_Select::_internal_mutable_list() { - if (!_internal_has_list()) { - clear_type(); - set_has_list(); - type_.list_ = CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect >(GetArena()); - } - return type_.list_; -} -inline ::io::substrait::MaskExpression_ListSelect* MaskExpression_Select::mutable_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.Select.list) - return _internal_mutable_list(); -} - -// .io.substrait.MaskExpression.MapSelect map = 3; -inline bool MaskExpression_Select::_internal_has_map() const { - return type_case() == kMap; -} -inline bool MaskExpression_Select::has_map() const { - return _internal_has_map(); -} -inline void MaskExpression_Select::set_has_map() { - _oneof_case_[0] = kMap; -} -inline void MaskExpression_Select::clear_map() { - if (_internal_has_map()) { - if (GetArena() == nullptr) { - delete type_.map_; - } - clear_has_type(); - } -} -inline ::io::substrait::MaskExpression_MapSelect* MaskExpression_Select::release_map() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.Select.map) - if (_internal_has_map()) { - clear_has_type(); - ::io::substrait::MaskExpression_MapSelect* temp = type_.map_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - type_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::MaskExpression_MapSelect& MaskExpression_Select::_internal_map() const { - return _internal_has_map() - ? *type_.map_ - : reinterpret_cast< ::io::substrait::MaskExpression_MapSelect&>(::io::substrait::_MaskExpression_MapSelect_default_instance_); -} -inline const ::io::substrait::MaskExpression_MapSelect& MaskExpression_Select::map() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.Select.map) - return _internal_map(); -} -inline ::io::substrait::MaskExpression_MapSelect* MaskExpression_Select::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.Select.map) - if (_internal_has_map()) { - clear_has_type(); - ::io::substrait::MaskExpression_MapSelect* temp = type_.map_; - type_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void MaskExpression_Select::unsafe_arena_set_allocated_map(::io::substrait::MaskExpression_MapSelect* map) { - clear_type(); - if (map) { - set_has_map(); - type_.map_ = map; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.Select.map) -} -inline ::io::substrait::MaskExpression_MapSelect* MaskExpression_Select::_internal_mutable_map() { - if (!_internal_has_map()) { - clear_type(); - set_has_map(); - type_.map_ = CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect >(GetArena()); - } - return type_.map_; -} -inline ::io::substrait::MaskExpression_MapSelect* MaskExpression_Select::mutable_map() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.Select.map) - return _internal_mutable_map(); -} - -inline bool MaskExpression_Select::has_type() const { - return type_case() != TYPE_NOT_SET; -} -inline void MaskExpression_Select::clear_has_type() { - _oneof_case_[0] = TYPE_NOT_SET; -} -inline MaskExpression_Select::TypeCase MaskExpression_Select::type_case() const { - return MaskExpression_Select::TypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// MaskExpression_StructSelect - -// repeated .io.substrait.MaskExpression.StructItem struct_items = 1; -inline int MaskExpression_StructSelect::_internal_struct_items_size() const { - return struct_items_.size(); -} -inline int MaskExpression_StructSelect::struct_items_size() const { - return _internal_struct_items_size(); -} -inline void MaskExpression_StructSelect::clear_struct_items() { - struct_items_.Clear(); -} -inline ::io::substrait::MaskExpression_StructItem* MaskExpression_StructSelect::mutable_struct_items(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.StructSelect.struct_items) - return struct_items_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_StructItem >* -MaskExpression_StructSelect::mutable_struct_items() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.MaskExpression.StructSelect.struct_items) - return &struct_items_; -} -inline const ::io::substrait::MaskExpression_StructItem& MaskExpression_StructSelect::_internal_struct_items(int index) const { - return struct_items_.Get(index); -} -inline const ::io::substrait::MaskExpression_StructItem& MaskExpression_StructSelect::struct_items(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.StructSelect.struct_items) - return _internal_struct_items(index); -} -inline ::io::substrait::MaskExpression_StructItem* MaskExpression_StructSelect::_internal_add_struct_items() { - return struct_items_.Add(); -} -inline ::io::substrait::MaskExpression_StructItem* MaskExpression_StructSelect::add_struct_items() { - // @@protoc_insertion_point(field_add:io.substrait.MaskExpression.StructSelect.struct_items) - return _internal_add_struct_items(); -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_StructItem >& -MaskExpression_StructSelect::struct_items() const { - // @@protoc_insertion_point(field_list:io.substrait.MaskExpression.StructSelect.struct_items) - return struct_items_; -} - -// ------------------------------------------------------------------- - -// MaskExpression_StructItem - -// int32 field = 1; -inline void MaskExpression_StructItem::clear_field() { - field_ = 0; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_StructItem::_internal_field() const { - return field_; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_StructItem::field() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.StructItem.field) - return _internal_field(); -} -inline void MaskExpression_StructItem::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { - - field_ = value; -} -inline void MaskExpression_StructItem::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_field(value); - // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.StructItem.field) -} - -// .io.substrait.MaskExpression.Select child = 2; -inline bool MaskExpression_StructItem::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool MaskExpression_StructItem::has_child() const { - return _internal_has_child(); -} -inline void MaskExpression_StructItem::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::io::substrait::MaskExpression_Select& MaskExpression_StructItem::_internal_child() const { - const ::io::substrait::MaskExpression_Select* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_MaskExpression_Select_default_instance_); -} -inline const ::io::substrait::MaskExpression_Select& MaskExpression_StructItem::child() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.StructItem.child) - return _internal_child(); -} -inline void MaskExpression_StructItem::unsafe_arena_set_allocated_child( - ::io::substrait::MaskExpression_Select* child) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.StructItem.child) -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_StructItem::release_child() { - - ::io::substrait::MaskExpression_Select* temp = child_; - child_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_StructItem::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.StructItem.child) - - ::io::substrait::MaskExpression_Select* temp = child_; - child_ = nullptr; - return temp; -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_StructItem::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::MaskExpression_Select>(GetArena()); - child_ = p; - } - return child_; -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_StructItem::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.StructItem.child) - return _internal_mutable_child(); -} -inline void MaskExpression_StructItem::set_allocated_child(::io::substrait::MaskExpression_Select* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.StructItem.child) -} - -// ------------------------------------------------------------------- - -// MaskExpression_ListSelect_ListSelectItem_ListElement - -// int32 field = 1; -inline void MaskExpression_ListSelect_ListSelectItem_ListElement::clear_field() { - field_ = 0; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_field() const { - return field_; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListElement::field() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement.field) - return _internal_field(); -} -inline void MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { - - field_ = value; -} -inline void MaskExpression_ListSelect_ListSelectItem_ListElement::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_field(value); - // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement.field) -} - -// ------------------------------------------------------------------- - -// MaskExpression_ListSelect_ListSelectItem_ListSlice - -// int32 start = 1; -inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_start() { - start_ = 0; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_start() const { - return start_; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListSlice::start() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) - return _internal_start(); -} -inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { - - start_ = value; -} -inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_start(value); - // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) -} - -// int32 end = 2; -inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_end() { - end_ = 0; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_end() const { - return end_; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 MaskExpression_ListSelect_ListSelectItem_ListSlice::end() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) - return _internal_end(); -} -inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { - - end_ = value; -} -inline void MaskExpression_ListSelect_ListSelectItem_ListSlice::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_end(value); - // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) -} - -// ------------------------------------------------------------------- - -// MaskExpression_ListSelect_ListSelectItem - -// .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; -inline bool MaskExpression_ListSelect_ListSelectItem::_internal_has_item() const { - return type_case() == kItem; -} -inline bool MaskExpression_ListSelect_ListSelectItem::has_item() const { - return _internal_has_item(); -} -inline void MaskExpression_ListSelect_ListSelectItem::set_has_item() { - _oneof_case_[0] = kItem; -} -inline void MaskExpression_ListSelect_ListSelectItem::clear_item() { - if (_internal_has_item()) { - if (GetArena() == nullptr) { - delete type_.item_; - } - clear_has_type(); - } -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* MaskExpression_ListSelect_ListSelectItem::release_item() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) - if (_internal_has_item()) { - clear_has_type(); - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - type_.item_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& MaskExpression_ListSelect_ListSelectItem::_internal_item() const { - return _internal_has_item() - ? *type_.item_ - : reinterpret_cast< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement&>(::io::substrait::_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_); -} -inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement& MaskExpression_ListSelect_ListSelectItem::item() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) - return _internal_item(); -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_item() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) - if (_internal_has_item()) { - clear_has_type(); - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; - type_.item_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_item(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* item) { - clear_type(); - if (item) { - set_has_item(); - type_.item_ = item; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* MaskExpression_ListSelect_ListSelectItem::_internal_mutable_item() { - if (!_internal_has_item()) { - clear_type(); - set_has_item(); - type_.item_ = CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement >(GetArena()); - } - return type_.item_; -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListElement* MaskExpression_ListSelect_ListSelectItem::mutable_item() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.ListSelect.ListSelectItem.item) - return _internal_mutable_item(); -} - -// .io.substrait.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; -inline bool MaskExpression_ListSelect_ListSelectItem::_internal_has_slice() const { - return type_case() == kSlice; -} -inline bool MaskExpression_ListSelect_ListSelectItem::has_slice() const { - return _internal_has_slice(); -} -inline void MaskExpression_ListSelect_ListSelectItem::set_has_slice() { - _oneof_case_[0] = kSlice; -} -inline void MaskExpression_ListSelect_ListSelectItem::clear_slice() { - if (_internal_has_slice()) { - if (GetArena() == nullptr) { - delete type_.slice_; - } - clear_has_type(); - } -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* MaskExpression_ListSelect_ListSelectItem::release_slice() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) - if (_internal_has_slice()) { - clear_has_type(); - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - type_.slice_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& MaskExpression_ListSelect_ListSelectItem::_internal_slice() const { - return _internal_has_slice() - ? *type_.slice_ - : reinterpret_cast< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice&>(::io::substrait::_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_); -} -inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice& MaskExpression_ListSelect_ListSelectItem::slice() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) - return _internal_slice(); -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_slice() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) - if (_internal_has_slice()) { - clear_has_type(); - ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; - type_.slice_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_slice(::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { - clear_type(); - if (slice) { - set_has_slice(); - type_.slice_ = slice; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* MaskExpression_ListSelect_ListSelectItem::_internal_mutable_slice() { - if (!_internal_has_slice()) { - clear_type(); - set_has_slice(); - type_.slice_ = CreateMaybeMessage< ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice >(GetArena()); - } - return type_.slice_; -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem_ListSlice* MaskExpression_ListSelect_ListSelectItem::mutable_slice() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.ListSelect.ListSelectItem.slice) - return _internal_mutable_slice(); -} - -inline bool MaskExpression_ListSelect_ListSelectItem::has_type() const { - return type_case() != TYPE_NOT_SET; -} -inline void MaskExpression_ListSelect_ListSelectItem::clear_has_type() { - _oneof_case_[0] = TYPE_NOT_SET; -} -inline MaskExpression_ListSelect_ListSelectItem::TypeCase MaskExpression_ListSelect_ListSelectItem::type_case() const { - return MaskExpression_ListSelect_ListSelectItem::TypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// MaskExpression_ListSelect - -// repeated .io.substrait.MaskExpression.ListSelect.ListSelectItem selection = 1; -inline int MaskExpression_ListSelect::_internal_selection_size() const { - return selection_.size(); -} -inline int MaskExpression_ListSelect::selection_size() const { - return _internal_selection_size(); -} -inline void MaskExpression_ListSelect::clear_selection() { - selection_.Clear(); -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem* MaskExpression_ListSelect::mutable_selection(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.ListSelect.selection) - return selection_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >* -MaskExpression_ListSelect::mutable_selection() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.MaskExpression.ListSelect.selection) - return &selection_; -} -inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem& MaskExpression_ListSelect::_internal_selection(int index) const { - return selection_.Get(index); -} -inline const ::io::substrait::MaskExpression_ListSelect_ListSelectItem& MaskExpression_ListSelect::selection(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.selection) - return _internal_selection(index); -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem* MaskExpression_ListSelect::_internal_add_selection() { - return selection_.Add(); -} -inline ::io::substrait::MaskExpression_ListSelect_ListSelectItem* MaskExpression_ListSelect::add_selection() { - // @@protoc_insertion_point(field_add:io.substrait.MaskExpression.ListSelect.selection) - return _internal_add_selection(); -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::MaskExpression_ListSelect_ListSelectItem >& -MaskExpression_ListSelect::selection() const { - // @@protoc_insertion_point(field_list:io.substrait.MaskExpression.ListSelect.selection) - return selection_; -} - -// .io.substrait.MaskExpression.Select child = 2; -inline bool MaskExpression_ListSelect::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool MaskExpression_ListSelect::has_child() const { - return _internal_has_child(); -} -inline void MaskExpression_ListSelect::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::io::substrait::MaskExpression_Select& MaskExpression_ListSelect::_internal_child() const { - const ::io::substrait::MaskExpression_Select* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_MaskExpression_Select_default_instance_); -} -inline const ::io::substrait::MaskExpression_Select& MaskExpression_ListSelect::child() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.ListSelect.child) - return _internal_child(); -} -inline void MaskExpression_ListSelect::unsafe_arena_set_allocated_child( - ::io::substrait::MaskExpression_Select* child) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.ListSelect.child) -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_ListSelect::release_child() { - - ::io::substrait::MaskExpression_Select* temp = child_; - child_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_ListSelect::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.ListSelect.child) - - ::io::substrait::MaskExpression_Select* temp = child_; - child_ = nullptr; - return temp; -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_ListSelect::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::MaskExpression_Select>(GetArena()); - child_ = p; - } - return child_; -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_ListSelect::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.ListSelect.child) - return _internal_mutable_child(); -} -inline void MaskExpression_ListSelect::set_allocated_child(::io::substrait::MaskExpression_Select* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.ListSelect.child) -} - -// ------------------------------------------------------------------- - -// MaskExpression_MapSelect_MapKey - -// string map_key = 1; -inline void MaskExpression_MapSelect_MapKey::clear_map_key() { - map_key_.ClearToEmpty(); -} -inline const std::string& MaskExpression_MapSelect_MapKey::map_key() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.MapSelect.MapKey.map_key) - return _internal_map_key(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void MaskExpression_MapSelect_MapKey::set_map_key(ArgT0&& arg0, ArgT... args) { - - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.MapSelect.MapKey.map_key) -} -inline std::string* MaskExpression_MapSelect_MapKey::mutable_map_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.MapSelect.MapKey.map_key) - return _internal_mutable_map_key(); -} -inline const std::string& MaskExpression_MapSelect_MapKey::_internal_map_key() const { - return map_key_.Get(); -} -inline void MaskExpression_MapSelect_MapKey::_internal_set_map_key(const std::string& value) { - - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* MaskExpression_MapSelect_MapKey::_internal_mutable_map_key() { - - return map_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* MaskExpression_MapSelect_MapKey::release_map_key() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.MapSelect.MapKey.map_key) - return map_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void MaskExpression_MapSelect_MapKey::set_allocated_map_key(std::string* map_key) { - if (map_key != nullptr) { - - } else { - - } - map_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.MapSelect.MapKey.map_key) -} - -// ------------------------------------------------------------------- - -// MaskExpression_MapSelect_MapKeyExpression - -// string map_key_expression = 1; -inline void MaskExpression_MapSelect_MapKeyExpression::clear_map_key_expression() { - map_key_expression_.ClearToEmpty(); -} -inline const std::string& MaskExpression_MapSelect_MapKeyExpression::map_key_expression() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) - return _internal_map_key_expression(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void MaskExpression_MapSelect_MapKeyExpression::set_map_key_expression(ArgT0&& arg0, ArgT... args) { - - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) -} -inline std::string* MaskExpression_MapSelect_MapKeyExpression::mutable_map_key_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) - return _internal_mutable_map_key_expression(); -} -inline const std::string& MaskExpression_MapSelect_MapKeyExpression::_internal_map_key_expression() const { - return map_key_expression_.Get(); -} -inline void MaskExpression_MapSelect_MapKeyExpression::_internal_set_map_key_expression(const std::string& value) { - - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* MaskExpression_MapSelect_MapKeyExpression::_internal_mutable_map_key_expression() { - - return map_key_expression_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* MaskExpression_MapSelect_MapKeyExpression::release_map_key_expression() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) - return map_key_expression_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void MaskExpression_MapSelect_MapKeyExpression::set_allocated_map_key_expression(std::string* map_key_expression) { - if (map_key_expression != nullptr) { - - } else { - - } - map_key_expression_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key_expression, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) -} - -// ------------------------------------------------------------------- - -// MaskExpression_MapSelect - -// .io.substrait.MaskExpression.MapSelect.MapKey key = 1; -inline bool MaskExpression_MapSelect::_internal_has_key() const { - return select_case() == kKey; -} -inline bool MaskExpression_MapSelect::has_key() const { - return _internal_has_key(); -} -inline void MaskExpression_MapSelect::set_has_key() { - _oneof_case_[0] = kKey; -} -inline void MaskExpression_MapSelect::clear_key() { - if (_internal_has_key()) { - if (GetArena() == nullptr) { - delete select_.key_; - } - clear_has_select(); - } -} -inline ::io::substrait::MaskExpression_MapSelect_MapKey* MaskExpression_MapSelect::release_key() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.MapSelect.key) - if (_internal_has_key()) { - clear_has_select(); - ::io::substrait::MaskExpression_MapSelect_MapKey* temp = select_.key_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - select_.key_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::MaskExpression_MapSelect_MapKey& MaskExpression_MapSelect::_internal_key() const { - return _internal_has_key() - ? *select_.key_ - : reinterpret_cast< ::io::substrait::MaskExpression_MapSelect_MapKey&>(::io::substrait::_MaskExpression_MapSelect_MapKey_default_instance_); -} -inline const ::io::substrait::MaskExpression_MapSelect_MapKey& MaskExpression_MapSelect::key() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.MapSelect.key) - return _internal_key(); -} -inline ::io::substrait::MaskExpression_MapSelect_MapKey* MaskExpression_MapSelect::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.MapSelect.key) - if (_internal_has_key()) { - clear_has_select(); - ::io::substrait::MaskExpression_MapSelect_MapKey* temp = select_.key_; - select_.key_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void MaskExpression_MapSelect::unsafe_arena_set_allocated_key(::io::substrait::MaskExpression_MapSelect_MapKey* key) { - clear_select(); - if (key) { - set_has_key(); - select_.key_ = key; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.MapSelect.key) -} -inline ::io::substrait::MaskExpression_MapSelect_MapKey* MaskExpression_MapSelect::_internal_mutable_key() { - if (!_internal_has_key()) { - clear_select(); - set_has_key(); - select_.key_ = CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect_MapKey >(GetArena()); - } - return select_.key_; -} -inline ::io::substrait::MaskExpression_MapSelect_MapKey* MaskExpression_MapSelect::mutable_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.MapSelect.key) - return _internal_mutable_key(); -} - -// .io.substrait.MaskExpression.MapSelect.MapKeyExpression expression = 2; -inline bool MaskExpression_MapSelect::_internal_has_expression() const { - return select_case() == kExpression; -} -inline bool MaskExpression_MapSelect::has_expression() const { - return _internal_has_expression(); -} -inline void MaskExpression_MapSelect::set_has_expression() { - _oneof_case_[0] = kExpression; -} -inline void MaskExpression_MapSelect::clear_expression() { - if (_internal_has_expression()) { - if (GetArena() == nullptr) { - delete select_.expression_; - } - clear_has_select(); - } -} -inline ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* MaskExpression_MapSelect::release_expression() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.MapSelect.expression) - if (_internal_has_expression()) { - clear_has_select(); - ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - select_.expression_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& MaskExpression_MapSelect::_internal_expression() const { - return _internal_has_expression() - ? *select_.expression_ - : reinterpret_cast< ::io::substrait::MaskExpression_MapSelect_MapKeyExpression&>(::io::substrait::_MaskExpression_MapSelect_MapKeyExpression_default_instance_); -} -inline const ::io::substrait::MaskExpression_MapSelect_MapKeyExpression& MaskExpression_MapSelect::expression() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.MapSelect.expression) - return _internal_expression(); -} -inline ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* MaskExpression_MapSelect::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.MaskExpression.MapSelect.expression) - if (_internal_has_expression()) { - clear_has_select(); - ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; - select_.expression_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void MaskExpression_MapSelect::unsafe_arena_set_allocated_expression(::io::substrait::MaskExpression_MapSelect_MapKeyExpression* expression) { - clear_select(); - if (expression) { - set_has_expression(); - select_.expression_ = expression; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.MapSelect.expression) -} -inline ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* MaskExpression_MapSelect::_internal_mutable_expression() { - if (!_internal_has_expression()) { - clear_select(); - set_has_expression(); - select_.expression_ = CreateMaybeMessage< ::io::substrait::MaskExpression_MapSelect_MapKeyExpression >(GetArena()); - } - return select_.expression_; -} -inline ::io::substrait::MaskExpression_MapSelect_MapKeyExpression* MaskExpression_MapSelect::mutable_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.MapSelect.expression) - return _internal_mutable_expression(); -} - -// .io.substrait.MaskExpression.Select child = 3; -inline bool MaskExpression_MapSelect::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool MaskExpression_MapSelect::has_child() const { - return _internal_has_child(); -} -inline void MaskExpression_MapSelect::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::io::substrait::MaskExpression_Select& MaskExpression_MapSelect::_internal_child() const { - const ::io::substrait::MaskExpression_Select* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_MaskExpression_Select_default_instance_); -} -inline const ::io::substrait::MaskExpression_Select& MaskExpression_MapSelect::child() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.MapSelect.child) - return _internal_child(); -} -inline void MaskExpression_MapSelect::unsafe_arena_set_allocated_child( - ::io::substrait::MaskExpression_Select* child) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.MapSelect.child) -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_MapSelect::release_child() { - - ::io::substrait::MaskExpression_Select* temp = child_; - child_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_MapSelect::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.MapSelect.child) - - ::io::substrait::MaskExpression_Select* temp = child_; - child_ = nullptr; - return temp; -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_MapSelect::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::MaskExpression_Select>(GetArena()); - child_ = p; - } - return child_; -} -inline ::io::substrait::MaskExpression_Select* MaskExpression_MapSelect::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.MapSelect.child) - return _internal_mutable_child(); -} -inline void MaskExpression_MapSelect::set_allocated_child(::io::substrait::MaskExpression_Select* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.MapSelect.child) -} - -inline bool MaskExpression_MapSelect::has_select() const { - return select_case() != SELECT_NOT_SET; -} -inline void MaskExpression_MapSelect::clear_has_select() { - _oneof_case_[0] = SELECT_NOT_SET; -} -inline MaskExpression_MapSelect::SelectCase MaskExpression_MapSelect::select_case() const { - return MaskExpression_MapSelect::SelectCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// MaskExpression - -// .io.substrait.MaskExpression.StructSelect select = 1; -inline bool MaskExpression::_internal_has_select() const { - return this != internal_default_instance() && select_ != nullptr; -} -inline bool MaskExpression::has_select() const { - return _internal_has_select(); -} -inline void MaskExpression::clear_select() { - if (GetArena() == nullptr && select_ != nullptr) { - delete select_; - } - select_ = nullptr; -} -inline const ::io::substrait::MaskExpression_StructSelect& MaskExpression::_internal_select() const { - const ::io::substrait::MaskExpression_StructSelect* p = select_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_MaskExpression_StructSelect_default_instance_); -} -inline const ::io::substrait::MaskExpression_StructSelect& MaskExpression::select() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.select) - return _internal_select(); -} -inline void MaskExpression::unsafe_arena_set_allocated_select( - ::io::substrait::MaskExpression_StructSelect* select) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(select_); - } - select_ = select; - if (select) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.MaskExpression.select) -} -inline ::io::substrait::MaskExpression_StructSelect* MaskExpression::release_select() { - - ::io::substrait::MaskExpression_StructSelect* temp = select_; - select_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::MaskExpression_StructSelect* MaskExpression::unsafe_arena_release_select() { - // @@protoc_insertion_point(field_release:io.substrait.MaskExpression.select) - - ::io::substrait::MaskExpression_StructSelect* temp = select_; - select_ = nullptr; - return temp; -} -inline ::io::substrait::MaskExpression_StructSelect* MaskExpression::_internal_mutable_select() { - - if (select_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::MaskExpression_StructSelect>(GetArena()); - select_ = p; - } - return select_; -} -inline ::io::substrait::MaskExpression_StructSelect* MaskExpression::mutable_select() { - // @@protoc_insertion_point(field_mutable:io.substrait.MaskExpression.select) - return _internal_mutable_select(); -} -inline void MaskExpression::set_allocated_select(::io::substrait::MaskExpression_StructSelect* select) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete select_; - } - if (select) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(select); - if (message_arena != submessage_arena) { - select = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, select, submessage_arena); - } - - } else { - - } - select_ = select; - // @@protoc_insertion_point(field_set_allocated:io.substrait.MaskExpression.select) -} - -// bool maintain_singular_struct = 2; -inline void MaskExpression::clear_maintain_singular_struct() { - maintain_singular_struct_ = false; -} -inline bool MaskExpression::_internal_maintain_singular_struct() const { - return maintain_singular_struct_; -} -inline bool MaskExpression::maintain_singular_struct() const { - // @@protoc_insertion_point(field_get:io.substrait.MaskExpression.maintain_singular_struct) - return _internal_maintain_singular_struct(); -} -inline void MaskExpression::_internal_set_maintain_singular_struct(bool value) { - - maintain_singular_struct_ = value; -} -inline void MaskExpression::set_maintain_singular_struct(bool value) { - _internal_set_maintain_singular_struct(value); - // @@protoc_insertion_point(field_set:io.substrait.MaskExpression.maintain_singular_struct) -} - -// ------------------------------------------------------------------- - -// FieldReference - -// .io.substrait.ReferenceSegment direct_reference = 1; -inline bool FieldReference::_internal_has_direct_reference() const { - return reference_type_case() == kDirectReference; -} -inline bool FieldReference::has_direct_reference() const { - return _internal_has_direct_reference(); -} -inline void FieldReference::set_has_direct_reference() { - _oneof_case_[0] = kDirectReference; -} -inline void FieldReference::clear_direct_reference() { - if (_internal_has_direct_reference()) { - if (GetArena() == nullptr) { - delete reference_type_.direct_reference_; - } - clear_has_reference_type(); - } -} -inline ::io::substrait::ReferenceSegment* FieldReference::release_direct_reference() { - // @@protoc_insertion_point(field_release:io.substrait.FieldReference.direct_reference) - if (_internal_has_direct_reference()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment* temp = reference_type_.direct_reference_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.direct_reference_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::ReferenceSegment& FieldReference::_internal_direct_reference() const { - return _internal_has_direct_reference() - ? *reference_type_.direct_reference_ - : reinterpret_cast< ::io::substrait::ReferenceSegment&>(::io::substrait::_ReferenceSegment_default_instance_); -} -inline const ::io::substrait::ReferenceSegment& FieldReference::direct_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.FieldReference.direct_reference) - return _internal_direct_reference(); -} -inline ::io::substrait::ReferenceSegment* FieldReference::unsafe_arena_release_direct_reference() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FieldReference.direct_reference) - if (_internal_has_direct_reference()) { - clear_has_reference_type(); - ::io::substrait::ReferenceSegment* temp = reference_type_.direct_reference_; - reference_type_.direct_reference_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FieldReference::unsafe_arena_set_allocated_direct_reference(::io::substrait::ReferenceSegment* direct_reference) { - clear_reference_type(); - if (direct_reference) { - set_has_direct_reference(); - reference_type_.direct_reference_ = direct_reference; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FieldReference.direct_reference) -} -inline ::io::substrait::ReferenceSegment* FieldReference::_internal_mutable_direct_reference() { - if (!_internal_has_direct_reference()) { - clear_reference_type(); - set_has_direct_reference(); - reference_type_.direct_reference_ = CreateMaybeMessage< ::io::substrait::ReferenceSegment >(GetArena()); - } - return reference_type_.direct_reference_; -} -inline ::io::substrait::ReferenceSegment* FieldReference::mutable_direct_reference() { - // @@protoc_insertion_point(field_mutable:io.substrait.FieldReference.direct_reference) - return _internal_mutable_direct_reference(); -} - -// .io.substrait.MaskExpression masked_reference = 2; -inline bool FieldReference::_internal_has_masked_reference() const { - return reference_type_case() == kMaskedReference; -} -inline bool FieldReference::has_masked_reference() const { - return _internal_has_masked_reference(); -} -inline void FieldReference::set_has_masked_reference() { - _oneof_case_[0] = kMaskedReference; -} -inline void FieldReference::clear_masked_reference() { - if (_internal_has_masked_reference()) { - if (GetArena() == nullptr) { - delete reference_type_.masked_reference_; - } - clear_has_reference_type(); - } -} -inline ::io::substrait::MaskExpression* FieldReference::release_masked_reference() { - // @@protoc_insertion_point(field_release:io.substrait.FieldReference.masked_reference) - if (_internal_has_masked_reference()) { - clear_has_reference_type(); - ::io::substrait::MaskExpression* temp = reference_type_.masked_reference_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.masked_reference_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::MaskExpression& FieldReference::_internal_masked_reference() const { - return _internal_has_masked_reference() - ? *reference_type_.masked_reference_ - : reinterpret_cast< ::io::substrait::MaskExpression&>(::io::substrait::_MaskExpression_default_instance_); -} -inline const ::io::substrait::MaskExpression& FieldReference::masked_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.FieldReference.masked_reference) - return _internal_masked_reference(); -} -inline ::io::substrait::MaskExpression* FieldReference::unsafe_arena_release_masked_reference() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FieldReference.masked_reference) - if (_internal_has_masked_reference()) { - clear_has_reference_type(); - ::io::substrait::MaskExpression* temp = reference_type_.masked_reference_; - reference_type_.masked_reference_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FieldReference::unsafe_arena_set_allocated_masked_reference(::io::substrait::MaskExpression* masked_reference) { - clear_reference_type(); - if (masked_reference) { - set_has_masked_reference(); - reference_type_.masked_reference_ = masked_reference; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FieldReference.masked_reference) -} -inline ::io::substrait::MaskExpression* FieldReference::_internal_mutable_masked_reference() { - if (!_internal_has_masked_reference()) { - clear_reference_type(); - set_has_masked_reference(); - reference_type_.masked_reference_ = CreateMaybeMessage< ::io::substrait::MaskExpression >(GetArena()); - } - return reference_type_.masked_reference_; -} -inline ::io::substrait::MaskExpression* FieldReference::mutable_masked_reference() { - // @@protoc_insertion_point(field_mutable:io.substrait.FieldReference.masked_reference) - return _internal_mutable_masked_reference(); -} - -inline bool FieldReference::has_reference_type() const { - return reference_type_case() != REFERENCE_TYPE_NOT_SET; -} -inline void FieldReference::clear_has_reference_type() { - _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; -} -inline FieldReference::ReferenceTypeCase FieldReference::reference_type_case() const { - return FieldReference::ReferenceTypeCase(_oneof_case_[0]); -} -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace substrait -} // namespace io - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_selection_2eproto diff --git a/cpp/src/generated/substrait/type.pb.cc b/cpp/src/generated/substrait/type.pb.cc index 8f487a02a85..62a35389b7b 100644 --- a/cpp/src/generated/substrait/type.pb.cc +++ b/cpp/src/generated/substrait/type.pb.cc @@ -20,7 +20,7 @@ namespace io { namespace substrait { constexpr Type_Boolean::Type_Boolean( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_BooleanDefaultTypeInternal { @@ -34,7 +34,7 @@ struct Type_BooleanDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_BooleanDefaultTypeInternal _Type_Boolean_default_instance_; constexpr Type_I8::Type_I8( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_I8DefaultTypeInternal { @@ -48,7 +48,7 @@ struct Type_I8DefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I8DefaultTypeInternal _Type_I8_default_instance_; constexpr Type_I16::Type_I16( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_I16DefaultTypeInternal { @@ -62,7 +62,7 @@ struct Type_I16DefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I16DefaultTypeInternal _Type_I16_default_instance_; constexpr Type_I32::Type_I32( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_I32DefaultTypeInternal { @@ -76,7 +76,7 @@ struct Type_I32DefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I32DefaultTypeInternal _Type_I32_default_instance_; constexpr Type_I64::Type_I64( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_I64DefaultTypeInternal { @@ -90,7 +90,7 @@ struct Type_I64DefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I64DefaultTypeInternal _Type_I64_default_instance_; constexpr Type_FP32::Type_FP32( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_FP32DefaultTypeInternal { @@ -104,7 +104,7 @@ struct Type_FP32DefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FP32DefaultTypeInternal _Type_FP32_default_instance_; constexpr Type_FP64::Type_FP64( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_FP64DefaultTypeInternal { @@ -118,7 +118,7 @@ struct Type_FP64DefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FP64DefaultTypeInternal _Type_FP64_default_instance_; constexpr Type_String::Type_String( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_StringDefaultTypeInternal { @@ -132,7 +132,7 @@ struct Type_StringDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_StringDefaultTypeInternal _Type_String_default_instance_; constexpr Type_Binary::Type_Binary( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_BinaryDefaultTypeInternal { @@ -146,7 +146,7 @@ struct Type_BinaryDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_BinaryDefaultTypeInternal _Type_Binary_default_instance_; constexpr Type_Timestamp::Type_Timestamp( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_TimestampDefaultTypeInternal { @@ -160,7 +160,7 @@ struct Type_TimestampDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimestampDefaultTypeInternal _Type_Timestamp_default_instance_; constexpr Type_Date::Type_Date( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_DateDefaultTypeInternal { @@ -174,7 +174,7 @@ struct Type_DateDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_DateDefaultTypeInternal _Type_Date_default_instance_; constexpr Type_Time::Type_Time( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_TimeDefaultTypeInternal { @@ -188,7 +188,7 @@ struct Type_TimeDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimeDefaultTypeInternal _Type_Time_default_instance_; constexpr Type_TimestampTZ::Type_TimestampTZ( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_TimestampTZDefaultTypeInternal { @@ -202,7 +202,7 @@ struct Type_TimestampTZDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimestampTZDefaultTypeInternal _Type_TimestampTZ_default_instance_; constexpr Type_IntervalYear::Type_IntervalYear( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_IntervalYearDefaultTypeInternal { @@ -216,7 +216,7 @@ struct Type_IntervalYearDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_IntervalYearDefaultTypeInternal _Type_IntervalYear_default_instance_; constexpr Type_IntervalDay::Type_IntervalDay( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_IntervalDayDefaultTypeInternal { @@ -230,7 +230,7 @@ struct Type_IntervalDayDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_IntervalDayDefaultTypeInternal _Type_IntervalDay_default_instance_; constexpr Type_UUID::Type_UUID( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) + : type_variation_reference_(0u) , nullability_(0) {} struct Type_UUIDDefaultTypeInternal { @@ -244,8 +244,8 @@ struct Type_UUIDDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_UUIDDefaultTypeInternal _Type_UUID_default_instance_; constexpr Type_FixedChar::Type_FixedChar( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) - , length_(0) + : length_(0) + , type_variation_reference_(0u) , nullability_(0) {} struct Type_FixedCharDefaultTypeInternal { @@ -259,8 +259,8 @@ struct Type_FixedCharDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FixedCharDefaultTypeInternal _Type_FixedChar_default_instance_; constexpr Type_VarChar::Type_VarChar( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) - , length_(0) + : length_(0) + , type_variation_reference_(0u) , nullability_(0) {} struct Type_VarCharDefaultTypeInternal { @@ -274,8 +274,8 @@ struct Type_VarCharDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_VarCharDefaultTypeInternal _Type_VarChar_default_instance_; constexpr Type_FixedBinary::Type_FixedBinary( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) - , length_(0) + : length_(0) + , type_variation_reference_(0u) , nullability_(0) {} struct Type_FixedBinaryDefaultTypeInternal { @@ -289,9 +289,9 @@ struct Type_FixedBinaryDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FixedBinaryDefaultTypeInternal _Type_FixedBinary_default_instance_; constexpr Type_Decimal::Type_Decimal( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : variation_(nullptr) - , scale_(0) + : scale_(0) , precision_(0) + , type_variation_reference_(0u) , nullability_(0) {} struct Type_DecimalDefaultTypeInternal { @@ -306,7 +306,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_DecimalDefaultTypeInternal constexpr Type_Struct::Type_Struct( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : types_() - , variation_(nullptr) + , type_variation_reference_(0u) , nullability_(0) {} struct Type_StructDefaultTypeInternal { @@ -318,23 +318,10 @@ struct Type_StructDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_StructDefaultTypeInternal _Type_Struct_default_instance_; -constexpr Type_NamedStruct::Type_NamedStruct( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : names_() - , struct__(nullptr){} -struct Type_NamedStructDefaultTypeInternal { - constexpr Type_NamedStructDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_NamedStructDefaultTypeInternal() {} - union { - Type_NamedStruct _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_NamedStructDefaultTypeInternal _Type_NamedStruct_default_instance_; constexpr Type_List::Type_List( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : type_(nullptr) - , variation_(nullptr) + , type_variation_reference_(0u) , nullability_(0) {} struct Type_ListDefaultTypeInternal { @@ -350,7 +337,7 @@ constexpr Type_Map::Type_Map( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : key_(nullptr) , value_(nullptr) - , variation_(nullptr) + , type_variation_reference_(0u) , nullability_(0) {} struct Type_MapDefaultTypeInternal { @@ -362,19 +349,6 @@ struct Type_MapDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_MapDefaultTypeInternal _Type_Map_default_instance_; -constexpr Type_Variation::Type_Variation( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , organization_(0){} -struct Type_VariationDefaultTypeInternal { - constexpr Type_VariationDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_VariationDefaultTypeInternal() {} - union { - Type_Variation _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_VariationDefaultTypeInternal _Type_Variation_default_instance_; constexpr Type::Type( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : _oneof_case_{}{} @@ -387,9 +361,22 @@ struct TypeDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TypeDefaultTypeInternal _Type_default_instance_; +constexpr NamedStruct::NamedStruct( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : names_() + , struct__(nullptr){} +struct NamedStructDefaultTypeInternal { + constexpr NamedStructDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~NamedStructDefaultTypeInternal() {} + union { + NamedStruct _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NamedStructDefaultTypeInternal _NamedStruct_default_instance_; } // namespace substrait } // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_type_2eproto[26]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_type_2eproto[25]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_type_2eproto[1]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_type_2eproto = nullptr; @@ -399,112 +386,112 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOB ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Boolean, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Boolean, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Boolean, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I8, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I8, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I8, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I8, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I16, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I16, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I16, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I16, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I32, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I32, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I32, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I32, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I64, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I64, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I64, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I64, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP32, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP32, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP32, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP32, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP64, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP64, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP64, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP64, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_String, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_String, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_String, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_String, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Binary, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Binary, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Binary, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Binary, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Timestamp, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Timestamp, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Timestamp, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Timestamp, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Date, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Date, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Date, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Date, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Time, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Time, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Time, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Time, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_TimestampTZ, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_TimestampTZ, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_TimestampTZ, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_TimestampTZ, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalYear, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalYear, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalYear, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalYear, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalDay, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalDay, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalDay, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalDay, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_UUID, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_UUID, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_UUID, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_UUID, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, _internal_metadata_), @@ -512,7 +499,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOB ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, _internal_metadata_), @@ -520,7 +507,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOB ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, _internal_metadata_), @@ -528,7 +515,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOB ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, _internal_metadata_), @@ -537,7 +524,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOB ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, scale_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, precision_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, _internal_metadata_), @@ -545,22 +532,15 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOB ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, types_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_NamedStruct, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_NamedStruct, names_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_NamedStruct, struct__), - ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, _internal_metadata_), @@ -569,16 +549,9 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOB ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, key_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, value_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Variation, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Variation, organization_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Variation, name_), - ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::io::substrait::Type, _oneof_case_[0]), @@ -608,6 +581,13 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOB ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::io::substrait::Type, kind_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::NamedStruct, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::NamedStruct, names_), + PROTOBUF_FIELD_OFFSET(::io::substrait::NamedStruct, struct__), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, sizeof(::io::substrait::Type_Boolean)}, @@ -631,11 +611,10 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 128, -1, sizeof(::io::substrait::Type_FixedBinary)}, { 136, -1, sizeof(::io::substrait::Type_Decimal)}, { 145, -1, sizeof(::io::substrait::Type_Struct)}, - { 153, -1, sizeof(::io::substrait::Type_NamedStruct)}, - { 160, -1, sizeof(::io::substrait::Type_List)}, - { 168, -1, sizeof(::io::substrait::Type_Map)}, - { 177, -1, sizeof(::io::substrait::Type_Variation)}, - { 184, -1, sizeof(::io::substrait::Type)}, + { 153, -1, sizeof(::io::substrait::Type_List)}, + { 161, -1, sizeof(::io::substrait::Type_Map)}, + { 170, -1, sizeof(::io::substrait::Type)}, + { 200, -1, sizeof(::io::substrait::NamedStruct)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -660,126 +639,112 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::io::substrait::_Type_FixedBinary_default_instance_), reinterpret_cast(&::io::substrait::_Type_Decimal_default_instance_), reinterpret_cast(&::io::substrait::_Type_Struct_default_instance_), - reinterpret_cast(&::io::substrait::_Type_NamedStruct_default_instance_), reinterpret_cast(&::io::substrait::_Type_List_default_instance_), reinterpret_cast(&::io::substrait::_Type_Map_default_instance_), - reinterpret_cast(&::io::substrait::_Type_Variation_default_instance_), reinterpret_cast(&::io::substrait::_Type_default_instance_), + reinterpret_cast(&::io::substrait::_NamedStruct_default_instance_), }; const char descriptor_table_protodef_type_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\ntype.proto\022\014io.substrait\032\020extensions.p" - "roto\"\360\037\n\004Type\022*\n\004bool\030\001 \001(\0132\032.io.substra" - "it.Type.BooleanH\000\022#\n\002i8\030\002 \001(\0132\025.io.subst" - "rait.Type.I8H\000\022%\n\003i16\030\003 \001(\0132\026.io.substra" - "it.Type.I16H\000\022%\n\003i32\030\005 \001(\0132\026.io.substrai" - "t.Type.I32H\000\022%\n\003i64\030\007 \001(\0132\026.io.substrait" - ".Type.I64H\000\022\'\n\004fp32\030\n \001(\0132\027.io.substrait" - ".Type.FP32H\000\022\'\n\004fp64\030\013 \001(\0132\027.io.substrai" - "t.Type.FP64H\000\022+\n\006string\030\014 \001(\0132\031.io.subst" - "rait.Type.StringH\000\022+\n\006binary\030\r \001(\0132\031.io." - "substrait.Type.BinaryH\000\0221\n\ttimestamp\030\016 \001" - "(\0132\034.io.substrait.Type.TimestampH\000\022\'\n\004da" - "te\030\020 \001(\0132\027.io.substrait.Type.DateH\000\022\'\n\004t" - "ime\030\021 \001(\0132\027.io.substrait.Type.TimeH\000\0228\n\r" - "interval_year\030\023 \001(\0132\037.io.substrait.Type." - "IntervalYearH\000\0226\n\014interval_day\030\024 \001(\0132\036.i" - "o.substrait.Type.IntervalDayH\000\0226\n\014timest" - "amp_tz\030\035 \001(\0132\036.io.substrait.Type.Timesta" - "mpTZH\000\022\'\n\004uuid\030 \001(\0132\027.io.substrait.Type" - ".UUIDH\000\0222\n\nfixed_char\030\025 \001(\0132\034.io.substra" - "it.Type.FixedCharH\000\022-\n\007varchar\030\026 \001(\0132\032.i" - "o.substrait.Type.VarCharH\000\0226\n\014fixed_bina" - "ry\030\027 \001(\0132\036.io.substrait.Type.FixedBinary" - "H\000\022-\n\007decimal\030\030 \001(\0132\032.io.substrait.Type." - "DecimalH\000\022+\n\006struct\030\031 \001(\0132\031.io.substrait" - ".Type.StructH\000\022\'\n\004list\030\033 \001(\0132\027.io.substr" - "ait.Type.ListH\000\022%\n\003map\030\034 \001(\0132\026.io.substr" - "ait.Type.MapH\000\0227\n\014user_defined\030\037 \001(\0132\037.i" - "o.substrait.Extensions.TypeIdH\000\032o\n\007Boole" - "an\022/\n\tvariation\030\001 \001(\0132\034.io.substrait.Typ" - "e.Variation\0223\n\013nullability\030\002 \001(\0162\036.io.su" - "bstrait.Type.Nullability\032j\n\002I8\022/\n\tvariat" - "ion\030\001 \001(\0132\034.io.substrait.Type.Variation\022" + "\n\ntype.proto\022\014io.substrait\"\210\034\n\004Type\022*\n\004b" + "ool\030\001 \001(\0132\032.io.substrait.Type.BooleanH\000\022" + "#\n\002i8\030\002 \001(\0132\025.io.substrait.Type.I8H\000\022%\n\003" + "i16\030\003 \001(\0132\026.io.substrait.Type.I16H\000\022%\n\003i" + "32\030\005 \001(\0132\026.io.substrait.Type.I32H\000\022%\n\003i6" + "4\030\007 \001(\0132\026.io.substrait.Type.I64H\000\022\'\n\004fp3" + "2\030\n \001(\0132\027.io.substrait.Type.FP32H\000\022\'\n\004fp" + "64\030\013 \001(\0132\027.io.substrait.Type.FP64H\000\022+\n\006s" + "tring\030\014 \001(\0132\031.io.substrait.Type.StringH\000" + "\022+\n\006binary\030\r \001(\0132\031.io.substrait.Type.Bin" + "aryH\000\0221\n\ttimestamp\030\016 \001(\0132\034.io.substrait." + "Type.TimestampH\000\022\'\n\004date\030\020 \001(\0132\027.io.subs" + "trait.Type.DateH\000\022\'\n\004time\030\021 \001(\0132\027.io.sub" + "strait.Type.TimeH\000\0228\n\rinterval_year\030\023 \001(" + "\0132\037.io.substrait.Type.IntervalYearH\000\0226\n\014" + "interval_day\030\024 \001(\0132\036.io.substrait.Type.I" + "ntervalDayH\000\0226\n\014timestamp_tz\030\035 \001(\0132\036.io." + "substrait.Type.TimestampTZH\000\022\'\n\004uuid\030 \001" + "(\0132\027.io.substrait.Type.UUIDH\000\0222\n\nfixed_c" + "har\030\025 \001(\0132\034.io.substrait.Type.FixedCharH" + "\000\022-\n\007varchar\030\026 \001(\0132\032.io.substrait.Type.V" + "arCharH\000\0226\n\014fixed_binary\030\027 \001(\0132\036.io.subs" + "trait.Type.FixedBinaryH\000\022-\n\007decimal\030\030 \001(" + "\0132\032.io.substrait.Type.DecimalH\000\022+\n\006struc" + "t\030\031 \001(\0132\031.io.substrait.Type.StructH\000\022\'\n\004" + "list\030\033 \001(\0132\027.io.substrait.Type.ListH\000\022%\n" + "\003map\030\034 \001(\0132\026.io.substrait.Type.MapH\000\022%\n\033" + "user_defined_type_reference\030\037 \001(\rH\000\032`\n\007B" + "oolean\022 \n\030type_variation_reference\030\001 \001(\r" + "\0223\n\013nullability\030\002 \001(\0162\036.io.substrait.Typ" + "e.Nullability\032[\n\002I8\022 \n\030type_variation_re" + "ference\030\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.io." + "substrait.Type.Nullability\032\\\n\003I16\022 \n\030typ" + "e_variation_reference\030\001 \001(\r\0223\n\013nullabili" + "ty\030\002 \001(\0162\036.io.substrait.Type.Nullability" + "\032\\\n\003I32\022 \n\030type_variation_reference\030\001 \001(" + "\r\0223\n\013nullability\030\002 \001(\0162\036.io.substrait.Ty" + "pe.Nullability\032\\\n\003I64\022 \n\030type_variation_" + "reference\030\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.i" + "o.substrait.Type.Nullability\032]\n\004FP32\022 \n\030" + "type_variation_reference\030\001 \001(\r\0223\n\013nullab" + "ility\030\002 \001(\0162\036.io.substrait.Type.Nullabil" + "ity\032]\n\004FP64\022 \n\030type_variation_reference\030" + "\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.io.substrai" + "t.Type.Nullability\032_\n\006String\022 \n\030type_var" + "iation_reference\030\001 \001(\r\0223\n\013nullability\030\002 " + "\001(\0162\036.io.substrait.Type.Nullability\032_\n\006B" + "inary\022 \n\030type_variation_reference\030\001 \001(\r\022" "3\n\013nullability\030\002 \001(\0162\036.io.substrait.Type" - ".Nullability\032k\n\003I16\022/\n\tvariation\030\001 \001(\0132\034" - ".io.substrait.Type.Variation\0223\n\013nullabil" - "ity\030\002 \001(\0162\036.io.substrait.Type.Nullabilit" - "y\032k\n\003I32\022/\n\tvariation\030\001 \001(\0132\034.io.substra" - "it.Type.Variation\0223\n\013nullability\030\002 \001(\0162\036" - ".io.substrait.Type.Nullability\032k\n\003I64\022/\n" - "\tvariation\030\001 \001(\0132\034.io.substrait.Type.Var" - "iation\0223\n\013nullability\030\002 \001(\0162\036.io.substra" - "it.Type.Nullability\032l\n\004FP32\022/\n\tvariation" - "\030\001 \001(\0132\034.io.substrait.Type.Variation\0223\n\013" + ".Nullability\032b\n\tTimestamp\022 \n\030type_variat" + "ion_reference\030\001 \001(\r\0223\n\013nullability\030\002 \001(\016" + "2\036.io.substrait.Type.Nullability\032]\n\004Date" + "\022 \n\030type_variation_reference\030\001 \001(\r\0223\n\013nu" + "llability\030\002 \001(\0162\036.io.substrait.Type.Null" + "ability\032]\n\004Time\022 \n\030type_variation_refere" + "nce\030\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.io.subs" + "trait.Type.Nullability\032d\n\013TimestampTZ\022 \n" + "\030type_variation_reference\030\001 \001(\r\0223\n\013nulla" + "bility\030\002 \001(\0162\036.io.substrait.Type.Nullabi" + "lity\032e\n\014IntervalYear\022 \n\030type_variation_r" + "eference\030\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.io" + ".substrait.Type.Nullability\032d\n\013IntervalD" + "ay\022 \n\030type_variation_reference\030\001 \001(\r\0223\n\013" "nullability\030\002 \001(\0162\036.io.substrait.Type.Nu" - "llability\032l\n\004FP64\022/\n\tvariation\030\001 \001(\0132\034.i" - "o.substrait.Type.Variation\0223\n\013nullabilit" - "y\030\002 \001(\0162\036.io.substrait.Type.Nullability\032" - "n\n\006String\022/\n\tvariation\030\001 \001(\0132\034.io.substr" - "ait.Type.Variation\0223\n\013nullability\030\002 \001(\0162" - "\036.io.substrait.Type.Nullability\032n\n\006Binar" - "y\022/\n\tvariation\030\001 \001(\0132\034.io.substrait.Type" - ".Variation\0223\n\013nullability\030\002 \001(\0162\036.io.sub" - "strait.Type.Nullability\032q\n\tTimestamp\022/\n\t" - "variation\030\001 \001(\0132\034.io.substrait.Type.Vari" - "ation\0223\n\013nullability\030\002 \001(\0162\036.io.substrai" - "t.Type.Nullability\032l\n\004Date\022/\n\tvariation\030" - "\001 \001(\0132\034.io.substrait.Type.Variation\0223\n\013n" - "ullability\030\002 \001(\0162\036.io.substrait.Type.Nul" - "lability\032l\n\004Time\022/\n\tvariation\030\001 \001(\0132\034.io" - ".substrait.Type.Variation\0223\n\013nullability" - "\030\002 \001(\0162\036.io.substrait.Type.Nullability\032s" - "\n\013TimestampTZ\022/\n\tvariation\030\001 \001(\0132\034.io.su" - "bstrait.Type.Variation\0223\n\013nullability\030\002 " - "\001(\0162\036.io.substrait.Type.Nullability\032t\n\014I" - "ntervalYear\022/\n\tvariation\030\001 \001(\0132\034.io.subs" - "trait.Type.Variation\0223\n\013nullability\030\002 \001(" - "\0162\036.io.substrait.Type.Nullability\032s\n\013Int" - "ervalDay\022/\n\tvariation\030\001 \001(\0132\034.io.substra" - "it.Type.Variation\0223\n\013nullability\030\002 \001(\0162\036" - ".io.substrait.Type.Nullability\032l\n\004UUID\022/" - "\n\tvariation\030\001 \001(\0132\034.io.substrait.Type.Va" - "riation\0223\n\013nullability\030\002 \001(\0162\036.io.substr" - "ait.Type.Nullability\032\201\001\n\tFixedChar\022\016\n\006le" - "ngth\030\001 \001(\005\022/\n\tvariation\030\002 \001(\0132\034.io.subst" - "rait.Type.Variation\0223\n\013nullability\030\003 \001(\016" - "2\036.io.substrait.Type.Nullability\032\177\n\007VarC" - "har\022\016\n\006length\030\001 \001(\005\022/\n\tvariation\030\002 \001(\0132\034" - ".io.substrait.Type.Variation\0223\n\013nullabil" - "ity\030\003 \001(\0162\036.io.substrait.Type.Nullabilit" - "y\032\203\001\n\013FixedBinary\022\016\n\006length\030\001 \001(\005\022/\n\tvar" - "iation\030\002 \001(\0132\034.io.substrait.Type.Variati" - "on\0223\n\013nullability\030\003 \001(\0162\036.io.substrait.T" - "ype.Nullability\032\221\001\n\007Decimal\022\r\n\005scale\030\001 \001" - "(\005\022\021\n\tprecision\030\002 \001(\005\022/\n\tvariation\030\003 \001(\013" - "2\034.io.substrait.Type.Variation\0223\n\013nullab" - "ility\030\004 \001(\0162\036.io.substrait.Type.Nullabil" - "ity\032\221\001\n\006Struct\022!\n\005types\030\001 \003(\0132\022.io.subst" - "rait.Type\022/\n\tvariation\030\002 \001(\0132\034.io.substr" - "ait.Type.Variation\0223\n\013nullability\030\003 \001(\0162" - "\036.io.substrait.Type.Nullability\032G\n\013Named" - "Struct\022\r\n\005names\030\001 \003(\t\022)\n\006struct\030\002 \001(\0132\031." - "io.substrait.Type.Struct\032\216\001\n\004List\022 \n\004typ" - "e\030\001 \001(\0132\022.io.substrait.Type\022/\n\tvariation" - "\030\002 \001(\0132\034.io.substrait.Type.Variation\0223\n\013" - "nullability\030\003 \001(\0162\036.io.substrait.Type.Nu" - "llability\032\257\001\n\003Map\022\037\n\003key\030\001 \001(\0132\022.io.subs" - "trait.Type\022!\n\005value\030\002 \001(\0132\022.io.substrait" - ".Type\022/\n\tvariation\030\003 \001(\0132\034.io.substrait." - "Type.Variation\0223\n\013nullability\030\004 \001(\0162\036.io" - ".substrait.Type.Nullability\032/\n\tVariation" - "\022\024\n\014organization\030\001 \001(\005\022\014\n\004name\030\002 \001(\t\")\n\013" - "Nullability\022\014\n\010NULLABLE\020\000\022\014\n\010REQUIRED\020\001B" - "\006\n\004kindB\027P\001\252\002\022Substrait.Protobufb\006proto3" + "llability\032]\n\004UUID\022 \n\030type_variation_refe" + "rence\030\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.io.su" + "bstrait.Type.Nullability\032r\n\tFixedChar\022\016\n" + "\006length\030\001 \001(\005\022 \n\030type_variation_referenc" + "e\030\002 \001(\r\0223\n\013nullability\030\003 \001(\0162\036.io.substr" + "ait.Type.Nullability\032p\n\007VarChar\022\016\n\006lengt" + "h\030\001 \001(\005\022 \n\030type_variation_reference\030\002 \001(" + "\r\0223\n\013nullability\030\003 \001(\0162\036.io.substrait.Ty" + "pe.Nullability\032t\n\013FixedBinary\022\016\n\006length\030" + "\001 \001(\005\022 \n\030type_variation_reference\030\002 \001(\r\022" + "3\n\013nullability\030\003 \001(\0162\036.io.substrait.Type" + ".Nullability\032\202\001\n\007Decimal\022\r\n\005scale\030\001 \001(\005\022" + "\021\n\tprecision\030\002 \001(\005\022 \n\030type_variation_ref" + "erence\030\003 \001(\r\0223\n\013nullability\030\004 \001(\0162\036.io.s" + "ubstrait.Type.Nullability\032\202\001\n\006Struct\022!\n\005" + "types\030\001 \003(\0132\022.io.substrait.Type\022 \n\030type_" + "variation_reference\030\002 \001(\r\0223\n\013nullability" + "\030\003 \001(\0162\036.io.substrait.Type.Nullability\032\177" + "\n\004List\022 \n\004type\030\001 \001(\0132\022.io.substrait.Type" + "\022 \n\030type_variation_reference\030\002 \001(\r\0223\n\013nu" + "llability\030\003 \001(\0162\036.io.substrait.Type.Null" + "ability\032\240\001\n\003Map\022\037\n\003key\030\001 \001(\0132\022.io.substr" + "ait.Type\022!\n\005value\030\002 \001(\0132\022.io.substrait.T" + "ype\022 \n\030type_variation_reference\030\003 \001(\r\0223\n" + "\013nullability\030\004 \001(\0162\036.io.substrait.Type.N" + "ullability\")\n\013Nullability\022\014\n\010NULLABLE\020\000\022" + "\014\n\010REQUIRED\020\001B\006\n\004kind\"G\n\013NamedStruct\022\r\n\005" + "names\030\001 \003(\t\022)\n\006struct\030\002 \001(\0132\031.io.substra" + "it.Type.StructB+\n\022io.substrait.protoP\001\252\002" + "\022Substrait.Protobufb\006proto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_type_2eproto_deps[1] = { - &::descriptor_table_extensions_2eproto, -}; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_type_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_2eproto = { - false, false, 4160, descriptor_table_protodef_type_2eproto, "type.proto", - &descriptor_table_type_2eproto_once, descriptor_table_type_2eproto_deps, 1, 26, + false, false, 3747, descriptor_table_protodef_type_2eproto, "type.proto", + &descriptor_table_type_2eproto_once, nullptr, 0, 25, schemas, file_default_instances, TableStruct_type_2eproto::offsets, file_level_metadata_type_2eproto, file_level_enum_descriptors_type_2eproto, file_level_service_descriptors_type_2eproto, }; @@ -817,13 +782,8 @@ constexpr int Type::Nullability_ARRAYSIZE; class Type_Boolean::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_Boolean* msg); }; -const ::io::substrait::Type_Variation& -Type_Boolean::_Internal::variation(const Type_Boolean* msg) { - return *msg->variation_; -} Type_Boolean::Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -833,20 +793,17 @@ Type_Boolean::Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_Boolean::Type_Boolean(const Type_Boolean& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Boolean) } void Type_Boolean::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_Boolean::~Type_Boolean() { @@ -857,7 +814,6 @@ Type_Boolean::~Type_Boolean() { void Type_Boolean::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_Boolean::ArenaDtor(void* object) { @@ -876,11 +832,9 @@ void Type_Boolean::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -890,10 +844,10 @@ const char* Type_Boolean::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -934,12 +888,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Boolean::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -965,11 +917,11 @@ size_t Type_Boolean::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -1009,8 +961,8 @@ void Type_Boolean::MergeFrom(const Type_Boolean& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1041,9 +993,9 @@ void Type_Boolean::InternalSwap(Type_Boolean* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Boolean, nullability_) + sizeof(Type_Boolean::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Boolean, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_Boolean, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_Boolean::GetMetadata() const { @@ -1056,13 +1008,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_Boolean::GetMetadata() const { class Type_I8::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_I8* msg); }; -const ::io::substrait::Type_Variation& -Type_I8::_Internal::variation(const Type_I8* msg) { - return *msg->variation_; -} Type_I8::Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1072,20 +1019,17 @@ Type_I8::Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_I8::Type_I8(const Type_I8& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I8) } void Type_I8::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_I8::~Type_I8() { @@ -1096,7 +1040,6 @@ Type_I8::~Type_I8() { void Type_I8::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_I8::ArenaDtor(void* object) { @@ -1115,11 +1058,9 @@ void Type_I8::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1129,10 +1070,10 @@ const char* Type_I8::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1173,12 +1114,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I8::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -1204,11 +1143,11 @@ size_t Type_I8::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -1248,8 +1187,8 @@ void Type_I8::MergeFrom(const Type_I8& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1280,9 +1219,9 @@ void Type_I8::InternalSwap(Type_I8* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_I8, nullability_) + sizeof(Type_I8::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_I8, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_I8, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_I8::GetMetadata() const { @@ -1295,13 +1234,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_I8::GetMetadata() const { class Type_I16::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_I16* msg); }; -const ::io::substrait::Type_Variation& -Type_I16::_Internal::variation(const Type_I16* msg) { - return *msg->variation_; -} Type_I16::Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1311,20 +1245,17 @@ Type_I16::Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_I16::Type_I16(const Type_I16& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I16) } void Type_I16::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_I16::~Type_I16() { @@ -1335,7 +1266,6 @@ Type_I16::~Type_I16() { void Type_I16::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_I16::ArenaDtor(void* object) { @@ -1354,11 +1284,9 @@ void Type_I16::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1368,10 +1296,10 @@ const char* Type_I16::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1412,12 +1340,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I16::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -1443,11 +1369,11 @@ size_t Type_I16::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -1487,8 +1413,8 @@ void Type_I16::MergeFrom(const Type_I16& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1519,9 +1445,9 @@ void Type_I16::InternalSwap(Type_I16* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_I16, nullability_) + sizeof(Type_I16::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_I16, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_I16, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_I16::GetMetadata() const { @@ -1534,13 +1460,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_I16::GetMetadata() const { class Type_I32::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_I32* msg); }; -const ::io::substrait::Type_Variation& -Type_I32::_Internal::variation(const Type_I32* msg) { - return *msg->variation_; -} Type_I32::Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1550,20 +1471,17 @@ Type_I32::Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_I32::Type_I32(const Type_I32& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I32) } void Type_I32::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_I32::~Type_I32() { @@ -1574,7 +1492,6 @@ Type_I32::~Type_I32() { void Type_I32::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_I32::ArenaDtor(void* object) { @@ -1593,11 +1510,9 @@ void Type_I32::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1607,10 +1522,10 @@ const char* Type_I32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1651,12 +1566,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I32::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -1682,11 +1595,11 @@ size_t Type_I32::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -1726,8 +1639,8 @@ void Type_I32::MergeFrom(const Type_I32& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1758,9 +1671,9 @@ void Type_I32::InternalSwap(Type_I32* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_I32, nullability_) + sizeof(Type_I32::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_I32, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_I32, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_I32::GetMetadata() const { @@ -1773,13 +1686,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_I32::GetMetadata() const { class Type_I64::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_I64* msg); }; -const ::io::substrait::Type_Variation& -Type_I64::_Internal::variation(const Type_I64* msg) { - return *msg->variation_; -} Type_I64::Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1789,20 +1697,17 @@ Type_I64::Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_I64::Type_I64(const Type_I64& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I64) } void Type_I64::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_I64::~Type_I64() { @@ -1813,7 +1718,6 @@ Type_I64::~Type_I64() { void Type_I64::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_I64::ArenaDtor(void* object) { @@ -1832,11 +1736,9 @@ void Type_I64::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1846,10 +1748,10 @@ const char* Type_I64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1890,12 +1792,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I64::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -1921,11 +1821,11 @@ size_t Type_I64::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -1965,8 +1865,8 @@ void Type_I64::MergeFrom(const Type_I64& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1997,9 +1897,9 @@ void Type_I64::InternalSwap(Type_I64* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_I64, nullability_) + sizeof(Type_I64::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_I64, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_I64, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_I64::GetMetadata() const { @@ -2012,13 +1912,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_I64::GetMetadata() const { class Type_FP32::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_FP32* msg); }; -const ::io::substrait::Type_Variation& -Type_FP32::_Internal::variation(const Type_FP32* msg) { - return *msg->variation_; -} Type_FP32::Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -2028,20 +1923,17 @@ Type_FP32::Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_FP32::Type_FP32(const Type_FP32& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.FP32) } void Type_FP32::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_FP32::~Type_FP32() { @@ -2052,7 +1944,6 @@ Type_FP32::~Type_FP32() { void Type_FP32::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_FP32::ArenaDtor(void* object) { @@ -2071,11 +1962,9 @@ void Type_FP32::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2085,10 +1974,10 @@ const char* Type_FP32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -2129,12 +2018,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FP32::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -2160,11 +2047,11 @@ size_t Type_FP32::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -2204,8 +2091,8 @@ void Type_FP32::MergeFrom(const Type_FP32& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -2236,9 +2123,9 @@ void Type_FP32::InternalSwap(Type_FP32* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_FP32, nullability_) + sizeof(Type_FP32::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_FP32, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_FP32, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_FP32::GetMetadata() const { @@ -2251,13 +2138,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_FP32::GetMetadata() const { class Type_FP64::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_FP64* msg); }; -const ::io::substrait::Type_Variation& -Type_FP64::_Internal::variation(const Type_FP64* msg) { - return *msg->variation_; -} Type_FP64::Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -2267,20 +2149,17 @@ Type_FP64::Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_FP64::Type_FP64(const Type_FP64& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.FP64) } void Type_FP64::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_FP64::~Type_FP64() { @@ -2291,7 +2170,6 @@ Type_FP64::~Type_FP64() { void Type_FP64::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_FP64::ArenaDtor(void* object) { @@ -2310,11 +2188,9 @@ void Type_FP64::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2324,10 +2200,10 @@ const char* Type_FP64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -2368,12 +2244,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FP64::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -2399,11 +2273,11 @@ size_t Type_FP64::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -2443,8 +2317,8 @@ void Type_FP64::MergeFrom(const Type_FP64& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -2475,9 +2349,9 @@ void Type_FP64::InternalSwap(Type_FP64* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_FP64, nullability_) + sizeof(Type_FP64::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_FP64, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_FP64, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_FP64::GetMetadata() const { @@ -2490,13 +2364,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_FP64::GetMetadata() const { class Type_String::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_String* msg); }; -const ::io::substrait::Type_Variation& -Type_String::_Internal::variation(const Type_String* msg) { - return *msg->variation_; -} Type_String::Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -2506,20 +2375,17 @@ Type_String::Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_String::Type_String(const Type_String& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.String) } void Type_String::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_String::~Type_String() { @@ -2530,7 +2396,6 @@ Type_String::~Type_String() { void Type_String::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_String::ArenaDtor(void* object) { @@ -2549,11 +2414,9 @@ void Type_String::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2563,10 +2426,10 @@ const char* Type_String::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -2607,12 +2470,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_String::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -2638,11 +2499,11 @@ size_t Type_String::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -2682,8 +2543,8 @@ void Type_String::MergeFrom(const Type_String& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -2714,9 +2575,9 @@ void Type_String::InternalSwap(Type_String* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_String, nullability_) + sizeof(Type_String::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_String, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_String, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_String::GetMetadata() const { @@ -2729,13 +2590,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_String::GetMetadata() const { class Type_Binary::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_Binary* msg); }; -const ::io::substrait::Type_Variation& -Type_Binary::_Internal::variation(const Type_Binary* msg) { - return *msg->variation_; -} Type_Binary::Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -2745,20 +2601,17 @@ Type_Binary::Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_Binary::Type_Binary(const Type_Binary& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Binary) } void Type_Binary::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_Binary::~Type_Binary() { @@ -2769,7 +2622,6 @@ Type_Binary::~Type_Binary() { void Type_Binary::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_Binary::ArenaDtor(void* object) { @@ -2788,11 +2640,9 @@ void Type_Binary::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2802,10 +2652,10 @@ const char* Type_Binary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -2846,12 +2696,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Binary::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -2877,11 +2725,11 @@ size_t Type_Binary::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -2921,8 +2769,8 @@ void Type_Binary::MergeFrom(const Type_Binary& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -2953,9 +2801,9 @@ void Type_Binary::InternalSwap(Type_Binary* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Binary, nullability_) + sizeof(Type_Binary::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Binary, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_Binary, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_Binary::GetMetadata() const { @@ -2968,13 +2816,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_Binary::GetMetadata() const { class Type_Timestamp::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_Timestamp* msg); }; -const ::io::substrait::Type_Variation& -Type_Timestamp::_Internal::variation(const Type_Timestamp* msg) { - return *msg->variation_; -} Type_Timestamp::Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -2984,20 +2827,17 @@ Type_Timestamp::Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_Timestamp::Type_Timestamp(const Type_Timestamp& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Timestamp) } void Type_Timestamp::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_Timestamp::~Type_Timestamp() { @@ -3008,7 +2848,6 @@ Type_Timestamp::~Type_Timestamp() { void Type_Timestamp::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_Timestamp::ArenaDtor(void* object) { @@ -3027,11 +2866,9 @@ void Type_Timestamp::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3041,10 +2878,10 @@ const char* Type_Timestamp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -3085,12 +2922,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Timestamp::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -3116,11 +2951,11 @@ size_t Type_Timestamp::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -3160,8 +2995,8 @@ void Type_Timestamp::MergeFrom(const Type_Timestamp& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -3192,9 +3027,9 @@ void Type_Timestamp::InternalSwap(Type_Timestamp* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Timestamp, nullability_) + sizeof(Type_Timestamp::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Timestamp, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_Timestamp, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_Timestamp::GetMetadata() const { @@ -3207,13 +3042,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_Timestamp::GetMetadata() const { class Type_Date::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_Date* msg); }; -const ::io::substrait::Type_Variation& -Type_Date::_Internal::variation(const Type_Date* msg) { - return *msg->variation_; -} Type_Date::Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -3223,20 +3053,17 @@ Type_Date::Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_Date::Type_Date(const Type_Date& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Date) } void Type_Date::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_Date::~Type_Date() { @@ -3247,7 +3074,6 @@ Type_Date::~Type_Date() { void Type_Date::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_Date::ArenaDtor(void* object) { @@ -3266,11 +3092,9 @@ void Type_Date::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3280,10 +3104,10 @@ const char* Type_Date::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -3324,12 +3148,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Date::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -3355,11 +3177,11 @@ size_t Type_Date::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -3399,8 +3221,8 @@ void Type_Date::MergeFrom(const Type_Date& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -3431,9 +3253,9 @@ void Type_Date::InternalSwap(Type_Date* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Date, nullability_) + sizeof(Type_Date::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Date, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_Date, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_Date::GetMetadata() const { @@ -3446,13 +3268,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_Date::GetMetadata() const { class Type_Time::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_Time* msg); }; -const ::io::substrait::Type_Variation& -Type_Time::_Internal::variation(const Type_Time* msg) { - return *msg->variation_; -} Type_Time::Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -3462,20 +3279,17 @@ Type_Time::Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_Time::Type_Time(const Type_Time& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Time) } void Type_Time::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_Time::~Type_Time() { @@ -3486,7 +3300,6 @@ Type_Time::~Type_Time() { void Type_Time::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_Time::ArenaDtor(void* object) { @@ -3505,11 +3318,9 @@ void Type_Time::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3519,10 +3330,10 @@ const char* Type_Time::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -3563,12 +3374,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Time::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -3594,11 +3403,11 @@ size_t Type_Time::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -3638,8 +3447,8 @@ void Type_Time::MergeFrom(const Type_Time& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -3670,9 +3479,9 @@ void Type_Time::InternalSwap(Type_Time* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Time, nullability_) + sizeof(Type_Time::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Time, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_Time, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_Time::GetMetadata() const { @@ -3685,13 +3494,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_Time::GetMetadata() const { class Type_TimestampTZ::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_TimestampTZ* msg); }; -const ::io::substrait::Type_Variation& -Type_TimestampTZ::_Internal::variation(const Type_TimestampTZ* msg) { - return *msg->variation_; -} Type_TimestampTZ::Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -3701,20 +3505,17 @@ Type_TimestampTZ::Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_TimestampTZ::Type_TimestampTZ(const Type_TimestampTZ& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.TimestampTZ) } void Type_TimestampTZ::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_TimestampTZ::~Type_TimestampTZ() { @@ -3725,7 +3526,6 @@ Type_TimestampTZ::~Type_TimestampTZ() { void Type_TimestampTZ::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_TimestampTZ::ArenaDtor(void* object) { @@ -3744,11 +3544,9 @@ void Type_TimestampTZ::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3758,10 +3556,10 @@ const char* Type_TimestampTZ::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -3802,12 +3600,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_TimestampTZ::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -3833,11 +3629,11 @@ size_t Type_TimestampTZ::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -3877,8 +3673,8 @@ void Type_TimestampTZ::MergeFrom(const Type_TimestampTZ& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -3909,9 +3705,9 @@ void Type_TimestampTZ::InternalSwap(Type_TimestampTZ* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_TimestampTZ, nullability_) + sizeof(Type_TimestampTZ::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_TimestampTZ, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_TimestampTZ, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_TimestampTZ::GetMetadata() const { @@ -3924,13 +3720,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_TimestampTZ::GetMetadata() const { class Type_IntervalYear::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_IntervalYear* msg); }; -const ::io::substrait::Type_Variation& -Type_IntervalYear::_Internal::variation(const Type_IntervalYear* msg) { - return *msg->variation_; -} Type_IntervalYear::Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -3940,20 +3731,17 @@ Type_IntervalYear::Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_IntervalYear::Type_IntervalYear(const Type_IntervalYear& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.IntervalYear) } void Type_IntervalYear::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_IntervalYear::~Type_IntervalYear() { @@ -3964,7 +3752,6 @@ Type_IntervalYear::~Type_IntervalYear() { void Type_IntervalYear::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_IntervalYear::ArenaDtor(void* object) { @@ -3983,11 +3770,9 @@ void Type_IntervalYear::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3997,10 +3782,10 @@ const char* Type_IntervalYear::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -4041,12 +3826,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalYear::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -4072,11 +3855,11 @@ size_t Type_IntervalYear::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -4116,8 +3899,8 @@ void Type_IntervalYear::MergeFrom(const Type_IntervalYear& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -4148,9 +3931,9 @@ void Type_IntervalYear::InternalSwap(Type_IntervalYear* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_IntervalYear, nullability_) + sizeof(Type_IntervalYear::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_IntervalYear, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_IntervalYear, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalYear::GetMetadata() const { @@ -4163,13 +3946,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalYear::GetMetadata() const { class Type_IntervalDay::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_IntervalDay* msg); }; -const ::io::substrait::Type_Variation& -Type_IntervalDay::_Internal::variation(const Type_IntervalDay* msg) { - return *msg->variation_; -} Type_IntervalDay::Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -4179,20 +3957,17 @@ Type_IntervalDay::Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_IntervalDay::Type_IntervalDay(const Type_IntervalDay& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.IntervalDay) } void Type_IntervalDay::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_IntervalDay::~Type_IntervalDay() { @@ -4203,7 +3978,6 @@ Type_IntervalDay::~Type_IntervalDay() { void Type_IntervalDay::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_IntervalDay::ArenaDtor(void* object) { @@ -4222,11 +3996,9 @@ void Type_IntervalDay::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4236,10 +4008,10 @@ const char* Type_IntervalDay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -4280,12 +4052,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalDay::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -4311,11 +4081,11 @@ size_t Type_IntervalDay::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -4355,8 +4125,8 @@ void Type_IntervalDay::MergeFrom(const Type_IntervalDay& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -4387,9 +4157,9 @@ void Type_IntervalDay::InternalSwap(Type_IntervalDay* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_IntervalDay, nullability_) + sizeof(Type_IntervalDay::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_IntervalDay, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_IntervalDay, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalDay::GetMetadata() const { @@ -4402,13 +4172,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalDay::GetMetadata() const { class Type_UUID::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_UUID* msg); }; -const ::io::substrait::Type_Variation& -Type_UUID::_Internal::variation(const Type_UUID* msg) { - return *msg->variation_; -} Type_UUID::Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -4418,20 +4183,17 @@ Type_UUID::Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_UUID::Type_UUID(const Type_UUID& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.UUID) } void Type_UUID::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_UUID::~Type_UUID() { @@ -4442,7 +4204,6 @@ Type_UUID::~Type_UUID() { void Type_UUID::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_UUID::ArenaDtor(void* object) { @@ -4461,11 +4222,9 @@ void Type_UUID::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4475,10 +4234,10 @@ const char* Type_UUID::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Variation variation = 1; + // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -4519,12 +4278,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_UUID::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 2; @@ -4550,11 +4307,11 @@ size_t Type_UUID::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 1; - if (this->has_variation()) { + // uint32 type_variation_reference = 1; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 2; @@ -4594,8 +4351,8 @@ void Type_UUID::MergeFrom(const Type_UUID& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -4626,9 +4383,9 @@ void Type_UUID::InternalSwap(Type_UUID* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_UUID, nullability_) + sizeof(Type_UUID::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_UUID, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_UUID, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_UUID::GetMetadata() const { @@ -4641,13 +4398,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_UUID::GetMetadata() const { class Type_FixedChar::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_FixedChar* msg); }; -const ::io::substrait::Type_Variation& -Type_FixedChar::_Internal::variation(const Type_FixedChar* msg) { - return *msg->variation_; -} Type_FixedChar::Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -4657,11 +4409,6 @@ Type_FixedChar::Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_FixedChar::Type_FixedChar(const Type_FixedChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } ::memcpy(&length_, &from.length_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&length_)) + sizeof(nullability_)); @@ -4670,9 +4417,9 @@ Type_FixedChar::Type_FixedChar(const Type_FixedChar& from) void Type_FixedChar::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&length_)) + sizeof(nullability_)); } Type_FixedChar::~Type_FixedChar() { @@ -4683,7 +4430,6 @@ Type_FixedChar::~Type_FixedChar() { void Type_FixedChar::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_FixedChar::ArenaDtor(void* object) { @@ -4702,10 +4448,6 @@ void Type_FixedChar::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; ::memset(&length_, 0, static_cast( reinterpret_cast(&nullability_) - reinterpret_cast(&length_)) + sizeof(nullability_)); @@ -4725,10 +4467,10 @@ const char* Type_FixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 type_variation_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -4775,12 +4517,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedChar::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 type_variation_reference = 2; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -4806,13 +4546,6 @@ size_t Type_FixedChar::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); - } - // int32 length = 1; if (this->length() != 0) { total_size += 1 + @@ -4820,6 +4553,13 @@ size_t Type_FixedChar::ByteSizeLong() const { this->_internal_length()); } + // uint32 type_variation_reference = 2; + if (this->type_variation_reference() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); + } + // .io.substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + @@ -4857,12 +4597,12 @@ void Type_FixedChar::MergeFrom(const Type_FixedChar& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); - } if (from.length() != 0) { _internal_set_length(from._internal_length()); } + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); + } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } @@ -4892,9 +4632,9 @@ void Type_FixedChar::InternalSwap(Type_FixedChar* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_FixedChar, nullability_) + sizeof(Type_FixedChar::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_FixedChar, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_FixedChar, length_)>( + reinterpret_cast(&length_), + reinterpret_cast(&other->length_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedChar::GetMetadata() const { @@ -4907,13 +4647,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedChar::GetMetadata() const { class Type_VarChar::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_VarChar* msg); }; -const ::io::substrait::Type_Variation& -Type_VarChar::_Internal::variation(const Type_VarChar* msg) { - return *msg->variation_; -} Type_VarChar::Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -4923,11 +4658,6 @@ Type_VarChar::Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_VarChar::Type_VarChar(const Type_VarChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } ::memcpy(&length_, &from.length_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&length_)) + sizeof(nullability_)); @@ -4936,9 +4666,9 @@ Type_VarChar::Type_VarChar(const Type_VarChar& from) void Type_VarChar::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&length_)) + sizeof(nullability_)); } Type_VarChar::~Type_VarChar() { @@ -4949,7 +4679,6 @@ Type_VarChar::~Type_VarChar() { void Type_VarChar::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_VarChar::ArenaDtor(void* object) { @@ -4968,10 +4697,6 @@ void Type_VarChar::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; ::memset(&length_, 0, static_cast( reinterpret_cast(&nullability_) - reinterpret_cast(&length_)) + sizeof(nullability_)); @@ -4991,10 +4716,10 @@ const char* Type_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 type_variation_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -5041,12 +4766,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_VarChar::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 type_variation_reference = 2; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -5072,13 +4795,6 @@ size_t Type_VarChar::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); - } - // int32 length = 1; if (this->length() != 0) { total_size += 1 + @@ -5086,6 +4802,13 @@ size_t Type_VarChar::ByteSizeLong() const { this->_internal_length()); } + // uint32 type_variation_reference = 2; + if (this->type_variation_reference() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); + } + // .io.substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + @@ -5123,12 +4846,12 @@ void Type_VarChar::MergeFrom(const Type_VarChar& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); - } if (from.length() != 0) { _internal_set_length(from._internal_length()); } + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); + } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } @@ -5158,9 +4881,9 @@ void Type_VarChar::InternalSwap(Type_VarChar* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_VarChar, nullability_) + sizeof(Type_VarChar::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_VarChar, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_VarChar, length_)>( + reinterpret_cast(&length_), + reinterpret_cast(&other->length_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_VarChar::GetMetadata() const { @@ -5173,13 +4896,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_VarChar::GetMetadata() const { class Type_FixedBinary::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_FixedBinary* msg); }; -const ::io::substrait::Type_Variation& -Type_FixedBinary::_Internal::variation(const Type_FixedBinary* msg) { - return *msg->variation_; -} Type_FixedBinary::Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -5189,11 +4907,6 @@ Type_FixedBinary::Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_FixedBinary::Type_FixedBinary(const Type_FixedBinary& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } ::memcpy(&length_, &from.length_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&length_)) + sizeof(nullability_)); @@ -5202,9 +4915,9 @@ Type_FixedBinary::Type_FixedBinary(const Type_FixedBinary& from) void Type_FixedBinary::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&length_)) + sizeof(nullability_)); } Type_FixedBinary::~Type_FixedBinary() { @@ -5215,7 +4928,6 @@ Type_FixedBinary::~Type_FixedBinary() { void Type_FixedBinary::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_FixedBinary::ArenaDtor(void* object) { @@ -5234,10 +4946,6 @@ void Type_FixedBinary::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; ::memset(&length_, 0, static_cast( reinterpret_cast(&nullability_) - reinterpret_cast(&length_)) + sizeof(nullability_)); @@ -5257,10 +4965,10 @@ const char* Type_FixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 type_variation_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -5307,12 +5015,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedBinary::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 type_variation_reference = 2; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -5338,18 +5044,18 @@ size_t Type_FixedBinary::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // int32 length = 1; + if (this->length() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( + this->_internal_length()); } - // int32 length = 1; - if (this->length() != 0) { + // uint32 type_variation_reference = 2; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_length()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 3; @@ -5389,12 +5095,12 @@ void Type_FixedBinary::MergeFrom(const Type_FixedBinary& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); - } if (from.length() != 0) { _internal_set_length(from._internal_length()); } + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); + } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } @@ -5424,9 +5130,9 @@ void Type_FixedBinary::InternalSwap(Type_FixedBinary* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_FixedBinary, nullability_) + sizeof(Type_FixedBinary::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_FixedBinary, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_FixedBinary, length_)>( + reinterpret_cast(&length_), + reinterpret_cast(&other->length_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedBinary::GetMetadata() const { @@ -5439,13 +5145,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedBinary::GetMetadata() const { class Type_Decimal::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_Decimal* msg); }; -const ::io::substrait::Type_Variation& -Type_Decimal::_Internal::variation(const Type_Decimal* msg) { - return *msg->variation_; -} Type_Decimal::Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -5455,11 +5156,6 @@ Type_Decimal::Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) Type_Decimal::Type_Decimal(const Type_Decimal& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } ::memcpy(&scale_, &from.scale_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&scale_)) + sizeof(nullability_)); @@ -5468,9 +5164,9 @@ Type_Decimal::Type_Decimal(const Type_Decimal& from) void Type_Decimal::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&scale_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&scale_)) + sizeof(nullability_)); } Type_Decimal::~Type_Decimal() { @@ -5481,7 +5177,6 @@ Type_Decimal::~Type_Decimal() { void Type_Decimal::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_Decimal::ArenaDtor(void* object) { @@ -5500,10 +5195,6 @@ void Type_Decimal::Clear() { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; ::memset(&scale_, 0, static_cast( reinterpret_cast(&nullability_) - reinterpret_cast(&scale_)) + sizeof(nullability_)); @@ -5530,10 +5221,10 @@ const char* Type_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 3; + // uint32 type_variation_reference = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -5586,12 +5277,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Decimal::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_precision(), target); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 type_variation_reference = 3; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 4; @@ -5617,13 +5306,6 @@ size_t Type_Decimal::ByteSizeLong() const { // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); - } - // int32 scale = 1; if (this->scale() != 0) { total_size += 1 + @@ -5638,6 +5320,13 @@ size_t Type_Decimal::ByteSizeLong() const { this->_internal_precision()); } + // uint32 type_variation_reference = 3; + if (this->type_variation_reference() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); + } + // .io.substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { total_size += 1 + @@ -5675,15 +5364,15 @@ void Type_Decimal::MergeFrom(const Type_Decimal& from) { ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); - } if (from.scale() != 0) { _internal_set_scale(from._internal_scale()); } if (from.precision() != 0) { _internal_set_precision(from._internal_precision()); } + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); + } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } @@ -5713,9 +5402,9 @@ void Type_Decimal::InternalSwap(Type_Decimal* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Decimal, nullability_) + sizeof(Type_Decimal::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Decimal, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_Decimal, scale_)>( + reinterpret_cast(&scale_), + reinterpret_cast(&other->scale_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_Decimal::GetMetadata() const { @@ -5728,13 +5417,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_Decimal::GetMetadata() const { class Type_Struct::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const Type_Struct* msg); }; -const ::io::substrait::Type_Variation& -Type_Struct::_Internal::variation(const Type_Struct* msg) { - return *msg->variation_; -} Type_Struct::Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), types_(arena) { @@ -5746,20 +5430,17 @@ Type_Struct::Type_Struct(const Type_Struct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), types_(from.types_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Struct) } void Type_Struct::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); } Type_Struct::~Type_Struct() { @@ -5770,7 +5451,6 @@ Type_Struct::~Type_Struct() { void Type_Struct::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void Type_Struct::ArenaDtor(void* object) { @@ -5790,11 +5470,9 @@ void Type_Struct::Clear() { (void) cached_has_bits; types_.Clear(); - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5816,10 +5494,10 @@ const char* Type_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 type_variation_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -5868,12 +5546,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Struct::_InternalSerialize( InternalWriteMessage(1, this->_internal_types(i), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 type_variation_reference = 2; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -5906,11 +5582,11 @@ size_t Type_Struct::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 type_variation_reference = 2; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 3; @@ -5951,8 +5627,8 @@ void Type_Struct::MergeFrom(const Type_Struct& from) { (void) cached_has_bits; types_.MergeFrom(from.types_); - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -5984,9 +5660,9 @@ void Type_Struct::InternalSwap(Type_Struct* other) { ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Struct, nullability_) + sizeof(Type_Struct::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Struct, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(Type_Struct, type_variation_reference_)>( + reinterpret_cast(&type_variation_reference_), + reinterpret_cast(&other->type_variation_reference_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Type_Struct::GetMetadata() const { @@ -5997,262 +5673,15 @@ ::PROTOBUF_NAMESPACE_ID::Metadata Type_Struct::GetMetadata() const { // =================================================================== -class Type_NamedStruct::_Internal { - public: - static const ::io::substrait::Type_Struct& struct_(const Type_NamedStruct* msg); -}; - -const ::io::substrait::Type_Struct& -Type_NamedStruct::_Internal::struct_(const Type_NamedStruct* msg) { - return *msg->struct__; -} -Type_NamedStruct::Type_NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), - names_(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.NamedStruct) -} -Type_NamedStruct::Type_NamedStruct(const Type_NamedStruct& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - names_(from.names_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_struct_()) { - struct__ = new ::io::substrait::Type_Struct(*from.struct__); - } else { - struct__ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.NamedStruct) -} - -void Type_NamedStruct::SharedCtor() { -struct__ = nullptr; -} - -Type_NamedStruct::~Type_NamedStruct() { - // @@protoc_insertion_point(destructor:io.substrait.Type.NamedStruct) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Type_NamedStruct::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete struct__; -} - -void Type_NamedStruct::ArenaDtor(void* object) { - Type_NamedStruct* _this = reinterpret_cast< Type_NamedStruct* >(object); - (void)_this; -} -void Type_NamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_NamedStruct::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_NamedStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.NamedStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - names_.Clear(); - if (GetArena() == nullptr && struct__ != nullptr) { - delete struct__; - } - struct__ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_NamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string names = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_names(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Type.NamedStruct.names")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; - continue; - // .io.substrait.Type.Struct struct = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Type_NamedStruct::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.NamedStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string names = 1; - for (int i = 0, n = this->_internal_names_size(); i < n; i++) { - const auto& s = this->_internal_names(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Type.NamedStruct.names"); - target = stream->WriteString(1, s, target); - } - - // .io.substrait.Type.Struct struct = 2; - if (this->has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::struct_(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.NamedStruct) - return target; -} - -size_t Type_NamedStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.NamedStruct) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string names = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); - for (int i = 0, n = names_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - names_.Get(i)); - } - - // .io.substrait.Type.Struct struct = 2; - if (this->has_struct_()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *struct__); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void Type_NamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.NamedStruct) - GOOGLE_DCHECK_NE(&from, this); - const Type_NamedStruct* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.NamedStruct) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.NamedStruct) - MergeFrom(*source); - } -} - -void Type_NamedStruct::MergeFrom(const Type_NamedStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.NamedStruct) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - names_.MergeFrom(from.names_); - if (from.has_struct_()) { - _internal_mutable_struct_()->::io::substrait::Type_Struct::MergeFrom(from._internal_struct_()); - } -} - -void Type_NamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.NamedStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Type_NamedStruct::CopyFrom(const Type_NamedStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.NamedStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_NamedStruct::IsInitialized() const { - return true; -} - -void Type_NamedStruct::InternalSwap(Type_NamedStruct* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - names_.InternalSwap(&other->names_); - swap(struct__, other->struct__); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_NamedStruct::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[21]); -} - -// =================================================================== - class Type_List::_Internal { public: static const ::io::substrait::Type& type(const Type_List* msg); - static const ::io::substrait::Type_Variation& variation(const Type_List* msg); }; const ::io::substrait::Type& Type_List::_Internal::type(const Type_List* msg) { return *msg->type_; } -const ::io::substrait::Type_Variation& -Type_List::_Internal::variation(const Type_List* msg) { - return *msg->variation_; -} Type_List::Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -6267,12 +5696,9 @@ Type_List::Type_List(const Type_List& from) } else { type_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.List) } @@ -6292,7 +5718,6 @@ Type_List::~Type_List() { void Type_List::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete type_; - if (this != internal_default_instance()) delete variation_; } void Type_List::ArenaDtor(void* object) { @@ -6315,11 +5740,9 @@ void Type_List::Clear() { delete type_; } type_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -6336,10 +5759,10 @@ const char* Type_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 type_variation_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -6388,12 +5811,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_List::_InternalSerialize( 1, _Internal::type(this), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 type_variation_reference = 2; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -6426,11 +5847,11 @@ size_t Type_List::ByteSizeLong() const { *type_); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 type_variation_reference = 2; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 3; @@ -6473,8 +5894,8 @@ void Type_List::MergeFrom(const Type_List& from) { if (from.has_type()) { _internal_mutable_type()->::io::substrait::Type::MergeFrom(from._internal_type()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -6513,7 +5934,7 @@ void Type_List::InternalSwap(Type_List* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_List::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[22]); + file_level_metadata_type_2eproto[21]); } // =================================================================== @@ -6522,7 +5943,6 @@ class Type_Map::_Internal { public: static const ::io::substrait::Type& key(const Type_Map* msg); static const ::io::substrait::Type& value(const Type_Map* msg); - static const ::io::substrait::Type_Variation& variation(const Type_Map* msg); }; const ::io::substrait::Type& @@ -6533,10 +5953,6 @@ const ::io::substrait::Type& Type_Map::_Internal::value(const Type_Map* msg) { return *msg->value_; } -const ::io::substrait::Type_Variation& -Type_Map::_Internal::variation(const Type_Map* msg) { - return *msg->variation_; -} Type_Map::Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -6556,12 +5972,9 @@ Type_Map::Type_Map(const Type_Map& from) } else { value_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&type_variation_reference_, &from.type_variation_reference_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Map) } @@ -6582,7 +5995,6 @@ void Type_Map::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete key_; if (this != internal_default_instance()) delete value_; - if (this != internal_default_instance()) delete variation_; } void Type_Map::ArenaDtor(void* object) { @@ -6609,11 +6021,9 @@ void Type_Map::Clear() { delete value_; } value_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&type_variation_reference_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -6637,10 +6047,10 @@ const char* Type_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 3; + // uint32 type_variation_reference = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -6697,12 +6107,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Map::_InternalSerialize( 2, _Internal::value(this), target, stream); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 type_variation_reference = 3; + if (this->type_variation_reference() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_type_variation_reference(), target); } // .io.substrait.Type.Nullability nullability = 4; @@ -6742,255 +6150,17 @@ size_t Type_Map::ByteSizeLong() const { *value_); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 type_variation_reference = 3; + if (this->type_variation_reference() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_reference()); } // .io.substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void Type_Map::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Map) - GOOGLE_DCHECK_NE(&from, this); - const Type_Map* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Map) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Map) - MergeFrom(*source); - } -} - -void Type_Map::MergeFrom(const Type_Map& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Map) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_key()) { - _internal_mutable_key()->::io::substrait::Type::MergeFrom(from._internal_key()); - } - if (from.has_value()) { - _internal_mutable_value()->::io::substrait::Type::MergeFrom(from._internal_value()); - } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); - } - if (from.nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } -} - -void Type_Map::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Map) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Type_Map::CopyFrom(const Type_Map& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Map) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_Map::IsInitialized() const { - return true; -} - -void Type_Map::InternalSwap(Type_Map* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_Map, nullability_) - + sizeof(Type_Map::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Map, key_)>( - reinterpret_cast(&key_), - reinterpret_cast(&other->key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_Map::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[23]); -} - -// =================================================================== - -class Type_Variation::_Internal { - public: -}; - -Type_Variation::Type_Variation(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Variation) -} -Type_Variation::Type_Variation(const Type_Variation& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); - } - organization_ = from.organization_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Variation) -} - -void Type_Variation::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -organization_ = 0; -} - -Type_Variation::~Type_Variation() { - // @@protoc_insertion_point(destructor:io.substrait.Type.Variation) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Type_Variation::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void Type_Variation::ArenaDtor(void* object) { - Type_Variation* _this = reinterpret_cast< Type_Variation* >(object); - (void)_this; -} -void Type_Variation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_Variation::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_Variation::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Variation) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmpty(); - organization_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_Variation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 organization = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - organization_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // string name = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Type.Variation.name")); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Type_Variation::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Variation) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 organization = 1; - if (this->organization() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_organization(), target); - } - - // string name = 2; - if (this->name().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Type.Variation.name"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_name(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Variation) - return target; -} - -size_t Type_Variation::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Variation) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // string name = 2; - if (this->name().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // int32 organization = 1; - if (this->organization() != 0) { + if (this->nullability() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_organization()); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -7002,65 +6172,75 @@ size_t Type_Variation::ByteSizeLong() const { return total_size; } -void Type_Variation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Variation) +void Type_Map::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Map) GOOGLE_DCHECK_NE(&from, this); - const Type_Variation* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + const Type_Map* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Variation) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Map) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Variation) + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Map) MergeFrom(*source); } } -void Type_Variation::MergeFrom(const Type_Variation& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Variation) +void Type_Map::MergeFrom(const Type_Map& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Map) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - if (from.name().size() > 0) { - _internal_set_name(from._internal_name()); + if (from.has_key()) { + _internal_mutable_key()->::io::substrait::Type::MergeFrom(from._internal_key()); + } + if (from.has_value()) { + _internal_mutable_value()->::io::substrait::Type::MergeFrom(from._internal_value()); } - if (from.organization() != 0) { - _internal_set_organization(from._internal_organization()); + if (from.type_variation_reference() != 0) { + _internal_set_type_variation_reference(from._internal_type_variation_reference()); + } + if (from.nullability() != 0) { + _internal_set_nullability(from._internal_nullability()); } } -void Type_Variation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Variation) +void Type_Map::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Map) if (&from == this) return; Clear(); MergeFrom(from); } -void Type_Variation::CopyFrom(const Type_Variation& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Variation) +void Type_Map::CopyFrom(const Type_Map& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Map) if (&from == this) return; Clear(); MergeFrom(from); } -bool Type_Variation::IsInitialized() const { +bool Type_Map::IsInitialized() const { return true; } -void Type_Variation::InternalSwap(Type_Variation* other) { +void Type_Map::InternalSwap(Type_Map* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - swap(organization_, other->organization_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(Type_Map, nullability_) + + sizeof(Type_Map::nullability_) + - PROTOBUF_FIELD_OFFSET(Type_Map, key_)>( + reinterpret_cast(&key_), + reinterpret_cast(&other->key_)); } -::PROTOBUF_NAMESPACE_ID::Metadata Type_Variation::GetMetadata() const { +::PROTOBUF_NAMESPACE_ID::Metadata Type_Map::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[24]); + file_level_metadata_type_2eproto[22]); } // =================================================================== @@ -7090,7 +6270,6 @@ class Type::_Internal { static const ::io::substrait::Type_Struct& struct_(const Type* msg); static const ::io::substrait::Type_List& list(const Type* msg); static const ::io::substrait::Type_Map& map(const Type* msg); - static const ::io::substrait::Extensions_TypeId& user_defined(const Type* msg); }; const ::io::substrait::Type_Boolean& @@ -7185,10 +6364,6 @@ const ::io::substrait::Type_Map& Type::_Internal::map(const Type* msg) { return *msg->kind_.map_; } -const ::io::substrait::Extensions_TypeId& -Type::_Internal::user_defined(const Type* msg) { - return *msg->kind_.user_defined_; -} void Type::set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); @@ -7534,29 +6709,6 @@ void Type::set_allocated_map(::io::substrait::Type_Map* map) { } // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.map) } -void Type::set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_kind(); - if (user_defined) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(user_defined)->GetArena(); - if (message_arena != submessage_arena) { - user_defined = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, user_defined, submessage_arena); - } - set_has_user_defined(); - kind_.user_defined_ = user_defined; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.user_defined) -} -void Type::clear_user_defined() { - if (_internal_has_user_defined()) { - if (GetArena() == nullptr) { - delete kind_.user_defined_; - } - clear_has_kind(); - } -} Type::Type(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -7660,8 +6812,8 @@ Type::Type(const Type& from) _internal_mutable_map()->::io::substrait::Type_Map::MergeFrom(from._internal_map()); break; } - case kUserDefined: { - _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + case kUserDefinedTypeReference: { + _internal_set_user_defined_type_reference(from._internal_user_defined_type_reference()); break; } case KIND_NOT_SET: { @@ -7839,10 +6991,8 @@ void Type::clear_kind() { } break; } - case kUserDefined: { - if (GetArena() == nullptr) { - delete kind_.user_defined_; - } + case kUserDefinedTypeReference: { + // No need to clear break; } case KIND_NOT_SET: { @@ -8023,10 +7173,10 @@ const char* Type::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Extensions.TypeId user_defined = 31; + // uint32 user_defined_type_reference = 31; case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) { - ptr = ctx->ParseMessage(_internal_mutable_user_defined(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 248)) { + _internal_set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; @@ -8242,12 +7392,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 29, _Internal::timestamp_tz(this), target, stream); } - // .io.substrait.Extensions.TypeId user_defined = 31; - if (_internal_has_user_defined()) { + // uint32 user_defined_type_reference = 31; + if (_internal_has_user_defined_type_reference()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 31, _Internal::user_defined(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_type_reference(), target); } // .io.substrait.Type.UUID uuid = 32; @@ -8436,11 +7584,11 @@ size_t Type::ByteSizeLong() const { *kind_.map_); break; } - // .io.substrait.Extensions.TypeId user_defined = 31; - case kUserDefined: { + // uint32 user_defined_type_reference = 31; + case kUserDefinedTypeReference: { total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.user_defined_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_user_defined_type_reference()); break; } case KIND_NOT_SET: { @@ -8571,8 +7719,8 @@ void Type::MergeFrom(const Type& from) { _internal_mutable_map()->::io::substrait::Type_Map::MergeFrom(from._internal_map()); break; } - case kUserDefined: { - _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + case kUserDefinedTypeReference: { + _internal_set_user_defined_type_reference(from._internal_user_defined_type_reference()); break; } case KIND_NOT_SET: { @@ -8609,7 +7757,249 @@ void Type::InternalSwap(Type* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[25]); + file_level_metadata_type_2eproto[23]); +} + +// =================================================================== + +class NamedStruct::_Internal { + public: + static const ::io::substrait::Type_Struct& struct_(const NamedStruct* msg); +}; + +const ::io::substrait::Type_Struct& +NamedStruct::_Internal::struct_(const NamedStruct* msg) { + return *msg->struct__; +} +NamedStruct::NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + names_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.NamedStruct) +} +NamedStruct::NamedStruct(const NamedStruct& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + names_(from.names_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_struct_()) { + struct__ = new ::io::substrait::Type_Struct(*from.struct__); + } else { + struct__ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.NamedStruct) +} + +void NamedStruct::SharedCtor() { +struct__ = nullptr; +} + +NamedStruct::~NamedStruct() { + // @@protoc_insertion_point(destructor:io.substrait.NamedStruct) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void NamedStruct::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete struct__; +} + +void NamedStruct::ArenaDtor(void* object) { + NamedStruct* _this = reinterpret_cast< NamedStruct* >(object); + (void)_this; +} +void NamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void NamedStruct::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void NamedStruct::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.NamedStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + names_.Clear(); + if (GetArena() == nullptr && struct__ != nullptr) { + delete struct__; + } + struct__ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* NamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated string names = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + auto str = _internal_add_names(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.NamedStruct.names")); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.Type.Struct struct = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* NamedStruct::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.NamedStruct) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated string names = 1; + for (int i = 0, n = this->_internal_names_size(); i < n; i++) { + const auto& s = this->_internal_names(i); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.NamedStruct.names"); + target = stream->WriteString(1, s, target); + } + + // .io.substrait.Type.Struct struct = 2; + if (this->has_struct_()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::struct_(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.NamedStruct) + return target; +} + +size_t NamedStruct::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.NamedStruct) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated string names = 1; + total_size += 1 * + ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); + for (int i = 0, n = names_.size(); i < n; i++) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + names_.Get(i)); + } + + // .io.substrait.Type.Struct struct = 2; + if (this->has_struct_()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *struct__); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void NamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.NamedStruct) + GOOGLE_DCHECK_NE(&from, this); + const NamedStruct* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.NamedStruct) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.NamedStruct) + MergeFrom(*source); + } +} + +void NamedStruct::MergeFrom(const NamedStruct& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.NamedStruct) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + names_.MergeFrom(from.names_); + if (from.has_struct_()) { + _internal_mutable_struct_()->::io::substrait::Type_Struct::MergeFrom(from._internal_struct_()); + } +} + +void NamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.NamedStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void NamedStruct::CopyFrom(const NamedStruct& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.NamedStruct) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool NamedStruct::IsInitialized() const { + return true; +} + +void NamedStruct::InternalSwap(NamedStruct* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + names_.InternalSwap(&other->names_); + swap(struct__, other->struct__); +} + +::PROTOBUF_NAMESPACE_ID::Metadata NamedStruct::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, + file_level_metadata_type_2eproto[24]); } // @@protoc_insertion_point(namespace_scope) @@ -8679,21 +8069,18 @@ template<> PROTOBUF_NOINLINE ::io::substrait::Type_Decimal* Arena::CreateMaybeMe template<> PROTOBUF_NOINLINE ::io::substrait::Type_Struct* Arena::CreateMaybeMessage< ::io::substrait::Type_Struct >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Type_Struct >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_NamedStruct* Arena::CreateMaybeMessage< ::io::substrait::Type_NamedStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_NamedStruct >(arena); -} template<> PROTOBUF_NOINLINE ::io::substrait::Type_List* Arena::CreateMaybeMessage< ::io::substrait::Type_List >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Type_List >(arena); } template<> PROTOBUF_NOINLINE ::io::substrait::Type_Map* Arena::CreateMaybeMessage< ::io::substrait::Type_Map >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Type_Map >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_Variation* Arena::CreateMaybeMessage< ::io::substrait::Type_Variation >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_Variation >(arena); -} template<> PROTOBUF_NOINLINE ::io::substrait::Type* Arena::CreateMaybeMessage< ::io::substrait::Type >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::Type >(arena); } +template<> PROTOBUF_NOINLINE ::io::substrait::NamedStruct* Arena::CreateMaybeMessage< ::io::substrait::NamedStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::NamedStruct >(arena); +} PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) diff --git a/cpp/src/generated/substrait/type.pb.h b/cpp/src/generated/substrait/type.pb.h index d751cfdbb74..660c45e7c38 100644 --- a/cpp/src/generated/substrait/type.pb.h +++ b/cpp/src/generated/substrait/type.pb.h @@ -32,7 +32,6 @@ #include // IWYU pragma: export #include #include -#include "extensions.pb.h" // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_type_2eproto @@ -48,7 +47,7 @@ struct TableStruct_type_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[26] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[25] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -57,6 +56,9 @@ struct TableStruct_type_2eproto { extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_2eproto; namespace io { namespace substrait { +class NamedStruct; +struct NamedStructDefaultTypeInternal; +extern NamedStructDefaultTypeInternal _NamedStruct_default_instance_; class Type; struct TypeDefaultTypeInternal; extern TypeDefaultTypeInternal _Type_default_instance_; @@ -108,9 +110,6 @@ extern Type_ListDefaultTypeInternal _Type_List_default_instance_; class Type_Map; struct Type_MapDefaultTypeInternal; extern Type_MapDefaultTypeInternal _Type_Map_default_instance_; -class Type_NamedStruct; -struct Type_NamedStructDefaultTypeInternal; -extern Type_NamedStructDefaultTypeInternal _Type_NamedStruct_default_instance_; class Type_String; struct Type_StringDefaultTypeInternal; extern Type_StringDefaultTypeInternal _Type_String_default_instance_; @@ -132,12 +131,10 @@ extern Type_UUIDDefaultTypeInternal _Type_UUID_default_instance_; class Type_VarChar; struct Type_VarCharDefaultTypeInternal; extern Type_VarCharDefaultTypeInternal _Type_VarChar_default_instance_; -class Type_Variation; -struct Type_VariationDefaultTypeInternal; -extern Type_VariationDefaultTypeInternal _Type_Variation_default_instance_; } // namespace substrait } // namespace io PROTOBUF_NAMESPACE_OPEN +template<> ::io::substrait::NamedStruct* Arena::CreateMaybeMessage<::io::substrait::NamedStruct>(Arena*); template<> ::io::substrait::Type* Arena::CreateMaybeMessage<::io::substrait::Type>(Arena*); template<> ::io::substrait::Type_Binary* Arena::CreateMaybeMessage<::io::substrait::Type_Binary>(Arena*); template<> ::io::substrait::Type_Boolean* Arena::CreateMaybeMessage<::io::substrait::Type_Boolean>(Arena*); @@ -155,7 +152,6 @@ template<> ::io::substrait::Type_IntervalDay* Arena::CreateMaybeMessage<::io::su template<> ::io::substrait::Type_IntervalYear* Arena::CreateMaybeMessage<::io::substrait::Type_IntervalYear>(Arena*); template<> ::io::substrait::Type_List* Arena::CreateMaybeMessage<::io::substrait::Type_List>(Arena*); template<> ::io::substrait::Type_Map* Arena::CreateMaybeMessage<::io::substrait::Type_Map>(Arena*); -template<> ::io::substrait::Type_NamedStruct* Arena::CreateMaybeMessage<::io::substrait::Type_NamedStruct>(Arena*); template<> ::io::substrait::Type_String* Arena::CreateMaybeMessage<::io::substrait::Type_String>(Arena*); template<> ::io::substrait::Type_Struct* Arena::CreateMaybeMessage<::io::substrait::Type_Struct>(Arena*); template<> ::io::substrait::Type_Time* Arena::CreateMaybeMessage<::io::substrait::Type_Time>(Arena*); @@ -163,7 +159,6 @@ template<> ::io::substrait::Type_Timestamp* Arena::CreateMaybeMessage<::io::subs template<> ::io::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage<::io::substrait::Type_TimestampTZ>(Arena*); template<> ::io::substrait::Type_UUID* Arena::CreateMaybeMessage<::io::substrait::Type_UUID>(Arena*); template<> ::io::substrait::Type_VarChar* Arena::CreateMaybeMessage<::io::substrait::Type_VarChar>(Arena*); -template<> ::io::substrait::Type_Variation* Arena::CreateMaybeMessage<::io::substrait::Type_Variation>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace io { namespace substrait { @@ -302,26 +297,17 @@ class Type_Boolean PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -339,7 +325,7 @@ class Type_Boolean PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -453,26 +439,17 @@ class Type_I8 PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -490,7 +467,7 @@ class Type_I8 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -604,26 +581,17 @@ class Type_I16 PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -641,7 +609,7 @@ class Type_I16 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -755,26 +723,17 @@ class Type_I32 PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -792,7 +751,7 @@ class Type_I32 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -906,26 +865,17 @@ class Type_I64 PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -943,7 +893,7 @@ class Type_I64 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -1057,26 +1007,17 @@ class Type_FP32 PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -1094,7 +1035,7 @@ class Type_FP32 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -1208,26 +1149,17 @@ class Type_FP64 PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -1245,7 +1177,7 @@ class Type_FP64 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -1359,26 +1291,17 @@ class Type_String PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -1396,7 +1319,7 @@ class Type_String PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -1510,26 +1433,17 @@ class Type_Binary PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -1547,7 +1461,7 @@ class Type_Binary PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -1661,26 +1575,17 @@ class Type_Timestamp PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -1698,7 +1603,7 @@ class Type_Timestamp PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -1812,26 +1717,17 @@ class Type_Date PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -1849,7 +1745,7 @@ class Type_Date PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -1963,26 +1859,17 @@ class Type_Time PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -2000,7 +1887,7 @@ class Type_Time PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -2114,26 +2001,17 @@ class Type_TimestampTZ PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -2151,7 +2029,7 @@ class Type_TimestampTZ PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -2265,26 +2143,17 @@ class Type_IntervalYear PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -2302,7 +2171,7 @@ class Type_IntervalYear PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -2416,26 +2285,17 @@ class Type_IntervalDay PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -2453,7 +2313,7 @@ class Type_IntervalDay PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -2567,26 +2427,17 @@ class Type_UUID PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 1, kNullabilityFieldNumber = 2, }; - // .io.substrait.Type.Variation variation = 1; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 type_variation_reference = 1; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 2; void clear_nullability(); @@ -2604,7 +2455,7 @@ class Type_UUID PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -2718,28 +2569,10 @@ class Type_FixedChar PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 2, kLengthFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); - // int32 length = 1; void clear_length(); ::PROTOBUF_NAMESPACE_ID::int32 length() const; @@ -2749,6 +2582,15 @@ class Type_FixedChar PROTOBUF_FINAL : void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value); public: + // uint32 type_variation_reference = 2; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); ::io::substrait::Type_Nullability nullability() const; @@ -2765,8 +2607,8 @@ class Type_FixedChar PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; ::PROTOBUF_NAMESPACE_ID::int32 length_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -2880,28 +2722,10 @@ class Type_VarChar PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 2, kLengthFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); - // int32 length = 1; void clear_length(); ::PROTOBUF_NAMESPACE_ID::int32 length() const; @@ -2911,6 +2735,15 @@ class Type_VarChar PROTOBUF_FINAL : void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value); public: + // uint32 type_variation_reference = 2; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); ::io::substrait::Type_Nullability nullability() const; @@ -2927,8 +2760,8 @@ class Type_VarChar PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; ::PROTOBUF_NAMESPACE_ID::int32 length_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -3042,28 +2875,10 @@ class Type_FixedBinary PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 2, kLengthFieldNumber = 1, + kTypeVariationReferenceFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); - // int32 length = 1; void clear_length(); ::PROTOBUF_NAMESPACE_ID::int32 length() const; @@ -3073,6 +2888,15 @@ class Type_FixedBinary PROTOBUF_FINAL : void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value); public: + // uint32 type_variation_reference = 2; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); ::io::substrait::Type_Nullability nullability() const; @@ -3089,8 +2913,8 @@ class Type_FixedBinary PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; ::PROTOBUF_NAMESPACE_ID::int32 length_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -3204,29 +3028,11 @@ class Type_Decimal PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kVariationFieldNumber = 3, kScaleFieldNumber = 1, kPrecisionFieldNumber = 2, + kTypeVariationReferenceFieldNumber = 3, kNullabilityFieldNumber = 4, }; - // .io.substrait.Type.Variation variation = 3; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); - // int32 scale = 1; void clear_scale(); ::PROTOBUF_NAMESPACE_ID::int32 scale() const; @@ -3245,6 +3051,15 @@ class Type_Decimal PROTOBUF_FINAL : void _internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); public: + // uint32 type_variation_reference = 3; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + // .io.substrait.Type.Nullability nullability = 4; void clear_nullability(); ::io::substrait::Type_Nullability nullability() const; @@ -3261,9 +3076,9 @@ class Type_Decimal PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type_Variation* variation_; ::PROTOBUF_NAMESPACE_ID::int32 scale_; ::PROTOBUF_NAMESPACE_ID::int32 precision_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -3378,7 +3193,7 @@ class Type_Struct PROTOBUF_FINAL : enum : int { kTypesFieldNumber = 1, - kVariationFieldNumber = 2, + kTypeVariationReferenceFieldNumber = 2, kNullabilityFieldNumber = 3, }; // repeated .io.substrait.Type types = 1; @@ -3399,23 +3214,14 @@ class Type_Struct PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type >& types() const; - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; + // uint32 type_variation_reference = 2; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -3434,179 +3240,13 @@ class Type_Struct PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type > types_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; }; // ------------------------------------------------------------------- -class Type_NamedStruct PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.NamedStruct) */ { - public: - inline Type_NamedStruct() : Type_NamedStruct(nullptr) {} - ~Type_NamedStruct() override; - explicit constexpr Type_NamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_NamedStruct(const Type_NamedStruct& from); - Type_NamedStruct(Type_NamedStruct&& from) noexcept - : Type_NamedStruct() { - *this = ::std::move(from); - } - - inline Type_NamedStruct& operator=(const Type_NamedStruct& from) { - CopyFrom(from); - return *this; - } - inline Type_NamedStruct& operator=(Type_NamedStruct&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 Type_NamedStruct& default_instance() { - return *internal_default_instance(); - } - static inline const Type_NamedStruct* internal_default_instance() { - return reinterpret_cast( - &_Type_NamedStruct_default_instance_); - } - static constexpr int kIndexInFileMessages = - 21; - - friend void swap(Type_NamedStruct& a, Type_NamedStruct& b) { - a.Swap(&b); - } - inline void Swap(Type_NamedStruct* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Type_NamedStruct* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline Type_NamedStruct* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_NamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Type_NamedStruct& from); - void MergeFrom(const Type_NamedStruct& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_NamedStruct* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.NamedStruct"; - } - protected: - explicit Type_NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNamesFieldNumber = 1, - kStructFieldNumber = 2, - }; - // repeated string names = 1; - int names_size() const; - private: - int _internal_names_size() const; - public: - void clear_names(); - const std::string& names(int index) const; - std::string* mutable_names(int index); - void set_names(int index, const std::string& value); - void set_names(int index, std::string&& value); - void set_names(int index, const char* value); - void set_names(int index, const char* value, size_t size); - std::string* add_names(); - void add_names(const std::string& value); - void add_names(std::string&& value); - void add_names(const char* value); - void add_names(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); - private: - const std::string& _internal_names(int index) const; - std::string* _internal_add_names(); - public: - - // .io.substrait.Type.Struct struct = 2; - bool has_struct_() const; - private: - bool _internal_has_struct_() const; - public: - void clear_struct_(); - const ::io::substrait::Type_Struct& struct_() const; - ::io::substrait::Type_Struct* release_struct_(); - ::io::substrait::Type_Struct* mutable_struct_(); - void set_allocated_struct_(::io::substrait::Type_Struct* struct_); - private: - const ::io::substrait::Type_Struct& _internal_struct_() const; - ::io::substrait::Type_Struct* _internal_mutable_struct_(); - public: - void unsafe_arena_set_allocated_struct_( - ::io::substrait::Type_Struct* struct_); - ::io::substrait::Type_Struct* unsafe_arena_release_struct_(); - - // @@protoc_insertion_point(class_scope:io.substrait.Type.NamedStruct) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::io::substrait::Type_Struct* struct__; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; -}; -// ------------------------------------------------------------------- - class Type_List PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.List) */ { public: @@ -3650,7 +3290,7 @@ class Type_List PROTOBUF_FINAL : &_Type_List_default_instance_); } static constexpr int kIndexInFileMessages = - 22; + 21; friend void swap(Type_List& a, Type_List& b) { a.Swap(&b); @@ -3715,7 +3355,7 @@ class Type_List PROTOBUF_FINAL : enum : int { kTypeFieldNumber = 1, - kVariationFieldNumber = 2, + kTypeVariationReferenceFieldNumber = 2, kNullabilityFieldNumber = 3, }; // .io.substrait.Type type = 1; @@ -3736,23 +3376,14 @@ class Type_List PROTOBUF_FINAL : ::io::substrait::Type* type); ::io::substrait::Type* unsafe_arena_release_type(); - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 type_variation_reference = 2; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -3771,7 +3402,7 @@ class Type_List PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::Type* type_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; @@ -3821,7 +3452,7 @@ class Type_Map PROTOBUF_FINAL : &_Type_Map_default_instance_); } static constexpr int kIndexInFileMessages = - 23; + 22; friend void swap(Type_Map& a, Type_Map& b) { a.Swap(&b); @@ -3887,7 +3518,7 @@ class Type_Map PROTOBUF_FINAL : enum : int { kKeyFieldNumber = 1, kValueFieldNumber = 2, - kVariationFieldNumber = 3, + kTypeVariationReferenceFieldNumber = 3, kNullabilityFieldNumber = 4, }; // .io.substrait.Type key = 1; @@ -3926,23 +3557,14 @@ class Type_Map PROTOBUF_FINAL : ::io::substrait::Type* value); ::io::substrait::Type* unsafe_arena_release_value(); - // .io.substrait.Type.Variation variation = 3; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 type_variation_reference = 3; + void clear_type_variation_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; + void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 4; void clear_nullability(); @@ -3962,31 +3584,31 @@ class Type_Map PROTOBUF_FINAL : typedef void DestructorSkippable_; ::io::substrait::Type* key_; ::io::substrait::Type* value_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_2eproto; }; // ------------------------------------------------------------------- -class Type_Variation PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Variation) */ { +class Type PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type) */ { public: - inline Type_Variation() : Type_Variation(nullptr) {} - ~Type_Variation() override; - explicit constexpr Type_Variation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + inline Type() : Type(nullptr) {} + ~Type() override; + explicit constexpr Type(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - Type_Variation(const Type_Variation& from); - Type_Variation(Type_Variation&& from) noexcept - : Type_Variation() { + Type(const Type& from); + Type(Type&& from) noexcept + : Type() { *this = ::std::move(from); } - inline Type_Variation& operator=(const Type_Variation& from) { + inline Type& operator=(const Type& from) { CopyFrom(from); return *this; } - inline Type_Variation& operator=(Type_Variation&& from) noexcept { + inline Type& operator=(Type&& from) noexcept { if (GetArena() == from.GetArena()) { if (this != &from) InternalSwap(&from); } else { @@ -4004,190 +3626,43 @@ class Type_Variation PROTOBUF_FINAL : static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } - static const Type_Variation& default_instance() { + static const Type& default_instance() { return *internal_default_instance(); } - static inline const Type_Variation* internal_default_instance() { - return reinterpret_cast( - &_Type_Variation_default_instance_); + enum KindCase { + kBool = 1, + kI8 = 2, + kI16 = 3, + kI32 = 5, + kI64 = 7, + kFp32 = 10, + kFp64 = 11, + kString = 12, + kBinary = 13, + kTimestamp = 14, + kDate = 16, + kTime = 17, + kIntervalYear = 19, + kIntervalDay = 20, + kTimestampTz = 29, + kUuid = 32, + kFixedChar = 21, + kVarchar = 22, + kFixedBinary = 23, + kDecimal = 24, + kStruct = 25, + kList = 27, + kMap = 28, + kUserDefinedTypeReference = 31, + KIND_NOT_SET = 0, + }; + + static inline const Type* internal_default_instance() { + return reinterpret_cast( + &_Type_default_instance_); } static constexpr int kIndexInFileMessages = - 24; - - friend void swap(Type_Variation& a, Type_Variation& b) { - a.Swap(&b); - } - inline void Swap(Type_Variation* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Type_Variation* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline Type_Variation* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_Variation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Type_Variation& from); - void MergeFrom(const Type_Variation& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_Variation* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.Variation"; - } - protected: - explicit Type_Variation(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 2, - kOrganizationFieldNumber = 1, - }; - // string name = 2; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // int32 organization = 1; - void clear_organization(); - ::PROTOBUF_NAMESPACE_ID::int32 organization() const; - void set_organization(::PROTOBUF_NAMESPACE_ID::int32 value); - private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_organization() const; - void _internal_set_organization(::PROTOBUF_NAMESPACE_ID::int32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.Type.Variation) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::int32 organization_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; -}; -// ------------------------------------------------------------------- - -class Type PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type) */ { - public: - inline Type() : Type(nullptr) {} - ~Type() override; - explicit constexpr Type(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type(const Type& from); - Type(Type&& from) noexcept - : Type() { - *this = ::std::move(from); - } - - inline Type& operator=(const Type& from) { - CopyFrom(from); - return *this; - } - inline Type& operator=(Type&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 Type& default_instance() { - return *internal_default_instance(); - } - enum KindCase { - kBool = 1, - kI8 = 2, - kI16 = 3, - kI32 = 5, - kI64 = 7, - kFp32 = 10, - kFp64 = 11, - kString = 12, - kBinary = 13, - kTimestamp = 14, - kDate = 16, - kTime = 17, - kIntervalYear = 19, - kIntervalDay = 20, - kTimestampTz = 29, - kUuid = 32, - kFixedChar = 21, - kVarchar = 22, - kFixedBinary = 23, - kDecimal = 24, - kStruct = 25, - kList = 27, - kMap = 28, - kUserDefined = 31, - KIND_NOT_SET = 0, - }; - - static inline const Type* internal_default_instance() { - return reinterpret_cast( - &_Type_default_instance_); - } - static constexpr int kIndexInFileMessages = - 25; + 23; friend void swap(Type& a, Type& b) { a.Swap(&b); @@ -4269,10 +3744,8 @@ class Type PROTOBUF_FINAL : typedef Type_FixedBinary FixedBinary; typedef Type_Decimal Decimal; typedef Type_Struct Struct; - typedef Type_NamedStruct NamedStruct; typedef Type_List List; typedef Type_Map Map; - typedef Type_Variation Variation; typedef Type_Nullability Nullability; static constexpr Nullability NULLABLE = @@ -4330,7 +3803,7 @@ class Type PROTOBUF_FINAL : kStructFieldNumber = 25, kListFieldNumber = 27, kMapFieldNumber = 28, - kUserDefinedFieldNumber = 31, + kUserDefinedTypeReferenceFieldNumber = 31, }; // .io.substrait.Type.Boolean bool = 1; bool has_bool_() const; @@ -4746,23 +4219,18 @@ class Type PROTOBUF_FINAL : ::io::substrait::Type_Map* map); ::io::substrait::Type_Map* unsafe_arena_release_map(); - // .io.substrait.Extensions.TypeId user_defined = 31; - bool has_user_defined() const; + // uint32 user_defined_type_reference = 31; + bool has_user_defined_type_reference() const; private: - bool _internal_has_user_defined() const; + bool _internal_has_user_defined_type_reference() const; public: - void clear_user_defined(); - const ::io::substrait::Extensions_TypeId& user_defined() const; - ::io::substrait::Extensions_TypeId* release_user_defined(); - ::io::substrait::Extensions_TypeId* mutable_user_defined(); - void set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined); + void clear_user_defined_type_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_type_reference() const; + void set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Extensions_TypeId& _internal_user_defined() const; - ::io::substrait::Extensions_TypeId* _internal_mutable_user_defined(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_user_defined_type_reference() const; + void _internal_set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_user_defined( - ::io::substrait::Extensions_TypeId* user_defined); - ::io::substrait::Extensions_TypeId* unsafe_arena_release_user_defined(); void clear_kind(); KindCase kind_case() const; @@ -4792,7 +4260,7 @@ class Type PROTOBUF_FINAL : void set_has_struct_(); void set_has_list(); void set_has_map(); - void set_has_user_defined(); + void set_has_user_defined_type_reference(); inline bool has_kind() const; inline void clear_has_kind(); @@ -4826,212 +4294,252 @@ class Type PROTOBUF_FINAL : ::io::substrait::Type_Struct* struct__; ::io::substrait::Type_List* list_; ::io::substrait::Type_Map* map_; - ::io::substrait::Extensions_TypeId* user_defined_; + ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_type_reference_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; friend struct ::TableStruct_type_2eproto; }; -// =================================================================== +// ------------------------------------------------------------------- +class NamedStruct PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.NamedStruct) */ { + public: + inline NamedStruct() : NamedStruct(nullptr) {} + ~NamedStruct() override; + explicit constexpr NamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); -// =================================================================== + NamedStruct(const NamedStruct& from); + NamedStruct(NamedStruct&& from) noexcept + : NamedStruct() { + *this = ::std::move(from); + } -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// Type_Boolean + inline NamedStruct& operator=(const NamedStruct& from) { + CopyFrom(from); + return *this; + } + inline NamedStruct& operator=(NamedStruct&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } -// .io.substrait.Type.Variation variation = 1; -inline bool Type_Boolean::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_Boolean::has_variation() const { - return _internal_has_variation(); -} -inline void Type_Boolean::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_Boolean::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_Boolean::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Boolean.variation) - return _internal_variation(); -} -inline void Type_Boolean::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; } - variation_ = variation; - if (variation) { - - } else { - + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Boolean.variation) -} -inline ::io::substrait::Type_Variation* Type_Boolean::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + static const NamedStruct& default_instance() { + return *internal_default_instance(); } - return temp; -} -inline ::io::substrait::Type_Variation* Type_Boolean::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Boolean.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* Type_Boolean::_internal_mutable_variation() { - - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; + static inline const NamedStruct* internal_default_instance() { + return reinterpret_cast( + &_NamedStruct_default_instance_); } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_Boolean::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Boolean.variation) - return _internal_mutable_variation(); -} -inline void Type_Boolean::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; + static constexpr int kIndexInFileMessages = + 24; + + friend void swap(NamedStruct& a, NamedStruct& b) { + a.Swap(&b); } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); + inline void Swap(NamedStruct* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } - - } else { - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Boolean.variation) -} - -// .io.substrait.Type.Nullability nullability = 2; -inline void Type_Boolean::clear_nullability() { - nullability_ = 0; -} -inline ::io::substrait::Type_Nullability Type_Boolean::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); -} -inline ::io::substrait::Type_Nullability Type_Boolean::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Boolean.nullability) - return _internal_nullability(); -} -inline void Type_Boolean::_internal_set_nullability(::io::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_Boolean::set_nullability(::io::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Boolean.nullability) -} + void UnsafeArenaSwap(NamedStruct* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } -// ------------------------------------------------------------------- + // implements Message ---------------------------------------------- -// Type_I8 + inline NamedStruct* New() const final { + return CreateMaybeMessage(nullptr); + } -// .io.substrait.Type.Variation variation = 1; -inline bool Type_I8::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_I8::has_variation() const { - return _internal_has_variation(); -} -inline void Type_I8::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; + NamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_I8::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_I8::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I8.variation) - return _internal_variation(); -} -inline void Type_I8::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const NamedStruct& from); + void MergeFrom(const NamedStruct& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(NamedStruct* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.NamedStruct"; } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.I8.variation) + protected: + explicit NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNamesFieldNumber = 1, + kStructFieldNumber = 2, + }; + // repeated string names = 1; + int names_size() const; + private: + int _internal_names_size() const; + public: + void clear_names(); + const std::string& names(int index) const; + std::string* mutable_names(int index); + void set_names(int index, const std::string& value); + void set_names(int index, std::string&& value); + void set_names(int index, const char* value); + void set_names(int index, const char* value, size_t size); + std::string* add_names(); + void add_names(const std::string& value); + void add_names(std::string&& value); + void add_names(const char* value); + void add_names(const char* value, size_t size); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); + private: + const std::string& _internal_names(int index) const; + std::string* _internal_add_names(); + public: + + // .io.substrait.Type.Struct struct = 2; + bool has_struct_() const; + private: + bool _internal_has_struct_() const; + public: + void clear_struct_(); + const ::io::substrait::Type_Struct& struct_() const; + ::io::substrait::Type_Struct* release_struct_(); + ::io::substrait::Type_Struct* mutable_struct_(); + void set_allocated_struct_(::io::substrait::Type_Struct* struct_); + private: + const ::io::substrait::Type_Struct& _internal_struct_() const; + ::io::substrait::Type_Struct* _internal_mutable_struct_(); + public: + void unsafe_arena_set_allocated_struct_( + ::io::substrait::Type_Struct* struct_); + ::io::substrait::Type_Struct* unsafe_arena_release_struct_(); + + // @@protoc_insertion_point(class_scope:io.substrait.NamedStruct) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; + ::io::substrait::Type_Struct* struct__; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// Type_Boolean + +// uint32 type_variation_reference = 1; +inline void Type_Boolean::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_I8::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Boolean::_internal_type_variation_reference() const { + return type_variation_reference_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Boolean::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Boolean.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_I8::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.I8.variation) +inline void Type_Boolean::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; + type_variation_reference_ = value; +} +inline void Type_Boolean::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Boolean.type_variation_reference) +} + +// .io.substrait.Type.Nullability nullability = 2; +inline void Type_Boolean::clear_nullability() { + nullability_ = 0; +} +inline ::io::substrait::Type_Nullability Type_Boolean::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Variation* Type_I8::_internal_mutable_variation() { +inline ::io::substrait::Type_Nullability Type_Boolean::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Boolean.nullability) + return _internal_nullability(); +} +inline void Type_Boolean::_internal_set_nullability(::io::substrait::Type_Nullability value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + nullability_ = value; } -inline ::io::substrait::Type_Variation* Type_I8::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.I8.variation) - return _internal_mutable_variation(); +inline void Type_Boolean::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Boolean.nullability) } -inline void Type_I8::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.I8.variation) + +// ------------------------------------------------------------------- + +// Type_I8 + +// uint32 type_variation_reference = 1; +inline void Type_I8::clear_type_variation_reference() { + type_variation_reference_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I8::_internal_type_variation_reference() const { + return type_variation_reference_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I8::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I8.type_variation_reference) + return _internal_type_variation_reference(); +} +inline void Type_I8::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + type_variation_reference_ = value; +} +inline void Type_I8::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.I8.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -5058,87 +4566,24 @@ inline void Type_I8::set_nullability(::io::substrait::Type_Nullability value) { // Type_I16 -// .io.substrait.Type.Variation variation = 1; -inline bool Type_I16::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_I16::has_variation() const { - return _internal_has_variation(); -} -inline void Type_I16::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_I16::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_I16::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I16.variation) - return _internal_variation(); -} -inline void Type_I16::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.I16.variation) +// uint32 type_variation_reference = 1; +inline void Type_I16::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_I16::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I16::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_I16::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.I16.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I16::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I16.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_I16::_internal_mutable_variation() { +inline void Type_I16::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + type_variation_reference_ = value; } -inline ::io::substrait::Type_Variation* Type_I16::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.I16.variation) - return _internal_mutable_variation(); -} -inline void Type_I16::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.I16.variation) +inline void Type_I16::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.I16.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -5165,87 +4610,24 @@ inline void Type_I16::set_nullability(::io::substrait::Type_Nullability value) { // Type_I32 -// .io.substrait.Type.Variation variation = 1; -inline bool Type_I32::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_I32::has_variation() const { - return _internal_has_variation(); -} -inline void Type_I32::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_I32::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_I32::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I32.variation) - return _internal_variation(); -} -inline void Type_I32::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.I32.variation) +// uint32 type_variation_reference = 1; +inline void Type_I32::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_I32::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I32::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_I32::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.I32.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I32::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I32.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_I32::_internal_mutable_variation() { +inline void Type_I32::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_I32::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.I32.variation) - return _internal_mutable_variation(); + type_variation_reference_ = value; } -inline void Type_I32::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.I32.variation) +inline void Type_I32::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.I32.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -5272,87 +4654,24 @@ inline void Type_I32::set_nullability(::io::substrait::Type_Nullability value) { // Type_I64 -// .io.substrait.Type.Variation variation = 1; -inline bool Type_I64::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_I64::has_variation() const { - return _internal_has_variation(); -} -inline void Type_I64::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_I64::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_I64::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I64.variation) - return _internal_variation(); -} -inline void Type_I64::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.I64.variation) +// uint32 type_variation_reference = 1; +inline void Type_I64::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_I64::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I64::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_I64::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.I64.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I64::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.I64.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_I64::_internal_mutable_variation() { +inline void Type_I64::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_I64::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.I64.variation) - return _internal_mutable_variation(); + type_variation_reference_ = value; } -inline void Type_I64::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.I64.variation) +inline void Type_I64::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.I64.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -5379,87 +4698,24 @@ inline void Type_I64::set_nullability(::io::substrait::Type_Nullability value) { // Type_FP32 -// .io.substrait.Type.Variation variation = 1; -inline bool Type_FP32::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_FP32::has_variation() const { - return _internal_has_variation(); -} -inline void Type_FP32::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_FP32::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +// uint32 type_variation_reference = 1; +inline void Type_FP32::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline const ::io::substrait::Type_Variation& Type_FP32::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FP32.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP32::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline void Type_FP32::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.FP32.variation) +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP32::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FP32.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_FP32::release_variation() { +inline void Type_FP32::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; + type_variation_reference_ = value; } -inline ::io::substrait::Type_Variation* Type_FP32::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.FP32.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* Type_FP32::_internal_mutable_variation() { - - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_FP32::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.FP32.variation) - return _internal_mutable_variation(); -} -inline void Type_FP32::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.FP32.variation) +inline void Type_FP32::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.FP32.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -5486,87 +4742,24 @@ inline void Type_FP32::set_nullability(::io::substrait::Type_Nullability value) // Type_FP64 -// .io.substrait.Type.Variation variation = 1; -inline bool Type_FP64::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_FP64::has_variation() const { - return _internal_has_variation(); -} -inline void Type_FP64::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_FP64::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_FP64::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FP64.variation) - return _internal_variation(); -} -inline void Type_FP64::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.FP64.variation) +// uint32 type_variation_reference = 1; +inline void Type_FP64::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_FP64::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP64::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_FP64::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.FP64.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP64::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FP64.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_FP64::_internal_mutable_variation() { +inline void Type_FP64::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + type_variation_reference_ = value; } -inline ::io::substrait::Type_Variation* Type_FP64::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.FP64.variation) - return _internal_mutable_variation(); -} -inline void Type_FP64::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.FP64.variation) +inline void Type_FP64::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.FP64.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -5593,87 +4786,24 @@ inline void Type_FP64::set_nullability(::io::substrait::Type_Nullability value) // Type_String -// .io.substrait.Type.Variation variation = 1; -inline bool Type_String::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_String::has_variation() const { - return _internal_has_variation(); -} -inline void Type_String::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_String::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_String::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.String.variation) - return _internal_variation(); +// uint32 type_variation_reference = 1; +inline void Type_String::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline void Type_String::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.String.variation) +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_String::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_String::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type_Variation* Type_String::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.String.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* Type_String::_internal_mutable_variation() { - - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_String::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.String.variation) - return _internal_mutable_variation(); -} -inline void Type_String::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.String.variation) +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_String::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.String.type_variation_reference) + return _internal_type_variation_reference(); +} +inline void Type_String::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + type_variation_reference_ = value; +} +inline void Type_String::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.String.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -5700,87 +4830,24 @@ inline void Type_String::set_nullability(::io::substrait::Type_Nullability value // Type_Binary -// .io.substrait.Type.Variation variation = 1; -inline bool Type_Binary::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_Binary::has_variation() const { - return _internal_has_variation(); -} -inline void Type_Binary::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_Binary::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_Binary::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Binary.variation) - return _internal_variation(); +// uint32 type_variation_reference = 1; +inline void Type_Binary::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline void Type_Binary::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Binary.variation) -} -inline ::io::substrait::Type_Variation* Type_Binary::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Binary::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_Binary::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Binary.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Binary::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Binary.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_Binary::_internal_mutable_variation() { +inline void Type_Binary::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_Binary::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Binary.variation) - return _internal_mutable_variation(); + type_variation_reference_ = value; } -inline void Type_Binary::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Binary.variation) +inline void Type_Binary::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Binary.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -5807,87 +4874,24 @@ inline void Type_Binary::set_nullability(::io::substrait::Type_Nullability value // Type_Timestamp -// .io.substrait.Type.Variation variation = 1; -inline bool Type_Timestamp::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_Timestamp::has_variation() const { - return _internal_has_variation(); -} -inline void Type_Timestamp::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_Timestamp::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_Timestamp::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Timestamp.variation) - return _internal_variation(); -} -inline void Type_Timestamp::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Timestamp.variation) +// uint32 type_variation_reference = 1; +inline void Type_Timestamp::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_Timestamp::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Timestamp::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_Timestamp::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Timestamp.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Timestamp::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Timestamp.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_Timestamp::_internal_mutable_variation() { +inline void Type_Timestamp::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + type_variation_reference_ = value; } -inline ::io::substrait::Type_Variation* Type_Timestamp::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Timestamp.variation) - return _internal_mutable_variation(); -} -inline void Type_Timestamp::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Timestamp.variation) +inline void Type_Timestamp::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Timestamp.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -5914,87 +4918,24 @@ inline void Type_Timestamp::set_nullability(::io::substrait::Type_Nullability va // Type_Date -// .io.substrait.Type.Variation variation = 1; -inline bool Type_Date::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_Date::has_variation() const { - return _internal_has_variation(); -} -inline void Type_Date::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_Date::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_Date::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Date.variation) - return _internal_variation(); -} -inline void Type_Date::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Date.variation) +// uint32 type_variation_reference = 1; +inline void Type_Date::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_Date::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Date::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_Date::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Date.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Date::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Date.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_Date::_internal_mutable_variation() { +inline void Type_Date::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_Date::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Date.variation) - return _internal_mutable_variation(); + type_variation_reference_ = value; } -inline void Type_Date::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Date.variation) +inline void Type_Date::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Date.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -6021,87 +4962,24 @@ inline void Type_Date::set_nullability(::io::substrait::Type_Nullability value) // Type_Time -// .io.substrait.Type.Variation variation = 1; -inline bool Type_Time::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; +// uint32 type_variation_reference = 1; +inline void Type_Time::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline bool Type_Time::has_variation() const { - return _internal_has_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Time::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline void Type_Time::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_Time::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_Time::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Time.variation) - return _internal_variation(); -} -inline void Type_Time::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Time.variation) -} -inline ::io::substrait::Type_Variation* Type_Time::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Time::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Time.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_Time::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Time.variation) +inline void Type_Time::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* Type_Time::_internal_mutable_variation() { - - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + type_variation_reference_ = value; } -inline ::io::substrait::Type_Variation* Type_Time::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Time.variation) - return _internal_mutable_variation(); -} -inline void Type_Time::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Time.variation) +inline void Type_Time::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Time.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -6128,87 +5006,24 @@ inline void Type_Time::set_nullability(::io::substrait::Type_Nullability value) // Type_TimestampTZ -// .io.substrait.Type.Variation variation = 1; -inline bool Type_TimestampTZ::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_TimestampTZ::has_variation() const { - return _internal_has_variation(); +// uint32 type_variation_reference = 1; +inline void Type_TimestampTZ::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline void Type_TimestampTZ::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_TimestampTZ::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_TimestampTZ::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.TimestampTZ.variation) - return _internal_variation(); -} -inline void Type_TimestampTZ::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.TimestampTZ.variation) -} -inline ::io::substrait::Type_Variation* Type_TimestampTZ::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_TimestampTZ::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_TimestampTZ::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.TimestampTZ.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_TimestampTZ::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.TimestampTZ.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_TimestampTZ::_internal_mutable_variation() { +inline void Type_TimestampTZ::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_TimestampTZ::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.TimestampTZ.variation) - return _internal_mutable_variation(); + type_variation_reference_ = value; } -inline void Type_TimestampTZ::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.TimestampTZ.variation) +inline void Type_TimestampTZ::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.TimestampTZ.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -6235,87 +5050,24 @@ inline void Type_TimestampTZ::set_nullability(::io::substrait::Type_Nullability // Type_IntervalYear -// .io.substrait.Type.Variation variation = 1; -inline bool Type_IntervalYear::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_IntervalYear::has_variation() const { - return _internal_has_variation(); -} -inline void Type_IntervalYear::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_IntervalYear::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_IntervalYear::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalYear.variation) - return _internal_variation(); -} -inline void Type_IntervalYear::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.IntervalYear.variation) +// uint32 type_variation_reference = 1; +inline void Type_IntervalYear::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_IntervalYear::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalYear::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_IntervalYear::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.IntervalYear.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalYear::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalYear.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_IntervalYear::_internal_mutable_variation() { +inline void Type_IntervalYear::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + type_variation_reference_ = value; } -inline ::io::substrait::Type_Variation* Type_IntervalYear::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.IntervalYear.variation) - return _internal_mutable_variation(); -} -inline void Type_IntervalYear::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.IntervalYear.variation) +inline void Type_IntervalYear::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.IntervalYear.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -6342,87 +5094,24 @@ inline void Type_IntervalYear::set_nullability(::io::substrait::Type_Nullability // Type_IntervalDay -// .io.substrait.Type.Variation variation = 1; -inline bool Type_IntervalDay::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_IntervalDay::has_variation() const { - return _internal_has_variation(); -} -inline void Type_IntervalDay::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; +// uint32 type_variation_reference = 1; +inline void Type_IntervalDay::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline const ::io::substrait::Type_Variation& Type_IntervalDay::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalDay::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline const ::io::substrait::Type_Variation& Type_IntervalDay::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalDay.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalDay::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalDay.type_variation_reference) + return _internal_type_variation_reference(); } -inline void Type_IntervalDay::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.IntervalDay.variation) -} -inline ::io::substrait::Type_Variation* Type_IntervalDay::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type_Variation* Type_IntervalDay::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.IntervalDay.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* Type_IntervalDay::_internal_mutable_variation() { +inline void Type_IntervalDay::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_IntervalDay::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.IntervalDay.variation) - return _internal_mutable_variation(); + type_variation_reference_ = value; } -inline void Type_IntervalDay::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.IntervalDay.variation) +inline void Type_IntervalDay::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.IntervalDay.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -6449,87 +5138,24 @@ inline void Type_IntervalDay::set_nullability(::io::substrait::Type_Nullability // Type_UUID -// .io.substrait.Type.Variation variation = 1; -inline bool Type_UUID::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_UUID::has_variation() const { - return _internal_has_variation(); -} -inline void Type_UUID::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_UUID::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_UUID::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.UUID.variation) - return _internal_variation(); -} -inline void Type_UUID::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.UUID.variation) -} -inline ::io::substrait::Type_Variation* Type_UUID::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type_Variation* Type_UUID::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.UUID.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* Type_UUID::_internal_mutable_variation() { - - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_UUID::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.UUID.variation) - return _internal_mutable_variation(); -} -inline void Type_UUID::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.UUID.variation) +// uint32 type_variation_reference = 1; +inline void Type_UUID::clear_type_variation_reference() { + type_variation_reference_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_UUID::_internal_type_variation_reference() const { + return type_variation_reference_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_UUID::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.UUID.type_variation_reference) + return _internal_type_variation_reference(); +} +inline void Type_UUID::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + type_variation_reference_ = value; +} +inline void Type_UUID::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.UUID.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 2; @@ -6576,87 +5202,24 @@ inline void Type_FixedChar::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { // @@protoc_insertion_point(field_set:io.substrait.Type.FixedChar.length) } -// .io.substrait.Type.Variation variation = 2; -inline bool Type_FixedChar::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_FixedChar::has_variation() const { - return _internal_has_variation(); -} -inline void Type_FixedChar::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_FixedChar::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_FixedChar::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FixedChar.variation) - return _internal_variation(); -} -inline void Type_FixedChar::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.FixedChar.variation) +// uint32 type_variation_reference = 2; +inline void Type_FixedChar::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_FixedChar::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedChar::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_FixedChar::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.FixedChar.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedChar::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FixedChar.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_FixedChar::_internal_mutable_variation() { +inline void Type_FixedChar::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_FixedChar::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.FixedChar.variation) - return _internal_mutable_variation(); + type_variation_reference_ = value; } -inline void Type_FixedChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.FixedChar.variation) +inline void Type_FixedChar::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.FixedChar.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 3; @@ -6703,87 +5266,24 @@ inline void Type_VarChar::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { // @@protoc_insertion_point(field_set:io.substrait.Type.VarChar.length) } -// .io.substrait.Type.Variation variation = 2; -inline bool Type_VarChar::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_VarChar::has_variation() const { - return _internal_has_variation(); -} -inline void Type_VarChar::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_VarChar::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_VarChar::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.VarChar.variation) - return _internal_variation(); -} -inline void Type_VarChar::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.VarChar.variation) +// uint32 type_variation_reference = 2; +inline void Type_VarChar::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_VarChar::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_VarChar::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_VarChar::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.VarChar.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_VarChar::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.VarChar.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_VarChar::_internal_mutable_variation() { +inline void Type_VarChar::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + type_variation_reference_ = value; } -inline ::io::substrait::Type_Variation* Type_VarChar::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.VarChar.variation) - return _internal_mutable_variation(); -} -inline void Type_VarChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.VarChar.variation) +inline void Type_VarChar::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.VarChar.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 3; @@ -6830,87 +5330,24 @@ inline void Type_FixedBinary::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { // @@protoc_insertion_point(field_set:io.substrait.Type.FixedBinary.length) } -// .io.substrait.Type.Variation variation = 2; -inline bool Type_FixedBinary::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_FixedBinary::has_variation() const { - return _internal_has_variation(); -} -inline void Type_FixedBinary::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_FixedBinary::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_FixedBinary::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FixedBinary.variation) - return _internal_variation(); +// uint32 type_variation_reference = 2; +inline void Type_FixedBinary::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline void Type_FixedBinary::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.FixedBinary.variation) -} -inline ::io::substrait::Type_Variation* Type_FixedBinary::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedBinary::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_FixedBinary::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.FixedBinary.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedBinary::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.FixedBinary.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_FixedBinary::_internal_mutable_variation() { +inline void Type_FixedBinary::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_FixedBinary::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.FixedBinary.variation) - return _internal_mutable_variation(); + type_variation_reference_ = value; } -inline void Type_FixedBinary::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.FixedBinary.variation) +inline void Type_FixedBinary::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.FixedBinary.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 3; @@ -6977,87 +5414,24 @@ inline void Type_Decimal::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { // @@protoc_insertion_point(field_set:io.substrait.Type.Decimal.precision) } -// .io.substrait.Type.Variation variation = 3; -inline bool Type_Decimal::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_Decimal::has_variation() const { - return _internal_has_variation(); -} -inline void Type_Decimal::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_Decimal::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_Decimal::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Decimal.variation) - return _internal_variation(); -} -inline void Type_Decimal::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Decimal.variation) +// uint32 type_variation_reference = 3; +inline void Type_Decimal::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_Decimal::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Decimal::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_Decimal::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Decimal.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Decimal::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Decimal.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_Decimal::_internal_mutable_variation() { +inline void Type_Decimal::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + type_variation_reference_ = value; } -inline ::io::substrait::Type_Variation* Type_Decimal::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Decimal.variation) - return _internal_mutable_variation(); -} -inline void Type_Decimal::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Decimal.variation) +inline void Type_Decimal::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Decimal.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 4; @@ -7123,268 +5497,44 @@ Type_Struct::types() const { return types_; } -// .io.substrait.Type.Variation variation = 2; -inline bool Type_Struct::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_Struct::has_variation() const { - return _internal_has_variation(); -} -inline void Type_Struct::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_Struct::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_Struct::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Struct.variation) - return _internal_variation(); -} -inline void Type_Struct::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Struct.variation) +// uint32 type_variation_reference = 2; +inline void Type_Struct::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_Struct::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Struct::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_Struct::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Struct.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Struct::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Struct.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_Struct::_internal_mutable_variation() { +inline void Type_Struct::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_Struct::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Struct.variation) - return _internal_mutable_variation(); + type_variation_reference_ = value; } -inline void Type_Struct::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Struct.variation) +inline void Type_Struct::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Struct.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 3; inline void Type_Struct::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_Struct::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); -} -inline ::io::substrait::Type_Nullability Type_Struct::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Struct.nullability) - return _internal_nullability(); -} -inline void Type_Struct::_internal_set_nullability(::io::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_Struct::set_nullability(::io::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Struct.nullability) -} - -// ------------------------------------------------------------------- - -// Type_NamedStruct - -// repeated string names = 1; -inline int Type_NamedStruct::_internal_names_size() const { - return names_.size(); -} -inline int Type_NamedStruct::names_size() const { - return _internal_names_size(); -} -inline void Type_NamedStruct::clear_names() { - names_.Clear(); -} -inline std::string* Type_NamedStruct::add_names() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Type.NamedStruct.names) - return _internal_add_names(); -} -inline const std::string& Type_NamedStruct::_internal_names(int index) const { - return names_.Get(index); -} -inline const std::string& Type_NamedStruct::names(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Type.NamedStruct.names) - return _internal_names(index); -} -inline std::string* Type_NamedStruct::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.NamedStruct.names) - return names_.Mutable(index); -} -inline void Type_NamedStruct::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Type.NamedStruct.names) - names_.Mutable(index)->assign(value); -} -inline void Type_NamedStruct::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Type.NamedStruct.names) - names_.Mutable(index)->assign(std::move(value)); -} -inline void Type_NamedStruct::set_names(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Type.NamedStruct.names) -} -inline void Type_NamedStruct::set_names(int index, const char* value, size_t size) { - names_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Type.NamedStruct.names) -} -inline std::string* Type_NamedStruct::_internal_add_names() { - return names_.Add(); -} -inline void Type_NamedStruct::add_names(const std::string& value) { - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Type.NamedStruct.names) -} -inline void Type_NamedStruct::add_names(std::string&& value) { - names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Type.NamedStruct.names) -} -inline void Type_NamedStruct::add_names(const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Type.NamedStruct.names) -} -inline void Type_NamedStruct::add_names(const char* value, size_t size) { - names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Type.NamedStruct.names) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Type_NamedStruct::names() const { - // @@protoc_insertion_point(field_list:io.substrait.Type.NamedStruct.names) - return names_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Type_NamedStruct::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Type.NamedStruct.names) - return &names_; -} - -// .io.substrait.Type.Struct struct = 2; -inline bool Type_NamedStruct::_internal_has_struct_() const { - return this != internal_default_instance() && struct__ != nullptr; -} -inline bool Type_NamedStruct::has_struct_() const { - return _internal_has_struct_(); -} -inline void Type_NamedStruct::clear_struct_() { - if (GetArena() == nullptr && struct__ != nullptr) { - delete struct__; - } - struct__ = nullptr; -} -inline const ::io::substrait::Type_Struct& Type_NamedStruct::_internal_struct_() const { - const ::io::substrait::Type_Struct* p = struct__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Struct_default_instance_); -} -inline const ::io::substrait::Type_Struct& Type_NamedStruct::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.NamedStruct.struct) - return _internal_struct_(); -} -inline void Type_NamedStruct::unsafe_arena_set_allocated_struct_( - ::io::substrait::Type_Struct* struct_) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); - } - struct__ = struct_; - if (struct_) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.NamedStruct.struct) -} -inline ::io::substrait::Type_Struct* Type_NamedStruct::release_struct_() { - - ::io::substrait::Type_Struct* temp = struct__; - struct__ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::io::substrait::Type_Nullability Type_Struct::_internal_nullability() const { + return static_cast< ::io::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Struct* Type_NamedStruct::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.Type.NamedStruct.struct) - - ::io::substrait::Type_Struct* temp = struct__; - struct__ = nullptr; - return temp; +inline ::io::substrait::Type_Nullability Type_Struct::nullability() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Struct.nullability) + return _internal_nullability(); } -inline ::io::substrait::Type_Struct* Type_NamedStruct::_internal_mutable_struct_() { +inline void Type_Struct::_internal_set_nullability(::io::substrait::Type_Nullability value) { - if (struct__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Struct>(GetArena()); - struct__ = p; - } - return struct__; -} -inline ::io::substrait::Type_Struct* Type_NamedStruct::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.NamedStruct.struct) - return _internal_mutable_struct_(); + nullability_ = value; } -inline void Type_NamedStruct::set_allocated_struct_(::io::substrait::Type_Struct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete struct__; - } - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - - } else { - - } - struct__ = struct_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.NamedStruct.struct) +inline void Type_Struct::set_nullability(::io::substrait::Type_Nullability value) { + _internal_set_nullability(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Struct.nullability) } // ------------------------------------------------------------------- @@ -7474,87 +5624,24 @@ inline void Type_List::set_allocated_type(::io::substrait::Type* type) { // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.List.type) } -// .io.substrait.Type.Variation variation = 2; -inline bool Type_List::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_List::has_variation() const { - return _internal_has_variation(); -} -inline void Type_List::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_List::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_List::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.List.variation) - return _internal_variation(); -} -inline void Type_List::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.List.variation) +// uint32 type_variation_reference = 2; +inline void Type_List::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_List::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_List::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_List::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.List.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_List::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.List.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_List::_internal_mutable_variation() { +inline void Type_List::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* Type_List::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.List.variation) - return _internal_mutable_variation(); + type_variation_reference_ = value; } -inline void Type_List::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.List.variation) +inline void Type_List::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.List.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 3; @@ -7747,87 +5834,24 @@ inline void Type_Map::set_allocated_value(::io::substrait::Type* value) { // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Map.value) } -// .io.substrait.Type.Variation variation = 3; -inline bool Type_Map::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool Type_Map::has_variation() const { - return _internal_has_variation(); -} -inline void Type_Map::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} -inline const ::io::substrait::Type_Variation& Type_Map::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& Type_Map::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Map.variation) - return _internal_variation(); -} -inline void Type_Map::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Map.variation) +// uint32 type_variation_reference = 3; +inline void Type_Map::clear_type_variation_reference() { + type_variation_reference_ = 0u; } -inline ::io::substrait::Type_Variation* Type_Map::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Map::_internal_type_variation_reference() const { + return type_variation_reference_; } -inline ::io::substrait::Type_Variation* Type_Map::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Map.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Map::type_variation_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.Map.type_variation_reference) + return _internal_type_variation_reference(); } -inline ::io::substrait::Type_Variation* Type_Map::_internal_mutable_variation() { +inline void Type_Map::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + type_variation_reference_ = value; } -inline ::io::substrait::Type_Variation* Type_Map::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Map.variation) - return _internal_mutable_variation(); -} -inline void Type_Map::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete variation_; - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variation); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Map.variation) +inline void Type_Map::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.Map.type_variation_reference) } // .io.substrait.Type.Nullability nullability = 4; @@ -7852,75 +5876,6 @@ inline void Type_Map::set_nullability(::io::substrait::Type_Nullability value) { // ------------------------------------------------------------------- -// Type_Variation - -// int32 organization = 1; -inline void Type_Variation::clear_organization() { - organization_ = 0; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Variation::_internal_organization() const { - return organization_; -} -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Variation::organization() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Variation.organization) - return _internal_organization(); -} -inline void Type_Variation::_internal_set_organization(::PROTOBUF_NAMESPACE_ID::int32 value) { - - organization_ = value; -} -inline void Type_Variation::set_organization(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_set_organization(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Variation.organization) -} - -// string name = 2; -inline void Type_Variation::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& Type_Variation::name() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Variation.name) - return _internal_name(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void Type_Variation::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Type.Variation.name) -} -inline std::string* Type_Variation::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Variation.name) - return _internal_mutable_name(); -} -inline const std::string& Type_Variation::_internal_name() const { - return name_.Get(); -} -inline void Type_Variation::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* Type_Variation::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* Type_Variation::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Variation.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void Type_Variation::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Variation.name) -} - -// ------------------------------------------------------------------- - // Type // .io.substrait.Type.Boolean bool = 1; @@ -9602,69 +7557,42 @@ inline ::io::substrait::Type_Map* Type::mutable_map() { return _internal_mutable_map(); } -// .io.substrait.Extensions.TypeId user_defined = 31; -inline bool Type::_internal_has_user_defined() const { - return kind_case() == kUserDefined; -} -inline bool Type::has_user_defined() const { - return _internal_has_user_defined(); -} -inline void Type::set_has_user_defined() { - _oneof_case_[0] = kUserDefined; -} -inline ::io::substrait::Extensions_TypeId* Type::release_user_defined() { - // @@protoc_insertion_point(field_release:io.substrait.Type.user_defined) - if (_internal_has_user_defined()) { - clear_has_kind(); - ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.user_defined_ = nullptr; - return temp; - } else { - return nullptr; - } +// uint32 user_defined_type_reference = 31; +inline bool Type::_internal_has_user_defined_type_reference() const { + return kind_case() == kUserDefinedTypeReference; } -inline const ::io::substrait::Extensions_TypeId& Type::_internal_user_defined() const { - return _internal_has_user_defined() - ? *kind_.user_defined_ - : reinterpret_cast< ::io::substrait::Extensions_TypeId&>(::io::substrait::_Extensions_TypeId_default_instance_); +inline bool Type::has_user_defined_type_reference() const { + return _internal_has_user_defined_type_reference(); } -inline const ::io::substrait::Extensions_TypeId& Type::user_defined() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.user_defined) - return _internal_user_defined(); +inline void Type::set_has_user_defined_type_reference() { + _oneof_case_[0] = kUserDefinedTypeReference; } -inline ::io::substrait::Extensions_TypeId* Type::unsafe_arena_release_user_defined() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.user_defined) - if (_internal_has_user_defined()) { +inline void Type::clear_user_defined_type_reference() { + if (_internal_has_user_defined_type_reference()) { + kind_.user_defined_type_reference_ = 0u; clear_has_kind(); - ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; - kind_.user_defined_ = nullptr; - return temp; - } else { - return nullptr; } } -inline void Type::unsafe_arena_set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { - clear_kind(); - if (user_defined) { - set_has_user_defined(); - kind_.user_defined_ = user_defined; +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type::_internal_user_defined_type_reference() const { + if (_internal_has_user_defined_type_reference()) { + return kind_.user_defined_type_reference_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.user_defined) + return 0u; } -inline ::io::substrait::Extensions_TypeId* Type::_internal_mutable_user_defined() { - if (!_internal_has_user_defined()) { +inline void Type::_internal_set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + if (!_internal_has_user_defined_type_reference()) { clear_kind(); - set_has_user_defined(); - kind_.user_defined_ = CreateMaybeMessage< ::io::substrait::Extensions_TypeId >(GetArena()); + set_has_user_defined_type_reference(); } - return kind_.user_defined_; + kind_.user_defined_type_reference_ = value; } -inline ::io::substrait::Extensions_TypeId* Type::mutable_user_defined() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.user_defined) - return _internal_mutable_user_defined(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 Type::user_defined_type_reference() const { + // @@protoc_insertion_point(field_get:io.substrait.Type.user_defined_type_reference) + return _internal_user_defined_type_reference(); +} +inline void Type::set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_user_defined_type_reference(value); + // @@protoc_insertion_point(field_set:io.substrait.Type.user_defined_type_reference) } inline bool Type::has_kind() const { @@ -9676,6 +7604,167 @@ inline void Type::clear_has_kind() { inline Type::KindCase Type::kind_case() const { return Type::KindCase(_oneof_case_[0]); } +// ------------------------------------------------------------------- + +// NamedStruct + +// repeated string names = 1; +inline int NamedStruct::_internal_names_size() const { + return names_.size(); +} +inline int NamedStruct::names_size() const { + return _internal_names_size(); +} +inline void NamedStruct::clear_names() { + names_.Clear(); +} +inline std::string* NamedStruct::add_names() { + // @@protoc_insertion_point(field_add_mutable:io.substrait.NamedStruct.names) + return _internal_add_names(); +} +inline const std::string& NamedStruct::_internal_names(int index) const { + return names_.Get(index); +} +inline const std::string& NamedStruct::names(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.NamedStruct.names) + return _internal_names(index); +} +inline std::string* NamedStruct::mutable_names(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.NamedStruct.names) + return names_.Mutable(index); +} +inline void NamedStruct::set_names(int index, const std::string& value) { + // @@protoc_insertion_point(field_set:io.substrait.NamedStruct.names) + names_.Mutable(index)->assign(value); +} +inline void NamedStruct::set_names(int index, std::string&& value) { + // @@protoc_insertion_point(field_set:io.substrait.NamedStruct.names) + names_.Mutable(index)->assign(std::move(value)); +} +inline void NamedStruct::set_names(int index, const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set_char:io.substrait.NamedStruct.names) +} +inline void NamedStruct::set_names(int index, const char* value, size_t size) { + names_.Mutable(index)->assign( + reinterpret_cast(value), size); + // @@protoc_insertion_point(field_set_pointer:io.substrait.NamedStruct.names) +} +inline std::string* NamedStruct::_internal_add_names() { + return names_.Add(); +} +inline void NamedStruct::add_names(const std::string& value) { + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add:io.substrait.NamedStruct.names) +} +inline void NamedStruct::add_names(std::string&& value) { + names_.Add(std::move(value)); + // @@protoc_insertion_point(field_add:io.substrait.NamedStruct.names) +} +inline void NamedStruct::add_names(const char* value) { + GOOGLE_DCHECK(value != nullptr); + names_.Add()->assign(value); + // @@protoc_insertion_point(field_add_char:io.substrait.NamedStruct.names) +} +inline void NamedStruct::add_names(const char* value, size_t size) { + names_.Add()->assign(reinterpret_cast(value), size); + // @@protoc_insertion_point(field_add_pointer:io.substrait.NamedStruct.names) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& +NamedStruct::names() const { + // @@protoc_insertion_point(field_list:io.substrait.NamedStruct.names) + return names_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* +NamedStruct::mutable_names() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.NamedStruct.names) + return &names_; +} + +// .io.substrait.Type.Struct struct = 2; +inline bool NamedStruct::_internal_has_struct_() const { + return this != internal_default_instance() && struct__ != nullptr; +} +inline bool NamedStruct::has_struct_() const { + return _internal_has_struct_(); +} +inline void NamedStruct::clear_struct_() { + if (GetArena() == nullptr && struct__ != nullptr) { + delete struct__; + } + struct__ = nullptr; +} +inline const ::io::substrait::Type_Struct& NamedStruct::_internal_struct_() const { + const ::io::substrait::Type_Struct* p = struct__; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_Type_Struct_default_instance_); +} +inline const ::io::substrait::Type_Struct& NamedStruct::struct_() const { + // @@protoc_insertion_point(field_get:io.substrait.NamedStruct.struct) + return _internal_struct_(); +} +inline void NamedStruct::unsafe_arena_set_allocated_struct_( + ::io::substrait::Type_Struct* struct_) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); + } + struct__ = struct_; + if (struct_) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.NamedStruct.struct) +} +inline ::io::substrait::Type_Struct* NamedStruct::release_struct_() { + + ::io::substrait::Type_Struct* temp = struct__; + struct__ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::Type_Struct* NamedStruct::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_release:io.substrait.NamedStruct.struct) + + ::io::substrait::Type_Struct* temp = struct__; + struct__ = nullptr; + return temp; +} +inline ::io::substrait::Type_Struct* NamedStruct::_internal_mutable_struct_() { + + if (struct__ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::Type_Struct>(GetArena()); + struct__ = p; + } + return struct__; +} +inline ::io::substrait::Type_Struct* NamedStruct::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:io.substrait.NamedStruct.struct) + return _internal_mutable_struct_(); +} +inline void NamedStruct::set_allocated_struct_(::io::substrait::Type_Struct* struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete struct__; + } + if (struct_) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + if (message_arena != submessage_arena) { + struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, struct_, submessage_arena); + } + + } else { + + } + struct__ = struct_; + // @@protoc_insertion_point(field_set_allocated:io.substrait.NamedStruct.struct) +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -9727,8 +7816,6 @@ inline Type::KindCase Type::kind_case() const { // ------------------------------------------------------------------- -// ------------------------------------------------------------------- - // @@protoc_insertion_point(namespace_scope) diff --git a/cpp/src/generated/substrait/type_expressions.pb.cc b/cpp/src/generated/substrait/type_expressions.pb.cc index 295a00ef1e9..31f8bb35418 100644 --- a/cpp/src/generated/substrait/type_expressions.pb.cc +++ b/cpp/src/generated/substrait/type_expressions.pb.cc @@ -21,7 +21,7 @@ namespace substrait { constexpr DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : length_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct DerivationExpression_ExpressionFixedCharDefaultTypeInternal { @@ -36,7 +36,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_Expression constexpr DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : length_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct DerivationExpression_ExpressionVarCharDefaultTypeInternal { @@ -51,7 +51,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_Expression constexpr DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : length_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal { @@ -67,7 +67,7 @@ constexpr DerivationExpression_ExpressionDecimal::DerivationExpression_Expressio ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : scale_(nullptr) , precision_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct DerivationExpression_ExpressionDecimalDefaultTypeInternal { @@ -82,7 +82,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_Expression constexpr DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : types_() - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct DerivationExpression_ExpressionStructDefaultTypeInternal { @@ -110,7 +110,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_Expression constexpr DerivationExpression_ExpressionList::DerivationExpression_ExpressionList( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : type_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct DerivationExpression_ExpressionListDefaultTypeInternal { @@ -126,7 +126,7 @@ constexpr DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : key_(nullptr) , value_(nullptr) - , variation_(nullptr) + , variation_pointer_(0u) , nullability_(0) {} struct DerivationExpression_ExpressionMapDefaultTypeInternal { @@ -181,6 +181,32 @@ struct DerivationExpression_BinaryOpDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_BinaryOpDefaultTypeInternal _DerivationExpression_BinaryOp_default_instance_; +constexpr DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , expression_(nullptr){} +struct DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal { + constexpr DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal() {} + union { + DerivationExpression_ReturnProgram_Assignment _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal _DerivationExpression_ReturnProgram_Assignment_default_instance_; +constexpr DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : assignments_() + , finalexpression_(nullptr){} +struct DerivationExpression_ReturnProgramDefaultTypeInternal { + constexpr DerivationExpression_ReturnProgramDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~DerivationExpression_ReturnProgramDefaultTypeInternal() {} + union { + DerivationExpression_ReturnProgram _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ReturnProgramDefaultTypeInternal _DerivationExpression_ReturnProgram_default_instance_; constexpr DerivationExpression::DerivationExpression( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : _oneof_case_{}{} @@ -195,7 +221,7 @@ struct DerivationExpressionDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpressionDefaultTypeInternal _DerivationExpression_default_instance_; } // namespace substrait } // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_type_5fexpressions_2eproto[12]; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_type_5fexpressions_2eproto[14]; static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_type_5fexpressions_2eproto[2]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_type_5fexpressions_2eproto = nullptr; @@ -206,7 +232,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::of ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, _internal_metadata_), @@ -214,7 +240,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::of ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, _internal_metadata_), @@ -222,7 +248,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::of ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, _internal_metadata_), @@ -231,7 +257,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::of ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, scale_), PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, precision_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, _internal_metadata_), @@ -239,7 +265,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::of ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, types_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionNamedStruct, _internal_metadata_), @@ -254,7 +280,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::of ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, _internal_metadata_), @@ -263,7 +289,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::of ~0u, // no _weak_field_map_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, key_), PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, value_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, variation_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, variation_pointer_), PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, nullability_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_IfElse, _internal_metadata_), @@ -289,6 +315,20 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::of PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_BinaryOp, arg1_), PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_BinaryOp, arg2_), ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram_Assignment, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram_Assignment, name_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram_Assignment, expression_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram, assignments_), + PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram, finalexpression_), + ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression, _oneof_case_[0]), @@ -323,6 +363,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::of ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression, kind_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { @@ -337,7 +378,9 @@ static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOB { 65, -1, sizeof(::io::substrait::DerivationExpression_IfElse)}, { 73, -1, sizeof(::io::substrait::DerivationExpression_UnaryOp)}, { 80, -1, sizeof(::io::substrait::DerivationExpression_BinaryOp)}, - { 88, -1, sizeof(::io::substrait::DerivationExpression)}, + { 88, -1, sizeof(::io::substrait::DerivationExpression_ReturnProgram_Assignment)}, + { 95, -1, sizeof(::io::substrait::DerivationExpression_ReturnProgram)}, + { 102, -1, sizeof(::io::substrait::DerivationExpression)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -352,115 +395,120 @@ static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = reinterpret_cast(&::io::substrait::_DerivationExpression_IfElse_default_instance_), reinterpret_cast(&::io::substrait::_DerivationExpression_UnaryOp_default_instance_), reinterpret_cast(&::io::substrait::_DerivationExpression_BinaryOp_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_ReturnProgram_Assignment_default_instance_), + reinterpret_cast(&::io::substrait::_DerivationExpression_ReturnProgram_default_instance_), reinterpret_cast(&::io::substrait::_DerivationExpression_default_instance_), }; const char descriptor_table_protodef_type_5fexpressions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\026type_expressions.proto\022\014io.substrait\032\n" - "type.proto\032\020extensions.proto\"\217\035\n\024Derivat" - "ionExpression\022*\n\004bool\030\001 \001(\0132\032.io.substra" - "it.Type.BooleanH\000\022#\n\002i8\030\002 \001(\0132\025.io.subst" - "rait.Type.I8H\000\022%\n\003i16\030\003 \001(\0132\026.io.substra" - "it.Type.I16H\000\022%\n\003i32\030\005 \001(\0132\026.io.substrai" - "t.Type.I32H\000\022%\n\003i64\030\007 \001(\0132\026.io.substrait" - ".Type.I64H\000\022\'\n\004fp32\030\n \001(\0132\027.io.substrait" - ".Type.FP32H\000\022\'\n\004fp64\030\013 \001(\0132\027.io.substrai" - "t.Type.FP64H\000\022+\n\006string\030\014 \001(\0132\031.io.subst" - "rait.Type.StringH\000\022+\n\006binary\030\r \001(\0132\031.io." - "substrait.Type.BinaryH\000\0221\n\ttimestamp\030\016 \001" - "(\0132\034.io.substrait.Type.TimestampH\000\022\'\n\004da" - "te\030\020 \001(\0132\027.io.substrait.Type.DateH\000\022\'\n\004t" - "ime\030\021 \001(\0132\027.io.substrait.Type.TimeH\000\0228\n\r" - "interval_year\030\023 \001(\0132\037.io.substrait.Type." - "IntervalYearH\000\0226\n\014interval_day\030\024 \001(\0132\036.i" - "o.substrait.Type.IntervalDayH\000\0226\n\014timest" - "amp_tz\030\035 \001(\0132\036.io.substrait.Type.Timesta" - "mpTZH\000\022\'\n\004uuid\030 \001(\0132\027.io.substrait.Type" - ".UUIDH\000\022L\n\nfixed_char\030\025 \001(\01326.io.substra" - "it.DerivationExpression.ExpressionFixedC" - "harH\000\022G\n\007varchar\030\026 \001(\01324.io.substrait.De" - "rivationExpression.ExpressionVarCharH\000\022P" - "\n\014fixed_binary\030\027 \001(\01328.io.substrait.Deri" - "vationExpression.ExpressionFixedBinaryH\000" - "\022G\n\007decimal\030\030 \001(\01324.io.substrait.Derivat" - "ionExpression.ExpressionDecimalH\000\022E\n\006str" - "uct\030\031 \001(\01323.io.substrait.DerivationExpre" - "ssion.ExpressionStructH\000\022A\n\004list\030\033 \001(\01321" - ".io.substrait.DerivationExpression.Expre" - "ssionListH\000\022\?\n\003map\030\034 \001(\01320.io.substrait." - "DerivationExpression.ExpressionMapH\000\0227\n\014" - "user_defined\030\037 \001(\0132\037.io.substrait.Extens" - "ions.TypeIdH\000\022\035\n\023type_parameter_name\030! \001" - "(\tH\000\022 \n\026integer_parameter_name\030\" \001(\tH\000\022\031" - "\n\017integer_literal\030# \001(\005H\000\022>\n\010unary_op\030$ " - "\001(\0132*.io.substrait.DerivationExpression." - "UnaryOpH\000\022@\n\tbinary_op\030% \001(\0132+.io.substr" - "ait.DerivationExpression.BinaryOpH\000\022<\n\007i" - "f_else\030& \001(\0132).io.substrait.DerivationEx" - "pression.IfElseH\000\032\257\001\n\023ExpressionFixedCha" - "r\0222\n\006length\030\001 \001(\0132\".io.substrait.Derivat" - "ionExpression\022/\n\tvariation\030\002 \001(\0132\034.io.su" - "bstrait.Type.Variation\0223\n\013nullability\030\003 " - "\001(\0162\036.io.substrait.Type.Nullability\032\255\001\n\021" - "ExpressionVarChar\0222\n\006length\030\001 \001(\0132\".io.s" - "ubstrait.DerivationExpression\022/\n\tvariati" - "on\030\002 \001(\0132\034.io.substrait.Type.Variation\0223" - "\n\013nullability\030\003 \001(\0162\036.io.substrait.Type." - "Nullability\032\261\001\n\025ExpressionFixedBinary\0222\n" - "\006length\030\001 \001(\0132\".io.substrait.DerivationE" - "xpression\022/\n\tvariation\030\002 \001(\0132\034.io.substr" - "ait.Type.Variation\0223\n\013nullability\030\003 \001(\0162" - "\036.io.substrait.Type.Nullability\032\343\001\n\021Expr" - "essionDecimal\0221\n\005scale\030\001 \001(\0132\".io.substr" - "ait.DerivationExpression\0225\n\tprecision\030\002 " - "\001(\0132\".io.substrait.DerivationExpression\022" - "/\n\tvariation\030\003 \001(\0132\034.io.substrait.Type.V" - "ariation\0223\n\013nullability\030\004 \001(\0162\036.io.subst" - "rait.Type.Nullability\032\253\001\n\020ExpressionStru" - "ct\0221\n\005types\030\001 \003(\0132\".io.substrait.Derivat" - "ionExpression\022/\n\tvariation\030\002 \001(\0132\034.io.su" - "bstrait.Type.Variation\0223\n\013nullability\030\003 " - "\001(\0162\036.io.substrait.Type.Nullability\032k\n\025E" - "xpressionNamedStruct\022\r\n\005names\030\001 \003(\t\022C\n\006s" - "truct\030\002 \001(\01323.io.substrait.DerivationExp" - "ression.ExpressionStruct\032\250\001\n\016ExpressionL" - "ist\0220\n\004type\030\001 \001(\0132\".io.substrait.Derivat" - "ionExpression\022/\n\tvariation\030\002 \001(\0132\034.io.su" - "bstrait.Type.Variation\0223\n\013nullability\030\003 " - "\001(\0162\036.io.substrait.Type.Nullability\032\331\001\n\r" - "ExpressionMap\022/\n\003key\030\001 \001(\0132\".io.substrai" - "t.DerivationExpression\0221\n\005value\030\002 \001(\0132\"." - "io.substrait.DerivationExpression\022/\n\tvar" - "iation\030\003 \001(\0132\034.io.substrait.Type.Variati" - "on\0223\n\013nullability\030\004 \001(\0162\036.io.substrait.T" - "ype.Nullability\032\262\001\n\006IfElse\0228\n\014if_conditi" - "on\030\001 \001(\0132\".io.substrait.DerivationExpres" - "sion\0225\n\tif_return\030\002 \001(\0132\".io.substrait.D" - "erivationExpression\0227\n\013else_return\030\003 \001(\013" - "2\".io.substrait.DerivationExpression\032\246\001\n" - "\007UnaryOp\022B\n\007op_type\030\001 \001(\01621.io.substrait" - ".DerivationExpression.UnaryOp.OpType\022/\n\003" - "arg\030\002 \001(\0132\".io.substrait.DerivationExpre" - "ssion\"&\n\006OpType\022\013\n\007UNKNOWN\020\000\022\017\n\013BOOLEAN_" - "NOT\020\001\032\326\002\n\010BinaryOp\022C\n\007op_type\030\001 \001(\01622.io" - ".substrait.DerivationExpression.BinaryOp" - ".OpType\0220\n\004arg1\030\002 \001(\0132\".io.substrait.Der" - "ivationExpression\0220\n\004arg2\030\003 \001(\0132\".io.sub" - "strait.DerivationExpression\"\240\001\n\006OpType\022\013" - "\n\007UNKNOWN\020\000\022\010\n\004PLUS\020\001\022\t\n\005MINUS\020\002\022\014\n\010MULT" - "IPLY\020\003\022\n\n\006DIVIDE\020\004\022\007\n\003MIN\020\005\022\007\n\003MAX\020\006\022\020\n\014" - "GREATER_THAN\020\007\022\r\n\tLESS_THAN\020\010\022\007\n\003AND\020\t\022\006" - "\n\002OR\020\n\022\n\n\006EQUALS\020\013\022\n\n\006COVERS\020\014B\006\n\004kindB\027" - "P\001\252\002\022Substrait.Protobufb\006proto3" + "type.proto\"\235\036\n\024DerivationExpression\022*\n\004b" + "ool\030\001 \001(\0132\032.io.substrait.Type.BooleanH\000\022" + "#\n\002i8\030\002 \001(\0132\025.io.substrait.Type.I8H\000\022%\n\003" + "i16\030\003 \001(\0132\026.io.substrait.Type.I16H\000\022%\n\003i" + "32\030\005 \001(\0132\026.io.substrait.Type.I32H\000\022%\n\003i6" + "4\030\007 \001(\0132\026.io.substrait.Type.I64H\000\022\'\n\004fp3" + "2\030\n \001(\0132\027.io.substrait.Type.FP32H\000\022\'\n\004fp" + "64\030\013 \001(\0132\027.io.substrait.Type.FP64H\000\022+\n\006s" + "tring\030\014 \001(\0132\031.io.substrait.Type.StringH\000" + "\022+\n\006binary\030\r \001(\0132\031.io.substrait.Type.Bin" + "aryH\000\0221\n\ttimestamp\030\016 \001(\0132\034.io.substrait." + "Type.TimestampH\000\022\'\n\004date\030\020 \001(\0132\027.io.subs" + "trait.Type.DateH\000\022\'\n\004time\030\021 \001(\0132\027.io.sub" + "strait.Type.TimeH\000\0228\n\rinterval_year\030\023 \001(" + "\0132\037.io.substrait.Type.IntervalYearH\000\0226\n\014" + "interval_day\030\024 \001(\0132\036.io.substrait.Type.I" + "ntervalDayH\000\0226\n\014timestamp_tz\030\035 \001(\0132\036.io." + "substrait.Type.TimestampTZH\000\022\'\n\004uuid\030 \001" + "(\0132\027.io.substrait.Type.UUIDH\000\022L\n\nfixed_c" + "har\030\025 \001(\01326.io.substrait.DerivationExpre" + "ssion.ExpressionFixedCharH\000\022G\n\007varchar\030\026" + " \001(\01324.io.substrait.DerivationExpression" + ".ExpressionVarCharH\000\022P\n\014fixed_binary\030\027 \001" + "(\01328.io.substrait.DerivationExpression.E" + "xpressionFixedBinaryH\000\022G\n\007decimal\030\030 \001(\0132" + "4.io.substrait.DerivationExpression.Expr" + "essionDecimalH\000\022E\n\006struct\030\031 \001(\01323.io.sub" + "strait.DerivationExpression.ExpressionSt" + "ructH\000\022A\n\004list\030\033 \001(\01321.io.substrait.Deri" + "vationExpression.ExpressionListH\000\022\?\n\003map" + "\030\034 \001(\01320.io.substrait.DerivationExpressi" + "on.ExpressionMapH\000\022\036\n\024user_defined_point" + "er\030\037 \001(\rH\000\022\035\n\023type_parameter_name\030! \001(\tH" + "\000\022 \n\026integer_parameter_name\030\" \001(\tH\000\022\031\n\017i" + "nteger_literal\030# \001(\005H\000\022>\n\010unary_op\030$ \001(\013" + "2*.io.substrait.DerivationExpression.Una" + "ryOpH\000\022@\n\tbinary_op\030% \001(\0132+.io.substrait" + ".DerivationExpression.BinaryOpH\000\022<\n\007if_e" + "lse\030& \001(\0132).io.substrait.DerivationExpre" + "ssion.IfElseH\000\022J\n\016return_program\030\' \001(\01320" + ".io.substrait.DerivationExpression.Retur" + "nProgramH\000\032\231\001\n\023ExpressionFixedChar\0222\n\006le" + "ngth\030\001 \001(\0132\".io.substrait.DerivationExpr" + "ession\022\031\n\021variation_pointer\030\002 \001(\r\0223\n\013nul" + "lability\030\003 \001(\0162\036.io.substrait.Type.Nulla" + "bility\032\227\001\n\021ExpressionVarChar\0222\n\006length\030\001" + " \001(\0132\".io.substrait.DerivationExpression" + "\022\031\n\021variation_pointer\030\002 \001(\r\0223\n\013nullabili" + "ty\030\003 \001(\0162\036.io.substrait.Type.Nullability" + "\032\233\001\n\025ExpressionFixedBinary\0222\n\006length\030\001 \001" + "(\0132\".io.substrait.DerivationExpression\022\031" + "\n\021variation_pointer\030\002 \001(\r\0223\n\013nullability" + "\030\003 \001(\0162\036.io.substrait.Type.Nullability\032\315" + "\001\n\021ExpressionDecimal\0221\n\005scale\030\001 \001(\0132\".io" + ".substrait.DerivationExpression\0225\n\tpreci" + "sion\030\002 \001(\0132\".io.substrait.DerivationExpr" + "ession\022\031\n\021variation_pointer\030\003 \001(\r\0223\n\013nul" + "lability\030\004 \001(\0162\036.io.substrait.Type.Nulla" + "bility\032\225\001\n\020ExpressionStruct\0221\n\005types\030\001 \003" + "(\0132\".io.substrait.DerivationExpression\022\031" + "\n\021variation_pointer\030\002 \001(\r\0223\n\013nullability" + "\030\003 \001(\0162\036.io.substrait.Type.Nullability\032k" + "\n\025ExpressionNamedStruct\022\r\n\005names\030\001 \003(\t\022C" + "\n\006struct\030\002 \001(\01323.io.substrait.Derivation" + "Expression.ExpressionStruct\032\222\001\n\016Expressi" + "onList\0220\n\004type\030\001 \001(\0132\".io.substrait.Deri" + "vationExpression\022\031\n\021variation_pointer\030\002 " + "\001(\r\0223\n\013nullability\030\003 \001(\0162\036.io.substrait." + "Type.Nullability\032\303\001\n\rExpressionMap\022/\n\003ke" + "y\030\001 \001(\0132\".io.substrait.DerivationExpress" + "ion\0221\n\005value\030\002 \001(\0132\".io.substrait.Deriva" + "tionExpression\022\031\n\021variation_pointer\030\003 \001(" + "\r\0223\n\013nullability\030\004 \001(\0162\036.io.substrait.Ty" + "pe.Nullability\032\262\001\n\006IfElse\0228\n\014if_conditio" + "n\030\001 \001(\0132\".io.substrait.DerivationExpress" + "ion\0225\n\tif_return\030\002 \001(\0132\".io.substrait.De" + "rivationExpression\0227\n\013else_return\030\003 \001(\0132" + "\".io.substrait.DerivationExpression\032\246\001\n\007" + "UnaryOp\022B\n\007op_type\030\001 \001(\01621.io.substrait." + "DerivationExpression.UnaryOp.OpType\022/\n\003a" + "rg\030\002 \001(\0132\".io.substrait.DerivationExpres" + "sion\"&\n\006OpType\022\013\n\007UNKNOWN\020\000\022\017\n\013BOOLEAN_N" + "OT\020\001\032\326\002\n\010BinaryOp\022C\n\007op_type\030\001 \001(\01622.io." + "substrait.DerivationExpression.BinaryOp." + "OpType\0220\n\004arg1\030\002 \001(\0132\".io.substrait.Deri" + "vationExpression\0220\n\004arg2\030\003 \001(\0132\".io.subs" + "trait.DerivationExpression\"\240\001\n\006OpType\022\013\n" + "\007UNKNOWN\020\000\022\010\n\004PLUS\020\001\022\t\n\005MINUS\020\002\022\014\n\010MULTI" + "PLY\020\003\022\n\n\006DIVIDE\020\004\022\007\n\003MIN\020\005\022\007\n\003MAX\020\006\022\020\n\014G" + "REATER_THAN\020\007\022\r\n\tLESS_THAN\020\010\022\007\n\003AND\020\t\022\006\n" + "\002OR\020\n\022\n\n\006EQUALS\020\013\022\n\n\006COVERS\020\014\032\362\001\n\rReturn" + "Program\022P\n\013assignments\030\001 \003(\0132;.io.substr" + "ait.DerivationExpression.ReturnProgram.A" + "ssignment\022;\n\017finalExpression\030\002 \001(\0132\".io." + "substrait.DerivationExpression\032R\n\nAssign" + "ment\022\014\n\004name\030\001 \001(\t\0226\n\nexpression\030\002 \001(\0132\"" + ".io.substrait.DerivationExpressionB\006\n\004ki" + "ndB+\n\022io.substrait.protoP\001\252\002\022Substrait.P" + "rotobufb\006proto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_type_5fexpressions_2eproto_deps[2] = { - &::descriptor_table_extensions_2eproto, +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_type_5fexpressions_2eproto_deps[1] = { &::descriptor_table_type_2eproto, }; static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_type_5fexpressions_2eproto_once; const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_5fexpressions_2eproto = { - false, false, 3831, descriptor_table_protodef_type_5fexpressions_2eproto, "type_expressions.proto", - &descriptor_table_type_5fexpressions_2eproto_once, descriptor_table_type_5fexpressions_2eproto_deps, 2, 12, + false, false, 3975, descriptor_table_protodef_type_5fexpressions_2eproto, "type_expressions.proto", + &descriptor_table_type_5fexpressions_2eproto_once, descriptor_table_type_5fexpressions_2eproto_deps, 1, 14, schemas, file_default_instances, TableStruct_type_5fexpressions_2eproto::offsets, file_level_metadata_type_5fexpressions_2eproto, file_level_enum_descriptors_type_5fexpressions_2eproto, file_level_service_descriptors_type_5fexpressions_2eproto, }; @@ -542,23 +590,12 @@ constexpr int DerivationExpression_BinaryOp::OpType_ARRAYSIZE; class DerivationExpression_ExpressionFixedChar::_Internal { public: static const ::io::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedChar* msg); - static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionFixedChar* msg); }; const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::_Internal::length(const DerivationExpression_ExpressionFixedChar* msg) { return *msg->length_; } -const ::io::substrait::Type_Variation& -DerivationExpression_ExpressionFixedChar::_Internal::variation(const DerivationExpression_ExpressionFixedChar* msg) { - return *msg->variation_; -} -void DerivationExpression_ExpressionFixedChar::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -573,12 +610,9 @@ DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedCh } else { length_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionFixedChar) } @@ -598,7 +632,6 @@ DerivationExpression_ExpressionFixedChar::~DerivationExpression_ExpressionFixedC void DerivationExpression_ExpressionFixedChar::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete length_; - if (this != internal_default_instance()) delete variation_; } void DerivationExpression_ExpressionFixedChar::ArenaDtor(void* object) { @@ -621,11 +654,9 @@ void DerivationExpression_ExpressionFixedChar::Clear() { delete length_; } length_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -642,10 +673,10 @@ const char* DerivationExpression_ExpressionFixedChar::_InternalParse(const char* CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -694,12 +725,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedChar::_Inter 1, _Internal::length(this), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -732,11 +761,11 @@ size_t DerivationExpression_ExpressionFixedChar::ByteSizeLong() const { *length_); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 3; @@ -779,8 +808,8 @@ void DerivationExpression_ExpressionFixedChar::MergeFrom(const DerivationExpress if (from.has_length()) { _internal_mutable_length()->::io::substrait::DerivationExpression::MergeFrom(from._internal_length()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -827,23 +856,12 @@ ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedChar::GetM class DerivationExpression_ExpressionVarChar::_Internal { public: static const ::io::substrait::DerivationExpression& length(const DerivationExpression_ExpressionVarChar* msg); - static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionVarChar* msg); }; const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::_Internal::length(const DerivationExpression_ExpressionVarChar* msg) { return *msg->length_; } -const ::io::substrait::Type_Variation& -DerivationExpression_ExpressionVarChar::_Internal::variation(const DerivationExpression_ExpressionVarChar* msg) { - return *msg->variation_; -} -void DerivationExpression_ExpressionVarChar::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -858,12 +876,9 @@ DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(c } else { length_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionVarChar) } @@ -883,7 +898,6 @@ DerivationExpression_ExpressionVarChar::~DerivationExpression_ExpressionVarChar( void DerivationExpression_ExpressionVarChar::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete length_; - if (this != internal_default_instance()) delete variation_; } void DerivationExpression_ExpressionVarChar::ArenaDtor(void* object) { @@ -906,11 +920,9 @@ void DerivationExpression_ExpressionVarChar::Clear() { delete length_; } length_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -927,10 +939,10 @@ const char* DerivationExpression_ExpressionVarChar::_InternalParse(const char* p CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -979,12 +991,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionVarChar::_Interna 1, _Internal::length(this), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -1017,11 +1027,11 @@ size_t DerivationExpression_ExpressionVarChar::ByteSizeLong() const { *length_); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 3; @@ -1064,8 +1074,8 @@ void DerivationExpression_ExpressionVarChar::MergeFrom(const DerivationExpressio if (from.has_length()) { _internal_mutable_length()->::io::substrait::DerivationExpression::MergeFrom(from._internal_length()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1112,23 +1122,12 @@ ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionVarChar::GetMet class DerivationExpression_ExpressionFixedBinary::_Internal { public: static const ::io::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedBinary* msg); - static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionFixedBinary* msg); }; const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::_Internal::length(const DerivationExpression_ExpressionFixedBinary* msg) { return *msg->length_; } -const ::io::substrait::Type_Variation& -DerivationExpression_ExpressionFixedBinary::_Internal::variation(const DerivationExpression_ExpressionFixedBinary* msg) { - return *msg->variation_; -} -void DerivationExpression_ExpressionFixedBinary::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1143,12 +1142,9 @@ DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixed } else { length_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionFixedBinary) } @@ -1168,7 +1164,6 @@ DerivationExpression_ExpressionFixedBinary::~DerivationExpression_ExpressionFixe void DerivationExpression_ExpressionFixedBinary::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete length_; - if (this != internal_default_instance()) delete variation_; } void DerivationExpression_ExpressionFixedBinary::ArenaDtor(void* object) { @@ -1191,11 +1186,9 @@ void DerivationExpression_ExpressionFixedBinary::Clear() { delete length_; } length_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1212,10 +1205,10 @@ const char* DerivationExpression_ExpressionFixedBinary::_InternalParse(const cha CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1264,12 +1257,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedBinary::_Int 1, _Internal::length(this), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -1302,11 +1293,11 @@ size_t DerivationExpression_ExpressionFixedBinary::ByteSizeLong() const { *length_); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 3; @@ -1349,8 +1340,8 @@ void DerivationExpression_ExpressionFixedBinary::MergeFrom(const DerivationExpre if (from.has_length()) { _internal_mutable_length()->::io::substrait::DerivationExpression::MergeFrom(from._internal_length()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1398,7 +1389,6 @@ class DerivationExpression_ExpressionDecimal::_Internal { public: static const ::io::substrait::DerivationExpression& scale(const DerivationExpression_ExpressionDecimal* msg); static const ::io::substrait::DerivationExpression& precision(const DerivationExpression_ExpressionDecimal* msg); - static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionDecimal* msg); }; const ::io::substrait::DerivationExpression& @@ -1409,16 +1399,6 @@ const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_Internal::precision(const DerivationExpression_ExpressionDecimal* msg) { return *msg->precision_; } -const ::io::substrait::Type_Variation& -DerivationExpression_ExpressionDecimal::_Internal::variation(const DerivationExpression_ExpressionDecimal* msg) { - return *msg->variation_; -} -void DerivationExpression_ExpressionDecimal::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -1438,12 +1418,9 @@ DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(c } else { precision_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionDecimal) } @@ -1464,7 +1441,6 @@ void DerivationExpression_ExpressionDecimal::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete scale_; if (this != internal_default_instance()) delete precision_; - if (this != internal_default_instance()) delete variation_; } void DerivationExpression_ExpressionDecimal::ArenaDtor(void* object) { @@ -1491,11 +1467,9 @@ void DerivationExpression_ExpressionDecimal::Clear() { delete precision_; } precision_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1519,10 +1493,10 @@ const char* DerivationExpression_ExpressionDecimal::_InternalParse(const char* p CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 3; + // uint32 variation_pointer = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1579,12 +1553,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionDecimal::_Interna 2, _Internal::precision(this), target, stream); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 variation_pointer = 3; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 4; @@ -1624,11 +1596,11 @@ size_t DerivationExpression_ExpressionDecimal::ByteSizeLong() const { *precision_); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 variation_pointer = 3; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 4; @@ -1674,8 +1646,8 @@ void DerivationExpression_ExpressionDecimal::MergeFrom(const DerivationExpressio if (from.has_precision()) { _internal_mutable_precision()->::io::substrait::DerivationExpression::MergeFrom(from._internal_precision()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1721,19 +1693,8 @@ ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionDecimal::GetMet class DerivationExpression_ExpressionStruct::_Internal { public: - static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionStruct* msg); }; -const ::io::substrait::Type_Variation& -DerivationExpression_ExpressionStruct::_Internal::variation(const DerivationExpression_ExpressionStruct* msg) { - return *msg->variation_; -} -void DerivationExpression_ExpressionStruct::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), types_(arena) { @@ -1745,20 +1706,17 @@ DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(con : ::PROTOBUF_NAMESPACE_ID::Message(), types_(from.types_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionStruct) } void DerivationExpression_ExpressionStruct::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_) - reinterpret_cast(this)), + reinterpret_cast(&variation_pointer_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_)) + sizeof(nullability_)); + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); } DerivationExpression_ExpressionStruct::~DerivationExpression_ExpressionStruct() { @@ -1769,7 +1727,6 @@ DerivationExpression_ExpressionStruct::~DerivationExpression_ExpressionStruct() void DerivationExpression_ExpressionStruct::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete variation_; } void DerivationExpression_ExpressionStruct::ArenaDtor(void* object) { @@ -1789,11 +1746,9 @@ void DerivationExpression_ExpressionStruct::Clear() { (void) cached_has_bits; types_.Clear(); - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1815,10 +1770,10 @@ const char* DerivationExpression_ExpressionStruct::_InternalParse(const char* pt } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -1867,12 +1822,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionStruct::_Internal InternalWriteMessage(1, this->_internal_types(i), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -1905,11 +1858,11 @@ size_t DerivationExpression_ExpressionStruct::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 3; @@ -1950,8 +1903,8 @@ void DerivationExpression_ExpressionStruct::MergeFrom(const DerivationExpression (void) cached_has_bits; types_.MergeFrom(from.types_); - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -1983,9 +1936,9 @@ void DerivationExpression_ExpressionStruct::InternalSwap(DerivationExpression_Ex ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, nullability_) + sizeof(DerivationExpression_ExpressionStruct::nullability_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, variation_)>( - reinterpret_cast(&variation_), - reinterpret_cast(&other->variation_)); + - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, variation_pointer_)>( + reinterpret_cast(&variation_pointer_), + reinterpret_cast(&other->variation_pointer_)); } ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionStruct::GetMetadata() const { @@ -2241,23 +2194,12 @@ ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionNamedStruct::Ge class DerivationExpression_ExpressionList::_Internal { public: static const ::io::substrait::DerivationExpression& type(const DerivationExpression_ExpressionList* msg); - static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionList* msg); }; const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionList::_Internal::type(const DerivationExpression_ExpressionList* msg) { return *msg->type_; } -const ::io::substrait::Type_Variation& -DerivationExpression_ExpressionList::_Internal::variation(const DerivationExpression_ExpressionList* msg) { - return *msg->variation_; -} -void DerivationExpression_ExpressionList::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -2272,12 +2214,9 @@ DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(const D } else { type_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionList) } @@ -2297,7 +2236,6 @@ DerivationExpression_ExpressionList::~DerivationExpression_ExpressionList() { void DerivationExpression_ExpressionList::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete type_; - if (this != internal_default_instance()) delete variation_; } void DerivationExpression_ExpressionList::ArenaDtor(void* object) { @@ -2320,11 +2258,9 @@ void DerivationExpression_ExpressionList::Clear() { delete type_; } type_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2341,10 +2277,10 @@ const char* DerivationExpression_ExpressionList::_InternalParse(const char* ptr, CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 2; + // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -2393,12 +2329,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionList::_InternalSe 1, _Internal::type(this), target, stream); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 3; @@ -2431,11 +2365,11 @@ size_t DerivationExpression_ExpressionList::ByteSizeLong() const { *type_); } - // .io.substrait.Type.Variation variation = 2; - if (this->has_variation()) { + // uint32 variation_pointer = 2; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 3; @@ -2478,8 +2412,8 @@ void DerivationExpression_ExpressionList::MergeFrom(const DerivationExpression_E if (from.has_type()) { _internal_mutable_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_type()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -2527,7 +2461,6 @@ class DerivationExpression_ExpressionMap::_Internal { public: static const ::io::substrait::DerivationExpression& key(const DerivationExpression_ExpressionMap* msg); static const ::io::substrait::DerivationExpression& value(const DerivationExpression_ExpressionMap* msg); - static const ::io::substrait::Type_Variation& variation(const DerivationExpression_ExpressionMap* msg); }; const ::io::substrait::DerivationExpression& @@ -2538,16 +2471,6 @@ const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_Internal::value(const DerivationExpression_ExpressionMap* msg) { return *msg->value_; } -const ::io::substrait::Type_Variation& -DerivationExpression_ExpressionMap::_Internal::variation(const DerivationExpression_ExpressionMap* msg) { - return *msg->variation_; -} -void DerivationExpression_ExpressionMap::clear_variation() { - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; -} DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -2567,12 +2490,9 @@ DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(const Der } else { value_ = nullptr; } - if (from._internal_has_variation()) { - variation_ = new ::io::substrait::Type_Variation(*from.variation_); - } else { - variation_ = nullptr; - } - nullability_ = from.nullability_; + ::memcpy(&variation_pointer_, &from.variation_pointer_, + static_cast(reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionMap) } @@ -2593,7 +2513,6 @@ void DerivationExpression_ExpressionMap::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); if (this != internal_default_instance()) delete key_; if (this != internal_default_instance()) delete value_; - if (this != internal_default_instance()) delete variation_; } void DerivationExpression_ExpressionMap::ArenaDtor(void* object) { @@ -2620,11 +2539,9 @@ void DerivationExpression_ExpressionMap::Clear() { delete value_; } value_ = nullptr; - if (GetArena() == nullptr && variation_ != nullptr) { - delete variation_; - } - variation_ = nullptr; - nullability_ = 0; + ::memset(&variation_pointer_, 0, static_cast( + reinterpret_cast(&nullability_) - + reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2648,10 +2565,10 @@ const char* DerivationExpression_ExpressionMap::_InternalParse(const char* ptr, CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Variation variation = 3; + // uint32 variation_pointer = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_variation(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -2708,12 +2625,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionMap::_InternalSer 2, _Internal::value(this), target, stream); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 variation_pointer = 3; + if (this->variation_pointer() != 0) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::variation(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } // .io.substrait.Type.Nullability nullability = 4; @@ -2753,11 +2668,11 @@ size_t DerivationExpression_ExpressionMap::ByteSizeLong() const { *value_); } - // .io.substrait.Type.Variation variation = 3; - if (this->has_variation()) { + // uint32 variation_pointer = 3; + if (this->variation_pointer() != 0) { total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *variation_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_variation_pointer()); } // .io.substrait.Type.Nullability nullability = 4; @@ -2803,8 +2718,8 @@ void DerivationExpression_ExpressionMap::MergeFrom(const DerivationExpression_Ex if (from.has_value()) { _internal_mutable_value()->::io::substrait::DerivationExpression::MergeFrom(from._internal_value()); } - if (from.has_variation()) { - _internal_mutable_variation()->::io::substrait::Type_Variation::MergeFrom(from._internal_variation()); + if (from.variation_pointer() != 0) { + _internal_set_variation_pointer(from._internal_variation_pointer()); } if (from.nullability() != 0) { _internal_set_nullability(from._internal_nullability()); @@ -3659,6 +3574,486 @@ ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_BinaryOp::GetMetadata() c // =================================================================== +class DerivationExpression_ReturnProgram_Assignment::_Internal { + public: + static const ::io::substrait::DerivationExpression& expression(const DerivationExpression_ReturnProgram_Assignment* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_ReturnProgram_Assignment::_Internal::expression(const DerivationExpression_ReturnProgram_Assignment* msg) { + return *msg->expression_; +} +DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ReturnProgram.Assignment) +} +DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(const DerivationExpression_ReturnProgram_Assignment& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); + } + if (from._internal_has_expression()) { + expression_ = new ::io::substrait::DerivationExpression(*from.expression_); + } else { + expression_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ReturnProgram.Assignment) +} + +void DerivationExpression_ReturnProgram_Assignment::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +expression_ = nullptr; +} + +DerivationExpression_ReturnProgram_Assignment::~DerivationExpression_ReturnProgram_Assignment() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ReturnProgram.Assignment) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_ReturnProgram_Assignment::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (this != internal_default_instance()) delete expression_; +} + +void DerivationExpression_ReturnProgram_Assignment::ArenaDtor(void* object) { + DerivationExpression_ReturnProgram_Assignment* _this = reinterpret_cast< DerivationExpression_ReturnProgram_Assignment* >(object); + (void)_this; +} +void DerivationExpression_ReturnProgram_Assignment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_ReturnProgram_Assignment::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_ReturnProgram_Assignment::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmpty(); + if (GetArena() == nullptr && expression_ != nullptr) { + delete expression_; + } + expression_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_ReturnProgram_Assignment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // string name = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.DerivationExpression.ReturnProgram.Assignment.name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression expression = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram_Assignment::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // string name = 1; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "io.substrait.DerivationExpression.ReturnProgram.Assignment.name"); + target = stream->WriteStringMaybeAliased( + 1, this->_internal_name(), target); + } + + // .io.substrait.DerivationExpression expression = 2; + if (this->has_expression()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::expression(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ReturnProgram.Assignment) + return target; +} + +size_t DerivationExpression_ReturnProgram_Assignment::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 1; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // .io.substrait.DerivationExpression expression = 2; + if (this->has_expression()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *expression_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_ReturnProgram_Assignment::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_ReturnProgram_Assignment* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ReturnProgram.Assignment) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ReturnProgram.Assignment) + MergeFrom(*source); + } +} + +void DerivationExpression_ReturnProgram_Assignment::MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } + if (from.has_expression()) { + _internal_mutable_expression()->::io::substrait::DerivationExpression::MergeFrom(from._internal_expression()); + } +} + +void DerivationExpression_ReturnProgram_Assignment::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_ReturnProgram_Assignment::CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_ReturnProgram_Assignment::IsInitialized() const { + return true; +} + +void DerivationExpression_ReturnProgram_Assignment::InternalSwap(DerivationExpression_ReturnProgram_Assignment* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(expression_, other->expression_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ReturnProgram_Assignment::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[11]); +} + +// =================================================================== + +class DerivationExpression_ReturnProgram::_Internal { + public: + static const ::io::substrait::DerivationExpression& finalexpression(const DerivationExpression_ReturnProgram* msg); +}; + +const ::io::substrait::DerivationExpression& +DerivationExpression_ReturnProgram::_Internal::finalexpression(const DerivationExpression_ReturnProgram* msg) { + return *msg->finalexpression_; +} +DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena), + assignments_(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ReturnProgram) +} +DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(const DerivationExpression_ReturnProgram& from) + : ::PROTOBUF_NAMESPACE_ID::Message(), + assignments_(from.assignments_) { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_finalexpression()) { + finalexpression_ = new ::io::substrait::DerivationExpression(*from.finalexpression_); + } else { + finalexpression_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ReturnProgram) +} + +void DerivationExpression_ReturnProgram::SharedCtor() { +finalexpression_ = nullptr; +} + +DerivationExpression_ReturnProgram::~DerivationExpression_ReturnProgram() { + // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ReturnProgram) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void DerivationExpression_ReturnProgram::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete finalexpression_; +} + +void DerivationExpression_ReturnProgram::ArenaDtor(void* object) { + DerivationExpression_ReturnProgram* _this = reinterpret_cast< DerivationExpression_ReturnProgram* >(object); + (void)_this; +} +void DerivationExpression_ReturnProgram::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void DerivationExpression_ReturnProgram::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void DerivationExpression_ReturnProgram::Clear() { +// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ReturnProgram) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + assignments_.Clear(); + if (GetArena() == nullptr && finalexpression_ != nullptr) { + delete finalexpression_; + } + finalexpression_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* DerivationExpression_ReturnProgram::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // repeated .io.substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_assignments(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); + } else goto handle_unusual; + continue; + // .io.substrait.DerivationExpression finalExpression = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_finalexpression(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ReturnProgram) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // repeated .io.substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_assignments_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_assignments(i), target, stream); + } + + // .io.substrait.DerivationExpression finalExpression = 2; + if (this->has_finalexpression()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::finalexpression(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ReturnProgram) + return target; +} + +size_t DerivationExpression_ReturnProgram::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ReturnProgram) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // repeated .io.substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; + total_size += 1UL * this->_internal_assignments_size(); + for (const auto& msg : this->assignments_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); + } + + // .io.substrait.DerivationExpression finalExpression = 2; + if (this->has_finalexpression()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *finalexpression_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void DerivationExpression_ReturnProgram::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ReturnProgram) + GOOGLE_DCHECK_NE(&from, this); + const DerivationExpression_ReturnProgram* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ReturnProgram) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ReturnProgram) + MergeFrom(*source); + } +} + +void DerivationExpression_ReturnProgram::MergeFrom(const DerivationExpression_ReturnProgram& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ReturnProgram) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + assignments_.MergeFrom(from.assignments_); + if (from.has_finalexpression()) { + _internal_mutable_finalexpression()->::io::substrait::DerivationExpression::MergeFrom(from._internal_finalexpression()); + } +} + +void DerivationExpression_ReturnProgram::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ReturnProgram) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void DerivationExpression_ReturnProgram::CopyFrom(const DerivationExpression_ReturnProgram& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ReturnProgram) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DerivationExpression_ReturnProgram::IsInitialized() const { + return true; +} + +void DerivationExpression_ReturnProgram::InternalSwap(DerivationExpression_ReturnProgram* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + assignments_.InternalSwap(&other->assignments_); + swap(finalexpression_, other->finalexpression_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ReturnProgram::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, + file_level_metadata_type_5fexpressions_2eproto[12]); +} + +// =================================================================== + class DerivationExpression::_Internal { public: static const ::io::substrait::Type_Boolean& bool_(const DerivationExpression* msg); @@ -3684,10 +4079,10 @@ class DerivationExpression::_Internal { static const ::io::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression* msg); static const ::io::substrait::DerivationExpression_ExpressionList& list(const DerivationExpression* msg); static const ::io::substrait::DerivationExpression_ExpressionMap& map(const DerivationExpression* msg); - static const ::io::substrait::Extensions_TypeId& user_defined(const DerivationExpression* msg); static const ::io::substrait::DerivationExpression_UnaryOp& unary_op(const DerivationExpression* msg); static const ::io::substrait::DerivationExpression_BinaryOp& binary_op(const DerivationExpression* msg); static const ::io::substrait::DerivationExpression_IfElse& if_else(const DerivationExpression* msg); + static const ::io::substrait::DerivationExpression_ReturnProgram& return_program(const DerivationExpression* msg); }; const ::io::substrait::Type_Boolean& @@ -3782,10 +4177,6 @@ const ::io::substrait::DerivationExpression_ExpressionMap& DerivationExpression::_Internal::map(const DerivationExpression* msg) { return *msg->kind_.map_; } -const ::io::substrait::Extensions_TypeId& -DerivationExpression::_Internal::user_defined(const DerivationExpression* msg) { - return *msg->kind_.user_defined_; -} const ::io::substrait::DerivationExpression_UnaryOp& DerivationExpression::_Internal::unary_op(const DerivationExpression* msg) { return *msg->kind_.unary_op_; @@ -3798,6 +4189,10 @@ const ::io::substrait::DerivationExpression_IfElse& DerivationExpression::_Internal::if_else(const DerivationExpression* msg) { return *msg->kind_.if_else_; } +const ::io::substrait::DerivationExpression_ReturnProgram& +DerivationExpression::_Internal::return_program(const DerivationExpression* msg) { + return *msg->kind_.return_program_; +} void DerivationExpression::set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); @@ -4271,29 +4666,6 @@ void DerivationExpression::set_allocated_map(::io::substrait::DerivationExpressi } // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.map) } -void DerivationExpression::set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_kind(); - if (user_defined) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(user_defined)->GetArena(); - if (message_arena != submessage_arena) { - user_defined = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, user_defined, submessage_arena); - } - set_has_user_defined(); - kind_.user_defined_ = user_defined; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.user_defined) -} -void DerivationExpression::clear_user_defined() { - if (_internal_has_user_defined()) { - if (GetArena() == nullptr) { - delete kind_.user_defined_; - } - clear_has_kind(); - } -} void DerivationExpression::set_allocated_unary_op(::io::substrait::DerivationExpression_UnaryOp* unary_op) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); @@ -4339,6 +4711,21 @@ void DerivationExpression::set_allocated_if_else(::io::substrait::DerivationExpr } // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.if_else) } +void DerivationExpression::set_allocated_return_program(::io::substrait::DerivationExpression_ReturnProgram* return_program) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_kind(); + if (return_program) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(return_program); + if (message_arena != submessage_arena) { + return_program = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, return_program, submessage_arena); + } + set_has_return_program(); + kind_.return_program_ = return_program; + } + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.return_program) +} DerivationExpression::DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); @@ -4442,8 +4829,8 @@ DerivationExpression::DerivationExpression(const DerivationExpression& from) _internal_mutable_map()->::io::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map()); break; } - case kUserDefined: { - _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + case kUserDefinedPointer: { + _internal_set_user_defined_pointer(from._internal_user_defined_pointer()); break; } case kTypeParameterName: { @@ -4470,6 +4857,10 @@ DerivationExpression::DerivationExpression(const DerivationExpression& from) _internal_mutable_if_else()->::io::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else()); break; } + case kReturnProgram: { + _internal_mutable_return_program()->::io::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program()); + break; + } case KIND_NOT_SET: { break; } @@ -4645,10 +5036,8 @@ void DerivationExpression::clear_kind() { } break; } - case kUserDefined: { - if (GetArena() == nullptr) { - delete kind_.user_defined_; - } + case kUserDefinedPointer: { + // No need to clear break; } case kTypeParameterName: { @@ -4681,6 +5070,12 @@ void DerivationExpression::clear_kind() { } break; } + case kReturnProgram: { + if (GetArena() == nullptr) { + delete kind_.return_program_; + } + break; + } case KIND_NOT_SET: { break; } @@ -4859,10 +5254,10 @@ const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAM CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Extensions.TypeId user_defined = 31; + // uint32 user_defined_pointer = 31; case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) { - ptr = ctx->ParseMessage(_internal_mutable_user_defined(), ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 248)) { + _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); } else goto handle_unusual; continue; @@ -4919,6 +5314,13 @@ const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAM CHK_(ptr); } else goto handle_unusual; continue; + // .io.substrait.DerivationExpression.ReturnProgram return_program = 39; + case 39: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + ptr = ctx->ParseMessage(_internal_mutable_return_program(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -5124,12 +5526,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 29, _Internal::timestamp_tz(this), target, stream); } - // .io.substrait.Extensions.TypeId user_defined = 31; - if (_internal_has_user_defined()) { + // uint32 user_defined_pointer = 31; + if (_internal_has_user_defined_pointer()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 31, _Internal::user_defined(this), target, stream); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_pointer(), target); } // .io.substrait.Type.UUID uuid = 32; @@ -5190,6 +5590,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 38, _Internal::if_else(this), target, stream); } + // .io.substrait.DerivationExpression.ReturnProgram return_program = 39; + if (_internal_has_return_program()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 39, _Internal::return_program(this), target, stream); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -5368,11 +5776,11 @@ size_t DerivationExpression::ByteSizeLong() const { *kind_.map_); break; } - // .io.substrait.Extensions.TypeId user_defined = 31; - case kUserDefined: { + // uint32 user_defined_pointer = 31; + case kUserDefinedPointer: { total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.user_defined_); + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_user_defined_pointer()); break; } // string type_parameter_name = 33; @@ -5417,6 +5825,13 @@ size_t DerivationExpression::ByteSizeLong() const { *kind_.if_else_); break; } + // .io.substrait.DerivationExpression.ReturnProgram return_program = 39; + case kReturnProgram: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *kind_.return_program_); + break; + } case KIND_NOT_SET: { break; } @@ -5545,8 +5960,8 @@ void DerivationExpression::MergeFrom(const DerivationExpression& from) { _internal_mutable_map()->::io::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map()); break; } - case kUserDefined: { - _internal_mutable_user_defined()->::io::substrait::Extensions_TypeId::MergeFrom(from._internal_user_defined()); + case kUserDefinedPointer: { + _internal_set_user_defined_pointer(from._internal_user_defined_pointer()); break; } case kTypeParameterName: { @@ -5573,6 +5988,10 @@ void DerivationExpression::MergeFrom(const DerivationExpression& from) { _internal_mutable_if_else()->::io::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else()); break; } + case kReturnProgram: { + _internal_mutable_return_program()->::io::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program()); + break; + } case KIND_NOT_SET: { break; } @@ -5607,7 +6026,7 @@ void DerivationExpression::InternalSwap(DerivationExpression* other) { ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[11]); + file_level_metadata_type_5fexpressions_2eproto[13]); } // @@protoc_insertion_point(namespace_scope) @@ -5647,6 +6066,12 @@ template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_UnaryOp* Aren template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_BinaryOp >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_BinaryOp >(arena); } +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >(arena); +} +template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ReturnProgram >(Arena* arena) { + return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ReturnProgram >(arena); +} template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression >(Arena* arena) { return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression >(arena); } diff --git a/cpp/src/generated/substrait/type_expressions.pb.h b/cpp/src/generated/substrait/type_expressions.pb.h index ec27b93e51b..2b940b3af60 100644 --- a/cpp/src/generated/substrait/type_expressions.pb.h +++ b/cpp/src/generated/substrait/type_expressions.pb.h @@ -33,7 +33,6 @@ #include #include #include "type.pb.h" -#include "extensions.pb.h" // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_type_5fexpressions_2eproto @@ -49,7 +48,7 @@ struct TableStruct_type_5fexpressions_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12] + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; @@ -91,6 +90,12 @@ extern DerivationExpression_ExpressionVarCharDefaultTypeInternal _DerivationExpr class DerivationExpression_IfElse; struct DerivationExpression_IfElseDefaultTypeInternal; extern DerivationExpression_IfElseDefaultTypeInternal _DerivationExpression_IfElse_default_instance_; +class DerivationExpression_ReturnProgram; +struct DerivationExpression_ReturnProgramDefaultTypeInternal; +extern DerivationExpression_ReturnProgramDefaultTypeInternal _DerivationExpression_ReturnProgram_default_instance_; +class DerivationExpression_ReturnProgram_Assignment; +struct DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal; +extern DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal _DerivationExpression_ReturnProgram_Assignment_default_instance_; class DerivationExpression_UnaryOp; struct DerivationExpression_UnaryOpDefaultTypeInternal; extern DerivationExpression_UnaryOpDefaultTypeInternal _DerivationExpression_UnaryOp_default_instance_; @@ -108,6 +113,8 @@ template<> ::io::substrait::DerivationExpression_ExpressionNamedStruct* Arena::C template<> ::io::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionStruct>(Arena*); template<> ::io::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionVarChar>(Arena*); template<> ::io::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_IfElse>(Arena*); +template<> ::io::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ReturnProgram>(Arena*); +template<> ::io::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ReturnProgram_Assignment>(Arena*); template<> ::io::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_UnaryOp>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace io { @@ -284,7 +291,7 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : enum : int { kLengthFieldNumber = 1, - kVariationFieldNumber = 2, + kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; // .io.substrait.DerivationExpression length = 1; @@ -305,23 +312,14 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : ::io::substrait::DerivationExpression* length); ::io::substrait::DerivationExpression* unsafe_arena_release_length(); - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; + // uint32 variation_pointer = 2; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -340,7 +338,7 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::DerivationExpression* length_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_5fexpressions_2eproto; @@ -455,7 +453,7 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : enum : int { kLengthFieldNumber = 1, - kVariationFieldNumber = 2, + kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; // .io.substrait.DerivationExpression length = 1; @@ -476,23 +474,14 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : ::io::substrait::DerivationExpression* length); ::io::substrait::DerivationExpression* unsafe_arena_release_length(); - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 variation_pointer = 2; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -511,7 +500,7 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::DerivationExpression* length_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_5fexpressions_2eproto; @@ -626,7 +615,7 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : enum : int { kLengthFieldNumber = 1, - kVariationFieldNumber = 2, + kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; // .io.substrait.DerivationExpression length = 1; @@ -647,23 +636,14 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : ::io::substrait::DerivationExpression* length); ::io::substrait::DerivationExpression* unsafe_arena_release_length(); - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 variation_pointer = 2; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -682,7 +662,7 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::DerivationExpression* length_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_5fexpressions_2eproto; @@ -798,7 +778,7 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : enum : int { kScaleFieldNumber = 1, kPrecisionFieldNumber = 2, - kVariationFieldNumber = 3, + kVariationPointerFieldNumber = 3, kNullabilityFieldNumber = 4, }; // .io.substrait.DerivationExpression scale = 1; @@ -837,23 +817,14 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : ::io::substrait::DerivationExpression* precision); ::io::substrait::DerivationExpression* unsafe_arena_release_precision(); - // .io.substrait.Type.Variation variation = 3; - bool has_variation() const; + // uint32 variation_pointer = 3; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 4; void clear_nullability(); @@ -873,7 +844,7 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : typedef void DestructorSkippable_; ::io::substrait::DerivationExpression* scale_; ::io::substrait::DerivationExpression* precision_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_5fexpressions_2eproto; @@ -988,7 +959,7 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : enum : int { kTypesFieldNumber = 1, - kVariationFieldNumber = 2, + kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; // repeated .io.substrait.DerivationExpression types = 1; @@ -1009,23 +980,14 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression >& types() const; - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; + // uint32 variation_pointer = 2; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - bool _internal_has_variation() const; + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); - private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); - public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -1044,7 +1006,7 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression > types_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_5fexpressions_2eproto; @@ -1325,7 +1287,7 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : enum : int { kTypeFieldNumber = 1, - kVariationFieldNumber = 2, + kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; // .io.substrait.DerivationExpression type = 1; @@ -1346,23 +1308,14 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : ::io::substrait::DerivationExpression* type); ::io::substrait::DerivationExpression* unsafe_arena_release_type(); - // .io.substrait.Type.Variation variation = 2; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 variation_pointer = 2; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 3; void clear_nullability(); @@ -1381,7 +1334,7 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::io::substrait::DerivationExpression* type_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_5fexpressions_2eproto; @@ -1497,7 +1450,7 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : enum : int { kKeyFieldNumber = 1, kValueFieldNumber = 2, - kVariationFieldNumber = 3, + kVariationPointerFieldNumber = 3, kNullabilityFieldNumber = 4, }; // .io.substrait.DerivationExpression key = 1; @@ -1536,23 +1489,14 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : ::io::substrait::DerivationExpression* value); ::io::substrait::DerivationExpression* unsafe_arena_release_value(); - // .io.substrait.Type.Variation variation = 3; - bool has_variation() const; - private: - bool _internal_has_variation() const; - public: - void clear_variation(); - const ::io::substrait::Type_Variation& variation() const; - ::io::substrait::Type_Variation* release_variation(); - ::io::substrait::Type_Variation* mutable_variation(); - void set_allocated_variation(::io::substrait::Type_Variation* variation); + // uint32 variation_pointer = 3; + void clear_variation_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; + void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Type_Variation& _internal_variation() const; - ::io::substrait::Type_Variation* _internal_mutable_variation(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; + void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation); - ::io::substrait::Type_Variation* unsafe_arena_release_variation(); // .io.substrait.Type.Nullability nullability = 4; void clear_nullability(); @@ -1572,7 +1516,7 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : typedef void DestructorSkippable_; ::io::substrait::DerivationExpression* key_; ::io::substrait::DerivationExpression* value_; - ::io::substrait::Type_Variation* variation_; + ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_type_5fexpressions_2eproto; @@ -2163,6 +2107,324 @@ class DerivationExpression_BinaryOp PROTOBUF_FINAL : }; // ------------------------------------------------------------------- +class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ReturnProgram.Assignment) */ { + public: + inline DerivationExpression_ReturnProgram_Assignment() : DerivationExpression_ReturnProgram_Assignment(nullptr) {} + ~DerivationExpression_ReturnProgram_Assignment() override; + explicit constexpr DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_ReturnProgram_Assignment(const DerivationExpression_ReturnProgram_Assignment& from); + DerivationExpression_ReturnProgram_Assignment(DerivationExpression_ReturnProgram_Assignment&& from) noexcept + : DerivationExpression_ReturnProgram_Assignment() { + *this = ::std::move(from); + } + + inline DerivationExpression_ReturnProgram_Assignment& operator=(const DerivationExpression_ReturnProgram_Assignment& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_ReturnProgram_Assignment& operator=(DerivationExpression_ReturnProgram_Assignment&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_ReturnProgram_Assignment& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_ReturnProgram_Assignment* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_ReturnProgram_Assignment_default_instance_); + } + static constexpr int kIndexInFileMessages = + 11; + + friend void swap(DerivationExpression_ReturnProgram_Assignment& a, DerivationExpression_ReturnProgram_Assignment& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_ReturnProgram_Assignment* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_ReturnProgram_Assignment* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_ReturnProgram_Assignment* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_ReturnProgram_Assignment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from); + void MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_ReturnProgram_Assignment* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.ReturnProgram.Assignment"; + } + protected: + explicit DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 1, + kExpressionFieldNumber = 2, + }; + // string name = 1; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // .io.substrait.DerivationExpression expression = 2; + bool has_expression() const; + private: + bool _internal_has_expression() const; + public: + void clear_expression(); + const ::io::substrait::DerivationExpression& expression() const; + ::io::substrait::DerivationExpression* release_expression(); + ::io::substrait::DerivationExpression* mutable_expression(); + void set_allocated_expression(::io::substrait::DerivationExpression* expression); + private: + const ::io::substrait::DerivationExpression& _internal_expression() const; + ::io::substrait::DerivationExpression* _internal_mutable_expression(); + public: + void unsafe_arena_set_allocated_expression( + ::io::substrait::DerivationExpression* expression); + ::io::substrait::DerivationExpression* unsafe_arena_release_expression(); + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ReturnProgram.Assignment) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::io::substrait::DerivationExpression* expression_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + +class DerivationExpression_ReturnProgram PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ReturnProgram) */ { + public: + inline DerivationExpression_ReturnProgram() : DerivationExpression_ReturnProgram(nullptr) {} + ~DerivationExpression_ReturnProgram() override; + explicit constexpr DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + DerivationExpression_ReturnProgram(const DerivationExpression_ReturnProgram& from); + DerivationExpression_ReturnProgram(DerivationExpression_ReturnProgram&& from) noexcept + : DerivationExpression_ReturnProgram() { + *this = ::std::move(from); + } + + inline DerivationExpression_ReturnProgram& operator=(const DerivationExpression_ReturnProgram& from) { + CopyFrom(from); + return *this; + } + inline DerivationExpression_ReturnProgram& operator=(DerivationExpression_ReturnProgram&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 DerivationExpression_ReturnProgram& default_instance() { + return *internal_default_instance(); + } + static inline const DerivationExpression_ReturnProgram* internal_default_instance() { + return reinterpret_cast( + &_DerivationExpression_ReturnProgram_default_instance_); + } + static constexpr int kIndexInFileMessages = + 12; + + friend void swap(DerivationExpression_ReturnProgram& a, DerivationExpression_ReturnProgram& b) { + a.Swap(&b); + } + inline void Swap(DerivationExpression_ReturnProgram* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DerivationExpression_ReturnProgram* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline DerivationExpression_ReturnProgram* New() const final { + return CreateMaybeMessage(nullptr); + } + + DerivationExpression_ReturnProgram* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const DerivationExpression_ReturnProgram& from); + void MergeFrom(const DerivationExpression_ReturnProgram& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(DerivationExpression_ReturnProgram* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "io.substrait.DerivationExpression.ReturnProgram"; + } + protected: + explicit DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef DerivationExpression_ReturnProgram_Assignment Assignment; + + // accessors ------------------------------------------------------- + + enum : int { + kAssignmentsFieldNumber = 1, + kFinalExpressionFieldNumber = 2, + }; + // repeated .io.substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; + int assignments_size() const; + private: + int _internal_assignments_size() const; + public: + void clear_assignments(); + ::io::substrait::DerivationExpression_ReturnProgram_Assignment* mutable_assignments(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >* + mutable_assignments(); + private: + const ::io::substrait::DerivationExpression_ReturnProgram_Assignment& _internal_assignments(int index) const; + ::io::substrait::DerivationExpression_ReturnProgram_Assignment* _internal_add_assignments(); + public: + const ::io::substrait::DerivationExpression_ReturnProgram_Assignment& assignments(int index) const; + ::io::substrait::DerivationExpression_ReturnProgram_Assignment* add_assignments(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >& + assignments() const; + + // .io.substrait.DerivationExpression finalExpression = 2; + bool has_finalexpression() const; + private: + bool _internal_has_finalexpression() const; + public: + void clear_finalexpression(); + const ::io::substrait::DerivationExpression& finalexpression() const; + ::io::substrait::DerivationExpression* release_finalexpression(); + ::io::substrait::DerivationExpression* mutable_finalexpression(); + void set_allocated_finalexpression(::io::substrait::DerivationExpression* finalexpression); + private: + const ::io::substrait::DerivationExpression& _internal_finalexpression() const; + ::io::substrait::DerivationExpression* _internal_mutable_finalexpression(); + public: + void unsafe_arena_set_allocated_finalexpression( + ::io::substrait::DerivationExpression* finalexpression); + ::io::substrait::DerivationExpression* unsafe_arena_release_finalexpression(); + + // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ReturnProgram) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression_ReturnProgram_Assignment > assignments_; + ::io::substrait::DerivationExpression* finalexpression_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_type_5fexpressions_2eproto; +}; +// ------------------------------------------------------------------- + class DerivationExpression PROTOBUF_FINAL : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression) */ { public: @@ -2225,13 +2487,14 @@ class DerivationExpression PROTOBUF_FINAL : kStruct = 25, kList = 27, kMap = 28, - kUserDefined = 31, + kUserDefinedPointer = 31, kTypeParameterName = 33, kIntegerParameterName = 34, kIntegerLiteral = 35, kUnaryOp = 36, kBinaryOp = 37, kIfElse = 38, + kReturnProgram = 39, KIND_NOT_SET = 0, }; @@ -2240,7 +2503,7 @@ class DerivationExpression PROTOBUF_FINAL : &_DerivationExpression_default_instance_); } static constexpr int kIndexInFileMessages = - 11; + 13; friend void swap(DerivationExpression& a, DerivationExpression& b) { a.Swap(&b); @@ -2312,6 +2575,7 @@ class DerivationExpression PROTOBUF_FINAL : typedef DerivationExpression_IfElse IfElse; typedef DerivationExpression_UnaryOp UnaryOp; typedef DerivationExpression_BinaryOp BinaryOp; + typedef DerivationExpression_ReturnProgram ReturnProgram; // accessors ------------------------------------------------------- @@ -2339,13 +2603,14 @@ class DerivationExpression PROTOBUF_FINAL : kStructFieldNumber = 25, kListFieldNumber = 27, kMapFieldNumber = 28, - kUserDefinedFieldNumber = 31, + kUserDefinedPointerFieldNumber = 31, kTypeParameterNameFieldNumber = 33, kIntegerParameterNameFieldNumber = 34, kIntegerLiteralFieldNumber = 35, kUnaryOpFieldNumber = 36, kBinaryOpFieldNumber = 37, kIfElseFieldNumber = 38, + kReturnProgramFieldNumber = 39, }; // .io.substrait.Type.Boolean bool = 1; bool has_bool_() const; @@ -2761,23 +3026,18 @@ class DerivationExpression PROTOBUF_FINAL : ::io::substrait::DerivationExpression_ExpressionMap* map); ::io::substrait::DerivationExpression_ExpressionMap* unsafe_arena_release_map(); - // .io.substrait.Extensions.TypeId user_defined = 31; - bool has_user_defined() const; + // uint32 user_defined_pointer = 31; + bool has_user_defined_pointer() const; private: - bool _internal_has_user_defined() const; + bool _internal_has_user_defined_pointer() const; public: - void clear_user_defined(); - const ::io::substrait::Extensions_TypeId& user_defined() const; - ::io::substrait::Extensions_TypeId* release_user_defined(); - ::io::substrait::Extensions_TypeId* mutable_user_defined(); - void set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined); + void clear_user_defined_pointer(); + ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_pointer() const; + void set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); private: - const ::io::substrait::Extensions_TypeId& _internal_user_defined() const; - ::io::substrait::Extensions_TypeId* _internal_mutable_user_defined(); + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_user_defined_pointer() const; + void _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - void unsafe_arena_set_allocated_user_defined( - ::io::substrait::Extensions_TypeId* user_defined); - ::io::substrait::Extensions_TypeId* unsafe_arena_release_user_defined(); // string type_parameter_name = 33; bool has_type_parameter_name() const; @@ -2882,6 +3142,24 @@ class DerivationExpression PROTOBUF_FINAL : ::io::substrait::DerivationExpression_IfElse* if_else); ::io::substrait::DerivationExpression_IfElse* unsafe_arena_release_if_else(); + // .io.substrait.DerivationExpression.ReturnProgram return_program = 39; + bool has_return_program() const; + private: + bool _internal_has_return_program() const; + public: + void clear_return_program(); + const ::io::substrait::DerivationExpression_ReturnProgram& return_program() const; + ::io::substrait::DerivationExpression_ReturnProgram* release_return_program(); + ::io::substrait::DerivationExpression_ReturnProgram* mutable_return_program(); + void set_allocated_return_program(::io::substrait::DerivationExpression_ReturnProgram* return_program); + private: + const ::io::substrait::DerivationExpression_ReturnProgram& _internal_return_program() const; + ::io::substrait::DerivationExpression_ReturnProgram* _internal_mutable_return_program(); + public: + void unsafe_arena_set_allocated_return_program( + ::io::substrait::DerivationExpression_ReturnProgram* return_program); + ::io::substrait::DerivationExpression_ReturnProgram* unsafe_arena_release_return_program(); + void clear_kind(); KindCase kind_case() const; // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression) @@ -2910,13 +3188,14 @@ class DerivationExpression PROTOBUF_FINAL : void set_has_struct_(); void set_has_list(); void set_has_map(); - void set_has_user_defined(); + void set_has_user_defined_pointer(); void set_has_type_parameter_name(); void set_has_integer_parameter_name(); void set_has_integer_literal(); void set_has_unary_op(); void set_has_binary_op(); void set_has_if_else(); + void set_has_return_program(); inline bool has_kind() const; inline void clear_has_kind(); @@ -2950,13 +3229,14 @@ class DerivationExpression PROTOBUF_FINAL : ::io::substrait::DerivationExpression_ExpressionStruct* struct__; ::io::substrait::DerivationExpression_ExpressionList* list_; ::io::substrait::DerivationExpression_ExpressionMap* map_; - ::io::substrait::Extensions_TypeId* user_defined_; + ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_pointer_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_parameter_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr integer_parameter_name_; ::PROTOBUF_NAMESPACE_ID::int32 integer_literal_; ::io::substrait::DerivationExpression_UnaryOp* unary_op_; ::io::substrait::DerivationExpression_BinaryOp* binary_op_; ::io::substrait::DerivationExpression_IfElse* if_else_; + ::io::substrait::DerivationExpression_ReturnProgram* return_program_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; @@ -3057,81 +3337,24 @@ inline void DerivationExpression_ExpressionFixedChar::set_allocated_length(::io: // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionFixedChar.length) } -// .io.substrait.Type.Variation variation = 2; -inline bool DerivationExpression_ExpressionFixedChar::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool DerivationExpression_ExpressionFixedChar::has_variation() const { - return _internal_has_variation(); -} -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionFixedChar::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionFixedChar::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedChar.variation) - return _internal_variation(); -} -inline void DerivationExpression_ExpressionFixedChar::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionFixedChar.variation) +// uint32 variation_pointer = 2; +inline void DerivationExpression_ExpressionFixedChar::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedChar::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedChar::_internal_variation_pointer() const { + return variation_pointer_; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedChar::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionFixedChar.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedChar::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedChar.variation_pointer) + return _internal_variation_pointer(); } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedChar::_internal_mutable_variation() { +inline void DerivationExpression_ExpressionFixedChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedChar::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionFixedChar.variation) - return _internal_mutable_variation(); -} -inline void DerivationExpression_ExpressionFixedChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionFixedChar.variation) +inline void DerivationExpression_ExpressionFixedChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionFixedChar.variation_pointer) } // .io.substrait.Type.Nullability nullability = 3; @@ -3241,81 +3464,24 @@ inline void DerivationExpression_ExpressionVarChar::set_allocated_length(::io::s // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionVarChar.length) } -// .io.substrait.Type.Variation variation = 2; -inline bool DerivationExpression_ExpressionVarChar::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool DerivationExpression_ExpressionVarChar::has_variation() const { - return _internal_has_variation(); -} -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionVarChar::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +// uint32 variation_pointer = 2; +inline void DerivationExpression_ExpressionVarChar::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionVarChar::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionVarChar.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionVarChar::_internal_variation_pointer() const { + return variation_pointer_; } -inline void DerivationExpression_ExpressionVarChar::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionVarChar.variation) -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionVarChar::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionVarChar::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionVarChar.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionVarChar::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionVarChar.variation_pointer) + return _internal_variation_pointer(); } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionVarChar::_internal_mutable_variation() { +inline void DerivationExpression_ExpressionVarChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionVarChar::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionVarChar.variation) - return _internal_mutable_variation(); -} -inline void DerivationExpression_ExpressionVarChar::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionVarChar.variation) +inline void DerivationExpression_ExpressionVarChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionVarChar.variation_pointer) } // .io.substrait.Type.Nullability nullability = 3; @@ -3425,81 +3591,24 @@ inline void DerivationExpression_ExpressionFixedBinary::set_allocated_length(::i // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionFixedBinary.length) } -// .io.substrait.Type.Variation variation = 2; -inline bool DerivationExpression_ExpressionFixedBinary::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool DerivationExpression_ExpressionFixedBinary::has_variation() const { - return _internal_has_variation(); +// uint32 variation_pointer = 2; +inline void DerivationExpression_ExpressionFixedBinary::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionFixedBinary::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedBinary::_internal_variation_pointer() const { + return variation_pointer_; } -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionFixedBinary::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedBinary.variation) - return _internal_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedBinary::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer) + return _internal_variation_pointer(); } -inline void DerivationExpression_ExpressionFixedBinary::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionFixedBinary.variation) -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedBinary::release_variation() { +inline void DerivationExpression_ExpressionFixedBinary::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedBinary::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionFixedBinary.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedBinary::_internal_mutable_variation() { - - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionFixedBinary::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionFixedBinary.variation) - return _internal_mutable_variation(); -} -inline void DerivationExpression_ExpressionFixedBinary::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionFixedBinary.variation) +inline void DerivationExpression_ExpressionFixedBinary::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer) } // .io.substrait.Type.Nullability nullability = 3; @@ -3692,81 +3801,24 @@ inline void DerivationExpression_ExpressionDecimal::set_allocated_precision(::io // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.precision) } -// .io.substrait.Type.Variation variation = 3; -inline bool DerivationExpression_ExpressionDecimal::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool DerivationExpression_ExpressionDecimal::has_variation() const { - return _internal_has_variation(); -} -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionDecimal::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionDecimal::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionDecimal.variation) - return _internal_variation(); -} -inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.variation) +// uint32 variation_pointer = 3; +inline void DerivationExpression_ExpressionDecimal::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionDecimal::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionDecimal::_internal_variation_pointer() const { + return variation_pointer_; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionDecimal::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionDecimal.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionDecimal::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionDecimal.variation_pointer) + return _internal_variation_pointer(); } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionDecimal::_internal_mutable_variation() { +inline void DerivationExpression_ExpressionDecimal::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionDecimal::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionDecimal.variation) - return _internal_mutable_variation(); + variation_pointer_ = value; } -inline void DerivationExpression_ExpressionDecimal::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.variation) +inline void DerivationExpression_ExpressionDecimal::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionDecimal.variation_pointer) } // .io.substrait.Type.Nullability nullability = 4; @@ -3832,81 +3884,24 @@ DerivationExpression_ExpressionStruct::types() const { return types_; } -// .io.substrait.Type.Variation variation = 2; -inline bool DerivationExpression_ExpressionStruct::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; +// uint32 variation_pointer = 2; +inline void DerivationExpression_ExpressionStruct::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline bool DerivationExpression_ExpressionStruct::has_variation() const { - return _internal_has_variation(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionStruct::_internal_variation_pointer() const { + return variation_pointer_; } -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionStruct::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionStruct::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionStruct.variation_pointer) + return _internal_variation_pointer(); } -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionStruct::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionStruct.variation) - return _internal_variation(); -} -inline void DerivationExpression_ExpressionStruct::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionStruct.variation) -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionStruct::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionStruct::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionStruct.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionStruct::_internal_mutable_variation() { +inline void DerivationExpression_ExpressionStruct::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionStruct::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionStruct.variation) - return _internal_mutable_variation(); -} -inline void DerivationExpression_ExpressionStruct::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionStruct.variation) +inline void DerivationExpression_ExpressionStruct::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionStruct.variation_pointer) } // .io.substrait.Type.Nullability nullability = 3; @@ -4177,81 +4172,24 @@ inline void DerivationExpression_ExpressionList::set_allocated_type(::io::substr // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionList.type) } -// .io.substrait.Type.Variation variation = 2; -inline bool DerivationExpression_ExpressionList::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool DerivationExpression_ExpressionList::has_variation() const { - return _internal_has_variation(); -} -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionList::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionList::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionList.variation) - return _internal_variation(); +// uint32 variation_pointer = 2; +inline void DerivationExpression_ExpressionList::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline void DerivationExpression_ExpressionList::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionList.variation) -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionList::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionList::_internal_variation_pointer() const { + return variation_pointer_; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionList::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionList.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionList::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionList.variation_pointer) + return _internal_variation_pointer(); } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionList::_internal_mutable_variation() { +inline void DerivationExpression_ExpressionList::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; -} -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionList::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionList.variation) - return _internal_mutable_variation(); + variation_pointer_ = value; } -inline void DerivationExpression_ExpressionList::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionList.variation) +inline void DerivationExpression_ExpressionList::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionList.variation_pointer) } // .io.substrait.Type.Nullability nullability = 3; @@ -4444,81 +4382,24 @@ inline void DerivationExpression_ExpressionMap::set_allocated_value(::io::substr // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionMap.value) } -// .io.substrait.Type.Variation variation = 3; -inline bool DerivationExpression_ExpressionMap::_internal_has_variation() const { - return this != internal_default_instance() && variation_ != nullptr; -} -inline bool DerivationExpression_ExpressionMap::has_variation() const { - return _internal_has_variation(); -} -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionMap::_internal_variation() const { - const ::io::substrait::Type_Variation* p = variation_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Variation_default_instance_); -} -inline const ::io::substrait::Type_Variation& DerivationExpression_ExpressionMap::variation() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionMap.variation) - return _internal_variation(); -} -inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_variation( - ::io::substrait::Type_Variation* variation) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - variation_ = variation; - if (variation) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionMap.variation) +// uint32 variation_pointer = 3; +inline void DerivationExpression_ExpressionMap::clear_variation_pointer() { + variation_pointer_ = 0u; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionMap::release_variation() { - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionMap::_internal_variation_pointer() const { + return variation_pointer_; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionMap::unsafe_arena_release_variation() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionMap.variation) - - ::io::substrait::Type_Variation* temp = variation_; - variation_ = nullptr; - return temp; +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionMap::variation_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionMap.variation_pointer) + return _internal_variation_pointer(); } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionMap::_internal_mutable_variation() { +inline void DerivationExpression_ExpressionMap::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - if (variation_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Variation>(GetArena()); - variation_ = p; - } - return variation_; + variation_pointer_ = value; } -inline ::io::substrait::Type_Variation* DerivationExpression_ExpressionMap::mutable_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionMap.variation) - return _internal_mutable_variation(); -} -inline void DerivationExpression_ExpressionMap::set_allocated_variation(::io::substrait::Type_Variation* variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation_); - } - if (variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variation)->GetArena(); - if (message_arena != submessage_arena) { - variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variation, submessage_arena); - } - - } else { - - } - variation_ = variation; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionMap.variation) +inline void DerivationExpression_ExpressionMap::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_variation_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionMap.variation_pointer) } // .io.substrait.Type.Nullability nullability = 4; @@ -5093,6 +4974,264 @@ inline void DerivationExpression_BinaryOp::set_allocated_arg2(::io::substrait::D // ------------------------------------------------------------------- +// DerivationExpression_ReturnProgram_Assignment + +// string name = 1; +inline void DerivationExpression_ReturnProgram_Assignment::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& DerivationExpression_ReturnProgram_Assignment::name() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ReturnProgram.Assignment.name) + return _internal_name(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void DerivationExpression_ReturnProgram_Assignment::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ReturnProgram.Assignment.name) +} +inline std::string* DerivationExpression_ReturnProgram_Assignment::mutable_name() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ReturnProgram.Assignment.name) + return _internal_mutable_name(); +} +inline const std::string& DerivationExpression_ReturnProgram_Assignment::_internal_name() const { + return name_.Get(); +} +inline void DerivationExpression_ReturnProgram_Assignment::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* DerivationExpression_ReturnProgram_Assignment::release_name() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ReturnProgram.Assignment.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ReturnProgram.Assignment.name) +} + +// .io.substrait.DerivationExpression expression = 2; +inline bool DerivationExpression_ReturnProgram_Assignment::_internal_has_expression() const { + return this != internal_default_instance() && expression_ != nullptr; +} +inline bool DerivationExpression_ReturnProgram_Assignment::has_expression() const { + return _internal_has_expression(); +} +inline void DerivationExpression_ReturnProgram_Assignment::clear_expression() { + if (GetArena() == nullptr && expression_ != nullptr) { + delete expression_; + } + expression_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::_internal_expression() const { + const ::io::substrait::DerivationExpression* p = expression_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::expression() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ReturnProgram.Assignment.expression) + return _internal_expression(); +} +inline void DerivationExpression_ReturnProgram_Assignment::unsafe_arena_set_allocated_expression( + ::io::substrait::DerivationExpression* expression) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); + } + expression_ = expression; + if (expression) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ReturnProgram.Assignment.expression) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::release_expression() { + + ::io::substrait::DerivationExpression* temp = expression_; + expression_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ReturnProgram.Assignment.expression) + + ::io::substrait::DerivationExpression* temp = expression_; + expression_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_expression() { + + if (expression_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + expression_ = p; + } + return expression_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::mutable_expression() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ReturnProgram.Assignment.expression) + return _internal_mutable_expression(); +} +inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_expression(::io::substrait::DerivationExpression* expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete expression_; + } + if (expression) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expression); + if (message_arena != submessage_arena) { + expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, expression, submessage_arena); + } + + } else { + + } + expression_ = expression; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ReturnProgram.Assignment.expression) +} + +// ------------------------------------------------------------------- + +// DerivationExpression_ReturnProgram + +// repeated .io.substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; +inline int DerivationExpression_ReturnProgram::_internal_assignments_size() const { + return assignments_.size(); +} +inline int DerivationExpression_ReturnProgram::assignments_size() const { + return _internal_assignments_size(); +} +inline void DerivationExpression_ReturnProgram::clear_assignments() { + assignments_.Clear(); +} +inline ::io::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::mutable_assignments(int index) { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ReturnProgram.assignments) + return assignments_.Mutable(index); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >* +DerivationExpression_ReturnProgram::mutable_assignments() { + // @@protoc_insertion_point(field_mutable_list:io.substrait.DerivationExpression.ReturnProgram.assignments) + return &assignments_; +} +inline const ::io::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::_internal_assignments(int index) const { + return assignments_.Get(index); +} +inline const ::io::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::assignments(int index) const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ReturnProgram.assignments) + return _internal_assignments(index); +} +inline ::io::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::_internal_add_assignments() { + return assignments_.Add(); +} +inline ::io::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::add_assignments() { + // @@protoc_insertion_point(field_add:io.substrait.DerivationExpression.ReturnProgram.assignments) + return _internal_add_assignments(); +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >& +DerivationExpression_ReturnProgram::assignments() const { + // @@protoc_insertion_point(field_list:io.substrait.DerivationExpression.ReturnProgram.assignments) + return assignments_; +} + +// .io.substrait.DerivationExpression finalExpression = 2; +inline bool DerivationExpression_ReturnProgram::_internal_has_finalexpression() const { + return this != internal_default_instance() && finalexpression_ != nullptr; +} +inline bool DerivationExpression_ReturnProgram::has_finalexpression() const { + return _internal_has_finalexpression(); +} +inline void DerivationExpression_ReturnProgram::clear_finalexpression() { + if (GetArena() == nullptr && finalexpression_ != nullptr) { + delete finalexpression_; + } + finalexpression_ = nullptr; +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ReturnProgram::_internal_finalexpression() const { + const ::io::substrait::DerivationExpression* p = finalexpression_; + return p != nullptr ? *p : reinterpret_cast( + ::io::substrait::_DerivationExpression_default_instance_); +} +inline const ::io::substrait::DerivationExpression& DerivationExpression_ReturnProgram::finalexpression() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ReturnProgram.finalExpression) + return _internal_finalexpression(); +} +inline void DerivationExpression_ReturnProgram::unsafe_arena_set_allocated_finalexpression( + ::io::substrait::DerivationExpression* finalexpression) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(finalexpression_); + } + finalexpression_ = finalexpression; + if (finalexpression) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ReturnProgram.finalExpression) +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram::release_finalexpression() { + + ::io::substrait::DerivationExpression* temp = finalexpression_; + finalexpression_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram::unsafe_arena_release_finalexpression() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ReturnProgram.finalExpression) + + ::io::substrait::DerivationExpression* temp = finalexpression_; + finalexpression_ = nullptr; + return temp; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram::_internal_mutable_finalexpression() { + + if (finalexpression_ == nullptr) { + auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + finalexpression_ = p; + } + return finalexpression_; +} +inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram::mutable_finalexpression() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ReturnProgram.finalExpression) + return _internal_mutable_finalexpression(); +} +inline void DerivationExpression_ReturnProgram::set_allocated_finalexpression(::io::substrait::DerivationExpression* finalexpression) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete finalexpression_; + } + if (finalexpression) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(finalexpression); + if (message_arena != submessage_arena) { + finalexpression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, finalexpression, submessage_arena); + } + + } else { + + } + finalexpression_ = finalexpression; + // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ReturnProgram.finalExpression) +} + +// ------------------------------------------------------------------- + // DerivationExpression // .io.substrait.Type.Boolean bool = 1; @@ -6646,69 +6785,42 @@ inline ::io::substrait::DerivationExpression_ExpressionMap* DerivationExpression return _internal_mutable_map(); } -// .io.substrait.Extensions.TypeId user_defined = 31; -inline bool DerivationExpression::_internal_has_user_defined() const { - return kind_case() == kUserDefined; -} -inline bool DerivationExpression::has_user_defined() const { - return _internal_has_user_defined(); -} -inline void DerivationExpression::set_has_user_defined() { - _oneof_case_[0] = kUserDefined; -} -inline ::io::substrait::Extensions_TypeId* DerivationExpression::release_user_defined() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.user_defined) - if (_internal_has_user_defined()) { - clear_has_kind(); - ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.user_defined_ = nullptr; - return temp; - } else { - return nullptr; - } +// uint32 user_defined_pointer = 31; +inline bool DerivationExpression::_internal_has_user_defined_pointer() const { + return kind_case() == kUserDefinedPointer; } -inline const ::io::substrait::Extensions_TypeId& DerivationExpression::_internal_user_defined() const { - return _internal_has_user_defined() - ? *kind_.user_defined_ - : reinterpret_cast< ::io::substrait::Extensions_TypeId&>(::io::substrait::_Extensions_TypeId_default_instance_); +inline bool DerivationExpression::has_user_defined_pointer() const { + return _internal_has_user_defined_pointer(); } -inline const ::io::substrait::Extensions_TypeId& DerivationExpression::user_defined() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.user_defined) - return _internal_user_defined(); +inline void DerivationExpression::set_has_user_defined_pointer() { + _oneof_case_[0] = kUserDefinedPointer; } -inline ::io::substrait::Extensions_TypeId* DerivationExpression::unsafe_arena_release_user_defined() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.user_defined) - if (_internal_has_user_defined()) { +inline void DerivationExpression::clear_user_defined_pointer() { + if (_internal_has_user_defined_pointer()) { + kind_.user_defined_pointer_ = 0u; clear_has_kind(); - ::io::substrait::Extensions_TypeId* temp = kind_.user_defined_; - kind_.user_defined_ = nullptr; - return temp; - } else { - return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_user_defined(::io::substrait::Extensions_TypeId* user_defined) { - clear_kind(); - if (user_defined) { - set_has_user_defined(); - kind_.user_defined_ = user_defined; +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression::_internal_user_defined_pointer() const { + if (_internal_has_user_defined_pointer()) { + return kind_.user_defined_pointer_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.user_defined) + return 0u; } -inline ::io::substrait::Extensions_TypeId* DerivationExpression::_internal_mutable_user_defined() { - if (!_internal_has_user_defined()) { +inline void DerivationExpression::_internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + if (!_internal_has_user_defined_pointer()) { clear_kind(); - set_has_user_defined(); - kind_.user_defined_ = CreateMaybeMessage< ::io::substrait::Extensions_TypeId >(GetArena()); + set_has_user_defined_pointer(); } - return kind_.user_defined_; + kind_.user_defined_pointer_ = value; } -inline ::io::substrait::Extensions_TypeId* DerivationExpression::mutable_user_defined() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.user_defined) - return _internal_mutable_user_defined(); +inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression::user_defined_pointer() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.user_defined_pointer) + return _internal_user_defined_pointer(); +} +inline void DerivationExpression::set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_user_defined_pointer(value); + // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.user_defined_pointer) } // string type_parameter_name = 33; @@ -7130,6 +7242,79 @@ inline ::io::substrait::DerivationExpression_IfElse* DerivationExpression::mutab return _internal_mutable_if_else(); } +// .io.substrait.DerivationExpression.ReturnProgram return_program = 39; +inline bool DerivationExpression::_internal_has_return_program() const { + return kind_case() == kReturnProgram; +} +inline bool DerivationExpression::has_return_program() const { + return _internal_has_return_program(); +} +inline void DerivationExpression::set_has_return_program() { + _oneof_case_[0] = kReturnProgram; +} +inline void DerivationExpression::clear_return_program() { + if (_internal_has_return_program()) { + if (GetArena() == nullptr) { + delete kind_.return_program_; + } + clear_has_kind(); + } +} +inline ::io::substrait::DerivationExpression_ReturnProgram* DerivationExpression::release_return_program() { + // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.return_program) + if (_internal_has_return_program()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + kind_.return_program_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::io::substrait::DerivationExpression_ReturnProgram& DerivationExpression::_internal_return_program() const { + return _internal_has_return_program() + ? *kind_.return_program_ + : reinterpret_cast< ::io::substrait::DerivationExpression_ReturnProgram&>(::io::substrait::_DerivationExpression_ReturnProgram_default_instance_); +} +inline const ::io::substrait::DerivationExpression_ReturnProgram& DerivationExpression::return_program() const { + // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.return_program) + return _internal_return_program(); +} +inline ::io::substrait::DerivationExpression_ReturnProgram* DerivationExpression::unsafe_arena_release_return_program() { + // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.return_program) + if (_internal_has_return_program()) { + clear_has_kind(); + ::io::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_; + kind_.return_program_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void DerivationExpression::unsafe_arena_set_allocated_return_program(::io::substrait::DerivationExpression_ReturnProgram* return_program) { + clear_kind(); + if (return_program) { + set_has_return_program(); + kind_.return_program_ = return_program; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.return_program) +} +inline ::io::substrait::DerivationExpression_ReturnProgram* DerivationExpression::_internal_mutable_return_program() { + if (!_internal_has_return_program()) { + clear_kind(); + set_has_return_program(); + kind_.return_program_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ReturnProgram >(GetArena()); + } + return kind_.return_program_; +} +inline ::io::substrait::DerivationExpression_ReturnProgram* DerivationExpression::mutable_return_program() { + // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.return_program) + return _internal_mutable_return_program(); +} + inline bool DerivationExpression::has_kind() const { return kind_case() != KIND_NOT_SET; } @@ -7164,6 +7349,10 @@ inline DerivationExpression::KindCase DerivationExpression::kind_case() const { // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) From 5c69fb187d7b20359837784690fd592fc436305e Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Wed, 1 Dec 2021 15:53:52 -0500 Subject: [PATCH 010/113] finish catching up with substrait's new field references --- .../engine/substrait/expression_internal.cc | 88 +++++++++---------- cpp/src/arrow/engine/substrait/serde.cc | 4 +- cpp/src/arrow/engine/substrait/serde_test.cc | 6 ++ .../arrow/engine/substrait/type_internal.cc | 2 +- 4 files changed, 52 insertions(+), 48 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index b2b6eb7fea4..aa28167c311 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -61,7 +61,7 @@ Result FromProto(const st::Expression& expr) { util::optional root_expr; if (expr.selection().has_expression()) { - ARROW_ASSIGN_OR_RAISE(*root_expr, FromProto(expr.selection().expression())); + ARROW_ASSIGN_OR_RAISE(root_expr, FromProto(expr.selection().expression())); } const auto& ref = expr.selection().direct_reference(); @@ -529,32 +529,33 @@ Result> ToProto(const compute::Expression& expr) } if (auto param = expr.parameter()) { - /* - DCHECK(!param->indices.empty()); - for (int i : param->indices) { - } + // Special case of a nested StructField + DCHECK(!param->indices.empty()); + auto out = internal::make_unique(); - std::unique_ptr ref_segment; + for (auto it = param->indices.rbegin(); it != param->indices.rend(); ++it) { + auto struct_field = + internal::make_unique(); + struct_field->set_field(*it); - for (auto it = param->indices.rbegin(); it != param->indices.rend(); ++it) { - auto struct_field = internal::make_unique(); + auto ref_segment = internal::make_unique(); + ref_segment->set_allocated_struct_field(struct_field.release()); - if (ref_segment) { - struct_field->set_allocated_child(ref_segment.release()); - } - struct_field->set_field(*it); + auto selection = internal::make_unique(); + selection->set_allocated_direct_reference(ref_segment.release()); - ref_segment = internal::make_unique(); - ref_segment->set_allocated_struct_field(struct_field.release()); - } + if (out->has_selection()) { + selection->set_allocated_expression(out.release()); + out = internal::make_unique(); + } else { + selection->set_allocated_root_reference( + new st::Expression::FieldReference::RootReference()); + } - auto field_ref = internal::make_unique(); - field_ref->set_allocated_direct_reference(ref_segment.release()); + out->set_allocated_selection(selection.release()); + } - auto out = internal::make_unique(); - out->set_allocated_selection(field_ref.release()); - return std::move(out); - */ + return std::move(out); } auto call = CallNotNull(expr); @@ -566,30 +567,27 @@ Result> ToProto(const compute::Expression& expr) } if (call->function_name == "list_element") { - /* - // catch the special case of calls convertible to a ListElement - if (arguments[0]->has_selection() && - arguments[0]->selection().has_direct_reference()) { - if (arguments[1]->has_literal() && arguments[1]->literal().has_i32()) { - auto list_element = - internal::make_unique(); - - list_element->set_allocated_child( - arguments[0]->mutable_selection()->release_direct_reference()); - list_element->set_offset(arguments[1]->literal().i32()); - - auto ref_segment = internal::make_unique(); - ref_segment->set_allocated_list_element(list_element.release()); - - auto field_ref = internal::make_unique(); - field_ref->set_allocated_direct_reference(ref_segment.release()); - - auto out = std::move(arguments[0]); // reuse an emptied st::Expression - out->set_allocated_selection(field_ref.release()); - return std::move(out); - } - } - */ + // catch the special case of calls convertible to a ListElement + if (arguments[0]->has_selection() && + arguments[0]->selection().has_direct_reference()) { + if (arguments[1]->has_literal() && arguments[1]->literal().has_i32()) { + auto list_element = + internal::make_unique(); + + list_element->set_offset(arguments[1]->literal().i32()); + + auto ref_segment = internal::make_unique(); + ref_segment->set_allocated_list_element(list_element.release()); + + auto field_ref = internal::make_unique(); + field_ref->set_allocated_direct_reference(ref_segment.release()); + field_ref->set_allocated_expression(arguments[0].release()); + + auto out = internal::make_unique(); + out->set_allocated_selection(field_ref.release()); + return std::move(out); + } + } } if (call->function_name == "if_else") { diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc index 2c4304c4e79..3fe331c96bc 100644 --- a/cpp/src/arrow/engine/substrait/serde.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -55,7 +55,7 @@ Result ParseFromBuffer(const Buffer& buf) { return message; } -Result Convert(const st::Rel& relation) { +Result Convert(const st::PlanRel& relation) { return Status::NotImplemented(""); } @@ -72,7 +72,7 @@ Result> ConvertPlan(const Buffer& buf) { } Result> DeserializeSchema(const Buffer& buf) { - ARROW_ASSIGN_OR_RAISE(auto named_struct, ParseFromBuffer(buf)); + ARROW_ASSIGN_OR_RAISE(auto named_struct, ParseFromBuffer(buf)); return FromProto(named_struct); } diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 5b8d2dac7e0..700f61eecfe 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -39,6 +39,7 @@ const std::shared_ptr kBoringSchema = schema({ field("f64", float64()), field("date64", date64()), field("str", utf8()), + field("list_i32", list(int32())), field("struct_i32_str", struct_({ field("i32", int32()), field("str", utf8()), @@ -200,6 +201,11 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { compute::field_ref({"struct_i32_str", 1}), compute::field_ref("str"), }), + compute::call("list_element", + { + compute::field_ref("list_i32"), + compute::literal(3), + }), }) { ARROW_SCOPED_TRACE(expr.ToString()); ASSERT_OK_AND_ASSIGN(expr, expr.Bind(*kBoringSchema)); diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 8cf5da3fe63..645db3b839e 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -35,7 +35,7 @@ namespace { template Status CheckVariation(const TypeMessage& type) { - if (type.type_variation_reference() != 0) return Status::OK(); + if (type.type_variation_reference() == 0) return Status::OK(); return Status::NotImplemented("Type variations for ", type.DebugString()); } From 2a77d2807e6f1516db5643f1d92f3c081fdd0a3c Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Wed, 1 Dec 2021 18:15:32 -0500 Subject: [PATCH 011/113] add SubstraitFromJSON --- cpp/src/arrow/engine/substrait/serde_test.cc | 77 ++++++++++++++++++++ 1 file changed, 77 insertions(+) diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 700f61eecfe..978eed49cfb 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -17,6 +17,9 @@ #include "arrow/engine/substrait/serde.h" +#include +#include +#include #include #include "arrow/compute/exec/expression_internal.h" @@ -69,6 +72,80 @@ inline compute::Expression UseBoringRefs(const compute::Expression& expr) { return compute::Expression{std::move(modified_call)}; } +google::protobuf::util::TypeResolver* GetGeneratedTypeResolver() { + static std::unique_ptr type_resolver; + if (!type_resolver) { + type_resolver.reset(google::protobuf::util::NewTypeResolverForDescriptorPool( + /*url_prefix=*/"", google::protobuf::DescriptorPool::generated_pool())); + } + return type_resolver.get(); +} + +std::shared_ptr SubstraitFromJSON(util::string_view json, + util::string_view type_name) { + std::string type_url = "/io.substrait." + type_name.to_string(); + + google::protobuf::io::ArrayInputStream json_stream{json.data(), + static_cast(json.size())}; + + std::string out; + google::protobuf::io::StringOutputStream out_stream{&out}; + + auto status = google::protobuf::util::JsonToBinaryStream( + GetGeneratedTypeResolver(), type_url, &json_stream, &out_stream); + DCHECK(status.ok()) << "JsonToBinaryStream returned " << status; + + return Buffer::FromString(std::move(out)); +} + +TEST(Substrait, BasicTypeFromJSON) { + auto ExpectEq = [](util::string_view json, std::shared_ptr expected_type) { + ARROW_SCOPED_TRACE(expected_type->ToString()); + + auto buf = SubstraitFromJSON(json, "Type"); + ASSERT_OK_AND_ASSIGN(auto actual, DeserializeType(*buf)); + + ASSERT_EQ(*actual, *expected_type); + }; + + ExpectEq(R"({"bool": {}})", boolean()); + + ExpectEq(R"({"i8": {}})", int8()); + ExpectEq(R"({"i16": {}})", int16()); + ExpectEq(R"({"i32": {}})", int32()); + ExpectEq(R"({"i64": {}})", int64()); + + ExpectEq(R"({"fp32": {}})", float32()); + ExpectEq(R"({"fp64": {}})", float64()); + + ExpectEq(R"({"string": {}})", utf8()); + ExpectEq(R"({"binary": {}})", binary()); + + ExpectEq(R"({"timestamp": {}})", timestamp(TimeUnit::MICRO)); + ExpectEq(R"({"date": {}})", date32()); + ExpectEq(R"({"time": {}})", time64(TimeUnit::MICRO)); + ExpectEq(R"({"timestamp_tz": {}})", timestamp(TimeUnit::MICRO, "UTC")); + + ExpectEq(R"({"uuid": {}})", uuid()); + + ExpectEq(R"({"fixed_char": {"length": 32}})", fixed_char(32)); + ExpectEq(R"({"varchar": {"length": 1024}})", varchar(1024)); + ExpectEq(R"({"fixed_binary": {"length": 32}})", fixed_size_binary(32)); + + ExpectEq(R"({"decimal": {"precision": 27, "scale": 5}})", decimal128(27, 5)); + + ExpectEq(R"({"struct": { + "types": [ + {"i64": {}}, + {"list": {"type": {"string":{}} }} + ] + }})", + struct_({ + field("", int64()), + field("", list(utf8())), + })); +} + TEST(Substrait, BasicTypeRoundTrip) { for (auto type : { boolean(), From a5c25defc9cfb6808677b38a8918c4ace1226ca7 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 3 Dec 2021 15:17:10 -0500 Subject: [PATCH 012/113] port more tests to JSON --- cpp/src/arrow/array/array_base.h | 5 +- cpp/src/arrow/datum.h | 7 + .../engine/simple_extension_type_internal.h | 2 + .../engine/substrait/expression_internal.cc | 105 +++++---- cpp/src/arrow/engine/substrait/serde_test.cc | 210 +++++++++++++----- cpp/src/arrow/scalar.h | 5 + cpp/src/arrow/testing/matchers.h | 13 +- 7 files changed, 253 insertions(+), 94 deletions(-) diff --git a/cpp/src/arrow/array/array_base.h b/cpp/src/arrow/array/array_base.h index b6b769cf033..63044c419cd 100644 --- a/cpp/src/arrow/array/array_base.h +++ b/cpp/src/arrow/array/array_base.h @@ -187,10 +187,11 @@ class ARROW_EXPORT Array { Status ValidateFull() const; protected: - Array() : null_bitmap_data_(NULLPTR) {} + Array() = default; + ARROW_DEFAULT_MOVE_AND_ASSIGN(Array); std::shared_ptr data_; - const uint8_t* null_bitmap_data_; + const uint8_t* null_bitmap_data_ = NULLPTR; /// Protected method for constructors void SetData(const std::shared_ptr& data) { diff --git a/cpp/src/arrow/datum.h b/cpp/src/arrow/datum.h index 514b4247316..45e0d682fa9 100644 --- a/cpp/src/arrow/datum.h +++ b/cpp/src/arrow/datum.h @@ -153,6 +153,13 @@ struct ARROW_EXPORT Datum { : Datum(std::shared_ptr::type>( value)) {} + // Cast from subtypes of Array or Scalar to Datum + template ::value, + bool IsScalar = std::is_base_of::value, + typename = enable_if_t> + Datum(T&& value) // NOLINT implicit conversion + : Datum(std::make_shared(std::move(value))) {} + // Convenience constructors explicit Datum(bool value); explicit Datum(int8_t value); diff --git a/cpp/src/arrow/engine/simple_extension_type_internal.h b/cpp/src/arrow/engine/simple_extension_type_internal.h index a236ba6eb49..2c370e42d62 100644 --- a/cpp/src/arrow/engine/simple_extension_type_internal.h +++ b/cpp/src/arrow/engine/simple_extension_type_internal.h @@ -58,6 +58,8 @@ class SimpleExtensionType : public ExtensionType { std::string extension_name() const override { return kExtensionName.to_string(); } + std::string ToString() const override { return "extension<" + this->Serialize() + ">"; } + struct ExtensionEqualsImpl { ExtensionEqualsImpl(const Params& l, const Params& r) : left_(l), right_(r) { kProperties.ForEach(*this); diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index aa28167c311..2c1de9f6540 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -122,6 +122,13 @@ Result FromProto(const st::Expression& expr) { } Result FromProto(const st::Expression::Literal& lit) { + if (lit.nullable()) { + // FIXME not sure how this field should be interpreted and there's no way to round + // trip it through arrow + return Status::Invalid( + "Nullable Literals - Literal.nullable must be left at the default"); + } + switch (lit.literal_type_case()) { case st::Expression::Literal::kBoolean: return Datum(lit.boolean()); @@ -143,43 +150,40 @@ Result FromProto(const st::Expression::Literal& lit) { case st::Expression::Literal::kString: return Datum(lit.string()); case st::Expression::Literal::kBinary: - return Datum(std::make_shared(Buffer::FromString(lit.binary()))); + return Datum(BinaryScalar(Buffer::FromString(lit.binary()))); case st::Expression::Literal::kTimestamp: - return Datum(std::make_shared( - static_cast(lit.timestamp()), TimeUnit::MICRO)); + return Datum( + TimestampScalar(static_cast(lit.timestamp()), TimeUnit::MICRO)); case st::Expression::Literal::kTimestampTz: - return Datum(std::make_shared( - static_cast(lit.timestamp_tz()), TimeUnit::MICRO, - TimestampTzTimezoneString())); + return Datum(TimestampScalar(static_cast(lit.timestamp_tz()), + TimeUnit::MICRO, TimestampTzTimezoneString())); case st::Expression::Literal::kDate: - return Datum(std::make_shared(static_cast(lit.date()))); + return Datum(Date32Scalar(static_cast(lit.date()))); case st::Expression::Literal::kTime: - return Datum(std::make_shared(static_cast(lit.time()), - TimeUnit::MICRO)); + return Datum(Time64Scalar(static_cast(lit.time()), TimeUnit::MICRO)); case st::Expression::Literal::kIntervalYearToMonth: case st::Expression::Literal::kIntervalDayToSecond: break; case st::Expression::Literal::kUuid: - return Datum(std::make_shared( - FixedSizeBinaryScalarFromBytes(lit.uuid()), uuid())); + return Datum(ExtensionScalar(FixedSizeBinaryScalarFromBytes(lit.uuid()), uuid())); case st::Expression::Literal::kFixedChar: - return Datum(std::make_shared( - FixedSizeBinaryScalarFromBytes(lit.fixed_char()), - fixed_char(static_cast(lit.fixed_char().size())))); + return Datum( + ExtensionScalar(FixedSizeBinaryScalarFromBytes(lit.fixed_char()), + fixed_char(static_cast(lit.fixed_char().size())))); case st::Expression::Literal::kVarChar: - return Datum(std::make_shared( - std::make_shared(lit.var_char().value()), - varchar(static_cast(lit.var_char().length())))); + return Datum( + ExtensionScalar(StringScalar(lit.var_char().value()), + varchar(static_cast(lit.var_char().length())))); case st::Expression::Literal::kFixedBinary: - return Datum(FixedSizeBinaryScalarFromBytes(lit.fixed_char())); + return Datum(FixedSizeBinaryScalarFromBytes(lit.fixed_binary())); case st::Expression::Literal::kDecimal: { if (lit.decimal().value().size() != sizeof(Decimal128)) { @@ -195,7 +199,7 @@ Result FromProto(const st::Expression::Literal& lit) { value.mutable_native_endian_bytes() + sizeof(Decimal128)); #endif auto type = decimal128(lit.decimal().precision(), lit.decimal().scale()); - return Datum(std::make_shared(value, std::move(type))); + return Datum(Decimal128Scalar(value, std::move(type))); } case st::Expression::Literal::kStruct: { @@ -206,7 +210,7 @@ Result FromProto(const st::Expression::Literal& lit) { for (size_t i = 0; i < fields.size(); ++i) { ARROW_ASSIGN_OR_RAISE(auto field, FromProto(struct_.fields(i))); DCHECK(field.is_scalar()); - fields.push_back(field.scalar()); + fields[i] = field.scalar(); } ARROW_ASSIGN_OR_RAISE( auto scalar, StructScalar::Make(std::move(fields), std::move(field_names))); @@ -230,7 +234,7 @@ Result FromProto(const st::Expression::Literal& lit) { for (size_t i = 0; i < values.size(); ++i) { ARROW_ASSIGN_OR_RAISE(auto value, FromProto(list.values(i))); DCHECK(value.is_scalar()); - values.push_back(value.scalar()); + values[i] = value.scalar(); if (element_type) { if (!value.type()->Equals(*element_type)) { return Status::Invalid(list.DebugString(), @@ -244,7 +248,7 @@ Result FromProto(const st::Expression::Literal& lit) { ARROW_ASSIGN_OR_RAISE(auto builder, MakeBuilder(element_type)); RETURN_NOT_OK(builder->AppendScalars(values)); ARROW_ASSIGN_OR_RAISE(auto arr, builder->Finish()); - return Datum(std::make_shared(std::move(arr))); + return Datum(ListScalar(std::move(arr))); } case st::Expression::Literal::kMap: { @@ -280,8 +284,8 @@ Result FromProto(const st::Expression::Literal& lit) { DCHECK(key.is_scalar()); DCHECK(value.is_scalar()); - keys.push_back(key.scalar()); - values.push_back(value.scalar()); + keys[i] = key.scalar(); + values[i] = value.scalar(); if (key_type) { if (!key.type()->Equals(*key_type)) { @@ -341,14 +345,14 @@ struct ToProtoImpl { template Status Primitive(void (st::Expression::Literal::*set)(Arg), const PrimitiveScalar& primitive_scalar) { - (type_->*set)(static_cast(primitive_scalar.value)); + (lit_->*set)(static_cast(primitive_scalar.value)); return Status::OK(); } template Status FromBuffer(void (st::Expression::Literal::*set)(std::string&&), const ScalarWithBufferValue& scalar_with_buffer) { - (type_->*set)(util::string_view{*scalar_with_buffer.value}.to_string()); + (lit_->*set)(scalar_with_buffer.value->ToString()); return Status::OK(); } @@ -403,13 +407,33 @@ struct ToProtoImpl { Status Visit(const MonthIntervalScalar& s) { return NotImplemented(s); } Status Visit(const DayTimeIntervalScalar& s) { return NotImplemented(s); } - Status Visit(const Decimal128Scalar& s) { return NotImplemented(s); } + Status Visit(const Decimal128Scalar& s) { + auto decimal = internal::make_unique(); + + auto decimal_type = internal::checked_cast(s.type.get()); + decimal->set_precision(decimal_type->precision()); + decimal->set_scale(decimal_type->scale()); + + decimal->set_value(reinterpret_cast(s.value.native_endian_bytes()), + sizeof(Decimal128)); +#if !ARROW_LITTLE_ENDIAN + std::reverse(decimal->mutable_value()->begin(), decimal->mutable_value()->end()); +#endif + lit_->set_allocated_decimal(decimal.release()); + return Status::OK(); + } + Status Visit(const Decimal256Scalar& s) { return NotImplemented(s); } Status Visit(const ListScalar& s) { - type_->set_allocated_list(new Lit::List()); + lit_->set_allocated_list(new Lit::List()); + + ARROW_ASSIGN_OR_RAISE( + auto element_type, + ToProto(*internal::checked_cast(*s.type).value_type())); + lit_->mutable_list()->set_allocated_element_type(element_type.release()); - auto values = type_->mutable_list()->mutable_values(); + auto values = lit_->mutable_list()->mutable_values(); values->Reserve(static_cast(s.value->length())); for (int64_t i = 0; i < s.value->length(); ++i) { @@ -421,9 +445,9 @@ struct ToProtoImpl { } Status Visit(const StructScalar& s) { - type_->set_allocated_struct_(new Lit::Struct()); + lit_->set_allocated_struct_(new Lit::Struct()); - auto fields = type_->mutable_struct_()->mutable_fields(); + auto fields = lit_->mutable_struct_()->mutable_fields(); fields->Reserve(static_cast(s.value.size())); for (Datum field : s.value) { @@ -438,11 +462,11 @@ struct ToProtoImpl { Status Visit(const DictionaryScalar& s) { return NotImplemented(s); } Status Visit(const MapScalar& s) { - type_->set_allocated_map(new Lit::Map()); + lit_->set_allocated_map(new Lit::Map()); const auto& kv_arr = internal::checked_cast(*s.value); - auto key_values = type_->mutable_map()->mutable_key_values(); + auto key_values = lit_->mutable_map()->mutable_key_values(); key_values->Reserve(static_cast(kv_arr.length())); for (int64_t i = 0; i < s.value->length(); ++i) { @@ -468,13 +492,18 @@ struct ToProtoImpl { } if (UnwrapFixedChar(*s.type)) { - return FromBuffer(&Lit::set_uuid, + return FromBuffer(&Lit::set_fixed_char, internal::checked_cast(*s.value)); } - if (UnwrapVarChar(*s.type)) { - return FromBuffer(&Lit::set_uuid, - internal::checked_cast(*s.value)); + if (auto length = UnwrapVarChar(*s.type)) { + auto var_char = internal::make_unique(); + var_char->set_length(*length); + var_char->set_value( + internal::checked_cast(*s.value).value->ToString()); + + lit_->set_allocated_var_char(var_char.release()); + return Status::OK(); } return NotImplemented(s); @@ -494,7 +523,7 @@ struct ToProtoImpl { Status operator()(const Scalar& scalar) { return VisitScalarInline(scalar, this); } - st::Expression::Literal* type_; + st::Expression::Literal* lit_; }; } // namespace diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 978eed49cfb..b2aa37a105f 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -52,6 +52,22 @@ const std::shared_ptr kBoringSchema = schema({ field("ts_ns", timestamp(TimeUnit::NANO)), }); +std::shared_ptr StripFieldNames(std::shared_ptr type) { + if (type->id() == Type::STRUCT) { + FieldVector fields(type->num_fields()); + for (size_t i = 0; i < fields.size(); ++i) { + fields[i] = type->field(i)->WithName(""); + } + return struct_(std::move(fields)); + } + + if (type->id() == Type::LIST) { + return list(type->field(0)->WithName("")); + } + + return type; +} + // map to an index-only field reference inline FieldRef BoringRef(FieldRef ref) { auto path = *ref.FindOne(*kBoringSchema); @@ -81,8 +97,8 @@ google::protobuf::util::TypeResolver* GetGeneratedTypeResolver() { return type_resolver.get(); } -std::shared_ptr SubstraitFromJSON(util::string_view json, - util::string_view type_name) { +std::shared_ptr SubstraitFromJSON(util::string_view type_name, + util::string_view json) { std::string type_url = "/io.substrait." + type_name.to_string(); google::protobuf::io::ArrayInputStream json_stream{json.data(), @@ -98,14 +114,35 @@ std::shared_ptr SubstraitFromJSON(util::string_view json, return Buffer::FromString(std::move(out)); } -TEST(Substrait, BasicTypeFromJSON) { +std::string SubstraitToJSON(util::string_view type_name, const Buffer& buf) { + std::string type_url = "/io.substrait." + type_name.to_string(); + + google::protobuf::io::ArrayInputStream buf_stream{buf.data(), + static_cast(buf.size())}; + + std::string out; + google::protobuf::io::StringOutputStream out_stream{&out}; + + auto status = google::protobuf::util::BinaryToJsonStream( + GetGeneratedTypeResolver(), type_url, &buf_stream, &out_stream); + DCHECK(status.ok()) << "BinaryToJsonStream returned " << status; + + return out; +} + +TEST(Substrait, SupportedTypes) { auto ExpectEq = [](util::string_view json, std::shared_ptr expected_type) { - ARROW_SCOPED_TRACE(expected_type->ToString()); + ARROW_SCOPED_TRACE(json); - auto buf = SubstraitFromJSON(json, "Type"); - ASSERT_OK_AND_ASSIGN(auto actual, DeserializeType(*buf)); + auto buf = SubstraitFromJSON("Type", json); + ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf)); - ASSERT_EQ(*actual, *expected_type); + EXPECT_EQ(*type, *expected_type); + + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type)); + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized)); + + EXPECT_EQ(*roundtripped, *expected_type); }; ExpectEq(R"({"bool": {}})", boolean()); @@ -146,42 +183,19 @@ TEST(Substrait, BasicTypeFromJSON) { })); } -TEST(Substrait, BasicTypeRoundTrip) { - for (auto type : { - boolean(), - - int8(), - int16(), - int32(), - int64(), - - float32(), - float64(), - - date32(), - timestamp(TimeUnit::MICRO), - timestamp(TimeUnit::MICRO, "UTC"), - time64(TimeUnit::MICRO), - - decimal128(27, 5), - - struct_({ - field("", int64()), - field("", list(utf8())), - }), - - uuid(), - fixed_char(32), - varchar(1024), +TEST(Substrait, NoEquivalentArrowType) { + for (util::string_view json : { + R"({"interval_year": {}})", + R"({"interval_day": {}})", + R"({"user_defined_type_reference": 99})", }) { - ARROW_SCOPED_TRACE(type->ToString()); - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type)); - ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized)); - EXPECT_EQ(*roundtripped, *type); + ARROW_SCOPED_TRACE(json); + auto buf = SubstraitFromJSON("Type", json); + ASSERT_THAT(DeserializeType(*buf), Raises(StatusCode::NotImplemented)); } } -TEST(Substrait, UnsupportedTypes) { +TEST(Substrait, NoEquivalentSubstraitType) { for (auto type : { uint8(), uint16(), @@ -221,23 +235,115 @@ TEST(Substrait, UnsupportedTypes) { } } -TEST(Substrait, BasicLiteralRoundTrip) { - for (Datum datum : { - Datum(true), +TEST(Substrait, SupportedLiterals) { + auto ExpectEq = [](util::string_view json, Datum expected_value) { + ARROW_SCOPED_TRACE(json); - Datum(int8_t(34)), - Datum(int16_t(34)), - Datum(int32_t(34)), - Datum(int64_t(34)), + auto buf = SubstraitFromJSON("Expression", "{\"literal\":" + json.to_string() + "}"); + ASSERT_OK_AND_ASSIGN(auto expr, DeserializeExpression(*buf)); - Datum(3.5F), - Datum(7.125), - }) { - ARROW_SCOPED_TRACE(datum.scalar()->ToString()); - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(compute::literal(datum))); + ASSERT_TRUE(expr.literal()); + ASSERT_THAT(*expr.literal(), DataEq(expected_value)); + + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized)); + ASSERT_TRUE(roundtripped.literal()); - EXPECT_THAT(*roundtripped.literal(), DataEq(datum)); + ASSERT_THAT(*roundtripped.literal(), DataEq(expected_value)); + }; + + ExpectEq(R"({"boolean": true})", Datum(true)); + + ExpectEq(R"({"i8": 34})", Datum(int8_t(34))); + ExpectEq(R"({"i16": 34})", Datum(int16_t(34))); + ExpectEq(R"({"i32": 34})", Datum(int32_t(34))); + ExpectEq(R"({"i64": "34"})", Datum(int64_t(34))); + + ExpectEq(R"({"fp32": 3.5})", Datum(3.5F)); + ExpectEq(R"({"fp64": 7.125})", Datum(7.125)); + + ExpectEq(R"({"string": "hello world"})", Datum("hello world")); + + ExpectEq(R"({"binary": "enp6"})", BinaryScalar(Buffer::FromString("zzz"))); + + ExpectEq(R"({"timestamp": "579"})", TimestampScalar(579, TimeUnit::MICRO)); + + /* + constexpr int64_t kDayFiveOfEpoch = 24 * 60 * 60 * 1000 * 5; + static_assert(kDayFiveOfEpoch == 432000000, "until c++ gets string interpolation"); + ExpectEq(R"({"date": "432000000"})", TimestampScalar(kDayFiveOfEpoch, + TimeUnit::MICRO)); + */ + + ExpectEq(R"({"time": "64"})", Time64Scalar(64, TimeUnit::MICRO)); + + ExpectEq(R"({"fixed_char": "zzz"})", + ExtensionScalar( + FixedSizeBinaryScalar(Buffer::FromString("zzz"), fixed_size_binary(3)), + fixed_char(3))); + + ExpectEq(R"({"var_char": {"value": "zzz", "length": 1024}})", + ExtensionScalar(StringScalar("zzz"), varchar(1024))); + + ExpectEq(R"({"fixed_binary": "enp6"})", + FixedSizeBinaryScalar(Buffer::FromString("zzz"), fixed_size_binary(3))); + + ExpectEq( + R"({"decimal": {"value": "0gKWSQAAAAAAAAAAAAAAAA==", "precision": 27, "scale": 5}})", + Decimal128Scalar(Decimal128("123456789.0"), decimal128(27, 5))); + + ExpectEq(R"({"timestamp_tz": "579"})", TimestampScalar(579, TimeUnit::MICRO, "UTC")); + + // special case for empty lists + ExpectEq(R"({"list": {"element_type": {"i32": {}}, "values": []}})", + ScalarFromJSON(list(int32()), "[]")); + + ExpectEq(R"({"struct": { + "fields": [ + {"i64": "32"}, + {"list": {"values": [ + {"string": "hello"}, + {"string": "world"} + ]}} + ] + }})", + ScalarFromJSON(struct_({ + field("", int64()), + field("", list(utf8())), + }), + R"([32, ["hello", "world"]])")); + + // check null scalars: + for (const auto& field : kBoringSchema->fields()) { + auto maybe_type_buf = SerializeType(*field->type()); + if (!maybe_type_buf.ok()) continue; + + ExpectEq("{\"null\": " + SubstraitToJSON("Type", **maybe_type_buf) + "}", + MakeNullScalar(field->type())); + } +} + +TEST(Substrait, CannotDeserializeLiteral) { + // Invalid: missing List.element_type + EXPECT_THAT(DeserializeExpression(*SubstraitFromJSON( + "Expression", R"({"literal": {"list": {"values": []}}})")), + Raises(StatusCode::Invalid)); + + // Invalid: required null literal + EXPECT_THAT(DeserializeExpression(*SubstraitFromJSON( + "Expression", + R"({"literal": {"null": {"bool": {"nullability": "REQUIRED"}}}})")), + Raises(StatusCode::Invalid)); + + // no equivalent arrow scalar + for (util::string_view json : { + R"({"interval_year_to_month": {"years": 3, "months": 2}})", + R"({"interval_day_to_second": {"days": 3, "seconds": 2}})", + // FIXME no way to specify scalars of user_defined_type_reference + }) { + ARROW_SCOPED_TRACE(json); + auto buf = SubstraitFromJSON("Expression", "{\"literal\": " + json.to_string() + "}"); + ASSERT_THAT(DeserializeExpression(*buf), Raises(StatusCode::NotImplemented)); } } diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h index a4cda58b87b..e5a398b7014 100644 --- a/cpp/src/arrow/scalar.h +++ b/cpp/src/arrow/scalar.h @@ -533,6 +533,11 @@ struct ARROW_EXPORT ExtensionScalar : public Scalar { ExtensionScalar(std::shared_ptr storage, std::shared_ptr type) : Scalar(std::move(type), true), value(std::move(storage)) {} + template ::value>> + ExtensionScalar(Storage&& storage, std::shared_ptr type) + : ExtensionScalar(std::make_shared(std::move(storage)), std::move(type)) {} + std::shared_ptr value; }; diff --git a/cpp/src/arrow/testing/matchers.h b/cpp/src/arrow/testing/matchers.h index 998e45e3078..69622b30477 100644 --- a/cpp/src/arrow/testing/matchers.h +++ b/cpp/src/arrow/testing/matchers.h @@ -27,6 +27,7 @@ #include "arrow/testing/future_util.h" #include "arrow/testing/gtest_util.h" #include "arrow/util/future.h" +#include "arrow/util/unreachable.h" namespace arrow { @@ -196,8 +197,14 @@ class ErrorMatcher { message_matcher_->MatchAndExplain(status.message(), &value_listener); } - *listener << "whose value " << testing::PrintToString(status.ToString()) - << (match ? " matches" : " doesn't match"); + if (match) { + *listener << "whose error matches"; + } else if (status.ok()) { + *listener << "whose value doesn't match"; + } else { + *listener << "whose error doesn't match"; + } + testing::internal::PrintIfNotEmpty(value_listener.str(), listener->stream()); return match; } @@ -307,6 +314,8 @@ class DataEqMatcher { << expected_.schema()->ToString(); return false; } + } else { + Unreachable(); } const bool match = boxed == expected_; From 873ec2381664748cd26ed1ce8476b5b1036f11e8 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Mon, 6 Dec 2021 15:03:01 -0500 Subject: [PATCH 013/113] add more DataEq matchers --- cpp/src/arrow/testing/gtest_util.h | 22 +++++++++ cpp/src/arrow/testing/matchers.h | 76 ++++++++++++++++++++++++++++-- cpp/src/arrow/type.h | 20 +++++++- 3 files changed, 112 insertions(+), 6 deletions(-) diff --git a/cpp/src/arrow/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h index c8cb6af986e..df863c43a7f 100644 --- a/cpp/src/arrow/testing/gtest_util.h +++ b/cpp/src/arrow/testing/gtest_util.h @@ -527,6 +527,28 @@ class ARROW_TESTING_EXPORT GatingTask { std::shared_ptr impl_; }; +template +void PrintTo(const std::shared_ptr& ptr, std::ostream* os) { + if (ptr) { + *os << "{"; + ::testing::internal::UniversalPrint(*ptr, os); + *os << "}"; + } else { + *os << "nullptr"; + } +} + +template +void PrintTo(const std::unique_ptr& ptr, std::ostream* os) { + if (ptr) { + *os << "{"; + ::testing::internal::UniversalPrint(*ptr, os); + *os << "}"; + } else { + *os << "nullptr"; + } +} + } // namespace arrow namespace nonstd { diff --git a/cpp/src/arrow/testing/matchers.h b/cpp/src/arrow/testing/matchers.h index 69622b30477..5c57b4602dd 100644 --- a/cpp/src/arrow/testing/matchers.h +++ b/cpp/src/arrow/testing/matchers.h @@ -275,6 +275,9 @@ ErrorMatcher Raises(StatusCode code, const MessageMatcher& message_matcher) { class DataEqMatcher { public: + // TODO(bkietz) support EqualOptions, ApproxEquals, etc + // Probably it's better to use something like config-through-key_value_metadata + // as with the random generators to decouple this from EqualOptions etc. explicit DataEqMatcher(Datum expected) : expected_(std::move(expected)) {} template @@ -318,11 +321,18 @@ class DataEqMatcher { Unreachable(); } - const bool match = boxed == expected_; - *listener << "whose value "; - if (listener->IsInterested()) PrintTo(boxed, listener->stream()); - *listener << (match ? " matches" : " doesn't match"); - return match; + if (boxed == expected_) { + *listener << "whose value matches"; + return true; + } + + if (listener->IsInterested() && boxed.kind() == Datum::ARRAY) { + *listener << "whose value differs from the expected value by " + << boxed.make_array()->Diff(*expected_.make_array()); + } else { + *listener << "whose value doesn't match"; + } + return false; } Datum expected_; @@ -335,9 +345,65 @@ class DataEqMatcher { Datum expected_; }; +/// Constructs a datum against which arguments are matched template DataEqMatcher DataEq(Data&& dat) { return DataEqMatcher(Datum(std::forward(dat))); } +/// Constructs an array with ArrayFromJSON against which arguments are matched +inline DataEqMatcher DataEqArray(const std::shared_ptr& type, + util::string_view json) { + return DataEq(ArrayFromJSON(type, json)); +} + +/// Constructs an array from a vector of optionals against which arguments are matched +template < + typename T, typename ArrayType = typename TypeTraits::ArrayType, + typename BuilderType = typename TypeTraits::BuilderType, + typename ValueType = typename stl::detail::DefaultValueAccessor::ValueType> +DataEqMatcher DataEqArray(T type, const std::vector>& values) { + BuilderType builder(std::make_shared(std::move(type)), default_memory_pool()); + DCHECK_OK(builder.Reserve(static_cast(values.size()))); + + // pseudo constexpr: + static const bool need_safe_append = !is_fixed_width(T::type_id); + + for (auto value : values) { + if (value) { + if (need_safe_append) { + builder.UnsafeAppend(*value); + } else { + DCHECK_OK(builder.Append(*value)); + } + } else { + builder.UnsafeAppendNull(); + } + } + + return DataEq(builder.Finish().ValueOrDie()); +} + +/// Constructs a scalar with ScalarFromJSON against which arguments are matched +inline DataEqMatcher DataEqScalar(const std::shared_ptr& type, + util::string_view json) { + return DataEq(ScalarFromJSON(type, json)); +} + +/// Constructs a scalar against which arguments are matched +template ::ScalarType, + typename ValueType = typename ScalarType::ValueType> +DataEqMatcher DataEqScalar(T type, util::optional value) { + ScalarType expected(std::make_shared(std::move(type))); + + if (value) { + expected.is_valid = true; + expected.value = std::move(*value); + } + + return DataEq(std::move(expected)); +} + +// HasType, HasSchema matchers + } // namespace arrow diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h index b3427413180..2383a94bb81 100644 --- a/cpp/src/arrow/type.h +++ b/cpp/src/arrow/type.h @@ -76,6 +76,22 @@ class ARROW_EXPORT Fingerprintable { } protected: + Fingerprintable() = default; + + Fingerprintable(Fingerprintable&& other) { MoveFrom(std::move(other)); } + + Fingerprintable& operator=(Fingerprintable&& other) { + MoveFrom(std::move(other)); + return *this; + } + + void MoveFrom(Fingerprintable&& other) { + fingerprint_.store(other.fingerprint_.load()); + other.fingerprint_.store(NULLPTR); + metadata_fingerprint_.store(other.fingerprint_.load()); + other.metadata_fingerprint_.store(NULLPTR); + } + const std::string& LoadFingerprintSlow() const; const std::string& LoadMetadataFingerprintSlow() const; @@ -128,7 +144,6 @@ struct ARROW_EXPORT DataTypeLayout { /// complex datatypes are usually parametric. class ARROW_EXPORT DataType : public detail::Fingerprintable { public: - explicit DataType(Type::type id) : detail::Fingerprintable(), id_(id) {} ~DataType() override; /// \brief Return whether the types are equal @@ -174,6 +189,9 @@ class ARROW_EXPORT DataType : public detail::Fingerprintable { virtual Type::type storage_id() const { return id_; } protected: + explicit DataType(Type::type id) : detail::Fingerprintable(), id_(id) {} + ARROW_DEFAULT_MOVE_AND_ASSIGN(DataType); + // Dummy version that returns a null string (indicating not implemented). // Subclasses should override for fast equality checks. std::string ComputeFingerprint() const override; From 05be90969eae9bb992c4109746970c8d9c646cdd Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Mon, 6 Dec 2021 15:21:31 -0500 Subject: [PATCH 014/113] use Date64 for substrait::date --- .../arrow/engine/substrait/expression_internal.cc | 6 +++--- cpp/src/arrow/engine/substrait/serde_test.cc | 13 +++++-------- cpp/src/arrow/engine/substrait/type_internal.cc | 13 +++---------- 3 files changed, 11 insertions(+), 21 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 2c1de9f6540..1805c699986 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -161,7 +161,7 @@ Result FromProto(const st::Expression::Literal& lit) { TimeUnit::MICRO, TimestampTzTimezoneString())); case st::Expression::Literal::kDate: - return Datum(Date32Scalar(static_cast(lit.date()))); + return Datum(Date64Scalar(static_cast(lit.date()))); case st::Expression::Literal::kTime: return Datum(Time64Scalar(static_cast(lit.time()), TimeUnit::MICRO)); @@ -379,8 +379,8 @@ struct ToProtoImpl { return FromBuffer(&Lit::set_fixed_binary, s); } - Status Visit(const Date32Scalar& s) { return Primitive(&Lit::set_date, s); } - Status Visit(const Date64Scalar& s) { return NotImplemented(s); } + Status Visit(const Date32Scalar& s) { return NotImplemented(s); } + Status Visit(const Date64Scalar& s) { return Primitive(&Lit::set_date, s); } Status Visit(const TimestampScalar& s) { const auto& t = internal::checked_cast(*s.type); diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index b2aa37a105f..9fa3be4ebd4 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -159,7 +159,7 @@ TEST(Substrait, SupportedTypes) { ExpectEq(R"({"binary": {}})", binary()); ExpectEq(R"({"timestamp": {}})", timestamp(TimeUnit::MICRO)); - ExpectEq(R"({"date": {}})", date32()); + ExpectEq(R"({"date": {}})", date64()); ExpectEq(R"({"time": {}})", time64(TimeUnit::MICRO)); ExpectEq(R"({"timestamp_tz": {}})", timestamp(TimeUnit::MICRO, "UTC")); @@ -204,7 +204,7 @@ TEST(Substrait, NoEquivalentSubstraitType) { float16(), - date64(), + date32(), timestamp(TimeUnit::SECOND), timestamp(TimeUnit::NANO), timestamp(TimeUnit::MICRO, "New York"), @@ -268,12 +268,9 @@ TEST(Substrait, SupportedLiterals) { ExpectEq(R"({"timestamp": "579"})", TimestampScalar(579, TimeUnit::MICRO)); - /* - constexpr int64_t kDayFiveOfEpoch = 24 * 60 * 60 * 1000 * 5; - static_assert(kDayFiveOfEpoch == 432000000, "until c++ gets string interpolation"); - ExpectEq(R"({"date": "432000000"})", TimestampScalar(kDayFiveOfEpoch, - TimeUnit::MICRO)); - */ + constexpr int64_t kDayFiveOfEpoch = 24 * 60 * 60 * 1000 * 5; + static_assert(kDayFiveOfEpoch == 432000000, "until c++ gets string interpolation"); + ExpectEq(R"({"date": "432000000"})", Date64Scalar(kDayFiveOfEpoch)); ExpectEq(R"({"time": "64"})", Time64Scalar(64, TimeUnit::MICRO)); diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 645db3b839e..64a9fc8750d 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -111,14 +111,7 @@ Result, bool>> FromProto(const st::Type& typ return FromProtoImpl(type.timestamp_tz(), TimeUnit::MICRO, TimestampTzTimezoneString()); case st::Type::kDate: - // FIXME - // Substrait uses uint32_t to store dates, and further restricts the allowed - // range of dates to [1000-01-01..9999-12-31]. Does this mean the value should - // be interpreted as an offset from 1000-01-01 instead of the epoch? Or should - // the value be signed instead? - // Furthermore, simple_logical_types.md states that the equivalent arrow type - // is Date64 (which measures milliseconds rather than days). Is that incorrect? - return FromProtoImpl(type.date()); + return FromProtoImpl(type.date()); case st::Type::kTime: return FromProtoImpl(type.time(), TimeUnit::MICRO); @@ -270,8 +263,8 @@ struct ToProtoImpl { return Status::OK(); } - Status Visit(const Date32Type& t) { return SetWith(&st::Type::set_allocated_date); } - Status Visit(const Date64Type& t) { return NotImplemented(t); } + Status Visit(const Date32Type& t) { return NotImplemented(t); } + Status Visit(const Date64Type& t) { return SetWith(&st::Type::set_allocated_date); } Status Visit(const TimestampType& t) { if (t.unit() != TimeUnit::MICRO) return NotImplemented(t); From 73099646532f4c784c1f0ac3b297457258611ad4 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Mon, 6 Dec 2021 17:28:06 -0500 Subject: [PATCH 015/113] add extension types for interval_*, support deeply nested struct field names --- .../engine/substrait/expression_internal.cc | 43 +++++- .../arrow/engine/substrait/extension_types.cc | 42 ++++++ .../arrow/engine/substrait/extension_types.h | 25 +++- cpp/src/arrow/engine/substrait/serde_test.cc | 102 ++++++++++--- .../arrow/engine/substrait/type_internal.cc | 136 ++++++++++-------- 5 files changed, 271 insertions(+), 77 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 1805c699986..5d3511cd647 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -166,8 +166,22 @@ Result FromProto(const st::Expression::Literal& lit) { return Datum(Time64Scalar(static_cast(lit.time()), TimeUnit::MICRO)); case st::Expression::Literal::kIntervalYearToMonth: - case st::Expression::Literal::kIntervalDayToSecond: - break; + case st::Expression::Literal::kIntervalDayToSecond: { + Int32Builder builder; + std::shared_ptr type; + if (lit.has_interval_year_to_month()) { + RETURN_NOT_OK(builder.Append(lit.interval_year_to_month().years())); + RETURN_NOT_OK(builder.Append(lit.interval_year_to_month().months())); + type = interval_year(); + } else { + RETURN_NOT_OK(builder.Append(lit.interval_day_to_second().days())); + RETURN_NOT_OK(builder.Append(lit.interval_day_to_second().seconds())); + type = interval_day(); + } + ARROW_ASSIGN_OR_RAISE(auto array, builder.Finish()); + return Datum( + ExtensionScalar(FixedSizeListScalar(std::move(array)), std::move(type))); + } case st::Expression::Literal::kUuid: return Datum(ExtensionScalar(FixedSizeBinaryScalarFromBytes(lit.uuid()), uuid())); @@ -506,6 +520,31 @@ struct ToProtoImpl { return Status::OK(); } + auto GetPairOfInts = [&] { + const auto& array = + *internal::checked_cast(*s.value).value; + auto ints = internal::checked_cast(array).raw_values(); + return std::make_pair(ints[0], ints[1]); + }; + + if (UnwrapIntervalYear(*s.type)) { + auto interval_year = internal::make_unique(); + interval_year->set_years(GetPairOfInts().first); + interval_year->set_months(GetPairOfInts().second); + + lit_->set_allocated_interval_year_to_month(interval_year.release()); + return Status::OK(); + } + + if (UnwrapIntervalDay(*s.type)) { + auto interval_day = internal::make_unique(); + interval_day->set_days(GetPairOfInts().first); + interval_day->set_seconds(GetPairOfInts().second); + + lit_->set_allocated_interval_day_to_second(interval_day.release()); + return Status::OK(); + } + return NotImplemented(s); } diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index fc4ce36a03e..8a7a7492293 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -65,6 +65,30 @@ using VarCharType = decltype(kVarCharExtensionParamsProperties), kVarCharExtensionParamsProperties, VarCharGetStorage>; +constexpr util::string_view kIntervalYearExtensionName = "interval_year"; +struct IntervalYearExtensionParams {}; +std::shared_ptr IntervalYearGetStorage(const IntervalYearExtensionParams&) { + return fixed_size_list(int32(), 2); +} +static auto kIntervalYearExtensionParamsProperties = internal::MakeProperties(); + +using IntervalYearType = + SimpleExtensionType; + +constexpr util::string_view kIntervalDayExtensionName = "interval_day"; +struct IntervalDayExtensionParams {}; +std::shared_ptr IntervalDayGetStorage(const IntervalDayExtensionParams&) { + return fixed_size_list(int32(), 2); +} +static auto kIntervalDayExtensionParamsProperties = internal::MakeProperties(); + +using IntervalDayType = + SimpleExtensionType; + } // namespace std::shared_ptr uuid() { return UuidType::Make({}); } @@ -75,6 +99,10 @@ std::shared_ptr fixed_char(int32_t length) { std::shared_ptr varchar(int32_t length) { return VarCharType::Make({length}); } +std::shared_ptr interval_year() { return IntervalYearType::Make({}); } + +std::shared_ptr interval_day() { return IntervalDayType::Make({}); } + bool UnwrapUuid(const DataType& t) { if (auto params = UuidType::GetIf(t)) { return true; @@ -96,5 +124,19 @@ util::optional UnwrapVarChar(const DataType& t) { return util::nullopt; } +bool UnwrapIntervalYear(const DataType& t) { + if (auto params = IntervalYearType::GetIf(t)) { + return true; + } + return false; +} + +bool UnwrapIntervalDay(const DataType& t) { + if (auto params = IntervalDayType::GetIf(t)) { + return true; + } + return false; +} + } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index 6deeb95337a..e8aae58b782 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -29,19 +29,30 @@ namespace arrow { namespace engine { -// uuid, fixed_char, and varchar are provided as first-class types by substrait -// but do not appear in the arrow type system. The following arrow::ExtensionTypes -// are provided to wrap them. +// uuid, fixed_char, varchar, interval_year, and interval_day are provided as first-class +// types by substrait but do not appear in the arrow type system. The following +// arrow::ExtensionTypes are provided to wrap them. +/// fixed_size_binary(16) for storing Universally Unique IDentifiers ARROW_ENGINE_EXPORT std::shared_ptr uuid(); +/// fixed_size_binary(length) constrained to contain only valid UTF-8 ARROW_ENGINE_EXPORT std::shared_ptr fixed_char(int32_t length); +/// utf8() constrained to be shorter than `length` ARROW_ENGINE_EXPORT std::shared_ptr varchar(int32_t length); +/// fixed_size_list(int32(), 2) storing a number of [years, months] +ARROW_ENGINE_EXPORT +std::shared_ptr interval_year(); + +/// fixed_size_list(int32(), 2) storing a number of [days, seconds] +ARROW_ENGINE_EXPORT +std::shared_ptr interval_day(); + /// Return true if t is Uuid, otherwise false ARROW_ENGINE_EXPORT bool UnwrapUuid(const DataType&); @@ -54,5 +65,13 @@ util::optional UnwrapFixedChar(const DataType&); ARROW_ENGINE_EXPORT util::optional UnwrapVarChar(const DataType& t); +/// Return true if t is IntervalYear, otherwise false +ARROW_ENGINE_EXPORT +bool UnwrapIntervalYear(const DataType&); + +/// Return true if t is IntervalDay, otherwise false +ARROW_ENGINE_EXPORT +bool UnwrapIntervalDay(const DataType&); + } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 9fa3be4ebd4..e07607ae40f 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -26,6 +26,7 @@ #include "arrow/engine/substrait/extension_types.h" #include "arrow/testing/gtest_util.h" #include "arrow/testing/matchers.h" +#include "arrow/util/key_value_metadata.h" namespace arrow { namespace engine { @@ -162,6 +163,8 @@ TEST(Substrait, SupportedTypes) { ExpectEq(R"({"date": {}})", date64()); ExpectEq(R"({"time": {}})", time64(TimeUnit::MICRO)); ExpectEq(R"({"timestamp_tz": {}})", timestamp(TimeUnit::MICRO, "UTC")); + ExpectEq(R"({"interval_year": {}})", interval_year()); + ExpectEq(R"({"interval_day": {}})", interval_day()); ExpectEq(R"({"uuid": {}})", uuid()); @@ -183,10 +186,65 @@ TEST(Substrait, SupportedTypes) { })); } +TEST(Substrait, NamedStruct) { + auto buf = SubstraitFromJSON("NamedStruct", R"({ + "struct": { + "types": [ + {"i64": {}}, + {"list": {"type": {"string":{}} }}, + {"struct": { + "types": [ + {"fp32": {}}, + {"string": {}} + ] + }}, + {"list": {"type": {"string":{}} }}, + ] + }, + "names": ["a", "b", "c", "d", "e", "f"] + })"); + ASSERT_OK_AND_ASSIGN(auto schema, DeserializeSchema(*buf)); + Schema expected_schema({ + field("a", int64()), + field("b", list(utf8())), + field("c", struct_({ + field("d", float32()), + field("e", utf8()), + })), + field("f", list(utf8())), + }); + EXPECT_EQ(*schema, expected_schema); + + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeSchema(*schema)); + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeSchema(*serialized)); + EXPECT_EQ(*roundtripped, expected_schema); + + // too few names + buf = SubstraitFromJSON("NamedStruct", R"({ + "struct": {"types": [{"i32": {}}, {"i32": {}}, {"i32": {}}]}, + "names": [] + })"); + EXPECT_THAT(DeserializeSchema(*buf), Raises(StatusCode::Invalid)); + + // too many names + buf = SubstraitFromJSON("NamedStruct", R"({ + "struct": {"types": []}, + "names": ["a", "b", "c"] + })"); + EXPECT_THAT(DeserializeSchema(*buf), Raises(StatusCode::Invalid)); + + // no schema metadata allowed + EXPECT_THAT(SerializeSchema(Schema({}, key_value_metadata({{"ext", "yes"}}))), + Raises(StatusCode::Invalid)); + + // no schema metadata allowed + EXPECT_THAT(SerializeSchema( + Schema({field("a", int32(), key_value_metadata({{"ext", "yes"}}))})), + Raises(StatusCode::Invalid)); +} + TEST(Substrait, NoEquivalentArrowType) { for (util::string_view json : { - R"({"interval_year": {}})", - R"({"interval_day": {}})", R"({"user_defined_type_reference": 99})", }) { ARROW_SCOPED_TRACE(json); @@ -197,6 +255,8 @@ TEST(Substrait, NoEquivalentArrowType) { TEST(Substrait, NoEquivalentSubstraitType) { for (auto type : { + null(), + uint8(), uint16(), uint32(), @@ -274,6 +334,14 @@ TEST(Substrait, SupportedLiterals) { ExpectEq(R"({"time": "64"})", Time64Scalar(64, TimeUnit::MICRO)); + ExpectEq(R"({"interval_year_to_month": {"years": 34, "months": 3}})", + ExtensionScalar(FixedSizeListScalar(ArrayFromJSON(int32(), "[34, 3]")), + interval_year())); + + ExpectEq(R"({"interval_day_to_second": {"days": 34, "seconds": 3}})", + ExtensionScalar(FixedSizeListScalar(ArrayFromJSON(int32(), "[34, 3]")), + interval_day())); + ExpectEq(R"({"fixed_char": "zzz"})", ExtensionScalar( FixedSizeBinaryScalar(Buffer::FromString("zzz"), fixed_size_binary(3)), @@ -311,12 +379,22 @@ TEST(Substrait, SupportedLiterals) { R"([32, ["hello", "world"]])")); // check null scalars: - for (const auto& field : kBoringSchema->fields()) { - auto maybe_type_buf = SerializeType(*field->type()); - if (!maybe_type_buf.ok()) continue; + for (auto type : { + boolean(), + + int8(), + int64(), - ExpectEq("{\"null\": " + SubstraitToJSON("Type", **maybe_type_buf) + "}", - MakeNullScalar(field->type())); + timestamp(TimeUnit::MICRO), + interval_year(), + + struct_({ + field("", int64()), + field("", list(utf8())), + }), + }) { + ASSERT_OK_AND_ASSIGN(auto buf, SerializeType(*type)); + ExpectEq("{\"null\": " + SubstraitToJSON("Type", *buf) + "}", MakeNullScalar(type)); } } @@ -333,15 +411,7 @@ TEST(Substrait, CannotDeserializeLiteral) { Raises(StatusCode::Invalid)); // no equivalent arrow scalar - for (util::string_view json : { - R"({"interval_year_to_month": {"years": 3, "months": 2}})", - R"({"interval_day_to_second": {"days": 3, "seconds": 2}})", - // FIXME no way to specify scalars of user_defined_type_reference - }) { - ARROW_SCOPED_TRACE(json); - auto buf = SubstraitFromJSON("Expression", "{\"literal\": " + json.to_string() + "}"); - ASSERT_THAT(DeserializeExpression(*buf), Raises(StatusCode::NotImplemented)); - } + // FIXME no way to specify scalars of user_defined_type_reference } TEST(Substrait, FieldRefRoundTrip) { diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 64a9fc8750d..1314cec03e5 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -64,17 +64,28 @@ Result, bool>> FromProtoImpl( IsNullable(type)); } -template -Result FieldsFromProto( - int size, const Types& types, - const Names* names = static_cast(nullptr)) { +template +Result FieldsFromProto(int size, const Types& types, + const NextName& next_name) { FieldVector fields(size); for (int i = 0; i < size; ++i) { - ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(types[i])); + std::string name = next_name(); + std::shared_ptr type; + bool nullable; - std::string name = names ? std::move((*names)[i]) : ""; - fields[i] = - field(std::move(name), std::move(type_nullable.first), type_nullable.second); + if (types[i].has_struct_()) { + const auto& struct_ = types[i].struct_(); + + ARROW_ASSIGN_OR_RAISE( + type, FieldsFromProto(struct_.types_size(), struct_.types(), next_name) + .Map(arrow::struct_)); + + nullable = IsNullable(struct_); + } else { + ARROW_ASSIGN_OR_RAISE(std::tie(type, nullable), FromProto(types[i])); + } + + fields[i] = field(std::move(name), std::move(type), nullable); } return fields; } @@ -117,37 +128,18 @@ Result, bool>> FromProto(const st::Type& typ return FromProtoImpl(type.time(), TimeUnit::MICRO); case st::Type::kIntervalYear: - // FIXME - // None of MonthIntervalType, DayTimeIntervalType, MonthDayNanoIntervalType - // corresponds; none has a year field. Lossy conversion to MonthIntervalType - // would be possible... - break; + return FromProtoImpl(type.interval_year(), interval_year); case st::Type::kIntervalDay: - // FIXME - // Documentation is inconsistent; the precision of the sub-day interval is - // described as microsecond in simple_logical_types.md but IntervalDayToSecond has - // the field `int32 seconds`. At microsecond precision it's minimally necessary to - // store all values in the range `[0,24*60*60*1000_000)` in order to express all - // possible sub-day intervals, but this is not possible for 32 bit integers. - // - // Possible fixes: amend that field to `int64 milliseconds`, then this type can be - // converted to MonthDayNanoIntervalType (months will always be - // 0). - // : amend documentation to claim only second precision, then this - // type can be converted to DayTimeIntervalType (milliseconds % - // 1000 will always be 0). - break; + return FromProtoImpl(type.interval_day(), interval_day); case st::Type::kUuid: return FromProtoImpl(type.uuid(), uuid); case st::Type::kFixedChar: - // need extension type to mark utf-8 constraint return FromProtoImpl(type.fixed_char(), fixed_char, type.fixed_char().length()); case st::Type::kVarchar: - // need extension type to hold type.varchar().length() constraint return FromProtoImpl(type.varchar(), varchar, type.varchar().length()); case st::Type::kFixedBinary: @@ -163,7 +155,8 @@ Result, bool>> FromProto(const st::Type& typ const auto& struct_ = type.struct_(); ARROW_ASSIGN_OR_RAISE(auto fields, - FieldsFromProto(struct_.types_size(), struct_.types())); + FieldsFromProto(struct_.types_size(), struct_.types(), + /*next_name=*/[] { return ""; })); return FromProtoImpl(struct_, std::move(fields)); } @@ -214,27 +207,6 @@ Result, bool>> FromProto(const st::Type& typ type.DebugString()); } -Result> FromProto(const st::NamedStruct& named_struct) { - if (named_struct.has_struct_()) { - return Status::Invalid("While converting ", named_struct.DebugString(), - " no anonymous struct type was provided to which to names " - "could be attached."); - } - const auto& struct_ = named_struct.struct_(); - RETURN_NOT_OK(CheckVariation(struct_)); - - if (struct_.types_size() != named_struct.names_size()) { - return Status::Invalid("While converting ", named_struct.DebugString(), " received ", - struct_.types_size(), " types but ", named_struct.names_size(), - " names."); - } - - ARROW_ASSIGN_OR_RAISE( - auto fields, - FieldsFromProto(struct_.types_size(), struct_.types(), &named_struct.names())); - return schema(std::move(fields)); -} - namespace { struct ToProtoImpl { Status Visit(const NullType& t) { return NotImplemented(t); } @@ -297,6 +269,7 @@ struct ToProtoImpl { Status Visit(const Decimal256Type& t) { return NotImplemented(t); } Status Visit(const ListType& t) { + // FIXME assert default field name; custom ones won't roundtrip ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*t.value_type(), t.value_field()->nullable())); SetWithThen(&st::Type::set_allocated_list)->set_allocated_type(type.release()); @@ -309,9 +282,6 @@ struct ToProtoImpl { types->Reserve(t.num_fields()); for (const auto& field : t.fields()) { - if (field->name() != "") { - return Status::Invalid("substrait::Type::Struct does not support named fields"); - } if (field->metadata() != nullptr) { return Status::Invalid("substrait::Type::Struct does not support field metadata"); } @@ -326,6 +296,7 @@ struct ToProtoImpl { Status Visit(const DictionaryType& t) { return NotImplemented(t); } Status Visit(const MapType& t) { + // FIXME assert default field names; custom ones won't roundtrip auto map = SetWithThen(&st::Type::set_allocated_map); ARROW_ASSIGN_OR_RAISE(auto key, ToProto(*t.key_type())); @@ -353,6 +324,14 @@ struct ToProtoImpl { return Status::OK(); } + if (UnwrapIntervalYear(t)) { + return SetWith(&st::Type::set_allocated_interval_year); + } + + if (UnwrapIntervalDay(t)) { + return SetWith(&st::Type::set_allocated_interval_day); + } + return NotImplemented(t); } @@ -396,18 +375,63 @@ Result> ToProto(const DataType& type, bool nullable) { return std::move(out); } +namespace { +void ToProtoGetDepthFirstNames(const FieldVector& fields, + google::protobuf::RepeatedPtrField* names) { + for (const auto& field : fields) { + *names->Add() = field->name(); + + if (field->type()->id() == Type::STRUCT) { + ToProtoGetDepthFirstNames(field->type()->fields(), names); + } + } +} +} // namespace + +Result> FromProto(const st::NamedStruct& named_struct) { + if (!named_struct.has_struct_()) { + return Status::Invalid("While converting ", named_struct.DebugString(), + " no anonymous struct type was provided to which to names " + "could be attached."); + } + const auto& struct_ = named_struct.struct_(); + RETURN_NOT_OK(CheckVariation(struct_)); + + int requested_names_count = 0; + ARROW_ASSIGN_OR_RAISE(auto fields, + FieldsFromProto(struct_.types_size(), struct_.types(), + /*next_name=*/[&] { + int i = requested_names_count++; + return i < named_struct.names_size() + ? named_struct.names().Get(i) + : ""; + })); + + if (requested_names_count != named_struct.names_size()) { + return Status::Invalid("While converting ", named_struct.DebugString(), " received ", + named_struct.names_size(), " names but ", + requested_names_count, " struct fields"); + } + + return schema(std::move(fields)); +} + Result> ToProto(const Schema& schema) { + if (schema.metadata()) { + return Status::Invalid("substrait::NamedStruct does not support schema metadata"); + } + auto named_struct = internal::make_unique(); + auto names = named_struct->mutable_names(); names->Reserve(schema.num_fields()); + ToProtoGetDepthFirstNames(schema.fields(), names); auto struct_ = internal::make_unique(); auto types = struct_->mutable_types(); types->Reserve(schema.num_fields()); for (const auto& field : schema.fields()) { - *names->Add() = field->name(); - if (field->metadata() != nullptr) { return Status::Invalid("substrait::NamedStruct does not support field metadata"); } From 27af6b676e4ddf34733c6739f5d151f09b8742d4 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Thu, 9 Dec 2021 14:50:45 -0500 Subject: [PATCH 016/113] add basic sketch of ExtensionSet for tracking substrait extensions --- .../engine/substrait/expression_internal.cc | 7 +- .../arrow/engine/substrait/extension_types.cc | 165 ++++++++++++++++++ .../arrow/engine/substrait/extension_types.h | 94 +++++++++- cpp/src/arrow/engine/substrait/serde.cc | 5 +- cpp/src/arrow/engine/substrait/serde.h | 7 +- cpp/src/arrow/engine/substrait/serde_test.cc | 14 +- .../arrow/engine/substrait/type_internal.cc | 31 ++-- .../arrow/engine/substrait/type_internal.h | 3 +- cpp/src/arrow/util/hashing.h | 9 + format/substrait/extension_types.yaml | 121 +++++++++++++ 10 files changed, 430 insertions(+), 26 deletions(-) create mode 100644 format/substrait/extension_types.yaml diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 5d3511cd647..a44fc5b1adf 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -442,9 +442,11 @@ struct ToProtoImpl { Status Visit(const ListScalar& s) { lit_->set_allocated_list(new Lit::List()); + const auto& list_type = internal::checked_cast(*s.type); + ExtensionSet ext_set; ARROW_ASSIGN_OR_RAISE( auto element_type, - ToProto(*internal::checked_cast(*s.type).value_type())); + ToProto(*list_type.value_type(), list_type.value_field()->nullable(), &ext_set)); lit_->mutable_list()->set_allocated_element_type(element_type.release()); auto values = lit_->mutable_list()->mutable_values(); @@ -577,7 +579,8 @@ Result> ToProto(const Datum& datum) { if (datum.scalar()->is_valid) { RETURN_NOT_OK((ToProtoImpl{out.get()})(*datum.scalar())); } else { - ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*datum.type())); + ExtensionSet ext_set; + ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*datum.type(), /*nullable=*/true, &ext_set)); out->set_allocated_null(type.release()); } diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index 8a7a7492293..66195934744 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -17,7 +17,12 @@ #include "arrow/engine/substrait/extension_types.h" +#include +#include + #include "arrow/engine/simple_extension_type_internal.h" +#include "arrow/util/hash_util.h" +#include "arrow/util/hashing.h" #include "arrow/util/string_view.h" namespace arrow { @@ -138,5 +143,165 @@ bool UnwrapIntervalDay(const DataType& t) { return false; } +struct ExtensionSet::Impl { + struct IdHash { + size_t operator()(Id id) const { + internal::StringViewHash hash; + auto out = hash(id.uri); + internal::hash_combine(out, hash(id.name)); + return out; + } + }; + + using IdToIndexMap = std::unordered_map; + + void AddUri(util::string_view uri, ExtensionSet* self) { + if (uris_.insert(uri).second) { + self->uris_.push_back(uri); + } + } + + Status CheckHasUri(util::string_view uri) { + if (uris_.count(uri) == 0) { + return Status::Invalid( + "Uri ", uri, + " was referenced by an extension but was not declared in the ExtensionSet."); + } + return Status::OK(); + } + + enum { kType, kTypeVariation }; + + template + uint32_t EncodeTypeOrTypeVariation(Id id, const std::shared_ptr& type, + ExtensionSet* self) { + AddUri(id.uri, self); + + auto map = (kTypeOrTypeVariation == kType ? &types_ : &type_variations_); + + auto ids = + (kTypeOrTypeVariation == kType ? &self->type_ids_ : &self->type_variation_ids_); + + auto types = + (kTypeOrTypeVariation == kType ? &self->types_ : &self->type_variations_); + + auto it_success = map->emplace(id, static_cast(map->size())); + + if (it_success.second) { + DCHECK_EQ(ids->size(), types->size()); + ids->push_back(id); + types->push_back(type); + } + + return it_success.first->second; + } + + std::unordered_set uris_; + IdToIndexMap type_variations_, types_; +}; + +ExtensionSet::ExtensionSet() : impl_(new Impl()) {} + +Result ExtensionSet::Make(std::vector uris, + std::vector type_variation_ids, + std::vector type_ids, + ExtensionIdRegistry* registry) { + ExtensionSet set; + + for (auto uri : uris) { + if (uri.empty()) continue; + set.impl_->AddUri(uri, &set); + } + set.uris_ = std::move(uris); + + set.types_.resize(type_ids.size()); + set.type_variations_.resize(type_variation_ids.size()); + + uint32_t anchor = 0; + for (Id id : type_variation_ids) { + auto i = anchor++; + if (id.empty()) continue; + RETURN_NOT_OK(set.impl_->CheckHasUri(id.uri)); + + auto type = registry->GetTypeVariation(id); + if (type == nullptr) { + return Status::Invalid("Type variation not found"); + } + set.types_[i] = std::move(type); + } + + anchor = 0; + for (Id id : type_ids) { + auto i = anchor++; + if (id.empty()) continue; + RETURN_NOT_OK(set.impl_->CheckHasUri(id.uri)); + + auto type = registry->GetType(id); + if (type == nullptr) { + return Status::Invalid("Type not found"); + } + set.types_[i] = std::move(type); + } + + set.type_ids_ = std::move(type_ids); + set.type_variation_ids_ = std::move(type_variation_ids); + + return std::move(set); +} + +ExtensionSet::~ExtensionSet() = default; + +uint32_t ExtensionSet::EncodeTypeVariation(Id id, const std::shared_ptr& type) { + return impl_->EncodeTypeOrTypeVariation(id, type, this); +} + +uint32_t ExtensionSet::EncodeType(Id id, const std::shared_ptr& type) { + return impl_->EncodeTypeOrTypeVariation(id, type, this); +} + +ExtensionIdRegistry* default_extension_id_registry() { + static struct : ExtensionIdRegistry { + struct TypeHashEq { + size_t operator()(const std::shared_ptr& type) const { + return type->Hash(); + } + bool operator()(const std::shared_ptr& l, + const std::shared_ptr& r) const { + return *l == *r; + } + }; + + util::optional GetTypeVariation( + const std::shared_ptr& type) const override { + auto it = type_variations_.find(type); + if (it == type_variations_.end()) return {}; + return it->second; + } + std::shared_ptr GetTypeVariation(Id) const override { return nullptr; } + Status RegisterTypeVariation(Id id, const std::shared_ptr& type) override { + if (type_variations_.emplace(type, id).second) return Status::OK(); + return Status::Invalid("TypeVariation id was already registered"); + } + + util::optional GetType(const std::shared_ptr&) const override { + return {}; + } + std::shared_ptr GetType(Id) const override { return nullptr; } + Status RegisterType(Id, const std::shared_ptr&) override { + return Status::NotImplemented("FIXME"); + } + + std::unordered_map, Id, TypeHashEq, TypeHashEq> + type_variations_, types_; + } impl_; + + constexpr util::string_view kArrowExtTypesUrl = + "https://github.com/apache/arrow/blob/master/format/substrait/extension_types.yaml"; + + DCHECK_OK(impl_.RegisterTypeVariation({kArrowExtTypesUrl, "null"}, null())); + + return &impl_; +} + } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index e8aae58b782..6ca30c41353 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -25,13 +25,20 @@ #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" #include "arrow/util/optional.h" +#include "arrow/util/string_view.h" namespace arrow { namespace engine { -// uuid, fixed_char, varchar, interval_year, and interval_day are provided as first-class -// types by substrait but do not appear in the arrow type system. The following -// arrow::ExtensionTypes are provided to wrap them. +// arrow::ExtensionTypes are provided to wrap uuid, fixed_char, varchar, interval_year, +// and interval_day which are first-class types in substrait but do not appear in +// the arrow type system. +// +// Note that these are not automatically registered with arrow::RegisterExtensionType(), +// which means among other things that serialization of these types to IPC would fail. +// +// FIXME we'll also need arrow::ExtensionTypes to wrap substrait::ExtensionTypeVariations +// and substrait::ExtensionTypes. /// fixed_size_binary(16) for storing Universally Unique IDentifiers ARROW_ENGINE_EXPORT @@ -73,5 +80,86 @@ bool UnwrapIntervalYear(const DataType&); ARROW_ENGINE_EXPORT bool UnwrapIntervalDay(const DataType&); +// We need to be able to append to ExtensionSets as we serialize- +// we first serialize Plan.relations, then finalize by hydrating +// Plan.extensions etc with the accumulated variations etc +// +// We need to be able to draw from ExtensionSets as we deserialize- +// type variation references in protobuf are just ints and we need to +// be able to look them up and efficiently hydrate with the corresponding +// DataType. + +/// A mapping from arrow types and functions to the (uri, name) which identifies +/// the corresponding substrait extension. +class ARROW_ENGINE_EXPORT ExtensionIdRegistry { + public: + struct Id { + util::string_view uri, name; + + bool empty() const { return uri.empty() && name.empty(); } + + bool operator==(Id other) const { return uri == other.uri && name == other.name; } + bool operator!=(Id other) const { return !(*this == other); } + }; + + virtual util::optional GetTypeVariation(const std::shared_ptr&) const = 0; + virtual std::shared_ptr GetTypeVariation(Id) const = 0; + virtual Status RegisterTypeVariation(Id, const std::shared_ptr&) = 0; + + virtual util::optional GetType(const std::shared_ptr&) const = 0; + virtual std::shared_ptr GetType(Id) const = 0; + virtual Status RegisterType(Id, const std::shared_ptr&) = 0; +}; + +ARROW_ENGINE_EXPORT ExtensionIdRegistry* default_extension_id_registry(); + +/// A subset of an ExtensionIdRegistry with extensions identifiable by an integer. +class ARROW_ENGINE_EXPORT ExtensionSet { + public: + using Id = ExtensionIdRegistry::Id; + + /// Construct an empty ExtensionSet to be populated during serialization. + ExtensionSet(); + ARROW_DEFAULT_MOVE_AND_ASSIGN(ExtensionSet); + + /// Construct an ExtensionSet with explicit extension ids for efficient referencing + /// during deserialization. Note that input vectors need not be densely packed; an empty + /// (default constructed) Id may be used as a placeholder to indicate an unused + /// _anchor/_reference. + static Result Make( + std::vector uris, std::vector type_variation_ids, + std::vector type_ids, ExtensionIdRegistry* = default_extension_id_registry()); + + ~ExtensionSet(); + + // index in these vectors == value of _anchor/_reference fields + /// FIXME this assumes that _anchor/_references won't be huge, which is not guaranteed. + /// Could it be? + const std::vector& uris() const { return uris_; } + + const DataTypeVector& type_variations() const { return type_variations_; } + const std::vector& type_variation_ids() const { return type_variation_ids_; } + + const DataTypeVector& types() const { return types_; } + const std::vector& type_ids() const { return type_ids_; } + + /// Encode a type as a substrait::ExtensionTypeVariation. + /// Returns an integer usable for Type.*.type_variation_reference. + uint32_t EncodeTypeVariation(Id, const std::shared_ptr&); + + /// Encode a type as a substrait::ExtensionType. + /// Returns an integer usable for Type.user_defined_type_reference. + uint32_t EncodeType(Id, const std::shared_ptr&); + + private: + DataTypeVector type_variations_, types_; + std::vector type_variation_ids_, type_ids_; + std::vector uris_; + + // pimpl pattern to hide lookup details + struct Impl; + std::unique_ptr impl_; +}; + } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc index 3fe331c96bc..8a863a09095 100644 --- a/cpp/src/arrow/engine/substrait/serde.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -88,8 +88,9 @@ Result> DeserializeType(const Buffer& buf) { return std::move(type_nullable.first); } -Result> SerializeType(const DataType& type) { - ARROW_ASSIGN_OR_RAISE(auto st_type, ToProto(type)); +Result> SerializeType(const DataType& type, + ExtensionSet* ext_set) { + ARROW_ASSIGN_OR_RAISE(auto st_type, ToProto(type, /*nullable=*/true, ext_set)); std::string serialized = st_type->SerializeAsString(); return Buffer::FromString(std::move(serialized)); } diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index 4fb4b8d5438..53730a6849e 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -19,24 +19,25 @@ #pragma once +#include #include #include "arrow/buffer.h" #include "arrow/compute/exec/exec_plan.h" +#include "arrow/engine/substrait/extension_types.h" #include "arrow/engine/visibility.h" #include "arrow/result.h" namespace arrow { namespace engine { -ARROW_ENGINE_EXPORT -Result> ConvertPlan(const Buffer&); +ARROW_ENGINE_EXPORT Result> ConvertPlan(const Buffer&); ARROW_ENGINE_EXPORT Result> DeserializeType(const Buffer&); ARROW_ENGINE_EXPORT -Result> SerializeType(const DataType&); +Result> SerializeType(const DataType&, ExtensionSet*); ARROW_ENGINE_EXPORT Result> DeserializeSchema(const Buffer&); diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index e07607ae40f..9110987d5d6 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -140,7 +140,8 @@ TEST(Substrait, SupportedTypes) { EXPECT_EQ(*type, *expected_type); - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type)); + ExtensionSet set; + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &set)); ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized)); EXPECT_EQ(*roundtripped, *expected_type); @@ -148,6 +149,8 @@ TEST(Substrait, SupportedTypes) { ExpectEq(R"({"bool": {}})", boolean()); + ExpectEq(R"({"user_defined_type_reference": 0})", null()); + ExpectEq(R"({"i8": {}})", int8()); ExpectEq(R"({"i16": {}})", int16()); ExpectEq(R"({"i32": {}})", int32()); @@ -255,8 +258,6 @@ TEST(Substrait, NoEquivalentArrowType) { TEST(Substrait, NoEquivalentSubstraitType) { for (auto type : { - null(), - uint8(), uint16(), uint32(), @@ -291,7 +292,8 @@ TEST(Substrait, NoEquivalentSubstraitType) { month_day_nano_interval(), }) { ARROW_SCOPED_TRACE(type->ToString()); - EXPECT_THAT(SerializeType(*type), Raises(StatusCode::NotImplemented)); + ExtensionSet set; + EXPECT_THAT(SerializeType(*type, &set), Raises(StatusCode::NotImplemented)); } } @@ -393,7 +395,8 @@ TEST(Substrait, SupportedLiterals) { field("", list(utf8())), }), }) { - ASSERT_OK_AND_ASSIGN(auto buf, SerializeType(*type)); + ExtensionSet set; + ASSERT_OK_AND_ASSIGN(auto buf, SerializeType(*type, &set)); ExpectEq("{\"null\": " + SubstraitToJSON("Type", *buf) + "}", MakeNullScalar(type)); } } @@ -451,6 +454,7 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { compute::field_ref({"struct_i32_str", 1}), compute::field_ref("str"), }), + compute::call("list_element", { compute::field_ref("list_i32"), diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 1314cec03e5..1009e35be9d 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -208,8 +208,14 @@ Result, bool>> FromProto(const st::Type& typ } namespace { + struct ToProtoImpl { - Status Visit(const NullType& t) { return NotImplemented(t); } + Status Visit(const NullType& t) { + auto id = *default_extension_id_registry()->GetTypeVariation(null()); + auto anchor = ext_set_->EncodeTypeVariation(id, null()); + type_->set_user_defined_type_reference(anchor); + return Status::OK(); + } Status Visit(const BooleanType& t) { return SetWith(&st::Type::set_allocated_bool_); } @@ -270,8 +276,8 @@ struct ToProtoImpl { Status Visit(const ListType& t) { // FIXME assert default field name; custom ones won't roundtrip - ARROW_ASSIGN_OR_RAISE(auto type, - ToProto(*t.value_type(), t.value_field()->nullable())); + ARROW_ASSIGN_OR_RAISE( + auto type, ToProto(*t.value_type(), t.value_field()->nullable(), ext_set_)); SetWithThen(&st::Type::set_allocated_list)->set_allocated_type(type.release()); return Status::OK(); } @@ -285,7 +291,8 @@ struct ToProtoImpl { if (field->metadata() != nullptr) { return Status::Invalid("substrait::Type::Struct does not support field metadata"); } - ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*field->type(), field->nullable())); + ARROW_ASSIGN_OR_RAISE(auto type, + ToProto(*field->type(), field->nullable(), ext_set_)); types->AddAllocated(type.release()); } return Status::OK(); @@ -299,11 +306,11 @@ struct ToProtoImpl { // FIXME assert default field names; custom ones won't roundtrip auto map = SetWithThen(&st::Type::set_allocated_map); - ARROW_ASSIGN_OR_RAISE(auto key, ToProto(*t.key_type())); + ARROW_ASSIGN_OR_RAISE(auto key, ToProto(*t.key_type(), /*nullable=*/false, ext_set_)); map->set_allocated_key(key.release()); - ARROW_ASSIGN_OR_RAISE(auto value, - ToProto(*t.value_type(), t.value_field()->nullable())); + ARROW_ASSIGN_OR_RAISE( + auto value, ToProto(*t.value_type(), t.value_field()->nullable(), ext_set_)); map->set_allocated_value(value.release()); return Status::OK(); @@ -366,12 +373,14 @@ struct ToProtoImpl { st::Type* type_; bool nullable_; + ExtensionSet* ext_set_; }; } // namespace -Result> ToProto(const DataType& type, bool nullable) { +Result> ToProto(const DataType& type, bool nullable, + ExtensionSet* ext_set) { auto out = internal::make_unique(); - RETURN_NOT_OK((ToProtoImpl{out.get(), nullable})(type)); + RETURN_NOT_OK((ToProtoImpl{out.get(), nullable, ext_set})(type)); return std::move(out); } @@ -436,7 +445,9 @@ Result> ToProto(const Schema& schema) { return Status::Invalid("substrait::NamedStruct does not support field metadata"); } - ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*field->type(), field->nullable())); + ExtensionSet ext_set; + ARROW_ASSIGN_OR_RAISE(auto type, + ToProto(*field->type(), field->nullable(), &ext_set)); types->AddAllocated(type.release()); } diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h index 73420619cd4..9ab37a88e94 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -21,6 +21,7 @@ #include +#include "arrow/engine/substrait/extension_types.h" #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" @@ -35,7 +36,7 @@ ARROW_ENGINE_EXPORT Result, bool>> FromProto(const st::Type&); ARROW_ENGINE_EXPORT -Result> ToProto(const DataType&, bool nullable = true); +Result> ToProto(const DataType&, bool nullable, ExtensionSet*); ARROW_ENGINE_EXPORT Result> FromProto(const st::NamedStruct&); diff --git a/cpp/src/arrow/util/hashing.h b/cpp/src/arrow/util/hashing.h index 328d7e7ca21..f6caf4419b2 100644 --- a/cpp/src/arrow/util/hashing.h +++ b/cpp/src/arrow/util/hashing.h @@ -882,5 +882,14 @@ static inline Status ComputeNullBitmap(MemoryPool* pool, const MemoTableType& me return Status::OK(); } +struct StringViewHash { + // std::hash compatible hasher for use with std::unordered_* + // (the std::hash specialization provided by nonstd constructs std::string + // temporaries then invokes std::hash against those) + hash_t operator()(const util::string_view& value) const { + return ComputeStringHash<>(value.data(), static_cast(value.size())); + } +}; + } // namespace internal } // namespace arrow diff --git a/format/substrait/extension_types.yaml b/format/substrait/extension_types.yaml new file mode 100644 index 00000000000..8909ae7372d --- /dev/null +++ b/format/substrait/extension_types.yaml @@ -0,0 +1,121 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +# substrait::{ExtensionTypeVariation, ExtensionType}s +# for wrapping types which appear in the arrow type system but +# are not first-class in substrait. These include: +# - null +# - unsigned integers +# - half-precision floating point numbers +# - 32 bit times and dates +# - timestamps with units other than microseconds +# - timestamps with timezones other than UTC +# - 256 bit decimals +# - sparse and dense unions +# - dictionary encoded types +# - durations +# - string and binary with 64 bit offsets +# - list with 64 bit offsets +# - interval +# - interval +# - interval +# - arrow::ExtensionTypes + +# FIXME these extension types are not parameterizable, which means among +# other things that we can't declare dictionary type here at all since +# we'd have to declare a different dictionary type for all encoded types +# (but that is an infinite space). Similarly, do we need to declare a +# timestamp variation for all possible timezone strings? +# +# Ultimately these declarations are a promise which needs to be backed by +# equivalent serde in c++. For example, consider u8: when serializing to +# substrait, we need to wrap instances of arrow::uint8 into the type +# variation listed below. It would be ideal if we could SinglePointOfTruth +# this correspondence; either generating c++ from the YAML or YAML from the +# c++. +# +# At present (AFAICT) it's not valid to make this user extensible because +# even if a user adds their custom scalar function to the registry *and* +# defines the mapping from that scalar function to a substrait::ExtensionFunction +# the corresponding YAML doesn't exist at any URI and so it can't be used in +# substrait. Perhaps we could still help that case by providing a tool to +# generate YAML from functions; that'd simplify the lives of people trying to +# write arrow::compute::Functions to "define the function and if you want to +# reference it from substrait generate this YAML and put it at some URI". +# +# In any case for the foreseeable future generation would be far too brittle; +# URIs will not be accessed by anything but humans and the YAML is effectively +# structured documentation. Thus extenders should pass the URI in the same way +# they pass a description string; it's opaque to anything in arrow. +# +# We'll need a global mapping which contains: +# arrow::uint8 <-> { +# uri: "https://github.com/apache/arrow/blob//format/substrait/extension_types.yaml", +# name: "u8" +# } +# +# And additionally convenient builders for subsets of that mapping during serde: +# arrow::uint8 <-> reference to anchor +# +# Worth noting: it's valid to have multiple ExtensionFunctions with the same name, +# as long as all impls' mangled ("compound") names are unique. +# Also worth noting: Options may only be enumerations. This will get strange with +# functions like is_in, where we'll have to require that one argument is a literal +# list or something. + +type_variations: + - parent: i8 + name: u8 + description: an unsigned 8 bit integer + functions: SEPARATE + - parent: i16 + name: u16 + description: an unsigned 16 bit integer + functions: SEPARATE + - parent: i32 + name: u32 + description: an unsigned 32 bit integer + functions: SEPARATE + - parent: i32 + name: u32 + description: an unsigned 32 bit integer + functions: SEPARATE + - parent: i64 + name: u64 + description: an unsigned 64 bit integer + functions: SEPARATE + + - parent: i16 + name: fp16 + description: a 16 bit floating point number + functions: SEPARATE + +types: + - name: "null" + structure: {} + - name: interval_month + structure: + months: i32 + - name: interval_day_milli + structure: + days: i32 + millis: i32 + - name: interval_month_day_nano + structure: + months: i32 + days: i32 + nanos: i64 From 37a62decd22387230ae8fe239f73acb23f32f78b Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Mon, 13 Dec 2021 14:45:04 -0500 Subject: [PATCH 017/113] get a failing test for arrow::null --- .../engine/substrait/expression_internal.cc | 11 +++-- cpp/src/arrow/engine/substrait/serde.cc | 5 +- cpp/src/arrow/engine/substrait/serde.h | 2 +- cpp/src/arrow/engine/substrait/serde_test.cc | 11 +++-- .../arrow/engine/substrait/type_internal.cc | 46 +++++++++++-------- .../arrow/engine/substrait/type_internal.h | 3 +- 6 files changed, 47 insertions(+), 31 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index a44fc5b1adf..7d1f5cfc820 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -129,6 +129,8 @@ Result FromProto(const st::Expression::Literal& lit) { "Nullable Literals - Literal.nullable must be left at the default"); } + ExtensionSet ext_set; + switch (lit.literal_type_case()) { case st::Expression::Literal::kBoolean: return Datum(lit.boolean()); @@ -241,7 +243,7 @@ Result FromProto(const st::Expression::Literal& lit) { std::shared_ptr element_type; if (list.has_element_type()) { ARROW_ASSIGN_OR_RAISE(std::tie(element_type, std::ignore), - FromProto(list.element_type())); + FromProto(list.element_type(), ext_set)); } ScalarVector values(list.values_size()); @@ -275,11 +277,12 @@ Result FromProto(const st::Expression::Literal& lit) { std::shared_ptr key_type, value_type; if (map.has_key_type()) { - ARROW_ASSIGN_OR_RAISE(std::tie(key_type, std::ignore), FromProto(map.key_type())); + ARROW_ASSIGN_OR_RAISE(std::tie(key_type, std::ignore), + FromProto(map.key_type(), ext_set)); } if (map.has_value_type()) { ARROW_ASSIGN_OR_RAISE(std::tie(value_type, std::ignore), - FromProto(map.value_type())); + FromProto(map.value_type(), ext_set)); } ScalarVector keys(map.key_values_size()), values(map.key_values_size()); @@ -334,7 +337,7 @@ Result FromProto(const st::Expression::Literal& lit) { } case st::Expression::Literal::kNull: { - ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(lit.null())); + ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(lit.null(), ext_set)); if (!type_nullable.second) { return Status::Invalid("Null literal ", lit.DebugString(), " is of non-nullable type"); diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc index 8a863a09095..daf01f0e852 100644 --- a/cpp/src/arrow/engine/substrait/serde.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -82,9 +82,10 @@ Result> SerializeSchema(const Schema& schema) { return Buffer::FromString(std::move(serialized)); } -Result> DeserializeType(const Buffer& buf) { +Result> DeserializeType(const Buffer& buf, + const ExtensionSet& ext_set) { ARROW_ASSIGN_OR_RAISE(auto type, ParseFromBuffer(buf)); - ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(type)); + ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(type, ext_set)); return std::move(type_nullable.first); } diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index 53730a6849e..e1a1e27c9f8 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -34,7 +34,7 @@ namespace engine { ARROW_ENGINE_EXPORT Result> ConvertPlan(const Buffer&); ARROW_ENGINE_EXPORT -Result> DeserializeType(const Buffer&); +Result> DeserializeType(const Buffer&, const ExtensionSet&); ARROW_ENGINE_EXPORT Result> SerializeType(const DataType&, ExtensionSet*); diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 9110987d5d6..40f2911dafb 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -135,14 +135,14 @@ TEST(Substrait, SupportedTypes) { auto ExpectEq = [](util::string_view json, std::shared_ptr expected_type) { ARROW_SCOPED_TRACE(json); + ExtensionSet ext_set; auto buf = SubstraitFromJSON("Type", json); - ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf)); + ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf, ext_set)); EXPECT_EQ(*type, *expected_type); - ExtensionSet set; - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &set)); - ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized)); + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &ext_set)); + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized, ext_set)); EXPECT_EQ(*roundtripped, *expected_type); }; @@ -252,7 +252,8 @@ TEST(Substrait, NoEquivalentArrowType) { }) { ARROW_SCOPED_TRACE(json); auto buf = SubstraitFromJSON("Type", json); - ASSERT_THAT(DeserializeType(*buf), Raises(StatusCode::NotImplemented)); + ExtensionSet ext_set; + ASSERT_THAT(DeserializeType(*buf, ext_set), Raises(StatusCode::NotImplemented)); } } diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 1009e35be9d..ee82b72ad06 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -66,7 +66,8 @@ Result, bool>> FromProtoImpl( template Result FieldsFromProto(int size, const Types& types, - const NextName& next_name) { + const NextName& next_name, + const ExtensionSet& ext_set) { FieldVector fields(size); for (int i = 0; i < size; ++i) { std::string name = next_name(); @@ -77,12 +78,12 @@ Result FieldsFromProto(int size, const Types& types, const auto& struct_ = types[i].struct_(); ARROW_ASSIGN_OR_RAISE( - type, FieldsFromProto(struct_.types_size(), struct_.types(), next_name) + type, FieldsFromProto(struct_.types_size(), struct_.types(), next_name, ext_set) .Map(arrow::struct_)); nullable = IsNullable(struct_); } else { - ARROW_ASSIGN_OR_RAISE(std::tie(type, nullable), FromProto(types[i])); + ARROW_ASSIGN_OR_RAISE(std::tie(type, nullable), FromProto(types[i], ext_set)); } fields[i] = field(std::move(name), std::move(type), nullable); @@ -92,7 +93,8 @@ Result FieldsFromProto(int size, const Types& types, } // namespace -Result, bool>> FromProto(const st::Type& type) { +Result, bool>> FromProto( + const st::Type& type, const ExtensionSet& ext_set) { switch (type.kind_case()) { case st::Type::kBool: return FromProtoImpl(type.bool_()); @@ -154,9 +156,9 @@ Result, bool>> FromProto(const st::Type& typ case st::Type::kStruct: { const auto& struct_ = type.struct_(); - ARROW_ASSIGN_OR_RAISE(auto fields, - FieldsFromProto(struct_.types_size(), struct_.types(), - /*next_name=*/[] { return ""; })); + ARROW_ASSIGN_OR_RAISE(auto fields, FieldsFromProto( + struct_.types_size(), struct_.types(), + /*next_name=*/[] { return ""; }, ext_set)); return FromProtoImpl(struct_, std::move(fields)); } @@ -170,7 +172,7 @@ Result, bool>> FromProto(const st::Type& typ list.DebugString()); } - ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(list.type())); + ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(list.type(), ext_set)); return FromProtoImpl( list, field("item", std::move(type_nullable.first), type_nullable.second)); } @@ -185,8 +187,8 @@ Result, bool>> FromProto(const st::Type& typ missing, " type in ", map.DebugString()); } - ARROW_ASSIGN_OR_RAISE(auto key_nullable, FromProto(map.key())); - ARROW_ASSIGN_OR_RAISE(auto value_nullable, FromProto(map.value())); + ARROW_ASSIGN_OR_RAISE(auto key_nullable, FromProto(map.key(), ext_set)); + ARROW_ASSIGN_OR_RAISE(auto value_nullable, FromProto(map.value(), ext_set)); if (key_nullable.second) { return Status::Invalid( @@ -199,6 +201,11 @@ Result, bool>> FromProto(const st::Type& typ field("value", std::move(value_nullable.first), value_nullable.second)); } + case st::Type::kUserDefinedTypeReference: { + auto anchor = type.user_defined_type_reference(); + return std::make_pair(ext_set.type_variations()[anchor], true); + } + default: break; } @@ -406,15 +413,18 @@ Result> FromProto(const st::NamedStruct& named_struct) { const auto& struct_ = named_struct.struct_(); RETURN_NOT_OK(CheckVariation(struct_)); + ExtensionSet ext_set; int requested_names_count = 0; - ARROW_ASSIGN_OR_RAISE(auto fields, - FieldsFromProto(struct_.types_size(), struct_.types(), - /*next_name=*/[&] { - int i = requested_names_count++; - return i < named_struct.names_size() - ? named_struct.names().Get(i) - : ""; - })); + ARROW_ASSIGN_OR_RAISE(auto fields, FieldsFromProto( + struct_.types_size(), struct_.types(), + /*next_name=*/ + [&] { + int i = requested_names_count++; + return i < named_struct.names_size() + ? named_struct.names().Get(i) + : ""; + }, + ext_set)); if (requested_names_count != named_struct.names_size()) { return Status::Invalid("While converting ", named_struct.DebugString(), " received ", diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h index 9ab37a88e94..8c219d51188 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -33,7 +33,8 @@ namespace arrow { namespace engine { ARROW_ENGINE_EXPORT -Result, bool>> FromProto(const st::Type&); +Result, bool>> FromProto(const st::Type&, + const ExtensionSet&); ARROW_ENGINE_EXPORT Result> ToProto(const DataType&, bool nullable, ExtensionSet*); From 8397ee5049591020666ea7c4f1c55efc795f1b8b Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Wed, 15 Dec 2021 12:39:52 -0500 Subject: [PATCH 018/113] refactor extension types to index variations alongside types --- .../arrow/engine/substrait/extension_types.cc | 225 ++++++++++-------- .../arrow/engine/substrait/extension_types.h | 57 +++-- cpp/src/arrow/engine/substrait/serde_test.cc | 69 ++++-- .../arrow/engine/substrait/type_internal.cc | 39 +-- 4 files changed, 224 insertions(+), 166 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index 66195934744..bc6b4ac4d67 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -143,68 +143,76 @@ bool UnwrapIntervalDay(const DataType& t) { return false; } -struct ExtensionSet::Impl { - struct IdHash { - size_t operator()(Id id) const { - internal::StringViewHash hash; - auto out = hash(id.uri); - internal::hash_combine(out, hash(id.name)); - return out; - } - }; +namespace { - using IdToIndexMap = std::unordered_map; +struct TypePtrHashEq { + template + size_t operator()(const Ptr& type) const { + return type->Hash(); + } - void AddUri(util::string_view uri, ExtensionSet* self) { - if (uris_.insert(uri).second) { - self->uris_.push_back(uri); - } + template + bool operator()(const Ptr& l, const Ptr& r) const { + return *l == *r; } +}; - Status CheckHasUri(util::string_view uri) { - if (uris_.count(uri) == 0) { - return Status::Invalid( - "Uri ", uri, - " was referenced by an extension but was not declared in the ExtensionSet."); - } - return Status::OK(); +struct IdHashEq { + using Id = ExtensionSet::Id; + + size_t operator()(Id id) const { + constexpr internal::StringViewHash hash = {}; + auto out = hash(id.uri); + internal::hash_combine(out, hash(id.name)); + return out; } - enum { kType, kTypeVariation }; + bool operator()(Id l, Id r) const { return l.uri == r.uri && l.name == r.name; } +}; + +} // namespace - template - uint32_t EncodeTypeOrTypeVariation(Id id, const std::shared_ptr& type, - ExtensionSet* self) { - AddUri(id.uri, self); +struct ExtensionSet::Impl { + void AddUri(util::string_view uri, ExtensionSet* self) { + if (uris_.find(uri) != uris_.end()) return; - auto map = (kTypeOrTypeVariation == kType ? &types_ : &type_variations_); + self->uris_.push_back(uri.to_string()); + uris_.insert(self->uris_.back()); // lookup helper's keys should reference memory + // owned by this ExtensionSet + } - auto ids = - (kTypeOrTypeVariation == kType ? &self->type_ids_ : &self->type_variation_ids_); + Status CheckHasUri(util::string_view uri) { + if (uris_.find(uri) != uris_.end()) return Status::OK(); - auto types = - (kTypeOrTypeVariation == kType ? &self->types_ : &self->type_variations_); + return Status::Invalid( + "Uri ", uri, + " was referenced by an extension but was not declared in the ExtensionSet."); + } - auto it_success = map->emplace(id, static_cast(map->size())); + uint32_t EncodeType(Id id, const std::shared_ptr& type, bool is_variation, + ExtensionSet* self) { + AddUri(id.uri, self); + auto it_success = types_.emplace(id, static_cast(types_.size())); if (it_success.second) { - DCHECK_EQ(ids->size(), types->size()); - ids->push_back(id); - types->push_back(type); + DCHECK_EQ(self->type_ids_.size(), self->types_.size()); + self->type_ids_.push_back(id); + self->types_.push_back(type); + self->type_is_variation_.push_back(is_variation); } return it_success.first->second; } std::unordered_set uris_; - IdToIndexMap type_variations_, types_; + std::unordered_map types_; }; ExtensionSet::ExtensionSet() : impl_(new Impl()) {} -Result ExtensionSet::Make(std::vector uris, - std::vector type_variation_ids, +Result ExtensionSet::Make(std::vector uris, std::vector type_ids, + std::vector type_is_variation, ExtensionIdRegistry* registry) { ExtensionSet set; @@ -214,91 +222,110 @@ Result ExtensionSet::Make(std::vector uris, } set.uris_ = std::move(uris); - set.types_.resize(type_ids.size()); - set.type_variations_.resize(type_variation_ids.size()); - - uint32_t anchor = 0; - for (Id id : type_variation_ids) { - auto i = anchor++; - if (id.empty()) continue; - RETURN_NOT_OK(set.impl_->CheckHasUri(id.uri)); - - auto type = registry->GetTypeVariation(id); - if (type == nullptr) { - return Status::Invalid("Type variation not found"); - } - set.types_[i] = std::move(type); + if (type_ids.size() != type_is_variation.size()) { + return Status::Invalid("Received ", type_ids.size(), " type ids but a ", + type_is_variation.size(), "-long is_variation vector"); } + set.types_.resize(type_ids.size()); - anchor = 0; - for (Id id : type_ids) { - auto i = anchor++; - if (id.empty()) continue; - RETURN_NOT_OK(set.impl_->CheckHasUri(id.uri)); + for (size_t i = 0; i < type_ids.size(); ++i) { + if (type_ids[i].empty()) continue; + RETURN_NOT_OK(set.impl_->CheckHasUri(type_ids[i].uri)); - auto type = registry->GetType(id); - if (type == nullptr) { - return Status::Invalid("Type not found"); + if (auto rec = registry->GetType(type_ids[i], type_is_variation[i])) { + set.types_[i] = rec->type; + type_ids[i] = rec->id; // use Id which references memory owned by the registry + continue; } - set.types_[i] = std::move(type); + return Status::Invalid("Type not found"); } set.type_ids_ = std::move(type_ids); - set.type_variation_ids_ = std::move(type_variation_ids); + set.type_is_variation_ = std::move(type_is_variation); return std::move(set); } ExtensionSet::~ExtensionSet() = default; -uint32_t ExtensionSet::EncodeTypeVariation(Id id, const std::shared_ptr& type) { - return impl_->EncodeTypeOrTypeVariation(id, type, this); -} - -uint32_t ExtensionSet::EncodeType(Id id, const std::shared_ptr& type) { - return impl_->EncodeTypeOrTypeVariation(id, type, this); +uint32_t ExtensionSet::EncodeType(Id id, const std::shared_ptr& type, + bool is_variation) { + return impl_->EncodeType(id, type, is_variation, this); } ExtensionIdRegistry* default_extension_id_registry() { - static struct : ExtensionIdRegistry { - struct TypeHashEq { - size_t operator()(const std::shared_ptr& type) const { - return type->Hash(); - } - bool operator()(const std::shared_ptr& l, - const std::shared_ptr& r) const { - return *l == *r; + static struct Impl : ExtensionIdRegistry { + Impl() { + struct TypeName { + std::shared_ptr type; + util::string_view name; + }; + for (TypeName e : { + TypeName{null(), "null"}, + TypeName{uint8(), "u8"}, + TypeName{uint16(), "u16"}, + TypeName{uint32(), "u32"}, + TypeName{uint64(), "u64"}, + }) { + DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type), + /*is_variation=*/true)); } - }; - - util::optional GetTypeVariation( - const std::shared_ptr& type) const override { - auto it = type_variations_.find(type); - if (it == type_variations_.end()) return {}; - return it->second; - } - std::shared_ptr GetTypeVariation(Id) const override { return nullptr; } - Status RegisterTypeVariation(Id id, const std::shared_ptr& type) override { - if (type_variations_.emplace(type, id).second) return Status::OK(); - return Status::Invalid("TypeVariation id was already registered"); } + util::optional GetType(const DataType& type) const override { + auto it = type_to_index_.find(&type); + if (it == type_to_index_.end()) return {}; - util::optional GetType(const std::shared_ptr&) const override { - return {}; + int index = it->second; + return TypeRecord{ids_[index], types_[index], type_is_variation_[index]}; } - std::shared_ptr GetType(Id) const override { return nullptr; } - Status RegisterType(Id, const std::shared_ptr&) override { - return Status::NotImplemented("FIXME"); + + util::optional GetType(Id id, bool is_variation) const override { + auto* id_to_index = is_variation ? &variation_id_to_index_ : &id_to_index_; + auto it = id_to_index->find(id); + if (it == id_to_index->end()) return {}; + + int index = it->second; + return TypeRecord{ids_[index], types_[index], type_is_variation_[index]}; } - std::unordered_map, Id, TypeHashEq, TypeHashEq> - type_variations_, types_; - } impl_; + Status RegisterType(Id id, std::shared_ptr type, + bool is_variation) override { + DCHECK_EQ(ids_.size(), types_.size()); + DCHECK_EQ(ids_.size(), type_is_variation_.size()); - constexpr util::string_view kArrowExtTypesUrl = - "https://github.com/apache/arrow/blob/master/format/substrait/extension_types.yaml"; + Id copied_id{*uris_.emplace(id.uri.to_string()).first, + *names_.emplace(id.name.to_string()).first}; - DCHECK_OK(impl_.RegisterTypeVariation({kArrowExtTypesUrl, "null"}, null())); + size_t index = ids_.size(); + + auto* id_to_index = is_variation ? &variation_id_to_index_ : &id_to_index_; + auto it_success = id_to_index->emplace(copied_id, index); + + if (!it_success.second) { + return Status::Invalid("Type id was already registered"); + } + + if (!type_to_index_.emplace(type.get(), index).second) { + id_to_index->erase(it_success.first); + return Status::Invalid("Type was already registered"); + } + + ids_.push_back(copied_id); + types_.push_back(std::move(type)); + type_is_variation_.push_back(is_variation); + return Status::OK(); + } + + // owning storage of uris, names, types + std::unordered_set uris_, names_; + DataTypeVector types_; + std::vector type_is_variation_; + + // non-owning lookup helpers + std::vector ids_; + std::unordered_map id_to_index_, variation_id_to_index_; + std::unordered_map type_to_index_; + } impl_; return &impl_; } diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index 6ca30c41353..6722d969855 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -97,20 +97,22 @@ class ARROW_ENGINE_EXPORT ExtensionIdRegistry { util::string_view uri, name; bool empty() const { return uri.empty() && name.empty(); } - - bool operator==(Id other) const { return uri == other.uri && name == other.name; } - bool operator!=(Id other) const { return !(*this == other); } }; - virtual util::optional GetTypeVariation(const std::shared_ptr&) const = 0; - virtual std::shared_ptr GetTypeVariation(Id) const = 0; - virtual Status RegisterTypeVariation(Id, const std::shared_ptr&) = 0; - - virtual util::optional GetType(const std::shared_ptr&) const = 0; - virtual std::shared_ptr GetType(Id) const = 0; - virtual Status RegisterType(Id, const std::shared_ptr&) = 0; + struct TypeRecord { + Id id; + const std::shared_ptr& type; + bool is_variation; + }; + virtual util::optional GetType(const DataType&) const = 0; + virtual util::optional GetType(Id, bool is_variation) const = 0; + virtual Status RegisterType(Id, std::shared_ptr, bool is_variation) = 0; }; +constexpr util::string_view kArrowExtTypesUri = + "https://github.com/apache/arrow/blob/master/format/substrait/" + "extension_types.yaml"; + ARROW_ENGINE_EXPORT ExtensionIdRegistry* default_extension_id_registry(); /// A subset of an ExtensionIdRegistry with extensions identifiable by an integer. @@ -125,36 +127,39 @@ class ARROW_ENGINE_EXPORT ExtensionSet { /// Construct an ExtensionSet with explicit extension ids for efficient referencing /// during deserialization. Note that input vectors need not be densely packed; an empty /// (default constructed) Id may be used as a placeholder to indicate an unused - /// _anchor/_reference. + /// _anchor/_reference. This factory will be used to wrap the extensions declared in a + /// substrait::Plan before deserializing the plan's relations. static Result Make( - std::vector uris, std::vector type_variation_ids, - std::vector type_ids, ExtensionIdRegistry* = default_extension_id_registry()); + std::vector uris, std::vector type_ids, + std::vector type_is_variation, + ExtensionIdRegistry* = default_extension_id_registry()); ~ExtensionSet(); // index in these vectors == value of _anchor/_reference fields /// FIXME this assumes that _anchor/_references won't be huge, which is not guaranteed. /// Could it be? - const std::vector& uris() const { return uris_; } - - const DataTypeVector& type_variations() const { return type_variations_; } - const std::vector& type_variation_ids() const { return type_variation_ids_; } + const std::vector& uris() const { return uris_; } const DataTypeVector& types() const { return types_; } const std::vector& type_ids() const { return type_ids_; } + bool type_is_variation(uint32_t i) const { return type_is_variation_[i]; } - /// Encode a type as a substrait::ExtensionTypeVariation. - /// Returns an integer usable for Type.*.type_variation_reference. - uint32_t EncodeTypeVariation(Id, const std::shared_ptr&); + /// Encode a type as a substrait::ExtensionType or a substrait::ExtensionTypeVariation. + /// Returns an integer usable for Type.user_defined_type_reference. This method will be + /// invoked during serialization when non substrait-core types are encountered. + uint32_t EncodeType(Id, const std::shared_ptr&, bool is_variation); + uint32_t EncodeType(ExtensionIdRegistry::TypeRecord rec) { + return EncodeType(rec.id, rec.type, rec.is_variation); + } - /// Encode a type as a substrait::ExtensionType. - /// Returns an integer usable for Type.user_defined_type_reference. - uint32_t EncodeType(Id, const std::shared_ptr&); + // FIXME need type_internal.h::{AddExtensionSetToPlan, GetExtensionSetFromPlan} or so private: - DataTypeVector type_variations_, types_; - std::vector type_variation_ids_, type_ids_; - std::vector uris_; + DataTypeVector types_; + std::vector type_ids_; + std::vector uris_; + std::vector type_is_variation_; // pimpl pattern to hide lookup details struct Impl; diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 40f2911dafb..a03c9d2b275 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -28,6 +28,8 @@ #include "arrow/testing/matchers.h" #include "arrow/util/key_value_metadata.h" +using testing::HasSubstr; + namespace arrow { namespace engine { @@ -135,22 +137,22 @@ TEST(Substrait, SupportedTypes) { auto ExpectEq = [](util::string_view json, std::shared_ptr expected_type) { ARROW_SCOPED_TRACE(json); - ExtensionSet ext_set; + ExtensionSet empty; auto buf = SubstraitFromJSON("Type", json); - ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf, ext_set)); + ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf, empty)); EXPECT_EQ(*type, *expected_type); - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &ext_set)); - ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized, ext_set)); + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &empty)); + EXPECT_EQ(empty.types().size(), 0); + + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized, empty)); EXPECT_EQ(*roundtripped, *expected_type); }; ExpectEq(R"({"bool": {}})", boolean()); - ExpectEq(R"({"user_defined_type_reference": 0})", null()); - ExpectEq(R"({"i8": {}})", int8()); ExpectEq(R"({"i16": {}})", int16()); ExpectEq(R"({"i32": {}})", int32()); @@ -189,6 +191,37 @@ TEST(Substrait, SupportedTypes) { })); } +TEST(Substrait, SupportedExtensionTypes) { + ExtensionSet ext_set; + + for (auto expected_type : { + null(), + uint8(), + uint16(), + uint32(), + uint64(), + }) { + auto anchor = ext_set.types().size(); + + auto rec = default_extension_id_registry()->GetType(*expected_type); + EXPECT_TRUE(rec.has_value()); + + EXPECT_EQ(ext_set.EncodeType(*rec), anchor); + auto buf = SubstraitFromJSON( + "Type", "{\"user_defined_type_reference\": " + std::to_string(anchor) + "}"); + + ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf, ext_set)); + EXPECT_EQ(*type, *expected_type); + + auto size = ext_set.types().size(); + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &ext_set)); + EXPECT_EQ(ext_set.types().size(), size) << "was already added to the set above"; + + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized, ext_set)); + EXPECT_EQ(*roundtripped, *expected_type); + } +} + TEST(Substrait, NamedStruct) { auto buf = SubstraitFromJSON("NamedStruct", R"({ "struct": { @@ -247,25 +280,15 @@ TEST(Substrait, NamedStruct) { } TEST(Substrait, NoEquivalentArrowType) { - for (util::string_view json : { - R"({"user_defined_type_reference": 99})", - }) { - ARROW_SCOPED_TRACE(json); - auto buf = SubstraitFromJSON("Type", json); - ExtensionSet ext_set; - ASSERT_THAT(DeserializeType(*buf, ext_set), Raises(StatusCode::NotImplemented)); - } + auto buf = SubstraitFromJSON("Type", R"({"user_defined_type_reference": 99})"); + ExtensionSet empty; + ASSERT_THAT( + DeserializeType(*buf, empty), + Raises(StatusCode::Invalid, HasSubstr("did not have a corresponding anchor"))); } TEST(Substrait, NoEquivalentSubstraitType) { for (auto type : { - uint8(), - uint16(), - uint32(), - uint64(), - - float16(), - date32(), timestamp(TimeUnit::SECOND), timestamp(TimeUnit::NANO), @@ -273,8 +296,6 @@ TEST(Substrait, NoEquivalentSubstraitType) { time32(TimeUnit::SECOND), time32(TimeUnit::MILLI), time64(TimeUnit::NANO), - month_interval(), - day_time_interval(), decimal256(76, 67), @@ -289,8 +310,6 @@ TEST(Substrait, NoEquivalentSubstraitType) { large_utf8(), large_binary(), large_list(utf8()), - - month_day_nano_interval(), }) { ARROW_SCOPED_TRACE(type->ToString()); ExtensionSet set; diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index ee82b72ad06..9aa799ae2d1 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -202,8 +202,13 @@ Result, bool>> FromProto( } case st::Type::kUserDefinedTypeReference: { - auto anchor = type.user_defined_type_reference(); - return std::make_pair(ext_set.type_variations()[anchor], true); + uint32_t anchor = type.user_defined_type_reference(); + if (anchor >= ext_set.types().size() || ext_set.types()[anchor] == nullptr) { + return Status::Invalid( + "User defined type reference ", anchor, + " did not have a corresponding anchor in the extension set"); + } + return std::make_pair(ext_set.types()[anchor], true); } default: @@ -217,12 +222,7 @@ Result, bool>> FromProto( namespace { struct ToProtoImpl { - Status Visit(const NullType& t) { - auto id = *default_extension_id_registry()->GetTypeVariation(null()); - auto anchor = ext_set_->EncodeTypeVariation(id, null()); - type_->set_user_defined_type_reference(anchor); - return Status::OK(); - } + Status Visit(const NullType& t) { return EncodeUserDefined(t); } Status Visit(const BooleanType& t) { return SetWith(&st::Type::set_allocated_bool_); } @@ -231,12 +231,12 @@ struct ToProtoImpl { Status Visit(const Int32Type& t) { return SetWith(&st::Type::set_allocated_i32); } Status Visit(const Int64Type& t) { return SetWith(&st::Type::set_allocated_i64); } - Status Visit(const UInt8Type& t) { return NotImplemented(t); } - Status Visit(const UInt16Type& t) { return NotImplemented(t); } - Status Visit(const UInt32Type& t) { return NotImplemented(t); } - Status Visit(const UInt64Type& t) { return NotImplemented(t); } + Status Visit(const UInt8Type& t) { return EncodeUserDefined(t); } + Status Visit(const UInt16Type& t) { return EncodeUserDefined(t); } + Status Visit(const UInt32Type& t) { return EncodeUserDefined(t); } + Status Visit(const UInt64Type& t) { return EncodeUserDefined(t); } - Status Visit(const HalfFloatType& t) { return NotImplemented(t); } + Status Visit(const HalfFloatType& t) { return EncodeUserDefined(t); } Status Visit(const FloatType& t) { return SetWith(&st::Type::set_allocated_fp32); } Status Visit(const DoubleType& t) { return SetWith(&st::Type::set_allocated_fp64); } @@ -270,8 +270,8 @@ struct ToProtoImpl { return SetWith(&st::Type::set_allocated_time); } - Status Visit(const MonthIntervalType& t) { return NotImplemented(t); } - Status Visit(const DayTimeIntervalType& t) { return NotImplemented(t); } + Status Visit(const MonthIntervalType& t) { return EncodeUserDefined(t); } + Status Visit(const DayTimeIntervalType& t) { return EncodeUserDefined(t); } Status Visit(const Decimal128Type& t) { auto dec = SetWithThen(&st::Type::set_allocated_decimal); @@ -354,7 +354,7 @@ struct ToProtoImpl { Status Visit(const LargeStringType& t) { return NotImplemented(t); } Status Visit(const LargeBinaryType& t) { return NotImplemented(t); } Status Visit(const LargeListType& t) { return NotImplemented(t); } - Status Visit(const MonthDayNanoIntervalType& t) { return NotImplemented(t); } + Status Visit(const MonthDayNanoIntervalType& t) { return EncodeUserDefined(t); } template Sub* SetWithThen(void (st::Type::*set_allocated_sub)(Sub*)) { @@ -372,6 +372,13 @@ struct ToProtoImpl { return SetWithThen(set_allocated_sub), Status::OK(); } + template + Status EncodeUserDefined(const T& t) { + static auto rec = default_extension_id_registry()->GetType(t); + type_->set_user_defined_type_reference(ext_set_->EncodeType(*rec)); + return Status::OK(); + } + Status NotImplemented(const DataType& t) { return Status::NotImplemented("conversion to substrait::Type from ", t.ToString()); } From 61feb19ef99a57ab3e5f1decfadff2a245ba10c6 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Wed, 15 Dec 2021 12:50:48 -0500 Subject: [PATCH 019/113] use an ExtensionSet-local registry --- cpp/src/arrow/engine/substrait/extension_types.cc | 11 ++++++++++- cpp/src/arrow/engine/substrait/extension_types.h | 10 ++++++---- cpp/src/arrow/engine/substrait/serde_test.cc | 6 ++---- cpp/src/arrow/engine/substrait/type_internal.cc | 4 ++-- 4 files changed, 20 insertions(+), 11 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index bc6b4ac4d67..d527e10b5cb 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -208,13 +208,15 @@ struct ExtensionSet::Impl { std::unordered_map types_; }; -ExtensionSet::ExtensionSet() : impl_(new Impl()) {} +ExtensionSet::ExtensionSet(ExtensionIdRegistry* registry) + : registry_(registry), impl_(new Impl()) {} Result ExtensionSet::Make(std::vector uris, std::vector type_ids, std::vector type_is_variation, ExtensionIdRegistry* registry) { ExtensionSet set; + set.registry_ = registry; for (auto uri : uris) { if (uri.empty()) continue; @@ -253,6 +255,13 @@ uint32_t ExtensionSet::EncodeType(Id id, const std::shared_ptr& type, return impl_->EncodeType(id, type, is_variation, this); } +Result ExtensionSet::EncodeType(const DataType& type) { + if (auto rec = registry_->GetType(type)) { + return EncodeType(rec->id, rec->type, rec->is_variation); + } + return Status::KeyError("type ", type.ToString(), " not found in the registry"); +} + ExtensionIdRegistry* default_extension_id_registry() { static struct Impl : ExtensionIdRegistry { Impl() { diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index 6722d969855..4c58dcef65c 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -121,7 +121,7 @@ class ARROW_ENGINE_EXPORT ExtensionSet { using Id = ExtensionIdRegistry::Id; /// Construct an empty ExtensionSet to be populated during serialization. - ExtensionSet(); + explicit ExtensionSet(ExtensionIdRegistry* = default_extension_id_registry()); ARROW_DEFAULT_MOVE_AND_ASSIGN(ExtensionSet); /// Construct an ExtensionSet with explicit extension ids for efficient referencing @@ -149,13 +149,15 @@ class ARROW_ENGINE_EXPORT ExtensionSet { /// Returns an integer usable for Type.user_defined_type_reference. This method will be /// invoked during serialization when non substrait-core types are encountered. uint32_t EncodeType(Id, const std::shared_ptr&, bool is_variation); - uint32_t EncodeType(ExtensionIdRegistry::TypeRecord rec) { - return EncodeType(rec.id, rec.type, rec.is_variation); - } + + /// Encode a type, looking it up first in this set's ExtensionIdRegistry. + /// If no type is found, an error will be raised. + Result EncodeType(const DataType& type); // FIXME need type_internal.h::{AddExtensionSetToPlan, GetExtensionSetFromPlan} or so private: + ExtensionIdRegistry* registry_; DataTypeVector types_; std::vector type_ids_; std::vector uris_; diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index a03c9d2b275..4fc29864d41 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -28,6 +28,7 @@ #include "arrow/testing/matchers.h" #include "arrow/util/key_value_metadata.h" +using testing::Eq; using testing::HasSubstr; namespace arrow { @@ -203,10 +204,7 @@ TEST(Substrait, SupportedExtensionTypes) { }) { auto anchor = ext_set.types().size(); - auto rec = default_extension_id_registry()->GetType(*expected_type); - EXPECT_TRUE(rec.has_value()); - - EXPECT_EQ(ext_set.EncodeType(*rec), anchor); + EXPECT_THAT(ext_set.EncodeType(*expected_type), ResultWith(Eq(anchor))); auto buf = SubstraitFromJSON( "Type", "{\"user_defined_type_reference\": " + std::to_string(anchor) + "}"); diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 9aa799ae2d1..9c6e7c256ef 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -374,8 +374,8 @@ struct ToProtoImpl { template Status EncodeUserDefined(const T& t) { - static auto rec = default_extension_id_registry()->GetType(t); - type_->set_user_defined_type_reference(ext_set_->EncodeType(*rec)); + ARROW_ASSIGN_OR_RAISE(auto anchor, ext_set_->EncodeType(t)); + type_->set_user_defined_type_reference(anchor); return Status::OK(); } From 1eb4bc075fd6e89b239a062dc9e844d7b80156a5 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 17 Dec 2021 11:30:08 -0500 Subject: [PATCH 020/113] add ExtensionSet <-> Plan factories --- cpp/src/arrow/engine/CMakeLists.txt | 3 +- .../arrow/engine/substrait/extension_types.cc | 4 +- .../arrow/engine/substrait/extension_types.h | 21 +-- .../arrow/engine/substrait/plan_internal.cc | 129 ++++++++++++++++++ .../arrow/engine/substrait/plan_internal.h | 40 ++++++ .../arrow/engine/substrait/type_internal.cc | 26 ++-- 6 files changed, 188 insertions(+), 35 deletions(-) create mode 100644 cpp/src/arrow/engine/substrait/plan_internal.cc create mode 100644 cpp/src/arrow/engine/substrait/plan_internal.h diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 2471216d7d2..239cdfc464f 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -29,6 +29,7 @@ set(ARROW_ENGINE_SRCS substrait/expression_internal.cc substrait/extension_types.cc substrait/serde.cc + substrait/plan_internal.cc substrait/type_internal.cc) set(SUBSTRAIT_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait") @@ -83,7 +84,7 @@ find_package(Git) add_custom_target(substrait_gen_verify COMMENT "Verifying that generated substrait accessors are consistent with \ ARROW_SUBSTRAIT_REPO_AND_TAG='${ARROW_SUBSTRAIT_REPO_AND_TAG}'" - COMMAND ${GIT_EXECUTABLE} diff --quiet ${SUBSTRAIT_GEN_DIR} + COMMAND ${GIT_EXECUTABLE} diff --exit-code ${SUBSTRAIT_GEN_DIR} DEPENDS substrait_gen) add_arrow_lib(arrow_engine diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index d527e10b5cb..1cd7aab708a 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -209,7 +209,7 @@ struct ExtensionSet::Impl { }; ExtensionSet::ExtensionSet(ExtensionIdRegistry* registry) - : registry_(registry), impl_(new Impl()) {} + : registry_(registry), impl_(new Impl(), [](Impl* impl) { delete impl; }) {} Result ExtensionSet::Make(std::vector uris, std::vector type_ids, @@ -248,8 +248,6 @@ Result ExtensionSet::Make(std::vector uris, return std::move(set); } -ExtensionSet::~ExtensionSet() = default; - uint32_t ExtensionSet::EncodeType(Id id, const std::shared_ptr& type, bool is_variation) { return impl_->EncodeType(id, type, is_variation, this); diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index 4c58dcef65c..64a71d0a798 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -36,9 +36,6 @@ namespace engine { // // Note that these are not automatically registered with arrow::RegisterExtensionType(), // which means among other things that serialization of these types to IPC would fail. -// -// FIXME we'll also need arrow::ExtensionTypes to wrap substrait::ExtensionTypeVariations -// and substrait::ExtensionTypes. /// fixed_size_binary(16) for storing Universally Unique IDentifiers ARROW_ENGINE_EXPORT @@ -80,17 +77,9 @@ bool UnwrapIntervalYear(const DataType&); ARROW_ENGINE_EXPORT bool UnwrapIntervalDay(const DataType&); -// We need to be able to append to ExtensionSets as we serialize- -// we first serialize Plan.relations, then finalize by hydrating -// Plan.extensions etc with the accumulated variations etc -// -// We need to be able to draw from ExtensionSets as we deserialize- -// type variation references in protobuf are just ints and we need to -// be able to look them up and efficiently hydrate with the corresponding -// DataType. - /// A mapping from arrow types and functions to the (uri, name) which identifies -/// the corresponding substrait extension. +/// the corresponding substrait extension. Substrait types and variations must be +/// registered with their corresponding arrow::DataType before they can be used! class ARROW_ENGINE_EXPORT ExtensionIdRegistry { public: struct Id { @@ -134,8 +123,6 @@ class ARROW_ENGINE_EXPORT ExtensionSet { std::vector type_is_variation, ExtensionIdRegistry* = default_extension_id_registry()); - ~ExtensionSet(); - // index in these vectors == value of _anchor/_reference fields /// FIXME this assumes that _anchor/_references won't be huge, which is not guaranteed. /// Could it be? @@ -154,8 +141,6 @@ class ARROW_ENGINE_EXPORT ExtensionSet { /// If no type is found, an error will be raised. Result EncodeType(const DataType& type); - // FIXME need type_internal.h::{AddExtensionSetToPlan, GetExtensionSetFromPlan} or so - private: ExtensionIdRegistry* registry_; DataTypeVector types_; @@ -165,7 +150,7 @@ class ARROW_ENGINE_EXPORT ExtensionSet { // pimpl pattern to hide lookup details struct Impl; - std::unique_ptr impl_; + std::unique_ptr impl_; }; } // namespace engine diff --git a/cpp/src/arrow/engine/substrait/plan_internal.cc b/cpp/src/arrow/engine/substrait/plan_internal.cc new file mode 100644 index 00000000000..02500ce782a --- /dev/null +++ b/cpp/src/arrow/engine/substrait/plan_internal.cc @@ -0,0 +1,129 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "arrow/engine/substrait/plan_internal.h" + +#include "arrow/result.h" +#include "arrow/util/hashing.h" +#include "arrow/util/logging.h" +#include "arrow/util/make_unique.h" + +namespace arrow { +namespace engine { + +Status AddExtensionSetToPlan(const ExtensionSet& ext_set, st::Plan* plan) { + plan->clear_extension_uris(); + + std::unordered_map map; + + auto uris = plan->mutable_extension_uris(); + uris->Reserve(static_cast(ext_set.uris().size())); + for (size_t anchor = 0; anchor < ext_set.uris().size(); ++anchor) { + const auto& uri = ext_set.uris()[anchor]; + if (uri.empty()) continue; + + auto ext_uri = internal::make_unique(); + ext_uri->set_uri(uri); + ext_uri->set_extension_uri_anchor(anchor); + uris->AddAllocated(ext_uri.release()); + + map[uri] = anchor; + } + + auto extensions = plan->mutable_extensions(); + extensions->Reserve(static_cast(ext_set.types().size())); + + for (size_t anchor = 0; anchor < ext_set.type_ids().size(); ++anchor) { + auto id = ext_set.type_ids()[anchor]; + if (id.empty()) continue; + + using ExtDecl = st::extensions::SimpleExtensionDeclaration; + auto ext_decl = internal::make_unique(); + + if (ext_set.type_is_variation(anchor)) { + auto type_var = internal::make_unique(); + type_var->set_extension_uri_pointer(map[id.uri]); + type_var->set_type_variation_anchor(anchor); + type_var->set_name(id.name.to_string()); + ext_decl->set_allocated_extension_type_variation(type_var.release()); + } else { + auto type = internal::make_unique(); + type->set_extension_uri_reference(map[id.uri]); + type->set_type_anchor(anchor); + type->set_name(id.name.to_string()); + ext_decl->set_allocated_extension_type(type.release()); + } + + extensions->AddAllocated(ext_decl.release()); + } + + return Status::OK(); +} + +namespace { +template +void SetElement(size_t i, T element, std::vector* vector) { + DCHECK_LE(i, 1 << 20); + if (i >= vector->size()) { + vector->resize(i + 1); + } + (*vector)[i] = std::move(element); +} +} // namespace + +Result GetExtensionSetFromPlan(const st::Plan& plan, + ExtensionIdRegistry* registry) { + std::vector uris; + for (const auto& uri : plan.extension_uris()) { + SetElement(uri.extension_uri_anchor(), uri.uri(), &uris); + } + + // NOTE: it's acceptable to use views to memory owned by plan; ExtensionSet::Make + // will only store views to memory owned by registry. + + std::vector type_ids; + std::vector type_is_variation; + for (const auto& ext : plan.extensions()) { + switch (ext.mapping_type_case()) { + case st::extensions::SimpleExtensionDeclaration::kExtensionTypeVariation: { + const auto& type_var = ext.extension_type_variation(); + util::string_view uri = uris[type_var.extension_uri_pointer()]; + SetElement(type_var.type_variation_anchor(), {uri, type_var.name()}, &type_ids); + SetElement(type_var.type_variation_anchor(), true, &type_is_variation); + break; + } + + case st::extensions::SimpleExtensionDeclaration::kExtensionType: { + const auto& type = ext.extension_type(); + util::string_view uri = uris[type.extension_uri_reference()]; + SetElement(type.type_anchor(), {uri, type.name()}, &type_ids); + SetElement(type.type_anchor(), false, &type_is_variation); + break; + } + + case st::extensions::SimpleExtensionDeclaration::kExtensionFunction: + default: + return Status::NotImplemented(""); + } + } + + return ExtensionSet::Make(std::move(uris), std::move(type_ids), + std::move(type_is_variation), registry); +} + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/plan_internal.h b/cpp/src/arrow/engine/substrait/plan_internal.h new file mode 100644 index 00000000000..ec344a250d0 --- /dev/null +++ b/cpp/src/arrow/engine/substrait/plan_internal.h @@ -0,0 +1,40 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// This API is EXPERIMENTAL. + +#pragma once + +#include "arrow/engine/substrait/extension_types.h" +#include "arrow/engine/visibility.h" +#include "arrow/type_fwd.h" +#include "generated/substrait/plan.pb.h" // IWYU pragma: export + +namespace st = io::substrait; + +namespace arrow { +namespace engine { + +ARROW_ENGINE_EXPORT +Status AddExtensionSetToPlan(const ExtensionSet&, st::Plan*); + +ARROW_ENGINE_EXPORT +Result GetExtensionSetFromPlan( + const st::Plan&, ExtensionIdRegistry* = default_extension_id_registry()); + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 9c6e7c256ef..ab9717bbfd8 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -398,19 +398,6 @@ Result> ToProto(const DataType& type, bool nullable, return std::move(out); } -namespace { -void ToProtoGetDepthFirstNames(const FieldVector& fields, - google::protobuf::RepeatedPtrField* names) { - for (const auto& field : fields) { - *names->Add() = field->name(); - - if (field->type()->id() == Type::STRUCT) { - ToProtoGetDepthFirstNames(field->type()->fields(), names); - } - } -} -} // namespace - Result> FromProto(const st::NamedStruct& named_struct) { if (!named_struct.has_struct_()) { return Status::Invalid("While converting ", named_struct.DebugString(), @@ -442,6 +429,19 @@ Result> FromProto(const st::NamedStruct& named_struct) { return schema(std::move(fields)); } +namespace { +void ToProtoGetDepthFirstNames(const FieldVector& fields, + google::protobuf::RepeatedPtrField* names) { + for (const auto& field : fields) { + *names->Add() = field->name(); + + if (field->type()->id() == Type::STRUCT) { + ToProtoGetDepthFirstNames(field->type()->fields(), names); + } + } +} +} // namespace + Result> ToProto(const Schema& schema) { if (schema.metadata()) { return Status::Invalid("substrait::NamedStruct does not support schema metadata"); From e63da1e5b3e3562f5ea26f40a1dfbe08120f9908 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Mon, 10 Jan 2022 14:00:49 -0500 Subject: [PATCH 021/113] pre merge stash --- .../engine/substrait/expression_internal.cc | 41 ++++++++++++++----- .../arrow/engine/substrait/extension_types.cc | 1 + .../arrow/engine/substrait/extension_types.h | 24 ++++++++++- .../arrow/engine/substrait/plan_internal.cc | 40 +++++++++++++++--- 4 files changed, 88 insertions(+), 18 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 7d1f5cfc820..1e06b4b5195 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -30,7 +30,6 @@ #include "arrow/engine/visibility.h" #include "arrow/result.h" #include "arrow/status.h" - #include "arrow/util/make_unique.h" #include "generated/substrait/expression.pb.h" // IWYU pragma: export @@ -75,7 +74,7 @@ Result FromProto(const st::Expression& expr) { if (auto root_ref = root_expr->field_ref()) { out = FieldRef(std::move(out), *root_ref); } else { - // FIXME add field_ref compute function to handle + // FIXME add struct_field compute function to handle // field references into expressions break; } @@ -113,6 +112,20 @@ Result FromProto(const st::Expression& expr) { {std::move(if_), std::move(then), std::move(else_)}); } + case st::Expression::kScalarFunction: { + const auto& scalar_fn = expr.scalar_function(); + + ExtensionSet ext_set; + auto id = ext_set.function_ids()[scalar_fn.function_reference()]; + + std::vector arguments(scalar_fn.args_size()); + for (size_t i = 0; i < arguments.size(); ++i) { + ARROW_ASSIGN_OR_RAISE(arguments[i], FromProto(scalar_fn.args(i))); + } + + return compute::call(id.name.to_string(), std::move(arguments)); + } + default: break; } @@ -595,9 +608,10 @@ Result> ToProto(const compute::Expression& expr) return Status::Invalid("ToProto requires a bound Expression"); } + auto out = internal::make_unique(); + if (auto datum = expr.literal()) { ARROW_ASSIGN_OR_RAISE(auto literal, ToProto(*datum)); - auto out = internal::make_unique(); out->set_allocated_literal(literal.release()); return std::move(out); } @@ -605,7 +619,6 @@ Result> ToProto(const compute::Expression& expr) if (auto param = expr.parameter()) { // Special case of a nested StructField DCHECK(!param->indices.empty()); - auto out = internal::make_unique(); for (auto it = param->indices.rbegin(); it != param->indices.rend(); ++it) { auto struct_field = @@ -657,7 +670,6 @@ Result> ToProto(const compute::Expression& expr) field_ref->set_allocated_direct_reference(ref_segment.release()); field_ref->set_allocated_expression(arguments[0].release()); - auto out = internal::make_unique(); out->set_allocated_selection(field_ref.release()); return std::move(out); } @@ -674,12 +686,10 @@ Result> ToProto(const compute::Expression& expr) if_then->mutable_ifs()->AddAllocated(if_clause.release()); if_then->set_allocated_else_(arguments[2].release()); - auto out = internal::make_unique(); out->set_allocated_if_then(if_then.release()); return std::move(out); } - // other expression types dive into extensions immediately /* if (call->function_name == "case_when") { auto conditions = call->arguments[0].call(); @@ -703,10 +713,21 @@ Result> ToProto(const compute::Expression& expr) return std::move(out); } } - */ + // other expression types dive into extensions immediately + ExtensionSet* ext_set = nullptr; + ARROW_ASSIGN_OR_RAISE(auto anchor, ext_set->EncodeFunction({"", call->function_name})); + + auto scalar_fn = internal::make_unique(); + scalar_fn->set_function_reference(anchor); + scalar_fn->mutable_args()->Reserve(arguments.size()); + for (auto& arg : arguments) { + scalar_fn->mutable_args()->AddAllocated(arg.release()); + } - return Status::NotImplemented("conversion to substrait::Expression from ", - expr.ToString()); + out->set_allocated_scalar_function(scalar_fn.release()); + return std::move(out); + */ + return Status::NotImplemented(""); } } // namespace engine diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index 1cd7aab708a..256ac3bc993 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -214,6 +214,7 @@ ExtensionSet::ExtensionSet(ExtensionIdRegistry* registry) Result ExtensionSet::Make(std::vector uris, std::vector type_ids, std::vector type_is_variation, + std::vector function_ids, ExtensionIdRegistry* registry) { ExtensionSet set; set.registry_ = registry; diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index 64a71d0a798..b466fc3bc91 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -22,6 +22,7 @@ #include #include "arrow/buffer.h" +#include "arrow/compute/function.h" #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" #include "arrow/util/optional.h" @@ -96,6 +97,16 @@ class ARROW_ENGINE_EXPORT ExtensionIdRegistry { virtual util::optional GetType(const DataType&) const = 0; virtual util::optional GetType(Id, bool is_variation) const = 0; virtual Status RegisterType(Id, std::shared_ptr, bool is_variation) = 0; + + // FIXME some functions will not be simple enough to convert without access to their + // arguments/options. For example is_in embeds the set in options rather than using an + // argument: + // is_in(x, SetLookupOptions(set)) <-> (k...Uri, "is_in")(x, set) + // + // ... for another example, depending on the value of the first argument to + // substrait::add it either corresponds to arrow::add or arrow::add_checked + // virtual util::optional GetFunction(const compute::Expression&) const = 0; + // virtual Status RegisterFunction(Id, const std::string&) = 0; }; constexpr util::string_view kArrowExtTypesUri = @@ -118,9 +129,12 @@ class ARROW_ENGINE_EXPORT ExtensionSet { /// (default constructed) Id may be used as a placeholder to indicate an unused /// _anchor/_reference. This factory will be used to wrap the extensions declared in a /// substrait::Plan before deserializing the plan's relations. + /// + /// Views will be replaced with equivalent views pointing to memory owned by the + /// registry. static Result Make( std::vector uris, std::vector type_ids, - std::vector type_is_variation, + std::vector type_is_variation, std::vector function_ids, ExtensionIdRegistry* = default_extension_id_registry()); // index in these vectors == value of _anchor/_reference fields @@ -141,13 +155,19 @@ class ARROW_ENGINE_EXPORT ExtensionSet { /// If no type is found, an error will be raised. Result EncodeType(const DataType& type); + const std::vector& function_ids() const { return function_ids_; } + + Result EncodeFunction(Id); + private: ExtensionIdRegistry* registry_; + std::vector uris_; DataTypeVector types_; std::vector type_ids_; - std::vector uris_; std::vector type_is_variation_; + std::vector function_ids_; + // pimpl pattern to hide lookup details struct Impl; std::unique_ptr impl_; diff --git a/cpp/src/arrow/engine/substrait/plan_internal.cc b/cpp/src/arrow/engine/substrait/plan_internal.cc index 02500ce782a..9a3810c51b2 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.cc +++ b/cpp/src/arrow/engine/substrait/plan_internal.cc @@ -21,6 +21,7 @@ #include "arrow/util/hashing.h" #include "arrow/util/logging.h" #include "arrow/util/make_unique.h" +#include "arrow/util/unreachable.h" namespace arrow { namespace engine { @@ -45,13 +46,15 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, st::Plan* plan) { } auto extensions = plan->mutable_extensions(); - extensions->Reserve(static_cast(ext_set.types().size())); + extensions->Reserve( + static_cast(ext_set.type_ids().size() + ext_set.function_ids().size())); + + using ExtDecl = st::extensions::SimpleExtensionDeclaration; for (size_t anchor = 0; anchor < ext_set.type_ids().size(); ++anchor) { auto id = ext_set.type_ids()[anchor]; if (id.empty()) continue; - using ExtDecl = st::extensions::SimpleExtensionDeclaration; auto ext_decl = internal::make_unique(); if (ext_set.type_is_variation(anchor)) { @@ -71,6 +74,20 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, st::Plan* plan) { extensions->AddAllocated(ext_decl.release()); } + for (size_t anchor = 0; anchor < ext_set.function_ids().size(); ++anchor) { + auto id = ext_set.function_ids()[anchor]; + if (id.empty()) continue; + + auto fn = internal::make_unique(); + fn->set_extension_uri_pointer(map[id.uri]); + fn->set_function_anchor(anchor); + fn->set_name(id.name.to_string()); + + auto ext_decl = internal::make_unique(); + ext_decl->set_allocated_extension_function(fn.release()); + extensions->AddAllocated(ext_decl.release()); + } + return Status::OK(); } @@ -95,7 +112,7 @@ Result GetExtensionSetFromPlan(const st::Plan& plan, // NOTE: it's acceptable to use views to memory owned by plan; ExtensionSet::Make // will only store views to memory owned by registry. - std::vector type_ids; + std::vector type_ids, function_ids; std::vector type_is_variation; for (const auto& ext : plan.extensions()) { switch (ext.mapping_type_case()) { @@ -115,15 +132,26 @@ Result GetExtensionSetFromPlan(const st::Plan& plan, break; } - case st::extensions::SimpleExtensionDeclaration::kExtensionFunction: + case st::extensions::SimpleExtensionDeclaration::kExtensionFunction: { + const auto& fn = ext.extension_function(); + util::string_view uri = uris[fn.extension_uri_pointer()]; + SetElement(fn.function_anchor(), {uri, fn.name()}, &function_ids); + break; + } + default: - return Status::NotImplemented(""); + Unreachable(); } } return ExtensionSet::Make(std::move(uris), std::move(type_ids), - std::move(type_is_variation), registry); + std::move(type_is_variation), std::move(function_ids), + registry); } +// if read relation is LocalFiles -> produce dataset scan node Declaration +// otherwise -> invoke callback, probably does Voltron specific +// things with other read relation types + } // namespace engine } // namespace arrow From f37084ab4a504a83de3ebb5b7cab934e5bf8ed71 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Mon, 10 Jan 2022 14:23:07 -0500 Subject: [PATCH 022/113] post rebase cleanup --- cpp/src/arrow/array/array_base.cc | 2 ++ cpp/src/arrow/array/array_base.h | 2 ++ cpp/src/arrow/csv/column_decoder_test.cc | 1 + cpp/src/arrow/engine/substrait/expression_internal.cc | 1 + cpp/src/arrow/engine/substrait/type_internal.cc | 2 +- cpp/src/arrow/testing/matchers.h | 9 +++++---- 6 files changed, 12 insertions(+), 5 deletions(-) diff --git a/cpp/src/arrow/array/array_base.cc b/cpp/src/arrow/array/array_base.cc index c31a7b72483..11b6b1630c5 100644 --- a/cpp/src/arrow/array/array_base.cc +++ b/cpp/src/arrow/array/array_base.cc @@ -282,6 +282,8 @@ std::string Array::ToString() const { return ss.str(); } +void PrintTo(const Array& x, std::ostream* os) { *os << x.ToString(); } + Result> Array::View( const std::shared_ptr& out_type) const { ARROW_ASSIGN_OR_RAISE(std::shared_ptr result, diff --git a/cpp/src/arrow/array/array_base.h b/cpp/src/arrow/array/array_base.h index 63044c419cd..c17daad48fa 100644 --- a/cpp/src/arrow/array/array_base.h +++ b/cpp/src/arrow/array/array_base.h @@ -205,6 +205,8 @@ class ARROW_EXPORT Array { private: ARROW_DISALLOW_COPY_AND_ASSIGN(Array); + + ARROW_EXPORT friend void PrintTo(const Array& x, std::ostream* os); }; static inline std::ostream& operator<<(std::ostream& os, const Array& x) { diff --git a/cpp/src/arrow/csv/column_decoder_test.cc b/cpp/src/arrow/csv/column_decoder_test.cc index c8b96e04696..ebac7a3da2f 100644 --- a/cpp/src/arrow/csv/column_decoder_test.cc +++ b/cpp/src/arrow/csv/column_decoder_test.cc @@ -22,6 +22,7 @@ #include +#include "arrow/array/array_base.h" #include "arrow/csv/column_decoder.h" #include "arrow/csv/options.h" #include "arrow/csv/test_common.h" diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 1e06b4b5195..6ada3211cc5 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -31,6 +31,7 @@ #include "arrow/result.h" #include "arrow/status.h" #include "arrow/util/make_unique.h" +#include "arrow/visit_scalar_inline.h" #include "generated/substrait/expression.pb.h" // IWYU pragma: export namespace st = io::substrait; diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index ab9717bbfd8..3adc7d2b5b8 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -27,7 +27,7 @@ #include "arrow/type.h" #include "arrow/util/logging.h" #include "arrow/util/make_unique.h" -#include "arrow/visitor_inline.h" +#include "arrow/visit_type_inline.h" namespace arrow { namespace engine { diff --git a/cpp/src/arrow/testing/matchers.h b/cpp/src/arrow/testing/matchers.h index 5c57b4602dd..7ab1d6de2f1 100644 --- a/cpp/src/arrow/testing/matchers.h +++ b/cpp/src/arrow/testing/matchers.h @@ -24,6 +24,7 @@ #include "arrow/datum.h" #include "arrow/result.h" #include "arrow/status.h" +#include "arrow/stl_iterator.h" #include "arrow/testing/future_util.h" #include "arrow/testing/gtest_util.h" #include "arrow/util/future.h" @@ -358,10 +359,10 @@ inline DataEqMatcher DataEqArray(const std::shared_ptr& type, } /// Constructs an array from a vector of optionals against which arguments are matched -template < - typename T, typename ArrayType = typename TypeTraits::ArrayType, - typename BuilderType = typename TypeTraits::BuilderType, - typename ValueType = typename stl::detail::DefaultValueAccessor::ValueType> +template ::ArrayType, + typename BuilderType = typename TypeTraits::BuilderType, + typename ValueType = + typename ::arrow::stl::detail::DefaultValueAccessor::ValueType> DataEqMatcher DataEqArray(T type, const std::vector>& values) { BuilderType builder(std::make_shared(std::move(type)), default_memory_pool()); DCHECK_OK(builder.Reserve(static_cast(values.size()))); From 2725ed7d34f1b2c47280641538544d11411fa404 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 11 Jan 2022 12:55:37 +0100 Subject: [PATCH 023/113] Changes needed to get branch to compile Using `--preset ninja-debug`. Build will fail on initially on GCC 11+ due to a use of undefined error from googletest; lower version is needed to avoid hundreds of instances of an ambiguous print overload, but that version doesn't have googletest PR 3024 included yet. This change needs to be made manually in the googletest build tree as downloaded by cmake. --- cpp/src/arrow/engine/substrait/extension_types.cc | 10 +++++----- cpp/src/arrow/util/hashing.h | 2 +- cpp/src/arrow/util/reflection_internal.h | 2 +- cpp/thirdparty/versions.txt | 4 ++-- 4 files changed, 9 insertions(+), 9 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index 256ac3bc993..f08f27b1a52 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -47,7 +47,7 @@ struct FixedCharExtensionParams { std::shared_ptr FixedCharGetStorage(const FixedCharExtensionParams& params) { return fixed_size_binary(params.length); } -static auto kFixedCharExtensionParamsProperties = internal::MakeProperties( +static constexpr auto kFixedCharExtensionParamsProperties = internal::MakeProperties( internal::DataMember("length", &FixedCharExtensionParams::length)); using FixedCharType = @@ -62,7 +62,7 @@ struct VarCharExtensionParams { std::shared_ptr VarCharGetStorage(const VarCharExtensionParams&) { return utf8(); } -static auto kVarCharExtensionParamsProperties = internal::MakeProperties( +static constexpr auto kVarCharExtensionParamsProperties = internal::MakeProperties( internal::DataMember("length", &VarCharExtensionParams::length)); using VarCharType = @@ -109,7 +109,7 @@ std::shared_ptr interval_year() { return IntervalYearType::Make({}); } std::shared_ptr interval_day() { return IntervalDayType::Make({}); } bool UnwrapUuid(const DataType& t) { - if (auto params = UuidType::GetIf(t)) { + if (UuidType::GetIf(t)) { return true; } return false; @@ -130,14 +130,14 @@ util::optional UnwrapVarChar(const DataType& t) { } bool UnwrapIntervalYear(const DataType& t) { - if (auto params = IntervalYearType::GetIf(t)) { + if (IntervalYearType::GetIf(t)) { return true; } return false; } bool UnwrapIntervalDay(const DataType& t) { - if (auto params = IntervalDayType::GetIf(t)) { + if (IntervalDayType::GetIf(t)) { return true; } return false; diff --git a/cpp/src/arrow/util/hashing.h b/cpp/src/arrow/util/hashing.h index f6caf4419b2..d2c0178b008 100644 --- a/cpp/src/arrow/util/hashing.h +++ b/cpp/src/arrow/util/hashing.h @@ -887,7 +887,7 @@ struct StringViewHash { // (the std::hash specialization provided by nonstd constructs std::string // temporaries then invokes std::hash against those) hash_t operator()(const util::string_view& value) const { - return ComputeStringHash<>(value.data(), static_cast(value.size())); + return ComputeStringHash<0>(value.data(), static_cast(value.size())); } }; diff --git a/cpp/src/arrow/util/reflection_internal.h b/cpp/src/arrow/util/reflection_internal.h index 0440a2eb563..ca2d01e9be7 100644 --- a/cpp/src/arrow/util/reflection_internal.h +++ b/cpp/src/arrow/util/reflection_internal.h @@ -109,7 +109,7 @@ struct PropertyTuple { }; template -PropertyTuple MakeProperties(Properties... props) { +PropertyTuple constexpr MakeProperties(Properties... props) { return {std::make_tuple(props...)}; } diff --git a/cpp/thirdparty/versions.txt b/cpp/thirdparty/versions.txt index 80751adc028..9192160036b 100644 --- a/cpp/thirdparty/versions.txt +++ b/cpp/thirdparty/versions.txt @@ -53,8 +53,8 @@ ARROW_GOOGLE_CLOUD_CPP_BUILD_VERSION=v1.31.1 ARROW_GOOGLE_CLOUD_CPP_BUILD_SHA256_CHECKSUM=dc7cbf95b506a84b48cf71e0462985d262183edeaabdacaaee2109852394a609 ARROW_GRPC_BUILD_VERSION=v1.35.0 ARROW_GRPC_BUILD_SHA256_CHECKSUM=27dd2fc5c9809ddcde8eb6fa1fa278a3486566dfc28335fca13eb8df8bd3b958 -ARROW_GTEST_BUILD_VERSION=1.11.0 -ARROW_GTEST_BUILD_SHA256_CHECKSUM=b4870bf121ff7795ba20d20bcdd8627b8e088f2d1dab299a031c1034eddc93d5 +ARROW_GTEST_BUILD_VERSION=1.10.0 +ARROW_GTEST_BUILD_SHA256_CHECKSUM=9dc9157a9a1551ec7a7e43daea9a694a0bb5fb8bec81235d8a1e6ef64c716dcb ARROW_JEMALLOC_BUILD_VERSION=5.2.1 ARROW_JEMALLOC_BUILD_SHA256_CHECKSUM=34330e5ce276099e2e8950d9335db5a875689a4c6a56751ef3b1d8c537f887f6 # Include post-1.9.3 fixes for undefined behaviour From 11e7f3fdf6056ca23c90d03aab7e91d7c7f5f648 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 11 Jan 2022 14:22:40 +0100 Subject: [PATCH 024/113] Fix uninitialized pointers --- cpp/src/arrow/type.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h index 2383a94bb81..18c5532449e 100644 --- a/cpp/src/arrow/type.h +++ b/cpp/src/arrow/type.h @@ -76,7 +76,7 @@ class ARROW_EXPORT Fingerprintable { } protected: - Fingerprintable() = default; + Fingerprintable() : fingerprint_(NULLPTR), metadata_fingerprint_(NULLPTR) {} Fingerprintable(Fingerprintable&& other) { MoveFrom(std::move(other)); } From 96727e14ac8176e8d32edc253c88df24deecfa2b Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 11 Jan 2022 17:10:17 +0100 Subject: [PATCH 025/113] Fix FieldRef/StructField order --- .../arrow/engine/substrait/expression_internal.cc | 4 ++-- cpp/src/arrow/engine/substrait/serde_test.cc | 14 +++++++++++++- 2 files changed, 15 insertions(+), 3 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 6ada3211cc5..d8f677e3e79 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -73,7 +73,7 @@ Result FromProto(const st::Expression& expr) { if (root_expr) { if (auto root_ref = root_expr->field_ref()) { - out = FieldRef(std::move(out), *root_ref); + out = FieldRef(*root_ref, std::move(out)); } else { // FIXME add struct_field compute function to handle // field references into expressions @@ -621,7 +621,7 @@ Result> ToProto(const compute::Expression& expr) // Special case of a nested StructField DCHECK(!param->indices.empty()); - for (auto it = param->indices.rbegin(); it != param->indices.rend(); ++it) { + for (auto it = param->indices.begin(); it != param->indices.end(); ++it) { auto struct_field = internal::make_unique(); struct_field->set_field(*it); diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 4fc29864d41..932eadc0253 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -464,6 +464,19 @@ TEST(Substrait, FieldRefRoundTrip) { } } +TEST(Substrait, RecursiveFieldRef) { + FieldRef ref("struct_i32_str", "str"); + + ARROW_SCOPED_TRACE(ref.ToString()); + ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); + + auto json = SubstraitToJSON("Expression", *serialized); + EXPECT_EQ( + R"({"selection":{"directReference":{"structField":{"field":1}},"expression":{"selection":{"directReference":{"structField":{"field":12}},"rootReference":{}}}}})", + json); +} + TEST(Substrait, CallSpecialCaseRoundTrip) { for (compute::Expression expr : { compute::call("if_else", @@ -490,4 +503,3 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { } // namespace engine } // namespace arrow - From 07b259c632b50c314c21158d8dfc380cf9ad3090 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Tue, 11 Jan 2022 12:20:37 -0500 Subject: [PATCH 026/113] gcc: use a pointer to the properties tuple instead of a reference --- .../arrow/engine/simple_extension_type_internal.h | 12 ++++++------ cpp/src/arrow/engine/substrait/extension_types.cc | 10 +++++----- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/cpp/src/arrow/engine/simple_extension_type_internal.h b/cpp/src/arrow/engine/simple_extension_type_internal.h index 2c370e42d62..3e8b69ae36c 100644 --- a/cpp/src/arrow/engine/simple_extension_type_internal.h +++ b/cpp/src/arrow/engine/simple_extension_type_internal.h @@ -32,7 +32,7 @@ namespace arrow { namespace engine { template GetStorage(const Params&)> class SimpleExtensionType : public ExtensionType { public: @@ -62,7 +62,7 @@ class SimpleExtensionType : public ExtensionType { struct ExtensionEqualsImpl { ExtensionEqualsImpl(const Params& l, const Params& r) : left_(l), right_(r) { - kProperties.ForEach(*this); + kProperties->ForEach(*this); } template @@ -89,8 +89,8 @@ class SimpleExtensionType : public ExtensionType { struct DeserializeImpl { explicit DeserializeImpl(util::string_view repr) { - Init(kExtensionName, repr, kProperties.size()); - kProperties.ForEach(*this); + Init(kExtensionName, repr, kProperties->size()); + kProperties->ForEach(*this); } void Fail() { params_ = util::nullopt; } @@ -154,8 +154,8 @@ class SimpleExtensionType : public ExtensionType { struct SerializeImpl { explicit SerializeImpl(const Params& params) - : params_(params), members_(kProperties.size()) { - kProperties.ForEach(*this); + : params_(params), members_(kProperties->size()) { + kProperties->ForEach(*this); } template diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index f08f27b1a52..2d05d5c3616 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -38,7 +38,7 @@ static auto kUuidExtensionParamsProperties = internal::MakeProperties(); using UuidType = SimpleExtensionType; + &kUuidExtensionParamsProperties, UuidGetStorage>; constexpr util::string_view kFixedCharExtensionName = "fixed_char"; struct FixedCharExtensionParams { @@ -53,7 +53,7 @@ static constexpr auto kFixedCharExtensionParamsProperties = internal::MakeProper using FixedCharType = SimpleExtensionType; + &kFixedCharExtensionParamsProperties, FixedCharGetStorage>; constexpr util::string_view kVarCharExtensionName = "varchar"; struct VarCharExtensionParams { @@ -68,7 +68,7 @@ static constexpr auto kVarCharExtensionParamsProperties = internal::MakeProperti using VarCharType = SimpleExtensionType; + &kVarCharExtensionParamsProperties, VarCharGetStorage>; constexpr util::string_view kIntervalYearExtensionName = "interval_year"; struct IntervalYearExtensionParams {}; @@ -80,7 +80,7 @@ static auto kIntervalYearExtensionParamsProperties = internal::MakeProperties(); using IntervalYearType = SimpleExtensionType; + &kIntervalYearExtensionParamsProperties, IntervalYearGetStorage>; constexpr util::string_view kIntervalDayExtensionName = "interval_day"; struct IntervalDayExtensionParams {}; @@ -92,7 +92,7 @@ static auto kIntervalDayExtensionParamsProperties = internal::MakeProperties(); using IntervalDayType = SimpleExtensionType; + &kIntervalDayExtensionParamsProperties, IntervalDayGetStorage>; } // namespace From 885836ad2d38e0fac537ec6ad38336521befd471 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Tue, 11 Jan 2022 13:59:35 -0500 Subject: [PATCH 027/113] advance substrait version --- cpp/cmake_modules/DefineOptions.cmake | 2 +- cpp/src/arrow/engine/CMakeLists.txt | 15 +- .../engine/substrait/expression_internal.cc | 185 +- .../engine/substrait/expression_internal.h | 10 +- .../arrow/engine/substrait/plan_internal.cc | 22 +- .../arrow/engine/substrait/plan_internal.h | 6 +- cpp/src/arrow/engine/substrait/serde.cc | 10 +- cpp/src/arrow/engine/substrait/serde_test.cc | 15 +- .../arrow/engine/substrait/type_internal.cc | 141 +- .../arrow/engine/substrait/type_internal.h | 10 +- .../generated/substrait/capabilities.pb.cc | 178 +- cpp/src/generated/substrait/capabilities.pb.h | 222 +- cpp/src/generated/substrait/expression.pb.cc | 4132 ++++++------ cpp/src/generated/substrait/expression.pb.h | 5905 ++++++++--------- .../substrait/extensions/extensions.pb.cc | 1891 ++++++ .../substrait/extensions/extensions.pb.h | 1831 +++++ cpp/src/generated/substrait/function.pb.cc | 1200 ++-- cpp/src/generated/substrait/function.pb.h | 1840 +++-- .../substrait/parameterized_types.pb.cc | 1479 ++--- .../substrait/parameterized_types.pb.h | 2516 ++++--- cpp/src/generated/substrait/plan.pb.cc | 297 +- cpp/src/generated/substrait/plan.pb.h | 430 +- cpp/src/generated/substrait/relations.pb.cc | 2878 ++++---- cpp/src/generated/substrait/relations.pb.h | 5159 +++++++------- cpp/src/generated/substrait/type.pb.cc | 2014 +++--- cpp/src/generated/substrait/type.pb.h | 2559 ++++--- .../substrait/type_expressions.pb.cc | 1799 +++-- .../generated/substrait/type_expressions.pb.h | 3356 +++++----- 28 files changed, 21911 insertions(+), 18191 deletions(-) create mode 100644 cpp/src/generated/substrait/extensions/extensions.pb.cc create mode 100644 cpp/src/generated/substrait/extensions/extensions.pb.h diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake index cc24c90f8ff..44fedec80c3 100644 --- a/cpp/cmake_modules/DefineOptions.cmake +++ b/cpp/cmake_modules/DefineOptions.cmake @@ -481,7 +481,7 @@ that have not been built" OFF) set(ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT - "https://github.com/substrait-io/substrait 30e77cad10a33f861e82993ba7295aed5a7923e5") + "https://github.com/substrait-io/substrait e1b4c04a1b518912f4c4065b16a1b2c0ac8e14cf") define_option_string(ARROW_SUBSTRAIT_REPO_AND_TAG "Custom 'repository_url tag' for generating substrait accessors" "${ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT}") diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 239cdfc464f..6b975764d44 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -32,11 +32,11 @@ set(ARROW_ENGINE_SRCS substrait/plan_internal.cc substrait/type_internal.cc) -set(SUBSTRAIT_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait") -set(SUBSTRAIT_GEN_DIR "${ARROW_SOURCE_DIR}/src/generated/substrait") +set(SUBSTRAIT_LOCAL_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait") +set(SUBSTRAIT_GEN_DIR "${ARROW_SOURCE_DIR}/src/generated") set(SUBSTRAIT_PROTOS capabilities expression - extensions + extensions/extensions function parameterized_types plan @@ -55,22 +55,22 @@ string(STRIP "${ARROW_SUBSTRAIT_TAG}" ARROW_SUBSTRAIT_TAG) externalproject_add(substrait_ep GIT_REPOSITORY "${ARROW_SUBSTRAIT_REPO}" GIT_TAG "${ARROW_SUBSTRAIT_TAG}" - SOURCE_DIR "${SUBSTRAIT_DIR}" + SOURCE_DIR "${SUBSTRAIT_LOCAL_DIR}" CONFIGURE_COMMAND "" BUILD_COMMAND "" INSTALL_COMMAND "") set(SUBSTRAIT_PROTO_GEN_ALL) foreach(SUBSTRAIT_PROTO ${SUBSTRAIT_PROTOS}) - set(SUBSTRAIT_PROTO_GEN "${SUBSTRAIT_GEN_DIR}/${SUBSTRAIT_PROTO}.pb") + set(SUBSTRAIT_PROTO_GEN "${SUBSTRAIT_GEN_DIR}/substrait/${SUBSTRAIT_PROTO}.pb") foreach(EXT h cc) set_source_files_properties("${SUBSTRAIT_PROTO_GEN}.${EXT}" PROPERTIES GENERATED TRUE) add_custom_command(OUTPUT "${SUBSTRAIT_PROTO_GEN}.${EXT}" COMMAND ${ARROW_PROTOBUF_PROTOC} - "-I${SUBSTRAIT_DIR}/binary" + "-I${SUBSTRAIT_LOCAL_DIR}/proto" "--cpp_out=${SUBSTRAIT_GEN_DIR}" - "${SUBSTRAIT_DIR}/binary/${SUBSTRAIT_PROTO}.proto" + "${SUBSTRAIT_LOCAL_DIR}/proto/substrait/${SUBSTRAIT_PROTO}.proto" DEPENDS ${PROTO_DEPENDS} substrait_ep) list(APPEND SUBSTRAIT_PROTO_GEN_ALL "${SUBSTRAIT_PROTO_GEN}.${EXT}") endforeach() @@ -85,6 +85,7 @@ add_custom_target(substrait_gen_verify COMMENT "Verifying that generated substrait accessors are consistent with \ ARROW_SUBSTRAIT_REPO_AND_TAG='${ARROW_SUBSTRAIT_REPO_AND_TAG}'" COMMAND ${GIT_EXECUTABLE} diff --exit-code ${SUBSTRAIT_GEN_DIR} + DEPENDS substrait_gen_clear DEPENDS substrait_gen) add_arrow_lib(arrow_engine diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index d8f677e3e79..1c3a67fcfb6 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -34,8 +34,6 @@ #include "arrow/visit_scalar_inline.h" #include "generated/substrait/expression.pb.h" // IWYU pragma: export -namespace st = io::substrait; - namespace arrow { namespace engine { namespace { @@ -49,14 +47,14 @@ std::shared_ptr FixedSizeBinaryScalarFromBytes( } // namespace -Result FromProto(const st::Expression& expr) { +Result FromProto(const substrait::Expression& expr) { switch (expr.rex_type_case()) { - case st::Expression::kLiteral: { + case substrait::Expression::kLiteral: { ARROW_ASSIGN_OR_RAISE(auto datum, FromProto(expr.literal())); return compute::literal(std::move(datum)); } - case st::Expression::kSelection: { + case substrait::Expression::kSelection: { if (!expr.selection().has_direct_reference()) break; util::optional root_expr; @@ -66,7 +64,7 @@ Result FromProto(const st::Expression& expr) { const auto& ref = expr.selection().direct_reference(); switch (ref.reference_type_case()) { - case st::Expression::ReferenceSegment::kStructField: { + case substrait::Expression::ReferenceSegment::kStructField: { if (ref.struct_field().has_child()) break; FieldRef out(ref.struct_field().field()); @@ -83,7 +81,7 @@ Result FromProto(const st::Expression& expr) { return compute::field_ref(std::move(out)); } - case st::Expression::ReferenceSegment::kListElement: { + case substrait::Expression::ReferenceSegment::kListElement: { if (ref.list_element().has_child()) break; if (!root_expr) { return Status::Invalid( @@ -102,7 +100,7 @@ Result FromProto(const st::Expression& expr) { break; } - case st::Expression::kIfThen: { + case substrait::Expression::kIfThen: { const auto& if_then = expr.if_then(); if (!if_then.has_else_()) break; if (if_then.ifs_size() != 1) break; @@ -113,7 +111,7 @@ Result FromProto(const st::Expression& expr) { {std::move(if_), std::move(then), std::move(else_)}); } - case st::Expression::kScalarFunction: { + case substrait::Expression::kScalarFunction: { const auto& scalar_fn = expr.scalar_function(); ExtensionSet ext_set; @@ -135,7 +133,7 @@ Result FromProto(const st::Expression& expr) { expr.DebugString()); } -Result FromProto(const st::Expression::Literal& lit) { +Result FromProto(const substrait::Expression::Literal& lit) { if (lit.nullable()) { // FIXME not sure how this field should be interpreted and there's no way to round // trip it through arrow @@ -146,43 +144,43 @@ Result FromProto(const st::Expression::Literal& lit) { ExtensionSet ext_set; switch (lit.literal_type_case()) { - case st::Expression::Literal::kBoolean: + case substrait::Expression::Literal::kBoolean: return Datum(lit.boolean()); - case st::Expression::Literal::kI8: + case substrait::Expression::Literal::kI8: return Datum(static_cast(lit.i8())); - case st::Expression::Literal::kI16: + case substrait::Expression::Literal::kI16: return Datum(static_cast(lit.i16())); - case st::Expression::Literal::kI32: + case substrait::Expression::Literal::kI32: return Datum(static_cast(lit.i32())); - case st::Expression::Literal::kI64: + case substrait::Expression::Literal::kI64: return Datum(static_cast(lit.i64())); - case st::Expression::Literal::kFp32: + case substrait::Expression::Literal::kFp32: return Datum(lit.fp32()); - case st::Expression::Literal::kFp64: + case substrait::Expression::Literal::kFp64: return Datum(lit.fp64()); - case st::Expression::Literal::kString: + case substrait::Expression::Literal::kString: return Datum(lit.string()); - case st::Expression::Literal::kBinary: + case substrait::Expression::Literal::kBinary: return Datum(BinaryScalar(Buffer::FromString(lit.binary()))); - case st::Expression::Literal::kTimestamp: + case substrait::Expression::Literal::kTimestamp: return Datum( TimestampScalar(static_cast(lit.timestamp()), TimeUnit::MICRO)); - case st::Expression::Literal::kTimestampTz: + case substrait::Expression::Literal::kTimestampTz: return Datum(TimestampScalar(static_cast(lit.timestamp_tz()), TimeUnit::MICRO, TimestampTzTimezoneString())); - case st::Expression::Literal::kDate: + case substrait::Expression::Literal::kDate: return Datum(Date64Scalar(static_cast(lit.date()))); - case st::Expression::Literal::kTime: + case substrait::Expression::Literal::kTime: return Datum(Time64Scalar(static_cast(lit.time()), TimeUnit::MICRO)); - case st::Expression::Literal::kIntervalYearToMonth: - case st::Expression::Literal::kIntervalDayToSecond: { + case substrait::Expression::Literal::kIntervalYearToMonth: + case substrait::Expression::Literal::kIntervalDayToSecond: { Int32Builder builder; std::shared_ptr type; if (lit.has_interval_year_to_month()) { @@ -199,23 +197,23 @@ Result FromProto(const st::Expression::Literal& lit) { ExtensionScalar(FixedSizeListScalar(std::move(array)), std::move(type))); } - case st::Expression::Literal::kUuid: + case substrait::Expression::Literal::kUuid: return Datum(ExtensionScalar(FixedSizeBinaryScalarFromBytes(lit.uuid()), uuid())); - case st::Expression::Literal::kFixedChar: + case substrait::Expression::Literal::kFixedChar: return Datum( ExtensionScalar(FixedSizeBinaryScalarFromBytes(lit.fixed_char()), fixed_char(static_cast(lit.fixed_char().size())))); - case st::Expression::Literal::kVarChar: + case substrait::Expression::Literal::kVarChar: return Datum( ExtensionScalar(StringScalar(lit.var_char().value()), varchar(static_cast(lit.var_char().length())))); - case st::Expression::Literal::kFixedBinary: + case substrait::Expression::Literal::kFixedBinary: return Datum(FixedSizeBinaryScalarFromBytes(lit.fixed_binary())); - case st::Expression::Literal::kDecimal: { + case substrait::Expression::Literal::kDecimal: { if (lit.decimal().value().size() != sizeof(Decimal128)) { return Status::Invalid("Decimal literal had ", lit.decimal().value().size(), " bytes (expected ", sizeof(Decimal128), ")"); @@ -232,7 +230,7 @@ Result FromProto(const st::Expression::Literal& lit) { return Datum(Decimal128Scalar(value, std::move(type))); } - case st::Expression::Literal::kStruct: { + case substrait::Expression::Literal::kStruct: { const auto& struct_ = lit.struct_(); ScalarVector fields(struct_.fields_size()); @@ -247,18 +245,15 @@ Result FromProto(const st::Expression::Literal& lit) { return Datum(std::move(scalar)); } - case st::Expression::Literal::kList: { + case substrait::Expression::Literal::kList: { const auto& list = lit.list(); - if (list.values_size() == 0 && !list.has_element_type()) { + if (list.values_size() == 0) { return Status::Invalid( - "substrait::Expression::Literal::List had no values and no element_type"); + "substrait::Expression::Literal::List had no values; should have been an " + "substrait::Expression::Literal::EmptyList"); } std::shared_ptr element_type; - if (list.has_element_type()) { - ARROW_ASSIGN_OR_RAISE(std::tie(element_type, std::ignore), - FromProto(list.element_type(), ext_set)); - } ScalarVector values(list.values_size()); for (size_t i = 0; i < values.size(); ++i) { @@ -267,38 +262,30 @@ Result FromProto(const st::Expression::Literal& lit) { values[i] = value.scalar(); if (element_type) { if (!value.type()->Equals(*element_type)) { - return Status::Invalid(list.DebugString(), - " has a value whose type doesn't match element_type"); + return Status::Invalid( + list.DebugString(), + " has a value whose type doesn't match the other list values"); } } else { element_type = value.type(); } } - ARROW_ASSIGN_OR_RAISE(auto builder, MakeBuilder(element_type)); + ARROW_ASSIGN_OR_RAISE(auto builder, MakeBuilder(std::move(element_type))); RETURN_NOT_OK(builder->AppendScalars(values)); ARROW_ASSIGN_OR_RAISE(auto arr, builder->Finish()); return Datum(ListScalar(std::move(arr))); } - case st::Expression::Literal::kMap: { + case substrait::Expression::Literal::kMap: { const auto& map = lit.map(); - if (map.key_values_size() == 0 && !(map.has_key_type() && map.has_value_type())) { + if (map.key_values_size() == 0) { return Status::Invalid( - "substrait::Expression::Literal::Map had no key_values and no key_type or " - "values_type"); + "substrait::Expression::Literal::Map had no values; should have been an " + "substrait::Expression::Literal::EmptyMap"); } std::shared_ptr key_type, value_type; - if (map.has_key_type()) { - ARROW_ASSIGN_OR_RAISE(std::tie(key_type, std::ignore), - FromProto(map.key_type(), ext_set)); - } - if (map.has_value_type()) { - ARROW_ASSIGN_OR_RAISE(std::tie(value_type, std::ignore), - FromProto(map.value_type(), ext_set)); - } - ScalarVector keys(map.key_values_size()), values(map.key_values_size()); for (size_t i = 0; i < values.size(); ++i) { const auto& kv = map.key_values(i); @@ -350,7 +337,31 @@ Result FromProto(const st::Expression::Literal& lit) { return Datum(std::make_shared(std::move(kv_arr))); } - case st::Expression::Literal::kNull: { + case substrait::Expression::Literal::kEmptyList: { + ARROW_ASSIGN_OR_RAISE(auto type_nullable, + FromProto(lit.empty_list().type(), ext_set)); + ARROW_ASSIGN_OR_RAISE(auto values, MakeEmptyArray(type_nullable.first)); + return ListScalar{std::move(values)}; + } + + case substrait::Expression::Literal::kEmptyMap: { + ARROW_ASSIGN_OR_RAISE(auto key_type_nullable, + FromProto(lit.empty_map().key(), ext_set)); + ARROW_ASSIGN_OR_RAISE(auto value_type_nullable, + FromProto(lit.empty_map().value(), ext_set)); + ARROW_ASSIGN_OR_RAISE(auto keys, MakeEmptyArray(key_type_nullable.first)); + ARROW_ASSIGN_OR_RAISE(auto values, MakeEmptyArray(value_type_nullable.first)); + + auto map_type = std::make_shared(keys->type(), values->type()); + ARROW_ASSIGN_OR_RAISE( + auto key_values, + StructArray::Make( + {std::move(keys), std::move(values)}, + checked_cast(*map_type).value_type()->fields())); + return MapScalar{std::move(key_values)}; + } + + case substrait::Expression::Literal::kNull: { ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(lit.null(), ext_set)); if (!type_nullable.second) { return Status::Invalid("Null literal ", lit.DebugString(), @@ -371,17 +382,17 @@ namespace { struct ToProtoImpl { Status Visit(const NullScalar& s) { return NotImplemented(s); } - using Lit = st::Expression::Literal; + using Lit = substrait::Expression::Literal; template - Status Primitive(void (st::Expression::Literal::*set)(Arg), + Status Primitive(void (substrait::Expression::Literal::*set)(Arg), const PrimitiveScalar& primitive_scalar) { (lit_->*set)(static_cast(primitive_scalar.value)); return Status::OK(); } template - Status FromBuffer(void (st::Expression::Literal::*set)(std::string&&), + Status FromBuffer(void (substrait::Expression::Literal::*set)(std::string&&), const ScalarWithBufferValue& scalar_with_buffer) { (lit_->*set)(scalar_with_buffer.value->ToString()); return Status::OK(); @@ -457,14 +468,20 @@ struct ToProtoImpl { Status Visit(const Decimal256Scalar& s) { return NotImplemented(s); } Status Visit(const ListScalar& s) { + ExtensionSet ext_set; + if (s.value->length() == 0) { + ARROW_ASSIGN_OR_RAISE(auto list_type, + ToProto(*s.type, /*nullable=*/true, &ext_set)); + lit_->set_allocated_empty_list(list_type->release_list()); + return Status::OK(); + } + lit_->set_allocated_list(new Lit::List()); const auto& list_type = internal::checked_cast(*s.type); - ExtensionSet ext_set; ARROW_ASSIGN_OR_RAISE( auto element_type, ToProto(*list_type.value_type(), list_type.value_field()->nullable(), &ext_set)); - lit_->mutable_list()->set_allocated_element_type(element_type.release()); auto values = lit_->mutable_list()->mutable_values(); values->Reserve(static_cast(s.value->length())); @@ -495,6 +512,13 @@ struct ToProtoImpl { Status Visit(const DictionaryScalar& s) { return NotImplemented(s); } Status Visit(const MapScalar& s) { + ExtensionSet ext_set; + if (s.value->length() == 0) { + ARROW_ASSIGN_OR_RAISE(auto map_type, ToProto(*s.type, /*nullable=*/true, &ext_set)); + lit_->set_allocated_empty_map(map_type->release_map()); + return Status::OK(); + } + lit_->set_allocated_map(new Lit::Map()); const auto& kv_arr = internal::checked_cast(*s.value); @@ -581,17 +605,17 @@ struct ToProtoImpl { Status operator()(const Scalar& scalar) { return VisitScalarInline(scalar, this); } - st::Expression::Literal* lit_; + substrait::Expression::Literal* lit_; }; } // namespace -Result> ToProto(const Datum& datum) { +Result> ToProto(const Datum& datum) { if (!datum.is_scalar()) { return Status::NotImplemented("representing ", datum.ToString(), " as a substrait::Expression::Literal"); } - auto out = internal::make_unique(); + auto out = internal::make_unique(); if (datum.scalar()->is_valid) { RETURN_NOT_OK((ToProtoImpl{out.get()})(*datum.scalar())); @@ -604,12 +628,12 @@ Result> ToProto(const Datum& datum) { return std::move(out); } -Result> ToProto(const compute::Expression& expr) { +Result> ToProto(const compute::Expression& expr) { if (!expr.IsBound()) { return Status::Invalid("ToProto requires a bound Expression"); } - auto out = internal::make_unique(); + auto out = internal::make_unique(); if (auto datum = expr.literal()) { ARROW_ASSIGN_OR_RAISE(auto literal, ToProto(*datum)); @@ -623,21 +647,21 @@ Result> ToProto(const compute::Expression& expr) for (auto it = param->indices.begin(); it != param->indices.end(); ++it) { auto struct_field = - internal::make_unique(); + internal::make_unique(); struct_field->set_field(*it); - auto ref_segment = internal::make_unique(); + auto ref_segment = internal::make_unique(); ref_segment->set_allocated_struct_field(struct_field.release()); - auto selection = internal::make_unique(); + auto selection = internal::make_unique(); selection->set_allocated_direct_reference(ref_segment.release()); if (out->has_selection()) { selection->set_allocated_expression(out.release()); - out = internal::make_unique(); + out = internal::make_unique(); } else { selection->set_allocated_root_reference( - new st::Expression::FieldReference::RootReference()); + new substrait::Expression::FieldReference::RootReference()); } out->set_allocated_selection(selection.release()); @@ -649,7 +673,7 @@ Result> ToProto(const compute::Expression& expr) auto call = CallNotNull(expr); // convert all arguments first - std::vector> arguments(call->arguments.size()); + std::vector> arguments(call->arguments.size()); for (size_t i = 0; i < arguments.size(); ++i) { ARROW_ASSIGN_OR_RAISE(arguments[i], ToProto(call->arguments[i])); } @@ -660,14 +684,15 @@ Result> ToProto(const compute::Expression& expr) arguments[0]->selection().has_direct_reference()) { if (arguments[1]->has_literal() && arguments[1]->literal().has_i32()) { auto list_element = - internal::make_unique(); + internal::make_unique(); list_element->set_offset(arguments[1]->literal().i32()); - auto ref_segment = internal::make_unique(); + auto ref_segment = + internal::make_unique(); ref_segment->set_allocated_list_element(list_element.release()); - auto field_ref = internal::make_unique(); + auto field_ref = internal::make_unique(); field_ref->set_allocated_direct_reference(ref_segment.release()); field_ref->set_allocated_expression(arguments[0].release()); @@ -679,11 +704,11 @@ Result> ToProto(const compute::Expression& expr) if (call->function_name == "if_else") { // catch the special case of calls convertible to IfThen - auto if_clause = internal::make_unique(); + auto if_clause = internal::make_unique(); if_clause->set_allocated_if_(arguments[0].release()); if_clause->set_allocated_then(arguments[1].release()); - auto if_then = internal::make_unique(); + auto if_then = internal::make_unique(); if_then->mutable_ifs()->AddAllocated(if_clause.release()); if_then->set_allocated_else_(arguments[2].release()); @@ -696,11 +721,11 @@ Result> ToProto(const compute::Expression& expr) auto conditions = call->arguments[0].call(); if (conditions && conditions->function_name == "make_struct") { // catch the special case of calls convertible to SwitchExpression - auto switch_ = internal::make_unique(); + auto switch_ = internal::make_unique(); for (auto& cond : conditions->arguments) { auto if_value = - internal::make_unique(); + internal::make_unique(); if_value->set_allocated_if_(arguments[0].release()); if_value->set_allocated_then(arguments[1].release()); @@ -709,7 +734,7 @@ Result> ToProto(const compute::Expression& expr) switch_->set_allocated_else_(arguments[2].release()); - auto out = std::move(arguments[0]); // reuse an emptied st::Expression + auto out = std::move(arguments[0]); // reuse an emptied substrait::Expression out->set_allocated_switch_expression(switch_.release()); return std::move(out); } @@ -718,7 +743,7 @@ Result> ToProto(const compute::Expression& expr) ExtensionSet* ext_set = nullptr; ARROW_ASSIGN_OR_RAISE(auto anchor, ext_set->EncodeFunction({"", call->function_name})); - auto scalar_fn = internal::make_unique(); + auto scalar_fn = internal::make_unique(); scalar_fn->set_function_reference(anchor); scalar_fn->mutable_args()->Reserve(arguments.size()); for (auto& arg : arguments) { diff --git a/cpp/src/arrow/engine/substrait/expression_internal.h b/cpp/src/arrow/engine/substrait/expression_internal.h index 6fef22f45e6..407a775df4b 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.h +++ b/cpp/src/arrow/engine/substrait/expression_internal.h @@ -27,22 +27,20 @@ #include "generated/substrait/expression.pb.h" // IWYU pragma: export -namespace st = io::substrait; - namespace arrow { namespace engine { ARROW_ENGINE_EXPORT -Result FromProto(const st::Expression&); +Result FromProto(const substrait::Expression&); ARROW_ENGINE_EXPORT -Result> ToProto(const compute::Expression&); +Result> ToProto(const compute::Expression&); ARROW_ENGINE_EXPORT -Result FromProto(const st::Expression::Literal&); +Result FromProto(const substrait::Expression::Literal&); ARROW_ENGINE_EXPORT -Result> ToProto(const Datum&); +Result> ToProto(const Datum&); } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/plan_internal.cc b/cpp/src/arrow/engine/substrait/plan_internal.cc index 9a3810c51b2..10ebfd4f017 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.cc +++ b/cpp/src/arrow/engine/substrait/plan_internal.cc @@ -26,7 +26,7 @@ namespace arrow { namespace engine { -Status AddExtensionSetToPlan(const ExtensionSet& ext_set, st::Plan* plan) { +Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan) { plan->clear_extension_uris(); std::unordered_map map; @@ -37,7 +37,7 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, st::Plan* plan) { const auto& uri = ext_set.uris()[anchor]; if (uri.empty()) continue; - auto ext_uri = internal::make_unique(); + auto ext_uri = internal::make_unique(); ext_uri->set_uri(uri); ext_uri->set_extension_uri_anchor(anchor); uris->AddAllocated(ext_uri.release()); @@ -49,7 +49,7 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, st::Plan* plan) { extensions->Reserve( static_cast(ext_set.type_ids().size() + ext_set.function_ids().size())); - using ExtDecl = st::extensions::SimpleExtensionDeclaration; + using ExtDecl = substrait::extensions::SimpleExtensionDeclaration; for (size_t anchor = 0; anchor < ext_set.type_ids().size(); ++anchor) { auto id = ext_set.type_ids()[anchor]; @@ -59,7 +59,7 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, st::Plan* plan) { if (ext_set.type_is_variation(anchor)) { auto type_var = internal::make_unique(); - type_var->set_extension_uri_pointer(map[id.uri]); + type_var->set_extension_uri_reference(map[id.uri]); type_var->set_type_variation_anchor(anchor); type_var->set_name(id.name.to_string()); ext_decl->set_allocated_extension_type_variation(type_var.release()); @@ -79,7 +79,7 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, st::Plan* plan) { if (id.empty()) continue; auto fn = internal::make_unique(); - fn->set_extension_uri_pointer(map[id.uri]); + fn->set_extension_uri_reference(map[id.uri]); fn->set_function_anchor(anchor); fn->set_name(id.name.to_string()); @@ -102,7 +102,7 @@ void SetElement(size_t i, T element, std::vector* vector) { } } // namespace -Result GetExtensionSetFromPlan(const st::Plan& plan, +Result GetExtensionSetFromPlan(const substrait::Plan& plan, ExtensionIdRegistry* registry) { std::vector uris; for (const auto& uri : plan.extension_uris()) { @@ -116,15 +116,15 @@ Result GetExtensionSetFromPlan(const st::Plan& plan, std::vector type_is_variation; for (const auto& ext : plan.extensions()) { switch (ext.mapping_type_case()) { - case st::extensions::SimpleExtensionDeclaration::kExtensionTypeVariation: { + case substrait::extensions::SimpleExtensionDeclaration::kExtensionTypeVariation: { const auto& type_var = ext.extension_type_variation(); - util::string_view uri = uris[type_var.extension_uri_pointer()]; + util::string_view uri = uris[type_var.extension_uri_reference()]; SetElement(type_var.type_variation_anchor(), {uri, type_var.name()}, &type_ids); SetElement(type_var.type_variation_anchor(), true, &type_is_variation); break; } - case st::extensions::SimpleExtensionDeclaration::kExtensionType: { + case substrait::extensions::SimpleExtensionDeclaration::kExtensionType: { const auto& type = ext.extension_type(); util::string_view uri = uris[type.extension_uri_reference()]; SetElement(type.type_anchor(), {uri, type.name()}, &type_ids); @@ -132,9 +132,9 @@ Result GetExtensionSetFromPlan(const st::Plan& plan, break; } - case st::extensions::SimpleExtensionDeclaration::kExtensionFunction: { + case substrait::extensions::SimpleExtensionDeclaration::kExtensionFunction: { const auto& fn = ext.extension_function(); - util::string_view uri = uris[fn.extension_uri_pointer()]; + util::string_view uri = uris[fn.extension_uri_reference()]; SetElement(fn.function_anchor(), {uri, fn.name()}, &function_ids); break; } diff --git a/cpp/src/arrow/engine/substrait/plan_internal.h b/cpp/src/arrow/engine/substrait/plan_internal.h index ec344a250d0..8ebe56b627a 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.h +++ b/cpp/src/arrow/engine/substrait/plan_internal.h @@ -24,17 +24,15 @@ #include "arrow/type_fwd.h" #include "generated/substrait/plan.pb.h" // IWYU pragma: export -namespace st = io::substrait; - namespace arrow { namespace engine { ARROW_ENGINE_EXPORT -Status AddExtensionSetToPlan(const ExtensionSet&, st::Plan*); +Status AddExtensionSetToPlan(const ExtensionSet&, substrait::Plan*); ARROW_ENGINE_EXPORT Result GetExtensionSetFromPlan( - const st::Plan&, ExtensionIdRegistry* = default_extension_id_registry()); + const substrait::Plan&, ExtensionIdRegistry* = default_extension_id_registry()); } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc index daf01f0e852..6e5d758ff7f 100644 --- a/cpp/src/arrow/engine/substrait/serde.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -55,12 +55,12 @@ Result ParseFromBuffer(const Buffer& buf) { return message; } -Result Convert(const st::PlanRel& relation) { +Result Convert(const substrait::PlanRel& relation) { return Status::NotImplemented(""); } Result> ConvertPlan(const Buffer& buf) { - ARROW_ASSIGN_OR_RAISE(auto plan, ParseFromBuffer(buf)); + ARROW_ASSIGN_OR_RAISE(auto plan, ParseFromBuffer(buf)); std::vector decls; for (const auto& relation : plan.relations()) { @@ -72,7 +72,7 @@ Result> ConvertPlan(const Buffer& buf) { } Result> DeserializeSchema(const Buffer& buf) { - ARROW_ASSIGN_OR_RAISE(auto named_struct, ParseFromBuffer(buf)); + ARROW_ASSIGN_OR_RAISE(auto named_struct, ParseFromBuffer(buf)); return FromProto(named_struct); } @@ -84,7 +84,7 @@ Result> SerializeSchema(const Schema& schema) { Result> DeserializeType(const Buffer& buf, const ExtensionSet& ext_set) { - ARROW_ASSIGN_OR_RAISE(auto type, ParseFromBuffer(buf)); + ARROW_ASSIGN_OR_RAISE(auto type, ParseFromBuffer(buf)); ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(type, ext_set)); return std::move(type_nullable.first); } @@ -97,7 +97,7 @@ Result> SerializeType(const DataType& type, } Result DeserializeExpression(const Buffer& buf) { - ARROW_ASSIGN_OR_RAISE(auto expr, ParseFromBuffer(buf)); + ARROW_ASSIGN_OR_RAISE(auto expr, ParseFromBuffer(buf)); return FromProto(expr); } diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 932eadc0253..5d6df1749c5 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -103,7 +103,7 @@ google::protobuf::util::TypeResolver* GetGeneratedTypeResolver() { std::shared_ptr SubstraitFromJSON(util::string_view type_name, util::string_view json) { - std::string type_url = "/io.substrait." + type_name.to_string(); + std::string type_url = "/substrait." + type_name.to_string(); google::protobuf::io::ArrayInputStream json_stream{json.data(), static_cast(json.size())}; @@ -119,7 +119,7 @@ std::shared_ptr SubstraitFromJSON(util::string_view type_name, } std::string SubstraitToJSON(util::string_view type_name, const Buffer& buf) { - std::string type_url = "/io.substrait." + type_name.to_string(); + std::string type_url = "/substrait." + type_name.to_string(); google::protobuf::io::ArrayInputStream buf_stream{buf.data(), static_cast(buf.size())}; @@ -380,7 +380,7 @@ TEST(Substrait, SupportedLiterals) { ExpectEq(R"({"timestamp_tz": "579"})", TimestampScalar(579, TimeUnit::MICRO, "UTC")); // special case for empty lists - ExpectEq(R"({"list": {"element_type": {"i32": {}}, "values": []}})", + ExpectEq(R"({"empty_list": {"type": {"i32": {}}}})", ScalarFromJSON(list(int32()), "[]")); ExpectEq(R"({"struct": { @@ -426,10 +426,11 @@ TEST(Substrait, CannotDeserializeLiteral) { Raises(StatusCode::Invalid)); // Invalid: required null literal - EXPECT_THAT(DeserializeExpression(*SubstraitFromJSON( - "Expression", - R"({"literal": {"null": {"bool": {"nullability": "REQUIRED"}}}})")), - Raises(StatusCode::Invalid)); + EXPECT_THAT( + DeserializeExpression(*SubstraitFromJSON( + "Expression", + R"({"literal": {"null": {"bool": {"nullability": "NULLABILITY_REQUIRED"}}}})")), + Raises(StatusCode::Invalid)); // no equivalent arrow scalar // FIXME no way to specify scalars of user_defined_type_reference diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 3adc7d2b5b8..b4575876b3d 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -41,7 +41,8 @@ Status CheckVariation(const TypeMessage& type) { template bool IsNullable(const TypeMessage& type) { - return type.nullability() == st::Type_Nullability_NULLABLE; + // FIXME what can we do with NULLABILITY_UNSPECIFIED + return type.nullability() != substrait::Type::NULLABILITY_REQUIRED; } template @@ -94,66 +95,66 @@ Result FieldsFromProto(int size, const Types& types, } // namespace Result, bool>> FromProto( - const st::Type& type, const ExtensionSet& ext_set) { + const substrait::Type& type, const ExtensionSet& ext_set) { switch (type.kind_case()) { - case st::Type::kBool: + case substrait::Type::kBool: return FromProtoImpl(type.bool_()); - case st::Type::kI8: + case substrait::Type::kI8: return FromProtoImpl(type.i8()); - case st::Type::kI16: + case substrait::Type::kI16: return FromProtoImpl(type.i16()); - case st::Type::kI32: + case substrait::Type::kI32: return FromProtoImpl(type.i32()); - case st::Type::kI64: + case substrait::Type::kI64: return FromProtoImpl(type.i64()); - case st::Type::kFp32: + case substrait::Type::kFp32: return FromProtoImpl(type.fp32()); - case st::Type::kFp64: + case substrait::Type::kFp64: return FromProtoImpl(type.fp64()); - case st::Type::kString: + case substrait::Type::kString: return FromProtoImpl(type.string()); - case st::Type::kBinary: + case substrait::Type::kBinary: return FromProtoImpl(type.binary()); - case st::Type::kTimestamp: + case substrait::Type::kTimestamp: return FromProtoImpl(type.timestamp(), TimeUnit::MICRO); - case st::Type::kTimestampTz: + case substrait::Type::kTimestampTz: return FromProtoImpl(type.timestamp_tz(), TimeUnit::MICRO, TimestampTzTimezoneString()); - case st::Type::kDate: + case substrait::Type::kDate: return FromProtoImpl(type.date()); - case st::Type::kTime: + case substrait::Type::kTime: return FromProtoImpl(type.time(), TimeUnit::MICRO); - case st::Type::kIntervalYear: + case substrait::Type::kIntervalYear: return FromProtoImpl(type.interval_year(), interval_year); - case st::Type::kIntervalDay: + case substrait::Type::kIntervalDay: return FromProtoImpl(type.interval_day(), interval_day); - case st::Type::kUuid: + case substrait::Type::kUuid: return FromProtoImpl(type.uuid(), uuid); - case st::Type::kFixedChar: + case substrait::Type::kFixedChar: return FromProtoImpl(type.fixed_char(), fixed_char, type.fixed_char().length()); - case st::Type::kVarchar: + case substrait::Type::kVarchar: return FromProtoImpl(type.varchar(), varchar, type.varchar().length()); - case st::Type::kFixedBinary: + case substrait::Type::kFixedBinary: return FromProtoImpl(type.fixed_binary(), type.fixed_binary().length()); - case st::Type::kDecimal: { + case substrait::Type::kDecimal: { const auto& decimal = type.decimal(); return FromProtoImpl(decimal, decimal.precision(), decimal.scale()); } - case st::Type::kStruct: { + case substrait::Type::kStruct: { const auto& struct_ = type.struct_(); ARROW_ASSIGN_OR_RAISE(auto fields, FieldsFromProto( @@ -163,7 +164,7 @@ Result, bool>> FromProto( return FromProtoImpl(struct_, std::move(fields)); } - case st::Type::kList: { + case substrait::Type::kList: { const auto& list = type.list(); if (!list.has_type()) { @@ -177,7 +178,7 @@ Result, bool>> FromProto( list, field("item", std::move(type_nullable.first), type_nullable.second)); } - case st::Type::kMap: { + case substrait::Type::kMap: { const auto& map = type.map(); static const std::array kMissing = {"key and value", "value", "key", @@ -201,7 +202,7 @@ Result, bool>> FromProto( field("value", std::move(value_nullable.first), value_nullable.second)); } - case st::Type::kUserDefinedTypeReference: { + case substrait::Type::kUserDefinedTypeReference: { uint32_t anchor = type.user_defined_type_reference(); if (anchor >= ext_set.types().size() || ext_set.types()[anchor] == nullptr) { return Status::Invalid( @@ -224,12 +225,20 @@ namespace { struct ToProtoImpl { Status Visit(const NullType& t) { return EncodeUserDefined(t); } - Status Visit(const BooleanType& t) { return SetWith(&st::Type::set_allocated_bool_); } + Status Visit(const BooleanType& t) { + return SetWith(&substrait::Type::set_allocated_bool_); + } - Status Visit(const Int8Type& t) { return SetWith(&st::Type::set_allocated_i8); } - Status Visit(const Int16Type& t) { return SetWith(&st::Type::set_allocated_i16); } - Status Visit(const Int32Type& t) { return SetWith(&st::Type::set_allocated_i32); } - Status Visit(const Int64Type& t) { return SetWith(&st::Type::set_allocated_i64); } + Status Visit(const Int8Type& t) { return SetWith(&substrait::Type::set_allocated_i8); } + Status Visit(const Int16Type& t) { + return SetWith(&substrait::Type::set_allocated_i16); + } + Status Visit(const Int32Type& t) { + return SetWith(&substrait::Type::set_allocated_i32); + } + Status Visit(const Int64Type& t) { + return SetWith(&substrait::Type::set_allocated_i64); + } Status Visit(const UInt8Type& t) { return EncodeUserDefined(t); } Status Visit(const UInt16Type& t) { return EncodeUserDefined(t); } @@ -237,28 +246,38 @@ struct ToProtoImpl { Status Visit(const UInt64Type& t) { return EncodeUserDefined(t); } Status Visit(const HalfFloatType& t) { return EncodeUserDefined(t); } - Status Visit(const FloatType& t) { return SetWith(&st::Type::set_allocated_fp32); } - Status Visit(const DoubleType& t) { return SetWith(&st::Type::set_allocated_fp64); } + Status Visit(const FloatType& t) { + return SetWith(&substrait::Type::set_allocated_fp32); + } + Status Visit(const DoubleType& t) { + return SetWith(&substrait::Type::set_allocated_fp64); + } - Status Visit(const StringType& t) { return SetWith(&st::Type::set_allocated_string); } - Status Visit(const BinaryType& t) { return SetWith(&st::Type::set_allocated_binary); } + Status Visit(const StringType& t) { + return SetWith(&substrait::Type::set_allocated_string); + } + Status Visit(const BinaryType& t) { + return SetWith(&substrait::Type::set_allocated_binary); + } Status Visit(const FixedSizeBinaryType& t) { - SetWithThen(&st::Type::set_allocated_fixed_binary)->set_length(t.byte_width()); + SetWithThen(&substrait::Type::set_allocated_fixed_binary)->set_length(t.byte_width()); return Status::OK(); } Status Visit(const Date32Type& t) { return NotImplemented(t); } - Status Visit(const Date64Type& t) { return SetWith(&st::Type::set_allocated_date); } + Status Visit(const Date64Type& t) { + return SetWith(&substrait::Type::set_allocated_date); + } Status Visit(const TimestampType& t) { if (t.unit() != TimeUnit::MICRO) return NotImplemented(t); if (t.timezone() == "") { - return SetWith(&st::Type::set_allocated_timestamp); + return SetWith(&substrait::Type::set_allocated_timestamp); } if (t.timezone() == TimestampTzTimezoneString()) { - return SetWith(&st::Type::set_allocated_timestamp_tz); + return SetWith(&substrait::Type::set_allocated_timestamp_tz); } return NotImplemented(t); @@ -267,14 +286,14 @@ struct ToProtoImpl { Status Visit(const Time32Type& t) { return NotImplemented(t); } Status Visit(const Time64Type& t) { if (t.unit() != TimeUnit::MICRO) return NotImplemented(t); - return SetWith(&st::Type::set_allocated_time); + return SetWith(&substrait::Type::set_allocated_time); } Status Visit(const MonthIntervalType& t) { return EncodeUserDefined(t); } Status Visit(const DayTimeIntervalType& t) { return EncodeUserDefined(t); } Status Visit(const Decimal128Type& t) { - auto dec = SetWithThen(&st::Type::set_allocated_decimal); + auto dec = SetWithThen(&substrait::Type::set_allocated_decimal); dec->set_precision(t.precision()); dec->set_scale(t.scale()); return Status::OK(); @@ -285,12 +304,12 @@ struct ToProtoImpl { // FIXME assert default field name; custom ones won't roundtrip ARROW_ASSIGN_OR_RAISE( auto type, ToProto(*t.value_type(), t.value_field()->nullable(), ext_set_)); - SetWithThen(&st::Type::set_allocated_list)->set_allocated_type(type.release()); + SetWithThen(&substrait::Type::set_allocated_list)->set_allocated_type(type.release()); return Status::OK(); } Status Visit(const StructType& t) { - auto types = SetWithThen(&st::Type::set_allocated_struct_)->mutable_types(); + auto types = SetWithThen(&substrait::Type::set_allocated_struct_)->mutable_types(); types->Reserve(t.num_fields()); @@ -311,7 +330,7 @@ struct ToProtoImpl { Status Visit(const MapType& t) { // FIXME assert default field names; custom ones won't roundtrip - auto map = SetWithThen(&st::Type::set_allocated_map); + auto map = SetWithThen(&substrait::Type::set_allocated_map); ARROW_ASSIGN_OR_RAISE(auto key, ToProto(*t.key_type(), /*nullable=*/false, ext_set_)); map->set_allocated_key(key.release()); @@ -325,25 +344,25 @@ struct ToProtoImpl { Status Visit(const ExtensionType& t) { if (UnwrapUuid(t)) { - return SetWith(&st::Type::set_allocated_uuid); + return SetWith(&substrait::Type::set_allocated_uuid); } if (auto length = UnwrapFixedChar(t)) { - SetWithThen(&st::Type::set_allocated_fixed_char)->set_length(*length); + SetWithThen(&substrait::Type::set_allocated_fixed_char)->set_length(*length); return Status::OK(); } if (auto length = UnwrapVarChar(t)) { - SetWithThen(&st::Type::set_allocated_varchar)->set_length(*length); + SetWithThen(&substrait::Type::set_allocated_varchar)->set_length(*length); return Status::OK(); } if (UnwrapIntervalYear(t)) { - return SetWith(&st::Type::set_allocated_interval_year); + return SetWith(&substrait::Type::set_allocated_interval_year); } if (UnwrapIntervalDay(t)) { - return SetWith(&st::Type::set_allocated_interval_day); + return SetWith(&substrait::Type::set_allocated_interval_day); } return NotImplemented(t); @@ -357,10 +376,10 @@ struct ToProtoImpl { Status Visit(const MonthDayNanoIntervalType& t) { return EncodeUserDefined(t); } template - Sub* SetWithThen(void (st::Type::*set_allocated_sub)(Sub*)) { + Sub* SetWithThen(void (substrait::Type::*set_allocated_sub)(Sub*)) { auto sub = internal::make_unique(); - sub->set_nullability(nullable_ ? st::Type_Nullability_NULLABLE - : st::Type_Nullability_REQUIRED); + sub->set_nullability(nullable_ ? substrait::Type::NULLABILITY_NULLABLE + : substrait::Type::NULLABILITY_REQUIRED); auto out = sub.get(); (type_->*set_allocated_sub)(sub.release()); @@ -368,7 +387,7 @@ struct ToProtoImpl { } template - Status SetWith(void (st::Type::*set_allocated_sub)(Sub*)) { + Status SetWith(void (substrait::Type::*set_allocated_sub)(Sub*)) { return SetWithThen(set_allocated_sub), Status::OK(); } @@ -385,20 +404,20 @@ struct ToProtoImpl { Status operator()(const DataType& type) { return VisitTypeInline(type, this); } - st::Type* type_; + substrait::Type* type_; bool nullable_; ExtensionSet* ext_set_; }; } // namespace -Result> ToProto(const DataType& type, bool nullable, - ExtensionSet* ext_set) { - auto out = internal::make_unique(); +Result> ToProto(const DataType& type, bool nullable, + ExtensionSet* ext_set) { + auto out = internal::make_unique(); RETURN_NOT_OK((ToProtoImpl{out.get(), nullable, ext_set})(type)); return std::move(out); } -Result> FromProto(const st::NamedStruct& named_struct) { +Result> FromProto(const substrait::NamedStruct& named_struct) { if (!named_struct.has_struct_()) { return Status::Invalid("While converting ", named_struct.DebugString(), " no anonymous struct type was provided to which to names " @@ -442,18 +461,18 @@ void ToProtoGetDepthFirstNames(const FieldVector& fields, } } // namespace -Result> ToProto(const Schema& schema) { +Result> ToProto(const Schema& schema) { if (schema.metadata()) { return Status::Invalid("substrait::NamedStruct does not support schema metadata"); } - auto named_struct = internal::make_unique(); + auto named_struct = internal::make_unique(); auto names = named_struct->mutable_names(); names->Reserve(schema.num_fields()); ToProtoGetDepthFirstNames(schema.fields(), names); - auto struct_ = internal::make_unique(); + auto struct_ = internal::make_unique(); auto types = struct_->mutable_types(); types->Reserve(schema.num_fields()); diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h index 8c219d51188..0eb5b3df325 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -27,23 +27,21 @@ #include "generated/substrait/type.pb.h" // IWYU pragma: export -namespace st = io::substrait; - namespace arrow { namespace engine { ARROW_ENGINE_EXPORT -Result, bool>> FromProto(const st::Type&, +Result, bool>> FromProto(const substrait::Type&, const ExtensionSet&); ARROW_ENGINE_EXPORT -Result> ToProto(const DataType&, bool nullable, ExtensionSet*); +Result> ToProto(const DataType&, bool nullable, ExtensionSet*); ARROW_ENGINE_EXPORT -Result> FromProto(const st::NamedStruct&); +Result> FromProto(const substrait::NamedStruct&); ARROW_ENGINE_EXPORT -Result> ToProto(const Schema&); +Result> ToProto(const Schema&); inline std::string TimestampTzTimezoneString() { return "UTC"; } diff --git a/cpp/src/generated/substrait/capabilities.pb.cc b/cpp/src/generated/substrait/capabilities.pb.cc index d8597d5c5b8..29156824796 100644 --- a/cpp/src/generated/substrait/capabilities.pb.cc +++ b/cpp/src/generated/substrait/capabilities.pb.cc @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: capabilities.proto +// source: substrait/capabilities.proto -#include "capabilities.pb.h" +#include "substrait/capabilities.pb.h" #include @@ -16,7 +16,6 @@ #include PROTOBUF_PRAGMA_INIT_SEG -namespace io { namespace substrait { constexpr Capabilities_SimpleExtension::Capabilities_SimpleExtension( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) @@ -48,65 +47,63 @@ struct CapabilitiesDefaultTypeInternal { }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CapabilitiesDefaultTypeInternal _Capabilities_default_instance_; } // namespace substrait -} // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_capabilities_2eproto[2]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_capabilities_2eproto = nullptr; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_capabilities_2eproto = nullptr; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fcapabilities_2eproto[2]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fcapabilities_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fcapabilities_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_capabilities_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fcapabilities_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities_SimpleExtension, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities_SimpleExtension, uri_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities_SimpleExtension, function_keys_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities_SimpleExtension, type_keys_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities_SimpleExtension, type_variation_keys_), + PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, uri_), + PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, function_keys_), + PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, type_keys_), + PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, type_variation_keys_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities, substrait_versions_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities, advanced_extension_type_urls_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Capabilities, simple_extensions_), + PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, substrait_versions_), + PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, advanced_extension_type_urls_), + PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, simple_extensions_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::Capabilities_SimpleExtension)}, - { 9, -1, sizeof(::io::substrait::Capabilities)}, + { 0, -1, sizeof(::substrait::Capabilities_SimpleExtension)}, + { 9, -1, sizeof(::substrait::Capabilities)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::_Capabilities_SimpleExtension_default_instance_), - reinterpret_cast(&::io::substrait::_Capabilities_default_instance_), + reinterpret_cast(&::substrait::_Capabilities_SimpleExtension_default_instance_), + reinterpret_cast(&::substrait::_Capabilities_default_instance_), }; -const char descriptor_table_protodef_capabilities_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\022capabilities.proto\022\014io.substrait\"\376\001\n\014C" - "apabilities\022\032\n\022substrait_versions\030\001 \003(\t\022" - "$\n\034advanced_extension_type_urls\030\002 \003(\t\022E\n" - "\021simple_extensions\030\003 \003(\0132*.io.substrait." - "Capabilities.SimpleExtension\032e\n\017SimpleEx" - "tension\022\013\n\003uri\030\001 \001(\t\022\025\n\rfunction_keys\030\002 " - "\003(\t\022\021\n\ttype_keys\030\003 \003(\t\022\033\n\023type_variation" - "_keys\030\004 \003(\tB.\n\025io.substrait.protobufP\001\252\002" - "\022Substrait.Protobufb\006proto3" +const char descriptor_table_protodef_substrait_2fcapabilities_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\034substrait/capabilities.proto\022\tsubstrai" + "t\"\373\001\n\014Capabilities\022\032\n\022substrait_versions" + "\030\001 \003(\t\022$\n\034advanced_extension_type_urls\030\002" + " \003(\t\022B\n\021simple_extensions\030\003 \003(\0132\'.substr" + "ait.Capabilities.SimpleExtension\032e\n\017Simp" + "leExtension\022\013\n\003uri\030\001 \001(\t\022\025\n\rfunction_key" + "s\030\002 \003(\t\022\021\n\ttype_keys\030\003 \003(\t\022\033\n\023type_varia" + "tion_keys\030\004 \003(\tB+\n\022io.substrait.protoP\001\252" + "\002\022Substrait.Protobufb\006proto3" ; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_capabilities_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_capabilities_2eproto = { - false, false, 347, descriptor_table_protodef_capabilities_2eproto, "capabilities.proto", - &descriptor_table_capabilities_2eproto_once, nullptr, 0, 2, - schemas, file_default_instances, TableStruct_capabilities_2eproto::offsets, - file_level_metadata_capabilities_2eproto, file_level_enum_descriptors_capabilities_2eproto, file_level_service_descriptors_capabilities_2eproto, +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fcapabilities_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fcapabilities_2eproto = { + false, false, 348, descriptor_table_protodef_substrait_2fcapabilities_2eproto, "substrait/capabilities.proto", + &descriptor_table_substrait_2fcapabilities_2eproto_once, nullptr, 0, 2, + schemas, file_default_instances, TableStruct_substrait_2fcapabilities_2eproto::offsets, + file_level_metadata_substrait_2fcapabilities_2eproto, file_level_enum_descriptors_substrait_2fcapabilities_2eproto, file_level_service_descriptors_substrait_2fcapabilities_2eproto, }; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_capabilities_2eproto_getter() { - return &descriptor_table_capabilities_2eproto; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fcapabilities_2eproto_getter() { + return &descriptor_table_substrait_2fcapabilities_2eproto; } // Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_capabilities_2eproto(&descriptor_table_capabilities_2eproto); -namespace io { +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fcapabilities_2eproto(&descriptor_table_substrait_2fcapabilities_2eproto); namespace substrait { // =================================================================== @@ -122,7 +119,7 @@ Capabilities_SimpleExtension::Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ type_variation_keys_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Capabilities.SimpleExtension) + // @@protoc_insertion_point(arena_constructor:substrait.Capabilities.SimpleExtension) } Capabilities_SimpleExtension::Capabilities_SimpleExtension(const Capabilities_SimpleExtension& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -135,7 +132,7 @@ Capabilities_SimpleExtension::Capabilities_SimpleExtension(const Capabilities_Si uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.Capabilities.SimpleExtension) + // @@protoc_insertion_point(copy_constructor:substrait.Capabilities.SimpleExtension) } void Capabilities_SimpleExtension::SharedCtor() { @@ -143,7 +140,7 @@ uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyI } Capabilities_SimpleExtension::~Capabilities_SimpleExtension() { - // @@protoc_insertion_point(destructor:io.substrait.Capabilities.SimpleExtension) + // @@protoc_insertion_point(destructor:substrait.Capabilities.SimpleExtension) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -164,7 +161,7 @@ void Capabilities_SimpleExtension::SetCachedSize(int size) const { } void Capabilities_SimpleExtension::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Capabilities.SimpleExtension) +// @@protoc_insertion_point(message_clear_start:substrait.Capabilities.SimpleExtension) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -187,7 +184,7 @@ const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROT if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_uri(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.SimpleExtension.uri")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.uri")); CHK_(ptr); } else goto handle_unusual; continue; @@ -199,7 +196,7 @@ const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROT ptr += 1; auto str = _internal_add_function_keys(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.SimpleExtension.function_keys")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.function_keys")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); @@ -213,7 +210,7 @@ const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROT ptr += 1; auto str = _internal_add_type_keys(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.SimpleExtension.type_keys")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.type_keys")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); @@ -227,7 +224,7 @@ const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROT ptr += 1; auto str = _internal_add_type_variation_keys(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.SimpleExtension.type_variation_keys")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.type_variation_keys")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); @@ -258,7 +255,7 @@ const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROT ::PROTOBUF_NAMESPACE_ID::uint8* Capabilities_SimpleExtension::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Capabilities.SimpleExtension) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Capabilities.SimpleExtension) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -267,7 +264,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Capabilities_SimpleExtension::_InternalSerialize ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_uri().data(), static_cast(this->_internal_uri().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Capabilities.SimpleExtension.uri"); + "substrait.Capabilities.SimpleExtension.uri"); target = stream->WriteStringMaybeAliased( 1, this->_internal_uri(), target); } @@ -278,7 +275,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Capabilities_SimpleExtension::_InternalSerialize ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Capabilities.SimpleExtension.function_keys"); + "substrait.Capabilities.SimpleExtension.function_keys"); target = stream->WriteString(2, s, target); } @@ -288,7 +285,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Capabilities_SimpleExtension::_InternalSerialize ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Capabilities.SimpleExtension.type_keys"); + "substrait.Capabilities.SimpleExtension.type_keys"); target = stream->WriteString(3, s, target); } @@ -298,7 +295,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Capabilities_SimpleExtension::_InternalSerialize ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Capabilities.SimpleExtension.type_variation_keys"); + "substrait.Capabilities.SimpleExtension.type_variation_keys"); target = stream->WriteString(4, s, target); } @@ -306,12 +303,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Capabilities_SimpleExtension::_InternalSerialize target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Capabilities.SimpleExtension) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Capabilities.SimpleExtension) return target; } size_t Capabilities_SimpleExtension::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Capabilities.SimpleExtension) +// @@protoc_insertion_point(message_byte_size_start:substrait.Capabilities.SimpleExtension) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -359,22 +356,22 @@ size_t Capabilities_SimpleExtension::ByteSizeLong() const { } void Capabilities_SimpleExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Capabilities.SimpleExtension) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Capabilities.SimpleExtension) GOOGLE_DCHECK_NE(&from, this); const Capabilities_SimpleExtension* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Capabilities.SimpleExtension) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Capabilities.SimpleExtension) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Capabilities.SimpleExtension) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Capabilities.SimpleExtension) MergeFrom(*source); } } void Capabilities_SimpleExtension::MergeFrom(const Capabilities_SimpleExtension& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Capabilities.SimpleExtension) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Capabilities.SimpleExtension) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -389,14 +386,14 @@ void Capabilities_SimpleExtension::MergeFrom(const Capabilities_SimpleExtension& } void Capabilities_SimpleExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Capabilities.SimpleExtension) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Capabilities.SimpleExtension) if (&from == this) return; Clear(); MergeFrom(from); } void Capabilities_SimpleExtension::CopyFrom(const Capabilities_SimpleExtension& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Capabilities.SimpleExtension) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Capabilities.SimpleExtension) if (&from == this) return; Clear(); MergeFrom(from); @@ -417,8 +414,8 @@ void Capabilities_SimpleExtension::InternalSwap(Capabilities_SimpleExtension* ot ::PROTOBUF_NAMESPACE_ID::Metadata Capabilities_SimpleExtension::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_capabilities_2eproto_getter, &descriptor_table_capabilities_2eproto_once, - file_level_metadata_capabilities_2eproto[0]); + &descriptor_table_substrait_2fcapabilities_2eproto_getter, &descriptor_table_substrait_2fcapabilities_2eproto_once, + file_level_metadata_substrait_2fcapabilities_2eproto[0]); } // =================================================================== @@ -434,7 +431,7 @@ Capabilities::Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena) simple_extensions_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Capabilities) + // @@protoc_insertion_point(arena_constructor:substrait.Capabilities) } Capabilities::Capabilities(const Capabilities& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -442,14 +439,14 @@ Capabilities::Capabilities(const Capabilities& from) advanced_extension_type_urls_(from.advanced_extension_type_urls_), simple_extensions_(from.simple_extensions_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Capabilities) + // @@protoc_insertion_point(copy_constructor:substrait.Capabilities) } void Capabilities::SharedCtor() { } Capabilities::~Capabilities() { - // @@protoc_insertion_point(destructor:io.substrait.Capabilities) + // @@protoc_insertion_point(destructor:substrait.Capabilities) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -469,7 +466,7 @@ void Capabilities::SetCachedSize(int size) const { } void Capabilities::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Capabilities) +// @@protoc_insertion_point(message_clear_start:substrait.Capabilities) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -494,7 +491,7 @@ const char* Capabilities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ptr += 1; auto str = _internal_add_substrait_versions(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.substrait_versions")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.substrait_versions")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); @@ -508,13 +505,13 @@ const char* Capabilities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ptr += 1; auto str = _internal_add_advanced_extension_type_urls(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Capabilities.advanced_extension_type_urls")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.advanced_extension_type_urls")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // repeated .io.substrait.Capabilities.SimpleExtension simple_extensions = 3; + // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; @@ -551,7 +548,7 @@ const char* Capabilities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ::PROTOBUF_NAMESPACE_ID::uint8* Capabilities::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Capabilities) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Capabilities) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -561,7 +558,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Capabilities::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Capabilities.substrait_versions"); + "substrait.Capabilities.substrait_versions"); target = stream->WriteString(1, s, target); } @@ -571,11 +568,11 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Capabilities::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Capabilities.advanced_extension_type_urls"); + "substrait.Capabilities.advanced_extension_type_urls"); target = stream->WriteString(2, s, target); } - // repeated .io.substrait.Capabilities.SimpleExtension simple_extensions = 3; + // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; for (unsigned int i = 0, n = static_cast(this->_internal_simple_extensions_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -587,12 +584,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Capabilities::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Capabilities) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Capabilities) return target; } size_t Capabilities::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Capabilities) +// @@protoc_insertion_point(message_byte_size_start:substrait.Capabilities) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -615,7 +612,7 @@ size_t Capabilities::ByteSizeLong() const { advanced_extension_type_urls_.Get(i)); } - // repeated .io.substrait.Capabilities.SimpleExtension simple_extensions = 3; + // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; total_size += 1UL * this->_internal_simple_extensions_size(); for (const auto& msg : this->simple_extensions_) { total_size += @@ -632,22 +629,22 @@ size_t Capabilities::ByteSizeLong() const { } void Capabilities::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Capabilities) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Capabilities) GOOGLE_DCHECK_NE(&from, this); const Capabilities* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Capabilities) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Capabilities) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Capabilities) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Capabilities) MergeFrom(*source); } } void Capabilities::MergeFrom(const Capabilities& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Capabilities) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Capabilities) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -659,14 +656,14 @@ void Capabilities::MergeFrom(const Capabilities& from) { } void Capabilities::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Capabilities) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Capabilities) if (&from == this) return; Clear(); MergeFrom(from); } void Capabilities::CopyFrom(const Capabilities& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Capabilities) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Capabilities) if (&from == this) return; Clear(); MergeFrom(from); @@ -686,19 +683,18 @@ void Capabilities::InternalSwap(Capabilities* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Capabilities::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_capabilities_2eproto_getter, &descriptor_table_capabilities_2eproto_once, - file_level_metadata_capabilities_2eproto[1]); + &descriptor_table_substrait_2fcapabilities_2eproto_getter, &descriptor_table_substrait_2fcapabilities_2eproto_once, + file_level_metadata_substrait_2fcapabilities_2eproto[1]); } // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::Capabilities_SimpleExtension* Arena::CreateMaybeMessage< ::io::substrait::Capabilities_SimpleExtension >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Capabilities_SimpleExtension >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Capabilities_SimpleExtension* Arena::CreateMaybeMessage< ::substrait::Capabilities_SimpleExtension >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Capabilities_SimpleExtension >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Capabilities* Arena::CreateMaybeMessage< ::io::substrait::Capabilities >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Capabilities >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Capabilities* Arena::CreateMaybeMessage< ::substrait::Capabilities >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Capabilities >(arena); } PROTOBUF_NAMESPACE_CLOSE diff --git a/cpp/src/generated/substrait/capabilities.pb.h b/cpp/src/generated/substrait/capabilities.pb.h index c9232b22d8e..1bad72cf967 100644 --- a/cpp/src/generated/substrait/capabilities.pb.h +++ b/cpp/src/generated/substrait/capabilities.pb.h @@ -1,8 +1,8 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: capabilities.proto +// source: substrait/capabilities.proto -#ifndef GOOGLE_PROTOBUF_INCLUDED_capabilities_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_capabilities_2eproto +#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fcapabilities_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fcapabilities_2eproto #include #include @@ -33,7 +33,7 @@ #include // @@protoc_insertion_point(includes) #include -#define PROTOBUF_INTERNAL_EXPORT_capabilities_2eproto +#define PROTOBUF_INTERNAL_EXPORT_substrait_2fcapabilities_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; @@ -41,7 +41,7 @@ class AnyMetadata; PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. -struct TableStruct_capabilities_2eproto { +struct TableStruct_substrait_2fcapabilities_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] @@ -52,8 +52,7 @@ struct TableStruct_capabilities_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; }; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_capabilities_2eproto; -namespace io { +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fcapabilities_2eproto; namespace substrait { class Capabilities; struct CapabilitiesDefaultTypeInternal; @@ -62,18 +61,16 @@ class Capabilities_SimpleExtension; struct Capabilities_SimpleExtensionDefaultTypeInternal; extern Capabilities_SimpleExtensionDefaultTypeInternal _Capabilities_SimpleExtension_default_instance_; } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::Capabilities* Arena::CreateMaybeMessage<::io::substrait::Capabilities>(Arena*); -template<> ::io::substrait::Capabilities_SimpleExtension* Arena::CreateMaybeMessage<::io::substrait::Capabilities_SimpleExtension>(Arena*); +template<> ::substrait::Capabilities* Arena::CreateMaybeMessage<::substrait::Capabilities>(Arena*); +template<> ::substrait::Capabilities_SimpleExtension* Arena::CreateMaybeMessage<::substrait::Capabilities_SimpleExtension>(Arena*); PROTOBUF_NAMESPACE_CLOSE -namespace io { namespace substrait { // =================================================================== class Capabilities_SimpleExtension PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Capabilities.SimpleExtension) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Capabilities.SimpleExtension) */ { public: inline Capabilities_SimpleExtension() : Capabilities_SimpleExtension(nullptr) {} ~Capabilities_SimpleExtension() override; @@ -163,7 +160,7 @@ class Capabilities_SimpleExtension PROTOBUF_FINAL : void InternalSwap(Capabilities_SimpleExtension* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Capabilities.SimpleExtension"; + return "substrait.Capabilities.SimpleExtension"; } protected: explicit Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -270,7 +267,7 @@ class Capabilities_SimpleExtension PROTOBUF_FINAL : std::string* _internal_mutable_uri(); public: - // @@protoc_insertion_point(class_scope:io.substrait.Capabilities.SimpleExtension) + // @@protoc_insertion_point(class_scope:substrait.Capabilities.SimpleExtension) private: class _Internal; @@ -282,12 +279,12 @@ class Capabilities_SimpleExtension PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField type_variation_keys_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_capabilities_2eproto; + friend struct ::TableStruct_substrait_2fcapabilities_2eproto; }; // ------------------------------------------------------------------- class Capabilities PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Capabilities) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Capabilities) */ { public: inline Capabilities() : Capabilities(nullptr) {} ~Capabilities() override; @@ -377,7 +374,7 @@ class Capabilities PROTOBUF_FINAL : void InternalSwap(Capabilities* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Capabilities"; + return "substrait.Capabilities"; } protected: explicit Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -447,25 +444,25 @@ class Capabilities PROTOBUF_FINAL : std::string* _internal_add_advanced_extension_type_urls(); public: - // repeated .io.substrait.Capabilities.SimpleExtension simple_extensions = 3; + // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; int simple_extensions_size() const; private: int _internal_simple_extensions_size() const; public: void clear_simple_extensions(); - ::io::substrait::Capabilities_SimpleExtension* mutable_simple_extensions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Capabilities_SimpleExtension >* + ::substrait::Capabilities_SimpleExtension* mutable_simple_extensions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >* mutable_simple_extensions(); private: - const ::io::substrait::Capabilities_SimpleExtension& _internal_simple_extensions(int index) const; - ::io::substrait::Capabilities_SimpleExtension* _internal_add_simple_extensions(); + const ::substrait::Capabilities_SimpleExtension& _internal_simple_extensions(int index) const; + ::substrait::Capabilities_SimpleExtension* _internal_add_simple_extensions(); public: - const ::io::substrait::Capabilities_SimpleExtension& simple_extensions(int index) const; - ::io::substrait::Capabilities_SimpleExtension* add_simple_extensions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Capabilities_SimpleExtension >& + const ::substrait::Capabilities_SimpleExtension& simple_extensions(int index) const; + ::substrait::Capabilities_SimpleExtension* add_simple_extensions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >& simple_extensions() const; - // @@protoc_insertion_point(class_scope:io.substrait.Capabilities) + // @@protoc_insertion_point(class_scope:substrait.Capabilities) private: class _Internal; @@ -474,9 +471,9 @@ class Capabilities PROTOBUF_FINAL : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField substrait_versions_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField advanced_extension_type_urls_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Capabilities_SimpleExtension > simple_extensions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension > simple_extensions_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_capabilities_2eproto; + friend struct ::TableStruct_substrait_2fcapabilities_2eproto; }; // =================================================================== @@ -494,7 +491,7 @@ inline void Capabilities_SimpleExtension::clear_uri() { uri_.ClearToEmpty(); } inline const std::string& Capabilities_SimpleExtension::uri() const { - // @@protoc_insertion_point(field_get:io.substrait.Capabilities.SimpleExtension.uri) + // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.uri) return _internal_uri(); } template @@ -502,10 +499,10 @@ PROTOBUF_ALWAYS_INLINE inline void Capabilities_SimpleExtension::set_uri(ArgT0&& arg0, ArgT... args) { uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.uri) + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.uri) } inline std::string* Capabilities_SimpleExtension::mutable_uri() { - // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.SimpleExtension.uri) + // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.uri) return _internal_mutable_uri(); } inline const std::string& Capabilities_SimpleExtension::_internal_uri() const { @@ -520,7 +517,7 @@ inline std::string* Capabilities_SimpleExtension::_internal_mutable_uri() { return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Capabilities_SimpleExtension::release_uri() { - // @@protoc_insertion_point(field_release:io.substrait.Capabilities.SimpleExtension.uri) + // @@protoc_insertion_point(field_release:substrait.Capabilities.SimpleExtension.uri) return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void Capabilities_SimpleExtension::set_allocated_uri(std::string* uri) { @@ -531,7 +528,7 @@ inline void Capabilities_SimpleExtension::set_allocated_uri(std::string* uri) { } uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Capabilities.SimpleExtension.uri) + // @@protoc_insertion_point(field_set_allocated:substrait.Capabilities.SimpleExtension.uri) } // repeated string function_keys = 2; @@ -545,66 +542,66 @@ inline void Capabilities_SimpleExtension::clear_function_keys() { function_keys_.Clear(); } inline std::string* Capabilities_SimpleExtension::add_function_keys() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.function_keys) return _internal_add_function_keys(); } inline const std::string& Capabilities_SimpleExtension::_internal_function_keys(int index) const { return function_keys_.Get(index); } inline const std::string& Capabilities_SimpleExtension::function_keys(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.function_keys) return _internal_function_keys(index); } inline std::string* Capabilities_SimpleExtension::mutable_function_keys(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.function_keys) return function_keys_.Mutable(index); } inline void Capabilities_SimpleExtension::set_function_keys(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.function_keys) function_keys_.Mutable(index)->assign(value); } inline void Capabilities_SimpleExtension::set_function_keys(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.function_keys) function_keys_.Mutable(index)->assign(std::move(value)); } inline void Capabilities_SimpleExtension::set_function_keys(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); function_keys_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_set_char:substrait.Capabilities.SimpleExtension.function_keys) } inline void Capabilities_SimpleExtension::set_function_keys(int index, const char* value, size_t size) { function_keys_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.SimpleExtension.function_keys) } inline std::string* Capabilities_SimpleExtension::_internal_add_function_keys() { return function_keys_.Add(); } inline void Capabilities_SimpleExtension::add_function_keys(const std::string& value) { function_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.function_keys) } inline void Capabilities_SimpleExtension::add_function_keys(std::string&& value) { function_keys_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.function_keys) } inline void Capabilities_SimpleExtension::add_function_keys(const char* value) { GOOGLE_DCHECK(value != nullptr); function_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_add_char:substrait.Capabilities.SimpleExtension.function_keys) } inline void Capabilities_SimpleExtension::add_function_keys(const char* value, size_t size) { function_keys_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.function_keys) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& Capabilities_SimpleExtension::function_keys() const { - // @@protoc_insertion_point(field_list:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.function_keys) return function_keys_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* Capabilities_SimpleExtension::mutable_function_keys() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.SimpleExtension.function_keys) + // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.SimpleExtension.function_keys) return &function_keys_; } @@ -619,66 +616,66 @@ inline void Capabilities_SimpleExtension::clear_type_keys() { type_keys_.Clear(); } inline std::string* Capabilities_SimpleExtension::add_type_keys() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.type_keys) return _internal_add_type_keys(); } inline const std::string& Capabilities_SimpleExtension::_internal_type_keys(int index) const { return type_keys_.Get(index); } inline const std::string& Capabilities_SimpleExtension::type_keys(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.type_keys) return _internal_type_keys(index); } inline std::string* Capabilities_SimpleExtension::mutable_type_keys(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.type_keys) return type_keys_.Mutable(index); } inline void Capabilities_SimpleExtension::set_type_keys(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_keys) type_keys_.Mutable(index)->assign(value); } inline void Capabilities_SimpleExtension::set_type_keys(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_keys) type_keys_.Mutable(index)->assign(std::move(value)); } inline void Capabilities_SimpleExtension::set_type_keys(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); type_keys_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_set_char:substrait.Capabilities.SimpleExtension.type_keys) } inline void Capabilities_SimpleExtension::set_type_keys(int index, const char* value, size_t size) { type_keys_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.SimpleExtension.type_keys) } inline std::string* Capabilities_SimpleExtension::_internal_add_type_keys() { return type_keys_.Add(); } inline void Capabilities_SimpleExtension::add_type_keys(const std::string& value) { type_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_keys) } inline void Capabilities_SimpleExtension::add_type_keys(std::string&& value) { type_keys_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_keys) } inline void Capabilities_SimpleExtension::add_type_keys(const char* value) { GOOGLE_DCHECK(value != nullptr); type_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_add_char:substrait.Capabilities.SimpleExtension.type_keys) } inline void Capabilities_SimpleExtension::add_type_keys(const char* value, size_t size) { type_keys_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.type_keys) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& Capabilities_SimpleExtension::type_keys() const { - // @@protoc_insertion_point(field_list:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.type_keys) return type_keys_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* Capabilities_SimpleExtension::mutable_type_keys() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.SimpleExtension.type_keys) + // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.SimpleExtension.type_keys) return &type_keys_; } @@ -693,66 +690,66 @@ inline void Capabilities_SimpleExtension::clear_type_variation_keys() { type_variation_keys_.Clear(); } inline std::string* Capabilities_SimpleExtension::add_type_variation_keys() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.type_variation_keys) return _internal_add_type_variation_keys(); } inline const std::string& Capabilities_SimpleExtension::_internal_type_variation_keys(int index) const { return type_variation_keys_.Get(index); } inline const std::string& Capabilities_SimpleExtension::type_variation_keys(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.type_variation_keys) return _internal_type_variation_keys(index); } inline std::string* Capabilities_SimpleExtension::mutable_type_variation_keys(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.type_variation_keys) return type_variation_keys_.Mutable(index); } inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_variation_keys) type_variation_keys_.Mutable(index)->assign(value); } inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_variation_keys) type_variation_keys_.Mutable(index)->assign(std::move(value)); } inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); type_variation_keys_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_set_char:substrait.Capabilities.SimpleExtension.type_variation_keys) } inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const char* value, size_t size) { type_variation_keys_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.SimpleExtension.type_variation_keys) } inline std::string* Capabilities_SimpleExtension::_internal_add_type_variation_keys() { return type_variation_keys_.Add(); } inline void Capabilities_SimpleExtension::add_type_variation_keys(const std::string& value) { type_variation_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_variation_keys) } inline void Capabilities_SimpleExtension::add_type_variation_keys(std::string&& value) { type_variation_keys_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_variation_keys) } inline void Capabilities_SimpleExtension::add_type_variation_keys(const char* value) { GOOGLE_DCHECK(value != nullptr); type_variation_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_add_char:substrait.Capabilities.SimpleExtension.type_variation_keys) } inline void Capabilities_SimpleExtension::add_type_variation_keys(const char* value, size_t size) { type_variation_keys_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.type_variation_keys) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& Capabilities_SimpleExtension::type_variation_keys() const { - // @@protoc_insertion_point(field_list:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.type_variation_keys) return type_variation_keys_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* Capabilities_SimpleExtension::mutable_type_variation_keys() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.SimpleExtension.type_variation_keys) + // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.SimpleExtension.type_variation_keys) return &type_variation_keys_; } @@ -771,66 +768,66 @@ inline void Capabilities::clear_substrait_versions() { substrait_versions_.Clear(); } inline std::string* Capabilities::add_substrait_versions() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.substrait_versions) return _internal_add_substrait_versions(); } inline const std::string& Capabilities::_internal_substrait_versions(int index) const { return substrait_versions_.Get(index); } inline const std::string& Capabilities::substrait_versions(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_get:substrait.Capabilities.substrait_versions) return _internal_substrait_versions(index); } inline std::string* Capabilities::mutable_substrait_versions(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_mutable:substrait.Capabilities.substrait_versions) return substrait_versions_.Mutable(index); } inline void Capabilities::set_substrait_versions(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_set:substrait.Capabilities.substrait_versions) substrait_versions_.Mutable(index)->assign(value); } inline void Capabilities::set_substrait_versions(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_set:substrait.Capabilities.substrait_versions) substrait_versions_.Mutable(index)->assign(std::move(value)); } inline void Capabilities::set_substrait_versions(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); substrait_versions_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_set_char:substrait.Capabilities.substrait_versions) } inline void Capabilities::set_substrait_versions(int index, const char* value, size_t size) { substrait_versions_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.substrait_versions) } inline std::string* Capabilities::_internal_add_substrait_versions() { return substrait_versions_.Add(); } inline void Capabilities::add_substrait_versions(const std::string& value) { substrait_versions_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_add:substrait.Capabilities.substrait_versions) } inline void Capabilities::add_substrait_versions(std::string&& value) { substrait_versions_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_add:substrait.Capabilities.substrait_versions) } inline void Capabilities::add_substrait_versions(const char* value) { GOOGLE_DCHECK(value != nullptr); substrait_versions_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_add_char:substrait.Capabilities.substrait_versions) } inline void Capabilities::add_substrait_versions(const char* value, size_t size) { substrait_versions_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.substrait_versions) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& Capabilities::substrait_versions() const { - // @@protoc_insertion_point(field_list:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_list:substrait.Capabilities.substrait_versions) return substrait_versions_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* Capabilities::mutable_substrait_versions() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.substrait_versions) + // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.substrait_versions) return &substrait_versions_; } @@ -845,70 +842,70 @@ inline void Capabilities::clear_advanced_extension_type_urls() { advanced_extension_type_urls_.Clear(); } inline std::string* Capabilities::add_advanced_extension_type_urls() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.advanced_extension_type_urls) return _internal_add_advanced_extension_type_urls(); } inline const std::string& Capabilities::_internal_advanced_extension_type_urls(int index) const { return advanced_extension_type_urls_.Get(index); } inline const std::string& Capabilities::advanced_extension_type_urls(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_get:substrait.Capabilities.advanced_extension_type_urls) return _internal_advanced_extension_type_urls(index); } inline std::string* Capabilities::mutable_advanced_extension_type_urls(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_mutable:substrait.Capabilities.advanced_extension_type_urls) return advanced_extension_type_urls_.Mutable(index); } inline void Capabilities::set_advanced_extension_type_urls(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_set:substrait.Capabilities.advanced_extension_type_urls) advanced_extension_type_urls_.Mutable(index)->assign(value); } inline void Capabilities::set_advanced_extension_type_urls(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_set:substrait.Capabilities.advanced_extension_type_urls) advanced_extension_type_urls_.Mutable(index)->assign(std::move(value)); } inline void Capabilities::set_advanced_extension_type_urls(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); advanced_extension_type_urls_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_set_char:substrait.Capabilities.advanced_extension_type_urls) } inline void Capabilities::set_advanced_extension_type_urls(int index, const char* value, size_t size) { advanced_extension_type_urls_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.advanced_extension_type_urls) } inline std::string* Capabilities::_internal_add_advanced_extension_type_urls() { return advanced_extension_type_urls_.Add(); } inline void Capabilities::add_advanced_extension_type_urls(const std::string& value) { advanced_extension_type_urls_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_add:substrait.Capabilities.advanced_extension_type_urls) } inline void Capabilities::add_advanced_extension_type_urls(std::string&& value) { advanced_extension_type_urls_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_add:substrait.Capabilities.advanced_extension_type_urls) } inline void Capabilities::add_advanced_extension_type_urls(const char* value) { GOOGLE_DCHECK(value != nullptr); advanced_extension_type_urls_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_add_char:substrait.Capabilities.advanced_extension_type_urls) } inline void Capabilities::add_advanced_extension_type_urls(const char* value, size_t size) { advanced_extension_type_urls_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.advanced_extension_type_urls) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& Capabilities::advanced_extension_type_urls() const { - // @@protoc_insertion_point(field_list:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_list:substrait.Capabilities.advanced_extension_type_urls) return advanced_extension_type_urls_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* Capabilities::mutable_advanced_extension_type_urls() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.advanced_extension_type_urls) + // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.advanced_extension_type_urls) return &advanced_extension_type_urls_; } -// repeated .io.substrait.Capabilities.SimpleExtension simple_extensions = 3; +// repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; inline int Capabilities::_internal_simple_extensions_size() const { return simple_extensions_.size(); } @@ -918,32 +915,32 @@ inline int Capabilities::simple_extensions_size() const { inline void Capabilities::clear_simple_extensions() { simple_extensions_.Clear(); } -inline ::io::substrait::Capabilities_SimpleExtension* Capabilities::mutable_simple_extensions(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Capabilities.simple_extensions) +inline ::substrait::Capabilities_SimpleExtension* Capabilities::mutable_simple_extensions(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Capabilities.simple_extensions) return simple_extensions_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Capabilities_SimpleExtension >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >* Capabilities::mutable_simple_extensions() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Capabilities.simple_extensions) + // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.simple_extensions) return &simple_extensions_; } -inline const ::io::substrait::Capabilities_SimpleExtension& Capabilities::_internal_simple_extensions(int index) const { +inline const ::substrait::Capabilities_SimpleExtension& Capabilities::_internal_simple_extensions(int index) const { return simple_extensions_.Get(index); } -inline const ::io::substrait::Capabilities_SimpleExtension& Capabilities::simple_extensions(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Capabilities.simple_extensions) +inline const ::substrait::Capabilities_SimpleExtension& Capabilities::simple_extensions(int index) const { + // @@protoc_insertion_point(field_get:substrait.Capabilities.simple_extensions) return _internal_simple_extensions(index); } -inline ::io::substrait::Capabilities_SimpleExtension* Capabilities::_internal_add_simple_extensions() { +inline ::substrait::Capabilities_SimpleExtension* Capabilities::_internal_add_simple_extensions() { return simple_extensions_.Add(); } -inline ::io::substrait::Capabilities_SimpleExtension* Capabilities::add_simple_extensions() { - // @@protoc_insertion_point(field_add:io.substrait.Capabilities.simple_extensions) +inline ::substrait::Capabilities_SimpleExtension* Capabilities::add_simple_extensions() { + // @@protoc_insertion_point(field_add:substrait.Capabilities.simple_extensions) return _internal_add_simple_extensions(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Capabilities_SimpleExtension >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >& Capabilities::simple_extensions() const { - // @@protoc_insertion_point(field_list:io.substrait.Capabilities.simple_extensions) + // @@protoc_insertion_point(field_list:substrait.Capabilities.simple_extensions) return simple_extensions_; } @@ -956,9 +953,8 @@ Capabilities::simple_extensions() const { // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io // @@protoc_insertion_point(global_scope) #include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_capabilities_2eproto +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fcapabilities_2eproto diff --git a/cpp/src/generated/substrait/expression.pb.cc b/cpp/src/generated/substrait/expression.pb.cc index 33b42139e64..8ab2069b7a3 100644 --- a/cpp/src/generated/substrait/expression.pb.cc +++ b/cpp/src/generated/substrait/expression.pb.cc @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: expression.proto +// source: substrait/expression.proto -#include "expression.pb.h" +#include "substrait/expression.pb.h" #include @@ -16,7 +16,6 @@ #include PROTOBUF_PRAGMA_INIT_SEG -namespace io { namespace substrait { constexpr Expression_Enum_Empty::Expression_Enum_Empty( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} @@ -83,9 +82,7 @@ struct Expression_Literal_Map_KeyValueDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_Map_KeyValueDefaultTypeInternal _Expression_Literal_Map_KeyValue_default_instance_; constexpr Expression_Literal_Map::Expression_Literal_Map( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : key_values_() - , key_type_(nullptr) - , value_type_(nullptr){} + : key_values_(){} struct Expression_Literal_MapDefaultTypeInternal { constexpr Expression_Literal_MapDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -135,8 +132,7 @@ struct Expression_Literal_StructDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_StructDefaultTypeInternal _Expression_Literal_Struct_default_instance_; constexpr Expression_Literal_List::Expression_Literal_List( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : values_() - , element_type_(nullptr){} + : values_(){} struct Expression_Literal_ListDefaultTypeInternal { constexpr Expression_Literal_ListDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -648,86 +644,82 @@ struct AggregateFunctionDefaultTypeInternal { }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateFunctionDefaultTypeInternal _AggregateFunction_default_instance_; } // namespace substrait -} // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_expression_2eproto[49]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_expression_2eproto[2]; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_expression_2eproto = nullptr; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fexpression_2eproto[49]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2fexpression_2eproto[2]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fexpression_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Enum_Empty, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum_Empty, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Enum, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Enum, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Enum, enum_kind_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, enum_kind_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_VarChar, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_VarChar, value_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_VarChar, length_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, value_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, length_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Decimal, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Decimal, value_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Decimal, precision_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Decimal, scale_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, value_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, precision_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, scale_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map_KeyValue, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map_KeyValue, key_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map_KeyValue, value_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, key_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, value_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map, key_values_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map, key_type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Map, value_type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map, key_values_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalYearToMonth, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalYearToMonth, years_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalYearToMonth, months_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, years_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, months_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalDayToSecond, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalDayToSecond, days_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_IntervalDayToSecond, seconds_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, days_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, seconds_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Struct, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Struct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_Struct, fields_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Struct, fields_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_List, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_List, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_List, values_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal_List, element_type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_List, values_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -753,268 +745,270 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal, nullable_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Literal, literal_type_), + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, nullable_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, literal_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, function_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, args_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ScalarFunction, output_type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, function_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, args_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, output_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Preceding, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Preceding, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Preceding, offset_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Preceding, offset_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Following, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Following, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Following, offset_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Following, offset_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_CurrentRow, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_CurrentRow, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound_Unbounded, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Unbounded, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction_Bound, kind_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, kind_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, function_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, partitions_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, sorts_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, upper_bound_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, lower_bound_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, phase_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, output_type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_WindowFunction, args_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, function_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, partitions_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, sorts_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, upper_bound_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, lower_bound_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, phase_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, output_type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, args_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen_IfClause, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen_IfClause, if__), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen_IfClause, then_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, if__), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, then_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen, ifs_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_IfThen, else__), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, ifs_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, else__), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Cast, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Cast, type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_Cast, input_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, input_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression_IfValue, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression_IfValue, if__), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression_IfValue, then_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, if__), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, then_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression, ifs_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SwitchExpression, else__), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, ifs_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, else__), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SingularOrList, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SingularOrList, value_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_SingularOrList, options_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, value_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, options_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MultiOrList_Record, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList_Record, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MultiOrList_Record, fields_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList_Record, fields_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MultiOrList, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MultiOrList, value_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MultiOrList, options_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, value_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, options_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction, function_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction, prerequisite_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, function_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, prerequisite_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, script_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, prerequisite_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, script_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, prerequisite_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, arguments_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, output_type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, arguments_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, output_type_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_EmbeddedFunction, kind_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, kind_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_MapKey, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_MapKey, map_key_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_MapKey, child_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, map_key_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, child_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_StructField, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_StructField, field_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_StructField, child_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, field_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, child_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_ListElement, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_ListElement, offset_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment_ListElement, child_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, offset_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, child_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_ReferenceSegment, reference_type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, reference_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_Select, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_Select, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_Select, type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_StructSelect, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructSelect, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_StructSelect, struct_items_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructSelect, struct_items_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_StructItem, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_StructItem, field_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_StructItem, child_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, field_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, child_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, field_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, field_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, start_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, start_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect, selection_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_ListSelect, child_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, selection_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, child_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect_MapKey, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKey, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect_MapKey, map_key_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKey, map_key_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, map_key_expression_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, map_key_expression_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect, child_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression_MapSelect, select_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, child_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, select_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression, select_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_MaskExpression, maintain_singular_struct_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, select_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, maintain_singular_struct_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_FieldReference_RootReference, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference_RootReference, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_FieldReference, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_FieldReference, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_FieldReference, reference_type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression_FieldReference, root_type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, reference_type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, root_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Expression, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -1026,337 +1020,334 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_expression_2eproto::offsets[] ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Expression, rex_type_), + PROTOBUF_FIELD_OFFSET(::substrait::Expression, rex_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::SortField, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::SortField, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::SortField, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::SortField, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::SortField, expr_), + PROTOBUF_FIELD_OFFSET(::substrait::SortField, expr_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::SortField, sort_kind_), + PROTOBUF_FIELD_OFFSET(::substrait::SortField, sort_kind_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, function_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, args_), - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, sorts_), - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, phase_), - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateFunction, output_type_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, function_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, args_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, sorts_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, phase_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, output_type_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::Expression_Enum_Empty)}, - { 5, -1, sizeof(::io::substrait::Expression_Enum)}, - { 13, -1, sizeof(::io::substrait::Expression_Literal_VarChar)}, - { 20, -1, sizeof(::io::substrait::Expression_Literal_Decimal)}, - { 28, -1, sizeof(::io::substrait::Expression_Literal_Map_KeyValue)}, - { 35, -1, sizeof(::io::substrait::Expression_Literal_Map)}, - { 43, -1, sizeof(::io::substrait::Expression_Literal_IntervalYearToMonth)}, - { 50, -1, sizeof(::io::substrait::Expression_Literal_IntervalDayToSecond)}, - { 57, -1, sizeof(::io::substrait::Expression_Literal_Struct)}, - { 63, -1, sizeof(::io::substrait::Expression_Literal_List)}, - { 70, -1, sizeof(::io::substrait::Expression_Literal)}, - { 101, -1, sizeof(::io::substrait::Expression_ScalarFunction)}, - { 109, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Preceding)}, - { 115, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Following)}, - { 121, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_CurrentRow)}, - { 126, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound_Unbounded)}, - { 131, -1, sizeof(::io::substrait::Expression_WindowFunction_Bound)}, - { 141, -1, sizeof(::io::substrait::Expression_WindowFunction)}, - { 154, -1, sizeof(::io::substrait::Expression_IfThen_IfClause)}, - { 161, -1, sizeof(::io::substrait::Expression_IfThen)}, - { 168, -1, sizeof(::io::substrait::Expression_Cast)}, - { 175, -1, sizeof(::io::substrait::Expression_SwitchExpression_IfValue)}, - { 182, -1, sizeof(::io::substrait::Expression_SwitchExpression)}, - { 189, -1, sizeof(::io::substrait::Expression_SingularOrList)}, - { 196, -1, sizeof(::io::substrait::Expression_MultiOrList_Record)}, - { 202, -1, sizeof(::io::substrait::Expression_MultiOrList)}, - { 209, -1, sizeof(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction)}, - { 216, -1, sizeof(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction)}, - { 223, -1, sizeof(::io::substrait::Expression_EmbeddedFunction)}, - { 233, -1, sizeof(::io::substrait::Expression_ReferenceSegment_MapKey)}, - { 240, -1, sizeof(::io::substrait::Expression_ReferenceSegment_StructField)}, - { 247, -1, sizeof(::io::substrait::Expression_ReferenceSegment_ListElement)}, - { 254, -1, sizeof(::io::substrait::Expression_ReferenceSegment)}, - { 263, -1, sizeof(::io::substrait::Expression_MaskExpression_Select)}, - { 272, -1, sizeof(::io::substrait::Expression_MaskExpression_StructSelect)}, - { 278, -1, sizeof(::io::substrait::Expression_MaskExpression_StructItem)}, - { 285, -1, sizeof(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement)}, - { 291, -1, sizeof(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice)}, - { 298, -1, sizeof(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem)}, - { 306, -1, sizeof(::io::substrait::Expression_MaskExpression_ListSelect)}, - { 313, -1, sizeof(::io::substrait::Expression_MaskExpression_MapSelect_MapKey)}, - { 319, -1, sizeof(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression)}, - { 325, -1, sizeof(::io::substrait::Expression_MaskExpression_MapSelect)}, - { 334, -1, sizeof(::io::substrait::Expression_MaskExpression)}, - { 341, -1, sizeof(::io::substrait::Expression_FieldReference_RootReference)}, - { 346, -1, sizeof(::io::substrait::Expression_FieldReference)}, - { 357, -1, sizeof(::io::substrait::Expression)}, - { 373, -1, sizeof(::io::substrait::SortField)}, - { 382, -1, sizeof(::io::substrait::AggregateFunction)}, + { 0, -1, sizeof(::substrait::Expression_Enum_Empty)}, + { 5, -1, sizeof(::substrait::Expression_Enum)}, + { 13, -1, sizeof(::substrait::Expression_Literal_VarChar)}, + { 20, -1, sizeof(::substrait::Expression_Literal_Decimal)}, + { 28, -1, sizeof(::substrait::Expression_Literal_Map_KeyValue)}, + { 35, -1, sizeof(::substrait::Expression_Literal_Map)}, + { 41, -1, sizeof(::substrait::Expression_Literal_IntervalYearToMonth)}, + { 48, -1, sizeof(::substrait::Expression_Literal_IntervalDayToSecond)}, + { 55, -1, sizeof(::substrait::Expression_Literal_Struct)}, + { 61, -1, sizeof(::substrait::Expression_Literal_List)}, + { 67, -1, sizeof(::substrait::Expression_Literal)}, + { 100, -1, sizeof(::substrait::Expression_ScalarFunction)}, + { 108, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Preceding)}, + { 114, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Following)}, + { 120, -1, sizeof(::substrait::Expression_WindowFunction_Bound_CurrentRow)}, + { 125, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Unbounded)}, + { 130, -1, sizeof(::substrait::Expression_WindowFunction_Bound)}, + { 140, -1, sizeof(::substrait::Expression_WindowFunction)}, + { 153, -1, sizeof(::substrait::Expression_IfThen_IfClause)}, + { 160, -1, sizeof(::substrait::Expression_IfThen)}, + { 167, -1, sizeof(::substrait::Expression_Cast)}, + { 174, -1, sizeof(::substrait::Expression_SwitchExpression_IfValue)}, + { 181, -1, sizeof(::substrait::Expression_SwitchExpression)}, + { 188, -1, sizeof(::substrait::Expression_SingularOrList)}, + { 195, -1, sizeof(::substrait::Expression_MultiOrList_Record)}, + { 201, -1, sizeof(::substrait::Expression_MultiOrList)}, + { 208, -1, sizeof(::substrait::Expression_EmbeddedFunction_PythonPickleFunction)}, + { 215, -1, sizeof(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction)}, + { 222, -1, sizeof(::substrait::Expression_EmbeddedFunction)}, + { 232, -1, sizeof(::substrait::Expression_ReferenceSegment_MapKey)}, + { 239, -1, sizeof(::substrait::Expression_ReferenceSegment_StructField)}, + { 246, -1, sizeof(::substrait::Expression_ReferenceSegment_ListElement)}, + { 253, -1, sizeof(::substrait::Expression_ReferenceSegment)}, + { 262, -1, sizeof(::substrait::Expression_MaskExpression_Select)}, + { 271, -1, sizeof(::substrait::Expression_MaskExpression_StructSelect)}, + { 277, -1, sizeof(::substrait::Expression_MaskExpression_StructItem)}, + { 284, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement)}, + { 290, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice)}, + { 297, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem)}, + { 305, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect)}, + { 312, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKey)}, + { 318, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression)}, + { 324, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect)}, + { 333, -1, sizeof(::substrait::Expression_MaskExpression)}, + { 340, -1, sizeof(::substrait::Expression_FieldReference_RootReference)}, + { 345, -1, sizeof(::substrait::Expression_FieldReference)}, + { 356, -1, sizeof(::substrait::Expression)}, + { 372, -1, sizeof(::substrait::SortField)}, + { 381, -1, sizeof(::substrait::AggregateFunction)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::_Expression_Enum_Empty_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Enum_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Literal_VarChar_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Literal_Decimal_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Literal_Map_KeyValue_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Literal_Map_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Literal_Struct_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Literal_List_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Literal_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_ScalarFunction_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_Following_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_WindowFunction_Bound_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_WindowFunction_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_IfThen_IfClause_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_IfThen_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_Cast_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_SwitchExpression_IfValue_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_SwitchExpression_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_SingularOrList_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MultiOrList_Record_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MultiOrList_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_EmbeddedFunction_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_ReferenceSegment_MapKey_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_ReferenceSegment_StructField_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_ReferenceSegment_ListElement_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_ReferenceSegment_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_Select_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_StructSelect_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_StructItem_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_ListSelect_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_MapSelect_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_MaskExpression_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_FieldReference_RootReference_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_FieldReference_default_instance_), - reinterpret_cast(&::io::substrait::_Expression_default_instance_), - reinterpret_cast(&::io::substrait::_SortField_default_instance_), - reinterpret_cast(&::io::substrait::_AggregateFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_Enum_Empty_default_instance_), + reinterpret_cast(&::substrait::_Expression_Enum_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_VarChar_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_Decimal_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_Map_KeyValue_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_Map_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_Struct_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_List_default_instance_), + reinterpret_cast(&::substrait::_Expression_Literal_default_instance_), + reinterpret_cast(&::substrait::_Expression_ScalarFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_Following_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_default_instance_), + reinterpret_cast(&::substrait::_Expression_WindowFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_IfThen_IfClause_default_instance_), + reinterpret_cast(&::substrait::_Expression_IfThen_default_instance_), + reinterpret_cast(&::substrait::_Expression_Cast_default_instance_), + reinterpret_cast(&::substrait::_Expression_SwitchExpression_IfValue_default_instance_), + reinterpret_cast(&::substrait::_Expression_SwitchExpression_default_instance_), + reinterpret_cast(&::substrait::_Expression_SingularOrList_default_instance_), + reinterpret_cast(&::substrait::_Expression_MultiOrList_Record_default_instance_), + reinterpret_cast(&::substrait::_Expression_MultiOrList_default_instance_), + reinterpret_cast(&::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_EmbeddedFunction_default_instance_), + reinterpret_cast(&::substrait::_Expression_ReferenceSegment_MapKey_default_instance_), + reinterpret_cast(&::substrait::_Expression_ReferenceSegment_StructField_default_instance_), + reinterpret_cast(&::substrait::_Expression_ReferenceSegment_ListElement_default_instance_), + reinterpret_cast(&::substrait::_Expression_ReferenceSegment_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_Select_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_StructSelect_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_StructItem_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_MapSelect_default_instance_), + reinterpret_cast(&::substrait::_Expression_MaskExpression_default_instance_), + reinterpret_cast(&::substrait::_Expression_FieldReference_RootReference_default_instance_), + reinterpret_cast(&::substrait::_Expression_FieldReference_default_instance_), + reinterpret_cast(&::substrait::_Expression_default_instance_), + reinterpret_cast(&::substrait::_SortField_default_instance_), + reinterpret_cast(&::substrait::_AggregateFunction_default_instance_), }; -const char descriptor_table_protodef_expression_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\020expression.proto\022\014io.substrait\032\ntype.p" - "roto\"\2323\n\nExpression\0223\n\007literal\030\001 \001(\0132 .i" - "o.substrait.Expression.LiteralH\000\022<\n\tsele" - "ction\030\002 \001(\0132\'.io.substrait.Expression.Fi" - "eldReferenceH\000\022B\n\017scalar_function\030\003 \001(\0132" - "\'.io.substrait.Expression.ScalarFunction" - "H\000\022B\n\017window_function\030\005 \001(\0132\'.io.substra" - "it.Expression.WindowFunctionH\000\0222\n\007if_the" - "n\030\006 \001(\0132\037.io.substrait.Expression.IfThen" - "H\000\022F\n\021switch_expression\030\007 \001(\0132).io.subst" - "rait.Expression.SwitchExpressionH\000\022C\n\020si" - "ngular_or_list\030\010 \001(\0132\'.io.substrait.Expr" - "ession.SingularOrListH\000\022=\n\rmulti_or_list" - "\030\t \001(\0132$.io.substrait.Expression.MultiOr" - "ListH\000\022-\n\004enum\030\n \001(\0132\035.io.substrait.Expr" - "ession.EnumH\000\022-\n\004cast\030\013 \001(\0132\035.io.substra" - "it.Expression.CastH\000\032m\n\004Enum\022\023\n\tspecifie" - "d\030\001 \001(\tH\000\022:\n\013unspecified\030\002 \001(\0132#.io.subs" - "trait.Expression.Enum.EmptyH\000\032\007\n\005EmptyB\013" - "\n\tenum_kind\032\265\013\n\007Literal\022\021\n\007boolean\030\001 \001(\010" - "H\000\022\014\n\002i8\030\002 \001(\005H\000\022\r\n\003i16\030\003 \001(\005H\000\022\r\n\003i32\030\005" - " \001(\005H\000\022\r\n\003i64\030\007 \001(\003H\000\022\016\n\004fp32\030\n \001(\002H\000\022\016\n" - "\004fp64\030\013 \001(\001H\000\022\020\n\006string\030\014 \001(\tH\000\022\020\n\006binar" - "y\030\r \001(\014H\000\022\023\n\ttimestamp\030\016 \001(\003H\000\022\016\n\004date\030\020" - " \001(\003H\000\022\016\n\004time\030\021 \001(\003H\000\022V\n\026interval_year_" - "to_month\030\023 \001(\01324.io.substrait.Expression" - ".Literal.IntervalYearToMonthH\000\022V\n\026interv" - "al_day_to_second\030\024 \001(\01324.io.substrait.Ex" - "pression.Literal.IntervalDayToSecondH\000\022\024" - "\n\nfixed_char\030\025 \001(\tH\000\022<\n\010var_char\030\026 \001(\0132(" - ".io.substrait.Expression.Literal.VarChar" - "H\000\022\026\n\014fixed_binary\030\027 \001(\014H\000\022;\n\007decimal\030\030 " - "\001(\0132(.io.substrait.Expression.Literal.De" - "cimalH\000\0229\n\006struct\030\031 \001(\0132\'.io.substrait.E" - "xpression.Literal.StructH\000\0223\n\003map\030\032 \001(\0132" - "$.io.substrait.Expression.Literal.MapH\000\022" - "\026\n\014timestamp_tz\030\033 \001(\003H\000\022\016\n\004uuid\030\034 \001(\014H\000\022" - "\"\n\004null\030\035 \001(\0132\022.io.substrait.TypeH\000\0225\n\004l" - "ist\030\036 \001(\0132%.io.substrait.Expression.Lite" - "ral.ListH\000\022\020\n\010nullable\0302 \001(\010\032(\n\007VarChar\022" - "\r\n\005value\030\001 \001(\t\022\016\n\006length\030\002 \001(\r\032:\n\007Decima" - "l\022\r\n\005value\030\001 \001(\014\022\021\n\tprecision\030\002 \001(\005\022\r\n\005s" - "cale\030\003 \001(\005\032\202\002\n\003Map\022A\n\nkey_values\030\001 \003(\0132-" - ".io.substrait.Expression.Literal.Map.Key" - "Value\022$\n\010key_type\030\002 \001(\0132\022.io.substrait.T" - "ype\022&\n\nvalue_type\030\003 \001(\0132\022.io.substrait.T" - "ype\032j\n\010KeyValue\022-\n\003key\030\001 \001(\0132 .io.substr" - "ait.Expression.Literal\022/\n\005value\030\002 \001(\0132 ." - "io.substrait.Expression.Literal\0324\n\023Inter" - "valYearToMonth\022\r\n\005years\030\001 \001(\005\022\016\n\006months\030" - "\002 \001(\005\0324\n\023IntervalDayToSecond\022\014\n\004days\030\001 \001" - "(\005\022\017\n\007seconds\030\002 \001(\005\032:\n\006Struct\0220\n\006fields\030" - "\001 \003(\0132 .io.substrait.Expression.Literal\032" - "b\n\004List\0220\n\006values\030\001 \003(\0132 .io.substrait.E" - "xpression.Literal\022(\n\014element_type\030\002 \001(\0132" - "\022.io.substrait.TypeB\016\n\014literal_type\032}\n\016S" - "calarFunction\022\032\n\022function_reference\030\001 \001(" - "\r\022&\n\004args\030\002 \003(\0132\030.io.substrait.Expressio" - "n\022\'\n\013output_type\030\003 \001(\0132\022.io.substrait.Ty" - "pe\032\254\006\n\016WindowFunction\022\032\n\022function_refere" - "nce\030\001 \001(\r\022,\n\npartitions\030\002 \003(\0132\030.io.subst" - "rait.Expression\022&\n\005sorts\030\003 \003(\0132\027.io.subs" - "trait.SortField\022B\n\013upper_bound\030\004 \001(\0132-.i" - "o.substrait.Expression.WindowFunction.Bo" - "und\022B\n\013lower_bound\030\005 \001(\0132-.io.substrait." - "Expression.WindowFunction.Bound\022-\n\005phase" - "\030\006 \001(\0162\036.io.substrait.AggregationPhase\022\'" - "\n\013output_type\030\007 \001(\0132\022.io.substrait.Type\022" - "&\n\004args\030\010 \003(\0132\030.io.substrait.Expression\032" - "\237\003\n\005Bound\022L\n\tpreceding\030\001 \001(\01327.io.substr" - "ait.Expression.WindowFunction.Bound.Prec" - "edingH\000\022L\n\tfollowing\030\002 \001(\01327.io.substrai" - "t.Expression.WindowFunction.Bound.Follow" - "ingH\000\022O\n\013current_row\030\003 \001(\01328.io.substrai" - "t.Expression.WindowFunction.Bound.Curren" - "tRowH\000\022L\n\tunbounded\030\004 \001(\01327.io.substrait" - ".Expression.WindowFunction.Bound.Unbound" - "edH\000\032\033\n\tPreceding\022\016\n\006offset\030\001 \001(\003\032\033\n\tFol" - "lowing\022\016\n\006offset\030\001 \001(\003\032\014\n\nCurrentRow\032\013\n\t" - "UnboundedB\006\n\004kind\032\301\001\n\006IfThen\0225\n\003ifs\030\001 \003(" - "\0132(.io.substrait.Expression.IfThen.IfCla" - "use\022&\n\004else\030\002 \001(\0132\030.io.substrait.Express" - "ion\032X\n\010IfClause\022$\n\002if\030\001 \001(\0132\030.io.substra" - "it.Expression\022&\n\004then\030\002 \001(\0132\030.io.substra" - "it.Expression\032Q\n\004Cast\022 \n\004type\030\001 \001(\0132\022.io" - ".substrait.Type\022\'\n\005input\030\002 \001(\0132\030.io.subs" - "trait.Expression\032\333\001\n\020SwitchExpression\022>\n" - "\003ifs\030\001 \003(\01321.io.substrait.Expression.Swi" - "tchExpression.IfValue\022&\n\004else\030\002 \001(\0132\030.io" - ".substrait.Expression\032_\n\007IfValue\022,\n\002if\030\001" - " \001(\0132 .io.substrait.Expression.Literal\022&" - "\n\004then\030\002 \001(\0132\030.io.substrait.Expression\032d" - "\n\016SingularOrList\022\'\n\005value\030\001 \001(\0132\030.io.sub" - "strait.Expression\022)\n\007options\030\002 \003(\0132\030.io." - "substrait.Expression\032\250\001\n\013MultiOrList\022\'\n\005" - "value\030\001 \003(\0132\030.io.substrait.Expression\022<\n" - "\007options\030\002 \003(\0132+.io.substrait.Expression" - ".MultiOrList.Record\0322\n\006Record\022(\n\006fields\030" - "\001 \003(\0132\030.io.substrait.Expression\032\257\003\n\020Embe" - "ddedFunction\022+\n\targuments\030\001 \003(\0132\030.io.sub" - "strait.Expression\022\'\n\013output_type\030\002 \001(\0132\022" - ".io.substrait.Type\022`\n\026python_pickle_func" - "tion\030\003 \001(\0132>.io.substrait.Expression.Emb" - "eddedFunction.PythonPickleFunctionH\000\022^\n\025" - "web_assembly_function\030\004 \001(\0132=.io.substra" - "it.Expression.EmbeddedFunction.WebAssemb" - "lyFunctionH\000\032>\n\024PythonPickleFunction\022\020\n\010" - "function\030\001 \001(\014\022\024\n\014prerequisite\030\002 \003(\t\032;\n\023" - "WebAssemblyFunction\022\016\n\006script\030\001 \001(\014\022\024\n\014p" - "rerequisite\030\002 \003(\tB\006\n\004kind\032\257\004\n\020ReferenceS" - "egment\022C\n\007map_key\030\001 \001(\01320.io.substrait.E" - "xpression.ReferenceSegment.MapKeyH\000\022M\n\014s" - "truct_field\030\002 \001(\01325.io.substrait.Express" - "ion.ReferenceSegment.StructFieldH\000\022M\n\014li" - "st_element\030\003 \001(\01325.io.substrait.Expressi" - "on.ReferenceSegment.ListElementH\000\032u\n\006Map" - "Key\0221\n\007map_key\030\001 \001(\0132 .io.substrait.Expr" - "ession.Literal\0228\n\005child\030\002 \001(\0132).io.subst" - "rait.Expression.ReferenceSegment\032V\n\013Stru" - "ctField\022\r\n\005field\030\001 \001(\005\0228\n\005child\030\002 \001(\0132)." - "io.substrait.Expression.ReferenceSegment" - "\032W\n\013ListElement\022\016\n\006offset\030\001 \001(\005\0228\n\005child" - "\030\002 \001(\0132).io.substrait.Expression.Referen" - "ceSegmentB\020\n\016reference_type\032\227\n\n\016MaskExpr" - "ession\022D\n\006select\030\001 \001(\01324.io.substrait.Ex" - "pression.MaskExpression.StructSelect\022 \n\030" - "maintain_singular_struct\030\002 \001(\010\032\336\001\n\006Selec" - "t\022F\n\006struct\030\001 \001(\01324.io.substrait.Express" - "ion.MaskExpression.StructSelectH\000\022B\n\004lis" - "t\030\002 \001(\01322.io.substrait.Expression.MaskEx" - "pression.ListSelectH\000\022@\n\003map\030\003 \001(\01321.io." - "substrait.Expression.MaskExpression.MapS" - "electH\000B\006\n\004type\032X\n\014StructSelect\022H\n\014struc" - "t_items\030\001 \003(\01322.io.substrait.Expression." - "MaskExpression.StructItem\032Z\n\nStructItem\022" - "\r\n\005field\030\001 \001(\005\022=\n\005child\030\002 \001(\0132..io.subst" - "rait.Expression.MaskExpression.Select\032\300\003" - "\n\nListSelect\022T\n\tselection\030\001 \003(\0132A.io.sub" - "strait.Expression.MaskExpression.ListSel" - "ect.ListSelectItem\022=\n\005child\030\002 \001(\0132..io.s" - "ubstrait.Expression.MaskExpression.Selec" - "t\032\234\002\n\016ListSelectItem\022]\n\004item\030\001 \001(\0132M.io." - "substrait.Expression.MaskExpression.List" - "Select.ListSelectItem.ListElementH\000\022\\\n\005s" - "lice\030\002 \001(\0132K.io.substrait.Expression.Mas" - "kExpression.ListSelect.ListSelectItem.Li" - "stSliceH\000\032\034\n\013ListElement\022\r\n\005field\030\001 \001(\005\032" - "\'\n\tListSlice\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002 \001(\005" - "B\006\n\004type\032\302\002\n\tMapSelect\022G\n\003key\030\001 \001(\01328.io" - ".substrait.Expression.MaskExpression.Map" - "Select.MapKeyH\000\022X\n\nexpression\030\002 \001(\0132B.io" - ".substrait.Expression.MaskExpression.Map" - "Select.MapKeyExpressionH\000\022=\n\005child\030\003 \001(\013" - "2..io.substrait.Expression.MaskExpressio" - "n.Select\032\031\n\006MapKey\022\017\n\007map_key\030\001 \001(\t\032.\n\020M" - "apKeyExpression\022\032\n\022map_key_expression\030\001 " - "\001(\tB\010\n\006select\032\315\002\n\016FieldReference\022E\n\020dire" - "ct_reference\030\001 \001(\0132).io.substrait.Expres" - "sion.ReferenceSegmentH\000\022C\n\020masked_refere" - "nce\030\002 \001(\0132\'.io.substrait.Expression.Mask" - "ExpressionH\000\022.\n\nexpression\030\003 \001(\0132\030.io.su" - "bstrait.ExpressionH\001\022O\n\016root_reference\030\004" - " \001(\01325.io.substrait.Expression.FieldRefe" - "rence.RootReferenceH\001\032\017\n\rRootReferenceB\020" - "\n\016reference_typeB\013\n\troot_typeB\n\n\010rex_typ" - "e\"\246\002\n\tSortField\022&\n\004expr\030\001 \001(\0132\030.io.subst" - "rait.Expression\022:\n\tdirection\030\002 \001(\0162%.io." - "substrait.SortField.SortDirectionH\000\022\'\n\035c" - "omparison_function_reference\030\003 \001(\rH\000\"\177\n\r" - "SortDirection\022\013\n\007UNKNOWN\020\000\022\023\n\017ASC_NULLS_" - "FIRST\020\001\022\022\n\016ASC_NULLS_LAST\020\002\022\024\n\020DESC_NULL" - "S_FIRST\020\003\022\023\n\017DESC_NULLS_LAST\020\004\022\r\n\tCLUSTE" - "RED\020\005B\013\n\tsort_kind\"\327\001\n\021AggregateFunction" - "\022\032\n\022function_reference\030\001 \001(\r\022&\n\004args\030\002 \003" - "(\0132\030.io.substrait.Expression\022&\n\005sorts\030\003 " - "\003(\0132\027.io.substrait.SortField\022-\n\005phase\030\004 " - "\001(\0162\036.io.substrait.AggregationPhase\022\'\n\013o" - "utput_type\030\005 \001(\0132\022.io.substrait.Type*\221\001\n" - "\020AggregationPhase\022\013\n\007UNKNOWN\020\000\022\033\n\027INITIA" - "L_TO_INTERMEDIATE\020\001\022 \n\034INTERMEDIATE_TO_I" - "NTERMEDIATE\020\002\022\025\n\021INITIAL_TO_RESULT\020\003\022\032\n\026" - "INTERMEDIATE_TO_RESULT\020\004B+\n\022io.substrait" - ".protoP\001\252\002\022Substrait.Protobufb\006proto3" +const char descriptor_table_protodef_substrait_2fexpression_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\032substrait/expression.proto\022\tsubstrait\032" + "\024substrait/type.proto\"\2101\n\nExpression\0220\n\007" + "literal\030\001 \001(\0132\035.substrait.Expression.Lit" + "eralH\000\0229\n\tselection\030\002 \001(\0132$.substrait.Ex" + "pression.FieldReferenceH\000\022\?\n\017scalar_func" + "tion\030\003 \001(\0132$.substrait.Expression.Scalar" + "FunctionH\000\022\?\n\017window_function\030\005 \001(\0132$.su" + "bstrait.Expression.WindowFunctionH\000\022/\n\007i" + "f_then\030\006 \001(\0132\034.substrait.Expression.IfTh" + "enH\000\022C\n\021switch_expression\030\007 \001(\0132&.substr" + "ait.Expression.SwitchExpressionH\000\022@\n\020sin" + "gular_or_list\030\010 \001(\0132$.substrait.Expressi" + "on.SingularOrListH\000\022:\n\rmulti_or_list\030\t \001" + "(\0132!.substrait.Expression.MultiOrListH\000\022" + "*\n\004enum\030\n \001(\0132\032.substrait.Expression.Enu" + "mH\000\022*\n\004cast\030\013 \001(\0132\032.substrait.Expression" + ".CastH\000\032j\n\004Enum\022\023\n\tspecified\030\001 \001(\tH\000\0227\n\013" + "unspecified\030\002 \001(\0132 .substrait.Expression" + ".Enum.EmptyH\000\032\007\n\005EmptyB\013\n\tenum_kind\032\354\n\n\007" + "Literal\022\021\n\007boolean\030\001 \001(\010H\000\022\014\n\002i8\030\002 \001(\005H\000" + "\022\r\n\003i16\030\003 \001(\005H\000\022\r\n\003i32\030\005 \001(\005H\000\022\r\n\003i64\030\007 " + "\001(\003H\000\022\016\n\004fp32\030\n \001(\002H\000\022\016\n\004fp64\030\013 \001(\001H\000\022\020\n" + "\006string\030\014 \001(\tH\000\022\020\n\006binary\030\r \001(\014H\000\022\023\n\ttim" + "estamp\030\016 \001(\003H\000\022\016\n\004date\030\020 \001(\005H\000\022\016\n\004time\030\021" + " \001(\003H\000\022S\n\026interval_year_to_month\030\023 \001(\01321" + ".substrait.Expression.Literal.IntervalYe" + "arToMonthH\000\022S\n\026interval_day_to_second\030\024 " + "\001(\01321.substrait.Expression.Literal.Inter" + "valDayToSecondH\000\022\024\n\nfixed_char\030\025 \001(\tH\000\0229" + "\n\010var_char\030\026 \001(\0132%.substrait.Expression." + "Literal.VarCharH\000\022\026\n\014fixed_binary\030\027 \001(\014H" + "\000\0228\n\007decimal\030\030 \001(\0132%.substrait.Expressio" + "n.Literal.DecimalH\000\0226\n\006struct\030\031 \001(\0132$.su" + "bstrait.Expression.Literal.StructH\000\0220\n\003m" + "ap\030\032 \001(\0132!.substrait.Expression.Literal." + "MapH\000\022\026\n\014timestamp_tz\030\033 \001(\003H\000\022\016\n\004uuid\030\034 " + "\001(\014H\000\022\037\n\004null\030\035 \001(\0132\017.substrait.TypeH\000\0222" + "\n\004list\030\036 \001(\0132\".substrait.Expression.Lite" + "ral.ListH\000\022*\n\nempty_list\030\037 \001(\0132\024.substra" + "it.Type.ListH\000\022(\n\tempty_map\030 \001(\0132\023.subs" + "trait.Type.MapH\000\022\020\n\010nullable\0302 \001(\010\032(\n\007Va" + "rChar\022\r\n\005value\030\001 \001(\t\022\016\n\006length\030\002 \001(\r\032:\n\007" + "Decimal\022\r\n\005value\030\001 \001(\014\022\021\n\tprecision\030\002 \001(" + "\005\022\r\n\005scale\030\003 \001(\005\032\253\001\n\003Map\022>\n\nkey_values\030\001" + " \003(\0132*.substrait.Expression.Literal.Map." + "KeyValue\032d\n\010KeyValue\022*\n\003key\030\001 \001(\0132\035.subs" + "trait.Expression.Literal\022,\n\005value\030\002 \001(\0132" + "\035.substrait.Expression.Literal\0324\n\023Interv" + "alYearToMonth\022\r\n\005years\030\001 \001(\005\022\016\n\006months\030\002" + " \001(\005\0324\n\023IntervalDayToSecond\022\014\n\004days\030\001 \001(" + "\005\022\017\n\007seconds\030\002 \001(\005\0327\n\006Struct\022-\n\006fields\030\001" + " \003(\0132\035.substrait.Expression.Literal\0325\n\004L" + "ist\022-\n\006values\030\001 \003(\0132\035.substrait.Expressi" + "on.LiteralB\016\n\014literal_type\032w\n\016ScalarFunc" + "tion\022\032\n\022function_reference\030\001 \001(\r\022#\n\004args" + "\030\002 \003(\0132\025.substrait.Expression\022$\n\013output_" + "type\030\003 \001(\0132\017.substrait.Type\032\213\006\n\016WindowFu" + "nction\022\032\n\022function_reference\030\001 \001(\r\022)\n\npa" + "rtitions\030\002 \003(\0132\025.substrait.Expression\022#\n" + "\005sorts\030\003 \003(\0132\024.substrait.SortField\022\?\n\013up" + "per_bound\030\004 \001(\0132*.substrait.Expression.W" + "indowFunction.Bound\022\?\n\013lower_bound\030\005 \001(\013" + "2*.substrait.Expression.WindowFunction.B" + "ound\022*\n\005phase\030\006 \001(\0162\033.substrait.Aggregat" + "ionPhase\022$\n\013output_type\030\007 \001(\0132\017.substrai" + "t.Type\022#\n\004args\030\010 \003(\0132\025.substrait.Express" + "ion\032\223\003\n\005Bound\022I\n\tpreceding\030\001 \001(\01324.subst" + "rait.Expression.WindowFunction.Bound.Pre" + "cedingH\000\022I\n\tfollowing\030\002 \001(\01324.substrait." + "Expression.WindowFunction.Bound.Followin" + "gH\000\022L\n\013current_row\030\003 \001(\01325.substrait.Exp" + "ression.WindowFunction.Bound.CurrentRowH" + "\000\022I\n\tunbounded\030\004 \001(\01324.substrait.Express" + "ion.WindowFunction.Bound.UnboundedH\000\032\033\n\t" + "Preceding\022\016\n\006offset\030\001 \001(\003\032\033\n\tFollowing\022\016" + "\n\006offset\030\001 \001(\003\032\014\n\nCurrentRow\032\013\n\tUnbounde" + "dB\006\n\004kind\032\265\001\n\006IfThen\0222\n\003ifs\030\001 \003(\0132%.subs" + "trait.Expression.IfThen.IfClause\022#\n\004else" + "\030\002 \001(\0132\025.substrait.Expression\032R\n\010IfClaus" + "e\022!\n\002if\030\001 \001(\0132\025.substrait.Expression\022#\n\004" + "then\030\002 \001(\0132\025.substrait.Expression\032K\n\004Cas" + "t\022\035\n\004type\030\001 \001(\0132\017.substrait.Type\022$\n\005inpu" + "t\030\002 \001(\0132\025.substrait.Expression\032\317\001\n\020Switc" + "hExpression\022;\n\003ifs\030\001 \003(\0132..substrait.Exp" + "ression.SwitchExpression.IfValue\022#\n\004else" + "\030\002 \001(\0132\025.substrait.Expression\032Y\n\007IfValue" + "\022)\n\002if\030\001 \001(\0132\035.substrait.Expression.Lite" + "ral\022#\n\004then\030\002 \001(\0132\025.substrait.Expression" + "\032^\n\016SingularOrList\022$\n\005value\030\001 \001(\0132\025.subs" + "trait.Expression\022&\n\007options\030\002 \003(\0132\025.subs" + "trait.Expression\032\237\001\n\013MultiOrList\022$\n\005valu" + "e\030\001 \003(\0132\025.substrait.Expression\0229\n\007option" + "s\030\002 \003(\0132(.substrait.Expression.MultiOrLi" + "st.Record\032/\n\006Record\022%\n\006fields\030\001 \003(\0132\025.su" + "bstrait.Expression\032\243\003\n\020EmbeddedFunction\022" + "(\n\targuments\030\001 \003(\0132\025.substrait.Expressio" + "n\022$\n\013output_type\030\002 \001(\0132\017.substrait.Type\022" + "]\n\026python_pickle_function\030\003 \001(\0132;.substr" + "ait.Expression.EmbeddedFunction.PythonPi" + "ckleFunctionH\000\022[\n\025web_assembly_function\030" + "\004 \001(\0132:.substrait.Expression.EmbeddedFun" + "ction.WebAssemblyFunctionH\000\032>\n\024PythonPic" + "kleFunction\022\020\n\010function\030\001 \001(\014\022\024\n\014prerequ" + "isite\030\002 \003(\t\032;\n\023WebAssemblyFunction\022\016\n\006sc" + "ript\030\001 \001(\014\022\024\n\014prerequisite\030\002 \003(\tB\006\n\004kind" + "\032\232\004\n\020ReferenceSegment\022@\n\007map_key\030\001 \001(\0132-" + ".substrait.Expression.ReferenceSegment.M" + "apKeyH\000\022J\n\014struct_field\030\002 \001(\01322.substrai" + "t.Expression.ReferenceSegment.StructFiel" + "dH\000\022J\n\014list_element\030\003 \001(\01322.substrait.Ex" + "pression.ReferenceSegment.ListElementH\000\032" + "o\n\006MapKey\022.\n\007map_key\030\001 \001(\0132\035.substrait.E" + "xpression.Literal\0225\n\005child\030\002 \001(\0132&.subst" + "rait.Expression.ReferenceSegment\032S\n\013Stru" + "ctField\022\r\n\005field\030\001 \001(\005\0225\n\005child\030\002 \001(\0132&." + "substrait.Expression.ReferenceSegment\032T\n" + "\013ListElement\022\016\n\006offset\030\001 \001(\005\0225\n\005child\030\002 " + "\001(\0132&.substrait.Expression.ReferenceSegm" + "entB\020\n\016reference_type\032\360\t\n\016MaskExpression" + "\022A\n\006select\030\001 \001(\01321.substrait.Expression." + "MaskExpression.StructSelect\022 \n\030maintain_" + "singular_struct\030\002 \001(\010\032\325\001\n\006Select\022C\n\006stru" + "ct\030\001 \001(\01321.substrait.Expression.MaskExpr" + "ession.StructSelectH\000\022\?\n\004list\030\002 \001(\0132/.su" + "bstrait.Expression.MaskExpression.ListSe" + "lectH\000\022=\n\003map\030\003 \001(\0132..substrait.Expressi" + "on.MaskExpression.MapSelectH\000B\006\n\004type\032U\n" + "\014StructSelect\022E\n\014struct_items\030\001 \003(\0132/.su" + "bstrait.Expression.MaskExpression.Struct" + "Item\032W\n\nStructItem\022\r\n\005field\030\001 \001(\005\022:\n\005chi" + "ld\030\002 \001(\0132+.substrait.Expression.MaskExpr" + "ession.Select\032\264\003\n\nListSelect\022Q\n\tselectio" + "n\030\001 \003(\0132>.substrait.Expression.MaskExpre" + "ssion.ListSelect.ListSelectItem\022:\n\005child" + "\030\002 \001(\0132+.substrait.Expression.MaskExpres" + "sion.Select\032\226\002\n\016ListSelectItem\022Z\n\004item\030\001" + " \001(\0132J.substrait.Expression.MaskExpressi" + "on.ListSelect.ListSelectItem.ListElement" + "H\000\022Y\n\005slice\030\002 \001(\0132H.substrait.Expression" + ".MaskExpression.ListSelect.ListSelectIte" + "m.ListSliceH\000\032\034\n\013ListElement\022\r\n\005field\030\001 " + "\001(\005\032\'\n\tListSlice\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002" + " \001(\005B\006\n\004type\032\271\002\n\tMapSelect\022D\n\003key\030\001 \001(\0132" + "5.substrait.Expression.MaskExpression.Ma" + "pSelect.MapKeyH\000\022U\n\nexpression\030\002 \001(\0132\?.s" + "ubstrait.Expression.MaskExpression.MapSe" + "lect.MapKeyExpressionH\000\022:\n\005child\030\003 \001(\0132+" + ".substrait.Expression.MaskExpression.Sel" + "ect\032\031\n\006MapKey\022\017\n\007map_key\030\001 \001(\t\032.\n\020MapKey" + "Expression\022\032\n\022map_key_expression\030\001 \001(\tB\010" + "\n\006select\032\301\002\n\016FieldReference\022B\n\020direct_re" + "ference\030\001 \001(\0132&.substrait.Expression.Ref" + "erenceSegmentH\000\022@\n\020masked_reference\030\002 \001(" + "\0132$.substrait.Expression.MaskExpressionH" + "\000\022+\n\nexpression\030\003 \001(\0132\025.substrait.Expres" + "sionH\001\022L\n\016root_reference\030\004 \001(\01322.substra" + "it.Expression.FieldReference.RootReferen" + "ceH\001\032\017\n\rRootReferenceB\020\n\016reference_typeB" + "\013\n\troot_typeB\n\n\010rex_type\"\377\002\n\tSortField\022#" + "\n\004expr\030\001 \001(\0132\025.substrait.Expression\0227\n\td" + "irection\030\002 \001(\0162\".substrait.SortField.Sor" + "tDirectionH\000\022\'\n\035comparison_function_refe" + "rence\030\003 \001(\rH\000\"\335\001\n\rSortDirection\022\036\n\032SORT_" + "DIRECTION_UNSPECIFIED\020\000\022\"\n\036SORT_DIRECTIO" + "N_ASC_NULLS_FIRST\020\001\022!\n\035SORT_DIRECTION_AS" + "C_NULLS_LAST\020\002\022#\n\037SORT_DIRECTION_DESC_NU" + "LLS_FIRST\020\003\022\"\n\036SORT_DIRECTION_DESC_NULLS" + "_LAST\020\004\022\034\n\030SORT_DIRECTION_CLUSTERED\020\005B\013\n" + "\tsort_kind\"\313\001\n\021AggregateFunction\022\032\n\022func" + "tion_reference\030\001 \001(\r\022#\n\004args\030\002 \003(\0132\025.sub" + "strait.Expression\022#\n\005sorts\030\003 \003(\0132\024.subst" + "rait.SortField\022*\n\005phase\030\004 \001(\0162\033.substrai" + "t.AggregationPhase\022$\n\013output_type\030\005 \001(\0132" + "\017.substrait.Type*\357\001\n\020AggregationPhase\022!\n" + "\035AGGREGATION_PHASE_UNSPECIFIED\020\000\022-\n)AGGR" + "EGATION_PHASE_INITIAL_TO_INTERMEDIATE\020\001\022" + "2\n.AGGREGATION_PHASE_INTERMEDIATE_TO_INT" + "ERMEDIATE\020\002\022\'\n#AGGREGATION_PHASE_INITIAL" + "_TO_RESULT\020\003\022,\n(AGGREGATION_PHASE_INTERM" + "EDIATE_TO_RESULT\020\004B+\n\022io.substrait.proto" + "P\001\252\002\022Substrait.Protobufb\006proto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_expression_2eproto_deps[1] = { - &::descriptor_table_type_2eproto, +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fexpression_2eproto_deps[1] = { + &::descriptor_table_substrait_2ftype_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_expression_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_expression_2eproto = { - false, false, 7317, descriptor_table_protodef_expression_2eproto, "expression.proto", - &descriptor_table_expression_2eproto_once, descriptor_table_expression_2eproto_deps, 1, 49, - schemas, file_default_instances, TableStruct_expression_2eproto::offsets, - file_level_metadata_expression_2eproto, file_level_enum_descriptors_expression_2eproto, file_level_service_descriptors_expression_2eproto, +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fexpression_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fexpression_2eproto = { + false, false, 7231, descriptor_table_protodef_substrait_2fexpression_2eproto, "substrait/expression.proto", + &descriptor_table_substrait_2fexpression_2eproto_once, descriptor_table_substrait_2fexpression_2eproto_deps, 1, 49, + schemas, file_default_instances, TableStruct_substrait_2fexpression_2eproto::offsets, + file_level_metadata_substrait_2fexpression_2eproto, file_level_enum_descriptors_substrait_2fexpression_2eproto, file_level_service_descriptors_substrait_2fexpression_2eproto, }; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_expression_2eproto_getter() { - return &descriptor_table_expression_2eproto; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fexpression_2eproto_getter() { + return &descriptor_table_substrait_2fexpression_2eproto; } // Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_expression_2eproto(&descriptor_table_expression_2eproto); -namespace io { +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fexpression_2eproto(&descriptor_table_substrait_2fexpression_2eproto); namespace substrait { const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortField_SortDirection_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_expression_2eproto); - return file_level_enum_descriptors_expression_2eproto[0]; + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2fexpression_2eproto); + return file_level_enum_descriptors_substrait_2fexpression_2eproto[0]; } bool SortField_SortDirection_IsValid(int value) { switch (value) { @@ -1373,19 +1364,19 @@ bool SortField_SortDirection_IsValid(int value) { } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr SortField_SortDirection SortField::UNKNOWN; -constexpr SortField_SortDirection SortField::ASC_NULLS_FIRST; -constexpr SortField_SortDirection SortField::ASC_NULLS_LAST; -constexpr SortField_SortDirection SortField::DESC_NULLS_FIRST; -constexpr SortField_SortDirection SortField::DESC_NULLS_LAST; -constexpr SortField_SortDirection SortField::CLUSTERED; +constexpr SortField_SortDirection SortField::SORT_DIRECTION_UNSPECIFIED; +constexpr SortField_SortDirection SortField::SORT_DIRECTION_ASC_NULLS_FIRST; +constexpr SortField_SortDirection SortField::SORT_DIRECTION_ASC_NULLS_LAST; +constexpr SortField_SortDirection SortField::SORT_DIRECTION_DESC_NULLS_FIRST; +constexpr SortField_SortDirection SortField::SORT_DIRECTION_DESC_NULLS_LAST; +constexpr SortField_SortDirection SortField::SORT_DIRECTION_CLUSTERED; constexpr SortField_SortDirection SortField::SortDirection_MIN; constexpr SortField_SortDirection SortField::SortDirection_MAX; constexpr int SortField::SortDirection_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggregationPhase_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_expression_2eproto); - return file_level_enum_descriptors_expression_2eproto[1]; + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2fexpression_2eproto); + return file_level_enum_descriptors_substrait_2fexpression_2eproto[1]; } bool AggregationPhase_IsValid(int value) { switch (value) { @@ -1411,19 +1402,19 @@ Expression_Enum_Empty::Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* are : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Enum.Empty) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Enum.Empty) } Expression_Enum_Empty::Expression_Enum_Empty(const Expression_Enum_Empty& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Enum.Empty) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Enum.Empty) } void Expression_Enum_Empty::SharedCtor() { } Expression_Enum_Empty::~Expression_Enum_Empty() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Enum.Empty) + // @@protoc_insertion_point(destructor:substrait.Expression.Enum.Empty) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1443,7 +1434,7 @@ void Expression_Enum_Empty::SetCachedSize(int size) const { } void Expression_Enum_Empty::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Enum.Empty) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Enum.Empty) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1477,7 +1468,7 @@ const char* Expression_Enum_Empty::_InternalParse(const char* ptr, ::PROTOBUF_NA ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Enum_Empty::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Enum.Empty) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Enum.Empty) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1485,12 +1476,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Enum_Empty::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Enum.Empty) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Enum.Empty) return target; } size_t Expression_Enum_Empty::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Enum.Empty) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Enum.Empty) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1507,22 +1498,22 @@ size_t Expression_Enum_Empty::ByteSizeLong() const { } void Expression_Enum_Empty::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Enum.Empty) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Enum.Empty) GOOGLE_DCHECK_NE(&from, this); const Expression_Enum_Empty* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Enum.Empty) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Enum.Empty) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Enum.Empty) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Enum.Empty) MergeFrom(*source); } } void Expression_Enum_Empty::MergeFrom(const Expression_Enum_Empty& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Enum.Empty) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Enum.Empty) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1531,14 +1522,14 @@ void Expression_Enum_Empty::MergeFrom(const Expression_Enum_Empty& from) { } void Expression_Enum_Empty::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Enum.Empty) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Enum.Empty) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Enum_Empty::CopyFrom(const Expression_Enum_Empty& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Enum.Empty) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Enum.Empty) if (&from == this) return; Clear(); MergeFrom(from); @@ -1555,22 +1546,22 @@ void Expression_Enum_Empty::InternalSwap(Expression_Enum_Empty* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum_Empty::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[0]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[0]); } // =================================================================== class Expression_Enum::_Internal { public: - static const ::io::substrait::Expression_Enum_Empty& unspecified(const Expression_Enum* msg); + static const ::substrait::Expression_Enum_Empty& unspecified(const Expression_Enum* msg); }; -const ::io::substrait::Expression_Enum_Empty& +const ::substrait::Expression_Enum_Empty& Expression_Enum::_Internal::unspecified(const Expression_Enum* msg) { return *msg->enum_kind_.unspecified_; } -void Expression_Enum::set_allocated_unspecified(::io::substrait::Expression_Enum_Empty* unspecified) { +void Expression_Enum::set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_enum_kind(); if (unspecified) { @@ -1583,13 +1574,13 @@ void Expression_Enum::set_allocated_unspecified(::io::substrait::Expression_Enum set_has_unspecified(); enum_kind_.unspecified_ = unspecified; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Enum.unspecified) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Enum.unspecified) } Expression_Enum::Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Enum) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Enum) } Expression_Enum::Expression_Enum(const Expression_Enum& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -1601,14 +1592,14 @@ Expression_Enum::Expression_Enum(const Expression_Enum& from) break; } case kUnspecified: { - _internal_mutable_unspecified()->::io::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified()); + _internal_mutable_unspecified()->::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified()); break; } case ENUM_KIND_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Enum) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Enum) } void Expression_Enum::SharedCtor() { @@ -1616,7 +1607,7 @@ clear_has_enum_kind(); } Expression_Enum::~Expression_Enum() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Enum) + // @@protoc_insertion_point(destructor:substrait.Expression.Enum) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1639,7 +1630,7 @@ void Expression_Enum::SetCachedSize(int size) const { } void Expression_Enum::clear_enum_kind() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.Enum) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.Enum) switch (enum_kind_case()) { case kSpecified: { enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); @@ -1660,7 +1651,7 @@ void Expression_Enum::clear_enum_kind() { void Expression_Enum::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Enum) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Enum) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1680,11 +1671,11 @@ const char* Expression_Enum::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPAC if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_specified(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Enum.specified")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Enum.specified")); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Enum.Empty unspecified = 2; + // .substrait.Expression.Enum.Empty unspecified = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_unspecified(), ptr); @@ -1716,7 +1707,7 @@ const char* Expression_Enum::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPAC ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Enum::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Enum) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Enum) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1725,12 +1716,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Enum::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_specified().data(), static_cast(this->_internal_specified().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.Enum.specified"); + "substrait.Expression.Enum.specified"); target = stream->WriteStringMaybeAliased( 1, this->_internal_specified(), target); } - // .io.substrait.Expression.Enum.Empty unspecified = 2; + // .substrait.Expression.Enum.Empty unspecified = 2; if (_internal_has_unspecified()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1742,12 +1733,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Enum::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Enum) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Enum) return target; } size_t Expression_Enum::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Enum) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Enum) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1762,7 +1753,7 @@ size_t Expression_Enum::ByteSizeLong() const { this->_internal_specified()); break; } - // .io.substrait.Expression.Enum.Empty unspecified = 2; + // .substrait.Expression.Enum.Empty unspecified = 2; case kUnspecified: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1783,22 +1774,22 @@ size_t Expression_Enum::ByteSizeLong() const { } void Expression_Enum::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Enum) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Enum) GOOGLE_DCHECK_NE(&from, this); const Expression_Enum* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Enum) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Enum) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Enum) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Enum) MergeFrom(*source); } } void Expression_Enum::MergeFrom(const Expression_Enum& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Enum) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Enum) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1810,7 +1801,7 @@ void Expression_Enum::MergeFrom(const Expression_Enum& from) { break; } case kUnspecified: { - _internal_mutable_unspecified()->::io::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified()); + _internal_mutable_unspecified()->::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified()); break; } case ENUM_KIND_NOT_SET: { @@ -1820,14 +1811,14 @@ void Expression_Enum::MergeFrom(const Expression_Enum& from) { } void Expression_Enum::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Enum) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Enum) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Enum::CopyFrom(const Expression_Enum& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Enum) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Enum) if (&from == this) return; Clear(); MergeFrom(from); @@ -1846,8 +1837,8 @@ void Expression_Enum::InternalSwap(Expression_Enum* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[1]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[1]); } // =================================================================== @@ -1860,7 +1851,7 @@ Expression_Literal_VarChar::Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID:: : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.VarChar) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.VarChar) } Expression_Literal_VarChar::Expression_Literal_VarChar(const Expression_Literal_VarChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -1871,7 +1862,7 @@ Expression_Literal_VarChar::Expression_Literal_VarChar(const Expression_Literal_ GetArena()); } length_ = from.length_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.VarChar) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.VarChar) } void Expression_Literal_VarChar::SharedCtor() { @@ -1880,7 +1871,7 @@ length_ = 0u; } Expression_Literal_VarChar::~Expression_Literal_VarChar() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.VarChar) + // @@protoc_insertion_point(destructor:substrait.Expression.Literal.VarChar) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1901,7 +1892,7 @@ void Expression_Literal_VarChar::SetCachedSize(int size) const { } void Expression_Literal_VarChar::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.VarChar) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.VarChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1922,7 +1913,7 @@ const char* Expression_Literal_VarChar::_InternalParse(const char* ptr, ::PROTOB if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_value(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.VarChar.value")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.VarChar.value")); CHK_(ptr); } else goto handle_unusual; continue; @@ -1958,7 +1949,7 @@ const char* Expression_Literal_VarChar::_InternalParse(const char* ptr, ::PROTOB ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_VarChar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.VarChar) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.VarChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1967,7 +1958,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_VarChar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_value().data(), static_cast(this->_internal_value().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.Literal.VarChar.value"); + "substrait.Expression.Literal.VarChar.value"); target = stream->WriteStringMaybeAliased( 1, this->_internal_value(), target); } @@ -1982,12 +1973,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_VarChar::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.VarChar) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.VarChar) return target; } size_t Expression_Literal_VarChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.VarChar) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.VarChar) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2018,22 +2009,22 @@ size_t Expression_Literal_VarChar::ByteSizeLong() const { } void Expression_Literal_VarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.VarChar) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.VarChar) GOOGLE_DCHECK_NE(&from, this); const Expression_Literal_VarChar* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.VarChar) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.VarChar) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.VarChar) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.VarChar) MergeFrom(*source); } } void Expression_Literal_VarChar::MergeFrom(const Expression_Literal_VarChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.VarChar) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.VarChar) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2048,14 +2039,14 @@ void Expression_Literal_VarChar::MergeFrom(const Expression_Literal_VarChar& fro } void Expression_Literal_VarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.VarChar) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.VarChar) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Literal_VarChar::CopyFrom(const Expression_Literal_VarChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.VarChar) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.VarChar) if (&from == this) return; Clear(); MergeFrom(from); @@ -2074,8 +2065,8 @@ void Expression_Literal_VarChar::InternalSwap(Expression_Literal_VarChar* other) ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_VarChar::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[2]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[2]); } // =================================================================== @@ -2088,7 +2079,7 @@ Expression_Literal_Decimal::Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID:: : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Decimal) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Decimal) } Expression_Literal_Decimal::Expression_Literal_Decimal(const Expression_Literal_Decimal& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -2101,7 +2092,7 @@ Expression_Literal_Decimal::Expression_Literal_Decimal(const Expression_Literal_ ::memcpy(&precision_, &from.precision_, static_cast(reinterpret_cast(&scale_) - reinterpret_cast(&precision_)) + sizeof(scale_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Decimal) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Decimal) } void Expression_Literal_Decimal::SharedCtor() { @@ -2113,7 +2104,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_Literal_Decimal::~Expression_Literal_Decimal() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Decimal) + // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Decimal) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2134,7 +2125,7 @@ void Expression_Literal_Decimal::SetCachedSize(int size) const { } void Expression_Literal_Decimal::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Decimal) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Decimal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2199,7 +2190,7 @@ const char* Expression_Literal_Decimal::_InternalParse(const char* ptr, ::PROTOB ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Decimal::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Decimal) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Decimal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2225,12 +2216,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Decimal::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Decimal) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Decimal) return target; } size_t Expression_Literal_Decimal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Decimal) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Decimal) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2268,22 +2259,22 @@ size_t Expression_Literal_Decimal::ByteSizeLong() const { } void Expression_Literal_Decimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Decimal) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.Decimal) GOOGLE_DCHECK_NE(&from, this); const Expression_Literal_Decimal* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Decimal) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.Decimal) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Decimal) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.Decimal) MergeFrom(*source); } } void Expression_Literal_Decimal::MergeFrom(const Expression_Literal_Decimal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Decimal) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Decimal) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2301,14 +2292,14 @@ void Expression_Literal_Decimal::MergeFrom(const Expression_Literal_Decimal& fro } void Expression_Literal_Decimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Decimal) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.Decimal) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Literal_Decimal::CopyFrom(const Expression_Literal_Decimal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Decimal) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Decimal) if (&from == this) return; Clear(); MergeFrom(from); @@ -2332,23 +2323,23 @@ void Expression_Literal_Decimal::InternalSwap(Expression_Literal_Decimal* other) ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Decimal::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[3]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[3]); } // =================================================================== class Expression_Literal_Map_KeyValue::_Internal { public: - static const ::io::substrait::Expression_Literal& key(const Expression_Literal_Map_KeyValue* msg); - static const ::io::substrait::Expression_Literal& value(const Expression_Literal_Map_KeyValue* msg); + static const ::substrait::Expression_Literal& key(const Expression_Literal_Map_KeyValue* msg); + static const ::substrait::Expression_Literal& value(const Expression_Literal_Map_KeyValue* msg); }; -const ::io::substrait::Expression_Literal& +const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_Internal::key(const Expression_Literal_Map_KeyValue* msg) { return *msg->key_; } -const ::io::substrait::Expression_Literal& +const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_Internal::value(const Expression_Literal_Map_KeyValue* msg) { return *msg->value_; } @@ -2356,22 +2347,22 @@ Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(::PROTOBUF_NAME : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Map.KeyValue) } Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_key()) { - key_ = new ::io::substrait::Expression_Literal(*from.key_); + key_ = new ::substrait::Expression_Literal(*from.key_); } else { key_ = nullptr; } if (from._internal_has_value()) { - value_ = new ::io::substrait::Expression_Literal(*from.value_); + value_ = new ::substrait::Expression_Literal(*from.value_); } else { value_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Map.KeyValue) } void Expression_Literal_Map_KeyValue::SharedCtor() { @@ -2382,7 +2373,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_Literal_Map_KeyValue::~Expression_Literal_Map_KeyValue() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Map.KeyValue) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2404,7 +2395,7 @@ void Expression_Literal_Map_KeyValue::SetCachedSize(int size) const { } void Expression_Literal_Map_KeyValue::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Map.KeyValue) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Map.KeyValue) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2426,14 +2417,14 @@ const char* Expression_Literal_Map_KeyValue::_InternalParse(const char* ptr, ::P ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.Literal key = 1; + // .substrait.Expression.Literal key = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Literal value = 2; + // .substrait.Expression.Literal value = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); @@ -2465,11 +2456,11 @@ const char* Expression_Literal_Map_KeyValue::_InternalParse(const char* ptr, ::P ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map_KeyValue::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Map.KeyValue) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.Literal key = 1; + // .substrait.Expression.Literal key = 1; if (this->has_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2477,7 +2468,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map_KeyValue::_InternalSerial 1, _Internal::key(this), target, stream); } - // .io.substrait.Expression.Literal value = 2; + // .substrait.Expression.Literal value = 2; if (this->has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2489,26 +2480,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map_KeyValue::_InternalSerial target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Map.KeyValue) return target; } size_t Expression_Literal_Map_KeyValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Map.KeyValue) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Map.KeyValue) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression.Literal key = 1; + // .substrait.Expression.Literal key = 1; if (this->has_key()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *key_); } - // .io.substrait.Expression.Literal value = 2; + // .substrait.Expression.Literal value = 2; if (this->has_value()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2525,44 +2516,44 @@ size_t Expression_Literal_Map_KeyValue::ByteSizeLong() const { } void Expression_Literal_Map_KeyValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Map.KeyValue) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.Map.KeyValue) GOOGLE_DCHECK_NE(&from, this); const Expression_Literal_Map_KeyValue* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.Map.KeyValue) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.Map.KeyValue) MergeFrom(*source); } } void Expression_Literal_Map_KeyValue::MergeFrom(const Expression_Literal_Map_KeyValue& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Map.KeyValue) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Map.KeyValue) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_key()) { - _internal_mutable_key()->::io::substrait::Expression_Literal::MergeFrom(from._internal_key()); + _internal_mutable_key()->::substrait::Expression_Literal::MergeFrom(from._internal_key()); } if (from.has_value()) { - _internal_mutable_value()->::io::substrait::Expression_Literal::MergeFrom(from._internal_value()); + _internal_mutable_value()->::substrait::Expression_Literal::MergeFrom(from._internal_value()); } } void Expression_Literal_Map_KeyValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Map.KeyValue) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.Map.KeyValue) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Literal_Map_KeyValue::CopyFrom(const Expression_Literal_Map_KeyValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Map.KeyValue) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Map.KeyValue) if (&from == this) return; Clear(); MergeFrom(from); @@ -2585,79 +2576,41 @@ void Expression_Literal_Map_KeyValue::InternalSwap(Expression_Literal_Map_KeyVal ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map_KeyValue::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[4]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[4]); } // =================================================================== class Expression_Literal_Map::_Internal { public: - static const ::io::substrait::Type& key_type(const Expression_Literal_Map* msg); - static const ::io::substrait::Type& value_type(const Expression_Literal_Map* msg); }; -const ::io::substrait::Type& -Expression_Literal_Map::_Internal::key_type(const Expression_Literal_Map* msg) { - return *msg->key_type_; -} -const ::io::substrait::Type& -Expression_Literal_Map::_Internal::value_type(const Expression_Literal_Map* msg) { - return *msg->value_type_; -} -void Expression_Literal_Map::clear_key_type() { - if (GetArena() == nullptr && key_type_ != nullptr) { - delete key_type_; - } - key_type_ = nullptr; -} -void Expression_Literal_Map::clear_value_type() { - if (GetArena() == nullptr && value_type_ != nullptr) { - delete value_type_; - } - value_type_ = nullptr; -} Expression_Literal_Map::Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), key_values_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Map) } Expression_Literal_Map::Expression_Literal_Map(const Expression_Literal_Map& from) : ::PROTOBUF_NAMESPACE_ID::Message(), key_values_(from.key_values_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key_type()) { - key_type_ = new ::io::substrait::Type(*from.key_type_); - } else { - key_type_ = nullptr; - } - if (from._internal_has_value_type()) { - value_type_ = new ::io::substrait::Type(*from.value_type_); - } else { - value_type_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Map) } void Expression_Literal_Map::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&key_type_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&value_type_) - - reinterpret_cast(&key_type_)) + sizeof(value_type_)); } Expression_Literal_Map::~Expression_Literal_Map() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Map) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void Expression_Literal_Map::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete key_type_; - if (this != internal_default_instance()) delete value_type_; } void Expression_Literal_Map::ArenaDtor(void* object) { @@ -2671,20 +2624,12 @@ void Expression_Literal_Map::SetCachedSize(int size) const { } void Expression_Literal_Map::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Map) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Map) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; key_values_.Clear(); - if (GetArena() == nullptr && key_type_ != nullptr) { - delete key_type_; - } - key_type_ = nullptr; - if (GetArena() == nullptr && value_type_ != nullptr) { - delete value_type_; - } - value_type_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2694,7 +2639,7 @@ const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_N ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -2706,20 +2651,6 @@ const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_N } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Type key_type = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_key_type(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.Type value_type = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_value_type(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -2745,11 +2676,11 @@ const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_N ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Map) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; for (unsigned int i = 0, n = static_cast(this->_internal_key_values_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -2757,59 +2688,29 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map::_InternalSerialize( InternalWriteMessage(1, this->_internal_key_values(i), target, stream); } - // .io.substrait.Type key_type = 2; - if (this->has_key_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::key_type(this), target, stream); - } - - // .io.substrait.Type value_type = 3; - if (this->has_value_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::value_type(this), target, stream); - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Map) return target; } size_t Expression_Literal_Map::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Map) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Map) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; total_size += 1UL * this->_internal_key_values_size(); for (const auto& msg : this->key_values_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Type key_type = 2; - if (this->has_key_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *key_type_); - } - - // .io.substrait.Type value_type = 3; - if (this->has_value_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *value_type_); - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -2820,45 +2721,39 @@ size_t Expression_Literal_Map::ByteSizeLong() const { } void Expression_Literal_Map::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Map) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.Map) GOOGLE_DCHECK_NE(&from, this); const Expression_Literal_Map* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.Map) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.Map) MergeFrom(*source); } } void Expression_Literal_Map::MergeFrom(const Expression_Literal_Map& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Map) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Map) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; key_values_.MergeFrom(from.key_values_); - if (from.has_key_type()) { - _internal_mutable_key_type()->::io::substrait::Type::MergeFrom(from._internal_key_type()); - } - if (from.has_value_type()) { - _internal_mutable_value_type()->::io::substrait::Type::MergeFrom(from._internal_value_type()); - } } void Expression_Literal_Map::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Map) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.Map) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Literal_Map::CopyFrom(const Expression_Literal_Map& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Map) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Map) if (&from == this) return; Clear(); MergeFrom(from); @@ -2872,18 +2767,12 @@ void Expression_Literal_Map::InternalSwap(Expression_Literal_Map* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); key_values_.InternalSwap(&other->key_values_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_Literal_Map, value_type_) - + sizeof(Expression_Literal_Map::value_type_) - - PROTOBUF_FIELD_OFFSET(Expression_Literal_Map, key_type_)>( - reinterpret_cast(&key_type_), - reinterpret_cast(&other->key_type_)); } ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[5]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[5]); } // =================================================================== @@ -2896,7 +2785,7 @@ Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(: : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.IntervalYearToMonth) } Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -2904,7 +2793,7 @@ Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(c ::memcpy(&years_, &from.years_, static_cast(reinterpret_cast(&months_) - reinterpret_cast(&years_)) + sizeof(months_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalYearToMonth) } void Expression_Literal_IntervalYearToMonth::SharedCtor() { @@ -2915,7 +2804,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_Literal_IntervalYearToMonth::~Expression_Literal_IntervalYearToMonth() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(destructor:substrait.Expression.Literal.IntervalYearToMonth) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2935,7 +2824,7 @@ void Expression_Literal_IntervalYearToMonth::SetCachedSize(int size) const { } void Expression_Literal_IntervalYearToMonth::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.IntervalYearToMonth) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.IntervalYearToMonth) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2991,7 +2880,7 @@ const char* Expression_Literal_IntervalYearToMonth::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalYearToMonth::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.IntervalYearToMonth) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3011,12 +2900,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalYearToMonth::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.IntervalYearToMonth) return target; } size_t Expression_Literal_IntervalYearToMonth::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.IntervalYearToMonth) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.IntervalYearToMonth) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3047,22 +2936,22 @@ size_t Expression_Literal_IntervalYearToMonth::ByteSizeLong() const { } void Expression_Literal_IntervalYearToMonth::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.IntervalYearToMonth) GOOGLE_DCHECK_NE(&from, this); const Expression_Literal_IntervalYearToMonth* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.IntervalYearToMonth) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.IntervalYearToMonth) MergeFrom(*source); } } void Expression_Literal_IntervalYearToMonth::MergeFrom(const Expression_Literal_IntervalYearToMonth& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.IntervalYearToMonth) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3077,14 +2966,14 @@ void Expression_Literal_IntervalYearToMonth::MergeFrom(const Expression_Literal_ } void Expression_Literal_IntervalYearToMonth::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.IntervalYearToMonth) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Literal_IntervalYearToMonth::CopyFrom(const Expression_Literal_IntervalYearToMonth& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.IntervalYearToMonth) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.IntervalYearToMonth) if (&from == this) return; Clear(); MergeFrom(from); @@ -3107,8 +2996,8 @@ void Expression_Literal_IntervalYearToMonth::InternalSwap(Expression_Literal_Int ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalYearToMonth::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[6]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[6]); } // =================================================================== @@ -3121,7 +3010,7 @@ Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(: : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.IntervalDayToSecond) } Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -3129,7 +3018,7 @@ Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(c ::memcpy(&days_, &from.days_, static_cast(reinterpret_cast(&seconds_) - reinterpret_cast(&days_)) + sizeof(seconds_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalDayToSecond) } void Expression_Literal_IntervalDayToSecond::SharedCtor() { @@ -3140,7 +3029,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_Literal_IntervalDayToSecond::~Expression_Literal_IntervalDayToSecond() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(destructor:substrait.Expression.Literal.IntervalDayToSecond) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3160,7 +3049,7 @@ void Expression_Literal_IntervalDayToSecond::SetCachedSize(int size) const { } void Expression_Literal_IntervalDayToSecond::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.IntervalDayToSecond) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.IntervalDayToSecond) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3216,7 +3105,7 @@ const char* Expression_Literal_IntervalDayToSecond::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalDayToSecond::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.IntervalDayToSecond) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3236,12 +3125,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalDayToSecond::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.IntervalDayToSecond) return target; } size_t Expression_Literal_IntervalDayToSecond::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.IntervalDayToSecond) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.IntervalDayToSecond) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3272,22 +3161,22 @@ size_t Expression_Literal_IntervalDayToSecond::ByteSizeLong() const { } void Expression_Literal_IntervalDayToSecond::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.IntervalDayToSecond) GOOGLE_DCHECK_NE(&from, this); const Expression_Literal_IntervalDayToSecond* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.IntervalDayToSecond) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.IntervalDayToSecond) MergeFrom(*source); } } void Expression_Literal_IntervalDayToSecond::MergeFrom(const Expression_Literal_IntervalDayToSecond& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.IntervalDayToSecond) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3302,14 +3191,14 @@ void Expression_Literal_IntervalDayToSecond::MergeFrom(const Expression_Literal_ } void Expression_Literal_IntervalDayToSecond::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.IntervalDayToSecond) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Literal_IntervalDayToSecond::CopyFrom(const Expression_Literal_IntervalDayToSecond& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.IntervalDayToSecond) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.IntervalDayToSecond) if (&from == this) return; Clear(); MergeFrom(from); @@ -3332,8 +3221,8 @@ void Expression_Literal_IntervalDayToSecond::InternalSwap(Expression_Literal_Int ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalDayToSecond::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[7]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[7]); } // =================================================================== @@ -3347,20 +3236,20 @@ Expression_Literal_Struct::Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Ar fields_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Struct) } Expression_Literal_Struct::Expression_Literal_Struct(const Expression_Literal_Struct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), fields_(from.fields_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Struct) } void Expression_Literal_Struct::SharedCtor() { } Expression_Literal_Struct::~Expression_Literal_Struct() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Struct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3380,7 +3269,7 @@ void Expression_Literal_Struct::SetCachedSize(int size) const { } void Expression_Literal_Struct::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.Struct) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Struct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3395,7 +3284,7 @@ const char* Expression_Literal_Struct::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.Literal fields = 1; + // repeated .substrait.Expression.Literal fields = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -3432,11 +3321,11 @@ const char* Expression_Literal_Struct::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Struct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Struct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal fields = 1; + // repeated .substrait.Expression.Literal fields = 1; for (unsigned int i = 0, n = static_cast(this->_internal_fields_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -3448,19 +3337,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Struct::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Struct) return target; } size_t Expression_Literal_Struct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.Struct) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Struct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal fields = 1; + // repeated .substrait.Expression.Literal fields = 1; total_size += 1UL * this->_internal_fields_size(); for (const auto& msg : this->fields_) { total_size += @@ -3477,22 +3366,22 @@ size_t Expression_Literal_Struct::ByteSizeLong() const { } void Expression_Literal_Struct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.Struct) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.Struct) GOOGLE_DCHECK_NE(&from, this); const Expression_Literal_Struct* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.Struct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.Struct) MergeFrom(*source); } } void Expression_Literal_Struct::MergeFrom(const Expression_Literal_Struct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.Struct) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Struct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3502,14 +3391,14 @@ void Expression_Literal_Struct::MergeFrom(const Expression_Literal_Struct& from) } void Expression_Literal_Struct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.Struct) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.Struct) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Literal_Struct::CopyFrom(const Expression_Literal_Struct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.Struct) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Struct) if (&from == this) return; Clear(); MergeFrom(from); @@ -3527,59 +3416,41 @@ void Expression_Literal_Struct::InternalSwap(Expression_Literal_Struct* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Struct::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[8]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[8]); } // =================================================================== class Expression_Literal_List::_Internal { public: - static const ::io::substrait::Type& element_type(const Expression_Literal_List* msg); }; -const ::io::substrait::Type& -Expression_Literal_List::_Internal::element_type(const Expression_Literal_List* msg) { - return *msg->element_type_; -} -void Expression_Literal_List::clear_element_type() { - if (GetArena() == nullptr && element_type_ != nullptr) { - delete element_type_; - } - element_type_ = nullptr; -} Expression_Literal_List::Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), values_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.List) } Expression_Literal_List::Expression_Literal_List(const Expression_Literal_List& from) : ::PROTOBUF_NAMESPACE_ID::Message(), values_(from.values_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_element_type()) { - element_type_ = new ::io::substrait::Type(*from.element_type_); - } else { - element_type_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.List) } void Expression_Literal_List::SharedCtor() { -element_type_ = nullptr; } Expression_Literal_List::~Expression_Literal_List() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(destructor:substrait.Expression.Literal.List) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void Expression_Literal_List::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete element_type_; } void Expression_Literal_List::ArenaDtor(void* object) { @@ -3593,16 +3464,12 @@ void Expression_Literal_List::SetCachedSize(int size) const { } void Expression_Literal_List::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal.List) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.List) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; values_.Clear(); - if (GetArena() == nullptr && element_type_ != nullptr) { - delete element_type_; - } - element_type_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3612,7 +3479,7 @@ const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_ ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.Literal values = 1; + // repeated .substrait.Expression.Literal values = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -3624,13 +3491,6 @@ const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_ } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Type element_type = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_element_type(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; default: { handle_unusual: if ((tag == 0) || ((tag & 7) == 4)) { @@ -3656,11 +3516,11 @@ const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_List::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.List) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal values = 1; + // repeated .substrait.Expression.Literal values = 1; for (unsigned int i = 0, n = static_cast(this->_internal_values_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -3668,44 +3528,29 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_List::_InternalSerialize( InternalWriteMessage(1, this->_internal_values(i), target, stream); } - // .io.substrait.Type element_type = 2; - if (this->has_element_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::element_type(this), target, stream); - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.List) return target; } size_t Expression_Literal_List::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal.List) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.List) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal values = 1; + // repeated .substrait.Expression.Literal values = 1; total_size += 1UL * this->_internal_values_size(); for (const auto& msg : this->values_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Type element_type = 2; - if (this->has_element_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *element_type_); - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( _internal_metadata_, total_size, &_cached_size_); @@ -3716,42 +3561,39 @@ size_t Expression_Literal_List::ByteSizeLong() const { } void Expression_Literal_List::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal.List) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.List) GOOGLE_DCHECK_NE(&from, this); const Expression_Literal_List* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.List) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.List) MergeFrom(*source); } } void Expression_Literal_List::MergeFrom(const Expression_Literal_List& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal.List) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.List) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; values_.MergeFrom(from.values_); - if (from.has_element_type()) { - _internal_mutable_element_type()->::io::substrait::Type::MergeFrom(from._internal_element_type()); - } } void Expression_Literal_List::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal.List) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.List) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Literal_List::CopyFrom(const Expression_Literal_List& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal.List) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.List) if (&from == this) return; Clear(); MergeFrom(from); @@ -3765,62 +3607,71 @@ void Expression_Literal_List::InternalSwap(Expression_Literal_List* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); values_.InternalSwap(&other->values_); - swap(element_type_, other->element_type_); } ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_List::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[9]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[9]); } // =================================================================== class Expression_Literal::_Internal { public: - static const ::io::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month(const Expression_Literal* msg); - static const ::io::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second(const Expression_Literal* msg); - static const ::io::substrait::Expression_Literal_VarChar& var_char(const Expression_Literal* msg); - static const ::io::substrait::Expression_Literal_Decimal& decimal(const Expression_Literal* msg); - static const ::io::substrait::Expression_Literal_Struct& struct_(const Expression_Literal* msg); - static const ::io::substrait::Expression_Literal_Map& map(const Expression_Literal* msg); - static const ::io::substrait::Type& null(const Expression_Literal* msg); - static const ::io::substrait::Expression_Literal_List& list(const Expression_Literal* msg); + static const ::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month(const Expression_Literal* msg); + static const ::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second(const Expression_Literal* msg); + static const ::substrait::Expression_Literal_VarChar& var_char(const Expression_Literal* msg); + static const ::substrait::Expression_Literal_Decimal& decimal(const Expression_Literal* msg); + static const ::substrait::Expression_Literal_Struct& struct_(const Expression_Literal* msg); + static const ::substrait::Expression_Literal_Map& map(const Expression_Literal* msg); + static const ::substrait::Type& null(const Expression_Literal* msg); + static const ::substrait::Expression_Literal_List& list(const Expression_Literal* msg); + static const ::substrait::Type_List& empty_list(const Expression_Literal* msg); + static const ::substrait::Type_Map& empty_map(const Expression_Literal* msg); }; -const ::io::substrait::Expression_Literal_IntervalYearToMonth& +const ::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::_Internal::interval_year_to_month(const Expression_Literal* msg) { return *msg->literal_type_.interval_year_to_month_; } -const ::io::substrait::Expression_Literal_IntervalDayToSecond& +const ::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::_Internal::interval_day_to_second(const Expression_Literal* msg) { return *msg->literal_type_.interval_day_to_second_; } -const ::io::substrait::Expression_Literal_VarChar& +const ::substrait::Expression_Literal_VarChar& Expression_Literal::_Internal::var_char(const Expression_Literal* msg) { return *msg->literal_type_.var_char_; } -const ::io::substrait::Expression_Literal_Decimal& +const ::substrait::Expression_Literal_Decimal& Expression_Literal::_Internal::decimal(const Expression_Literal* msg) { return *msg->literal_type_.decimal_; } -const ::io::substrait::Expression_Literal_Struct& +const ::substrait::Expression_Literal_Struct& Expression_Literal::_Internal::struct_(const Expression_Literal* msg) { return *msg->literal_type_.struct__; } -const ::io::substrait::Expression_Literal_Map& +const ::substrait::Expression_Literal_Map& Expression_Literal::_Internal::map(const Expression_Literal* msg) { return *msg->literal_type_.map_; } -const ::io::substrait::Type& +const ::substrait::Type& Expression_Literal::_Internal::null(const Expression_Literal* msg) { return *msg->literal_type_.null_; } -const ::io::substrait::Expression_Literal_List& +const ::substrait::Expression_Literal_List& Expression_Literal::_Internal::list(const Expression_Literal* msg) { return *msg->literal_type_.list_; } -void Expression_Literal::set_allocated_interval_year_to_month(::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { +const ::substrait::Type_List& +Expression_Literal::_Internal::empty_list(const Expression_Literal* msg) { + return *msg->literal_type_.empty_list_; +} +const ::substrait::Type_Map& +Expression_Literal::_Internal::empty_map(const Expression_Literal* msg) { + return *msg->literal_type_.empty_map_; +} +void Expression_Literal::set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_literal_type(); if (interval_year_to_month) { @@ -3833,9 +3684,9 @@ void Expression_Literal::set_allocated_interval_year_to_month(::io::substrait::E set_has_interval_year_to_month(); literal_type_.interval_year_to_month_ = interval_year_to_month; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.interval_year_to_month) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.interval_year_to_month) } -void Expression_Literal::set_allocated_interval_day_to_second(::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { +void Expression_Literal::set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_literal_type(); if (interval_day_to_second) { @@ -3848,9 +3699,9 @@ void Expression_Literal::set_allocated_interval_day_to_second(::io::substrait::E set_has_interval_day_to_second(); literal_type_.interval_day_to_second_ = interval_day_to_second; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.interval_day_to_second) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.interval_day_to_second) } -void Expression_Literal::set_allocated_var_char(::io::substrait::Expression_Literal_VarChar* var_char) { +void Expression_Literal::set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_literal_type(); if (var_char) { @@ -3863,9 +3714,9 @@ void Expression_Literal::set_allocated_var_char(::io::substrait::Expression_Lite set_has_var_char(); literal_type_.var_char_ = var_char; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.var_char) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.var_char) } -void Expression_Literal::set_allocated_decimal(::io::substrait::Expression_Literal_Decimal* decimal) { +void Expression_Literal::set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_literal_type(); if (decimal) { @@ -3878,9 +3729,9 @@ void Expression_Literal::set_allocated_decimal(::io::substrait::Expression_Liter set_has_decimal(); literal_type_.decimal_ = decimal; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.decimal) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.decimal) } -void Expression_Literal::set_allocated_struct_(::io::substrait::Expression_Literal_Struct* struct_) { +void Expression_Literal::set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_literal_type(); if (struct_) { @@ -3893,9 +3744,9 @@ void Expression_Literal::set_allocated_struct_(::io::substrait::Expression_Liter set_has_struct_(); literal_type_.struct__ = struct_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.struct) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.struct) } -void Expression_Literal::set_allocated_map(::io::substrait::Expression_Literal_Map* map) { +void Expression_Literal::set_allocated_map(::substrait::Expression_Literal_Map* map) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_literal_type(); if (map) { @@ -3908,9 +3759,9 @@ void Expression_Literal::set_allocated_map(::io::substrait::Expression_Literal_M set_has_map(); literal_type_.map_ = map; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.map) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.map) } -void Expression_Literal::set_allocated_null(::io::substrait::Type* null) { +void Expression_Literal::set_allocated_null(::substrait::Type* null) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_literal_type(); if (null) { @@ -3923,7 +3774,7 @@ void Expression_Literal::set_allocated_null(::io::substrait::Type* null) { set_has_null(); literal_type_.null_ = null; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.null) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.null) } void Expression_Literal::clear_null() { if (_internal_has_null()) { @@ -3933,7 +3784,7 @@ void Expression_Literal::clear_null() { clear_has_literal_type(); } } -void Expression_Literal::set_allocated_list(::io::substrait::Expression_Literal_List* list) { +void Expression_Literal::set_allocated_list(::substrait::Expression_Literal_List* list) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_literal_type(); if (list) { @@ -3946,13 +3797,59 @@ void Expression_Literal::set_allocated_list(::io::substrait::Expression_Literal_ set_has_list(); literal_type_.list_ = list; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.list) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.list) +} +void Expression_Literal::set_allocated_empty_list(::substrait::Type_List* empty_list) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (empty_list) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_list)->GetArena(); + if (message_arena != submessage_arena) { + empty_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, empty_list, submessage_arena); + } + set_has_empty_list(); + literal_type_.empty_list_ = empty_list; + } + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.empty_list) +} +void Expression_Literal::clear_empty_list() { + if (_internal_has_empty_list()) { + if (GetArena() == nullptr) { + delete literal_type_.empty_list_; + } + clear_has_literal_type(); + } +} +void Expression_Literal::set_allocated_empty_map(::substrait::Type_Map* empty_map) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_literal_type(); + if (empty_map) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_map)->GetArena(); + if (message_arena != submessage_arena) { + empty_map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, empty_map, submessage_arena); + } + set_has_empty_map(); + literal_type_.empty_map_ = empty_map; + } + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.empty_map) +} +void Expression_Literal::clear_empty_map() { + if (_internal_has_empty_map()) { + if (GetArena() == nullptr) { + delete literal_type_.empty_map_; + } + clear_has_literal_type(); + } } Expression_Literal::Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Literal) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal) } Expression_Literal::Expression_Literal(const Expression_Literal& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -4009,11 +3906,11 @@ Expression_Literal::Expression_Literal(const Expression_Literal& from) break; } case kIntervalYearToMonth: { - _internal_mutable_interval_year_to_month()->::io::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); + _internal_mutable_interval_year_to_month()->::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); break; } case kIntervalDayToSecond: { - _internal_mutable_interval_day_to_second()->::io::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); + _internal_mutable_interval_day_to_second()->::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); break; } case kFixedChar: { @@ -4021,7 +3918,7 @@ Expression_Literal::Expression_Literal(const Expression_Literal& from) break; } case kVarChar: { - _internal_mutable_var_char()->::io::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char()); + _internal_mutable_var_char()->::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char()); break; } case kFixedBinary: { @@ -4029,15 +3926,15 @@ Expression_Literal::Expression_Literal(const Expression_Literal& from) break; } case kDecimal: { - _internal_mutable_decimal()->::io::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal()); + _internal_mutable_decimal()->::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal()); break; } case kStruct: { - _internal_mutable_struct_()->::io::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); break; } case kMap: { - _internal_mutable_map()->::io::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); + _internal_mutable_map()->::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); break; } case kTimestampTz: { @@ -4049,18 +3946,26 @@ Expression_Literal::Expression_Literal(const Expression_Literal& from) break; } case kNull: { - _internal_mutable_null()->::io::substrait::Type::MergeFrom(from._internal_null()); + _internal_mutable_null()->::substrait::Type::MergeFrom(from._internal_null()); break; } case kList: { - _internal_mutable_list()->::io::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); + _internal_mutable_list()->::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); + break; + } + case kEmptyList: { + _internal_mutable_empty_list()->::substrait::Type_List::MergeFrom(from._internal_empty_list()); + break; + } + case kEmptyMap: { + _internal_mutable_empty_map()->::substrait::Type_Map::MergeFrom(from._internal_empty_map()); break; } case LITERAL_TYPE_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Literal) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal) } void Expression_Literal::SharedCtor() { @@ -4069,7 +3974,7 @@ clear_has_literal_type(); } Expression_Literal::~Expression_Literal() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Literal) + // @@protoc_insertion_point(destructor:substrait.Expression.Literal) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4092,7 +3997,7 @@ void Expression_Literal::SetCachedSize(int size) const { } void Expression_Literal::clear_literal_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.Literal) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.Literal) switch (literal_type_case()) { case kBoolean: { // No need to clear @@ -4206,6 +4111,18 @@ void Expression_Literal::clear_literal_type() { } break; } + case kEmptyList: { + if (GetArena() == nullptr) { + delete literal_type_.empty_list_; + } + break; + } + case kEmptyMap: { + if (GetArena() == nullptr) { + delete literal_type_.empty_map_; + } + break; + } case LITERAL_TYPE_NOT_SET: { break; } @@ -4215,7 +4132,7 @@ void Expression_Literal::clear_literal_type() { void Expression_Literal::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Literal) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4285,7 +4202,7 @@ const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMES if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { auto str = _internal_mutable_string(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.string")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.string")); CHK_(ptr); } else goto handle_unusual; continue; @@ -4304,7 +4221,7 @@ const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMES CHK_(ptr); } else goto handle_unusual; continue; - // int64 date = 16; + // int32 date = 16; case 16: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 128)) { _internal_set_date(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); @@ -4318,14 +4235,14 @@ const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMES CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; case 19: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_interval_year_to_month(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; case 20: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_interval_day_to_second(), ptr); @@ -4337,11 +4254,11 @@ const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMES if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { auto str = _internal_mutable_fixed_char(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.Literal.fixed_char")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.fixed_char")); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Literal.VarChar var_char = 22; + // .substrait.Expression.Literal.VarChar var_char = 22; case 22: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_var_char(), ptr); @@ -4356,21 +4273,21 @@ const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMES CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Literal.Decimal decimal = 24; + // .substrait.Expression.Literal.Decimal decimal = 24; case 24: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Literal.Struct struct = 25; + // .substrait.Expression.Literal.Struct struct = 25; case 25: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Literal.Map map = 26; + // .substrait.Expression.Literal.Map map = 26; case 26: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) { ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); @@ -4392,20 +4309,34 @@ const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMES CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type null = 29; + // .substrait.Type null = 29; case 29: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { ptr = ctx->ParseMessage(_internal_mutable_null(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Literal.List list = 30; + // .substrait.Expression.Literal.List list = 30; case 30: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 242)) { ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); CHK_(ptr); } else goto handle_unusual; continue; + // .substrait.Type.List empty_list = 31; + case 31: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) { + ptr = ctx->ParseMessage(_internal_mutable_empty_list(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .substrait.Type.Map empty_map = 32; + case 32: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { + ptr = ctx->ParseMessage(_internal_mutable_empty_map(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; // bool nullable = 50; case 50: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) { @@ -4438,7 +4369,7 @@ const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMES ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Literal) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -4489,7 +4420,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_string().data(), static_cast(this->_internal_string().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.Literal.string"); + "substrait.Expression.Literal.string"); target = stream->WriteStringMaybeAliased( 12, this->_internal_string(), target); } @@ -4506,10 +4437,10 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(14, this->_internal_timestamp(), target); } - // int64 date = 16; + // int32 date = 16; if (_internal_has_date()) { target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(16, this->_internal_date(), target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(16, this->_internal_date(), target); } // int64 time = 17; @@ -4518,7 +4449,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(17, this->_internal_time(), target); } - // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; if (_internal_has_interval_year_to_month()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4526,7 +4457,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( 19, _Internal::interval_year_to_month(this), target, stream); } - // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; if (_internal_has_interval_day_to_second()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4539,12 +4470,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_fixed_char().data(), static_cast(this->_internal_fixed_char().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.Literal.fixed_char"); + "substrait.Expression.Literal.fixed_char"); target = stream->WriteStringMaybeAliased( 21, this->_internal_fixed_char(), target); } - // .io.substrait.Expression.Literal.VarChar var_char = 22; + // .substrait.Expression.Literal.VarChar var_char = 22; if (_internal_has_var_char()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4558,7 +4489,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( 23, this->_internal_fixed_binary(), target); } - // .io.substrait.Expression.Literal.Decimal decimal = 24; + // .substrait.Expression.Literal.Decimal decimal = 24; if (_internal_has_decimal()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4566,7 +4497,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( 24, _Internal::decimal(this), target, stream); } - // .io.substrait.Expression.Literal.Struct struct = 25; + // .substrait.Expression.Literal.Struct struct = 25; if (_internal_has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4574,7 +4505,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( 25, _Internal::struct_(this), target, stream); } - // .io.substrait.Expression.Literal.Map map = 26; + // .substrait.Expression.Literal.Map map = 26; if (_internal_has_map()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4594,7 +4525,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( 28, this->_internal_uuid(), target); } - // .io.substrait.Type null = 29; + // .substrait.Type null = 29; if (_internal_has_null()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4602,7 +4533,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( 29, _Internal::null(this), target, stream); } - // .io.substrait.Expression.Literal.List list = 30; + // .substrait.Expression.Literal.List list = 30; if (_internal_has_list()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4610,6 +4541,22 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( 30, _Internal::list(this), target, stream); } + // .substrait.Type.List empty_list = 31; + if (_internal_has_empty_list()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 31, _Internal::empty_list(this), target, stream); + } + + // .substrait.Type.Map empty_map = 32; + if (_internal_has_empty_map()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 32, _Internal::empty_map(this), target, stream); + } + // bool nullable = 50; if (this->nullable() != 0) { target = stream->EnsureSpace(target); @@ -4620,12 +4567,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Literal) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal) return target; } size_t Expression_Literal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Literal) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4702,10 +4649,10 @@ size_t Expression_Literal::ByteSizeLong() const { this->_internal_timestamp()); break; } - // int64 date = 16; + // int32 date = 16; case kDate: { total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( this->_internal_date()); break; } @@ -4716,14 +4663,14 @@ size_t Expression_Literal::ByteSizeLong() const { this->_internal_time()); break; } - // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; case kIntervalYearToMonth: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *literal_type_.interval_year_to_month_); break; } - // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; case kIntervalDayToSecond: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -4737,7 +4684,7 @@ size_t Expression_Literal::ByteSizeLong() const { this->_internal_fixed_char()); break; } - // .io.substrait.Expression.Literal.VarChar var_char = 22; + // .substrait.Expression.Literal.VarChar var_char = 22; case kVarChar: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -4751,21 +4698,21 @@ size_t Expression_Literal::ByteSizeLong() const { this->_internal_fixed_binary()); break; } - // .io.substrait.Expression.Literal.Decimal decimal = 24; + // .substrait.Expression.Literal.Decimal decimal = 24; case kDecimal: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *literal_type_.decimal_); break; } - // .io.substrait.Expression.Literal.Struct struct = 25; + // .substrait.Expression.Literal.Struct struct = 25; case kStruct: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *literal_type_.struct__); break; } - // .io.substrait.Expression.Literal.Map map = 26; + // .substrait.Expression.Literal.Map map = 26; case kMap: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -4786,20 +4733,34 @@ size_t Expression_Literal::ByteSizeLong() const { this->_internal_uuid()); break; } - // .io.substrait.Type null = 29; + // .substrait.Type null = 29; case kNull: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *literal_type_.null_); break; } - // .io.substrait.Expression.Literal.List list = 30; + // .substrait.Expression.Literal.List list = 30; case kList: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *literal_type_.list_); break; } + // .substrait.Type.List empty_list = 31; + case kEmptyList: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.empty_list_); + break; + } + // .substrait.Type.Map empty_map = 32; + case kEmptyMap: { + total_size += 2 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *literal_type_.empty_map_); + break; + } case LITERAL_TYPE_NOT_SET: { break; } @@ -4814,22 +4775,22 @@ size_t Expression_Literal::ByteSizeLong() const { } void Expression_Literal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Literal) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal) GOOGLE_DCHECK_NE(&from, this); const Expression_Literal* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Literal) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Literal) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal) MergeFrom(*source); } } void Expression_Literal::MergeFrom(const Expression_Literal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Literal) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4888,11 +4849,11 @@ void Expression_Literal::MergeFrom(const Expression_Literal& from) { break; } case kIntervalYearToMonth: { - _internal_mutable_interval_year_to_month()->::io::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); + _internal_mutable_interval_year_to_month()->::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); break; } case kIntervalDayToSecond: { - _internal_mutable_interval_day_to_second()->::io::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); + _internal_mutable_interval_day_to_second()->::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); break; } case kFixedChar: { @@ -4900,7 +4861,7 @@ void Expression_Literal::MergeFrom(const Expression_Literal& from) { break; } case kVarChar: { - _internal_mutable_var_char()->::io::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char()); + _internal_mutable_var_char()->::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char()); break; } case kFixedBinary: { @@ -4908,15 +4869,15 @@ void Expression_Literal::MergeFrom(const Expression_Literal& from) { break; } case kDecimal: { - _internal_mutable_decimal()->::io::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal()); + _internal_mutable_decimal()->::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal()); break; } case kStruct: { - _internal_mutable_struct_()->::io::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); break; } case kMap: { - _internal_mutable_map()->::io::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); + _internal_mutable_map()->::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); break; } case kTimestampTz: { @@ -4928,11 +4889,19 @@ void Expression_Literal::MergeFrom(const Expression_Literal& from) { break; } case kNull: { - _internal_mutable_null()->::io::substrait::Type::MergeFrom(from._internal_null()); + _internal_mutable_null()->::substrait::Type::MergeFrom(from._internal_null()); break; } case kList: { - _internal_mutable_list()->::io::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); + _internal_mutable_list()->::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); + break; + } + case kEmptyList: { + _internal_mutable_empty_list()->::substrait::Type_List::MergeFrom(from._internal_empty_list()); + break; + } + case kEmptyMap: { + _internal_mutable_empty_map()->::substrait::Type_Map::MergeFrom(from._internal_empty_map()); break; } case LITERAL_TYPE_NOT_SET: { @@ -4942,14 +4911,14 @@ void Expression_Literal::MergeFrom(const Expression_Literal& from) { } void Expression_Literal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Literal) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Literal::CopyFrom(const Expression_Literal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Literal) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal) if (&from == this) return; Clear(); MergeFrom(from); @@ -4969,18 +4938,18 @@ void Expression_Literal::InternalSwap(Expression_Literal* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[10]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[10]); } // =================================================================== class Expression_ScalarFunction::_Internal { public: - static const ::io::substrait::Type& output_type(const Expression_ScalarFunction* msg); + static const ::substrait::Type& output_type(const Expression_ScalarFunction* msg); }; -const ::io::substrait::Type& +const ::substrait::Type& Expression_ScalarFunction::_Internal::output_type(const Expression_ScalarFunction* msg) { return *msg->output_type_; } @@ -4995,19 +4964,19 @@ Expression_ScalarFunction::Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Ar args_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ScalarFunction) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.ScalarFunction) } Expression_ScalarFunction::Expression_ScalarFunction(const Expression_ScalarFunction& from) : ::PROTOBUF_NAMESPACE_ID::Message(), args_(from.args_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_output_type()) { - output_type_ = new ::io::substrait::Type(*from.output_type_); + output_type_ = new ::substrait::Type(*from.output_type_); } else { output_type_ = nullptr; } function_reference_ = from.function_reference_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ScalarFunction) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.ScalarFunction) } void Expression_ScalarFunction::SharedCtor() { @@ -5018,7 +4987,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_ScalarFunction::~Expression_ScalarFunction() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.ScalarFunction) + // @@protoc_insertion_point(destructor:substrait.Expression.ScalarFunction) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5039,7 +5008,7 @@ void Expression_ScalarFunction::SetCachedSize(int size) const { } void Expression_ScalarFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ScalarFunction) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.ScalarFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5066,7 +5035,7 @@ const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBU CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Expression args = 2; + // repeated .substrait.Expression args = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -5078,7 +5047,7 @@ const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBU } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Type output_type = 3; + // .substrait.Type output_type = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); @@ -5110,7 +5079,7 @@ const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ScalarFunction::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ScalarFunction) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ScalarFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -5120,7 +5089,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ScalarFunction::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); } - // repeated .io.substrait.Expression args = 2; + // repeated .substrait.Expression args = 2; for (unsigned int i = 0, n = static_cast(this->_internal_args_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -5128,7 +5097,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ScalarFunction::_InternalSerialize( InternalWriteMessage(2, this->_internal_args(i), target, stream); } - // .io.substrait.Type output_type = 3; + // .substrait.Type output_type = 3; if (this->has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5140,26 +5109,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ScalarFunction::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ScalarFunction) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ScalarFunction) return target; } size_t Expression_ScalarFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ScalarFunction) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ScalarFunction) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression args = 2; + // repeated .substrait.Expression args = 2; total_size += 1UL * this->_internal_args_size(); for (const auto& msg : this->args_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Type output_type = 3; + // .substrait.Type output_type = 3; if (this->has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -5183,22 +5152,22 @@ size_t Expression_ScalarFunction::ByteSizeLong() const { } void Expression_ScalarFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ScalarFunction) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.ScalarFunction) GOOGLE_DCHECK_NE(&from, this); const Expression_ScalarFunction* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ScalarFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.ScalarFunction) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ScalarFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.ScalarFunction) MergeFrom(*source); } } void Expression_ScalarFunction::MergeFrom(const Expression_ScalarFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ScalarFunction) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ScalarFunction) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5206,7 +5175,7 @@ void Expression_ScalarFunction::MergeFrom(const Expression_ScalarFunction& from) args_.MergeFrom(from.args_); if (from.has_output_type()) { - _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); } if (from.function_reference() != 0) { _internal_set_function_reference(from._internal_function_reference()); @@ -5214,14 +5183,14 @@ void Expression_ScalarFunction::MergeFrom(const Expression_ScalarFunction& from) } void Expression_ScalarFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ScalarFunction) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.ScalarFunction) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_ScalarFunction::CopyFrom(const Expression_ScalarFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ScalarFunction) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ScalarFunction) if (&from == this) return; Clear(); MergeFrom(from); @@ -5245,8 +5214,8 @@ void Expression_ScalarFunction::InternalSwap(Expression_ScalarFunction* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_ScalarFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[11]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[11]); } // =================================================================== @@ -5259,13 +5228,13 @@ Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Prece : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound.Preceding) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Preceding) } Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); offset_ = from.offset_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound.Preceding) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Preceding) } void Expression_WindowFunction_Bound_Preceding::SharedCtor() { @@ -5273,7 +5242,7 @@ offset_ = PROTOBUF_LONGLONG(0); } Expression_WindowFunction_Bound_Preceding::~Expression_WindowFunction_Bound_Preceding() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound.Preceding) + // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.Preceding) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5293,7 +5262,7 @@ void Expression_WindowFunction_Bound_Preceding::SetCachedSize(int size) const { } void Expression_WindowFunction_Bound_Preceding::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound.Preceding) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Preceding) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5340,7 +5309,7 @@ const char* Expression_WindowFunction_Bound_Preceding::_InternalParse(const char ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Preceding::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound.Preceding) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Preceding) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -5354,12 +5323,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Preceding::_Inte target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound.Preceding) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound.Preceding) return target; } size_t Expression_WindowFunction_Bound_Preceding::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound.Preceding) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Preceding) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5383,22 +5352,22 @@ size_t Expression_WindowFunction_Bound_Preceding::ByteSizeLong() const { } void Expression_WindowFunction_Bound_Preceding::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Preceding) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction.Bound.Preceding) GOOGLE_DCHECK_NE(&from, this); const Expression_WindowFunction_Bound_Preceding* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction.Bound.Preceding) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction.Bound.Preceding) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction.Bound.Preceding) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction.Bound.Preceding) MergeFrom(*source); } } void Expression_WindowFunction_Bound_Preceding::MergeFrom(const Expression_WindowFunction_Bound_Preceding& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Preceding) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Preceding) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5410,14 +5379,14 @@ void Expression_WindowFunction_Bound_Preceding::MergeFrom(const Expression_Windo } void Expression_WindowFunction_Bound_Preceding::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Preceding) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction.Bound.Preceding) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_WindowFunction_Bound_Preceding::CopyFrom(const Expression_WindowFunction_Bound_Preceding& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Preceding) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.Preceding) if (&from == this) return; Clear(); MergeFrom(from); @@ -5435,8 +5404,8 @@ void Expression_WindowFunction_Bound_Preceding::InternalSwap(Expression_WindowFu ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Preceding::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[12]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[12]); } // =================================================================== @@ -5449,13 +5418,13 @@ Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Follo : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound.Following) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Following) } Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(const Expression_WindowFunction_Bound_Following& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); offset_ = from.offset_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound.Following) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Following) } void Expression_WindowFunction_Bound_Following::SharedCtor() { @@ -5463,7 +5432,7 @@ offset_ = PROTOBUF_LONGLONG(0); } Expression_WindowFunction_Bound_Following::~Expression_WindowFunction_Bound_Following() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound.Following) + // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.Following) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5483,7 +5452,7 @@ void Expression_WindowFunction_Bound_Following::SetCachedSize(int size) const { } void Expression_WindowFunction_Bound_Following::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound.Following) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Following) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5530,7 +5499,7 @@ const char* Expression_WindowFunction_Bound_Following::_InternalParse(const char ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Following::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound.Following) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Following) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -5544,12 +5513,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Following::_Inte target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound.Following) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound.Following) return target; } size_t Expression_WindowFunction_Bound_Following::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound.Following) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Following) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5573,22 +5542,22 @@ size_t Expression_WindowFunction_Bound_Following::ByteSizeLong() const { } void Expression_WindowFunction_Bound_Following::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Following) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction.Bound.Following) GOOGLE_DCHECK_NE(&from, this); const Expression_WindowFunction_Bound_Following* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction.Bound.Following) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction.Bound.Following) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction.Bound.Following) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction.Bound.Following) MergeFrom(*source); } } void Expression_WindowFunction_Bound_Following::MergeFrom(const Expression_WindowFunction_Bound_Following& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Following) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Following) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5600,14 +5569,14 @@ void Expression_WindowFunction_Bound_Following::MergeFrom(const Expression_Windo } void Expression_WindowFunction_Bound_Following::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Following) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction.Bound.Following) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_WindowFunction_Bound_Following::CopyFrom(const Expression_WindowFunction_Bound_Following& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Following) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.Following) if (&from == this) return; Clear(); MergeFrom(from); @@ -5625,8 +5594,8 @@ void Expression_WindowFunction_Bound_Following::InternalSwap(Expression_WindowFu ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Following::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[13]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[13]); } // =================================================================== @@ -5639,19 +5608,19 @@ Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_Curr : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.CurrentRow) } Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(const Expression_WindowFunction_Bound_CurrentRow& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.CurrentRow) } void Expression_WindowFunction_Bound_CurrentRow::SharedCtor() { } Expression_WindowFunction_Bound_CurrentRow::~Expression_WindowFunction_Bound_CurrentRow() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.CurrentRow) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5671,7 +5640,7 @@ void Expression_WindowFunction_Bound_CurrentRow::SetCachedSize(int size) const { } void Expression_WindowFunction_Bound_CurrentRow::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.CurrentRow) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5705,7 +5674,7 @@ const char* Expression_WindowFunction_Bound_CurrentRow::_InternalParse(const cha ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_CurrentRow::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.CurrentRow) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -5713,12 +5682,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_CurrentRow::_Int target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound.CurrentRow) return target; } size_t Expression_WindowFunction_Bound_CurrentRow::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.CurrentRow) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5735,22 +5704,22 @@ size_t Expression_WindowFunction_Bound_CurrentRow::ByteSizeLong() const { } void Expression_WindowFunction_Bound_CurrentRow::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction.Bound.CurrentRow) GOOGLE_DCHECK_NE(&from, this); const Expression_WindowFunction_Bound_CurrentRow* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction.Bound.CurrentRow) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction.Bound.CurrentRow) MergeFrom(*source); } } void Expression_WindowFunction_Bound_CurrentRow::MergeFrom(const Expression_WindowFunction_Bound_CurrentRow& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.CurrentRow) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5759,14 +5728,14 @@ void Expression_WindowFunction_Bound_CurrentRow::MergeFrom(const Expression_Wind } void Expression_WindowFunction_Bound_CurrentRow::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction.Bound.CurrentRow) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_WindowFunction_Bound_CurrentRow::CopyFrom(const Expression_WindowFunction_Bound_CurrentRow& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction.Bound.CurrentRow) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.CurrentRow) if (&from == this) return; Clear(); MergeFrom(from); @@ -5783,8 +5752,8 @@ void Expression_WindowFunction_Bound_CurrentRow::InternalSwap(Expression_WindowF ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_CurrentRow::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[14]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[14]); } // =================================================================== @@ -5797,19 +5766,19 @@ Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbou : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound.Unbounded) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Unbounded) } Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(const Expression_WindowFunction_Bound_Unbounded& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound.Unbounded) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Unbounded) } void Expression_WindowFunction_Bound_Unbounded::SharedCtor() { } Expression_WindowFunction_Bound_Unbounded::~Expression_WindowFunction_Bound_Unbounded() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound.Unbounded) + // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.Unbounded) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5829,7 +5798,7 @@ void Expression_WindowFunction_Bound_Unbounded::SetCachedSize(int size) const { } void Expression_WindowFunction_Bound_Unbounded::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Unbounded) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5863,7 +5832,7 @@ const char* Expression_WindowFunction_Bound_Unbounded::_InternalParse(const char ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Unbounded::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Unbounded) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -5871,12 +5840,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Unbounded::_Inte target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound.Unbounded) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound.Unbounded) return target; } size_t Expression_WindowFunction_Bound_Unbounded::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Unbounded) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5893,22 +5862,22 @@ size_t Expression_WindowFunction_Bound_Unbounded::ByteSizeLong() const { } void Expression_WindowFunction_Bound_Unbounded::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction.Bound.Unbounded) GOOGLE_DCHECK_NE(&from, this); const Expression_WindowFunction_Bound_Unbounded* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction.Bound.Unbounded) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction.Bound.Unbounded) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction.Bound.Unbounded) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction.Bound.Unbounded) MergeFrom(*source); } } void Expression_WindowFunction_Bound_Unbounded::MergeFrom(const Expression_WindowFunction_Bound_Unbounded& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Unbounded) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5917,14 +5886,14 @@ void Expression_WindowFunction_Bound_Unbounded::MergeFrom(const Expression_Windo } void Expression_WindowFunction_Bound_Unbounded::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction.Bound.Unbounded) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_WindowFunction_Bound_Unbounded::CopyFrom(const Expression_WindowFunction_Bound_Unbounded& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction.Bound.Unbounded) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.Unbounded) if (&from == this) return; Clear(); MergeFrom(from); @@ -5941,37 +5910,37 @@ void Expression_WindowFunction_Bound_Unbounded::InternalSwap(Expression_WindowFu ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Unbounded::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[15]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[15]); } // =================================================================== class Expression_WindowFunction_Bound::_Internal { public: - static const ::io::substrait::Expression_WindowFunction_Bound_Preceding& preceding(const Expression_WindowFunction_Bound* msg); - static const ::io::substrait::Expression_WindowFunction_Bound_Following& following(const Expression_WindowFunction_Bound* msg); - static const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row(const Expression_WindowFunction_Bound* msg); - static const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded(const Expression_WindowFunction_Bound* msg); + static const ::substrait::Expression_WindowFunction_Bound_Preceding& preceding(const Expression_WindowFunction_Bound* msg); + static const ::substrait::Expression_WindowFunction_Bound_Following& following(const Expression_WindowFunction_Bound* msg); + static const ::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row(const Expression_WindowFunction_Bound* msg); + static const ::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded(const Expression_WindowFunction_Bound* msg); }; -const ::io::substrait::Expression_WindowFunction_Bound_Preceding& +const ::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::_Internal::preceding(const Expression_WindowFunction_Bound* msg) { return *msg->kind_.preceding_; } -const ::io::substrait::Expression_WindowFunction_Bound_Following& +const ::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::_Internal::following(const Expression_WindowFunction_Bound* msg) { return *msg->kind_.following_; } -const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& +const ::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::_Internal::current_row(const Expression_WindowFunction_Bound* msg) { return *msg->kind_.current_row_; } -const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& +const ::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::_Internal::unbounded(const Expression_WindowFunction_Bound* msg) { return *msg->kind_.unbounded_; } -void Expression_WindowFunction_Bound::set_allocated_preceding(::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { +void Expression_WindowFunction_Bound::set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (preceding) { @@ -5984,9 +5953,9 @@ void Expression_WindowFunction_Bound::set_allocated_preceding(::io::substrait::E set_has_preceding(); kind_.preceding_ = preceding; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.Bound.preceding) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.preceding) } -void Expression_WindowFunction_Bound::set_allocated_following(::io::substrait::Expression_WindowFunction_Bound_Following* following) { +void Expression_WindowFunction_Bound::set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (following) { @@ -5999,9 +5968,9 @@ void Expression_WindowFunction_Bound::set_allocated_following(::io::substrait::E set_has_following(); kind_.following_ = following; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.Bound.following) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.following) } -void Expression_WindowFunction_Bound::set_allocated_current_row(::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { +void Expression_WindowFunction_Bound::set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (current_row) { @@ -6014,9 +5983,9 @@ void Expression_WindowFunction_Bound::set_allocated_current_row(::io::substrait: set_has_current_row(); kind_.current_row_ = current_row; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.Bound.current_row) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.current_row) } -void Expression_WindowFunction_Bound::set_allocated_unbounded(::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { +void Expression_WindowFunction_Bound::set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (unbounded) { @@ -6029,13 +5998,13 @@ void Expression_WindowFunction_Bound::set_allocated_unbounded(::io::substrait::E set_has_unbounded(); kind_.unbounded_ = unbounded; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.Bound.unbounded) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.unbounded) } Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction.Bound) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound) } Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(const Expression_WindowFunction_Bound& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -6043,26 +6012,26 @@ Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(const Expressio clear_has_kind(); switch (from.kind_case()) { case kPreceding: { - _internal_mutable_preceding()->::io::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding()); + _internal_mutable_preceding()->::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding()); break; } case kFollowing: { - _internal_mutable_following()->::io::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following()); + _internal_mutable_following()->::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following()); break; } case kCurrentRow: { - _internal_mutable_current_row()->::io::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row()); + _internal_mutable_current_row()->::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row()); break; } case kUnbounded: { - _internal_mutable_unbounded()->::io::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded()); + _internal_mutable_unbounded()->::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded()); break; } case KIND_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction.Bound) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound) } void Expression_WindowFunction_Bound::SharedCtor() { @@ -6070,7 +6039,7 @@ clear_has_kind(); } Expression_WindowFunction_Bound::~Expression_WindowFunction_Bound() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction.Bound) + // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -6093,7 +6062,7 @@ void Expression_WindowFunction_Bound::SetCachedSize(int size) const { } void Expression_WindowFunction_Bound::clear_kind() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.WindowFunction.Bound) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.WindowFunction.Bound) switch (kind_case()) { case kPreceding: { if (GetArena() == nullptr) { @@ -6128,7 +6097,7 @@ void Expression_WindowFunction_Bound::clear_kind() { void Expression_WindowFunction_Bound::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction.Bound) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6143,28 +6112,28 @@ const char* Expression_WindowFunction_Bound::_InternalParse(const char* ptr, ::P ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; + // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_preceding(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.WindowFunction.Bound.Following following = 2; + // .substrait.Expression.WindowFunction.Bound.Following following = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_following(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; + // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_current_row(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; + // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_unbounded(), ptr); @@ -6196,11 +6165,11 @@ const char* Expression_WindowFunction_Bound::_InternalParse(const char* ptr, ::P ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction.Bound) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; + // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; if (_internal_has_preceding()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6208,7 +6177,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound::_InternalSerial 1, _Internal::preceding(this), target, stream); } - // .io.substrait.Expression.WindowFunction.Bound.Following following = 2; + // .substrait.Expression.WindowFunction.Bound.Following following = 2; if (_internal_has_following()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6216,7 +6185,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound::_InternalSerial 2, _Internal::following(this), target, stream); } - // .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; + // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; if (_internal_has_current_row()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6224,7 +6193,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound::_InternalSerial 3, _Internal::current_row(this), target, stream); } - // .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; + // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; if (_internal_has_unbounded()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6236,12 +6205,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound::_InternalSerial target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction.Bound) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound) return target; } size_t Expression_WindowFunction_Bound::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction.Bound) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -6249,28 +6218,28 @@ size_t Expression_WindowFunction_Bound::ByteSizeLong() const { (void) cached_has_bits; switch (kind_case()) { - // .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; + // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; case kPreceding: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.preceding_); break; } - // .io.substrait.Expression.WindowFunction.Bound.Following following = 2; + // .substrait.Expression.WindowFunction.Bound.Following following = 2; case kFollowing: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.following_); break; } - // .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; + // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; case kCurrentRow: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.current_row_); break; } - // .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; + // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; case kUnbounded: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -6291,22 +6260,22 @@ size_t Expression_WindowFunction_Bound::ByteSizeLong() const { } void Expression_WindowFunction_Bound::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction.Bound) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction.Bound) GOOGLE_DCHECK_NE(&from, this); const Expression_WindowFunction_Bound* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction.Bound) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction.Bound) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction.Bound) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction.Bound) MergeFrom(*source); } } void Expression_WindowFunction_Bound::MergeFrom(const Expression_WindowFunction_Bound& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction.Bound) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -6314,19 +6283,19 @@ void Expression_WindowFunction_Bound::MergeFrom(const Expression_WindowFunction_ switch (from.kind_case()) { case kPreceding: { - _internal_mutable_preceding()->::io::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding()); + _internal_mutable_preceding()->::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding()); break; } case kFollowing: { - _internal_mutable_following()->::io::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following()); + _internal_mutable_following()->::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following()); break; } case kCurrentRow: { - _internal_mutable_current_row()->::io::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row()); + _internal_mutable_current_row()->::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row()); break; } case kUnbounded: { - _internal_mutable_unbounded()->::io::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded()); + _internal_mutable_unbounded()->::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded()); break; } case KIND_NOT_SET: { @@ -6336,14 +6305,14 @@ void Expression_WindowFunction_Bound::MergeFrom(const Expression_WindowFunction_ } void Expression_WindowFunction_Bound::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction.Bound) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction.Bound) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_WindowFunction_Bound::CopyFrom(const Expression_WindowFunction_Bound& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction.Bound) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound) if (&from == this) return; Clear(); MergeFrom(from); @@ -6362,28 +6331,28 @@ void Expression_WindowFunction_Bound::InternalSwap(Expression_WindowFunction_Bou ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[16]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[16]); } // =================================================================== class Expression_WindowFunction::_Internal { public: - static const ::io::substrait::Expression_WindowFunction_Bound& upper_bound(const Expression_WindowFunction* msg); - static const ::io::substrait::Expression_WindowFunction_Bound& lower_bound(const Expression_WindowFunction* msg); - static const ::io::substrait::Type& output_type(const Expression_WindowFunction* msg); + static const ::substrait::Expression_WindowFunction_Bound& upper_bound(const Expression_WindowFunction* msg); + static const ::substrait::Expression_WindowFunction_Bound& lower_bound(const Expression_WindowFunction* msg); + static const ::substrait::Type& output_type(const Expression_WindowFunction* msg); }; -const ::io::substrait::Expression_WindowFunction_Bound& +const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_Internal::upper_bound(const Expression_WindowFunction* msg) { return *msg->upper_bound_; } -const ::io::substrait::Expression_WindowFunction_Bound& +const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_Internal::lower_bound(const Expression_WindowFunction* msg) { return *msg->lower_bound_; } -const ::io::substrait::Type& +const ::substrait::Type& Expression_WindowFunction::_Internal::output_type(const Expression_WindowFunction* msg) { return *msg->output_type_; } @@ -6400,7 +6369,7 @@ Expression_WindowFunction::Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Ar args_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.WindowFunction) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction) } Expression_WindowFunction::Expression_WindowFunction(const Expression_WindowFunction& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -6409,24 +6378,24 @@ Expression_WindowFunction::Expression_WindowFunction(const Expression_WindowFunc args_(from.args_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_upper_bound()) { - upper_bound_ = new ::io::substrait::Expression_WindowFunction_Bound(*from.upper_bound_); + upper_bound_ = new ::substrait::Expression_WindowFunction_Bound(*from.upper_bound_); } else { upper_bound_ = nullptr; } if (from._internal_has_lower_bound()) { - lower_bound_ = new ::io::substrait::Expression_WindowFunction_Bound(*from.lower_bound_); + lower_bound_ = new ::substrait::Expression_WindowFunction_Bound(*from.lower_bound_); } else { lower_bound_ = nullptr; } if (from._internal_has_output_type()) { - output_type_ = new ::io::substrait::Type(*from.output_type_); + output_type_ = new ::substrait::Type(*from.output_type_); } else { output_type_ = nullptr; } ::memcpy(&function_reference_, &from.function_reference_, static_cast(reinterpret_cast(&phase_) - reinterpret_cast(&function_reference_)) + sizeof(phase_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.WindowFunction) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction) } void Expression_WindowFunction::SharedCtor() { @@ -6437,7 +6406,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_WindowFunction::~Expression_WindowFunction() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.WindowFunction) + // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -6460,7 +6429,7 @@ void Expression_WindowFunction::SetCachedSize(int size) const { } void Expression_WindowFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.WindowFunction) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6499,7 +6468,7 @@ const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBU CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Expression partitions = 2; + // repeated .substrait.Expression partitions = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -6511,7 +6480,7 @@ const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBU } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; @@ -6523,36 +6492,36 @@ const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBU } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; + // .substrait.Expression.WindowFunction.Bound upper_bound = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_upper_bound(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; + // .substrait.Expression.WindowFunction.Bound lower_bound = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_lower_bound(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.AggregationPhase phase = 6; + // .substrait.AggregationPhase phase = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_phase(static_cast<::io::substrait::AggregationPhase>(val)); + _internal_set_phase(static_cast<::substrait::AggregationPhase>(val)); } else goto handle_unusual; continue; - // .io.substrait.Type output_type = 7; + // .substrait.Type output_type = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Expression args = 8; + // repeated .substrait.Expression args = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { ptr -= 1; @@ -6589,7 +6558,7 @@ const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.WindowFunction) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -6599,7 +6568,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); } - // repeated .io.substrait.Expression partitions = 2; + // repeated .substrait.Expression partitions = 2; for (unsigned int i = 0, n = static_cast(this->_internal_partitions_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -6607,7 +6576,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( InternalWriteMessage(2, this->_internal_partitions(i), target, stream); } - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; for (unsigned int i = 0, n = static_cast(this->_internal_sorts_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -6615,7 +6584,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( InternalWriteMessage(3, this->_internal_sorts(i), target, stream); } - // .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; + // .substrait.Expression.WindowFunction.Bound upper_bound = 4; if (this->has_upper_bound()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6623,7 +6592,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( 4, _Internal::upper_bound(this), target, stream); } - // .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; + // .substrait.Expression.WindowFunction.Bound lower_bound = 5; if (this->has_lower_bound()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6631,14 +6600,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( 5, _Internal::lower_bound(this), target, stream); } - // .io.substrait.AggregationPhase phase = 6; + // .substrait.AggregationPhase phase = 6; if (this->phase() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 6, this->_internal_phase(), target); } - // .io.substrait.Type output_type = 7; + // .substrait.Type output_type = 7; if (this->has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6646,7 +6615,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( 7, _Internal::output_type(this), target, stream); } - // repeated .io.substrait.Expression args = 8; + // repeated .substrait.Expression args = 8; for (unsigned int i = 0, n = static_cast(this->_internal_args_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -6658,54 +6627,54 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.WindowFunction) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction) return target; } size_t Expression_WindowFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.WindowFunction) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression partitions = 2; + // repeated .substrait.Expression partitions = 2; total_size += 1UL * this->_internal_partitions_size(); for (const auto& msg : this->partitions_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; total_size += 1UL * this->_internal_sorts_size(); for (const auto& msg : this->sorts_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.Expression args = 8; + // repeated .substrait.Expression args = 8; total_size += 1UL * this->_internal_args_size(); for (const auto& msg : this->args_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; + // .substrait.Expression.WindowFunction.Bound upper_bound = 4; if (this->has_upper_bound()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *upper_bound_); } - // .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; + // .substrait.Expression.WindowFunction.Bound lower_bound = 5; if (this->has_lower_bound()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *lower_bound_); } - // .io.substrait.Type output_type = 7; + // .substrait.Type output_type = 7; if (this->has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -6719,7 +6688,7 @@ size_t Expression_WindowFunction::ByteSizeLong() const { this->_internal_function_reference()); } - // .io.substrait.AggregationPhase phase = 6; + // .substrait.AggregationPhase phase = 6; if (this->phase() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); @@ -6735,22 +6704,22 @@ size_t Expression_WindowFunction::ByteSizeLong() const { } void Expression_WindowFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.WindowFunction) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction) GOOGLE_DCHECK_NE(&from, this); const Expression_WindowFunction* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.WindowFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.WindowFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction) MergeFrom(*source); } } void Expression_WindowFunction::MergeFrom(const Expression_WindowFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.WindowFunction) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -6760,13 +6729,13 @@ void Expression_WindowFunction::MergeFrom(const Expression_WindowFunction& from) sorts_.MergeFrom(from.sorts_); args_.MergeFrom(from.args_); if (from.has_upper_bound()) { - _internal_mutable_upper_bound()->::io::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_upper_bound()); + _internal_mutable_upper_bound()->::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_upper_bound()); } if (from.has_lower_bound()) { - _internal_mutable_lower_bound()->::io::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_lower_bound()); + _internal_mutable_lower_bound()->::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_lower_bound()); } if (from.has_output_type()) { - _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); } if (from.function_reference() != 0) { _internal_set_function_reference(from._internal_function_reference()); @@ -6777,14 +6746,14 @@ void Expression_WindowFunction::MergeFrom(const Expression_WindowFunction& from) } void Expression_WindowFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.WindowFunction) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_WindowFunction::CopyFrom(const Expression_WindowFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.WindowFunction) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction) if (&from == this) return; Clear(); MergeFrom(from); @@ -6810,23 +6779,23 @@ void Expression_WindowFunction::InternalSwap(Expression_WindowFunction* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[17]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[17]); } // =================================================================== class Expression_IfThen_IfClause::_Internal { public: - static const ::io::substrait::Expression& if_(const Expression_IfThen_IfClause* msg); - static const ::io::substrait::Expression& then(const Expression_IfThen_IfClause* msg); + static const ::substrait::Expression& if_(const Expression_IfThen_IfClause* msg); + static const ::substrait::Expression& then(const Expression_IfThen_IfClause* msg); }; -const ::io::substrait::Expression& +const ::substrait::Expression& Expression_IfThen_IfClause::_Internal::if_(const Expression_IfThen_IfClause* msg) { return *msg->if__; } -const ::io::substrait::Expression& +const ::substrait::Expression& Expression_IfThen_IfClause::_Internal::then(const Expression_IfThen_IfClause* msg) { return *msg->then_; } @@ -6834,22 +6803,22 @@ Expression_IfThen_IfClause::Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID:: : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.IfThen.IfClause) } Expression_IfThen_IfClause::Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_if_()) { - if__ = new ::io::substrait::Expression(*from.if__); + if__ = new ::substrait::Expression(*from.if__); } else { if__ = nullptr; } if (from._internal_has_then()) { - then_ = new ::io::substrait::Expression(*from.then_); + then_ = new ::substrait::Expression(*from.then_); } else { then_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.IfThen.IfClause) } void Expression_IfThen_IfClause::SharedCtor() { @@ -6860,7 +6829,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_IfThen_IfClause::~Expression_IfThen_IfClause() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(destructor:substrait.Expression.IfThen.IfClause) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -6882,7 +6851,7 @@ void Expression_IfThen_IfClause::SetCachedSize(int size) const { } void Expression_IfThen_IfClause::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.IfThen.IfClause) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.IfThen.IfClause) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6904,14 +6873,14 @@ const char* Expression_IfThen_IfClause::_InternalParse(const char* ptr, ::PROTOB ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression if = 1; + // .substrait.Expression if = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression then = 2; + // .substrait.Expression then = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_then(), ptr); @@ -6943,11 +6912,11 @@ const char* Expression_IfThen_IfClause::_InternalParse(const char* ptr, ::PROTOB ::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen_IfClause::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.IfThen.IfClause) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression if = 1; + // .substrait.Expression if = 1; if (this->has_if_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6955,7 +6924,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen_IfClause::_InternalSerialize( 1, _Internal::if_(this), target, stream); } - // .io.substrait.Expression then = 2; + // .substrait.Expression then = 2; if (this->has_then()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6967,26 +6936,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen_IfClause::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.IfThen.IfClause) return target; } size_t Expression_IfThen_IfClause::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.IfThen.IfClause) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.IfThen.IfClause) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression if = 1; + // .substrait.Expression if = 1; if (this->has_if_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *if__); } - // .io.substrait.Expression then = 2; + // .substrait.Expression then = 2; if (this->has_then()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -7003,44 +6972,44 @@ size_t Expression_IfThen_IfClause::ByteSizeLong() const { } void Expression_IfThen_IfClause::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.IfThen.IfClause) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.IfThen.IfClause) GOOGLE_DCHECK_NE(&from, this); const Expression_IfThen_IfClause* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.IfThen.IfClause) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.IfThen.IfClause) MergeFrom(*source); } } void Expression_IfThen_IfClause::MergeFrom(const Expression_IfThen_IfClause& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.IfThen.IfClause) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.IfThen.IfClause) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_if_()) { - _internal_mutable_if_()->::io::substrait::Expression::MergeFrom(from._internal_if_()); + _internal_mutable_if_()->::substrait::Expression::MergeFrom(from._internal_if_()); } if (from.has_then()) { - _internal_mutable_then()->::io::substrait::Expression::MergeFrom(from._internal_then()); + _internal_mutable_then()->::substrait::Expression::MergeFrom(from._internal_then()); } } void Expression_IfThen_IfClause::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.IfThen.IfClause) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.IfThen.IfClause) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_IfThen_IfClause::CopyFrom(const Expression_IfThen_IfClause& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.IfThen.IfClause) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.IfThen.IfClause) if (&from == this) return; Clear(); MergeFrom(from); @@ -7063,18 +7032,18 @@ void Expression_IfThen_IfClause::InternalSwap(Expression_IfThen_IfClause* other) ::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen_IfClause::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[18]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[18]); } // =================================================================== class Expression_IfThen::_Internal { public: - static const ::io::substrait::Expression& else_(const Expression_IfThen* msg); + static const ::substrait::Expression& else_(const Expression_IfThen* msg); }; -const ::io::substrait::Expression& +const ::substrait::Expression& Expression_IfThen::_Internal::else_(const Expression_IfThen* msg) { return *msg->else__; } @@ -7083,18 +7052,18 @@ Expression_IfThen::Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena) ifs_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.IfThen) } Expression_IfThen::Expression_IfThen(const Expression_IfThen& from) : ::PROTOBUF_NAMESPACE_ID::Message(), ifs_(from.ifs_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_else_()) { - else__ = new ::io::substrait::Expression(*from.else__); + else__ = new ::substrait::Expression(*from.else__); } else { else__ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.IfThen) } void Expression_IfThen::SharedCtor() { @@ -7102,7 +7071,7 @@ else__ = nullptr; } Expression_IfThen::~Expression_IfThen() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(destructor:substrait.Expression.IfThen) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -7123,7 +7092,7 @@ void Expression_IfThen::SetCachedSize(int size) const { } void Expression_IfThen::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.IfThen) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.IfThen) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7142,7 +7111,7 @@ const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + // repeated .substrait.Expression.IfThen.IfClause ifs = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -7154,7 +7123,7 @@ const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Expression else = 2; + // .substrait.Expression else = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr); @@ -7186,11 +7155,11 @@ const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.IfThen) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + // repeated .substrait.Expression.IfThen.IfClause ifs = 1; for (unsigned int i = 0, n = static_cast(this->_internal_ifs_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -7198,7 +7167,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen::_InternalSerialize( InternalWriteMessage(1, this->_internal_ifs(i), target, stream); } - // .io.substrait.Expression else = 2; + // .substrait.Expression else = 2; if (this->has_else_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7210,26 +7179,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.IfThen) return target; } size_t Expression_IfThen::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.IfThen) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.IfThen) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + // repeated .substrait.Expression.IfThen.IfClause ifs = 1; total_size += 1UL * this->_internal_ifs_size(); for (const auto& msg : this->ifs_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Expression else = 2; + // .substrait.Expression else = 2; if (this->has_else_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -7246,22 +7215,22 @@ size_t Expression_IfThen::ByteSizeLong() const { } void Expression_IfThen::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.IfThen) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.IfThen) GOOGLE_DCHECK_NE(&from, this); const Expression_IfThen* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.IfThen) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.IfThen) MergeFrom(*source); } } void Expression_IfThen::MergeFrom(const Expression_IfThen& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.IfThen) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.IfThen) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -7269,19 +7238,19 @@ void Expression_IfThen::MergeFrom(const Expression_IfThen& from) { ifs_.MergeFrom(from.ifs_); if (from.has_else_()) { - _internal_mutable_else_()->::io::substrait::Expression::MergeFrom(from._internal_else_()); + _internal_mutable_else_()->::substrait::Expression::MergeFrom(from._internal_else_()); } } void Expression_IfThen::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.IfThen) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.IfThen) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_IfThen::CopyFrom(const Expression_IfThen& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.IfThen) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.IfThen) if (&from == this) return; Clear(); MergeFrom(from); @@ -7300,23 +7269,23 @@ void Expression_IfThen::InternalSwap(Expression_IfThen* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[19]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[19]); } // =================================================================== class Expression_Cast::_Internal { public: - static const ::io::substrait::Type& type(const Expression_Cast* msg); - static const ::io::substrait::Expression& input(const Expression_Cast* msg); + static const ::substrait::Type& type(const Expression_Cast* msg); + static const ::substrait::Expression& input(const Expression_Cast* msg); }; -const ::io::substrait::Type& +const ::substrait::Type& Expression_Cast::_Internal::type(const Expression_Cast* msg) { return *msg->type_; } -const ::io::substrait::Expression& +const ::substrait::Expression& Expression_Cast::_Internal::input(const Expression_Cast* msg) { return *msg->input_; } @@ -7330,22 +7299,22 @@ Expression_Cast::Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.Cast) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.Cast) } Expression_Cast::Expression_Cast(const Expression_Cast& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_type()) { - type_ = new ::io::substrait::Type(*from.type_); + type_ = new ::substrait::Type(*from.type_); } else { type_ = nullptr; } if (from._internal_has_input()) { - input_ = new ::io::substrait::Expression(*from.input_); + input_ = new ::substrait::Expression(*from.input_); } else { input_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.Cast) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.Cast) } void Expression_Cast::SharedCtor() { @@ -7356,7 +7325,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_Cast::~Expression_Cast() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.Cast) + // @@protoc_insertion_point(destructor:substrait.Expression.Cast) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -7378,7 +7347,7 @@ void Expression_Cast::SetCachedSize(int size) const { } void Expression_Cast::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.Cast) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.Cast) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7400,14 +7369,14 @@ const char* Expression_Cast::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPAC ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type type = 1; + // .substrait.Type type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression input = 2; + // .substrait.Expression input = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); @@ -7439,11 +7408,11 @@ const char* Expression_Cast::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPAC ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Cast::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.Cast) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Cast) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type type = 1; + // .substrait.Type type = 1; if (this->has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7451,7 +7420,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Cast::_InternalSerialize( 1, _Internal::type(this), target, stream); } - // .io.substrait.Expression input = 2; + // .substrait.Expression input = 2; if (this->has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7463,26 +7432,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Cast::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.Cast) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Cast) return target; } size_t Expression_Cast::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.Cast) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Cast) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type type = 1; + // .substrait.Type type = 1; if (this->has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *type_); } - // .io.substrait.Expression input = 2; + // .substrait.Expression input = 2; if (this->has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -7499,44 +7468,44 @@ size_t Expression_Cast::ByteSizeLong() const { } void Expression_Cast::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.Cast) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Cast) GOOGLE_DCHECK_NE(&from, this); const Expression_Cast* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.Cast) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Cast) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.Cast) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Cast) MergeFrom(*source); } } void Expression_Cast::MergeFrom(const Expression_Cast& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.Cast) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Cast) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_type()) { - _internal_mutable_type()->::io::substrait::Type::MergeFrom(from._internal_type()); + _internal_mutable_type()->::substrait::Type::MergeFrom(from._internal_type()); } if (from.has_input()) { - _internal_mutable_input()->::io::substrait::Expression::MergeFrom(from._internal_input()); + _internal_mutable_input()->::substrait::Expression::MergeFrom(from._internal_input()); } } void Expression_Cast::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.Cast) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Cast) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_Cast::CopyFrom(const Expression_Cast& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.Cast) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Cast) if (&from == this) return; Clear(); MergeFrom(from); @@ -7559,23 +7528,23 @@ void Expression_Cast::InternalSwap(Expression_Cast* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Cast::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[20]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[20]); } // =================================================================== class Expression_SwitchExpression_IfValue::_Internal { public: - static const ::io::substrait::Expression_Literal& if_(const Expression_SwitchExpression_IfValue* msg); - static const ::io::substrait::Expression& then(const Expression_SwitchExpression_IfValue* msg); + static const ::substrait::Expression_Literal& if_(const Expression_SwitchExpression_IfValue* msg); + static const ::substrait::Expression& then(const Expression_SwitchExpression_IfValue* msg); }; -const ::io::substrait::Expression_Literal& +const ::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::_Internal::if_(const Expression_SwitchExpression_IfValue* msg) { return *msg->if__; } -const ::io::substrait::Expression& +const ::substrait::Expression& Expression_SwitchExpression_IfValue::_Internal::then(const Expression_SwitchExpression_IfValue* msg) { return *msg->then_; } @@ -7583,22 +7552,22 @@ Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(::PROTO : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.SwitchExpression.IfValue) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.SwitchExpression.IfValue) } Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(const Expression_SwitchExpression_IfValue& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_if_()) { - if__ = new ::io::substrait::Expression_Literal(*from.if__); + if__ = new ::substrait::Expression_Literal(*from.if__); } else { if__ = nullptr; } if (from._internal_has_then()) { - then_ = new ::io::substrait::Expression(*from.then_); + then_ = new ::substrait::Expression(*from.then_); } else { then_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.SwitchExpression.IfValue) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.SwitchExpression.IfValue) } void Expression_SwitchExpression_IfValue::SharedCtor() { @@ -7609,7 +7578,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_SwitchExpression_IfValue::~Expression_SwitchExpression_IfValue() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.SwitchExpression.IfValue) + // @@protoc_insertion_point(destructor:substrait.Expression.SwitchExpression.IfValue) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -7631,7 +7600,7 @@ void Expression_SwitchExpression_IfValue::SetCachedSize(int size) const { } void Expression_SwitchExpression_IfValue::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.SwitchExpression.IfValue) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.SwitchExpression.IfValue) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7653,14 +7622,14 @@ const char* Expression_SwitchExpression_IfValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.Literal if = 1; + // .substrait.Expression.Literal if = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression then = 2; + // .substrait.Expression then = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_then(), ptr); @@ -7692,11 +7661,11 @@ const char* Expression_SwitchExpression_IfValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression_IfValue::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.SwitchExpression.IfValue) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SwitchExpression.IfValue) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.Literal if = 1; + // .substrait.Expression.Literal if = 1; if (this->has_if_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7704,7 +7673,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression_IfValue::_InternalSe 1, _Internal::if_(this), target, stream); } - // .io.substrait.Expression then = 2; + // .substrait.Expression then = 2; if (this->has_then()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7716,26 +7685,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression_IfValue::_InternalSe target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.SwitchExpression.IfValue) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.SwitchExpression.IfValue) return target; } size_t Expression_SwitchExpression_IfValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.SwitchExpression.IfValue) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SwitchExpression.IfValue) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression.Literal if = 1; + // .substrait.Expression.Literal if = 1; if (this->has_if_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *if__); } - // .io.substrait.Expression then = 2; + // .substrait.Expression then = 2; if (this->has_then()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -7752,44 +7721,44 @@ size_t Expression_SwitchExpression_IfValue::ByteSizeLong() const { } void Expression_SwitchExpression_IfValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.SwitchExpression.IfValue) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.SwitchExpression.IfValue) GOOGLE_DCHECK_NE(&from, this); const Expression_SwitchExpression_IfValue* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.SwitchExpression.IfValue) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.SwitchExpression.IfValue) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.SwitchExpression.IfValue) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.SwitchExpression.IfValue) MergeFrom(*source); } } void Expression_SwitchExpression_IfValue::MergeFrom(const Expression_SwitchExpression_IfValue& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.SwitchExpression.IfValue) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SwitchExpression.IfValue) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_if_()) { - _internal_mutable_if_()->::io::substrait::Expression_Literal::MergeFrom(from._internal_if_()); + _internal_mutable_if_()->::substrait::Expression_Literal::MergeFrom(from._internal_if_()); } if (from.has_then()) { - _internal_mutable_then()->::io::substrait::Expression::MergeFrom(from._internal_then()); + _internal_mutable_then()->::substrait::Expression::MergeFrom(from._internal_then()); } } void Expression_SwitchExpression_IfValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.SwitchExpression.IfValue) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.SwitchExpression.IfValue) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_SwitchExpression_IfValue::CopyFrom(const Expression_SwitchExpression_IfValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.SwitchExpression.IfValue) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.SwitchExpression.IfValue) if (&from == this) return; Clear(); MergeFrom(from); @@ -7812,18 +7781,18 @@ void Expression_SwitchExpression_IfValue::InternalSwap(Expression_SwitchExpressi ::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression_IfValue::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[21]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[21]); } // =================================================================== class Expression_SwitchExpression::_Internal { public: - static const ::io::substrait::Expression& else_(const Expression_SwitchExpression* msg); + static const ::substrait::Expression& else_(const Expression_SwitchExpression* msg); }; -const ::io::substrait::Expression& +const ::substrait::Expression& Expression_SwitchExpression::_Internal::else_(const Expression_SwitchExpression* msg) { return *msg->else__; } @@ -7832,18 +7801,18 @@ Expression_SwitchExpression::Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID ifs_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.SwitchExpression) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.SwitchExpression) } Expression_SwitchExpression::Expression_SwitchExpression(const Expression_SwitchExpression& from) : ::PROTOBUF_NAMESPACE_ID::Message(), ifs_(from.ifs_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_else_()) { - else__ = new ::io::substrait::Expression(*from.else__); + else__ = new ::substrait::Expression(*from.else__); } else { else__ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.SwitchExpression) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.SwitchExpression) } void Expression_SwitchExpression::SharedCtor() { @@ -7851,7 +7820,7 @@ else__ = nullptr; } Expression_SwitchExpression::~Expression_SwitchExpression() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.SwitchExpression) + // @@protoc_insertion_point(destructor:substrait.Expression.SwitchExpression) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -7872,7 +7841,7 @@ void Expression_SwitchExpression::SetCachedSize(int size) const { } void Expression_SwitchExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.SwitchExpression) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.SwitchExpression) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7891,7 +7860,7 @@ const char* Expression_SwitchExpression::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; + // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -7903,7 +7872,7 @@ const char* Expression_SwitchExpression::_InternalParse(const char* ptr, ::PROTO } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Expression else = 2; + // .substrait.Expression else = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr); @@ -7935,11 +7904,11 @@ const char* Expression_SwitchExpression::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.SwitchExpression) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SwitchExpression) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; + // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; for (unsigned int i = 0, n = static_cast(this->_internal_ifs_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -7947,7 +7916,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression::_InternalSerialize( InternalWriteMessage(1, this->_internal_ifs(i), target, stream); } - // .io.substrait.Expression else = 2; + // .substrait.Expression else = 2; if (this->has_else_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7959,26 +7928,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.SwitchExpression) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.SwitchExpression) return target; } size_t Expression_SwitchExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.SwitchExpression) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SwitchExpression) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; + // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; total_size += 1UL * this->_internal_ifs_size(); for (const auto& msg : this->ifs_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Expression else = 2; + // .substrait.Expression else = 2; if (this->has_else_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -7995,22 +7964,22 @@ size_t Expression_SwitchExpression::ByteSizeLong() const { } void Expression_SwitchExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.SwitchExpression) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.SwitchExpression) GOOGLE_DCHECK_NE(&from, this); const Expression_SwitchExpression* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.SwitchExpression) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.SwitchExpression) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.SwitchExpression) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.SwitchExpression) MergeFrom(*source); } } void Expression_SwitchExpression::MergeFrom(const Expression_SwitchExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.SwitchExpression) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SwitchExpression) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -8018,19 +7987,19 @@ void Expression_SwitchExpression::MergeFrom(const Expression_SwitchExpression& f ifs_.MergeFrom(from.ifs_); if (from.has_else_()) { - _internal_mutable_else_()->::io::substrait::Expression::MergeFrom(from._internal_else_()); + _internal_mutable_else_()->::substrait::Expression::MergeFrom(from._internal_else_()); } } void Expression_SwitchExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.SwitchExpression) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.SwitchExpression) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_SwitchExpression::CopyFrom(const Expression_SwitchExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.SwitchExpression) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.SwitchExpression) if (&from == this) return; Clear(); MergeFrom(from); @@ -8049,18 +8018,18 @@ void Expression_SwitchExpression::InternalSwap(Expression_SwitchExpression* othe ::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[22]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[22]); } // =================================================================== class Expression_SingularOrList::_Internal { public: - static const ::io::substrait::Expression& value(const Expression_SingularOrList* msg); + static const ::substrait::Expression& value(const Expression_SingularOrList* msg); }; -const ::io::substrait::Expression& +const ::substrait::Expression& Expression_SingularOrList::_Internal::value(const Expression_SingularOrList* msg) { return *msg->value_; } @@ -8069,18 +8038,18 @@ Expression_SingularOrList::Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Ar options_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.SingularOrList) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.SingularOrList) } Expression_SingularOrList::Expression_SingularOrList(const Expression_SingularOrList& from) : ::PROTOBUF_NAMESPACE_ID::Message(), options_(from.options_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_value()) { - value_ = new ::io::substrait::Expression(*from.value_); + value_ = new ::substrait::Expression(*from.value_); } else { value_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.SingularOrList) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.SingularOrList) } void Expression_SingularOrList::SharedCtor() { @@ -8088,7 +8057,7 @@ value_ = nullptr; } Expression_SingularOrList::~Expression_SingularOrList() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.SingularOrList) + // @@protoc_insertion_point(destructor:substrait.Expression.SingularOrList) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -8109,7 +8078,7 @@ void Expression_SingularOrList::SetCachedSize(int size) const { } void Expression_SingularOrList::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.SingularOrList) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.SingularOrList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8128,14 +8097,14 @@ const char* Expression_SingularOrList::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression value = 1; + // .substrait.Expression value = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Expression options = 2; + // repeated .substrait.Expression options = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -8172,11 +8141,11 @@ const char* Expression_SingularOrList::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SingularOrList::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.SingularOrList) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SingularOrList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression value = 1; + // .substrait.Expression value = 1; if (this->has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -8184,7 +8153,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SingularOrList::_InternalSerialize( 1, _Internal::value(this), target, stream); } - // repeated .io.substrait.Expression options = 2; + // repeated .substrait.Expression options = 2; for (unsigned int i = 0, n = static_cast(this->_internal_options_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -8196,26 +8165,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SingularOrList::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.SingularOrList) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.SingularOrList) return target; } size_t Expression_SingularOrList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.SingularOrList) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SingularOrList) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression options = 2; + // repeated .substrait.Expression options = 2; total_size += 1UL * this->_internal_options_size(); for (const auto& msg : this->options_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Expression value = 1; + // .substrait.Expression value = 1; if (this->has_value()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -8232,22 +8201,22 @@ size_t Expression_SingularOrList::ByteSizeLong() const { } void Expression_SingularOrList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.SingularOrList) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.SingularOrList) GOOGLE_DCHECK_NE(&from, this); const Expression_SingularOrList* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.SingularOrList) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.SingularOrList) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.SingularOrList) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.SingularOrList) MergeFrom(*source); } } void Expression_SingularOrList::MergeFrom(const Expression_SingularOrList& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.SingularOrList) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SingularOrList) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -8255,19 +8224,19 @@ void Expression_SingularOrList::MergeFrom(const Expression_SingularOrList& from) options_.MergeFrom(from.options_); if (from.has_value()) { - _internal_mutable_value()->::io::substrait::Expression::MergeFrom(from._internal_value()); + _internal_mutable_value()->::substrait::Expression::MergeFrom(from._internal_value()); } } void Expression_SingularOrList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.SingularOrList) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.SingularOrList) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_SingularOrList::CopyFrom(const Expression_SingularOrList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.SingularOrList) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.SingularOrList) if (&from == this) return; Clear(); MergeFrom(from); @@ -8286,8 +8255,8 @@ void Expression_SingularOrList::InternalSwap(Expression_SingularOrList* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_SingularOrList::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[23]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[23]); } // =================================================================== @@ -8301,20 +8270,20 @@ Expression_MultiOrList_Record::Expression_MultiOrList_Record(::PROTOBUF_NAMESPAC fields_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MultiOrList.Record) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MultiOrList.Record) } Expression_MultiOrList_Record::Expression_MultiOrList_Record(const Expression_MultiOrList_Record& from) : ::PROTOBUF_NAMESPACE_ID::Message(), fields_(from.fields_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MultiOrList.Record) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MultiOrList.Record) } void Expression_MultiOrList_Record::SharedCtor() { } Expression_MultiOrList_Record::~Expression_MultiOrList_Record() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MultiOrList.Record) + // @@protoc_insertion_point(destructor:substrait.Expression.MultiOrList.Record) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -8334,7 +8303,7 @@ void Expression_MultiOrList_Record::SetCachedSize(int size) const { } void Expression_MultiOrList_Record::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MultiOrList.Record) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MultiOrList.Record) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8349,7 +8318,7 @@ const char* Expression_MultiOrList_Record::_InternalParse(const char* ptr, ::PRO ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression fields = 1; + // repeated .substrait.Expression fields = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -8386,11 +8355,11 @@ const char* Expression_MultiOrList_Record::_InternalParse(const char* ptr, ::PRO ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MultiOrList_Record::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MultiOrList.Record) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MultiOrList.Record) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression fields = 1; + // repeated .substrait.Expression fields = 1; for (unsigned int i = 0, n = static_cast(this->_internal_fields_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -8402,19 +8371,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MultiOrList_Record::_InternalSerializ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MultiOrList.Record) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MultiOrList.Record) return target; } size_t Expression_MultiOrList_Record::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MultiOrList.Record) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MultiOrList.Record) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression fields = 1; + // repeated .substrait.Expression fields = 1; total_size += 1UL * this->_internal_fields_size(); for (const auto& msg : this->fields_) { total_size += @@ -8431,22 +8400,22 @@ size_t Expression_MultiOrList_Record::ByteSizeLong() const { } void Expression_MultiOrList_Record::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MultiOrList.Record) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MultiOrList.Record) GOOGLE_DCHECK_NE(&from, this); const Expression_MultiOrList_Record* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MultiOrList.Record) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MultiOrList.Record) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MultiOrList.Record) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MultiOrList.Record) MergeFrom(*source); } } void Expression_MultiOrList_Record::MergeFrom(const Expression_MultiOrList_Record& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MultiOrList.Record) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MultiOrList.Record) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -8456,14 +8425,14 @@ void Expression_MultiOrList_Record::MergeFrom(const Expression_MultiOrList_Recor } void Expression_MultiOrList_Record::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MultiOrList.Record) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MultiOrList.Record) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MultiOrList_Record::CopyFrom(const Expression_MultiOrList_Record& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MultiOrList.Record) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MultiOrList.Record) if (&from == this) return; Clear(); MergeFrom(from); @@ -8481,8 +8450,8 @@ void Expression_MultiOrList_Record::InternalSwap(Expression_MultiOrList_Record* ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList_Record::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[24]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[24]); } // =================================================================== @@ -8497,21 +8466,21 @@ Expression_MultiOrList::Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* a options_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MultiOrList) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MultiOrList) } Expression_MultiOrList::Expression_MultiOrList(const Expression_MultiOrList& from) : ::PROTOBUF_NAMESPACE_ID::Message(), value_(from.value_), options_(from.options_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MultiOrList) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MultiOrList) } void Expression_MultiOrList::SharedCtor() { } Expression_MultiOrList::~Expression_MultiOrList() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MultiOrList) + // @@protoc_insertion_point(destructor:substrait.Expression.MultiOrList) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -8531,7 +8500,7 @@ void Expression_MultiOrList::SetCachedSize(int size) const { } void Expression_MultiOrList::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MultiOrList) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MultiOrList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8547,7 +8516,7 @@ const char* Expression_MultiOrList::_InternalParse(const char* ptr, ::PROTOBUF_N ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression value = 1; + // repeated .substrait.Expression value = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -8559,7 +8528,7 @@ const char* Expression_MultiOrList::_InternalParse(const char* ptr, ::PROTOBUF_N } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // repeated .io.substrait.Expression.MultiOrList.Record options = 2; + // repeated .substrait.Expression.MultiOrList.Record options = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -8596,11 +8565,11 @@ const char* Expression_MultiOrList::_InternalParse(const char* ptr, ::PROTOBUF_N ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MultiOrList::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MultiOrList) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MultiOrList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression value = 1; + // repeated .substrait.Expression value = 1; for (unsigned int i = 0, n = static_cast(this->_internal_value_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -8608,7 +8577,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MultiOrList::_InternalSerialize( InternalWriteMessage(1, this->_internal_value(i), target, stream); } - // repeated .io.substrait.Expression.MultiOrList.Record options = 2; + // repeated .substrait.Expression.MultiOrList.Record options = 2; for (unsigned int i = 0, n = static_cast(this->_internal_options_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -8620,26 +8589,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MultiOrList::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MultiOrList) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MultiOrList) return target; } size_t Expression_MultiOrList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MultiOrList) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MultiOrList) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression value = 1; + // repeated .substrait.Expression value = 1; total_size += 1UL * this->_internal_value_size(); for (const auto& msg : this->value_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.Expression.MultiOrList.Record options = 2; + // repeated .substrait.Expression.MultiOrList.Record options = 2; total_size += 1UL * this->_internal_options_size(); for (const auto& msg : this->options_) { total_size += @@ -8656,22 +8625,22 @@ size_t Expression_MultiOrList::ByteSizeLong() const { } void Expression_MultiOrList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MultiOrList) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MultiOrList) GOOGLE_DCHECK_NE(&from, this); const Expression_MultiOrList* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MultiOrList) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MultiOrList) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MultiOrList) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MultiOrList) MergeFrom(*source); } } void Expression_MultiOrList::MergeFrom(const Expression_MultiOrList& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MultiOrList) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MultiOrList) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -8682,14 +8651,14 @@ void Expression_MultiOrList::MergeFrom(const Expression_MultiOrList& from) { } void Expression_MultiOrList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MultiOrList) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MultiOrList) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MultiOrList::CopyFrom(const Expression_MultiOrList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MultiOrList) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MultiOrList) if (&from == this) return; Clear(); MergeFrom(from); @@ -8708,8 +8677,8 @@ void Expression_MultiOrList::InternalSwap(Expression_MultiOrList* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[25]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[25]); } // =================================================================== @@ -8723,7 +8692,7 @@ Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_Py prerequisite_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction) } Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(const Expression_EmbeddedFunction_PythonPickleFunction& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -8734,7 +8703,7 @@ Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_Py function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_function(), GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction) } void Expression_EmbeddedFunction_PythonPickleFunction::SharedCtor() { @@ -8742,7 +8711,7 @@ function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlr } Expression_EmbeddedFunction_PythonPickleFunction::~Expression_EmbeddedFunction_PythonPickleFunction() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -8763,7 +8732,7 @@ void Expression_EmbeddedFunction_PythonPickleFunction::SetCachedSize(int size) c } void Expression_EmbeddedFunction_PythonPickleFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8795,7 +8764,7 @@ const char* Expression_EmbeddedFunction_PythonPickleFunction::_InternalParse(con ptr += 1; auto str = _internal_add_prerequisite(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); @@ -8826,7 +8795,7 @@ const char* Expression_EmbeddedFunction_PythonPickleFunction::_InternalParse(con ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction_PythonPickleFunction::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -8842,7 +8811,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction_PythonPickleFunction ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite"); + "substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite"); target = stream->WriteString(2, s, target); } @@ -8850,12 +8819,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction_PythonPickleFunction target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.EmbeddedFunction.PythonPickleFunction) return target; } size_t Expression_EmbeddedFunction_PythonPickleFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -8887,22 +8856,22 @@ size_t Expression_EmbeddedFunction_PythonPickleFunction::ByteSizeLong() const { } void Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) GOOGLE_DCHECK_NE(&from, this); const Expression_EmbeddedFunction_PythonPickleFunction* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.EmbeddedFunction.PythonPickleFunction) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.EmbeddedFunction.PythonPickleFunction) MergeFrom(*source); } } void Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -8915,14 +8884,14 @@ void Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(const Expressio } void Expression_EmbeddedFunction_PythonPickleFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_EmbeddedFunction_PythonPickleFunction::CopyFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) if (&from == this) return; Clear(); MergeFrom(from); @@ -8941,8 +8910,8 @@ void Expression_EmbeddedFunction_PythonPickleFunction::InternalSwap(Expression_E ::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_PythonPickleFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[26]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[26]); } // =================================================================== @@ -8956,7 +8925,7 @@ Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_Web prerequisite_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) } Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(const Expression_EmbeddedFunction_WebAssemblyFunction& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -8967,7 +8936,7 @@ Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_Web script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_script(), GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) } void Expression_EmbeddedFunction_WebAssemblyFunction::SharedCtor() { @@ -8975,7 +8944,7 @@ script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlrea } Expression_EmbeddedFunction_WebAssemblyFunction::~Expression_EmbeddedFunction_WebAssemblyFunction() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -8996,7 +8965,7 @@ void Expression_EmbeddedFunction_WebAssemblyFunction::SetCachedSize(int size) co } void Expression_EmbeddedFunction_WebAssemblyFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -9028,7 +8997,7 @@ const char* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalParse(cons ptr += 1; auto str = _internal_add_prerequisite(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); @@ -9059,7 +9028,7 @@ const char* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalParse(cons ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -9075,7 +9044,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction_WebAssemblyFunction: ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite"); + "substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite"); target = stream->WriteString(2, s, target); } @@ -9083,12 +9052,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction_WebAssemblyFunction: target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) return target; } size_t Expression_EmbeddedFunction_WebAssemblyFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -9120,22 +9089,22 @@ size_t Expression_EmbeddedFunction_WebAssemblyFunction::ByteSizeLong() const { } void Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) GOOGLE_DCHECK_NE(&from, this); const Expression_EmbeddedFunction_WebAssemblyFunction* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) MergeFrom(*source); } } void Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -9148,14 +9117,14 @@ void Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(const Expression } void Expression_EmbeddedFunction_WebAssemblyFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_EmbeddedFunction_WebAssemblyFunction::CopyFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) if (&from == this) return; Clear(); MergeFrom(from); @@ -9174,28 +9143,28 @@ void Expression_EmbeddedFunction_WebAssemblyFunction::InternalSwap(Expression_Em ::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_WebAssemblyFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[27]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[27]); } // =================================================================== class Expression_EmbeddedFunction::_Internal { public: - static const ::io::substrait::Type& output_type(const Expression_EmbeddedFunction* msg); - static const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function(const Expression_EmbeddedFunction* msg); - static const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function(const Expression_EmbeddedFunction* msg); + static const ::substrait::Type& output_type(const Expression_EmbeddedFunction* msg); + static const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function(const Expression_EmbeddedFunction* msg); + static const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function(const Expression_EmbeddedFunction* msg); }; -const ::io::substrait::Type& +const ::substrait::Type& Expression_EmbeddedFunction::_Internal::output_type(const Expression_EmbeddedFunction* msg) { return *msg->output_type_; } -const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& +const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::_Internal::python_pickle_function(const Expression_EmbeddedFunction* msg) { return *msg->kind_.python_pickle_function_; } -const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& +const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::_Internal::web_assembly_function(const Expression_EmbeddedFunction* msg) { return *msg->kind_.web_assembly_function_; } @@ -9205,7 +9174,7 @@ void Expression_EmbeddedFunction::clear_output_type() { } output_type_ = nullptr; } -void Expression_EmbeddedFunction::set_allocated_python_pickle_function(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { +void Expression_EmbeddedFunction::set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (python_pickle_function) { @@ -9218,9 +9187,9 @@ void Expression_EmbeddedFunction::set_allocated_python_pickle_function(::io::sub set_has_python_pickle_function(); kind_.python_pickle_function_ = python_pickle_function; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.python_pickle_function) } -void Expression_EmbeddedFunction::set_allocated_web_assembly_function(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { +void Expression_EmbeddedFunction::set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (web_assembly_function) { @@ -9233,39 +9202,39 @@ void Expression_EmbeddedFunction::set_allocated_web_assembly_function(::io::subs set_has_web_assembly_function(); kind_.web_assembly_function_ = web_assembly_function; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.web_assembly_function) } Expression_EmbeddedFunction::Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), arguments_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.EmbeddedFunction) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction) } Expression_EmbeddedFunction::Expression_EmbeddedFunction(const Expression_EmbeddedFunction& from) : ::PROTOBUF_NAMESPACE_ID::Message(), arguments_(from.arguments_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_output_type()) { - output_type_ = new ::io::substrait::Type(*from.output_type_); + output_type_ = new ::substrait::Type(*from.output_type_); } else { output_type_ = nullptr; } clear_has_kind(); switch (from.kind_case()) { case kPythonPickleFunction: { - _internal_mutable_python_pickle_function()->::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function()); + _internal_mutable_python_pickle_function()->::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function()); break; } case kWebAssemblyFunction: { - _internal_mutable_web_assembly_function()->::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function()); + _internal_mutable_web_assembly_function()->::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function()); break; } case KIND_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.EmbeddedFunction) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction) } void Expression_EmbeddedFunction::SharedCtor() { @@ -9274,7 +9243,7 @@ clear_has_kind(); } Expression_EmbeddedFunction::~Expression_EmbeddedFunction() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.EmbeddedFunction) + // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -9298,7 +9267,7 @@ void Expression_EmbeddedFunction::SetCachedSize(int size) const { } void Expression_EmbeddedFunction::clear_kind() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.EmbeddedFunction) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.EmbeddedFunction) switch (kind_case()) { case kPythonPickleFunction: { if (GetArena() == nullptr) { @@ -9321,7 +9290,7 @@ void Expression_EmbeddedFunction::clear_kind() { void Expression_EmbeddedFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.EmbeddedFunction) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -9341,7 +9310,7 @@ const char* Expression_EmbeddedFunction::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression arguments = 1; + // repeated .substrait.Expression arguments = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -9353,21 +9322,21 @@ const char* Expression_EmbeddedFunction::_InternalParse(const char* ptr, ::PROTO } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Type output_type = 2; + // .substrait.Type output_type = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; + // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_python_pickle_function(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; + // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_web_assembly_function(), ptr); @@ -9399,11 +9368,11 @@ const char* Expression_EmbeddedFunction::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.EmbeddedFunction) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression arguments = 1; + // repeated .substrait.Expression arguments = 1; for (unsigned int i = 0, n = static_cast(this->_internal_arguments_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -9411,7 +9380,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction::_InternalSerialize( InternalWriteMessage(1, this->_internal_arguments(i), target, stream); } - // .io.substrait.Type output_type = 2; + // .substrait.Type output_type = 2; if (this->has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9419,7 +9388,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction::_InternalSerialize( 2, _Internal::output_type(this), target, stream); } - // .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; + // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; if (_internal_has_python_pickle_function()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9427,7 +9396,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction::_InternalSerialize( 3, _Internal::python_pickle_function(this), target, stream); } - // .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; + // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; if (_internal_has_web_assembly_function()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9439,26 +9408,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.EmbeddedFunction) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.EmbeddedFunction) return target; } size_t Expression_EmbeddedFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.EmbeddedFunction) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression arguments = 1; + // repeated .substrait.Expression arguments = 1; total_size += 1UL * this->_internal_arguments_size(); for (const auto& msg : this->arguments_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Type output_type = 2; + // .substrait.Type output_type = 2; if (this->has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -9466,14 +9435,14 @@ size_t Expression_EmbeddedFunction::ByteSizeLong() const { } switch (kind_case()) { - // .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; + // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; case kPythonPickleFunction: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.python_pickle_function_); break; } - // .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; + // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; case kWebAssemblyFunction: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -9494,22 +9463,22 @@ size_t Expression_EmbeddedFunction::ByteSizeLong() const { } void Expression_EmbeddedFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.EmbeddedFunction) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.EmbeddedFunction) GOOGLE_DCHECK_NE(&from, this); const Expression_EmbeddedFunction* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.EmbeddedFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.EmbeddedFunction) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.EmbeddedFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.EmbeddedFunction) MergeFrom(*source); } } void Expression_EmbeddedFunction::MergeFrom(const Expression_EmbeddedFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.EmbeddedFunction) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -9517,15 +9486,15 @@ void Expression_EmbeddedFunction::MergeFrom(const Expression_EmbeddedFunction& f arguments_.MergeFrom(from.arguments_); if (from.has_output_type()) { - _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); } switch (from.kind_case()) { case kPythonPickleFunction: { - _internal_mutable_python_pickle_function()->::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function()); + _internal_mutable_python_pickle_function()->::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function()); break; } case kWebAssemblyFunction: { - _internal_mutable_web_assembly_function()->::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function()); + _internal_mutable_web_assembly_function()->::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function()); break; } case KIND_NOT_SET: { @@ -9535,14 +9504,14 @@ void Expression_EmbeddedFunction::MergeFrom(const Expression_EmbeddedFunction& f } void Expression_EmbeddedFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.EmbeddedFunction) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.EmbeddedFunction) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_EmbeddedFunction::CopyFrom(const Expression_EmbeddedFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.EmbeddedFunction) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.EmbeddedFunction) if (&from == this) return; Clear(); MergeFrom(from); @@ -9563,23 +9532,23 @@ void Expression_EmbeddedFunction::InternalSwap(Expression_EmbeddedFunction* othe ::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[28]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[28]); } // =================================================================== class Expression_ReferenceSegment_MapKey::_Internal { public: - static const ::io::substrait::Expression_Literal& map_key(const Expression_ReferenceSegment_MapKey* msg); - static const ::io::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_MapKey* msg); + static const ::substrait::Expression_Literal& map_key(const Expression_ReferenceSegment_MapKey* msg); + static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_MapKey* msg); }; -const ::io::substrait::Expression_Literal& +const ::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::_Internal::map_key(const Expression_ReferenceSegment_MapKey* msg) { return *msg->map_key_; } -const ::io::substrait::Expression_ReferenceSegment& +const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::_Internal::child(const Expression_ReferenceSegment_MapKey* msg) { return *msg->child_; } @@ -9587,22 +9556,22 @@ Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(::PROTOBU : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ReferenceSegment.MapKey) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.MapKey) } Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(const Expression_ReferenceSegment_MapKey& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_map_key()) { - map_key_ = new ::io::substrait::Expression_Literal(*from.map_key_); + map_key_ = new ::substrait::Expression_Literal(*from.map_key_); } else { map_key_ = nullptr; } if (from._internal_has_child()) { - child_ = new ::io::substrait::Expression_ReferenceSegment(*from.child_); + child_ = new ::substrait::Expression_ReferenceSegment(*from.child_); } else { child_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ReferenceSegment.MapKey) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.MapKey) } void Expression_ReferenceSegment_MapKey::SharedCtor() { @@ -9613,7 +9582,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_ReferenceSegment_MapKey::~Expression_ReferenceSegment_MapKey() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.ReferenceSegment.MapKey) + // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.MapKey) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -9635,7 +9604,7 @@ void Expression_ReferenceSegment_MapKey::SetCachedSize(int size) const { } void Expression_ReferenceSegment_MapKey::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ReferenceSegment.MapKey) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.MapKey) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -9657,14 +9626,14 @@ const char* Expression_ReferenceSegment_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.Literal map_key = 1; + // .substrait.Expression.Literal map_key = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); @@ -9696,11 +9665,11 @@ const char* Expression_ReferenceSegment_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_MapKey::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ReferenceSegment.MapKey) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.MapKey) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.Literal map_key = 1; + // .substrait.Expression.Literal map_key = 1; if (this->has_map_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9708,7 +9677,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_MapKey::_InternalSer 1, _Internal::map_key(this), target, stream); } - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; if (this->has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9720,26 +9689,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_MapKey::_InternalSer target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ReferenceSegment.MapKey) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment.MapKey) return target; } size_t Expression_ReferenceSegment_MapKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ReferenceSegment.MapKey) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.MapKey) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression.Literal map_key = 1; + // .substrait.Expression.Literal map_key = 1; if (this->has_map_key()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *map_key_); } - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; if (this->has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -9756,44 +9725,44 @@ size_t Expression_ReferenceSegment_MapKey::ByteSizeLong() const { } void Expression_ReferenceSegment_MapKey::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ReferenceSegment.MapKey) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.ReferenceSegment.MapKey) GOOGLE_DCHECK_NE(&from, this); const Expression_ReferenceSegment_MapKey* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ReferenceSegment.MapKey) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.ReferenceSegment.MapKey) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ReferenceSegment.MapKey) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.ReferenceSegment.MapKey) MergeFrom(*source); } } void Expression_ReferenceSegment_MapKey::MergeFrom(const Expression_ReferenceSegment_MapKey& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ReferenceSegment.MapKey) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.MapKey) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_map_key()) { - _internal_mutable_map_key()->::io::substrait::Expression_Literal::MergeFrom(from._internal_map_key()); + _internal_mutable_map_key()->::substrait::Expression_Literal::MergeFrom(from._internal_map_key()); } if (from.has_child()) { - _internal_mutable_child()->::io::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); + _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); } } void Expression_ReferenceSegment_MapKey::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ReferenceSegment.MapKey) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.ReferenceSegment.MapKey) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_ReferenceSegment_MapKey::CopyFrom(const Expression_ReferenceSegment_MapKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ReferenceSegment.MapKey) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment.MapKey) if (&from == this) return; Clear(); MergeFrom(from); @@ -9816,18 +9785,18 @@ void Expression_ReferenceSegment_MapKey::InternalSwap(Expression_ReferenceSegmen ::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_MapKey::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[29]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[29]); } // =================================================================== class Expression_ReferenceSegment_StructField::_Internal { public: - static const ::io::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_StructField* msg); + static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_StructField* msg); }; -const ::io::substrait::Expression_ReferenceSegment& +const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::_Internal::child(const Expression_ReferenceSegment_StructField* msg) { return *msg->child_; } @@ -9835,18 +9804,18 @@ Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ReferenceSegment.StructField) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.StructField) } Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(const Expression_ReferenceSegment_StructField& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_child()) { - child_ = new ::io::substrait::Expression_ReferenceSegment(*from.child_); + child_ = new ::substrait::Expression_ReferenceSegment(*from.child_); } else { child_ = nullptr; } field_ = from.field_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ReferenceSegment.StructField) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.StructField) } void Expression_ReferenceSegment_StructField::SharedCtor() { @@ -9857,7 +9826,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_ReferenceSegment_StructField::~Expression_ReferenceSegment_StructField() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.ReferenceSegment.StructField) + // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.StructField) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -9878,7 +9847,7 @@ void Expression_ReferenceSegment_StructField::SetCachedSize(int size) const { } void Expression_ReferenceSegment_StructField::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ReferenceSegment.StructField) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.StructField) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -9904,7 +9873,7 @@ const char* Expression_ReferenceSegment_StructField::_InternalParse(const char* CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); @@ -9936,7 +9905,7 @@ const char* Expression_ReferenceSegment_StructField::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_StructField::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ReferenceSegment.StructField) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.StructField) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -9946,7 +9915,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_StructField::_Intern target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); } - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; if (this->has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9958,19 +9927,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_StructField::_Intern target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ReferenceSegment.StructField) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment.StructField) return target; } size_t Expression_ReferenceSegment_StructField::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ReferenceSegment.StructField) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.StructField) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; if (this->has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -9994,29 +9963,29 @@ size_t Expression_ReferenceSegment_StructField::ByteSizeLong() const { } void Expression_ReferenceSegment_StructField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ReferenceSegment.StructField) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.ReferenceSegment.StructField) GOOGLE_DCHECK_NE(&from, this); const Expression_ReferenceSegment_StructField* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ReferenceSegment.StructField) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.ReferenceSegment.StructField) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ReferenceSegment.StructField) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.ReferenceSegment.StructField) MergeFrom(*source); } } void Expression_ReferenceSegment_StructField::MergeFrom(const Expression_ReferenceSegment_StructField& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ReferenceSegment.StructField) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.StructField) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_child()) { - _internal_mutable_child()->::io::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); + _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); } if (from.field() != 0) { _internal_set_field(from._internal_field()); @@ -10024,14 +9993,14 @@ void Expression_ReferenceSegment_StructField::MergeFrom(const Expression_Referen } void Expression_ReferenceSegment_StructField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ReferenceSegment.StructField) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.ReferenceSegment.StructField) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_ReferenceSegment_StructField::CopyFrom(const Expression_ReferenceSegment_StructField& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ReferenceSegment.StructField) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment.StructField) if (&from == this) return; Clear(); MergeFrom(from); @@ -10054,18 +10023,18 @@ void Expression_ReferenceSegment_StructField::InternalSwap(Expression_ReferenceS ::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_StructField::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[30]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[30]); } // =================================================================== class Expression_ReferenceSegment_ListElement::_Internal { public: - static const ::io::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_ListElement* msg); + static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_ListElement* msg); }; -const ::io::substrait::Expression_ReferenceSegment& +const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::_Internal::child(const Expression_ReferenceSegment_ListElement* msg) { return *msg->child_; } @@ -10073,18 +10042,18 @@ Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ReferenceSegment.ListElement) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.ListElement) } Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(const Expression_ReferenceSegment_ListElement& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_child()) { - child_ = new ::io::substrait::Expression_ReferenceSegment(*from.child_); + child_ = new ::substrait::Expression_ReferenceSegment(*from.child_); } else { child_ = nullptr; } offset_ = from.offset_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ReferenceSegment.ListElement) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.ListElement) } void Expression_ReferenceSegment_ListElement::SharedCtor() { @@ -10095,7 +10064,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_ReferenceSegment_ListElement::~Expression_ReferenceSegment_ListElement() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.ReferenceSegment.ListElement) + // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.ListElement) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -10116,7 +10085,7 @@ void Expression_ReferenceSegment_ListElement::SetCachedSize(int size) const { } void Expression_ReferenceSegment_ListElement::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ReferenceSegment.ListElement) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.ListElement) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -10142,7 +10111,7 @@ const char* Expression_ReferenceSegment_ListElement::_InternalParse(const char* CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); @@ -10174,7 +10143,7 @@ const char* Expression_ReferenceSegment_ListElement::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_ListElement::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ReferenceSegment.ListElement) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.ListElement) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -10184,7 +10153,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_ListElement::_Intern target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_offset(), target); } - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; if (this->has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -10196,19 +10165,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_ListElement::_Intern target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ReferenceSegment.ListElement) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment.ListElement) return target; } size_t Expression_ReferenceSegment_ListElement::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ReferenceSegment.ListElement) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.ListElement) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; if (this->has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -10232,29 +10201,29 @@ size_t Expression_ReferenceSegment_ListElement::ByteSizeLong() const { } void Expression_ReferenceSegment_ListElement::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ReferenceSegment.ListElement) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.ReferenceSegment.ListElement) GOOGLE_DCHECK_NE(&from, this); const Expression_ReferenceSegment_ListElement* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ReferenceSegment.ListElement) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.ReferenceSegment.ListElement) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ReferenceSegment.ListElement) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.ReferenceSegment.ListElement) MergeFrom(*source); } } void Expression_ReferenceSegment_ListElement::MergeFrom(const Expression_ReferenceSegment_ListElement& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ReferenceSegment.ListElement) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.ListElement) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_child()) { - _internal_mutable_child()->::io::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); + _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); } if (from.offset() != 0) { _internal_set_offset(from._internal_offset()); @@ -10262,14 +10231,14 @@ void Expression_ReferenceSegment_ListElement::MergeFrom(const Expression_Referen } void Expression_ReferenceSegment_ListElement::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ReferenceSegment.ListElement) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.ReferenceSegment.ListElement) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_ReferenceSegment_ListElement::CopyFrom(const Expression_ReferenceSegment_ListElement& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ReferenceSegment.ListElement) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment.ListElement) if (&from == this) return; Clear(); MergeFrom(from); @@ -10292,32 +10261,32 @@ void Expression_ReferenceSegment_ListElement::InternalSwap(Expression_ReferenceS ::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_ListElement::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[31]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[31]); } // =================================================================== class Expression_ReferenceSegment::_Internal { public: - static const ::io::substrait::Expression_ReferenceSegment_MapKey& map_key(const Expression_ReferenceSegment* msg); - static const ::io::substrait::Expression_ReferenceSegment_StructField& struct_field(const Expression_ReferenceSegment* msg); - static const ::io::substrait::Expression_ReferenceSegment_ListElement& list_element(const Expression_ReferenceSegment* msg); + static const ::substrait::Expression_ReferenceSegment_MapKey& map_key(const Expression_ReferenceSegment* msg); + static const ::substrait::Expression_ReferenceSegment_StructField& struct_field(const Expression_ReferenceSegment* msg); + static const ::substrait::Expression_ReferenceSegment_ListElement& list_element(const Expression_ReferenceSegment* msg); }; -const ::io::substrait::Expression_ReferenceSegment_MapKey& +const ::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::_Internal::map_key(const Expression_ReferenceSegment* msg) { return *msg->reference_type_.map_key_; } -const ::io::substrait::Expression_ReferenceSegment_StructField& +const ::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::_Internal::struct_field(const Expression_ReferenceSegment* msg) { return *msg->reference_type_.struct_field_; } -const ::io::substrait::Expression_ReferenceSegment_ListElement& +const ::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::_Internal::list_element(const Expression_ReferenceSegment* msg) { return *msg->reference_type_.list_element_; } -void Expression_ReferenceSegment::set_allocated_map_key(::io::substrait::Expression_ReferenceSegment_MapKey* map_key) { +void Expression_ReferenceSegment::set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_reference_type(); if (map_key) { @@ -10330,9 +10299,9 @@ void Expression_ReferenceSegment::set_allocated_map_key(::io::substrait::Express set_has_map_key(); reference_type_.map_key_ = map_key; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.map_key) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.map_key) } -void Expression_ReferenceSegment::set_allocated_struct_field(::io::substrait::Expression_ReferenceSegment_StructField* struct_field) { +void Expression_ReferenceSegment::set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_reference_type(); if (struct_field) { @@ -10345,9 +10314,9 @@ void Expression_ReferenceSegment::set_allocated_struct_field(::io::substrait::Ex set_has_struct_field(); reference_type_.struct_field_ = struct_field; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.struct_field) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.struct_field) } -void Expression_ReferenceSegment::set_allocated_list_element(::io::substrait::Expression_ReferenceSegment_ListElement* list_element) { +void Expression_ReferenceSegment::set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_reference_type(); if (list_element) { @@ -10360,13 +10329,13 @@ void Expression_ReferenceSegment::set_allocated_list_element(::io::substrait::Ex set_has_list_element(); reference_type_.list_element_ = list_element; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.list_element) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.list_element) } Expression_ReferenceSegment::Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.ReferenceSegment) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment) } Expression_ReferenceSegment::Expression_ReferenceSegment(const Expression_ReferenceSegment& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -10374,22 +10343,22 @@ Expression_ReferenceSegment::Expression_ReferenceSegment(const Expression_Refere clear_has_reference_type(); switch (from.reference_type_case()) { case kMapKey: { - _internal_mutable_map_key()->::io::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); + _internal_mutable_map_key()->::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); break; } case kStructField: { - _internal_mutable_struct_field()->::io::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); + _internal_mutable_struct_field()->::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); break; } case kListElement: { - _internal_mutable_list_element()->::io::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); + _internal_mutable_list_element()->::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); break; } case REFERENCE_TYPE_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.ReferenceSegment) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment) } void Expression_ReferenceSegment::SharedCtor() { @@ -10397,7 +10366,7 @@ clear_has_reference_type(); } Expression_ReferenceSegment::~Expression_ReferenceSegment() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.ReferenceSegment) + // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -10420,7 +10389,7 @@ void Expression_ReferenceSegment::SetCachedSize(int size) const { } void Expression_ReferenceSegment::clear_reference_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.ReferenceSegment) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.ReferenceSegment) switch (reference_type_case()) { case kMapKey: { if (GetArena() == nullptr) { @@ -10449,7 +10418,7 @@ void Expression_ReferenceSegment::clear_reference_type() { void Expression_ReferenceSegment::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.ReferenceSegment) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -10464,21 +10433,21 @@ const char* Expression_ReferenceSegment::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.ReferenceSegment.MapKey map_key = 1; + // .substrait.Expression.ReferenceSegment.MapKey map_key = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.ReferenceSegment.StructField struct_field = 2; + // .substrait.Expression.ReferenceSegment.StructField struct_field = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_struct_field(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.ReferenceSegment.ListElement list_element = 3; + // .substrait.Expression.ReferenceSegment.ListElement list_element = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_list_element(), ptr); @@ -10510,11 +10479,11 @@ const char* Expression_ReferenceSegment::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.ReferenceSegment) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.ReferenceSegment.MapKey map_key = 1; + // .substrait.Expression.ReferenceSegment.MapKey map_key = 1; if (_internal_has_map_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -10522,7 +10491,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment::_InternalSerialize( 1, _Internal::map_key(this), target, stream); } - // .io.substrait.Expression.ReferenceSegment.StructField struct_field = 2; + // .substrait.Expression.ReferenceSegment.StructField struct_field = 2; if (_internal_has_struct_field()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -10530,7 +10499,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment::_InternalSerialize( 2, _Internal::struct_field(this), target, stream); } - // .io.substrait.Expression.ReferenceSegment.ListElement list_element = 3; + // .substrait.Expression.ReferenceSegment.ListElement list_element = 3; if (_internal_has_list_element()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -10542,12 +10511,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.ReferenceSegment) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment) return target; } size_t Expression_ReferenceSegment::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.ReferenceSegment) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -10555,21 +10524,21 @@ size_t Expression_ReferenceSegment::ByteSizeLong() const { (void) cached_has_bits; switch (reference_type_case()) { - // .io.substrait.Expression.ReferenceSegment.MapKey map_key = 1; + // .substrait.Expression.ReferenceSegment.MapKey map_key = 1; case kMapKey: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *reference_type_.map_key_); break; } - // .io.substrait.Expression.ReferenceSegment.StructField struct_field = 2; + // .substrait.Expression.ReferenceSegment.StructField struct_field = 2; case kStructField: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *reference_type_.struct_field_); break; } - // .io.substrait.Expression.ReferenceSegment.ListElement list_element = 3; + // .substrait.Expression.ReferenceSegment.ListElement list_element = 3; case kListElement: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -10590,22 +10559,22 @@ size_t Expression_ReferenceSegment::ByteSizeLong() const { } void Expression_ReferenceSegment::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.ReferenceSegment) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.ReferenceSegment) GOOGLE_DCHECK_NE(&from, this); const Expression_ReferenceSegment* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.ReferenceSegment) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.ReferenceSegment) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.ReferenceSegment) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.ReferenceSegment) MergeFrom(*source); } } void Expression_ReferenceSegment::MergeFrom(const Expression_ReferenceSegment& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.ReferenceSegment) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -10613,15 +10582,15 @@ void Expression_ReferenceSegment::MergeFrom(const Expression_ReferenceSegment& f switch (from.reference_type_case()) { case kMapKey: { - _internal_mutable_map_key()->::io::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); + _internal_mutable_map_key()->::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); break; } case kStructField: { - _internal_mutable_struct_field()->::io::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); + _internal_mutable_struct_field()->::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); break; } case kListElement: { - _internal_mutable_list_element()->::io::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); + _internal_mutable_list_element()->::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); break; } case REFERENCE_TYPE_NOT_SET: { @@ -10631,14 +10600,14 @@ void Expression_ReferenceSegment::MergeFrom(const Expression_ReferenceSegment& f } void Expression_ReferenceSegment::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.ReferenceSegment) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.ReferenceSegment) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_ReferenceSegment::CopyFrom(const Expression_ReferenceSegment& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.ReferenceSegment) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment) if (&from == this) return; Clear(); MergeFrom(from); @@ -10657,32 +10626,32 @@ void Expression_ReferenceSegment::InternalSwap(Expression_ReferenceSegment* othe ::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[32]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[32]); } // =================================================================== class Expression_MaskExpression_Select::_Internal { public: - static const ::io::substrait::Expression_MaskExpression_StructSelect& struct_(const Expression_MaskExpression_Select* msg); - static const ::io::substrait::Expression_MaskExpression_ListSelect& list(const Expression_MaskExpression_Select* msg); - static const ::io::substrait::Expression_MaskExpression_MapSelect& map(const Expression_MaskExpression_Select* msg); + static const ::substrait::Expression_MaskExpression_StructSelect& struct_(const Expression_MaskExpression_Select* msg); + static const ::substrait::Expression_MaskExpression_ListSelect& list(const Expression_MaskExpression_Select* msg); + static const ::substrait::Expression_MaskExpression_MapSelect& map(const Expression_MaskExpression_Select* msg); }; -const ::io::substrait::Expression_MaskExpression_StructSelect& +const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::_Internal::struct_(const Expression_MaskExpression_Select* msg) { return *msg->type_.struct__; } -const ::io::substrait::Expression_MaskExpression_ListSelect& +const ::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::_Internal::list(const Expression_MaskExpression_Select* msg) { return *msg->type_.list_; } -const ::io::substrait::Expression_MaskExpression_MapSelect& +const ::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::_Internal::map(const Expression_MaskExpression_Select* msg) { return *msg->type_.map_; } -void Expression_MaskExpression_Select::set_allocated_struct_(::io::substrait::Expression_MaskExpression_StructSelect* struct_) { +void Expression_MaskExpression_Select::set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_type(); if (struct_) { @@ -10695,9 +10664,9 @@ void Expression_MaskExpression_Select::set_allocated_struct_(::io::substrait::Ex set_has_struct_(); type_.struct__ = struct_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.Select.struct) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.struct) } -void Expression_MaskExpression_Select::set_allocated_list(::io::substrait::Expression_MaskExpression_ListSelect* list) { +void Expression_MaskExpression_Select::set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_type(); if (list) { @@ -10710,9 +10679,9 @@ void Expression_MaskExpression_Select::set_allocated_list(::io::substrait::Expre set_has_list(); type_.list_ = list; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.Select.list) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.list) } -void Expression_MaskExpression_Select::set_allocated_map(::io::substrait::Expression_MaskExpression_MapSelect* map) { +void Expression_MaskExpression_Select::set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_type(); if (map) { @@ -10725,13 +10694,13 @@ void Expression_MaskExpression_Select::set_allocated_map(::io::substrait::Expres set_has_map(); type_.map_ = map; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.Select.map) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.map) } Expression_MaskExpression_Select::Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.Select) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.Select) } Expression_MaskExpression_Select::Expression_MaskExpression_Select(const Expression_MaskExpression_Select& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -10739,22 +10708,22 @@ Expression_MaskExpression_Select::Expression_MaskExpression_Select(const Express clear_has_type(); switch (from.type_case()) { case kStruct: { - _internal_mutable_struct_()->::io::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); break; } case kList: { - _internal_mutable_list()->::io::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list()); + _internal_mutable_list()->::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list()); break; } case kMap: { - _internal_mutable_map()->::io::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map()); + _internal_mutable_map()->::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map()); break; } case TYPE_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.Select) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.Select) } void Expression_MaskExpression_Select::SharedCtor() { @@ -10762,7 +10731,7 @@ clear_has_type(); } Expression_MaskExpression_Select::~Expression_MaskExpression_Select() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.Select) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.Select) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -10785,7 +10754,7 @@ void Expression_MaskExpression_Select::SetCachedSize(int size) const { } void Expression_MaskExpression_Select::clear_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.MaskExpression.Select) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.Select) switch (type_case()) { case kStruct: { if (GetArena() == nullptr) { @@ -10814,7 +10783,7 @@ void Expression_MaskExpression_Select::clear_type() { void Expression_MaskExpression_Select::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.Select) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.Select) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -10829,21 +10798,21 @@ const char* Expression_MaskExpression_Select::_InternalParse(const char* ptr, :: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.MaskExpression.StructSelect struct = 1; + // .substrait.Expression.MaskExpression.StructSelect struct = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.MaskExpression.ListSelect list = 2; + // .substrait.Expression.MaskExpression.ListSelect list = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.MaskExpression.MapSelect map = 3; + // .substrait.Expression.MaskExpression.MapSelect map = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); @@ -10875,11 +10844,11 @@ const char* Expression_MaskExpression_Select::_InternalParse(const char* ptr, :: ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_Select::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.Select) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.Select) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.MaskExpression.StructSelect struct = 1; + // .substrait.Expression.MaskExpression.StructSelect struct = 1; if (_internal_has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -10887,7 +10856,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_Select::_InternalSeria 1, _Internal::struct_(this), target, stream); } - // .io.substrait.Expression.MaskExpression.ListSelect list = 2; + // .substrait.Expression.MaskExpression.ListSelect list = 2; if (_internal_has_list()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -10895,7 +10864,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_Select::_InternalSeria 2, _Internal::list(this), target, stream); } - // .io.substrait.Expression.MaskExpression.MapSelect map = 3; + // .substrait.Expression.MaskExpression.MapSelect map = 3; if (_internal_has_map()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -10907,12 +10876,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_Select::_InternalSeria target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.Select) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.Select) return target; } size_t Expression_MaskExpression_Select::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.Select) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.Select) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -10920,21 +10889,21 @@ size_t Expression_MaskExpression_Select::ByteSizeLong() const { (void) cached_has_bits; switch (type_case()) { - // .io.substrait.Expression.MaskExpression.StructSelect struct = 1; + // .substrait.Expression.MaskExpression.StructSelect struct = 1; case kStruct: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *type_.struct__); break; } - // .io.substrait.Expression.MaskExpression.ListSelect list = 2; + // .substrait.Expression.MaskExpression.ListSelect list = 2; case kList: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *type_.list_); break; } - // .io.substrait.Expression.MaskExpression.MapSelect map = 3; + // .substrait.Expression.MaskExpression.MapSelect map = 3; case kMap: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -10955,22 +10924,22 @@ size_t Expression_MaskExpression_Select::ByteSizeLong() const { } void Expression_MaskExpression_Select::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.Select) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.Select) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression_Select* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.Select) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.Select) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.Select) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.Select) MergeFrom(*source); } } void Expression_MaskExpression_Select::MergeFrom(const Expression_MaskExpression_Select& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.Select) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.Select) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -10978,15 +10947,15 @@ void Expression_MaskExpression_Select::MergeFrom(const Expression_MaskExpression switch (from.type_case()) { case kStruct: { - _internal_mutable_struct_()->::io::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); break; } case kList: { - _internal_mutable_list()->::io::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list()); + _internal_mutable_list()->::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list()); break; } case kMap: { - _internal_mutable_map()->::io::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map()); + _internal_mutable_map()->::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map()); break; } case TYPE_NOT_SET: { @@ -10996,14 +10965,14 @@ void Expression_MaskExpression_Select::MergeFrom(const Expression_MaskExpression } void Expression_MaskExpression_Select::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.Select) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.Select) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression_Select::CopyFrom(const Expression_MaskExpression_Select& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.Select) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.Select) if (&from == this) return; Clear(); MergeFrom(from); @@ -11022,8 +10991,8 @@ void Expression_MaskExpression_Select::InternalSwap(Expression_MaskExpression_Se ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_Select::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[33]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[33]); } // =================================================================== @@ -11037,20 +11006,20 @@ Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(: struct_items_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.StructSelect) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.StructSelect) } Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(const Expression_MaskExpression_StructSelect& from) : ::PROTOBUF_NAMESPACE_ID::Message(), struct_items_(from.struct_items_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.StructSelect) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.StructSelect) } void Expression_MaskExpression_StructSelect::SharedCtor() { } Expression_MaskExpression_StructSelect::~Expression_MaskExpression_StructSelect() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.StructSelect) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.StructSelect) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -11070,7 +11039,7 @@ void Expression_MaskExpression_StructSelect::SetCachedSize(int size) const { } void Expression_MaskExpression_StructSelect::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.StructSelect) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.StructSelect) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11085,7 +11054,7 @@ const char* Expression_MaskExpression_StructSelect::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.MaskExpression.StructItem struct_items = 1; + // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -11122,11 +11091,11 @@ const char* Expression_MaskExpression_StructSelect::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_StructSelect::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.StructSelect) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.StructSelect) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.MaskExpression.StructItem struct_items = 1; + // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; for (unsigned int i = 0, n = static_cast(this->_internal_struct_items_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -11138,19 +11107,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_StructSelect::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.StructSelect) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.StructSelect) return target; } size_t Expression_MaskExpression_StructSelect::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.StructSelect) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.StructSelect) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.MaskExpression.StructItem struct_items = 1; + // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; total_size += 1UL * this->_internal_struct_items_size(); for (const auto& msg : this->struct_items_) { total_size += @@ -11167,22 +11136,22 @@ size_t Expression_MaskExpression_StructSelect::ByteSizeLong() const { } void Expression_MaskExpression_StructSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.StructSelect) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.StructSelect) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression_StructSelect* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.StructSelect) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.StructSelect) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.StructSelect) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.StructSelect) MergeFrom(*source); } } void Expression_MaskExpression_StructSelect::MergeFrom(const Expression_MaskExpression_StructSelect& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.StructSelect) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.StructSelect) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -11192,14 +11161,14 @@ void Expression_MaskExpression_StructSelect::MergeFrom(const Expression_MaskExpr } void Expression_MaskExpression_StructSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.StructSelect) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.StructSelect) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression_StructSelect::CopyFrom(const Expression_MaskExpression_StructSelect& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.StructSelect) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.StructSelect) if (&from == this) return; Clear(); MergeFrom(from); @@ -11217,18 +11186,18 @@ void Expression_MaskExpression_StructSelect::InternalSwap(Expression_MaskExpress ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_StructSelect::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[34]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[34]); } // =================================================================== class Expression_MaskExpression_StructItem::_Internal { public: - static const ::io::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_StructItem* msg); + static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_StructItem* msg); }; -const ::io::substrait::Expression_MaskExpression_Select& +const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::_Internal::child(const Expression_MaskExpression_StructItem* msg) { return *msg->child_; } @@ -11236,18 +11205,18 @@ Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(::PRO : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.StructItem) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.StructItem) } Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(const Expression_MaskExpression_StructItem& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_child()) { - child_ = new ::io::substrait::Expression_MaskExpression_Select(*from.child_); + child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_); } else { child_ = nullptr; } field_ = from.field_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.StructItem) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.StructItem) } void Expression_MaskExpression_StructItem::SharedCtor() { @@ -11258,7 +11227,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_MaskExpression_StructItem::~Expression_MaskExpression_StructItem() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.StructItem) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.StructItem) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -11279,7 +11248,7 @@ void Expression_MaskExpression_StructItem::SetCachedSize(int size) const { } void Expression_MaskExpression_StructItem::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.StructItem) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.StructItem) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11305,7 +11274,7 @@ const char* Expression_MaskExpression_StructItem::_InternalParse(const char* ptr CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.MaskExpression.Select child = 2; + // .substrait.Expression.MaskExpression.Select child = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); @@ -11337,7 +11306,7 @@ const char* Expression_MaskExpression_StructItem::_InternalParse(const char* ptr ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_StructItem::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.StructItem) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.StructItem) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -11347,7 +11316,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_StructItem::_InternalS target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); } - // .io.substrait.Expression.MaskExpression.Select child = 2; + // .substrait.Expression.MaskExpression.Select child = 2; if (this->has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -11359,19 +11328,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_StructItem::_InternalS target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.StructItem) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.StructItem) return target; } size_t Expression_MaskExpression_StructItem::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.StructItem) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.StructItem) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression.MaskExpression.Select child = 2; + // .substrait.Expression.MaskExpression.Select child = 2; if (this->has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -11395,29 +11364,29 @@ size_t Expression_MaskExpression_StructItem::ByteSizeLong() const { } void Expression_MaskExpression_StructItem::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.StructItem) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.StructItem) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression_StructItem* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.StructItem) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.StructItem) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.StructItem) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.StructItem) MergeFrom(*source); } } void Expression_MaskExpression_StructItem::MergeFrom(const Expression_MaskExpression_StructItem& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.StructItem) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.StructItem) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_child()) { - _internal_mutable_child()->::io::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); + _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); } if (from.field() != 0) { _internal_set_field(from._internal_field()); @@ -11425,14 +11394,14 @@ void Expression_MaskExpression_StructItem::MergeFrom(const Expression_MaskExpres } void Expression_MaskExpression_StructItem::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.StructItem) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.StructItem) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression_StructItem::CopyFrom(const Expression_MaskExpression_StructItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.StructItem) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.StructItem) if (&from == this) return; Clear(); MergeFrom(from); @@ -11455,8 +11424,8 @@ void Expression_MaskExpression_StructItem::InternalSwap(Expression_MaskExpressio ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_StructItem::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[35]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[35]); } // =================================================================== @@ -11469,13 +11438,13 @@ Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_Mask : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) } Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); field_ = from.field_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) } void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedCtor() { @@ -11483,7 +11452,7 @@ field_ = 0; } Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::~Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -11503,7 +11472,7 @@ void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SetCachedS } void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11550,7 +11519,7 @@ const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_In ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -11564,12 +11533,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectI target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) return target; } size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -11593,22 +11562,22 @@ size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ByteSize } void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) MergeFrom(*source); } } void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -11620,14 +11589,14 @@ void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom( } void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) if (&from == this) return; Clear(); MergeFrom(from); @@ -11645,8 +11614,8 @@ void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::InternalSw ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[36]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[36]); } // =================================================================== @@ -11659,7 +11628,7 @@ Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskEx : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) } Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -11667,7 +11636,7 @@ Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskEx ::memcpy(&start_, &from.start_, static_cast(reinterpret_cast(&end_) - reinterpret_cast(&start_)) + sizeof(end_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) } void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedCtor() { @@ -11678,7 +11647,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::~Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -11698,7 +11667,7 @@ void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SetCachedSiz } void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11754,7 +11723,7 @@ const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_Inte ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -11774,12 +11743,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectI target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) return target; } size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -11810,22 +11779,22 @@ size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ByteSizeLo } void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) MergeFrom(*source); } } void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -11840,14 +11809,14 @@ void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(co } void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) if (&from == this) return; Clear(); MergeFrom(from); @@ -11870,27 +11839,27 @@ void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::InternalSwap ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[37]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[37]); } // =================================================================== class Expression_MaskExpression_ListSelect_ListSelectItem::_Internal { public: - static const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg); - static const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg); + static const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg); + static const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg); }; -const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& +const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg) { return *msg->type_.item_; } -const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& +const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg) { return *msg->type_.slice_; } -void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) { +void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_type(); if (item) { @@ -11903,9 +11872,9 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::i set_has_item(); type_.item_ = item; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) } -void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { +void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_type(); if (slice) { @@ -11918,13 +11887,13 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(:: set_has_slice(); type_.slice_ = slice; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) } Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) } Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(const Expression_MaskExpression_ListSelect_ListSelectItem& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -11932,18 +11901,18 @@ Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_L clear_has_type(); switch (from.type_case()) { case kItem: { - _internal_mutable_item()->::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); + _internal_mutable_item()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); break; } case kSlice: { - _internal_mutable_slice()->::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); + _internal_mutable_slice()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); break; } case TYPE_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) } void Expression_MaskExpression_ListSelect_ListSelectItem::SharedCtor() { @@ -11951,7 +11920,7 @@ clear_has_type(); } Expression_MaskExpression_ListSelect_ListSelectItem::~Expression_MaskExpression_ListSelect_ListSelectItem() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -11974,7 +11943,7 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::SetCachedSize(int size } void Expression_MaskExpression_ListSelect_ListSelectItem::clear_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) switch (type_case()) { case kItem: { if (GetArena() == nullptr) { @@ -11997,7 +11966,7 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::clear_type() { void Expression_MaskExpression_ListSelect_ListSelectItem::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -12012,14 +11981,14 @@ const char* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalParse( ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_item(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_slice(), ptr); @@ -12051,11 +12020,11 @@ const char* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalParse( ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; if (_internal_has_item()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -12063,7 +12032,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectI 1, _Internal::item(this), target, stream); } - // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; if (_internal_has_slice()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -12075,12 +12044,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectI target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) return target; } size_t Expression_MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -12088,14 +12057,14 @@ size_t Expression_MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const (void) cached_has_bits; switch (type_case()) { - // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; case kItem: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *type_.item_); break; } - // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; case kSlice: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -12116,22 +12085,22 @@ size_t Expression_MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const } void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression_ListSelect_ListSelectItem* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) MergeFrom(*source); } } void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -12139,11 +12108,11 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const Expres switch (from.type_case()) { case kItem: { - _internal_mutable_item()->::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); + _internal_mutable_item()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); break; } case kSlice: { - _internal_mutable_slice()->::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); + _internal_mutable_slice()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); break; } case TYPE_NOT_SET: { @@ -12153,14 +12122,14 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const Expres } void Expression_MaskExpression_ListSelect_ListSelectItem::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression_ListSelect_ListSelectItem::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) if (&from == this) return; Clear(); MergeFrom(from); @@ -12179,18 +12148,18 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::InternalSwap(Expressio ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[38]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[38]); } // =================================================================== class Expression_MaskExpression_ListSelect::_Internal { public: - static const ::io::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_ListSelect* msg); + static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_ListSelect* msg); }; -const ::io::substrait::Expression_MaskExpression_Select& +const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::_Internal::child(const Expression_MaskExpression_ListSelect* msg) { return *msg->child_; } @@ -12199,18 +12168,18 @@ Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(::PRO selection_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.ListSelect) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect) } Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(const Expression_MaskExpression_ListSelect& from) : ::PROTOBUF_NAMESPACE_ID::Message(), selection_(from.selection_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_child()) { - child_ = new ::io::substrait::Expression_MaskExpression_Select(*from.child_); + child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_); } else { child_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.ListSelect) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect) } void Expression_MaskExpression_ListSelect::SharedCtor() { @@ -12218,7 +12187,7 @@ child_ = nullptr; } Expression_MaskExpression_ListSelect::~Expression_MaskExpression_ListSelect() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.ListSelect) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -12239,7 +12208,7 @@ void Expression_MaskExpression_ListSelect::SetCachedSize(int size) const { } void Expression_MaskExpression_ListSelect::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.ListSelect) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -12258,7 +12227,7 @@ const char* Expression_MaskExpression_ListSelect::_InternalParse(const char* ptr ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; + // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -12270,7 +12239,7 @@ const char* Expression_MaskExpression_ListSelect::_InternalParse(const char* ptr } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Expression.MaskExpression.Select child = 2; + // .substrait.Expression.MaskExpression.Select child = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); @@ -12302,11 +12271,11 @@ const char* Expression_MaskExpression_ListSelect::_InternalParse(const char* ptr ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.ListSelect) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; + // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; for (unsigned int i = 0, n = static_cast(this->_internal_selection_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -12314,7 +12283,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect::_InternalS InternalWriteMessage(1, this->_internal_selection(i), target, stream); } - // .io.substrait.Expression.MaskExpression.Select child = 2; + // .substrait.Expression.MaskExpression.Select child = 2; if (this->has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -12326,26 +12295,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect::_InternalS target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.ListSelect) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect) return target; } size_t Expression_MaskExpression_ListSelect::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.ListSelect) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; + // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; total_size += 1UL * this->_internal_selection_size(); for (const auto& msg : this->selection_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Expression.MaskExpression.Select child = 2; + // .substrait.Expression.MaskExpression.Select child = 2; if (this->has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -12362,22 +12331,22 @@ size_t Expression_MaskExpression_ListSelect::ByteSizeLong() const { } void Expression_MaskExpression_ListSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.ListSelect) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression_ListSelect* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.ListSelect) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.ListSelect) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.ListSelect) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.ListSelect) MergeFrom(*source); } } void Expression_MaskExpression_ListSelect::MergeFrom(const Expression_MaskExpression_ListSelect& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.ListSelect) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -12385,19 +12354,19 @@ void Expression_MaskExpression_ListSelect::MergeFrom(const Expression_MaskExpres selection_.MergeFrom(from.selection_); if (from.has_child()) { - _internal_mutable_child()->::io::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); + _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); } } void Expression_MaskExpression_ListSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.ListSelect) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression_ListSelect::CopyFrom(const Expression_MaskExpression_ListSelect& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.ListSelect) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect) if (&from == this) return; Clear(); MergeFrom(from); @@ -12416,8 +12385,8 @@ void Expression_MaskExpression_ListSelect::InternalSwap(Expression_MaskExpressio ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[39]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[39]); } // =================================================================== @@ -12430,7 +12399,7 @@ Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_ : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect.MapKey) } Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(const Expression_MaskExpression_MapSelect_MapKey& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -12440,7 +12409,7 @@ Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_ map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key(), GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect.MapKey) } void Expression_MaskExpression_MapSelect_MapKey::SharedCtor() { @@ -12448,7 +12417,7 @@ map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlre } Expression_MaskExpression_MapSelect_MapKey::~Expression_MaskExpression_MapSelect_MapKey() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect.MapKey) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -12469,7 +12438,7 @@ void Expression_MaskExpression_MapSelect_MapKey::SetCachedSize(int size) const { } void Expression_MaskExpression_MapSelect_MapKey::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect.MapKey) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -12489,7 +12458,7 @@ const char* Expression_MaskExpression_MapSelect_MapKey::_InternalParse(const cha if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_map_key(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.MaskExpression.MapSelect.MapKey.map_key")); CHK_(ptr); } else goto handle_unusual; continue; @@ -12518,7 +12487,7 @@ const char* Expression_MaskExpression_MapSelect_MapKey::_InternalParse(const cha ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect_MapKey::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect.MapKey) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -12527,7 +12496,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect_MapKey::_Int ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_map_key().data(), static_cast(this->_internal_map_key().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key"); + "substrait.Expression.MaskExpression.MapSelect.MapKey.map_key"); target = stream->WriteStringMaybeAliased( 1, this->_internal_map_key(), target); } @@ -12536,12 +12505,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect_MapKey::_Int target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.MapSelect.MapKey) return target; } size_t Expression_MaskExpression_MapSelect_MapKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect.MapKey) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -12565,22 +12534,22 @@ size_t Expression_MaskExpression_MapSelect_MapKey::ByteSizeLong() const { } void Expression_MaskExpression_MapSelect_MapKey::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression_MapSelect_MapKey* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.MapSelect.MapKey) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.MapSelect.MapKey) MergeFrom(*source); } } void Expression_MaskExpression_MapSelect_MapKey::MergeFrom(const Expression_MaskExpression_MapSelect_MapKey& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -12592,14 +12561,14 @@ void Expression_MaskExpression_MapSelect_MapKey::MergeFrom(const Expression_Mask } void Expression_MaskExpression_MapSelect_MapKey::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression_MapSelect_MapKey::CopyFrom(const Expression_MaskExpression_MapSelect_MapKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKey) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey) if (&from == this) return; Clear(); MergeFrom(from); @@ -12617,8 +12586,8 @@ void Expression_MaskExpression_MapSelect_MapKey::InternalSwap(Expression_MaskExp ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKey::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[40]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[40]); } // =================================================================== @@ -12631,7 +12600,7 @@ Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_ : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) } Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -12641,7 +12610,7 @@ Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_ map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key_expression(), GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) } void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedCtor() { @@ -12649,7 +12618,7 @@ map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmpt } Expression_MaskExpression_MapSelect_MapKeyExpression::~Expression_MaskExpression_MapSelect_MapKeyExpression() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -12670,7 +12639,7 @@ void Expression_MaskExpression_MapSelect_MapKeyExpression::SetCachedSize(int siz } void Expression_MaskExpression_MapSelect_MapKeyExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -12690,7 +12659,7 @@ const char* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalParse if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_map_key_expression(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression")); CHK_(ptr); } else goto handle_unusual; continue; @@ -12719,7 +12688,7 @@ const char* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalParse ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -12728,7 +12697,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect_MapKeyExpres ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_map_key_expression().data(), static_cast(this->_internal_map_key_expression().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression"); + "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression"); target = stream->WriteStringMaybeAliased( 1, this->_internal_map_key_expression(), target); } @@ -12737,12 +12706,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect_MapKeyExpres target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) return target; } size_t Expression_MaskExpression_MapSelect_MapKeyExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -12766,22 +12735,22 @@ size_t Expression_MaskExpression_MapSelect_MapKeyExpression::ByteSizeLong() cons } void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression_MapSelect_MapKeyExpression* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) MergeFrom(*source); } } void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -12793,14 +12762,14 @@ void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const Expre } void Expression_MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) if (&from == this) return; Clear(); MergeFrom(from); @@ -12818,32 +12787,32 @@ void Expression_MaskExpression_MapSelect_MapKeyExpression::InternalSwap(Expressi ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKeyExpression::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[41]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[41]); } // =================================================================== class Expression_MaskExpression_MapSelect::_Internal { public: - static const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& key(const Expression_MaskExpression_MapSelect* msg); - static const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression(const Expression_MaskExpression_MapSelect* msg); - static const ::io::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_MapSelect* msg); + static const ::substrait::Expression_MaskExpression_MapSelect_MapKey& key(const Expression_MaskExpression_MapSelect* msg); + static const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression(const Expression_MaskExpression_MapSelect* msg); + static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_MapSelect* msg); }; -const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& +const ::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::_Internal::key(const Expression_MaskExpression_MapSelect* msg) { return *msg->select_.key_; } -const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& +const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::_Internal::expression(const Expression_MaskExpression_MapSelect* msg) { return *msg->select_.expression_; } -const ::io::substrait::Expression_MaskExpression_Select& +const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::_Internal::child(const Expression_MaskExpression_MapSelect* msg) { return *msg->child_; } -void Expression_MaskExpression_MapSelect::set_allocated_key(::io::substrait::Expression_MaskExpression_MapSelect_MapKey* key) { +void Expression_MaskExpression_MapSelect::set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_select(); if (key) { @@ -12856,9 +12825,9 @@ void Expression_MaskExpression_MapSelect::set_allocated_key(::io::substrait::Exp set_has_key(); select_.key_ = key; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.key) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.key) } -void Expression_MaskExpression_MapSelect::set_allocated_expression(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) { +void Expression_MaskExpression_MapSelect::set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_select(); if (expression) { @@ -12871,37 +12840,37 @@ void Expression_MaskExpression_MapSelect::set_allocated_expression(::io::substra set_has_expression(); select_.expression_ = expression; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.expression) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.expression) } Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression.MapSelect) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect) } Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(const Expression_MaskExpression_MapSelect& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_child()) { - child_ = new ::io::substrait::Expression_MaskExpression_Select(*from.child_); + child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_); } else { child_ = nullptr; } clear_has_select(); switch (from.select_case()) { case kKey: { - _internal_mutable_key()->::io::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); + _internal_mutable_key()->::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); break; } case kExpression: { - _internal_mutable_expression()->::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); + _internal_mutable_expression()->::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); break; } case SELECT_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression.MapSelect) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect) } void Expression_MaskExpression_MapSelect::SharedCtor() { @@ -12910,7 +12879,7 @@ clear_has_select(); } Expression_MaskExpression_MapSelect::~Expression_MaskExpression_MapSelect() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression.MapSelect) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -12934,7 +12903,7 @@ void Expression_MaskExpression_MapSelect::SetCachedSize(int size) const { } void Expression_MaskExpression_MapSelect::clear_select() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.MaskExpression.MapSelect) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.MapSelect) switch (select_case()) { case kKey: { if (GetArena() == nullptr) { @@ -12957,7 +12926,7 @@ void Expression_MaskExpression_MapSelect::clear_select() { void Expression_MaskExpression_MapSelect::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression.MapSelect) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -12976,21 +12945,21 @@ const char* Expression_MaskExpression_MapSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; + // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; + // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.MaskExpression.Select child = 3; + // .substrait.Expression.MaskExpression.Select child = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); @@ -13022,11 +12991,11 @@ const char* Expression_MaskExpression_MapSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression.MapSelect) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; + // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; if (_internal_has_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -13034,7 +13003,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect::_InternalSe 1, _Internal::key(this), target, stream); } - // .io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; + // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; if (_internal_has_expression()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -13042,7 +13011,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect::_InternalSe 2, _Internal::expression(this), target, stream); } - // .io.substrait.Expression.MaskExpression.Select child = 3; + // .substrait.Expression.MaskExpression.Select child = 3; if (this->has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -13054,19 +13023,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect::_InternalSe target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression.MapSelect) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.MapSelect) return target; } size_t Expression_MaskExpression_MapSelect::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression.MapSelect) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression.MaskExpression.Select child = 3; + // .substrait.Expression.MaskExpression.Select child = 3; if (this->has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -13074,14 +13043,14 @@ size_t Expression_MaskExpression_MapSelect::ByteSizeLong() const { } switch (select_case()) { - // .io.substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; + // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; case kKey: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *select_.key_); break; } - // .io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; + // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; case kExpression: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -13102,37 +13071,37 @@ size_t Expression_MaskExpression_MapSelect::ByteSizeLong() const { } void Expression_MaskExpression_MapSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.MapSelect) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression_MapSelect* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression.MapSelect) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.MapSelect) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression.MapSelect) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.MapSelect) MergeFrom(*source); } } void Expression_MaskExpression_MapSelect::MergeFrom(const Expression_MaskExpression_MapSelect& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression.MapSelect) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_child()) { - _internal_mutable_child()->::io::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); + _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); } switch (from.select_case()) { case kKey: { - _internal_mutable_key()->::io::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); + _internal_mutable_key()->::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); break; } case kExpression: { - _internal_mutable_expression()->::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); + _internal_mutable_expression()->::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); break; } case SELECT_NOT_SET: { @@ -13142,14 +13111,14 @@ void Expression_MaskExpression_MapSelect::MergeFrom(const Expression_MaskExpress } void Expression_MaskExpression_MapSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.MapSelect) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression_MapSelect::CopyFrom(const Expression_MaskExpression_MapSelect& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression.MapSelect) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect) if (&from == this) return; Clear(); MergeFrom(from); @@ -13169,18 +13138,18 @@ void Expression_MaskExpression_MapSelect::InternalSwap(Expression_MaskExpression ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[42]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[42]); } // =================================================================== class Expression_MaskExpression::_Internal { public: - static const ::io::substrait::Expression_MaskExpression_StructSelect& select(const Expression_MaskExpression* msg); + static const ::substrait::Expression_MaskExpression_StructSelect& select(const Expression_MaskExpression* msg); }; -const ::io::substrait::Expression_MaskExpression_StructSelect& +const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::_Internal::select(const Expression_MaskExpression* msg) { return *msg->select_; } @@ -13188,18 +13157,18 @@ Expression_MaskExpression::Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Ar : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.MaskExpression) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression) } Expression_MaskExpression::Expression_MaskExpression(const Expression_MaskExpression& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_select()) { - select_ = new ::io::substrait::Expression_MaskExpression_StructSelect(*from.select_); + select_ = new ::substrait::Expression_MaskExpression_StructSelect(*from.select_); } else { select_ = nullptr; } maintain_singular_struct_ = from.maintain_singular_struct_; - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.MaskExpression) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression) } void Expression_MaskExpression::SharedCtor() { @@ -13210,7 +13179,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Expression_MaskExpression::~Expression_MaskExpression() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.MaskExpression) + // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -13231,7 +13200,7 @@ void Expression_MaskExpression::SetCachedSize(int size) const { } void Expression_MaskExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.MaskExpression) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -13250,7 +13219,7 @@ const char* Expression_MaskExpression::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.MaskExpression.StructSelect select = 1; + // .substrait.Expression.MaskExpression.StructSelect select = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_select(), ptr); @@ -13289,11 +13258,11 @@ const char* Expression_MaskExpression::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.MaskExpression) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.MaskExpression.StructSelect select = 1; + // .substrait.Expression.MaskExpression.StructSelect select = 1; if (this->has_select()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -13311,19 +13280,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.MaskExpression) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression) return target; } size_t Expression_MaskExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.MaskExpression) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression.MaskExpression.StructSelect select = 1; + // .substrait.Expression.MaskExpression.StructSelect select = 1; if (this->has_select()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -13345,29 +13314,29 @@ size_t Expression_MaskExpression::ByteSizeLong() const { } void Expression_MaskExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.MaskExpression) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression) GOOGLE_DCHECK_NE(&from, this); const Expression_MaskExpression* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.MaskExpression) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.MaskExpression) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression) MergeFrom(*source); } } void Expression_MaskExpression::MergeFrom(const Expression_MaskExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.MaskExpression) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_select()) { - _internal_mutable_select()->::io::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_select()); + _internal_mutable_select()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_select()); } if (from.maintain_singular_struct() != 0) { _internal_set_maintain_singular_struct(from._internal_maintain_singular_struct()); @@ -13375,14 +13344,14 @@ void Expression_MaskExpression::MergeFrom(const Expression_MaskExpression& from) } void Expression_MaskExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.MaskExpression) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_MaskExpression::CopyFrom(const Expression_MaskExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.MaskExpression) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression) if (&from == this) return; Clear(); MergeFrom(from); @@ -13405,8 +13374,8 @@ void Expression_MaskExpression::InternalSwap(Expression_MaskExpression* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[43]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[43]); } // =================================================================== @@ -13419,19 +13388,19 @@ Expression_FieldReference_RootReference::Expression_FieldReference_RootReference : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.FieldReference.RootReference) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.FieldReference.RootReference) } Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(const Expression_FieldReference_RootReference& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.FieldReference.RootReference) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference.RootReference) } void Expression_FieldReference_RootReference::SharedCtor() { } Expression_FieldReference_RootReference::~Expression_FieldReference_RootReference() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.FieldReference.RootReference) + // @@protoc_insertion_point(destructor:substrait.Expression.FieldReference.RootReference) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -13451,7 +13420,7 @@ void Expression_FieldReference_RootReference::SetCachedSize(int size) const { } void Expression_FieldReference_RootReference::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.FieldReference.RootReference) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.FieldReference.RootReference) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -13485,7 +13454,7 @@ const char* Expression_FieldReference_RootReference::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference_RootReference::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.FieldReference.RootReference) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.FieldReference.RootReference) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -13493,12 +13462,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference_RootReference::_Intern target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.FieldReference.RootReference) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.FieldReference.RootReference) return target; } size_t Expression_FieldReference_RootReference::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.FieldReference.RootReference) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.FieldReference.RootReference) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -13515,22 +13484,22 @@ size_t Expression_FieldReference_RootReference::ByteSizeLong() const { } void Expression_FieldReference_RootReference::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.FieldReference.RootReference) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.FieldReference.RootReference) GOOGLE_DCHECK_NE(&from, this); const Expression_FieldReference_RootReference* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.FieldReference.RootReference) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.FieldReference.RootReference) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.FieldReference.RootReference) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.FieldReference.RootReference) MergeFrom(*source); } } void Expression_FieldReference_RootReference::MergeFrom(const Expression_FieldReference_RootReference& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.FieldReference.RootReference) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.FieldReference.RootReference) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -13539,14 +13508,14 @@ void Expression_FieldReference_RootReference::MergeFrom(const Expression_FieldRe } void Expression_FieldReference_RootReference::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.FieldReference.RootReference) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.FieldReference.RootReference) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_FieldReference_RootReference::CopyFrom(const Expression_FieldReference_RootReference& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.FieldReference.RootReference) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.FieldReference.RootReference) if (&from == this) return; Clear(); MergeFrom(from); @@ -13563,37 +13532,37 @@ void Expression_FieldReference_RootReference::InternalSwap(Expression_FieldRefer ::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference_RootReference::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[44]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[44]); } // =================================================================== class Expression_FieldReference::_Internal { public: - static const ::io::substrait::Expression_ReferenceSegment& direct_reference(const Expression_FieldReference* msg); - static const ::io::substrait::Expression_MaskExpression& masked_reference(const Expression_FieldReference* msg); - static const ::io::substrait::Expression& expression(const Expression_FieldReference* msg); - static const ::io::substrait::Expression_FieldReference_RootReference& root_reference(const Expression_FieldReference* msg); + static const ::substrait::Expression_ReferenceSegment& direct_reference(const Expression_FieldReference* msg); + static const ::substrait::Expression_MaskExpression& masked_reference(const Expression_FieldReference* msg); + static const ::substrait::Expression& expression(const Expression_FieldReference* msg); + static const ::substrait::Expression_FieldReference_RootReference& root_reference(const Expression_FieldReference* msg); }; -const ::io::substrait::Expression_ReferenceSegment& +const ::substrait::Expression_ReferenceSegment& Expression_FieldReference::_Internal::direct_reference(const Expression_FieldReference* msg) { return *msg->reference_type_.direct_reference_; } -const ::io::substrait::Expression_MaskExpression& +const ::substrait::Expression_MaskExpression& Expression_FieldReference::_Internal::masked_reference(const Expression_FieldReference* msg) { return *msg->reference_type_.masked_reference_; } -const ::io::substrait::Expression& +const ::substrait::Expression& Expression_FieldReference::_Internal::expression(const Expression_FieldReference* msg) { return *msg->root_type_.expression_; } -const ::io::substrait::Expression_FieldReference_RootReference& +const ::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::_Internal::root_reference(const Expression_FieldReference* msg) { return *msg->root_type_.root_reference_; } -void Expression_FieldReference::set_allocated_direct_reference(::io::substrait::Expression_ReferenceSegment* direct_reference) { +void Expression_FieldReference::set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_reference_type(); if (direct_reference) { @@ -13606,9 +13575,9 @@ void Expression_FieldReference::set_allocated_direct_reference(::io::substrait:: set_has_direct_reference(); reference_type_.direct_reference_ = direct_reference; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.FieldReference.direct_reference) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.direct_reference) } -void Expression_FieldReference::set_allocated_masked_reference(::io::substrait::Expression_MaskExpression* masked_reference) { +void Expression_FieldReference::set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_reference_type(); if (masked_reference) { @@ -13621,9 +13590,9 @@ void Expression_FieldReference::set_allocated_masked_reference(::io::substrait:: set_has_masked_reference(); reference_type_.masked_reference_ = masked_reference; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.FieldReference.masked_reference) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.masked_reference) } -void Expression_FieldReference::set_allocated_expression(::io::substrait::Expression* expression) { +void Expression_FieldReference::set_allocated_expression(::substrait::Expression* expression) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_root_type(); if (expression) { @@ -13636,9 +13605,9 @@ void Expression_FieldReference::set_allocated_expression(::io::substrait::Expres set_has_expression(); root_type_.expression_ = expression; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.FieldReference.expression) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.expression) } -void Expression_FieldReference::set_allocated_root_reference(::io::substrait::Expression_FieldReference_RootReference* root_reference) { +void Expression_FieldReference::set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_root_type(); if (root_reference) { @@ -13651,13 +13620,13 @@ void Expression_FieldReference::set_allocated_root_reference(::io::substrait::Ex set_has_root_reference(); root_type_.root_reference_ = root_reference; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.FieldReference.root_reference) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.root_reference) } Expression_FieldReference::Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression.FieldReference) + // @@protoc_insertion_point(arena_constructor:substrait.Expression.FieldReference) } Expression_FieldReference::Expression_FieldReference(const Expression_FieldReference& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -13665,11 +13634,11 @@ Expression_FieldReference::Expression_FieldReference(const Expression_FieldRefer clear_has_reference_type(); switch (from.reference_type_case()) { case kDirectReference: { - _internal_mutable_direct_reference()->::io::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference()); + _internal_mutable_direct_reference()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference()); break; } case kMaskedReference: { - _internal_mutable_masked_reference()->::io::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference()); + _internal_mutable_masked_reference()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference()); break; } case REFERENCE_TYPE_NOT_SET: { @@ -13679,18 +13648,18 @@ Expression_FieldReference::Expression_FieldReference(const Expression_FieldRefer clear_has_root_type(); switch (from.root_type_case()) { case kExpression: { - _internal_mutable_expression()->::io::substrait::Expression::MergeFrom(from._internal_expression()); + _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression()); break; } case kRootReference: { - _internal_mutable_root_reference()->::io::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference()); + _internal_mutable_root_reference()->::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference()); break; } case ROOT_TYPE_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression.FieldReference) + // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference) } void Expression_FieldReference::SharedCtor() { @@ -13699,7 +13668,7 @@ clear_has_root_type(); } Expression_FieldReference::~Expression_FieldReference() { - // @@protoc_insertion_point(destructor:io.substrait.Expression.FieldReference) + // @@protoc_insertion_point(destructor:substrait.Expression.FieldReference) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -13725,7 +13694,7 @@ void Expression_FieldReference::SetCachedSize(int size) const { } void Expression_FieldReference::clear_reference_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.FieldReference) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.FieldReference) switch (reference_type_case()) { case kDirectReference: { if (GetArena() == nullptr) { @@ -13747,7 +13716,7 @@ void Expression_FieldReference::clear_reference_type() { } void Expression_FieldReference::clear_root_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression.FieldReference) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.FieldReference) switch (root_type_case()) { case kExpression: { if (GetArena() == nullptr) { @@ -13770,7 +13739,7 @@ void Expression_FieldReference::clear_root_type() { void Expression_FieldReference::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression.FieldReference) +// @@protoc_insertion_point(message_clear_start:substrait.Expression.FieldReference) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -13786,28 +13755,28 @@ const char* Expression_FieldReference::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.ReferenceSegment direct_reference = 1; + // .substrait.Expression.ReferenceSegment direct_reference = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_direct_reference(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.MaskExpression masked_reference = 2; + // .substrait.Expression.MaskExpression masked_reference = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_masked_reference(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression expression = 3; + // .substrait.Expression expression = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.FieldReference.RootReference root_reference = 4; + // .substrait.Expression.FieldReference.RootReference root_reference = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_root_reference(), ptr); @@ -13839,11 +13808,11 @@ const char* Expression_FieldReference::_InternalParse(const char* ptr, ::PROTOBU ::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression.FieldReference) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.FieldReference) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.ReferenceSegment direct_reference = 1; + // .substrait.Expression.ReferenceSegment direct_reference = 1; if (_internal_has_direct_reference()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -13851,7 +13820,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference::_InternalSerialize( 1, _Internal::direct_reference(this), target, stream); } - // .io.substrait.Expression.MaskExpression masked_reference = 2; + // .substrait.Expression.MaskExpression masked_reference = 2; if (_internal_has_masked_reference()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -13859,7 +13828,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference::_InternalSerialize( 2, _Internal::masked_reference(this), target, stream); } - // .io.substrait.Expression expression = 3; + // .substrait.Expression expression = 3; if (_internal_has_expression()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -13867,7 +13836,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference::_InternalSerialize( 3, _Internal::expression(this), target, stream); } - // .io.substrait.Expression.FieldReference.RootReference root_reference = 4; + // .substrait.Expression.FieldReference.RootReference root_reference = 4; if (_internal_has_root_reference()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -13879,12 +13848,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression.FieldReference) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.FieldReference) return target; } size_t Expression_FieldReference::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression.FieldReference) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.FieldReference) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -13892,14 +13861,14 @@ size_t Expression_FieldReference::ByteSizeLong() const { (void) cached_has_bits; switch (reference_type_case()) { - // .io.substrait.Expression.ReferenceSegment direct_reference = 1; + // .substrait.Expression.ReferenceSegment direct_reference = 1; case kDirectReference: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *reference_type_.direct_reference_); break; } - // .io.substrait.Expression.MaskExpression masked_reference = 2; + // .substrait.Expression.MaskExpression masked_reference = 2; case kMaskedReference: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -13911,14 +13880,14 @@ size_t Expression_FieldReference::ByteSizeLong() const { } } switch (root_type_case()) { - // .io.substrait.Expression expression = 3; + // .substrait.Expression expression = 3; case kExpression: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *root_type_.expression_); break; } - // .io.substrait.Expression.FieldReference.RootReference root_reference = 4; + // .substrait.Expression.FieldReference.RootReference root_reference = 4; case kRootReference: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -13939,22 +13908,22 @@ size_t Expression_FieldReference::ByteSizeLong() const { } void Expression_FieldReference::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression.FieldReference) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.FieldReference) GOOGLE_DCHECK_NE(&from, this); const Expression_FieldReference* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression.FieldReference) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.FieldReference) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression.FieldReference) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.FieldReference) MergeFrom(*source); } } void Expression_FieldReference::MergeFrom(const Expression_FieldReference& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression.FieldReference) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.FieldReference) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -13962,11 +13931,11 @@ void Expression_FieldReference::MergeFrom(const Expression_FieldReference& from) switch (from.reference_type_case()) { case kDirectReference: { - _internal_mutable_direct_reference()->::io::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference()); + _internal_mutable_direct_reference()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference()); break; } case kMaskedReference: { - _internal_mutable_masked_reference()->::io::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference()); + _internal_mutable_masked_reference()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference()); break; } case REFERENCE_TYPE_NOT_SET: { @@ -13975,11 +13944,11 @@ void Expression_FieldReference::MergeFrom(const Expression_FieldReference& from) } switch (from.root_type_case()) { case kExpression: { - _internal_mutable_expression()->::io::substrait::Expression::MergeFrom(from._internal_expression()); + _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression()); break; } case kRootReference: { - _internal_mutable_root_reference()->::io::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference()); + _internal_mutable_root_reference()->::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference()); break; } case ROOT_TYPE_NOT_SET: { @@ -13989,14 +13958,14 @@ void Expression_FieldReference::MergeFrom(const Expression_FieldReference& from) } void Expression_FieldReference::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression.FieldReference) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.FieldReference) if (&from == this) return; Clear(); MergeFrom(from); } void Expression_FieldReference::CopyFrom(const Expression_FieldReference& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression.FieldReference) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.FieldReference) if (&from == this) return; Clear(); MergeFrom(from); @@ -14017,67 +13986,67 @@ void Expression_FieldReference::InternalSwap(Expression_FieldReference* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[45]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[45]); } // =================================================================== class Expression::_Internal { public: - static const ::io::substrait::Expression_Literal& literal(const Expression* msg); - static const ::io::substrait::Expression_FieldReference& selection(const Expression* msg); - static const ::io::substrait::Expression_ScalarFunction& scalar_function(const Expression* msg); - static const ::io::substrait::Expression_WindowFunction& window_function(const Expression* msg); - static const ::io::substrait::Expression_IfThen& if_then(const Expression* msg); - static const ::io::substrait::Expression_SwitchExpression& switch_expression(const Expression* msg); - static const ::io::substrait::Expression_SingularOrList& singular_or_list(const Expression* msg); - static const ::io::substrait::Expression_MultiOrList& multi_or_list(const Expression* msg); - static const ::io::substrait::Expression_Enum& enum_(const Expression* msg); - static const ::io::substrait::Expression_Cast& cast(const Expression* msg); + static const ::substrait::Expression_Literal& literal(const Expression* msg); + static const ::substrait::Expression_FieldReference& selection(const Expression* msg); + static const ::substrait::Expression_ScalarFunction& scalar_function(const Expression* msg); + static const ::substrait::Expression_WindowFunction& window_function(const Expression* msg); + static const ::substrait::Expression_IfThen& if_then(const Expression* msg); + static const ::substrait::Expression_SwitchExpression& switch_expression(const Expression* msg); + static const ::substrait::Expression_SingularOrList& singular_or_list(const Expression* msg); + static const ::substrait::Expression_MultiOrList& multi_or_list(const Expression* msg); + static const ::substrait::Expression_Enum& enum_(const Expression* msg); + static const ::substrait::Expression_Cast& cast(const Expression* msg); }; -const ::io::substrait::Expression_Literal& +const ::substrait::Expression_Literal& Expression::_Internal::literal(const Expression* msg) { return *msg->rex_type_.literal_; } -const ::io::substrait::Expression_FieldReference& +const ::substrait::Expression_FieldReference& Expression::_Internal::selection(const Expression* msg) { return *msg->rex_type_.selection_; } -const ::io::substrait::Expression_ScalarFunction& +const ::substrait::Expression_ScalarFunction& Expression::_Internal::scalar_function(const Expression* msg) { return *msg->rex_type_.scalar_function_; } -const ::io::substrait::Expression_WindowFunction& +const ::substrait::Expression_WindowFunction& Expression::_Internal::window_function(const Expression* msg) { return *msg->rex_type_.window_function_; } -const ::io::substrait::Expression_IfThen& +const ::substrait::Expression_IfThen& Expression::_Internal::if_then(const Expression* msg) { return *msg->rex_type_.if_then_; } -const ::io::substrait::Expression_SwitchExpression& +const ::substrait::Expression_SwitchExpression& Expression::_Internal::switch_expression(const Expression* msg) { return *msg->rex_type_.switch_expression_; } -const ::io::substrait::Expression_SingularOrList& +const ::substrait::Expression_SingularOrList& Expression::_Internal::singular_or_list(const Expression* msg) { return *msg->rex_type_.singular_or_list_; } -const ::io::substrait::Expression_MultiOrList& +const ::substrait::Expression_MultiOrList& Expression::_Internal::multi_or_list(const Expression* msg) { return *msg->rex_type_.multi_or_list_; } -const ::io::substrait::Expression_Enum& +const ::substrait::Expression_Enum& Expression::_Internal::enum_(const Expression* msg) { return *msg->rex_type_.enum__; } -const ::io::substrait::Expression_Cast& +const ::substrait::Expression_Cast& Expression::_Internal::cast(const Expression* msg) { return *msg->rex_type_.cast_; } -void Expression::set_allocated_literal(::io::substrait::Expression_Literal* literal) { +void Expression::set_allocated_literal(::substrait::Expression_Literal* literal) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_rex_type(); if (literal) { @@ -14090,9 +14059,9 @@ void Expression::set_allocated_literal(::io::substrait::Expression_Literal* lite set_has_literal(); rex_type_.literal_ = literal; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.literal) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.literal) } -void Expression::set_allocated_selection(::io::substrait::Expression_FieldReference* selection) { +void Expression::set_allocated_selection(::substrait::Expression_FieldReference* selection) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_rex_type(); if (selection) { @@ -14105,9 +14074,9 @@ void Expression::set_allocated_selection(::io::substrait::Expression_FieldRefere set_has_selection(); rex_type_.selection_ = selection; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.selection) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.selection) } -void Expression::set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function) { +void Expression::set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_rex_type(); if (scalar_function) { @@ -14120,9 +14089,9 @@ void Expression::set_allocated_scalar_function(::io::substrait::Expression_Scala set_has_scalar_function(); rex_type_.scalar_function_ = scalar_function; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.scalar_function) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.scalar_function) } -void Expression::set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function) { +void Expression::set_allocated_window_function(::substrait::Expression_WindowFunction* window_function) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_rex_type(); if (window_function) { @@ -14135,9 +14104,9 @@ void Expression::set_allocated_window_function(::io::substrait::Expression_Windo set_has_window_function(); rex_type_.window_function_ = window_function; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.window_function) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.window_function) } -void Expression::set_allocated_if_then(::io::substrait::Expression_IfThen* if_then) { +void Expression::set_allocated_if_then(::substrait::Expression_IfThen* if_then) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_rex_type(); if (if_then) { @@ -14150,9 +14119,9 @@ void Expression::set_allocated_if_then(::io::substrait::Expression_IfThen* if_th set_has_if_then(); rex_type_.if_then_ = if_then; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.if_then) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.if_then) } -void Expression::set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression) { +void Expression::set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_rex_type(); if (switch_expression) { @@ -14165,9 +14134,9 @@ void Expression::set_allocated_switch_expression(::io::substrait::Expression_Swi set_has_switch_expression(); rex_type_.switch_expression_ = switch_expression; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.switch_expression) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.switch_expression) } -void Expression::set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list) { +void Expression::set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_rex_type(); if (singular_or_list) { @@ -14180,9 +14149,9 @@ void Expression::set_allocated_singular_or_list(::io::substrait::Expression_Sing set_has_singular_or_list(); rex_type_.singular_or_list_ = singular_or_list; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.singular_or_list) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.singular_or_list) } -void Expression::set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list) { +void Expression::set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_rex_type(); if (multi_or_list) { @@ -14195,9 +14164,9 @@ void Expression::set_allocated_multi_or_list(::io::substrait::Expression_MultiOr set_has_multi_or_list(); rex_type_.multi_or_list_ = multi_or_list; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.multi_or_list) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.multi_or_list) } -void Expression::set_allocated_enum_(::io::substrait::Expression_Enum* enum_) { +void Expression::set_allocated_enum_(::substrait::Expression_Enum* enum_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_rex_type(); if (enum_) { @@ -14210,9 +14179,9 @@ void Expression::set_allocated_enum_(::io::substrait::Expression_Enum* enum_) { set_has_enum_(); rex_type_.enum__ = enum_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.enum) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.enum) } -void Expression::set_allocated_cast(::io::substrait::Expression_Cast* cast) { +void Expression::set_allocated_cast(::substrait::Expression_Cast* cast) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_rex_type(); if (cast) { @@ -14225,13 +14194,13 @@ void Expression::set_allocated_cast(::io::substrait::Expression_Cast* cast) { set_has_cast(); rex_type_.cast_ = cast; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.cast) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.cast) } Expression::Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Expression) + // @@protoc_insertion_point(arena_constructor:substrait.Expression) } Expression::Expression(const Expression& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -14239,50 +14208,50 @@ Expression::Expression(const Expression& from) clear_has_rex_type(); switch (from.rex_type_case()) { case kLiteral: { - _internal_mutable_literal()->::io::substrait::Expression_Literal::MergeFrom(from._internal_literal()); + _internal_mutable_literal()->::substrait::Expression_Literal::MergeFrom(from._internal_literal()); break; } case kSelection: { - _internal_mutable_selection()->::io::substrait::Expression_FieldReference::MergeFrom(from._internal_selection()); + _internal_mutable_selection()->::substrait::Expression_FieldReference::MergeFrom(from._internal_selection()); break; } case kScalarFunction: { - _internal_mutable_scalar_function()->::io::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function()); + _internal_mutable_scalar_function()->::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function()); break; } case kWindowFunction: { - _internal_mutable_window_function()->::io::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function()); + _internal_mutable_window_function()->::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function()); break; } case kIfThen: { - _internal_mutable_if_then()->::io::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); + _internal_mutable_if_then()->::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); break; } case kSwitchExpression: { - _internal_mutable_switch_expression()->::io::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); + _internal_mutable_switch_expression()->::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); break; } case kSingularOrList: { - _internal_mutable_singular_or_list()->::io::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); + _internal_mutable_singular_or_list()->::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); break; } case kMultiOrList: { - _internal_mutable_multi_or_list()->::io::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); + _internal_mutable_multi_or_list()->::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); break; } case kEnum: { - _internal_mutable_enum_()->::io::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); + _internal_mutable_enum_()->::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); break; } case kCast: { - _internal_mutable_cast()->::io::substrait::Expression_Cast::MergeFrom(from._internal_cast()); + _internal_mutable_cast()->::substrait::Expression_Cast::MergeFrom(from._internal_cast()); break; } case REX_TYPE_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Expression) + // @@protoc_insertion_point(copy_constructor:substrait.Expression) } void Expression::SharedCtor() { @@ -14290,7 +14259,7 @@ clear_has_rex_type(); } Expression::~Expression() { - // @@protoc_insertion_point(destructor:io.substrait.Expression) + // @@protoc_insertion_point(destructor:substrait.Expression) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -14313,7 +14282,7 @@ void Expression::SetCachedSize(int size) const { } void Expression::clear_rex_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Expression) +// @@protoc_insertion_point(one_of_clear_start:substrait.Expression) switch (rex_type_case()) { case kLiteral: { if (GetArena() == nullptr) { @@ -14384,7 +14353,7 @@ void Expression::clear_rex_type() { void Expression::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Expression) +// @@protoc_insertion_point(message_clear_start:substrait.Expression) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -14399,70 +14368,70 @@ const char* Expression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression.Literal literal = 1; + // .substrait.Expression.Literal literal = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_literal(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.FieldReference selection = 2; + // .substrait.Expression.FieldReference selection = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_selection(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.ScalarFunction scalar_function = 3; + // .substrait.Expression.ScalarFunction scalar_function = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_scalar_function(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.WindowFunction window_function = 5; + // .substrait.Expression.WindowFunction window_function = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_window_function(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.IfThen if_then = 6; + // .substrait.Expression.IfThen if_then = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_if_then(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.SwitchExpression switch_expression = 7; + // .substrait.Expression.SwitchExpression switch_expression = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_switch_expression(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.SingularOrList singular_or_list = 8; + // .substrait.Expression.SingularOrList singular_or_list = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { ptr = ctx->ParseMessage(_internal_mutable_singular_or_list(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.MultiOrList multi_or_list = 9; + // .substrait.Expression.MultiOrList multi_or_list = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_multi_or_list(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Enum enum = 10; + // .substrait.Expression.Enum enum = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.Cast cast = 11; + // .substrait.Expression.Cast cast = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_cast(), ptr); @@ -14494,11 +14463,11 @@ const char* Expression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Expression) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression.Literal literal = 1; + // .substrait.Expression.Literal literal = 1; if (_internal_has_literal()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14506,7 +14475,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( 1, _Internal::literal(this), target, stream); } - // .io.substrait.Expression.FieldReference selection = 2; + // .substrait.Expression.FieldReference selection = 2; if (_internal_has_selection()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14514,7 +14483,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( 2, _Internal::selection(this), target, stream); } - // .io.substrait.Expression.ScalarFunction scalar_function = 3; + // .substrait.Expression.ScalarFunction scalar_function = 3; if (_internal_has_scalar_function()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14522,7 +14491,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( 3, _Internal::scalar_function(this), target, stream); } - // .io.substrait.Expression.WindowFunction window_function = 5; + // .substrait.Expression.WindowFunction window_function = 5; if (_internal_has_window_function()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14530,7 +14499,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( 5, _Internal::window_function(this), target, stream); } - // .io.substrait.Expression.IfThen if_then = 6; + // .substrait.Expression.IfThen if_then = 6; if (_internal_has_if_then()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14538,7 +14507,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( 6, _Internal::if_then(this), target, stream); } - // .io.substrait.Expression.SwitchExpression switch_expression = 7; + // .substrait.Expression.SwitchExpression switch_expression = 7; if (_internal_has_switch_expression()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14546,7 +14515,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( 7, _Internal::switch_expression(this), target, stream); } - // .io.substrait.Expression.SingularOrList singular_or_list = 8; + // .substrait.Expression.SingularOrList singular_or_list = 8; if (_internal_has_singular_or_list()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14554,7 +14523,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( 8, _Internal::singular_or_list(this), target, stream); } - // .io.substrait.Expression.MultiOrList multi_or_list = 9; + // .substrait.Expression.MultiOrList multi_or_list = 9; if (_internal_has_multi_or_list()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14562,7 +14531,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( 9, _Internal::multi_or_list(this), target, stream); } - // .io.substrait.Expression.Enum enum = 10; + // .substrait.Expression.Enum enum = 10; if (_internal_has_enum_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14570,7 +14539,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( 10, _Internal::enum_(this), target, stream); } - // .io.substrait.Expression.Cast cast = 11; + // .substrait.Expression.Cast cast = 11; if (_internal_has_cast()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14582,12 +14551,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Expression) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression) return target; } size_t Expression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Expression) +// @@protoc_insertion_point(message_byte_size_start:substrait.Expression) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -14595,70 +14564,70 @@ size_t Expression::ByteSizeLong() const { (void) cached_has_bits; switch (rex_type_case()) { - // .io.substrait.Expression.Literal literal = 1; + // .substrait.Expression.Literal literal = 1; case kLiteral: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *rex_type_.literal_); break; } - // .io.substrait.Expression.FieldReference selection = 2; + // .substrait.Expression.FieldReference selection = 2; case kSelection: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *rex_type_.selection_); break; } - // .io.substrait.Expression.ScalarFunction scalar_function = 3; + // .substrait.Expression.ScalarFunction scalar_function = 3; case kScalarFunction: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *rex_type_.scalar_function_); break; } - // .io.substrait.Expression.WindowFunction window_function = 5; + // .substrait.Expression.WindowFunction window_function = 5; case kWindowFunction: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *rex_type_.window_function_); break; } - // .io.substrait.Expression.IfThen if_then = 6; + // .substrait.Expression.IfThen if_then = 6; case kIfThen: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *rex_type_.if_then_); break; } - // .io.substrait.Expression.SwitchExpression switch_expression = 7; + // .substrait.Expression.SwitchExpression switch_expression = 7; case kSwitchExpression: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *rex_type_.switch_expression_); break; } - // .io.substrait.Expression.SingularOrList singular_or_list = 8; + // .substrait.Expression.SingularOrList singular_or_list = 8; case kSingularOrList: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *rex_type_.singular_or_list_); break; } - // .io.substrait.Expression.MultiOrList multi_or_list = 9; + // .substrait.Expression.MultiOrList multi_or_list = 9; case kMultiOrList: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *rex_type_.multi_or_list_); break; } - // .io.substrait.Expression.Enum enum = 10; + // .substrait.Expression.Enum enum = 10; case kEnum: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *rex_type_.enum__); break; } - // .io.substrait.Expression.Cast cast = 11; + // .substrait.Expression.Cast cast = 11; case kCast: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -14679,22 +14648,22 @@ size_t Expression::ByteSizeLong() const { } void Expression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Expression) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression) GOOGLE_DCHECK_NE(&from, this); const Expression* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Expression) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Expression) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression) MergeFrom(*source); } } void Expression::MergeFrom(const Expression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Expression) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -14702,43 +14671,43 @@ void Expression::MergeFrom(const Expression& from) { switch (from.rex_type_case()) { case kLiteral: { - _internal_mutable_literal()->::io::substrait::Expression_Literal::MergeFrom(from._internal_literal()); + _internal_mutable_literal()->::substrait::Expression_Literal::MergeFrom(from._internal_literal()); break; } case kSelection: { - _internal_mutable_selection()->::io::substrait::Expression_FieldReference::MergeFrom(from._internal_selection()); + _internal_mutable_selection()->::substrait::Expression_FieldReference::MergeFrom(from._internal_selection()); break; } case kScalarFunction: { - _internal_mutable_scalar_function()->::io::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function()); + _internal_mutable_scalar_function()->::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function()); break; } case kWindowFunction: { - _internal_mutable_window_function()->::io::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function()); + _internal_mutable_window_function()->::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function()); break; } case kIfThen: { - _internal_mutable_if_then()->::io::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); + _internal_mutable_if_then()->::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); break; } case kSwitchExpression: { - _internal_mutable_switch_expression()->::io::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); + _internal_mutable_switch_expression()->::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); break; } case kSingularOrList: { - _internal_mutable_singular_or_list()->::io::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); + _internal_mutable_singular_or_list()->::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); break; } case kMultiOrList: { - _internal_mutable_multi_or_list()->::io::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); + _internal_mutable_multi_or_list()->::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); break; } case kEnum: { - _internal_mutable_enum_()->::io::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); + _internal_mutable_enum_()->::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); break; } case kCast: { - _internal_mutable_cast()->::io::substrait::Expression_Cast::MergeFrom(from._internal_cast()); + _internal_mutable_cast()->::substrait::Expression_Cast::MergeFrom(from._internal_cast()); break; } case REX_TYPE_NOT_SET: { @@ -14748,14 +14717,14 @@ void Expression::MergeFrom(const Expression& from) { } void Expression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Expression) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression) if (&from == this) return; Clear(); MergeFrom(from); } void Expression::CopyFrom(const Expression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Expression) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression) if (&from == this) return; Clear(); MergeFrom(from); @@ -14774,18 +14743,18 @@ void Expression::InternalSwap(Expression* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Expression::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[46]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[46]); } // =================================================================== class SortField::_Internal { public: - static const ::io::substrait::Expression& expr(const SortField* msg); + static const ::substrait::Expression& expr(const SortField* msg); }; -const ::io::substrait::Expression& +const ::substrait::Expression& SortField::_Internal::expr(const SortField* msg) { return *msg->expr_; } @@ -14793,13 +14762,13 @@ SortField::SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.SortField) + // @@protoc_insertion_point(arena_constructor:substrait.SortField) } SortField::SortField(const SortField& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_expr()) { - expr_ = new ::io::substrait::Expression(*from.expr_); + expr_ = new ::substrait::Expression(*from.expr_); } else { expr_ = nullptr; } @@ -14817,7 +14786,7 @@ SortField::SortField(const SortField& from) break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.SortField) + // @@protoc_insertion_point(copy_constructor:substrait.SortField) } void SortField::SharedCtor() { @@ -14826,7 +14795,7 @@ clear_has_sort_kind(); } SortField::~SortField() { - // @@protoc_insertion_point(destructor:io.substrait.SortField) + // @@protoc_insertion_point(destructor:substrait.SortField) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -14850,7 +14819,7 @@ void SortField::SetCachedSize(int size) const { } void SortField::clear_sort_kind() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.SortField) +// @@protoc_insertion_point(one_of_clear_start:substrait.SortField) switch (sort_kind_case()) { case kDirection: { // No need to clear @@ -14869,7 +14838,7 @@ void SortField::clear_sort_kind() { void SortField::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.SortField) +// @@protoc_insertion_point(message_clear_start:substrait.SortField) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -14888,19 +14857,19 @@ const char* SortField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Expression expr = 1; + // .substrait.Expression expr = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_expr(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.SortField.SortDirection direction = 2; + // .substrait.SortField.SortDirection direction = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_direction(static_cast<::io::substrait::SortField_SortDirection>(val)); + _internal_set_direction(static_cast<::substrait::SortField_SortDirection>(val)); } else goto handle_unusual; continue; // uint32 comparison_function_reference = 3; @@ -14935,11 +14904,11 @@ const char* SortField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint8* SortField::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.SortField) + // @@protoc_insertion_point(serialize_to_array_start:substrait.SortField) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Expression expr = 1; + // .substrait.Expression expr = 1; if (this->has_expr()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -14947,7 +14916,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SortField::_InternalSerialize( 1, _Internal::expr(this), target, stream); } - // .io.substrait.SortField.SortDirection direction = 2; + // .substrait.SortField.SortDirection direction = 2; if (_internal_has_direction()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -14964,19 +14933,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SortField::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.SortField) + // @@protoc_insertion_point(serialize_to_array_end:substrait.SortField) return target; } size_t SortField::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.SortField) +// @@protoc_insertion_point(message_byte_size_start:substrait.SortField) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Expression expr = 1; + // .substrait.Expression expr = 1; if (this->has_expr()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -14984,7 +14953,7 @@ size_t SortField::ByteSizeLong() const { } switch (sort_kind_case()) { - // .io.substrait.SortField.SortDirection direction = 2; + // .substrait.SortField.SortDirection direction = 2; case kDirection: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_direction()); @@ -15011,29 +14980,29 @@ size_t SortField::ByteSizeLong() const { } void SortField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.SortField) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.SortField) GOOGLE_DCHECK_NE(&from, this); const SortField* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.SortField) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.SortField) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.SortField) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.SortField) MergeFrom(*source); } } void SortField::MergeFrom(const SortField& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.SortField) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.SortField) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_expr()) { - _internal_mutable_expr()->::io::substrait::Expression::MergeFrom(from._internal_expr()); + _internal_mutable_expr()->::substrait::Expression::MergeFrom(from._internal_expr()); } switch (from.sort_kind_case()) { case kDirection: { @@ -15051,14 +15020,14 @@ void SortField::MergeFrom(const SortField& from) { } void SortField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.SortField) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.SortField) if (&from == this) return; Clear(); MergeFrom(from); } void SortField::CopyFrom(const SortField& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.SortField) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.SortField) if (&from == this) return; Clear(); MergeFrom(from); @@ -15078,18 +15047,18 @@ void SortField::InternalSwap(SortField* other) { ::PROTOBUF_NAMESPACE_ID::Metadata SortField::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[47]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[47]); } // =================================================================== class AggregateFunction::_Internal { public: - static const ::io::substrait::Type& output_type(const AggregateFunction* msg); + static const ::substrait::Type& output_type(const AggregateFunction* msg); }; -const ::io::substrait::Type& +const ::substrait::Type& AggregateFunction::_Internal::output_type(const AggregateFunction* msg) { return *msg->output_type_; } @@ -15105,7 +15074,7 @@ AggregateFunction::AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) sorts_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.AggregateFunction) + // @@protoc_insertion_point(arena_constructor:substrait.AggregateFunction) } AggregateFunction::AggregateFunction(const AggregateFunction& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -15113,14 +15082,14 @@ AggregateFunction::AggregateFunction(const AggregateFunction& from) sorts_(from.sorts_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_output_type()) { - output_type_ = new ::io::substrait::Type(*from.output_type_); + output_type_ = new ::substrait::Type(*from.output_type_); } else { output_type_ = nullptr; } ::memcpy(&function_reference_, &from.function_reference_, static_cast(reinterpret_cast(&phase_) - reinterpret_cast(&function_reference_)) + sizeof(phase_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.AggregateFunction) + // @@protoc_insertion_point(copy_constructor:substrait.AggregateFunction) } void AggregateFunction::SharedCtor() { @@ -15131,7 +15100,7 @@ ::memset(reinterpret_cast(this) + static_cast( } AggregateFunction::~AggregateFunction() { - // @@protoc_insertion_point(destructor:io.substrait.AggregateFunction) + // @@protoc_insertion_point(destructor:substrait.AggregateFunction) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -15152,7 +15121,7 @@ void AggregateFunction::SetCachedSize(int size) const { } void AggregateFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.AggregateFunction) +// @@protoc_insertion_point(message_clear_start:substrait.AggregateFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -15182,7 +15151,7 @@ const char* AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Expression args = 2; + // repeated .substrait.Expression args = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -15194,7 +15163,7 @@ const char* AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; @@ -15206,15 +15175,15 @@ const char* AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.AggregationPhase phase = 4; + // .substrait.AggregationPhase phase = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_phase(static_cast<::io::substrait::AggregationPhase>(val)); + _internal_set_phase(static_cast<::substrait::AggregationPhase>(val)); } else goto handle_unusual; continue; - // .io.substrait.Type output_type = 5; + // .substrait.Type output_type = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); @@ -15246,7 +15215,7 @@ const char* AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ::PROTOBUF_NAMESPACE_ID::uint8* AggregateFunction::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.AggregateFunction) + // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateFunction) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -15256,7 +15225,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateFunction::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); } - // repeated .io.substrait.Expression args = 2; + // repeated .substrait.Expression args = 2; for (unsigned int i = 0, n = static_cast(this->_internal_args_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -15264,7 +15233,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateFunction::_InternalSerialize( InternalWriteMessage(2, this->_internal_args(i), target, stream); } - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; for (unsigned int i = 0, n = static_cast(this->_internal_sorts_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -15272,14 +15241,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateFunction::_InternalSerialize( InternalWriteMessage(3, this->_internal_sorts(i), target, stream); } - // .io.substrait.AggregationPhase phase = 4; + // .substrait.AggregationPhase phase = 4; if (this->phase() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 4, this->_internal_phase(), target); } - // .io.substrait.Type output_type = 5; + // .substrait.Type output_type = 5; if (this->has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -15291,33 +15260,33 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateFunction::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.AggregateFunction) + // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateFunction) return target; } size_t AggregateFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.AggregateFunction) +// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateFunction) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression args = 2; + // repeated .substrait.Expression args = 2; total_size += 1UL * this->_internal_args_size(); for (const auto& msg : this->args_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; total_size += 1UL * this->_internal_sorts_size(); for (const auto& msg : this->sorts_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.Type output_type = 5; + // .substrait.Type output_type = 5; if (this->has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -15331,7 +15300,7 @@ size_t AggregateFunction::ByteSizeLong() const { this->_internal_function_reference()); } - // .io.substrait.AggregationPhase phase = 4; + // .substrait.AggregationPhase phase = 4; if (this->phase() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); @@ -15347,22 +15316,22 @@ size_t AggregateFunction::ByteSizeLong() const { } void AggregateFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.AggregateFunction) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.AggregateFunction) GOOGLE_DCHECK_NE(&from, this); const AggregateFunction* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.AggregateFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.AggregateFunction) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.AggregateFunction) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.AggregateFunction) MergeFrom(*source); } } void AggregateFunction::MergeFrom(const AggregateFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.AggregateFunction) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateFunction) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -15371,7 +15340,7 @@ void AggregateFunction::MergeFrom(const AggregateFunction& from) { args_.MergeFrom(from.args_); sorts_.MergeFrom(from.sorts_); if (from.has_output_type()) { - _internal_mutable_output_type()->::io::substrait::Type::MergeFrom(from._internal_output_type()); + _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); } if (from.function_reference() != 0) { _internal_set_function_reference(from._internal_function_reference()); @@ -15382,14 +15351,14 @@ void AggregateFunction::MergeFrom(const AggregateFunction& from) { } void AggregateFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.AggregateFunction) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.AggregateFunction) if (&from == this) return; Clear(); MergeFrom(from); } void AggregateFunction::CopyFrom(const AggregateFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.AggregateFunction) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateFunction) if (&from == this) return; Clear(); MergeFrom(from); @@ -15414,160 +15383,159 @@ void AggregateFunction::InternalSwap(AggregateFunction* other) { ::PROTOBUF_NAMESPACE_ID::Metadata AggregateFunction::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_expression_2eproto_getter, &descriptor_table_expression_2eproto_once, - file_level_metadata_expression_2eproto[48]); + &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, + file_level_metadata_substrait_2fexpression_2eproto[48]); } // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage< ::io::substrait::Expression_Enum_Empty >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Enum_Empty >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage< ::substrait::Expression_Enum_Empty >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Enum_Empty >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Enum* Arena::CreateMaybeMessage< ::io::substrait::Expression_Enum >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Enum >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Enum* Arena::CreateMaybeMessage< ::substrait::Expression_Enum >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Enum >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_VarChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_VarChar >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_VarChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Literal_VarChar >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_Decimal >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_Decimal >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Decimal >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Decimal >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_Map_KeyValue >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_Map_KeyValue >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Map_KeyValue >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Map_KeyValue >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_Map >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_Map >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Map >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Map >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalYearToMonth >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_IntervalYearToMonth >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_IntervalYearToMonth >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Literal_IntervalYearToMonth >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalDayToSecond >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_IntervalDayToSecond >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_IntervalDayToSecond >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Literal_IntervalDayToSecond >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_Struct >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_Struct >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Struct >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Struct >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal_List* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal_List >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal_List >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_List* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_List >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Literal_List >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Literal* Arena::CreateMaybeMessage< ::io::substrait::Expression_Literal >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Literal >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal* Arena::CreateMaybeMessage< ::substrait::Expression_Literal >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Literal >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_ScalarFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_ScalarFunction >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage< ::substrait::Expression_ScalarFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_ScalarFunction >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Preceding >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound_Preceding >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Preceding >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Preceding >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Following >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound_Following >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Following >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Following >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Unbounded >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound_Unbounded >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Unbounded >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Unbounded >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction_Bound >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_WindowFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_WindowFunction >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage< ::io::substrait::Expression_IfThen_IfClause >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_IfThen_IfClause >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage< ::substrait::Expression_IfThen_IfClause >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_IfThen_IfClause >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_IfThen* Arena::CreateMaybeMessage< ::io::substrait::Expression_IfThen >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_IfThen >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_IfThen* Arena::CreateMaybeMessage< ::substrait::Expression_IfThen >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_IfThen >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_Cast* Arena::CreateMaybeMessage< ::io::substrait::Expression_Cast >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_Cast >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_Cast* Arena::CreateMaybeMessage< ::substrait::Expression_Cast >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_Cast >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage< ::io::substrait::Expression_SwitchExpression_IfValue >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_SwitchExpression_IfValue >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage< ::substrait::Expression_SwitchExpression_IfValue >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_SwitchExpression_IfValue >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage< ::io::substrait::Expression_SwitchExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_SwitchExpression >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage< ::substrait::Expression_SwitchExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_SwitchExpression >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage< ::io::substrait::Expression_SingularOrList >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_SingularOrList >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage< ::substrait::Expression_SingularOrList >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_SingularOrList >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage< ::io::substrait::Expression_MultiOrList_Record >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MultiOrList_Record >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage< ::substrait::Expression_MultiOrList_Record >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MultiOrList_Record >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage< ::io::substrait::Expression_MultiOrList >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MultiOrList >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage< ::substrait::Expression_MultiOrList >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MultiOrList >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_EmbeddedFunction >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_MapKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_ReferenceSegment_MapKey >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_MapKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_MapKey >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_StructField >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_ReferenceSegment_StructField >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_StructField >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_StructField >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_ListElement >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_ReferenceSegment_ListElement >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_ListElement >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_ListElement >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_ReferenceSegment >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_Select >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_Select >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_Select >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_Select >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_StructSelect >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_StructSelect >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructSelect >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_StructSelect >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_StructItem >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_StructItem >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructItem >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_StructItem >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_ListSelect >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect_MapKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_MapSelect_MapKey >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression_MapSelect >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage< ::io::substrait::Expression_MaskExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_MaskExpression >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage< ::io::substrait::Expression_FieldReference_RootReference >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_FieldReference_RootReference >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage< ::substrait::Expression_FieldReference_RootReference >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_FieldReference_RootReference >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression_FieldReference* Arena::CreateMaybeMessage< ::io::substrait::Expression_FieldReference >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression_FieldReference >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression_FieldReference* Arena::CreateMaybeMessage< ::substrait::Expression_FieldReference >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression_FieldReference >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Expression* Arena::CreateMaybeMessage< ::io::substrait::Expression >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Expression >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Expression* Arena::CreateMaybeMessage< ::substrait::Expression >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Expression >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::SortField* Arena::CreateMaybeMessage< ::io::substrait::SortField >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::SortField >(arena); +template<> PROTOBUF_NOINLINE ::substrait::SortField* Arena::CreateMaybeMessage< ::substrait::SortField >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::SortField >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::AggregateFunction* Arena::CreateMaybeMessage< ::io::substrait::AggregateFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::AggregateFunction >(arena); +template<> PROTOBUF_NOINLINE ::substrait::AggregateFunction* Arena::CreateMaybeMessage< ::substrait::AggregateFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::AggregateFunction >(arena); } PROTOBUF_NAMESPACE_CLOSE diff --git a/cpp/src/generated/substrait/expression.pb.h b/cpp/src/generated/substrait/expression.pb.h index 4791ae494c5..5818e2b20f5 100644 --- a/cpp/src/generated/substrait/expression.pb.h +++ b/cpp/src/generated/substrait/expression.pb.h @@ -1,8 +1,8 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: expression.proto +// source: substrait/expression.proto -#ifndef GOOGLE_PROTOBUF_INCLUDED_expression_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_expression_2eproto +#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fexpression_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fexpression_2eproto #include #include @@ -32,10 +32,10 @@ #include // IWYU pragma: export #include #include -#include "type.pb.h" +#include "substrait/type.pb.h" // @@protoc_insertion_point(includes) #include -#define PROTOBUF_INTERNAL_EXPORT_expression_2eproto +#define PROTOBUF_INTERNAL_EXPORT_substrait_2fexpression_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; @@ -43,7 +43,7 @@ class AnyMetadata; PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. -struct TableStruct_expression_2eproto { +struct TableStruct_substrait_2fexpression_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] @@ -54,8 +54,7 @@ struct TableStruct_expression_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; }; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_expression_2eproto; -namespace io { +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fexpression_2eproto; namespace substrait { class AggregateFunction; struct AggregateFunctionDefaultTypeInternal; @@ -205,74 +204,72 @@ class SortField; struct SortFieldDefaultTypeInternal; extern SortFieldDefaultTypeInternal _SortField_default_instance_; } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::AggregateFunction* Arena::CreateMaybeMessage<::io::substrait::AggregateFunction>(Arena*); -template<> ::io::substrait::Expression* Arena::CreateMaybeMessage<::io::substrait::Expression>(Arena*); -template<> ::io::substrait::Expression_Cast* Arena::CreateMaybeMessage<::io::substrait::Expression_Cast>(Arena*); -template<> ::io::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_EmbeddedFunction>(Arena*); -template<> ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction>(Arena*); -template<> ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction>(Arena*); -template<> ::io::substrait::Expression_Enum* Arena::CreateMaybeMessage<::io::substrait::Expression_Enum>(Arena*); -template<> ::io::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage<::io::substrait::Expression_Enum_Empty>(Arena*); -template<> ::io::substrait::Expression_FieldReference* Arena::CreateMaybeMessage<::io::substrait::Expression_FieldReference>(Arena*); -template<> ::io::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage<::io::substrait::Expression_FieldReference_RootReference>(Arena*); -template<> ::io::substrait::Expression_IfThen* Arena::CreateMaybeMessage<::io::substrait::Expression_IfThen>(Arena*); -template<> ::io::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage<::io::substrait::Expression_IfThen_IfClause>(Arena*); -template<> ::io::substrait::Expression_Literal* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal>(Arena*); -template<> ::io::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Decimal>(Arena*); -template<> ::io::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_IntervalDayToSecond>(Arena*); -template<> ::io::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_IntervalYearToMonth>(Arena*); -template<> ::io::substrait::Expression_Literal_List* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_List>(Arena*); -template<> ::io::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Map>(Arena*); -template<> ::io::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Map_KeyValue>(Arena*); -template<> ::io::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_Struct>(Arena*); -template<> ::io::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage<::io::substrait::Expression_Literal_VarChar>(Arena*); -template<> ::io::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression>(Arena*); -template<> ::io::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_ListSelect>(Arena*); -template<> ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem>(Arena*); -template<> ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement>(Arena*); -template<> ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice>(Arena*); -template<> ::io::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_MapSelect>(Arena*); -template<> ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_MapSelect_MapKey>(Arena*); -template<> ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression>(Arena*); -template<> ::io::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_Select>(Arena*); -template<> ::io::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_StructItem>(Arena*); -template<> ::io::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage<::io::substrait::Expression_MaskExpression_StructSelect>(Arena*); -template<> ::io::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage<::io::substrait::Expression_MultiOrList>(Arena*); -template<> ::io::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage<::io::substrait::Expression_MultiOrList_Record>(Arena*); -template<> ::io::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment>(Arena*); -template<> ::io::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment_ListElement>(Arena*); -template<> ::io::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment_MapKey>(Arena*); -template<> ::io::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment_StructField>(Arena*); -template<> ::io::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_ScalarFunction>(Arena*); -template<> ::io::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage<::io::substrait::Expression_SingularOrList>(Arena*); -template<> ::io::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage<::io::substrait::Expression_SwitchExpression>(Arena*); -template<> ::io::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage<::io::substrait::Expression_SwitchExpression_IfValue>(Arena*); -template<> ::io::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction>(Arena*); -template<> ::io::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound>(Arena*); -template<> ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_CurrentRow>(Arena*); -template<> ::io::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_Following>(Arena*); -template<> ::io::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_Preceding>(Arena*); -template<> ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound_Unbounded>(Arena*); -template<> ::io::substrait::SortField* Arena::CreateMaybeMessage<::io::substrait::SortField>(Arena*); +template<> ::substrait::AggregateFunction* Arena::CreateMaybeMessage<::substrait::AggregateFunction>(Arena*); +template<> ::substrait::Expression* Arena::CreateMaybeMessage<::substrait::Expression>(Arena*); +template<> ::substrait::Expression_Cast* Arena::CreateMaybeMessage<::substrait::Expression_Cast>(Arena*); +template<> ::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage<::substrait::Expression_EmbeddedFunction>(Arena*); +template<> ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage<::substrait::Expression_EmbeddedFunction_PythonPickleFunction>(Arena*); +template<> ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage<::substrait::Expression_EmbeddedFunction_WebAssemblyFunction>(Arena*); +template<> ::substrait::Expression_Enum* Arena::CreateMaybeMessage<::substrait::Expression_Enum>(Arena*); +template<> ::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage<::substrait::Expression_Enum_Empty>(Arena*); +template<> ::substrait::Expression_FieldReference* Arena::CreateMaybeMessage<::substrait::Expression_FieldReference>(Arena*); +template<> ::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage<::substrait::Expression_FieldReference_RootReference>(Arena*); +template<> ::substrait::Expression_IfThen* Arena::CreateMaybeMessage<::substrait::Expression_IfThen>(Arena*); +template<> ::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage<::substrait::Expression_IfThen_IfClause>(Arena*); +template<> ::substrait::Expression_Literal* Arena::CreateMaybeMessage<::substrait::Expression_Literal>(Arena*); +template<> ::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Decimal>(Arena*); +template<> ::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage<::substrait::Expression_Literal_IntervalDayToSecond>(Arena*); +template<> ::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage<::substrait::Expression_Literal_IntervalYearToMonth>(Arena*); +template<> ::substrait::Expression_Literal_List* Arena::CreateMaybeMessage<::substrait::Expression_Literal_List>(Arena*); +template<> ::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Map>(Arena*); +template<> ::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Map_KeyValue>(Arena*); +template<> ::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Struct>(Arena*); +template<> ::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage<::substrait::Expression_Literal_VarChar>(Arena*); +template<> ::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression>(Arena*); +template<> ::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect>(Arena*); +template<> ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem>(Arena*); +template<> ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement>(Arena*); +template<> ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice>(Arena*); +template<> ::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_MapSelect>(Arena*); +template<> ::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_MapSelect_MapKey>(Arena*); +template<> ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression>(Arena*); +template<> ::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(Arena*); +template<> ::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_StructItem>(Arena*); +template<> ::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_StructSelect>(Arena*); +template<> ::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage<::substrait::Expression_MultiOrList>(Arena*); +template<> ::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage<::substrait::Expression_MultiOrList_Record>(Arena*); +template<> ::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(Arena*); +template<> ::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment_ListElement>(Arena*); +template<> ::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment_MapKey>(Arena*); +template<> ::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment_StructField>(Arena*); +template<> ::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage<::substrait::Expression_ScalarFunction>(Arena*); +template<> ::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage<::substrait::Expression_SingularOrList>(Arena*); +template<> ::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage<::substrait::Expression_SwitchExpression>(Arena*); +template<> ::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage<::substrait::Expression_SwitchExpression_IfValue>(Arena*); +template<> ::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction>(Arena*); +template<> ::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(Arena*); +template<> ::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_CurrentRow>(Arena*); +template<> ::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_Following>(Arena*); +template<> ::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_Preceding>(Arena*); +template<> ::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_Unbounded>(Arena*); +template<> ::substrait::SortField* Arena::CreateMaybeMessage<::substrait::SortField>(Arena*); PROTOBUF_NAMESPACE_CLOSE -namespace io { namespace substrait { enum SortField_SortDirection : int { - SortField_SortDirection_UNKNOWN = 0, - SortField_SortDirection_ASC_NULLS_FIRST = 1, - SortField_SortDirection_ASC_NULLS_LAST = 2, - SortField_SortDirection_DESC_NULLS_FIRST = 3, - SortField_SortDirection_DESC_NULLS_LAST = 4, - SortField_SortDirection_CLUSTERED = 5, + SortField_SortDirection_SORT_DIRECTION_UNSPECIFIED = 0, + SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_FIRST = 1, + SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_LAST = 2, + SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_FIRST = 3, + SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_LAST = 4, + SortField_SortDirection_SORT_DIRECTION_CLUSTERED = 5, SortField_SortDirection_SortField_SortDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), SortField_SortDirection_SortField_SortDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool SortField_SortDirection_IsValid(int value); -constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MIN = SortField_SortDirection_UNKNOWN; -constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MAX = SortField_SortDirection_CLUSTERED; +constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MIN = SortField_SortDirection_SORT_DIRECTION_UNSPECIFIED; +constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MAX = SortField_SortDirection_SORT_DIRECTION_CLUSTERED; constexpr int SortField_SortDirection_SortDirection_ARRAYSIZE = SortField_SortDirection_SortDirection_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortField_SortDirection_descriptor(); @@ -290,17 +287,17 @@ inline bool SortField_SortDirection_Parse( SortField_SortDirection_descriptor(), name, value); } enum AggregationPhase : int { - UNKNOWN = 0, - INITIAL_TO_INTERMEDIATE = 1, - INTERMEDIATE_TO_INTERMEDIATE = 2, - INITIAL_TO_RESULT = 3, - INTERMEDIATE_TO_RESULT = 4, + AGGREGATION_PHASE_UNSPECIFIED = 0, + AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE = 1, + AGGREGATION_PHASE_INTERMEDIATE_TO_INTERMEDIATE = 2, + AGGREGATION_PHASE_INITIAL_TO_RESULT = 3, + AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT = 4, AggregationPhase_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), AggregationPhase_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool AggregationPhase_IsValid(int value); -constexpr AggregationPhase AggregationPhase_MIN = UNKNOWN; -constexpr AggregationPhase AggregationPhase_MAX = INTERMEDIATE_TO_RESULT; +constexpr AggregationPhase AggregationPhase_MIN = AGGREGATION_PHASE_UNSPECIFIED; +constexpr AggregationPhase AggregationPhase_MAX = AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT; constexpr int AggregationPhase_ARRAYSIZE = AggregationPhase_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggregationPhase_descriptor(); @@ -320,7 +317,7 @@ inline bool AggregationPhase_Parse( // =================================================================== class Expression_Enum_Empty PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Enum.Empty) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Enum.Empty) */ { public: inline Expression_Enum_Empty() : Expression_Enum_Empty(nullptr) {} ~Expression_Enum_Empty() override; @@ -410,7 +407,7 @@ class Expression_Enum_Empty PROTOBUF_FINAL : void InternalSwap(Expression_Enum_Empty* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Enum.Empty"; + return "substrait.Expression.Enum.Empty"; } protected: explicit Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -425,7 +422,7 @@ class Expression_Enum_Empty PROTOBUF_FINAL : // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Enum.Empty) + // @@protoc_insertion_point(class_scope:substrait.Expression.Enum.Empty) private: class _Internal; @@ -433,12 +430,12 @@ class Expression_Enum_Empty PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Enum PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Enum) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Enum) */ { public: inline Expression_Enum() : Expression_Enum(nullptr) {} ~Expression_Enum() override; @@ -534,7 +531,7 @@ class Expression_Enum PROTOBUF_FINAL : void InternalSwap(Expression_Enum* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Enum"; + return "substrait.Expression.Enum"; } protected: explicit Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -573,27 +570,27 @@ class Expression_Enum PROTOBUF_FINAL : std::string* _internal_mutable_specified(); public: - // .io.substrait.Expression.Enum.Empty unspecified = 2; + // .substrait.Expression.Enum.Empty unspecified = 2; bool has_unspecified() const; private: bool _internal_has_unspecified() const; public: void clear_unspecified(); - const ::io::substrait::Expression_Enum_Empty& unspecified() const; - ::io::substrait::Expression_Enum_Empty* release_unspecified(); - ::io::substrait::Expression_Enum_Empty* mutable_unspecified(); - void set_allocated_unspecified(::io::substrait::Expression_Enum_Empty* unspecified); + const ::substrait::Expression_Enum_Empty& unspecified() const; + ::substrait::Expression_Enum_Empty* release_unspecified(); + ::substrait::Expression_Enum_Empty* mutable_unspecified(); + void set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified); private: - const ::io::substrait::Expression_Enum_Empty& _internal_unspecified() const; - ::io::substrait::Expression_Enum_Empty* _internal_mutable_unspecified(); + const ::substrait::Expression_Enum_Empty& _internal_unspecified() const; + ::substrait::Expression_Enum_Empty* _internal_mutable_unspecified(); public: void unsafe_arena_set_allocated_unspecified( - ::io::substrait::Expression_Enum_Empty* unspecified); - ::io::substrait::Expression_Enum_Empty* unsafe_arena_release_unspecified(); + ::substrait::Expression_Enum_Empty* unspecified); + ::substrait::Expression_Enum_Empty* unsafe_arena_release_unspecified(); void clear_enum_kind(); EnumKindCase enum_kind_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Enum) + // @@protoc_insertion_point(class_scope:substrait.Expression.Enum) private: class _Internal; void set_has_specified(); @@ -609,17 +606,17 @@ class Expression_Enum PROTOBUF_FINAL : constexpr EnumKindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr specified_; - ::io::substrait::Expression_Enum_Empty* unspecified_; + ::substrait::Expression_Enum_Empty* unspecified_; } enum_kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Literal_VarChar PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.VarChar) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.VarChar) */ { public: inline Expression_Literal_VarChar() : Expression_Literal_VarChar(nullptr) {} ~Expression_Literal_VarChar() override; @@ -709,7 +706,7 @@ class Expression_Literal_VarChar PROTOBUF_FINAL : void InternalSwap(Expression_Literal_VarChar* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Literal.VarChar"; + return "substrait.Expression.Literal.VarChar"; } protected: explicit Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -751,7 +748,7 @@ class Expression_Literal_VarChar PROTOBUF_FINAL : void _internal_set_length(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.VarChar) + // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.VarChar) private: class _Internal; @@ -761,12 +758,12 @@ class Expression_Literal_VarChar PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; ::PROTOBUF_NAMESPACE_ID::uint32 length_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Literal_Decimal PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.Decimal) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Decimal) */ { public: inline Expression_Literal_Decimal() : Expression_Literal_Decimal(nullptr) {} ~Expression_Literal_Decimal() override; @@ -856,7 +853,7 @@ class Expression_Literal_Decimal PROTOBUF_FINAL : void InternalSwap(Expression_Literal_Decimal* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Literal.Decimal"; + return "substrait.Expression.Literal.Decimal"; } protected: explicit Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -908,7 +905,7 @@ class Expression_Literal_Decimal PROTOBUF_FINAL : void _internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.Decimal) + // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Decimal) private: class _Internal; @@ -919,12 +916,12 @@ class Expression_Literal_Decimal PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::int32 precision_; ::PROTOBUF_NAMESPACE_ID::int32 scale_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.Map.KeyValue) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Map.KeyValue) */ { public: inline Expression_Literal_Map_KeyValue() : Expression_Literal_Map_KeyValue(nullptr) {} ~Expression_Literal_Map_KeyValue() override; @@ -1014,7 +1011,7 @@ class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : void InternalSwap(Expression_Literal_Map_KeyValue* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Literal.Map.KeyValue"; + return "substrait.Expression.Literal.Map.KeyValue"; } protected: explicit Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1033,58 +1030,58 @@ class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : kKeyFieldNumber = 1, kValueFieldNumber = 2, }; - // .io.substrait.Expression.Literal key = 1; + // .substrait.Expression.Literal key = 1; bool has_key() const; private: bool _internal_has_key() const; public: void clear_key(); - const ::io::substrait::Expression_Literal& key() const; - ::io::substrait::Expression_Literal* release_key(); - ::io::substrait::Expression_Literal* mutable_key(); - void set_allocated_key(::io::substrait::Expression_Literal* key); + const ::substrait::Expression_Literal& key() const; + ::substrait::Expression_Literal* release_key(); + ::substrait::Expression_Literal* mutable_key(); + void set_allocated_key(::substrait::Expression_Literal* key); private: - const ::io::substrait::Expression_Literal& _internal_key() const; - ::io::substrait::Expression_Literal* _internal_mutable_key(); + const ::substrait::Expression_Literal& _internal_key() const; + ::substrait::Expression_Literal* _internal_mutable_key(); public: void unsafe_arena_set_allocated_key( - ::io::substrait::Expression_Literal* key); - ::io::substrait::Expression_Literal* unsafe_arena_release_key(); + ::substrait::Expression_Literal* key); + ::substrait::Expression_Literal* unsafe_arena_release_key(); - // .io.substrait.Expression.Literal value = 2; + // .substrait.Expression.Literal value = 2; bool has_value() const; private: bool _internal_has_value() const; public: void clear_value(); - const ::io::substrait::Expression_Literal& value() const; - ::io::substrait::Expression_Literal* release_value(); - ::io::substrait::Expression_Literal* mutable_value(); - void set_allocated_value(::io::substrait::Expression_Literal* value); + const ::substrait::Expression_Literal& value() const; + ::substrait::Expression_Literal* release_value(); + ::substrait::Expression_Literal* mutable_value(); + void set_allocated_value(::substrait::Expression_Literal* value); private: - const ::io::substrait::Expression_Literal& _internal_value() const; - ::io::substrait::Expression_Literal* _internal_mutable_value(); + const ::substrait::Expression_Literal& _internal_value() const; + ::substrait::Expression_Literal* _internal_mutable_value(); public: void unsafe_arena_set_allocated_value( - ::io::substrait::Expression_Literal* value); - ::io::substrait::Expression_Literal* unsafe_arena_release_value(); + ::substrait::Expression_Literal* value); + ::substrait::Expression_Literal* unsafe_arena_release_value(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.Map.KeyValue) + // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Map.KeyValue) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression_Literal* key_; - ::io::substrait::Expression_Literal* value_; + ::substrait::Expression_Literal* key_; + ::substrait::Expression_Literal* value_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Literal_Map PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.Map) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Map) */ { public: inline Expression_Literal_Map() : Expression_Literal_Map(nullptr) {} ~Expression_Literal_Map() override; @@ -1174,7 +1171,7 @@ class Expression_Literal_Map PROTOBUF_FINAL : void InternalSwap(Expression_Literal_Map* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Literal.Map"; + return "substrait.Expression.Literal.Map"; } protected: explicit Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1193,80 +1190,40 @@ class Expression_Literal_Map PROTOBUF_FINAL : enum : int { kKeyValuesFieldNumber = 1, - kKeyTypeFieldNumber = 2, - kValueTypeFieldNumber = 3, }; - // repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; + // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; int key_values_size() const; private: int _internal_key_values_size() const; public: void clear_key_values(); - ::io::substrait::Expression_Literal_Map_KeyValue* mutable_key_values(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >* + ::substrait::Expression_Literal_Map_KeyValue* mutable_key_values(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >* mutable_key_values(); private: - const ::io::substrait::Expression_Literal_Map_KeyValue& _internal_key_values(int index) const; - ::io::substrait::Expression_Literal_Map_KeyValue* _internal_add_key_values(); + const ::substrait::Expression_Literal_Map_KeyValue& _internal_key_values(int index) const; + ::substrait::Expression_Literal_Map_KeyValue* _internal_add_key_values(); public: - const ::io::substrait::Expression_Literal_Map_KeyValue& key_values(int index) const; - ::io::substrait::Expression_Literal_Map_KeyValue* add_key_values(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >& + const ::substrait::Expression_Literal_Map_KeyValue& key_values(int index) const; + ::substrait::Expression_Literal_Map_KeyValue* add_key_values(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >& key_values() const; - // .io.substrait.Type key_type = 2; - bool has_key_type() const; - private: - bool _internal_has_key_type() const; - public: - void clear_key_type(); - const ::io::substrait::Type& key_type() const; - ::io::substrait::Type* release_key_type(); - ::io::substrait::Type* mutable_key_type(); - void set_allocated_key_type(::io::substrait::Type* key_type); - private: - const ::io::substrait::Type& _internal_key_type() const; - ::io::substrait::Type* _internal_mutable_key_type(); - public: - void unsafe_arena_set_allocated_key_type( - ::io::substrait::Type* key_type); - ::io::substrait::Type* unsafe_arena_release_key_type(); - - // .io.substrait.Type value_type = 3; - bool has_value_type() const; - private: - bool _internal_has_value_type() const; - public: - void clear_value_type(); - const ::io::substrait::Type& value_type() const; - ::io::substrait::Type* release_value_type(); - ::io::substrait::Type* mutable_value_type(); - void set_allocated_value_type(::io::substrait::Type* value_type); - private: - const ::io::substrait::Type& _internal_value_type() const; - ::io::substrait::Type* _internal_mutable_value_type(); - public: - void unsafe_arena_set_allocated_value_type( - ::io::substrait::Type* value_type); - ::io::substrait::Type* unsafe_arena_release_value_type(); - - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.Map) + // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Map) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue > key_values_; - ::io::substrait::Type* key_type_; - ::io::substrait::Type* value_type_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue > key_values_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.IntervalYearToMonth) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.IntervalYearToMonth) */ { public: inline Expression_Literal_IntervalYearToMonth() : Expression_Literal_IntervalYearToMonth(nullptr) {} ~Expression_Literal_IntervalYearToMonth() override; @@ -1356,7 +1313,7 @@ class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : void InternalSwap(Expression_Literal_IntervalYearToMonth* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Literal.IntervalYearToMonth"; + return "substrait.Expression.Literal.IntervalYearToMonth"; } protected: explicit Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1393,7 +1350,7 @@ class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : void _internal_set_months(::PROTOBUF_NAMESPACE_ID::int32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.IntervalYearToMonth) + // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.IntervalYearToMonth) private: class _Internal; @@ -1403,12 +1360,12 @@ class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::int32 years_; ::PROTOBUF_NAMESPACE_ID::int32 months_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.IntervalDayToSecond) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.IntervalDayToSecond) */ { public: inline Expression_Literal_IntervalDayToSecond() : Expression_Literal_IntervalDayToSecond(nullptr) {} ~Expression_Literal_IntervalDayToSecond() override; @@ -1498,7 +1455,7 @@ class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : void InternalSwap(Expression_Literal_IntervalDayToSecond* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Literal.IntervalDayToSecond"; + return "substrait.Expression.Literal.IntervalDayToSecond"; } protected: explicit Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1535,7 +1492,7 @@ class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : void _internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.IntervalDayToSecond) + // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.IntervalDayToSecond) private: class _Internal; @@ -1545,12 +1502,12 @@ class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::int32 days_; ::PROTOBUF_NAMESPACE_ID::int32 seconds_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Literal_Struct PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.Struct) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Struct) */ { public: inline Expression_Literal_Struct() : Expression_Literal_Struct(nullptr) {} ~Expression_Literal_Struct() override; @@ -1640,7 +1597,7 @@ class Expression_Literal_Struct PROTOBUF_FINAL : void InternalSwap(Expression_Literal_Struct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Literal.Struct"; + return "substrait.Expression.Literal.Struct"; } protected: explicit Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1658,39 +1615,39 @@ class Expression_Literal_Struct PROTOBUF_FINAL : enum : int { kFieldsFieldNumber = 1, }; - // repeated .io.substrait.Expression.Literal fields = 1; + // repeated .substrait.Expression.Literal fields = 1; int fields_size() const; private: int _internal_fields_size() const; public: void clear_fields(); - ::io::substrait::Expression_Literal* mutable_fields(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* + ::substrait::Expression_Literal* mutable_fields(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >* mutable_fields(); private: - const ::io::substrait::Expression_Literal& _internal_fields(int index) const; - ::io::substrait::Expression_Literal* _internal_add_fields(); + const ::substrait::Expression_Literal& _internal_fields(int index) const; + ::substrait::Expression_Literal* _internal_add_fields(); public: - const ::io::substrait::Expression_Literal& fields(int index) const; - ::io::substrait::Expression_Literal* add_fields(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& + const ::substrait::Expression_Literal& fields(int index) const; + ::substrait::Expression_Literal* add_fields(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >& fields() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.Struct) + // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Struct) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal > fields_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal > fields_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Literal_List PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal.List) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.List) */ { public: inline Expression_Literal_List() : Expression_Literal_List(nullptr) {} ~Expression_Literal_List() override; @@ -1780,7 +1737,7 @@ class Expression_Literal_List PROTOBUF_FINAL : void InternalSwap(Expression_Literal_List* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Literal.List"; + return "substrait.Expression.Literal.List"; } protected: explicit Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1797,60 +1754,40 @@ class Expression_Literal_List PROTOBUF_FINAL : enum : int { kValuesFieldNumber = 1, - kElementTypeFieldNumber = 2, }; - // repeated .io.substrait.Expression.Literal values = 1; + // repeated .substrait.Expression.Literal values = 1; int values_size() const; private: int _internal_values_size() const; public: void clear_values(); - ::io::substrait::Expression_Literal* mutable_values(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* + ::substrait::Expression_Literal* mutable_values(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >* mutable_values(); private: - const ::io::substrait::Expression_Literal& _internal_values(int index) const; - ::io::substrait::Expression_Literal* _internal_add_values(); + const ::substrait::Expression_Literal& _internal_values(int index) const; + ::substrait::Expression_Literal* _internal_add_values(); public: - const ::io::substrait::Expression_Literal& values(int index) const; - ::io::substrait::Expression_Literal* add_values(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& + const ::substrait::Expression_Literal& values(int index) const; + ::substrait::Expression_Literal* add_values(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >& values() const; - // .io.substrait.Type element_type = 2; - bool has_element_type() const; - private: - bool _internal_has_element_type() const; - public: - void clear_element_type(); - const ::io::substrait::Type& element_type() const; - ::io::substrait::Type* release_element_type(); - ::io::substrait::Type* mutable_element_type(); - void set_allocated_element_type(::io::substrait::Type* element_type); - private: - const ::io::substrait::Type& _internal_element_type() const; - ::io::substrait::Type* _internal_mutable_element_type(); - public: - void unsafe_arena_set_allocated_element_type( - ::io::substrait::Type* element_type); - ::io::substrait::Type* unsafe_arena_release_element_type(); - - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal.List) + // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.List) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal > values_; - ::io::substrait::Type* element_type_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal > values_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Literal PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Literal) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal) */ { public: inline Expression_Literal() : Expression_Literal(nullptr) {} ~Expression_Literal() override; @@ -1912,6 +1849,8 @@ class Expression_Literal PROTOBUF_FINAL : kUuid = 28, kNull = 29, kList = 30, + kEmptyList = 31, + kEmptyMap = 32, LITERAL_TYPE_NOT_SET = 0, }; @@ -1968,7 +1907,7 @@ class Expression_Literal PROTOBUF_FINAL : void InternalSwap(Expression_Literal* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Literal"; + return "substrait.Expression.Literal"; } protected: explicit Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2017,6 +1956,8 @@ class Expression_Literal PROTOBUF_FINAL : kUuidFieldNumber = 28, kNullFieldNumber = 29, kListFieldNumber = 30, + kEmptyListFieldNumber = 31, + kEmptyMapFieldNumber = 32, }; // bool nullable = 50; void clear_nullable(); @@ -2167,17 +2108,17 @@ class Expression_Literal PROTOBUF_FINAL : void _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value); public: - // int64 date = 16; + // int32 date = 16; bool has_date() const; private: bool _internal_has_date() const; public: void clear_date(); - ::PROTOBUF_NAMESPACE_ID::int64 date() const; - void set_date(::PROTOBUF_NAMESPACE_ID::int64 value); + ::PROTOBUF_NAMESPACE_ID::int32 date() const; + void set_date(::PROTOBUF_NAMESPACE_ID::int32 value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_date() const; - void _internal_set_date(::PROTOBUF_NAMESPACE_ID::int64 value); + ::PROTOBUF_NAMESPACE_ID::int32 _internal_date() const; + void _internal_set_date(::PROTOBUF_NAMESPACE_ID::int32 value); public: // int64 time = 17; @@ -2193,41 +2134,41 @@ class Expression_Literal PROTOBUF_FINAL : void _internal_set_time(::PROTOBUF_NAMESPACE_ID::int64 value); public: - // .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; + // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; bool has_interval_year_to_month() const; private: bool _internal_has_interval_year_to_month() const; public: void clear_interval_year_to_month(); - const ::io::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month() const; - ::io::substrait::Expression_Literal_IntervalYearToMonth* release_interval_year_to_month(); - ::io::substrait::Expression_Literal_IntervalYearToMonth* mutable_interval_year_to_month(); - void set_allocated_interval_year_to_month(::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month); + const ::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month() const; + ::substrait::Expression_Literal_IntervalYearToMonth* release_interval_year_to_month(); + ::substrait::Expression_Literal_IntervalYearToMonth* mutable_interval_year_to_month(); + void set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month); private: - const ::io::substrait::Expression_Literal_IntervalYearToMonth& _internal_interval_year_to_month() const; - ::io::substrait::Expression_Literal_IntervalYearToMonth* _internal_mutable_interval_year_to_month(); + const ::substrait::Expression_Literal_IntervalYearToMonth& _internal_interval_year_to_month() const; + ::substrait::Expression_Literal_IntervalYearToMonth* _internal_mutable_interval_year_to_month(); public: void unsafe_arena_set_allocated_interval_year_to_month( - ::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month); - ::io::substrait::Expression_Literal_IntervalYearToMonth* unsafe_arena_release_interval_year_to_month(); + ::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month); + ::substrait::Expression_Literal_IntervalYearToMonth* unsafe_arena_release_interval_year_to_month(); - // .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; + // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; bool has_interval_day_to_second() const; private: bool _internal_has_interval_day_to_second() const; public: void clear_interval_day_to_second(); - const ::io::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second() const; - ::io::substrait::Expression_Literal_IntervalDayToSecond* release_interval_day_to_second(); - ::io::substrait::Expression_Literal_IntervalDayToSecond* mutable_interval_day_to_second(); - void set_allocated_interval_day_to_second(::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second); + const ::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second() const; + ::substrait::Expression_Literal_IntervalDayToSecond* release_interval_day_to_second(); + ::substrait::Expression_Literal_IntervalDayToSecond* mutable_interval_day_to_second(); + void set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second); private: - const ::io::substrait::Expression_Literal_IntervalDayToSecond& _internal_interval_day_to_second() const; - ::io::substrait::Expression_Literal_IntervalDayToSecond* _internal_mutable_interval_day_to_second(); + const ::substrait::Expression_Literal_IntervalDayToSecond& _internal_interval_day_to_second() const; + ::substrait::Expression_Literal_IntervalDayToSecond* _internal_mutable_interval_day_to_second(); public: void unsafe_arena_set_allocated_interval_day_to_second( - ::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second); - ::io::substrait::Expression_Literal_IntervalDayToSecond* unsafe_arena_release_interval_day_to_second(); + ::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second); + ::substrait::Expression_Literal_IntervalDayToSecond* unsafe_arena_release_interval_day_to_second(); // string fixed_char = 21; bool has_fixed_char() const; @@ -2247,23 +2188,23 @@ class Expression_Literal PROTOBUF_FINAL : std::string* _internal_mutable_fixed_char(); public: - // .io.substrait.Expression.Literal.VarChar var_char = 22; + // .substrait.Expression.Literal.VarChar var_char = 22; bool has_var_char() const; private: bool _internal_has_var_char() const; public: void clear_var_char(); - const ::io::substrait::Expression_Literal_VarChar& var_char() const; - ::io::substrait::Expression_Literal_VarChar* release_var_char(); - ::io::substrait::Expression_Literal_VarChar* mutable_var_char(); - void set_allocated_var_char(::io::substrait::Expression_Literal_VarChar* var_char); + const ::substrait::Expression_Literal_VarChar& var_char() const; + ::substrait::Expression_Literal_VarChar* release_var_char(); + ::substrait::Expression_Literal_VarChar* mutable_var_char(); + void set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char); private: - const ::io::substrait::Expression_Literal_VarChar& _internal_var_char() const; - ::io::substrait::Expression_Literal_VarChar* _internal_mutable_var_char(); + const ::substrait::Expression_Literal_VarChar& _internal_var_char() const; + ::substrait::Expression_Literal_VarChar* _internal_mutable_var_char(); public: void unsafe_arena_set_allocated_var_char( - ::io::substrait::Expression_Literal_VarChar* var_char); - ::io::substrait::Expression_Literal_VarChar* unsafe_arena_release_var_char(); + ::substrait::Expression_Literal_VarChar* var_char); + ::substrait::Expression_Literal_VarChar* unsafe_arena_release_var_char(); // bytes fixed_binary = 23; bool has_fixed_binary() const; @@ -2283,59 +2224,59 @@ class Expression_Literal PROTOBUF_FINAL : std::string* _internal_mutable_fixed_binary(); public: - // .io.substrait.Expression.Literal.Decimal decimal = 24; + // .substrait.Expression.Literal.Decimal decimal = 24; bool has_decimal() const; private: bool _internal_has_decimal() const; public: void clear_decimal(); - const ::io::substrait::Expression_Literal_Decimal& decimal() const; - ::io::substrait::Expression_Literal_Decimal* release_decimal(); - ::io::substrait::Expression_Literal_Decimal* mutable_decimal(); - void set_allocated_decimal(::io::substrait::Expression_Literal_Decimal* decimal); + const ::substrait::Expression_Literal_Decimal& decimal() const; + ::substrait::Expression_Literal_Decimal* release_decimal(); + ::substrait::Expression_Literal_Decimal* mutable_decimal(); + void set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal); private: - const ::io::substrait::Expression_Literal_Decimal& _internal_decimal() const; - ::io::substrait::Expression_Literal_Decimal* _internal_mutable_decimal(); + const ::substrait::Expression_Literal_Decimal& _internal_decimal() const; + ::substrait::Expression_Literal_Decimal* _internal_mutable_decimal(); public: void unsafe_arena_set_allocated_decimal( - ::io::substrait::Expression_Literal_Decimal* decimal); - ::io::substrait::Expression_Literal_Decimal* unsafe_arena_release_decimal(); + ::substrait::Expression_Literal_Decimal* decimal); + ::substrait::Expression_Literal_Decimal* unsafe_arena_release_decimal(); - // .io.substrait.Expression.Literal.Struct struct = 25; + // .substrait.Expression.Literal.Struct struct = 25; bool has_struct_() const; private: bool _internal_has_struct_() const; public: void clear_struct_(); - const ::io::substrait::Expression_Literal_Struct& struct_() const; - ::io::substrait::Expression_Literal_Struct* release_struct_(); - ::io::substrait::Expression_Literal_Struct* mutable_struct_(); - void set_allocated_struct_(::io::substrait::Expression_Literal_Struct* struct_); + const ::substrait::Expression_Literal_Struct& struct_() const; + ::substrait::Expression_Literal_Struct* release_struct_(); + ::substrait::Expression_Literal_Struct* mutable_struct_(); + void set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_); private: - const ::io::substrait::Expression_Literal_Struct& _internal_struct_() const; - ::io::substrait::Expression_Literal_Struct* _internal_mutable_struct_(); + const ::substrait::Expression_Literal_Struct& _internal_struct_() const; + ::substrait::Expression_Literal_Struct* _internal_mutable_struct_(); public: void unsafe_arena_set_allocated_struct_( - ::io::substrait::Expression_Literal_Struct* struct_); - ::io::substrait::Expression_Literal_Struct* unsafe_arena_release_struct_(); + ::substrait::Expression_Literal_Struct* struct_); + ::substrait::Expression_Literal_Struct* unsafe_arena_release_struct_(); - // .io.substrait.Expression.Literal.Map map = 26; + // .substrait.Expression.Literal.Map map = 26; bool has_map() const; private: bool _internal_has_map() const; public: void clear_map(); - const ::io::substrait::Expression_Literal_Map& map() const; - ::io::substrait::Expression_Literal_Map* release_map(); - ::io::substrait::Expression_Literal_Map* mutable_map(); - void set_allocated_map(::io::substrait::Expression_Literal_Map* map); + const ::substrait::Expression_Literal_Map& map() const; + ::substrait::Expression_Literal_Map* release_map(); + ::substrait::Expression_Literal_Map* mutable_map(); + void set_allocated_map(::substrait::Expression_Literal_Map* map); private: - const ::io::substrait::Expression_Literal_Map& _internal_map() const; - ::io::substrait::Expression_Literal_Map* _internal_mutable_map(); + const ::substrait::Expression_Literal_Map& _internal_map() const; + ::substrait::Expression_Literal_Map* _internal_mutable_map(); public: void unsafe_arena_set_allocated_map( - ::io::substrait::Expression_Literal_Map* map); - ::io::substrait::Expression_Literal_Map* unsafe_arena_release_map(); + ::substrait::Expression_Literal_Map* map); + ::substrait::Expression_Literal_Map* unsafe_arena_release_map(); // int64 timestamp_tz = 27; bool has_timestamp_tz() const; @@ -2368,45 +2309,81 @@ class Expression_Literal PROTOBUF_FINAL : std::string* _internal_mutable_uuid(); public: - // .io.substrait.Type null = 29; + // .substrait.Type null = 29; bool has_null() const; private: bool _internal_has_null() const; public: void clear_null(); - const ::io::substrait::Type& null() const; - ::io::substrait::Type* release_null(); - ::io::substrait::Type* mutable_null(); - void set_allocated_null(::io::substrait::Type* null); + const ::substrait::Type& null() const; + ::substrait::Type* release_null(); + ::substrait::Type* mutable_null(); + void set_allocated_null(::substrait::Type* null); private: - const ::io::substrait::Type& _internal_null() const; - ::io::substrait::Type* _internal_mutable_null(); + const ::substrait::Type& _internal_null() const; + ::substrait::Type* _internal_mutable_null(); public: void unsafe_arena_set_allocated_null( - ::io::substrait::Type* null); - ::io::substrait::Type* unsafe_arena_release_null(); + ::substrait::Type* null); + ::substrait::Type* unsafe_arena_release_null(); - // .io.substrait.Expression.Literal.List list = 30; + // .substrait.Expression.Literal.List list = 30; bool has_list() const; private: bool _internal_has_list() const; public: void clear_list(); - const ::io::substrait::Expression_Literal_List& list() const; - ::io::substrait::Expression_Literal_List* release_list(); - ::io::substrait::Expression_Literal_List* mutable_list(); - void set_allocated_list(::io::substrait::Expression_Literal_List* list); + const ::substrait::Expression_Literal_List& list() const; + ::substrait::Expression_Literal_List* release_list(); + ::substrait::Expression_Literal_List* mutable_list(); + void set_allocated_list(::substrait::Expression_Literal_List* list); private: - const ::io::substrait::Expression_Literal_List& _internal_list() const; - ::io::substrait::Expression_Literal_List* _internal_mutable_list(); + const ::substrait::Expression_Literal_List& _internal_list() const; + ::substrait::Expression_Literal_List* _internal_mutable_list(); public: void unsafe_arena_set_allocated_list( - ::io::substrait::Expression_Literal_List* list); - ::io::substrait::Expression_Literal_List* unsafe_arena_release_list(); + ::substrait::Expression_Literal_List* list); + ::substrait::Expression_Literal_List* unsafe_arena_release_list(); + + // .substrait.Type.List empty_list = 31; + bool has_empty_list() const; + private: + bool _internal_has_empty_list() const; + public: + void clear_empty_list(); + const ::substrait::Type_List& empty_list() const; + ::substrait::Type_List* release_empty_list(); + ::substrait::Type_List* mutable_empty_list(); + void set_allocated_empty_list(::substrait::Type_List* empty_list); + private: + const ::substrait::Type_List& _internal_empty_list() const; + ::substrait::Type_List* _internal_mutable_empty_list(); + public: + void unsafe_arena_set_allocated_empty_list( + ::substrait::Type_List* empty_list); + ::substrait::Type_List* unsafe_arena_release_empty_list(); + + // .substrait.Type.Map empty_map = 32; + bool has_empty_map() const; + private: + bool _internal_has_empty_map() const; + public: + void clear_empty_map(); + const ::substrait::Type_Map& empty_map() const; + ::substrait::Type_Map* release_empty_map(); + ::substrait::Type_Map* mutable_empty_map(); + void set_allocated_empty_map(::substrait::Type_Map* empty_map); + private: + const ::substrait::Type_Map& _internal_empty_map() const; + ::substrait::Type_Map* _internal_mutable_empty_map(); + public: + void unsafe_arena_set_allocated_empty_map( + ::substrait::Type_Map* empty_map); + ::substrait::Type_Map* unsafe_arena_release_empty_map(); void clear_literal_type(); LiteralTypeCase literal_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Literal) + // @@protoc_insertion_point(class_scope:substrait.Expression.Literal) private: class _Internal; void set_has_boolean(); @@ -2433,6 +2410,8 @@ class Expression_Literal PROTOBUF_FINAL : void set_has_uuid(); void set_has_null(); void set_has_list(); + void set_has_empty_list(); + void set_has_empty_map(); inline bool has_literal_type() const; inline void clear_has_literal_type(); @@ -2454,30 +2433,32 @@ class Expression_Literal PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_; ::PROTOBUF_NAMESPACE_ID::int64 timestamp_; - ::PROTOBUF_NAMESPACE_ID::int64 date_; + ::PROTOBUF_NAMESPACE_ID::int32 date_; ::PROTOBUF_NAMESPACE_ID::int64 time_; - ::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month_; - ::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second_; + ::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month_; + ::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_char_; - ::io::substrait::Expression_Literal_VarChar* var_char_; + ::substrait::Expression_Literal_VarChar* var_char_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_binary_; - ::io::substrait::Expression_Literal_Decimal* decimal_; - ::io::substrait::Expression_Literal_Struct* struct__; - ::io::substrait::Expression_Literal_Map* map_; + ::substrait::Expression_Literal_Decimal* decimal_; + ::substrait::Expression_Literal_Struct* struct__; + ::substrait::Expression_Literal_Map* map_; ::PROTOBUF_NAMESPACE_ID::int64 timestamp_tz_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uuid_; - ::io::substrait::Type* null_; - ::io::substrait::Expression_Literal_List* list_; + ::substrait::Type* null_; + ::substrait::Expression_Literal_List* list_; + ::substrait::Type_List* empty_list_; + ::substrait::Type_Map* empty_map_; } literal_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_ScalarFunction PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.ScalarFunction) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ScalarFunction) */ { public: inline Expression_ScalarFunction() : Expression_ScalarFunction(nullptr) {} ~Expression_ScalarFunction() override; @@ -2567,7 +2548,7 @@ class Expression_ScalarFunction PROTOBUF_FINAL : void InternalSwap(Expression_ScalarFunction* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.ScalarFunction"; + return "substrait.Expression.ScalarFunction"; } protected: explicit Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2587,41 +2568,41 @@ class Expression_ScalarFunction PROTOBUF_FINAL : kOutputTypeFieldNumber = 3, kFunctionReferenceFieldNumber = 1, }; - // repeated .io.substrait.Expression args = 2; + // repeated .substrait.Expression args = 2; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); - ::io::substrait::Expression* mutable_args(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + ::substrait::Expression* mutable_args(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* mutable_args(); private: - const ::io::substrait::Expression& _internal_args(int index) const; - ::io::substrait::Expression* _internal_add_args(); + const ::substrait::Expression& _internal_args(int index) const; + ::substrait::Expression* _internal_add_args(); public: - const ::io::substrait::Expression& args(int index) const; - ::io::substrait::Expression* add_args(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + const ::substrait::Expression& args(int index) const; + ::substrait::Expression* add_args(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& args() const; - // .io.substrait.Type output_type = 3; + // .substrait.Type output_type = 3; bool has_output_type() const; private: bool _internal_has_output_type() const; public: void clear_output_type(); - const ::io::substrait::Type& output_type() const; - ::io::substrait::Type* release_output_type(); - ::io::substrait::Type* mutable_output_type(); - void set_allocated_output_type(::io::substrait::Type* output_type); + const ::substrait::Type& output_type() const; + ::substrait::Type* release_output_type(); + ::substrait::Type* mutable_output_type(); + void set_allocated_output_type(::substrait::Type* output_type); private: - const ::io::substrait::Type& _internal_output_type() const; - ::io::substrait::Type* _internal_mutable_output_type(); + const ::substrait::Type& _internal_output_type() const; + ::substrait::Type* _internal_mutable_output_type(); public: void unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type); - ::io::substrait::Type* unsafe_arena_release_output_type(); + ::substrait::Type* output_type); + ::substrait::Type* unsafe_arena_release_output_type(); // uint32 function_reference = 1; void clear_function_reference(); @@ -2632,23 +2613,23 @@ class Expression_ScalarFunction PROTOBUF_FINAL : void _internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.ScalarFunction) + // @@protoc_insertion_point(class_scope:substrait.Expression.ScalarFunction) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > args_; - ::io::substrait::Type* output_type_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_; + ::substrait::Type* output_type_; ::PROTOBUF_NAMESPACE_ID::uint32 function_reference_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound.Preceding) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Preceding) */ { public: inline Expression_WindowFunction_Bound_Preceding() : Expression_WindowFunction_Bound_Preceding(nullptr) {} ~Expression_WindowFunction_Bound_Preceding() override; @@ -2738,7 +2719,7 @@ class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : void InternalSwap(Expression_WindowFunction_Bound_Preceding* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.WindowFunction.Bound.Preceding"; + return "substrait.Expression.WindowFunction.Bound.Preceding"; } protected: explicit Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2765,7 +2746,7 @@ class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction.Bound.Preceding) + // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Preceding) private: class _Internal; @@ -2774,12 +2755,12 @@ class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::int64 offset_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound.Following) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Following) */ { public: inline Expression_WindowFunction_Bound_Following() : Expression_WindowFunction_Bound_Following(nullptr) {} ~Expression_WindowFunction_Bound_Following() override; @@ -2869,7 +2850,7 @@ class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : void InternalSwap(Expression_WindowFunction_Bound_Following* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.WindowFunction.Bound.Following"; + return "substrait.Expression.WindowFunction.Bound.Following"; } protected: explicit Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2896,7 +2877,7 @@ class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction.Bound.Following) + // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Following) private: class _Internal; @@ -2905,12 +2886,12 @@ class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::int64 offset_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound.CurrentRow) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.CurrentRow) */ { public: inline Expression_WindowFunction_Bound_CurrentRow() : Expression_WindowFunction_Bound_CurrentRow(nullptr) {} ~Expression_WindowFunction_Bound_CurrentRow() override; @@ -3000,7 +2981,7 @@ class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : void InternalSwap(Expression_WindowFunction_Bound_CurrentRow* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.WindowFunction.Bound.CurrentRow"; + return "substrait.Expression.WindowFunction.Bound.CurrentRow"; } protected: explicit Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3015,7 +2996,7 @@ class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction.Bound.CurrentRow) + // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.CurrentRow) private: class _Internal; @@ -3023,12 +3004,12 @@ class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound.Unbounded) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Unbounded) */ { public: inline Expression_WindowFunction_Bound_Unbounded() : Expression_WindowFunction_Bound_Unbounded(nullptr) {} ~Expression_WindowFunction_Bound_Unbounded() override; @@ -3118,7 +3099,7 @@ class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : void InternalSwap(Expression_WindowFunction_Bound_Unbounded* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.WindowFunction.Bound.Unbounded"; + return "substrait.Expression.WindowFunction.Bound.Unbounded"; } protected: explicit Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3133,7 +3114,7 @@ class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction.Bound.Unbounded) + // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Unbounded) private: class _Internal; @@ -3141,12 +3122,12 @@ class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_WindowFunction_Bound PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction.Bound) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound) */ { public: inline Expression_WindowFunction_Bound() : Expression_WindowFunction_Bound(nullptr) {} ~Expression_WindowFunction_Bound() override; @@ -3244,7 +3225,7 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : void InternalSwap(Expression_WindowFunction_Bound* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.WindowFunction.Bound"; + return "substrait.Expression.WindowFunction.Bound"; } protected: explicit Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3270,81 +3251,81 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : kCurrentRowFieldNumber = 3, kUnboundedFieldNumber = 4, }; - // .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; + // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; bool has_preceding() const; private: bool _internal_has_preceding() const; public: void clear_preceding(); - const ::io::substrait::Expression_WindowFunction_Bound_Preceding& preceding() const; - ::io::substrait::Expression_WindowFunction_Bound_Preceding* release_preceding(); - ::io::substrait::Expression_WindowFunction_Bound_Preceding* mutable_preceding(); - void set_allocated_preceding(::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding); + const ::substrait::Expression_WindowFunction_Bound_Preceding& preceding() const; + ::substrait::Expression_WindowFunction_Bound_Preceding* release_preceding(); + ::substrait::Expression_WindowFunction_Bound_Preceding* mutable_preceding(); + void set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding); private: - const ::io::substrait::Expression_WindowFunction_Bound_Preceding& _internal_preceding() const; - ::io::substrait::Expression_WindowFunction_Bound_Preceding* _internal_mutable_preceding(); + const ::substrait::Expression_WindowFunction_Bound_Preceding& _internal_preceding() const; + ::substrait::Expression_WindowFunction_Bound_Preceding* _internal_mutable_preceding(); public: void unsafe_arena_set_allocated_preceding( - ::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding); - ::io::substrait::Expression_WindowFunction_Bound_Preceding* unsafe_arena_release_preceding(); + ::substrait::Expression_WindowFunction_Bound_Preceding* preceding); + ::substrait::Expression_WindowFunction_Bound_Preceding* unsafe_arena_release_preceding(); - // .io.substrait.Expression.WindowFunction.Bound.Following following = 2; + // .substrait.Expression.WindowFunction.Bound.Following following = 2; bool has_following() const; private: bool _internal_has_following() const; public: void clear_following(); - const ::io::substrait::Expression_WindowFunction_Bound_Following& following() const; - ::io::substrait::Expression_WindowFunction_Bound_Following* release_following(); - ::io::substrait::Expression_WindowFunction_Bound_Following* mutable_following(); - void set_allocated_following(::io::substrait::Expression_WindowFunction_Bound_Following* following); + const ::substrait::Expression_WindowFunction_Bound_Following& following() const; + ::substrait::Expression_WindowFunction_Bound_Following* release_following(); + ::substrait::Expression_WindowFunction_Bound_Following* mutable_following(); + void set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following); private: - const ::io::substrait::Expression_WindowFunction_Bound_Following& _internal_following() const; - ::io::substrait::Expression_WindowFunction_Bound_Following* _internal_mutable_following(); + const ::substrait::Expression_WindowFunction_Bound_Following& _internal_following() const; + ::substrait::Expression_WindowFunction_Bound_Following* _internal_mutable_following(); public: void unsafe_arena_set_allocated_following( - ::io::substrait::Expression_WindowFunction_Bound_Following* following); - ::io::substrait::Expression_WindowFunction_Bound_Following* unsafe_arena_release_following(); + ::substrait::Expression_WindowFunction_Bound_Following* following); + ::substrait::Expression_WindowFunction_Bound_Following* unsafe_arena_release_following(); - // .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; + // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; bool has_current_row() const; private: bool _internal_has_current_row() const; public: void clear_current_row(); - const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row() const; - ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* release_current_row(); - ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* mutable_current_row(); - void set_allocated_current_row(::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row); + const ::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row() const; + ::substrait::Expression_WindowFunction_Bound_CurrentRow* release_current_row(); + ::substrait::Expression_WindowFunction_Bound_CurrentRow* mutable_current_row(); + void set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row); private: - const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& _internal_current_row() const; - ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* _internal_mutable_current_row(); + const ::substrait::Expression_WindowFunction_Bound_CurrentRow& _internal_current_row() const; + ::substrait::Expression_WindowFunction_Bound_CurrentRow* _internal_mutable_current_row(); public: void unsafe_arena_set_allocated_current_row( - ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row); - ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* unsafe_arena_release_current_row(); + ::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row); + ::substrait::Expression_WindowFunction_Bound_CurrentRow* unsafe_arena_release_current_row(); - // .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; + // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; bool has_unbounded() const; private: bool _internal_has_unbounded() const; public: void clear_unbounded(); - const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded() const; - ::io::substrait::Expression_WindowFunction_Bound_Unbounded* release_unbounded(); - ::io::substrait::Expression_WindowFunction_Bound_Unbounded* mutable_unbounded(); - void set_allocated_unbounded(::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded); + const ::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded() const; + ::substrait::Expression_WindowFunction_Bound_Unbounded* release_unbounded(); + ::substrait::Expression_WindowFunction_Bound_Unbounded* mutable_unbounded(); + void set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded); private: - const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& _internal_unbounded() const; - ::io::substrait::Expression_WindowFunction_Bound_Unbounded* _internal_mutable_unbounded(); + const ::substrait::Expression_WindowFunction_Bound_Unbounded& _internal_unbounded() const; + ::substrait::Expression_WindowFunction_Bound_Unbounded* _internal_mutable_unbounded(); public: void unsafe_arena_set_allocated_unbounded( - ::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded); - ::io::substrait::Expression_WindowFunction_Bound_Unbounded* unsafe_arena_release_unbounded(); + ::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded); + ::substrait::Expression_WindowFunction_Bound_Unbounded* unsafe_arena_release_unbounded(); void clear_kind(); KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction.Bound) + // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound) private: class _Internal; void set_has_preceding(); @@ -3361,20 +3342,20 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : union KindUnion { constexpr KindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding_; - ::io::substrait::Expression_WindowFunction_Bound_Following* following_; - ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row_; - ::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded_; + ::substrait::Expression_WindowFunction_Bound_Preceding* preceding_; + ::substrait::Expression_WindowFunction_Bound_Following* following_; + ::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row_; + ::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_WindowFunction PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.WindowFunction) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction) */ { public: inline Expression_WindowFunction() : Expression_WindowFunction(nullptr) {} ~Expression_WindowFunction() override; @@ -3464,7 +3445,7 @@ class Expression_WindowFunction PROTOBUF_FINAL : void InternalSwap(Expression_WindowFunction* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.WindowFunction"; + return "substrait.Expression.WindowFunction"; } protected: explicit Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3491,113 +3472,113 @@ class Expression_WindowFunction PROTOBUF_FINAL : kFunctionReferenceFieldNumber = 1, kPhaseFieldNumber = 6, }; - // repeated .io.substrait.Expression partitions = 2; + // repeated .substrait.Expression partitions = 2; int partitions_size() const; private: int _internal_partitions_size() const; public: void clear_partitions(); - ::io::substrait::Expression* mutable_partitions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + ::substrait::Expression* mutable_partitions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* mutable_partitions(); private: - const ::io::substrait::Expression& _internal_partitions(int index) const; - ::io::substrait::Expression* _internal_add_partitions(); + const ::substrait::Expression& _internal_partitions(int index) const; + ::substrait::Expression* _internal_add_partitions(); public: - const ::io::substrait::Expression& partitions(int index) const; - ::io::substrait::Expression* add_partitions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + const ::substrait::Expression& partitions(int index) const; + ::substrait::Expression* add_partitions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& partitions() const; - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; int sorts_size() const; private: int _internal_sorts_size() const; public: void clear_sorts(); - ::io::substrait::SortField* mutable_sorts(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* + ::substrait::SortField* mutable_sorts(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* mutable_sorts(); private: - const ::io::substrait::SortField& _internal_sorts(int index) const; - ::io::substrait::SortField* _internal_add_sorts(); + const ::substrait::SortField& _internal_sorts(int index) const; + ::substrait::SortField* _internal_add_sorts(); public: - const ::io::substrait::SortField& sorts(int index) const; - ::io::substrait::SortField* add_sorts(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& + const ::substrait::SortField& sorts(int index) const; + ::substrait::SortField* add_sorts(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& sorts() const; - // repeated .io.substrait.Expression args = 8; + // repeated .substrait.Expression args = 8; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); - ::io::substrait::Expression* mutable_args(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + ::substrait::Expression* mutable_args(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* mutable_args(); private: - const ::io::substrait::Expression& _internal_args(int index) const; - ::io::substrait::Expression* _internal_add_args(); + const ::substrait::Expression& _internal_args(int index) const; + ::substrait::Expression* _internal_add_args(); public: - const ::io::substrait::Expression& args(int index) const; - ::io::substrait::Expression* add_args(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + const ::substrait::Expression& args(int index) const; + ::substrait::Expression* add_args(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& args() const; - // .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; + // .substrait.Expression.WindowFunction.Bound upper_bound = 4; bool has_upper_bound() const; private: bool _internal_has_upper_bound() const; public: void clear_upper_bound(); - const ::io::substrait::Expression_WindowFunction_Bound& upper_bound() const; - ::io::substrait::Expression_WindowFunction_Bound* release_upper_bound(); - ::io::substrait::Expression_WindowFunction_Bound* mutable_upper_bound(); - void set_allocated_upper_bound(::io::substrait::Expression_WindowFunction_Bound* upper_bound); + const ::substrait::Expression_WindowFunction_Bound& upper_bound() const; + ::substrait::Expression_WindowFunction_Bound* release_upper_bound(); + ::substrait::Expression_WindowFunction_Bound* mutable_upper_bound(); + void set_allocated_upper_bound(::substrait::Expression_WindowFunction_Bound* upper_bound); private: - const ::io::substrait::Expression_WindowFunction_Bound& _internal_upper_bound() const; - ::io::substrait::Expression_WindowFunction_Bound* _internal_mutable_upper_bound(); + const ::substrait::Expression_WindowFunction_Bound& _internal_upper_bound() const; + ::substrait::Expression_WindowFunction_Bound* _internal_mutable_upper_bound(); public: void unsafe_arena_set_allocated_upper_bound( - ::io::substrait::Expression_WindowFunction_Bound* upper_bound); - ::io::substrait::Expression_WindowFunction_Bound* unsafe_arena_release_upper_bound(); + ::substrait::Expression_WindowFunction_Bound* upper_bound); + ::substrait::Expression_WindowFunction_Bound* unsafe_arena_release_upper_bound(); - // .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; + // .substrait.Expression.WindowFunction.Bound lower_bound = 5; bool has_lower_bound() const; private: bool _internal_has_lower_bound() const; public: void clear_lower_bound(); - const ::io::substrait::Expression_WindowFunction_Bound& lower_bound() const; - ::io::substrait::Expression_WindowFunction_Bound* release_lower_bound(); - ::io::substrait::Expression_WindowFunction_Bound* mutable_lower_bound(); - void set_allocated_lower_bound(::io::substrait::Expression_WindowFunction_Bound* lower_bound); + const ::substrait::Expression_WindowFunction_Bound& lower_bound() const; + ::substrait::Expression_WindowFunction_Bound* release_lower_bound(); + ::substrait::Expression_WindowFunction_Bound* mutable_lower_bound(); + void set_allocated_lower_bound(::substrait::Expression_WindowFunction_Bound* lower_bound); private: - const ::io::substrait::Expression_WindowFunction_Bound& _internal_lower_bound() const; - ::io::substrait::Expression_WindowFunction_Bound* _internal_mutable_lower_bound(); + const ::substrait::Expression_WindowFunction_Bound& _internal_lower_bound() const; + ::substrait::Expression_WindowFunction_Bound* _internal_mutable_lower_bound(); public: void unsafe_arena_set_allocated_lower_bound( - ::io::substrait::Expression_WindowFunction_Bound* lower_bound); - ::io::substrait::Expression_WindowFunction_Bound* unsafe_arena_release_lower_bound(); + ::substrait::Expression_WindowFunction_Bound* lower_bound); + ::substrait::Expression_WindowFunction_Bound* unsafe_arena_release_lower_bound(); - // .io.substrait.Type output_type = 7; + // .substrait.Type output_type = 7; bool has_output_type() const; private: bool _internal_has_output_type() const; public: void clear_output_type(); - const ::io::substrait::Type& output_type() const; - ::io::substrait::Type* release_output_type(); - ::io::substrait::Type* mutable_output_type(); - void set_allocated_output_type(::io::substrait::Type* output_type); + const ::substrait::Type& output_type() const; + ::substrait::Type* release_output_type(); + ::substrait::Type* mutable_output_type(); + void set_allocated_output_type(::substrait::Type* output_type); private: - const ::io::substrait::Type& _internal_output_type() const; - ::io::substrait::Type* _internal_mutable_output_type(); + const ::substrait::Type& _internal_output_type() const; + ::substrait::Type* _internal_mutable_output_type(); public: void unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type); - ::io::substrait::Type* unsafe_arena_release_output_type(); + ::substrait::Type* output_type); + ::substrait::Type* unsafe_arena_release_output_type(); // uint32 function_reference = 1; void clear_function_reference(); @@ -3608,37 +3589,37 @@ class Expression_WindowFunction PROTOBUF_FINAL : void _internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.AggregationPhase phase = 6; + // .substrait.AggregationPhase phase = 6; void clear_phase(); - ::io::substrait::AggregationPhase phase() const; - void set_phase(::io::substrait::AggregationPhase value); + ::substrait::AggregationPhase phase() const; + void set_phase(::substrait::AggregationPhase value); private: - ::io::substrait::AggregationPhase _internal_phase() const; - void _internal_set_phase(::io::substrait::AggregationPhase value); + ::substrait::AggregationPhase _internal_phase() const; + void _internal_set_phase(::substrait::AggregationPhase value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.WindowFunction) + // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > partitions_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField > sorts_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > args_; - ::io::substrait::Expression_WindowFunction_Bound* upper_bound_; - ::io::substrait::Expression_WindowFunction_Bound* lower_bound_; - ::io::substrait::Type* output_type_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > partitions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField > sorts_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_; + ::substrait::Expression_WindowFunction_Bound* upper_bound_; + ::substrait::Expression_WindowFunction_Bound* lower_bound_; + ::substrait::Type* output_type_; ::PROTOBUF_NAMESPACE_ID::uint32 function_reference_; int phase_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_IfThen_IfClause PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.IfThen.IfClause) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.IfThen.IfClause) */ { public: inline Expression_IfThen_IfClause() : Expression_IfThen_IfClause(nullptr) {} ~Expression_IfThen_IfClause() override; @@ -3728,7 +3709,7 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : void InternalSwap(Expression_IfThen_IfClause* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.IfThen.IfClause"; + return "substrait.Expression.IfThen.IfClause"; } protected: explicit Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3747,58 +3728,58 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : kIfFieldNumber = 1, kThenFieldNumber = 2, }; - // .io.substrait.Expression if = 1; + // .substrait.Expression if = 1; bool has_if_() const; private: bool _internal_has_if_() const; public: void clear_if_(); - const ::io::substrait::Expression& if_() const; - ::io::substrait::Expression* release_if_(); - ::io::substrait::Expression* mutable_if_(); - void set_allocated_if_(::io::substrait::Expression* if_); + const ::substrait::Expression& if_() const; + ::substrait::Expression* release_if_(); + ::substrait::Expression* mutable_if_(); + void set_allocated_if_(::substrait::Expression* if_); private: - const ::io::substrait::Expression& _internal_if_() const; - ::io::substrait::Expression* _internal_mutable_if_(); + const ::substrait::Expression& _internal_if_() const; + ::substrait::Expression* _internal_mutable_if_(); public: void unsafe_arena_set_allocated_if_( - ::io::substrait::Expression* if_); - ::io::substrait::Expression* unsafe_arena_release_if_(); + ::substrait::Expression* if_); + ::substrait::Expression* unsafe_arena_release_if_(); - // .io.substrait.Expression then = 2; + // .substrait.Expression then = 2; bool has_then() const; private: bool _internal_has_then() const; public: void clear_then(); - const ::io::substrait::Expression& then() const; - ::io::substrait::Expression* release_then(); - ::io::substrait::Expression* mutable_then(); - void set_allocated_then(::io::substrait::Expression* then); + const ::substrait::Expression& then() const; + ::substrait::Expression* release_then(); + ::substrait::Expression* mutable_then(); + void set_allocated_then(::substrait::Expression* then); private: - const ::io::substrait::Expression& _internal_then() const; - ::io::substrait::Expression* _internal_mutable_then(); + const ::substrait::Expression& _internal_then() const; + ::substrait::Expression* _internal_mutable_then(); public: void unsafe_arena_set_allocated_then( - ::io::substrait::Expression* then); - ::io::substrait::Expression* unsafe_arena_release_then(); + ::substrait::Expression* then); + ::substrait::Expression* unsafe_arena_release_then(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.IfThen.IfClause) + // @@protoc_insertion_point(class_scope:substrait.Expression.IfThen.IfClause) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression* if__; - ::io::substrait::Expression* then_; + ::substrait::Expression* if__; + ::substrait::Expression* then_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_IfThen PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.IfThen) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.IfThen) */ { public: inline Expression_IfThen() : Expression_IfThen(nullptr) {} ~Expression_IfThen() override; @@ -3888,7 +3869,7 @@ class Expression_IfThen PROTOBUF_FINAL : void InternalSwap(Expression_IfThen* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.IfThen"; + return "substrait.Expression.IfThen"; } protected: explicit Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3909,58 +3890,58 @@ class Expression_IfThen PROTOBUF_FINAL : kIfsFieldNumber = 1, kElseFieldNumber = 2, }; - // repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; + // repeated .substrait.Expression.IfThen.IfClause ifs = 1; int ifs_size() const; private: int _internal_ifs_size() const; public: void clear_ifs(); - ::io::substrait::Expression_IfThen_IfClause* mutable_ifs(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >* + ::substrait::Expression_IfThen_IfClause* mutable_ifs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >* mutable_ifs(); private: - const ::io::substrait::Expression_IfThen_IfClause& _internal_ifs(int index) const; - ::io::substrait::Expression_IfThen_IfClause* _internal_add_ifs(); + const ::substrait::Expression_IfThen_IfClause& _internal_ifs(int index) const; + ::substrait::Expression_IfThen_IfClause* _internal_add_ifs(); public: - const ::io::substrait::Expression_IfThen_IfClause& ifs(int index) const; - ::io::substrait::Expression_IfThen_IfClause* add_ifs(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >& + const ::substrait::Expression_IfThen_IfClause& ifs(int index) const; + ::substrait::Expression_IfThen_IfClause* add_ifs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >& ifs() const; - // .io.substrait.Expression else = 2; + // .substrait.Expression else = 2; bool has_else_() const; private: bool _internal_has_else_() const; public: void clear_else_(); - const ::io::substrait::Expression& else_() const; - ::io::substrait::Expression* release_else_(); - ::io::substrait::Expression* mutable_else_(); - void set_allocated_else_(::io::substrait::Expression* else_); + const ::substrait::Expression& else_() const; + ::substrait::Expression* release_else_(); + ::substrait::Expression* mutable_else_(); + void set_allocated_else_(::substrait::Expression* else_); private: - const ::io::substrait::Expression& _internal_else_() const; - ::io::substrait::Expression* _internal_mutable_else_(); + const ::substrait::Expression& _internal_else_() const; + ::substrait::Expression* _internal_mutable_else_(); public: void unsafe_arena_set_allocated_else_( - ::io::substrait::Expression* else_); - ::io::substrait::Expression* unsafe_arena_release_else_(); + ::substrait::Expression* else_); + ::substrait::Expression* unsafe_arena_release_else_(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.IfThen) + // @@protoc_insertion_point(class_scope:substrait.Expression.IfThen) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause > ifs_; - ::io::substrait::Expression* else__; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause > ifs_; + ::substrait::Expression* else__; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_Cast PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.Cast) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Cast) */ { public: inline Expression_Cast() : Expression_Cast(nullptr) {} ~Expression_Cast() override; @@ -4050,7 +4031,7 @@ class Expression_Cast PROTOBUF_FINAL : void InternalSwap(Expression_Cast* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.Cast"; + return "substrait.Expression.Cast"; } protected: explicit Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4069,58 +4050,58 @@ class Expression_Cast PROTOBUF_FINAL : kTypeFieldNumber = 1, kInputFieldNumber = 2, }; - // .io.substrait.Type type = 1; + // .substrait.Type type = 1; bool has_type() const; private: bool _internal_has_type() const; public: void clear_type(); - const ::io::substrait::Type& type() const; - ::io::substrait::Type* release_type(); - ::io::substrait::Type* mutable_type(); - void set_allocated_type(::io::substrait::Type* type); + const ::substrait::Type& type() const; + ::substrait::Type* release_type(); + ::substrait::Type* mutable_type(); + void set_allocated_type(::substrait::Type* type); private: - const ::io::substrait::Type& _internal_type() const; - ::io::substrait::Type* _internal_mutable_type(); + const ::substrait::Type& _internal_type() const; + ::substrait::Type* _internal_mutable_type(); public: void unsafe_arena_set_allocated_type( - ::io::substrait::Type* type); - ::io::substrait::Type* unsafe_arena_release_type(); + ::substrait::Type* type); + ::substrait::Type* unsafe_arena_release_type(); - // .io.substrait.Expression input = 2; + // .substrait.Expression input = 2; bool has_input() const; private: bool _internal_has_input() const; public: void clear_input(); - const ::io::substrait::Expression& input() const; - ::io::substrait::Expression* release_input(); - ::io::substrait::Expression* mutable_input(); - void set_allocated_input(::io::substrait::Expression* input); + const ::substrait::Expression& input() const; + ::substrait::Expression* release_input(); + ::substrait::Expression* mutable_input(); + void set_allocated_input(::substrait::Expression* input); private: - const ::io::substrait::Expression& _internal_input() const; - ::io::substrait::Expression* _internal_mutable_input(); + const ::substrait::Expression& _internal_input() const; + ::substrait::Expression* _internal_mutable_input(); public: void unsafe_arena_set_allocated_input( - ::io::substrait::Expression* input); - ::io::substrait::Expression* unsafe_arena_release_input(); + ::substrait::Expression* input); + ::substrait::Expression* unsafe_arena_release_input(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.Cast) + // @@protoc_insertion_point(class_scope:substrait.Expression.Cast) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type* type_; - ::io::substrait::Expression* input_; + ::substrait::Type* type_; + ::substrait::Expression* input_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.SwitchExpression.IfValue) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SwitchExpression.IfValue) */ { public: inline Expression_SwitchExpression_IfValue() : Expression_SwitchExpression_IfValue(nullptr) {} ~Expression_SwitchExpression_IfValue() override; @@ -4210,7 +4191,7 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : void InternalSwap(Expression_SwitchExpression_IfValue* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.SwitchExpression.IfValue"; + return "substrait.Expression.SwitchExpression.IfValue"; } protected: explicit Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4229,58 +4210,58 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : kIfFieldNumber = 1, kThenFieldNumber = 2, }; - // .io.substrait.Expression.Literal if = 1; + // .substrait.Expression.Literal if = 1; bool has_if_() const; private: bool _internal_has_if_() const; public: void clear_if_(); - const ::io::substrait::Expression_Literal& if_() const; - ::io::substrait::Expression_Literal* release_if_(); - ::io::substrait::Expression_Literal* mutable_if_(); - void set_allocated_if_(::io::substrait::Expression_Literal* if_); + const ::substrait::Expression_Literal& if_() const; + ::substrait::Expression_Literal* release_if_(); + ::substrait::Expression_Literal* mutable_if_(); + void set_allocated_if_(::substrait::Expression_Literal* if_); private: - const ::io::substrait::Expression_Literal& _internal_if_() const; - ::io::substrait::Expression_Literal* _internal_mutable_if_(); + const ::substrait::Expression_Literal& _internal_if_() const; + ::substrait::Expression_Literal* _internal_mutable_if_(); public: void unsafe_arena_set_allocated_if_( - ::io::substrait::Expression_Literal* if_); - ::io::substrait::Expression_Literal* unsafe_arena_release_if_(); + ::substrait::Expression_Literal* if_); + ::substrait::Expression_Literal* unsafe_arena_release_if_(); - // .io.substrait.Expression then = 2; + // .substrait.Expression then = 2; bool has_then() const; private: bool _internal_has_then() const; public: void clear_then(); - const ::io::substrait::Expression& then() const; - ::io::substrait::Expression* release_then(); - ::io::substrait::Expression* mutable_then(); - void set_allocated_then(::io::substrait::Expression* then); + const ::substrait::Expression& then() const; + ::substrait::Expression* release_then(); + ::substrait::Expression* mutable_then(); + void set_allocated_then(::substrait::Expression* then); private: - const ::io::substrait::Expression& _internal_then() const; - ::io::substrait::Expression* _internal_mutable_then(); + const ::substrait::Expression& _internal_then() const; + ::substrait::Expression* _internal_mutable_then(); public: void unsafe_arena_set_allocated_then( - ::io::substrait::Expression* then); - ::io::substrait::Expression* unsafe_arena_release_then(); + ::substrait::Expression* then); + ::substrait::Expression* unsafe_arena_release_then(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.SwitchExpression.IfValue) + // @@protoc_insertion_point(class_scope:substrait.Expression.SwitchExpression.IfValue) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression_Literal* if__; - ::io::substrait::Expression* then_; + ::substrait::Expression_Literal* if__; + ::substrait::Expression* then_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_SwitchExpression PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.SwitchExpression) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SwitchExpression) */ { public: inline Expression_SwitchExpression() : Expression_SwitchExpression(nullptr) {} ~Expression_SwitchExpression() override; @@ -4370,7 +4351,7 @@ class Expression_SwitchExpression PROTOBUF_FINAL : void InternalSwap(Expression_SwitchExpression* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.SwitchExpression"; + return "substrait.Expression.SwitchExpression"; } protected: explicit Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4391,58 +4372,58 @@ class Expression_SwitchExpression PROTOBUF_FINAL : kIfsFieldNumber = 1, kElseFieldNumber = 2, }; - // repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; + // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; int ifs_size() const; private: int _internal_ifs_size() const; public: void clear_ifs(); - ::io::substrait::Expression_SwitchExpression_IfValue* mutable_ifs(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >* + ::substrait::Expression_SwitchExpression_IfValue* mutable_ifs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >* mutable_ifs(); private: - const ::io::substrait::Expression_SwitchExpression_IfValue& _internal_ifs(int index) const; - ::io::substrait::Expression_SwitchExpression_IfValue* _internal_add_ifs(); + const ::substrait::Expression_SwitchExpression_IfValue& _internal_ifs(int index) const; + ::substrait::Expression_SwitchExpression_IfValue* _internal_add_ifs(); public: - const ::io::substrait::Expression_SwitchExpression_IfValue& ifs(int index) const; - ::io::substrait::Expression_SwitchExpression_IfValue* add_ifs(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >& + const ::substrait::Expression_SwitchExpression_IfValue& ifs(int index) const; + ::substrait::Expression_SwitchExpression_IfValue* add_ifs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >& ifs() const; - // .io.substrait.Expression else = 2; + // .substrait.Expression else = 2; bool has_else_() const; private: bool _internal_has_else_() const; public: void clear_else_(); - const ::io::substrait::Expression& else_() const; - ::io::substrait::Expression* release_else_(); - ::io::substrait::Expression* mutable_else_(); - void set_allocated_else_(::io::substrait::Expression* else_); + const ::substrait::Expression& else_() const; + ::substrait::Expression* release_else_(); + ::substrait::Expression* mutable_else_(); + void set_allocated_else_(::substrait::Expression* else_); private: - const ::io::substrait::Expression& _internal_else_() const; - ::io::substrait::Expression* _internal_mutable_else_(); + const ::substrait::Expression& _internal_else_() const; + ::substrait::Expression* _internal_mutable_else_(); public: void unsafe_arena_set_allocated_else_( - ::io::substrait::Expression* else_); - ::io::substrait::Expression* unsafe_arena_release_else_(); + ::substrait::Expression* else_); + ::substrait::Expression* unsafe_arena_release_else_(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.SwitchExpression) + // @@protoc_insertion_point(class_scope:substrait.Expression.SwitchExpression) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue > ifs_; - ::io::substrait::Expression* else__; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue > ifs_; + ::substrait::Expression* else__; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_SingularOrList PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.SingularOrList) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SingularOrList) */ { public: inline Expression_SingularOrList() : Expression_SingularOrList(nullptr) {} ~Expression_SingularOrList() override; @@ -4532,7 +4513,7 @@ class Expression_SingularOrList PROTOBUF_FINAL : void InternalSwap(Expression_SingularOrList* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.SingularOrList"; + return "substrait.Expression.SingularOrList"; } protected: explicit Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4551,58 +4532,58 @@ class Expression_SingularOrList PROTOBUF_FINAL : kOptionsFieldNumber = 2, kValueFieldNumber = 1, }; - // repeated .io.substrait.Expression options = 2; + // repeated .substrait.Expression options = 2; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); - ::io::substrait::Expression* mutable_options(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + ::substrait::Expression* mutable_options(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* mutable_options(); private: - const ::io::substrait::Expression& _internal_options(int index) const; - ::io::substrait::Expression* _internal_add_options(); + const ::substrait::Expression& _internal_options(int index) const; + ::substrait::Expression* _internal_add_options(); public: - const ::io::substrait::Expression& options(int index) const; - ::io::substrait::Expression* add_options(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + const ::substrait::Expression& options(int index) const; + ::substrait::Expression* add_options(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& options() const; - // .io.substrait.Expression value = 1; + // .substrait.Expression value = 1; bool has_value() const; private: bool _internal_has_value() const; public: void clear_value(); - const ::io::substrait::Expression& value() const; - ::io::substrait::Expression* release_value(); - ::io::substrait::Expression* mutable_value(); - void set_allocated_value(::io::substrait::Expression* value); + const ::substrait::Expression& value() const; + ::substrait::Expression* release_value(); + ::substrait::Expression* mutable_value(); + void set_allocated_value(::substrait::Expression* value); private: - const ::io::substrait::Expression& _internal_value() const; - ::io::substrait::Expression* _internal_mutable_value(); + const ::substrait::Expression& _internal_value() const; + ::substrait::Expression* _internal_mutable_value(); public: void unsafe_arena_set_allocated_value( - ::io::substrait::Expression* value); - ::io::substrait::Expression* unsafe_arena_release_value(); + ::substrait::Expression* value); + ::substrait::Expression* unsafe_arena_release_value(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.SingularOrList) + // @@protoc_insertion_point(class_scope:substrait.Expression.SingularOrList) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > options_; - ::io::substrait::Expression* value_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > options_; + ::substrait::Expression* value_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MultiOrList_Record PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MultiOrList.Record) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MultiOrList.Record) */ { public: inline Expression_MultiOrList_Record() : Expression_MultiOrList_Record(nullptr) {} ~Expression_MultiOrList_Record() override; @@ -4692,7 +4673,7 @@ class Expression_MultiOrList_Record PROTOBUF_FINAL : void InternalSwap(Expression_MultiOrList_Record* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MultiOrList.Record"; + return "substrait.Expression.MultiOrList.Record"; } protected: explicit Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4710,39 +4691,39 @@ class Expression_MultiOrList_Record PROTOBUF_FINAL : enum : int { kFieldsFieldNumber = 1, }; - // repeated .io.substrait.Expression fields = 1; + // repeated .substrait.Expression fields = 1; int fields_size() const; private: int _internal_fields_size() const; public: void clear_fields(); - ::io::substrait::Expression* mutable_fields(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + ::substrait::Expression* mutable_fields(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* mutable_fields(); private: - const ::io::substrait::Expression& _internal_fields(int index) const; - ::io::substrait::Expression* _internal_add_fields(); + const ::substrait::Expression& _internal_fields(int index) const; + ::substrait::Expression* _internal_add_fields(); public: - const ::io::substrait::Expression& fields(int index) const; - ::io::substrait::Expression* add_fields(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + const ::substrait::Expression& fields(int index) const; + ::substrait::Expression* add_fields(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& fields() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MultiOrList.Record) + // @@protoc_insertion_point(class_scope:substrait.Expression.MultiOrList.Record) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > fields_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > fields_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MultiOrList PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MultiOrList) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MultiOrList) */ { public: inline Expression_MultiOrList() : Expression_MultiOrList(nullptr) {} ~Expression_MultiOrList() override; @@ -4832,7 +4813,7 @@ class Expression_MultiOrList PROTOBUF_FINAL : void InternalSwap(Expression_MultiOrList* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MultiOrList"; + return "substrait.Expression.MultiOrList"; } protected: explicit Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4853,58 +4834,58 @@ class Expression_MultiOrList PROTOBUF_FINAL : kValueFieldNumber = 1, kOptionsFieldNumber = 2, }; - // repeated .io.substrait.Expression value = 1; + // repeated .substrait.Expression value = 1; int value_size() const; private: int _internal_value_size() const; public: void clear_value(); - ::io::substrait::Expression* mutable_value(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + ::substrait::Expression* mutable_value(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* mutable_value(); private: - const ::io::substrait::Expression& _internal_value(int index) const; - ::io::substrait::Expression* _internal_add_value(); + const ::substrait::Expression& _internal_value(int index) const; + ::substrait::Expression* _internal_add_value(); public: - const ::io::substrait::Expression& value(int index) const; - ::io::substrait::Expression* add_value(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + const ::substrait::Expression& value(int index) const; + ::substrait::Expression* add_value(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& value() const; - // repeated .io.substrait.Expression.MultiOrList.Record options = 2; + // repeated .substrait.Expression.MultiOrList.Record options = 2; int options_size() const; private: int _internal_options_size() const; public: void clear_options(); - ::io::substrait::Expression_MultiOrList_Record* mutable_options(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >* + ::substrait::Expression_MultiOrList_Record* mutable_options(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >* mutable_options(); private: - const ::io::substrait::Expression_MultiOrList_Record& _internal_options(int index) const; - ::io::substrait::Expression_MultiOrList_Record* _internal_add_options(); + const ::substrait::Expression_MultiOrList_Record& _internal_options(int index) const; + ::substrait::Expression_MultiOrList_Record* _internal_add_options(); public: - const ::io::substrait::Expression_MultiOrList_Record& options(int index) const; - ::io::substrait::Expression_MultiOrList_Record* add_options(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >& + const ::substrait::Expression_MultiOrList_Record& options(int index) const; + ::substrait::Expression_MultiOrList_Record* add_options(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >& options() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MultiOrList) + // @@protoc_insertion_point(class_scope:substrait.Expression.MultiOrList) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > value_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record > options_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > value_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record > options_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction.PythonPickleFunction) */ { public: inline Expression_EmbeddedFunction_PythonPickleFunction() : Expression_EmbeddedFunction_PythonPickleFunction(nullptr) {} ~Expression_EmbeddedFunction_PythonPickleFunction() override; @@ -4994,7 +4975,7 @@ class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : void InternalSwap(Expression_EmbeddedFunction_PythonPickleFunction* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.EmbeddedFunction.PythonPickleFunction"; + return "substrait.Expression.EmbeddedFunction.PythonPickleFunction"; } protected: explicit Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -5051,7 +5032,7 @@ class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : std::string* _internal_mutable_function(); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction) + // @@protoc_insertion_point(class_scope:substrait.Expression.EmbeddedFunction.PythonPickleFunction) private: class _Internal; @@ -5061,12 +5042,12 @@ class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField prerequisite_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr function_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) */ { public: inline Expression_EmbeddedFunction_WebAssemblyFunction() : Expression_EmbeddedFunction_WebAssemblyFunction(nullptr) {} ~Expression_EmbeddedFunction_WebAssemblyFunction() override; @@ -5156,7 +5137,7 @@ class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : void InternalSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction"; + return "substrait.Expression.EmbeddedFunction.WebAssemblyFunction"; } protected: explicit Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -5213,7 +5194,7 @@ class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : std::string* _internal_mutable_script(); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + // @@protoc_insertion_point(class_scope:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) private: class _Internal; @@ -5223,12 +5204,12 @@ class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField prerequisite_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr script_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_EmbeddedFunction PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.EmbeddedFunction) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction) */ { public: inline Expression_EmbeddedFunction() : Expression_EmbeddedFunction(nullptr) {} ~Expression_EmbeddedFunction() override; @@ -5324,7 +5305,7 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : void InternalSwap(Expression_EmbeddedFunction* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.EmbeddedFunction"; + return "substrait.Expression.EmbeddedFunction"; } protected: explicit Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -5348,81 +5329,81 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : kPythonPickleFunctionFieldNumber = 3, kWebAssemblyFunctionFieldNumber = 4, }; - // repeated .io.substrait.Expression arguments = 1; + // repeated .substrait.Expression arguments = 1; int arguments_size() const; private: int _internal_arguments_size() const; public: void clear_arguments(); - ::io::substrait::Expression* mutable_arguments(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + ::substrait::Expression* mutable_arguments(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* mutable_arguments(); private: - const ::io::substrait::Expression& _internal_arguments(int index) const; - ::io::substrait::Expression* _internal_add_arguments(); + const ::substrait::Expression& _internal_arguments(int index) const; + ::substrait::Expression* _internal_add_arguments(); public: - const ::io::substrait::Expression& arguments(int index) const; - ::io::substrait::Expression* add_arguments(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + const ::substrait::Expression& arguments(int index) const; + ::substrait::Expression* add_arguments(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& arguments() const; - // .io.substrait.Type output_type = 2; + // .substrait.Type output_type = 2; bool has_output_type() const; private: bool _internal_has_output_type() const; public: void clear_output_type(); - const ::io::substrait::Type& output_type() const; - ::io::substrait::Type* release_output_type(); - ::io::substrait::Type* mutable_output_type(); - void set_allocated_output_type(::io::substrait::Type* output_type); + const ::substrait::Type& output_type() const; + ::substrait::Type* release_output_type(); + ::substrait::Type* mutable_output_type(); + void set_allocated_output_type(::substrait::Type* output_type); private: - const ::io::substrait::Type& _internal_output_type() const; - ::io::substrait::Type* _internal_mutable_output_type(); + const ::substrait::Type& _internal_output_type() const; + ::substrait::Type* _internal_mutable_output_type(); public: void unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type); - ::io::substrait::Type* unsafe_arena_release_output_type(); + ::substrait::Type* output_type); + ::substrait::Type* unsafe_arena_release_output_type(); - // .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; + // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; bool has_python_pickle_function() const; private: bool _internal_has_python_pickle_function() const; public: void clear_python_pickle_function(); - const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function() const; - ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* release_python_pickle_function(); - ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* mutable_python_pickle_function(); - void set_allocated_python_pickle_function(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function); + const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function() const; + ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* release_python_pickle_function(); + ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* mutable_python_pickle_function(); + void set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function); private: - const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& _internal_python_pickle_function() const; - ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* _internal_mutable_python_pickle_function(); + const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& _internal_python_pickle_function() const; + ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* _internal_mutable_python_pickle_function(); public: void unsafe_arena_set_allocated_python_pickle_function( - ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function); - ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* unsafe_arena_release_python_pickle_function(); + ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function); + ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* unsafe_arena_release_python_pickle_function(); - // .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; + // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; bool has_web_assembly_function() const; private: bool _internal_has_web_assembly_function() const; public: void clear_web_assembly_function(); - const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function() const; - ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* release_web_assembly_function(); - ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* mutable_web_assembly_function(); - void set_allocated_web_assembly_function(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function); + const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function() const; + ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* release_web_assembly_function(); + ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* mutable_web_assembly_function(); + void set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function); private: - const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& _internal_web_assembly_function() const; - ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* _internal_mutable_web_assembly_function(); + const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& _internal_web_assembly_function() const; + ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* _internal_mutable_web_assembly_function(); public: void unsafe_arena_set_allocated_web_assembly_function( - ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function); - ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* unsafe_arena_release_web_assembly_function(); + ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function); + ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* unsafe_arena_release_web_assembly_function(); void clear_kind(); KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.EmbeddedFunction) + // @@protoc_insertion_point(class_scope:substrait.Expression.EmbeddedFunction) private: class _Internal; void set_has_python_pickle_function(); @@ -5434,23 +5415,23 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > arguments_; - ::io::substrait::Type* output_type_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > arguments_; + ::substrait::Type* output_type_; union KindUnion { constexpr KindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function_; - ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function_; + ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function_; + ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.ReferenceSegment.MapKey) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.MapKey) */ { public: inline Expression_ReferenceSegment_MapKey() : Expression_ReferenceSegment_MapKey(nullptr) {} ~Expression_ReferenceSegment_MapKey() override; @@ -5540,7 +5521,7 @@ class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : void InternalSwap(Expression_ReferenceSegment_MapKey* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.ReferenceSegment.MapKey"; + return "substrait.Expression.ReferenceSegment.MapKey"; } protected: explicit Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -5559,58 +5540,58 @@ class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : kMapKeyFieldNumber = 1, kChildFieldNumber = 2, }; - // .io.substrait.Expression.Literal map_key = 1; + // .substrait.Expression.Literal map_key = 1; bool has_map_key() const; private: bool _internal_has_map_key() const; public: void clear_map_key(); - const ::io::substrait::Expression_Literal& map_key() const; - ::io::substrait::Expression_Literal* release_map_key(); - ::io::substrait::Expression_Literal* mutable_map_key(); - void set_allocated_map_key(::io::substrait::Expression_Literal* map_key); + const ::substrait::Expression_Literal& map_key() const; + ::substrait::Expression_Literal* release_map_key(); + ::substrait::Expression_Literal* mutable_map_key(); + void set_allocated_map_key(::substrait::Expression_Literal* map_key); private: - const ::io::substrait::Expression_Literal& _internal_map_key() const; - ::io::substrait::Expression_Literal* _internal_mutable_map_key(); + const ::substrait::Expression_Literal& _internal_map_key() const; + ::substrait::Expression_Literal* _internal_mutable_map_key(); public: void unsafe_arena_set_allocated_map_key( - ::io::substrait::Expression_Literal* map_key); - ::io::substrait::Expression_Literal* unsafe_arena_release_map_key(); + ::substrait::Expression_Literal* map_key); + ::substrait::Expression_Literal* unsafe_arena_release_map_key(); - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; bool has_child() const; private: bool _internal_has_child() const; public: void clear_child(); - const ::io::substrait::Expression_ReferenceSegment& child() const; - ::io::substrait::Expression_ReferenceSegment* release_child(); - ::io::substrait::Expression_ReferenceSegment* mutable_child(); - void set_allocated_child(::io::substrait::Expression_ReferenceSegment* child); + const ::substrait::Expression_ReferenceSegment& child() const; + ::substrait::Expression_ReferenceSegment* release_child(); + ::substrait::Expression_ReferenceSegment* mutable_child(); + void set_allocated_child(::substrait::Expression_ReferenceSegment* child); private: - const ::io::substrait::Expression_ReferenceSegment& _internal_child() const; - ::io::substrait::Expression_ReferenceSegment* _internal_mutable_child(); + const ::substrait::Expression_ReferenceSegment& _internal_child() const; + ::substrait::Expression_ReferenceSegment* _internal_mutable_child(); public: void unsafe_arena_set_allocated_child( - ::io::substrait::Expression_ReferenceSegment* child); - ::io::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); + ::substrait::Expression_ReferenceSegment* child); + ::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.ReferenceSegment.MapKey) + // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.MapKey) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression_Literal* map_key_; - ::io::substrait::Expression_ReferenceSegment* child_; + ::substrait::Expression_Literal* map_key_; + ::substrait::Expression_ReferenceSegment* child_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.ReferenceSegment.StructField) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.StructField) */ { public: inline Expression_ReferenceSegment_StructField() : Expression_ReferenceSegment_StructField(nullptr) {} ~Expression_ReferenceSegment_StructField() override; @@ -5700,7 +5681,7 @@ class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : void InternalSwap(Expression_ReferenceSegment_StructField* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.ReferenceSegment.StructField"; + return "substrait.Expression.ReferenceSegment.StructField"; } protected: explicit Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -5719,23 +5700,23 @@ class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : kChildFieldNumber = 2, kFieldFieldNumber = 1, }; - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; bool has_child() const; private: bool _internal_has_child() const; public: void clear_child(); - const ::io::substrait::Expression_ReferenceSegment& child() const; - ::io::substrait::Expression_ReferenceSegment* release_child(); - ::io::substrait::Expression_ReferenceSegment* mutable_child(); - void set_allocated_child(::io::substrait::Expression_ReferenceSegment* child); + const ::substrait::Expression_ReferenceSegment& child() const; + ::substrait::Expression_ReferenceSegment* release_child(); + ::substrait::Expression_ReferenceSegment* mutable_child(); + void set_allocated_child(::substrait::Expression_ReferenceSegment* child); private: - const ::io::substrait::Expression_ReferenceSegment& _internal_child() const; - ::io::substrait::Expression_ReferenceSegment* _internal_mutable_child(); + const ::substrait::Expression_ReferenceSegment& _internal_child() const; + ::substrait::Expression_ReferenceSegment* _internal_mutable_child(); public: void unsafe_arena_set_allocated_child( - ::io::substrait::Expression_ReferenceSegment* child); - ::io::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); + ::substrait::Expression_ReferenceSegment* child); + ::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); // int32 field = 1; void clear_field(); @@ -5746,22 +5727,22 @@ class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.ReferenceSegment.StructField) + // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.StructField) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression_ReferenceSegment* child_; + ::substrait::Expression_ReferenceSegment* child_; ::PROTOBUF_NAMESPACE_ID::int32 field_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.ReferenceSegment.ListElement) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.ListElement) */ { public: inline Expression_ReferenceSegment_ListElement() : Expression_ReferenceSegment_ListElement(nullptr) {} ~Expression_ReferenceSegment_ListElement() override; @@ -5851,7 +5832,7 @@ class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : void InternalSwap(Expression_ReferenceSegment_ListElement* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.ReferenceSegment.ListElement"; + return "substrait.Expression.ReferenceSegment.ListElement"; } protected: explicit Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -5870,23 +5851,23 @@ class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : kChildFieldNumber = 2, kOffsetFieldNumber = 1, }; - // .io.substrait.Expression.ReferenceSegment child = 2; + // .substrait.Expression.ReferenceSegment child = 2; bool has_child() const; private: bool _internal_has_child() const; public: void clear_child(); - const ::io::substrait::Expression_ReferenceSegment& child() const; - ::io::substrait::Expression_ReferenceSegment* release_child(); - ::io::substrait::Expression_ReferenceSegment* mutable_child(); - void set_allocated_child(::io::substrait::Expression_ReferenceSegment* child); + const ::substrait::Expression_ReferenceSegment& child() const; + ::substrait::Expression_ReferenceSegment* release_child(); + ::substrait::Expression_ReferenceSegment* mutable_child(); + void set_allocated_child(::substrait::Expression_ReferenceSegment* child); private: - const ::io::substrait::Expression_ReferenceSegment& _internal_child() const; - ::io::substrait::Expression_ReferenceSegment* _internal_mutable_child(); + const ::substrait::Expression_ReferenceSegment& _internal_child() const; + ::substrait::Expression_ReferenceSegment* _internal_mutable_child(); public: void unsafe_arena_set_allocated_child( - ::io::substrait::Expression_ReferenceSegment* child); - ::io::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); + ::substrait::Expression_ReferenceSegment* child); + ::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); // int32 offset = 1; void clear_offset(); @@ -5897,22 +5878,22 @@ class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.ReferenceSegment.ListElement) + // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.ListElement) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression_ReferenceSegment* child_; + ::substrait::Expression_ReferenceSegment* child_; ::PROTOBUF_NAMESPACE_ID::int32 offset_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_ReferenceSegment PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.ReferenceSegment) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment) */ { public: inline Expression_ReferenceSegment() : Expression_ReferenceSegment(nullptr) {} ~Expression_ReferenceSegment() override; @@ -6009,7 +5990,7 @@ class Expression_ReferenceSegment PROTOBUF_FINAL : void InternalSwap(Expression_ReferenceSegment* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.ReferenceSegment"; + return "substrait.Expression.ReferenceSegment"; } protected: explicit Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -6033,63 +6014,63 @@ class Expression_ReferenceSegment PROTOBUF_FINAL : kStructFieldFieldNumber = 2, kListElementFieldNumber = 3, }; - // .io.substrait.Expression.ReferenceSegment.MapKey map_key = 1; + // .substrait.Expression.ReferenceSegment.MapKey map_key = 1; bool has_map_key() const; private: bool _internal_has_map_key() const; public: void clear_map_key(); - const ::io::substrait::Expression_ReferenceSegment_MapKey& map_key() const; - ::io::substrait::Expression_ReferenceSegment_MapKey* release_map_key(); - ::io::substrait::Expression_ReferenceSegment_MapKey* mutable_map_key(); - void set_allocated_map_key(::io::substrait::Expression_ReferenceSegment_MapKey* map_key); + const ::substrait::Expression_ReferenceSegment_MapKey& map_key() const; + ::substrait::Expression_ReferenceSegment_MapKey* release_map_key(); + ::substrait::Expression_ReferenceSegment_MapKey* mutable_map_key(); + void set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key); private: - const ::io::substrait::Expression_ReferenceSegment_MapKey& _internal_map_key() const; - ::io::substrait::Expression_ReferenceSegment_MapKey* _internal_mutable_map_key(); + const ::substrait::Expression_ReferenceSegment_MapKey& _internal_map_key() const; + ::substrait::Expression_ReferenceSegment_MapKey* _internal_mutable_map_key(); public: void unsafe_arena_set_allocated_map_key( - ::io::substrait::Expression_ReferenceSegment_MapKey* map_key); - ::io::substrait::Expression_ReferenceSegment_MapKey* unsafe_arena_release_map_key(); + ::substrait::Expression_ReferenceSegment_MapKey* map_key); + ::substrait::Expression_ReferenceSegment_MapKey* unsafe_arena_release_map_key(); - // .io.substrait.Expression.ReferenceSegment.StructField struct_field = 2; + // .substrait.Expression.ReferenceSegment.StructField struct_field = 2; bool has_struct_field() const; private: bool _internal_has_struct_field() const; public: void clear_struct_field(); - const ::io::substrait::Expression_ReferenceSegment_StructField& struct_field() const; - ::io::substrait::Expression_ReferenceSegment_StructField* release_struct_field(); - ::io::substrait::Expression_ReferenceSegment_StructField* mutable_struct_field(); - void set_allocated_struct_field(::io::substrait::Expression_ReferenceSegment_StructField* struct_field); + const ::substrait::Expression_ReferenceSegment_StructField& struct_field() const; + ::substrait::Expression_ReferenceSegment_StructField* release_struct_field(); + ::substrait::Expression_ReferenceSegment_StructField* mutable_struct_field(); + void set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field); private: - const ::io::substrait::Expression_ReferenceSegment_StructField& _internal_struct_field() const; - ::io::substrait::Expression_ReferenceSegment_StructField* _internal_mutable_struct_field(); + const ::substrait::Expression_ReferenceSegment_StructField& _internal_struct_field() const; + ::substrait::Expression_ReferenceSegment_StructField* _internal_mutable_struct_field(); public: void unsafe_arena_set_allocated_struct_field( - ::io::substrait::Expression_ReferenceSegment_StructField* struct_field); - ::io::substrait::Expression_ReferenceSegment_StructField* unsafe_arena_release_struct_field(); + ::substrait::Expression_ReferenceSegment_StructField* struct_field); + ::substrait::Expression_ReferenceSegment_StructField* unsafe_arena_release_struct_field(); - // .io.substrait.Expression.ReferenceSegment.ListElement list_element = 3; + // .substrait.Expression.ReferenceSegment.ListElement list_element = 3; bool has_list_element() const; private: bool _internal_has_list_element() const; public: void clear_list_element(); - const ::io::substrait::Expression_ReferenceSegment_ListElement& list_element() const; - ::io::substrait::Expression_ReferenceSegment_ListElement* release_list_element(); - ::io::substrait::Expression_ReferenceSegment_ListElement* mutable_list_element(); - void set_allocated_list_element(::io::substrait::Expression_ReferenceSegment_ListElement* list_element); + const ::substrait::Expression_ReferenceSegment_ListElement& list_element() const; + ::substrait::Expression_ReferenceSegment_ListElement* release_list_element(); + ::substrait::Expression_ReferenceSegment_ListElement* mutable_list_element(); + void set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element); private: - const ::io::substrait::Expression_ReferenceSegment_ListElement& _internal_list_element() const; - ::io::substrait::Expression_ReferenceSegment_ListElement* _internal_mutable_list_element(); + const ::substrait::Expression_ReferenceSegment_ListElement& _internal_list_element() const; + ::substrait::Expression_ReferenceSegment_ListElement* _internal_mutable_list_element(); public: void unsafe_arena_set_allocated_list_element( - ::io::substrait::Expression_ReferenceSegment_ListElement* list_element); - ::io::substrait::Expression_ReferenceSegment_ListElement* unsafe_arena_release_list_element(); + ::substrait::Expression_ReferenceSegment_ListElement* list_element); + ::substrait::Expression_ReferenceSegment_ListElement* unsafe_arena_release_list_element(); void clear_reference_type(); ReferenceTypeCase reference_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.ReferenceSegment) + // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment) private: class _Internal; void set_has_map_key(); @@ -6105,19 +6086,19 @@ class Expression_ReferenceSegment PROTOBUF_FINAL : union ReferenceTypeUnion { constexpr ReferenceTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Expression_ReferenceSegment_MapKey* map_key_; - ::io::substrait::Expression_ReferenceSegment_StructField* struct_field_; - ::io::substrait::Expression_ReferenceSegment_ListElement* list_element_; + ::substrait::Expression_ReferenceSegment_MapKey* map_key_; + ::substrait::Expression_ReferenceSegment_StructField* struct_field_; + ::substrait::Expression_ReferenceSegment_ListElement* list_element_; } reference_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression_Select PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.Select) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.Select) */ { public: inline Expression_MaskExpression_Select() : Expression_MaskExpression_Select(nullptr) {} ~Expression_MaskExpression_Select() override; @@ -6214,7 +6195,7 @@ class Expression_MaskExpression_Select PROTOBUF_FINAL : void InternalSwap(Expression_MaskExpression_Select* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression.Select"; + return "substrait.Expression.MaskExpression.Select"; } protected: explicit Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -6234,63 +6215,63 @@ class Expression_MaskExpression_Select PROTOBUF_FINAL : kListFieldNumber = 2, kMapFieldNumber = 3, }; - // .io.substrait.Expression.MaskExpression.StructSelect struct = 1; + // .substrait.Expression.MaskExpression.StructSelect struct = 1; bool has_struct_() const; private: bool _internal_has_struct_() const; public: void clear_struct_(); - const ::io::substrait::Expression_MaskExpression_StructSelect& struct_() const; - ::io::substrait::Expression_MaskExpression_StructSelect* release_struct_(); - ::io::substrait::Expression_MaskExpression_StructSelect* mutable_struct_(); - void set_allocated_struct_(::io::substrait::Expression_MaskExpression_StructSelect* struct_); + const ::substrait::Expression_MaskExpression_StructSelect& struct_() const; + ::substrait::Expression_MaskExpression_StructSelect* release_struct_(); + ::substrait::Expression_MaskExpression_StructSelect* mutable_struct_(); + void set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_); private: - const ::io::substrait::Expression_MaskExpression_StructSelect& _internal_struct_() const; - ::io::substrait::Expression_MaskExpression_StructSelect* _internal_mutable_struct_(); + const ::substrait::Expression_MaskExpression_StructSelect& _internal_struct_() const; + ::substrait::Expression_MaskExpression_StructSelect* _internal_mutable_struct_(); public: void unsafe_arena_set_allocated_struct_( - ::io::substrait::Expression_MaskExpression_StructSelect* struct_); - ::io::substrait::Expression_MaskExpression_StructSelect* unsafe_arena_release_struct_(); + ::substrait::Expression_MaskExpression_StructSelect* struct_); + ::substrait::Expression_MaskExpression_StructSelect* unsafe_arena_release_struct_(); - // .io.substrait.Expression.MaskExpression.ListSelect list = 2; + // .substrait.Expression.MaskExpression.ListSelect list = 2; bool has_list() const; private: bool _internal_has_list() const; public: void clear_list(); - const ::io::substrait::Expression_MaskExpression_ListSelect& list() const; - ::io::substrait::Expression_MaskExpression_ListSelect* release_list(); - ::io::substrait::Expression_MaskExpression_ListSelect* mutable_list(); - void set_allocated_list(::io::substrait::Expression_MaskExpression_ListSelect* list); + const ::substrait::Expression_MaskExpression_ListSelect& list() const; + ::substrait::Expression_MaskExpression_ListSelect* release_list(); + ::substrait::Expression_MaskExpression_ListSelect* mutable_list(); + void set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list); private: - const ::io::substrait::Expression_MaskExpression_ListSelect& _internal_list() const; - ::io::substrait::Expression_MaskExpression_ListSelect* _internal_mutable_list(); + const ::substrait::Expression_MaskExpression_ListSelect& _internal_list() const; + ::substrait::Expression_MaskExpression_ListSelect* _internal_mutable_list(); public: void unsafe_arena_set_allocated_list( - ::io::substrait::Expression_MaskExpression_ListSelect* list); - ::io::substrait::Expression_MaskExpression_ListSelect* unsafe_arena_release_list(); + ::substrait::Expression_MaskExpression_ListSelect* list); + ::substrait::Expression_MaskExpression_ListSelect* unsafe_arena_release_list(); - // .io.substrait.Expression.MaskExpression.MapSelect map = 3; + // .substrait.Expression.MaskExpression.MapSelect map = 3; bool has_map() const; private: bool _internal_has_map() const; public: void clear_map(); - const ::io::substrait::Expression_MaskExpression_MapSelect& map() const; - ::io::substrait::Expression_MaskExpression_MapSelect* release_map(); - ::io::substrait::Expression_MaskExpression_MapSelect* mutable_map(); - void set_allocated_map(::io::substrait::Expression_MaskExpression_MapSelect* map); + const ::substrait::Expression_MaskExpression_MapSelect& map() const; + ::substrait::Expression_MaskExpression_MapSelect* release_map(); + ::substrait::Expression_MaskExpression_MapSelect* mutable_map(); + void set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map); private: - const ::io::substrait::Expression_MaskExpression_MapSelect& _internal_map() const; - ::io::substrait::Expression_MaskExpression_MapSelect* _internal_mutable_map(); + const ::substrait::Expression_MaskExpression_MapSelect& _internal_map() const; + ::substrait::Expression_MaskExpression_MapSelect* _internal_mutable_map(); public: void unsafe_arena_set_allocated_map( - ::io::substrait::Expression_MaskExpression_MapSelect* map); - ::io::substrait::Expression_MaskExpression_MapSelect* unsafe_arena_release_map(); + ::substrait::Expression_MaskExpression_MapSelect* map); + ::substrait::Expression_MaskExpression_MapSelect* unsafe_arena_release_map(); void clear_type(); TypeCase type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.Select) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.Select) private: class _Internal; void set_has_struct_(); @@ -6306,19 +6287,19 @@ class Expression_MaskExpression_Select PROTOBUF_FINAL : union TypeUnion { constexpr TypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Expression_MaskExpression_StructSelect* struct__; - ::io::substrait::Expression_MaskExpression_ListSelect* list_; - ::io::substrait::Expression_MaskExpression_MapSelect* map_; + ::substrait::Expression_MaskExpression_StructSelect* struct__; + ::substrait::Expression_MaskExpression_ListSelect* list_; + ::substrait::Expression_MaskExpression_MapSelect* map_; } type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression_StructSelect PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.StructSelect) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.StructSelect) */ { public: inline Expression_MaskExpression_StructSelect() : Expression_MaskExpression_StructSelect(nullptr) {} ~Expression_MaskExpression_StructSelect() override; @@ -6408,7 +6389,7 @@ class Expression_MaskExpression_StructSelect PROTOBUF_FINAL : void InternalSwap(Expression_MaskExpression_StructSelect* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression.StructSelect"; + return "substrait.Expression.MaskExpression.StructSelect"; } protected: explicit Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -6426,39 +6407,39 @@ class Expression_MaskExpression_StructSelect PROTOBUF_FINAL : enum : int { kStructItemsFieldNumber = 1, }; - // repeated .io.substrait.Expression.MaskExpression.StructItem struct_items = 1; + // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; int struct_items_size() const; private: int _internal_struct_items_size() const; public: void clear_struct_items(); - ::io::substrait::Expression_MaskExpression_StructItem* mutable_struct_items(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_StructItem >* + ::substrait::Expression_MaskExpression_StructItem* mutable_struct_items(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >* mutable_struct_items(); private: - const ::io::substrait::Expression_MaskExpression_StructItem& _internal_struct_items(int index) const; - ::io::substrait::Expression_MaskExpression_StructItem* _internal_add_struct_items(); + const ::substrait::Expression_MaskExpression_StructItem& _internal_struct_items(int index) const; + ::substrait::Expression_MaskExpression_StructItem* _internal_add_struct_items(); public: - const ::io::substrait::Expression_MaskExpression_StructItem& struct_items(int index) const; - ::io::substrait::Expression_MaskExpression_StructItem* add_struct_items(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_StructItem >& + const ::substrait::Expression_MaskExpression_StructItem& struct_items(int index) const; + ::substrait::Expression_MaskExpression_StructItem* add_struct_items(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >& struct_items() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.StructSelect) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.StructSelect) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_StructItem > struct_items_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem > struct_items_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression_StructItem PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.StructItem) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.StructItem) */ { public: inline Expression_MaskExpression_StructItem() : Expression_MaskExpression_StructItem(nullptr) {} ~Expression_MaskExpression_StructItem() override; @@ -6548,7 +6529,7 @@ class Expression_MaskExpression_StructItem PROTOBUF_FINAL : void InternalSwap(Expression_MaskExpression_StructItem* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression.StructItem"; + return "substrait.Expression.MaskExpression.StructItem"; } protected: explicit Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -6567,23 +6548,23 @@ class Expression_MaskExpression_StructItem PROTOBUF_FINAL : kChildFieldNumber = 2, kFieldFieldNumber = 1, }; - // .io.substrait.Expression.MaskExpression.Select child = 2; + // .substrait.Expression.MaskExpression.Select child = 2; bool has_child() const; private: bool _internal_has_child() const; public: void clear_child(); - const ::io::substrait::Expression_MaskExpression_Select& child() const; - ::io::substrait::Expression_MaskExpression_Select* release_child(); - ::io::substrait::Expression_MaskExpression_Select* mutable_child(); - void set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child); + const ::substrait::Expression_MaskExpression_Select& child() const; + ::substrait::Expression_MaskExpression_Select* release_child(); + ::substrait::Expression_MaskExpression_Select* mutable_child(); + void set_allocated_child(::substrait::Expression_MaskExpression_Select* child); private: - const ::io::substrait::Expression_MaskExpression_Select& _internal_child() const; - ::io::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); + const ::substrait::Expression_MaskExpression_Select& _internal_child() const; + ::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); public: void unsafe_arena_set_allocated_child( - ::io::substrait::Expression_MaskExpression_Select* child); - ::io::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); + ::substrait::Expression_MaskExpression_Select* child); + ::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); // int32 field = 1; void clear_field(); @@ -6594,22 +6575,22 @@ class Expression_MaskExpression_StructItem PROTOBUF_FINAL : void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.StructItem) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.StructItem) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression_MaskExpression_Select* child_; + ::substrait::Expression_MaskExpression_Select* child_; ::PROTOBUF_NAMESPACE_ID::int32 field_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) */ { public: inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() : Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(nullptr) {} ~Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() override; @@ -6699,7 +6680,7 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_F void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement"; + return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement"; } protected: explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -6726,7 +6707,7 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_F void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) private: class _Internal; @@ -6735,12 +6716,12 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_F typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::int32 field_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) */ { public: inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() : Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(nullptr) {} ~Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() override; @@ -6830,7 +6811,7 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FIN void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice"; + return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice"; } protected: explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -6867,7 +6848,7 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FIN void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) private: class _Internal; @@ -6877,12 +6858,12 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FIN ::PROTOBUF_NAMESPACE_ID::int32 start_; ::PROTOBUF_NAMESPACE_ID::int32 end_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) */ { public: inline Expression_MaskExpression_ListSelect_ListSelectItem() : Expression_MaskExpression_ListSelect_ListSelectItem(nullptr) {} ~Expression_MaskExpression_ListSelect_ListSelectItem() override; @@ -6978,7 +6959,7 @@ class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem"; + return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem"; } protected: explicit Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -7000,45 +6981,45 @@ class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : kItemFieldNumber = 1, kSliceFieldNumber = 2, }; - // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; + // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; bool has_item() const; private: bool _internal_has_item() const; public: void clear_item(); - const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item() const; - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* release_item(); - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* mutable_item(); - void set_allocated_item(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item); + const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item() const; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* release_item(); + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* mutable_item(); + void set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item); private: - const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& _internal_item() const; - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _internal_mutable_item(); + const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& _internal_item() const; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _internal_mutable_item(); public: void unsafe_arena_set_allocated_item( - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item); - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* unsafe_arena_release_item(); + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item); + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* unsafe_arena_release_item(); - // .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; + // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; bool has_slice() const; private: bool _internal_has_slice() const; public: void clear_slice(); - const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice() const; - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* release_slice(); - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* mutable_slice(); - void set_allocated_slice(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); + const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice() const; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* release_slice(); + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* mutable_slice(); + void set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); private: - const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& _internal_slice() const; - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _internal_mutable_slice(); + const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& _internal_slice() const; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _internal_mutable_slice(); public: void unsafe_arena_set_allocated_slice( - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* unsafe_arena_release_slice(); + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* unsafe_arena_release_slice(); void clear_type(); TypeCase type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) private: class _Internal; void set_has_item(); @@ -7053,18 +7034,18 @@ class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : union TypeUnion { constexpr TypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item_; - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice_; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item_; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice_; } type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression_ListSelect PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.ListSelect) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect) */ { public: inline Expression_MaskExpression_ListSelect() : Expression_MaskExpression_ListSelect(nullptr) {} ~Expression_MaskExpression_ListSelect() override; @@ -7154,7 +7135,7 @@ class Expression_MaskExpression_ListSelect PROTOBUF_FINAL : void InternalSwap(Expression_MaskExpression_ListSelect* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression.ListSelect"; + return "substrait.Expression.MaskExpression.ListSelect"; } protected: explicit Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -7175,58 +7156,58 @@ class Expression_MaskExpression_ListSelect PROTOBUF_FINAL : kSelectionFieldNumber = 1, kChildFieldNumber = 2, }; - // repeated .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; + // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; int selection_size() const; private: int _internal_selection_size() const; public: void clear_selection(); - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* mutable_selection(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >* + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* mutable_selection(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >* mutable_selection(); private: - const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& _internal_selection(int index) const; - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* _internal_add_selection(); + const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& _internal_selection(int index) const; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* _internal_add_selection(); public: - const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& selection(int index) const; - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* add_selection(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >& + const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& selection(int index) const; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* add_selection(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >& selection() const; - // .io.substrait.Expression.MaskExpression.Select child = 2; + // .substrait.Expression.MaskExpression.Select child = 2; bool has_child() const; private: bool _internal_has_child() const; public: void clear_child(); - const ::io::substrait::Expression_MaskExpression_Select& child() const; - ::io::substrait::Expression_MaskExpression_Select* release_child(); - ::io::substrait::Expression_MaskExpression_Select* mutable_child(); - void set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child); + const ::substrait::Expression_MaskExpression_Select& child() const; + ::substrait::Expression_MaskExpression_Select* release_child(); + ::substrait::Expression_MaskExpression_Select* mutable_child(); + void set_allocated_child(::substrait::Expression_MaskExpression_Select* child); private: - const ::io::substrait::Expression_MaskExpression_Select& _internal_child() const; - ::io::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); + const ::substrait::Expression_MaskExpression_Select& _internal_child() const; + ::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); public: void unsafe_arena_set_allocated_child( - ::io::substrait::Expression_MaskExpression_Select* child); - ::io::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); + ::substrait::Expression_MaskExpression_Select* child); + ::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.ListSelect) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem > selection_; - ::io::substrait::Expression_MaskExpression_Select* child_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem > selection_; + ::substrait::Expression_MaskExpression_Select* child_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.MapSelect.MapKey) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect.MapKey) */ { public: inline Expression_MaskExpression_MapSelect_MapKey() : Expression_MaskExpression_MapSelect_MapKey(nullptr) {} ~Expression_MaskExpression_MapSelect_MapKey() override; @@ -7316,7 +7297,7 @@ class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : void InternalSwap(Expression_MaskExpression_MapSelect_MapKey* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression.MapSelect.MapKey"; + return "substrait.Expression.MaskExpression.MapSelect.MapKey"; } protected: explicit Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -7348,7 +7329,7 @@ class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : std::string* _internal_mutable_map_key(); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.MapSelect.MapKey) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.MapSelect.MapKey) private: class _Internal; @@ -7357,12 +7338,12 @@ class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) */ { public: inline Expression_MaskExpression_MapSelect_MapKeyExpression() : Expression_MaskExpression_MapSelect_MapKeyExpression(nullptr) {} ~Expression_MaskExpression_MapSelect_MapKeyExpression() override; @@ -7452,7 +7433,7 @@ class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : void InternalSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression"; + return "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression"; } protected: explicit Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -7484,7 +7465,7 @@ class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : std::string* _internal_mutable_map_key_expression(); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) private: class _Internal; @@ -7493,12 +7474,12 @@ class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_expression_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression.MapSelect) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect) */ { public: inline Expression_MaskExpression_MapSelect() : Expression_MaskExpression_MapSelect(nullptr) {} ~Expression_MaskExpression_MapSelect() override; @@ -7594,7 +7575,7 @@ class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : void InternalSwap(Expression_MaskExpression_MapSelect* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression.MapSelect"; + return "substrait.Expression.MaskExpression.MapSelect"; } protected: explicit Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -7617,63 +7598,63 @@ class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : kKeyFieldNumber = 1, kExpressionFieldNumber = 2, }; - // .io.substrait.Expression.MaskExpression.Select child = 3; + // .substrait.Expression.MaskExpression.Select child = 3; bool has_child() const; private: bool _internal_has_child() const; public: void clear_child(); - const ::io::substrait::Expression_MaskExpression_Select& child() const; - ::io::substrait::Expression_MaskExpression_Select* release_child(); - ::io::substrait::Expression_MaskExpression_Select* mutable_child(); - void set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child); + const ::substrait::Expression_MaskExpression_Select& child() const; + ::substrait::Expression_MaskExpression_Select* release_child(); + ::substrait::Expression_MaskExpression_Select* mutable_child(); + void set_allocated_child(::substrait::Expression_MaskExpression_Select* child); private: - const ::io::substrait::Expression_MaskExpression_Select& _internal_child() const; - ::io::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); + const ::substrait::Expression_MaskExpression_Select& _internal_child() const; + ::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); public: void unsafe_arena_set_allocated_child( - ::io::substrait::Expression_MaskExpression_Select* child); - ::io::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); + ::substrait::Expression_MaskExpression_Select* child); + ::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); - // .io.substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; + // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; bool has_key() const; private: bool _internal_has_key() const; public: void clear_key(); - const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& key() const; - ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* release_key(); - ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* mutable_key(); - void set_allocated_key(::io::substrait::Expression_MaskExpression_MapSelect_MapKey* key); + const ::substrait::Expression_MaskExpression_MapSelect_MapKey& key() const; + ::substrait::Expression_MaskExpression_MapSelect_MapKey* release_key(); + ::substrait::Expression_MaskExpression_MapSelect_MapKey* mutable_key(); + void set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key); private: - const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& _internal_key() const; - ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* _internal_mutable_key(); + const ::substrait::Expression_MaskExpression_MapSelect_MapKey& _internal_key() const; + ::substrait::Expression_MaskExpression_MapSelect_MapKey* _internal_mutable_key(); public: void unsafe_arena_set_allocated_key( - ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* key); - ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* unsafe_arena_release_key(); + ::substrait::Expression_MaskExpression_MapSelect_MapKey* key); + ::substrait::Expression_MaskExpression_MapSelect_MapKey* unsafe_arena_release_key(); - // .io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; + // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; bool has_expression() const; private: bool _internal_has_expression() const; public: void clear_expression(); - const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression() const; - ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* release_expression(); - ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* mutable_expression(); - void set_allocated_expression(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression); + const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression() const; + ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* release_expression(); + ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* mutable_expression(); + void set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression); private: - const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& _internal_expression() const; - ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* _internal_mutable_expression(); + const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& _internal_expression() const; + ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* _internal_mutable_expression(); public: void unsafe_arena_set_allocated_expression( - ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression); - ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* unsafe_arena_release_expression(); + ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression); + ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* unsafe_arena_release_expression(); void clear_select(); SelectCase select_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression.MapSelect) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.MapSelect) private: class _Internal; void set_has_key(); @@ -7685,22 +7666,22 @@ class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression_MaskExpression_Select* child_; + ::substrait::Expression_MaskExpression_Select* child_; union SelectUnion { constexpr SelectUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* key_; - ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression_; + ::substrait::Expression_MaskExpression_MapSelect_MapKey* key_; + ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression_; } select_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_MaskExpression PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.MaskExpression) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression) */ { public: inline Expression_MaskExpression() : Expression_MaskExpression(nullptr) {} ~Expression_MaskExpression() override; @@ -7790,7 +7771,7 @@ class Expression_MaskExpression PROTOBUF_FINAL : void InternalSwap(Expression_MaskExpression* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.MaskExpression"; + return "substrait.Expression.MaskExpression"; } protected: explicit Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -7815,23 +7796,23 @@ class Expression_MaskExpression PROTOBUF_FINAL : kSelectFieldNumber = 1, kMaintainSingularStructFieldNumber = 2, }; - // .io.substrait.Expression.MaskExpression.StructSelect select = 1; + // .substrait.Expression.MaskExpression.StructSelect select = 1; bool has_select() const; private: bool _internal_has_select() const; public: void clear_select(); - const ::io::substrait::Expression_MaskExpression_StructSelect& select() const; - ::io::substrait::Expression_MaskExpression_StructSelect* release_select(); - ::io::substrait::Expression_MaskExpression_StructSelect* mutable_select(); - void set_allocated_select(::io::substrait::Expression_MaskExpression_StructSelect* select); + const ::substrait::Expression_MaskExpression_StructSelect& select() const; + ::substrait::Expression_MaskExpression_StructSelect* release_select(); + ::substrait::Expression_MaskExpression_StructSelect* mutable_select(); + void set_allocated_select(::substrait::Expression_MaskExpression_StructSelect* select); private: - const ::io::substrait::Expression_MaskExpression_StructSelect& _internal_select() const; - ::io::substrait::Expression_MaskExpression_StructSelect* _internal_mutable_select(); + const ::substrait::Expression_MaskExpression_StructSelect& _internal_select() const; + ::substrait::Expression_MaskExpression_StructSelect* _internal_mutable_select(); public: void unsafe_arena_set_allocated_select( - ::io::substrait::Expression_MaskExpression_StructSelect* select); - ::io::substrait::Expression_MaskExpression_StructSelect* unsafe_arena_release_select(); + ::substrait::Expression_MaskExpression_StructSelect* select); + ::substrait::Expression_MaskExpression_StructSelect* unsafe_arena_release_select(); // bool maintain_singular_struct = 2; void clear_maintain_singular_struct(); @@ -7842,22 +7823,22 @@ class Expression_MaskExpression PROTOBUF_FINAL : void _internal_set_maintain_singular_struct(bool value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Expression.MaskExpression) + // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression_MaskExpression_StructSelect* select_; + ::substrait::Expression_MaskExpression_StructSelect* select_; bool maintain_singular_struct_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_FieldReference_RootReference PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.FieldReference.RootReference) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.FieldReference.RootReference) */ { public: inline Expression_FieldReference_RootReference() : Expression_FieldReference_RootReference(nullptr) {} ~Expression_FieldReference_RootReference() override; @@ -7947,7 +7928,7 @@ class Expression_FieldReference_RootReference PROTOBUF_FINAL : void InternalSwap(Expression_FieldReference_RootReference* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.FieldReference.RootReference"; + return "substrait.Expression.FieldReference.RootReference"; } protected: explicit Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -7962,7 +7943,7 @@ class Expression_FieldReference_RootReference PROTOBUF_FINAL : // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:io.substrait.Expression.FieldReference.RootReference) + // @@protoc_insertion_point(class_scope:substrait.Expression.FieldReference.RootReference) private: class _Internal; @@ -7970,12 +7951,12 @@ class Expression_FieldReference_RootReference PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression_FieldReference PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression.FieldReference) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.FieldReference) */ { public: inline Expression_FieldReference() : Expression_FieldReference(nullptr) {} ~Expression_FieldReference() override; @@ -8077,7 +8058,7 @@ class Expression_FieldReference PROTOBUF_FINAL : void InternalSwap(Expression_FieldReference* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression.FieldReference"; + return "substrait.Expression.FieldReference"; } protected: explicit Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -8100,83 +8081,83 @@ class Expression_FieldReference PROTOBUF_FINAL : kExpressionFieldNumber = 3, kRootReferenceFieldNumber = 4, }; - // .io.substrait.Expression.ReferenceSegment direct_reference = 1; + // .substrait.Expression.ReferenceSegment direct_reference = 1; bool has_direct_reference() const; private: bool _internal_has_direct_reference() const; public: void clear_direct_reference(); - const ::io::substrait::Expression_ReferenceSegment& direct_reference() const; - ::io::substrait::Expression_ReferenceSegment* release_direct_reference(); - ::io::substrait::Expression_ReferenceSegment* mutable_direct_reference(); - void set_allocated_direct_reference(::io::substrait::Expression_ReferenceSegment* direct_reference); + const ::substrait::Expression_ReferenceSegment& direct_reference() const; + ::substrait::Expression_ReferenceSegment* release_direct_reference(); + ::substrait::Expression_ReferenceSegment* mutable_direct_reference(); + void set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference); private: - const ::io::substrait::Expression_ReferenceSegment& _internal_direct_reference() const; - ::io::substrait::Expression_ReferenceSegment* _internal_mutable_direct_reference(); + const ::substrait::Expression_ReferenceSegment& _internal_direct_reference() const; + ::substrait::Expression_ReferenceSegment* _internal_mutable_direct_reference(); public: void unsafe_arena_set_allocated_direct_reference( - ::io::substrait::Expression_ReferenceSegment* direct_reference); - ::io::substrait::Expression_ReferenceSegment* unsafe_arena_release_direct_reference(); + ::substrait::Expression_ReferenceSegment* direct_reference); + ::substrait::Expression_ReferenceSegment* unsafe_arena_release_direct_reference(); - // .io.substrait.Expression.MaskExpression masked_reference = 2; + // .substrait.Expression.MaskExpression masked_reference = 2; bool has_masked_reference() const; private: bool _internal_has_masked_reference() const; public: void clear_masked_reference(); - const ::io::substrait::Expression_MaskExpression& masked_reference() const; - ::io::substrait::Expression_MaskExpression* release_masked_reference(); - ::io::substrait::Expression_MaskExpression* mutable_masked_reference(); - void set_allocated_masked_reference(::io::substrait::Expression_MaskExpression* masked_reference); + const ::substrait::Expression_MaskExpression& masked_reference() const; + ::substrait::Expression_MaskExpression* release_masked_reference(); + ::substrait::Expression_MaskExpression* mutable_masked_reference(); + void set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference); private: - const ::io::substrait::Expression_MaskExpression& _internal_masked_reference() const; - ::io::substrait::Expression_MaskExpression* _internal_mutable_masked_reference(); + const ::substrait::Expression_MaskExpression& _internal_masked_reference() const; + ::substrait::Expression_MaskExpression* _internal_mutable_masked_reference(); public: void unsafe_arena_set_allocated_masked_reference( - ::io::substrait::Expression_MaskExpression* masked_reference); - ::io::substrait::Expression_MaskExpression* unsafe_arena_release_masked_reference(); + ::substrait::Expression_MaskExpression* masked_reference); + ::substrait::Expression_MaskExpression* unsafe_arena_release_masked_reference(); - // .io.substrait.Expression expression = 3; + // .substrait.Expression expression = 3; bool has_expression() const; private: bool _internal_has_expression() const; public: void clear_expression(); - const ::io::substrait::Expression& expression() const; - ::io::substrait::Expression* release_expression(); - ::io::substrait::Expression* mutable_expression(); - void set_allocated_expression(::io::substrait::Expression* expression); + const ::substrait::Expression& expression() const; + ::substrait::Expression* release_expression(); + ::substrait::Expression* mutable_expression(); + void set_allocated_expression(::substrait::Expression* expression); private: - const ::io::substrait::Expression& _internal_expression() const; - ::io::substrait::Expression* _internal_mutable_expression(); + const ::substrait::Expression& _internal_expression() const; + ::substrait::Expression* _internal_mutable_expression(); public: void unsafe_arena_set_allocated_expression( - ::io::substrait::Expression* expression); - ::io::substrait::Expression* unsafe_arena_release_expression(); + ::substrait::Expression* expression); + ::substrait::Expression* unsafe_arena_release_expression(); - // .io.substrait.Expression.FieldReference.RootReference root_reference = 4; + // .substrait.Expression.FieldReference.RootReference root_reference = 4; bool has_root_reference() const; private: bool _internal_has_root_reference() const; public: void clear_root_reference(); - const ::io::substrait::Expression_FieldReference_RootReference& root_reference() const; - ::io::substrait::Expression_FieldReference_RootReference* release_root_reference(); - ::io::substrait::Expression_FieldReference_RootReference* mutable_root_reference(); - void set_allocated_root_reference(::io::substrait::Expression_FieldReference_RootReference* root_reference); + const ::substrait::Expression_FieldReference_RootReference& root_reference() const; + ::substrait::Expression_FieldReference_RootReference* release_root_reference(); + ::substrait::Expression_FieldReference_RootReference* mutable_root_reference(); + void set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference); private: - const ::io::substrait::Expression_FieldReference_RootReference& _internal_root_reference() const; - ::io::substrait::Expression_FieldReference_RootReference* _internal_mutable_root_reference(); + const ::substrait::Expression_FieldReference_RootReference& _internal_root_reference() const; + ::substrait::Expression_FieldReference_RootReference* _internal_mutable_root_reference(); public: void unsafe_arena_set_allocated_root_reference( - ::io::substrait::Expression_FieldReference_RootReference* root_reference); - ::io::substrait::Expression_FieldReference_RootReference* unsafe_arena_release_root_reference(); + ::substrait::Expression_FieldReference_RootReference* root_reference); + ::substrait::Expression_FieldReference_RootReference* unsafe_arena_release_root_reference(); void clear_reference_type(); ReferenceTypeCase reference_type_case() const; void clear_root_type(); RootTypeCase root_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression.FieldReference) + // @@protoc_insertion_point(class_scope:substrait.Expression.FieldReference) private: class _Internal; void set_has_direct_reference(); @@ -8196,24 +8177,24 @@ class Expression_FieldReference PROTOBUF_FINAL : union ReferenceTypeUnion { constexpr ReferenceTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Expression_ReferenceSegment* direct_reference_; - ::io::substrait::Expression_MaskExpression* masked_reference_; + ::substrait::Expression_ReferenceSegment* direct_reference_; + ::substrait::Expression_MaskExpression* masked_reference_; } reference_type_; union RootTypeUnion { constexpr RootTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Expression* expression_; - ::io::substrait::Expression_FieldReference_RootReference* root_reference_; + ::substrait::Expression* expression_; + ::substrait::Expression_FieldReference_RootReference* root_reference_; } root_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class Expression PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Expression) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression) */ { public: inline Expression() : Expression(nullptr) {} ~Expression() override; @@ -8317,7 +8298,7 @@ class Expression PROTOBUF_FINAL : void InternalSwap(Expression* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Expression"; + return "substrait.Expression"; } protected: explicit Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -8358,189 +8339,189 @@ class Expression PROTOBUF_FINAL : kEnumFieldNumber = 10, kCastFieldNumber = 11, }; - // .io.substrait.Expression.Literal literal = 1; + // .substrait.Expression.Literal literal = 1; bool has_literal() const; private: bool _internal_has_literal() const; public: void clear_literal(); - const ::io::substrait::Expression_Literal& literal() const; - ::io::substrait::Expression_Literal* release_literal(); - ::io::substrait::Expression_Literal* mutable_literal(); - void set_allocated_literal(::io::substrait::Expression_Literal* literal); + const ::substrait::Expression_Literal& literal() const; + ::substrait::Expression_Literal* release_literal(); + ::substrait::Expression_Literal* mutable_literal(); + void set_allocated_literal(::substrait::Expression_Literal* literal); private: - const ::io::substrait::Expression_Literal& _internal_literal() const; - ::io::substrait::Expression_Literal* _internal_mutable_literal(); + const ::substrait::Expression_Literal& _internal_literal() const; + ::substrait::Expression_Literal* _internal_mutable_literal(); public: void unsafe_arena_set_allocated_literal( - ::io::substrait::Expression_Literal* literal); - ::io::substrait::Expression_Literal* unsafe_arena_release_literal(); + ::substrait::Expression_Literal* literal); + ::substrait::Expression_Literal* unsafe_arena_release_literal(); - // .io.substrait.Expression.FieldReference selection = 2; + // .substrait.Expression.FieldReference selection = 2; bool has_selection() const; private: bool _internal_has_selection() const; public: void clear_selection(); - const ::io::substrait::Expression_FieldReference& selection() const; - ::io::substrait::Expression_FieldReference* release_selection(); - ::io::substrait::Expression_FieldReference* mutable_selection(); - void set_allocated_selection(::io::substrait::Expression_FieldReference* selection); + const ::substrait::Expression_FieldReference& selection() const; + ::substrait::Expression_FieldReference* release_selection(); + ::substrait::Expression_FieldReference* mutable_selection(); + void set_allocated_selection(::substrait::Expression_FieldReference* selection); private: - const ::io::substrait::Expression_FieldReference& _internal_selection() const; - ::io::substrait::Expression_FieldReference* _internal_mutable_selection(); + const ::substrait::Expression_FieldReference& _internal_selection() const; + ::substrait::Expression_FieldReference* _internal_mutable_selection(); public: void unsafe_arena_set_allocated_selection( - ::io::substrait::Expression_FieldReference* selection); - ::io::substrait::Expression_FieldReference* unsafe_arena_release_selection(); + ::substrait::Expression_FieldReference* selection); + ::substrait::Expression_FieldReference* unsafe_arena_release_selection(); - // .io.substrait.Expression.ScalarFunction scalar_function = 3; + // .substrait.Expression.ScalarFunction scalar_function = 3; bool has_scalar_function() const; private: bool _internal_has_scalar_function() const; public: void clear_scalar_function(); - const ::io::substrait::Expression_ScalarFunction& scalar_function() const; - ::io::substrait::Expression_ScalarFunction* release_scalar_function(); - ::io::substrait::Expression_ScalarFunction* mutable_scalar_function(); - void set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function); + const ::substrait::Expression_ScalarFunction& scalar_function() const; + ::substrait::Expression_ScalarFunction* release_scalar_function(); + ::substrait::Expression_ScalarFunction* mutable_scalar_function(); + void set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function); private: - const ::io::substrait::Expression_ScalarFunction& _internal_scalar_function() const; - ::io::substrait::Expression_ScalarFunction* _internal_mutable_scalar_function(); + const ::substrait::Expression_ScalarFunction& _internal_scalar_function() const; + ::substrait::Expression_ScalarFunction* _internal_mutable_scalar_function(); public: void unsafe_arena_set_allocated_scalar_function( - ::io::substrait::Expression_ScalarFunction* scalar_function); - ::io::substrait::Expression_ScalarFunction* unsafe_arena_release_scalar_function(); + ::substrait::Expression_ScalarFunction* scalar_function); + ::substrait::Expression_ScalarFunction* unsafe_arena_release_scalar_function(); - // .io.substrait.Expression.WindowFunction window_function = 5; + // .substrait.Expression.WindowFunction window_function = 5; bool has_window_function() const; private: bool _internal_has_window_function() const; public: void clear_window_function(); - const ::io::substrait::Expression_WindowFunction& window_function() const; - ::io::substrait::Expression_WindowFunction* release_window_function(); - ::io::substrait::Expression_WindowFunction* mutable_window_function(); - void set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function); + const ::substrait::Expression_WindowFunction& window_function() const; + ::substrait::Expression_WindowFunction* release_window_function(); + ::substrait::Expression_WindowFunction* mutable_window_function(); + void set_allocated_window_function(::substrait::Expression_WindowFunction* window_function); private: - const ::io::substrait::Expression_WindowFunction& _internal_window_function() const; - ::io::substrait::Expression_WindowFunction* _internal_mutable_window_function(); + const ::substrait::Expression_WindowFunction& _internal_window_function() const; + ::substrait::Expression_WindowFunction* _internal_mutable_window_function(); public: void unsafe_arena_set_allocated_window_function( - ::io::substrait::Expression_WindowFunction* window_function); - ::io::substrait::Expression_WindowFunction* unsafe_arena_release_window_function(); + ::substrait::Expression_WindowFunction* window_function); + ::substrait::Expression_WindowFunction* unsafe_arena_release_window_function(); - // .io.substrait.Expression.IfThen if_then = 6; + // .substrait.Expression.IfThen if_then = 6; bool has_if_then() const; private: bool _internal_has_if_then() const; public: void clear_if_then(); - const ::io::substrait::Expression_IfThen& if_then() const; - ::io::substrait::Expression_IfThen* release_if_then(); - ::io::substrait::Expression_IfThen* mutable_if_then(); - void set_allocated_if_then(::io::substrait::Expression_IfThen* if_then); + const ::substrait::Expression_IfThen& if_then() const; + ::substrait::Expression_IfThen* release_if_then(); + ::substrait::Expression_IfThen* mutable_if_then(); + void set_allocated_if_then(::substrait::Expression_IfThen* if_then); private: - const ::io::substrait::Expression_IfThen& _internal_if_then() const; - ::io::substrait::Expression_IfThen* _internal_mutable_if_then(); + const ::substrait::Expression_IfThen& _internal_if_then() const; + ::substrait::Expression_IfThen* _internal_mutable_if_then(); public: void unsafe_arena_set_allocated_if_then( - ::io::substrait::Expression_IfThen* if_then); - ::io::substrait::Expression_IfThen* unsafe_arena_release_if_then(); + ::substrait::Expression_IfThen* if_then); + ::substrait::Expression_IfThen* unsafe_arena_release_if_then(); - // .io.substrait.Expression.SwitchExpression switch_expression = 7; + // .substrait.Expression.SwitchExpression switch_expression = 7; bool has_switch_expression() const; private: bool _internal_has_switch_expression() const; public: void clear_switch_expression(); - const ::io::substrait::Expression_SwitchExpression& switch_expression() const; - ::io::substrait::Expression_SwitchExpression* release_switch_expression(); - ::io::substrait::Expression_SwitchExpression* mutable_switch_expression(); - void set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression); + const ::substrait::Expression_SwitchExpression& switch_expression() const; + ::substrait::Expression_SwitchExpression* release_switch_expression(); + ::substrait::Expression_SwitchExpression* mutable_switch_expression(); + void set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression); private: - const ::io::substrait::Expression_SwitchExpression& _internal_switch_expression() const; - ::io::substrait::Expression_SwitchExpression* _internal_mutable_switch_expression(); + const ::substrait::Expression_SwitchExpression& _internal_switch_expression() const; + ::substrait::Expression_SwitchExpression* _internal_mutable_switch_expression(); public: void unsafe_arena_set_allocated_switch_expression( - ::io::substrait::Expression_SwitchExpression* switch_expression); - ::io::substrait::Expression_SwitchExpression* unsafe_arena_release_switch_expression(); + ::substrait::Expression_SwitchExpression* switch_expression); + ::substrait::Expression_SwitchExpression* unsafe_arena_release_switch_expression(); - // .io.substrait.Expression.SingularOrList singular_or_list = 8; + // .substrait.Expression.SingularOrList singular_or_list = 8; bool has_singular_or_list() const; private: bool _internal_has_singular_or_list() const; public: void clear_singular_or_list(); - const ::io::substrait::Expression_SingularOrList& singular_or_list() const; - ::io::substrait::Expression_SingularOrList* release_singular_or_list(); - ::io::substrait::Expression_SingularOrList* mutable_singular_or_list(); - void set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list); + const ::substrait::Expression_SingularOrList& singular_or_list() const; + ::substrait::Expression_SingularOrList* release_singular_or_list(); + ::substrait::Expression_SingularOrList* mutable_singular_or_list(); + void set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list); private: - const ::io::substrait::Expression_SingularOrList& _internal_singular_or_list() const; - ::io::substrait::Expression_SingularOrList* _internal_mutable_singular_or_list(); + const ::substrait::Expression_SingularOrList& _internal_singular_or_list() const; + ::substrait::Expression_SingularOrList* _internal_mutable_singular_or_list(); public: void unsafe_arena_set_allocated_singular_or_list( - ::io::substrait::Expression_SingularOrList* singular_or_list); - ::io::substrait::Expression_SingularOrList* unsafe_arena_release_singular_or_list(); + ::substrait::Expression_SingularOrList* singular_or_list); + ::substrait::Expression_SingularOrList* unsafe_arena_release_singular_or_list(); - // .io.substrait.Expression.MultiOrList multi_or_list = 9; + // .substrait.Expression.MultiOrList multi_or_list = 9; bool has_multi_or_list() const; private: bool _internal_has_multi_or_list() const; public: void clear_multi_or_list(); - const ::io::substrait::Expression_MultiOrList& multi_or_list() const; - ::io::substrait::Expression_MultiOrList* release_multi_or_list(); - ::io::substrait::Expression_MultiOrList* mutable_multi_or_list(); - void set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list); + const ::substrait::Expression_MultiOrList& multi_or_list() const; + ::substrait::Expression_MultiOrList* release_multi_or_list(); + ::substrait::Expression_MultiOrList* mutable_multi_or_list(); + void set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list); private: - const ::io::substrait::Expression_MultiOrList& _internal_multi_or_list() const; - ::io::substrait::Expression_MultiOrList* _internal_mutable_multi_or_list(); + const ::substrait::Expression_MultiOrList& _internal_multi_or_list() const; + ::substrait::Expression_MultiOrList* _internal_mutable_multi_or_list(); public: void unsafe_arena_set_allocated_multi_or_list( - ::io::substrait::Expression_MultiOrList* multi_or_list); - ::io::substrait::Expression_MultiOrList* unsafe_arena_release_multi_or_list(); + ::substrait::Expression_MultiOrList* multi_or_list); + ::substrait::Expression_MultiOrList* unsafe_arena_release_multi_or_list(); - // .io.substrait.Expression.Enum enum = 10; + // .substrait.Expression.Enum enum = 10; bool has_enum_() const; private: bool _internal_has_enum_() const; public: void clear_enum_(); - const ::io::substrait::Expression_Enum& enum_() const; - ::io::substrait::Expression_Enum* release_enum_(); - ::io::substrait::Expression_Enum* mutable_enum_(); - void set_allocated_enum_(::io::substrait::Expression_Enum* enum_); + const ::substrait::Expression_Enum& enum_() const; + ::substrait::Expression_Enum* release_enum_(); + ::substrait::Expression_Enum* mutable_enum_(); + void set_allocated_enum_(::substrait::Expression_Enum* enum_); private: - const ::io::substrait::Expression_Enum& _internal_enum_() const; - ::io::substrait::Expression_Enum* _internal_mutable_enum_(); + const ::substrait::Expression_Enum& _internal_enum_() const; + ::substrait::Expression_Enum* _internal_mutable_enum_(); public: void unsafe_arena_set_allocated_enum_( - ::io::substrait::Expression_Enum* enum_); - ::io::substrait::Expression_Enum* unsafe_arena_release_enum_(); + ::substrait::Expression_Enum* enum_); + ::substrait::Expression_Enum* unsafe_arena_release_enum_(); - // .io.substrait.Expression.Cast cast = 11; + // .substrait.Expression.Cast cast = 11; bool has_cast() const; private: bool _internal_has_cast() const; public: void clear_cast(); - const ::io::substrait::Expression_Cast& cast() const; - ::io::substrait::Expression_Cast* release_cast(); - ::io::substrait::Expression_Cast* mutable_cast(); - void set_allocated_cast(::io::substrait::Expression_Cast* cast); + const ::substrait::Expression_Cast& cast() const; + ::substrait::Expression_Cast* release_cast(); + ::substrait::Expression_Cast* mutable_cast(); + void set_allocated_cast(::substrait::Expression_Cast* cast); private: - const ::io::substrait::Expression_Cast& _internal_cast() const; - ::io::substrait::Expression_Cast* _internal_mutable_cast(); + const ::substrait::Expression_Cast& _internal_cast() const; + ::substrait::Expression_Cast* _internal_mutable_cast(); public: void unsafe_arena_set_allocated_cast( - ::io::substrait::Expression_Cast* cast); - ::io::substrait::Expression_Cast* unsafe_arena_release_cast(); + ::substrait::Expression_Cast* cast); + ::substrait::Expression_Cast* unsafe_arena_release_cast(); void clear_rex_type(); RexTypeCase rex_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Expression) + // @@protoc_insertion_point(class_scope:substrait.Expression) private: class _Internal; void set_has_literal(); @@ -8563,26 +8544,26 @@ class Expression PROTOBUF_FINAL : union RexTypeUnion { constexpr RexTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Expression_Literal* literal_; - ::io::substrait::Expression_FieldReference* selection_; - ::io::substrait::Expression_ScalarFunction* scalar_function_; - ::io::substrait::Expression_WindowFunction* window_function_; - ::io::substrait::Expression_IfThen* if_then_; - ::io::substrait::Expression_SwitchExpression* switch_expression_; - ::io::substrait::Expression_SingularOrList* singular_or_list_; - ::io::substrait::Expression_MultiOrList* multi_or_list_; - ::io::substrait::Expression_Enum* enum__; - ::io::substrait::Expression_Cast* cast_; + ::substrait::Expression_Literal* literal_; + ::substrait::Expression_FieldReference* selection_; + ::substrait::Expression_ScalarFunction* scalar_function_; + ::substrait::Expression_WindowFunction* window_function_; + ::substrait::Expression_IfThen* if_then_; + ::substrait::Expression_SwitchExpression* switch_expression_; + ::substrait::Expression_SingularOrList* singular_or_list_; + ::substrait::Expression_MultiOrList* multi_or_list_; + ::substrait::Expression_Enum* enum__; + ::substrait::Expression_Cast* cast_; } rex_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class SortField PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.SortField) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SortField) */ { public: inline SortField() : SortField(nullptr) {} ~SortField() override; @@ -8678,7 +8659,7 @@ class SortField PROTOBUF_FINAL : void InternalSwap(SortField* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.SortField"; + return "substrait.SortField"; } protected: explicit SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -8692,18 +8673,18 @@ class SortField PROTOBUF_FINAL : // nested types ---------------------------------------------------- typedef SortField_SortDirection SortDirection; - static constexpr SortDirection UNKNOWN = - SortField_SortDirection_UNKNOWN; - static constexpr SortDirection ASC_NULLS_FIRST = - SortField_SortDirection_ASC_NULLS_FIRST; - static constexpr SortDirection ASC_NULLS_LAST = - SortField_SortDirection_ASC_NULLS_LAST; - static constexpr SortDirection DESC_NULLS_FIRST = - SortField_SortDirection_DESC_NULLS_FIRST; - static constexpr SortDirection DESC_NULLS_LAST = - SortField_SortDirection_DESC_NULLS_LAST; - static constexpr SortDirection CLUSTERED = - SortField_SortDirection_CLUSTERED; + static constexpr SortDirection SORT_DIRECTION_UNSPECIFIED = + SortField_SortDirection_SORT_DIRECTION_UNSPECIFIED; + static constexpr SortDirection SORT_DIRECTION_ASC_NULLS_FIRST = + SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_FIRST; + static constexpr SortDirection SORT_DIRECTION_ASC_NULLS_LAST = + SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_LAST; + static constexpr SortDirection SORT_DIRECTION_DESC_NULLS_FIRST = + SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_FIRST; + static constexpr SortDirection SORT_DIRECTION_DESC_NULLS_LAST = + SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_LAST; + static constexpr SortDirection SORT_DIRECTION_CLUSTERED = + SortField_SortDirection_SORT_DIRECTION_CLUSTERED; static inline bool SortDirection_IsValid(int value) { return SortField_SortDirection_IsValid(value); } @@ -8736,35 +8717,35 @@ class SortField PROTOBUF_FINAL : kDirectionFieldNumber = 2, kComparisonFunctionReferenceFieldNumber = 3, }; - // .io.substrait.Expression expr = 1; + // .substrait.Expression expr = 1; bool has_expr() const; private: bool _internal_has_expr() const; public: void clear_expr(); - const ::io::substrait::Expression& expr() const; - ::io::substrait::Expression* release_expr(); - ::io::substrait::Expression* mutable_expr(); - void set_allocated_expr(::io::substrait::Expression* expr); + const ::substrait::Expression& expr() const; + ::substrait::Expression* release_expr(); + ::substrait::Expression* mutable_expr(); + void set_allocated_expr(::substrait::Expression* expr); private: - const ::io::substrait::Expression& _internal_expr() const; - ::io::substrait::Expression* _internal_mutable_expr(); + const ::substrait::Expression& _internal_expr() const; + ::substrait::Expression* _internal_mutable_expr(); public: void unsafe_arena_set_allocated_expr( - ::io::substrait::Expression* expr); - ::io::substrait::Expression* unsafe_arena_release_expr(); + ::substrait::Expression* expr); + ::substrait::Expression* unsafe_arena_release_expr(); - // .io.substrait.SortField.SortDirection direction = 2; + // .substrait.SortField.SortDirection direction = 2; bool has_direction() const; private: bool _internal_has_direction() const; public: void clear_direction(); - ::io::substrait::SortField_SortDirection direction() const; - void set_direction(::io::substrait::SortField_SortDirection value); + ::substrait::SortField_SortDirection direction() const; + void set_direction(::substrait::SortField_SortDirection value); private: - ::io::substrait::SortField_SortDirection _internal_direction() const; - void _internal_set_direction(::io::substrait::SortField_SortDirection value); + ::substrait::SortField_SortDirection _internal_direction() const; + void _internal_set_direction(::substrait::SortField_SortDirection value); public: // uint32 comparison_function_reference = 3; @@ -8782,7 +8763,7 @@ class SortField PROTOBUF_FINAL : void clear_sort_kind(); SortKindCase sort_kind_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.SortField) + // @@protoc_insertion_point(class_scope:substrait.SortField) private: class _Internal; void set_has_direction(); @@ -8794,7 +8775,7 @@ class SortField PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Expression* expr_; + ::substrait::Expression* expr_; union SortKindUnion { constexpr SortKindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; @@ -8804,12 +8785,12 @@ class SortField PROTOBUF_FINAL : mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- class AggregateFunction PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.AggregateFunction) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateFunction) */ { public: inline AggregateFunction() : AggregateFunction(nullptr) {} ~AggregateFunction() override; @@ -8899,7 +8880,7 @@ class AggregateFunction PROTOBUF_FINAL : void InternalSwap(AggregateFunction* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.AggregateFunction"; + return "substrait.AggregateFunction"; } protected: explicit AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -8921,59 +8902,59 @@ class AggregateFunction PROTOBUF_FINAL : kFunctionReferenceFieldNumber = 1, kPhaseFieldNumber = 4, }; - // repeated .io.substrait.Expression args = 2; + // repeated .substrait.Expression args = 2; int args_size() const; private: int _internal_args_size() const; public: void clear_args(); - ::io::substrait::Expression* mutable_args(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + ::substrait::Expression* mutable_args(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* mutable_args(); private: - const ::io::substrait::Expression& _internal_args(int index) const; - ::io::substrait::Expression* _internal_add_args(); + const ::substrait::Expression& _internal_args(int index) const; + ::substrait::Expression* _internal_add_args(); public: - const ::io::substrait::Expression& args(int index) const; - ::io::substrait::Expression* add_args(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + const ::substrait::Expression& args(int index) const; + ::substrait::Expression* add_args(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& args() const; - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; int sorts_size() const; private: int _internal_sorts_size() const; public: void clear_sorts(); - ::io::substrait::SortField* mutable_sorts(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* + ::substrait::SortField* mutable_sorts(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* mutable_sorts(); private: - const ::io::substrait::SortField& _internal_sorts(int index) const; - ::io::substrait::SortField* _internal_add_sorts(); + const ::substrait::SortField& _internal_sorts(int index) const; + ::substrait::SortField* _internal_add_sorts(); public: - const ::io::substrait::SortField& sorts(int index) const; - ::io::substrait::SortField* add_sorts(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& + const ::substrait::SortField& sorts(int index) const; + ::substrait::SortField* add_sorts(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& sorts() const; - // .io.substrait.Type output_type = 5; + // .substrait.Type output_type = 5; bool has_output_type() const; private: bool _internal_has_output_type() const; public: void clear_output_type(); - const ::io::substrait::Type& output_type() const; - ::io::substrait::Type* release_output_type(); - ::io::substrait::Type* mutable_output_type(); - void set_allocated_output_type(::io::substrait::Type* output_type); + const ::substrait::Type& output_type() const; + ::substrait::Type* release_output_type(); + ::substrait::Type* mutable_output_type(); + void set_allocated_output_type(::substrait::Type* output_type); private: - const ::io::substrait::Type& _internal_output_type() const; - ::io::substrait::Type* _internal_mutable_output_type(); + const ::substrait::Type& _internal_output_type() const; + ::substrait::Type* _internal_mutable_output_type(); public: void unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type); - ::io::substrait::Type* unsafe_arena_release_output_type(); + ::substrait::Type* output_type); + ::substrait::Type* unsafe_arena_release_output_type(); // uint32 function_reference = 1; void clear_function_reference(); @@ -8984,29 +8965,29 @@ class AggregateFunction PROTOBUF_FINAL : void _internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.AggregationPhase phase = 4; + // .substrait.AggregationPhase phase = 4; void clear_phase(); - ::io::substrait::AggregationPhase phase() const; - void set_phase(::io::substrait::AggregationPhase value); + ::substrait::AggregationPhase phase() const; + void set_phase(::substrait::AggregationPhase value); private: - ::io::substrait::AggregationPhase _internal_phase() const; - void _internal_set_phase(::io::substrait::AggregationPhase value); + ::substrait::AggregationPhase _internal_phase() const; + void _internal_set_phase(::substrait::AggregationPhase value); public: - // @@protoc_insertion_point(class_scope:io.substrait.AggregateFunction) + // @@protoc_insertion_point(class_scope:substrait.AggregateFunction) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > args_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField > sorts_; - ::io::substrait::Type* output_type_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField > sorts_; + ::substrait::Type* output_type_; ::PROTOBUF_NAMESPACE_ID::uint32 function_reference_; int phase_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_expression_2eproto; + friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // =================================================================== @@ -9040,7 +9021,7 @@ inline void Expression_Enum::clear_specified() { } } inline const std::string& Expression_Enum::specified() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Enum.specified) + // @@protoc_insertion_point(field_get:substrait.Expression.Enum.specified) return _internal_specified(); } template @@ -9051,10 +9032,10 @@ inline void Expression_Enum::set_specified(ArgT0&& arg0, ArgT... args) { enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Enum.specified) + // @@protoc_insertion_point(field_set:substrait.Expression.Enum.specified) } inline std::string* Expression_Enum::mutable_specified() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Enum.specified) + // @@protoc_insertion_point(field_mutable:substrait.Expression.Enum.specified) return _internal_mutable_specified(); } inline const std::string& Expression_Enum::_internal_specified() const { @@ -9081,7 +9062,7 @@ inline std::string* Expression_Enum::_internal_mutable_specified() { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_Enum::release_specified() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Enum.specified) + // @@protoc_insertion_point(field_release:substrait.Expression.Enum.specified) if (_internal_has_specified()) { clear_has_enum_kind(); return enum_kind_.specified_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -9101,10 +9082,10 @@ inline void Expression_Enum::set_allocated_specified(std::string* specified) { arena->Own(specified); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Enum.specified) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Enum.specified) } -// .io.substrait.Expression.Enum.Empty unspecified = 2; +// .substrait.Expression.Enum.Empty unspecified = 2; inline bool Expression_Enum::_internal_has_unspecified() const { return enum_kind_case() == kUnspecified; } @@ -9122,11 +9103,11 @@ inline void Expression_Enum::clear_unspecified() { clear_has_enum_kind(); } } -inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::release_unspecified() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Enum.unspecified) +inline ::substrait::Expression_Enum_Empty* Expression_Enum::release_unspecified() { + // @@protoc_insertion_point(field_release:substrait.Expression.Enum.unspecified) if (_internal_has_unspecified()) { clear_has_enum_kind(); - ::io::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; + ::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -9136,44 +9117,44 @@ inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::release_unspecif return nullptr; } } -inline const ::io::substrait::Expression_Enum_Empty& Expression_Enum::_internal_unspecified() const { +inline const ::substrait::Expression_Enum_Empty& Expression_Enum::_internal_unspecified() const { return _internal_has_unspecified() ? *enum_kind_.unspecified_ - : reinterpret_cast< ::io::substrait::Expression_Enum_Empty&>(::io::substrait::_Expression_Enum_Empty_default_instance_); + : reinterpret_cast< ::substrait::Expression_Enum_Empty&>(::substrait::_Expression_Enum_Empty_default_instance_); } -inline const ::io::substrait::Expression_Enum_Empty& Expression_Enum::unspecified() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Enum.unspecified) +inline const ::substrait::Expression_Enum_Empty& Expression_Enum::unspecified() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Enum.unspecified) return _internal_unspecified(); } -inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::unsafe_arena_release_unspecified() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Enum.unspecified) +inline ::substrait::Expression_Enum_Empty* Expression_Enum::unsafe_arena_release_unspecified() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Enum.unspecified) if (_internal_has_unspecified()) { clear_has_enum_kind(); - ::io::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; + ::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; enum_kind_.unspecified_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_Enum::unsafe_arena_set_allocated_unspecified(::io::substrait::Expression_Enum_Empty* unspecified) { +inline void Expression_Enum::unsafe_arena_set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified) { clear_enum_kind(); if (unspecified) { set_has_unspecified(); enum_kind_.unspecified_ = unspecified; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Enum.unspecified) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Enum.unspecified) } -inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::_internal_mutable_unspecified() { +inline ::substrait::Expression_Enum_Empty* Expression_Enum::_internal_mutable_unspecified() { if (!_internal_has_unspecified()) { clear_enum_kind(); set_has_unspecified(); - enum_kind_.unspecified_ = CreateMaybeMessage< ::io::substrait::Expression_Enum_Empty >(GetArena()); + enum_kind_.unspecified_ = CreateMaybeMessage< ::substrait::Expression_Enum_Empty >(GetArena()); } return enum_kind_.unspecified_; } -inline ::io::substrait::Expression_Enum_Empty* Expression_Enum::mutable_unspecified() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Enum.unspecified) +inline ::substrait::Expression_Enum_Empty* Expression_Enum::mutable_unspecified() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Enum.unspecified) return _internal_mutable_unspecified(); } @@ -9195,7 +9176,7 @@ inline void Expression_Literal_VarChar::clear_value() { value_.ClearToEmpty(); } inline const std::string& Expression_Literal_VarChar::value() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.VarChar.value) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.VarChar.value) return _internal_value(); } template @@ -9203,10 +9184,10 @@ PROTOBUF_ALWAYS_INLINE inline void Expression_Literal_VarChar::set_value(ArgT0&& arg0, ArgT... args) { value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.VarChar.value) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.VarChar.value) } inline std::string* Expression_Literal_VarChar::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.VarChar.value) + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.VarChar.value) return _internal_mutable_value(); } inline const std::string& Expression_Literal_VarChar::_internal_value() const { @@ -9221,7 +9202,7 @@ inline std::string* Expression_Literal_VarChar::_internal_mutable_value() { return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_Literal_VarChar::release_value() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.VarChar.value) + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.VarChar.value) return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void Expression_Literal_VarChar::set_allocated_value(std::string* value) { @@ -9232,7 +9213,7 @@ inline void Expression_Literal_VarChar::set_allocated_value(std::string* value) } value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.VarChar.value) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.VarChar.value) } // uint32 length = 2; @@ -9243,7 +9224,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_Literal_VarChar::_internal_len return length_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_Literal_VarChar::length() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.VarChar.length) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.VarChar.length) return _internal_length(); } inline void Expression_Literal_VarChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -9252,7 +9233,7 @@ inline void Expression_Literal_VarChar::_internal_set_length(::PROTOBUF_NAMESPAC } inline void Expression_Literal_VarChar::set_length(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_length(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.VarChar.length) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.VarChar.length) } // ------------------------------------------------------------------- @@ -9264,7 +9245,7 @@ inline void Expression_Literal_Decimal::clear_value() { value_.ClearToEmpty(); } inline const std::string& Expression_Literal_Decimal::value() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Decimal.value) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.value) return _internal_value(); } template @@ -9272,10 +9253,10 @@ PROTOBUF_ALWAYS_INLINE inline void Expression_Literal_Decimal::set_value(ArgT0&& arg0, ArgT... args) { value_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.Decimal.value) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.value) } inline std::string* Expression_Literal_Decimal::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Decimal.value) + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Decimal.value) return _internal_mutable_value(); } inline const std::string& Expression_Literal_Decimal::_internal_value() const { @@ -9290,7 +9271,7 @@ inline std::string* Expression_Literal_Decimal::_internal_mutable_value() { return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_Literal_Decimal::release_value() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Decimal.value) + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.Decimal.value) return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void Expression_Literal_Decimal::set_allocated_value(std::string* value) { @@ -9301,7 +9282,7 @@ inline void Expression_Literal_Decimal::set_allocated_value(std::string* value) } value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Decimal.value) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.Decimal.value) } // int32 precision = 2; @@ -9312,7 +9293,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::_internal_prec return precision_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::precision() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Decimal.precision) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.precision) return _internal_precision(); } inline void Expression_Literal_Decimal::_internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -9321,7 +9302,7 @@ inline void Expression_Literal_Decimal::_internal_set_precision(::PROTOBUF_NAMES } inline void Expression_Literal_Decimal::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_precision(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.Decimal.precision) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.precision) } // int32 scale = 3; @@ -9332,7 +9313,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::_internal_scal return scale_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::scale() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Decimal.scale) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.scale) return _internal_scale(); } inline void Expression_Literal_Decimal::_internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -9341,14 +9322,14 @@ inline void Expression_Literal_Decimal::_internal_set_scale(::PROTOBUF_NAMESPACE } inline void Expression_Literal_Decimal::set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_scale(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.Decimal.scale) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.scale) } // ------------------------------------------------------------------- // Expression_Literal_Map_KeyValue -// .io.substrait.Expression.Literal key = 1; +// .substrait.Expression.Literal key = 1; inline bool Expression_Literal_Map_KeyValue::_internal_has_key() const { return this != internal_default_instance() && key_ != nullptr; } @@ -9361,17 +9342,17 @@ inline void Expression_Literal_Map_KeyValue::clear_key() { } key_ = nullptr; } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_key() const { - const ::io::substrait::Expression_Literal* p = key_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_Literal_default_instance_); +inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_key() const { + const ::substrait::Expression_Literal* p = key_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_Literal_default_instance_); } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::key() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.KeyValue.key) +inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::key() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Map.KeyValue.key) return _internal_key(); } inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_key( - ::io::substrait::Expression_Literal* key) { + ::substrait::Expression_Literal* key) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); } @@ -9381,37 +9362,37 @@ inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_key( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.key) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.Map.KeyValue.key) } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_key() { +inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_key() { - ::io::substrait::Expression_Literal* temp = key_; + ::substrait::Expression_Literal* temp = key_; key_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.KeyValue.key) +inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.Map.KeyValue.key) - ::io::substrait::Expression_Literal* temp = key_; + ::substrait::Expression_Literal* temp = key_; key_ = nullptr; return temp; } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_key() { +inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_key() { if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArena()); key_ = p; } return key_; } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.KeyValue.key) +inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_key() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.KeyValue.key) return _internal_mutable_key(); } -inline void Expression_Literal_Map_KeyValue::set_allocated_key(::io::substrait::Expression_Literal* key) { +inline void Expression_Literal_Map_KeyValue::set_allocated_key(::substrait::Expression_Literal* key) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete key_; @@ -9428,10 +9409,10 @@ inline void Expression_Literal_Map_KeyValue::set_allocated_key(::io::substrait:: } key_ = key; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.key) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.Map.KeyValue.key) } -// .io.substrait.Expression.Literal value = 2; +// .substrait.Expression.Literal value = 2; inline bool Expression_Literal_Map_KeyValue::_internal_has_value() const { return this != internal_default_instance() && value_ != nullptr; } @@ -9444,17 +9425,17 @@ inline void Expression_Literal_Map_KeyValue::clear_value() { } value_ = nullptr; } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_value() const { - const ::io::substrait::Expression_Literal* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_Literal_default_instance_); +inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_value() const { + const ::substrait::Expression_Literal* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_Literal_default_instance_); } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::value() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.KeyValue.value) +inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::value() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Map.KeyValue.value) return _internal_value(); } inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_value( - ::io::substrait::Expression_Literal* value) { + ::substrait::Expression_Literal* value) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } @@ -9464,37 +9445,37 @@ inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_value( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.value) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.Map.KeyValue.value) } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_value() { +inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_value() { - ::io::substrait::Expression_Literal* temp = value_; + ::substrait::Expression_Literal* temp = value_; value_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.KeyValue.value) +inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.Map.KeyValue.value) - ::io::substrait::Expression_Literal* temp = value_; + ::substrait::Expression_Literal* temp = value_; value_ = nullptr; return temp; } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_value() { +inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_value() { if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArena()); value_ = p; } return value_; } -inline ::io::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.KeyValue.value) +inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_value() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.KeyValue.value) return _internal_mutable_value(); } -inline void Expression_Literal_Map_KeyValue::set_allocated_value(::io::substrait::Expression_Literal* value) { +inline void Expression_Literal_Map_KeyValue::set_allocated_value(::substrait::Expression_Literal* value) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete value_; @@ -9511,14 +9492,14 @@ inline void Expression_Literal_Map_KeyValue::set_allocated_value(::io::substrait } value_ = value; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.KeyValue.value) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.Map.KeyValue.value) } // ------------------------------------------------------------------- // Expression_Literal_Map -// repeated .io.substrait.Expression.Literal.Map.KeyValue key_values = 1; +// repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; inline int Expression_Literal_Map::_internal_key_values_size() const { return key_values_.size(); } @@ -9528,189 +9509,35 @@ inline int Expression_Literal_Map::key_values_size() const { inline void Expression_Literal_Map::clear_key_values() { key_values_.Clear(); } -inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::mutable_key_values(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.key_values) +inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::mutable_key_values(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.key_values) return key_values_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >* Expression_Literal_Map::mutable_key_values() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.Map.key_values) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.Literal.Map.key_values) return &key_values_; } -inline const ::io::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::_internal_key_values(int index) const { +inline const ::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::_internal_key_values(int index) const { return key_values_.Get(index); } -inline const ::io::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::key_values(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.key_values) +inline const ::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::key_values(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Map.key_values) return _internal_key_values(index); } -inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::_internal_add_key_values() { +inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::_internal_add_key_values() { return key_values_.Add(); } -inline ::io::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::add_key_values() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.Map.key_values) +inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::add_key_values() { + // @@protoc_insertion_point(field_add:substrait.Expression.Literal.Map.key_values) return _internal_add_key_values(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Map_KeyValue >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >& Expression_Literal_Map::key_values() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.Map.key_values) + // @@protoc_insertion_point(field_list:substrait.Expression.Literal.Map.key_values) return key_values_; } -// .io.substrait.Type key_type = 2; -inline bool Expression_Literal_Map::_internal_has_key_type() const { - return this != internal_default_instance() && key_type_ != nullptr; -} -inline bool Expression_Literal_Map::has_key_type() const { - return _internal_has_key_type(); -} -inline const ::io::substrait::Type& Expression_Literal_Map::_internal_key_type() const { - const ::io::substrait::Type* p = key_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); -} -inline const ::io::substrait::Type& Expression_Literal_Map::key_type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.key_type) - return _internal_key_type(); -} -inline void Expression_Literal_Map::unsafe_arena_set_allocated_key_type( - ::io::substrait::Type* key_type) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_type_); - } - key_type_ = key_type; - if (key_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.key_type) -} -inline ::io::substrait::Type* Expression_Literal_Map::release_key_type() { - - ::io::substrait::Type* temp = key_type_; - key_type_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type* Expression_Literal_Map::unsafe_arena_release_key_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.key_type) - - ::io::substrait::Type* temp = key_type_; - key_type_ = nullptr; - return temp; -} -inline ::io::substrait::Type* Expression_Literal_Map::_internal_mutable_key_type() { - - if (key_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); - key_type_ = p; - } - return key_type_; -} -inline ::io::substrait::Type* Expression_Literal_Map::mutable_key_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.key_type) - return _internal_mutable_key_type(); -} -inline void Expression_Literal_Map::set_allocated_key_type(::io::substrait::Type* key_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_type_); - } - if (key_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_type)->GetArena(); - if (message_arena != submessage_arena) { - key_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key_type, submessage_arena); - } - - } else { - - } - key_type_ = key_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.key_type) -} - -// .io.substrait.Type value_type = 3; -inline bool Expression_Literal_Map::_internal_has_value_type() const { - return this != internal_default_instance() && value_type_ != nullptr; -} -inline bool Expression_Literal_Map::has_value_type() const { - return _internal_has_value_type(); -} -inline const ::io::substrait::Type& Expression_Literal_Map::_internal_value_type() const { - const ::io::substrait::Type* p = value_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); -} -inline const ::io::substrait::Type& Expression_Literal_Map::value_type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Map.value_type) - return _internal_value_type(); -} -inline void Expression_Literal_Map::unsafe_arena_set_allocated_value_type( - ::io::substrait::Type* value_type) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_type_); - } - value_type_ = value_type; - if (value_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.Map.value_type) -} -inline ::io::substrait::Type* Expression_Literal_Map::release_value_type() { - - ::io::substrait::Type* temp = value_type_; - value_type_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type* Expression_Literal_Map::unsafe_arena_release_value_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.Map.value_type) - - ::io::substrait::Type* temp = value_type_; - value_type_ = nullptr; - return temp; -} -inline ::io::substrait::Type* Expression_Literal_Map::_internal_mutable_value_type() { - - if (value_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); - value_type_ = p; - } - return value_type_; -} -inline ::io::substrait::Type* Expression_Literal_Map::mutable_value_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Map.value_type) - return _internal_mutable_value_type(); -} -inline void Expression_Literal_Map::set_allocated_value_type(::io::substrait::Type* value_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_type_); - } - if (value_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_type)->GetArena(); - if (message_arena != submessage_arena) { - value_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value_type, submessage_arena); - } - - } else { - - } - value_type_ = value_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.Map.value_type) -} - // ------------------------------------------------------------------- // Expression_Literal_IntervalYearToMonth @@ -9723,7 +9550,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::_i return years_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::years() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalYearToMonth.years) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalYearToMonth.years) return _internal_years(); } inline void Expression_Literal_IntervalYearToMonth::_internal_set_years(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -9732,7 +9559,7 @@ inline void Expression_Literal_IntervalYearToMonth::_internal_set_years(::PROTOB } inline void Expression_Literal_IntervalYearToMonth::set_years(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_years(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalYearToMonth.years) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalYearToMonth.years) } // int32 months = 2; @@ -9743,7 +9570,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::_i return months_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::months() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalYearToMonth.months) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalYearToMonth.months) return _internal_months(); } inline void Expression_Literal_IntervalYearToMonth::_internal_set_months(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -9752,7 +9579,7 @@ inline void Expression_Literal_IntervalYearToMonth::_internal_set_months(::PROTO } inline void Expression_Literal_IntervalYearToMonth::set_months(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_months(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalYearToMonth.months) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalYearToMonth.months) } // ------------------------------------------------------------------- @@ -9767,7 +9594,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::_i return days_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::days() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalDayToSecond.days) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalDayToSecond.days) return _internal_days(); } inline void Expression_Literal_IntervalDayToSecond::_internal_set_days(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -9776,7 +9603,7 @@ inline void Expression_Literal_IntervalDayToSecond::_internal_set_days(::PROTOBU } inline void Expression_Literal_IntervalDayToSecond::set_days(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_days(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalDayToSecond.days) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalDayToSecond.days) } // int32 seconds = 2; @@ -9787,7 +9614,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::_i return seconds_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::seconds() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.IntervalDayToSecond.seconds) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalDayToSecond.seconds) return _internal_seconds(); } inline void Expression_Literal_IntervalDayToSecond::_internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -9796,14 +9623,14 @@ inline void Expression_Literal_IntervalDayToSecond::_internal_set_seconds(::PROT } inline void Expression_Literal_IntervalDayToSecond::set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_seconds(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.IntervalDayToSecond.seconds) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalDayToSecond.seconds) } // ------------------------------------------------------------------- // Expression_Literal_Struct -// repeated .io.substrait.Expression.Literal fields = 1; +// repeated .substrait.Expression.Literal fields = 1; inline int Expression_Literal_Struct::_internal_fields_size() const { return fields_.size(); } @@ -9813,32 +9640,32 @@ inline int Expression_Literal_Struct::fields_size() const { inline void Expression_Literal_Struct::clear_fields() { fields_.Clear(); } -inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::mutable_fields(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.Struct.fields) +inline ::substrait::Expression_Literal* Expression_Literal_Struct::mutable_fields(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Struct.fields) return fields_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >* Expression_Literal_Struct::mutable_fields() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.Struct.fields) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.Literal.Struct.fields) return &fields_; } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Struct::_internal_fields(int index) const { +inline const ::substrait::Expression_Literal& Expression_Literal_Struct::_internal_fields(int index) const { return fields_.Get(index); } -inline const ::io::substrait::Expression_Literal& Expression_Literal_Struct::fields(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.Struct.fields) +inline const ::substrait::Expression_Literal& Expression_Literal_Struct::fields(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Struct.fields) return _internal_fields(index); } -inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::_internal_add_fields() { +inline ::substrait::Expression_Literal* Expression_Literal_Struct::_internal_add_fields() { return fields_.Add(); } -inline ::io::substrait::Expression_Literal* Expression_Literal_Struct::add_fields() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.Struct.fields) +inline ::substrait::Expression_Literal* Expression_Literal_Struct::add_fields() { + // @@protoc_insertion_point(field_add:substrait.Expression.Literal.Struct.fields) return _internal_add_fields(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >& Expression_Literal_Struct::fields() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.Struct.fields) + // @@protoc_insertion_point(field_list:substrait.Expression.Literal.Struct.fields) return fields_; } @@ -9846,7 +9673,7 @@ Expression_Literal_Struct::fields() const { // Expression_Literal_List -// repeated .io.substrait.Expression.Literal values = 1; +// repeated .substrait.Expression.Literal values = 1; inline int Expression_Literal_List::_internal_values_size() const { return values_.size(); } @@ -9856,112 +9683,35 @@ inline int Expression_Literal_List::values_size() const { inline void Expression_Literal_List::clear_values() { values_.Clear(); } -inline ::io::substrait::Expression_Literal* Expression_Literal_List::mutable_values(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.List.values) +inline ::substrait::Expression_Literal* Expression_Literal_List::mutable_values(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.List.values) return values_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >* Expression_Literal_List::mutable_values() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.Literal.List.values) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.Literal.List.values) return &values_; } -inline const ::io::substrait::Expression_Literal& Expression_Literal_List::_internal_values(int index) const { +inline const ::substrait::Expression_Literal& Expression_Literal_List::_internal_values(int index) const { return values_.Get(index); } -inline const ::io::substrait::Expression_Literal& Expression_Literal_List::values(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.List.values) +inline const ::substrait::Expression_Literal& Expression_Literal_List::values(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.List.values) return _internal_values(index); } -inline ::io::substrait::Expression_Literal* Expression_Literal_List::_internal_add_values() { +inline ::substrait::Expression_Literal* Expression_Literal_List::_internal_add_values() { return values_.Add(); } -inline ::io::substrait::Expression_Literal* Expression_Literal_List::add_values() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.Literal.List.values) +inline ::substrait::Expression_Literal* Expression_Literal_List::add_values() { + // @@protoc_insertion_point(field_add:substrait.Expression.Literal.List.values) return _internal_add_values(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >& Expression_Literal_List::values() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.Literal.List.values) + // @@protoc_insertion_point(field_list:substrait.Expression.Literal.List.values) return values_; } -// .io.substrait.Type element_type = 2; -inline bool Expression_Literal_List::_internal_has_element_type() const { - return this != internal_default_instance() && element_type_ != nullptr; -} -inline bool Expression_Literal_List::has_element_type() const { - return _internal_has_element_type(); -} -inline const ::io::substrait::Type& Expression_Literal_List::_internal_element_type() const { - const ::io::substrait::Type* p = element_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); -} -inline const ::io::substrait::Type& Expression_Literal_List::element_type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.List.element_type) - return _internal_element_type(); -} -inline void Expression_Literal_List::unsafe_arena_set_allocated_element_type( - ::io::substrait::Type* element_type) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(element_type_); - } - element_type_ = element_type; - if (element_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.List.element_type) -} -inline ::io::substrait::Type* Expression_Literal_List::release_element_type() { - - ::io::substrait::Type* temp = element_type_; - element_type_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline ::io::substrait::Type* Expression_Literal_List::unsafe_arena_release_element_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.List.element_type) - - ::io::substrait::Type* temp = element_type_; - element_type_ = nullptr; - return temp; -} -inline ::io::substrait::Type* Expression_Literal_List::_internal_mutable_element_type() { - - if (element_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); - element_type_ = p; - } - return element_type_; -} -inline ::io::substrait::Type* Expression_Literal_List::mutable_element_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.List.element_type) - return _internal_mutable_element_type(); -} -inline void Expression_Literal_List::set_allocated_element_type(::io::substrait::Type* element_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(element_type_); - } - if (element_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(element_type)->GetArena(); - if (message_arena != submessage_arena) { - element_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, element_type, submessage_arena); - } - - } else { - - } - element_type_ = element_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.List.element_type) -} - // ------------------------------------------------------------------- // Expression_Literal @@ -9996,12 +9746,12 @@ inline void Expression_Literal::_internal_set_boolean(bool value) { literal_type_.boolean_ = value; } inline bool Expression_Literal::boolean() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.boolean) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.boolean) return _internal_boolean(); } inline void Expression_Literal::set_boolean(bool value) { _internal_set_boolean(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.boolean) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.boolean) } // int32 i8 = 2; @@ -10034,12 +9784,12 @@ inline void Expression_Literal::_internal_set_i8(::PROTOBUF_NAMESPACE_ID::int32 literal_type_.i8_ = value; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i8() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i8) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i8) return _internal_i8(); } inline void Expression_Literal::set_i8(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_i8(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i8) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i8) } // int32 i16 = 3; @@ -10072,12 +9822,12 @@ inline void Expression_Literal::_internal_set_i16(::PROTOBUF_NAMESPACE_ID::int32 literal_type_.i16_ = value; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i16() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i16) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i16) return _internal_i16(); } inline void Expression_Literal::set_i16(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_i16(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i16) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i16) } // int32 i32 = 5; @@ -10110,12 +9860,12 @@ inline void Expression_Literal::_internal_set_i32(::PROTOBUF_NAMESPACE_ID::int32 literal_type_.i32_ = value; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i32() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i32) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i32) return _internal_i32(); } inline void Expression_Literal::set_i32(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_i32(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i32) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i32) } // int64 i64 = 7; @@ -10148,12 +9898,12 @@ inline void Expression_Literal::_internal_set_i64(::PROTOBUF_NAMESPACE_ID::int64 literal_type_.i64_ = value; } inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::i64() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.i64) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i64) return _internal_i64(); } inline void Expression_Literal::set_i64(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_i64(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.i64) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i64) } // float fp32 = 10; @@ -10186,12 +9936,12 @@ inline void Expression_Literal::_internal_set_fp32(float value) { literal_type_.fp32_ = value; } inline float Expression_Literal::fp32() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fp32) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fp32) return _internal_fp32(); } inline void Expression_Literal::set_fp32(float value) { _internal_set_fp32(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fp32) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fp32) } // double fp64 = 11; @@ -10224,12 +9974,12 @@ inline void Expression_Literal::_internal_set_fp64(double value) { literal_type_.fp64_ = value; } inline double Expression_Literal::fp64() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fp64) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fp64) return _internal_fp64(); } inline void Expression_Literal::set_fp64(double value) { _internal_set_fp64(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fp64) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fp64) } // string string = 12; @@ -10249,7 +9999,7 @@ inline void Expression_Literal::clear_string() { } } inline const std::string& Expression_Literal::string() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.string) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.string) return _internal_string(); } template @@ -10260,10 +10010,10 @@ inline void Expression_Literal::set_string(ArgT0&& arg0, ArgT... args) { literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.string) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.string) } inline std::string* Expression_Literal::mutable_string() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.string) + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.string) return _internal_mutable_string(); } inline const std::string& Expression_Literal::_internal_string() const { @@ -10290,7 +10040,7 @@ inline std::string* Expression_Literal::_internal_mutable_string() { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_Literal::release_string() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.string) + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.string) if (_internal_has_string()) { clear_has_literal_type(); return literal_type_.string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -10310,7 +10060,7 @@ inline void Expression_Literal::set_allocated_string(std::string* string) { arena->Own(string); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.string) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.string) } // bytes binary = 13; @@ -10330,7 +10080,7 @@ inline void Expression_Literal::clear_binary() { } } inline const std::string& Expression_Literal::binary() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.binary) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.binary) return _internal_binary(); } template @@ -10341,10 +10091,10 @@ inline void Expression_Literal::set_binary(ArgT0&& arg0, ArgT... args) { literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } literal_type_.binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.binary) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.binary) } inline std::string* Expression_Literal::mutable_binary() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.binary) + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.binary) return _internal_mutable_binary(); } inline const std::string& Expression_Literal::_internal_binary() const { @@ -10371,7 +10121,7 @@ inline std::string* Expression_Literal::_internal_mutable_binary() { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_Literal::release_binary() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.binary) + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.binary) if (_internal_has_binary()) { clear_has_literal_type(); return literal_type_.binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -10391,7 +10141,7 @@ inline void Expression_Literal::set_allocated_binary(std::string* binary) { arena->Own(binary); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.binary) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.binary) } // int64 timestamp = 14; @@ -10424,15 +10174,15 @@ inline void Expression_Literal::_internal_set_timestamp(::PROTOBUF_NAMESPACE_ID: literal_type_.timestamp_ = value; } inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::timestamp() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.timestamp) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.timestamp) return _internal_timestamp(); } inline void Expression_Literal::set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.timestamp) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.timestamp) } -// int64 date = 16; +// int32 date = 16; inline bool Expression_Literal::_internal_has_date() const { return literal_type_case() == kDate; } @@ -10444,30 +10194,30 @@ inline void Expression_Literal::set_has_date() { } inline void Expression_Literal::clear_date() { if (_internal_has_date()) { - literal_type_.date_ = PROTOBUF_LONGLONG(0); + literal_type_.date_ = 0; clear_has_literal_type(); } } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_date() const { +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_date() const { if (_internal_has_date()) { return literal_type_.date_; } - return PROTOBUF_LONGLONG(0); + return 0; } -inline void Expression_Literal::_internal_set_date(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_Literal::_internal_set_date(::PROTOBUF_NAMESPACE_ID::int32 value) { if (!_internal_has_date()) { clear_literal_type(); set_has_date(); } literal_type_.date_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::date() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.date) +inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::date() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.date) return _internal_date(); } -inline void Expression_Literal::set_date(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_Literal::set_date(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_date(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.date) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.date) } // int64 time = 17; @@ -10500,15 +10250,15 @@ inline void Expression_Literal::_internal_set_time(::PROTOBUF_NAMESPACE_ID::int6 literal_type_.time_ = value; } inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::time() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.time) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.time) return _internal_time(); } inline void Expression_Literal::set_time(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_time(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.time) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.time) } -// .io.substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; +// .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; inline bool Expression_Literal::_internal_has_interval_year_to_month() const { return literal_type_case() == kIntervalYearToMonth; } @@ -10526,11 +10276,11 @@ inline void Expression_Literal::clear_interval_year_to_month() { clear_has_literal_type(); } } -inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::release_interval_year_to_month() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.interval_year_to_month) +inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::release_interval_year_to_month() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.interval_year_to_month) if (_internal_has_interval_year_to_month()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; + ::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -10540,48 +10290,48 @@ inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Liter return nullptr; } } -inline const ::io::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::_internal_interval_year_to_month() const { +inline const ::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::_internal_interval_year_to_month() const { return _internal_has_interval_year_to_month() ? *literal_type_.interval_year_to_month_ - : reinterpret_cast< ::io::substrait::Expression_Literal_IntervalYearToMonth&>(::io::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_); + : reinterpret_cast< ::substrait::Expression_Literal_IntervalYearToMonth&>(::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_); } -inline const ::io::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::interval_year_to_month() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.interval_year_to_month) +inline const ::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::interval_year_to_month() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.interval_year_to_month) return _internal_interval_year_to_month(); } -inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::unsafe_arena_release_interval_year_to_month() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.interval_year_to_month) +inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::unsafe_arena_release_interval_year_to_month() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.interval_year_to_month) if (_internal_has_interval_year_to_month()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; + ::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; literal_type_.interval_year_to_month_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_Literal::unsafe_arena_set_allocated_interval_year_to_month(::io::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { +inline void Expression_Literal::unsafe_arena_set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { clear_literal_type(); if (interval_year_to_month) { set_has_interval_year_to_month(); literal_type_.interval_year_to_month_ = interval_year_to_month; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.interval_year_to_month) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.interval_year_to_month) } -inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::_internal_mutable_interval_year_to_month() { +inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::_internal_mutable_interval_year_to_month() { if (!_internal_has_interval_year_to_month()) { clear_literal_type(); set_has_interval_year_to_month(); - literal_type_.interval_year_to_month_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalYearToMonth >(GetArena()); + literal_type_.interval_year_to_month_ = CreateMaybeMessage< ::substrait::Expression_Literal_IntervalYearToMonth >(GetArena()); } return literal_type_.interval_year_to_month_; } -inline ::io::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::mutable_interval_year_to_month() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.interval_year_to_month) +inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::mutable_interval_year_to_month() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.interval_year_to_month) return _internal_mutable_interval_year_to_month(); } -// .io.substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; +// .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; inline bool Expression_Literal::_internal_has_interval_day_to_second() const { return literal_type_case() == kIntervalDayToSecond; } @@ -10599,11 +10349,11 @@ inline void Expression_Literal::clear_interval_day_to_second() { clear_has_literal_type(); } } -inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::release_interval_day_to_second() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.interval_day_to_second) +inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::release_interval_day_to_second() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.interval_day_to_second) if (_internal_has_interval_day_to_second()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; + ::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -10613,44 +10363,44 @@ inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Liter return nullptr; } } -inline const ::io::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::_internal_interval_day_to_second() const { +inline const ::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::_internal_interval_day_to_second() const { return _internal_has_interval_day_to_second() ? *literal_type_.interval_day_to_second_ - : reinterpret_cast< ::io::substrait::Expression_Literal_IntervalDayToSecond&>(::io::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_); + : reinterpret_cast< ::substrait::Expression_Literal_IntervalDayToSecond&>(::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_); } -inline const ::io::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::interval_day_to_second() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.interval_day_to_second) +inline const ::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::interval_day_to_second() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.interval_day_to_second) return _internal_interval_day_to_second(); } -inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::unsafe_arena_release_interval_day_to_second() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.interval_day_to_second) +inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::unsafe_arena_release_interval_day_to_second() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.interval_day_to_second) if (_internal_has_interval_day_to_second()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; + ::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; literal_type_.interval_day_to_second_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_Literal::unsafe_arena_set_allocated_interval_day_to_second(::io::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { +inline void Expression_Literal::unsafe_arena_set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { clear_literal_type(); if (interval_day_to_second) { set_has_interval_day_to_second(); literal_type_.interval_day_to_second_ = interval_day_to_second; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.interval_day_to_second) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.interval_day_to_second) } -inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::_internal_mutable_interval_day_to_second() { +inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::_internal_mutable_interval_day_to_second() { if (!_internal_has_interval_day_to_second()) { clear_literal_type(); set_has_interval_day_to_second(); - literal_type_.interval_day_to_second_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_IntervalDayToSecond >(GetArena()); + literal_type_.interval_day_to_second_ = CreateMaybeMessage< ::substrait::Expression_Literal_IntervalDayToSecond >(GetArena()); } return literal_type_.interval_day_to_second_; } -inline ::io::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::mutable_interval_day_to_second() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.interval_day_to_second) +inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::mutable_interval_day_to_second() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.interval_day_to_second) return _internal_mutable_interval_day_to_second(); } @@ -10671,7 +10421,7 @@ inline void Expression_Literal::clear_fixed_char() { } } inline const std::string& Expression_Literal::fixed_char() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fixed_char) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fixed_char) return _internal_fixed_char(); } template @@ -10682,10 +10432,10 @@ inline void Expression_Literal::set_fixed_char(ArgT0&& arg0, ArgT... args) { literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fixed_char) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fixed_char) } inline std::string* Expression_Literal::mutable_fixed_char() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.fixed_char) + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.fixed_char) return _internal_mutable_fixed_char(); } inline const std::string& Expression_Literal::_internal_fixed_char() const { @@ -10712,7 +10462,7 @@ inline std::string* Expression_Literal::_internal_mutable_fixed_char() { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_Literal::release_fixed_char() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.fixed_char) + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.fixed_char) if (_internal_has_fixed_char()) { clear_has_literal_type(); return literal_type_.fixed_char_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -10732,10 +10482,10 @@ inline void Expression_Literal::set_allocated_fixed_char(std::string* fixed_char arena->Own(fixed_char); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.fixed_char) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.fixed_char) } -// .io.substrait.Expression.Literal.VarChar var_char = 22; +// .substrait.Expression.Literal.VarChar var_char = 22; inline bool Expression_Literal::_internal_has_var_char() const { return literal_type_case() == kVarChar; } @@ -10753,11 +10503,11 @@ inline void Expression_Literal::clear_var_char() { clear_has_literal_type(); } } -inline ::io::substrait::Expression_Literal_VarChar* Expression_Literal::release_var_char() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.var_char) +inline ::substrait::Expression_Literal_VarChar* Expression_Literal::release_var_char() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.var_char) if (_internal_has_var_char()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_; + ::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -10767,44 +10517,44 @@ inline ::io::substrait::Expression_Literal_VarChar* Expression_Literal::release_ return nullptr; } } -inline const ::io::substrait::Expression_Literal_VarChar& Expression_Literal::_internal_var_char() const { +inline const ::substrait::Expression_Literal_VarChar& Expression_Literal::_internal_var_char() const { return _internal_has_var_char() ? *literal_type_.var_char_ - : reinterpret_cast< ::io::substrait::Expression_Literal_VarChar&>(::io::substrait::_Expression_Literal_VarChar_default_instance_); + : reinterpret_cast< ::substrait::Expression_Literal_VarChar&>(::substrait::_Expression_Literal_VarChar_default_instance_); } -inline const ::io::substrait::Expression_Literal_VarChar& Expression_Literal::var_char() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.var_char) +inline const ::substrait::Expression_Literal_VarChar& Expression_Literal::var_char() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.var_char) return _internal_var_char(); } -inline ::io::substrait::Expression_Literal_VarChar* Expression_Literal::unsafe_arena_release_var_char() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.var_char) +inline ::substrait::Expression_Literal_VarChar* Expression_Literal::unsafe_arena_release_var_char() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.var_char) if (_internal_has_var_char()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_; + ::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_; literal_type_.var_char_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_Literal::unsafe_arena_set_allocated_var_char(::io::substrait::Expression_Literal_VarChar* var_char) { +inline void Expression_Literal::unsafe_arena_set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char) { clear_literal_type(); if (var_char) { set_has_var_char(); literal_type_.var_char_ = var_char; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.var_char) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.var_char) } -inline ::io::substrait::Expression_Literal_VarChar* Expression_Literal::_internal_mutable_var_char() { +inline ::substrait::Expression_Literal_VarChar* Expression_Literal::_internal_mutable_var_char() { if (!_internal_has_var_char()) { clear_literal_type(); set_has_var_char(); - literal_type_.var_char_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_VarChar >(GetArena()); + literal_type_.var_char_ = CreateMaybeMessage< ::substrait::Expression_Literal_VarChar >(GetArena()); } return literal_type_.var_char_; } -inline ::io::substrait::Expression_Literal_VarChar* Expression_Literal::mutable_var_char() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.var_char) +inline ::substrait::Expression_Literal_VarChar* Expression_Literal::mutable_var_char() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.var_char) return _internal_mutable_var_char(); } @@ -10825,7 +10575,7 @@ inline void Expression_Literal::clear_fixed_binary() { } } inline const std::string& Expression_Literal::fixed_binary() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.fixed_binary) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fixed_binary) return _internal_fixed_binary(); } template @@ -10836,10 +10586,10 @@ inline void Expression_Literal::set_fixed_binary(ArgT0&& arg0, ArgT... args) { literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } literal_type_.fixed_binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.fixed_binary) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fixed_binary) } inline std::string* Expression_Literal::mutable_fixed_binary() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.fixed_binary) + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.fixed_binary) return _internal_mutable_fixed_binary(); } inline const std::string& Expression_Literal::_internal_fixed_binary() const { @@ -10866,7 +10616,7 @@ inline std::string* Expression_Literal::_internal_mutable_fixed_binary() { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_Literal::release_fixed_binary() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.fixed_binary) + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.fixed_binary) if (_internal_has_fixed_binary()) { clear_has_literal_type(); return literal_type_.fixed_binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -10886,10 +10636,10 @@ inline void Expression_Literal::set_allocated_fixed_binary(std::string* fixed_bi arena->Own(fixed_binary); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.fixed_binary) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.fixed_binary) } -// .io.substrait.Expression.Literal.Decimal decimal = 24; +// .substrait.Expression.Literal.Decimal decimal = 24; inline bool Expression_Literal::_internal_has_decimal() const { return literal_type_case() == kDecimal; } @@ -10907,11 +10657,11 @@ inline void Expression_Literal::clear_decimal() { clear_has_literal_type(); } } -inline ::io::substrait::Expression_Literal_Decimal* Expression_Literal::release_decimal() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.decimal) +inline ::substrait::Expression_Literal_Decimal* Expression_Literal::release_decimal() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.decimal) if (_internal_has_decimal()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_; + ::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -10921,48 +10671,48 @@ inline ::io::substrait::Expression_Literal_Decimal* Expression_Literal::release_ return nullptr; } } -inline const ::io::substrait::Expression_Literal_Decimal& Expression_Literal::_internal_decimal() const { +inline const ::substrait::Expression_Literal_Decimal& Expression_Literal::_internal_decimal() const { return _internal_has_decimal() ? *literal_type_.decimal_ - : reinterpret_cast< ::io::substrait::Expression_Literal_Decimal&>(::io::substrait::_Expression_Literal_Decimal_default_instance_); + : reinterpret_cast< ::substrait::Expression_Literal_Decimal&>(::substrait::_Expression_Literal_Decimal_default_instance_); } -inline const ::io::substrait::Expression_Literal_Decimal& Expression_Literal::decimal() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.decimal) +inline const ::substrait::Expression_Literal_Decimal& Expression_Literal::decimal() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.decimal) return _internal_decimal(); } -inline ::io::substrait::Expression_Literal_Decimal* Expression_Literal::unsafe_arena_release_decimal() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.decimal) +inline ::substrait::Expression_Literal_Decimal* Expression_Literal::unsafe_arena_release_decimal() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.decimal) if (_internal_has_decimal()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_; + ::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_; literal_type_.decimal_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_Literal::unsafe_arena_set_allocated_decimal(::io::substrait::Expression_Literal_Decimal* decimal) { +inline void Expression_Literal::unsafe_arena_set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal) { clear_literal_type(); if (decimal) { set_has_decimal(); literal_type_.decimal_ = decimal; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.decimal) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.decimal) } -inline ::io::substrait::Expression_Literal_Decimal* Expression_Literal::_internal_mutable_decimal() { +inline ::substrait::Expression_Literal_Decimal* Expression_Literal::_internal_mutable_decimal() { if (!_internal_has_decimal()) { clear_literal_type(); set_has_decimal(); - literal_type_.decimal_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_Decimal >(GetArena()); + literal_type_.decimal_ = CreateMaybeMessage< ::substrait::Expression_Literal_Decimal >(GetArena()); } return literal_type_.decimal_; } -inline ::io::substrait::Expression_Literal_Decimal* Expression_Literal::mutable_decimal() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.decimal) +inline ::substrait::Expression_Literal_Decimal* Expression_Literal::mutable_decimal() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.decimal) return _internal_mutable_decimal(); } -// .io.substrait.Expression.Literal.Struct struct = 25; +// .substrait.Expression.Literal.Struct struct = 25; inline bool Expression_Literal::_internal_has_struct_() const { return literal_type_case() == kStruct; } @@ -10980,11 +10730,11 @@ inline void Expression_Literal::clear_struct_() { clear_has_literal_type(); } } -inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.struct) +inline ::substrait::Expression_Literal_Struct* Expression_Literal::release_struct_() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.struct) if (_internal_has_struct_()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; + ::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -10994,48 +10744,48 @@ inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::release_s return nullptr; } } -inline const ::io::substrait::Expression_Literal_Struct& Expression_Literal::_internal_struct_() const { +inline const ::substrait::Expression_Literal_Struct& Expression_Literal::_internal_struct_() const { return _internal_has_struct_() ? *literal_type_.struct__ - : reinterpret_cast< ::io::substrait::Expression_Literal_Struct&>(::io::substrait::_Expression_Literal_Struct_default_instance_); + : reinterpret_cast< ::substrait::Expression_Literal_Struct&>(::substrait::_Expression_Literal_Struct_default_instance_); } -inline const ::io::substrait::Expression_Literal_Struct& Expression_Literal::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.struct) +inline const ::substrait::Expression_Literal_Struct& Expression_Literal::struct_() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.struct) return _internal_struct_(); } -inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.struct) +inline ::substrait::Expression_Literal_Struct* Expression_Literal::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.struct) if (_internal_has_struct_()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; + ::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; literal_type_.struct__ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_Literal::unsafe_arena_set_allocated_struct_(::io::substrait::Expression_Literal_Struct* struct_) { +inline void Expression_Literal::unsafe_arena_set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_) { clear_literal_type(); if (struct_) { set_has_struct_(); literal_type_.struct__ = struct_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.struct) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.struct) } -inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::_internal_mutable_struct_() { +inline ::substrait::Expression_Literal_Struct* Expression_Literal::_internal_mutable_struct_() { if (!_internal_has_struct_()) { clear_literal_type(); set_has_struct_(); - literal_type_.struct__ = CreateMaybeMessage< ::io::substrait::Expression_Literal_Struct >(GetArena()); + literal_type_.struct__ = CreateMaybeMessage< ::substrait::Expression_Literal_Struct >(GetArena()); } return literal_type_.struct__; } -inline ::io::substrait::Expression_Literal_Struct* Expression_Literal::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.struct) +inline ::substrait::Expression_Literal_Struct* Expression_Literal::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.struct) return _internal_mutable_struct_(); } -// .io.substrait.Expression.Literal.Map map = 26; +// .substrait.Expression.Literal.Map map = 26; inline bool Expression_Literal::_internal_has_map() const { return literal_type_case() == kMap; } @@ -11053,11 +10803,11 @@ inline void Expression_Literal::clear_map() { clear_has_literal_type(); } } -inline ::io::substrait::Expression_Literal_Map* Expression_Literal::release_map() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.map) +inline ::substrait::Expression_Literal_Map* Expression_Literal::release_map() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.map) if (_internal_has_map()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_Map* temp = literal_type_.map_; + ::substrait::Expression_Literal_Map* temp = literal_type_.map_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -11067,44 +10817,44 @@ inline ::io::substrait::Expression_Literal_Map* Expression_Literal::release_map( return nullptr; } } -inline const ::io::substrait::Expression_Literal_Map& Expression_Literal::_internal_map() const { +inline const ::substrait::Expression_Literal_Map& Expression_Literal::_internal_map() const { return _internal_has_map() ? *literal_type_.map_ - : reinterpret_cast< ::io::substrait::Expression_Literal_Map&>(::io::substrait::_Expression_Literal_Map_default_instance_); + : reinterpret_cast< ::substrait::Expression_Literal_Map&>(::substrait::_Expression_Literal_Map_default_instance_); } -inline const ::io::substrait::Expression_Literal_Map& Expression_Literal::map() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.map) +inline const ::substrait::Expression_Literal_Map& Expression_Literal::map() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.map) return _internal_map(); } -inline ::io::substrait::Expression_Literal_Map* Expression_Literal::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.map) +inline ::substrait::Expression_Literal_Map* Expression_Literal::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.map) if (_internal_has_map()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_Map* temp = literal_type_.map_; + ::substrait::Expression_Literal_Map* temp = literal_type_.map_; literal_type_.map_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_Literal::unsafe_arena_set_allocated_map(::io::substrait::Expression_Literal_Map* map) { +inline void Expression_Literal::unsafe_arena_set_allocated_map(::substrait::Expression_Literal_Map* map) { clear_literal_type(); if (map) { set_has_map(); literal_type_.map_ = map; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.map) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.map) } -inline ::io::substrait::Expression_Literal_Map* Expression_Literal::_internal_mutable_map() { +inline ::substrait::Expression_Literal_Map* Expression_Literal::_internal_mutable_map() { if (!_internal_has_map()) { clear_literal_type(); set_has_map(); - literal_type_.map_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_Map >(GetArena()); + literal_type_.map_ = CreateMaybeMessage< ::substrait::Expression_Literal_Map >(GetArena()); } return literal_type_.map_; } -inline ::io::substrait::Expression_Literal_Map* Expression_Literal::mutable_map() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.map) +inline ::substrait::Expression_Literal_Map* Expression_Literal::mutable_map() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.map) return _internal_mutable_map(); } @@ -11138,12 +10888,12 @@ inline void Expression_Literal::_internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ literal_type_.timestamp_tz_ = value; } inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::timestamp_tz() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.timestamp_tz) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.timestamp_tz) return _internal_timestamp_tz(); } inline void Expression_Literal::set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_timestamp_tz(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.timestamp_tz) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.timestamp_tz) } // bytes uuid = 28; @@ -11163,7 +10913,7 @@ inline void Expression_Literal::clear_uuid() { } } inline const std::string& Expression_Literal::uuid() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.uuid) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.uuid) return _internal_uuid(); } template @@ -11174,10 +10924,10 @@ inline void Expression_Literal::set_uuid(ArgT0&& arg0, ArgT... args) { literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } literal_type_.uuid_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.uuid) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.uuid) } inline std::string* Expression_Literal::mutable_uuid() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.uuid) + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.uuid) return _internal_mutable_uuid(); } inline const std::string& Expression_Literal::_internal_uuid() const { @@ -11204,7 +10954,7 @@ inline std::string* Expression_Literal::_internal_mutable_uuid() { ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_Literal::release_uuid() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.uuid) + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.uuid) if (_internal_has_uuid()) { clear_has_literal_type(); return literal_type_.uuid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -11224,10 +10974,10 @@ inline void Expression_Literal::set_allocated_uuid(std::string* uuid) { arena->Own(uuid); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Literal.uuid) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.uuid) } -// .io.substrait.Type null = 29; +// .substrait.Type null = 29; inline bool Expression_Literal::_internal_has_null() const { return literal_type_case() == kNull; } @@ -11237,11 +10987,11 @@ inline bool Expression_Literal::has_null() const { inline void Expression_Literal::set_has_null() { _oneof_case_[0] = kNull; } -inline ::io::substrait::Type* Expression_Literal::release_null() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.null) +inline ::substrait::Type* Expression_Literal::release_null() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.null) if (_internal_has_null()) { clear_has_literal_type(); - ::io::substrait::Type* temp = literal_type_.null_; + ::substrait::Type* temp = literal_type_.null_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -11251,48 +11001,48 @@ inline ::io::substrait::Type* Expression_Literal::release_null() { return nullptr; } } -inline const ::io::substrait::Type& Expression_Literal::_internal_null() const { +inline const ::substrait::Type& Expression_Literal::_internal_null() const { return _internal_has_null() ? *literal_type_.null_ - : reinterpret_cast< ::io::substrait::Type&>(::io::substrait::_Type_default_instance_); + : reinterpret_cast< ::substrait::Type&>(::substrait::_Type_default_instance_); } -inline const ::io::substrait::Type& Expression_Literal::null() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.null) +inline const ::substrait::Type& Expression_Literal::null() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.null) return _internal_null(); } -inline ::io::substrait::Type* Expression_Literal::unsafe_arena_release_null() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.null) +inline ::substrait::Type* Expression_Literal::unsafe_arena_release_null() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.null) if (_internal_has_null()) { clear_has_literal_type(); - ::io::substrait::Type* temp = literal_type_.null_; + ::substrait::Type* temp = literal_type_.null_; literal_type_.null_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_Literal::unsafe_arena_set_allocated_null(::io::substrait::Type* null) { +inline void Expression_Literal::unsafe_arena_set_allocated_null(::substrait::Type* null) { clear_literal_type(); if (null) { set_has_null(); literal_type_.null_ = null; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.null) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.null) } -inline ::io::substrait::Type* Expression_Literal::_internal_mutable_null() { +inline ::substrait::Type* Expression_Literal::_internal_mutable_null() { if (!_internal_has_null()) { clear_literal_type(); set_has_null(); - literal_type_.null_ = CreateMaybeMessage< ::io::substrait::Type >(GetArena()); + literal_type_.null_ = CreateMaybeMessage< ::substrait::Type >(GetArena()); } return literal_type_.null_; } -inline ::io::substrait::Type* Expression_Literal::mutable_null() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.null) +inline ::substrait::Type* Expression_Literal::mutable_null() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.null) return _internal_mutable_null(); } -// .io.substrait.Expression.Literal.List list = 30; +// .substrait.Expression.Literal.List list = 30; inline bool Expression_Literal::_internal_has_list() const { return literal_type_case() == kList; } @@ -11310,11 +11060,11 @@ inline void Expression_Literal::clear_list() { clear_has_literal_type(); } } -inline ::io::substrait::Expression_Literal_List* Expression_Literal::release_list() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Literal.list) +inline ::substrait::Expression_Literal_List* Expression_Literal::release_list() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.list) if (_internal_has_list()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_List* temp = literal_type_.list_; + ::substrait::Expression_Literal_List* temp = literal_type_.list_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -11324,47 +11074,177 @@ inline ::io::substrait::Expression_Literal_List* Expression_Literal::release_lis return nullptr; } } -inline const ::io::substrait::Expression_Literal_List& Expression_Literal::_internal_list() const { +inline const ::substrait::Expression_Literal_List& Expression_Literal::_internal_list() const { return _internal_has_list() ? *literal_type_.list_ - : reinterpret_cast< ::io::substrait::Expression_Literal_List&>(::io::substrait::_Expression_Literal_List_default_instance_); + : reinterpret_cast< ::substrait::Expression_Literal_List&>(::substrait::_Expression_Literal_List_default_instance_); } -inline const ::io::substrait::Expression_Literal_List& Expression_Literal::list() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.list) +inline const ::substrait::Expression_Literal_List& Expression_Literal::list() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.list) return _internal_list(); } -inline ::io::substrait::Expression_Literal_List* Expression_Literal::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.Literal.list) +inline ::substrait::Expression_Literal_List* Expression_Literal::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.list) if (_internal_has_list()) { clear_has_literal_type(); - ::io::substrait::Expression_Literal_List* temp = literal_type_.list_; + ::substrait::Expression_Literal_List* temp = literal_type_.list_; literal_type_.list_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_Literal::unsafe_arena_set_allocated_list(::io::substrait::Expression_Literal_List* list) { +inline void Expression_Literal::unsafe_arena_set_allocated_list(::substrait::Expression_Literal_List* list) { clear_literal_type(); if (list) { set_has_list(); literal_type_.list_ = list; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Literal.list) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.list) } -inline ::io::substrait::Expression_Literal_List* Expression_Literal::_internal_mutable_list() { +inline ::substrait::Expression_Literal_List* Expression_Literal::_internal_mutable_list() { if (!_internal_has_list()) { clear_literal_type(); set_has_list(); - literal_type_.list_ = CreateMaybeMessage< ::io::substrait::Expression_Literal_List >(GetArena()); + literal_type_.list_ = CreateMaybeMessage< ::substrait::Expression_Literal_List >(GetArena()); } return literal_type_.list_; } -inline ::io::substrait::Expression_Literal_List* Expression_Literal::mutable_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Literal.list) +inline ::substrait::Expression_Literal_List* Expression_Literal::mutable_list() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.list) return _internal_mutable_list(); } +// .substrait.Type.List empty_list = 31; +inline bool Expression_Literal::_internal_has_empty_list() const { + return literal_type_case() == kEmptyList; +} +inline bool Expression_Literal::has_empty_list() const { + return _internal_has_empty_list(); +} +inline void Expression_Literal::set_has_empty_list() { + _oneof_case_[0] = kEmptyList; +} +inline ::substrait::Type_List* Expression_Literal::release_empty_list() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.empty_list) + if (_internal_has_empty_list()) { + clear_has_literal_type(); + ::substrait::Type_List* temp = literal_type_.empty_list_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.empty_list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::substrait::Type_List& Expression_Literal::_internal_empty_list() const { + return _internal_has_empty_list() + ? *literal_type_.empty_list_ + : reinterpret_cast< ::substrait::Type_List&>(::substrait::_Type_List_default_instance_); +} +inline const ::substrait::Type_List& Expression_Literal::empty_list() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.empty_list) + return _internal_empty_list(); +} +inline ::substrait::Type_List* Expression_Literal::unsafe_arena_release_empty_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.empty_list) + if (_internal_has_empty_list()) { + clear_has_literal_type(); + ::substrait::Type_List* temp = literal_type_.empty_list_; + literal_type_.empty_list_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_empty_list(::substrait::Type_List* empty_list) { + clear_literal_type(); + if (empty_list) { + set_has_empty_list(); + literal_type_.empty_list_ = empty_list; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.empty_list) +} +inline ::substrait::Type_List* Expression_Literal::_internal_mutable_empty_list() { + if (!_internal_has_empty_list()) { + clear_literal_type(); + set_has_empty_list(); + literal_type_.empty_list_ = CreateMaybeMessage< ::substrait::Type_List >(GetArena()); + } + return literal_type_.empty_list_; +} +inline ::substrait::Type_List* Expression_Literal::mutable_empty_list() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.empty_list) + return _internal_mutable_empty_list(); +} + +// .substrait.Type.Map empty_map = 32; +inline bool Expression_Literal::_internal_has_empty_map() const { + return literal_type_case() == kEmptyMap; +} +inline bool Expression_Literal::has_empty_map() const { + return _internal_has_empty_map(); +} +inline void Expression_Literal::set_has_empty_map() { + _oneof_case_[0] = kEmptyMap; +} +inline ::substrait::Type_Map* Expression_Literal::release_empty_map() { + // @@protoc_insertion_point(field_release:substrait.Expression.Literal.empty_map) + if (_internal_has_empty_map()) { + clear_has_literal_type(); + ::substrait::Type_Map* temp = literal_type_.empty_map_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + literal_type_.empty_map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::substrait::Type_Map& Expression_Literal::_internal_empty_map() const { + return _internal_has_empty_map() + ? *literal_type_.empty_map_ + : reinterpret_cast< ::substrait::Type_Map&>(::substrait::_Type_Map_default_instance_); +} +inline const ::substrait::Type_Map& Expression_Literal::empty_map() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.empty_map) + return _internal_empty_map(); +} +inline ::substrait::Type_Map* Expression_Literal::unsafe_arena_release_empty_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.empty_map) + if (_internal_has_empty_map()) { + clear_has_literal_type(); + ::substrait::Type_Map* temp = literal_type_.empty_map_; + literal_type_.empty_map_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Expression_Literal::unsafe_arena_set_allocated_empty_map(::substrait::Type_Map* empty_map) { + clear_literal_type(); + if (empty_map) { + set_has_empty_map(); + literal_type_.empty_map_ = empty_map; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.empty_map) +} +inline ::substrait::Type_Map* Expression_Literal::_internal_mutable_empty_map() { + if (!_internal_has_empty_map()) { + clear_literal_type(); + set_has_empty_map(); + literal_type_.empty_map_ = CreateMaybeMessage< ::substrait::Type_Map >(GetArena()); + } + return literal_type_.empty_map_; +} +inline ::substrait::Type_Map* Expression_Literal::mutable_empty_map() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.empty_map) + return _internal_mutable_empty_map(); +} + // bool nullable = 50; inline void Expression_Literal::clear_nullable() { nullable_ = false; @@ -11373,7 +11253,7 @@ inline bool Expression_Literal::_internal_nullable() const { return nullable_; } inline bool Expression_Literal::nullable() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Literal.nullable) + // @@protoc_insertion_point(field_get:substrait.Expression.Literal.nullable) return _internal_nullable(); } inline void Expression_Literal::_internal_set_nullable(bool value) { @@ -11382,7 +11262,7 @@ inline void Expression_Literal::_internal_set_nullable(bool value) { } inline void Expression_Literal::set_nullable(bool value) { _internal_set_nullable(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.Literal.nullable) + // @@protoc_insertion_point(field_set:substrait.Expression.Literal.nullable) } inline bool Expression_Literal::has_literal_type() const { @@ -11406,7 +11286,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_ScalarFunction::_internal_func return function_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_ScalarFunction::function_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.function_reference) + // @@protoc_insertion_point(field_get:substrait.Expression.ScalarFunction.function_reference) return _internal_function_reference(); } inline void Expression_ScalarFunction::_internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -11415,10 +11295,10 @@ inline void Expression_ScalarFunction::_internal_set_function_reference(::PROTOB } inline void Expression_ScalarFunction::set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_function_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.ScalarFunction.function_reference) + // @@protoc_insertion_point(field_set:substrait.Expression.ScalarFunction.function_reference) } -// repeated .io.substrait.Expression args = 2; +// repeated .substrait.Expression args = 2; inline int Expression_ScalarFunction::_internal_args_size() const { return args_.size(); } @@ -11428,53 +11308,53 @@ inline int Expression_ScalarFunction::args_size() const { inline void Expression_ScalarFunction::clear_args() { args_.Clear(); } -inline ::io::substrait::Expression* Expression_ScalarFunction::mutable_args(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ScalarFunction.args) +inline ::substrait::Expression* Expression_ScalarFunction::mutable_args(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.ScalarFunction.args) return args_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* Expression_ScalarFunction::mutable_args() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.ScalarFunction.args) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.ScalarFunction.args) return &args_; } -inline const ::io::substrait::Expression& Expression_ScalarFunction::_internal_args(int index) const { +inline const ::substrait::Expression& Expression_ScalarFunction::_internal_args(int index) const { return args_.Get(index); } -inline const ::io::substrait::Expression& Expression_ScalarFunction::args(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.args) +inline const ::substrait::Expression& Expression_ScalarFunction::args(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.ScalarFunction.args) return _internal_args(index); } -inline ::io::substrait::Expression* Expression_ScalarFunction::_internal_add_args() { +inline ::substrait::Expression* Expression_ScalarFunction::_internal_add_args() { return args_.Add(); } -inline ::io::substrait::Expression* Expression_ScalarFunction::add_args() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.ScalarFunction.args) +inline ::substrait::Expression* Expression_ScalarFunction::add_args() { + // @@protoc_insertion_point(field_add:substrait.Expression.ScalarFunction.args) return _internal_add_args(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_ScalarFunction::args() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.ScalarFunction.args) + // @@protoc_insertion_point(field_list:substrait.Expression.ScalarFunction.args) return args_; } -// .io.substrait.Type output_type = 3; +// .substrait.Type output_type = 3; inline bool Expression_ScalarFunction::_internal_has_output_type() const { return this != internal_default_instance() && output_type_ != nullptr; } inline bool Expression_ScalarFunction::has_output_type() const { return _internal_has_output_type(); } -inline const ::io::substrait::Type& Expression_ScalarFunction::_internal_output_type() const { - const ::io::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline const ::substrait::Type& Expression_ScalarFunction::_internal_output_type() const { + const ::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Type_default_instance_); } -inline const ::io::substrait::Type& Expression_ScalarFunction::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ScalarFunction.output_type) +inline const ::substrait::Type& Expression_ScalarFunction::output_type() const { + // @@protoc_insertion_point(field_get:substrait.Expression.ScalarFunction.output_type) return _internal_output_type(); } inline void Expression_ScalarFunction::unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type) { + ::substrait::Type* output_type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } @@ -11484,37 +11364,37 @@ inline void Expression_ScalarFunction::unsafe_arena_set_allocated_output_type( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ScalarFunction.output_type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ScalarFunction.output_type) } -inline ::io::substrait::Type* Expression_ScalarFunction::release_output_type() { +inline ::substrait::Type* Expression_ScalarFunction::release_output_type() { - ::io::substrait::Type* temp = output_type_; + ::substrait::Type* temp = output_type_; output_type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type* Expression_ScalarFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.ScalarFunction.output_type) +inline ::substrait::Type* Expression_ScalarFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:substrait.Expression.ScalarFunction.output_type) - ::io::substrait::Type* temp = output_type_; + ::substrait::Type* temp = output_type_; output_type_ = nullptr; return temp; } -inline ::io::substrait::Type* Expression_ScalarFunction::_internal_mutable_output_type() { +inline ::substrait::Type* Expression_ScalarFunction::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); output_type_ = p; } return output_type_; } -inline ::io::substrait::Type* Expression_ScalarFunction::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ScalarFunction.output_type) +inline ::substrait::Type* Expression_ScalarFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.ScalarFunction.output_type) return _internal_mutable_output_type(); } -inline void Expression_ScalarFunction::set_allocated_output_type(::io::substrait::Type* output_type) { +inline void Expression_ScalarFunction::set_allocated_output_type(::substrait::Type* output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); @@ -11531,7 +11411,7 @@ inline void Expression_ScalarFunction::set_allocated_output_type(::io::substrait } output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ScalarFunction.output_type) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ScalarFunction.output_type) } // ------------------------------------------------------------------- @@ -11546,7 +11426,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Preceding: return offset_; } inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Preceding::offset() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.Preceding.offset) + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.Preceding.offset) return _internal_offset(); } inline void Expression_WindowFunction_Bound_Preceding::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { @@ -11555,7 +11435,7 @@ inline void Expression_WindowFunction_Bound_Preceding::_internal_set_offset(::PR } inline void Expression_WindowFunction_Bound_Preceding::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_offset(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.Bound.Preceding.offset) + // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.Bound.Preceding.offset) } // ------------------------------------------------------------------- @@ -11570,7 +11450,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Following: return offset_; } inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Following::offset() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.Following.offset) + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.Following.offset) return _internal_offset(); } inline void Expression_WindowFunction_Bound_Following::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { @@ -11579,7 +11459,7 @@ inline void Expression_WindowFunction_Bound_Following::_internal_set_offset(::PR } inline void Expression_WindowFunction_Bound_Following::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_offset(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.Bound.Following.offset) + // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.Bound.Following.offset) } // ------------------------------------------------------------------- @@ -11594,7 +11474,7 @@ inline void Expression_WindowFunction_Bound_Following::set_offset(::PROTOBUF_NAM // Expression_WindowFunction_Bound -// .io.substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; +// .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; inline bool Expression_WindowFunction_Bound::_internal_has_preceding() const { return kind_case() == kPreceding; } @@ -11612,11 +11492,11 @@ inline void Expression_WindowFunction_Bound::clear_preceding() { clear_has_kind(); } } -inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::release_preceding() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.preceding) +inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::release_preceding() { + // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.preceding) if (_internal_has_preceding()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; + ::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -11626,48 +11506,48 @@ inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_Wi return nullptr; } } -inline const ::io::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::_internal_preceding() const { +inline const ::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::_internal_preceding() const { return _internal_has_preceding() ? *kind_.preceding_ - : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Preceding&>(::io::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_); + : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_Preceding&>(::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::preceding() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.preceding) +inline const ::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::preceding() const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.preceding) return _internal_preceding(); } -inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::unsafe_arena_release_preceding() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.preceding) +inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::unsafe_arena_release_preceding() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.preceding) if (_internal_has_preceding()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; + ::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; kind_.preceding_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_preceding(::io::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { clear_kind(); if (preceding) { set_has_preceding(); kind_.preceding_ = preceding; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.preceding) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.preceding) } -inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::_internal_mutable_preceding() { +inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::_internal_mutable_preceding() { if (!_internal_has_preceding()) { clear_kind(); set_has_preceding(); - kind_.preceding_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Preceding >(GetArena()); + kind_.preceding_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Preceding >(GetArena()); } return kind_.preceding_; } -inline ::io::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::mutable_preceding() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.preceding) +inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::mutable_preceding() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.preceding) return _internal_mutable_preceding(); } -// .io.substrait.Expression.WindowFunction.Bound.Following following = 2; +// .substrait.Expression.WindowFunction.Bound.Following following = 2; inline bool Expression_WindowFunction_Bound::_internal_has_following() const { return kind_case() == kFollowing; } @@ -11685,11 +11565,11 @@ inline void Expression_WindowFunction_Bound::clear_following() { clear_has_kind(); } } -inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::release_following() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.following) +inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::release_following() { + // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.following) if (_internal_has_following()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; + ::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -11699,48 +11579,48 @@ inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_Wi return nullptr; } } -inline const ::io::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::_internal_following() const { +inline const ::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::_internal_following() const { return _internal_has_following() ? *kind_.following_ - : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Following&>(::io::substrait::_Expression_WindowFunction_Bound_Following_default_instance_); + : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_Following&>(::substrait::_Expression_WindowFunction_Bound_Following_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::following() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.following) +inline const ::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::following() const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.following) return _internal_following(); } -inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::unsafe_arena_release_following() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.following) +inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::unsafe_arena_release_following() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.following) if (_internal_has_following()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; + ::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; kind_.following_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_following(::io::substrait::Expression_WindowFunction_Bound_Following* following) { +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following) { clear_kind(); if (following) { set_has_following(); kind_.following_ = following; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.following) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.following) } -inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::_internal_mutable_following() { +inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::_internal_mutable_following() { if (!_internal_has_following()) { clear_kind(); set_has_following(); - kind_.following_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Following >(GetArena()); + kind_.following_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Following >(GetArena()); } return kind_.following_; } -inline ::io::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::mutable_following() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.following) +inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::mutable_following() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.following) return _internal_mutable_following(); } -// .io.substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; +// .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; inline bool Expression_WindowFunction_Bound::_internal_has_current_row() const { return kind_case() == kCurrentRow; } @@ -11758,11 +11638,11 @@ inline void Expression_WindowFunction_Bound::clear_current_row() { clear_has_kind(); } } -inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::release_current_row() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.current_row) +inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::release_current_row() { + // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.current_row) if (_internal_has_current_row()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; + ::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -11772,48 +11652,48 @@ inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_W return nullptr; } } -inline const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::_internal_current_row() const { +inline const ::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::_internal_current_row() const { return _internal_has_current_row() ? *kind_.current_row_ - : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow&>(::io::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_); + : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_CurrentRow&>(::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::current_row() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.current_row) +inline const ::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::current_row() const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.current_row) return _internal_current_row(); } -inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::unsafe_arena_release_current_row() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.current_row) +inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::unsafe_arena_release_current_row() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.current_row) if (_internal_has_current_row()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; + ::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; kind_.current_row_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_current_row(::io::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { clear_kind(); if (current_row) { set_has_current_row(); kind_.current_row_ = current_row; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.current_row) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.current_row) } -inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::_internal_mutable_current_row() { +inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::_internal_mutable_current_row() { if (!_internal_has_current_row()) { clear_kind(); set_has_current_row(); - kind_.current_row_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_CurrentRow >(GetArena()); + kind_.current_row_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(GetArena()); } return kind_.current_row_; } -inline ::io::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::mutable_current_row() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.current_row) +inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::mutable_current_row() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.current_row) return _internal_mutable_current_row(); } -// .io.substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; +// .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; inline bool Expression_WindowFunction_Bound::_internal_has_unbounded() const { return kind_case() == kUnbounded; } @@ -11831,11 +11711,11 @@ inline void Expression_WindowFunction_Bound::clear_unbounded() { clear_has_kind(); } } -inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::release_unbounded() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.Bound.unbounded) +inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::release_unbounded() { + // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.unbounded) if (_internal_has_unbounded()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; + ::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -11845,44 +11725,44 @@ inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_Wi return nullptr; } } -inline const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::_internal_unbounded() const { +inline const ::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::_internal_unbounded() const { return _internal_has_unbounded() ? *kind_.unbounded_ - : reinterpret_cast< ::io::substrait::Expression_WindowFunction_Bound_Unbounded&>(::io::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_); + : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_Unbounded&>(::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::unbounded() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.Bound.unbounded) +inline const ::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::unbounded() const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.unbounded) return _internal_unbounded(); } -inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::unsafe_arena_release_unbounded() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.WindowFunction.Bound.unbounded) +inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::unsafe_arena_release_unbounded() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.unbounded) if (_internal_has_unbounded()) { clear_has_kind(); - ::io::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; + ::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; kind_.unbounded_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_unbounded(::io::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { +inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { clear_kind(); if (unbounded) { set_has_unbounded(); kind_.unbounded_ = unbounded; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.Bound.unbounded) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.unbounded) } -inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::_internal_mutable_unbounded() { +inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::_internal_mutable_unbounded() { if (!_internal_has_unbounded()) { clear_kind(); set_has_unbounded(); - kind_.unbounded_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction_Bound_Unbounded >(GetArena()); + kind_.unbounded_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Unbounded >(GetArena()); } return kind_.unbounded_; } -inline ::io::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::mutable_unbounded() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.Bound.unbounded) +inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::mutable_unbounded() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.unbounded) return _internal_mutable_unbounded(); } @@ -11907,7 +11787,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_WindowFunction::_internal_func return function_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_WindowFunction::function_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.function_reference) + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.function_reference) return _internal_function_reference(); } inline void Expression_WindowFunction::_internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -11916,10 +11796,10 @@ inline void Expression_WindowFunction::_internal_set_function_reference(::PROTOB } inline void Expression_WindowFunction::set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_function_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.function_reference) + // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.function_reference) } -// repeated .io.substrait.Expression partitions = 2; +// repeated .substrait.Expression partitions = 2; inline int Expression_WindowFunction::_internal_partitions_size() const { return partitions_.size(); } @@ -11929,36 +11809,36 @@ inline int Expression_WindowFunction::partitions_size() const { inline void Expression_WindowFunction::clear_partitions() { partitions_.Clear(); } -inline ::io::substrait::Expression* Expression_WindowFunction::mutable_partitions(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.partitions) +inline ::substrait::Expression* Expression_WindowFunction::mutable_partitions(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.partitions) return partitions_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* Expression_WindowFunction::mutable_partitions() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.partitions) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.WindowFunction.partitions) return &partitions_; } -inline const ::io::substrait::Expression& Expression_WindowFunction::_internal_partitions(int index) const { +inline const ::substrait::Expression& Expression_WindowFunction::_internal_partitions(int index) const { return partitions_.Get(index); } -inline const ::io::substrait::Expression& Expression_WindowFunction::partitions(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.partitions) +inline const ::substrait::Expression& Expression_WindowFunction::partitions(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.partitions) return _internal_partitions(index); } -inline ::io::substrait::Expression* Expression_WindowFunction::_internal_add_partitions() { +inline ::substrait::Expression* Expression_WindowFunction::_internal_add_partitions() { return partitions_.Add(); } -inline ::io::substrait::Expression* Expression_WindowFunction::add_partitions() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.partitions) +inline ::substrait::Expression* Expression_WindowFunction::add_partitions() { + // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.partitions) return _internal_add_partitions(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_WindowFunction::partitions() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.partitions) + // @@protoc_insertion_point(field_list:substrait.Expression.WindowFunction.partitions) return partitions_; } -// repeated .io.substrait.SortField sorts = 3; +// repeated .substrait.SortField sorts = 3; inline int Expression_WindowFunction::_internal_sorts_size() const { return sorts_.size(); } @@ -11968,36 +11848,36 @@ inline int Expression_WindowFunction::sorts_size() const { inline void Expression_WindowFunction::clear_sorts() { sorts_.Clear(); } -inline ::io::substrait::SortField* Expression_WindowFunction::mutable_sorts(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.sorts) +inline ::substrait::SortField* Expression_WindowFunction::mutable_sorts(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.sorts) return sorts_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* Expression_WindowFunction::mutable_sorts() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.sorts) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.WindowFunction.sorts) return &sorts_; } -inline const ::io::substrait::SortField& Expression_WindowFunction::_internal_sorts(int index) const { +inline const ::substrait::SortField& Expression_WindowFunction::_internal_sorts(int index) const { return sorts_.Get(index); } -inline const ::io::substrait::SortField& Expression_WindowFunction::sorts(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.sorts) +inline const ::substrait::SortField& Expression_WindowFunction::sorts(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.sorts) return _internal_sorts(index); } -inline ::io::substrait::SortField* Expression_WindowFunction::_internal_add_sorts() { +inline ::substrait::SortField* Expression_WindowFunction::_internal_add_sorts() { return sorts_.Add(); } -inline ::io::substrait::SortField* Expression_WindowFunction::add_sorts() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.sorts) +inline ::substrait::SortField* Expression_WindowFunction::add_sorts() { + // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.sorts) return _internal_add_sorts(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& Expression_WindowFunction::sorts() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.sorts) + // @@protoc_insertion_point(field_list:substrait.Expression.WindowFunction.sorts) return sorts_; } -// .io.substrait.Expression.WindowFunction.Bound upper_bound = 4; +// .substrait.Expression.WindowFunction.Bound upper_bound = 4; inline bool Expression_WindowFunction::_internal_has_upper_bound() const { return this != internal_default_instance() && upper_bound_ != nullptr; } @@ -12010,17 +11890,17 @@ inline void Expression_WindowFunction::clear_upper_bound() { } upper_bound_ = nullptr; } -inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_upper_bound() const { - const ::io::substrait::Expression_WindowFunction_Bound* p = upper_bound_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_WindowFunction_Bound_default_instance_); +inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_upper_bound() const { + const ::substrait::Expression_WindowFunction_Bound* p = upper_bound_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_WindowFunction_Bound_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::upper_bound() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.upper_bound) +inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::upper_bound() const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.upper_bound) return _internal_upper_bound(); } inline void Expression_WindowFunction::unsafe_arena_set_allocated_upper_bound( - ::io::substrait::Expression_WindowFunction_Bound* upper_bound) { + ::substrait::Expression_WindowFunction_Bound* upper_bound) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(upper_bound_); } @@ -12030,37 +11910,37 @@ inline void Expression_WindowFunction::unsafe_arena_set_allocated_upper_bound( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.upper_bound) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.upper_bound) } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_upper_bound() { +inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_upper_bound() { - ::io::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; + ::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; upper_bound_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_upper_bound() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.upper_bound) +inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_upper_bound() { + // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.upper_bound) - ::io::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; + ::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; upper_bound_ = nullptr; return temp; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_upper_bound() { +inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_upper_bound() { if (upper_bound_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(GetArena()); upper_bound_ = p; } return upper_bound_; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_upper_bound() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.upper_bound) +inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_upper_bound() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.upper_bound) return _internal_mutable_upper_bound(); } -inline void Expression_WindowFunction::set_allocated_upper_bound(::io::substrait::Expression_WindowFunction_Bound* upper_bound) { +inline void Expression_WindowFunction::set_allocated_upper_bound(::substrait::Expression_WindowFunction_Bound* upper_bound) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete upper_bound_; @@ -12077,10 +11957,10 @@ inline void Expression_WindowFunction::set_allocated_upper_bound(::io::substrait } upper_bound_ = upper_bound; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.upper_bound) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.upper_bound) } -// .io.substrait.Expression.WindowFunction.Bound lower_bound = 5; +// .substrait.Expression.WindowFunction.Bound lower_bound = 5; inline bool Expression_WindowFunction::_internal_has_lower_bound() const { return this != internal_default_instance() && lower_bound_ != nullptr; } @@ -12093,17 +11973,17 @@ inline void Expression_WindowFunction::clear_lower_bound() { } lower_bound_ = nullptr; } -inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_lower_bound() const { - const ::io::substrait::Expression_WindowFunction_Bound* p = lower_bound_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_WindowFunction_Bound_default_instance_); +inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_lower_bound() const { + const ::substrait::Expression_WindowFunction_Bound* p = lower_bound_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_WindowFunction_Bound_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::lower_bound() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.lower_bound) +inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::lower_bound() const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.lower_bound) return _internal_lower_bound(); } inline void Expression_WindowFunction::unsafe_arena_set_allocated_lower_bound( - ::io::substrait::Expression_WindowFunction_Bound* lower_bound) { + ::substrait::Expression_WindowFunction_Bound* lower_bound) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lower_bound_); } @@ -12113,37 +11993,37 @@ inline void Expression_WindowFunction::unsafe_arena_set_allocated_lower_bound( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.lower_bound) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.lower_bound) } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_lower_bound() { +inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_lower_bound() { - ::io::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; + ::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; lower_bound_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_lower_bound() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.lower_bound) +inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_lower_bound() { + // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.lower_bound) - ::io::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; + ::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; lower_bound_ = nullptr; return temp; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_lower_bound() { +inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_lower_bound() { if (lower_bound_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_WindowFunction_Bound>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(GetArena()); lower_bound_ = p; } return lower_bound_; } -inline ::io::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_lower_bound() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.lower_bound) +inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_lower_bound() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.lower_bound) return _internal_mutable_lower_bound(); } -inline void Expression_WindowFunction::set_allocated_lower_bound(::io::substrait::Expression_WindowFunction_Bound* lower_bound) { +inline void Expression_WindowFunction::set_allocated_lower_bound(::substrait::Expression_WindowFunction_Bound* lower_bound) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete lower_bound_; @@ -12160,47 +12040,47 @@ inline void Expression_WindowFunction::set_allocated_lower_bound(::io::substrait } lower_bound_ = lower_bound; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.lower_bound) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.lower_bound) } -// .io.substrait.AggregationPhase phase = 6; +// .substrait.AggregationPhase phase = 6; inline void Expression_WindowFunction::clear_phase() { phase_ = 0; } -inline ::io::substrait::AggregationPhase Expression_WindowFunction::_internal_phase() const { - return static_cast< ::io::substrait::AggregationPhase >(phase_); +inline ::substrait::AggregationPhase Expression_WindowFunction::_internal_phase() const { + return static_cast< ::substrait::AggregationPhase >(phase_); } -inline ::io::substrait::AggregationPhase Expression_WindowFunction::phase() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.phase) +inline ::substrait::AggregationPhase Expression_WindowFunction::phase() const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.phase) return _internal_phase(); } -inline void Expression_WindowFunction::_internal_set_phase(::io::substrait::AggregationPhase value) { +inline void Expression_WindowFunction::_internal_set_phase(::substrait::AggregationPhase value) { phase_ = value; } -inline void Expression_WindowFunction::set_phase(::io::substrait::AggregationPhase value) { +inline void Expression_WindowFunction::set_phase(::substrait::AggregationPhase value) { _internal_set_phase(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.WindowFunction.phase) + // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.phase) } -// .io.substrait.Type output_type = 7; +// .substrait.Type output_type = 7; inline bool Expression_WindowFunction::_internal_has_output_type() const { return this != internal_default_instance() && output_type_ != nullptr; } inline bool Expression_WindowFunction::has_output_type() const { return _internal_has_output_type(); } -inline const ::io::substrait::Type& Expression_WindowFunction::_internal_output_type() const { - const ::io::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline const ::substrait::Type& Expression_WindowFunction::_internal_output_type() const { + const ::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Type_default_instance_); } -inline const ::io::substrait::Type& Expression_WindowFunction::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.output_type) +inline const ::substrait::Type& Expression_WindowFunction::output_type() const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.output_type) return _internal_output_type(); } inline void Expression_WindowFunction::unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type) { + ::substrait::Type* output_type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } @@ -12210,37 +12090,37 @@ inline void Expression_WindowFunction::unsafe_arena_set_allocated_output_type( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.WindowFunction.output_type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.output_type) } -inline ::io::substrait::Type* Expression_WindowFunction::release_output_type() { +inline ::substrait::Type* Expression_WindowFunction::release_output_type() { - ::io::substrait::Type* temp = output_type_; + ::substrait::Type* temp = output_type_; output_type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type* Expression_WindowFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.WindowFunction.output_type) +inline ::substrait::Type* Expression_WindowFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.output_type) - ::io::substrait::Type* temp = output_type_; + ::substrait::Type* temp = output_type_; output_type_ = nullptr; return temp; } -inline ::io::substrait::Type* Expression_WindowFunction::_internal_mutable_output_type() { +inline ::substrait::Type* Expression_WindowFunction::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); output_type_ = p; } return output_type_; } -inline ::io::substrait::Type* Expression_WindowFunction::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.output_type) +inline ::substrait::Type* Expression_WindowFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.output_type) return _internal_mutable_output_type(); } -inline void Expression_WindowFunction::set_allocated_output_type(::io::substrait::Type* output_type) { +inline void Expression_WindowFunction::set_allocated_output_type(::substrait::Type* output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); @@ -12257,10 +12137,10 @@ inline void Expression_WindowFunction::set_allocated_output_type(::io::substrait } output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.WindowFunction.output_type) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.output_type) } -// repeated .io.substrait.Expression args = 8; +// repeated .substrait.Expression args = 8; inline int Expression_WindowFunction::_internal_args_size() const { return args_.size(); } @@ -12270,32 +12150,32 @@ inline int Expression_WindowFunction::args_size() const { inline void Expression_WindowFunction::clear_args() { args_.Clear(); } -inline ::io::substrait::Expression* Expression_WindowFunction::mutable_args(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.WindowFunction.args) +inline ::substrait::Expression* Expression_WindowFunction::mutable_args(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.args) return args_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* Expression_WindowFunction::mutable_args() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.WindowFunction.args) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.WindowFunction.args) return &args_; } -inline const ::io::substrait::Expression& Expression_WindowFunction::_internal_args(int index) const { +inline const ::substrait::Expression& Expression_WindowFunction::_internal_args(int index) const { return args_.Get(index); } -inline const ::io::substrait::Expression& Expression_WindowFunction::args(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.WindowFunction.args) +inline const ::substrait::Expression& Expression_WindowFunction::args(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.args) return _internal_args(index); } -inline ::io::substrait::Expression* Expression_WindowFunction::_internal_add_args() { +inline ::substrait::Expression* Expression_WindowFunction::_internal_add_args() { return args_.Add(); } -inline ::io::substrait::Expression* Expression_WindowFunction::add_args() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.WindowFunction.args) +inline ::substrait::Expression* Expression_WindowFunction::add_args() { + // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.args) return _internal_add_args(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_WindowFunction::args() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.WindowFunction.args) + // @@protoc_insertion_point(field_list:substrait.Expression.WindowFunction.args) return args_; } @@ -12303,7 +12183,7 @@ Expression_WindowFunction::args() const { // Expression_IfThen_IfClause -// .io.substrait.Expression if = 1; +// .substrait.Expression if = 1; inline bool Expression_IfThen_IfClause::_internal_has_if_() const { return this != internal_default_instance() && if__ != nullptr; } @@ -12316,17 +12196,17 @@ inline void Expression_IfThen_IfClause::clear_if_() { } if__ = nullptr; } -inline const ::io::substrait::Expression& Expression_IfThen_IfClause::_internal_if_() const { - const ::io::substrait::Expression* p = if__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& Expression_IfThen_IfClause::_internal_if_() const { + const ::substrait::Expression* p = if__; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& Expression_IfThen_IfClause::if_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.IfClause.if) +inline const ::substrait::Expression& Expression_IfThen_IfClause::if_() const { + // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.IfClause.if) return _internal_if_(); } inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_if_( - ::io::substrait::Expression* if_) { + ::substrait::Expression* if_) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); } @@ -12336,37 +12216,37 @@ inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_if_( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.IfClause.if) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.IfThen.IfClause.if) } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::release_if_() { +inline ::substrait::Expression* Expression_IfThen_IfClause::release_if_() { - ::io::substrait::Expression* temp = if__; + ::substrait::Expression* temp = if__; if__ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_if_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.IfClause.if) +inline ::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_if_() { + // @@protoc_insertion_point(field_release:substrait.Expression.IfThen.IfClause.if) - ::io::substrait::Expression* temp = if__; + ::substrait::Expression* temp = if__; if__ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_if_() { +inline ::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_if_() { if (if__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); if__ = p; } return if__; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::mutable_if_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.IfClause.if) +inline ::substrait::Expression* Expression_IfThen_IfClause::mutable_if_() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.IfClause.if) return _internal_mutable_if_(); } -inline void Expression_IfThen_IfClause::set_allocated_if_(::io::substrait::Expression* if_) { +inline void Expression_IfThen_IfClause::set_allocated_if_(::substrait::Expression* if_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete if__; @@ -12383,10 +12263,10 @@ inline void Expression_IfThen_IfClause::set_allocated_if_(::io::substrait::Expre } if__ = if_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.IfClause.if) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.IfThen.IfClause.if) } -// .io.substrait.Expression then = 2; +// .substrait.Expression then = 2; inline bool Expression_IfThen_IfClause::_internal_has_then() const { return this != internal_default_instance() && then_ != nullptr; } @@ -12399,17 +12279,17 @@ inline void Expression_IfThen_IfClause::clear_then() { } then_ = nullptr; } -inline const ::io::substrait::Expression& Expression_IfThen_IfClause::_internal_then() const { - const ::io::substrait::Expression* p = then_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& Expression_IfThen_IfClause::_internal_then() const { + const ::substrait::Expression* p = then_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& Expression_IfThen_IfClause::then() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.IfClause.then) +inline const ::substrait::Expression& Expression_IfThen_IfClause::then() const { + // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.IfClause.then) return _internal_then(); } inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_then( - ::io::substrait::Expression* then) { + ::substrait::Expression* then) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); } @@ -12419,37 +12299,37 @@ inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_then( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.IfClause.then) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.IfThen.IfClause.then) } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::release_then() { +inline ::substrait::Expression* Expression_IfThen_IfClause::release_then() { - ::io::substrait::Expression* temp = then_; + ::substrait::Expression* temp = then_; then_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_then() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.IfClause.then) +inline ::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_then() { + // @@protoc_insertion_point(field_release:substrait.Expression.IfThen.IfClause.then) - ::io::substrait::Expression* temp = then_; + ::substrait::Expression* temp = then_; then_ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_then() { +inline ::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_then() { if (then_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); then_ = p; } return then_; } -inline ::io::substrait::Expression* Expression_IfThen_IfClause::mutable_then() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.IfClause.then) +inline ::substrait::Expression* Expression_IfThen_IfClause::mutable_then() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.IfClause.then) return _internal_mutable_then(); } -inline void Expression_IfThen_IfClause::set_allocated_then(::io::substrait::Expression* then) { +inline void Expression_IfThen_IfClause::set_allocated_then(::substrait::Expression* then) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete then_; @@ -12466,14 +12346,14 @@ inline void Expression_IfThen_IfClause::set_allocated_then(::io::substrait::Expr } then_ = then; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.IfClause.then) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.IfThen.IfClause.then) } // ------------------------------------------------------------------- // Expression_IfThen -// repeated .io.substrait.Expression.IfThen.IfClause ifs = 1; +// repeated .substrait.Expression.IfThen.IfClause ifs = 1; inline int Expression_IfThen::_internal_ifs_size() const { return ifs_.size(); } @@ -12483,36 +12363,36 @@ inline int Expression_IfThen::ifs_size() const { inline void Expression_IfThen::clear_ifs() { ifs_.Clear(); } -inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::mutable_ifs(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.ifs) +inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::mutable_ifs(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.ifs) return ifs_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >* Expression_IfThen::mutable_ifs() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.IfThen.ifs) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.IfThen.ifs) return &ifs_; } -inline const ::io::substrait::Expression_IfThen_IfClause& Expression_IfThen::_internal_ifs(int index) const { +inline const ::substrait::Expression_IfThen_IfClause& Expression_IfThen::_internal_ifs(int index) const { return ifs_.Get(index); } -inline const ::io::substrait::Expression_IfThen_IfClause& Expression_IfThen::ifs(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.ifs) +inline const ::substrait::Expression_IfThen_IfClause& Expression_IfThen::ifs(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.ifs) return _internal_ifs(index); } -inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::_internal_add_ifs() { +inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::_internal_add_ifs() { return ifs_.Add(); } -inline ::io::substrait::Expression_IfThen_IfClause* Expression_IfThen::add_ifs() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.IfThen.ifs) +inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::add_ifs() { + // @@protoc_insertion_point(field_add:substrait.Expression.IfThen.ifs) return _internal_add_ifs(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_IfThen_IfClause >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >& Expression_IfThen::ifs() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.IfThen.ifs) + // @@protoc_insertion_point(field_list:substrait.Expression.IfThen.ifs) return ifs_; } -// .io.substrait.Expression else = 2; +// .substrait.Expression else = 2; inline bool Expression_IfThen::_internal_has_else_() const { return this != internal_default_instance() && else__ != nullptr; } @@ -12525,17 +12405,17 @@ inline void Expression_IfThen::clear_else_() { } else__ = nullptr; } -inline const ::io::substrait::Expression& Expression_IfThen::_internal_else_() const { - const ::io::substrait::Expression* p = else__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& Expression_IfThen::_internal_else_() const { + const ::substrait::Expression* p = else__; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& Expression_IfThen::else_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.IfThen.else) +inline const ::substrait::Expression& Expression_IfThen::else_() const { + // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.else) return _internal_else_(); } inline void Expression_IfThen::unsafe_arena_set_allocated_else_( - ::io::substrait::Expression* else_) { + ::substrait::Expression* else_) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); } @@ -12545,37 +12425,37 @@ inline void Expression_IfThen::unsafe_arena_set_allocated_else_( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.IfThen.else) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.IfThen.else) } -inline ::io::substrait::Expression* Expression_IfThen::release_else_() { +inline ::substrait::Expression* Expression_IfThen::release_else_() { - ::io::substrait::Expression* temp = else__; + ::substrait::Expression* temp = else__; else__ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_IfThen::unsafe_arena_release_else_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.IfThen.else) +inline ::substrait::Expression* Expression_IfThen::unsafe_arena_release_else_() { + // @@protoc_insertion_point(field_release:substrait.Expression.IfThen.else) - ::io::substrait::Expression* temp = else__; + ::substrait::Expression* temp = else__; else__ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_IfThen::_internal_mutable_else_() { +inline ::substrait::Expression* Expression_IfThen::_internal_mutable_else_() { if (else__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); else__ = p; } return else__; } -inline ::io::substrait::Expression* Expression_IfThen::mutable_else_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.IfThen.else) +inline ::substrait::Expression* Expression_IfThen::mutable_else_() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.else) return _internal_mutable_else_(); } -inline void Expression_IfThen::set_allocated_else_(::io::substrait::Expression* else_) { +inline void Expression_IfThen::set_allocated_else_(::substrait::Expression* else_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete else__; @@ -12592,31 +12472,31 @@ inline void Expression_IfThen::set_allocated_else_(::io::substrait::Expression* } else__ = else_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.IfThen.else) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.IfThen.else) } // ------------------------------------------------------------------- // Expression_Cast -// .io.substrait.Type type = 1; +// .substrait.Type type = 1; inline bool Expression_Cast::_internal_has_type() const { return this != internal_default_instance() && type_ != nullptr; } inline bool Expression_Cast::has_type() const { return _internal_has_type(); } -inline const ::io::substrait::Type& Expression_Cast::_internal_type() const { - const ::io::substrait::Type* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline const ::substrait::Type& Expression_Cast::_internal_type() const { + const ::substrait::Type* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Type_default_instance_); } -inline const ::io::substrait::Type& Expression_Cast::type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Cast.type) +inline const ::substrait::Type& Expression_Cast::type() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Cast.type) return _internal_type(); } inline void Expression_Cast::unsafe_arena_set_allocated_type( - ::io::substrait::Type* type) { + ::substrait::Type* type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } @@ -12626,37 +12506,37 @@ inline void Expression_Cast::unsafe_arena_set_allocated_type( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Cast.type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Cast.type) } -inline ::io::substrait::Type* Expression_Cast::release_type() { +inline ::substrait::Type* Expression_Cast::release_type() { - ::io::substrait::Type* temp = type_; + ::substrait::Type* temp = type_; type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type* Expression_Cast::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Cast.type) +inline ::substrait::Type* Expression_Cast::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:substrait.Expression.Cast.type) - ::io::substrait::Type* temp = type_; + ::substrait::Type* temp = type_; type_ = nullptr; return temp; } -inline ::io::substrait::Type* Expression_Cast::_internal_mutable_type() { +inline ::substrait::Type* Expression_Cast::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); type_ = p; } return type_; } -inline ::io::substrait::Type* Expression_Cast::mutable_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Cast.type) +inline ::substrait::Type* Expression_Cast::mutable_type() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Cast.type) return _internal_mutable_type(); } -inline void Expression_Cast::set_allocated_type(::io::substrait::Type* type) { +inline void Expression_Cast::set_allocated_type(::substrait::Type* type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); @@ -12673,10 +12553,10 @@ inline void Expression_Cast::set_allocated_type(::io::substrait::Type* type) { } type_ = type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Cast.type) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Cast.type) } -// .io.substrait.Expression input = 2; +// .substrait.Expression input = 2; inline bool Expression_Cast::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } @@ -12689,17 +12569,17 @@ inline void Expression_Cast::clear_input() { } input_ = nullptr; } -inline const ::io::substrait::Expression& Expression_Cast::_internal_input() const { - const ::io::substrait::Expression* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& Expression_Cast::_internal_input() const { + const ::substrait::Expression* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& Expression_Cast::input() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.Cast.input) +inline const ::substrait::Expression& Expression_Cast::input() const { + // @@protoc_insertion_point(field_get:substrait.Expression.Cast.input) return _internal_input(); } inline void Expression_Cast::unsafe_arena_set_allocated_input( - ::io::substrait::Expression* input) { + ::substrait::Expression* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } @@ -12709,37 +12589,37 @@ inline void Expression_Cast::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.Cast.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Cast.input) } -inline ::io::substrait::Expression* Expression_Cast::release_input() { +inline ::substrait::Expression* Expression_Cast::release_input() { - ::io::substrait::Expression* temp = input_; + ::substrait::Expression* temp = input_; input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_Cast::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.Cast.input) +inline ::substrait::Expression* Expression_Cast::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:substrait.Expression.Cast.input) - ::io::substrait::Expression* temp = input_; + ::substrait::Expression* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_Cast::_internal_mutable_input() { +inline ::substrait::Expression* Expression_Cast::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); input_ = p; } return input_; } -inline ::io::substrait::Expression* Expression_Cast::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.Cast.input) +inline ::substrait::Expression* Expression_Cast::mutable_input() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.Cast.input) return _internal_mutable_input(); } -inline void Expression_Cast::set_allocated_input(::io::substrait::Expression* input) { +inline void Expression_Cast::set_allocated_input(::substrait::Expression* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -12756,14 +12636,14 @@ inline void Expression_Cast::set_allocated_input(::io::substrait::Expression* in } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.Cast.input) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Cast.input) } // ------------------------------------------------------------------- // Expression_SwitchExpression_IfValue -// .io.substrait.Expression.Literal if = 1; +// .substrait.Expression.Literal if = 1; inline bool Expression_SwitchExpression_IfValue::_internal_has_if_() const { return this != internal_default_instance() && if__ != nullptr; } @@ -12776,17 +12656,17 @@ inline void Expression_SwitchExpression_IfValue::clear_if_() { } if__ = nullptr; } -inline const ::io::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::_internal_if_() const { - const ::io::substrait::Expression_Literal* p = if__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_Literal_default_instance_); +inline const ::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::_internal_if_() const { + const ::substrait::Expression_Literal* p = if__; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_Literal_default_instance_); } -inline const ::io::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::if_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.IfValue.if) +inline const ::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::if_() const { + // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.IfValue.if) return _internal_if_(); } inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_if_( - ::io::substrait::Expression_Literal* if_) { + ::substrait::Expression_Literal* if_) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); } @@ -12796,37 +12676,37 @@ inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_if_( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.if) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SwitchExpression.IfValue.if) } -inline ::io::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::release_if_() { +inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::release_if_() { - ::io::substrait::Expression_Literal* temp = if__; + ::substrait::Expression_Literal* temp = if__; if__ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::unsafe_arena_release_if_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.IfValue.if) +inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::unsafe_arena_release_if_() { + // @@protoc_insertion_point(field_release:substrait.Expression.SwitchExpression.IfValue.if) - ::io::substrait::Expression_Literal* temp = if__; + ::substrait::Expression_Literal* temp = if__; if__ = nullptr; return temp; } -inline ::io::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::_internal_mutable_if_() { +inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::_internal_mutable_if_() { if (if__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArena()); if__ = p; } return if__; } -inline ::io::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::mutable_if_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.IfValue.if) +inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::mutable_if_() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.IfValue.if) return _internal_mutable_if_(); } -inline void Expression_SwitchExpression_IfValue::set_allocated_if_(::io::substrait::Expression_Literal* if_) { +inline void Expression_SwitchExpression_IfValue::set_allocated_if_(::substrait::Expression_Literal* if_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete if__; @@ -12843,10 +12723,10 @@ inline void Expression_SwitchExpression_IfValue::set_allocated_if_(::io::substra } if__ = if_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.if) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SwitchExpression.IfValue.if) } -// .io.substrait.Expression then = 2; +// .substrait.Expression then = 2; inline bool Expression_SwitchExpression_IfValue::_internal_has_then() const { return this != internal_default_instance() && then_ != nullptr; } @@ -12859,17 +12739,17 @@ inline void Expression_SwitchExpression_IfValue::clear_then() { } then_ = nullptr; } -inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::_internal_then() const { - const ::io::substrait::Expression* p = then_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& Expression_SwitchExpression_IfValue::_internal_then() const { + const ::substrait::Expression* p = then_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& Expression_SwitchExpression_IfValue::then() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.IfValue.then) +inline const ::substrait::Expression& Expression_SwitchExpression_IfValue::then() const { + // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.IfValue.then) return _internal_then(); } inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_then( - ::io::substrait::Expression* then) { + ::substrait::Expression* then) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); } @@ -12879,37 +12759,37 @@ inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_then } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.then) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SwitchExpression.IfValue.then) } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::release_then() { +inline ::substrait::Expression* Expression_SwitchExpression_IfValue::release_then() { - ::io::substrait::Expression* temp = then_; + ::substrait::Expression* temp = then_; then_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_arena_release_then() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.IfValue.then) +inline ::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_arena_release_then() { + // @@protoc_insertion_point(field_release:substrait.Expression.SwitchExpression.IfValue.then) - ::io::substrait::Expression* temp = then_; + ::substrait::Expression* temp = then_; then_ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::_internal_mutable_then() { +inline ::substrait::Expression* Expression_SwitchExpression_IfValue::_internal_mutable_then() { if (then_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); then_ = p; } return then_; } -inline ::io::substrait::Expression* Expression_SwitchExpression_IfValue::mutable_then() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.IfValue.then) +inline ::substrait::Expression* Expression_SwitchExpression_IfValue::mutable_then() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.IfValue.then) return _internal_mutable_then(); } -inline void Expression_SwitchExpression_IfValue::set_allocated_then(::io::substrait::Expression* then) { +inline void Expression_SwitchExpression_IfValue::set_allocated_then(::substrait::Expression* then) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete then_; @@ -12926,14 +12806,14 @@ inline void Expression_SwitchExpression_IfValue::set_allocated_then(::io::substr } then_ = then; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.IfValue.then) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SwitchExpression.IfValue.then) } // ------------------------------------------------------------------- // Expression_SwitchExpression -// repeated .io.substrait.Expression.SwitchExpression.IfValue ifs = 1; +// repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; inline int Expression_SwitchExpression::_internal_ifs_size() const { return ifs_.size(); } @@ -12943,36 +12823,36 @@ inline int Expression_SwitchExpression::ifs_size() const { inline void Expression_SwitchExpression::clear_ifs() { ifs_.Clear(); } -inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::mutable_ifs(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.ifs) +inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::mutable_ifs(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.ifs) return ifs_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >* Expression_SwitchExpression::mutable_ifs() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.SwitchExpression.ifs) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.SwitchExpression.ifs) return &ifs_; } -inline const ::io::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::_internal_ifs(int index) const { +inline const ::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::_internal_ifs(int index) const { return ifs_.Get(index); } -inline const ::io::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::ifs(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.ifs) +inline const ::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::ifs(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.ifs) return _internal_ifs(index); } -inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::_internal_add_ifs() { +inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::_internal_add_ifs() { return ifs_.Add(); } -inline ::io::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::add_ifs() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.SwitchExpression.ifs) +inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::add_ifs() { + // @@protoc_insertion_point(field_add:substrait.Expression.SwitchExpression.ifs) return _internal_add_ifs(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_SwitchExpression_IfValue >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >& Expression_SwitchExpression::ifs() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.SwitchExpression.ifs) + // @@protoc_insertion_point(field_list:substrait.Expression.SwitchExpression.ifs) return ifs_; } -// .io.substrait.Expression else = 2; +// .substrait.Expression else = 2; inline bool Expression_SwitchExpression::_internal_has_else_() const { return this != internal_default_instance() && else__ != nullptr; } @@ -12985,17 +12865,17 @@ inline void Expression_SwitchExpression::clear_else_() { } else__ = nullptr; } -inline const ::io::substrait::Expression& Expression_SwitchExpression::_internal_else_() const { - const ::io::substrait::Expression* p = else__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& Expression_SwitchExpression::_internal_else_() const { + const ::substrait::Expression* p = else__; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& Expression_SwitchExpression::else_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SwitchExpression.else) +inline const ::substrait::Expression& Expression_SwitchExpression::else_() const { + // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.else) return _internal_else_(); } inline void Expression_SwitchExpression::unsafe_arena_set_allocated_else_( - ::io::substrait::Expression* else_) { + ::substrait::Expression* else_) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); } @@ -13005,37 +12885,37 @@ inline void Expression_SwitchExpression::unsafe_arena_set_allocated_else_( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SwitchExpression.else) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SwitchExpression.else) } -inline ::io::substrait::Expression* Expression_SwitchExpression::release_else_() { +inline ::substrait::Expression* Expression_SwitchExpression::release_else_() { - ::io::substrait::Expression* temp = else__; + ::substrait::Expression* temp = else__; else__ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_SwitchExpression::unsafe_arena_release_else_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.SwitchExpression.else) +inline ::substrait::Expression* Expression_SwitchExpression::unsafe_arena_release_else_() { + // @@protoc_insertion_point(field_release:substrait.Expression.SwitchExpression.else) - ::io::substrait::Expression* temp = else__; + ::substrait::Expression* temp = else__; else__ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_SwitchExpression::_internal_mutable_else_() { +inline ::substrait::Expression* Expression_SwitchExpression::_internal_mutable_else_() { if (else__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); else__ = p; } return else__; } -inline ::io::substrait::Expression* Expression_SwitchExpression::mutable_else_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SwitchExpression.else) +inline ::substrait::Expression* Expression_SwitchExpression::mutable_else_() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.else) return _internal_mutable_else_(); } -inline void Expression_SwitchExpression::set_allocated_else_(::io::substrait::Expression* else_) { +inline void Expression_SwitchExpression::set_allocated_else_(::substrait::Expression* else_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete else__; @@ -13052,14 +12932,14 @@ inline void Expression_SwitchExpression::set_allocated_else_(::io::substrait::Ex } else__ = else_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SwitchExpression.else) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SwitchExpression.else) } // ------------------------------------------------------------------- // Expression_SingularOrList -// .io.substrait.Expression value = 1; +// .substrait.Expression value = 1; inline bool Expression_SingularOrList::_internal_has_value() const { return this != internal_default_instance() && value_ != nullptr; } @@ -13072,17 +12952,17 @@ inline void Expression_SingularOrList::clear_value() { } value_ = nullptr; } -inline const ::io::substrait::Expression& Expression_SingularOrList::_internal_value() const { - const ::io::substrait::Expression* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& Expression_SingularOrList::_internal_value() const { + const ::substrait::Expression* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& Expression_SingularOrList::value() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SingularOrList.value) +inline const ::substrait::Expression& Expression_SingularOrList::value() const { + // @@protoc_insertion_point(field_get:substrait.Expression.SingularOrList.value) return _internal_value(); } inline void Expression_SingularOrList::unsafe_arena_set_allocated_value( - ::io::substrait::Expression* value) { + ::substrait::Expression* value) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } @@ -13092,37 +12972,37 @@ inline void Expression_SingularOrList::unsafe_arena_set_allocated_value( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.SingularOrList.value) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SingularOrList.value) } -inline ::io::substrait::Expression* Expression_SingularOrList::release_value() { +inline ::substrait::Expression* Expression_SingularOrList::release_value() { - ::io::substrait::Expression* temp = value_; + ::substrait::Expression* temp = value_; value_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* Expression_SingularOrList::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.SingularOrList.value) +inline ::substrait::Expression* Expression_SingularOrList::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:substrait.Expression.SingularOrList.value) - ::io::substrait::Expression* temp = value_; + ::substrait::Expression* temp = value_; value_ = nullptr; return temp; } -inline ::io::substrait::Expression* Expression_SingularOrList::_internal_mutable_value() { +inline ::substrait::Expression* Expression_SingularOrList::_internal_mutable_value() { if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); value_ = p; } return value_; } -inline ::io::substrait::Expression* Expression_SingularOrList::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SingularOrList.value) +inline ::substrait::Expression* Expression_SingularOrList::mutable_value() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.SingularOrList.value) return _internal_mutable_value(); } -inline void Expression_SingularOrList::set_allocated_value(::io::substrait::Expression* value) { +inline void Expression_SingularOrList::set_allocated_value(::substrait::Expression* value) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete value_; @@ -13139,10 +13019,10 @@ inline void Expression_SingularOrList::set_allocated_value(::io::substrait::Expr } value_ = value; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.SingularOrList.value) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SingularOrList.value) } -// repeated .io.substrait.Expression options = 2; +// repeated .substrait.Expression options = 2; inline int Expression_SingularOrList::_internal_options_size() const { return options_.size(); } @@ -13152,32 +13032,32 @@ inline int Expression_SingularOrList::options_size() const { inline void Expression_SingularOrList::clear_options() { options_.Clear(); } -inline ::io::substrait::Expression* Expression_SingularOrList::mutable_options(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.SingularOrList.options) +inline ::substrait::Expression* Expression_SingularOrList::mutable_options(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.SingularOrList.options) return options_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* Expression_SingularOrList::mutable_options() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.SingularOrList.options) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.SingularOrList.options) return &options_; } -inline const ::io::substrait::Expression& Expression_SingularOrList::_internal_options(int index) const { +inline const ::substrait::Expression& Expression_SingularOrList::_internal_options(int index) const { return options_.Get(index); } -inline const ::io::substrait::Expression& Expression_SingularOrList::options(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.SingularOrList.options) +inline const ::substrait::Expression& Expression_SingularOrList::options(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.SingularOrList.options) return _internal_options(index); } -inline ::io::substrait::Expression* Expression_SingularOrList::_internal_add_options() { +inline ::substrait::Expression* Expression_SingularOrList::_internal_add_options() { return options_.Add(); } -inline ::io::substrait::Expression* Expression_SingularOrList::add_options() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.SingularOrList.options) +inline ::substrait::Expression* Expression_SingularOrList::add_options() { + // @@protoc_insertion_point(field_add:substrait.Expression.SingularOrList.options) return _internal_add_options(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_SingularOrList::options() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.SingularOrList.options) + // @@protoc_insertion_point(field_list:substrait.Expression.SingularOrList.options) return options_; } @@ -13185,7 +13065,7 @@ Expression_SingularOrList::options() const { // Expression_MultiOrList_Record -// repeated .io.substrait.Expression fields = 1; +// repeated .substrait.Expression fields = 1; inline int Expression_MultiOrList_Record::_internal_fields_size() const { return fields_.size(); } @@ -13195,32 +13075,32 @@ inline int Expression_MultiOrList_Record::fields_size() const { inline void Expression_MultiOrList_Record::clear_fields() { fields_.Clear(); } -inline ::io::substrait::Expression* Expression_MultiOrList_Record::mutable_fields(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.Record.fields) +inline ::substrait::Expression* Expression_MultiOrList_Record::mutable_fields(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MultiOrList.Record.fields) return fields_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* Expression_MultiOrList_Record::mutable_fields() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.Record.fields) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MultiOrList.Record.fields) return &fields_; } -inline const ::io::substrait::Expression& Expression_MultiOrList_Record::_internal_fields(int index) const { +inline const ::substrait::Expression& Expression_MultiOrList_Record::_internal_fields(int index) const { return fields_.Get(index); } -inline const ::io::substrait::Expression& Expression_MultiOrList_Record::fields(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.Record.fields) +inline const ::substrait::Expression& Expression_MultiOrList_Record::fields(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.MultiOrList.Record.fields) return _internal_fields(index); } -inline ::io::substrait::Expression* Expression_MultiOrList_Record::_internal_add_fields() { +inline ::substrait::Expression* Expression_MultiOrList_Record::_internal_add_fields() { return fields_.Add(); } -inline ::io::substrait::Expression* Expression_MultiOrList_Record::add_fields() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.Record.fields) +inline ::substrait::Expression* Expression_MultiOrList_Record::add_fields() { + // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.Record.fields) return _internal_add_fields(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_MultiOrList_Record::fields() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.Record.fields) + // @@protoc_insertion_point(field_list:substrait.Expression.MultiOrList.Record.fields) return fields_; } @@ -13228,7 +13108,7 @@ Expression_MultiOrList_Record::fields() const { // Expression_MultiOrList -// repeated .io.substrait.Expression value = 1; +// repeated .substrait.Expression value = 1; inline int Expression_MultiOrList::_internal_value_size() const { return value_.size(); } @@ -13238,36 +13118,36 @@ inline int Expression_MultiOrList::value_size() const { inline void Expression_MultiOrList::clear_value() { value_.Clear(); } -inline ::io::substrait::Expression* Expression_MultiOrList::mutable_value(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.value) +inline ::substrait::Expression* Expression_MultiOrList::mutable_value(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MultiOrList.value) return value_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* Expression_MultiOrList::mutable_value() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.value) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MultiOrList.value) return &value_; } -inline const ::io::substrait::Expression& Expression_MultiOrList::_internal_value(int index) const { +inline const ::substrait::Expression& Expression_MultiOrList::_internal_value(int index) const { return value_.Get(index); } -inline const ::io::substrait::Expression& Expression_MultiOrList::value(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.value) +inline const ::substrait::Expression& Expression_MultiOrList::value(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.MultiOrList.value) return _internal_value(index); } -inline ::io::substrait::Expression* Expression_MultiOrList::_internal_add_value() { +inline ::substrait::Expression* Expression_MultiOrList::_internal_add_value() { return value_.Add(); } -inline ::io::substrait::Expression* Expression_MultiOrList::add_value() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.value) +inline ::substrait::Expression* Expression_MultiOrList::add_value() { + // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.value) return _internal_add_value(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_MultiOrList::value() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.value) + // @@protoc_insertion_point(field_list:substrait.Expression.MultiOrList.value) return value_; } -// repeated .io.substrait.Expression.MultiOrList.Record options = 2; +// repeated .substrait.Expression.MultiOrList.Record options = 2; inline int Expression_MultiOrList::_internal_options_size() const { return options_.size(); } @@ -13277,32 +13157,32 @@ inline int Expression_MultiOrList::options_size() const { inline void Expression_MultiOrList::clear_options() { options_.Clear(); } -inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::mutable_options(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MultiOrList.options) +inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::mutable_options(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MultiOrList.options) return options_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >* Expression_MultiOrList::mutable_options() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MultiOrList.options) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MultiOrList.options) return &options_; } -inline const ::io::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::_internal_options(int index) const { +inline const ::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::_internal_options(int index) const { return options_.Get(index); } -inline const ::io::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::options(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MultiOrList.options) +inline const ::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::options(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.MultiOrList.options) return _internal_options(index); } -inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::_internal_add_options() { +inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::_internal_add_options() { return options_.Add(); } -inline ::io::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::add_options() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.MultiOrList.options) +inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::add_options() { + // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.options) return _internal_add_options(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MultiOrList_Record >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >& Expression_MultiOrList::options() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.MultiOrList.options) + // @@protoc_insertion_point(field_list:substrait.Expression.MultiOrList.options) return options_; } @@ -13315,7 +13195,7 @@ inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_function() { function_.ClearToEmpty(); } inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) return _internal_function(); } template @@ -13323,10 +13203,10 @@ PROTOBUF_ALWAYS_INLINE inline void Expression_EmbeddedFunction_PythonPickleFunction::set_function(ArgT0&& arg0, ArgT... args) { function_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) } inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) return _internal_mutable_function(); } inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_function() const { @@ -13341,7 +13221,7 @@ inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_ return function_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::release_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) return function_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void Expression_EmbeddedFunction_PythonPickleFunction::set_allocated_function(std::string* function) { @@ -13352,7 +13232,7 @@ inline void Expression_EmbeddedFunction_PythonPickleFunction::set_allocated_func } function_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), function, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) } // repeated string prerequisite = 2; @@ -13366,66 +13246,66 @@ inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_prerequisite prerequisite_.Clear(); } inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_add_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) return _internal_add_prerequisite(); } inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite(int index) const { return prerequisite_.Get(index); } inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::prerequisite(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) return _internal_prerequisite(index); } inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) return prerequisite_.Mutable(index); } inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) prerequisite_.Mutable(index)->assign(value); } inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) prerequisite_.Mutable(index)->assign(std::move(value)); } inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); prerequisite_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_set_char:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value, size_t size) { prerequisite_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_set_pointer:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_add_prerequisite() { return prerequisite_.Add(); } inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const std::string& value) { prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(std::string&& value) { prerequisite_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value) { GOOGLE_DCHECK(value != nullptr); prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_add_char:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value, size_t size) { prerequisite_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_add_pointer:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& Expression_EmbeddedFunction_PythonPickleFunction::prerequisite() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) return prerequisite_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) return &prerequisite_; } @@ -13438,7 +13318,7 @@ inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_script() { script_.ClearToEmpty(); } inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::script() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) return _internal_script(); } template @@ -13446,10 +13326,10 @@ PROTOBUF_ALWAYS_INLINE inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_script(ArgT0&& arg0, ArgT... args) { script_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) } inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_script() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) return _internal_mutable_script(); } inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_script() const { @@ -13464,7 +13344,7 @@ inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_m return script_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::release_script() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) return script_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_allocated_script(std::string* script) { @@ -13475,7 +13355,7 @@ inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_allocated_scrip } script_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), script, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) } // repeated string prerequisite = 2; @@ -13489,66 +13369,66 @@ inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_prerequisite( prerequisite_.Clear(); } inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_add_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) return _internal_add_prerequisite(); } inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite(int index) const { return prerequisite_.Get(index); } inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) return _internal_prerequisite(index); } inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) return prerequisite_.Mutable(index); } inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) prerequisite_.Mutable(index)->assign(value); } inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) prerequisite_.Mutable(index)->assign(std::move(value)); } inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); prerequisite_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_set_char:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) } inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value, size_t size) { prerequisite_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_set_pointer:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) } inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_add_prerequisite() { return prerequisite_.Add(); } inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const std::string& value) { prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) } inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(std::string&& value) { prerequisite_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) } inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value) { GOOGLE_DCHECK(value != nullptr); prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_add_char:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) } inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value, size_t size) { prerequisite_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_add_pointer:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) return prerequisite_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) return &prerequisite_; } @@ -13556,7 +13436,7 @@ Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite() { // Expression_EmbeddedFunction -// repeated .io.substrait.Expression arguments = 1; +// repeated .substrait.Expression arguments = 1; inline int Expression_EmbeddedFunction::_internal_arguments_size() const { return arguments_.size(); } @@ -13566,53 +13446,53 @@ inline int Expression_EmbeddedFunction::arguments_size() const { inline void Expression_EmbeddedFunction::clear_arguments() { arguments_.Clear(); } -inline ::io::substrait::Expression* Expression_EmbeddedFunction::mutable_arguments(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.arguments) +inline ::substrait::Expression* Expression_EmbeddedFunction::mutable_arguments(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.arguments) return arguments_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* Expression_EmbeddedFunction::mutable_arguments() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.EmbeddedFunction.arguments) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.EmbeddedFunction.arguments) return &arguments_; } -inline const ::io::substrait::Expression& Expression_EmbeddedFunction::_internal_arguments(int index) const { +inline const ::substrait::Expression& Expression_EmbeddedFunction::_internal_arguments(int index) const { return arguments_.Get(index); } -inline const ::io::substrait::Expression& Expression_EmbeddedFunction::arguments(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.arguments) +inline const ::substrait::Expression& Expression_EmbeddedFunction::arguments(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.arguments) return _internal_arguments(index); } -inline ::io::substrait::Expression* Expression_EmbeddedFunction::_internal_add_arguments() { +inline ::substrait::Expression* Expression_EmbeddedFunction::_internal_add_arguments() { return arguments_.Add(); } -inline ::io::substrait::Expression* Expression_EmbeddedFunction::add_arguments() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.EmbeddedFunction.arguments) +inline ::substrait::Expression* Expression_EmbeddedFunction::add_arguments() { + // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.arguments) return _internal_add_arguments(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_EmbeddedFunction::arguments() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.EmbeddedFunction.arguments) + // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.arguments) return arguments_; } -// .io.substrait.Type output_type = 2; +// .substrait.Type output_type = 2; inline bool Expression_EmbeddedFunction::_internal_has_output_type() const { return this != internal_default_instance() && output_type_ != nullptr; } inline bool Expression_EmbeddedFunction::has_output_type() const { return _internal_has_output_type(); } -inline const ::io::substrait::Type& Expression_EmbeddedFunction::_internal_output_type() const { - const ::io::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline const ::substrait::Type& Expression_EmbeddedFunction::_internal_output_type() const { + const ::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Type_default_instance_); } -inline const ::io::substrait::Type& Expression_EmbeddedFunction::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.output_type) +inline const ::substrait::Type& Expression_EmbeddedFunction::output_type() const { + // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.output_type) return _internal_output_type(); } inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type) { + ::substrait::Type* output_type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } @@ -13622,37 +13502,37 @@ inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_output_type( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.output_type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.EmbeddedFunction.output_type) } -inline ::io::substrait::Type* Expression_EmbeddedFunction::release_output_type() { +inline ::substrait::Type* Expression_EmbeddedFunction::release_output_type() { - ::io::substrait::Type* temp = output_type_; + ::substrait::Type* temp = output_type_; output_type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type* Expression_EmbeddedFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.output_type) +inline ::substrait::Type* Expression_EmbeddedFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.output_type) - ::io::substrait::Type* temp = output_type_; + ::substrait::Type* temp = output_type_; output_type_ = nullptr; return temp; } -inline ::io::substrait::Type* Expression_EmbeddedFunction::_internal_mutable_output_type() { +inline ::substrait::Type* Expression_EmbeddedFunction::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); output_type_ = p; } return output_type_; } -inline ::io::substrait::Type* Expression_EmbeddedFunction::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.output_type) +inline ::substrait::Type* Expression_EmbeddedFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.output_type) return _internal_mutable_output_type(); } -inline void Expression_EmbeddedFunction::set_allocated_output_type(::io::substrait::Type* output_type) { +inline void Expression_EmbeddedFunction::set_allocated_output_type(::substrait::Type* output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); @@ -13669,10 +13549,10 @@ inline void Expression_EmbeddedFunction::set_allocated_output_type(::io::substra } output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.EmbeddedFunction.output_type) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.output_type) } -// .io.substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; +// .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; inline bool Expression_EmbeddedFunction::_internal_has_python_pickle_function() const { return kind_case() == kPythonPickleFunction; } @@ -13690,11 +13570,11 @@ inline void Expression_EmbeddedFunction::clear_python_pickle_function() { clear_has_kind(); } } -inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::release_python_pickle_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.python_pickle_function) +inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::release_python_pickle_function() { + // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.python_pickle_function) if (_internal_has_python_pickle_function()) { clear_has_kind(); - ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; + ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -13704,48 +13584,48 @@ inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expres return nullptr; } } -inline const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::_internal_python_pickle_function() const { +inline const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::_internal_python_pickle_function() const { return _internal_has_python_pickle_function() ? *kind_.python_pickle_function_ - : reinterpret_cast< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction&>(::io::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_); + : reinterpret_cast< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction&>(::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_); } -inline const ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::python_pickle_function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.python_pickle_function) +inline const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::python_pickle_function() const { + // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.python_pickle_function) return _internal_python_pickle_function(); } -inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::unsafe_arena_release_python_pickle_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.EmbeddedFunction.python_pickle_function) +inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::unsafe_arena_release_python_pickle_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.EmbeddedFunction.python_pickle_function) if (_internal_has_python_pickle_function()) { clear_has_kind(); - ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; + ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; kind_.python_pickle_function_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_python_pickle_function(::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { +inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { clear_kind(); if (python_pickle_function) { set_has_python_pickle_function(); kind_.python_pickle_function_ = python_pickle_function; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.python_pickle_function) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.EmbeddedFunction.python_pickle_function) } -inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::_internal_mutable_python_pickle_function() { +inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::_internal_mutable_python_pickle_function() { if (!_internal_has_python_pickle_function()) { clear_kind(); set_has_python_pickle_function(); - kind_.python_pickle_function_ = CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(GetArena()); + kind_.python_pickle_function_ = CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(GetArena()); } return kind_.python_pickle_function_; } -inline ::io::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::mutable_python_pickle_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.python_pickle_function) +inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::mutable_python_pickle_function() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.python_pickle_function) return _internal_mutable_python_pickle_function(); } -// .io.substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; +// .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; inline bool Expression_EmbeddedFunction::_internal_has_web_assembly_function() const { return kind_case() == kWebAssemblyFunction; } @@ -13763,11 +13643,11 @@ inline void Expression_EmbeddedFunction::clear_web_assembly_function() { clear_has_kind(); } } -inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::release_web_assembly_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.EmbeddedFunction.web_assembly_function) +inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::release_web_assembly_function() { + // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.web_assembly_function) if (_internal_has_web_assembly_function()) { clear_has_kind(); - ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; + ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -13777,44 +13657,44 @@ inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Express return nullptr; } } -inline const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::_internal_web_assembly_function() const { +inline const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::_internal_web_assembly_function() const { return _internal_has_web_assembly_function() ? *kind_.web_assembly_function_ - : reinterpret_cast< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction&>(::io::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_); + : reinterpret_cast< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction&>(::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_); } -inline const ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::web_assembly_function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.EmbeddedFunction.web_assembly_function) +inline const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::web_assembly_function() const { + // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.web_assembly_function) return _internal_web_assembly_function(); } -inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::unsafe_arena_release_web_assembly_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.EmbeddedFunction.web_assembly_function) +inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::unsafe_arena_release_web_assembly_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.EmbeddedFunction.web_assembly_function) if (_internal_has_web_assembly_function()) { clear_has_kind(); - ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; + ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; kind_.web_assembly_function_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_web_assembly_function(::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { +inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { clear_kind(); if (web_assembly_function) { set_has_web_assembly_function(); kind_.web_assembly_function_ = web_assembly_function; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.EmbeddedFunction.web_assembly_function) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.EmbeddedFunction.web_assembly_function) } -inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::_internal_mutable_web_assembly_function() { +inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::_internal_mutable_web_assembly_function() { if (!_internal_has_web_assembly_function()) { clear_kind(); set_has_web_assembly_function(); - kind_.web_assembly_function_ = CreateMaybeMessage< ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(GetArena()); + kind_.web_assembly_function_ = CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(GetArena()); } return kind_.web_assembly_function_; } -inline ::io::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::mutable_web_assembly_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.EmbeddedFunction.web_assembly_function) +inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::mutable_web_assembly_function() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.web_assembly_function) return _internal_mutable_web_assembly_function(); } @@ -13831,7 +13711,7 @@ inline Expression_EmbeddedFunction::KindCase Expression_EmbeddedFunction::kind_c // Expression_ReferenceSegment_MapKey -// .io.substrait.Expression.Literal map_key = 1; +// .substrait.Expression.Literal map_key = 1; inline bool Expression_ReferenceSegment_MapKey::_internal_has_map_key() const { return this != internal_default_instance() && map_key_ != nullptr; } @@ -13844,17 +13724,17 @@ inline void Expression_ReferenceSegment_MapKey::clear_map_key() { } map_key_ = nullptr; } -inline const ::io::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::_internal_map_key() const { - const ::io::substrait::Expression_Literal* p = map_key_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_Literal_default_instance_); +inline const ::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::_internal_map_key() const { + const ::substrait::Expression_Literal* p = map_key_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_Literal_default_instance_); } -inline const ::io::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::map_key() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.MapKey.map_key) +inline const ::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::map_key() const { + // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.MapKey.map_key) return _internal_map_key(); } inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_map_key( - ::io::substrait::Expression_Literal* map_key) { + ::substrait::Expression_Literal* map_key) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_key_); } @@ -13864,37 +13744,37 @@ inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_map_k } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.MapKey.map_key) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.MapKey.map_key) } -inline ::io::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::release_map_key() { +inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::release_map_key() { - ::io::substrait::Expression_Literal* temp = map_key_; + ::substrait::Expression_Literal* temp = map_key_; map_key_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::unsafe_arena_release_map_key() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.MapKey.map_key) +inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::unsafe_arena_release_map_key() { + // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.MapKey.map_key) - ::io::substrait::Expression_Literal* temp = map_key_; + ::substrait::Expression_Literal* temp = map_key_; map_key_ = nullptr; return temp; } -inline ::io::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::_internal_mutable_map_key() { +inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::_internal_mutable_map_key() { if (map_key_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_Literal>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArena()); map_key_ = p; } return map_key_; } -inline ::io::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::mutable_map_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.MapKey.map_key) +inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::mutable_map_key() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.MapKey.map_key) return _internal_mutable_map_key(); } -inline void Expression_ReferenceSegment_MapKey::set_allocated_map_key(::io::substrait::Expression_Literal* map_key) { +inline void Expression_ReferenceSegment_MapKey::set_allocated_map_key(::substrait::Expression_Literal* map_key) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete map_key_; @@ -13911,10 +13791,10 @@ inline void Expression_ReferenceSegment_MapKey::set_allocated_map_key(::io::subs } map_key_ = map_key; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.MapKey.map_key) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.MapKey.map_key) } -// .io.substrait.Expression.ReferenceSegment child = 2; +// .substrait.Expression.ReferenceSegment child = 2; inline bool Expression_ReferenceSegment_MapKey::_internal_has_child() const { return this != internal_default_instance() && child_ != nullptr; } @@ -13927,17 +13807,17 @@ inline void Expression_ReferenceSegment_MapKey::clear_child() { } child_ = nullptr; } -inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::_internal_child() const { - const ::io::substrait::Expression_ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_ReferenceSegment_default_instance_); +inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::_internal_child() const { + const ::substrait::Expression_ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_ReferenceSegment_default_instance_); } -inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::child() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.MapKey.child) +inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::child() const { + // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.MapKey.child) return _internal_child(); } inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_child( - ::io::substrait::Expression_ReferenceSegment* child) { + ::substrait::Expression_ReferenceSegment* child) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } @@ -13947,37 +13827,37 @@ inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_child } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.MapKey.child) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.MapKey.child) } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::release_child() { +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::release_child() { - ::io::substrait::Expression_ReferenceSegment* temp = child_; + ::substrait::Expression_ReferenceSegment* temp = child_; child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.MapKey.child) +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.MapKey.child) - ::io::substrait::Expression_ReferenceSegment* temp = child_; + ::substrait::Expression_ReferenceSegment* temp = child_; child_ = nullptr; return temp; } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::_internal_mutable_child() { +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArena()); child_ = p; } return child_; } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.MapKey.child) +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::mutable_child() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.MapKey.child) return _internal_mutable_child(); } -inline void Expression_ReferenceSegment_MapKey::set_allocated_child(::io::substrait::Expression_ReferenceSegment* child) { +inline void Expression_ReferenceSegment_MapKey::set_allocated_child(::substrait::Expression_ReferenceSegment* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete child_; @@ -13994,7 +13874,7 @@ inline void Expression_ReferenceSegment_MapKey::set_allocated_child(::io::substr } child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.MapKey.child) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.MapKey.child) } // ------------------------------------------------------------------- @@ -14009,7 +13889,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_StructField::_ return field_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_StructField::field() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.StructField.field) + // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.StructField.field) return _internal_field(); } inline void Expression_ReferenceSegment_StructField::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -14018,10 +13898,10 @@ inline void Expression_ReferenceSegment_StructField::_internal_set_field(::PROTO } inline void Expression_ReferenceSegment_StructField::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_field(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.ReferenceSegment.StructField.field) + // @@protoc_insertion_point(field_set:substrait.Expression.ReferenceSegment.StructField.field) } -// .io.substrait.Expression.ReferenceSegment child = 2; +// .substrait.Expression.ReferenceSegment child = 2; inline bool Expression_ReferenceSegment_StructField::_internal_has_child() const { return this != internal_default_instance() && child_ != nullptr; } @@ -14034,17 +13914,17 @@ inline void Expression_ReferenceSegment_StructField::clear_child() { } child_ = nullptr; } -inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::_internal_child() const { - const ::io::substrait::Expression_ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_ReferenceSegment_default_instance_); +inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::_internal_child() const { + const ::substrait::Expression_ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_ReferenceSegment_default_instance_); } -inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::child() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.StructField.child) +inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::child() const { + // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.StructField.child) return _internal_child(); } inline void Expression_ReferenceSegment_StructField::unsafe_arena_set_allocated_child( - ::io::substrait::Expression_ReferenceSegment* child) { + ::substrait::Expression_ReferenceSegment* child) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } @@ -14054,37 +13934,37 @@ inline void Expression_ReferenceSegment_StructField::unsafe_arena_set_allocated_ } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.StructField.child) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.StructField.child) } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::release_child() { +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::release_child() { - ::io::substrait::Expression_ReferenceSegment* temp = child_; + ::substrait::Expression_ReferenceSegment* temp = child_; child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.StructField.child) +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.StructField.child) - ::io::substrait::Expression_ReferenceSegment* temp = child_; + ::substrait::Expression_ReferenceSegment* temp = child_; child_ = nullptr; return temp; } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::_internal_mutable_child() { +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArena()); child_ = p; } return child_; } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.StructField.child) +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::mutable_child() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.StructField.child) return _internal_mutable_child(); } -inline void Expression_ReferenceSegment_StructField::set_allocated_child(::io::substrait::Expression_ReferenceSegment* child) { +inline void Expression_ReferenceSegment_StructField::set_allocated_child(::substrait::Expression_ReferenceSegment* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete child_; @@ -14101,7 +13981,7 @@ inline void Expression_ReferenceSegment_StructField::set_allocated_child(::io::s } child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.StructField.child) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.StructField.child) } // ------------------------------------------------------------------- @@ -14116,7 +13996,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_ListElement::_ return offset_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_ListElement::offset() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.ListElement.offset) + // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.ListElement.offset) return _internal_offset(); } inline void Expression_ReferenceSegment_ListElement::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -14125,10 +14005,10 @@ inline void Expression_ReferenceSegment_ListElement::_internal_set_offset(::PROT } inline void Expression_ReferenceSegment_ListElement::set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_offset(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.ReferenceSegment.ListElement.offset) + // @@protoc_insertion_point(field_set:substrait.Expression.ReferenceSegment.ListElement.offset) } -// .io.substrait.Expression.ReferenceSegment child = 2; +// .substrait.Expression.ReferenceSegment child = 2; inline bool Expression_ReferenceSegment_ListElement::_internal_has_child() const { return this != internal_default_instance() && child_ != nullptr; } @@ -14141,17 +14021,17 @@ inline void Expression_ReferenceSegment_ListElement::clear_child() { } child_ = nullptr; } -inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::_internal_child() const { - const ::io::substrait::Expression_ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_ReferenceSegment_default_instance_); +inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::_internal_child() const { + const ::substrait::Expression_ReferenceSegment* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_ReferenceSegment_default_instance_); } -inline const ::io::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::child() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.ListElement.child) +inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::child() const { + // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.ListElement.child) return _internal_child(); } inline void Expression_ReferenceSegment_ListElement::unsafe_arena_set_allocated_child( - ::io::substrait::Expression_ReferenceSegment* child) { + ::substrait::Expression_ReferenceSegment* child) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } @@ -14161,37 +14041,37 @@ inline void Expression_ReferenceSegment_ListElement::unsafe_arena_set_allocated_ } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.ListElement.child) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.ListElement.child) } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::release_child() { +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::release_child() { - ::io::substrait::Expression_ReferenceSegment* temp = child_; + ::substrait::Expression_ReferenceSegment* temp = child_; child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.ListElement.child) +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.ListElement.child) - ::io::substrait::Expression_ReferenceSegment* temp = child_; + ::substrait::Expression_ReferenceSegment* temp = child_; child_ = nullptr; return temp; } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::_internal_mutable_child() { +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_ReferenceSegment>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArena()); child_ = p; } return child_; } -inline ::io::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.ListElement.child) +inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::mutable_child() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.ListElement.child) return _internal_mutable_child(); } -inline void Expression_ReferenceSegment_ListElement::set_allocated_child(::io::substrait::Expression_ReferenceSegment* child) { +inline void Expression_ReferenceSegment_ListElement::set_allocated_child(::substrait::Expression_ReferenceSegment* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete child_; @@ -14208,14 +14088,14 @@ inline void Expression_ReferenceSegment_ListElement::set_allocated_child(::io::s } child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.ReferenceSegment.ListElement.child) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.ListElement.child) } // ------------------------------------------------------------------- // Expression_ReferenceSegment -// .io.substrait.Expression.ReferenceSegment.MapKey map_key = 1; +// .substrait.Expression.ReferenceSegment.MapKey map_key = 1; inline bool Expression_ReferenceSegment::_internal_has_map_key() const { return reference_type_case() == kMapKey; } @@ -14233,11 +14113,11 @@ inline void Expression_ReferenceSegment::clear_map_key() { clear_has_reference_type(); } } -inline ::io::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::release_map_key() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.map_key) +inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::release_map_key() { + // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.map_key) if (_internal_has_map_key()) { clear_has_reference_type(); - ::io::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_; + ::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -14247,48 +14127,48 @@ inline ::io::substrait::Expression_ReferenceSegment_MapKey* Expression_Reference return nullptr; } } -inline const ::io::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::_internal_map_key() const { +inline const ::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::_internal_map_key() const { return _internal_has_map_key() ? *reference_type_.map_key_ - : reinterpret_cast< ::io::substrait::Expression_ReferenceSegment_MapKey&>(::io::substrait::_Expression_ReferenceSegment_MapKey_default_instance_); + : reinterpret_cast< ::substrait::Expression_ReferenceSegment_MapKey&>(::substrait::_Expression_ReferenceSegment_MapKey_default_instance_); } -inline const ::io::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::map_key() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.map_key) +inline const ::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::map_key() const { + // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.map_key) return _internal_map_key(); } -inline ::io::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::unsafe_arena_release_map_key() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.ReferenceSegment.map_key) +inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::unsafe_arena_release_map_key() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.ReferenceSegment.map_key) if (_internal_has_map_key()) { clear_has_reference_type(); - ::io::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_; + ::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_; reference_type_.map_key_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_map_key(::io::substrait::Expression_ReferenceSegment_MapKey* map_key) { +inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key) { clear_reference_type(); if (map_key) { set_has_map_key(); reference_type_.map_key_ = map_key; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.map_key) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.map_key) } -inline ::io::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::_internal_mutable_map_key() { +inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::_internal_mutable_map_key() { if (!_internal_has_map_key()) { clear_reference_type(); set_has_map_key(); - reference_type_.map_key_ = CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_MapKey >(GetArena()); + reference_type_.map_key_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_MapKey >(GetArena()); } return reference_type_.map_key_; } -inline ::io::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::mutable_map_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.map_key) +inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::mutable_map_key() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.map_key) return _internal_mutable_map_key(); } -// .io.substrait.Expression.ReferenceSegment.StructField struct_field = 2; +// .substrait.Expression.ReferenceSegment.StructField struct_field = 2; inline bool Expression_ReferenceSegment::_internal_has_struct_field() const { return reference_type_case() == kStructField; } @@ -14306,11 +14186,11 @@ inline void Expression_ReferenceSegment::clear_struct_field() { clear_has_reference_type(); } } -inline ::io::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::release_struct_field() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.struct_field) +inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::release_struct_field() { + // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.struct_field) if (_internal_has_struct_field()) { clear_has_reference_type(); - ::io::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_; + ::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -14320,48 +14200,48 @@ inline ::io::substrait::Expression_ReferenceSegment_StructField* Expression_Refe return nullptr; } } -inline const ::io::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::_internal_struct_field() const { +inline const ::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::_internal_struct_field() const { return _internal_has_struct_field() ? *reference_type_.struct_field_ - : reinterpret_cast< ::io::substrait::Expression_ReferenceSegment_StructField&>(::io::substrait::_Expression_ReferenceSegment_StructField_default_instance_); + : reinterpret_cast< ::substrait::Expression_ReferenceSegment_StructField&>(::substrait::_Expression_ReferenceSegment_StructField_default_instance_); } -inline const ::io::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::struct_field() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.struct_field) +inline const ::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::struct_field() const { + // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.struct_field) return _internal_struct_field(); } -inline ::io::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::unsafe_arena_release_struct_field() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.ReferenceSegment.struct_field) +inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::unsafe_arena_release_struct_field() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.ReferenceSegment.struct_field) if (_internal_has_struct_field()) { clear_has_reference_type(); - ::io::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_; + ::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_; reference_type_.struct_field_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_struct_field(::io::substrait::Expression_ReferenceSegment_StructField* struct_field) { +inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field) { clear_reference_type(); if (struct_field) { set_has_struct_field(); reference_type_.struct_field_ = struct_field; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.struct_field) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.struct_field) } -inline ::io::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::_internal_mutable_struct_field() { +inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::_internal_mutable_struct_field() { if (!_internal_has_struct_field()) { clear_reference_type(); set_has_struct_field(); - reference_type_.struct_field_ = CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_StructField >(GetArena()); + reference_type_.struct_field_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_StructField >(GetArena()); } return reference_type_.struct_field_; } -inline ::io::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::mutable_struct_field() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.struct_field) +inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::mutable_struct_field() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.struct_field) return _internal_mutable_struct_field(); } -// .io.substrait.Expression.ReferenceSegment.ListElement list_element = 3; +// .substrait.Expression.ReferenceSegment.ListElement list_element = 3; inline bool Expression_ReferenceSegment::_internal_has_list_element() const { return reference_type_case() == kListElement; } @@ -14379,11 +14259,11 @@ inline void Expression_ReferenceSegment::clear_list_element() { clear_has_reference_type(); } } -inline ::io::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::release_list_element() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.ReferenceSegment.list_element) +inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::release_list_element() { + // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.list_element) if (_internal_has_list_element()) { clear_has_reference_type(); - ::io::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_; + ::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -14393,44 +14273,44 @@ inline ::io::substrait::Expression_ReferenceSegment_ListElement* Expression_Refe return nullptr; } } -inline const ::io::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::_internal_list_element() const { +inline const ::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::_internal_list_element() const { return _internal_has_list_element() ? *reference_type_.list_element_ - : reinterpret_cast< ::io::substrait::Expression_ReferenceSegment_ListElement&>(::io::substrait::_Expression_ReferenceSegment_ListElement_default_instance_); + : reinterpret_cast< ::substrait::Expression_ReferenceSegment_ListElement&>(::substrait::_Expression_ReferenceSegment_ListElement_default_instance_); } -inline const ::io::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::list_element() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.ReferenceSegment.list_element) +inline const ::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::list_element() const { + // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.list_element) return _internal_list_element(); } -inline ::io::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::unsafe_arena_release_list_element() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.ReferenceSegment.list_element) +inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::unsafe_arena_release_list_element() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.ReferenceSegment.list_element) if (_internal_has_list_element()) { clear_has_reference_type(); - ::io::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_; + ::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_; reference_type_.list_element_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_list_element(::io::substrait::Expression_ReferenceSegment_ListElement* list_element) { +inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element) { clear_reference_type(); if (list_element) { set_has_list_element(); reference_type_.list_element_ = list_element; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.ReferenceSegment.list_element) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.list_element) } -inline ::io::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::_internal_mutable_list_element() { +inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::_internal_mutable_list_element() { if (!_internal_has_list_element()) { clear_reference_type(); set_has_list_element(); - reference_type_.list_element_ = CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment_ListElement >(GetArena()); + reference_type_.list_element_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_ListElement >(GetArena()); } return reference_type_.list_element_; } -inline ::io::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::mutable_list_element() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.ReferenceSegment.list_element) +inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::mutable_list_element() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.list_element) return _internal_mutable_list_element(); } @@ -14447,7 +14327,7 @@ inline Expression_ReferenceSegment::ReferenceTypeCase Expression_ReferenceSegmen // Expression_MaskExpression_Select -// .io.substrait.Expression.MaskExpression.StructSelect struct = 1; +// .substrait.Expression.MaskExpression.StructSelect struct = 1; inline bool Expression_MaskExpression_Select::_internal_has_struct_() const { return type_case() == kStruct; } @@ -14465,11 +14345,11 @@ inline void Expression_MaskExpression_Select::clear_struct_() { clear_has_type(); } } -inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.Select.struct) +inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::release_struct_() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.Select.struct) if (_internal_has_struct_()) { clear_has_type(); - ::io::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__; + ::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -14479,48 +14359,48 @@ inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskE return nullptr; } } -inline const ::io::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::_internal_struct_() const { +inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::_internal_struct_() const { return _internal_has_struct_() ? *type_.struct__ - : reinterpret_cast< ::io::substrait::Expression_MaskExpression_StructSelect&>(::io::substrait::_Expression_MaskExpression_StructSelect_default_instance_); + : reinterpret_cast< ::substrait::Expression_MaskExpression_StructSelect&>(::substrait::_Expression_MaskExpression_StructSelect_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.Select.struct) +inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::struct_() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.Select.struct) return _internal_struct_(); } -inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.Select.struct) +inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.Select.struct) if (_internal_has_struct_()) { clear_has_type(); - ::io::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__; + ::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__; type_.struct__ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_struct_(::io::substrait::Expression_MaskExpression_StructSelect* struct_) { +inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_) { clear_type(); if (struct_) { set_has_struct_(); type_.struct__ = struct_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.Select.struct) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.Select.struct) } -inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::_internal_mutable_struct_() { +inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::_internal_mutable_struct_() { if (!_internal_has_struct_()) { clear_type(); set_has_struct_(); - type_.struct__ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_StructSelect >(GetArena()); + type_.struct__ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructSelect >(GetArena()); } return type_.struct__; } -inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.Select.struct) +inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.struct) return _internal_mutable_struct_(); } -// .io.substrait.Expression.MaskExpression.ListSelect list = 2; +// .substrait.Expression.MaskExpression.ListSelect list = 2; inline bool Expression_MaskExpression_Select::_internal_has_list() const { return type_case() == kList; } @@ -14538,11 +14418,11 @@ inline void Expression_MaskExpression_Select::clear_list() { clear_has_type(); } } -inline ::io::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::release_list() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.Select.list) +inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::release_list() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.Select.list) if (_internal_has_list()) { clear_has_type(); - ::io::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_; + ::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -14552,48 +14432,48 @@ inline ::io::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExp return nullptr; } } -inline const ::io::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::_internal_list() const { +inline const ::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::_internal_list() const { return _internal_has_list() ? *type_.list_ - : reinterpret_cast< ::io::substrait::Expression_MaskExpression_ListSelect&>(::io::substrait::_Expression_MaskExpression_ListSelect_default_instance_); + : reinterpret_cast< ::substrait::Expression_MaskExpression_ListSelect&>(::substrait::_Expression_MaskExpression_ListSelect_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::list() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.Select.list) +inline const ::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::list() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.Select.list) return _internal_list(); } -inline ::io::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.Select.list) +inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.Select.list) if (_internal_has_list()) { clear_has_type(); - ::io::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_; + ::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_; type_.list_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_list(::io::substrait::Expression_MaskExpression_ListSelect* list) { +inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list) { clear_type(); if (list) { set_has_list(); type_.list_ = list; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.Select.list) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.Select.list) } -inline ::io::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::_internal_mutable_list() { +inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::_internal_mutable_list() { if (!_internal_has_list()) { clear_type(); set_has_list(); - type_.list_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect >(GetArena()); + type_.list_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect >(GetArena()); } return type_.list_; } -inline ::io::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::mutable_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.Select.list) +inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::mutable_list() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.list) return _internal_mutable_list(); } -// .io.substrait.Expression.MaskExpression.MapSelect map = 3; +// .substrait.Expression.MaskExpression.MapSelect map = 3; inline bool Expression_MaskExpression_Select::_internal_has_map() const { return type_case() == kMap; } @@ -14611,11 +14491,11 @@ inline void Expression_MaskExpression_Select::clear_map() { clear_has_type(); } } -inline ::io::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::release_map() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.Select.map) +inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::release_map() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.Select.map) if (_internal_has_map()) { clear_has_type(); - ::io::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_; + ::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -14625,44 +14505,44 @@ inline ::io::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpr return nullptr; } } -inline const ::io::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::_internal_map() const { +inline const ::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::_internal_map() const { return _internal_has_map() ? *type_.map_ - : reinterpret_cast< ::io::substrait::Expression_MaskExpression_MapSelect&>(::io::substrait::_Expression_MaskExpression_MapSelect_default_instance_); + : reinterpret_cast< ::substrait::Expression_MaskExpression_MapSelect&>(::substrait::_Expression_MaskExpression_MapSelect_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::map() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.Select.map) +inline const ::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::map() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.Select.map) return _internal_map(); } -inline ::io::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.Select.map) +inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.Select.map) if (_internal_has_map()) { clear_has_type(); - ::io::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_; + ::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_; type_.map_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_map(::io::substrait::Expression_MaskExpression_MapSelect* map) { +inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map) { clear_type(); if (map) { set_has_map(); type_.map_ = map; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.Select.map) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.Select.map) } -inline ::io::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::_internal_mutable_map() { +inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::_internal_mutable_map() { if (!_internal_has_map()) { clear_type(); set_has_map(); - type_.map_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect >(GetArena()); + type_.map_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect >(GetArena()); } return type_.map_; } -inline ::io::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::mutable_map() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.Select.map) +inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::mutable_map() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.map) return _internal_mutable_map(); } @@ -14679,7 +14559,7 @@ inline Expression_MaskExpression_Select::TypeCase Expression_MaskExpression_Sele // Expression_MaskExpression_StructSelect -// repeated .io.substrait.Expression.MaskExpression.StructItem struct_items = 1; +// repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; inline int Expression_MaskExpression_StructSelect::_internal_struct_items_size() const { return struct_items_.size(); } @@ -14689,32 +14569,32 @@ inline int Expression_MaskExpression_StructSelect::struct_items_size() const { inline void Expression_MaskExpression_StructSelect::clear_struct_items() { struct_items_.Clear(); } -inline ::io::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::mutable_struct_items(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.StructSelect.struct_items) +inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::mutable_struct_items(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.StructSelect.struct_items) return struct_items_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_StructItem >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >* Expression_MaskExpression_StructSelect::mutable_struct_items() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MaskExpression.StructSelect.struct_items) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MaskExpression.StructSelect.struct_items) return &struct_items_; } -inline const ::io::substrait::Expression_MaskExpression_StructItem& Expression_MaskExpression_StructSelect::_internal_struct_items(int index) const { +inline const ::substrait::Expression_MaskExpression_StructItem& Expression_MaskExpression_StructSelect::_internal_struct_items(int index) const { return struct_items_.Get(index); } -inline const ::io::substrait::Expression_MaskExpression_StructItem& Expression_MaskExpression_StructSelect::struct_items(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.StructSelect.struct_items) +inline const ::substrait::Expression_MaskExpression_StructItem& Expression_MaskExpression_StructSelect::struct_items(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.StructSelect.struct_items) return _internal_struct_items(index); } -inline ::io::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::_internal_add_struct_items() { +inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::_internal_add_struct_items() { return struct_items_.Add(); } -inline ::io::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::add_struct_items() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.MaskExpression.StructSelect.struct_items) +inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::add_struct_items() { + // @@protoc_insertion_point(field_add:substrait.Expression.MaskExpression.StructSelect.struct_items) return _internal_add_struct_items(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_StructItem >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >& Expression_MaskExpression_StructSelect::struct_items() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.MaskExpression.StructSelect.struct_items) + // @@protoc_insertion_point(field_list:substrait.Expression.MaskExpression.StructSelect.struct_items) return struct_items_; } @@ -14730,7 +14610,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_StructItem::_int return field_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_StructItem::field() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.StructItem.field) + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.StructItem.field) return _internal_field(); } inline void Expression_MaskExpression_StructItem::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -14739,10 +14619,10 @@ inline void Expression_MaskExpression_StructItem::_internal_set_field(::PROTOBUF } inline void Expression_MaskExpression_StructItem::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_field(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.StructItem.field) + // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.StructItem.field) } -// .io.substrait.Expression.MaskExpression.Select child = 2; +// .substrait.Expression.MaskExpression.Select child = 2; inline bool Expression_MaskExpression_StructItem::_internal_has_child() const { return this != internal_default_instance() && child_ != nullptr; } @@ -14755,17 +14635,17 @@ inline void Expression_MaskExpression_StructItem::clear_child() { } child_ = nullptr; } -inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::_internal_child() const { - const ::io::substrait::Expression_MaskExpression_Select* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_MaskExpression_Select_default_instance_); +inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::_internal_child() const { + const ::substrait::Expression_MaskExpression_Select* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_MaskExpression_Select_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::child() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.StructItem.child) +inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::child() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.StructItem.child) return _internal_child(); } inline void Expression_MaskExpression_StructItem::unsafe_arena_set_allocated_child( - ::io::substrait::Expression_MaskExpression_Select* child) { + ::substrait::Expression_MaskExpression_Select* child) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } @@ -14775,37 +14655,37 @@ inline void Expression_MaskExpression_StructItem::unsafe_arena_set_allocated_chi } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.StructItem.child) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.StructItem.child) } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::release_child() { +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::release_child() { - ::io::substrait::Expression_MaskExpression_Select* temp = child_; + ::substrait::Expression_MaskExpression_Select* temp = child_; child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.StructItem.child) +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.StructItem.child) - ::io::substrait::Expression_MaskExpression_Select* temp = child_; + ::substrait::Expression_MaskExpression_Select* temp = child_; child_ = nullptr; return temp; } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::_internal_mutable_child() { +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_MaskExpression_Select>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArena()); child_ = p; } return child_; } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.StructItem.child) +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::mutable_child() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.StructItem.child) return _internal_mutable_child(); } -inline void Expression_MaskExpression_StructItem::set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child) { +inline void Expression_MaskExpression_StructItem::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete child_; @@ -14822,7 +14702,7 @@ inline void Expression_MaskExpression_StructItem::set_allocated_child(::io::subs } child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.StructItem.child) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.StructItem.child) } // ------------------------------------------------------------------- @@ -14837,7 +14717,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListS return field_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::field() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field) + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field) return _internal_field(); } inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -14846,7 +14726,7 @@ inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_in } inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_field(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field) + // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field) } // ------------------------------------------------------------------- @@ -14861,7 +14741,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListS return start_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::start() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) return _internal_start(); } inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -14870,7 +14750,7 @@ inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_inte } inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_start(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) + // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) } // int32 end = 2; @@ -14881,7 +14761,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListS return end_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::end() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) return _internal_end(); } inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -14890,14 +14770,14 @@ inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_inte } inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_end(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) + // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) } // ------------------------------------------------------------------- // Expression_MaskExpression_ListSelect_ListSelectItem -// .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; +// .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; inline bool Expression_MaskExpression_ListSelect_ListSelectItem::_internal_has_item() const { return type_case() == kItem; } @@ -14915,11 +14795,11 @@ inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_item() { clear_has_type(); } } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::release_item() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::release_item() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) if (_internal_has_item()) { clear_has_type(); - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -14929,48 +14809,48 @@ inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_List return nullptr; } } -inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::_internal_item() const { +inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::_internal_item() const { return _internal_has_item() ? *type_.item_ - : reinterpret_cast< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&>(::io::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_); + : reinterpret_cast< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&>(::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::item() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) +inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::item() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) return _internal_item(); } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_item() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_item() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) if (_internal_has_item()) { clear_has_type(); - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; type_.item_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_item(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) { +inline void Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) { clear_type(); if (item) { set_has_item(); type_.item_ = item; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::_internal_mutable_item() { +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::_internal_mutable_item() { if (!_internal_has_item()) { clear_type(); set_has_item(); - type_.item_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(GetArena()); + type_.item_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(GetArena()); } return type_.item_; } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_item() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_item() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) return _internal_mutable_item(); } -// .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; +// .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; inline bool Expression_MaskExpression_ListSelect_ListSelectItem::_internal_has_slice() const { return type_case() == kSlice; } @@ -14988,11 +14868,11 @@ inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_slice() { clear_has_type(); } } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::release_slice() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::release_slice() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) if (_internal_has_slice()) { clear_has_type(); - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -15002,44 +14882,44 @@ inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_List return nullptr; } } -inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::_internal_slice() const { +inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::_internal_slice() const { return _internal_has_slice() ? *type_.slice_ - : reinterpret_cast< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&>(::io::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_); + : reinterpret_cast< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&>(::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::slice() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) +inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::slice() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) return _internal_slice(); } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_slice() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_slice() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) if (_internal_has_slice()) { clear_has_type(); - ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; type_.slice_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_slice(::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { +inline void Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { clear_type(); if (slice) { set_has_slice(); type_.slice_ = slice; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::_internal_mutable_slice() { +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::_internal_mutable_slice() { if (!_internal_has_slice()) { clear_type(); set_has_slice(); - type_.slice_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(GetArena()); + type_.slice_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(GetArena()); } return type_.slice_; } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_slice() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_slice() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) return _internal_mutable_slice(); } @@ -15056,7 +14936,7 @@ inline Expression_MaskExpression_ListSelect_ListSelectItem::TypeCase Expression_ // Expression_MaskExpression_ListSelect -// repeated .io.substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; +// repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; inline int Expression_MaskExpression_ListSelect::_internal_selection_size() const { return selection_.size(); } @@ -15066,36 +14946,36 @@ inline int Expression_MaskExpression_ListSelect::selection_size() const { inline void Expression_MaskExpression_ListSelect::clear_selection() { selection_.Clear(); } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::mutable_selection(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.ListSelect.selection) +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::mutable_selection(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.selection) return selection_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >* Expression_MaskExpression_ListSelect::mutable_selection() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Expression.MaskExpression.ListSelect.selection) + // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MaskExpression.ListSelect.selection) return &selection_; } -inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& Expression_MaskExpression_ListSelect::_internal_selection(int index) const { +inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& Expression_MaskExpression_ListSelect::_internal_selection(int index) const { return selection_.Get(index); } -inline const ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& Expression_MaskExpression_ListSelect::selection(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.selection) +inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& Expression_MaskExpression_ListSelect::selection(int index) const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.selection) return _internal_selection(index); } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::_internal_add_selection() { +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::_internal_add_selection() { return selection_.Add(); } -inline ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::add_selection() { - // @@protoc_insertion_point(field_add:io.substrait.Expression.MaskExpression.ListSelect.selection) +inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::add_selection() { + // @@protoc_insertion_point(field_add:substrait.Expression.MaskExpression.ListSelect.selection) return _internal_add_selection(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >& Expression_MaskExpression_ListSelect::selection() const { - // @@protoc_insertion_point(field_list:io.substrait.Expression.MaskExpression.ListSelect.selection) + // @@protoc_insertion_point(field_list:substrait.Expression.MaskExpression.ListSelect.selection) return selection_; } -// .io.substrait.Expression.MaskExpression.Select child = 2; +// .substrait.Expression.MaskExpression.Select child = 2; inline bool Expression_MaskExpression_ListSelect::_internal_has_child() const { return this != internal_default_instance() && child_ != nullptr; } @@ -15108,17 +14988,17 @@ inline void Expression_MaskExpression_ListSelect::clear_child() { } child_ = nullptr; } -inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::_internal_child() const { - const ::io::substrait::Expression_MaskExpression_Select* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_MaskExpression_Select_default_instance_); +inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::_internal_child() const { + const ::substrait::Expression_MaskExpression_Select* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_MaskExpression_Select_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::child() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.ListSelect.child) +inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::child() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.child) return _internal_child(); } inline void Expression_MaskExpression_ListSelect::unsafe_arena_set_allocated_child( - ::io::substrait::Expression_MaskExpression_Select* child) { + ::substrait::Expression_MaskExpression_Select* child) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } @@ -15128,37 +15008,37 @@ inline void Expression_MaskExpression_ListSelect::unsafe_arena_set_allocated_chi } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.child) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.ListSelect.child) } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::release_child() { +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::release_child() { - ::io::substrait::Expression_MaskExpression_Select* temp = child_; + ::substrait::Expression_MaskExpression_Select* temp = child_; child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.ListSelect.child) +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.ListSelect.child) - ::io::substrait::Expression_MaskExpression_Select* temp = child_; + ::substrait::Expression_MaskExpression_Select* temp = child_; child_ = nullptr; return temp; } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::_internal_mutable_child() { +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_MaskExpression_Select>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArena()); child_ = p; } return child_; } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.ListSelect.child) +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::mutable_child() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.child) return _internal_mutable_child(); } -inline void Expression_MaskExpression_ListSelect::set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child) { +inline void Expression_MaskExpression_ListSelect::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete child_; @@ -15175,7 +15055,7 @@ inline void Expression_MaskExpression_ListSelect::set_allocated_child(::io::subs } child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.ListSelect.child) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.child) } // ------------------------------------------------------------------- @@ -15187,7 +15067,7 @@ inline void Expression_MaskExpression_MapSelect_MapKey::clear_map_key() { map_key_.ClearToEmpty(); } inline const std::string& Expression_MaskExpression_MapSelect_MapKey::map_key() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) return _internal_map_key(); } template @@ -15195,10 +15075,10 @@ PROTOBUF_ALWAYS_INLINE inline void Expression_MaskExpression_MapSelect_MapKey::set_map_key(ArgT0&& arg0, ArgT... args) { map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) + // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) } inline std::string* Expression_MaskExpression_MapSelect_MapKey::mutable_map_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) return _internal_mutable_map_key(); } inline const std::string& Expression_MaskExpression_MapSelect_MapKey::_internal_map_key() const { @@ -15213,7 +15093,7 @@ inline std::string* Expression_MaskExpression_MapSelect_MapKey::_internal_mutabl return map_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_MaskExpression_MapSelect_MapKey::release_map_key() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) return map_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void Expression_MaskExpression_MapSelect_MapKey::set_allocated_map_key(std::string* map_key) { @@ -15224,7 +15104,7 @@ inline void Expression_MaskExpression_MapSelect_MapKey::set_allocated_map_key(st } map_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) } // ------------------------------------------------------------------- @@ -15236,7 +15116,7 @@ inline void Expression_MaskExpression_MapSelect_MapKeyExpression::clear_map_key_ map_key_expression_.ClearToEmpty(); } inline const std::string& Expression_MaskExpression_MapSelect_MapKeyExpression::map_key_expression() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) return _internal_map_key_expression(); } template @@ -15244,10 +15124,10 @@ PROTOBUF_ALWAYS_INLINE inline void Expression_MaskExpression_MapSelect_MapKeyExpression::set_map_key_expression(ArgT0&& arg0, ArgT... args) { map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) } inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::mutable_map_key_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) return _internal_mutable_map_key_expression(); } inline const std::string& Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_map_key_expression() const { @@ -15262,7 +15142,7 @@ inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::_inter return map_key_expression_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::release_map_key_expression() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) return map_key_expression_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void Expression_MaskExpression_MapSelect_MapKeyExpression::set_allocated_map_key_expression(std::string* map_key_expression) { @@ -15273,14 +15153,14 @@ inline void Expression_MaskExpression_MapSelect_MapKeyExpression::set_allocated_ } map_key_expression_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key_expression, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) } // ------------------------------------------------------------------- // Expression_MaskExpression_MapSelect -// .io.substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; +// .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; inline bool Expression_MaskExpression_MapSelect::_internal_has_key() const { return select_case() == kKey; } @@ -15298,11 +15178,11 @@ inline void Expression_MaskExpression_MapSelect::clear_key() { clear_has_select(); } } -inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::release_key() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.MapSelect.key) +inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::release_key() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.key) if (_internal_has_key()) { clear_has_select(); - ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_; + ::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -15312,48 +15192,48 @@ inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_M return nullptr; } } -inline const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::_internal_key() const { +inline const ::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::_internal_key() const { return _internal_has_key() ? *select_.key_ - : reinterpret_cast< ::io::substrait::Expression_MaskExpression_MapSelect_MapKey&>(::io::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_); + : reinterpret_cast< ::substrait::Expression_MaskExpression_MapSelect_MapKey&>(::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::key() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.MapSelect.key) +inline const ::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::key() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.key) return _internal_key(); } -inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.MapSelect.key) +inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.MapSelect.key) if (_internal_has_key()) { clear_has_select(); - ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_; + ::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_; select_.key_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_key(::io::substrait::Expression_MaskExpression_MapSelect_MapKey* key) { +inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key) { clear_select(); if (key) { set_has_key(); select_.key_ = key; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.key) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.MapSelect.key) } -inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::_internal_mutable_key() { +inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::_internal_mutable_key() { if (!_internal_has_key()) { clear_select(); set_has_key(); - select_.key_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect_MapKey >(GetArena()); + select_.key_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(GetArena()); } return select_.key_; } -inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::mutable_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.MapSelect.key) +inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::mutable_key() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.key) return _internal_mutable_key(); } -// .io.substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; +// .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; inline bool Expression_MaskExpression_MapSelect::_internal_has_expression() const { return select_case() == kExpression; } @@ -15371,11 +15251,11 @@ inline void Expression_MaskExpression_MapSelect::clear_expression() { clear_has_select(); } } -inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::release_expression() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.MapSelect.expression) +inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::release_expression() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.expression) if (_internal_has_expression()) { clear_has_select(); - ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; + ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -15385,48 +15265,48 @@ inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Ex return nullptr; } } -inline const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::_internal_expression() const { +inline const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::_internal_expression() const { return _internal_has_expression() ? *select_.expression_ - : reinterpret_cast< ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression&>(::io::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_); + : reinterpret_cast< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression&>(::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::expression() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.MapSelect.expression) +inline const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::expression() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.expression) return _internal_expression(); } -inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.MaskExpression.MapSelect.expression) +inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.MapSelect.expression) if (_internal_has_expression()) { clear_has_select(); - ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; + ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; select_.expression_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_expression(::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) { +inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) { clear_select(); if (expression) { set_has_expression(); select_.expression_ = expression; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.expression) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.MapSelect.expression) } -inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::_internal_mutable_expression() { +inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::_internal_mutable_expression() { if (!_internal_has_expression()) { clear_select(); set_has_expression(); - select_.expression_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(GetArena()); + select_.expression_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(GetArena()); } return select_.expression_; } -inline ::io::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::mutable_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.MapSelect.expression) +inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::mutable_expression() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.expression) return _internal_mutable_expression(); } -// .io.substrait.Expression.MaskExpression.Select child = 3; +// .substrait.Expression.MaskExpression.Select child = 3; inline bool Expression_MaskExpression_MapSelect::_internal_has_child() const { return this != internal_default_instance() && child_ != nullptr; } @@ -15439,17 +15319,17 @@ inline void Expression_MaskExpression_MapSelect::clear_child() { } child_ = nullptr; } -inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::_internal_child() const { - const ::io::substrait::Expression_MaskExpression_Select* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_MaskExpression_Select_default_instance_); +inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::_internal_child() const { + const ::substrait::Expression_MaskExpression_Select* p = child_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_MaskExpression_Select_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::child() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.MapSelect.child) +inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::child() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.child) return _internal_child(); } inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_child( - ::io::substrait::Expression_MaskExpression_Select* child) { + ::substrait::Expression_MaskExpression_Select* child) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } @@ -15459,37 +15339,37 @@ inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_chil } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.child) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.MapSelect.child) } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::release_child() { +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::release_child() { - ::io::substrait::Expression_MaskExpression_Select* temp = child_; + ::substrait::Expression_MaskExpression_Select* temp = child_; child_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.MapSelect.child) +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::unsafe_arena_release_child() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.child) - ::io::substrait::Expression_MaskExpression_Select* temp = child_; + ::substrait::Expression_MaskExpression_Select* temp = child_; child_ = nullptr; return temp; } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::_internal_mutable_child() { +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_MaskExpression_Select>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArena()); child_ = p; } return child_; } -inline ::io::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::mutable_child() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.MapSelect.child) +inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::mutable_child() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.child) return _internal_mutable_child(); } -inline void Expression_MaskExpression_MapSelect::set_allocated_child(::io::substrait::Expression_MaskExpression_Select* child) { +inline void Expression_MaskExpression_MapSelect::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete child_; @@ -15506,7 +15386,7 @@ inline void Expression_MaskExpression_MapSelect::set_allocated_child(::io::subst } child_ = child; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.MapSelect.child) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.child) } inline bool Expression_MaskExpression_MapSelect::has_select() const { @@ -15522,7 +15402,7 @@ inline Expression_MaskExpression_MapSelect::SelectCase Expression_MaskExpression // Expression_MaskExpression -// .io.substrait.Expression.MaskExpression.StructSelect select = 1; +// .substrait.Expression.MaskExpression.StructSelect select = 1; inline bool Expression_MaskExpression::_internal_has_select() const { return this != internal_default_instance() && select_ != nullptr; } @@ -15535,17 +15415,17 @@ inline void Expression_MaskExpression::clear_select() { } select_ = nullptr; } -inline const ::io::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::_internal_select() const { - const ::io::substrait::Expression_MaskExpression_StructSelect* p = select_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_MaskExpression_StructSelect_default_instance_); +inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::_internal_select() const { + const ::substrait::Expression_MaskExpression_StructSelect* p = select_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_MaskExpression_StructSelect_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::select() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.select) +inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::select() const { + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.select) return _internal_select(); } inline void Expression_MaskExpression::unsafe_arena_set_allocated_select( - ::io::substrait::Expression_MaskExpression_StructSelect* select) { + ::substrait::Expression_MaskExpression_StructSelect* select) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(select_); } @@ -15555,37 +15435,37 @@ inline void Expression_MaskExpression::unsafe_arena_set_allocated_select( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.MaskExpression.select) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.select) } -inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::release_select() { +inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::release_select() { - ::io::substrait::Expression_MaskExpression_StructSelect* temp = select_; + ::substrait::Expression_MaskExpression_StructSelect* temp = select_; select_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::unsafe_arena_release_select() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.MaskExpression.select) +inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::unsafe_arena_release_select() { + // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.select) - ::io::substrait::Expression_MaskExpression_StructSelect* temp = select_; + ::substrait::Expression_MaskExpression_StructSelect* temp = select_; select_ = nullptr; return temp; } -inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::_internal_mutable_select() { +inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::_internal_mutable_select() { if (select_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_MaskExpression_StructSelect>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_StructSelect>(GetArena()); select_ = p; } return select_; } -inline ::io::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::mutable_select() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.MaskExpression.select) +inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::mutable_select() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.select) return _internal_mutable_select(); } -inline void Expression_MaskExpression::set_allocated_select(::io::substrait::Expression_MaskExpression_StructSelect* select) { +inline void Expression_MaskExpression::set_allocated_select(::substrait::Expression_MaskExpression_StructSelect* select) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete select_; @@ -15602,7 +15482,7 @@ inline void Expression_MaskExpression::set_allocated_select(::io::substrait::Exp } select_ = select; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Expression.MaskExpression.select) + // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.select) } // bool maintain_singular_struct = 2; @@ -15613,7 +15493,7 @@ inline bool Expression_MaskExpression::_internal_maintain_singular_struct() cons return maintain_singular_struct_; } inline bool Expression_MaskExpression::maintain_singular_struct() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.MaskExpression.maintain_singular_struct) + // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.maintain_singular_struct) return _internal_maintain_singular_struct(); } inline void Expression_MaskExpression::_internal_set_maintain_singular_struct(bool value) { @@ -15622,7 +15502,7 @@ inline void Expression_MaskExpression::_internal_set_maintain_singular_struct(bo } inline void Expression_MaskExpression::set_maintain_singular_struct(bool value) { _internal_set_maintain_singular_struct(value); - // @@protoc_insertion_point(field_set:io.substrait.Expression.MaskExpression.maintain_singular_struct) + // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.maintain_singular_struct) } // ------------------------------------------------------------------- @@ -15633,7 +15513,7 @@ inline void Expression_MaskExpression::set_maintain_singular_struct(bool value) // Expression_FieldReference -// .io.substrait.Expression.ReferenceSegment direct_reference = 1; +// .substrait.Expression.ReferenceSegment direct_reference = 1; inline bool Expression_FieldReference::_internal_has_direct_reference() const { return reference_type_case() == kDirectReference; } @@ -15651,11 +15531,11 @@ inline void Expression_FieldReference::clear_direct_reference() { clear_has_reference_type(); } } -inline ::io::substrait::Expression_ReferenceSegment* Expression_FieldReference::release_direct_reference() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.FieldReference.direct_reference) +inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::release_direct_reference() { + // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.direct_reference) if (_internal_has_direct_reference()) { clear_has_reference_type(); - ::io::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_; + ::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -15665,48 +15545,48 @@ inline ::io::substrait::Expression_ReferenceSegment* Expression_FieldReference:: return nullptr; } } -inline const ::io::substrait::Expression_ReferenceSegment& Expression_FieldReference::_internal_direct_reference() const { +inline const ::substrait::Expression_ReferenceSegment& Expression_FieldReference::_internal_direct_reference() const { return _internal_has_direct_reference() ? *reference_type_.direct_reference_ - : reinterpret_cast< ::io::substrait::Expression_ReferenceSegment&>(::io::substrait::_Expression_ReferenceSegment_default_instance_); + : reinterpret_cast< ::substrait::Expression_ReferenceSegment&>(::substrait::_Expression_ReferenceSegment_default_instance_); } -inline const ::io::substrait::Expression_ReferenceSegment& Expression_FieldReference::direct_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.FieldReference.direct_reference) +inline const ::substrait::Expression_ReferenceSegment& Expression_FieldReference::direct_reference() const { + // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.direct_reference) return _internal_direct_reference(); } -inline ::io::substrait::Expression_ReferenceSegment* Expression_FieldReference::unsafe_arena_release_direct_reference() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.FieldReference.direct_reference) +inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::unsafe_arena_release_direct_reference() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.direct_reference) if (_internal_has_direct_reference()) { clear_has_reference_type(); - ::io::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_; + ::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_; reference_type_.direct_reference_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_FieldReference::unsafe_arena_set_allocated_direct_reference(::io::substrait::Expression_ReferenceSegment* direct_reference) { +inline void Expression_FieldReference::unsafe_arena_set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference) { clear_reference_type(); if (direct_reference) { set_has_direct_reference(); reference_type_.direct_reference_ = direct_reference; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.FieldReference.direct_reference) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.direct_reference) } -inline ::io::substrait::Expression_ReferenceSegment* Expression_FieldReference::_internal_mutable_direct_reference() { +inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::_internal_mutable_direct_reference() { if (!_internal_has_direct_reference()) { clear_reference_type(); set_has_direct_reference(); - reference_type_.direct_reference_ = CreateMaybeMessage< ::io::substrait::Expression_ReferenceSegment >(GetArena()); + reference_type_.direct_reference_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment >(GetArena()); } return reference_type_.direct_reference_; } -inline ::io::substrait::Expression_ReferenceSegment* Expression_FieldReference::mutable_direct_reference() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.FieldReference.direct_reference) +inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::mutable_direct_reference() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.direct_reference) return _internal_mutable_direct_reference(); } -// .io.substrait.Expression.MaskExpression masked_reference = 2; +// .substrait.Expression.MaskExpression masked_reference = 2; inline bool Expression_FieldReference::_internal_has_masked_reference() const { return reference_type_case() == kMaskedReference; } @@ -15724,11 +15604,11 @@ inline void Expression_FieldReference::clear_masked_reference() { clear_has_reference_type(); } } -inline ::io::substrait::Expression_MaskExpression* Expression_FieldReference::release_masked_reference() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.FieldReference.masked_reference) +inline ::substrait::Expression_MaskExpression* Expression_FieldReference::release_masked_reference() { + // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.masked_reference) if (_internal_has_masked_reference()) { clear_has_reference_type(); - ::io::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_; + ::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -15738,48 +15618,48 @@ inline ::io::substrait::Expression_MaskExpression* Expression_FieldReference::re return nullptr; } } -inline const ::io::substrait::Expression_MaskExpression& Expression_FieldReference::_internal_masked_reference() const { +inline const ::substrait::Expression_MaskExpression& Expression_FieldReference::_internal_masked_reference() const { return _internal_has_masked_reference() ? *reference_type_.masked_reference_ - : reinterpret_cast< ::io::substrait::Expression_MaskExpression&>(::io::substrait::_Expression_MaskExpression_default_instance_); + : reinterpret_cast< ::substrait::Expression_MaskExpression&>(::substrait::_Expression_MaskExpression_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression& Expression_FieldReference::masked_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.FieldReference.masked_reference) +inline const ::substrait::Expression_MaskExpression& Expression_FieldReference::masked_reference() const { + // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.masked_reference) return _internal_masked_reference(); } -inline ::io::substrait::Expression_MaskExpression* Expression_FieldReference::unsafe_arena_release_masked_reference() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.FieldReference.masked_reference) +inline ::substrait::Expression_MaskExpression* Expression_FieldReference::unsafe_arena_release_masked_reference() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.masked_reference) if (_internal_has_masked_reference()) { clear_has_reference_type(); - ::io::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_; + ::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_; reference_type_.masked_reference_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_FieldReference::unsafe_arena_set_allocated_masked_reference(::io::substrait::Expression_MaskExpression* masked_reference) { +inline void Expression_FieldReference::unsafe_arena_set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference) { clear_reference_type(); if (masked_reference) { set_has_masked_reference(); reference_type_.masked_reference_ = masked_reference; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.FieldReference.masked_reference) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.masked_reference) } -inline ::io::substrait::Expression_MaskExpression* Expression_FieldReference::_internal_mutable_masked_reference() { +inline ::substrait::Expression_MaskExpression* Expression_FieldReference::_internal_mutable_masked_reference() { if (!_internal_has_masked_reference()) { clear_reference_type(); set_has_masked_reference(); - reference_type_.masked_reference_ = CreateMaybeMessage< ::io::substrait::Expression_MaskExpression >(GetArena()); + reference_type_.masked_reference_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression >(GetArena()); } return reference_type_.masked_reference_; } -inline ::io::substrait::Expression_MaskExpression* Expression_FieldReference::mutable_masked_reference() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.FieldReference.masked_reference) +inline ::substrait::Expression_MaskExpression* Expression_FieldReference::mutable_masked_reference() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.masked_reference) return _internal_mutable_masked_reference(); } -// .io.substrait.Expression expression = 3; +// .substrait.Expression expression = 3; inline bool Expression_FieldReference::_internal_has_expression() const { return root_type_case() == kExpression; } @@ -15797,11 +15677,11 @@ inline void Expression_FieldReference::clear_expression() { clear_has_root_type(); } } -inline ::io::substrait::Expression* Expression_FieldReference::release_expression() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.FieldReference.expression) +inline ::substrait::Expression* Expression_FieldReference::release_expression() { + // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.expression) if (_internal_has_expression()) { clear_has_root_type(); - ::io::substrait::Expression* temp = root_type_.expression_; + ::substrait::Expression* temp = root_type_.expression_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -15811,48 +15691,48 @@ inline ::io::substrait::Expression* Expression_FieldReference::release_expressio return nullptr; } } -inline const ::io::substrait::Expression& Expression_FieldReference::_internal_expression() const { +inline const ::substrait::Expression& Expression_FieldReference::_internal_expression() const { return _internal_has_expression() ? *root_type_.expression_ - : reinterpret_cast< ::io::substrait::Expression&>(::io::substrait::_Expression_default_instance_); + : reinterpret_cast< ::substrait::Expression&>(::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& Expression_FieldReference::expression() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.FieldReference.expression) +inline const ::substrait::Expression& Expression_FieldReference::expression() const { + // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.expression) return _internal_expression(); } -inline ::io::substrait::Expression* Expression_FieldReference::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.FieldReference.expression) +inline ::substrait::Expression* Expression_FieldReference::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.expression) if (_internal_has_expression()) { clear_has_root_type(); - ::io::substrait::Expression* temp = root_type_.expression_; + ::substrait::Expression* temp = root_type_.expression_; root_type_.expression_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_FieldReference::unsafe_arena_set_allocated_expression(::io::substrait::Expression* expression) { +inline void Expression_FieldReference::unsafe_arena_set_allocated_expression(::substrait::Expression* expression) { clear_root_type(); if (expression) { set_has_expression(); root_type_.expression_ = expression; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.FieldReference.expression) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.expression) } -inline ::io::substrait::Expression* Expression_FieldReference::_internal_mutable_expression() { +inline ::substrait::Expression* Expression_FieldReference::_internal_mutable_expression() { if (!_internal_has_expression()) { clear_root_type(); set_has_expression(); - root_type_.expression_ = CreateMaybeMessage< ::io::substrait::Expression >(GetArena()); + root_type_.expression_ = CreateMaybeMessage< ::substrait::Expression >(GetArena()); } return root_type_.expression_; } -inline ::io::substrait::Expression* Expression_FieldReference::mutable_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.FieldReference.expression) +inline ::substrait::Expression* Expression_FieldReference::mutable_expression() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.expression) return _internal_mutable_expression(); } -// .io.substrait.Expression.FieldReference.RootReference root_reference = 4; +// .substrait.Expression.FieldReference.RootReference root_reference = 4; inline bool Expression_FieldReference::_internal_has_root_reference() const { return root_type_case() == kRootReference; } @@ -15870,11 +15750,11 @@ inline void Expression_FieldReference::clear_root_reference() { clear_has_root_type(); } } -inline ::io::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::release_root_reference() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.FieldReference.root_reference) +inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::release_root_reference() { + // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.root_reference) if (_internal_has_root_reference()) { clear_has_root_type(); - ::io::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_; + ::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -15884,44 +15764,44 @@ inline ::io::substrait::Expression_FieldReference_RootReference* Expression_Fiel return nullptr; } } -inline const ::io::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::_internal_root_reference() const { +inline const ::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::_internal_root_reference() const { return _internal_has_root_reference() ? *root_type_.root_reference_ - : reinterpret_cast< ::io::substrait::Expression_FieldReference_RootReference&>(::io::substrait::_Expression_FieldReference_RootReference_default_instance_); + : reinterpret_cast< ::substrait::Expression_FieldReference_RootReference&>(::substrait::_Expression_FieldReference_RootReference_default_instance_); } -inline const ::io::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::root_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.FieldReference.root_reference) +inline const ::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::root_reference() const { + // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.root_reference) return _internal_root_reference(); } -inline ::io::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::unsafe_arena_release_root_reference() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.FieldReference.root_reference) +inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::unsafe_arena_release_root_reference() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.root_reference) if (_internal_has_root_reference()) { clear_has_root_type(); - ::io::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_; + ::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_; root_type_.root_reference_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression_FieldReference::unsafe_arena_set_allocated_root_reference(::io::substrait::Expression_FieldReference_RootReference* root_reference) { +inline void Expression_FieldReference::unsafe_arena_set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference) { clear_root_type(); if (root_reference) { set_has_root_reference(); root_type_.root_reference_ = root_reference; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.FieldReference.root_reference) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.root_reference) } -inline ::io::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::_internal_mutable_root_reference() { +inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::_internal_mutable_root_reference() { if (!_internal_has_root_reference()) { clear_root_type(); set_has_root_reference(); - root_type_.root_reference_ = CreateMaybeMessage< ::io::substrait::Expression_FieldReference_RootReference >(GetArena()); + root_type_.root_reference_ = CreateMaybeMessage< ::substrait::Expression_FieldReference_RootReference >(GetArena()); } return root_type_.root_reference_; } -inline ::io::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::mutable_root_reference() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.FieldReference.root_reference) +inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::mutable_root_reference() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.root_reference) return _internal_mutable_root_reference(); } @@ -15947,7 +15827,7 @@ inline Expression_FieldReference::RootTypeCase Expression_FieldReference::root_t // Expression -// .io.substrait.Expression.Literal literal = 1; +// .substrait.Expression.Literal literal = 1; inline bool Expression::_internal_has_literal() const { return rex_type_case() == kLiteral; } @@ -15965,11 +15845,11 @@ inline void Expression::clear_literal() { clear_has_rex_type(); } } -inline ::io::substrait::Expression_Literal* Expression::release_literal() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.literal) +inline ::substrait::Expression_Literal* Expression::release_literal() { + // @@protoc_insertion_point(field_release:substrait.Expression.literal) if (_internal_has_literal()) { clear_has_rex_type(); - ::io::substrait::Expression_Literal* temp = rex_type_.literal_; + ::substrait::Expression_Literal* temp = rex_type_.literal_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -15979,48 +15859,48 @@ inline ::io::substrait::Expression_Literal* Expression::release_literal() { return nullptr; } } -inline const ::io::substrait::Expression_Literal& Expression::_internal_literal() const { +inline const ::substrait::Expression_Literal& Expression::_internal_literal() const { return _internal_has_literal() ? *rex_type_.literal_ - : reinterpret_cast< ::io::substrait::Expression_Literal&>(::io::substrait::_Expression_Literal_default_instance_); + : reinterpret_cast< ::substrait::Expression_Literal&>(::substrait::_Expression_Literal_default_instance_); } -inline const ::io::substrait::Expression_Literal& Expression::literal() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.literal) +inline const ::substrait::Expression_Literal& Expression::literal() const { + // @@protoc_insertion_point(field_get:substrait.Expression.literal) return _internal_literal(); } -inline ::io::substrait::Expression_Literal* Expression::unsafe_arena_release_literal() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.literal) +inline ::substrait::Expression_Literal* Expression::unsafe_arena_release_literal() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.literal) if (_internal_has_literal()) { clear_has_rex_type(); - ::io::substrait::Expression_Literal* temp = rex_type_.literal_; + ::substrait::Expression_Literal* temp = rex_type_.literal_; rex_type_.literal_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_literal(::io::substrait::Expression_Literal* literal) { +inline void Expression::unsafe_arena_set_allocated_literal(::substrait::Expression_Literal* literal) { clear_rex_type(); if (literal) { set_has_literal(); rex_type_.literal_ = literal; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.literal) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.literal) } -inline ::io::substrait::Expression_Literal* Expression::_internal_mutable_literal() { +inline ::substrait::Expression_Literal* Expression::_internal_mutable_literal() { if (!_internal_has_literal()) { clear_rex_type(); set_has_literal(); - rex_type_.literal_ = CreateMaybeMessage< ::io::substrait::Expression_Literal >(GetArena()); + rex_type_.literal_ = CreateMaybeMessage< ::substrait::Expression_Literal >(GetArena()); } return rex_type_.literal_; } -inline ::io::substrait::Expression_Literal* Expression::mutable_literal() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.literal) +inline ::substrait::Expression_Literal* Expression::mutable_literal() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.literal) return _internal_mutable_literal(); } -// .io.substrait.Expression.FieldReference selection = 2; +// .substrait.Expression.FieldReference selection = 2; inline bool Expression::_internal_has_selection() const { return rex_type_case() == kSelection; } @@ -16038,11 +15918,11 @@ inline void Expression::clear_selection() { clear_has_rex_type(); } } -inline ::io::substrait::Expression_FieldReference* Expression::release_selection() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.selection) +inline ::substrait::Expression_FieldReference* Expression::release_selection() { + // @@protoc_insertion_point(field_release:substrait.Expression.selection) if (_internal_has_selection()) { clear_has_rex_type(); - ::io::substrait::Expression_FieldReference* temp = rex_type_.selection_; + ::substrait::Expression_FieldReference* temp = rex_type_.selection_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -16052,48 +15932,48 @@ inline ::io::substrait::Expression_FieldReference* Expression::release_selection return nullptr; } } -inline const ::io::substrait::Expression_FieldReference& Expression::_internal_selection() const { +inline const ::substrait::Expression_FieldReference& Expression::_internal_selection() const { return _internal_has_selection() ? *rex_type_.selection_ - : reinterpret_cast< ::io::substrait::Expression_FieldReference&>(::io::substrait::_Expression_FieldReference_default_instance_); + : reinterpret_cast< ::substrait::Expression_FieldReference&>(::substrait::_Expression_FieldReference_default_instance_); } -inline const ::io::substrait::Expression_FieldReference& Expression::selection() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.selection) +inline const ::substrait::Expression_FieldReference& Expression::selection() const { + // @@protoc_insertion_point(field_get:substrait.Expression.selection) return _internal_selection(); } -inline ::io::substrait::Expression_FieldReference* Expression::unsafe_arena_release_selection() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.selection) +inline ::substrait::Expression_FieldReference* Expression::unsafe_arena_release_selection() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.selection) if (_internal_has_selection()) { clear_has_rex_type(); - ::io::substrait::Expression_FieldReference* temp = rex_type_.selection_; + ::substrait::Expression_FieldReference* temp = rex_type_.selection_; rex_type_.selection_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_selection(::io::substrait::Expression_FieldReference* selection) { +inline void Expression::unsafe_arena_set_allocated_selection(::substrait::Expression_FieldReference* selection) { clear_rex_type(); if (selection) { set_has_selection(); rex_type_.selection_ = selection; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.selection) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.selection) } -inline ::io::substrait::Expression_FieldReference* Expression::_internal_mutable_selection() { +inline ::substrait::Expression_FieldReference* Expression::_internal_mutable_selection() { if (!_internal_has_selection()) { clear_rex_type(); set_has_selection(); - rex_type_.selection_ = CreateMaybeMessage< ::io::substrait::Expression_FieldReference >(GetArena()); + rex_type_.selection_ = CreateMaybeMessage< ::substrait::Expression_FieldReference >(GetArena()); } return rex_type_.selection_; } -inline ::io::substrait::Expression_FieldReference* Expression::mutable_selection() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.selection) +inline ::substrait::Expression_FieldReference* Expression::mutable_selection() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.selection) return _internal_mutable_selection(); } -// .io.substrait.Expression.ScalarFunction scalar_function = 3; +// .substrait.Expression.ScalarFunction scalar_function = 3; inline bool Expression::_internal_has_scalar_function() const { return rex_type_case() == kScalarFunction; } @@ -16111,11 +15991,11 @@ inline void Expression::clear_scalar_function() { clear_has_rex_type(); } } -inline ::io::substrait::Expression_ScalarFunction* Expression::release_scalar_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.scalar_function) +inline ::substrait::Expression_ScalarFunction* Expression::release_scalar_function() { + // @@protoc_insertion_point(field_release:substrait.Expression.scalar_function) if (_internal_has_scalar_function()) { clear_has_rex_type(); - ::io::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; + ::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -16125,48 +16005,48 @@ inline ::io::substrait::Expression_ScalarFunction* Expression::release_scalar_fu return nullptr; } } -inline const ::io::substrait::Expression_ScalarFunction& Expression::_internal_scalar_function() const { +inline const ::substrait::Expression_ScalarFunction& Expression::_internal_scalar_function() const { return _internal_has_scalar_function() ? *rex_type_.scalar_function_ - : reinterpret_cast< ::io::substrait::Expression_ScalarFunction&>(::io::substrait::_Expression_ScalarFunction_default_instance_); + : reinterpret_cast< ::substrait::Expression_ScalarFunction&>(::substrait::_Expression_ScalarFunction_default_instance_); } -inline const ::io::substrait::Expression_ScalarFunction& Expression::scalar_function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.scalar_function) +inline const ::substrait::Expression_ScalarFunction& Expression::scalar_function() const { + // @@protoc_insertion_point(field_get:substrait.Expression.scalar_function) return _internal_scalar_function(); } -inline ::io::substrait::Expression_ScalarFunction* Expression::unsafe_arena_release_scalar_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.scalar_function) +inline ::substrait::Expression_ScalarFunction* Expression::unsafe_arena_release_scalar_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.scalar_function) if (_internal_has_scalar_function()) { clear_has_rex_type(); - ::io::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; + ::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; rex_type_.scalar_function_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_scalar_function(::io::substrait::Expression_ScalarFunction* scalar_function) { +inline void Expression::unsafe_arena_set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function) { clear_rex_type(); if (scalar_function) { set_has_scalar_function(); rex_type_.scalar_function_ = scalar_function; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.scalar_function) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.scalar_function) } -inline ::io::substrait::Expression_ScalarFunction* Expression::_internal_mutable_scalar_function() { +inline ::substrait::Expression_ScalarFunction* Expression::_internal_mutable_scalar_function() { if (!_internal_has_scalar_function()) { clear_rex_type(); set_has_scalar_function(); - rex_type_.scalar_function_ = CreateMaybeMessage< ::io::substrait::Expression_ScalarFunction >(GetArena()); + rex_type_.scalar_function_ = CreateMaybeMessage< ::substrait::Expression_ScalarFunction >(GetArena()); } return rex_type_.scalar_function_; } -inline ::io::substrait::Expression_ScalarFunction* Expression::mutable_scalar_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.scalar_function) +inline ::substrait::Expression_ScalarFunction* Expression::mutable_scalar_function() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.scalar_function) return _internal_mutable_scalar_function(); } -// .io.substrait.Expression.WindowFunction window_function = 5; +// .substrait.Expression.WindowFunction window_function = 5; inline bool Expression::_internal_has_window_function() const { return rex_type_case() == kWindowFunction; } @@ -16184,11 +16064,11 @@ inline void Expression::clear_window_function() { clear_has_rex_type(); } } -inline ::io::substrait::Expression_WindowFunction* Expression::release_window_function() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.window_function) +inline ::substrait::Expression_WindowFunction* Expression::release_window_function() { + // @@protoc_insertion_point(field_release:substrait.Expression.window_function) if (_internal_has_window_function()) { clear_has_rex_type(); - ::io::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; + ::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -16198,48 +16078,48 @@ inline ::io::substrait::Expression_WindowFunction* Expression::release_window_fu return nullptr; } } -inline const ::io::substrait::Expression_WindowFunction& Expression::_internal_window_function() const { +inline const ::substrait::Expression_WindowFunction& Expression::_internal_window_function() const { return _internal_has_window_function() ? *rex_type_.window_function_ - : reinterpret_cast< ::io::substrait::Expression_WindowFunction&>(::io::substrait::_Expression_WindowFunction_default_instance_); + : reinterpret_cast< ::substrait::Expression_WindowFunction&>(::substrait::_Expression_WindowFunction_default_instance_); } -inline const ::io::substrait::Expression_WindowFunction& Expression::window_function() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.window_function) +inline const ::substrait::Expression_WindowFunction& Expression::window_function() const { + // @@protoc_insertion_point(field_get:substrait.Expression.window_function) return _internal_window_function(); } -inline ::io::substrait::Expression_WindowFunction* Expression::unsafe_arena_release_window_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.window_function) +inline ::substrait::Expression_WindowFunction* Expression::unsafe_arena_release_window_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.window_function) if (_internal_has_window_function()) { clear_has_rex_type(); - ::io::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; + ::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; rex_type_.window_function_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_window_function(::io::substrait::Expression_WindowFunction* window_function) { +inline void Expression::unsafe_arena_set_allocated_window_function(::substrait::Expression_WindowFunction* window_function) { clear_rex_type(); if (window_function) { set_has_window_function(); rex_type_.window_function_ = window_function; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.window_function) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.window_function) } -inline ::io::substrait::Expression_WindowFunction* Expression::_internal_mutable_window_function() { +inline ::substrait::Expression_WindowFunction* Expression::_internal_mutable_window_function() { if (!_internal_has_window_function()) { clear_rex_type(); set_has_window_function(); - rex_type_.window_function_ = CreateMaybeMessage< ::io::substrait::Expression_WindowFunction >(GetArena()); + rex_type_.window_function_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction >(GetArena()); } return rex_type_.window_function_; } -inline ::io::substrait::Expression_WindowFunction* Expression::mutable_window_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.window_function) +inline ::substrait::Expression_WindowFunction* Expression::mutable_window_function() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.window_function) return _internal_mutable_window_function(); } -// .io.substrait.Expression.IfThen if_then = 6; +// .substrait.Expression.IfThen if_then = 6; inline bool Expression::_internal_has_if_then() const { return rex_type_case() == kIfThen; } @@ -16257,11 +16137,11 @@ inline void Expression::clear_if_then() { clear_has_rex_type(); } } -inline ::io::substrait::Expression_IfThen* Expression::release_if_then() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.if_then) +inline ::substrait::Expression_IfThen* Expression::release_if_then() { + // @@protoc_insertion_point(field_release:substrait.Expression.if_then) if (_internal_has_if_then()) { clear_has_rex_type(); - ::io::substrait::Expression_IfThen* temp = rex_type_.if_then_; + ::substrait::Expression_IfThen* temp = rex_type_.if_then_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -16271,48 +16151,48 @@ inline ::io::substrait::Expression_IfThen* Expression::release_if_then() { return nullptr; } } -inline const ::io::substrait::Expression_IfThen& Expression::_internal_if_then() const { +inline const ::substrait::Expression_IfThen& Expression::_internal_if_then() const { return _internal_has_if_then() ? *rex_type_.if_then_ - : reinterpret_cast< ::io::substrait::Expression_IfThen&>(::io::substrait::_Expression_IfThen_default_instance_); + : reinterpret_cast< ::substrait::Expression_IfThen&>(::substrait::_Expression_IfThen_default_instance_); } -inline const ::io::substrait::Expression_IfThen& Expression::if_then() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.if_then) +inline const ::substrait::Expression_IfThen& Expression::if_then() const { + // @@protoc_insertion_point(field_get:substrait.Expression.if_then) return _internal_if_then(); } -inline ::io::substrait::Expression_IfThen* Expression::unsafe_arena_release_if_then() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.if_then) +inline ::substrait::Expression_IfThen* Expression::unsafe_arena_release_if_then() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.if_then) if (_internal_has_if_then()) { clear_has_rex_type(); - ::io::substrait::Expression_IfThen* temp = rex_type_.if_then_; + ::substrait::Expression_IfThen* temp = rex_type_.if_then_; rex_type_.if_then_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_if_then(::io::substrait::Expression_IfThen* if_then) { +inline void Expression::unsafe_arena_set_allocated_if_then(::substrait::Expression_IfThen* if_then) { clear_rex_type(); if (if_then) { set_has_if_then(); rex_type_.if_then_ = if_then; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.if_then) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.if_then) } -inline ::io::substrait::Expression_IfThen* Expression::_internal_mutable_if_then() { +inline ::substrait::Expression_IfThen* Expression::_internal_mutable_if_then() { if (!_internal_has_if_then()) { clear_rex_type(); set_has_if_then(); - rex_type_.if_then_ = CreateMaybeMessage< ::io::substrait::Expression_IfThen >(GetArena()); + rex_type_.if_then_ = CreateMaybeMessage< ::substrait::Expression_IfThen >(GetArena()); } return rex_type_.if_then_; } -inline ::io::substrait::Expression_IfThen* Expression::mutable_if_then() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.if_then) +inline ::substrait::Expression_IfThen* Expression::mutable_if_then() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.if_then) return _internal_mutable_if_then(); } -// .io.substrait.Expression.SwitchExpression switch_expression = 7; +// .substrait.Expression.SwitchExpression switch_expression = 7; inline bool Expression::_internal_has_switch_expression() const { return rex_type_case() == kSwitchExpression; } @@ -16330,11 +16210,11 @@ inline void Expression::clear_switch_expression() { clear_has_rex_type(); } } -inline ::io::substrait::Expression_SwitchExpression* Expression::release_switch_expression() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.switch_expression) +inline ::substrait::Expression_SwitchExpression* Expression::release_switch_expression() { + // @@protoc_insertion_point(field_release:substrait.Expression.switch_expression) if (_internal_has_switch_expression()) { clear_has_rex_type(); - ::io::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; + ::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -16344,48 +16224,48 @@ inline ::io::substrait::Expression_SwitchExpression* Expression::release_switch_ return nullptr; } } -inline const ::io::substrait::Expression_SwitchExpression& Expression::_internal_switch_expression() const { +inline const ::substrait::Expression_SwitchExpression& Expression::_internal_switch_expression() const { return _internal_has_switch_expression() ? *rex_type_.switch_expression_ - : reinterpret_cast< ::io::substrait::Expression_SwitchExpression&>(::io::substrait::_Expression_SwitchExpression_default_instance_); + : reinterpret_cast< ::substrait::Expression_SwitchExpression&>(::substrait::_Expression_SwitchExpression_default_instance_); } -inline const ::io::substrait::Expression_SwitchExpression& Expression::switch_expression() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.switch_expression) +inline const ::substrait::Expression_SwitchExpression& Expression::switch_expression() const { + // @@protoc_insertion_point(field_get:substrait.Expression.switch_expression) return _internal_switch_expression(); } -inline ::io::substrait::Expression_SwitchExpression* Expression::unsafe_arena_release_switch_expression() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.switch_expression) +inline ::substrait::Expression_SwitchExpression* Expression::unsafe_arena_release_switch_expression() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.switch_expression) if (_internal_has_switch_expression()) { clear_has_rex_type(); - ::io::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; + ::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; rex_type_.switch_expression_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_switch_expression(::io::substrait::Expression_SwitchExpression* switch_expression) { +inline void Expression::unsafe_arena_set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression) { clear_rex_type(); if (switch_expression) { set_has_switch_expression(); rex_type_.switch_expression_ = switch_expression; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.switch_expression) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.switch_expression) } -inline ::io::substrait::Expression_SwitchExpression* Expression::_internal_mutable_switch_expression() { +inline ::substrait::Expression_SwitchExpression* Expression::_internal_mutable_switch_expression() { if (!_internal_has_switch_expression()) { clear_rex_type(); set_has_switch_expression(); - rex_type_.switch_expression_ = CreateMaybeMessage< ::io::substrait::Expression_SwitchExpression >(GetArena()); + rex_type_.switch_expression_ = CreateMaybeMessage< ::substrait::Expression_SwitchExpression >(GetArena()); } return rex_type_.switch_expression_; } -inline ::io::substrait::Expression_SwitchExpression* Expression::mutable_switch_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.switch_expression) +inline ::substrait::Expression_SwitchExpression* Expression::mutable_switch_expression() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.switch_expression) return _internal_mutable_switch_expression(); } -// .io.substrait.Expression.SingularOrList singular_or_list = 8; +// .substrait.Expression.SingularOrList singular_or_list = 8; inline bool Expression::_internal_has_singular_or_list() const { return rex_type_case() == kSingularOrList; } @@ -16403,11 +16283,11 @@ inline void Expression::clear_singular_or_list() { clear_has_rex_type(); } } -inline ::io::substrait::Expression_SingularOrList* Expression::release_singular_or_list() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.singular_or_list) +inline ::substrait::Expression_SingularOrList* Expression::release_singular_or_list() { + // @@protoc_insertion_point(field_release:substrait.Expression.singular_or_list) if (_internal_has_singular_or_list()) { clear_has_rex_type(); - ::io::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; + ::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -16417,48 +16297,48 @@ inline ::io::substrait::Expression_SingularOrList* Expression::release_singular_ return nullptr; } } -inline const ::io::substrait::Expression_SingularOrList& Expression::_internal_singular_or_list() const { +inline const ::substrait::Expression_SingularOrList& Expression::_internal_singular_or_list() const { return _internal_has_singular_or_list() ? *rex_type_.singular_or_list_ - : reinterpret_cast< ::io::substrait::Expression_SingularOrList&>(::io::substrait::_Expression_SingularOrList_default_instance_); + : reinterpret_cast< ::substrait::Expression_SingularOrList&>(::substrait::_Expression_SingularOrList_default_instance_); } -inline const ::io::substrait::Expression_SingularOrList& Expression::singular_or_list() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.singular_or_list) +inline const ::substrait::Expression_SingularOrList& Expression::singular_or_list() const { + // @@protoc_insertion_point(field_get:substrait.Expression.singular_or_list) return _internal_singular_or_list(); } -inline ::io::substrait::Expression_SingularOrList* Expression::unsafe_arena_release_singular_or_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.singular_or_list) +inline ::substrait::Expression_SingularOrList* Expression::unsafe_arena_release_singular_or_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.singular_or_list) if (_internal_has_singular_or_list()) { clear_has_rex_type(); - ::io::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; + ::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; rex_type_.singular_or_list_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_singular_or_list(::io::substrait::Expression_SingularOrList* singular_or_list) { +inline void Expression::unsafe_arena_set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list) { clear_rex_type(); if (singular_or_list) { set_has_singular_or_list(); rex_type_.singular_or_list_ = singular_or_list; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.singular_or_list) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.singular_or_list) } -inline ::io::substrait::Expression_SingularOrList* Expression::_internal_mutable_singular_or_list() { +inline ::substrait::Expression_SingularOrList* Expression::_internal_mutable_singular_or_list() { if (!_internal_has_singular_or_list()) { clear_rex_type(); set_has_singular_or_list(); - rex_type_.singular_or_list_ = CreateMaybeMessage< ::io::substrait::Expression_SingularOrList >(GetArena()); + rex_type_.singular_or_list_ = CreateMaybeMessage< ::substrait::Expression_SingularOrList >(GetArena()); } return rex_type_.singular_or_list_; } -inline ::io::substrait::Expression_SingularOrList* Expression::mutable_singular_or_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.singular_or_list) +inline ::substrait::Expression_SingularOrList* Expression::mutable_singular_or_list() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.singular_or_list) return _internal_mutable_singular_or_list(); } -// .io.substrait.Expression.MultiOrList multi_or_list = 9; +// .substrait.Expression.MultiOrList multi_or_list = 9; inline bool Expression::_internal_has_multi_or_list() const { return rex_type_case() == kMultiOrList; } @@ -16476,11 +16356,11 @@ inline void Expression::clear_multi_or_list() { clear_has_rex_type(); } } -inline ::io::substrait::Expression_MultiOrList* Expression::release_multi_or_list() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.multi_or_list) +inline ::substrait::Expression_MultiOrList* Expression::release_multi_or_list() { + // @@protoc_insertion_point(field_release:substrait.Expression.multi_or_list) if (_internal_has_multi_or_list()) { clear_has_rex_type(); - ::io::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; + ::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -16490,48 +16370,48 @@ inline ::io::substrait::Expression_MultiOrList* Expression::release_multi_or_lis return nullptr; } } -inline const ::io::substrait::Expression_MultiOrList& Expression::_internal_multi_or_list() const { +inline const ::substrait::Expression_MultiOrList& Expression::_internal_multi_or_list() const { return _internal_has_multi_or_list() ? *rex_type_.multi_or_list_ - : reinterpret_cast< ::io::substrait::Expression_MultiOrList&>(::io::substrait::_Expression_MultiOrList_default_instance_); + : reinterpret_cast< ::substrait::Expression_MultiOrList&>(::substrait::_Expression_MultiOrList_default_instance_); } -inline const ::io::substrait::Expression_MultiOrList& Expression::multi_or_list() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.multi_or_list) +inline const ::substrait::Expression_MultiOrList& Expression::multi_or_list() const { + // @@protoc_insertion_point(field_get:substrait.Expression.multi_or_list) return _internal_multi_or_list(); } -inline ::io::substrait::Expression_MultiOrList* Expression::unsafe_arena_release_multi_or_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.multi_or_list) +inline ::substrait::Expression_MultiOrList* Expression::unsafe_arena_release_multi_or_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.multi_or_list) if (_internal_has_multi_or_list()) { clear_has_rex_type(); - ::io::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; + ::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; rex_type_.multi_or_list_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_multi_or_list(::io::substrait::Expression_MultiOrList* multi_or_list) { +inline void Expression::unsafe_arena_set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list) { clear_rex_type(); if (multi_or_list) { set_has_multi_or_list(); rex_type_.multi_or_list_ = multi_or_list; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.multi_or_list) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.multi_or_list) } -inline ::io::substrait::Expression_MultiOrList* Expression::_internal_mutable_multi_or_list() { +inline ::substrait::Expression_MultiOrList* Expression::_internal_mutable_multi_or_list() { if (!_internal_has_multi_or_list()) { clear_rex_type(); set_has_multi_or_list(); - rex_type_.multi_or_list_ = CreateMaybeMessage< ::io::substrait::Expression_MultiOrList >(GetArena()); + rex_type_.multi_or_list_ = CreateMaybeMessage< ::substrait::Expression_MultiOrList >(GetArena()); } return rex_type_.multi_or_list_; } -inline ::io::substrait::Expression_MultiOrList* Expression::mutable_multi_or_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.multi_or_list) +inline ::substrait::Expression_MultiOrList* Expression::mutable_multi_or_list() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.multi_or_list) return _internal_mutable_multi_or_list(); } -// .io.substrait.Expression.Enum enum = 10; +// .substrait.Expression.Enum enum = 10; inline bool Expression::_internal_has_enum_() const { return rex_type_case() == kEnum; } @@ -16549,11 +16429,11 @@ inline void Expression::clear_enum_() { clear_has_rex_type(); } } -inline ::io::substrait::Expression_Enum* Expression::release_enum_() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.enum) +inline ::substrait::Expression_Enum* Expression::release_enum_() { + // @@protoc_insertion_point(field_release:substrait.Expression.enum) if (_internal_has_enum_()) { clear_has_rex_type(); - ::io::substrait::Expression_Enum* temp = rex_type_.enum__; + ::substrait::Expression_Enum* temp = rex_type_.enum__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -16563,48 +16443,48 @@ inline ::io::substrait::Expression_Enum* Expression::release_enum_() { return nullptr; } } -inline const ::io::substrait::Expression_Enum& Expression::_internal_enum_() const { +inline const ::substrait::Expression_Enum& Expression::_internal_enum_() const { return _internal_has_enum_() ? *rex_type_.enum__ - : reinterpret_cast< ::io::substrait::Expression_Enum&>(::io::substrait::_Expression_Enum_default_instance_); + : reinterpret_cast< ::substrait::Expression_Enum&>(::substrait::_Expression_Enum_default_instance_); } -inline const ::io::substrait::Expression_Enum& Expression::enum_() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.enum) +inline const ::substrait::Expression_Enum& Expression::enum_() const { + // @@protoc_insertion_point(field_get:substrait.Expression.enum) return _internal_enum_(); } -inline ::io::substrait::Expression_Enum* Expression::unsafe_arena_release_enum_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.enum) +inline ::substrait::Expression_Enum* Expression::unsafe_arena_release_enum_() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.enum) if (_internal_has_enum_()) { clear_has_rex_type(); - ::io::substrait::Expression_Enum* temp = rex_type_.enum__; + ::substrait::Expression_Enum* temp = rex_type_.enum__; rex_type_.enum__ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_enum_(::io::substrait::Expression_Enum* enum_) { +inline void Expression::unsafe_arena_set_allocated_enum_(::substrait::Expression_Enum* enum_) { clear_rex_type(); if (enum_) { set_has_enum_(); rex_type_.enum__ = enum_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.enum) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.enum) } -inline ::io::substrait::Expression_Enum* Expression::_internal_mutable_enum_() { +inline ::substrait::Expression_Enum* Expression::_internal_mutable_enum_() { if (!_internal_has_enum_()) { clear_rex_type(); set_has_enum_(); - rex_type_.enum__ = CreateMaybeMessage< ::io::substrait::Expression_Enum >(GetArena()); + rex_type_.enum__ = CreateMaybeMessage< ::substrait::Expression_Enum >(GetArena()); } return rex_type_.enum__; } -inline ::io::substrait::Expression_Enum* Expression::mutable_enum_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.enum) +inline ::substrait::Expression_Enum* Expression::mutable_enum_() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.enum) return _internal_mutable_enum_(); } -// .io.substrait.Expression.Cast cast = 11; +// .substrait.Expression.Cast cast = 11; inline bool Expression::_internal_has_cast() const { return rex_type_case() == kCast; } @@ -16622,11 +16502,11 @@ inline void Expression::clear_cast() { clear_has_rex_type(); } } -inline ::io::substrait::Expression_Cast* Expression::release_cast() { - // @@protoc_insertion_point(field_release:io.substrait.Expression.cast) +inline ::substrait::Expression_Cast* Expression::release_cast() { + // @@protoc_insertion_point(field_release:substrait.Expression.cast) if (_internal_has_cast()) { clear_has_rex_type(); - ::io::substrait::Expression_Cast* temp = rex_type_.cast_; + ::substrait::Expression_Cast* temp = rex_type_.cast_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -16636,44 +16516,44 @@ inline ::io::substrait::Expression_Cast* Expression::release_cast() { return nullptr; } } -inline const ::io::substrait::Expression_Cast& Expression::_internal_cast() const { +inline const ::substrait::Expression_Cast& Expression::_internal_cast() const { return _internal_has_cast() ? *rex_type_.cast_ - : reinterpret_cast< ::io::substrait::Expression_Cast&>(::io::substrait::_Expression_Cast_default_instance_); + : reinterpret_cast< ::substrait::Expression_Cast&>(::substrait::_Expression_Cast_default_instance_); } -inline const ::io::substrait::Expression_Cast& Expression::cast() const { - // @@protoc_insertion_point(field_get:io.substrait.Expression.cast) +inline const ::substrait::Expression_Cast& Expression::cast() const { + // @@protoc_insertion_point(field_get:substrait.Expression.cast) return _internal_cast(); } -inline ::io::substrait::Expression_Cast* Expression::unsafe_arena_release_cast() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Expression.cast) +inline ::substrait::Expression_Cast* Expression::unsafe_arena_release_cast() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.cast) if (_internal_has_cast()) { clear_has_rex_type(); - ::io::substrait::Expression_Cast* temp = rex_type_.cast_; + ::substrait::Expression_Cast* temp = rex_type_.cast_; rex_type_.cast_ = nullptr; return temp; } else { return nullptr; } } -inline void Expression::unsafe_arena_set_allocated_cast(::io::substrait::Expression_Cast* cast) { +inline void Expression::unsafe_arena_set_allocated_cast(::substrait::Expression_Cast* cast) { clear_rex_type(); if (cast) { set_has_cast(); rex_type_.cast_ = cast; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Expression.cast) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.cast) } -inline ::io::substrait::Expression_Cast* Expression::_internal_mutable_cast() { +inline ::substrait::Expression_Cast* Expression::_internal_mutable_cast() { if (!_internal_has_cast()) { clear_rex_type(); set_has_cast(); - rex_type_.cast_ = CreateMaybeMessage< ::io::substrait::Expression_Cast >(GetArena()); + rex_type_.cast_ = CreateMaybeMessage< ::substrait::Expression_Cast >(GetArena()); } return rex_type_.cast_; } -inline ::io::substrait::Expression_Cast* Expression::mutable_cast() { - // @@protoc_insertion_point(field_mutable:io.substrait.Expression.cast) +inline ::substrait::Expression_Cast* Expression::mutable_cast() { + // @@protoc_insertion_point(field_mutable:substrait.Expression.cast) return _internal_mutable_cast(); } @@ -16690,7 +16570,7 @@ inline Expression::RexTypeCase Expression::rex_type_case() const { // SortField -// .io.substrait.Expression expr = 1; +// .substrait.Expression expr = 1; inline bool SortField::_internal_has_expr() const { return this != internal_default_instance() && expr_ != nullptr; } @@ -16703,17 +16583,17 @@ inline void SortField::clear_expr() { } expr_ = nullptr; } -inline const ::io::substrait::Expression& SortField::_internal_expr() const { - const ::io::substrait::Expression* p = expr_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& SortField::_internal_expr() const { + const ::substrait::Expression* p = expr_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& SortField::expr() const { - // @@protoc_insertion_point(field_get:io.substrait.SortField.expr) +inline const ::substrait::Expression& SortField::expr() const { + // @@protoc_insertion_point(field_get:substrait.SortField.expr) return _internal_expr(); } inline void SortField::unsafe_arena_set_allocated_expr( - ::io::substrait::Expression* expr) { + ::substrait::Expression* expr) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_); } @@ -16723,37 +16603,37 @@ inline void SortField::unsafe_arena_set_allocated_expr( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortField.expr) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortField.expr) } -inline ::io::substrait::Expression* SortField::release_expr() { +inline ::substrait::Expression* SortField::release_expr() { - ::io::substrait::Expression* temp = expr_; + ::substrait::Expression* temp = expr_; expr_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* SortField::unsafe_arena_release_expr() { - // @@protoc_insertion_point(field_release:io.substrait.SortField.expr) +inline ::substrait::Expression* SortField::unsafe_arena_release_expr() { + // @@protoc_insertion_point(field_release:substrait.SortField.expr) - ::io::substrait::Expression* temp = expr_; + ::substrait::Expression* temp = expr_; expr_ = nullptr; return temp; } -inline ::io::substrait::Expression* SortField::_internal_mutable_expr() { +inline ::substrait::Expression* SortField::_internal_mutable_expr() { if (expr_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); expr_ = p; } return expr_; } -inline ::io::substrait::Expression* SortField::mutable_expr() { - // @@protoc_insertion_point(field_mutable:io.substrait.SortField.expr) +inline ::substrait::Expression* SortField::mutable_expr() { + // @@protoc_insertion_point(field_mutable:substrait.SortField.expr) return _internal_mutable_expr(); } -inline void SortField::set_allocated_expr(::io::substrait::Expression* expr) { +inline void SortField::set_allocated_expr(::substrait::Expression* expr) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete expr_; @@ -16770,10 +16650,10 @@ inline void SortField::set_allocated_expr(::io::substrait::Expression* expr) { } expr_ = expr; - // @@protoc_insertion_point(field_set_allocated:io.substrait.SortField.expr) + // @@protoc_insertion_point(field_set_allocated:substrait.SortField.expr) } -// .io.substrait.SortField.SortDirection direction = 2; +// .substrait.SortField.SortDirection direction = 2; inline bool SortField::_internal_has_direction() const { return sort_kind_case() == kDirection; } @@ -16789,25 +16669,25 @@ inline void SortField::clear_direction() { clear_has_sort_kind(); } } -inline ::io::substrait::SortField_SortDirection SortField::_internal_direction() const { +inline ::substrait::SortField_SortDirection SortField::_internal_direction() const { if (_internal_has_direction()) { - return static_cast< ::io::substrait::SortField_SortDirection >(sort_kind_.direction_); + return static_cast< ::substrait::SortField_SortDirection >(sort_kind_.direction_); } - return static_cast< ::io::substrait::SortField_SortDirection >(0); + return static_cast< ::substrait::SortField_SortDirection >(0); } -inline ::io::substrait::SortField_SortDirection SortField::direction() const { - // @@protoc_insertion_point(field_get:io.substrait.SortField.direction) +inline ::substrait::SortField_SortDirection SortField::direction() const { + // @@protoc_insertion_point(field_get:substrait.SortField.direction) return _internal_direction(); } -inline void SortField::_internal_set_direction(::io::substrait::SortField_SortDirection value) { +inline void SortField::_internal_set_direction(::substrait::SortField_SortDirection value) { if (!_internal_has_direction()) { clear_sort_kind(); set_has_direction(); } sort_kind_.direction_ = value; } -inline void SortField::set_direction(::io::substrait::SortField_SortDirection value) { - // @@protoc_insertion_point(field_set:io.substrait.SortField.direction) +inline void SortField::set_direction(::substrait::SortField_SortDirection value) { + // @@protoc_insertion_point(field_set:substrait.SortField.direction) _internal_set_direction(value); } @@ -16841,12 +16721,12 @@ inline void SortField::_internal_set_comparison_function_reference(::PROTOBUF_NA sort_kind_.comparison_function_reference_ = value; } inline ::PROTOBUF_NAMESPACE_ID::uint32 SortField::comparison_function_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.SortField.comparison_function_reference) + // @@protoc_insertion_point(field_get:substrait.SortField.comparison_function_reference) return _internal_comparison_function_reference(); } inline void SortField::set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_comparison_function_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.SortField.comparison_function_reference) + // @@protoc_insertion_point(field_set:substrait.SortField.comparison_function_reference) } inline bool SortField::has_sort_kind() const { @@ -16870,7 +16750,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 AggregateFunction::_internal_function_ref return function_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 AggregateFunction::function_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateFunction.function_reference) + // @@protoc_insertion_point(field_get:substrait.AggregateFunction.function_reference) return _internal_function_reference(); } inline void AggregateFunction::_internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -16879,10 +16759,10 @@ inline void AggregateFunction::_internal_set_function_reference(::PROTOBUF_NAMES } inline void AggregateFunction::set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_function_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.AggregateFunction.function_reference) + // @@protoc_insertion_point(field_set:substrait.AggregateFunction.function_reference) } -// repeated .io.substrait.Expression args = 2; +// repeated .substrait.Expression args = 2; inline int AggregateFunction::_internal_args_size() const { return args_.size(); } @@ -16892,36 +16772,36 @@ inline int AggregateFunction::args_size() const { inline void AggregateFunction::clear_args() { args_.Clear(); } -inline ::io::substrait::Expression* AggregateFunction::mutable_args(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateFunction.args) +inline ::substrait::Expression* AggregateFunction::mutable_args(int index) { + // @@protoc_insertion_point(field_mutable:substrait.AggregateFunction.args) return args_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* AggregateFunction::mutable_args() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateFunction.args) + // @@protoc_insertion_point(field_mutable_list:substrait.AggregateFunction.args) return &args_; } -inline const ::io::substrait::Expression& AggregateFunction::_internal_args(int index) const { +inline const ::substrait::Expression& AggregateFunction::_internal_args(int index) const { return args_.Get(index); } -inline const ::io::substrait::Expression& AggregateFunction::args(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateFunction.args) +inline const ::substrait::Expression& AggregateFunction::args(int index) const { + // @@protoc_insertion_point(field_get:substrait.AggregateFunction.args) return _internal_args(index); } -inline ::io::substrait::Expression* AggregateFunction::_internal_add_args() { +inline ::substrait::Expression* AggregateFunction::_internal_add_args() { return args_.Add(); } -inline ::io::substrait::Expression* AggregateFunction::add_args() { - // @@protoc_insertion_point(field_add:io.substrait.AggregateFunction.args) +inline ::substrait::Expression* AggregateFunction::add_args() { + // @@protoc_insertion_point(field_add:substrait.AggregateFunction.args) return _internal_add_args(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& AggregateFunction::args() const { - // @@protoc_insertion_point(field_list:io.substrait.AggregateFunction.args) + // @@protoc_insertion_point(field_list:substrait.AggregateFunction.args) return args_; } -// repeated .io.substrait.SortField sorts = 3; +// repeated .substrait.SortField sorts = 3; inline int AggregateFunction::_internal_sorts_size() const { return sorts_.size(); } @@ -16931,73 +16811,73 @@ inline int AggregateFunction::sorts_size() const { inline void AggregateFunction::clear_sorts() { sorts_.Clear(); } -inline ::io::substrait::SortField* AggregateFunction::mutable_sorts(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateFunction.sorts) +inline ::substrait::SortField* AggregateFunction::mutable_sorts(int index) { + // @@protoc_insertion_point(field_mutable:substrait.AggregateFunction.sorts) return sorts_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* AggregateFunction::mutable_sorts() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateFunction.sorts) + // @@protoc_insertion_point(field_mutable_list:substrait.AggregateFunction.sorts) return &sorts_; } -inline const ::io::substrait::SortField& AggregateFunction::_internal_sorts(int index) const { +inline const ::substrait::SortField& AggregateFunction::_internal_sorts(int index) const { return sorts_.Get(index); } -inline const ::io::substrait::SortField& AggregateFunction::sorts(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateFunction.sorts) +inline const ::substrait::SortField& AggregateFunction::sorts(int index) const { + // @@protoc_insertion_point(field_get:substrait.AggregateFunction.sorts) return _internal_sorts(index); } -inline ::io::substrait::SortField* AggregateFunction::_internal_add_sorts() { +inline ::substrait::SortField* AggregateFunction::_internal_add_sorts() { return sorts_.Add(); } -inline ::io::substrait::SortField* AggregateFunction::add_sorts() { - // @@protoc_insertion_point(field_add:io.substrait.AggregateFunction.sorts) +inline ::substrait::SortField* AggregateFunction::add_sorts() { + // @@protoc_insertion_point(field_add:substrait.AggregateFunction.sorts) return _internal_add_sorts(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& AggregateFunction::sorts() const { - // @@protoc_insertion_point(field_list:io.substrait.AggregateFunction.sorts) + // @@protoc_insertion_point(field_list:substrait.AggregateFunction.sorts) return sorts_; } -// .io.substrait.AggregationPhase phase = 4; +// .substrait.AggregationPhase phase = 4; inline void AggregateFunction::clear_phase() { phase_ = 0; } -inline ::io::substrait::AggregationPhase AggregateFunction::_internal_phase() const { - return static_cast< ::io::substrait::AggregationPhase >(phase_); +inline ::substrait::AggregationPhase AggregateFunction::_internal_phase() const { + return static_cast< ::substrait::AggregationPhase >(phase_); } -inline ::io::substrait::AggregationPhase AggregateFunction::phase() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateFunction.phase) +inline ::substrait::AggregationPhase AggregateFunction::phase() const { + // @@protoc_insertion_point(field_get:substrait.AggregateFunction.phase) return _internal_phase(); } -inline void AggregateFunction::_internal_set_phase(::io::substrait::AggregationPhase value) { +inline void AggregateFunction::_internal_set_phase(::substrait::AggregationPhase value) { phase_ = value; } -inline void AggregateFunction::set_phase(::io::substrait::AggregationPhase value) { +inline void AggregateFunction::set_phase(::substrait::AggregationPhase value) { _internal_set_phase(value); - // @@protoc_insertion_point(field_set:io.substrait.AggregateFunction.phase) + // @@protoc_insertion_point(field_set:substrait.AggregateFunction.phase) } -// .io.substrait.Type output_type = 5; +// .substrait.Type output_type = 5; inline bool AggregateFunction::_internal_has_output_type() const { return this != internal_default_instance() && output_type_ != nullptr; } inline bool AggregateFunction::has_output_type() const { return _internal_has_output_type(); } -inline const ::io::substrait::Type& AggregateFunction::_internal_output_type() const { - const ::io::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline const ::substrait::Type& AggregateFunction::_internal_output_type() const { + const ::substrait::Type* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Type_default_instance_); } -inline const ::io::substrait::Type& AggregateFunction::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateFunction.output_type) +inline const ::substrait::Type& AggregateFunction::output_type() const { + // @@protoc_insertion_point(field_get:substrait.AggregateFunction.output_type) return _internal_output_type(); } inline void AggregateFunction::unsafe_arena_set_allocated_output_type( - ::io::substrait::Type* output_type) { + ::substrait::Type* output_type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } @@ -17007,37 +16887,37 @@ inline void AggregateFunction::unsafe_arena_set_allocated_output_type( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateFunction.output_type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateFunction.output_type) } -inline ::io::substrait::Type* AggregateFunction::release_output_type() { +inline ::substrait::Type* AggregateFunction::release_output_type() { - ::io::substrait::Type* temp = output_type_; + ::substrait::Type* temp = output_type_; output_type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type* AggregateFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.AggregateFunction.output_type) +inline ::substrait::Type* AggregateFunction::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:substrait.AggregateFunction.output_type) - ::io::substrait::Type* temp = output_type_; + ::substrait::Type* temp = output_type_; output_type_ = nullptr; return temp; } -inline ::io::substrait::Type* AggregateFunction::_internal_mutable_output_type() { +inline ::substrait::Type* AggregateFunction::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); output_type_ = p; } return output_type_; } -inline ::io::substrait::Type* AggregateFunction::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateFunction.output_type) +inline ::substrait::Type* AggregateFunction::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:substrait.AggregateFunction.output_type) return _internal_mutable_output_type(); } -inline void AggregateFunction::set_allocated_output_type(::io::substrait::Type* output_type) { +inline void AggregateFunction::set_allocated_output_type(::substrait::Type* output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); @@ -17054,7 +16934,7 @@ inline void AggregateFunction::set_allocated_output_type(::io::substrait::Type* } output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateFunction.output_type) + // @@protoc_insertion_point(field_set_allocated:substrait.AggregateFunction.output_type) } #ifdef __GNUC__ @@ -17160,19 +17040,18 @@ inline void AggregateFunction::set_allocated_output_type(::io::substrait::Type* // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template <> struct is_proto_enum< ::io::substrait::SortField_SortDirection> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::SortField_SortDirection> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::SortField_SortDirection>() { - return ::io::substrait::SortField_SortDirection_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::SortField_SortDirection>() { + return ::substrait::SortField_SortDirection_descriptor(); } -template <> struct is_proto_enum< ::io::substrait::AggregationPhase> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::AggregationPhase> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::AggregationPhase>() { - return ::io::substrait::AggregationPhase_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::AggregationPhase>() { + return ::substrait::AggregationPhase_descriptor(); } PROTOBUF_NAMESPACE_CLOSE @@ -17180,4 +17059,4 @@ PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_expression_2eproto +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fexpression_2eproto diff --git a/cpp/src/generated/substrait/extensions/extensions.pb.cc b/cpp/src/generated/substrait/extensions/extensions.pb.cc new file mode 100644 index 00000000000..395295144e7 --- /dev/null +++ b/cpp/src/generated/substrait/extensions/extensions.pb.cc @@ -0,0 +1,1891 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: substrait/extensions/extensions.proto + +#include "substrait/extensions/extensions.pb.h" + +#include + +#include +#include +#include +#include +#include +#include +#include +// @@protoc_insertion_point(includes) +#include + +PROTOBUF_PRAGMA_INIT_SEG +namespace substrait { +namespace extensions { +constexpr SimpleExtensionURI::SimpleExtensionURI( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , extension_uri_anchor_(0u){} +struct SimpleExtensionURIDefaultTypeInternal { + constexpr SimpleExtensionURIDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SimpleExtensionURIDefaultTypeInternal() {} + union { + SimpleExtensionURI _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionURIDefaultTypeInternal _SimpleExtensionURI_default_instance_; +constexpr SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , extension_uri_reference_(0u) + , type_anchor_(0u){} +struct SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal { + constexpr SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal() {} + union { + SimpleExtensionDeclaration_ExtensionType _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionType_default_instance_; +constexpr SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , extension_uri_reference_(0u) + , type_variation_anchor_(0u){} +struct SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal { + constexpr SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal() {} + union { + SimpleExtensionDeclaration_ExtensionTypeVariation _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_; +constexpr SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) + , extension_uri_reference_(0u) + , function_anchor_(0u){} +struct SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal { + constexpr SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal() {} + union { + SimpleExtensionDeclaration_ExtensionFunction _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionFunction_default_instance_; +constexpr SimpleExtensionDeclaration::SimpleExtensionDeclaration( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : _oneof_case_{}{} +struct SimpleExtensionDeclarationDefaultTypeInternal { + constexpr SimpleExtensionDeclarationDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~SimpleExtensionDeclarationDefaultTypeInternal() {} + union { + SimpleExtensionDeclaration _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclarationDefaultTypeInternal _SimpleExtensionDeclaration_default_instance_; +constexpr AdvancedExtension::AdvancedExtension( + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) + : optimization_(nullptr) + , enhancement_(nullptr){} +struct AdvancedExtensionDefaultTypeInternal { + constexpr AdvancedExtensionDefaultTypeInternal() + : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} + ~AdvancedExtensionDefaultTypeInternal() {} + union { + AdvancedExtension _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AdvancedExtensionDefaultTypeInternal _AdvancedExtension_default_instance_; +} // namespace extensions +} // namespace substrait +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fextensions_2fextensions_2eproto[6]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fextensions_2fextensions_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fextensions_2fextensions_2eproto = nullptr; + +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fextensions_2fextensions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, extension_uri_anchor_), + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, uri_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, type_anchor_), + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_), + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, extension_uri_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, function_anchor_), + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, name_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration, _internal_metadata_), + ~0u, // no _extensions_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration, _oneof_case_[0]), + ~0u, // no _weak_field_map_ + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, + PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration, mapping_type_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, optimization_), + PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, enhancement_), +}; +static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { + { 0, -1, sizeof(::substrait::extensions::SimpleExtensionURI)}, + { 7, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType)}, + { 15, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation)}, + { 23, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction)}, + { 31, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration)}, + { 40, -1, sizeof(::substrait::extensions::AdvancedExtension)}, +}; + +static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { + reinterpret_cast(&::substrait::extensions::_SimpleExtensionURI_default_instance_), + reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_), + reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_), + reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_), + reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_default_instance_), + reinterpret_cast(&::substrait::extensions::_AdvancedExtension_default_instance_), +}; + +const char descriptor_table_protodef_substrait_2fextensions_2fextensions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n%substrait/extensions/extensions.proto\022" + "\024substrait.extensions\032\031google/protobuf/a" + "ny.proto\"\?\n\022SimpleExtensionURI\022\034\n\024extens" + "ion_uri_anchor\030\001 \001(\r\022\013\n\003uri\030\002 \001(\t\"\357\004\n\032Si" + "mpleExtensionDeclaration\022X\n\016extension_ty" + "pe\030\001 \001(\0132>.substrait.extensions.SimpleEx" + "tensionDeclaration.ExtensionTypeH\000\022k\n\030ex" + "tension_type_variation\030\002 \001(\0132G.substrait" + ".extensions.SimpleExtensionDeclaration.E" + "xtensionTypeVariationH\000\022`\n\022extension_fun" + "ction\030\003 \001(\0132B.substrait.extensions.Simpl" + "eExtensionDeclaration.ExtensionFunctionH" + "\000\032S\n\rExtensionType\022\037\n\027extension_uri_refe" + "rence\030\001 \001(\r\022\023\n\013type_anchor\030\002 \001(\r\022\014\n\004name" + "\030\003 \001(\t\032f\n\026ExtensionTypeVariation\022\037\n\027exte" + "nsion_uri_reference\030\001 \001(\r\022\035\n\025type_variat" + "ion_anchor\030\002 \001(\r\022\014\n\004name\030\003 \001(\t\032[\n\021Extens" + "ionFunction\022\037\n\027extension_uri_reference\030\001" + " \001(\r\022\027\n\017function_anchor\030\002 \001(\r\022\014\n\004name\030\003 " + "\001(\tB\016\n\014mapping_type\"j\n\021AdvancedExtension" + "\022*\n\014optimization\030\001 \001(\0132\024.google.protobuf" + ".Any\022)\n\013enhancement\030\002 \001(\0132\024.google.proto" + "buf.AnyB+\n\022io.substrait.protoP\001\252\002\022Substr" + "ait.Protobufb\006proto3" + ; +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fextensions_2fextensions_2eproto_deps[1] = { + &::descriptor_table_google_2fprotobuf_2fany_2eproto, +}; +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fextensions_2fextensions_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fextensions_2fextensions_2eproto = { + false, false, 940, descriptor_table_protodef_substrait_2fextensions_2fextensions_2eproto, "substrait/extensions/extensions.proto", + &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, descriptor_table_substrait_2fextensions_2fextensions_2eproto_deps, 1, 6, + schemas, file_default_instances, TableStruct_substrait_2fextensions_2fextensions_2eproto::offsets, + file_level_metadata_substrait_2fextensions_2fextensions_2eproto, file_level_enum_descriptors_substrait_2fextensions_2fextensions_2eproto, file_level_service_descriptors_substrait_2fextensions_2fextensions_2eproto, +}; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter() { + return &descriptor_table_substrait_2fextensions_2fextensions_2eproto; +} + +// Force running AddDescriptors() at dynamic initialization time. +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fextensions_2fextensions_2eproto(&descriptor_table_substrait_2fextensions_2fextensions_2eproto); +namespace substrait { +namespace extensions { + +// =================================================================== + +class SimpleExtensionURI::_Internal { + public: +}; + +SimpleExtensionURI::SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionURI) +} +SimpleExtensionURI::SimpleExtensionURI(const SimpleExtensionURI& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_uri().empty()) { + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), + GetArena()); + } + extension_uri_anchor_ = from.extension_uri_anchor_; + // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionURI) +} + +void SimpleExtensionURI::SharedCtor() { +uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +extension_uri_anchor_ = 0u; +} + +SimpleExtensionURI::~SimpleExtensionURI() { + // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionURI) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SimpleExtensionURI::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SimpleExtensionURI::ArenaDtor(void* object) { + SimpleExtensionURI* _this = reinterpret_cast< SimpleExtensionURI* >(object); + (void)_this; +} +void SimpleExtensionURI::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SimpleExtensionURI::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SimpleExtensionURI::Clear() { +// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionURI) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + uri_.ClearToEmpty(); + extension_uri_anchor_ = 0u; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SimpleExtensionURI::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // uint32 extension_uri_anchor = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + extension_uri_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string uri = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + auto str = _internal_mutable_uri(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionURI.uri")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionURI::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionURI) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint32 extension_uri_anchor = 1; + if (this->extension_uri_anchor() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_anchor(), target); + } + + // string uri = 2; + if (this->uri().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_uri().data(), static_cast(this->_internal_uri().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "substrait.extensions.SimpleExtensionURI.uri"); + target = stream->WriteStringMaybeAliased( + 2, this->_internal_uri(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionURI) + return target; +} + +size_t SimpleExtensionURI::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionURI) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string uri = 2; + if (this->uri().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_uri()); + } + + // uint32 extension_uri_anchor = 1; + if (this->extension_uri_anchor() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_extension_uri_anchor()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SimpleExtensionURI::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.SimpleExtensionURI) + GOOGLE_DCHECK_NE(&from, this); + const SimpleExtensionURI* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.SimpleExtensionURI) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.SimpleExtensionURI) + MergeFrom(*source); + } +} + +void SimpleExtensionURI::MergeFrom(const SimpleExtensionURI& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionURI) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.uri().size() > 0) { + _internal_set_uri(from._internal_uri()); + } + if (from.extension_uri_anchor() != 0) { + _internal_set_extension_uri_anchor(from._internal_extension_uri_anchor()); + } +} + +void SimpleExtensionURI::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.SimpleExtensionURI) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SimpleExtensionURI::CopyFrom(const SimpleExtensionURI& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionURI) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SimpleExtensionURI::IsInitialized() const { + return true; +} + +void SimpleExtensionURI::InternalSwap(SimpleExtensionURI* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + uri_.Swap(&other->uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + swap(extension_uri_anchor_, other->extension_uri_anchor_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionURI::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, + file_level_metadata_substrait_2fextensions_2fextensions_2eproto[0]); +} + +// =================================================================== + +class SimpleExtensionDeclaration_ExtensionType::_Internal { + public: +}; + +SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) +} +SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); + } + ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, + static_cast(reinterpret_cast(&type_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); + // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) +} + +void SimpleExtensionDeclaration_ExtensionType::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&type_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); +} + +SimpleExtensionDeclaration_ExtensionType::~SimpleExtensionDeclaration_ExtensionType() { + // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SimpleExtensionDeclaration_ExtensionType::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SimpleExtensionDeclaration_ExtensionType::ArenaDtor(void* object) { + SimpleExtensionDeclaration_ExtensionType* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionType* >(object); + (void)_this; +} +void SimpleExtensionDeclaration_ExtensionType::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SimpleExtensionDeclaration_ExtensionType::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SimpleExtensionDeclaration_ExtensionType::Clear() { +// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmpty(); + ::memset(&extension_uri_reference_, 0, static_cast( + reinterpret_cast(&type_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SimpleExtensionDeclaration_ExtensionType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // uint32 extension_uri_reference = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint32 type_anchor = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + type_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionType::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint32 extension_uri_reference = 1; + if (this->extension_uri_reference() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); + } + + // uint32 type_anchor = 2; + if (this->type_anchor() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_anchor(), target); + } + + // string name = 3; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + return target; +} + +size_t SimpleExtensionDeclaration_ExtensionType::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 3; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // uint32 extension_uri_reference = 1; + if (this->extension_uri_reference() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_extension_uri_reference()); + } + + // uint32 type_anchor = 2; + if (this->type_anchor() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_anchor()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SimpleExtensionDeclaration_ExtensionType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + GOOGLE_DCHECK_NE(&from, this); + const SimpleExtensionDeclaration_ExtensionType* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + MergeFrom(*source); + } +} + +void SimpleExtensionDeclaration_ExtensionType::MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } + if (from.extension_uri_reference() != 0) { + _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); + } + if (from.type_anchor() != 0) { + _internal_set_type_anchor(from._internal_type_anchor()); + } +} + +void SimpleExtensionDeclaration_ExtensionType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SimpleExtensionDeclaration_ExtensionType::CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SimpleExtensionDeclaration_ExtensionType::IsInitialized() const { + return true; +} + +void SimpleExtensionDeclaration_ExtensionType::InternalSwap(SimpleExtensionDeclaration_ExtensionType* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, type_anchor_) + + sizeof(SimpleExtensionDeclaration_ExtensionType::type_anchor_) + - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_)>( + reinterpret_cast(&extension_uri_reference_), + reinterpret_cast(&other->extension_uri_reference_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionType::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, + file_level_metadata_substrait_2fextensions_2fextensions_2eproto[1]); +} + +// =================================================================== + +class SimpleExtensionDeclaration_ExtensionTypeVariation::_Internal { + public: +}; + +SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) +} +SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); + } + ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, + static_cast(reinterpret_cast(&type_variation_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(type_variation_anchor_)); + // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) +} + +void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&type_variation_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(type_variation_anchor_)); +} + +SimpleExtensionDeclaration_ExtensionTypeVariation::~SimpleExtensionDeclaration_ExtensionTypeVariation() { + // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SimpleExtensionDeclaration_ExtensionTypeVariation::ArenaDtor(void* object) { + SimpleExtensionDeclaration_ExtensionTypeVariation* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionTypeVariation* >(object); + (void)_this; +} +void SimpleExtensionDeclaration_ExtensionTypeVariation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SimpleExtensionDeclaration_ExtensionTypeVariation::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SimpleExtensionDeclaration_ExtensionTypeVariation::Clear() { +// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmpty(); + ::memset(&extension_uri_reference_, 0, static_cast( + reinterpret_cast(&type_variation_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(type_variation_anchor_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // uint32 extension_uri_reference = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint32 type_variation_anchor = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + type_variation_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint32 extension_uri_reference = 1; + if (this->extension_uri_reference() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); + } + + // uint32 type_variation_anchor = 2; + if (this->type_variation_anchor() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_anchor(), target); + } + + // string name = 3; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + return target; +} + +size_t SimpleExtensionDeclaration_ExtensionTypeVariation::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 3; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // uint32 extension_uri_reference = 1; + if (this->extension_uri_reference() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_extension_uri_reference()); + } + + // uint32 type_variation_anchor = 2; + if (this->type_variation_anchor() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_type_variation_anchor()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + GOOGLE_DCHECK_NE(&from, this); + const SimpleExtensionDeclaration_ExtensionTypeVariation* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + MergeFrom(*source); + } +} + +void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } + if (from.extension_uri_reference() != 0) { + _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); + } + if (from.type_variation_anchor() != 0) { + _internal_set_type_variation_anchor(from._internal_type_variation_anchor()); + } +} + +void SimpleExtensionDeclaration_ExtensionTypeVariation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SimpleExtensionDeclaration_ExtensionTypeVariation::CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SimpleExtensionDeclaration_ExtensionTypeVariation::IsInitialized() const { + return true; +} + +void SimpleExtensionDeclaration_ExtensionTypeVariation::InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_) + + sizeof(SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor_) + - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_reference_)>( + reinterpret_cast(&extension_uri_reference_), + reinterpret_cast(&other->extension_uri_reference_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionTypeVariation::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, + file_level_metadata_substrait_2fextensions_2fextensions_2eproto[2]); +} + +// =================================================================== + +class SimpleExtensionDeclaration_ExtensionFunction::_Internal { + public: +}; + +SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) +} +SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + if (!from._internal_name().empty()) { + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), + GetArena()); + } + ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, + static_cast(reinterpret_cast(&function_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(function_anchor_)); + // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) +} + +void SimpleExtensionDeclaration_ExtensionFunction::SharedCtor() { +name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&function_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(function_anchor_)); +} + +SimpleExtensionDeclaration_ExtensionFunction::~SimpleExtensionDeclaration_ExtensionFunction() { + // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SimpleExtensionDeclaration_ExtensionFunction::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +} + +void SimpleExtensionDeclaration_ExtensionFunction::ArenaDtor(void* object) { + SimpleExtensionDeclaration_ExtensionFunction* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionFunction* >(object); + (void)_this; +} +void SimpleExtensionDeclaration_ExtensionFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SimpleExtensionDeclaration_ExtensionFunction::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SimpleExtensionDeclaration_ExtensionFunction::Clear() { +// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + name_.ClearToEmpty(); + ::memset(&extension_uri_reference_, 0, static_cast( + reinterpret_cast(&function_anchor_) - + reinterpret_cast(&extension_uri_reference_)) + sizeof(function_anchor_)); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SimpleExtensionDeclaration_ExtensionFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // uint32 extension_uri_reference = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint32 function_anchor = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + function_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // string name = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + auto str = _internal_mutable_name(); + ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name")); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionFunction::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // uint32 extension_uri_reference = 1; + if (this->extension_uri_reference() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); + } + + // uint32 function_anchor = 2; + if (this->function_anchor() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_function_anchor(), target); + } + + // string name = 3; + if (this->name().size() > 0) { + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( + this->_internal_name().data(), static_cast(this->_internal_name().length()), + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, + "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name"); + target = stream->WriteStringMaybeAliased( + 3, this->_internal_name(), target); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + return target; +} + +size_t SimpleExtensionDeclaration_ExtensionFunction::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // string name = 3; + if (this->name().size() > 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( + this->_internal_name()); + } + + // uint32 extension_uri_reference = 1; + if (this->extension_uri_reference() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_extension_uri_reference()); + } + + // uint32 function_anchor = 2; + if (this->function_anchor() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( + this->_internal_function_anchor()); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + GOOGLE_DCHECK_NE(&from, this); + const SimpleExtensionDeclaration_ExtensionFunction* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + MergeFrom(*source); + } +} + +void SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.name().size() > 0) { + _internal_set_name(from._internal_name()); + } + if (from.extension_uri_reference() != 0) { + _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); + } + if (from.function_anchor() != 0) { + _internal_set_function_anchor(from._internal_function_anchor()); + } +} + +void SimpleExtensionDeclaration_ExtensionFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SimpleExtensionDeclaration_ExtensionFunction::CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SimpleExtensionDeclaration_ExtensionFunction::IsInitialized() const { + return true; +} + +void SimpleExtensionDeclaration_ExtensionFunction::InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, function_anchor_) + + sizeof(SimpleExtensionDeclaration_ExtensionFunction::function_anchor_) + - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, extension_uri_reference_)>( + reinterpret_cast(&extension_uri_reference_), + reinterpret_cast(&other->extension_uri_reference_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionFunction::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, + file_level_metadata_substrait_2fextensions_2fextensions_2eproto[3]); +} + +// =================================================================== + +class SimpleExtensionDeclaration::_Internal { + public: + static const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type(const SimpleExtensionDeclaration* msg); + static const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation(const SimpleExtensionDeclaration* msg); + static const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function(const SimpleExtensionDeclaration* msg); +}; + +const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& +SimpleExtensionDeclaration::_Internal::extension_type(const SimpleExtensionDeclaration* msg) { + return *msg->mapping_type_.extension_type_; +} +const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& +SimpleExtensionDeclaration::_Internal::extension_type_variation(const SimpleExtensionDeclaration* msg) { + return *msg->mapping_type_.extension_type_variation_; +} +const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& +SimpleExtensionDeclaration::_Internal::extension_function(const SimpleExtensionDeclaration* msg) { + return *msg->mapping_type_.extension_function_; +} +void SimpleExtensionDeclaration::set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_mapping_type(); + if (extension_type) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_type); + if (message_arena != submessage_arena) { + extension_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_type, submessage_arena); + } + set_has_extension_type(); + mapping_type_.extension_type_ = extension_type; + } + // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type) +} +void SimpleExtensionDeclaration::set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_mapping_type(); + if (extension_type_variation) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_type_variation); + if (message_arena != submessage_arena) { + extension_type_variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_type_variation, submessage_arena); + } + set_has_extension_type_variation(); + mapping_type_.extension_type_variation_ = extension_type_variation; + } + // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) +} +void SimpleExtensionDeclaration::set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + clear_mapping_type(); + if (extension_function) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_function); + if (message_arena != submessage_arena) { + extension_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, extension_function, submessage_arena); + } + set_has_extension_function(); + mapping_type_.extension_function_ = extension_function; + } + // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_function) +} +SimpleExtensionDeclaration::SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration) +} +SimpleExtensionDeclaration::SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + clear_has_mapping_type(); + switch (from.mapping_type_case()) { + case kExtensionType: { + _internal_mutable_extension_type()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionType::MergeFrom(from._internal_extension_type()); + break; + } + case kExtensionTypeVariation: { + _internal_mutable_extension_type_variation()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(from._internal_extension_type_variation()); + break; + } + case kExtensionFunction: { + _internal_mutable_extension_function()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(from._internal_extension_function()); + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } + } + // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration) +} + +void SimpleExtensionDeclaration::SharedCtor() { +clear_has_mapping_type(); +} + +SimpleExtensionDeclaration::~SimpleExtensionDeclaration() { + // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void SimpleExtensionDeclaration::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (has_mapping_type()) { + clear_mapping_type(); + } +} + +void SimpleExtensionDeclaration::ArenaDtor(void* object) { + SimpleExtensionDeclaration* _this = reinterpret_cast< SimpleExtensionDeclaration* >(object); + (void)_this; +} +void SimpleExtensionDeclaration::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void SimpleExtensionDeclaration::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void SimpleExtensionDeclaration::clear_mapping_type() { +// @@protoc_insertion_point(one_of_clear_start:substrait.extensions.SimpleExtensionDeclaration) + switch (mapping_type_case()) { + case kExtensionType: { + if (GetArena() == nullptr) { + delete mapping_type_.extension_type_; + } + break; + } + case kExtensionTypeVariation: { + if (GetArena() == nullptr) { + delete mapping_type_.extension_type_variation_; + } + break; + } + case kExtensionFunction: { + if (GetArena() == nullptr) { + delete mapping_type_.extension_function_; + } + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } + } + _oneof_case_[0] = MAPPING_TYPE_NOT_SET; +} + + +void SimpleExtensionDeclaration::Clear() { +// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_mapping_type(); + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* SimpleExtensionDeclaration::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_type(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_type_variation(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_extension_function(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; + if (_internal_has_extension_type()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::extension_type(this), target, stream); + } + + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; + if (_internal_has_extension_type_variation()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::extension_type_variation(this), target, stream); + } + + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; + if (_internal_has_extension_function()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 3, _Internal::extension_function(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration) + return target; +} + +size_t SimpleExtensionDeclaration::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + switch (mapping_type_case()) { + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; + case kExtensionType: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mapping_type_.extension_type_); + break; + } + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; + case kExtensionTypeVariation: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mapping_type_.extension_type_variation_); + break; + } + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; + case kExtensionFunction: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *mapping_type_.extension_function_); + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void SimpleExtensionDeclaration::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.SimpleExtensionDeclaration) + GOOGLE_DCHECK_NE(&from, this); + const SimpleExtensionDeclaration* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.SimpleExtensionDeclaration) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.SimpleExtensionDeclaration) + MergeFrom(*source); + } +} + +void SimpleExtensionDeclaration::MergeFrom(const SimpleExtensionDeclaration& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + switch (from.mapping_type_case()) { + case kExtensionType: { + _internal_mutable_extension_type()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionType::MergeFrom(from._internal_extension_type()); + break; + } + case kExtensionTypeVariation: { + _internal_mutable_extension_type_variation()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(from._internal_extension_type_variation()); + break; + } + case kExtensionFunction: { + _internal_mutable_extension_function()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(from._internal_extension_function()); + break; + } + case MAPPING_TYPE_NOT_SET: { + break; + } + } +} + +void SimpleExtensionDeclaration::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.SimpleExtensionDeclaration) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void SimpleExtensionDeclaration::CopyFrom(const SimpleExtensionDeclaration& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SimpleExtensionDeclaration::IsInitialized() const { + return true; +} + +void SimpleExtensionDeclaration::InternalSwap(SimpleExtensionDeclaration* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + swap(mapping_type_, other->mapping_type_); + swap(_oneof_case_[0], other->_oneof_case_[0]); +} + +::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, + file_level_metadata_substrait_2fextensions_2fextensions_2eproto[4]); +} + +// =================================================================== + +class AdvancedExtension::_Internal { + public: + static const PROTOBUF_NAMESPACE_ID::Any& optimization(const AdvancedExtension* msg); + static const PROTOBUF_NAMESPACE_ID::Any& enhancement(const AdvancedExtension* msg); +}; + +const PROTOBUF_NAMESPACE_ID::Any& +AdvancedExtension::_Internal::optimization(const AdvancedExtension* msg) { + return *msg->optimization_; +} +const PROTOBUF_NAMESPACE_ID::Any& +AdvancedExtension::_Internal::enhancement(const AdvancedExtension* msg) { + return *msg->enhancement_; +} +void AdvancedExtension::clear_optimization() { + if (GetArena() == nullptr && optimization_ != nullptr) { + delete optimization_; + } + optimization_ = nullptr; +} +void AdvancedExtension::clear_enhancement() { + if (GetArena() == nullptr && enhancement_ != nullptr) { + delete enhancement_; + } + enhancement_ = nullptr; +} +AdvancedExtension::AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena) + : ::PROTOBUF_NAMESPACE_ID::Message(arena) { + SharedCtor(); + RegisterArenaDtor(arena); + // @@protoc_insertion_point(arena_constructor:substrait.extensions.AdvancedExtension) +} +AdvancedExtension::AdvancedExtension(const AdvancedExtension& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_optimization()) { + optimization_ = new PROTOBUF_NAMESPACE_ID::Any(*from.optimization_); + } else { + optimization_ = nullptr; + } + if (from._internal_has_enhancement()) { + enhancement_ = new PROTOBUF_NAMESPACE_ID::Any(*from.enhancement_); + } else { + enhancement_ = nullptr; + } + // @@protoc_insertion_point(copy_constructor:substrait.extensions.AdvancedExtension) +} + +void AdvancedExtension::SharedCtor() { +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&optimization_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&enhancement_) - + reinterpret_cast(&optimization_)) + sizeof(enhancement_)); +} + +AdvancedExtension::~AdvancedExtension() { + // @@protoc_insertion_point(destructor:substrait.extensions.AdvancedExtension) + SharedDtor(); + _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +void AdvancedExtension::SharedDtor() { + GOOGLE_DCHECK(GetArena() == nullptr); + if (this != internal_default_instance()) delete optimization_; + if (this != internal_default_instance()) delete enhancement_; +} + +void AdvancedExtension::ArenaDtor(void* object) { + AdvancedExtension* _this = reinterpret_cast< AdvancedExtension* >(object); + (void)_this; +} +void AdvancedExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { +} +void AdvancedExtension::SetCachedSize(int size) const { + _cached_size_.Set(size); +} + +void AdvancedExtension::Clear() { +// @@protoc_insertion_point(message_clear_start:substrait.extensions.AdvancedExtension) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArena() == nullptr && optimization_ != nullptr) { + delete optimization_; + } + optimization_ = nullptr; + if (GetArena() == nullptr && enhancement_ != nullptr) { + delete enhancement_; + } + enhancement_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* AdvancedExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + ::PROTOBUF_NAMESPACE_ID::uint32 tag; + ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .google.protobuf.Any optimization = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_optimization(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // .google.protobuf.Any enhancement = 2; + case 2: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + ptr = ctx->ParseMessage(_internal_mutable_enhancement(), ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + default: { + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto success; + } + ptr = UnknownFieldParse(tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + continue; + } + } // switch + } // while +success: + return ptr; +failure: + ptr = nullptr; + goto success; +#undef CHK_ +} + +::PROTOBUF_NAMESPACE_ID::uint8* AdvancedExtension::_InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.AdvancedExtension) + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + // .google.protobuf.Any optimization = 1; + if (this->has_optimization()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 1, _Internal::optimization(this), target, stream); + } + + // .google.protobuf.Any enhancement = 2; + if (this->has_enhancement()) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage( + 2, _Internal::enhancement(this), target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( + _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.AdvancedExtension) + return target; +} + +size_t AdvancedExtension::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.AdvancedExtension) + size_t total_size = 0; + + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .google.protobuf.Any optimization = 1; + if (this->has_optimization()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *optimization_); + } + + // .google.protobuf.Any enhancement = 2; + if (this->has_enhancement()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *enhancement_); + } + + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { + return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( + _internal_metadata_, total_size, &_cached_size_); + } + int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); + SetCachedSize(cached_size); + return total_size; +} + +void AdvancedExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.AdvancedExtension) + GOOGLE_DCHECK_NE(&from, this); + const AdvancedExtension* source = + ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( + &from); + if (source == nullptr) { + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.AdvancedExtension) + ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); + } else { + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.AdvancedExtension) + MergeFrom(*source); + } +} + +void AdvancedExtension::MergeFrom(const AdvancedExtension& from) { +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.AdvancedExtension) + GOOGLE_DCHECK_NE(&from, this); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + (void) cached_has_bits; + + if (from.has_optimization()) { + _internal_mutable_optimization()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_optimization()); + } + if (from.has_enhancement()) { + _internal_mutable_enhancement()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_enhancement()); + } +} + +void AdvancedExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { +// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.AdvancedExtension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void AdvancedExtension::CopyFrom(const AdvancedExtension& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.AdvancedExtension) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AdvancedExtension::IsInitialized() const { + return true; +} + +void AdvancedExtension::InternalSwap(AdvancedExtension* other) { + using std::swap; + _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(AdvancedExtension, enhancement_) + + sizeof(AdvancedExtension::enhancement_) + - PROTOBUF_FIELD_OFFSET(AdvancedExtension, optimization_)>( + reinterpret_cast(&optimization_), + reinterpret_cast(&other->optimization_)); +} + +::PROTOBUF_NAMESPACE_ID::Metadata AdvancedExtension::GetMetadata() const { + return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( + &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, + file_level_metadata_substrait_2fextensions_2fextensions_2eproto[5]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace extensions +} // namespace substrait +PROTOBUF_NAMESPACE_OPEN +template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionURI* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionURI >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionURI >(arena); +} +template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(arena); +} +template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(arena); +} +template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(arena); +} +template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration >(arena); +} +template<> PROTOBUF_NOINLINE ::substrait::extensions::AdvancedExtension* Arena::CreateMaybeMessage< ::substrait::extensions::AdvancedExtension >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::extensions::AdvancedExtension >(arena); +} +PROTOBUF_NAMESPACE_CLOSE + +// @@protoc_insertion_point(global_scope) +#include diff --git a/cpp/src/generated/substrait/extensions/extensions.pb.h b/cpp/src/generated/substrait/extensions/extensions.pb.h new file mode 100644 index 00000000000..45b2a664723 --- /dev/null +++ b/cpp/src/generated/substrait/extensions/extensions.pb.h @@ -0,0 +1,1831 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: substrait/extensions/extensions.proto + +#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fextensions_2fextensions_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fextensions_2fextensions_2eproto + +#include +#include + +#include +#if PROTOBUF_VERSION < 3016000 +#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 3016000 < 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include // IWYU pragma: export +#include // IWYU pragma: export +#include +#include +// @@protoc_insertion_point(includes) +#include +#define PROTOBUF_INTERNAL_EXPORT_substrait_2fextensions_2fextensions_2eproto +PROTOBUF_NAMESPACE_OPEN +namespace internal { +class AnyMetadata; +} // namespace internal +PROTOBUF_NAMESPACE_CLOSE + +// Internal implementation detail -- do not use these members. +struct TableStruct_substrait_2fextensions_2fextensions_2eproto { + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6] + PROTOBUF_SECTION_VARIABLE(protodesc_cold); + static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; + static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; + static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; +}; +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fextensions_2fextensions_2eproto; +namespace substrait { +namespace extensions { +class AdvancedExtension; +struct AdvancedExtensionDefaultTypeInternal; +extern AdvancedExtensionDefaultTypeInternal _AdvancedExtension_default_instance_; +class SimpleExtensionDeclaration; +struct SimpleExtensionDeclarationDefaultTypeInternal; +extern SimpleExtensionDeclarationDefaultTypeInternal _SimpleExtensionDeclaration_default_instance_; +class SimpleExtensionDeclaration_ExtensionFunction; +struct SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal; +extern SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionFunction_default_instance_; +class SimpleExtensionDeclaration_ExtensionType; +struct SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal; +extern SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionType_default_instance_; +class SimpleExtensionDeclaration_ExtensionTypeVariation; +struct SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal; +extern SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_; +class SimpleExtensionURI; +struct SimpleExtensionURIDefaultTypeInternal; +extern SimpleExtensionURIDefaultTypeInternal _SimpleExtensionURI_default_instance_; +} // namespace extensions +} // namespace substrait +PROTOBUF_NAMESPACE_OPEN +template<> ::substrait::extensions::AdvancedExtension* Arena::CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(Arena*); +template<> ::substrait::extensions::SimpleExtensionDeclaration* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration>(Arena*); +template<> ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction>(Arena*); +template<> ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration_ExtensionType>(Arena*); +template<> ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation>(Arena*); +template<> ::substrait::extensions::SimpleExtensionURI* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionURI>(Arena*); +PROTOBUF_NAMESPACE_CLOSE +namespace substrait { +namespace extensions { + +// =================================================================== + +class SimpleExtensionURI PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionURI) */ { + public: + inline SimpleExtensionURI() : SimpleExtensionURI(nullptr) {} + ~SimpleExtensionURI() override; + explicit constexpr SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SimpleExtensionURI(const SimpleExtensionURI& from); + SimpleExtensionURI(SimpleExtensionURI&& from) noexcept + : SimpleExtensionURI() { + *this = ::std::move(from); + } + + inline SimpleExtensionURI& operator=(const SimpleExtensionURI& from) { + CopyFrom(from); + return *this; + } + inline SimpleExtensionURI& operator=(SimpleExtensionURI&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 SimpleExtensionURI& default_instance() { + return *internal_default_instance(); + } + static inline const SimpleExtensionURI* internal_default_instance() { + return reinterpret_cast( + &_SimpleExtensionURI_default_instance_); + } + static constexpr int kIndexInFileMessages = + 0; + + friend void swap(SimpleExtensionURI& a, SimpleExtensionURI& b) { + a.Swap(&b); + } + inline void Swap(SimpleExtensionURI* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SimpleExtensionURI* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SimpleExtensionURI* New() const final { + return CreateMaybeMessage(nullptr); + } + + SimpleExtensionURI* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SimpleExtensionURI& from); + void MergeFrom(const SimpleExtensionURI& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SimpleExtensionURI* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "substrait.extensions.SimpleExtensionURI"; + } + protected: + explicit SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kUriFieldNumber = 2, + kExtensionUriAnchorFieldNumber = 1, + }; + // string uri = 2; + void clear_uri(); + const std::string& uri() const; + template + void set_uri(ArgT0&& arg0, ArgT... args); + std::string* mutable_uri(); + std::string* release_uri(); + void set_allocated_uri(std::string* uri); + private: + const std::string& _internal_uri() const; + void _internal_set_uri(const std::string& value); + std::string* _internal_mutable_uri(); + public: + + // uint32 extension_uri_anchor = 1; + void clear_extension_uri_anchor(); + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_anchor() const; + void set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_anchor() const; + void _internal_set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionURI) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_anchor_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; +}; +// ------------------------------------------------------------------- + +class SimpleExtensionDeclaration_ExtensionType PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) */ { + public: + inline SimpleExtensionDeclaration_ExtensionType() : SimpleExtensionDeclaration_ExtensionType(nullptr) {} + ~SimpleExtensionDeclaration_ExtensionType() override; + explicit constexpr SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from); + SimpleExtensionDeclaration_ExtensionType(SimpleExtensionDeclaration_ExtensionType&& from) noexcept + : SimpleExtensionDeclaration_ExtensionType() { + *this = ::std::move(from); + } + + inline SimpleExtensionDeclaration_ExtensionType& operator=(const SimpleExtensionDeclaration_ExtensionType& from) { + CopyFrom(from); + return *this; + } + inline SimpleExtensionDeclaration_ExtensionType& operator=(SimpleExtensionDeclaration_ExtensionType&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 SimpleExtensionDeclaration_ExtensionType& default_instance() { + return *internal_default_instance(); + } + static inline const SimpleExtensionDeclaration_ExtensionType* internal_default_instance() { + return reinterpret_cast( + &_SimpleExtensionDeclaration_ExtensionType_default_instance_); + } + static constexpr int kIndexInFileMessages = + 1; + + friend void swap(SimpleExtensionDeclaration_ExtensionType& a, SimpleExtensionDeclaration_ExtensionType& b) { + a.Swap(&b); + } + inline void Swap(SimpleExtensionDeclaration_ExtensionType* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionType* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SimpleExtensionDeclaration_ExtensionType* New() const final { + return CreateMaybeMessage(nullptr); + } + + SimpleExtensionDeclaration_ExtensionType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from); + void MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SimpleExtensionDeclaration_ExtensionType* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "substrait.extensions.SimpleExtensionDeclaration.ExtensionType"; + } + protected: + explicit SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 3, + kExtensionUriReferenceFieldNumber = 1, + kTypeAnchorFieldNumber = 2, + }; + // string name = 3; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // uint32 extension_uri_reference = 1; + void clear_extension_uri_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference() const; + void set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_reference() const; + void _internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // uint32 type_anchor = 2; + void clear_type_anchor(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_anchor() const; + void set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_anchor() const; + void _internal_set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_anchor_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; +}; +// ------------------------------------------------------------------- + +class SimpleExtensionDeclaration_ExtensionTypeVariation PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) */ { + public: + inline SimpleExtensionDeclaration_ExtensionTypeVariation() : SimpleExtensionDeclaration_ExtensionTypeVariation(nullptr) {} + ~SimpleExtensionDeclaration_ExtensionTypeVariation() override; + explicit constexpr SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); + SimpleExtensionDeclaration_ExtensionTypeVariation(SimpleExtensionDeclaration_ExtensionTypeVariation&& from) noexcept + : SimpleExtensionDeclaration_ExtensionTypeVariation() { + *this = ::std::move(from); + } + + inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { + CopyFrom(from); + return *this; + } + inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(SimpleExtensionDeclaration_ExtensionTypeVariation&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 SimpleExtensionDeclaration_ExtensionTypeVariation& default_instance() { + return *internal_default_instance(); + } + static inline const SimpleExtensionDeclaration_ExtensionTypeVariation* internal_default_instance() { + return reinterpret_cast( + &_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_); + } + static constexpr int kIndexInFileMessages = + 2; + + friend void swap(SimpleExtensionDeclaration_ExtensionTypeVariation& a, SimpleExtensionDeclaration_ExtensionTypeVariation& b) { + a.Swap(&b); + } + inline void Swap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SimpleExtensionDeclaration_ExtensionTypeVariation* New() const final { + return CreateMaybeMessage(nullptr); + } + + SimpleExtensionDeclaration_ExtensionTypeVariation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); + void MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation"; + } + protected: + explicit SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 3, + kExtensionUriReferenceFieldNumber = 1, + kTypeVariationAnchorFieldNumber = 2, + }; + // string name = 3; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // uint32 extension_uri_reference = 1; + void clear_extension_uri_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference() const; + void set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_reference() const; + void _internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // uint32 type_variation_anchor = 2; + void clear_type_variation_anchor(); + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_anchor() const; + void set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_anchor() const; + void _internal_set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference_; + ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_anchor_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; +}; +// ------------------------------------------------------------------- + +class SimpleExtensionDeclaration_ExtensionFunction PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) */ { + public: + inline SimpleExtensionDeclaration_ExtensionFunction() : SimpleExtensionDeclaration_ExtensionFunction(nullptr) {} + ~SimpleExtensionDeclaration_ExtensionFunction() override; + explicit constexpr SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from); + SimpleExtensionDeclaration_ExtensionFunction(SimpleExtensionDeclaration_ExtensionFunction&& from) noexcept + : SimpleExtensionDeclaration_ExtensionFunction() { + *this = ::std::move(from); + } + + inline SimpleExtensionDeclaration_ExtensionFunction& operator=(const SimpleExtensionDeclaration_ExtensionFunction& from) { + CopyFrom(from); + return *this; + } + inline SimpleExtensionDeclaration_ExtensionFunction& operator=(SimpleExtensionDeclaration_ExtensionFunction&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 SimpleExtensionDeclaration_ExtensionFunction& default_instance() { + return *internal_default_instance(); + } + static inline const SimpleExtensionDeclaration_ExtensionFunction* internal_default_instance() { + return reinterpret_cast( + &_SimpleExtensionDeclaration_ExtensionFunction_default_instance_); + } + static constexpr int kIndexInFileMessages = + 3; + + friend void swap(SimpleExtensionDeclaration_ExtensionFunction& a, SimpleExtensionDeclaration_ExtensionFunction& b) { + a.Swap(&b); + } + inline void Swap(SimpleExtensionDeclaration_ExtensionFunction* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionFunction* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SimpleExtensionDeclaration_ExtensionFunction* New() const final { + return CreateMaybeMessage(nullptr); + } + + SimpleExtensionDeclaration_ExtensionFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from); + void MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction"; + } + protected: + explicit SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kNameFieldNumber = 3, + kExtensionUriReferenceFieldNumber = 1, + kFunctionAnchorFieldNumber = 2, + }; + // string name = 3; + void clear_name(); + const std::string& name() const; + template + void set_name(ArgT0&& arg0, ArgT... args); + std::string* mutable_name(); + std::string* release_name(); + void set_allocated_name(std::string* name); + private: + const std::string& _internal_name() const; + void _internal_set_name(const std::string& value); + std::string* _internal_mutable_name(); + public: + + // uint32 extension_uri_reference = 1; + void clear_extension_uri_reference(); + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference() const; + void set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_reference() const; + void _internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // uint32 function_anchor = 2; + void clear_function_anchor(); + ::PROTOBUF_NAMESPACE_ID::uint32 function_anchor() const; + void set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint32 _internal_function_anchor() const; + void _internal_set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + public: + + // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; + ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference_; + ::PROTOBUF_NAMESPACE_ID::uint32 function_anchor_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; +}; +// ------------------------------------------------------------------- + +class SimpleExtensionDeclaration PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration) */ { + public: + inline SimpleExtensionDeclaration() : SimpleExtensionDeclaration(nullptr) {} + ~SimpleExtensionDeclaration() override; + explicit constexpr SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from); + SimpleExtensionDeclaration(SimpleExtensionDeclaration&& from) noexcept + : SimpleExtensionDeclaration() { + *this = ::std::move(from); + } + + inline SimpleExtensionDeclaration& operator=(const SimpleExtensionDeclaration& from) { + CopyFrom(from); + return *this; + } + inline SimpleExtensionDeclaration& operator=(SimpleExtensionDeclaration&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 SimpleExtensionDeclaration& default_instance() { + return *internal_default_instance(); + } + enum MappingTypeCase { + kExtensionType = 1, + kExtensionTypeVariation = 2, + kExtensionFunction = 3, + MAPPING_TYPE_NOT_SET = 0, + }; + + static inline const SimpleExtensionDeclaration* internal_default_instance() { + return reinterpret_cast( + &_SimpleExtensionDeclaration_default_instance_); + } + static constexpr int kIndexInFileMessages = + 4; + + friend void swap(SimpleExtensionDeclaration& a, SimpleExtensionDeclaration& b) { + a.Swap(&b); + } + inline void Swap(SimpleExtensionDeclaration* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SimpleExtensionDeclaration* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline SimpleExtensionDeclaration* New() const final { + return CreateMaybeMessage(nullptr); + } + + SimpleExtensionDeclaration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const SimpleExtensionDeclaration& from); + void MergeFrom(const SimpleExtensionDeclaration& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(SimpleExtensionDeclaration* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "substrait.extensions.SimpleExtensionDeclaration"; + } + protected: + explicit SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + typedef SimpleExtensionDeclaration_ExtensionType ExtensionType; + typedef SimpleExtensionDeclaration_ExtensionTypeVariation ExtensionTypeVariation; + typedef SimpleExtensionDeclaration_ExtensionFunction ExtensionFunction; + + // accessors ------------------------------------------------------- + + enum : int { + kExtensionTypeFieldNumber = 1, + kExtensionTypeVariationFieldNumber = 2, + kExtensionFunctionFieldNumber = 3, + }; + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; + bool has_extension_type() const; + private: + bool _internal_has_extension_type() const; + public: + void clear_extension_type(); + const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type() const; + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* release_extension_type(); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* mutable_extension_type(); + void set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type); + private: + const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& _internal_extension_type() const; + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* _internal_mutable_extension_type(); + public: + void unsafe_arena_set_allocated_extension_type( + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* unsafe_arena_release_extension_type(); + + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; + bool has_extension_type_variation() const; + private: + bool _internal_has_extension_type_variation() const; + public: + void clear_extension_type_variation(); + const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation() const; + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* release_extension_type_variation(); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* mutable_extension_type_variation(); + void set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation); + private: + const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& _internal_extension_type_variation() const; + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* _internal_mutable_extension_type_variation(); + public: + void unsafe_arena_set_allocated_extension_type_variation( + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* unsafe_arena_release_extension_type_variation(); + + // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; + bool has_extension_function() const; + private: + bool _internal_has_extension_function() const; + public: + void clear_extension_function(); + const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function() const; + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* release_extension_function(); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* mutable_extension_function(); + void set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function); + private: + const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& _internal_extension_function() const; + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* _internal_mutable_extension_function(); + public: + void unsafe_arena_set_allocated_extension_function( + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* unsafe_arena_release_extension_function(); + + void clear_mapping_type(); + MappingTypeCase mapping_type_case() const; + // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration) + private: + class _Internal; + void set_has_extension_type(); + void set_has_extension_type_variation(); + void set_has_extension_function(); + + inline bool has_mapping_type() const; + inline void clear_has_mapping_type(); + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + union MappingTypeUnion { + constexpr MappingTypeUnion() : _constinit_{} {} + ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type_; + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation_; + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function_; + } mapping_type_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + + friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; +}; +// ------------------------------------------------------------------- + +class AdvancedExtension PROTOBUF_FINAL : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.AdvancedExtension) */ { + public: + inline AdvancedExtension() : AdvancedExtension(nullptr) {} + ~AdvancedExtension() override; + explicit constexpr AdvancedExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + AdvancedExtension(const AdvancedExtension& from); + AdvancedExtension(AdvancedExtension&& from) noexcept + : AdvancedExtension() { + *this = ::std::move(from); + } + + inline AdvancedExtension& operator=(const AdvancedExtension& from) { + CopyFrom(from); + return *this; + } + inline AdvancedExtension& operator=(AdvancedExtension&& from) noexcept { + if (GetArena() == from.GetArena()) { + if (this != &from) 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 AdvancedExtension& default_instance() { + return *internal_default_instance(); + } + static inline const AdvancedExtension* internal_default_instance() { + return reinterpret_cast( + &_AdvancedExtension_default_instance_); + } + static constexpr int kIndexInFileMessages = + 5; + + friend void swap(AdvancedExtension& a, AdvancedExtension& b) { + a.Swap(&b); + } + inline void Swap(AdvancedExtension* other) { + if (other == this) return; + if (GetArena() == other->GetArena()) { + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AdvancedExtension* other) { + if (other == this) return; + GOOGLE_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + inline AdvancedExtension* New() const final { + return CreateMaybeMessage(nullptr); + } + + AdvancedExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + return CreateMaybeMessage(arena); + } + void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + void CopyFrom(const AdvancedExtension& from); + void MergeFrom(const AdvancedExtension& from); + 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; + ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( + ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _cached_size_.Get(); } + + private: + inline void SharedCtor(); + inline void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(AdvancedExtension* other); + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "substrait.extensions.AdvancedExtension"; + } + protected: + explicit AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); + private: + static void ArenaDtor(void* object); + inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); + public: + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kOptimizationFieldNumber = 1, + kEnhancementFieldNumber = 2, + }; + // .google.protobuf.Any optimization = 1; + bool has_optimization() const; + private: + bool _internal_has_optimization() const; + public: + void clear_optimization(); + const PROTOBUF_NAMESPACE_ID::Any& optimization() const; + PROTOBUF_NAMESPACE_ID::Any* release_optimization(); + PROTOBUF_NAMESPACE_ID::Any* mutable_optimization(); + void set_allocated_optimization(PROTOBUF_NAMESPACE_ID::Any* optimization); + private: + const PROTOBUF_NAMESPACE_ID::Any& _internal_optimization() const; + PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_optimization(); + public: + void unsafe_arena_set_allocated_optimization( + PROTOBUF_NAMESPACE_ID::Any* optimization); + PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_optimization(); + + // .google.protobuf.Any enhancement = 2; + bool has_enhancement() const; + private: + bool _internal_has_enhancement() const; + public: + void clear_enhancement(); + const PROTOBUF_NAMESPACE_ID::Any& enhancement() const; + PROTOBUF_NAMESPACE_ID::Any* release_enhancement(); + PROTOBUF_NAMESPACE_ID::Any* mutable_enhancement(); + void set_allocated_enhancement(PROTOBUF_NAMESPACE_ID::Any* enhancement); + private: + const PROTOBUF_NAMESPACE_ID::Any& _internal_enhancement() const; + PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_enhancement(); + public: + void unsafe_arena_set_allocated_enhancement( + PROTOBUF_NAMESPACE_ID::Any* enhancement); + PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_enhancement(); + + // @@protoc_insertion_point(class_scope:substrait.extensions.AdvancedExtension) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + PROTOBUF_NAMESPACE_ID::Any* optimization_; + PROTOBUF_NAMESPACE_ID::Any* enhancement_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; +}; +// =================================================================== + + +// =================================================================== + +#ifdef __GNUC__ + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// SimpleExtensionURI + +// uint32 extension_uri_anchor = 1; +inline void SimpleExtensionURI::clear_extension_uri_anchor() { + extension_uri_anchor_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionURI::_internal_extension_uri_anchor() const { + return extension_uri_anchor_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionURI::extension_uri_anchor() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionURI.extension_uri_anchor) + return _internal_extension_uri_anchor(); +} +inline void SimpleExtensionURI::_internal_set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + extension_uri_anchor_ = value; +} +inline void SimpleExtensionURI::set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_extension_uri_anchor(value); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionURI.extension_uri_anchor) +} + +// string uri = 2; +inline void SimpleExtensionURI::clear_uri() { + uri_.ClearToEmpty(); +} +inline const std::string& SimpleExtensionURI::uri() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionURI.uri) + return _internal_uri(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void SimpleExtensionURI::set_uri(ArgT0&& arg0, ArgT... args) { + + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionURI.uri) +} +inline std::string* SimpleExtensionURI::mutable_uri() { + // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionURI.uri) + return _internal_mutable_uri(); +} +inline const std::string& SimpleExtensionURI::_internal_uri() const { + return uri_.Get(); +} +inline void SimpleExtensionURI::_internal_set_uri(const std::string& value) { + + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* SimpleExtensionURI::_internal_mutable_uri() { + + return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* SimpleExtensionURI::release_uri() { + // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionURI.uri) + return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void SimpleExtensionURI::set_allocated_uri(std::string* uri) { + if (uri != nullptr) { + + } else { + + } + uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionURI.uri) +} + +// ------------------------------------------------------------------- + +// SimpleExtensionDeclaration_ExtensionType + +// uint32 extension_uri_reference = 1; +inline void SimpleExtensionDeclaration_ExtensionType::clear_extension_uri_reference() { + extension_uri_reference_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::_internal_extension_uri_reference() const { + return extension_uri_reference_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::extension_uri_reference() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference) + return _internal_extension_uri_reference(); +} +inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + extension_uri_reference_ = value; +} +inline void SimpleExtensionDeclaration_ExtensionType::set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_extension_uri_reference(value); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference) +} + +// uint32 type_anchor = 2; +inline void SimpleExtensionDeclaration_ExtensionType::clear_type_anchor() { + type_anchor_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::_internal_type_anchor() const { + return type_anchor_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::type_anchor() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor) + return _internal_type_anchor(); +} +inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + type_anchor_ = value; +} +inline void SimpleExtensionDeclaration_ExtensionType::set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_anchor(value); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor) +} + +// string name = 3; +inline void SimpleExtensionDeclaration_ExtensionType::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& SimpleExtensionDeclaration_ExtensionType::name() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) + return _internal_name(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void SimpleExtensionDeclaration_ExtensionType::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) +} +inline std::string* SimpleExtensionDeclaration_ExtensionType::mutable_name() { + // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) + return _internal_mutable_name(); +} +inline const std::string& SimpleExtensionDeclaration_ExtensionType::_internal_name() const { + return name_.Get(); +} +inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* SimpleExtensionDeclaration_ExtensionType::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* SimpleExtensionDeclaration_ExtensionType::release_name() { + // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void SimpleExtensionDeclaration_ExtensionType::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) +} + +// ------------------------------------------------------------------- + +// SimpleExtensionDeclaration_ExtensionTypeVariation + +// uint32 extension_uri_reference = 1; +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_extension_uri_reference() { + extension_uri_reference_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_extension_uri_reference() const { + return extension_uri_reference_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::extension_uri_reference() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_reference) + return _internal_extension_uri_reference(); +} +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + extension_uri_reference_ = value; +} +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_extension_uri_reference(value); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_reference) +} + +// uint32 type_variation_anchor = 2; +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_type_variation_anchor() { + type_variation_anchor_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_type_variation_anchor() const { + return type_variation_anchor_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor) + return _internal_type_variation_anchor(); +} +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + type_variation_anchor_ = value; +} +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_type_variation_anchor(value); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor) +} + +// string name = 3; +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::name() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) + return _internal_name(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) +} +inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::mutable_name() { + // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) + return _internal_mutable_name(); +} +inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_name() const { + return name_.Get(); +} +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::release_name() { + // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) +} + +// ------------------------------------------------------------------- + +// SimpleExtensionDeclaration_ExtensionFunction + +// uint32 extension_uri_reference = 1; +inline void SimpleExtensionDeclaration_ExtensionFunction::clear_extension_uri_reference() { + extension_uri_reference_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::_internal_extension_uri_reference() const { + return extension_uri_reference_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::extension_uri_reference() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_reference) + return _internal_extension_uri_reference(); +} +inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + extension_uri_reference_ = value; +} +inline void SimpleExtensionDeclaration_ExtensionFunction::set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_extension_uri_reference(value); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_reference) +} + +// uint32 function_anchor = 2; +inline void SimpleExtensionDeclaration_ExtensionFunction::clear_function_anchor() { + function_anchor_ = 0u; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::_internal_function_anchor() const { + return function_anchor_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::function_anchor() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor) + return _internal_function_anchor(); +} +inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + + function_anchor_ = value; +} +inline void SimpleExtensionDeclaration_ExtensionFunction::set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { + _internal_set_function_anchor(value); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor) +} + +// string name = 3; +inline void SimpleExtensionDeclaration_ExtensionFunction::clear_name() { + name_.ClearToEmpty(); +} +inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::name() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) + return _internal_name(); +} +template +PROTOBUF_ALWAYS_INLINE +inline void SimpleExtensionDeclaration_ExtensionFunction::set_name(ArgT0&& arg0, ArgT... args) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) +} +inline std::string* SimpleExtensionDeclaration_ExtensionFunction::mutable_name() { + // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) + return _internal_mutable_name(); +} +inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::_internal_name() const { + return name_.Get(); +} +inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_name(const std::string& value) { + + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); +} +inline std::string* SimpleExtensionDeclaration_ExtensionFunction::_internal_mutable_name() { + + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); +} +inline std::string* SimpleExtensionDeclaration_ExtensionFunction::release_name() { + // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); +} +inline void SimpleExtensionDeclaration_ExtensionFunction::set_allocated_name(std::string* name) { + if (name != nullptr) { + + } else { + + } + name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, + GetArena()); + // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) +} + +// ------------------------------------------------------------------- + +// SimpleExtensionDeclaration + +// .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; +inline bool SimpleExtensionDeclaration::_internal_has_extension_type() const { + return mapping_type_case() == kExtensionType; +} +inline bool SimpleExtensionDeclaration::has_extension_type() const { + return _internal_has_extension_type(); +} +inline void SimpleExtensionDeclaration::set_has_extension_type() { + _oneof_case_[0] = kExtensionType; +} +inline void SimpleExtensionDeclaration::clear_extension_type() { + if (_internal_has_extension_type()) { + if (GetArena() == nullptr) { + delete mapping_type_.extension_type_; + } + clear_has_mapping_type(); + } +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::release_extension_type() { + // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.extension_type) + if (_internal_has_extension_type()) { + clear_has_mapping_type(); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + mapping_type_.extension_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& SimpleExtensionDeclaration::_internal_extension_type() const { + return _internal_has_extension_type() + ? *mapping_type_.extension_type_ + : reinterpret_cast< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType&>(::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_); +} +inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& SimpleExtensionDeclaration::extension_type() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.extension_type) + return _internal_extension_type(); +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::unsafe_arena_release_extension_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.extensions.SimpleExtensionDeclaration.extension_type) + if (_internal_has_extension_type()) { + clear_has_mapping_type(); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_; + mapping_type_.extension_type_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) { + clear_mapping_type(); + if (extension_type) { + set_has_extension_type(); + mapping_type_.extension_type_ = extension_type; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type) +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::_internal_mutable_extension_type() { + if (!_internal_has_extension_type()) { + clear_mapping_type(); + set_has_extension_type(); + mapping_type_.extension_type_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(GetArena()); + } + return mapping_type_.extension_type_; +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::mutable_extension_type() { + // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_type) + return _internal_mutable_extension_type(); +} + +// .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; +inline bool SimpleExtensionDeclaration::_internal_has_extension_type_variation() const { + return mapping_type_case() == kExtensionTypeVariation; +} +inline bool SimpleExtensionDeclaration::has_extension_type_variation() const { + return _internal_has_extension_type_variation(); +} +inline void SimpleExtensionDeclaration::set_has_extension_type_variation() { + _oneof_case_[0] = kExtensionTypeVariation; +} +inline void SimpleExtensionDeclaration::clear_extension_type_variation() { + if (_internal_has_extension_type_variation()) { + if (GetArena() == nullptr) { + delete mapping_type_.extension_type_variation_; + } + clear_has_mapping_type(); + } +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::release_extension_type_variation() { + // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) + if (_internal_has_extension_type_variation()) { + clear_has_mapping_type(); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + mapping_type_.extension_type_variation_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& SimpleExtensionDeclaration::_internal_extension_type_variation() const { + return _internal_has_extension_type_variation() + ? *mapping_type_.extension_type_variation_ + : reinterpret_cast< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation&>(::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_); +} +inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& SimpleExtensionDeclaration::extension_type_variation() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) + return _internal_extension_type_variation(); +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::unsafe_arena_release_extension_type_variation() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) + if (_internal_has_extension_type_variation()) { + clear_has_mapping_type(); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_; + mapping_type_.extension_type_variation_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) { + clear_mapping_type(); + if (extension_type_variation) { + set_has_extension_type_variation(); + mapping_type_.extension_type_variation_ = extension_type_variation; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::_internal_mutable_extension_type_variation() { + if (!_internal_has_extension_type_variation()) { + clear_mapping_type(); + set_has_extension_type_variation(); + mapping_type_.extension_type_variation_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(GetArena()); + } + return mapping_type_.extension_type_variation_; +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::mutable_extension_type_variation() { + // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) + return _internal_mutable_extension_type_variation(); +} + +// .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; +inline bool SimpleExtensionDeclaration::_internal_has_extension_function() const { + return mapping_type_case() == kExtensionFunction; +} +inline bool SimpleExtensionDeclaration::has_extension_function() const { + return _internal_has_extension_function(); +} +inline void SimpleExtensionDeclaration::set_has_extension_function() { + _oneof_case_[0] = kExtensionFunction; +} +inline void SimpleExtensionDeclaration::clear_extension_function() { + if (_internal_has_extension_function()) { + if (GetArena() == nullptr) { + delete mapping_type_.extension_function_; + } + clear_has_mapping_type(); + } +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::release_extension_function() { + // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.extension_function) + if (_internal_has_extension_function()) { + clear_has_mapping_type(); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + mapping_type_.extension_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& SimpleExtensionDeclaration::_internal_extension_function() const { + return _internal_has_extension_function() + ? *mapping_type_.extension_function_ + : reinterpret_cast< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction&>(::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_); +} +inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& SimpleExtensionDeclaration::extension_function() const { + // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.extension_function) + return _internal_extension_function(); +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::unsafe_arena_release_extension_function() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.extensions.SimpleExtensionDeclaration.extension_function) + if (_internal_has_extension_function()) { + clear_has_mapping_type(); + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_; + mapping_type_.extension_function_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) { + clear_mapping_type(); + if (extension_function) { + set_has_extension_function(); + mapping_type_.extension_function_ = extension_function; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_function) +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::_internal_mutable_extension_function() { + if (!_internal_has_extension_function()) { + clear_mapping_type(); + set_has_extension_function(); + mapping_type_.extension_function_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(GetArena()); + } + return mapping_type_.extension_function_; +} +inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::mutable_extension_function() { + // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_function) + return _internal_mutable_extension_function(); +} + +inline bool SimpleExtensionDeclaration::has_mapping_type() const { + return mapping_type_case() != MAPPING_TYPE_NOT_SET; +} +inline void SimpleExtensionDeclaration::clear_has_mapping_type() { + _oneof_case_[0] = MAPPING_TYPE_NOT_SET; +} +inline SimpleExtensionDeclaration::MappingTypeCase SimpleExtensionDeclaration::mapping_type_case() const { + return SimpleExtensionDeclaration::MappingTypeCase(_oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// AdvancedExtension + +// .google.protobuf.Any optimization = 1; +inline bool AdvancedExtension::_internal_has_optimization() const { + return this != internal_default_instance() && optimization_ != nullptr; +} +inline bool AdvancedExtension::has_optimization() const { + return _internal_has_optimization(); +} +inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_optimization() const { + const PROTOBUF_NAMESPACE_ID::Any* p = optimization_; + return p != nullptr ? *p : reinterpret_cast( + PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +} +inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::optimization() const { + // @@protoc_insertion_point(field_get:substrait.extensions.AdvancedExtension.optimization) + return _internal_optimization(); +} +inline void AdvancedExtension::unsafe_arena_set_allocated_optimization( + PROTOBUF_NAMESPACE_ID::Any* optimization) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_); + } + optimization_ = optimization; + if (optimization) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.AdvancedExtension.optimization) +} +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_optimization() { + + PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; + optimization_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_optimization() { + // @@protoc_insertion_point(field_release:substrait.extensions.AdvancedExtension.optimization) + + PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; + optimization_ = nullptr; + return temp; +} +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_optimization() { + + if (optimization_ == nullptr) { + auto* p = CreateMaybeMessage(GetArena()); + optimization_ = p; + } + return optimization_; +} +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_optimization() { + // @@protoc_insertion_point(field_mutable:substrait.extensions.AdvancedExtension.optimization) + return _internal_mutable_optimization(); +} +inline void AdvancedExtension::set_allocated_optimization(PROTOBUF_NAMESPACE_ID::Any* optimization) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_); + } + if (optimization) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization)->GetArena(); + if (message_arena != submessage_arena) { + optimization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, optimization, submessage_arena); + } + + } else { + + } + optimization_ = optimization; + // @@protoc_insertion_point(field_set_allocated:substrait.extensions.AdvancedExtension.optimization) +} + +// .google.protobuf.Any enhancement = 2; +inline bool AdvancedExtension::_internal_has_enhancement() const { + return this != internal_default_instance() && enhancement_ != nullptr; +} +inline bool AdvancedExtension::has_enhancement() const { + return _internal_has_enhancement(); +} +inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_enhancement() const { + const PROTOBUF_NAMESPACE_ID::Any* p = enhancement_; + return p != nullptr ? *p : reinterpret_cast( + PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +} +inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::enhancement() const { + // @@protoc_insertion_point(field_get:substrait.extensions.AdvancedExtension.enhancement) + return _internal_enhancement(); +} +inline void AdvancedExtension::unsafe_arena_set_allocated_enhancement( + PROTOBUF_NAMESPACE_ID::Any* enhancement) { + if (GetArena() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_); + } + enhancement_ = enhancement; + if (enhancement) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.AdvancedExtension.enhancement) +} +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_enhancement() { + + PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; + enhancement_ = nullptr; + if (GetArena() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + return temp; +} +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_enhancement() { + // @@protoc_insertion_point(field_release:substrait.extensions.AdvancedExtension.enhancement) + + PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; + enhancement_ = nullptr; + return temp; +} +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_enhancement() { + + if (enhancement_ == nullptr) { + auto* p = CreateMaybeMessage(GetArena()); + enhancement_ = p; + } + return enhancement_; +} +inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_enhancement() { + // @@protoc_insertion_point(field_mutable:substrait.extensions.AdvancedExtension.enhancement) + return _internal_mutable_enhancement(); +} +inline void AdvancedExtension::set_allocated_enhancement(PROTOBUF_NAMESPACE_ID::Any* enhancement) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_); + } + if (enhancement) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement)->GetArena(); + if (message_arena != submessage_arena) { + enhancement = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, enhancement, submessage_arena); + } + + } else { + + } + enhancement_ = enhancement; + // @@protoc_insertion_point(field_set_allocated:substrait.extensions.AdvancedExtension.enhancement) +} + +#ifdef __GNUC__ + #pragma GCC diagnostic pop +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + +// ------------------------------------------------------------------- + + +// @@protoc_insertion_point(namespace_scope) + +} // namespace extensions +} // namespace substrait + +// @@protoc_insertion_point(global_scope) + +#include +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fextensions_2fextensions_2eproto diff --git a/cpp/src/generated/substrait/function.pb.cc b/cpp/src/generated/substrait/function.pb.cc index 6e561b86474..0a447b27bc2 100644 --- a/cpp/src/generated/substrait/function.pb.cc +++ b/cpp/src/generated/substrait/function.pb.cc @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: function.proto +// source: substrait/function.proto -#include "function.pb.h" +#include "substrait/function.pb.h" #include @@ -16,7 +16,6 @@ #include PROTOBUF_PRAGMA_INIT_SEG -namespace io { namespace substrait { constexpr FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) @@ -199,254 +198,254 @@ struct FunctionSignatureDefaultTypeInternal { }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignatureDefaultTypeInternal _FunctionSignature_default_instance_; } // namespace substrait -} // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_function_2eproto[12]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_function_2eproto[3]; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_function_2eproto = nullptr; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ffunction_2eproto[12]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ffunction_2eproto[3]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ffunction_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_function_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_FinalArgVariadic, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_FinalArgVariadic, min_args_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_FinalArgVariadic, max_args_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_FinalArgVariadic, consistency_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, min_args_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, max_args_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, consistency_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_FinalArgNormal, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgNormal, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, arguments_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, name_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, description_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, deterministic_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, session_dependent_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, output_type_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, arguments_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, name_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, description_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, deterministic_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, session_dependent_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, output_type_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, implementations_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Scalar, final_variable_behavior_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, implementations_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, final_variable_behavior_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, arguments_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, name_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, description_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, deterministic_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, session_dependent_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, output_type_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, arguments_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, name_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, description_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, deterministic_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, session_dependent_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, output_type_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, ordered_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, max_set_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, intermediate_type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, implementations_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Aggregate, final_variable_behavior_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, ordered_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, max_set_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, intermediate_type_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, implementations_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, final_variable_behavior_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, arguments_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, name_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, description_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, deterministic_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, session_dependent_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, intermediate_type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, output_type_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, arguments_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, name_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, description_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, deterministic_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, session_dependent_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, intermediate_type_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, output_type_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, ordered_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, max_set_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, window_type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, implementations_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Window, final_variable_behavior_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, ordered_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, max_set_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, window_type_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, implementations_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, final_variable_behavior_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Description, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Description, language_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Description, body_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, language_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, body_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Implementation, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Implementation, type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Implementation, uri_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, type_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, uri_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_ValueArgument, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_ValueArgument, type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_ValueArgument, constant_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, type_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, constant_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_TypeArgument, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_TypeArgument, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_TypeArgument, type_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_TypeArgument, type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_EnumArgument, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_EnumArgument, options_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument_EnumArgument, optional_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, options_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, optional_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument, name_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, name_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature_Argument, argument_kind_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, argument_kind_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FunctionSignature, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::FunctionSignature_FinalArgVariadic)}, - { 8, -1, sizeof(::io::substrait::FunctionSignature_FinalArgNormal)}, - { 13, -1, sizeof(::io::substrait::FunctionSignature_Scalar)}, - { 28, -1, sizeof(::io::substrait::FunctionSignature_Aggregate)}, - { 46, -1, sizeof(::io::substrait::FunctionSignature_Window)}, - { 65, -1, sizeof(::io::substrait::FunctionSignature_Description)}, - { 72, -1, sizeof(::io::substrait::FunctionSignature_Implementation)}, - { 79, -1, sizeof(::io::substrait::FunctionSignature_Argument_ValueArgument)}, - { 86, -1, sizeof(::io::substrait::FunctionSignature_Argument_TypeArgument)}, - { 92, -1, sizeof(::io::substrait::FunctionSignature_Argument_EnumArgument)}, - { 99, -1, sizeof(::io::substrait::FunctionSignature_Argument)}, - { 109, -1, sizeof(::io::substrait::FunctionSignature)}, + { 0, -1, sizeof(::substrait::FunctionSignature_FinalArgVariadic)}, + { 8, -1, sizeof(::substrait::FunctionSignature_FinalArgNormal)}, + { 13, -1, sizeof(::substrait::FunctionSignature_Scalar)}, + { 28, -1, sizeof(::substrait::FunctionSignature_Aggregate)}, + { 46, -1, sizeof(::substrait::FunctionSignature_Window)}, + { 65, -1, sizeof(::substrait::FunctionSignature_Description)}, + { 72, -1, sizeof(::substrait::FunctionSignature_Implementation)}, + { 79, -1, sizeof(::substrait::FunctionSignature_Argument_ValueArgument)}, + { 86, -1, sizeof(::substrait::FunctionSignature_Argument_TypeArgument)}, + { 92, -1, sizeof(::substrait::FunctionSignature_Argument_EnumArgument)}, + { 99, -1, sizeof(::substrait::FunctionSignature_Argument)}, + { 109, -1, sizeof(::substrait::FunctionSignature)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::_FunctionSignature_FinalArgVariadic_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_FinalArgNormal_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_Scalar_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_Aggregate_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_Window_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_Description_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_Implementation_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_Argument_default_instance_), - reinterpret_cast(&::io::substrait::_FunctionSignature_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_FinalArgVariadic_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_FinalArgNormal_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Scalar_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Aggregate_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Window_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Description_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Implementation_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_Argument_default_instance_), + reinterpret_cast(&::substrait::_FunctionSignature_default_instance_), }; -const char descriptor_table_protodef_function_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\016function.proto\022\014io.substrait\032\ntype.pro" - "to\032\031parameterized_types.proto\032\026type_expr" - "essions.proto\"\223\025\n\021FunctionSignature\032\331\001\n\020" - "FinalArgVariadic\022\020\n\010min_args\030\001 \001(\003\022\020\n\010ma" - "x_args\030\002 \001(\003\022Z\n\013consistency\030\003 \001(\0162E.io.s" - "ubstrait.FunctionSignature.FinalArgVaria" - "dic.ParameterConsistency\"E\n\024ParameterCon" - "sistency\022\013\n\007UNKNOWN\020\000\022\016\n\nCONSISTENT\020\001\022\020\n" - "\014INCONSISTENT\020\002\032\020\n\016FinalArgNormal\032\354\003\n\006Sc" - "alar\022;\n\targuments\030\002 \003(\0132(.io.substrait.F" - "unctionSignature.Argument\022\014\n\004name\030\003 \003(\t\022" - "@\n\013description\030\004 \001(\0132+.io.substrait.Func" - "tionSignature.Description\022\025\n\rdeterminist" - "ic\030\007 \001(\010\022\031\n\021session_dependent\030\010 \001(\010\0227\n\013o" - "utput_type\030\t \001(\0132\".io.substrait.Derivati" - "onExpression\022D\n\010variadic\030\n \001(\01320.io.subs" - "trait.FunctionSignature.FinalArgVariadic" - "H\000\022@\n\006normal\030\013 \001(\0132..io.substrait.Functi" - "onSignature.FinalArgNormalH\000\022G\n\017implemen" - "tations\030\014 \003(\0132..io.substrait.FunctionSig" - "nature.ImplementationB\031\n\027final_variable_" - "behavior\032\300\004\n\tAggregate\022;\n\targuments\030\002 \003(" - "\0132(.io.substrait.FunctionSignature.Argum" - "ent\022\014\n\004name\030\003 \001(\t\022@\n\013description\030\004 \001(\0132+" - ".io.substrait.FunctionSignature.Descript" - "ion\022\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_de" - "pendent\030\010 \001(\010\0227\n\013output_type\030\t \001(\0132\".io." - "substrait.DerivationExpression\022D\n\010variad" - "ic\030\n \001(\01320.io.substrait.FunctionSignatur" - "e.FinalArgVariadicH\000\022@\n\006normal\030\013 \001(\0132..i" - "o.substrait.FunctionSignature.FinalArgNo" - "rmalH\000\022\017\n\007ordered\030\016 \001(\010\022\017\n\007max_set\030\014 \001(\004" - "\022-\n\021intermediate_type\030\r \001(\0132\022.io.substra" - "it.Type\022G\n\017implementations\030\017 \003(\0132..io.su" - "bstrait.FunctionSignature.Implementation" - "B\031\n\027final_variable_behavior\032\316\005\n\006Window\022;" - "\n\targuments\030\002 \003(\0132(.io.substrait.Functio" - "nSignature.Argument\022\014\n\004name\030\003 \003(\t\022@\n\013des" - "cription\030\004 \001(\0132+.io.substrait.FunctionSi" - "gnature.Description\022\025\n\rdeterministic\030\007 \001" - "(\010\022\031\n\021session_dependent\030\010 \001(\010\022=\n\021interme" - "diate_type\030\t \001(\0132\".io.substrait.Derivati" - "onExpression\0227\n\013output_type\030\n \001(\0132\".io.s" - "ubstrait.DerivationExpression\022D\n\010variadi" - "c\030\020 \001(\01320.io.substrait.FunctionSignature" - ".FinalArgVariadicH\000\022@\n\006normal\030\021 \001(\0132..io" - ".substrait.FunctionSignature.FinalArgNor" - "malH\000\022\017\n\007ordered\030\013 \001(\010\022\017\n\007max_set\030\014 \001(\004\022" - "F\n\013window_type\030\016 \001(\01621.io.substrait.Func" - "tionSignature.Window.WindowType\022G\n\017imple" - "mentations\030\017 \003(\0132..io.substrait.Function" - "Signature.Implementation\"7\n\nWindowType\022\013" - "\n\007UNKNOWN\020\000\022\r\n\tSTREAMING\020\001\022\r\n\tPARTITION\020" - "\002B\031\n\027final_variable_behavior\032-\n\013Descript" - "ion\022\020\n\010language\030\001 \001(\t\022\014\n\004body\030\002 \001(\t\032\226\001\n\016" - "Implementation\022A\n\004type\030\001 \001(\01623.io.substr" - "ait.FunctionSignature.Implementation.Typ" - "e\022\013\n\003uri\030\002 \001(\t\"4\n\004Type\022\013\n\007UNKNOWN\020\000\022\020\n\014W" - "EB_ASSEMBLY\020\001\022\r\n\tTRINO_JAR\020\002\032\304\003\n\010Argumen" - "t\022\014\n\004name\030\001 \001(\t\022G\n\005value\030\002 \001(\01326.io.subs" - "trait.FunctionSignature.Argument.ValueAr" - "gumentH\000\022E\n\004type\030\003 \001(\01325.io.substrait.Fu" - "nctionSignature.Argument.TypeArgumentH\000\022" - "E\n\004enum\030\004 \001(\01325.io.substrait.FunctionSig" - "nature.Argument.EnumArgumentH\000\032P\n\rValueA" - "rgument\022-\n\004type\030\001 \001(\0132\037.io.substrait.Par" - "ameterizedType\022\020\n\010constant\030\002 \001(\010\032=\n\014Type" - "Argument\022-\n\004type\030\001 \001(\0132\037.io.substrait.Pa" - "rameterizedType\0321\n\014EnumArgument\022\017\n\007optio" - "ns\030\001 \003(\t\022\020\n\010optional\030\002 \001(\010B\017\n\rargument_k" - "indB+\n\022io.substrait.protoP\001\252\002\022Substrait." - "Protobufb\006proto3" +const char descriptor_table_protodef_substrait_2ffunction_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\030substrait/function.proto\022\tsubstrait\032\024s" + "ubstrait/type.proto\032#substrait/parameter" + "ized_types.proto\032 substrait/type_express" + "ions.proto\"\301\025\n\021FunctionSignature\032\235\002\n\020Fin" + "alArgVariadic\022\020\n\010min_args\030\001 \001(\003\022\020\n\010max_a" + "rgs\030\002 \001(\003\022W\n\013consistency\030\003 \001(\0162B.substra" + "it.FunctionSignature.FinalArgVariadic.Pa" + "rameterConsistency\"\213\001\n\024ParameterConsiste" + "ncy\022%\n!PARAMETER_CONSISTENCY_UNSPECIFIED" + "\020\000\022$\n PARAMETER_CONSISTENCY_CONSISTENT\020\001" + "\022&\n\"PARAMETER_CONSISTENCY_INCONSISTENT\020\002" + "\032\020\n\016FinalArgNormal\032\332\003\n\006Scalar\0228\n\targumen" + "ts\030\002 \003(\0132%.substrait.FunctionSignature.A" + "rgument\022\014\n\004name\030\003 \003(\t\022=\n\013description\030\004 \001" + "(\0132(.substrait.FunctionSignature.Descrip" + "tion\022\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_d" + "ependent\030\010 \001(\010\0224\n\013output_type\030\t \001(\0132\037.su" + "bstrait.DerivationExpression\022A\n\010variadic" + "\030\n \001(\0132-.substrait.FunctionSignature.Fin" + "alArgVariadicH\000\022=\n\006normal\030\013 \001(\0132+.substr" + "ait.FunctionSignature.FinalArgNormalH\000\022D" + "\n\017implementations\030\014 \003(\0132+.substrait.Func" + "tionSignature.ImplementationB\031\n\027final_va" + "riable_behavior\032\253\004\n\tAggregate\0228\n\targumen" + "ts\030\002 \003(\0132%.substrait.FunctionSignature.A" + "rgument\022\014\n\004name\030\003 \001(\t\022=\n\013description\030\004 \001" + "(\0132(.substrait.FunctionSignature.Descrip" + "tion\022\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_d" + "ependent\030\010 \001(\010\0224\n\013output_type\030\t \001(\0132\037.su" + "bstrait.DerivationExpression\022A\n\010variadic" + "\030\n \001(\0132-.substrait.FunctionSignature.Fin" + "alArgVariadicH\000\022=\n\006normal\030\013 \001(\0132+.substr" + "ait.FunctionSignature.FinalArgNormalH\000\022\017" + "\n\007ordered\030\016 \001(\010\022\017\n\007max_set\030\014 \001(\004\022*\n\021inte" + "rmediate_type\030\r \001(\0132\017.substrait.Type\022D\n\017" + "implementations\030\017 \003(\0132+.substrait.Functi" + "onSignature.ImplementationB\031\n\027final_vari" + "able_behavior\032\336\005\n\006Window\0228\n\targuments\030\002 " + "\003(\0132%.substrait.FunctionSignature.Argume" + "nt\022\014\n\004name\030\003 \003(\t\022=\n\013description\030\004 \001(\0132(." + "substrait.FunctionSignature.Description\022" + "\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_depend" + "ent\030\010 \001(\010\022:\n\021intermediate_type\030\t \001(\0132\037.s" + "ubstrait.DerivationExpression\0224\n\013output_" + "type\030\n \001(\0132\037.substrait.DerivationExpress" + "ion\022A\n\010variadic\030\020 \001(\0132-.substrait.Functi" + "onSignature.FinalArgVariadicH\000\022=\n\006normal" + "\030\021 \001(\0132+.substrait.FunctionSignature.Fin" + "alArgNormalH\000\022\017\n\007ordered\030\013 \001(\010\022\017\n\007max_se" + "t\030\014 \001(\004\022C\n\013window_type\030\016 \001(\0162..substrait" + ".FunctionSignature.Window.WindowType\022D\n\017" + "implementations\030\017 \003(\0132+.substrait.Functi" + "onSignature.Implementation\"_\n\nWindowType" + "\022\033\n\027WINDOW_TYPE_UNSPECIFIED\020\000\022\031\n\025WINDOW_" + "TYPE_STREAMING\020\001\022\031\n\025WINDOW_TYPE_PARTITIO" + "N\020\002B\031\n\027final_variable_behavior\032-\n\013Descri" + "ption\022\020\n\010language\030\001 \001(\t\022\014\n\004body\030\002 \001(\t\032\246\001" + "\n\016Implementation\022>\n\004type\030\001 \001(\01620.substra" + "it.FunctionSignature.Implementation.Type" + "\022\013\n\003uri\030\002 \001(\t\"G\n\004Type\022\024\n\020TYPE_UNSPECIFIE" + "D\020\000\022\025\n\021TYPE_WEB_ASSEMBLY\020\001\022\022\n\016TYPE_TRINO" + "_JAR\020\002\032\265\003\n\010Argument\022\014\n\004name\030\001 \001(\t\022D\n\005val" + "ue\030\002 \001(\01323.substrait.FunctionSignature.A" + "rgument.ValueArgumentH\000\022B\n\004type\030\003 \001(\01322." + "substrait.FunctionSignature.Argument.Typ" + "eArgumentH\000\022B\n\004enum\030\004 \001(\01322.substrait.Fu" + "nctionSignature.Argument.EnumArgumentH\000\032" + "M\n\rValueArgument\022*\n\004type\030\001 \001(\0132\034.substra" + "it.ParameterizedType\022\020\n\010constant\030\002 \001(\010\032:" + "\n\014TypeArgument\022*\n\004type\030\001 \001(\0132\034.substrait" + ".ParameterizedType\0321\n\014EnumArgument\022\017\n\007op" + "tions\030\001 \003(\t\022\020\n\010optional\030\002 \001(\010B\017\n\rargumen" + "t_kindB+\n\022io.substrait.protoP\001\252\002\022Substra" + "it.Protobufb\006proto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_function_2eproto_deps[3] = { - &::descriptor_table_parameterized_5ftypes_2eproto, - &::descriptor_table_type_2eproto, - &::descriptor_table_type_5fexpressions_2eproto, +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2ffunction_2eproto_deps[3] = { + &::descriptor_table_substrait_2fparameterized_5ftypes_2eproto, + &::descriptor_table_substrait_2ftype_2eproto, + &::descriptor_table_substrait_2ftype_5fexpressions_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_function_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_function_2eproto = { - false, false, 2856, descriptor_table_protodef_function_2eproto, "function.proto", - &descriptor_table_function_2eproto_once, descriptor_table_function_2eproto_deps, 3, 12, - schemas, file_default_instances, TableStruct_function_2eproto::offsets, - file_level_metadata_function_2eproto, file_level_enum_descriptors_function_2eproto, file_level_service_descriptors_function_2eproto, +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ffunction_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ffunction_2eproto = { + false, false, 2939, descriptor_table_protodef_substrait_2ffunction_2eproto, "substrait/function.proto", + &descriptor_table_substrait_2ffunction_2eproto_once, descriptor_table_substrait_2ffunction_2eproto_deps, 3, 12, + schemas, file_default_instances, TableStruct_substrait_2ffunction_2eproto::offsets, + file_level_metadata_substrait_2ffunction_2eproto, file_level_enum_descriptors_substrait_2ffunction_2eproto, file_level_service_descriptors_substrait_2ffunction_2eproto, }; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_function_2eproto_getter() { - return &descriptor_table_function_2eproto; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ffunction_2eproto_getter() { + return &descriptor_table_substrait_2ffunction_2eproto; } // Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_function_2eproto(&descriptor_table_function_2eproto); -namespace io { +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ffunction_2eproto(&descriptor_table_substrait_2ffunction_2eproto); namespace substrait { const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_function_2eproto); - return file_level_enum_descriptors_function_2eproto[0]; + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto); + return file_level_enum_descriptors_substrait_2ffunction_2eproto[0]; } bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value) { switch (value) { @@ -460,16 +459,16 @@ bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value) } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::UNKNOWN; -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::CONSISTENT; -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::INCONSISTENT; +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_UNSPECIFIED; +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_CONSISTENT; +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_INCONSISTENT; constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MIN; constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MAX; constexpr int FunctionSignature_FinalArgVariadic::ParameterConsistency_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_function_2eproto); - return file_level_enum_descriptors_function_2eproto[1]; + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto); + return file_level_enum_descriptors_substrait_2ffunction_2eproto[1]; } bool FunctionSignature_Window_WindowType_IsValid(int value) { switch (value) { @@ -483,16 +482,16 @@ bool FunctionSignature_Window_WindowType_IsValid(int value) { } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::UNKNOWN; -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::STREAMING; -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::PARTITION; +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_UNSPECIFIED; +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_STREAMING; +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_PARTITION; constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MIN; constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MAX; constexpr int FunctionSignature_Window::WindowType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_function_2eproto); - return file_level_enum_descriptors_function_2eproto[2]; + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto); + return file_level_enum_descriptors_substrait_2ffunction_2eproto[2]; } bool FunctionSignature_Implementation_Type_IsValid(int value) { switch (value) { @@ -506,9 +505,9 @@ bool FunctionSignature_Implementation_Type_IsValid(int value) { } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::UNKNOWN; -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::WEB_ASSEMBLY; -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TRINO_JAR; +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_UNSPECIFIED; +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_WEB_ASSEMBLY; +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_TRINO_JAR; constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MIN; constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MAX; constexpr int FunctionSignature_Implementation::Type_ARRAYSIZE; @@ -524,7 +523,7 @@ FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(::PROTOBU : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.FinalArgVariadic) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.FinalArgVariadic) } FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(const FunctionSignature_FinalArgVariadic& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -532,7 +531,7 @@ FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(const Fun ::memcpy(&min_args_, &from.min_args_, static_cast(reinterpret_cast(&consistency_) - reinterpret_cast(&min_args_)) + sizeof(consistency_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.FinalArgVariadic) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.FinalArgVariadic) } void FunctionSignature_FinalArgVariadic::SharedCtor() { @@ -543,7 +542,7 @@ ::memset(reinterpret_cast(this) + static_cast( } FunctionSignature_FinalArgVariadic::~FunctionSignature_FinalArgVariadic() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.FinalArgVariadic) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.FinalArgVariadic) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -563,7 +562,7 @@ void FunctionSignature_FinalArgVariadic::SetCachedSize(int size) const { } void FunctionSignature_FinalArgVariadic::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.FinalArgVariadic) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.FinalArgVariadic) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -594,12 +593,12 @@ const char* FunctionSignature_FinalArgVariadic::_InternalParse(const char* ptr, CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; + // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_consistency(static_cast<::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>(val)); + _internal_set_consistency(static_cast<::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>(val)); } else goto handle_unusual; continue; default: { @@ -627,7 +626,7 @@ const char* FunctionSignature_FinalArgVariadic::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_FinalArgVariadic::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.FinalArgVariadic) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.FinalArgVariadic) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -643,7 +642,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_FinalArgVariadic::_InternalSer target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_max_args(), target); } - // .io.substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; + // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; if (this->consistency() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -654,12 +653,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_FinalArgVariadic::_InternalSer target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.FinalArgVariadic) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.FinalArgVariadic) return target; } size_t FunctionSignature_FinalArgVariadic::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.FinalArgVariadic) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.FinalArgVariadic) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -680,7 +679,7 @@ size_t FunctionSignature_FinalArgVariadic::ByteSizeLong() const { this->_internal_max_args()); } - // .io.substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; + // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; if (this->consistency() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_consistency()); @@ -696,22 +695,22 @@ size_t FunctionSignature_FinalArgVariadic::ByteSizeLong() const { } void FunctionSignature_FinalArgVariadic::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.FinalArgVariadic) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.FinalArgVariadic) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_FinalArgVariadic* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.FinalArgVariadic) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.FinalArgVariadic) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.FinalArgVariadic) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.FinalArgVariadic) MergeFrom(*source); } } void FunctionSignature_FinalArgVariadic::MergeFrom(const FunctionSignature_FinalArgVariadic& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.FinalArgVariadic) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.FinalArgVariadic) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -729,14 +728,14 @@ void FunctionSignature_FinalArgVariadic::MergeFrom(const FunctionSignature_Final } void FunctionSignature_FinalArgVariadic::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.FinalArgVariadic) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.FinalArgVariadic) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_FinalArgVariadic::CopyFrom(const FunctionSignature_FinalArgVariadic& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.FinalArgVariadic) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.FinalArgVariadic) if (&from == this) return; Clear(); MergeFrom(from); @@ -759,8 +758,8 @@ void FunctionSignature_FinalArgVariadic::InternalSwap(FunctionSignature_FinalArg ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgVariadic::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[0]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[0]); } // =================================================================== @@ -773,19 +772,19 @@ FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(::PROTOBUF_NA : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.FinalArgNormal) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.FinalArgNormal) } FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(const FunctionSignature_FinalArgNormal& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.FinalArgNormal) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.FinalArgNormal) } void FunctionSignature_FinalArgNormal::SharedCtor() { } FunctionSignature_FinalArgNormal::~FunctionSignature_FinalArgNormal() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.FinalArgNormal) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.FinalArgNormal) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -805,7 +804,7 @@ void FunctionSignature_FinalArgNormal::SetCachedSize(int size) const { } void FunctionSignature_FinalArgNormal::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.FinalArgNormal) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.FinalArgNormal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -839,7 +838,7 @@ const char* FunctionSignature_FinalArgNormal::_InternalParse(const char* ptr, :: ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_FinalArgNormal::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.FinalArgNormal) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.FinalArgNormal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -847,12 +846,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_FinalArgNormal::_InternalSeria target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.FinalArgNormal) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.FinalArgNormal) return target; } size_t FunctionSignature_FinalArgNormal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.FinalArgNormal) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.FinalArgNormal) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -869,22 +868,22 @@ size_t FunctionSignature_FinalArgNormal::ByteSizeLong() const { } void FunctionSignature_FinalArgNormal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.FinalArgNormal) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.FinalArgNormal) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_FinalArgNormal* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.FinalArgNormal) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.FinalArgNormal) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.FinalArgNormal) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.FinalArgNormal) MergeFrom(*source); } } void FunctionSignature_FinalArgNormal::MergeFrom(const FunctionSignature_FinalArgNormal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.FinalArgNormal) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.FinalArgNormal) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -893,14 +892,14 @@ void FunctionSignature_FinalArgNormal::MergeFrom(const FunctionSignature_FinalAr } void FunctionSignature_FinalArgNormal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.FinalArgNormal) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.FinalArgNormal) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_FinalArgNormal::CopyFrom(const FunctionSignature_FinalArgNormal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.FinalArgNormal) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.FinalArgNormal) if (&from == this) return; Clear(); MergeFrom(from); @@ -917,33 +916,33 @@ void FunctionSignature_FinalArgNormal::InternalSwap(FunctionSignature_FinalArgNo ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgNormal::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[1]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[1]); } // =================================================================== class FunctionSignature_Scalar::_Internal { public: - static const ::io::substrait::FunctionSignature_Description& description(const FunctionSignature_Scalar* msg); - static const ::io::substrait::DerivationExpression& output_type(const FunctionSignature_Scalar* msg); - static const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Scalar* msg); - static const ::io::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Scalar* msg); + static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Scalar* msg); + static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Scalar* msg); + static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Scalar* msg); + static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Scalar* msg); }; -const ::io::substrait::FunctionSignature_Description& +const ::substrait::FunctionSignature_Description& FunctionSignature_Scalar::_Internal::description(const FunctionSignature_Scalar* msg) { return *msg->description_; } -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& FunctionSignature_Scalar::_Internal::output_type(const FunctionSignature_Scalar* msg) { return *msg->output_type_; } -const ::io::substrait::FunctionSignature_FinalArgVariadic& +const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::_Internal::variadic(const FunctionSignature_Scalar* msg) { return *msg->final_variable_behavior_.variadic_; } -const ::io::substrait::FunctionSignature_FinalArgNormal& +const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::_Internal::normal(const FunctionSignature_Scalar* msg) { return *msg->final_variable_behavior_.normal_; } @@ -953,7 +952,7 @@ void FunctionSignature_Scalar::clear_output_type() { } output_type_ = nullptr; } -void FunctionSignature_Scalar::set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { +void FunctionSignature_Scalar::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_final_variable_behavior(); if (variadic) { @@ -966,9 +965,9 @@ void FunctionSignature_Scalar::set_allocated_variadic(::io::substrait::FunctionS set_has_variadic(); final_variable_behavior_.variadic_ = variadic; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Scalar.variadic) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.variadic) } -void FunctionSignature_Scalar::set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { +void FunctionSignature_Scalar::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_final_variable_behavior(); if (normal) { @@ -981,7 +980,7 @@ void FunctionSignature_Scalar::set_allocated_normal(::io::substrait::FunctionSig set_has_normal(); final_variable_behavior_.normal_ = normal; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Scalar.normal) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.normal) } FunctionSignature_Scalar::FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), @@ -990,7 +989,7 @@ FunctionSignature_Scalar::FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Aren implementations_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Scalar) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Scalar) } FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scalar& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -999,12 +998,12 @@ FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scala implementations_(from.implementations_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_description()) { - description_ = new ::io::substrait::FunctionSignature_Description(*from.description_); + description_ = new ::substrait::FunctionSignature_Description(*from.description_); } else { description_ = nullptr; } if (from._internal_has_output_type()) { - output_type_ = new ::io::substrait::DerivationExpression(*from.output_type_); + output_type_ = new ::substrait::DerivationExpression(*from.output_type_); } else { output_type_ = nullptr; } @@ -1014,18 +1013,18 @@ FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scala clear_has_final_variable_behavior(); switch (from.final_variable_behavior_case()) { case kVariadic: { - _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); break; } case kNormal: { - _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); break; } case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Scalar) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Scalar) } void FunctionSignature_Scalar::SharedCtor() { @@ -1037,7 +1036,7 @@ clear_has_final_variable_behavior(); } FunctionSignature_Scalar::~FunctionSignature_Scalar() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Scalar) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Scalar) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1062,7 +1061,7 @@ void FunctionSignature_Scalar::SetCachedSize(int size) const { } void FunctionSignature_Scalar::clear_final_variable_behavior() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.FunctionSignature.Scalar) +// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Scalar) switch (final_variable_behavior_case()) { case kVariadic: { if (GetArena() == nullptr) { @@ -1085,7 +1084,7 @@ void FunctionSignature_Scalar::clear_final_variable_behavior() { void FunctionSignature_Scalar::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Scalar) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Scalar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1114,7 +1113,7 @@ const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -1134,13 +1133,13 @@ const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF ptr += 1; auto str = _internal_add_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Scalar.name")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Scalar.name")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); @@ -1161,28 +1160,28 @@ const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression output_type = 9; + // .substrait.DerivationExpression output_type = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + // .substrait.FunctionSignature.FinalArgNormal normal = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.FunctionSignature.Implementation implementations = 12; + // repeated .substrait.FunctionSignature.Implementation implementations = 12; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { ptr -= 1; @@ -1219,11 +1218,11 @@ const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Scalar) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Scalar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; for (unsigned int i = 0, n = static_cast(this->_internal_arguments_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -1237,11 +1236,11 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.FunctionSignature.Scalar.name"); + "substrait.FunctionSignature.Scalar.name"); target = stream->WriteString(3, s, target); } - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; if (this->has_description()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1261,7 +1260,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); } - // .io.substrait.DerivationExpression output_type = 9; + // .substrait.DerivationExpression output_type = 9; if (this->has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1269,7 +1268,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( 9, _Internal::output_type(this), target, stream); } - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; if (_internal_has_variadic()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1277,7 +1276,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( 10, _Internal::variadic(this), target, stream); } - // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + // .substrait.FunctionSignature.FinalArgNormal normal = 11; if (_internal_has_normal()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1285,7 +1284,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( 11, _Internal::normal(this), target, stream); } - // repeated .io.substrait.FunctionSignature.Implementation implementations = 12; + // repeated .substrait.FunctionSignature.Implementation implementations = 12; for (unsigned int i = 0, n = static_cast(this->_internal_implementations_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -1297,19 +1296,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Scalar) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Scalar) return target; } size_t FunctionSignature_Scalar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Scalar) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Scalar) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; total_size += 1UL * this->_internal_arguments_size(); for (const auto& msg : this->arguments_) { total_size += @@ -1324,21 +1323,21 @@ size_t FunctionSignature_Scalar::ByteSizeLong() const { name_.Get(i)); } - // repeated .io.substrait.FunctionSignature.Implementation implementations = 12; + // repeated .substrait.FunctionSignature.Implementation implementations = 12; total_size += 1UL * this->_internal_implementations_size(); for (const auto& msg : this->implementations_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; if (this->has_description()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *description_); } - // .io.substrait.DerivationExpression output_type = 9; + // .substrait.DerivationExpression output_type = 9; if (this->has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1356,14 +1355,14 @@ size_t FunctionSignature_Scalar::ByteSizeLong() const { } switch (final_variable_behavior_case()) { - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; case kVariadic: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *final_variable_behavior_.variadic_); break; } - // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + // .substrait.FunctionSignature.FinalArgNormal normal = 11; case kNormal: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1384,22 +1383,22 @@ size_t FunctionSignature_Scalar::ByteSizeLong() const { } void FunctionSignature_Scalar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Scalar) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Scalar) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_Scalar* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Scalar) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Scalar) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Scalar) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Scalar) MergeFrom(*source); } } void FunctionSignature_Scalar::MergeFrom(const FunctionSignature_Scalar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Scalar) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Scalar) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1409,10 +1408,10 @@ void FunctionSignature_Scalar::MergeFrom(const FunctionSignature_Scalar& from) { name_.MergeFrom(from.name_); implementations_.MergeFrom(from.implementations_); if (from.has_description()) { - _internal_mutable_description()->::io::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); + _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); } if (from.has_output_type()) { - _internal_mutable_output_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); + _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); } if (from.deterministic() != 0) { _internal_set_deterministic(from._internal_deterministic()); @@ -1422,11 +1421,11 @@ void FunctionSignature_Scalar::MergeFrom(const FunctionSignature_Scalar& from) { } switch (from.final_variable_behavior_case()) { case kVariadic: { - _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); break; } case kNormal: { - _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); break; } case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { @@ -1436,14 +1435,14 @@ void FunctionSignature_Scalar::MergeFrom(const FunctionSignature_Scalar& from) { } void FunctionSignature_Scalar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Scalar) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Scalar) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_Scalar::CopyFrom(const FunctionSignature_Scalar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Scalar) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Scalar) if (&from == this) return; Clear(); MergeFrom(from); @@ -1471,38 +1470,38 @@ void FunctionSignature_Scalar::InternalSwap(FunctionSignature_Scalar* other) { ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Scalar::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[2]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[2]); } // =================================================================== class FunctionSignature_Aggregate::_Internal { public: - static const ::io::substrait::FunctionSignature_Description& description(const FunctionSignature_Aggregate* msg); - static const ::io::substrait::DerivationExpression& output_type(const FunctionSignature_Aggregate* msg); - static const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Aggregate* msg); - static const ::io::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Aggregate* msg); - static const ::io::substrait::Type& intermediate_type(const FunctionSignature_Aggregate* msg); + static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Aggregate* msg); + static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Aggregate* msg); + static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Aggregate* msg); + static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Aggregate* msg); + static const ::substrait::Type& intermediate_type(const FunctionSignature_Aggregate* msg); }; -const ::io::substrait::FunctionSignature_Description& +const ::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::_Internal::description(const FunctionSignature_Aggregate* msg) { return *msg->description_; } -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& FunctionSignature_Aggregate::_Internal::output_type(const FunctionSignature_Aggregate* msg) { return *msg->output_type_; } -const ::io::substrait::FunctionSignature_FinalArgVariadic& +const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::_Internal::variadic(const FunctionSignature_Aggregate* msg) { return *msg->final_variable_behavior_.variadic_; } -const ::io::substrait::FunctionSignature_FinalArgNormal& +const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::_Internal::normal(const FunctionSignature_Aggregate* msg) { return *msg->final_variable_behavior_.normal_; } -const ::io::substrait::Type& +const ::substrait::Type& FunctionSignature_Aggregate::_Internal::intermediate_type(const FunctionSignature_Aggregate* msg) { return *msg->intermediate_type_; } @@ -1512,7 +1511,7 @@ void FunctionSignature_Aggregate::clear_output_type() { } output_type_ = nullptr; } -void FunctionSignature_Aggregate::set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { +void FunctionSignature_Aggregate::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_final_variable_behavior(); if (variadic) { @@ -1525,9 +1524,9 @@ void FunctionSignature_Aggregate::set_allocated_variadic(::io::substrait::Functi set_has_variadic(); final_variable_behavior_.variadic_ = variadic; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.variadic) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.variadic) } -void FunctionSignature_Aggregate::set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { +void FunctionSignature_Aggregate::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_final_variable_behavior(); if (normal) { @@ -1540,7 +1539,7 @@ void FunctionSignature_Aggregate::set_allocated_normal(::io::substrait::Function set_has_normal(); final_variable_behavior_.normal_ = normal; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.normal) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.normal) } void FunctionSignature_Aggregate::clear_intermediate_type() { if (GetArena() == nullptr && intermediate_type_ != nullptr) { @@ -1554,7 +1553,7 @@ FunctionSignature_Aggregate::FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID implementations_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Aggregate) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Aggregate) } FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -1567,17 +1566,17 @@ FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature GetArena()); } if (from._internal_has_description()) { - description_ = new ::io::substrait::FunctionSignature_Description(*from.description_); + description_ = new ::substrait::FunctionSignature_Description(*from.description_); } else { description_ = nullptr; } if (from._internal_has_output_type()) { - output_type_ = new ::io::substrait::DerivationExpression(*from.output_type_); + output_type_ = new ::substrait::DerivationExpression(*from.output_type_); } else { output_type_ = nullptr; } if (from._internal_has_intermediate_type()) { - intermediate_type_ = new ::io::substrait::Type(*from.intermediate_type_); + intermediate_type_ = new ::substrait::Type(*from.intermediate_type_); } else { intermediate_type_ = nullptr; } @@ -1587,18 +1586,18 @@ FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature clear_has_final_variable_behavior(); switch (from.final_variable_behavior_case()) { case kVariadic: { - _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); break; } case kNormal: { - _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); break; } case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Aggregate) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Aggregate) } void FunctionSignature_Aggregate::SharedCtor() { @@ -1611,7 +1610,7 @@ clear_has_final_variable_behavior(); } FunctionSignature_Aggregate::~FunctionSignature_Aggregate() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Aggregate) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Aggregate) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1638,7 +1637,7 @@ void FunctionSignature_Aggregate::SetCachedSize(int size) const { } void FunctionSignature_Aggregate::clear_final_variable_behavior() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.FunctionSignature.Aggregate) +// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Aggregate) switch (final_variable_behavior_case()) { case kVariadic: { if (GetArena() == nullptr) { @@ -1661,7 +1660,7 @@ void FunctionSignature_Aggregate::clear_final_variable_behavior() { void FunctionSignature_Aggregate::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Aggregate) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Aggregate) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1694,7 +1693,7 @@ const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -1711,11 +1710,11 @@ const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTO if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Aggregate.name")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Aggregate.name")); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); @@ -1736,21 +1735,21 @@ const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTO CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression output_type = 9; + // .substrait.DerivationExpression output_type = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + // .substrait.FunctionSignature.FinalArgNormal normal = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); @@ -1764,7 +1763,7 @@ const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTO CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type intermediate_type = 13; + // .substrait.Type intermediate_type = 13; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr); @@ -1778,7 +1777,7 @@ const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTO CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + // repeated .substrait.FunctionSignature.Implementation implementations = 15; case 15: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) { ptr -= 1; @@ -1815,11 +1814,11 @@ const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Aggregate) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Aggregate) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; for (unsigned int i = 0, n = static_cast(this->_internal_arguments_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -1832,12 +1831,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.FunctionSignature.Aggregate.name"); + "substrait.FunctionSignature.Aggregate.name"); target = stream->WriteStringMaybeAliased( 3, this->_internal_name(), target); } - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; if (this->has_description()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1857,7 +1856,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); } - // .io.substrait.DerivationExpression output_type = 9; + // .substrait.DerivationExpression output_type = 9; if (this->has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1865,7 +1864,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( 9, _Internal::output_type(this), target, stream); } - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; if (_internal_has_variadic()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1873,7 +1872,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( 10, _Internal::variadic(this), target, stream); } - // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + // .substrait.FunctionSignature.FinalArgNormal normal = 11; if (_internal_has_normal()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1887,7 +1886,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target); } - // .io.substrait.Type intermediate_type = 13; + // .substrait.Type intermediate_type = 13; if (this->has_intermediate_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1901,7 +1900,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(14, this->_internal_ordered(), target); } - // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + // repeated .substrait.FunctionSignature.Implementation implementations = 15; for (unsigned int i = 0, n = static_cast(this->_internal_implementations_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -1913,26 +1912,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Aggregate) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Aggregate) return target; } size_t FunctionSignature_Aggregate::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Aggregate) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Aggregate) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; total_size += 1UL * this->_internal_arguments_size(); for (const auto& msg : this->arguments_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + // repeated .substrait.FunctionSignature.Implementation implementations = 15; total_size += 1UL * this->_internal_implementations_size(); for (const auto& msg : this->implementations_) { total_size += @@ -1946,21 +1945,21 @@ size_t FunctionSignature_Aggregate::ByteSizeLong() const { this->_internal_name()); } - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; if (this->has_description()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *description_); } - // .io.substrait.DerivationExpression output_type = 9; + // .substrait.DerivationExpression output_type = 9; if (this->has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *output_type_); } - // .io.substrait.Type intermediate_type = 13; + // .substrait.Type intermediate_type = 13; if (this->has_intermediate_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1990,14 +1989,14 @@ size_t FunctionSignature_Aggregate::ByteSizeLong() const { } switch (final_variable_behavior_case()) { - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; case kVariadic: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *final_variable_behavior_.variadic_); break; } - // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + // .substrait.FunctionSignature.FinalArgNormal normal = 11; case kNormal: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2018,22 +2017,22 @@ size_t FunctionSignature_Aggregate::ByteSizeLong() const { } void FunctionSignature_Aggregate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Aggregate) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Aggregate) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_Aggregate* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Aggregate) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Aggregate) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Aggregate) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Aggregate) MergeFrom(*source); } } void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Aggregate) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Aggregate) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2045,13 +2044,13 @@ void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& f _internal_set_name(from._internal_name()); } if (from.has_description()) { - _internal_mutable_description()->::io::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); + _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); } if (from.has_output_type()) { - _internal_mutable_output_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); + _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); } if (from.has_intermediate_type()) { - _internal_mutable_intermediate_type()->::io::substrait::Type::MergeFrom(from._internal_intermediate_type()); + _internal_mutable_intermediate_type()->::substrait::Type::MergeFrom(from._internal_intermediate_type()); } if (from.deterministic() != 0) { _internal_set_deterministic(from._internal_deterministic()); @@ -2067,11 +2066,11 @@ void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& f } switch (from.final_variable_behavior_case()) { case kVariadic: { - _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); break; } case kNormal: { - _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); break; } case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { @@ -2081,14 +2080,14 @@ void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& f } void FunctionSignature_Aggregate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Aggregate) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Aggregate) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_Aggregate::CopyFrom(const FunctionSignature_Aggregate& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Aggregate) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Aggregate) if (&from == this) return; Clear(); MergeFrom(from); @@ -2116,38 +2115,38 @@ void FunctionSignature_Aggregate::InternalSwap(FunctionSignature_Aggregate* othe ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Aggregate::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[3]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[3]); } // =================================================================== class FunctionSignature_Window::_Internal { public: - static const ::io::substrait::FunctionSignature_Description& description(const FunctionSignature_Window* msg); - static const ::io::substrait::DerivationExpression& intermediate_type(const FunctionSignature_Window* msg); - static const ::io::substrait::DerivationExpression& output_type(const FunctionSignature_Window* msg); - static const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Window* msg); - static const ::io::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Window* msg); + static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Window* msg); + static const ::substrait::DerivationExpression& intermediate_type(const FunctionSignature_Window* msg); + static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Window* msg); + static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Window* msg); + static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Window* msg); }; -const ::io::substrait::FunctionSignature_Description& +const ::substrait::FunctionSignature_Description& FunctionSignature_Window::_Internal::description(const FunctionSignature_Window* msg) { return *msg->description_; } -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& FunctionSignature_Window::_Internal::intermediate_type(const FunctionSignature_Window* msg) { return *msg->intermediate_type_; } -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& FunctionSignature_Window::_Internal::output_type(const FunctionSignature_Window* msg) { return *msg->output_type_; } -const ::io::substrait::FunctionSignature_FinalArgVariadic& +const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::_Internal::variadic(const FunctionSignature_Window* msg) { return *msg->final_variable_behavior_.variadic_; } -const ::io::substrait::FunctionSignature_FinalArgNormal& +const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::_Internal::normal(const FunctionSignature_Window* msg) { return *msg->final_variable_behavior_.normal_; } @@ -2163,7 +2162,7 @@ void FunctionSignature_Window::clear_output_type() { } output_type_ = nullptr; } -void FunctionSignature_Window::set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { +void FunctionSignature_Window::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_final_variable_behavior(); if (variadic) { @@ -2176,9 +2175,9 @@ void FunctionSignature_Window::set_allocated_variadic(::io::substrait::FunctionS set_has_variadic(); final_variable_behavior_.variadic_ = variadic; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.variadic) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.variadic) } -void FunctionSignature_Window::set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { +void FunctionSignature_Window::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_final_variable_behavior(); if (normal) { @@ -2191,7 +2190,7 @@ void FunctionSignature_Window::set_allocated_normal(::io::substrait::FunctionSig set_has_normal(); final_variable_behavior_.normal_ = normal; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.normal) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.normal) } FunctionSignature_Window::FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), @@ -2200,7 +2199,7 @@ FunctionSignature_Window::FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Aren implementations_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Window) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Window) } FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Window& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -2209,17 +2208,17 @@ FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Windo implementations_(from.implementations_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_description()) { - description_ = new ::io::substrait::FunctionSignature_Description(*from.description_); + description_ = new ::substrait::FunctionSignature_Description(*from.description_); } else { description_ = nullptr; } if (from._internal_has_intermediate_type()) { - intermediate_type_ = new ::io::substrait::DerivationExpression(*from.intermediate_type_); + intermediate_type_ = new ::substrait::DerivationExpression(*from.intermediate_type_); } else { intermediate_type_ = nullptr; } if (from._internal_has_output_type()) { - output_type_ = new ::io::substrait::DerivationExpression(*from.output_type_); + output_type_ = new ::substrait::DerivationExpression(*from.output_type_); } else { output_type_ = nullptr; } @@ -2229,18 +2228,18 @@ FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Windo clear_has_final_variable_behavior(); switch (from.final_variable_behavior_case()) { case kVariadic: { - _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); break; } case kNormal: { - _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); break; } case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Window) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Window) } void FunctionSignature_Window::SharedCtor() { @@ -2252,7 +2251,7 @@ clear_has_final_variable_behavior(); } FunctionSignature_Window::~FunctionSignature_Window() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Window) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Window) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2278,7 +2277,7 @@ void FunctionSignature_Window::SetCachedSize(int size) const { } void FunctionSignature_Window::clear_final_variable_behavior() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.FunctionSignature.Window) +// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Window) switch (final_variable_behavior_case()) { case kVariadic: { if (GetArena() == nullptr) { @@ -2301,7 +2300,7 @@ void FunctionSignature_Window::clear_final_variable_behavior() { void FunctionSignature_Window::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Window) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Window) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2334,7 +2333,7 @@ const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -2354,13 +2353,13 @@ const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF ptr += 1; auto str = _internal_add_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Window.name")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Window.name")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); @@ -2381,14 +2380,14 @@ const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression intermediate_type = 9; + // .substrait.DerivationExpression intermediate_type = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression output_type = 10; + // .substrait.DerivationExpression output_type = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); @@ -2409,15 +2408,15 @@ const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.Window.WindowType window_type = 14; + // .substrait.FunctionSignature.Window.WindowType window_type = 14; case 14: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_window_type(static_cast<::io::substrait::FunctionSignature_Window_WindowType>(val)); + _internal_set_window_type(static_cast<::substrait::FunctionSignature_Window_WindowType>(val)); } else goto handle_unusual; continue; - // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + // repeated .substrait.FunctionSignature.Implementation implementations = 15; case 15: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) { ptr -= 1; @@ -2429,14 +2428,14 @@ const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 16; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 16; case 16: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.FinalArgNormal normal = 17; + // .substrait.FunctionSignature.FinalArgNormal normal = 17; case 17: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); @@ -2468,11 +2467,11 @@ const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Window) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Window) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; for (unsigned int i = 0, n = static_cast(this->_internal_arguments_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -2486,11 +2485,11 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.FunctionSignature.Window.name"); + "substrait.FunctionSignature.Window.name"); target = stream->WriteString(3, s, target); } - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; if (this->has_description()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2510,7 +2509,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); } - // .io.substrait.DerivationExpression intermediate_type = 9; + // .substrait.DerivationExpression intermediate_type = 9; if (this->has_intermediate_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2518,7 +2517,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( 9, _Internal::intermediate_type(this), target, stream); } - // .io.substrait.DerivationExpression output_type = 10; + // .substrait.DerivationExpression output_type = 10; if (this->has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2538,14 +2537,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target); } - // .io.substrait.FunctionSignature.Window.WindowType window_type = 14; + // .substrait.FunctionSignature.Window.WindowType window_type = 14; if (this->window_type() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 14, this->_internal_window_type(), target); } - // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + // repeated .substrait.FunctionSignature.Implementation implementations = 15; for (unsigned int i = 0, n = static_cast(this->_internal_implementations_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -2553,7 +2552,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( InternalWriteMessage(15, this->_internal_implementations(i), target, stream); } - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 16; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 16; if (_internal_has_variadic()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2561,7 +2560,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( 16, _Internal::variadic(this), target, stream); } - // .io.substrait.FunctionSignature.FinalArgNormal normal = 17; + // .substrait.FunctionSignature.FinalArgNormal normal = 17; if (_internal_has_normal()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2573,19 +2572,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Window) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Window) return target; } size_t FunctionSignature_Window::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Window) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Window) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; total_size += 1UL * this->_internal_arguments_size(); for (const auto& msg : this->arguments_) { total_size += @@ -2600,28 +2599,28 @@ size_t FunctionSignature_Window::ByteSizeLong() const { name_.Get(i)); } - // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + // repeated .substrait.FunctionSignature.Implementation implementations = 15; total_size += 1UL * this->_internal_implementations_size(); for (const auto& msg : this->implementations_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; if (this->has_description()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *description_); } - // .io.substrait.DerivationExpression intermediate_type = 9; + // .substrait.DerivationExpression intermediate_type = 9; if (this->has_intermediate_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *intermediate_type_); } - // .io.substrait.DerivationExpression output_type = 10; + // .substrait.DerivationExpression output_type = 10; if (this->has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2643,7 +2642,7 @@ size_t FunctionSignature_Window::ByteSizeLong() const { total_size += 1 + 1; } - // .io.substrait.FunctionSignature.Window.WindowType window_type = 14; + // .substrait.FunctionSignature.Window.WindowType window_type = 14; if (this->window_type() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_window_type()); @@ -2657,14 +2656,14 @@ size_t FunctionSignature_Window::ByteSizeLong() const { } switch (final_variable_behavior_case()) { - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 16; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 16; case kVariadic: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *final_variable_behavior_.variadic_); break; } - // .io.substrait.FunctionSignature.FinalArgNormal normal = 17; + // .substrait.FunctionSignature.FinalArgNormal normal = 17; case kNormal: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2685,22 +2684,22 @@ size_t FunctionSignature_Window::ByteSizeLong() const { } void FunctionSignature_Window::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Window) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Window) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_Window* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Window) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Window) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Window) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Window) MergeFrom(*source); } } void FunctionSignature_Window::MergeFrom(const FunctionSignature_Window& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Window) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Window) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2710,13 +2709,13 @@ void FunctionSignature_Window::MergeFrom(const FunctionSignature_Window& from) { name_.MergeFrom(from.name_); implementations_.MergeFrom(from.implementations_); if (from.has_description()) { - _internal_mutable_description()->::io::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); + _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); } if (from.has_intermediate_type()) { - _internal_mutable_intermediate_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_intermediate_type()); + _internal_mutable_intermediate_type()->::substrait::DerivationExpression::MergeFrom(from._internal_intermediate_type()); } if (from.has_output_type()) { - _internal_mutable_output_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); + _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); } if (from.deterministic() != 0) { _internal_set_deterministic(from._internal_deterministic()); @@ -2735,11 +2734,11 @@ void FunctionSignature_Window::MergeFrom(const FunctionSignature_Window& from) { } switch (from.final_variable_behavior_case()) { case kVariadic: { - _internal_mutable_variadic()->::io::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); + _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); break; } case kNormal: { - _internal_mutable_normal()->::io::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); + _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); break; } case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { @@ -2749,14 +2748,14 @@ void FunctionSignature_Window::MergeFrom(const FunctionSignature_Window& from) { } void FunctionSignature_Window::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Window) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Window) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_Window::CopyFrom(const FunctionSignature_Window& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Window) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Window) if (&from == this) return; Clear(); MergeFrom(from); @@ -2784,8 +2783,8 @@ void FunctionSignature_Window::InternalSwap(FunctionSignature_Window* other) { ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Window::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[4]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[4]); } // =================================================================== @@ -2798,7 +2797,7 @@ FunctionSignature_Description::FunctionSignature_Description(::PROTOBUF_NAMESPAC : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Description) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Description) } FunctionSignature_Description::FunctionSignature_Description(const FunctionSignature_Description& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -2813,7 +2812,7 @@ FunctionSignature_Description::FunctionSignature_Description(const FunctionSigna body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_body(), GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Description) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Description) } void FunctionSignature_Description::SharedCtor() { @@ -2822,7 +2821,7 @@ body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlready } FunctionSignature_Description::~FunctionSignature_Description() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Description) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Description) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2844,7 +2843,7 @@ void FunctionSignature_Description::SetCachedSize(int size) const { } void FunctionSignature_Description::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Description) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Description) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2865,7 +2864,7 @@ const char* FunctionSignature_Description::_InternalParse(const char* ptr, ::PRO if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_language(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Description.language")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Description.language")); CHK_(ptr); } else goto handle_unusual; continue; @@ -2874,7 +2873,7 @@ const char* FunctionSignature_Description::_InternalParse(const char* ptr, ::PRO if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_body(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Description.body")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Description.body")); CHK_(ptr); } else goto handle_unusual; continue; @@ -2903,7 +2902,7 @@ const char* FunctionSignature_Description::_InternalParse(const char* ptr, ::PRO ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Description::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Description) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Description) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2912,7 +2911,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Description::_InternalSerializ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_language().data(), static_cast(this->_internal_language().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.FunctionSignature.Description.language"); + "substrait.FunctionSignature.Description.language"); target = stream->WriteStringMaybeAliased( 1, this->_internal_language(), target); } @@ -2922,7 +2921,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Description::_InternalSerializ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_body().data(), static_cast(this->_internal_body().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.FunctionSignature.Description.body"); + "substrait.FunctionSignature.Description.body"); target = stream->WriteStringMaybeAliased( 2, this->_internal_body(), target); } @@ -2931,12 +2930,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Description::_InternalSerializ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Description) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Description) return target; } size_t FunctionSignature_Description::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Description) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Description) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2967,22 +2966,22 @@ size_t FunctionSignature_Description::ByteSizeLong() const { } void FunctionSignature_Description::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Description) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Description) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_Description* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Description) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Description) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Description) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Description) MergeFrom(*source); } } void FunctionSignature_Description::MergeFrom(const FunctionSignature_Description& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Description) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Description) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2997,14 +2996,14 @@ void FunctionSignature_Description::MergeFrom(const FunctionSignature_Descriptio } void FunctionSignature_Description::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Description) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Description) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_Description::CopyFrom(const FunctionSignature_Description& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Description) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Description) if (&from == this) return; Clear(); MergeFrom(from); @@ -3023,8 +3022,8 @@ void FunctionSignature_Description::InternalSwap(FunctionSignature_Description* ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Description::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[5]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[5]); } // =================================================================== @@ -3037,7 +3036,7 @@ FunctionSignature_Implementation::FunctionSignature_Implementation(::PROTOBUF_NA : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Implementation) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Implementation) } FunctionSignature_Implementation::FunctionSignature_Implementation(const FunctionSignature_Implementation& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -3048,7 +3047,7 @@ FunctionSignature_Implementation::FunctionSignature_Implementation(const Functio GetArena()); } type_ = from.type_; - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Implementation) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Implementation) } void FunctionSignature_Implementation::SharedCtor() { @@ -3057,7 +3056,7 @@ type_ = 0; } FunctionSignature_Implementation::~FunctionSignature_Implementation() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Implementation) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Implementation) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3078,7 +3077,7 @@ void FunctionSignature_Implementation::SetCachedSize(int size) const { } void FunctionSignature_Implementation::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Implementation) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Implementation) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3094,12 +3093,12 @@ const char* FunctionSignature_Implementation::_InternalParse(const char* ptr, :: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.FunctionSignature.Implementation.Type type = 1; + // .substrait.FunctionSignature.Implementation.Type type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_type(static_cast<::io::substrait::FunctionSignature_Implementation_Type>(val)); + _internal_set_type(static_cast<::substrait::FunctionSignature_Implementation_Type>(val)); } else goto handle_unusual; continue; // string uri = 2; @@ -3107,7 +3106,7 @@ const char* FunctionSignature_Implementation::_InternalParse(const char* ptr, :: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_uri(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Implementation.uri")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Implementation.uri")); CHK_(ptr); } else goto handle_unusual; continue; @@ -3136,11 +3135,11 @@ const char* FunctionSignature_Implementation::_InternalParse(const char* ptr, :: ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Implementation::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Implementation) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Implementation) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.FunctionSignature.Implementation.Type type = 1; + // .substrait.FunctionSignature.Implementation.Type type = 1; if (this->type() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -3152,7 +3151,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Implementation::_InternalSeria ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_uri().data(), static_cast(this->_internal_uri().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.FunctionSignature.Implementation.uri"); + "substrait.FunctionSignature.Implementation.uri"); target = stream->WriteStringMaybeAliased( 2, this->_internal_uri(), target); } @@ -3161,12 +3160,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Implementation::_InternalSeria target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Implementation) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Implementation) return target; } size_t FunctionSignature_Implementation::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Implementation) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Implementation) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3180,7 +3179,7 @@ size_t FunctionSignature_Implementation::ByteSizeLong() const { this->_internal_uri()); } - // .io.substrait.FunctionSignature.Implementation.Type type = 1; + // .substrait.FunctionSignature.Implementation.Type type = 1; if (this->type() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); @@ -3196,22 +3195,22 @@ size_t FunctionSignature_Implementation::ByteSizeLong() const { } void FunctionSignature_Implementation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Implementation) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Implementation) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_Implementation* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Implementation) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Implementation) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Implementation) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Implementation) MergeFrom(*source); } } void FunctionSignature_Implementation::MergeFrom(const FunctionSignature_Implementation& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Implementation) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Implementation) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3226,14 +3225,14 @@ void FunctionSignature_Implementation::MergeFrom(const FunctionSignature_Impleme } void FunctionSignature_Implementation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Implementation) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Implementation) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_Implementation::CopyFrom(const FunctionSignature_Implementation& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Implementation) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Implementation) if (&from == this) return; Clear(); MergeFrom(from); @@ -3252,18 +3251,18 @@ void FunctionSignature_Implementation::InternalSwap(FunctionSignature_Implementa ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Implementation::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[6]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[6]); } // =================================================================== class FunctionSignature_Argument_ValueArgument::_Internal { public: - static const ::io::substrait::ParameterizedType& type(const FunctionSignature_Argument_ValueArgument* msg); + static const ::substrait::ParameterizedType& type(const FunctionSignature_Argument_ValueArgument* msg); }; -const ::io::substrait::ParameterizedType& +const ::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::_Internal::type(const FunctionSignature_Argument_ValueArgument* msg) { return *msg->type_; } @@ -3277,18 +3276,18 @@ FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgume : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Argument.ValueArgument) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.ValueArgument) } FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(const FunctionSignature_Argument_ValueArgument& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_type()) { - type_ = new ::io::substrait::ParameterizedType(*from.type_); + type_ = new ::substrait::ParameterizedType(*from.type_); } else { type_ = nullptr; } constant_ = from.constant_; - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Argument.ValueArgument) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.ValueArgument) } void FunctionSignature_Argument_ValueArgument::SharedCtor() { @@ -3299,7 +3298,7 @@ ::memset(reinterpret_cast(this) + static_cast( } FunctionSignature_Argument_ValueArgument::~FunctionSignature_Argument_ValueArgument() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Argument.ValueArgument) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.ValueArgument) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3320,7 +3319,7 @@ void FunctionSignature_Argument_ValueArgument::SetCachedSize(int size) const { } void FunctionSignature_Argument_ValueArgument::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Argument.ValueArgument) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.ValueArgument) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3339,7 +3338,7 @@ const char* FunctionSignature_Argument_ValueArgument::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); @@ -3378,11 +3377,11 @@ const char* FunctionSignature_Argument_ValueArgument::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_ValueArgument::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Argument.ValueArgument) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.ValueArgument) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; if (this->has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3400,19 +3399,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_ValueArgument::_Inter target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Argument.ValueArgument) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument.ValueArgument) return target; } size_t FunctionSignature_Argument_ValueArgument::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Argument.ValueArgument) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.ValueArgument) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; if (this->has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -3434,29 +3433,29 @@ size_t FunctionSignature_Argument_ValueArgument::ByteSizeLong() const { } void FunctionSignature_Argument_ValueArgument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Argument.ValueArgument) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Argument.ValueArgument) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_Argument_ValueArgument* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Argument.ValueArgument) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Argument.ValueArgument) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Argument.ValueArgument) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Argument.ValueArgument) MergeFrom(*source); } } void FunctionSignature_Argument_ValueArgument::MergeFrom(const FunctionSignature_Argument_ValueArgument& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Argument.ValueArgument) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.ValueArgument) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_type()) { - _internal_mutable_type()->::io::substrait::ParameterizedType::MergeFrom(from._internal_type()); + _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type()); } if (from.constant() != 0) { _internal_set_constant(from._internal_constant()); @@ -3464,14 +3463,14 @@ void FunctionSignature_Argument_ValueArgument::MergeFrom(const FunctionSignature } void FunctionSignature_Argument_ValueArgument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Argument.ValueArgument) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Argument.ValueArgument) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_Argument_ValueArgument::CopyFrom(const FunctionSignature_Argument_ValueArgument& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Argument.ValueArgument) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument.ValueArgument) if (&from == this) return; Clear(); MergeFrom(from); @@ -3494,18 +3493,18 @@ void FunctionSignature_Argument_ValueArgument::InternalSwap(FunctionSignature_Ar ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_ValueArgument::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[7]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[7]); } // =================================================================== class FunctionSignature_Argument_TypeArgument::_Internal { public: - static const ::io::substrait::ParameterizedType& type(const FunctionSignature_Argument_TypeArgument* msg); + static const ::substrait::ParameterizedType& type(const FunctionSignature_Argument_TypeArgument* msg); }; -const ::io::substrait::ParameterizedType& +const ::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::_Internal::type(const FunctionSignature_Argument_TypeArgument* msg) { return *msg->type_; } @@ -3519,17 +3518,17 @@ FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Argument.TypeArgument) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.TypeArgument) } FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(const FunctionSignature_Argument_TypeArgument& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_type()) { - type_ = new ::io::substrait::ParameterizedType(*from.type_); + type_ = new ::substrait::ParameterizedType(*from.type_); } else { type_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Argument.TypeArgument) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.TypeArgument) } void FunctionSignature_Argument_TypeArgument::SharedCtor() { @@ -3537,7 +3536,7 @@ type_ = nullptr; } FunctionSignature_Argument_TypeArgument::~FunctionSignature_Argument_TypeArgument() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Argument.TypeArgument) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.TypeArgument) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3558,7 +3557,7 @@ void FunctionSignature_Argument_TypeArgument::SetCachedSize(int size) const { } void FunctionSignature_Argument_TypeArgument::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Argument.TypeArgument) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.TypeArgument) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3576,7 +3575,7 @@ const char* FunctionSignature_Argument_TypeArgument::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); @@ -3608,11 +3607,11 @@ const char* FunctionSignature_Argument_TypeArgument::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_TypeArgument::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Argument.TypeArgument) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.TypeArgument) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; if (this->has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3624,19 +3623,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_TypeArgument::_Intern target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Argument.TypeArgument) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument.TypeArgument) return target; } size_t FunctionSignature_Argument_TypeArgument::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Argument.TypeArgument) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.TypeArgument) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; if (this->has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -3653,41 +3652,41 @@ size_t FunctionSignature_Argument_TypeArgument::ByteSizeLong() const { } void FunctionSignature_Argument_TypeArgument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Argument.TypeArgument) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Argument.TypeArgument) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_Argument_TypeArgument* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Argument.TypeArgument) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Argument.TypeArgument) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Argument.TypeArgument) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Argument.TypeArgument) MergeFrom(*source); } } void FunctionSignature_Argument_TypeArgument::MergeFrom(const FunctionSignature_Argument_TypeArgument& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Argument.TypeArgument) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.TypeArgument) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_type()) { - _internal_mutable_type()->::io::substrait::ParameterizedType::MergeFrom(from._internal_type()); + _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type()); } } void FunctionSignature_Argument_TypeArgument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Argument.TypeArgument) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Argument.TypeArgument) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_Argument_TypeArgument::CopyFrom(const FunctionSignature_Argument_TypeArgument& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Argument.TypeArgument) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument.TypeArgument) if (&from == this) return; Clear(); MergeFrom(from); @@ -3705,8 +3704,8 @@ void FunctionSignature_Argument_TypeArgument::InternalSwap(FunctionSignature_Arg ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_TypeArgument::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[8]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[8]); } // =================================================================== @@ -3720,14 +3719,14 @@ FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument options_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Argument.EnumArgument) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.EnumArgument) } FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(const FunctionSignature_Argument_EnumArgument& from) : ::PROTOBUF_NAMESPACE_ID::Message(), options_(from.options_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); optional_ = from.optional_; - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Argument.EnumArgument) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.EnumArgument) } void FunctionSignature_Argument_EnumArgument::SharedCtor() { @@ -3735,7 +3734,7 @@ optional_ = false; } FunctionSignature_Argument_EnumArgument::~FunctionSignature_Argument_EnumArgument() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Argument.EnumArgument) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.EnumArgument) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3755,7 +3754,7 @@ void FunctionSignature_Argument_EnumArgument::SetCachedSize(int size) const { } void FunctionSignature_Argument_EnumArgument::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Argument.EnumArgument) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.EnumArgument) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3779,7 +3778,7 @@ const char* FunctionSignature_Argument_EnumArgument::_InternalParse(const char* ptr += 1; auto str = _internal_add_options(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Argument.EnumArgument.options")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Argument.EnumArgument.options")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); @@ -3817,7 +3816,7 @@ const char* FunctionSignature_Argument_EnumArgument::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_EnumArgument::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Argument.EnumArgument) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.EnumArgument) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3827,7 +3826,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_EnumArgument::_Intern ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.FunctionSignature.Argument.EnumArgument.options"); + "substrait.FunctionSignature.Argument.EnumArgument.options"); target = stream->WriteString(1, s, target); } @@ -3841,12 +3840,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_EnumArgument::_Intern target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Argument.EnumArgument) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument.EnumArgument) return target; } size_t FunctionSignature_Argument_EnumArgument::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Argument.EnumArgument) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.EnumArgument) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3876,22 +3875,22 @@ size_t FunctionSignature_Argument_EnumArgument::ByteSizeLong() const { } void FunctionSignature_Argument_EnumArgument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Argument.EnumArgument) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Argument.EnumArgument) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_Argument_EnumArgument* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Argument.EnumArgument) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Argument.EnumArgument) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Argument.EnumArgument) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Argument.EnumArgument) MergeFrom(*source); } } void FunctionSignature_Argument_EnumArgument::MergeFrom(const FunctionSignature_Argument_EnumArgument& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Argument.EnumArgument) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.EnumArgument) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3904,14 +3903,14 @@ void FunctionSignature_Argument_EnumArgument::MergeFrom(const FunctionSignature_ } void FunctionSignature_Argument_EnumArgument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Argument.EnumArgument) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Argument.EnumArgument) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_Argument_EnumArgument::CopyFrom(const FunctionSignature_Argument_EnumArgument& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Argument.EnumArgument) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument.EnumArgument) if (&from == this) return; Clear(); MergeFrom(from); @@ -3930,32 +3929,32 @@ void FunctionSignature_Argument_EnumArgument::InternalSwap(FunctionSignature_Arg ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_EnumArgument::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[9]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[9]); } // =================================================================== class FunctionSignature_Argument::_Internal { public: - static const ::io::substrait::FunctionSignature_Argument_ValueArgument& value(const FunctionSignature_Argument* msg); - static const ::io::substrait::FunctionSignature_Argument_TypeArgument& type(const FunctionSignature_Argument* msg); - static const ::io::substrait::FunctionSignature_Argument_EnumArgument& enum_(const FunctionSignature_Argument* msg); + static const ::substrait::FunctionSignature_Argument_ValueArgument& value(const FunctionSignature_Argument* msg); + static const ::substrait::FunctionSignature_Argument_TypeArgument& type(const FunctionSignature_Argument* msg); + static const ::substrait::FunctionSignature_Argument_EnumArgument& enum_(const FunctionSignature_Argument* msg); }; -const ::io::substrait::FunctionSignature_Argument_ValueArgument& +const ::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::_Internal::value(const FunctionSignature_Argument* msg) { return *msg->argument_kind_.value_; } -const ::io::substrait::FunctionSignature_Argument_TypeArgument& +const ::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::_Internal::type(const FunctionSignature_Argument* msg) { return *msg->argument_kind_.type_; } -const ::io::substrait::FunctionSignature_Argument_EnumArgument& +const ::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::_Internal::enum_(const FunctionSignature_Argument* msg) { return *msg->argument_kind_.enum__; } -void FunctionSignature_Argument::set_allocated_value(::io::substrait::FunctionSignature_Argument_ValueArgument* value) { +void FunctionSignature_Argument::set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_argument_kind(); if (value) { @@ -3968,9 +3967,9 @@ void FunctionSignature_Argument::set_allocated_value(::io::substrait::FunctionSi set_has_value(); argument_kind_.value_ = value; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.value) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.value) } -void FunctionSignature_Argument::set_allocated_type(::io::substrait::FunctionSignature_Argument_TypeArgument* type) { +void FunctionSignature_Argument::set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_argument_kind(); if (type) { @@ -3983,9 +3982,9 @@ void FunctionSignature_Argument::set_allocated_type(::io::substrait::FunctionSig set_has_type(); argument_kind_.type_ = type; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.type) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.type) } -void FunctionSignature_Argument::set_allocated_enum_(::io::substrait::FunctionSignature_Argument_EnumArgument* enum_) { +void FunctionSignature_Argument::set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_argument_kind(); if (enum_) { @@ -3998,13 +3997,13 @@ void FunctionSignature_Argument::set_allocated_enum_(::io::substrait::FunctionSi set_has_enum_(); argument_kind_.enum__ = enum_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.enum) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.enum) } FunctionSignature_Argument::FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature.Argument) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument) } FunctionSignature_Argument::FunctionSignature_Argument(const FunctionSignature_Argument& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -4017,22 +4016,22 @@ FunctionSignature_Argument::FunctionSignature_Argument(const FunctionSignature_A clear_has_argument_kind(); switch (from.argument_kind_case()) { case kValue: { - _internal_mutable_value()->::io::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value()); + _internal_mutable_value()->::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value()); break; } case kType: { - _internal_mutable_type()->::io::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type()); + _internal_mutable_type()->::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type()); break; } case kEnum: { - _internal_mutable_enum_()->::io::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_()); + _internal_mutable_enum_()->::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_()); break; } case ARGUMENT_KIND_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature.Argument) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument) } void FunctionSignature_Argument::SharedCtor() { @@ -4041,7 +4040,7 @@ clear_has_argument_kind(); } FunctionSignature_Argument::~FunctionSignature_Argument() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature.Argument) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4065,7 +4064,7 @@ void FunctionSignature_Argument::SetCachedSize(int size) const { } void FunctionSignature_Argument::clear_argument_kind() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.FunctionSignature.Argument) +// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Argument) switch (argument_kind_case()) { case kValue: { if (GetArena() == nullptr) { @@ -4094,7 +4093,7 @@ void FunctionSignature_Argument::clear_argument_kind() { void FunctionSignature_Argument::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature.Argument) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4115,25 +4114,25 @@ const char* FunctionSignature_Argument::_InternalParse(const char* ptr, ::PROTOB if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.FunctionSignature.Argument.name")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Argument.name")); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.Argument.ValueArgument value = 2; + // .substrait.FunctionSignature.Argument.ValueArgument value = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.Argument.TypeArgument type = 3; + // .substrait.FunctionSignature.Argument.TypeArgument type = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FunctionSignature.Argument.EnumArgument enum = 4; + // .substrait.FunctionSignature.Argument.EnumArgument enum = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr); @@ -4165,7 +4164,7 @@ const char* FunctionSignature_Argument::_InternalParse(const char* ptr, ::PROTOB ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature.Argument) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -4174,12 +4173,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.FunctionSignature.Argument.name"); + "substrait.FunctionSignature.Argument.name"); target = stream->WriteStringMaybeAliased( 1, this->_internal_name(), target); } - // .io.substrait.FunctionSignature.Argument.ValueArgument value = 2; + // .substrait.FunctionSignature.Argument.ValueArgument value = 2; if (_internal_has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4187,7 +4186,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument::_InternalSerialize( 2, _Internal::value(this), target, stream); } - // .io.substrait.FunctionSignature.Argument.TypeArgument type = 3; + // .substrait.FunctionSignature.Argument.TypeArgument type = 3; if (_internal_has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4195,7 +4194,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument::_InternalSerialize( 3, _Internal::type(this), target, stream); } - // .io.substrait.FunctionSignature.Argument.EnumArgument enum = 4; + // .substrait.FunctionSignature.Argument.EnumArgument enum = 4; if (_internal_has_enum_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4207,12 +4206,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature.Argument) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument) return target; } size_t FunctionSignature_Argument::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature.Argument) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4227,21 +4226,21 @@ size_t FunctionSignature_Argument::ByteSizeLong() const { } switch (argument_kind_case()) { - // .io.substrait.FunctionSignature.Argument.ValueArgument value = 2; + // .substrait.FunctionSignature.Argument.ValueArgument value = 2; case kValue: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *argument_kind_.value_); break; } - // .io.substrait.FunctionSignature.Argument.TypeArgument type = 3; + // .substrait.FunctionSignature.Argument.TypeArgument type = 3; case kType: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *argument_kind_.type_); break; } - // .io.substrait.FunctionSignature.Argument.EnumArgument enum = 4; + // .substrait.FunctionSignature.Argument.EnumArgument enum = 4; case kEnum: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -4262,22 +4261,22 @@ size_t FunctionSignature_Argument::ByteSizeLong() const { } void FunctionSignature_Argument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature.Argument) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Argument) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature_Argument* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature.Argument) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Argument) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature.Argument) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Argument) MergeFrom(*source); } } void FunctionSignature_Argument::MergeFrom(const FunctionSignature_Argument& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature.Argument) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4288,15 +4287,15 @@ void FunctionSignature_Argument::MergeFrom(const FunctionSignature_Argument& fro } switch (from.argument_kind_case()) { case kValue: { - _internal_mutable_value()->::io::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value()); + _internal_mutable_value()->::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value()); break; } case kType: { - _internal_mutable_type()->::io::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type()); + _internal_mutable_type()->::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type()); break; } case kEnum: { - _internal_mutable_enum_()->::io::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_()); + _internal_mutable_enum_()->::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_()); break; } case ARGUMENT_KIND_NOT_SET: { @@ -4306,14 +4305,14 @@ void FunctionSignature_Argument::MergeFrom(const FunctionSignature_Argument& fro } void FunctionSignature_Argument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature.Argument) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Argument) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature_Argument::CopyFrom(const FunctionSignature_Argument& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature.Argument) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument) if (&from == this) return; Clear(); MergeFrom(from); @@ -4333,8 +4332,8 @@ void FunctionSignature_Argument::InternalSwap(FunctionSignature_Argument* other) ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[10]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[10]); } // =================================================================== @@ -4347,19 +4346,19 @@ FunctionSignature::FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FunctionSignature) + // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature) } FunctionSignature::FunctionSignature(const FunctionSignature& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.FunctionSignature) + // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature) } void FunctionSignature::SharedCtor() { } FunctionSignature::~FunctionSignature() { - // @@protoc_insertion_point(destructor:io.substrait.FunctionSignature) + // @@protoc_insertion_point(destructor:substrait.FunctionSignature) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4379,7 +4378,7 @@ void FunctionSignature::SetCachedSize(int size) const { } void FunctionSignature::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FunctionSignature) +// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4413,7 +4412,7 @@ const char* FunctionSignature::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FunctionSignature) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -4421,12 +4420,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FunctionSignature) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature) return target; } size_t FunctionSignature::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FunctionSignature) +// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4443,22 +4442,22 @@ size_t FunctionSignature::ByteSizeLong() const { } void FunctionSignature::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FunctionSignature) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature) GOOGLE_DCHECK_NE(&from, this); const FunctionSignature* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FunctionSignature) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FunctionSignature) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature) MergeFrom(*source); } } void FunctionSignature::MergeFrom(const FunctionSignature& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FunctionSignature) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4467,14 +4466,14 @@ void FunctionSignature::MergeFrom(const FunctionSignature& from) { } void FunctionSignature::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FunctionSignature) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature) if (&from == this) return; Clear(); MergeFrom(from); } void FunctionSignature::CopyFrom(const FunctionSignature& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FunctionSignature) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature) if (&from == this) return; Clear(); MergeFrom(from); @@ -4491,49 +4490,48 @@ void FunctionSignature::InternalSwap(FunctionSignature* other) { ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_function_2eproto_getter, &descriptor_table_function_2eproto_once, - file_level_metadata_function_2eproto[11]); + &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, + file_level_metadata_substrait_2ffunction_2eproto[11]); } // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgVariadic >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_FinalArgVariadic >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_FinalArgVariadic >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgNormal >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_FinalArgNormal >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_FinalArgNormal >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Scalar >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Scalar >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Scalar >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Scalar >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Aggregate >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Aggregate >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Aggregate >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Aggregate >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Window >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Window >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Window >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Window >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Description >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Description >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Description >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Description >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Implementation >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Implementation >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Implementation >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Implementation >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_ValueArgument >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Argument_ValueArgument >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_ValueArgument >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_ValueArgument >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_TypeArgument >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Argument_TypeArgument >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_TypeArgument >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_TypeArgument >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_EnumArgument >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Argument_EnumArgument >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_EnumArgument >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_EnumArgument >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature_Argument >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FunctionSignature* Arena::CreateMaybeMessage< ::io::substrait::FunctionSignature >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FunctionSignature >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature* Arena::CreateMaybeMessage< ::substrait::FunctionSignature >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FunctionSignature >(arena); } PROTOBUF_NAMESPACE_CLOSE diff --git a/cpp/src/generated/substrait/function.pb.h b/cpp/src/generated/substrait/function.pb.h index 319f5e995f6..d9e2e5669d7 100644 --- a/cpp/src/generated/substrait/function.pb.h +++ b/cpp/src/generated/substrait/function.pb.h @@ -1,8 +1,8 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: function.proto +// source: substrait/function.proto -#ifndef GOOGLE_PROTOBUF_INCLUDED_function_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_function_2eproto +#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto #include #include @@ -32,12 +32,12 @@ #include // IWYU pragma: export #include #include -#include "type.pb.h" -#include "parameterized_types.pb.h" -#include "type_expressions.pb.h" +#include "substrait/type.pb.h" +#include "substrait/parameterized_types.pb.h" +#include "substrait/type_expressions.pb.h" // @@protoc_insertion_point(includes) #include -#define PROTOBUF_INTERNAL_EXPORT_function_2eproto +#define PROTOBUF_INTERNAL_EXPORT_substrait_2ffunction_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; @@ -45,7 +45,7 @@ class AnyMetadata; PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. -struct TableStruct_function_2eproto { +struct TableStruct_substrait_2ffunction_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] @@ -56,8 +56,7 @@ struct TableStruct_function_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; }; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_function_2eproto; -namespace io { +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ffunction_2eproto; namespace substrait { class FunctionSignature; struct FunctionSignatureDefaultTypeInternal; @@ -96,34 +95,32 @@ class FunctionSignature_Window; struct FunctionSignature_WindowDefaultTypeInternal; extern FunctionSignature_WindowDefaultTypeInternal _FunctionSignature_Window_default_instance_; } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::FunctionSignature* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature>(Arena*); -template<> ::io::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Aggregate>(Arena*); -template<> ::io::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Argument>(Arena*); -template<> ::io::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Argument_EnumArgument>(Arena*); -template<> ::io::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Argument_TypeArgument>(Arena*); -template<> ::io::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Argument_ValueArgument>(Arena*); -template<> ::io::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Description>(Arena*); -template<> ::io::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_FinalArgNormal>(Arena*); -template<> ::io::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_FinalArgVariadic>(Arena*); -template<> ::io::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Implementation>(Arena*); -template<> ::io::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Scalar>(Arena*); -template<> ::io::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage<::io::substrait::FunctionSignature_Window>(Arena*); +template<> ::substrait::FunctionSignature* Arena::CreateMaybeMessage<::substrait::FunctionSignature>(Arena*); +template<> ::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Aggregate>(Arena*); +template<> ::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument>(Arena*); +template<> ::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_EnumArgument>(Arena*); +template<> ::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_TypeArgument>(Arena*); +template<> ::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_ValueArgument>(Arena*); +template<> ::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Description>(Arena*); +template<> ::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage<::substrait::FunctionSignature_FinalArgNormal>(Arena*); +template<> ::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage<::substrait::FunctionSignature_FinalArgVariadic>(Arena*); +template<> ::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Implementation>(Arena*); +template<> ::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Scalar>(Arena*); +template<> ::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Window>(Arena*); PROTOBUF_NAMESPACE_CLOSE -namespace io { namespace substrait { enum FunctionSignature_FinalArgVariadic_ParameterConsistency : int { - FunctionSignature_FinalArgVariadic_ParameterConsistency_UNKNOWN = 0, - FunctionSignature_FinalArgVariadic_ParameterConsistency_CONSISTENT = 1, - FunctionSignature_FinalArgVariadic_ParameterConsistency_INCONSISTENT = 2, + FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED = 0, + FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_CONSISTENT = 1, + FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT = 2, FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value); -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN = FunctionSignature_FinalArgVariadic_ParameterConsistency_UNKNOWN; -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX = FunctionSignature_FinalArgVariadic_ParameterConsistency_INCONSISTENT; +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN = FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED; +constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX = FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT; constexpr int FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_ARRAYSIZE = FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(); @@ -141,15 +138,15 @@ inline bool FunctionSignature_FinalArgVariadic_ParameterConsistency_Parse( FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(), name, value); } enum FunctionSignature_Window_WindowType : int { - FunctionSignature_Window_WindowType_UNKNOWN = 0, - FunctionSignature_Window_WindowType_STREAMING = 1, - FunctionSignature_Window_WindowType_PARTITION = 2, + FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED = 0, + FunctionSignature_Window_WindowType_WINDOW_TYPE_STREAMING = 1, + FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION = 2, FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool FunctionSignature_Window_WindowType_IsValid(int value); -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MIN = FunctionSignature_Window_WindowType_UNKNOWN; -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MAX = FunctionSignature_Window_WindowType_PARTITION; +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MIN = FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED; +constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MAX = FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION; constexpr int FunctionSignature_Window_WindowType_WindowType_ARRAYSIZE = FunctionSignature_Window_WindowType_WindowType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor(); @@ -167,15 +164,15 @@ inline bool FunctionSignature_Window_WindowType_Parse( FunctionSignature_Window_WindowType_descriptor(), name, value); } enum FunctionSignature_Implementation_Type : int { - FunctionSignature_Implementation_Type_UNKNOWN = 0, - FunctionSignature_Implementation_Type_WEB_ASSEMBLY = 1, - FunctionSignature_Implementation_Type_TRINO_JAR = 2, + FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED = 0, + FunctionSignature_Implementation_Type_TYPE_WEB_ASSEMBLY = 1, + FunctionSignature_Implementation_Type_TYPE_TRINO_JAR = 2, FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool FunctionSignature_Implementation_Type_IsValid(int value); -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MIN = FunctionSignature_Implementation_Type_UNKNOWN; -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MAX = FunctionSignature_Implementation_Type_TRINO_JAR; +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MIN = FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED; +constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MAX = FunctionSignature_Implementation_Type_TYPE_TRINO_JAR; constexpr int FunctionSignature_Implementation_Type_Type_ARRAYSIZE = FunctionSignature_Implementation_Type_Type_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor(); @@ -195,7 +192,7 @@ inline bool FunctionSignature_Implementation_Type_Parse( // =================================================================== class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.FinalArgVariadic) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgVariadic) */ { public: inline FunctionSignature_FinalArgVariadic() : FunctionSignature_FinalArgVariadic(nullptr) {} ~FunctionSignature_FinalArgVariadic() override; @@ -285,7 +282,7 @@ class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : void InternalSwap(FunctionSignature_FinalArgVariadic* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.FinalArgVariadic"; + return "substrait.FunctionSignature.FinalArgVariadic"; } protected: explicit FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -299,12 +296,12 @@ class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : // nested types ---------------------------------------------------- typedef FunctionSignature_FinalArgVariadic_ParameterConsistency ParameterConsistency; - static constexpr ParameterConsistency UNKNOWN = - FunctionSignature_FinalArgVariadic_ParameterConsistency_UNKNOWN; - static constexpr ParameterConsistency CONSISTENT = - FunctionSignature_FinalArgVariadic_ParameterConsistency_CONSISTENT; - static constexpr ParameterConsistency INCONSISTENT = - FunctionSignature_FinalArgVariadic_ParameterConsistency_INCONSISTENT; + static constexpr ParameterConsistency PARAMETER_CONSISTENCY_UNSPECIFIED = + FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED; + static constexpr ParameterConsistency PARAMETER_CONSISTENCY_CONSISTENT = + FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_CONSISTENT; + static constexpr ParameterConsistency PARAMETER_CONSISTENCY_INCONSISTENT = + FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT; static inline bool ParameterConsistency_IsValid(int value) { return FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(value); } @@ -355,16 +352,16 @@ class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : void _internal_set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value); public: - // .io.substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; + // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; void clear_consistency(); - ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency consistency() const; - void set_consistency(::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value); + ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency consistency() const; + void set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value); private: - ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency _internal_consistency() const; - void _internal_set_consistency(::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value); + ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency _internal_consistency() const; + void _internal_set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value); public: - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.FinalArgVariadic) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.FinalArgVariadic) private: class _Internal; @@ -375,12 +372,12 @@ class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::int64 max_args_; int consistency_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature_FinalArgNormal PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.FinalArgNormal) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgNormal) */ { public: inline FunctionSignature_FinalArgNormal() : FunctionSignature_FinalArgNormal(nullptr) {} ~FunctionSignature_FinalArgNormal() override; @@ -470,7 +467,7 @@ class FunctionSignature_FinalArgNormal PROTOBUF_FINAL : void InternalSwap(FunctionSignature_FinalArgNormal* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.FinalArgNormal"; + return "substrait.FunctionSignature.FinalArgNormal"; } protected: explicit FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -485,7 +482,7 @@ class FunctionSignature_FinalArgNormal PROTOBUF_FINAL : // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.FinalArgNormal) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.FinalArgNormal) private: class _Internal; @@ -493,12 +490,12 @@ class FunctionSignature_FinalArgNormal PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature_Scalar PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Scalar) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Scalar) */ { public: inline FunctionSignature_Scalar() : FunctionSignature_Scalar(nullptr) {} ~FunctionSignature_Scalar() override; @@ -594,7 +591,7 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : void InternalSwap(FunctionSignature_Scalar* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.Scalar"; + return "substrait.FunctionSignature.Scalar"; } protected: explicit FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -620,22 +617,22 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : kVariadicFieldNumber = 10, kNormalFieldNumber = 11, }; - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; int arguments_size() const; private: int _internal_arguments_size() const; public: void clear_arguments(); - ::io::substrait::FunctionSignature_Argument* mutable_arguments(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* + ::substrait::FunctionSignature_Argument* mutable_arguments(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* mutable_arguments(); private: - const ::io::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; - ::io::substrait::FunctionSignature_Argument* _internal_add_arguments(); + const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; + ::substrait::FunctionSignature_Argument* _internal_add_arguments(); public: - const ::io::substrait::FunctionSignature_Argument& arguments(int index) const; - ::io::substrait::FunctionSignature_Argument* add_arguments(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& + const ::substrait::FunctionSignature_Argument& arguments(int index) const; + ::substrait::FunctionSignature_Argument* add_arguments(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& arguments() const; // repeated string name = 3; @@ -662,59 +659,59 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : std::string* _internal_add_name(); public: - // repeated .io.substrait.FunctionSignature.Implementation implementations = 12; + // repeated .substrait.FunctionSignature.Implementation implementations = 12; int implementations_size() const; private: int _internal_implementations_size() const; public: void clear_implementations(); - ::io::substrait::FunctionSignature_Implementation* mutable_implementations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* + ::substrait::FunctionSignature_Implementation* mutable_implementations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* mutable_implementations(); private: - const ::io::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; - ::io::substrait::FunctionSignature_Implementation* _internal_add_implementations(); + const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; + ::substrait::FunctionSignature_Implementation* _internal_add_implementations(); public: - const ::io::substrait::FunctionSignature_Implementation& implementations(int index) const; - ::io::substrait::FunctionSignature_Implementation* add_implementations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& + const ::substrait::FunctionSignature_Implementation& implementations(int index) const; + ::substrait::FunctionSignature_Implementation* add_implementations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& implementations() const; - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; bool has_description() const; private: bool _internal_has_description() const; public: void clear_description(); - const ::io::substrait::FunctionSignature_Description& description() const; - ::io::substrait::FunctionSignature_Description* release_description(); - ::io::substrait::FunctionSignature_Description* mutable_description(); - void set_allocated_description(::io::substrait::FunctionSignature_Description* description); + const ::substrait::FunctionSignature_Description& description() const; + ::substrait::FunctionSignature_Description* release_description(); + ::substrait::FunctionSignature_Description* mutable_description(); + void set_allocated_description(::substrait::FunctionSignature_Description* description); private: - const ::io::substrait::FunctionSignature_Description& _internal_description() const; - ::io::substrait::FunctionSignature_Description* _internal_mutable_description(); + const ::substrait::FunctionSignature_Description& _internal_description() const; + ::substrait::FunctionSignature_Description* _internal_mutable_description(); public: void unsafe_arena_set_allocated_description( - ::io::substrait::FunctionSignature_Description* description); - ::io::substrait::FunctionSignature_Description* unsafe_arena_release_description(); + ::substrait::FunctionSignature_Description* description); + ::substrait::FunctionSignature_Description* unsafe_arena_release_description(); - // .io.substrait.DerivationExpression output_type = 9; + // .substrait.DerivationExpression output_type = 9; bool has_output_type() const; private: bool _internal_has_output_type() const; public: void clear_output_type(); - const ::io::substrait::DerivationExpression& output_type() const; - ::io::substrait::DerivationExpression* release_output_type(); - ::io::substrait::DerivationExpression* mutable_output_type(); - void set_allocated_output_type(::io::substrait::DerivationExpression* output_type); + const ::substrait::DerivationExpression& output_type() const; + ::substrait::DerivationExpression* release_output_type(); + ::substrait::DerivationExpression* mutable_output_type(); + void set_allocated_output_type(::substrait::DerivationExpression* output_type); private: - const ::io::substrait::DerivationExpression& _internal_output_type() const; - ::io::substrait::DerivationExpression* _internal_mutable_output_type(); + const ::substrait::DerivationExpression& _internal_output_type() const; + ::substrait::DerivationExpression* _internal_mutable_output_type(); public: void unsafe_arena_set_allocated_output_type( - ::io::substrait::DerivationExpression* output_type); - ::io::substrait::DerivationExpression* unsafe_arena_release_output_type(); + ::substrait::DerivationExpression* output_type); + ::substrait::DerivationExpression* unsafe_arena_release_output_type(); // bool deterministic = 7; void clear_deterministic(); @@ -734,45 +731,45 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : void _internal_set_session_dependent(bool value); public: - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; bool has_variadic() const; private: bool _internal_has_variadic() const; public: void clear_variadic(); - const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic() const; - ::io::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); - ::io::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); - void set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic); + const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const; + ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); + ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); + void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic); private: - const ::io::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; - ::io::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); + const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; + ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); public: void unsafe_arena_set_allocated_variadic( - ::io::substrait::FunctionSignature_FinalArgVariadic* variadic); - ::io::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); + ::substrait::FunctionSignature_FinalArgVariadic* variadic); + ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); - // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + // .substrait.FunctionSignature.FinalArgNormal normal = 11; bool has_normal() const; private: bool _internal_has_normal() const; public: void clear_normal(); - const ::io::substrait::FunctionSignature_FinalArgNormal& normal() const; - ::io::substrait::FunctionSignature_FinalArgNormal* release_normal(); - ::io::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); - void set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal); + const ::substrait::FunctionSignature_FinalArgNormal& normal() const; + ::substrait::FunctionSignature_FinalArgNormal* release_normal(); + ::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); + void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal); private: - const ::io::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; - ::io::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); + const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; + ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); public: void unsafe_arena_set_allocated_normal( - ::io::substrait::FunctionSignature_FinalArgNormal* normal); - ::io::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); + ::substrait::FunctionSignature_FinalArgNormal* normal); + ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); void clear_final_variable_behavior(); FinalVariableBehaviorCase final_variable_behavior_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Scalar) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Scalar) private: class _Internal; void set_has_variadic(); @@ -784,28 +781,28 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument > arguments_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField name_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation > implementations_; - ::io::substrait::FunctionSignature_Description* description_; - ::io::substrait::DerivationExpression* output_type_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_; + ::substrait::FunctionSignature_Description* description_; + ::substrait::DerivationExpression* output_type_; bool deterministic_; bool session_dependent_; union FinalVariableBehaviorUnion { constexpr FinalVariableBehaviorUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::FunctionSignature_FinalArgVariadic* variadic_; - ::io::substrait::FunctionSignature_FinalArgNormal* normal_; + ::substrait::FunctionSignature_FinalArgVariadic* variadic_; + ::substrait::FunctionSignature_FinalArgNormal* normal_; } final_variable_behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature_Aggregate PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Aggregate) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Aggregate) */ { public: inline FunctionSignature_Aggregate() : FunctionSignature_Aggregate(nullptr) {} ~FunctionSignature_Aggregate() override; @@ -901,7 +898,7 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : void InternalSwap(FunctionSignature_Aggregate* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.Aggregate"; + return "substrait.FunctionSignature.Aggregate"; } protected: explicit FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -930,40 +927,40 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : kVariadicFieldNumber = 10, kNormalFieldNumber = 11, }; - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; int arguments_size() const; private: int _internal_arguments_size() const; public: void clear_arguments(); - ::io::substrait::FunctionSignature_Argument* mutable_arguments(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* + ::substrait::FunctionSignature_Argument* mutable_arguments(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* mutable_arguments(); private: - const ::io::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; - ::io::substrait::FunctionSignature_Argument* _internal_add_arguments(); + const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; + ::substrait::FunctionSignature_Argument* _internal_add_arguments(); public: - const ::io::substrait::FunctionSignature_Argument& arguments(int index) const; - ::io::substrait::FunctionSignature_Argument* add_arguments(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& + const ::substrait::FunctionSignature_Argument& arguments(int index) const; + ::substrait::FunctionSignature_Argument* add_arguments(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& arguments() const; - // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + // repeated .substrait.FunctionSignature.Implementation implementations = 15; int implementations_size() const; private: int _internal_implementations_size() const; public: void clear_implementations(); - ::io::substrait::FunctionSignature_Implementation* mutable_implementations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* + ::substrait::FunctionSignature_Implementation* mutable_implementations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* mutable_implementations(); private: - const ::io::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; - ::io::substrait::FunctionSignature_Implementation* _internal_add_implementations(); + const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; + ::substrait::FunctionSignature_Implementation* _internal_add_implementations(); public: - const ::io::substrait::FunctionSignature_Implementation& implementations(int index) const; - ::io::substrait::FunctionSignature_Implementation* add_implementations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& + const ::substrait::FunctionSignature_Implementation& implementations(int index) const; + ::substrait::FunctionSignature_Implementation* add_implementations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& implementations() const; // string name = 3; @@ -980,59 +977,59 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : std::string* _internal_mutable_name(); public: - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; bool has_description() const; private: bool _internal_has_description() const; public: void clear_description(); - const ::io::substrait::FunctionSignature_Description& description() const; - ::io::substrait::FunctionSignature_Description* release_description(); - ::io::substrait::FunctionSignature_Description* mutable_description(); - void set_allocated_description(::io::substrait::FunctionSignature_Description* description); + const ::substrait::FunctionSignature_Description& description() const; + ::substrait::FunctionSignature_Description* release_description(); + ::substrait::FunctionSignature_Description* mutable_description(); + void set_allocated_description(::substrait::FunctionSignature_Description* description); private: - const ::io::substrait::FunctionSignature_Description& _internal_description() const; - ::io::substrait::FunctionSignature_Description* _internal_mutable_description(); + const ::substrait::FunctionSignature_Description& _internal_description() const; + ::substrait::FunctionSignature_Description* _internal_mutable_description(); public: void unsafe_arena_set_allocated_description( - ::io::substrait::FunctionSignature_Description* description); - ::io::substrait::FunctionSignature_Description* unsafe_arena_release_description(); + ::substrait::FunctionSignature_Description* description); + ::substrait::FunctionSignature_Description* unsafe_arena_release_description(); - // .io.substrait.DerivationExpression output_type = 9; + // .substrait.DerivationExpression output_type = 9; bool has_output_type() const; private: bool _internal_has_output_type() const; public: void clear_output_type(); - const ::io::substrait::DerivationExpression& output_type() const; - ::io::substrait::DerivationExpression* release_output_type(); - ::io::substrait::DerivationExpression* mutable_output_type(); - void set_allocated_output_type(::io::substrait::DerivationExpression* output_type); + const ::substrait::DerivationExpression& output_type() const; + ::substrait::DerivationExpression* release_output_type(); + ::substrait::DerivationExpression* mutable_output_type(); + void set_allocated_output_type(::substrait::DerivationExpression* output_type); private: - const ::io::substrait::DerivationExpression& _internal_output_type() const; - ::io::substrait::DerivationExpression* _internal_mutable_output_type(); + const ::substrait::DerivationExpression& _internal_output_type() const; + ::substrait::DerivationExpression* _internal_mutable_output_type(); public: void unsafe_arena_set_allocated_output_type( - ::io::substrait::DerivationExpression* output_type); - ::io::substrait::DerivationExpression* unsafe_arena_release_output_type(); + ::substrait::DerivationExpression* output_type); + ::substrait::DerivationExpression* unsafe_arena_release_output_type(); - // .io.substrait.Type intermediate_type = 13; + // .substrait.Type intermediate_type = 13; bool has_intermediate_type() const; private: bool _internal_has_intermediate_type() const; public: void clear_intermediate_type(); - const ::io::substrait::Type& intermediate_type() const; - ::io::substrait::Type* release_intermediate_type(); - ::io::substrait::Type* mutable_intermediate_type(); - void set_allocated_intermediate_type(::io::substrait::Type* intermediate_type); + const ::substrait::Type& intermediate_type() const; + ::substrait::Type* release_intermediate_type(); + ::substrait::Type* mutable_intermediate_type(); + void set_allocated_intermediate_type(::substrait::Type* intermediate_type); private: - const ::io::substrait::Type& _internal_intermediate_type() const; - ::io::substrait::Type* _internal_mutable_intermediate_type(); + const ::substrait::Type& _internal_intermediate_type() const; + ::substrait::Type* _internal_mutable_intermediate_type(); public: void unsafe_arena_set_allocated_intermediate_type( - ::io::substrait::Type* intermediate_type); - ::io::substrait::Type* unsafe_arena_release_intermediate_type(); + ::substrait::Type* intermediate_type); + ::substrait::Type* unsafe_arena_release_intermediate_type(); // bool deterministic = 7; void clear_deterministic(); @@ -1070,45 +1067,45 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : void _internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); public: - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; bool has_variadic() const; private: bool _internal_has_variadic() const; public: void clear_variadic(); - const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic() const; - ::io::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); - ::io::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); - void set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic); + const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const; + ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); + ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); + void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic); private: - const ::io::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; - ::io::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); + const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; + ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); public: void unsafe_arena_set_allocated_variadic( - ::io::substrait::FunctionSignature_FinalArgVariadic* variadic); - ::io::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); + ::substrait::FunctionSignature_FinalArgVariadic* variadic); + ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); - // .io.substrait.FunctionSignature.FinalArgNormal normal = 11; + // .substrait.FunctionSignature.FinalArgNormal normal = 11; bool has_normal() const; private: bool _internal_has_normal() const; public: void clear_normal(); - const ::io::substrait::FunctionSignature_FinalArgNormal& normal() const; - ::io::substrait::FunctionSignature_FinalArgNormal* release_normal(); - ::io::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); - void set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal); + const ::substrait::FunctionSignature_FinalArgNormal& normal() const; + ::substrait::FunctionSignature_FinalArgNormal* release_normal(); + ::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); + void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal); private: - const ::io::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; - ::io::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); + const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; + ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); public: void unsafe_arena_set_allocated_normal( - ::io::substrait::FunctionSignature_FinalArgNormal* normal); - ::io::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); + ::substrait::FunctionSignature_FinalArgNormal* normal); + ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); void clear_final_variable_behavior(); FinalVariableBehaviorCase final_variable_behavior_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Aggregate) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Aggregate) private: class _Internal; void set_has_variadic(); @@ -1120,12 +1117,12 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument > arguments_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation > implementations_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::io::substrait::FunctionSignature_Description* description_; - ::io::substrait::DerivationExpression* output_type_; - ::io::substrait::Type* intermediate_type_; + ::substrait::FunctionSignature_Description* description_; + ::substrait::DerivationExpression* output_type_; + ::substrait::Type* intermediate_type_; bool deterministic_; bool session_dependent_; bool ordered_; @@ -1133,18 +1130,18 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : union FinalVariableBehaviorUnion { constexpr FinalVariableBehaviorUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::FunctionSignature_FinalArgVariadic* variadic_; - ::io::substrait::FunctionSignature_FinalArgNormal* normal_; + ::substrait::FunctionSignature_FinalArgVariadic* variadic_; + ::substrait::FunctionSignature_FinalArgNormal* normal_; } final_variable_behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature_Window PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Window) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Window) */ { public: inline FunctionSignature_Window() : FunctionSignature_Window(nullptr) {} ~FunctionSignature_Window() override; @@ -1240,7 +1237,7 @@ class FunctionSignature_Window PROTOBUF_FINAL : void InternalSwap(FunctionSignature_Window* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.Window"; + return "substrait.FunctionSignature.Window"; } protected: explicit FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1254,12 +1251,12 @@ class FunctionSignature_Window PROTOBUF_FINAL : // nested types ---------------------------------------------------- typedef FunctionSignature_Window_WindowType WindowType; - static constexpr WindowType UNKNOWN = - FunctionSignature_Window_WindowType_UNKNOWN; - static constexpr WindowType STREAMING = - FunctionSignature_Window_WindowType_STREAMING; - static constexpr WindowType PARTITION = - FunctionSignature_Window_WindowType_PARTITION; + static constexpr WindowType WINDOW_TYPE_UNSPECIFIED = + FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED; + static constexpr WindowType WINDOW_TYPE_STREAMING = + FunctionSignature_Window_WindowType_WINDOW_TYPE_STREAMING; + static constexpr WindowType WINDOW_TYPE_PARTITION = + FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION; static inline bool WindowType_IsValid(int value) { return FunctionSignature_Window_WindowType_IsValid(value); } @@ -1302,22 +1299,22 @@ class FunctionSignature_Window PROTOBUF_FINAL : kVariadicFieldNumber = 16, kNormalFieldNumber = 17, }; - // repeated .io.substrait.FunctionSignature.Argument arguments = 2; + // repeated .substrait.FunctionSignature.Argument arguments = 2; int arguments_size() const; private: int _internal_arguments_size() const; public: void clear_arguments(); - ::io::substrait::FunctionSignature_Argument* mutable_arguments(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* + ::substrait::FunctionSignature_Argument* mutable_arguments(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* mutable_arguments(); private: - const ::io::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; - ::io::substrait::FunctionSignature_Argument* _internal_add_arguments(); + const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; + ::substrait::FunctionSignature_Argument* _internal_add_arguments(); public: - const ::io::substrait::FunctionSignature_Argument& arguments(int index) const; - ::io::substrait::FunctionSignature_Argument* add_arguments(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& + const ::substrait::FunctionSignature_Argument& arguments(int index) const; + ::substrait::FunctionSignature_Argument* add_arguments(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& arguments() const; // repeated string name = 3; @@ -1344,77 +1341,77 @@ class FunctionSignature_Window PROTOBUF_FINAL : std::string* _internal_add_name(); public: - // repeated .io.substrait.FunctionSignature.Implementation implementations = 15; + // repeated .substrait.FunctionSignature.Implementation implementations = 15; int implementations_size() const; private: int _internal_implementations_size() const; public: void clear_implementations(); - ::io::substrait::FunctionSignature_Implementation* mutable_implementations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* + ::substrait::FunctionSignature_Implementation* mutable_implementations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* mutable_implementations(); private: - const ::io::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; - ::io::substrait::FunctionSignature_Implementation* _internal_add_implementations(); + const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; + ::substrait::FunctionSignature_Implementation* _internal_add_implementations(); public: - const ::io::substrait::FunctionSignature_Implementation& implementations(int index) const; - ::io::substrait::FunctionSignature_Implementation* add_implementations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& + const ::substrait::FunctionSignature_Implementation& implementations(int index) const; + ::substrait::FunctionSignature_Implementation* add_implementations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& implementations() const; - // .io.substrait.FunctionSignature.Description description = 4; + // .substrait.FunctionSignature.Description description = 4; bool has_description() const; private: bool _internal_has_description() const; public: void clear_description(); - const ::io::substrait::FunctionSignature_Description& description() const; - ::io::substrait::FunctionSignature_Description* release_description(); - ::io::substrait::FunctionSignature_Description* mutable_description(); - void set_allocated_description(::io::substrait::FunctionSignature_Description* description); + const ::substrait::FunctionSignature_Description& description() const; + ::substrait::FunctionSignature_Description* release_description(); + ::substrait::FunctionSignature_Description* mutable_description(); + void set_allocated_description(::substrait::FunctionSignature_Description* description); private: - const ::io::substrait::FunctionSignature_Description& _internal_description() const; - ::io::substrait::FunctionSignature_Description* _internal_mutable_description(); + const ::substrait::FunctionSignature_Description& _internal_description() const; + ::substrait::FunctionSignature_Description* _internal_mutable_description(); public: void unsafe_arena_set_allocated_description( - ::io::substrait::FunctionSignature_Description* description); - ::io::substrait::FunctionSignature_Description* unsafe_arena_release_description(); + ::substrait::FunctionSignature_Description* description); + ::substrait::FunctionSignature_Description* unsafe_arena_release_description(); - // .io.substrait.DerivationExpression intermediate_type = 9; + // .substrait.DerivationExpression intermediate_type = 9; bool has_intermediate_type() const; private: bool _internal_has_intermediate_type() const; public: void clear_intermediate_type(); - const ::io::substrait::DerivationExpression& intermediate_type() const; - ::io::substrait::DerivationExpression* release_intermediate_type(); - ::io::substrait::DerivationExpression* mutable_intermediate_type(); - void set_allocated_intermediate_type(::io::substrait::DerivationExpression* intermediate_type); + const ::substrait::DerivationExpression& intermediate_type() const; + ::substrait::DerivationExpression* release_intermediate_type(); + ::substrait::DerivationExpression* mutable_intermediate_type(); + void set_allocated_intermediate_type(::substrait::DerivationExpression* intermediate_type); private: - const ::io::substrait::DerivationExpression& _internal_intermediate_type() const; - ::io::substrait::DerivationExpression* _internal_mutable_intermediate_type(); + const ::substrait::DerivationExpression& _internal_intermediate_type() const; + ::substrait::DerivationExpression* _internal_mutable_intermediate_type(); public: void unsafe_arena_set_allocated_intermediate_type( - ::io::substrait::DerivationExpression* intermediate_type); - ::io::substrait::DerivationExpression* unsafe_arena_release_intermediate_type(); + ::substrait::DerivationExpression* intermediate_type); + ::substrait::DerivationExpression* unsafe_arena_release_intermediate_type(); - // .io.substrait.DerivationExpression output_type = 10; + // .substrait.DerivationExpression output_type = 10; bool has_output_type() const; private: bool _internal_has_output_type() const; public: void clear_output_type(); - const ::io::substrait::DerivationExpression& output_type() const; - ::io::substrait::DerivationExpression* release_output_type(); - ::io::substrait::DerivationExpression* mutable_output_type(); - void set_allocated_output_type(::io::substrait::DerivationExpression* output_type); + const ::substrait::DerivationExpression& output_type() const; + ::substrait::DerivationExpression* release_output_type(); + ::substrait::DerivationExpression* mutable_output_type(); + void set_allocated_output_type(::substrait::DerivationExpression* output_type); private: - const ::io::substrait::DerivationExpression& _internal_output_type() const; - ::io::substrait::DerivationExpression* _internal_mutable_output_type(); + const ::substrait::DerivationExpression& _internal_output_type() const; + ::substrait::DerivationExpression* _internal_mutable_output_type(); public: void unsafe_arena_set_allocated_output_type( - ::io::substrait::DerivationExpression* output_type); - ::io::substrait::DerivationExpression* unsafe_arena_release_output_type(); + ::substrait::DerivationExpression* output_type); + ::substrait::DerivationExpression* unsafe_arena_release_output_type(); // bool deterministic = 7; void clear_deterministic(); @@ -1443,13 +1440,13 @@ class FunctionSignature_Window PROTOBUF_FINAL : void _internal_set_ordered(bool value); public: - // .io.substrait.FunctionSignature.Window.WindowType window_type = 14; + // .substrait.FunctionSignature.Window.WindowType window_type = 14; void clear_window_type(); - ::io::substrait::FunctionSignature_Window_WindowType window_type() const; - void set_window_type(::io::substrait::FunctionSignature_Window_WindowType value); + ::substrait::FunctionSignature_Window_WindowType window_type() const; + void set_window_type(::substrait::FunctionSignature_Window_WindowType value); private: - ::io::substrait::FunctionSignature_Window_WindowType _internal_window_type() const; - void _internal_set_window_type(::io::substrait::FunctionSignature_Window_WindowType value); + ::substrait::FunctionSignature_Window_WindowType _internal_window_type() const; + void _internal_set_window_type(::substrait::FunctionSignature_Window_WindowType value); public: // uint64 max_set = 12; @@ -1461,45 +1458,45 @@ class FunctionSignature_Window PROTOBUF_FINAL : void _internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); public: - // .io.substrait.FunctionSignature.FinalArgVariadic variadic = 16; + // .substrait.FunctionSignature.FinalArgVariadic variadic = 16; bool has_variadic() const; private: bool _internal_has_variadic() const; public: void clear_variadic(); - const ::io::substrait::FunctionSignature_FinalArgVariadic& variadic() const; - ::io::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); - ::io::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); - void set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic); + const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const; + ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); + ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); + void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic); private: - const ::io::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; - ::io::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); + const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; + ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); public: void unsafe_arena_set_allocated_variadic( - ::io::substrait::FunctionSignature_FinalArgVariadic* variadic); - ::io::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); + ::substrait::FunctionSignature_FinalArgVariadic* variadic); + ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); - // .io.substrait.FunctionSignature.FinalArgNormal normal = 17; + // .substrait.FunctionSignature.FinalArgNormal normal = 17; bool has_normal() const; private: bool _internal_has_normal() const; public: void clear_normal(); - const ::io::substrait::FunctionSignature_FinalArgNormal& normal() const; - ::io::substrait::FunctionSignature_FinalArgNormal* release_normal(); - ::io::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); - void set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal); + const ::substrait::FunctionSignature_FinalArgNormal& normal() const; + ::substrait::FunctionSignature_FinalArgNormal* release_normal(); + ::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); + void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal); private: - const ::io::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; - ::io::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); + const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; + ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); public: void unsafe_arena_set_allocated_normal( - ::io::substrait::FunctionSignature_FinalArgNormal* normal); - ::io::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); + ::substrait::FunctionSignature_FinalArgNormal* normal); + ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); void clear_final_variable_behavior(); FinalVariableBehaviorCase final_variable_behavior_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Window) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Window) private: class _Internal; void set_has_variadic(); @@ -1511,12 +1508,12 @@ class FunctionSignature_Window PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument > arguments_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField name_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation > implementations_; - ::io::substrait::FunctionSignature_Description* description_; - ::io::substrait::DerivationExpression* intermediate_type_; - ::io::substrait::DerivationExpression* output_type_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_; + ::substrait::FunctionSignature_Description* description_; + ::substrait::DerivationExpression* intermediate_type_; + ::substrait::DerivationExpression* output_type_; bool deterministic_; bool session_dependent_; bool ordered_; @@ -1525,18 +1522,18 @@ class FunctionSignature_Window PROTOBUF_FINAL : union FinalVariableBehaviorUnion { constexpr FinalVariableBehaviorUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::FunctionSignature_FinalArgVariadic* variadic_; - ::io::substrait::FunctionSignature_FinalArgNormal* normal_; + ::substrait::FunctionSignature_FinalArgVariadic* variadic_; + ::substrait::FunctionSignature_FinalArgNormal* normal_; } final_variable_behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature_Description PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Description) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Description) */ { public: inline FunctionSignature_Description() : FunctionSignature_Description(nullptr) {} ~FunctionSignature_Description() override; @@ -1626,7 +1623,7 @@ class FunctionSignature_Description PROTOBUF_FINAL : void InternalSwap(FunctionSignature_Description* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.Description"; + return "substrait.FunctionSignature.Description"; } protected: explicit FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1673,7 +1670,7 @@ class FunctionSignature_Description PROTOBUF_FINAL : std::string* _internal_mutable_body(); public: - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Description) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Description) private: class _Internal; @@ -1683,12 +1680,12 @@ class FunctionSignature_Description PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr language_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature_Implementation PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Implementation) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Implementation) */ { public: inline FunctionSignature_Implementation() : FunctionSignature_Implementation(nullptr) {} ~FunctionSignature_Implementation() override; @@ -1778,7 +1775,7 @@ class FunctionSignature_Implementation PROTOBUF_FINAL : void InternalSwap(FunctionSignature_Implementation* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.Implementation"; + return "substrait.FunctionSignature.Implementation"; } protected: explicit FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1792,12 +1789,12 @@ class FunctionSignature_Implementation PROTOBUF_FINAL : // nested types ---------------------------------------------------- typedef FunctionSignature_Implementation_Type Type; - static constexpr Type UNKNOWN = - FunctionSignature_Implementation_Type_UNKNOWN; - static constexpr Type WEB_ASSEMBLY = - FunctionSignature_Implementation_Type_WEB_ASSEMBLY; - static constexpr Type TRINO_JAR = - FunctionSignature_Implementation_Type_TRINO_JAR; + static constexpr Type TYPE_UNSPECIFIED = + FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED; + static constexpr Type TYPE_WEB_ASSEMBLY = + FunctionSignature_Implementation_Type_TYPE_WEB_ASSEMBLY; + static constexpr Type TYPE_TRINO_JAR = + FunctionSignature_Implementation_Type_TYPE_TRINO_JAR; static inline bool Type_IsValid(int value) { return FunctionSignature_Implementation_Type_IsValid(value); } @@ -1843,16 +1840,16 @@ class FunctionSignature_Implementation PROTOBUF_FINAL : std::string* _internal_mutable_uri(); public: - // .io.substrait.FunctionSignature.Implementation.Type type = 1; + // .substrait.FunctionSignature.Implementation.Type type = 1; void clear_type(); - ::io::substrait::FunctionSignature_Implementation_Type type() const; - void set_type(::io::substrait::FunctionSignature_Implementation_Type value); + ::substrait::FunctionSignature_Implementation_Type type() const; + void set_type(::substrait::FunctionSignature_Implementation_Type value); private: - ::io::substrait::FunctionSignature_Implementation_Type _internal_type() const; - void _internal_set_type(::io::substrait::FunctionSignature_Implementation_Type value); + ::substrait::FunctionSignature_Implementation_Type _internal_type() const; + void _internal_set_type(::substrait::FunctionSignature_Implementation_Type value); public: - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Implementation) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Implementation) private: class _Internal; @@ -1862,12 +1859,12 @@ class FunctionSignature_Implementation PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; int type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Argument.ValueArgument) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.ValueArgument) */ { public: inline FunctionSignature_Argument_ValueArgument() : FunctionSignature_Argument_ValueArgument(nullptr) {} ~FunctionSignature_Argument_ValueArgument() override; @@ -1957,7 +1954,7 @@ class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : void InternalSwap(FunctionSignature_Argument_ValueArgument* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.Argument.ValueArgument"; + return "substrait.FunctionSignature.Argument.ValueArgument"; } protected: explicit FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1976,23 +1973,23 @@ class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : kTypeFieldNumber = 1, kConstantFieldNumber = 2, }; - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; bool has_type() const; private: bool _internal_has_type() const; public: void clear_type(); - const ::io::substrait::ParameterizedType& type() const; - ::io::substrait::ParameterizedType* release_type(); - ::io::substrait::ParameterizedType* mutable_type(); - void set_allocated_type(::io::substrait::ParameterizedType* type); + const ::substrait::ParameterizedType& type() const; + ::substrait::ParameterizedType* release_type(); + ::substrait::ParameterizedType* mutable_type(); + void set_allocated_type(::substrait::ParameterizedType* type); private: - const ::io::substrait::ParameterizedType& _internal_type() const; - ::io::substrait::ParameterizedType* _internal_mutable_type(); + const ::substrait::ParameterizedType& _internal_type() const; + ::substrait::ParameterizedType* _internal_mutable_type(); public: void unsafe_arena_set_allocated_type( - ::io::substrait::ParameterizedType* type); - ::io::substrait::ParameterizedType* unsafe_arena_release_type(); + ::substrait::ParameterizedType* type); + ::substrait::ParameterizedType* unsafe_arena_release_type(); // bool constant = 2; void clear_constant(); @@ -2003,22 +2000,22 @@ class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : void _internal_set_constant(bool value); public: - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Argument.ValueArgument) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.ValueArgument) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::ParameterizedType* type_; + ::substrait::ParameterizedType* type_; bool constant_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature_Argument_TypeArgument PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Argument.TypeArgument) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.TypeArgument) */ { public: inline FunctionSignature_Argument_TypeArgument() : FunctionSignature_Argument_TypeArgument(nullptr) {} ~FunctionSignature_Argument_TypeArgument() override; @@ -2108,7 +2105,7 @@ class FunctionSignature_Argument_TypeArgument PROTOBUF_FINAL : void InternalSwap(FunctionSignature_Argument_TypeArgument* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.Argument.TypeArgument"; + return "substrait.FunctionSignature.Argument.TypeArgument"; } protected: explicit FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2126,39 +2123,39 @@ class FunctionSignature_Argument_TypeArgument PROTOBUF_FINAL : enum : int { kTypeFieldNumber = 1, }; - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; bool has_type() const; private: bool _internal_has_type() const; public: void clear_type(); - const ::io::substrait::ParameterizedType& type() const; - ::io::substrait::ParameterizedType* release_type(); - ::io::substrait::ParameterizedType* mutable_type(); - void set_allocated_type(::io::substrait::ParameterizedType* type); + const ::substrait::ParameterizedType& type() const; + ::substrait::ParameterizedType* release_type(); + ::substrait::ParameterizedType* mutable_type(); + void set_allocated_type(::substrait::ParameterizedType* type); private: - const ::io::substrait::ParameterizedType& _internal_type() const; - ::io::substrait::ParameterizedType* _internal_mutable_type(); + const ::substrait::ParameterizedType& _internal_type() const; + ::substrait::ParameterizedType* _internal_mutable_type(); public: void unsafe_arena_set_allocated_type( - ::io::substrait::ParameterizedType* type); - ::io::substrait::ParameterizedType* unsafe_arena_release_type(); + ::substrait::ParameterizedType* type); + ::substrait::ParameterizedType* unsafe_arena_release_type(); - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Argument.TypeArgument) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.TypeArgument) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::ParameterizedType* type_; + ::substrait::ParameterizedType* type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature_Argument_EnumArgument PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Argument.EnumArgument) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.EnumArgument) */ { public: inline FunctionSignature_Argument_EnumArgument() : FunctionSignature_Argument_EnumArgument(nullptr) {} ~FunctionSignature_Argument_EnumArgument() override; @@ -2248,7 +2245,7 @@ class FunctionSignature_Argument_EnumArgument PROTOBUF_FINAL : void InternalSwap(FunctionSignature_Argument_EnumArgument* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.Argument.EnumArgument"; + return "substrait.FunctionSignature.Argument.EnumArgument"; } protected: explicit FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2300,7 +2297,7 @@ class FunctionSignature_Argument_EnumArgument PROTOBUF_FINAL : void _internal_set_optional(bool value); public: - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Argument.EnumArgument) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.EnumArgument) private: class _Internal; @@ -2310,12 +2307,12 @@ class FunctionSignature_Argument_EnumArgument PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField options_; bool optional_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature_Argument PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature.Argument) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument) */ { public: inline FunctionSignature_Argument() : FunctionSignature_Argument(nullptr) {} ~FunctionSignature_Argument() override; @@ -2412,7 +2409,7 @@ class FunctionSignature_Argument PROTOBUF_FINAL : void InternalSwap(FunctionSignature_Argument* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature.Argument"; + return "substrait.FunctionSignature.Argument"; } protected: explicit FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2451,63 +2448,63 @@ class FunctionSignature_Argument PROTOBUF_FINAL : std::string* _internal_mutable_name(); public: - // .io.substrait.FunctionSignature.Argument.ValueArgument value = 2; + // .substrait.FunctionSignature.Argument.ValueArgument value = 2; bool has_value() const; private: bool _internal_has_value() const; public: void clear_value(); - const ::io::substrait::FunctionSignature_Argument_ValueArgument& value() const; - ::io::substrait::FunctionSignature_Argument_ValueArgument* release_value(); - ::io::substrait::FunctionSignature_Argument_ValueArgument* mutable_value(); - void set_allocated_value(::io::substrait::FunctionSignature_Argument_ValueArgument* value); + const ::substrait::FunctionSignature_Argument_ValueArgument& value() const; + ::substrait::FunctionSignature_Argument_ValueArgument* release_value(); + ::substrait::FunctionSignature_Argument_ValueArgument* mutable_value(); + void set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value); private: - const ::io::substrait::FunctionSignature_Argument_ValueArgument& _internal_value() const; - ::io::substrait::FunctionSignature_Argument_ValueArgument* _internal_mutable_value(); + const ::substrait::FunctionSignature_Argument_ValueArgument& _internal_value() const; + ::substrait::FunctionSignature_Argument_ValueArgument* _internal_mutable_value(); public: void unsafe_arena_set_allocated_value( - ::io::substrait::FunctionSignature_Argument_ValueArgument* value); - ::io::substrait::FunctionSignature_Argument_ValueArgument* unsafe_arena_release_value(); + ::substrait::FunctionSignature_Argument_ValueArgument* value); + ::substrait::FunctionSignature_Argument_ValueArgument* unsafe_arena_release_value(); - // .io.substrait.FunctionSignature.Argument.TypeArgument type = 3; + // .substrait.FunctionSignature.Argument.TypeArgument type = 3; bool has_type() const; private: bool _internal_has_type() const; public: void clear_type(); - const ::io::substrait::FunctionSignature_Argument_TypeArgument& type() const; - ::io::substrait::FunctionSignature_Argument_TypeArgument* release_type(); - ::io::substrait::FunctionSignature_Argument_TypeArgument* mutable_type(); - void set_allocated_type(::io::substrait::FunctionSignature_Argument_TypeArgument* type); + const ::substrait::FunctionSignature_Argument_TypeArgument& type() const; + ::substrait::FunctionSignature_Argument_TypeArgument* release_type(); + ::substrait::FunctionSignature_Argument_TypeArgument* mutable_type(); + void set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type); private: - const ::io::substrait::FunctionSignature_Argument_TypeArgument& _internal_type() const; - ::io::substrait::FunctionSignature_Argument_TypeArgument* _internal_mutable_type(); + const ::substrait::FunctionSignature_Argument_TypeArgument& _internal_type() const; + ::substrait::FunctionSignature_Argument_TypeArgument* _internal_mutable_type(); public: void unsafe_arena_set_allocated_type( - ::io::substrait::FunctionSignature_Argument_TypeArgument* type); - ::io::substrait::FunctionSignature_Argument_TypeArgument* unsafe_arena_release_type(); + ::substrait::FunctionSignature_Argument_TypeArgument* type); + ::substrait::FunctionSignature_Argument_TypeArgument* unsafe_arena_release_type(); - // .io.substrait.FunctionSignature.Argument.EnumArgument enum = 4; + // .substrait.FunctionSignature.Argument.EnumArgument enum = 4; bool has_enum_() const; private: bool _internal_has_enum_() const; public: void clear_enum_(); - const ::io::substrait::FunctionSignature_Argument_EnumArgument& enum_() const; - ::io::substrait::FunctionSignature_Argument_EnumArgument* release_enum_(); - ::io::substrait::FunctionSignature_Argument_EnumArgument* mutable_enum_(); - void set_allocated_enum_(::io::substrait::FunctionSignature_Argument_EnumArgument* enum_); + const ::substrait::FunctionSignature_Argument_EnumArgument& enum_() const; + ::substrait::FunctionSignature_Argument_EnumArgument* release_enum_(); + ::substrait::FunctionSignature_Argument_EnumArgument* mutable_enum_(); + void set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_); private: - const ::io::substrait::FunctionSignature_Argument_EnumArgument& _internal_enum_() const; - ::io::substrait::FunctionSignature_Argument_EnumArgument* _internal_mutable_enum_(); + const ::substrait::FunctionSignature_Argument_EnumArgument& _internal_enum_() const; + ::substrait::FunctionSignature_Argument_EnumArgument* _internal_mutable_enum_(); public: void unsafe_arena_set_allocated_enum_( - ::io::substrait::FunctionSignature_Argument_EnumArgument* enum_); - ::io::substrait::FunctionSignature_Argument_EnumArgument* unsafe_arena_release_enum_(); + ::substrait::FunctionSignature_Argument_EnumArgument* enum_); + ::substrait::FunctionSignature_Argument_EnumArgument* unsafe_arena_release_enum_(); void clear_argument_kind(); ArgumentKindCase argument_kind_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature.Argument) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument) private: class _Internal; void set_has_value(); @@ -2524,19 +2521,19 @@ class FunctionSignature_Argument PROTOBUF_FINAL : union ArgumentKindUnion { constexpr ArgumentKindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::FunctionSignature_Argument_ValueArgument* value_; - ::io::substrait::FunctionSignature_Argument_TypeArgument* type_; - ::io::substrait::FunctionSignature_Argument_EnumArgument* enum__; + ::substrait::FunctionSignature_Argument_ValueArgument* value_; + ::substrait::FunctionSignature_Argument_TypeArgument* type_; + ::substrait::FunctionSignature_Argument_EnumArgument* enum__; } argument_kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- class FunctionSignature PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FunctionSignature) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature) */ { public: inline FunctionSignature() : FunctionSignature(nullptr) {} ~FunctionSignature() override; @@ -2626,7 +2623,7 @@ class FunctionSignature PROTOBUF_FINAL : void InternalSwap(FunctionSignature* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FunctionSignature"; + return "substrait.FunctionSignature"; } protected: explicit FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2650,7 +2647,7 @@ class FunctionSignature PROTOBUF_FINAL : // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:io.substrait.FunctionSignature) + // @@protoc_insertion_point(class_scope:substrait.FunctionSignature) private: class _Internal; @@ -2658,7 +2655,7 @@ class FunctionSignature PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_function_2eproto; + friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // =================================================================== @@ -2679,7 +2676,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::_inter return min_args_; } inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::min_args() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.FinalArgVariadic.min_args) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.min_args) return _internal_min_args(); } inline void FunctionSignature_FinalArgVariadic::_internal_set_min_args(::PROTOBUF_NAMESPACE_ID::int64 value) { @@ -2688,7 +2685,7 @@ inline void FunctionSignature_FinalArgVariadic::_internal_set_min_args(::PROTOBU } inline void FunctionSignature_FinalArgVariadic::set_min_args(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_min_args(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.FinalArgVariadic.min_args) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.min_args) } // int64 max_args = 2; @@ -2699,7 +2696,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::_inter return max_args_; } inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::max_args() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.FinalArgVariadic.max_args) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.max_args) return _internal_max_args(); } inline void FunctionSignature_FinalArgVariadic::_internal_set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value) { @@ -2708,27 +2705,27 @@ inline void FunctionSignature_FinalArgVariadic::_internal_set_max_args(::PROTOBU } inline void FunctionSignature_FinalArgVariadic::set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_max_args(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.FinalArgVariadic.max_args) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.max_args) } -// .io.substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; +// .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; inline void FunctionSignature_FinalArgVariadic::clear_consistency() { consistency_ = 0; } -inline ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::_internal_consistency() const { - return static_cast< ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency >(consistency_); +inline ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::_internal_consistency() const { + return static_cast< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency >(consistency_); } -inline ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::consistency() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.FinalArgVariadic.consistency) +inline ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::consistency() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.consistency) return _internal_consistency(); } -inline void FunctionSignature_FinalArgVariadic::_internal_set_consistency(::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) { +inline void FunctionSignature_FinalArgVariadic::_internal_set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) { consistency_ = value; } -inline void FunctionSignature_FinalArgVariadic::set_consistency(::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) { +inline void FunctionSignature_FinalArgVariadic::set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) { _internal_set_consistency(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.FinalArgVariadic.consistency) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.consistency) } // ------------------------------------------------------------------- @@ -2739,7 +2736,7 @@ inline void FunctionSignature_FinalArgVariadic::set_consistency(::io::substrait: // FunctionSignature_Scalar -// repeated .io.substrait.FunctionSignature.Argument arguments = 2; +// repeated .substrait.FunctionSignature.Argument arguments = 2; inline int FunctionSignature_Scalar::_internal_arguments_size() const { return arguments_.size(); } @@ -2749,32 +2746,32 @@ inline int FunctionSignature_Scalar::arguments_size() const { inline void FunctionSignature_Scalar::clear_arguments() { arguments_.Clear(); } -inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::mutable_arguments(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.arguments) +inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::mutable_arguments(int index) { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.arguments) return arguments_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* FunctionSignature_Scalar::mutable_arguments() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Scalar.arguments) + // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.arguments) return &arguments_; } -inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::_internal_arguments(int index) const { +inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::_internal_arguments(int index) const { return arguments_.Get(index); } -inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::arguments(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.arguments) +inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::arguments(int index) const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.arguments) return _internal_arguments(index); } -inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::_internal_add_arguments() { +inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::_internal_add_arguments() { return arguments_.Add(); } -inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::add_arguments() { - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Scalar.arguments) +inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::add_arguments() { + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.arguments) return _internal_add_arguments(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& FunctionSignature_Scalar::arguments() const { - // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Scalar.arguments) + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.arguments) return arguments_; } @@ -2789,70 +2786,70 @@ inline void FunctionSignature_Scalar::clear_name() { name_.Clear(); } inline std::string* FunctionSignature_Scalar::add_name() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Scalar.name) return _internal_add_name(); } inline const std::string& FunctionSignature_Scalar::_internal_name(int index) const { return name_.Get(index); } inline const std::string& FunctionSignature_Scalar::name(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.name) return _internal_name(index); } inline std::string* FunctionSignature_Scalar::mutable_name(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.name) return name_.Mutable(index); } inline void FunctionSignature_Scalar::set_name(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name) name_.Mutable(index)->assign(value); } inline void FunctionSignature_Scalar::set_name(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name) name_.Mutable(index)->assign(std::move(value)); } inline void FunctionSignature_Scalar::set_name(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); name_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Scalar.name) } inline void FunctionSignature_Scalar::set_name(int index, const char* value, size_t size) { name_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Scalar.name) } inline std::string* FunctionSignature_Scalar::_internal_add_name() { return name_.Add(); } inline void FunctionSignature_Scalar::add_name(const std::string& value) { name_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.name) } inline void FunctionSignature_Scalar::add_name(std::string&& value) { name_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.name) } inline void FunctionSignature_Scalar::add_name(const char* value) { GOOGLE_DCHECK(value != nullptr); name_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Scalar.name) } inline void FunctionSignature_Scalar::add_name(const char* value, size_t size) { name_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Scalar.name) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& FunctionSignature_Scalar::name() const { - // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.name) return name_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* FunctionSignature_Scalar::mutable_name() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Scalar.name) + // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.name) return &name_; } -// .io.substrait.FunctionSignature.Description description = 4; +// .substrait.FunctionSignature.Description description = 4; inline bool FunctionSignature_Scalar::_internal_has_description() const { return this != internal_default_instance() && description_ != nullptr; } @@ -2865,17 +2862,17 @@ inline void FunctionSignature_Scalar::clear_description() { } description_ = nullptr; } -inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Scalar::_internal_description() const { - const ::io::substrait::FunctionSignature_Description* p = description_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_FunctionSignature_Description_default_instance_); +inline const ::substrait::FunctionSignature_Description& FunctionSignature_Scalar::_internal_description() const { + const ::substrait::FunctionSignature_Description* p = description_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_FunctionSignature_Description_default_instance_); } -inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Scalar::description() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.description) +inline const ::substrait::FunctionSignature_Description& FunctionSignature_Scalar::description() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.description) return _internal_description(); } inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_description( - ::io::substrait::FunctionSignature_Description* description) { + ::substrait::FunctionSignature_Description* description) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); } @@ -2885,37 +2882,37 @@ inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_description( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Scalar.description) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.description) } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Scalar::release_description() { +inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::release_description() { - ::io::substrait::FunctionSignature_Description* temp = description_; + ::substrait::FunctionSignature_Description* temp = description_; description_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Scalar::unsafe_arena_release_description() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Scalar.description) +inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.description) - ::io::substrait::FunctionSignature_Description* temp = description_; + ::substrait::FunctionSignature_Description* temp = description_; description_ = nullptr; return temp; } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Scalar::_internal_mutable_description() { +inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::_internal_mutable_description() { if (description_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::FunctionSignature_Description>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArena()); description_ = p; } return description_; } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Scalar::mutable_description() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.description) +inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::mutable_description() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.description) return _internal_mutable_description(); } -inline void FunctionSignature_Scalar::set_allocated_description(::io::substrait::FunctionSignature_Description* description) { +inline void FunctionSignature_Scalar::set_allocated_description(::substrait::FunctionSignature_Description* description) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete description_; @@ -2932,7 +2929,7 @@ inline void FunctionSignature_Scalar::set_allocated_description(::io::substrait: } description_ = description; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Scalar.description) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.description) } // bool deterministic = 7; @@ -2943,7 +2940,7 @@ inline bool FunctionSignature_Scalar::_internal_deterministic() const { return deterministic_; } inline bool FunctionSignature_Scalar::deterministic() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.deterministic) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.deterministic) return _internal_deterministic(); } inline void FunctionSignature_Scalar::_internal_set_deterministic(bool value) { @@ -2952,7 +2949,7 @@ inline void FunctionSignature_Scalar::_internal_set_deterministic(bool value) { } inline void FunctionSignature_Scalar::set_deterministic(bool value) { _internal_set_deterministic(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Scalar.deterministic) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.deterministic) } // bool session_dependent = 8; @@ -2963,7 +2960,7 @@ inline bool FunctionSignature_Scalar::_internal_session_dependent() const { return session_dependent_; } inline bool FunctionSignature_Scalar::session_dependent() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.session_dependent) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.session_dependent) return _internal_session_dependent(); } inline void FunctionSignature_Scalar::_internal_set_session_dependent(bool value) { @@ -2972,27 +2969,27 @@ inline void FunctionSignature_Scalar::_internal_set_session_dependent(bool value } inline void FunctionSignature_Scalar::set_session_dependent(bool value) { _internal_set_session_dependent(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Scalar.session_dependent) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.session_dependent) } -// .io.substrait.DerivationExpression output_type = 9; +// .substrait.DerivationExpression output_type = 9; inline bool FunctionSignature_Scalar::_internal_has_output_type() const { return this != internal_default_instance() && output_type_ != nullptr; } inline bool FunctionSignature_Scalar::has_output_type() const { return _internal_has_output_type(); } -inline const ::io::substrait::DerivationExpression& FunctionSignature_Scalar::_internal_output_type() const { - const ::io::substrait::DerivationExpression* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& FunctionSignature_Scalar::_internal_output_type() const { + const ::substrait::DerivationExpression* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& FunctionSignature_Scalar::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.output_type) +inline const ::substrait::DerivationExpression& FunctionSignature_Scalar::output_type() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.output_type) return _internal_output_type(); } inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_output_type( - ::io::substrait::DerivationExpression* output_type) { + ::substrait::DerivationExpression* output_type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } @@ -3002,37 +2999,37 @@ inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_output_type( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Scalar.output_type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.output_type) } -inline ::io::substrait::DerivationExpression* FunctionSignature_Scalar::release_output_type() { +inline ::substrait::DerivationExpression* FunctionSignature_Scalar::release_output_type() { - ::io::substrait::DerivationExpression* temp = output_type_; + ::substrait::DerivationExpression* temp = output_type_; output_type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Scalar::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Scalar.output_type) +inline ::substrait::DerivationExpression* FunctionSignature_Scalar::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.output_type) - ::io::substrait::DerivationExpression* temp = output_type_; + ::substrait::DerivationExpression* temp = output_type_; output_type_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Scalar::_internal_mutable_output_type() { +inline ::substrait::DerivationExpression* FunctionSignature_Scalar::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); output_type_ = p; } return output_type_; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Scalar::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.output_type) +inline ::substrait::DerivationExpression* FunctionSignature_Scalar::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.output_type) return _internal_mutable_output_type(); } -inline void FunctionSignature_Scalar::set_allocated_output_type(::io::substrait::DerivationExpression* output_type) { +inline void FunctionSignature_Scalar::set_allocated_output_type(::substrait::DerivationExpression* output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); @@ -3049,10 +3046,10 @@ inline void FunctionSignature_Scalar::set_allocated_output_type(::io::substrait: } output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Scalar.output_type) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.output_type) } -// .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; +// .substrait.FunctionSignature.FinalArgVariadic variadic = 10; inline bool FunctionSignature_Scalar::_internal_has_variadic() const { return final_variable_behavior_case() == kVariadic; } @@ -3070,11 +3067,11 @@ inline void FunctionSignature_Scalar::clear_variadic() { clear_has_final_variable_behavior(); } } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::release_variadic() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Scalar.variadic) +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::release_variadic() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.variadic) if (_internal_has_variadic()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -3084,48 +3081,48 @@ inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Sc return nullptr; } } -inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::_internal_variadic() const { +inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::_internal_variadic() const { return _internal_has_variadic() ? *final_variable_behavior_.variadic_ - : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgVariadic&>(::io::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); + : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); } -inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::variadic() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.variadic) +inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::variadic() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.variadic) return _internal_variadic(); } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::unsafe_arena_release_variadic() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Scalar.variadic) +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::unsafe_arena_release_variadic() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Scalar.variadic) if (_internal_has_variadic()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; final_variable_behavior_.variadic_ = nullptr; return temp; } else { return nullptr; } } -inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { +inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { clear_final_variable_behavior(); if (variadic) { set_has_variadic(); final_variable_behavior_.variadic_ = variadic; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Scalar.variadic) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.variadic) } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::_internal_mutable_variadic() { +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::_internal_mutable_variadic() { if (!_internal_has_variadic()) { clear_final_variable_behavior(); set_has_variadic(); - final_variable_behavior_.variadic_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); + final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); } return final_variable_behavior_.variadic_; } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::mutable_variadic() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.variadic) +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::mutable_variadic() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.variadic) return _internal_mutable_variadic(); } -// .io.substrait.FunctionSignature.FinalArgNormal normal = 11; +// .substrait.FunctionSignature.FinalArgNormal normal = 11; inline bool FunctionSignature_Scalar::_internal_has_normal() const { return final_variable_behavior_case() == kNormal; } @@ -3143,11 +3140,11 @@ inline void FunctionSignature_Scalar::clear_normal() { clear_has_final_variable_behavior(); } } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::release_normal() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Scalar.normal) +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::release_normal() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.normal) if (_internal_has_normal()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -3157,48 +3154,48 @@ inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scal return nullptr; } } -inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::_internal_normal() const { +inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::_internal_normal() const { return _internal_has_normal() ? *final_variable_behavior_.normal_ - : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgNormal&>(::io::substrait::_FunctionSignature_FinalArgNormal_default_instance_); + : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_); } -inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::normal() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.normal) +inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::normal() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.normal) return _internal_normal(); } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::unsafe_arena_release_normal() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Scalar.normal) +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::unsafe_arena_release_normal() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Scalar.normal) if (_internal_has_normal()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; final_variable_behavior_.normal_ = nullptr; return temp; } else { return nullptr; } } -inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { +inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { clear_final_variable_behavior(); if (normal) { set_has_normal(); final_variable_behavior_.normal_ = normal; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Scalar.normal) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.normal) } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::_internal_mutable_normal() { +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::_internal_mutable_normal() { if (!_internal_has_normal()) { clear_final_variable_behavior(); set_has_normal(); - final_variable_behavior_.normal_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgNormal >(GetArena()); + final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArena()); } return final_variable_behavior_.normal_; } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::mutable_normal() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.normal) +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::mutable_normal() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.normal) return _internal_mutable_normal(); } -// repeated .io.substrait.FunctionSignature.Implementation implementations = 12; +// repeated .substrait.FunctionSignature.Implementation implementations = 12; inline int FunctionSignature_Scalar::_internal_implementations_size() const { return implementations_.size(); } @@ -3208,32 +3205,32 @@ inline int FunctionSignature_Scalar::implementations_size() const { inline void FunctionSignature_Scalar::clear_implementations() { implementations_.Clear(); } -inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::mutable_implementations(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Scalar.implementations) +inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::mutable_implementations(int index) { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.implementations) return implementations_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* FunctionSignature_Scalar::mutable_implementations() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Scalar.implementations) + // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.implementations) return &implementations_; } -inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::_internal_implementations(int index) const { +inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::_internal_implementations(int index) const { return implementations_.Get(index); } -inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::implementations(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Scalar.implementations) +inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::implementations(int index) const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.implementations) return _internal_implementations(index); } -inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::_internal_add_implementations() { +inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::_internal_add_implementations() { return implementations_.Add(); } -inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::add_implementations() { - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Scalar.implementations) +inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::add_implementations() { + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.implementations) return _internal_add_implementations(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& FunctionSignature_Scalar::implementations() const { - // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Scalar.implementations) + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.implementations) return implementations_; } @@ -3250,7 +3247,7 @@ inline FunctionSignature_Scalar::FinalVariableBehaviorCase FunctionSignature_Sca // FunctionSignature_Aggregate -// repeated .io.substrait.FunctionSignature.Argument arguments = 2; +// repeated .substrait.FunctionSignature.Argument arguments = 2; inline int FunctionSignature_Aggregate::_internal_arguments_size() const { return arguments_.size(); } @@ -3260,32 +3257,32 @@ inline int FunctionSignature_Aggregate::arguments_size() const { inline void FunctionSignature_Aggregate::clear_arguments() { arguments_.Clear(); } -inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::mutable_arguments(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.arguments) +inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::mutable_arguments(int index) { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.arguments) return arguments_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* FunctionSignature_Aggregate::mutable_arguments() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Aggregate.arguments) + // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Aggregate.arguments) return &arguments_; } -inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::_internal_arguments(int index) const { +inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::_internal_arguments(int index) const { return arguments_.Get(index); } -inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::arguments(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.arguments) +inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::arguments(int index) const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.arguments) return _internal_arguments(index); } -inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::_internal_add_arguments() { +inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::_internal_add_arguments() { return arguments_.Add(); } -inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::add_arguments() { - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Aggregate.arguments) +inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::add_arguments() { + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Aggregate.arguments) return _internal_add_arguments(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& FunctionSignature_Aggregate::arguments() const { - // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Aggregate.arguments) + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Aggregate.arguments) return arguments_; } @@ -3294,7 +3291,7 @@ inline void FunctionSignature_Aggregate::clear_name() { name_.ClearToEmpty(); } inline const std::string& FunctionSignature_Aggregate::name() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.name) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.name) return _internal_name(); } template @@ -3302,10 +3299,10 @@ PROTOBUF_ALWAYS_INLINE inline void FunctionSignature_Aggregate::set_name(ArgT0&& arg0, ArgT... args) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.name) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.name) } inline std::string* FunctionSignature_Aggregate::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.name) + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.name) return _internal_mutable_name(); } inline const std::string& FunctionSignature_Aggregate::_internal_name() const { @@ -3320,7 +3317,7 @@ inline std::string* FunctionSignature_Aggregate::_internal_mutable_name() { return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* FunctionSignature_Aggregate::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.name) + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.name) return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void FunctionSignature_Aggregate::set_allocated_name(std::string* name) { @@ -3331,10 +3328,10 @@ inline void FunctionSignature_Aggregate::set_allocated_name(std::string* name) { } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.name) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.name) } -// .io.substrait.FunctionSignature.Description description = 4; +// .substrait.FunctionSignature.Description description = 4; inline bool FunctionSignature_Aggregate::_internal_has_description() const { return this != internal_default_instance() && description_ != nullptr; } @@ -3347,17 +3344,17 @@ inline void FunctionSignature_Aggregate::clear_description() { } description_ = nullptr; } -inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::_internal_description() const { - const ::io::substrait::FunctionSignature_Description* p = description_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_FunctionSignature_Description_default_instance_); +inline const ::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::_internal_description() const { + const ::substrait::FunctionSignature_Description* p = description_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_FunctionSignature_Description_default_instance_); } -inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::description() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.description) +inline const ::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::description() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.description) return _internal_description(); } inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_description( - ::io::substrait::FunctionSignature_Description* description) { + ::substrait::FunctionSignature_Description* description) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); } @@ -3367,37 +3364,37 @@ inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_description( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.description) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.description) } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::release_description() { +inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::release_description() { - ::io::substrait::FunctionSignature_Description* temp = description_; + ::substrait::FunctionSignature_Description* temp = description_; description_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::unsafe_arena_release_description() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.description) +inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.description) - ::io::substrait::FunctionSignature_Description* temp = description_; + ::substrait::FunctionSignature_Description* temp = description_; description_ = nullptr; return temp; } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::_internal_mutable_description() { +inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::_internal_mutable_description() { if (description_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::FunctionSignature_Description>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArena()); description_ = p; } return description_; } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::mutable_description() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.description) +inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::mutable_description() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.description) return _internal_mutable_description(); } -inline void FunctionSignature_Aggregate::set_allocated_description(::io::substrait::FunctionSignature_Description* description) { +inline void FunctionSignature_Aggregate::set_allocated_description(::substrait::FunctionSignature_Description* description) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete description_; @@ -3414,7 +3411,7 @@ inline void FunctionSignature_Aggregate::set_allocated_description(::io::substra } description_ = description; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.description) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.description) } // bool deterministic = 7; @@ -3425,7 +3422,7 @@ inline bool FunctionSignature_Aggregate::_internal_deterministic() const { return deterministic_; } inline bool FunctionSignature_Aggregate::deterministic() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.deterministic) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.deterministic) return _internal_deterministic(); } inline void FunctionSignature_Aggregate::_internal_set_deterministic(bool value) { @@ -3434,7 +3431,7 @@ inline void FunctionSignature_Aggregate::_internal_set_deterministic(bool value) } inline void FunctionSignature_Aggregate::set_deterministic(bool value) { _internal_set_deterministic(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.deterministic) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.deterministic) } // bool session_dependent = 8; @@ -3445,7 +3442,7 @@ inline bool FunctionSignature_Aggregate::_internal_session_dependent() const { return session_dependent_; } inline bool FunctionSignature_Aggregate::session_dependent() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.session_dependent) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.session_dependent) return _internal_session_dependent(); } inline void FunctionSignature_Aggregate::_internal_set_session_dependent(bool value) { @@ -3454,27 +3451,27 @@ inline void FunctionSignature_Aggregate::_internal_set_session_dependent(bool va } inline void FunctionSignature_Aggregate::set_session_dependent(bool value) { _internal_set_session_dependent(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.session_dependent) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.session_dependent) } -// .io.substrait.DerivationExpression output_type = 9; +// .substrait.DerivationExpression output_type = 9; inline bool FunctionSignature_Aggregate::_internal_has_output_type() const { return this != internal_default_instance() && output_type_ != nullptr; } inline bool FunctionSignature_Aggregate::has_output_type() const { return _internal_has_output_type(); } -inline const ::io::substrait::DerivationExpression& FunctionSignature_Aggregate::_internal_output_type() const { - const ::io::substrait::DerivationExpression* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& FunctionSignature_Aggregate::_internal_output_type() const { + const ::substrait::DerivationExpression* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& FunctionSignature_Aggregate::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.output_type) +inline const ::substrait::DerivationExpression& FunctionSignature_Aggregate::output_type() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.output_type) return _internal_output_type(); } inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_output_type( - ::io::substrait::DerivationExpression* output_type) { + ::substrait::DerivationExpression* output_type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } @@ -3484,37 +3481,37 @@ inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_output_type( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.output_type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.output_type) } -inline ::io::substrait::DerivationExpression* FunctionSignature_Aggregate::release_output_type() { +inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::release_output_type() { - ::io::substrait::DerivationExpression* temp = output_type_; + ::substrait::DerivationExpression* temp = output_type_; output_type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Aggregate::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.output_type) +inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.output_type) - ::io::substrait::DerivationExpression* temp = output_type_; + ::substrait::DerivationExpression* temp = output_type_; output_type_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Aggregate::_internal_mutable_output_type() { +inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); output_type_ = p; } return output_type_; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Aggregate::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.output_type) +inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.output_type) return _internal_mutable_output_type(); } -inline void FunctionSignature_Aggregate::set_allocated_output_type(::io::substrait::DerivationExpression* output_type) { +inline void FunctionSignature_Aggregate::set_allocated_output_type(::substrait::DerivationExpression* output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); @@ -3531,10 +3528,10 @@ inline void FunctionSignature_Aggregate::set_allocated_output_type(::io::substra } output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.output_type) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.output_type) } -// .io.substrait.FunctionSignature.FinalArgVariadic variadic = 10; +// .substrait.FunctionSignature.FinalArgVariadic variadic = 10; inline bool FunctionSignature_Aggregate::_internal_has_variadic() const { return final_variable_behavior_case() == kVariadic; } @@ -3552,11 +3549,11 @@ inline void FunctionSignature_Aggregate::clear_variadic() { clear_has_final_variable_behavior(); } } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::release_variadic() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.variadic) +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::release_variadic() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.variadic) if (_internal_has_variadic()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -3566,48 +3563,48 @@ inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Ag return nullptr; } } -inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::_internal_variadic() const { +inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::_internal_variadic() const { return _internal_has_variadic() ? *final_variable_behavior_.variadic_ - : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgVariadic&>(::io::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); + : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); } -inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::variadic() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.variadic) +inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::variadic() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.variadic) return _internal_variadic(); } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::unsafe_arena_release_variadic() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Aggregate.variadic) +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::unsafe_arena_release_variadic() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Aggregate.variadic) if (_internal_has_variadic()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; final_variable_behavior_.variadic_ = nullptr; return temp; } else { return nullptr; } } -inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { +inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { clear_final_variable_behavior(); if (variadic) { set_has_variadic(); final_variable_behavior_.variadic_ = variadic; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.variadic) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.variadic) } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::_internal_mutable_variadic() { +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::_internal_mutable_variadic() { if (!_internal_has_variadic()) { clear_final_variable_behavior(); set_has_variadic(); - final_variable_behavior_.variadic_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); + final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); } return final_variable_behavior_.variadic_; } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::mutable_variadic() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.variadic) +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::mutable_variadic() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.variadic) return _internal_mutable_variadic(); } -// .io.substrait.FunctionSignature.FinalArgNormal normal = 11; +// .substrait.FunctionSignature.FinalArgNormal normal = 11; inline bool FunctionSignature_Aggregate::_internal_has_normal() const { return final_variable_behavior_case() == kNormal; } @@ -3625,11 +3622,11 @@ inline void FunctionSignature_Aggregate::clear_normal() { clear_has_final_variable_behavior(); } } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::release_normal() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.normal) +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::release_normal() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.normal) if (_internal_has_normal()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -3639,44 +3636,44 @@ inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggr return nullptr; } } -inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::_internal_normal() const { +inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::_internal_normal() const { return _internal_has_normal() ? *final_variable_behavior_.normal_ - : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgNormal&>(::io::substrait::_FunctionSignature_FinalArgNormal_default_instance_); + : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_); } -inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::normal() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.normal) +inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::normal() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.normal) return _internal_normal(); } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::unsafe_arena_release_normal() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Aggregate.normal) +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::unsafe_arena_release_normal() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Aggregate.normal) if (_internal_has_normal()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; final_variable_behavior_.normal_ = nullptr; return temp; } else { return nullptr; } } -inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { +inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { clear_final_variable_behavior(); if (normal) { set_has_normal(); final_variable_behavior_.normal_ = normal; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.normal) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.normal) } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::_internal_mutable_normal() { +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::_internal_mutable_normal() { if (!_internal_has_normal()) { clear_final_variable_behavior(); set_has_normal(); - final_variable_behavior_.normal_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgNormal >(GetArena()); + final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArena()); } return final_variable_behavior_.normal_; } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::mutable_normal() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.normal) +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::mutable_normal() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.normal) return _internal_mutable_normal(); } @@ -3688,7 +3685,7 @@ inline bool FunctionSignature_Aggregate::_internal_ordered() const { return ordered_; } inline bool FunctionSignature_Aggregate::ordered() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.ordered) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.ordered) return _internal_ordered(); } inline void FunctionSignature_Aggregate::_internal_set_ordered(bool value) { @@ -3697,7 +3694,7 @@ inline void FunctionSignature_Aggregate::_internal_set_ordered(bool value) { } inline void FunctionSignature_Aggregate::set_ordered(bool value) { _internal_set_ordered(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.ordered) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.ordered) } // uint64 max_set = 12; @@ -3708,7 +3705,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Aggregate::_internal_ma return max_set_; } inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Aggregate::max_set() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.max_set) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.max_set) return _internal_max_set(); } inline void FunctionSignature_Aggregate::_internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { @@ -3717,27 +3714,27 @@ inline void FunctionSignature_Aggregate::_internal_set_max_set(::PROTOBUF_NAMESP } inline void FunctionSignature_Aggregate::set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { _internal_set_max_set(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Aggregate.max_set) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.max_set) } -// .io.substrait.Type intermediate_type = 13; +// .substrait.Type intermediate_type = 13; inline bool FunctionSignature_Aggregate::_internal_has_intermediate_type() const { return this != internal_default_instance() && intermediate_type_ != nullptr; } inline bool FunctionSignature_Aggregate::has_intermediate_type() const { return _internal_has_intermediate_type(); } -inline const ::io::substrait::Type& FunctionSignature_Aggregate::_internal_intermediate_type() const { - const ::io::substrait::Type* p = intermediate_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline const ::substrait::Type& FunctionSignature_Aggregate::_internal_intermediate_type() const { + const ::substrait::Type* p = intermediate_type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Type_default_instance_); } -inline const ::io::substrait::Type& FunctionSignature_Aggregate::intermediate_type() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.intermediate_type) +inline const ::substrait::Type& FunctionSignature_Aggregate::intermediate_type() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.intermediate_type) return _internal_intermediate_type(); } inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_intermediate_type( - ::io::substrait::Type* intermediate_type) { + ::substrait::Type* intermediate_type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); } @@ -3747,37 +3744,37 @@ inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_intermediate } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Aggregate.intermediate_type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.intermediate_type) } -inline ::io::substrait::Type* FunctionSignature_Aggregate::release_intermediate_type() { +inline ::substrait::Type* FunctionSignature_Aggregate::release_intermediate_type() { - ::io::substrait::Type* temp = intermediate_type_; + ::substrait::Type* temp = intermediate_type_; intermediate_type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type* FunctionSignature_Aggregate::unsafe_arena_release_intermediate_type() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Aggregate.intermediate_type) +inline ::substrait::Type* FunctionSignature_Aggregate::unsafe_arena_release_intermediate_type() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.intermediate_type) - ::io::substrait::Type* temp = intermediate_type_; + ::substrait::Type* temp = intermediate_type_; intermediate_type_ = nullptr; return temp; } -inline ::io::substrait::Type* FunctionSignature_Aggregate::_internal_mutable_intermediate_type() { +inline ::substrait::Type* FunctionSignature_Aggregate::_internal_mutable_intermediate_type() { if (intermediate_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); intermediate_type_ = p; } return intermediate_type_; } -inline ::io::substrait::Type* FunctionSignature_Aggregate::mutable_intermediate_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.intermediate_type) +inline ::substrait::Type* FunctionSignature_Aggregate::mutable_intermediate_type() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.intermediate_type) return _internal_mutable_intermediate_type(); } -inline void FunctionSignature_Aggregate::set_allocated_intermediate_type(::io::substrait::Type* intermediate_type) { +inline void FunctionSignature_Aggregate::set_allocated_intermediate_type(::substrait::Type* intermediate_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); @@ -3794,10 +3791,10 @@ inline void FunctionSignature_Aggregate::set_allocated_intermediate_type(::io::s } intermediate_type_ = intermediate_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Aggregate.intermediate_type) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.intermediate_type) } -// repeated .io.substrait.FunctionSignature.Implementation implementations = 15; +// repeated .substrait.FunctionSignature.Implementation implementations = 15; inline int FunctionSignature_Aggregate::_internal_implementations_size() const { return implementations_.size(); } @@ -3807,32 +3804,32 @@ inline int FunctionSignature_Aggregate::implementations_size() const { inline void FunctionSignature_Aggregate::clear_implementations() { implementations_.Clear(); } -inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::mutable_implementations(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Aggregate.implementations) +inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::mutable_implementations(int index) { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.implementations) return implementations_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* FunctionSignature_Aggregate::mutable_implementations() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Aggregate.implementations) + // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Aggregate.implementations) return &implementations_; } -inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::_internal_implementations(int index) const { +inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::_internal_implementations(int index) const { return implementations_.Get(index); } -inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::implementations(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Aggregate.implementations) +inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::implementations(int index) const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.implementations) return _internal_implementations(index); } -inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::_internal_add_implementations() { +inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::_internal_add_implementations() { return implementations_.Add(); } -inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::add_implementations() { - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Aggregate.implementations) +inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::add_implementations() { + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Aggregate.implementations) return _internal_add_implementations(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& FunctionSignature_Aggregate::implementations() const { - // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Aggregate.implementations) + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Aggregate.implementations) return implementations_; } @@ -3849,7 +3846,7 @@ inline FunctionSignature_Aggregate::FinalVariableBehaviorCase FunctionSignature_ // FunctionSignature_Window -// repeated .io.substrait.FunctionSignature.Argument arguments = 2; +// repeated .substrait.FunctionSignature.Argument arguments = 2; inline int FunctionSignature_Window::_internal_arguments_size() const { return arguments_.size(); } @@ -3859,32 +3856,32 @@ inline int FunctionSignature_Window::arguments_size() const { inline void FunctionSignature_Window::clear_arguments() { arguments_.Clear(); } -inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Window::mutable_arguments(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.arguments) +inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::mutable_arguments(int index) { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.arguments) return arguments_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* FunctionSignature_Window::mutable_arguments() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Window.arguments) + // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.arguments) return &arguments_; } -inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Window::_internal_arguments(int index) const { +inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Window::_internal_arguments(int index) const { return arguments_.Get(index); } -inline const ::io::substrait::FunctionSignature_Argument& FunctionSignature_Window::arguments(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.arguments) +inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Window::arguments(int index) const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.arguments) return _internal_arguments(index); } -inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Window::_internal_add_arguments() { +inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::_internal_add_arguments() { return arguments_.Add(); } -inline ::io::substrait::FunctionSignature_Argument* FunctionSignature_Window::add_arguments() { - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Window.arguments) +inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::add_arguments() { + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.arguments) return _internal_add_arguments(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Argument >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& FunctionSignature_Window::arguments() const { - // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Window.arguments) + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.arguments) return arguments_; } @@ -3899,70 +3896,70 @@ inline void FunctionSignature_Window::clear_name() { name_.Clear(); } inline std::string* FunctionSignature_Window::add_name() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Window.name) return _internal_add_name(); } inline const std::string& FunctionSignature_Window::_internal_name(int index) const { return name_.Get(index); } inline const std::string& FunctionSignature_Window::name(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.name) return _internal_name(index); } inline std::string* FunctionSignature_Window::mutable_name(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.name) return name_.Mutable(index); } inline void FunctionSignature_Window::set_name(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name) name_.Mutable(index)->assign(value); } inline void FunctionSignature_Window::set_name(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name) name_.Mutable(index)->assign(std::move(value)); } inline void FunctionSignature_Window::set_name(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); name_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Window.name) } inline void FunctionSignature_Window::set_name(int index, const char* value, size_t size) { name_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Window.name) } inline std::string* FunctionSignature_Window::_internal_add_name() { return name_.Add(); } inline void FunctionSignature_Window::add_name(const std::string& value) { name_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.name) } inline void FunctionSignature_Window::add_name(std::string&& value) { name_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.name) } inline void FunctionSignature_Window::add_name(const char* value) { GOOGLE_DCHECK(value != nullptr); name_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Window.name) } inline void FunctionSignature_Window::add_name(const char* value, size_t size) { name_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Window.name) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& FunctionSignature_Window::name() const { - // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.name) return name_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* FunctionSignature_Window::mutable_name() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Window.name) + // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.name) return &name_; } -// .io.substrait.FunctionSignature.Description description = 4; +// .substrait.FunctionSignature.Description description = 4; inline bool FunctionSignature_Window::_internal_has_description() const { return this != internal_default_instance() && description_ != nullptr; } @@ -3975,17 +3972,17 @@ inline void FunctionSignature_Window::clear_description() { } description_ = nullptr; } -inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Window::_internal_description() const { - const ::io::substrait::FunctionSignature_Description* p = description_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_FunctionSignature_Description_default_instance_); +inline const ::substrait::FunctionSignature_Description& FunctionSignature_Window::_internal_description() const { + const ::substrait::FunctionSignature_Description* p = description_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_FunctionSignature_Description_default_instance_); } -inline const ::io::substrait::FunctionSignature_Description& FunctionSignature_Window::description() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.description) +inline const ::substrait::FunctionSignature_Description& FunctionSignature_Window::description() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.description) return _internal_description(); } inline void FunctionSignature_Window::unsafe_arena_set_allocated_description( - ::io::substrait::FunctionSignature_Description* description) { + ::substrait::FunctionSignature_Description* description) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); } @@ -3995,37 +3992,37 @@ inline void FunctionSignature_Window::unsafe_arena_set_allocated_description( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.description) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.description) } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Window::release_description() { +inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::release_description() { - ::io::substrait::FunctionSignature_Description* temp = description_; + ::substrait::FunctionSignature_Description* temp = description_; description_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Window::unsafe_arena_release_description() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.description) +inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::unsafe_arena_release_description() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.description) - ::io::substrait::FunctionSignature_Description* temp = description_; + ::substrait::FunctionSignature_Description* temp = description_; description_ = nullptr; return temp; } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Window::_internal_mutable_description() { +inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::_internal_mutable_description() { if (description_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::FunctionSignature_Description>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArena()); description_ = p; } return description_; } -inline ::io::substrait::FunctionSignature_Description* FunctionSignature_Window::mutable_description() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.description) +inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::mutable_description() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.description) return _internal_mutable_description(); } -inline void FunctionSignature_Window::set_allocated_description(::io::substrait::FunctionSignature_Description* description) { +inline void FunctionSignature_Window::set_allocated_description(::substrait::FunctionSignature_Description* description) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete description_; @@ -4042,7 +4039,7 @@ inline void FunctionSignature_Window::set_allocated_description(::io::substrait: } description_ = description; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.description) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.description) } // bool deterministic = 7; @@ -4053,7 +4050,7 @@ inline bool FunctionSignature_Window::_internal_deterministic() const { return deterministic_; } inline bool FunctionSignature_Window::deterministic() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.deterministic) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.deterministic) return _internal_deterministic(); } inline void FunctionSignature_Window::_internal_set_deterministic(bool value) { @@ -4062,7 +4059,7 @@ inline void FunctionSignature_Window::_internal_set_deterministic(bool value) { } inline void FunctionSignature_Window::set_deterministic(bool value) { _internal_set_deterministic(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.deterministic) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.deterministic) } // bool session_dependent = 8; @@ -4073,7 +4070,7 @@ inline bool FunctionSignature_Window::_internal_session_dependent() const { return session_dependent_; } inline bool FunctionSignature_Window::session_dependent() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.session_dependent) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.session_dependent) return _internal_session_dependent(); } inline void FunctionSignature_Window::_internal_set_session_dependent(bool value) { @@ -4082,27 +4079,27 @@ inline void FunctionSignature_Window::_internal_set_session_dependent(bool value } inline void FunctionSignature_Window::set_session_dependent(bool value) { _internal_set_session_dependent(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.session_dependent) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.session_dependent) } -// .io.substrait.DerivationExpression intermediate_type = 9; +// .substrait.DerivationExpression intermediate_type = 9; inline bool FunctionSignature_Window::_internal_has_intermediate_type() const { return this != internal_default_instance() && intermediate_type_ != nullptr; } inline bool FunctionSignature_Window::has_intermediate_type() const { return _internal_has_intermediate_type(); } -inline const ::io::substrait::DerivationExpression& FunctionSignature_Window::_internal_intermediate_type() const { - const ::io::substrait::DerivationExpression* p = intermediate_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& FunctionSignature_Window::_internal_intermediate_type() const { + const ::substrait::DerivationExpression* p = intermediate_type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& FunctionSignature_Window::intermediate_type() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.intermediate_type) +inline const ::substrait::DerivationExpression& FunctionSignature_Window::intermediate_type() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.intermediate_type) return _internal_intermediate_type(); } inline void FunctionSignature_Window::unsafe_arena_set_allocated_intermediate_type( - ::io::substrait::DerivationExpression* intermediate_type) { + ::substrait::DerivationExpression* intermediate_type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); } @@ -4112,37 +4109,37 @@ inline void FunctionSignature_Window::unsafe_arena_set_allocated_intermediate_ty } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.intermediate_type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.intermediate_type) } -inline ::io::substrait::DerivationExpression* FunctionSignature_Window::release_intermediate_type() { +inline ::substrait::DerivationExpression* FunctionSignature_Window::release_intermediate_type() { - ::io::substrait::DerivationExpression* temp = intermediate_type_; + ::substrait::DerivationExpression* temp = intermediate_type_; intermediate_type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_intermediate_type() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.intermediate_type) +inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_intermediate_type() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.intermediate_type) - ::io::substrait::DerivationExpression* temp = intermediate_type_; + ::substrait::DerivationExpression* temp = intermediate_type_; intermediate_type_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_intermediate_type() { +inline ::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_intermediate_type() { if (intermediate_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); intermediate_type_ = p; } return intermediate_type_; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Window::mutable_intermediate_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.intermediate_type) +inline ::substrait::DerivationExpression* FunctionSignature_Window::mutable_intermediate_type() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.intermediate_type) return _internal_mutable_intermediate_type(); } -inline void FunctionSignature_Window::set_allocated_intermediate_type(::io::substrait::DerivationExpression* intermediate_type) { +inline void FunctionSignature_Window::set_allocated_intermediate_type(::substrait::DerivationExpression* intermediate_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); @@ -4159,27 +4156,27 @@ inline void FunctionSignature_Window::set_allocated_intermediate_type(::io::subs } intermediate_type_ = intermediate_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.intermediate_type) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.intermediate_type) } -// .io.substrait.DerivationExpression output_type = 10; +// .substrait.DerivationExpression output_type = 10; inline bool FunctionSignature_Window::_internal_has_output_type() const { return this != internal_default_instance() && output_type_ != nullptr; } inline bool FunctionSignature_Window::has_output_type() const { return _internal_has_output_type(); } -inline const ::io::substrait::DerivationExpression& FunctionSignature_Window::_internal_output_type() const { - const ::io::substrait::DerivationExpression* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& FunctionSignature_Window::_internal_output_type() const { + const ::substrait::DerivationExpression* p = output_type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& FunctionSignature_Window::output_type() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.output_type) +inline const ::substrait::DerivationExpression& FunctionSignature_Window::output_type() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.output_type) return _internal_output_type(); } inline void FunctionSignature_Window::unsafe_arena_set_allocated_output_type( - ::io::substrait::DerivationExpression* output_type) { + ::substrait::DerivationExpression* output_type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } @@ -4189,37 +4186,37 @@ inline void FunctionSignature_Window::unsafe_arena_set_allocated_output_type( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.output_type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.output_type) } -inline ::io::substrait::DerivationExpression* FunctionSignature_Window::release_output_type() { +inline ::substrait::DerivationExpression* FunctionSignature_Window::release_output_type() { - ::io::substrait::DerivationExpression* temp = output_type_; + ::substrait::DerivationExpression* temp = output_type_; output_type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.output_type) +inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_output_type() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.output_type) - ::io::substrait::DerivationExpression* temp = output_type_; + ::substrait::DerivationExpression* temp = output_type_; output_type_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_output_type() { +inline ::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); output_type_ = p; } return output_type_; } -inline ::io::substrait::DerivationExpression* FunctionSignature_Window::mutable_output_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.output_type) +inline ::substrait::DerivationExpression* FunctionSignature_Window::mutable_output_type() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.output_type) return _internal_mutable_output_type(); } -inline void FunctionSignature_Window::set_allocated_output_type(::io::substrait::DerivationExpression* output_type) { +inline void FunctionSignature_Window::set_allocated_output_type(::substrait::DerivationExpression* output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); @@ -4236,10 +4233,10 @@ inline void FunctionSignature_Window::set_allocated_output_type(::io::substrait: } output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Window.output_type) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.output_type) } -// .io.substrait.FunctionSignature.FinalArgVariadic variadic = 16; +// .substrait.FunctionSignature.FinalArgVariadic variadic = 16; inline bool FunctionSignature_Window::_internal_has_variadic() const { return final_variable_behavior_case() == kVariadic; } @@ -4257,11 +4254,11 @@ inline void FunctionSignature_Window::clear_variadic() { clear_has_final_variable_behavior(); } } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::release_variadic() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.variadic) +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::release_variadic() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.variadic) if (_internal_has_variadic()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4271,48 +4268,48 @@ inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Wi return nullptr; } } -inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::_internal_variadic() const { +inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::_internal_variadic() const { return _internal_has_variadic() ? *final_variable_behavior_.variadic_ - : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgVariadic&>(::io::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); + : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); } -inline const ::io::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::variadic() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.variadic) +inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::variadic() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.variadic) return _internal_variadic(); } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::unsafe_arena_release_variadic() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Window.variadic) +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::unsafe_arena_release_variadic() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Window.variadic) if (_internal_has_variadic()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; + ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; final_variable_behavior_.variadic_ = nullptr; return temp; } else { return nullptr; } } -inline void FunctionSignature_Window::unsafe_arena_set_allocated_variadic(::io::substrait::FunctionSignature_FinalArgVariadic* variadic) { +inline void FunctionSignature_Window::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { clear_final_variable_behavior(); if (variadic) { set_has_variadic(); final_variable_behavior_.variadic_ = variadic; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.variadic) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.variadic) } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::_internal_mutable_variadic() { +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::_internal_mutable_variadic() { if (!_internal_has_variadic()) { clear_final_variable_behavior(); set_has_variadic(); - final_variable_behavior_.variadic_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); + final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); } return final_variable_behavior_.variadic_; } -inline ::io::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::mutable_variadic() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.variadic) +inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::mutable_variadic() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.variadic) return _internal_mutable_variadic(); } -// .io.substrait.FunctionSignature.FinalArgNormal normal = 17; +// .substrait.FunctionSignature.FinalArgNormal normal = 17; inline bool FunctionSignature_Window::_internal_has_normal() const { return final_variable_behavior_case() == kNormal; } @@ -4330,11 +4327,11 @@ inline void FunctionSignature_Window::clear_normal() { clear_has_final_variable_behavior(); } } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::release_normal() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Window.normal) +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::release_normal() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.normal) if (_internal_has_normal()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4344,44 +4341,44 @@ inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Wind return nullptr; } } -inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::_internal_normal() const { +inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::_internal_normal() const { return _internal_has_normal() ? *final_variable_behavior_.normal_ - : reinterpret_cast< ::io::substrait::FunctionSignature_FinalArgNormal&>(::io::substrait::_FunctionSignature_FinalArgNormal_default_instance_); + : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_); } -inline const ::io::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::normal() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.normal) +inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::normal() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.normal) return _internal_normal(); } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::unsafe_arena_release_normal() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Window.normal) +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::unsafe_arena_release_normal() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Window.normal) if (_internal_has_normal()) { clear_has_final_variable_behavior(); - ::io::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; + ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; final_variable_behavior_.normal_ = nullptr; return temp; } else { return nullptr; } } -inline void FunctionSignature_Window::unsafe_arena_set_allocated_normal(::io::substrait::FunctionSignature_FinalArgNormal* normal) { +inline void FunctionSignature_Window::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { clear_final_variable_behavior(); if (normal) { set_has_normal(); final_variable_behavior_.normal_ = normal; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Window.normal) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.normal) } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::_internal_mutable_normal() { +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::_internal_mutable_normal() { if (!_internal_has_normal()) { clear_final_variable_behavior(); set_has_normal(); - final_variable_behavior_.normal_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_FinalArgNormal >(GetArena()); + final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArena()); } return final_variable_behavior_.normal_; } -inline ::io::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::mutable_normal() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.normal) +inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::mutable_normal() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.normal) return _internal_mutable_normal(); } @@ -4393,7 +4390,7 @@ inline bool FunctionSignature_Window::_internal_ordered() const { return ordered_; } inline bool FunctionSignature_Window::ordered() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.ordered) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.ordered) return _internal_ordered(); } inline void FunctionSignature_Window::_internal_set_ordered(bool value) { @@ -4402,7 +4399,7 @@ inline void FunctionSignature_Window::_internal_set_ordered(bool value) { } inline void FunctionSignature_Window::set_ordered(bool value) { _internal_set_ordered(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.ordered) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.ordered) } // uint64 max_set = 12; @@ -4413,7 +4410,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Window::_internal_max_s return max_set_; } inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Window::max_set() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.max_set) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.max_set) return _internal_max_set(); } inline void FunctionSignature_Window::_internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { @@ -4422,30 +4419,30 @@ inline void FunctionSignature_Window::_internal_set_max_set(::PROTOBUF_NAMESPACE } inline void FunctionSignature_Window::set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { _internal_set_max_set(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.max_set) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.max_set) } -// .io.substrait.FunctionSignature.Window.WindowType window_type = 14; +// .substrait.FunctionSignature.Window.WindowType window_type = 14; inline void FunctionSignature_Window::clear_window_type() { window_type_ = 0; } -inline ::io::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::_internal_window_type() const { - return static_cast< ::io::substrait::FunctionSignature_Window_WindowType >(window_type_); +inline ::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::_internal_window_type() const { + return static_cast< ::substrait::FunctionSignature_Window_WindowType >(window_type_); } -inline ::io::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::window_type() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.window_type) +inline ::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::window_type() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.window_type) return _internal_window_type(); } -inline void FunctionSignature_Window::_internal_set_window_type(::io::substrait::FunctionSignature_Window_WindowType value) { +inline void FunctionSignature_Window::_internal_set_window_type(::substrait::FunctionSignature_Window_WindowType value) { window_type_ = value; } -inline void FunctionSignature_Window::set_window_type(::io::substrait::FunctionSignature_Window_WindowType value) { +inline void FunctionSignature_Window::set_window_type(::substrait::FunctionSignature_Window_WindowType value) { _internal_set_window_type(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Window.window_type) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.window_type) } -// repeated .io.substrait.FunctionSignature.Implementation implementations = 15; +// repeated .substrait.FunctionSignature.Implementation implementations = 15; inline int FunctionSignature_Window::_internal_implementations_size() const { return implementations_.size(); } @@ -4455,32 +4452,32 @@ inline int FunctionSignature_Window::implementations_size() const { inline void FunctionSignature_Window::clear_implementations() { implementations_.Clear(); } -inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Window::mutable_implementations(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Window.implementations) +inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::mutable_implementations(int index) { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.implementations) return implementations_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* FunctionSignature_Window::mutable_implementations() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Window.implementations) + // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.implementations) return &implementations_; } -inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Window::_internal_implementations(int index) const { +inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Window::_internal_implementations(int index) const { return implementations_.Get(index); } -inline const ::io::substrait::FunctionSignature_Implementation& FunctionSignature_Window::implementations(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Window.implementations) +inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Window::implementations(int index) const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.implementations) return _internal_implementations(index); } -inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Window::_internal_add_implementations() { +inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::_internal_add_implementations() { return implementations_.Add(); } -inline ::io::substrait::FunctionSignature_Implementation* FunctionSignature_Window::add_implementations() { - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Window.implementations) +inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::add_implementations() { + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.implementations) return _internal_add_implementations(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::FunctionSignature_Implementation >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& FunctionSignature_Window::implementations() const { - // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Window.implementations) + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.implementations) return implementations_; } @@ -4502,7 +4499,7 @@ inline void FunctionSignature_Description::clear_language() { language_.ClearToEmpty(); } inline const std::string& FunctionSignature_Description::language() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Description.language) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Description.language) return _internal_language(); } template @@ -4510,10 +4507,10 @@ PROTOBUF_ALWAYS_INLINE inline void FunctionSignature_Description::set_language(ArgT0&& arg0, ArgT... args) { language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Description.language) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Description.language) } inline std::string* FunctionSignature_Description::mutable_language() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Description.language) + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Description.language) return _internal_mutable_language(); } inline const std::string& FunctionSignature_Description::_internal_language() const { @@ -4528,7 +4525,7 @@ inline std::string* FunctionSignature_Description::_internal_mutable_language() return language_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* FunctionSignature_Description::release_language() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Description.language) + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Description.language) return language_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void FunctionSignature_Description::set_allocated_language(std::string* language) { @@ -4539,7 +4536,7 @@ inline void FunctionSignature_Description::set_allocated_language(std::string* l } language_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), language, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Description.language) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Description.language) } // string body = 2; @@ -4547,7 +4544,7 @@ inline void FunctionSignature_Description::clear_body() { body_.ClearToEmpty(); } inline const std::string& FunctionSignature_Description::body() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Description.body) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Description.body) return _internal_body(); } template @@ -4555,10 +4552,10 @@ PROTOBUF_ALWAYS_INLINE inline void FunctionSignature_Description::set_body(ArgT0&& arg0, ArgT... args) { body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Description.body) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Description.body) } inline std::string* FunctionSignature_Description::mutable_body() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Description.body) + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Description.body) return _internal_mutable_body(); } inline const std::string& FunctionSignature_Description::_internal_body() const { @@ -4573,7 +4570,7 @@ inline std::string* FunctionSignature_Description::_internal_mutable_body() { return body_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* FunctionSignature_Description::release_body() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Description.body) + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Description.body) return body_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void FunctionSignature_Description::set_allocated_body(std::string* body) { @@ -4584,31 +4581,31 @@ inline void FunctionSignature_Description::set_allocated_body(std::string* body) } body_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), body, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Description.body) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Description.body) } // ------------------------------------------------------------------- // FunctionSignature_Implementation -// .io.substrait.FunctionSignature.Implementation.Type type = 1; +// .substrait.FunctionSignature.Implementation.Type type = 1; inline void FunctionSignature_Implementation::clear_type() { type_ = 0; } -inline ::io::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::_internal_type() const { - return static_cast< ::io::substrait::FunctionSignature_Implementation_Type >(type_); +inline ::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::_internal_type() const { + return static_cast< ::substrait::FunctionSignature_Implementation_Type >(type_); } -inline ::io::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::type() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Implementation.type) +inline ::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::type() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Implementation.type) return _internal_type(); } -inline void FunctionSignature_Implementation::_internal_set_type(::io::substrait::FunctionSignature_Implementation_Type value) { +inline void FunctionSignature_Implementation::_internal_set_type(::substrait::FunctionSignature_Implementation_Type value) { type_ = value; } -inline void FunctionSignature_Implementation::set_type(::io::substrait::FunctionSignature_Implementation_Type value) { +inline void FunctionSignature_Implementation::set_type(::substrait::FunctionSignature_Implementation_Type value) { _internal_set_type(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Implementation.type) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Implementation.type) } // string uri = 2; @@ -4616,7 +4613,7 @@ inline void FunctionSignature_Implementation::clear_uri() { uri_.ClearToEmpty(); } inline const std::string& FunctionSignature_Implementation::uri() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Implementation.uri) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Implementation.uri) return _internal_uri(); } template @@ -4624,10 +4621,10 @@ PROTOBUF_ALWAYS_INLINE inline void FunctionSignature_Implementation::set_uri(ArgT0&& arg0, ArgT... args) { uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Implementation.uri) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Implementation.uri) } inline std::string* FunctionSignature_Implementation::mutable_uri() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Implementation.uri) + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Implementation.uri) return _internal_mutable_uri(); } inline const std::string& FunctionSignature_Implementation::_internal_uri() const { @@ -4642,7 +4639,7 @@ inline std::string* FunctionSignature_Implementation::_internal_mutable_uri() { return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* FunctionSignature_Implementation::release_uri() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Implementation.uri) + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Implementation.uri) return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void FunctionSignature_Implementation::set_allocated_uri(std::string* uri) { @@ -4653,31 +4650,31 @@ inline void FunctionSignature_Implementation::set_allocated_uri(std::string* uri } uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Implementation.uri) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Implementation.uri) } // ------------------------------------------------------------------- // FunctionSignature_Argument_ValueArgument -// .io.substrait.ParameterizedType type = 1; +// .substrait.ParameterizedType type = 1; inline bool FunctionSignature_Argument_ValueArgument::_internal_has_type() const { return this != internal_default_instance() && type_ != nullptr; } inline bool FunctionSignature_Argument_ValueArgument::has_type() const { return _internal_has_type(); } -inline const ::io::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::_internal_type() const { - const ::io::substrait::ParameterizedType* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_default_instance_); +inline const ::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::_internal_type() const { + const ::substrait::ParameterizedType* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_default_instance_); } -inline const ::io::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::type() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.ValueArgument.type) +inline const ::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::type() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.ValueArgument.type) return _internal_type(); } inline void FunctionSignature_Argument_ValueArgument::unsafe_arena_set_allocated_type( - ::io::substrait::ParameterizedType* type) { + ::substrait::ParameterizedType* type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } @@ -4687,37 +4684,37 @@ inline void FunctionSignature_Argument_ValueArgument::unsafe_arena_set_allocated } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Argument.ValueArgument.type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.ValueArgument.type) } -inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::release_type() { +inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::release_type() { - ::io::substrait::ParameterizedType* temp = type_; + ::substrait::ParameterizedType* temp = type_; type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.ValueArgument.type) +inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.ValueArgument.type) - ::io::substrait::ParameterizedType* temp = type_; + ::substrait::ParameterizedType* temp = type_; type_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::_internal_mutable_type() { +inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArena()); type_ = p; } return type_; } -inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::mutable_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.ValueArgument.type) +inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::mutable_type() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.ValueArgument.type) return _internal_mutable_type(); } -inline void FunctionSignature_Argument_ValueArgument::set_allocated_type(::io::substrait::ParameterizedType* type) { +inline void FunctionSignature_Argument_ValueArgument::set_allocated_type(::substrait::ParameterizedType* type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); @@ -4734,7 +4731,7 @@ inline void FunctionSignature_Argument_ValueArgument::set_allocated_type(::io::s } type_ = type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.ValueArgument.type) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.ValueArgument.type) } // bool constant = 2; @@ -4745,7 +4742,7 @@ inline bool FunctionSignature_Argument_ValueArgument::_internal_constant() const return constant_; } inline bool FunctionSignature_Argument_ValueArgument::constant() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.ValueArgument.constant) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.ValueArgument.constant) return _internal_constant(); } inline void FunctionSignature_Argument_ValueArgument::_internal_set_constant(bool value) { @@ -4754,31 +4751,31 @@ inline void FunctionSignature_Argument_ValueArgument::_internal_set_constant(boo } inline void FunctionSignature_Argument_ValueArgument::set_constant(bool value) { _internal_set_constant(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Argument.ValueArgument.constant) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.ValueArgument.constant) } // ------------------------------------------------------------------- // FunctionSignature_Argument_TypeArgument -// .io.substrait.ParameterizedType type = 1; +// .substrait.ParameterizedType type = 1; inline bool FunctionSignature_Argument_TypeArgument::_internal_has_type() const { return this != internal_default_instance() && type_ != nullptr; } inline bool FunctionSignature_Argument_TypeArgument::has_type() const { return _internal_has_type(); } -inline const ::io::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::_internal_type() const { - const ::io::substrait::ParameterizedType* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_default_instance_); +inline const ::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::_internal_type() const { + const ::substrait::ParameterizedType* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_default_instance_); } -inline const ::io::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::type() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.TypeArgument.type) +inline const ::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::type() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.TypeArgument.type) return _internal_type(); } inline void FunctionSignature_Argument_TypeArgument::unsafe_arena_set_allocated_type( - ::io::substrait::ParameterizedType* type) { + ::substrait::ParameterizedType* type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } @@ -4788,37 +4785,37 @@ inline void FunctionSignature_Argument_TypeArgument::unsafe_arena_set_allocated_ } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Argument.TypeArgument.type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.TypeArgument.type) } -inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::release_type() { +inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::release_type() { - ::io::substrait::ParameterizedType* temp = type_; + ::substrait::ParameterizedType* temp = type_; type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.TypeArgument.type) +inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.TypeArgument.type) - ::io::substrait::ParameterizedType* temp = type_; + ::substrait::ParameterizedType* temp = type_; type_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::_internal_mutable_type() { +inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArena()); type_ = p; } return type_; } -inline ::io::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::mutable_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.TypeArgument.type) +inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::mutable_type() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.TypeArgument.type) return _internal_mutable_type(); } -inline void FunctionSignature_Argument_TypeArgument::set_allocated_type(::io::substrait::ParameterizedType* type) { +inline void FunctionSignature_Argument_TypeArgument::set_allocated_type(::substrait::ParameterizedType* type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); @@ -4835,7 +4832,7 @@ inline void FunctionSignature_Argument_TypeArgument::set_allocated_type(::io::su } type_ = type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.TypeArgument.type) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.TypeArgument.type) } // ------------------------------------------------------------------- @@ -4853,66 +4850,66 @@ inline void FunctionSignature_Argument_EnumArgument::clear_options() { options_.Clear(); } inline std::string* FunctionSignature_Argument_EnumArgument::add_options() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Argument.EnumArgument.options) return _internal_add_options(); } inline const std::string& FunctionSignature_Argument_EnumArgument::_internal_options(int index) const { return options_.Get(index); } inline const std::string& FunctionSignature_Argument_EnumArgument::options(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.EnumArgument.options) return _internal_options(index); } inline std::string* FunctionSignature_Argument_EnumArgument::mutable_options(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.EnumArgument.options) return options_.Mutable(index); } inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options) options_.Mutable(index)->assign(value); } inline void FunctionSignature_Argument_EnumArgument::set_options(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options) options_.Mutable(index)->assign(std::move(value)); } inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); options_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Argument.EnumArgument.options) } inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value, size_t size) { options_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Argument.EnumArgument.options) } inline std::string* FunctionSignature_Argument_EnumArgument::_internal_add_options() { return options_.Add(); } inline void FunctionSignature_Argument_EnumArgument::add_options(const std::string& value) { options_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Argument.EnumArgument.options) } inline void FunctionSignature_Argument_EnumArgument::add_options(std::string&& value) { options_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Argument.EnumArgument.options) } inline void FunctionSignature_Argument_EnumArgument::add_options(const char* value) { GOOGLE_DCHECK(value != nullptr); options_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Argument.EnumArgument.options) } inline void FunctionSignature_Argument_EnumArgument::add_options(const char* value, size_t size) { options_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Argument.EnumArgument.options) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& FunctionSignature_Argument_EnumArgument::options() const { - // @@protoc_insertion_point(field_list:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Argument.EnumArgument.options) return options_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* FunctionSignature_Argument_EnumArgument::mutable_options() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.FunctionSignature.Argument.EnumArgument.options) + // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Argument.EnumArgument.options) return &options_; } @@ -4924,7 +4921,7 @@ inline bool FunctionSignature_Argument_EnumArgument::_internal_optional() const return optional_; } inline bool FunctionSignature_Argument_EnumArgument::optional() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.EnumArgument.optional) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.EnumArgument.optional) return _internal_optional(); } inline void FunctionSignature_Argument_EnumArgument::_internal_set_optional(bool value) { @@ -4933,7 +4930,7 @@ inline void FunctionSignature_Argument_EnumArgument::_internal_set_optional(bool } inline void FunctionSignature_Argument_EnumArgument::set_optional(bool value) { _internal_set_optional(value); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Argument.EnumArgument.optional) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.optional) } // ------------------------------------------------------------------- @@ -4945,7 +4942,7 @@ inline void FunctionSignature_Argument::clear_name() { name_.ClearToEmpty(); } inline const std::string& FunctionSignature_Argument::name() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.name) + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.name) return _internal_name(); } template @@ -4953,10 +4950,10 @@ PROTOBUF_ALWAYS_INLINE inline void FunctionSignature_Argument::set_name(ArgT0&& arg0, ArgT... args) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.FunctionSignature.Argument.name) + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.name) } inline std::string* FunctionSignature_Argument::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.name) + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.name) return _internal_mutable_name(); } inline const std::string& FunctionSignature_Argument::_internal_name() const { @@ -4971,7 +4968,7 @@ inline std::string* FunctionSignature_Argument::_internal_mutable_name() { return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* FunctionSignature_Argument::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.name) + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.name) return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void FunctionSignature_Argument::set_allocated_name(std::string* name) { @@ -4982,10 +4979,10 @@ inline void FunctionSignature_Argument::set_allocated_name(std::string* name) { } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.FunctionSignature.Argument.name) + // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.name) } -// .io.substrait.FunctionSignature.Argument.ValueArgument value = 2; +// .substrait.FunctionSignature.Argument.ValueArgument value = 2; inline bool FunctionSignature_Argument::_internal_has_value() const { return argument_kind_case() == kValue; } @@ -5003,11 +5000,11 @@ inline void FunctionSignature_Argument::clear_value() { clear_has_argument_kind(); } } -inline ::io::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::release_value() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.value) +inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::release_value() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.value) if (_internal_has_value()) { clear_has_argument_kind(); - ::io::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_; + ::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5017,48 +5014,48 @@ inline ::io::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignat return nullptr; } } -inline const ::io::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::_internal_value() const { +inline const ::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::_internal_value() const { return _internal_has_value() ? *argument_kind_.value_ - : reinterpret_cast< ::io::substrait::FunctionSignature_Argument_ValueArgument&>(::io::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_); + : reinterpret_cast< ::substrait::FunctionSignature_Argument_ValueArgument&>(::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_); } -inline const ::io::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::value() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.value) +inline const ::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::value() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.value) return _internal_value(); } -inline ::io::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Argument.value) +inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.value) if (_internal_has_value()) { clear_has_argument_kind(); - ::io::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_; + ::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_; argument_kind_.value_ = nullptr; return temp; } else { return nullptr; } } -inline void FunctionSignature_Argument::unsafe_arena_set_allocated_value(::io::substrait::FunctionSignature_Argument_ValueArgument* value) { +inline void FunctionSignature_Argument::unsafe_arena_set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value) { clear_argument_kind(); if (value) { set_has_value(); argument_kind_.value_ = value; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Argument.value) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.value) } -inline ::io::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::_internal_mutable_value() { +inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::_internal_mutable_value() { if (!_internal_has_value()) { clear_argument_kind(); set_has_value(); - argument_kind_.value_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_ValueArgument >(GetArena()); + argument_kind_.value_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_ValueArgument >(GetArena()); } return argument_kind_.value_; } -inline ::io::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.value) +inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::mutable_value() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.value) return _internal_mutable_value(); } -// .io.substrait.FunctionSignature.Argument.TypeArgument type = 3; +// .substrait.FunctionSignature.Argument.TypeArgument type = 3; inline bool FunctionSignature_Argument::_internal_has_type() const { return argument_kind_case() == kType; } @@ -5076,11 +5073,11 @@ inline void FunctionSignature_Argument::clear_type() { clear_has_argument_kind(); } } -inline ::io::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::release_type() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.type) +inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::release_type() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.type) if (_internal_has_type()) { clear_has_argument_kind(); - ::io::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_; + ::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5090,48 +5087,48 @@ inline ::io::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignatu return nullptr; } } -inline const ::io::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::_internal_type() const { +inline const ::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::_internal_type() const { return _internal_has_type() ? *argument_kind_.type_ - : reinterpret_cast< ::io::substrait::FunctionSignature_Argument_TypeArgument&>(::io::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_); + : reinterpret_cast< ::substrait::FunctionSignature_Argument_TypeArgument&>(::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_); } -inline const ::io::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::type() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.type) +inline const ::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::type() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.type) return _internal_type(); } -inline ::io::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Argument.type) +inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.type) if (_internal_has_type()) { clear_has_argument_kind(); - ::io::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_; + ::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_; argument_kind_.type_ = nullptr; return temp; } else { return nullptr; } } -inline void FunctionSignature_Argument::unsafe_arena_set_allocated_type(::io::substrait::FunctionSignature_Argument_TypeArgument* type) { +inline void FunctionSignature_Argument::unsafe_arena_set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type) { clear_argument_kind(); if (type) { set_has_type(); argument_kind_.type_ = type; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Argument.type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.type) } -inline ::io::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::_internal_mutable_type() { +inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::_internal_mutable_type() { if (!_internal_has_type()) { clear_argument_kind(); set_has_type(); - argument_kind_.type_ = CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_TypeArgument >(GetArena()); + argument_kind_.type_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_TypeArgument >(GetArena()); } return argument_kind_.type_; } -inline ::io::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::mutable_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.type) +inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::mutable_type() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.type) return _internal_mutable_type(); } -// .io.substrait.FunctionSignature.Argument.EnumArgument enum = 4; +// .substrait.FunctionSignature.Argument.EnumArgument enum = 4; inline bool FunctionSignature_Argument::_internal_has_enum_() const { return argument_kind_case() == kEnum; } @@ -5149,11 +5146,11 @@ inline void FunctionSignature_Argument::clear_enum_() { clear_has_argument_kind(); } } -inline ::io::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::release_enum_() { - // @@protoc_insertion_point(field_release:io.substrait.FunctionSignature.Argument.enum) +inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::release_enum_() { + // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.enum) if (_internal_has_enum_()) { clear_has_argument_kind(); - ::io::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__; + ::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5163,44 +5160,44 @@ inline ::io::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignatu return nullptr; } } -inline const ::io::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::_internal_enum_() const { +inline const ::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::_internal_enum_() const { return _internal_has_enum_() ? *argument_kind_.enum__ - : reinterpret_cast< ::io::substrait::FunctionSignature_Argument_EnumArgument&>(::io::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_); + : reinterpret_cast< ::substrait::FunctionSignature_Argument_EnumArgument&>(::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_); } -inline const ::io::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::enum_() const { - // @@protoc_insertion_point(field_get:io.substrait.FunctionSignature.Argument.enum) +inline const ::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::enum_() const { + // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.enum) return _internal_enum_(); } -inline ::io::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::unsafe_arena_release_enum_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.FunctionSignature.Argument.enum) +inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::unsafe_arena_release_enum_() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.enum) if (_internal_has_enum_()) { clear_has_argument_kind(); - ::io::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__; + ::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__; argument_kind_.enum__ = nullptr; return temp; } else { return nullptr; } } -inline void FunctionSignature_Argument::unsafe_arena_set_allocated_enum_(::io::substrait::FunctionSignature_Argument_EnumArgument* enum_) { +inline void FunctionSignature_Argument::unsafe_arena_set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_) { clear_argument_kind(); if (enum_) { set_has_enum_(); argument_kind_.enum__ = enum_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FunctionSignature.Argument.enum) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.enum) } -inline ::io::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::_internal_mutable_enum_() { +inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::_internal_mutable_enum_() { if (!_internal_has_enum_()) { clear_argument_kind(); set_has_enum_(); - argument_kind_.enum__ = CreateMaybeMessage< ::io::substrait::FunctionSignature_Argument_EnumArgument >(GetArena()); + argument_kind_.enum__ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_EnumArgument >(GetArena()); } return argument_kind_.enum__; } -inline ::io::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::mutable_enum_() { - // @@protoc_insertion_point(field_mutable:io.substrait.FunctionSignature.Argument.enum) +inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::mutable_enum_() { + // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.enum) return _internal_mutable_enum_(); } @@ -5246,24 +5243,23 @@ inline FunctionSignature_Argument::ArgumentKindCase FunctionSignature_Argument:: // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template <> struct is_proto_enum< ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>() { - return ::io::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>() { + return ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(); } -template <> struct is_proto_enum< ::io::substrait::FunctionSignature_Window_WindowType> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::FunctionSignature_Window_WindowType> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::FunctionSignature_Window_WindowType>() { - return ::io::substrait::FunctionSignature_Window_WindowType_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_Window_WindowType>() { + return ::substrait::FunctionSignature_Window_WindowType_descriptor(); } -template <> struct is_proto_enum< ::io::substrait::FunctionSignature_Implementation_Type> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::FunctionSignature_Implementation_Type> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::FunctionSignature_Implementation_Type>() { - return ::io::substrait::FunctionSignature_Implementation_Type_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_Implementation_Type>() { + return ::substrait::FunctionSignature_Implementation_Type_descriptor(); } PROTOBUF_NAMESPACE_CLOSE @@ -5271,4 +5267,4 @@ PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_function_2eproto +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto diff --git a/cpp/src/generated/substrait/parameterized_types.pb.cc b/cpp/src/generated/substrait/parameterized_types.pb.cc index c3e21d41a7d..4f55cf851de 100644 --- a/cpp/src/generated/substrait/parameterized_types.pb.cc +++ b/cpp/src/generated/substrait/parameterized_types.pb.cc @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: parameterized_types.proto +// source: substrait/parameterized_types.proto -#include "parameterized_types.pb.h" +#include "substrait/parameterized_types.pb.h" #include @@ -16,7 +16,6 @@ #include PROTOBUF_PRAGMA_INIT_SEG -namespace io { namespace substrait { constexpr ParameterizedType_TypeParameter::ParameterizedType_TypeParameter( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) @@ -202,110 +201,109 @@ struct ParameterizedTypeDefaultTypeInternal { }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedTypeDefaultTypeInternal _ParameterizedType_default_instance_; } // namespace substrait -} // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_parameterized_5ftypes_2eproto[13]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_parameterized_5ftypes_2eproto = nullptr; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_parameterized_5ftypes_2eproto = nullptr; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[13]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fparameterized_5ftypes_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fparameterized_5ftypes_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_parameterized_5ftypes_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5ftypes_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_TypeParameter, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_TypeParameter, name_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_TypeParameter, bounds_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, name_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, bounds_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerParameter, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerParameter, name_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerParameter, range_start_inclusive_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerParameter, range_end_exclusive_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, name_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, range_start_inclusive_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, range_end_exclusive_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_NullableInteger, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_NullableInteger, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_NullableInteger, value_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_NullableInteger, value_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedChar, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, length_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedVarChar, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, length_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedFixedBinary, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, length_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, scale_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, precision_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedDecimal, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, scale_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, precision_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, types_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedStruct, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, types_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedNamedStruct, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedNamedStruct, names_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedNamedStruct, struct__), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, names_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, struct__), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedList, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, type_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, key_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, value_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_ParameterizedMap, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, key_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, value_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerOption, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerOption, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType_IntegerOption, integer_type_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, integer_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -332,141 +330,137 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_parameterized_5ftypes_2eproto: ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::ParameterizedType, kind_), + PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, kind_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::ParameterizedType_TypeParameter)}, - { 7, -1, sizeof(::io::substrait::ParameterizedType_IntegerParameter)}, - { 15, -1, sizeof(::io::substrait::ParameterizedType_NullableInteger)}, - { 21, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedFixedChar)}, - { 29, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedVarChar)}, - { 37, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedFixedBinary)}, - { 45, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedDecimal)}, - { 54, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedStruct)}, - { 62, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedNamedStruct)}, - { 69, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedList)}, - { 77, -1, sizeof(::io::substrait::ParameterizedType_ParameterizedMap)}, - { 86, -1, sizeof(::io::substrait::ParameterizedType_IntegerOption)}, - { 94, -1, sizeof(::io::substrait::ParameterizedType)}, + { 0, -1, sizeof(::substrait::ParameterizedType_TypeParameter)}, + { 7, -1, sizeof(::substrait::ParameterizedType_IntegerParameter)}, + { 15, -1, sizeof(::substrait::ParameterizedType_NullableInteger)}, + { 21, -1, sizeof(::substrait::ParameterizedType_ParameterizedFixedChar)}, + { 29, -1, sizeof(::substrait::ParameterizedType_ParameterizedVarChar)}, + { 37, -1, sizeof(::substrait::ParameterizedType_ParameterizedFixedBinary)}, + { 45, -1, sizeof(::substrait::ParameterizedType_ParameterizedDecimal)}, + { 54, -1, sizeof(::substrait::ParameterizedType_ParameterizedStruct)}, + { 62, -1, sizeof(::substrait::ParameterizedType_ParameterizedNamedStruct)}, + { 69, -1, sizeof(::substrait::ParameterizedType_ParameterizedList)}, + { 77, -1, sizeof(::substrait::ParameterizedType_ParameterizedMap)}, + { 86, -1, sizeof(::substrait::ParameterizedType_IntegerOption)}, + { 94, -1, sizeof(::substrait::ParameterizedType)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::_ParameterizedType_TypeParameter_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_IntegerParameter_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_NullableInteger_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedStruct_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedNamedStruct_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedList_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_ParameterizedMap_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_IntegerOption_default_instance_), - reinterpret_cast(&::io::substrait::_ParameterizedType_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_TypeParameter_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_IntegerParameter_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_NullableInteger_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedStruct_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedNamedStruct_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedList_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedMap_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_IntegerOption_default_instance_), + reinterpret_cast(&::substrait::_ParameterizedType_default_instance_), }; -const char descriptor_table_protodef_parameterized_5ftypes_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\031parameterized_types.proto\022\014io.substrai" - "t\032\ntype.proto\"\300\030\n\021ParameterizedType\022*\n\004b" - "ool\030\001 \001(\0132\032.io.substrait.Type.BooleanH\000\022" - "#\n\002i8\030\002 \001(\0132\025.io.substrait.Type.I8H\000\022%\n\003" - "i16\030\003 \001(\0132\026.io.substrait.Type.I16H\000\022%\n\003i" - "32\030\005 \001(\0132\026.io.substrait.Type.I32H\000\022%\n\003i6" - "4\030\007 \001(\0132\026.io.substrait.Type.I64H\000\022\'\n\004fp3" - "2\030\n \001(\0132\027.io.substrait.Type.FP32H\000\022\'\n\004fp" - "64\030\013 \001(\0132\027.io.substrait.Type.FP64H\000\022+\n\006s" - "tring\030\014 \001(\0132\031.io.substrait.Type.StringH\000" - "\022+\n\006binary\030\r \001(\0132\031.io.substrait.Type.Bin" - "aryH\000\0221\n\ttimestamp\030\016 \001(\0132\034.io.substrait." - "Type.TimestampH\000\022\'\n\004date\030\020 \001(\0132\027.io.subs" - "trait.Type.DateH\000\022\'\n\004time\030\021 \001(\0132\027.io.sub" - "strait.Type.TimeH\000\0228\n\rinterval_year\030\023 \001(" - "\0132\037.io.substrait.Type.IntervalYearH\000\0226\n\014" - "interval_day\030\024 \001(\0132\036.io.substrait.Type.I" - "ntervalDayH\000\0226\n\014timestamp_tz\030\035 \001(\0132\036.io." - "substrait.Type.TimestampTZH\000\022\'\n\004uuid\030 \001" - "(\0132\027.io.substrait.Type.UUIDH\000\022L\n\nfixed_c" - "har\030\025 \001(\01326.io.substrait.ParameterizedTy" - "pe.ParameterizedFixedCharH\000\022G\n\007varchar\030\026" - " \001(\01324.io.substrait.ParameterizedType.Pa" - "rameterizedVarCharH\000\022P\n\014fixed_binary\030\027 \001" - "(\01328.io.substrait.ParameterizedType.Para" - "meterizedFixedBinaryH\000\022G\n\007decimal\030\030 \001(\0132" - "4.io.substrait.ParameterizedType.Paramet" - "erizedDecimalH\000\022E\n\006struct\030\031 \001(\01323.io.sub" - "strait.ParameterizedType.ParameterizedSt" - "ructH\000\022A\n\004list\030\033 \001(\01321.io.substrait.Para" - "meterizedType.ParameterizedListH\000\022\?\n\003map" - "\030\034 \001(\01320.io.substrait.ParameterizedType." - "ParameterizedMapH\000\022\036\n\024user_defined_point" - "er\030\037 \001(\rH\000\022G\n\016type_parameter\030! \001(\0132-.io." - "substrait.ParameterizedType.TypeParamete" - "rH\000\032N\n\rTypeParameter\022\014\n\004name\030\001 \001(\t\022/\n\006bo" - "unds\030\002 \003(\0132\037.io.substrait.ParameterizedT" - "ype\032\276\001\n\020IntegerParameter\022\014\n\004name\030\001 \001(\t\022N" - "\n\025range_start_inclusive\030\002 \001(\0132/.io.subst" - "rait.ParameterizedType.NullableInteger\022L" - "\n\023range_end_exclusive\030\003 \001(\0132/.io.substra" - "it.ParameterizedType.NullableInteger\032 \n\017" - "NullableInteger\022\r\n\005value\030\001 \001(\003\032\247\001\n\026Param" - "eterizedFixedChar\022=\n\006length\030\001 \001(\0132-.io.s" - "ubstrait.ParameterizedType.IntegerOption" - "\022\031\n\021variation_pointer\030\002 \001(\r\0223\n\013nullabili" - "ty\030\003 \001(\0162\036.io.substrait.Type.Nullability" - "\032\245\001\n\024ParameterizedVarChar\022=\n\006length\030\001 \001(" - "\0132-.io.substrait.ParameterizedType.Integ" - "erOption\022\031\n\021variation_pointer\030\002 \001(\r\0223\n\013n" - "ullability\030\003 \001(\0162\036.io.substrait.Type.Nul" - "lability\032\251\001\n\030ParameterizedFixedBinary\022=\n" - "\006length\030\001 \001(\0132-.io.substrait.Parameteriz" - "edType.IntegerOption\022\031\n\021variation_pointe" - "r\030\002 \001(\r\0223\n\013nullability\030\003 \001(\0162\036.io.substr" - "ait.Type.Nullability\032\346\001\n\024ParameterizedDe" - "cimal\022<\n\005scale\030\001 \001(\0132-.io.substrait.Para" - "meterizedType.IntegerOption\022@\n\tprecision" - "\030\002 \001(\0132-.io.substrait.ParameterizedType." - "IntegerOption\022\031\n\021variation_pointer\030\003 \001(\r" - "\0223\n\013nullability\030\004 \001(\0162\036.io.substrait.Typ" - "e.Nullability\032\225\001\n\023ParameterizedStruct\022.\n" - "\005types\030\001 \003(\0132\037.io.substrait.Parameterize" - "dType\022\031\n\021variation_pointer\030\002 \001(\r\0223\n\013null" - "ability\030\003 \001(\0162\036.io.substrait.Type.Nullab" - "ility\032n\n\030ParameterizedNamedStruct\022\r\n\005nam" - "es\030\001 \003(\t\022C\n\006struct\030\002 \001(\01323.io.substrait." - "ParameterizedType.ParameterizedStruct\032\222\001" - "\n\021ParameterizedList\022-\n\004type\030\001 \001(\0132\037.io.s" - "ubstrait.ParameterizedType\022\031\n\021variation_" - "pointer\030\002 \001(\r\0223\n\013nullability\030\003 \001(\0162\036.io." - "substrait.Type.Nullability\032\300\001\n\020Parameter" - "izedMap\022,\n\003key\030\001 \001(\0132\037.io.substrait.Para" - "meterizedType\022.\n\005value\030\002 \001(\0132\037.io.substr" - "ait.ParameterizedType\022\031\n\021variation_point" - "er\030\003 \001(\r\0223\n\013nullability\030\004 \001(\0162\036.io.subst" - "rait.Type.Nullability\032y\n\rIntegerOption\022\021" - "\n\007literal\030\001 \001(\005H\000\022E\n\tparameter\030\002 \001(\01320.i" - "o.substrait.ParameterizedType.IntegerPar" - "ameterH\000B\016\n\014integer_typeB\006\n\004kindB+\n\022io.s" - "ubstrait.protoP\001\252\002\022Substrait.Protobufb\006p" - "roto3" +const char descriptor_table_protodef_substrait_2fparameterized_5ftypes_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n#substrait/parameterized_types.proto\022\ts" + "ubstrait\032\024substrait/type.proto\"\271\027\n\021Param" + "eterizedType\022\'\n\004bool\030\001 \001(\0132\027.substrait.T" + "ype.BooleanH\000\022 \n\002i8\030\002 \001(\0132\022.substrait.Ty" + "pe.I8H\000\022\"\n\003i16\030\003 \001(\0132\023.substrait.Type.I1" + "6H\000\022\"\n\003i32\030\005 \001(\0132\023.substrait.Type.I32H\000\022" + "\"\n\003i64\030\007 \001(\0132\023.substrait.Type.I64H\000\022$\n\004f" + "p32\030\n \001(\0132\024.substrait.Type.FP32H\000\022$\n\004fp6" + "4\030\013 \001(\0132\024.substrait.Type.FP64H\000\022(\n\006strin" + "g\030\014 \001(\0132\026.substrait.Type.StringH\000\022(\n\006bin" + "ary\030\r \001(\0132\026.substrait.Type.BinaryH\000\022.\n\tt" + "imestamp\030\016 \001(\0132\031.substrait.Type.Timestam" + "pH\000\022$\n\004date\030\020 \001(\0132\024.substrait.Type.DateH" + "\000\022$\n\004time\030\021 \001(\0132\024.substrait.Type.TimeH\000\022" + "5\n\rinterval_year\030\023 \001(\0132\034.substrait.Type." + "IntervalYearH\000\0223\n\014interval_day\030\024 \001(\0132\033.s" + "ubstrait.Type.IntervalDayH\000\0223\n\014timestamp" + "_tz\030\035 \001(\0132\033.substrait.Type.TimestampTZH\000" + "\022$\n\004uuid\030 \001(\0132\024.substrait.Type.UUIDH\000\022I" + "\n\nfixed_char\030\025 \001(\01323.substrait.Parameter" + "izedType.ParameterizedFixedCharH\000\022D\n\007var" + "char\030\026 \001(\01321.substrait.ParameterizedType" + ".ParameterizedVarCharH\000\022M\n\014fixed_binary\030" + "\027 \001(\01325.substrait.ParameterizedType.Para" + "meterizedFixedBinaryH\000\022D\n\007decimal\030\030 \001(\0132" + "1.substrait.ParameterizedType.Parameteri" + "zedDecimalH\000\022B\n\006struct\030\031 \001(\01320.substrait" + ".ParameterizedType.ParameterizedStructH\000" + "\022>\n\004list\030\033 \001(\0132..substrait.Parameterized" + "Type.ParameterizedListH\000\022<\n\003map\030\034 \001(\0132-." + "substrait.ParameterizedType.Parameterize" + "dMapH\000\022\036\n\024user_defined_pointer\030\037 \001(\rH\000\022D" + "\n\016type_parameter\030! \001(\0132*.substrait.Param" + "eterizedType.TypeParameterH\000\032K\n\rTypePara" + "meter\022\014\n\004name\030\001 \001(\t\022,\n\006bounds\030\002 \003(\0132\034.su" + "bstrait.ParameterizedType\032\270\001\n\020IntegerPar" + "ameter\022\014\n\004name\030\001 \001(\t\022K\n\025range_start_incl" + "usive\030\002 \001(\0132,.substrait.ParameterizedTyp" + "e.NullableInteger\022I\n\023range_end_exclusive" + "\030\003 \001(\0132,.substrait.ParameterizedType.Nul" + "lableInteger\032 \n\017NullableInteger\022\r\n\005value" + "\030\001 \001(\003\032\241\001\n\026ParameterizedFixedChar\022:\n\006len" + "gth\030\001 \001(\0132*.substrait.ParameterizedType." + "IntegerOption\022\031\n\021variation_pointer\030\002 \001(\r" + "\0220\n\013nullability\030\003 \001(\0162\033.substrait.Type.N" + "ullability\032\237\001\n\024ParameterizedVarChar\022:\n\006l" + "ength\030\001 \001(\0132*.substrait.ParameterizedTyp" + "e.IntegerOption\022\031\n\021variation_pointer\030\002 \001" + "(\r\0220\n\013nullability\030\003 \001(\0162\033.substrait.Type" + ".Nullability\032\243\001\n\030ParameterizedFixedBinar" + "y\022:\n\006length\030\001 \001(\0132*.substrait.Parameteri" + "zedType.IntegerOption\022\031\n\021variation_point" + "er\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrai" + "t.Type.Nullability\032\335\001\n\024ParameterizedDeci" + "mal\0229\n\005scale\030\001 \001(\0132*.substrait.Parameter" + "izedType.IntegerOption\022=\n\tprecision\030\002 \001(" + "\0132*.substrait.ParameterizedType.IntegerO" + "ption\022\031\n\021variation_pointer\030\003 \001(\r\0220\n\013null" + "ability\030\004 \001(\0162\033.substrait.Type.Nullabili" + "ty\032\217\001\n\023ParameterizedStruct\022+\n\005types\030\001 \003(" + "\0132\034.substrait.ParameterizedType\022\031\n\021varia" + "tion_pointer\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162" + "\033.substrait.Type.Nullability\032k\n\030Paramete" + "rizedNamedStruct\022\r\n\005names\030\001 \003(\t\022@\n\006struc" + "t\030\002 \001(\01320.substrait.ParameterizedType.Pa" + "rameterizedStruct\032\214\001\n\021ParameterizedList\022" + "*\n\004type\030\001 \001(\0132\034.substrait.ParameterizedT" + "ype\022\031\n\021variation_pointer\030\002 \001(\r\0220\n\013nullab" + "ility\030\003 \001(\0162\033.substrait.Type.Nullability" + "\032\267\001\n\020ParameterizedMap\022)\n\003key\030\001 \001(\0132\034.sub" + "strait.ParameterizedType\022+\n\005value\030\002 \001(\0132" + "\034.substrait.ParameterizedType\022\031\n\021variati" + "on_pointer\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033." + "substrait.Type.Nullability\032v\n\rIntegerOpt" + "ion\022\021\n\007literal\030\001 \001(\005H\000\022B\n\tparameter\030\002 \001(" + "\0132-.substrait.ParameterizedType.IntegerP" + "arameterH\000B\016\n\014integer_typeB\006\n\004kindB+\n\022io" + ".substrait.protoP\001\252\002\022Substrait.Protobufb" + "\006proto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_parameterized_5ftypes_2eproto_deps[1] = { - &::descriptor_table_type_2eproto, +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fparameterized_5ftypes_2eproto_deps[1] = { + &::descriptor_table_substrait_2ftype_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_parameterized_5ftypes_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_parameterized_5ftypes_2eproto = { - false, false, 3245, descriptor_table_protodef_parameterized_5ftypes_2eproto, "parameterized_types.proto", - &descriptor_table_parameterized_5ftypes_2eproto_once, descriptor_table_parameterized_5ftypes_2eproto_deps, 1, 13, - schemas, file_default_instances, TableStruct_parameterized_5ftypes_2eproto::offsets, - file_level_metadata_parameterized_5ftypes_2eproto, file_level_enum_descriptors_parameterized_5ftypes_2eproto, file_level_service_descriptors_parameterized_5ftypes_2eproto, +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fparameterized_5ftypes_2eproto = { + false, false, 3127, descriptor_table_protodef_substrait_2fparameterized_5ftypes_2eproto, "substrait/parameterized_types.proto", + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, descriptor_table_substrait_2fparameterized_5ftypes_2eproto_deps, 1, 13, + schemas, file_default_instances, TableStruct_substrait_2fparameterized_5ftypes_2eproto::offsets, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto, file_level_enum_descriptors_substrait_2fparameterized_5ftypes_2eproto, file_level_service_descriptors_substrait_2fparameterized_5ftypes_2eproto, }; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_parameterized_5ftypes_2eproto_getter() { - return &descriptor_table_parameterized_5ftypes_2eproto; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter() { + return &descriptor_table_substrait_2fparameterized_5ftypes_2eproto; } // Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_parameterized_5ftypes_2eproto(&descriptor_table_parameterized_5ftypes_2eproto); -namespace io { +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fparameterized_5ftypes_2eproto(&descriptor_table_substrait_2fparameterized_5ftypes_2eproto); namespace substrait { // =================================================================== @@ -480,7 +474,7 @@ ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(::PROTOBUF_NAME bounds_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.TypeParameter) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.TypeParameter) } ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(const ParameterizedType_TypeParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -491,7 +485,7 @@ ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(const Parameter name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), GetArena()); } - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.TypeParameter) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.TypeParameter) } void ParameterizedType_TypeParameter::SharedCtor() { @@ -499,7 +493,7 @@ name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlready } ParameterizedType_TypeParameter::~ParameterizedType_TypeParameter() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.TypeParameter) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.TypeParameter) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -520,7 +514,7 @@ void ParameterizedType_TypeParameter::SetCachedSize(int size) const { } void ParameterizedType_TypeParameter::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.TypeParameter) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.TypeParameter) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -541,11 +535,11 @@ const char* ParameterizedType_TypeParameter::_InternalParse(const char* ptr, ::P if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ParameterizedType.TypeParameter.name")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.TypeParameter.name")); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.ParameterizedType bounds = 2; + // repeated .substrait.ParameterizedType bounds = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -582,7 +576,7 @@ const char* ParameterizedType_TypeParameter::_InternalParse(const char* ptr, ::P ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_TypeParameter::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.TypeParameter) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.TypeParameter) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -591,12 +585,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_TypeParameter::_InternalSerial ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.ParameterizedType.TypeParameter.name"); + "substrait.ParameterizedType.TypeParameter.name"); target = stream->WriteStringMaybeAliased( 1, this->_internal_name(), target); } - // repeated .io.substrait.ParameterizedType bounds = 2; + // repeated .substrait.ParameterizedType bounds = 2; for (unsigned int i = 0, n = static_cast(this->_internal_bounds_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -608,19 +602,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_TypeParameter::_InternalSerial target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.TypeParameter) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.TypeParameter) return target; } size_t ParameterizedType_TypeParameter::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.TypeParameter) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.TypeParameter) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.ParameterizedType bounds = 2; + // repeated .substrait.ParameterizedType bounds = 2; total_size += 1UL * this->_internal_bounds_size(); for (const auto& msg : this->bounds_) { total_size += @@ -644,22 +638,22 @@ size_t ParameterizedType_TypeParameter::ByteSizeLong() const { } void ParameterizedType_TypeParameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.TypeParameter) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.TypeParameter) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_TypeParameter* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.TypeParameter) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.TypeParameter) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.TypeParameter) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.TypeParameter) MergeFrom(*source); } } void ParameterizedType_TypeParameter::MergeFrom(const ParameterizedType_TypeParameter& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.TypeParameter) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.TypeParameter) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -672,14 +666,14 @@ void ParameterizedType_TypeParameter::MergeFrom(const ParameterizedType_TypePara } void ParameterizedType_TypeParameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.TypeParameter) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.TypeParameter) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_TypeParameter::CopyFrom(const ParameterizedType_TypeParameter& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.TypeParameter) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.TypeParameter) if (&from == this) return; Clear(); MergeFrom(from); @@ -698,23 +692,23 @@ void ParameterizedType_TypeParameter::InternalSwap(ParameterizedType_TypeParamet ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_TypeParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[0]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[0]); } // =================================================================== class ParameterizedType_IntegerParameter::_Internal { public: - static const ::io::substrait::ParameterizedType_NullableInteger& range_start_inclusive(const ParameterizedType_IntegerParameter* msg); - static const ::io::substrait::ParameterizedType_NullableInteger& range_end_exclusive(const ParameterizedType_IntegerParameter* msg); + static const ::substrait::ParameterizedType_NullableInteger& range_start_inclusive(const ParameterizedType_IntegerParameter* msg); + static const ::substrait::ParameterizedType_NullableInteger& range_end_exclusive(const ParameterizedType_IntegerParameter* msg); }; -const ::io::substrait::ParameterizedType_NullableInteger& +const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_Internal::range_start_inclusive(const ParameterizedType_IntegerParameter* msg) { return *msg->range_start_inclusive_; } -const ::io::substrait::ParameterizedType_NullableInteger& +const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_Internal::range_end_exclusive(const ParameterizedType_IntegerParameter* msg) { return *msg->range_end_exclusive_; } @@ -722,7 +716,7 @@ ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(::PROTOBU : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.IntegerParameter) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.IntegerParameter) } ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(const ParameterizedType_IntegerParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -733,16 +727,16 @@ ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(const Par GetArena()); } if (from._internal_has_range_start_inclusive()) { - range_start_inclusive_ = new ::io::substrait::ParameterizedType_NullableInteger(*from.range_start_inclusive_); + range_start_inclusive_ = new ::substrait::ParameterizedType_NullableInteger(*from.range_start_inclusive_); } else { range_start_inclusive_ = nullptr; } if (from._internal_has_range_end_exclusive()) { - range_end_exclusive_ = new ::io::substrait::ParameterizedType_NullableInteger(*from.range_end_exclusive_); + range_end_exclusive_ = new ::substrait::ParameterizedType_NullableInteger(*from.range_end_exclusive_); } else { range_end_exclusive_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.IntegerParameter) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.IntegerParameter) } void ParameterizedType_IntegerParameter::SharedCtor() { @@ -754,7 +748,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ParameterizedType_IntegerParameter::~ParameterizedType_IntegerParameter() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.IntegerParameter) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.IntegerParameter) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -777,7 +771,7 @@ void ParameterizedType_IntegerParameter::SetCachedSize(int size) const { } void ParameterizedType_IntegerParameter::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.IntegerParameter) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.IntegerParameter) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -805,18 +799,18 @@ const char* ParameterizedType_IntegerParameter::_InternalParse(const char* ptr, if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ParameterizedType.IntegerParameter.name")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.IntegerParameter.name")); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; + // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_range_start_inclusive(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; + // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_range_end_exclusive(), ptr); @@ -848,7 +842,7 @@ const char* ParameterizedType_IntegerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerParameter::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.IntegerParameter) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.IntegerParameter) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -857,12 +851,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerParameter::_InternalSer ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.ParameterizedType.IntegerParameter.name"); + "substrait.ParameterizedType.IntegerParameter.name"); target = stream->WriteStringMaybeAliased( 1, this->_internal_name(), target); } - // .io.substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; + // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; if (this->has_range_start_inclusive()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -870,7 +864,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerParameter::_InternalSer 2, _Internal::range_start_inclusive(this), target, stream); } - // .io.substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; + // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; if (this->has_range_end_exclusive()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -882,12 +876,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerParameter::_InternalSer target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.IntegerParameter) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.IntegerParameter) return target; } size_t ParameterizedType_IntegerParameter::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.IntegerParameter) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.IntegerParameter) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -901,14 +895,14 @@ size_t ParameterizedType_IntegerParameter::ByteSizeLong() const { this->_internal_name()); } - // .io.substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; + // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; if (this->has_range_start_inclusive()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *range_start_inclusive_); } - // .io.substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; + // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; if (this->has_range_end_exclusive()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -925,22 +919,22 @@ size_t ParameterizedType_IntegerParameter::ByteSizeLong() const { } void ParameterizedType_IntegerParameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.IntegerParameter) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.IntegerParameter) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_IntegerParameter* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.IntegerParameter) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.IntegerParameter) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.IntegerParameter) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.IntegerParameter) MergeFrom(*source); } } void ParameterizedType_IntegerParameter::MergeFrom(const ParameterizedType_IntegerParameter& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.IntegerParameter) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.IntegerParameter) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -950,22 +944,22 @@ void ParameterizedType_IntegerParameter::MergeFrom(const ParameterizedType_Integ _internal_set_name(from._internal_name()); } if (from.has_range_start_inclusive()) { - _internal_mutable_range_start_inclusive()->::io::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_start_inclusive()); + _internal_mutable_range_start_inclusive()->::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_start_inclusive()); } if (from.has_range_end_exclusive()) { - _internal_mutable_range_end_exclusive()->::io::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_end_exclusive()); + _internal_mutable_range_end_exclusive()->::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_end_exclusive()); } } void ParameterizedType_IntegerParameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.IntegerParameter) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.IntegerParameter) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_IntegerParameter::CopyFrom(const ParameterizedType_IntegerParameter& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.IntegerParameter) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.IntegerParameter) if (&from == this) return; Clear(); MergeFrom(from); @@ -989,8 +983,8 @@ void ParameterizedType_IntegerParameter::InternalSwap(ParameterizedType_IntegerP ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_IntegerParameter::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[1]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[1]); } // =================================================================== @@ -1003,13 +997,13 @@ ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(::PROTOBUF_ : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.NullableInteger) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.NullableInteger) } ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(const ParameterizedType_NullableInteger& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); value_ = from.value_; - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.NullableInteger) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.NullableInteger) } void ParameterizedType_NullableInteger::SharedCtor() { @@ -1017,7 +1011,7 @@ value_ = PROTOBUF_LONGLONG(0); } ParameterizedType_NullableInteger::~ParameterizedType_NullableInteger() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.NullableInteger) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.NullableInteger) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1037,7 +1031,7 @@ void ParameterizedType_NullableInteger::SetCachedSize(int size) const { } void ParameterizedType_NullableInteger::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.NullableInteger) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.NullableInteger) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1084,7 +1078,7 @@ const char* ParameterizedType_NullableInteger::_InternalParse(const char* ptr, : ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_NullableInteger::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.NullableInteger) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.NullableInteger) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1098,12 +1092,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_NullableInteger::_InternalSeri target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.NullableInteger) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.NullableInteger) return target; } size_t ParameterizedType_NullableInteger::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.NullableInteger) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.NullableInteger) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1127,22 +1121,22 @@ size_t ParameterizedType_NullableInteger::ByteSizeLong() const { } void ParameterizedType_NullableInteger::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.NullableInteger) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.NullableInteger) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_NullableInteger* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.NullableInteger) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.NullableInteger) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.NullableInteger) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.NullableInteger) MergeFrom(*source); } } void ParameterizedType_NullableInteger::MergeFrom(const ParameterizedType_NullableInteger& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.NullableInteger) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.NullableInteger) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1154,14 +1148,14 @@ void ParameterizedType_NullableInteger::MergeFrom(const ParameterizedType_Nullab } void ParameterizedType_NullableInteger::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.NullableInteger) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.NullableInteger) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_NullableInteger::CopyFrom(const ParameterizedType_NullableInteger& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.NullableInteger) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.NullableInteger) if (&from == this) return; Clear(); MergeFrom(from); @@ -1179,18 +1173,18 @@ void ParameterizedType_NullableInteger::InternalSwap(ParameterizedType_NullableI ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_NullableInteger::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[2]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[2]); } // =================================================================== class ParameterizedType_ParameterizedFixedChar::_Internal { public: - static const ::io::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedChar* msg); + static const ::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedChar* msg); }; -const ::io::substrait::ParameterizedType_IntegerOption& +const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::_Internal::length(const ParameterizedType_ParameterizedFixedChar* msg) { return *msg->length_; } @@ -1198,20 +1192,20 @@ ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedCh : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedFixedChar) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedFixedChar) } ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(const ParameterizedType_ParameterizedFixedChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_length()) { - length_ = new ::io::substrait::ParameterizedType_IntegerOption(*from.length_); + length_ = new ::substrait::ParameterizedType_IntegerOption(*from.length_); } else { length_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedFixedChar) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedFixedChar) } void ParameterizedType_ParameterizedFixedChar::SharedCtor() { @@ -1222,7 +1216,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ParameterizedType_ParameterizedFixedChar::~ParameterizedType_ParameterizedFixedChar() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedFixedChar) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedFixedChar) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1243,7 +1237,7 @@ void ParameterizedType_ParameterizedFixedChar::SetCachedSize(int size) const { } void ParameterizedType_ParameterizedFixedChar::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedFixedChar) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedFixedChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1264,7 +1258,7 @@ const char* ParameterizedType_ParameterizedFixedChar::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); @@ -1278,12 +1272,12 @@ const char* ParameterizedType_ParameterizedFixedChar::_InternalParse(const char* CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -1311,11 +1305,11 @@ const char* ParameterizedType_ParameterizedFixedChar::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedChar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedFixedChar) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedFixedChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; if (this->has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1329,7 +1323,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedChar::_Inter target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1340,19 +1334,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedChar::_Inter target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedFixedChar) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedFixedChar) return target; } size_t ParameterizedType_ParameterizedFixedChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedFixedChar) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedFixedChar) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; if (this->has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1366,7 +1360,7 @@ size_t ParameterizedType_ParameterizedFixedChar::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1382,29 +1376,29 @@ size_t ParameterizedType_ParameterizedFixedChar::ByteSizeLong() const { } void ParameterizedType_ParameterizedFixedChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedFixedChar) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedFixedChar) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_ParameterizedFixedChar* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedFixedChar) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedFixedChar) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedFixedChar) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedFixedChar) MergeFrom(*source); } } void ParameterizedType_ParameterizedFixedChar::MergeFrom(const ParameterizedType_ParameterizedFixedChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedFixedChar) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedFixedChar) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_length()) { - _internal_mutable_length()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); + _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -1415,14 +1409,14 @@ void ParameterizedType_ParameterizedFixedChar::MergeFrom(const ParameterizedType } void ParameterizedType_ParameterizedFixedChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedFixedChar) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedFixedChar) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_ParameterizedFixedChar::CopyFrom(const ParameterizedType_ParameterizedFixedChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedFixedChar) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedFixedChar) if (&from == this) return; Clear(); MergeFrom(from); @@ -1445,18 +1439,18 @@ void ParameterizedType_ParameterizedFixedChar::InternalSwap(ParameterizedType_Pa ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedFixedChar::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[3]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[3]); } // =================================================================== class ParameterizedType_ParameterizedVarChar::_Internal { public: - static const ::io::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedVarChar* msg); + static const ::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedVarChar* msg); }; -const ::io::substrait::ParameterizedType_IntegerOption& +const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::_Internal::length(const ParameterizedType_ParameterizedVarChar* msg) { return *msg->length_; } @@ -1464,20 +1458,20 @@ ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(: : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedVarChar) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedVarChar) } ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(const ParameterizedType_ParameterizedVarChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_length()) { - length_ = new ::io::substrait::ParameterizedType_IntegerOption(*from.length_); + length_ = new ::substrait::ParameterizedType_IntegerOption(*from.length_); } else { length_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedVarChar) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedVarChar) } void ParameterizedType_ParameterizedVarChar::SharedCtor() { @@ -1488,7 +1482,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ParameterizedType_ParameterizedVarChar::~ParameterizedType_ParameterizedVarChar() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedVarChar) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedVarChar) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1509,7 +1503,7 @@ void ParameterizedType_ParameterizedVarChar::SetCachedSize(int size) const { } void ParameterizedType_ParameterizedVarChar::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedVarChar) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedVarChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1530,7 +1524,7 @@ const char* ParameterizedType_ParameterizedVarChar::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); @@ -1544,12 +1538,12 @@ const char* ParameterizedType_ParameterizedVarChar::_InternalParse(const char* p CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -1577,11 +1571,11 @@ const char* ParameterizedType_ParameterizedVarChar::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedVarChar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedVarChar) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedVarChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; if (this->has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1595,7 +1589,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedVarChar::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1606,19 +1600,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedVarChar::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedVarChar) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedVarChar) return target; } size_t ParameterizedType_ParameterizedVarChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedVarChar) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedVarChar) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; if (this->has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1632,7 +1626,7 @@ size_t ParameterizedType_ParameterizedVarChar::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1648,29 +1642,29 @@ size_t ParameterizedType_ParameterizedVarChar::ByteSizeLong() const { } void ParameterizedType_ParameterizedVarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedVarChar) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedVarChar) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_ParameterizedVarChar* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedVarChar) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedVarChar) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedVarChar) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedVarChar) MergeFrom(*source); } } void ParameterizedType_ParameterizedVarChar::MergeFrom(const ParameterizedType_ParameterizedVarChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedVarChar) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedVarChar) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_length()) { - _internal_mutable_length()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); + _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -1681,14 +1675,14 @@ void ParameterizedType_ParameterizedVarChar::MergeFrom(const ParameterizedType_P } void ParameterizedType_ParameterizedVarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedVarChar) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedVarChar) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_ParameterizedVarChar::CopyFrom(const ParameterizedType_ParameterizedVarChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedVarChar) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedVarChar) if (&from == this) return; Clear(); MergeFrom(from); @@ -1711,18 +1705,18 @@ void ParameterizedType_ParameterizedVarChar::InternalSwap(ParameterizedType_Para ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedVarChar::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[4]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[4]); } // =================================================================== class ParameterizedType_ParameterizedFixedBinary::_Internal { public: - static const ::io::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedBinary* msg); + static const ::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedBinary* msg); }; -const ::io::substrait::ParameterizedType_IntegerOption& +const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::_Internal::length(const ParameterizedType_ParameterizedFixedBinary* msg) { return *msg->length_; } @@ -1730,20 +1724,20 @@ ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixed : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedFixedBinary) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedFixedBinary) } ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(const ParameterizedType_ParameterizedFixedBinary& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_length()) { - length_ = new ::io::substrait::ParameterizedType_IntegerOption(*from.length_); + length_ = new ::substrait::ParameterizedType_IntegerOption(*from.length_); } else { length_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedFixedBinary) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedFixedBinary) } void ParameterizedType_ParameterizedFixedBinary::SharedCtor() { @@ -1754,7 +1748,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ParameterizedType_ParameterizedFixedBinary::~ParameterizedType_ParameterizedFixedBinary() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedFixedBinary) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedFixedBinary) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1775,7 +1769,7 @@ void ParameterizedType_ParameterizedFixedBinary::SetCachedSize(int size) const { } void ParameterizedType_ParameterizedFixedBinary::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedFixedBinary) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1796,7 +1790,7 @@ const char* ParameterizedType_ParameterizedFixedBinary::_InternalParse(const cha ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); @@ -1810,12 +1804,12 @@ const char* ParameterizedType_ParameterizedFixedBinary::_InternalParse(const cha CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -1843,11 +1837,11 @@ const char* ParameterizedType_ParameterizedFixedBinary::_InternalParse(const cha ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedBinary::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedFixedBinary) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; if (this->has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1861,7 +1855,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedBinary::_Int target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1872,19 +1866,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedBinary::_Int target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedFixedBinary) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedFixedBinary) return target; } size_t ParameterizedType_ParameterizedFixedBinary::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedFixedBinary) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; if (this->has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1898,7 +1892,7 @@ size_t ParameterizedType_ParameterizedFixedBinary::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1914,29 +1908,29 @@ size_t ParameterizedType_ParameterizedFixedBinary::ByteSizeLong() const { } void ParameterizedType_ParameterizedFixedBinary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedFixedBinary) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_ParameterizedFixedBinary* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedFixedBinary) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedFixedBinary) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedFixedBinary) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedFixedBinary) MergeFrom(*source); } } void ParameterizedType_ParameterizedFixedBinary::MergeFrom(const ParameterizedType_ParameterizedFixedBinary& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedFixedBinary) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_length()) { - _internal_mutable_length()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); + _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -1947,14 +1941,14 @@ void ParameterizedType_ParameterizedFixedBinary::MergeFrom(const ParameterizedTy } void ParameterizedType_ParameterizedFixedBinary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedFixedBinary) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_ParameterizedFixedBinary::CopyFrom(const ParameterizedType_ParameterizedFixedBinary& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedFixedBinary) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedFixedBinary) if (&from == this) return; Clear(); MergeFrom(from); @@ -1977,23 +1971,23 @@ void ParameterizedType_ParameterizedFixedBinary::InternalSwap(ParameterizedType_ ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedFixedBinary::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[5]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[5]); } // =================================================================== class ParameterizedType_ParameterizedDecimal::_Internal { public: - static const ::io::substrait::ParameterizedType_IntegerOption& scale(const ParameterizedType_ParameterizedDecimal* msg); - static const ::io::substrait::ParameterizedType_IntegerOption& precision(const ParameterizedType_ParameterizedDecimal* msg); + static const ::substrait::ParameterizedType_IntegerOption& scale(const ParameterizedType_ParameterizedDecimal* msg); + static const ::substrait::ParameterizedType_IntegerOption& precision(const ParameterizedType_ParameterizedDecimal* msg); }; -const ::io::substrait::ParameterizedType_IntegerOption& +const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_Internal::scale(const ParameterizedType_ParameterizedDecimal* msg) { return *msg->scale_; } -const ::io::substrait::ParameterizedType_IntegerOption& +const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_Internal::precision(const ParameterizedType_ParameterizedDecimal* msg) { return *msg->precision_; } @@ -2001,25 +1995,25 @@ ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(: : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedDecimal) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedDecimal) } ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(const ParameterizedType_ParameterizedDecimal& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_scale()) { - scale_ = new ::io::substrait::ParameterizedType_IntegerOption(*from.scale_); + scale_ = new ::substrait::ParameterizedType_IntegerOption(*from.scale_); } else { scale_ = nullptr; } if (from._internal_has_precision()) { - precision_ = new ::io::substrait::ParameterizedType_IntegerOption(*from.precision_); + precision_ = new ::substrait::ParameterizedType_IntegerOption(*from.precision_); } else { precision_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedDecimal) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedDecimal) } void ParameterizedType_ParameterizedDecimal::SharedCtor() { @@ -2030,7 +2024,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ParameterizedType_ParameterizedDecimal::~ParameterizedType_ParameterizedDecimal() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedDecimal) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedDecimal) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2052,7 +2046,7 @@ void ParameterizedType_ParameterizedDecimal::SetCachedSize(int size) const { } void ParameterizedType_ParameterizedDecimal::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedDecimal) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedDecimal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2077,14 +2071,14 @@ const char* ParameterizedType_ParameterizedDecimal::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.ParameterizedType.IntegerOption scale = 1; + // .substrait.ParameterizedType.IntegerOption scale = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.IntegerOption precision = 2; + // .substrait.ParameterizedType.IntegerOption precision = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr); @@ -2098,12 +2092,12 @@ const char* ParameterizedType_ParameterizedDecimal::_InternalParse(const char* p CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -2131,11 +2125,11 @@ const char* ParameterizedType_ParameterizedDecimal::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedDecimal::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedDecimal) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedDecimal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.ParameterizedType.IntegerOption scale = 1; + // .substrait.ParameterizedType.IntegerOption scale = 1; if (this->has_scale()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2143,7 +2137,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedDecimal::_Interna 1, _Internal::scale(this), target, stream); } - // .io.substrait.ParameterizedType.IntegerOption precision = 2; + // .substrait.ParameterizedType.IntegerOption precision = 2; if (this->has_precision()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2157,7 +2151,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedDecimal::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -2168,26 +2162,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedDecimal::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedDecimal) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedDecimal) return target; } size_t ParameterizedType_ParameterizedDecimal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedDecimal) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedDecimal) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.ParameterizedType.IntegerOption scale = 1; + // .substrait.ParameterizedType.IntegerOption scale = 1; if (this->has_scale()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *scale_); } - // .io.substrait.ParameterizedType.IntegerOption precision = 2; + // .substrait.ParameterizedType.IntegerOption precision = 2; if (this->has_precision()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2201,7 +2195,7 @@ size_t ParameterizedType_ParameterizedDecimal::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -2217,32 +2211,32 @@ size_t ParameterizedType_ParameterizedDecimal::ByteSizeLong() const { } void ParameterizedType_ParameterizedDecimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedDecimal) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedDecimal) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_ParameterizedDecimal* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedDecimal) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedDecimal) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedDecimal) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedDecimal) MergeFrom(*source); } } void ParameterizedType_ParameterizedDecimal::MergeFrom(const ParameterizedType_ParameterizedDecimal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedDecimal) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedDecimal) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_scale()) { - _internal_mutable_scale()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_scale()); + _internal_mutable_scale()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_scale()); } if (from.has_precision()) { - _internal_mutable_precision()->::io::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_precision()); + _internal_mutable_precision()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_precision()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -2253,14 +2247,14 @@ void ParameterizedType_ParameterizedDecimal::MergeFrom(const ParameterizedType_P } void ParameterizedType_ParameterizedDecimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedDecimal) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedDecimal) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_ParameterizedDecimal::CopyFrom(const ParameterizedType_ParameterizedDecimal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedDecimal) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedDecimal) if (&from == this) return; Clear(); MergeFrom(from); @@ -2283,8 +2277,8 @@ void ParameterizedType_ParameterizedDecimal::InternalSwap(ParameterizedType_Para ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedDecimal::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[6]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[6]); } // =================================================================== @@ -2298,7 +2292,7 @@ ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(::P types_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedStruct) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedStruct) } ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(const ParameterizedType_ParameterizedStruct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -2307,7 +2301,7 @@ ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(con ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedStruct) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedStruct) } void ParameterizedType_ParameterizedStruct::SharedCtor() { @@ -2318,7 +2312,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ParameterizedType_ParameterizedStruct::~ParameterizedType_ParameterizedStruct() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedStruct) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedStruct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2338,7 +2332,7 @@ void ParameterizedType_ParameterizedStruct::SetCachedSize(int size) const { } void ParameterizedType_ParameterizedStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedStruct) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2356,7 +2350,7 @@ const char* ParameterizedType_ParameterizedStruct::_InternalParse(const char* pt ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.ParameterizedType types = 1; + // repeated .substrait.ParameterizedType types = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -2375,12 +2369,12 @@ const char* ParameterizedType_ParameterizedStruct::_InternalParse(const char* pt CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -2408,11 +2402,11 @@ const char* ParameterizedType_ParameterizedStruct::_InternalParse(const char* pt ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedStruct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedStruct) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.ParameterizedType types = 1; + // repeated .substrait.ParameterizedType types = 1; for (unsigned int i = 0, n = static_cast(this->_internal_types_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -2426,7 +2420,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedStruct::_Internal target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -2437,19 +2431,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedStruct::_Internal target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedStruct) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedStruct) return target; } size_t ParameterizedType_ParameterizedStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedStruct) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedStruct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.ParameterizedType types = 1; + // repeated .substrait.ParameterizedType types = 1; total_size += 1UL * this->_internal_types_size(); for (const auto& msg : this->types_) { total_size += @@ -2463,7 +2457,7 @@ size_t ParameterizedType_ParameterizedStruct::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -2479,22 +2473,22 @@ size_t ParameterizedType_ParameterizedStruct::ByteSizeLong() const { } void ParameterizedType_ParameterizedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedStruct) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedStruct) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_ParameterizedStruct* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedStruct) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedStruct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedStruct) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedStruct) MergeFrom(*source); } } void ParameterizedType_ParameterizedStruct::MergeFrom(const ParameterizedType_ParameterizedStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedStruct) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedStruct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2510,14 +2504,14 @@ void ParameterizedType_ParameterizedStruct::MergeFrom(const ParameterizedType_Pa } void ParameterizedType_ParameterizedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedStruct) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedStruct) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_ParameterizedStruct::CopyFrom(const ParameterizedType_ParameterizedStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedStruct) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedStruct) if (&from == this) return; Clear(); MergeFrom(from); @@ -2541,18 +2535,18 @@ void ParameterizedType_ParameterizedStruct::InternalSwap(ParameterizedType_Param ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedStruct::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[7]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[7]); } // =================================================================== class ParameterizedType_ParameterizedNamedStruct::_Internal { public: - static const ::io::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType_ParameterizedNamedStruct* msg); + static const ::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType_ParameterizedNamedStruct* msg); }; -const ::io::substrait::ParameterizedType_ParameterizedStruct& +const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::_Internal::struct_(const ParameterizedType_ParameterizedNamedStruct* msg) { return *msg->struct__; } @@ -2561,18 +2555,18 @@ ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamed names_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedNamedStruct) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedNamedStruct) } ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(const ParameterizedType_ParameterizedNamedStruct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), names_(from.names_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_struct_()) { - struct__ = new ::io::substrait::ParameterizedType_ParameterizedStruct(*from.struct__); + struct__ = new ::substrait::ParameterizedType_ParameterizedStruct(*from.struct__); } else { struct__ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedNamedStruct) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedNamedStruct) } void ParameterizedType_ParameterizedNamedStruct::SharedCtor() { @@ -2580,7 +2574,7 @@ struct__ = nullptr; } ParameterizedType_ParameterizedNamedStruct::~ParameterizedType_ParameterizedNamedStruct() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedNamedStruct) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedNamedStruct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2601,7 +2595,7 @@ void ParameterizedType_ParameterizedNamedStruct::SetCachedSize(int size) const { } void ParameterizedType_ParameterizedNamedStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedNamedStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2628,13 +2622,13 @@ const char* ParameterizedType_ParameterizedNamedStruct::_InternalParse(const cha ptr += 1; auto str = _internal_add_names(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ParameterizedType.ParameterizedNamedStruct.names")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.ParameterizedNamedStruct.names")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.ParameterizedStruct struct = 2; + // .substrait.ParameterizedType.ParameterizedStruct struct = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); @@ -2666,7 +2660,7 @@ const char* ParameterizedType_ParameterizedNamedStruct::_InternalParse(const cha ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedNamedStruct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedNamedStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2676,11 +2670,11 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedNamedStruct::_Int ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.ParameterizedType.ParameterizedNamedStruct.names"); + "substrait.ParameterizedType.ParameterizedNamedStruct.names"); target = stream->WriteString(1, s, target); } - // .io.substrait.ParameterizedType.ParameterizedStruct struct = 2; + // .substrait.ParameterizedType.ParameterizedStruct struct = 2; if (this->has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2692,12 +2686,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedNamedStruct::_Int target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedNamedStruct) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedNamedStruct) return target; } size_t ParameterizedType_ParameterizedNamedStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedNamedStruct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2712,7 +2706,7 @@ size_t ParameterizedType_ParameterizedNamedStruct::ByteSizeLong() const { names_.Get(i)); } - // .io.substrait.ParameterizedType.ParameterizedStruct struct = 2; + // .substrait.ParameterizedType.ParameterizedStruct struct = 2; if (this->has_struct_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2729,22 +2723,22 @@ size_t ParameterizedType_ParameterizedNamedStruct::ByteSizeLong() const { } void ParameterizedType_ParameterizedNamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedNamedStruct) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_ParameterizedNamedStruct* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedNamedStruct) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedNamedStruct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedNamedStruct) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedNamedStruct) MergeFrom(*source); } } void ParameterizedType_ParameterizedNamedStruct::MergeFrom(const ParameterizedType_ParameterizedNamedStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedNamedStruct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2752,19 +2746,19 @@ void ParameterizedType_ParameterizedNamedStruct::MergeFrom(const ParameterizedTy names_.MergeFrom(from.names_); if (from.has_struct_()) { - _internal_mutable_struct_()->::io::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); } } void ParameterizedType_ParameterizedNamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedNamedStruct) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_ParameterizedNamedStruct::CopyFrom(const ParameterizedType_ParameterizedNamedStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedNamedStruct) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedNamedStruct) if (&from == this) return; Clear(); MergeFrom(from); @@ -2783,18 +2777,18 @@ void ParameterizedType_ParameterizedNamedStruct::InternalSwap(ParameterizedType_ ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedNamedStruct::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[8]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[8]); } // =================================================================== class ParameterizedType_ParameterizedList::_Internal { public: - static const ::io::substrait::ParameterizedType& type(const ParameterizedType_ParameterizedList* msg); + static const ::substrait::ParameterizedType& type(const ParameterizedType_ParameterizedList* msg); }; -const ::io::substrait::ParameterizedType& +const ::substrait::ParameterizedType& ParameterizedType_ParameterizedList::_Internal::type(const ParameterizedType_ParameterizedList* msg) { return *msg->type_; } @@ -2802,20 +2796,20 @@ ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(::PROTO : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedList) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedList) } ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(const ParameterizedType_ParameterizedList& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_type()) { - type_ = new ::io::substrait::ParameterizedType(*from.type_); + type_ = new ::substrait::ParameterizedType(*from.type_); } else { type_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedList) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedList) } void ParameterizedType_ParameterizedList::SharedCtor() { @@ -2826,7 +2820,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ParameterizedType_ParameterizedList::~ParameterizedType_ParameterizedList() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedList) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedList) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2847,7 +2841,7 @@ void ParameterizedType_ParameterizedList::SetCachedSize(int size) const { } void ParameterizedType_ParameterizedList::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedList) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2868,7 +2862,7 @@ const char* ParameterizedType_ParameterizedList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); @@ -2882,12 +2876,12 @@ const char* ParameterizedType_ParameterizedList::_InternalParse(const char* ptr, CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -2915,11 +2909,11 @@ const char* ParameterizedType_ParameterizedList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedList::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedList) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; if (this->has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2933,7 +2927,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedList::_InternalSe target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -2944,19 +2938,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedList::_InternalSe target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedList) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedList) return target; } size_t ParameterizedType_ParameterizedList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedList) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedList) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; if (this->has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2970,7 +2964,7 @@ size_t ParameterizedType_ParameterizedList::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -2986,29 +2980,29 @@ size_t ParameterizedType_ParameterizedList::ByteSizeLong() const { } void ParameterizedType_ParameterizedList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedList) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedList) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_ParameterizedList* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedList) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedList) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedList) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedList) MergeFrom(*source); } } void ParameterizedType_ParameterizedList::MergeFrom(const ParameterizedType_ParameterizedList& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedList) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedList) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_type()) { - _internal_mutable_type()->::io::substrait::ParameterizedType::MergeFrom(from._internal_type()); + _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -3019,14 +3013,14 @@ void ParameterizedType_ParameterizedList::MergeFrom(const ParameterizedType_Para } void ParameterizedType_ParameterizedList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedList) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedList) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_ParameterizedList::CopyFrom(const ParameterizedType_ParameterizedList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedList) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedList) if (&from == this) return; Clear(); MergeFrom(from); @@ -3049,23 +3043,23 @@ void ParameterizedType_ParameterizedList::InternalSwap(ParameterizedType_Paramet ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedList::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[9]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[9]); } // =================================================================== class ParameterizedType_ParameterizedMap::_Internal { public: - static const ::io::substrait::ParameterizedType& key(const ParameterizedType_ParameterizedMap* msg); - static const ::io::substrait::ParameterizedType& value(const ParameterizedType_ParameterizedMap* msg); + static const ::substrait::ParameterizedType& key(const ParameterizedType_ParameterizedMap* msg); + static const ::substrait::ParameterizedType& value(const ParameterizedType_ParameterizedMap* msg); }; -const ::io::substrait::ParameterizedType& +const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_Internal::key(const ParameterizedType_ParameterizedMap* msg) { return *msg->key_; } -const ::io::substrait::ParameterizedType& +const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_Internal::value(const ParameterizedType_ParameterizedMap* msg) { return *msg->value_; } @@ -3073,25 +3067,25 @@ ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(::PROTOBU : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.ParameterizedMap) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedMap) } ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(const ParameterizedType_ParameterizedMap& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_key()) { - key_ = new ::io::substrait::ParameterizedType(*from.key_); + key_ = new ::substrait::ParameterizedType(*from.key_); } else { key_ = nullptr; } if (from._internal_has_value()) { - value_ = new ::io::substrait::ParameterizedType(*from.value_); + value_ = new ::substrait::ParameterizedType(*from.value_); } else { value_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.ParameterizedMap) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedMap) } void ParameterizedType_ParameterizedMap::SharedCtor() { @@ -3102,7 +3096,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ParameterizedType_ParameterizedMap::~ParameterizedType_ParameterizedMap() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.ParameterizedMap) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedMap) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3124,7 +3118,7 @@ void ParameterizedType_ParameterizedMap::SetCachedSize(int size) const { } void ParameterizedType_ParameterizedMap::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.ParameterizedMap) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedMap) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3149,14 +3143,14 @@ const char* ParameterizedType_ParameterizedMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.ParameterizedType key = 1; + // .substrait.ParameterizedType key = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType value = 2; + // .substrait.ParameterizedType value = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); @@ -3170,12 +3164,12 @@ const char* ParameterizedType_ParameterizedMap::_InternalParse(const char* ptr, CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -3203,11 +3197,11 @@ const char* ParameterizedType_ParameterizedMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedMap::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.ParameterizedMap) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedMap) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.ParameterizedType key = 1; + // .substrait.ParameterizedType key = 1; if (this->has_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3215,7 +3209,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedMap::_InternalSer 1, _Internal::key(this), target, stream); } - // .io.substrait.ParameterizedType value = 2; + // .substrait.ParameterizedType value = 2; if (this->has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3229,7 +3223,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedMap::_InternalSer target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -3240,26 +3234,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedMap::_InternalSer target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.ParameterizedMap) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedMap) return target; } size_t ParameterizedType_ParameterizedMap::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.ParameterizedMap) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedMap) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.ParameterizedType key = 1; + // .substrait.ParameterizedType key = 1; if (this->has_key()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *key_); } - // .io.substrait.ParameterizedType value = 2; + // .substrait.ParameterizedType value = 2; if (this->has_value()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -3273,7 +3267,7 @@ size_t ParameterizedType_ParameterizedMap::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -3289,32 +3283,32 @@ size_t ParameterizedType_ParameterizedMap::ByteSizeLong() const { } void ParameterizedType_ParameterizedMap::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.ParameterizedMap) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedMap) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_ParameterizedMap* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.ParameterizedMap) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedMap) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.ParameterizedMap) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedMap) MergeFrom(*source); } } void ParameterizedType_ParameterizedMap::MergeFrom(const ParameterizedType_ParameterizedMap& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.ParameterizedMap) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedMap) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_key()) { - _internal_mutable_key()->::io::substrait::ParameterizedType::MergeFrom(from._internal_key()); + _internal_mutable_key()->::substrait::ParameterizedType::MergeFrom(from._internal_key()); } if (from.has_value()) { - _internal_mutable_value()->::io::substrait::ParameterizedType::MergeFrom(from._internal_value()); + _internal_mutable_value()->::substrait::ParameterizedType::MergeFrom(from._internal_value()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -3325,14 +3319,14 @@ void ParameterizedType_ParameterizedMap::MergeFrom(const ParameterizedType_Param } void ParameterizedType_ParameterizedMap::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.ParameterizedMap) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedMap) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_ParameterizedMap::CopyFrom(const ParameterizedType_ParameterizedMap& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.ParameterizedMap) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedMap) if (&from == this) return; Clear(); MergeFrom(from); @@ -3355,22 +3349,22 @@ void ParameterizedType_ParameterizedMap::InternalSwap(ParameterizedType_Paramete ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedMap::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[10]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[10]); } // =================================================================== class ParameterizedType_IntegerOption::_Internal { public: - static const ::io::substrait::ParameterizedType_IntegerParameter& parameter(const ParameterizedType_IntegerOption* msg); + static const ::substrait::ParameterizedType_IntegerParameter& parameter(const ParameterizedType_IntegerOption* msg); }; -const ::io::substrait::ParameterizedType_IntegerParameter& +const ::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::_Internal::parameter(const ParameterizedType_IntegerOption* msg) { return *msg->integer_type_.parameter_; } -void ParameterizedType_IntegerOption::set_allocated_parameter(::io::substrait::ParameterizedType_IntegerParameter* parameter) { +void ParameterizedType_IntegerOption::set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_integer_type(); if (parameter) { @@ -3383,13 +3377,13 @@ void ParameterizedType_IntegerOption::set_allocated_parameter(::io::substrait::P set_has_parameter(); integer_type_.parameter_ = parameter; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.IntegerOption.parameter) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerOption.parameter) } ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType.IntegerOption) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.IntegerOption) } ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(const ParameterizedType_IntegerOption& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -3401,14 +3395,14 @@ ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(const Parameter break; } case kParameter: { - _internal_mutable_parameter()->::io::substrait::ParameterizedType_IntegerParameter::MergeFrom(from._internal_parameter()); + _internal_mutable_parameter()->::substrait::ParameterizedType_IntegerParameter::MergeFrom(from._internal_parameter()); break; } case INTEGER_TYPE_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType.IntegerOption) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.IntegerOption) } void ParameterizedType_IntegerOption::SharedCtor() { @@ -3416,7 +3410,7 @@ clear_has_integer_type(); } ParameterizedType_IntegerOption::~ParameterizedType_IntegerOption() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType.IntegerOption) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType.IntegerOption) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3439,7 +3433,7 @@ void ParameterizedType_IntegerOption::SetCachedSize(int size) const { } void ParameterizedType_IntegerOption::clear_integer_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.ParameterizedType.IntegerOption) +// @@protoc_insertion_point(one_of_clear_start:substrait.ParameterizedType.IntegerOption) switch (integer_type_case()) { case kLiteral: { // No need to clear @@ -3460,7 +3454,7 @@ void ParameterizedType_IntegerOption::clear_integer_type() { void ParameterizedType_IntegerOption::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType.IntegerOption) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.IntegerOption) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3482,7 +3476,7 @@ const char* ParameterizedType_IntegerOption::_InternalParse(const char* ptr, ::P CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.IntegerParameter parameter = 2; + // .substrait.ParameterizedType.IntegerParameter parameter = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_parameter(), ptr); @@ -3514,7 +3508,7 @@ const char* ParameterizedType_IntegerOption::_InternalParse(const char* ptr, ::P ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerOption::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType.IntegerOption) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.IntegerOption) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3524,7 +3518,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerOption::_InternalSerial target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_literal(), target); } - // .io.substrait.ParameterizedType.IntegerParameter parameter = 2; + // .substrait.ParameterizedType.IntegerParameter parameter = 2; if (_internal_has_parameter()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3536,12 +3530,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerOption::_InternalSerial target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType.IntegerOption) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.IntegerOption) return target; } size_t ParameterizedType_IntegerOption::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType.IntegerOption) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.IntegerOption) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3556,7 +3550,7 @@ size_t ParameterizedType_IntegerOption::ByteSizeLong() const { this->_internal_literal()); break; } - // .io.substrait.ParameterizedType.IntegerParameter parameter = 2; + // .substrait.ParameterizedType.IntegerParameter parameter = 2; case kParameter: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -3577,22 +3571,22 @@ size_t ParameterizedType_IntegerOption::ByteSizeLong() const { } void ParameterizedType_IntegerOption::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType.IntegerOption) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.IntegerOption) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType_IntegerOption* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType.IntegerOption) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.IntegerOption) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType.IntegerOption) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.IntegerOption) MergeFrom(*source); } } void ParameterizedType_IntegerOption::MergeFrom(const ParameterizedType_IntegerOption& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType.IntegerOption) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.IntegerOption) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3604,7 +3598,7 @@ void ParameterizedType_IntegerOption::MergeFrom(const ParameterizedType_IntegerO break; } case kParameter: { - _internal_mutable_parameter()->::io::substrait::ParameterizedType_IntegerParameter::MergeFrom(from._internal_parameter()); + _internal_mutable_parameter()->::substrait::ParameterizedType_IntegerParameter::MergeFrom(from._internal_parameter()); break; } case INTEGER_TYPE_NOT_SET: { @@ -3614,14 +3608,14 @@ void ParameterizedType_IntegerOption::MergeFrom(const ParameterizedType_IntegerO } void ParameterizedType_IntegerOption::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType.IntegerOption) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.IntegerOption) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType_IntegerOption::CopyFrom(const ParameterizedType_IntegerOption& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType.IntegerOption) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.IntegerOption) if (&from == this) return; Clear(); MergeFrom(from); @@ -3640,137 +3634,137 @@ void ParameterizedType_IntegerOption::InternalSwap(ParameterizedType_IntegerOpti ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_IntegerOption::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[11]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[11]); } // =================================================================== class ParameterizedType::_Internal { public: - static const ::io::substrait::Type_Boolean& bool_(const ParameterizedType* msg); - static const ::io::substrait::Type_I8& i8(const ParameterizedType* msg); - static const ::io::substrait::Type_I16& i16(const ParameterizedType* msg); - static const ::io::substrait::Type_I32& i32(const ParameterizedType* msg); - static const ::io::substrait::Type_I64& i64(const ParameterizedType* msg); - static const ::io::substrait::Type_FP32& fp32(const ParameterizedType* msg); - static const ::io::substrait::Type_FP64& fp64(const ParameterizedType* msg); - static const ::io::substrait::Type_String& string(const ParameterizedType* msg); - static const ::io::substrait::Type_Binary& binary(const ParameterizedType* msg); - static const ::io::substrait::Type_Timestamp& timestamp(const ParameterizedType* msg); - static const ::io::substrait::Type_Date& date(const ParameterizedType* msg); - static const ::io::substrait::Type_Time& time(const ParameterizedType* msg); - static const ::io::substrait::Type_IntervalYear& interval_year(const ParameterizedType* msg); - static const ::io::substrait::Type_IntervalDay& interval_day(const ParameterizedType* msg); - static const ::io::substrait::Type_TimestampTZ& timestamp_tz(const ParameterizedType* msg); - static const ::io::substrait::Type_UUID& uuid(const ParameterizedType* msg); - static const ::io::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char(const ParameterizedType* msg); - static const ::io::substrait::ParameterizedType_ParameterizedVarChar& varchar(const ParameterizedType* msg); - static const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary(const ParameterizedType* msg); - static const ::io::substrait::ParameterizedType_ParameterizedDecimal& decimal(const ParameterizedType* msg); - static const ::io::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType* msg); - static const ::io::substrait::ParameterizedType_ParameterizedList& list(const ParameterizedType* msg); - static const ::io::substrait::ParameterizedType_ParameterizedMap& map(const ParameterizedType* msg); - static const ::io::substrait::ParameterizedType_TypeParameter& type_parameter(const ParameterizedType* msg); + static const ::substrait::Type_Boolean& bool_(const ParameterizedType* msg); + static const ::substrait::Type_I8& i8(const ParameterizedType* msg); + static const ::substrait::Type_I16& i16(const ParameterizedType* msg); + static const ::substrait::Type_I32& i32(const ParameterizedType* msg); + static const ::substrait::Type_I64& i64(const ParameterizedType* msg); + static const ::substrait::Type_FP32& fp32(const ParameterizedType* msg); + static const ::substrait::Type_FP64& fp64(const ParameterizedType* msg); + static const ::substrait::Type_String& string(const ParameterizedType* msg); + static const ::substrait::Type_Binary& binary(const ParameterizedType* msg); + static const ::substrait::Type_Timestamp& timestamp(const ParameterizedType* msg); + static const ::substrait::Type_Date& date(const ParameterizedType* msg); + static const ::substrait::Type_Time& time(const ParameterizedType* msg); + static const ::substrait::Type_IntervalYear& interval_year(const ParameterizedType* msg); + static const ::substrait::Type_IntervalDay& interval_day(const ParameterizedType* msg); + static const ::substrait::Type_TimestampTZ& timestamp_tz(const ParameterizedType* msg); + static const ::substrait::Type_UUID& uuid(const ParameterizedType* msg); + static const ::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char(const ParameterizedType* msg); + static const ::substrait::ParameterizedType_ParameterizedVarChar& varchar(const ParameterizedType* msg); + static const ::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary(const ParameterizedType* msg); + static const ::substrait::ParameterizedType_ParameterizedDecimal& decimal(const ParameterizedType* msg); + static const ::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType* msg); + static const ::substrait::ParameterizedType_ParameterizedList& list(const ParameterizedType* msg); + static const ::substrait::ParameterizedType_ParameterizedMap& map(const ParameterizedType* msg); + static const ::substrait::ParameterizedType_TypeParameter& type_parameter(const ParameterizedType* msg); }; -const ::io::substrait::Type_Boolean& +const ::substrait::Type_Boolean& ParameterizedType::_Internal::bool_(const ParameterizedType* msg) { return *msg->kind_.bool__; } -const ::io::substrait::Type_I8& +const ::substrait::Type_I8& ParameterizedType::_Internal::i8(const ParameterizedType* msg) { return *msg->kind_.i8_; } -const ::io::substrait::Type_I16& +const ::substrait::Type_I16& ParameterizedType::_Internal::i16(const ParameterizedType* msg) { return *msg->kind_.i16_; } -const ::io::substrait::Type_I32& +const ::substrait::Type_I32& ParameterizedType::_Internal::i32(const ParameterizedType* msg) { return *msg->kind_.i32_; } -const ::io::substrait::Type_I64& +const ::substrait::Type_I64& ParameterizedType::_Internal::i64(const ParameterizedType* msg) { return *msg->kind_.i64_; } -const ::io::substrait::Type_FP32& +const ::substrait::Type_FP32& ParameterizedType::_Internal::fp32(const ParameterizedType* msg) { return *msg->kind_.fp32_; } -const ::io::substrait::Type_FP64& +const ::substrait::Type_FP64& ParameterizedType::_Internal::fp64(const ParameterizedType* msg) { return *msg->kind_.fp64_; } -const ::io::substrait::Type_String& +const ::substrait::Type_String& ParameterizedType::_Internal::string(const ParameterizedType* msg) { return *msg->kind_.string_; } -const ::io::substrait::Type_Binary& +const ::substrait::Type_Binary& ParameterizedType::_Internal::binary(const ParameterizedType* msg) { return *msg->kind_.binary_; } -const ::io::substrait::Type_Timestamp& +const ::substrait::Type_Timestamp& ParameterizedType::_Internal::timestamp(const ParameterizedType* msg) { return *msg->kind_.timestamp_; } -const ::io::substrait::Type_Date& +const ::substrait::Type_Date& ParameterizedType::_Internal::date(const ParameterizedType* msg) { return *msg->kind_.date_; } -const ::io::substrait::Type_Time& +const ::substrait::Type_Time& ParameterizedType::_Internal::time(const ParameterizedType* msg) { return *msg->kind_.time_; } -const ::io::substrait::Type_IntervalYear& +const ::substrait::Type_IntervalYear& ParameterizedType::_Internal::interval_year(const ParameterizedType* msg) { return *msg->kind_.interval_year_; } -const ::io::substrait::Type_IntervalDay& +const ::substrait::Type_IntervalDay& ParameterizedType::_Internal::interval_day(const ParameterizedType* msg) { return *msg->kind_.interval_day_; } -const ::io::substrait::Type_TimestampTZ& +const ::substrait::Type_TimestampTZ& ParameterizedType::_Internal::timestamp_tz(const ParameterizedType* msg) { return *msg->kind_.timestamp_tz_; } -const ::io::substrait::Type_UUID& +const ::substrait::Type_UUID& ParameterizedType::_Internal::uuid(const ParameterizedType* msg) { return *msg->kind_.uuid_; } -const ::io::substrait::ParameterizedType_ParameterizedFixedChar& +const ::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::_Internal::fixed_char(const ParameterizedType* msg) { return *msg->kind_.fixed_char_; } -const ::io::substrait::ParameterizedType_ParameterizedVarChar& +const ::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::_Internal::varchar(const ParameterizedType* msg) { return *msg->kind_.varchar_; } -const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& +const ::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::_Internal::fixed_binary(const ParameterizedType* msg) { return *msg->kind_.fixed_binary_; } -const ::io::substrait::ParameterizedType_ParameterizedDecimal& +const ::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::_Internal::decimal(const ParameterizedType* msg) { return *msg->kind_.decimal_; } -const ::io::substrait::ParameterizedType_ParameterizedStruct& +const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::_Internal::struct_(const ParameterizedType* msg) { return *msg->kind_.struct__; } -const ::io::substrait::ParameterizedType_ParameterizedList& +const ::substrait::ParameterizedType_ParameterizedList& ParameterizedType::_Internal::list(const ParameterizedType* msg) { return *msg->kind_.list_; } -const ::io::substrait::ParameterizedType_ParameterizedMap& +const ::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::_Internal::map(const ParameterizedType* msg) { return *msg->kind_.map_; } -const ::io::substrait::ParameterizedType_TypeParameter& +const ::substrait::ParameterizedType_TypeParameter& ParameterizedType::_Internal::type_parameter(const ParameterizedType* msg) { return *msg->kind_.type_parameter_; } -void ParameterizedType::set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { +void ParameterizedType::set_allocated_bool_(::substrait::Type_Boolean* bool_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (bool_) { @@ -3783,7 +3777,7 @@ void ParameterizedType::set_allocated_bool_(::io::substrait::Type_Boolean* bool_ set_has_bool_(); kind_.bool__ = bool_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.bool) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.bool) } void ParameterizedType::clear_bool_() { if (_internal_has_bool_()) { @@ -3793,7 +3787,7 @@ void ParameterizedType::clear_bool_() { clear_has_kind(); } } -void ParameterizedType::set_allocated_i8(::io::substrait::Type_I8* i8) { +void ParameterizedType::set_allocated_i8(::substrait::Type_I8* i8) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i8) { @@ -3806,7 +3800,7 @@ void ParameterizedType::set_allocated_i8(::io::substrait::Type_I8* i8) { set_has_i8(); kind_.i8_ = i8; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.i8) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i8) } void ParameterizedType::clear_i8() { if (_internal_has_i8()) { @@ -3816,7 +3810,7 @@ void ParameterizedType::clear_i8() { clear_has_kind(); } } -void ParameterizedType::set_allocated_i16(::io::substrait::Type_I16* i16) { +void ParameterizedType::set_allocated_i16(::substrait::Type_I16* i16) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i16) { @@ -3829,7 +3823,7 @@ void ParameterizedType::set_allocated_i16(::io::substrait::Type_I16* i16) { set_has_i16(); kind_.i16_ = i16; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.i16) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i16) } void ParameterizedType::clear_i16() { if (_internal_has_i16()) { @@ -3839,7 +3833,7 @@ void ParameterizedType::clear_i16() { clear_has_kind(); } } -void ParameterizedType::set_allocated_i32(::io::substrait::Type_I32* i32) { +void ParameterizedType::set_allocated_i32(::substrait::Type_I32* i32) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i32) { @@ -3852,7 +3846,7 @@ void ParameterizedType::set_allocated_i32(::io::substrait::Type_I32* i32) { set_has_i32(); kind_.i32_ = i32; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.i32) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i32) } void ParameterizedType::clear_i32() { if (_internal_has_i32()) { @@ -3862,7 +3856,7 @@ void ParameterizedType::clear_i32() { clear_has_kind(); } } -void ParameterizedType::set_allocated_i64(::io::substrait::Type_I64* i64) { +void ParameterizedType::set_allocated_i64(::substrait::Type_I64* i64) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i64) { @@ -3875,7 +3869,7 @@ void ParameterizedType::set_allocated_i64(::io::substrait::Type_I64* i64) { set_has_i64(); kind_.i64_ = i64; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.i64) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i64) } void ParameterizedType::clear_i64() { if (_internal_has_i64()) { @@ -3885,7 +3879,7 @@ void ParameterizedType::clear_i64() { clear_has_kind(); } } -void ParameterizedType::set_allocated_fp32(::io::substrait::Type_FP32* fp32) { +void ParameterizedType::set_allocated_fp32(::substrait::Type_FP32* fp32) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fp32) { @@ -3898,7 +3892,7 @@ void ParameterizedType::set_allocated_fp32(::io::substrait::Type_FP32* fp32) { set_has_fp32(); kind_.fp32_ = fp32; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.fp32) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fp32) } void ParameterizedType::clear_fp32() { if (_internal_has_fp32()) { @@ -3908,7 +3902,7 @@ void ParameterizedType::clear_fp32() { clear_has_kind(); } } -void ParameterizedType::set_allocated_fp64(::io::substrait::Type_FP64* fp64) { +void ParameterizedType::set_allocated_fp64(::substrait::Type_FP64* fp64) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fp64) { @@ -3921,7 +3915,7 @@ void ParameterizedType::set_allocated_fp64(::io::substrait::Type_FP64* fp64) { set_has_fp64(); kind_.fp64_ = fp64; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.fp64) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fp64) } void ParameterizedType::clear_fp64() { if (_internal_has_fp64()) { @@ -3931,7 +3925,7 @@ void ParameterizedType::clear_fp64() { clear_has_kind(); } } -void ParameterizedType::set_allocated_string(::io::substrait::Type_String* string) { +void ParameterizedType::set_allocated_string(::substrait::Type_String* string) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (string) { @@ -3944,7 +3938,7 @@ void ParameterizedType::set_allocated_string(::io::substrait::Type_String* strin set_has_string(); kind_.string_ = string; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.string) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.string) } void ParameterizedType::clear_string() { if (_internal_has_string()) { @@ -3954,7 +3948,7 @@ void ParameterizedType::clear_string() { clear_has_kind(); } } -void ParameterizedType::set_allocated_binary(::io::substrait::Type_Binary* binary) { +void ParameterizedType::set_allocated_binary(::substrait::Type_Binary* binary) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (binary) { @@ -3967,7 +3961,7 @@ void ParameterizedType::set_allocated_binary(::io::substrait::Type_Binary* binar set_has_binary(); kind_.binary_ = binary; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.binary) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.binary) } void ParameterizedType::clear_binary() { if (_internal_has_binary()) { @@ -3977,7 +3971,7 @@ void ParameterizedType::clear_binary() { clear_has_kind(); } } -void ParameterizedType::set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { +void ParameterizedType::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (timestamp) { @@ -3990,7 +3984,7 @@ void ParameterizedType::set_allocated_timestamp(::io::substrait::Type_Timestamp* set_has_timestamp(); kind_.timestamp_ = timestamp; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.timestamp) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.timestamp) } void ParameterizedType::clear_timestamp() { if (_internal_has_timestamp()) { @@ -4000,7 +3994,7 @@ void ParameterizedType::clear_timestamp() { clear_has_kind(); } } -void ParameterizedType::set_allocated_date(::io::substrait::Type_Date* date) { +void ParameterizedType::set_allocated_date(::substrait::Type_Date* date) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (date) { @@ -4013,7 +4007,7 @@ void ParameterizedType::set_allocated_date(::io::substrait::Type_Date* date) { set_has_date(); kind_.date_ = date; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.date) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.date) } void ParameterizedType::clear_date() { if (_internal_has_date()) { @@ -4023,7 +4017,7 @@ void ParameterizedType::clear_date() { clear_has_kind(); } } -void ParameterizedType::set_allocated_time(::io::substrait::Type_Time* time) { +void ParameterizedType::set_allocated_time(::substrait::Type_Time* time) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (time) { @@ -4036,7 +4030,7 @@ void ParameterizedType::set_allocated_time(::io::substrait::Type_Time* time) { set_has_time(); kind_.time_ = time; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.time) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.time) } void ParameterizedType::clear_time() { if (_internal_has_time()) { @@ -4046,7 +4040,7 @@ void ParameterizedType::clear_time() { clear_has_kind(); } } -void ParameterizedType::set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { +void ParameterizedType::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (interval_year) { @@ -4059,7 +4053,7 @@ void ParameterizedType::set_allocated_interval_year(::io::substrait::Type_Interv set_has_interval_year(); kind_.interval_year_ = interval_year; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.interval_year) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.interval_year) } void ParameterizedType::clear_interval_year() { if (_internal_has_interval_year()) { @@ -4069,7 +4063,7 @@ void ParameterizedType::clear_interval_year() { clear_has_kind(); } } -void ParameterizedType::set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { +void ParameterizedType::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (interval_day) { @@ -4082,7 +4076,7 @@ void ParameterizedType::set_allocated_interval_day(::io::substrait::Type_Interva set_has_interval_day(); kind_.interval_day_ = interval_day; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.interval_day) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.interval_day) } void ParameterizedType::clear_interval_day() { if (_internal_has_interval_day()) { @@ -4092,7 +4086,7 @@ void ParameterizedType::clear_interval_day() { clear_has_kind(); } } -void ParameterizedType::set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { +void ParameterizedType::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (timestamp_tz) { @@ -4105,7 +4099,7 @@ void ParameterizedType::set_allocated_timestamp_tz(::io::substrait::Type_Timesta set_has_timestamp_tz(); kind_.timestamp_tz_ = timestamp_tz; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.timestamp_tz) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.timestamp_tz) } void ParameterizedType::clear_timestamp_tz() { if (_internal_has_timestamp_tz()) { @@ -4115,7 +4109,7 @@ void ParameterizedType::clear_timestamp_tz() { clear_has_kind(); } } -void ParameterizedType::set_allocated_uuid(::io::substrait::Type_UUID* uuid) { +void ParameterizedType::set_allocated_uuid(::substrait::Type_UUID* uuid) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (uuid) { @@ -4128,7 +4122,7 @@ void ParameterizedType::set_allocated_uuid(::io::substrait::Type_UUID* uuid) { set_has_uuid(); kind_.uuid_ = uuid; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.uuid) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.uuid) } void ParameterizedType::clear_uuid() { if (_internal_has_uuid()) { @@ -4138,7 +4132,7 @@ void ParameterizedType::clear_uuid() { clear_has_kind(); } } -void ParameterizedType::set_allocated_fixed_char(::io::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) { +void ParameterizedType::set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fixed_char) { @@ -4151,9 +4145,9 @@ void ParameterizedType::set_allocated_fixed_char(::io::substrait::ParameterizedT set_has_fixed_char(); kind_.fixed_char_ = fixed_char; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.fixed_char) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fixed_char) } -void ParameterizedType::set_allocated_varchar(::io::substrait::ParameterizedType_ParameterizedVarChar* varchar) { +void ParameterizedType::set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (varchar) { @@ -4166,9 +4160,9 @@ void ParameterizedType::set_allocated_varchar(::io::substrait::ParameterizedType set_has_varchar(); kind_.varchar_ = varchar; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.varchar) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.varchar) } -void ParameterizedType::set_allocated_fixed_binary(::io::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) { +void ParameterizedType::set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fixed_binary) { @@ -4181,9 +4175,9 @@ void ParameterizedType::set_allocated_fixed_binary(::io::substrait::Parameterize set_has_fixed_binary(); kind_.fixed_binary_ = fixed_binary; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.fixed_binary) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fixed_binary) } -void ParameterizedType::set_allocated_decimal(::io::substrait::ParameterizedType_ParameterizedDecimal* decimal) { +void ParameterizedType::set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (decimal) { @@ -4196,9 +4190,9 @@ void ParameterizedType::set_allocated_decimal(::io::substrait::ParameterizedType set_has_decimal(); kind_.decimal_ = decimal; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.decimal) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.decimal) } -void ParameterizedType::set_allocated_struct_(::io::substrait::ParameterizedType_ParameterizedStruct* struct_) { +void ParameterizedType::set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (struct_) { @@ -4211,9 +4205,9 @@ void ParameterizedType::set_allocated_struct_(::io::substrait::ParameterizedType set_has_struct_(); kind_.struct__ = struct_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.struct) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.struct) } -void ParameterizedType::set_allocated_list(::io::substrait::ParameterizedType_ParameterizedList* list) { +void ParameterizedType::set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (list) { @@ -4226,9 +4220,9 @@ void ParameterizedType::set_allocated_list(::io::substrait::ParameterizedType_Pa set_has_list(); kind_.list_ = list; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.list) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.list) } -void ParameterizedType::set_allocated_map(::io::substrait::ParameterizedType_ParameterizedMap* map) { +void ParameterizedType::set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (map) { @@ -4241,9 +4235,9 @@ void ParameterizedType::set_allocated_map(::io::substrait::ParameterizedType_Par set_has_map(); kind_.map_ = map; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.map) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.map) } -void ParameterizedType::set_allocated_type_parameter(::io::substrait::ParameterizedType_TypeParameter* type_parameter) { +void ParameterizedType::set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (type_parameter) { @@ -4256,13 +4250,13 @@ void ParameterizedType::set_allocated_type_parameter(::io::substrait::Parameteri set_has_type_parameter(); kind_.type_parameter_ = type_parameter; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.type_parameter) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.type_parameter) } ParameterizedType::ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ParameterizedType) + // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType) } ParameterizedType::ParameterizedType(const ParameterizedType& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -4270,95 +4264,95 @@ ParameterizedType::ParameterizedType(const ParameterizedType& from) clear_has_kind(); switch (from.kind_case()) { case kBool: { - _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); break; } case kI8: { - _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); break; } case kI16: { - _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); break; } case kI32: { - _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); break; } case kI64: { - _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); break; } case kFp32: { - _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); break; } case kFp64: { - _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); break; } case kString: { - _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); break; } case kBinary: { - _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); break; } case kTimestamp: { - _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); break; } case kDate: { - _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); break; } case kTime: { - _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); break; } case kIntervalYear: { - _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); break; } case kIntervalDay: { - _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); break; } case kTimestampTz: { - _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); break; } case kUuid: { - _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); break; } case kFixedChar: { - _internal_mutable_fixed_char()->::io::substrait::ParameterizedType_ParameterizedFixedChar::MergeFrom(from._internal_fixed_char()); + _internal_mutable_fixed_char()->::substrait::ParameterizedType_ParameterizedFixedChar::MergeFrom(from._internal_fixed_char()); break; } case kVarchar: { - _internal_mutable_varchar()->::io::substrait::ParameterizedType_ParameterizedVarChar::MergeFrom(from._internal_varchar()); + _internal_mutable_varchar()->::substrait::ParameterizedType_ParameterizedVarChar::MergeFrom(from._internal_varchar()); break; } case kFixedBinary: { - _internal_mutable_fixed_binary()->::io::substrait::ParameterizedType_ParameterizedFixedBinary::MergeFrom(from._internal_fixed_binary()); + _internal_mutable_fixed_binary()->::substrait::ParameterizedType_ParameterizedFixedBinary::MergeFrom(from._internal_fixed_binary()); break; } case kDecimal: { - _internal_mutable_decimal()->::io::substrait::ParameterizedType_ParameterizedDecimal::MergeFrom(from._internal_decimal()); + _internal_mutable_decimal()->::substrait::ParameterizedType_ParameterizedDecimal::MergeFrom(from._internal_decimal()); break; } case kStruct: { - _internal_mutable_struct_()->::io::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); break; } case kList: { - _internal_mutable_list()->::io::substrait::ParameterizedType_ParameterizedList::MergeFrom(from._internal_list()); + _internal_mutable_list()->::substrait::ParameterizedType_ParameterizedList::MergeFrom(from._internal_list()); break; } case kMap: { - _internal_mutable_map()->::io::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map()); + _internal_mutable_map()->::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map()); break; } case kUserDefinedPointer: { @@ -4366,14 +4360,14 @@ ParameterizedType::ParameterizedType(const ParameterizedType& from) break; } case kTypeParameter: { - _internal_mutable_type_parameter()->::io::substrait::ParameterizedType_TypeParameter::MergeFrom(from._internal_type_parameter()); + _internal_mutable_type_parameter()->::substrait::ParameterizedType_TypeParameter::MergeFrom(from._internal_type_parameter()); break; } case KIND_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.ParameterizedType) + // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType) } void ParameterizedType::SharedCtor() { @@ -4381,7 +4375,7 @@ clear_has_kind(); } ParameterizedType::~ParameterizedType() { - // @@protoc_insertion_point(destructor:io.substrait.ParameterizedType) + // @@protoc_insertion_point(destructor:substrait.ParameterizedType) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4404,7 +4398,7 @@ void ParameterizedType::SetCachedSize(int size) const { } void ParameterizedType::clear_kind() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.ParameterizedType) +// @@protoc_insertion_point(one_of_clear_start:substrait.ParameterizedType) switch (kind_case()) { case kBool: { if (GetArena() == nullptr) { @@ -4563,7 +4557,7 @@ void ParameterizedType::clear_kind() { void ParameterizedType::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ParameterizedType) +// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4578,154 +4572,154 @@ const char* ParameterizedType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; case 14: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; case 16: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; case 17: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; case 19: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; case 20: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; + // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; case 21: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.ParameterizedVarChar varchar = 22; + // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; case 22: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; + // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; case 23: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.ParameterizedDecimal decimal = 24; + // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; case 24: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.ParameterizedStruct struct = 25; + // .substrait.ParameterizedType.ParameterizedStruct struct = 25; case 25: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.ParameterizedList list = 27; + // .substrait.ParameterizedType.ParameterizedList list = 27; case 27: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) { ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.ParameterizedMap map = 28; + // .substrait.ParameterizedType.ParameterizedMap map = 28; case 28: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; case 29: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); @@ -4739,14 +4733,14 @@ const char* ParameterizedType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; case 32: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; + // .substrait.ParameterizedType.TypeParameter type_parameter = 33; case 33: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type_parameter(), ptr); @@ -4778,11 +4772,11 @@ const char* ParameterizedType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ParameterizedType) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; if (_internal_has_bool_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4790,7 +4784,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 1, _Internal::bool_(this), target, stream); } - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; if (_internal_has_i8()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4798,7 +4792,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 2, _Internal::i8(this), target, stream); } - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; if (_internal_has_i16()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4806,7 +4800,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 3, _Internal::i16(this), target, stream); } - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; if (_internal_has_i32()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4814,7 +4808,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 5, _Internal::i32(this), target, stream); } - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; if (_internal_has_i64()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4822,7 +4816,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 7, _Internal::i64(this), target, stream); } - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; if (_internal_has_fp32()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4830,7 +4824,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 10, _Internal::fp32(this), target, stream); } - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; if (_internal_has_fp64()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4838,7 +4832,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 11, _Internal::fp64(this), target, stream); } - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; if (_internal_has_string()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4846,7 +4840,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 12, _Internal::string(this), target, stream); } - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; if (_internal_has_binary()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4854,7 +4848,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 13, _Internal::binary(this), target, stream); } - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; if (_internal_has_timestamp()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4862,7 +4856,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 14, _Internal::timestamp(this), target, stream); } - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; if (_internal_has_date()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4870,7 +4864,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 16, _Internal::date(this), target, stream); } - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; if (_internal_has_time()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4878,7 +4872,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 17, _Internal::time(this), target, stream); } - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; if (_internal_has_interval_year()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4886,7 +4880,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 19, _Internal::interval_year(this), target, stream); } - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; if (_internal_has_interval_day()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4894,7 +4888,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 20, _Internal::interval_day(this), target, stream); } - // .io.substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; + // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; if (_internal_has_fixed_char()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4902,7 +4896,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 21, _Internal::fixed_char(this), target, stream); } - // .io.substrait.ParameterizedType.ParameterizedVarChar varchar = 22; + // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; if (_internal_has_varchar()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4910,7 +4904,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 22, _Internal::varchar(this), target, stream); } - // .io.substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; + // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; if (_internal_has_fixed_binary()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4918,7 +4912,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 23, _Internal::fixed_binary(this), target, stream); } - // .io.substrait.ParameterizedType.ParameterizedDecimal decimal = 24; + // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; if (_internal_has_decimal()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4926,7 +4920,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 24, _Internal::decimal(this), target, stream); } - // .io.substrait.ParameterizedType.ParameterizedStruct struct = 25; + // .substrait.ParameterizedType.ParameterizedStruct struct = 25; if (_internal_has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4934,7 +4928,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 25, _Internal::struct_(this), target, stream); } - // .io.substrait.ParameterizedType.ParameterizedList list = 27; + // .substrait.ParameterizedType.ParameterizedList list = 27; if (_internal_has_list()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4942,7 +4936,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 27, _Internal::list(this), target, stream); } - // .io.substrait.ParameterizedType.ParameterizedMap map = 28; + // .substrait.ParameterizedType.ParameterizedMap map = 28; if (_internal_has_map()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4950,7 +4944,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 28, _Internal::map(this), target, stream); } - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; if (_internal_has_timestamp_tz()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4964,7 +4958,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_pointer(), target); } - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; if (_internal_has_uuid()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4972,7 +4966,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( 32, _Internal::uuid(this), target, stream); } - // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; + // .substrait.ParameterizedType.TypeParameter type_parameter = 33; if (_internal_has_type_parameter()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4984,12 +4978,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ParameterizedType) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType) return target; } size_t ParameterizedType::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ParameterizedType) +// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4997,161 +4991,161 @@ size_t ParameterizedType::ByteSizeLong() const { (void) cached_has_bits; switch (kind_case()) { - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; case kBool: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.bool__); break; } - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; case kI8: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i8_); break; } - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; case kI16: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i16_); break; } - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; case kI32: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i32_); break; } - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; case kI64: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i64_); break; } - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; case kFp32: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fp32_); break; } - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; case kFp64: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fp64_); break; } - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; case kString: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.string_); break; } - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; case kBinary: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.binary_); break; } - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; case kTimestamp: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.timestamp_); break; } - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; case kDate: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.date_); break; } - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; case kTime: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.time_); break; } - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; case kIntervalYear: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.interval_year_); break; } - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; case kIntervalDay: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.interval_day_); break; } - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; case kTimestampTz: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.timestamp_tz_); break; } - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; case kUuid: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.uuid_); break; } - // .io.substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; + // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; case kFixedChar: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fixed_char_); break; } - // .io.substrait.ParameterizedType.ParameterizedVarChar varchar = 22; + // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; case kVarchar: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.varchar_); break; } - // .io.substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; + // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; case kFixedBinary: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fixed_binary_); break; } - // .io.substrait.ParameterizedType.ParameterizedDecimal decimal = 24; + // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; case kDecimal: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.decimal_); break; } - // .io.substrait.ParameterizedType.ParameterizedStruct struct = 25; + // .substrait.ParameterizedType.ParameterizedStruct struct = 25; case kStruct: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.struct__); break; } - // .io.substrait.ParameterizedType.ParameterizedList list = 27; + // .substrait.ParameterizedType.ParameterizedList list = 27; case kList: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.list_); break; } - // .io.substrait.ParameterizedType.ParameterizedMap map = 28; + // .substrait.ParameterizedType.ParameterizedMap map = 28; case kMap: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -5165,7 +5159,7 @@ size_t ParameterizedType::ByteSizeLong() const { this->_internal_user_defined_pointer()); break; } - // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; + // .substrait.ParameterizedType.TypeParameter type_parameter = 33; case kTypeParameter: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -5186,22 +5180,22 @@ size_t ParameterizedType::ByteSizeLong() const { } void ParameterizedType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ParameterizedType) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType) GOOGLE_DCHECK_NE(&from, this); const ParameterizedType* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ParameterizedType) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ParameterizedType) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType) MergeFrom(*source); } } void ParameterizedType::MergeFrom(const ParameterizedType& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ParameterizedType) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5209,95 +5203,95 @@ void ParameterizedType::MergeFrom(const ParameterizedType& from) { switch (from.kind_case()) { case kBool: { - _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); break; } case kI8: { - _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); break; } case kI16: { - _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); break; } case kI32: { - _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); break; } case kI64: { - _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); break; } case kFp32: { - _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); break; } case kFp64: { - _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); break; } case kString: { - _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); break; } case kBinary: { - _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); break; } case kTimestamp: { - _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); break; } case kDate: { - _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); break; } case kTime: { - _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); break; } case kIntervalYear: { - _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); break; } case kIntervalDay: { - _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); break; } case kTimestampTz: { - _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); break; } case kUuid: { - _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); break; } case kFixedChar: { - _internal_mutable_fixed_char()->::io::substrait::ParameterizedType_ParameterizedFixedChar::MergeFrom(from._internal_fixed_char()); + _internal_mutable_fixed_char()->::substrait::ParameterizedType_ParameterizedFixedChar::MergeFrom(from._internal_fixed_char()); break; } case kVarchar: { - _internal_mutable_varchar()->::io::substrait::ParameterizedType_ParameterizedVarChar::MergeFrom(from._internal_varchar()); + _internal_mutable_varchar()->::substrait::ParameterizedType_ParameterizedVarChar::MergeFrom(from._internal_varchar()); break; } case kFixedBinary: { - _internal_mutable_fixed_binary()->::io::substrait::ParameterizedType_ParameterizedFixedBinary::MergeFrom(from._internal_fixed_binary()); + _internal_mutable_fixed_binary()->::substrait::ParameterizedType_ParameterizedFixedBinary::MergeFrom(from._internal_fixed_binary()); break; } case kDecimal: { - _internal_mutable_decimal()->::io::substrait::ParameterizedType_ParameterizedDecimal::MergeFrom(from._internal_decimal()); + _internal_mutable_decimal()->::substrait::ParameterizedType_ParameterizedDecimal::MergeFrom(from._internal_decimal()); break; } case kStruct: { - _internal_mutable_struct_()->::io::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); break; } case kList: { - _internal_mutable_list()->::io::substrait::ParameterizedType_ParameterizedList::MergeFrom(from._internal_list()); + _internal_mutable_list()->::substrait::ParameterizedType_ParameterizedList::MergeFrom(from._internal_list()); break; } case kMap: { - _internal_mutable_map()->::io::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map()); + _internal_mutable_map()->::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map()); break; } case kUserDefinedPointer: { @@ -5305,7 +5299,7 @@ void ParameterizedType::MergeFrom(const ParameterizedType& from) { break; } case kTypeParameter: { - _internal_mutable_type_parameter()->::io::substrait::ParameterizedType_TypeParameter::MergeFrom(from._internal_type_parameter()); + _internal_mutable_type_parameter()->::substrait::ParameterizedType_TypeParameter::MergeFrom(from._internal_type_parameter()); break; } case KIND_NOT_SET: { @@ -5315,14 +5309,14 @@ void ParameterizedType::MergeFrom(const ParameterizedType& from) { } void ParameterizedType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ParameterizedType) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType) if (&from == this) return; Clear(); MergeFrom(from); } void ParameterizedType::CopyFrom(const ParameterizedType& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ParameterizedType) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType) if (&from == this) return; Clear(); MergeFrom(from); @@ -5341,52 +5335,51 @@ void ParameterizedType::InternalSwap(ParameterizedType* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_parameterized_5ftypes_2eproto_getter, &descriptor_table_parameterized_5ftypes_2eproto_once, - file_level_metadata_parameterized_5ftypes_2eproto[12]); + &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, + file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[12]); } // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_TypeParameter* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_TypeParameter >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_TypeParameter >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_TypeParameter* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_TypeParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_TypeParameter >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_IntegerParameter* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_IntegerParameter >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_IntegerParameter >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_IntegerParameter* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_IntegerParameter >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_IntegerParameter >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_NullableInteger* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_NullableInteger >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_NullableInteger >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_NullableInteger* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_NullableInteger >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_NullableInteger >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedFixedChar* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedFixedChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedFixedChar >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedFixedChar* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedFixedChar >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedVarChar* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedVarChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedVarChar >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedVarChar* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedVarChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedVarChar >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedFixedBinary* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedFixedBinary >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedFixedBinary >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedFixedBinary* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedBinary >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedFixedBinary >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedDecimal* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedDecimal >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedDecimal >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedDecimal* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedDecimal >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedDecimal >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedStruct* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedStruct >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedStruct* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedStruct >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedNamedStruct* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedNamedStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedNamedStruct >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedNamedStruct* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedNamedStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedNamedStruct >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedList* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedList >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedList >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedList* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedList >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedList >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_ParameterizedMap* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedMap >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_ParameterizedMap >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedMap* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedMap >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedMap >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType_IntegerOption* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType_IntegerOption >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType_IntegerOption >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_IntegerOption* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_IntegerOption >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType_IntegerOption >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ParameterizedType* Arena::CreateMaybeMessage< ::io::substrait::ParameterizedType >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ParameterizedType >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType* Arena::CreateMaybeMessage< ::substrait::ParameterizedType >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ParameterizedType >(arena); } PROTOBUF_NAMESPACE_CLOSE diff --git a/cpp/src/generated/substrait/parameterized_types.pb.h b/cpp/src/generated/substrait/parameterized_types.pb.h index 0b77fd1fe5b..3d3d6a499fc 100644 --- a/cpp/src/generated/substrait/parameterized_types.pb.h +++ b/cpp/src/generated/substrait/parameterized_types.pb.h @@ -1,8 +1,8 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: parameterized_types.proto +// source: substrait/parameterized_types.proto -#ifndef GOOGLE_PROTOBUF_INCLUDED_parameterized_5ftypes_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_parameterized_5ftypes_2eproto +#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fparameterized_5ftypes_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fparameterized_5ftypes_2eproto #include #include @@ -31,10 +31,10 @@ #include // IWYU pragma: export #include // IWYU pragma: export #include -#include "type.pb.h" +#include "substrait/type.pb.h" // @@protoc_insertion_point(includes) #include -#define PROTOBUF_INTERNAL_EXPORT_parameterized_5ftypes_2eproto +#define PROTOBUF_INTERNAL_EXPORT_substrait_2fparameterized_5ftypes_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; @@ -42,7 +42,7 @@ class AnyMetadata; PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. -struct TableStruct_parameterized_5ftypes_2eproto { +struct TableStruct_substrait_2fparameterized_5ftypes_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] @@ -53,8 +53,7 @@ struct TableStruct_parameterized_5ftypes_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; }; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_parameterized_5ftypes_2eproto; -namespace io { +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fparameterized_5ftypes_2eproto; namespace substrait { class ParameterizedType; struct ParameterizedTypeDefaultTypeInternal; @@ -96,29 +95,27 @@ class ParameterizedType_TypeParameter; struct ParameterizedType_TypeParameterDefaultTypeInternal; extern ParameterizedType_TypeParameterDefaultTypeInternal _ParameterizedType_TypeParameter_default_instance_; } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::ParameterizedType* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType>(Arena*); -template<> ::io::substrait::ParameterizedType_IntegerOption* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(Arena*); -template<> ::io::substrait::ParameterizedType_IntegerParameter* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerParameter>(Arena*); -template<> ::io::substrait::ParameterizedType_NullableInteger* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_NullableInteger>(Arena*); -template<> ::io::substrait::ParameterizedType_ParameterizedDecimal* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedDecimal>(Arena*); -template<> ::io::substrait::ParameterizedType_ParameterizedFixedBinary* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedFixedBinary>(Arena*); -template<> ::io::substrait::ParameterizedType_ParameterizedFixedChar* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedFixedChar>(Arena*); -template<> ::io::substrait::ParameterizedType_ParameterizedList* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedList>(Arena*); -template<> ::io::substrait::ParameterizedType_ParameterizedMap* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedMap>(Arena*); -template<> ::io::substrait::ParameterizedType_ParameterizedNamedStruct* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedNamedStruct>(Arena*); -template<> ::io::substrait::ParameterizedType_ParameterizedStruct* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedStruct>(Arena*); -template<> ::io::substrait::ParameterizedType_ParameterizedVarChar* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedVarChar>(Arena*); -template<> ::io::substrait::ParameterizedType_TypeParameter* Arena::CreateMaybeMessage<::io::substrait::ParameterizedType_TypeParameter>(Arena*); +template<> ::substrait::ParameterizedType* Arena::CreateMaybeMessage<::substrait::ParameterizedType>(Arena*); +template<> ::substrait::ParameterizedType_IntegerOption* Arena::CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(Arena*); +template<> ::substrait::ParameterizedType_IntegerParameter* Arena::CreateMaybeMessage<::substrait::ParameterizedType_IntegerParameter>(Arena*); +template<> ::substrait::ParameterizedType_NullableInteger* Arena::CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(Arena*); +template<> ::substrait::ParameterizedType_ParameterizedDecimal* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedDecimal>(Arena*); +template<> ::substrait::ParameterizedType_ParameterizedFixedBinary* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedFixedBinary>(Arena*); +template<> ::substrait::ParameterizedType_ParameterizedFixedChar* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedFixedChar>(Arena*); +template<> ::substrait::ParameterizedType_ParameterizedList* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedList>(Arena*); +template<> ::substrait::ParameterizedType_ParameterizedMap* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedMap>(Arena*); +template<> ::substrait::ParameterizedType_ParameterizedNamedStruct* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedNamedStruct>(Arena*); +template<> ::substrait::ParameterizedType_ParameterizedStruct* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedStruct>(Arena*); +template<> ::substrait::ParameterizedType_ParameterizedVarChar* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedVarChar>(Arena*); +template<> ::substrait::ParameterizedType_TypeParameter* Arena::CreateMaybeMessage<::substrait::ParameterizedType_TypeParameter>(Arena*); PROTOBUF_NAMESPACE_CLOSE -namespace io { namespace substrait { // =================================================================== class ParameterizedType_TypeParameter PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.TypeParameter) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.TypeParameter) */ { public: inline ParameterizedType_TypeParameter() : ParameterizedType_TypeParameter(nullptr) {} ~ParameterizedType_TypeParameter() override; @@ -208,7 +205,7 @@ class ParameterizedType_TypeParameter PROTOBUF_FINAL : void InternalSwap(ParameterizedType_TypeParameter* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.TypeParameter"; + return "substrait.ParameterizedType.TypeParameter"; } protected: explicit ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -227,22 +224,22 @@ class ParameterizedType_TypeParameter PROTOBUF_FINAL : kBoundsFieldNumber = 2, kNameFieldNumber = 1, }; - // repeated .io.substrait.ParameterizedType bounds = 2; + // repeated .substrait.ParameterizedType bounds = 2; int bounds_size() const; private: int _internal_bounds_size() const; public: void clear_bounds(); - ::io::substrait::ParameterizedType* mutable_bounds(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >* + ::substrait::ParameterizedType* mutable_bounds(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >* mutable_bounds(); private: - const ::io::substrait::ParameterizedType& _internal_bounds(int index) const; - ::io::substrait::ParameterizedType* _internal_add_bounds(); + const ::substrait::ParameterizedType& _internal_bounds(int index) const; + ::substrait::ParameterizedType* _internal_add_bounds(); public: - const ::io::substrait::ParameterizedType& bounds(int index) const; - ::io::substrait::ParameterizedType* add_bounds(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >& + const ::substrait::ParameterizedType& bounds(int index) const; + ::substrait::ParameterizedType* add_bounds(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >& bounds() const; // string name = 1; @@ -259,22 +256,22 @@ class ParameterizedType_TypeParameter PROTOBUF_FINAL : std::string* _internal_mutable_name(); public: - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.TypeParameter) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.TypeParameter) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType > bounds_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType > bounds_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_IntegerParameter PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.IntegerParameter) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.IntegerParameter) */ { public: inline ParameterizedType_IntegerParameter() : ParameterizedType_IntegerParameter(nullptr) {} ~ParameterizedType_IntegerParameter() override; @@ -364,7 +361,7 @@ class ParameterizedType_IntegerParameter PROTOBUF_FINAL : void InternalSwap(ParameterizedType_IntegerParameter* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.IntegerParameter"; + return "substrait.ParameterizedType.IntegerParameter"; } protected: explicit ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -398,43 +395,43 @@ class ParameterizedType_IntegerParameter PROTOBUF_FINAL : std::string* _internal_mutable_name(); public: - // .io.substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; + // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; bool has_range_start_inclusive() const; private: bool _internal_has_range_start_inclusive() const; public: void clear_range_start_inclusive(); - const ::io::substrait::ParameterizedType_NullableInteger& range_start_inclusive() const; - ::io::substrait::ParameterizedType_NullableInteger* release_range_start_inclusive(); - ::io::substrait::ParameterizedType_NullableInteger* mutable_range_start_inclusive(); - void set_allocated_range_start_inclusive(::io::substrait::ParameterizedType_NullableInteger* range_start_inclusive); + const ::substrait::ParameterizedType_NullableInteger& range_start_inclusive() const; + ::substrait::ParameterizedType_NullableInteger* release_range_start_inclusive(); + ::substrait::ParameterizedType_NullableInteger* mutable_range_start_inclusive(); + void set_allocated_range_start_inclusive(::substrait::ParameterizedType_NullableInteger* range_start_inclusive); private: - const ::io::substrait::ParameterizedType_NullableInteger& _internal_range_start_inclusive() const; - ::io::substrait::ParameterizedType_NullableInteger* _internal_mutable_range_start_inclusive(); + const ::substrait::ParameterizedType_NullableInteger& _internal_range_start_inclusive() const; + ::substrait::ParameterizedType_NullableInteger* _internal_mutable_range_start_inclusive(); public: void unsafe_arena_set_allocated_range_start_inclusive( - ::io::substrait::ParameterizedType_NullableInteger* range_start_inclusive); - ::io::substrait::ParameterizedType_NullableInteger* unsafe_arena_release_range_start_inclusive(); + ::substrait::ParameterizedType_NullableInteger* range_start_inclusive); + ::substrait::ParameterizedType_NullableInteger* unsafe_arena_release_range_start_inclusive(); - // .io.substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; + // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; bool has_range_end_exclusive() const; private: bool _internal_has_range_end_exclusive() const; public: void clear_range_end_exclusive(); - const ::io::substrait::ParameterizedType_NullableInteger& range_end_exclusive() const; - ::io::substrait::ParameterizedType_NullableInteger* release_range_end_exclusive(); - ::io::substrait::ParameterizedType_NullableInteger* mutable_range_end_exclusive(); - void set_allocated_range_end_exclusive(::io::substrait::ParameterizedType_NullableInteger* range_end_exclusive); + const ::substrait::ParameterizedType_NullableInteger& range_end_exclusive() const; + ::substrait::ParameterizedType_NullableInteger* release_range_end_exclusive(); + ::substrait::ParameterizedType_NullableInteger* mutable_range_end_exclusive(); + void set_allocated_range_end_exclusive(::substrait::ParameterizedType_NullableInteger* range_end_exclusive); private: - const ::io::substrait::ParameterizedType_NullableInteger& _internal_range_end_exclusive() const; - ::io::substrait::ParameterizedType_NullableInteger* _internal_mutable_range_end_exclusive(); + const ::substrait::ParameterizedType_NullableInteger& _internal_range_end_exclusive() const; + ::substrait::ParameterizedType_NullableInteger* _internal_mutable_range_end_exclusive(); public: void unsafe_arena_set_allocated_range_end_exclusive( - ::io::substrait::ParameterizedType_NullableInteger* range_end_exclusive); - ::io::substrait::ParameterizedType_NullableInteger* unsafe_arena_release_range_end_exclusive(); + ::substrait::ParameterizedType_NullableInteger* range_end_exclusive); + ::substrait::ParameterizedType_NullableInteger* unsafe_arena_release_range_end_exclusive(); - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.IntegerParameter) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.IntegerParameter) private: class _Internal; @@ -442,15 +439,15 @@ class ParameterizedType_IntegerParameter PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::io::substrait::ParameterizedType_NullableInteger* range_start_inclusive_; - ::io::substrait::ParameterizedType_NullableInteger* range_end_exclusive_; + ::substrait::ParameterizedType_NullableInteger* range_start_inclusive_; + ::substrait::ParameterizedType_NullableInteger* range_end_exclusive_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_NullableInteger PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.NullableInteger) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.NullableInteger) */ { public: inline ParameterizedType_NullableInteger() : ParameterizedType_NullableInteger(nullptr) {} ~ParameterizedType_NullableInteger() override; @@ -540,7 +537,7 @@ class ParameterizedType_NullableInteger PROTOBUF_FINAL : void InternalSwap(ParameterizedType_NullableInteger* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.NullableInteger"; + return "substrait.ParameterizedType.NullableInteger"; } protected: explicit ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -567,7 +564,7 @@ class ParameterizedType_NullableInteger PROTOBUF_FINAL : void _internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.NullableInteger) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.NullableInteger) private: class _Internal; @@ -576,12 +573,12 @@ class ParameterizedType_NullableInteger PROTOBUF_FINAL : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::int64 value_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedFixedChar) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedFixedChar) */ { public: inline ParameterizedType_ParameterizedFixedChar() : ParameterizedType_ParameterizedFixedChar(nullptr) {} ~ParameterizedType_ParameterizedFixedChar() override; @@ -671,7 +668,7 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : void InternalSwap(ParameterizedType_ParameterizedFixedChar* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.ParameterizedFixedChar"; + return "substrait.ParameterizedType.ParameterizedFixedChar"; } protected: explicit ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -691,23 +688,23 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; bool has_length() const; private: bool _internal_has_length() const; public: void clear_length(); - const ::io::substrait::ParameterizedType_IntegerOption& length() const; - ::io::substrait::ParameterizedType_IntegerOption* release_length(); - ::io::substrait::ParameterizedType_IntegerOption* mutable_length(); - void set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length); + const ::substrait::ParameterizedType_IntegerOption& length() const; + ::substrait::ParameterizedType_IntegerOption* release_length(); + ::substrait::ParameterizedType_IntegerOption* mutable_length(); + void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length); private: - const ::io::substrait::ParameterizedType_IntegerOption& _internal_length() const; - ::io::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); + const ::substrait::ParameterizedType_IntegerOption& _internal_length() const; + ::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); public: void unsafe_arena_set_allocated_length( - ::io::substrait::ParameterizedType_IntegerOption* length); - ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); + ::substrait::ParameterizedType_IntegerOption* length); + ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); // uint32 variation_pointer = 2; void clear_variation_pointer(); @@ -718,32 +715,32 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedFixedChar) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedFixedChar) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::ParameterizedType_IntegerOption* length_; + ::substrait::ParameterizedType_IntegerOption* length_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedVarChar) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedVarChar) */ { public: inline ParameterizedType_ParameterizedVarChar() : ParameterizedType_ParameterizedVarChar(nullptr) {} ~ParameterizedType_ParameterizedVarChar() override; @@ -833,7 +830,7 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : void InternalSwap(ParameterizedType_ParameterizedVarChar* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.ParameterizedVarChar"; + return "substrait.ParameterizedType.ParameterizedVarChar"; } protected: explicit ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -853,23 +850,23 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; bool has_length() const; private: bool _internal_has_length() const; public: void clear_length(); - const ::io::substrait::ParameterizedType_IntegerOption& length() const; - ::io::substrait::ParameterizedType_IntegerOption* release_length(); - ::io::substrait::ParameterizedType_IntegerOption* mutable_length(); - void set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length); + const ::substrait::ParameterizedType_IntegerOption& length() const; + ::substrait::ParameterizedType_IntegerOption* release_length(); + ::substrait::ParameterizedType_IntegerOption* mutable_length(); + void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length); private: - const ::io::substrait::ParameterizedType_IntegerOption& _internal_length() const; - ::io::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); + const ::substrait::ParameterizedType_IntegerOption& _internal_length() const; + ::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); public: void unsafe_arena_set_allocated_length( - ::io::substrait::ParameterizedType_IntegerOption* length); - ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); + ::substrait::ParameterizedType_IntegerOption* length); + ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); // uint32 variation_pointer = 2; void clear_variation_pointer(); @@ -880,32 +877,32 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedVarChar) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedVarChar) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::ParameterizedType_IntegerOption* length_; + ::substrait::ParameterizedType_IntegerOption* length_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedFixedBinary) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedFixedBinary) */ { public: inline ParameterizedType_ParameterizedFixedBinary() : ParameterizedType_ParameterizedFixedBinary(nullptr) {} ~ParameterizedType_ParameterizedFixedBinary() override; @@ -995,7 +992,7 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : void InternalSwap(ParameterizedType_ParameterizedFixedBinary* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.ParameterizedFixedBinary"; + return "substrait.ParameterizedType.ParameterizedFixedBinary"; } protected: explicit ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1015,23 +1012,23 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.ParameterizedType.IntegerOption length = 1; + // .substrait.ParameterizedType.IntegerOption length = 1; bool has_length() const; private: bool _internal_has_length() const; public: void clear_length(); - const ::io::substrait::ParameterizedType_IntegerOption& length() const; - ::io::substrait::ParameterizedType_IntegerOption* release_length(); - ::io::substrait::ParameterizedType_IntegerOption* mutable_length(); - void set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length); + const ::substrait::ParameterizedType_IntegerOption& length() const; + ::substrait::ParameterizedType_IntegerOption* release_length(); + ::substrait::ParameterizedType_IntegerOption* mutable_length(); + void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length); private: - const ::io::substrait::ParameterizedType_IntegerOption& _internal_length() const; - ::io::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); + const ::substrait::ParameterizedType_IntegerOption& _internal_length() const; + ::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); public: void unsafe_arena_set_allocated_length( - ::io::substrait::ParameterizedType_IntegerOption* length); - ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); + ::substrait::ParameterizedType_IntegerOption* length); + ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); // uint32 variation_pointer = 2; void clear_variation_pointer(); @@ -1042,32 +1039,32 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedFixedBinary) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedFixedBinary) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::ParameterizedType_IntegerOption* length_; + ::substrait::ParameterizedType_IntegerOption* length_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedDecimal) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedDecimal) */ { public: inline ParameterizedType_ParameterizedDecimal() : ParameterizedType_ParameterizedDecimal(nullptr) {} ~ParameterizedType_ParameterizedDecimal() override; @@ -1157,7 +1154,7 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : void InternalSwap(ParameterizedType_ParameterizedDecimal* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.ParameterizedDecimal"; + return "substrait.ParameterizedType.ParameterizedDecimal"; } protected: explicit ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1178,41 +1175,41 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : kVariationPointerFieldNumber = 3, kNullabilityFieldNumber = 4, }; - // .io.substrait.ParameterizedType.IntegerOption scale = 1; + // .substrait.ParameterizedType.IntegerOption scale = 1; bool has_scale() const; private: bool _internal_has_scale() const; public: void clear_scale(); - const ::io::substrait::ParameterizedType_IntegerOption& scale() const; - ::io::substrait::ParameterizedType_IntegerOption* release_scale(); - ::io::substrait::ParameterizedType_IntegerOption* mutable_scale(); - void set_allocated_scale(::io::substrait::ParameterizedType_IntegerOption* scale); + const ::substrait::ParameterizedType_IntegerOption& scale() const; + ::substrait::ParameterizedType_IntegerOption* release_scale(); + ::substrait::ParameterizedType_IntegerOption* mutable_scale(); + void set_allocated_scale(::substrait::ParameterizedType_IntegerOption* scale); private: - const ::io::substrait::ParameterizedType_IntegerOption& _internal_scale() const; - ::io::substrait::ParameterizedType_IntegerOption* _internal_mutable_scale(); + const ::substrait::ParameterizedType_IntegerOption& _internal_scale() const; + ::substrait::ParameterizedType_IntegerOption* _internal_mutable_scale(); public: void unsafe_arena_set_allocated_scale( - ::io::substrait::ParameterizedType_IntegerOption* scale); - ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_scale(); + ::substrait::ParameterizedType_IntegerOption* scale); + ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_scale(); - // .io.substrait.ParameterizedType.IntegerOption precision = 2; + // .substrait.ParameterizedType.IntegerOption precision = 2; bool has_precision() const; private: bool _internal_has_precision() const; public: void clear_precision(); - const ::io::substrait::ParameterizedType_IntegerOption& precision() const; - ::io::substrait::ParameterizedType_IntegerOption* release_precision(); - ::io::substrait::ParameterizedType_IntegerOption* mutable_precision(); - void set_allocated_precision(::io::substrait::ParameterizedType_IntegerOption* precision); + const ::substrait::ParameterizedType_IntegerOption& precision() const; + ::substrait::ParameterizedType_IntegerOption* release_precision(); + ::substrait::ParameterizedType_IntegerOption* mutable_precision(); + void set_allocated_precision(::substrait::ParameterizedType_IntegerOption* precision); private: - const ::io::substrait::ParameterizedType_IntegerOption& _internal_precision() const; - ::io::substrait::ParameterizedType_IntegerOption* _internal_mutable_precision(); + const ::substrait::ParameterizedType_IntegerOption& _internal_precision() const; + ::substrait::ParameterizedType_IntegerOption* _internal_mutable_precision(); public: void unsafe_arena_set_allocated_precision( - ::io::substrait::ParameterizedType_IntegerOption* precision); - ::io::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_precision(); + ::substrait::ParameterizedType_IntegerOption* precision); + ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_precision(); // uint32 variation_pointer = 3; void clear_variation_pointer(); @@ -1223,33 +1220,33 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedDecimal) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedDecimal) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::ParameterizedType_IntegerOption* scale_; - ::io::substrait::ParameterizedType_IntegerOption* precision_; + ::substrait::ParameterizedType_IntegerOption* scale_; + ::substrait::ParameterizedType_IntegerOption* precision_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedStruct) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedStruct) */ { public: inline ParameterizedType_ParameterizedStruct() : ParameterizedType_ParameterizedStruct(nullptr) {} ~ParameterizedType_ParameterizedStruct() override; @@ -1339,7 +1336,7 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : void InternalSwap(ParameterizedType_ParameterizedStruct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.ParameterizedStruct"; + return "substrait.ParameterizedType.ParameterizedStruct"; } protected: explicit ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1359,22 +1356,22 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // repeated .io.substrait.ParameterizedType types = 1; + // repeated .substrait.ParameterizedType types = 1; int types_size() const; private: int _internal_types_size() const; public: void clear_types(); - ::io::substrait::ParameterizedType* mutable_types(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >* + ::substrait::ParameterizedType* mutable_types(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >* mutable_types(); private: - const ::io::substrait::ParameterizedType& _internal_types(int index) const; - ::io::substrait::ParameterizedType* _internal_add_types(); + const ::substrait::ParameterizedType& _internal_types(int index) const; + ::substrait::ParameterizedType* _internal_add_types(); public: - const ::io::substrait::ParameterizedType& types(int index) const; - ::io::substrait::ParameterizedType* add_types(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >& + const ::substrait::ParameterizedType& types(int index) const; + ::substrait::ParameterizedType* add_types(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >& types() const; // uint32 variation_pointer = 2; @@ -1386,32 +1383,32 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedStruct) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedStruct) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType > types_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType > types_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedNamedStruct) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedNamedStruct) */ { public: inline ParameterizedType_ParameterizedNamedStruct() : ParameterizedType_ParameterizedNamedStruct(nullptr) {} ~ParameterizedType_ParameterizedNamedStruct() override; @@ -1501,7 +1498,7 @@ class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : void InternalSwap(ParameterizedType_ParameterizedNamedStruct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.ParameterizedNamedStruct"; + return "substrait.ParameterizedType.ParameterizedNamedStruct"; } protected: explicit ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1544,25 +1541,25 @@ class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : std::string* _internal_add_names(); public: - // .io.substrait.ParameterizedType.ParameterizedStruct struct = 2; + // .substrait.ParameterizedType.ParameterizedStruct struct = 2; bool has_struct_() const; private: bool _internal_has_struct_() const; public: void clear_struct_(); - const ::io::substrait::ParameterizedType_ParameterizedStruct& struct_() const; - ::io::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); - ::io::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_(); - void set_allocated_struct_(::io::substrait::ParameterizedType_ParameterizedStruct* struct_); + const ::substrait::ParameterizedType_ParameterizedStruct& struct_() const; + ::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); + ::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_(); + void set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_); private: - const ::io::substrait::ParameterizedType_ParameterizedStruct& _internal_struct_() const; - ::io::substrait::ParameterizedType_ParameterizedStruct* _internal_mutable_struct_(); + const ::substrait::ParameterizedType_ParameterizedStruct& _internal_struct_() const; + ::substrait::ParameterizedType_ParameterizedStruct* _internal_mutable_struct_(); public: void unsafe_arena_set_allocated_struct_( - ::io::substrait::ParameterizedType_ParameterizedStruct* struct_); - ::io::substrait::ParameterizedType_ParameterizedStruct* unsafe_arena_release_struct_(); + ::substrait::ParameterizedType_ParameterizedStruct* struct_); + ::substrait::ParameterizedType_ParameterizedStruct* unsafe_arena_release_struct_(); - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedNamedStruct) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedNamedStruct) private: class _Internal; @@ -1570,14 +1567,14 @@ class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::io::substrait::ParameterizedType_ParameterizedStruct* struct__; + ::substrait::ParameterizedType_ParameterizedStruct* struct__; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_ParameterizedList PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedList) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedList) */ { public: inline ParameterizedType_ParameterizedList() : ParameterizedType_ParameterizedList(nullptr) {} ~ParameterizedType_ParameterizedList() override; @@ -1667,7 +1664,7 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : void InternalSwap(ParameterizedType_ParameterizedList* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.ParameterizedList"; + return "substrait.ParameterizedType.ParameterizedList"; } protected: explicit ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1687,23 +1684,23 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.ParameterizedType type = 1; + // .substrait.ParameterizedType type = 1; bool has_type() const; private: bool _internal_has_type() const; public: void clear_type(); - const ::io::substrait::ParameterizedType& type() const; - ::io::substrait::ParameterizedType* release_type(); - ::io::substrait::ParameterizedType* mutable_type(); - void set_allocated_type(::io::substrait::ParameterizedType* type); + const ::substrait::ParameterizedType& type() const; + ::substrait::ParameterizedType* release_type(); + ::substrait::ParameterizedType* mutable_type(); + void set_allocated_type(::substrait::ParameterizedType* type); private: - const ::io::substrait::ParameterizedType& _internal_type() const; - ::io::substrait::ParameterizedType* _internal_mutable_type(); + const ::substrait::ParameterizedType& _internal_type() const; + ::substrait::ParameterizedType* _internal_mutable_type(); public: void unsafe_arena_set_allocated_type( - ::io::substrait::ParameterizedType* type); - ::io::substrait::ParameterizedType* unsafe_arena_release_type(); + ::substrait::ParameterizedType* type); + ::substrait::ParameterizedType* unsafe_arena_release_type(); // uint32 variation_pointer = 2; void clear_variation_pointer(); @@ -1714,32 +1711,32 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedList) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedList) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::ParameterizedType* type_; + ::substrait::ParameterizedType* type_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.ParameterizedMap) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedMap) */ { public: inline ParameterizedType_ParameterizedMap() : ParameterizedType_ParameterizedMap(nullptr) {} ~ParameterizedType_ParameterizedMap() override; @@ -1829,7 +1826,7 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : void InternalSwap(ParameterizedType_ParameterizedMap* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.ParameterizedMap"; + return "substrait.ParameterizedType.ParameterizedMap"; } protected: explicit ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1850,41 +1847,41 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : kVariationPointerFieldNumber = 3, kNullabilityFieldNumber = 4, }; - // .io.substrait.ParameterizedType key = 1; + // .substrait.ParameterizedType key = 1; bool has_key() const; private: bool _internal_has_key() const; public: void clear_key(); - const ::io::substrait::ParameterizedType& key() const; - ::io::substrait::ParameterizedType* release_key(); - ::io::substrait::ParameterizedType* mutable_key(); - void set_allocated_key(::io::substrait::ParameterizedType* key); + const ::substrait::ParameterizedType& key() const; + ::substrait::ParameterizedType* release_key(); + ::substrait::ParameterizedType* mutable_key(); + void set_allocated_key(::substrait::ParameterizedType* key); private: - const ::io::substrait::ParameterizedType& _internal_key() const; - ::io::substrait::ParameterizedType* _internal_mutable_key(); + const ::substrait::ParameterizedType& _internal_key() const; + ::substrait::ParameterizedType* _internal_mutable_key(); public: void unsafe_arena_set_allocated_key( - ::io::substrait::ParameterizedType* key); - ::io::substrait::ParameterizedType* unsafe_arena_release_key(); + ::substrait::ParameterizedType* key); + ::substrait::ParameterizedType* unsafe_arena_release_key(); - // .io.substrait.ParameterizedType value = 2; + // .substrait.ParameterizedType value = 2; bool has_value() const; private: bool _internal_has_value() const; public: void clear_value(); - const ::io::substrait::ParameterizedType& value() const; - ::io::substrait::ParameterizedType* release_value(); - ::io::substrait::ParameterizedType* mutable_value(); - void set_allocated_value(::io::substrait::ParameterizedType* value); + const ::substrait::ParameterizedType& value() const; + ::substrait::ParameterizedType* release_value(); + ::substrait::ParameterizedType* mutable_value(); + void set_allocated_value(::substrait::ParameterizedType* value); private: - const ::io::substrait::ParameterizedType& _internal_value() const; - ::io::substrait::ParameterizedType* _internal_mutable_value(); + const ::substrait::ParameterizedType& _internal_value() const; + ::substrait::ParameterizedType* _internal_mutable_value(); public: void unsafe_arena_set_allocated_value( - ::io::substrait::ParameterizedType* value); - ::io::substrait::ParameterizedType* unsafe_arena_release_value(); + ::substrait::ParameterizedType* value); + ::substrait::ParameterizedType* unsafe_arena_release_value(); // uint32 variation_pointer = 3; void clear_variation_pointer(); @@ -1895,33 +1892,33 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.ParameterizedMap) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedMap) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::ParameterizedType* key_; - ::io::substrait::ParameterizedType* value_; + ::substrait::ParameterizedType* key_; + ::substrait::ParameterizedType* value_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType_IntegerOption PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType.IntegerOption) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.IntegerOption) */ { public: inline ParameterizedType_IntegerOption() : ParameterizedType_IntegerOption(nullptr) {} ~ParameterizedType_IntegerOption() override; @@ -2017,7 +2014,7 @@ class ParameterizedType_IntegerOption PROTOBUF_FINAL : void InternalSwap(ParameterizedType_IntegerOption* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType.IntegerOption"; + return "substrait.ParameterizedType.IntegerOption"; } protected: explicit ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2049,27 +2046,27 @@ class ParameterizedType_IntegerOption PROTOBUF_FINAL : void _internal_set_literal(::PROTOBUF_NAMESPACE_ID::int32 value); public: - // .io.substrait.ParameterizedType.IntegerParameter parameter = 2; + // .substrait.ParameterizedType.IntegerParameter parameter = 2; bool has_parameter() const; private: bool _internal_has_parameter() const; public: void clear_parameter(); - const ::io::substrait::ParameterizedType_IntegerParameter& parameter() const; - ::io::substrait::ParameterizedType_IntegerParameter* release_parameter(); - ::io::substrait::ParameterizedType_IntegerParameter* mutable_parameter(); - void set_allocated_parameter(::io::substrait::ParameterizedType_IntegerParameter* parameter); + const ::substrait::ParameterizedType_IntegerParameter& parameter() const; + ::substrait::ParameterizedType_IntegerParameter* release_parameter(); + ::substrait::ParameterizedType_IntegerParameter* mutable_parameter(); + void set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter); private: - const ::io::substrait::ParameterizedType_IntegerParameter& _internal_parameter() const; - ::io::substrait::ParameterizedType_IntegerParameter* _internal_mutable_parameter(); + const ::substrait::ParameterizedType_IntegerParameter& _internal_parameter() const; + ::substrait::ParameterizedType_IntegerParameter* _internal_mutable_parameter(); public: void unsafe_arena_set_allocated_parameter( - ::io::substrait::ParameterizedType_IntegerParameter* parameter); - ::io::substrait::ParameterizedType_IntegerParameter* unsafe_arena_release_parameter(); + ::substrait::ParameterizedType_IntegerParameter* parameter); + ::substrait::ParameterizedType_IntegerParameter* unsafe_arena_release_parameter(); void clear_integer_type(); IntegerTypeCase integer_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType.IntegerOption) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.IntegerOption) private: class _Internal; void set_has_literal(); @@ -2085,17 +2082,17 @@ class ParameterizedType_IntegerOption PROTOBUF_FINAL : constexpr IntegerTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::PROTOBUF_NAMESPACE_ID::int32 literal_; - ::io::substrait::ParameterizedType_IntegerParameter* parameter_; + ::substrait::ParameterizedType_IntegerParameter* parameter_; } integer_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- class ParameterizedType PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ParameterizedType) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType) */ { public: inline ParameterizedType() : ParameterizedType(nullptr) {} ~ParameterizedType() override; @@ -2214,7 +2211,7 @@ class ParameterizedType PROTOBUF_FINAL : void InternalSwap(ParameterizedType* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ParameterizedType"; + return "substrait.ParameterizedType"; } protected: explicit ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2269,419 +2266,419 @@ class ParameterizedType PROTOBUF_FINAL : kUserDefinedPointerFieldNumber = 31, kTypeParameterFieldNumber = 33, }; - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; bool has_bool_() const; private: bool _internal_has_bool_() const; public: void clear_bool_(); - const ::io::substrait::Type_Boolean& bool_() const; - ::io::substrait::Type_Boolean* release_bool_(); - ::io::substrait::Type_Boolean* mutable_bool_(); - void set_allocated_bool_(::io::substrait::Type_Boolean* bool_); + const ::substrait::Type_Boolean& bool_() const; + ::substrait::Type_Boolean* release_bool_(); + ::substrait::Type_Boolean* mutable_bool_(); + void set_allocated_bool_(::substrait::Type_Boolean* bool_); private: - const ::io::substrait::Type_Boolean& _internal_bool_() const; - ::io::substrait::Type_Boolean* _internal_mutable_bool_(); + const ::substrait::Type_Boolean& _internal_bool_() const; + ::substrait::Type_Boolean* _internal_mutable_bool_(); public: void unsafe_arena_set_allocated_bool_( - ::io::substrait::Type_Boolean* bool_); - ::io::substrait::Type_Boolean* unsafe_arena_release_bool_(); + ::substrait::Type_Boolean* bool_); + ::substrait::Type_Boolean* unsafe_arena_release_bool_(); - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; bool has_i8() const; private: bool _internal_has_i8() const; public: void clear_i8(); - const ::io::substrait::Type_I8& i8() const; - ::io::substrait::Type_I8* release_i8(); - ::io::substrait::Type_I8* mutable_i8(); - void set_allocated_i8(::io::substrait::Type_I8* i8); + const ::substrait::Type_I8& i8() const; + ::substrait::Type_I8* release_i8(); + ::substrait::Type_I8* mutable_i8(); + void set_allocated_i8(::substrait::Type_I8* i8); private: - const ::io::substrait::Type_I8& _internal_i8() const; - ::io::substrait::Type_I8* _internal_mutable_i8(); + const ::substrait::Type_I8& _internal_i8() const; + ::substrait::Type_I8* _internal_mutable_i8(); public: void unsafe_arena_set_allocated_i8( - ::io::substrait::Type_I8* i8); - ::io::substrait::Type_I8* unsafe_arena_release_i8(); + ::substrait::Type_I8* i8); + ::substrait::Type_I8* unsafe_arena_release_i8(); - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; bool has_i16() const; private: bool _internal_has_i16() const; public: void clear_i16(); - const ::io::substrait::Type_I16& i16() const; - ::io::substrait::Type_I16* release_i16(); - ::io::substrait::Type_I16* mutable_i16(); - void set_allocated_i16(::io::substrait::Type_I16* i16); + const ::substrait::Type_I16& i16() const; + ::substrait::Type_I16* release_i16(); + ::substrait::Type_I16* mutable_i16(); + void set_allocated_i16(::substrait::Type_I16* i16); private: - const ::io::substrait::Type_I16& _internal_i16() const; - ::io::substrait::Type_I16* _internal_mutable_i16(); + const ::substrait::Type_I16& _internal_i16() const; + ::substrait::Type_I16* _internal_mutable_i16(); public: void unsafe_arena_set_allocated_i16( - ::io::substrait::Type_I16* i16); - ::io::substrait::Type_I16* unsafe_arena_release_i16(); + ::substrait::Type_I16* i16); + ::substrait::Type_I16* unsafe_arena_release_i16(); - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; bool has_i32() const; private: bool _internal_has_i32() const; public: void clear_i32(); - const ::io::substrait::Type_I32& i32() const; - ::io::substrait::Type_I32* release_i32(); - ::io::substrait::Type_I32* mutable_i32(); - void set_allocated_i32(::io::substrait::Type_I32* i32); + const ::substrait::Type_I32& i32() const; + ::substrait::Type_I32* release_i32(); + ::substrait::Type_I32* mutable_i32(); + void set_allocated_i32(::substrait::Type_I32* i32); private: - const ::io::substrait::Type_I32& _internal_i32() const; - ::io::substrait::Type_I32* _internal_mutable_i32(); + const ::substrait::Type_I32& _internal_i32() const; + ::substrait::Type_I32* _internal_mutable_i32(); public: void unsafe_arena_set_allocated_i32( - ::io::substrait::Type_I32* i32); - ::io::substrait::Type_I32* unsafe_arena_release_i32(); + ::substrait::Type_I32* i32); + ::substrait::Type_I32* unsafe_arena_release_i32(); - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; bool has_i64() const; private: bool _internal_has_i64() const; public: void clear_i64(); - const ::io::substrait::Type_I64& i64() const; - ::io::substrait::Type_I64* release_i64(); - ::io::substrait::Type_I64* mutable_i64(); - void set_allocated_i64(::io::substrait::Type_I64* i64); + const ::substrait::Type_I64& i64() const; + ::substrait::Type_I64* release_i64(); + ::substrait::Type_I64* mutable_i64(); + void set_allocated_i64(::substrait::Type_I64* i64); private: - const ::io::substrait::Type_I64& _internal_i64() const; - ::io::substrait::Type_I64* _internal_mutable_i64(); + const ::substrait::Type_I64& _internal_i64() const; + ::substrait::Type_I64* _internal_mutable_i64(); public: void unsafe_arena_set_allocated_i64( - ::io::substrait::Type_I64* i64); - ::io::substrait::Type_I64* unsafe_arena_release_i64(); + ::substrait::Type_I64* i64); + ::substrait::Type_I64* unsafe_arena_release_i64(); - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; bool has_fp32() const; private: bool _internal_has_fp32() const; public: void clear_fp32(); - const ::io::substrait::Type_FP32& fp32() const; - ::io::substrait::Type_FP32* release_fp32(); - ::io::substrait::Type_FP32* mutable_fp32(); - void set_allocated_fp32(::io::substrait::Type_FP32* fp32); + const ::substrait::Type_FP32& fp32() const; + ::substrait::Type_FP32* release_fp32(); + ::substrait::Type_FP32* mutable_fp32(); + void set_allocated_fp32(::substrait::Type_FP32* fp32); private: - const ::io::substrait::Type_FP32& _internal_fp32() const; - ::io::substrait::Type_FP32* _internal_mutable_fp32(); + const ::substrait::Type_FP32& _internal_fp32() const; + ::substrait::Type_FP32* _internal_mutable_fp32(); public: void unsafe_arena_set_allocated_fp32( - ::io::substrait::Type_FP32* fp32); - ::io::substrait::Type_FP32* unsafe_arena_release_fp32(); + ::substrait::Type_FP32* fp32); + ::substrait::Type_FP32* unsafe_arena_release_fp32(); - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; bool has_fp64() const; private: bool _internal_has_fp64() const; public: void clear_fp64(); - const ::io::substrait::Type_FP64& fp64() const; - ::io::substrait::Type_FP64* release_fp64(); - ::io::substrait::Type_FP64* mutable_fp64(); - void set_allocated_fp64(::io::substrait::Type_FP64* fp64); + const ::substrait::Type_FP64& fp64() const; + ::substrait::Type_FP64* release_fp64(); + ::substrait::Type_FP64* mutable_fp64(); + void set_allocated_fp64(::substrait::Type_FP64* fp64); private: - const ::io::substrait::Type_FP64& _internal_fp64() const; - ::io::substrait::Type_FP64* _internal_mutable_fp64(); + const ::substrait::Type_FP64& _internal_fp64() const; + ::substrait::Type_FP64* _internal_mutable_fp64(); public: void unsafe_arena_set_allocated_fp64( - ::io::substrait::Type_FP64* fp64); - ::io::substrait::Type_FP64* unsafe_arena_release_fp64(); + ::substrait::Type_FP64* fp64); + ::substrait::Type_FP64* unsafe_arena_release_fp64(); - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; bool has_string() const; private: bool _internal_has_string() const; public: void clear_string(); - const ::io::substrait::Type_String& string() const; - ::io::substrait::Type_String* release_string(); - ::io::substrait::Type_String* mutable_string(); - void set_allocated_string(::io::substrait::Type_String* string); + const ::substrait::Type_String& string() const; + ::substrait::Type_String* release_string(); + ::substrait::Type_String* mutable_string(); + void set_allocated_string(::substrait::Type_String* string); private: - const ::io::substrait::Type_String& _internal_string() const; - ::io::substrait::Type_String* _internal_mutable_string(); + const ::substrait::Type_String& _internal_string() const; + ::substrait::Type_String* _internal_mutable_string(); public: void unsafe_arena_set_allocated_string( - ::io::substrait::Type_String* string); - ::io::substrait::Type_String* unsafe_arena_release_string(); + ::substrait::Type_String* string); + ::substrait::Type_String* unsafe_arena_release_string(); - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; bool has_binary() const; private: bool _internal_has_binary() const; public: void clear_binary(); - const ::io::substrait::Type_Binary& binary() const; - ::io::substrait::Type_Binary* release_binary(); - ::io::substrait::Type_Binary* mutable_binary(); - void set_allocated_binary(::io::substrait::Type_Binary* binary); + const ::substrait::Type_Binary& binary() const; + ::substrait::Type_Binary* release_binary(); + ::substrait::Type_Binary* mutable_binary(); + void set_allocated_binary(::substrait::Type_Binary* binary); private: - const ::io::substrait::Type_Binary& _internal_binary() const; - ::io::substrait::Type_Binary* _internal_mutable_binary(); + const ::substrait::Type_Binary& _internal_binary() const; + ::substrait::Type_Binary* _internal_mutable_binary(); public: void unsafe_arena_set_allocated_binary( - ::io::substrait::Type_Binary* binary); - ::io::substrait::Type_Binary* unsafe_arena_release_binary(); + ::substrait::Type_Binary* binary); + ::substrait::Type_Binary* unsafe_arena_release_binary(); - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; bool has_timestamp() const; private: bool _internal_has_timestamp() const; public: void clear_timestamp(); - const ::io::substrait::Type_Timestamp& timestamp() const; - ::io::substrait::Type_Timestamp* release_timestamp(); - ::io::substrait::Type_Timestamp* mutable_timestamp(); - void set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp); + const ::substrait::Type_Timestamp& timestamp() const; + ::substrait::Type_Timestamp* release_timestamp(); + ::substrait::Type_Timestamp* mutable_timestamp(); + void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp); private: - const ::io::substrait::Type_Timestamp& _internal_timestamp() const; - ::io::substrait::Type_Timestamp* _internal_mutable_timestamp(); + const ::substrait::Type_Timestamp& _internal_timestamp() const; + ::substrait::Type_Timestamp* _internal_mutable_timestamp(); public: void unsafe_arena_set_allocated_timestamp( - ::io::substrait::Type_Timestamp* timestamp); - ::io::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); + ::substrait::Type_Timestamp* timestamp); + ::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; bool has_date() const; private: bool _internal_has_date() const; public: void clear_date(); - const ::io::substrait::Type_Date& date() const; - ::io::substrait::Type_Date* release_date(); - ::io::substrait::Type_Date* mutable_date(); - void set_allocated_date(::io::substrait::Type_Date* date); + const ::substrait::Type_Date& date() const; + ::substrait::Type_Date* release_date(); + ::substrait::Type_Date* mutable_date(); + void set_allocated_date(::substrait::Type_Date* date); private: - const ::io::substrait::Type_Date& _internal_date() const; - ::io::substrait::Type_Date* _internal_mutable_date(); + const ::substrait::Type_Date& _internal_date() const; + ::substrait::Type_Date* _internal_mutable_date(); public: void unsafe_arena_set_allocated_date( - ::io::substrait::Type_Date* date); - ::io::substrait::Type_Date* unsafe_arena_release_date(); + ::substrait::Type_Date* date); + ::substrait::Type_Date* unsafe_arena_release_date(); - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; bool has_time() const; private: bool _internal_has_time() const; public: void clear_time(); - const ::io::substrait::Type_Time& time() const; - ::io::substrait::Type_Time* release_time(); - ::io::substrait::Type_Time* mutable_time(); - void set_allocated_time(::io::substrait::Type_Time* time); + const ::substrait::Type_Time& time() const; + ::substrait::Type_Time* release_time(); + ::substrait::Type_Time* mutable_time(); + void set_allocated_time(::substrait::Type_Time* time); private: - const ::io::substrait::Type_Time& _internal_time() const; - ::io::substrait::Type_Time* _internal_mutable_time(); + const ::substrait::Type_Time& _internal_time() const; + ::substrait::Type_Time* _internal_mutable_time(); public: void unsafe_arena_set_allocated_time( - ::io::substrait::Type_Time* time); - ::io::substrait::Type_Time* unsafe_arena_release_time(); + ::substrait::Type_Time* time); + ::substrait::Type_Time* unsafe_arena_release_time(); - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; bool has_interval_year() const; private: bool _internal_has_interval_year() const; public: void clear_interval_year(); - const ::io::substrait::Type_IntervalYear& interval_year() const; - ::io::substrait::Type_IntervalYear* release_interval_year(); - ::io::substrait::Type_IntervalYear* mutable_interval_year(); - void set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year); + const ::substrait::Type_IntervalYear& interval_year() const; + ::substrait::Type_IntervalYear* release_interval_year(); + ::substrait::Type_IntervalYear* mutable_interval_year(); + void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year); private: - const ::io::substrait::Type_IntervalYear& _internal_interval_year() const; - ::io::substrait::Type_IntervalYear* _internal_mutable_interval_year(); + const ::substrait::Type_IntervalYear& _internal_interval_year() const; + ::substrait::Type_IntervalYear* _internal_mutable_interval_year(); public: void unsafe_arena_set_allocated_interval_year( - ::io::substrait::Type_IntervalYear* interval_year); - ::io::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); + ::substrait::Type_IntervalYear* interval_year); + ::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; bool has_interval_day() const; private: bool _internal_has_interval_day() const; public: void clear_interval_day(); - const ::io::substrait::Type_IntervalDay& interval_day() const; - ::io::substrait::Type_IntervalDay* release_interval_day(); - ::io::substrait::Type_IntervalDay* mutable_interval_day(); - void set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day); + const ::substrait::Type_IntervalDay& interval_day() const; + ::substrait::Type_IntervalDay* release_interval_day(); + ::substrait::Type_IntervalDay* mutable_interval_day(); + void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day); private: - const ::io::substrait::Type_IntervalDay& _internal_interval_day() const; - ::io::substrait::Type_IntervalDay* _internal_mutable_interval_day(); + const ::substrait::Type_IntervalDay& _internal_interval_day() const; + ::substrait::Type_IntervalDay* _internal_mutable_interval_day(); public: void unsafe_arena_set_allocated_interval_day( - ::io::substrait::Type_IntervalDay* interval_day); - ::io::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); + ::substrait::Type_IntervalDay* interval_day); + ::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; bool has_timestamp_tz() const; private: bool _internal_has_timestamp_tz() const; public: void clear_timestamp_tz(); - const ::io::substrait::Type_TimestampTZ& timestamp_tz() const; - ::io::substrait::Type_TimestampTZ* release_timestamp_tz(); - ::io::substrait::Type_TimestampTZ* mutable_timestamp_tz(); - void set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz); + const ::substrait::Type_TimestampTZ& timestamp_tz() const; + ::substrait::Type_TimestampTZ* release_timestamp_tz(); + ::substrait::Type_TimestampTZ* mutable_timestamp_tz(); + void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz); private: - const ::io::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; - ::io::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); + const ::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; + ::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); public: void unsafe_arena_set_allocated_timestamp_tz( - ::io::substrait::Type_TimestampTZ* timestamp_tz); - ::io::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); + ::substrait::Type_TimestampTZ* timestamp_tz); + ::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; bool has_uuid() const; private: bool _internal_has_uuid() const; public: void clear_uuid(); - const ::io::substrait::Type_UUID& uuid() const; - ::io::substrait::Type_UUID* release_uuid(); - ::io::substrait::Type_UUID* mutable_uuid(); - void set_allocated_uuid(::io::substrait::Type_UUID* uuid); + const ::substrait::Type_UUID& uuid() const; + ::substrait::Type_UUID* release_uuid(); + ::substrait::Type_UUID* mutable_uuid(); + void set_allocated_uuid(::substrait::Type_UUID* uuid); private: - const ::io::substrait::Type_UUID& _internal_uuid() const; - ::io::substrait::Type_UUID* _internal_mutable_uuid(); + const ::substrait::Type_UUID& _internal_uuid() const; + ::substrait::Type_UUID* _internal_mutable_uuid(); public: void unsafe_arena_set_allocated_uuid( - ::io::substrait::Type_UUID* uuid); - ::io::substrait::Type_UUID* unsafe_arena_release_uuid(); + ::substrait::Type_UUID* uuid); + ::substrait::Type_UUID* unsafe_arena_release_uuid(); - // .io.substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; + // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; bool has_fixed_char() const; private: bool _internal_has_fixed_char() const; public: void clear_fixed_char(); - const ::io::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char() const; - ::io::substrait::ParameterizedType_ParameterizedFixedChar* release_fixed_char(); - ::io::substrait::ParameterizedType_ParameterizedFixedChar* mutable_fixed_char(); - void set_allocated_fixed_char(::io::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char); + const ::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char() const; + ::substrait::ParameterizedType_ParameterizedFixedChar* release_fixed_char(); + ::substrait::ParameterizedType_ParameterizedFixedChar* mutable_fixed_char(); + void set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char); private: - const ::io::substrait::ParameterizedType_ParameterizedFixedChar& _internal_fixed_char() const; - ::io::substrait::ParameterizedType_ParameterizedFixedChar* _internal_mutable_fixed_char(); + const ::substrait::ParameterizedType_ParameterizedFixedChar& _internal_fixed_char() const; + ::substrait::ParameterizedType_ParameterizedFixedChar* _internal_mutable_fixed_char(); public: void unsafe_arena_set_allocated_fixed_char( - ::io::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char); - ::io::substrait::ParameterizedType_ParameterizedFixedChar* unsafe_arena_release_fixed_char(); + ::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char); + ::substrait::ParameterizedType_ParameterizedFixedChar* unsafe_arena_release_fixed_char(); - // .io.substrait.ParameterizedType.ParameterizedVarChar varchar = 22; + // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; bool has_varchar() const; private: bool _internal_has_varchar() const; public: void clear_varchar(); - const ::io::substrait::ParameterizedType_ParameterizedVarChar& varchar() const; - ::io::substrait::ParameterizedType_ParameterizedVarChar* release_varchar(); - ::io::substrait::ParameterizedType_ParameterizedVarChar* mutable_varchar(); - void set_allocated_varchar(::io::substrait::ParameterizedType_ParameterizedVarChar* varchar); + const ::substrait::ParameterizedType_ParameterizedVarChar& varchar() const; + ::substrait::ParameterizedType_ParameterizedVarChar* release_varchar(); + ::substrait::ParameterizedType_ParameterizedVarChar* mutable_varchar(); + void set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar); private: - const ::io::substrait::ParameterizedType_ParameterizedVarChar& _internal_varchar() const; - ::io::substrait::ParameterizedType_ParameterizedVarChar* _internal_mutable_varchar(); + const ::substrait::ParameterizedType_ParameterizedVarChar& _internal_varchar() const; + ::substrait::ParameterizedType_ParameterizedVarChar* _internal_mutable_varchar(); public: void unsafe_arena_set_allocated_varchar( - ::io::substrait::ParameterizedType_ParameterizedVarChar* varchar); - ::io::substrait::ParameterizedType_ParameterizedVarChar* unsafe_arena_release_varchar(); + ::substrait::ParameterizedType_ParameterizedVarChar* varchar); + ::substrait::ParameterizedType_ParameterizedVarChar* unsafe_arena_release_varchar(); - // .io.substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; + // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; bool has_fixed_binary() const; private: bool _internal_has_fixed_binary() const; public: void clear_fixed_binary(); - const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary() const; - ::io::substrait::ParameterizedType_ParameterizedFixedBinary* release_fixed_binary(); - ::io::substrait::ParameterizedType_ParameterizedFixedBinary* mutable_fixed_binary(); - void set_allocated_fixed_binary(::io::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary); + const ::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary() const; + ::substrait::ParameterizedType_ParameterizedFixedBinary* release_fixed_binary(); + ::substrait::ParameterizedType_ParameterizedFixedBinary* mutable_fixed_binary(); + void set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary); private: - const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& _internal_fixed_binary() const; - ::io::substrait::ParameterizedType_ParameterizedFixedBinary* _internal_mutable_fixed_binary(); + const ::substrait::ParameterizedType_ParameterizedFixedBinary& _internal_fixed_binary() const; + ::substrait::ParameterizedType_ParameterizedFixedBinary* _internal_mutable_fixed_binary(); public: void unsafe_arena_set_allocated_fixed_binary( - ::io::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary); - ::io::substrait::ParameterizedType_ParameterizedFixedBinary* unsafe_arena_release_fixed_binary(); + ::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary); + ::substrait::ParameterizedType_ParameterizedFixedBinary* unsafe_arena_release_fixed_binary(); - // .io.substrait.ParameterizedType.ParameterizedDecimal decimal = 24; + // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; bool has_decimal() const; private: bool _internal_has_decimal() const; public: void clear_decimal(); - const ::io::substrait::ParameterizedType_ParameterizedDecimal& decimal() const; - ::io::substrait::ParameterizedType_ParameterizedDecimal* release_decimal(); - ::io::substrait::ParameterizedType_ParameterizedDecimal* mutable_decimal(); - void set_allocated_decimal(::io::substrait::ParameterizedType_ParameterizedDecimal* decimal); + const ::substrait::ParameterizedType_ParameterizedDecimal& decimal() const; + ::substrait::ParameterizedType_ParameterizedDecimal* release_decimal(); + ::substrait::ParameterizedType_ParameterizedDecimal* mutable_decimal(); + void set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal); private: - const ::io::substrait::ParameterizedType_ParameterizedDecimal& _internal_decimal() const; - ::io::substrait::ParameterizedType_ParameterizedDecimal* _internal_mutable_decimal(); + const ::substrait::ParameterizedType_ParameterizedDecimal& _internal_decimal() const; + ::substrait::ParameterizedType_ParameterizedDecimal* _internal_mutable_decimal(); public: void unsafe_arena_set_allocated_decimal( - ::io::substrait::ParameterizedType_ParameterizedDecimal* decimal); - ::io::substrait::ParameterizedType_ParameterizedDecimal* unsafe_arena_release_decimal(); + ::substrait::ParameterizedType_ParameterizedDecimal* decimal); + ::substrait::ParameterizedType_ParameterizedDecimal* unsafe_arena_release_decimal(); - // .io.substrait.ParameterizedType.ParameterizedStruct struct = 25; + // .substrait.ParameterizedType.ParameterizedStruct struct = 25; bool has_struct_() const; private: bool _internal_has_struct_() const; public: void clear_struct_(); - const ::io::substrait::ParameterizedType_ParameterizedStruct& struct_() const; - ::io::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); - ::io::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_(); - void set_allocated_struct_(::io::substrait::ParameterizedType_ParameterizedStruct* struct_); + const ::substrait::ParameterizedType_ParameterizedStruct& struct_() const; + ::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); + ::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_(); + void set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_); private: - const ::io::substrait::ParameterizedType_ParameterizedStruct& _internal_struct_() const; - ::io::substrait::ParameterizedType_ParameterizedStruct* _internal_mutable_struct_(); + const ::substrait::ParameterizedType_ParameterizedStruct& _internal_struct_() const; + ::substrait::ParameterizedType_ParameterizedStruct* _internal_mutable_struct_(); public: void unsafe_arena_set_allocated_struct_( - ::io::substrait::ParameterizedType_ParameterizedStruct* struct_); - ::io::substrait::ParameterizedType_ParameterizedStruct* unsafe_arena_release_struct_(); + ::substrait::ParameterizedType_ParameterizedStruct* struct_); + ::substrait::ParameterizedType_ParameterizedStruct* unsafe_arena_release_struct_(); - // .io.substrait.ParameterizedType.ParameterizedList list = 27; + // .substrait.ParameterizedType.ParameterizedList list = 27; bool has_list() const; private: bool _internal_has_list() const; public: void clear_list(); - const ::io::substrait::ParameterizedType_ParameterizedList& list() const; - ::io::substrait::ParameterizedType_ParameterizedList* release_list(); - ::io::substrait::ParameterizedType_ParameterizedList* mutable_list(); - void set_allocated_list(::io::substrait::ParameterizedType_ParameterizedList* list); + const ::substrait::ParameterizedType_ParameterizedList& list() const; + ::substrait::ParameterizedType_ParameterizedList* release_list(); + ::substrait::ParameterizedType_ParameterizedList* mutable_list(); + void set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list); private: - const ::io::substrait::ParameterizedType_ParameterizedList& _internal_list() const; - ::io::substrait::ParameterizedType_ParameterizedList* _internal_mutable_list(); + const ::substrait::ParameterizedType_ParameterizedList& _internal_list() const; + ::substrait::ParameterizedType_ParameterizedList* _internal_mutable_list(); public: void unsafe_arena_set_allocated_list( - ::io::substrait::ParameterizedType_ParameterizedList* list); - ::io::substrait::ParameterizedType_ParameterizedList* unsafe_arena_release_list(); + ::substrait::ParameterizedType_ParameterizedList* list); + ::substrait::ParameterizedType_ParameterizedList* unsafe_arena_release_list(); - // .io.substrait.ParameterizedType.ParameterizedMap map = 28; + // .substrait.ParameterizedType.ParameterizedMap map = 28; bool has_map() const; private: bool _internal_has_map() const; public: void clear_map(); - const ::io::substrait::ParameterizedType_ParameterizedMap& map() const; - ::io::substrait::ParameterizedType_ParameterizedMap* release_map(); - ::io::substrait::ParameterizedType_ParameterizedMap* mutable_map(); - void set_allocated_map(::io::substrait::ParameterizedType_ParameterizedMap* map); + const ::substrait::ParameterizedType_ParameterizedMap& map() const; + ::substrait::ParameterizedType_ParameterizedMap* release_map(); + ::substrait::ParameterizedType_ParameterizedMap* mutable_map(); + void set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map); private: - const ::io::substrait::ParameterizedType_ParameterizedMap& _internal_map() const; - ::io::substrait::ParameterizedType_ParameterizedMap* _internal_mutable_map(); + const ::substrait::ParameterizedType_ParameterizedMap& _internal_map() const; + ::substrait::ParameterizedType_ParameterizedMap* _internal_mutable_map(); public: void unsafe_arena_set_allocated_map( - ::io::substrait::ParameterizedType_ParameterizedMap* map); - ::io::substrait::ParameterizedType_ParameterizedMap* unsafe_arena_release_map(); + ::substrait::ParameterizedType_ParameterizedMap* map); + ::substrait::ParameterizedType_ParameterizedMap* unsafe_arena_release_map(); // uint32 user_defined_pointer = 31; bool has_user_defined_pointer() const; @@ -2696,27 +2693,27 @@ class ParameterizedType PROTOBUF_FINAL : void _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; + // .substrait.ParameterizedType.TypeParameter type_parameter = 33; bool has_type_parameter() const; private: bool _internal_has_type_parameter() const; public: void clear_type_parameter(); - const ::io::substrait::ParameterizedType_TypeParameter& type_parameter() const; - ::io::substrait::ParameterizedType_TypeParameter* release_type_parameter(); - ::io::substrait::ParameterizedType_TypeParameter* mutable_type_parameter(); - void set_allocated_type_parameter(::io::substrait::ParameterizedType_TypeParameter* type_parameter); + const ::substrait::ParameterizedType_TypeParameter& type_parameter() const; + ::substrait::ParameterizedType_TypeParameter* release_type_parameter(); + ::substrait::ParameterizedType_TypeParameter* mutable_type_parameter(); + void set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter); private: - const ::io::substrait::ParameterizedType_TypeParameter& _internal_type_parameter() const; - ::io::substrait::ParameterizedType_TypeParameter* _internal_mutable_type_parameter(); + const ::substrait::ParameterizedType_TypeParameter& _internal_type_parameter() const; + ::substrait::ParameterizedType_TypeParameter* _internal_mutable_type_parameter(); public: void unsafe_arena_set_allocated_type_parameter( - ::io::substrait::ParameterizedType_TypeParameter* type_parameter); - ::io::substrait::ParameterizedType_TypeParameter* unsafe_arena_release_type_parameter(); + ::substrait::ParameterizedType_TypeParameter* type_parameter); + ::substrait::ParameterizedType_TypeParameter* unsafe_arena_release_type_parameter(); void clear_kind(); KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.ParameterizedType) + // @@protoc_insertion_point(class_scope:substrait.ParameterizedType) private: class _Internal; void set_has_bool_(); @@ -2754,36 +2751,36 @@ class ParameterizedType PROTOBUF_FINAL : union KindUnion { constexpr KindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Type_Boolean* bool__; - ::io::substrait::Type_I8* i8_; - ::io::substrait::Type_I16* i16_; - ::io::substrait::Type_I32* i32_; - ::io::substrait::Type_I64* i64_; - ::io::substrait::Type_FP32* fp32_; - ::io::substrait::Type_FP64* fp64_; - ::io::substrait::Type_String* string_; - ::io::substrait::Type_Binary* binary_; - ::io::substrait::Type_Timestamp* timestamp_; - ::io::substrait::Type_Date* date_; - ::io::substrait::Type_Time* time_; - ::io::substrait::Type_IntervalYear* interval_year_; - ::io::substrait::Type_IntervalDay* interval_day_; - ::io::substrait::Type_TimestampTZ* timestamp_tz_; - ::io::substrait::Type_UUID* uuid_; - ::io::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char_; - ::io::substrait::ParameterizedType_ParameterizedVarChar* varchar_; - ::io::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary_; - ::io::substrait::ParameterizedType_ParameterizedDecimal* decimal_; - ::io::substrait::ParameterizedType_ParameterizedStruct* struct__; - ::io::substrait::ParameterizedType_ParameterizedList* list_; - ::io::substrait::ParameterizedType_ParameterizedMap* map_; + ::substrait::Type_Boolean* bool__; + ::substrait::Type_I8* i8_; + ::substrait::Type_I16* i16_; + ::substrait::Type_I32* i32_; + ::substrait::Type_I64* i64_; + ::substrait::Type_FP32* fp32_; + ::substrait::Type_FP64* fp64_; + ::substrait::Type_String* string_; + ::substrait::Type_Binary* binary_; + ::substrait::Type_Timestamp* timestamp_; + ::substrait::Type_Date* date_; + ::substrait::Type_Time* time_; + ::substrait::Type_IntervalYear* interval_year_; + ::substrait::Type_IntervalDay* interval_day_; + ::substrait::Type_TimestampTZ* timestamp_tz_; + ::substrait::Type_UUID* uuid_; + ::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char_; + ::substrait::ParameterizedType_ParameterizedVarChar* varchar_; + ::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary_; + ::substrait::ParameterizedType_ParameterizedDecimal* decimal_; + ::substrait::ParameterizedType_ParameterizedStruct* struct__; + ::substrait::ParameterizedType_ParameterizedList* list_; + ::substrait::ParameterizedType_ParameterizedMap* map_; ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_pointer_; - ::io::substrait::ParameterizedType_TypeParameter* type_parameter_; + ::substrait::ParameterizedType_TypeParameter* type_parameter_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_parameterized_5ftypes_2eproto; + friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // =================================================================== @@ -2801,7 +2798,7 @@ inline void ParameterizedType_TypeParameter::clear_name() { name_.ClearToEmpty(); } inline const std::string& ParameterizedType_TypeParameter::name() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.TypeParameter.name) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.TypeParameter.name) return _internal_name(); } template @@ -2809,10 +2806,10 @@ PROTOBUF_ALWAYS_INLINE inline void ParameterizedType_TypeParameter::set_name(ArgT0&& arg0, ArgT... args) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.TypeParameter.name) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.TypeParameter.name) } inline std::string* ParameterizedType_TypeParameter::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.TypeParameter.name) + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.TypeParameter.name) return _internal_mutable_name(); } inline const std::string& ParameterizedType_TypeParameter::_internal_name() const { @@ -2827,7 +2824,7 @@ inline std::string* ParameterizedType_TypeParameter::_internal_mutable_name() { return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* ParameterizedType_TypeParameter::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.TypeParameter.name) + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.TypeParameter.name) return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void ParameterizedType_TypeParameter::set_allocated_name(std::string* name) { @@ -2838,10 +2835,10 @@ inline void ParameterizedType_TypeParameter::set_allocated_name(std::string* nam } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.TypeParameter.name) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.TypeParameter.name) } -// repeated .io.substrait.ParameterizedType bounds = 2; +// repeated .substrait.ParameterizedType bounds = 2; inline int ParameterizedType_TypeParameter::_internal_bounds_size() const { return bounds_.size(); } @@ -2851,32 +2848,32 @@ inline int ParameterizedType_TypeParameter::bounds_size() const { inline void ParameterizedType_TypeParameter::clear_bounds() { bounds_.Clear(); } -inline ::io::substrait::ParameterizedType* ParameterizedType_TypeParameter::mutable_bounds(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.TypeParameter.bounds) +inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::mutable_bounds(int index) { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.TypeParameter.bounds) return bounds_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >* ParameterizedType_TypeParameter::mutable_bounds() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ParameterizedType.TypeParameter.bounds) + // @@protoc_insertion_point(field_mutable_list:substrait.ParameterizedType.TypeParameter.bounds) return &bounds_; } -inline const ::io::substrait::ParameterizedType& ParameterizedType_TypeParameter::_internal_bounds(int index) const { +inline const ::substrait::ParameterizedType& ParameterizedType_TypeParameter::_internal_bounds(int index) const { return bounds_.Get(index); } -inline const ::io::substrait::ParameterizedType& ParameterizedType_TypeParameter::bounds(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.TypeParameter.bounds) +inline const ::substrait::ParameterizedType& ParameterizedType_TypeParameter::bounds(int index) const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.TypeParameter.bounds) return _internal_bounds(index); } -inline ::io::substrait::ParameterizedType* ParameterizedType_TypeParameter::_internal_add_bounds() { +inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::_internal_add_bounds() { return bounds_.Add(); } -inline ::io::substrait::ParameterizedType* ParameterizedType_TypeParameter::add_bounds() { - // @@protoc_insertion_point(field_add:io.substrait.ParameterizedType.TypeParameter.bounds) +inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::add_bounds() { + // @@protoc_insertion_point(field_add:substrait.ParameterizedType.TypeParameter.bounds) return _internal_add_bounds(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >& ParameterizedType_TypeParameter::bounds() const { - // @@protoc_insertion_point(field_list:io.substrait.ParameterizedType.TypeParameter.bounds) + // @@protoc_insertion_point(field_list:substrait.ParameterizedType.TypeParameter.bounds) return bounds_; } @@ -2889,7 +2886,7 @@ inline void ParameterizedType_IntegerParameter::clear_name() { name_.ClearToEmpty(); } inline const std::string& ParameterizedType_IntegerParameter::name() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.IntegerParameter.name) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerParameter.name) return _internal_name(); } template @@ -2897,10 +2894,10 @@ PROTOBUF_ALWAYS_INLINE inline void ParameterizedType_IntegerParameter::set_name(ArgT0&& arg0, ArgT... args) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.IntegerParameter.name) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.IntegerParameter.name) } inline std::string* ParameterizedType_IntegerParameter::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.IntegerParameter.name) + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.name) return _internal_mutable_name(); } inline const std::string& ParameterizedType_IntegerParameter::_internal_name() const { @@ -2915,7 +2912,7 @@ inline std::string* ParameterizedType_IntegerParameter::_internal_mutable_name() return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* ParameterizedType_IntegerParameter::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.IntegerParameter.name) + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerParameter.name) return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void ParameterizedType_IntegerParameter::set_allocated_name(std::string* name) { @@ -2926,10 +2923,10 @@ inline void ParameterizedType_IntegerParameter::set_allocated_name(std::string* } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.IntegerParameter.name) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerParameter.name) } -// .io.substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; +// .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; inline bool ParameterizedType_IntegerParameter::_internal_has_range_start_inclusive() const { return this != internal_default_instance() && range_start_inclusive_ != nullptr; } @@ -2942,17 +2939,17 @@ inline void ParameterizedType_IntegerParameter::clear_range_start_inclusive() { } range_start_inclusive_ = nullptr; } -inline const ::io::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_internal_range_start_inclusive() const { - const ::io::substrait::ParameterizedType_NullableInteger* p = range_start_inclusive_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_NullableInteger_default_instance_); +inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_internal_range_start_inclusive() const { + const ::substrait::ParameterizedType_NullableInteger* p = range_start_inclusive_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_NullableInteger_default_instance_); } -inline const ::io::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::range_start_inclusive() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.IntegerParameter.range_start_inclusive) +inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::range_start_inclusive() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) return _internal_range_start_inclusive(); } inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range_start_inclusive( - ::io::substrait::ParameterizedType_NullableInteger* range_start_inclusive) { + ::substrait::ParameterizedType_NullableInteger* range_start_inclusive) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(range_start_inclusive_); } @@ -2962,37 +2959,37 @@ inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.IntegerParameter.range_start_inclusive) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) } -inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::release_range_start_inclusive() { +inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::release_range_start_inclusive() { - ::io::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_; + ::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_; range_start_inclusive_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_start_inclusive() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.IntegerParameter.range_start_inclusive) +inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_start_inclusive() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) - ::io::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_; + ::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_; range_start_inclusive_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_start_inclusive() { +inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_start_inclusive() { if (range_start_inclusive_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_NullableInteger>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(GetArena()); range_start_inclusive_ = p; } return range_start_inclusive_; } -inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_start_inclusive() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.IntegerParameter.range_start_inclusive) +inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_start_inclusive() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) return _internal_mutable_range_start_inclusive(); } -inline void ParameterizedType_IntegerParameter::set_allocated_range_start_inclusive(::io::substrait::ParameterizedType_NullableInteger* range_start_inclusive) { +inline void ParameterizedType_IntegerParameter::set_allocated_range_start_inclusive(::substrait::ParameterizedType_NullableInteger* range_start_inclusive) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete range_start_inclusive_; @@ -3009,10 +3006,10 @@ inline void ParameterizedType_IntegerParameter::set_allocated_range_start_inclus } range_start_inclusive_ = range_start_inclusive; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.IntegerParameter.range_start_inclusive) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) } -// .io.substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; +// .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; inline bool ParameterizedType_IntegerParameter::_internal_has_range_end_exclusive() const { return this != internal_default_instance() && range_end_exclusive_ != nullptr; } @@ -3025,17 +3022,17 @@ inline void ParameterizedType_IntegerParameter::clear_range_end_exclusive() { } range_end_exclusive_ = nullptr; } -inline const ::io::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_internal_range_end_exclusive() const { - const ::io::substrait::ParameterizedType_NullableInteger* p = range_end_exclusive_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_NullableInteger_default_instance_); +inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_internal_range_end_exclusive() const { + const ::substrait::ParameterizedType_NullableInteger* p = range_end_exclusive_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_NullableInteger_default_instance_); } -inline const ::io::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::range_end_exclusive() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.IntegerParameter.range_end_exclusive) +inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::range_end_exclusive() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) return _internal_range_end_exclusive(); } inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range_end_exclusive( - ::io::substrait::ParameterizedType_NullableInteger* range_end_exclusive) { + ::substrait::ParameterizedType_NullableInteger* range_end_exclusive) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(range_end_exclusive_); } @@ -3045,37 +3042,37 @@ inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.IntegerParameter.range_end_exclusive) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) } -inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::release_range_end_exclusive() { +inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::release_range_end_exclusive() { - ::io::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_; + ::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_; range_end_exclusive_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_end_exclusive() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.IntegerParameter.range_end_exclusive) +inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_end_exclusive() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) - ::io::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_; + ::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_; range_end_exclusive_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_end_exclusive() { +inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_end_exclusive() { if (range_end_exclusive_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_NullableInteger>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(GetArena()); range_end_exclusive_ = p; } return range_end_exclusive_; } -inline ::io::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_end_exclusive() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.IntegerParameter.range_end_exclusive) +inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_end_exclusive() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) return _internal_mutable_range_end_exclusive(); } -inline void ParameterizedType_IntegerParameter::set_allocated_range_end_exclusive(::io::substrait::ParameterizedType_NullableInteger* range_end_exclusive) { +inline void ParameterizedType_IntegerParameter::set_allocated_range_end_exclusive(::substrait::ParameterizedType_NullableInteger* range_end_exclusive) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete range_end_exclusive_; @@ -3092,7 +3089,7 @@ inline void ParameterizedType_IntegerParameter::set_allocated_range_end_exclusiv } range_end_exclusive_ = range_end_exclusive; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.IntegerParameter.range_end_exclusive) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) } // ------------------------------------------------------------------- @@ -3107,7 +3104,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 ParameterizedType_NullableInteger::_intern return value_; } inline ::PROTOBUF_NAMESPACE_ID::int64 ParameterizedType_NullableInteger::value() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.NullableInteger.value) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.NullableInteger.value) return _internal_value(); } inline void ParameterizedType_NullableInteger::_internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value) { @@ -3116,14 +3113,14 @@ inline void ParameterizedType_NullableInteger::_internal_set_value(::PROTOBUF_NA } inline void ParameterizedType_NullableInteger::set_value(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_value(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.NullableInteger.value) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.NullableInteger.value) } // ------------------------------------------------------------------- // ParameterizedType_ParameterizedFixedChar -// .io.substrait.ParameterizedType.IntegerOption length = 1; +// .substrait.ParameterizedType.IntegerOption length = 1; inline bool ParameterizedType_ParameterizedFixedChar::_internal_has_length() const { return this != internal_default_instance() && length_ != nullptr; } @@ -3136,17 +3133,17 @@ inline void ParameterizedType_ParameterizedFixedChar::clear_length() { } length_ = nullptr; } -inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::_internal_length() const { - const ::io::substrait::ParameterizedType_IntegerOption* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_IntegerOption_default_instance_); +inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::_internal_length() const { + const ::substrait::ParameterizedType_IntegerOption* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_IntegerOption_default_instance_); } -inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::length() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedChar.length) +inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::length() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedChar.length) return _internal_length(); } inline void ParameterizedType_ParameterizedFixedChar::unsafe_arena_set_allocated_length( - ::io::substrait::ParameterizedType_IntegerOption* length) { + ::substrait::ParameterizedType_IntegerOption* length) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } @@ -3156,37 +3153,37 @@ inline void ParameterizedType_ParameterizedFixedChar::unsafe_arena_set_allocated } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedChar.length) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedFixedChar.length) } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::release_length() { +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::release_length() { - ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + ::substrait::ParameterizedType_IntegerOption* temp = length_; length_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedFixedChar.length) +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedFixedChar.length) - ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + ::substrait::ParameterizedType_IntegerOption* temp = length_; length_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::_internal_mutable_length() { +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArena()); length_ = p; } return length_; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::mutable_length() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedFixedChar.length) +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::mutable_length() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedFixedChar.length) return _internal_mutable_length(); } -inline void ParameterizedType_ParameterizedFixedChar::set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length) { +inline void ParameterizedType_ParameterizedFixedChar::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete length_; @@ -3203,7 +3200,7 @@ inline void ParameterizedType_ParameterizedFixedChar::set_allocated_length(::io: } length_ = length; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedChar.length) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedFixedChar.length) } // uint32 variation_pointer = 2; @@ -3214,7 +3211,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedChar: return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedChar::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer) return _internal_variation_pointer(); } inline void ParameterizedType_ParameterizedFixedChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -3223,34 +3220,34 @@ inline void ParameterizedType_ParameterizedFixedChar::_internal_set_variation_po } inline void ParameterizedType_ParameterizedFixedChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void ParameterizedType_ParameterizedFixedChar::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedFixedChar::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedChar::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedFixedChar::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedChar.nullability) +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedChar::nullability() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedChar.nullability) return _internal_nullability(); } -inline void ParameterizedType_ParameterizedFixedChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedFixedChar::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void ParameterizedType_ParameterizedFixedChar::set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedFixedChar::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedFixedChar.nullability) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedChar.nullability) } // ------------------------------------------------------------------- // ParameterizedType_ParameterizedVarChar -// .io.substrait.ParameterizedType.IntegerOption length = 1; +// .substrait.ParameterizedType.IntegerOption length = 1; inline bool ParameterizedType_ParameterizedVarChar::_internal_has_length() const { return this != internal_default_instance() && length_ != nullptr; } @@ -3263,17 +3260,17 @@ inline void ParameterizedType_ParameterizedVarChar::clear_length() { } length_ = nullptr; } -inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::_internal_length() const { - const ::io::substrait::ParameterizedType_IntegerOption* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_IntegerOption_default_instance_); +inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::_internal_length() const { + const ::substrait::ParameterizedType_IntegerOption* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_IntegerOption_default_instance_); } -inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::length() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedVarChar.length) +inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::length() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedVarChar.length) return _internal_length(); } inline void ParameterizedType_ParameterizedVarChar::unsafe_arena_set_allocated_length( - ::io::substrait::ParameterizedType_IntegerOption* length) { + ::substrait::ParameterizedType_IntegerOption* length) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } @@ -3283,37 +3280,37 @@ inline void ParameterizedType_ParameterizedVarChar::unsafe_arena_set_allocated_l } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedVarChar.length) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedVarChar.length) } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::release_length() { +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::release_length() { - ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + ::substrait::ParameterizedType_IntegerOption* temp = length_; length_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedVarChar.length) +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedVarChar.length) - ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + ::substrait::ParameterizedType_IntegerOption* temp = length_; length_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::_internal_mutable_length() { +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArena()); length_ = p; } return length_; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::mutable_length() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedVarChar.length) +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::mutable_length() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedVarChar.length) return _internal_mutable_length(); } -inline void ParameterizedType_ParameterizedVarChar::set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length) { +inline void ParameterizedType_ParameterizedVarChar::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete length_; @@ -3330,7 +3327,7 @@ inline void ParameterizedType_ParameterizedVarChar::set_allocated_length(::io::s } length_ = length; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedVarChar.length) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedVarChar.length) } // uint32 variation_pointer = 2; @@ -3341,7 +3338,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedVarChar::_ return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedVarChar::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedVarChar.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedVarChar.variation_pointer) return _internal_variation_pointer(); } inline void ParameterizedType_ParameterizedVarChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -3350,34 +3347,34 @@ inline void ParameterizedType_ParameterizedVarChar::_internal_set_variation_poin } inline void ParameterizedType_ParameterizedVarChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedVarChar.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedVarChar.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void ParameterizedType_ParameterizedVarChar::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedVarChar::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedVarChar::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedVarChar::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedVarChar.nullability) +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedVarChar::nullability() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedVarChar.nullability) return _internal_nullability(); } -inline void ParameterizedType_ParameterizedVarChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedVarChar::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void ParameterizedType_ParameterizedVarChar::set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedVarChar::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedVarChar.nullability) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedVarChar.nullability) } // ------------------------------------------------------------------- // ParameterizedType_ParameterizedFixedBinary -// .io.substrait.ParameterizedType.IntegerOption length = 1; +// .substrait.ParameterizedType.IntegerOption length = 1; inline bool ParameterizedType_ParameterizedFixedBinary::_internal_has_length() const { return this != internal_default_instance() && length_ != nullptr; } @@ -3390,17 +3387,17 @@ inline void ParameterizedType_ParameterizedFixedBinary::clear_length() { } length_ = nullptr; } -inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::_internal_length() const { - const ::io::substrait::ParameterizedType_IntegerOption* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_IntegerOption_default_instance_); +inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::_internal_length() const { + const ::substrait::ParameterizedType_IntegerOption* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_IntegerOption_default_instance_); } -inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::length() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) +inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::length() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedBinary.length) return _internal_length(); } inline void ParameterizedType_ParameterizedFixedBinary::unsafe_arena_set_allocated_length( - ::io::substrait::ParameterizedType_IntegerOption* length) { + ::substrait::ParameterizedType_IntegerOption* length) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } @@ -3410,37 +3407,37 @@ inline void ParameterizedType_ParameterizedFixedBinary::unsafe_arena_set_allocat } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedFixedBinary.length) } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::release_length() { +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::release_length() { - ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + ::substrait::ParameterizedType_IntegerOption* temp = length_; length_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedFixedBinary.length) - ::io::substrait::ParameterizedType_IntegerOption* temp = length_; + ::substrait::ParameterizedType_IntegerOption* temp = length_; length_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::_internal_mutable_length() { +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArena()); length_ = p; } return length_; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::mutable_length() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::mutable_length() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedFixedBinary.length) return _internal_mutable_length(); } -inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_length(::io::substrait::ParameterizedType_IntegerOption* length) { +inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete length_; @@ -3457,7 +3454,7 @@ inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_length(::i } length_ = length; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedFixedBinary.length) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedFixedBinary.length) } // uint32 variation_pointer = 2; @@ -3468,7 +3465,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedBinar return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedBinary::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer) return _internal_variation_pointer(); } inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -3477,34 +3474,34 @@ inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_variation_ } inline void ParameterizedType_ParameterizedFixedBinary::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void ParameterizedType_ParameterizedFixedBinary::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedFixedBinary::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedBinary::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedFixedBinary::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedFixedBinary.nullability) +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedBinary::nullability() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedBinary.nullability) return _internal_nullability(); } -inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void ParameterizedType_ParameterizedFixedBinary::set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedFixedBinary::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedFixedBinary.nullability) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedBinary.nullability) } // ------------------------------------------------------------------- // ParameterizedType_ParameterizedDecimal -// .io.substrait.ParameterizedType.IntegerOption scale = 1; +// .substrait.ParameterizedType.IntegerOption scale = 1; inline bool ParameterizedType_ParameterizedDecimal::_internal_has_scale() const { return this != internal_default_instance() && scale_ != nullptr; } @@ -3517,17 +3514,17 @@ inline void ParameterizedType_ParameterizedDecimal::clear_scale() { } scale_ = nullptr; } -inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_internal_scale() const { - const ::io::substrait::ParameterizedType_IntegerOption* p = scale_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_IntegerOption_default_instance_); +inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_internal_scale() const { + const ::substrait::ParameterizedType_IntegerOption* p = scale_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_IntegerOption_default_instance_); } -inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::scale() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedDecimal.scale) +inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::scale() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.scale) return _internal_scale(); } inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_scale( - ::io::substrait::ParameterizedType_IntegerOption* scale) { + ::substrait::ParameterizedType_IntegerOption* scale) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_); } @@ -3537,37 +3534,37 @@ inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_s } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.scale) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.scale) } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::release_scale() { +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::release_scale() { - ::io::substrait::ParameterizedType_IntegerOption* temp = scale_; + ::substrait::ParameterizedType_IntegerOption* temp = scale_; scale_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_scale() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedDecimal.scale) +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_scale() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedDecimal.scale) - ::io::substrait::ParameterizedType_IntegerOption* temp = scale_; + ::substrait::ParameterizedType_IntegerOption* temp = scale_; scale_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_scale() { +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_scale() { if (scale_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArena()); scale_ = p; } return scale_; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_scale() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedDecimal.scale) +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_scale() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedDecimal.scale) return _internal_mutable_scale(); } -inline void ParameterizedType_ParameterizedDecimal::set_allocated_scale(::io::substrait::ParameterizedType_IntegerOption* scale) { +inline void ParameterizedType_ParameterizedDecimal::set_allocated_scale(::substrait::ParameterizedType_IntegerOption* scale) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete scale_; @@ -3584,10 +3581,10 @@ inline void ParameterizedType_ParameterizedDecimal::set_allocated_scale(::io::su } scale_ = scale; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.scale) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.scale) } -// .io.substrait.ParameterizedType.IntegerOption precision = 2; +// .substrait.ParameterizedType.IntegerOption precision = 2; inline bool ParameterizedType_ParameterizedDecimal::_internal_has_precision() const { return this != internal_default_instance() && precision_ != nullptr; } @@ -3600,17 +3597,17 @@ inline void ParameterizedType_ParameterizedDecimal::clear_precision() { } precision_ = nullptr; } -inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_internal_precision() const { - const ::io::substrait::ParameterizedType_IntegerOption* p = precision_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_IntegerOption_default_instance_); +inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_internal_precision() const { + const ::substrait::ParameterizedType_IntegerOption* p = precision_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_IntegerOption_default_instance_); } -inline const ::io::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::precision() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedDecimal.precision) +inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::precision() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.precision) return _internal_precision(); } inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_precision( - ::io::substrait::ParameterizedType_IntegerOption* precision) { + ::substrait::ParameterizedType_IntegerOption* precision) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_); } @@ -3620,37 +3617,37 @@ inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_p } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.precision) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.precision) } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::release_precision() { +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::release_precision() { - ::io::substrait::ParameterizedType_IntegerOption* temp = precision_; + ::substrait::ParameterizedType_IntegerOption* temp = precision_; precision_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_precision() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedDecimal.precision) +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_precision() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedDecimal.precision) - ::io::substrait::ParameterizedType_IntegerOption* temp = precision_; + ::substrait::ParameterizedType_IntegerOption* temp = precision_; precision_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_precision() { +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_precision() { if (precision_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_IntegerOption>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArena()); precision_ = p; } return precision_; } -inline ::io::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_precision() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedDecimal.precision) +inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_precision() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedDecimal.precision) return _internal_mutable_precision(); } -inline void ParameterizedType_ParameterizedDecimal::set_allocated_precision(::io::substrait::ParameterizedType_IntegerOption* precision) { +inline void ParameterizedType_ParameterizedDecimal::set_allocated_precision(::substrait::ParameterizedType_IntegerOption* precision) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete precision_; @@ -3667,7 +3664,7 @@ inline void ParameterizedType_ParameterizedDecimal::set_allocated_precision(::io } precision_ = precision; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedDecimal.precision) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.precision) } // uint32 variation_pointer = 3; @@ -3678,7 +3675,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedDecimal::_ return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedDecimal::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedDecimal.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.variation_pointer) return _internal_variation_pointer(); } inline void ParameterizedType_ParameterizedDecimal::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -3687,34 +3684,34 @@ inline void ParameterizedType_ParameterizedDecimal::_internal_set_variation_poin } inline void ParameterizedType_ParameterizedDecimal::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedDecimal.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedDecimal.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 4; +// .substrait.Type.Nullability nullability = 4; inline void ParameterizedType_ParameterizedDecimal::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedDecimal::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedDecimal::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedDecimal::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedDecimal.nullability) +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedDecimal::nullability() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.nullability) return _internal_nullability(); } -inline void ParameterizedType_ParameterizedDecimal::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedDecimal::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void ParameterizedType_ParameterizedDecimal::set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedDecimal::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedDecimal.nullability) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedDecimal.nullability) } // ------------------------------------------------------------------- // ParameterizedType_ParameterizedStruct -// repeated .io.substrait.ParameterizedType types = 1; +// repeated .substrait.ParameterizedType types = 1; inline int ParameterizedType_ParameterizedStruct::_internal_types_size() const { return types_.size(); } @@ -3724,32 +3721,32 @@ inline int ParameterizedType_ParameterizedStruct::types_size() const { inline void ParameterizedType_ParameterizedStruct::clear_types() { types_.Clear(); } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::mutable_types(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedStruct.types) +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::mutable_types(int index) { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedStruct.types) return types_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >* ParameterizedType_ParameterizedStruct::mutable_types() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ParameterizedType.ParameterizedStruct.types) + // @@protoc_insertion_point(field_mutable_list:substrait.ParameterizedType.ParameterizedStruct.types) return &types_; } -inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedStruct::_internal_types(int index) const { +inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedStruct::_internal_types(int index) const { return types_.Get(index); } -inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedStruct::types(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedStruct.types) +inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedStruct::types(int index) const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedStruct.types) return _internal_types(index); } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::_internal_add_types() { +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::_internal_add_types() { return types_.Add(); } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::add_types() { - // @@protoc_insertion_point(field_add:io.substrait.ParameterizedType.ParameterizedStruct.types) +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::add_types() { + // @@protoc_insertion_point(field_add:substrait.ParameterizedType.ParameterizedStruct.types) return _internal_add_types(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ParameterizedType >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >& ParameterizedType_ParameterizedStruct::types() const { - // @@protoc_insertion_point(field_list:io.substrait.ParameterizedType.ParameterizedStruct.types) + // @@protoc_insertion_point(field_list:substrait.ParameterizedType.ParameterizedStruct.types) return types_; } @@ -3761,7 +3758,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedStruct::_i return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedStruct::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedStruct.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedStruct.variation_pointer) return _internal_variation_pointer(); } inline void ParameterizedType_ParameterizedStruct::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -3770,27 +3767,27 @@ inline void ParameterizedType_ParameterizedStruct::_internal_set_variation_point } inline void ParameterizedType_ParameterizedStruct::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedStruct.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedStruct.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void ParameterizedType_ParameterizedStruct::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedStruct::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedStruct::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedStruct::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedStruct.nullability) +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedStruct::nullability() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedStruct.nullability) return _internal_nullability(); } -inline void ParameterizedType_ParameterizedStruct::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedStruct::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void ParameterizedType_ParameterizedStruct::set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedStruct::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedStruct.nullability) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedStruct.nullability) } // ------------------------------------------------------------------- @@ -3808,70 +3805,70 @@ inline void ParameterizedType_ParameterizedNamedStruct::clear_names() { names_.Clear(); } inline std::string* ParameterizedType_ParameterizedNamedStruct::add_names() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_add_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.names) return _internal_add_names(); } inline const std::string& ParameterizedType_ParameterizedNamedStruct::_internal_names(int index) const { return names_.Get(index); } inline const std::string& ParameterizedType_ParameterizedNamedStruct::names(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedNamedStruct.names) return _internal_names(index); } inline std::string* ParameterizedType_ParameterizedNamedStruct::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.names) return names_.Mutable(index); } inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedNamedStruct.names) names_.Mutable(index)->assign(value); } inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedNamedStruct.names) names_.Mutable(index)->assign(std::move(value)); } inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_set_char:substrait.ParameterizedType.ParameterizedNamedStruct.names) } inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const char* value, size_t size) { names_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_set_pointer:substrait.ParameterizedType.ParameterizedNamedStruct.names) } inline std::string* ParameterizedType_ParameterizedNamedStruct::_internal_add_names() { return names_.Add(); } inline void ParameterizedType_ParameterizedNamedStruct::add_names(const std::string& value) { names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_add:substrait.ParameterizedType.ParameterizedNamedStruct.names) } inline void ParameterizedType_ParameterizedNamedStruct::add_names(std::string&& value) { names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_add:substrait.ParameterizedType.ParameterizedNamedStruct.names) } inline void ParameterizedType_ParameterizedNamedStruct::add_names(const char* value) { GOOGLE_DCHECK(value != nullptr); names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_add_char:substrait.ParameterizedType.ParameterizedNamedStruct.names) } inline void ParameterizedType_ParameterizedNamedStruct::add_names(const char* value, size_t size) { names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_add_pointer:substrait.ParameterizedType.ParameterizedNamedStruct.names) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& ParameterizedType_ParameterizedNamedStruct::names() const { - // @@protoc_insertion_point(field_list:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_list:substrait.ParameterizedType.ParameterizedNamedStruct.names) return names_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* ParameterizedType_ParameterizedNamedStruct::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ParameterizedType.ParameterizedNamedStruct.names) + // @@protoc_insertion_point(field_mutable_list:substrait.ParameterizedType.ParameterizedNamedStruct.names) return &names_; } -// .io.substrait.ParameterizedType.ParameterizedStruct struct = 2; +// .substrait.ParameterizedType.ParameterizedStruct struct = 2; inline bool ParameterizedType_ParameterizedNamedStruct::_internal_has_struct_() const { return this != internal_default_instance() && struct__ != nullptr; } @@ -3884,17 +3881,17 @@ inline void ParameterizedType_ParameterizedNamedStruct::clear_struct_() { } struct__ = nullptr; } -inline const ::io::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::_internal_struct_() const { - const ::io::substrait::ParameterizedType_ParameterizedStruct* p = struct__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_ParameterizedStruct_default_instance_); +inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::_internal_struct_() const { + const ::substrait::ParameterizedType_ParameterizedStruct* p = struct__; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_ParameterizedStruct_default_instance_); } -inline const ::io::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedNamedStruct.struct) +inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::struct_() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedNamedStruct.struct) return _internal_struct_(); } inline void ParameterizedType_ParameterizedNamedStruct::unsafe_arena_set_allocated_struct_( - ::io::substrait::ParameterizedType_ParameterizedStruct* struct_) { + ::substrait::ParameterizedType_ParameterizedStruct* struct_) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); } @@ -3904,37 +3901,37 @@ inline void ParameterizedType_ParameterizedNamedStruct::unsafe_arena_set_allocat } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedNamedStruct.struct) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedNamedStruct.struct) } -inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::release_struct_() { +inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::release_struct_() { - ::io::substrait::ParameterizedType_ParameterizedStruct* temp = struct__; + ::substrait::ParameterizedType_ParameterizedStruct* temp = struct__; struct__ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedNamedStruct.struct) +inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedNamedStruct.struct) - ::io::substrait::ParameterizedType_ParameterizedStruct* temp = struct__; + ::substrait::ParameterizedType_ParameterizedStruct* temp = struct__; struct__ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::_internal_mutable_struct_() { +inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::_internal_mutable_struct_() { if (struct__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType_ParameterizedStruct>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedStruct>(GetArena()); struct__ = p; } return struct__; } -inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedNamedStruct.struct) +inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.struct) return _internal_mutable_struct_(); } -inline void ParameterizedType_ParameterizedNamedStruct::set_allocated_struct_(::io::substrait::ParameterizedType_ParameterizedStruct* struct_) { +inline void ParameterizedType_ParameterizedNamedStruct::set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete struct__; @@ -3951,14 +3948,14 @@ inline void ParameterizedType_ParameterizedNamedStruct::set_allocated_struct_(:: } struct__ = struct_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedNamedStruct.struct) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedNamedStruct.struct) } // ------------------------------------------------------------------- // ParameterizedType_ParameterizedList -// .io.substrait.ParameterizedType type = 1; +// .substrait.ParameterizedType type = 1; inline bool ParameterizedType_ParameterizedList::_internal_has_type() const { return this != internal_default_instance() && type_ != nullptr; } @@ -3971,17 +3968,17 @@ inline void ParameterizedType_ParameterizedList::clear_type() { } type_ = nullptr; } -inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedList::_internal_type() const { - const ::io::substrait::ParameterizedType* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_default_instance_); +inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedList::_internal_type() const { + const ::substrait::ParameterizedType* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_default_instance_); } -inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedList::type() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedList.type) +inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedList::type() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedList.type) return _internal_type(); } inline void ParameterizedType_ParameterizedList::unsafe_arena_set_allocated_type( - ::io::substrait::ParameterizedType* type) { + ::substrait::ParameterizedType* type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } @@ -3991,37 +3988,37 @@ inline void ParameterizedType_ParameterizedList::unsafe_arena_set_allocated_type } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedList.type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedList.type) } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedList::release_type() { +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::release_type() { - ::io::substrait::ParameterizedType* temp = type_; + ::substrait::ParameterizedType* temp = type_; type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedList::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedList.type) +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedList.type) - ::io::substrait::ParameterizedType* temp = type_; + ::substrait::ParameterizedType* temp = type_; type_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedList::_internal_mutable_type() { +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArena()); type_ = p; } return type_; } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedList::mutable_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedList.type) +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::mutable_type() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedList.type) return _internal_mutable_type(); } -inline void ParameterizedType_ParameterizedList::set_allocated_type(::io::substrait::ParameterizedType* type) { +inline void ParameterizedType_ParameterizedList::set_allocated_type(::substrait::ParameterizedType* type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete type_; @@ -4038,7 +4035,7 @@ inline void ParameterizedType_ParameterizedList::set_allocated_type(::io::substr } type_ = type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedList.type) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedList.type) } // uint32 variation_pointer = 2; @@ -4049,7 +4046,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedList::_int return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedList::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedList.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedList.variation_pointer) return _internal_variation_pointer(); } inline void ParameterizedType_ParameterizedList::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4058,34 +4055,34 @@ inline void ParameterizedType_ParameterizedList::_internal_set_variation_pointer } inline void ParameterizedType_ParameterizedList::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedList.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedList.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void ParameterizedType_ParameterizedList::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedList::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedList::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedList::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedList.nullability) +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedList::nullability() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedList.nullability) return _internal_nullability(); } -inline void ParameterizedType_ParameterizedList::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedList::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void ParameterizedType_ParameterizedList::set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedList::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedList.nullability) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedList.nullability) } // ------------------------------------------------------------------- // ParameterizedType_ParameterizedMap -// .io.substrait.ParameterizedType key = 1; +// .substrait.ParameterizedType key = 1; inline bool ParameterizedType_ParameterizedMap::_internal_has_key() const { return this != internal_default_instance() && key_ != nullptr; } @@ -4098,17 +4095,17 @@ inline void ParameterizedType_ParameterizedMap::clear_key() { } key_ = nullptr; } -inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_internal_key() const { - const ::io::substrait::ParameterizedType* p = key_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_default_instance_); +inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_internal_key() const { + const ::substrait::ParameterizedType* p = key_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_default_instance_); } -inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::key() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedMap.key) +inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::key() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.key) return _internal_key(); } inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_key( - ::io::substrait::ParameterizedType* key) { + ::substrait::ParameterizedType* key) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); } @@ -4118,37 +4115,37 @@ inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_key( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.key) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedMap.key) } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::release_key() { +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::release_key() { - ::io::substrait::ParameterizedType* temp = key_; + ::substrait::ParameterizedType* temp = key_; key_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedMap.key) +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedMap.key) - ::io::substrait::ParameterizedType* temp = key_; + ::substrait::ParameterizedType* temp = key_; key_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_key() { +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_key() { if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArena()); key_ = p; } return key_; } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedMap.key) +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_key() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedMap.key) return _internal_mutable_key(); } -inline void ParameterizedType_ParameterizedMap::set_allocated_key(::io::substrait::ParameterizedType* key) { +inline void ParameterizedType_ParameterizedMap::set_allocated_key(::substrait::ParameterizedType* key) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete key_; @@ -4165,10 +4162,10 @@ inline void ParameterizedType_ParameterizedMap::set_allocated_key(::io::substrai } key_ = key; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.key) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedMap.key) } -// .io.substrait.ParameterizedType value = 2; +// .substrait.ParameterizedType value = 2; inline bool ParameterizedType_ParameterizedMap::_internal_has_value() const { return this != internal_default_instance() && value_ != nullptr; } @@ -4181,17 +4178,17 @@ inline void ParameterizedType_ParameterizedMap::clear_value() { } value_ = nullptr; } -inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_internal_value() const { - const ::io::substrait::ParameterizedType* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_ParameterizedType_default_instance_); +inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_internal_value() const { + const ::substrait::ParameterizedType* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_ParameterizedType_default_instance_); } -inline const ::io::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::value() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedMap.value) +inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::value() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.value) return _internal_value(); } inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_value( - ::io::substrait::ParameterizedType* value) { + ::substrait::ParameterizedType* value) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } @@ -4201,37 +4198,37 @@ inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_value } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.value) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedMap.value) } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::release_value() { +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::release_value() { - ::io::substrait::ParameterizedType* temp = value_; + ::substrait::ParameterizedType* temp = value_; value_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.ParameterizedMap.value) +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedMap.value) - ::io::substrait::ParameterizedType* temp = value_; + ::substrait::ParameterizedType* temp = value_; value_ = nullptr; return temp; } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_value() { +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_value() { if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::ParameterizedType>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArena()); value_ = p; } return value_; } -inline ::io::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.ParameterizedMap.value) +inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_value() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedMap.value) return _internal_mutable_value(); } -inline void ParameterizedType_ParameterizedMap::set_allocated_value(::io::substrait::ParameterizedType* value) { +inline void ParameterizedType_ParameterizedMap::set_allocated_value(::substrait::ParameterizedType* value) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete value_; @@ -4248,7 +4245,7 @@ inline void ParameterizedType_ParameterizedMap::set_allocated_value(::io::substr } value_ = value; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ParameterizedType.ParameterizedMap.value) + // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedMap.value) } // uint32 variation_pointer = 3; @@ -4259,7 +4256,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedMap::_inte return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedMap::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedMap.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.variation_pointer) return _internal_variation_pointer(); } inline void ParameterizedType_ParameterizedMap::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4268,27 +4265,27 @@ inline void ParameterizedType_ParameterizedMap::_internal_set_variation_pointer( } inline void ParameterizedType_ParameterizedMap::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedMap.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedMap.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 4; +// .substrait.Type.Nullability nullability = 4; inline void ParameterizedType_ParameterizedMap::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedMap::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedMap::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability ParameterizedType_ParameterizedMap::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.ParameterizedMap.nullability) +inline ::substrait::Type_Nullability ParameterizedType_ParameterizedMap::nullability() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.nullability) return _internal_nullability(); } -inline void ParameterizedType_ParameterizedMap::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedMap::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void ParameterizedType_ParameterizedMap::set_nullability(::io::substrait::Type_Nullability value) { +inline void ParameterizedType_ParameterizedMap::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.ParameterizedMap.nullability) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedMap.nullability) } // ------------------------------------------------------------------- @@ -4325,15 +4322,15 @@ inline void ParameterizedType_IntegerOption::_internal_set_literal(::PROTOBUF_NA integer_type_.literal_ = value; } inline ::PROTOBUF_NAMESPACE_ID::int32 ParameterizedType_IntegerOption::literal() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.IntegerOption.literal) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerOption.literal) return _internal_literal(); } inline void ParameterizedType_IntegerOption::set_literal(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_literal(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.IntegerOption.literal) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.IntegerOption.literal) } -// .io.substrait.ParameterizedType.IntegerParameter parameter = 2; +// .substrait.ParameterizedType.IntegerParameter parameter = 2; inline bool ParameterizedType_IntegerOption::_internal_has_parameter() const { return integer_type_case() == kParameter; } @@ -4351,11 +4348,11 @@ inline void ParameterizedType_IntegerOption::clear_parameter() { clear_has_integer_type(); } } -inline ::io::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::release_parameter() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.IntegerOption.parameter) +inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::release_parameter() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerOption.parameter) if (_internal_has_parameter()) { clear_has_integer_type(); - ::io::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_; + ::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4365,44 +4362,44 @@ inline ::io::substrait::ParameterizedType_IntegerParameter* ParameterizedType_In return nullptr; } } -inline const ::io::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::_internal_parameter() const { +inline const ::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::_internal_parameter() const { return _internal_has_parameter() ? *integer_type_.parameter_ - : reinterpret_cast< ::io::substrait::ParameterizedType_IntegerParameter&>(::io::substrait::_ParameterizedType_IntegerParameter_default_instance_); + : reinterpret_cast< ::substrait::ParameterizedType_IntegerParameter&>(::substrait::_ParameterizedType_IntegerParameter_default_instance_); } -inline const ::io::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::parameter() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.IntegerOption.parameter) +inline const ::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::parameter() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerOption.parameter) return _internal_parameter(); } -inline ::io::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::unsafe_arena_release_parameter() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.IntegerOption.parameter) +inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::unsafe_arena_release_parameter() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.IntegerOption.parameter) if (_internal_has_parameter()) { clear_has_integer_type(); - ::io::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_; + ::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_; integer_type_.parameter_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType_IntegerOption::unsafe_arena_set_allocated_parameter(::io::substrait::ParameterizedType_IntegerParameter* parameter) { +inline void ParameterizedType_IntegerOption::unsafe_arena_set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter) { clear_integer_type(); if (parameter) { set_has_parameter(); integer_type_.parameter_ = parameter; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.IntegerOption.parameter) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.IntegerOption.parameter) } -inline ::io::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::_internal_mutable_parameter() { +inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::_internal_mutable_parameter() { if (!_internal_has_parameter()) { clear_integer_type(); set_has_parameter(); - integer_type_.parameter_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_IntegerParameter >(GetArena()); + integer_type_.parameter_ = CreateMaybeMessage< ::substrait::ParameterizedType_IntegerParameter >(GetArena()); } return integer_type_.parameter_; } -inline ::io::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::mutable_parameter() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.IntegerOption.parameter) +inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::mutable_parameter() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerOption.parameter) return _internal_mutable_parameter(); } @@ -4419,7 +4416,7 @@ inline ParameterizedType_IntegerOption::IntegerTypeCase ParameterizedType_Intege // ParameterizedType -// .io.substrait.Type.Boolean bool = 1; +// .substrait.Type.Boolean bool = 1; inline bool ParameterizedType::_internal_has_bool_() const { return kind_case() == kBool; } @@ -4429,11 +4426,11 @@ inline bool ParameterizedType::has_bool_() const { inline void ParameterizedType::set_has_bool_() { _oneof_case_[0] = kBool; } -inline ::io::substrait::Type_Boolean* ParameterizedType::release_bool_() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.bool) +inline ::substrait::Type_Boolean* ParameterizedType::release_bool_() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.bool) if (_internal_has_bool_()) { clear_has_kind(); - ::io::substrait::Type_Boolean* temp = kind_.bool__; + ::substrait::Type_Boolean* temp = kind_.bool__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4443,48 +4440,48 @@ inline ::io::substrait::Type_Boolean* ParameterizedType::release_bool_() { return nullptr; } } -inline const ::io::substrait::Type_Boolean& ParameterizedType::_internal_bool_() const { +inline const ::substrait::Type_Boolean& ParameterizedType::_internal_bool_() const { return _internal_has_bool_() ? *kind_.bool__ - : reinterpret_cast< ::io::substrait::Type_Boolean&>(::io::substrait::_Type_Boolean_default_instance_); + : reinterpret_cast< ::substrait::Type_Boolean&>(::substrait::_Type_Boolean_default_instance_); } -inline const ::io::substrait::Type_Boolean& ParameterizedType::bool_() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.bool) +inline const ::substrait::Type_Boolean& ParameterizedType::bool_() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.bool) return _internal_bool_(); } -inline ::io::substrait::Type_Boolean* ParameterizedType::unsafe_arena_release_bool_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.bool) +inline ::substrait::Type_Boolean* ParameterizedType::unsafe_arena_release_bool_() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.bool) if (_internal_has_bool_()) { clear_has_kind(); - ::io::substrait::Type_Boolean* temp = kind_.bool__; + ::substrait::Type_Boolean* temp = kind_.bool__; kind_.bool__ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { +inline void ParameterizedType::unsafe_arena_set_allocated_bool_(::substrait::Type_Boolean* bool_) { clear_kind(); if (bool_) { set_has_bool_(); kind_.bool__ = bool_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.bool) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.bool) } -inline ::io::substrait::Type_Boolean* ParameterizedType::_internal_mutable_bool_() { +inline ::substrait::Type_Boolean* ParameterizedType::_internal_mutable_bool_() { if (!_internal_has_bool_()) { clear_kind(); set_has_bool_(); - kind_.bool__ = CreateMaybeMessage< ::io::substrait::Type_Boolean >(GetArena()); + kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArena()); } return kind_.bool__; } -inline ::io::substrait::Type_Boolean* ParameterizedType::mutable_bool_() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.bool) +inline ::substrait::Type_Boolean* ParameterizedType::mutable_bool_() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.bool) return _internal_mutable_bool_(); } -// .io.substrait.Type.I8 i8 = 2; +// .substrait.Type.I8 i8 = 2; inline bool ParameterizedType::_internal_has_i8() const { return kind_case() == kI8; } @@ -4494,11 +4491,11 @@ inline bool ParameterizedType::has_i8() const { inline void ParameterizedType::set_has_i8() { _oneof_case_[0] = kI8; } -inline ::io::substrait::Type_I8* ParameterizedType::release_i8() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.i8) +inline ::substrait::Type_I8* ParameterizedType::release_i8() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i8) if (_internal_has_i8()) { clear_has_kind(); - ::io::substrait::Type_I8* temp = kind_.i8_; + ::substrait::Type_I8* temp = kind_.i8_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4508,48 +4505,48 @@ inline ::io::substrait::Type_I8* ParameterizedType::release_i8() { return nullptr; } } -inline const ::io::substrait::Type_I8& ParameterizedType::_internal_i8() const { +inline const ::substrait::Type_I8& ParameterizedType::_internal_i8() const { return _internal_has_i8() ? *kind_.i8_ - : reinterpret_cast< ::io::substrait::Type_I8&>(::io::substrait::_Type_I8_default_instance_); + : reinterpret_cast< ::substrait::Type_I8&>(::substrait::_Type_I8_default_instance_); } -inline const ::io::substrait::Type_I8& ParameterizedType::i8() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.i8) +inline const ::substrait::Type_I8& ParameterizedType::i8() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i8) return _internal_i8(); } -inline ::io::substrait::Type_I8* ParameterizedType::unsafe_arena_release_i8() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.i8) +inline ::substrait::Type_I8* ParameterizedType::unsafe_arena_release_i8() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i8) if (_internal_has_i8()) { clear_has_kind(); - ::io::substrait::Type_I8* temp = kind_.i8_; + ::substrait::Type_I8* temp = kind_.i8_; kind_.i8_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_i8(::io::substrait::Type_I8* i8) { +inline void ParameterizedType::unsafe_arena_set_allocated_i8(::substrait::Type_I8* i8) { clear_kind(); if (i8) { set_has_i8(); kind_.i8_ = i8; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.i8) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i8) } -inline ::io::substrait::Type_I8* ParameterizedType::_internal_mutable_i8() { +inline ::substrait::Type_I8* ParameterizedType::_internal_mutable_i8() { if (!_internal_has_i8()) { clear_kind(); set_has_i8(); - kind_.i8_ = CreateMaybeMessage< ::io::substrait::Type_I8 >(GetArena()); + kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArena()); } return kind_.i8_; } -inline ::io::substrait::Type_I8* ParameterizedType::mutable_i8() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.i8) +inline ::substrait::Type_I8* ParameterizedType::mutable_i8() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i8) return _internal_mutable_i8(); } -// .io.substrait.Type.I16 i16 = 3; +// .substrait.Type.I16 i16 = 3; inline bool ParameterizedType::_internal_has_i16() const { return kind_case() == kI16; } @@ -4559,11 +4556,11 @@ inline bool ParameterizedType::has_i16() const { inline void ParameterizedType::set_has_i16() { _oneof_case_[0] = kI16; } -inline ::io::substrait::Type_I16* ParameterizedType::release_i16() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.i16) +inline ::substrait::Type_I16* ParameterizedType::release_i16() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i16) if (_internal_has_i16()) { clear_has_kind(); - ::io::substrait::Type_I16* temp = kind_.i16_; + ::substrait::Type_I16* temp = kind_.i16_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4573,48 +4570,48 @@ inline ::io::substrait::Type_I16* ParameterizedType::release_i16() { return nullptr; } } -inline const ::io::substrait::Type_I16& ParameterizedType::_internal_i16() const { +inline const ::substrait::Type_I16& ParameterizedType::_internal_i16() const { return _internal_has_i16() ? *kind_.i16_ - : reinterpret_cast< ::io::substrait::Type_I16&>(::io::substrait::_Type_I16_default_instance_); + : reinterpret_cast< ::substrait::Type_I16&>(::substrait::_Type_I16_default_instance_); } -inline const ::io::substrait::Type_I16& ParameterizedType::i16() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.i16) +inline const ::substrait::Type_I16& ParameterizedType::i16() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i16) return _internal_i16(); } -inline ::io::substrait::Type_I16* ParameterizedType::unsafe_arena_release_i16() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.i16) +inline ::substrait::Type_I16* ParameterizedType::unsafe_arena_release_i16() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i16) if (_internal_has_i16()) { clear_has_kind(); - ::io::substrait::Type_I16* temp = kind_.i16_; + ::substrait::Type_I16* temp = kind_.i16_; kind_.i16_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_i16(::io::substrait::Type_I16* i16) { +inline void ParameterizedType::unsafe_arena_set_allocated_i16(::substrait::Type_I16* i16) { clear_kind(); if (i16) { set_has_i16(); kind_.i16_ = i16; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.i16) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i16) } -inline ::io::substrait::Type_I16* ParameterizedType::_internal_mutable_i16() { +inline ::substrait::Type_I16* ParameterizedType::_internal_mutable_i16() { if (!_internal_has_i16()) { clear_kind(); set_has_i16(); - kind_.i16_ = CreateMaybeMessage< ::io::substrait::Type_I16 >(GetArena()); + kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArena()); } return kind_.i16_; } -inline ::io::substrait::Type_I16* ParameterizedType::mutable_i16() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.i16) +inline ::substrait::Type_I16* ParameterizedType::mutable_i16() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i16) return _internal_mutable_i16(); } -// .io.substrait.Type.I32 i32 = 5; +// .substrait.Type.I32 i32 = 5; inline bool ParameterizedType::_internal_has_i32() const { return kind_case() == kI32; } @@ -4624,11 +4621,11 @@ inline bool ParameterizedType::has_i32() const { inline void ParameterizedType::set_has_i32() { _oneof_case_[0] = kI32; } -inline ::io::substrait::Type_I32* ParameterizedType::release_i32() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.i32) +inline ::substrait::Type_I32* ParameterizedType::release_i32() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i32) if (_internal_has_i32()) { clear_has_kind(); - ::io::substrait::Type_I32* temp = kind_.i32_; + ::substrait::Type_I32* temp = kind_.i32_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4638,48 +4635,48 @@ inline ::io::substrait::Type_I32* ParameterizedType::release_i32() { return nullptr; } } -inline const ::io::substrait::Type_I32& ParameterizedType::_internal_i32() const { +inline const ::substrait::Type_I32& ParameterizedType::_internal_i32() const { return _internal_has_i32() ? *kind_.i32_ - : reinterpret_cast< ::io::substrait::Type_I32&>(::io::substrait::_Type_I32_default_instance_); + : reinterpret_cast< ::substrait::Type_I32&>(::substrait::_Type_I32_default_instance_); } -inline const ::io::substrait::Type_I32& ParameterizedType::i32() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.i32) +inline const ::substrait::Type_I32& ParameterizedType::i32() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i32) return _internal_i32(); } -inline ::io::substrait::Type_I32* ParameterizedType::unsafe_arena_release_i32() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.i32) +inline ::substrait::Type_I32* ParameterizedType::unsafe_arena_release_i32() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i32) if (_internal_has_i32()) { clear_has_kind(); - ::io::substrait::Type_I32* temp = kind_.i32_; + ::substrait::Type_I32* temp = kind_.i32_; kind_.i32_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_i32(::io::substrait::Type_I32* i32) { +inline void ParameterizedType::unsafe_arena_set_allocated_i32(::substrait::Type_I32* i32) { clear_kind(); if (i32) { set_has_i32(); kind_.i32_ = i32; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.i32) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i32) } -inline ::io::substrait::Type_I32* ParameterizedType::_internal_mutable_i32() { +inline ::substrait::Type_I32* ParameterizedType::_internal_mutable_i32() { if (!_internal_has_i32()) { clear_kind(); set_has_i32(); - kind_.i32_ = CreateMaybeMessage< ::io::substrait::Type_I32 >(GetArena()); + kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArena()); } return kind_.i32_; } -inline ::io::substrait::Type_I32* ParameterizedType::mutable_i32() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.i32) +inline ::substrait::Type_I32* ParameterizedType::mutable_i32() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i32) return _internal_mutable_i32(); } -// .io.substrait.Type.I64 i64 = 7; +// .substrait.Type.I64 i64 = 7; inline bool ParameterizedType::_internal_has_i64() const { return kind_case() == kI64; } @@ -4689,11 +4686,11 @@ inline bool ParameterizedType::has_i64() const { inline void ParameterizedType::set_has_i64() { _oneof_case_[0] = kI64; } -inline ::io::substrait::Type_I64* ParameterizedType::release_i64() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.i64) +inline ::substrait::Type_I64* ParameterizedType::release_i64() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i64) if (_internal_has_i64()) { clear_has_kind(); - ::io::substrait::Type_I64* temp = kind_.i64_; + ::substrait::Type_I64* temp = kind_.i64_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4703,48 +4700,48 @@ inline ::io::substrait::Type_I64* ParameterizedType::release_i64() { return nullptr; } } -inline const ::io::substrait::Type_I64& ParameterizedType::_internal_i64() const { +inline const ::substrait::Type_I64& ParameterizedType::_internal_i64() const { return _internal_has_i64() ? *kind_.i64_ - : reinterpret_cast< ::io::substrait::Type_I64&>(::io::substrait::_Type_I64_default_instance_); + : reinterpret_cast< ::substrait::Type_I64&>(::substrait::_Type_I64_default_instance_); } -inline const ::io::substrait::Type_I64& ParameterizedType::i64() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.i64) +inline const ::substrait::Type_I64& ParameterizedType::i64() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i64) return _internal_i64(); } -inline ::io::substrait::Type_I64* ParameterizedType::unsafe_arena_release_i64() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.i64) +inline ::substrait::Type_I64* ParameterizedType::unsafe_arena_release_i64() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i64) if (_internal_has_i64()) { clear_has_kind(); - ::io::substrait::Type_I64* temp = kind_.i64_; + ::substrait::Type_I64* temp = kind_.i64_; kind_.i64_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_i64(::io::substrait::Type_I64* i64) { +inline void ParameterizedType::unsafe_arena_set_allocated_i64(::substrait::Type_I64* i64) { clear_kind(); if (i64) { set_has_i64(); kind_.i64_ = i64; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.i64) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i64) } -inline ::io::substrait::Type_I64* ParameterizedType::_internal_mutable_i64() { +inline ::substrait::Type_I64* ParameterizedType::_internal_mutable_i64() { if (!_internal_has_i64()) { clear_kind(); set_has_i64(); - kind_.i64_ = CreateMaybeMessage< ::io::substrait::Type_I64 >(GetArena()); + kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArena()); } return kind_.i64_; } -inline ::io::substrait::Type_I64* ParameterizedType::mutable_i64() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.i64) +inline ::substrait::Type_I64* ParameterizedType::mutable_i64() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i64) return _internal_mutable_i64(); } -// .io.substrait.Type.FP32 fp32 = 10; +// .substrait.Type.FP32 fp32 = 10; inline bool ParameterizedType::_internal_has_fp32() const { return kind_case() == kFp32; } @@ -4754,11 +4751,11 @@ inline bool ParameterizedType::has_fp32() const { inline void ParameterizedType::set_has_fp32() { _oneof_case_[0] = kFp32; } -inline ::io::substrait::Type_FP32* ParameterizedType::release_fp32() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.fp32) +inline ::substrait::Type_FP32* ParameterizedType::release_fp32() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fp32) if (_internal_has_fp32()) { clear_has_kind(); - ::io::substrait::Type_FP32* temp = kind_.fp32_; + ::substrait::Type_FP32* temp = kind_.fp32_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4768,48 +4765,48 @@ inline ::io::substrait::Type_FP32* ParameterizedType::release_fp32() { return nullptr; } } -inline const ::io::substrait::Type_FP32& ParameterizedType::_internal_fp32() const { +inline const ::substrait::Type_FP32& ParameterizedType::_internal_fp32() const { return _internal_has_fp32() ? *kind_.fp32_ - : reinterpret_cast< ::io::substrait::Type_FP32&>(::io::substrait::_Type_FP32_default_instance_); + : reinterpret_cast< ::substrait::Type_FP32&>(::substrait::_Type_FP32_default_instance_); } -inline const ::io::substrait::Type_FP32& ParameterizedType::fp32() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.fp32) +inline const ::substrait::Type_FP32& ParameterizedType::fp32() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fp32) return _internal_fp32(); } -inline ::io::substrait::Type_FP32* ParameterizedType::unsafe_arena_release_fp32() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.fp32) +inline ::substrait::Type_FP32* ParameterizedType::unsafe_arena_release_fp32() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fp32) if (_internal_has_fp32()) { clear_has_kind(); - ::io::substrait::Type_FP32* temp = kind_.fp32_; + ::substrait::Type_FP32* temp = kind_.fp32_; kind_.fp32_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_fp32(::io::substrait::Type_FP32* fp32) { +inline void ParameterizedType::unsafe_arena_set_allocated_fp32(::substrait::Type_FP32* fp32) { clear_kind(); if (fp32) { set_has_fp32(); kind_.fp32_ = fp32; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.fp32) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fp32) } -inline ::io::substrait::Type_FP32* ParameterizedType::_internal_mutable_fp32() { +inline ::substrait::Type_FP32* ParameterizedType::_internal_mutable_fp32() { if (!_internal_has_fp32()) { clear_kind(); set_has_fp32(); - kind_.fp32_ = CreateMaybeMessage< ::io::substrait::Type_FP32 >(GetArena()); + kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArena()); } return kind_.fp32_; } -inline ::io::substrait::Type_FP32* ParameterizedType::mutable_fp32() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.fp32) +inline ::substrait::Type_FP32* ParameterizedType::mutable_fp32() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fp32) return _internal_mutable_fp32(); } -// .io.substrait.Type.FP64 fp64 = 11; +// .substrait.Type.FP64 fp64 = 11; inline bool ParameterizedType::_internal_has_fp64() const { return kind_case() == kFp64; } @@ -4819,11 +4816,11 @@ inline bool ParameterizedType::has_fp64() const { inline void ParameterizedType::set_has_fp64() { _oneof_case_[0] = kFp64; } -inline ::io::substrait::Type_FP64* ParameterizedType::release_fp64() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.fp64) +inline ::substrait::Type_FP64* ParameterizedType::release_fp64() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fp64) if (_internal_has_fp64()) { clear_has_kind(); - ::io::substrait::Type_FP64* temp = kind_.fp64_; + ::substrait::Type_FP64* temp = kind_.fp64_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4833,48 +4830,48 @@ inline ::io::substrait::Type_FP64* ParameterizedType::release_fp64() { return nullptr; } } -inline const ::io::substrait::Type_FP64& ParameterizedType::_internal_fp64() const { +inline const ::substrait::Type_FP64& ParameterizedType::_internal_fp64() const { return _internal_has_fp64() ? *kind_.fp64_ - : reinterpret_cast< ::io::substrait::Type_FP64&>(::io::substrait::_Type_FP64_default_instance_); + : reinterpret_cast< ::substrait::Type_FP64&>(::substrait::_Type_FP64_default_instance_); } -inline const ::io::substrait::Type_FP64& ParameterizedType::fp64() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.fp64) +inline const ::substrait::Type_FP64& ParameterizedType::fp64() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fp64) return _internal_fp64(); } -inline ::io::substrait::Type_FP64* ParameterizedType::unsafe_arena_release_fp64() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.fp64) +inline ::substrait::Type_FP64* ParameterizedType::unsafe_arena_release_fp64() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fp64) if (_internal_has_fp64()) { clear_has_kind(); - ::io::substrait::Type_FP64* temp = kind_.fp64_; + ::substrait::Type_FP64* temp = kind_.fp64_; kind_.fp64_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_fp64(::io::substrait::Type_FP64* fp64) { +inline void ParameterizedType::unsafe_arena_set_allocated_fp64(::substrait::Type_FP64* fp64) { clear_kind(); if (fp64) { set_has_fp64(); kind_.fp64_ = fp64; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.fp64) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fp64) } -inline ::io::substrait::Type_FP64* ParameterizedType::_internal_mutable_fp64() { +inline ::substrait::Type_FP64* ParameterizedType::_internal_mutable_fp64() { if (!_internal_has_fp64()) { clear_kind(); set_has_fp64(); - kind_.fp64_ = CreateMaybeMessage< ::io::substrait::Type_FP64 >(GetArena()); + kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArena()); } return kind_.fp64_; } -inline ::io::substrait::Type_FP64* ParameterizedType::mutable_fp64() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.fp64) +inline ::substrait::Type_FP64* ParameterizedType::mutable_fp64() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fp64) return _internal_mutable_fp64(); } -// .io.substrait.Type.String string = 12; +// .substrait.Type.String string = 12; inline bool ParameterizedType::_internal_has_string() const { return kind_case() == kString; } @@ -4884,11 +4881,11 @@ inline bool ParameterizedType::has_string() const { inline void ParameterizedType::set_has_string() { _oneof_case_[0] = kString; } -inline ::io::substrait::Type_String* ParameterizedType::release_string() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.string) +inline ::substrait::Type_String* ParameterizedType::release_string() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.string) if (_internal_has_string()) { clear_has_kind(); - ::io::substrait::Type_String* temp = kind_.string_; + ::substrait::Type_String* temp = kind_.string_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4898,48 +4895,48 @@ inline ::io::substrait::Type_String* ParameterizedType::release_string() { return nullptr; } } -inline const ::io::substrait::Type_String& ParameterizedType::_internal_string() const { +inline const ::substrait::Type_String& ParameterizedType::_internal_string() const { return _internal_has_string() ? *kind_.string_ - : reinterpret_cast< ::io::substrait::Type_String&>(::io::substrait::_Type_String_default_instance_); + : reinterpret_cast< ::substrait::Type_String&>(::substrait::_Type_String_default_instance_); } -inline const ::io::substrait::Type_String& ParameterizedType::string() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.string) +inline const ::substrait::Type_String& ParameterizedType::string() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.string) return _internal_string(); } -inline ::io::substrait::Type_String* ParameterizedType::unsafe_arena_release_string() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.string) +inline ::substrait::Type_String* ParameterizedType::unsafe_arena_release_string() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.string) if (_internal_has_string()) { clear_has_kind(); - ::io::substrait::Type_String* temp = kind_.string_; + ::substrait::Type_String* temp = kind_.string_; kind_.string_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_string(::io::substrait::Type_String* string) { +inline void ParameterizedType::unsafe_arena_set_allocated_string(::substrait::Type_String* string) { clear_kind(); if (string) { set_has_string(); kind_.string_ = string; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.string) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.string) } -inline ::io::substrait::Type_String* ParameterizedType::_internal_mutable_string() { +inline ::substrait::Type_String* ParameterizedType::_internal_mutable_string() { if (!_internal_has_string()) { clear_kind(); set_has_string(); - kind_.string_ = CreateMaybeMessage< ::io::substrait::Type_String >(GetArena()); + kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArena()); } return kind_.string_; } -inline ::io::substrait::Type_String* ParameterizedType::mutable_string() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.string) +inline ::substrait::Type_String* ParameterizedType::mutable_string() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.string) return _internal_mutable_string(); } -// .io.substrait.Type.Binary binary = 13; +// .substrait.Type.Binary binary = 13; inline bool ParameterizedType::_internal_has_binary() const { return kind_case() == kBinary; } @@ -4949,11 +4946,11 @@ inline bool ParameterizedType::has_binary() const { inline void ParameterizedType::set_has_binary() { _oneof_case_[0] = kBinary; } -inline ::io::substrait::Type_Binary* ParameterizedType::release_binary() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.binary) +inline ::substrait::Type_Binary* ParameterizedType::release_binary() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.binary) if (_internal_has_binary()) { clear_has_kind(); - ::io::substrait::Type_Binary* temp = kind_.binary_; + ::substrait::Type_Binary* temp = kind_.binary_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -4963,48 +4960,48 @@ inline ::io::substrait::Type_Binary* ParameterizedType::release_binary() { return nullptr; } } -inline const ::io::substrait::Type_Binary& ParameterizedType::_internal_binary() const { +inline const ::substrait::Type_Binary& ParameterizedType::_internal_binary() const { return _internal_has_binary() ? *kind_.binary_ - : reinterpret_cast< ::io::substrait::Type_Binary&>(::io::substrait::_Type_Binary_default_instance_); + : reinterpret_cast< ::substrait::Type_Binary&>(::substrait::_Type_Binary_default_instance_); } -inline const ::io::substrait::Type_Binary& ParameterizedType::binary() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.binary) +inline const ::substrait::Type_Binary& ParameterizedType::binary() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.binary) return _internal_binary(); } -inline ::io::substrait::Type_Binary* ParameterizedType::unsafe_arena_release_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.binary) +inline ::substrait::Type_Binary* ParameterizedType::unsafe_arena_release_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.binary) if (_internal_has_binary()) { clear_has_kind(); - ::io::substrait::Type_Binary* temp = kind_.binary_; + ::substrait::Type_Binary* temp = kind_.binary_; kind_.binary_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_binary(::io::substrait::Type_Binary* binary) { +inline void ParameterizedType::unsafe_arena_set_allocated_binary(::substrait::Type_Binary* binary) { clear_kind(); if (binary) { set_has_binary(); kind_.binary_ = binary; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.binary) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.binary) } -inline ::io::substrait::Type_Binary* ParameterizedType::_internal_mutable_binary() { +inline ::substrait::Type_Binary* ParameterizedType::_internal_mutable_binary() { if (!_internal_has_binary()) { clear_kind(); set_has_binary(); - kind_.binary_ = CreateMaybeMessage< ::io::substrait::Type_Binary >(GetArena()); + kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArena()); } return kind_.binary_; } -inline ::io::substrait::Type_Binary* ParameterizedType::mutable_binary() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.binary) +inline ::substrait::Type_Binary* ParameterizedType::mutable_binary() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.binary) return _internal_mutable_binary(); } -// .io.substrait.Type.Timestamp timestamp = 14; +// .substrait.Type.Timestamp timestamp = 14; inline bool ParameterizedType::_internal_has_timestamp() const { return kind_case() == kTimestamp; } @@ -5014,11 +5011,11 @@ inline bool ParameterizedType::has_timestamp() const { inline void ParameterizedType::set_has_timestamp() { _oneof_case_[0] = kTimestamp; } -inline ::io::substrait::Type_Timestamp* ParameterizedType::release_timestamp() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.timestamp) +inline ::substrait::Type_Timestamp* ParameterizedType::release_timestamp() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.timestamp) if (_internal_has_timestamp()) { clear_has_kind(); - ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + ::substrait::Type_Timestamp* temp = kind_.timestamp_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5028,48 +5025,48 @@ inline ::io::substrait::Type_Timestamp* ParameterizedType::release_timestamp() { return nullptr; } } -inline const ::io::substrait::Type_Timestamp& ParameterizedType::_internal_timestamp() const { +inline const ::substrait::Type_Timestamp& ParameterizedType::_internal_timestamp() const { return _internal_has_timestamp() ? *kind_.timestamp_ - : reinterpret_cast< ::io::substrait::Type_Timestamp&>(::io::substrait::_Type_Timestamp_default_instance_); + : reinterpret_cast< ::substrait::Type_Timestamp&>(::substrait::_Type_Timestamp_default_instance_); } -inline const ::io::substrait::Type_Timestamp& ParameterizedType::timestamp() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.timestamp) +inline const ::substrait::Type_Timestamp& ParameterizedType::timestamp() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.timestamp) return _internal_timestamp(); } -inline ::io::substrait::Type_Timestamp* ParameterizedType::unsafe_arena_release_timestamp() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.timestamp) +inline ::substrait::Type_Timestamp* ParameterizedType::unsafe_arena_release_timestamp() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.timestamp) if (_internal_has_timestamp()) { clear_has_kind(); - ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + ::substrait::Type_Timestamp* temp = kind_.timestamp_; kind_.timestamp_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { +inline void ParameterizedType::unsafe_arena_set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { clear_kind(); if (timestamp) { set_has_timestamp(); kind_.timestamp_ = timestamp; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.timestamp) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.timestamp) } -inline ::io::substrait::Type_Timestamp* ParameterizedType::_internal_mutable_timestamp() { +inline ::substrait::Type_Timestamp* ParameterizedType::_internal_mutable_timestamp() { if (!_internal_has_timestamp()) { clear_kind(); set_has_timestamp(); - kind_.timestamp_ = CreateMaybeMessage< ::io::substrait::Type_Timestamp >(GetArena()); + kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArena()); } return kind_.timestamp_; } -inline ::io::substrait::Type_Timestamp* ParameterizedType::mutable_timestamp() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.timestamp) +inline ::substrait::Type_Timestamp* ParameterizedType::mutable_timestamp() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.timestamp) return _internal_mutable_timestamp(); } -// .io.substrait.Type.Date date = 16; +// .substrait.Type.Date date = 16; inline bool ParameterizedType::_internal_has_date() const { return kind_case() == kDate; } @@ -5079,11 +5076,11 @@ inline bool ParameterizedType::has_date() const { inline void ParameterizedType::set_has_date() { _oneof_case_[0] = kDate; } -inline ::io::substrait::Type_Date* ParameterizedType::release_date() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.date) +inline ::substrait::Type_Date* ParameterizedType::release_date() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.date) if (_internal_has_date()) { clear_has_kind(); - ::io::substrait::Type_Date* temp = kind_.date_; + ::substrait::Type_Date* temp = kind_.date_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5093,48 +5090,48 @@ inline ::io::substrait::Type_Date* ParameterizedType::release_date() { return nullptr; } } -inline const ::io::substrait::Type_Date& ParameterizedType::_internal_date() const { +inline const ::substrait::Type_Date& ParameterizedType::_internal_date() const { return _internal_has_date() ? *kind_.date_ - : reinterpret_cast< ::io::substrait::Type_Date&>(::io::substrait::_Type_Date_default_instance_); + : reinterpret_cast< ::substrait::Type_Date&>(::substrait::_Type_Date_default_instance_); } -inline const ::io::substrait::Type_Date& ParameterizedType::date() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.date) +inline const ::substrait::Type_Date& ParameterizedType::date() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.date) return _internal_date(); } -inline ::io::substrait::Type_Date* ParameterizedType::unsafe_arena_release_date() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.date) +inline ::substrait::Type_Date* ParameterizedType::unsafe_arena_release_date() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.date) if (_internal_has_date()) { clear_has_kind(); - ::io::substrait::Type_Date* temp = kind_.date_; + ::substrait::Type_Date* temp = kind_.date_; kind_.date_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_date(::io::substrait::Type_Date* date) { +inline void ParameterizedType::unsafe_arena_set_allocated_date(::substrait::Type_Date* date) { clear_kind(); if (date) { set_has_date(); kind_.date_ = date; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.date) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.date) } -inline ::io::substrait::Type_Date* ParameterizedType::_internal_mutable_date() { +inline ::substrait::Type_Date* ParameterizedType::_internal_mutable_date() { if (!_internal_has_date()) { clear_kind(); set_has_date(); - kind_.date_ = CreateMaybeMessage< ::io::substrait::Type_Date >(GetArena()); + kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArena()); } return kind_.date_; } -inline ::io::substrait::Type_Date* ParameterizedType::mutable_date() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.date) +inline ::substrait::Type_Date* ParameterizedType::mutable_date() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.date) return _internal_mutable_date(); } -// .io.substrait.Type.Time time = 17; +// .substrait.Type.Time time = 17; inline bool ParameterizedType::_internal_has_time() const { return kind_case() == kTime; } @@ -5144,11 +5141,11 @@ inline bool ParameterizedType::has_time() const { inline void ParameterizedType::set_has_time() { _oneof_case_[0] = kTime; } -inline ::io::substrait::Type_Time* ParameterizedType::release_time() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.time) +inline ::substrait::Type_Time* ParameterizedType::release_time() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.time) if (_internal_has_time()) { clear_has_kind(); - ::io::substrait::Type_Time* temp = kind_.time_; + ::substrait::Type_Time* temp = kind_.time_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5158,48 +5155,48 @@ inline ::io::substrait::Type_Time* ParameterizedType::release_time() { return nullptr; } } -inline const ::io::substrait::Type_Time& ParameterizedType::_internal_time() const { +inline const ::substrait::Type_Time& ParameterizedType::_internal_time() const { return _internal_has_time() ? *kind_.time_ - : reinterpret_cast< ::io::substrait::Type_Time&>(::io::substrait::_Type_Time_default_instance_); + : reinterpret_cast< ::substrait::Type_Time&>(::substrait::_Type_Time_default_instance_); } -inline const ::io::substrait::Type_Time& ParameterizedType::time() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.time) +inline const ::substrait::Type_Time& ParameterizedType::time() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.time) return _internal_time(); } -inline ::io::substrait::Type_Time* ParameterizedType::unsafe_arena_release_time() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.time) +inline ::substrait::Type_Time* ParameterizedType::unsafe_arena_release_time() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.time) if (_internal_has_time()) { clear_has_kind(); - ::io::substrait::Type_Time* temp = kind_.time_; + ::substrait::Type_Time* temp = kind_.time_; kind_.time_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_time(::io::substrait::Type_Time* time) { +inline void ParameterizedType::unsafe_arena_set_allocated_time(::substrait::Type_Time* time) { clear_kind(); if (time) { set_has_time(); kind_.time_ = time; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.time) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.time) } -inline ::io::substrait::Type_Time* ParameterizedType::_internal_mutable_time() { +inline ::substrait::Type_Time* ParameterizedType::_internal_mutable_time() { if (!_internal_has_time()) { clear_kind(); set_has_time(); - kind_.time_ = CreateMaybeMessage< ::io::substrait::Type_Time >(GetArena()); + kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArena()); } return kind_.time_; } -inline ::io::substrait::Type_Time* ParameterizedType::mutable_time() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.time) +inline ::substrait::Type_Time* ParameterizedType::mutable_time() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.time) return _internal_mutable_time(); } -// .io.substrait.Type.IntervalYear interval_year = 19; +// .substrait.Type.IntervalYear interval_year = 19; inline bool ParameterizedType::_internal_has_interval_year() const { return kind_case() == kIntervalYear; } @@ -5209,11 +5206,11 @@ inline bool ParameterizedType::has_interval_year() const { inline void ParameterizedType::set_has_interval_year() { _oneof_case_[0] = kIntervalYear; } -inline ::io::substrait::Type_IntervalYear* ParameterizedType::release_interval_year() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.interval_year) +inline ::substrait::Type_IntervalYear* ParameterizedType::release_interval_year() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.interval_year) if (_internal_has_interval_year()) { clear_has_kind(); - ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + ::substrait::Type_IntervalYear* temp = kind_.interval_year_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5223,48 +5220,48 @@ inline ::io::substrait::Type_IntervalYear* ParameterizedType::release_interval_y return nullptr; } } -inline const ::io::substrait::Type_IntervalYear& ParameterizedType::_internal_interval_year() const { +inline const ::substrait::Type_IntervalYear& ParameterizedType::_internal_interval_year() const { return _internal_has_interval_year() ? *kind_.interval_year_ - : reinterpret_cast< ::io::substrait::Type_IntervalYear&>(::io::substrait::_Type_IntervalYear_default_instance_); + : reinterpret_cast< ::substrait::Type_IntervalYear&>(::substrait::_Type_IntervalYear_default_instance_); } -inline const ::io::substrait::Type_IntervalYear& ParameterizedType::interval_year() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.interval_year) +inline const ::substrait::Type_IntervalYear& ParameterizedType::interval_year() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.interval_year) return _internal_interval_year(); } -inline ::io::substrait::Type_IntervalYear* ParameterizedType::unsafe_arena_release_interval_year() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.interval_year) +inline ::substrait::Type_IntervalYear* ParameterizedType::unsafe_arena_release_interval_year() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.interval_year) if (_internal_has_interval_year()) { clear_has_kind(); - ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + ::substrait::Type_IntervalYear* temp = kind_.interval_year_; kind_.interval_year_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { +inline void ParameterizedType::unsafe_arena_set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { clear_kind(); if (interval_year) { set_has_interval_year(); kind_.interval_year_ = interval_year; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.interval_year) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.interval_year) } -inline ::io::substrait::Type_IntervalYear* ParameterizedType::_internal_mutable_interval_year() { +inline ::substrait::Type_IntervalYear* ParameterizedType::_internal_mutable_interval_year() { if (!_internal_has_interval_year()) { clear_kind(); set_has_interval_year(); - kind_.interval_year_ = CreateMaybeMessage< ::io::substrait::Type_IntervalYear >(GetArena()); + kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArena()); } return kind_.interval_year_; } -inline ::io::substrait::Type_IntervalYear* ParameterizedType::mutable_interval_year() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.interval_year) +inline ::substrait::Type_IntervalYear* ParameterizedType::mutable_interval_year() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.interval_year) return _internal_mutable_interval_year(); } -// .io.substrait.Type.IntervalDay interval_day = 20; +// .substrait.Type.IntervalDay interval_day = 20; inline bool ParameterizedType::_internal_has_interval_day() const { return kind_case() == kIntervalDay; } @@ -5274,11 +5271,11 @@ inline bool ParameterizedType::has_interval_day() const { inline void ParameterizedType::set_has_interval_day() { _oneof_case_[0] = kIntervalDay; } -inline ::io::substrait::Type_IntervalDay* ParameterizedType::release_interval_day() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.interval_day) +inline ::substrait::Type_IntervalDay* ParameterizedType::release_interval_day() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.interval_day) if (_internal_has_interval_day()) { clear_has_kind(); - ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + ::substrait::Type_IntervalDay* temp = kind_.interval_day_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5288,48 +5285,48 @@ inline ::io::substrait::Type_IntervalDay* ParameterizedType::release_interval_da return nullptr; } } -inline const ::io::substrait::Type_IntervalDay& ParameterizedType::_internal_interval_day() const { +inline const ::substrait::Type_IntervalDay& ParameterizedType::_internal_interval_day() const { return _internal_has_interval_day() ? *kind_.interval_day_ - : reinterpret_cast< ::io::substrait::Type_IntervalDay&>(::io::substrait::_Type_IntervalDay_default_instance_); + : reinterpret_cast< ::substrait::Type_IntervalDay&>(::substrait::_Type_IntervalDay_default_instance_); } -inline const ::io::substrait::Type_IntervalDay& ParameterizedType::interval_day() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.interval_day) +inline const ::substrait::Type_IntervalDay& ParameterizedType::interval_day() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.interval_day) return _internal_interval_day(); } -inline ::io::substrait::Type_IntervalDay* ParameterizedType::unsafe_arena_release_interval_day() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.interval_day) +inline ::substrait::Type_IntervalDay* ParameterizedType::unsafe_arena_release_interval_day() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.interval_day) if (_internal_has_interval_day()) { clear_has_kind(); - ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + ::substrait::Type_IntervalDay* temp = kind_.interval_day_; kind_.interval_day_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { +inline void ParameterizedType::unsafe_arena_set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { clear_kind(); if (interval_day) { set_has_interval_day(); kind_.interval_day_ = interval_day; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.interval_day) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.interval_day) } -inline ::io::substrait::Type_IntervalDay* ParameterizedType::_internal_mutable_interval_day() { +inline ::substrait::Type_IntervalDay* ParameterizedType::_internal_mutable_interval_day() { if (!_internal_has_interval_day()) { clear_kind(); set_has_interval_day(); - kind_.interval_day_ = CreateMaybeMessage< ::io::substrait::Type_IntervalDay >(GetArena()); + kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArena()); } return kind_.interval_day_; } -inline ::io::substrait::Type_IntervalDay* ParameterizedType::mutable_interval_day() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.interval_day) +inline ::substrait::Type_IntervalDay* ParameterizedType::mutable_interval_day() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.interval_day) return _internal_mutable_interval_day(); } -// .io.substrait.Type.TimestampTZ timestamp_tz = 29; +// .substrait.Type.TimestampTZ timestamp_tz = 29; inline bool ParameterizedType::_internal_has_timestamp_tz() const { return kind_case() == kTimestampTz; } @@ -5339,11 +5336,11 @@ inline bool ParameterizedType::has_timestamp_tz() const { inline void ParameterizedType::set_has_timestamp_tz() { _oneof_case_[0] = kTimestampTz; } -inline ::io::substrait::Type_TimestampTZ* ParameterizedType::release_timestamp_tz() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.timestamp_tz) +inline ::substrait::Type_TimestampTZ* ParameterizedType::release_timestamp_tz() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.timestamp_tz) if (_internal_has_timestamp_tz()) { clear_has_kind(); - ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5353,48 +5350,48 @@ inline ::io::substrait::Type_TimestampTZ* ParameterizedType::release_timestamp_t return nullptr; } } -inline const ::io::substrait::Type_TimestampTZ& ParameterizedType::_internal_timestamp_tz() const { +inline const ::substrait::Type_TimestampTZ& ParameterizedType::_internal_timestamp_tz() const { return _internal_has_timestamp_tz() ? *kind_.timestamp_tz_ - : reinterpret_cast< ::io::substrait::Type_TimestampTZ&>(::io::substrait::_Type_TimestampTZ_default_instance_); + : reinterpret_cast< ::substrait::Type_TimestampTZ&>(::substrait::_Type_TimestampTZ_default_instance_); } -inline const ::io::substrait::Type_TimestampTZ& ParameterizedType::timestamp_tz() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.timestamp_tz) +inline const ::substrait::Type_TimestampTZ& ParameterizedType::timestamp_tz() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.timestamp_tz) return _internal_timestamp_tz(); } -inline ::io::substrait::Type_TimestampTZ* ParameterizedType::unsafe_arena_release_timestamp_tz() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.timestamp_tz) +inline ::substrait::Type_TimestampTZ* ParameterizedType::unsafe_arena_release_timestamp_tz() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.timestamp_tz) if (_internal_has_timestamp_tz()) { clear_has_kind(); - ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; kind_.timestamp_tz_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { +inline void ParameterizedType::unsafe_arena_set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { clear_kind(); if (timestamp_tz) { set_has_timestamp_tz(); kind_.timestamp_tz_ = timestamp_tz; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.timestamp_tz) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.timestamp_tz) } -inline ::io::substrait::Type_TimestampTZ* ParameterizedType::_internal_mutable_timestamp_tz() { +inline ::substrait::Type_TimestampTZ* ParameterizedType::_internal_mutable_timestamp_tz() { if (!_internal_has_timestamp_tz()) { clear_kind(); set_has_timestamp_tz(); - kind_.timestamp_tz_ = CreateMaybeMessage< ::io::substrait::Type_TimestampTZ >(GetArena()); + kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArena()); } return kind_.timestamp_tz_; } -inline ::io::substrait::Type_TimestampTZ* ParameterizedType::mutable_timestamp_tz() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.timestamp_tz) +inline ::substrait::Type_TimestampTZ* ParameterizedType::mutable_timestamp_tz() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.timestamp_tz) return _internal_mutable_timestamp_tz(); } -// .io.substrait.Type.UUID uuid = 32; +// .substrait.Type.UUID uuid = 32; inline bool ParameterizedType::_internal_has_uuid() const { return kind_case() == kUuid; } @@ -5404,11 +5401,11 @@ inline bool ParameterizedType::has_uuid() const { inline void ParameterizedType::set_has_uuid() { _oneof_case_[0] = kUuid; } -inline ::io::substrait::Type_UUID* ParameterizedType::release_uuid() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.uuid) +inline ::substrait::Type_UUID* ParameterizedType::release_uuid() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.uuid) if (_internal_has_uuid()) { clear_has_kind(); - ::io::substrait::Type_UUID* temp = kind_.uuid_; + ::substrait::Type_UUID* temp = kind_.uuid_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5418,48 +5415,48 @@ inline ::io::substrait::Type_UUID* ParameterizedType::release_uuid() { return nullptr; } } -inline const ::io::substrait::Type_UUID& ParameterizedType::_internal_uuid() const { +inline const ::substrait::Type_UUID& ParameterizedType::_internal_uuid() const { return _internal_has_uuid() ? *kind_.uuid_ - : reinterpret_cast< ::io::substrait::Type_UUID&>(::io::substrait::_Type_UUID_default_instance_); + : reinterpret_cast< ::substrait::Type_UUID&>(::substrait::_Type_UUID_default_instance_); } -inline const ::io::substrait::Type_UUID& ParameterizedType::uuid() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.uuid) +inline const ::substrait::Type_UUID& ParameterizedType::uuid() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.uuid) return _internal_uuid(); } -inline ::io::substrait::Type_UUID* ParameterizedType::unsafe_arena_release_uuid() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.uuid) +inline ::substrait::Type_UUID* ParameterizedType::unsafe_arena_release_uuid() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.uuid) if (_internal_has_uuid()) { clear_has_kind(); - ::io::substrait::Type_UUID* temp = kind_.uuid_; + ::substrait::Type_UUID* temp = kind_.uuid_; kind_.uuid_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_uuid(::io::substrait::Type_UUID* uuid) { +inline void ParameterizedType::unsafe_arena_set_allocated_uuid(::substrait::Type_UUID* uuid) { clear_kind(); if (uuid) { set_has_uuid(); kind_.uuid_ = uuid; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.uuid) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.uuid) } -inline ::io::substrait::Type_UUID* ParameterizedType::_internal_mutable_uuid() { +inline ::substrait::Type_UUID* ParameterizedType::_internal_mutable_uuid() { if (!_internal_has_uuid()) { clear_kind(); set_has_uuid(); - kind_.uuid_ = CreateMaybeMessage< ::io::substrait::Type_UUID >(GetArena()); + kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArena()); } return kind_.uuid_; } -inline ::io::substrait::Type_UUID* ParameterizedType::mutable_uuid() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.uuid) +inline ::substrait::Type_UUID* ParameterizedType::mutable_uuid() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.uuid) return _internal_mutable_uuid(); } -// .io.substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; +// .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; inline bool ParameterizedType::_internal_has_fixed_char() const { return kind_case() == kFixedChar; } @@ -5477,11 +5474,11 @@ inline void ParameterizedType::clear_fixed_char() { clear_has_kind(); } } -inline ::io::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::release_fixed_char() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.fixed_char) +inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::release_fixed_char() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fixed_char) if (_internal_has_fixed_char()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_; + ::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5491,48 +5488,48 @@ inline ::io::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedT return nullptr; } } -inline const ::io::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::_internal_fixed_char() const { +inline const ::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::_internal_fixed_char() const { return _internal_has_fixed_char() ? *kind_.fixed_char_ - : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedFixedChar&>(::io::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_); + : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedFixedChar&>(::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_); } -inline const ::io::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::fixed_char() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.fixed_char) +inline const ::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::fixed_char() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fixed_char) return _internal_fixed_char(); } -inline ::io::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::unsafe_arena_release_fixed_char() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.fixed_char) +inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::unsafe_arena_release_fixed_char() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fixed_char) if (_internal_has_fixed_char()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_; + ::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_; kind_.fixed_char_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_fixed_char(::io::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) { +inline void ParameterizedType::unsafe_arena_set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) { clear_kind(); if (fixed_char) { set_has_fixed_char(); kind_.fixed_char_ = fixed_char; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.fixed_char) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fixed_char) } -inline ::io::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::_internal_mutable_fixed_char() { +inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::_internal_mutable_fixed_char() { if (!_internal_has_fixed_char()) { clear_kind(); set_has_fixed_char(); - kind_.fixed_char_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedFixedChar >(GetArena()); + kind_.fixed_char_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedChar >(GetArena()); } return kind_.fixed_char_; } -inline ::io::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::mutable_fixed_char() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.fixed_char) +inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::mutable_fixed_char() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fixed_char) return _internal_mutable_fixed_char(); } -// .io.substrait.ParameterizedType.ParameterizedVarChar varchar = 22; +// .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; inline bool ParameterizedType::_internal_has_varchar() const { return kind_case() == kVarchar; } @@ -5550,11 +5547,11 @@ inline void ParameterizedType::clear_varchar() { clear_has_kind(); } } -inline ::io::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::release_varchar() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.varchar) +inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::release_varchar() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.varchar) if (_internal_has_varchar()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_; + ::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5564,48 +5561,48 @@ inline ::io::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedTyp return nullptr; } } -inline const ::io::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::_internal_varchar() const { +inline const ::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::_internal_varchar() const { return _internal_has_varchar() ? *kind_.varchar_ - : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedVarChar&>(::io::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_); + : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedVarChar&>(::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_); } -inline const ::io::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::varchar() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.varchar) +inline const ::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::varchar() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.varchar) return _internal_varchar(); } -inline ::io::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::unsafe_arena_release_varchar() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.varchar) +inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::unsafe_arena_release_varchar() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.varchar) if (_internal_has_varchar()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_; + ::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_; kind_.varchar_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_varchar(::io::substrait::ParameterizedType_ParameterizedVarChar* varchar) { +inline void ParameterizedType::unsafe_arena_set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar) { clear_kind(); if (varchar) { set_has_varchar(); kind_.varchar_ = varchar; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.varchar) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.varchar) } -inline ::io::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::_internal_mutable_varchar() { +inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::_internal_mutable_varchar() { if (!_internal_has_varchar()) { clear_kind(); set_has_varchar(); - kind_.varchar_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedVarChar >(GetArena()); + kind_.varchar_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedVarChar >(GetArena()); } return kind_.varchar_; } -inline ::io::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::mutable_varchar() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.varchar) +inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::mutable_varchar() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.varchar) return _internal_mutable_varchar(); } -// .io.substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; +// .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; inline bool ParameterizedType::_internal_has_fixed_binary() const { return kind_case() == kFixedBinary; } @@ -5623,11 +5620,11 @@ inline void ParameterizedType::clear_fixed_binary() { clear_has_kind(); } } -inline ::io::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::release_fixed_binary() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.fixed_binary) +inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::release_fixed_binary() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fixed_binary) if (_internal_has_fixed_binary()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_; + ::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5637,48 +5634,48 @@ inline ::io::substrait::ParameterizedType_ParameterizedFixedBinary* Parameterize return nullptr; } } -inline const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::_internal_fixed_binary() const { +inline const ::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::_internal_fixed_binary() const { return _internal_has_fixed_binary() ? *kind_.fixed_binary_ - : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedFixedBinary&>(::io::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_); + : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedFixedBinary&>(::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_); } -inline const ::io::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::fixed_binary() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.fixed_binary) +inline const ::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::fixed_binary() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fixed_binary) return _internal_fixed_binary(); } -inline ::io::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::unsafe_arena_release_fixed_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.fixed_binary) +inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::unsafe_arena_release_fixed_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fixed_binary) if (_internal_has_fixed_binary()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_; + ::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_; kind_.fixed_binary_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_fixed_binary(::io::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) { +inline void ParameterizedType::unsafe_arena_set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) { clear_kind(); if (fixed_binary) { set_has_fixed_binary(); kind_.fixed_binary_ = fixed_binary; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.fixed_binary) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fixed_binary) } -inline ::io::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::_internal_mutable_fixed_binary() { +inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::_internal_mutable_fixed_binary() { if (!_internal_has_fixed_binary()) { clear_kind(); set_has_fixed_binary(); - kind_.fixed_binary_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedFixedBinary >(GetArena()); + kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedBinary >(GetArena()); } return kind_.fixed_binary_; } -inline ::io::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::mutable_fixed_binary() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.fixed_binary) +inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::mutable_fixed_binary() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fixed_binary) return _internal_mutable_fixed_binary(); } -// .io.substrait.ParameterizedType.ParameterizedDecimal decimal = 24; +// .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; inline bool ParameterizedType::_internal_has_decimal() const { return kind_case() == kDecimal; } @@ -5696,11 +5693,11 @@ inline void ParameterizedType::clear_decimal() { clear_has_kind(); } } -inline ::io::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::release_decimal() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.decimal) +inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::release_decimal() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.decimal) if (_internal_has_decimal()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_; + ::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5710,48 +5707,48 @@ inline ::io::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedTyp return nullptr; } } -inline const ::io::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::_internal_decimal() const { +inline const ::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::_internal_decimal() const { return _internal_has_decimal() ? *kind_.decimal_ - : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedDecimal&>(::io::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_); + : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedDecimal&>(::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_); } -inline const ::io::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::decimal() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.decimal) +inline const ::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::decimal() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.decimal) return _internal_decimal(); } -inline ::io::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::unsafe_arena_release_decimal() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.decimal) +inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::unsafe_arena_release_decimal() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.decimal) if (_internal_has_decimal()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_; + ::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_; kind_.decimal_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_decimal(::io::substrait::ParameterizedType_ParameterizedDecimal* decimal) { +inline void ParameterizedType::unsafe_arena_set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal) { clear_kind(); if (decimal) { set_has_decimal(); kind_.decimal_ = decimal; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.decimal) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.decimal) } -inline ::io::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::_internal_mutable_decimal() { +inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::_internal_mutable_decimal() { if (!_internal_has_decimal()) { clear_kind(); set_has_decimal(); - kind_.decimal_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedDecimal >(GetArena()); + kind_.decimal_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedDecimal >(GetArena()); } return kind_.decimal_; } -inline ::io::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::mutable_decimal() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.decimal) +inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::mutable_decimal() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.decimal) return _internal_mutable_decimal(); } -// .io.substrait.ParameterizedType.ParameterizedStruct struct = 25; +// .substrait.ParameterizedType.ParameterizedStruct struct = 25; inline bool ParameterizedType::_internal_has_struct_() const { return kind_case() == kStruct; } @@ -5769,11 +5766,11 @@ inline void ParameterizedType::clear_struct_() { clear_has_kind(); } } -inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.struct) +inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::release_struct_() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.struct) if (_internal_has_struct_()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__; + ::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5783,48 +5780,48 @@ inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType return nullptr; } } -inline const ::io::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::_internal_struct_() const { +inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::_internal_struct_() const { return _internal_has_struct_() ? *kind_.struct__ - : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedStruct&>(::io::substrait::_ParameterizedType_ParameterizedStruct_default_instance_); + : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedStruct&>(::substrait::_ParameterizedType_ParameterizedStruct_default_instance_); } -inline const ::io::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.struct) +inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::struct_() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.struct) return _internal_struct_(); } -inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.struct) +inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.struct) if (_internal_has_struct_()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__; + ::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__; kind_.struct__ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_struct_(::io::substrait::ParameterizedType_ParameterizedStruct* struct_) { +inline void ParameterizedType::unsafe_arena_set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) { clear_kind(); if (struct_) { set_has_struct_(); kind_.struct__ = struct_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.struct) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.struct) } -inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::_internal_mutable_struct_() { +inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::_internal_mutable_struct_() { if (!_internal_has_struct_()) { clear_kind(); set_has_struct_(); - kind_.struct__ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedStruct >(GetArena()); + kind_.struct__ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedStruct >(GetArena()); } return kind_.struct__; } -inline ::io::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.struct) +inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.struct) return _internal_mutable_struct_(); } -// .io.substrait.ParameterizedType.ParameterizedList list = 27; +// .substrait.ParameterizedType.ParameterizedList list = 27; inline bool ParameterizedType::_internal_has_list() const { return kind_case() == kList; } @@ -5842,11 +5839,11 @@ inline void ParameterizedType::clear_list() { clear_has_kind(); } } -inline ::io::substrait::ParameterizedType_ParameterizedList* ParameterizedType::release_list() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.list) +inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::release_list() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.list) if (_internal_has_list()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_; + ::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5856,48 +5853,48 @@ inline ::io::substrait::ParameterizedType_ParameterizedList* ParameterizedType:: return nullptr; } } -inline const ::io::substrait::ParameterizedType_ParameterizedList& ParameterizedType::_internal_list() const { +inline const ::substrait::ParameterizedType_ParameterizedList& ParameterizedType::_internal_list() const { return _internal_has_list() ? *kind_.list_ - : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedList&>(::io::substrait::_ParameterizedType_ParameterizedList_default_instance_); + : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedList&>(::substrait::_ParameterizedType_ParameterizedList_default_instance_); } -inline const ::io::substrait::ParameterizedType_ParameterizedList& ParameterizedType::list() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.list) +inline const ::substrait::ParameterizedType_ParameterizedList& ParameterizedType::list() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.list) return _internal_list(); } -inline ::io::substrait::ParameterizedType_ParameterizedList* ParameterizedType::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.list) +inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.list) if (_internal_has_list()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_; + ::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_; kind_.list_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_list(::io::substrait::ParameterizedType_ParameterizedList* list) { +inline void ParameterizedType::unsafe_arena_set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list) { clear_kind(); if (list) { set_has_list(); kind_.list_ = list; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.list) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.list) } -inline ::io::substrait::ParameterizedType_ParameterizedList* ParameterizedType::_internal_mutable_list() { +inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::_internal_mutable_list() { if (!_internal_has_list()) { clear_kind(); set_has_list(); - kind_.list_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedList >(GetArena()); + kind_.list_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedList >(GetArena()); } return kind_.list_; } -inline ::io::substrait::ParameterizedType_ParameterizedList* ParameterizedType::mutable_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.list) +inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::mutable_list() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.list) return _internal_mutable_list(); } -// .io.substrait.ParameterizedType.ParameterizedMap map = 28; +// .substrait.ParameterizedType.ParameterizedMap map = 28; inline bool ParameterizedType::_internal_has_map() const { return kind_case() == kMap; } @@ -5915,11 +5912,11 @@ inline void ParameterizedType::clear_map() { clear_has_kind(); } } -inline ::io::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::release_map() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.map) +inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::release_map() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.map) if (_internal_has_map()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_; + ::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5929,44 +5926,44 @@ inline ::io::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::r return nullptr; } } -inline const ::io::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::_internal_map() const { +inline const ::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::_internal_map() const { return _internal_has_map() ? *kind_.map_ - : reinterpret_cast< ::io::substrait::ParameterizedType_ParameterizedMap&>(::io::substrait::_ParameterizedType_ParameterizedMap_default_instance_); + : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedMap&>(::substrait::_ParameterizedType_ParameterizedMap_default_instance_); } -inline const ::io::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::map() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.map) +inline const ::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::map() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.map) return _internal_map(); } -inline ::io::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.map) +inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.map) if (_internal_has_map()) { clear_has_kind(); - ::io::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_; + ::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_; kind_.map_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_map(::io::substrait::ParameterizedType_ParameterizedMap* map) { +inline void ParameterizedType::unsafe_arena_set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map) { clear_kind(); if (map) { set_has_map(); kind_.map_ = map; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.map) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.map) } -inline ::io::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::_internal_mutable_map() { +inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::_internal_mutable_map() { if (!_internal_has_map()) { clear_kind(); set_has_map(); - kind_.map_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_ParameterizedMap >(GetArena()); + kind_.map_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedMap >(GetArena()); } return kind_.map_; } -inline ::io::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::mutable_map() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.map) +inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::mutable_map() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.map) return _internal_mutable_map(); } @@ -6000,15 +5997,15 @@ inline void ParameterizedType::_internal_set_user_defined_pointer(::PROTOBUF_NAM kind_.user_defined_pointer_ = value; } inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType::user_defined_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.user_defined_pointer) + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.user_defined_pointer) return _internal_user_defined_pointer(); } inline void ParameterizedType::set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_user_defined_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.ParameterizedType.user_defined_pointer) + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.user_defined_pointer) } -// .io.substrait.ParameterizedType.TypeParameter type_parameter = 33; +// .substrait.ParameterizedType.TypeParameter type_parameter = 33; inline bool ParameterizedType::_internal_has_type_parameter() const { return kind_case() == kTypeParameter; } @@ -6026,11 +6023,11 @@ inline void ParameterizedType::clear_type_parameter() { clear_has_kind(); } } -inline ::io::substrait::ParameterizedType_TypeParameter* ParameterizedType::release_type_parameter() { - // @@protoc_insertion_point(field_release:io.substrait.ParameterizedType.type_parameter) +inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::release_type_parameter() { + // @@protoc_insertion_point(field_release:substrait.ParameterizedType.type_parameter) if (_internal_has_type_parameter()) { clear_has_kind(); - ::io::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_; + ::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6040,44 +6037,44 @@ inline ::io::substrait::ParameterizedType_TypeParameter* ParameterizedType::rele return nullptr; } } -inline const ::io::substrait::ParameterizedType_TypeParameter& ParameterizedType::_internal_type_parameter() const { +inline const ::substrait::ParameterizedType_TypeParameter& ParameterizedType::_internal_type_parameter() const { return _internal_has_type_parameter() ? *kind_.type_parameter_ - : reinterpret_cast< ::io::substrait::ParameterizedType_TypeParameter&>(::io::substrait::_ParameterizedType_TypeParameter_default_instance_); + : reinterpret_cast< ::substrait::ParameterizedType_TypeParameter&>(::substrait::_ParameterizedType_TypeParameter_default_instance_); } -inline const ::io::substrait::ParameterizedType_TypeParameter& ParameterizedType::type_parameter() const { - // @@protoc_insertion_point(field_get:io.substrait.ParameterizedType.type_parameter) +inline const ::substrait::ParameterizedType_TypeParameter& ParameterizedType::type_parameter() const { + // @@protoc_insertion_point(field_get:substrait.ParameterizedType.type_parameter) return _internal_type_parameter(); } -inline ::io::substrait::ParameterizedType_TypeParameter* ParameterizedType::unsafe_arena_release_type_parameter() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ParameterizedType.type_parameter) +inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::unsafe_arena_release_type_parameter() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.type_parameter) if (_internal_has_type_parameter()) { clear_has_kind(); - ::io::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_; + ::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_; kind_.type_parameter_ = nullptr; return temp; } else { return nullptr; } } -inline void ParameterizedType::unsafe_arena_set_allocated_type_parameter(::io::substrait::ParameterizedType_TypeParameter* type_parameter) { +inline void ParameterizedType::unsafe_arena_set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter) { clear_kind(); if (type_parameter) { set_has_type_parameter(); kind_.type_parameter_ = type_parameter; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ParameterizedType.type_parameter) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.type_parameter) } -inline ::io::substrait::ParameterizedType_TypeParameter* ParameterizedType::_internal_mutable_type_parameter() { +inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::_internal_mutable_type_parameter() { if (!_internal_has_type_parameter()) { clear_kind(); set_has_type_parameter(); - kind_.type_parameter_ = CreateMaybeMessage< ::io::substrait::ParameterizedType_TypeParameter >(GetArena()); + kind_.type_parameter_ = CreateMaybeMessage< ::substrait::ParameterizedType_TypeParameter >(GetArena()); } return kind_.type_parameter_; } -inline ::io::substrait::ParameterizedType_TypeParameter* ParameterizedType::mutable_type_parameter() { - // @@protoc_insertion_point(field_mutable:io.substrait.ParameterizedType.type_parameter) +inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::mutable_type_parameter() { + // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.type_parameter) return _internal_mutable_type_parameter(); } @@ -6121,9 +6118,8 @@ inline ParameterizedType::KindCase ParameterizedType::kind_case() const { // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io // @@protoc_insertion_point(global_scope) #include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_parameterized_5ftypes_2eproto +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fparameterized_5ftypes_2eproto diff --git a/cpp/src/generated/substrait/plan.pb.cc b/cpp/src/generated/substrait/plan.pb.cc index edfbc2b7747..0e3d7c7c768 100644 --- a/cpp/src/generated/substrait/plan.pb.cc +++ b/cpp/src/generated/substrait/plan.pb.cc @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: plan.proto +// source: substrait/plan.proto -#include "plan.pb.h" +#include "substrait/plan.pb.h" #include @@ -16,7 +16,6 @@ #include PROTOBUF_PRAGMA_INIT_SEG -namespace io { namespace substrait { constexpr PlanRel::PlanRel( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) @@ -47,95 +46,94 @@ struct PlanDefaultTypeInternal { }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PlanDefaultTypeInternal _Plan_default_instance_; } // namespace substrait -} // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_plan_2eproto[2]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_plan_2eproto = nullptr; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_plan_2eproto = nullptr; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fplan_2eproto[2]; +static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fplan_2eproto = nullptr; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fplan_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_plan_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fplan_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::PlanRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::PlanRel, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::PlanRel, RelType_), + PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, rel_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Plan, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, extension_uris_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, extensions_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, relations_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, advanced_extensions_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Plan, expected_type_urls_), + PROTOBUF_FIELD_OFFSET(::substrait::Plan, extension_uris_), + PROTOBUF_FIELD_OFFSET(::substrait::Plan, extensions_), + PROTOBUF_FIELD_OFFSET(::substrait::Plan, relations_), + PROTOBUF_FIELD_OFFSET(::substrait::Plan, advanced_extensions_), + PROTOBUF_FIELD_OFFSET(::substrait::Plan, expected_type_urls_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::PlanRel)}, - { 8, -1, sizeof(::io::substrait::Plan)}, + { 0, -1, sizeof(::substrait::PlanRel)}, + { 8, -1, sizeof(::substrait::Plan)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::_PlanRel_default_instance_), - reinterpret_cast(&::io::substrait::_Plan_default_instance_), + reinterpret_cast(&::substrait::_PlanRel_default_instance_), + reinterpret_cast(&::substrait::_Plan_default_instance_), }; -const char descriptor_table_protodef_plan_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\nplan.proto\022\014io.substrait\032\017relations.pr" - "oto\032\020extensions.proto\"]\n\007PlanRel\022 \n\003rel\030" - "\001 \001(\0132\021.io.substrait.RelH\000\022%\n\004root\030\002 \001(\013" - "2\025.io.substrait.RelRootH\000B\t\n\007RelType\"\243\002\n" - "\004Plan\022C\n\016extension_uris\030\001 \003(\0132+.io.subst" - "rait.extensions.SimpleExtensionURI\022G\n\nex" - "tensions\030\002 \003(\01323.io.substrait.extensions" - ".SimpleExtensionDeclaration\022(\n\trelations" - "\030\003 \003(\0132\025.io.substrait.PlanRel\022G\n\023advance" - "d_extensions\030\004 \001(\0132*.io.substrait.extens" - "ions.AdvancedExtension\022\032\n\022expected_type_" - "urls\030\005 \003(\tB+\n\022io.substrait.protoP\001\252\002\022Sub" - "strait.Protobufb\006proto3" +const char descriptor_table_protodef_substrait_2fplan_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\024substrait/plan.proto\022\tsubstrait\032\031subst" + "rait/relations.proto\032%substrait/extensio" + "ns/extensions.proto\"X\n\007PlanRel\022\035\n\003rel\030\001 " + "\001(\0132\016.substrait.RelH\000\022\"\n\004root\030\002 \001(\0132\022.su" + "bstrait.RelRootH\000B\n\n\010rel_type\"\227\002\n\004Plan\022@" + "\n\016extension_uris\030\001 \003(\0132(.substrait.exten" + "sions.SimpleExtensionURI\022D\n\nextensions\030\002" + " \003(\01320.substrait.extensions.SimpleExtens" + "ionDeclaration\022%\n\trelations\030\003 \003(\0132\022.subs" + "trait.PlanRel\022D\n\023advanced_extensions\030\004 \001" + "(\0132\'.substrait.extensions.AdvancedExtens" + "ion\022\032\n\022expected_type_urls\030\005 \003(\tB+\n\022io.su" + "bstrait.protoP\001\252\002\022Substrait.Protobufb\006pr" + "oto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_plan_2eproto_deps[2] = { - &::descriptor_table_extensions_2eproto, - &::descriptor_table_relations_2eproto, +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fplan_2eproto_deps[2] = { + &::descriptor_table_substrait_2fextensions_2fextensions_2eproto, + &::descriptor_table_substrait_2frelations_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_plan_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_plan_2eproto = { - false, false, 503, descriptor_table_protodef_plan_2eproto, "plan.proto", - &descriptor_table_plan_2eproto_once, descriptor_table_plan_2eproto_deps, 2, 2, - schemas, file_default_instances, TableStruct_plan_2eproto::offsets, - file_level_metadata_plan_2eproto, file_level_enum_descriptors_plan_2eproto, file_level_service_descriptors_plan_2eproto, +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fplan_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fplan_2eproto = { + false, false, 524, descriptor_table_protodef_substrait_2fplan_2eproto, "substrait/plan.proto", + &descriptor_table_substrait_2fplan_2eproto_once, descriptor_table_substrait_2fplan_2eproto_deps, 2, 2, + schemas, file_default_instances, TableStruct_substrait_2fplan_2eproto::offsets, + file_level_metadata_substrait_2fplan_2eproto, file_level_enum_descriptors_substrait_2fplan_2eproto, file_level_service_descriptors_substrait_2fplan_2eproto, }; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_plan_2eproto_getter() { - return &descriptor_table_plan_2eproto; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fplan_2eproto_getter() { + return &descriptor_table_substrait_2fplan_2eproto; } // Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_plan_2eproto(&descriptor_table_plan_2eproto); -namespace io { +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fplan_2eproto(&descriptor_table_substrait_2fplan_2eproto); namespace substrait { // =================================================================== class PlanRel::_Internal { public: - static const ::io::substrait::Rel& rel(const PlanRel* msg); - static const ::io::substrait::RelRoot& root(const PlanRel* msg); + static const ::substrait::Rel& rel(const PlanRel* msg); + static const ::substrait::RelRoot& root(const PlanRel* msg); }; -const ::io::substrait::Rel& +const ::substrait::Rel& PlanRel::_Internal::rel(const PlanRel* msg) { - return *msg->RelType_.rel_; + return *msg->rel_type_.rel_; } -const ::io::substrait::RelRoot& +const ::substrait::RelRoot& PlanRel::_Internal::root(const PlanRel* msg) { - return *msg->RelType_.root_; + return *msg->rel_type_.root_; } -void PlanRel::set_allocated_rel(::io::substrait::Rel* rel) { +void PlanRel::set_allocated_rel(::substrait::Rel* rel) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (rel) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rel)->GetArena(); @@ -144,21 +142,21 @@ void PlanRel::set_allocated_rel(::io::substrait::Rel* rel) { message_arena, rel, submessage_arena); } set_has_rel(); - RelType_.rel_ = rel; + rel_type_.rel_ = rel; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.PlanRel.rel) + // @@protoc_insertion_point(field_set_allocated:substrait.PlanRel.rel) } void PlanRel::clear_rel() { if (_internal_has_rel()) { if (GetArena() == nullptr) { - delete RelType_.rel_; + delete rel_type_.rel_; } - clear_has_RelType(); + clear_has_rel_type(); } } -void PlanRel::set_allocated_root(::io::substrait::RelRoot* root) { +void PlanRel::set_allocated_root(::substrait::RelRoot* root) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (root) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(root)->GetArena(); @@ -167,58 +165,58 @@ void PlanRel::set_allocated_root(::io::substrait::RelRoot* root) { message_arena, root, submessage_arena); } set_has_root(); - RelType_.root_ = root; + rel_type_.root_ = root; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.PlanRel.root) + // @@protoc_insertion_point(field_set_allocated:substrait.PlanRel.root) } void PlanRel::clear_root() { if (_internal_has_root()) { if (GetArena() == nullptr) { - delete RelType_.root_; + delete rel_type_.root_; } - clear_has_RelType(); + clear_has_rel_type(); } } PlanRel::PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.PlanRel) + // @@protoc_insertion_point(arena_constructor:substrait.PlanRel) } PlanRel::PlanRel(const PlanRel& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_RelType(); - switch (from.RelType_case()) { + clear_has_rel_type(); + switch (from.rel_type_case()) { case kRel: { - _internal_mutable_rel()->::io::substrait::Rel::MergeFrom(from._internal_rel()); + _internal_mutable_rel()->::substrait::Rel::MergeFrom(from._internal_rel()); break; } case kRoot: { - _internal_mutable_root()->::io::substrait::RelRoot::MergeFrom(from._internal_root()); + _internal_mutable_root()->::substrait::RelRoot::MergeFrom(from._internal_root()); break; } - case RELTYPE_NOT_SET: { + case REL_TYPE_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.PlanRel) + // @@protoc_insertion_point(copy_constructor:substrait.PlanRel) } void PlanRel::SharedCtor() { -clear_has_RelType(); +clear_has_rel_type(); } PlanRel::~PlanRel() { - // @@protoc_insertion_point(destructor:io.substrait.PlanRel) + // @@protoc_insertion_point(destructor:substrait.PlanRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void PlanRel::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (has_RelType()) { - clear_RelType(); + if (has_rel_type()) { + clear_rel_type(); } } @@ -232,36 +230,36 @@ void PlanRel::SetCachedSize(int size) const { _cached_size_.Set(size); } -void PlanRel::clear_RelType() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.PlanRel) - switch (RelType_case()) { +void PlanRel::clear_rel_type() { +// @@protoc_insertion_point(one_of_clear_start:substrait.PlanRel) + switch (rel_type_case()) { case kRel: { if (GetArena() == nullptr) { - delete RelType_.rel_; + delete rel_type_.rel_; } break; } case kRoot: { if (GetArena() == nullptr) { - delete RelType_.root_; + delete rel_type_.root_; } break; } - case RELTYPE_NOT_SET: { + case REL_TYPE_NOT_SET: { break; } } - _oneof_case_[0] = RELTYPE_NOT_SET; + _oneof_case_[0] = REL_TYPE_NOT_SET; } void PlanRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.PlanRel) +// @@protoc_insertion_point(message_clear_start:substrait.PlanRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - clear_RelType(); + clear_rel_type(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -271,14 +269,14 @@ const char* PlanRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Rel rel = 1; + // .substrait.Rel rel = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_rel(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.RelRoot root = 2; + // .substrait.RelRoot root = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_root(), ptr); @@ -310,11 +308,11 @@ const char* PlanRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint8* PlanRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.PlanRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.PlanRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Rel rel = 1; + // .substrait.Rel rel = 1; if (_internal_has_rel()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -322,7 +320,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* PlanRel::_InternalSerialize( 1, _Internal::rel(this), target, stream); } - // .io.substrait.RelRoot root = 2; + // .substrait.RelRoot root = 2; if (_internal_has_root()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -334,34 +332,34 @@ ::PROTOBUF_NAMESPACE_ID::uint8* PlanRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.PlanRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.PlanRel) return target; } size_t PlanRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.PlanRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.PlanRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - switch (RelType_case()) { - // .io.substrait.Rel rel = 1; + switch (rel_type_case()) { + // .substrait.Rel rel = 1; case kRel: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.rel_); + *rel_type_.rel_); break; } - // .io.substrait.RelRoot root = 2; + // .substrait.RelRoot root = 2; case kRoot: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.root_); + *rel_type_.root_); break; } - case RELTYPE_NOT_SET: { + case REL_TYPE_NOT_SET: { break; } } @@ -375,51 +373,51 @@ size_t PlanRel::ByteSizeLong() const { } void PlanRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.PlanRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.PlanRel) GOOGLE_DCHECK_NE(&from, this); const PlanRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.PlanRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.PlanRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.PlanRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.PlanRel) MergeFrom(*source); } } void PlanRel::MergeFrom(const PlanRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.PlanRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.PlanRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - switch (from.RelType_case()) { + switch (from.rel_type_case()) { case kRel: { - _internal_mutable_rel()->::io::substrait::Rel::MergeFrom(from._internal_rel()); + _internal_mutable_rel()->::substrait::Rel::MergeFrom(from._internal_rel()); break; } case kRoot: { - _internal_mutable_root()->::io::substrait::RelRoot::MergeFrom(from._internal_root()); + _internal_mutable_root()->::substrait::RelRoot::MergeFrom(from._internal_root()); break; } - case RELTYPE_NOT_SET: { + case REL_TYPE_NOT_SET: { break; } } } void PlanRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.PlanRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.PlanRel) if (&from == this) return; Clear(); MergeFrom(from); } void PlanRel::CopyFrom(const PlanRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.PlanRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.PlanRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -432,24 +430,24 @@ bool PlanRel::IsInitialized() const { void PlanRel::InternalSwap(PlanRel* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(RelType_, other->RelType_); + swap(rel_type_, other->rel_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } ::PROTOBUF_NAMESPACE_ID::Metadata PlanRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once, - file_level_metadata_plan_2eproto[0]); + &descriptor_table_substrait_2fplan_2eproto_getter, &descriptor_table_substrait_2fplan_2eproto_once, + file_level_metadata_substrait_2fplan_2eproto[0]); } // =================================================================== class Plan::_Internal { public: - static const ::io::substrait::extensions::AdvancedExtension& advanced_extensions(const Plan* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extensions(const Plan* msg); }; -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& Plan::_Internal::advanced_extensions(const Plan* msg) { return *msg->advanced_extensions_; } @@ -473,7 +471,7 @@ Plan::Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena) expected_type_urls_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Plan) + // @@protoc_insertion_point(arena_constructor:substrait.Plan) } Plan::Plan(const Plan& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -483,11 +481,11 @@ Plan::Plan(const Plan& from) expected_type_urls_(from.expected_type_urls_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_advanced_extensions()) { - advanced_extensions_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extensions_); + advanced_extensions_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extensions_); } else { advanced_extensions_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.Plan) + // @@protoc_insertion_point(copy_constructor:substrait.Plan) } void Plan::SharedCtor() { @@ -495,7 +493,7 @@ advanced_extensions_ = nullptr; } Plan::~Plan() { - // @@protoc_insertion_point(destructor:io.substrait.Plan) + // @@protoc_insertion_point(destructor:substrait.Plan) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -516,7 +514,7 @@ void Plan::SetCachedSize(int size) const { } void Plan::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Plan) +// @@protoc_insertion_point(message_clear_start:substrait.Plan) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -538,7 +536,7 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.extensions.SimpleExtensionURI extension_uris = 1; + // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -550,7 +548,7 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // repeated .io.substrait.extensions.SimpleExtensionDeclaration extensions = 2; + // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -562,7 +560,7 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // repeated .io.substrait.PlanRel relations = 3; + // repeated .substrait.PlanRel relations = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; @@ -574,7 +572,7 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extensions = 4; + // .substrait.extensions.AdvancedExtension advanced_extensions = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extensions(), ptr); @@ -589,7 +587,7 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter ptr += 1; auto str = _internal_add_expected_type_urls(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.Plan.expected_type_urls")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Plan.expected_type_urls")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); @@ -620,11 +618,11 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter ::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Plan) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Plan) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.extensions.SimpleExtensionURI extension_uris = 1; + // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; for (unsigned int i = 0, n = static_cast(this->_internal_extension_uris_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -632,7 +630,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( InternalWriteMessage(1, this->_internal_extension_uris(i), target, stream); } - // repeated .io.substrait.extensions.SimpleExtensionDeclaration extensions = 2; + // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; for (unsigned int i = 0, n = static_cast(this->_internal_extensions_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -640,7 +638,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( InternalWriteMessage(2, this->_internal_extensions(i), target, stream); } - // repeated .io.substrait.PlanRel relations = 3; + // repeated .substrait.PlanRel relations = 3; for (unsigned int i = 0, n = static_cast(this->_internal_relations_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -648,7 +646,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( InternalWriteMessage(3, this->_internal_relations(i), target, stream); } - // .io.substrait.extensions.AdvancedExtension advanced_extensions = 4; + // .substrait.extensions.AdvancedExtension advanced_extensions = 4; if (this->has_advanced_extensions()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -662,7 +660,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.Plan.expected_type_urls"); + "substrait.Plan.expected_type_urls"); target = stream->WriteString(5, s, target); } @@ -670,33 +668,33 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Plan) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Plan) return target; } size_t Plan::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Plan) +// @@protoc_insertion_point(message_byte_size_start:substrait.Plan) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.extensions.SimpleExtensionURI extension_uris = 1; + // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; total_size += 1UL * this->_internal_extension_uris_size(); for (const auto& msg : this->extension_uris_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.extensions.SimpleExtensionDeclaration extensions = 2; + // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; total_size += 1UL * this->_internal_extensions_size(); for (const auto& msg : this->extensions_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.PlanRel relations = 3; + // repeated .substrait.PlanRel relations = 3; total_size += 1UL * this->_internal_relations_size(); for (const auto& msg : this->relations_) { total_size += @@ -711,7 +709,7 @@ size_t Plan::ByteSizeLong() const { expected_type_urls_.Get(i)); } - // .io.substrait.extensions.AdvancedExtension advanced_extensions = 4; + // .substrait.extensions.AdvancedExtension advanced_extensions = 4; if (this->has_advanced_extensions()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -728,22 +726,22 @@ size_t Plan::ByteSizeLong() const { } void Plan::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Plan) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Plan) GOOGLE_DCHECK_NE(&from, this); const Plan* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Plan) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Plan) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Plan) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Plan) MergeFrom(*source); } } void Plan::MergeFrom(const Plan& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Plan) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Plan) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -754,19 +752,19 @@ void Plan::MergeFrom(const Plan& from) { relations_.MergeFrom(from.relations_); expected_type_urls_.MergeFrom(from.expected_type_urls_); if (from.has_advanced_extensions()) { - _internal_mutable_advanced_extensions()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extensions()); + _internal_mutable_advanced_extensions()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extensions()); } } void Plan::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Plan) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Plan) if (&from == this) return; Clear(); MergeFrom(from); } void Plan::CopyFrom(const Plan& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Plan) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Plan) if (&from == this) return; Clear(); MergeFrom(from); @@ -788,19 +786,18 @@ void Plan::InternalSwap(Plan* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Plan::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_plan_2eproto_getter, &descriptor_table_plan_2eproto_once, - file_level_metadata_plan_2eproto[1]); + &descriptor_table_substrait_2fplan_2eproto_getter, &descriptor_table_substrait_2fplan_2eproto_once, + file_level_metadata_substrait_2fplan_2eproto[1]); } // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::PlanRel* Arena::CreateMaybeMessage< ::io::substrait::PlanRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::PlanRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::PlanRel* Arena::CreateMaybeMessage< ::substrait::PlanRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::PlanRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Plan* Arena::CreateMaybeMessage< ::io::substrait::Plan >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Plan >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Plan* Arena::CreateMaybeMessage< ::substrait::Plan >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Plan >(arena); } PROTOBUF_NAMESPACE_CLOSE diff --git a/cpp/src/generated/substrait/plan.pb.h b/cpp/src/generated/substrait/plan.pb.h index dfbd2528fa7..e8592745fe6 100644 --- a/cpp/src/generated/substrait/plan.pb.h +++ b/cpp/src/generated/substrait/plan.pb.h @@ -1,8 +1,8 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: plan.proto +// source: substrait/plan.proto -#ifndef GOOGLE_PROTOBUF_INCLUDED_plan_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_plan_2eproto +#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fplan_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fplan_2eproto #include #include @@ -31,11 +31,11 @@ #include // IWYU pragma: export #include // IWYU pragma: export #include -#include "relations.pb.h" -#include "extensions.pb.h" +#include "substrait/relations.pb.h" +#include "substrait/extensions/extensions.pb.h" // @@protoc_insertion_point(includes) #include -#define PROTOBUF_INTERNAL_EXPORT_plan_2eproto +#define PROTOBUF_INTERNAL_EXPORT_substrait_2fplan_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; @@ -43,7 +43,7 @@ class AnyMetadata; PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. -struct TableStruct_plan_2eproto { +struct TableStruct_substrait_2fplan_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] @@ -54,8 +54,7 @@ struct TableStruct_plan_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; }; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_plan_2eproto; -namespace io { +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fplan_2eproto; namespace substrait { class Plan; struct PlanDefaultTypeInternal; @@ -64,18 +63,16 @@ class PlanRel; struct PlanRelDefaultTypeInternal; extern PlanRelDefaultTypeInternal _PlanRel_default_instance_; } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::Plan* Arena::CreateMaybeMessage<::io::substrait::Plan>(Arena*); -template<> ::io::substrait::PlanRel* Arena::CreateMaybeMessage<::io::substrait::PlanRel>(Arena*); +template<> ::substrait::Plan* Arena::CreateMaybeMessage<::substrait::Plan>(Arena*); +template<> ::substrait::PlanRel* Arena::CreateMaybeMessage<::substrait::PlanRel>(Arena*); PROTOBUF_NAMESPACE_CLOSE -namespace io { namespace substrait { // =================================================================== class PlanRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.PlanRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.PlanRel) */ { public: inline PlanRel() : PlanRel(nullptr) {} ~PlanRel() override; @@ -115,7 +112,7 @@ class PlanRel PROTOBUF_FINAL : enum RelTypeCase { kRel = 1, kRoot = 2, - RELTYPE_NOT_SET = 0, + REL_TYPE_NOT_SET = 0, }; static inline const PlanRel* internal_default_instance() { @@ -171,7 +168,7 @@ class PlanRel PROTOBUF_FINAL : void InternalSwap(PlanRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.PlanRel"; + return "substrait.PlanRel"; } protected: explicit PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -190,52 +187,52 @@ class PlanRel PROTOBUF_FINAL : kRelFieldNumber = 1, kRootFieldNumber = 2, }; - // .io.substrait.Rel rel = 1; + // .substrait.Rel rel = 1; bool has_rel() const; private: bool _internal_has_rel() const; public: void clear_rel(); - const ::io::substrait::Rel& rel() const; - ::io::substrait::Rel* release_rel(); - ::io::substrait::Rel* mutable_rel(); - void set_allocated_rel(::io::substrait::Rel* rel); + const ::substrait::Rel& rel() const; + ::substrait::Rel* release_rel(); + ::substrait::Rel* mutable_rel(); + void set_allocated_rel(::substrait::Rel* rel); private: - const ::io::substrait::Rel& _internal_rel() const; - ::io::substrait::Rel* _internal_mutable_rel(); + const ::substrait::Rel& _internal_rel() const; + ::substrait::Rel* _internal_mutable_rel(); public: void unsafe_arena_set_allocated_rel( - ::io::substrait::Rel* rel); - ::io::substrait::Rel* unsafe_arena_release_rel(); + ::substrait::Rel* rel); + ::substrait::Rel* unsafe_arena_release_rel(); - // .io.substrait.RelRoot root = 2; + // .substrait.RelRoot root = 2; bool has_root() const; private: bool _internal_has_root() const; public: void clear_root(); - const ::io::substrait::RelRoot& root() const; - ::io::substrait::RelRoot* release_root(); - ::io::substrait::RelRoot* mutable_root(); - void set_allocated_root(::io::substrait::RelRoot* root); + const ::substrait::RelRoot& root() const; + ::substrait::RelRoot* release_root(); + ::substrait::RelRoot* mutable_root(); + void set_allocated_root(::substrait::RelRoot* root); private: - const ::io::substrait::RelRoot& _internal_root() const; - ::io::substrait::RelRoot* _internal_mutable_root(); + const ::substrait::RelRoot& _internal_root() const; + ::substrait::RelRoot* _internal_mutable_root(); public: void unsafe_arena_set_allocated_root( - ::io::substrait::RelRoot* root); - ::io::substrait::RelRoot* unsafe_arena_release_root(); + ::substrait::RelRoot* root); + ::substrait::RelRoot* unsafe_arena_release_root(); - void clear_RelType(); - RelTypeCase RelType_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.PlanRel) + void clear_rel_type(); + RelTypeCase rel_type_case() const; + // @@protoc_insertion_point(class_scope:substrait.PlanRel) private: class _Internal; void set_has_rel(); void set_has_root(); - inline bool has_RelType() const; - inline void clear_has_RelType(); + inline bool has_rel_type() const; + inline void clear_has_rel_type(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; @@ -243,18 +240,18 @@ class PlanRel PROTOBUF_FINAL : union RelTypeUnion { constexpr RelTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Rel* rel_; - ::io::substrait::RelRoot* root_; - } RelType_; + ::substrait::Rel* rel_; + ::substrait::RelRoot* root_; + } rel_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_plan_2eproto; + friend struct ::TableStruct_substrait_2fplan_2eproto; }; // ------------------------------------------------------------------- class Plan PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Plan) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Plan) */ { public: inline Plan() : Plan(nullptr) {} ~Plan() override; @@ -344,7 +341,7 @@ class Plan PROTOBUF_FINAL : void InternalSwap(Plan* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Plan"; + return "substrait.Plan"; } protected: explicit Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -366,58 +363,58 @@ class Plan PROTOBUF_FINAL : kExpectedTypeUrlsFieldNumber = 5, kAdvancedExtensionsFieldNumber = 4, }; - // repeated .io.substrait.extensions.SimpleExtensionURI extension_uris = 1; + // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; int extension_uris_size() const; private: int _internal_extension_uris_size() const; public: void clear_extension_uris(); - ::io::substrait::extensions::SimpleExtensionURI* mutable_extension_uris(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionURI >* + ::substrait::extensions::SimpleExtensionURI* mutable_extension_uris(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >* mutable_extension_uris(); private: - const ::io::substrait::extensions::SimpleExtensionURI& _internal_extension_uris(int index) const; - ::io::substrait::extensions::SimpleExtensionURI* _internal_add_extension_uris(); + const ::substrait::extensions::SimpleExtensionURI& _internal_extension_uris(int index) const; + ::substrait::extensions::SimpleExtensionURI* _internal_add_extension_uris(); public: - const ::io::substrait::extensions::SimpleExtensionURI& extension_uris(int index) const; - ::io::substrait::extensions::SimpleExtensionURI* add_extension_uris(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionURI >& + const ::substrait::extensions::SimpleExtensionURI& extension_uris(int index) const; + ::substrait::extensions::SimpleExtensionURI* add_extension_uris(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >& extension_uris() const; - // repeated .io.substrait.extensions.SimpleExtensionDeclaration extensions = 2; + // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; int extensions_size() const; private: int _internal_extensions_size() const; public: void clear_extensions(); - ::io::substrait::extensions::SimpleExtensionDeclaration* mutable_extensions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionDeclaration >* + ::substrait::extensions::SimpleExtensionDeclaration* mutable_extensions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >* mutable_extensions(); private: - const ::io::substrait::extensions::SimpleExtensionDeclaration& _internal_extensions(int index) const; - ::io::substrait::extensions::SimpleExtensionDeclaration* _internal_add_extensions(); + const ::substrait::extensions::SimpleExtensionDeclaration& _internal_extensions(int index) const; + ::substrait::extensions::SimpleExtensionDeclaration* _internal_add_extensions(); public: - const ::io::substrait::extensions::SimpleExtensionDeclaration& extensions(int index) const; - ::io::substrait::extensions::SimpleExtensionDeclaration* add_extensions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionDeclaration >& + const ::substrait::extensions::SimpleExtensionDeclaration& extensions(int index) const; + ::substrait::extensions::SimpleExtensionDeclaration* add_extensions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >& extensions() const; - // repeated .io.substrait.PlanRel relations = 3; + // repeated .substrait.PlanRel relations = 3; int relations_size() const; private: int _internal_relations_size() const; public: void clear_relations(); - ::io::substrait::PlanRel* mutable_relations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::PlanRel >* + ::substrait::PlanRel* mutable_relations(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >* mutable_relations(); private: - const ::io::substrait::PlanRel& _internal_relations(int index) const; - ::io::substrait::PlanRel* _internal_add_relations(); + const ::substrait::PlanRel& _internal_relations(int index) const; + ::substrait::PlanRel* _internal_add_relations(); public: - const ::io::substrait::PlanRel& relations(int index) const; - ::io::substrait::PlanRel* add_relations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::PlanRel >& + const ::substrait::PlanRel& relations(int index) const; + ::substrait::PlanRel* add_relations(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >& relations() const; // repeated string expected_type_urls = 5; @@ -444,38 +441,38 @@ class Plan PROTOBUF_FINAL : std::string* _internal_add_expected_type_urls(); public: - // .io.substrait.extensions.AdvancedExtension advanced_extensions = 4; + // .substrait.extensions.AdvancedExtension advanced_extensions = 4; bool has_advanced_extensions() const; private: bool _internal_has_advanced_extensions() const; public: void clear_advanced_extensions(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extensions() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extensions(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extensions(); - void set_allocated_advanced_extensions(::io::substrait::extensions::AdvancedExtension* advanced_extensions); + const ::substrait::extensions::AdvancedExtension& advanced_extensions() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extensions(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extensions(); + void set_allocated_advanced_extensions(::substrait::extensions::AdvancedExtension* advanced_extensions); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extensions() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extensions(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extensions() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extensions(); public: void unsafe_arena_set_allocated_advanced_extensions( - ::io::substrait::extensions::AdvancedExtension* advanced_extensions); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extensions(); + ::substrait::extensions::AdvancedExtension* advanced_extensions); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extensions(); - // @@protoc_insertion_point(class_scope:io.substrait.Plan) + // @@protoc_insertion_point(class_scope:substrait.Plan) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionURI > extension_uris_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionDeclaration > extensions_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::PlanRel > relations_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI > extension_uris_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration > extensions_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel > relations_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField expected_type_urls_; - ::io::substrait::extensions::AdvancedExtension* advanced_extensions_; + ::substrait::extensions::AdvancedExtension* advanced_extensions_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_plan_2eproto; + friend struct ::TableStruct_substrait_2fplan_2eproto; }; // =================================================================== @@ -488,9 +485,9 @@ class Plan PROTOBUF_FINAL : #endif // __GNUC__ // PlanRel -// .io.substrait.Rel rel = 1; +// .substrait.Rel rel = 1; inline bool PlanRel::_internal_has_rel() const { - return RelType_case() == kRel; + return rel_type_case() == kRel; } inline bool PlanRel::has_rel() const { return _internal_has_rel(); @@ -498,64 +495,64 @@ inline bool PlanRel::has_rel() const { inline void PlanRel::set_has_rel() { _oneof_case_[0] = kRel; } -inline ::io::substrait::Rel* PlanRel::release_rel() { - // @@protoc_insertion_point(field_release:io.substrait.PlanRel.rel) +inline ::substrait::Rel* PlanRel::release_rel() { + // @@protoc_insertion_point(field_release:substrait.PlanRel.rel) if (_internal_has_rel()) { - clear_has_RelType(); - ::io::substrait::Rel* temp = RelType_.rel_; + clear_has_rel_type(); + ::substrait::Rel* temp = rel_type_.rel_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.rel_ = nullptr; + rel_type_.rel_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::Rel& PlanRel::_internal_rel() const { +inline const ::substrait::Rel& PlanRel::_internal_rel() const { return _internal_has_rel() - ? *RelType_.rel_ - : reinterpret_cast< ::io::substrait::Rel&>(::io::substrait::_Rel_default_instance_); + ? *rel_type_.rel_ + : reinterpret_cast< ::substrait::Rel&>(::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& PlanRel::rel() const { - // @@protoc_insertion_point(field_get:io.substrait.PlanRel.rel) +inline const ::substrait::Rel& PlanRel::rel() const { + // @@protoc_insertion_point(field_get:substrait.PlanRel.rel) return _internal_rel(); } -inline ::io::substrait::Rel* PlanRel::unsafe_arena_release_rel() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.PlanRel.rel) +inline ::substrait::Rel* PlanRel::unsafe_arena_release_rel() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.PlanRel.rel) if (_internal_has_rel()) { - clear_has_RelType(); - ::io::substrait::Rel* temp = RelType_.rel_; - RelType_.rel_ = nullptr; + clear_has_rel_type(); + ::substrait::Rel* temp = rel_type_.rel_; + rel_type_.rel_ = nullptr; return temp; } else { return nullptr; } } -inline void PlanRel::unsafe_arena_set_allocated_rel(::io::substrait::Rel* rel) { - clear_RelType(); +inline void PlanRel::unsafe_arena_set_allocated_rel(::substrait::Rel* rel) { + clear_rel_type(); if (rel) { set_has_rel(); - RelType_.rel_ = rel; + rel_type_.rel_ = rel; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.PlanRel.rel) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.PlanRel.rel) } -inline ::io::substrait::Rel* PlanRel::_internal_mutable_rel() { +inline ::substrait::Rel* PlanRel::_internal_mutable_rel() { if (!_internal_has_rel()) { - clear_RelType(); + clear_rel_type(); set_has_rel(); - RelType_.rel_ = CreateMaybeMessage< ::io::substrait::Rel >(GetArena()); + rel_type_.rel_ = CreateMaybeMessage< ::substrait::Rel >(GetArena()); } - return RelType_.rel_; + return rel_type_.rel_; } -inline ::io::substrait::Rel* PlanRel::mutable_rel() { - // @@protoc_insertion_point(field_mutable:io.substrait.PlanRel.rel) +inline ::substrait::Rel* PlanRel::mutable_rel() { + // @@protoc_insertion_point(field_mutable:substrait.PlanRel.rel) return _internal_mutable_rel(); } -// .io.substrait.RelRoot root = 2; +// .substrait.RelRoot root = 2; inline bool PlanRel::_internal_has_root() const { - return RelType_case() == kRoot; + return rel_type_case() == kRoot; } inline bool PlanRel::has_root() const { return _internal_has_root(); @@ -563,147 +560,147 @@ inline bool PlanRel::has_root() const { inline void PlanRel::set_has_root() { _oneof_case_[0] = kRoot; } -inline ::io::substrait::RelRoot* PlanRel::release_root() { - // @@protoc_insertion_point(field_release:io.substrait.PlanRel.root) +inline ::substrait::RelRoot* PlanRel::release_root() { + // @@protoc_insertion_point(field_release:substrait.PlanRel.root) if (_internal_has_root()) { - clear_has_RelType(); - ::io::substrait::RelRoot* temp = RelType_.root_; + clear_has_rel_type(); + ::substrait::RelRoot* temp = rel_type_.root_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.root_ = nullptr; + rel_type_.root_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::RelRoot& PlanRel::_internal_root() const { +inline const ::substrait::RelRoot& PlanRel::_internal_root() const { return _internal_has_root() - ? *RelType_.root_ - : reinterpret_cast< ::io::substrait::RelRoot&>(::io::substrait::_RelRoot_default_instance_); + ? *rel_type_.root_ + : reinterpret_cast< ::substrait::RelRoot&>(::substrait::_RelRoot_default_instance_); } -inline const ::io::substrait::RelRoot& PlanRel::root() const { - // @@protoc_insertion_point(field_get:io.substrait.PlanRel.root) +inline const ::substrait::RelRoot& PlanRel::root() const { + // @@protoc_insertion_point(field_get:substrait.PlanRel.root) return _internal_root(); } -inline ::io::substrait::RelRoot* PlanRel::unsafe_arena_release_root() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.PlanRel.root) +inline ::substrait::RelRoot* PlanRel::unsafe_arena_release_root() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.PlanRel.root) if (_internal_has_root()) { - clear_has_RelType(); - ::io::substrait::RelRoot* temp = RelType_.root_; - RelType_.root_ = nullptr; + clear_has_rel_type(); + ::substrait::RelRoot* temp = rel_type_.root_; + rel_type_.root_ = nullptr; return temp; } else { return nullptr; } } -inline void PlanRel::unsafe_arena_set_allocated_root(::io::substrait::RelRoot* root) { - clear_RelType(); +inline void PlanRel::unsafe_arena_set_allocated_root(::substrait::RelRoot* root) { + clear_rel_type(); if (root) { set_has_root(); - RelType_.root_ = root; + rel_type_.root_ = root; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.PlanRel.root) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.PlanRel.root) } -inline ::io::substrait::RelRoot* PlanRel::_internal_mutable_root() { +inline ::substrait::RelRoot* PlanRel::_internal_mutable_root() { if (!_internal_has_root()) { - clear_RelType(); + clear_rel_type(); set_has_root(); - RelType_.root_ = CreateMaybeMessage< ::io::substrait::RelRoot >(GetArena()); + rel_type_.root_ = CreateMaybeMessage< ::substrait::RelRoot >(GetArena()); } - return RelType_.root_; + return rel_type_.root_; } -inline ::io::substrait::RelRoot* PlanRel::mutable_root() { - // @@protoc_insertion_point(field_mutable:io.substrait.PlanRel.root) +inline ::substrait::RelRoot* PlanRel::mutable_root() { + // @@protoc_insertion_point(field_mutable:substrait.PlanRel.root) return _internal_mutable_root(); } -inline bool PlanRel::has_RelType() const { - return RelType_case() != RELTYPE_NOT_SET; +inline bool PlanRel::has_rel_type() const { + return rel_type_case() != REL_TYPE_NOT_SET; } -inline void PlanRel::clear_has_RelType() { - _oneof_case_[0] = RELTYPE_NOT_SET; +inline void PlanRel::clear_has_rel_type() { + _oneof_case_[0] = REL_TYPE_NOT_SET; } -inline PlanRel::RelTypeCase PlanRel::RelType_case() const { +inline PlanRel::RelTypeCase PlanRel::rel_type_case() const { return PlanRel::RelTypeCase(_oneof_case_[0]); } // ------------------------------------------------------------------- // Plan -// repeated .io.substrait.extensions.SimpleExtensionURI extension_uris = 1; +// repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; inline int Plan::_internal_extension_uris_size() const { return extension_uris_.size(); } inline int Plan::extension_uris_size() const { return _internal_extension_uris_size(); } -inline ::io::substrait::extensions::SimpleExtensionURI* Plan::mutable_extension_uris(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Plan.extension_uris) +inline ::substrait::extensions::SimpleExtensionURI* Plan::mutable_extension_uris(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Plan.extension_uris) return extension_uris_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionURI >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >* Plan::mutable_extension_uris() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.extension_uris) + // @@protoc_insertion_point(field_mutable_list:substrait.Plan.extension_uris) return &extension_uris_; } -inline const ::io::substrait::extensions::SimpleExtensionURI& Plan::_internal_extension_uris(int index) const { +inline const ::substrait::extensions::SimpleExtensionURI& Plan::_internal_extension_uris(int index) const { return extension_uris_.Get(index); } -inline const ::io::substrait::extensions::SimpleExtensionURI& Plan::extension_uris(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Plan.extension_uris) +inline const ::substrait::extensions::SimpleExtensionURI& Plan::extension_uris(int index) const { + // @@protoc_insertion_point(field_get:substrait.Plan.extension_uris) return _internal_extension_uris(index); } -inline ::io::substrait::extensions::SimpleExtensionURI* Plan::_internal_add_extension_uris() { +inline ::substrait::extensions::SimpleExtensionURI* Plan::_internal_add_extension_uris() { return extension_uris_.Add(); } -inline ::io::substrait::extensions::SimpleExtensionURI* Plan::add_extension_uris() { - // @@protoc_insertion_point(field_add:io.substrait.Plan.extension_uris) +inline ::substrait::extensions::SimpleExtensionURI* Plan::add_extension_uris() { + // @@protoc_insertion_point(field_add:substrait.Plan.extension_uris) return _internal_add_extension_uris(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionURI >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >& Plan::extension_uris() const { - // @@protoc_insertion_point(field_list:io.substrait.Plan.extension_uris) + // @@protoc_insertion_point(field_list:substrait.Plan.extension_uris) return extension_uris_; } -// repeated .io.substrait.extensions.SimpleExtensionDeclaration extensions = 2; +// repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; inline int Plan::_internal_extensions_size() const { return extensions_.size(); } inline int Plan::extensions_size() const { return _internal_extensions_size(); } -inline ::io::substrait::extensions::SimpleExtensionDeclaration* Plan::mutable_extensions(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Plan.extensions) +inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::mutable_extensions(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Plan.extensions) return extensions_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionDeclaration >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >* Plan::mutable_extensions() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.extensions) + // @@protoc_insertion_point(field_mutable_list:substrait.Plan.extensions) return &extensions_; } -inline const ::io::substrait::extensions::SimpleExtensionDeclaration& Plan::_internal_extensions(int index) const { +inline const ::substrait::extensions::SimpleExtensionDeclaration& Plan::_internal_extensions(int index) const { return extensions_.Get(index); } -inline const ::io::substrait::extensions::SimpleExtensionDeclaration& Plan::extensions(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Plan.extensions) +inline const ::substrait::extensions::SimpleExtensionDeclaration& Plan::extensions(int index) const { + // @@protoc_insertion_point(field_get:substrait.Plan.extensions) return _internal_extensions(index); } -inline ::io::substrait::extensions::SimpleExtensionDeclaration* Plan::_internal_add_extensions() { +inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::_internal_add_extensions() { return extensions_.Add(); } -inline ::io::substrait::extensions::SimpleExtensionDeclaration* Plan::add_extensions() { - // @@protoc_insertion_point(field_add:io.substrait.Plan.extensions) +inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::add_extensions() { + // @@protoc_insertion_point(field_add:substrait.Plan.extensions) return _internal_add_extensions(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::extensions::SimpleExtensionDeclaration >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >& Plan::extensions() const { - // @@protoc_insertion_point(field_list:io.substrait.Plan.extensions) + // @@protoc_insertion_point(field_list:substrait.Plan.extensions) return extensions_; } -// repeated .io.substrait.PlanRel relations = 3; +// repeated .substrait.PlanRel relations = 3; inline int Plan::_internal_relations_size() const { return relations_.size(); } @@ -713,53 +710,53 @@ inline int Plan::relations_size() const { inline void Plan::clear_relations() { relations_.Clear(); } -inline ::io::substrait::PlanRel* Plan::mutable_relations(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Plan.relations) +inline ::substrait::PlanRel* Plan::mutable_relations(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Plan.relations) return relations_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::PlanRel >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >* Plan::mutable_relations() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.relations) + // @@protoc_insertion_point(field_mutable_list:substrait.Plan.relations) return &relations_; } -inline const ::io::substrait::PlanRel& Plan::_internal_relations(int index) const { +inline const ::substrait::PlanRel& Plan::_internal_relations(int index) const { return relations_.Get(index); } -inline const ::io::substrait::PlanRel& Plan::relations(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Plan.relations) +inline const ::substrait::PlanRel& Plan::relations(int index) const { + // @@protoc_insertion_point(field_get:substrait.Plan.relations) return _internal_relations(index); } -inline ::io::substrait::PlanRel* Plan::_internal_add_relations() { +inline ::substrait::PlanRel* Plan::_internal_add_relations() { return relations_.Add(); } -inline ::io::substrait::PlanRel* Plan::add_relations() { - // @@protoc_insertion_point(field_add:io.substrait.Plan.relations) +inline ::substrait::PlanRel* Plan::add_relations() { + // @@protoc_insertion_point(field_add:substrait.Plan.relations) return _internal_add_relations(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::PlanRel >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >& Plan::relations() const { - // @@protoc_insertion_point(field_list:io.substrait.Plan.relations) + // @@protoc_insertion_point(field_list:substrait.Plan.relations) return relations_; } -// .io.substrait.extensions.AdvancedExtension advanced_extensions = 4; +// .substrait.extensions.AdvancedExtension advanced_extensions = 4; inline bool Plan::_internal_has_advanced_extensions() const { return this != internal_default_instance() && advanced_extensions_ != nullptr; } inline bool Plan::has_advanced_extensions() const { return _internal_has_advanced_extensions(); } -inline const ::io::substrait::extensions::AdvancedExtension& Plan::_internal_advanced_extensions() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extensions_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& Plan::_internal_advanced_extensions() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extensions_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& Plan::advanced_extensions() const { - // @@protoc_insertion_point(field_get:io.substrait.Plan.advanced_extensions) +inline const ::substrait::extensions::AdvancedExtension& Plan::advanced_extensions() const { + // @@protoc_insertion_point(field_get:substrait.Plan.advanced_extensions) return _internal_advanced_extensions(); } inline void Plan::unsafe_arena_set_allocated_advanced_extensions( - ::io::substrait::extensions::AdvancedExtension* advanced_extensions) { + ::substrait::extensions::AdvancedExtension* advanced_extensions) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions_); } @@ -769,37 +766,37 @@ inline void Plan::unsafe_arena_set_allocated_advanced_extensions( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Plan.advanced_extensions) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Plan.advanced_extensions) } -inline ::io::substrait::extensions::AdvancedExtension* Plan::release_advanced_extensions() { +inline ::substrait::extensions::AdvancedExtension* Plan::release_advanced_extensions() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extensions_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extensions_; advanced_extensions_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* Plan::unsafe_arena_release_advanced_extensions() { - // @@protoc_insertion_point(field_release:io.substrait.Plan.advanced_extensions) +inline ::substrait::extensions::AdvancedExtension* Plan::unsafe_arena_release_advanced_extensions() { + // @@protoc_insertion_point(field_release:substrait.Plan.advanced_extensions) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extensions_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extensions_; advanced_extensions_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* Plan::_internal_mutable_advanced_extensions() { +inline ::substrait::extensions::AdvancedExtension* Plan::_internal_mutable_advanced_extensions() { if (advanced_extensions_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extensions_ = p; } return advanced_extensions_; } -inline ::io::substrait::extensions::AdvancedExtension* Plan::mutable_advanced_extensions() { - // @@protoc_insertion_point(field_mutable:io.substrait.Plan.advanced_extensions) +inline ::substrait::extensions::AdvancedExtension* Plan::mutable_advanced_extensions() { + // @@protoc_insertion_point(field_mutable:substrait.Plan.advanced_extensions) return _internal_mutable_advanced_extensions(); } -inline void Plan::set_allocated_advanced_extensions(::io::substrait::extensions::AdvancedExtension* advanced_extensions) { +inline void Plan::set_allocated_advanced_extensions(::substrait::extensions::AdvancedExtension* advanced_extensions) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions_); @@ -816,7 +813,7 @@ inline void Plan::set_allocated_advanced_extensions(::io::substrait::extensions: } advanced_extensions_ = advanced_extensions; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Plan.advanced_extensions) + // @@protoc_insertion_point(field_set_allocated:substrait.Plan.advanced_extensions) } // repeated string expected_type_urls = 5; @@ -830,66 +827,66 @@ inline void Plan::clear_expected_type_urls() { expected_type_urls_.Clear(); } inline std::string* Plan::add_expected_type_urls() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_add_mutable:substrait.Plan.expected_type_urls) return _internal_add_expected_type_urls(); } inline const std::string& Plan::_internal_expected_type_urls(int index) const { return expected_type_urls_.Get(index); } inline const std::string& Plan::expected_type_urls(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_get:substrait.Plan.expected_type_urls) return _internal_expected_type_urls(index); } inline std::string* Plan::mutable_expected_type_urls(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_mutable:substrait.Plan.expected_type_urls) return expected_type_urls_.Mutable(index); } inline void Plan::set_expected_type_urls(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_set:substrait.Plan.expected_type_urls) expected_type_urls_.Mutable(index)->assign(value); } inline void Plan::set_expected_type_urls(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_set:substrait.Plan.expected_type_urls) expected_type_urls_.Mutable(index)->assign(std::move(value)); } inline void Plan::set_expected_type_urls(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); expected_type_urls_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_set_char:substrait.Plan.expected_type_urls) } inline void Plan::set_expected_type_urls(int index, const char* value, size_t size) { expected_type_urls_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_set_pointer:substrait.Plan.expected_type_urls) } inline std::string* Plan::_internal_add_expected_type_urls() { return expected_type_urls_.Add(); } inline void Plan::add_expected_type_urls(const std::string& value) { expected_type_urls_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_add:substrait.Plan.expected_type_urls) } inline void Plan::add_expected_type_urls(std::string&& value) { expected_type_urls_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_add:substrait.Plan.expected_type_urls) } inline void Plan::add_expected_type_urls(const char* value) { GOOGLE_DCHECK(value != nullptr); expected_type_urls_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_add_char:substrait.Plan.expected_type_urls) } inline void Plan::add_expected_type_urls(const char* value, size_t size) { expected_type_urls_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_add_pointer:substrait.Plan.expected_type_urls) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& Plan::expected_type_urls() const { - // @@protoc_insertion_point(field_list:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_list:substrait.Plan.expected_type_urls) return expected_type_urls_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* Plan::mutable_expected_type_urls() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Plan.expected_type_urls) + // @@protoc_insertion_point(field_mutable_list:substrait.Plan.expected_type_urls) return &expected_type_urls_; } @@ -902,9 +899,8 @@ Plan::mutable_expected_type_urls() { // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io // @@protoc_insertion_point(global_scope) #include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_plan_2eproto +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fplan_2eproto diff --git a/cpp/src/generated/substrait/relations.pb.cc b/cpp/src/generated/substrait/relations.pb.cc index 7a44a3bbfa5..6ecc0e52d04 100644 --- a/cpp/src/generated/substrait/relations.pb.cc +++ b/cpp/src/generated/substrait/relations.pb.cc @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: relations.proto +// source: substrait/relations.proto -#include "relations.pb.h" +#include "substrait/relations.pb.h" #include @@ -16,7 +16,6 @@ #include PROTOBUF_PRAGMA_INIT_SEG -namespace io { namespace substrait { constexpr RelCommon_Direct::RelCommon_Direct( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} @@ -137,6 +136,9 @@ constexpr ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : format_(0) + , partition_index_(PROTOBUF_ULONGLONG(0)) + , start_(PROTOBUF_ULONGLONG(0)) + , length_(PROTOBUF_ULONGLONG(0)) , _oneof_case_{}{} struct ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal { constexpr ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal() @@ -229,8 +231,7 @@ struct FetchRelDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FetchRelDefaultTypeInternal _FetchRel_default_instance_; constexpr AggregateRel_Grouping::AggregateRel_Grouping( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : input_fields_() - , _input_fields_cached_byte_size_(){} + : grouping_expressions_(){} struct AggregateRel_GroupingDefaultTypeInternal { constexpr AggregateRel_GroupingDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -382,222 +383,224 @@ struct RelDefaultTypeInternal { }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelDefaultTypeInternal _Rel_default_instance_; } // namespace substrait -} // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_relations_2eproto[26]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_relations_2eproto[3]; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_relations_2eproto = nullptr; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2frelations_2eproto[26]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2frelations_2eproto[3]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2frelations_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Direct, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Direct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Emit, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Emit, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Emit, output_mapping_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Emit, output_mapping_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_Stats, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_Stats, row_count_), - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_Stats, record_size_), - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_Stats, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, row_count_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, record_size_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_RuntimeConstraint, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_RuntimeConstraint, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint_RuntimeConstraint, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_RuntimeConstraint, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, stats_), - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, constraint_), - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon_Hint, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, stats_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, constraint_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, hint_), - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, advanced_extension_), - PROTOBUF_FIELD_OFFSET(::io::substrait::RelCommon, emit_kind_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, hint_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, emit_kind_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_NamedTable, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_NamedTable, names_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_NamedTable, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, names_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_VirtualTable, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_VirtualTable, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_VirtualTable, values_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_VirtualTable, values_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_ExtensionTable, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_ExtensionTable, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_ExtensionTable, detail_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_ExtensionTable, detail_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, format_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles_FileOrFiles, path_type_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, format_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, partition_index_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, start_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, length_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, path_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles, items_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel_LocalFiles, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, items_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, _oneof_case_[0]), ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, base_schema_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, filter_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, projection_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, base_schema_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, filter_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, projection_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, advanced_extension_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::ReadRel, read_type_), + PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, read_type_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, input_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, expressions_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ProjectRel, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, input_), + PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, expressions_), + PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, left_), - PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, right_), - PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, expression_), - PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, post_join_filter_), - PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::JoinRel, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, left_), + PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, right_), + PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, expression_), + PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, post_join_filter_), + PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, type_), + PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, input_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, offset_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, count_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FetchRel, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, input_), + PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, offset_), + PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, count_), + PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Grouping, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Grouping, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Grouping, input_fields_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Grouping, grouping_expressions_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Measure, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Measure, measure_), - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel_Measure, filter_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, measure_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, filter_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, input_), - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, groupings_), - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, measures_), - PROTOBUF_FIELD_OFFSET(::io::substrait::AggregateRel, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, input_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, groupings_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, measures_), + PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::SortRel, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, input_), - PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, sorts_), - PROTOBUF_FIELD_OFFSET(::io::substrait::SortRel, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::SortRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::SortRel, input_), + PROTOBUF_FIELD_OFFSET(::substrait::SortRel, sorts_), + PROTOBUF_FIELD_OFFSET(::substrait::SortRel, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, input_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, condition_), - PROTOBUF_FIELD_OFFSET(::io::substrait::FilterRel, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, input_), + PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, condition_), + PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::SetRel, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, inputs_), - PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, op_), - PROTOBUF_FIELD_OFFSET(::io::substrait::SetRel, advanced_extension_), + PROTOBUF_FIELD_OFFSET(::substrait::SetRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::SetRel, inputs_), + PROTOBUF_FIELD_OFFSET(::substrait::SetRel, op_), + PROTOBUF_FIELD_OFFSET(::substrait::SetRel, advanced_extension_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionSingleRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionSingleRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionSingleRel, input_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionSingleRel, detail_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, input_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, detail_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionLeafRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionLeafRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionLeafRel, detail_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, detail_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionMultiRel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionMultiRel, common_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionMultiRel, inputs_), - PROTOBUF_FIELD_OFFSET(::io::substrait::ExtensionMultiRel, detail_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, common_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, inputs_), + PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, detail_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelRoot, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::RelRoot, input_), - PROTOBUF_FIELD_OFFSET(::io::substrait::RelRoot, names_), + PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, input_), + PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, names_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Rel, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Rel, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Rel, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Rel, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -610,218 +613,219 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_relations_2eproto::offsets[] P ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Rel, RelType_), + PROTOBUF_FIELD_OFFSET(::substrait::Rel, rel_type_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::RelCommon_Direct)}, - { 5, -1, sizeof(::io::substrait::RelCommon_Emit)}, - { 11, -1, sizeof(::io::substrait::RelCommon_Hint_Stats)}, - { 19, -1, sizeof(::io::substrait::RelCommon_Hint_RuntimeConstraint)}, - { 25, -1, sizeof(::io::substrait::RelCommon_Hint)}, - { 33, -1, sizeof(::io::substrait::RelCommon)}, - { 43, -1, sizeof(::io::substrait::ReadRel_NamedTable)}, - { 50, -1, sizeof(::io::substrait::ReadRel_VirtualTable)}, - { 56, -1, sizeof(::io::substrait::ReadRel_ExtensionTable)}, - { 62, -1, sizeof(::io::substrait::ReadRel_LocalFiles_FileOrFiles)}, - { 73, -1, sizeof(::io::substrait::ReadRel_LocalFiles)}, - { 80, -1, sizeof(::io::substrait::ReadRel)}, - { 95, -1, sizeof(::io::substrait::ProjectRel)}, - { 104, -1, sizeof(::io::substrait::JoinRel)}, - { 116, -1, sizeof(::io::substrait::FetchRel)}, - { 126, -1, sizeof(::io::substrait::AggregateRel_Grouping)}, - { 132, -1, sizeof(::io::substrait::AggregateRel_Measure)}, - { 139, -1, sizeof(::io::substrait::AggregateRel)}, - { 149, -1, sizeof(::io::substrait::SortRel)}, - { 158, -1, sizeof(::io::substrait::FilterRel)}, - { 167, -1, sizeof(::io::substrait::SetRel)}, - { 176, -1, sizeof(::io::substrait::ExtensionSingleRel)}, - { 184, -1, sizeof(::io::substrait::ExtensionLeafRel)}, - { 191, -1, sizeof(::io::substrait::ExtensionMultiRel)}, - { 199, -1, sizeof(::io::substrait::RelRoot)}, - { 206, -1, sizeof(::io::substrait::Rel)}, + { 0, -1, sizeof(::substrait::RelCommon_Direct)}, + { 5, -1, sizeof(::substrait::RelCommon_Emit)}, + { 11, -1, sizeof(::substrait::RelCommon_Hint_Stats)}, + { 19, -1, sizeof(::substrait::RelCommon_Hint_RuntimeConstraint)}, + { 25, -1, sizeof(::substrait::RelCommon_Hint)}, + { 33, -1, sizeof(::substrait::RelCommon)}, + { 43, -1, sizeof(::substrait::ReadRel_NamedTable)}, + { 50, -1, sizeof(::substrait::ReadRel_VirtualTable)}, + { 56, -1, sizeof(::substrait::ReadRel_ExtensionTable)}, + { 62, -1, sizeof(::substrait::ReadRel_LocalFiles_FileOrFiles)}, + { 76, -1, sizeof(::substrait::ReadRel_LocalFiles)}, + { 83, -1, sizeof(::substrait::ReadRel)}, + { 98, -1, sizeof(::substrait::ProjectRel)}, + { 107, -1, sizeof(::substrait::JoinRel)}, + { 119, -1, sizeof(::substrait::FetchRel)}, + { 129, -1, sizeof(::substrait::AggregateRel_Grouping)}, + { 135, -1, sizeof(::substrait::AggregateRel_Measure)}, + { 142, -1, sizeof(::substrait::AggregateRel)}, + { 152, -1, sizeof(::substrait::SortRel)}, + { 161, -1, sizeof(::substrait::FilterRel)}, + { 170, -1, sizeof(::substrait::SetRel)}, + { 179, -1, sizeof(::substrait::ExtensionSingleRel)}, + { 187, -1, sizeof(::substrait::ExtensionLeafRel)}, + { 194, -1, sizeof(::substrait::ExtensionMultiRel)}, + { 202, -1, sizeof(::substrait::RelRoot)}, + { 209, -1, sizeof(::substrait::Rel)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::_RelCommon_Direct_default_instance_), - reinterpret_cast(&::io::substrait::_RelCommon_Emit_default_instance_), - reinterpret_cast(&::io::substrait::_RelCommon_Hint_Stats_default_instance_), - reinterpret_cast(&::io::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_), - reinterpret_cast(&::io::substrait::_RelCommon_Hint_default_instance_), - reinterpret_cast(&::io::substrait::_RelCommon_default_instance_), - reinterpret_cast(&::io::substrait::_ReadRel_NamedTable_default_instance_), - reinterpret_cast(&::io::substrait::_ReadRel_VirtualTable_default_instance_), - reinterpret_cast(&::io::substrait::_ReadRel_ExtensionTable_default_instance_), - reinterpret_cast(&::io::substrait::_ReadRel_LocalFiles_FileOrFiles_default_instance_), - reinterpret_cast(&::io::substrait::_ReadRel_LocalFiles_default_instance_), - reinterpret_cast(&::io::substrait::_ReadRel_default_instance_), - reinterpret_cast(&::io::substrait::_ProjectRel_default_instance_), - reinterpret_cast(&::io::substrait::_JoinRel_default_instance_), - reinterpret_cast(&::io::substrait::_FetchRel_default_instance_), - reinterpret_cast(&::io::substrait::_AggregateRel_Grouping_default_instance_), - reinterpret_cast(&::io::substrait::_AggregateRel_Measure_default_instance_), - reinterpret_cast(&::io::substrait::_AggregateRel_default_instance_), - reinterpret_cast(&::io::substrait::_SortRel_default_instance_), - reinterpret_cast(&::io::substrait::_FilterRel_default_instance_), - reinterpret_cast(&::io::substrait::_SetRel_default_instance_), - reinterpret_cast(&::io::substrait::_ExtensionSingleRel_default_instance_), - reinterpret_cast(&::io::substrait::_ExtensionLeafRel_default_instance_), - reinterpret_cast(&::io::substrait::_ExtensionMultiRel_default_instance_), - reinterpret_cast(&::io::substrait::_RelRoot_default_instance_), - reinterpret_cast(&::io::substrait::_Rel_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_Direct_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_Emit_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_Hint_Stats_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_Hint_default_instance_), + reinterpret_cast(&::substrait::_RelCommon_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_NamedTable_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_VirtualTable_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_ExtensionTable_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_LocalFiles_FileOrFiles_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_LocalFiles_default_instance_), + reinterpret_cast(&::substrait::_ReadRel_default_instance_), + reinterpret_cast(&::substrait::_ProjectRel_default_instance_), + reinterpret_cast(&::substrait::_JoinRel_default_instance_), + reinterpret_cast(&::substrait::_FetchRel_default_instance_), + reinterpret_cast(&::substrait::_AggregateRel_Grouping_default_instance_), + reinterpret_cast(&::substrait::_AggregateRel_Measure_default_instance_), + reinterpret_cast(&::substrait::_AggregateRel_default_instance_), + reinterpret_cast(&::substrait::_SortRel_default_instance_), + reinterpret_cast(&::substrait::_FilterRel_default_instance_), + reinterpret_cast(&::substrait::_SetRel_default_instance_), + reinterpret_cast(&::substrait::_ExtensionSingleRel_default_instance_), + reinterpret_cast(&::substrait::_ExtensionLeafRel_default_instance_), + reinterpret_cast(&::substrait::_ExtensionMultiRel_default_instance_), + reinterpret_cast(&::substrait::_RelRoot_default_instance_), + reinterpret_cast(&::substrait::_Rel_default_instance_), }; -const char descriptor_table_protodef_relations_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\017relations.proto\022\014io.substrait\032\ntype.pr" - "oto\032\020expression.proto\032\020extensions.proto\032" - "\031google/protobuf/any.proto\"\264\005\n\tRelCommon" - "\0220\n\006direct\030\001 \001(\0132\036.io.substrait.RelCommo" - "n.DirectH\000\022,\n\004emit\030\002 \001(\0132\034.io.substrait." - "RelCommon.EmitH\000\022*\n\004hint\030\003 \001(\0132\034.io.subs" - "trait.RelCommon.Hint\022F\n\022advanced_extensi" - "on\030\004 \001(\0132*.io.substrait.extensions.Advan" - "cedExtension\032\010\n\006Direct\032\036\n\004Emit\022\026\n\016output" - "_mapping\030\001 \003(\005\032\233\003\n\004Hint\0221\n\005stats\030\001 \001(\0132\"" - ".io.substrait.RelCommon.Hint.Stats\022B\n\nco" - "nstraint\030\002 \001(\0132..io.substrait.RelCommon." - "Hint.RuntimeConstraint\022F\n\022advanced_exten" - "sion\030\n \001(\0132*.io.substrait.extensions.Adv" - "ancedExtension\032w\n\005Stats\022\021\n\trow_count\030\001 \001" - "(\001\022\023\n\013record_size\030\002 \001(\001\022F\n\022advanced_exte" - "nsion\030\n \001(\0132*.io.substrait.extensions.Ad" - "vancedExtension\032[\n\021RuntimeConstraint\022F\n\022" - "advanced_extension\030\n \001(\0132*.io.substrait." - "extensions.AdvancedExtensionB\013\n\temit_kin" - "d\"\345\010\n\007ReadRel\022\'\n\006common\030\001 \001(\0132\027.io.subst" - "rait.RelCommon\022.\n\013base_schema\030\002 \001(\0132\031.io" - ".substrait.NamedStruct\022(\n\006filter\030\003 \001(\0132\030" - ".io.substrait.Expression\022;\n\nprojection\030\004" - " \001(\0132\'.io.substrait.Expression.MaskExpre" - "ssion\022F\n\022advanced_extension\030\n \001(\0132*.io.s" - "ubstrait.extensions.AdvancedExtension\022;\n" - "\rvirtual_table\030\005 \001(\0132\".io.substrait.Read" - "Rel.VirtualTableH\000\0227\n\013local_files\030\006 \001(\0132" - " .io.substrait.ReadRel.LocalFilesH\000\0227\n\013n" - "amed_table\030\007 \001(\0132 .io.substrait.ReadRel." - "NamedTableH\000\022\?\n\017extension_table\030\010 \001(\0132$." - "io.substrait.ReadRel.ExtensionTableH\000\032c\n" - "\nNamedTable\022\r\n\005names\030\001 \003(\t\022F\n\022advanced_e" - "xtension\030\n \001(\0132*.io.substrait.extensions" - ".AdvancedExtension\032G\n\014VirtualTable\0227\n\006va" - "lues\030\001 \003(\0132\'.io.substrait.Expression.Lit" - "eral.Struct\0326\n\016ExtensionTable\022$\n\006detail\030" - "\001 \001(\0132\024.google.protobuf.Any\032\356\002\n\nLocalFil" - "es\022;\n\005items\030\001 \003(\0132,.io.substrait.ReadRel" - ".LocalFiles.FileOrFiles\022F\n\022advanced_exte" - "nsion\030\n \001(\0132*.io.substrait.extensions.Ad" - "vancedExtension\032\332\001\n\013FileOrFiles\022\022\n\010uri_p" - "ath\030\001 \001(\tH\000\022\027\n\ruri_path_glob\030\002 \001(\tH\000\022\022\n\010" - "uri_file\030\003 \001(\tH\000\022\024\n\nuri_folder\030\004 \001(\tH\000\022C" - "\n\006format\030\005 \001(\01623.io.substrait.ReadRel.Lo" - "calFiles.FileOrFiles.Format\"\"\n\006Format\022\013\n" - "\007UNKNOWN\020\000\022\013\n\007PARQUET\020\001B\013\n\tpath_typeB\013\n\t" - "read_type\"\316\001\n\nProjectRel\022\'\n\006common\030\001 \001(\013" - "2\027.io.substrait.RelCommon\022 \n\005input\030\002 \001(\013" - "2\021.io.substrait.Rel\022-\n\013expressions\030\003 \003(\013" - "2\030.io.substrait.Expression\022F\n\022advanced_e" - "xtension\030\n \001(\0132*.io.substrait.extensions" - ".AdvancedExtension\"\245\003\n\007JoinRel\022\'\n\006common" - "\030\001 \001(\0132\027.io.substrait.RelCommon\022\037\n\004left\030" - "\002 \001(\0132\021.io.substrait.Rel\022 \n\005right\030\003 \001(\0132" - "\021.io.substrait.Rel\022,\n\nexpression\030\004 \001(\0132\030" - ".io.substrait.Expression\0222\n\020post_join_fi" - "lter\030\005 \001(\0132\030.io.substrait.Expression\022,\n\004" - "type\030\006 \001(\0162\036.io.substrait.JoinRel.JoinTy" - "pe\022F\n\022advanced_extension\030\n \001(\0132*.io.subs" - "trait.extensions.AdvancedExtension\"V\n\010Jo" - "inType\022\013\n\007UNKNOWN\020\000\022\t\n\005INNER\020\001\022\t\n\005OUTER\020" - "\002\022\010\n\004LEFT\020\003\022\t\n\005RIGHT\020\004\022\010\n\004SEMI\020\005\022\010\n\004ANTI" - "\020\006\"\274\001\n\010FetchRel\022\'\n\006common\030\001 \001(\0132\027.io.sub" - "strait.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.sub" - "strait.Rel\022\016\n\006offset\030\003 \001(\003\022\r\n\005count\030\004 \001(" - "\003\022F\n\022advanced_extension\030\n \001(\0132*.io.subst" - "rait.extensions.AdvancedExtension\"\230\003\n\014Ag" - "gregateRel\022\'\n\006common\030\001 \001(\0132\027.io.substrai" - "t.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.substrai" - "t.Rel\0226\n\tgroupings\030\003 \003(\0132#.io.substrait." - "AggregateRel.Grouping\0224\n\010measures\030\004 \003(\0132" - "\".io.substrait.AggregateRel.Measure\022F\n\022a" - "dvanced_extension\030\n \001(\0132*.io.substrait.e" - "xtensions.AdvancedExtension\032 \n\010Grouping\022" - "\024\n\014input_fields\030\001 \003(\005\032e\n\007Measure\0220\n\007meas" - "ure\030\001 \001(\0132\037.io.substrait.AggregateFuncti" - "on\022(\n\006filter\030\002 \001(\0132\030.io.substrait.Expres" - "sion\"\304\001\n\007SortRel\022\'\n\006common\030\001 \001(\0132\027.io.su" - "bstrait.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.su" - "bstrait.Rel\022&\n\005sorts\030\003 \003(\0132\027.io.substrai" - "t.SortField\022F\n\022advanced_extension\030\n \001(\0132" - "*.io.substrait.extensions.AdvancedExtens" - "ion\"\313\001\n\tFilterRel\022\'\n\006common\030\001 \001(\0132\027.io.s" - "ubstrait.RelCommon\022 \n\005input\030\002 \001(\0132\021.io.s" - "ubstrait.Rel\022+\n\tcondition\030\003 \001(\0132\030.io.sub" - "strait.Expression\022F\n\022advanced_extension\030" - "\n \001(\0132*.io.substrait.extensions.Advanced" - "Extension\"\332\002\n\006SetRel\022\'\n\006common\030\001 \001(\0132\027.i" - "o.substrait.RelCommon\022!\n\006inputs\030\002 \003(\0132\021." - "io.substrait.Rel\022&\n\002op\030\003 \001(\0162\032.io.substr" - "ait.SetRel.SetOp\022F\n\022advanced_extension\030\n" - " \001(\0132*.io.substrait.extensions.AdvancedE" - "xtension\"\223\001\n\005SetOp\022\013\n\007UNKNOWN\020\000\022\021\n\rMINUS" - "_PRIMARY\020\001\022\022\n\016MINUS_MULTISET\020\002\022\030\n\024INTERS" - "ECTION_PRIMARY\020\003\022\031\n\025INTERSECTION_MULTISE" - "T\020\004\022\022\n\016UNION_DISTINCT\020\005\022\r\n\tUNION_ALL\020\006\"\205" - "\001\n\022ExtensionSingleRel\022\'\n\006common\030\001 \001(\0132\027." - "io.substrait.RelCommon\022 \n\005input\030\002 \001(\0132\021." - "io.substrait.Rel\022$\n\006detail\030\003 \001(\0132\024.googl" - "e.protobuf.Any\"a\n\020ExtensionLeafRel\022\'\n\006co" - "mmon\030\001 \001(\0132\027.io.substrait.RelCommon\022$\n\006d" - "etail\030\002 \001(\0132\024.google.protobuf.Any\"\205\001\n\021Ex" - "tensionMultiRel\022\'\n\006common\030\001 \001(\0132\027.io.sub" - "strait.RelCommon\022!\n\006inputs\030\002 \003(\0132\021.io.su" - "bstrait.Rel\022$\n\006detail\030\003 \001(\0132\024.google.pro" - "tobuf.Any\":\n\007RelRoot\022 \n\005input\030\001 \001(\0132\021.io" - ".substrait.Rel\022\r\n\005names\030\002 \003(\t\"\220\004\n\003Rel\022%\n" - "\004read\030\001 \001(\0132\025.io.substrait.ReadRelH\000\022)\n\006" - "filter\030\002 \001(\0132\027.io.substrait.FilterRelH\000\022" - "\'\n\005fetch\030\003 \001(\0132\026.io.substrait.FetchRelH\000" - "\022/\n\taggregate\030\004 \001(\0132\032.io.substrait.Aggre" - "gateRelH\000\022%\n\004sort\030\005 \001(\0132\025.io.substrait.S" - "ortRelH\000\022%\n\004join\030\006 \001(\0132\025.io.substrait.Jo" - "inRelH\000\022+\n\007project\030\007 \001(\0132\030.io.substrait." - "ProjectRelH\000\022#\n\003set\030\010 \001(\0132\024.io.substrait" - ".SetRelH\000\022<\n\020extension_single\030\t \001(\0132 .io" - ".substrait.ExtensionSingleRelH\000\022:\n\017exten" - "sion_multi\030\n \001(\0132\037.io.substrait.Extensio" - "nMultiRelH\000\0228\n\016extension_leaf\030\013 \001(\0132\036.io" - ".substrait.ExtensionLeafRelH\000B\t\n\007RelType" - "B+\n\022io.substrait.protoP\001\252\002\022Substrait.Pro" - "tobufb\006proto3" +const char descriptor_table_protodef_substrait_2frelations_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\031substrait/relations.proto\022\tsubstrait\032\024" + "substrait/type.proto\032\032substrait/expressi" + "on.proto\032%substrait/extensions/extension" + "s.proto\032\031google/protobuf/any.proto\"\231\005\n\tR" + "elCommon\022-\n\006direct\030\001 \001(\0132\033.substrait.Rel" + "Common.DirectH\000\022)\n\004emit\030\002 \001(\0132\031.substrai" + "t.RelCommon.EmitH\000\022\'\n\004hint\030\003 \001(\0132\031.subst" + "rait.RelCommon.Hint\022C\n\022advanced_extensio" + "n\030\004 \001(\0132\'.substrait.extensions.AdvancedE" + "xtension\032\010\n\006Direct\032\036\n\004Emit\022\026\n\016output_map" + "ping\030\001 \003(\005\032\214\003\n\004Hint\022.\n\005stats\030\001 \001(\0132\037.sub" + "strait.RelCommon.Hint.Stats\022\?\n\nconstrain" + "t\030\002 \001(\0132+.substrait.RelCommon.Hint.Runti" + "meConstraint\022C\n\022advanced_extension\030\n \001(\013" + "2\'.substrait.extensions.AdvancedExtensio" + "n\032t\n\005Stats\022\021\n\trow_count\030\001 \001(\001\022\023\n\013record_" + "size\030\002 \001(\001\022C\n\022advanced_extension\030\n \001(\0132\'" + ".substrait.extensions.AdvancedExtension\032" + "X\n\021RuntimeConstraint\022C\n\022advanced_extensi" + "on\030\n \001(\0132\'.substrait.extensions.Advanced" + "ExtensionB\013\n\temit_kind\"\227\t\n\007ReadRel\022$\n\006co" + "mmon\030\001 \001(\0132\024.substrait.RelCommon\022+\n\013base" + "_schema\030\002 \001(\0132\026.substrait.NamedStruct\022%\n" + "\006filter\030\003 \001(\0132\025.substrait.Expression\0228\n\n" + "projection\030\004 \001(\0132$.substrait.Expression." + "MaskExpression\022C\n\022advanced_extension\030\n \001" + "(\0132\'.substrait.extensions.AdvancedExtens" + "ion\0228\n\rvirtual_table\030\005 \001(\0132\037.substrait.R" + "eadRel.VirtualTableH\000\0224\n\013local_files\030\006 \001" + "(\0132\035.substrait.ReadRel.LocalFilesH\000\0224\n\013n" + "amed_table\030\007 \001(\0132\035.substrait.ReadRel.Nam" + "edTableH\000\022<\n\017extension_table\030\010 \001(\0132!.sub" + "strait.ReadRel.ExtensionTableH\000\032`\n\nNamed" + "Table\022\r\n\005names\030\001 \003(\t\022C\n\022advanced_extensi" + "on\030\n \001(\0132\'.substrait.extensions.Advanced" + "Extension\032D\n\014VirtualTable\0224\n\006values\030\001 \003(" + "\0132$.substrait.Expression.Literal.Struct\032" + "6\n\016ExtensionTable\022$\n\006detail\030\001 \001(\0132\024.goog" + "le.protobuf.Any\032\301\003\n\nLocalFiles\0228\n\005items\030" + "\001 \003(\0132).substrait.ReadRel.LocalFiles.Fil" + "eOrFiles\022C\n\022advanced_extension\030\n \001(\0132\'.s" + "ubstrait.extensions.AdvancedExtension\032\263\002" + "\n\013FileOrFiles\022\022\n\010uri_path\030\001 \001(\tH\000\022\027\n\ruri" + "_path_glob\030\002 \001(\tH\000\022\022\n\010uri_file\030\003 \001(\tH\000\022\024" + "\n\nuri_folder\030\004 \001(\tH\000\022D\n\006format\030\005 \001(\01624.s" + "ubstrait.ReadRel.LocalFiles.FileOrFiles." + "FileFormat\022\027\n\017partition_index\030\006 \001(\004\022\r\n\005s" + "tart\030\007 \001(\004\022\016\n\006length\030\010 \001(\004\"B\n\nFileFormat" + "\022\033\n\027FILE_FORMAT_UNSPECIFIED\020\000\022\027\n\023FILE_FO" + "RMAT_PARQUET\020\001B\013\n\tpath_typeB\013\n\tread_type" + "\"\302\001\n\nProjectRel\022$\n\006common\030\001 \001(\0132\024.substr" + "ait.RelCommon\022\035\n\005input\030\002 \001(\0132\016.substrait" + ".Rel\022*\n\013expressions\030\003 \003(\0132\025.substrait.Ex" + "pression\022C\n\022advanced_extension\030\n \001(\0132\'.s" + "ubstrait.extensions.AdvancedExtension\"\333\003" + "\n\007JoinRel\022$\n\006common\030\001 \001(\0132\024.substrait.Re" + "lCommon\022\034\n\004left\030\002 \001(\0132\016.substrait.Rel\022\035\n" + "\005right\030\003 \001(\0132\016.substrait.Rel\022)\n\nexpressi" + "on\030\004 \001(\0132\025.substrait.Expression\022/\n\020post_" + "join_filter\030\005 \001(\0132\025.substrait.Expression" + "\022)\n\004type\030\006 \001(\0162\033.substrait.JoinRel.JoinT" + "ype\022C\n\022advanced_extension\030\n \001(\0132\'.substr" + "ait.extensions.AdvancedExtension\"\240\001\n\010Joi" + "nType\022\031\n\025JOIN_TYPE_UNSPECIFIED\020\000\022\023\n\017JOIN" + "_TYPE_INNER\020\001\022\023\n\017JOIN_TYPE_OUTER\020\002\022\022\n\016JO" + "IN_TYPE_LEFT\020\003\022\023\n\017JOIN_TYPE_RIGHT\020\004\022\022\n\016J" + "OIN_TYPE_SEMI\020\005\022\022\n\016JOIN_TYPE_ANTI\020\006\"\263\001\n\010" + "FetchRel\022$\n\006common\030\001 \001(\0132\024.substrait.Rel" + "Common\022\035\n\005input\030\002 \001(\0132\016.substrait.Rel\022\016\n" + "\006offset\030\003 \001(\003\022\r\n\005count\030\004 \001(\003\022C\n\022advanced" + "_extension\030\n \001(\0132\'.substrait.extensions." + "AdvancedExtension\"\242\003\n\014AggregateRel\022$\n\006co" + "mmon\030\001 \001(\0132\024.substrait.RelCommon\022\035\n\005inpu" + "t\030\002 \001(\0132\016.substrait.Rel\0223\n\tgroupings\030\003 \003" + "(\0132 .substrait.AggregateRel.Grouping\0221\n\010" + "measures\030\004 \003(\0132\037.substrait.AggregateRel." + "Measure\022C\n\022advanced_extension\030\n \001(\0132\'.su" + "bstrait.extensions.AdvancedExtension\032\?\n\010" + "Grouping\0223\n\024grouping_expressions\030\001 \003(\0132\025" + ".substrait.Expression\032_\n\007Measure\022-\n\007meas" + "ure\030\001 \001(\0132\034.substrait.AggregateFunction\022" + "%\n\006filter\030\002 \001(\0132\025.substrait.Expression\"\270" + "\001\n\007SortRel\022$\n\006common\030\001 \001(\0132\024.substrait.R" + "elCommon\022\035\n\005input\030\002 \001(\0132\016.substrait.Rel\022" + "#\n\005sorts\030\003 \003(\0132\024.substrait.SortField\022C\n\022" + "advanced_extension\030\n \001(\0132\'.substrait.ext" + "ensions.AdvancedExtension\"\277\001\n\tFilterRel\022" + "$\n\006common\030\001 \001(\0132\024.substrait.RelCommon\022\035\n" + "\005input\030\002 \001(\0132\016.substrait.Rel\022(\n\tconditio" + "n\030\003 \001(\0132\025.substrait.Expression\022C\n\022advanc" + "ed_extension\030\n \001(\0132\'.substrait.extension" + "s.AdvancedExtension\"\203\003\n\006SetRel\022$\n\006common" + "\030\001 \001(\0132\024.substrait.RelCommon\022\036\n\006inputs\030\002" + " \003(\0132\016.substrait.Rel\022#\n\002op\030\003 \001(\0162\027.subst" + "rait.SetRel.SetOp\022C\n\022advanced_extension\030" + "\n \001(\0132\'.substrait.extensions.AdvancedExt" + "ension\"\310\001\n\005SetOp\022\026\n\022SET_OP_UNSPECIFIED\020\000" + "\022\030\n\024SET_OP_MINUS_PRIMARY\020\001\022\031\n\025SET_OP_MIN" + "US_MULTISET\020\002\022\037\n\033SET_OP_INTERSECTION_PRI" + "MARY\020\003\022 \n\034SET_OP_INTERSECTION_MULTISET\020\004" + "\022\031\n\025SET_OP_UNION_DISTINCT\020\005\022\024\n\020SET_OP_UN" + "ION_ALL\020\006\"\177\n\022ExtensionSingleRel\022$\n\006commo" + "n\030\001 \001(\0132\024.substrait.RelCommon\022\035\n\005input\030\002" + " \001(\0132\016.substrait.Rel\022$\n\006detail\030\003 \001(\0132\024.g" + "oogle.protobuf.Any\"^\n\020ExtensionLeafRel\022$" + "\n\006common\030\001 \001(\0132\024.substrait.RelCommon\022$\n\006" + "detail\030\002 \001(\0132\024.google.protobuf.Any\"\177\n\021Ex" + "tensionMultiRel\022$\n\006common\030\001 \001(\0132\024.substr" + "ait.RelCommon\022\036\n\006inputs\030\002 \003(\0132\016.substrai" + "t.Rel\022$\n\006detail\030\003 \001(\0132\024.google.protobuf." + "Any\"7\n\007RelRoot\022\035\n\005input\030\001 \001(\0132\016.substrai" + "t.Rel\022\r\n\005names\030\002 \003(\t\"\360\003\n\003Rel\022\"\n\004read\030\001 \001" + "(\0132\022.substrait.ReadRelH\000\022&\n\006filter\030\002 \001(\013" + "2\024.substrait.FilterRelH\000\022$\n\005fetch\030\003 \001(\0132" + "\023.substrait.FetchRelH\000\022,\n\taggregate\030\004 \001(" + "\0132\027.substrait.AggregateRelH\000\022\"\n\004sort\030\005 \001" + "(\0132\022.substrait.SortRelH\000\022\"\n\004join\030\006 \001(\0132\022" + ".substrait.JoinRelH\000\022(\n\007project\030\007 \001(\0132\025." + "substrait.ProjectRelH\000\022 \n\003set\030\010 \001(\0132\021.su" + "bstrait.SetRelH\000\0229\n\020extension_single\030\t \001" + "(\0132\035.substrait.ExtensionSingleRelH\000\0227\n\017e" + "xtension_multi\030\n \001(\0132\034.substrait.Extensi" + "onMultiRelH\000\0225\n\016extension_leaf\030\013 \001(\0132\033.s" + "ubstrait.ExtensionLeafRelH\000B\n\n\010rel_typeB" + "+\n\022io.substrait.protoP\001\252\002\022Substrait.Prot" + "obufb\006proto3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_relations_2eproto_deps[4] = { - &::descriptor_table_expression_2eproto, - &::descriptor_table_extensions_2eproto, +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2frelations_2eproto_deps[4] = { &::descriptor_table_google_2fprotobuf_2fany_2eproto, - &::descriptor_table_type_2eproto, + &::descriptor_table_substrait_2fexpression_2eproto, + &::descriptor_table_substrait_2fextensions_2fextensions_2eproto, + &::descriptor_table_substrait_2ftype_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_relations_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_relations_2eproto = { - false, false, 4933, descriptor_table_protodef_relations_2eproto, "relations.proto", - &descriptor_table_relations_2eproto_once, descriptor_table_relations_2eproto_deps, 4, 26, - schemas, file_default_instances, TableStruct_relations_2eproto::offsets, - file_level_metadata_relations_2eproto, file_level_enum_descriptors_relations_2eproto, file_level_service_descriptors_relations_2eproto, +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2frelations_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2frelations_2eproto = { + false, false, 5012, descriptor_table_protodef_substrait_2frelations_2eproto, "substrait/relations.proto", + &descriptor_table_substrait_2frelations_2eproto_once, descriptor_table_substrait_2frelations_2eproto_deps, 4, 26, + schemas, file_default_instances, TableStruct_substrait_2frelations_2eproto::offsets, + file_level_metadata_substrait_2frelations_2eproto, file_level_enum_descriptors_substrait_2frelations_2eproto, file_level_service_descriptors_substrait_2frelations_2eproto, }; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_relations_2eproto_getter() { - return &descriptor_table_relations_2eproto; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2frelations_2eproto_getter() { + return &descriptor_table_substrait_2frelations_2eproto; } // Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_relations_2eproto(&descriptor_table_relations_2eproto); -namespace io { +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2frelations_2eproto(&descriptor_table_substrait_2frelations_2eproto); namespace substrait { -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_Format_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_relations_2eproto); - return file_level_enum_descriptors_relations_2eproto[0]; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto); + return file_level_enum_descriptors_substrait_2frelations_2eproto[0]; } -bool ReadRel_LocalFiles_FileOrFiles_Format_IsValid(int value) { +bool ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(int value) { switch (value) { case 0: case 1: @@ -832,15 +836,15 @@ bool ReadRel_LocalFiles_FileOrFiles_Format_IsValid(int value) { } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::UNKNOWN; -constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::PARQUET; -constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::Format_MIN; -constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::Format_MAX; -constexpr int ReadRel_LocalFiles_FileOrFiles::Format_ARRAYSIZE; +constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FILE_FORMAT_UNSPECIFIED; +constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FILE_FORMAT_PARQUET; +constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FileFormat_MIN; +constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FileFormat_MAX; +constexpr int ReadRel_LocalFiles_FileOrFiles::FileFormat_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_relations_2eproto); - return file_level_enum_descriptors_relations_2eproto[1]; + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto); + return file_level_enum_descriptors_substrait_2frelations_2eproto[1]; } bool JoinRel_JoinType_IsValid(int value) { switch (value) { @@ -858,20 +862,20 @@ bool JoinRel_JoinType_IsValid(int value) { } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr JoinRel_JoinType JoinRel::UNKNOWN; -constexpr JoinRel_JoinType JoinRel::INNER; -constexpr JoinRel_JoinType JoinRel::OUTER; -constexpr JoinRel_JoinType JoinRel::LEFT; -constexpr JoinRel_JoinType JoinRel::RIGHT; -constexpr JoinRel_JoinType JoinRel::SEMI; -constexpr JoinRel_JoinType JoinRel::ANTI; +constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_UNSPECIFIED; +constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_INNER; +constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_OUTER; +constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_LEFT; +constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_RIGHT; +constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_SEMI; +constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_ANTI; constexpr JoinRel_JoinType JoinRel::JoinType_MIN; constexpr JoinRel_JoinType JoinRel::JoinType_MAX; constexpr int JoinRel::JoinType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetRel_SetOp_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_relations_2eproto); - return file_level_enum_descriptors_relations_2eproto[2]; + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto); + return file_level_enum_descriptors_substrait_2frelations_2eproto[2]; } bool SetRel_SetOp_IsValid(int value) { switch (value) { @@ -889,13 +893,13 @@ bool SetRel_SetOp_IsValid(int value) { } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr SetRel_SetOp SetRel::UNKNOWN; -constexpr SetRel_SetOp SetRel::MINUS_PRIMARY; -constexpr SetRel_SetOp SetRel::MINUS_MULTISET; -constexpr SetRel_SetOp SetRel::INTERSECTION_PRIMARY; -constexpr SetRel_SetOp SetRel::INTERSECTION_MULTISET; -constexpr SetRel_SetOp SetRel::UNION_DISTINCT; -constexpr SetRel_SetOp SetRel::UNION_ALL; +constexpr SetRel_SetOp SetRel::SET_OP_UNSPECIFIED; +constexpr SetRel_SetOp SetRel::SET_OP_MINUS_PRIMARY; +constexpr SetRel_SetOp SetRel::SET_OP_MINUS_MULTISET; +constexpr SetRel_SetOp SetRel::SET_OP_INTERSECTION_PRIMARY; +constexpr SetRel_SetOp SetRel::SET_OP_INTERSECTION_MULTISET; +constexpr SetRel_SetOp SetRel::SET_OP_UNION_DISTINCT; +constexpr SetRel_SetOp SetRel::SET_OP_UNION_ALL; constexpr SetRel_SetOp SetRel::SetOp_MIN; constexpr SetRel_SetOp SetRel::SetOp_MAX; constexpr int SetRel::SetOp_ARRAYSIZE; @@ -911,19 +915,19 @@ RelCommon_Direct::RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Direct) + // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Direct) } RelCommon_Direct::RelCommon_Direct(const RelCommon_Direct& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Direct) + // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Direct) } void RelCommon_Direct::SharedCtor() { } RelCommon_Direct::~RelCommon_Direct() { - // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Direct) + // @@protoc_insertion_point(destructor:substrait.RelCommon.Direct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -943,7 +947,7 @@ void RelCommon_Direct::SetCachedSize(int size) const { } void RelCommon_Direct::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Direct) +// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Direct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -977,7 +981,7 @@ const char* RelCommon_Direct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Direct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Direct) + // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Direct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -985,12 +989,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Direct::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Direct) + // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Direct) return target; } size_t RelCommon_Direct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Direct) +// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Direct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1007,22 +1011,22 @@ size_t RelCommon_Direct::ByteSizeLong() const { } void RelCommon_Direct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Direct) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon.Direct) GOOGLE_DCHECK_NE(&from, this); const RelCommon_Direct* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Direct) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon.Direct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Direct) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon.Direct) MergeFrom(*source); } } void RelCommon_Direct::MergeFrom(const RelCommon_Direct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Direct) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Direct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1031,14 +1035,14 @@ void RelCommon_Direct::MergeFrom(const RelCommon_Direct& from) { } void RelCommon_Direct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Direct) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon.Direct) if (&from == this) return; Clear(); MergeFrom(from); } void RelCommon_Direct::CopyFrom(const RelCommon_Direct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Direct) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Direct) if (&from == this) return; Clear(); MergeFrom(from); @@ -1055,8 +1059,8 @@ void RelCommon_Direct::InternalSwap(RelCommon_Direct* other) { ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Direct::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[0]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[0]); } // =================================================================== @@ -1070,20 +1074,20 @@ RelCommon_Emit::RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena) output_mapping_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Emit) + // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Emit) } RelCommon_Emit::RelCommon_Emit(const RelCommon_Emit& from) : ::PROTOBUF_NAMESPACE_ID::Message(), output_mapping_(from.output_mapping_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Emit) + // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Emit) } void RelCommon_Emit::SharedCtor() { } RelCommon_Emit::~RelCommon_Emit() { - // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Emit) + // @@protoc_insertion_point(destructor:substrait.RelCommon.Emit) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1103,7 +1107,7 @@ void RelCommon_Emit::SetCachedSize(int size) const { } void RelCommon_Emit::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Emit) +// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Emit) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1153,7 +1157,7 @@ const char* RelCommon_Emit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Emit::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Emit) + // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Emit) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1170,12 +1174,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Emit::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Emit) + // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Emit) return target; } size_t RelCommon_Emit::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Emit) +// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Emit) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1207,22 +1211,22 @@ size_t RelCommon_Emit::ByteSizeLong() const { } void RelCommon_Emit::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Emit) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon.Emit) GOOGLE_DCHECK_NE(&from, this); const RelCommon_Emit* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Emit) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon.Emit) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Emit) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon.Emit) MergeFrom(*source); } } void RelCommon_Emit::MergeFrom(const RelCommon_Emit& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Emit) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Emit) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1232,14 +1236,14 @@ void RelCommon_Emit::MergeFrom(const RelCommon_Emit& from) { } void RelCommon_Emit::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Emit) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon.Emit) if (&from == this) return; Clear(); MergeFrom(from); } void RelCommon_Emit::CopyFrom(const RelCommon_Emit& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Emit) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Emit) if (&from == this) return; Clear(); MergeFrom(from); @@ -1257,18 +1261,18 @@ void RelCommon_Emit::InternalSwap(RelCommon_Emit* other) { ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Emit::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[1]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[1]); } // =================================================================== class RelCommon_Hint_Stats::_Internal { public: - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_Stats* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_Stats* msg); }; -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::_Internal::advanced_extension(const RelCommon_Hint_Stats* msg) { return *msg->advanced_extension_; } @@ -1282,20 +1286,20 @@ RelCommon_Hint_Stats::RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Hint.Stats) + // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint.Stats) } RelCommon_Hint_Stats::RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } ::memcpy(&row_count_, &from.row_count_, static_cast(reinterpret_cast(&record_size_) - reinterpret_cast(&row_count_)) + sizeof(record_size_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Hint.Stats) + // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.Stats) } void RelCommon_Hint_Stats::SharedCtor() { @@ -1306,7 +1310,7 @@ ::memset(reinterpret_cast(this) + static_cast( } RelCommon_Hint_Stats::~RelCommon_Hint_Stats() { - // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Hint.Stats) + // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint.Stats) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1327,7 +1331,7 @@ void RelCommon_Hint_Stats::SetCachedSize(int size) const { } void RelCommon_Hint_Stats::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Hint.Stats) +// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint.Stats) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1362,7 +1366,7 @@ const char* RelCommon_Hint_Stats::_InternalParse(const char* ptr, ::PROTOBUF_NAM ptr += sizeof(double); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -1394,7 +1398,7 @@ const char* RelCommon_Hint_Stats::_InternalParse(const char* ptr, ::PROTOBUF_NAM ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_Stats::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Hint.Stats) + // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint.Stats) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1410,7 +1414,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_Stats::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_record_size(), target); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1422,19 +1426,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_Stats::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Hint.Stats) + // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Hint.Stats) return target; } size_t RelCommon_Hint_Stats::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Hint.Stats) +// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint.Stats) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1461,29 +1465,29 @@ size_t RelCommon_Hint_Stats::ByteSizeLong() const { } void RelCommon_Hint_Stats::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Hint.Stats) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon.Hint.Stats) GOOGLE_DCHECK_NE(&from, this); const RelCommon_Hint_Stats* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Hint.Stats) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon.Hint.Stats) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Hint.Stats) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon.Hint.Stats) MergeFrom(*source); } } void RelCommon_Hint_Stats::MergeFrom(const RelCommon_Hint_Stats& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Hint.Stats) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint.Stats) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } if (!(from.row_count() <= 0 && from.row_count() >= 0)) { _internal_set_row_count(from._internal_row_count()); @@ -1494,14 +1498,14 @@ void RelCommon_Hint_Stats::MergeFrom(const RelCommon_Hint_Stats& from) { } void RelCommon_Hint_Stats::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Hint.Stats) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon.Hint.Stats) if (&from == this) return; Clear(); MergeFrom(from); } void RelCommon_Hint_Stats::CopyFrom(const RelCommon_Hint_Stats& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Hint.Stats) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Hint.Stats) if (&from == this) return; Clear(); MergeFrom(from); @@ -1524,18 +1528,18 @@ void RelCommon_Hint_Stats::InternalSwap(RelCommon_Hint_Stats* other) { ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_Stats::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[2]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[2]); } // =================================================================== class RelCommon_Hint_RuntimeConstraint::_Internal { public: - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg); }; -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::_Internal::advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg) { return *msg->advanced_extension_; } @@ -1549,17 +1553,17 @@ RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NA : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Hint.RuntimeConstraint) + // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint.RuntimeConstraint) } RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(const RelCommon_Hint_RuntimeConstraint& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Hint.RuntimeConstraint) + // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.RuntimeConstraint) } void RelCommon_Hint_RuntimeConstraint::SharedCtor() { @@ -1567,7 +1571,7 @@ advanced_extension_ = nullptr; } RelCommon_Hint_RuntimeConstraint::~RelCommon_Hint_RuntimeConstraint() { - // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Hint.RuntimeConstraint) + // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint.RuntimeConstraint) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1588,7 +1592,7 @@ void RelCommon_Hint_RuntimeConstraint::SetCachedSize(int size) const { } void RelCommon_Hint_RuntimeConstraint::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Hint.RuntimeConstraint) +// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint.RuntimeConstraint) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1606,7 +1610,7 @@ const char* RelCommon_Hint_RuntimeConstraint::_InternalParse(const char* ptr, :: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -1638,11 +1642,11 @@ const char* RelCommon_Hint_RuntimeConstraint::_InternalParse(const char* ptr, :: ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_RuntimeConstraint::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Hint.RuntimeConstraint) + // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint.RuntimeConstraint) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1654,19 +1658,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_RuntimeConstraint::_InternalSeria target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Hint.RuntimeConstraint) + // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Hint.RuntimeConstraint) return target; } size_t RelCommon_Hint_RuntimeConstraint::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Hint.RuntimeConstraint) +// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint.RuntimeConstraint) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1683,41 +1687,41 @@ size_t RelCommon_Hint_RuntimeConstraint::ByteSizeLong() const { } void RelCommon_Hint_RuntimeConstraint::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Hint.RuntimeConstraint) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon.Hint.RuntimeConstraint) GOOGLE_DCHECK_NE(&from, this); const RelCommon_Hint_RuntimeConstraint* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Hint.RuntimeConstraint) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon.Hint.RuntimeConstraint) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Hint.RuntimeConstraint) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon.Hint.RuntimeConstraint) MergeFrom(*source); } } void RelCommon_Hint_RuntimeConstraint::MergeFrom(const RelCommon_Hint_RuntimeConstraint& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Hint.RuntimeConstraint) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint.RuntimeConstraint) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } } void RelCommon_Hint_RuntimeConstraint::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Hint.RuntimeConstraint) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon.Hint.RuntimeConstraint) if (&from == this) return; Clear(); MergeFrom(from); } void RelCommon_Hint_RuntimeConstraint::CopyFrom(const RelCommon_Hint_RuntimeConstraint& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Hint.RuntimeConstraint) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Hint.RuntimeConstraint) if (&from == this) return; Clear(); MergeFrom(from); @@ -1735,28 +1739,28 @@ void RelCommon_Hint_RuntimeConstraint::InternalSwap(RelCommon_Hint_RuntimeConstr ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_RuntimeConstraint::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[3]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[3]); } // =================================================================== class RelCommon_Hint::_Internal { public: - static const ::io::substrait::RelCommon_Hint_Stats& stats(const RelCommon_Hint* msg); - static const ::io::substrait::RelCommon_Hint_RuntimeConstraint& constraint(const RelCommon_Hint* msg); - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint* msg); + static const ::substrait::RelCommon_Hint_Stats& stats(const RelCommon_Hint* msg); + static const ::substrait::RelCommon_Hint_RuntimeConstraint& constraint(const RelCommon_Hint* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint* msg); }; -const ::io::substrait::RelCommon_Hint_Stats& +const ::substrait::RelCommon_Hint_Stats& RelCommon_Hint::_Internal::stats(const RelCommon_Hint* msg) { return *msg->stats_; } -const ::io::substrait::RelCommon_Hint_RuntimeConstraint& +const ::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::_Internal::constraint(const RelCommon_Hint* msg) { return *msg->constraint_; } -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& RelCommon_Hint::_Internal::advanced_extension(const RelCommon_Hint* msg) { return *msg->advanced_extension_; } @@ -1770,27 +1774,27 @@ RelCommon_Hint::RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon.Hint) + // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint) } RelCommon_Hint::RelCommon_Hint(const RelCommon_Hint& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_stats()) { - stats_ = new ::io::substrait::RelCommon_Hint_Stats(*from.stats_); + stats_ = new ::substrait::RelCommon_Hint_Stats(*from.stats_); } else { stats_ = nullptr; } if (from._internal_has_constraint()) { - constraint_ = new ::io::substrait::RelCommon_Hint_RuntimeConstraint(*from.constraint_); + constraint_ = new ::substrait::RelCommon_Hint_RuntimeConstraint(*from.constraint_); } else { constraint_ = nullptr; } if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon.Hint) + // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint) } void RelCommon_Hint::SharedCtor() { @@ -1801,7 +1805,7 @@ ::memset(reinterpret_cast(this) + static_cast( } RelCommon_Hint::~RelCommon_Hint() { - // @@protoc_insertion_point(destructor:io.substrait.RelCommon.Hint) + // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1824,7 +1828,7 @@ void RelCommon_Hint::SetCachedSize(int size) const { } void RelCommon_Hint::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon.Hint) +// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1850,21 +1854,21 @@ const char* RelCommon_Hint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon.Hint.Stats stats = 1; + // .substrait.RelCommon.Hint.Stats stats = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_stats(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; + // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_constraint(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -1896,11 +1900,11 @@ const char* RelCommon_Hint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon.Hint) + // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon.Hint.Stats stats = 1; + // .substrait.RelCommon.Hint.Stats stats = 1; if (this->has_stats()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1908,7 +1912,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint::_InternalSerialize( 1, _Internal::stats(this), target, stream); } - // .io.substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; + // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; if (this->has_constraint()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1916,7 +1920,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint::_InternalSerialize( 2, _Internal::constraint(this), target, stream); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1928,33 +1932,33 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon.Hint) + // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Hint) return target; } size_t RelCommon_Hint::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon.Hint) +// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.RelCommon.Hint.Stats stats = 1; + // .substrait.RelCommon.Hint.Stats stats = 1; if (this->has_stats()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *stats_); } - // .io.substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; + // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; if (this->has_constraint()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *constraint_); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1971,47 +1975,47 @@ size_t RelCommon_Hint::ByteSizeLong() const { } void RelCommon_Hint::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon.Hint) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon.Hint) GOOGLE_DCHECK_NE(&from, this); const RelCommon_Hint* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon.Hint) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon.Hint) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon.Hint) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon.Hint) MergeFrom(*source); } } void RelCommon_Hint::MergeFrom(const RelCommon_Hint& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon.Hint) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_stats()) { - _internal_mutable_stats()->::io::substrait::RelCommon_Hint_Stats::MergeFrom(from._internal_stats()); + _internal_mutable_stats()->::substrait::RelCommon_Hint_Stats::MergeFrom(from._internal_stats()); } if (from.has_constraint()) { - _internal_mutable_constraint()->::io::substrait::RelCommon_Hint_RuntimeConstraint::MergeFrom(from._internal_constraint()); + _internal_mutable_constraint()->::substrait::RelCommon_Hint_RuntimeConstraint::MergeFrom(from._internal_constraint()); } if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } } void RelCommon_Hint::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon.Hint) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon.Hint) if (&from == this) return; Clear(); MergeFrom(from); } void RelCommon_Hint::CopyFrom(const RelCommon_Hint& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon.Hint) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Hint) if (&from == this) return; Clear(); MergeFrom(from); @@ -2034,37 +2038,37 @@ void RelCommon_Hint::InternalSwap(RelCommon_Hint* other) { ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[4]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[4]); } // =================================================================== class RelCommon::_Internal { public: - static const ::io::substrait::RelCommon_Direct& direct(const RelCommon* msg); - static const ::io::substrait::RelCommon_Emit& emit(const RelCommon* msg); - static const ::io::substrait::RelCommon_Hint& hint(const RelCommon* msg); - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon* msg); + static const ::substrait::RelCommon_Direct& direct(const RelCommon* msg); + static const ::substrait::RelCommon_Emit& emit(const RelCommon* msg); + static const ::substrait::RelCommon_Hint& hint(const RelCommon* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon* msg); }; -const ::io::substrait::RelCommon_Direct& +const ::substrait::RelCommon_Direct& RelCommon::_Internal::direct(const RelCommon* msg) { return *msg->emit_kind_.direct_; } -const ::io::substrait::RelCommon_Emit& +const ::substrait::RelCommon_Emit& RelCommon::_Internal::emit(const RelCommon* msg) { return *msg->emit_kind_.emit_; } -const ::io::substrait::RelCommon_Hint& +const ::substrait::RelCommon_Hint& RelCommon::_Internal::hint(const RelCommon* msg) { return *msg->hint_; } -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& RelCommon::_Internal::advanced_extension(const RelCommon* msg) { return *msg->advanced_extension_; } -void RelCommon::set_allocated_direct(::io::substrait::RelCommon_Direct* direct) { +void RelCommon::set_allocated_direct(::substrait::RelCommon_Direct* direct) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_emit_kind(); if (direct) { @@ -2077,9 +2081,9 @@ void RelCommon::set_allocated_direct(::io::substrait::RelCommon_Direct* direct) set_has_direct(); emit_kind_.direct_ = direct; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.direct) + // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.direct) } -void RelCommon::set_allocated_emit(::io::substrait::RelCommon_Emit* emit) { +void RelCommon::set_allocated_emit(::substrait::RelCommon_Emit* emit) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_emit_kind(); if (emit) { @@ -2092,7 +2096,7 @@ void RelCommon::set_allocated_emit(::io::substrait::RelCommon_Emit* emit) { set_has_emit(); emit_kind_.emit_ = emit; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.emit) + // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.emit) } void RelCommon::clear_advanced_extension() { if (GetArena() == nullptr && advanced_extension_ != nullptr) { @@ -2104,36 +2108,36 @@ RelCommon::RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.RelCommon) + // @@protoc_insertion_point(arena_constructor:substrait.RelCommon) } RelCommon::RelCommon(const RelCommon& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_hint()) { - hint_ = new ::io::substrait::RelCommon_Hint(*from.hint_); + hint_ = new ::substrait::RelCommon_Hint(*from.hint_); } else { hint_ = nullptr; } if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } clear_has_emit_kind(); switch (from.emit_kind_case()) { case kDirect: { - _internal_mutable_direct()->::io::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); + _internal_mutable_direct()->::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); break; } case kEmit: { - _internal_mutable_emit()->::io::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); + _internal_mutable_emit()->::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); break; } case EMIT_KIND_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.RelCommon) + // @@protoc_insertion_point(copy_constructor:substrait.RelCommon) } void RelCommon::SharedCtor() { @@ -2145,7 +2149,7 @@ clear_has_emit_kind(); } RelCommon::~RelCommon() { - // @@protoc_insertion_point(destructor:io.substrait.RelCommon) + // @@protoc_insertion_point(destructor:substrait.RelCommon) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2170,7 +2174,7 @@ void RelCommon::SetCachedSize(int size) const { } void RelCommon::clear_emit_kind() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.RelCommon) +// @@protoc_insertion_point(one_of_clear_start:substrait.RelCommon) switch (emit_kind_case()) { case kDirect: { if (GetArena() == nullptr) { @@ -2193,7 +2197,7 @@ void RelCommon::clear_emit_kind() { void RelCommon::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.RelCommon) +// @@protoc_insertion_point(message_clear_start:substrait.RelCommon) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2216,28 +2220,28 @@ const char* RelCommon::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon.Direct direct = 1; + // .substrait.RelCommon.Direct direct = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_direct(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.RelCommon.Emit emit = 2; + // .substrait.RelCommon.Emit emit = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_emit(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.RelCommon.Hint hint = 3; + // .substrait.RelCommon.Hint hint = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_hint(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 4; + // .substrait.extensions.AdvancedExtension advanced_extension = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -2269,11 +2273,11 @@ const char* RelCommon::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelCommon) + // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon.Direct direct = 1; + // .substrait.RelCommon.Direct direct = 1; if (_internal_has_direct()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2281,7 +2285,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon::_InternalSerialize( 1, _Internal::direct(this), target, stream); } - // .io.substrait.RelCommon.Emit emit = 2; + // .substrait.RelCommon.Emit emit = 2; if (_internal_has_emit()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2289,7 +2293,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon::_InternalSerialize( 2, _Internal::emit(this), target, stream); } - // .io.substrait.RelCommon.Hint hint = 3; + // .substrait.RelCommon.Hint hint = 3; if (this->has_hint()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2297,7 +2301,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon::_InternalSerialize( 3, _Internal::hint(this), target, stream); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 4; + // .substrait.extensions.AdvancedExtension advanced_extension = 4; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2309,26 +2313,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelCommon) + // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon) return target; } size_t RelCommon::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelCommon) +// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.RelCommon.Hint hint = 3; + // .substrait.RelCommon.Hint hint = 3; if (this->has_hint()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *hint_); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 4; + // .substrait.extensions.AdvancedExtension advanced_extension = 4; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2336,14 +2340,14 @@ size_t RelCommon::ByteSizeLong() const { } switch (emit_kind_case()) { - // .io.substrait.RelCommon.Direct direct = 1; + // .substrait.RelCommon.Direct direct = 1; case kDirect: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *emit_kind_.direct_); break; } - // .io.substrait.RelCommon.Emit emit = 2; + // .substrait.RelCommon.Emit emit = 2; case kEmit: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2364,40 +2368,40 @@ size_t RelCommon::ByteSizeLong() const { } void RelCommon::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelCommon) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon) GOOGLE_DCHECK_NE(&from, this); const RelCommon* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelCommon) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelCommon) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon) MergeFrom(*source); } } void RelCommon::MergeFrom(const RelCommon& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelCommon) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_hint()) { - _internal_mutable_hint()->::io::substrait::RelCommon_Hint::MergeFrom(from._internal_hint()); + _internal_mutable_hint()->::substrait::RelCommon_Hint::MergeFrom(from._internal_hint()); } if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } switch (from.emit_kind_case()) { case kDirect: { - _internal_mutable_direct()->::io::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); + _internal_mutable_direct()->::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); break; } case kEmit: { - _internal_mutable_emit()->::io::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); + _internal_mutable_emit()->::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); break; } case EMIT_KIND_NOT_SET: { @@ -2407,14 +2411,14 @@ void RelCommon::MergeFrom(const RelCommon& from) { } void RelCommon::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelCommon) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon) if (&from == this) return; Clear(); MergeFrom(from); } void RelCommon::CopyFrom(const RelCommon& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelCommon) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon) if (&from == this) return; Clear(); MergeFrom(from); @@ -2439,18 +2443,18 @@ void RelCommon::InternalSwap(RelCommon* other) { ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[5]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[5]); } // =================================================================== class ReadRel_NamedTable::_Internal { public: - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_NamedTable* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_NamedTable* msg); }; -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::_Internal::advanced_extension(const ReadRel_NamedTable* msg) { return *msg->advanced_extension_; } @@ -2465,18 +2469,18 @@ ReadRel_NamedTable::ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena) names_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.NamedTable) + // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.NamedTable) } ReadRel_NamedTable::ReadRel_NamedTable(const ReadRel_NamedTable& from) : ::PROTOBUF_NAMESPACE_ID::Message(), names_(from.names_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.NamedTable) + // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.NamedTable) } void ReadRel_NamedTable::SharedCtor() { @@ -2484,7 +2488,7 @@ advanced_extension_ = nullptr; } ReadRel_NamedTable::~ReadRel_NamedTable() { - // @@protoc_insertion_point(destructor:io.substrait.ReadRel.NamedTable) + // @@protoc_insertion_point(destructor:substrait.ReadRel.NamedTable) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2505,7 +2509,7 @@ void ReadRel_NamedTable::SetCachedSize(int size) const { } void ReadRel_NamedTable::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel.NamedTable) +// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.NamedTable) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2532,13 +2536,13 @@ const char* ReadRel_NamedTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMES ptr += 1; auto str = _internal_add_names(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReadRel.NamedTable.names")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.NamedTable.names")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -2570,7 +2574,7 @@ const char* ReadRel_NamedTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMES ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_NamedTable::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel.NamedTable) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.NamedTable) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2580,11 +2584,11 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_NamedTable::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.ReadRel.NamedTable.names"); + "substrait.ReadRel.NamedTable.names"); target = stream->WriteString(1, s, target); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2596,12 +2600,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_NamedTable::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel.NamedTable) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.NamedTable) return target; } size_t ReadRel_NamedTable::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel.NamedTable) +// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.NamedTable) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2616,7 +2620,7 @@ size_t ReadRel_NamedTable::ByteSizeLong() const { names_.Get(i)); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2633,22 +2637,22 @@ size_t ReadRel_NamedTable::ByteSizeLong() const { } void ReadRel_NamedTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel.NamedTable) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel.NamedTable) GOOGLE_DCHECK_NE(&from, this); const ReadRel_NamedTable* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel.NamedTable) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel.NamedTable) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel.NamedTable) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel.NamedTable) MergeFrom(*source); } } void ReadRel_NamedTable::MergeFrom(const ReadRel_NamedTable& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel.NamedTable) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.NamedTable) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2656,19 +2660,19 @@ void ReadRel_NamedTable::MergeFrom(const ReadRel_NamedTable& from) { names_.MergeFrom(from.names_); if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } } void ReadRel_NamedTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel.NamedTable) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel.NamedTable) if (&from == this) return; Clear(); MergeFrom(from); } void ReadRel_NamedTable::CopyFrom(const ReadRel_NamedTable& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel.NamedTable) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.NamedTable) if (&from == this) return; Clear(); MergeFrom(from); @@ -2687,8 +2691,8 @@ void ReadRel_NamedTable::InternalSwap(ReadRel_NamedTable* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_NamedTable::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[6]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[6]); } // =================================================================== @@ -2705,20 +2709,20 @@ ReadRel_VirtualTable::ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena values_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.VirtualTable) + // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.VirtualTable) } ReadRel_VirtualTable::ReadRel_VirtualTable(const ReadRel_VirtualTable& from) : ::PROTOBUF_NAMESPACE_ID::Message(), values_(from.values_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.VirtualTable) + // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.VirtualTable) } void ReadRel_VirtualTable::SharedCtor() { } ReadRel_VirtualTable::~ReadRel_VirtualTable() { - // @@protoc_insertion_point(destructor:io.substrait.ReadRel.VirtualTable) + // @@protoc_insertion_point(destructor:substrait.ReadRel.VirtualTable) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2738,7 +2742,7 @@ void ReadRel_VirtualTable::SetCachedSize(int size) const { } void ReadRel_VirtualTable::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel.VirtualTable) +// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.VirtualTable) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2753,7 +2757,7 @@ const char* ReadRel_VirtualTable::_InternalParse(const char* ptr, ::PROTOBUF_NAM ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Expression.Literal.Struct values = 1; + // repeated .substrait.Expression.Literal.Struct values = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -2790,11 +2794,11 @@ const char* ReadRel_VirtualTable::_InternalParse(const char* ptr, ::PROTOBUF_NAM ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_VirtualTable::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel.VirtualTable) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.VirtualTable) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal.Struct values = 1; + // repeated .substrait.Expression.Literal.Struct values = 1; for (unsigned int i = 0, n = static_cast(this->_internal_values_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -2806,19 +2810,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_VirtualTable::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel.VirtualTable) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.VirtualTable) return target; } size_t ReadRel_VirtualTable::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel.VirtualTable) +// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.VirtualTable) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression.Literal.Struct values = 1; + // repeated .substrait.Expression.Literal.Struct values = 1; total_size += 1UL * this->_internal_values_size(); for (const auto& msg : this->values_) { total_size += @@ -2835,22 +2839,22 @@ size_t ReadRel_VirtualTable::ByteSizeLong() const { } void ReadRel_VirtualTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel.VirtualTable) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel.VirtualTable) GOOGLE_DCHECK_NE(&from, this); const ReadRel_VirtualTable* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel.VirtualTable) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel.VirtualTable) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel.VirtualTable) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel.VirtualTable) MergeFrom(*source); } } void ReadRel_VirtualTable::MergeFrom(const ReadRel_VirtualTable& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel.VirtualTable) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.VirtualTable) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2860,14 +2864,14 @@ void ReadRel_VirtualTable::MergeFrom(const ReadRel_VirtualTable& from) { } void ReadRel_VirtualTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel.VirtualTable) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel.VirtualTable) if (&from == this) return; Clear(); MergeFrom(from); } void ReadRel_VirtualTable::CopyFrom(const ReadRel_VirtualTable& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel.VirtualTable) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.VirtualTable) if (&from == this) return; Clear(); MergeFrom(from); @@ -2885,8 +2889,8 @@ void ReadRel_VirtualTable::InternalSwap(ReadRel_VirtualTable* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_VirtualTable::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[7]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[7]); } // =================================================================== @@ -2910,7 +2914,7 @@ ReadRel_ExtensionTable::ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* a : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.ExtensionTable) + // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.ExtensionTable) } ReadRel_ExtensionTable::ReadRel_ExtensionTable(const ReadRel_ExtensionTable& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -2920,7 +2924,7 @@ ReadRel_ExtensionTable::ReadRel_ExtensionTable(const ReadRel_ExtensionTable& fro } else { detail_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.ExtensionTable) + // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.ExtensionTable) } void ReadRel_ExtensionTable::SharedCtor() { @@ -2928,7 +2932,7 @@ detail_ = nullptr; } ReadRel_ExtensionTable::~ReadRel_ExtensionTable() { - // @@protoc_insertion_point(destructor:io.substrait.ReadRel.ExtensionTable) + // @@protoc_insertion_point(destructor:substrait.ReadRel.ExtensionTable) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2949,7 +2953,7 @@ void ReadRel_ExtensionTable::SetCachedSize(int size) const { } void ReadRel_ExtensionTable::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel.ExtensionTable) +// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.ExtensionTable) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2999,7 +3003,7 @@ const char* ReadRel_ExtensionTable::_InternalParse(const char* ptr, ::PROTOBUF_N ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_ExtensionTable::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel.ExtensionTable) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.ExtensionTable) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3015,12 +3019,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_ExtensionTable::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel.ExtensionTable) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.ExtensionTable) return target; } size_t ReadRel_ExtensionTable::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel.ExtensionTable) +// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.ExtensionTable) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3044,22 +3048,22 @@ size_t ReadRel_ExtensionTable::ByteSizeLong() const { } void ReadRel_ExtensionTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel.ExtensionTable) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel.ExtensionTable) GOOGLE_DCHECK_NE(&from, this); const ReadRel_ExtensionTable* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel.ExtensionTable) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel.ExtensionTable) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel.ExtensionTable) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel.ExtensionTable) MergeFrom(*source); } } void ReadRel_ExtensionTable::MergeFrom(const ReadRel_ExtensionTable& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel.ExtensionTable) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.ExtensionTable) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3071,14 +3075,14 @@ void ReadRel_ExtensionTable::MergeFrom(const ReadRel_ExtensionTable& from) { } void ReadRel_ExtensionTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel.ExtensionTable) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel.ExtensionTable) if (&from == this) return; Clear(); MergeFrom(from); } void ReadRel_ExtensionTable::CopyFrom(const ReadRel_ExtensionTable& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel.ExtensionTable) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.ExtensionTable) if (&from == this) return; Clear(); MergeFrom(from); @@ -3096,8 +3100,8 @@ void ReadRel_ExtensionTable::InternalSwap(ReadRel_ExtensionTable* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_ExtensionTable::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[8]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[8]); } // =================================================================== @@ -3110,12 +3114,14 @@ ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESP : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) + // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.LocalFiles.FileOrFiles) } ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - format_ = from.format_; + ::memcpy(&format_, &from.format_, + static_cast(reinterpret_cast(&length_) - + reinterpret_cast(&format_)) + sizeof(length_)); clear_has_path_type(); switch (from.path_type_case()) { case kUriPath: { @@ -3138,16 +3144,19 @@ ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(const ReadRel_Loc break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) + // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.LocalFiles.FileOrFiles) } void ReadRel_LocalFiles_FileOrFiles::SharedCtor() { -format_ = 0; +::memset(reinterpret_cast(this) + static_cast( + reinterpret_cast(&format_) - reinterpret_cast(this)), + 0, static_cast(reinterpret_cast(&length_) - + reinterpret_cast(&format_)) + sizeof(length_)); clear_has_path_type(); } ReadRel_LocalFiles_FileOrFiles::~ReadRel_LocalFiles_FileOrFiles() { - // @@protoc_insertion_point(destructor:io.substrait.ReadRel.LocalFiles.FileOrFiles) + // @@protoc_insertion_point(destructor:substrait.ReadRel.LocalFiles.FileOrFiles) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3170,7 +3179,7 @@ void ReadRel_LocalFiles_FileOrFiles::SetCachedSize(int size) const { } void ReadRel_LocalFiles_FileOrFiles::clear_path_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) +// @@protoc_insertion_point(one_of_clear_start:substrait.ReadRel.LocalFiles.FileOrFiles) switch (path_type_case()) { case kUriPath: { path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); @@ -3197,12 +3206,14 @@ void ReadRel_LocalFiles_FileOrFiles::clear_path_type() { void ReadRel_LocalFiles_FileOrFiles::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) +// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.LocalFiles.FileOrFiles) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - format_ = 0; + ::memset(&format_, 0, static_cast( + reinterpret_cast(&length_) - + reinterpret_cast(&format_)) + sizeof(length_)); clear_path_type(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3218,7 +3229,7 @@ const char* ReadRel_LocalFiles_FileOrFiles::_InternalParse(const char* ptr, ::PR if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_uri_path(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path")); CHK_(ptr); } else goto handle_unusual; continue; @@ -3227,7 +3238,7 @@ const char* ReadRel_LocalFiles_FileOrFiles::_InternalParse(const char* ptr, ::PR if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_uri_path_glob(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob")); CHK_(ptr); } else goto handle_unusual; continue; @@ -3236,7 +3247,7 @@ const char* ReadRel_LocalFiles_FileOrFiles::_InternalParse(const char* ptr, ::PR if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { auto str = _internal_mutable_uri_file(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_file")); CHK_(ptr); } else goto handle_unusual; continue; @@ -3245,16 +3256,37 @@ const char* ReadRel_LocalFiles_FileOrFiles::_InternalParse(const char* ptr, ::PR if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { auto str = _internal_mutable_uri_folder(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder")); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 5; + // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_format(static_cast<::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format>(val)); + _internal_set_format(static_cast<::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat>(val)); + } else goto handle_unusual; + continue; + // uint64 partition_index = 6; + case 6: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + partition_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 start = 7; + case 7: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); + } else goto handle_unusual; + continue; + // uint64 length = 8; + case 8: + if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + CHK_(ptr); } else goto handle_unusual; continue; default: { @@ -3282,7 +3314,7 @@ const char* ReadRel_LocalFiles_FileOrFiles::_InternalParse(const char* ptr, ::PR ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles_FileOrFiles::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.LocalFiles.FileOrFiles) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3291,7 +3323,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles_FileOrFiles::_InternalSeriali ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_uri_path().data(), static_cast(this->_internal_uri_path().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path"); + "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path"); target = stream->WriteStringMaybeAliased( 1, this->_internal_uri_path(), target); } @@ -3301,7 +3333,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles_FileOrFiles::_InternalSeriali ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_uri_path_glob().data(), static_cast(this->_internal_uri_path_glob().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob"); + "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob"); target = stream->WriteStringMaybeAliased( 2, this->_internal_uri_path_glob(), target); } @@ -3311,7 +3343,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles_FileOrFiles::_InternalSeriali ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_uri_file().data(), static_cast(this->_internal_uri_file().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file"); + "substrait.ReadRel.LocalFiles.FileOrFiles.uri_file"); target = stream->WriteStringMaybeAliased( 3, this->_internal_uri_file(), target); } @@ -3321,40 +3353,79 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles_FileOrFiles::_InternalSeriali ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_uri_folder().data(), static_cast(this->_internal_uri_folder().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder"); + "substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder"); target = stream->WriteStringMaybeAliased( 4, this->_internal_uri_folder(), target); } - // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 5; + // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; if (this->format() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 5, this->_internal_format(), target); } + // uint64 partition_index = 6; + if (this->partition_index() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(6, this->_internal_partition_index(), target); + } + + // uint64 start = 7; + if (this->start() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(7, this->_internal_start(), target); + } + + // uint64 length = 8; + if (this->length() != 0) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->_internal_length(), target); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel.LocalFiles.FileOrFiles) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.LocalFiles.FileOrFiles) return target; } size_t ReadRel_LocalFiles_FileOrFiles::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) +// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.LocalFiles.FileOrFiles) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 5; + // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; if (this->format() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_format()); } + // uint64 partition_index = 6; + if (this->partition_index() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_partition_index()); + } + + // uint64 start = 7; + if (this->start() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_start()); + } + + // uint64 length = 8; + if (this->length() != 0) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( + this->_internal_length()); + } + switch (path_type_case()) { // string uri_path = 1; case kUriPath: { @@ -3398,22 +3469,22 @@ size_t ReadRel_LocalFiles_FileOrFiles::ByteSizeLong() const { } void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel.LocalFiles.FileOrFiles) GOOGLE_DCHECK_NE(&from, this); const ReadRel_LocalFiles_FileOrFiles* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel.LocalFiles.FileOrFiles) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel.LocalFiles.FileOrFiles) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel.LocalFiles.FileOrFiles) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel.LocalFiles.FileOrFiles) MergeFrom(*source); } } void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ReadRel_LocalFiles_FileOrFiles& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.LocalFiles.FileOrFiles) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3422,6 +3493,15 @@ void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ReadRel_LocalFiles_FileOrFi if (from.format() != 0) { _internal_set_format(from._internal_format()); } + if (from.partition_index() != 0) { + _internal_set_partition_index(from._internal_partition_index()); + } + if (from.start() != 0) { + _internal_set_start(from._internal_start()); + } + if (from.length() != 0) { + _internal_set_length(from._internal_length()); + } switch (from.path_type_case()) { case kUriPath: { _internal_set_uri_path(from._internal_uri_path()); @@ -3446,14 +3526,14 @@ void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ReadRel_LocalFiles_FileOrFi } void ReadRel_LocalFiles_FileOrFiles::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel.LocalFiles.FileOrFiles) if (&from == this) return; Clear(); MergeFrom(from); } void ReadRel_LocalFiles_FileOrFiles::CopyFrom(const ReadRel_LocalFiles_FileOrFiles& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel.LocalFiles.FileOrFiles) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.LocalFiles.FileOrFiles) if (&from == this) return; Clear(); MergeFrom(from); @@ -3466,25 +3546,30 @@ bool ReadRel_LocalFiles_FileOrFiles::IsInitialized() const { void ReadRel_LocalFiles_FileOrFiles::InternalSwap(ReadRel_LocalFiles_FileOrFiles* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(format_, other->format_); + ::PROTOBUF_NAMESPACE_ID::internal::memswap< + PROTOBUF_FIELD_OFFSET(ReadRel_LocalFiles_FileOrFiles, length_) + + sizeof(ReadRel_LocalFiles_FileOrFiles::length_) + - PROTOBUF_FIELD_OFFSET(ReadRel_LocalFiles_FileOrFiles, format_)>( + reinterpret_cast(&format_), + reinterpret_cast(&other->format_)); swap(path_type_, other->path_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles_FileOrFiles::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[9]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[9]); } // =================================================================== class ReadRel_LocalFiles::_Internal { public: - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_LocalFiles* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_LocalFiles* msg); }; -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::_Internal::advanced_extension(const ReadRel_LocalFiles* msg) { return *msg->advanced_extension_; } @@ -3499,18 +3584,18 @@ ReadRel_LocalFiles::ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena) items_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel.LocalFiles) + // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.LocalFiles) } ReadRel_LocalFiles::ReadRel_LocalFiles(const ReadRel_LocalFiles& from) : ::PROTOBUF_NAMESPACE_ID::Message(), items_(from.items_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel.LocalFiles) + // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.LocalFiles) } void ReadRel_LocalFiles::SharedCtor() { @@ -3518,7 +3603,7 @@ advanced_extension_ = nullptr; } ReadRel_LocalFiles::~ReadRel_LocalFiles() { - // @@protoc_insertion_point(destructor:io.substrait.ReadRel.LocalFiles) + // @@protoc_insertion_point(destructor:substrait.ReadRel.LocalFiles) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3539,7 +3624,7 @@ void ReadRel_LocalFiles::SetCachedSize(int size) const { } void ReadRel_LocalFiles::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel.LocalFiles) +// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.LocalFiles) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3558,7 +3643,7 @@ const char* ReadRel_LocalFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMES ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; + // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -3570,7 +3655,7 @@ const char* ReadRel_LocalFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMES } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -3602,11 +3687,11 @@ const char* ReadRel_LocalFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMES ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel.LocalFiles) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.LocalFiles) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; + // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; for (unsigned int i = 0, n = static_cast(this->_internal_items_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -3614,7 +3699,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles::_InternalSerialize( InternalWriteMessage(1, this->_internal_items(i), target, stream); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3626,26 +3711,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel.LocalFiles) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.LocalFiles) return target; } size_t ReadRel_LocalFiles::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel.LocalFiles) +// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.LocalFiles) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; + // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; total_size += 1UL * this->_internal_items_size(); for (const auto& msg : this->items_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -3662,22 +3747,22 @@ size_t ReadRel_LocalFiles::ByteSizeLong() const { } void ReadRel_LocalFiles::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel.LocalFiles) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel.LocalFiles) GOOGLE_DCHECK_NE(&from, this); const ReadRel_LocalFiles* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel.LocalFiles) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel.LocalFiles) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel.LocalFiles) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel.LocalFiles) MergeFrom(*source); } } void ReadRel_LocalFiles::MergeFrom(const ReadRel_LocalFiles& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel.LocalFiles) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.LocalFiles) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3685,19 +3770,19 @@ void ReadRel_LocalFiles::MergeFrom(const ReadRel_LocalFiles& from) { items_.MergeFrom(from.items_); if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } } void ReadRel_LocalFiles::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel.LocalFiles) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel.LocalFiles) if (&from == this) return; Clear(); MergeFrom(from); } void ReadRel_LocalFiles::CopyFrom(const ReadRel_LocalFiles& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel.LocalFiles) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.LocalFiles) if (&from == this) return; Clear(); MergeFrom(from); @@ -3716,58 +3801,58 @@ void ReadRel_LocalFiles::InternalSwap(ReadRel_LocalFiles* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[10]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[10]); } // =================================================================== class ReadRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const ReadRel* msg); - static const ::io::substrait::NamedStruct& base_schema(const ReadRel* msg); - static const ::io::substrait::Expression& filter(const ReadRel* msg); - static const ::io::substrait::Expression_MaskExpression& projection(const ReadRel* msg); - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel* msg); - static const ::io::substrait::ReadRel_VirtualTable& virtual_table(const ReadRel* msg); - static const ::io::substrait::ReadRel_LocalFiles& local_files(const ReadRel* msg); - static const ::io::substrait::ReadRel_NamedTable& named_table(const ReadRel* msg); - static const ::io::substrait::ReadRel_ExtensionTable& extension_table(const ReadRel* msg); + static const ::substrait::RelCommon& common(const ReadRel* msg); + static const ::substrait::NamedStruct& base_schema(const ReadRel* msg); + static const ::substrait::Expression& filter(const ReadRel* msg); + static const ::substrait::Expression_MaskExpression& projection(const ReadRel* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel* msg); + static const ::substrait::ReadRel_VirtualTable& virtual_table(const ReadRel* msg); + static const ::substrait::ReadRel_LocalFiles& local_files(const ReadRel* msg); + static const ::substrait::ReadRel_NamedTable& named_table(const ReadRel* msg); + static const ::substrait::ReadRel_ExtensionTable& extension_table(const ReadRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& ReadRel::_Internal::common(const ReadRel* msg) { return *msg->common_; } -const ::io::substrait::NamedStruct& +const ::substrait::NamedStruct& ReadRel::_Internal::base_schema(const ReadRel* msg) { return *msg->base_schema_; } -const ::io::substrait::Expression& +const ::substrait::Expression& ReadRel::_Internal::filter(const ReadRel* msg) { return *msg->filter_; } -const ::io::substrait::Expression_MaskExpression& +const ::substrait::Expression_MaskExpression& ReadRel::_Internal::projection(const ReadRel* msg) { return *msg->projection_; } -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& ReadRel::_Internal::advanced_extension(const ReadRel* msg) { return *msg->advanced_extension_; } -const ::io::substrait::ReadRel_VirtualTable& +const ::substrait::ReadRel_VirtualTable& ReadRel::_Internal::virtual_table(const ReadRel* msg) { return *msg->read_type_.virtual_table_; } -const ::io::substrait::ReadRel_LocalFiles& +const ::substrait::ReadRel_LocalFiles& ReadRel::_Internal::local_files(const ReadRel* msg) { return *msg->read_type_.local_files_; } -const ::io::substrait::ReadRel_NamedTable& +const ::substrait::ReadRel_NamedTable& ReadRel::_Internal::named_table(const ReadRel* msg) { return *msg->read_type_.named_table_; } -const ::io::substrait::ReadRel_ExtensionTable& +const ::substrait::ReadRel_ExtensionTable& ReadRel::_Internal::extension_table(const ReadRel* msg) { return *msg->read_type_.extension_table_; } @@ -3795,7 +3880,7 @@ void ReadRel::clear_advanced_extension() { } advanced_extension_ = nullptr; } -void ReadRel::set_allocated_virtual_table(::io::substrait::ReadRel_VirtualTable* virtual_table) { +void ReadRel::set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_read_type(); if (virtual_table) { @@ -3808,9 +3893,9 @@ void ReadRel::set_allocated_virtual_table(::io::substrait::ReadRel_VirtualTable* set_has_virtual_table(); read_type_.virtual_table_ = virtual_table; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.virtual_table) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.virtual_table) } -void ReadRel::set_allocated_local_files(::io::substrait::ReadRel_LocalFiles* local_files) { +void ReadRel::set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_read_type(); if (local_files) { @@ -3823,9 +3908,9 @@ void ReadRel::set_allocated_local_files(::io::substrait::ReadRel_LocalFiles* loc set_has_local_files(); read_type_.local_files_ = local_files; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.local_files) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.local_files) } -void ReadRel::set_allocated_named_table(::io::substrait::ReadRel_NamedTable* named_table) { +void ReadRel::set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_read_type(); if (named_table) { @@ -3838,9 +3923,9 @@ void ReadRel::set_allocated_named_table(::io::substrait::ReadRel_NamedTable* nam set_has_named_table(); read_type_.named_table_ = named_table; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.named_table) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.named_table) } -void ReadRel::set_allocated_extension_table(::io::substrait::ReadRel_ExtensionTable* extension_table) { +void ReadRel::set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_read_type(); if (extension_table) { @@ -3853,65 +3938,65 @@ void ReadRel::set_allocated_extension_table(::io::substrait::ReadRel_ExtensionTa set_has_extension_table(); read_type_.extension_table_ = extension_table; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.extension_table) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.extension_table) } ReadRel::ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ReadRel) + // @@protoc_insertion_point(arena_constructor:substrait.ReadRel) } ReadRel::ReadRel(const ReadRel& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } if (from._internal_has_base_schema()) { - base_schema_ = new ::io::substrait::NamedStruct(*from.base_schema_); + base_schema_ = new ::substrait::NamedStruct(*from.base_schema_); } else { base_schema_ = nullptr; } if (from._internal_has_filter()) { - filter_ = new ::io::substrait::Expression(*from.filter_); + filter_ = new ::substrait::Expression(*from.filter_); } else { filter_ = nullptr; } if (from._internal_has_projection()) { - projection_ = new ::io::substrait::Expression_MaskExpression(*from.projection_); + projection_ = new ::substrait::Expression_MaskExpression(*from.projection_); } else { projection_ = nullptr; } if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } clear_has_read_type(); switch (from.read_type_case()) { case kVirtualTable: { - _internal_mutable_virtual_table()->::io::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table()); + _internal_mutable_virtual_table()->::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table()); break; } case kLocalFiles: { - _internal_mutable_local_files()->::io::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files()); + _internal_mutable_local_files()->::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files()); break; } case kNamedTable: { - _internal_mutable_named_table()->::io::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table()); + _internal_mutable_named_table()->::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table()); break; } case kExtensionTable: { - _internal_mutable_extension_table()->::io::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table()); + _internal_mutable_extension_table()->::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table()); break; } case READ_TYPE_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.ReadRel) + // @@protoc_insertion_point(copy_constructor:substrait.ReadRel) } void ReadRel::SharedCtor() { @@ -3923,7 +4008,7 @@ clear_has_read_type(); } ReadRel::~ReadRel() { - // @@protoc_insertion_point(destructor:io.substrait.ReadRel) + // @@protoc_insertion_point(destructor:substrait.ReadRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3951,7 +4036,7 @@ void ReadRel::SetCachedSize(int size) const { } void ReadRel::clear_read_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.ReadRel) +// @@protoc_insertion_point(one_of_clear_start:substrait.ReadRel) switch (read_type_case()) { case kVirtualTable: { if (GetArena() == nullptr) { @@ -3986,7 +4071,7 @@ void ReadRel::clear_read_type() { void ReadRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ReadRel) +// @@protoc_insertion_point(message_clear_start:substrait.ReadRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4021,63 +4106,63 @@ const char* ReadRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.NamedStruct base_schema = 2; + // .substrait.NamedStruct base_schema = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_base_schema(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression filter = 3; + // .substrait.Expression filter = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression.MaskExpression projection = 4; + // .substrait.Expression.MaskExpression projection = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_projection(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ReadRel.VirtualTable virtual_table = 5; + // .substrait.ReadRel.VirtualTable virtual_table = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_virtual_table(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ReadRel.LocalFiles local_files = 6; + // .substrait.ReadRel.LocalFiles local_files = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_local_files(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ReadRel.NamedTable named_table = 7; + // .substrait.ReadRel.NamedTable named_table = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_named_table(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ReadRel.ExtensionTable extension_table = 8; + // .substrait.ReadRel.ExtensionTable extension_table = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { ptr = ctx->ParseMessage(_internal_mutable_extension_table(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -4109,11 +4194,11 @@ const char* ReadRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ReadRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4121,7 +4206,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // .io.substrait.NamedStruct base_schema = 2; + // .substrait.NamedStruct base_schema = 2; if (this->has_base_schema()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4129,7 +4214,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 2, _Internal::base_schema(this), target, stream); } - // .io.substrait.Expression filter = 3; + // .substrait.Expression filter = 3; if (this->has_filter()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4137,7 +4222,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 3, _Internal::filter(this), target, stream); } - // .io.substrait.Expression.MaskExpression projection = 4; + // .substrait.Expression.MaskExpression projection = 4; if (this->has_projection()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4145,7 +4230,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 4, _Internal::projection(this), target, stream); } - // .io.substrait.ReadRel.VirtualTable virtual_table = 5; + // .substrait.ReadRel.VirtualTable virtual_table = 5; if (_internal_has_virtual_table()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4153,7 +4238,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 5, _Internal::virtual_table(this), target, stream); } - // .io.substrait.ReadRel.LocalFiles local_files = 6; + // .substrait.ReadRel.LocalFiles local_files = 6; if (_internal_has_local_files()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4161,7 +4246,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 6, _Internal::local_files(this), target, stream); } - // .io.substrait.ReadRel.NamedTable named_table = 7; + // .substrait.ReadRel.NamedTable named_table = 7; if (_internal_has_named_table()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4169,7 +4254,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 7, _Internal::named_table(this), target, stream); } - // .io.substrait.ReadRel.ExtensionTable extension_table = 8; + // .substrait.ReadRel.ExtensionTable extension_table = 8; if (_internal_has_extension_table()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4177,7 +4262,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( 8, _Internal::extension_table(this), target, stream); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4189,47 +4274,47 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ReadRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel) return target; } size_t ReadRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ReadRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } - // .io.substrait.NamedStruct base_schema = 2; + // .substrait.NamedStruct base_schema = 2; if (this->has_base_schema()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *base_schema_); } - // .io.substrait.Expression filter = 3; + // .substrait.Expression filter = 3; if (this->has_filter()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *filter_); } - // .io.substrait.Expression.MaskExpression projection = 4; + // .substrait.Expression.MaskExpression projection = 4; if (this->has_projection()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *projection_); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -4237,28 +4322,28 @@ size_t ReadRel::ByteSizeLong() const { } switch (read_type_case()) { - // .io.substrait.ReadRel.VirtualTable virtual_table = 5; + // .substrait.ReadRel.VirtualTable virtual_table = 5; case kVirtualTable: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *read_type_.virtual_table_); break; } - // .io.substrait.ReadRel.LocalFiles local_files = 6; + // .substrait.ReadRel.LocalFiles local_files = 6; case kLocalFiles: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *read_type_.local_files_); break; } - // .io.substrait.ReadRel.NamedTable named_table = 7; + // .substrait.ReadRel.NamedTable named_table = 7; case kNamedTable: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *read_type_.named_table_); break; } - // .io.substrait.ReadRel.ExtensionTable extension_table = 8; + // .substrait.ReadRel.ExtensionTable extension_table = 8; case kExtensionTable: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -4279,57 +4364,57 @@ size_t ReadRel::ByteSizeLong() const { } void ReadRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ReadRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel) GOOGLE_DCHECK_NE(&from, this); const ReadRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ReadRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ReadRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel) MergeFrom(*source); } } void ReadRel::MergeFrom(const ReadRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ReadRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_base_schema()) { - _internal_mutable_base_schema()->::io::substrait::NamedStruct::MergeFrom(from._internal_base_schema()); + _internal_mutable_base_schema()->::substrait::NamedStruct::MergeFrom(from._internal_base_schema()); } if (from.has_filter()) { - _internal_mutable_filter()->::io::substrait::Expression::MergeFrom(from._internal_filter()); + _internal_mutable_filter()->::substrait::Expression::MergeFrom(from._internal_filter()); } if (from.has_projection()) { - _internal_mutable_projection()->::io::substrait::Expression_MaskExpression::MergeFrom(from._internal_projection()); + _internal_mutable_projection()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_projection()); } if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } switch (from.read_type_case()) { case kVirtualTable: { - _internal_mutable_virtual_table()->::io::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table()); + _internal_mutable_virtual_table()->::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table()); break; } case kLocalFiles: { - _internal_mutable_local_files()->::io::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files()); + _internal_mutable_local_files()->::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files()); break; } case kNamedTable: { - _internal_mutable_named_table()->::io::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table()); + _internal_mutable_named_table()->::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table()); break; } case kExtensionTable: { - _internal_mutable_extension_table()->::io::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table()); + _internal_mutable_extension_table()->::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table()); break; } case READ_TYPE_NOT_SET: { @@ -4339,14 +4424,14 @@ void ReadRel::MergeFrom(const ReadRel& from) { } void ReadRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ReadRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel) if (&from == this) return; Clear(); MergeFrom(from); } void ReadRel::CopyFrom(const ReadRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ReadRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -4371,28 +4456,28 @@ void ReadRel::InternalSwap(ReadRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[11]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[11]); } // =================================================================== class ProjectRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const ProjectRel* msg); - static const ::io::substrait::Rel& input(const ProjectRel* msg); - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const ProjectRel* msg); + static const ::substrait::RelCommon& common(const ProjectRel* msg); + static const ::substrait::Rel& input(const ProjectRel* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ProjectRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& ProjectRel::_Internal::common(const ProjectRel* msg) { return *msg->common_; } -const ::io::substrait::Rel& +const ::substrait::Rel& ProjectRel::_Internal::input(const ProjectRel* msg) { return *msg->input_; } -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& ProjectRel::_Internal::advanced_extension(const ProjectRel* msg) { return *msg->advanced_extension_; } @@ -4410,28 +4495,28 @@ ProjectRel::ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) expressions_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ProjectRel) + // @@protoc_insertion_point(arena_constructor:substrait.ProjectRel) } ProjectRel::ProjectRel(const ProjectRel& from) : ::PROTOBUF_NAMESPACE_ID::Message(), expressions_(from.expressions_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } if (from._internal_has_input()) { - input_ = new ::io::substrait::Rel(*from.input_); + input_ = new ::substrait::Rel(*from.input_); } else { input_ = nullptr; } if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.ProjectRel) + // @@protoc_insertion_point(copy_constructor:substrait.ProjectRel) } void ProjectRel::SharedCtor() { @@ -4442,7 +4527,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ProjectRel::~ProjectRel() { - // @@protoc_insertion_point(destructor:io.substrait.ProjectRel) + // @@protoc_insertion_point(destructor:substrait.ProjectRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4465,7 +4550,7 @@ void ProjectRel::SetCachedSize(int size) const { } void ProjectRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ProjectRel) +// @@protoc_insertion_point(message_clear_start:substrait.ProjectRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4492,21 +4577,21 @@ const char* ProjectRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Expression expressions = 3; + // repeated .substrait.Expression expressions = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; @@ -4518,7 +4603,7 @@ const char* ProjectRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -4550,11 +4635,11 @@ const char* ProjectRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: ::PROTOBUF_NAMESPACE_ID::uint8* ProjectRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ProjectRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ProjectRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4562,7 +4647,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ProjectRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4570,7 +4655,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ProjectRel::_InternalSerialize( 2, _Internal::input(this), target, stream); } - // repeated .io.substrait.Expression expressions = 3; + // repeated .substrait.Expression expressions = 3; for (unsigned int i = 0, n = static_cast(this->_internal_expressions_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -4578,7 +4663,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ProjectRel::_InternalSerialize( InternalWriteMessage(3, this->_internal_expressions(i), target, stream); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4590,40 +4675,40 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ProjectRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ProjectRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ProjectRel) return target; } size_t ProjectRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ProjectRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.ProjectRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Expression expressions = 3; + // repeated .substrait.Expression expressions = 3; total_size += 1UL * this->_internal_expressions_size(); for (const auto& msg : this->expressions_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -4640,22 +4725,22 @@ size_t ProjectRel::ByteSizeLong() const { } void ProjectRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ProjectRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ProjectRel) GOOGLE_DCHECK_NE(&from, this); const ProjectRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ProjectRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ProjectRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ProjectRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ProjectRel) MergeFrom(*source); } } void ProjectRel::MergeFrom(const ProjectRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ProjectRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ProjectRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4663,25 +4748,25 @@ void ProjectRel::MergeFrom(const ProjectRel& from) { expressions_.MergeFrom(from.expressions_); if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_input()) { - _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } } void ProjectRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ProjectRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ProjectRel) if (&from == this) return; Clear(); MergeFrom(from); } void ProjectRel::CopyFrom(const ProjectRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ProjectRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ProjectRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -4705,43 +4790,43 @@ void ProjectRel::InternalSwap(ProjectRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ProjectRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[12]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[12]); } // =================================================================== class JoinRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const JoinRel* msg); - static const ::io::substrait::Rel& left(const JoinRel* msg); - static const ::io::substrait::Rel& right(const JoinRel* msg); - static const ::io::substrait::Expression& expression(const JoinRel* msg); - static const ::io::substrait::Expression& post_join_filter(const JoinRel* msg); - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const JoinRel* msg); + static const ::substrait::RelCommon& common(const JoinRel* msg); + static const ::substrait::Rel& left(const JoinRel* msg); + static const ::substrait::Rel& right(const JoinRel* msg); + static const ::substrait::Expression& expression(const JoinRel* msg); + static const ::substrait::Expression& post_join_filter(const JoinRel* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const JoinRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& JoinRel::_Internal::common(const JoinRel* msg) { return *msg->common_; } -const ::io::substrait::Rel& +const ::substrait::Rel& JoinRel::_Internal::left(const JoinRel* msg) { return *msg->left_; } -const ::io::substrait::Rel& +const ::substrait::Rel& JoinRel::_Internal::right(const JoinRel* msg) { return *msg->right_; } -const ::io::substrait::Expression& +const ::substrait::Expression& JoinRel::_Internal::expression(const JoinRel* msg) { return *msg->expression_; } -const ::io::substrait::Expression& +const ::substrait::Expression& JoinRel::_Internal::post_join_filter(const JoinRel* msg) { return *msg->post_join_filter_; } -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& JoinRel::_Internal::advanced_extension(const JoinRel* msg) { return *msg->advanced_extension_; } @@ -4767,43 +4852,43 @@ JoinRel::JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.JoinRel) + // @@protoc_insertion_point(arena_constructor:substrait.JoinRel) } JoinRel::JoinRel(const JoinRel& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } if (from._internal_has_left()) { - left_ = new ::io::substrait::Rel(*from.left_); + left_ = new ::substrait::Rel(*from.left_); } else { left_ = nullptr; } if (from._internal_has_right()) { - right_ = new ::io::substrait::Rel(*from.right_); + right_ = new ::substrait::Rel(*from.right_); } else { right_ = nullptr; } if (from._internal_has_expression()) { - expression_ = new ::io::substrait::Expression(*from.expression_); + expression_ = new ::substrait::Expression(*from.expression_); } else { expression_ = nullptr; } if (from._internal_has_post_join_filter()) { - post_join_filter_ = new ::io::substrait::Expression(*from.post_join_filter_); + post_join_filter_ = new ::substrait::Expression(*from.post_join_filter_); } else { post_join_filter_ = nullptr; } if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } type_ = from.type_; - // @@protoc_insertion_point(copy_constructor:io.substrait.JoinRel) + // @@protoc_insertion_point(copy_constructor:substrait.JoinRel) } void JoinRel::SharedCtor() { @@ -4814,7 +4899,7 @@ ::memset(reinterpret_cast(this) + static_cast( } JoinRel::~JoinRel() { - // @@protoc_insertion_point(destructor:io.substrait.JoinRel) + // @@protoc_insertion_point(destructor:substrait.JoinRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4840,7 +4925,7 @@ void JoinRel::SetCachedSize(int size) const { } void JoinRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.JoinRel) +// @@protoc_insertion_point(message_clear_start:substrait.JoinRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4879,50 +4964,50 @@ const char* JoinRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Rel left = 2; + // .substrait.Rel left = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_left(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Rel right = 3; + // .substrait.Rel right = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_right(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression expression = 4; + // .substrait.Expression expression = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression post_join_filter = 5; + // .substrait.Expression post_join_filter = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_post_join_filter(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.JoinRel.JoinType type = 6; + // .substrait.JoinRel.JoinType type = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_type(static_cast<::io::substrait::JoinRel_JoinType>(val)); + _internal_set_type(static_cast<::substrait::JoinRel_JoinType>(val)); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -4954,11 +5039,11 @@ const char* JoinRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.JoinRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.JoinRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4966,7 +5051,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // .io.substrait.Rel left = 2; + // .substrait.Rel left = 2; if (this->has_left()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4974,7 +5059,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( 2, _Internal::left(this), target, stream); } - // .io.substrait.Rel right = 3; + // .substrait.Rel right = 3; if (this->has_right()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4982,7 +5067,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( 3, _Internal::right(this), target, stream); } - // .io.substrait.Expression expression = 4; + // .substrait.Expression expression = 4; if (this->has_expression()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4990,7 +5075,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( 4, _Internal::expression(this), target, stream); } - // .io.substrait.Expression post_join_filter = 5; + // .substrait.Expression post_join_filter = 5; if (this->has_post_join_filter()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -4998,14 +5083,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( 5, _Internal::post_join_filter(this), target, stream); } - // .io.substrait.JoinRel.JoinType type = 6; + // .substrait.JoinRel.JoinType type = 6; if (this->type() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 6, this->_internal_type(), target); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5017,61 +5102,61 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.JoinRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.JoinRel) return target; } size_t JoinRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.JoinRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.JoinRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } - // .io.substrait.Rel left = 2; + // .substrait.Rel left = 2; if (this->has_left()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *left_); } - // .io.substrait.Rel right = 3; + // .substrait.Rel right = 3; if (this->has_right()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *right_); } - // .io.substrait.Expression expression = 4; + // .substrait.Expression expression = 4; if (this->has_expression()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *expression_); } - // .io.substrait.Expression post_join_filter = 5; + // .substrait.Expression post_join_filter = 5; if (this->has_post_join_filter()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *post_join_filter_); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } - // .io.substrait.JoinRel.JoinType type = 6; + // .substrait.JoinRel.JoinType type = 6; if (this->type() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); @@ -5087,44 +5172,44 @@ size_t JoinRel::ByteSizeLong() const { } void JoinRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.JoinRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.JoinRel) GOOGLE_DCHECK_NE(&from, this); const JoinRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.JoinRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.JoinRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.JoinRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.JoinRel) MergeFrom(*source); } } void JoinRel::MergeFrom(const JoinRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.JoinRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.JoinRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_left()) { - _internal_mutable_left()->::io::substrait::Rel::MergeFrom(from._internal_left()); + _internal_mutable_left()->::substrait::Rel::MergeFrom(from._internal_left()); } if (from.has_right()) { - _internal_mutable_right()->::io::substrait::Rel::MergeFrom(from._internal_right()); + _internal_mutable_right()->::substrait::Rel::MergeFrom(from._internal_right()); } if (from.has_expression()) { - _internal_mutable_expression()->::io::substrait::Expression::MergeFrom(from._internal_expression()); + _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression()); } if (from.has_post_join_filter()) { - _internal_mutable_post_join_filter()->::io::substrait::Expression::MergeFrom(from._internal_post_join_filter()); + _internal_mutable_post_join_filter()->::substrait::Expression::MergeFrom(from._internal_post_join_filter()); } if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } if (from.type() != 0) { _internal_set_type(from._internal_type()); @@ -5132,14 +5217,14 @@ void JoinRel::MergeFrom(const JoinRel& from) { } void JoinRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.JoinRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.JoinRel) if (&from == this) return; Clear(); MergeFrom(from); } void JoinRel::CopyFrom(const JoinRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.JoinRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.JoinRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -5162,28 +5247,28 @@ void JoinRel::InternalSwap(JoinRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata JoinRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[13]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[13]); } // =================================================================== class FetchRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const FetchRel* msg); - static const ::io::substrait::Rel& input(const FetchRel* msg); - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const FetchRel* msg); + static const ::substrait::RelCommon& common(const FetchRel* msg); + static const ::substrait::Rel& input(const FetchRel* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const FetchRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& FetchRel::_Internal::common(const FetchRel* msg) { return *msg->common_; } -const ::io::substrait::Rel& +const ::substrait::Rel& FetchRel::_Internal::input(const FetchRel* msg) { return *msg->input_; } -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& FetchRel::_Internal::advanced_extension(const FetchRel* msg) { return *msg->advanced_extension_; } @@ -5197,30 +5282,30 @@ FetchRel::FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FetchRel) + // @@protoc_insertion_point(arena_constructor:substrait.FetchRel) } FetchRel::FetchRel(const FetchRel& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } if (from._internal_has_input()) { - input_ = new ::io::substrait::Rel(*from.input_); + input_ = new ::substrait::Rel(*from.input_); } else { input_ = nullptr; } if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } ::memcpy(&offset_, &from.offset_, static_cast(reinterpret_cast(&count_) - reinterpret_cast(&offset_)) + sizeof(count_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.FetchRel) + // @@protoc_insertion_point(copy_constructor:substrait.FetchRel) } void FetchRel::SharedCtor() { @@ -5231,7 +5316,7 @@ ::memset(reinterpret_cast(this) + static_cast( } FetchRel::~FetchRel() { - // @@protoc_insertion_point(destructor:io.substrait.FetchRel) + // @@protoc_insertion_point(destructor:substrait.FetchRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5254,7 +5339,7 @@ void FetchRel::SetCachedSize(int size) const { } void FetchRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FetchRel) +// @@protoc_insertion_point(message_clear_start:substrait.FetchRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5283,14 +5368,14 @@ const char* FetchRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); @@ -5311,7 +5396,7 @@ const char* FetchRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -5343,11 +5428,11 @@ const char* FetchRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i ::PROTOBUF_NAMESPACE_ID::uint8* FetchRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FetchRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FetchRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5355,7 +5440,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FetchRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5375,7 +5460,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FetchRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_count(), target); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5387,33 +5472,33 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FetchRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FetchRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FetchRel) return target; } size_t FetchRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FetchRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.FetchRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -5444,35 +5529,35 @@ size_t FetchRel::ByteSizeLong() const { } void FetchRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FetchRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FetchRel) GOOGLE_DCHECK_NE(&from, this); const FetchRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FetchRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FetchRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FetchRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FetchRel) MergeFrom(*source); } } void FetchRel::MergeFrom(const FetchRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FetchRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FetchRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_input()) { - _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } if (from.offset() != 0) { _internal_set_offset(from._internal_offset()); @@ -5483,14 +5568,14 @@ void FetchRel::MergeFrom(const FetchRel& from) { } void FetchRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FetchRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FetchRel) if (&from == this) return; Clear(); MergeFrom(from); } void FetchRel::CopyFrom(const FetchRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FetchRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FetchRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -5513,8 +5598,8 @@ void FetchRel::InternalSwap(FetchRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata FetchRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[14]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[14]); } // =================================================================== @@ -5523,25 +5608,28 @@ class AggregateRel_Grouping::_Internal { public: }; +void AggregateRel_Grouping::clear_grouping_expressions() { + grouping_expressions_.Clear(); +} AggregateRel_Grouping::AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), - input_fields_(arena) { + grouping_expressions_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.AggregateRel.Grouping) + // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel.Grouping) } AggregateRel_Grouping::AggregateRel_Grouping(const AggregateRel_Grouping& from) : ::PROTOBUF_NAMESPACE_ID::Message(), - input_fields_(from.input_fields_) { + grouping_expressions_(from.grouping_expressions_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:io.substrait.AggregateRel.Grouping) + // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel.Grouping) } void AggregateRel_Grouping::SharedCtor() { } AggregateRel_Grouping::~AggregateRel_Grouping() { - // @@protoc_insertion_point(destructor:io.substrait.AggregateRel.Grouping) + // @@protoc_insertion_point(destructor:substrait.AggregateRel.Grouping) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5561,12 +5649,12 @@ void AggregateRel_Grouping::SetCachedSize(int size) const { } void AggregateRel_Grouping::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.AggregateRel.Grouping) +// @@protoc_insertion_point(message_clear_start:substrait.AggregateRel.Grouping) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - input_fields_.Clear(); + grouping_expressions_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5576,14 +5664,16 @@ const char* AggregateRel_Grouping::_InternalParse(const char* ptr, ::PROTOBUF_NA ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated int32 input_fields = 1; + // repeated .substrait.Expression grouping_expressions = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_input_fields(), ptr, ctx); - CHK_(ptr); - } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8) { - _internal_add_input_fields(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); + ptr -= 1; + do { + ptr += 1; + ptr = ctx->ParseMessage(_internal_add_grouping_expressions(), ptr); + CHK_(ptr); + if (!ctx->DataAvailable(ptr)) break; + } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; default: { @@ -5611,48 +5701,39 @@ const char* AggregateRel_Grouping::_InternalParse(const char* ptr, ::PROTOBUF_NA ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Grouping::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.AggregateRel.Grouping) + // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel.Grouping) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated int32 input_fields = 1; - { - int byte_size = _input_fields_cached_byte_size_.load(std::memory_order_relaxed); - if (byte_size > 0) { - target = stream->WriteInt32Packed( - 1, _internal_input_fields(), byte_size, target); - } + // repeated .substrait.Expression grouping_expressions = 1; + for (unsigned int i = 0, + n = static_cast(this->_internal_grouping_expressions_size()); i < n; i++) { + target = stream->EnsureSpace(target); + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, this->_internal_grouping_expressions(i), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.AggregateRel.Grouping) + // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateRel.Grouping) return target; } size_t AggregateRel_Grouping::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.AggregateRel.Grouping) +// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel.Grouping) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated int32 input_fields = 1; - { - size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - Int32Size(this->input_fields_); - if (data_size > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); - _input_fields_cached_byte_size_.store(cached_size, - std::memory_order_relaxed); - total_size += data_size; + // repeated .substrait.Expression grouping_expressions = 1; + total_size += 1UL * this->_internal_grouping_expressions_size(); + for (const auto& msg : this->grouping_expressions_) { + total_size += + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -5665,39 +5746,39 @@ size_t AggregateRel_Grouping::ByteSizeLong() const { } void AggregateRel_Grouping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.AggregateRel.Grouping) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.AggregateRel.Grouping) GOOGLE_DCHECK_NE(&from, this); const AggregateRel_Grouping* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.AggregateRel.Grouping) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.AggregateRel.Grouping) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.AggregateRel.Grouping) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.AggregateRel.Grouping) MergeFrom(*source); } } void AggregateRel_Grouping::MergeFrom(const AggregateRel_Grouping& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.AggregateRel.Grouping) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel.Grouping) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - input_fields_.MergeFrom(from.input_fields_); + grouping_expressions_.MergeFrom(from.grouping_expressions_); } void AggregateRel_Grouping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.AggregateRel.Grouping) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.AggregateRel.Grouping) if (&from == this) return; Clear(); MergeFrom(from); } void AggregateRel_Grouping::CopyFrom(const AggregateRel_Grouping& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.AggregateRel.Grouping) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateRel.Grouping) if (&from == this) return; Clear(); MergeFrom(from); @@ -5710,28 +5791,28 @@ bool AggregateRel_Grouping::IsInitialized() const { void AggregateRel_Grouping::InternalSwap(AggregateRel_Grouping* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - input_fields_.InternalSwap(&other->input_fields_); + grouping_expressions_.InternalSwap(&other->grouping_expressions_); } ::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Grouping::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[15]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[15]); } // =================================================================== class AggregateRel_Measure::_Internal { public: - static const ::io::substrait::AggregateFunction& measure(const AggregateRel_Measure* msg); - static const ::io::substrait::Expression& filter(const AggregateRel_Measure* msg); + static const ::substrait::AggregateFunction& measure(const AggregateRel_Measure* msg); + static const ::substrait::Expression& filter(const AggregateRel_Measure* msg); }; -const ::io::substrait::AggregateFunction& +const ::substrait::AggregateFunction& AggregateRel_Measure::_Internal::measure(const AggregateRel_Measure* msg) { return *msg->measure_; } -const ::io::substrait::Expression& +const ::substrait::Expression& AggregateRel_Measure::_Internal::filter(const AggregateRel_Measure* msg) { return *msg->filter_; } @@ -5751,22 +5832,22 @@ AggregateRel_Measure::AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.AggregateRel.Measure) + // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel.Measure) } AggregateRel_Measure::AggregateRel_Measure(const AggregateRel_Measure& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_measure()) { - measure_ = new ::io::substrait::AggregateFunction(*from.measure_); + measure_ = new ::substrait::AggregateFunction(*from.measure_); } else { measure_ = nullptr; } if (from._internal_has_filter()) { - filter_ = new ::io::substrait::Expression(*from.filter_); + filter_ = new ::substrait::Expression(*from.filter_); } else { filter_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.AggregateRel.Measure) + // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel.Measure) } void AggregateRel_Measure::SharedCtor() { @@ -5777,7 +5858,7 @@ ::memset(reinterpret_cast(this) + static_cast( } AggregateRel_Measure::~AggregateRel_Measure() { - // @@protoc_insertion_point(destructor:io.substrait.AggregateRel.Measure) + // @@protoc_insertion_point(destructor:substrait.AggregateRel.Measure) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5799,7 +5880,7 @@ void AggregateRel_Measure::SetCachedSize(int size) const { } void AggregateRel_Measure::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.AggregateRel.Measure) +// @@protoc_insertion_point(message_clear_start:substrait.AggregateRel.Measure) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5821,14 +5902,14 @@ const char* AggregateRel_Measure::_InternalParse(const char* ptr, ::PROTOBUF_NAM ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.AggregateFunction measure = 1; + // .substrait.AggregateFunction measure = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_measure(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression filter = 2; + // .substrait.Expression filter = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); @@ -5860,11 +5941,11 @@ const char* AggregateRel_Measure::_InternalParse(const char* ptr, ::PROTOBUF_NAM ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Measure::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.AggregateRel.Measure) + // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel.Measure) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.AggregateFunction measure = 1; + // .substrait.AggregateFunction measure = 1; if (this->has_measure()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5872,7 +5953,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Measure::_InternalSerialize( 1, _Internal::measure(this), target, stream); } - // .io.substrait.Expression filter = 2; + // .substrait.Expression filter = 2; if (this->has_filter()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5884,26 +5965,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Measure::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.AggregateRel.Measure) + // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateRel.Measure) return target; } size_t AggregateRel_Measure::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.AggregateRel.Measure) +// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel.Measure) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.AggregateFunction measure = 1; + // .substrait.AggregateFunction measure = 1; if (this->has_measure()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *measure_); } - // .io.substrait.Expression filter = 2; + // .substrait.Expression filter = 2; if (this->has_filter()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -5920,44 +6001,44 @@ size_t AggregateRel_Measure::ByteSizeLong() const { } void AggregateRel_Measure::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.AggregateRel.Measure) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.AggregateRel.Measure) GOOGLE_DCHECK_NE(&from, this); const AggregateRel_Measure* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.AggregateRel.Measure) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.AggregateRel.Measure) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.AggregateRel.Measure) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.AggregateRel.Measure) MergeFrom(*source); } } void AggregateRel_Measure::MergeFrom(const AggregateRel_Measure& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.AggregateRel.Measure) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel.Measure) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_measure()) { - _internal_mutable_measure()->::io::substrait::AggregateFunction::MergeFrom(from._internal_measure()); + _internal_mutable_measure()->::substrait::AggregateFunction::MergeFrom(from._internal_measure()); } if (from.has_filter()) { - _internal_mutable_filter()->::io::substrait::Expression::MergeFrom(from._internal_filter()); + _internal_mutable_filter()->::substrait::Expression::MergeFrom(from._internal_filter()); } } void AggregateRel_Measure::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.AggregateRel.Measure) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.AggregateRel.Measure) if (&from == this) return; Clear(); MergeFrom(from); } void AggregateRel_Measure::CopyFrom(const AggregateRel_Measure& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.AggregateRel.Measure) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateRel.Measure) if (&from == this) return; Clear(); MergeFrom(from); @@ -5980,28 +6061,28 @@ void AggregateRel_Measure::InternalSwap(AggregateRel_Measure* other) { ::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Measure::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[16]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[16]); } // =================================================================== class AggregateRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const AggregateRel* msg); - static const ::io::substrait::Rel& input(const AggregateRel* msg); - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const AggregateRel* msg); + static const ::substrait::RelCommon& common(const AggregateRel* msg); + static const ::substrait::Rel& input(const AggregateRel* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const AggregateRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& AggregateRel::_Internal::common(const AggregateRel* msg) { return *msg->common_; } -const ::io::substrait::Rel& +const ::substrait::Rel& AggregateRel::_Internal::input(const AggregateRel* msg) { return *msg->input_; } -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& AggregateRel::_Internal::advanced_extension(const AggregateRel* msg) { return *msg->advanced_extension_; } @@ -6017,7 +6098,7 @@ AggregateRel::AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) measures_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.AggregateRel) + // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel) } AggregateRel::AggregateRel(const AggregateRel& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -6025,21 +6106,21 @@ AggregateRel::AggregateRel(const AggregateRel& from) measures_(from.measures_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } if (from._internal_has_input()) { - input_ = new ::io::substrait::Rel(*from.input_); + input_ = new ::substrait::Rel(*from.input_); } else { input_ = nullptr; } if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.AggregateRel) + // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel) } void AggregateRel::SharedCtor() { @@ -6050,7 +6131,7 @@ ::memset(reinterpret_cast(this) + static_cast( } AggregateRel::~AggregateRel() { - // @@protoc_insertion_point(destructor:io.substrait.AggregateRel) + // @@protoc_insertion_point(destructor:substrait.AggregateRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -6073,7 +6154,7 @@ void AggregateRel::SetCachedSize(int size) const { } void AggregateRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.AggregateRel) +// @@protoc_insertion_point(message_clear_start:substrait.AggregateRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6101,21 +6182,21 @@ const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.AggregateRel.Grouping groupings = 3; + // repeated .substrait.AggregateRel.Grouping groupings = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; @@ -6127,7 +6208,7 @@ const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; - // repeated .io.substrait.AggregateRel.Measure measures = 4; + // repeated .substrait.AggregateRel.Measure measures = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr -= 1; @@ -6139,7 +6220,7 @@ const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -6171,11 +6252,11 @@ const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.AggregateRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6183,7 +6264,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6191,7 +6272,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( 2, _Internal::input(this), target, stream); } - // repeated .io.substrait.AggregateRel.Grouping groupings = 3; + // repeated .substrait.AggregateRel.Grouping groupings = 3; for (unsigned int i = 0, n = static_cast(this->_internal_groupings_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -6199,7 +6280,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( InternalWriteMessage(3, this->_internal_groupings(i), target, stream); } - // repeated .io.substrait.AggregateRel.Measure measures = 4; + // repeated .substrait.AggregateRel.Measure measures = 4; for (unsigned int i = 0, n = static_cast(this->_internal_measures_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -6207,7 +6288,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( InternalWriteMessage(4, this->_internal_measures(i), target, stream); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6219,47 +6300,47 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.AggregateRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateRel) return target; } size_t AggregateRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.AggregateRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.AggregateRel.Grouping groupings = 3; + // repeated .substrait.AggregateRel.Grouping groupings = 3; total_size += 1UL * this->_internal_groupings_size(); for (const auto& msg : this->groupings_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // repeated .io.substrait.AggregateRel.Measure measures = 4; + // repeated .substrait.AggregateRel.Measure measures = 4; total_size += 1UL * this->_internal_measures_size(); for (const auto& msg : this->measures_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -6276,22 +6357,22 @@ size_t AggregateRel::ByteSizeLong() const { } void AggregateRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.AggregateRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.AggregateRel) GOOGLE_DCHECK_NE(&from, this); const AggregateRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.AggregateRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.AggregateRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.AggregateRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.AggregateRel) MergeFrom(*source); } } void AggregateRel::MergeFrom(const AggregateRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.AggregateRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -6300,25 +6381,25 @@ void AggregateRel::MergeFrom(const AggregateRel& from) { groupings_.MergeFrom(from.groupings_); measures_.MergeFrom(from.measures_); if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_input()) { - _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } } void AggregateRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.AggregateRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.AggregateRel) if (&from == this) return; Clear(); MergeFrom(from); } void AggregateRel::CopyFrom(const AggregateRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.AggregateRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -6343,28 +6424,28 @@ void AggregateRel::InternalSwap(AggregateRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[17]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[17]); } // =================================================================== class SortRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const SortRel* msg); - static const ::io::substrait::Rel& input(const SortRel* msg); - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const SortRel* msg); + static const ::substrait::RelCommon& common(const SortRel* msg); + static const ::substrait::Rel& input(const SortRel* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const SortRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& SortRel::_Internal::common(const SortRel* msg) { return *msg->common_; } -const ::io::substrait::Rel& +const ::substrait::Rel& SortRel::_Internal::input(const SortRel* msg) { return *msg->input_; } -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& SortRel::_Internal::advanced_extension(const SortRel* msg) { return *msg->advanced_extension_; } @@ -6382,28 +6463,28 @@ SortRel::SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) sorts_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.SortRel) + // @@protoc_insertion_point(arena_constructor:substrait.SortRel) } SortRel::SortRel(const SortRel& from) : ::PROTOBUF_NAMESPACE_ID::Message(), sorts_(from.sorts_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } if (from._internal_has_input()) { - input_ = new ::io::substrait::Rel(*from.input_); + input_ = new ::substrait::Rel(*from.input_); } else { input_ = nullptr; } if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.SortRel) + // @@protoc_insertion_point(copy_constructor:substrait.SortRel) } void SortRel::SharedCtor() { @@ -6414,7 +6495,7 @@ ::memset(reinterpret_cast(this) + static_cast( } SortRel::~SortRel() { - // @@protoc_insertion_point(destructor:io.substrait.SortRel) + // @@protoc_insertion_point(destructor:substrait.SortRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -6437,7 +6518,7 @@ void SortRel::SetCachedSize(int size) const { } void SortRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.SortRel) +// @@protoc_insertion_point(message_clear_start:substrait.SortRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6464,21 +6545,21 @@ const char* SortRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr -= 1; @@ -6490,7 +6571,7 @@ const char* SortRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -6522,11 +6603,11 @@ const char* SortRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.SortRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.SortRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6534,7 +6615,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6542,7 +6623,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( 2, _Internal::input(this), target, stream); } - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; for (unsigned int i = 0, n = static_cast(this->_internal_sorts_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -6550,7 +6631,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( InternalWriteMessage(3, this->_internal_sorts(i), target, stream); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6562,40 +6643,40 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.SortRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.SortRel) return target; } size_t SortRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.SortRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.SortRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; total_size += 1UL * this->_internal_sorts_size(); for (const auto& msg : this->sorts_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -6612,22 +6693,22 @@ size_t SortRel::ByteSizeLong() const { } void SortRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.SortRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.SortRel) GOOGLE_DCHECK_NE(&from, this); const SortRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.SortRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.SortRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.SortRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.SortRel) MergeFrom(*source); } } void SortRel::MergeFrom(const SortRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.SortRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.SortRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -6635,25 +6716,25 @@ void SortRel::MergeFrom(const SortRel& from) { sorts_.MergeFrom(from.sorts_); if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_input()) { - _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } } void SortRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.SortRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.SortRel) if (&from == this) return; Clear(); MergeFrom(from); } void SortRel::CopyFrom(const SortRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.SortRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.SortRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -6677,33 +6758,33 @@ void SortRel::InternalSwap(SortRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata SortRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[18]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[18]); } // =================================================================== class FilterRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const FilterRel* msg); - static const ::io::substrait::Rel& input(const FilterRel* msg); - static const ::io::substrait::Expression& condition(const FilterRel* msg); - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const FilterRel* msg); + static const ::substrait::RelCommon& common(const FilterRel* msg); + static const ::substrait::Rel& input(const FilterRel* msg); + static const ::substrait::Expression& condition(const FilterRel* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const FilterRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& FilterRel::_Internal::common(const FilterRel* msg) { return *msg->common_; } -const ::io::substrait::Rel& +const ::substrait::Rel& FilterRel::_Internal::input(const FilterRel* msg) { return *msg->input_; } -const ::io::substrait::Expression& +const ::substrait::Expression& FilterRel::_Internal::condition(const FilterRel* msg) { return *msg->condition_; } -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& FilterRel::_Internal::advanced_extension(const FilterRel* msg) { return *msg->advanced_extension_; } @@ -6723,32 +6804,32 @@ FilterRel::FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.FilterRel) + // @@protoc_insertion_point(arena_constructor:substrait.FilterRel) } FilterRel::FilterRel(const FilterRel& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } if (from._internal_has_input()) { - input_ = new ::io::substrait::Rel(*from.input_); + input_ = new ::substrait::Rel(*from.input_); } else { input_ = nullptr; } if (from._internal_has_condition()) { - condition_ = new ::io::substrait::Expression(*from.condition_); + condition_ = new ::substrait::Expression(*from.condition_); } else { condition_ = nullptr; } if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.FilterRel) + // @@protoc_insertion_point(copy_constructor:substrait.FilterRel) } void FilterRel::SharedCtor() { @@ -6759,7 +6840,7 @@ ::memset(reinterpret_cast(this) + static_cast( } FilterRel::~FilterRel() { - // @@protoc_insertion_point(destructor:io.substrait.FilterRel) + // @@protoc_insertion_point(destructor:substrait.FilterRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -6783,7 +6864,7 @@ void FilterRel::SetCachedSize(int size) const { } void FilterRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.FilterRel) +// @@protoc_insertion_point(message_clear_start:substrait.FilterRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6813,28 +6894,28 @@ const char* FilterRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Expression condition = 3; + // .substrait.Expression condition = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_condition(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -6866,11 +6947,11 @@ const char* FilterRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.FilterRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.FilterRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6878,7 +6959,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6886,7 +6967,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( 2, _Internal::input(this), target, stream); } - // .io.substrait.Expression condition = 3; + // .substrait.Expression condition = 3; if (this->has_condition()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6894,7 +6975,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( 3, _Internal::condition(this), target, stream); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6906,40 +6987,40 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.FilterRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.FilterRel) return target; } size_t FilterRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.FilterRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.FilterRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } - // .io.substrait.Expression condition = 3; + // .substrait.Expression condition = 3; if (this->has_condition()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *condition_); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -6956,50 +7037,50 @@ size_t FilterRel::ByteSizeLong() const { } void FilterRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.FilterRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.FilterRel) GOOGLE_DCHECK_NE(&from, this); const FilterRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.FilterRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FilterRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.FilterRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FilterRel) MergeFrom(*source); } } void FilterRel::MergeFrom(const FilterRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.FilterRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FilterRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_input()) { - _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } if (from.has_condition()) { - _internal_mutable_condition()->::io::substrait::Expression::MergeFrom(from._internal_condition()); + _internal_mutable_condition()->::substrait::Expression::MergeFrom(from._internal_condition()); } if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } } void FilterRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.FilterRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.FilterRel) if (&from == this) return; Clear(); MergeFrom(from); } void FilterRel::CopyFrom(const FilterRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.FilterRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FilterRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -7022,23 +7103,23 @@ void FilterRel::InternalSwap(FilterRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata FilterRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[19]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[19]); } // =================================================================== class SetRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const SetRel* msg); - static const ::io::substrait::extensions::AdvancedExtension& advanced_extension(const SetRel* msg); + static const ::substrait::RelCommon& common(const SetRel* msg); + static const ::substrait::extensions::AdvancedExtension& advanced_extension(const SetRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& SetRel::_Internal::common(const SetRel* msg) { return *msg->common_; } -const ::io::substrait::extensions::AdvancedExtension& +const ::substrait::extensions::AdvancedExtension& SetRel::_Internal::advanced_extension(const SetRel* msg) { return *msg->advanced_extension_; } @@ -7053,24 +7134,24 @@ SetRel::SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) inputs_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.SetRel) + // @@protoc_insertion_point(arena_constructor:substrait.SetRel) } SetRel::SetRel(const SetRel& from) : ::PROTOBUF_NAMESPACE_ID::Message(), inputs_(from.inputs_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::io::substrait::extensions::AdvancedExtension(*from.advanced_extension_); + advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); } else { advanced_extension_ = nullptr; } op_ = from.op_; - // @@protoc_insertion_point(copy_constructor:io.substrait.SetRel) + // @@protoc_insertion_point(copy_constructor:substrait.SetRel) } void SetRel::SharedCtor() { @@ -7081,7 +7162,7 @@ ::memset(reinterpret_cast(this) + static_cast( } SetRel::~SetRel() { - // @@protoc_insertion_point(destructor:io.substrait.SetRel) + // @@protoc_insertion_point(destructor:substrait.SetRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -7103,7 +7184,7 @@ void SetRel::SetCachedSize(int size) const { } void SetRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.SetRel) +// @@protoc_insertion_point(message_clear_start:substrait.SetRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7127,14 +7208,14 @@ const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::int ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Rel inputs = 2; + // repeated .substrait.Rel inputs = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -7146,15 +7227,15 @@ const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::int } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.SetRel.SetOp op = 3; + // .substrait.SetRel.SetOp op = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_op(static_cast<::io::substrait::SetRel_SetOp>(val)); + _internal_set_op(static_cast<::substrait::SetRel_SetOp>(val)); } else goto handle_unusual; continue; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); @@ -7186,11 +7267,11 @@ const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::int ::PROTOBUF_NAMESPACE_ID::uint8* SetRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.SetRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.SetRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7198,7 +7279,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SetRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // repeated .io.substrait.Rel inputs = 2; + // repeated .substrait.Rel inputs = 2; for (unsigned int i = 0, n = static_cast(this->_internal_inputs_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -7206,14 +7287,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SetRel::_InternalSerialize( InternalWriteMessage(2, this->_internal_inputs(i), target, stream); } - // .io.substrait.SetRel.SetOp op = 3; + // .substrait.SetRel.SetOp op = 3; if (this->op() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_op(), target); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7225,40 +7306,40 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SetRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.SetRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.SetRel) return target; } size_t SetRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.SetRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.SetRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Rel inputs = 2; + // repeated .substrait.Rel inputs = 2; total_size += 1UL * this->_internal_inputs_size(); for (const auto& msg : this->inputs_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; if (this->has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } - // .io.substrait.SetRel.SetOp op = 3; + // .substrait.SetRel.SetOp op = 3; if (this->op() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op()); @@ -7274,22 +7355,22 @@ size_t SetRel::ByteSizeLong() const { } void SetRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.SetRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.SetRel) GOOGLE_DCHECK_NE(&from, this); const SetRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.SetRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.SetRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.SetRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.SetRel) MergeFrom(*source); } } void SetRel::MergeFrom(const SetRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.SetRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.SetRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -7297,10 +7378,10 @@ void SetRel::MergeFrom(const SetRel& from) { inputs_.MergeFrom(from.inputs_); if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_advanced_extension()) { - _internal_mutable_advanced_extension()->::io::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); + _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } if (from.op() != 0) { _internal_set_op(from._internal_op()); @@ -7308,14 +7389,14 @@ void SetRel::MergeFrom(const SetRel& from) { } void SetRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.SetRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.SetRel) if (&from == this) return; Clear(); MergeFrom(from); } void SetRel::CopyFrom(const SetRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.SetRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.SetRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -7339,24 +7420,24 @@ void SetRel::InternalSwap(SetRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata SetRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[20]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[20]); } // =================================================================== class ExtensionSingleRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const ExtensionSingleRel* msg); - static const ::io::substrait::Rel& input(const ExtensionSingleRel* msg); + static const ::substrait::RelCommon& common(const ExtensionSingleRel* msg); + static const ::substrait::Rel& input(const ExtensionSingleRel* msg); static const PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionSingleRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& ExtensionSingleRel::_Internal::common(const ExtensionSingleRel* msg) { return *msg->common_; } -const ::io::substrait::Rel& +const ::substrait::Rel& ExtensionSingleRel::_Internal::input(const ExtensionSingleRel* msg) { return *msg->input_; } @@ -7374,18 +7455,18 @@ ExtensionSingleRel::ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ExtensionSingleRel) + // @@protoc_insertion_point(arena_constructor:substrait.ExtensionSingleRel) } ExtensionSingleRel::ExtensionSingleRel(const ExtensionSingleRel& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } if (from._internal_has_input()) { - input_ = new ::io::substrait::Rel(*from.input_); + input_ = new ::substrait::Rel(*from.input_); } else { input_ = nullptr; } @@ -7394,7 +7475,7 @@ ExtensionSingleRel::ExtensionSingleRel(const ExtensionSingleRel& from) } else { detail_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.ExtensionSingleRel) + // @@protoc_insertion_point(copy_constructor:substrait.ExtensionSingleRel) } void ExtensionSingleRel::SharedCtor() { @@ -7405,7 +7486,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ExtensionSingleRel::~ExtensionSingleRel() { - // @@protoc_insertion_point(destructor:io.substrait.ExtensionSingleRel) + // @@protoc_insertion_point(destructor:substrait.ExtensionSingleRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -7428,7 +7509,7 @@ void ExtensionSingleRel::SetCachedSize(int size) const { } void ExtensionSingleRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ExtensionSingleRel) +// @@protoc_insertion_point(message_clear_start:substrait.ExtensionSingleRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7454,14 +7535,14 @@ const char* ExtensionSingleRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMES ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); @@ -7500,11 +7581,11 @@ const char* ExtensionSingleRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMES ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionSingleRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ExtensionSingleRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionSingleRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7512,7 +7593,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionSingleRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7532,26 +7613,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionSingleRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ExtensionSingleRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ExtensionSingleRel) return target; } size_t ExtensionSingleRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ExtensionSingleRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionSingleRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; if (this->has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -7575,32 +7656,32 @@ size_t ExtensionSingleRel::ByteSizeLong() const { } void ExtensionSingleRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ExtensionSingleRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ExtensionSingleRel) GOOGLE_DCHECK_NE(&from, this); const ExtensionSingleRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ExtensionSingleRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ExtensionSingleRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ExtensionSingleRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ExtensionSingleRel) MergeFrom(*source); } } void ExtensionSingleRel::MergeFrom(const ExtensionSingleRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ExtensionSingleRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionSingleRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_input()) { - _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } if (from.has_detail()) { _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); @@ -7608,14 +7689,14 @@ void ExtensionSingleRel::MergeFrom(const ExtensionSingleRel& from) { } void ExtensionSingleRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ExtensionSingleRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ExtensionSingleRel) if (&from == this) return; Clear(); MergeFrom(from); } void ExtensionSingleRel::CopyFrom(const ExtensionSingleRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ExtensionSingleRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ExtensionSingleRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -7638,19 +7719,19 @@ void ExtensionSingleRel::InternalSwap(ExtensionSingleRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ExtensionSingleRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[21]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[21]); } // =================================================================== class ExtensionLeafRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const ExtensionLeafRel* msg); + static const ::substrait::RelCommon& common(const ExtensionLeafRel* msg); static const PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionLeafRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& ExtensionLeafRel::_Internal::common(const ExtensionLeafRel* msg) { return *msg->common_; } @@ -7668,13 +7749,13 @@ ExtensionLeafRel::ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ExtensionLeafRel) + // @@protoc_insertion_point(arena_constructor:substrait.ExtensionLeafRel) } ExtensionLeafRel::ExtensionLeafRel(const ExtensionLeafRel& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } @@ -7683,7 +7764,7 @@ ExtensionLeafRel::ExtensionLeafRel(const ExtensionLeafRel& from) } else { detail_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.ExtensionLeafRel) + // @@protoc_insertion_point(copy_constructor:substrait.ExtensionLeafRel) } void ExtensionLeafRel::SharedCtor() { @@ -7694,7 +7775,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ExtensionLeafRel::~ExtensionLeafRel() { - // @@protoc_insertion_point(destructor:io.substrait.ExtensionLeafRel) + // @@protoc_insertion_point(destructor:substrait.ExtensionLeafRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -7716,7 +7797,7 @@ void ExtensionLeafRel::SetCachedSize(int size) const { } void ExtensionLeafRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ExtensionLeafRel) +// @@protoc_insertion_point(message_clear_start:substrait.ExtensionLeafRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7738,7 +7819,7 @@ const char* ExtensionLeafRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); @@ -7777,11 +7858,11 @@ const char* ExtensionLeafRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionLeafRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ExtensionLeafRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionLeafRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7801,19 +7882,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionLeafRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ExtensionLeafRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ExtensionLeafRel) return target; } size_t ExtensionLeafRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ExtensionLeafRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionLeafRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -7837,29 +7918,29 @@ size_t ExtensionLeafRel::ByteSizeLong() const { } void ExtensionLeafRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ExtensionLeafRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ExtensionLeafRel) GOOGLE_DCHECK_NE(&from, this); const ExtensionLeafRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ExtensionLeafRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ExtensionLeafRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ExtensionLeafRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ExtensionLeafRel) MergeFrom(*source); } } void ExtensionLeafRel::MergeFrom(const ExtensionLeafRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ExtensionLeafRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionLeafRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_detail()) { _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); @@ -7867,14 +7948,14 @@ void ExtensionLeafRel::MergeFrom(const ExtensionLeafRel& from) { } void ExtensionLeafRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ExtensionLeafRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ExtensionLeafRel) if (&from == this) return; Clear(); MergeFrom(from); } void ExtensionLeafRel::CopyFrom(const ExtensionLeafRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ExtensionLeafRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ExtensionLeafRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -7897,19 +7978,19 @@ void ExtensionLeafRel::InternalSwap(ExtensionLeafRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ExtensionLeafRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[22]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[22]); } // =================================================================== class ExtensionMultiRel::_Internal { public: - static const ::io::substrait::RelCommon& common(const ExtensionMultiRel* msg); + static const ::substrait::RelCommon& common(const ExtensionMultiRel* msg); static const PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionMultiRel* msg); }; -const ::io::substrait::RelCommon& +const ::substrait::RelCommon& ExtensionMultiRel::_Internal::common(const ExtensionMultiRel* msg) { return *msg->common_; } @@ -7928,14 +8009,14 @@ ExtensionMultiRel::ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) inputs_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.ExtensionMultiRel) + // @@protoc_insertion_point(arena_constructor:substrait.ExtensionMultiRel) } ExtensionMultiRel::ExtensionMultiRel(const ExtensionMultiRel& from) : ::PROTOBUF_NAMESPACE_ID::Message(), inputs_(from.inputs_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_common()) { - common_ = new ::io::substrait::RelCommon(*from.common_); + common_ = new ::substrait::RelCommon(*from.common_); } else { common_ = nullptr; } @@ -7944,7 +8025,7 @@ ExtensionMultiRel::ExtensionMultiRel(const ExtensionMultiRel& from) } else { detail_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.ExtensionMultiRel) + // @@protoc_insertion_point(copy_constructor:substrait.ExtensionMultiRel) } void ExtensionMultiRel::SharedCtor() { @@ -7955,7 +8036,7 @@ ::memset(reinterpret_cast(this) + static_cast( } ExtensionMultiRel::~ExtensionMultiRel() { - // @@protoc_insertion_point(destructor:io.substrait.ExtensionMultiRel) + // @@protoc_insertion_point(destructor:substrait.ExtensionMultiRel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -7977,7 +8058,7 @@ void ExtensionMultiRel::SetCachedSize(int size) const { } void ExtensionMultiRel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.ExtensionMultiRel) +// @@protoc_insertion_point(message_clear_start:substrait.ExtensionMultiRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8000,14 +8081,14 @@ const char* ExtensionMultiRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // repeated .io.substrait.Rel inputs = 2; + // repeated .substrait.Rel inputs = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr -= 1; @@ -8051,11 +8132,11 @@ const char* ExtensionMultiRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionMultiRel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.ExtensionMultiRel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionMultiRel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -8063,7 +8144,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionMultiRel::_InternalSerialize( 1, _Internal::common(this), target, stream); } - // repeated .io.substrait.Rel inputs = 2; + // repeated .substrait.Rel inputs = 2; for (unsigned int i = 0, n = static_cast(this->_internal_inputs_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -8083,26 +8164,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionMultiRel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.ExtensionMultiRel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.ExtensionMultiRel) return target; } size_t ExtensionMultiRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.ExtensionMultiRel) +// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionMultiRel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Rel inputs = 2; + // repeated .substrait.Rel inputs = 2; total_size += 1UL * this->_internal_inputs_size(); for (const auto& msg : this->inputs_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; if (this->has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -8126,22 +8207,22 @@ size_t ExtensionMultiRel::ByteSizeLong() const { } void ExtensionMultiRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.ExtensionMultiRel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.ExtensionMultiRel) GOOGLE_DCHECK_NE(&from, this); const ExtensionMultiRel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.ExtensionMultiRel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ExtensionMultiRel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.ExtensionMultiRel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ExtensionMultiRel) MergeFrom(*source); } } void ExtensionMultiRel::MergeFrom(const ExtensionMultiRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.ExtensionMultiRel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionMultiRel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -8149,7 +8230,7 @@ void ExtensionMultiRel::MergeFrom(const ExtensionMultiRel& from) { inputs_.MergeFrom(from.inputs_); if (from.has_common()) { - _internal_mutable_common()->::io::substrait::RelCommon::MergeFrom(from._internal_common()); + _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } if (from.has_detail()) { _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); @@ -8157,14 +8238,14 @@ void ExtensionMultiRel::MergeFrom(const ExtensionMultiRel& from) { } void ExtensionMultiRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.ExtensionMultiRel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.ExtensionMultiRel) if (&from == this) return; Clear(); MergeFrom(from); } void ExtensionMultiRel::CopyFrom(const ExtensionMultiRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.ExtensionMultiRel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ExtensionMultiRel) if (&from == this) return; Clear(); MergeFrom(from); @@ -8188,18 +8269,18 @@ void ExtensionMultiRel::InternalSwap(ExtensionMultiRel* other) { ::PROTOBUF_NAMESPACE_ID::Metadata ExtensionMultiRel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[23]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[23]); } // =================================================================== class RelRoot::_Internal { public: - static const ::io::substrait::Rel& input(const RelRoot* msg); + static const ::substrait::Rel& input(const RelRoot* msg); }; -const ::io::substrait::Rel& +const ::substrait::Rel& RelRoot::_Internal::input(const RelRoot* msg) { return *msg->input_; } @@ -8208,18 +8289,18 @@ RelRoot::RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena) names_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.RelRoot) + // @@protoc_insertion_point(arena_constructor:substrait.RelRoot) } RelRoot::RelRoot(const RelRoot& from) : ::PROTOBUF_NAMESPACE_ID::Message(), names_(from.names_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_input()) { - input_ = new ::io::substrait::Rel(*from.input_); + input_ = new ::substrait::Rel(*from.input_); } else { input_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.RelRoot) + // @@protoc_insertion_point(copy_constructor:substrait.RelRoot) } void RelRoot::SharedCtor() { @@ -8227,7 +8308,7 @@ input_ = nullptr; } RelRoot::~RelRoot() { - // @@protoc_insertion_point(destructor:io.substrait.RelRoot) + // @@protoc_insertion_point(destructor:substrait.RelRoot) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -8248,7 +8329,7 @@ void RelRoot::SetCachedSize(int size) const { } void RelRoot::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.RelRoot) +// @@protoc_insertion_point(message_clear_start:substrait.RelRoot) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8267,7 +8348,7 @@ const char* RelRoot::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Rel input = 1; + // .substrait.Rel input = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); @@ -8282,7 +8363,7 @@ const char* RelRoot::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ptr += 1; auto str = _internal_add_names(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.RelRoot.names")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.RelRoot.names")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); @@ -8313,11 +8394,11 @@ const char* RelRoot::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint8* RelRoot::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.RelRoot) + // @@protoc_insertion_point(serialize_to_array_start:substrait.RelRoot) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Rel input = 1; + // .substrait.Rel input = 1; if (this->has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -8331,7 +8412,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelRoot::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.RelRoot.names"); + "substrait.RelRoot.names"); target = stream->WriteString(2, s, target); } @@ -8339,12 +8420,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelRoot::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.RelRoot) + // @@protoc_insertion_point(serialize_to_array_end:substrait.RelRoot) return target; } size_t RelRoot::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.RelRoot) +// @@protoc_insertion_point(message_byte_size_start:substrait.RelRoot) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -8359,7 +8440,7 @@ size_t RelRoot::ByteSizeLong() const { names_.Get(i)); } - // .io.substrait.Rel input = 1; + // .substrait.Rel input = 1; if (this->has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -8376,22 +8457,22 @@ size_t RelRoot::ByteSizeLong() const { } void RelRoot::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.RelRoot) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelRoot) GOOGLE_DCHECK_NE(&from, this); const RelRoot* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.RelRoot) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelRoot) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.RelRoot) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelRoot) MergeFrom(*source); } } void RelRoot::MergeFrom(const RelRoot& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.RelRoot) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelRoot) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -8399,19 +8480,19 @@ void RelRoot::MergeFrom(const RelRoot& from) { names_.MergeFrom(from.names_); if (from.has_input()) { - _internal_mutable_input()->::io::substrait::Rel::MergeFrom(from._internal_input()); + _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } } void RelRoot::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.RelRoot) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelRoot) if (&from == this) return; Clear(); MergeFrom(from); } void RelRoot::CopyFrom(const RelRoot& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.RelRoot) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelRoot) if (&from == this) return; Clear(); MergeFrom(from); @@ -8430,74 +8511,74 @@ void RelRoot::InternalSwap(RelRoot* other) { ::PROTOBUF_NAMESPACE_ID::Metadata RelRoot::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[24]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[24]); } // =================================================================== class Rel::_Internal { public: - static const ::io::substrait::ReadRel& read(const Rel* msg); - static const ::io::substrait::FilterRel& filter(const Rel* msg); - static const ::io::substrait::FetchRel& fetch(const Rel* msg); - static const ::io::substrait::AggregateRel& aggregate(const Rel* msg); - static const ::io::substrait::SortRel& sort(const Rel* msg); - static const ::io::substrait::JoinRel& join(const Rel* msg); - static const ::io::substrait::ProjectRel& project(const Rel* msg); - static const ::io::substrait::SetRel& set(const Rel* msg); - static const ::io::substrait::ExtensionSingleRel& extension_single(const Rel* msg); - static const ::io::substrait::ExtensionMultiRel& extension_multi(const Rel* msg); - static const ::io::substrait::ExtensionLeafRel& extension_leaf(const Rel* msg); + static const ::substrait::ReadRel& read(const Rel* msg); + static const ::substrait::FilterRel& filter(const Rel* msg); + static const ::substrait::FetchRel& fetch(const Rel* msg); + static const ::substrait::AggregateRel& aggregate(const Rel* msg); + static const ::substrait::SortRel& sort(const Rel* msg); + static const ::substrait::JoinRel& join(const Rel* msg); + static const ::substrait::ProjectRel& project(const Rel* msg); + static const ::substrait::SetRel& set(const Rel* msg); + static const ::substrait::ExtensionSingleRel& extension_single(const Rel* msg); + static const ::substrait::ExtensionMultiRel& extension_multi(const Rel* msg); + static const ::substrait::ExtensionLeafRel& extension_leaf(const Rel* msg); }; -const ::io::substrait::ReadRel& +const ::substrait::ReadRel& Rel::_Internal::read(const Rel* msg) { - return *msg->RelType_.read_; + return *msg->rel_type_.read_; } -const ::io::substrait::FilterRel& +const ::substrait::FilterRel& Rel::_Internal::filter(const Rel* msg) { - return *msg->RelType_.filter_; + return *msg->rel_type_.filter_; } -const ::io::substrait::FetchRel& +const ::substrait::FetchRel& Rel::_Internal::fetch(const Rel* msg) { - return *msg->RelType_.fetch_; + return *msg->rel_type_.fetch_; } -const ::io::substrait::AggregateRel& +const ::substrait::AggregateRel& Rel::_Internal::aggregate(const Rel* msg) { - return *msg->RelType_.aggregate_; + return *msg->rel_type_.aggregate_; } -const ::io::substrait::SortRel& +const ::substrait::SortRel& Rel::_Internal::sort(const Rel* msg) { - return *msg->RelType_.sort_; + return *msg->rel_type_.sort_; } -const ::io::substrait::JoinRel& +const ::substrait::JoinRel& Rel::_Internal::join(const Rel* msg) { - return *msg->RelType_.join_; + return *msg->rel_type_.join_; } -const ::io::substrait::ProjectRel& +const ::substrait::ProjectRel& Rel::_Internal::project(const Rel* msg) { - return *msg->RelType_.project_; + return *msg->rel_type_.project_; } -const ::io::substrait::SetRel& +const ::substrait::SetRel& Rel::_Internal::set(const Rel* msg) { - return *msg->RelType_.set_; + return *msg->rel_type_.set_; } -const ::io::substrait::ExtensionSingleRel& +const ::substrait::ExtensionSingleRel& Rel::_Internal::extension_single(const Rel* msg) { - return *msg->RelType_.extension_single_; + return *msg->rel_type_.extension_single_; } -const ::io::substrait::ExtensionMultiRel& +const ::substrait::ExtensionMultiRel& Rel::_Internal::extension_multi(const Rel* msg) { - return *msg->RelType_.extension_multi_; + return *msg->rel_type_.extension_multi_; } -const ::io::substrait::ExtensionLeafRel& +const ::substrait::ExtensionLeafRel& Rel::_Internal::extension_leaf(const Rel* msg) { - return *msg->RelType_.extension_leaf_; + return *msg->rel_type_.extension_leaf_; } -void Rel::set_allocated_read(::io::substrait::ReadRel* read) { +void Rel::set_allocated_read(::substrait::ReadRel* read) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (read) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(read); @@ -8506,13 +8587,13 @@ void Rel::set_allocated_read(::io::substrait::ReadRel* read) { message_arena, read, submessage_arena); } set_has_read(); - RelType_.read_ = read; + rel_type_.read_ = read; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.read) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.read) } -void Rel::set_allocated_filter(::io::substrait::FilterRel* filter) { +void Rel::set_allocated_filter(::substrait::FilterRel* filter) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (filter) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(filter); @@ -8521,13 +8602,13 @@ void Rel::set_allocated_filter(::io::substrait::FilterRel* filter) { message_arena, filter, submessage_arena); } set_has_filter(); - RelType_.filter_ = filter; + rel_type_.filter_ = filter; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.filter) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.filter) } -void Rel::set_allocated_fetch(::io::substrait::FetchRel* fetch) { +void Rel::set_allocated_fetch(::substrait::FetchRel* fetch) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (fetch) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fetch); @@ -8536,13 +8617,13 @@ void Rel::set_allocated_fetch(::io::substrait::FetchRel* fetch) { message_arena, fetch, submessage_arena); } set_has_fetch(); - RelType_.fetch_ = fetch; + rel_type_.fetch_ = fetch; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.fetch) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.fetch) } -void Rel::set_allocated_aggregate(::io::substrait::AggregateRel* aggregate) { +void Rel::set_allocated_aggregate(::substrait::AggregateRel* aggregate) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (aggregate) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(aggregate); @@ -8551,13 +8632,13 @@ void Rel::set_allocated_aggregate(::io::substrait::AggregateRel* aggregate) { message_arena, aggregate, submessage_arena); } set_has_aggregate(); - RelType_.aggregate_ = aggregate; + rel_type_.aggregate_ = aggregate; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.aggregate) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.aggregate) } -void Rel::set_allocated_sort(::io::substrait::SortRel* sort) { +void Rel::set_allocated_sort(::substrait::SortRel* sort) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (sort) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sort); @@ -8566,13 +8647,13 @@ void Rel::set_allocated_sort(::io::substrait::SortRel* sort) { message_arena, sort, submessage_arena); } set_has_sort(); - RelType_.sort_ = sort; + rel_type_.sort_ = sort; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.sort) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.sort) } -void Rel::set_allocated_join(::io::substrait::JoinRel* join) { +void Rel::set_allocated_join(::substrait::JoinRel* join) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (join) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(join); @@ -8581,13 +8662,13 @@ void Rel::set_allocated_join(::io::substrait::JoinRel* join) { message_arena, join, submessage_arena); } set_has_join(); - RelType_.join_ = join; + rel_type_.join_ = join; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.join) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.join) } -void Rel::set_allocated_project(::io::substrait::ProjectRel* project) { +void Rel::set_allocated_project(::substrait::ProjectRel* project) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (project) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(project); @@ -8596,13 +8677,13 @@ void Rel::set_allocated_project(::io::substrait::ProjectRel* project) { message_arena, project, submessage_arena); } set_has_project(); - RelType_.project_ = project; + rel_type_.project_ = project; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.project) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.project) } -void Rel::set_allocated_set(::io::substrait::SetRel* set) { +void Rel::set_allocated_set(::substrait::SetRel* set) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (set) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(set); @@ -8611,13 +8692,13 @@ void Rel::set_allocated_set(::io::substrait::SetRel* set) { message_arena, set, submessage_arena); } set_has_set(); - RelType_.set_ = set; + rel_type_.set_ = set; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.set) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.set) } -void Rel::set_allocated_extension_single(::io::substrait::ExtensionSingleRel* extension_single) { +void Rel::set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (extension_single) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_single); @@ -8626,13 +8707,13 @@ void Rel::set_allocated_extension_single(::io::substrait::ExtensionSingleRel* ex message_arena, extension_single, submessage_arena); } set_has_extension_single(); - RelType_.extension_single_ = extension_single; + rel_type_.extension_single_ = extension_single; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.extension_single) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_single) } -void Rel::set_allocated_extension_multi(::io::substrait::ExtensionMultiRel* extension_multi) { +void Rel::set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (extension_multi) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_multi); @@ -8641,13 +8722,13 @@ void Rel::set_allocated_extension_multi(::io::substrait::ExtensionMultiRel* exte message_arena, extension_multi, submessage_arena); } set_has_extension_multi(); - RelType_.extension_multi_ = extension_multi; + rel_type_.extension_multi_ = extension_multi; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.extension_multi) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_multi) } -void Rel::set_allocated_extension_leaf(::io::substrait::ExtensionLeafRel* extension_leaf) { +void Rel::set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_RelType(); + clear_rel_type(); if (extension_leaf) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_leaf); @@ -8656,86 +8737,86 @@ void Rel::set_allocated_extension_leaf(::io::substrait::ExtensionLeafRel* extens message_arena, extension_leaf, submessage_arena); } set_has_extension_leaf(); - RelType_.extension_leaf_ = extension_leaf; + rel_type_.extension_leaf_ = extension_leaf; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Rel.extension_leaf) + // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_leaf) } Rel::Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Rel) + // @@protoc_insertion_point(arena_constructor:substrait.Rel) } Rel::Rel(const Rel& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_RelType(); - switch (from.RelType_case()) { + clear_has_rel_type(); + switch (from.rel_type_case()) { case kRead: { - _internal_mutable_read()->::io::substrait::ReadRel::MergeFrom(from._internal_read()); + _internal_mutable_read()->::substrait::ReadRel::MergeFrom(from._internal_read()); break; } case kFilter: { - _internal_mutable_filter()->::io::substrait::FilterRel::MergeFrom(from._internal_filter()); + _internal_mutable_filter()->::substrait::FilterRel::MergeFrom(from._internal_filter()); break; } case kFetch: { - _internal_mutable_fetch()->::io::substrait::FetchRel::MergeFrom(from._internal_fetch()); + _internal_mutable_fetch()->::substrait::FetchRel::MergeFrom(from._internal_fetch()); break; } case kAggregate: { - _internal_mutable_aggregate()->::io::substrait::AggregateRel::MergeFrom(from._internal_aggregate()); + _internal_mutable_aggregate()->::substrait::AggregateRel::MergeFrom(from._internal_aggregate()); break; } case kSort: { - _internal_mutable_sort()->::io::substrait::SortRel::MergeFrom(from._internal_sort()); + _internal_mutable_sort()->::substrait::SortRel::MergeFrom(from._internal_sort()); break; } case kJoin: { - _internal_mutable_join()->::io::substrait::JoinRel::MergeFrom(from._internal_join()); + _internal_mutable_join()->::substrait::JoinRel::MergeFrom(from._internal_join()); break; } case kProject: { - _internal_mutable_project()->::io::substrait::ProjectRel::MergeFrom(from._internal_project()); + _internal_mutable_project()->::substrait::ProjectRel::MergeFrom(from._internal_project()); break; } case kSet: { - _internal_mutable_set()->::io::substrait::SetRel::MergeFrom(from._internal_set()); + _internal_mutable_set()->::substrait::SetRel::MergeFrom(from._internal_set()); break; } case kExtensionSingle: { - _internal_mutable_extension_single()->::io::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single()); + _internal_mutable_extension_single()->::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single()); break; } case kExtensionMulti: { - _internal_mutable_extension_multi()->::io::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi()); + _internal_mutable_extension_multi()->::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi()); break; } case kExtensionLeaf: { - _internal_mutable_extension_leaf()->::io::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf()); + _internal_mutable_extension_leaf()->::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf()); break; } - case RELTYPE_NOT_SET: { + case REL_TYPE_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Rel) + // @@protoc_insertion_point(copy_constructor:substrait.Rel) } void Rel::SharedCtor() { -clear_has_RelType(); +clear_has_rel_type(); } Rel::~Rel() { - // @@protoc_insertion_point(destructor:io.substrait.Rel) + // @@protoc_insertion_point(destructor:substrait.Rel) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void Rel::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (has_RelType()) { - clear_RelType(); + if (has_rel_type()) { + clear_rel_type(); } } @@ -8749,90 +8830,90 @@ void Rel::SetCachedSize(int size) const { _cached_size_.Set(size); } -void Rel::clear_RelType() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Rel) - switch (RelType_case()) { +void Rel::clear_rel_type() { +// @@protoc_insertion_point(one_of_clear_start:substrait.Rel) + switch (rel_type_case()) { case kRead: { if (GetArena() == nullptr) { - delete RelType_.read_; + delete rel_type_.read_; } break; } case kFilter: { if (GetArena() == nullptr) { - delete RelType_.filter_; + delete rel_type_.filter_; } break; } case kFetch: { if (GetArena() == nullptr) { - delete RelType_.fetch_; + delete rel_type_.fetch_; } break; } case kAggregate: { if (GetArena() == nullptr) { - delete RelType_.aggregate_; + delete rel_type_.aggregate_; } break; } case kSort: { if (GetArena() == nullptr) { - delete RelType_.sort_; + delete rel_type_.sort_; } break; } case kJoin: { if (GetArena() == nullptr) { - delete RelType_.join_; + delete rel_type_.join_; } break; } case kProject: { if (GetArena() == nullptr) { - delete RelType_.project_; + delete rel_type_.project_; } break; } case kSet: { if (GetArena() == nullptr) { - delete RelType_.set_; + delete rel_type_.set_; } break; } case kExtensionSingle: { if (GetArena() == nullptr) { - delete RelType_.extension_single_; + delete rel_type_.extension_single_; } break; } case kExtensionMulti: { if (GetArena() == nullptr) { - delete RelType_.extension_multi_; + delete rel_type_.extension_multi_; } break; } case kExtensionLeaf: { if (GetArena() == nullptr) { - delete RelType_.extension_leaf_; + delete rel_type_.extension_leaf_; } break; } - case RELTYPE_NOT_SET: { + case REL_TYPE_NOT_SET: { break; } } - _oneof_case_[0] = RELTYPE_NOT_SET; + _oneof_case_[0] = REL_TYPE_NOT_SET; } void Rel::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Rel) +// @@protoc_insertion_point(message_clear_start:substrait.Rel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - clear_RelType(); + clear_rel_type(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -8842,77 +8923,77 @@ const char* Rel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::intern ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.ReadRel read = 1; + // .substrait.ReadRel read = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_read(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FilterRel filter = 2; + // .substrait.FilterRel filter = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.FetchRel fetch = 3; + // .substrait.FetchRel fetch = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_fetch(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.AggregateRel aggregate = 4; + // .substrait.AggregateRel aggregate = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_aggregate(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.SortRel sort = 5; + // .substrait.SortRel sort = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_sort(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.JoinRel join = 6; + // .substrait.JoinRel join = 6; case 6: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_join(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ProjectRel project = 7; + // .substrait.ProjectRel project = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_project(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.SetRel set = 8; + // .substrait.SetRel set = 8; case 8: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { ptr = ctx->ParseMessage(_internal_mutable_set(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ExtensionSingleRel extension_single = 9; + // .substrait.ExtensionSingleRel extension_single = 9; case 9: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_extension_single(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ExtensionMultiRel extension_multi = 10; + // .substrait.ExtensionMultiRel extension_multi = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_extension_multi(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.ExtensionLeafRel extension_leaf = 11; + // .substrait.ExtensionLeafRel extension_leaf = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_extension_leaf(), ptr); @@ -8944,11 +9025,11 @@ const char* Rel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::intern ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Rel) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Rel) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.ReadRel read = 1; + // .substrait.ReadRel read = 1; if (_internal_has_read()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -8956,7 +9037,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 1, _Internal::read(this), target, stream); } - // .io.substrait.FilterRel filter = 2; + // .substrait.FilterRel filter = 2; if (_internal_has_filter()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -8964,7 +9045,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 2, _Internal::filter(this), target, stream); } - // .io.substrait.FetchRel fetch = 3; + // .substrait.FetchRel fetch = 3; if (_internal_has_fetch()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -8972,7 +9053,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 3, _Internal::fetch(this), target, stream); } - // .io.substrait.AggregateRel aggregate = 4; + // .substrait.AggregateRel aggregate = 4; if (_internal_has_aggregate()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -8980,7 +9061,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 4, _Internal::aggregate(this), target, stream); } - // .io.substrait.SortRel sort = 5; + // .substrait.SortRel sort = 5; if (_internal_has_sort()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -8988,7 +9069,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 5, _Internal::sort(this), target, stream); } - // .io.substrait.JoinRel join = 6; + // .substrait.JoinRel join = 6; if (_internal_has_join()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -8996,7 +9077,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 6, _Internal::join(this), target, stream); } - // .io.substrait.ProjectRel project = 7; + // .substrait.ProjectRel project = 7; if (_internal_has_project()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9004,7 +9085,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 7, _Internal::project(this), target, stream); } - // .io.substrait.SetRel set = 8; + // .substrait.SetRel set = 8; if (_internal_has_set()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9012,7 +9093,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 8, _Internal::set(this), target, stream); } - // .io.substrait.ExtensionSingleRel extension_single = 9; + // .substrait.ExtensionSingleRel extension_single = 9; if (_internal_has_extension_single()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9020,7 +9101,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 9, _Internal::extension_single(this), target, stream); } - // .io.substrait.ExtensionMultiRel extension_multi = 10; + // .substrait.ExtensionMultiRel extension_multi = 10; if (_internal_has_extension_multi()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9028,7 +9109,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( 10, _Internal::extension_multi(this), target, stream); } - // .io.substrait.ExtensionLeafRel extension_leaf = 11; + // .substrait.ExtensionLeafRel extension_leaf = 11; if (_internal_has_extension_leaf()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -9040,97 +9121,97 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Rel) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Rel) return target; } size_t Rel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Rel) +// @@protoc_insertion_point(message_byte_size_start:substrait.Rel) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - switch (RelType_case()) { - // .io.substrait.ReadRel read = 1; + switch (rel_type_case()) { + // .substrait.ReadRel read = 1; case kRead: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.read_); + *rel_type_.read_); break; } - // .io.substrait.FilterRel filter = 2; + // .substrait.FilterRel filter = 2; case kFilter: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.filter_); + *rel_type_.filter_); break; } - // .io.substrait.FetchRel fetch = 3; + // .substrait.FetchRel fetch = 3; case kFetch: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.fetch_); + *rel_type_.fetch_); break; } - // .io.substrait.AggregateRel aggregate = 4; + // .substrait.AggregateRel aggregate = 4; case kAggregate: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.aggregate_); + *rel_type_.aggregate_); break; } - // .io.substrait.SortRel sort = 5; + // .substrait.SortRel sort = 5; case kSort: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.sort_); + *rel_type_.sort_); break; } - // .io.substrait.JoinRel join = 6; + // .substrait.JoinRel join = 6; case kJoin: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.join_); + *rel_type_.join_); break; } - // .io.substrait.ProjectRel project = 7; + // .substrait.ProjectRel project = 7; case kProject: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.project_); + *rel_type_.project_); break; } - // .io.substrait.SetRel set = 8; + // .substrait.SetRel set = 8; case kSet: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.set_); + *rel_type_.set_); break; } - // .io.substrait.ExtensionSingleRel extension_single = 9; + // .substrait.ExtensionSingleRel extension_single = 9; case kExtensionSingle: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.extension_single_); + *rel_type_.extension_single_); break; } - // .io.substrait.ExtensionMultiRel extension_multi = 10; + // .substrait.ExtensionMultiRel extension_multi = 10; case kExtensionMulti: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.extension_multi_); + *rel_type_.extension_multi_); break; } - // .io.substrait.ExtensionLeafRel extension_leaf = 11; + // .substrait.ExtensionLeafRel extension_leaf = 11; case kExtensionLeaf: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *RelType_.extension_leaf_); + *rel_type_.extension_leaf_); break; } - case RELTYPE_NOT_SET: { + case REL_TYPE_NOT_SET: { break; } } @@ -9144,87 +9225,87 @@ size_t Rel::ByteSizeLong() const { } void Rel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Rel) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Rel) GOOGLE_DCHECK_NE(&from, this); const Rel* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Rel) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Rel) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Rel) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Rel) MergeFrom(*source); } } void Rel::MergeFrom(const Rel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Rel) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Rel) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - switch (from.RelType_case()) { + switch (from.rel_type_case()) { case kRead: { - _internal_mutable_read()->::io::substrait::ReadRel::MergeFrom(from._internal_read()); + _internal_mutable_read()->::substrait::ReadRel::MergeFrom(from._internal_read()); break; } case kFilter: { - _internal_mutable_filter()->::io::substrait::FilterRel::MergeFrom(from._internal_filter()); + _internal_mutable_filter()->::substrait::FilterRel::MergeFrom(from._internal_filter()); break; } case kFetch: { - _internal_mutable_fetch()->::io::substrait::FetchRel::MergeFrom(from._internal_fetch()); + _internal_mutable_fetch()->::substrait::FetchRel::MergeFrom(from._internal_fetch()); break; } case kAggregate: { - _internal_mutable_aggregate()->::io::substrait::AggregateRel::MergeFrom(from._internal_aggregate()); + _internal_mutable_aggregate()->::substrait::AggregateRel::MergeFrom(from._internal_aggregate()); break; } case kSort: { - _internal_mutable_sort()->::io::substrait::SortRel::MergeFrom(from._internal_sort()); + _internal_mutable_sort()->::substrait::SortRel::MergeFrom(from._internal_sort()); break; } case kJoin: { - _internal_mutable_join()->::io::substrait::JoinRel::MergeFrom(from._internal_join()); + _internal_mutable_join()->::substrait::JoinRel::MergeFrom(from._internal_join()); break; } case kProject: { - _internal_mutable_project()->::io::substrait::ProjectRel::MergeFrom(from._internal_project()); + _internal_mutable_project()->::substrait::ProjectRel::MergeFrom(from._internal_project()); break; } case kSet: { - _internal_mutable_set()->::io::substrait::SetRel::MergeFrom(from._internal_set()); + _internal_mutable_set()->::substrait::SetRel::MergeFrom(from._internal_set()); break; } case kExtensionSingle: { - _internal_mutable_extension_single()->::io::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single()); + _internal_mutable_extension_single()->::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single()); break; } case kExtensionMulti: { - _internal_mutable_extension_multi()->::io::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi()); + _internal_mutable_extension_multi()->::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi()); break; } case kExtensionLeaf: { - _internal_mutable_extension_leaf()->::io::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf()); + _internal_mutable_extension_leaf()->::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf()); break; } - case RELTYPE_NOT_SET: { + case REL_TYPE_NOT_SET: { break; } } } void Rel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Rel) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Rel) if (&from == this) return; Clear(); MergeFrom(from); } void Rel::CopyFrom(const Rel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Rel) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Rel) if (&from == this) return; Clear(); MergeFrom(from); @@ -9237,97 +9318,96 @@ bool Rel::IsInitialized() const { void Rel::InternalSwap(Rel* other) { using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(RelType_, other->RelType_); + swap(rel_type_, other->rel_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } ::PROTOBUF_NAMESPACE_ID::Metadata Rel::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_relations_2eproto_getter, &descriptor_table_relations_2eproto_once, - file_level_metadata_relations_2eproto[25]); + &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, + file_level_metadata_substrait_2frelations_2eproto[25]); } // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Direct* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Direct >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Direct >(arena); +template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Direct* Arena::CreateMaybeMessage< ::substrait::RelCommon_Direct >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::RelCommon_Direct >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Emit* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Emit >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Emit >(arena); +template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Emit* Arena::CreateMaybeMessage< ::substrait::RelCommon_Emit >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::RelCommon_Emit >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Hint_Stats >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Hint_Stats >(arena); +template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint_Stats >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint_Stats >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Hint_RuntimeConstraint >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Hint_RuntimeConstraint >(arena); +template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint_RuntimeConstraint >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint_RuntimeConstraint >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon_Hint* Arena::CreateMaybeMessage< ::io::substrait::RelCommon_Hint >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::RelCommon_Hint >(arena); +template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::RelCommon* Arena::CreateMaybeMessage< ::io::substrait::RelCommon >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::RelCommon >(arena); +template<> PROTOBUF_NOINLINE ::substrait::RelCommon* Arena::CreateMaybeMessage< ::substrait::RelCommon >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::RelCommon >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_NamedTable >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReadRel_NamedTable >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_NamedTable >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ReadRel_NamedTable >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_VirtualTable >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReadRel_VirtualTable >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_VirtualTable >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ReadRel_VirtualTable >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_ExtensionTable >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReadRel_ExtensionTable >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_ExtensionTable >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ReadRel_ExtensionTable >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage< ::substrait::ReadRel_LocalFiles_FileOrFiles >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ReadRel_LocalFiles_FileOrFiles >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage< ::io::substrait::ReadRel_LocalFiles >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReadRel_LocalFiles >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage< ::substrait::ReadRel_LocalFiles >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ReadRel_LocalFiles >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ReadRel* Arena::CreateMaybeMessage< ::io::substrait::ReadRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ReadRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ReadRel* Arena::CreateMaybeMessage< ::substrait::ReadRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ReadRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ProjectRel* Arena::CreateMaybeMessage< ::io::substrait::ProjectRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ProjectRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ProjectRel* Arena::CreateMaybeMessage< ::substrait::ProjectRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ProjectRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::JoinRel* Arena::CreateMaybeMessage< ::io::substrait::JoinRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::JoinRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::JoinRel* Arena::CreateMaybeMessage< ::substrait::JoinRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::JoinRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FetchRel* Arena::CreateMaybeMessage< ::io::substrait::FetchRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FetchRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FetchRel* Arena::CreateMaybeMessage< ::substrait::FetchRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FetchRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage< ::io::substrait::AggregateRel_Grouping >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::AggregateRel_Grouping >(arena); +template<> PROTOBUF_NOINLINE ::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage< ::substrait::AggregateRel_Grouping >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::AggregateRel_Grouping >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage< ::io::substrait::AggregateRel_Measure >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::AggregateRel_Measure >(arena); +template<> PROTOBUF_NOINLINE ::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage< ::substrait::AggregateRel_Measure >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::AggregateRel_Measure >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::AggregateRel* Arena::CreateMaybeMessage< ::io::substrait::AggregateRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::AggregateRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::AggregateRel* Arena::CreateMaybeMessage< ::substrait::AggregateRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::AggregateRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::SortRel* Arena::CreateMaybeMessage< ::io::substrait::SortRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::SortRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::SortRel* Arena::CreateMaybeMessage< ::substrait::SortRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::SortRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::FilterRel* Arena::CreateMaybeMessage< ::io::substrait::FilterRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::FilterRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::FilterRel* Arena::CreateMaybeMessage< ::substrait::FilterRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::FilterRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::SetRel* Arena::CreateMaybeMessage< ::io::substrait::SetRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::SetRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::SetRel* Arena::CreateMaybeMessage< ::substrait::SetRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::SetRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage< ::io::substrait::ExtensionSingleRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ExtensionSingleRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage< ::substrait::ExtensionSingleRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ExtensionSingleRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage< ::io::substrait::ExtensionLeafRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ExtensionLeafRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage< ::substrait::ExtensionLeafRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ExtensionLeafRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage< ::io::substrait::ExtensionMultiRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::ExtensionMultiRel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage< ::substrait::ExtensionMultiRel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::ExtensionMultiRel >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::RelRoot* Arena::CreateMaybeMessage< ::io::substrait::RelRoot >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::RelRoot >(arena); +template<> PROTOBUF_NOINLINE ::substrait::RelRoot* Arena::CreateMaybeMessage< ::substrait::RelRoot >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::RelRoot >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Rel* Arena::CreateMaybeMessage< ::io::substrait::Rel >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Rel >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Rel* Arena::CreateMaybeMessage< ::substrait::Rel >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Rel >(arena); } PROTOBUF_NAMESPACE_CLOSE diff --git a/cpp/src/generated/substrait/relations.pb.h b/cpp/src/generated/substrait/relations.pb.h index 2f803d7f678..8128e2999dc 100644 --- a/cpp/src/generated/substrait/relations.pb.h +++ b/cpp/src/generated/substrait/relations.pb.h @@ -1,8 +1,8 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: relations.proto +// source: substrait/relations.proto -#ifndef GOOGLE_PROTOBUF_INCLUDED_relations_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_relations_2eproto +#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2frelations_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_substrait_2frelations_2eproto #include #include @@ -32,13 +32,13 @@ #include // IWYU pragma: export #include #include -#include "type.pb.h" -#include "expression.pb.h" -#include "extensions.pb.h" +#include "substrait/type.pb.h" +#include "substrait/expression.pb.h" +#include "substrait/extensions/extensions.pb.h" #include // @@protoc_insertion_point(includes) #include -#define PROTOBUF_INTERNAL_EXPORT_relations_2eproto +#define PROTOBUF_INTERNAL_EXPORT_substrait_2frelations_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; @@ -46,7 +46,7 @@ class AnyMetadata; PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. -struct TableStruct_relations_2eproto { +struct TableStruct_substrait_2frelations_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] @@ -57,8 +57,7 @@ struct TableStruct_relations_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; }; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_relations_2eproto; -namespace io { +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2frelations_2eproto; namespace substrait { class AggregateRel; struct AggregateRelDefaultTypeInternal; @@ -139,77 +138,75 @@ class SortRel; struct SortRelDefaultTypeInternal; extern SortRelDefaultTypeInternal _SortRel_default_instance_; } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::AggregateRel* Arena::CreateMaybeMessage<::io::substrait::AggregateRel>(Arena*); -template<> ::io::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage<::io::substrait::AggregateRel_Grouping>(Arena*); -template<> ::io::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage<::io::substrait::AggregateRel_Measure>(Arena*); -template<> ::io::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage<::io::substrait::ExtensionLeafRel>(Arena*); -template<> ::io::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage<::io::substrait::ExtensionMultiRel>(Arena*); -template<> ::io::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage<::io::substrait::ExtensionSingleRel>(Arena*); -template<> ::io::substrait::FetchRel* Arena::CreateMaybeMessage<::io::substrait::FetchRel>(Arena*); -template<> ::io::substrait::FilterRel* Arena::CreateMaybeMessage<::io::substrait::FilterRel>(Arena*); -template<> ::io::substrait::JoinRel* Arena::CreateMaybeMessage<::io::substrait::JoinRel>(Arena*); -template<> ::io::substrait::ProjectRel* Arena::CreateMaybeMessage<::io::substrait::ProjectRel>(Arena*); -template<> ::io::substrait::ReadRel* Arena::CreateMaybeMessage<::io::substrait::ReadRel>(Arena*); -template<> ::io::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage<::io::substrait::ReadRel_ExtensionTable>(Arena*); -template<> ::io::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage<::io::substrait::ReadRel_LocalFiles>(Arena*); -template<> ::io::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage<::io::substrait::ReadRel_LocalFiles_FileOrFiles>(Arena*); -template<> ::io::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage<::io::substrait::ReadRel_NamedTable>(Arena*); -template<> ::io::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage<::io::substrait::ReadRel_VirtualTable>(Arena*); -template<> ::io::substrait::Rel* Arena::CreateMaybeMessage<::io::substrait::Rel>(Arena*); -template<> ::io::substrait::RelCommon* Arena::CreateMaybeMessage<::io::substrait::RelCommon>(Arena*); -template<> ::io::substrait::RelCommon_Direct* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Direct>(Arena*); -template<> ::io::substrait::RelCommon_Emit* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Emit>(Arena*); -template<> ::io::substrait::RelCommon_Hint* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Hint>(Arena*); -template<> ::io::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Hint_RuntimeConstraint>(Arena*); -template<> ::io::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage<::io::substrait::RelCommon_Hint_Stats>(Arena*); -template<> ::io::substrait::RelRoot* Arena::CreateMaybeMessage<::io::substrait::RelRoot>(Arena*); -template<> ::io::substrait::SetRel* Arena::CreateMaybeMessage<::io::substrait::SetRel>(Arena*); -template<> ::io::substrait::SortRel* Arena::CreateMaybeMessage<::io::substrait::SortRel>(Arena*); +template<> ::substrait::AggregateRel* Arena::CreateMaybeMessage<::substrait::AggregateRel>(Arena*); +template<> ::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage<::substrait::AggregateRel_Grouping>(Arena*); +template<> ::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage<::substrait::AggregateRel_Measure>(Arena*); +template<> ::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage<::substrait::ExtensionLeafRel>(Arena*); +template<> ::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage<::substrait::ExtensionMultiRel>(Arena*); +template<> ::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage<::substrait::ExtensionSingleRel>(Arena*); +template<> ::substrait::FetchRel* Arena::CreateMaybeMessage<::substrait::FetchRel>(Arena*); +template<> ::substrait::FilterRel* Arena::CreateMaybeMessage<::substrait::FilterRel>(Arena*); +template<> ::substrait::JoinRel* Arena::CreateMaybeMessage<::substrait::JoinRel>(Arena*); +template<> ::substrait::ProjectRel* Arena::CreateMaybeMessage<::substrait::ProjectRel>(Arena*); +template<> ::substrait::ReadRel* Arena::CreateMaybeMessage<::substrait::ReadRel>(Arena*); +template<> ::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage<::substrait::ReadRel_ExtensionTable>(Arena*); +template<> ::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage<::substrait::ReadRel_LocalFiles>(Arena*); +template<> ::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage<::substrait::ReadRel_LocalFiles_FileOrFiles>(Arena*); +template<> ::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage<::substrait::ReadRel_NamedTable>(Arena*); +template<> ::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage<::substrait::ReadRel_VirtualTable>(Arena*); +template<> ::substrait::Rel* Arena::CreateMaybeMessage<::substrait::Rel>(Arena*); +template<> ::substrait::RelCommon* Arena::CreateMaybeMessage<::substrait::RelCommon>(Arena*); +template<> ::substrait::RelCommon_Direct* Arena::CreateMaybeMessage<::substrait::RelCommon_Direct>(Arena*); +template<> ::substrait::RelCommon_Emit* Arena::CreateMaybeMessage<::substrait::RelCommon_Emit>(Arena*); +template<> ::substrait::RelCommon_Hint* Arena::CreateMaybeMessage<::substrait::RelCommon_Hint>(Arena*); +template<> ::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage<::substrait::RelCommon_Hint_RuntimeConstraint>(Arena*); +template<> ::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage<::substrait::RelCommon_Hint_Stats>(Arena*); +template<> ::substrait::RelRoot* Arena::CreateMaybeMessage<::substrait::RelRoot>(Arena*); +template<> ::substrait::SetRel* Arena::CreateMaybeMessage<::substrait::SetRel>(Arena*); +template<> ::substrait::SortRel* Arena::CreateMaybeMessage<::substrait::SortRel>(Arena*); PROTOBUF_NAMESPACE_CLOSE -namespace io { namespace substrait { -enum ReadRel_LocalFiles_FileOrFiles_Format : int { - ReadRel_LocalFiles_FileOrFiles_Format_UNKNOWN = 0, - ReadRel_LocalFiles_FileOrFiles_Format_PARQUET = 1, - ReadRel_LocalFiles_FileOrFiles_Format_ReadRel_LocalFiles_FileOrFiles_Format_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - ReadRel_LocalFiles_FileOrFiles_Format_ReadRel_LocalFiles_FileOrFiles_Format_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +enum ReadRel_LocalFiles_FileOrFiles_FileFormat : int { + ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED = 0, + ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_PARQUET = 1, + ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; -bool ReadRel_LocalFiles_FileOrFiles_Format_IsValid(int value); -constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles_Format_Format_MIN = ReadRel_LocalFiles_FileOrFiles_Format_UNKNOWN; -constexpr ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles_Format_Format_MAX = ReadRel_LocalFiles_FileOrFiles_Format_PARQUET; -constexpr int ReadRel_LocalFiles_FileOrFiles_Format_Format_ARRAYSIZE = ReadRel_LocalFiles_FileOrFiles_Format_Format_MAX + 1; +bool ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(int value); +constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MIN = ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED; +constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MAX = ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_PARQUET; +constexpr int ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_ARRAYSIZE = ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MAX + 1; -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_Format_descriptor(); +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(); template -inline const std::string& ReadRel_LocalFiles_FileOrFiles_Format_Name(T enum_t_value) { - static_assert(::std::is_same::value || +inline const std::string& ReadRel_LocalFiles_FileOrFiles_FileFormat_Name(T enum_t_value) { + static_assert(::std::is_same::value || ::std::is_integral::value, - "Incorrect type passed to function ReadRel_LocalFiles_FileOrFiles_Format_Name."); + "Incorrect type passed to function ReadRel_LocalFiles_FileOrFiles_FileFormat_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ReadRel_LocalFiles_FileOrFiles_Format_descriptor(), enum_t_value); + ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(), enum_t_value); } -inline bool ReadRel_LocalFiles_FileOrFiles_Format_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReadRel_LocalFiles_FileOrFiles_Format* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ReadRel_LocalFiles_FileOrFiles_Format_descriptor(), name, value); +inline bool ReadRel_LocalFiles_FileOrFiles_FileFormat_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReadRel_LocalFiles_FileOrFiles_FileFormat* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(), name, value); } enum JoinRel_JoinType : int { - JoinRel_JoinType_UNKNOWN = 0, - JoinRel_JoinType_INNER = 1, - JoinRel_JoinType_OUTER = 2, - JoinRel_JoinType_LEFT = 3, - JoinRel_JoinType_RIGHT = 4, - JoinRel_JoinType_SEMI = 5, - JoinRel_JoinType_ANTI = 6, + JoinRel_JoinType_JOIN_TYPE_UNSPECIFIED = 0, + JoinRel_JoinType_JOIN_TYPE_INNER = 1, + JoinRel_JoinType_JOIN_TYPE_OUTER = 2, + JoinRel_JoinType_JOIN_TYPE_LEFT = 3, + JoinRel_JoinType_JOIN_TYPE_RIGHT = 4, + JoinRel_JoinType_JOIN_TYPE_SEMI = 5, + JoinRel_JoinType_JOIN_TYPE_ANTI = 6, JoinRel_JoinType_JoinRel_JoinType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), JoinRel_JoinType_JoinRel_JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool JoinRel_JoinType_IsValid(int value); -constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MIN = JoinRel_JoinType_UNKNOWN; -constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MAX = JoinRel_JoinType_ANTI; +constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MIN = JoinRel_JoinType_JOIN_TYPE_UNSPECIFIED; +constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MAX = JoinRel_JoinType_JOIN_TYPE_ANTI; constexpr int JoinRel_JoinType_JoinType_ARRAYSIZE = JoinRel_JoinType_JoinType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor(); @@ -227,19 +224,19 @@ inline bool JoinRel_JoinType_Parse( JoinRel_JoinType_descriptor(), name, value); } enum SetRel_SetOp : int { - SetRel_SetOp_UNKNOWN = 0, - SetRel_SetOp_MINUS_PRIMARY = 1, - SetRel_SetOp_MINUS_MULTISET = 2, - SetRel_SetOp_INTERSECTION_PRIMARY = 3, - SetRel_SetOp_INTERSECTION_MULTISET = 4, - SetRel_SetOp_UNION_DISTINCT = 5, - SetRel_SetOp_UNION_ALL = 6, + SetRel_SetOp_SET_OP_UNSPECIFIED = 0, + SetRel_SetOp_SET_OP_MINUS_PRIMARY = 1, + SetRel_SetOp_SET_OP_MINUS_MULTISET = 2, + SetRel_SetOp_SET_OP_INTERSECTION_PRIMARY = 3, + SetRel_SetOp_SET_OP_INTERSECTION_MULTISET = 4, + SetRel_SetOp_SET_OP_UNION_DISTINCT = 5, + SetRel_SetOp_SET_OP_UNION_ALL = 6, SetRel_SetOp_SetRel_SetOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), SetRel_SetOp_SetRel_SetOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool SetRel_SetOp_IsValid(int value); -constexpr SetRel_SetOp SetRel_SetOp_SetOp_MIN = SetRel_SetOp_UNKNOWN; -constexpr SetRel_SetOp SetRel_SetOp_SetOp_MAX = SetRel_SetOp_UNION_ALL; +constexpr SetRel_SetOp SetRel_SetOp_SetOp_MIN = SetRel_SetOp_SET_OP_UNSPECIFIED; +constexpr SetRel_SetOp SetRel_SetOp_SetOp_MAX = SetRel_SetOp_SET_OP_UNION_ALL; constexpr int SetRel_SetOp_SetOp_ARRAYSIZE = SetRel_SetOp_SetOp_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetRel_SetOp_descriptor(); @@ -259,7 +256,7 @@ inline bool SetRel_SetOp_Parse( // =================================================================== class RelCommon_Direct PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Direct) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Direct) */ { public: inline RelCommon_Direct() : RelCommon_Direct(nullptr) {} ~RelCommon_Direct() override; @@ -349,7 +346,7 @@ class RelCommon_Direct PROTOBUF_FINAL : void InternalSwap(RelCommon_Direct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.RelCommon.Direct"; + return "substrait.RelCommon.Direct"; } protected: explicit RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -364,7 +361,7 @@ class RelCommon_Direct PROTOBUF_FINAL : // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Direct) + // @@protoc_insertion_point(class_scope:substrait.RelCommon.Direct) private: class _Internal; @@ -372,12 +369,12 @@ class RelCommon_Direct PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class RelCommon_Emit PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Emit) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Emit) */ { public: inline RelCommon_Emit() : RelCommon_Emit(nullptr) {} ~RelCommon_Emit() override; @@ -467,7 +464,7 @@ class RelCommon_Emit PROTOBUF_FINAL : void InternalSwap(RelCommon_Emit* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.RelCommon.Emit"; + return "substrait.RelCommon.Emit"; } protected: explicit RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -507,7 +504,7 @@ class RelCommon_Emit PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* mutable_output_mapping(); - // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Emit) + // @@protoc_insertion_point(class_scope:substrait.RelCommon.Emit) private: class _Internal; @@ -517,12 +514,12 @@ class RelCommon_Emit PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > output_mapping_; mutable std::atomic _output_mapping_cached_byte_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class RelCommon_Hint_Stats PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Hint.Stats) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint.Stats) */ { public: inline RelCommon_Hint_Stats() : RelCommon_Hint_Stats(nullptr) {} ~RelCommon_Hint_Stats() override; @@ -612,7 +609,7 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : void InternalSwap(RelCommon_Hint_Stats* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.RelCommon.Hint.Stats"; + return "substrait.RelCommon.Hint.Stats"; } protected: explicit RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -632,23 +629,23 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : kRowCountFieldNumber = 1, kRecordSizeFieldNumber = 2, }; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); // double row_count = 1; void clear_row_count(); @@ -668,23 +665,23 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : void _internal_set_record_size(double value); public: - // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Hint.Stats) + // @@protoc_insertion_point(class_scope:substrait.RelCommon.Hint.Stats) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; double row_count_; double record_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class RelCommon_Hint_RuntimeConstraint PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Hint.RuntimeConstraint) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint.RuntimeConstraint) */ { public: inline RelCommon_Hint_RuntimeConstraint() : RelCommon_Hint_RuntimeConstraint(nullptr) {} ~RelCommon_Hint_RuntimeConstraint() override; @@ -774,7 +771,7 @@ class RelCommon_Hint_RuntimeConstraint PROTOBUF_FINAL : void InternalSwap(RelCommon_Hint_RuntimeConstraint* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.RelCommon.Hint.RuntimeConstraint"; + return "substrait.RelCommon.Hint.RuntimeConstraint"; } protected: explicit RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -792,39 +789,39 @@ class RelCommon_Hint_RuntimeConstraint PROTOBUF_FINAL : enum : int { kAdvancedExtensionFieldNumber = 10, }; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Hint.RuntimeConstraint) + // @@protoc_insertion_point(class_scope:substrait.RelCommon.Hint.RuntimeConstraint) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class RelCommon_Hint PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon.Hint) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint) */ { public: inline RelCommon_Hint() : RelCommon_Hint(nullptr) {} ~RelCommon_Hint() override; @@ -914,7 +911,7 @@ class RelCommon_Hint PROTOBUF_FINAL : void InternalSwap(RelCommon_Hint* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.RelCommon.Hint"; + return "substrait.RelCommon.Hint"; } protected: explicit RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -937,77 +934,77 @@ class RelCommon_Hint PROTOBUF_FINAL : kConstraintFieldNumber = 2, kAdvancedExtensionFieldNumber = 10, }; - // .io.substrait.RelCommon.Hint.Stats stats = 1; + // .substrait.RelCommon.Hint.Stats stats = 1; bool has_stats() const; private: bool _internal_has_stats() const; public: void clear_stats(); - const ::io::substrait::RelCommon_Hint_Stats& stats() const; - ::io::substrait::RelCommon_Hint_Stats* release_stats(); - ::io::substrait::RelCommon_Hint_Stats* mutable_stats(); - void set_allocated_stats(::io::substrait::RelCommon_Hint_Stats* stats); + const ::substrait::RelCommon_Hint_Stats& stats() const; + ::substrait::RelCommon_Hint_Stats* release_stats(); + ::substrait::RelCommon_Hint_Stats* mutable_stats(); + void set_allocated_stats(::substrait::RelCommon_Hint_Stats* stats); private: - const ::io::substrait::RelCommon_Hint_Stats& _internal_stats() const; - ::io::substrait::RelCommon_Hint_Stats* _internal_mutable_stats(); + const ::substrait::RelCommon_Hint_Stats& _internal_stats() const; + ::substrait::RelCommon_Hint_Stats* _internal_mutable_stats(); public: void unsafe_arena_set_allocated_stats( - ::io::substrait::RelCommon_Hint_Stats* stats); - ::io::substrait::RelCommon_Hint_Stats* unsafe_arena_release_stats(); + ::substrait::RelCommon_Hint_Stats* stats); + ::substrait::RelCommon_Hint_Stats* unsafe_arena_release_stats(); - // .io.substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; + // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; bool has_constraint() const; private: bool _internal_has_constraint() const; public: void clear_constraint(); - const ::io::substrait::RelCommon_Hint_RuntimeConstraint& constraint() const; - ::io::substrait::RelCommon_Hint_RuntimeConstraint* release_constraint(); - ::io::substrait::RelCommon_Hint_RuntimeConstraint* mutable_constraint(); - void set_allocated_constraint(::io::substrait::RelCommon_Hint_RuntimeConstraint* constraint); + const ::substrait::RelCommon_Hint_RuntimeConstraint& constraint() const; + ::substrait::RelCommon_Hint_RuntimeConstraint* release_constraint(); + ::substrait::RelCommon_Hint_RuntimeConstraint* mutable_constraint(); + void set_allocated_constraint(::substrait::RelCommon_Hint_RuntimeConstraint* constraint); private: - const ::io::substrait::RelCommon_Hint_RuntimeConstraint& _internal_constraint() const; - ::io::substrait::RelCommon_Hint_RuntimeConstraint* _internal_mutable_constraint(); + const ::substrait::RelCommon_Hint_RuntimeConstraint& _internal_constraint() const; + ::substrait::RelCommon_Hint_RuntimeConstraint* _internal_mutable_constraint(); public: void unsafe_arena_set_allocated_constraint( - ::io::substrait::RelCommon_Hint_RuntimeConstraint* constraint); - ::io::substrait::RelCommon_Hint_RuntimeConstraint* unsafe_arena_release_constraint(); + ::substrait::RelCommon_Hint_RuntimeConstraint* constraint); + ::substrait::RelCommon_Hint_RuntimeConstraint* unsafe_arena_release_constraint(); - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // @@protoc_insertion_point(class_scope:io.substrait.RelCommon.Hint) + // @@protoc_insertion_point(class_scope:substrait.RelCommon.Hint) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::RelCommon_Hint_Stats* stats_; - ::io::substrait::RelCommon_Hint_RuntimeConstraint* constraint_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::substrait::RelCommon_Hint_Stats* stats_; + ::substrait::RelCommon_Hint_RuntimeConstraint* constraint_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class RelCommon PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelCommon) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon) */ { public: inline RelCommon() : RelCommon(nullptr) {} ~RelCommon() override; @@ -1103,7 +1100,7 @@ class RelCommon PROTOBUF_FINAL : void InternalSwap(RelCommon* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.RelCommon"; + return "substrait.RelCommon"; } protected: explicit RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1128,81 +1125,81 @@ class RelCommon PROTOBUF_FINAL : kDirectFieldNumber = 1, kEmitFieldNumber = 2, }; - // .io.substrait.RelCommon.Hint hint = 3; + // .substrait.RelCommon.Hint hint = 3; bool has_hint() const; private: bool _internal_has_hint() const; public: void clear_hint(); - const ::io::substrait::RelCommon_Hint& hint() const; - ::io::substrait::RelCommon_Hint* release_hint(); - ::io::substrait::RelCommon_Hint* mutable_hint(); - void set_allocated_hint(::io::substrait::RelCommon_Hint* hint); + const ::substrait::RelCommon_Hint& hint() const; + ::substrait::RelCommon_Hint* release_hint(); + ::substrait::RelCommon_Hint* mutable_hint(); + void set_allocated_hint(::substrait::RelCommon_Hint* hint); private: - const ::io::substrait::RelCommon_Hint& _internal_hint() const; - ::io::substrait::RelCommon_Hint* _internal_mutable_hint(); + const ::substrait::RelCommon_Hint& _internal_hint() const; + ::substrait::RelCommon_Hint* _internal_mutable_hint(); public: void unsafe_arena_set_allocated_hint( - ::io::substrait::RelCommon_Hint* hint); - ::io::substrait::RelCommon_Hint* unsafe_arena_release_hint(); + ::substrait::RelCommon_Hint* hint); + ::substrait::RelCommon_Hint* unsafe_arena_release_hint(); - // .io.substrait.extensions.AdvancedExtension advanced_extension = 4; + // .substrait.extensions.AdvancedExtension advanced_extension = 4; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // .io.substrait.RelCommon.Direct direct = 1; + // .substrait.RelCommon.Direct direct = 1; bool has_direct() const; private: bool _internal_has_direct() const; public: void clear_direct(); - const ::io::substrait::RelCommon_Direct& direct() const; - ::io::substrait::RelCommon_Direct* release_direct(); - ::io::substrait::RelCommon_Direct* mutable_direct(); - void set_allocated_direct(::io::substrait::RelCommon_Direct* direct); + const ::substrait::RelCommon_Direct& direct() const; + ::substrait::RelCommon_Direct* release_direct(); + ::substrait::RelCommon_Direct* mutable_direct(); + void set_allocated_direct(::substrait::RelCommon_Direct* direct); private: - const ::io::substrait::RelCommon_Direct& _internal_direct() const; - ::io::substrait::RelCommon_Direct* _internal_mutable_direct(); + const ::substrait::RelCommon_Direct& _internal_direct() const; + ::substrait::RelCommon_Direct* _internal_mutable_direct(); public: void unsafe_arena_set_allocated_direct( - ::io::substrait::RelCommon_Direct* direct); - ::io::substrait::RelCommon_Direct* unsafe_arena_release_direct(); + ::substrait::RelCommon_Direct* direct); + ::substrait::RelCommon_Direct* unsafe_arena_release_direct(); - // .io.substrait.RelCommon.Emit emit = 2; + // .substrait.RelCommon.Emit emit = 2; bool has_emit() const; private: bool _internal_has_emit() const; public: void clear_emit(); - const ::io::substrait::RelCommon_Emit& emit() const; - ::io::substrait::RelCommon_Emit* release_emit(); - ::io::substrait::RelCommon_Emit* mutable_emit(); - void set_allocated_emit(::io::substrait::RelCommon_Emit* emit); + const ::substrait::RelCommon_Emit& emit() const; + ::substrait::RelCommon_Emit* release_emit(); + ::substrait::RelCommon_Emit* mutable_emit(); + void set_allocated_emit(::substrait::RelCommon_Emit* emit); private: - const ::io::substrait::RelCommon_Emit& _internal_emit() const; - ::io::substrait::RelCommon_Emit* _internal_mutable_emit(); + const ::substrait::RelCommon_Emit& _internal_emit() const; + ::substrait::RelCommon_Emit* _internal_mutable_emit(); public: void unsafe_arena_set_allocated_emit( - ::io::substrait::RelCommon_Emit* emit); - ::io::substrait::RelCommon_Emit* unsafe_arena_release_emit(); + ::substrait::RelCommon_Emit* emit); + ::substrait::RelCommon_Emit* unsafe_arena_release_emit(); void clear_emit_kind(); EmitKindCase emit_kind_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.RelCommon) + // @@protoc_insertion_point(class_scope:substrait.RelCommon) private: class _Internal; void set_has_direct(); @@ -1214,23 +1211,23 @@ class RelCommon PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::RelCommon_Hint* hint_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::substrait::RelCommon_Hint* hint_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; union EmitKindUnion { constexpr EmitKindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::RelCommon_Direct* direct_; - ::io::substrait::RelCommon_Emit* emit_; + ::substrait::RelCommon_Direct* direct_; + ::substrait::RelCommon_Emit* emit_; } emit_kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class ReadRel_NamedTable PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.NamedTable) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.NamedTable) */ { public: inline ReadRel_NamedTable() : ReadRel_NamedTable(nullptr) {} ~ReadRel_NamedTable() override; @@ -1320,7 +1317,7 @@ class ReadRel_NamedTable PROTOBUF_FINAL : void InternalSwap(ReadRel_NamedTable* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReadRel.NamedTable"; + return "substrait.ReadRel.NamedTable"; } protected: explicit ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1363,25 +1360,25 @@ class ReadRel_NamedTable PROTOBUF_FINAL : std::string* _internal_add_names(); public: - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.NamedTable) + // @@protoc_insertion_point(class_scope:substrait.ReadRel.NamedTable) private: class _Internal; @@ -1389,14 +1386,14 @@ class ReadRel_NamedTable PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class ReadRel_VirtualTable PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.VirtualTable) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.VirtualTable) */ { public: inline ReadRel_VirtualTable() : ReadRel_VirtualTable(nullptr) {} ~ReadRel_VirtualTable() override; @@ -1486,7 +1483,7 @@ class ReadRel_VirtualTable PROTOBUF_FINAL : void InternalSwap(ReadRel_VirtualTable* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReadRel.VirtualTable"; + return "substrait.ReadRel.VirtualTable"; } protected: explicit ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1504,39 +1501,39 @@ class ReadRel_VirtualTable PROTOBUF_FINAL : enum : int { kValuesFieldNumber = 1, }; - // repeated .io.substrait.Expression.Literal.Struct values = 1; + // repeated .substrait.Expression.Literal.Struct values = 1; int values_size() const; private: int _internal_values_size() const; public: void clear_values(); - ::io::substrait::Expression_Literal_Struct* mutable_values(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >* + ::substrait::Expression_Literal_Struct* mutable_values(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >* mutable_values(); private: - const ::io::substrait::Expression_Literal_Struct& _internal_values(int index) const; - ::io::substrait::Expression_Literal_Struct* _internal_add_values(); + const ::substrait::Expression_Literal_Struct& _internal_values(int index) const; + ::substrait::Expression_Literal_Struct* _internal_add_values(); public: - const ::io::substrait::Expression_Literal_Struct& values(int index) const; - ::io::substrait::Expression_Literal_Struct* add_values(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >& + const ::substrait::Expression_Literal_Struct& values(int index) const; + ::substrait::Expression_Literal_Struct* add_values(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >& values() const; - // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.VirtualTable) + // @@protoc_insertion_point(class_scope:substrait.ReadRel.VirtualTable) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct > values_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct > values_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class ReadRel_ExtensionTable PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.ExtensionTable) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.ExtensionTable) */ { public: inline ReadRel_ExtensionTable() : ReadRel_ExtensionTable(nullptr) {} ~ReadRel_ExtensionTable() override; @@ -1626,7 +1623,7 @@ class ReadRel_ExtensionTable PROTOBUF_FINAL : void InternalSwap(ReadRel_ExtensionTable* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReadRel.ExtensionTable"; + return "substrait.ReadRel.ExtensionTable"; } protected: explicit ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1662,7 +1659,7 @@ class ReadRel_ExtensionTable PROTOBUF_FINAL : PROTOBUF_NAMESPACE_ID::Any* detail); PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); - // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.ExtensionTable) + // @@protoc_insertion_point(class_scope:substrait.ReadRel.ExtensionTable) private: class _Internal; @@ -1671,12 +1668,12 @@ class ReadRel_ExtensionTable PROTOBUF_FINAL : typedef void DestructorSkippable_; PROTOBUF_NAMESPACE_ID::Any* detail_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.LocalFiles.FileOrFiles) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.LocalFiles.FileOrFiles) */ { public: inline ReadRel_LocalFiles_FileOrFiles() : ReadRel_LocalFiles_FileOrFiles(nullptr) {} ~ReadRel_LocalFiles_FileOrFiles() override; @@ -1774,7 +1771,7 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : void InternalSwap(ReadRel_LocalFiles_FileOrFiles* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReadRel.LocalFiles.FileOrFiles"; + return "substrait.ReadRel.LocalFiles.FileOrFiles"; } protected: explicit ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1787,52 +1784,82 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : // nested types ---------------------------------------------------- - typedef ReadRel_LocalFiles_FileOrFiles_Format Format; - static constexpr Format UNKNOWN = - ReadRel_LocalFiles_FileOrFiles_Format_UNKNOWN; - static constexpr Format PARQUET = - ReadRel_LocalFiles_FileOrFiles_Format_PARQUET; - static inline bool Format_IsValid(int value) { - return ReadRel_LocalFiles_FileOrFiles_Format_IsValid(value); - } - static constexpr Format Format_MIN = - ReadRel_LocalFiles_FileOrFiles_Format_Format_MIN; - static constexpr Format Format_MAX = - ReadRel_LocalFiles_FileOrFiles_Format_Format_MAX; - static constexpr int Format_ARRAYSIZE = - ReadRel_LocalFiles_FileOrFiles_Format_Format_ARRAYSIZE; + typedef ReadRel_LocalFiles_FileOrFiles_FileFormat FileFormat; + static constexpr FileFormat FILE_FORMAT_UNSPECIFIED = + ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED; + static constexpr FileFormat FILE_FORMAT_PARQUET = + ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_PARQUET; + static inline bool FileFormat_IsValid(int value) { + return ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(value); + } + static constexpr FileFormat FileFormat_MIN = + ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MIN; + static constexpr FileFormat FileFormat_MAX = + ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MAX; + static constexpr int FileFormat_ARRAYSIZE = + ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Format_descriptor() { - return ReadRel_LocalFiles_FileOrFiles_Format_descriptor(); + FileFormat_descriptor() { + return ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(); } template - static inline const std::string& Format_Name(T enum_t_value) { - static_assert(::std::is_same::value || + static inline const std::string& FileFormat_Name(T enum_t_value) { + static_assert(::std::is_same::value || ::std::is_integral::value, - "Incorrect type passed to function Format_Name."); - return ReadRel_LocalFiles_FileOrFiles_Format_Name(enum_t_value); + "Incorrect type passed to function FileFormat_Name."); + return ReadRel_LocalFiles_FileOrFiles_FileFormat_Name(enum_t_value); } - static inline bool Format_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Format* value) { - return ReadRel_LocalFiles_FileOrFiles_Format_Parse(name, value); + static inline bool FileFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + FileFormat* value) { + return ReadRel_LocalFiles_FileOrFiles_FileFormat_Parse(name, value); } // accessors ------------------------------------------------------- enum : int { kFormatFieldNumber = 5, + kPartitionIndexFieldNumber = 6, + kStartFieldNumber = 7, + kLengthFieldNumber = 8, kUriPathFieldNumber = 1, kUriPathGlobFieldNumber = 2, kUriFileFieldNumber = 3, kUriFolderFieldNumber = 4, }; - // .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 5; + // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; void clear_format(); - ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format format() const; - void set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value); + ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat format() const; + void set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value); private: - ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format _internal_format() const; - void _internal_set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value); + ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat _internal_format() const; + void _internal_set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value); + public: + + // uint64 partition_index = 6; + void clear_partition_index(); + ::PROTOBUF_NAMESPACE_ID::uint64 partition_index() const; + void set_partition_index(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_partition_index() const; + void _internal_set_partition_index(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // uint64 start = 7; + void clear_start(); + ::PROTOBUF_NAMESPACE_ID::uint64 start() const; + void set_start(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_start() const; + void _internal_set_start(::PROTOBUF_NAMESPACE_ID::uint64 value); + public: + + // uint64 length = 8; + void clear_length(); + ::PROTOBUF_NAMESPACE_ID::uint64 length() const; + void set_length(::PROTOBUF_NAMESPACE_ID::uint64 value); + private: + ::PROTOBUF_NAMESPACE_ID::uint64 _internal_length() const; + void _internal_set_length(::PROTOBUF_NAMESPACE_ID::uint64 value); public: // string uri_path = 1; @@ -1909,7 +1936,7 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : void clear_path_type(); PathTypeCase path_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.LocalFiles.FileOrFiles) + // @@protoc_insertion_point(class_scope:substrait.ReadRel.LocalFiles.FileOrFiles) private: class _Internal; void set_has_uri_path(); @@ -1924,6 +1951,9 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; int format_; + ::PROTOBUF_NAMESPACE_ID::uint64 partition_index_; + ::PROTOBUF_NAMESPACE_ID::uint64 start_; + ::PROTOBUF_NAMESPACE_ID::uint64 length_; union PathTypeUnion { constexpr PathTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; @@ -1935,12 +1965,12 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class ReadRel_LocalFiles PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel.LocalFiles) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.LocalFiles) */ { public: inline ReadRel_LocalFiles() : ReadRel_LocalFiles(nullptr) {} ~ReadRel_LocalFiles() override; @@ -2030,7 +2060,7 @@ class ReadRel_LocalFiles PROTOBUF_FINAL : void InternalSwap(ReadRel_LocalFiles* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReadRel.LocalFiles"; + return "substrait.ReadRel.LocalFiles"; } protected: explicit ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2051,58 +2081,58 @@ class ReadRel_LocalFiles PROTOBUF_FINAL : kItemsFieldNumber = 1, kAdvancedExtensionFieldNumber = 10, }; - // repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; + // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; int items_size() const; private: int _internal_items_size() const; public: void clear_items(); - ::io::substrait::ReadRel_LocalFiles_FileOrFiles* mutable_items(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >* + ::substrait::ReadRel_LocalFiles_FileOrFiles* mutable_items(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >* mutable_items(); private: - const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& _internal_items(int index) const; - ::io::substrait::ReadRel_LocalFiles_FileOrFiles* _internal_add_items(); + const ::substrait::ReadRel_LocalFiles_FileOrFiles& _internal_items(int index) const; + ::substrait::ReadRel_LocalFiles_FileOrFiles* _internal_add_items(); public: - const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& items(int index) const; - ::io::substrait::ReadRel_LocalFiles_FileOrFiles* add_items(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >& + const ::substrait::ReadRel_LocalFiles_FileOrFiles& items(int index) const; + ::substrait::ReadRel_LocalFiles_FileOrFiles* add_items(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >& items() const; - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // @@protoc_insertion_point(class_scope:io.substrait.ReadRel.LocalFiles) + // @@protoc_insertion_point(class_scope:substrait.ReadRel.LocalFiles) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles > items_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles > items_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class ReadRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ReadRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel) */ { public: inline ReadRel() : ReadRel(nullptr) {} ~ReadRel() override; @@ -2200,7 +2230,7 @@ class ReadRel PROTOBUF_FINAL : void InternalSwap(ReadRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ReadRel"; + return "substrait.ReadRel"; } protected: explicit ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2231,171 +2261,171 @@ class ReadRel PROTOBUF_FINAL : kNamedTableFieldNumber = 7, kExtensionTableFieldNumber = 8, }; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.NamedStruct base_schema = 2; + // .substrait.NamedStruct base_schema = 2; bool has_base_schema() const; private: bool _internal_has_base_schema() const; public: void clear_base_schema(); - const ::io::substrait::NamedStruct& base_schema() const; - ::io::substrait::NamedStruct* release_base_schema(); - ::io::substrait::NamedStruct* mutable_base_schema(); - void set_allocated_base_schema(::io::substrait::NamedStruct* base_schema); + const ::substrait::NamedStruct& base_schema() const; + ::substrait::NamedStruct* release_base_schema(); + ::substrait::NamedStruct* mutable_base_schema(); + void set_allocated_base_schema(::substrait::NamedStruct* base_schema); private: - const ::io::substrait::NamedStruct& _internal_base_schema() const; - ::io::substrait::NamedStruct* _internal_mutable_base_schema(); + const ::substrait::NamedStruct& _internal_base_schema() const; + ::substrait::NamedStruct* _internal_mutable_base_schema(); public: void unsafe_arena_set_allocated_base_schema( - ::io::substrait::NamedStruct* base_schema); - ::io::substrait::NamedStruct* unsafe_arena_release_base_schema(); + ::substrait::NamedStruct* base_schema); + ::substrait::NamedStruct* unsafe_arena_release_base_schema(); - // .io.substrait.Expression filter = 3; + // .substrait.Expression filter = 3; bool has_filter() const; private: bool _internal_has_filter() const; public: void clear_filter(); - const ::io::substrait::Expression& filter() const; - ::io::substrait::Expression* release_filter(); - ::io::substrait::Expression* mutable_filter(); - void set_allocated_filter(::io::substrait::Expression* filter); + const ::substrait::Expression& filter() const; + ::substrait::Expression* release_filter(); + ::substrait::Expression* mutable_filter(); + void set_allocated_filter(::substrait::Expression* filter); private: - const ::io::substrait::Expression& _internal_filter() const; - ::io::substrait::Expression* _internal_mutable_filter(); + const ::substrait::Expression& _internal_filter() const; + ::substrait::Expression* _internal_mutable_filter(); public: void unsafe_arena_set_allocated_filter( - ::io::substrait::Expression* filter); - ::io::substrait::Expression* unsafe_arena_release_filter(); + ::substrait::Expression* filter); + ::substrait::Expression* unsafe_arena_release_filter(); - // .io.substrait.Expression.MaskExpression projection = 4; + // .substrait.Expression.MaskExpression projection = 4; bool has_projection() const; private: bool _internal_has_projection() const; public: void clear_projection(); - const ::io::substrait::Expression_MaskExpression& projection() const; - ::io::substrait::Expression_MaskExpression* release_projection(); - ::io::substrait::Expression_MaskExpression* mutable_projection(); - void set_allocated_projection(::io::substrait::Expression_MaskExpression* projection); + const ::substrait::Expression_MaskExpression& projection() const; + ::substrait::Expression_MaskExpression* release_projection(); + ::substrait::Expression_MaskExpression* mutable_projection(); + void set_allocated_projection(::substrait::Expression_MaskExpression* projection); private: - const ::io::substrait::Expression_MaskExpression& _internal_projection() const; - ::io::substrait::Expression_MaskExpression* _internal_mutable_projection(); + const ::substrait::Expression_MaskExpression& _internal_projection() const; + ::substrait::Expression_MaskExpression* _internal_mutable_projection(); public: void unsafe_arena_set_allocated_projection( - ::io::substrait::Expression_MaskExpression* projection); - ::io::substrait::Expression_MaskExpression* unsafe_arena_release_projection(); + ::substrait::Expression_MaskExpression* projection); + ::substrait::Expression_MaskExpression* unsafe_arena_release_projection(); - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // .io.substrait.ReadRel.VirtualTable virtual_table = 5; + // .substrait.ReadRel.VirtualTable virtual_table = 5; bool has_virtual_table() const; private: bool _internal_has_virtual_table() const; public: void clear_virtual_table(); - const ::io::substrait::ReadRel_VirtualTable& virtual_table() const; - ::io::substrait::ReadRel_VirtualTable* release_virtual_table(); - ::io::substrait::ReadRel_VirtualTable* mutable_virtual_table(); - void set_allocated_virtual_table(::io::substrait::ReadRel_VirtualTable* virtual_table); + const ::substrait::ReadRel_VirtualTable& virtual_table() const; + ::substrait::ReadRel_VirtualTable* release_virtual_table(); + ::substrait::ReadRel_VirtualTable* mutable_virtual_table(); + void set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table); private: - const ::io::substrait::ReadRel_VirtualTable& _internal_virtual_table() const; - ::io::substrait::ReadRel_VirtualTable* _internal_mutable_virtual_table(); + const ::substrait::ReadRel_VirtualTable& _internal_virtual_table() const; + ::substrait::ReadRel_VirtualTable* _internal_mutable_virtual_table(); public: void unsafe_arena_set_allocated_virtual_table( - ::io::substrait::ReadRel_VirtualTable* virtual_table); - ::io::substrait::ReadRel_VirtualTable* unsafe_arena_release_virtual_table(); + ::substrait::ReadRel_VirtualTable* virtual_table); + ::substrait::ReadRel_VirtualTable* unsafe_arena_release_virtual_table(); - // .io.substrait.ReadRel.LocalFiles local_files = 6; + // .substrait.ReadRel.LocalFiles local_files = 6; bool has_local_files() const; private: bool _internal_has_local_files() const; public: void clear_local_files(); - const ::io::substrait::ReadRel_LocalFiles& local_files() const; - ::io::substrait::ReadRel_LocalFiles* release_local_files(); - ::io::substrait::ReadRel_LocalFiles* mutable_local_files(); - void set_allocated_local_files(::io::substrait::ReadRel_LocalFiles* local_files); + const ::substrait::ReadRel_LocalFiles& local_files() const; + ::substrait::ReadRel_LocalFiles* release_local_files(); + ::substrait::ReadRel_LocalFiles* mutable_local_files(); + void set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files); private: - const ::io::substrait::ReadRel_LocalFiles& _internal_local_files() const; - ::io::substrait::ReadRel_LocalFiles* _internal_mutable_local_files(); + const ::substrait::ReadRel_LocalFiles& _internal_local_files() const; + ::substrait::ReadRel_LocalFiles* _internal_mutable_local_files(); public: void unsafe_arena_set_allocated_local_files( - ::io::substrait::ReadRel_LocalFiles* local_files); - ::io::substrait::ReadRel_LocalFiles* unsafe_arena_release_local_files(); + ::substrait::ReadRel_LocalFiles* local_files); + ::substrait::ReadRel_LocalFiles* unsafe_arena_release_local_files(); - // .io.substrait.ReadRel.NamedTable named_table = 7; + // .substrait.ReadRel.NamedTable named_table = 7; bool has_named_table() const; private: bool _internal_has_named_table() const; public: void clear_named_table(); - const ::io::substrait::ReadRel_NamedTable& named_table() const; - ::io::substrait::ReadRel_NamedTable* release_named_table(); - ::io::substrait::ReadRel_NamedTable* mutable_named_table(); - void set_allocated_named_table(::io::substrait::ReadRel_NamedTable* named_table); + const ::substrait::ReadRel_NamedTable& named_table() const; + ::substrait::ReadRel_NamedTable* release_named_table(); + ::substrait::ReadRel_NamedTable* mutable_named_table(); + void set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table); private: - const ::io::substrait::ReadRel_NamedTable& _internal_named_table() const; - ::io::substrait::ReadRel_NamedTable* _internal_mutable_named_table(); + const ::substrait::ReadRel_NamedTable& _internal_named_table() const; + ::substrait::ReadRel_NamedTable* _internal_mutable_named_table(); public: void unsafe_arena_set_allocated_named_table( - ::io::substrait::ReadRel_NamedTable* named_table); - ::io::substrait::ReadRel_NamedTable* unsafe_arena_release_named_table(); + ::substrait::ReadRel_NamedTable* named_table); + ::substrait::ReadRel_NamedTable* unsafe_arena_release_named_table(); - // .io.substrait.ReadRel.ExtensionTable extension_table = 8; + // .substrait.ReadRel.ExtensionTable extension_table = 8; bool has_extension_table() const; private: bool _internal_has_extension_table() const; public: void clear_extension_table(); - const ::io::substrait::ReadRel_ExtensionTable& extension_table() const; - ::io::substrait::ReadRel_ExtensionTable* release_extension_table(); - ::io::substrait::ReadRel_ExtensionTable* mutable_extension_table(); - void set_allocated_extension_table(::io::substrait::ReadRel_ExtensionTable* extension_table); + const ::substrait::ReadRel_ExtensionTable& extension_table() const; + ::substrait::ReadRel_ExtensionTable* release_extension_table(); + ::substrait::ReadRel_ExtensionTable* mutable_extension_table(); + void set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table); private: - const ::io::substrait::ReadRel_ExtensionTable& _internal_extension_table() const; - ::io::substrait::ReadRel_ExtensionTable* _internal_mutable_extension_table(); + const ::substrait::ReadRel_ExtensionTable& _internal_extension_table() const; + ::substrait::ReadRel_ExtensionTable* _internal_mutable_extension_table(); public: void unsafe_arena_set_allocated_extension_table( - ::io::substrait::ReadRel_ExtensionTable* extension_table); - ::io::substrait::ReadRel_ExtensionTable* unsafe_arena_release_extension_table(); + ::substrait::ReadRel_ExtensionTable* extension_table); + ::substrait::ReadRel_ExtensionTable* unsafe_arena_release_extension_table(); void clear_read_type(); ReadTypeCase read_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.ReadRel) + // @@protoc_insertion_point(class_scope:substrait.ReadRel) private: class _Internal; void set_has_virtual_table(); @@ -2409,28 +2439,28 @@ class ReadRel PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::RelCommon* common_; - ::io::substrait::NamedStruct* base_schema_; - ::io::substrait::Expression* filter_; - ::io::substrait::Expression_MaskExpression* projection_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::substrait::RelCommon* common_; + ::substrait::NamedStruct* base_schema_; + ::substrait::Expression* filter_; + ::substrait::Expression_MaskExpression* projection_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; union ReadTypeUnion { constexpr ReadTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::ReadRel_VirtualTable* virtual_table_; - ::io::substrait::ReadRel_LocalFiles* local_files_; - ::io::substrait::ReadRel_NamedTable* named_table_; - ::io::substrait::ReadRel_ExtensionTable* extension_table_; + ::substrait::ReadRel_VirtualTable* virtual_table_; + ::substrait::ReadRel_LocalFiles* local_files_; + ::substrait::ReadRel_NamedTable* named_table_; + ::substrait::ReadRel_ExtensionTable* extension_table_; } read_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class ProjectRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ProjectRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ProjectRel) */ { public: inline ProjectRel() : ProjectRel(nullptr) {} ~ProjectRel() override; @@ -2520,7 +2550,7 @@ class ProjectRel PROTOBUF_FINAL : void InternalSwap(ProjectRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ProjectRel"; + return "substrait.ProjectRel"; } protected: explicit ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2541,96 +2571,96 @@ class ProjectRel PROTOBUF_FINAL : kInputFieldNumber = 2, kAdvancedExtensionFieldNumber = 10, }; - // repeated .io.substrait.Expression expressions = 3; + // repeated .substrait.Expression expressions = 3; int expressions_size() const; private: int _internal_expressions_size() const; public: void clear_expressions(); - ::io::substrait::Expression* mutable_expressions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* + ::substrait::Expression* mutable_expressions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* mutable_expressions(); private: - const ::io::substrait::Expression& _internal_expressions(int index) const; - ::io::substrait::Expression* _internal_add_expressions(); + const ::substrait::Expression& _internal_expressions(int index) const; + ::substrait::Expression* _internal_add_expressions(); public: - const ::io::substrait::Expression& expressions(int index) const; - ::io::substrait::Expression* add_expressions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& + const ::substrait::Expression& expressions(int index) const; + ::substrait::Expression* add_expressions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& expressions() const; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; bool has_input() const; private: bool _internal_has_input() const; public: void clear_input(); - const ::io::substrait::Rel& input() const; - ::io::substrait::Rel* release_input(); - ::io::substrait::Rel* mutable_input(); - void set_allocated_input(::io::substrait::Rel* input); + const ::substrait::Rel& input() const; + ::substrait::Rel* release_input(); + ::substrait::Rel* mutable_input(); + void set_allocated_input(::substrait::Rel* input); private: - const ::io::substrait::Rel& _internal_input() const; - ::io::substrait::Rel* _internal_mutable_input(); + const ::substrait::Rel& _internal_input() const; + ::substrait::Rel* _internal_mutable_input(); public: void unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input); - ::io::substrait::Rel* unsafe_arena_release_input(); + ::substrait::Rel* input); + ::substrait::Rel* unsafe_arena_release_input(); - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // @@protoc_insertion_point(class_scope:io.substrait.ProjectRel) + // @@protoc_insertion_point(class_scope:substrait.ProjectRel) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression > expressions_; - ::io::substrait::RelCommon* common_; - ::io::substrait::Rel* input_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > expressions_; + ::substrait::RelCommon* common_; + ::substrait::Rel* input_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class JoinRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.JoinRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.JoinRel) */ { public: inline JoinRel() : JoinRel(nullptr) {} ~JoinRel() override; @@ -2720,7 +2750,7 @@ class JoinRel PROTOBUF_FINAL : void InternalSwap(JoinRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.JoinRel"; + return "substrait.JoinRel"; } protected: explicit JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2734,20 +2764,20 @@ class JoinRel PROTOBUF_FINAL : // nested types ---------------------------------------------------- typedef JoinRel_JoinType JoinType; - static constexpr JoinType UNKNOWN = - JoinRel_JoinType_UNKNOWN; - static constexpr JoinType INNER = - JoinRel_JoinType_INNER; - static constexpr JoinType OUTER = - JoinRel_JoinType_OUTER; - static constexpr JoinType LEFT = - JoinRel_JoinType_LEFT; - static constexpr JoinType RIGHT = - JoinRel_JoinType_RIGHT; - static constexpr JoinType SEMI = - JoinRel_JoinType_SEMI; - static constexpr JoinType ANTI = - JoinRel_JoinType_ANTI; + static constexpr JoinType JOIN_TYPE_UNSPECIFIED = + JoinRel_JoinType_JOIN_TYPE_UNSPECIFIED; + static constexpr JoinType JOIN_TYPE_INNER = + JoinRel_JoinType_JOIN_TYPE_INNER; + static constexpr JoinType JOIN_TYPE_OUTER = + JoinRel_JoinType_JOIN_TYPE_OUTER; + static constexpr JoinType JOIN_TYPE_LEFT = + JoinRel_JoinType_JOIN_TYPE_LEFT; + static constexpr JoinType JOIN_TYPE_RIGHT = + JoinRel_JoinType_JOIN_TYPE_RIGHT; + static constexpr JoinType JOIN_TYPE_SEMI = + JoinRel_JoinType_JOIN_TYPE_SEMI; + static constexpr JoinType JOIN_TYPE_ANTI = + JoinRel_JoinType_JOIN_TYPE_ANTI; static inline bool JoinType_IsValid(int value) { return JoinRel_JoinType_IsValid(value); } @@ -2784,144 +2814,144 @@ class JoinRel PROTOBUF_FINAL : kAdvancedExtensionFieldNumber = 10, kTypeFieldNumber = 6, }; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.Rel left = 2; + // .substrait.Rel left = 2; bool has_left() const; private: bool _internal_has_left() const; public: void clear_left(); - const ::io::substrait::Rel& left() const; - ::io::substrait::Rel* release_left(); - ::io::substrait::Rel* mutable_left(); - void set_allocated_left(::io::substrait::Rel* left); + const ::substrait::Rel& left() const; + ::substrait::Rel* release_left(); + ::substrait::Rel* mutable_left(); + void set_allocated_left(::substrait::Rel* left); private: - const ::io::substrait::Rel& _internal_left() const; - ::io::substrait::Rel* _internal_mutable_left(); + const ::substrait::Rel& _internal_left() const; + ::substrait::Rel* _internal_mutable_left(); public: void unsafe_arena_set_allocated_left( - ::io::substrait::Rel* left); - ::io::substrait::Rel* unsafe_arena_release_left(); + ::substrait::Rel* left); + ::substrait::Rel* unsafe_arena_release_left(); - // .io.substrait.Rel right = 3; + // .substrait.Rel right = 3; bool has_right() const; private: bool _internal_has_right() const; public: void clear_right(); - const ::io::substrait::Rel& right() const; - ::io::substrait::Rel* release_right(); - ::io::substrait::Rel* mutable_right(); - void set_allocated_right(::io::substrait::Rel* right); + const ::substrait::Rel& right() const; + ::substrait::Rel* release_right(); + ::substrait::Rel* mutable_right(); + void set_allocated_right(::substrait::Rel* right); private: - const ::io::substrait::Rel& _internal_right() const; - ::io::substrait::Rel* _internal_mutable_right(); + const ::substrait::Rel& _internal_right() const; + ::substrait::Rel* _internal_mutable_right(); public: void unsafe_arena_set_allocated_right( - ::io::substrait::Rel* right); - ::io::substrait::Rel* unsafe_arena_release_right(); + ::substrait::Rel* right); + ::substrait::Rel* unsafe_arena_release_right(); - // .io.substrait.Expression expression = 4; + // .substrait.Expression expression = 4; bool has_expression() const; private: bool _internal_has_expression() const; public: void clear_expression(); - const ::io::substrait::Expression& expression() const; - ::io::substrait::Expression* release_expression(); - ::io::substrait::Expression* mutable_expression(); - void set_allocated_expression(::io::substrait::Expression* expression); + const ::substrait::Expression& expression() const; + ::substrait::Expression* release_expression(); + ::substrait::Expression* mutable_expression(); + void set_allocated_expression(::substrait::Expression* expression); private: - const ::io::substrait::Expression& _internal_expression() const; - ::io::substrait::Expression* _internal_mutable_expression(); + const ::substrait::Expression& _internal_expression() const; + ::substrait::Expression* _internal_mutable_expression(); public: void unsafe_arena_set_allocated_expression( - ::io::substrait::Expression* expression); - ::io::substrait::Expression* unsafe_arena_release_expression(); + ::substrait::Expression* expression); + ::substrait::Expression* unsafe_arena_release_expression(); - // .io.substrait.Expression post_join_filter = 5; + // .substrait.Expression post_join_filter = 5; bool has_post_join_filter() const; private: bool _internal_has_post_join_filter() const; public: void clear_post_join_filter(); - const ::io::substrait::Expression& post_join_filter() const; - ::io::substrait::Expression* release_post_join_filter(); - ::io::substrait::Expression* mutable_post_join_filter(); - void set_allocated_post_join_filter(::io::substrait::Expression* post_join_filter); + const ::substrait::Expression& post_join_filter() const; + ::substrait::Expression* release_post_join_filter(); + ::substrait::Expression* mutable_post_join_filter(); + void set_allocated_post_join_filter(::substrait::Expression* post_join_filter); private: - const ::io::substrait::Expression& _internal_post_join_filter() const; - ::io::substrait::Expression* _internal_mutable_post_join_filter(); + const ::substrait::Expression& _internal_post_join_filter() const; + ::substrait::Expression* _internal_mutable_post_join_filter(); public: void unsafe_arena_set_allocated_post_join_filter( - ::io::substrait::Expression* post_join_filter); - ::io::substrait::Expression* unsafe_arena_release_post_join_filter(); + ::substrait::Expression* post_join_filter); + ::substrait::Expression* unsafe_arena_release_post_join_filter(); - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // .io.substrait.JoinRel.JoinType type = 6; + // .substrait.JoinRel.JoinType type = 6; void clear_type(); - ::io::substrait::JoinRel_JoinType type() const; - void set_type(::io::substrait::JoinRel_JoinType value); + ::substrait::JoinRel_JoinType type() const; + void set_type(::substrait::JoinRel_JoinType value); private: - ::io::substrait::JoinRel_JoinType _internal_type() const; - void _internal_set_type(::io::substrait::JoinRel_JoinType value); + ::substrait::JoinRel_JoinType _internal_type() const; + void _internal_set_type(::substrait::JoinRel_JoinType value); public: - // @@protoc_insertion_point(class_scope:io.substrait.JoinRel) + // @@protoc_insertion_point(class_scope:substrait.JoinRel) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::RelCommon* common_; - ::io::substrait::Rel* left_; - ::io::substrait::Rel* right_; - ::io::substrait::Expression* expression_; - ::io::substrait::Expression* post_join_filter_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::substrait::RelCommon* common_; + ::substrait::Rel* left_; + ::substrait::Rel* right_; + ::substrait::Expression* expression_; + ::substrait::Expression* post_join_filter_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; int type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class FetchRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FetchRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FetchRel) */ { public: inline FetchRel() : FetchRel(nullptr) {} ~FetchRel() override; @@ -3011,7 +3041,7 @@ class FetchRel PROTOBUF_FINAL : void InternalSwap(FetchRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FetchRel"; + return "substrait.FetchRel"; } protected: explicit FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3033,59 +3063,59 @@ class FetchRel PROTOBUF_FINAL : kOffsetFieldNumber = 3, kCountFieldNumber = 4, }; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; bool has_input() const; private: bool _internal_has_input() const; public: void clear_input(); - const ::io::substrait::Rel& input() const; - ::io::substrait::Rel* release_input(); - ::io::substrait::Rel* mutable_input(); - void set_allocated_input(::io::substrait::Rel* input); + const ::substrait::Rel& input() const; + ::substrait::Rel* release_input(); + ::substrait::Rel* mutable_input(); + void set_allocated_input(::substrait::Rel* input); private: - const ::io::substrait::Rel& _internal_input() const; - ::io::substrait::Rel* _internal_mutable_input(); + const ::substrait::Rel& _internal_input() const; + ::substrait::Rel* _internal_mutable_input(); public: void unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input); - ::io::substrait::Rel* unsafe_arena_release_input(); + ::substrait::Rel* input); + ::substrait::Rel* unsafe_arena_release_input(); - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); // int64 offset = 3; void clear_offset(); @@ -3105,25 +3135,25 @@ class FetchRel PROTOBUF_FINAL : void _internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value); public: - // @@protoc_insertion_point(class_scope:io.substrait.FetchRel) + // @@protoc_insertion_point(class_scope:substrait.FetchRel) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::RelCommon* common_; - ::io::substrait::Rel* input_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::substrait::RelCommon* common_; + ::substrait::Rel* input_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; ::PROTOBUF_NAMESPACE_ID::int64 offset_; ::PROTOBUF_NAMESPACE_ID::int64 count_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class AggregateRel_Grouping PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.AggregateRel.Grouping) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel.Grouping) */ { public: inline AggregateRel_Grouping() : AggregateRel_Grouping(nullptr) {} ~AggregateRel_Grouping() override; @@ -3213,7 +3243,7 @@ class AggregateRel_Grouping PROTOBUF_FINAL : void InternalSwap(AggregateRel_Grouping* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.AggregateRel.Grouping"; + return "substrait.AggregateRel.Grouping"; } protected: explicit AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3229,46 +3259,41 @@ class AggregateRel_Grouping PROTOBUF_FINAL : // accessors ------------------------------------------------------- enum : int { - kInputFieldsFieldNumber = 1, + kGroupingExpressionsFieldNumber = 1, }; - // repeated int32 input_fields = 1; - int input_fields_size() const; + // repeated .substrait.Expression grouping_expressions = 1; + int grouping_expressions_size() const; private: - int _internal_input_fields_size() const; + int _internal_grouping_expressions_size() const; public: - void clear_input_fields(); + void clear_grouping_expressions(); + ::substrait::Expression* mutable_grouping_expressions(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* + mutable_grouping_expressions(); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_input_fields(int index) const; - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& - _internal_input_fields() const; - void _internal_add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value); - ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* - _internal_mutable_input_fields(); + const ::substrait::Expression& _internal_grouping_expressions(int index) const; + ::substrait::Expression* _internal_add_grouping_expressions(); public: - ::PROTOBUF_NAMESPACE_ID::int32 input_fields(int index) const; - void set_input_fields(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); - void add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value); - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& - input_fields() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* - mutable_input_fields(); + const ::substrait::Expression& grouping_expressions(int index) const; + ::substrait::Expression* add_grouping_expressions(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& + grouping_expressions() const; - // @@protoc_insertion_point(class_scope:io.substrait.AggregateRel.Grouping) + // @@protoc_insertion_point(class_scope:substrait.AggregateRel.Grouping) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > input_fields_; - mutable std::atomic _input_fields_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > grouping_expressions_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class AggregateRel_Measure PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.AggregateRel.Measure) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel.Measure) */ { public: inline AggregateRel_Measure() : AggregateRel_Measure(nullptr) {} ~AggregateRel_Measure() override; @@ -3358,7 +3383,7 @@ class AggregateRel_Measure PROTOBUF_FINAL : void InternalSwap(AggregateRel_Measure* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.AggregateRel.Measure"; + return "substrait.AggregateRel.Measure"; } protected: explicit AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3377,58 +3402,58 @@ class AggregateRel_Measure PROTOBUF_FINAL : kMeasureFieldNumber = 1, kFilterFieldNumber = 2, }; - // .io.substrait.AggregateFunction measure = 1; + // .substrait.AggregateFunction measure = 1; bool has_measure() const; private: bool _internal_has_measure() const; public: void clear_measure(); - const ::io::substrait::AggregateFunction& measure() const; - ::io::substrait::AggregateFunction* release_measure(); - ::io::substrait::AggregateFunction* mutable_measure(); - void set_allocated_measure(::io::substrait::AggregateFunction* measure); + const ::substrait::AggregateFunction& measure() const; + ::substrait::AggregateFunction* release_measure(); + ::substrait::AggregateFunction* mutable_measure(); + void set_allocated_measure(::substrait::AggregateFunction* measure); private: - const ::io::substrait::AggregateFunction& _internal_measure() const; - ::io::substrait::AggregateFunction* _internal_mutable_measure(); + const ::substrait::AggregateFunction& _internal_measure() const; + ::substrait::AggregateFunction* _internal_mutable_measure(); public: void unsafe_arena_set_allocated_measure( - ::io::substrait::AggregateFunction* measure); - ::io::substrait::AggregateFunction* unsafe_arena_release_measure(); + ::substrait::AggregateFunction* measure); + ::substrait::AggregateFunction* unsafe_arena_release_measure(); - // .io.substrait.Expression filter = 2; + // .substrait.Expression filter = 2; bool has_filter() const; private: bool _internal_has_filter() const; public: void clear_filter(); - const ::io::substrait::Expression& filter() const; - ::io::substrait::Expression* release_filter(); - ::io::substrait::Expression* mutable_filter(); - void set_allocated_filter(::io::substrait::Expression* filter); + const ::substrait::Expression& filter() const; + ::substrait::Expression* release_filter(); + ::substrait::Expression* mutable_filter(); + void set_allocated_filter(::substrait::Expression* filter); private: - const ::io::substrait::Expression& _internal_filter() const; - ::io::substrait::Expression* _internal_mutable_filter(); + const ::substrait::Expression& _internal_filter() const; + ::substrait::Expression* _internal_mutable_filter(); public: void unsafe_arena_set_allocated_filter( - ::io::substrait::Expression* filter); - ::io::substrait::Expression* unsafe_arena_release_filter(); + ::substrait::Expression* filter); + ::substrait::Expression* unsafe_arena_release_filter(); - // @@protoc_insertion_point(class_scope:io.substrait.AggregateRel.Measure) + // @@protoc_insertion_point(class_scope:substrait.AggregateRel.Measure) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::AggregateFunction* measure_; - ::io::substrait::Expression* filter_; + ::substrait::AggregateFunction* measure_; + ::substrait::Expression* filter_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class AggregateRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.AggregateRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel) */ { public: inline AggregateRel() : AggregateRel(nullptr) {} ~AggregateRel() override; @@ -3518,7 +3543,7 @@ class AggregateRel PROTOBUF_FINAL : void InternalSwap(AggregateRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.AggregateRel"; + return "substrait.AggregateRel"; } protected: explicit AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3543,115 +3568,115 @@ class AggregateRel PROTOBUF_FINAL : kInputFieldNumber = 2, kAdvancedExtensionFieldNumber = 10, }; - // repeated .io.substrait.AggregateRel.Grouping groupings = 3; + // repeated .substrait.AggregateRel.Grouping groupings = 3; int groupings_size() const; private: int _internal_groupings_size() const; public: void clear_groupings(); - ::io::substrait::AggregateRel_Grouping* mutable_groupings(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >* + ::substrait::AggregateRel_Grouping* mutable_groupings(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >* mutable_groupings(); private: - const ::io::substrait::AggregateRel_Grouping& _internal_groupings(int index) const; - ::io::substrait::AggregateRel_Grouping* _internal_add_groupings(); + const ::substrait::AggregateRel_Grouping& _internal_groupings(int index) const; + ::substrait::AggregateRel_Grouping* _internal_add_groupings(); public: - const ::io::substrait::AggregateRel_Grouping& groupings(int index) const; - ::io::substrait::AggregateRel_Grouping* add_groupings(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >& + const ::substrait::AggregateRel_Grouping& groupings(int index) const; + ::substrait::AggregateRel_Grouping* add_groupings(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >& groupings() const; - // repeated .io.substrait.AggregateRel.Measure measures = 4; + // repeated .substrait.AggregateRel.Measure measures = 4; int measures_size() const; private: int _internal_measures_size() const; public: void clear_measures(); - ::io::substrait::AggregateRel_Measure* mutable_measures(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >* + ::substrait::AggregateRel_Measure* mutable_measures(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >* mutable_measures(); private: - const ::io::substrait::AggregateRel_Measure& _internal_measures(int index) const; - ::io::substrait::AggregateRel_Measure* _internal_add_measures(); + const ::substrait::AggregateRel_Measure& _internal_measures(int index) const; + ::substrait::AggregateRel_Measure* _internal_add_measures(); public: - const ::io::substrait::AggregateRel_Measure& measures(int index) const; - ::io::substrait::AggregateRel_Measure* add_measures(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >& + const ::substrait::AggregateRel_Measure& measures(int index) const; + ::substrait::AggregateRel_Measure* add_measures(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >& measures() const; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; bool has_input() const; private: bool _internal_has_input() const; public: void clear_input(); - const ::io::substrait::Rel& input() const; - ::io::substrait::Rel* release_input(); - ::io::substrait::Rel* mutable_input(); - void set_allocated_input(::io::substrait::Rel* input); + const ::substrait::Rel& input() const; + ::substrait::Rel* release_input(); + ::substrait::Rel* mutable_input(); + void set_allocated_input(::substrait::Rel* input); private: - const ::io::substrait::Rel& _internal_input() const; - ::io::substrait::Rel* _internal_mutable_input(); + const ::substrait::Rel& _internal_input() const; + ::substrait::Rel* _internal_mutable_input(); public: void unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input); - ::io::substrait::Rel* unsafe_arena_release_input(); + ::substrait::Rel* input); + ::substrait::Rel* unsafe_arena_release_input(); - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // @@protoc_insertion_point(class_scope:io.substrait.AggregateRel) + // @@protoc_insertion_point(class_scope:substrait.AggregateRel) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping > groupings_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure > measures_; - ::io::substrait::RelCommon* common_; - ::io::substrait::Rel* input_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping > groupings_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure > measures_; + ::substrait::RelCommon* common_; + ::substrait::Rel* input_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class SortRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.SortRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SortRel) */ { public: inline SortRel() : SortRel(nullptr) {} ~SortRel() override; @@ -3741,7 +3766,7 @@ class SortRel PROTOBUF_FINAL : void InternalSwap(SortRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.SortRel"; + return "substrait.SortRel"; } protected: explicit SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3762,96 +3787,96 @@ class SortRel PROTOBUF_FINAL : kInputFieldNumber = 2, kAdvancedExtensionFieldNumber = 10, }; - // repeated .io.substrait.SortField sorts = 3; + // repeated .substrait.SortField sorts = 3; int sorts_size() const; private: int _internal_sorts_size() const; public: void clear_sorts(); - ::io::substrait::SortField* mutable_sorts(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* + ::substrait::SortField* mutable_sorts(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* mutable_sorts(); private: - const ::io::substrait::SortField& _internal_sorts(int index) const; - ::io::substrait::SortField* _internal_add_sorts(); + const ::substrait::SortField& _internal_sorts(int index) const; + ::substrait::SortField* _internal_add_sorts(); public: - const ::io::substrait::SortField& sorts(int index) const; - ::io::substrait::SortField* add_sorts(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& + const ::substrait::SortField& sorts(int index) const; + ::substrait::SortField* add_sorts(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& sorts() const; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; bool has_input() const; private: bool _internal_has_input() const; public: void clear_input(); - const ::io::substrait::Rel& input() const; - ::io::substrait::Rel* release_input(); - ::io::substrait::Rel* mutable_input(); - void set_allocated_input(::io::substrait::Rel* input); + const ::substrait::Rel& input() const; + ::substrait::Rel* release_input(); + ::substrait::Rel* mutable_input(); + void set_allocated_input(::substrait::Rel* input); private: - const ::io::substrait::Rel& _internal_input() const; - ::io::substrait::Rel* _internal_mutable_input(); + const ::substrait::Rel& _internal_input() const; + ::substrait::Rel* _internal_mutable_input(); public: void unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input); - ::io::substrait::Rel* unsafe_arena_release_input(); + ::substrait::Rel* input); + ::substrait::Rel* unsafe_arena_release_input(); - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // @@protoc_insertion_point(class_scope:io.substrait.SortRel) + // @@protoc_insertion_point(class_scope:substrait.SortRel) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField > sorts_; - ::io::substrait::RelCommon* common_; - ::io::substrait::Rel* input_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField > sorts_; + ::substrait::RelCommon* common_; + ::substrait::Rel* input_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class FilterRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.FilterRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FilterRel) */ { public: inline FilterRel() : FilterRel(nullptr) {} ~FilterRel() override; @@ -3941,7 +3966,7 @@ class FilterRel PROTOBUF_FINAL : void InternalSwap(FilterRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.FilterRel"; + return "substrait.FilterRel"; } protected: explicit FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3962,96 +3987,96 @@ class FilterRel PROTOBUF_FINAL : kConditionFieldNumber = 3, kAdvancedExtensionFieldNumber = 10, }; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; bool has_input() const; private: bool _internal_has_input() const; public: void clear_input(); - const ::io::substrait::Rel& input() const; - ::io::substrait::Rel* release_input(); - ::io::substrait::Rel* mutable_input(); - void set_allocated_input(::io::substrait::Rel* input); + const ::substrait::Rel& input() const; + ::substrait::Rel* release_input(); + ::substrait::Rel* mutable_input(); + void set_allocated_input(::substrait::Rel* input); private: - const ::io::substrait::Rel& _internal_input() const; - ::io::substrait::Rel* _internal_mutable_input(); + const ::substrait::Rel& _internal_input() const; + ::substrait::Rel* _internal_mutable_input(); public: void unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input); - ::io::substrait::Rel* unsafe_arena_release_input(); + ::substrait::Rel* input); + ::substrait::Rel* unsafe_arena_release_input(); - // .io.substrait.Expression condition = 3; + // .substrait.Expression condition = 3; bool has_condition() const; private: bool _internal_has_condition() const; public: void clear_condition(); - const ::io::substrait::Expression& condition() const; - ::io::substrait::Expression* release_condition(); - ::io::substrait::Expression* mutable_condition(); - void set_allocated_condition(::io::substrait::Expression* condition); + const ::substrait::Expression& condition() const; + ::substrait::Expression* release_condition(); + ::substrait::Expression* mutable_condition(); + void set_allocated_condition(::substrait::Expression* condition); private: - const ::io::substrait::Expression& _internal_condition() const; - ::io::substrait::Expression* _internal_mutable_condition(); + const ::substrait::Expression& _internal_condition() const; + ::substrait::Expression* _internal_mutable_condition(); public: void unsafe_arena_set_allocated_condition( - ::io::substrait::Expression* condition); - ::io::substrait::Expression* unsafe_arena_release_condition(); + ::substrait::Expression* condition); + ::substrait::Expression* unsafe_arena_release_condition(); - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // @@protoc_insertion_point(class_scope:io.substrait.FilterRel) + // @@protoc_insertion_point(class_scope:substrait.FilterRel) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::RelCommon* common_; - ::io::substrait::Rel* input_; - ::io::substrait::Expression* condition_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::substrait::RelCommon* common_; + ::substrait::Rel* input_; + ::substrait::Expression* condition_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class SetRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.SetRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SetRel) */ { public: inline SetRel() : SetRel(nullptr) {} ~SetRel() override; @@ -4141,7 +4166,7 @@ class SetRel PROTOBUF_FINAL : void InternalSwap(SetRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.SetRel"; + return "substrait.SetRel"; } protected: explicit SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4155,20 +4180,20 @@ class SetRel PROTOBUF_FINAL : // nested types ---------------------------------------------------- typedef SetRel_SetOp SetOp; - static constexpr SetOp UNKNOWN = - SetRel_SetOp_UNKNOWN; - static constexpr SetOp MINUS_PRIMARY = - SetRel_SetOp_MINUS_PRIMARY; - static constexpr SetOp MINUS_MULTISET = - SetRel_SetOp_MINUS_MULTISET; - static constexpr SetOp INTERSECTION_PRIMARY = - SetRel_SetOp_INTERSECTION_PRIMARY; - static constexpr SetOp INTERSECTION_MULTISET = - SetRel_SetOp_INTERSECTION_MULTISET; - static constexpr SetOp UNION_DISTINCT = - SetRel_SetOp_UNION_DISTINCT; - static constexpr SetOp UNION_ALL = - SetRel_SetOp_UNION_ALL; + static constexpr SetOp SET_OP_UNSPECIFIED = + SetRel_SetOp_SET_OP_UNSPECIFIED; + static constexpr SetOp SET_OP_MINUS_PRIMARY = + SetRel_SetOp_SET_OP_MINUS_PRIMARY; + static constexpr SetOp SET_OP_MINUS_MULTISET = + SetRel_SetOp_SET_OP_MINUS_MULTISET; + static constexpr SetOp SET_OP_INTERSECTION_PRIMARY = + SetRel_SetOp_SET_OP_INTERSECTION_PRIMARY; + static constexpr SetOp SET_OP_INTERSECTION_MULTISET = + SetRel_SetOp_SET_OP_INTERSECTION_MULTISET; + static constexpr SetOp SET_OP_UNION_DISTINCT = + SetRel_SetOp_SET_OP_UNION_DISTINCT; + static constexpr SetOp SET_OP_UNION_ALL = + SetRel_SetOp_SET_OP_UNION_ALL; static inline bool SetOp_IsValid(int value) { return SetRel_SetOp_IsValid(value); } @@ -4202,87 +4227,87 @@ class SetRel PROTOBUF_FINAL : kAdvancedExtensionFieldNumber = 10, kOpFieldNumber = 3, }; - // repeated .io.substrait.Rel inputs = 2; + // repeated .substrait.Rel inputs = 2; int inputs_size() const; private: int _internal_inputs_size() const; public: void clear_inputs(); - ::io::substrait::Rel* mutable_inputs(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* + ::substrait::Rel* mutable_inputs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >* mutable_inputs(); private: - const ::io::substrait::Rel& _internal_inputs(int index) const; - ::io::substrait::Rel* _internal_add_inputs(); + const ::substrait::Rel& _internal_inputs(int index) const; + ::substrait::Rel* _internal_add_inputs(); public: - const ::io::substrait::Rel& inputs(int index) const; - ::io::substrait::Rel* add_inputs(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& + const ::substrait::Rel& inputs(int index) const; + ::substrait::Rel* add_inputs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >& inputs() const; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.extensions.AdvancedExtension advanced_extension = 10; + // .substrait.extensions.AdvancedExtension advanced_extension = 10; bool has_advanced_extension() const; private: bool _internal_has_advanced_extension() const; public: void clear_advanced_extension(); - const ::io::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::io::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension); + const ::substrait::extensions::AdvancedExtension& advanced_extension() const; + ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); + void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: - const ::io::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::io::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); + const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; + ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); public: void unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension); - ::io::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); + ::substrait::extensions::AdvancedExtension* advanced_extension); + ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - // .io.substrait.SetRel.SetOp op = 3; + // .substrait.SetRel.SetOp op = 3; void clear_op(); - ::io::substrait::SetRel_SetOp op() const; - void set_op(::io::substrait::SetRel_SetOp value); + ::substrait::SetRel_SetOp op() const; + void set_op(::substrait::SetRel_SetOp value); private: - ::io::substrait::SetRel_SetOp _internal_op() const; - void _internal_set_op(::io::substrait::SetRel_SetOp value); + ::substrait::SetRel_SetOp _internal_op() const; + void _internal_set_op(::substrait::SetRel_SetOp value); public: - // @@protoc_insertion_point(class_scope:io.substrait.SetRel) + // @@protoc_insertion_point(class_scope:substrait.SetRel) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel > inputs_; - ::io::substrait::RelCommon* common_; - ::io::substrait::extensions::AdvancedExtension* advanced_extension_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel > inputs_; + ::substrait::RelCommon* common_; + ::substrait::extensions::AdvancedExtension* advanced_extension_; int op_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class ExtensionSingleRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ExtensionSingleRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionSingleRel) */ { public: inline ExtensionSingleRel() : ExtensionSingleRel(nullptr) {} ~ExtensionSingleRel() override; @@ -4372,7 +4397,7 @@ class ExtensionSingleRel PROTOBUF_FINAL : void InternalSwap(ExtensionSingleRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ExtensionSingleRel"; + return "substrait.ExtensionSingleRel"; } protected: explicit ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4392,41 +4417,41 @@ class ExtensionSingleRel PROTOBUF_FINAL : kInputFieldNumber = 2, kDetailFieldNumber = 3, }; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); - // .io.substrait.Rel input = 2; + // .substrait.Rel input = 2; bool has_input() const; private: bool _internal_has_input() const; public: void clear_input(); - const ::io::substrait::Rel& input() const; - ::io::substrait::Rel* release_input(); - ::io::substrait::Rel* mutable_input(); - void set_allocated_input(::io::substrait::Rel* input); + const ::substrait::Rel& input() const; + ::substrait::Rel* release_input(); + ::substrait::Rel* mutable_input(); + void set_allocated_input(::substrait::Rel* input); private: - const ::io::substrait::Rel& _internal_input() const; - ::io::substrait::Rel* _internal_mutable_input(); + const ::substrait::Rel& _internal_input() const; + ::substrait::Rel* _internal_mutable_input(); public: void unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input); - ::io::substrait::Rel* unsafe_arena_release_input(); + ::substrait::Rel* input); + ::substrait::Rel* unsafe_arena_release_input(); // .google.protobuf.Any detail = 3; bool has_detail() const; @@ -4446,23 +4471,23 @@ class ExtensionSingleRel PROTOBUF_FINAL : PROTOBUF_NAMESPACE_ID::Any* detail); PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); - // @@protoc_insertion_point(class_scope:io.substrait.ExtensionSingleRel) + // @@protoc_insertion_point(class_scope:substrait.ExtensionSingleRel) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::RelCommon* common_; - ::io::substrait::Rel* input_; + ::substrait::RelCommon* common_; + ::substrait::Rel* input_; PROTOBUF_NAMESPACE_ID::Any* detail_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class ExtensionLeafRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ExtensionLeafRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionLeafRel) */ { public: inline ExtensionLeafRel() : ExtensionLeafRel(nullptr) {} ~ExtensionLeafRel() override; @@ -4552,7 +4577,7 @@ class ExtensionLeafRel PROTOBUF_FINAL : void InternalSwap(ExtensionLeafRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ExtensionLeafRel"; + return "substrait.ExtensionLeafRel"; } protected: explicit ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4571,23 +4596,23 @@ class ExtensionLeafRel PROTOBUF_FINAL : kCommonFieldNumber = 1, kDetailFieldNumber = 2, }; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); // .google.protobuf.Any detail = 2; bool has_detail() const; @@ -4607,22 +4632,22 @@ class ExtensionLeafRel PROTOBUF_FINAL : PROTOBUF_NAMESPACE_ID::Any* detail); PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); - // @@protoc_insertion_point(class_scope:io.substrait.ExtensionLeafRel) + // @@protoc_insertion_point(class_scope:substrait.ExtensionLeafRel) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::RelCommon* common_; + ::substrait::RelCommon* common_; PROTOBUF_NAMESPACE_ID::Any* detail_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class ExtensionMultiRel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.ExtensionMultiRel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionMultiRel) */ { public: inline ExtensionMultiRel() : ExtensionMultiRel(nullptr) {} ~ExtensionMultiRel() override; @@ -4712,7 +4737,7 @@ class ExtensionMultiRel PROTOBUF_FINAL : void InternalSwap(ExtensionMultiRel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.ExtensionMultiRel"; + return "substrait.ExtensionMultiRel"; } protected: explicit ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4732,41 +4757,41 @@ class ExtensionMultiRel PROTOBUF_FINAL : kCommonFieldNumber = 1, kDetailFieldNumber = 3, }; - // repeated .io.substrait.Rel inputs = 2; + // repeated .substrait.Rel inputs = 2; int inputs_size() const; private: int _internal_inputs_size() const; public: void clear_inputs(); - ::io::substrait::Rel* mutable_inputs(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* + ::substrait::Rel* mutable_inputs(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >* mutable_inputs(); private: - const ::io::substrait::Rel& _internal_inputs(int index) const; - ::io::substrait::Rel* _internal_add_inputs(); + const ::substrait::Rel& _internal_inputs(int index) const; + ::substrait::Rel* _internal_add_inputs(); public: - const ::io::substrait::Rel& inputs(int index) const; - ::io::substrait::Rel* add_inputs(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& + const ::substrait::Rel& inputs(int index) const; + ::substrait::Rel* add_inputs(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >& inputs() const; - // .io.substrait.RelCommon common = 1; + // .substrait.RelCommon common = 1; bool has_common() const; private: bool _internal_has_common() const; public: void clear_common(); - const ::io::substrait::RelCommon& common() const; - ::io::substrait::RelCommon* release_common(); - ::io::substrait::RelCommon* mutable_common(); - void set_allocated_common(::io::substrait::RelCommon* common); + const ::substrait::RelCommon& common() const; + ::substrait::RelCommon* release_common(); + ::substrait::RelCommon* mutable_common(); + void set_allocated_common(::substrait::RelCommon* common); private: - const ::io::substrait::RelCommon& _internal_common() const; - ::io::substrait::RelCommon* _internal_mutable_common(); + const ::substrait::RelCommon& _internal_common() const; + ::substrait::RelCommon* _internal_mutable_common(); public: void unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common); - ::io::substrait::RelCommon* unsafe_arena_release_common(); + ::substrait::RelCommon* common); + ::substrait::RelCommon* unsafe_arena_release_common(); // .google.protobuf.Any detail = 3; bool has_detail() const; @@ -4786,23 +4811,23 @@ class ExtensionMultiRel PROTOBUF_FINAL : PROTOBUF_NAMESPACE_ID::Any* detail); PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); - // @@protoc_insertion_point(class_scope:io.substrait.ExtensionMultiRel) + // @@protoc_insertion_point(class_scope:substrait.ExtensionMultiRel) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel > inputs_; - ::io::substrait::RelCommon* common_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel > inputs_; + ::substrait::RelCommon* common_; PROTOBUF_NAMESPACE_ID::Any* detail_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class RelRoot PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.RelRoot) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelRoot) */ { public: inline RelRoot() : RelRoot(nullptr) {} ~RelRoot() override; @@ -4892,7 +4917,7 @@ class RelRoot PROTOBUF_FINAL : void InternalSwap(RelRoot* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.RelRoot"; + return "substrait.RelRoot"; } protected: explicit RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4935,25 +4960,25 @@ class RelRoot PROTOBUF_FINAL : std::string* _internal_add_names(); public: - // .io.substrait.Rel input = 1; + // .substrait.Rel input = 1; bool has_input() const; private: bool _internal_has_input() const; public: void clear_input(); - const ::io::substrait::Rel& input() const; - ::io::substrait::Rel* release_input(); - ::io::substrait::Rel* mutable_input(); - void set_allocated_input(::io::substrait::Rel* input); + const ::substrait::Rel& input() const; + ::substrait::Rel* release_input(); + ::substrait::Rel* mutable_input(); + void set_allocated_input(::substrait::Rel* input); private: - const ::io::substrait::Rel& _internal_input() const; - ::io::substrait::Rel* _internal_mutable_input(); + const ::substrait::Rel& _internal_input() const; + ::substrait::Rel* _internal_mutable_input(); public: void unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input); - ::io::substrait::Rel* unsafe_arena_release_input(); + ::substrait::Rel* input); + ::substrait::Rel* unsafe_arena_release_input(); - // @@protoc_insertion_point(class_scope:io.substrait.RelRoot) + // @@protoc_insertion_point(class_scope:substrait.RelRoot) private: class _Internal; @@ -4961,14 +4986,14 @@ class RelRoot PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::io::substrait::Rel* input_; + ::substrait::Rel* input_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- class Rel PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Rel) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Rel) */ { public: inline Rel() : Rel(nullptr) {} ~Rel() override; @@ -5017,7 +5042,7 @@ class Rel PROTOBUF_FINAL : kExtensionSingle = 9, kExtensionMulti = 10, kExtensionLeaf = 11, - RELTYPE_NOT_SET = 0, + REL_TYPE_NOT_SET = 0, }; static inline const Rel* internal_default_instance() { @@ -5073,7 +5098,7 @@ class Rel PROTOBUF_FINAL : void InternalSwap(Rel* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Rel"; + return "substrait.Rel"; } protected: explicit Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -5101,207 +5126,207 @@ class Rel PROTOBUF_FINAL : kExtensionMultiFieldNumber = 10, kExtensionLeafFieldNumber = 11, }; - // .io.substrait.ReadRel read = 1; + // .substrait.ReadRel read = 1; bool has_read() const; private: bool _internal_has_read() const; public: void clear_read(); - const ::io::substrait::ReadRel& read() const; - ::io::substrait::ReadRel* release_read(); - ::io::substrait::ReadRel* mutable_read(); - void set_allocated_read(::io::substrait::ReadRel* read); + const ::substrait::ReadRel& read() const; + ::substrait::ReadRel* release_read(); + ::substrait::ReadRel* mutable_read(); + void set_allocated_read(::substrait::ReadRel* read); private: - const ::io::substrait::ReadRel& _internal_read() const; - ::io::substrait::ReadRel* _internal_mutable_read(); + const ::substrait::ReadRel& _internal_read() const; + ::substrait::ReadRel* _internal_mutable_read(); public: void unsafe_arena_set_allocated_read( - ::io::substrait::ReadRel* read); - ::io::substrait::ReadRel* unsafe_arena_release_read(); + ::substrait::ReadRel* read); + ::substrait::ReadRel* unsafe_arena_release_read(); - // .io.substrait.FilterRel filter = 2; + // .substrait.FilterRel filter = 2; bool has_filter() const; private: bool _internal_has_filter() const; public: void clear_filter(); - const ::io::substrait::FilterRel& filter() const; - ::io::substrait::FilterRel* release_filter(); - ::io::substrait::FilterRel* mutable_filter(); - void set_allocated_filter(::io::substrait::FilterRel* filter); + const ::substrait::FilterRel& filter() const; + ::substrait::FilterRel* release_filter(); + ::substrait::FilterRel* mutable_filter(); + void set_allocated_filter(::substrait::FilterRel* filter); private: - const ::io::substrait::FilterRel& _internal_filter() const; - ::io::substrait::FilterRel* _internal_mutable_filter(); + const ::substrait::FilterRel& _internal_filter() const; + ::substrait::FilterRel* _internal_mutable_filter(); public: void unsafe_arena_set_allocated_filter( - ::io::substrait::FilterRel* filter); - ::io::substrait::FilterRel* unsafe_arena_release_filter(); + ::substrait::FilterRel* filter); + ::substrait::FilterRel* unsafe_arena_release_filter(); - // .io.substrait.FetchRel fetch = 3; + // .substrait.FetchRel fetch = 3; bool has_fetch() const; private: bool _internal_has_fetch() const; public: void clear_fetch(); - const ::io::substrait::FetchRel& fetch() const; - ::io::substrait::FetchRel* release_fetch(); - ::io::substrait::FetchRel* mutable_fetch(); - void set_allocated_fetch(::io::substrait::FetchRel* fetch); + const ::substrait::FetchRel& fetch() const; + ::substrait::FetchRel* release_fetch(); + ::substrait::FetchRel* mutable_fetch(); + void set_allocated_fetch(::substrait::FetchRel* fetch); private: - const ::io::substrait::FetchRel& _internal_fetch() const; - ::io::substrait::FetchRel* _internal_mutable_fetch(); + const ::substrait::FetchRel& _internal_fetch() const; + ::substrait::FetchRel* _internal_mutable_fetch(); public: void unsafe_arena_set_allocated_fetch( - ::io::substrait::FetchRel* fetch); - ::io::substrait::FetchRel* unsafe_arena_release_fetch(); + ::substrait::FetchRel* fetch); + ::substrait::FetchRel* unsafe_arena_release_fetch(); - // .io.substrait.AggregateRel aggregate = 4; + // .substrait.AggregateRel aggregate = 4; bool has_aggregate() const; private: bool _internal_has_aggregate() const; public: void clear_aggregate(); - const ::io::substrait::AggregateRel& aggregate() const; - ::io::substrait::AggregateRel* release_aggregate(); - ::io::substrait::AggregateRel* mutable_aggregate(); - void set_allocated_aggregate(::io::substrait::AggregateRel* aggregate); + const ::substrait::AggregateRel& aggregate() const; + ::substrait::AggregateRel* release_aggregate(); + ::substrait::AggregateRel* mutable_aggregate(); + void set_allocated_aggregate(::substrait::AggregateRel* aggregate); private: - const ::io::substrait::AggregateRel& _internal_aggregate() const; - ::io::substrait::AggregateRel* _internal_mutable_aggregate(); + const ::substrait::AggregateRel& _internal_aggregate() const; + ::substrait::AggregateRel* _internal_mutable_aggregate(); public: void unsafe_arena_set_allocated_aggregate( - ::io::substrait::AggregateRel* aggregate); - ::io::substrait::AggregateRel* unsafe_arena_release_aggregate(); + ::substrait::AggregateRel* aggregate); + ::substrait::AggregateRel* unsafe_arena_release_aggregate(); - // .io.substrait.SortRel sort = 5; + // .substrait.SortRel sort = 5; bool has_sort() const; private: bool _internal_has_sort() const; public: void clear_sort(); - const ::io::substrait::SortRel& sort() const; - ::io::substrait::SortRel* release_sort(); - ::io::substrait::SortRel* mutable_sort(); - void set_allocated_sort(::io::substrait::SortRel* sort); + const ::substrait::SortRel& sort() const; + ::substrait::SortRel* release_sort(); + ::substrait::SortRel* mutable_sort(); + void set_allocated_sort(::substrait::SortRel* sort); private: - const ::io::substrait::SortRel& _internal_sort() const; - ::io::substrait::SortRel* _internal_mutable_sort(); + const ::substrait::SortRel& _internal_sort() const; + ::substrait::SortRel* _internal_mutable_sort(); public: void unsafe_arena_set_allocated_sort( - ::io::substrait::SortRel* sort); - ::io::substrait::SortRel* unsafe_arena_release_sort(); + ::substrait::SortRel* sort); + ::substrait::SortRel* unsafe_arena_release_sort(); - // .io.substrait.JoinRel join = 6; + // .substrait.JoinRel join = 6; bool has_join() const; private: bool _internal_has_join() const; public: void clear_join(); - const ::io::substrait::JoinRel& join() const; - ::io::substrait::JoinRel* release_join(); - ::io::substrait::JoinRel* mutable_join(); - void set_allocated_join(::io::substrait::JoinRel* join); + const ::substrait::JoinRel& join() const; + ::substrait::JoinRel* release_join(); + ::substrait::JoinRel* mutable_join(); + void set_allocated_join(::substrait::JoinRel* join); private: - const ::io::substrait::JoinRel& _internal_join() const; - ::io::substrait::JoinRel* _internal_mutable_join(); + const ::substrait::JoinRel& _internal_join() const; + ::substrait::JoinRel* _internal_mutable_join(); public: void unsafe_arena_set_allocated_join( - ::io::substrait::JoinRel* join); - ::io::substrait::JoinRel* unsafe_arena_release_join(); + ::substrait::JoinRel* join); + ::substrait::JoinRel* unsafe_arena_release_join(); - // .io.substrait.ProjectRel project = 7; + // .substrait.ProjectRel project = 7; bool has_project() const; private: bool _internal_has_project() const; public: void clear_project(); - const ::io::substrait::ProjectRel& project() const; - ::io::substrait::ProjectRel* release_project(); - ::io::substrait::ProjectRel* mutable_project(); - void set_allocated_project(::io::substrait::ProjectRel* project); + const ::substrait::ProjectRel& project() const; + ::substrait::ProjectRel* release_project(); + ::substrait::ProjectRel* mutable_project(); + void set_allocated_project(::substrait::ProjectRel* project); private: - const ::io::substrait::ProjectRel& _internal_project() const; - ::io::substrait::ProjectRel* _internal_mutable_project(); + const ::substrait::ProjectRel& _internal_project() const; + ::substrait::ProjectRel* _internal_mutable_project(); public: void unsafe_arena_set_allocated_project( - ::io::substrait::ProjectRel* project); - ::io::substrait::ProjectRel* unsafe_arena_release_project(); + ::substrait::ProjectRel* project); + ::substrait::ProjectRel* unsafe_arena_release_project(); - // .io.substrait.SetRel set = 8; + // .substrait.SetRel set = 8; bool has_set() const; private: bool _internal_has_set() const; public: void clear_set(); - const ::io::substrait::SetRel& set() const; - ::io::substrait::SetRel* release_set(); - ::io::substrait::SetRel* mutable_set(); - void set_allocated_set(::io::substrait::SetRel* set); + const ::substrait::SetRel& set() const; + ::substrait::SetRel* release_set(); + ::substrait::SetRel* mutable_set(); + void set_allocated_set(::substrait::SetRel* set); private: - const ::io::substrait::SetRel& _internal_set() const; - ::io::substrait::SetRel* _internal_mutable_set(); + const ::substrait::SetRel& _internal_set() const; + ::substrait::SetRel* _internal_mutable_set(); public: void unsafe_arena_set_allocated_set( - ::io::substrait::SetRel* set); - ::io::substrait::SetRel* unsafe_arena_release_set(); + ::substrait::SetRel* set); + ::substrait::SetRel* unsafe_arena_release_set(); - // .io.substrait.ExtensionSingleRel extension_single = 9; + // .substrait.ExtensionSingleRel extension_single = 9; bool has_extension_single() const; private: bool _internal_has_extension_single() const; public: void clear_extension_single(); - const ::io::substrait::ExtensionSingleRel& extension_single() const; - ::io::substrait::ExtensionSingleRel* release_extension_single(); - ::io::substrait::ExtensionSingleRel* mutable_extension_single(); - void set_allocated_extension_single(::io::substrait::ExtensionSingleRel* extension_single); + const ::substrait::ExtensionSingleRel& extension_single() const; + ::substrait::ExtensionSingleRel* release_extension_single(); + ::substrait::ExtensionSingleRel* mutable_extension_single(); + void set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single); private: - const ::io::substrait::ExtensionSingleRel& _internal_extension_single() const; - ::io::substrait::ExtensionSingleRel* _internal_mutable_extension_single(); + const ::substrait::ExtensionSingleRel& _internal_extension_single() const; + ::substrait::ExtensionSingleRel* _internal_mutable_extension_single(); public: void unsafe_arena_set_allocated_extension_single( - ::io::substrait::ExtensionSingleRel* extension_single); - ::io::substrait::ExtensionSingleRel* unsafe_arena_release_extension_single(); + ::substrait::ExtensionSingleRel* extension_single); + ::substrait::ExtensionSingleRel* unsafe_arena_release_extension_single(); - // .io.substrait.ExtensionMultiRel extension_multi = 10; + // .substrait.ExtensionMultiRel extension_multi = 10; bool has_extension_multi() const; private: bool _internal_has_extension_multi() const; public: void clear_extension_multi(); - const ::io::substrait::ExtensionMultiRel& extension_multi() const; - ::io::substrait::ExtensionMultiRel* release_extension_multi(); - ::io::substrait::ExtensionMultiRel* mutable_extension_multi(); - void set_allocated_extension_multi(::io::substrait::ExtensionMultiRel* extension_multi); + const ::substrait::ExtensionMultiRel& extension_multi() const; + ::substrait::ExtensionMultiRel* release_extension_multi(); + ::substrait::ExtensionMultiRel* mutable_extension_multi(); + void set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi); private: - const ::io::substrait::ExtensionMultiRel& _internal_extension_multi() const; - ::io::substrait::ExtensionMultiRel* _internal_mutable_extension_multi(); + const ::substrait::ExtensionMultiRel& _internal_extension_multi() const; + ::substrait::ExtensionMultiRel* _internal_mutable_extension_multi(); public: void unsafe_arena_set_allocated_extension_multi( - ::io::substrait::ExtensionMultiRel* extension_multi); - ::io::substrait::ExtensionMultiRel* unsafe_arena_release_extension_multi(); + ::substrait::ExtensionMultiRel* extension_multi); + ::substrait::ExtensionMultiRel* unsafe_arena_release_extension_multi(); - // .io.substrait.ExtensionLeafRel extension_leaf = 11; + // .substrait.ExtensionLeafRel extension_leaf = 11; bool has_extension_leaf() const; private: bool _internal_has_extension_leaf() const; public: void clear_extension_leaf(); - const ::io::substrait::ExtensionLeafRel& extension_leaf() const; - ::io::substrait::ExtensionLeafRel* release_extension_leaf(); - ::io::substrait::ExtensionLeafRel* mutable_extension_leaf(); - void set_allocated_extension_leaf(::io::substrait::ExtensionLeafRel* extension_leaf); + const ::substrait::ExtensionLeafRel& extension_leaf() const; + ::substrait::ExtensionLeafRel* release_extension_leaf(); + ::substrait::ExtensionLeafRel* mutable_extension_leaf(); + void set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf); private: - const ::io::substrait::ExtensionLeafRel& _internal_extension_leaf() const; - ::io::substrait::ExtensionLeafRel* _internal_mutable_extension_leaf(); + const ::substrait::ExtensionLeafRel& _internal_extension_leaf() const; + ::substrait::ExtensionLeafRel* _internal_mutable_extension_leaf(); public: void unsafe_arena_set_allocated_extension_leaf( - ::io::substrait::ExtensionLeafRel* extension_leaf); - ::io::substrait::ExtensionLeafRel* unsafe_arena_release_extension_leaf(); + ::substrait::ExtensionLeafRel* extension_leaf); + ::substrait::ExtensionLeafRel* unsafe_arena_release_extension_leaf(); - void clear_RelType(); - RelTypeCase RelType_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Rel) + void clear_rel_type(); + RelTypeCase rel_type_case() const; + // @@protoc_insertion_point(class_scope:substrait.Rel) private: class _Internal; void set_has_read(); @@ -5316,8 +5341,8 @@ class Rel PROTOBUF_FINAL : void set_has_extension_multi(); void set_has_extension_leaf(); - inline bool has_RelType() const; - inline void clear_has_RelType(); + inline bool has_rel_type() const; + inline void clear_has_rel_type(); template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; @@ -5325,22 +5350,22 @@ class Rel PROTOBUF_FINAL : union RelTypeUnion { constexpr RelTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::ReadRel* read_; - ::io::substrait::FilterRel* filter_; - ::io::substrait::FetchRel* fetch_; - ::io::substrait::AggregateRel* aggregate_; - ::io::substrait::SortRel* sort_; - ::io::substrait::JoinRel* join_; - ::io::substrait::ProjectRel* project_; - ::io::substrait::SetRel* set_; - ::io::substrait::ExtensionSingleRel* extension_single_; - ::io::substrait::ExtensionMultiRel* extension_multi_; - ::io::substrait::ExtensionLeafRel* extension_leaf_; - } RelType_; + ::substrait::ReadRel* read_; + ::substrait::FilterRel* filter_; + ::substrait::FetchRel* fetch_; + ::substrait::AggregateRel* aggregate_; + ::substrait::SortRel* sort_; + ::substrait::JoinRel* join_; + ::substrait::ProjectRel* project_; + ::substrait::SetRel* set_; + ::substrait::ExtensionSingleRel* extension_single_; + ::substrait::ExtensionMultiRel* extension_multi_; + ::substrait::ExtensionLeafRel* extension_leaf_; + } rel_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_relations_2eproto; + friend struct ::TableStruct_substrait_2frelations_2eproto; }; // =================================================================== @@ -5371,19 +5396,19 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 RelCommon_Emit::_internal_output_mapping(i return output_mapping_.Get(index); } inline ::PROTOBUF_NAMESPACE_ID::int32 RelCommon_Emit::output_mapping(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Emit.output_mapping) + // @@protoc_insertion_point(field_get:substrait.RelCommon.Emit.output_mapping) return _internal_output_mapping(index); } inline void RelCommon_Emit::set_output_mapping(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { output_mapping_.Set(index, value); - // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Emit.output_mapping) + // @@protoc_insertion_point(field_set:substrait.RelCommon.Emit.output_mapping) } inline void RelCommon_Emit::_internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value) { output_mapping_.Add(value); } inline void RelCommon_Emit::add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_add_output_mapping(value); - // @@protoc_insertion_point(field_add:io.substrait.RelCommon.Emit.output_mapping) + // @@protoc_insertion_point(field_add:substrait.RelCommon.Emit.output_mapping) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& RelCommon_Emit::_internal_output_mapping() const { @@ -5391,7 +5416,7 @@ RelCommon_Emit::_internal_output_mapping() const { } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& RelCommon_Emit::output_mapping() const { - // @@protoc_insertion_point(field_list:io.substrait.RelCommon.Emit.output_mapping) + // @@protoc_insertion_point(field_list:substrait.RelCommon.Emit.output_mapping) return _internal_output_mapping(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* @@ -5400,7 +5425,7 @@ RelCommon_Emit::_internal_mutable_output_mapping() { } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* RelCommon_Emit::mutable_output_mapping() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.RelCommon.Emit.output_mapping) + // @@protoc_insertion_point(field_mutable_list:substrait.RelCommon.Emit.output_mapping) return _internal_mutable_output_mapping(); } @@ -5416,7 +5441,7 @@ inline double RelCommon_Hint_Stats::_internal_row_count() const { return row_count_; } inline double RelCommon_Hint_Stats::row_count() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.Stats.row_count) + // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.Stats.row_count) return _internal_row_count(); } inline void RelCommon_Hint_Stats::_internal_set_row_count(double value) { @@ -5425,7 +5450,7 @@ inline void RelCommon_Hint_Stats::_internal_set_row_count(double value) { } inline void RelCommon_Hint_Stats::set_row_count(double value) { _internal_set_row_count(value); - // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.Stats.row_count) + // @@protoc_insertion_point(field_set:substrait.RelCommon.Hint.Stats.row_count) } // double record_size = 2; @@ -5436,7 +5461,7 @@ inline double RelCommon_Hint_Stats::_internal_record_size() const { return record_size_; } inline double RelCommon_Hint_Stats::record_size() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.Stats.record_size) + // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.Stats.record_size) return _internal_record_size(); } inline void RelCommon_Hint_Stats::_internal_set_record_size(double value) { @@ -5445,27 +5470,27 @@ inline void RelCommon_Hint_Stats::_internal_set_record_size(double value) { } inline void RelCommon_Hint_Stats::set_record_size(double value) { _internal_set_record_size(value); - // @@protoc_insertion_point(field_set:io.substrait.RelCommon.Hint.Stats.record_size) + // @@protoc_insertion_point(field_set:substrait.RelCommon.Hint.Stats.record_size) } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool RelCommon_Hint_Stats::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool RelCommon_Hint_Stats::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.Stats.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.Stats.advanced_extension) return _internal_advanced_extension(); } inline void RelCommon_Hint_Stats::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -5475,37 +5500,37 @@ inline void RelCommon_Hint_Stats::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.Stats.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.Stats.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.Stats.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.Stats.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.Stats.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.Stats.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void RelCommon_Hint_Stats::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void RelCommon_Hint_Stats::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -5522,31 +5547,31 @@ inline void RelCommon_Hint_Stats::set_allocated_advanced_extension(::io::substra } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.Stats.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.Stats.advanced_extension) } // ------------------------------------------------------------------- // RelCommon_Hint_RuntimeConstraint -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool RelCommon_Hint_RuntimeConstraint::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool RelCommon_Hint_RuntimeConstraint::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) return _internal_advanced_extension(); } inline void RelCommon_Hint_RuntimeConstraint::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -5556,37 +5581,37 @@ inline void RelCommon_Hint_RuntimeConstraint::unsafe_arena_set_allocated_advance } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void RelCommon_Hint_RuntimeConstraint::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void RelCommon_Hint_RuntimeConstraint::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -5603,14 +5628,14 @@ inline void RelCommon_Hint_RuntimeConstraint::set_allocated_advanced_extension(: } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) } // ------------------------------------------------------------------- // RelCommon_Hint -// .io.substrait.RelCommon.Hint.Stats stats = 1; +// .substrait.RelCommon.Hint.Stats stats = 1; inline bool RelCommon_Hint::_internal_has_stats() const { return this != internal_default_instance() && stats_ != nullptr; } @@ -5623,17 +5648,17 @@ inline void RelCommon_Hint::clear_stats() { } stats_ = nullptr; } -inline const ::io::substrait::RelCommon_Hint_Stats& RelCommon_Hint::_internal_stats() const { - const ::io::substrait::RelCommon_Hint_Stats* p = stats_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_Hint_Stats_default_instance_); +inline const ::substrait::RelCommon_Hint_Stats& RelCommon_Hint::_internal_stats() const { + const ::substrait::RelCommon_Hint_Stats* p = stats_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_Hint_Stats_default_instance_); } -inline const ::io::substrait::RelCommon_Hint_Stats& RelCommon_Hint::stats() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.stats) +inline const ::substrait::RelCommon_Hint_Stats& RelCommon_Hint::stats() const { + // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.stats) return _internal_stats(); } inline void RelCommon_Hint::unsafe_arena_set_allocated_stats( - ::io::substrait::RelCommon_Hint_Stats* stats) { + ::substrait::RelCommon_Hint_Stats* stats) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(stats_); } @@ -5643,37 +5668,37 @@ inline void RelCommon_Hint::unsafe_arena_set_allocated_stats( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.stats) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.stats) } -inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::release_stats() { +inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::release_stats() { - ::io::substrait::RelCommon_Hint_Stats* temp = stats_; + ::substrait::RelCommon_Hint_Stats* temp = stats_; stats_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::unsafe_arena_release_stats() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.stats) +inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::unsafe_arena_release_stats() { + // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.stats) - ::io::substrait::RelCommon_Hint_Stats* temp = stats_; + ::substrait::RelCommon_Hint_Stats* temp = stats_; stats_ = nullptr; return temp; } -inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::_internal_mutable_stats() { +inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::_internal_mutable_stats() { if (stats_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon_Hint_Stats>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint_Stats>(GetArena()); stats_ = p; } return stats_; } -inline ::io::substrait::RelCommon_Hint_Stats* RelCommon_Hint::mutable_stats() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.stats) +inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::mutable_stats() { + // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.stats) return _internal_mutable_stats(); } -inline void RelCommon_Hint::set_allocated_stats(::io::substrait::RelCommon_Hint_Stats* stats) { +inline void RelCommon_Hint::set_allocated_stats(::substrait::RelCommon_Hint_Stats* stats) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete stats_; @@ -5690,10 +5715,10 @@ inline void RelCommon_Hint::set_allocated_stats(::io::substrait::RelCommon_Hint_ } stats_ = stats; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.stats) + // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.stats) } -// .io.substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; +// .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; inline bool RelCommon_Hint::_internal_has_constraint() const { return this != internal_default_instance() && constraint_ != nullptr; } @@ -5706,17 +5731,17 @@ inline void RelCommon_Hint::clear_constraint() { } constraint_ = nullptr; } -inline const ::io::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::_internal_constraint() const { - const ::io::substrait::RelCommon_Hint_RuntimeConstraint* p = constraint_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_); +inline const ::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::_internal_constraint() const { + const ::substrait::RelCommon_Hint_RuntimeConstraint* p = constraint_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_); } -inline const ::io::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::constraint() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.constraint) +inline const ::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::constraint() const { + // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.constraint) return _internal_constraint(); } inline void RelCommon_Hint::unsafe_arena_set_allocated_constraint( - ::io::substrait::RelCommon_Hint_RuntimeConstraint* constraint) { + ::substrait::RelCommon_Hint_RuntimeConstraint* constraint) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(constraint_); } @@ -5726,37 +5751,37 @@ inline void RelCommon_Hint::unsafe_arena_set_allocated_constraint( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.constraint) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.constraint) } -inline ::io::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::release_constraint() { +inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::release_constraint() { - ::io::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_; + ::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_; constraint_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::unsafe_arena_release_constraint() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.constraint) +inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::unsafe_arena_release_constraint() { + // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.constraint) - ::io::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_; + ::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_; constraint_ = nullptr; return temp; } -inline ::io::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::_internal_mutable_constraint() { +inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::_internal_mutable_constraint() { if (constraint_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon_Hint_RuntimeConstraint>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint_RuntimeConstraint>(GetArena()); constraint_ = p; } return constraint_; } -inline ::io::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::mutable_constraint() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.constraint) +inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::mutable_constraint() { + // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.constraint) return _internal_mutable_constraint(); } -inline void RelCommon_Hint::set_allocated_constraint(::io::substrait::RelCommon_Hint_RuntimeConstraint* constraint) { +inline void RelCommon_Hint::set_allocated_constraint(::substrait::RelCommon_Hint_RuntimeConstraint* constraint) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete constraint_; @@ -5773,27 +5798,27 @@ inline void RelCommon_Hint::set_allocated_constraint(::io::substrait::RelCommon_ } constraint_ = constraint; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.constraint) + // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.constraint) } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool RelCommon_Hint::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool RelCommon_Hint::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& RelCommon_Hint::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.Hint.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.advanced_extension) return _internal_advanced_extension(); } inline void RelCommon_Hint::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -5803,37 +5828,37 @@ inline void RelCommon_Hint::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.Hint.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.Hint.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon_Hint::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.Hint.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void RelCommon_Hint::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void RelCommon_Hint::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -5850,14 +5875,14 @@ inline void RelCommon_Hint::set_allocated_advanced_extension(::io::substrait::ex } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.Hint.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.advanced_extension) } // ------------------------------------------------------------------- // RelCommon -// .io.substrait.RelCommon.Direct direct = 1; +// .substrait.RelCommon.Direct direct = 1; inline bool RelCommon::_internal_has_direct() const { return emit_kind_case() == kDirect; } @@ -5875,11 +5900,11 @@ inline void RelCommon::clear_direct() { clear_has_emit_kind(); } } -inline ::io::substrait::RelCommon_Direct* RelCommon::release_direct() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.direct) +inline ::substrait::RelCommon_Direct* RelCommon::release_direct() { + // @@protoc_insertion_point(field_release:substrait.RelCommon.direct) if (_internal_has_direct()) { clear_has_emit_kind(); - ::io::substrait::RelCommon_Direct* temp = emit_kind_.direct_; + ::substrait::RelCommon_Direct* temp = emit_kind_.direct_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5889,48 +5914,48 @@ inline ::io::substrait::RelCommon_Direct* RelCommon::release_direct() { return nullptr; } } -inline const ::io::substrait::RelCommon_Direct& RelCommon::_internal_direct() const { +inline const ::substrait::RelCommon_Direct& RelCommon::_internal_direct() const { return _internal_has_direct() ? *emit_kind_.direct_ - : reinterpret_cast< ::io::substrait::RelCommon_Direct&>(::io::substrait::_RelCommon_Direct_default_instance_); + : reinterpret_cast< ::substrait::RelCommon_Direct&>(::substrait::_RelCommon_Direct_default_instance_); } -inline const ::io::substrait::RelCommon_Direct& RelCommon::direct() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.direct) +inline const ::substrait::RelCommon_Direct& RelCommon::direct() const { + // @@protoc_insertion_point(field_get:substrait.RelCommon.direct) return _internal_direct(); } -inline ::io::substrait::RelCommon_Direct* RelCommon::unsafe_arena_release_direct() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.RelCommon.direct) +inline ::substrait::RelCommon_Direct* RelCommon::unsafe_arena_release_direct() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.RelCommon.direct) if (_internal_has_direct()) { clear_has_emit_kind(); - ::io::substrait::RelCommon_Direct* temp = emit_kind_.direct_; + ::substrait::RelCommon_Direct* temp = emit_kind_.direct_; emit_kind_.direct_ = nullptr; return temp; } else { return nullptr; } } -inline void RelCommon::unsafe_arena_set_allocated_direct(::io::substrait::RelCommon_Direct* direct) { +inline void RelCommon::unsafe_arena_set_allocated_direct(::substrait::RelCommon_Direct* direct) { clear_emit_kind(); if (direct) { set_has_direct(); emit_kind_.direct_ = direct; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.direct) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.direct) } -inline ::io::substrait::RelCommon_Direct* RelCommon::_internal_mutable_direct() { +inline ::substrait::RelCommon_Direct* RelCommon::_internal_mutable_direct() { if (!_internal_has_direct()) { clear_emit_kind(); set_has_direct(); - emit_kind_.direct_ = CreateMaybeMessage< ::io::substrait::RelCommon_Direct >(GetArena()); + emit_kind_.direct_ = CreateMaybeMessage< ::substrait::RelCommon_Direct >(GetArena()); } return emit_kind_.direct_; } -inline ::io::substrait::RelCommon_Direct* RelCommon::mutable_direct() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.direct) +inline ::substrait::RelCommon_Direct* RelCommon::mutable_direct() { + // @@protoc_insertion_point(field_mutable:substrait.RelCommon.direct) return _internal_mutable_direct(); } -// .io.substrait.RelCommon.Emit emit = 2; +// .substrait.RelCommon.Emit emit = 2; inline bool RelCommon::_internal_has_emit() const { return emit_kind_case() == kEmit; } @@ -5948,11 +5973,11 @@ inline void RelCommon::clear_emit() { clear_has_emit_kind(); } } -inline ::io::substrait::RelCommon_Emit* RelCommon::release_emit() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.emit) +inline ::substrait::RelCommon_Emit* RelCommon::release_emit() { + // @@protoc_insertion_point(field_release:substrait.RelCommon.emit) if (_internal_has_emit()) { clear_has_emit_kind(); - ::io::substrait::RelCommon_Emit* temp = emit_kind_.emit_; + ::substrait::RelCommon_Emit* temp = emit_kind_.emit_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5962,48 +5987,48 @@ inline ::io::substrait::RelCommon_Emit* RelCommon::release_emit() { return nullptr; } } -inline const ::io::substrait::RelCommon_Emit& RelCommon::_internal_emit() const { +inline const ::substrait::RelCommon_Emit& RelCommon::_internal_emit() const { return _internal_has_emit() ? *emit_kind_.emit_ - : reinterpret_cast< ::io::substrait::RelCommon_Emit&>(::io::substrait::_RelCommon_Emit_default_instance_); + : reinterpret_cast< ::substrait::RelCommon_Emit&>(::substrait::_RelCommon_Emit_default_instance_); } -inline const ::io::substrait::RelCommon_Emit& RelCommon::emit() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.emit) +inline const ::substrait::RelCommon_Emit& RelCommon::emit() const { + // @@protoc_insertion_point(field_get:substrait.RelCommon.emit) return _internal_emit(); } -inline ::io::substrait::RelCommon_Emit* RelCommon::unsafe_arena_release_emit() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.RelCommon.emit) +inline ::substrait::RelCommon_Emit* RelCommon::unsafe_arena_release_emit() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.RelCommon.emit) if (_internal_has_emit()) { clear_has_emit_kind(); - ::io::substrait::RelCommon_Emit* temp = emit_kind_.emit_; + ::substrait::RelCommon_Emit* temp = emit_kind_.emit_; emit_kind_.emit_ = nullptr; return temp; } else { return nullptr; } } -inline void RelCommon::unsafe_arena_set_allocated_emit(::io::substrait::RelCommon_Emit* emit) { +inline void RelCommon::unsafe_arena_set_allocated_emit(::substrait::RelCommon_Emit* emit) { clear_emit_kind(); if (emit) { set_has_emit(); emit_kind_.emit_ = emit; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.emit) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.emit) } -inline ::io::substrait::RelCommon_Emit* RelCommon::_internal_mutable_emit() { +inline ::substrait::RelCommon_Emit* RelCommon::_internal_mutable_emit() { if (!_internal_has_emit()) { clear_emit_kind(); set_has_emit(); - emit_kind_.emit_ = CreateMaybeMessage< ::io::substrait::RelCommon_Emit >(GetArena()); + emit_kind_.emit_ = CreateMaybeMessage< ::substrait::RelCommon_Emit >(GetArena()); } return emit_kind_.emit_; } -inline ::io::substrait::RelCommon_Emit* RelCommon::mutable_emit() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.emit) +inline ::substrait::RelCommon_Emit* RelCommon::mutable_emit() { + // @@protoc_insertion_point(field_mutable:substrait.RelCommon.emit) return _internal_mutable_emit(); } -// .io.substrait.RelCommon.Hint hint = 3; +// .substrait.RelCommon.Hint hint = 3; inline bool RelCommon::_internal_has_hint() const { return this != internal_default_instance() && hint_ != nullptr; } @@ -6016,17 +6041,17 @@ inline void RelCommon::clear_hint() { } hint_ = nullptr; } -inline const ::io::substrait::RelCommon_Hint& RelCommon::_internal_hint() const { - const ::io::substrait::RelCommon_Hint* p = hint_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_Hint_default_instance_); +inline const ::substrait::RelCommon_Hint& RelCommon::_internal_hint() const { + const ::substrait::RelCommon_Hint* p = hint_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_Hint_default_instance_); } -inline const ::io::substrait::RelCommon_Hint& RelCommon::hint() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.hint) +inline const ::substrait::RelCommon_Hint& RelCommon::hint() const { + // @@protoc_insertion_point(field_get:substrait.RelCommon.hint) return _internal_hint(); } inline void RelCommon::unsafe_arena_set_allocated_hint( - ::io::substrait::RelCommon_Hint* hint) { + ::substrait::RelCommon_Hint* hint) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hint_); } @@ -6036,37 +6061,37 @@ inline void RelCommon::unsafe_arena_set_allocated_hint( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.hint) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.hint) } -inline ::io::substrait::RelCommon_Hint* RelCommon::release_hint() { +inline ::substrait::RelCommon_Hint* RelCommon::release_hint() { - ::io::substrait::RelCommon_Hint* temp = hint_; + ::substrait::RelCommon_Hint* temp = hint_; hint_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon_Hint* RelCommon::unsafe_arena_release_hint() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.hint) +inline ::substrait::RelCommon_Hint* RelCommon::unsafe_arena_release_hint() { + // @@protoc_insertion_point(field_release:substrait.RelCommon.hint) - ::io::substrait::RelCommon_Hint* temp = hint_; + ::substrait::RelCommon_Hint* temp = hint_; hint_ = nullptr; return temp; } -inline ::io::substrait::RelCommon_Hint* RelCommon::_internal_mutable_hint() { +inline ::substrait::RelCommon_Hint* RelCommon::_internal_mutable_hint() { if (hint_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon_Hint>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint>(GetArena()); hint_ = p; } return hint_; } -inline ::io::substrait::RelCommon_Hint* RelCommon::mutable_hint() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.hint) +inline ::substrait::RelCommon_Hint* RelCommon::mutable_hint() { + // @@protoc_insertion_point(field_mutable:substrait.RelCommon.hint) return _internal_mutable_hint(); } -inline void RelCommon::set_allocated_hint(::io::substrait::RelCommon_Hint* hint) { +inline void RelCommon::set_allocated_hint(::substrait::RelCommon_Hint* hint) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete hint_; @@ -6083,27 +6108,27 @@ inline void RelCommon::set_allocated_hint(::io::substrait::RelCommon_Hint* hint) } hint_ = hint; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.hint) + // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.hint) } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 4; +// .substrait.extensions.AdvancedExtension advanced_extension = 4; inline bool RelCommon::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool RelCommon::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& RelCommon::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& RelCommon::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& RelCommon::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.RelCommon.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& RelCommon::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.RelCommon.advanced_extension) return _internal_advanced_extension(); } inline void RelCommon::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -6113,37 +6138,37 @@ inline void RelCommon::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelCommon.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* RelCommon::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.RelCommon.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* RelCommon::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.RelCommon.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* RelCommon::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* RelCommon::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelCommon.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* RelCommon::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.RelCommon.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void RelCommon::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void RelCommon::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -6160,7 +6185,7 @@ inline void RelCommon::set_allocated_advanced_extension(::io::substrait::extensi } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelCommon.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.advanced_extension) } inline bool RelCommon::has_emit_kind() const { @@ -6187,87 +6212,87 @@ inline void ReadRel_NamedTable::clear_names() { names_.Clear(); } inline std::string* ReadRel_NamedTable::add_names() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_add_mutable:substrait.ReadRel.NamedTable.names) return _internal_add_names(); } inline const std::string& ReadRel_NamedTable::_internal_names(int index) const { return names_.Get(index); } inline const std::string& ReadRel_NamedTable::names(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_get:substrait.ReadRel.NamedTable.names) return _internal_names(index); } inline std::string* ReadRel_NamedTable::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.NamedTable.names) return names_.Mutable(index); } inline void ReadRel_NamedTable::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_set:substrait.ReadRel.NamedTable.names) names_.Mutable(index)->assign(value); } inline void ReadRel_NamedTable::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_set:substrait.ReadRel.NamedTable.names) names_.Mutable(index)->assign(std::move(value)); } inline void ReadRel_NamedTable::set_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_set_char:substrait.ReadRel.NamedTable.names) } inline void ReadRel_NamedTable::set_names(int index, const char* value, size_t size) { names_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_set_pointer:substrait.ReadRel.NamedTable.names) } inline std::string* ReadRel_NamedTable::_internal_add_names() { return names_.Add(); } inline void ReadRel_NamedTable::add_names(const std::string& value) { names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_add:substrait.ReadRel.NamedTable.names) } inline void ReadRel_NamedTable::add_names(std::string&& value) { names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_add:substrait.ReadRel.NamedTable.names) } inline void ReadRel_NamedTable::add_names(const char* value) { GOOGLE_DCHECK(value != nullptr); names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_add_char:substrait.ReadRel.NamedTable.names) } inline void ReadRel_NamedTable::add_names(const char* value, size_t size) { names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_add_pointer:substrait.ReadRel.NamedTable.names) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& ReadRel_NamedTable::names() const { - // @@protoc_insertion_point(field_list:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_list:substrait.ReadRel.NamedTable.names) return names_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* ReadRel_NamedTable::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.NamedTable.names) + // @@protoc_insertion_point(field_mutable_list:substrait.ReadRel.NamedTable.names) return &names_; } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool ReadRel_NamedTable::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool ReadRel_NamedTable::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.NamedTable.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.NamedTable.advanced_extension) return _internal_advanced_extension(); } inline void ReadRel_NamedTable::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -6277,37 +6302,37 @@ inline void ReadRel_NamedTable::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.NamedTable.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.NamedTable.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.NamedTable.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.NamedTable.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.NamedTable.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.NamedTable.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void ReadRel_NamedTable::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void ReadRel_NamedTable::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -6324,46 +6349,46 @@ inline void ReadRel_NamedTable::set_allocated_advanced_extension(::io::substrait } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.NamedTable.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.NamedTable.advanced_extension) } // ------------------------------------------------------------------- // ReadRel_VirtualTable -// repeated .io.substrait.Expression.Literal.Struct values = 1; +// repeated .substrait.Expression.Literal.Struct values = 1; inline int ReadRel_VirtualTable::_internal_values_size() const { return values_.size(); } inline int ReadRel_VirtualTable::values_size() const { return _internal_values_size(); } -inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::mutable_values(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.VirtualTable.values) +inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::mutable_values(int index) { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.VirtualTable.values) return values_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >* ReadRel_VirtualTable::mutable_values() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.VirtualTable.values) + // @@protoc_insertion_point(field_mutable_list:substrait.ReadRel.VirtualTable.values) return &values_; } -inline const ::io::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::_internal_values(int index) const { +inline const ::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::_internal_values(int index) const { return values_.Get(index); } -inline const ::io::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::values(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.VirtualTable.values) +inline const ::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::values(int index) const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.VirtualTable.values) return _internal_values(index); } -inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::_internal_add_values() { +inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::_internal_add_values() { return values_.Add(); } -inline ::io::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::add_values() { - // @@protoc_insertion_point(field_add:io.substrait.ReadRel.VirtualTable.values) +inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::add_values() { + // @@protoc_insertion_point(field_add:substrait.ReadRel.VirtualTable.values) return _internal_add_values(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression_Literal_Struct >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >& ReadRel_VirtualTable::values() const { - // @@protoc_insertion_point(field_list:io.substrait.ReadRel.VirtualTable.values) + // @@protoc_insertion_point(field_list:substrait.ReadRel.VirtualTable.values) return values_; } @@ -6384,7 +6409,7 @@ inline const PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::_internal_detai PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } inline const PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::detail() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.ExtensionTable.detail) + // @@protoc_insertion_point(field_get:substrait.ReadRel.ExtensionTable.detail) return _internal_detail(); } inline void ReadRel_ExtensionTable::unsafe_arena_set_allocated_detail( @@ -6398,7 +6423,7 @@ inline void ReadRel_ExtensionTable::unsafe_arena_set_allocated_detail( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.ExtensionTable.detail) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.ExtensionTable.detail) } inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::release_detail() { @@ -6410,7 +6435,7 @@ inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::release_detail() { return temp; } inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::unsafe_arena_release_detail() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.ExtensionTable.detail) + // @@protoc_insertion_point(field_release:substrait.ReadRel.ExtensionTable.detail) PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; @@ -6425,7 +6450,7 @@ inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::_internal_mutable_det return detail_; } inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::mutable_detail() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.ExtensionTable.detail) + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.ExtensionTable.detail) return _internal_mutable_detail(); } inline void ReadRel_ExtensionTable::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { @@ -6445,7 +6470,7 @@ inline void ReadRel_ExtensionTable::set_allocated_detail(PROTOBUF_NAMESPACE_ID:: } detail_ = detail; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.ExtensionTable.detail) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.ExtensionTable.detail) } // ------------------------------------------------------------------- @@ -6469,7 +6494,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path() { } } inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) return _internal_uri_path(); } template @@ -6480,10 +6505,10 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path(ArgT0&& arg0, ArgT... a path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) } inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) return _internal_mutable_uri_path(); } inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path() const { @@ -6510,7 +6535,7 @@ inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path() ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) if (_internal_has_uri_path()) { clear_has_path_type(); return path_type_.uri_path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -6530,7 +6555,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path(std::string* arena->Own(uri_path); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) } // string uri_path_glob = 2; @@ -6550,7 +6575,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path_glob() { } } inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path_glob() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) return _internal_uri_path_glob(); } template @@ -6561,10 +6586,10 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path_glob(ArgT0&& arg0, ArgT path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) } inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path_glob() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) return _internal_mutable_uri_path_glob(); } inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path_glob() const { @@ -6591,7 +6616,7 @@ inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path_g ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path_glob() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) if (_internal_has_uri_path_glob()) { clear_has_path_type(); return path_type_.uri_path_glob_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -6611,7 +6636,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path_glob(std::str arena->Own(uri_path_glob); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) } // string uri_file = 3; @@ -6631,7 +6656,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_file() { } } inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_file() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) + // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) return _internal_uri_file(); } template @@ -6642,10 +6667,10 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_uri_file(ArgT0&& arg0, ArgT... a path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) + // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) } inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_file() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) return _internal_mutable_uri_file(); } inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_file() const { @@ -6672,7 +6697,7 @@ inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_file() ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_file() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) + // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) if (_internal_has_uri_file()) { clear_has_path_type(); return path_type_.uri_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -6692,7 +6717,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_file(std::string* arena->Own(uri_file); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) } // string uri_folder = 4; @@ -6712,7 +6737,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_folder() { } } inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_folder() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) + // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) return _internal_uri_folder(); } template @@ -6723,10 +6748,10 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_uri_folder(ArgT0&& arg0, ArgT... path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) + // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) } inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_folder() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) return _internal_mutable_uri_folder(); } inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_folder() const { @@ -6753,7 +6778,7 @@ inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_folder ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_folder() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) + // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) if (_internal_has_uri_folder()) { clear_has_path_type(); return path_type_.uri_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -6773,27 +6798,87 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_folder(std::string arena->Own(uri_folder); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) } -// .io.substrait.ReadRel.LocalFiles.FileOrFiles.Format format = 5; +// .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; inline void ReadRel_LocalFiles_FileOrFiles::clear_format() { format_ = 0; } -inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::_internal_format() const { - return static_cast< ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format >(format_); +inline ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::_internal_format() const { + return static_cast< ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat >(format_); } -inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format ReadRel_LocalFiles_FileOrFiles::format() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.FileOrFiles.format) +inline ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::format() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.format) return _internal_format(); } -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value) { +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value) { format_ = value; } -inline void ReadRel_LocalFiles_FileOrFiles::set_format(::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format value) { +inline void ReadRel_LocalFiles_FileOrFiles::set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value) { _internal_set_format(value); - // @@protoc_insertion_point(field_set:io.substrait.ReadRel.LocalFiles.FileOrFiles.format) + // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.format) +} + +// uint64 partition_index = 6; +inline void ReadRel_LocalFiles_FileOrFiles::clear_partition_index() { + partition_index_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::_internal_partition_index() const { + return partition_index_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::partition_index() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.partition_index) + return _internal_partition_index(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_partition_index(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + partition_index_ = value; +} +inline void ReadRel_LocalFiles_FileOrFiles::set_partition_index(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_partition_index(value); + // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.partition_index) +} + +// uint64 start = 7; +inline void ReadRel_LocalFiles_FileOrFiles::clear_start() { + start_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::_internal_start() const { + return start_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::start() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.start) + return _internal_start(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_start(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + start_ = value; +} +inline void ReadRel_LocalFiles_FileOrFiles::set_start(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_start(value); + // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.start) +} + +// uint64 length = 8; +inline void ReadRel_LocalFiles_FileOrFiles::clear_length() { + length_ = PROTOBUF_ULONGLONG(0); +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::_internal_length() const { + return length_; +} +inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::length() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.length) + return _internal_length(); +} +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_length(::PROTOBUF_NAMESPACE_ID::uint64 value) { + + length_ = value; +} +inline void ReadRel_LocalFiles_FileOrFiles::set_length(::PROTOBUF_NAMESPACE_ID::uint64 value) { + _internal_set_length(value); + // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.length) } inline bool ReadRel_LocalFiles_FileOrFiles::has_path_type() const { @@ -6809,7 +6894,7 @@ inline ReadRel_LocalFiles_FileOrFiles::PathTypeCase ReadRel_LocalFiles_FileOrFil // ReadRel_LocalFiles -// repeated .io.substrait.ReadRel.LocalFiles.FileOrFiles items = 1; +// repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; inline int ReadRel_LocalFiles::_internal_items_size() const { return items_.size(); } @@ -6819,53 +6904,53 @@ inline int ReadRel_LocalFiles::items_size() const { inline void ReadRel_LocalFiles::clear_items() { items_.Clear(); } -inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::mutable_items(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.items) +inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::mutable_items(int index) { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.items) return items_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >* ReadRel_LocalFiles::mutable_items() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ReadRel.LocalFiles.items) + // @@protoc_insertion_point(field_mutable_list:substrait.ReadRel.LocalFiles.items) return &items_; } -inline const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::_internal_items(int index) const { +inline const ::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::_internal_items(int index) const { return items_.Get(index); } -inline const ::io::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::items(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.items) +inline const ::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::items(int index) const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.items) return _internal_items(index); } -inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::_internal_add_items() { +inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::_internal_add_items() { return items_.Add(); } -inline ::io::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::add_items() { - // @@protoc_insertion_point(field_add:io.substrait.ReadRel.LocalFiles.items) +inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::add_items() { + // @@protoc_insertion_point(field_add:substrait.ReadRel.LocalFiles.items) return _internal_add_items(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::ReadRel_LocalFiles_FileOrFiles >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >& ReadRel_LocalFiles::items() const { - // @@protoc_insertion_point(field_list:io.substrait.ReadRel.LocalFiles.items) + // @@protoc_insertion_point(field_list:substrait.ReadRel.LocalFiles.items) return items_; } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool ReadRel_LocalFiles::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool ReadRel_LocalFiles::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.LocalFiles.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.advanced_extension) return _internal_advanced_extension(); } inline void ReadRel_LocalFiles::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -6875,37 +6960,37 @@ inline void ReadRel_LocalFiles::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.LocalFiles.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.LocalFiles.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.LocalFiles.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.LocalFiles.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void ReadRel_LocalFiles::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void ReadRel_LocalFiles::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -6922,14 +7007,14 @@ inline void ReadRel_LocalFiles::set_allocated_advanced_extension(::io::substrait } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.LocalFiles.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.advanced_extension) } // ------------------------------------------------------------------- // ReadRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool ReadRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -6942,17 +7027,17 @@ inline void ReadRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& ReadRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& ReadRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& ReadRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.common) +inline const ::substrait::RelCommon& ReadRel::common() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.common) return _internal_common(); } inline void ReadRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -6962,37 +7047,37 @@ inline void ReadRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.common) } -inline ::io::substrait::RelCommon* ReadRel::release_common() { +inline ::substrait::RelCommon* ReadRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* ReadRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.common) +inline ::substrait::RelCommon* ReadRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* ReadRel::_internal_mutable_common() { +inline ::substrait::RelCommon* ReadRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* ReadRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.common) +inline ::substrait::RelCommon* ReadRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.common) return _internal_mutable_common(); } -inline void ReadRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void ReadRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -7009,27 +7094,27 @@ inline void ReadRel::set_allocated_common(::io::substrait::RelCommon* common) { } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.common) } -// .io.substrait.NamedStruct base_schema = 2; +// .substrait.NamedStruct base_schema = 2; inline bool ReadRel::_internal_has_base_schema() const { return this != internal_default_instance() && base_schema_ != nullptr; } inline bool ReadRel::has_base_schema() const { return _internal_has_base_schema(); } -inline const ::io::substrait::NamedStruct& ReadRel::_internal_base_schema() const { - const ::io::substrait::NamedStruct* p = base_schema_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_NamedStruct_default_instance_); +inline const ::substrait::NamedStruct& ReadRel::_internal_base_schema() const { + const ::substrait::NamedStruct* p = base_schema_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_NamedStruct_default_instance_); } -inline const ::io::substrait::NamedStruct& ReadRel::base_schema() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.base_schema) +inline const ::substrait::NamedStruct& ReadRel::base_schema() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.base_schema) return _internal_base_schema(); } inline void ReadRel::unsafe_arena_set_allocated_base_schema( - ::io::substrait::NamedStruct* base_schema) { + ::substrait::NamedStruct* base_schema) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); } @@ -7039,37 +7124,37 @@ inline void ReadRel::unsafe_arena_set_allocated_base_schema( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.base_schema) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.base_schema) } -inline ::io::substrait::NamedStruct* ReadRel::release_base_schema() { +inline ::substrait::NamedStruct* ReadRel::release_base_schema() { - ::io::substrait::NamedStruct* temp = base_schema_; + ::substrait::NamedStruct* temp = base_schema_; base_schema_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::NamedStruct* ReadRel::unsafe_arena_release_base_schema() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.base_schema) +inline ::substrait::NamedStruct* ReadRel::unsafe_arena_release_base_schema() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.base_schema) - ::io::substrait::NamedStruct* temp = base_schema_; + ::substrait::NamedStruct* temp = base_schema_; base_schema_ = nullptr; return temp; } -inline ::io::substrait::NamedStruct* ReadRel::_internal_mutable_base_schema() { +inline ::substrait::NamedStruct* ReadRel::_internal_mutable_base_schema() { if (base_schema_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::NamedStruct>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::NamedStruct>(GetArena()); base_schema_ = p; } return base_schema_; } -inline ::io::substrait::NamedStruct* ReadRel::mutable_base_schema() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.base_schema) +inline ::substrait::NamedStruct* ReadRel::mutable_base_schema() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.base_schema) return _internal_mutable_base_schema(); } -inline void ReadRel::set_allocated_base_schema(::io::substrait::NamedStruct* base_schema) { +inline void ReadRel::set_allocated_base_schema(::substrait::NamedStruct* base_schema) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); @@ -7086,27 +7171,27 @@ inline void ReadRel::set_allocated_base_schema(::io::substrait::NamedStruct* bas } base_schema_ = base_schema; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.base_schema) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.base_schema) } -// .io.substrait.Expression filter = 3; +// .substrait.Expression filter = 3; inline bool ReadRel::_internal_has_filter() const { return this != internal_default_instance() && filter_ != nullptr; } inline bool ReadRel::has_filter() const { return _internal_has_filter(); } -inline const ::io::substrait::Expression& ReadRel::_internal_filter() const { - const ::io::substrait::Expression* p = filter_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& ReadRel::_internal_filter() const { + const ::substrait::Expression* p = filter_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& ReadRel::filter() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.filter) +inline const ::substrait::Expression& ReadRel::filter() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.filter) return _internal_filter(); } inline void ReadRel::unsafe_arena_set_allocated_filter( - ::io::substrait::Expression* filter) { + ::substrait::Expression* filter) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); } @@ -7116,37 +7201,37 @@ inline void ReadRel::unsafe_arena_set_allocated_filter( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.filter) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.filter) } -inline ::io::substrait::Expression* ReadRel::release_filter() { +inline ::substrait::Expression* ReadRel::release_filter() { - ::io::substrait::Expression* temp = filter_; + ::substrait::Expression* temp = filter_; filter_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* ReadRel::unsafe_arena_release_filter() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.filter) +inline ::substrait::Expression* ReadRel::unsafe_arena_release_filter() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.filter) - ::io::substrait::Expression* temp = filter_; + ::substrait::Expression* temp = filter_; filter_ = nullptr; return temp; } -inline ::io::substrait::Expression* ReadRel::_internal_mutable_filter() { +inline ::substrait::Expression* ReadRel::_internal_mutable_filter() { if (filter_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); filter_ = p; } return filter_; } -inline ::io::substrait::Expression* ReadRel::mutable_filter() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.filter) +inline ::substrait::Expression* ReadRel::mutable_filter() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.filter) return _internal_mutable_filter(); } -inline void ReadRel::set_allocated_filter(::io::substrait::Expression* filter) { +inline void ReadRel::set_allocated_filter(::substrait::Expression* filter) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); @@ -7163,27 +7248,27 @@ inline void ReadRel::set_allocated_filter(::io::substrait::Expression* filter) { } filter_ = filter; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.filter) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.filter) } -// .io.substrait.Expression.MaskExpression projection = 4; +// .substrait.Expression.MaskExpression projection = 4; inline bool ReadRel::_internal_has_projection() const { return this != internal_default_instance() && projection_ != nullptr; } inline bool ReadRel::has_projection() const { return _internal_has_projection(); } -inline const ::io::substrait::Expression_MaskExpression& ReadRel::_internal_projection() const { - const ::io::substrait::Expression_MaskExpression* p = projection_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_MaskExpression_default_instance_); +inline const ::substrait::Expression_MaskExpression& ReadRel::_internal_projection() const { + const ::substrait::Expression_MaskExpression* p = projection_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_MaskExpression_default_instance_); } -inline const ::io::substrait::Expression_MaskExpression& ReadRel::projection() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.projection) +inline const ::substrait::Expression_MaskExpression& ReadRel::projection() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.projection) return _internal_projection(); } inline void ReadRel::unsafe_arena_set_allocated_projection( - ::io::substrait::Expression_MaskExpression* projection) { + ::substrait::Expression_MaskExpression* projection) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); } @@ -7193,37 +7278,37 @@ inline void ReadRel::unsafe_arena_set_allocated_projection( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.projection) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.projection) } -inline ::io::substrait::Expression_MaskExpression* ReadRel::release_projection() { +inline ::substrait::Expression_MaskExpression* ReadRel::release_projection() { - ::io::substrait::Expression_MaskExpression* temp = projection_; + ::substrait::Expression_MaskExpression* temp = projection_; projection_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression_MaskExpression* ReadRel::unsafe_arena_release_projection() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.projection) +inline ::substrait::Expression_MaskExpression* ReadRel::unsafe_arena_release_projection() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.projection) - ::io::substrait::Expression_MaskExpression* temp = projection_; + ::substrait::Expression_MaskExpression* temp = projection_; projection_ = nullptr; return temp; } -inline ::io::substrait::Expression_MaskExpression* ReadRel::_internal_mutable_projection() { +inline ::substrait::Expression_MaskExpression* ReadRel::_internal_mutable_projection() { if (projection_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression_MaskExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression>(GetArena()); projection_ = p; } return projection_; } -inline ::io::substrait::Expression_MaskExpression* ReadRel::mutable_projection() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.projection) +inline ::substrait::Expression_MaskExpression* ReadRel::mutable_projection() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.projection) return _internal_mutable_projection(); } -inline void ReadRel::set_allocated_projection(::io::substrait::Expression_MaskExpression* projection) { +inline void ReadRel::set_allocated_projection(::substrait::Expression_MaskExpression* projection) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); @@ -7240,27 +7325,27 @@ inline void ReadRel::set_allocated_projection(::io::substrait::Expression_MaskEx } projection_ = projection; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.projection) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.projection) } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool ReadRel::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool ReadRel::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& ReadRel::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& ReadRel::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& ReadRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& ReadRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.advanced_extension) return _internal_advanced_extension(); } inline void ReadRel::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -7270,37 +7355,37 @@ inline void ReadRel::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* ReadRel::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* ReadRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* ReadRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* ReadRel::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* ReadRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void ReadRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void ReadRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -7317,10 +7402,10 @@ inline void ReadRel::set_allocated_advanced_extension(::io::substrait::extension } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ReadRel.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.advanced_extension) } -// .io.substrait.ReadRel.VirtualTable virtual_table = 5; +// .substrait.ReadRel.VirtualTable virtual_table = 5; inline bool ReadRel::_internal_has_virtual_table() const { return read_type_case() == kVirtualTable; } @@ -7338,11 +7423,11 @@ inline void ReadRel::clear_virtual_table() { clear_has_read_type(); } } -inline ::io::substrait::ReadRel_VirtualTable* ReadRel::release_virtual_table() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.virtual_table) +inline ::substrait::ReadRel_VirtualTable* ReadRel::release_virtual_table() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.virtual_table) if (_internal_has_virtual_table()) { clear_has_read_type(); - ::io::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; + ::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7352,48 +7437,48 @@ inline ::io::substrait::ReadRel_VirtualTable* ReadRel::release_virtual_table() { return nullptr; } } -inline const ::io::substrait::ReadRel_VirtualTable& ReadRel::_internal_virtual_table() const { +inline const ::substrait::ReadRel_VirtualTable& ReadRel::_internal_virtual_table() const { return _internal_has_virtual_table() ? *read_type_.virtual_table_ - : reinterpret_cast< ::io::substrait::ReadRel_VirtualTable&>(::io::substrait::_ReadRel_VirtualTable_default_instance_); + : reinterpret_cast< ::substrait::ReadRel_VirtualTable&>(::substrait::_ReadRel_VirtualTable_default_instance_); } -inline const ::io::substrait::ReadRel_VirtualTable& ReadRel::virtual_table() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.virtual_table) +inline const ::substrait::ReadRel_VirtualTable& ReadRel::virtual_table() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.virtual_table) return _internal_virtual_table(); } -inline ::io::substrait::ReadRel_VirtualTable* ReadRel::unsafe_arena_release_virtual_table() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.virtual_table) +inline ::substrait::ReadRel_VirtualTable* ReadRel::unsafe_arena_release_virtual_table() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.virtual_table) if (_internal_has_virtual_table()) { clear_has_read_type(); - ::io::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; + ::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; read_type_.virtual_table_ = nullptr; return temp; } else { return nullptr; } } -inline void ReadRel::unsafe_arena_set_allocated_virtual_table(::io::substrait::ReadRel_VirtualTable* virtual_table) { +inline void ReadRel::unsafe_arena_set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table) { clear_read_type(); if (virtual_table) { set_has_virtual_table(); read_type_.virtual_table_ = virtual_table; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.virtual_table) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.virtual_table) } -inline ::io::substrait::ReadRel_VirtualTable* ReadRel::_internal_mutable_virtual_table() { +inline ::substrait::ReadRel_VirtualTable* ReadRel::_internal_mutable_virtual_table() { if (!_internal_has_virtual_table()) { clear_read_type(); set_has_virtual_table(); - read_type_.virtual_table_ = CreateMaybeMessage< ::io::substrait::ReadRel_VirtualTable >(GetArena()); + read_type_.virtual_table_ = CreateMaybeMessage< ::substrait::ReadRel_VirtualTable >(GetArena()); } return read_type_.virtual_table_; } -inline ::io::substrait::ReadRel_VirtualTable* ReadRel::mutable_virtual_table() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.virtual_table) +inline ::substrait::ReadRel_VirtualTable* ReadRel::mutable_virtual_table() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.virtual_table) return _internal_mutable_virtual_table(); } -// .io.substrait.ReadRel.LocalFiles local_files = 6; +// .substrait.ReadRel.LocalFiles local_files = 6; inline bool ReadRel::_internal_has_local_files() const { return read_type_case() == kLocalFiles; } @@ -7411,11 +7496,11 @@ inline void ReadRel::clear_local_files() { clear_has_read_type(); } } -inline ::io::substrait::ReadRel_LocalFiles* ReadRel::release_local_files() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.local_files) +inline ::substrait::ReadRel_LocalFiles* ReadRel::release_local_files() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.local_files) if (_internal_has_local_files()) { clear_has_read_type(); - ::io::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; + ::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7425,48 +7510,48 @@ inline ::io::substrait::ReadRel_LocalFiles* ReadRel::release_local_files() { return nullptr; } } -inline const ::io::substrait::ReadRel_LocalFiles& ReadRel::_internal_local_files() const { +inline const ::substrait::ReadRel_LocalFiles& ReadRel::_internal_local_files() const { return _internal_has_local_files() ? *read_type_.local_files_ - : reinterpret_cast< ::io::substrait::ReadRel_LocalFiles&>(::io::substrait::_ReadRel_LocalFiles_default_instance_); + : reinterpret_cast< ::substrait::ReadRel_LocalFiles&>(::substrait::_ReadRel_LocalFiles_default_instance_); } -inline const ::io::substrait::ReadRel_LocalFiles& ReadRel::local_files() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.local_files) +inline const ::substrait::ReadRel_LocalFiles& ReadRel::local_files() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.local_files) return _internal_local_files(); } -inline ::io::substrait::ReadRel_LocalFiles* ReadRel::unsafe_arena_release_local_files() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.local_files) +inline ::substrait::ReadRel_LocalFiles* ReadRel::unsafe_arena_release_local_files() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.local_files) if (_internal_has_local_files()) { clear_has_read_type(); - ::io::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; + ::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; read_type_.local_files_ = nullptr; return temp; } else { return nullptr; } } -inline void ReadRel::unsafe_arena_set_allocated_local_files(::io::substrait::ReadRel_LocalFiles* local_files) { +inline void ReadRel::unsafe_arena_set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files) { clear_read_type(); if (local_files) { set_has_local_files(); read_type_.local_files_ = local_files; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.local_files) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.local_files) } -inline ::io::substrait::ReadRel_LocalFiles* ReadRel::_internal_mutable_local_files() { +inline ::substrait::ReadRel_LocalFiles* ReadRel::_internal_mutable_local_files() { if (!_internal_has_local_files()) { clear_read_type(); set_has_local_files(); - read_type_.local_files_ = CreateMaybeMessage< ::io::substrait::ReadRel_LocalFiles >(GetArena()); + read_type_.local_files_ = CreateMaybeMessage< ::substrait::ReadRel_LocalFiles >(GetArena()); } return read_type_.local_files_; } -inline ::io::substrait::ReadRel_LocalFiles* ReadRel::mutable_local_files() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.local_files) +inline ::substrait::ReadRel_LocalFiles* ReadRel::mutable_local_files() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.local_files) return _internal_mutable_local_files(); } -// .io.substrait.ReadRel.NamedTable named_table = 7; +// .substrait.ReadRel.NamedTable named_table = 7; inline bool ReadRel::_internal_has_named_table() const { return read_type_case() == kNamedTable; } @@ -7484,11 +7569,11 @@ inline void ReadRel::clear_named_table() { clear_has_read_type(); } } -inline ::io::substrait::ReadRel_NamedTable* ReadRel::release_named_table() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.named_table) +inline ::substrait::ReadRel_NamedTable* ReadRel::release_named_table() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.named_table) if (_internal_has_named_table()) { clear_has_read_type(); - ::io::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; + ::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7498,48 +7583,48 @@ inline ::io::substrait::ReadRel_NamedTable* ReadRel::release_named_table() { return nullptr; } } -inline const ::io::substrait::ReadRel_NamedTable& ReadRel::_internal_named_table() const { +inline const ::substrait::ReadRel_NamedTable& ReadRel::_internal_named_table() const { return _internal_has_named_table() ? *read_type_.named_table_ - : reinterpret_cast< ::io::substrait::ReadRel_NamedTable&>(::io::substrait::_ReadRel_NamedTable_default_instance_); + : reinterpret_cast< ::substrait::ReadRel_NamedTable&>(::substrait::_ReadRel_NamedTable_default_instance_); } -inline const ::io::substrait::ReadRel_NamedTable& ReadRel::named_table() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.named_table) +inline const ::substrait::ReadRel_NamedTable& ReadRel::named_table() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.named_table) return _internal_named_table(); } -inline ::io::substrait::ReadRel_NamedTable* ReadRel::unsafe_arena_release_named_table() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.named_table) +inline ::substrait::ReadRel_NamedTable* ReadRel::unsafe_arena_release_named_table() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.named_table) if (_internal_has_named_table()) { clear_has_read_type(); - ::io::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; + ::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; read_type_.named_table_ = nullptr; return temp; } else { return nullptr; } } -inline void ReadRel::unsafe_arena_set_allocated_named_table(::io::substrait::ReadRel_NamedTable* named_table) { +inline void ReadRel::unsafe_arena_set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table) { clear_read_type(); if (named_table) { set_has_named_table(); read_type_.named_table_ = named_table; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.named_table) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.named_table) } -inline ::io::substrait::ReadRel_NamedTable* ReadRel::_internal_mutable_named_table() { +inline ::substrait::ReadRel_NamedTable* ReadRel::_internal_mutable_named_table() { if (!_internal_has_named_table()) { clear_read_type(); set_has_named_table(); - read_type_.named_table_ = CreateMaybeMessage< ::io::substrait::ReadRel_NamedTable >(GetArena()); + read_type_.named_table_ = CreateMaybeMessage< ::substrait::ReadRel_NamedTable >(GetArena()); } return read_type_.named_table_; } -inline ::io::substrait::ReadRel_NamedTable* ReadRel::mutable_named_table() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.named_table) +inline ::substrait::ReadRel_NamedTable* ReadRel::mutable_named_table() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.named_table) return _internal_mutable_named_table(); } -// .io.substrait.ReadRel.ExtensionTable extension_table = 8; +// .substrait.ReadRel.ExtensionTable extension_table = 8; inline bool ReadRel::_internal_has_extension_table() const { return read_type_case() == kExtensionTable; } @@ -7557,11 +7642,11 @@ inline void ReadRel::clear_extension_table() { clear_has_read_type(); } } -inline ::io::substrait::ReadRel_ExtensionTable* ReadRel::release_extension_table() { - // @@protoc_insertion_point(field_release:io.substrait.ReadRel.extension_table) +inline ::substrait::ReadRel_ExtensionTable* ReadRel::release_extension_table() { + // @@protoc_insertion_point(field_release:substrait.ReadRel.extension_table) if (_internal_has_extension_table()) { clear_has_read_type(); - ::io::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_; + ::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7571,44 +7656,44 @@ inline ::io::substrait::ReadRel_ExtensionTable* ReadRel::release_extension_table return nullptr; } } -inline const ::io::substrait::ReadRel_ExtensionTable& ReadRel::_internal_extension_table() const { +inline const ::substrait::ReadRel_ExtensionTable& ReadRel::_internal_extension_table() const { return _internal_has_extension_table() ? *read_type_.extension_table_ - : reinterpret_cast< ::io::substrait::ReadRel_ExtensionTable&>(::io::substrait::_ReadRel_ExtensionTable_default_instance_); + : reinterpret_cast< ::substrait::ReadRel_ExtensionTable&>(::substrait::_ReadRel_ExtensionTable_default_instance_); } -inline const ::io::substrait::ReadRel_ExtensionTable& ReadRel::extension_table() const { - // @@protoc_insertion_point(field_get:io.substrait.ReadRel.extension_table) +inline const ::substrait::ReadRel_ExtensionTable& ReadRel::extension_table() const { + // @@protoc_insertion_point(field_get:substrait.ReadRel.extension_table) return _internal_extension_table(); } -inline ::io::substrait::ReadRel_ExtensionTable* ReadRel::unsafe_arena_release_extension_table() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.ReadRel.extension_table) +inline ::substrait::ReadRel_ExtensionTable* ReadRel::unsafe_arena_release_extension_table() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.extension_table) if (_internal_has_extension_table()) { clear_has_read_type(); - ::io::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_; + ::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_; read_type_.extension_table_ = nullptr; return temp; } else { return nullptr; } } -inline void ReadRel::unsafe_arena_set_allocated_extension_table(::io::substrait::ReadRel_ExtensionTable* extension_table) { +inline void ReadRel::unsafe_arena_set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table) { clear_read_type(); if (extension_table) { set_has_extension_table(); read_type_.extension_table_ = extension_table; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ReadRel.extension_table) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.extension_table) } -inline ::io::substrait::ReadRel_ExtensionTable* ReadRel::_internal_mutable_extension_table() { +inline ::substrait::ReadRel_ExtensionTable* ReadRel::_internal_mutable_extension_table() { if (!_internal_has_extension_table()) { clear_read_type(); set_has_extension_table(); - read_type_.extension_table_ = CreateMaybeMessage< ::io::substrait::ReadRel_ExtensionTable >(GetArena()); + read_type_.extension_table_ = CreateMaybeMessage< ::substrait::ReadRel_ExtensionTable >(GetArena()); } return read_type_.extension_table_; } -inline ::io::substrait::ReadRel_ExtensionTable* ReadRel::mutable_extension_table() { - // @@protoc_insertion_point(field_mutable:io.substrait.ReadRel.extension_table) +inline ::substrait::ReadRel_ExtensionTable* ReadRel::mutable_extension_table() { + // @@protoc_insertion_point(field_mutable:substrait.ReadRel.extension_table) return _internal_mutable_extension_table(); } @@ -7625,7 +7710,7 @@ inline ReadRel::ReadTypeCase ReadRel::read_type_case() const { // ProjectRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool ProjectRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -7638,17 +7723,17 @@ inline void ProjectRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& ProjectRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& ProjectRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& ProjectRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.common) +inline const ::substrait::RelCommon& ProjectRel::common() const { + // @@protoc_insertion_point(field_get:substrait.ProjectRel.common) return _internal_common(); } inline void ProjectRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -7658,37 +7743,37 @@ inline void ProjectRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ProjectRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ProjectRel.common) } -inline ::io::substrait::RelCommon* ProjectRel::release_common() { +inline ::substrait::RelCommon* ProjectRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* ProjectRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.ProjectRel.common) +inline ::substrait::RelCommon* ProjectRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.ProjectRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* ProjectRel::_internal_mutable_common() { +inline ::substrait::RelCommon* ProjectRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* ProjectRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.common) +inline ::substrait::RelCommon* ProjectRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.common) return _internal_mutable_common(); } -inline void ProjectRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void ProjectRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -7705,10 +7790,10 @@ inline void ProjectRel::set_allocated_common(::io::substrait::RelCommon* common) } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ProjectRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.ProjectRel.common) } -// .io.substrait.Rel input = 2; +// .substrait.Rel input = 2; inline bool ProjectRel::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } @@ -7721,17 +7806,17 @@ inline void ProjectRel::clear_input() { } input_ = nullptr; } -inline const ::io::substrait::Rel& ProjectRel::_internal_input() const { - const ::io::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::substrait::Rel& ProjectRel::_internal_input() const { + const ::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& ProjectRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.input) +inline const ::substrait::Rel& ProjectRel::input() const { + // @@protoc_insertion_point(field_get:substrait.ProjectRel.input) return _internal_input(); } inline void ProjectRel::unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input) { + ::substrait::Rel* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } @@ -7741,37 +7826,37 @@ inline void ProjectRel::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ProjectRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ProjectRel.input) } -inline ::io::substrait::Rel* ProjectRel::release_input() { +inline ::substrait::Rel* ProjectRel::release_input() { - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* ProjectRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.ProjectRel.input) +inline ::substrait::Rel* ProjectRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:substrait.ProjectRel.input) - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Rel* ProjectRel::_internal_mutable_input() { +inline ::substrait::Rel* ProjectRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); input_ = p; } return input_; } -inline ::io::substrait::Rel* ProjectRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.input) +inline ::substrait::Rel* ProjectRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.input) return _internal_mutable_input(); } -inline void ProjectRel::set_allocated_input(::io::substrait::Rel* input) { +inline void ProjectRel::set_allocated_input(::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -7788,63 +7873,63 @@ inline void ProjectRel::set_allocated_input(::io::substrait::Rel* input) { } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ProjectRel.input) + // @@protoc_insertion_point(field_set_allocated:substrait.ProjectRel.input) } -// repeated .io.substrait.Expression expressions = 3; +// repeated .substrait.Expression expressions = 3; inline int ProjectRel::_internal_expressions_size() const { return expressions_.size(); } inline int ProjectRel::expressions_size() const { return _internal_expressions_size(); } -inline ::io::substrait::Expression* ProjectRel::mutable_expressions(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.expressions) +inline ::substrait::Expression* ProjectRel::mutable_expressions(int index) { + // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.expressions) return expressions_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* ProjectRel::mutable_expressions() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ProjectRel.expressions) + // @@protoc_insertion_point(field_mutable_list:substrait.ProjectRel.expressions) return &expressions_; } -inline const ::io::substrait::Expression& ProjectRel::_internal_expressions(int index) const { +inline const ::substrait::Expression& ProjectRel::_internal_expressions(int index) const { return expressions_.Get(index); } -inline const ::io::substrait::Expression& ProjectRel::expressions(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.expressions) +inline const ::substrait::Expression& ProjectRel::expressions(int index) const { + // @@protoc_insertion_point(field_get:substrait.ProjectRel.expressions) return _internal_expressions(index); } -inline ::io::substrait::Expression* ProjectRel::_internal_add_expressions() { +inline ::substrait::Expression* ProjectRel::_internal_add_expressions() { return expressions_.Add(); } -inline ::io::substrait::Expression* ProjectRel::add_expressions() { - // @@protoc_insertion_point(field_add:io.substrait.ProjectRel.expressions) +inline ::substrait::Expression* ProjectRel::add_expressions() { + // @@protoc_insertion_point(field_add:substrait.ProjectRel.expressions) return _internal_add_expressions(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Expression >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& ProjectRel::expressions() const { - // @@protoc_insertion_point(field_list:io.substrait.ProjectRel.expressions) + // @@protoc_insertion_point(field_list:substrait.ProjectRel.expressions) return expressions_; } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool ProjectRel::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool ProjectRel::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& ProjectRel::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& ProjectRel::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& ProjectRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.ProjectRel.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& ProjectRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.ProjectRel.advanced_extension) return _internal_advanced_extension(); } inline void ProjectRel::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -7854,37 +7939,37 @@ inline void ProjectRel::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ProjectRel.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ProjectRel.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* ProjectRel::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* ProjectRel::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* ProjectRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.ProjectRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* ProjectRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.ProjectRel.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* ProjectRel::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* ProjectRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* ProjectRel::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.ProjectRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* ProjectRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void ProjectRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void ProjectRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -7901,14 +7986,14 @@ inline void ProjectRel::set_allocated_advanced_extension(::io::substrait::extens } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ProjectRel.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.ProjectRel.advanced_extension) } // ------------------------------------------------------------------- // JoinRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool JoinRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -7921,17 +8006,17 @@ inline void JoinRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& JoinRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& JoinRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& JoinRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.common) +inline const ::substrait::RelCommon& JoinRel::common() const { + // @@protoc_insertion_point(field_get:substrait.JoinRel.common) return _internal_common(); } inline void JoinRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -7941,37 +8026,37 @@ inline void JoinRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.common) } -inline ::io::substrait::RelCommon* JoinRel::release_common() { +inline ::substrait::RelCommon* JoinRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* JoinRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.common) +inline ::substrait::RelCommon* JoinRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.JoinRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* JoinRel::_internal_mutable_common() { +inline ::substrait::RelCommon* JoinRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* JoinRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.common) +inline ::substrait::RelCommon* JoinRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.JoinRel.common) return _internal_mutable_common(); } -inline void JoinRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void JoinRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -7988,10 +8073,10 @@ inline void JoinRel::set_allocated_common(::io::substrait::RelCommon* common) { } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.common) } -// .io.substrait.Rel left = 2; +// .substrait.Rel left = 2; inline bool JoinRel::_internal_has_left() const { return this != internal_default_instance() && left_ != nullptr; } @@ -8004,17 +8089,17 @@ inline void JoinRel::clear_left() { } left_ = nullptr; } -inline const ::io::substrait::Rel& JoinRel::_internal_left() const { - const ::io::substrait::Rel* p = left_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::substrait::Rel& JoinRel::_internal_left() const { + const ::substrait::Rel* p = left_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& JoinRel::left() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.left) +inline const ::substrait::Rel& JoinRel::left() const { + // @@protoc_insertion_point(field_get:substrait.JoinRel.left) return _internal_left(); } inline void JoinRel::unsafe_arena_set_allocated_left( - ::io::substrait::Rel* left) { + ::substrait::Rel* left) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(left_); } @@ -8024,37 +8109,37 @@ inline void JoinRel::unsafe_arena_set_allocated_left( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.left) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.left) } -inline ::io::substrait::Rel* JoinRel::release_left() { +inline ::substrait::Rel* JoinRel::release_left() { - ::io::substrait::Rel* temp = left_; + ::substrait::Rel* temp = left_; left_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* JoinRel::unsafe_arena_release_left() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.left) +inline ::substrait::Rel* JoinRel::unsafe_arena_release_left() { + // @@protoc_insertion_point(field_release:substrait.JoinRel.left) - ::io::substrait::Rel* temp = left_; + ::substrait::Rel* temp = left_; left_ = nullptr; return temp; } -inline ::io::substrait::Rel* JoinRel::_internal_mutable_left() { +inline ::substrait::Rel* JoinRel::_internal_mutable_left() { if (left_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); left_ = p; } return left_; } -inline ::io::substrait::Rel* JoinRel::mutable_left() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.left) +inline ::substrait::Rel* JoinRel::mutable_left() { + // @@protoc_insertion_point(field_mutable:substrait.JoinRel.left) return _internal_mutable_left(); } -inline void JoinRel::set_allocated_left(::io::substrait::Rel* left) { +inline void JoinRel::set_allocated_left(::substrait::Rel* left) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete left_; @@ -8071,10 +8156,10 @@ inline void JoinRel::set_allocated_left(::io::substrait::Rel* left) { } left_ = left; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.left) + // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.left) } -// .io.substrait.Rel right = 3; +// .substrait.Rel right = 3; inline bool JoinRel::_internal_has_right() const { return this != internal_default_instance() && right_ != nullptr; } @@ -8087,17 +8172,17 @@ inline void JoinRel::clear_right() { } right_ = nullptr; } -inline const ::io::substrait::Rel& JoinRel::_internal_right() const { - const ::io::substrait::Rel* p = right_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::substrait::Rel& JoinRel::_internal_right() const { + const ::substrait::Rel* p = right_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& JoinRel::right() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.right) +inline const ::substrait::Rel& JoinRel::right() const { + // @@protoc_insertion_point(field_get:substrait.JoinRel.right) return _internal_right(); } inline void JoinRel::unsafe_arena_set_allocated_right( - ::io::substrait::Rel* right) { + ::substrait::Rel* right) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(right_); } @@ -8107,37 +8192,37 @@ inline void JoinRel::unsafe_arena_set_allocated_right( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.right) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.right) } -inline ::io::substrait::Rel* JoinRel::release_right() { +inline ::substrait::Rel* JoinRel::release_right() { - ::io::substrait::Rel* temp = right_; + ::substrait::Rel* temp = right_; right_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* JoinRel::unsafe_arena_release_right() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.right) +inline ::substrait::Rel* JoinRel::unsafe_arena_release_right() { + // @@protoc_insertion_point(field_release:substrait.JoinRel.right) - ::io::substrait::Rel* temp = right_; + ::substrait::Rel* temp = right_; right_ = nullptr; return temp; } -inline ::io::substrait::Rel* JoinRel::_internal_mutable_right() { +inline ::substrait::Rel* JoinRel::_internal_mutable_right() { if (right_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); right_ = p; } return right_; } -inline ::io::substrait::Rel* JoinRel::mutable_right() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.right) +inline ::substrait::Rel* JoinRel::mutable_right() { + // @@protoc_insertion_point(field_mutable:substrait.JoinRel.right) return _internal_mutable_right(); } -inline void JoinRel::set_allocated_right(::io::substrait::Rel* right) { +inline void JoinRel::set_allocated_right(::substrait::Rel* right) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete right_; @@ -8154,27 +8239,27 @@ inline void JoinRel::set_allocated_right(::io::substrait::Rel* right) { } right_ = right; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.right) + // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.right) } -// .io.substrait.Expression expression = 4; +// .substrait.Expression expression = 4; inline bool JoinRel::_internal_has_expression() const { return this != internal_default_instance() && expression_ != nullptr; } inline bool JoinRel::has_expression() const { return _internal_has_expression(); } -inline const ::io::substrait::Expression& JoinRel::_internal_expression() const { - const ::io::substrait::Expression* p = expression_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& JoinRel::_internal_expression() const { + const ::substrait::Expression* p = expression_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& JoinRel::expression() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.expression) +inline const ::substrait::Expression& JoinRel::expression() const { + // @@protoc_insertion_point(field_get:substrait.JoinRel.expression) return _internal_expression(); } inline void JoinRel::unsafe_arena_set_allocated_expression( - ::io::substrait::Expression* expression) { + ::substrait::Expression* expression) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); } @@ -8184,37 +8269,37 @@ inline void JoinRel::unsafe_arena_set_allocated_expression( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.expression) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.expression) } -inline ::io::substrait::Expression* JoinRel::release_expression() { +inline ::substrait::Expression* JoinRel::release_expression() { - ::io::substrait::Expression* temp = expression_; + ::substrait::Expression* temp = expression_; expression_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* JoinRel::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.expression) +inline ::substrait::Expression* JoinRel::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_release:substrait.JoinRel.expression) - ::io::substrait::Expression* temp = expression_; + ::substrait::Expression* temp = expression_; expression_ = nullptr; return temp; } -inline ::io::substrait::Expression* JoinRel::_internal_mutable_expression() { +inline ::substrait::Expression* JoinRel::_internal_mutable_expression() { if (expression_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); expression_ = p; } return expression_; } -inline ::io::substrait::Expression* JoinRel::mutable_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.expression) +inline ::substrait::Expression* JoinRel::mutable_expression() { + // @@protoc_insertion_point(field_mutable:substrait.JoinRel.expression) return _internal_mutable_expression(); } -inline void JoinRel::set_allocated_expression(::io::substrait::Expression* expression) { +inline void JoinRel::set_allocated_expression(::substrait::Expression* expression) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); @@ -8231,27 +8316,27 @@ inline void JoinRel::set_allocated_expression(::io::substrait::Expression* expre } expression_ = expression; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.expression) + // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.expression) } -// .io.substrait.Expression post_join_filter = 5; +// .substrait.Expression post_join_filter = 5; inline bool JoinRel::_internal_has_post_join_filter() const { return this != internal_default_instance() && post_join_filter_ != nullptr; } inline bool JoinRel::has_post_join_filter() const { return _internal_has_post_join_filter(); } -inline const ::io::substrait::Expression& JoinRel::_internal_post_join_filter() const { - const ::io::substrait::Expression* p = post_join_filter_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& JoinRel::_internal_post_join_filter() const { + const ::substrait::Expression* p = post_join_filter_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& JoinRel::post_join_filter() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.post_join_filter) +inline const ::substrait::Expression& JoinRel::post_join_filter() const { + // @@protoc_insertion_point(field_get:substrait.JoinRel.post_join_filter) return _internal_post_join_filter(); } inline void JoinRel::unsafe_arena_set_allocated_post_join_filter( - ::io::substrait::Expression* post_join_filter) { + ::substrait::Expression* post_join_filter) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); } @@ -8261,37 +8346,37 @@ inline void JoinRel::unsafe_arena_set_allocated_post_join_filter( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.post_join_filter) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.post_join_filter) } -inline ::io::substrait::Expression* JoinRel::release_post_join_filter() { +inline ::substrait::Expression* JoinRel::release_post_join_filter() { - ::io::substrait::Expression* temp = post_join_filter_; + ::substrait::Expression* temp = post_join_filter_; post_join_filter_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* JoinRel::unsafe_arena_release_post_join_filter() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.post_join_filter) +inline ::substrait::Expression* JoinRel::unsafe_arena_release_post_join_filter() { + // @@protoc_insertion_point(field_release:substrait.JoinRel.post_join_filter) - ::io::substrait::Expression* temp = post_join_filter_; + ::substrait::Expression* temp = post_join_filter_; post_join_filter_ = nullptr; return temp; } -inline ::io::substrait::Expression* JoinRel::_internal_mutable_post_join_filter() { +inline ::substrait::Expression* JoinRel::_internal_mutable_post_join_filter() { if (post_join_filter_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); post_join_filter_ = p; } return post_join_filter_; } -inline ::io::substrait::Expression* JoinRel::mutable_post_join_filter() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.post_join_filter) +inline ::substrait::Expression* JoinRel::mutable_post_join_filter() { + // @@protoc_insertion_point(field_mutable:substrait.JoinRel.post_join_filter) return _internal_mutable_post_join_filter(); } -inline void JoinRel::set_allocated_post_join_filter(::io::substrait::Expression* post_join_filter) { +inline void JoinRel::set_allocated_post_join_filter(::substrait::Expression* post_join_filter) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); @@ -8308,47 +8393,47 @@ inline void JoinRel::set_allocated_post_join_filter(::io::substrait::Expression* } post_join_filter_ = post_join_filter; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.post_join_filter) + // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.post_join_filter) } -// .io.substrait.JoinRel.JoinType type = 6; +// .substrait.JoinRel.JoinType type = 6; inline void JoinRel::clear_type() { type_ = 0; } -inline ::io::substrait::JoinRel_JoinType JoinRel::_internal_type() const { - return static_cast< ::io::substrait::JoinRel_JoinType >(type_); +inline ::substrait::JoinRel_JoinType JoinRel::_internal_type() const { + return static_cast< ::substrait::JoinRel_JoinType >(type_); } -inline ::io::substrait::JoinRel_JoinType JoinRel::type() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.type) +inline ::substrait::JoinRel_JoinType JoinRel::type() const { + // @@protoc_insertion_point(field_get:substrait.JoinRel.type) return _internal_type(); } -inline void JoinRel::_internal_set_type(::io::substrait::JoinRel_JoinType value) { +inline void JoinRel::_internal_set_type(::substrait::JoinRel_JoinType value) { type_ = value; } -inline void JoinRel::set_type(::io::substrait::JoinRel_JoinType value) { +inline void JoinRel::set_type(::substrait::JoinRel_JoinType value) { _internal_set_type(value); - // @@protoc_insertion_point(field_set:io.substrait.JoinRel.type) + // @@protoc_insertion_point(field_set:substrait.JoinRel.type) } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool JoinRel::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool JoinRel::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& JoinRel::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& JoinRel::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& JoinRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.JoinRel.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& JoinRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.JoinRel.advanced_extension) return _internal_advanced_extension(); } inline void JoinRel::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -8358,37 +8443,37 @@ inline void JoinRel::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.JoinRel.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* JoinRel::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* JoinRel::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* JoinRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.JoinRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* JoinRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.JoinRel.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* JoinRel::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* JoinRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* JoinRel::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.JoinRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* JoinRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.JoinRel.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void JoinRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void JoinRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -8405,14 +8490,14 @@ inline void JoinRel::set_allocated_advanced_extension(::io::substrait::extension } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.JoinRel.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.advanced_extension) } // ------------------------------------------------------------------- // FetchRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool FetchRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -8425,17 +8510,17 @@ inline void FetchRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& FetchRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& FetchRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& FetchRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.FetchRel.common) +inline const ::substrait::RelCommon& FetchRel::common() const { + // @@protoc_insertion_point(field_get:substrait.FetchRel.common) return _internal_common(); } inline void FetchRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -8445,37 +8530,37 @@ inline void FetchRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FetchRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FetchRel.common) } -inline ::io::substrait::RelCommon* FetchRel::release_common() { +inline ::substrait::RelCommon* FetchRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* FetchRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.FetchRel.common) +inline ::substrait::RelCommon* FetchRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.FetchRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* FetchRel::_internal_mutable_common() { +inline ::substrait::RelCommon* FetchRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* FetchRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.FetchRel.common) +inline ::substrait::RelCommon* FetchRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.FetchRel.common) return _internal_mutable_common(); } -inline void FetchRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void FetchRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -8492,10 +8577,10 @@ inline void FetchRel::set_allocated_common(::io::substrait::RelCommon* common) { } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FetchRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.FetchRel.common) } -// .io.substrait.Rel input = 2; +// .substrait.Rel input = 2; inline bool FetchRel::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } @@ -8508,17 +8593,17 @@ inline void FetchRel::clear_input() { } input_ = nullptr; } -inline const ::io::substrait::Rel& FetchRel::_internal_input() const { - const ::io::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::substrait::Rel& FetchRel::_internal_input() const { + const ::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& FetchRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.FetchRel.input) +inline const ::substrait::Rel& FetchRel::input() const { + // @@protoc_insertion_point(field_get:substrait.FetchRel.input) return _internal_input(); } inline void FetchRel::unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input) { + ::substrait::Rel* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } @@ -8528,37 +8613,37 @@ inline void FetchRel::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FetchRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FetchRel.input) } -inline ::io::substrait::Rel* FetchRel::release_input() { +inline ::substrait::Rel* FetchRel::release_input() { - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* FetchRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.FetchRel.input) +inline ::substrait::Rel* FetchRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:substrait.FetchRel.input) - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Rel* FetchRel::_internal_mutable_input() { +inline ::substrait::Rel* FetchRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); input_ = p; } return input_; } -inline ::io::substrait::Rel* FetchRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.FetchRel.input) +inline ::substrait::Rel* FetchRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:substrait.FetchRel.input) return _internal_mutable_input(); } -inline void FetchRel::set_allocated_input(::io::substrait::Rel* input) { +inline void FetchRel::set_allocated_input(::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -8575,7 +8660,7 @@ inline void FetchRel::set_allocated_input(::io::substrait::Rel* input) { } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FetchRel.input) + // @@protoc_insertion_point(field_set_allocated:substrait.FetchRel.input) } // int64 offset = 3; @@ -8586,7 +8671,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::_internal_offset() const { return offset_; } inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::offset() const { - // @@protoc_insertion_point(field_get:io.substrait.FetchRel.offset) + // @@protoc_insertion_point(field_get:substrait.FetchRel.offset) return _internal_offset(); } inline void FetchRel::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { @@ -8595,7 +8680,7 @@ inline void FetchRel::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) } inline void FetchRel::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_offset(value); - // @@protoc_insertion_point(field_set:io.substrait.FetchRel.offset) + // @@protoc_insertion_point(field_set:substrait.FetchRel.offset) } // int64 count = 4; @@ -8606,7 +8691,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::_internal_count() const { return count_; } inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::count() const { - // @@protoc_insertion_point(field_get:io.substrait.FetchRel.count) + // @@protoc_insertion_point(field_get:substrait.FetchRel.count) return _internal_count(); } inline void FetchRel::_internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { @@ -8615,27 +8700,27 @@ inline void FetchRel::_internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value) } inline void FetchRel::set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { _internal_set_count(value); - // @@protoc_insertion_point(field_set:io.substrait.FetchRel.count) + // @@protoc_insertion_point(field_set:substrait.FetchRel.count) } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool FetchRel::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool FetchRel::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& FetchRel::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& FetchRel::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& FetchRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.FetchRel.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& FetchRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.FetchRel.advanced_extension) return _internal_advanced_extension(); } inline void FetchRel::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -8645,37 +8730,37 @@ inline void FetchRel::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FetchRel.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FetchRel.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* FetchRel::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* FetchRel::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* FetchRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.FetchRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* FetchRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.FetchRel.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* FetchRel::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* FetchRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* FetchRel::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.FetchRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* FetchRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.FetchRel.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void FetchRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void FetchRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -8692,82 +8777,71 @@ inline void FetchRel::set_allocated_advanced_extension(::io::substrait::extensio } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FetchRel.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.FetchRel.advanced_extension) } // ------------------------------------------------------------------- // AggregateRel_Grouping -// repeated int32 input_fields = 1; -inline int AggregateRel_Grouping::_internal_input_fields_size() const { - return input_fields_.size(); -} -inline int AggregateRel_Grouping::input_fields_size() const { - return _internal_input_fields_size(); -} -inline void AggregateRel_Grouping::clear_input_fields() { - input_fields_.Clear(); +// repeated .substrait.Expression grouping_expressions = 1; +inline int AggregateRel_Grouping::_internal_grouping_expressions_size() const { + return grouping_expressions_.size(); } -inline ::PROTOBUF_NAMESPACE_ID::int32 AggregateRel_Grouping::_internal_input_fields(int index) const { - return input_fields_.Get(index); +inline int AggregateRel_Grouping::grouping_expressions_size() const { + return _internal_grouping_expressions_size(); } -inline ::PROTOBUF_NAMESPACE_ID::int32 AggregateRel_Grouping::input_fields(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.Grouping.input_fields) - return _internal_input_fields(index); +inline ::substrait::Expression* AggregateRel_Grouping::mutable_grouping_expressions(int index) { + // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Grouping.grouping_expressions) + return grouping_expressions_.Mutable(index); } -inline void AggregateRel_Grouping::set_input_fields(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { - input_fields_.Set(index, value); - // @@protoc_insertion_point(field_set:io.substrait.AggregateRel.Grouping.input_fields) +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* +AggregateRel_Grouping::mutable_grouping_expressions() { + // @@protoc_insertion_point(field_mutable_list:substrait.AggregateRel.Grouping.grouping_expressions) + return &grouping_expressions_; } -inline void AggregateRel_Grouping::_internal_add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value) { - input_fields_.Add(value); +inline const ::substrait::Expression& AggregateRel_Grouping::_internal_grouping_expressions(int index) const { + return grouping_expressions_.Get(index); } -inline void AggregateRel_Grouping::add_input_fields(::PROTOBUF_NAMESPACE_ID::int32 value) { - _internal_add_input_fields(value); - // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.Grouping.input_fields) +inline const ::substrait::Expression& AggregateRel_Grouping::grouping_expressions(int index) const { + // @@protoc_insertion_point(field_get:substrait.AggregateRel.Grouping.grouping_expressions) + return _internal_grouping_expressions(index); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& -AggregateRel_Grouping::_internal_input_fields() const { - return input_fields_; +inline ::substrait::Expression* AggregateRel_Grouping::_internal_add_grouping_expressions() { + return grouping_expressions_.Add(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& -AggregateRel_Grouping::input_fields() const { - // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.Grouping.input_fields) - return _internal_input_fields(); +inline ::substrait::Expression* AggregateRel_Grouping::add_grouping_expressions() { + // @@protoc_insertion_point(field_add:substrait.AggregateRel.Grouping.grouping_expressions) + return _internal_add_grouping_expressions(); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* -AggregateRel_Grouping::_internal_mutable_input_fields() { - return &input_fields_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* -AggregateRel_Grouping::mutable_input_fields() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.Grouping.input_fields) - return _internal_mutable_input_fields(); +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& +AggregateRel_Grouping::grouping_expressions() const { + // @@protoc_insertion_point(field_list:substrait.AggregateRel.Grouping.grouping_expressions) + return grouping_expressions_; } // ------------------------------------------------------------------- // AggregateRel_Measure -// .io.substrait.AggregateFunction measure = 1; +// .substrait.AggregateFunction measure = 1; inline bool AggregateRel_Measure::_internal_has_measure() const { return this != internal_default_instance() && measure_ != nullptr; } inline bool AggregateRel_Measure::has_measure() const { return _internal_has_measure(); } -inline const ::io::substrait::AggregateFunction& AggregateRel_Measure::_internal_measure() const { - const ::io::substrait::AggregateFunction* p = measure_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_AggregateFunction_default_instance_); +inline const ::substrait::AggregateFunction& AggregateRel_Measure::_internal_measure() const { + const ::substrait::AggregateFunction* p = measure_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_AggregateFunction_default_instance_); } -inline const ::io::substrait::AggregateFunction& AggregateRel_Measure::measure() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.Measure.measure) +inline const ::substrait::AggregateFunction& AggregateRel_Measure::measure() const { + // @@protoc_insertion_point(field_get:substrait.AggregateRel.Measure.measure) return _internal_measure(); } inline void AggregateRel_Measure::unsafe_arena_set_allocated_measure( - ::io::substrait::AggregateFunction* measure) { + ::substrait::AggregateFunction* measure) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); } @@ -8777,37 +8851,37 @@ inline void AggregateRel_Measure::unsafe_arena_set_allocated_measure( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.Measure.measure) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.Measure.measure) } -inline ::io::substrait::AggregateFunction* AggregateRel_Measure::release_measure() { +inline ::substrait::AggregateFunction* AggregateRel_Measure::release_measure() { - ::io::substrait::AggregateFunction* temp = measure_; + ::substrait::AggregateFunction* temp = measure_; measure_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::AggregateFunction* AggregateRel_Measure::unsafe_arena_release_measure() { - // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.Measure.measure) +inline ::substrait::AggregateFunction* AggregateRel_Measure::unsafe_arena_release_measure() { + // @@protoc_insertion_point(field_release:substrait.AggregateRel.Measure.measure) - ::io::substrait::AggregateFunction* temp = measure_; + ::substrait::AggregateFunction* temp = measure_; measure_ = nullptr; return temp; } -inline ::io::substrait::AggregateFunction* AggregateRel_Measure::_internal_mutable_measure() { +inline ::substrait::AggregateFunction* AggregateRel_Measure::_internal_mutable_measure() { if (measure_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::AggregateFunction>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::AggregateFunction>(GetArena()); measure_ = p; } return measure_; } -inline ::io::substrait::AggregateFunction* AggregateRel_Measure::mutable_measure() { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.Measure.measure) +inline ::substrait::AggregateFunction* AggregateRel_Measure::mutable_measure() { + // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Measure.measure) return _internal_mutable_measure(); } -inline void AggregateRel_Measure::set_allocated_measure(::io::substrait::AggregateFunction* measure) { +inline void AggregateRel_Measure::set_allocated_measure(::substrait::AggregateFunction* measure) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); @@ -8824,27 +8898,27 @@ inline void AggregateRel_Measure::set_allocated_measure(::io::substrait::Aggrega } measure_ = measure; - // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.Measure.measure) + // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.Measure.measure) } -// .io.substrait.Expression filter = 2; +// .substrait.Expression filter = 2; inline bool AggregateRel_Measure::_internal_has_filter() const { return this != internal_default_instance() && filter_ != nullptr; } inline bool AggregateRel_Measure::has_filter() const { return _internal_has_filter(); } -inline const ::io::substrait::Expression& AggregateRel_Measure::_internal_filter() const { - const ::io::substrait::Expression* p = filter_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& AggregateRel_Measure::_internal_filter() const { + const ::substrait::Expression* p = filter_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& AggregateRel_Measure::filter() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.Measure.filter) +inline const ::substrait::Expression& AggregateRel_Measure::filter() const { + // @@protoc_insertion_point(field_get:substrait.AggregateRel.Measure.filter) return _internal_filter(); } inline void AggregateRel_Measure::unsafe_arena_set_allocated_filter( - ::io::substrait::Expression* filter) { + ::substrait::Expression* filter) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); } @@ -8854,37 +8928,37 @@ inline void AggregateRel_Measure::unsafe_arena_set_allocated_filter( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.Measure.filter) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.Measure.filter) } -inline ::io::substrait::Expression* AggregateRel_Measure::release_filter() { +inline ::substrait::Expression* AggregateRel_Measure::release_filter() { - ::io::substrait::Expression* temp = filter_; + ::substrait::Expression* temp = filter_; filter_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* AggregateRel_Measure::unsafe_arena_release_filter() { - // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.Measure.filter) +inline ::substrait::Expression* AggregateRel_Measure::unsafe_arena_release_filter() { + // @@protoc_insertion_point(field_release:substrait.AggregateRel.Measure.filter) - ::io::substrait::Expression* temp = filter_; + ::substrait::Expression* temp = filter_; filter_ = nullptr; return temp; } -inline ::io::substrait::Expression* AggregateRel_Measure::_internal_mutable_filter() { +inline ::substrait::Expression* AggregateRel_Measure::_internal_mutable_filter() { if (filter_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); filter_ = p; } return filter_; } -inline ::io::substrait::Expression* AggregateRel_Measure::mutable_filter() { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.Measure.filter) +inline ::substrait::Expression* AggregateRel_Measure::mutable_filter() { + // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Measure.filter) return _internal_mutable_filter(); } -inline void AggregateRel_Measure::set_allocated_filter(::io::substrait::Expression* filter) { +inline void AggregateRel_Measure::set_allocated_filter(::substrait::Expression* filter) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); @@ -8901,14 +8975,14 @@ inline void AggregateRel_Measure::set_allocated_filter(::io::substrait::Expressi } filter_ = filter; - // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.Measure.filter) + // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.Measure.filter) } // ------------------------------------------------------------------- // AggregateRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool AggregateRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -8921,17 +8995,17 @@ inline void AggregateRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& AggregateRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& AggregateRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& AggregateRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.common) +inline const ::substrait::RelCommon& AggregateRel::common() const { + // @@protoc_insertion_point(field_get:substrait.AggregateRel.common) return _internal_common(); } inline void AggregateRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -8941,37 +9015,37 @@ inline void AggregateRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.common) } -inline ::io::substrait::RelCommon* AggregateRel::release_common() { +inline ::substrait::RelCommon* AggregateRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* AggregateRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.common) +inline ::substrait::RelCommon* AggregateRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.AggregateRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* AggregateRel::_internal_mutable_common() { +inline ::substrait::RelCommon* AggregateRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* AggregateRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.common) +inline ::substrait::RelCommon* AggregateRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.common) return _internal_mutable_common(); } -inline void AggregateRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void AggregateRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -8988,10 +9062,10 @@ inline void AggregateRel::set_allocated_common(::io::substrait::RelCommon* commo } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.common) } -// .io.substrait.Rel input = 2; +// .substrait.Rel input = 2; inline bool AggregateRel::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } @@ -9004,17 +9078,17 @@ inline void AggregateRel::clear_input() { } input_ = nullptr; } -inline const ::io::substrait::Rel& AggregateRel::_internal_input() const { - const ::io::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::substrait::Rel& AggregateRel::_internal_input() const { + const ::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& AggregateRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.input) +inline const ::substrait::Rel& AggregateRel::input() const { + // @@protoc_insertion_point(field_get:substrait.AggregateRel.input) return _internal_input(); } inline void AggregateRel::unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input) { + ::substrait::Rel* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } @@ -9024,37 +9098,37 @@ inline void AggregateRel::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.input) } -inline ::io::substrait::Rel* AggregateRel::release_input() { +inline ::substrait::Rel* AggregateRel::release_input() { - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* AggregateRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.input) +inline ::substrait::Rel* AggregateRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:substrait.AggregateRel.input) - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Rel* AggregateRel::_internal_mutable_input() { +inline ::substrait::Rel* AggregateRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); input_ = p; } return input_; } -inline ::io::substrait::Rel* AggregateRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.input) +inline ::substrait::Rel* AggregateRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.input) return _internal_mutable_input(); } -inline void AggregateRel::set_allocated_input(::io::substrait::Rel* input) { +inline void AggregateRel::set_allocated_input(::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -9071,10 +9145,10 @@ inline void AggregateRel::set_allocated_input(::io::substrait::Rel* input) { } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.input) + // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.input) } -// repeated .io.substrait.AggregateRel.Grouping groupings = 3; +// repeated .substrait.AggregateRel.Grouping groupings = 3; inline int AggregateRel::_internal_groupings_size() const { return groupings_.size(); } @@ -9084,36 +9158,36 @@ inline int AggregateRel::groupings_size() const { inline void AggregateRel::clear_groupings() { groupings_.Clear(); } -inline ::io::substrait::AggregateRel_Grouping* AggregateRel::mutable_groupings(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.groupings) +inline ::substrait::AggregateRel_Grouping* AggregateRel::mutable_groupings(int index) { + // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.groupings) return groupings_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >* AggregateRel::mutable_groupings() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.groupings) + // @@protoc_insertion_point(field_mutable_list:substrait.AggregateRel.groupings) return &groupings_; } -inline const ::io::substrait::AggregateRel_Grouping& AggregateRel::_internal_groupings(int index) const { +inline const ::substrait::AggregateRel_Grouping& AggregateRel::_internal_groupings(int index) const { return groupings_.Get(index); } -inline const ::io::substrait::AggregateRel_Grouping& AggregateRel::groupings(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.groupings) +inline const ::substrait::AggregateRel_Grouping& AggregateRel::groupings(int index) const { + // @@protoc_insertion_point(field_get:substrait.AggregateRel.groupings) return _internal_groupings(index); } -inline ::io::substrait::AggregateRel_Grouping* AggregateRel::_internal_add_groupings() { +inline ::substrait::AggregateRel_Grouping* AggregateRel::_internal_add_groupings() { return groupings_.Add(); } -inline ::io::substrait::AggregateRel_Grouping* AggregateRel::add_groupings() { - // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.groupings) +inline ::substrait::AggregateRel_Grouping* AggregateRel::add_groupings() { + // @@protoc_insertion_point(field_add:substrait.AggregateRel.groupings) return _internal_add_groupings(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Grouping >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >& AggregateRel::groupings() const { - // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.groupings) + // @@protoc_insertion_point(field_list:substrait.AggregateRel.groupings) return groupings_; } -// repeated .io.substrait.AggregateRel.Measure measures = 4; +// repeated .substrait.AggregateRel.Measure measures = 4; inline int AggregateRel::_internal_measures_size() const { return measures_.size(); } @@ -9123,53 +9197,53 @@ inline int AggregateRel::measures_size() const { inline void AggregateRel::clear_measures() { measures_.Clear(); } -inline ::io::substrait::AggregateRel_Measure* AggregateRel::mutable_measures(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.measures) +inline ::substrait::AggregateRel_Measure* AggregateRel::mutable_measures(int index) { + // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.measures) return measures_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >* AggregateRel::mutable_measures() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.AggregateRel.measures) + // @@protoc_insertion_point(field_mutable_list:substrait.AggregateRel.measures) return &measures_; } -inline const ::io::substrait::AggregateRel_Measure& AggregateRel::_internal_measures(int index) const { +inline const ::substrait::AggregateRel_Measure& AggregateRel::_internal_measures(int index) const { return measures_.Get(index); } -inline const ::io::substrait::AggregateRel_Measure& AggregateRel::measures(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.measures) +inline const ::substrait::AggregateRel_Measure& AggregateRel::measures(int index) const { + // @@protoc_insertion_point(field_get:substrait.AggregateRel.measures) return _internal_measures(index); } -inline ::io::substrait::AggregateRel_Measure* AggregateRel::_internal_add_measures() { +inline ::substrait::AggregateRel_Measure* AggregateRel::_internal_add_measures() { return measures_.Add(); } -inline ::io::substrait::AggregateRel_Measure* AggregateRel::add_measures() { - // @@protoc_insertion_point(field_add:io.substrait.AggregateRel.measures) +inline ::substrait::AggregateRel_Measure* AggregateRel::add_measures() { + // @@protoc_insertion_point(field_add:substrait.AggregateRel.measures) return _internal_add_measures(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::AggregateRel_Measure >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >& AggregateRel::measures() const { - // @@protoc_insertion_point(field_list:io.substrait.AggregateRel.measures) + // @@protoc_insertion_point(field_list:substrait.AggregateRel.measures) return measures_; } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool AggregateRel::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool AggregateRel::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& AggregateRel::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& AggregateRel::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& AggregateRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.AggregateRel.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& AggregateRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.AggregateRel.advanced_extension) return _internal_advanced_extension(); } inline void AggregateRel::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -9179,37 +9253,37 @@ inline void AggregateRel::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.AggregateRel.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* AggregateRel::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* AggregateRel::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* AggregateRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.AggregateRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* AggregateRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.AggregateRel.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* AggregateRel::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* AggregateRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* AggregateRel::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.AggregateRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* AggregateRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void AggregateRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void AggregateRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -9226,14 +9300,14 @@ inline void AggregateRel::set_allocated_advanced_extension(::io::substrait::exte } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.AggregateRel.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.advanced_extension) } // ------------------------------------------------------------------- // SortRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool SortRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -9246,17 +9320,17 @@ inline void SortRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& SortRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& SortRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& SortRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.SortRel.common) +inline const ::substrait::RelCommon& SortRel::common() const { + // @@protoc_insertion_point(field_get:substrait.SortRel.common) return _internal_common(); } inline void SortRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -9266,37 +9340,37 @@ inline void SortRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortRel.common) } -inline ::io::substrait::RelCommon* SortRel::release_common() { +inline ::substrait::RelCommon* SortRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* SortRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.SortRel.common) +inline ::substrait::RelCommon* SortRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.SortRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* SortRel::_internal_mutable_common() { +inline ::substrait::RelCommon* SortRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* SortRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.common) +inline ::substrait::RelCommon* SortRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.SortRel.common) return _internal_mutable_common(); } -inline void SortRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void SortRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -9313,10 +9387,10 @@ inline void SortRel::set_allocated_common(::io::substrait::RelCommon* common) { } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.SortRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.SortRel.common) } -// .io.substrait.Rel input = 2; +// .substrait.Rel input = 2; inline bool SortRel::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } @@ -9329,17 +9403,17 @@ inline void SortRel::clear_input() { } input_ = nullptr; } -inline const ::io::substrait::Rel& SortRel::_internal_input() const { - const ::io::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::substrait::Rel& SortRel::_internal_input() const { + const ::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& SortRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.SortRel.input) +inline const ::substrait::Rel& SortRel::input() const { + // @@protoc_insertion_point(field_get:substrait.SortRel.input) return _internal_input(); } inline void SortRel::unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input) { + ::substrait::Rel* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } @@ -9349,37 +9423,37 @@ inline void SortRel::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortRel.input) } -inline ::io::substrait::Rel* SortRel::release_input() { +inline ::substrait::Rel* SortRel::release_input() { - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* SortRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.SortRel.input) +inline ::substrait::Rel* SortRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:substrait.SortRel.input) - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Rel* SortRel::_internal_mutable_input() { +inline ::substrait::Rel* SortRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); input_ = p; } return input_; } -inline ::io::substrait::Rel* SortRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.input) +inline ::substrait::Rel* SortRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:substrait.SortRel.input) return _internal_mutable_input(); } -inline void SortRel::set_allocated_input(::io::substrait::Rel* input) { +inline void SortRel::set_allocated_input(::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -9396,63 +9470,63 @@ inline void SortRel::set_allocated_input(::io::substrait::Rel* input) { } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.SortRel.input) + // @@protoc_insertion_point(field_set_allocated:substrait.SortRel.input) } -// repeated .io.substrait.SortField sorts = 3; +// repeated .substrait.SortField sorts = 3; inline int SortRel::_internal_sorts_size() const { return sorts_.size(); } inline int SortRel::sorts_size() const { return _internal_sorts_size(); } -inline ::io::substrait::SortField* SortRel::mutable_sorts(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.sorts) +inline ::substrait::SortField* SortRel::mutable_sorts(int index) { + // @@protoc_insertion_point(field_mutable:substrait.SortRel.sorts) return sorts_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* SortRel::mutable_sorts() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.SortRel.sorts) + // @@protoc_insertion_point(field_mutable_list:substrait.SortRel.sorts) return &sorts_; } -inline const ::io::substrait::SortField& SortRel::_internal_sorts(int index) const { +inline const ::substrait::SortField& SortRel::_internal_sorts(int index) const { return sorts_.Get(index); } -inline const ::io::substrait::SortField& SortRel::sorts(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.SortRel.sorts) +inline const ::substrait::SortField& SortRel::sorts(int index) const { + // @@protoc_insertion_point(field_get:substrait.SortRel.sorts) return _internal_sorts(index); } -inline ::io::substrait::SortField* SortRel::_internal_add_sorts() { +inline ::substrait::SortField* SortRel::_internal_add_sorts() { return sorts_.Add(); } -inline ::io::substrait::SortField* SortRel::add_sorts() { - // @@protoc_insertion_point(field_add:io.substrait.SortRel.sorts) +inline ::substrait::SortField* SortRel::add_sorts() { + // @@protoc_insertion_point(field_add:substrait.SortRel.sorts) return _internal_add_sorts(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::SortField >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& SortRel::sorts() const { - // @@protoc_insertion_point(field_list:io.substrait.SortRel.sorts) + // @@protoc_insertion_point(field_list:substrait.SortRel.sorts) return sorts_; } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool SortRel::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool SortRel::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& SortRel::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& SortRel::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& SortRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.SortRel.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& SortRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.SortRel.advanced_extension) return _internal_advanced_extension(); } inline void SortRel::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -9462,37 +9536,37 @@ inline void SortRel::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SortRel.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortRel.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* SortRel::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* SortRel::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* SortRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.SortRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* SortRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.SortRel.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* SortRel::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* SortRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* SortRel::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.SortRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* SortRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.SortRel.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void SortRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void SortRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -9509,14 +9583,14 @@ inline void SortRel::set_allocated_advanced_extension(::io::substrait::extension } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.SortRel.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.SortRel.advanced_extension) } // ------------------------------------------------------------------- // FilterRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool FilterRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -9529,17 +9603,17 @@ inline void FilterRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& FilterRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& FilterRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& FilterRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.FilterRel.common) +inline const ::substrait::RelCommon& FilterRel::common() const { + // @@protoc_insertion_point(field_get:substrait.FilterRel.common) return _internal_common(); } inline void FilterRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -9549,37 +9623,37 @@ inline void FilterRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.common) } -inline ::io::substrait::RelCommon* FilterRel::release_common() { +inline ::substrait::RelCommon* FilterRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* FilterRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.FilterRel.common) +inline ::substrait::RelCommon* FilterRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.FilterRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* FilterRel::_internal_mutable_common() { +inline ::substrait::RelCommon* FilterRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* FilterRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.common) +inline ::substrait::RelCommon* FilterRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.FilterRel.common) return _internal_mutable_common(); } -inline void FilterRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void FilterRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -9596,10 +9670,10 @@ inline void FilterRel::set_allocated_common(::io::substrait::RelCommon* common) } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.common) } -// .io.substrait.Rel input = 2; +// .substrait.Rel input = 2; inline bool FilterRel::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } @@ -9612,17 +9686,17 @@ inline void FilterRel::clear_input() { } input_ = nullptr; } -inline const ::io::substrait::Rel& FilterRel::_internal_input() const { - const ::io::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::substrait::Rel& FilterRel::_internal_input() const { + const ::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& FilterRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.FilterRel.input) +inline const ::substrait::Rel& FilterRel::input() const { + // @@protoc_insertion_point(field_get:substrait.FilterRel.input) return _internal_input(); } inline void FilterRel::unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input) { + ::substrait::Rel* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } @@ -9632,37 +9706,37 @@ inline void FilterRel::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.input) } -inline ::io::substrait::Rel* FilterRel::release_input() { +inline ::substrait::Rel* FilterRel::release_input() { - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* FilterRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.FilterRel.input) +inline ::substrait::Rel* FilterRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:substrait.FilterRel.input) - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Rel* FilterRel::_internal_mutable_input() { +inline ::substrait::Rel* FilterRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); input_ = p; } return input_; } -inline ::io::substrait::Rel* FilterRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.input) +inline ::substrait::Rel* FilterRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:substrait.FilterRel.input) return _internal_mutable_input(); } -inline void FilterRel::set_allocated_input(::io::substrait::Rel* input) { +inline void FilterRel::set_allocated_input(::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -9679,27 +9753,27 @@ inline void FilterRel::set_allocated_input(::io::substrait::Rel* input) { } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.input) + // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.input) } -// .io.substrait.Expression condition = 3; +// .substrait.Expression condition = 3; inline bool FilterRel::_internal_has_condition() const { return this != internal_default_instance() && condition_ != nullptr; } inline bool FilterRel::has_condition() const { return _internal_has_condition(); } -inline const ::io::substrait::Expression& FilterRel::_internal_condition() const { - const ::io::substrait::Expression* p = condition_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Expression_default_instance_); +inline const ::substrait::Expression& FilterRel::_internal_condition() const { + const ::substrait::Expression* p = condition_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Expression_default_instance_); } -inline const ::io::substrait::Expression& FilterRel::condition() const { - // @@protoc_insertion_point(field_get:io.substrait.FilterRel.condition) +inline const ::substrait::Expression& FilterRel::condition() const { + // @@protoc_insertion_point(field_get:substrait.FilterRel.condition) return _internal_condition(); } inline void FilterRel::unsafe_arena_set_allocated_condition( - ::io::substrait::Expression* condition) { + ::substrait::Expression* condition) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); } @@ -9709,37 +9783,37 @@ inline void FilterRel::unsafe_arena_set_allocated_condition( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.condition) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.condition) } -inline ::io::substrait::Expression* FilterRel::release_condition() { +inline ::substrait::Expression* FilterRel::release_condition() { - ::io::substrait::Expression* temp = condition_; + ::substrait::Expression* temp = condition_; condition_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Expression* FilterRel::unsafe_arena_release_condition() { - // @@protoc_insertion_point(field_release:io.substrait.FilterRel.condition) +inline ::substrait::Expression* FilterRel::unsafe_arena_release_condition() { + // @@protoc_insertion_point(field_release:substrait.FilterRel.condition) - ::io::substrait::Expression* temp = condition_; + ::substrait::Expression* temp = condition_; condition_ = nullptr; return temp; } -inline ::io::substrait::Expression* FilterRel::_internal_mutable_condition() { +inline ::substrait::Expression* FilterRel::_internal_mutable_condition() { if (condition_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); condition_ = p; } return condition_; } -inline ::io::substrait::Expression* FilterRel::mutable_condition() { - // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.condition) +inline ::substrait::Expression* FilterRel::mutable_condition() { + // @@protoc_insertion_point(field_mutable:substrait.FilterRel.condition) return _internal_mutable_condition(); } -inline void FilterRel::set_allocated_condition(::io::substrait::Expression* condition) { +inline void FilterRel::set_allocated_condition(::substrait::Expression* condition) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); @@ -9756,27 +9830,27 @@ inline void FilterRel::set_allocated_condition(::io::substrait::Expression* cond } condition_ = condition; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.condition) + // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.condition) } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool FilterRel::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool FilterRel::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& FilterRel::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& FilterRel::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& FilterRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.FilterRel.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& FilterRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.FilterRel.advanced_extension) return _internal_advanced_extension(); } inline void FilterRel::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -9786,37 +9860,37 @@ inline void FilterRel::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.FilterRel.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* FilterRel::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* FilterRel::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* FilterRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.FilterRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* FilterRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.FilterRel.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* FilterRel::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* FilterRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* FilterRel::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.FilterRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* FilterRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.FilterRel.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void FilterRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void FilterRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -9833,14 +9907,14 @@ inline void FilterRel::set_allocated_advanced_extension(::io::substrait::extensi } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.FilterRel.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.advanced_extension) } // ------------------------------------------------------------------- // SetRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool SetRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -9853,17 +9927,17 @@ inline void SetRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& SetRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& SetRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& SetRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.SetRel.common) +inline const ::substrait::RelCommon& SetRel::common() const { + // @@protoc_insertion_point(field_get:substrait.SetRel.common) return _internal_common(); } inline void SetRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -9873,37 +9947,37 @@ inline void SetRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SetRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SetRel.common) } -inline ::io::substrait::RelCommon* SetRel::release_common() { +inline ::substrait::RelCommon* SetRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* SetRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.SetRel.common) +inline ::substrait::RelCommon* SetRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.SetRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* SetRel::_internal_mutable_common() { +inline ::substrait::RelCommon* SetRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* SetRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.SetRel.common) +inline ::substrait::RelCommon* SetRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.SetRel.common) return _internal_mutable_common(); } -inline void SetRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void SetRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -9920,10 +9994,10 @@ inline void SetRel::set_allocated_common(::io::substrait::RelCommon* common) { } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.SetRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.SetRel.common) } -// repeated .io.substrait.Rel inputs = 2; +// repeated .substrait.Rel inputs = 2; inline int SetRel::_internal_inputs_size() const { return inputs_.size(); } @@ -9933,73 +10007,73 @@ inline int SetRel::inputs_size() const { inline void SetRel::clear_inputs() { inputs_.Clear(); } -inline ::io::substrait::Rel* SetRel::mutable_inputs(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.SetRel.inputs) +inline ::substrait::Rel* SetRel::mutable_inputs(int index) { + // @@protoc_insertion_point(field_mutable:substrait.SetRel.inputs) return inputs_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >* SetRel::mutable_inputs() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.SetRel.inputs) + // @@protoc_insertion_point(field_mutable_list:substrait.SetRel.inputs) return &inputs_; } -inline const ::io::substrait::Rel& SetRel::_internal_inputs(int index) const { +inline const ::substrait::Rel& SetRel::_internal_inputs(int index) const { return inputs_.Get(index); } -inline const ::io::substrait::Rel& SetRel::inputs(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.SetRel.inputs) +inline const ::substrait::Rel& SetRel::inputs(int index) const { + // @@protoc_insertion_point(field_get:substrait.SetRel.inputs) return _internal_inputs(index); } -inline ::io::substrait::Rel* SetRel::_internal_add_inputs() { +inline ::substrait::Rel* SetRel::_internal_add_inputs() { return inputs_.Add(); } -inline ::io::substrait::Rel* SetRel::add_inputs() { - // @@protoc_insertion_point(field_add:io.substrait.SetRel.inputs) +inline ::substrait::Rel* SetRel::add_inputs() { + // @@protoc_insertion_point(field_add:substrait.SetRel.inputs) return _internal_add_inputs(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >& SetRel::inputs() const { - // @@protoc_insertion_point(field_list:io.substrait.SetRel.inputs) + // @@protoc_insertion_point(field_list:substrait.SetRel.inputs) return inputs_; } -// .io.substrait.SetRel.SetOp op = 3; +// .substrait.SetRel.SetOp op = 3; inline void SetRel::clear_op() { op_ = 0; } -inline ::io::substrait::SetRel_SetOp SetRel::_internal_op() const { - return static_cast< ::io::substrait::SetRel_SetOp >(op_); +inline ::substrait::SetRel_SetOp SetRel::_internal_op() const { + return static_cast< ::substrait::SetRel_SetOp >(op_); } -inline ::io::substrait::SetRel_SetOp SetRel::op() const { - // @@protoc_insertion_point(field_get:io.substrait.SetRel.op) +inline ::substrait::SetRel_SetOp SetRel::op() const { + // @@protoc_insertion_point(field_get:substrait.SetRel.op) return _internal_op(); } -inline void SetRel::_internal_set_op(::io::substrait::SetRel_SetOp value) { +inline void SetRel::_internal_set_op(::substrait::SetRel_SetOp value) { op_ = value; } -inline void SetRel::set_op(::io::substrait::SetRel_SetOp value) { +inline void SetRel::set_op(::substrait::SetRel_SetOp value) { _internal_set_op(value); - // @@protoc_insertion_point(field_set:io.substrait.SetRel.op) + // @@protoc_insertion_point(field_set:substrait.SetRel.op) } -// .io.substrait.extensions.AdvancedExtension advanced_extension = 10; +// .substrait.extensions.AdvancedExtension advanced_extension = 10; inline bool SetRel::_internal_has_advanced_extension() const { return this != internal_default_instance() && advanced_extension_ != nullptr; } inline bool SetRel::has_advanced_extension() const { return _internal_has_advanced_extension(); } -inline const ::io::substrait::extensions::AdvancedExtension& SetRel::_internal_advanced_extension() const { - const ::io::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::extensions::_AdvancedExtension_default_instance_); +inline const ::substrait::extensions::AdvancedExtension& SetRel::_internal_advanced_extension() const { + const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::extensions::_AdvancedExtension_default_instance_); } -inline const ::io::substrait::extensions::AdvancedExtension& SetRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:io.substrait.SetRel.advanced_extension) +inline const ::substrait::extensions::AdvancedExtension& SetRel::advanced_extension() const { + // @@protoc_insertion_point(field_get:substrait.SetRel.advanced_extension) return _internal_advanced_extension(); } inline void SetRel::unsafe_arena_set_allocated_advanced_extension( - ::io::substrait::extensions::AdvancedExtension* advanced_extension) { + ::substrait::extensions::AdvancedExtension* advanced_extension) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } @@ -10009,37 +10083,37 @@ inline void SetRel::unsafe_arena_set_allocated_advanced_extension( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.SetRel.advanced_extension) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SetRel.advanced_extension) } -inline ::io::substrait::extensions::AdvancedExtension* SetRel::release_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* SetRel::release_advanced_extension() { - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::extensions::AdvancedExtension* SetRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:io.substrait.SetRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* SetRel::unsafe_arena_release_advanced_extension() { + // @@protoc_insertion_point(field_release:substrait.SetRel.advanced_extension) - ::io::substrait::extensions::AdvancedExtension* temp = advanced_extension_; + ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; return temp; } -inline ::io::substrait::extensions::AdvancedExtension* SetRel::_internal_mutable_advanced_extension() { +inline ::substrait::extensions::AdvancedExtension* SetRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); advanced_extension_ = p; } return advanced_extension_; } -inline ::io::substrait::extensions::AdvancedExtension* SetRel::mutable_advanced_extension() { - // @@protoc_insertion_point(field_mutable:io.substrait.SetRel.advanced_extension) +inline ::substrait::extensions::AdvancedExtension* SetRel::mutable_advanced_extension() { + // @@protoc_insertion_point(field_mutable:substrait.SetRel.advanced_extension) return _internal_mutable_advanced_extension(); } -inline void SetRel::set_allocated_advanced_extension(::io::substrait::extensions::AdvancedExtension* advanced_extension) { +inline void SetRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); @@ -10056,14 +10130,14 @@ inline void SetRel::set_allocated_advanced_extension(::io::substrait::extensions } advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:io.substrait.SetRel.advanced_extension) + // @@protoc_insertion_point(field_set_allocated:substrait.SetRel.advanced_extension) } // ------------------------------------------------------------------- // ExtensionSingleRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool ExtensionSingleRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -10076,17 +10150,17 @@ inline void ExtensionSingleRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& ExtensionSingleRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& ExtensionSingleRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& ExtensionSingleRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.ExtensionSingleRel.common) +inline const ::substrait::RelCommon& ExtensionSingleRel::common() const { + // @@protoc_insertion_point(field_get:substrait.ExtensionSingleRel.common) return _internal_common(); } inline void ExtensionSingleRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -10096,37 +10170,37 @@ inline void ExtensionSingleRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionSingleRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionSingleRel.common) } -inline ::io::substrait::RelCommon* ExtensionSingleRel::release_common() { +inline ::substrait::RelCommon* ExtensionSingleRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* ExtensionSingleRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.ExtensionSingleRel.common) +inline ::substrait::RelCommon* ExtensionSingleRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.ExtensionSingleRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* ExtensionSingleRel::_internal_mutable_common() { +inline ::substrait::RelCommon* ExtensionSingleRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* ExtensionSingleRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionSingleRel.common) +inline ::substrait::RelCommon* ExtensionSingleRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.common) return _internal_mutable_common(); } -inline void ExtensionSingleRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void ExtensionSingleRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -10143,10 +10217,10 @@ inline void ExtensionSingleRel::set_allocated_common(::io::substrait::RelCommon* } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionSingleRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionSingleRel.common) } -// .io.substrait.Rel input = 2; +// .substrait.Rel input = 2; inline bool ExtensionSingleRel::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } @@ -10159,17 +10233,17 @@ inline void ExtensionSingleRel::clear_input() { } input_ = nullptr; } -inline const ::io::substrait::Rel& ExtensionSingleRel::_internal_input() const { - const ::io::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::substrait::Rel& ExtensionSingleRel::_internal_input() const { + const ::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& ExtensionSingleRel::input() const { - // @@protoc_insertion_point(field_get:io.substrait.ExtensionSingleRel.input) +inline const ::substrait::Rel& ExtensionSingleRel::input() const { + // @@protoc_insertion_point(field_get:substrait.ExtensionSingleRel.input) return _internal_input(); } inline void ExtensionSingleRel::unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input) { + ::substrait::Rel* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } @@ -10179,37 +10253,37 @@ inline void ExtensionSingleRel::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionSingleRel.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionSingleRel.input) } -inline ::io::substrait::Rel* ExtensionSingleRel::release_input() { +inline ::substrait::Rel* ExtensionSingleRel::release_input() { - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* ExtensionSingleRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.ExtensionSingleRel.input) +inline ::substrait::Rel* ExtensionSingleRel::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:substrait.ExtensionSingleRel.input) - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Rel* ExtensionSingleRel::_internal_mutable_input() { +inline ::substrait::Rel* ExtensionSingleRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); input_ = p; } return input_; } -inline ::io::substrait::Rel* ExtensionSingleRel::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionSingleRel.input) +inline ::substrait::Rel* ExtensionSingleRel::mutable_input() { + // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.input) return _internal_mutable_input(); } -inline void ExtensionSingleRel::set_allocated_input(::io::substrait::Rel* input) { +inline void ExtensionSingleRel::set_allocated_input(::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -10226,7 +10300,7 @@ inline void ExtensionSingleRel::set_allocated_input(::io::substrait::Rel* input) } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionSingleRel.input) + // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionSingleRel.input) } // .google.protobuf.Any detail = 3; @@ -10242,7 +10316,7 @@ inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::_internal_detail() PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::detail() const { - // @@protoc_insertion_point(field_get:io.substrait.ExtensionSingleRel.detail) + // @@protoc_insertion_point(field_get:substrait.ExtensionSingleRel.detail) return _internal_detail(); } inline void ExtensionSingleRel::unsafe_arena_set_allocated_detail( @@ -10256,7 +10330,7 @@ inline void ExtensionSingleRel::unsafe_arena_set_allocated_detail( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionSingleRel.detail) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionSingleRel.detail) } inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::release_detail() { @@ -10268,7 +10342,7 @@ inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::release_detail() { return temp; } inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::unsafe_arena_release_detail() { - // @@protoc_insertion_point(field_release:io.substrait.ExtensionSingleRel.detail) + // @@protoc_insertion_point(field_release:substrait.ExtensionSingleRel.detail) PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; @@ -10283,7 +10357,7 @@ inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::_internal_mutable_detail( return detail_; } inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::mutable_detail() { - // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionSingleRel.detail) + // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.detail) return _internal_mutable_detail(); } inline void ExtensionSingleRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { @@ -10303,14 +10377,14 @@ inline void ExtensionSingleRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* } detail_ = detail; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionSingleRel.detail) + // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionSingleRel.detail) } // ------------------------------------------------------------------- // ExtensionLeafRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool ExtensionLeafRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -10323,17 +10397,17 @@ inline void ExtensionLeafRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& ExtensionLeafRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& ExtensionLeafRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& ExtensionLeafRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.ExtensionLeafRel.common) +inline const ::substrait::RelCommon& ExtensionLeafRel::common() const { + // @@protoc_insertion_point(field_get:substrait.ExtensionLeafRel.common) return _internal_common(); } inline void ExtensionLeafRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -10343,37 +10417,37 @@ inline void ExtensionLeafRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionLeafRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionLeafRel.common) } -inline ::io::substrait::RelCommon* ExtensionLeafRel::release_common() { +inline ::substrait::RelCommon* ExtensionLeafRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* ExtensionLeafRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.ExtensionLeafRel.common) +inline ::substrait::RelCommon* ExtensionLeafRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.ExtensionLeafRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* ExtensionLeafRel::_internal_mutable_common() { +inline ::substrait::RelCommon* ExtensionLeafRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* ExtensionLeafRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionLeafRel.common) +inline ::substrait::RelCommon* ExtensionLeafRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.ExtensionLeafRel.common) return _internal_mutable_common(); } -inline void ExtensionLeafRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void ExtensionLeafRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -10390,7 +10464,7 @@ inline void ExtensionLeafRel::set_allocated_common(::io::substrait::RelCommon* c } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionLeafRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionLeafRel.common) } // .google.protobuf.Any detail = 2; @@ -10406,7 +10480,7 @@ inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::_internal_detail() co PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::detail() const { - // @@protoc_insertion_point(field_get:io.substrait.ExtensionLeafRel.detail) + // @@protoc_insertion_point(field_get:substrait.ExtensionLeafRel.detail) return _internal_detail(); } inline void ExtensionLeafRel::unsafe_arena_set_allocated_detail( @@ -10420,7 +10494,7 @@ inline void ExtensionLeafRel::unsafe_arena_set_allocated_detail( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionLeafRel.detail) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionLeafRel.detail) } inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::release_detail() { @@ -10432,7 +10506,7 @@ inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::release_detail() { return temp; } inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::unsafe_arena_release_detail() { - // @@protoc_insertion_point(field_release:io.substrait.ExtensionLeafRel.detail) + // @@protoc_insertion_point(field_release:substrait.ExtensionLeafRel.detail) PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; @@ -10447,7 +10521,7 @@ inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::_internal_mutable_detail() return detail_; } inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::mutable_detail() { - // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionLeafRel.detail) + // @@protoc_insertion_point(field_mutable:substrait.ExtensionLeafRel.detail) return _internal_mutable_detail(); } inline void ExtensionLeafRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { @@ -10467,14 +10541,14 @@ inline void ExtensionLeafRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* d } detail_ = detail; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionLeafRel.detail) + // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionLeafRel.detail) } // ------------------------------------------------------------------- // ExtensionMultiRel -// .io.substrait.RelCommon common = 1; +// .substrait.RelCommon common = 1; inline bool ExtensionMultiRel::_internal_has_common() const { return this != internal_default_instance() && common_ != nullptr; } @@ -10487,17 +10561,17 @@ inline void ExtensionMultiRel::clear_common() { } common_ = nullptr; } -inline const ::io::substrait::RelCommon& ExtensionMultiRel::_internal_common() const { - const ::io::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_RelCommon_default_instance_); +inline const ::substrait::RelCommon& ExtensionMultiRel::_internal_common() const { + const ::substrait::RelCommon* p = common_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_RelCommon_default_instance_); } -inline const ::io::substrait::RelCommon& ExtensionMultiRel::common() const { - // @@protoc_insertion_point(field_get:io.substrait.ExtensionMultiRel.common) +inline const ::substrait::RelCommon& ExtensionMultiRel::common() const { + // @@protoc_insertion_point(field_get:substrait.ExtensionMultiRel.common) return _internal_common(); } inline void ExtensionMultiRel::unsafe_arena_set_allocated_common( - ::io::substrait::RelCommon* common) { + ::substrait::RelCommon* common) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } @@ -10507,37 +10581,37 @@ inline void ExtensionMultiRel::unsafe_arena_set_allocated_common( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionMultiRel.common) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionMultiRel.common) } -inline ::io::substrait::RelCommon* ExtensionMultiRel::release_common() { +inline ::substrait::RelCommon* ExtensionMultiRel::release_common() { - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::RelCommon* ExtensionMultiRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:io.substrait.ExtensionMultiRel.common) +inline ::substrait::RelCommon* ExtensionMultiRel::unsafe_arena_release_common() { + // @@protoc_insertion_point(field_release:substrait.ExtensionMultiRel.common) - ::io::substrait::RelCommon* temp = common_; + ::substrait::RelCommon* temp = common_; common_ = nullptr; return temp; } -inline ::io::substrait::RelCommon* ExtensionMultiRel::_internal_mutable_common() { +inline ::substrait::RelCommon* ExtensionMultiRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); common_ = p; } return common_; } -inline ::io::substrait::RelCommon* ExtensionMultiRel::mutable_common() { - // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionMultiRel.common) +inline ::substrait::RelCommon* ExtensionMultiRel::mutable_common() { + // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.common) return _internal_mutable_common(); } -inline void ExtensionMultiRel::set_allocated_common(::io::substrait::RelCommon* common) { +inline void ExtensionMultiRel::set_allocated_common(::substrait::RelCommon* common) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete common_; @@ -10554,10 +10628,10 @@ inline void ExtensionMultiRel::set_allocated_common(::io::substrait::RelCommon* } common_ = common; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionMultiRel.common) + // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionMultiRel.common) } -// repeated .io.substrait.Rel inputs = 2; +// repeated .substrait.Rel inputs = 2; inline int ExtensionMultiRel::_internal_inputs_size() const { return inputs_.size(); } @@ -10567,32 +10641,32 @@ inline int ExtensionMultiRel::inputs_size() const { inline void ExtensionMultiRel::clear_inputs() { inputs_.Clear(); } -inline ::io::substrait::Rel* ExtensionMultiRel::mutable_inputs(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionMultiRel.inputs) +inline ::substrait::Rel* ExtensionMultiRel::mutable_inputs(int index) { + // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.inputs) return inputs_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >* ExtensionMultiRel::mutable_inputs() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.ExtensionMultiRel.inputs) + // @@protoc_insertion_point(field_mutable_list:substrait.ExtensionMultiRel.inputs) return &inputs_; } -inline const ::io::substrait::Rel& ExtensionMultiRel::_internal_inputs(int index) const { +inline const ::substrait::Rel& ExtensionMultiRel::_internal_inputs(int index) const { return inputs_.Get(index); } -inline const ::io::substrait::Rel& ExtensionMultiRel::inputs(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.ExtensionMultiRel.inputs) +inline const ::substrait::Rel& ExtensionMultiRel::inputs(int index) const { + // @@protoc_insertion_point(field_get:substrait.ExtensionMultiRel.inputs) return _internal_inputs(index); } -inline ::io::substrait::Rel* ExtensionMultiRel::_internal_add_inputs() { +inline ::substrait::Rel* ExtensionMultiRel::_internal_add_inputs() { return inputs_.Add(); } -inline ::io::substrait::Rel* ExtensionMultiRel::add_inputs() { - // @@protoc_insertion_point(field_add:io.substrait.ExtensionMultiRel.inputs) +inline ::substrait::Rel* ExtensionMultiRel::add_inputs() { + // @@protoc_insertion_point(field_add:substrait.ExtensionMultiRel.inputs) return _internal_add_inputs(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Rel >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >& ExtensionMultiRel::inputs() const { - // @@protoc_insertion_point(field_list:io.substrait.ExtensionMultiRel.inputs) + // @@protoc_insertion_point(field_list:substrait.ExtensionMultiRel.inputs) return inputs_; } @@ -10609,7 +10683,7 @@ inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::_internal_detail() c PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::detail() const { - // @@protoc_insertion_point(field_get:io.substrait.ExtensionMultiRel.detail) + // @@protoc_insertion_point(field_get:substrait.ExtensionMultiRel.detail) return _internal_detail(); } inline void ExtensionMultiRel::unsafe_arena_set_allocated_detail( @@ -10623,7 +10697,7 @@ inline void ExtensionMultiRel::unsafe_arena_set_allocated_detail( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.ExtensionMultiRel.detail) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionMultiRel.detail) } inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::release_detail() { @@ -10635,7 +10709,7 @@ inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::release_detail() { return temp; } inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::unsafe_arena_release_detail() { - // @@protoc_insertion_point(field_release:io.substrait.ExtensionMultiRel.detail) + // @@protoc_insertion_point(field_release:substrait.ExtensionMultiRel.detail) PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; @@ -10650,7 +10724,7 @@ inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::_internal_mutable_detail() return detail_; } inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::mutable_detail() { - // @@protoc_insertion_point(field_mutable:io.substrait.ExtensionMultiRel.detail) + // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.detail) return _internal_mutable_detail(); } inline void ExtensionMultiRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { @@ -10670,14 +10744,14 @@ inline void ExtensionMultiRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* } detail_ = detail; - // @@protoc_insertion_point(field_set_allocated:io.substrait.ExtensionMultiRel.detail) + // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionMultiRel.detail) } // ------------------------------------------------------------------- // RelRoot -// .io.substrait.Rel input = 1; +// .substrait.Rel input = 1; inline bool RelRoot::_internal_has_input() const { return this != internal_default_instance() && input_ != nullptr; } @@ -10690,17 +10764,17 @@ inline void RelRoot::clear_input() { } input_ = nullptr; } -inline const ::io::substrait::Rel& RelRoot::_internal_input() const { - const ::io::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Rel_default_instance_); +inline const ::substrait::Rel& RelRoot::_internal_input() const { + const ::substrait::Rel* p = input_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Rel_default_instance_); } -inline const ::io::substrait::Rel& RelRoot::input() const { - // @@protoc_insertion_point(field_get:io.substrait.RelRoot.input) +inline const ::substrait::Rel& RelRoot::input() const { + // @@protoc_insertion_point(field_get:substrait.RelRoot.input) return _internal_input(); } inline void RelRoot::unsafe_arena_set_allocated_input( - ::io::substrait::Rel* input) { + ::substrait::Rel* input) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } @@ -10710,37 +10784,37 @@ inline void RelRoot::unsafe_arena_set_allocated_input( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.RelRoot.input) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelRoot.input) } -inline ::io::substrait::Rel* RelRoot::release_input() { +inline ::substrait::Rel* RelRoot::release_input() { - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Rel* RelRoot::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:io.substrait.RelRoot.input) +inline ::substrait::Rel* RelRoot::unsafe_arena_release_input() { + // @@protoc_insertion_point(field_release:substrait.RelRoot.input) - ::io::substrait::Rel* temp = input_; + ::substrait::Rel* temp = input_; input_ = nullptr; return temp; } -inline ::io::substrait::Rel* RelRoot::_internal_mutable_input() { +inline ::substrait::Rel* RelRoot::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); input_ = p; } return input_; } -inline ::io::substrait::Rel* RelRoot::mutable_input() { - // @@protoc_insertion_point(field_mutable:io.substrait.RelRoot.input) +inline ::substrait::Rel* RelRoot::mutable_input() { + // @@protoc_insertion_point(field_mutable:substrait.RelRoot.input) return _internal_mutable_input(); } -inline void RelRoot::set_allocated_input(::io::substrait::Rel* input) { +inline void RelRoot::set_allocated_input(::substrait::Rel* input) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete input_; @@ -10757,7 +10831,7 @@ inline void RelRoot::set_allocated_input(::io::substrait::Rel* input) { } input_ = input; - // @@protoc_insertion_point(field_set_allocated:io.substrait.RelRoot.input) + // @@protoc_insertion_point(field_set_allocated:substrait.RelRoot.input) } // repeated string names = 2; @@ -10771,66 +10845,66 @@ inline void RelRoot::clear_names() { names_.Clear(); } inline std::string* RelRoot::add_names() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_add_mutable:substrait.RelRoot.names) return _internal_add_names(); } inline const std::string& RelRoot::_internal_names(int index) const { return names_.Get(index); } inline const std::string& RelRoot::names(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_get:substrait.RelRoot.names) return _internal_names(index); } inline std::string* RelRoot::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_mutable:substrait.RelRoot.names) return names_.Mutable(index); } inline void RelRoot::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_set:substrait.RelRoot.names) names_.Mutable(index)->assign(value); } inline void RelRoot::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_set:substrait.RelRoot.names) names_.Mutable(index)->assign(std::move(value)); } inline void RelRoot::set_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_set_char:substrait.RelRoot.names) } inline void RelRoot::set_names(int index, const char* value, size_t size) { names_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_set_pointer:substrait.RelRoot.names) } inline std::string* RelRoot::_internal_add_names() { return names_.Add(); } inline void RelRoot::add_names(const std::string& value) { names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_add:substrait.RelRoot.names) } inline void RelRoot::add_names(std::string&& value) { names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_add:substrait.RelRoot.names) } inline void RelRoot::add_names(const char* value) { GOOGLE_DCHECK(value != nullptr); names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_add_char:substrait.RelRoot.names) } inline void RelRoot::add_names(const char* value, size_t size) { names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_add_pointer:substrait.RelRoot.names) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& RelRoot::names() const { - // @@protoc_insertion_point(field_list:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_list:substrait.RelRoot.names) return names_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* RelRoot::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.RelRoot.names) + // @@protoc_insertion_point(field_mutable_list:substrait.RelRoot.names) return &names_; } @@ -10838,9 +10912,9 @@ RelRoot::mutable_names() { // Rel -// .io.substrait.ReadRel read = 1; +// .substrait.ReadRel read = 1; inline bool Rel::_internal_has_read() const { - return RelType_case() == kRead; + return rel_type_case() == kRead; } inline bool Rel::has_read() const { return _internal_has_read(); @@ -10851,69 +10925,69 @@ inline void Rel::set_has_read() { inline void Rel::clear_read() { if (_internal_has_read()) { if (GetArena() == nullptr) { - delete RelType_.read_; + delete rel_type_.read_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::ReadRel* Rel::release_read() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.read) +inline ::substrait::ReadRel* Rel::release_read() { + // @@protoc_insertion_point(field_release:substrait.Rel.read) if (_internal_has_read()) { - clear_has_RelType(); - ::io::substrait::ReadRel* temp = RelType_.read_; + clear_has_rel_type(); + ::substrait::ReadRel* temp = rel_type_.read_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.read_ = nullptr; + rel_type_.read_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::ReadRel& Rel::_internal_read() const { +inline const ::substrait::ReadRel& Rel::_internal_read() const { return _internal_has_read() - ? *RelType_.read_ - : reinterpret_cast< ::io::substrait::ReadRel&>(::io::substrait::_ReadRel_default_instance_); + ? *rel_type_.read_ + : reinterpret_cast< ::substrait::ReadRel&>(::substrait::_ReadRel_default_instance_); } -inline const ::io::substrait::ReadRel& Rel::read() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.read) +inline const ::substrait::ReadRel& Rel::read() const { + // @@protoc_insertion_point(field_get:substrait.Rel.read) return _internal_read(); } -inline ::io::substrait::ReadRel* Rel::unsafe_arena_release_read() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.read) +inline ::substrait::ReadRel* Rel::unsafe_arena_release_read() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.read) if (_internal_has_read()) { - clear_has_RelType(); - ::io::substrait::ReadRel* temp = RelType_.read_; - RelType_.read_ = nullptr; + clear_has_rel_type(); + ::substrait::ReadRel* temp = rel_type_.read_; + rel_type_.read_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_read(::io::substrait::ReadRel* read) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_read(::substrait::ReadRel* read) { + clear_rel_type(); if (read) { set_has_read(); - RelType_.read_ = read; + rel_type_.read_ = read; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.read) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.read) } -inline ::io::substrait::ReadRel* Rel::_internal_mutable_read() { +inline ::substrait::ReadRel* Rel::_internal_mutable_read() { if (!_internal_has_read()) { - clear_RelType(); + clear_rel_type(); set_has_read(); - RelType_.read_ = CreateMaybeMessage< ::io::substrait::ReadRel >(GetArena()); + rel_type_.read_ = CreateMaybeMessage< ::substrait::ReadRel >(GetArena()); } - return RelType_.read_; + return rel_type_.read_; } -inline ::io::substrait::ReadRel* Rel::mutable_read() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.read) +inline ::substrait::ReadRel* Rel::mutable_read() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.read) return _internal_mutable_read(); } -// .io.substrait.FilterRel filter = 2; +// .substrait.FilterRel filter = 2; inline bool Rel::_internal_has_filter() const { - return RelType_case() == kFilter; + return rel_type_case() == kFilter; } inline bool Rel::has_filter() const { return _internal_has_filter(); @@ -10924,69 +10998,69 @@ inline void Rel::set_has_filter() { inline void Rel::clear_filter() { if (_internal_has_filter()) { if (GetArena() == nullptr) { - delete RelType_.filter_; + delete rel_type_.filter_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::FilterRel* Rel::release_filter() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.filter) +inline ::substrait::FilterRel* Rel::release_filter() { + // @@protoc_insertion_point(field_release:substrait.Rel.filter) if (_internal_has_filter()) { - clear_has_RelType(); - ::io::substrait::FilterRel* temp = RelType_.filter_; + clear_has_rel_type(); + ::substrait::FilterRel* temp = rel_type_.filter_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.filter_ = nullptr; + rel_type_.filter_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::FilterRel& Rel::_internal_filter() const { +inline const ::substrait::FilterRel& Rel::_internal_filter() const { return _internal_has_filter() - ? *RelType_.filter_ - : reinterpret_cast< ::io::substrait::FilterRel&>(::io::substrait::_FilterRel_default_instance_); + ? *rel_type_.filter_ + : reinterpret_cast< ::substrait::FilterRel&>(::substrait::_FilterRel_default_instance_); } -inline const ::io::substrait::FilterRel& Rel::filter() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.filter) +inline const ::substrait::FilterRel& Rel::filter() const { + // @@protoc_insertion_point(field_get:substrait.Rel.filter) return _internal_filter(); } -inline ::io::substrait::FilterRel* Rel::unsafe_arena_release_filter() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.filter) +inline ::substrait::FilterRel* Rel::unsafe_arena_release_filter() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.filter) if (_internal_has_filter()) { - clear_has_RelType(); - ::io::substrait::FilterRel* temp = RelType_.filter_; - RelType_.filter_ = nullptr; + clear_has_rel_type(); + ::substrait::FilterRel* temp = rel_type_.filter_; + rel_type_.filter_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_filter(::io::substrait::FilterRel* filter) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_filter(::substrait::FilterRel* filter) { + clear_rel_type(); if (filter) { set_has_filter(); - RelType_.filter_ = filter; + rel_type_.filter_ = filter; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.filter) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.filter) } -inline ::io::substrait::FilterRel* Rel::_internal_mutable_filter() { +inline ::substrait::FilterRel* Rel::_internal_mutable_filter() { if (!_internal_has_filter()) { - clear_RelType(); + clear_rel_type(); set_has_filter(); - RelType_.filter_ = CreateMaybeMessage< ::io::substrait::FilterRel >(GetArena()); + rel_type_.filter_ = CreateMaybeMessage< ::substrait::FilterRel >(GetArena()); } - return RelType_.filter_; + return rel_type_.filter_; } -inline ::io::substrait::FilterRel* Rel::mutable_filter() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.filter) +inline ::substrait::FilterRel* Rel::mutable_filter() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.filter) return _internal_mutable_filter(); } -// .io.substrait.FetchRel fetch = 3; +// .substrait.FetchRel fetch = 3; inline bool Rel::_internal_has_fetch() const { - return RelType_case() == kFetch; + return rel_type_case() == kFetch; } inline bool Rel::has_fetch() const { return _internal_has_fetch(); @@ -10997,69 +11071,69 @@ inline void Rel::set_has_fetch() { inline void Rel::clear_fetch() { if (_internal_has_fetch()) { if (GetArena() == nullptr) { - delete RelType_.fetch_; + delete rel_type_.fetch_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::FetchRel* Rel::release_fetch() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.fetch) +inline ::substrait::FetchRel* Rel::release_fetch() { + // @@protoc_insertion_point(field_release:substrait.Rel.fetch) if (_internal_has_fetch()) { - clear_has_RelType(); - ::io::substrait::FetchRel* temp = RelType_.fetch_; + clear_has_rel_type(); + ::substrait::FetchRel* temp = rel_type_.fetch_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.fetch_ = nullptr; + rel_type_.fetch_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::FetchRel& Rel::_internal_fetch() const { +inline const ::substrait::FetchRel& Rel::_internal_fetch() const { return _internal_has_fetch() - ? *RelType_.fetch_ - : reinterpret_cast< ::io::substrait::FetchRel&>(::io::substrait::_FetchRel_default_instance_); + ? *rel_type_.fetch_ + : reinterpret_cast< ::substrait::FetchRel&>(::substrait::_FetchRel_default_instance_); } -inline const ::io::substrait::FetchRel& Rel::fetch() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.fetch) +inline const ::substrait::FetchRel& Rel::fetch() const { + // @@protoc_insertion_point(field_get:substrait.Rel.fetch) return _internal_fetch(); } -inline ::io::substrait::FetchRel* Rel::unsafe_arena_release_fetch() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.fetch) +inline ::substrait::FetchRel* Rel::unsafe_arena_release_fetch() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.fetch) if (_internal_has_fetch()) { - clear_has_RelType(); - ::io::substrait::FetchRel* temp = RelType_.fetch_; - RelType_.fetch_ = nullptr; + clear_has_rel_type(); + ::substrait::FetchRel* temp = rel_type_.fetch_; + rel_type_.fetch_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_fetch(::io::substrait::FetchRel* fetch) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_fetch(::substrait::FetchRel* fetch) { + clear_rel_type(); if (fetch) { set_has_fetch(); - RelType_.fetch_ = fetch; + rel_type_.fetch_ = fetch; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.fetch) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.fetch) } -inline ::io::substrait::FetchRel* Rel::_internal_mutable_fetch() { +inline ::substrait::FetchRel* Rel::_internal_mutable_fetch() { if (!_internal_has_fetch()) { - clear_RelType(); + clear_rel_type(); set_has_fetch(); - RelType_.fetch_ = CreateMaybeMessage< ::io::substrait::FetchRel >(GetArena()); + rel_type_.fetch_ = CreateMaybeMessage< ::substrait::FetchRel >(GetArena()); } - return RelType_.fetch_; + return rel_type_.fetch_; } -inline ::io::substrait::FetchRel* Rel::mutable_fetch() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.fetch) +inline ::substrait::FetchRel* Rel::mutable_fetch() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.fetch) return _internal_mutable_fetch(); } -// .io.substrait.AggregateRel aggregate = 4; +// .substrait.AggregateRel aggregate = 4; inline bool Rel::_internal_has_aggregate() const { - return RelType_case() == kAggregate; + return rel_type_case() == kAggregate; } inline bool Rel::has_aggregate() const { return _internal_has_aggregate(); @@ -11070,69 +11144,69 @@ inline void Rel::set_has_aggregate() { inline void Rel::clear_aggregate() { if (_internal_has_aggregate()) { if (GetArena() == nullptr) { - delete RelType_.aggregate_; + delete rel_type_.aggregate_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::AggregateRel* Rel::release_aggregate() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.aggregate) +inline ::substrait::AggregateRel* Rel::release_aggregate() { + // @@protoc_insertion_point(field_release:substrait.Rel.aggregate) if (_internal_has_aggregate()) { - clear_has_RelType(); - ::io::substrait::AggregateRel* temp = RelType_.aggregate_; + clear_has_rel_type(); + ::substrait::AggregateRel* temp = rel_type_.aggregate_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.aggregate_ = nullptr; + rel_type_.aggregate_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::AggregateRel& Rel::_internal_aggregate() const { +inline const ::substrait::AggregateRel& Rel::_internal_aggregate() const { return _internal_has_aggregate() - ? *RelType_.aggregate_ - : reinterpret_cast< ::io::substrait::AggregateRel&>(::io::substrait::_AggregateRel_default_instance_); + ? *rel_type_.aggregate_ + : reinterpret_cast< ::substrait::AggregateRel&>(::substrait::_AggregateRel_default_instance_); } -inline const ::io::substrait::AggregateRel& Rel::aggregate() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.aggregate) +inline const ::substrait::AggregateRel& Rel::aggregate() const { + // @@protoc_insertion_point(field_get:substrait.Rel.aggregate) return _internal_aggregate(); } -inline ::io::substrait::AggregateRel* Rel::unsafe_arena_release_aggregate() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.aggregate) +inline ::substrait::AggregateRel* Rel::unsafe_arena_release_aggregate() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.aggregate) if (_internal_has_aggregate()) { - clear_has_RelType(); - ::io::substrait::AggregateRel* temp = RelType_.aggregate_; - RelType_.aggregate_ = nullptr; + clear_has_rel_type(); + ::substrait::AggregateRel* temp = rel_type_.aggregate_; + rel_type_.aggregate_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_aggregate(::io::substrait::AggregateRel* aggregate) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_aggregate(::substrait::AggregateRel* aggregate) { + clear_rel_type(); if (aggregate) { set_has_aggregate(); - RelType_.aggregate_ = aggregate; + rel_type_.aggregate_ = aggregate; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.aggregate) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.aggregate) } -inline ::io::substrait::AggregateRel* Rel::_internal_mutable_aggregate() { +inline ::substrait::AggregateRel* Rel::_internal_mutable_aggregate() { if (!_internal_has_aggregate()) { - clear_RelType(); + clear_rel_type(); set_has_aggregate(); - RelType_.aggregate_ = CreateMaybeMessage< ::io::substrait::AggregateRel >(GetArena()); + rel_type_.aggregate_ = CreateMaybeMessage< ::substrait::AggregateRel >(GetArena()); } - return RelType_.aggregate_; + return rel_type_.aggregate_; } -inline ::io::substrait::AggregateRel* Rel::mutable_aggregate() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.aggregate) +inline ::substrait::AggregateRel* Rel::mutable_aggregate() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.aggregate) return _internal_mutable_aggregate(); } -// .io.substrait.SortRel sort = 5; +// .substrait.SortRel sort = 5; inline bool Rel::_internal_has_sort() const { - return RelType_case() == kSort; + return rel_type_case() == kSort; } inline bool Rel::has_sort() const { return _internal_has_sort(); @@ -11143,69 +11217,69 @@ inline void Rel::set_has_sort() { inline void Rel::clear_sort() { if (_internal_has_sort()) { if (GetArena() == nullptr) { - delete RelType_.sort_; + delete rel_type_.sort_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::SortRel* Rel::release_sort() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.sort) +inline ::substrait::SortRel* Rel::release_sort() { + // @@protoc_insertion_point(field_release:substrait.Rel.sort) if (_internal_has_sort()) { - clear_has_RelType(); - ::io::substrait::SortRel* temp = RelType_.sort_; + clear_has_rel_type(); + ::substrait::SortRel* temp = rel_type_.sort_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.sort_ = nullptr; + rel_type_.sort_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::SortRel& Rel::_internal_sort() const { +inline const ::substrait::SortRel& Rel::_internal_sort() const { return _internal_has_sort() - ? *RelType_.sort_ - : reinterpret_cast< ::io::substrait::SortRel&>(::io::substrait::_SortRel_default_instance_); + ? *rel_type_.sort_ + : reinterpret_cast< ::substrait::SortRel&>(::substrait::_SortRel_default_instance_); } -inline const ::io::substrait::SortRel& Rel::sort() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.sort) +inline const ::substrait::SortRel& Rel::sort() const { + // @@protoc_insertion_point(field_get:substrait.Rel.sort) return _internal_sort(); } -inline ::io::substrait::SortRel* Rel::unsafe_arena_release_sort() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.sort) +inline ::substrait::SortRel* Rel::unsafe_arena_release_sort() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.sort) if (_internal_has_sort()) { - clear_has_RelType(); - ::io::substrait::SortRel* temp = RelType_.sort_; - RelType_.sort_ = nullptr; + clear_has_rel_type(); + ::substrait::SortRel* temp = rel_type_.sort_; + rel_type_.sort_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_sort(::io::substrait::SortRel* sort) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_sort(::substrait::SortRel* sort) { + clear_rel_type(); if (sort) { set_has_sort(); - RelType_.sort_ = sort; + rel_type_.sort_ = sort; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.sort) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.sort) } -inline ::io::substrait::SortRel* Rel::_internal_mutable_sort() { +inline ::substrait::SortRel* Rel::_internal_mutable_sort() { if (!_internal_has_sort()) { - clear_RelType(); + clear_rel_type(); set_has_sort(); - RelType_.sort_ = CreateMaybeMessage< ::io::substrait::SortRel >(GetArena()); + rel_type_.sort_ = CreateMaybeMessage< ::substrait::SortRel >(GetArena()); } - return RelType_.sort_; + return rel_type_.sort_; } -inline ::io::substrait::SortRel* Rel::mutable_sort() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.sort) +inline ::substrait::SortRel* Rel::mutable_sort() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.sort) return _internal_mutable_sort(); } -// .io.substrait.JoinRel join = 6; +// .substrait.JoinRel join = 6; inline bool Rel::_internal_has_join() const { - return RelType_case() == kJoin; + return rel_type_case() == kJoin; } inline bool Rel::has_join() const { return _internal_has_join(); @@ -11216,69 +11290,69 @@ inline void Rel::set_has_join() { inline void Rel::clear_join() { if (_internal_has_join()) { if (GetArena() == nullptr) { - delete RelType_.join_; + delete rel_type_.join_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::JoinRel* Rel::release_join() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.join) +inline ::substrait::JoinRel* Rel::release_join() { + // @@protoc_insertion_point(field_release:substrait.Rel.join) if (_internal_has_join()) { - clear_has_RelType(); - ::io::substrait::JoinRel* temp = RelType_.join_; + clear_has_rel_type(); + ::substrait::JoinRel* temp = rel_type_.join_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.join_ = nullptr; + rel_type_.join_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::JoinRel& Rel::_internal_join() const { +inline const ::substrait::JoinRel& Rel::_internal_join() const { return _internal_has_join() - ? *RelType_.join_ - : reinterpret_cast< ::io::substrait::JoinRel&>(::io::substrait::_JoinRel_default_instance_); + ? *rel_type_.join_ + : reinterpret_cast< ::substrait::JoinRel&>(::substrait::_JoinRel_default_instance_); } -inline const ::io::substrait::JoinRel& Rel::join() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.join) +inline const ::substrait::JoinRel& Rel::join() const { + // @@protoc_insertion_point(field_get:substrait.Rel.join) return _internal_join(); } -inline ::io::substrait::JoinRel* Rel::unsafe_arena_release_join() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.join) +inline ::substrait::JoinRel* Rel::unsafe_arena_release_join() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.join) if (_internal_has_join()) { - clear_has_RelType(); - ::io::substrait::JoinRel* temp = RelType_.join_; - RelType_.join_ = nullptr; + clear_has_rel_type(); + ::substrait::JoinRel* temp = rel_type_.join_; + rel_type_.join_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_join(::io::substrait::JoinRel* join) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_join(::substrait::JoinRel* join) { + clear_rel_type(); if (join) { set_has_join(); - RelType_.join_ = join; + rel_type_.join_ = join; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.join) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.join) } -inline ::io::substrait::JoinRel* Rel::_internal_mutable_join() { +inline ::substrait::JoinRel* Rel::_internal_mutable_join() { if (!_internal_has_join()) { - clear_RelType(); + clear_rel_type(); set_has_join(); - RelType_.join_ = CreateMaybeMessage< ::io::substrait::JoinRel >(GetArena()); + rel_type_.join_ = CreateMaybeMessage< ::substrait::JoinRel >(GetArena()); } - return RelType_.join_; + return rel_type_.join_; } -inline ::io::substrait::JoinRel* Rel::mutable_join() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.join) +inline ::substrait::JoinRel* Rel::mutable_join() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.join) return _internal_mutable_join(); } -// .io.substrait.ProjectRel project = 7; +// .substrait.ProjectRel project = 7; inline bool Rel::_internal_has_project() const { - return RelType_case() == kProject; + return rel_type_case() == kProject; } inline bool Rel::has_project() const { return _internal_has_project(); @@ -11289,69 +11363,69 @@ inline void Rel::set_has_project() { inline void Rel::clear_project() { if (_internal_has_project()) { if (GetArena() == nullptr) { - delete RelType_.project_; + delete rel_type_.project_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::ProjectRel* Rel::release_project() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.project) +inline ::substrait::ProjectRel* Rel::release_project() { + // @@protoc_insertion_point(field_release:substrait.Rel.project) if (_internal_has_project()) { - clear_has_RelType(); - ::io::substrait::ProjectRel* temp = RelType_.project_; + clear_has_rel_type(); + ::substrait::ProjectRel* temp = rel_type_.project_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.project_ = nullptr; + rel_type_.project_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::ProjectRel& Rel::_internal_project() const { +inline const ::substrait::ProjectRel& Rel::_internal_project() const { return _internal_has_project() - ? *RelType_.project_ - : reinterpret_cast< ::io::substrait::ProjectRel&>(::io::substrait::_ProjectRel_default_instance_); + ? *rel_type_.project_ + : reinterpret_cast< ::substrait::ProjectRel&>(::substrait::_ProjectRel_default_instance_); } -inline const ::io::substrait::ProjectRel& Rel::project() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.project) +inline const ::substrait::ProjectRel& Rel::project() const { + // @@protoc_insertion_point(field_get:substrait.Rel.project) return _internal_project(); } -inline ::io::substrait::ProjectRel* Rel::unsafe_arena_release_project() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.project) +inline ::substrait::ProjectRel* Rel::unsafe_arena_release_project() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.project) if (_internal_has_project()) { - clear_has_RelType(); - ::io::substrait::ProjectRel* temp = RelType_.project_; - RelType_.project_ = nullptr; + clear_has_rel_type(); + ::substrait::ProjectRel* temp = rel_type_.project_; + rel_type_.project_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_project(::io::substrait::ProjectRel* project) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_project(::substrait::ProjectRel* project) { + clear_rel_type(); if (project) { set_has_project(); - RelType_.project_ = project; + rel_type_.project_ = project; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.project) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.project) } -inline ::io::substrait::ProjectRel* Rel::_internal_mutable_project() { +inline ::substrait::ProjectRel* Rel::_internal_mutable_project() { if (!_internal_has_project()) { - clear_RelType(); + clear_rel_type(); set_has_project(); - RelType_.project_ = CreateMaybeMessage< ::io::substrait::ProjectRel >(GetArena()); + rel_type_.project_ = CreateMaybeMessage< ::substrait::ProjectRel >(GetArena()); } - return RelType_.project_; + return rel_type_.project_; } -inline ::io::substrait::ProjectRel* Rel::mutable_project() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.project) +inline ::substrait::ProjectRel* Rel::mutable_project() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.project) return _internal_mutable_project(); } -// .io.substrait.SetRel set = 8; +// .substrait.SetRel set = 8; inline bool Rel::_internal_has_set() const { - return RelType_case() == kSet; + return rel_type_case() == kSet; } inline bool Rel::has_set() const { return _internal_has_set(); @@ -11362,69 +11436,69 @@ inline void Rel::set_has_set() { inline void Rel::clear_set() { if (_internal_has_set()) { if (GetArena() == nullptr) { - delete RelType_.set_; + delete rel_type_.set_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::SetRel* Rel::release_set() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.set) +inline ::substrait::SetRel* Rel::release_set() { + // @@protoc_insertion_point(field_release:substrait.Rel.set) if (_internal_has_set()) { - clear_has_RelType(); - ::io::substrait::SetRel* temp = RelType_.set_; + clear_has_rel_type(); + ::substrait::SetRel* temp = rel_type_.set_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.set_ = nullptr; + rel_type_.set_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::SetRel& Rel::_internal_set() const { +inline const ::substrait::SetRel& Rel::_internal_set() const { return _internal_has_set() - ? *RelType_.set_ - : reinterpret_cast< ::io::substrait::SetRel&>(::io::substrait::_SetRel_default_instance_); + ? *rel_type_.set_ + : reinterpret_cast< ::substrait::SetRel&>(::substrait::_SetRel_default_instance_); } -inline const ::io::substrait::SetRel& Rel::set() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.set) +inline const ::substrait::SetRel& Rel::set() const { + // @@protoc_insertion_point(field_get:substrait.Rel.set) return _internal_set(); } -inline ::io::substrait::SetRel* Rel::unsafe_arena_release_set() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.set) +inline ::substrait::SetRel* Rel::unsafe_arena_release_set() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.set) if (_internal_has_set()) { - clear_has_RelType(); - ::io::substrait::SetRel* temp = RelType_.set_; - RelType_.set_ = nullptr; + clear_has_rel_type(); + ::substrait::SetRel* temp = rel_type_.set_; + rel_type_.set_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_set(::io::substrait::SetRel* set) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_set(::substrait::SetRel* set) { + clear_rel_type(); if (set) { set_has_set(); - RelType_.set_ = set; + rel_type_.set_ = set; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.set) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.set) } -inline ::io::substrait::SetRel* Rel::_internal_mutable_set() { +inline ::substrait::SetRel* Rel::_internal_mutable_set() { if (!_internal_has_set()) { - clear_RelType(); + clear_rel_type(); set_has_set(); - RelType_.set_ = CreateMaybeMessage< ::io::substrait::SetRel >(GetArena()); + rel_type_.set_ = CreateMaybeMessage< ::substrait::SetRel >(GetArena()); } - return RelType_.set_; + return rel_type_.set_; } -inline ::io::substrait::SetRel* Rel::mutable_set() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.set) +inline ::substrait::SetRel* Rel::mutable_set() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.set) return _internal_mutable_set(); } -// .io.substrait.ExtensionSingleRel extension_single = 9; +// .substrait.ExtensionSingleRel extension_single = 9; inline bool Rel::_internal_has_extension_single() const { - return RelType_case() == kExtensionSingle; + return rel_type_case() == kExtensionSingle; } inline bool Rel::has_extension_single() const { return _internal_has_extension_single(); @@ -11435,69 +11509,69 @@ inline void Rel::set_has_extension_single() { inline void Rel::clear_extension_single() { if (_internal_has_extension_single()) { if (GetArena() == nullptr) { - delete RelType_.extension_single_; + delete rel_type_.extension_single_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::ExtensionSingleRel* Rel::release_extension_single() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.extension_single) +inline ::substrait::ExtensionSingleRel* Rel::release_extension_single() { + // @@protoc_insertion_point(field_release:substrait.Rel.extension_single) if (_internal_has_extension_single()) { - clear_has_RelType(); - ::io::substrait::ExtensionSingleRel* temp = RelType_.extension_single_; + clear_has_rel_type(); + ::substrait::ExtensionSingleRel* temp = rel_type_.extension_single_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.extension_single_ = nullptr; + rel_type_.extension_single_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::ExtensionSingleRel& Rel::_internal_extension_single() const { +inline const ::substrait::ExtensionSingleRel& Rel::_internal_extension_single() const { return _internal_has_extension_single() - ? *RelType_.extension_single_ - : reinterpret_cast< ::io::substrait::ExtensionSingleRel&>(::io::substrait::_ExtensionSingleRel_default_instance_); + ? *rel_type_.extension_single_ + : reinterpret_cast< ::substrait::ExtensionSingleRel&>(::substrait::_ExtensionSingleRel_default_instance_); } -inline const ::io::substrait::ExtensionSingleRel& Rel::extension_single() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.extension_single) +inline const ::substrait::ExtensionSingleRel& Rel::extension_single() const { + // @@protoc_insertion_point(field_get:substrait.Rel.extension_single) return _internal_extension_single(); } -inline ::io::substrait::ExtensionSingleRel* Rel::unsafe_arena_release_extension_single() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.extension_single) +inline ::substrait::ExtensionSingleRel* Rel::unsafe_arena_release_extension_single() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.extension_single) if (_internal_has_extension_single()) { - clear_has_RelType(); - ::io::substrait::ExtensionSingleRel* temp = RelType_.extension_single_; - RelType_.extension_single_ = nullptr; + clear_has_rel_type(); + ::substrait::ExtensionSingleRel* temp = rel_type_.extension_single_; + rel_type_.extension_single_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_extension_single(::io::substrait::ExtensionSingleRel* extension_single) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single) { + clear_rel_type(); if (extension_single) { set_has_extension_single(); - RelType_.extension_single_ = extension_single; + rel_type_.extension_single_ = extension_single; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.extension_single) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.extension_single) } -inline ::io::substrait::ExtensionSingleRel* Rel::_internal_mutable_extension_single() { +inline ::substrait::ExtensionSingleRel* Rel::_internal_mutable_extension_single() { if (!_internal_has_extension_single()) { - clear_RelType(); + clear_rel_type(); set_has_extension_single(); - RelType_.extension_single_ = CreateMaybeMessage< ::io::substrait::ExtensionSingleRel >(GetArena()); + rel_type_.extension_single_ = CreateMaybeMessage< ::substrait::ExtensionSingleRel >(GetArena()); } - return RelType_.extension_single_; + return rel_type_.extension_single_; } -inline ::io::substrait::ExtensionSingleRel* Rel::mutable_extension_single() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.extension_single) +inline ::substrait::ExtensionSingleRel* Rel::mutable_extension_single() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_single) return _internal_mutable_extension_single(); } -// .io.substrait.ExtensionMultiRel extension_multi = 10; +// .substrait.ExtensionMultiRel extension_multi = 10; inline bool Rel::_internal_has_extension_multi() const { - return RelType_case() == kExtensionMulti; + return rel_type_case() == kExtensionMulti; } inline bool Rel::has_extension_multi() const { return _internal_has_extension_multi(); @@ -11508,69 +11582,69 @@ inline void Rel::set_has_extension_multi() { inline void Rel::clear_extension_multi() { if (_internal_has_extension_multi()) { if (GetArena() == nullptr) { - delete RelType_.extension_multi_; + delete rel_type_.extension_multi_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::ExtensionMultiRel* Rel::release_extension_multi() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.extension_multi) +inline ::substrait::ExtensionMultiRel* Rel::release_extension_multi() { + // @@protoc_insertion_point(field_release:substrait.Rel.extension_multi) if (_internal_has_extension_multi()) { - clear_has_RelType(); - ::io::substrait::ExtensionMultiRel* temp = RelType_.extension_multi_; + clear_has_rel_type(); + ::substrait::ExtensionMultiRel* temp = rel_type_.extension_multi_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.extension_multi_ = nullptr; + rel_type_.extension_multi_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::ExtensionMultiRel& Rel::_internal_extension_multi() const { +inline const ::substrait::ExtensionMultiRel& Rel::_internal_extension_multi() const { return _internal_has_extension_multi() - ? *RelType_.extension_multi_ - : reinterpret_cast< ::io::substrait::ExtensionMultiRel&>(::io::substrait::_ExtensionMultiRel_default_instance_); + ? *rel_type_.extension_multi_ + : reinterpret_cast< ::substrait::ExtensionMultiRel&>(::substrait::_ExtensionMultiRel_default_instance_); } -inline const ::io::substrait::ExtensionMultiRel& Rel::extension_multi() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.extension_multi) +inline const ::substrait::ExtensionMultiRel& Rel::extension_multi() const { + // @@protoc_insertion_point(field_get:substrait.Rel.extension_multi) return _internal_extension_multi(); } -inline ::io::substrait::ExtensionMultiRel* Rel::unsafe_arena_release_extension_multi() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.extension_multi) +inline ::substrait::ExtensionMultiRel* Rel::unsafe_arena_release_extension_multi() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.extension_multi) if (_internal_has_extension_multi()) { - clear_has_RelType(); - ::io::substrait::ExtensionMultiRel* temp = RelType_.extension_multi_; - RelType_.extension_multi_ = nullptr; + clear_has_rel_type(); + ::substrait::ExtensionMultiRel* temp = rel_type_.extension_multi_; + rel_type_.extension_multi_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_extension_multi(::io::substrait::ExtensionMultiRel* extension_multi) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi) { + clear_rel_type(); if (extension_multi) { set_has_extension_multi(); - RelType_.extension_multi_ = extension_multi; + rel_type_.extension_multi_ = extension_multi; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.extension_multi) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.extension_multi) } -inline ::io::substrait::ExtensionMultiRel* Rel::_internal_mutable_extension_multi() { +inline ::substrait::ExtensionMultiRel* Rel::_internal_mutable_extension_multi() { if (!_internal_has_extension_multi()) { - clear_RelType(); + clear_rel_type(); set_has_extension_multi(); - RelType_.extension_multi_ = CreateMaybeMessage< ::io::substrait::ExtensionMultiRel >(GetArena()); + rel_type_.extension_multi_ = CreateMaybeMessage< ::substrait::ExtensionMultiRel >(GetArena()); } - return RelType_.extension_multi_; + return rel_type_.extension_multi_; } -inline ::io::substrait::ExtensionMultiRel* Rel::mutable_extension_multi() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.extension_multi) +inline ::substrait::ExtensionMultiRel* Rel::mutable_extension_multi() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_multi) return _internal_mutable_extension_multi(); } -// .io.substrait.ExtensionLeafRel extension_leaf = 11; +// .substrait.ExtensionLeafRel extension_leaf = 11; inline bool Rel::_internal_has_extension_leaf() const { - return RelType_case() == kExtensionLeaf; + return rel_type_case() == kExtensionLeaf; } inline bool Rel::has_extension_leaf() const { return _internal_has_extension_leaf(); @@ -11581,73 +11655,73 @@ inline void Rel::set_has_extension_leaf() { inline void Rel::clear_extension_leaf() { if (_internal_has_extension_leaf()) { if (GetArena() == nullptr) { - delete RelType_.extension_leaf_; + delete rel_type_.extension_leaf_; } - clear_has_RelType(); + clear_has_rel_type(); } } -inline ::io::substrait::ExtensionLeafRel* Rel::release_extension_leaf() { - // @@protoc_insertion_point(field_release:io.substrait.Rel.extension_leaf) +inline ::substrait::ExtensionLeafRel* Rel::release_extension_leaf() { + // @@protoc_insertion_point(field_release:substrait.Rel.extension_leaf) if (_internal_has_extension_leaf()) { - clear_has_RelType(); - ::io::substrait::ExtensionLeafRel* temp = RelType_.extension_leaf_; + clear_has_rel_type(); + ::substrait::ExtensionLeafRel* temp = rel_type_.extension_leaf_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } - RelType_.extension_leaf_ = nullptr; + rel_type_.extension_leaf_ = nullptr; return temp; } else { return nullptr; } } -inline const ::io::substrait::ExtensionLeafRel& Rel::_internal_extension_leaf() const { +inline const ::substrait::ExtensionLeafRel& Rel::_internal_extension_leaf() const { return _internal_has_extension_leaf() - ? *RelType_.extension_leaf_ - : reinterpret_cast< ::io::substrait::ExtensionLeafRel&>(::io::substrait::_ExtensionLeafRel_default_instance_); + ? *rel_type_.extension_leaf_ + : reinterpret_cast< ::substrait::ExtensionLeafRel&>(::substrait::_ExtensionLeafRel_default_instance_); } -inline const ::io::substrait::ExtensionLeafRel& Rel::extension_leaf() const { - // @@protoc_insertion_point(field_get:io.substrait.Rel.extension_leaf) +inline const ::substrait::ExtensionLeafRel& Rel::extension_leaf() const { + // @@protoc_insertion_point(field_get:substrait.Rel.extension_leaf) return _internal_extension_leaf(); } -inline ::io::substrait::ExtensionLeafRel* Rel::unsafe_arena_release_extension_leaf() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Rel.extension_leaf) +inline ::substrait::ExtensionLeafRel* Rel::unsafe_arena_release_extension_leaf() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.extension_leaf) if (_internal_has_extension_leaf()) { - clear_has_RelType(); - ::io::substrait::ExtensionLeafRel* temp = RelType_.extension_leaf_; - RelType_.extension_leaf_ = nullptr; + clear_has_rel_type(); + ::substrait::ExtensionLeafRel* temp = rel_type_.extension_leaf_; + rel_type_.extension_leaf_ = nullptr; return temp; } else { return nullptr; } } -inline void Rel::unsafe_arena_set_allocated_extension_leaf(::io::substrait::ExtensionLeafRel* extension_leaf) { - clear_RelType(); +inline void Rel::unsafe_arena_set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf) { + clear_rel_type(); if (extension_leaf) { set_has_extension_leaf(); - RelType_.extension_leaf_ = extension_leaf; + rel_type_.extension_leaf_ = extension_leaf; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Rel.extension_leaf) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.extension_leaf) } -inline ::io::substrait::ExtensionLeafRel* Rel::_internal_mutable_extension_leaf() { +inline ::substrait::ExtensionLeafRel* Rel::_internal_mutable_extension_leaf() { if (!_internal_has_extension_leaf()) { - clear_RelType(); + clear_rel_type(); set_has_extension_leaf(); - RelType_.extension_leaf_ = CreateMaybeMessage< ::io::substrait::ExtensionLeafRel >(GetArena()); + rel_type_.extension_leaf_ = CreateMaybeMessage< ::substrait::ExtensionLeafRel >(GetArena()); } - return RelType_.extension_leaf_; + return rel_type_.extension_leaf_; } -inline ::io::substrait::ExtensionLeafRel* Rel::mutable_extension_leaf() { - // @@protoc_insertion_point(field_mutable:io.substrait.Rel.extension_leaf) +inline ::substrait::ExtensionLeafRel* Rel::mutable_extension_leaf() { + // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_leaf) return _internal_mutable_extension_leaf(); } -inline bool Rel::has_RelType() const { - return RelType_case() != RELTYPE_NOT_SET; +inline bool Rel::has_rel_type() const { + return rel_type_case() != REL_TYPE_NOT_SET; } -inline void Rel::clear_has_RelType() { - _oneof_case_[0] = RELTYPE_NOT_SET; +inline void Rel::clear_has_rel_type() { + _oneof_case_[0] = REL_TYPE_NOT_SET; } -inline Rel::RelTypeCase Rel::RelType_case() const { +inline Rel::RelTypeCase Rel::rel_type_case() const { return Rel::RelTypeCase(_oneof_case_[0]); } #ifdef __GNUC__ @@ -11707,24 +11781,23 @@ inline Rel::RelTypeCase Rel::RelType_case() const { // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template <> struct is_proto_enum< ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format>() { - return ::io::substrait::ReadRel_LocalFiles_FileOrFiles_Format_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat>() { + return ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(); } -template <> struct is_proto_enum< ::io::substrait::JoinRel_JoinType> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::JoinRel_JoinType> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::JoinRel_JoinType>() { - return ::io::substrait::JoinRel_JoinType_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::JoinRel_JoinType>() { + return ::substrait::JoinRel_JoinType_descriptor(); } -template <> struct is_proto_enum< ::io::substrait::SetRel_SetOp> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::SetRel_SetOp> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::SetRel_SetOp>() { - return ::io::substrait::SetRel_SetOp_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::SetRel_SetOp>() { + return ::substrait::SetRel_SetOp_descriptor(); } PROTOBUF_NAMESPACE_CLOSE @@ -11732,4 +11805,4 @@ PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_relations_2eproto +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2frelations_2eproto diff --git a/cpp/src/generated/substrait/type.pb.cc b/cpp/src/generated/substrait/type.pb.cc index 62a35389b7b..4f567b5d0a8 100644 --- a/cpp/src/generated/substrait/type.pb.cc +++ b/cpp/src/generated/substrait/type.pb.cc @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: type.proto +// source: substrait/type.proto -#include "type.pb.h" +#include "substrait/type.pb.h" #include @@ -16,7 +16,6 @@ #include PROTOBUF_PRAGMA_INIT_SEG -namespace io { namespace substrait { constexpr Type_Boolean::Type_Boolean( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) @@ -375,186 +374,185 @@ struct NamedStructDefaultTypeInternal { }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NamedStructDefaultTypeInternal _NamedStruct_default_instance_; } // namespace substrait -} // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_type_2eproto[25]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_type_2eproto[1]; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_type_2eproto = nullptr; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ftype_2eproto[25]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ftype_2eproto[1]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ftype_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Boolean, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Boolean, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Boolean, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I8, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I8, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I8, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I16, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I16, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I16, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I32, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I32, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I32, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I64, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I64, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_I64, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP32, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP32, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP32, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP64, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP64, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FP64, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_String, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_String, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_String, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_String, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_String, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_String, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Binary, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Binary, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Binary, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Timestamp, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Timestamp, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Timestamp, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Date, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Date, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Date, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Time, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Time, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Time, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_TimestampTZ, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_TimestampTZ, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_TimestampTZ, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalYear, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalYear, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalYear, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalDay, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalDay, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_IntervalDay, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_UUID, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_UUID, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_UUID, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedChar, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, length_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_VarChar, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, length_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_FixedBinary, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, length_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, scale_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, precision_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Decimal, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, scale_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, precision_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, types_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Struct, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, types_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_List, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_List, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_List, type_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_List, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_List, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, key_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, value_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::Type_Map, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, key_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, value_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, type_variation_reference_), + PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::Type, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::Type, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::Type, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -580,190 +578,188 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_2eproto::offsets[] PROTOB ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::Type, kind_), + PROTOBUF_FIELD_OFFSET(::substrait::Type, kind_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::NamedStruct, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::NamedStruct, names_), - PROTOBUF_FIELD_OFFSET(::io::substrait::NamedStruct, struct__), + PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, names_), + PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, struct__), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::Type_Boolean)}, - { 7, -1, sizeof(::io::substrait::Type_I8)}, - { 14, -1, sizeof(::io::substrait::Type_I16)}, - { 21, -1, sizeof(::io::substrait::Type_I32)}, - { 28, -1, sizeof(::io::substrait::Type_I64)}, - { 35, -1, sizeof(::io::substrait::Type_FP32)}, - { 42, -1, sizeof(::io::substrait::Type_FP64)}, - { 49, -1, sizeof(::io::substrait::Type_String)}, - { 56, -1, sizeof(::io::substrait::Type_Binary)}, - { 63, -1, sizeof(::io::substrait::Type_Timestamp)}, - { 70, -1, sizeof(::io::substrait::Type_Date)}, - { 77, -1, sizeof(::io::substrait::Type_Time)}, - { 84, -1, sizeof(::io::substrait::Type_TimestampTZ)}, - { 91, -1, sizeof(::io::substrait::Type_IntervalYear)}, - { 98, -1, sizeof(::io::substrait::Type_IntervalDay)}, - { 105, -1, sizeof(::io::substrait::Type_UUID)}, - { 112, -1, sizeof(::io::substrait::Type_FixedChar)}, - { 120, -1, sizeof(::io::substrait::Type_VarChar)}, - { 128, -1, sizeof(::io::substrait::Type_FixedBinary)}, - { 136, -1, sizeof(::io::substrait::Type_Decimal)}, - { 145, -1, sizeof(::io::substrait::Type_Struct)}, - { 153, -1, sizeof(::io::substrait::Type_List)}, - { 161, -1, sizeof(::io::substrait::Type_Map)}, - { 170, -1, sizeof(::io::substrait::Type)}, - { 200, -1, sizeof(::io::substrait::NamedStruct)}, + { 0, -1, sizeof(::substrait::Type_Boolean)}, + { 7, -1, sizeof(::substrait::Type_I8)}, + { 14, -1, sizeof(::substrait::Type_I16)}, + { 21, -1, sizeof(::substrait::Type_I32)}, + { 28, -1, sizeof(::substrait::Type_I64)}, + { 35, -1, sizeof(::substrait::Type_FP32)}, + { 42, -1, sizeof(::substrait::Type_FP64)}, + { 49, -1, sizeof(::substrait::Type_String)}, + { 56, -1, sizeof(::substrait::Type_Binary)}, + { 63, -1, sizeof(::substrait::Type_Timestamp)}, + { 70, -1, sizeof(::substrait::Type_Date)}, + { 77, -1, sizeof(::substrait::Type_Time)}, + { 84, -1, sizeof(::substrait::Type_TimestampTZ)}, + { 91, -1, sizeof(::substrait::Type_IntervalYear)}, + { 98, -1, sizeof(::substrait::Type_IntervalDay)}, + { 105, -1, sizeof(::substrait::Type_UUID)}, + { 112, -1, sizeof(::substrait::Type_FixedChar)}, + { 120, -1, sizeof(::substrait::Type_VarChar)}, + { 128, -1, sizeof(::substrait::Type_FixedBinary)}, + { 136, -1, sizeof(::substrait::Type_Decimal)}, + { 145, -1, sizeof(::substrait::Type_Struct)}, + { 153, -1, sizeof(::substrait::Type_List)}, + { 161, -1, sizeof(::substrait::Type_Map)}, + { 170, -1, sizeof(::substrait::Type)}, + { 200, -1, sizeof(::substrait::NamedStruct)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::_Type_Boolean_default_instance_), - reinterpret_cast(&::io::substrait::_Type_I8_default_instance_), - reinterpret_cast(&::io::substrait::_Type_I16_default_instance_), - reinterpret_cast(&::io::substrait::_Type_I32_default_instance_), - reinterpret_cast(&::io::substrait::_Type_I64_default_instance_), - reinterpret_cast(&::io::substrait::_Type_FP32_default_instance_), - reinterpret_cast(&::io::substrait::_Type_FP64_default_instance_), - reinterpret_cast(&::io::substrait::_Type_String_default_instance_), - reinterpret_cast(&::io::substrait::_Type_Binary_default_instance_), - reinterpret_cast(&::io::substrait::_Type_Timestamp_default_instance_), - reinterpret_cast(&::io::substrait::_Type_Date_default_instance_), - reinterpret_cast(&::io::substrait::_Type_Time_default_instance_), - reinterpret_cast(&::io::substrait::_Type_TimestampTZ_default_instance_), - reinterpret_cast(&::io::substrait::_Type_IntervalYear_default_instance_), - reinterpret_cast(&::io::substrait::_Type_IntervalDay_default_instance_), - reinterpret_cast(&::io::substrait::_Type_UUID_default_instance_), - reinterpret_cast(&::io::substrait::_Type_FixedChar_default_instance_), - reinterpret_cast(&::io::substrait::_Type_VarChar_default_instance_), - reinterpret_cast(&::io::substrait::_Type_FixedBinary_default_instance_), - reinterpret_cast(&::io::substrait::_Type_Decimal_default_instance_), - reinterpret_cast(&::io::substrait::_Type_Struct_default_instance_), - reinterpret_cast(&::io::substrait::_Type_List_default_instance_), - reinterpret_cast(&::io::substrait::_Type_Map_default_instance_), - reinterpret_cast(&::io::substrait::_Type_default_instance_), - reinterpret_cast(&::io::substrait::_NamedStruct_default_instance_), + reinterpret_cast(&::substrait::_Type_Boolean_default_instance_), + reinterpret_cast(&::substrait::_Type_I8_default_instance_), + reinterpret_cast(&::substrait::_Type_I16_default_instance_), + reinterpret_cast(&::substrait::_Type_I32_default_instance_), + reinterpret_cast(&::substrait::_Type_I64_default_instance_), + reinterpret_cast(&::substrait::_Type_FP32_default_instance_), + reinterpret_cast(&::substrait::_Type_FP64_default_instance_), + reinterpret_cast(&::substrait::_Type_String_default_instance_), + reinterpret_cast(&::substrait::_Type_Binary_default_instance_), + reinterpret_cast(&::substrait::_Type_Timestamp_default_instance_), + reinterpret_cast(&::substrait::_Type_Date_default_instance_), + reinterpret_cast(&::substrait::_Type_Time_default_instance_), + reinterpret_cast(&::substrait::_Type_TimestampTZ_default_instance_), + reinterpret_cast(&::substrait::_Type_IntervalYear_default_instance_), + reinterpret_cast(&::substrait::_Type_IntervalDay_default_instance_), + reinterpret_cast(&::substrait::_Type_UUID_default_instance_), + reinterpret_cast(&::substrait::_Type_FixedChar_default_instance_), + reinterpret_cast(&::substrait::_Type_VarChar_default_instance_), + reinterpret_cast(&::substrait::_Type_FixedBinary_default_instance_), + reinterpret_cast(&::substrait::_Type_Decimal_default_instance_), + reinterpret_cast(&::substrait::_Type_Struct_default_instance_), + reinterpret_cast(&::substrait::_Type_List_default_instance_), + reinterpret_cast(&::substrait::_Type_Map_default_instance_), + reinterpret_cast(&::substrait::_Type_default_instance_), + reinterpret_cast(&::substrait::_NamedStruct_default_instance_), }; -const char descriptor_table_protodef_type_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\ntype.proto\022\014io.substrait\"\210\034\n\004Type\022*\n\004b" - "ool\030\001 \001(\0132\032.io.substrait.Type.BooleanH\000\022" - "#\n\002i8\030\002 \001(\0132\025.io.substrait.Type.I8H\000\022%\n\003" - "i16\030\003 \001(\0132\026.io.substrait.Type.I16H\000\022%\n\003i" - "32\030\005 \001(\0132\026.io.substrait.Type.I32H\000\022%\n\003i6" - "4\030\007 \001(\0132\026.io.substrait.Type.I64H\000\022\'\n\004fp3" - "2\030\n \001(\0132\027.io.substrait.Type.FP32H\000\022\'\n\004fp" - "64\030\013 \001(\0132\027.io.substrait.Type.FP64H\000\022+\n\006s" - "tring\030\014 \001(\0132\031.io.substrait.Type.StringH\000" - "\022+\n\006binary\030\r \001(\0132\031.io.substrait.Type.Bin" - "aryH\000\0221\n\ttimestamp\030\016 \001(\0132\034.io.substrait." - "Type.TimestampH\000\022\'\n\004date\030\020 \001(\0132\027.io.subs" - "trait.Type.DateH\000\022\'\n\004time\030\021 \001(\0132\027.io.sub" - "strait.Type.TimeH\000\0228\n\rinterval_year\030\023 \001(" - "\0132\037.io.substrait.Type.IntervalYearH\000\0226\n\014" - "interval_day\030\024 \001(\0132\036.io.substrait.Type.I" - "ntervalDayH\000\0226\n\014timestamp_tz\030\035 \001(\0132\036.io." - "substrait.Type.TimestampTZH\000\022\'\n\004uuid\030 \001" - "(\0132\027.io.substrait.Type.UUIDH\000\0222\n\nfixed_c" - "har\030\025 \001(\0132\034.io.substrait.Type.FixedCharH" - "\000\022-\n\007varchar\030\026 \001(\0132\032.io.substrait.Type.V" - "arCharH\000\0226\n\014fixed_binary\030\027 \001(\0132\036.io.subs" - "trait.Type.FixedBinaryH\000\022-\n\007decimal\030\030 \001(" - "\0132\032.io.substrait.Type.DecimalH\000\022+\n\006struc" - "t\030\031 \001(\0132\031.io.substrait.Type.StructH\000\022\'\n\004" - "list\030\033 \001(\0132\027.io.substrait.Type.ListH\000\022%\n" - "\003map\030\034 \001(\0132\026.io.substrait.Type.MapH\000\022%\n\033" - "user_defined_type_reference\030\037 \001(\rH\000\032`\n\007B" - "oolean\022 \n\030type_variation_reference\030\001 \001(\r" - "\0223\n\013nullability\030\002 \001(\0162\036.io.substrait.Typ" - "e.Nullability\032[\n\002I8\022 \n\030type_variation_re" - "ference\030\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.io." - "substrait.Type.Nullability\032\\\n\003I16\022 \n\030typ" - "e_variation_reference\030\001 \001(\r\0223\n\013nullabili" - "ty\030\002 \001(\0162\036.io.substrait.Type.Nullability" - "\032\\\n\003I32\022 \n\030type_variation_reference\030\001 \001(" - "\r\0223\n\013nullability\030\002 \001(\0162\036.io.substrait.Ty" - "pe.Nullability\032\\\n\003I64\022 \n\030type_variation_" - "reference\030\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.i" - "o.substrait.Type.Nullability\032]\n\004FP32\022 \n\030" - "type_variation_reference\030\001 \001(\r\0223\n\013nullab" - "ility\030\002 \001(\0162\036.io.substrait.Type.Nullabil" - "ity\032]\n\004FP64\022 \n\030type_variation_reference\030" - "\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.io.substrai" - "t.Type.Nullability\032_\n\006String\022 \n\030type_var" - "iation_reference\030\001 \001(\r\0223\n\013nullability\030\002 " - "\001(\0162\036.io.substrait.Type.Nullability\032_\n\006B" - "inary\022 \n\030type_variation_reference\030\001 \001(\r\022" - "3\n\013nullability\030\002 \001(\0162\036.io.substrait.Type" - ".Nullability\032b\n\tTimestamp\022 \n\030type_variat" - "ion_reference\030\001 \001(\r\0223\n\013nullability\030\002 \001(\016" - "2\036.io.substrait.Type.Nullability\032]\n\004Date" - "\022 \n\030type_variation_reference\030\001 \001(\r\0223\n\013nu" - "llability\030\002 \001(\0162\036.io.substrait.Type.Null" - "ability\032]\n\004Time\022 \n\030type_variation_refere" - "nce\030\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.io.subs" - "trait.Type.Nullability\032d\n\013TimestampTZ\022 \n" - "\030type_variation_reference\030\001 \001(\r\0223\n\013nulla" - "bility\030\002 \001(\0162\036.io.substrait.Type.Nullabi" - "lity\032e\n\014IntervalYear\022 \n\030type_variation_r" - "eference\030\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.io" - ".substrait.Type.Nullability\032d\n\013IntervalD" - "ay\022 \n\030type_variation_reference\030\001 \001(\r\0223\n\013" - "nullability\030\002 \001(\0162\036.io.substrait.Type.Nu" - "llability\032]\n\004UUID\022 \n\030type_variation_refe" - "rence\030\001 \001(\r\0223\n\013nullability\030\002 \001(\0162\036.io.su" - "bstrait.Type.Nullability\032r\n\tFixedChar\022\016\n" - "\006length\030\001 \001(\005\022 \n\030type_variation_referenc" - "e\030\002 \001(\r\0223\n\013nullability\030\003 \001(\0162\036.io.substr" - "ait.Type.Nullability\032p\n\007VarChar\022\016\n\006lengt" - "h\030\001 \001(\005\022 \n\030type_variation_reference\030\002 \001(" - "\r\0223\n\013nullability\030\003 \001(\0162\036.io.substrait.Ty" - "pe.Nullability\032t\n\013FixedBinary\022\016\n\006length\030" - "\001 \001(\005\022 \n\030type_variation_reference\030\002 \001(\r\022" - "3\n\013nullability\030\003 \001(\0162\036.io.substrait.Type" - ".Nullability\032\202\001\n\007Decimal\022\r\n\005scale\030\001 \001(\005\022" +const char descriptor_table_protodef_substrait_2ftype_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n\024substrait/type.proto\022\tsubstrait\"\245\033\n\004Ty" + "pe\022\'\n\004bool\030\001 \001(\0132\027.substrait.Type.Boolea" + "nH\000\022 \n\002i8\030\002 \001(\0132\022.substrait.Type.I8H\000\022\"\n" + "\003i16\030\003 \001(\0132\023.substrait.Type.I16H\000\022\"\n\003i32" + "\030\005 \001(\0132\023.substrait.Type.I32H\000\022\"\n\003i64\030\007 \001" + "(\0132\023.substrait.Type.I64H\000\022$\n\004fp32\030\n \001(\0132" + "\024.substrait.Type.FP32H\000\022$\n\004fp64\030\013 \001(\0132\024." + "substrait.Type.FP64H\000\022(\n\006string\030\014 \001(\0132\026." + "substrait.Type.StringH\000\022(\n\006binary\030\r \001(\0132" + "\026.substrait.Type.BinaryH\000\022.\n\ttimestamp\030\016" + " \001(\0132\031.substrait.Type.TimestampH\000\022$\n\004dat" + "e\030\020 \001(\0132\024.substrait.Type.DateH\000\022$\n\004time\030" + "\021 \001(\0132\024.substrait.Type.TimeH\000\0225\n\rinterva" + "l_year\030\023 \001(\0132\034.substrait.Type.IntervalYe" + "arH\000\0223\n\014interval_day\030\024 \001(\0132\033.substrait.T" + "ype.IntervalDayH\000\0223\n\014timestamp_tz\030\035 \001(\0132" + "\033.substrait.Type.TimestampTZH\000\022$\n\004uuid\030 " + " \001(\0132\024.substrait.Type.UUIDH\000\022/\n\nfixed_ch" + "ar\030\025 \001(\0132\031.substrait.Type.FixedCharH\000\022*\n" + "\007varchar\030\026 \001(\0132\027.substrait.Type.VarCharH" + "\000\0223\n\014fixed_binary\030\027 \001(\0132\033.substrait.Type" + ".FixedBinaryH\000\022*\n\007decimal\030\030 \001(\0132\027.substr" + "ait.Type.DecimalH\000\022(\n\006struct\030\031 \001(\0132\026.sub" + "strait.Type.StructH\000\022$\n\004list\030\033 \001(\0132\024.sub" + "strait.Type.ListH\000\022\"\n\003map\030\034 \001(\0132\023.substr" + "ait.Type.MapH\000\022%\n\033user_defined_type_refe" + "rence\030\037 \001(\rH\000\032]\n\007Boolean\022 \n\030type_variati" + "on_reference\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162" + "\033.substrait.Type.Nullability\032X\n\002I8\022 \n\030ty" + "pe_variation_reference\030\001 \001(\r\0220\n\013nullabil" + "ity\030\002 \001(\0162\033.substrait.Type.Nullability\032Y" + "\n\003I16\022 \n\030type_variation_reference\030\001 \001(\r\022" + "0\n\013nullability\030\002 \001(\0162\033.substrait.Type.Nu" + "llability\032Y\n\003I32\022 \n\030type_variation_refer" + "ence\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.substr" + "ait.Type.Nullability\032Y\n\003I64\022 \n\030type_vari" + "ation_reference\030\001 \001(\r\0220\n\013nullability\030\002 \001" + "(\0162\033.substrait.Type.Nullability\032Z\n\004FP32\022" + " \n\030type_variation_reference\030\001 \001(\r\0220\n\013nul" + "lability\030\002 \001(\0162\033.substrait.Type.Nullabil" + "ity\032Z\n\004FP64\022 \n\030type_variation_reference\030" + "\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.substrait.T" + "ype.Nullability\032\\\n\006String\022 \n\030type_variat" + "ion_reference\030\001 \001(\r\0220\n\013nullability\030\002 \001(\016" + "2\033.substrait.Type.Nullability\032\\\n\006Binary\022" + " \n\030type_variation_reference\030\001 \001(\r\0220\n\013nul" + "lability\030\002 \001(\0162\033.substrait.Type.Nullabil" + "ity\032_\n\tTimestamp\022 \n\030type_variation_refer" + "ence\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.substr" + "ait.Type.Nullability\032Z\n\004Date\022 \n\030type_var" + "iation_reference\030\001 \001(\r\0220\n\013nullability\030\002 " + "\001(\0162\033.substrait.Type.Nullability\032Z\n\004Time" + "\022 \n\030type_variation_reference\030\001 \001(\r\0220\n\013nu" + "llability\030\002 \001(\0162\033.substrait.Type.Nullabi" + "lity\032a\n\013TimestampTZ\022 \n\030type_variation_re" + "ference\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.sub" + "strait.Type.Nullability\032b\n\014IntervalYear\022" + " \n\030type_variation_reference\030\001 \001(\r\0220\n\013nul" + "lability\030\002 \001(\0162\033.substrait.Type.Nullabil" + "ity\032a\n\013IntervalDay\022 \n\030type_variation_ref" + "erence\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.subs" + "trait.Type.Nullability\032Z\n\004UUID\022 \n\030type_v" + "ariation_reference\030\001 \001(\r\0220\n\013nullability\030" + "\002 \001(\0162\033.substrait.Type.Nullability\032o\n\tFi" + "xedChar\022\016\n\006length\030\001 \001(\005\022 \n\030type_variatio" + "n_reference\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033" + ".substrait.Type.Nullability\032m\n\007VarChar\022\016" + "\n\006length\030\001 \001(\005\022 \n\030type_variation_referen" + "ce\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrai" + "t.Type.Nullability\032q\n\013FixedBinary\022\016\n\006len" + "gth\030\001 \001(\005\022 \n\030type_variation_reference\030\002 " + "\001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrait.Typ" + "e.Nullability\032\177\n\007Decimal\022\r\n\005scale\030\001 \001(\005\022" "\021\n\tprecision\030\002 \001(\005\022 \n\030type_variation_ref" - "erence\030\003 \001(\r\0223\n\013nullability\030\004 \001(\0162\036.io.s" - "ubstrait.Type.Nullability\032\202\001\n\006Struct\022!\n\005" - "types\030\001 \003(\0132\022.io.substrait.Type\022 \n\030type_" - "variation_reference\030\002 \001(\r\0223\n\013nullability" - "\030\003 \001(\0162\036.io.substrait.Type.Nullability\032\177" - "\n\004List\022 \n\004type\030\001 \001(\0132\022.io.substrait.Type" - "\022 \n\030type_variation_reference\030\002 \001(\r\0223\n\013nu" - "llability\030\003 \001(\0162\036.io.substrait.Type.Null" - "ability\032\240\001\n\003Map\022\037\n\003key\030\001 \001(\0132\022.io.substr" - "ait.Type\022!\n\005value\030\002 \001(\0132\022.io.substrait.T" - "ype\022 \n\030type_variation_reference\030\003 \001(\r\0223\n" - "\013nullability\030\004 \001(\0162\036.io.substrait.Type.N" - "ullability\")\n\013Nullability\022\014\n\010NULLABLE\020\000\022" - "\014\n\010REQUIRED\020\001B\006\n\004kind\"G\n\013NamedStruct\022\r\n\005" - "names\030\001 \003(\t\022)\n\006struct\030\002 \001(\0132\031.io.substra" - "it.Type.StructB+\n\022io.substrait.protoP\001\252\002" - "\022Substrait.Protobufb\006proto3" + "erence\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033.subs" + "trait.Type.Nullability\032|\n\006Struct\022\036\n\005type" + "s\030\001 \003(\0132\017.substrait.Type\022 \n\030type_variati" + "on_reference\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162" + "\033.substrait.Type.Nullability\032y\n\004List\022\035\n\004" + "type\030\001 \001(\0132\017.substrait.Type\022 \n\030type_vari" + "ation_reference\030\002 \001(\r\0220\n\013nullability\030\003 \001" + "(\0162\033.substrait.Type.Nullability\032\227\001\n\003Map\022" + "\034\n\003key\030\001 \001(\0132\017.substrait.Type\022\036\n\005value\030\002" + " \001(\0132\017.substrait.Type\022 \n\030type_variation_" + "reference\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033.s" + "ubstrait.Type.Nullability\"^\n\013Nullability" + "\022\033\n\027NULLABILITY_UNSPECIFIED\020\000\022\030\n\024NULLABI" + "LITY_NULLABLE\020\001\022\030\n\024NULLABILITY_REQUIRED\020" + "\002B\006\n\004kind\"D\n\013NamedStruct\022\r\n\005names\030\001 \003(\t\022" + "&\n\006struct\030\002 \001(\0132\026.substrait.Type.StructB" + "+\n\022io.substrait.protoP\001\252\002\022Substrait.Prot" + "obufb\006proto3" ; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_type_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_2eproto = { - false, false, 3747, descriptor_table_protodef_type_2eproto, "type.proto", - &descriptor_table_type_2eproto_once, nullptr, 0, 25, - schemas, file_default_instances, TableStruct_type_2eproto::offsets, - file_level_metadata_type_2eproto, file_level_enum_descriptors_type_2eproto, file_level_service_descriptors_type_2eproto, +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ftype_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_2eproto = { + false, false, 3652, descriptor_table_protodef_substrait_2ftype_2eproto, "substrait/type.proto", + &descriptor_table_substrait_2ftype_2eproto_once, nullptr, 0, 25, + schemas, file_default_instances, TableStruct_substrait_2ftype_2eproto::offsets, + file_level_metadata_substrait_2ftype_2eproto, file_level_enum_descriptors_substrait_2ftype_2eproto, file_level_service_descriptors_substrait_2ftype_2eproto, }; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_type_2eproto_getter() { - return &descriptor_table_type_2eproto; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ftype_2eproto_getter() { + return &descriptor_table_substrait_2ftype_2eproto; } // Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_type_2eproto(&descriptor_table_type_2eproto); -namespace io { +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ftype_2eproto(&descriptor_table_substrait_2ftype_2eproto); namespace substrait { const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_Nullability_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_type_2eproto); - return file_level_enum_descriptors_type_2eproto[0]; + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_2eproto); + return file_level_enum_descriptors_substrait_2ftype_2eproto[0]; } bool Type_Nullability_IsValid(int value) { switch (value) { case 0: case 1: + case 2: return true; default: return false; @@ -771,8 +767,9 @@ bool Type_Nullability_IsValid(int value) { } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr Type_Nullability Type::NULLABLE; -constexpr Type_Nullability Type::REQUIRED; +constexpr Type_Nullability Type::NULLABILITY_UNSPECIFIED; +constexpr Type_Nullability Type::NULLABILITY_NULLABLE; +constexpr Type_Nullability Type::NULLABILITY_REQUIRED; constexpr Type_Nullability Type::Nullability_MIN; constexpr Type_Nullability Type::Nullability_MAX; constexpr int Type::Nullability_ARRAYSIZE; @@ -788,7 +785,7 @@ Type_Boolean::Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Boolean) + // @@protoc_insertion_point(arena_constructor:substrait.Type.Boolean) } Type_Boolean::Type_Boolean(const Type_Boolean& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -796,7 +793,7 @@ Type_Boolean::Type_Boolean(const Type_Boolean& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Boolean) + // @@protoc_insertion_point(copy_constructor:substrait.Type.Boolean) } void Type_Boolean::SharedCtor() { @@ -807,7 +804,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_Boolean::~Type_Boolean() { - // @@protoc_insertion_point(destructor:io.substrait.Type.Boolean) + // @@protoc_insertion_point(destructor:substrait.Type.Boolean) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -827,7 +824,7 @@ void Type_Boolean::SetCachedSize(int size) const { } void Type_Boolean::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Boolean) +// @@protoc_insertion_point(message_clear_start:substrait.Type.Boolean) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -851,12 +848,12 @@ const char* Type_Boolean::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -884,7 +881,7 @@ const char* Type_Boolean::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ::PROTOBUF_NAMESPACE_ID::uint8* Type_Boolean::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Boolean) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Boolean) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -894,7 +891,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Boolean::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -905,12 +902,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Boolean::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Boolean) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Boolean) return target; } size_t Type_Boolean::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Boolean) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Boolean) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -924,7 +921,7 @@ size_t Type_Boolean::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -940,22 +937,22 @@ size_t Type_Boolean::ByteSizeLong() const { } void Type_Boolean::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Boolean) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Boolean) GOOGLE_DCHECK_NE(&from, this); const Type_Boolean* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Boolean) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Boolean) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Boolean) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Boolean) MergeFrom(*source); } } void Type_Boolean::MergeFrom(const Type_Boolean& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Boolean) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Boolean) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -970,14 +967,14 @@ void Type_Boolean::MergeFrom(const Type_Boolean& from) { } void Type_Boolean::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Boolean) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Boolean) if (&from == this) return; Clear(); MergeFrom(from); } void Type_Boolean::CopyFrom(const Type_Boolean& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Boolean) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Boolean) if (&from == this) return; Clear(); MergeFrom(from); @@ -1000,8 +997,8 @@ void Type_Boolean::InternalSwap(Type_Boolean* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_Boolean::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[0]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[0]); } // =================================================================== @@ -1014,7 +1011,7 @@ Type_I8::Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.I8) + // @@protoc_insertion_point(arena_constructor:substrait.Type.I8) } Type_I8::Type_I8(const Type_I8& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -1022,7 +1019,7 @@ Type_I8::Type_I8(const Type_I8& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I8) + // @@protoc_insertion_point(copy_constructor:substrait.Type.I8) } void Type_I8::SharedCtor() { @@ -1033,7 +1030,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_I8::~Type_I8() { - // @@protoc_insertion_point(destructor:io.substrait.Type.I8) + // @@protoc_insertion_point(destructor:substrait.Type.I8) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1053,7 +1050,7 @@ void Type_I8::SetCachedSize(int size) const { } void Type_I8::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.I8) +// @@protoc_insertion_point(message_clear_start:substrait.Type.I8) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1077,12 +1074,12 @@ const char* Type_I8::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -1110,7 +1107,7 @@ const char* Type_I8::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in ::PROTOBUF_NAMESPACE_ID::uint8* Type_I8::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.I8) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I8) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1120,7 +1117,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I8::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1131,12 +1128,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I8::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.I8) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I8) return target; } size_t Type_I8::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.I8) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I8) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1150,7 +1147,7 @@ size_t Type_I8::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1166,22 +1163,22 @@ size_t Type_I8::ByteSizeLong() const { } void Type_I8::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.I8) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.I8) GOOGLE_DCHECK_NE(&from, this); const Type_I8* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.I8) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.I8) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.I8) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.I8) MergeFrom(*source); } } void Type_I8::MergeFrom(const Type_I8& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.I8) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I8) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1196,14 +1193,14 @@ void Type_I8::MergeFrom(const Type_I8& from) { } void Type_I8::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.I8) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.I8) if (&from == this) return; Clear(); MergeFrom(from); } void Type_I8::CopyFrom(const Type_I8& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.I8) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I8) if (&from == this) return; Clear(); MergeFrom(from); @@ -1226,8 +1223,8 @@ void Type_I8::InternalSwap(Type_I8* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_I8::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[1]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[1]); } // =================================================================== @@ -1240,7 +1237,7 @@ Type_I16::Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.I16) + // @@protoc_insertion_point(arena_constructor:substrait.Type.I16) } Type_I16::Type_I16(const Type_I16& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -1248,7 +1245,7 @@ Type_I16::Type_I16(const Type_I16& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I16) + // @@protoc_insertion_point(copy_constructor:substrait.Type.I16) } void Type_I16::SharedCtor() { @@ -1259,7 +1256,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_I16::~Type_I16() { - // @@protoc_insertion_point(destructor:io.substrait.Type.I16) + // @@protoc_insertion_point(destructor:substrait.Type.I16) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1279,7 +1276,7 @@ void Type_I16::SetCachedSize(int size) const { } void Type_I16::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.I16) +// @@protoc_insertion_point(message_clear_start:substrait.Type.I16) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1303,12 +1300,12 @@ const char* Type_I16::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -1336,7 +1333,7 @@ const char* Type_I16::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i ::PROTOBUF_NAMESPACE_ID::uint8* Type_I16::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.I16) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I16) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1346,7 +1343,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I16::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1357,12 +1354,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I16::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.I16) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I16) return target; } size_t Type_I16::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.I16) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I16) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1376,7 +1373,7 @@ size_t Type_I16::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1392,22 +1389,22 @@ size_t Type_I16::ByteSizeLong() const { } void Type_I16::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.I16) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.I16) GOOGLE_DCHECK_NE(&from, this); const Type_I16* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.I16) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.I16) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.I16) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.I16) MergeFrom(*source); } } void Type_I16::MergeFrom(const Type_I16& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.I16) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I16) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1422,14 +1419,14 @@ void Type_I16::MergeFrom(const Type_I16& from) { } void Type_I16::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.I16) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.I16) if (&from == this) return; Clear(); MergeFrom(from); } void Type_I16::CopyFrom(const Type_I16& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.I16) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I16) if (&from == this) return; Clear(); MergeFrom(from); @@ -1452,8 +1449,8 @@ void Type_I16::InternalSwap(Type_I16* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_I16::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[2]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[2]); } // =================================================================== @@ -1466,7 +1463,7 @@ Type_I32::Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.I32) + // @@protoc_insertion_point(arena_constructor:substrait.Type.I32) } Type_I32::Type_I32(const Type_I32& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -1474,7 +1471,7 @@ Type_I32::Type_I32(const Type_I32& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I32) + // @@protoc_insertion_point(copy_constructor:substrait.Type.I32) } void Type_I32::SharedCtor() { @@ -1485,7 +1482,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_I32::~Type_I32() { - // @@protoc_insertion_point(destructor:io.substrait.Type.I32) + // @@protoc_insertion_point(destructor:substrait.Type.I32) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1505,7 +1502,7 @@ void Type_I32::SetCachedSize(int size) const { } void Type_I32::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.I32) +// @@protoc_insertion_point(message_clear_start:substrait.Type.I32) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1529,12 +1526,12 @@ const char* Type_I32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -1562,7 +1559,7 @@ const char* Type_I32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i ::PROTOBUF_NAMESPACE_ID::uint8* Type_I32::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.I32) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I32) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1572,7 +1569,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I32::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1583,12 +1580,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I32::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.I32) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I32) return target; } size_t Type_I32::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.I32) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I32) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1602,7 +1599,7 @@ size_t Type_I32::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1618,22 +1615,22 @@ size_t Type_I32::ByteSizeLong() const { } void Type_I32::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.I32) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.I32) GOOGLE_DCHECK_NE(&from, this); const Type_I32* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.I32) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.I32) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.I32) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.I32) MergeFrom(*source); } } void Type_I32::MergeFrom(const Type_I32& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.I32) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I32) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1648,14 +1645,14 @@ void Type_I32::MergeFrom(const Type_I32& from) { } void Type_I32::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.I32) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.I32) if (&from == this) return; Clear(); MergeFrom(from); } void Type_I32::CopyFrom(const Type_I32& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.I32) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I32) if (&from == this) return; Clear(); MergeFrom(from); @@ -1678,8 +1675,8 @@ void Type_I32::InternalSwap(Type_I32* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_I32::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[3]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[3]); } // =================================================================== @@ -1692,7 +1689,7 @@ Type_I64::Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.I64) + // @@protoc_insertion_point(arena_constructor:substrait.Type.I64) } Type_I64::Type_I64(const Type_I64& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -1700,7 +1697,7 @@ Type_I64::Type_I64(const Type_I64& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.I64) + // @@protoc_insertion_point(copy_constructor:substrait.Type.I64) } void Type_I64::SharedCtor() { @@ -1711,7 +1708,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_I64::~Type_I64() { - // @@protoc_insertion_point(destructor:io.substrait.Type.I64) + // @@protoc_insertion_point(destructor:substrait.Type.I64) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1731,7 +1728,7 @@ void Type_I64::SetCachedSize(int size) const { } void Type_I64::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.I64) +// @@protoc_insertion_point(message_clear_start:substrait.Type.I64) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1755,12 +1752,12 @@ const char* Type_I64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -1788,7 +1785,7 @@ const char* Type_I64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i ::PROTOBUF_NAMESPACE_ID::uint8* Type_I64::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.I64) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I64) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -1798,7 +1795,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I64::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1809,12 +1806,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_I64::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.I64) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I64) return target; } size_t Type_I64::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.I64) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I64) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1828,7 +1825,7 @@ size_t Type_I64::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1844,22 +1841,22 @@ size_t Type_I64::ByteSizeLong() const { } void Type_I64::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.I64) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.I64) GOOGLE_DCHECK_NE(&from, this); const Type_I64* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.I64) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.I64) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.I64) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.I64) MergeFrom(*source); } } void Type_I64::MergeFrom(const Type_I64& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.I64) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I64) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1874,14 +1871,14 @@ void Type_I64::MergeFrom(const Type_I64& from) { } void Type_I64::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.I64) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.I64) if (&from == this) return; Clear(); MergeFrom(from); } void Type_I64::CopyFrom(const Type_I64& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.I64) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I64) if (&from == this) return; Clear(); MergeFrom(from); @@ -1904,8 +1901,8 @@ void Type_I64::InternalSwap(Type_I64* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_I64::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[4]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[4]); } // =================================================================== @@ -1918,7 +1915,7 @@ Type_FP32::Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.FP32) + // @@protoc_insertion_point(arena_constructor:substrait.Type.FP32) } Type_FP32::Type_FP32(const Type_FP32& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -1926,7 +1923,7 @@ Type_FP32::Type_FP32(const Type_FP32& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.FP32) + // @@protoc_insertion_point(copy_constructor:substrait.Type.FP32) } void Type_FP32::SharedCtor() { @@ -1937,7 +1934,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_FP32::~Type_FP32() { - // @@protoc_insertion_point(destructor:io.substrait.Type.FP32) + // @@protoc_insertion_point(destructor:substrait.Type.FP32) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1957,7 +1954,7 @@ void Type_FP32::SetCachedSize(int size) const { } void Type_FP32::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.FP32) +// @@protoc_insertion_point(message_clear_start:substrait.Type.FP32) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1981,12 +1978,12 @@ const char* Type_FP32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -2014,7 +2011,7 @@ const char* Type_FP32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint8* Type_FP32::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.FP32) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FP32) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2024,7 +2021,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FP32::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -2035,12 +2032,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FP32::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.FP32) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FP32) return target; } size_t Type_FP32::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.FP32) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FP32) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2054,7 +2051,7 @@ size_t Type_FP32::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -2070,22 +2067,22 @@ size_t Type_FP32::ByteSizeLong() const { } void Type_FP32::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.FP32) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.FP32) GOOGLE_DCHECK_NE(&from, this); const Type_FP32* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.FP32) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.FP32) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.FP32) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.FP32) MergeFrom(*source); } } void Type_FP32::MergeFrom(const Type_FP32& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.FP32) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FP32) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2100,14 +2097,14 @@ void Type_FP32::MergeFrom(const Type_FP32& from) { } void Type_FP32::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.FP32) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.FP32) if (&from == this) return; Clear(); MergeFrom(from); } void Type_FP32::CopyFrom(const Type_FP32& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.FP32) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FP32) if (&from == this) return; Clear(); MergeFrom(from); @@ -2130,8 +2127,8 @@ void Type_FP32::InternalSwap(Type_FP32* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_FP32::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[5]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[5]); } // =================================================================== @@ -2144,7 +2141,7 @@ Type_FP64::Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.FP64) + // @@protoc_insertion_point(arena_constructor:substrait.Type.FP64) } Type_FP64::Type_FP64(const Type_FP64& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -2152,7 +2149,7 @@ Type_FP64::Type_FP64(const Type_FP64& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.FP64) + // @@protoc_insertion_point(copy_constructor:substrait.Type.FP64) } void Type_FP64::SharedCtor() { @@ -2163,7 +2160,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_FP64::~Type_FP64() { - // @@protoc_insertion_point(destructor:io.substrait.Type.FP64) + // @@protoc_insertion_point(destructor:substrait.Type.FP64) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2183,7 +2180,7 @@ void Type_FP64::SetCachedSize(int size) const { } void Type_FP64::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.FP64) +// @@protoc_insertion_point(message_clear_start:substrait.Type.FP64) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2207,12 +2204,12 @@ const char* Type_FP64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -2240,7 +2237,7 @@ const char* Type_FP64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint8* Type_FP64::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.FP64) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FP64) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2250,7 +2247,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FP64::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -2261,12 +2258,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FP64::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.FP64) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FP64) return target; } size_t Type_FP64::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.FP64) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FP64) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2280,7 +2277,7 @@ size_t Type_FP64::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -2296,22 +2293,22 @@ size_t Type_FP64::ByteSizeLong() const { } void Type_FP64::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.FP64) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.FP64) GOOGLE_DCHECK_NE(&from, this); const Type_FP64* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.FP64) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.FP64) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.FP64) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.FP64) MergeFrom(*source); } } void Type_FP64::MergeFrom(const Type_FP64& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.FP64) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FP64) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2326,14 +2323,14 @@ void Type_FP64::MergeFrom(const Type_FP64& from) { } void Type_FP64::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.FP64) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.FP64) if (&from == this) return; Clear(); MergeFrom(from); } void Type_FP64::CopyFrom(const Type_FP64& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.FP64) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FP64) if (&from == this) return; Clear(); MergeFrom(from); @@ -2356,8 +2353,8 @@ void Type_FP64::InternalSwap(Type_FP64* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_FP64::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[6]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[6]); } // =================================================================== @@ -2370,7 +2367,7 @@ Type_String::Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.String) + // @@protoc_insertion_point(arena_constructor:substrait.Type.String) } Type_String::Type_String(const Type_String& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -2378,7 +2375,7 @@ Type_String::Type_String(const Type_String& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.String) + // @@protoc_insertion_point(copy_constructor:substrait.Type.String) } void Type_String::SharedCtor() { @@ -2389,7 +2386,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_String::~Type_String() { - // @@protoc_insertion_point(destructor:io.substrait.Type.String) + // @@protoc_insertion_point(destructor:substrait.Type.String) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2409,7 +2406,7 @@ void Type_String::SetCachedSize(int size) const { } void Type_String::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.String) +// @@protoc_insertion_point(message_clear_start:substrait.Type.String) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2433,12 +2430,12 @@ const char* Type_String::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -2466,7 +2463,7 @@ const char* Type_String::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ::PROTOBUF_NAMESPACE_ID::uint8* Type_String::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.String) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.String) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2476,7 +2473,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_String::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -2487,12 +2484,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_String::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.String) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.String) return target; } size_t Type_String::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.String) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.String) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2506,7 +2503,7 @@ size_t Type_String::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -2522,22 +2519,22 @@ size_t Type_String::ByteSizeLong() const { } void Type_String::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.String) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.String) GOOGLE_DCHECK_NE(&from, this); const Type_String* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.String) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.String) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.String) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.String) MergeFrom(*source); } } void Type_String::MergeFrom(const Type_String& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.String) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.String) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2552,14 +2549,14 @@ void Type_String::MergeFrom(const Type_String& from) { } void Type_String::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.String) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.String) if (&from == this) return; Clear(); MergeFrom(from); } void Type_String::CopyFrom(const Type_String& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.String) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.String) if (&from == this) return; Clear(); MergeFrom(from); @@ -2582,8 +2579,8 @@ void Type_String::InternalSwap(Type_String* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_String::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[7]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[7]); } // =================================================================== @@ -2596,7 +2593,7 @@ Type_Binary::Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Binary) + // @@protoc_insertion_point(arena_constructor:substrait.Type.Binary) } Type_Binary::Type_Binary(const Type_Binary& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -2604,7 +2601,7 @@ Type_Binary::Type_Binary(const Type_Binary& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Binary) + // @@protoc_insertion_point(copy_constructor:substrait.Type.Binary) } void Type_Binary::SharedCtor() { @@ -2615,7 +2612,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_Binary::~Type_Binary() { - // @@protoc_insertion_point(destructor:io.substrait.Type.Binary) + // @@protoc_insertion_point(destructor:substrait.Type.Binary) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2635,7 +2632,7 @@ void Type_Binary::SetCachedSize(int size) const { } void Type_Binary::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Binary) +// @@protoc_insertion_point(message_clear_start:substrait.Type.Binary) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2659,12 +2656,12 @@ const char* Type_Binary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -2692,7 +2689,7 @@ const char* Type_Binary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ::PROTOBUF_NAMESPACE_ID::uint8* Type_Binary::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Binary) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Binary) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2702,7 +2699,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Binary::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -2713,12 +2710,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Binary::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Binary) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Binary) return target; } size_t Type_Binary::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Binary) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Binary) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2732,7 +2729,7 @@ size_t Type_Binary::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -2748,22 +2745,22 @@ size_t Type_Binary::ByteSizeLong() const { } void Type_Binary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Binary) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Binary) GOOGLE_DCHECK_NE(&from, this); const Type_Binary* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Binary) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Binary) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Binary) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Binary) MergeFrom(*source); } } void Type_Binary::MergeFrom(const Type_Binary& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Binary) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Binary) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2778,14 +2775,14 @@ void Type_Binary::MergeFrom(const Type_Binary& from) { } void Type_Binary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Binary) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Binary) if (&from == this) return; Clear(); MergeFrom(from); } void Type_Binary::CopyFrom(const Type_Binary& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Binary) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Binary) if (&from == this) return; Clear(); MergeFrom(from); @@ -2808,8 +2805,8 @@ void Type_Binary::InternalSwap(Type_Binary* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_Binary::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[8]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[8]); } // =================================================================== @@ -2822,7 +2819,7 @@ Type_Timestamp::Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Timestamp) + // @@protoc_insertion_point(arena_constructor:substrait.Type.Timestamp) } Type_Timestamp::Type_Timestamp(const Type_Timestamp& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -2830,7 +2827,7 @@ Type_Timestamp::Type_Timestamp(const Type_Timestamp& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Timestamp) + // @@protoc_insertion_point(copy_constructor:substrait.Type.Timestamp) } void Type_Timestamp::SharedCtor() { @@ -2841,7 +2838,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_Timestamp::~Type_Timestamp() { - // @@protoc_insertion_point(destructor:io.substrait.Type.Timestamp) + // @@protoc_insertion_point(destructor:substrait.Type.Timestamp) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2861,7 +2858,7 @@ void Type_Timestamp::SetCachedSize(int size) const { } void Type_Timestamp::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Timestamp) +// @@protoc_insertion_point(message_clear_start:substrait.Type.Timestamp) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2885,12 +2882,12 @@ const char* Type_Timestamp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -2918,7 +2915,7 @@ const char* Type_Timestamp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ::PROTOBUF_NAMESPACE_ID::uint8* Type_Timestamp::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Timestamp) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Timestamp) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2928,7 +2925,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Timestamp::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -2939,12 +2936,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Timestamp::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Timestamp) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Timestamp) return target; } size_t Type_Timestamp::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Timestamp) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Timestamp) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2958,7 +2955,7 @@ size_t Type_Timestamp::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -2974,22 +2971,22 @@ size_t Type_Timestamp::ByteSizeLong() const { } void Type_Timestamp::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Timestamp) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Timestamp) GOOGLE_DCHECK_NE(&from, this); const Type_Timestamp* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Timestamp) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Timestamp) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Timestamp) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Timestamp) MergeFrom(*source); } } void Type_Timestamp::MergeFrom(const Type_Timestamp& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Timestamp) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Timestamp) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3004,14 +3001,14 @@ void Type_Timestamp::MergeFrom(const Type_Timestamp& from) { } void Type_Timestamp::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Timestamp) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Timestamp) if (&from == this) return; Clear(); MergeFrom(from); } void Type_Timestamp::CopyFrom(const Type_Timestamp& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Timestamp) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Timestamp) if (&from == this) return; Clear(); MergeFrom(from); @@ -3034,8 +3031,8 @@ void Type_Timestamp::InternalSwap(Type_Timestamp* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_Timestamp::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[9]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[9]); } // =================================================================== @@ -3048,7 +3045,7 @@ Type_Date::Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Date) + // @@protoc_insertion_point(arena_constructor:substrait.Type.Date) } Type_Date::Type_Date(const Type_Date& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -3056,7 +3053,7 @@ Type_Date::Type_Date(const Type_Date& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Date) + // @@protoc_insertion_point(copy_constructor:substrait.Type.Date) } void Type_Date::SharedCtor() { @@ -3067,7 +3064,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_Date::~Type_Date() { - // @@protoc_insertion_point(destructor:io.substrait.Type.Date) + // @@protoc_insertion_point(destructor:substrait.Type.Date) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3087,7 +3084,7 @@ void Type_Date::SetCachedSize(int size) const { } void Type_Date::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Date) +// @@protoc_insertion_point(message_clear_start:substrait.Type.Date) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3111,12 +3108,12 @@ const char* Type_Date::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -3144,7 +3141,7 @@ const char* Type_Date::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint8* Type_Date::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Date) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Date) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3154,7 +3151,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Date::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -3165,12 +3162,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Date::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Date) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Date) return target; } size_t Type_Date::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Date) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Date) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3184,7 +3181,7 @@ size_t Type_Date::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -3200,22 +3197,22 @@ size_t Type_Date::ByteSizeLong() const { } void Type_Date::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Date) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Date) GOOGLE_DCHECK_NE(&from, this); const Type_Date* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Date) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Date) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Date) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Date) MergeFrom(*source); } } void Type_Date::MergeFrom(const Type_Date& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Date) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Date) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3230,14 +3227,14 @@ void Type_Date::MergeFrom(const Type_Date& from) { } void Type_Date::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Date) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Date) if (&from == this) return; Clear(); MergeFrom(from); } void Type_Date::CopyFrom(const Type_Date& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Date) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Date) if (&from == this) return; Clear(); MergeFrom(from); @@ -3260,8 +3257,8 @@ void Type_Date::InternalSwap(Type_Date* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_Date::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[10]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[10]); } // =================================================================== @@ -3274,7 +3271,7 @@ Type_Time::Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Time) + // @@protoc_insertion_point(arena_constructor:substrait.Type.Time) } Type_Time::Type_Time(const Type_Time& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -3282,7 +3279,7 @@ Type_Time::Type_Time(const Type_Time& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Time) + // @@protoc_insertion_point(copy_constructor:substrait.Type.Time) } void Type_Time::SharedCtor() { @@ -3293,7 +3290,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_Time::~Type_Time() { - // @@protoc_insertion_point(destructor:io.substrait.Type.Time) + // @@protoc_insertion_point(destructor:substrait.Type.Time) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3313,7 +3310,7 @@ void Type_Time::SetCachedSize(int size) const { } void Type_Time::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Time) +// @@protoc_insertion_point(message_clear_start:substrait.Type.Time) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3337,12 +3334,12 @@ const char* Type_Time::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -3370,7 +3367,7 @@ const char* Type_Time::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint8* Type_Time::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Time) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Time) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3380,7 +3377,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Time::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -3391,12 +3388,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Time::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Time) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Time) return target; } size_t Type_Time::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Time) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Time) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3410,7 +3407,7 @@ size_t Type_Time::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -3426,22 +3423,22 @@ size_t Type_Time::ByteSizeLong() const { } void Type_Time::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Time) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Time) GOOGLE_DCHECK_NE(&from, this); const Type_Time* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Time) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Time) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Time) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Time) MergeFrom(*source); } } void Type_Time::MergeFrom(const Type_Time& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Time) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Time) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3456,14 +3453,14 @@ void Type_Time::MergeFrom(const Type_Time& from) { } void Type_Time::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Time) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Time) if (&from == this) return; Clear(); MergeFrom(from); } void Type_Time::CopyFrom(const Type_Time& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Time) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Time) if (&from == this) return; Clear(); MergeFrom(from); @@ -3486,8 +3483,8 @@ void Type_Time::InternalSwap(Type_Time* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_Time::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[11]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[11]); } // =================================================================== @@ -3500,7 +3497,7 @@ Type_TimestampTZ::Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.TimestampTZ) + // @@protoc_insertion_point(arena_constructor:substrait.Type.TimestampTZ) } Type_TimestampTZ::Type_TimestampTZ(const Type_TimestampTZ& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -3508,7 +3505,7 @@ Type_TimestampTZ::Type_TimestampTZ(const Type_TimestampTZ& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.TimestampTZ) + // @@protoc_insertion_point(copy_constructor:substrait.Type.TimestampTZ) } void Type_TimestampTZ::SharedCtor() { @@ -3519,7 +3516,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_TimestampTZ::~Type_TimestampTZ() { - // @@protoc_insertion_point(destructor:io.substrait.Type.TimestampTZ) + // @@protoc_insertion_point(destructor:substrait.Type.TimestampTZ) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3539,7 +3536,7 @@ void Type_TimestampTZ::SetCachedSize(int size) const { } void Type_TimestampTZ::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.TimestampTZ) +// @@protoc_insertion_point(message_clear_start:substrait.Type.TimestampTZ) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3563,12 +3560,12 @@ const char* Type_TimestampTZ::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -3596,7 +3593,7 @@ const char* Type_TimestampTZ::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA ::PROTOBUF_NAMESPACE_ID::uint8* Type_TimestampTZ::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.TimestampTZ) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.TimestampTZ) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3606,7 +3603,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_TimestampTZ::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -3617,12 +3614,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_TimestampTZ::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.TimestampTZ) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.TimestampTZ) return target; } size_t Type_TimestampTZ::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.TimestampTZ) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.TimestampTZ) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3636,7 +3633,7 @@ size_t Type_TimestampTZ::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -3652,22 +3649,22 @@ size_t Type_TimestampTZ::ByteSizeLong() const { } void Type_TimestampTZ::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.TimestampTZ) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.TimestampTZ) GOOGLE_DCHECK_NE(&from, this); const Type_TimestampTZ* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.TimestampTZ) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.TimestampTZ) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.TimestampTZ) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.TimestampTZ) MergeFrom(*source); } } void Type_TimestampTZ::MergeFrom(const Type_TimestampTZ& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.TimestampTZ) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.TimestampTZ) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3682,14 +3679,14 @@ void Type_TimestampTZ::MergeFrom(const Type_TimestampTZ& from) { } void Type_TimestampTZ::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.TimestampTZ) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.TimestampTZ) if (&from == this) return; Clear(); MergeFrom(from); } void Type_TimestampTZ::CopyFrom(const Type_TimestampTZ& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.TimestampTZ) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.TimestampTZ) if (&from == this) return; Clear(); MergeFrom(from); @@ -3712,8 +3709,8 @@ void Type_TimestampTZ::InternalSwap(Type_TimestampTZ* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_TimestampTZ::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[12]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[12]); } // =================================================================== @@ -3726,7 +3723,7 @@ Type_IntervalYear::Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.IntervalYear) + // @@protoc_insertion_point(arena_constructor:substrait.Type.IntervalYear) } Type_IntervalYear::Type_IntervalYear(const Type_IntervalYear& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -3734,7 +3731,7 @@ Type_IntervalYear::Type_IntervalYear(const Type_IntervalYear& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.IntervalYear) + // @@protoc_insertion_point(copy_constructor:substrait.Type.IntervalYear) } void Type_IntervalYear::SharedCtor() { @@ -3745,7 +3742,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_IntervalYear::~Type_IntervalYear() { - // @@protoc_insertion_point(destructor:io.substrait.Type.IntervalYear) + // @@protoc_insertion_point(destructor:substrait.Type.IntervalYear) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3765,7 +3762,7 @@ void Type_IntervalYear::SetCachedSize(int size) const { } void Type_IntervalYear::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.IntervalYear) +// @@protoc_insertion_point(message_clear_start:substrait.Type.IntervalYear) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3789,12 +3786,12 @@ const char* Type_IntervalYear::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -3822,7 +3819,7 @@ const char* Type_IntervalYear::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP ::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalYear::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.IntervalYear) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.IntervalYear) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3832,7 +3829,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalYear::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -3843,12 +3840,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalYear::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.IntervalYear) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.IntervalYear) return target; } size_t Type_IntervalYear::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.IntervalYear) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.IntervalYear) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3862,7 +3859,7 @@ size_t Type_IntervalYear::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -3878,22 +3875,22 @@ size_t Type_IntervalYear::ByteSizeLong() const { } void Type_IntervalYear::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.IntervalYear) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.IntervalYear) GOOGLE_DCHECK_NE(&from, this); const Type_IntervalYear* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.IntervalYear) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.IntervalYear) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.IntervalYear) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.IntervalYear) MergeFrom(*source); } } void Type_IntervalYear::MergeFrom(const Type_IntervalYear& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.IntervalYear) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.IntervalYear) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3908,14 +3905,14 @@ void Type_IntervalYear::MergeFrom(const Type_IntervalYear& from) { } void Type_IntervalYear::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.IntervalYear) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.IntervalYear) if (&from == this) return; Clear(); MergeFrom(from); } void Type_IntervalYear::CopyFrom(const Type_IntervalYear& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.IntervalYear) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.IntervalYear) if (&from == this) return; Clear(); MergeFrom(from); @@ -3938,8 +3935,8 @@ void Type_IntervalYear::InternalSwap(Type_IntervalYear* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalYear::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[13]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[13]); } // =================================================================== @@ -3952,7 +3949,7 @@ Type_IntervalDay::Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.IntervalDay) + // @@protoc_insertion_point(arena_constructor:substrait.Type.IntervalDay) } Type_IntervalDay::Type_IntervalDay(const Type_IntervalDay& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -3960,7 +3957,7 @@ Type_IntervalDay::Type_IntervalDay(const Type_IntervalDay& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.IntervalDay) + // @@protoc_insertion_point(copy_constructor:substrait.Type.IntervalDay) } void Type_IntervalDay::SharedCtor() { @@ -3971,7 +3968,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_IntervalDay::~Type_IntervalDay() { - // @@protoc_insertion_point(destructor:io.substrait.Type.IntervalDay) + // @@protoc_insertion_point(destructor:substrait.Type.IntervalDay) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3991,7 +3988,7 @@ void Type_IntervalDay::SetCachedSize(int size) const { } void Type_IntervalDay::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.IntervalDay) +// @@protoc_insertion_point(message_clear_start:substrait.Type.IntervalDay) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4015,12 +4012,12 @@ const char* Type_IntervalDay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -4048,7 +4045,7 @@ const char* Type_IntervalDay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA ::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalDay::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.IntervalDay) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.IntervalDay) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -4058,7 +4055,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalDay::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -4069,12 +4066,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalDay::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.IntervalDay) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.IntervalDay) return target; } size_t Type_IntervalDay::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.IntervalDay) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.IntervalDay) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4088,7 +4085,7 @@ size_t Type_IntervalDay::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -4104,22 +4101,22 @@ size_t Type_IntervalDay::ByteSizeLong() const { } void Type_IntervalDay::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.IntervalDay) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.IntervalDay) GOOGLE_DCHECK_NE(&from, this); const Type_IntervalDay* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.IntervalDay) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.IntervalDay) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.IntervalDay) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.IntervalDay) MergeFrom(*source); } } void Type_IntervalDay::MergeFrom(const Type_IntervalDay& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.IntervalDay) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.IntervalDay) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4134,14 +4131,14 @@ void Type_IntervalDay::MergeFrom(const Type_IntervalDay& from) { } void Type_IntervalDay::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.IntervalDay) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.IntervalDay) if (&from == this) return; Clear(); MergeFrom(from); } void Type_IntervalDay::CopyFrom(const Type_IntervalDay& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.IntervalDay) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.IntervalDay) if (&from == this) return; Clear(); MergeFrom(from); @@ -4164,8 +4161,8 @@ void Type_IntervalDay::InternalSwap(Type_IntervalDay* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalDay::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[14]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[14]); } // =================================================================== @@ -4178,7 +4175,7 @@ Type_UUID::Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.UUID) + // @@protoc_insertion_point(arena_constructor:substrait.Type.UUID) } Type_UUID::Type_UUID(const Type_UUID& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -4186,7 +4183,7 @@ Type_UUID::Type_UUID(const Type_UUID& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.UUID) + // @@protoc_insertion_point(copy_constructor:substrait.Type.UUID) } void Type_UUID::SharedCtor() { @@ -4197,7 +4194,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_UUID::~Type_UUID() { - // @@protoc_insertion_point(destructor:io.substrait.Type.UUID) + // @@protoc_insertion_point(destructor:substrait.Type.UUID) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4217,7 +4214,7 @@ void Type_UUID::SetCachedSize(int size) const { } void Type_UUID::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.UUID) +// @@protoc_insertion_point(message_clear_start:substrait.Type.UUID) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4241,12 +4238,12 @@ const char* Type_UUID::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -4274,7 +4271,7 @@ const char* Type_UUID::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint8* Type_UUID::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.UUID) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.UUID) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -4284,7 +4281,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_UUID::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -4295,12 +4292,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_UUID::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.UUID) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.UUID) return target; } size_t Type_UUID::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.UUID) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.UUID) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4314,7 +4311,7 @@ size_t Type_UUID::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -4330,22 +4327,22 @@ size_t Type_UUID::ByteSizeLong() const { } void Type_UUID::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.UUID) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.UUID) GOOGLE_DCHECK_NE(&from, this); const Type_UUID* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.UUID) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.UUID) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.UUID) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.UUID) MergeFrom(*source); } } void Type_UUID::MergeFrom(const Type_UUID& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.UUID) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.UUID) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4360,14 +4357,14 @@ void Type_UUID::MergeFrom(const Type_UUID& from) { } void Type_UUID::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.UUID) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.UUID) if (&from == this) return; Clear(); MergeFrom(from); } void Type_UUID::CopyFrom(const Type_UUID& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.UUID) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.UUID) if (&from == this) return; Clear(); MergeFrom(from); @@ -4390,8 +4387,8 @@ void Type_UUID::InternalSwap(Type_UUID* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_UUID::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[15]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[15]); } // =================================================================== @@ -4404,7 +4401,7 @@ Type_FixedChar::Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.FixedChar) + // @@protoc_insertion_point(arena_constructor:substrait.Type.FixedChar) } Type_FixedChar::Type_FixedChar(const Type_FixedChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -4412,7 +4409,7 @@ Type_FixedChar::Type_FixedChar(const Type_FixedChar& from) ::memcpy(&length_, &from.length_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&length_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.FixedChar) + // @@protoc_insertion_point(copy_constructor:substrait.Type.FixedChar) } void Type_FixedChar::SharedCtor() { @@ -4423,7 +4420,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_FixedChar::~Type_FixedChar() { - // @@protoc_insertion_point(destructor:io.substrait.Type.FixedChar) + // @@protoc_insertion_point(destructor:substrait.Type.FixedChar) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4443,7 +4440,7 @@ void Type_FixedChar::SetCachedSize(int size) const { } void Type_FixedChar::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.FixedChar) +// @@protoc_insertion_point(message_clear_start:substrait.Type.FixedChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4474,12 +4471,12 @@ const char* Type_FixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -4507,7 +4504,7 @@ const char* Type_FixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE ::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedChar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.FixedChar) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FixedChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -4523,7 +4520,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedChar::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -4534,12 +4531,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedChar::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.FixedChar) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FixedChar) return target; } size_t Type_FixedChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.FixedChar) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FixedChar) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4560,7 +4557,7 @@ size_t Type_FixedChar::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -4576,22 +4573,22 @@ size_t Type_FixedChar::ByteSizeLong() const { } void Type_FixedChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.FixedChar) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.FixedChar) GOOGLE_DCHECK_NE(&from, this); const Type_FixedChar* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.FixedChar) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.FixedChar) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.FixedChar) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.FixedChar) MergeFrom(*source); } } void Type_FixedChar::MergeFrom(const Type_FixedChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.FixedChar) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FixedChar) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4609,14 +4606,14 @@ void Type_FixedChar::MergeFrom(const Type_FixedChar& from) { } void Type_FixedChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.FixedChar) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.FixedChar) if (&from == this) return; Clear(); MergeFrom(from); } void Type_FixedChar::CopyFrom(const Type_FixedChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.FixedChar) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FixedChar) if (&from == this) return; Clear(); MergeFrom(from); @@ -4639,8 +4636,8 @@ void Type_FixedChar::InternalSwap(Type_FixedChar* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedChar::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[16]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[16]); } // =================================================================== @@ -4653,7 +4650,7 @@ Type_VarChar::Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.VarChar) + // @@protoc_insertion_point(arena_constructor:substrait.Type.VarChar) } Type_VarChar::Type_VarChar(const Type_VarChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -4661,7 +4658,7 @@ Type_VarChar::Type_VarChar(const Type_VarChar& from) ::memcpy(&length_, &from.length_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&length_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.VarChar) + // @@protoc_insertion_point(copy_constructor:substrait.Type.VarChar) } void Type_VarChar::SharedCtor() { @@ -4672,7 +4669,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_VarChar::~Type_VarChar() { - // @@protoc_insertion_point(destructor:io.substrait.Type.VarChar) + // @@protoc_insertion_point(destructor:substrait.Type.VarChar) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4692,7 +4689,7 @@ void Type_VarChar::SetCachedSize(int size) const { } void Type_VarChar::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.VarChar) +// @@protoc_insertion_point(message_clear_start:substrait.Type.VarChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4723,12 +4720,12 @@ const char* Type_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -4756,7 +4753,7 @@ const char* Type_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ::PROTOBUF_NAMESPACE_ID::uint8* Type_VarChar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.VarChar) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.VarChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -4772,7 +4769,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_VarChar::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -4783,12 +4780,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_VarChar::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.VarChar) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.VarChar) return target; } size_t Type_VarChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.VarChar) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.VarChar) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4809,7 +4806,7 @@ size_t Type_VarChar::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -4825,22 +4822,22 @@ size_t Type_VarChar::ByteSizeLong() const { } void Type_VarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.VarChar) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.VarChar) GOOGLE_DCHECK_NE(&from, this); const Type_VarChar* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.VarChar) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.VarChar) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.VarChar) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.VarChar) MergeFrom(*source); } } void Type_VarChar::MergeFrom(const Type_VarChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.VarChar) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.VarChar) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -4858,14 +4855,14 @@ void Type_VarChar::MergeFrom(const Type_VarChar& from) { } void Type_VarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.VarChar) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.VarChar) if (&from == this) return; Clear(); MergeFrom(from); } void Type_VarChar::CopyFrom(const Type_VarChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.VarChar) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.VarChar) if (&from == this) return; Clear(); MergeFrom(from); @@ -4888,8 +4885,8 @@ void Type_VarChar::InternalSwap(Type_VarChar* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_VarChar::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[17]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[17]); } // =================================================================== @@ -4902,7 +4899,7 @@ Type_FixedBinary::Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.FixedBinary) + // @@protoc_insertion_point(arena_constructor:substrait.Type.FixedBinary) } Type_FixedBinary::Type_FixedBinary(const Type_FixedBinary& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -4910,7 +4907,7 @@ Type_FixedBinary::Type_FixedBinary(const Type_FixedBinary& from) ::memcpy(&length_, &from.length_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&length_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.FixedBinary) + // @@protoc_insertion_point(copy_constructor:substrait.Type.FixedBinary) } void Type_FixedBinary::SharedCtor() { @@ -4921,7 +4918,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_FixedBinary::~Type_FixedBinary() { - // @@protoc_insertion_point(destructor:io.substrait.Type.FixedBinary) + // @@protoc_insertion_point(destructor:substrait.Type.FixedBinary) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4941,7 +4938,7 @@ void Type_FixedBinary::SetCachedSize(int size) const { } void Type_FixedBinary::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.FixedBinary) +// @@protoc_insertion_point(message_clear_start:substrait.Type.FixedBinary) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4972,12 +4969,12 @@ const char* Type_FixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -5005,7 +5002,7 @@ const char* Type_FixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPA ::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedBinary::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.FixedBinary) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FixedBinary) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -5021,7 +5018,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedBinary::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -5032,12 +5029,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedBinary::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.FixedBinary) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FixedBinary) return target; } size_t Type_FixedBinary::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.FixedBinary) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FixedBinary) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5058,7 +5055,7 @@ size_t Type_FixedBinary::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -5074,22 +5071,22 @@ size_t Type_FixedBinary::ByteSizeLong() const { } void Type_FixedBinary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.FixedBinary) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.FixedBinary) GOOGLE_DCHECK_NE(&from, this); const Type_FixedBinary* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.FixedBinary) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.FixedBinary) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.FixedBinary) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.FixedBinary) MergeFrom(*source); } } void Type_FixedBinary::MergeFrom(const Type_FixedBinary& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.FixedBinary) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FixedBinary) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5107,14 +5104,14 @@ void Type_FixedBinary::MergeFrom(const Type_FixedBinary& from) { } void Type_FixedBinary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.FixedBinary) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.FixedBinary) if (&from == this) return; Clear(); MergeFrom(from); } void Type_FixedBinary::CopyFrom(const Type_FixedBinary& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.FixedBinary) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FixedBinary) if (&from == this) return; Clear(); MergeFrom(from); @@ -5137,8 +5134,8 @@ void Type_FixedBinary::InternalSwap(Type_FixedBinary* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedBinary::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[18]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[18]); } // =================================================================== @@ -5151,7 +5148,7 @@ Type_Decimal::Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Decimal) + // @@protoc_insertion_point(arena_constructor:substrait.Type.Decimal) } Type_Decimal::Type_Decimal(const Type_Decimal& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -5159,7 +5156,7 @@ Type_Decimal::Type_Decimal(const Type_Decimal& from) ::memcpy(&scale_, &from.scale_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&scale_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Decimal) + // @@protoc_insertion_point(copy_constructor:substrait.Type.Decimal) } void Type_Decimal::SharedCtor() { @@ -5170,7 +5167,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_Decimal::~Type_Decimal() { - // @@protoc_insertion_point(destructor:io.substrait.Type.Decimal) + // @@protoc_insertion_point(destructor:substrait.Type.Decimal) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5190,7 +5187,7 @@ void Type_Decimal::SetCachedSize(int size) const { } void Type_Decimal::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Decimal) +// @@protoc_insertion_point(message_clear_start:substrait.Type.Decimal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5228,12 +5225,12 @@ const char* Type_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -5261,7 +5258,7 @@ const char* Type_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I ::PROTOBUF_NAMESPACE_ID::uint8* Type_Decimal::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Decimal) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Decimal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -5283,7 +5280,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Decimal::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -5294,12 +5291,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Decimal::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Decimal) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Decimal) return target; } size_t Type_Decimal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Decimal) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Decimal) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5327,7 +5324,7 @@ size_t Type_Decimal::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -5343,22 +5340,22 @@ size_t Type_Decimal::ByteSizeLong() const { } void Type_Decimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Decimal) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Decimal) GOOGLE_DCHECK_NE(&from, this); const Type_Decimal* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Decimal) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Decimal) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Decimal) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Decimal) MergeFrom(*source); } } void Type_Decimal::MergeFrom(const Type_Decimal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Decimal) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Decimal) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5379,14 +5376,14 @@ void Type_Decimal::MergeFrom(const Type_Decimal& from) { } void Type_Decimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Decimal) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Decimal) if (&from == this) return; Clear(); MergeFrom(from); } void Type_Decimal::CopyFrom(const Type_Decimal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Decimal) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Decimal) if (&from == this) return; Clear(); MergeFrom(from); @@ -5409,8 +5406,8 @@ void Type_Decimal::InternalSwap(Type_Decimal* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_Decimal::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[19]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[19]); } // =================================================================== @@ -5424,7 +5421,7 @@ Type_Struct::Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena) types_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Struct) + // @@protoc_insertion_point(arena_constructor:substrait.Type.Struct) } Type_Struct::Type_Struct(const Type_Struct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -5433,7 +5430,7 @@ Type_Struct::Type_Struct(const Type_Struct& from) ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Struct) + // @@protoc_insertion_point(copy_constructor:substrait.Type.Struct) } void Type_Struct::SharedCtor() { @@ -5444,7 +5441,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_Struct::~Type_Struct() { - // @@protoc_insertion_point(destructor:io.substrait.Type.Struct) + // @@protoc_insertion_point(destructor:substrait.Type.Struct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5464,7 +5461,7 @@ void Type_Struct::SetCachedSize(int size) const { } void Type_Struct::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Struct) +// @@protoc_insertion_point(message_clear_start:substrait.Type.Struct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5482,7 +5479,7 @@ const char* Type_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.Type types = 1; + // repeated .substrait.Type types = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -5501,12 +5498,12 @@ const char* Type_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -5534,11 +5531,11 @@ const char* Type_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ::PROTOBUF_NAMESPACE_ID::uint8* Type_Struct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Struct) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Struct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.Type types = 1; + // repeated .substrait.Type types = 1; for (unsigned int i = 0, n = static_cast(this->_internal_types_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -5552,7 +5549,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Struct::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -5563,19 +5560,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Struct::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Struct) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Struct) return target; } size_t Type_Struct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Struct) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Struct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.Type types = 1; + // repeated .substrait.Type types = 1; total_size += 1UL * this->_internal_types_size(); for (const auto& msg : this->types_) { total_size += @@ -5589,7 +5586,7 @@ size_t Type_Struct::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -5605,22 +5602,22 @@ size_t Type_Struct::ByteSizeLong() const { } void Type_Struct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Struct) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Struct) GOOGLE_DCHECK_NE(&from, this); const Type_Struct* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Struct) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Struct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Struct) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Struct) MergeFrom(*source); } } void Type_Struct::MergeFrom(const Type_Struct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Struct) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Struct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5636,14 +5633,14 @@ void Type_Struct::MergeFrom(const Type_Struct& from) { } void Type_Struct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Struct) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Struct) if (&from == this) return; Clear(); MergeFrom(from); } void Type_Struct::CopyFrom(const Type_Struct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Struct) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Struct) if (&from == this) return; Clear(); MergeFrom(from); @@ -5667,18 +5664,18 @@ void Type_Struct::InternalSwap(Type_Struct* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_Struct::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[20]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[20]); } // =================================================================== class Type_List::_Internal { public: - static const ::io::substrait::Type& type(const Type_List* msg); + static const ::substrait::Type& type(const Type_List* msg); }; -const ::io::substrait::Type& +const ::substrait::Type& Type_List::_Internal::type(const Type_List* msg) { return *msg->type_; } @@ -5686,20 +5683,20 @@ Type_List::Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.List) + // @@protoc_insertion_point(arena_constructor:substrait.Type.List) } Type_List::Type_List(const Type_List& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_type()) { - type_ = new ::io::substrait::Type(*from.type_); + type_ = new ::substrait::Type(*from.type_); } else { type_ = nullptr; } ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.List) + // @@protoc_insertion_point(copy_constructor:substrait.Type.List) } void Type_List::SharedCtor() { @@ -5710,7 +5707,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_List::~Type_List() { - // @@protoc_insertion_point(destructor:io.substrait.Type.List) + // @@protoc_insertion_point(destructor:substrait.Type.List) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -5731,7 +5728,7 @@ void Type_List::SetCachedSize(int size) const { } void Type_List::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.List) +// @@protoc_insertion_point(message_clear_start:substrait.Type.List) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5752,7 +5749,7 @@ const char* Type_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type type = 1; + // .substrait.Type type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); @@ -5766,12 +5763,12 @@ const char* Type_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -5799,11 +5796,11 @@ const char* Type_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID:: ::PROTOBUF_NAMESPACE_ID::uint8* Type_List::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.List) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.List) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type type = 1; + // .substrait.Type type = 1; if (this->has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5817,7 +5814,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_List::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -5828,19 +5825,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_List::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.List) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.List) return target; } size_t Type_List::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.List) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.List) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type type = 1; + // .substrait.Type type = 1; if (this->has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -5854,7 +5851,7 @@ size_t Type_List::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -5870,29 +5867,29 @@ size_t Type_List::ByteSizeLong() const { } void Type_List::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.List) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.List) GOOGLE_DCHECK_NE(&from, this); const Type_List* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.List) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.List) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.List) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.List) MergeFrom(*source); } } void Type_List::MergeFrom(const Type_List& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.List) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.List) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_type()) { - _internal_mutable_type()->::io::substrait::Type::MergeFrom(from._internal_type()); + _internal_mutable_type()->::substrait::Type::MergeFrom(from._internal_type()); } if (from.type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); @@ -5903,14 +5900,14 @@ void Type_List::MergeFrom(const Type_List& from) { } void Type_List::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.List) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.List) if (&from == this) return; Clear(); MergeFrom(from); } void Type_List::CopyFrom(const Type_List& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.List) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.List) if (&from == this) return; Clear(); MergeFrom(from); @@ -5933,23 +5930,23 @@ void Type_List::InternalSwap(Type_List* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_List::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[21]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[21]); } // =================================================================== class Type_Map::_Internal { public: - static const ::io::substrait::Type& key(const Type_Map* msg); - static const ::io::substrait::Type& value(const Type_Map* msg); + static const ::substrait::Type& key(const Type_Map* msg); + static const ::substrait::Type& value(const Type_Map* msg); }; -const ::io::substrait::Type& +const ::substrait::Type& Type_Map::_Internal::key(const Type_Map* msg) { return *msg->key_; } -const ::io::substrait::Type& +const ::substrait::Type& Type_Map::_Internal::value(const Type_Map* msg) { return *msg->value_; } @@ -5957,25 +5954,25 @@ Type_Map::Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type.Map) + // @@protoc_insertion_point(arena_constructor:substrait.Type.Map) } Type_Map::Type_Map(const Type_Map& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_key()) { - key_ = new ::io::substrait::Type(*from.key_); + key_ = new ::substrait::Type(*from.key_); } else { key_ = nullptr; } if (from._internal_has_value()) { - value_ = new ::io::substrait::Type(*from.value_); + value_ = new ::substrait::Type(*from.value_); } else { value_ = nullptr; } ::memcpy(&type_variation_reference_, &from.type_variation_reference_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.Type.Map) + // @@protoc_insertion_point(copy_constructor:substrait.Type.Map) } void Type_Map::SharedCtor() { @@ -5986,7 +5983,7 @@ ::memset(reinterpret_cast(this) + static_cast( } Type_Map::~Type_Map() { - // @@protoc_insertion_point(destructor:io.substrait.Type.Map) + // @@protoc_insertion_point(destructor:substrait.Type.Map) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -6008,7 +6005,7 @@ void Type_Map::SetCachedSize(int size) const { } void Type_Map::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type.Map) +// @@protoc_insertion_point(message_clear_start:substrait.Type.Map) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6033,14 +6030,14 @@ const char* Type_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type key = 1; + // .substrait.Type key = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type value = 2; + // .substrait.Type value = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); @@ -6054,12 +6051,12 @@ const char* Type_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -6087,11 +6084,11 @@ const char* Type_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::i ::PROTOBUF_NAMESPACE_ID::uint8* Type_Map::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type.Map) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Map) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type key = 1; + // .substrait.Type key = 1; if (this->has_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6099,7 +6096,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Map::_InternalSerialize( 1, _Internal::key(this), target, stream); } - // .io.substrait.Type value = 2; + // .substrait.Type value = 2; if (this->has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -6113,7 +6110,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Map::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_type_variation_reference(), target); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -6124,26 +6121,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Map::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type.Map) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Map) return target; } size_t Type_Map::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type.Map) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Map) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.Type key = 1; + // .substrait.Type key = 1; if (this->has_key()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *key_); } - // .io.substrait.Type value = 2; + // .substrait.Type value = 2; if (this->has_value()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -6157,7 +6154,7 @@ size_t Type_Map::ByteSizeLong() const { this->_internal_type_variation_reference()); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -6173,32 +6170,32 @@ size_t Type_Map::ByteSizeLong() const { } void Type_Map::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type.Map) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Map) GOOGLE_DCHECK_NE(&from, this); const Type_Map* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type.Map) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Map) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type.Map) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Map) MergeFrom(*source); } } void Type_Map::MergeFrom(const Type_Map& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type.Map) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Map) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_key()) { - _internal_mutable_key()->::io::substrait::Type::MergeFrom(from._internal_key()); + _internal_mutable_key()->::substrait::Type::MergeFrom(from._internal_key()); } if (from.has_value()) { - _internal_mutable_value()->::io::substrait::Type::MergeFrom(from._internal_value()); + _internal_mutable_value()->::substrait::Type::MergeFrom(from._internal_value()); } if (from.type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); @@ -6209,14 +6206,14 @@ void Type_Map::MergeFrom(const Type_Map& from) { } void Type_Map::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type.Map) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Map) if (&from == this) return; Clear(); MergeFrom(from); } void Type_Map::CopyFrom(const Type_Map& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type.Map) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Map) if (&from == this) return; Clear(); MergeFrom(from); @@ -6239,132 +6236,132 @@ void Type_Map::InternalSwap(Type_Map* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type_Map::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[22]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[22]); } // =================================================================== class Type::_Internal { public: - static const ::io::substrait::Type_Boolean& bool_(const Type* msg); - static const ::io::substrait::Type_I8& i8(const Type* msg); - static const ::io::substrait::Type_I16& i16(const Type* msg); - static const ::io::substrait::Type_I32& i32(const Type* msg); - static const ::io::substrait::Type_I64& i64(const Type* msg); - static const ::io::substrait::Type_FP32& fp32(const Type* msg); - static const ::io::substrait::Type_FP64& fp64(const Type* msg); - static const ::io::substrait::Type_String& string(const Type* msg); - static const ::io::substrait::Type_Binary& binary(const Type* msg); - static const ::io::substrait::Type_Timestamp& timestamp(const Type* msg); - static const ::io::substrait::Type_Date& date(const Type* msg); - static const ::io::substrait::Type_Time& time(const Type* msg); - static const ::io::substrait::Type_IntervalYear& interval_year(const Type* msg); - static const ::io::substrait::Type_IntervalDay& interval_day(const Type* msg); - static const ::io::substrait::Type_TimestampTZ& timestamp_tz(const Type* msg); - static const ::io::substrait::Type_UUID& uuid(const Type* msg); - static const ::io::substrait::Type_FixedChar& fixed_char(const Type* msg); - static const ::io::substrait::Type_VarChar& varchar(const Type* msg); - static const ::io::substrait::Type_FixedBinary& fixed_binary(const Type* msg); - static const ::io::substrait::Type_Decimal& decimal(const Type* msg); - static const ::io::substrait::Type_Struct& struct_(const Type* msg); - static const ::io::substrait::Type_List& list(const Type* msg); - static const ::io::substrait::Type_Map& map(const Type* msg); + static const ::substrait::Type_Boolean& bool_(const Type* msg); + static const ::substrait::Type_I8& i8(const Type* msg); + static const ::substrait::Type_I16& i16(const Type* msg); + static const ::substrait::Type_I32& i32(const Type* msg); + static const ::substrait::Type_I64& i64(const Type* msg); + static const ::substrait::Type_FP32& fp32(const Type* msg); + static const ::substrait::Type_FP64& fp64(const Type* msg); + static const ::substrait::Type_String& string(const Type* msg); + static const ::substrait::Type_Binary& binary(const Type* msg); + static const ::substrait::Type_Timestamp& timestamp(const Type* msg); + static const ::substrait::Type_Date& date(const Type* msg); + static const ::substrait::Type_Time& time(const Type* msg); + static const ::substrait::Type_IntervalYear& interval_year(const Type* msg); + static const ::substrait::Type_IntervalDay& interval_day(const Type* msg); + static const ::substrait::Type_TimestampTZ& timestamp_tz(const Type* msg); + static const ::substrait::Type_UUID& uuid(const Type* msg); + static const ::substrait::Type_FixedChar& fixed_char(const Type* msg); + static const ::substrait::Type_VarChar& varchar(const Type* msg); + static const ::substrait::Type_FixedBinary& fixed_binary(const Type* msg); + static const ::substrait::Type_Decimal& decimal(const Type* msg); + static const ::substrait::Type_Struct& struct_(const Type* msg); + static const ::substrait::Type_List& list(const Type* msg); + static const ::substrait::Type_Map& map(const Type* msg); }; -const ::io::substrait::Type_Boolean& +const ::substrait::Type_Boolean& Type::_Internal::bool_(const Type* msg) { return *msg->kind_.bool__; } -const ::io::substrait::Type_I8& +const ::substrait::Type_I8& Type::_Internal::i8(const Type* msg) { return *msg->kind_.i8_; } -const ::io::substrait::Type_I16& +const ::substrait::Type_I16& Type::_Internal::i16(const Type* msg) { return *msg->kind_.i16_; } -const ::io::substrait::Type_I32& +const ::substrait::Type_I32& Type::_Internal::i32(const Type* msg) { return *msg->kind_.i32_; } -const ::io::substrait::Type_I64& +const ::substrait::Type_I64& Type::_Internal::i64(const Type* msg) { return *msg->kind_.i64_; } -const ::io::substrait::Type_FP32& +const ::substrait::Type_FP32& Type::_Internal::fp32(const Type* msg) { return *msg->kind_.fp32_; } -const ::io::substrait::Type_FP64& +const ::substrait::Type_FP64& Type::_Internal::fp64(const Type* msg) { return *msg->kind_.fp64_; } -const ::io::substrait::Type_String& +const ::substrait::Type_String& Type::_Internal::string(const Type* msg) { return *msg->kind_.string_; } -const ::io::substrait::Type_Binary& +const ::substrait::Type_Binary& Type::_Internal::binary(const Type* msg) { return *msg->kind_.binary_; } -const ::io::substrait::Type_Timestamp& +const ::substrait::Type_Timestamp& Type::_Internal::timestamp(const Type* msg) { return *msg->kind_.timestamp_; } -const ::io::substrait::Type_Date& +const ::substrait::Type_Date& Type::_Internal::date(const Type* msg) { return *msg->kind_.date_; } -const ::io::substrait::Type_Time& +const ::substrait::Type_Time& Type::_Internal::time(const Type* msg) { return *msg->kind_.time_; } -const ::io::substrait::Type_IntervalYear& +const ::substrait::Type_IntervalYear& Type::_Internal::interval_year(const Type* msg) { return *msg->kind_.interval_year_; } -const ::io::substrait::Type_IntervalDay& +const ::substrait::Type_IntervalDay& Type::_Internal::interval_day(const Type* msg) { return *msg->kind_.interval_day_; } -const ::io::substrait::Type_TimestampTZ& +const ::substrait::Type_TimestampTZ& Type::_Internal::timestamp_tz(const Type* msg) { return *msg->kind_.timestamp_tz_; } -const ::io::substrait::Type_UUID& +const ::substrait::Type_UUID& Type::_Internal::uuid(const Type* msg) { return *msg->kind_.uuid_; } -const ::io::substrait::Type_FixedChar& +const ::substrait::Type_FixedChar& Type::_Internal::fixed_char(const Type* msg) { return *msg->kind_.fixed_char_; } -const ::io::substrait::Type_VarChar& +const ::substrait::Type_VarChar& Type::_Internal::varchar(const Type* msg) { return *msg->kind_.varchar_; } -const ::io::substrait::Type_FixedBinary& +const ::substrait::Type_FixedBinary& Type::_Internal::fixed_binary(const Type* msg) { return *msg->kind_.fixed_binary_; } -const ::io::substrait::Type_Decimal& +const ::substrait::Type_Decimal& Type::_Internal::decimal(const Type* msg) { return *msg->kind_.decimal_; } -const ::io::substrait::Type_Struct& +const ::substrait::Type_Struct& Type::_Internal::struct_(const Type* msg) { return *msg->kind_.struct__; } -const ::io::substrait::Type_List& +const ::substrait::Type_List& Type::_Internal::list(const Type* msg) { return *msg->kind_.list_; } -const ::io::substrait::Type_Map& +const ::substrait::Type_Map& Type::_Internal::map(const Type* msg) { return *msg->kind_.map_; } -void Type::set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { +void Type::set_allocated_bool_(::substrait::Type_Boolean* bool_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (bool_) { @@ -6377,9 +6374,9 @@ void Type::set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { set_has_bool_(); kind_.bool__ = bool_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.bool) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.bool) } -void Type::set_allocated_i8(::io::substrait::Type_I8* i8) { +void Type::set_allocated_i8(::substrait::Type_I8* i8) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i8) { @@ -6392,9 +6389,9 @@ void Type::set_allocated_i8(::io::substrait::Type_I8* i8) { set_has_i8(); kind_.i8_ = i8; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.i8) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.i8) } -void Type::set_allocated_i16(::io::substrait::Type_I16* i16) { +void Type::set_allocated_i16(::substrait::Type_I16* i16) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i16) { @@ -6407,9 +6404,9 @@ void Type::set_allocated_i16(::io::substrait::Type_I16* i16) { set_has_i16(); kind_.i16_ = i16; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.i16) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.i16) } -void Type::set_allocated_i32(::io::substrait::Type_I32* i32) { +void Type::set_allocated_i32(::substrait::Type_I32* i32) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i32) { @@ -6422,9 +6419,9 @@ void Type::set_allocated_i32(::io::substrait::Type_I32* i32) { set_has_i32(); kind_.i32_ = i32; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.i32) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.i32) } -void Type::set_allocated_i64(::io::substrait::Type_I64* i64) { +void Type::set_allocated_i64(::substrait::Type_I64* i64) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i64) { @@ -6437,9 +6434,9 @@ void Type::set_allocated_i64(::io::substrait::Type_I64* i64) { set_has_i64(); kind_.i64_ = i64; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.i64) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.i64) } -void Type::set_allocated_fp32(::io::substrait::Type_FP32* fp32) { +void Type::set_allocated_fp32(::substrait::Type_FP32* fp32) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fp32) { @@ -6452,9 +6449,9 @@ void Type::set_allocated_fp32(::io::substrait::Type_FP32* fp32) { set_has_fp32(); kind_.fp32_ = fp32; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.fp32) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.fp32) } -void Type::set_allocated_fp64(::io::substrait::Type_FP64* fp64) { +void Type::set_allocated_fp64(::substrait::Type_FP64* fp64) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fp64) { @@ -6467,9 +6464,9 @@ void Type::set_allocated_fp64(::io::substrait::Type_FP64* fp64) { set_has_fp64(); kind_.fp64_ = fp64; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.fp64) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.fp64) } -void Type::set_allocated_string(::io::substrait::Type_String* string) { +void Type::set_allocated_string(::substrait::Type_String* string) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (string) { @@ -6482,9 +6479,9 @@ void Type::set_allocated_string(::io::substrait::Type_String* string) { set_has_string(); kind_.string_ = string; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.string) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.string) } -void Type::set_allocated_binary(::io::substrait::Type_Binary* binary) { +void Type::set_allocated_binary(::substrait::Type_Binary* binary) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (binary) { @@ -6497,9 +6494,9 @@ void Type::set_allocated_binary(::io::substrait::Type_Binary* binary) { set_has_binary(); kind_.binary_ = binary; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.binary) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.binary) } -void Type::set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { +void Type::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (timestamp) { @@ -6512,9 +6509,9 @@ void Type::set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { set_has_timestamp(); kind_.timestamp_ = timestamp; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.timestamp) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.timestamp) } -void Type::set_allocated_date(::io::substrait::Type_Date* date) { +void Type::set_allocated_date(::substrait::Type_Date* date) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (date) { @@ -6527,9 +6524,9 @@ void Type::set_allocated_date(::io::substrait::Type_Date* date) { set_has_date(); kind_.date_ = date; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.date) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.date) } -void Type::set_allocated_time(::io::substrait::Type_Time* time) { +void Type::set_allocated_time(::substrait::Type_Time* time) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (time) { @@ -6542,9 +6539,9 @@ void Type::set_allocated_time(::io::substrait::Type_Time* time) { set_has_time(); kind_.time_ = time; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.time) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.time) } -void Type::set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { +void Type::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (interval_year) { @@ -6557,9 +6554,9 @@ void Type::set_allocated_interval_year(::io::substrait::Type_IntervalYear* inter set_has_interval_year(); kind_.interval_year_ = interval_year; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.interval_year) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.interval_year) } -void Type::set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { +void Type::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (interval_day) { @@ -6572,9 +6569,9 @@ void Type::set_allocated_interval_day(::io::substrait::Type_IntervalDay* interva set_has_interval_day(); kind_.interval_day_ = interval_day; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.interval_day) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.interval_day) } -void Type::set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { +void Type::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (timestamp_tz) { @@ -6587,9 +6584,9 @@ void Type::set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timesta set_has_timestamp_tz(); kind_.timestamp_tz_ = timestamp_tz; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.timestamp_tz) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.timestamp_tz) } -void Type::set_allocated_uuid(::io::substrait::Type_UUID* uuid) { +void Type::set_allocated_uuid(::substrait::Type_UUID* uuid) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (uuid) { @@ -6602,9 +6599,9 @@ void Type::set_allocated_uuid(::io::substrait::Type_UUID* uuid) { set_has_uuid(); kind_.uuid_ = uuid; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.uuid) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.uuid) } -void Type::set_allocated_fixed_char(::io::substrait::Type_FixedChar* fixed_char) { +void Type::set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fixed_char) { @@ -6617,9 +6614,9 @@ void Type::set_allocated_fixed_char(::io::substrait::Type_FixedChar* fixed_char) set_has_fixed_char(); kind_.fixed_char_ = fixed_char; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.fixed_char) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.fixed_char) } -void Type::set_allocated_varchar(::io::substrait::Type_VarChar* varchar) { +void Type::set_allocated_varchar(::substrait::Type_VarChar* varchar) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (varchar) { @@ -6632,9 +6629,9 @@ void Type::set_allocated_varchar(::io::substrait::Type_VarChar* varchar) { set_has_varchar(); kind_.varchar_ = varchar; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.varchar) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.varchar) } -void Type::set_allocated_fixed_binary(::io::substrait::Type_FixedBinary* fixed_binary) { +void Type::set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fixed_binary) { @@ -6647,9 +6644,9 @@ void Type::set_allocated_fixed_binary(::io::substrait::Type_FixedBinary* fixed_b set_has_fixed_binary(); kind_.fixed_binary_ = fixed_binary; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.fixed_binary) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.fixed_binary) } -void Type::set_allocated_decimal(::io::substrait::Type_Decimal* decimal) { +void Type::set_allocated_decimal(::substrait::Type_Decimal* decimal) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (decimal) { @@ -6662,9 +6659,9 @@ void Type::set_allocated_decimal(::io::substrait::Type_Decimal* decimal) { set_has_decimal(); kind_.decimal_ = decimal; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.decimal) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.decimal) } -void Type::set_allocated_struct_(::io::substrait::Type_Struct* struct_) { +void Type::set_allocated_struct_(::substrait::Type_Struct* struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (struct_) { @@ -6677,9 +6674,9 @@ void Type::set_allocated_struct_(::io::substrait::Type_Struct* struct_) { set_has_struct_(); kind_.struct__ = struct_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.struct) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.struct) } -void Type::set_allocated_list(::io::substrait::Type_List* list) { +void Type::set_allocated_list(::substrait::Type_List* list) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (list) { @@ -6692,9 +6689,9 @@ void Type::set_allocated_list(::io::substrait::Type_List* list) { set_has_list(); kind_.list_ = list; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.list) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.list) } -void Type::set_allocated_map(::io::substrait::Type_Map* map) { +void Type::set_allocated_map(::substrait::Type_Map* map) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (map) { @@ -6707,13 +6704,13 @@ void Type::set_allocated_map(::io::substrait::Type_Map* map) { set_has_map(); kind_.map_ = map; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.map) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.map) } Type::Type(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.Type) + // @@protoc_insertion_point(arena_constructor:substrait.Type) } Type::Type(const Type& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -6721,95 +6718,95 @@ Type::Type(const Type& from) clear_has_kind(); switch (from.kind_case()) { case kBool: { - _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); break; } case kI8: { - _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); break; } case kI16: { - _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); break; } case kI32: { - _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); break; } case kI64: { - _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); break; } case kFp32: { - _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); break; } case kFp64: { - _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); break; } case kString: { - _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); break; } case kBinary: { - _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); break; } case kTimestamp: { - _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); break; } case kDate: { - _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); break; } case kTime: { - _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); break; } case kIntervalYear: { - _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); break; } case kIntervalDay: { - _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); break; } case kTimestampTz: { - _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); break; } case kUuid: { - _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); break; } case kFixedChar: { - _internal_mutable_fixed_char()->::io::substrait::Type_FixedChar::MergeFrom(from._internal_fixed_char()); + _internal_mutable_fixed_char()->::substrait::Type_FixedChar::MergeFrom(from._internal_fixed_char()); break; } case kVarchar: { - _internal_mutable_varchar()->::io::substrait::Type_VarChar::MergeFrom(from._internal_varchar()); + _internal_mutable_varchar()->::substrait::Type_VarChar::MergeFrom(from._internal_varchar()); break; } case kFixedBinary: { - _internal_mutable_fixed_binary()->::io::substrait::Type_FixedBinary::MergeFrom(from._internal_fixed_binary()); + _internal_mutable_fixed_binary()->::substrait::Type_FixedBinary::MergeFrom(from._internal_fixed_binary()); break; } case kDecimal: { - _internal_mutable_decimal()->::io::substrait::Type_Decimal::MergeFrom(from._internal_decimal()); + _internal_mutable_decimal()->::substrait::Type_Decimal::MergeFrom(from._internal_decimal()); break; } case kStruct: { - _internal_mutable_struct_()->::io::substrait::Type_Struct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::Type_Struct::MergeFrom(from._internal_struct_()); break; } case kList: { - _internal_mutable_list()->::io::substrait::Type_List::MergeFrom(from._internal_list()); + _internal_mutable_list()->::substrait::Type_List::MergeFrom(from._internal_list()); break; } case kMap: { - _internal_mutable_map()->::io::substrait::Type_Map::MergeFrom(from._internal_map()); + _internal_mutable_map()->::substrait::Type_Map::MergeFrom(from._internal_map()); break; } case kUserDefinedTypeReference: { @@ -6820,7 +6817,7 @@ Type::Type(const Type& from) break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.Type) + // @@protoc_insertion_point(copy_constructor:substrait.Type) } void Type::SharedCtor() { @@ -6828,7 +6825,7 @@ clear_has_kind(); } Type::~Type() { - // @@protoc_insertion_point(destructor:io.substrait.Type) + // @@protoc_insertion_point(destructor:substrait.Type) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -6851,7 +6848,7 @@ void Type::SetCachedSize(int size) const { } void Type::clear_kind() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.Type) +// @@protoc_insertion_point(one_of_clear_start:substrait.Type) switch (kind_case()) { case kBool: { if (GetArena() == nullptr) { @@ -7004,7 +7001,7 @@ void Type::clear_kind() { void Type::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.Type) +// @@protoc_insertion_point(message_clear_start:substrait.Type) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7019,154 +7016,154 @@ const char* Type::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; case 14: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; case 16: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; case 17: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; case 19: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; case 20: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.FixedChar fixed_char = 21; + // .substrait.Type.FixedChar fixed_char = 21; case 21: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.VarChar varchar = 22; + // .substrait.Type.VarChar varchar = 22; case 22: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.FixedBinary fixed_binary = 23; + // .substrait.Type.FixedBinary fixed_binary = 23; case 23: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Decimal decimal = 24; + // .substrait.Type.Decimal decimal = 24; case 24: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Struct struct = 25; + // .substrait.Type.Struct struct = 25; case 25: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.List list = 27; + // .substrait.Type.List list = 27; case 27: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) { ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Map map = 28; + // .substrait.Type.Map map = 28; case 28: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; case 29: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); @@ -7180,7 +7177,7 @@ const char* Type::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; case 32: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); @@ -7212,11 +7209,11 @@ const char* Type::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.Type) + // @@protoc_insertion_point(serialize_to_array_start:substrait.Type) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; if (_internal_has_bool_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7224,7 +7221,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 1, _Internal::bool_(this), target, stream); } - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; if (_internal_has_i8()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7232,7 +7229,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 2, _Internal::i8(this), target, stream); } - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; if (_internal_has_i16()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7240,7 +7237,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 3, _Internal::i16(this), target, stream); } - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; if (_internal_has_i32()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7248,7 +7245,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 5, _Internal::i32(this), target, stream); } - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; if (_internal_has_i64()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7256,7 +7253,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 7, _Internal::i64(this), target, stream); } - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; if (_internal_has_fp32()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7264,7 +7261,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 10, _Internal::fp32(this), target, stream); } - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; if (_internal_has_fp64()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7272,7 +7269,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 11, _Internal::fp64(this), target, stream); } - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; if (_internal_has_string()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7280,7 +7277,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 12, _Internal::string(this), target, stream); } - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; if (_internal_has_binary()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7288,7 +7285,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 13, _Internal::binary(this), target, stream); } - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; if (_internal_has_timestamp()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7296,7 +7293,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 14, _Internal::timestamp(this), target, stream); } - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; if (_internal_has_date()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7304,7 +7301,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 16, _Internal::date(this), target, stream); } - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; if (_internal_has_time()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7312,7 +7309,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 17, _Internal::time(this), target, stream); } - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; if (_internal_has_interval_year()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7320,7 +7317,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 19, _Internal::interval_year(this), target, stream); } - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; if (_internal_has_interval_day()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7328,7 +7325,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 20, _Internal::interval_day(this), target, stream); } - // .io.substrait.Type.FixedChar fixed_char = 21; + // .substrait.Type.FixedChar fixed_char = 21; if (_internal_has_fixed_char()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7336,7 +7333,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 21, _Internal::fixed_char(this), target, stream); } - // .io.substrait.Type.VarChar varchar = 22; + // .substrait.Type.VarChar varchar = 22; if (_internal_has_varchar()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7344,7 +7341,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 22, _Internal::varchar(this), target, stream); } - // .io.substrait.Type.FixedBinary fixed_binary = 23; + // .substrait.Type.FixedBinary fixed_binary = 23; if (_internal_has_fixed_binary()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7352,7 +7349,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 23, _Internal::fixed_binary(this), target, stream); } - // .io.substrait.Type.Decimal decimal = 24; + // .substrait.Type.Decimal decimal = 24; if (_internal_has_decimal()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7360,7 +7357,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 24, _Internal::decimal(this), target, stream); } - // .io.substrait.Type.Struct struct = 25; + // .substrait.Type.Struct struct = 25; if (_internal_has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7368,7 +7365,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 25, _Internal::struct_(this), target, stream); } - // .io.substrait.Type.List list = 27; + // .substrait.Type.List list = 27; if (_internal_has_list()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7376,7 +7373,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 27, _Internal::list(this), target, stream); } - // .io.substrait.Type.Map map = 28; + // .substrait.Type.Map map = 28; if (_internal_has_map()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7384,7 +7381,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( 28, _Internal::map(this), target, stream); } - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; if (_internal_has_timestamp_tz()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7398,7 +7395,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_type_reference(), target); } - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; if (_internal_has_uuid()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7410,12 +7407,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.Type) + // @@protoc_insertion_point(serialize_to_array_end:substrait.Type) return target; } size_t Type::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.Type) +// @@protoc_insertion_point(message_byte_size_start:substrait.Type) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -7423,161 +7420,161 @@ size_t Type::ByteSizeLong() const { (void) cached_has_bits; switch (kind_case()) { - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; case kBool: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.bool__); break; } - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; case kI8: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i8_); break; } - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; case kI16: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i16_); break; } - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; case kI32: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i32_); break; } - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; case kI64: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i64_); break; } - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; case kFp32: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fp32_); break; } - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; case kFp64: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fp64_); break; } - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; case kString: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.string_); break; } - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; case kBinary: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.binary_); break; } - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; case kTimestamp: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.timestamp_); break; } - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; case kDate: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.date_); break; } - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; case kTime: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.time_); break; } - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; case kIntervalYear: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.interval_year_); break; } - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; case kIntervalDay: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.interval_day_); break; } - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; case kTimestampTz: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.timestamp_tz_); break; } - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; case kUuid: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.uuid_); break; } - // .io.substrait.Type.FixedChar fixed_char = 21; + // .substrait.Type.FixedChar fixed_char = 21; case kFixedChar: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fixed_char_); break; } - // .io.substrait.Type.VarChar varchar = 22; + // .substrait.Type.VarChar varchar = 22; case kVarchar: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.varchar_); break; } - // .io.substrait.Type.FixedBinary fixed_binary = 23; + // .substrait.Type.FixedBinary fixed_binary = 23; case kFixedBinary: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fixed_binary_); break; } - // .io.substrait.Type.Decimal decimal = 24; + // .substrait.Type.Decimal decimal = 24; case kDecimal: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.decimal_); break; } - // .io.substrait.Type.Struct struct = 25; + // .substrait.Type.Struct struct = 25; case kStruct: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.struct__); break; } - // .io.substrait.Type.List list = 27; + // .substrait.Type.List list = 27; case kList: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.list_); break; } - // .io.substrait.Type.Map map = 28; + // .substrait.Type.Map map = 28; case kMap: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -7605,22 +7602,22 @@ size_t Type::ByteSizeLong() const { } void Type::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.Type) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type) GOOGLE_DCHECK_NE(&from, this); const Type* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.Type) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.Type) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type) MergeFrom(*source); } } void Type::MergeFrom(const Type& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.Type) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -7628,95 +7625,95 @@ void Type::MergeFrom(const Type& from) { switch (from.kind_case()) { case kBool: { - _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); break; } case kI8: { - _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); break; } case kI16: { - _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); break; } case kI32: { - _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); break; } case kI64: { - _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); break; } case kFp32: { - _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); break; } case kFp64: { - _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); break; } case kString: { - _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); break; } case kBinary: { - _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); break; } case kTimestamp: { - _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); break; } case kDate: { - _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); break; } case kTime: { - _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); break; } case kIntervalYear: { - _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); break; } case kIntervalDay: { - _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); break; } case kTimestampTz: { - _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); break; } case kUuid: { - _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); break; } case kFixedChar: { - _internal_mutable_fixed_char()->::io::substrait::Type_FixedChar::MergeFrom(from._internal_fixed_char()); + _internal_mutable_fixed_char()->::substrait::Type_FixedChar::MergeFrom(from._internal_fixed_char()); break; } case kVarchar: { - _internal_mutable_varchar()->::io::substrait::Type_VarChar::MergeFrom(from._internal_varchar()); + _internal_mutable_varchar()->::substrait::Type_VarChar::MergeFrom(from._internal_varchar()); break; } case kFixedBinary: { - _internal_mutable_fixed_binary()->::io::substrait::Type_FixedBinary::MergeFrom(from._internal_fixed_binary()); + _internal_mutable_fixed_binary()->::substrait::Type_FixedBinary::MergeFrom(from._internal_fixed_binary()); break; } case kDecimal: { - _internal_mutable_decimal()->::io::substrait::Type_Decimal::MergeFrom(from._internal_decimal()); + _internal_mutable_decimal()->::substrait::Type_Decimal::MergeFrom(from._internal_decimal()); break; } case kStruct: { - _internal_mutable_struct_()->::io::substrait::Type_Struct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::Type_Struct::MergeFrom(from._internal_struct_()); break; } case kList: { - _internal_mutable_list()->::io::substrait::Type_List::MergeFrom(from._internal_list()); + _internal_mutable_list()->::substrait::Type_List::MergeFrom(from._internal_list()); break; } case kMap: { - _internal_mutable_map()->::io::substrait::Type_Map::MergeFrom(from._internal_map()); + _internal_mutable_map()->::substrait::Type_Map::MergeFrom(from._internal_map()); break; } case kUserDefinedTypeReference: { @@ -7730,14 +7727,14 @@ void Type::MergeFrom(const Type& from) { } void Type::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.Type) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type) if (&from == this) return; Clear(); MergeFrom(from); } void Type::CopyFrom(const Type& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.Type) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type) if (&from == this) return; Clear(); MergeFrom(from); @@ -7756,18 +7753,18 @@ void Type::InternalSwap(Type* other) { ::PROTOBUF_NAMESPACE_ID::Metadata Type::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[23]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[23]); } // =================================================================== class NamedStruct::_Internal { public: - static const ::io::substrait::Type_Struct& struct_(const NamedStruct* msg); + static const ::substrait::Type_Struct& struct_(const NamedStruct* msg); }; -const ::io::substrait::Type_Struct& +const ::substrait::Type_Struct& NamedStruct::_Internal::struct_(const NamedStruct* msg) { return *msg->struct__; } @@ -7776,18 +7773,18 @@ NamedStruct::NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) names_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.NamedStruct) + // @@protoc_insertion_point(arena_constructor:substrait.NamedStruct) } NamedStruct::NamedStruct(const NamedStruct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), names_(from.names_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_struct_()) { - struct__ = new ::io::substrait::Type_Struct(*from.struct__); + struct__ = new ::substrait::Type_Struct(*from.struct__); } else { struct__ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.NamedStruct) + // @@protoc_insertion_point(copy_constructor:substrait.NamedStruct) } void NamedStruct::SharedCtor() { @@ -7795,7 +7792,7 @@ struct__ = nullptr; } NamedStruct::~NamedStruct() { - // @@protoc_insertion_point(destructor:io.substrait.NamedStruct) + // @@protoc_insertion_point(destructor:substrait.NamedStruct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -7816,7 +7813,7 @@ void NamedStruct::SetCachedSize(int size) const { } void NamedStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.NamedStruct) +// @@protoc_insertion_point(message_clear_start:substrait.NamedStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7843,13 +7840,13 @@ const char* NamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ptr += 1; auto str = _internal_add_names(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.NamedStruct.names")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.NamedStruct.names")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.Type.Struct struct = 2; + // .substrait.Type.Struct struct = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); @@ -7881,7 +7878,7 @@ const char* NamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID ::PROTOBUF_NAMESPACE_ID::uint8* NamedStruct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.NamedStruct) + // @@protoc_insertion_point(serialize_to_array_start:substrait.NamedStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -7891,11 +7888,11 @@ ::PROTOBUF_NAMESPACE_ID::uint8* NamedStruct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.NamedStruct.names"); + "substrait.NamedStruct.names"); target = stream->WriteString(1, s, target); } - // .io.substrait.Type.Struct struct = 2; + // .substrait.Type.Struct struct = 2; if (this->has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -7907,12 +7904,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* NamedStruct::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.NamedStruct) + // @@protoc_insertion_point(serialize_to_array_end:substrait.NamedStruct) return target; } size_t NamedStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.NamedStruct) +// @@protoc_insertion_point(message_byte_size_start:substrait.NamedStruct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -7927,7 +7924,7 @@ size_t NamedStruct::ByteSizeLong() const { names_.Get(i)); } - // .io.substrait.Type.Struct struct = 2; + // .substrait.Type.Struct struct = 2; if (this->has_struct_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -7944,22 +7941,22 @@ size_t NamedStruct::ByteSizeLong() const { } void NamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.NamedStruct) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.NamedStruct) GOOGLE_DCHECK_NE(&from, this); const NamedStruct* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.NamedStruct) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.NamedStruct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.NamedStruct) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.NamedStruct) MergeFrom(*source); } } void NamedStruct::MergeFrom(const NamedStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.NamedStruct) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.NamedStruct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -7967,19 +7964,19 @@ void NamedStruct::MergeFrom(const NamedStruct& from) { names_.MergeFrom(from.names_); if (from.has_struct_()) { - _internal_mutable_struct_()->::io::substrait::Type_Struct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::Type_Struct::MergeFrom(from._internal_struct_()); } } void NamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.NamedStruct) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.NamedStruct) if (&from == this) return; Clear(); MergeFrom(from); } void NamedStruct::CopyFrom(const NamedStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.NamedStruct) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.NamedStruct) if (&from == this) return; Clear(); MergeFrom(from); @@ -7998,88 +7995,87 @@ void NamedStruct::InternalSwap(NamedStruct* other) { ::PROTOBUF_NAMESPACE_ID::Metadata NamedStruct::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_2eproto_getter, &descriptor_table_type_2eproto_once, - file_level_metadata_type_2eproto[24]); + &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, + file_level_metadata_substrait_2ftype_2eproto[24]); } // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::Type_Boolean* Arena::CreateMaybeMessage< ::io::substrait::Type_Boolean >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_Boolean >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_Boolean* Arena::CreateMaybeMessage< ::substrait::Type_Boolean >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_Boolean >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_I8* Arena::CreateMaybeMessage< ::io::substrait::Type_I8 >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_I8 >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_I8* Arena::CreateMaybeMessage< ::substrait::Type_I8 >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_I8 >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_I16* Arena::CreateMaybeMessage< ::io::substrait::Type_I16 >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_I16 >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_I16* Arena::CreateMaybeMessage< ::substrait::Type_I16 >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_I16 >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_I32* Arena::CreateMaybeMessage< ::io::substrait::Type_I32 >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_I32 >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_I32* Arena::CreateMaybeMessage< ::substrait::Type_I32 >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_I32 >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_I64* Arena::CreateMaybeMessage< ::io::substrait::Type_I64 >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_I64 >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_I64* Arena::CreateMaybeMessage< ::substrait::Type_I64 >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_I64 >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_FP32* Arena::CreateMaybeMessage< ::io::substrait::Type_FP32 >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_FP32 >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_FP32* Arena::CreateMaybeMessage< ::substrait::Type_FP32 >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_FP32 >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_FP64* Arena::CreateMaybeMessage< ::io::substrait::Type_FP64 >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_FP64 >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_FP64* Arena::CreateMaybeMessage< ::substrait::Type_FP64 >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_FP64 >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_String* Arena::CreateMaybeMessage< ::io::substrait::Type_String >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_String >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_String* Arena::CreateMaybeMessage< ::substrait::Type_String >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_String >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_Binary* Arena::CreateMaybeMessage< ::io::substrait::Type_Binary >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_Binary >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_Binary* Arena::CreateMaybeMessage< ::substrait::Type_Binary >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_Binary >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_Timestamp* Arena::CreateMaybeMessage< ::io::substrait::Type_Timestamp >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_Timestamp >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_Timestamp* Arena::CreateMaybeMessage< ::substrait::Type_Timestamp >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_Timestamp >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_Date* Arena::CreateMaybeMessage< ::io::substrait::Type_Date >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_Date >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_Date* Arena::CreateMaybeMessage< ::substrait::Type_Date >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_Date >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_Time* Arena::CreateMaybeMessage< ::io::substrait::Type_Time >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_Time >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_Time* Arena::CreateMaybeMessage< ::substrait::Type_Time >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_Time >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage< ::io::substrait::Type_TimestampTZ >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_TimestampTZ >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage< ::substrait::Type_TimestampTZ >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_TimestampTZ >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_IntervalYear* Arena::CreateMaybeMessage< ::io::substrait::Type_IntervalYear >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_IntervalYear >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_IntervalYear* Arena::CreateMaybeMessage< ::substrait::Type_IntervalYear >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_IntervalYear >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_IntervalDay* Arena::CreateMaybeMessage< ::io::substrait::Type_IntervalDay >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_IntervalDay >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_IntervalDay* Arena::CreateMaybeMessage< ::substrait::Type_IntervalDay >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_IntervalDay >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_UUID* Arena::CreateMaybeMessage< ::io::substrait::Type_UUID >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_UUID >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_UUID* Arena::CreateMaybeMessage< ::substrait::Type_UUID >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_UUID >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_FixedChar* Arena::CreateMaybeMessage< ::io::substrait::Type_FixedChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_FixedChar >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_FixedChar* Arena::CreateMaybeMessage< ::substrait::Type_FixedChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_FixedChar >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_VarChar* Arena::CreateMaybeMessage< ::io::substrait::Type_VarChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_VarChar >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_VarChar* Arena::CreateMaybeMessage< ::substrait::Type_VarChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_VarChar >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_FixedBinary* Arena::CreateMaybeMessage< ::io::substrait::Type_FixedBinary >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_FixedBinary >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_FixedBinary* Arena::CreateMaybeMessage< ::substrait::Type_FixedBinary >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_FixedBinary >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_Decimal* Arena::CreateMaybeMessage< ::io::substrait::Type_Decimal >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_Decimal >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_Decimal* Arena::CreateMaybeMessage< ::substrait::Type_Decimal >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_Decimal >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_Struct* Arena::CreateMaybeMessage< ::io::substrait::Type_Struct >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_Struct >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_Struct* Arena::CreateMaybeMessage< ::substrait::Type_Struct >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_Struct >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_List* Arena::CreateMaybeMessage< ::io::substrait::Type_List >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_List >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_List* Arena::CreateMaybeMessage< ::substrait::Type_List >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_List >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type_Map* Arena::CreateMaybeMessage< ::io::substrait::Type_Map >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type_Map >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type_Map* Arena::CreateMaybeMessage< ::substrait::Type_Map >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type_Map >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::Type* Arena::CreateMaybeMessage< ::io::substrait::Type >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::Type >(arena); +template<> PROTOBUF_NOINLINE ::substrait::Type* Arena::CreateMaybeMessage< ::substrait::Type >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::Type >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::NamedStruct* Arena::CreateMaybeMessage< ::io::substrait::NamedStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::NamedStruct >(arena); +template<> PROTOBUF_NOINLINE ::substrait::NamedStruct* Arena::CreateMaybeMessage< ::substrait::NamedStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::NamedStruct >(arena); } PROTOBUF_NAMESPACE_CLOSE diff --git a/cpp/src/generated/substrait/type.pb.h b/cpp/src/generated/substrait/type.pb.h index 660c45e7c38..9a144ebbf75 100644 --- a/cpp/src/generated/substrait/type.pb.h +++ b/cpp/src/generated/substrait/type.pb.h @@ -1,8 +1,8 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: type.proto +// source: substrait/type.proto -#ifndef GOOGLE_PROTOBUF_INCLUDED_type_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_type_2eproto +#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_2eproto #include #include @@ -34,7 +34,7 @@ #include // @@protoc_insertion_point(includes) #include -#define PROTOBUF_INTERNAL_EXPORT_type_2eproto +#define PROTOBUF_INTERNAL_EXPORT_substrait_2ftype_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; @@ -42,7 +42,7 @@ class AnyMetadata; PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. -struct TableStruct_type_2eproto { +struct TableStruct_substrait_2ftype_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] @@ -53,8 +53,7 @@ struct TableStruct_type_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; }; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_2eproto; -namespace io { +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_2eproto; namespace substrait { class NamedStruct; struct NamedStructDefaultTypeInternal; @@ -132,46 +131,45 @@ class Type_VarChar; struct Type_VarCharDefaultTypeInternal; extern Type_VarCharDefaultTypeInternal _Type_VarChar_default_instance_; } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::NamedStruct* Arena::CreateMaybeMessage<::io::substrait::NamedStruct>(Arena*); -template<> ::io::substrait::Type* Arena::CreateMaybeMessage<::io::substrait::Type>(Arena*); -template<> ::io::substrait::Type_Binary* Arena::CreateMaybeMessage<::io::substrait::Type_Binary>(Arena*); -template<> ::io::substrait::Type_Boolean* Arena::CreateMaybeMessage<::io::substrait::Type_Boolean>(Arena*); -template<> ::io::substrait::Type_Date* Arena::CreateMaybeMessage<::io::substrait::Type_Date>(Arena*); -template<> ::io::substrait::Type_Decimal* Arena::CreateMaybeMessage<::io::substrait::Type_Decimal>(Arena*); -template<> ::io::substrait::Type_FP32* Arena::CreateMaybeMessage<::io::substrait::Type_FP32>(Arena*); -template<> ::io::substrait::Type_FP64* Arena::CreateMaybeMessage<::io::substrait::Type_FP64>(Arena*); -template<> ::io::substrait::Type_FixedBinary* Arena::CreateMaybeMessage<::io::substrait::Type_FixedBinary>(Arena*); -template<> ::io::substrait::Type_FixedChar* Arena::CreateMaybeMessage<::io::substrait::Type_FixedChar>(Arena*); -template<> ::io::substrait::Type_I16* Arena::CreateMaybeMessage<::io::substrait::Type_I16>(Arena*); -template<> ::io::substrait::Type_I32* Arena::CreateMaybeMessage<::io::substrait::Type_I32>(Arena*); -template<> ::io::substrait::Type_I64* Arena::CreateMaybeMessage<::io::substrait::Type_I64>(Arena*); -template<> ::io::substrait::Type_I8* Arena::CreateMaybeMessage<::io::substrait::Type_I8>(Arena*); -template<> ::io::substrait::Type_IntervalDay* Arena::CreateMaybeMessage<::io::substrait::Type_IntervalDay>(Arena*); -template<> ::io::substrait::Type_IntervalYear* Arena::CreateMaybeMessage<::io::substrait::Type_IntervalYear>(Arena*); -template<> ::io::substrait::Type_List* Arena::CreateMaybeMessage<::io::substrait::Type_List>(Arena*); -template<> ::io::substrait::Type_Map* Arena::CreateMaybeMessage<::io::substrait::Type_Map>(Arena*); -template<> ::io::substrait::Type_String* Arena::CreateMaybeMessage<::io::substrait::Type_String>(Arena*); -template<> ::io::substrait::Type_Struct* Arena::CreateMaybeMessage<::io::substrait::Type_Struct>(Arena*); -template<> ::io::substrait::Type_Time* Arena::CreateMaybeMessage<::io::substrait::Type_Time>(Arena*); -template<> ::io::substrait::Type_Timestamp* Arena::CreateMaybeMessage<::io::substrait::Type_Timestamp>(Arena*); -template<> ::io::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage<::io::substrait::Type_TimestampTZ>(Arena*); -template<> ::io::substrait::Type_UUID* Arena::CreateMaybeMessage<::io::substrait::Type_UUID>(Arena*); -template<> ::io::substrait::Type_VarChar* Arena::CreateMaybeMessage<::io::substrait::Type_VarChar>(Arena*); +template<> ::substrait::NamedStruct* Arena::CreateMaybeMessage<::substrait::NamedStruct>(Arena*); +template<> ::substrait::Type* Arena::CreateMaybeMessage<::substrait::Type>(Arena*); +template<> ::substrait::Type_Binary* Arena::CreateMaybeMessage<::substrait::Type_Binary>(Arena*); +template<> ::substrait::Type_Boolean* Arena::CreateMaybeMessage<::substrait::Type_Boolean>(Arena*); +template<> ::substrait::Type_Date* Arena::CreateMaybeMessage<::substrait::Type_Date>(Arena*); +template<> ::substrait::Type_Decimal* Arena::CreateMaybeMessage<::substrait::Type_Decimal>(Arena*); +template<> ::substrait::Type_FP32* Arena::CreateMaybeMessage<::substrait::Type_FP32>(Arena*); +template<> ::substrait::Type_FP64* Arena::CreateMaybeMessage<::substrait::Type_FP64>(Arena*); +template<> ::substrait::Type_FixedBinary* Arena::CreateMaybeMessage<::substrait::Type_FixedBinary>(Arena*); +template<> ::substrait::Type_FixedChar* Arena::CreateMaybeMessage<::substrait::Type_FixedChar>(Arena*); +template<> ::substrait::Type_I16* Arena::CreateMaybeMessage<::substrait::Type_I16>(Arena*); +template<> ::substrait::Type_I32* Arena::CreateMaybeMessage<::substrait::Type_I32>(Arena*); +template<> ::substrait::Type_I64* Arena::CreateMaybeMessage<::substrait::Type_I64>(Arena*); +template<> ::substrait::Type_I8* Arena::CreateMaybeMessage<::substrait::Type_I8>(Arena*); +template<> ::substrait::Type_IntervalDay* Arena::CreateMaybeMessage<::substrait::Type_IntervalDay>(Arena*); +template<> ::substrait::Type_IntervalYear* Arena::CreateMaybeMessage<::substrait::Type_IntervalYear>(Arena*); +template<> ::substrait::Type_List* Arena::CreateMaybeMessage<::substrait::Type_List>(Arena*); +template<> ::substrait::Type_Map* Arena::CreateMaybeMessage<::substrait::Type_Map>(Arena*); +template<> ::substrait::Type_String* Arena::CreateMaybeMessage<::substrait::Type_String>(Arena*); +template<> ::substrait::Type_Struct* Arena::CreateMaybeMessage<::substrait::Type_Struct>(Arena*); +template<> ::substrait::Type_Time* Arena::CreateMaybeMessage<::substrait::Type_Time>(Arena*); +template<> ::substrait::Type_Timestamp* Arena::CreateMaybeMessage<::substrait::Type_Timestamp>(Arena*); +template<> ::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage<::substrait::Type_TimestampTZ>(Arena*); +template<> ::substrait::Type_UUID* Arena::CreateMaybeMessage<::substrait::Type_UUID>(Arena*); +template<> ::substrait::Type_VarChar* Arena::CreateMaybeMessage<::substrait::Type_VarChar>(Arena*); PROTOBUF_NAMESPACE_CLOSE -namespace io { namespace substrait { enum Type_Nullability : int { - Type_Nullability_NULLABLE = 0, - Type_Nullability_REQUIRED = 1, + Type_Nullability_NULLABILITY_UNSPECIFIED = 0, + Type_Nullability_NULLABILITY_NULLABLE = 1, + Type_Nullability_NULLABILITY_REQUIRED = 2, Type_Nullability_Type_Nullability_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), Type_Nullability_Type_Nullability_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; bool Type_Nullability_IsValid(int value); -constexpr Type_Nullability Type_Nullability_Nullability_MIN = Type_Nullability_NULLABLE; -constexpr Type_Nullability Type_Nullability_Nullability_MAX = Type_Nullability_REQUIRED; +constexpr Type_Nullability Type_Nullability_Nullability_MIN = Type_Nullability_NULLABILITY_UNSPECIFIED; +constexpr Type_Nullability Type_Nullability_Nullability_MAX = Type_Nullability_NULLABILITY_REQUIRED; constexpr int Type_Nullability_Nullability_ARRAYSIZE = Type_Nullability_Nullability_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_Nullability_descriptor(); @@ -191,7 +189,7 @@ inline bool Type_Nullability_Parse( // =================================================================== class Type_Boolean PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Boolean) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Boolean) */ { public: inline Type_Boolean() : Type_Boolean(nullptr) {} ~Type_Boolean() override; @@ -281,7 +279,7 @@ class Type_Boolean PROTOBUF_FINAL : void InternalSwap(Type_Boolean* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.Boolean"; + return "substrait.Type.Boolean"; } protected: explicit Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -309,16 +307,16 @@ class Type_Boolean PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.Boolean) + // @@protoc_insertion_point(class_scope:substrait.Type.Boolean) private: class _Internal; @@ -328,12 +326,12 @@ class Type_Boolean PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_I8 PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.I8) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I8) */ { public: inline Type_I8() : Type_I8(nullptr) {} ~Type_I8() override; @@ -423,7 +421,7 @@ class Type_I8 PROTOBUF_FINAL : void InternalSwap(Type_I8* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.I8"; + return "substrait.Type.I8"; } protected: explicit Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -451,16 +449,16 @@ class Type_I8 PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.I8) + // @@protoc_insertion_point(class_scope:substrait.Type.I8) private: class _Internal; @@ -470,12 +468,12 @@ class Type_I8 PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_I16 PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.I16) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I16) */ { public: inline Type_I16() : Type_I16(nullptr) {} ~Type_I16() override; @@ -565,7 +563,7 @@ class Type_I16 PROTOBUF_FINAL : void InternalSwap(Type_I16* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.I16"; + return "substrait.Type.I16"; } protected: explicit Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -593,16 +591,16 @@ class Type_I16 PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.I16) + // @@protoc_insertion_point(class_scope:substrait.Type.I16) private: class _Internal; @@ -612,12 +610,12 @@ class Type_I16 PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_I32 PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.I32) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I32) */ { public: inline Type_I32() : Type_I32(nullptr) {} ~Type_I32() override; @@ -707,7 +705,7 @@ class Type_I32 PROTOBUF_FINAL : void InternalSwap(Type_I32* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.I32"; + return "substrait.Type.I32"; } protected: explicit Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -735,16 +733,16 @@ class Type_I32 PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.I32) + // @@protoc_insertion_point(class_scope:substrait.Type.I32) private: class _Internal; @@ -754,12 +752,12 @@ class Type_I32 PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_I64 PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.I64) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I64) */ { public: inline Type_I64() : Type_I64(nullptr) {} ~Type_I64() override; @@ -849,7 +847,7 @@ class Type_I64 PROTOBUF_FINAL : void InternalSwap(Type_I64* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.I64"; + return "substrait.Type.I64"; } protected: explicit Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -877,16 +875,16 @@ class Type_I64 PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.I64) + // @@protoc_insertion_point(class_scope:substrait.Type.I64) private: class _Internal; @@ -896,12 +894,12 @@ class Type_I64 PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_FP32 PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.FP32) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FP32) */ { public: inline Type_FP32() : Type_FP32(nullptr) {} ~Type_FP32() override; @@ -991,7 +989,7 @@ class Type_FP32 PROTOBUF_FINAL : void InternalSwap(Type_FP32* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.FP32"; + return "substrait.Type.FP32"; } protected: explicit Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1019,16 +1017,16 @@ class Type_FP32 PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.FP32) + // @@protoc_insertion_point(class_scope:substrait.Type.FP32) private: class _Internal; @@ -1038,12 +1036,12 @@ class Type_FP32 PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_FP64 PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.FP64) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FP64) */ { public: inline Type_FP64() : Type_FP64(nullptr) {} ~Type_FP64() override; @@ -1133,7 +1131,7 @@ class Type_FP64 PROTOBUF_FINAL : void InternalSwap(Type_FP64* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.FP64"; + return "substrait.Type.FP64"; } protected: explicit Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1161,16 +1159,16 @@ class Type_FP64 PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.FP64) + // @@protoc_insertion_point(class_scope:substrait.Type.FP64) private: class _Internal; @@ -1180,12 +1178,12 @@ class Type_FP64 PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_String PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.String) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.String) */ { public: inline Type_String() : Type_String(nullptr) {} ~Type_String() override; @@ -1275,7 +1273,7 @@ class Type_String PROTOBUF_FINAL : void InternalSwap(Type_String* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.String"; + return "substrait.Type.String"; } protected: explicit Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1303,16 +1301,16 @@ class Type_String PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.String) + // @@protoc_insertion_point(class_scope:substrait.Type.String) private: class _Internal; @@ -1322,12 +1320,12 @@ class Type_String PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_Binary PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Binary) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Binary) */ { public: inline Type_Binary() : Type_Binary(nullptr) {} ~Type_Binary() override; @@ -1417,7 +1415,7 @@ class Type_Binary PROTOBUF_FINAL : void InternalSwap(Type_Binary* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.Binary"; + return "substrait.Type.Binary"; } protected: explicit Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1445,16 +1443,16 @@ class Type_Binary PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.Binary) + // @@protoc_insertion_point(class_scope:substrait.Type.Binary) private: class _Internal; @@ -1464,12 +1462,12 @@ class Type_Binary PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_Timestamp PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Timestamp) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Timestamp) */ { public: inline Type_Timestamp() : Type_Timestamp(nullptr) {} ~Type_Timestamp() override; @@ -1559,7 +1557,7 @@ class Type_Timestamp PROTOBUF_FINAL : void InternalSwap(Type_Timestamp* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.Timestamp"; + return "substrait.Type.Timestamp"; } protected: explicit Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1587,16 +1585,16 @@ class Type_Timestamp PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.Timestamp) + // @@protoc_insertion_point(class_scope:substrait.Type.Timestamp) private: class _Internal; @@ -1606,12 +1604,12 @@ class Type_Timestamp PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_Date PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Date) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Date) */ { public: inline Type_Date() : Type_Date(nullptr) {} ~Type_Date() override; @@ -1701,7 +1699,7 @@ class Type_Date PROTOBUF_FINAL : void InternalSwap(Type_Date* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.Date"; + return "substrait.Type.Date"; } protected: explicit Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1729,16 +1727,16 @@ class Type_Date PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.Date) + // @@protoc_insertion_point(class_scope:substrait.Type.Date) private: class _Internal; @@ -1748,12 +1746,12 @@ class Type_Date PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_Time PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Time) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Time) */ { public: inline Type_Time() : Type_Time(nullptr) {} ~Type_Time() override; @@ -1843,7 +1841,7 @@ class Type_Time PROTOBUF_FINAL : void InternalSwap(Type_Time* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.Time"; + return "substrait.Type.Time"; } protected: explicit Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1871,16 +1869,16 @@ class Type_Time PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.Time) + // @@protoc_insertion_point(class_scope:substrait.Type.Time) private: class _Internal; @@ -1890,12 +1888,12 @@ class Type_Time PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_TimestampTZ PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.TimestampTZ) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.TimestampTZ) */ { public: inline Type_TimestampTZ() : Type_TimestampTZ(nullptr) {} ~Type_TimestampTZ() override; @@ -1985,7 +1983,7 @@ class Type_TimestampTZ PROTOBUF_FINAL : void InternalSwap(Type_TimestampTZ* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.TimestampTZ"; + return "substrait.Type.TimestampTZ"; } protected: explicit Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2013,16 +2011,16 @@ class Type_TimestampTZ PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.TimestampTZ) + // @@protoc_insertion_point(class_scope:substrait.Type.TimestampTZ) private: class _Internal; @@ -2032,12 +2030,12 @@ class Type_TimestampTZ PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_IntervalYear PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.IntervalYear) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.IntervalYear) */ { public: inline Type_IntervalYear() : Type_IntervalYear(nullptr) {} ~Type_IntervalYear() override; @@ -2127,7 +2125,7 @@ class Type_IntervalYear PROTOBUF_FINAL : void InternalSwap(Type_IntervalYear* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.IntervalYear"; + return "substrait.Type.IntervalYear"; } protected: explicit Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2155,16 +2153,16 @@ class Type_IntervalYear PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.IntervalYear) + // @@protoc_insertion_point(class_scope:substrait.Type.IntervalYear) private: class _Internal; @@ -2174,12 +2172,12 @@ class Type_IntervalYear PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_IntervalDay PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.IntervalDay) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.IntervalDay) */ { public: inline Type_IntervalDay() : Type_IntervalDay(nullptr) {} ~Type_IntervalDay() override; @@ -2269,7 +2267,7 @@ class Type_IntervalDay PROTOBUF_FINAL : void InternalSwap(Type_IntervalDay* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.IntervalDay"; + return "substrait.Type.IntervalDay"; } protected: explicit Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2297,16 +2295,16 @@ class Type_IntervalDay PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.IntervalDay) + // @@protoc_insertion_point(class_scope:substrait.Type.IntervalDay) private: class _Internal; @@ -2316,12 +2314,12 @@ class Type_IntervalDay PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_UUID PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.UUID) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.UUID) */ { public: inline Type_UUID() : Type_UUID(nullptr) {} ~Type_UUID() override; @@ -2411,7 +2409,7 @@ class Type_UUID PROTOBUF_FINAL : void InternalSwap(Type_UUID* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.UUID"; + return "substrait.Type.UUID"; } protected: explicit Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2439,16 +2437,16 @@ class Type_UUID PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 2; + // .substrait.Type.Nullability nullability = 2; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.UUID) + // @@protoc_insertion_point(class_scope:substrait.Type.UUID) private: class _Internal; @@ -2458,12 +2456,12 @@ class Type_UUID PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_FixedChar PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.FixedChar) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FixedChar) */ { public: inline Type_FixedChar() : Type_FixedChar(nullptr) {} ~Type_FixedChar() override; @@ -2553,7 +2551,7 @@ class Type_FixedChar PROTOBUF_FINAL : void InternalSwap(Type_FixedChar* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.FixedChar"; + return "substrait.Type.FixedChar"; } protected: explicit Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2591,16 +2589,16 @@ class Type_FixedChar PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.FixedChar) + // @@protoc_insertion_point(class_scope:substrait.Type.FixedChar) private: class _Internal; @@ -2611,12 +2609,12 @@ class Type_FixedChar PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_VarChar PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.VarChar) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.VarChar) */ { public: inline Type_VarChar() : Type_VarChar(nullptr) {} ~Type_VarChar() override; @@ -2706,7 +2704,7 @@ class Type_VarChar PROTOBUF_FINAL : void InternalSwap(Type_VarChar* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.VarChar"; + return "substrait.Type.VarChar"; } protected: explicit Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2744,16 +2742,16 @@ class Type_VarChar PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.VarChar) + // @@protoc_insertion_point(class_scope:substrait.Type.VarChar) private: class _Internal; @@ -2764,12 +2762,12 @@ class Type_VarChar PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_FixedBinary PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.FixedBinary) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FixedBinary) */ { public: inline Type_FixedBinary() : Type_FixedBinary(nullptr) {} ~Type_FixedBinary() override; @@ -2859,7 +2857,7 @@ class Type_FixedBinary PROTOBUF_FINAL : void InternalSwap(Type_FixedBinary* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.FixedBinary"; + return "substrait.Type.FixedBinary"; } protected: explicit Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2897,16 +2895,16 @@ class Type_FixedBinary PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.FixedBinary) + // @@protoc_insertion_point(class_scope:substrait.Type.FixedBinary) private: class _Internal; @@ -2917,12 +2915,12 @@ class Type_FixedBinary PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_Decimal PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Decimal) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Decimal) */ { public: inline Type_Decimal() : Type_Decimal(nullptr) {} ~Type_Decimal() override; @@ -3012,7 +3010,7 @@ class Type_Decimal PROTOBUF_FINAL : void InternalSwap(Type_Decimal* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.Decimal"; + return "substrait.Type.Decimal"; } protected: explicit Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3060,16 +3058,16 @@ class Type_Decimal PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.Decimal) + // @@protoc_insertion_point(class_scope:substrait.Type.Decimal) private: class _Internal; @@ -3081,12 +3079,12 @@ class Type_Decimal PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_Struct PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Struct) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Struct) */ { public: inline Type_Struct() : Type_Struct(nullptr) {} ~Type_Struct() override; @@ -3176,7 +3174,7 @@ class Type_Struct PROTOBUF_FINAL : void InternalSwap(Type_Struct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.Struct"; + return "substrait.Type.Struct"; } protected: explicit Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3196,22 +3194,22 @@ class Type_Struct PROTOBUF_FINAL : kTypeVariationReferenceFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // repeated .io.substrait.Type types = 1; + // repeated .substrait.Type types = 1; int types_size() const; private: int _internal_types_size() const; public: void clear_types(); - ::io::substrait::Type* mutable_types(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type >* + ::substrait::Type* mutable_types(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >* mutable_types(); private: - const ::io::substrait::Type& _internal_types(int index) const; - ::io::substrait::Type* _internal_add_types(); + const ::substrait::Type& _internal_types(int index) const; + ::substrait::Type* _internal_add_types(); public: - const ::io::substrait::Type& types(int index) const; - ::io::substrait::Type* add_types(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type >& + const ::substrait::Type& types(int index) const; + ::substrait::Type* add_types(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >& types() const; // uint32 type_variation_reference = 2; @@ -3223,32 +3221,32 @@ class Type_Struct PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.Struct) + // @@protoc_insertion_point(class_scope:substrait.Type.Struct) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type > types_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type > types_; ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_List PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.List) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.List) */ { public: inline Type_List() : Type_List(nullptr) {} ~Type_List() override; @@ -3338,7 +3336,7 @@ class Type_List PROTOBUF_FINAL : void InternalSwap(Type_List* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.List"; + return "substrait.Type.List"; } protected: explicit Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3358,23 +3356,23 @@ class Type_List PROTOBUF_FINAL : kTypeVariationReferenceFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.Type type = 1; + // .substrait.Type type = 1; bool has_type() const; private: bool _internal_has_type() const; public: void clear_type(); - const ::io::substrait::Type& type() const; - ::io::substrait::Type* release_type(); - ::io::substrait::Type* mutable_type(); - void set_allocated_type(::io::substrait::Type* type); + const ::substrait::Type& type() const; + ::substrait::Type* release_type(); + ::substrait::Type* mutable_type(); + void set_allocated_type(::substrait::Type* type); private: - const ::io::substrait::Type& _internal_type() const; - ::io::substrait::Type* _internal_mutable_type(); + const ::substrait::Type& _internal_type() const; + ::substrait::Type* _internal_mutable_type(); public: void unsafe_arena_set_allocated_type( - ::io::substrait::Type* type); - ::io::substrait::Type* unsafe_arena_release_type(); + ::substrait::Type* type); + ::substrait::Type* unsafe_arena_release_type(); // uint32 type_variation_reference = 2; void clear_type_variation_reference(); @@ -3385,32 +3383,32 @@ class Type_List PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.List) + // @@protoc_insertion_point(class_scope:substrait.Type.List) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type* type_; + ::substrait::Type* type_; ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type_Map PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type.Map) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Map) */ { public: inline Type_Map() : Type_Map(nullptr) {} ~Type_Map() override; @@ -3500,7 +3498,7 @@ class Type_Map PROTOBUF_FINAL : void InternalSwap(Type_Map* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type.Map"; + return "substrait.Type.Map"; } protected: explicit Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3521,41 +3519,41 @@ class Type_Map PROTOBUF_FINAL : kTypeVariationReferenceFieldNumber = 3, kNullabilityFieldNumber = 4, }; - // .io.substrait.Type key = 1; + // .substrait.Type key = 1; bool has_key() const; private: bool _internal_has_key() const; public: void clear_key(); - const ::io::substrait::Type& key() const; - ::io::substrait::Type* release_key(); - ::io::substrait::Type* mutable_key(); - void set_allocated_key(::io::substrait::Type* key); + const ::substrait::Type& key() const; + ::substrait::Type* release_key(); + ::substrait::Type* mutable_key(); + void set_allocated_key(::substrait::Type* key); private: - const ::io::substrait::Type& _internal_key() const; - ::io::substrait::Type* _internal_mutable_key(); + const ::substrait::Type& _internal_key() const; + ::substrait::Type* _internal_mutable_key(); public: void unsafe_arena_set_allocated_key( - ::io::substrait::Type* key); - ::io::substrait::Type* unsafe_arena_release_key(); + ::substrait::Type* key); + ::substrait::Type* unsafe_arena_release_key(); - // .io.substrait.Type value = 2; + // .substrait.Type value = 2; bool has_value() const; private: bool _internal_has_value() const; public: void clear_value(); - const ::io::substrait::Type& value() const; - ::io::substrait::Type* release_value(); - ::io::substrait::Type* mutable_value(); - void set_allocated_value(::io::substrait::Type* value); + const ::substrait::Type& value() const; + ::substrait::Type* release_value(); + ::substrait::Type* mutable_value(); + void set_allocated_value(::substrait::Type* value); private: - const ::io::substrait::Type& _internal_value() const; - ::io::substrait::Type* _internal_mutable_value(); + const ::substrait::Type& _internal_value() const; + ::substrait::Type* _internal_mutable_value(); public: void unsafe_arena_set_allocated_value( - ::io::substrait::Type* value); - ::io::substrait::Type* unsafe_arena_release_value(); + ::substrait::Type* value); + ::substrait::Type* unsafe_arena_release_value(); // uint32 type_variation_reference = 3; void clear_type_variation_reference(); @@ -3566,33 +3564,33 @@ class Type_Map PROTOBUF_FINAL : void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.Type.Map) + // @@protoc_insertion_point(class_scope:substrait.Type.Map) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::Type* key_; - ::io::substrait::Type* value_; + ::substrait::Type* key_; + ::substrait::Type* value_; ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class Type PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.Type) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type) */ { public: inline Type() : Type(nullptr) {} ~Type() override; @@ -3710,7 +3708,7 @@ class Type PROTOBUF_FINAL : void InternalSwap(Type* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.Type"; + return "substrait.Type"; } protected: explicit Type(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -3748,10 +3746,12 @@ class Type PROTOBUF_FINAL : typedef Type_Map Map; typedef Type_Nullability Nullability; - static constexpr Nullability NULLABLE = - Type_Nullability_NULLABLE; - static constexpr Nullability REQUIRED = - Type_Nullability_REQUIRED; + static constexpr Nullability NULLABILITY_UNSPECIFIED = + Type_Nullability_NULLABILITY_UNSPECIFIED; + static constexpr Nullability NULLABILITY_NULLABLE = + Type_Nullability_NULLABILITY_NULLABLE; + static constexpr Nullability NULLABILITY_REQUIRED = + Type_Nullability_NULLABILITY_REQUIRED; static inline bool Nullability_IsValid(int value) { return Type_Nullability_IsValid(value); } @@ -3805,419 +3805,419 @@ class Type PROTOBUF_FINAL : kMapFieldNumber = 28, kUserDefinedTypeReferenceFieldNumber = 31, }; - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; bool has_bool_() const; private: bool _internal_has_bool_() const; public: void clear_bool_(); - const ::io::substrait::Type_Boolean& bool_() const; - ::io::substrait::Type_Boolean* release_bool_(); - ::io::substrait::Type_Boolean* mutable_bool_(); - void set_allocated_bool_(::io::substrait::Type_Boolean* bool_); + const ::substrait::Type_Boolean& bool_() const; + ::substrait::Type_Boolean* release_bool_(); + ::substrait::Type_Boolean* mutable_bool_(); + void set_allocated_bool_(::substrait::Type_Boolean* bool_); private: - const ::io::substrait::Type_Boolean& _internal_bool_() const; - ::io::substrait::Type_Boolean* _internal_mutable_bool_(); + const ::substrait::Type_Boolean& _internal_bool_() const; + ::substrait::Type_Boolean* _internal_mutable_bool_(); public: void unsafe_arena_set_allocated_bool_( - ::io::substrait::Type_Boolean* bool_); - ::io::substrait::Type_Boolean* unsafe_arena_release_bool_(); + ::substrait::Type_Boolean* bool_); + ::substrait::Type_Boolean* unsafe_arena_release_bool_(); - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; bool has_i8() const; private: bool _internal_has_i8() const; public: void clear_i8(); - const ::io::substrait::Type_I8& i8() const; - ::io::substrait::Type_I8* release_i8(); - ::io::substrait::Type_I8* mutable_i8(); - void set_allocated_i8(::io::substrait::Type_I8* i8); + const ::substrait::Type_I8& i8() const; + ::substrait::Type_I8* release_i8(); + ::substrait::Type_I8* mutable_i8(); + void set_allocated_i8(::substrait::Type_I8* i8); private: - const ::io::substrait::Type_I8& _internal_i8() const; - ::io::substrait::Type_I8* _internal_mutable_i8(); + const ::substrait::Type_I8& _internal_i8() const; + ::substrait::Type_I8* _internal_mutable_i8(); public: void unsafe_arena_set_allocated_i8( - ::io::substrait::Type_I8* i8); - ::io::substrait::Type_I8* unsafe_arena_release_i8(); + ::substrait::Type_I8* i8); + ::substrait::Type_I8* unsafe_arena_release_i8(); - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; bool has_i16() const; private: bool _internal_has_i16() const; public: void clear_i16(); - const ::io::substrait::Type_I16& i16() const; - ::io::substrait::Type_I16* release_i16(); - ::io::substrait::Type_I16* mutable_i16(); - void set_allocated_i16(::io::substrait::Type_I16* i16); + const ::substrait::Type_I16& i16() const; + ::substrait::Type_I16* release_i16(); + ::substrait::Type_I16* mutable_i16(); + void set_allocated_i16(::substrait::Type_I16* i16); private: - const ::io::substrait::Type_I16& _internal_i16() const; - ::io::substrait::Type_I16* _internal_mutable_i16(); + const ::substrait::Type_I16& _internal_i16() const; + ::substrait::Type_I16* _internal_mutable_i16(); public: void unsafe_arena_set_allocated_i16( - ::io::substrait::Type_I16* i16); - ::io::substrait::Type_I16* unsafe_arena_release_i16(); + ::substrait::Type_I16* i16); + ::substrait::Type_I16* unsafe_arena_release_i16(); - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; bool has_i32() const; private: bool _internal_has_i32() const; public: void clear_i32(); - const ::io::substrait::Type_I32& i32() const; - ::io::substrait::Type_I32* release_i32(); - ::io::substrait::Type_I32* mutable_i32(); - void set_allocated_i32(::io::substrait::Type_I32* i32); + const ::substrait::Type_I32& i32() const; + ::substrait::Type_I32* release_i32(); + ::substrait::Type_I32* mutable_i32(); + void set_allocated_i32(::substrait::Type_I32* i32); private: - const ::io::substrait::Type_I32& _internal_i32() const; - ::io::substrait::Type_I32* _internal_mutable_i32(); + const ::substrait::Type_I32& _internal_i32() const; + ::substrait::Type_I32* _internal_mutable_i32(); public: void unsafe_arena_set_allocated_i32( - ::io::substrait::Type_I32* i32); - ::io::substrait::Type_I32* unsafe_arena_release_i32(); + ::substrait::Type_I32* i32); + ::substrait::Type_I32* unsafe_arena_release_i32(); - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; bool has_i64() const; private: bool _internal_has_i64() const; public: void clear_i64(); - const ::io::substrait::Type_I64& i64() const; - ::io::substrait::Type_I64* release_i64(); - ::io::substrait::Type_I64* mutable_i64(); - void set_allocated_i64(::io::substrait::Type_I64* i64); + const ::substrait::Type_I64& i64() const; + ::substrait::Type_I64* release_i64(); + ::substrait::Type_I64* mutable_i64(); + void set_allocated_i64(::substrait::Type_I64* i64); private: - const ::io::substrait::Type_I64& _internal_i64() const; - ::io::substrait::Type_I64* _internal_mutable_i64(); + const ::substrait::Type_I64& _internal_i64() const; + ::substrait::Type_I64* _internal_mutable_i64(); public: void unsafe_arena_set_allocated_i64( - ::io::substrait::Type_I64* i64); - ::io::substrait::Type_I64* unsafe_arena_release_i64(); + ::substrait::Type_I64* i64); + ::substrait::Type_I64* unsafe_arena_release_i64(); - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; bool has_fp32() const; private: bool _internal_has_fp32() const; public: void clear_fp32(); - const ::io::substrait::Type_FP32& fp32() const; - ::io::substrait::Type_FP32* release_fp32(); - ::io::substrait::Type_FP32* mutable_fp32(); - void set_allocated_fp32(::io::substrait::Type_FP32* fp32); + const ::substrait::Type_FP32& fp32() const; + ::substrait::Type_FP32* release_fp32(); + ::substrait::Type_FP32* mutable_fp32(); + void set_allocated_fp32(::substrait::Type_FP32* fp32); private: - const ::io::substrait::Type_FP32& _internal_fp32() const; - ::io::substrait::Type_FP32* _internal_mutable_fp32(); + const ::substrait::Type_FP32& _internal_fp32() const; + ::substrait::Type_FP32* _internal_mutable_fp32(); public: void unsafe_arena_set_allocated_fp32( - ::io::substrait::Type_FP32* fp32); - ::io::substrait::Type_FP32* unsafe_arena_release_fp32(); + ::substrait::Type_FP32* fp32); + ::substrait::Type_FP32* unsafe_arena_release_fp32(); - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; bool has_fp64() const; private: bool _internal_has_fp64() const; public: void clear_fp64(); - const ::io::substrait::Type_FP64& fp64() const; - ::io::substrait::Type_FP64* release_fp64(); - ::io::substrait::Type_FP64* mutable_fp64(); - void set_allocated_fp64(::io::substrait::Type_FP64* fp64); + const ::substrait::Type_FP64& fp64() const; + ::substrait::Type_FP64* release_fp64(); + ::substrait::Type_FP64* mutable_fp64(); + void set_allocated_fp64(::substrait::Type_FP64* fp64); private: - const ::io::substrait::Type_FP64& _internal_fp64() const; - ::io::substrait::Type_FP64* _internal_mutable_fp64(); + const ::substrait::Type_FP64& _internal_fp64() const; + ::substrait::Type_FP64* _internal_mutable_fp64(); public: void unsafe_arena_set_allocated_fp64( - ::io::substrait::Type_FP64* fp64); - ::io::substrait::Type_FP64* unsafe_arena_release_fp64(); + ::substrait::Type_FP64* fp64); + ::substrait::Type_FP64* unsafe_arena_release_fp64(); - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; bool has_string() const; private: bool _internal_has_string() const; public: void clear_string(); - const ::io::substrait::Type_String& string() const; - ::io::substrait::Type_String* release_string(); - ::io::substrait::Type_String* mutable_string(); - void set_allocated_string(::io::substrait::Type_String* string); + const ::substrait::Type_String& string() const; + ::substrait::Type_String* release_string(); + ::substrait::Type_String* mutable_string(); + void set_allocated_string(::substrait::Type_String* string); private: - const ::io::substrait::Type_String& _internal_string() const; - ::io::substrait::Type_String* _internal_mutable_string(); + const ::substrait::Type_String& _internal_string() const; + ::substrait::Type_String* _internal_mutable_string(); public: void unsafe_arena_set_allocated_string( - ::io::substrait::Type_String* string); - ::io::substrait::Type_String* unsafe_arena_release_string(); + ::substrait::Type_String* string); + ::substrait::Type_String* unsafe_arena_release_string(); - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; bool has_binary() const; private: bool _internal_has_binary() const; public: void clear_binary(); - const ::io::substrait::Type_Binary& binary() const; - ::io::substrait::Type_Binary* release_binary(); - ::io::substrait::Type_Binary* mutable_binary(); - void set_allocated_binary(::io::substrait::Type_Binary* binary); + const ::substrait::Type_Binary& binary() const; + ::substrait::Type_Binary* release_binary(); + ::substrait::Type_Binary* mutable_binary(); + void set_allocated_binary(::substrait::Type_Binary* binary); private: - const ::io::substrait::Type_Binary& _internal_binary() const; - ::io::substrait::Type_Binary* _internal_mutable_binary(); + const ::substrait::Type_Binary& _internal_binary() const; + ::substrait::Type_Binary* _internal_mutable_binary(); public: void unsafe_arena_set_allocated_binary( - ::io::substrait::Type_Binary* binary); - ::io::substrait::Type_Binary* unsafe_arena_release_binary(); + ::substrait::Type_Binary* binary); + ::substrait::Type_Binary* unsafe_arena_release_binary(); - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; bool has_timestamp() const; private: bool _internal_has_timestamp() const; public: void clear_timestamp(); - const ::io::substrait::Type_Timestamp& timestamp() const; - ::io::substrait::Type_Timestamp* release_timestamp(); - ::io::substrait::Type_Timestamp* mutable_timestamp(); - void set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp); + const ::substrait::Type_Timestamp& timestamp() const; + ::substrait::Type_Timestamp* release_timestamp(); + ::substrait::Type_Timestamp* mutable_timestamp(); + void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp); private: - const ::io::substrait::Type_Timestamp& _internal_timestamp() const; - ::io::substrait::Type_Timestamp* _internal_mutable_timestamp(); + const ::substrait::Type_Timestamp& _internal_timestamp() const; + ::substrait::Type_Timestamp* _internal_mutable_timestamp(); public: void unsafe_arena_set_allocated_timestamp( - ::io::substrait::Type_Timestamp* timestamp); - ::io::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); + ::substrait::Type_Timestamp* timestamp); + ::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; bool has_date() const; private: bool _internal_has_date() const; public: void clear_date(); - const ::io::substrait::Type_Date& date() const; - ::io::substrait::Type_Date* release_date(); - ::io::substrait::Type_Date* mutable_date(); - void set_allocated_date(::io::substrait::Type_Date* date); + const ::substrait::Type_Date& date() const; + ::substrait::Type_Date* release_date(); + ::substrait::Type_Date* mutable_date(); + void set_allocated_date(::substrait::Type_Date* date); private: - const ::io::substrait::Type_Date& _internal_date() const; - ::io::substrait::Type_Date* _internal_mutable_date(); + const ::substrait::Type_Date& _internal_date() const; + ::substrait::Type_Date* _internal_mutable_date(); public: void unsafe_arena_set_allocated_date( - ::io::substrait::Type_Date* date); - ::io::substrait::Type_Date* unsafe_arena_release_date(); + ::substrait::Type_Date* date); + ::substrait::Type_Date* unsafe_arena_release_date(); - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; bool has_time() const; private: bool _internal_has_time() const; public: void clear_time(); - const ::io::substrait::Type_Time& time() const; - ::io::substrait::Type_Time* release_time(); - ::io::substrait::Type_Time* mutable_time(); - void set_allocated_time(::io::substrait::Type_Time* time); + const ::substrait::Type_Time& time() const; + ::substrait::Type_Time* release_time(); + ::substrait::Type_Time* mutable_time(); + void set_allocated_time(::substrait::Type_Time* time); private: - const ::io::substrait::Type_Time& _internal_time() const; - ::io::substrait::Type_Time* _internal_mutable_time(); + const ::substrait::Type_Time& _internal_time() const; + ::substrait::Type_Time* _internal_mutable_time(); public: void unsafe_arena_set_allocated_time( - ::io::substrait::Type_Time* time); - ::io::substrait::Type_Time* unsafe_arena_release_time(); + ::substrait::Type_Time* time); + ::substrait::Type_Time* unsafe_arena_release_time(); - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; bool has_interval_year() const; private: bool _internal_has_interval_year() const; public: void clear_interval_year(); - const ::io::substrait::Type_IntervalYear& interval_year() const; - ::io::substrait::Type_IntervalYear* release_interval_year(); - ::io::substrait::Type_IntervalYear* mutable_interval_year(); - void set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year); + const ::substrait::Type_IntervalYear& interval_year() const; + ::substrait::Type_IntervalYear* release_interval_year(); + ::substrait::Type_IntervalYear* mutable_interval_year(); + void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year); private: - const ::io::substrait::Type_IntervalYear& _internal_interval_year() const; - ::io::substrait::Type_IntervalYear* _internal_mutable_interval_year(); + const ::substrait::Type_IntervalYear& _internal_interval_year() const; + ::substrait::Type_IntervalYear* _internal_mutable_interval_year(); public: void unsafe_arena_set_allocated_interval_year( - ::io::substrait::Type_IntervalYear* interval_year); - ::io::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); + ::substrait::Type_IntervalYear* interval_year); + ::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; bool has_interval_day() const; private: bool _internal_has_interval_day() const; public: void clear_interval_day(); - const ::io::substrait::Type_IntervalDay& interval_day() const; - ::io::substrait::Type_IntervalDay* release_interval_day(); - ::io::substrait::Type_IntervalDay* mutable_interval_day(); - void set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day); + const ::substrait::Type_IntervalDay& interval_day() const; + ::substrait::Type_IntervalDay* release_interval_day(); + ::substrait::Type_IntervalDay* mutable_interval_day(); + void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day); private: - const ::io::substrait::Type_IntervalDay& _internal_interval_day() const; - ::io::substrait::Type_IntervalDay* _internal_mutable_interval_day(); + const ::substrait::Type_IntervalDay& _internal_interval_day() const; + ::substrait::Type_IntervalDay* _internal_mutable_interval_day(); public: void unsafe_arena_set_allocated_interval_day( - ::io::substrait::Type_IntervalDay* interval_day); - ::io::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); + ::substrait::Type_IntervalDay* interval_day); + ::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; bool has_timestamp_tz() const; private: bool _internal_has_timestamp_tz() const; public: void clear_timestamp_tz(); - const ::io::substrait::Type_TimestampTZ& timestamp_tz() const; - ::io::substrait::Type_TimestampTZ* release_timestamp_tz(); - ::io::substrait::Type_TimestampTZ* mutable_timestamp_tz(); - void set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz); + const ::substrait::Type_TimestampTZ& timestamp_tz() const; + ::substrait::Type_TimestampTZ* release_timestamp_tz(); + ::substrait::Type_TimestampTZ* mutable_timestamp_tz(); + void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz); private: - const ::io::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; - ::io::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); + const ::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; + ::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); public: void unsafe_arena_set_allocated_timestamp_tz( - ::io::substrait::Type_TimestampTZ* timestamp_tz); - ::io::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); + ::substrait::Type_TimestampTZ* timestamp_tz); + ::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; bool has_uuid() const; private: bool _internal_has_uuid() const; public: void clear_uuid(); - const ::io::substrait::Type_UUID& uuid() const; - ::io::substrait::Type_UUID* release_uuid(); - ::io::substrait::Type_UUID* mutable_uuid(); - void set_allocated_uuid(::io::substrait::Type_UUID* uuid); + const ::substrait::Type_UUID& uuid() const; + ::substrait::Type_UUID* release_uuid(); + ::substrait::Type_UUID* mutable_uuid(); + void set_allocated_uuid(::substrait::Type_UUID* uuid); private: - const ::io::substrait::Type_UUID& _internal_uuid() const; - ::io::substrait::Type_UUID* _internal_mutable_uuid(); + const ::substrait::Type_UUID& _internal_uuid() const; + ::substrait::Type_UUID* _internal_mutable_uuid(); public: void unsafe_arena_set_allocated_uuid( - ::io::substrait::Type_UUID* uuid); - ::io::substrait::Type_UUID* unsafe_arena_release_uuid(); + ::substrait::Type_UUID* uuid); + ::substrait::Type_UUID* unsafe_arena_release_uuid(); - // .io.substrait.Type.FixedChar fixed_char = 21; + // .substrait.Type.FixedChar fixed_char = 21; bool has_fixed_char() const; private: bool _internal_has_fixed_char() const; public: void clear_fixed_char(); - const ::io::substrait::Type_FixedChar& fixed_char() const; - ::io::substrait::Type_FixedChar* release_fixed_char(); - ::io::substrait::Type_FixedChar* mutable_fixed_char(); - void set_allocated_fixed_char(::io::substrait::Type_FixedChar* fixed_char); + const ::substrait::Type_FixedChar& fixed_char() const; + ::substrait::Type_FixedChar* release_fixed_char(); + ::substrait::Type_FixedChar* mutable_fixed_char(); + void set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char); private: - const ::io::substrait::Type_FixedChar& _internal_fixed_char() const; - ::io::substrait::Type_FixedChar* _internal_mutable_fixed_char(); + const ::substrait::Type_FixedChar& _internal_fixed_char() const; + ::substrait::Type_FixedChar* _internal_mutable_fixed_char(); public: void unsafe_arena_set_allocated_fixed_char( - ::io::substrait::Type_FixedChar* fixed_char); - ::io::substrait::Type_FixedChar* unsafe_arena_release_fixed_char(); + ::substrait::Type_FixedChar* fixed_char); + ::substrait::Type_FixedChar* unsafe_arena_release_fixed_char(); - // .io.substrait.Type.VarChar varchar = 22; + // .substrait.Type.VarChar varchar = 22; bool has_varchar() const; private: bool _internal_has_varchar() const; public: void clear_varchar(); - const ::io::substrait::Type_VarChar& varchar() const; - ::io::substrait::Type_VarChar* release_varchar(); - ::io::substrait::Type_VarChar* mutable_varchar(); - void set_allocated_varchar(::io::substrait::Type_VarChar* varchar); + const ::substrait::Type_VarChar& varchar() const; + ::substrait::Type_VarChar* release_varchar(); + ::substrait::Type_VarChar* mutable_varchar(); + void set_allocated_varchar(::substrait::Type_VarChar* varchar); private: - const ::io::substrait::Type_VarChar& _internal_varchar() const; - ::io::substrait::Type_VarChar* _internal_mutable_varchar(); + const ::substrait::Type_VarChar& _internal_varchar() const; + ::substrait::Type_VarChar* _internal_mutable_varchar(); public: void unsafe_arena_set_allocated_varchar( - ::io::substrait::Type_VarChar* varchar); - ::io::substrait::Type_VarChar* unsafe_arena_release_varchar(); + ::substrait::Type_VarChar* varchar); + ::substrait::Type_VarChar* unsafe_arena_release_varchar(); - // .io.substrait.Type.FixedBinary fixed_binary = 23; + // .substrait.Type.FixedBinary fixed_binary = 23; bool has_fixed_binary() const; private: bool _internal_has_fixed_binary() const; public: void clear_fixed_binary(); - const ::io::substrait::Type_FixedBinary& fixed_binary() const; - ::io::substrait::Type_FixedBinary* release_fixed_binary(); - ::io::substrait::Type_FixedBinary* mutable_fixed_binary(); - void set_allocated_fixed_binary(::io::substrait::Type_FixedBinary* fixed_binary); + const ::substrait::Type_FixedBinary& fixed_binary() const; + ::substrait::Type_FixedBinary* release_fixed_binary(); + ::substrait::Type_FixedBinary* mutable_fixed_binary(); + void set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary); private: - const ::io::substrait::Type_FixedBinary& _internal_fixed_binary() const; - ::io::substrait::Type_FixedBinary* _internal_mutable_fixed_binary(); + const ::substrait::Type_FixedBinary& _internal_fixed_binary() const; + ::substrait::Type_FixedBinary* _internal_mutable_fixed_binary(); public: void unsafe_arena_set_allocated_fixed_binary( - ::io::substrait::Type_FixedBinary* fixed_binary); - ::io::substrait::Type_FixedBinary* unsafe_arena_release_fixed_binary(); + ::substrait::Type_FixedBinary* fixed_binary); + ::substrait::Type_FixedBinary* unsafe_arena_release_fixed_binary(); - // .io.substrait.Type.Decimal decimal = 24; + // .substrait.Type.Decimal decimal = 24; bool has_decimal() const; private: bool _internal_has_decimal() const; public: void clear_decimal(); - const ::io::substrait::Type_Decimal& decimal() const; - ::io::substrait::Type_Decimal* release_decimal(); - ::io::substrait::Type_Decimal* mutable_decimal(); - void set_allocated_decimal(::io::substrait::Type_Decimal* decimal); + const ::substrait::Type_Decimal& decimal() const; + ::substrait::Type_Decimal* release_decimal(); + ::substrait::Type_Decimal* mutable_decimal(); + void set_allocated_decimal(::substrait::Type_Decimal* decimal); private: - const ::io::substrait::Type_Decimal& _internal_decimal() const; - ::io::substrait::Type_Decimal* _internal_mutable_decimal(); + const ::substrait::Type_Decimal& _internal_decimal() const; + ::substrait::Type_Decimal* _internal_mutable_decimal(); public: void unsafe_arena_set_allocated_decimal( - ::io::substrait::Type_Decimal* decimal); - ::io::substrait::Type_Decimal* unsafe_arena_release_decimal(); + ::substrait::Type_Decimal* decimal); + ::substrait::Type_Decimal* unsafe_arena_release_decimal(); - // .io.substrait.Type.Struct struct = 25; + // .substrait.Type.Struct struct = 25; bool has_struct_() const; private: bool _internal_has_struct_() const; public: void clear_struct_(); - const ::io::substrait::Type_Struct& struct_() const; - ::io::substrait::Type_Struct* release_struct_(); - ::io::substrait::Type_Struct* mutable_struct_(); - void set_allocated_struct_(::io::substrait::Type_Struct* struct_); + const ::substrait::Type_Struct& struct_() const; + ::substrait::Type_Struct* release_struct_(); + ::substrait::Type_Struct* mutable_struct_(); + void set_allocated_struct_(::substrait::Type_Struct* struct_); private: - const ::io::substrait::Type_Struct& _internal_struct_() const; - ::io::substrait::Type_Struct* _internal_mutable_struct_(); + const ::substrait::Type_Struct& _internal_struct_() const; + ::substrait::Type_Struct* _internal_mutable_struct_(); public: void unsafe_arena_set_allocated_struct_( - ::io::substrait::Type_Struct* struct_); - ::io::substrait::Type_Struct* unsafe_arena_release_struct_(); + ::substrait::Type_Struct* struct_); + ::substrait::Type_Struct* unsafe_arena_release_struct_(); - // .io.substrait.Type.List list = 27; + // .substrait.Type.List list = 27; bool has_list() const; private: bool _internal_has_list() const; public: void clear_list(); - const ::io::substrait::Type_List& list() const; - ::io::substrait::Type_List* release_list(); - ::io::substrait::Type_List* mutable_list(); - void set_allocated_list(::io::substrait::Type_List* list); + const ::substrait::Type_List& list() const; + ::substrait::Type_List* release_list(); + ::substrait::Type_List* mutable_list(); + void set_allocated_list(::substrait::Type_List* list); private: - const ::io::substrait::Type_List& _internal_list() const; - ::io::substrait::Type_List* _internal_mutable_list(); + const ::substrait::Type_List& _internal_list() const; + ::substrait::Type_List* _internal_mutable_list(); public: void unsafe_arena_set_allocated_list( - ::io::substrait::Type_List* list); - ::io::substrait::Type_List* unsafe_arena_release_list(); + ::substrait::Type_List* list); + ::substrait::Type_List* unsafe_arena_release_list(); - // .io.substrait.Type.Map map = 28; + // .substrait.Type.Map map = 28; bool has_map() const; private: bool _internal_has_map() const; public: void clear_map(); - const ::io::substrait::Type_Map& map() const; - ::io::substrait::Type_Map* release_map(); - ::io::substrait::Type_Map* mutable_map(); - void set_allocated_map(::io::substrait::Type_Map* map); + const ::substrait::Type_Map& map() const; + ::substrait::Type_Map* release_map(); + ::substrait::Type_Map* mutable_map(); + void set_allocated_map(::substrait::Type_Map* map); private: - const ::io::substrait::Type_Map& _internal_map() const; - ::io::substrait::Type_Map* _internal_mutable_map(); + const ::substrait::Type_Map& _internal_map() const; + ::substrait::Type_Map* _internal_mutable_map(); public: void unsafe_arena_set_allocated_map( - ::io::substrait::Type_Map* map); - ::io::substrait::Type_Map* unsafe_arena_release_map(); + ::substrait::Type_Map* map); + ::substrait::Type_Map* unsafe_arena_release_map(); // uint32 user_defined_type_reference = 31; bool has_user_defined_type_reference() const; @@ -4234,7 +4234,7 @@ class Type PROTOBUF_FINAL : void clear_kind(); KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.Type) + // @@protoc_insertion_point(class_scope:substrait.Type) private: class _Internal; void set_has_bool_(); @@ -4271,40 +4271,40 @@ class Type PROTOBUF_FINAL : union KindUnion { constexpr KindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Type_Boolean* bool__; - ::io::substrait::Type_I8* i8_; - ::io::substrait::Type_I16* i16_; - ::io::substrait::Type_I32* i32_; - ::io::substrait::Type_I64* i64_; - ::io::substrait::Type_FP32* fp32_; - ::io::substrait::Type_FP64* fp64_; - ::io::substrait::Type_String* string_; - ::io::substrait::Type_Binary* binary_; - ::io::substrait::Type_Timestamp* timestamp_; - ::io::substrait::Type_Date* date_; - ::io::substrait::Type_Time* time_; - ::io::substrait::Type_IntervalYear* interval_year_; - ::io::substrait::Type_IntervalDay* interval_day_; - ::io::substrait::Type_TimestampTZ* timestamp_tz_; - ::io::substrait::Type_UUID* uuid_; - ::io::substrait::Type_FixedChar* fixed_char_; - ::io::substrait::Type_VarChar* varchar_; - ::io::substrait::Type_FixedBinary* fixed_binary_; - ::io::substrait::Type_Decimal* decimal_; - ::io::substrait::Type_Struct* struct__; - ::io::substrait::Type_List* list_; - ::io::substrait::Type_Map* map_; + ::substrait::Type_Boolean* bool__; + ::substrait::Type_I8* i8_; + ::substrait::Type_I16* i16_; + ::substrait::Type_I32* i32_; + ::substrait::Type_I64* i64_; + ::substrait::Type_FP32* fp32_; + ::substrait::Type_FP64* fp64_; + ::substrait::Type_String* string_; + ::substrait::Type_Binary* binary_; + ::substrait::Type_Timestamp* timestamp_; + ::substrait::Type_Date* date_; + ::substrait::Type_Time* time_; + ::substrait::Type_IntervalYear* interval_year_; + ::substrait::Type_IntervalDay* interval_day_; + ::substrait::Type_TimestampTZ* timestamp_tz_; + ::substrait::Type_UUID* uuid_; + ::substrait::Type_FixedChar* fixed_char_; + ::substrait::Type_VarChar* varchar_; + ::substrait::Type_FixedBinary* fixed_binary_; + ::substrait::Type_Decimal* decimal_; + ::substrait::Type_Struct* struct__; + ::substrait::Type_List* list_; + ::substrait::Type_Map* map_; ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_type_reference_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- class NamedStruct PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.NamedStruct) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.NamedStruct) */ { public: inline NamedStruct() : NamedStruct(nullptr) {} ~NamedStruct() override; @@ -4394,7 +4394,7 @@ class NamedStruct PROTOBUF_FINAL : void InternalSwap(NamedStruct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.NamedStruct"; + return "substrait.NamedStruct"; } protected: explicit NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -4437,25 +4437,25 @@ class NamedStruct PROTOBUF_FINAL : std::string* _internal_add_names(); public: - // .io.substrait.Type.Struct struct = 2; + // .substrait.Type.Struct struct = 2; bool has_struct_() const; private: bool _internal_has_struct_() const; public: void clear_struct_(); - const ::io::substrait::Type_Struct& struct_() const; - ::io::substrait::Type_Struct* release_struct_(); - ::io::substrait::Type_Struct* mutable_struct_(); - void set_allocated_struct_(::io::substrait::Type_Struct* struct_); + const ::substrait::Type_Struct& struct_() const; + ::substrait::Type_Struct* release_struct_(); + ::substrait::Type_Struct* mutable_struct_(); + void set_allocated_struct_(::substrait::Type_Struct* struct_); private: - const ::io::substrait::Type_Struct& _internal_struct_() const; - ::io::substrait::Type_Struct* _internal_mutable_struct_(); + const ::substrait::Type_Struct& _internal_struct_() const; + ::substrait::Type_Struct* _internal_mutable_struct_(); public: void unsafe_arena_set_allocated_struct_( - ::io::substrait::Type_Struct* struct_); - ::io::substrait::Type_Struct* unsafe_arena_release_struct_(); + ::substrait::Type_Struct* struct_); + ::substrait::Type_Struct* unsafe_arena_release_struct_(); - // @@protoc_insertion_point(class_scope:io.substrait.NamedStruct) + // @@protoc_insertion_point(class_scope:substrait.NamedStruct) private: class _Internal; @@ -4463,9 +4463,9 @@ class NamedStruct PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::io::substrait::Type_Struct* struct__; + ::substrait::Type_Struct* struct__; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_2eproto; + friend struct ::TableStruct_substrait_2ftype_2eproto; }; // =================================================================== @@ -4486,7 +4486,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Boolean::_internal_type_variation_re return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Boolean::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Boolean.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.Boolean.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_Boolean::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4495,27 +4495,27 @@ inline void Type_Boolean::_internal_set_type_variation_reference(::PROTOBUF_NAME } inline void Type_Boolean::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Boolean.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.Boolean.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_Boolean::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_Boolean::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_Boolean::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_Boolean::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Boolean.nullability) +inline ::substrait::Type_Nullability Type_Boolean::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.Boolean.nullability) return _internal_nullability(); } -inline void Type_Boolean::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Boolean::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_Boolean::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Boolean::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Boolean.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.Boolean.nullability) } // ------------------------------------------------------------------- @@ -4530,7 +4530,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I8::_internal_type_variation_referen return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I8::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I8.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.I8.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_I8::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4539,27 +4539,27 @@ inline void Type_I8::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE } inline void Type_I8::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.I8.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.I8.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_I8::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_I8::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_I8::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_I8::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I8.nullability) +inline ::substrait::Type_Nullability Type_I8::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.I8.nullability) return _internal_nullability(); } -inline void Type_I8::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_I8::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_I8::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_I8::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.I8.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.I8.nullability) } // ------------------------------------------------------------------- @@ -4574,7 +4574,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I16::_internal_type_variation_refere return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I16::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I16.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.I16.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_I16::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4583,27 +4583,27 @@ inline void Type_I16::_internal_set_type_variation_reference(::PROTOBUF_NAMESPAC } inline void Type_I16::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.I16.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.I16.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_I16::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_I16::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_I16::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_I16::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I16.nullability) +inline ::substrait::Type_Nullability Type_I16::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.I16.nullability) return _internal_nullability(); } -inline void Type_I16::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_I16::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_I16::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_I16::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.I16.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.I16.nullability) } // ------------------------------------------------------------------- @@ -4618,7 +4618,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I32::_internal_type_variation_refere return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I32::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I32.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.I32.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_I32::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4627,27 +4627,27 @@ inline void Type_I32::_internal_set_type_variation_reference(::PROTOBUF_NAMESPAC } inline void Type_I32::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.I32.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.I32.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_I32::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_I32::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_I32::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_I32::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I32.nullability) +inline ::substrait::Type_Nullability Type_I32::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.I32.nullability) return _internal_nullability(); } -inline void Type_I32::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_I32::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_I32::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_I32::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.I32.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.I32.nullability) } // ------------------------------------------------------------------- @@ -4662,7 +4662,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I64::_internal_type_variation_refere return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I64::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I64.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.I64.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_I64::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4671,27 +4671,27 @@ inline void Type_I64::_internal_set_type_variation_reference(::PROTOBUF_NAMESPAC } inline void Type_I64::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.I64.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.I64.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_I64::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_I64::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_I64::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_I64::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.I64.nullability) +inline ::substrait::Type_Nullability Type_I64::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.I64.nullability) return _internal_nullability(); } -inline void Type_I64::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_I64::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_I64::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_I64::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.I64.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.I64.nullability) } // ------------------------------------------------------------------- @@ -4706,7 +4706,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP32::_internal_type_variation_refer return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP32::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FP32.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.FP32.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_FP32::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4715,27 +4715,27 @@ inline void Type_FP32::_internal_set_type_variation_reference(::PROTOBUF_NAMESPA } inline void Type_FP32::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.FP32.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.FP32.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_FP32::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_FP32::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_FP32::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_FP32::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FP32.nullability) +inline ::substrait::Type_Nullability Type_FP32::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.FP32.nullability) return _internal_nullability(); } -inline void Type_FP32::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_FP32::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_FP32::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_FP32::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.FP32.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.FP32.nullability) } // ------------------------------------------------------------------- @@ -4750,7 +4750,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP64::_internal_type_variation_refer return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP64::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FP64.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.FP64.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_FP64::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4759,27 +4759,27 @@ inline void Type_FP64::_internal_set_type_variation_reference(::PROTOBUF_NAMESPA } inline void Type_FP64::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.FP64.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.FP64.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_FP64::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_FP64::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_FP64::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_FP64::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FP64.nullability) +inline ::substrait::Type_Nullability Type_FP64::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.FP64.nullability) return _internal_nullability(); } -inline void Type_FP64::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_FP64::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_FP64::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_FP64::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.FP64.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.FP64.nullability) } // ------------------------------------------------------------------- @@ -4794,7 +4794,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_String::_internal_type_variation_ref return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_String::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.String.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.String.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_String::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4803,27 +4803,27 @@ inline void Type_String::_internal_set_type_variation_reference(::PROTOBUF_NAMES } inline void Type_String::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.String.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.String.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_String::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_String::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_String::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_String::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.String.nullability) +inline ::substrait::Type_Nullability Type_String::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.String.nullability) return _internal_nullability(); } -inline void Type_String::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_String::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_String::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_String::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.String.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.String.nullability) } // ------------------------------------------------------------------- @@ -4838,7 +4838,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Binary::_internal_type_variation_ref return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Binary::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Binary.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.Binary.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_Binary::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4847,27 +4847,27 @@ inline void Type_Binary::_internal_set_type_variation_reference(::PROTOBUF_NAMES } inline void Type_Binary::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Binary.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.Binary.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_Binary::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_Binary::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_Binary::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_Binary::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Binary.nullability) +inline ::substrait::Type_Nullability Type_Binary::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.Binary.nullability) return _internal_nullability(); } -inline void Type_Binary::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Binary::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_Binary::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Binary::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Binary.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.Binary.nullability) } // ------------------------------------------------------------------- @@ -4882,7 +4882,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Timestamp::_internal_type_variation_ return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Timestamp::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Timestamp.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.Timestamp.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_Timestamp::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4891,27 +4891,27 @@ inline void Type_Timestamp::_internal_set_type_variation_reference(::PROTOBUF_NA } inline void Type_Timestamp::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Timestamp.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.Timestamp.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_Timestamp::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_Timestamp::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_Timestamp::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_Timestamp::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Timestamp.nullability) +inline ::substrait::Type_Nullability Type_Timestamp::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.Timestamp.nullability) return _internal_nullability(); } -inline void Type_Timestamp::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Timestamp::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_Timestamp::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Timestamp::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Timestamp.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.Timestamp.nullability) } // ------------------------------------------------------------------- @@ -4926,7 +4926,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Date::_internal_type_variation_refer return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Date::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Date.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.Date.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_Date::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4935,27 +4935,27 @@ inline void Type_Date::_internal_set_type_variation_reference(::PROTOBUF_NAMESPA } inline void Type_Date::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Date.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.Date.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_Date::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_Date::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_Date::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_Date::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Date.nullability) +inline ::substrait::Type_Nullability Type_Date::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.Date.nullability) return _internal_nullability(); } -inline void Type_Date::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Date::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_Date::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Date::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Date.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.Date.nullability) } // ------------------------------------------------------------------- @@ -4970,7 +4970,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Time::_internal_type_variation_refer return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Time::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Time.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.Time.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_Time::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4979,27 +4979,27 @@ inline void Type_Time::_internal_set_type_variation_reference(::PROTOBUF_NAMESPA } inline void Type_Time::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Time.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.Time.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_Time::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_Time::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_Time::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_Time::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Time.nullability) +inline ::substrait::Type_Nullability Type_Time::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.Time.nullability) return _internal_nullability(); } -inline void Type_Time::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Time::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_Time::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Time::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Time.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.Time.nullability) } // ------------------------------------------------------------------- @@ -5014,7 +5014,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_TimestampTZ::_internal_type_variatio return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_TimestampTZ::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.TimestampTZ.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.TimestampTZ.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_TimestampTZ::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5023,27 +5023,27 @@ inline void Type_TimestampTZ::_internal_set_type_variation_reference(::PROTOBUF_ } inline void Type_TimestampTZ::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.TimestampTZ.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.TimestampTZ.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_TimestampTZ::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_TimestampTZ::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_TimestampTZ::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_TimestampTZ::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.TimestampTZ.nullability) +inline ::substrait::Type_Nullability Type_TimestampTZ::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.TimestampTZ.nullability) return _internal_nullability(); } -inline void Type_TimestampTZ::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_TimestampTZ::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_TimestampTZ::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_TimestampTZ::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.TimestampTZ.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.TimestampTZ.nullability) } // ------------------------------------------------------------------- @@ -5058,7 +5058,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalYear::_internal_type_variati return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalYear::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalYear.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.IntervalYear.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_IntervalYear::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5067,27 +5067,27 @@ inline void Type_IntervalYear::_internal_set_type_variation_reference(::PROTOBUF } inline void Type_IntervalYear::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.IntervalYear.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.IntervalYear.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_IntervalYear::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_IntervalYear::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_IntervalYear::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_IntervalYear::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalYear.nullability) +inline ::substrait::Type_Nullability Type_IntervalYear::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.IntervalYear.nullability) return _internal_nullability(); } -inline void Type_IntervalYear::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_IntervalYear::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_IntervalYear::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_IntervalYear::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.IntervalYear.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.IntervalYear.nullability) } // ------------------------------------------------------------------- @@ -5102,7 +5102,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalDay::_internal_type_variatio return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalDay::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalDay.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.IntervalDay.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_IntervalDay::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5111,27 +5111,27 @@ inline void Type_IntervalDay::_internal_set_type_variation_reference(::PROTOBUF_ } inline void Type_IntervalDay::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.IntervalDay.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.IntervalDay.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_IntervalDay::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_IntervalDay::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_IntervalDay::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_IntervalDay::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.IntervalDay.nullability) +inline ::substrait::Type_Nullability Type_IntervalDay::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.IntervalDay.nullability) return _internal_nullability(); } -inline void Type_IntervalDay::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_IntervalDay::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_IntervalDay::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_IntervalDay::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.IntervalDay.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.IntervalDay.nullability) } // ------------------------------------------------------------------- @@ -5146,7 +5146,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_UUID::_internal_type_variation_refer return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_UUID::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.UUID.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.UUID.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_UUID::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5155,27 +5155,27 @@ inline void Type_UUID::_internal_set_type_variation_reference(::PROTOBUF_NAMESPA } inline void Type_UUID::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.UUID.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.UUID.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 2; +// .substrait.Type.Nullability nullability = 2; inline void Type_UUID::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_UUID::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_UUID::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_UUID::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.UUID.nullability) +inline ::substrait::Type_Nullability Type_UUID::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.UUID.nullability) return _internal_nullability(); } -inline void Type_UUID::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_UUID::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_UUID::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_UUID::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.UUID.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.UUID.nullability) } // ------------------------------------------------------------------- @@ -5190,7 +5190,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedChar::_internal_length() const { return length_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedChar::length() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FixedChar.length) + // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.length) return _internal_length(); } inline void Type_FixedChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -5199,7 +5199,7 @@ inline void Type_FixedChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 } inline void Type_FixedChar::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_length(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.FixedChar.length) + // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.length) } // uint32 type_variation_reference = 2; @@ -5210,7 +5210,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedChar::_internal_type_variation_ return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedChar::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FixedChar.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_FixedChar::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5219,27 +5219,27 @@ inline void Type_FixedChar::_internal_set_type_variation_reference(::PROTOBUF_NA } inline void Type_FixedChar::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.FixedChar.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void Type_FixedChar::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_FixedChar::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_FixedChar::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_FixedChar::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FixedChar.nullability) +inline ::substrait::Type_Nullability Type_FixedChar::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.nullability) return _internal_nullability(); } -inline void Type_FixedChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_FixedChar::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_FixedChar::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_FixedChar::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.FixedChar.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.nullability) } // ------------------------------------------------------------------- @@ -5254,7 +5254,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Type_VarChar::_internal_length() const { return length_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Type_VarChar::length() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.VarChar.length) + // @@protoc_insertion_point(field_get:substrait.Type.VarChar.length) return _internal_length(); } inline void Type_VarChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -5263,7 +5263,7 @@ inline void Type_VarChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 va } inline void Type_VarChar::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_length(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.VarChar.length) + // @@protoc_insertion_point(field_set:substrait.Type.VarChar.length) } // uint32 type_variation_reference = 2; @@ -5274,7 +5274,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_VarChar::_internal_type_variation_re return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_VarChar::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.VarChar.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.VarChar.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_VarChar::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5283,27 +5283,27 @@ inline void Type_VarChar::_internal_set_type_variation_reference(::PROTOBUF_NAME } inline void Type_VarChar::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.VarChar.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.VarChar.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void Type_VarChar::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_VarChar::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_VarChar::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_VarChar::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.VarChar.nullability) +inline ::substrait::Type_Nullability Type_VarChar::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.VarChar.nullability) return _internal_nullability(); } -inline void Type_VarChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_VarChar::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_VarChar::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_VarChar::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.VarChar.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.VarChar.nullability) } // ------------------------------------------------------------------- @@ -5318,7 +5318,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedBinary::_internal_length() const return length_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedBinary::length() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FixedBinary.length) + // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.length) return _internal_length(); } inline void Type_FixedBinary::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -5327,7 +5327,7 @@ inline void Type_FixedBinary::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int3 } inline void Type_FixedBinary::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_length(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.FixedBinary.length) + // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.length) } // uint32 type_variation_reference = 2; @@ -5338,7 +5338,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedBinary::_internal_type_variatio return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedBinary::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FixedBinary.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_FixedBinary::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5347,27 +5347,27 @@ inline void Type_FixedBinary::_internal_set_type_variation_reference(::PROTOBUF_ } inline void Type_FixedBinary::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.FixedBinary.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void Type_FixedBinary::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_FixedBinary::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_FixedBinary::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_FixedBinary::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.FixedBinary.nullability) +inline ::substrait::Type_Nullability Type_FixedBinary::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.nullability) return _internal_nullability(); } -inline void Type_FixedBinary::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_FixedBinary::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_FixedBinary::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_FixedBinary::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.FixedBinary.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.nullability) } // ------------------------------------------------------------------- @@ -5382,7 +5382,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::_internal_scale() const { return scale_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::scale() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Decimal.scale) + // @@protoc_insertion_point(field_get:substrait.Type.Decimal.scale) return _internal_scale(); } inline void Type_Decimal::_internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -5391,7 +5391,7 @@ inline void Type_Decimal::_internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 val } inline void Type_Decimal::set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_scale(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Decimal.scale) + // @@protoc_insertion_point(field_set:substrait.Type.Decimal.scale) } // int32 precision = 2; @@ -5402,7 +5402,7 @@ inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::_internal_precision() const return precision_; } inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::precision() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Decimal.precision) + // @@protoc_insertion_point(field_get:substrait.Type.Decimal.precision) return _internal_precision(); } inline void Type_Decimal::_internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { @@ -5411,7 +5411,7 @@ inline void Type_Decimal::_internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 } inline void Type_Decimal::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_precision(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Decimal.precision) + // @@protoc_insertion_point(field_set:substrait.Type.Decimal.precision) } // uint32 type_variation_reference = 3; @@ -5422,7 +5422,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Decimal::_internal_type_variation_re return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Decimal::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Decimal.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.Decimal.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_Decimal::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5431,34 +5431,34 @@ inline void Type_Decimal::_internal_set_type_variation_reference(::PROTOBUF_NAME } inline void Type_Decimal::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Decimal.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.Decimal.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 4; +// .substrait.Type.Nullability nullability = 4; inline void Type_Decimal::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_Decimal::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_Decimal::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_Decimal::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Decimal.nullability) +inline ::substrait::Type_Nullability Type_Decimal::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.Decimal.nullability) return _internal_nullability(); } -inline void Type_Decimal::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Decimal::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_Decimal::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Decimal::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Decimal.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.Decimal.nullability) } // ------------------------------------------------------------------- // Type_Struct -// repeated .io.substrait.Type types = 1; +// repeated .substrait.Type types = 1; inline int Type_Struct::_internal_types_size() const { return types_.size(); } @@ -5468,32 +5468,32 @@ inline int Type_Struct::types_size() const { inline void Type_Struct::clear_types() { types_.Clear(); } -inline ::io::substrait::Type* Type_Struct::mutable_types(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Struct.types) +inline ::substrait::Type* Type_Struct::mutable_types(int index) { + // @@protoc_insertion_point(field_mutable:substrait.Type.Struct.types) return types_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >* Type_Struct::mutable_types() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.Type.Struct.types) + // @@protoc_insertion_point(field_mutable_list:substrait.Type.Struct.types) return &types_; } -inline const ::io::substrait::Type& Type_Struct::_internal_types(int index) const { +inline const ::substrait::Type& Type_Struct::_internal_types(int index) const { return types_.Get(index); } -inline const ::io::substrait::Type& Type_Struct::types(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Struct.types) +inline const ::substrait::Type& Type_Struct::types(int index) const { + // @@protoc_insertion_point(field_get:substrait.Type.Struct.types) return _internal_types(index); } -inline ::io::substrait::Type* Type_Struct::_internal_add_types() { +inline ::substrait::Type* Type_Struct::_internal_add_types() { return types_.Add(); } -inline ::io::substrait::Type* Type_Struct::add_types() { - // @@protoc_insertion_point(field_add:io.substrait.Type.Struct.types) +inline ::substrait::Type* Type_Struct::add_types() { + // @@protoc_insertion_point(field_add:substrait.Type.Struct.types) return _internal_add_types(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::Type >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >& Type_Struct::types() const { - // @@protoc_insertion_point(field_list:io.substrait.Type.Struct.types) + // @@protoc_insertion_point(field_list:substrait.Type.Struct.types) return types_; } @@ -5505,7 +5505,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Struct::_internal_type_variation_ref return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Struct::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Struct.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.Struct.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_Struct::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5514,34 +5514,34 @@ inline void Type_Struct::_internal_set_type_variation_reference(::PROTOBUF_NAMES } inline void Type_Struct::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Struct.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.Struct.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void Type_Struct::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_Struct::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_Struct::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_Struct::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Struct.nullability) +inline ::substrait::Type_Nullability Type_Struct::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.Struct.nullability) return _internal_nullability(); } -inline void Type_Struct::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Struct::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_Struct::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Struct::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Struct.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.Struct.nullability) } // ------------------------------------------------------------------- // Type_List -// .io.substrait.Type type = 1; +// .substrait.Type type = 1; inline bool Type_List::_internal_has_type() const { return this != internal_default_instance() && type_ != nullptr; } @@ -5554,17 +5554,17 @@ inline void Type_List::clear_type() { } type_ = nullptr; } -inline const ::io::substrait::Type& Type_List::_internal_type() const { - const ::io::substrait::Type* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline const ::substrait::Type& Type_List::_internal_type() const { + const ::substrait::Type* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Type_default_instance_); } -inline const ::io::substrait::Type& Type_List::type() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.List.type) +inline const ::substrait::Type& Type_List::type() const { + // @@protoc_insertion_point(field_get:substrait.Type.List.type) return _internal_type(); } inline void Type_List::unsafe_arena_set_allocated_type( - ::io::substrait::Type* type) { + ::substrait::Type* type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } @@ -5574,37 +5574,37 @@ inline void Type_List::unsafe_arena_set_allocated_type( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.List.type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.List.type) } -inline ::io::substrait::Type* Type_List::release_type() { +inline ::substrait::Type* Type_List::release_type() { - ::io::substrait::Type* temp = type_; + ::substrait::Type* temp = type_; type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type* Type_List::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:io.substrait.Type.List.type) +inline ::substrait::Type* Type_List::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:substrait.Type.List.type) - ::io::substrait::Type* temp = type_; + ::substrait::Type* temp = type_; type_ = nullptr; return temp; } -inline ::io::substrait::Type* Type_List::_internal_mutable_type() { +inline ::substrait::Type* Type_List::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); type_ = p; } return type_; } -inline ::io::substrait::Type* Type_List::mutable_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.List.type) +inline ::substrait::Type* Type_List::mutable_type() { + // @@protoc_insertion_point(field_mutable:substrait.Type.List.type) return _internal_mutable_type(); } -inline void Type_List::set_allocated_type(::io::substrait::Type* type) { +inline void Type_List::set_allocated_type(::substrait::Type* type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete type_; @@ -5621,7 +5621,7 @@ inline void Type_List::set_allocated_type(::io::substrait::Type* type) { } type_ = type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.List.type) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.List.type) } // uint32 type_variation_reference = 2; @@ -5632,7 +5632,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_List::_internal_type_variation_refer return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_List::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.List.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.List.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_List::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5641,34 +5641,34 @@ inline void Type_List::_internal_set_type_variation_reference(::PROTOBUF_NAMESPA } inline void Type_List::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.List.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.List.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void Type_List::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_List::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_List::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_List::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.List.nullability) +inline ::substrait::Type_Nullability Type_List::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.List.nullability) return _internal_nullability(); } -inline void Type_List::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_List::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_List::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_List::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.List.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.List.nullability) } // ------------------------------------------------------------------- // Type_Map -// .io.substrait.Type key = 1; +// .substrait.Type key = 1; inline bool Type_Map::_internal_has_key() const { return this != internal_default_instance() && key_ != nullptr; } @@ -5681,17 +5681,17 @@ inline void Type_Map::clear_key() { } key_ = nullptr; } -inline const ::io::substrait::Type& Type_Map::_internal_key() const { - const ::io::substrait::Type* p = key_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline const ::substrait::Type& Type_Map::_internal_key() const { + const ::substrait::Type* p = key_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Type_default_instance_); } -inline const ::io::substrait::Type& Type_Map::key() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Map.key) +inline const ::substrait::Type& Type_Map::key() const { + // @@protoc_insertion_point(field_get:substrait.Type.Map.key) return _internal_key(); } inline void Type_Map::unsafe_arena_set_allocated_key( - ::io::substrait::Type* key) { + ::substrait::Type* key) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); } @@ -5701,37 +5701,37 @@ inline void Type_Map::unsafe_arena_set_allocated_key( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Map.key) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.Map.key) } -inline ::io::substrait::Type* Type_Map::release_key() { +inline ::substrait::Type* Type_Map::release_key() { - ::io::substrait::Type* temp = key_; + ::substrait::Type* temp = key_; key_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type* Type_Map::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Map.key) +inline ::substrait::Type* Type_Map::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:substrait.Type.Map.key) - ::io::substrait::Type* temp = key_; + ::substrait::Type* temp = key_; key_ = nullptr; return temp; } -inline ::io::substrait::Type* Type_Map::_internal_mutable_key() { +inline ::substrait::Type* Type_Map::_internal_mutable_key() { if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); key_ = p; } return key_; } -inline ::io::substrait::Type* Type_Map::mutable_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Map.key) +inline ::substrait::Type* Type_Map::mutable_key() { + // @@protoc_insertion_point(field_mutable:substrait.Type.Map.key) return _internal_mutable_key(); } -inline void Type_Map::set_allocated_key(::io::substrait::Type* key) { +inline void Type_Map::set_allocated_key(::substrait::Type* key) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete key_; @@ -5748,10 +5748,10 @@ inline void Type_Map::set_allocated_key(::io::substrait::Type* key) { } key_ = key; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Map.key) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.Map.key) } -// .io.substrait.Type value = 2; +// .substrait.Type value = 2; inline bool Type_Map::_internal_has_value() const { return this != internal_default_instance() && value_ != nullptr; } @@ -5764,17 +5764,17 @@ inline void Type_Map::clear_value() { } value_ = nullptr; } -inline const ::io::substrait::Type& Type_Map::_internal_value() const { - const ::io::substrait::Type* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_default_instance_); +inline const ::substrait::Type& Type_Map::_internal_value() const { + const ::substrait::Type* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Type_default_instance_); } -inline const ::io::substrait::Type& Type_Map::value() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Map.value) +inline const ::substrait::Type& Type_Map::value() const { + // @@protoc_insertion_point(field_get:substrait.Type.Map.value) return _internal_value(); } inline void Type_Map::unsafe_arena_set_allocated_value( - ::io::substrait::Type* value) { + ::substrait::Type* value) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } @@ -5784,37 +5784,37 @@ inline void Type_Map::unsafe_arena_set_allocated_value( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.Map.value) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.Map.value) } -inline ::io::substrait::Type* Type_Map::release_value() { +inline ::substrait::Type* Type_Map::release_value() { - ::io::substrait::Type* temp = value_; + ::substrait::Type* temp = value_; value_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type* Type_Map::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:io.substrait.Type.Map.value) +inline ::substrait::Type* Type_Map::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:substrait.Type.Map.value) - ::io::substrait::Type* temp = value_; + ::substrait::Type* temp = value_; value_ = nullptr; return temp; } -inline ::io::substrait::Type* Type_Map::_internal_mutable_value() { +inline ::substrait::Type* Type_Map::_internal_mutable_value() { if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); value_ = p; } return value_; } -inline ::io::substrait::Type* Type_Map::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.Map.value) +inline ::substrait::Type* Type_Map::mutable_value() { + // @@protoc_insertion_point(field_mutable:substrait.Type.Map.value) return _internal_mutable_value(); } -inline void Type_Map::set_allocated_value(::io::substrait::Type* value) { +inline void Type_Map::set_allocated_value(::substrait::Type* value) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete value_; @@ -5831,7 +5831,7 @@ inline void Type_Map::set_allocated_value(::io::substrait::Type* value) { } value_ = value; - // @@protoc_insertion_point(field_set_allocated:io.substrait.Type.Map.value) + // @@protoc_insertion_point(field_set_allocated:substrait.Type.Map.value) } // uint32 type_variation_reference = 3; @@ -5842,7 +5842,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Map::_internal_type_variation_refere return type_variation_reference_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Map::type_variation_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Map.type_variation_reference) + // @@protoc_insertion_point(field_get:substrait.Type.Map.type_variation_reference) return _internal_type_variation_reference(); } inline void Type_Map::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -5851,34 +5851,34 @@ inline void Type_Map::_internal_set_type_variation_reference(::PROTOBUF_NAMESPAC } inline void Type_Map::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Map.type_variation_reference) + // @@protoc_insertion_point(field_set:substrait.Type.Map.type_variation_reference) } -// .io.substrait.Type.Nullability nullability = 4; +// .substrait.Type.Nullability nullability = 4; inline void Type_Map::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability Type_Map::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability Type_Map::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability Type_Map::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.Map.nullability) +inline ::substrait::Type_Nullability Type_Map::nullability() const { + // @@protoc_insertion_point(field_get:substrait.Type.Map.nullability) return _internal_nullability(); } -inline void Type_Map::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Map::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void Type_Map::set_nullability(::io::substrait::Type_Nullability value) { +inline void Type_Map::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.Map.nullability) + // @@protoc_insertion_point(field_set:substrait.Type.Map.nullability) } // ------------------------------------------------------------------- // Type -// .io.substrait.Type.Boolean bool = 1; +// .substrait.Type.Boolean bool = 1; inline bool Type::_internal_has_bool_() const { return kind_case() == kBool; } @@ -5896,11 +5896,11 @@ inline void Type::clear_bool_() { clear_has_kind(); } } -inline ::io::substrait::Type_Boolean* Type::release_bool_() { - // @@protoc_insertion_point(field_release:io.substrait.Type.bool) +inline ::substrait::Type_Boolean* Type::release_bool_() { + // @@protoc_insertion_point(field_release:substrait.Type.bool) if (_internal_has_bool_()) { clear_has_kind(); - ::io::substrait::Type_Boolean* temp = kind_.bool__; + ::substrait::Type_Boolean* temp = kind_.bool__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5910,48 +5910,48 @@ inline ::io::substrait::Type_Boolean* Type::release_bool_() { return nullptr; } } -inline const ::io::substrait::Type_Boolean& Type::_internal_bool_() const { +inline const ::substrait::Type_Boolean& Type::_internal_bool_() const { return _internal_has_bool_() ? *kind_.bool__ - : reinterpret_cast< ::io::substrait::Type_Boolean&>(::io::substrait::_Type_Boolean_default_instance_); + : reinterpret_cast< ::substrait::Type_Boolean&>(::substrait::_Type_Boolean_default_instance_); } -inline const ::io::substrait::Type_Boolean& Type::bool_() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.bool) +inline const ::substrait::Type_Boolean& Type::bool_() const { + // @@protoc_insertion_point(field_get:substrait.Type.bool) return _internal_bool_(); } -inline ::io::substrait::Type_Boolean* Type::unsafe_arena_release_bool_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.bool) +inline ::substrait::Type_Boolean* Type::unsafe_arena_release_bool_() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.bool) if (_internal_has_bool_()) { clear_has_kind(); - ::io::substrait::Type_Boolean* temp = kind_.bool__; + ::substrait::Type_Boolean* temp = kind_.bool__; kind_.bool__ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { +inline void Type::unsafe_arena_set_allocated_bool_(::substrait::Type_Boolean* bool_) { clear_kind(); if (bool_) { set_has_bool_(); kind_.bool__ = bool_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.bool) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.bool) } -inline ::io::substrait::Type_Boolean* Type::_internal_mutable_bool_() { +inline ::substrait::Type_Boolean* Type::_internal_mutable_bool_() { if (!_internal_has_bool_()) { clear_kind(); set_has_bool_(); - kind_.bool__ = CreateMaybeMessage< ::io::substrait::Type_Boolean >(GetArena()); + kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArena()); } return kind_.bool__; } -inline ::io::substrait::Type_Boolean* Type::mutable_bool_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.bool) +inline ::substrait::Type_Boolean* Type::mutable_bool_() { + // @@protoc_insertion_point(field_mutable:substrait.Type.bool) return _internal_mutable_bool_(); } -// .io.substrait.Type.I8 i8 = 2; +// .substrait.Type.I8 i8 = 2; inline bool Type::_internal_has_i8() const { return kind_case() == kI8; } @@ -5969,11 +5969,11 @@ inline void Type::clear_i8() { clear_has_kind(); } } -inline ::io::substrait::Type_I8* Type::release_i8() { - // @@protoc_insertion_point(field_release:io.substrait.Type.i8) +inline ::substrait::Type_I8* Type::release_i8() { + // @@protoc_insertion_point(field_release:substrait.Type.i8) if (_internal_has_i8()) { clear_has_kind(); - ::io::substrait::Type_I8* temp = kind_.i8_; + ::substrait::Type_I8* temp = kind_.i8_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5983,48 +5983,48 @@ inline ::io::substrait::Type_I8* Type::release_i8() { return nullptr; } } -inline const ::io::substrait::Type_I8& Type::_internal_i8() const { +inline const ::substrait::Type_I8& Type::_internal_i8() const { return _internal_has_i8() ? *kind_.i8_ - : reinterpret_cast< ::io::substrait::Type_I8&>(::io::substrait::_Type_I8_default_instance_); + : reinterpret_cast< ::substrait::Type_I8&>(::substrait::_Type_I8_default_instance_); } -inline const ::io::substrait::Type_I8& Type::i8() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.i8) +inline const ::substrait::Type_I8& Type::i8() const { + // @@protoc_insertion_point(field_get:substrait.Type.i8) return _internal_i8(); } -inline ::io::substrait::Type_I8* Type::unsafe_arena_release_i8() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.i8) +inline ::substrait::Type_I8* Type::unsafe_arena_release_i8() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i8) if (_internal_has_i8()) { clear_has_kind(); - ::io::substrait::Type_I8* temp = kind_.i8_; + ::substrait::Type_I8* temp = kind_.i8_; kind_.i8_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_i8(::io::substrait::Type_I8* i8) { +inline void Type::unsafe_arena_set_allocated_i8(::substrait::Type_I8* i8) { clear_kind(); if (i8) { set_has_i8(); kind_.i8_ = i8; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.i8) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i8) } -inline ::io::substrait::Type_I8* Type::_internal_mutable_i8() { +inline ::substrait::Type_I8* Type::_internal_mutable_i8() { if (!_internal_has_i8()) { clear_kind(); set_has_i8(); - kind_.i8_ = CreateMaybeMessage< ::io::substrait::Type_I8 >(GetArena()); + kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArena()); } return kind_.i8_; } -inline ::io::substrait::Type_I8* Type::mutable_i8() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.i8) +inline ::substrait::Type_I8* Type::mutable_i8() { + // @@protoc_insertion_point(field_mutable:substrait.Type.i8) return _internal_mutable_i8(); } -// .io.substrait.Type.I16 i16 = 3; +// .substrait.Type.I16 i16 = 3; inline bool Type::_internal_has_i16() const { return kind_case() == kI16; } @@ -6042,11 +6042,11 @@ inline void Type::clear_i16() { clear_has_kind(); } } -inline ::io::substrait::Type_I16* Type::release_i16() { - // @@protoc_insertion_point(field_release:io.substrait.Type.i16) +inline ::substrait::Type_I16* Type::release_i16() { + // @@protoc_insertion_point(field_release:substrait.Type.i16) if (_internal_has_i16()) { clear_has_kind(); - ::io::substrait::Type_I16* temp = kind_.i16_; + ::substrait::Type_I16* temp = kind_.i16_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6056,48 +6056,48 @@ inline ::io::substrait::Type_I16* Type::release_i16() { return nullptr; } } -inline const ::io::substrait::Type_I16& Type::_internal_i16() const { +inline const ::substrait::Type_I16& Type::_internal_i16() const { return _internal_has_i16() ? *kind_.i16_ - : reinterpret_cast< ::io::substrait::Type_I16&>(::io::substrait::_Type_I16_default_instance_); + : reinterpret_cast< ::substrait::Type_I16&>(::substrait::_Type_I16_default_instance_); } -inline const ::io::substrait::Type_I16& Type::i16() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.i16) +inline const ::substrait::Type_I16& Type::i16() const { + // @@protoc_insertion_point(field_get:substrait.Type.i16) return _internal_i16(); } -inline ::io::substrait::Type_I16* Type::unsafe_arena_release_i16() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.i16) +inline ::substrait::Type_I16* Type::unsafe_arena_release_i16() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i16) if (_internal_has_i16()) { clear_has_kind(); - ::io::substrait::Type_I16* temp = kind_.i16_; + ::substrait::Type_I16* temp = kind_.i16_; kind_.i16_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_i16(::io::substrait::Type_I16* i16) { +inline void Type::unsafe_arena_set_allocated_i16(::substrait::Type_I16* i16) { clear_kind(); if (i16) { set_has_i16(); kind_.i16_ = i16; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.i16) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i16) } -inline ::io::substrait::Type_I16* Type::_internal_mutable_i16() { +inline ::substrait::Type_I16* Type::_internal_mutable_i16() { if (!_internal_has_i16()) { clear_kind(); set_has_i16(); - kind_.i16_ = CreateMaybeMessage< ::io::substrait::Type_I16 >(GetArena()); + kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArena()); } return kind_.i16_; } -inline ::io::substrait::Type_I16* Type::mutable_i16() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.i16) +inline ::substrait::Type_I16* Type::mutable_i16() { + // @@protoc_insertion_point(field_mutable:substrait.Type.i16) return _internal_mutable_i16(); } -// .io.substrait.Type.I32 i32 = 5; +// .substrait.Type.I32 i32 = 5; inline bool Type::_internal_has_i32() const { return kind_case() == kI32; } @@ -6115,11 +6115,11 @@ inline void Type::clear_i32() { clear_has_kind(); } } -inline ::io::substrait::Type_I32* Type::release_i32() { - // @@protoc_insertion_point(field_release:io.substrait.Type.i32) +inline ::substrait::Type_I32* Type::release_i32() { + // @@protoc_insertion_point(field_release:substrait.Type.i32) if (_internal_has_i32()) { clear_has_kind(); - ::io::substrait::Type_I32* temp = kind_.i32_; + ::substrait::Type_I32* temp = kind_.i32_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6129,48 +6129,48 @@ inline ::io::substrait::Type_I32* Type::release_i32() { return nullptr; } } -inline const ::io::substrait::Type_I32& Type::_internal_i32() const { +inline const ::substrait::Type_I32& Type::_internal_i32() const { return _internal_has_i32() ? *kind_.i32_ - : reinterpret_cast< ::io::substrait::Type_I32&>(::io::substrait::_Type_I32_default_instance_); + : reinterpret_cast< ::substrait::Type_I32&>(::substrait::_Type_I32_default_instance_); } -inline const ::io::substrait::Type_I32& Type::i32() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.i32) +inline const ::substrait::Type_I32& Type::i32() const { + // @@protoc_insertion_point(field_get:substrait.Type.i32) return _internal_i32(); } -inline ::io::substrait::Type_I32* Type::unsafe_arena_release_i32() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.i32) +inline ::substrait::Type_I32* Type::unsafe_arena_release_i32() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i32) if (_internal_has_i32()) { clear_has_kind(); - ::io::substrait::Type_I32* temp = kind_.i32_; + ::substrait::Type_I32* temp = kind_.i32_; kind_.i32_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_i32(::io::substrait::Type_I32* i32) { +inline void Type::unsafe_arena_set_allocated_i32(::substrait::Type_I32* i32) { clear_kind(); if (i32) { set_has_i32(); kind_.i32_ = i32; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.i32) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i32) } -inline ::io::substrait::Type_I32* Type::_internal_mutable_i32() { +inline ::substrait::Type_I32* Type::_internal_mutable_i32() { if (!_internal_has_i32()) { clear_kind(); set_has_i32(); - kind_.i32_ = CreateMaybeMessage< ::io::substrait::Type_I32 >(GetArena()); + kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArena()); } return kind_.i32_; } -inline ::io::substrait::Type_I32* Type::mutable_i32() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.i32) +inline ::substrait::Type_I32* Type::mutable_i32() { + // @@protoc_insertion_point(field_mutable:substrait.Type.i32) return _internal_mutable_i32(); } -// .io.substrait.Type.I64 i64 = 7; +// .substrait.Type.I64 i64 = 7; inline bool Type::_internal_has_i64() const { return kind_case() == kI64; } @@ -6188,11 +6188,11 @@ inline void Type::clear_i64() { clear_has_kind(); } } -inline ::io::substrait::Type_I64* Type::release_i64() { - // @@protoc_insertion_point(field_release:io.substrait.Type.i64) +inline ::substrait::Type_I64* Type::release_i64() { + // @@protoc_insertion_point(field_release:substrait.Type.i64) if (_internal_has_i64()) { clear_has_kind(); - ::io::substrait::Type_I64* temp = kind_.i64_; + ::substrait::Type_I64* temp = kind_.i64_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6202,48 +6202,48 @@ inline ::io::substrait::Type_I64* Type::release_i64() { return nullptr; } } -inline const ::io::substrait::Type_I64& Type::_internal_i64() const { +inline const ::substrait::Type_I64& Type::_internal_i64() const { return _internal_has_i64() ? *kind_.i64_ - : reinterpret_cast< ::io::substrait::Type_I64&>(::io::substrait::_Type_I64_default_instance_); + : reinterpret_cast< ::substrait::Type_I64&>(::substrait::_Type_I64_default_instance_); } -inline const ::io::substrait::Type_I64& Type::i64() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.i64) +inline const ::substrait::Type_I64& Type::i64() const { + // @@protoc_insertion_point(field_get:substrait.Type.i64) return _internal_i64(); } -inline ::io::substrait::Type_I64* Type::unsafe_arena_release_i64() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.i64) +inline ::substrait::Type_I64* Type::unsafe_arena_release_i64() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i64) if (_internal_has_i64()) { clear_has_kind(); - ::io::substrait::Type_I64* temp = kind_.i64_; + ::substrait::Type_I64* temp = kind_.i64_; kind_.i64_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_i64(::io::substrait::Type_I64* i64) { +inline void Type::unsafe_arena_set_allocated_i64(::substrait::Type_I64* i64) { clear_kind(); if (i64) { set_has_i64(); kind_.i64_ = i64; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.i64) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i64) } -inline ::io::substrait::Type_I64* Type::_internal_mutable_i64() { +inline ::substrait::Type_I64* Type::_internal_mutable_i64() { if (!_internal_has_i64()) { clear_kind(); set_has_i64(); - kind_.i64_ = CreateMaybeMessage< ::io::substrait::Type_I64 >(GetArena()); + kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArena()); } return kind_.i64_; } -inline ::io::substrait::Type_I64* Type::mutable_i64() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.i64) +inline ::substrait::Type_I64* Type::mutable_i64() { + // @@protoc_insertion_point(field_mutable:substrait.Type.i64) return _internal_mutable_i64(); } -// .io.substrait.Type.FP32 fp32 = 10; +// .substrait.Type.FP32 fp32 = 10; inline bool Type::_internal_has_fp32() const { return kind_case() == kFp32; } @@ -6261,11 +6261,11 @@ inline void Type::clear_fp32() { clear_has_kind(); } } -inline ::io::substrait::Type_FP32* Type::release_fp32() { - // @@protoc_insertion_point(field_release:io.substrait.Type.fp32) +inline ::substrait::Type_FP32* Type::release_fp32() { + // @@protoc_insertion_point(field_release:substrait.Type.fp32) if (_internal_has_fp32()) { clear_has_kind(); - ::io::substrait::Type_FP32* temp = kind_.fp32_; + ::substrait::Type_FP32* temp = kind_.fp32_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6275,48 +6275,48 @@ inline ::io::substrait::Type_FP32* Type::release_fp32() { return nullptr; } } -inline const ::io::substrait::Type_FP32& Type::_internal_fp32() const { +inline const ::substrait::Type_FP32& Type::_internal_fp32() const { return _internal_has_fp32() ? *kind_.fp32_ - : reinterpret_cast< ::io::substrait::Type_FP32&>(::io::substrait::_Type_FP32_default_instance_); + : reinterpret_cast< ::substrait::Type_FP32&>(::substrait::_Type_FP32_default_instance_); } -inline const ::io::substrait::Type_FP32& Type::fp32() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.fp32) +inline const ::substrait::Type_FP32& Type::fp32() const { + // @@protoc_insertion_point(field_get:substrait.Type.fp32) return _internal_fp32(); } -inline ::io::substrait::Type_FP32* Type::unsafe_arena_release_fp32() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.fp32) +inline ::substrait::Type_FP32* Type::unsafe_arena_release_fp32() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fp32) if (_internal_has_fp32()) { clear_has_kind(); - ::io::substrait::Type_FP32* temp = kind_.fp32_; + ::substrait::Type_FP32* temp = kind_.fp32_; kind_.fp32_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_fp32(::io::substrait::Type_FP32* fp32) { +inline void Type::unsafe_arena_set_allocated_fp32(::substrait::Type_FP32* fp32) { clear_kind(); if (fp32) { set_has_fp32(); kind_.fp32_ = fp32; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.fp32) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fp32) } -inline ::io::substrait::Type_FP32* Type::_internal_mutable_fp32() { +inline ::substrait::Type_FP32* Type::_internal_mutable_fp32() { if (!_internal_has_fp32()) { clear_kind(); set_has_fp32(); - kind_.fp32_ = CreateMaybeMessage< ::io::substrait::Type_FP32 >(GetArena()); + kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArena()); } return kind_.fp32_; } -inline ::io::substrait::Type_FP32* Type::mutable_fp32() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.fp32) +inline ::substrait::Type_FP32* Type::mutable_fp32() { + // @@protoc_insertion_point(field_mutable:substrait.Type.fp32) return _internal_mutable_fp32(); } -// .io.substrait.Type.FP64 fp64 = 11; +// .substrait.Type.FP64 fp64 = 11; inline bool Type::_internal_has_fp64() const { return kind_case() == kFp64; } @@ -6334,11 +6334,11 @@ inline void Type::clear_fp64() { clear_has_kind(); } } -inline ::io::substrait::Type_FP64* Type::release_fp64() { - // @@protoc_insertion_point(field_release:io.substrait.Type.fp64) +inline ::substrait::Type_FP64* Type::release_fp64() { + // @@protoc_insertion_point(field_release:substrait.Type.fp64) if (_internal_has_fp64()) { clear_has_kind(); - ::io::substrait::Type_FP64* temp = kind_.fp64_; + ::substrait::Type_FP64* temp = kind_.fp64_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6348,48 +6348,48 @@ inline ::io::substrait::Type_FP64* Type::release_fp64() { return nullptr; } } -inline const ::io::substrait::Type_FP64& Type::_internal_fp64() const { +inline const ::substrait::Type_FP64& Type::_internal_fp64() const { return _internal_has_fp64() ? *kind_.fp64_ - : reinterpret_cast< ::io::substrait::Type_FP64&>(::io::substrait::_Type_FP64_default_instance_); + : reinterpret_cast< ::substrait::Type_FP64&>(::substrait::_Type_FP64_default_instance_); } -inline const ::io::substrait::Type_FP64& Type::fp64() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.fp64) +inline const ::substrait::Type_FP64& Type::fp64() const { + // @@protoc_insertion_point(field_get:substrait.Type.fp64) return _internal_fp64(); } -inline ::io::substrait::Type_FP64* Type::unsafe_arena_release_fp64() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.fp64) +inline ::substrait::Type_FP64* Type::unsafe_arena_release_fp64() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fp64) if (_internal_has_fp64()) { clear_has_kind(); - ::io::substrait::Type_FP64* temp = kind_.fp64_; + ::substrait::Type_FP64* temp = kind_.fp64_; kind_.fp64_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_fp64(::io::substrait::Type_FP64* fp64) { +inline void Type::unsafe_arena_set_allocated_fp64(::substrait::Type_FP64* fp64) { clear_kind(); if (fp64) { set_has_fp64(); kind_.fp64_ = fp64; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.fp64) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fp64) } -inline ::io::substrait::Type_FP64* Type::_internal_mutable_fp64() { +inline ::substrait::Type_FP64* Type::_internal_mutable_fp64() { if (!_internal_has_fp64()) { clear_kind(); set_has_fp64(); - kind_.fp64_ = CreateMaybeMessage< ::io::substrait::Type_FP64 >(GetArena()); + kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArena()); } return kind_.fp64_; } -inline ::io::substrait::Type_FP64* Type::mutable_fp64() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.fp64) +inline ::substrait::Type_FP64* Type::mutable_fp64() { + // @@protoc_insertion_point(field_mutable:substrait.Type.fp64) return _internal_mutable_fp64(); } -// .io.substrait.Type.String string = 12; +// .substrait.Type.String string = 12; inline bool Type::_internal_has_string() const { return kind_case() == kString; } @@ -6407,11 +6407,11 @@ inline void Type::clear_string() { clear_has_kind(); } } -inline ::io::substrait::Type_String* Type::release_string() { - // @@protoc_insertion_point(field_release:io.substrait.Type.string) +inline ::substrait::Type_String* Type::release_string() { + // @@protoc_insertion_point(field_release:substrait.Type.string) if (_internal_has_string()) { clear_has_kind(); - ::io::substrait::Type_String* temp = kind_.string_; + ::substrait::Type_String* temp = kind_.string_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6421,48 +6421,48 @@ inline ::io::substrait::Type_String* Type::release_string() { return nullptr; } } -inline const ::io::substrait::Type_String& Type::_internal_string() const { +inline const ::substrait::Type_String& Type::_internal_string() const { return _internal_has_string() ? *kind_.string_ - : reinterpret_cast< ::io::substrait::Type_String&>(::io::substrait::_Type_String_default_instance_); + : reinterpret_cast< ::substrait::Type_String&>(::substrait::_Type_String_default_instance_); } -inline const ::io::substrait::Type_String& Type::string() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.string) +inline const ::substrait::Type_String& Type::string() const { + // @@protoc_insertion_point(field_get:substrait.Type.string) return _internal_string(); } -inline ::io::substrait::Type_String* Type::unsafe_arena_release_string() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.string) +inline ::substrait::Type_String* Type::unsafe_arena_release_string() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.string) if (_internal_has_string()) { clear_has_kind(); - ::io::substrait::Type_String* temp = kind_.string_; + ::substrait::Type_String* temp = kind_.string_; kind_.string_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_string(::io::substrait::Type_String* string) { +inline void Type::unsafe_arena_set_allocated_string(::substrait::Type_String* string) { clear_kind(); if (string) { set_has_string(); kind_.string_ = string; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.string) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.string) } -inline ::io::substrait::Type_String* Type::_internal_mutable_string() { +inline ::substrait::Type_String* Type::_internal_mutable_string() { if (!_internal_has_string()) { clear_kind(); set_has_string(); - kind_.string_ = CreateMaybeMessage< ::io::substrait::Type_String >(GetArena()); + kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArena()); } return kind_.string_; } -inline ::io::substrait::Type_String* Type::mutable_string() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.string) +inline ::substrait::Type_String* Type::mutable_string() { + // @@protoc_insertion_point(field_mutable:substrait.Type.string) return _internal_mutable_string(); } -// .io.substrait.Type.Binary binary = 13; +// .substrait.Type.Binary binary = 13; inline bool Type::_internal_has_binary() const { return kind_case() == kBinary; } @@ -6480,11 +6480,11 @@ inline void Type::clear_binary() { clear_has_kind(); } } -inline ::io::substrait::Type_Binary* Type::release_binary() { - // @@protoc_insertion_point(field_release:io.substrait.Type.binary) +inline ::substrait::Type_Binary* Type::release_binary() { + // @@protoc_insertion_point(field_release:substrait.Type.binary) if (_internal_has_binary()) { clear_has_kind(); - ::io::substrait::Type_Binary* temp = kind_.binary_; + ::substrait::Type_Binary* temp = kind_.binary_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6494,48 +6494,48 @@ inline ::io::substrait::Type_Binary* Type::release_binary() { return nullptr; } } -inline const ::io::substrait::Type_Binary& Type::_internal_binary() const { +inline const ::substrait::Type_Binary& Type::_internal_binary() const { return _internal_has_binary() ? *kind_.binary_ - : reinterpret_cast< ::io::substrait::Type_Binary&>(::io::substrait::_Type_Binary_default_instance_); + : reinterpret_cast< ::substrait::Type_Binary&>(::substrait::_Type_Binary_default_instance_); } -inline const ::io::substrait::Type_Binary& Type::binary() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.binary) +inline const ::substrait::Type_Binary& Type::binary() const { + // @@protoc_insertion_point(field_get:substrait.Type.binary) return _internal_binary(); } -inline ::io::substrait::Type_Binary* Type::unsafe_arena_release_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.binary) +inline ::substrait::Type_Binary* Type::unsafe_arena_release_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.binary) if (_internal_has_binary()) { clear_has_kind(); - ::io::substrait::Type_Binary* temp = kind_.binary_; + ::substrait::Type_Binary* temp = kind_.binary_; kind_.binary_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_binary(::io::substrait::Type_Binary* binary) { +inline void Type::unsafe_arena_set_allocated_binary(::substrait::Type_Binary* binary) { clear_kind(); if (binary) { set_has_binary(); kind_.binary_ = binary; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.binary) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.binary) } -inline ::io::substrait::Type_Binary* Type::_internal_mutable_binary() { +inline ::substrait::Type_Binary* Type::_internal_mutable_binary() { if (!_internal_has_binary()) { clear_kind(); set_has_binary(); - kind_.binary_ = CreateMaybeMessage< ::io::substrait::Type_Binary >(GetArena()); + kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArena()); } return kind_.binary_; } -inline ::io::substrait::Type_Binary* Type::mutable_binary() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.binary) +inline ::substrait::Type_Binary* Type::mutable_binary() { + // @@protoc_insertion_point(field_mutable:substrait.Type.binary) return _internal_mutable_binary(); } -// .io.substrait.Type.Timestamp timestamp = 14; +// .substrait.Type.Timestamp timestamp = 14; inline bool Type::_internal_has_timestamp() const { return kind_case() == kTimestamp; } @@ -6553,11 +6553,11 @@ inline void Type::clear_timestamp() { clear_has_kind(); } } -inline ::io::substrait::Type_Timestamp* Type::release_timestamp() { - // @@protoc_insertion_point(field_release:io.substrait.Type.timestamp) +inline ::substrait::Type_Timestamp* Type::release_timestamp() { + // @@protoc_insertion_point(field_release:substrait.Type.timestamp) if (_internal_has_timestamp()) { clear_has_kind(); - ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + ::substrait::Type_Timestamp* temp = kind_.timestamp_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6567,48 +6567,48 @@ inline ::io::substrait::Type_Timestamp* Type::release_timestamp() { return nullptr; } } -inline const ::io::substrait::Type_Timestamp& Type::_internal_timestamp() const { +inline const ::substrait::Type_Timestamp& Type::_internal_timestamp() const { return _internal_has_timestamp() ? *kind_.timestamp_ - : reinterpret_cast< ::io::substrait::Type_Timestamp&>(::io::substrait::_Type_Timestamp_default_instance_); + : reinterpret_cast< ::substrait::Type_Timestamp&>(::substrait::_Type_Timestamp_default_instance_); } -inline const ::io::substrait::Type_Timestamp& Type::timestamp() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.timestamp) +inline const ::substrait::Type_Timestamp& Type::timestamp() const { + // @@protoc_insertion_point(field_get:substrait.Type.timestamp) return _internal_timestamp(); } -inline ::io::substrait::Type_Timestamp* Type::unsafe_arena_release_timestamp() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.timestamp) +inline ::substrait::Type_Timestamp* Type::unsafe_arena_release_timestamp() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.timestamp) if (_internal_has_timestamp()) { clear_has_kind(); - ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + ::substrait::Type_Timestamp* temp = kind_.timestamp_; kind_.timestamp_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { +inline void Type::unsafe_arena_set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { clear_kind(); if (timestamp) { set_has_timestamp(); kind_.timestamp_ = timestamp; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.timestamp) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.timestamp) } -inline ::io::substrait::Type_Timestamp* Type::_internal_mutable_timestamp() { +inline ::substrait::Type_Timestamp* Type::_internal_mutable_timestamp() { if (!_internal_has_timestamp()) { clear_kind(); set_has_timestamp(); - kind_.timestamp_ = CreateMaybeMessage< ::io::substrait::Type_Timestamp >(GetArena()); + kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArena()); } return kind_.timestamp_; } -inline ::io::substrait::Type_Timestamp* Type::mutable_timestamp() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.timestamp) +inline ::substrait::Type_Timestamp* Type::mutable_timestamp() { + // @@protoc_insertion_point(field_mutable:substrait.Type.timestamp) return _internal_mutable_timestamp(); } -// .io.substrait.Type.Date date = 16; +// .substrait.Type.Date date = 16; inline bool Type::_internal_has_date() const { return kind_case() == kDate; } @@ -6626,11 +6626,11 @@ inline void Type::clear_date() { clear_has_kind(); } } -inline ::io::substrait::Type_Date* Type::release_date() { - // @@protoc_insertion_point(field_release:io.substrait.Type.date) +inline ::substrait::Type_Date* Type::release_date() { + // @@protoc_insertion_point(field_release:substrait.Type.date) if (_internal_has_date()) { clear_has_kind(); - ::io::substrait::Type_Date* temp = kind_.date_; + ::substrait::Type_Date* temp = kind_.date_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6640,48 +6640,48 @@ inline ::io::substrait::Type_Date* Type::release_date() { return nullptr; } } -inline const ::io::substrait::Type_Date& Type::_internal_date() const { +inline const ::substrait::Type_Date& Type::_internal_date() const { return _internal_has_date() ? *kind_.date_ - : reinterpret_cast< ::io::substrait::Type_Date&>(::io::substrait::_Type_Date_default_instance_); + : reinterpret_cast< ::substrait::Type_Date&>(::substrait::_Type_Date_default_instance_); } -inline const ::io::substrait::Type_Date& Type::date() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.date) +inline const ::substrait::Type_Date& Type::date() const { + // @@protoc_insertion_point(field_get:substrait.Type.date) return _internal_date(); } -inline ::io::substrait::Type_Date* Type::unsafe_arena_release_date() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.date) +inline ::substrait::Type_Date* Type::unsafe_arena_release_date() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.date) if (_internal_has_date()) { clear_has_kind(); - ::io::substrait::Type_Date* temp = kind_.date_; + ::substrait::Type_Date* temp = kind_.date_; kind_.date_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_date(::io::substrait::Type_Date* date) { +inline void Type::unsafe_arena_set_allocated_date(::substrait::Type_Date* date) { clear_kind(); if (date) { set_has_date(); kind_.date_ = date; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.date) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.date) } -inline ::io::substrait::Type_Date* Type::_internal_mutable_date() { +inline ::substrait::Type_Date* Type::_internal_mutable_date() { if (!_internal_has_date()) { clear_kind(); set_has_date(); - kind_.date_ = CreateMaybeMessage< ::io::substrait::Type_Date >(GetArena()); + kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArena()); } return kind_.date_; } -inline ::io::substrait::Type_Date* Type::mutable_date() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.date) +inline ::substrait::Type_Date* Type::mutable_date() { + // @@protoc_insertion_point(field_mutable:substrait.Type.date) return _internal_mutable_date(); } -// .io.substrait.Type.Time time = 17; +// .substrait.Type.Time time = 17; inline bool Type::_internal_has_time() const { return kind_case() == kTime; } @@ -6699,11 +6699,11 @@ inline void Type::clear_time() { clear_has_kind(); } } -inline ::io::substrait::Type_Time* Type::release_time() { - // @@protoc_insertion_point(field_release:io.substrait.Type.time) +inline ::substrait::Type_Time* Type::release_time() { + // @@protoc_insertion_point(field_release:substrait.Type.time) if (_internal_has_time()) { clear_has_kind(); - ::io::substrait::Type_Time* temp = kind_.time_; + ::substrait::Type_Time* temp = kind_.time_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6713,48 +6713,48 @@ inline ::io::substrait::Type_Time* Type::release_time() { return nullptr; } } -inline const ::io::substrait::Type_Time& Type::_internal_time() const { +inline const ::substrait::Type_Time& Type::_internal_time() const { return _internal_has_time() ? *kind_.time_ - : reinterpret_cast< ::io::substrait::Type_Time&>(::io::substrait::_Type_Time_default_instance_); + : reinterpret_cast< ::substrait::Type_Time&>(::substrait::_Type_Time_default_instance_); } -inline const ::io::substrait::Type_Time& Type::time() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.time) +inline const ::substrait::Type_Time& Type::time() const { + // @@protoc_insertion_point(field_get:substrait.Type.time) return _internal_time(); } -inline ::io::substrait::Type_Time* Type::unsafe_arena_release_time() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.time) +inline ::substrait::Type_Time* Type::unsafe_arena_release_time() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.time) if (_internal_has_time()) { clear_has_kind(); - ::io::substrait::Type_Time* temp = kind_.time_; + ::substrait::Type_Time* temp = kind_.time_; kind_.time_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_time(::io::substrait::Type_Time* time) { +inline void Type::unsafe_arena_set_allocated_time(::substrait::Type_Time* time) { clear_kind(); if (time) { set_has_time(); kind_.time_ = time; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.time) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.time) } -inline ::io::substrait::Type_Time* Type::_internal_mutable_time() { +inline ::substrait::Type_Time* Type::_internal_mutable_time() { if (!_internal_has_time()) { clear_kind(); set_has_time(); - kind_.time_ = CreateMaybeMessage< ::io::substrait::Type_Time >(GetArena()); + kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArena()); } return kind_.time_; } -inline ::io::substrait::Type_Time* Type::mutable_time() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.time) +inline ::substrait::Type_Time* Type::mutable_time() { + // @@protoc_insertion_point(field_mutable:substrait.Type.time) return _internal_mutable_time(); } -// .io.substrait.Type.IntervalYear interval_year = 19; +// .substrait.Type.IntervalYear interval_year = 19; inline bool Type::_internal_has_interval_year() const { return kind_case() == kIntervalYear; } @@ -6772,11 +6772,11 @@ inline void Type::clear_interval_year() { clear_has_kind(); } } -inline ::io::substrait::Type_IntervalYear* Type::release_interval_year() { - // @@protoc_insertion_point(field_release:io.substrait.Type.interval_year) +inline ::substrait::Type_IntervalYear* Type::release_interval_year() { + // @@protoc_insertion_point(field_release:substrait.Type.interval_year) if (_internal_has_interval_year()) { clear_has_kind(); - ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + ::substrait::Type_IntervalYear* temp = kind_.interval_year_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6786,48 +6786,48 @@ inline ::io::substrait::Type_IntervalYear* Type::release_interval_year() { return nullptr; } } -inline const ::io::substrait::Type_IntervalYear& Type::_internal_interval_year() const { +inline const ::substrait::Type_IntervalYear& Type::_internal_interval_year() const { return _internal_has_interval_year() ? *kind_.interval_year_ - : reinterpret_cast< ::io::substrait::Type_IntervalYear&>(::io::substrait::_Type_IntervalYear_default_instance_); + : reinterpret_cast< ::substrait::Type_IntervalYear&>(::substrait::_Type_IntervalYear_default_instance_); } -inline const ::io::substrait::Type_IntervalYear& Type::interval_year() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.interval_year) +inline const ::substrait::Type_IntervalYear& Type::interval_year() const { + // @@protoc_insertion_point(field_get:substrait.Type.interval_year) return _internal_interval_year(); } -inline ::io::substrait::Type_IntervalYear* Type::unsafe_arena_release_interval_year() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.interval_year) +inline ::substrait::Type_IntervalYear* Type::unsafe_arena_release_interval_year() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.interval_year) if (_internal_has_interval_year()) { clear_has_kind(); - ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + ::substrait::Type_IntervalYear* temp = kind_.interval_year_; kind_.interval_year_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { +inline void Type::unsafe_arena_set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { clear_kind(); if (interval_year) { set_has_interval_year(); kind_.interval_year_ = interval_year; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.interval_year) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.interval_year) } -inline ::io::substrait::Type_IntervalYear* Type::_internal_mutable_interval_year() { +inline ::substrait::Type_IntervalYear* Type::_internal_mutable_interval_year() { if (!_internal_has_interval_year()) { clear_kind(); set_has_interval_year(); - kind_.interval_year_ = CreateMaybeMessage< ::io::substrait::Type_IntervalYear >(GetArena()); + kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArena()); } return kind_.interval_year_; } -inline ::io::substrait::Type_IntervalYear* Type::mutable_interval_year() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.interval_year) +inline ::substrait::Type_IntervalYear* Type::mutable_interval_year() { + // @@protoc_insertion_point(field_mutable:substrait.Type.interval_year) return _internal_mutable_interval_year(); } -// .io.substrait.Type.IntervalDay interval_day = 20; +// .substrait.Type.IntervalDay interval_day = 20; inline bool Type::_internal_has_interval_day() const { return kind_case() == kIntervalDay; } @@ -6845,11 +6845,11 @@ inline void Type::clear_interval_day() { clear_has_kind(); } } -inline ::io::substrait::Type_IntervalDay* Type::release_interval_day() { - // @@protoc_insertion_point(field_release:io.substrait.Type.interval_day) +inline ::substrait::Type_IntervalDay* Type::release_interval_day() { + // @@protoc_insertion_point(field_release:substrait.Type.interval_day) if (_internal_has_interval_day()) { clear_has_kind(); - ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + ::substrait::Type_IntervalDay* temp = kind_.interval_day_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6859,48 +6859,48 @@ inline ::io::substrait::Type_IntervalDay* Type::release_interval_day() { return nullptr; } } -inline const ::io::substrait::Type_IntervalDay& Type::_internal_interval_day() const { +inline const ::substrait::Type_IntervalDay& Type::_internal_interval_day() const { return _internal_has_interval_day() ? *kind_.interval_day_ - : reinterpret_cast< ::io::substrait::Type_IntervalDay&>(::io::substrait::_Type_IntervalDay_default_instance_); + : reinterpret_cast< ::substrait::Type_IntervalDay&>(::substrait::_Type_IntervalDay_default_instance_); } -inline const ::io::substrait::Type_IntervalDay& Type::interval_day() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.interval_day) +inline const ::substrait::Type_IntervalDay& Type::interval_day() const { + // @@protoc_insertion_point(field_get:substrait.Type.interval_day) return _internal_interval_day(); } -inline ::io::substrait::Type_IntervalDay* Type::unsafe_arena_release_interval_day() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.interval_day) +inline ::substrait::Type_IntervalDay* Type::unsafe_arena_release_interval_day() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.interval_day) if (_internal_has_interval_day()) { clear_has_kind(); - ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + ::substrait::Type_IntervalDay* temp = kind_.interval_day_; kind_.interval_day_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { +inline void Type::unsafe_arena_set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { clear_kind(); if (interval_day) { set_has_interval_day(); kind_.interval_day_ = interval_day; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.interval_day) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.interval_day) } -inline ::io::substrait::Type_IntervalDay* Type::_internal_mutable_interval_day() { +inline ::substrait::Type_IntervalDay* Type::_internal_mutable_interval_day() { if (!_internal_has_interval_day()) { clear_kind(); set_has_interval_day(); - kind_.interval_day_ = CreateMaybeMessage< ::io::substrait::Type_IntervalDay >(GetArena()); + kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArena()); } return kind_.interval_day_; } -inline ::io::substrait::Type_IntervalDay* Type::mutable_interval_day() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.interval_day) +inline ::substrait::Type_IntervalDay* Type::mutable_interval_day() { + // @@protoc_insertion_point(field_mutable:substrait.Type.interval_day) return _internal_mutable_interval_day(); } -// .io.substrait.Type.TimestampTZ timestamp_tz = 29; +// .substrait.Type.TimestampTZ timestamp_tz = 29; inline bool Type::_internal_has_timestamp_tz() const { return kind_case() == kTimestampTz; } @@ -6918,11 +6918,11 @@ inline void Type::clear_timestamp_tz() { clear_has_kind(); } } -inline ::io::substrait::Type_TimestampTZ* Type::release_timestamp_tz() { - // @@protoc_insertion_point(field_release:io.substrait.Type.timestamp_tz) +inline ::substrait::Type_TimestampTZ* Type::release_timestamp_tz() { + // @@protoc_insertion_point(field_release:substrait.Type.timestamp_tz) if (_internal_has_timestamp_tz()) { clear_has_kind(); - ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6932,48 +6932,48 @@ inline ::io::substrait::Type_TimestampTZ* Type::release_timestamp_tz() { return nullptr; } } -inline const ::io::substrait::Type_TimestampTZ& Type::_internal_timestamp_tz() const { +inline const ::substrait::Type_TimestampTZ& Type::_internal_timestamp_tz() const { return _internal_has_timestamp_tz() ? *kind_.timestamp_tz_ - : reinterpret_cast< ::io::substrait::Type_TimestampTZ&>(::io::substrait::_Type_TimestampTZ_default_instance_); + : reinterpret_cast< ::substrait::Type_TimestampTZ&>(::substrait::_Type_TimestampTZ_default_instance_); } -inline const ::io::substrait::Type_TimestampTZ& Type::timestamp_tz() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.timestamp_tz) +inline const ::substrait::Type_TimestampTZ& Type::timestamp_tz() const { + // @@protoc_insertion_point(field_get:substrait.Type.timestamp_tz) return _internal_timestamp_tz(); } -inline ::io::substrait::Type_TimestampTZ* Type::unsafe_arena_release_timestamp_tz() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.timestamp_tz) +inline ::substrait::Type_TimestampTZ* Type::unsafe_arena_release_timestamp_tz() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.timestamp_tz) if (_internal_has_timestamp_tz()) { clear_has_kind(); - ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; kind_.timestamp_tz_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { +inline void Type::unsafe_arena_set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { clear_kind(); if (timestamp_tz) { set_has_timestamp_tz(); kind_.timestamp_tz_ = timestamp_tz; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.timestamp_tz) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.timestamp_tz) } -inline ::io::substrait::Type_TimestampTZ* Type::_internal_mutable_timestamp_tz() { +inline ::substrait::Type_TimestampTZ* Type::_internal_mutable_timestamp_tz() { if (!_internal_has_timestamp_tz()) { clear_kind(); set_has_timestamp_tz(); - kind_.timestamp_tz_ = CreateMaybeMessage< ::io::substrait::Type_TimestampTZ >(GetArena()); + kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArena()); } return kind_.timestamp_tz_; } -inline ::io::substrait::Type_TimestampTZ* Type::mutable_timestamp_tz() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.timestamp_tz) +inline ::substrait::Type_TimestampTZ* Type::mutable_timestamp_tz() { + // @@protoc_insertion_point(field_mutable:substrait.Type.timestamp_tz) return _internal_mutable_timestamp_tz(); } -// .io.substrait.Type.UUID uuid = 32; +// .substrait.Type.UUID uuid = 32; inline bool Type::_internal_has_uuid() const { return kind_case() == kUuid; } @@ -6991,11 +6991,11 @@ inline void Type::clear_uuid() { clear_has_kind(); } } -inline ::io::substrait::Type_UUID* Type::release_uuid() { - // @@protoc_insertion_point(field_release:io.substrait.Type.uuid) +inline ::substrait::Type_UUID* Type::release_uuid() { + // @@protoc_insertion_point(field_release:substrait.Type.uuid) if (_internal_has_uuid()) { clear_has_kind(); - ::io::substrait::Type_UUID* temp = kind_.uuid_; + ::substrait::Type_UUID* temp = kind_.uuid_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7005,48 +7005,48 @@ inline ::io::substrait::Type_UUID* Type::release_uuid() { return nullptr; } } -inline const ::io::substrait::Type_UUID& Type::_internal_uuid() const { +inline const ::substrait::Type_UUID& Type::_internal_uuid() const { return _internal_has_uuid() ? *kind_.uuid_ - : reinterpret_cast< ::io::substrait::Type_UUID&>(::io::substrait::_Type_UUID_default_instance_); + : reinterpret_cast< ::substrait::Type_UUID&>(::substrait::_Type_UUID_default_instance_); } -inline const ::io::substrait::Type_UUID& Type::uuid() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.uuid) +inline const ::substrait::Type_UUID& Type::uuid() const { + // @@protoc_insertion_point(field_get:substrait.Type.uuid) return _internal_uuid(); } -inline ::io::substrait::Type_UUID* Type::unsafe_arena_release_uuid() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.uuid) +inline ::substrait::Type_UUID* Type::unsafe_arena_release_uuid() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.uuid) if (_internal_has_uuid()) { clear_has_kind(); - ::io::substrait::Type_UUID* temp = kind_.uuid_; + ::substrait::Type_UUID* temp = kind_.uuid_; kind_.uuid_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_uuid(::io::substrait::Type_UUID* uuid) { +inline void Type::unsafe_arena_set_allocated_uuid(::substrait::Type_UUID* uuid) { clear_kind(); if (uuid) { set_has_uuid(); kind_.uuid_ = uuid; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.uuid) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.uuid) } -inline ::io::substrait::Type_UUID* Type::_internal_mutable_uuid() { +inline ::substrait::Type_UUID* Type::_internal_mutable_uuid() { if (!_internal_has_uuid()) { clear_kind(); set_has_uuid(); - kind_.uuid_ = CreateMaybeMessage< ::io::substrait::Type_UUID >(GetArena()); + kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArena()); } return kind_.uuid_; } -inline ::io::substrait::Type_UUID* Type::mutable_uuid() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.uuid) +inline ::substrait::Type_UUID* Type::mutable_uuid() { + // @@protoc_insertion_point(field_mutable:substrait.Type.uuid) return _internal_mutable_uuid(); } -// .io.substrait.Type.FixedChar fixed_char = 21; +// .substrait.Type.FixedChar fixed_char = 21; inline bool Type::_internal_has_fixed_char() const { return kind_case() == kFixedChar; } @@ -7064,11 +7064,11 @@ inline void Type::clear_fixed_char() { clear_has_kind(); } } -inline ::io::substrait::Type_FixedChar* Type::release_fixed_char() { - // @@protoc_insertion_point(field_release:io.substrait.Type.fixed_char) +inline ::substrait::Type_FixedChar* Type::release_fixed_char() { + // @@protoc_insertion_point(field_release:substrait.Type.fixed_char) if (_internal_has_fixed_char()) { clear_has_kind(); - ::io::substrait::Type_FixedChar* temp = kind_.fixed_char_; + ::substrait::Type_FixedChar* temp = kind_.fixed_char_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7078,48 +7078,48 @@ inline ::io::substrait::Type_FixedChar* Type::release_fixed_char() { return nullptr; } } -inline const ::io::substrait::Type_FixedChar& Type::_internal_fixed_char() const { +inline const ::substrait::Type_FixedChar& Type::_internal_fixed_char() const { return _internal_has_fixed_char() ? *kind_.fixed_char_ - : reinterpret_cast< ::io::substrait::Type_FixedChar&>(::io::substrait::_Type_FixedChar_default_instance_); + : reinterpret_cast< ::substrait::Type_FixedChar&>(::substrait::_Type_FixedChar_default_instance_); } -inline const ::io::substrait::Type_FixedChar& Type::fixed_char() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.fixed_char) +inline const ::substrait::Type_FixedChar& Type::fixed_char() const { + // @@protoc_insertion_point(field_get:substrait.Type.fixed_char) return _internal_fixed_char(); } -inline ::io::substrait::Type_FixedChar* Type::unsafe_arena_release_fixed_char() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.fixed_char) +inline ::substrait::Type_FixedChar* Type::unsafe_arena_release_fixed_char() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fixed_char) if (_internal_has_fixed_char()) { clear_has_kind(); - ::io::substrait::Type_FixedChar* temp = kind_.fixed_char_; + ::substrait::Type_FixedChar* temp = kind_.fixed_char_; kind_.fixed_char_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_fixed_char(::io::substrait::Type_FixedChar* fixed_char) { +inline void Type::unsafe_arena_set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char) { clear_kind(); if (fixed_char) { set_has_fixed_char(); kind_.fixed_char_ = fixed_char; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.fixed_char) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fixed_char) } -inline ::io::substrait::Type_FixedChar* Type::_internal_mutable_fixed_char() { +inline ::substrait::Type_FixedChar* Type::_internal_mutable_fixed_char() { if (!_internal_has_fixed_char()) { clear_kind(); set_has_fixed_char(); - kind_.fixed_char_ = CreateMaybeMessage< ::io::substrait::Type_FixedChar >(GetArena()); + kind_.fixed_char_ = CreateMaybeMessage< ::substrait::Type_FixedChar >(GetArena()); } return kind_.fixed_char_; } -inline ::io::substrait::Type_FixedChar* Type::mutable_fixed_char() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.fixed_char) +inline ::substrait::Type_FixedChar* Type::mutable_fixed_char() { + // @@protoc_insertion_point(field_mutable:substrait.Type.fixed_char) return _internal_mutable_fixed_char(); } -// .io.substrait.Type.VarChar varchar = 22; +// .substrait.Type.VarChar varchar = 22; inline bool Type::_internal_has_varchar() const { return kind_case() == kVarchar; } @@ -7137,11 +7137,11 @@ inline void Type::clear_varchar() { clear_has_kind(); } } -inline ::io::substrait::Type_VarChar* Type::release_varchar() { - // @@protoc_insertion_point(field_release:io.substrait.Type.varchar) +inline ::substrait::Type_VarChar* Type::release_varchar() { + // @@protoc_insertion_point(field_release:substrait.Type.varchar) if (_internal_has_varchar()) { clear_has_kind(); - ::io::substrait::Type_VarChar* temp = kind_.varchar_; + ::substrait::Type_VarChar* temp = kind_.varchar_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7151,48 +7151,48 @@ inline ::io::substrait::Type_VarChar* Type::release_varchar() { return nullptr; } } -inline const ::io::substrait::Type_VarChar& Type::_internal_varchar() const { +inline const ::substrait::Type_VarChar& Type::_internal_varchar() const { return _internal_has_varchar() ? *kind_.varchar_ - : reinterpret_cast< ::io::substrait::Type_VarChar&>(::io::substrait::_Type_VarChar_default_instance_); + : reinterpret_cast< ::substrait::Type_VarChar&>(::substrait::_Type_VarChar_default_instance_); } -inline const ::io::substrait::Type_VarChar& Type::varchar() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.varchar) +inline const ::substrait::Type_VarChar& Type::varchar() const { + // @@protoc_insertion_point(field_get:substrait.Type.varchar) return _internal_varchar(); } -inline ::io::substrait::Type_VarChar* Type::unsafe_arena_release_varchar() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.varchar) +inline ::substrait::Type_VarChar* Type::unsafe_arena_release_varchar() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.varchar) if (_internal_has_varchar()) { clear_has_kind(); - ::io::substrait::Type_VarChar* temp = kind_.varchar_; + ::substrait::Type_VarChar* temp = kind_.varchar_; kind_.varchar_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_varchar(::io::substrait::Type_VarChar* varchar) { +inline void Type::unsafe_arena_set_allocated_varchar(::substrait::Type_VarChar* varchar) { clear_kind(); if (varchar) { set_has_varchar(); kind_.varchar_ = varchar; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.varchar) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.varchar) } -inline ::io::substrait::Type_VarChar* Type::_internal_mutable_varchar() { +inline ::substrait::Type_VarChar* Type::_internal_mutable_varchar() { if (!_internal_has_varchar()) { clear_kind(); set_has_varchar(); - kind_.varchar_ = CreateMaybeMessage< ::io::substrait::Type_VarChar >(GetArena()); + kind_.varchar_ = CreateMaybeMessage< ::substrait::Type_VarChar >(GetArena()); } return kind_.varchar_; } -inline ::io::substrait::Type_VarChar* Type::mutable_varchar() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.varchar) +inline ::substrait::Type_VarChar* Type::mutable_varchar() { + // @@protoc_insertion_point(field_mutable:substrait.Type.varchar) return _internal_mutable_varchar(); } -// .io.substrait.Type.FixedBinary fixed_binary = 23; +// .substrait.Type.FixedBinary fixed_binary = 23; inline bool Type::_internal_has_fixed_binary() const { return kind_case() == kFixedBinary; } @@ -7210,11 +7210,11 @@ inline void Type::clear_fixed_binary() { clear_has_kind(); } } -inline ::io::substrait::Type_FixedBinary* Type::release_fixed_binary() { - // @@protoc_insertion_point(field_release:io.substrait.Type.fixed_binary) +inline ::substrait::Type_FixedBinary* Type::release_fixed_binary() { + // @@protoc_insertion_point(field_release:substrait.Type.fixed_binary) if (_internal_has_fixed_binary()) { clear_has_kind(); - ::io::substrait::Type_FixedBinary* temp = kind_.fixed_binary_; + ::substrait::Type_FixedBinary* temp = kind_.fixed_binary_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7224,48 +7224,48 @@ inline ::io::substrait::Type_FixedBinary* Type::release_fixed_binary() { return nullptr; } } -inline const ::io::substrait::Type_FixedBinary& Type::_internal_fixed_binary() const { +inline const ::substrait::Type_FixedBinary& Type::_internal_fixed_binary() const { return _internal_has_fixed_binary() ? *kind_.fixed_binary_ - : reinterpret_cast< ::io::substrait::Type_FixedBinary&>(::io::substrait::_Type_FixedBinary_default_instance_); + : reinterpret_cast< ::substrait::Type_FixedBinary&>(::substrait::_Type_FixedBinary_default_instance_); } -inline const ::io::substrait::Type_FixedBinary& Type::fixed_binary() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.fixed_binary) +inline const ::substrait::Type_FixedBinary& Type::fixed_binary() const { + // @@protoc_insertion_point(field_get:substrait.Type.fixed_binary) return _internal_fixed_binary(); } -inline ::io::substrait::Type_FixedBinary* Type::unsafe_arena_release_fixed_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.fixed_binary) +inline ::substrait::Type_FixedBinary* Type::unsafe_arena_release_fixed_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fixed_binary) if (_internal_has_fixed_binary()) { clear_has_kind(); - ::io::substrait::Type_FixedBinary* temp = kind_.fixed_binary_; + ::substrait::Type_FixedBinary* temp = kind_.fixed_binary_; kind_.fixed_binary_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_fixed_binary(::io::substrait::Type_FixedBinary* fixed_binary) { +inline void Type::unsafe_arena_set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary) { clear_kind(); if (fixed_binary) { set_has_fixed_binary(); kind_.fixed_binary_ = fixed_binary; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.fixed_binary) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fixed_binary) } -inline ::io::substrait::Type_FixedBinary* Type::_internal_mutable_fixed_binary() { +inline ::substrait::Type_FixedBinary* Type::_internal_mutable_fixed_binary() { if (!_internal_has_fixed_binary()) { clear_kind(); set_has_fixed_binary(); - kind_.fixed_binary_ = CreateMaybeMessage< ::io::substrait::Type_FixedBinary >(GetArena()); + kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::Type_FixedBinary >(GetArena()); } return kind_.fixed_binary_; } -inline ::io::substrait::Type_FixedBinary* Type::mutable_fixed_binary() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.fixed_binary) +inline ::substrait::Type_FixedBinary* Type::mutable_fixed_binary() { + // @@protoc_insertion_point(field_mutable:substrait.Type.fixed_binary) return _internal_mutable_fixed_binary(); } -// .io.substrait.Type.Decimal decimal = 24; +// .substrait.Type.Decimal decimal = 24; inline bool Type::_internal_has_decimal() const { return kind_case() == kDecimal; } @@ -7283,11 +7283,11 @@ inline void Type::clear_decimal() { clear_has_kind(); } } -inline ::io::substrait::Type_Decimal* Type::release_decimal() { - // @@protoc_insertion_point(field_release:io.substrait.Type.decimal) +inline ::substrait::Type_Decimal* Type::release_decimal() { + // @@protoc_insertion_point(field_release:substrait.Type.decimal) if (_internal_has_decimal()) { clear_has_kind(); - ::io::substrait::Type_Decimal* temp = kind_.decimal_; + ::substrait::Type_Decimal* temp = kind_.decimal_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7297,48 +7297,48 @@ inline ::io::substrait::Type_Decimal* Type::release_decimal() { return nullptr; } } -inline const ::io::substrait::Type_Decimal& Type::_internal_decimal() const { +inline const ::substrait::Type_Decimal& Type::_internal_decimal() const { return _internal_has_decimal() ? *kind_.decimal_ - : reinterpret_cast< ::io::substrait::Type_Decimal&>(::io::substrait::_Type_Decimal_default_instance_); + : reinterpret_cast< ::substrait::Type_Decimal&>(::substrait::_Type_Decimal_default_instance_); } -inline const ::io::substrait::Type_Decimal& Type::decimal() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.decimal) +inline const ::substrait::Type_Decimal& Type::decimal() const { + // @@protoc_insertion_point(field_get:substrait.Type.decimal) return _internal_decimal(); } -inline ::io::substrait::Type_Decimal* Type::unsafe_arena_release_decimal() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.decimal) +inline ::substrait::Type_Decimal* Type::unsafe_arena_release_decimal() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.decimal) if (_internal_has_decimal()) { clear_has_kind(); - ::io::substrait::Type_Decimal* temp = kind_.decimal_; + ::substrait::Type_Decimal* temp = kind_.decimal_; kind_.decimal_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_decimal(::io::substrait::Type_Decimal* decimal) { +inline void Type::unsafe_arena_set_allocated_decimal(::substrait::Type_Decimal* decimal) { clear_kind(); if (decimal) { set_has_decimal(); kind_.decimal_ = decimal; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.decimal) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.decimal) } -inline ::io::substrait::Type_Decimal* Type::_internal_mutable_decimal() { +inline ::substrait::Type_Decimal* Type::_internal_mutable_decimal() { if (!_internal_has_decimal()) { clear_kind(); set_has_decimal(); - kind_.decimal_ = CreateMaybeMessage< ::io::substrait::Type_Decimal >(GetArena()); + kind_.decimal_ = CreateMaybeMessage< ::substrait::Type_Decimal >(GetArena()); } return kind_.decimal_; } -inline ::io::substrait::Type_Decimal* Type::mutable_decimal() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.decimal) +inline ::substrait::Type_Decimal* Type::mutable_decimal() { + // @@protoc_insertion_point(field_mutable:substrait.Type.decimal) return _internal_mutable_decimal(); } -// .io.substrait.Type.Struct struct = 25; +// .substrait.Type.Struct struct = 25; inline bool Type::_internal_has_struct_() const { return kind_case() == kStruct; } @@ -7356,11 +7356,11 @@ inline void Type::clear_struct_() { clear_has_kind(); } } -inline ::io::substrait::Type_Struct* Type::release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.Type.struct) +inline ::substrait::Type_Struct* Type::release_struct_() { + // @@protoc_insertion_point(field_release:substrait.Type.struct) if (_internal_has_struct_()) { clear_has_kind(); - ::io::substrait::Type_Struct* temp = kind_.struct__; + ::substrait::Type_Struct* temp = kind_.struct__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7370,48 +7370,48 @@ inline ::io::substrait::Type_Struct* Type::release_struct_() { return nullptr; } } -inline const ::io::substrait::Type_Struct& Type::_internal_struct_() const { +inline const ::substrait::Type_Struct& Type::_internal_struct_() const { return _internal_has_struct_() ? *kind_.struct__ - : reinterpret_cast< ::io::substrait::Type_Struct&>(::io::substrait::_Type_Struct_default_instance_); + : reinterpret_cast< ::substrait::Type_Struct&>(::substrait::_Type_Struct_default_instance_); } -inline const ::io::substrait::Type_Struct& Type::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.struct) +inline const ::substrait::Type_Struct& Type::struct_() const { + // @@protoc_insertion_point(field_get:substrait.Type.struct) return _internal_struct_(); } -inline ::io::substrait::Type_Struct* Type::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.struct) +inline ::substrait::Type_Struct* Type::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.struct) if (_internal_has_struct_()) { clear_has_kind(); - ::io::substrait::Type_Struct* temp = kind_.struct__; + ::substrait::Type_Struct* temp = kind_.struct__; kind_.struct__ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_struct_(::io::substrait::Type_Struct* struct_) { +inline void Type::unsafe_arena_set_allocated_struct_(::substrait::Type_Struct* struct_) { clear_kind(); if (struct_) { set_has_struct_(); kind_.struct__ = struct_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.struct) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.struct) } -inline ::io::substrait::Type_Struct* Type::_internal_mutable_struct_() { +inline ::substrait::Type_Struct* Type::_internal_mutable_struct_() { if (!_internal_has_struct_()) { clear_kind(); set_has_struct_(); - kind_.struct__ = CreateMaybeMessage< ::io::substrait::Type_Struct >(GetArena()); + kind_.struct__ = CreateMaybeMessage< ::substrait::Type_Struct >(GetArena()); } return kind_.struct__; } -inline ::io::substrait::Type_Struct* Type::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.struct) +inline ::substrait::Type_Struct* Type::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:substrait.Type.struct) return _internal_mutable_struct_(); } -// .io.substrait.Type.List list = 27; +// .substrait.Type.List list = 27; inline bool Type::_internal_has_list() const { return kind_case() == kList; } @@ -7429,11 +7429,11 @@ inline void Type::clear_list() { clear_has_kind(); } } -inline ::io::substrait::Type_List* Type::release_list() { - // @@protoc_insertion_point(field_release:io.substrait.Type.list) +inline ::substrait::Type_List* Type::release_list() { + // @@protoc_insertion_point(field_release:substrait.Type.list) if (_internal_has_list()) { clear_has_kind(); - ::io::substrait::Type_List* temp = kind_.list_; + ::substrait::Type_List* temp = kind_.list_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7443,48 +7443,48 @@ inline ::io::substrait::Type_List* Type::release_list() { return nullptr; } } -inline const ::io::substrait::Type_List& Type::_internal_list() const { +inline const ::substrait::Type_List& Type::_internal_list() const { return _internal_has_list() ? *kind_.list_ - : reinterpret_cast< ::io::substrait::Type_List&>(::io::substrait::_Type_List_default_instance_); + : reinterpret_cast< ::substrait::Type_List&>(::substrait::_Type_List_default_instance_); } -inline const ::io::substrait::Type_List& Type::list() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.list) +inline const ::substrait::Type_List& Type::list() const { + // @@protoc_insertion_point(field_get:substrait.Type.list) return _internal_list(); } -inline ::io::substrait::Type_List* Type::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.list) +inline ::substrait::Type_List* Type::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.list) if (_internal_has_list()) { clear_has_kind(); - ::io::substrait::Type_List* temp = kind_.list_; + ::substrait::Type_List* temp = kind_.list_; kind_.list_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_list(::io::substrait::Type_List* list) { +inline void Type::unsafe_arena_set_allocated_list(::substrait::Type_List* list) { clear_kind(); if (list) { set_has_list(); kind_.list_ = list; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.list) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.list) } -inline ::io::substrait::Type_List* Type::_internal_mutable_list() { +inline ::substrait::Type_List* Type::_internal_mutable_list() { if (!_internal_has_list()) { clear_kind(); set_has_list(); - kind_.list_ = CreateMaybeMessage< ::io::substrait::Type_List >(GetArena()); + kind_.list_ = CreateMaybeMessage< ::substrait::Type_List >(GetArena()); } return kind_.list_; } -inline ::io::substrait::Type_List* Type::mutable_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.list) +inline ::substrait::Type_List* Type::mutable_list() { + // @@protoc_insertion_point(field_mutable:substrait.Type.list) return _internal_mutable_list(); } -// .io.substrait.Type.Map map = 28; +// .substrait.Type.Map map = 28; inline bool Type::_internal_has_map() const { return kind_case() == kMap; } @@ -7502,11 +7502,11 @@ inline void Type::clear_map() { clear_has_kind(); } } -inline ::io::substrait::Type_Map* Type::release_map() { - // @@protoc_insertion_point(field_release:io.substrait.Type.map) +inline ::substrait::Type_Map* Type::release_map() { + // @@protoc_insertion_point(field_release:substrait.Type.map) if (_internal_has_map()) { clear_has_kind(); - ::io::substrait::Type_Map* temp = kind_.map_; + ::substrait::Type_Map* temp = kind_.map_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7516,44 +7516,44 @@ inline ::io::substrait::Type_Map* Type::release_map() { return nullptr; } } -inline const ::io::substrait::Type_Map& Type::_internal_map() const { +inline const ::substrait::Type_Map& Type::_internal_map() const { return _internal_has_map() ? *kind_.map_ - : reinterpret_cast< ::io::substrait::Type_Map&>(::io::substrait::_Type_Map_default_instance_); + : reinterpret_cast< ::substrait::Type_Map&>(::substrait::_Type_Map_default_instance_); } -inline const ::io::substrait::Type_Map& Type::map() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.map) +inline const ::substrait::Type_Map& Type::map() const { + // @@protoc_insertion_point(field_get:substrait.Type.map) return _internal_map(); } -inline ::io::substrait::Type_Map* Type::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.Type.map) +inline ::substrait::Type_Map* Type::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.map) if (_internal_has_map()) { clear_has_kind(); - ::io::substrait::Type_Map* temp = kind_.map_; + ::substrait::Type_Map* temp = kind_.map_; kind_.map_ = nullptr; return temp; } else { return nullptr; } } -inline void Type::unsafe_arena_set_allocated_map(::io::substrait::Type_Map* map) { +inline void Type::unsafe_arena_set_allocated_map(::substrait::Type_Map* map) { clear_kind(); if (map) { set_has_map(); kind_.map_ = map; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.Type.map) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.map) } -inline ::io::substrait::Type_Map* Type::_internal_mutable_map() { +inline ::substrait::Type_Map* Type::_internal_mutable_map() { if (!_internal_has_map()) { clear_kind(); set_has_map(); - kind_.map_ = CreateMaybeMessage< ::io::substrait::Type_Map >(GetArena()); + kind_.map_ = CreateMaybeMessage< ::substrait::Type_Map >(GetArena()); } return kind_.map_; } -inline ::io::substrait::Type_Map* Type::mutable_map() { - // @@protoc_insertion_point(field_mutable:io.substrait.Type.map) +inline ::substrait::Type_Map* Type::mutable_map() { + // @@protoc_insertion_point(field_mutable:substrait.Type.map) return _internal_mutable_map(); } @@ -7587,12 +7587,12 @@ inline void Type::_internal_set_user_defined_type_reference(::PROTOBUF_NAMESPACE kind_.user_defined_type_reference_ = value; } inline ::PROTOBUF_NAMESPACE_ID::uint32 Type::user_defined_type_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.Type.user_defined_type_reference) + // @@protoc_insertion_point(field_get:substrait.Type.user_defined_type_reference) return _internal_user_defined_type_reference(); } inline void Type::set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_user_defined_type_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.Type.user_defined_type_reference) + // @@protoc_insertion_point(field_set:substrait.Type.user_defined_type_reference) } inline bool Type::has_kind() const { @@ -7619,70 +7619,70 @@ inline void NamedStruct::clear_names() { names_.Clear(); } inline std::string* NamedStruct::add_names() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_add_mutable:substrait.NamedStruct.names) return _internal_add_names(); } inline const std::string& NamedStruct::_internal_names(int index) const { return names_.Get(index); } inline const std::string& NamedStruct::names(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_get:substrait.NamedStruct.names) return _internal_names(index); } inline std::string* NamedStruct::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_mutable:substrait.NamedStruct.names) return names_.Mutable(index); } inline void NamedStruct::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_set:substrait.NamedStruct.names) names_.Mutable(index)->assign(value); } inline void NamedStruct::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_set:substrait.NamedStruct.names) names_.Mutable(index)->assign(std::move(value)); } inline void NamedStruct::set_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_set_char:substrait.NamedStruct.names) } inline void NamedStruct::set_names(int index, const char* value, size_t size) { names_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_set_pointer:substrait.NamedStruct.names) } inline std::string* NamedStruct::_internal_add_names() { return names_.Add(); } inline void NamedStruct::add_names(const std::string& value) { names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_add:substrait.NamedStruct.names) } inline void NamedStruct::add_names(std::string&& value) { names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_add:substrait.NamedStruct.names) } inline void NamedStruct::add_names(const char* value) { GOOGLE_DCHECK(value != nullptr); names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_add_char:substrait.NamedStruct.names) } inline void NamedStruct::add_names(const char* value, size_t size) { names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_add_pointer:substrait.NamedStruct.names) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& NamedStruct::names() const { - // @@protoc_insertion_point(field_list:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_list:substrait.NamedStruct.names) return names_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* NamedStruct::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.NamedStruct.names) + // @@protoc_insertion_point(field_mutable_list:substrait.NamedStruct.names) return &names_; } -// .io.substrait.Type.Struct struct = 2; +// .substrait.Type.Struct struct = 2; inline bool NamedStruct::_internal_has_struct_() const { return this != internal_default_instance() && struct__ != nullptr; } @@ -7695,17 +7695,17 @@ inline void NamedStruct::clear_struct_() { } struct__ = nullptr; } -inline const ::io::substrait::Type_Struct& NamedStruct::_internal_struct_() const { - const ::io::substrait::Type_Struct* p = struct__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_Type_Struct_default_instance_); +inline const ::substrait::Type_Struct& NamedStruct::_internal_struct_() const { + const ::substrait::Type_Struct* p = struct__; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_Type_Struct_default_instance_); } -inline const ::io::substrait::Type_Struct& NamedStruct::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.NamedStruct.struct) +inline const ::substrait::Type_Struct& NamedStruct::struct_() const { + // @@protoc_insertion_point(field_get:substrait.NamedStruct.struct) return _internal_struct_(); } inline void NamedStruct::unsafe_arena_set_allocated_struct_( - ::io::substrait::Type_Struct* struct_) { + ::substrait::Type_Struct* struct_) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); } @@ -7715,37 +7715,37 @@ inline void NamedStruct::unsafe_arena_set_allocated_struct_( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.NamedStruct.struct) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.NamedStruct.struct) } -inline ::io::substrait::Type_Struct* NamedStruct::release_struct_() { +inline ::substrait::Type_Struct* NamedStruct::release_struct_() { - ::io::substrait::Type_Struct* temp = struct__; + ::substrait::Type_Struct* temp = struct__; struct__ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::Type_Struct* NamedStruct::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.NamedStruct.struct) +inline ::substrait::Type_Struct* NamedStruct::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_release:substrait.NamedStruct.struct) - ::io::substrait::Type_Struct* temp = struct__; + ::substrait::Type_Struct* temp = struct__; struct__ = nullptr; return temp; } -inline ::io::substrait::Type_Struct* NamedStruct::_internal_mutable_struct_() { +inline ::substrait::Type_Struct* NamedStruct::_internal_mutable_struct_() { if (struct__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::Type_Struct>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type_Struct>(GetArena()); struct__ = p; } return struct__; } -inline ::io::substrait::Type_Struct* NamedStruct::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.NamedStruct.struct) +inline ::substrait::Type_Struct* NamedStruct::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:substrait.NamedStruct.struct) return _internal_mutable_struct_(); } -inline void NamedStruct::set_allocated_struct_(::io::substrait::Type_Struct* struct_) { +inline void NamedStruct::set_allocated_struct_(::substrait::Type_Struct* struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete struct__; @@ -7762,7 +7762,7 @@ inline void NamedStruct::set_allocated_struct_(::io::substrait::Type_Struct* str } struct__ = struct_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.NamedStruct.struct) + // @@protoc_insertion_point(field_set_allocated:substrait.NamedStruct.struct) } #ifdef __GNUC__ @@ -7820,14 +7820,13 @@ inline void NamedStruct::set_allocated_struct_(::io::substrait::Type_Struct* str // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template <> struct is_proto_enum< ::io::substrait::Type_Nullability> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::Type_Nullability> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::Type_Nullability>() { - return ::io::substrait::Type_Nullability_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::Type_Nullability>() { + return ::substrait::Type_Nullability_descriptor(); } PROTOBUF_NAMESPACE_CLOSE @@ -7835,4 +7834,4 @@ PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_type_2eproto +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_2eproto diff --git a/cpp/src/generated/substrait/type_expressions.pb.cc b/cpp/src/generated/substrait/type_expressions.pb.cc index 31f8bb35418..ff92154ed83 100644 --- a/cpp/src/generated/substrait/type_expressions.pb.cc +++ b/cpp/src/generated/substrait/type_expressions.pb.cc @@ -1,7 +1,7 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: type_expressions.proto +// source: substrait/type_expressions.proto -#include "type_expressions.pb.h" +#include "substrait/type_expressions.pb.h" #include @@ -16,7 +16,6 @@ #include PROTOBUF_PRAGMA_INIT_SEG -namespace io { namespace substrait { constexpr DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) @@ -197,7 +196,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ReturnProg constexpr DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : assignments_() - , finalexpression_(nullptr){} + , final_expression_(nullptr){} struct DerivationExpression_ReturnProgramDefaultTypeInternal { constexpr DerivationExpression_ReturnProgramDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -220,118 +219,117 @@ struct DerivationExpressionDefaultTypeInternal { }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpressionDefaultTypeInternal _DerivationExpression_default_instance_; } // namespace substrait -} // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_type_5fexpressions_2eproto[14]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_type_5fexpressions_2eproto[2]; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_type_5fexpressions_2eproto = nullptr; +static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ftype_5fexpressions_2eproto[14]; +static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[2]; +static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ftype_5fexpressions_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedChar, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, length_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionVarChar, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, length_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, length_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionFixedBinary, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, length_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, scale_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, precision_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionDecimal, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, scale_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, precision_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, types_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionStruct, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, types_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionNamedStruct, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionNamedStruct, names_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionNamedStruct, struct__), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, names_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, struct__), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionList, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, type_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, key_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, value_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ExpressionMap, nullability_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, key_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, value_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, variation_pointer_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, nullability_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_IfElse, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_IfElse, if_condition_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_IfElse, if_return_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_IfElse, else_return_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, if_condition_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, if_return_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, else_return_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_UnaryOp, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_UnaryOp, op_type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_UnaryOp, arg_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, op_type_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, arg_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_BinaryOp, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_BinaryOp, op_type_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_BinaryOp, arg1_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_BinaryOp, arg2_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, op_type_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, arg1_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, arg2_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram_Assignment, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram_Assignment, name_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram_Assignment, expression_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, name_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, expression_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram, assignments_), - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression_ReturnProgram, finalexpression_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, assignments_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, final_expression_), ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression, _internal_metadata_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, _internal_metadata_), ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression, _oneof_case_[0]), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, _oneof_case_[0]), ~0u, // no _weak_field_map_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -364,167 +362,169 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_type_5fexpressions_2eproto::of ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::DerivationExpression, kind_), + PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, kind_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::DerivationExpression_ExpressionFixedChar)}, - { 8, -1, sizeof(::io::substrait::DerivationExpression_ExpressionVarChar)}, - { 16, -1, sizeof(::io::substrait::DerivationExpression_ExpressionFixedBinary)}, - { 24, -1, sizeof(::io::substrait::DerivationExpression_ExpressionDecimal)}, - { 33, -1, sizeof(::io::substrait::DerivationExpression_ExpressionStruct)}, - { 41, -1, sizeof(::io::substrait::DerivationExpression_ExpressionNamedStruct)}, - { 48, -1, sizeof(::io::substrait::DerivationExpression_ExpressionList)}, - { 56, -1, sizeof(::io::substrait::DerivationExpression_ExpressionMap)}, - { 65, -1, sizeof(::io::substrait::DerivationExpression_IfElse)}, - { 73, -1, sizeof(::io::substrait::DerivationExpression_UnaryOp)}, - { 80, -1, sizeof(::io::substrait::DerivationExpression_BinaryOp)}, - { 88, -1, sizeof(::io::substrait::DerivationExpression_ReturnProgram_Assignment)}, - { 95, -1, sizeof(::io::substrait::DerivationExpression_ReturnProgram)}, - { 102, -1, sizeof(::io::substrait::DerivationExpression)}, + { 0, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedChar)}, + { 8, -1, sizeof(::substrait::DerivationExpression_ExpressionVarChar)}, + { 16, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedBinary)}, + { 24, -1, sizeof(::substrait::DerivationExpression_ExpressionDecimal)}, + { 33, -1, sizeof(::substrait::DerivationExpression_ExpressionStruct)}, + { 41, -1, sizeof(::substrait::DerivationExpression_ExpressionNamedStruct)}, + { 48, -1, sizeof(::substrait::DerivationExpression_ExpressionList)}, + { 56, -1, sizeof(::substrait::DerivationExpression_ExpressionMap)}, + { 65, -1, sizeof(::substrait::DerivationExpression_IfElse)}, + { 73, -1, sizeof(::substrait::DerivationExpression_UnaryOp)}, + { 80, -1, sizeof(::substrait::DerivationExpression_BinaryOp)}, + { 88, -1, sizeof(::substrait::DerivationExpression_ReturnProgram_Assignment)}, + { 95, -1, sizeof(::substrait::DerivationExpression_ReturnProgram)}, + { 102, -1, sizeof(::substrait::DerivationExpression)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionVarChar_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionDecimal_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionStruct_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionNamedStruct_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionList_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_ExpressionMap_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_IfElse_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_UnaryOp_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_BinaryOp_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_ReturnProgram_Assignment_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_ReturnProgram_default_instance_), - reinterpret_cast(&::io::substrait::_DerivationExpression_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionVarChar_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionDecimal_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionStruct_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionNamedStruct_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionList_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ExpressionMap_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_IfElse_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_UnaryOp_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_BinaryOp_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ReturnProgram_Assignment_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_ReturnProgram_default_instance_), + reinterpret_cast(&::substrait::_DerivationExpression_default_instance_), }; -const char descriptor_table_protodef_type_5fexpressions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\026type_expressions.proto\022\014io.substrait\032\n" - "type.proto\"\235\036\n\024DerivationExpression\022*\n\004b" - "ool\030\001 \001(\0132\032.io.substrait.Type.BooleanH\000\022" - "#\n\002i8\030\002 \001(\0132\025.io.substrait.Type.I8H\000\022%\n\003" - "i16\030\003 \001(\0132\026.io.substrait.Type.I16H\000\022%\n\003i" - "32\030\005 \001(\0132\026.io.substrait.Type.I32H\000\022%\n\003i6" - "4\030\007 \001(\0132\026.io.substrait.Type.I64H\000\022\'\n\004fp3" - "2\030\n \001(\0132\027.io.substrait.Type.FP32H\000\022\'\n\004fp" - "64\030\013 \001(\0132\027.io.substrait.Type.FP64H\000\022+\n\006s" - "tring\030\014 \001(\0132\031.io.substrait.Type.StringH\000" - "\022+\n\006binary\030\r \001(\0132\031.io.substrait.Type.Bin" - "aryH\000\0221\n\ttimestamp\030\016 \001(\0132\034.io.substrait." - "Type.TimestampH\000\022\'\n\004date\030\020 \001(\0132\027.io.subs" - "trait.Type.DateH\000\022\'\n\004time\030\021 \001(\0132\027.io.sub" - "strait.Type.TimeH\000\0228\n\rinterval_year\030\023 \001(" - "\0132\037.io.substrait.Type.IntervalYearH\000\0226\n\014" - "interval_day\030\024 \001(\0132\036.io.substrait.Type.I" - "ntervalDayH\000\0226\n\014timestamp_tz\030\035 \001(\0132\036.io." - "substrait.Type.TimestampTZH\000\022\'\n\004uuid\030 \001" - "(\0132\027.io.substrait.Type.UUIDH\000\022L\n\nfixed_c" - "har\030\025 \001(\01326.io.substrait.DerivationExpre" - "ssion.ExpressionFixedCharH\000\022G\n\007varchar\030\026" - " \001(\01324.io.substrait.DerivationExpression" - ".ExpressionVarCharH\000\022P\n\014fixed_binary\030\027 \001" - "(\01328.io.substrait.DerivationExpression.E" - "xpressionFixedBinaryH\000\022G\n\007decimal\030\030 \001(\0132" - "4.io.substrait.DerivationExpression.Expr" - "essionDecimalH\000\022E\n\006struct\030\031 \001(\01323.io.sub" - "strait.DerivationExpression.ExpressionSt" - "ructH\000\022A\n\004list\030\033 \001(\01321.io.substrait.Deri" - "vationExpression.ExpressionListH\000\022\?\n\003map" - "\030\034 \001(\01320.io.substrait.DerivationExpressi" - "on.ExpressionMapH\000\022\036\n\024user_defined_point" - "er\030\037 \001(\rH\000\022\035\n\023type_parameter_name\030! \001(\tH" - "\000\022 \n\026integer_parameter_name\030\" \001(\tH\000\022\031\n\017i" - "nteger_literal\030# \001(\005H\000\022>\n\010unary_op\030$ \001(\013" - "2*.io.substrait.DerivationExpression.Una" - "ryOpH\000\022@\n\tbinary_op\030% \001(\0132+.io.substrait" - ".DerivationExpression.BinaryOpH\000\022<\n\007if_e" - "lse\030& \001(\0132).io.substrait.DerivationExpre" - "ssion.IfElseH\000\022J\n\016return_program\030\' \001(\01320" - ".io.substrait.DerivationExpression.Retur" - "nProgramH\000\032\231\001\n\023ExpressionFixedChar\0222\n\006le" - "ngth\030\001 \001(\0132\".io.substrait.DerivationExpr" - "ession\022\031\n\021variation_pointer\030\002 \001(\r\0223\n\013nul" - "lability\030\003 \001(\0162\036.io.substrait.Type.Nulla" - "bility\032\227\001\n\021ExpressionVarChar\0222\n\006length\030\001" - " \001(\0132\".io.substrait.DerivationExpression" - "\022\031\n\021variation_pointer\030\002 \001(\r\0223\n\013nullabili" - "ty\030\003 \001(\0162\036.io.substrait.Type.Nullability" - "\032\233\001\n\025ExpressionFixedBinary\0222\n\006length\030\001 \001" - "(\0132\".io.substrait.DerivationExpression\022\031" - "\n\021variation_pointer\030\002 \001(\r\0223\n\013nullability" - "\030\003 \001(\0162\036.io.substrait.Type.Nullability\032\315" - "\001\n\021ExpressionDecimal\0221\n\005scale\030\001 \001(\0132\".io" - ".substrait.DerivationExpression\0225\n\tpreci" - "sion\030\002 \001(\0132\".io.substrait.DerivationExpr" - "ession\022\031\n\021variation_pointer\030\003 \001(\r\0223\n\013nul" - "lability\030\004 \001(\0162\036.io.substrait.Type.Nulla" - "bility\032\225\001\n\020ExpressionStruct\0221\n\005types\030\001 \003" - "(\0132\".io.substrait.DerivationExpression\022\031" - "\n\021variation_pointer\030\002 \001(\r\0223\n\013nullability" - "\030\003 \001(\0162\036.io.substrait.Type.Nullability\032k" - "\n\025ExpressionNamedStruct\022\r\n\005names\030\001 \003(\t\022C" - "\n\006struct\030\002 \001(\01323.io.substrait.Derivation" - "Expression.ExpressionStruct\032\222\001\n\016Expressi" - "onList\0220\n\004type\030\001 \001(\0132\".io.substrait.Deri" - "vationExpression\022\031\n\021variation_pointer\030\002 " - "\001(\r\0223\n\013nullability\030\003 \001(\0162\036.io.substrait." - "Type.Nullability\032\303\001\n\rExpressionMap\022/\n\003ke" - "y\030\001 \001(\0132\".io.substrait.DerivationExpress" - "ion\0221\n\005value\030\002 \001(\0132\".io.substrait.Deriva" - "tionExpression\022\031\n\021variation_pointer\030\003 \001(" - "\r\0223\n\013nullability\030\004 \001(\0162\036.io.substrait.Ty" - "pe.Nullability\032\262\001\n\006IfElse\0228\n\014if_conditio" - "n\030\001 \001(\0132\".io.substrait.DerivationExpress" - "ion\0225\n\tif_return\030\002 \001(\0132\".io.substrait.De" - "rivationExpression\0227\n\013else_return\030\003 \001(\0132" - "\".io.substrait.DerivationExpression\032\246\001\n\007" - "UnaryOp\022B\n\007op_type\030\001 \001(\01621.io.substrait." - "DerivationExpression.UnaryOp.OpType\022/\n\003a" - "rg\030\002 \001(\0132\".io.substrait.DerivationExpres" - "sion\"&\n\006OpType\022\013\n\007UNKNOWN\020\000\022\017\n\013BOOLEAN_N" - "OT\020\001\032\326\002\n\010BinaryOp\022C\n\007op_type\030\001 \001(\01622.io." - "substrait.DerivationExpression.BinaryOp." - "OpType\0220\n\004arg1\030\002 \001(\0132\".io.substrait.Deri" - "vationExpression\0220\n\004arg2\030\003 \001(\0132\".io.subs" - "trait.DerivationExpression\"\240\001\n\006OpType\022\013\n" - "\007UNKNOWN\020\000\022\010\n\004PLUS\020\001\022\t\n\005MINUS\020\002\022\014\n\010MULTI" - "PLY\020\003\022\n\n\006DIVIDE\020\004\022\007\n\003MIN\020\005\022\007\n\003MAX\020\006\022\020\n\014G" - "REATER_THAN\020\007\022\r\n\tLESS_THAN\020\010\022\007\n\003AND\020\t\022\006\n" - "\002OR\020\n\022\n\n\006EQUALS\020\013\022\n\n\006COVERS\020\014\032\362\001\n\rReturn" - "Program\022P\n\013assignments\030\001 \003(\0132;.io.substr" - "ait.DerivationExpression.ReturnProgram.A" - "ssignment\022;\n\017finalExpression\030\002 \001(\0132\".io." - "substrait.DerivationExpression\032R\n\nAssign" - "ment\022\014\n\004name\030\001 \001(\t\0226\n\nexpression\030\002 \001(\0132\"" - ".io.substrait.DerivationExpressionB\006\n\004ki" - "ndB+\n\022io.substrait.protoP\001\252\002\022Substrait.P" - "rotobufb\006proto3" +const char descriptor_table_protodef_substrait_2ftype_5fexpressions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = + "\n substrait/type_expressions.proto\022\tsubs" + "trait\032\024substrait/type.proto\"\366\036\n\024Derivati" + "onExpression\022\'\n\004bool\030\001 \001(\0132\027.substrait.T" + "ype.BooleanH\000\022 \n\002i8\030\002 \001(\0132\022.substrait.Ty" + "pe.I8H\000\022\"\n\003i16\030\003 \001(\0132\023.substrait.Type.I1" + "6H\000\022\"\n\003i32\030\005 \001(\0132\023.substrait.Type.I32H\000\022" + "\"\n\003i64\030\007 \001(\0132\023.substrait.Type.I64H\000\022$\n\004f" + "p32\030\n \001(\0132\024.substrait.Type.FP32H\000\022$\n\004fp6" + "4\030\013 \001(\0132\024.substrait.Type.FP64H\000\022(\n\006strin" + "g\030\014 \001(\0132\026.substrait.Type.StringH\000\022(\n\006bin" + "ary\030\r \001(\0132\026.substrait.Type.BinaryH\000\022.\n\tt" + "imestamp\030\016 \001(\0132\031.substrait.Type.Timestam" + "pH\000\022$\n\004date\030\020 \001(\0132\024.substrait.Type.DateH" + "\000\022$\n\004time\030\021 \001(\0132\024.substrait.Type.TimeH\000\022" + "5\n\rinterval_year\030\023 \001(\0132\034.substrait.Type." + "IntervalYearH\000\0223\n\014interval_day\030\024 \001(\0132\033.s" + "ubstrait.Type.IntervalDayH\000\0223\n\014timestamp" + "_tz\030\035 \001(\0132\033.substrait.Type.TimestampTZH\000" + "\022$\n\004uuid\030 \001(\0132\024.substrait.Type.UUIDH\000\022I" + "\n\nfixed_char\030\025 \001(\01323.substrait.Derivatio" + "nExpression.ExpressionFixedCharH\000\022D\n\007var" + "char\030\026 \001(\01321.substrait.DerivationExpress" + "ion.ExpressionVarCharH\000\022M\n\014fixed_binary\030" + "\027 \001(\01325.substrait.DerivationExpression.E" + "xpressionFixedBinaryH\000\022D\n\007decimal\030\030 \001(\0132" + "1.substrait.DerivationExpression.Express" + "ionDecimalH\000\022B\n\006struct\030\031 \001(\01320.substrait" + ".DerivationExpression.ExpressionStructH\000" + "\022>\n\004list\030\033 \001(\0132..substrait.DerivationExp" + "ression.ExpressionListH\000\022<\n\003map\030\034 \001(\0132-." + "substrait.DerivationExpression.Expressio" + "nMapH\000\022\036\n\024user_defined_pointer\030\037 \001(\rH\000\022\035" + "\n\023type_parameter_name\030! \001(\tH\000\022 \n\026integer" + "_parameter_name\030\" \001(\tH\000\022\031\n\017integer_liter" + "al\030# \001(\005H\000\022;\n\010unary_op\030$ \001(\0132\'.substrait" + ".DerivationExpression.UnaryOpH\000\022=\n\tbinar" + "y_op\030% \001(\0132(.substrait.DerivationExpress" + "ion.BinaryOpH\000\0229\n\007if_else\030& \001(\0132&.substr" + "ait.DerivationExpression.IfElseH\000\022G\n\016ret" + "urn_program\030\' \001(\0132-.substrait.Derivation" + "Expression.ReturnProgramH\000\032\223\001\n\023Expressio" + "nFixedChar\022/\n\006length\030\001 \001(\0132\037.substrait.D" + "erivationExpression\022\031\n\021variation_pointer" + "\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrait." + "Type.Nullability\032\221\001\n\021ExpressionVarChar\022/" + "\n\006length\030\001 \001(\0132\037.substrait.DerivationExp" + "ression\022\031\n\021variation_pointer\030\002 \001(\r\0220\n\013nu" + "llability\030\003 \001(\0162\033.substrait.Type.Nullabi" + "lity\032\225\001\n\025ExpressionFixedBinary\022/\n\006length" + "\030\001 \001(\0132\037.substrait.DerivationExpression\022" + "\031\n\021variation_pointer\030\002 \001(\r\0220\n\013nullabilit" + "y\030\003 \001(\0162\033.substrait.Type.Nullability\032\304\001\n" + "\021ExpressionDecimal\022.\n\005scale\030\001 \001(\0132\037.subs" + "trait.DerivationExpression\0222\n\tprecision\030" + "\002 \001(\0132\037.substrait.DerivationExpression\022\031" + "\n\021variation_pointer\030\003 \001(\r\0220\n\013nullability" + "\030\004 \001(\0162\033.substrait.Type.Nullability\032\217\001\n\020" + "ExpressionStruct\022.\n\005types\030\001 \003(\0132\037.substr" + "ait.DerivationExpression\022\031\n\021variation_po" + "inter\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.subst" + "rait.Type.Nullability\032h\n\025ExpressionNamed" + "Struct\022\r\n\005names\030\001 \003(\t\022@\n\006struct\030\002 \001(\01320." + "substrait.DerivationExpression.Expressio" + "nStruct\032\214\001\n\016ExpressionList\022-\n\004type\030\001 \001(\013" + "2\037.substrait.DerivationExpression\022\031\n\021var" + "iation_pointer\030\002 \001(\r\0220\n\013nullability\030\003 \001(" + "\0162\033.substrait.Type.Nullability\032\272\001\n\rExpre" + "ssionMap\022,\n\003key\030\001 \001(\0132\037.substrait.Deriva" + "tionExpression\022.\n\005value\030\002 \001(\0132\037.substrai" + "t.DerivationExpression\022\031\n\021variation_poin" + "ter\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033.substra" + "it.Type.Nullability\032\251\001\n\006IfElse\0225\n\014if_con" + "dition\030\001 \001(\0132\037.substrait.DerivationExpre" + "ssion\0222\n\tif_return\030\002 \001(\0132\037.substrait.Der" + "ivationExpression\0224\n\013else_return\030\003 \001(\0132\037" + ".substrait.DerivationExpression\032\312\001\n\007Unar" + "yOp\022D\n\007op_type\030\001 \001(\01623.substrait.Derivat" + "ionExpression.UnaryOp.UnaryOpType\022,\n\003arg" + "\030\002 \001(\0132\037.substrait.DerivationExpression\"" + "K\n\013UnaryOpType\022\035\n\031UNARY_OP_TYPE_UNSPECIF" + "IED\020\000\022\035\n\031UNARY_OP_TYPE_BOOLEAN_NOT\020\001\032\240\004\n" + "\010BinaryOp\022F\n\007op_type\030\001 \001(\01625.substrait.D" + "erivationExpression.BinaryOp.BinaryOpTyp" + "e\022-\n\004arg1\030\002 \001(\0132\037.substrait.DerivationEx" + "pression\022-\n\004arg2\030\003 \001(\0132\037.substrait.Deriv" + "ationExpression\"\355\002\n\014BinaryOpType\022\036\n\032BINA" + "RY_OP_TYPE_UNSPECIFIED\020\000\022\027\n\023BINARY_OP_TY" + "PE_PLUS\020\001\022\030\n\024BINARY_OP_TYPE_MINUS\020\002\022\033\n\027B" + "INARY_OP_TYPE_MULTIPLY\020\003\022\031\n\025BINARY_OP_TY" + "PE_DIVIDE\020\004\022\026\n\022BINARY_OP_TYPE_MIN\020\005\022\026\n\022B" + "INARY_OP_TYPE_MAX\020\006\022\037\n\033BINARY_OP_TYPE_GR" + "EATER_THAN\020\007\022\034\n\030BINARY_OP_TYPE_LESS_THAN" + "\020\010\022\026\n\022BINARY_OP_TYPE_AND\020\t\022\025\n\021BINARY_OP_" + "TYPE_OR\020\n\022\031\n\025BINARY_OP_TYPE_EQUALS\020\013\022\031\n\025" + "BINARY_OP_TYPE_COVERS\020\014\032\352\001\n\rReturnProgra" + "m\022M\n\013assignments\030\001 \003(\01328.substrait.Deriv" + "ationExpression.ReturnProgram.Assignment" + "\0229\n\020final_expression\030\002 \001(\0132\037.substrait.D" + "erivationExpression\032O\n\nAssignment\022\014\n\004nam" + "e\030\001 \001(\t\0223\n\nexpression\030\002 \001(\0132\037.substrait." + "DerivationExpressionB\006\n\004kindB+\n\022io.subst" + "rait.protoP\001\252\002\022Substrait.Protobufb\006proto" + "3" ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_type_5fexpressions_2eproto_deps[1] = { - &::descriptor_table_type_2eproto, +static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2ftype_5fexpressions_2eproto_deps[1] = { + &::descriptor_table_substrait_2ftype_2eproto, }; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_type_5fexpressions_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_5fexpressions_2eproto = { - false, false, 3975, descriptor_table_protodef_type_5fexpressions_2eproto, "type_expressions.proto", - &descriptor_table_type_5fexpressions_2eproto_once, descriptor_table_type_5fexpressions_2eproto_deps, 1, 14, - schemas, file_default_instances, TableStruct_type_5fexpressions_2eproto::offsets, - file_level_metadata_type_5fexpressions_2eproto, file_level_enum_descriptors_type_5fexpressions_2eproto, file_level_service_descriptors_type_5fexpressions_2eproto, +static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ftype_5fexpressions_2eproto_once; +const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_5fexpressions_2eproto = { + false, false, 4081, descriptor_table_protodef_substrait_2ftype_5fexpressions_2eproto, "substrait/type_expressions.proto", + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, descriptor_table_substrait_2ftype_5fexpressions_2eproto_deps, 1, 14, + schemas, file_default_instances, TableStruct_substrait_2ftype_5fexpressions_2eproto::offsets, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto, file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto, file_level_service_descriptors_substrait_2ftype_5fexpressions_2eproto, }; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_type_5fexpressions_2eproto_getter() { - return &descriptor_table_type_5fexpressions_2eproto; +PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter() { + return &descriptor_table_substrait_2ftype_5fexpressions_2eproto; } // Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_type_5fexpressions_2eproto(&descriptor_table_type_5fexpressions_2eproto); -namespace io { +PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ftype_5fexpressions_2eproto(&descriptor_table_substrait_2ftype_5fexpressions_2eproto); namespace substrait { -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_OpType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_type_5fexpressions_2eproto); - return file_level_enum_descriptors_type_5fexpressions_2eproto[0]; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_UnaryOpType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_5fexpressions_2eproto); + return file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[0]; } -bool DerivationExpression_UnaryOp_OpType_IsValid(int value) { +bool DerivationExpression_UnaryOp_UnaryOpType_IsValid(int value) { switch (value) { case 0: case 1: @@ -535,17 +535,17 @@ bool DerivationExpression_UnaryOp_OpType_IsValid(int value) { } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::UNKNOWN; -constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::BOOLEAN_NOT; -constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::OpType_MIN; -constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::OpType_MAX; -constexpr int DerivationExpression_UnaryOp::OpType_ARRAYSIZE; +constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UNARY_OP_TYPE_UNSPECIFIED; +constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UNARY_OP_TYPE_BOOLEAN_NOT; +constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UnaryOpType_MIN; +constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UnaryOpType_MAX; +constexpr int DerivationExpression_UnaryOp::UnaryOpType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_OpType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_type_5fexpressions_2eproto); - return file_level_enum_descriptors_type_5fexpressions_2eproto[1]; +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_BinaryOpType_descriptor() { + ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_5fexpressions_2eproto); + return file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[1]; } -bool DerivationExpression_BinaryOp_OpType_IsValid(int value) { +bool DerivationExpression_BinaryOp_BinaryOpType_IsValid(int value) { switch (value) { case 0: case 1: @@ -567,32 +567,32 @@ bool DerivationExpression_BinaryOp_OpType_IsValid(int value) { } #if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::UNKNOWN; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::PLUS; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::MINUS; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::MULTIPLY; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::DIVIDE; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::MIN; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::MAX; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::GREATER_THAN; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::LESS_THAN; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::AND; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::OR; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::EQUALS; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::COVERS; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::OpType_MIN; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::OpType_MAX; -constexpr int DerivationExpression_BinaryOp::OpType_ARRAYSIZE; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_UNSPECIFIED; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_PLUS; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MINUS; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MULTIPLY; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_DIVIDE; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MIN; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MAX; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_GREATER_THAN; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_LESS_THAN; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_AND; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_OR; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_EQUALS; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_COVERS; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BinaryOpType_MIN; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BinaryOpType_MAX; +constexpr int DerivationExpression_BinaryOp::BinaryOpType_ARRAYSIZE; #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) // =================================================================== class DerivationExpression_ExpressionFixedChar::_Internal { public: - static const ::io::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedChar* msg); + static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedChar* msg); }; -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::_Internal::length(const DerivationExpression_ExpressionFixedChar* msg) { return *msg->length_; } @@ -600,20 +600,20 @@ DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedCh : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionFixedChar) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionFixedChar) } DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(const DerivationExpression_ExpressionFixedChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_length()) { - length_ = new ::io::substrait::DerivationExpression(*from.length_); + length_ = new ::substrait::DerivationExpression(*from.length_); } else { length_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionFixedChar) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedChar) } void DerivationExpression_ExpressionFixedChar::SharedCtor() { @@ -624,7 +624,7 @@ ::memset(reinterpret_cast(this) + static_cast( } DerivationExpression_ExpressionFixedChar::~DerivationExpression_ExpressionFixedChar() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionFixedChar) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionFixedChar) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -645,7 +645,7 @@ void DerivationExpression_ExpressionFixedChar::SetCachedSize(int size) const { } void DerivationExpression_ExpressionFixedChar::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionFixedChar) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionFixedChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -666,7 +666,7 @@ const char* DerivationExpression_ExpressionFixedChar::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); @@ -680,12 +680,12 @@ const char* DerivationExpression_ExpressionFixedChar::_InternalParse(const char* CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -713,11 +713,11 @@ const char* DerivationExpression_ExpressionFixedChar::_InternalParse(const char* ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedChar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionFixedChar) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionFixedChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; if (this->has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -731,7 +731,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedChar::_Inter target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -742,19 +742,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedChar::_Inter target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionFixedChar) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionFixedChar) return target; } size_t DerivationExpression_ExpressionFixedChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionFixedChar) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionFixedChar) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; if (this->has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -768,7 +768,7 @@ size_t DerivationExpression_ExpressionFixedChar::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -784,29 +784,29 @@ size_t DerivationExpression_ExpressionFixedChar::ByteSizeLong() const { } void DerivationExpression_ExpressionFixedChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionFixedChar) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionFixedChar) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_ExpressionFixedChar* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionFixedChar) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionFixedChar) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionFixedChar) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionFixedChar) MergeFrom(*source); } } void DerivationExpression_ExpressionFixedChar::MergeFrom(const DerivationExpression_ExpressionFixedChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionFixedChar) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionFixedChar) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_length()) { - _internal_mutable_length()->::io::substrait::DerivationExpression::MergeFrom(from._internal_length()); + _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -817,14 +817,14 @@ void DerivationExpression_ExpressionFixedChar::MergeFrom(const DerivationExpress } void DerivationExpression_ExpressionFixedChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionFixedChar) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionFixedChar) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_ExpressionFixedChar::CopyFrom(const DerivationExpression_ExpressionFixedChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionFixedChar) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionFixedChar) if (&from == this) return; Clear(); MergeFrom(from); @@ -847,18 +847,18 @@ void DerivationExpression_ExpressionFixedChar::InternalSwap(DerivationExpression ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedChar::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[0]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[0]); } // =================================================================== class DerivationExpression_ExpressionVarChar::_Internal { public: - static const ::io::substrait::DerivationExpression& length(const DerivationExpression_ExpressionVarChar* msg); + static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionVarChar* msg); }; -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::_Internal::length(const DerivationExpression_ExpressionVarChar* msg) { return *msg->length_; } @@ -866,20 +866,20 @@ DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(: : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionVarChar) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionVarChar) } DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(const DerivationExpression_ExpressionVarChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_length()) { - length_ = new ::io::substrait::DerivationExpression(*from.length_); + length_ = new ::substrait::DerivationExpression(*from.length_); } else { length_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionVarChar) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionVarChar) } void DerivationExpression_ExpressionVarChar::SharedCtor() { @@ -890,7 +890,7 @@ ::memset(reinterpret_cast(this) + static_cast( } DerivationExpression_ExpressionVarChar::~DerivationExpression_ExpressionVarChar() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionVarChar) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionVarChar) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -911,7 +911,7 @@ void DerivationExpression_ExpressionVarChar::SetCachedSize(int size) const { } void DerivationExpression_ExpressionVarChar::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionVarChar) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionVarChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -932,7 +932,7 @@ const char* DerivationExpression_ExpressionVarChar::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); @@ -946,12 +946,12 @@ const char* DerivationExpression_ExpressionVarChar::_InternalParse(const char* p CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -979,11 +979,11 @@ const char* DerivationExpression_ExpressionVarChar::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionVarChar::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionVarChar) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionVarChar) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; if (this->has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -997,7 +997,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionVarChar::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1008,19 +1008,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionVarChar::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionVarChar) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionVarChar) return target; } size_t DerivationExpression_ExpressionVarChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionVarChar) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionVarChar) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; if (this->has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1034,7 +1034,7 @@ size_t DerivationExpression_ExpressionVarChar::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1050,29 +1050,29 @@ size_t DerivationExpression_ExpressionVarChar::ByteSizeLong() const { } void DerivationExpression_ExpressionVarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionVarChar) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionVarChar) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_ExpressionVarChar* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionVarChar) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionVarChar) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionVarChar) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionVarChar) MergeFrom(*source); } } void DerivationExpression_ExpressionVarChar::MergeFrom(const DerivationExpression_ExpressionVarChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionVarChar) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionVarChar) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_length()) { - _internal_mutable_length()->::io::substrait::DerivationExpression::MergeFrom(from._internal_length()); + _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -1083,14 +1083,14 @@ void DerivationExpression_ExpressionVarChar::MergeFrom(const DerivationExpressio } void DerivationExpression_ExpressionVarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionVarChar) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionVarChar) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_ExpressionVarChar::CopyFrom(const DerivationExpression_ExpressionVarChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionVarChar) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionVarChar) if (&from == this) return; Clear(); MergeFrom(from); @@ -1113,18 +1113,18 @@ void DerivationExpression_ExpressionVarChar::InternalSwap(DerivationExpression_E ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionVarChar::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[1]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[1]); } // =================================================================== class DerivationExpression_ExpressionFixedBinary::_Internal { public: - static const ::io::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedBinary* msg); + static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedBinary* msg); }; -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::_Internal::length(const DerivationExpression_ExpressionFixedBinary* msg) { return *msg->length_; } @@ -1132,20 +1132,20 @@ DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixed : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionFixedBinary) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionFixedBinary) } DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(const DerivationExpression_ExpressionFixedBinary& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_length()) { - length_ = new ::io::substrait::DerivationExpression(*from.length_); + length_ = new ::substrait::DerivationExpression(*from.length_); } else { length_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionFixedBinary) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedBinary) } void DerivationExpression_ExpressionFixedBinary::SharedCtor() { @@ -1156,7 +1156,7 @@ ::memset(reinterpret_cast(this) + static_cast( } DerivationExpression_ExpressionFixedBinary::~DerivationExpression_ExpressionFixedBinary() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionFixedBinary) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionFixedBinary) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1177,7 +1177,7 @@ void DerivationExpression_ExpressionFixedBinary::SetCachedSize(int size) const { } void DerivationExpression_ExpressionFixedBinary::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionFixedBinary) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionFixedBinary) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1198,7 +1198,7 @@ const char* DerivationExpression_ExpressionFixedBinary::_InternalParse(const cha ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); @@ -1212,12 +1212,12 @@ const char* DerivationExpression_ExpressionFixedBinary::_InternalParse(const cha CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -1245,11 +1245,11 @@ const char* DerivationExpression_ExpressionFixedBinary::_InternalParse(const cha ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedBinary::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionFixedBinary) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionFixedBinary) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; if (this->has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1263,7 +1263,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedBinary::_Int target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1274,19 +1274,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedBinary::_Int target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionFixedBinary) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionFixedBinary) return target; } size_t DerivationExpression_ExpressionFixedBinary::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionFixedBinary) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionFixedBinary) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; if (this->has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1300,7 +1300,7 @@ size_t DerivationExpression_ExpressionFixedBinary::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1316,29 +1316,29 @@ size_t DerivationExpression_ExpressionFixedBinary::ByteSizeLong() const { } void DerivationExpression_ExpressionFixedBinary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionFixedBinary) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionFixedBinary) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_ExpressionFixedBinary* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionFixedBinary) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionFixedBinary) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionFixedBinary) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionFixedBinary) MergeFrom(*source); } } void DerivationExpression_ExpressionFixedBinary::MergeFrom(const DerivationExpression_ExpressionFixedBinary& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionFixedBinary) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionFixedBinary) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_length()) { - _internal_mutable_length()->::io::substrait::DerivationExpression::MergeFrom(from._internal_length()); + _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -1349,14 +1349,14 @@ void DerivationExpression_ExpressionFixedBinary::MergeFrom(const DerivationExpre } void DerivationExpression_ExpressionFixedBinary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionFixedBinary) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionFixedBinary) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_ExpressionFixedBinary::CopyFrom(const DerivationExpression_ExpressionFixedBinary& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionFixedBinary) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionFixedBinary) if (&from == this) return; Clear(); MergeFrom(from); @@ -1379,23 +1379,23 @@ void DerivationExpression_ExpressionFixedBinary::InternalSwap(DerivationExpressi ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedBinary::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[2]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[2]); } // =================================================================== class DerivationExpression_ExpressionDecimal::_Internal { public: - static const ::io::substrait::DerivationExpression& scale(const DerivationExpression_ExpressionDecimal* msg); - static const ::io::substrait::DerivationExpression& precision(const DerivationExpression_ExpressionDecimal* msg); + static const ::substrait::DerivationExpression& scale(const DerivationExpression_ExpressionDecimal* msg); + static const ::substrait::DerivationExpression& precision(const DerivationExpression_ExpressionDecimal* msg); }; -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_Internal::scale(const DerivationExpression_ExpressionDecimal* msg) { return *msg->scale_; } -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_Internal::precision(const DerivationExpression_ExpressionDecimal* msg) { return *msg->precision_; } @@ -1403,25 +1403,25 @@ DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(: : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionDecimal) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionDecimal) } DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(const DerivationExpression_ExpressionDecimal& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_scale()) { - scale_ = new ::io::substrait::DerivationExpression(*from.scale_); + scale_ = new ::substrait::DerivationExpression(*from.scale_); } else { scale_ = nullptr; } if (from._internal_has_precision()) { - precision_ = new ::io::substrait::DerivationExpression(*from.precision_); + precision_ = new ::substrait::DerivationExpression(*from.precision_); } else { precision_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionDecimal) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionDecimal) } void DerivationExpression_ExpressionDecimal::SharedCtor() { @@ -1432,7 +1432,7 @@ ::memset(reinterpret_cast(this) + static_cast( } DerivationExpression_ExpressionDecimal::~DerivationExpression_ExpressionDecimal() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionDecimal) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionDecimal) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1454,7 +1454,7 @@ void DerivationExpression_ExpressionDecimal::SetCachedSize(int size) const { } void DerivationExpression_ExpressionDecimal::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionDecimal) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionDecimal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1479,14 +1479,14 @@ const char* DerivationExpression_ExpressionDecimal::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.DerivationExpression scale = 1; + // .substrait.DerivationExpression scale = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression precision = 2; + // .substrait.DerivationExpression precision = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr); @@ -1500,12 +1500,12 @@ const char* DerivationExpression_ExpressionDecimal::_InternalParse(const char* p CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -1533,11 +1533,11 @@ const char* DerivationExpression_ExpressionDecimal::_InternalParse(const char* p ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionDecimal::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionDecimal) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionDecimal) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.DerivationExpression scale = 1; + // .substrait.DerivationExpression scale = 1; if (this->has_scale()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1545,7 +1545,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionDecimal::_Interna 1, _Internal::scale(this), target, stream); } - // .io.substrait.DerivationExpression precision = 2; + // .substrait.DerivationExpression precision = 2; if (this->has_precision()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1559,7 +1559,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionDecimal::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1570,26 +1570,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionDecimal::_Interna target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionDecimal) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionDecimal) return target; } size_t DerivationExpression_ExpressionDecimal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionDecimal) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionDecimal) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.DerivationExpression scale = 1; + // .substrait.DerivationExpression scale = 1; if (this->has_scale()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *scale_); } - // .io.substrait.DerivationExpression precision = 2; + // .substrait.DerivationExpression precision = 2; if (this->has_precision()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -1603,7 +1603,7 @@ size_t DerivationExpression_ExpressionDecimal::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1619,32 +1619,32 @@ size_t DerivationExpression_ExpressionDecimal::ByteSizeLong() const { } void DerivationExpression_ExpressionDecimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionDecimal) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionDecimal) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_ExpressionDecimal* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionDecimal) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionDecimal) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionDecimal) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionDecimal) MergeFrom(*source); } } void DerivationExpression_ExpressionDecimal::MergeFrom(const DerivationExpression_ExpressionDecimal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionDecimal) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionDecimal) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_scale()) { - _internal_mutable_scale()->::io::substrait::DerivationExpression::MergeFrom(from._internal_scale()); + _internal_mutable_scale()->::substrait::DerivationExpression::MergeFrom(from._internal_scale()); } if (from.has_precision()) { - _internal_mutable_precision()->::io::substrait::DerivationExpression::MergeFrom(from._internal_precision()); + _internal_mutable_precision()->::substrait::DerivationExpression::MergeFrom(from._internal_precision()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -1655,14 +1655,14 @@ void DerivationExpression_ExpressionDecimal::MergeFrom(const DerivationExpressio } void DerivationExpression_ExpressionDecimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionDecimal) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionDecimal) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_ExpressionDecimal::CopyFrom(const DerivationExpression_ExpressionDecimal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionDecimal) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionDecimal) if (&from == this) return; Clear(); MergeFrom(from); @@ -1685,8 +1685,8 @@ void DerivationExpression_ExpressionDecimal::InternalSwap(DerivationExpression_E ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionDecimal::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[3]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[3]); } // =================================================================== @@ -1700,7 +1700,7 @@ DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(::P types_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionStruct) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionStruct) } DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(const DerivationExpression_ExpressionStruct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), @@ -1709,7 +1709,7 @@ DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(con ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionStruct) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionStruct) } void DerivationExpression_ExpressionStruct::SharedCtor() { @@ -1720,7 +1720,7 @@ ::memset(reinterpret_cast(this) + static_cast( } DerivationExpression_ExpressionStruct::~DerivationExpression_ExpressionStruct() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionStruct) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionStruct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -1740,7 +1740,7 @@ void DerivationExpression_ExpressionStruct::SetCachedSize(int size) const { } void DerivationExpression_ExpressionStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionStruct) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1758,7 +1758,7 @@ const char* DerivationExpression_ExpressionStruct::_InternalParse(const char* pt ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.DerivationExpression types = 1; + // repeated .substrait.DerivationExpression types = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -1777,12 +1777,12 @@ const char* DerivationExpression_ExpressionStruct::_InternalParse(const char* pt CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -1810,11 +1810,11 @@ const char* DerivationExpression_ExpressionStruct::_InternalParse(const char* pt ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionStruct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionStruct) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.DerivationExpression types = 1; + // repeated .substrait.DerivationExpression types = 1; for (unsigned int i = 0, n = static_cast(this->_internal_types_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -1828,7 +1828,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionStruct::_Internal target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -1839,19 +1839,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionStruct::_Internal target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionStruct) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionStruct) return target; } size_t DerivationExpression_ExpressionStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionStruct) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionStruct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.DerivationExpression types = 1; + // repeated .substrait.DerivationExpression types = 1; total_size += 1UL * this->_internal_types_size(); for (const auto& msg : this->types_) { total_size += @@ -1865,7 +1865,7 @@ size_t DerivationExpression_ExpressionStruct::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -1881,22 +1881,22 @@ size_t DerivationExpression_ExpressionStruct::ByteSizeLong() const { } void DerivationExpression_ExpressionStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionStruct) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionStruct) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_ExpressionStruct* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionStruct) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionStruct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionStruct) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionStruct) MergeFrom(*source); } } void DerivationExpression_ExpressionStruct::MergeFrom(const DerivationExpression_ExpressionStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionStruct) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionStruct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -1912,14 +1912,14 @@ void DerivationExpression_ExpressionStruct::MergeFrom(const DerivationExpression } void DerivationExpression_ExpressionStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionStruct) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionStruct) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_ExpressionStruct::CopyFrom(const DerivationExpression_ExpressionStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionStruct) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionStruct) if (&from == this) return; Clear(); MergeFrom(from); @@ -1943,18 +1943,18 @@ void DerivationExpression_ExpressionStruct::InternalSwap(DerivationExpression_Ex ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionStruct::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[4]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[4]); } // =================================================================== class DerivationExpression_ExpressionNamedStruct::_Internal { public: - static const ::io::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression_ExpressionNamedStruct* msg); + static const ::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression_ExpressionNamedStruct* msg); }; -const ::io::substrait::DerivationExpression_ExpressionStruct& +const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::_Internal::struct_(const DerivationExpression_ExpressionNamedStruct* msg) { return *msg->struct__; } @@ -1963,18 +1963,18 @@ DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamed names_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionNamedStruct) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionNamedStruct) } DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(const DerivationExpression_ExpressionNamedStruct& from) : ::PROTOBUF_NAMESPACE_ID::Message(), names_(from.names_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_struct_()) { - struct__ = new ::io::substrait::DerivationExpression_ExpressionStruct(*from.struct__); + struct__ = new ::substrait::DerivationExpression_ExpressionStruct(*from.struct__); } else { struct__ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionNamedStruct) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionNamedStruct) } void DerivationExpression_ExpressionNamedStruct::SharedCtor() { @@ -1982,7 +1982,7 @@ struct__ = nullptr; } DerivationExpression_ExpressionNamedStruct::~DerivationExpression_ExpressionNamedStruct() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionNamedStruct) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionNamedStruct) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2003,7 +2003,7 @@ void DerivationExpression_ExpressionNamedStruct::SetCachedSize(int size) const { } void DerivationExpression_ExpressionNamedStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionNamedStruct) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionNamedStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2030,13 +2030,13 @@ const char* DerivationExpression_ExpressionNamedStruct::_InternalParse(const cha ptr += 1; auto str = _internal_add_names(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.DerivationExpression.ExpressionNamedStruct.names")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.ExpressionNamedStruct.names")); CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.ExpressionStruct struct = 2; + // .substrait.DerivationExpression.ExpressionStruct struct = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); @@ -2068,7 +2068,7 @@ const char* DerivationExpression_ExpressionNamedStruct::_InternalParse(const cha ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionNamedStruct::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionNamedStruct) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionNamedStruct) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -2078,11 +2078,11 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionNamedStruct::_Int ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( s.data(), static_cast(s.length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.DerivationExpression.ExpressionNamedStruct.names"); + "substrait.DerivationExpression.ExpressionNamedStruct.names"); target = stream->WriteString(1, s, target); } - // .io.substrait.DerivationExpression.ExpressionStruct struct = 2; + // .substrait.DerivationExpression.ExpressionStruct struct = 2; if (this->has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2094,12 +2094,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionNamedStruct::_Int target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionNamedStruct) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionNamedStruct) return target; } size_t DerivationExpression_ExpressionNamedStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionNamedStruct) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionNamedStruct) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2114,7 +2114,7 @@ size_t DerivationExpression_ExpressionNamedStruct::ByteSizeLong() const { names_.Get(i)); } - // .io.substrait.DerivationExpression.ExpressionStruct struct = 2; + // .substrait.DerivationExpression.ExpressionStruct struct = 2; if (this->has_struct_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2131,22 +2131,22 @@ size_t DerivationExpression_ExpressionNamedStruct::ByteSizeLong() const { } void DerivationExpression_ExpressionNamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionNamedStruct) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionNamedStruct) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_ExpressionNamedStruct* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionNamedStruct) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionNamedStruct) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionNamedStruct) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionNamedStruct) MergeFrom(*source); } } void DerivationExpression_ExpressionNamedStruct::MergeFrom(const DerivationExpression_ExpressionNamedStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionNamedStruct) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionNamedStruct) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -2154,19 +2154,19 @@ void DerivationExpression_ExpressionNamedStruct::MergeFrom(const DerivationExpre names_.MergeFrom(from.names_); if (from.has_struct_()) { - _internal_mutable_struct_()->::io::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); } } void DerivationExpression_ExpressionNamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionNamedStruct) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionNamedStruct) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_ExpressionNamedStruct::CopyFrom(const DerivationExpression_ExpressionNamedStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionNamedStruct) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionNamedStruct) if (&from == this) return; Clear(); MergeFrom(from); @@ -2185,18 +2185,18 @@ void DerivationExpression_ExpressionNamedStruct::InternalSwap(DerivationExpressi ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionNamedStruct::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[5]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[5]); } // =================================================================== class DerivationExpression_ExpressionList::_Internal { public: - static const ::io::substrait::DerivationExpression& type(const DerivationExpression_ExpressionList* msg); + static const ::substrait::DerivationExpression& type(const DerivationExpression_ExpressionList* msg); }; -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_ExpressionList::_Internal::type(const DerivationExpression_ExpressionList* msg) { return *msg->type_; } @@ -2204,20 +2204,20 @@ DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(::PROTO : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionList) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionList) } DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(const DerivationExpression_ExpressionList& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_type()) { - type_ = new ::io::substrait::DerivationExpression(*from.type_); + type_ = new ::substrait::DerivationExpression(*from.type_); } else { type_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionList) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionList) } void DerivationExpression_ExpressionList::SharedCtor() { @@ -2228,7 +2228,7 @@ ::memset(reinterpret_cast(this) + static_cast( } DerivationExpression_ExpressionList::~DerivationExpression_ExpressionList() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionList) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionList) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2249,7 +2249,7 @@ void DerivationExpression_ExpressionList::SetCachedSize(int size) const { } void DerivationExpression_ExpressionList::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionList) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2270,7 +2270,7 @@ const char* DerivationExpression_ExpressionList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.DerivationExpression type = 1; + // .substrait.DerivationExpression type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); @@ -2284,12 +2284,12 @@ const char* DerivationExpression_ExpressionList::_InternalParse(const char* ptr, CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -2317,11 +2317,11 @@ const char* DerivationExpression_ExpressionList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionList::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionList) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionList) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.DerivationExpression type = 1; + // .substrait.DerivationExpression type = 1; if (this->has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2335,7 +2335,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionList::_InternalSe target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -2346,19 +2346,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionList::_InternalSe target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionList) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionList) return target; } size_t DerivationExpression_ExpressionList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionList) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionList) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.DerivationExpression type = 1; + // .substrait.DerivationExpression type = 1; if (this->has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2372,7 +2372,7 @@ size_t DerivationExpression_ExpressionList::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -2388,29 +2388,29 @@ size_t DerivationExpression_ExpressionList::ByteSizeLong() const { } void DerivationExpression_ExpressionList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionList) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionList) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_ExpressionList* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionList) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionList) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionList) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionList) MergeFrom(*source); } } void DerivationExpression_ExpressionList::MergeFrom(const DerivationExpression_ExpressionList& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionList) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionList) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_type()) { - _internal_mutable_type()->::io::substrait::DerivationExpression::MergeFrom(from._internal_type()); + _internal_mutable_type()->::substrait::DerivationExpression::MergeFrom(from._internal_type()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -2421,14 +2421,14 @@ void DerivationExpression_ExpressionList::MergeFrom(const DerivationExpression_E } void DerivationExpression_ExpressionList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionList) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionList) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_ExpressionList::CopyFrom(const DerivationExpression_ExpressionList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionList) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionList) if (&from == this) return; Clear(); MergeFrom(from); @@ -2451,23 +2451,23 @@ void DerivationExpression_ExpressionList::InternalSwap(DerivationExpression_Expr ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionList::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[6]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[6]); } // =================================================================== class DerivationExpression_ExpressionMap::_Internal { public: - static const ::io::substrait::DerivationExpression& key(const DerivationExpression_ExpressionMap* msg); - static const ::io::substrait::DerivationExpression& value(const DerivationExpression_ExpressionMap* msg); + static const ::substrait::DerivationExpression& key(const DerivationExpression_ExpressionMap* msg); + static const ::substrait::DerivationExpression& value(const DerivationExpression_ExpressionMap* msg); }; -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_Internal::key(const DerivationExpression_ExpressionMap* msg) { return *msg->key_; } -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_Internal::value(const DerivationExpression_ExpressionMap* msg) { return *msg->value_; } @@ -2475,25 +2475,25 @@ DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(::PROTOBU : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ExpressionMap) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionMap) } DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(const DerivationExpression_ExpressionMap& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_key()) { - key_ = new ::io::substrait::DerivationExpression(*from.key_); + key_ = new ::substrait::DerivationExpression(*from.key_); } else { key_ = nullptr; } if (from._internal_has_value()) { - value_ = new ::io::substrait::DerivationExpression(*from.value_); + value_ = new ::substrait::DerivationExpression(*from.value_); } else { value_ = nullptr; } ::memcpy(&variation_pointer_, &from.variation_pointer_, static_cast(reinterpret_cast(&nullability_) - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ExpressionMap) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionMap) } void DerivationExpression_ExpressionMap::SharedCtor() { @@ -2504,7 +2504,7 @@ ::memset(reinterpret_cast(this) + static_cast( } DerivationExpression_ExpressionMap::~DerivationExpression_ExpressionMap() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ExpressionMap) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionMap) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2526,7 +2526,7 @@ void DerivationExpression_ExpressionMap::SetCachedSize(int size) const { } void DerivationExpression_ExpressionMap::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ExpressionMap) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionMap) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2551,14 +2551,14 @@ const char* DerivationExpression_ExpressionMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.DerivationExpression key = 1; + // .substrait.DerivationExpression key = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression value = 2; + // .substrait.DerivationExpression value = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); @@ -2572,12 +2572,12 @@ const char* DerivationExpression_ExpressionMap::_InternalParse(const char* ptr, CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; case 4: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_nullability(static_cast<::io::substrait::Type_Nullability>(val)); + _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); } else goto handle_unusual; continue; default: { @@ -2605,11 +2605,11 @@ const char* DerivationExpression_ExpressionMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionMap::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ExpressionMap) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionMap) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.DerivationExpression key = 1; + // .substrait.DerivationExpression key = 1; if (this->has_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2617,7 +2617,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionMap::_InternalSer 1, _Internal::key(this), target, stream); } - // .io.substrait.DerivationExpression value = 2; + // .substrait.DerivationExpression value = 2; if (this->has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2631,7 +2631,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionMap::_InternalSer target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( @@ -2642,26 +2642,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionMap::_InternalSer target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ExpressionMap) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionMap) return target; } size_t DerivationExpression_ExpressionMap::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ExpressionMap) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionMap) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.DerivationExpression key = 1; + // .substrait.DerivationExpression key = 1; if (this->has_key()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *key_); } - // .io.substrait.DerivationExpression value = 2; + // .substrait.DerivationExpression value = 2; if (this->has_value()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2675,7 +2675,7 @@ size_t DerivationExpression_ExpressionMap::ByteSizeLong() const { this->_internal_variation_pointer()); } - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; if (this->nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); @@ -2691,32 +2691,32 @@ size_t DerivationExpression_ExpressionMap::ByteSizeLong() const { } void DerivationExpression_ExpressionMap::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ExpressionMap) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionMap) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_ExpressionMap* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ExpressionMap) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionMap) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ExpressionMap) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionMap) MergeFrom(*source); } } void DerivationExpression_ExpressionMap::MergeFrom(const DerivationExpression_ExpressionMap& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ExpressionMap) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionMap) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_key()) { - _internal_mutable_key()->::io::substrait::DerivationExpression::MergeFrom(from._internal_key()); + _internal_mutable_key()->::substrait::DerivationExpression::MergeFrom(from._internal_key()); } if (from.has_value()) { - _internal_mutable_value()->::io::substrait::DerivationExpression::MergeFrom(from._internal_value()); + _internal_mutable_value()->::substrait::DerivationExpression::MergeFrom(from._internal_value()); } if (from.variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); @@ -2727,14 +2727,14 @@ void DerivationExpression_ExpressionMap::MergeFrom(const DerivationExpression_Ex } void DerivationExpression_ExpressionMap::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ExpressionMap) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionMap) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_ExpressionMap::CopyFrom(const DerivationExpression_ExpressionMap& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ExpressionMap) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionMap) if (&from == this) return; Clear(); MergeFrom(from); @@ -2757,28 +2757,28 @@ void DerivationExpression_ExpressionMap::InternalSwap(DerivationExpression_Expre ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionMap::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[7]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[7]); } // =================================================================== class DerivationExpression_IfElse::_Internal { public: - static const ::io::substrait::DerivationExpression& if_condition(const DerivationExpression_IfElse* msg); - static const ::io::substrait::DerivationExpression& if_return(const DerivationExpression_IfElse* msg); - static const ::io::substrait::DerivationExpression& else_return(const DerivationExpression_IfElse* msg); + static const ::substrait::DerivationExpression& if_condition(const DerivationExpression_IfElse* msg); + static const ::substrait::DerivationExpression& if_return(const DerivationExpression_IfElse* msg); + static const ::substrait::DerivationExpression& else_return(const DerivationExpression_IfElse* msg); }; -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_IfElse::_Internal::if_condition(const DerivationExpression_IfElse* msg) { return *msg->if_condition_; } -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_IfElse::_Internal::if_return(const DerivationExpression_IfElse* msg) { return *msg->if_return_; } -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_IfElse::_Internal::else_return(const DerivationExpression_IfElse* msg) { return *msg->else_return_; } @@ -2786,27 +2786,27 @@ DerivationExpression_IfElse::DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.IfElse) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.IfElse) } DerivationExpression_IfElse::DerivationExpression_IfElse(const DerivationExpression_IfElse& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_if_condition()) { - if_condition_ = new ::io::substrait::DerivationExpression(*from.if_condition_); + if_condition_ = new ::substrait::DerivationExpression(*from.if_condition_); } else { if_condition_ = nullptr; } if (from._internal_has_if_return()) { - if_return_ = new ::io::substrait::DerivationExpression(*from.if_return_); + if_return_ = new ::substrait::DerivationExpression(*from.if_return_); } else { if_return_ = nullptr; } if (from._internal_has_else_return()) { - else_return_ = new ::io::substrait::DerivationExpression(*from.else_return_); + else_return_ = new ::substrait::DerivationExpression(*from.else_return_); } else { else_return_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.IfElse) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.IfElse) } void DerivationExpression_IfElse::SharedCtor() { @@ -2817,7 +2817,7 @@ ::memset(reinterpret_cast(this) + static_cast( } DerivationExpression_IfElse::~DerivationExpression_IfElse() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.IfElse) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.IfElse) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -2840,7 +2840,7 @@ void DerivationExpression_IfElse::SetCachedSize(int size) const { } void DerivationExpression_IfElse::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.IfElse) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.IfElse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2866,21 +2866,21 @@ const char* DerivationExpression_IfElse::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.DerivationExpression if_condition = 1; + // .substrait.DerivationExpression if_condition = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_if_condition(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression if_return = 2; + // .substrait.DerivationExpression if_return = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_if_return(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression else_return = 3; + // .substrait.DerivationExpression else_return = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_else_return(), ptr); @@ -2912,11 +2912,11 @@ const char* DerivationExpression_IfElse::_InternalParse(const char* ptr, ::PROTO ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_IfElse::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.IfElse) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.IfElse) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.DerivationExpression if_condition = 1; + // .substrait.DerivationExpression if_condition = 1; if (this->has_if_condition()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2924,7 +2924,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_IfElse::_InternalSerialize( 1, _Internal::if_condition(this), target, stream); } - // .io.substrait.DerivationExpression if_return = 2; + // .substrait.DerivationExpression if_return = 2; if (this->has_if_return()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2932,7 +2932,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_IfElse::_InternalSerialize( 2, _Internal::if_return(this), target, stream); } - // .io.substrait.DerivationExpression else_return = 3; + // .substrait.DerivationExpression else_return = 3; if (this->has_else_return()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -2944,33 +2944,33 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_IfElse::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.IfElse) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.IfElse) return target; } size_t DerivationExpression_IfElse::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.IfElse) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.IfElse) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.DerivationExpression if_condition = 1; + // .substrait.DerivationExpression if_condition = 1; if (this->has_if_condition()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *if_condition_); } - // .io.substrait.DerivationExpression if_return = 2; + // .substrait.DerivationExpression if_return = 2; if (this->has_if_return()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *if_return_); } - // .io.substrait.DerivationExpression else_return = 3; + // .substrait.DerivationExpression else_return = 3; if (this->has_else_return()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -2987,47 +2987,47 @@ size_t DerivationExpression_IfElse::ByteSizeLong() const { } void DerivationExpression_IfElse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.IfElse) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.IfElse) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_IfElse* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.IfElse) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.IfElse) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.IfElse) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.IfElse) MergeFrom(*source); } } void DerivationExpression_IfElse::MergeFrom(const DerivationExpression_IfElse& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.IfElse) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.IfElse) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_if_condition()) { - _internal_mutable_if_condition()->::io::substrait::DerivationExpression::MergeFrom(from._internal_if_condition()); + _internal_mutable_if_condition()->::substrait::DerivationExpression::MergeFrom(from._internal_if_condition()); } if (from.has_if_return()) { - _internal_mutable_if_return()->::io::substrait::DerivationExpression::MergeFrom(from._internal_if_return()); + _internal_mutable_if_return()->::substrait::DerivationExpression::MergeFrom(from._internal_if_return()); } if (from.has_else_return()) { - _internal_mutable_else_return()->::io::substrait::DerivationExpression::MergeFrom(from._internal_else_return()); + _internal_mutable_else_return()->::substrait::DerivationExpression::MergeFrom(from._internal_else_return()); } } void DerivationExpression_IfElse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.IfElse) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.IfElse) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_IfElse::CopyFrom(const DerivationExpression_IfElse& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.IfElse) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.IfElse) if (&from == this) return; Clear(); MergeFrom(from); @@ -3050,18 +3050,18 @@ void DerivationExpression_IfElse::InternalSwap(DerivationExpression_IfElse* othe ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_IfElse::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[8]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[8]); } // =================================================================== class DerivationExpression_UnaryOp::_Internal { public: - static const ::io::substrait::DerivationExpression& arg(const DerivationExpression_UnaryOp* msg); + static const ::substrait::DerivationExpression& arg(const DerivationExpression_UnaryOp* msg); }; -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::_Internal::arg(const DerivationExpression_UnaryOp* msg) { return *msg->arg_; } @@ -3069,18 +3069,18 @@ DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.UnaryOp) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.UnaryOp) } DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(const DerivationExpression_UnaryOp& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_arg()) { - arg_ = new ::io::substrait::DerivationExpression(*from.arg_); + arg_ = new ::substrait::DerivationExpression(*from.arg_); } else { arg_ = nullptr; } op_type_ = from.op_type_; - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.UnaryOp) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.UnaryOp) } void DerivationExpression_UnaryOp::SharedCtor() { @@ -3091,7 +3091,7 @@ ::memset(reinterpret_cast(this) + static_cast( } DerivationExpression_UnaryOp::~DerivationExpression_UnaryOp() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.UnaryOp) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.UnaryOp) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3112,7 +3112,7 @@ void DerivationExpression_UnaryOp::SetCachedSize(int size) const { } void DerivationExpression_UnaryOp::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.UnaryOp) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.UnaryOp) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3131,15 +3131,15 @@ const char* DerivationExpression_UnaryOp::_InternalParse(const char* ptr, ::PROT ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.DerivationExpression.UnaryOp.OpType op_type = 1; + // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_op_type(static_cast<::io::substrait::DerivationExpression_UnaryOp_OpType>(val)); + _internal_set_op_type(static_cast<::substrait::DerivationExpression_UnaryOp_UnaryOpType>(val)); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression arg = 2; + // .substrait.DerivationExpression arg = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_arg(), ptr); @@ -3171,18 +3171,18 @@ const char* DerivationExpression_UnaryOp::_InternalParse(const char* ptr, ::PROT ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_UnaryOp::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.UnaryOp) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.UnaryOp) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.DerivationExpression.UnaryOp.OpType op_type = 1; + // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; if (this->op_type() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_op_type(), target); } - // .io.substrait.DerivationExpression arg = 2; + // .substrait.DerivationExpression arg = 2; if (this->has_arg()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3194,26 +3194,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_UnaryOp::_InternalSerialize target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.UnaryOp) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.UnaryOp) return target; } size_t DerivationExpression_UnaryOp::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.UnaryOp) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.UnaryOp) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.DerivationExpression arg = 2; + // .substrait.DerivationExpression arg = 2; if (this->has_arg()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *arg_); } - // .io.substrait.DerivationExpression.UnaryOp.OpType op_type = 1; + // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; if (this->op_type() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type()); @@ -3229,29 +3229,29 @@ size_t DerivationExpression_UnaryOp::ByteSizeLong() const { } void DerivationExpression_UnaryOp::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.UnaryOp) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.UnaryOp) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_UnaryOp* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.UnaryOp) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.UnaryOp) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.UnaryOp) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.UnaryOp) MergeFrom(*source); } } void DerivationExpression_UnaryOp::MergeFrom(const DerivationExpression_UnaryOp& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.UnaryOp) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.UnaryOp) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_arg()) { - _internal_mutable_arg()->::io::substrait::DerivationExpression::MergeFrom(from._internal_arg()); + _internal_mutable_arg()->::substrait::DerivationExpression::MergeFrom(from._internal_arg()); } if (from.op_type() != 0) { _internal_set_op_type(from._internal_op_type()); @@ -3259,14 +3259,14 @@ void DerivationExpression_UnaryOp::MergeFrom(const DerivationExpression_UnaryOp& } void DerivationExpression_UnaryOp::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.UnaryOp) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.UnaryOp) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_UnaryOp::CopyFrom(const DerivationExpression_UnaryOp& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.UnaryOp) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.UnaryOp) if (&from == this) return; Clear(); MergeFrom(from); @@ -3289,23 +3289,23 @@ void DerivationExpression_UnaryOp::InternalSwap(DerivationExpression_UnaryOp* ot ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_UnaryOp::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[9]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[9]); } // =================================================================== class DerivationExpression_BinaryOp::_Internal { public: - static const ::io::substrait::DerivationExpression& arg1(const DerivationExpression_BinaryOp* msg); - static const ::io::substrait::DerivationExpression& arg2(const DerivationExpression_BinaryOp* msg); + static const ::substrait::DerivationExpression& arg1(const DerivationExpression_BinaryOp* msg); + static const ::substrait::DerivationExpression& arg2(const DerivationExpression_BinaryOp* msg); }; -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_Internal::arg1(const DerivationExpression_BinaryOp* msg) { return *msg->arg1_; } -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_Internal::arg2(const DerivationExpression_BinaryOp* msg) { return *msg->arg2_; } @@ -3313,23 +3313,23 @@ DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(::PROTOBUF_NAMESPAC : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.BinaryOp) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.BinaryOp) } DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(const DerivationExpression_BinaryOp& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_arg1()) { - arg1_ = new ::io::substrait::DerivationExpression(*from.arg1_); + arg1_ = new ::substrait::DerivationExpression(*from.arg1_); } else { arg1_ = nullptr; } if (from._internal_has_arg2()) { - arg2_ = new ::io::substrait::DerivationExpression(*from.arg2_); + arg2_ = new ::substrait::DerivationExpression(*from.arg2_); } else { arg2_ = nullptr; } op_type_ = from.op_type_; - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.BinaryOp) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.BinaryOp) } void DerivationExpression_BinaryOp::SharedCtor() { @@ -3340,7 +3340,7 @@ ::memset(reinterpret_cast(this) + static_cast( } DerivationExpression_BinaryOp::~DerivationExpression_BinaryOp() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.BinaryOp) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.BinaryOp) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3362,7 +3362,7 @@ void DerivationExpression_BinaryOp::SetCachedSize(int size) const { } void DerivationExpression_BinaryOp::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.BinaryOp) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.BinaryOp) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3385,22 +3385,22 @@ const char* DerivationExpression_BinaryOp::_InternalParse(const char* ptr, ::PRO ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.DerivationExpression.BinaryOp.OpType op_type = 1; + // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - _internal_set_op_type(static_cast<::io::substrait::DerivationExpression_BinaryOp_OpType>(val)); + _internal_set_op_type(static_cast<::substrait::DerivationExpression_BinaryOp_BinaryOpType>(val)); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression arg1 = 2; + // .substrait.DerivationExpression arg1 = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_arg1(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression arg2 = 3; + // .substrait.DerivationExpression arg2 = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_arg2(), ptr); @@ -3432,18 +3432,18 @@ const char* DerivationExpression_BinaryOp::_InternalParse(const char* ptr, ::PRO ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_BinaryOp::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.BinaryOp) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.BinaryOp) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.DerivationExpression.BinaryOp.OpType op_type = 1; + // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; if (this->op_type() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_op_type(), target); } - // .io.substrait.DerivationExpression arg1 = 2; + // .substrait.DerivationExpression arg1 = 2; if (this->has_arg1()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3451,7 +3451,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_BinaryOp::_InternalSerializ 2, _Internal::arg1(this), target, stream); } - // .io.substrait.DerivationExpression arg2 = 3; + // .substrait.DerivationExpression arg2 = 3; if (this->has_arg2()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3463,33 +3463,33 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_BinaryOp::_InternalSerializ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.BinaryOp) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.BinaryOp) return target; } size_t DerivationExpression_BinaryOp::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.BinaryOp) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.BinaryOp) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // .io.substrait.DerivationExpression arg1 = 2; + // .substrait.DerivationExpression arg1 = 2; if (this->has_arg1()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *arg1_); } - // .io.substrait.DerivationExpression arg2 = 3; + // .substrait.DerivationExpression arg2 = 3; if (this->has_arg2()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *arg2_); } - // .io.substrait.DerivationExpression.BinaryOp.OpType op_type = 1; + // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; if (this->op_type() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type()); @@ -3505,32 +3505,32 @@ size_t DerivationExpression_BinaryOp::ByteSizeLong() const { } void DerivationExpression_BinaryOp::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.BinaryOp) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.BinaryOp) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_BinaryOp* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.BinaryOp) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.BinaryOp) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.BinaryOp) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.BinaryOp) MergeFrom(*source); } } void DerivationExpression_BinaryOp::MergeFrom(const DerivationExpression_BinaryOp& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.BinaryOp) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.BinaryOp) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; if (from.has_arg1()) { - _internal_mutable_arg1()->::io::substrait::DerivationExpression::MergeFrom(from._internal_arg1()); + _internal_mutable_arg1()->::substrait::DerivationExpression::MergeFrom(from._internal_arg1()); } if (from.has_arg2()) { - _internal_mutable_arg2()->::io::substrait::DerivationExpression::MergeFrom(from._internal_arg2()); + _internal_mutable_arg2()->::substrait::DerivationExpression::MergeFrom(from._internal_arg2()); } if (from.op_type() != 0) { _internal_set_op_type(from._internal_op_type()); @@ -3538,14 +3538,14 @@ void DerivationExpression_BinaryOp::MergeFrom(const DerivationExpression_BinaryO } void DerivationExpression_BinaryOp::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.BinaryOp) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.BinaryOp) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_BinaryOp::CopyFrom(const DerivationExpression_BinaryOp& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.BinaryOp) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.BinaryOp) if (&from == this) return; Clear(); MergeFrom(from); @@ -3568,18 +3568,18 @@ void DerivationExpression_BinaryOp::InternalSwap(DerivationExpression_BinaryOp* ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_BinaryOp::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[10]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[10]); } // =================================================================== class DerivationExpression_ReturnProgram_Assignment::_Internal { public: - static const ::io::substrait::DerivationExpression& expression(const DerivationExpression_ReturnProgram_Assignment* msg); + static const ::substrait::DerivationExpression& expression(const DerivationExpression_ReturnProgram_Assignment* msg); }; -const ::io::substrait::DerivationExpression& +const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::_Internal::expression(const DerivationExpression_ReturnProgram_Assignment* msg) { return *msg->expression_; } @@ -3587,7 +3587,7 @@ DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgra : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ReturnProgram.Assignment) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ReturnProgram.Assignment) } DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(const DerivationExpression_ReturnProgram_Assignment& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -3598,11 +3598,11 @@ DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgra GetArena()); } if (from._internal_has_expression()) { - expression_ = new ::io::substrait::DerivationExpression(*from.expression_); + expression_ = new ::substrait::DerivationExpression(*from.expression_); } else { expression_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ReturnProgram.Assignment) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ReturnProgram.Assignment) } void DerivationExpression_ReturnProgram_Assignment::SharedCtor() { @@ -3611,7 +3611,7 @@ expression_ = nullptr; } DerivationExpression_ReturnProgram_Assignment::~DerivationExpression_ReturnProgram_Assignment() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ReturnProgram.Assignment) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ReturnProgram.Assignment) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3633,7 +3633,7 @@ void DerivationExpression_ReturnProgram_Assignment::SetCachedSize(int size) cons } void DerivationExpression_ReturnProgram_Assignment::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ReturnProgram.Assignment) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3657,11 +3657,11 @@ const char* DerivationExpression_ReturnProgram_Assignment::_InternalParse(const if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.DerivationExpression.ReturnProgram.Assignment.name")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.ReturnProgram.Assignment.name")); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression expression = 2; + // .substrait.DerivationExpression expression = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); @@ -3693,7 +3693,7 @@ const char* DerivationExpression_ReturnProgram_Assignment::_InternalParse(const ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram_Assignment::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ReturnProgram.Assignment) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; @@ -3702,12 +3702,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram_Assignment::_ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.DerivationExpression.ReturnProgram.Assignment.name"); + "substrait.DerivationExpression.ReturnProgram.Assignment.name"); target = stream->WriteStringMaybeAliased( 1, this->_internal_name(), target); } - // .io.substrait.DerivationExpression expression = 2; + // .substrait.DerivationExpression expression = 2; if (this->has_expression()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -3719,12 +3719,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram_Assignment::_ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ReturnProgram.Assignment) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ReturnProgram.Assignment) return target; } size_t DerivationExpression_ReturnProgram_Assignment::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ReturnProgram.Assignment) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3738,7 +3738,7 @@ size_t DerivationExpression_ReturnProgram_Assignment::ByteSizeLong() const { this->_internal_name()); } - // .io.substrait.DerivationExpression expression = 2; + // .substrait.DerivationExpression expression = 2; if (this->has_expression()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -3755,22 +3755,22 @@ size_t DerivationExpression_ReturnProgram_Assignment::ByteSizeLong() const { } void DerivationExpression_ReturnProgram_Assignment::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ReturnProgram.Assignment) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_ReturnProgram_Assignment* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ReturnProgram.Assignment) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ReturnProgram.Assignment) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ReturnProgram.Assignment) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ReturnProgram.Assignment) MergeFrom(*source); } } void DerivationExpression_ReturnProgram_Assignment::MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ReturnProgram.Assignment) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -3780,19 +3780,19 @@ void DerivationExpression_ReturnProgram_Assignment::MergeFrom(const DerivationEx _internal_set_name(from._internal_name()); } if (from.has_expression()) { - _internal_mutable_expression()->::io::substrait::DerivationExpression::MergeFrom(from._internal_expression()); + _internal_mutable_expression()->::substrait::DerivationExpression::MergeFrom(from._internal_expression()); } } void DerivationExpression_ReturnProgram_Assignment::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ReturnProgram.Assignment) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_ReturnProgram_Assignment::CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ReturnProgram.Assignment) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ReturnProgram.Assignment) if (&from == this) return; Clear(); MergeFrom(from); @@ -3811,53 +3811,53 @@ void DerivationExpression_ReturnProgram_Assignment::InternalSwap(DerivationExpre ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ReturnProgram_Assignment::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[11]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[11]); } // =================================================================== class DerivationExpression_ReturnProgram::_Internal { public: - static const ::io::substrait::DerivationExpression& finalexpression(const DerivationExpression_ReturnProgram* msg); + static const ::substrait::DerivationExpression& final_expression(const DerivationExpression_ReturnProgram* msg); }; -const ::io::substrait::DerivationExpression& -DerivationExpression_ReturnProgram::_Internal::finalexpression(const DerivationExpression_ReturnProgram* msg) { - return *msg->finalexpression_; +const ::substrait::DerivationExpression& +DerivationExpression_ReturnProgram::_Internal::final_expression(const DerivationExpression_ReturnProgram* msg) { + return *msg->final_expression_; } DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena), assignments_(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression.ReturnProgram) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ReturnProgram) } DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(const DerivationExpression_ReturnProgram& from) : ::PROTOBUF_NAMESPACE_ID::Message(), assignments_(from.assignments_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_finalexpression()) { - finalexpression_ = new ::io::substrait::DerivationExpression(*from.finalexpression_); + if (from._internal_has_final_expression()) { + final_expression_ = new ::substrait::DerivationExpression(*from.final_expression_); } else { - finalexpression_ = nullptr; + final_expression_ = nullptr; } - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression.ReturnProgram) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ReturnProgram) } void DerivationExpression_ReturnProgram::SharedCtor() { -finalexpression_ = nullptr; +final_expression_ = nullptr; } DerivationExpression_ReturnProgram::~DerivationExpression_ReturnProgram() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression.ReturnProgram) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ReturnProgram) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } void DerivationExpression_ReturnProgram::SharedDtor() { GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete finalexpression_; + if (this != internal_default_instance()) delete final_expression_; } void DerivationExpression_ReturnProgram::ArenaDtor(void* object) { @@ -3871,16 +3871,16 @@ void DerivationExpression_ReturnProgram::SetCachedSize(int size) const { } void DerivationExpression_ReturnProgram::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression.ReturnProgram) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ReturnProgram) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; assignments_.Clear(); - if (GetArena() == nullptr && finalexpression_ != nullptr) { - delete finalexpression_; + if (GetArena() == nullptr && final_expression_ != nullptr) { + delete final_expression_; } - finalexpression_ = nullptr; + final_expression_ = nullptr; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -3890,7 +3890,7 @@ const char* DerivationExpression_ReturnProgram::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // repeated .io.substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; + // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr -= 1; @@ -3902,10 +3902,10 @@ const char* DerivationExpression_ReturnProgram::_InternalParse(const char* ptr, } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression finalExpression = 2; + // .substrait.DerivationExpression final_expression = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_finalexpression(), ptr); + ptr = ctx->ParseMessage(_internal_mutable_final_expression(), ptr); CHK_(ptr); } else goto handle_unusual; continue; @@ -3934,11 +3934,11 @@ const char* DerivationExpression_ReturnProgram::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression.ReturnProgram) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ReturnProgram) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // repeated .io.substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; + // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; for (unsigned int i = 0, n = static_cast(this->_internal_assignments_size()); i < n; i++) { target = stream->EnsureSpace(target); @@ -3946,42 +3946,42 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram::_InternalSer InternalWriteMessage(1, this->_internal_assignments(i), target, stream); } - // .io.substrait.DerivationExpression finalExpression = 2; - if (this->has_finalexpression()) { + // .substrait.DerivationExpression final_expression = 2; + if (this->has_final_expression()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( - 2, _Internal::finalexpression(this), target, stream); + 2, _Internal::final_expression(this), target, stream); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression.ReturnProgram) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ReturnProgram) return target; } size_t DerivationExpression_ReturnProgram::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression.ReturnProgram) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ReturnProgram) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - // repeated .io.substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; + // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; total_size += 1UL * this->_internal_assignments_size(); for (const auto& msg : this->assignments_) { total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - // .io.substrait.DerivationExpression finalExpression = 2; - if (this->has_finalexpression()) { + // .substrait.DerivationExpression final_expression = 2; + if (this->has_final_expression()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *finalexpression_); + *final_expression_); } if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { @@ -3994,42 +3994,42 @@ size_t DerivationExpression_ReturnProgram::ByteSizeLong() const { } void DerivationExpression_ReturnProgram::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression.ReturnProgram) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ReturnProgram) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression_ReturnProgram* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression.ReturnProgram) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ReturnProgram) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression.ReturnProgram) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ReturnProgram) MergeFrom(*source); } } void DerivationExpression_ReturnProgram::MergeFrom(const DerivationExpression_ReturnProgram& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression.ReturnProgram) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ReturnProgram) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; assignments_.MergeFrom(from.assignments_); - if (from.has_finalexpression()) { - _internal_mutable_finalexpression()->::io::substrait::DerivationExpression::MergeFrom(from._internal_finalexpression()); + if (from.has_final_expression()) { + _internal_mutable_final_expression()->::substrait::DerivationExpression::MergeFrom(from._internal_final_expression()); } } void DerivationExpression_ReturnProgram::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression.ReturnProgram) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ReturnProgram) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression_ReturnProgram::CopyFrom(const DerivationExpression_ReturnProgram& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression.ReturnProgram) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ReturnProgram) if (&from == this) return; Clear(); MergeFrom(from); @@ -4043,157 +4043,157 @@ void DerivationExpression_ReturnProgram::InternalSwap(DerivationExpression_Retur using std::swap; _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); assignments_.InternalSwap(&other->assignments_); - swap(finalexpression_, other->finalexpression_); + swap(final_expression_, other->final_expression_); } ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ReturnProgram::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[12]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[12]); } // =================================================================== class DerivationExpression::_Internal { public: - static const ::io::substrait::Type_Boolean& bool_(const DerivationExpression* msg); - static const ::io::substrait::Type_I8& i8(const DerivationExpression* msg); - static const ::io::substrait::Type_I16& i16(const DerivationExpression* msg); - static const ::io::substrait::Type_I32& i32(const DerivationExpression* msg); - static const ::io::substrait::Type_I64& i64(const DerivationExpression* msg); - static const ::io::substrait::Type_FP32& fp32(const DerivationExpression* msg); - static const ::io::substrait::Type_FP64& fp64(const DerivationExpression* msg); - static const ::io::substrait::Type_String& string(const DerivationExpression* msg); - static const ::io::substrait::Type_Binary& binary(const DerivationExpression* msg); - static const ::io::substrait::Type_Timestamp& timestamp(const DerivationExpression* msg); - static const ::io::substrait::Type_Date& date(const DerivationExpression* msg); - static const ::io::substrait::Type_Time& time(const DerivationExpression* msg); - static const ::io::substrait::Type_IntervalYear& interval_year(const DerivationExpression* msg); - static const ::io::substrait::Type_IntervalDay& interval_day(const DerivationExpression* msg); - static const ::io::substrait::Type_TimestampTZ& timestamp_tz(const DerivationExpression* msg); - static const ::io::substrait::Type_UUID& uuid(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_ExpressionFixedChar& fixed_char(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_ExpressionVarChar& varchar(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_ExpressionDecimal& decimal(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_ExpressionList& list(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_ExpressionMap& map(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_UnaryOp& unary_op(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_BinaryOp& binary_op(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_IfElse& if_else(const DerivationExpression* msg); - static const ::io::substrait::DerivationExpression_ReturnProgram& return_program(const DerivationExpression* msg); + static const ::substrait::Type_Boolean& bool_(const DerivationExpression* msg); + static const ::substrait::Type_I8& i8(const DerivationExpression* msg); + static const ::substrait::Type_I16& i16(const DerivationExpression* msg); + static const ::substrait::Type_I32& i32(const DerivationExpression* msg); + static const ::substrait::Type_I64& i64(const DerivationExpression* msg); + static const ::substrait::Type_FP32& fp32(const DerivationExpression* msg); + static const ::substrait::Type_FP64& fp64(const DerivationExpression* msg); + static const ::substrait::Type_String& string(const DerivationExpression* msg); + static const ::substrait::Type_Binary& binary(const DerivationExpression* msg); + static const ::substrait::Type_Timestamp& timestamp(const DerivationExpression* msg); + static const ::substrait::Type_Date& date(const DerivationExpression* msg); + static const ::substrait::Type_Time& time(const DerivationExpression* msg); + static const ::substrait::Type_IntervalYear& interval_year(const DerivationExpression* msg); + static const ::substrait::Type_IntervalDay& interval_day(const DerivationExpression* msg); + static const ::substrait::Type_TimestampTZ& timestamp_tz(const DerivationExpression* msg); + static const ::substrait::Type_UUID& uuid(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_ExpressionFixedChar& fixed_char(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_ExpressionVarChar& varchar(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_ExpressionDecimal& decimal(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_ExpressionList& list(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_ExpressionMap& map(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_UnaryOp& unary_op(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_BinaryOp& binary_op(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_IfElse& if_else(const DerivationExpression* msg); + static const ::substrait::DerivationExpression_ReturnProgram& return_program(const DerivationExpression* msg); }; -const ::io::substrait::Type_Boolean& +const ::substrait::Type_Boolean& DerivationExpression::_Internal::bool_(const DerivationExpression* msg) { return *msg->kind_.bool__; } -const ::io::substrait::Type_I8& +const ::substrait::Type_I8& DerivationExpression::_Internal::i8(const DerivationExpression* msg) { return *msg->kind_.i8_; } -const ::io::substrait::Type_I16& +const ::substrait::Type_I16& DerivationExpression::_Internal::i16(const DerivationExpression* msg) { return *msg->kind_.i16_; } -const ::io::substrait::Type_I32& +const ::substrait::Type_I32& DerivationExpression::_Internal::i32(const DerivationExpression* msg) { return *msg->kind_.i32_; } -const ::io::substrait::Type_I64& +const ::substrait::Type_I64& DerivationExpression::_Internal::i64(const DerivationExpression* msg) { return *msg->kind_.i64_; } -const ::io::substrait::Type_FP32& +const ::substrait::Type_FP32& DerivationExpression::_Internal::fp32(const DerivationExpression* msg) { return *msg->kind_.fp32_; } -const ::io::substrait::Type_FP64& +const ::substrait::Type_FP64& DerivationExpression::_Internal::fp64(const DerivationExpression* msg) { return *msg->kind_.fp64_; } -const ::io::substrait::Type_String& +const ::substrait::Type_String& DerivationExpression::_Internal::string(const DerivationExpression* msg) { return *msg->kind_.string_; } -const ::io::substrait::Type_Binary& +const ::substrait::Type_Binary& DerivationExpression::_Internal::binary(const DerivationExpression* msg) { return *msg->kind_.binary_; } -const ::io::substrait::Type_Timestamp& +const ::substrait::Type_Timestamp& DerivationExpression::_Internal::timestamp(const DerivationExpression* msg) { return *msg->kind_.timestamp_; } -const ::io::substrait::Type_Date& +const ::substrait::Type_Date& DerivationExpression::_Internal::date(const DerivationExpression* msg) { return *msg->kind_.date_; } -const ::io::substrait::Type_Time& +const ::substrait::Type_Time& DerivationExpression::_Internal::time(const DerivationExpression* msg) { return *msg->kind_.time_; } -const ::io::substrait::Type_IntervalYear& +const ::substrait::Type_IntervalYear& DerivationExpression::_Internal::interval_year(const DerivationExpression* msg) { return *msg->kind_.interval_year_; } -const ::io::substrait::Type_IntervalDay& +const ::substrait::Type_IntervalDay& DerivationExpression::_Internal::interval_day(const DerivationExpression* msg) { return *msg->kind_.interval_day_; } -const ::io::substrait::Type_TimestampTZ& +const ::substrait::Type_TimestampTZ& DerivationExpression::_Internal::timestamp_tz(const DerivationExpression* msg) { return *msg->kind_.timestamp_tz_; } -const ::io::substrait::Type_UUID& +const ::substrait::Type_UUID& DerivationExpression::_Internal::uuid(const DerivationExpression* msg) { return *msg->kind_.uuid_; } -const ::io::substrait::DerivationExpression_ExpressionFixedChar& +const ::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::_Internal::fixed_char(const DerivationExpression* msg) { return *msg->kind_.fixed_char_; } -const ::io::substrait::DerivationExpression_ExpressionVarChar& +const ::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::_Internal::varchar(const DerivationExpression* msg) { return *msg->kind_.varchar_; } -const ::io::substrait::DerivationExpression_ExpressionFixedBinary& +const ::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::_Internal::fixed_binary(const DerivationExpression* msg) { return *msg->kind_.fixed_binary_; } -const ::io::substrait::DerivationExpression_ExpressionDecimal& +const ::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::_Internal::decimal(const DerivationExpression* msg) { return *msg->kind_.decimal_; } -const ::io::substrait::DerivationExpression_ExpressionStruct& +const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::_Internal::struct_(const DerivationExpression* msg) { return *msg->kind_.struct__; } -const ::io::substrait::DerivationExpression_ExpressionList& +const ::substrait::DerivationExpression_ExpressionList& DerivationExpression::_Internal::list(const DerivationExpression* msg) { return *msg->kind_.list_; } -const ::io::substrait::DerivationExpression_ExpressionMap& +const ::substrait::DerivationExpression_ExpressionMap& DerivationExpression::_Internal::map(const DerivationExpression* msg) { return *msg->kind_.map_; } -const ::io::substrait::DerivationExpression_UnaryOp& +const ::substrait::DerivationExpression_UnaryOp& DerivationExpression::_Internal::unary_op(const DerivationExpression* msg) { return *msg->kind_.unary_op_; } -const ::io::substrait::DerivationExpression_BinaryOp& +const ::substrait::DerivationExpression_BinaryOp& DerivationExpression::_Internal::binary_op(const DerivationExpression* msg) { return *msg->kind_.binary_op_; } -const ::io::substrait::DerivationExpression_IfElse& +const ::substrait::DerivationExpression_IfElse& DerivationExpression::_Internal::if_else(const DerivationExpression* msg) { return *msg->kind_.if_else_; } -const ::io::substrait::DerivationExpression_ReturnProgram& +const ::substrait::DerivationExpression_ReturnProgram& DerivationExpression::_Internal::return_program(const DerivationExpression* msg) { return *msg->kind_.return_program_; } -void DerivationExpression::set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { +void DerivationExpression::set_allocated_bool_(::substrait::Type_Boolean* bool_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (bool_) { @@ -4206,7 +4206,7 @@ void DerivationExpression::set_allocated_bool_(::io::substrait::Type_Boolean* bo set_has_bool_(); kind_.bool__ = bool_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.bool) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.bool) } void DerivationExpression::clear_bool_() { if (_internal_has_bool_()) { @@ -4216,7 +4216,7 @@ void DerivationExpression::clear_bool_() { clear_has_kind(); } } -void DerivationExpression::set_allocated_i8(::io::substrait::Type_I8* i8) { +void DerivationExpression::set_allocated_i8(::substrait::Type_I8* i8) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i8) { @@ -4229,7 +4229,7 @@ void DerivationExpression::set_allocated_i8(::io::substrait::Type_I8* i8) { set_has_i8(); kind_.i8_ = i8; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.i8) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i8) } void DerivationExpression::clear_i8() { if (_internal_has_i8()) { @@ -4239,7 +4239,7 @@ void DerivationExpression::clear_i8() { clear_has_kind(); } } -void DerivationExpression::set_allocated_i16(::io::substrait::Type_I16* i16) { +void DerivationExpression::set_allocated_i16(::substrait::Type_I16* i16) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i16) { @@ -4252,7 +4252,7 @@ void DerivationExpression::set_allocated_i16(::io::substrait::Type_I16* i16) { set_has_i16(); kind_.i16_ = i16; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.i16) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i16) } void DerivationExpression::clear_i16() { if (_internal_has_i16()) { @@ -4262,7 +4262,7 @@ void DerivationExpression::clear_i16() { clear_has_kind(); } } -void DerivationExpression::set_allocated_i32(::io::substrait::Type_I32* i32) { +void DerivationExpression::set_allocated_i32(::substrait::Type_I32* i32) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i32) { @@ -4275,7 +4275,7 @@ void DerivationExpression::set_allocated_i32(::io::substrait::Type_I32* i32) { set_has_i32(); kind_.i32_ = i32; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.i32) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i32) } void DerivationExpression::clear_i32() { if (_internal_has_i32()) { @@ -4285,7 +4285,7 @@ void DerivationExpression::clear_i32() { clear_has_kind(); } } -void DerivationExpression::set_allocated_i64(::io::substrait::Type_I64* i64) { +void DerivationExpression::set_allocated_i64(::substrait::Type_I64* i64) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (i64) { @@ -4298,7 +4298,7 @@ void DerivationExpression::set_allocated_i64(::io::substrait::Type_I64* i64) { set_has_i64(); kind_.i64_ = i64; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.i64) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i64) } void DerivationExpression::clear_i64() { if (_internal_has_i64()) { @@ -4308,7 +4308,7 @@ void DerivationExpression::clear_i64() { clear_has_kind(); } } -void DerivationExpression::set_allocated_fp32(::io::substrait::Type_FP32* fp32) { +void DerivationExpression::set_allocated_fp32(::substrait::Type_FP32* fp32) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fp32) { @@ -4321,7 +4321,7 @@ void DerivationExpression::set_allocated_fp32(::io::substrait::Type_FP32* fp32) set_has_fp32(); kind_.fp32_ = fp32; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.fp32) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fp32) } void DerivationExpression::clear_fp32() { if (_internal_has_fp32()) { @@ -4331,7 +4331,7 @@ void DerivationExpression::clear_fp32() { clear_has_kind(); } } -void DerivationExpression::set_allocated_fp64(::io::substrait::Type_FP64* fp64) { +void DerivationExpression::set_allocated_fp64(::substrait::Type_FP64* fp64) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fp64) { @@ -4344,7 +4344,7 @@ void DerivationExpression::set_allocated_fp64(::io::substrait::Type_FP64* fp64) set_has_fp64(); kind_.fp64_ = fp64; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.fp64) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fp64) } void DerivationExpression::clear_fp64() { if (_internal_has_fp64()) { @@ -4354,7 +4354,7 @@ void DerivationExpression::clear_fp64() { clear_has_kind(); } } -void DerivationExpression::set_allocated_string(::io::substrait::Type_String* string) { +void DerivationExpression::set_allocated_string(::substrait::Type_String* string) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (string) { @@ -4367,7 +4367,7 @@ void DerivationExpression::set_allocated_string(::io::substrait::Type_String* st set_has_string(); kind_.string_ = string; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.string) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.string) } void DerivationExpression::clear_string() { if (_internal_has_string()) { @@ -4377,7 +4377,7 @@ void DerivationExpression::clear_string() { clear_has_kind(); } } -void DerivationExpression::set_allocated_binary(::io::substrait::Type_Binary* binary) { +void DerivationExpression::set_allocated_binary(::substrait::Type_Binary* binary) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (binary) { @@ -4390,7 +4390,7 @@ void DerivationExpression::set_allocated_binary(::io::substrait::Type_Binary* bi set_has_binary(); kind_.binary_ = binary; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.binary) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.binary) } void DerivationExpression::clear_binary() { if (_internal_has_binary()) { @@ -4400,7 +4400,7 @@ void DerivationExpression::clear_binary() { clear_has_kind(); } } -void DerivationExpression::set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { +void DerivationExpression::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (timestamp) { @@ -4413,7 +4413,7 @@ void DerivationExpression::set_allocated_timestamp(::io::substrait::Type_Timesta set_has_timestamp(); kind_.timestamp_ = timestamp; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.timestamp) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.timestamp) } void DerivationExpression::clear_timestamp() { if (_internal_has_timestamp()) { @@ -4423,7 +4423,7 @@ void DerivationExpression::clear_timestamp() { clear_has_kind(); } } -void DerivationExpression::set_allocated_date(::io::substrait::Type_Date* date) { +void DerivationExpression::set_allocated_date(::substrait::Type_Date* date) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (date) { @@ -4436,7 +4436,7 @@ void DerivationExpression::set_allocated_date(::io::substrait::Type_Date* date) set_has_date(); kind_.date_ = date; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.date) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.date) } void DerivationExpression::clear_date() { if (_internal_has_date()) { @@ -4446,7 +4446,7 @@ void DerivationExpression::clear_date() { clear_has_kind(); } } -void DerivationExpression::set_allocated_time(::io::substrait::Type_Time* time) { +void DerivationExpression::set_allocated_time(::substrait::Type_Time* time) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (time) { @@ -4459,7 +4459,7 @@ void DerivationExpression::set_allocated_time(::io::substrait::Type_Time* time) set_has_time(); kind_.time_ = time; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.time) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.time) } void DerivationExpression::clear_time() { if (_internal_has_time()) { @@ -4469,7 +4469,7 @@ void DerivationExpression::clear_time() { clear_has_kind(); } } -void DerivationExpression::set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { +void DerivationExpression::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (interval_year) { @@ -4482,7 +4482,7 @@ void DerivationExpression::set_allocated_interval_year(::io::substrait::Type_Int set_has_interval_year(); kind_.interval_year_ = interval_year; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.interval_year) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.interval_year) } void DerivationExpression::clear_interval_year() { if (_internal_has_interval_year()) { @@ -4492,7 +4492,7 @@ void DerivationExpression::clear_interval_year() { clear_has_kind(); } } -void DerivationExpression::set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { +void DerivationExpression::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (interval_day) { @@ -4505,7 +4505,7 @@ void DerivationExpression::set_allocated_interval_day(::io::substrait::Type_Inte set_has_interval_day(); kind_.interval_day_ = interval_day; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.interval_day) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.interval_day) } void DerivationExpression::clear_interval_day() { if (_internal_has_interval_day()) { @@ -4515,7 +4515,7 @@ void DerivationExpression::clear_interval_day() { clear_has_kind(); } } -void DerivationExpression::set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { +void DerivationExpression::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (timestamp_tz) { @@ -4528,7 +4528,7 @@ void DerivationExpression::set_allocated_timestamp_tz(::io::substrait::Type_Time set_has_timestamp_tz(); kind_.timestamp_tz_ = timestamp_tz; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.timestamp_tz) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.timestamp_tz) } void DerivationExpression::clear_timestamp_tz() { if (_internal_has_timestamp_tz()) { @@ -4538,7 +4538,7 @@ void DerivationExpression::clear_timestamp_tz() { clear_has_kind(); } } -void DerivationExpression::set_allocated_uuid(::io::substrait::Type_UUID* uuid) { +void DerivationExpression::set_allocated_uuid(::substrait::Type_UUID* uuid) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (uuid) { @@ -4551,7 +4551,7 @@ void DerivationExpression::set_allocated_uuid(::io::substrait::Type_UUID* uuid) set_has_uuid(); kind_.uuid_ = uuid; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.uuid) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.uuid) } void DerivationExpression::clear_uuid() { if (_internal_has_uuid()) { @@ -4561,7 +4561,7 @@ void DerivationExpression::clear_uuid() { clear_has_kind(); } } -void DerivationExpression::set_allocated_fixed_char(::io::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) { +void DerivationExpression::set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fixed_char) { @@ -4574,9 +4574,9 @@ void DerivationExpression::set_allocated_fixed_char(::io::substrait::DerivationE set_has_fixed_char(); kind_.fixed_char_ = fixed_char; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.fixed_char) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fixed_char) } -void DerivationExpression::set_allocated_varchar(::io::substrait::DerivationExpression_ExpressionVarChar* varchar) { +void DerivationExpression::set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (varchar) { @@ -4589,9 +4589,9 @@ void DerivationExpression::set_allocated_varchar(::io::substrait::DerivationExpr set_has_varchar(); kind_.varchar_ = varchar; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.varchar) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.varchar) } -void DerivationExpression::set_allocated_fixed_binary(::io::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) { +void DerivationExpression::set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (fixed_binary) { @@ -4604,9 +4604,9 @@ void DerivationExpression::set_allocated_fixed_binary(::io::substrait::Derivatio set_has_fixed_binary(); kind_.fixed_binary_ = fixed_binary; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.fixed_binary) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fixed_binary) } -void DerivationExpression::set_allocated_decimal(::io::substrait::DerivationExpression_ExpressionDecimal* decimal) { +void DerivationExpression::set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (decimal) { @@ -4619,9 +4619,9 @@ void DerivationExpression::set_allocated_decimal(::io::substrait::DerivationExpr set_has_decimal(); kind_.decimal_ = decimal; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.decimal) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.decimal) } -void DerivationExpression::set_allocated_struct_(::io::substrait::DerivationExpression_ExpressionStruct* struct_) { +void DerivationExpression::set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (struct_) { @@ -4634,9 +4634,9 @@ void DerivationExpression::set_allocated_struct_(::io::substrait::DerivationExpr set_has_struct_(); kind_.struct__ = struct_; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.struct) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.struct) } -void DerivationExpression::set_allocated_list(::io::substrait::DerivationExpression_ExpressionList* list) { +void DerivationExpression::set_allocated_list(::substrait::DerivationExpression_ExpressionList* list) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (list) { @@ -4649,9 +4649,9 @@ void DerivationExpression::set_allocated_list(::io::substrait::DerivationExpress set_has_list(); kind_.list_ = list; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.list) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.list) } -void DerivationExpression::set_allocated_map(::io::substrait::DerivationExpression_ExpressionMap* map) { +void DerivationExpression::set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (map) { @@ -4664,9 +4664,9 @@ void DerivationExpression::set_allocated_map(::io::substrait::DerivationExpressi set_has_map(); kind_.map_ = map; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.map) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.map) } -void DerivationExpression::set_allocated_unary_op(::io::substrait::DerivationExpression_UnaryOp* unary_op) { +void DerivationExpression::set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (unary_op) { @@ -4679,9 +4679,9 @@ void DerivationExpression::set_allocated_unary_op(::io::substrait::DerivationExp set_has_unary_op(); kind_.unary_op_ = unary_op; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.unary_op) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.unary_op) } -void DerivationExpression::set_allocated_binary_op(::io::substrait::DerivationExpression_BinaryOp* binary_op) { +void DerivationExpression::set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (binary_op) { @@ -4694,9 +4694,9 @@ void DerivationExpression::set_allocated_binary_op(::io::substrait::DerivationEx set_has_binary_op(); kind_.binary_op_ = binary_op; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.binary_op) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.binary_op) } -void DerivationExpression::set_allocated_if_else(::io::substrait::DerivationExpression_IfElse* if_else) { +void DerivationExpression::set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (if_else) { @@ -4709,9 +4709,9 @@ void DerivationExpression::set_allocated_if_else(::io::substrait::DerivationExpr set_has_if_else(); kind_.if_else_ = if_else; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.if_else) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.if_else) } -void DerivationExpression::set_allocated_return_program(::io::substrait::DerivationExpression_ReturnProgram* return_program) { +void DerivationExpression::set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); clear_kind(); if (return_program) { @@ -4724,13 +4724,13 @@ void DerivationExpression::set_allocated_return_program(::io::substrait::Derivat set_has_return_program(); kind_.return_program_ = return_program; } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.return_program) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.return_program) } DerivationExpression::DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) : ::PROTOBUF_NAMESPACE_ID::Message(arena) { SharedCtor(); RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.DerivationExpression) + // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression) } DerivationExpression::DerivationExpression(const DerivationExpression& from) : ::PROTOBUF_NAMESPACE_ID::Message() { @@ -4738,95 +4738,95 @@ DerivationExpression::DerivationExpression(const DerivationExpression& from) clear_has_kind(); switch (from.kind_case()) { case kBool: { - _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); break; } case kI8: { - _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); break; } case kI16: { - _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); break; } case kI32: { - _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); break; } case kI64: { - _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); break; } case kFp32: { - _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); break; } case kFp64: { - _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); break; } case kString: { - _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); break; } case kBinary: { - _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); break; } case kTimestamp: { - _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); break; } case kDate: { - _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); break; } case kTime: { - _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); break; } case kIntervalYear: { - _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); break; } case kIntervalDay: { - _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); break; } case kTimestampTz: { - _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); break; } case kUuid: { - _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); break; } case kFixedChar: { - _internal_mutable_fixed_char()->::io::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char()); + _internal_mutable_fixed_char()->::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char()); break; } case kVarchar: { - _internal_mutable_varchar()->::io::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar()); + _internal_mutable_varchar()->::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar()); break; } case kFixedBinary: { - _internal_mutable_fixed_binary()->::io::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary()); + _internal_mutable_fixed_binary()->::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary()); break; } case kDecimal: { - _internal_mutable_decimal()->::io::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal()); + _internal_mutable_decimal()->::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal()); break; } case kStruct: { - _internal_mutable_struct_()->::io::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); break; } case kList: { - _internal_mutable_list()->::io::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list()); + _internal_mutable_list()->::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list()); break; } case kMap: { - _internal_mutable_map()->::io::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map()); + _internal_mutable_map()->::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map()); break; } case kUserDefinedPointer: { @@ -4846,26 +4846,26 @@ DerivationExpression::DerivationExpression(const DerivationExpression& from) break; } case kUnaryOp: { - _internal_mutable_unary_op()->::io::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op()); + _internal_mutable_unary_op()->::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op()); break; } case kBinaryOp: { - _internal_mutable_binary_op()->::io::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op()); + _internal_mutable_binary_op()->::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op()); break; } case kIfElse: { - _internal_mutable_if_else()->::io::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else()); + _internal_mutable_if_else()->::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else()); break; } case kReturnProgram: { - _internal_mutable_return_program()->::io::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program()); + _internal_mutable_return_program()->::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program()); break; } case KIND_NOT_SET: { break; } } - // @@protoc_insertion_point(copy_constructor:io.substrait.DerivationExpression) + // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression) } void DerivationExpression::SharedCtor() { @@ -4873,7 +4873,7 @@ clear_has_kind(); } DerivationExpression::~DerivationExpression() { - // @@protoc_insertion_point(destructor:io.substrait.DerivationExpression) + // @@protoc_insertion_point(destructor:substrait.DerivationExpression) SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -4896,7 +4896,7 @@ void DerivationExpression::SetCachedSize(int size) const { } void DerivationExpression::clear_kind() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.DerivationExpression) +// @@protoc_insertion_point(one_of_clear_start:substrait.DerivationExpression) switch (kind_case()) { case kBool: { if (GetArena() == nullptr) { @@ -5085,7 +5085,7 @@ void DerivationExpression::clear_kind() { void DerivationExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.DerivationExpression) +// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5100,154 +5100,154 @@ const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAM ::PROTOBUF_NAMESPACE_ID::uint32 tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; case 1: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; case 2: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; case 3: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; case 5: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; case 7: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; case 10: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; case 11: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; case 12: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; case 13: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; case 14: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; case 16: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; case 17: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; case 19: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; case 20: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; + // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; case 21: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.ExpressionVarChar varchar = 22; + // .substrait.DerivationExpression.ExpressionVarChar varchar = 22; case 22: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; + // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; case 23: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.ExpressionDecimal decimal = 24; + // .substrait.DerivationExpression.ExpressionDecimal decimal = 24; case 24: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.ExpressionStruct struct = 25; + // .substrait.DerivationExpression.ExpressionStruct struct = 25; case 25: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.ExpressionList list = 27; + // .substrait.DerivationExpression.ExpressionList list = 27; case 27: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) { ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.ExpressionMap map = 28; + // .substrait.DerivationExpression.ExpressionMap map = 28; case 28: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; case 29: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); @@ -5261,7 +5261,7 @@ const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAM CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; case 32: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); @@ -5273,7 +5273,7 @@ const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAM if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { auto str = _internal_mutable_type_parameter_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.DerivationExpression.type_parameter_name")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.type_parameter_name")); CHK_(ptr); } else goto handle_unusual; continue; @@ -5282,7 +5282,7 @@ const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAM if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { auto str = _internal_mutable_integer_parameter_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.DerivationExpression.integer_parameter_name")); + CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.integer_parameter_name")); CHK_(ptr); } else goto handle_unusual; continue; @@ -5293,28 +5293,28 @@ const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAM CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.UnaryOp unary_op = 36; + // .substrait.DerivationExpression.UnaryOp unary_op = 36; case 36: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_unary_op(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.BinaryOp binary_op = 37; + // .substrait.DerivationExpression.BinaryOp binary_op = 37; case 37: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_binary_op(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.IfElse if_else = 38; + // .substrait.DerivationExpression.IfElse if_else = 38; case 38: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_if_else(), ptr); CHK_(ptr); } else goto handle_unusual; continue; - // .io.substrait.DerivationExpression.ReturnProgram return_program = 39; + // .substrait.DerivationExpression.ReturnProgram return_program = 39; case 39: if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_return_program(), ptr); @@ -5346,11 +5346,11 @@ const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAM ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.DerivationExpression) + // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression) ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; (void) cached_has_bits; - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; if (_internal_has_bool_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5358,7 +5358,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 1, _Internal::bool_(this), target, stream); } - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; if (_internal_has_i8()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5366,7 +5366,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 2, _Internal::i8(this), target, stream); } - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; if (_internal_has_i16()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5374,7 +5374,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 3, _Internal::i16(this), target, stream); } - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; if (_internal_has_i32()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5382,7 +5382,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 5, _Internal::i32(this), target, stream); } - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; if (_internal_has_i64()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5390,7 +5390,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 7, _Internal::i64(this), target, stream); } - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; if (_internal_has_fp32()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5398,7 +5398,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 10, _Internal::fp32(this), target, stream); } - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; if (_internal_has_fp64()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5406,7 +5406,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 11, _Internal::fp64(this), target, stream); } - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; if (_internal_has_string()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5414,7 +5414,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 12, _Internal::string(this), target, stream); } - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; if (_internal_has_binary()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5422,7 +5422,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 13, _Internal::binary(this), target, stream); } - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; if (_internal_has_timestamp()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5430,7 +5430,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 14, _Internal::timestamp(this), target, stream); } - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; if (_internal_has_date()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5438,7 +5438,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 16, _Internal::date(this), target, stream); } - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; if (_internal_has_time()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5446,7 +5446,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 17, _Internal::time(this), target, stream); } - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; if (_internal_has_interval_year()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5454,7 +5454,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 19, _Internal::interval_year(this), target, stream); } - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; if (_internal_has_interval_day()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5462,7 +5462,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 20, _Internal::interval_day(this), target, stream); } - // .io.substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; + // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; if (_internal_has_fixed_char()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5470,7 +5470,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 21, _Internal::fixed_char(this), target, stream); } - // .io.substrait.DerivationExpression.ExpressionVarChar varchar = 22; + // .substrait.DerivationExpression.ExpressionVarChar varchar = 22; if (_internal_has_varchar()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5478,7 +5478,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 22, _Internal::varchar(this), target, stream); } - // .io.substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; + // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; if (_internal_has_fixed_binary()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5486,7 +5486,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 23, _Internal::fixed_binary(this), target, stream); } - // .io.substrait.DerivationExpression.ExpressionDecimal decimal = 24; + // .substrait.DerivationExpression.ExpressionDecimal decimal = 24; if (_internal_has_decimal()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5494,7 +5494,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 24, _Internal::decimal(this), target, stream); } - // .io.substrait.DerivationExpression.ExpressionStruct struct = 25; + // .substrait.DerivationExpression.ExpressionStruct struct = 25; if (_internal_has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5502,7 +5502,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 25, _Internal::struct_(this), target, stream); } - // .io.substrait.DerivationExpression.ExpressionList list = 27; + // .substrait.DerivationExpression.ExpressionList list = 27; if (_internal_has_list()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5510,7 +5510,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 27, _Internal::list(this), target, stream); } - // .io.substrait.DerivationExpression.ExpressionMap map = 28; + // .substrait.DerivationExpression.ExpressionMap map = 28; if (_internal_has_map()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5518,7 +5518,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 28, _Internal::map(this), target, stream); } - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; if (_internal_has_timestamp_tz()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5532,7 +5532,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_pointer(), target); } - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; if (_internal_has_uuid()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5545,7 +5545,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_type_parameter_name().data(), static_cast(this->_internal_type_parameter_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.DerivationExpression.type_parameter_name"); + "substrait.DerivationExpression.type_parameter_name"); target = stream->WriteStringMaybeAliased( 33, this->_internal_type_parameter_name(), target); } @@ -5555,7 +5555,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_integer_parameter_name().data(), static_cast(this->_internal_integer_parameter_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.DerivationExpression.integer_parameter_name"); + "substrait.DerivationExpression.integer_parameter_name"); target = stream->WriteStringMaybeAliased( 34, this->_internal_integer_parameter_name(), target); } @@ -5566,7 +5566,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(35, this->_internal_integer_literal(), target); } - // .io.substrait.DerivationExpression.UnaryOp unary_op = 36; + // .substrait.DerivationExpression.UnaryOp unary_op = 36; if (_internal_has_unary_op()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5574,7 +5574,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 36, _Internal::unary_op(this), target, stream); } - // .io.substrait.DerivationExpression.BinaryOp binary_op = 37; + // .substrait.DerivationExpression.BinaryOp binary_op = 37; if (_internal_has_binary_op()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5582,7 +5582,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 37, _Internal::binary_op(this), target, stream); } - // .io.substrait.DerivationExpression.IfElse if_else = 38; + // .substrait.DerivationExpression.IfElse if_else = 38; if (_internal_has_if_else()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5590,7 +5590,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( 38, _Internal::if_else(this), target, stream); } - // .io.substrait.DerivationExpression.ReturnProgram return_program = 39; + // .substrait.DerivationExpression.ReturnProgram return_program = 39; if (_internal_has_return_program()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -5602,12 +5602,12 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.DerivationExpression) + // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression) return target; } size_t DerivationExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.DerivationExpression) +// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression) size_t total_size = 0; ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5615,161 +5615,161 @@ size_t DerivationExpression::ByteSizeLong() const { (void) cached_has_bits; switch (kind_case()) { - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; case kBool: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.bool__); break; } - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; case kI8: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i8_); break; } - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; case kI16: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i16_); break; } - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; case kI32: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i32_); break; } - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; case kI64: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.i64_); break; } - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; case kFp32: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fp32_); break; } - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; case kFp64: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fp64_); break; } - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; case kString: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.string_); break; } - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; case kBinary: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.binary_); break; } - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; case kTimestamp: { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.timestamp_); break; } - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; case kDate: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.date_); break; } - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; case kTime: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.time_); break; } - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; case kIntervalYear: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.interval_year_); break; } - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; case kIntervalDay: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.interval_day_); break; } - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; case kTimestampTz: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.timestamp_tz_); break; } - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; case kUuid: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.uuid_); break; } - // .io.substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; + // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; case kFixedChar: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fixed_char_); break; } - // .io.substrait.DerivationExpression.ExpressionVarChar varchar = 22; + // .substrait.DerivationExpression.ExpressionVarChar varchar = 22; case kVarchar: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.varchar_); break; } - // .io.substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; + // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; case kFixedBinary: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.fixed_binary_); break; } - // .io.substrait.DerivationExpression.ExpressionDecimal decimal = 24; + // .substrait.DerivationExpression.ExpressionDecimal decimal = 24; case kDecimal: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.decimal_); break; } - // .io.substrait.DerivationExpression.ExpressionStruct struct = 25; + // .substrait.DerivationExpression.ExpressionStruct struct = 25; case kStruct: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.struct__); break; } - // .io.substrait.DerivationExpression.ExpressionList list = 27; + // .substrait.DerivationExpression.ExpressionList list = 27; case kList: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.list_); break; } - // .io.substrait.DerivationExpression.ExpressionMap map = 28; + // .substrait.DerivationExpression.ExpressionMap map = 28; case kMap: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -5804,28 +5804,28 @@ size_t DerivationExpression::ByteSizeLong() const { this->_internal_integer_literal()); break; } - // .io.substrait.DerivationExpression.UnaryOp unary_op = 36; + // .substrait.DerivationExpression.UnaryOp unary_op = 36; case kUnaryOp: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.unary_op_); break; } - // .io.substrait.DerivationExpression.BinaryOp binary_op = 37; + // .substrait.DerivationExpression.BinaryOp binary_op = 37; case kBinaryOp: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.binary_op_); break; } - // .io.substrait.DerivationExpression.IfElse if_else = 38; + // .substrait.DerivationExpression.IfElse if_else = 38; case kIfElse: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *kind_.if_else_); break; } - // .io.substrait.DerivationExpression.ReturnProgram return_program = 39; + // .substrait.DerivationExpression.ReturnProgram return_program = 39; case kReturnProgram: { total_size += 2 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( @@ -5846,22 +5846,22 @@ size_t DerivationExpression::ByteSizeLong() const { } void DerivationExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.DerivationExpression) +// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression) GOOGLE_DCHECK_NE(&from, this); const DerivationExpression* source = ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( &from); if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.DerivationExpression) + // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression) ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.DerivationExpression) + // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression) MergeFrom(*source); } } void DerivationExpression::MergeFrom(const DerivationExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.DerivationExpression) +// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression) GOOGLE_DCHECK_NE(&from, this); _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; @@ -5869,95 +5869,95 @@ void DerivationExpression::MergeFrom(const DerivationExpression& from) { switch (from.kind_case()) { case kBool: { - _internal_mutable_bool_()->::io::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); + _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); break; } case kI8: { - _internal_mutable_i8()->::io::substrait::Type_I8::MergeFrom(from._internal_i8()); + _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); break; } case kI16: { - _internal_mutable_i16()->::io::substrait::Type_I16::MergeFrom(from._internal_i16()); + _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); break; } case kI32: { - _internal_mutable_i32()->::io::substrait::Type_I32::MergeFrom(from._internal_i32()); + _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); break; } case kI64: { - _internal_mutable_i64()->::io::substrait::Type_I64::MergeFrom(from._internal_i64()); + _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); break; } case kFp32: { - _internal_mutable_fp32()->::io::substrait::Type_FP32::MergeFrom(from._internal_fp32()); + _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); break; } case kFp64: { - _internal_mutable_fp64()->::io::substrait::Type_FP64::MergeFrom(from._internal_fp64()); + _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); break; } case kString: { - _internal_mutable_string()->::io::substrait::Type_String::MergeFrom(from._internal_string()); + _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); break; } case kBinary: { - _internal_mutable_binary()->::io::substrait::Type_Binary::MergeFrom(from._internal_binary()); + _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); break; } case kTimestamp: { - _internal_mutable_timestamp()->::io::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); + _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); break; } case kDate: { - _internal_mutable_date()->::io::substrait::Type_Date::MergeFrom(from._internal_date()); + _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); break; } case kTime: { - _internal_mutable_time()->::io::substrait::Type_Time::MergeFrom(from._internal_time()); + _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); break; } case kIntervalYear: { - _internal_mutable_interval_year()->::io::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); + _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); break; } case kIntervalDay: { - _internal_mutable_interval_day()->::io::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); + _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); break; } case kTimestampTz: { - _internal_mutable_timestamp_tz()->::io::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); + _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); break; } case kUuid: { - _internal_mutable_uuid()->::io::substrait::Type_UUID::MergeFrom(from._internal_uuid()); + _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); break; } case kFixedChar: { - _internal_mutable_fixed_char()->::io::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char()); + _internal_mutable_fixed_char()->::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char()); break; } case kVarchar: { - _internal_mutable_varchar()->::io::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar()); + _internal_mutable_varchar()->::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar()); break; } case kFixedBinary: { - _internal_mutable_fixed_binary()->::io::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary()); + _internal_mutable_fixed_binary()->::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary()); break; } case kDecimal: { - _internal_mutable_decimal()->::io::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal()); + _internal_mutable_decimal()->::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal()); break; } case kStruct: { - _internal_mutable_struct_()->::io::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); + _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); break; } case kList: { - _internal_mutable_list()->::io::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list()); + _internal_mutable_list()->::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list()); break; } case kMap: { - _internal_mutable_map()->::io::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map()); + _internal_mutable_map()->::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map()); break; } case kUserDefinedPointer: { @@ -5977,19 +5977,19 @@ void DerivationExpression::MergeFrom(const DerivationExpression& from) { break; } case kUnaryOp: { - _internal_mutable_unary_op()->::io::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op()); + _internal_mutable_unary_op()->::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op()); break; } case kBinaryOp: { - _internal_mutable_binary_op()->::io::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op()); + _internal_mutable_binary_op()->::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op()); break; } case kIfElse: { - _internal_mutable_if_else()->::io::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else()); + _internal_mutable_if_else()->::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else()); break; } case kReturnProgram: { - _internal_mutable_return_program()->::io::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program()); + _internal_mutable_return_program()->::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program()); break; } case KIND_NOT_SET: { @@ -5999,14 +5999,14 @@ void DerivationExpression::MergeFrom(const DerivationExpression& from) { } void DerivationExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.DerivationExpression) +// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression) if (&from == this) return; Clear(); MergeFrom(from); } void DerivationExpression::CopyFrom(const DerivationExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.DerivationExpression) +// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression) if (&from == this) return; Clear(); MergeFrom(from); @@ -6025,55 +6025,54 @@ void DerivationExpression::InternalSwap(DerivationExpression* other) { ::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_type_5fexpressions_2eproto_getter, &descriptor_table_type_5fexpressions_2eproto_once, - file_level_metadata_type_5fexpressions_2eproto[13]); + &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, + file_level_metadata_substrait_2ftype_5fexpressions_2eproto[13]); } // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionFixedChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionFixedChar >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionFixedChar >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionVarChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionVarChar >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionVarChar >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionVarChar >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionFixedBinary >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionFixedBinary >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedBinary >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionFixedBinary >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionDecimal >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionDecimal >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionDecimal >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionDecimal >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionStruct >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionStruct >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionNamedStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionNamedStruct >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionNamedStruct >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionNamedStruct >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionList >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionList >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionList >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionList >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionMap >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ExpressionMap >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionMap >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionMap >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_IfElse >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_IfElse >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_IfElse >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_IfElse >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_UnaryOp >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_UnaryOp >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_UnaryOp >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_UnaryOp >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_BinaryOp >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_BinaryOp >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_BinaryOp >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_BinaryOp >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram_Assignment >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ReturnProgram_Assignment >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression_ReturnProgram >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression_ReturnProgram >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ReturnProgram >(arena); } -template<> PROTOBUF_NOINLINE ::io::substrait::DerivationExpression* Arena::CreateMaybeMessage< ::io::substrait::DerivationExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::DerivationExpression >(arena); +template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression* Arena::CreateMaybeMessage< ::substrait::DerivationExpression >(Arena* arena) { + return Arena::CreateMessageInternal< ::substrait::DerivationExpression >(arena); } PROTOBUF_NAMESPACE_CLOSE diff --git a/cpp/src/generated/substrait/type_expressions.pb.h b/cpp/src/generated/substrait/type_expressions.pb.h index 2b940b3af60..4046899622b 100644 --- a/cpp/src/generated/substrait/type_expressions.pb.h +++ b/cpp/src/generated/substrait/type_expressions.pb.h @@ -1,8 +1,8 @@ // Generated by the protocol buffer compiler. DO NOT EDIT! -// source: type_expressions.proto +// source: substrait/type_expressions.proto -#ifndef GOOGLE_PROTOBUF_INCLUDED_type_5fexpressions_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_type_5fexpressions_2eproto +#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto +#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto #include #include @@ -32,10 +32,10 @@ #include // IWYU pragma: export #include #include -#include "type.pb.h" +#include "substrait/type.pb.h" // @@protoc_insertion_point(includes) #include -#define PROTOBUF_INTERNAL_EXPORT_type_5fexpressions_2eproto +#define PROTOBUF_INTERNAL_EXPORT_substrait_2ftype_5fexpressions_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; @@ -43,7 +43,7 @@ class AnyMetadata; PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. -struct TableStruct_type_5fexpressions_2eproto { +struct TableStruct_substrait_2ftype_5fexpressions_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] @@ -54,8 +54,7 @@ struct TableStruct_type_5fexpressions_2eproto { static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; }; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_type_5fexpressions_2eproto; -namespace io { +extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_5fexpressions_2eproto; namespace substrait { class DerivationExpression; struct DerivationExpressionDefaultTypeInternal; @@ -100,91 +99,89 @@ class DerivationExpression_UnaryOp; struct DerivationExpression_UnaryOpDefaultTypeInternal; extern DerivationExpression_UnaryOpDefaultTypeInternal _DerivationExpression_UnaryOp_default_instance_; } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::DerivationExpression* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression>(Arena*); -template<> ::io::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_BinaryOp>(Arena*); -template<> ::io::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionDecimal>(Arena*); -template<> ::io::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionFixedBinary>(Arena*); -template<> ::io::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionFixedChar>(Arena*); -template<> ::io::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionList>(Arena*); -template<> ::io::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionMap>(Arena*); -template<> ::io::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionNamedStruct>(Arena*); -template<> ::io::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionStruct>(Arena*); -template<> ::io::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionVarChar>(Arena*); -template<> ::io::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_IfElse>(Arena*); -template<> ::io::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ReturnProgram>(Arena*); -template<> ::io::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_ReturnProgram_Assignment>(Arena*); -template<> ::io::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage<::io::substrait::DerivationExpression_UnaryOp>(Arena*); +template<> ::substrait::DerivationExpression* Arena::CreateMaybeMessage<::substrait::DerivationExpression>(Arena*); +template<> ::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage<::substrait::DerivationExpression_BinaryOp>(Arena*); +template<> ::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionDecimal>(Arena*); +template<> ::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionFixedBinary>(Arena*); +template<> ::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionFixedChar>(Arena*); +template<> ::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionList>(Arena*); +template<> ::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionMap>(Arena*); +template<> ::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionNamedStruct>(Arena*); +template<> ::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionStruct>(Arena*); +template<> ::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionVarChar>(Arena*); +template<> ::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage<::substrait::DerivationExpression_IfElse>(Arena*); +template<> ::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ReturnProgram>(Arena*); +template<> ::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ReturnProgram_Assignment>(Arena*); +template<> ::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage<::substrait::DerivationExpression_UnaryOp>(Arena*); PROTOBUF_NAMESPACE_CLOSE -namespace io { namespace substrait { -enum DerivationExpression_UnaryOp_OpType : int { - DerivationExpression_UnaryOp_OpType_UNKNOWN = 0, - DerivationExpression_UnaryOp_OpType_BOOLEAN_NOT = 1, - DerivationExpression_UnaryOp_OpType_DerivationExpression_UnaryOp_OpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - DerivationExpression_UnaryOp_OpType_DerivationExpression_UnaryOp_OpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() +enum DerivationExpression_UnaryOp_UnaryOpType : int { + DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED = 0, + DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT = 1, + DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; -bool DerivationExpression_UnaryOp_OpType_IsValid(int value); -constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp_OpType_OpType_MIN = DerivationExpression_UnaryOp_OpType_UNKNOWN; -constexpr DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp_OpType_OpType_MAX = DerivationExpression_UnaryOp_OpType_BOOLEAN_NOT; -constexpr int DerivationExpression_UnaryOp_OpType_OpType_ARRAYSIZE = DerivationExpression_UnaryOp_OpType_OpType_MAX + 1; +bool DerivationExpression_UnaryOp_UnaryOpType_IsValid(int value); +constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MIN = DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED; +constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX = DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT; +constexpr int DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_ARRAYSIZE = DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX + 1; -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_OpType_descriptor(); +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_UnaryOpType_descriptor(); template -inline const std::string& DerivationExpression_UnaryOp_OpType_Name(T enum_t_value) { - static_assert(::std::is_same::value || +inline const std::string& DerivationExpression_UnaryOp_UnaryOpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || ::std::is_integral::value, - "Incorrect type passed to function DerivationExpression_UnaryOp_OpType_Name."); + "Incorrect type passed to function DerivationExpression_UnaryOp_UnaryOpType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - DerivationExpression_UnaryOp_OpType_descriptor(), enum_t_value); -} -inline bool DerivationExpression_UnaryOp_OpType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_UnaryOp_OpType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - DerivationExpression_UnaryOp_OpType_descriptor(), name, value); -} -enum DerivationExpression_BinaryOp_OpType : int { - DerivationExpression_BinaryOp_OpType_UNKNOWN = 0, - DerivationExpression_BinaryOp_OpType_PLUS = 1, - DerivationExpression_BinaryOp_OpType_MINUS = 2, - DerivationExpression_BinaryOp_OpType_MULTIPLY = 3, - DerivationExpression_BinaryOp_OpType_DIVIDE = 4, - DerivationExpression_BinaryOp_OpType_MIN = 5, - DerivationExpression_BinaryOp_OpType_MAX = 6, - DerivationExpression_BinaryOp_OpType_GREATER_THAN = 7, - DerivationExpression_BinaryOp_OpType_LESS_THAN = 8, - DerivationExpression_BinaryOp_OpType_AND = 9, - DerivationExpression_BinaryOp_OpType_OR = 10, - DerivationExpression_BinaryOp_OpType_EQUALS = 11, - DerivationExpression_BinaryOp_OpType_COVERS = 12, - DerivationExpression_BinaryOp_OpType_DerivationExpression_BinaryOp_OpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - DerivationExpression_BinaryOp_OpType_DerivationExpression_BinaryOp_OpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + DerivationExpression_UnaryOp_UnaryOpType_descriptor(), enum_t_value); +} +inline bool DerivationExpression_UnaryOp_UnaryOpType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_UnaryOp_UnaryOpType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DerivationExpression_UnaryOp_UnaryOpType_descriptor(), name, value); +} +enum DerivationExpression_BinaryOp_BinaryOpType : int { + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED = 0, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_PLUS = 1, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MINUS = 2, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MULTIPLY = 3, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_DIVIDE = 4, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MIN = 5, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MAX = 6, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_GREATER_THAN = 7, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_LESS_THAN = 8, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_AND = 9, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_OR = 10, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_EQUALS = 11, + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS = 12, + DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), + DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() }; -bool DerivationExpression_BinaryOp_OpType_IsValid(int value); -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp_OpType_OpType_MIN = DerivationExpression_BinaryOp_OpType_UNKNOWN; -constexpr DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp_OpType_OpType_MAX = DerivationExpression_BinaryOp_OpType_COVERS; -constexpr int DerivationExpression_BinaryOp_OpType_OpType_ARRAYSIZE = DerivationExpression_BinaryOp_OpType_OpType_MAX + 1; +bool DerivationExpression_BinaryOp_BinaryOpType_IsValid(int value); +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MIN = DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED; +constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX = DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS; +constexpr int DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_ARRAYSIZE = DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX + 1; -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_OpType_descriptor(); +const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_BinaryOpType_descriptor(); template -inline const std::string& DerivationExpression_BinaryOp_OpType_Name(T enum_t_value) { - static_assert(::std::is_same::value || +inline const std::string& DerivationExpression_BinaryOp_BinaryOpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || ::std::is_integral::value, - "Incorrect type passed to function DerivationExpression_BinaryOp_OpType_Name."); + "Incorrect type passed to function DerivationExpression_BinaryOp_BinaryOpType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - DerivationExpression_BinaryOp_OpType_descriptor(), enum_t_value); + DerivationExpression_BinaryOp_BinaryOpType_descriptor(), enum_t_value); } -inline bool DerivationExpression_BinaryOp_OpType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_BinaryOp_OpType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - DerivationExpression_BinaryOp_OpType_descriptor(), name, value); +inline bool DerivationExpression_BinaryOp_BinaryOpType_Parse( + ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_BinaryOp_BinaryOpType* value) { + return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( + DerivationExpression_BinaryOp_BinaryOpType_descriptor(), name, value); } // =================================================================== class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionFixedChar) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionFixedChar) */ { public: inline DerivationExpression_ExpressionFixedChar() : DerivationExpression_ExpressionFixedChar(nullptr) {} ~DerivationExpression_ExpressionFixedChar() override; @@ -274,7 +271,7 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : void InternalSwap(DerivationExpression_ExpressionFixedChar* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.ExpressionFixedChar"; + return "substrait.DerivationExpression.ExpressionFixedChar"; } protected: explicit DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -294,23 +291,23 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; bool has_length() const; private: bool _internal_has_length() const; public: void clear_length(); - const ::io::substrait::DerivationExpression& length() const; - ::io::substrait::DerivationExpression* release_length(); - ::io::substrait::DerivationExpression* mutable_length(); - void set_allocated_length(::io::substrait::DerivationExpression* length); + const ::substrait::DerivationExpression& length() const; + ::substrait::DerivationExpression* release_length(); + ::substrait::DerivationExpression* mutable_length(); + void set_allocated_length(::substrait::DerivationExpression* length); private: - const ::io::substrait::DerivationExpression& _internal_length() const; - ::io::substrait::DerivationExpression* _internal_mutable_length(); + const ::substrait::DerivationExpression& _internal_length() const; + ::substrait::DerivationExpression* _internal_mutable_length(); public: void unsafe_arena_set_allocated_length( - ::io::substrait::DerivationExpression* length); - ::io::substrait::DerivationExpression* unsafe_arena_release_length(); + ::substrait::DerivationExpression* length); + ::substrait::DerivationExpression* unsafe_arena_release_length(); // uint32 variation_pointer = 2; void clear_variation_pointer(); @@ -321,32 +318,32 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionFixedChar) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionFixedChar) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::DerivationExpression* length_; + ::substrait::DerivationExpression* length_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionVarChar) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionVarChar) */ { public: inline DerivationExpression_ExpressionVarChar() : DerivationExpression_ExpressionVarChar(nullptr) {} ~DerivationExpression_ExpressionVarChar() override; @@ -436,7 +433,7 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : void InternalSwap(DerivationExpression_ExpressionVarChar* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.ExpressionVarChar"; + return "substrait.DerivationExpression.ExpressionVarChar"; } protected: explicit DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -456,23 +453,23 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; bool has_length() const; private: bool _internal_has_length() const; public: void clear_length(); - const ::io::substrait::DerivationExpression& length() const; - ::io::substrait::DerivationExpression* release_length(); - ::io::substrait::DerivationExpression* mutable_length(); - void set_allocated_length(::io::substrait::DerivationExpression* length); + const ::substrait::DerivationExpression& length() const; + ::substrait::DerivationExpression* release_length(); + ::substrait::DerivationExpression* mutable_length(); + void set_allocated_length(::substrait::DerivationExpression* length); private: - const ::io::substrait::DerivationExpression& _internal_length() const; - ::io::substrait::DerivationExpression* _internal_mutable_length(); + const ::substrait::DerivationExpression& _internal_length() const; + ::substrait::DerivationExpression* _internal_mutable_length(); public: void unsafe_arena_set_allocated_length( - ::io::substrait::DerivationExpression* length); - ::io::substrait::DerivationExpression* unsafe_arena_release_length(); + ::substrait::DerivationExpression* length); + ::substrait::DerivationExpression* unsafe_arena_release_length(); // uint32 variation_pointer = 2; void clear_variation_pointer(); @@ -483,32 +480,32 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionVarChar) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionVarChar) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::DerivationExpression* length_; + ::substrait::DerivationExpression* length_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionFixedBinary) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionFixedBinary) */ { public: inline DerivationExpression_ExpressionFixedBinary() : DerivationExpression_ExpressionFixedBinary(nullptr) {} ~DerivationExpression_ExpressionFixedBinary() override; @@ -598,7 +595,7 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : void InternalSwap(DerivationExpression_ExpressionFixedBinary* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.ExpressionFixedBinary"; + return "substrait.DerivationExpression.ExpressionFixedBinary"; } protected: explicit DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -618,23 +615,23 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.DerivationExpression length = 1; + // .substrait.DerivationExpression length = 1; bool has_length() const; private: bool _internal_has_length() const; public: void clear_length(); - const ::io::substrait::DerivationExpression& length() const; - ::io::substrait::DerivationExpression* release_length(); - ::io::substrait::DerivationExpression* mutable_length(); - void set_allocated_length(::io::substrait::DerivationExpression* length); + const ::substrait::DerivationExpression& length() const; + ::substrait::DerivationExpression* release_length(); + ::substrait::DerivationExpression* mutable_length(); + void set_allocated_length(::substrait::DerivationExpression* length); private: - const ::io::substrait::DerivationExpression& _internal_length() const; - ::io::substrait::DerivationExpression* _internal_mutable_length(); + const ::substrait::DerivationExpression& _internal_length() const; + ::substrait::DerivationExpression* _internal_mutable_length(); public: void unsafe_arena_set_allocated_length( - ::io::substrait::DerivationExpression* length); - ::io::substrait::DerivationExpression* unsafe_arena_release_length(); + ::substrait::DerivationExpression* length); + ::substrait::DerivationExpression* unsafe_arena_release_length(); // uint32 variation_pointer = 2; void clear_variation_pointer(); @@ -645,32 +642,32 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionFixedBinary) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionFixedBinary) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::DerivationExpression* length_; + ::substrait::DerivationExpression* length_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionDecimal) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionDecimal) */ { public: inline DerivationExpression_ExpressionDecimal() : DerivationExpression_ExpressionDecimal(nullptr) {} ~DerivationExpression_ExpressionDecimal() override; @@ -760,7 +757,7 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : void InternalSwap(DerivationExpression_ExpressionDecimal* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.ExpressionDecimal"; + return "substrait.DerivationExpression.ExpressionDecimal"; } protected: explicit DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -781,41 +778,41 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : kVariationPointerFieldNumber = 3, kNullabilityFieldNumber = 4, }; - // .io.substrait.DerivationExpression scale = 1; + // .substrait.DerivationExpression scale = 1; bool has_scale() const; private: bool _internal_has_scale() const; public: void clear_scale(); - const ::io::substrait::DerivationExpression& scale() const; - ::io::substrait::DerivationExpression* release_scale(); - ::io::substrait::DerivationExpression* mutable_scale(); - void set_allocated_scale(::io::substrait::DerivationExpression* scale); + const ::substrait::DerivationExpression& scale() const; + ::substrait::DerivationExpression* release_scale(); + ::substrait::DerivationExpression* mutable_scale(); + void set_allocated_scale(::substrait::DerivationExpression* scale); private: - const ::io::substrait::DerivationExpression& _internal_scale() const; - ::io::substrait::DerivationExpression* _internal_mutable_scale(); + const ::substrait::DerivationExpression& _internal_scale() const; + ::substrait::DerivationExpression* _internal_mutable_scale(); public: void unsafe_arena_set_allocated_scale( - ::io::substrait::DerivationExpression* scale); - ::io::substrait::DerivationExpression* unsafe_arena_release_scale(); + ::substrait::DerivationExpression* scale); + ::substrait::DerivationExpression* unsafe_arena_release_scale(); - // .io.substrait.DerivationExpression precision = 2; + // .substrait.DerivationExpression precision = 2; bool has_precision() const; private: bool _internal_has_precision() const; public: void clear_precision(); - const ::io::substrait::DerivationExpression& precision() const; - ::io::substrait::DerivationExpression* release_precision(); - ::io::substrait::DerivationExpression* mutable_precision(); - void set_allocated_precision(::io::substrait::DerivationExpression* precision); + const ::substrait::DerivationExpression& precision() const; + ::substrait::DerivationExpression* release_precision(); + ::substrait::DerivationExpression* mutable_precision(); + void set_allocated_precision(::substrait::DerivationExpression* precision); private: - const ::io::substrait::DerivationExpression& _internal_precision() const; - ::io::substrait::DerivationExpression* _internal_mutable_precision(); + const ::substrait::DerivationExpression& _internal_precision() const; + ::substrait::DerivationExpression* _internal_mutable_precision(); public: void unsafe_arena_set_allocated_precision( - ::io::substrait::DerivationExpression* precision); - ::io::substrait::DerivationExpression* unsafe_arena_release_precision(); + ::substrait::DerivationExpression* precision); + ::substrait::DerivationExpression* unsafe_arena_release_precision(); // uint32 variation_pointer = 3; void clear_variation_pointer(); @@ -826,33 +823,33 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionDecimal) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionDecimal) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::DerivationExpression* scale_; - ::io::substrait::DerivationExpression* precision_; + ::substrait::DerivationExpression* scale_; + ::substrait::DerivationExpression* precision_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionStruct) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionStruct) */ { public: inline DerivationExpression_ExpressionStruct() : DerivationExpression_ExpressionStruct(nullptr) {} ~DerivationExpression_ExpressionStruct() override; @@ -942,7 +939,7 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : void InternalSwap(DerivationExpression_ExpressionStruct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.ExpressionStruct"; + return "substrait.DerivationExpression.ExpressionStruct"; } protected: explicit DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -962,22 +959,22 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // repeated .io.substrait.DerivationExpression types = 1; + // repeated .substrait.DerivationExpression types = 1; int types_size() const; private: int _internal_types_size() const; public: void clear_types(); - ::io::substrait::DerivationExpression* mutable_types(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression >* + ::substrait::DerivationExpression* mutable_types(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >* mutable_types(); private: - const ::io::substrait::DerivationExpression& _internal_types(int index) const; - ::io::substrait::DerivationExpression* _internal_add_types(); + const ::substrait::DerivationExpression& _internal_types(int index) const; + ::substrait::DerivationExpression* _internal_add_types(); public: - const ::io::substrait::DerivationExpression& types(int index) const; - ::io::substrait::DerivationExpression* add_types(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression >& + const ::substrait::DerivationExpression& types(int index) const; + ::substrait::DerivationExpression* add_types(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >& types() const; // uint32 variation_pointer = 2; @@ -989,32 +986,32 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionStruct) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionStruct) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression > types_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression > types_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionNamedStruct) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionNamedStruct) */ { public: inline DerivationExpression_ExpressionNamedStruct() : DerivationExpression_ExpressionNamedStruct(nullptr) {} ~DerivationExpression_ExpressionNamedStruct() override; @@ -1104,7 +1101,7 @@ class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : void InternalSwap(DerivationExpression_ExpressionNamedStruct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.ExpressionNamedStruct"; + return "substrait.DerivationExpression.ExpressionNamedStruct"; } protected: explicit DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1147,25 +1144,25 @@ class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : std::string* _internal_add_names(); public: - // .io.substrait.DerivationExpression.ExpressionStruct struct = 2; + // .substrait.DerivationExpression.ExpressionStruct struct = 2; bool has_struct_() const; private: bool _internal_has_struct_() const; public: void clear_struct_(); - const ::io::substrait::DerivationExpression_ExpressionStruct& struct_() const; - ::io::substrait::DerivationExpression_ExpressionStruct* release_struct_(); - ::io::substrait::DerivationExpression_ExpressionStruct* mutable_struct_(); - void set_allocated_struct_(::io::substrait::DerivationExpression_ExpressionStruct* struct_); + const ::substrait::DerivationExpression_ExpressionStruct& struct_() const; + ::substrait::DerivationExpression_ExpressionStruct* release_struct_(); + ::substrait::DerivationExpression_ExpressionStruct* mutable_struct_(); + void set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_); private: - const ::io::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const; - ::io::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_(); + const ::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const; + ::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_(); public: void unsafe_arena_set_allocated_struct_( - ::io::substrait::DerivationExpression_ExpressionStruct* struct_); - ::io::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_(); + ::substrait::DerivationExpression_ExpressionStruct* struct_); + ::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_(); - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionNamedStruct) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionNamedStruct) private: class _Internal; @@ -1173,14 +1170,14 @@ class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::io::substrait::DerivationExpression_ExpressionStruct* struct__; + ::substrait::DerivationExpression_ExpressionStruct* struct__; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_ExpressionList PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionList) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionList) */ { public: inline DerivationExpression_ExpressionList() : DerivationExpression_ExpressionList(nullptr) {} ~DerivationExpression_ExpressionList() override; @@ -1270,7 +1267,7 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : void InternalSwap(DerivationExpression_ExpressionList* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.ExpressionList"; + return "substrait.DerivationExpression.ExpressionList"; } protected: explicit DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1290,23 +1287,23 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : kVariationPointerFieldNumber = 2, kNullabilityFieldNumber = 3, }; - // .io.substrait.DerivationExpression type = 1; + // .substrait.DerivationExpression type = 1; bool has_type() const; private: bool _internal_has_type() const; public: void clear_type(); - const ::io::substrait::DerivationExpression& type() const; - ::io::substrait::DerivationExpression* release_type(); - ::io::substrait::DerivationExpression* mutable_type(); - void set_allocated_type(::io::substrait::DerivationExpression* type); + const ::substrait::DerivationExpression& type() const; + ::substrait::DerivationExpression* release_type(); + ::substrait::DerivationExpression* mutable_type(); + void set_allocated_type(::substrait::DerivationExpression* type); private: - const ::io::substrait::DerivationExpression& _internal_type() const; - ::io::substrait::DerivationExpression* _internal_mutable_type(); + const ::substrait::DerivationExpression& _internal_type() const; + ::substrait::DerivationExpression* _internal_mutable_type(); public: void unsafe_arena_set_allocated_type( - ::io::substrait::DerivationExpression* type); - ::io::substrait::DerivationExpression* unsafe_arena_release_type(); + ::substrait::DerivationExpression* type); + ::substrait::DerivationExpression* unsafe_arena_release_type(); // uint32 variation_pointer = 2; void clear_variation_pointer(); @@ -1317,32 +1314,32 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 3; + // .substrait.Type.Nullability nullability = 3; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionList) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionList) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::DerivationExpression* type_; + ::substrait::DerivationExpression* type_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_ExpressionMap PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ExpressionMap) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionMap) */ { public: inline DerivationExpression_ExpressionMap() : DerivationExpression_ExpressionMap(nullptr) {} ~DerivationExpression_ExpressionMap() override; @@ -1432,7 +1429,7 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : void InternalSwap(DerivationExpression_ExpressionMap* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.ExpressionMap"; + return "substrait.DerivationExpression.ExpressionMap"; } protected: explicit DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1453,41 +1450,41 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : kVariationPointerFieldNumber = 3, kNullabilityFieldNumber = 4, }; - // .io.substrait.DerivationExpression key = 1; + // .substrait.DerivationExpression key = 1; bool has_key() const; private: bool _internal_has_key() const; public: void clear_key(); - const ::io::substrait::DerivationExpression& key() const; - ::io::substrait::DerivationExpression* release_key(); - ::io::substrait::DerivationExpression* mutable_key(); - void set_allocated_key(::io::substrait::DerivationExpression* key); + const ::substrait::DerivationExpression& key() const; + ::substrait::DerivationExpression* release_key(); + ::substrait::DerivationExpression* mutable_key(); + void set_allocated_key(::substrait::DerivationExpression* key); private: - const ::io::substrait::DerivationExpression& _internal_key() const; - ::io::substrait::DerivationExpression* _internal_mutable_key(); + const ::substrait::DerivationExpression& _internal_key() const; + ::substrait::DerivationExpression* _internal_mutable_key(); public: void unsafe_arena_set_allocated_key( - ::io::substrait::DerivationExpression* key); - ::io::substrait::DerivationExpression* unsafe_arena_release_key(); + ::substrait::DerivationExpression* key); + ::substrait::DerivationExpression* unsafe_arena_release_key(); - // .io.substrait.DerivationExpression value = 2; + // .substrait.DerivationExpression value = 2; bool has_value() const; private: bool _internal_has_value() const; public: void clear_value(); - const ::io::substrait::DerivationExpression& value() const; - ::io::substrait::DerivationExpression* release_value(); - ::io::substrait::DerivationExpression* mutable_value(); - void set_allocated_value(::io::substrait::DerivationExpression* value); + const ::substrait::DerivationExpression& value() const; + ::substrait::DerivationExpression* release_value(); + ::substrait::DerivationExpression* mutable_value(); + void set_allocated_value(::substrait::DerivationExpression* value); private: - const ::io::substrait::DerivationExpression& _internal_value() const; - ::io::substrait::DerivationExpression* _internal_mutable_value(); + const ::substrait::DerivationExpression& _internal_value() const; + ::substrait::DerivationExpression* _internal_mutable_value(); public: void unsafe_arena_set_allocated_value( - ::io::substrait::DerivationExpression* value); - ::io::substrait::DerivationExpression* unsafe_arena_release_value(); + ::substrait::DerivationExpression* value); + ::substrait::DerivationExpression* unsafe_arena_release_value(); // uint32 variation_pointer = 3; void clear_variation_pointer(); @@ -1498,33 +1495,33 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); public: - // .io.substrait.Type.Nullability nullability = 4; + // .substrait.Type.Nullability nullability = 4; void clear_nullability(); - ::io::substrait::Type_Nullability nullability() const; - void set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability nullability() const; + void set_nullability(::substrait::Type_Nullability value); private: - ::io::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::io::substrait::Type_Nullability value); + ::substrait::Type_Nullability _internal_nullability() const; + void _internal_set_nullability(::substrait::Type_Nullability value); public: - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ExpressionMap) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionMap) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::DerivationExpression* key_; - ::io::substrait::DerivationExpression* value_; + ::substrait::DerivationExpression* key_; + ::substrait::DerivationExpression* value_; ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_IfElse PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.IfElse) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.IfElse) */ { public: inline DerivationExpression_IfElse() : DerivationExpression_IfElse(nullptr) {} ~DerivationExpression_IfElse() override; @@ -1614,7 +1611,7 @@ class DerivationExpression_IfElse PROTOBUF_FINAL : void InternalSwap(DerivationExpression_IfElse* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.IfElse"; + return "substrait.DerivationExpression.IfElse"; } protected: explicit DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1634,77 +1631,77 @@ class DerivationExpression_IfElse PROTOBUF_FINAL : kIfReturnFieldNumber = 2, kElseReturnFieldNumber = 3, }; - // .io.substrait.DerivationExpression if_condition = 1; + // .substrait.DerivationExpression if_condition = 1; bool has_if_condition() const; private: bool _internal_has_if_condition() const; public: void clear_if_condition(); - const ::io::substrait::DerivationExpression& if_condition() const; - ::io::substrait::DerivationExpression* release_if_condition(); - ::io::substrait::DerivationExpression* mutable_if_condition(); - void set_allocated_if_condition(::io::substrait::DerivationExpression* if_condition); + const ::substrait::DerivationExpression& if_condition() const; + ::substrait::DerivationExpression* release_if_condition(); + ::substrait::DerivationExpression* mutable_if_condition(); + void set_allocated_if_condition(::substrait::DerivationExpression* if_condition); private: - const ::io::substrait::DerivationExpression& _internal_if_condition() const; - ::io::substrait::DerivationExpression* _internal_mutable_if_condition(); + const ::substrait::DerivationExpression& _internal_if_condition() const; + ::substrait::DerivationExpression* _internal_mutable_if_condition(); public: void unsafe_arena_set_allocated_if_condition( - ::io::substrait::DerivationExpression* if_condition); - ::io::substrait::DerivationExpression* unsafe_arena_release_if_condition(); + ::substrait::DerivationExpression* if_condition); + ::substrait::DerivationExpression* unsafe_arena_release_if_condition(); - // .io.substrait.DerivationExpression if_return = 2; + // .substrait.DerivationExpression if_return = 2; bool has_if_return() const; private: bool _internal_has_if_return() const; public: void clear_if_return(); - const ::io::substrait::DerivationExpression& if_return() const; - ::io::substrait::DerivationExpression* release_if_return(); - ::io::substrait::DerivationExpression* mutable_if_return(); - void set_allocated_if_return(::io::substrait::DerivationExpression* if_return); + const ::substrait::DerivationExpression& if_return() const; + ::substrait::DerivationExpression* release_if_return(); + ::substrait::DerivationExpression* mutable_if_return(); + void set_allocated_if_return(::substrait::DerivationExpression* if_return); private: - const ::io::substrait::DerivationExpression& _internal_if_return() const; - ::io::substrait::DerivationExpression* _internal_mutable_if_return(); + const ::substrait::DerivationExpression& _internal_if_return() const; + ::substrait::DerivationExpression* _internal_mutable_if_return(); public: void unsafe_arena_set_allocated_if_return( - ::io::substrait::DerivationExpression* if_return); - ::io::substrait::DerivationExpression* unsafe_arena_release_if_return(); + ::substrait::DerivationExpression* if_return); + ::substrait::DerivationExpression* unsafe_arena_release_if_return(); - // .io.substrait.DerivationExpression else_return = 3; + // .substrait.DerivationExpression else_return = 3; bool has_else_return() const; private: bool _internal_has_else_return() const; public: void clear_else_return(); - const ::io::substrait::DerivationExpression& else_return() const; - ::io::substrait::DerivationExpression* release_else_return(); - ::io::substrait::DerivationExpression* mutable_else_return(); - void set_allocated_else_return(::io::substrait::DerivationExpression* else_return); + const ::substrait::DerivationExpression& else_return() const; + ::substrait::DerivationExpression* release_else_return(); + ::substrait::DerivationExpression* mutable_else_return(); + void set_allocated_else_return(::substrait::DerivationExpression* else_return); private: - const ::io::substrait::DerivationExpression& _internal_else_return() const; - ::io::substrait::DerivationExpression* _internal_mutable_else_return(); + const ::substrait::DerivationExpression& _internal_else_return() const; + ::substrait::DerivationExpression* _internal_mutable_else_return(); public: void unsafe_arena_set_allocated_else_return( - ::io::substrait::DerivationExpression* else_return); - ::io::substrait::DerivationExpression* unsafe_arena_release_else_return(); + ::substrait::DerivationExpression* else_return); + ::substrait::DerivationExpression* unsafe_arena_release_else_return(); - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.IfElse) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.IfElse) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::DerivationExpression* if_condition_; - ::io::substrait::DerivationExpression* if_return_; - ::io::substrait::DerivationExpression* else_return_; + ::substrait::DerivationExpression* if_condition_; + ::substrait::DerivationExpression* if_return_; + ::substrait::DerivationExpression* else_return_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_UnaryOp PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.UnaryOp) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.UnaryOp) */ { public: inline DerivationExpression_UnaryOp() : DerivationExpression_UnaryOp(nullptr) {} ~DerivationExpression_UnaryOp() override; @@ -1794,7 +1791,7 @@ class DerivationExpression_UnaryOp PROTOBUF_FINAL : void InternalSwap(DerivationExpression_UnaryOp* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.UnaryOp"; + return "substrait.DerivationExpression.UnaryOp"; } protected: explicit DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1807,34 +1804,34 @@ class DerivationExpression_UnaryOp PROTOBUF_FINAL : // nested types ---------------------------------------------------- - typedef DerivationExpression_UnaryOp_OpType OpType; - static constexpr OpType UNKNOWN = - DerivationExpression_UnaryOp_OpType_UNKNOWN; - static constexpr OpType BOOLEAN_NOT = - DerivationExpression_UnaryOp_OpType_BOOLEAN_NOT; - static inline bool OpType_IsValid(int value) { - return DerivationExpression_UnaryOp_OpType_IsValid(value); - } - static constexpr OpType OpType_MIN = - DerivationExpression_UnaryOp_OpType_OpType_MIN; - static constexpr OpType OpType_MAX = - DerivationExpression_UnaryOp_OpType_OpType_MAX; - static constexpr int OpType_ARRAYSIZE = - DerivationExpression_UnaryOp_OpType_OpType_ARRAYSIZE; + typedef DerivationExpression_UnaryOp_UnaryOpType UnaryOpType; + static constexpr UnaryOpType UNARY_OP_TYPE_UNSPECIFIED = + DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED; + static constexpr UnaryOpType UNARY_OP_TYPE_BOOLEAN_NOT = + DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT; + static inline bool UnaryOpType_IsValid(int value) { + return DerivationExpression_UnaryOp_UnaryOpType_IsValid(value); + } + static constexpr UnaryOpType UnaryOpType_MIN = + DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MIN; + static constexpr UnaryOpType UnaryOpType_MAX = + DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX; + static constexpr int UnaryOpType_ARRAYSIZE = + DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - OpType_descriptor() { - return DerivationExpression_UnaryOp_OpType_descriptor(); + UnaryOpType_descriptor() { + return DerivationExpression_UnaryOp_UnaryOpType_descriptor(); } template - static inline const std::string& OpType_Name(T enum_t_value) { - static_assert(::std::is_same::value || + static inline const std::string& UnaryOpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || ::std::is_integral::value, - "Incorrect type passed to function OpType_Name."); - return DerivationExpression_UnaryOp_OpType_Name(enum_t_value); + "Incorrect type passed to function UnaryOpType_Name."); + return DerivationExpression_UnaryOp_UnaryOpType_Name(enum_t_value); } - static inline bool OpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - OpType* value) { - return DerivationExpression_UnaryOp_OpType_Parse(name, value); + static inline bool UnaryOpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + UnaryOpType* value) { + return DerivationExpression_UnaryOp_UnaryOpType_Parse(name, value); } // accessors ------------------------------------------------------- @@ -1843,49 +1840,49 @@ class DerivationExpression_UnaryOp PROTOBUF_FINAL : kArgFieldNumber = 2, kOpTypeFieldNumber = 1, }; - // .io.substrait.DerivationExpression arg = 2; + // .substrait.DerivationExpression arg = 2; bool has_arg() const; private: bool _internal_has_arg() const; public: void clear_arg(); - const ::io::substrait::DerivationExpression& arg() const; - ::io::substrait::DerivationExpression* release_arg(); - ::io::substrait::DerivationExpression* mutable_arg(); - void set_allocated_arg(::io::substrait::DerivationExpression* arg); + const ::substrait::DerivationExpression& arg() const; + ::substrait::DerivationExpression* release_arg(); + ::substrait::DerivationExpression* mutable_arg(); + void set_allocated_arg(::substrait::DerivationExpression* arg); private: - const ::io::substrait::DerivationExpression& _internal_arg() const; - ::io::substrait::DerivationExpression* _internal_mutable_arg(); + const ::substrait::DerivationExpression& _internal_arg() const; + ::substrait::DerivationExpression* _internal_mutable_arg(); public: void unsafe_arena_set_allocated_arg( - ::io::substrait::DerivationExpression* arg); - ::io::substrait::DerivationExpression* unsafe_arena_release_arg(); + ::substrait::DerivationExpression* arg); + ::substrait::DerivationExpression* unsafe_arena_release_arg(); - // .io.substrait.DerivationExpression.UnaryOp.OpType op_type = 1; + // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; void clear_op_type(); - ::io::substrait::DerivationExpression_UnaryOp_OpType op_type() const; - void set_op_type(::io::substrait::DerivationExpression_UnaryOp_OpType value); + ::substrait::DerivationExpression_UnaryOp_UnaryOpType op_type() const; + void set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value); private: - ::io::substrait::DerivationExpression_UnaryOp_OpType _internal_op_type() const; - void _internal_set_op_type(::io::substrait::DerivationExpression_UnaryOp_OpType value); + ::substrait::DerivationExpression_UnaryOp_UnaryOpType _internal_op_type() const; + void _internal_set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value); public: - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.UnaryOp) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.UnaryOp) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::DerivationExpression* arg_; + ::substrait::DerivationExpression* arg_; int op_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_BinaryOp PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.BinaryOp) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.BinaryOp) */ { public: inline DerivationExpression_BinaryOp() : DerivationExpression_BinaryOp(nullptr) {} ~DerivationExpression_BinaryOp() override; @@ -1975,7 +1972,7 @@ class DerivationExpression_BinaryOp PROTOBUF_FINAL : void InternalSwap(DerivationExpression_BinaryOp* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.BinaryOp"; + return "substrait.DerivationExpression.BinaryOp"; } protected: explicit DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -1988,56 +1985,56 @@ class DerivationExpression_BinaryOp PROTOBUF_FINAL : // nested types ---------------------------------------------------- - typedef DerivationExpression_BinaryOp_OpType OpType; - static constexpr OpType UNKNOWN = - DerivationExpression_BinaryOp_OpType_UNKNOWN; - static constexpr OpType PLUS = - DerivationExpression_BinaryOp_OpType_PLUS; - static constexpr OpType MINUS = - DerivationExpression_BinaryOp_OpType_MINUS; - static constexpr OpType MULTIPLY = - DerivationExpression_BinaryOp_OpType_MULTIPLY; - static constexpr OpType DIVIDE = - DerivationExpression_BinaryOp_OpType_DIVIDE; - static constexpr OpType MIN = - DerivationExpression_BinaryOp_OpType_MIN; - static constexpr OpType MAX = - DerivationExpression_BinaryOp_OpType_MAX; - static constexpr OpType GREATER_THAN = - DerivationExpression_BinaryOp_OpType_GREATER_THAN; - static constexpr OpType LESS_THAN = - DerivationExpression_BinaryOp_OpType_LESS_THAN; - static constexpr OpType AND = - DerivationExpression_BinaryOp_OpType_AND; - static constexpr OpType OR = - DerivationExpression_BinaryOp_OpType_OR; - static constexpr OpType EQUALS = - DerivationExpression_BinaryOp_OpType_EQUALS; - static constexpr OpType COVERS = - DerivationExpression_BinaryOp_OpType_COVERS; - static inline bool OpType_IsValid(int value) { - return DerivationExpression_BinaryOp_OpType_IsValid(value); - } - static constexpr OpType OpType_MIN = - DerivationExpression_BinaryOp_OpType_OpType_MIN; - static constexpr OpType OpType_MAX = - DerivationExpression_BinaryOp_OpType_OpType_MAX; - static constexpr int OpType_ARRAYSIZE = - DerivationExpression_BinaryOp_OpType_OpType_ARRAYSIZE; + typedef DerivationExpression_BinaryOp_BinaryOpType BinaryOpType; + static constexpr BinaryOpType BINARY_OP_TYPE_UNSPECIFIED = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED; + static constexpr BinaryOpType BINARY_OP_TYPE_PLUS = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_PLUS; + static constexpr BinaryOpType BINARY_OP_TYPE_MINUS = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MINUS; + static constexpr BinaryOpType BINARY_OP_TYPE_MULTIPLY = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MULTIPLY; + static constexpr BinaryOpType BINARY_OP_TYPE_DIVIDE = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_DIVIDE; + static constexpr BinaryOpType BINARY_OP_TYPE_MIN = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MIN; + static constexpr BinaryOpType BINARY_OP_TYPE_MAX = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MAX; + static constexpr BinaryOpType BINARY_OP_TYPE_GREATER_THAN = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_GREATER_THAN; + static constexpr BinaryOpType BINARY_OP_TYPE_LESS_THAN = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_LESS_THAN; + static constexpr BinaryOpType BINARY_OP_TYPE_AND = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_AND; + static constexpr BinaryOpType BINARY_OP_TYPE_OR = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_OR; + static constexpr BinaryOpType BINARY_OP_TYPE_EQUALS = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_EQUALS; + static constexpr BinaryOpType BINARY_OP_TYPE_COVERS = + DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS; + static inline bool BinaryOpType_IsValid(int value) { + return DerivationExpression_BinaryOp_BinaryOpType_IsValid(value); + } + static constexpr BinaryOpType BinaryOpType_MIN = + DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MIN; + static constexpr BinaryOpType BinaryOpType_MAX = + DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX; + static constexpr int BinaryOpType_ARRAYSIZE = + DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - OpType_descriptor() { - return DerivationExpression_BinaryOp_OpType_descriptor(); + BinaryOpType_descriptor() { + return DerivationExpression_BinaryOp_BinaryOpType_descriptor(); } template - static inline const std::string& OpType_Name(T enum_t_value) { - static_assert(::std::is_same::value || + static inline const std::string& BinaryOpType_Name(T enum_t_value) { + static_assert(::std::is_same::value || ::std::is_integral::value, - "Incorrect type passed to function OpType_Name."); - return DerivationExpression_BinaryOp_OpType_Name(enum_t_value); + "Incorrect type passed to function BinaryOpType_Name."); + return DerivationExpression_BinaryOp_BinaryOpType_Name(enum_t_value); } - static inline bool OpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - OpType* value) { - return DerivationExpression_BinaryOp_OpType_Parse(name, value); + static inline bool BinaryOpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, + BinaryOpType* value) { + return DerivationExpression_BinaryOp_BinaryOpType_Parse(name, value); } // accessors ------------------------------------------------------- @@ -2047,68 +2044,68 @@ class DerivationExpression_BinaryOp PROTOBUF_FINAL : kArg2FieldNumber = 3, kOpTypeFieldNumber = 1, }; - // .io.substrait.DerivationExpression arg1 = 2; + // .substrait.DerivationExpression arg1 = 2; bool has_arg1() const; private: bool _internal_has_arg1() const; public: void clear_arg1(); - const ::io::substrait::DerivationExpression& arg1() const; - ::io::substrait::DerivationExpression* release_arg1(); - ::io::substrait::DerivationExpression* mutable_arg1(); - void set_allocated_arg1(::io::substrait::DerivationExpression* arg1); + const ::substrait::DerivationExpression& arg1() const; + ::substrait::DerivationExpression* release_arg1(); + ::substrait::DerivationExpression* mutable_arg1(); + void set_allocated_arg1(::substrait::DerivationExpression* arg1); private: - const ::io::substrait::DerivationExpression& _internal_arg1() const; - ::io::substrait::DerivationExpression* _internal_mutable_arg1(); + const ::substrait::DerivationExpression& _internal_arg1() const; + ::substrait::DerivationExpression* _internal_mutable_arg1(); public: void unsafe_arena_set_allocated_arg1( - ::io::substrait::DerivationExpression* arg1); - ::io::substrait::DerivationExpression* unsafe_arena_release_arg1(); + ::substrait::DerivationExpression* arg1); + ::substrait::DerivationExpression* unsafe_arena_release_arg1(); - // .io.substrait.DerivationExpression arg2 = 3; + // .substrait.DerivationExpression arg2 = 3; bool has_arg2() const; private: bool _internal_has_arg2() const; public: void clear_arg2(); - const ::io::substrait::DerivationExpression& arg2() const; - ::io::substrait::DerivationExpression* release_arg2(); - ::io::substrait::DerivationExpression* mutable_arg2(); - void set_allocated_arg2(::io::substrait::DerivationExpression* arg2); + const ::substrait::DerivationExpression& arg2() const; + ::substrait::DerivationExpression* release_arg2(); + ::substrait::DerivationExpression* mutable_arg2(); + void set_allocated_arg2(::substrait::DerivationExpression* arg2); private: - const ::io::substrait::DerivationExpression& _internal_arg2() const; - ::io::substrait::DerivationExpression* _internal_mutable_arg2(); + const ::substrait::DerivationExpression& _internal_arg2() const; + ::substrait::DerivationExpression* _internal_mutable_arg2(); public: void unsafe_arena_set_allocated_arg2( - ::io::substrait::DerivationExpression* arg2); - ::io::substrait::DerivationExpression* unsafe_arena_release_arg2(); + ::substrait::DerivationExpression* arg2); + ::substrait::DerivationExpression* unsafe_arena_release_arg2(); - // .io.substrait.DerivationExpression.BinaryOp.OpType op_type = 1; + // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; void clear_op_type(); - ::io::substrait::DerivationExpression_BinaryOp_OpType op_type() const; - void set_op_type(::io::substrait::DerivationExpression_BinaryOp_OpType value); + ::substrait::DerivationExpression_BinaryOp_BinaryOpType op_type() const; + void set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value); private: - ::io::substrait::DerivationExpression_BinaryOp_OpType _internal_op_type() const; - void _internal_set_op_type(::io::substrait::DerivationExpression_BinaryOp_OpType value); + ::substrait::DerivationExpression_BinaryOp_BinaryOpType _internal_op_type() const; + void _internal_set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value); public: - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.BinaryOp) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.BinaryOp) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::io::substrait::DerivationExpression* arg1_; - ::io::substrait::DerivationExpression* arg2_; + ::substrait::DerivationExpression* arg1_; + ::substrait::DerivationExpression* arg2_; int op_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ReturnProgram.Assignment) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ReturnProgram.Assignment) */ { public: inline DerivationExpression_ReturnProgram_Assignment() : DerivationExpression_ReturnProgram_Assignment(nullptr) {} ~DerivationExpression_ReturnProgram_Assignment() override; @@ -2198,7 +2195,7 @@ class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : void InternalSwap(DerivationExpression_ReturnProgram_Assignment* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.ReturnProgram.Assignment"; + return "substrait.DerivationExpression.ReturnProgram.Assignment"; } protected: explicit DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2231,25 +2228,25 @@ class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : std::string* _internal_mutable_name(); public: - // .io.substrait.DerivationExpression expression = 2; + // .substrait.DerivationExpression expression = 2; bool has_expression() const; private: bool _internal_has_expression() const; public: void clear_expression(); - const ::io::substrait::DerivationExpression& expression() const; - ::io::substrait::DerivationExpression* release_expression(); - ::io::substrait::DerivationExpression* mutable_expression(); - void set_allocated_expression(::io::substrait::DerivationExpression* expression); + const ::substrait::DerivationExpression& expression() const; + ::substrait::DerivationExpression* release_expression(); + ::substrait::DerivationExpression* mutable_expression(); + void set_allocated_expression(::substrait::DerivationExpression* expression); private: - const ::io::substrait::DerivationExpression& _internal_expression() const; - ::io::substrait::DerivationExpression* _internal_mutable_expression(); + const ::substrait::DerivationExpression& _internal_expression() const; + ::substrait::DerivationExpression* _internal_mutable_expression(); public: void unsafe_arena_set_allocated_expression( - ::io::substrait::DerivationExpression* expression); - ::io::substrait::DerivationExpression* unsafe_arena_release_expression(); + ::substrait::DerivationExpression* expression); + ::substrait::DerivationExpression* unsafe_arena_release_expression(); - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ReturnProgram.Assignment) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ReturnProgram.Assignment) private: class _Internal; @@ -2257,14 +2254,14 @@ class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::io::substrait::DerivationExpression* expression_; + ::substrait::DerivationExpression* expression_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression_ReturnProgram PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression.ReturnProgram) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ReturnProgram) */ { public: inline DerivationExpression_ReturnProgram() : DerivationExpression_ReturnProgram(nullptr) {} ~DerivationExpression_ReturnProgram() override; @@ -2354,7 +2351,7 @@ class DerivationExpression_ReturnProgram PROTOBUF_FINAL : void InternalSwap(DerivationExpression_ReturnProgram* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression.ReturnProgram"; + return "substrait.DerivationExpression.ReturnProgram"; } protected: explicit DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2375,58 +2372,58 @@ class DerivationExpression_ReturnProgram PROTOBUF_FINAL : kAssignmentsFieldNumber = 1, kFinalExpressionFieldNumber = 2, }; - // repeated .io.substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; + // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; int assignments_size() const; private: int _internal_assignments_size() const; public: void clear_assignments(); - ::io::substrait::DerivationExpression_ReturnProgram_Assignment* mutable_assignments(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >* + ::substrait::DerivationExpression_ReturnProgram_Assignment* mutable_assignments(int index); + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >* mutable_assignments(); private: - const ::io::substrait::DerivationExpression_ReturnProgram_Assignment& _internal_assignments(int index) const; - ::io::substrait::DerivationExpression_ReturnProgram_Assignment* _internal_add_assignments(); + const ::substrait::DerivationExpression_ReturnProgram_Assignment& _internal_assignments(int index) const; + ::substrait::DerivationExpression_ReturnProgram_Assignment* _internal_add_assignments(); public: - const ::io::substrait::DerivationExpression_ReturnProgram_Assignment& assignments(int index) const; - ::io::substrait::DerivationExpression_ReturnProgram_Assignment* add_assignments(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >& + const ::substrait::DerivationExpression_ReturnProgram_Assignment& assignments(int index) const; + ::substrait::DerivationExpression_ReturnProgram_Assignment* add_assignments(); + const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >& assignments() const; - // .io.substrait.DerivationExpression finalExpression = 2; - bool has_finalexpression() const; + // .substrait.DerivationExpression final_expression = 2; + bool has_final_expression() const; private: - bool _internal_has_finalexpression() const; + bool _internal_has_final_expression() const; public: - void clear_finalexpression(); - const ::io::substrait::DerivationExpression& finalexpression() const; - ::io::substrait::DerivationExpression* release_finalexpression(); - ::io::substrait::DerivationExpression* mutable_finalexpression(); - void set_allocated_finalexpression(::io::substrait::DerivationExpression* finalexpression); + void clear_final_expression(); + const ::substrait::DerivationExpression& final_expression() const; + ::substrait::DerivationExpression* release_final_expression(); + ::substrait::DerivationExpression* mutable_final_expression(); + void set_allocated_final_expression(::substrait::DerivationExpression* final_expression); private: - const ::io::substrait::DerivationExpression& _internal_finalexpression() const; - ::io::substrait::DerivationExpression* _internal_mutable_finalexpression(); + const ::substrait::DerivationExpression& _internal_final_expression() const; + ::substrait::DerivationExpression* _internal_mutable_final_expression(); public: - void unsafe_arena_set_allocated_finalexpression( - ::io::substrait::DerivationExpression* finalexpression); - ::io::substrait::DerivationExpression* unsafe_arena_release_finalexpression(); + void unsafe_arena_set_allocated_final_expression( + ::substrait::DerivationExpression* final_expression); + ::substrait::DerivationExpression* unsafe_arena_release_final_expression(); - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression.ReturnProgram) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ReturnProgram) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression_ReturnProgram_Assignment > assignments_; - ::io::substrait::DerivationExpression* finalexpression_; + ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment > assignments_; + ::substrait::DerivationExpression* final_expression_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- class DerivationExpression PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.DerivationExpression) */ { + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression) */ { public: inline DerivationExpression() : DerivationExpression(nullptr) {} ~DerivationExpression() override; @@ -2551,7 +2548,7 @@ class DerivationExpression PROTOBUF_FINAL : void InternalSwap(DerivationExpression* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.DerivationExpression"; + return "substrait.DerivationExpression"; } protected: explicit DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); @@ -2612,419 +2609,419 @@ class DerivationExpression PROTOBUF_FINAL : kIfElseFieldNumber = 38, kReturnProgramFieldNumber = 39, }; - // .io.substrait.Type.Boolean bool = 1; + // .substrait.Type.Boolean bool = 1; bool has_bool_() const; private: bool _internal_has_bool_() const; public: void clear_bool_(); - const ::io::substrait::Type_Boolean& bool_() const; - ::io::substrait::Type_Boolean* release_bool_(); - ::io::substrait::Type_Boolean* mutable_bool_(); - void set_allocated_bool_(::io::substrait::Type_Boolean* bool_); + const ::substrait::Type_Boolean& bool_() const; + ::substrait::Type_Boolean* release_bool_(); + ::substrait::Type_Boolean* mutable_bool_(); + void set_allocated_bool_(::substrait::Type_Boolean* bool_); private: - const ::io::substrait::Type_Boolean& _internal_bool_() const; - ::io::substrait::Type_Boolean* _internal_mutable_bool_(); + const ::substrait::Type_Boolean& _internal_bool_() const; + ::substrait::Type_Boolean* _internal_mutable_bool_(); public: void unsafe_arena_set_allocated_bool_( - ::io::substrait::Type_Boolean* bool_); - ::io::substrait::Type_Boolean* unsafe_arena_release_bool_(); + ::substrait::Type_Boolean* bool_); + ::substrait::Type_Boolean* unsafe_arena_release_bool_(); - // .io.substrait.Type.I8 i8 = 2; + // .substrait.Type.I8 i8 = 2; bool has_i8() const; private: bool _internal_has_i8() const; public: void clear_i8(); - const ::io::substrait::Type_I8& i8() const; - ::io::substrait::Type_I8* release_i8(); - ::io::substrait::Type_I8* mutable_i8(); - void set_allocated_i8(::io::substrait::Type_I8* i8); + const ::substrait::Type_I8& i8() const; + ::substrait::Type_I8* release_i8(); + ::substrait::Type_I8* mutable_i8(); + void set_allocated_i8(::substrait::Type_I8* i8); private: - const ::io::substrait::Type_I8& _internal_i8() const; - ::io::substrait::Type_I8* _internal_mutable_i8(); + const ::substrait::Type_I8& _internal_i8() const; + ::substrait::Type_I8* _internal_mutable_i8(); public: void unsafe_arena_set_allocated_i8( - ::io::substrait::Type_I8* i8); - ::io::substrait::Type_I8* unsafe_arena_release_i8(); + ::substrait::Type_I8* i8); + ::substrait::Type_I8* unsafe_arena_release_i8(); - // .io.substrait.Type.I16 i16 = 3; + // .substrait.Type.I16 i16 = 3; bool has_i16() const; private: bool _internal_has_i16() const; public: void clear_i16(); - const ::io::substrait::Type_I16& i16() const; - ::io::substrait::Type_I16* release_i16(); - ::io::substrait::Type_I16* mutable_i16(); - void set_allocated_i16(::io::substrait::Type_I16* i16); + const ::substrait::Type_I16& i16() const; + ::substrait::Type_I16* release_i16(); + ::substrait::Type_I16* mutable_i16(); + void set_allocated_i16(::substrait::Type_I16* i16); private: - const ::io::substrait::Type_I16& _internal_i16() const; - ::io::substrait::Type_I16* _internal_mutable_i16(); + const ::substrait::Type_I16& _internal_i16() const; + ::substrait::Type_I16* _internal_mutable_i16(); public: void unsafe_arena_set_allocated_i16( - ::io::substrait::Type_I16* i16); - ::io::substrait::Type_I16* unsafe_arena_release_i16(); + ::substrait::Type_I16* i16); + ::substrait::Type_I16* unsafe_arena_release_i16(); - // .io.substrait.Type.I32 i32 = 5; + // .substrait.Type.I32 i32 = 5; bool has_i32() const; private: bool _internal_has_i32() const; public: void clear_i32(); - const ::io::substrait::Type_I32& i32() const; - ::io::substrait::Type_I32* release_i32(); - ::io::substrait::Type_I32* mutable_i32(); - void set_allocated_i32(::io::substrait::Type_I32* i32); + const ::substrait::Type_I32& i32() const; + ::substrait::Type_I32* release_i32(); + ::substrait::Type_I32* mutable_i32(); + void set_allocated_i32(::substrait::Type_I32* i32); private: - const ::io::substrait::Type_I32& _internal_i32() const; - ::io::substrait::Type_I32* _internal_mutable_i32(); + const ::substrait::Type_I32& _internal_i32() const; + ::substrait::Type_I32* _internal_mutable_i32(); public: void unsafe_arena_set_allocated_i32( - ::io::substrait::Type_I32* i32); - ::io::substrait::Type_I32* unsafe_arena_release_i32(); + ::substrait::Type_I32* i32); + ::substrait::Type_I32* unsafe_arena_release_i32(); - // .io.substrait.Type.I64 i64 = 7; + // .substrait.Type.I64 i64 = 7; bool has_i64() const; private: bool _internal_has_i64() const; public: void clear_i64(); - const ::io::substrait::Type_I64& i64() const; - ::io::substrait::Type_I64* release_i64(); - ::io::substrait::Type_I64* mutable_i64(); - void set_allocated_i64(::io::substrait::Type_I64* i64); + const ::substrait::Type_I64& i64() const; + ::substrait::Type_I64* release_i64(); + ::substrait::Type_I64* mutable_i64(); + void set_allocated_i64(::substrait::Type_I64* i64); private: - const ::io::substrait::Type_I64& _internal_i64() const; - ::io::substrait::Type_I64* _internal_mutable_i64(); + const ::substrait::Type_I64& _internal_i64() const; + ::substrait::Type_I64* _internal_mutable_i64(); public: void unsafe_arena_set_allocated_i64( - ::io::substrait::Type_I64* i64); - ::io::substrait::Type_I64* unsafe_arena_release_i64(); + ::substrait::Type_I64* i64); + ::substrait::Type_I64* unsafe_arena_release_i64(); - // .io.substrait.Type.FP32 fp32 = 10; + // .substrait.Type.FP32 fp32 = 10; bool has_fp32() const; private: bool _internal_has_fp32() const; public: void clear_fp32(); - const ::io::substrait::Type_FP32& fp32() const; - ::io::substrait::Type_FP32* release_fp32(); - ::io::substrait::Type_FP32* mutable_fp32(); - void set_allocated_fp32(::io::substrait::Type_FP32* fp32); + const ::substrait::Type_FP32& fp32() const; + ::substrait::Type_FP32* release_fp32(); + ::substrait::Type_FP32* mutable_fp32(); + void set_allocated_fp32(::substrait::Type_FP32* fp32); private: - const ::io::substrait::Type_FP32& _internal_fp32() const; - ::io::substrait::Type_FP32* _internal_mutable_fp32(); + const ::substrait::Type_FP32& _internal_fp32() const; + ::substrait::Type_FP32* _internal_mutable_fp32(); public: void unsafe_arena_set_allocated_fp32( - ::io::substrait::Type_FP32* fp32); - ::io::substrait::Type_FP32* unsafe_arena_release_fp32(); + ::substrait::Type_FP32* fp32); + ::substrait::Type_FP32* unsafe_arena_release_fp32(); - // .io.substrait.Type.FP64 fp64 = 11; + // .substrait.Type.FP64 fp64 = 11; bool has_fp64() const; private: bool _internal_has_fp64() const; public: void clear_fp64(); - const ::io::substrait::Type_FP64& fp64() const; - ::io::substrait::Type_FP64* release_fp64(); - ::io::substrait::Type_FP64* mutable_fp64(); - void set_allocated_fp64(::io::substrait::Type_FP64* fp64); + const ::substrait::Type_FP64& fp64() const; + ::substrait::Type_FP64* release_fp64(); + ::substrait::Type_FP64* mutable_fp64(); + void set_allocated_fp64(::substrait::Type_FP64* fp64); private: - const ::io::substrait::Type_FP64& _internal_fp64() const; - ::io::substrait::Type_FP64* _internal_mutable_fp64(); + const ::substrait::Type_FP64& _internal_fp64() const; + ::substrait::Type_FP64* _internal_mutable_fp64(); public: void unsafe_arena_set_allocated_fp64( - ::io::substrait::Type_FP64* fp64); - ::io::substrait::Type_FP64* unsafe_arena_release_fp64(); + ::substrait::Type_FP64* fp64); + ::substrait::Type_FP64* unsafe_arena_release_fp64(); - // .io.substrait.Type.String string = 12; + // .substrait.Type.String string = 12; bool has_string() const; private: bool _internal_has_string() const; public: void clear_string(); - const ::io::substrait::Type_String& string() const; - ::io::substrait::Type_String* release_string(); - ::io::substrait::Type_String* mutable_string(); - void set_allocated_string(::io::substrait::Type_String* string); + const ::substrait::Type_String& string() const; + ::substrait::Type_String* release_string(); + ::substrait::Type_String* mutable_string(); + void set_allocated_string(::substrait::Type_String* string); private: - const ::io::substrait::Type_String& _internal_string() const; - ::io::substrait::Type_String* _internal_mutable_string(); + const ::substrait::Type_String& _internal_string() const; + ::substrait::Type_String* _internal_mutable_string(); public: void unsafe_arena_set_allocated_string( - ::io::substrait::Type_String* string); - ::io::substrait::Type_String* unsafe_arena_release_string(); + ::substrait::Type_String* string); + ::substrait::Type_String* unsafe_arena_release_string(); - // .io.substrait.Type.Binary binary = 13; + // .substrait.Type.Binary binary = 13; bool has_binary() const; private: bool _internal_has_binary() const; public: void clear_binary(); - const ::io::substrait::Type_Binary& binary() const; - ::io::substrait::Type_Binary* release_binary(); - ::io::substrait::Type_Binary* mutable_binary(); - void set_allocated_binary(::io::substrait::Type_Binary* binary); + const ::substrait::Type_Binary& binary() const; + ::substrait::Type_Binary* release_binary(); + ::substrait::Type_Binary* mutable_binary(); + void set_allocated_binary(::substrait::Type_Binary* binary); private: - const ::io::substrait::Type_Binary& _internal_binary() const; - ::io::substrait::Type_Binary* _internal_mutable_binary(); + const ::substrait::Type_Binary& _internal_binary() const; + ::substrait::Type_Binary* _internal_mutable_binary(); public: void unsafe_arena_set_allocated_binary( - ::io::substrait::Type_Binary* binary); - ::io::substrait::Type_Binary* unsafe_arena_release_binary(); + ::substrait::Type_Binary* binary); + ::substrait::Type_Binary* unsafe_arena_release_binary(); - // .io.substrait.Type.Timestamp timestamp = 14; + // .substrait.Type.Timestamp timestamp = 14; bool has_timestamp() const; private: bool _internal_has_timestamp() const; public: void clear_timestamp(); - const ::io::substrait::Type_Timestamp& timestamp() const; - ::io::substrait::Type_Timestamp* release_timestamp(); - ::io::substrait::Type_Timestamp* mutable_timestamp(); - void set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp); + const ::substrait::Type_Timestamp& timestamp() const; + ::substrait::Type_Timestamp* release_timestamp(); + ::substrait::Type_Timestamp* mutable_timestamp(); + void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp); private: - const ::io::substrait::Type_Timestamp& _internal_timestamp() const; - ::io::substrait::Type_Timestamp* _internal_mutable_timestamp(); + const ::substrait::Type_Timestamp& _internal_timestamp() const; + ::substrait::Type_Timestamp* _internal_mutable_timestamp(); public: void unsafe_arena_set_allocated_timestamp( - ::io::substrait::Type_Timestamp* timestamp); - ::io::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); + ::substrait::Type_Timestamp* timestamp); + ::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); - // .io.substrait.Type.Date date = 16; + // .substrait.Type.Date date = 16; bool has_date() const; private: bool _internal_has_date() const; public: void clear_date(); - const ::io::substrait::Type_Date& date() const; - ::io::substrait::Type_Date* release_date(); - ::io::substrait::Type_Date* mutable_date(); - void set_allocated_date(::io::substrait::Type_Date* date); + const ::substrait::Type_Date& date() const; + ::substrait::Type_Date* release_date(); + ::substrait::Type_Date* mutable_date(); + void set_allocated_date(::substrait::Type_Date* date); private: - const ::io::substrait::Type_Date& _internal_date() const; - ::io::substrait::Type_Date* _internal_mutable_date(); + const ::substrait::Type_Date& _internal_date() const; + ::substrait::Type_Date* _internal_mutable_date(); public: void unsafe_arena_set_allocated_date( - ::io::substrait::Type_Date* date); - ::io::substrait::Type_Date* unsafe_arena_release_date(); + ::substrait::Type_Date* date); + ::substrait::Type_Date* unsafe_arena_release_date(); - // .io.substrait.Type.Time time = 17; + // .substrait.Type.Time time = 17; bool has_time() const; private: bool _internal_has_time() const; public: void clear_time(); - const ::io::substrait::Type_Time& time() const; - ::io::substrait::Type_Time* release_time(); - ::io::substrait::Type_Time* mutable_time(); - void set_allocated_time(::io::substrait::Type_Time* time); + const ::substrait::Type_Time& time() const; + ::substrait::Type_Time* release_time(); + ::substrait::Type_Time* mutable_time(); + void set_allocated_time(::substrait::Type_Time* time); private: - const ::io::substrait::Type_Time& _internal_time() const; - ::io::substrait::Type_Time* _internal_mutable_time(); + const ::substrait::Type_Time& _internal_time() const; + ::substrait::Type_Time* _internal_mutable_time(); public: void unsafe_arena_set_allocated_time( - ::io::substrait::Type_Time* time); - ::io::substrait::Type_Time* unsafe_arena_release_time(); + ::substrait::Type_Time* time); + ::substrait::Type_Time* unsafe_arena_release_time(); - // .io.substrait.Type.IntervalYear interval_year = 19; + // .substrait.Type.IntervalYear interval_year = 19; bool has_interval_year() const; private: bool _internal_has_interval_year() const; public: void clear_interval_year(); - const ::io::substrait::Type_IntervalYear& interval_year() const; - ::io::substrait::Type_IntervalYear* release_interval_year(); - ::io::substrait::Type_IntervalYear* mutable_interval_year(); - void set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year); + const ::substrait::Type_IntervalYear& interval_year() const; + ::substrait::Type_IntervalYear* release_interval_year(); + ::substrait::Type_IntervalYear* mutable_interval_year(); + void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year); private: - const ::io::substrait::Type_IntervalYear& _internal_interval_year() const; - ::io::substrait::Type_IntervalYear* _internal_mutable_interval_year(); + const ::substrait::Type_IntervalYear& _internal_interval_year() const; + ::substrait::Type_IntervalYear* _internal_mutable_interval_year(); public: void unsafe_arena_set_allocated_interval_year( - ::io::substrait::Type_IntervalYear* interval_year); - ::io::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); + ::substrait::Type_IntervalYear* interval_year); + ::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); - // .io.substrait.Type.IntervalDay interval_day = 20; + // .substrait.Type.IntervalDay interval_day = 20; bool has_interval_day() const; private: bool _internal_has_interval_day() const; public: void clear_interval_day(); - const ::io::substrait::Type_IntervalDay& interval_day() const; - ::io::substrait::Type_IntervalDay* release_interval_day(); - ::io::substrait::Type_IntervalDay* mutable_interval_day(); - void set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day); + const ::substrait::Type_IntervalDay& interval_day() const; + ::substrait::Type_IntervalDay* release_interval_day(); + ::substrait::Type_IntervalDay* mutable_interval_day(); + void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day); private: - const ::io::substrait::Type_IntervalDay& _internal_interval_day() const; - ::io::substrait::Type_IntervalDay* _internal_mutable_interval_day(); + const ::substrait::Type_IntervalDay& _internal_interval_day() const; + ::substrait::Type_IntervalDay* _internal_mutable_interval_day(); public: void unsafe_arena_set_allocated_interval_day( - ::io::substrait::Type_IntervalDay* interval_day); - ::io::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); + ::substrait::Type_IntervalDay* interval_day); + ::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); - // .io.substrait.Type.TimestampTZ timestamp_tz = 29; + // .substrait.Type.TimestampTZ timestamp_tz = 29; bool has_timestamp_tz() const; private: bool _internal_has_timestamp_tz() const; public: void clear_timestamp_tz(); - const ::io::substrait::Type_TimestampTZ& timestamp_tz() const; - ::io::substrait::Type_TimestampTZ* release_timestamp_tz(); - ::io::substrait::Type_TimestampTZ* mutable_timestamp_tz(); - void set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz); + const ::substrait::Type_TimestampTZ& timestamp_tz() const; + ::substrait::Type_TimestampTZ* release_timestamp_tz(); + ::substrait::Type_TimestampTZ* mutable_timestamp_tz(); + void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz); private: - const ::io::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; - ::io::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); + const ::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; + ::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); public: void unsafe_arena_set_allocated_timestamp_tz( - ::io::substrait::Type_TimestampTZ* timestamp_tz); - ::io::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); + ::substrait::Type_TimestampTZ* timestamp_tz); + ::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); - // .io.substrait.Type.UUID uuid = 32; + // .substrait.Type.UUID uuid = 32; bool has_uuid() const; private: bool _internal_has_uuid() const; public: void clear_uuid(); - const ::io::substrait::Type_UUID& uuid() const; - ::io::substrait::Type_UUID* release_uuid(); - ::io::substrait::Type_UUID* mutable_uuid(); - void set_allocated_uuid(::io::substrait::Type_UUID* uuid); + const ::substrait::Type_UUID& uuid() const; + ::substrait::Type_UUID* release_uuid(); + ::substrait::Type_UUID* mutable_uuid(); + void set_allocated_uuid(::substrait::Type_UUID* uuid); private: - const ::io::substrait::Type_UUID& _internal_uuid() const; - ::io::substrait::Type_UUID* _internal_mutable_uuid(); + const ::substrait::Type_UUID& _internal_uuid() const; + ::substrait::Type_UUID* _internal_mutable_uuid(); public: void unsafe_arena_set_allocated_uuid( - ::io::substrait::Type_UUID* uuid); - ::io::substrait::Type_UUID* unsafe_arena_release_uuid(); + ::substrait::Type_UUID* uuid); + ::substrait::Type_UUID* unsafe_arena_release_uuid(); - // .io.substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; + // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; bool has_fixed_char() const; private: bool _internal_has_fixed_char() const; public: void clear_fixed_char(); - const ::io::substrait::DerivationExpression_ExpressionFixedChar& fixed_char() const; - ::io::substrait::DerivationExpression_ExpressionFixedChar* release_fixed_char(); - ::io::substrait::DerivationExpression_ExpressionFixedChar* mutable_fixed_char(); - void set_allocated_fixed_char(::io::substrait::DerivationExpression_ExpressionFixedChar* fixed_char); + const ::substrait::DerivationExpression_ExpressionFixedChar& fixed_char() const; + ::substrait::DerivationExpression_ExpressionFixedChar* release_fixed_char(); + ::substrait::DerivationExpression_ExpressionFixedChar* mutable_fixed_char(); + void set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char); private: - const ::io::substrait::DerivationExpression_ExpressionFixedChar& _internal_fixed_char() const; - ::io::substrait::DerivationExpression_ExpressionFixedChar* _internal_mutable_fixed_char(); + const ::substrait::DerivationExpression_ExpressionFixedChar& _internal_fixed_char() const; + ::substrait::DerivationExpression_ExpressionFixedChar* _internal_mutable_fixed_char(); public: void unsafe_arena_set_allocated_fixed_char( - ::io::substrait::DerivationExpression_ExpressionFixedChar* fixed_char); - ::io::substrait::DerivationExpression_ExpressionFixedChar* unsafe_arena_release_fixed_char(); + ::substrait::DerivationExpression_ExpressionFixedChar* fixed_char); + ::substrait::DerivationExpression_ExpressionFixedChar* unsafe_arena_release_fixed_char(); - // .io.substrait.DerivationExpression.ExpressionVarChar varchar = 22; + // .substrait.DerivationExpression.ExpressionVarChar varchar = 22; bool has_varchar() const; private: bool _internal_has_varchar() const; public: void clear_varchar(); - const ::io::substrait::DerivationExpression_ExpressionVarChar& varchar() const; - ::io::substrait::DerivationExpression_ExpressionVarChar* release_varchar(); - ::io::substrait::DerivationExpression_ExpressionVarChar* mutable_varchar(); - void set_allocated_varchar(::io::substrait::DerivationExpression_ExpressionVarChar* varchar); + const ::substrait::DerivationExpression_ExpressionVarChar& varchar() const; + ::substrait::DerivationExpression_ExpressionVarChar* release_varchar(); + ::substrait::DerivationExpression_ExpressionVarChar* mutable_varchar(); + void set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar); private: - const ::io::substrait::DerivationExpression_ExpressionVarChar& _internal_varchar() const; - ::io::substrait::DerivationExpression_ExpressionVarChar* _internal_mutable_varchar(); + const ::substrait::DerivationExpression_ExpressionVarChar& _internal_varchar() const; + ::substrait::DerivationExpression_ExpressionVarChar* _internal_mutable_varchar(); public: void unsafe_arena_set_allocated_varchar( - ::io::substrait::DerivationExpression_ExpressionVarChar* varchar); - ::io::substrait::DerivationExpression_ExpressionVarChar* unsafe_arena_release_varchar(); + ::substrait::DerivationExpression_ExpressionVarChar* varchar); + ::substrait::DerivationExpression_ExpressionVarChar* unsafe_arena_release_varchar(); - // .io.substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; + // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; bool has_fixed_binary() const; private: bool _internal_has_fixed_binary() const; public: void clear_fixed_binary(); - const ::io::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary() const; - ::io::substrait::DerivationExpression_ExpressionFixedBinary* release_fixed_binary(); - ::io::substrait::DerivationExpression_ExpressionFixedBinary* mutable_fixed_binary(); - void set_allocated_fixed_binary(::io::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary); + const ::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary() const; + ::substrait::DerivationExpression_ExpressionFixedBinary* release_fixed_binary(); + ::substrait::DerivationExpression_ExpressionFixedBinary* mutable_fixed_binary(); + void set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary); private: - const ::io::substrait::DerivationExpression_ExpressionFixedBinary& _internal_fixed_binary() const; - ::io::substrait::DerivationExpression_ExpressionFixedBinary* _internal_mutable_fixed_binary(); + const ::substrait::DerivationExpression_ExpressionFixedBinary& _internal_fixed_binary() const; + ::substrait::DerivationExpression_ExpressionFixedBinary* _internal_mutable_fixed_binary(); public: void unsafe_arena_set_allocated_fixed_binary( - ::io::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary); - ::io::substrait::DerivationExpression_ExpressionFixedBinary* unsafe_arena_release_fixed_binary(); + ::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary); + ::substrait::DerivationExpression_ExpressionFixedBinary* unsafe_arena_release_fixed_binary(); - // .io.substrait.DerivationExpression.ExpressionDecimal decimal = 24; + // .substrait.DerivationExpression.ExpressionDecimal decimal = 24; bool has_decimal() const; private: bool _internal_has_decimal() const; public: void clear_decimal(); - const ::io::substrait::DerivationExpression_ExpressionDecimal& decimal() const; - ::io::substrait::DerivationExpression_ExpressionDecimal* release_decimal(); - ::io::substrait::DerivationExpression_ExpressionDecimal* mutable_decimal(); - void set_allocated_decimal(::io::substrait::DerivationExpression_ExpressionDecimal* decimal); + const ::substrait::DerivationExpression_ExpressionDecimal& decimal() const; + ::substrait::DerivationExpression_ExpressionDecimal* release_decimal(); + ::substrait::DerivationExpression_ExpressionDecimal* mutable_decimal(); + void set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal); private: - const ::io::substrait::DerivationExpression_ExpressionDecimal& _internal_decimal() const; - ::io::substrait::DerivationExpression_ExpressionDecimal* _internal_mutable_decimal(); + const ::substrait::DerivationExpression_ExpressionDecimal& _internal_decimal() const; + ::substrait::DerivationExpression_ExpressionDecimal* _internal_mutable_decimal(); public: void unsafe_arena_set_allocated_decimal( - ::io::substrait::DerivationExpression_ExpressionDecimal* decimal); - ::io::substrait::DerivationExpression_ExpressionDecimal* unsafe_arena_release_decimal(); + ::substrait::DerivationExpression_ExpressionDecimal* decimal); + ::substrait::DerivationExpression_ExpressionDecimal* unsafe_arena_release_decimal(); - // .io.substrait.DerivationExpression.ExpressionStruct struct = 25; + // .substrait.DerivationExpression.ExpressionStruct struct = 25; bool has_struct_() const; private: bool _internal_has_struct_() const; public: void clear_struct_(); - const ::io::substrait::DerivationExpression_ExpressionStruct& struct_() const; - ::io::substrait::DerivationExpression_ExpressionStruct* release_struct_(); - ::io::substrait::DerivationExpression_ExpressionStruct* mutable_struct_(); - void set_allocated_struct_(::io::substrait::DerivationExpression_ExpressionStruct* struct_); + const ::substrait::DerivationExpression_ExpressionStruct& struct_() const; + ::substrait::DerivationExpression_ExpressionStruct* release_struct_(); + ::substrait::DerivationExpression_ExpressionStruct* mutable_struct_(); + void set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_); private: - const ::io::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const; - ::io::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_(); + const ::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const; + ::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_(); public: void unsafe_arena_set_allocated_struct_( - ::io::substrait::DerivationExpression_ExpressionStruct* struct_); - ::io::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_(); + ::substrait::DerivationExpression_ExpressionStruct* struct_); + ::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_(); - // .io.substrait.DerivationExpression.ExpressionList list = 27; + // .substrait.DerivationExpression.ExpressionList list = 27; bool has_list() const; private: bool _internal_has_list() const; public: void clear_list(); - const ::io::substrait::DerivationExpression_ExpressionList& list() const; - ::io::substrait::DerivationExpression_ExpressionList* release_list(); - ::io::substrait::DerivationExpression_ExpressionList* mutable_list(); - void set_allocated_list(::io::substrait::DerivationExpression_ExpressionList* list); + const ::substrait::DerivationExpression_ExpressionList& list() const; + ::substrait::DerivationExpression_ExpressionList* release_list(); + ::substrait::DerivationExpression_ExpressionList* mutable_list(); + void set_allocated_list(::substrait::DerivationExpression_ExpressionList* list); private: - const ::io::substrait::DerivationExpression_ExpressionList& _internal_list() const; - ::io::substrait::DerivationExpression_ExpressionList* _internal_mutable_list(); + const ::substrait::DerivationExpression_ExpressionList& _internal_list() const; + ::substrait::DerivationExpression_ExpressionList* _internal_mutable_list(); public: void unsafe_arena_set_allocated_list( - ::io::substrait::DerivationExpression_ExpressionList* list); - ::io::substrait::DerivationExpression_ExpressionList* unsafe_arena_release_list(); + ::substrait::DerivationExpression_ExpressionList* list); + ::substrait::DerivationExpression_ExpressionList* unsafe_arena_release_list(); - // .io.substrait.DerivationExpression.ExpressionMap map = 28; + // .substrait.DerivationExpression.ExpressionMap map = 28; bool has_map() const; private: bool _internal_has_map() const; public: void clear_map(); - const ::io::substrait::DerivationExpression_ExpressionMap& map() const; - ::io::substrait::DerivationExpression_ExpressionMap* release_map(); - ::io::substrait::DerivationExpression_ExpressionMap* mutable_map(); - void set_allocated_map(::io::substrait::DerivationExpression_ExpressionMap* map); + const ::substrait::DerivationExpression_ExpressionMap& map() const; + ::substrait::DerivationExpression_ExpressionMap* release_map(); + ::substrait::DerivationExpression_ExpressionMap* mutable_map(); + void set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map); private: - const ::io::substrait::DerivationExpression_ExpressionMap& _internal_map() const; - ::io::substrait::DerivationExpression_ExpressionMap* _internal_mutable_map(); + const ::substrait::DerivationExpression_ExpressionMap& _internal_map() const; + ::substrait::DerivationExpression_ExpressionMap* _internal_mutable_map(); public: void unsafe_arena_set_allocated_map( - ::io::substrait::DerivationExpression_ExpressionMap* map); - ::io::substrait::DerivationExpression_ExpressionMap* unsafe_arena_release_map(); + ::substrait::DerivationExpression_ExpressionMap* map); + ::substrait::DerivationExpression_ExpressionMap* unsafe_arena_release_map(); // uint32 user_defined_pointer = 31; bool has_user_defined_pointer() const; @@ -3088,81 +3085,81 @@ class DerivationExpression PROTOBUF_FINAL : void _internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::int32 value); public: - // .io.substrait.DerivationExpression.UnaryOp unary_op = 36; + // .substrait.DerivationExpression.UnaryOp unary_op = 36; bool has_unary_op() const; private: bool _internal_has_unary_op() const; public: void clear_unary_op(); - const ::io::substrait::DerivationExpression_UnaryOp& unary_op() const; - ::io::substrait::DerivationExpression_UnaryOp* release_unary_op(); - ::io::substrait::DerivationExpression_UnaryOp* mutable_unary_op(); - void set_allocated_unary_op(::io::substrait::DerivationExpression_UnaryOp* unary_op); + const ::substrait::DerivationExpression_UnaryOp& unary_op() const; + ::substrait::DerivationExpression_UnaryOp* release_unary_op(); + ::substrait::DerivationExpression_UnaryOp* mutable_unary_op(); + void set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op); private: - const ::io::substrait::DerivationExpression_UnaryOp& _internal_unary_op() const; - ::io::substrait::DerivationExpression_UnaryOp* _internal_mutable_unary_op(); + const ::substrait::DerivationExpression_UnaryOp& _internal_unary_op() const; + ::substrait::DerivationExpression_UnaryOp* _internal_mutable_unary_op(); public: void unsafe_arena_set_allocated_unary_op( - ::io::substrait::DerivationExpression_UnaryOp* unary_op); - ::io::substrait::DerivationExpression_UnaryOp* unsafe_arena_release_unary_op(); + ::substrait::DerivationExpression_UnaryOp* unary_op); + ::substrait::DerivationExpression_UnaryOp* unsafe_arena_release_unary_op(); - // .io.substrait.DerivationExpression.BinaryOp binary_op = 37; + // .substrait.DerivationExpression.BinaryOp binary_op = 37; bool has_binary_op() const; private: bool _internal_has_binary_op() const; public: void clear_binary_op(); - const ::io::substrait::DerivationExpression_BinaryOp& binary_op() const; - ::io::substrait::DerivationExpression_BinaryOp* release_binary_op(); - ::io::substrait::DerivationExpression_BinaryOp* mutable_binary_op(); - void set_allocated_binary_op(::io::substrait::DerivationExpression_BinaryOp* binary_op); + const ::substrait::DerivationExpression_BinaryOp& binary_op() const; + ::substrait::DerivationExpression_BinaryOp* release_binary_op(); + ::substrait::DerivationExpression_BinaryOp* mutable_binary_op(); + void set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op); private: - const ::io::substrait::DerivationExpression_BinaryOp& _internal_binary_op() const; - ::io::substrait::DerivationExpression_BinaryOp* _internal_mutable_binary_op(); + const ::substrait::DerivationExpression_BinaryOp& _internal_binary_op() const; + ::substrait::DerivationExpression_BinaryOp* _internal_mutable_binary_op(); public: void unsafe_arena_set_allocated_binary_op( - ::io::substrait::DerivationExpression_BinaryOp* binary_op); - ::io::substrait::DerivationExpression_BinaryOp* unsafe_arena_release_binary_op(); + ::substrait::DerivationExpression_BinaryOp* binary_op); + ::substrait::DerivationExpression_BinaryOp* unsafe_arena_release_binary_op(); - // .io.substrait.DerivationExpression.IfElse if_else = 38; + // .substrait.DerivationExpression.IfElse if_else = 38; bool has_if_else() const; private: bool _internal_has_if_else() const; public: void clear_if_else(); - const ::io::substrait::DerivationExpression_IfElse& if_else() const; - ::io::substrait::DerivationExpression_IfElse* release_if_else(); - ::io::substrait::DerivationExpression_IfElse* mutable_if_else(); - void set_allocated_if_else(::io::substrait::DerivationExpression_IfElse* if_else); + const ::substrait::DerivationExpression_IfElse& if_else() const; + ::substrait::DerivationExpression_IfElse* release_if_else(); + ::substrait::DerivationExpression_IfElse* mutable_if_else(); + void set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else); private: - const ::io::substrait::DerivationExpression_IfElse& _internal_if_else() const; - ::io::substrait::DerivationExpression_IfElse* _internal_mutable_if_else(); + const ::substrait::DerivationExpression_IfElse& _internal_if_else() const; + ::substrait::DerivationExpression_IfElse* _internal_mutable_if_else(); public: void unsafe_arena_set_allocated_if_else( - ::io::substrait::DerivationExpression_IfElse* if_else); - ::io::substrait::DerivationExpression_IfElse* unsafe_arena_release_if_else(); + ::substrait::DerivationExpression_IfElse* if_else); + ::substrait::DerivationExpression_IfElse* unsafe_arena_release_if_else(); - // .io.substrait.DerivationExpression.ReturnProgram return_program = 39; + // .substrait.DerivationExpression.ReturnProgram return_program = 39; bool has_return_program() const; private: bool _internal_has_return_program() const; public: void clear_return_program(); - const ::io::substrait::DerivationExpression_ReturnProgram& return_program() const; - ::io::substrait::DerivationExpression_ReturnProgram* release_return_program(); - ::io::substrait::DerivationExpression_ReturnProgram* mutable_return_program(); - void set_allocated_return_program(::io::substrait::DerivationExpression_ReturnProgram* return_program); + const ::substrait::DerivationExpression_ReturnProgram& return_program() const; + ::substrait::DerivationExpression_ReturnProgram* release_return_program(); + ::substrait::DerivationExpression_ReturnProgram* mutable_return_program(); + void set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program); private: - const ::io::substrait::DerivationExpression_ReturnProgram& _internal_return_program() const; - ::io::substrait::DerivationExpression_ReturnProgram* _internal_mutable_return_program(); + const ::substrait::DerivationExpression_ReturnProgram& _internal_return_program() const; + ::substrait::DerivationExpression_ReturnProgram* _internal_mutable_return_program(); public: void unsafe_arena_set_allocated_return_program( - ::io::substrait::DerivationExpression_ReturnProgram* return_program); - ::io::substrait::DerivationExpression_ReturnProgram* unsafe_arena_release_return_program(); + ::substrait::DerivationExpression_ReturnProgram* return_program); + ::substrait::DerivationExpression_ReturnProgram* unsafe_arena_release_return_program(); void clear_kind(); KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.DerivationExpression) + // @@protoc_insertion_point(class_scope:substrait.DerivationExpression) private: class _Internal; void set_has_bool_(); @@ -3206,42 +3203,42 @@ class DerivationExpression PROTOBUF_FINAL : union KindUnion { constexpr KindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::Type_Boolean* bool__; - ::io::substrait::Type_I8* i8_; - ::io::substrait::Type_I16* i16_; - ::io::substrait::Type_I32* i32_; - ::io::substrait::Type_I64* i64_; - ::io::substrait::Type_FP32* fp32_; - ::io::substrait::Type_FP64* fp64_; - ::io::substrait::Type_String* string_; - ::io::substrait::Type_Binary* binary_; - ::io::substrait::Type_Timestamp* timestamp_; - ::io::substrait::Type_Date* date_; - ::io::substrait::Type_Time* time_; - ::io::substrait::Type_IntervalYear* interval_year_; - ::io::substrait::Type_IntervalDay* interval_day_; - ::io::substrait::Type_TimestampTZ* timestamp_tz_; - ::io::substrait::Type_UUID* uuid_; - ::io::substrait::DerivationExpression_ExpressionFixedChar* fixed_char_; - ::io::substrait::DerivationExpression_ExpressionVarChar* varchar_; - ::io::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary_; - ::io::substrait::DerivationExpression_ExpressionDecimal* decimal_; - ::io::substrait::DerivationExpression_ExpressionStruct* struct__; - ::io::substrait::DerivationExpression_ExpressionList* list_; - ::io::substrait::DerivationExpression_ExpressionMap* map_; + ::substrait::Type_Boolean* bool__; + ::substrait::Type_I8* i8_; + ::substrait::Type_I16* i16_; + ::substrait::Type_I32* i32_; + ::substrait::Type_I64* i64_; + ::substrait::Type_FP32* fp32_; + ::substrait::Type_FP64* fp64_; + ::substrait::Type_String* string_; + ::substrait::Type_Binary* binary_; + ::substrait::Type_Timestamp* timestamp_; + ::substrait::Type_Date* date_; + ::substrait::Type_Time* time_; + ::substrait::Type_IntervalYear* interval_year_; + ::substrait::Type_IntervalDay* interval_day_; + ::substrait::Type_TimestampTZ* timestamp_tz_; + ::substrait::Type_UUID* uuid_; + ::substrait::DerivationExpression_ExpressionFixedChar* fixed_char_; + ::substrait::DerivationExpression_ExpressionVarChar* varchar_; + ::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary_; + ::substrait::DerivationExpression_ExpressionDecimal* decimal_; + ::substrait::DerivationExpression_ExpressionStruct* struct__; + ::substrait::DerivationExpression_ExpressionList* list_; + ::substrait::DerivationExpression_ExpressionMap* map_; ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_pointer_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_parameter_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr integer_parameter_name_; ::PROTOBUF_NAMESPACE_ID::int32 integer_literal_; - ::io::substrait::DerivationExpression_UnaryOp* unary_op_; - ::io::substrait::DerivationExpression_BinaryOp* binary_op_; - ::io::substrait::DerivationExpression_IfElse* if_else_; - ::io::substrait::DerivationExpression_ReturnProgram* return_program_; + ::substrait::DerivationExpression_UnaryOp* unary_op_; + ::substrait::DerivationExpression_BinaryOp* binary_op_; + ::substrait::DerivationExpression_IfElse* if_else_; + ::substrait::DerivationExpression_ReturnProgram* return_program_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - friend struct ::TableStruct_type_5fexpressions_2eproto; + friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // =================================================================== @@ -3254,7 +3251,7 @@ class DerivationExpression PROTOBUF_FINAL : #endif // __GNUC__ // DerivationExpression_ExpressionFixedChar -// .io.substrait.DerivationExpression length = 1; +// .substrait.DerivationExpression length = 1; inline bool DerivationExpression_ExpressionFixedChar::_internal_has_length() const { return this != internal_default_instance() && length_ != nullptr; } @@ -3267,17 +3264,17 @@ inline void DerivationExpression_ExpressionFixedChar::clear_length() { } length_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::_internal_length() const { - const ::io::substrait::DerivationExpression* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::_internal_length() const { + const ::substrait::DerivationExpression* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::length() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedChar.length) +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::length() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.length) return _internal_length(); } inline void DerivationExpression_ExpressionFixedChar::unsafe_arena_set_allocated_length( - ::io::substrait::DerivationExpression* length) { + ::substrait::DerivationExpression* length) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } @@ -3287,37 +3284,37 @@ inline void DerivationExpression_ExpressionFixedChar::unsafe_arena_set_allocated } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionFixedChar.length) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionFixedChar.length) } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::release_length() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::release_length() { - ::io::substrait::DerivationExpression* temp = length_; + ::substrait::DerivationExpression* temp = length_; length_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionFixedChar.length) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionFixedChar.length) - ::io::substrait::DerivationExpression* temp = length_; + ::substrait::DerivationExpression* temp = length_; length_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::_internal_mutable_length() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); length_ = p; } return length_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::mutable_length() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionFixedChar.length) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::mutable_length() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionFixedChar.length) return _internal_mutable_length(); } -inline void DerivationExpression_ExpressionFixedChar::set_allocated_length(::io::substrait::DerivationExpression* length) { +inline void DerivationExpression_ExpressionFixedChar::set_allocated_length(::substrait::DerivationExpression* length) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete length_; @@ -3334,7 +3331,7 @@ inline void DerivationExpression_ExpressionFixedChar::set_allocated_length(::io: } length_ = length; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionFixedChar.length) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionFixedChar.length) } // uint32 variation_pointer = 2; @@ -3345,7 +3342,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedChar: return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedChar::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedChar.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.variation_pointer) return _internal_variation_pointer(); } inline void DerivationExpression_ExpressionFixedChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -3354,34 +3351,34 @@ inline void DerivationExpression_ExpressionFixedChar::_internal_set_variation_po } inline void DerivationExpression_ExpressionFixedChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionFixedChar.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedChar.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void DerivationExpression_ExpressionFixedChar::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedChar.nullability) +inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::nullability() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.nullability) return _internal_nullability(); } -inline void DerivationExpression_ExpressionFixedChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionFixedChar::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void DerivationExpression_ExpressionFixedChar::set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionFixedChar::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionFixedChar.nullability) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedChar.nullability) } // ------------------------------------------------------------------- // DerivationExpression_ExpressionVarChar -// .io.substrait.DerivationExpression length = 1; +// .substrait.DerivationExpression length = 1; inline bool DerivationExpression_ExpressionVarChar::_internal_has_length() const { return this != internal_default_instance() && length_ != nullptr; } @@ -3394,17 +3391,17 @@ inline void DerivationExpression_ExpressionVarChar::clear_length() { } length_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::_internal_length() const { - const ::io::substrait::DerivationExpression* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::_internal_length() const { + const ::substrait::DerivationExpression* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::length() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionVarChar.length) +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::length() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.length) return _internal_length(); } inline void DerivationExpression_ExpressionVarChar::unsafe_arena_set_allocated_length( - ::io::substrait::DerivationExpression* length) { + ::substrait::DerivationExpression* length) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } @@ -3414,37 +3411,37 @@ inline void DerivationExpression_ExpressionVarChar::unsafe_arena_set_allocated_l } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionVarChar.length) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionVarChar.length) } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::release_length() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::release_length() { - ::io::substrait::DerivationExpression* temp = length_; + ::substrait::DerivationExpression* temp = length_; length_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionVarChar.length) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionVarChar.length) - ::io::substrait::DerivationExpression* temp = length_; + ::substrait::DerivationExpression* temp = length_; length_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::_internal_mutable_length() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); length_ = p; } return length_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::mutable_length() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionVarChar.length) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::mutable_length() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionVarChar.length) return _internal_mutable_length(); } -inline void DerivationExpression_ExpressionVarChar::set_allocated_length(::io::substrait::DerivationExpression* length) { +inline void DerivationExpression_ExpressionVarChar::set_allocated_length(::substrait::DerivationExpression* length) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete length_; @@ -3461,7 +3458,7 @@ inline void DerivationExpression_ExpressionVarChar::set_allocated_length(::io::s } length_ = length; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionVarChar.length) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionVarChar.length) } // uint32 variation_pointer = 2; @@ -3472,7 +3469,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionVarChar::_ return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionVarChar::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionVarChar.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.variation_pointer) return _internal_variation_pointer(); } inline void DerivationExpression_ExpressionVarChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -3481,34 +3478,34 @@ inline void DerivationExpression_ExpressionVarChar::_internal_set_variation_poin } inline void DerivationExpression_ExpressionVarChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionVarChar.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionVarChar.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void DerivationExpression_ExpressionVarChar::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionVarChar.nullability) +inline ::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::nullability() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.nullability) return _internal_nullability(); } -inline void DerivationExpression_ExpressionVarChar::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionVarChar::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void DerivationExpression_ExpressionVarChar::set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionVarChar::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionVarChar.nullability) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionVarChar.nullability) } // ------------------------------------------------------------------- // DerivationExpression_ExpressionFixedBinary -// .io.substrait.DerivationExpression length = 1; +// .substrait.DerivationExpression length = 1; inline bool DerivationExpression_ExpressionFixedBinary::_internal_has_length() const { return this != internal_default_instance() && length_ != nullptr; } @@ -3521,17 +3518,17 @@ inline void DerivationExpression_ExpressionFixedBinary::clear_length() { } length_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::_internal_length() const { - const ::io::substrait::DerivationExpression* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::_internal_length() const { + const ::substrait::DerivationExpression* p = length_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::length() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedBinary.length) +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::length() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.length) return _internal_length(); } inline void DerivationExpression_ExpressionFixedBinary::unsafe_arena_set_allocated_length( - ::io::substrait::DerivationExpression* length) { + ::substrait::DerivationExpression* length) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } @@ -3541,37 +3538,37 @@ inline void DerivationExpression_ExpressionFixedBinary::unsafe_arena_set_allocat } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionFixedBinary.length) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionFixedBinary.length) } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::release_length() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::release_length() { - ::io::substrait::DerivationExpression* temp = length_; + ::substrait::DerivationExpression* temp = length_; length_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionFixedBinary.length) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::unsafe_arena_release_length() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionFixedBinary.length) - ::io::substrait::DerivationExpression* temp = length_; + ::substrait::DerivationExpression* temp = length_; length_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::_internal_mutable_length() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); length_ = p; } return length_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::mutable_length() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionFixedBinary.length) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::mutable_length() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionFixedBinary.length) return _internal_mutable_length(); } -inline void DerivationExpression_ExpressionFixedBinary::set_allocated_length(::io::substrait::DerivationExpression* length) { +inline void DerivationExpression_ExpressionFixedBinary::set_allocated_length(::substrait::DerivationExpression* length) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete length_; @@ -3588,7 +3585,7 @@ inline void DerivationExpression_ExpressionFixedBinary::set_allocated_length(::i } length_ = length; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionFixedBinary.length) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionFixedBinary.length) } // uint32 variation_pointer = 2; @@ -3599,7 +3596,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedBinar return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedBinary::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer) return _internal_variation_pointer(); } inline void DerivationExpression_ExpressionFixedBinary::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -3608,34 +3605,34 @@ inline void DerivationExpression_ExpressionFixedBinary::_internal_set_variation_ } inline void DerivationExpression_ExpressionFixedBinary::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void DerivationExpression_ExpressionFixedBinary::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionFixedBinary.nullability) +inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::nullability() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.nullability) return _internal_nullability(); } -inline void DerivationExpression_ExpressionFixedBinary::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionFixedBinary::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void DerivationExpression_ExpressionFixedBinary::set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionFixedBinary::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionFixedBinary.nullability) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedBinary.nullability) } // ------------------------------------------------------------------- // DerivationExpression_ExpressionDecimal -// .io.substrait.DerivationExpression scale = 1; +// .substrait.DerivationExpression scale = 1; inline bool DerivationExpression_ExpressionDecimal::_internal_has_scale() const { return this != internal_default_instance() && scale_ != nullptr; } @@ -3648,17 +3645,17 @@ inline void DerivationExpression_ExpressionDecimal::clear_scale() { } scale_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_scale() const { - const ::io::substrait::DerivationExpression* p = scale_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_scale() const { + const ::substrait::DerivationExpression* p = scale_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::scale() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionDecimal.scale) +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::scale() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.scale) return _internal_scale(); } inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_scale( - ::io::substrait::DerivationExpression* scale) { + ::substrait::DerivationExpression* scale) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_); } @@ -3668,37 +3665,37 @@ inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_s } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.scale) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionDecimal.scale) } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_scale() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_scale() { - ::io::substrait::DerivationExpression* temp = scale_; + ::substrait::DerivationExpression* temp = scale_; scale_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_scale() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionDecimal.scale) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_scale() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionDecimal.scale) - ::io::substrait::DerivationExpression* temp = scale_; + ::substrait::DerivationExpression* temp = scale_; scale_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_scale() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_scale() { if (scale_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); scale_ = p; } return scale_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_scale() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionDecimal.scale) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_scale() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionDecimal.scale) return _internal_mutable_scale(); } -inline void DerivationExpression_ExpressionDecimal::set_allocated_scale(::io::substrait::DerivationExpression* scale) { +inline void DerivationExpression_ExpressionDecimal::set_allocated_scale(::substrait::DerivationExpression* scale) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete scale_; @@ -3715,10 +3712,10 @@ inline void DerivationExpression_ExpressionDecimal::set_allocated_scale(::io::su } scale_ = scale; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.scale) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionDecimal.scale) } -// .io.substrait.DerivationExpression precision = 2; +// .substrait.DerivationExpression precision = 2; inline bool DerivationExpression_ExpressionDecimal::_internal_has_precision() const { return this != internal_default_instance() && precision_ != nullptr; } @@ -3731,17 +3728,17 @@ inline void DerivationExpression_ExpressionDecimal::clear_precision() { } precision_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_precision() const { - const ::io::substrait::DerivationExpression* p = precision_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_precision() const { + const ::substrait::DerivationExpression* p = precision_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::precision() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionDecimal.precision) +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::precision() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.precision) return _internal_precision(); } inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_precision( - ::io::substrait::DerivationExpression* precision) { + ::substrait::DerivationExpression* precision) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_); } @@ -3751,37 +3748,37 @@ inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_p } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.precision) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionDecimal.precision) } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_precision() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_precision() { - ::io::substrait::DerivationExpression* temp = precision_; + ::substrait::DerivationExpression* temp = precision_; precision_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_precision() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionDecimal.precision) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_precision() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionDecimal.precision) - ::io::substrait::DerivationExpression* temp = precision_; + ::substrait::DerivationExpression* temp = precision_; precision_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_precision() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_precision() { if (precision_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); precision_ = p; } return precision_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_precision() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionDecimal.precision) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_precision() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionDecimal.precision) return _internal_mutable_precision(); } -inline void DerivationExpression_ExpressionDecimal::set_allocated_precision(::io::substrait::DerivationExpression* precision) { +inline void DerivationExpression_ExpressionDecimal::set_allocated_precision(::substrait::DerivationExpression* precision) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete precision_; @@ -3798,7 +3795,7 @@ inline void DerivationExpression_ExpressionDecimal::set_allocated_precision(::io } precision_ = precision; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionDecimal.precision) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionDecimal.precision) } // uint32 variation_pointer = 3; @@ -3809,7 +3806,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionDecimal::_ return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionDecimal::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionDecimal.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.variation_pointer) return _internal_variation_pointer(); } inline void DerivationExpression_ExpressionDecimal::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -3818,34 +3815,34 @@ inline void DerivationExpression_ExpressionDecimal::_internal_set_variation_poin } inline void DerivationExpression_ExpressionDecimal::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionDecimal.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionDecimal.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 4; +// .substrait.Type.Nullability nullability = 4; inline void DerivationExpression_ExpressionDecimal::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionDecimal.nullability) +inline ::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::nullability() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.nullability) return _internal_nullability(); } -inline void DerivationExpression_ExpressionDecimal::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionDecimal::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void DerivationExpression_ExpressionDecimal::set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionDecimal::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionDecimal.nullability) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionDecimal.nullability) } // ------------------------------------------------------------------- // DerivationExpression_ExpressionStruct -// repeated .io.substrait.DerivationExpression types = 1; +// repeated .substrait.DerivationExpression types = 1; inline int DerivationExpression_ExpressionStruct::_internal_types_size() const { return types_.size(); } @@ -3855,32 +3852,32 @@ inline int DerivationExpression_ExpressionStruct::types_size() const { inline void DerivationExpression_ExpressionStruct::clear_types() { types_.Clear(); } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::mutable_types(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionStruct.types) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::mutable_types(int index) { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionStruct.types) return types_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >* DerivationExpression_ExpressionStruct::mutable_types() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.DerivationExpression.ExpressionStruct.types) + // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ExpressionStruct.types) return &types_; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::_internal_types(int index) const { +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::_internal_types(int index) const { return types_.Get(index); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::types(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionStruct.types) +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::types(int index) const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.types) return _internal_types(index); } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::_internal_add_types() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::_internal_add_types() { return types_.Add(); } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::add_types() { - // @@protoc_insertion_point(field_add:io.substrait.DerivationExpression.ExpressionStruct.types) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::add_types() { + // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionStruct.types) return _internal_add_types(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >& DerivationExpression_ExpressionStruct::types() const { - // @@protoc_insertion_point(field_list:io.substrait.DerivationExpression.ExpressionStruct.types) + // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ExpressionStruct.types) return types_; } @@ -3892,7 +3889,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionStruct::_i return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionStruct::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionStruct.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.variation_pointer) return _internal_variation_pointer(); } inline void DerivationExpression_ExpressionStruct::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -3901,27 +3898,27 @@ inline void DerivationExpression_ExpressionStruct::_internal_set_variation_point } inline void DerivationExpression_ExpressionStruct::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionStruct.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionStruct.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void DerivationExpression_ExpressionStruct::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionStruct::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability DerivationExpression_ExpressionStruct::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionStruct::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionStruct.nullability) +inline ::substrait::Type_Nullability DerivationExpression_ExpressionStruct::nullability() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.nullability) return _internal_nullability(); } -inline void DerivationExpression_ExpressionStruct::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionStruct::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void DerivationExpression_ExpressionStruct::set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionStruct::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionStruct.nullability) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionStruct.nullability) } // ------------------------------------------------------------------- @@ -3939,70 +3936,70 @@ inline void DerivationExpression_ExpressionNamedStruct::clear_names() { names_.Clear(); } inline std::string* DerivationExpression_ExpressionNamedStruct::add_names() { - // @@protoc_insertion_point(field_add_mutable:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_add_mutable:substrait.DerivationExpression.ExpressionNamedStruct.names) return _internal_add_names(); } inline const std::string& DerivationExpression_ExpressionNamedStruct::_internal_names(int index) const { return names_.Get(index); } inline const std::string& DerivationExpression_ExpressionNamedStruct::names(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionNamedStruct.names) return _internal_names(index); } inline std::string* DerivationExpression_ExpressionNamedStruct::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionNamedStruct.names) return names_.Mutable(index); } inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names) names_.Mutable(index)->assign(value); } inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names) names_.Mutable(index)->assign(std::move(value)); } inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_set_char:substrait.DerivationExpression.ExpressionNamedStruct.names) } inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value, size_t size) { names_.Mutable(index)->assign( reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_set_pointer:substrait.DerivationExpression.ExpressionNamedStruct.names) } inline std::string* DerivationExpression_ExpressionNamedStruct::_internal_add_names() { return names_.Add(); } inline void DerivationExpression_ExpressionNamedStruct::add_names(const std::string& value) { names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionNamedStruct.names) } inline void DerivationExpression_ExpressionNamedStruct::add_names(std::string&& value) { names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionNamedStruct.names) } inline void DerivationExpression_ExpressionNamedStruct::add_names(const char* value) { GOOGLE_DCHECK(value != nullptr); names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_add_char:substrait.DerivationExpression.ExpressionNamedStruct.names) } inline void DerivationExpression_ExpressionNamedStruct::add_names(const char* value, size_t size) { names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_add_pointer:substrait.DerivationExpression.ExpressionNamedStruct.names) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& DerivationExpression_ExpressionNamedStruct::names() const { - // @@protoc_insertion_point(field_list:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ExpressionNamedStruct.names) return names_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* DerivationExpression_ExpressionNamedStruct::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.DerivationExpression.ExpressionNamedStruct.names) + // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ExpressionNamedStruct.names) return &names_; } -// .io.substrait.DerivationExpression.ExpressionStruct struct = 2; +// .substrait.DerivationExpression.ExpressionStruct struct = 2; inline bool DerivationExpression_ExpressionNamedStruct::_internal_has_struct_() const { return this != internal_default_instance() && struct__ != nullptr; } @@ -4015,17 +4012,17 @@ inline void DerivationExpression_ExpressionNamedStruct::clear_struct_() { } struct__ = nullptr; } -inline const ::io::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::_internal_struct_() const { - const ::io::substrait::DerivationExpression_ExpressionStruct* p = struct__; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_ExpressionStruct_default_instance_); +inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::_internal_struct_() const { + const ::substrait::DerivationExpression_ExpressionStruct* p = struct__; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_ExpressionStruct_default_instance_); } -inline const ::io::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionNamedStruct.struct) +inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::struct_() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionNamedStruct.struct) return _internal_struct_(); } inline void DerivationExpression_ExpressionNamedStruct::unsafe_arena_set_allocated_struct_( - ::io::substrait::DerivationExpression_ExpressionStruct* struct_) { + ::substrait::DerivationExpression_ExpressionStruct* struct_) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); } @@ -4035,37 +4032,37 @@ inline void DerivationExpression_ExpressionNamedStruct::unsafe_arena_set_allocat } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionNamedStruct.struct) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionNamedStruct.struct) } -inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::release_struct_() { +inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::release_struct_() { - ::io::substrait::DerivationExpression_ExpressionStruct* temp = struct__; + ::substrait::DerivationExpression_ExpressionStruct* temp = struct__; struct__ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionNamedStruct.struct) +inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionNamedStruct.struct) - ::io::substrait::DerivationExpression_ExpressionStruct* temp = struct__; + ::substrait::DerivationExpression_ExpressionStruct* temp = struct__; struct__ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::_internal_mutable_struct_() { +inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::_internal_mutable_struct_() { if (struct__ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression_ExpressionStruct>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression_ExpressionStruct>(GetArena()); struct__ = p; } return struct__; } -inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionNamedStruct.struct) +inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionNamedStruct.struct) return _internal_mutable_struct_(); } -inline void DerivationExpression_ExpressionNamedStruct::set_allocated_struct_(::io::substrait::DerivationExpression_ExpressionStruct* struct_) { +inline void DerivationExpression_ExpressionNamedStruct::set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete struct__; @@ -4082,14 +4079,14 @@ inline void DerivationExpression_ExpressionNamedStruct::set_allocated_struct_(:: } struct__ = struct_; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionNamedStruct.struct) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionNamedStruct.struct) } // ------------------------------------------------------------------- // DerivationExpression_ExpressionList -// .io.substrait.DerivationExpression type = 1; +// .substrait.DerivationExpression type = 1; inline bool DerivationExpression_ExpressionList::_internal_has_type() const { return this != internal_default_instance() && type_ != nullptr; } @@ -4102,17 +4099,17 @@ inline void DerivationExpression_ExpressionList::clear_type() { } type_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionList::_internal_type() const { - const ::io::substrait::DerivationExpression* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionList::_internal_type() const { + const ::substrait::DerivationExpression* p = type_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionList::type() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionList.type) +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionList::type() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.type) return _internal_type(); } inline void DerivationExpression_ExpressionList::unsafe_arena_set_allocated_type( - ::io::substrait::DerivationExpression* type) { + ::substrait::DerivationExpression* type) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } @@ -4122,37 +4119,37 @@ inline void DerivationExpression_ExpressionList::unsafe_arena_set_allocated_type } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionList.type) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionList.type) } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionList::release_type() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::release_type() { - ::io::substrait::DerivationExpression* temp = type_; + ::substrait::DerivationExpression* temp = type_; type_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionList::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionList.type) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::unsafe_arena_release_type() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionList.type) - ::io::substrait::DerivationExpression* temp = type_; + ::substrait::DerivationExpression* temp = type_; type_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionList::_internal_mutable_type() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); type_ = p; } return type_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionList::mutable_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionList.type) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::mutable_type() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionList.type) return _internal_mutable_type(); } -inline void DerivationExpression_ExpressionList::set_allocated_type(::io::substrait::DerivationExpression* type) { +inline void DerivationExpression_ExpressionList::set_allocated_type(::substrait::DerivationExpression* type) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete type_; @@ -4169,7 +4166,7 @@ inline void DerivationExpression_ExpressionList::set_allocated_type(::io::substr } type_ = type; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionList.type) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionList.type) } // uint32 variation_pointer = 2; @@ -4180,7 +4177,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionList::_int return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionList::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionList.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.variation_pointer) return _internal_variation_pointer(); } inline void DerivationExpression_ExpressionList::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4189,34 +4186,34 @@ inline void DerivationExpression_ExpressionList::_internal_set_variation_pointer } inline void DerivationExpression_ExpressionList::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionList.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionList.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 3; +// .substrait.Type.Nullability nullability = 3; inline void DerivationExpression_ExpressionList::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionList::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability DerivationExpression_ExpressionList::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionList::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionList.nullability) +inline ::substrait::Type_Nullability DerivationExpression_ExpressionList::nullability() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.nullability) return _internal_nullability(); } -inline void DerivationExpression_ExpressionList::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionList::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void DerivationExpression_ExpressionList::set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionList::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionList.nullability) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionList.nullability) } // ------------------------------------------------------------------- // DerivationExpression_ExpressionMap -// .io.substrait.DerivationExpression key = 1; +// .substrait.DerivationExpression key = 1; inline bool DerivationExpression_ExpressionMap::_internal_has_key() const { return this != internal_default_instance() && key_ != nullptr; } @@ -4229,17 +4226,17 @@ inline void DerivationExpression_ExpressionMap::clear_key() { } key_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_key() const { - const ::io::substrait::DerivationExpression* p = key_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_key() const { + const ::substrait::DerivationExpression* p = key_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionMap::key() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionMap.key) +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::key() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.key) return _internal_key(); } inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_key( - ::io::substrait::DerivationExpression* key) { + ::substrait::DerivationExpression* key) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); } @@ -4249,37 +4246,37 @@ inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_key( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionMap.key) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionMap.key) } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_key() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_key() { - ::io::substrait::DerivationExpression* temp = key_; + ::substrait::DerivationExpression* temp = key_; key_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionMap.key) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_key() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionMap.key) - ::io::substrait::DerivationExpression* temp = key_; + ::substrait::DerivationExpression* temp = key_; key_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_key() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_key() { if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); key_ = p; } return key_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_key() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionMap.key) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_key() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionMap.key) return _internal_mutable_key(); } -inline void DerivationExpression_ExpressionMap::set_allocated_key(::io::substrait::DerivationExpression* key) { +inline void DerivationExpression_ExpressionMap::set_allocated_key(::substrait::DerivationExpression* key) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete key_; @@ -4296,10 +4293,10 @@ inline void DerivationExpression_ExpressionMap::set_allocated_key(::io::substrai } key_ = key; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionMap.key) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionMap.key) } -// .io.substrait.DerivationExpression value = 2; +// .substrait.DerivationExpression value = 2; inline bool DerivationExpression_ExpressionMap::_internal_has_value() const { return this != internal_default_instance() && value_ != nullptr; } @@ -4312,17 +4309,17 @@ inline void DerivationExpression_ExpressionMap::clear_value() { } value_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_value() const { - const ::io::substrait::DerivationExpression* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_value() const { + const ::substrait::DerivationExpression* p = value_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ExpressionMap::value() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionMap.value) +inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::value() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.value) return _internal_value(); } inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_value( - ::io::substrait::DerivationExpression* value) { + ::substrait::DerivationExpression* value) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } @@ -4332,37 +4329,37 @@ inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_value } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ExpressionMap.value) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionMap.value) } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_value() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_value() { - ::io::substrait::DerivationExpression* temp = value_; + ::substrait::DerivationExpression* temp = value_; value_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ExpressionMap.value) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_value() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionMap.value) - ::io::substrait::DerivationExpression* temp = value_; + ::substrait::DerivationExpression* temp = value_; value_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_value() { +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_value() { if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); value_ = p; } return value_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_value() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ExpressionMap.value) +inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_value() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionMap.value) return _internal_mutable_value(); } -inline void DerivationExpression_ExpressionMap::set_allocated_value(::io::substrait::DerivationExpression* value) { +inline void DerivationExpression_ExpressionMap::set_allocated_value(::substrait::DerivationExpression* value) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete value_; @@ -4379,7 +4376,7 @@ inline void DerivationExpression_ExpressionMap::set_allocated_value(::io::substr } value_ = value; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ExpressionMap.value) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionMap.value) } // uint32 variation_pointer = 3; @@ -4390,7 +4387,7 @@ inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionMap::_inte return variation_pointer_; } inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionMap::variation_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionMap.variation_pointer) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.variation_pointer) return _internal_variation_pointer(); } inline void DerivationExpression_ExpressionMap::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { @@ -4399,34 +4396,34 @@ inline void DerivationExpression_ExpressionMap::_internal_set_variation_pointer( } inline void DerivationExpression_ExpressionMap::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionMap.variation_pointer) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionMap.variation_pointer) } -// .io.substrait.Type.Nullability nullability = 4; +// .substrait.Type.Nullability nullability = 4; inline void DerivationExpression_ExpressionMap::clear_nullability() { nullability_ = 0; } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionMap::_internal_nullability() const { - return static_cast< ::io::substrait::Type_Nullability >(nullability_); +inline ::substrait::Type_Nullability DerivationExpression_ExpressionMap::_internal_nullability() const { + return static_cast< ::substrait::Type_Nullability >(nullability_); } -inline ::io::substrait::Type_Nullability DerivationExpression_ExpressionMap::nullability() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ExpressionMap.nullability) +inline ::substrait::Type_Nullability DerivationExpression_ExpressionMap::nullability() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.nullability) return _internal_nullability(); } -inline void DerivationExpression_ExpressionMap::_internal_set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionMap::_internal_set_nullability(::substrait::Type_Nullability value) { nullability_ = value; } -inline void DerivationExpression_ExpressionMap::set_nullability(::io::substrait::Type_Nullability value) { +inline void DerivationExpression_ExpressionMap::set_nullability(::substrait::Type_Nullability value) { _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ExpressionMap.nullability) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionMap.nullability) } // ------------------------------------------------------------------- // DerivationExpression_IfElse -// .io.substrait.DerivationExpression if_condition = 1; +// .substrait.DerivationExpression if_condition = 1; inline bool DerivationExpression_IfElse::_internal_has_if_condition() const { return this != internal_default_instance() && if_condition_ != nullptr; } @@ -4439,17 +4436,17 @@ inline void DerivationExpression_IfElse::clear_if_condition() { } if_condition_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_condition() const { - const ::io::substrait::DerivationExpression* p = if_condition_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_condition() const { + const ::substrait::DerivationExpression* p = if_condition_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::if_condition() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.IfElse.if_condition) +inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::if_condition() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.if_condition) return _internal_if_condition(); } inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_condition( - ::io::substrait::DerivationExpression* if_condition) { + ::substrait::DerivationExpression* if_condition) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_condition_); } @@ -4459,37 +4456,37 @@ inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_condition } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.IfElse.if_condition) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.if_condition) } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_condition() { +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_condition() { - ::io::substrait::DerivationExpression* temp = if_condition_; + ::substrait::DerivationExpression* temp = if_condition_; if_condition_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_condition() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.IfElse.if_condition) +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_condition() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.if_condition) - ::io::substrait::DerivationExpression* temp = if_condition_; + ::substrait::DerivationExpression* temp = if_condition_; if_condition_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_condition() { +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_condition() { if (if_condition_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); if_condition_ = p; } return if_condition_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_condition() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.IfElse.if_condition) +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_condition() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.if_condition) return _internal_mutable_if_condition(); } -inline void DerivationExpression_IfElse::set_allocated_if_condition(::io::substrait::DerivationExpression* if_condition) { +inline void DerivationExpression_IfElse::set_allocated_if_condition(::substrait::DerivationExpression* if_condition) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete if_condition_; @@ -4506,10 +4503,10 @@ inline void DerivationExpression_IfElse::set_allocated_if_condition(::io::substr } if_condition_ = if_condition; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.IfElse.if_condition) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.if_condition) } -// .io.substrait.DerivationExpression if_return = 2; +// .substrait.DerivationExpression if_return = 2; inline bool DerivationExpression_IfElse::_internal_has_if_return() const { return this != internal_default_instance() && if_return_ != nullptr; } @@ -4522,17 +4519,17 @@ inline void DerivationExpression_IfElse::clear_if_return() { } if_return_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_return() const { - const ::io::substrait::DerivationExpression* p = if_return_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_return() const { + const ::substrait::DerivationExpression* p = if_return_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::if_return() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.IfElse.if_return) +inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::if_return() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.if_return) return _internal_if_return(); } inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_return( - ::io::substrait::DerivationExpression* if_return) { + ::substrait::DerivationExpression* if_return) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_return_); } @@ -4542,37 +4539,37 @@ inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_return( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.IfElse.if_return) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.if_return) } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_return() { +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_return() { - ::io::substrait::DerivationExpression* temp = if_return_; + ::substrait::DerivationExpression* temp = if_return_; if_return_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_return() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.IfElse.if_return) +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_return() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.if_return) - ::io::substrait::DerivationExpression* temp = if_return_; + ::substrait::DerivationExpression* temp = if_return_; if_return_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_return() { +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_return() { if (if_return_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); if_return_ = p; } return if_return_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_return() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.IfElse.if_return) +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_return() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.if_return) return _internal_mutable_if_return(); } -inline void DerivationExpression_IfElse::set_allocated_if_return(::io::substrait::DerivationExpression* if_return) { +inline void DerivationExpression_IfElse::set_allocated_if_return(::substrait::DerivationExpression* if_return) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete if_return_; @@ -4589,10 +4586,10 @@ inline void DerivationExpression_IfElse::set_allocated_if_return(::io::substrait } if_return_ = if_return; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.IfElse.if_return) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.if_return) } -// .io.substrait.DerivationExpression else_return = 3; +// .substrait.DerivationExpression else_return = 3; inline bool DerivationExpression_IfElse::_internal_has_else_return() const { return this != internal_default_instance() && else_return_ != nullptr; } @@ -4605,17 +4602,17 @@ inline void DerivationExpression_IfElse::clear_else_return() { } else_return_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_else_return() const { - const ::io::substrait::DerivationExpression* p = else_return_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_else_return() const { + const ::substrait::DerivationExpression* p = else_return_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_IfElse::else_return() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.IfElse.else_return) +inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::else_return() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.else_return) return _internal_else_return(); } inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_else_return( - ::io::substrait::DerivationExpression* else_return) { + ::substrait::DerivationExpression* else_return) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else_return_); } @@ -4625,37 +4622,37 @@ inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_else_return( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.IfElse.else_return) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.else_return) } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::release_else_return() { +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_else_return() { - ::io::substrait::DerivationExpression* temp = else_return_; + ::substrait::DerivationExpression* temp = else_return_; else_return_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_else_return() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.IfElse.else_return) +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_else_return() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.else_return) - ::io::substrait::DerivationExpression* temp = else_return_; + ::substrait::DerivationExpression* temp = else_return_; else_return_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_else_return() { +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_else_return() { if (else_return_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); else_return_ = p; } return else_return_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_else_return() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.IfElse.else_return) +inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_else_return() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.else_return) return _internal_mutable_else_return(); } -inline void DerivationExpression_IfElse::set_allocated_else_return(::io::substrait::DerivationExpression* else_return) { +inline void DerivationExpression_IfElse::set_allocated_else_return(::substrait::DerivationExpression* else_return) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete else_return_; @@ -4672,34 +4669,34 @@ inline void DerivationExpression_IfElse::set_allocated_else_return(::io::substra } else_return_ = else_return; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.IfElse.else_return) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.else_return) } // ------------------------------------------------------------------- // DerivationExpression_UnaryOp -// .io.substrait.DerivationExpression.UnaryOp.OpType op_type = 1; +// .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; inline void DerivationExpression_UnaryOp::clear_op_type() { op_type_ = 0; } -inline ::io::substrait::DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::_internal_op_type() const { - return static_cast< ::io::substrait::DerivationExpression_UnaryOp_OpType >(op_type_); +inline ::substrait::DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::_internal_op_type() const { + return static_cast< ::substrait::DerivationExpression_UnaryOp_UnaryOpType >(op_type_); } -inline ::io::substrait::DerivationExpression_UnaryOp_OpType DerivationExpression_UnaryOp::op_type() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.UnaryOp.op_type) +inline ::substrait::DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::op_type() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.UnaryOp.op_type) return _internal_op_type(); } -inline void DerivationExpression_UnaryOp::_internal_set_op_type(::io::substrait::DerivationExpression_UnaryOp_OpType value) { +inline void DerivationExpression_UnaryOp::_internal_set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value) { op_type_ = value; } -inline void DerivationExpression_UnaryOp::set_op_type(::io::substrait::DerivationExpression_UnaryOp_OpType value) { +inline void DerivationExpression_UnaryOp::set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value) { _internal_set_op_type(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.UnaryOp.op_type) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.UnaryOp.op_type) } -// .io.substrait.DerivationExpression arg = 2; +// .substrait.DerivationExpression arg = 2; inline bool DerivationExpression_UnaryOp::_internal_has_arg() const { return this != internal_default_instance() && arg_ != nullptr; } @@ -4712,17 +4709,17 @@ inline void DerivationExpression_UnaryOp::clear_arg() { } arg_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_UnaryOp::_internal_arg() const { - const ::io::substrait::DerivationExpression* p = arg_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::_internal_arg() const { + const ::substrait::DerivationExpression* p = arg_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_UnaryOp::arg() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.UnaryOp.arg) +inline const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::arg() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.UnaryOp.arg) return _internal_arg(); } inline void DerivationExpression_UnaryOp::unsafe_arena_set_allocated_arg( - ::io::substrait::DerivationExpression* arg) { + ::substrait::DerivationExpression* arg) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_); } @@ -4732,37 +4729,37 @@ inline void DerivationExpression_UnaryOp::unsafe_arena_set_allocated_arg( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.UnaryOp.arg) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.UnaryOp.arg) } -inline ::io::substrait::DerivationExpression* DerivationExpression_UnaryOp::release_arg() { +inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::release_arg() { - ::io::substrait::DerivationExpression* temp = arg_; + ::substrait::DerivationExpression* temp = arg_; arg_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_UnaryOp::unsafe_arena_release_arg() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.UnaryOp.arg) +inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::unsafe_arena_release_arg() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.UnaryOp.arg) - ::io::substrait::DerivationExpression* temp = arg_; + ::substrait::DerivationExpression* temp = arg_; arg_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_UnaryOp::_internal_mutable_arg() { +inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::_internal_mutable_arg() { if (arg_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); arg_ = p; } return arg_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_UnaryOp::mutable_arg() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.UnaryOp.arg) +inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::mutable_arg() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.UnaryOp.arg) return _internal_mutable_arg(); } -inline void DerivationExpression_UnaryOp::set_allocated_arg(::io::substrait::DerivationExpression* arg) { +inline void DerivationExpression_UnaryOp::set_allocated_arg(::substrait::DerivationExpression* arg) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete arg_; @@ -4779,34 +4776,34 @@ inline void DerivationExpression_UnaryOp::set_allocated_arg(::io::substrait::Der } arg_ = arg; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.UnaryOp.arg) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.UnaryOp.arg) } // ------------------------------------------------------------------- // DerivationExpression_BinaryOp -// .io.substrait.DerivationExpression.BinaryOp.OpType op_type = 1; +// .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; inline void DerivationExpression_BinaryOp::clear_op_type() { op_type_ = 0; } -inline ::io::substrait::DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::_internal_op_type() const { - return static_cast< ::io::substrait::DerivationExpression_BinaryOp_OpType >(op_type_); +inline ::substrait::DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::_internal_op_type() const { + return static_cast< ::substrait::DerivationExpression_BinaryOp_BinaryOpType >(op_type_); } -inline ::io::substrait::DerivationExpression_BinaryOp_OpType DerivationExpression_BinaryOp::op_type() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.BinaryOp.op_type) +inline ::substrait::DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::op_type() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.op_type) return _internal_op_type(); } -inline void DerivationExpression_BinaryOp::_internal_set_op_type(::io::substrait::DerivationExpression_BinaryOp_OpType value) { +inline void DerivationExpression_BinaryOp::_internal_set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value) { op_type_ = value; } -inline void DerivationExpression_BinaryOp::set_op_type(::io::substrait::DerivationExpression_BinaryOp_OpType value) { +inline void DerivationExpression_BinaryOp::set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value) { _internal_set_op_type(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.BinaryOp.op_type) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.BinaryOp.op_type) } -// .io.substrait.DerivationExpression arg1 = 2; +// .substrait.DerivationExpression arg1 = 2; inline bool DerivationExpression_BinaryOp::_internal_has_arg1() const { return this != internal_default_instance() && arg1_ != nullptr; } @@ -4819,17 +4816,17 @@ inline void DerivationExpression_BinaryOp::clear_arg1() { } arg1_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg1() const { - const ::io::substrait::DerivationExpression* p = arg1_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg1() const { + const ::substrait::DerivationExpression* p = arg1_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg1() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.BinaryOp.arg1) +inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg1() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.arg1) return _internal_arg1(); } inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg1( - ::io::substrait::DerivationExpression* arg1) { + ::substrait::DerivationExpression* arg1) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg1_); } @@ -4839,37 +4836,37 @@ inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg1( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.BinaryOp.arg1) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.BinaryOp.arg1) } -inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg1() { +inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg1() { - ::io::substrait::DerivationExpression* temp = arg1_; + ::substrait::DerivationExpression* temp = arg1_; arg1_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg1() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.BinaryOp.arg1) +inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg1() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.BinaryOp.arg1) - ::io::substrait::DerivationExpression* temp = arg1_; + ::substrait::DerivationExpression* temp = arg1_; arg1_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg1() { +inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg1() { if (arg1_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); arg1_ = p; } return arg1_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg1() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.BinaryOp.arg1) +inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg1() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.BinaryOp.arg1) return _internal_mutable_arg1(); } -inline void DerivationExpression_BinaryOp::set_allocated_arg1(::io::substrait::DerivationExpression* arg1) { +inline void DerivationExpression_BinaryOp::set_allocated_arg1(::substrait::DerivationExpression* arg1) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete arg1_; @@ -4886,10 +4883,10 @@ inline void DerivationExpression_BinaryOp::set_allocated_arg1(::io::substrait::D } arg1_ = arg1; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.BinaryOp.arg1) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.BinaryOp.arg1) } -// .io.substrait.DerivationExpression arg2 = 3; +// .substrait.DerivationExpression arg2 = 3; inline bool DerivationExpression_BinaryOp::_internal_has_arg2() const { return this != internal_default_instance() && arg2_ != nullptr; } @@ -4902,17 +4899,17 @@ inline void DerivationExpression_BinaryOp::clear_arg2() { } arg2_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg2() const { - const ::io::substrait::DerivationExpression* p = arg2_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg2() const { + const ::substrait::DerivationExpression* p = arg2_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg2() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.BinaryOp.arg2) +inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg2() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.arg2) return _internal_arg2(); } inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg2( - ::io::substrait::DerivationExpression* arg2) { + ::substrait::DerivationExpression* arg2) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg2_); } @@ -4922,37 +4919,37 @@ inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg2( } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.BinaryOp.arg2) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.BinaryOp.arg2) } -inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg2() { +inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg2() { - ::io::substrait::DerivationExpression* temp = arg2_; + ::substrait::DerivationExpression* temp = arg2_; arg2_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg2() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.BinaryOp.arg2) +inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg2() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.BinaryOp.arg2) - ::io::substrait::DerivationExpression* temp = arg2_; + ::substrait::DerivationExpression* temp = arg2_; arg2_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg2() { +inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg2() { if (arg2_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); arg2_ = p; } return arg2_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg2() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.BinaryOp.arg2) +inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg2() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.BinaryOp.arg2) return _internal_mutable_arg2(); } -inline void DerivationExpression_BinaryOp::set_allocated_arg2(::io::substrait::DerivationExpression* arg2) { +inline void DerivationExpression_BinaryOp::set_allocated_arg2(::substrait::DerivationExpression* arg2) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete arg2_; @@ -4969,7 +4966,7 @@ inline void DerivationExpression_BinaryOp::set_allocated_arg2(::io::substrait::D } arg2_ = arg2; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.BinaryOp.arg2) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.BinaryOp.arg2) } // ------------------------------------------------------------------- @@ -4981,7 +4978,7 @@ inline void DerivationExpression_ReturnProgram_Assignment::clear_name() { name_.ClearToEmpty(); } inline const std::string& DerivationExpression_ReturnProgram_Assignment::name() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ReturnProgram.Assignment.name) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.Assignment.name) return _internal_name(); } template @@ -4989,10 +4986,10 @@ PROTOBUF_ALWAYS_INLINE inline void DerivationExpression_ReturnProgram_Assignment::set_name(ArgT0&& arg0, ArgT... args) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.ReturnProgram.Assignment.name) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ReturnProgram.Assignment.name) } inline std::string* DerivationExpression_ReturnProgram_Assignment::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ReturnProgram.Assignment.name) + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.Assignment.name) return _internal_mutable_name(); } inline const std::string& DerivationExpression_ReturnProgram_Assignment::_internal_name() const { @@ -5007,7 +5004,7 @@ inline std::string* DerivationExpression_ReturnProgram_Assignment::_internal_mut return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* DerivationExpression_ReturnProgram_Assignment::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ReturnProgram.Assignment.name) + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.Assignment.name) return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); } inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_name(std::string* name) { @@ -5018,10 +5015,10 @@ inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_name(st } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ReturnProgram.Assignment.name) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.name) } -// .io.substrait.DerivationExpression expression = 2; +// .substrait.DerivationExpression expression = 2; inline bool DerivationExpression_ReturnProgram_Assignment::_internal_has_expression() const { return this != internal_default_instance() && expression_ != nullptr; } @@ -5034,17 +5031,17 @@ inline void DerivationExpression_ReturnProgram_Assignment::clear_expression() { } expression_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::_internal_expression() const { - const ::io::substrait::DerivationExpression* p = expression_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::_internal_expression() const { + const ::substrait::DerivationExpression* p = expression_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::expression() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ReturnProgram.Assignment.expression) +inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::expression() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.Assignment.expression) return _internal_expression(); } inline void DerivationExpression_ReturnProgram_Assignment::unsafe_arena_set_allocated_expression( - ::io::substrait::DerivationExpression* expression) { + ::substrait::DerivationExpression* expression) { if (GetArena() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); } @@ -5054,37 +5051,37 @@ inline void DerivationExpression_ReturnProgram_Assignment::unsafe_arena_set_allo } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ReturnProgram.Assignment.expression) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.expression) } -inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::release_expression() { +inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::release_expression() { - ::io::substrait::DerivationExpression* temp = expression_; + ::substrait::DerivationExpression* temp = expression_; expression_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ReturnProgram.Assignment.expression) +inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::unsafe_arena_release_expression() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.Assignment.expression) - ::io::substrait::DerivationExpression* temp = expression_; + ::substrait::DerivationExpression* temp = expression_; expression_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_expression() { +inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_expression() { if (expression_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); expression_ = p; } return expression_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::mutable_expression() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ReturnProgram.Assignment.expression) +inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::mutable_expression() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.Assignment.expression) return _internal_mutable_expression(); } -inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_expression(::io::substrait::DerivationExpression* expression) { +inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_expression(::substrait::DerivationExpression* expression) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { delete expression_; @@ -5101,14 +5098,14 @@ inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_express } expression_ = expression; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ReturnProgram.Assignment.expression) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.expression) } // ------------------------------------------------------------------- // DerivationExpression_ReturnProgram -// repeated .io.substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; +// repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; inline int DerivationExpression_ReturnProgram::_internal_assignments_size() const { return assignments_.size(); } @@ -5118,123 +5115,123 @@ inline int DerivationExpression_ReturnProgram::assignments_size() const { inline void DerivationExpression_ReturnProgram::clear_assignments() { assignments_.Clear(); } -inline ::io::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::mutable_assignments(int index) { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ReturnProgram.assignments) +inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::mutable_assignments(int index) { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.assignments) return assignments_.Mutable(index); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >* DerivationExpression_ReturnProgram::mutable_assignments() { - // @@protoc_insertion_point(field_mutable_list:io.substrait.DerivationExpression.ReturnProgram.assignments) + // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ReturnProgram.assignments) return &assignments_; } -inline const ::io::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::_internal_assignments(int index) const { +inline const ::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::_internal_assignments(int index) const { return assignments_.Get(index); } -inline const ::io::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::assignments(int index) const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ReturnProgram.assignments) +inline const ::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::assignments(int index) const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.assignments) return _internal_assignments(index); } -inline ::io::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::_internal_add_assignments() { +inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::_internal_add_assignments() { return assignments_.Add(); } -inline ::io::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::add_assignments() { - // @@protoc_insertion_point(field_add:io.substrait.DerivationExpression.ReturnProgram.assignments) +inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::add_assignments() { + // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ReturnProgram.assignments) return _internal_add_assignments(); } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::io::substrait::DerivationExpression_ReturnProgram_Assignment >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >& DerivationExpression_ReturnProgram::assignments() const { - // @@protoc_insertion_point(field_list:io.substrait.DerivationExpression.ReturnProgram.assignments) + // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ReturnProgram.assignments) return assignments_; } -// .io.substrait.DerivationExpression finalExpression = 2; -inline bool DerivationExpression_ReturnProgram::_internal_has_finalexpression() const { - return this != internal_default_instance() && finalexpression_ != nullptr; +// .substrait.DerivationExpression final_expression = 2; +inline bool DerivationExpression_ReturnProgram::_internal_has_final_expression() const { + return this != internal_default_instance() && final_expression_ != nullptr; } -inline bool DerivationExpression_ReturnProgram::has_finalexpression() const { - return _internal_has_finalexpression(); +inline bool DerivationExpression_ReturnProgram::has_final_expression() const { + return _internal_has_final_expression(); } -inline void DerivationExpression_ReturnProgram::clear_finalexpression() { - if (GetArena() == nullptr && finalexpression_ != nullptr) { - delete finalexpression_; +inline void DerivationExpression_ReturnProgram::clear_final_expression() { + if (GetArena() == nullptr && final_expression_ != nullptr) { + delete final_expression_; } - finalexpression_ = nullptr; + final_expression_ = nullptr; } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ReturnProgram::_internal_finalexpression() const { - const ::io::substrait::DerivationExpression* p = finalexpression_; - return p != nullptr ? *p : reinterpret_cast( - ::io::substrait::_DerivationExpression_default_instance_); +inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram::_internal_final_expression() const { + const ::substrait::DerivationExpression* p = final_expression_; + return p != nullptr ? *p : reinterpret_cast( + ::substrait::_DerivationExpression_default_instance_); } -inline const ::io::substrait::DerivationExpression& DerivationExpression_ReturnProgram::finalexpression() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.ReturnProgram.finalExpression) - return _internal_finalexpression(); +inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram::final_expression() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.final_expression) + return _internal_final_expression(); } -inline void DerivationExpression_ReturnProgram::unsafe_arena_set_allocated_finalexpression( - ::io::substrait::DerivationExpression* finalexpression) { +inline void DerivationExpression_ReturnProgram::unsafe_arena_set_allocated_final_expression( + ::substrait::DerivationExpression* final_expression) { if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(finalexpression_); + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(final_expression_); } - finalexpression_ = finalexpression; - if (finalexpression) { + final_expression_ = final_expression; + if (final_expression) { } else { } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.ReturnProgram.finalExpression) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ReturnProgram.final_expression) } -inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram::release_finalexpression() { +inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::release_final_expression() { - ::io::substrait::DerivationExpression* temp = finalexpression_; - finalexpression_ = nullptr; + ::substrait::DerivationExpression* temp = final_expression_; + final_expression_ = nullptr; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram::unsafe_arena_release_finalexpression() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.ReturnProgram.finalExpression) +inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::unsafe_arena_release_final_expression() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.final_expression) - ::io::substrait::DerivationExpression* temp = finalexpression_; - finalexpression_ = nullptr; + ::substrait::DerivationExpression* temp = final_expression_; + final_expression_ = nullptr; return temp; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram::_internal_mutable_finalexpression() { +inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::_internal_mutable_final_expression() { - if (finalexpression_ == nullptr) { - auto* p = CreateMaybeMessage<::io::substrait::DerivationExpression>(GetArena()); - finalexpression_ = p; + if (final_expression_ == nullptr) { + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + final_expression_ = p; } - return finalexpression_; + return final_expression_; } -inline ::io::substrait::DerivationExpression* DerivationExpression_ReturnProgram::mutable_finalexpression() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.ReturnProgram.finalExpression) - return _internal_mutable_finalexpression(); +inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::mutable_final_expression() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.final_expression) + return _internal_mutable_final_expression(); } -inline void DerivationExpression_ReturnProgram::set_allocated_finalexpression(::io::substrait::DerivationExpression* finalexpression) { +inline void DerivationExpression_ReturnProgram::set_allocated_final_expression(::substrait::DerivationExpression* final_expression) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); if (message_arena == nullptr) { - delete finalexpression_; + delete final_expression_; } - if (finalexpression) { + if (final_expression) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(finalexpression); + ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(final_expression); if (message_arena != submessage_arena) { - finalexpression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, finalexpression, submessage_arena); + final_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, final_expression, submessage_arena); } } else { } - finalexpression_ = finalexpression; - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.ReturnProgram.finalExpression) + final_expression_ = final_expression; + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.final_expression) } // ------------------------------------------------------------------- // DerivationExpression -// .io.substrait.Type.Boolean bool = 1; +// .substrait.Type.Boolean bool = 1; inline bool DerivationExpression::_internal_has_bool_() const { return kind_case() == kBool; } @@ -5244,11 +5241,11 @@ inline bool DerivationExpression::has_bool_() const { inline void DerivationExpression::set_has_bool_() { _oneof_case_[0] = kBool; } -inline ::io::substrait::Type_Boolean* DerivationExpression::release_bool_() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.bool) +inline ::substrait::Type_Boolean* DerivationExpression::release_bool_() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.bool) if (_internal_has_bool_()) { clear_has_kind(); - ::io::substrait::Type_Boolean* temp = kind_.bool__; + ::substrait::Type_Boolean* temp = kind_.bool__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5258,48 +5255,48 @@ inline ::io::substrait::Type_Boolean* DerivationExpression::release_bool_() { return nullptr; } } -inline const ::io::substrait::Type_Boolean& DerivationExpression::_internal_bool_() const { +inline const ::substrait::Type_Boolean& DerivationExpression::_internal_bool_() const { return _internal_has_bool_() ? *kind_.bool__ - : reinterpret_cast< ::io::substrait::Type_Boolean&>(::io::substrait::_Type_Boolean_default_instance_); + : reinterpret_cast< ::substrait::Type_Boolean&>(::substrait::_Type_Boolean_default_instance_); } -inline const ::io::substrait::Type_Boolean& DerivationExpression::bool_() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.bool) +inline const ::substrait::Type_Boolean& DerivationExpression::bool_() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.bool) return _internal_bool_(); } -inline ::io::substrait::Type_Boolean* DerivationExpression::unsafe_arena_release_bool_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.bool) +inline ::substrait::Type_Boolean* DerivationExpression::unsafe_arena_release_bool_() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.bool) if (_internal_has_bool_()) { clear_has_kind(); - ::io::substrait::Type_Boolean* temp = kind_.bool__; + ::substrait::Type_Boolean* temp = kind_.bool__; kind_.bool__ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_bool_(::io::substrait::Type_Boolean* bool_) { +inline void DerivationExpression::unsafe_arena_set_allocated_bool_(::substrait::Type_Boolean* bool_) { clear_kind(); if (bool_) { set_has_bool_(); kind_.bool__ = bool_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.bool) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.bool) } -inline ::io::substrait::Type_Boolean* DerivationExpression::_internal_mutable_bool_() { +inline ::substrait::Type_Boolean* DerivationExpression::_internal_mutable_bool_() { if (!_internal_has_bool_()) { clear_kind(); set_has_bool_(); - kind_.bool__ = CreateMaybeMessage< ::io::substrait::Type_Boolean >(GetArena()); + kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArena()); } return kind_.bool__; } -inline ::io::substrait::Type_Boolean* DerivationExpression::mutable_bool_() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.bool) +inline ::substrait::Type_Boolean* DerivationExpression::mutable_bool_() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.bool) return _internal_mutable_bool_(); } -// .io.substrait.Type.I8 i8 = 2; +// .substrait.Type.I8 i8 = 2; inline bool DerivationExpression::_internal_has_i8() const { return kind_case() == kI8; } @@ -5309,11 +5306,11 @@ inline bool DerivationExpression::has_i8() const { inline void DerivationExpression::set_has_i8() { _oneof_case_[0] = kI8; } -inline ::io::substrait::Type_I8* DerivationExpression::release_i8() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.i8) +inline ::substrait::Type_I8* DerivationExpression::release_i8() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i8) if (_internal_has_i8()) { clear_has_kind(); - ::io::substrait::Type_I8* temp = kind_.i8_; + ::substrait::Type_I8* temp = kind_.i8_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5323,48 +5320,48 @@ inline ::io::substrait::Type_I8* DerivationExpression::release_i8() { return nullptr; } } -inline const ::io::substrait::Type_I8& DerivationExpression::_internal_i8() const { +inline const ::substrait::Type_I8& DerivationExpression::_internal_i8() const { return _internal_has_i8() ? *kind_.i8_ - : reinterpret_cast< ::io::substrait::Type_I8&>(::io::substrait::_Type_I8_default_instance_); + : reinterpret_cast< ::substrait::Type_I8&>(::substrait::_Type_I8_default_instance_); } -inline const ::io::substrait::Type_I8& DerivationExpression::i8() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.i8) +inline const ::substrait::Type_I8& DerivationExpression::i8() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i8) return _internal_i8(); } -inline ::io::substrait::Type_I8* DerivationExpression::unsafe_arena_release_i8() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.i8) +inline ::substrait::Type_I8* DerivationExpression::unsafe_arena_release_i8() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i8) if (_internal_has_i8()) { clear_has_kind(); - ::io::substrait::Type_I8* temp = kind_.i8_; + ::substrait::Type_I8* temp = kind_.i8_; kind_.i8_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_i8(::io::substrait::Type_I8* i8) { +inline void DerivationExpression::unsafe_arena_set_allocated_i8(::substrait::Type_I8* i8) { clear_kind(); if (i8) { set_has_i8(); kind_.i8_ = i8; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.i8) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i8) } -inline ::io::substrait::Type_I8* DerivationExpression::_internal_mutable_i8() { +inline ::substrait::Type_I8* DerivationExpression::_internal_mutable_i8() { if (!_internal_has_i8()) { clear_kind(); set_has_i8(); - kind_.i8_ = CreateMaybeMessage< ::io::substrait::Type_I8 >(GetArena()); + kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArena()); } return kind_.i8_; } -inline ::io::substrait::Type_I8* DerivationExpression::mutable_i8() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.i8) +inline ::substrait::Type_I8* DerivationExpression::mutable_i8() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i8) return _internal_mutable_i8(); } -// .io.substrait.Type.I16 i16 = 3; +// .substrait.Type.I16 i16 = 3; inline bool DerivationExpression::_internal_has_i16() const { return kind_case() == kI16; } @@ -5374,11 +5371,11 @@ inline bool DerivationExpression::has_i16() const { inline void DerivationExpression::set_has_i16() { _oneof_case_[0] = kI16; } -inline ::io::substrait::Type_I16* DerivationExpression::release_i16() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.i16) +inline ::substrait::Type_I16* DerivationExpression::release_i16() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i16) if (_internal_has_i16()) { clear_has_kind(); - ::io::substrait::Type_I16* temp = kind_.i16_; + ::substrait::Type_I16* temp = kind_.i16_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5388,48 +5385,48 @@ inline ::io::substrait::Type_I16* DerivationExpression::release_i16() { return nullptr; } } -inline const ::io::substrait::Type_I16& DerivationExpression::_internal_i16() const { +inline const ::substrait::Type_I16& DerivationExpression::_internal_i16() const { return _internal_has_i16() ? *kind_.i16_ - : reinterpret_cast< ::io::substrait::Type_I16&>(::io::substrait::_Type_I16_default_instance_); + : reinterpret_cast< ::substrait::Type_I16&>(::substrait::_Type_I16_default_instance_); } -inline const ::io::substrait::Type_I16& DerivationExpression::i16() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.i16) +inline const ::substrait::Type_I16& DerivationExpression::i16() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i16) return _internal_i16(); } -inline ::io::substrait::Type_I16* DerivationExpression::unsafe_arena_release_i16() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.i16) +inline ::substrait::Type_I16* DerivationExpression::unsafe_arena_release_i16() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i16) if (_internal_has_i16()) { clear_has_kind(); - ::io::substrait::Type_I16* temp = kind_.i16_; + ::substrait::Type_I16* temp = kind_.i16_; kind_.i16_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_i16(::io::substrait::Type_I16* i16) { +inline void DerivationExpression::unsafe_arena_set_allocated_i16(::substrait::Type_I16* i16) { clear_kind(); if (i16) { set_has_i16(); kind_.i16_ = i16; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.i16) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i16) } -inline ::io::substrait::Type_I16* DerivationExpression::_internal_mutable_i16() { +inline ::substrait::Type_I16* DerivationExpression::_internal_mutable_i16() { if (!_internal_has_i16()) { clear_kind(); set_has_i16(); - kind_.i16_ = CreateMaybeMessage< ::io::substrait::Type_I16 >(GetArena()); + kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArena()); } return kind_.i16_; } -inline ::io::substrait::Type_I16* DerivationExpression::mutable_i16() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.i16) +inline ::substrait::Type_I16* DerivationExpression::mutable_i16() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i16) return _internal_mutable_i16(); } -// .io.substrait.Type.I32 i32 = 5; +// .substrait.Type.I32 i32 = 5; inline bool DerivationExpression::_internal_has_i32() const { return kind_case() == kI32; } @@ -5439,11 +5436,11 @@ inline bool DerivationExpression::has_i32() const { inline void DerivationExpression::set_has_i32() { _oneof_case_[0] = kI32; } -inline ::io::substrait::Type_I32* DerivationExpression::release_i32() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.i32) +inline ::substrait::Type_I32* DerivationExpression::release_i32() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i32) if (_internal_has_i32()) { clear_has_kind(); - ::io::substrait::Type_I32* temp = kind_.i32_; + ::substrait::Type_I32* temp = kind_.i32_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5453,48 +5450,48 @@ inline ::io::substrait::Type_I32* DerivationExpression::release_i32() { return nullptr; } } -inline const ::io::substrait::Type_I32& DerivationExpression::_internal_i32() const { +inline const ::substrait::Type_I32& DerivationExpression::_internal_i32() const { return _internal_has_i32() ? *kind_.i32_ - : reinterpret_cast< ::io::substrait::Type_I32&>(::io::substrait::_Type_I32_default_instance_); + : reinterpret_cast< ::substrait::Type_I32&>(::substrait::_Type_I32_default_instance_); } -inline const ::io::substrait::Type_I32& DerivationExpression::i32() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.i32) +inline const ::substrait::Type_I32& DerivationExpression::i32() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i32) return _internal_i32(); } -inline ::io::substrait::Type_I32* DerivationExpression::unsafe_arena_release_i32() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.i32) +inline ::substrait::Type_I32* DerivationExpression::unsafe_arena_release_i32() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i32) if (_internal_has_i32()) { clear_has_kind(); - ::io::substrait::Type_I32* temp = kind_.i32_; + ::substrait::Type_I32* temp = kind_.i32_; kind_.i32_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_i32(::io::substrait::Type_I32* i32) { +inline void DerivationExpression::unsafe_arena_set_allocated_i32(::substrait::Type_I32* i32) { clear_kind(); if (i32) { set_has_i32(); kind_.i32_ = i32; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.i32) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i32) } -inline ::io::substrait::Type_I32* DerivationExpression::_internal_mutable_i32() { +inline ::substrait::Type_I32* DerivationExpression::_internal_mutable_i32() { if (!_internal_has_i32()) { clear_kind(); set_has_i32(); - kind_.i32_ = CreateMaybeMessage< ::io::substrait::Type_I32 >(GetArena()); + kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArena()); } return kind_.i32_; } -inline ::io::substrait::Type_I32* DerivationExpression::mutable_i32() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.i32) +inline ::substrait::Type_I32* DerivationExpression::mutable_i32() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i32) return _internal_mutable_i32(); } -// .io.substrait.Type.I64 i64 = 7; +// .substrait.Type.I64 i64 = 7; inline bool DerivationExpression::_internal_has_i64() const { return kind_case() == kI64; } @@ -5504,11 +5501,11 @@ inline bool DerivationExpression::has_i64() const { inline void DerivationExpression::set_has_i64() { _oneof_case_[0] = kI64; } -inline ::io::substrait::Type_I64* DerivationExpression::release_i64() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.i64) +inline ::substrait::Type_I64* DerivationExpression::release_i64() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i64) if (_internal_has_i64()) { clear_has_kind(); - ::io::substrait::Type_I64* temp = kind_.i64_; + ::substrait::Type_I64* temp = kind_.i64_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5518,48 +5515,48 @@ inline ::io::substrait::Type_I64* DerivationExpression::release_i64() { return nullptr; } } -inline const ::io::substrait::Type_I64& DerivationExpression::_internal_i64() const { +inline const ::substrait::Type_I64& DerivationExpression::_internal_i64() const { return _internal_has_i64() ? *kind_.i64_ - : reinterpret_cast< ::io::substrait::Type_I64&>(::io::substrait::_Type_I64_default_instance_); + : reinterpret_cast< ::substrait::Type_I64&>(::substrait::_Type_I64_default_instance_); } -inline const ::io::substrait::Type_I64& DerivationExpression::i64() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.i64) +inline const ::substrait::Type_I64& DerivationExpression::i64() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i64) return _internal_i64(); } -inline ::io::substrait::Type_I64* DerivationExpression::unsafe_arena_release_i64() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.i64) +inline ::substrait::Type_I64* DerivationExpression::unsafe_arena_release_i64() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i64) if (_internal_has_i64()) { clear_has_kind(); - ::io::substrait::Type_I64* temp = kind_.i64_; + ::substrait::Type_I64* temp = kind_.i64_; kind_.i64_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_i64(::io::substrait::Type_I64* i64) { +inline void DerivationExpression::unsafe_arena_set_allocated_i64(::substrait::Type_I64* i64) { clear_kind(); if (i64) { set_has_i64(); kind_.i64_ = i64; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.i64) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i64) } -inline ::io::substrait::Type_I64* DerivationExpression::_internal_mutable_i64() { +inline ::substrait::Type_I64* DerivationExpression::_internal_mutable_i64() { if (!_internal_has_i64()) { clear_kind(); set_has_i64(); - kind_.i64_ = CreateMaybeMessage< ::io::substrait::Type_I64 >(GetArena()); + kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArena()); } return kind_.i64_; } -inline ::io::substrait::Type_I64* DerivationExpression::mutable_i64() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.i64) +inline ::substrait::Type_I64* DerivationExpression::mutable_i64() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i64) return _internal_mutable_i64(); } -// .io.substrait.Type.FP32 fp32 = 10; +// .substrait.Type.FP32 fp32 = 10; inline bool DerivationExpression::_internal_has_fp32() const { return kind_case() == kFp32; } @@ -5569,11 +5566,11 @@ inline bool DerivationExpression::has_fp32() const { inline void DerivationExpression::set_has_fp32() { _oneof_case_[0] = kFp32; } -inline ::io::substrait::Type_FP32* DerivationExpression::release_fp32() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.fp32) +inline ::substrait::Type_FP32* DerivationExpression::release_fp32() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fp32) if (_internal_has_fp32()) { clear_has_kind(); - ::io::substrait::Type_FP32* temp = kind_.fp32_; + ::substrait::Type_FP32* temp = kind_.fp32_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5583,48 +5580,48 @@ inline ::io::substrait::Type_FP32* DerivationExpression::release_fp32() { return nullptr; } } -inline const ::io::substrait::Type_FP32& DerivationExpression::_internal_fp32() const { +inline const ::substrait::Type_FP32& DerivationExpression::_internal_fp32() const { return _internal_has_fp32() ? *kind_.fp32_ - : reinterpret_cast< ::io::substrait::Type_FP32&>(::io::substrait::_Type_FP32_default_instance_); + : reinterpret_cast< ::substrait::Type_FP32&>(::substrait::_Type_FP32_default_instance_); } -inline const ::io::substrait::Type_FP32& DerivationExpression::fp32() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.fp32) +inline const ::substrait::Type_FP32& DerivationExpression::fp32() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fp32) return _internal_fp32(); } -inline ::io::substrait::Type_FP32* DerivationExpression::unsafe_arena_release_fp32() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.fp32) +inline ::substrait::Type_FP32* DerivationExpression::unsafe_arena_release_fp32() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fp32) if (_internal_has_fp32()) { clear_has_kind(); - ::io::substrait::Type_FP32* temp = kind_.fp32_; + ::substrait::Type_FP32* temp = kind_.fp32_; kind_.fp32_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_fp32(::io::substrait::Type_FP32* fp32) { +inline void DerivationExpression::unsafe_arena_set_allocated_fp32(::substrait::Type_FP32* fp32) { clear_kind(); if (fp32) { set_has_fp32(); kind_.fp32_ = fp32; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.fp32) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fp32) } -inline ::io::substrait::Type_FP32* DerivationExpression::_internal_mutable_fp32() { +inline ::substrait::Type_FP32* DerivationExpression::_internal_mutable_fp32() { if (!_internal_has_fp32()) { clear_kind(); set_has_fp32(); - kind_.fp32_ = CreateMaybeMessage< ::io::substrait::Type_FP32 >(GetArena()); + kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArena()); } return kind_.fp32_; } -inline ::io::substrait::Type_FP32* DerivationExpression::mutable_fp32() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.fp32) +inline ::substrait::Type_FP32* DerivationExpression::mutable_fp32() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fp32) return _internal_mutable_fp32(); } -// .io.substrait.Type.FP64 fp64 = 11; +// .substrait.Type.FP64 fp64 = 11; inline bool DerivationExpression::_internal_has_fp64() const { return kind_case() == kFp64; } @@ -5634,11 +5631,11 @@ inline bool DerivationExpression::has_fp64() const { inline void DerivationExpression::set_has_fp64() { _oneof_case_[0] = kFp64; } -inline ::io::substrait::Type_FP64* DerivationExpression::release_fp64() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.fp64) +inline ::substrait::Type_FP64* DerivationExpression::release_fp64() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fp64) if (_internal_has_fp64()) { clear_has_kind(); - ::io::substrait::Type_FP64* temp = kind_.fp64_; + ::substrait::Type_FP64* temp = kind_.fp64_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5648,48 +5645,48 @@ inline ::io::substrait::Type_FP64* DerivationExpression::release_fp64() { return nullptr; } } -inline const ::io::substrait::Type_FP64& DerivationExpression::_internal_fp64() const { +inline const ::substrait::Type_FP64& DerivationExpression::_internal_fp64() const { return _internal_has_fp64() ? *kind_.fp64_ - : reinterpret_cast< ::io::substrait::Type_FP64&>(::io::substrait::_Type_FP64_default_instance_); + : reinterpret_cast< ::substrait::Type_FP64&>(::substrait::_Type_FP64_default_instance_); } -inline const ::io::substrait::Type_FP64& DerivationExpression::fp64() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.fp64) +inline const ::substrait::Type_FP64& DerivationExpression::fp64() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fp64) return _internal_fp64(); } -inline ::io::substrait::Type_FP64* DerivationExpression::unsafe_arena_release_fp64() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.fp64) +inline ::substrait::Type_FP64* DerivationExpression::unsafe_arena_release_fp64() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fp64) if (_internal_has_fp64()) { clear_has_kind(); - ::io::substrait::Type_FP64* temp = kind_.fp64_; + ::substrait::Type_FP64* temp = kind_.fp64_; kind_.fp64_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_fp64(::io::substrait::Type_FP64* fp64) { +inline void DerivationExpression::unsafe_arena_set_allocated_fp64(::substrait::Type_FP64* fp64) { clear_kind(); if (fp64) { set_has_fp64(); kind_.fp64_ = fp64; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.fp64) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fp64) } -inline ::io::substrait::Type_FP64* DerivationExpression::_internal_mutable_fp64() { +inline ::substrait::Type_FP64* DerivationExpression::_internal_mutable_fp64() { if (!_internal_has_fp64()) { clear_kind(); set_has_fp64(); - kind_.fp64_ = CreateMaybeMessage< ::io::substrait::Type_FP64 >(GetArena()); + kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArena()); } return kind_.fp64_; } -inline ::io::substrait::Type_FP64* DerivationExpression::mutable_fp64() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.fp64) +inline ::substrait::Type_FP64* DerivationExpression::mutable_fp64() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fp64) return _internal_mutable_fp64(); } -// .io.substrait.Type.String string = 12; +// .substrait.Type.String string = 12; inline bool DerivationExpression::_internal_has_string() const { return kind_case() == kString; } @@ -5699,11 +5696,11 @@ inline bool DerivationExpression::has_string() const { inline void DerivationExpression::set_has_string() { _oneof_case_[0] = kString; } -inline ::io::substrait::Type_String* DerivationExpression::release_string() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.string) +inline ::substrait::Type_String* DerivationExpression::release_string() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.string) if (_internal_has_string()) { clear_has_kind(); - ::io::substrait::Type_String* temp = kind_.string_; + ::substrait::Type_String* temp = kind_.string_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5713,48 +5710,48 @@ inline ::io::substrait::Type_String* DerivationExpression::release_string() { return nullptr; } } -inline const ::io::substrait::Type_String& DerivationExpression::_internal_string() const { +inline const ::substrait::Type_String& DerivationExpression::_internal_string() const { return _internal_has_string() ? *kind_.string_ - : reinterpret_cast< ::io::substrait::Type_String&>(::io::substrait::_Type_String_default_instance_); + : reinterpret_cast< ::substrait::Type_String&>(::substrait::_Type_String_default_instance_); } -inline const ::io::substrait::Type_String& DerivationExpression::string() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.string) +inline const ::substrait::Type_String& DerivationExpression::string() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.string) return _internal_string(); } -inline ::io::substrait::Type_String* DerivationExpression::unsafe_arena_release_string() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.string) +inline ::substrait::Type_String* DerivationExpression::unsafe_arena_release_string() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.string) if (_internal_has_string()) { clear_has_kind(); - ::io::substrait::Type_String* temp = kind_.string_; + ::substrait::Type_String* temp = kind_.string_; kind_.string_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_string(::io::substrait::Type_String* string) { +inline void DerivationExpression::unsafe_arena_set_allocated_string(::substrait::Type_String* string) { clear_kind(); if (string) { set_has_string(); kind_.string_ = string; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.string) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.string) } -inline ::io::substrait::Type_String* DerivationExpression::_internal_mutable_string() { +inline ::substrait::Type_String* DerivationExpression::_internal_mutable_string() { if (!_internal_has_string()) { clear_kind(); set_has_string(); - kind_.string_ = CreateMaybeMessage< ::io::substrait::Type_String >(GetArena()); + kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArena()); } return kind_.string_; } -inline ::io::substrait::Type_String* DerivationExpression::mutable_string() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.string) +inline ::substrait::Type_String* DerivationExpression::mutable_string() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.string) return _internal_mutable_string(); } -// .io.substrait.Type.Binary binary = 13; +// .substrait.Type.Binary binary = 13; inline bool DerivationExpression::_internal_has_binary() const { return kind_case() == kBinary; } @@ -5764,11 +5761,11 @@ inline bool DerivationExpression::has_binary() const { inline void DerivationExpression::set_has_binary() { _oneof_case_[0] = kBinary; } -inline ::io::substrait::Type_Binary* DerivationExpression::release_binary() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.binary) +inline ::substrait::Type_Binary* DerivationExpression::release_binary() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.binary) if (_internal_has_binary()) { clear_has_kind(); - ::io::substrait::Type_Binary* temp = kind_.binary_; + ::substrait::Type_Binary* temp = kind_.binary_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5778,48 +5775,48 @@ inline ::io::substrait::Type_Binary* DerivationExpression::release_binary() { return nullptr; } } -inline const ::io::substrait::Type_Binary& DerivationExpression::_internal_binary() const { +inline const ::substrait::Type_Binary& DerivationExpression::_internal_binary() const { return _internal_has_binary() ? *kind_.binary_ - : reinterpret_cast< ::io::substrait::Type_Binary&>(::io::substrait::_Type_Binary_default_instance_); + : reinterpret_cast< ::substrait::Type_Binary&>(::substrait::_Type_Binary_default_instance_); } -inline const ::io::substrait::Type_Binary& DerivationExpression::binary() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.binary) +inline const ::substrait::Type_Binary& DerivationExpression::binary() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.binary) return _internal_binary(); } -inline ::io::substrait::Type_Binary* DerivationExpression::unsafe_arena_release_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.binary) +inline ::substrait::Type_Binary* DerivationExpression::unsafe_arena_release_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.binary) if (_internal_has_binary()) { clear_has_kind(); - ::io::substrait::Type_Binary* temp = kind_.binary_; + ::substrait::Type_Binary* temp = kind_.binary_; kind_.binary_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_binary(::io::substrait::Type_Binary* binary) { +inline void DerivationExpression::unsafe_arena_set_allocated_binary(::substrait::Type_Binary* binary) { clear_kind(); if (binary) { set_has_binary(); kind_.binary_ = binary; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.binary) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.binary) } -inline ::io::substrait::Type_Binary* DerivationExpression::_internal_mutable_binary() { +inline ::substrait::Type_Binary* DerivationExpression::_internal_mutable_binary() { if (!_internal_has_binary()) { clear_kind(); set_has_binary(); - kind_.binary_ = CreateMaybeMessage< ::io::substrait::Type_Binary >(GetArena()); + kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArena()); } return kind_.binary_; } -inline ::io::substrait::Type_Binary* DerivationExpression::mutable_binary() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.binary) +inline ::substrait::Type_Binary* DerivationExpression::mutable_binary() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.binary) return _internal_mutable_binary(); } -// .io.substrait.Type.Timestamp timestamp = 14; +// .substrait.Type.Timestamp timestamp = 14; inline bool DerivationExpression::_internal_has_timestamp() const { return kind_case() == kTimestamp; } @@ -5829,11 +5826,11 @@ inline bool DerivationExpression::has_timestamp() const { inline void DerivationExpression::set_has_timestamp() { _oneof_case_[0] = kTimestamp; } -inline ::io::substrait::Type_Timestamp* DerivationExpression::release_timestamp() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.timestamp) +inline ::substrait::Type_Timestamp* DerivationExpression::release_timestamp() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.timestamp) if (_internal_has_timestamp()) { clear_has_kind(); - ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + ::substrait::Type_Timestamp* temp = kind_.timestamp_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5843,48 +5840,48 @@ inline ::io::substrait::Type_Timestamp* DerivationExpression::release_timestamp( return nullptr; } } -inline const ::io::substrait::Type_Timestamp& DerivationExpression::_internal_timestamp() const { +inline const ::substrait::Type_Timestamp& DerivationExpression::_internal_timestamp() const { return _internal_has_timestamp() ? *kind_.timestamp_ - : reinterpret_cast< ::io::substrait::Type_Timestamp&>(::io::substrait::_Type_Timestamp_default_instance_); + : reinterpret_cast< ::substrait::Type_Timestamp&>(::substrait::_Type_Timestamp_default_instance_); } -inline const ::io::substrait::Type_Timestamp& DerivationExpression::timestamp() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.timestamp) +inline const ::substrait::Type_Timestamp& DerivationExpression::timestamp() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.timestamp) return _internal_timestamp(); } -inline ::io::substrait::Type_Timestamp* DerivationExpression::unsafe_arena_release_timestamp() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.timestamp) +inline ::substrait::Type_Timestamp* DerivationExpression::unsafe_arena_release_timestamp() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.timestamp) if (_internal_has_timestamp()) { clear_has_kind(); - ::io::substrait::Type_Timestamp* temp = kind_.timestamp_; + ::substrait::Type_Timestamp* temp = kind_.timestamp_; kind_.timestamp_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_timestamp(::io::substrait::Type_Timestamp* timestamp) { +inline void DerivationExpression::unsafe_arena_set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { clear_kind(); if (timestamp) { set_has_timestamp(); kind_.timestamp_ = timestamp; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.timestamp) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.timestamp) } -inline ::io::substrait::Type_Timestamp* DerivationExpression::_internal_mutable_timestamp() { +inline ::substrait::Type_Timestamp* DerivationExpression::_internal_mutable_timestamp() { if (!_internal_has_timestamp()) { clear_kind(); set_has_timestamp(); - kind_.timestamp_ = CreateMaybeMessage< ::io::substrait::Type_Timestamp >(GetArena()); + kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArena()); } return kind_.timestamp_; } -inline ::io::substrait::Type_Timestamp* DerivationExpression::mutable_timestamp() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.timestamp) +inline ::substrait::Type_Timestamp* DerivationExpression::mutable_timestamp() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.timestamp) return _internal_mutable_timestamp(); } -// .io.substrait.Type.Date date = 16; +// .substrait.Type.Date date = 16; inline bool DerivationExpression::_internal_has_date() const { return kind_case() == kDate; } @@ -5894,11 +5891,11 @@ inline bool DerivationExpression::has_date() const { inline void DerivationExpression::set_has_date() { _oneof_case_[0] = kDate; } -inline ::io::substrait::Type_Date* DerivationExpression::release_date() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.date) +inline ::substrait::Type_Date* DerivationExpression::release_date() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.date) if (_internal_has_date()) { clear_has_kind(); - ::io::substrait::Type_Date* temp = kind_.date_; + ::substrait::Type_Date* temp = kind_.date_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5908,48 +5905,48 @@ inline ::io::substrait::Type_Date* DerivationExpression::release_date() { return nullptr; } } -inline const ::io::substrait::Type_Date& DerivationExpression::_internal_date() const { +inline const ::substrait::Type_Date& DerivationExpression::_internal_date() const { return _internal_has_date() ? *kind_.date_ - : reinterpret_cast< ::io::substrait::Type_Date&>(::io::substrait::_Type_Date_default_instance_); + : reinterpret_cast< ::substrait::Type_Date&>(::substrait::_Type_Date_default_instance_); } -inline const ::io::substrait::Type_Date& DerivationExpression::date() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.date) +inline const ::substrait::Type_Date& DerivationExpression::date() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.date) return _internal_date(); } -inline ::io::substrait::Type_Date* DerivationExpression::unsafe_arena_release_date() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.date) +inline ::substrait::Type_Date* DerivationExpression::unsafe_arena_release_date() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.date) if (_internal_has_date()) { clear_has_kind(); - ::io::substrait::Type_Date* temp = kind_.date_; + ::substrait::Type_Date* temp = kind_.date_; kind_.date_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_date(::io::substrait::Type_Date* date) { +inline void DerivationExpression::unsafe_arena_set_allocated_date(::substrait::Type_Date* date) { clear_kind(); if (date) { set_has_date(); kind_.date_ = date; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.date) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.date) } -inline ::io::substrait::Type_Date* DerivationExpression::_internal_mutable_date() { +inline ::substrait::Type_Date* DerivationExpression::_internal_mutable_date() { if (!_internal_has_date()) { clear_kind(); set_has_date(); - kind_.date_ = CreateMaybeMessage< ::io::substrait::Type_Date >(GetArena()); + kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArena()); } return kind_.date_; } -inline ::io::substrait::Type_Date* DerivationExpression::mutable_date() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.date) +inline ::substrait::Type_Date* DerivationExpression::mutable_date() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.date) return _internal_mutable_date(); } -// .io.substrait.Type.Time time = 17; +// .substrait.Type.Time time = 17; inline bool DerivationExpression::_internal_has_time() const { return kind_case() == kTime; } @@ -5959,11 +5956,11 @@ inline bool DerivationExpression::has_time() const { inline void DerivationExpression::set_has_time() { _oneof_case_[0] = kTime; } -inline ::io::substrait::Type_Time* DerivationExpression::release_time() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.time) +inline ::substrait::Type_Time* DerivationExpression::release_time() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.time) if (_internal_has_time()) { clear_has_kind(); - ::io::substrait::Type_Time* temp = kind_.time_; + ::substrait::Type_Time* temp = kind_.time_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -5973,48 +5970,48 @@ inline ::io::substrait::Type_Time* DerivationExpression::release_time() { return nullptr; } } -inline const ::io::substrait::Type_Time& DerivationExpression::_internal_time() const { +inline const ::substrait::Type_Time& DerivationExpression::_internal_time() const { return _internal_has_time() ? *kind_.time_ - : reinterpret_cast< ::io::substrait::Type_Time&>(::io::substrait::_Type_Time_default_instance_); + : reinterpret_cast< ::substrait::Type_Time&>(::substrait::_Type_Time_default_instance_); } -inline const ::io::substrait::Type_Time& DerivationExpression::time() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.time) +inline const ::substrait::Type_Time& DerivationExpression::time() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.time) return _internal_time(); } -inline ::io::substrait::Type_Time* DerivationExpression::unsafe_arena_release_time() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.time) +inline ::substrait::Type_Time* DerivationExpression::unsafe_arena_release_time() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.time) if (_internal_has_time()) { clear_has_kind(); - ::io::substrait::Type_Time* temp = kind_.time_; + ::substrait::Type_Time* temp = kind_.time_; kind_.time_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_time(::io::substrait::Type_Time* time) { +inline void DerivationExpression::unsafe_arena_set_allocated_time(::substrait::Type_Time* time) { clear_kind(); if (time) { set_has_time(); kind_.time_ = time; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.time) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.time) } -inline ::io::substrait::Type_Time* DerivationExpression::_internal_mutable_time() { +inline ::substrait::Type_Time* DerivationExpression::_internal_mutable_time() { if (!_internal_has_time()) { clear_kind(); set_has_time(); - kind_.time_ = CreateMaybeMessage< ::io::substrait::Type_Time >(GetArena()); + kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArena()); } return kind_.time_; } -inline ::io::substrait::Type_Time* DerivationExpression::mutable_time() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.time) +inline ::substrait::Type_Time* DerivationExpression::mutable_time() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.time) return _internal_mutable_time(); } -// .io.substrait.Type.IntervalYear interval_year = 19; +// .substrait.Type.IntervalYear interval_year = 19; inline bool DerivationExpression::_internal_has_interval_year() const { return kind_case() == kIntervalYear; } @@ -6024,11 +6021,11 @@ inline bool DerivationExpression::has_interval_year() const { inline void DerivationExpression::set_has_interval_year() { _oneof_case_[0] = kIntervalYear; } -inline ::io::substrait::Type_IntervalYear* DerivationExpression::release_interval_year() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.interval_year) +inline ::substrait::Type_IntervalYear* DerivationExpression::release_interval_year() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.interval_year) if (_internal_has_interval_year()) { clear_has_kind(); - ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + ::substrait::Type_IntervalYear* temp = kind_.interval_year_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6038,48 +6035,48 @@ inline ::io::substrait::Type_IntervalYear* DerivationExpression::release_interva return nullptr; } } -inline const ::io::substrait::Type_IntervalYear& DerivationExpression::_internal_interval_year() const { +inline const ::substrait::Type_IntervalYear& DerivationExpression::_internal_interval_year() const { return _internal_has_interval_year() ? *kind_.interval_year_ - : reinterpret_cast< ::io::substrait::Type_IntervalYear&>(::io::substrait::_Type_IntervalYear_default_instance_); + : reinterpret_cast< ::substrait::Type_IntervalYear&>(::substrait::_Type_IntervalYear_default_instance_); } -inline const ::io::substrait::Type_IntervalYear& DerivationExpression::interval_year() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.interval_year) +inline const ::substrait::Type_IntervalYear& DerivationExpression::interval_year() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.interval_year) return _internal_interval_year(); } -inline ::io::substrait::Type_IntervalYear* DerivationExpression::unsafe_arena_release_interval_year() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.interval_year) +inline ::substrait::Type_IntervalYear* DerivationExpression::unsafe_arena_release_interval_year() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.interval_year) if (_internal_has_interval_year()) { clear_has_kind(); - ::io::substrait::Type_IntervalYear* temp = kind_.interval_year_; + ::substrait::Type_IntervalYear* temp = kind_.interval_year_; kind_.interval_year_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_interval_year(::io::substrait::Type_IntervalYear* interval_year) { +inline void DerivationExpression::unsafe_arena_set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { clear_kind(); if (interval_year) { set_has_interval_year(); kind_.interval_year_ = interval_year; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.interval_year) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.interval_year) } -inline ::io::substrait::Type_IntervalYear* DerivationExpression::_internal_mutable_interval_year() { +inline ::substrait::Type_IntervalYear* DerivationExpression::_internal_mutable_interval_year() { if (!_internal_has_interval_year()) { clear_kind(); set_has_interval_year(); - kind_.interval_year_ = CreateMaybeMessage< ::io::substrait::Type_IntervalYear >(GetArena()); + kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArena()); } return kind_.interval_year_; } -inline ::io::substrait::Type_IntervalYear* DerivationExpression::mutable_interval_year() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.interval_year) +inline ::substrait::Type_IntervalYear* DerivationExpression::mutable_interval_year() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.interval_year) return _internal_mutable_interval_year(); } -// .io.substrait.Type.IntervalDay interval_day = 20; +// .substrait.Type.IntervalDay interval_day = 20; inline bool DerivationExpression::_internal_has_interval_day() const { return kind_case() == kIntervalDay; } @@ -6089,11 +6086,11 @@ inline bool DerivationExpression::has_interval_day() const { inline void DerivationExpression::set_has_interval_day() { _oneof_case_[0] = kIntervalDay; } -inline ::io::substrait::Type_IntervalDay* DerivationExpression::release_interval_day() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.interval_day) +inline ::substrait::Type_IntervalDay* DerivationExpression::release_interval_day() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.interval_day) if (_internal_has_interval_day()) { clear_has_kind(); - ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + ::substrait::Type_IntervalDay* temp = kind_.interval_day_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6103,48 +6100,48 @@ inline ::io::substrait::Type_IntervalDay* DerivationExpression::release_interval return nullptr; } } -inline const ::io::substrait::Type_IntervalDay& DerivationExpression::_internal_interval_day() const { +inline const ::substrait::Type_IntervalDay& DerivationExpression::_internal_interval_day() const { return _internal_has_interval_day() ? *kind_.interval_day_ - : reinterpret_cast< ::io::substrait::Type_IntervalDay&>(::io::substrait::_Type_IntervalDay_default_instance_); + : reinterpret_cast< ::substrait::Type_IntervalDay&>(::substrait::_Type_IntervalDay_default_instance_); } -inline const ::io::substrait::Type_IntervalDay& DerivationExpression::interval_day() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.interval_day) +inline const ::substrait::Type_IntervalDay& DerivationExpression::interval_day() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.interval_day) return _internal_interval_day(); } -inline ::io::substrait::Type_IntervalDay* DerivationExpression::unsafe_arena_release_interval_day() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.interval_day) +inline ::substrait::Type_IntervalDay* DerivationExpression::unsafe_arena_release_interval_day() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.interval_day) if (_internal_has_interval_day()) { clear_has_kind(); - ::io::substrait::Type_IntervalDay* temp = kind_.interval_day_; + ::substrait::Type_IntervalDay* temp = kind_.interval_day_; kind_.interval_day_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_interval_day(::io::substrait::Type_IntervalDay* interval_day) { +inline void DerivationExpression::unsafe_arena_set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { clear_kind(); if (interval_day) { set_has_interval_day(); kind_.interval_day_ = interval_day; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.interval_day) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.interval_day) } -inline ::io::substrait::Type_IntervalDay* DerivationExpression::_internal_mutable_interval_day() { +inline ::substrait::Type_IntervalDay* DerivationExpression::_internal_mutable_interval_day() { if (!_internal_has_interval_day()) { clear_kind(); set_has_interval_day(); - kind_.interval_day_ = CreateMaybeMessage< ::io::substrait::Type_IntervalDay >(GetArena()); + kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArena()); } return kind_.interval_day_; } -inline ::io::substrait::Type_IntervalDay* DerivationExpression::mutable_interval_day() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.interval_day) +inline ::substrait::Type_IntervalDay* DerivationExpression::mutable_interval_day() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.interval_day) return _internal_mutable_interval_day(); } -// .io.substrait.Type.TimestampTZ timestamp_tz = 29; +// .substrait.Type.TimestampTZ timestamp_tz = 29; inline bool DerivationExpression::_internal_has_timestamp_tz() const { return kind_case() == kTimestampTz; } @@ -6154,11 +6151,11 @@ inline bool DerivationExpression::has_timestamp_tz() const { inline void DerivationExpression::set_has_timestamp_tz() { _oneof_case_[0] = kTimestampTz; } -inline ::io::substrait::Type_TimestampTZ* DerivationExpression::release_timestamp_tz() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.timestamp_tz) +inline ::substrait::Type_TimestampTZ* DerivationExpression::release_timestamp_tz() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.timestamp_tz) if (_internal_has_timestamp_tz()) { clear_has_kind(); - ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6168,48 +6165,48 @@ inline ::io::substrait::Type_TimestampTZ* DerivationExpression::release_timestam return nullptr; } } -inline const ::io::substrait::Type_TimestampTZ& DerivationExpression::_internal_timestamp_tz() const { +inline const ::substrait::Type_TimestampTZ& DerivationExpression::_internal_timestamp_tz() const { return _internal_has_timestamp_tz() ? *kind_.timestamp_tz_ - : reinterpret_cast< ::io::substrait::Type_TimestampTZ&>(::io::substrait::_Type_TimestampTZ_default_instance_); + : reinterpret_cast< ::substrait::Type_TimestampTZ&>(::substrait::_Type_TimestampTZ_default_instance_); } -inline const ::io::substrait::Type_TimestampTZ& DerivationExpression::timestamp_tz() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.timestamp_tz) +inline const ::substrait::Type_TimestampTZ& DerivationExpression::timestamp_tz() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.timestamp_tz) return _internal_timestamp_tz(); } -inline ::io::substrait::Type_TimestampTZ* DerivationExpression::unsafe_arena_release_timestamp_tz() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.timestamp_tz) +inline ::substrait::Type_TimestampTZ* DerivationExpression::unsafe_arena_release_timestamp_tz() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.timestamp_tz) if (_internal_has_timestamp_tz()) { clear_has_kind(); - ::io::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; + ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; kind_.timestamp_tz_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_timestamp_tz(::io::substrait::Type_TimestampTZ* timestamp_tz) { +inline void DerivationExpression::unsafe_arena_set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { clear_kind(); if (timestamp_tz) { set_has_timestamp_tz(); kind_.timestamp_tz_ = timestamp_tz; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.timestamp_tz) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.timestamp_tz) } -inline ::io::substrait::Type_TimestampTZ* DerivationExpression::_internal_mutable_timestamp_tz() { +inline ::substrait::Type_TimestampTZ* DerivationExpression::_internal_mutable_timestamp_tz() { if (!_internal_has_timestamp_tz()) { clear_kind(); set_has_timestamp_tz(); - kind_.timestamp_tz_ = CreateMaybeMessage< ::io::substrait::Type_TimestampTZ >(GetArena()); + kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArena()); } return kind_.timestamp_tz_; } -inline ::io::substrait::Type_TimestampTZ* DerivationExpression::mutable_timestamp_tz() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.timestamp_tz) +inline ::substrait::Type_TimestampTZ* DerivationExpression::mutable_timestamp_tz() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.timestamp_tz) return _internal_mutable_timestamp_tz(); } -// .io.substrait.Type.UUID uuid = 32; +// .substrait.Type.UUID uuid = 32; inline bool DerivationExpression::_internal_has_uuid() const { return kind_case() == kUuid; } @@ -6219,11 +6216,11 @@ inline bool DerivationExpression::has_uuid() const { inline void DerivationExpression::set_has_uuid() { _oneof_case_[0] = kUuid; } -inline ::io::substrait::Type_UUID* DerivationExpression::release_uuid() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.uuid) +inline ::substrait::Type_UUID* DerivationExpression::release_uuid() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.uuid) if (_internal_has_uuid()) { clear_has_kind(); - ::io::substrait::Type_UUID* temp = kind_.uuid_; + ::substrait::Type_UUID* temp = kind_.uuid_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6233,48 +6230,48 @@ inline ::io::substrait::Type_UUID* DerivationExpression::release_uuid() { return nullptr; } } -inline const ::io::substrait::Type_UUID& DerivationExpression::_internal_uuid() const { +inline const ::substrait::Type_UUID& DerivationExpression::_internal_uuid() const { return _internal_has_uuid() ? *kind_.uuid_ - : reinterpret_cast< ::io::substrait::Type_UUID&>(::io::substrait::_Type_UUID_default_instance_); + : reinterpret_cast< ::substrait::Type_UUID&>(::substrait::_Type_UUID_default_instance_); } -inline const ::io::substrait::Type_UUID& DerivationExpression::uuid() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.uuid) +inline const ::substrait::Type_UUID& DerivationExpression::uuid() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.uuid) return _internal_uuid(); } -inline ::io::substrait::Type_UUID* DerivationExpression::unsafe_arena_release_uuid() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.uuid) +inline ::substrait::Type_UUID* DerivationExpression::unsafe_arena_release_uuid() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.uuid) if (_internal_has_uuid()) { clear_has_kind(); - ::io::substrait::Type_UUID* temp = kind_.uuid_; + ::substrait::Type_UUID* temp = kind_.uuid_; kind_.uuid_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_uuid(::io::substrait::Type_UUID* uuid) { +inline void DerivationExpression::unsafe_arena_set_allocated_uuid(::substrait::Type_UUID* uuid) { clear_kind(); if (uuid) { set_has_uuid(); kind_.uuid_ = uuid; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.uuid) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.uuid) } -inline ::io::substrait::Type_UUID* DerivationExpression::_internal_mutable_uuid() { +inline ::substrait::Type_UUID* DerivationExpression::_internal_mutable_uuid() { if (!_internal_has_uuid()) { clear_kind(); set_has_uuid(); - kind_.uuid_ = CreateMaybeMessage< ::io::substrait::Type_UUID >(GetArena()); + kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArena()); } return kind_.uuid_; } -inline ::io::substrait::Type_UUID* DerivationExpression::mutable_uuid() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.uuid) +inline ::substrait::Type_UUID* DerivationExpression::mutable_uuid() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.uuid) return _internal_mutable_uuid(); } -// .io.substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; +// .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; inline bool DerivationExpression::_internal_has_fixed_char() const { return kind_case() == kFixedChar; } @@ -6292,11 +6289,11 @@ inline void DerivationExpression::clear_fixed_char() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::release_fixed_char() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.fixed_char) +inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::release_fixed_char() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fixed_char) if (_internal_has_fixed_char()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_; + ::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6306,48 +6303,48 @@ inline ::io::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpr return nullptr; } } -inline const ::io::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::_internal_fixed_char() const { +inline const ::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::_internal_fixed_char() const { return _internal_has_fixed_char() ? *kind_.fixed_char_ - : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionFixedChar&>(::io::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_ExpressionFixedChar&>(::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_); } -inline const ::io::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::fixed_char() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.fixed_char) +inline const ::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::fixed_char() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fixed_char) return _internal_fixed_char(); } -inline ::io::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::unsafe_arena_release_fixed_char() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.fixed_char) +inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::unsafe_arena_release_fixed_char() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fixed_char) if (_internal_has_fixed_char()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_; + ::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_; kind_.fixed_char_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_fixed_char(::io::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) { +inline void DerivationExpression::unsafe_arena_set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) { clear_kind(); if (fixed_char) { set_has_fixed_char(); kind_.fixed_char_ = fixed_char; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.fixed_char) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fixed_char) } -inline ::io::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::_internal_mutable_fixed_char() { +inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::_internal_mutable_fixed_char() { if (!_internal_has_fixed_char()) { clear_kind(); set_has_fixed_char(); - kind_.fixed_char_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionFixedChar >(GetArena()); + kind_.fixed_char_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedChar >(GetArena()); } return kind_.fixed_char_; } -inline ::io::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::mutable_fixed_char() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.fixed_char) +inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::mutable_fixed_char() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fixed_char) return _internal_mutable_fixed_char(); } -// .io.substrait.DerivationExpression.ExpressionVarChar varchar = 22; +// .substrait.DerivationExpression.ExpressionVarChar varchar = 22; inline bool DerivationExpression::_internal_has_varchar() const { return kind_case() == kVarchar; } @@ -6365,11 +6362,11 @@ inline void DerivationExpression::clear_varchar() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::release_varchar() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.varchar) +inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::release_varchar() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.varchar) if (_internal_has_varchar()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_; + ::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6379,48 +6376,48 @@ inline ::io::substrait::DerivationExpression_ExpressionVarChar* DerivationExpres return nullptr; } } -inline const ::io::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::_internal_varchar() const { +inline const ::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::_internal_varchar() const { return _internal_has_varchar() ? *kind_.varchar_ - : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionVarChar&>(::io::substrait::_DerivationExpression_ExpressionVarChar_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_ExpressionVarChar&>(::substrait::_DerivationExpression_ExpressionVarChar_default_instance_); } -inline const ::io::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::varchar() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.varchar) +inline const ::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::varchar() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.varchar) return _internal_varchar(); } -inline ::io::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::unsafe_arena_release_varchar() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.varchar) +inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::unsafe_arena_release_varchar() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.varchar) if (_internal_has_varchar()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_; + ::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_; kind_.varchar_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_varchar(::io::substrait::DerivationExpression_ExpressionVarChar* varchar) { +inline void DerivationExpression::unsafe_arena_set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar) { clear_kind(); if (varchar) { set_has_varchar(); kind_.varchar_ = varchar; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.varchar) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.varchar) } -inline ::io::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::_internal_mutable_varchar() { +inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::_internal_mutable_varchar() { if (!_internal_has_varchar()) { clear_kind(); set_has_varchar(); - kind_.varchar_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionVarChar >(GetArena()); + kind_.varchar_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionVarChar >(GetArena()); } return kind_.varchar_; } -inline ::io::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::mutable_varchar() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.varchar) +inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::mutable_varchar() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.varchar) return _internal_mutable_varchar(); } -// .io.substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; +// .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; inline bool DerivationExpression::_internal_has_fixed_binary() const { return kind_case() == kFixedBinary; } @@ -6438,11 +6435,11 @@ inline void DerivationExpression::clear_fixed_binary() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::release_fixed_binary() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.fixed_binary) +inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::release_fixed_binary() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fixed_binary) if (_internal_has_fixed_binary()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_; + ::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6452,48 +6449,48 @@ inline ::io::substrait::DerivationExpression_ExpressionFixedBinary* DerivationEx return nullptr; } } -inline const ::io::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::_internal_fixed_binary() const { +inline const ::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::_internal_fixed_binary() const { return _internal_has_fixed_binary() ? *kind_.fixed_binary_ - : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionFixedBinary&>(::io::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_ExpressionFixedBinary&>(::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_); } -inline const ::io::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::fixed_binary() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.fixed_binary) +inline const ::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::fixed_binary() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fixed_binary) return _internal_fixed_binary(); } -inline ::io::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::unsafe_arena_release_fixed_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.fixed_binary) +inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::unsafe_arena_release_fixed_binary() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fixed_binary) if (_internal_has_fixed_binary()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_; + ::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_; kind_.fixed_binary_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_fixed_binary(::io::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) { +inline void DerivationExpression::unsafe_arena_set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) { clear_kind(); if (fixed_binary) { set_has_fixed_binary(); kind_.fixed_binary_ = fixed_binary; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.fixed_binary) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fixed_binary) } -inline ::io::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::_internal_mutable_fixed_binary() { +inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::_internal_mutable_fixed_binary() { if (!_internal_has_fixed_binary()) { clear_kind(); set_has_fixed_binary(); - kind_.fixed_binary_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionFixedBinary >(GetArena()); + kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedBinary >(GetArena()); } return kind_.fixed_binary_; } -inline ::io::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::mutable_fixed_binary() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.fixed_binary) +inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::mutable_fixed_binary() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fixed_binary) return _internal_mutable_fixed_binary(); } -// .io.substrait.DerivationExpression.ExpressionDecimal decimal = 24; +// .substrait.DerivationExpression.ExpressionDecimal decimal = 24; inline bool DerivationExpression::_internal_has_decimal() const { return kind_case() == kDecimal; } @@ -6511,11 +6508,11 @@ inline void DerivationExpression::clear_decimal() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::release_decimal() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.decimal) +inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::release_decimal() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.decimal) if (_internal_has_decimal()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_; + ::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6525,48 +6522,48 @@ inline ::io::substrait::DerivationExpression_ExpressionDecimal* DerivationExpres return nullptr; } } -inline const ::io::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::_internal_decimal() const { +inline const ::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::_internal_decimal() const { return _internal_has_decimal() ? *kind_.decimal_ - : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionDecimal&>(::io::substrait::_DerivationExpression_ExpressionDecimal_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_ExpressionDecimal&>(::substrait::_DerivationExpression_ExpressionDecimal_default_instance_); } -inline const ::io::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::decimal() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.decimal) +inline const ::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::decimal() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.decimal) return _internal_decimal(); } -inline ::io::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::unsafe_arena_release_decimal() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.decimal) +inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::unsafe_arena_release_decimal() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.decimal) if (_internal_has_decimal()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_; + ::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_; kind_.decimal_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_decimal(::io::substrait::DerivationExpression_ExpressionDecimal* decimal) { +inline void DerivationExpression::unsafe_arena_set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal) { clear_kind(); if (decimal) { set_has_decimal(); kind_.decimal_ = decimal; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.decimal) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.decimal) } -inline ::io::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::_internal_mutable_decimal() { +inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::_internal_mutable_decimal() { if (!_internal_has_decimal()) { clear_kind(); set_has_decimal(); - kind_.decimal_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionDecimal >(GetArena()); + kind_.decimal_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionDecimal >(GetArena()); } return kind_.decimal_; } -inline ::io::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::mutable_decimal() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.decimal) +inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::mutable_decimal() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.decimal) return _internal_mutable_decimal(); } -// .io.substrait.DerivationExpression.ExpressionStruct struct = 25; +// .substrait.DerivationExpression.ExpressionStruct struct = 25; inline bool DerivationExpression::_internal_has_struct_() const { return kind_case() == kStruct; } @@ -6584,11 +6581,11 @@ inline void DerivationExpression::clear_struct_() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::release_struct_() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.struct) +inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::release_struct_() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.struct) if (_internal_has_struct_()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__; + ::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6598,48 +6595,48 @@ inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpress return nullptr; } } -inline const ::io::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::_internal_struct_() const { +inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::_internal_struct_() const { return _internal_has_struct_() ? *kind_.struct__ - : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionStruct&>(::io::substrait::_DerivationExpression_ExpressionStruct_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_ExpressionStruct&>(::substrait::_DerivationExpression_ExpressionStruct_default_instance_); } -inline const ::io::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::struct_() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.struct) +inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::struct_() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.struct) return _internal_struct_(); } -inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.struct) +inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::unsafe_arena_release_struct_() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.struct) if (_internal_has_struct_()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__; + ::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__; kind_.struct__ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_struct_(::io::substrait::DerivationExpression_ExpressionStruct* struct_) { +inline void DerivationExpression::unsafe_arena_set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) { clear_kind(); if (struct_) { set_has_struct_(); kind_.struct__ = struct_; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.struct) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.struct) } -inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::_internal_mutable_struct_() { +inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::_internal_mutable_struct_() { if (!_internal_has_struct_()) { clear_kind(); set_has_struct_(); - kind_.struct__ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionStruct >(GetArena()); + kind_.struct__ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionStruct >(GetArena()); } return kind_.struct__; } -inline ::io::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::mutable_struct_() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.struct) +inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::mutable_struct_() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.struct) return _internal_mutable_struct_(); } -// .io.substrait.DerivationExpression.ExpressionList list = 27; +// .substrait.DerivationExpression.ExpressionList list = 27; inline bool DerivationExpression::_internal_has_list() const { return kind_case() == kList; } @@ -6657,11 +6654,11 @@ inline void DerivationExpression::clear_list() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_ExpressionList* DerivationExpression::release_list() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.list) +inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::release_list() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.list) if (_internal_has_list()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionList* temp = kind_.list_; + ::substrait::DerivationExpression_ExpressionList* temp = kind_.list_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6671,48 +6668,48 @@ inline ::io::substrait::DerivationExpression_ExpressionList* DerivationExpressio return nullptr; } } -inline const ::io::substrait::DerivationExpression_ExpressionList& DerivationExpression::_internal_list() const { +inline const ::substrait::DerivationExpression_ExpressionList& DerivationExpression::_internal_list() const { return _internal_has_list() ? *kind_.list_ - : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionList&>(::io::substrait::_DerivationExpression_ExpressionList_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_ExpressionList&>(::substrait::_DerivationExpression_ExpressionList_default_instance_); } -inline const ::io::substrait::DerivationExpression_ExpressionList& DerivationExpression::list() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.list) +inline const ::substrait::DerivationExpression_ExpressionList& DerivationExpression::list() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.list) return _internal_list(); } -inline ::io::substrait::DerivationExpression_ExpressionList* DerivationExpression::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.list) +inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::unsafe_arena_release_list() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.list) if (_internal_has_list()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionList* temp = kind_.list_; + ::substrait::DerivationExpression_ExpressionList* temp = kind_.list_; kind_.list_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_list(::io::substrait::DerivationExpression_ExpressionList* list) { +inline void DerivationExpression::unsafe_arena_set_allocated_list(::substrait::DerivationExpression_ExpressionList* list) { clear_kind(); if (list) { set_has_list(); kind_.list_ = list; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.list) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.list) } -inline ::io::substrait::DerivationExpression_ExpressionList* DerivationExpression::_internal_mutable_list() { +inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::_internal_mutable_list() { if (!_internal_has_list()) { clear_kind(); set_has_list(); - kind_.list_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionList >(GetArena()); + kind_.list_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionList >(GetArena()); } return kind_.list_; } -inline ::io::substrait::DerivationExpression_ExpressionList* DerivationExpression::mutable_list() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.list) +inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::mutable_list() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.list) return _internal_mutable_list(); } -// .io.substrait.DerivationExpression.ExpressionMap map = 28; +// .substrait.DerivationExpression.ExpressionMap map = 28; inline bool DerivationExpression::_internal_has_map() const { return kind_case() == kMap; } @@ -6730,11 +6727,11 @@ inline void DerivationExpression::clear_map() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_ExpressionMap* DerivationExpression::release_map() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.map) +inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::release_map() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.map) if (_internal_has_map()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_; + ::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -6744,44 +6741,44 @@ inline ::io::substrait::DerivationExpression_ExpressionMap* DerivationExpression return nullptr; } } -inline const ::io::substrait::DerivationExpression_ExpressionMap& DerivationExpression::_internal_map() const { +inline const ::substrait::DerivationExpression_ExpressionMap& DerivationExpression::_internal_map() const { return _internal_has_map() ? *kind_.map_ - : reinterpret_cast< ::io::substrait::DerivationExpression_ExpressionMap&>(::io::substrait::_DerivationExpression_ExpressionMap_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_ExpressionMap&>(::substrait::_DerivationExpression_ExpressionMap_default_instance_); } -inline const ::io::substrait::DerivationExpression_ExpressionMap& DerivationExpression::map() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.map) +inline const ::substrait::DerivationExpression_ExpressionMap& DerivationExpression::map() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.map) return _internal_map(); } -inline ::io::substrait::DerivationExpression_ExpressionMap* DerivationExpression::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.map) +inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::unsafe_arena_release_map() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.map) if (_internal_has_map()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_; + ::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_; kind_.map_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_map(::io::substrait::DerivationExpression_ExpressionMap* map) { +inline void DerivationExpression::unsafe_arena_set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map) { clear_kind(); if (map) { set_has_map(); kind_.map_ = map; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.map) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.map) } -inline ::io::substrait::DerivationExpression_ExpressionMap* DerivationExpression::_internal_mutable_map() { +inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::_internal_mutable_map() { if (!_internal_has_map()) { clear_kind(); set_has_map(); - kind_.map_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ExpressionMap >(GetArena()); + kind_.map_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionMap >(GetArena()); } return kind_.map_; } -inline ::io::substrait::DerivationExpression_ExpressionMap* DerivationExpression::mutable_map() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.map) +inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::mutable_map() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.map) return _internal_mutable_map(); } @@ -6815,12 +6812,12 @@ inline void DerivationExpression::_internal_set_user_defined_pointer(::PROTOBUF_ kind_.user_defined_pointer_ = value; } inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression::user_defined_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.user_defined_pointer) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.user_defined_pointer) return _internal_user_defined_pointer(); } inline void DerivationExpression::set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { _internal_set_user_defined_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.user_defined_pointer) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.user_defined_pointer) } // string type_parameter_name = 33; @@ -6840,7 +6837,7 @@ inline void DerivationExpression::clear_type_parameter_name() { } } inline const std::string& DerivationExpression::type_parameter_name() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.type_parameter_name) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.type_parameter_name) return _internal_type_parameter_name(); } template @@ -6851,10 +6848,10 @@ inline void DerivationExpression::set_type_parameter_name(ArgT0&& arg0, ArgT... kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.type_parameter_name) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.type_parameter_name) } inline std::string* DerivationExpression::mutable_type_parameter_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.type_parameter_name) + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.type_parameter_name) return _internal_mutable_type_parameter_name(); } inline const std::string& DerivationExpression::_internal_type_parameter_name() const { @@ -6881,7 +6878,7 @@ inline std::string* DerivationExpression::_internal_mutable_type_parameter_name( ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* DerivationExpression::release_type_parameter_name() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.type_parameter_name) + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.type_parameter_name) if (_internal_has_type_parameter_name()) { clear_has_kind(); return kind_.type_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -6901,7 +6898,7 @@ inline void DerivationExpression::set_allocated_type_parameter_name(std::string* arena->Own(type_parameter_name); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.type_parameter_name) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.type_parameter_name) } // string integer_parameter_name = 34; @@ -6921,7 +6918,7 @@ inline void DerivationExpression::clear_integer_parameter_name() { } } inline const std::string& DerivationExpression::integer_parameter_name() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.integer_parameter_name) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.integer_parameter_name) return _internal_integer_parameter_name(); } template @@ -6932,10 +6929,10 @@ inline void DerivationExpression::set_integer_parameter_name(ArgT0&& arg0, ArgT. kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.integer_parameter_name) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.integer_parameter_name) } inline std::string* DerivationExpression::mutable_integer_parameter_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.integer_parameter_name) + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.integer_parameter_name) return _internal_mutable_integer_parameter_name(); } inline const std::string& DerivationExpression::_internal_integer_parameter_name() const { @@ -6962,7 +6959,7 @@ inline std::string* DerivationExpression::_internal_mutable_integer_parameter_na ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); } inline std::string* DerivationExpression::release_integer_parameter_name() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.integer_parameter_name) + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.integer_parameter_name) if (_internal_has_integer_parameter_name()) { clear_has_kind(); return kind_.integer_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); @@ -6982,7 +6979,7 @@ inline void DerivationExpression::set_allocated_integer_parameter_name(std::stri arena->Own(integer_parameter_name); } } - // @@protoc_insertion_point(field_set_allocated:io.substrait.DerivationExpression.integer_parameter_name) + // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.integer_parameter_name) } // int32 integer_literal = 35; @@ -7015,15 +7012,15 @@ inline void DerivationExpression::_internal_set_integer_literal(::PROTOBUF_NAMES kind_.integer_literal_ = value; } inline ::PROTOBUF_NAMESPACE_ID::int32 DerivationExpression::integer_literal() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.integer_literal) + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.integer_literal) return _internal_integer_literal(); } inline void DerivationExpression::set_integer_literal(::PROTOBUF_NAMESPACE_ID::int32 value) { _internal_set_integer_literal(value); - // @@protoc_insertion_point(field_set:io.substrait.DerivationExpression.integer_literal) + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.integer_literal) } -// .io.substrait.DerivationExpression.UnaryOp unary_op = 36; +// .substrait.DerivationExpression.UnaryOp unary_op = 36; inline bool DerivationExpression::_internal_has_unary_op() const { return kind_case() == kUnaryOp; } @@ -7041,11 +7038,11 @@ inline void DerivationExpression::clear_unary_op() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_UnaryOp* DerivationExpression::release_unary_op() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.unary_op) +inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::release_unary_op() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.unary_op) if (_internal_has_unary_op()) { clear_has_kind(); - ::io::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_; + ::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7055,48 +7052,48 @@ inline ::io::substrait::DerivationExpression_UnaryOp* DerivationExpression::rele return nullptr; } } -inline const ::io::substrait::DerivationExpression_UnaryOp& DerivationExpression::_internal_unary_op() const { +inline const ::substrait::DerivationExpression_UnaryOp& DerivationExpression::_internal_unary_op() const { return _internal_has_unary_op() ? *kind_.unary_op_ - : reinterpret_cast< ::io::substrait::DerivationExpression_UnaryOp&>(::io::substrait::_DerivationExpression_UnaryOp_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_UnaryOp&>(::substrait::_DerivationExpression_UnaryOp_default_instance_); } -inline const ::io::substrait::DerivationExpression_UnaryOp& DerivationExpression::unary_op() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.unary_op) +inline const ::substrait::DerivationExpression_UnaryOp& DerivationExpression::unary_op() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.unary_op) return _internal_unary_op(); } -inline ::io::substrait::DerivationExpression_UnaryOp* DerivationExpression::unsafe_arena_release_unary_op() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.unary_op) +inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::unsafe_arena_release_unary_op() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.unary_op) if (_internal_has_unary_op()) { clear_has_kind(); - ::io::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_; + ::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_; kind_.unary_op_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_unary_op(::io::substrait::DerivationExpression_UnaryOp* unary_op) { +inline void DerivationExpression::unsafe_arena_set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op) { clear_kind(); if (unary_op) { set_has_unary_op(); kind_.unary_op_ = unary_op; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.unary_op) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.unary_op) } -inline ::io::substrait::DerivationExpression_UnaryOp* DerivationExpression::_internal_mutable_unary_op() { +inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::_internal_mutable_unary_op() { if (!_internal_has_unary_op()) { clear_kind(); set_has_unary_op(); - kind_.unary_op_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_UnaryOp >(GetArena()); + kind_.unary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_UnaryOp >(GetArena()); } return kind_.unary_op_; } -inline ::io::substrait::DerivationExpression_UnaryOp* DerivationExpression::mutable_unary_op() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.unary_op) +inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::mutable_unary_op() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.unary_op) return _internal_mutable_unary_op(); } -// .io.substrait.DerivationExpression.BinaryOp binary_op = 37; +// .substrait.DerivationExpression.BinaryOp binary_op = 37; inline bool DerivationExpression::_internal_has_binary_op() const { return kind_case() == kBinaryOp; } @@ -7114,11 +7111,11 @@ inline void DerivationExpression::clear_binary_op() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_BinaryOp* DerivationExpression::release_binary_op() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.binary_op) +inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::release_binary_op() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.binary_op) if (_internal_has_binary_op()) { clear_has_kind(); - ::io::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_; + ::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7128,48 +7125,48 @@ inline ::io::substrait::DerivationExpression_BinaryOp* DerivationExpression::rel return nullptr; } } -inline const ::io::substrait::DerivationExpression_BinaryOp& DerivationExpression::_internal_binary_op() const { +inline const ::substrait::DerivationExpression_BinaryOp& DerivationExpression::_internal_binary_op() const { return _internal_has_binary_op() ? *kind_.binary_op_ - : reinterpret_cast< ::io::substrait::DerivationExpression_BinaryOp&>(::io::substrait::_DerivationExpression_BinaryOp_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_BinaryOp&>(::substrait::_DerivationExpression_BinaryOp_default_instance_); } -inline const ::io::substrait::DerivationExpression_BinaryOp& DerivationExpression::binary_op() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.binary_op) +inline const ::substrait::DerivationExpression_BinaryOp& DerivationExpression::binary_op() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.binary_op) return _internal_binary_op(); } -inline ::io::substrait::DerivationExpression_BinaryOp* DerivationExpression::unsafe_arena_release_binary_op() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.binary_op) +inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::unsafe_arena_release_binary_op() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.binary_op) if (_internal_has_binary_op()) { clear_has_kind(); - ::io::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_; + ::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_; kind_.binary_op_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_binary_op(::io::substrait::DerivationExpression_BinaryOp* binary_op) { +inline void DerivationExpression::unsafe_arena_set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op) { clear_kind(); if (binary_op) { set_has_binary_op(); kind_.binary_op_ = binary_op; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.binary_op) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.binary_op) } -inline ::io::substrait::DerivationExpression_BinaryOp* DerivationExpression::_internal_mutable_binary_op() { +inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::_internal_mutable_binary_op() { if (!_internal_has_binary_op()) { clear_kind(); set_has_binary_op(); - kind_.binary_op_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_BinaryOp >(GetArena()); + kind_.binary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_BinaryOp >(GetArena()); } return kind_.binary_op_; } -inline ::io::substrait::DerivationExpression_BinaryOp* DerivationExpression::mutable_binary_op() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.binary_op) +inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::mutable_binary_op() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.binary_op) return _internal_mutable_binary_op(); } -// .io.substrait.DerivationExpression.IfElse if_else = 38; +// .substrait.DerivationExpression.IfElse if_else = 38; inline bool DerivationExpression::_internal_has_if_else() const { return kind_case() == kIfElse; } @@ -7187,11 +7184,11 @@ inline void DerivationExpression::clear_if_else() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_IfElse* DerivationExpression::release_if_else() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.if_else) +inline ::substrait::DerivationExpression_IfElse* DerivationExpression::release_if_else() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.if_else) if (_internal_has_if_else()) { clear_has_kind(); - ::io::substrait::DerivationExpression_IfElse* temp = kind_.if_else_; + ::substrait::DerivationExpression_IfElse* temp = kind_.if_else_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7201,48 +7198,48 @@ inline ::io::substrait::DerivationExpression_IfElse* DerivationExpression::relea return nullptr; } } -inline const ::io::substrait::DerivationExpression_IfElse& DerivationExpression::_internal_if_else() const { +inline const ::substrait::DerivationExpression_IfElse& DerivationExpression::_internal_if_else() const { return _internal_has_if_else() ? *kind_.if_else_ - : reinterpret_cast< ::io::substrait::DerivationExpression_IfElse&>(::io::substrait::_DerivationExpression_IfElse_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_IfElse&>(::substrait::_DerivationExpression_IfElse_default_instance_); } -inline const ::io::substrait::DerivationExpression_IfElse& DerivationExpression::if_else() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.if_else) +inline const ::substrait::DerivationExpression_IfElse& DerivationExpression::if_else() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.if_else) return _internal_if_else(); } -inline ::io::substrait::DerivationExpression_IfElse* DerivationExpression::unsafe_arena_release_if_else() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.if_else) +inline ::substrait::DerivationExpression_IfElse* DerivationExpression::unsafe_arena_release_if_else() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.if_else) if (_internal_has_if_else()) { clear_has_kind(); - ::io::substrait::DerivationExpression_IfElse* temp = kind_.if_else_; + ::substrait::DerivationExpression_IfElse* temp = kind_.if_else_; kind_.if_else_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_if_else(::io::substrait::DerivationExpression_IfElse* if_else) { +inline void DerivationExpression::unsafe_arena_set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else) { clear_kind(); if (if_else) { set_has_if_else(); kind_.if_else_ = if_else; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.if_else) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.if_else) } -inline ::io::substrait::DerivationExpression_IfElse* DerivationExpression::_internal_mutable_if_else() { +inline ::substrait::DerivationExpression_IfElse* DerivationExpression::_internal_mutable_if_else() { if (!_internal_has_if_else()) { clear_kind(); set_has_if_else(); - kind_.if_else_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_IfElse >(GetArena()); + kind_.if_else_ = CreateMaybeMessage< ::substrait::DerivationExpression_IfElse >(GetArena()); } return kind_.if_else_; } -inline ::io::substrait::DerivationExpression_IfElse* DerivationExpression::mutable_if_else() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.if_else) +inline ::substrait::DerivationExpression_IfElse* DerivationExpression::mutable_if_else() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.if_else) return _internal_mutable_if_else(); } -// .io.substrait.DerivationExpression.ReturnProgram return_program = 39; +// .substrait.DerivationExpression.ReturnProgram return_program = 39; inline bool DerivationExpression::_internal_has_return_program() const { return kind_case() == kReturnProgram; } @@ -7260,11 +7257,11 @@ inline void DerivationExpression::clear_return_program() { clear_has_kind(); } } -inline ::io::substrait::DerivationExpression_ReturnProgram* DerivationExpression::release_return_program() { - // @@protoc_insertion_point(field_release:io.substrait.DerivationExpression.return_program) +inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::release_return_program() { + // @@protoc_insertion_point(field_release:substrait.DerivationExpression.return_program) if (_internal_has_return_program()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_; + ::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_; if (GetArena() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } @@ -7274,44 +7271,44 @@ inline ::io::substrait::DerivationExpression_ReturnProgram* DerivationExpression return nullptr; } } -inline const ::io::substrait::DerivationExpression_ReturnProgram& DerivationExpression::_internal_return_program() const { +inline const ::substrait::DerivationExpression_ReturnProgram& DerivationExpression::_internal_return_program() const { return _internal_has_return_program() ? *kind_.return_program_ - : reinterpret_cast< ::io::substrait::DerivationExpression_ReturnProgram&>(::io::substrait::_DerivationExpression_ReturnProgram_default_instance_); + : reinterpret_cast< ::substrait::DerivationExpression_ReturnProgram&>(::substrait::_DerivationExpression_ReturnProgram_default_instance_); } -inline const ::io::substrait::DerivationExpression_ReturnProgram& DerivationExpression::return_program() const { - // @@protoc_insertion_point(field_get:io.substrait.DerivationExpression.return_program) +inline const ::substrait::DerivationExpression_ReturnProgram& DerivationExpression::return_program() const { + // @@protoc_insertion_point(field_get:substrait.DerivationExpression.return_program) return _internal_return_program(); } -inline ::io::substrait::DerivationExpression_ReturnProgram* DerivationExpression::unsafe_arena_release_return_program() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.DerivationExpression.return_program) +inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::unsafe_arena_release_return_program() { + // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.return_program) if (_internal_has_return_program()) { clear_has_kind(); - ::io::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_; + ::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_; kind_.return_program_ = nullptr; return temp; } else { return nullptr; } } -inline void DerivationExpression::unsafe_arena_set_allocated_return_program(::io::substrait::DerivationExpression_ReturnProgram* return_program) { +inline void DerivationExpression::unsafe_arena_set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program) { clear_kind(); if (return_program) { set_has_return_program(); kind_.return_program_ = return_program; } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.DerivationExpression.return_program) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.return_program) } -inline ::io::substrait::DerivationExpression_ReturnProgram* DerivationExpression::_internal_mutable_return_program() { +inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::_internal_mutable_return_program() { if (!_internal_has_return_program()) { clear_kind(); set_has_return_program(); - kind_.return_program_ = CreateMaybeMessage< ::io::substrait::DerivationExpression_ReturnProgram >(GetArena()); + kind_.return_program_ = CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram >(GetArena()); } return kind_.return_program_; } -inline ::io::substrait::DerivationExpression_ReturnProgram* DerivationExpression::mutable_return_program() { - // @@protoc_insertion_point(field_mutable:io.substrait.DerivationExpression.return_program) +inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::mutable_return_program() { + // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.return_program) return _internal_mutable_return_program(); } @@ -7357,19 +7354,18 @@ inline DerivationExpression::KindCase DerivationExpression::kind_case() const { // @@protoc_insertion_point(namespace_scope) } // namespace substrait -} // namespace io PROTOBUF_NAMESPACE_OPEN -template <> struct is_proto_enum< ::io::substrait::DerivationExpression_UnaryOp_OpType> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::DerivationExpression_UnaryOp_UnaryOpType> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::DerivationExpression_UnaryOp_OpType>() { - return ::io::substrait::DerivationExpression_UnaryOp_OpType_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::DerivationExpression_UnaryOp_UnaryOpType>() { + return ::substrait::DerivationExpression_UnaryOp_UnaryOpType_descriptor(); } -template <> struct is_proto_enum< ::io::substrait::DerivationExpression_BinaryOp_OpType> : ::std::true_type {}; +template <> struct is_proto_enum< ::substrait::DerivationExpression_BinaryOp_BinaryOpType> : ::std::true_type {}; template <> -inline const EnumDescriptor* GetEnumDescriptor< ::io::substrait::DerivationExpression_BinaryOp_OpType>() { - return ::io::substrait::DerivationExpression_BinaryOp_OpType_descriptor(); +inline const EnumDescriptor* GetEnumDescriptor< ::substrait::DerivationExpression_BinaryOp_BinaryOpType>() { + return ::substrait::DerivationExpression_BinaryOp_BinaryOpType_descriptor(); } PROTOBUF_NAMESPACE_CLOSE @@ -7377,4 +7373,4 @@ PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_type_5fexpressions_2eproto +#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto From 0b94f3a4f8c4f1a76b66abd3d4524589b846137d Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Tue, 11 Jan 2022 14:33:53 -0500 Subject: [PATCH 028/113] make JSON utils public, add CheckMessagesEquivalent() --- .../engine/substrait/expression_internal.cc | 8 +- cpp/src/arrow/engine/substrait/serde.cc | 100 ++++++++++++++++-- cpp/src/arrow/engine/substrait/serde.h | 15 +++ cpp/src/arrow/engine/substrait/serde_test.cc | 44 ++------ cpp/src/arrow/testing/matchers.h | 5 +- 5 files changed, 122 insertions(+), 50 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 1c3a67fcfb6..5a882349826 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -347,10 +347,13 @@ Result FromProto(const substrait::Expression::Literal& lit) { case substrait::Expression::Literal::kEmptyMap: { ARROW_ASSIGN_OR_RAISE(auto key_type_nullable, FromProto(lit.empty_map().key(), ext_set)); + ARROW_ASSIGN_OR_RAISE(auto keys, + MakeEmptyArray(std::move(key_type_nullable.first))); + ARROW_ASSIGN_OR_RAISE(auto value_type_nullable, FromProto(lit.empty_map().value(), ext_set)); - ARROW_ASSIGN_OR_RAISE(auto keys, MakeEmptyArray(key_type_nullable.first)); - ARROW_ASSIGN_OR_RAISE(auto values, MakeEmptyArray(value_type_nullable.first)); + ARROW_ASSIGN_OR_RAISE(auto values, + MakeEmptyArray(std::move(value_type_nullable.first))); auto map_type = std::make_shared(keys->type(), values->type()); ARROW_ASSIGN_OR_RAISE( @@ -358,6 +361,7 @@ Result FromProto(const substrait::Expression::Literal& lit) { StructArray::Make( {std::move(keys), std::move(values)}, checked_cast(*map_type).value_type()->fields())); + return MapScalar{std::move(key_values)}; } diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc index 6e5d758ff7f..a0e976ecae4 100644 --- a/cpp/src/arrow/engine/substrait/serde.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -20,18 +20,15 @@ #include "arrow/engine/substrait/expression_internal.h" #include "arrow/engine/substrait/type_internal.h" #include "arrow/util/string_view.h" -#include "google/protobuf/io/zero_copy_stream_impl_lite.h" -#include "google/protobuf/message.h" -#include "generated/substrait/plan.pb.h" - -namespace google { -namespace protobuf { - -class Message; +#include +#include +#include +#include +#include +#include -} // namespace protobuf -} // namespace google +#include "generated/substrait/plan.pb.h" namespace arrow { namespace engine { @@ -107,5 +104,88 @@ Result> SerializeExpression(const compute::Expression& e return Buffer::FromString(std::move(serialized)); } +namespace internal { + +template +static Status CheckMessagesEquivalent(const Buffer& l_buf, const Buffer& r_buf) { + ARROW_ASSIGN_OR_RAISE(auto l, ParseFromBuffer(l_buf)); + ARROW_ASSIGN_OR_RAISE(auto r, ParseFromBuffer(r_buf)); + + using google::protobuf::util::MessageDifferencer; + + std::string out; + google::protobuf::io::StringOutputStream out_stream{&out}; + MessageDifferencer::StreamReporter reporter{&out_stream}; + + MessageDifferencer differencer; + differencer.set_message_field_comparison(MessageDifferencer::EQUIVALENT); + differencer.ReportDifferencesTo(&reporter); + + if (differencer.Compare(l, r)) { + return Status::OK(); + } + return Status::Invalid("Messages were not equivalent: ", out); +} + +Status CheckMessagesEquivalent(util::string_view message_name, const Buffer& l_buf, + const Buffer& r_buf) { + if (message_name == "Type") { + return CheckMessagesEquivalent(l_buf, r_buf); + } + + if (message_name == "Expression") { + return CheckMessagesEquivalent(l_buf, r_buf); + } + + return Status::Invalid("Unsupported message name ", message_name, + " for CheckMessagesEquivalent"); +} + +inline google::protobuf::util::TypeResolver* GetGeneratedTypeResolver() { + static std::unique_ptr type_resolver; + if (!type_resolver) { + type_resolver.reset(google::protobuf::util::NewTypeResolverForDescriptorPool( + /*url_prefix=*/"", google::protobuf::DescriptorPool::generated_pool())); + } + return type_resolver.get(); +} + +Result> SubstraitFromJSON(util::string_view type_name, + util::string_view json) { + std::string type_url = "/substrait." + type_name.to_string(); + + google::protobuf::io::ArrayInputStream json_stream{json.data(), + static_cast(json.size())}; + + std::string out; + google::protobuf::io::StringOutputStream out_stream{&out}; + + auto status = google::protobuf::util::JsonToBinaryStream( + GetGeneratedTypeResolver(), type_url, &json_stream, &out_stream); + + if (!status.ok()) { + return Status::Invalid("JsonToBinaryStream returned ", status); + } + return Buffer::FromString(std::move(out)); +} + +Result SubstraitToJSON(util::string_view type_name, const Buffer& buf) { + std::string type_url = "/substrait." + type_name.to_string(); + + google::protobuf::io::ArrayInputStream buf_stream{buf.data(), + static_cast(buf.size())}; + + std::string out; + google::protobuf::io::StringOutputStream out_stream{&out}; + + auto status = google::protobuf::util::BinaryToJsonStream( + GetGeneratedTypeResolver(), type_url, &buf_stream, &out_stream); + if (!status.ok()) { + return Status::Invalid("BinaryToJsonStream returned ", status); + } + return out; +} + +} // namespace internal } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index e1a1e27c9f8..e0239b7b787 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -27,6 +27,7 @@ #include "arrow/engine/substrait/extension_types.h" #include "arrow/engine/visibility.h" #include "arrow/result.h" +#include "arrow/util/string_view.h" namespace arrow { namespace engine { @@ -51,5 +52,19 @@ Result DeserializeExpression(const Buffer&); ARROW_ENGINE_EXPORT Result> SerializeExpression(const compute::Expression&); +namespace internal { + +ARROW_ENGINE_EXPORT +Status CheckMessagesEquivalent(util::string_view message_name, const Buffer&, + const Buffer&); + +ARROW_ENGINE_EXPORT +Result> SubstraitFromJSON(util::string_view type_name, + util::string_view json); + +ARROW_ENGINE_EXPORT +Result SubstraitToJSON(util::string_view type_name, const Buffer& buf); + +} // namespace internal } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 5d6df1749c5..75d452e1447 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -92,46 +92,17 @@ inline compute::Expression UseBoringRefs(const compute::Expression& expr) { return compute::Expression{std::move(modified_call)}; } -google::protobuf::util::TypeResolver* GetGeneratedTypeResolver() { - static std::unique_ptr type_resolver; - if (!type_resolver) { - type_resolver.reset(google::protobuf::util::NewTypeResolverForDescriptorPool( - /*url_prefix=*/"", google::protobuf::DescriptorPool::generated_pool())); - } - return type_resolver.get(); -} - std::shared_ptr SubstraitFromJSON(util::string_view type_name, util::string_view json) { - std::string type_url = "/substrait." + type_name.to_string(); - - google::protobuf::io::ArrayInputStream json_stream{json.data(), - static_cast(json.size())}; - - std::string out; - google::protobuf::io::StringOutputStream out_stream{&out}; - - auto status = google::protobuf::util::JsonToBinaryStream( - GetGeneratedTypeResolver(), type_url, &json_stream, &out_stream); - DCHECK(status.ok()) << "JsonToBinaryStream returned " << status; - - return Buffer::FromString(std::move(out)); + auto maybe_buf = internal::SubstraitFromJSON(type_name, json); + DCHECK_OK(maybe_buf.status()); + return maybe_buf.ValueOrDie(); } std::string SubstraitToJSON(util::string_view type_name, const Buffer& buf) { - std::string type_url = "/substrait." + type_name.to_string(); - - google::protobuf::io::ArrayInputStream buf_stream{buf.data(), - static_cast(buf.size())}; - - std::string out; - google::protobuf::io::StringOutputStream out_stream{&out}; - - auto status = google::protobuf::util::BinaryToJsonStream( - GetGeneratedTypeResolver(), type_url, &buf_stream, &out_stream); - DCHECK(status.ok()) << "BinaryToJsonStream returned " << status; - - return out; + auto maybe_buf = internal::SubstraitToJSON(type_name, buf); + DCHECK_OK(maybe_buf.status()); + return maybe_buf.ValueOrDie(); } TEST(Substrait, SupportedTypes) { @@ -147,6 +118,9 @@ TEST(Substrait, SupportedTypes) { ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &empty)); EXPECT_EQ(empty.types().size(), 0); + // FIXME chokes on NULLABILITY_UNSPECIFIED + // EXPECT_THAT(internal::CheckMessagesEquivalent("Type", *buf, *serialized), Ok()); + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized, empty)); EXPECT_EQ(*roundtripped, *expected_type); diff --git a/cpp/src/arrow/testing/matchers.h b/cpp/src/arrow/testing/matchers.h index 7ab1d6de2f1..93a576ff6cd 100644 --- a/cpp/src/arrow/testing/matchers.h +++ b/cpp/src/arrow/testing/matchers.h @@ -201,7 +201,7 @@ class ErrorMatcher { if (match) { *listener << "whose error matches"; } else if (status.ok()) { - *listener << "whose value doesn't match"; + *listener << "whose non-error doesn't match"; } else { *listener << "whose error doesn't match"; } @@ -236,8 +236,7 @@ class OkMatcher { const Status& status = internal::GenericToStatus(maybe_value); const bool match = status.ok(); - *listener << "whose value " << testing::PrintToString(status.ToString()) - << (match ? " matches" : " doesn't match"); + *listener << "whose " << (match ? "non-error matches" : "error doesn't match"); return match; } }; From 98c74a893bee185bc389dc177c64bea8759f75c2 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 12 Jan 2022 12:05:04 +0100 Subject: [PATCH 029/113] Revert now unnecessary part of 9255fb6 --- cpp/src/arrow/engine/substrait/extension_types.cc | 4 ++-- cpp/src/arrow/util/reflection_internal.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index 2d05d5c3616..bcfbbd6ce16 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -47,7 +47,7 @@ struct FixedCharExtensionParams { std::shared_ptr FixedCharGetStorage(const FixedCharExtensionParams& params) { return fixed_size_binary(params.length); } -static constexpr auto kFixedCharExtensionParamsProperties = internal::MakeProperties( +static auto kFixedCharExtensionParamsProperties = internal::MakeProperties( internal::DataMember("length", &FixedCharExtensionParams::length)); using FixedCharType = @@ -62,7 +62,7 @@ struct VarCharExtensionParams { std::shared_ptr VarCharGetStorage(const VarCharExtensionParams&) { return utf8(); } -static constexpr auto kVarCharExtensionParamsProperties = internal::MakeProperties( +static auto kVarCharExtensionParamsProperties = internal::MakeProperties( internal::DataMember("length", &VarCharExtensionParams::length)); using VarCharType = diff --git a/cpp/src/arrow/util/reflection_internal.h b/cpp/src/arrow/util/reflection_internal.h index ca2d01e9be7..0440a2eb563 100644 --- a/cpp/src/arrow/util/reflection_internal.h +++ b/cpp/src/arrow/util/reflection_internal.h @@ -109,7 +109,7 @@ struct PropertyTuple { }; template -PropertyTuple constexpr MakeProperties(Properties... props) { +PropertyTuple MakeProperties(Properties... props) { return {std::make_tuple(props...)}; } From 6fd2e73cc60aeed72a16fbfe8c2b5b6a43b4121e Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 12 Jan 2022 13:37:48 +0100 Subject: [PATCH 030/113] Support nested StructFields --- .../engine/substrait/expression_internal.cc | 78 ++++++++++++------- cpp/src/arrow/engine/substrait/serde_test.cc | 23 +++--- 2 files changed, 62 insertions(+), 39 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 5a882349826..86bf204e440 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -57,45 +57,65 @@ Result FromProto(const substrait::Expression& expr) { case substrait::Expression::kSelection: { if (!expr.selection().has_direct_reference()) break; - util::optional root_expr; + util::optional out; if (expr.selection().has_expression()) { - ARROW_ASSIGN_OR_RAISE(root_expr, FromProto(expr.selection().expression())); + ARROW_ASSIGN_OR_RAISE(out, FromProto(expr.selection().expression())); } - const auto& ref = expr.selection().direct_reference(); - switch (ref.reference_type_case()) { - case substrait::Expression::ReferenceSegment::kStructField: { - if (ref.struct_field().has_child()) break; - - FieldRef out(ref.struct_field().field()); - - if (root_expr) { - if (auto root_ref = root_expr->field_ref()) { - out = FieldRef(*root_ref, std::move(out)); + const auto* ref = &expr.selection().direct_reference(); + while (ref != NULLPTR) { + switch (ref->reference_type_case()) { + case substrait::Expression::ReferenceSegment::kStructField: { + if (!out) { + // Root StructField (column selection) + out = compute::field_ref(FieldRef(ref->struct_field().field())); + } else if (auto out_ref = out->field_ref()) { + // StructField on top of another StructField + out = compute::field_ref(FieldRef(*out_ref, ref->struct_field().field())); } else { - // FIXME add struct_field compute function to handle - // field references into expressions + // StructField on top of an arbitrary expression + // FIXME add struct_field compute function to handle this case + out.reset(); + ref = NULLPTR; break; } - } - return compute::field_ref(std::move(out)); - } - case substrait::Expression::ReferenceSegment::kListElement: { - if (ref.list_element().has_child()) break; - if (!root_expr) { - return Status::Invalid( - "substrait::ListElement cannot take a Relation as an argument"); + // Segment handled, continue with child segment (if any) + if (ref->struct_field().has_child()) { + ref = &ref->struct_field().child(); + } else { + ref = NULLPTR; + } + break; } + case substrait::Expression::ReferenceSegment::kListElement: { + if (!out) { + // Root ListField (illegal) + return Status::Invalid( + "substrait::ListElement cannot take a Relation as an argument"); + } else { + // ListField on top of an arbitrary expression + out = compute::call( + "list_element", + {std::move(*out), compute::literal(ref->list_element().offset())}); + } - return compute::call( - "list_element", - {std::move(*root_expr), compute::literal(ref.list_element().offset())}); - break; + // Segment handled, continue with child segment (if any) + if (ref->list_element().has_child()) { + ref = &ref->list_element().child(); + } else { + ref = NULLPTR; + } + break; + } + default: + // Unimplemented construct, break out of loop + out.reset(); + ref = NULLPTR; } - - default: - break; + } + if (out) { + return *std::move(out); } break; } diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 75d452e1447..5d4eef51eaa 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -47,10 +47,12 @@ const std::shared_ptr kBoringSchema = schema({ field("date64", date64()), field("str", utf8()), field("list_i32", list(int32())), - field("struct_i32_str", struct_({ - field("i32", int32()), - field("str", utf8()), - })), + field("struct", struct_({ + field("i32", int32()), + field("str", utf8()), + field("struct_i32_str", + struct_({field("i32", int32()), field("str", utf8())})), + })), field("dict_str", dictionary(int32(), utf8())), field("dict_i32", dictionary(int32(), int32())), field("ts_ns", timestamp(TimeUnit::NANO)), @@ -415,17 +417,18 @@ TEST(Substrait, FieldRefRoundTrip) { // by name FieldRef("i32"), FieldRef("ts_ns"), - FieldRef("struct_i32_str"), + FieldRef("struct"), // by index FieldRef(0), FieldRef(1), FieldRef(kBoringSchema->num_fields() - 1), - FieldRef(kBoringSchema->GetFieldIndex("struct_i32_str")), + FieldRef(kBoringSchema->GetFieldIndex("struct")), // nested - FieldRef("struct_i32_str", "i32"), - FieldRef(kBoringSchema->GetFieldIndex("struct_i32_str"), 1), + FieldRef("struct", "i32"), + FieldRef("struct", "struct_i32_str", "i32"), + FieldRef(kBoringSchema->GetFieldIndex("struct"), 1), }) { ARROW_SCOPED_TRACE(ref.ToString()); ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); @@ -440,7 +443,7 @@ TEST(Substrait, FieldRefRoundTrip) { } TEST(Substrait, RecursiveFieldRef) { - FieldRef ref("struct_i32_str", "str"); + FieldRef ref("struct", "str"); ARROW_SCOPED_TRACE(ref.ToString()); ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); @@ -457,7 +460,7 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { compute::call("if_else", { compute::literal(true), - compute::field_ref({"struct_i32_str", 1}), + compute::field_ref({"struct", 1}), compute::field_ref("str"), }), From 0034651045041511f7ab8bb2958fe676a2ceee22 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 12 Jan 2022 14:38:30 +0100 Subject: [PATCH 031/113] Support struct_field compute function --- .../engine/substrait/expression_internal.cc | 57 +++++++++++++++---- cpp/src/arrow/engine/substrait/serde_test.cc | 50 ++++++++++------ 2 files changed, 80 insertions(+), 27 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 86bf204e440..54a18583385 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -66,18 +66,23 @@ Result FromProto(const substrait::Expression& expr) { while (ref != NULLPTR) { switch (ref->reference_type_case()) { case substrait::Expression::ReferenceSegment::kStructField: { + auto index = ref->struct_field().field(); if (!out) { // Root StructField (column selection) - out = compute::field_ref(FieldRef(ref->struct_field().field())); + out = compute::field_ref(FieldRef(index)); } else if (auto out_ref = out->field_ref()) { - // StructField on top of another StructField - out = compute::field_ref(FieldRef(*out_ref, ref->struct_field().field())); + // Nested StructFields on the root (selection of struct-typed column + // combined with selecting struct fields) + out = compute::field_ref(FieldRef(*out_ref, index)); + } else if (out->call() && out->call()->function_name == "struct_field") { + // Nested StructFields on top of an arbitrary expression + std::static_pointer_cast( + out->call()->options) + ->indices.push_back(index); } else { - // StructField on top of an arbitrary expression - // FIXME add struct_field compute function to handle this case - out.reset(); - ref = NULLPTR; - break; + // First StructField on top of an arbitrary expression + out = compute::call("struct_field", {std::move(*out)}, + arrow::compute::StructFieldOptions({index})); } // Segment handled, continue with child segment (if any) @@ -669,10 +674,10 @@ Result> ToProto(const compute::Expression // Special case of a nested StructField DCHECK(!param->indices.empty()); - for (auto it = param->indices.begin(); it != param->indices.end(); ++it) { + for (int index : param->indices) { auto struct_field = internal::make_unique(); - struct_field->set_field(*it); + struct_field->set_field(index); auto ref_segment = internal::make_unique(); ref_segment->set_allocated_struct_field(struct_field.release()); @@ -702,6 +707,38 @@ Result> ToProto(const compute::Expression ARROW_ASSIGN_OR_RAISE(arguments[i], ToProto(call->arguments[i])); } + if (call->function_name == "struct_field") { + // catch the special case of calls convertible to a StructField + // TODO: DRY (nested StructField above); also, utilize ReferenceSegment.child for + // nesting if possible + const auto& indices = + std::static_pointer_cast(call->options) + ->indices; + + for (int index : indices) { + auto struct_field = + internal::make_unique(); + struct_field->set_field(index); + + auto ref_segment = internal::make_unique(); + ref_segment->set_allocated_struct_field(struct_field.release()); + + auto selection = internal::make_unique(); + selection->set_allocated_direct_reference(ref_segment.release()); + + if (out->has_selection()) { + selection->set_allocated_expression(out.release()); + out = internal::make_unique(); + } else { + selection->set_allocated_expression(arguments[0].release()); + } + + out->set_allocated_selection(selection.release()); + } + + return std::move(out); + } + if (call->function_name == "list_element") { // catch the special case of calls convertible to a ListElement if (arguments[0]->has_selection() && diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 5d4eef51eaa..49c32ded12d 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -53,6 +53,12 @@ const std::shared_ptr kBoringSchema = schema({ field("struct_i32_str", struct_({field("i32", int32()), field("str", utf8())})), })), + field("list_struct", list(struct_({ + field("i32", int32()), + field("str", utf8()), + field("struct_i32_str", struct_({field("i32", int32()), + field("str", utf8())})), + }))), field("dict_str", dictionary(int32(), utf8())), field("dict_i32", dictionary(int32(), int32())), field("ts_ns", timestamp(TimeUnit::NANO)), @@ -413,23 +419,17 @@ TEST(Substrait, CannotDeserializeLiteral) { } TEST(Substrait, FieldRefRoundTrip) { - for (FieldRef ref : { - // by name - FieldRef("i32"), - FieldRef("ts_ns"), - FieldRef("struct"), - - // by index - FieldRef(0), - FieldRef(1), - FieldRef(kBoringSchema->num_fields() - 1), - FieldRef(kBoringSchema->GetFieldIndex("struct")), - - // nested - FieldRef("struct", "i32"), - FieldRef("struct", "struct_i32_str", "i32"), - FieldRef(kBoringSchema->GetFieldIndex("struct"), 1), - }) { + for (FieldRef ref : + {// by name + FieldRef("i32"), FieldRef("ts_ns"), FieldRef("struct"), + + // by index + FieldRef(0), FieldRef(1), FieldRef(kBoringSchema->num_fields() - 1), + FieldRef(kBoringSchema->GetFieldIndex("struct")), + + // nested + FieldRef("struct", "i32"), FieldRef("struct", "struct_i32_str", "i32"), + FieldRef(kBoringSchema->GetFieldIndex("struct"), 1)}) { ARROW_SCOPED_TRACE(ref.ToString()); ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); @@ -469,6 +469,22 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { compute::field_ref("list_i32"), compute::literal(3), }), + + compute::call("struct_field", + {compute::call("list_element", + { + compute::field_ref("list_struct"), + compute::literal(42), + })}, + arrow::compute::StructFieldOptions({1})), + + compute::call("struct_field", + {compute::call("list_element", + { + compute::field_ref("list_struct"), + compute::literal(42), + })}, + arrow::compute::StructFieldOptions({2, 0})), }) { ARROW_SCOPED_TRACE(expr.ToString()); ASSERT_OK_AND_ASSIGN(expr, expr.Bind(*kBoringSchema)); From b5e6fa42174e7ab54a7e8f3aa0a2f86a88264f2b Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 12 Jan 2022 18:24:17 +0100 Subject: [PATCH 032/113] Use ReferenceSegment.child where possible when emitting Substrait --- .../engine/substrait/expression_internal.cc | 177 ++++++++++++------ cpp/src/arrow/engine/substrait/serde_test.cc | 7 +- 2 files changed, 123 insertions(+), 61 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 54a18583385..06d6724c12f 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -657,6 +657,115 @@ Result> ToProto(const Datum& dat return std::move(out); } +static Status AddChildToReferenceSegment( + substrait::Expression::ReferenceSegment& segment, + std::unique_ptr&& child) { + auto status = Status::Invalid("Attempt to add child to incomplete reference segment"); + switch (segment.reference_type_case()) { + case substrait::Expression::ReferenceSegment::kMapKey: { + auto map_key = segment.release_map_key(); + if (map_key->has_child()) { + auto intermediate_segment = map_key->release_child(); + status = AddChildToReferenceSegment(*intermediate_segment, std::move(child)); + map_key->set_allocated_child(intermediate_segment); + } else { + map_key->set_allocated_child(child.release()); + status = Status::OK(); + } + segment.set_allocated_map_key(map_key); + break; + } + case substrait::Expression::ReferenceSegment::kStructField: { + auto struct_field = segment.release_struct_field(); + if (struct_field->has_child()) { + auto intermediate_segment = struct_field->release_child(); + status = AddChildToReferenceSegment(*intermediate_segment, std::move(child)); + struct_field->set_allocated_child(intermediate_segment); + } else { + struct_field->set_allocated_child(child.release()); + status = Status::OK(); + } + segment.set_allocated_struct_field(struct_field); + break; + } + case substrait::Expression::ReferenceSegment::kListElement: { + auto list_element = segment.release_list_element(); + if (list_element->has_child()) { + auto intermediate_segment = list_element->release_child(); + status = AddChildToReferenceSegment(*intermediate_segment, std::move(child)); + list_element->set_allocated_child(intermediate_segment); + } else { + list_element->set_allocated_child(child.release()); + status = Status::OK(); + } + segment.set_allocated_list_element(list_element); + break; + } + default: + break; + } + return status; +} + +// Indexes the given Substrait expression or root (if expr is empty) using the given +// ReferenceSegment. +static Result> MakeDirectReference( + std::unique_ptr&& expr, + std::unique_ptr&& ref_segment) { + // If expr is already a selection expression, add the index to its index stack. + if (expr && expr->has_selection() && expr->selection().has_direct_reference()) { + auto selection = expr->release_selection(); + auto root_ref_segment = selection->release_direct_reference(); + auto status = AddChildToReferenceSegment(*root_ref_segment, std::move(ref_segment)); + selection->set_allocated_direct_reference(root_ref_segment); + expr->set_allocated_selection(selection); + if (status.ok()) { + return std::move(expr); + } + } + + auto selection = internal::make_unique(); + selection->set_allocated_direct_reference(ref_segment.release()); + + if (expr && expr->rex_type_case() != substrait::Expression::REX_TYPE_NOT_SET) { + selection->set_allocated_expression(expr.release()); + } else { + selection->set_allocated_root_reference( + new substrait::Expression::FieldReference::RootReference()); + } + + auto out = internal::make_unique(); + out->set_allocated_selection(selection.release()); + return std::move(out); +} + +// Indexes the given Substrait struct-typed expression or root (if expr is empty) using +// the given field index. +static Result> MakeStructFieldReference( + std::unique_ptr&& expr, int field) { + auto struct_field = + internal::make_unique(); + struct_field->set_field(field); + + auto ref_segment = internal::make_unique(); + ref_segment->set_allocated_struct_field(struct_field.release()); + + return MakeDirectReference(std::move(expr), std::move(ref_segment)); +} + +// Indexes the given Substrait list-typed expression using the given offset. +static Result> MakeListElementReference( + std::unique_ptr&& expr, int offset) { + auto list_element = + internal::make_unique(); + list_element->set_offset(offset); + + auto ref_segment = internal::make_unique(); + ref_segment->set_allocated_list_element(list_element.release()); + + return MakeDirectReference(std::move(expr), std::move(ref_segment)); +} + Result> ToProto(const compute::Expression& expr) { if (!expr.IsBound()) { return Status::Invalid("ToProto requires a bound Expression"); @@ -675,25 +784,7 @@ Result> ToProto(const compute::Expression DCHECK(!param->indices.empty()); for (int index : param->indices) { - auto struct_field = - internal::make_unique(); - struct_field->set_field(index); - - auto ref_segment = internal::make_unique(); - ref_segment->set_allocated_struct_field(struct_field.release()); - - auto selection = internal::make_unique(); - selection->set_allocated_direct_reference(ref_segment.release()); - - if (out->has_selection()) { - selection->set_allocated_expression(out.release()); - out = internal::make_unique(); - } else { - selection->set_allocated_root_reference( - new substrait::Expression::FieldReference::RootReference()); - } - - out->set_allocated_selection(selection.release()); + ARROW_ASSIGN_OR_RAISE(out, MakeStructFieldReference(std::move(out), index)); } return std::move(out); @@ -709,31 +800,11 @@ Result> ToProto(const compute::Expression if (call->function_name == "struct_field") { // catch the special case of calls convertible to a StructField - // TODO: DRY (nested StructField above); also, utilize ReferenceSegment.child for - // nesting if possible - const auto& indices = - std::static_pointer_cast(call->options) - ->indices; - - for (int index : indices) { - auto struct_field = - internal::make_unique(); - struct_field->set_field(index); - - auto ref_segment = internal::make_unique(); - ref_segment->set_allocated_struct_field(struct_field.release()); - - auto selection = internal::make_unique(); - selection->set_allocated_direct_reference(ref_segment.release()); - - if (out->has_selection()) { - selection->set_allocated_expression(out.release()); - out = internal::make_unique(); - } else { - selection->set_allocated_expression(arguments[0].release()); - } - - out->set_allocated_selection(selection.release()); + out.reset(arguments[0].release()); + for (int index : + std::static_pointer_cast(call->options) + ->indices) { + ARROW_ASSIGN_OR_RAISE(out, MakeStructFieldReference(std::move(out), index)); } return std::move(out); @@ -744,21 +815,9 @@ Result> ToProto(const compute::Expression if (arguments[0]->has_selection() && arguments[0]->selection().has_direct_reference()) { if (arguments[1]->has_literal() && arguments[1]->literal().has_i32()) { - auto list_element = - internal::make_unique(); - - list_element->set_offset(arguments[1]->literal().i32()); - - auto ref_segment = - internal::make_unique(); - ref_segment->set_allocated_list_element(list_element.release()); - - auto field_ref = internal::make_unique(); - field_ref->set_allocated_direct_reference(ref_segment.release()); - field_ref->set_allocated_expression(arguments[0].release()); - - out->set_allocated_selection(field_ref.release()); - return std::move(out); + return MakeListElementReference( + std::unique_ptr(arguments[0].release()), + arguments[1]->literal().i32()); } } } diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 49c32ded12d..790be4f8c4f 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -429,7 +429,9 @@ TEST(Substrait, FieldRefRoundTrip) { // nested FieldRef("struct", "i32"), FieldRef("struct", "struct_i32_str", "i32"), - FieldRef(kBoringSchema->GetFieldIndex("struct"), 1)}) { + FieldRef(kBoringSchema->GetFieldIndex("struct"), 1) + + }) { ARROW_SCOPED_TRACE(ref.ToString()); ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); @@ -451,7 +453,8 @@ TEST(Substrait, RecursiveFieldRef) { auto json = SubstraitToJSON("Expression", *serialized); EXPECT_EQ( - R"({"selection":{"directReference":{"structField":{"field":1}},"expression":{"selection":{"directReference":{"structField":{"field":12}},"rootReference":{}}}}})", + // R"({"selection":{"directReference":{"structField":{"field":1}},"expression":{"selection":{"directReference":{"structField":{"field":12}},"rootReference":{}}}}})", + R"({"selection":{"directReference":{"structField":{"field":12,"child":{"structField":{"field":1}}}},"rootReference":{}}})", json); } From e7184f5754b960f0cd720eb4f6d3833918ddb63e Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 12 Jan 2022 18:31:22 +0100 Subject: [PATCH 033/113] Use CheckMessagesEquivalent() for test --- cpp/src/arrow/engine/substrait/serde_test.cc | 22 ++++++++++++++------ 1 file changed, 16 insertions(+), 6 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 790be4f8c4f..f63e833715b 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -450,12 +450,22 @@ TEST(Substrait, RecursiveFieldRef) { ARROW_SCOPED_TRACE(ref.ToString()); ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); - - auto json = SubstraitToJSON("Expression", *serialized); - EXPECT_EQ( - // R"({"selection":{"directReference":{"structField":{"field":1}},"expression":{"selection":{"directReference":{"structField":{"field":12}},"rootReference":{}}}}})", - R"({"selection":{"directReference":{"structField":{"field":12,"child":{"structField":{"field":1}}}},"rootReference":{}}})", - json); + auto expected = SubstraitFromJSON("Expression", R"({ + "selection": { + "directReference": { + "structField": { + "field": 12, + "child": { + "structField": { + "field": 1 + } + } + } + }, + "rootReference": {} + } + })"); + ASSERT_OK(internal::CheckMessagesEquivalent("Expression", *serialized, *expected)); } TEST(Substrait, CallSpecialCaseRoundTrip) { From bf93511245d3ce45606e31f922d2439a21453c65 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 12 Jan 2022 18:55:37 +0100 Subject: [PATCH 034/113] Fix compilation with googletest 1.11 --- cpp/src/arrow/testing/gtest_util.h | 22 ---------------------- cpp/thirdparty/versions.txt | 4 ++-- 2 files changed, 2 insertions(+), 24 deletions(-) diff --git a/cpp/src/arrow/testing/gtest_util.h b/cpp/src/arrow/testing/gtest_util.h index df863c43a7f..c8cb6af986e 100644 --- a/cpp/src/arrow/testing/gtest_util.h +++ b/cpp/src/arrow/testing/gtest_util.h @@ -527,28 +527,6 @@ class ARROW_TESTING_EXPORT GatingTask { std::shared_ptr impl_; }; -template -void PrintTo(const std::shared_ptr& ptr, std::ostream* os) { - if (ptr) { - *os << "{"; - ::testing::internal::UniversalPrint(*ptr, os); - *os << "}"; - } else { - *os << "nullptr"; - } -} - -template -void PrintTo(const std::unique_ptr& ptr, std::ostream* os) { - if (ptr) { - *os << "{"; - ::testing::internal::UniversalPrint(*ptr, os); - *os << "}"; - } else { - *os << "nullptr"; - } -} - } // namespace arrow namespace nonstd { diff --git a/cpp/thirdparty/versions.txt b/cpp/thirdparty/versions.txt index 9192160036b..80751adc028 100644 --- a/cpp/thirdparty/versions.txt +++ b/cpp/thirdparty/versions.txt @@ -53,8 +53,8 @@ ARROW_GOOGLE_CLOUD_CPP_BUILD_VERSION=v1.31.1 ARROW_GOOGLE_CLOUD_CPP_BUILD_SHA256_CHECKSUM=dc7cbf95b506a84b48cf71e0462985d262183edeaabdacaaee2109852394a609 ARROW_GRPC_BUILD_VERSION=v1.35.0 ARROW_GRPC_BUILD_SHA256_CHECKSUM=27dd2fc5c9809ddcde8eb6fa1fa278a3486566dfc28335fca13eb8df8bd3b958 -ARROW_GTEST_BUILD_VERSION=1.10.0 -ARROW_GTEST_BUILD_SHA256_CHECKSUM=9dc9157a9a1551ec7a7e43daea9a694a0bb5fb8bec81235d8a1e6ef64c716dcb +ARROW_GTEST_BUILD_VERSION=1.11.0 +ARROW_GTEST_BUILD_SHA256_CHECKSUM=b4870bf121ff7795ba20d20bcdd8627b8e088f2d1dab299a031c1034eddc93d5 ARROW_JEMALLOC_BUILD_VERSION=5.2.1 ARROW_JEMALLOC_BUILD_SHA256_CHECKSUM=34330e5ce276099e2e8950d9335db5a875689a4c6a56751ef3b1d8c537f887f6 # Include post-1.9.3 fixes for undefined behaviour From 2573bc51868b46c34f99bbce60713080ce731388 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Wed, 12 Jan 2022 12:58:46 -0500 Subject: [PATCH 035/113] add nullable field roundtrip test --- cpp/src/arrow/engine/substrait/serde_test.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index f63e833715b..f3d22ac62f5 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -210,7 +210,7 @@ TEST(Substrait, NamedStruct) { {"list": {"type": {"string":{}} }}, {"struct": { "types": [ - {"fp32": {}}, + {"fp32": {"nullability": "NULLABILITY_REQUIRED"}}, {"string": {}} ] }}, @@ -224,7 +224,7 @@ TEST(Substrait, NamedStruct) { field("a", int64()), field("b", list(utf8())), field("c", struct_({ - field("d", float32()), + field("d", float32(), /*nullable=*/false), field("e", utf8()), })), field("f", list(utf8())), From 095560f59732b79f7ce4c15406b8b077d3b64146 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 13 Jan 2022 13:30:25 +0100 Subject: [PATCH 036/113] Use lowercase nullptr in cc files --- cpp/src/arrow/engine/substrait/expression_internal.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 06d6724c12f..dd2bdd485a0 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -63,7 +63,7 @@ Result FromProto(const substrait::Expression& expr) { } const auto* ref = &expr.selection().direct_reference(); - while (ref != NULLPTR) { + while (ref != nullptr) { switch (ref->reference_type_case()) { case substrait::Expression::ReferenceSegment::kStructField: { auto index = ref->struct_field().field(); @@ -89,7 +89,7 @@ Result FromProto(const substrait::Expression& expr) { if (ref->struct_field().has_child()) { ref = &ref->struct_field().child(); } else { - ref = NULLPTR; + ref = nullptr; } break; } @@ -109,14 +109,14 @@ Result FromProto(const substrait::Expression& expr) { if (ref->list_element().has_child()) { ref = &ref->list_element().child(); } else { - ref = NULLPTR; + ref = nullptr; } break; } default: // Unimplemented construct, break out of loop out.reset(); - ref = NULLPTR; + ref = nullptr; } } if (out) { From 24517ff2a3ebab5346f0a631d18f80c72956caff Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 13 Jan 2022 13:34:24 +0100 Subject: [PATCH 037/113] Remove redundant else block Co-authored-by: Benjamin Kietzman --- cpp/src/arrow/engine/substrait/expression_internal.cc | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index dd2bdd485a0..7e252239878 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -98,13 +98,13 @@ Result FromProto(const substrait::Expression& expr) { // Root ListField (illegal) return Status::Invalid( "substrait::ListElement cannot take a Relation as an argument"); - } else { - // ListField on top of an arbitrary expression - out = compute::call( - "list_element", - {std::move(*out), compute::literal(ref->list_element().offset())}); } + // ListField on top of an arbitrary expression + out = compute::call( + "list_element", + {std::move(*out), compute::literal(ref->list_element().offset())}); + // Segment handled, continue with child segment (if any) if (ref->list_element().has_child()) { ref = &ref->list_element().child(); From c4d98775dc7ecea559d02bb530b1f4ad1506b3b6 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 13 Jan 2022 13:37:21 +0100 Subject: [PATCH 038/113] Fix clang-format'ing --- cpp/src/arrow/engine/substrait/serde_test.cc | 28 +++++++++++--------- 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index f3d22ac62f5..fd46a5ec4aa 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -419,18 +419,22 @@ TEST(Substrait, CannotDeserializeLiteral) { } TEST(Substrait, FieldRefRoundTrip) { - for (FieldRef ref : - {// by name - FieldRef("i32"), FieldRef("ts_ns"), FieldRef("struct"), - - // by index - FieldRef(0), FieldRef(1), FieldRef(kBoringSchema->num_fields() - 1), - FieldRef(kBoringSchema->GetFieldIndex("struct")), - - // nested - FieldRef("struct", "i32"), FieldRef("struct", "struct_i32_str", "i32"), - FieldRef(kBoringSchema->GetFieldIndex("struct"), 1) - + for (FieldRef ref : { + // by name + FieldRef("i32"), + FieldRef("ts_ns"), + FieldRef("struct"), + + // by index + FieldRef(0), + FieldRef(1), + FieldRef(kBoringSchema->num_fields() - 1), + FieldRef(kBoringSchema->GetFieldIndex("struct")), + + // nested + FieldRef("struct", "i32"), + FieldRef("struct", "struct_i32_str", "i32"), + FieldRef(kBoringSchema->GetFieldIndex("struct"), 1), }) { ARROW_SCOPED_TRACE(ref.ToString()); ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); From f2e0e71114520143c6fc188908f770af085c8ca5 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 13 Jan 2022 13:54:06 +0100 Subject: [PATCH 039/113] Simplify Fingerprintable constructor --- cpp/src/arrow/type.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h index 18c5532449e..efc528d1c29 100644 --- a/cpp/src/arrow/type.h +++ b/cpp/src/arrow/type.h @@ -76,7 +76,7 @@ class ARROW_EXPORT Fingerprintable { } protected: - Fingerprintable() : fingerprint_(NULLPTR), metadata_fingerprint_(NULLPTR) {} + Fingerprintable() = default; Fingerprintable(Fingerprintable&& other) { MoveFrom(std::move(other)); } @@ -98,8 +98,8 @@ class ARROW_EXPORT Fingerprintable { virtual std::string ComputeFingerprint() const = 0; virtual std::string ComputeMetadataFingerprint() const = 0; - mutable std::atomic fingerprint_; - mutable std::atomic metadata_fingerprint_; + mutable std::atomic fingerprint_{NULLPTR}; + mutable std::atomic metadata_fingerprint_{NULLPTR}; }; } // namespace detail From b09d372656066d8626f1aa6d66e65b154f73175c Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 13 Jan 2022 14:21:27 +0100 Subject: [PATCH 040/113] Simplify unique_ptr moves and casts Co-authored-by: Benjamin Kietzman --- cpp/src/arrow/engine/substrait/expression_internal.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 7e252239878..265e5528947 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -800,9 +800,9 @@ Result> ToProto(const compute::Expression if (call->function_name == "struct_field") { // catch the special case of calls convertible to a StructField - out.reset(arguments[0].release()); + out = std::move(arguments[0]); for (int index : - std::static_pointer_cast(call->options) + checked_cast(*call->options) ->indices) { ARROW_ASSIGN_OR_RAISE(out, MakeStructFieldReference(std::move(out), index)); } @@ -816,7 +816,7 @@ Result> ToProto(const compute::Expression arguments[0]->selection().has_direct_reference()) { if (arguments[1]->has_literal() && arguments[1]->literal().has_i32()) { return MakeListElementReference( - std::unique_ptr(arguments[0].release()), + std::move(arguments[0]), arguments[1]->literal().i32()); } } From 1557f4fa808c0366f592caff68ecbec8857adf25 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 13 Jan 2022 15:42:41 +0100 Subject: [PATCH 041/113] Minor fixes in suggested changes --- cpp/src/arrow/engine/substrait/expression_internal.cc | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 265e5528947..70a200fb082 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -803,7 +803,7 @@ Result> ToProto(const compute::Expression out = std::move(arguments[0]); for (int index : checked_cast(*call->options) - ->indices) { + .indices) { ARROW_ASSIGN_OR_RAISE(out, MakeStructFieldReference(std::move(out), index)); } @@ -815,9 +815,8 @@ Result> ToProto(const compute::Expression if (arguments[0]->has_selection() && arguments[0]->selection().has_direct_reference()) { if (arguments[1]->has_literal() && arguments[1]->literal().has_i32()) { - return MakeListElementReference( - std::move(arguments[0]), - arguments[1]->literal().i32()); + return MakeListElementReference(std::move(arguments[0]), + arguments[1]->literal().i32()); } } } From 839826b7b4d58031e053a1067c0bb25bc1b5b5a2 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 13 Jan 2022 15:43:02 +0100 Subject: [PATCH 042/113] Add tests for mixed struct references and expressions --- cpp/src/arrow/engine/substrait/serde_test.cc | 44 ++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index fd46a5ec4aa..ad8546775ab 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -472,6 +472,41 @@ TEST(Substrait, RecursiveFieldRef) { ASSERT_OK(internal::CheckMessagesEquivalent("Expression", *serialized, *expected)); } +TEST(Substrait, FieldRefsInExpressions) { + ASSERT_OK_AND_ASSIGN(auto expr, + compute::call("struct_field", + {compute::call("if_else", + { + compute::literal(true), + compute::field_ref("struct"), + compute::field_ref("struct"), + })}, + compute::StructFieldOptions({0})) + .Bind(*kBoringSchema)); + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); + auto expected = SubstraitFromJSON("Expression", R"({ + "selection": { + "directReference": { + "structField": { + "field": 0 + } + }, + "expression": { + "if_then": { + "ifs": [ + { + "if": {"literal": {"boolean": true}}, + "then": {"selection": {"directReference": {"structField": {"field": 12}}}} + } + ], + "else": {"selection": {"directReference": {"structField": {"field": 12}}}} + } + } + } + })"); + ASSERT_OK(internal::CheckMessagesEquivalent("Expression", *serialized, *expected)); +} + TEST(Substrait, CallSpecialCaseRoundTrip) { for (compute::Expression expr : { compute::call("if_else", @@ -502,6 +537,15 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { compute::literal(42), })}, arrow::compute::StructFieldOptions({2, 0})), + + compute::call("struct_field", + {compute::call("if_else", + { + compute::literal(true), + compute::field_ref("struct"), + compute::field_ref("struct"), + })}, + compute::StructFieldOptions({0})), }) { ARROW_SCOPED_TRACE(expr.ToString()); ASSERT_OK_AND_ASSIGN(expr, expr.Bind(*kBoringSchema)); From d12545fa2047ebc7893afca4d20b14df5085397f Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Thu, 13 Jan 2022 15:29:53 -0500 Subject: [PATCH 043/113] clean up internal:: --- cpp/build-support/lint_exclusions.txt | 1 + .../arrow/compute/exec/expression_internal.h | 11 ++++--- .../engine/substrait/expression_internal.cc | 30 +++++++++++-------- .../arrow/engine/substrait/plan_internal.cc | 9 +++++- .../arrow/engine/substrait/type_internal.cc | 5 ++++ .../arrow/engine/substrait/type_internal.h | 3 +- 6 files changed, 39 insertions(+), 20 deletions(-) diff --git a/cpp/build-support/lint_exclusions.txt b/cpp/build-support/lint_exclusions.txt index 73cbd884f44..46c9532266d 100644 --- a/cpp/build-support/lint_exclusions.txt +++ b/cpp/build-support/lint_exclusions.txt @@ -1,4 +1,5 @@ *_generated* +*generated/substrait/*.pb.* *.grpc.fb.* *arrowExports.cpp* *parquet_constants.* diff --git a/cpp/src/arrow/compute/exec/expression_internal.h b/cpp/src/arrow/compute/exec/expression_internal.h index dc38924d932..f8c686d2c81 100644 --- a/cpp/src/arrow/compute/exec/expression_internal.h +++ b/cpp/src/arrow/compute/exec/expression_internal.h @@ -29,9 +29,6 @@ #include "arrow/util/logging.h" namespace arrow { - -using internal::checked_cast; - namespace compute { struct KnownFieldValues { @@ -213,7 +210,7 @@ struct Comparison { inline const compute::CastOptions* GetCastOptions(const Expression::Call& call) { if (call.function_name != "cast") return nullptr; - return checked_cast(call.options.get()); + return ::arrow::internal::checked_cast(call.options.get()); } inline bool IsSetLookup(const std::string& function) { @@ -223,7 +220,8 @@ inline bool IsSetLookup(const std::string& function) { inline const compute::MakeStructOptions* GetMakeStructOptions( const Expression::Call& call) { if (call.function_name != "make_struct") return nullptr; - return checked_cast(call.options.get()); + return ::arrow::internal::checked_cast( + call.options.get()); } /// A helper for unboxing an Expression composed of associative function calls. @@ -281,7 +279,8 @@ inline Result> GetFunction( return exec_context->func_registry()->GetFunction(call.function_name); } // XXX this special case is strange; why not make "cast" a ScalarFunction? - const auto& to_type = checked_cast(*call.options).to_type; + const auto& to_type = + ::arrow::internal::checked_cast(*call.options).to_type; return compute::GetCastFunction(to_type); } diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 70a200fb082..0f8185b14cf 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -35,7 +35,15 @@ #include "generated/substrait/expression.pb.h" // IWYU pragma: export namespace arrow { + +using internal::checked_cast; + namespace engine { + +namespace internal { +using ::arrow::internal::make_unique; +} // namespace internal + namespace { std::shared_ptr FixedSizeBinaryScalarFromBytes( @@ -454,7 +462,7 @@ struct ToProtoImpl { Status Visit(const Date64Scalar& s) { return Primitive(&Lit::set_date, s); } Status Visit(const TimestampScalar& s) { - const auto& t = internal::checked_cast(*s.type); + const auto& t = checked_cast(*s.type); if (t.unit() != TimeUnit::MICRO) return NotImplemented(s); @@ -469,7 +477,7 @@ struct ToProtoImpl { Status Visit(const Time32Scalar& s) { return NotImplemented(s); } Status Visit(const Time64Scalar& s) { - if (internal::checked_cast(*s.type).unit() != TimeUnit::MICRO) { + if (checked_cast(*s.type).unit() != TimeUnit::MICRO) { return NotImplemented(s); } return Primitive(&Lit::set_time, s); @@ -481,7 +489,7 @@ struct ToProtoImpl { Status Visit(const Decimal128Scalar& s) { auto decimal = internal::make_unique(); - auto decimal_type = internal::checked_cast(s.type.get()); + auto decimal_type = checked_cast(s.type.get()); decimal->set_precision(decimal_type->precision()); decimal->set_scale(decimal_type->scale()); @@ -507,7 +515,7 @@ struct ToProtoImpl { lit_->set_allocated_list(new Lit::List()); - const auto& list_type = internal::checked_cast(*s.type); + const auto& list_type = checked_cast(*s.type); ARROW_ASSIGN_OR_RAISE( auto element_type, ToProto(*list_type.value_type(), list_type.value_field()->nullable(), &ext_set)); @@ -550,7 +558,7 @@ struct ToProtoImpl { lit_->set_allocated_map(new Lit::Map()); - const auto& kv_arr = internal::checked_cast(*s.value); + const auto& kv_arr = checked_cast(*s.value); auto key_values = lit_->mutable_map()->mutable_key_values(); key_values->Reserve(static_cast(kv_arr.length())); @@ -574,28 +582,26 @@ struct ToProtoImpl { Status Visit(const ExtensionScalar& s) { if (UnwrapUuid(*s.type)) { return FromBuffer(&Lit::set_uuid, - internal::checked_cast(*s.value)); + checked_cast(*s.value)); } if (UnwrapFixedChar(*s.type)) { return FromBuffer(&Lit::set_fixed_char, - internal::checked_cast(*s.value)); + checked_cast(*s.value)); } if (auto length = UnwrapVarChar(*s.type)) { auto var_char = internal::make_unique(); var_char->set_length(*length); - var_char->set_value( - internal::checked_cast(*s.value).value->ToString()); + var_char->set_value(checked_cast(*s.value).value->ToString()); lit_->set_allocated_var_char(var_char.release()); return Status::OK(); } auto GetPairOfInts = [&] { - const auto& array = - *internal::checked_cast(*s.value).value; - auto ints = internal::checked_cast(array).raw_values(); + const auto& array = *checked_cast(*s.value).value; + auto ints = checked_cast(array).raw_values(); return std::make_pair(ints[0], ints[1]); }; diff --git a/cpp/src/arrow/engine/substrait/plan_internal.cc b/cpp/src/arrow/engine/substrait/plan_internal.cc index 10ebfd4f017..edbfe7d85ad 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.cc +++ b/cpp/src/arrow/engine/substrait/plan_internal.cc @@ -24,12 +24,19 @@ #include "arrow/util/unreachable.h" namespace arrow { + +using internal::checked_cast; + namespace engine { +namespace internal { +using ::arrow::internal::make_unique; +} // namespace internal + Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan) { plan->clear_extension_uris(); - std::unordered_map map; + std::unordered_map map; auto uris = plan->mutable_extension_uris(); uris->Reserve(static_cast(ext_set.uris().size())); diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index b4575876b3d..1cad0049a73 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -31,6 +31,11 @@ namespace arrow { namespace engine { + +namespace internal { +using ::arrow::internal::make_unique; +} // namespace internal + namespace { template diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h index 0eb5b3df325..026e6c054bf 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -35,7 +35,8 @@ Result, bool>> FromProto(const substrait::Ty const ExtensionSet&); ARROW_ENGINE_EXPORT -Result> ToProto(const DataType&, bool nullable, ExtensionSet*); +Result> ToProto(const DataType&, bool nullable, + ExtensionSet*); ARROW_ENGINE_EXPORT Result> FromProto(const substrait::NamedStruct&); From 9dd9c701cef91e3ead04c547bb178ee2272477ae Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Thu, 13 Jan 2022 15:54:38 -0500 Subject: [PATCH 044/113] revert Fingerprintable change --- cpp/src/arrow/testing/matchers.h | 1 + cpp/src/arrow/type.cc | 2 +- cpp/src/arrow/type.h | 20 +------------------- 3 files changed, 3 insertions(+), 20 deletions(-) diff --git a/cpp/src/arrow/testing/matchers.h b/cpp/src/arrow/testing/matchers.h index 93a576ff6cd..be88c3f93b4 100644 --- a/cpp/src/arrow/testing/matchers.h +++ b/cpp/src/arrow/testing/matchers.h @@ -363,6 +363,7 @@ template ::ArrayType, typename ValueType = typename ::arrow::stl::detail::DefaultValueAccessor::ValueType> DataEqMatcher DataEqArray(T type, const std::vector>& values) { + // FIXME(bkietz) broken until DataType is move constructible BuilderType builder(std::make_shared(std::move(type)), default_memory_pool()); DCHECK_OK(builder.Reserve(static_cast(values.size()))); diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc index 2a382662497..5842d4bc92f 100644 --- a/cpp/src/arrow/type.cc +++ b/cpp/src/arrow/type.cc @@ -1544,7 +1544,7 @@ Result> Schema::AddField( Result> Schema::SetField( int i, const std::shared_ptr& field) const { if (i < 0 || i > this->num_fields()) { - return Status::Invalid("Invalid column index to set field."); + return Status::Invalid("Invalid column index to add field."); } return std::make_shared( diff --git a/cpp/src/arrow/type.h b/cpp/src/arrow/type.h index efc528d1c29..7381d94b43e 100644 --- a/cpp/src/arrow/type.h +++ b/cpp/src/arrow/type.h @@ -76,22 +76,6 @@ class ARROW_EXPORT Fingerprintable { } protected: - Fingerprintable() = default; - - Fingerprintable(Fingerprintable&& other) { MoveFrom(std::move(other)); } - - Fingerprintable& operator=(Fingerprintable&& other) { - MoveFrom(std::move(other)); - return *this; - } - - void MoveFrom(Fingerprintable&& other) { - fingerprint_.store(other.fingerprint_.load()); - other.fingerprint_.store(NULLPTR); - metadata_fingerprint_.store(other.fingerprint_.load()); - other.metadata_fingerprint_.store(NULLPTR); - } - const std::string& LoadFingerprintSlow() const; const std::string& LoadMetadataFingerprintSlow() const; @@ -144,6 +128,7 @@ struct ARROW_EXPORT DataTypeLayout { /// complex datatypes are usually parametric. class ARROW_EXPORT DataType : public detail::Fingerprintable { public: + explicit DataType(Type::type id) : detail::Fingerprintable(), id_(id) {} ~DataType() override; /// \brief Return whether the types are equal @@ -189,9 +174,6 @@ class ARROW_EXPORT DataType : public detail::Fingerprintable { virtual Type::type storage_id() const { return id_; } protected: - explicit DataType(Type::type id) : detail::Fingerprintable(), id_(id) {} - ARROW_DEFAULT_MOVE_AND_ASSIGN(DataType); - // Dummy version that returns a null string (indicating not implemented). // Subclasses should override for fast equality checks. std::string ComputeFingerprint() const override; From 9a569c9fbb1e69ce19d5b33cad122e6e980983e9 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 14 Jan 2022 12:19:50 -0500 Subject: [PATCH 045/113] add a simple example of substrait consumption --- cpp/examples/arrow/CMakeLists.txt | 6 + .../arrow/engine_substrait_consumption.cc | 135 ++++++++++++++++++ cpp/src/arrow/engine/substrait/serde.cc | 27 +++- cpp/src/arrow/engine/substrait/serde.h | 10 +- 4 files changed, 176 insertions(+), 2 deletions(-) create mode 100644 cpp/examples/arrow/engine_substrait_consumption.cc diff --git a/cpp/examples/arrow/CMakeLists.txt b/cpp/examples/arrow/CMakeLists.txt index e46cc7a6fe5..58d916625af 100644 --- a/cpp/examples/arrow/CMakeLists.txt +++ b/cpp/examples/arrow/CMakeLists.txt @@ -21,6 +21,12 @@ if(ARROW_COMPUTE) add_arrow_example(compute_register_example) endif() +if(ARROW_ENGINE) + add_arrow_example(engine_substrait_consumption + EXTRA_LINK_LIBS + arrow_engine_shared) +endif() + if(ARROW_COMPUTE AND ARROW_CSV) add_arrow_example(compute_and_write_csv_example) endif() diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc new file mode 100644 index 00000000000..0ab789a4372 --- /dev/null +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -0,0 +1,135 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace eng = ::arrow::engine; +namespace cp = ::arrow::compute; + +#define ABORT_ON_FAILURE(expr) \ + do { \ + arrow::Status status_ = (expr); \ + if (!status_.ok()) { \ + std::cerr << status_.message() << std::endl; \ + abort(); \ + } \ + } while (0); + +arrow::Future> GetSubstraitFromServer(); + +class IgnoringConsumer : public cp::SinkNodeConsumer { + public: + explicit IgnoringConsumer(size_t tag) : tag_{tag} {} + + arrow::Status Consume(cp::ExecBatch batch) override { + // Consume a batch of data + // (just print its row count to stdout) + std::cout << "-" << tag_ << " consumed " << batch.length << " rows" << std::endl; + return arrow::Status::OK(); + } + + arrow::Future<> Finish() override { + // Signal to the consumer that the last batch has been delivered + // (we don't do any real work in this consumer so mark it finished immediately) + // + // The returned future should only finish when all outstanding tasks have completed + // (after this method is called Consume is guaranteed not to be called again) + std::cout << "-" << tag_ << " finished" << std::endl; + return arrow::Future<>::MakeFinished(); + } + + private: + size_t tag_; +}; + +int main(int argc, char** argv) { + // Plans arrive at the consumer serialized in a substrait-formatted Buffer + auto maybe_serialized_plan = GetSubstraitFromServer().result(); + ABORT_ON_FAILURE(maybe_serialized_plan.status()); + std::shared_ptr serialized_plan = + std::move(maybe_serialized_plan).ValueOrDie(); + + // Print the received plan to stdout as JSON + arrow::Result maybe_plan_json = + eng::internal::SubstraitToJSON("Plan", *serialized_plan); + ABORT_ON_FAILURE(maybe_plan_json.status()); + std::cout << std::string('#', 50) << " received substrait::Plan:" << std::endl; + std::cout << maybe_plan_json.ValueOrDie() << std::endl; + + // Deserializing a plan requires a factory for consumers: each time a sink node is + // deserialized, a consumer is constructed into which its batches will be piped. + std::vector> consumers; + std::function()> consumer_factory = [&] { + // All batches produced by the plan will be fed into IgnoringConsumers: + auto tag = consumers.size(); + consumers.emplace_back(new IgnoringConsumer{tag}); + return consumers.back(); + }; + + // NOTE Although most of the Deserialize functions require a const ExtensionSet& to + // resolve extension references, a Plan is what we use to construct that ExtensionSet. + // (It should be an optional output later.) In particular, it does not need to be kept + // alive nor does the serialized plan- none of the arrow:: objects in the output will + // contain references to memory owned by either. + auto maybe_decls = eng::DeserializePlan(*serialized_plan, consumer_factory); + ABORT_ON_FAILURE(maybe_decls.status()); + std::vector decls = std::move(maybe_decls).ValueOrDie(); + + // It's safe to drop the serialized plan; we don't leave references to its memory + serialized_plan.reset(); + + // Construct an empty plan (note: configure Function registry and ThreadPool here) + auto maybe_plan = cp::ExecPlan::Make(); + ABORT_ON_FAILURE(maybe_plan.status()); + std::shared_ptr plan = std::move(maybe_plan).ValueOrDie(); + + for (const cp::Declaration& decl : decls) { + // Add decl to plan (note: configure ExecNode registry here) + ABORT_ON_FAILURE(decl.AddToPlan(plan.get()).status()); + } + + // Validate the plan and print it to stdout + ABORT_ON_FAILURE(plan->Validate()); + std::cout << std::string('#', 50) << " produced arrow::ExecPlan:" << std::endl; + std::cout << plan->ToString() << std::endl; + + // Start the plan... + std::cout << std::string('#', 50) << " consuming batches:" << std::endl; + ABORT_ON_FAILURE(plan->StartProducing()); + + // ... and wait for it to finish + ABORT_ON_FAILURE(plan->finished().status()); + return EXIT_SUCCESS; +} + +arrow::Future> GetSubstraitFromServer() { + // Emulate server interaction by parsing hard coded JSON + return eng::internal::SubstraitFromJSON("Plan", R"({ + // FIXME + // in particular, this example will need some LocalFiles to read from as an input + // this function should probably write them to a tmp dir or at least assert that + // there's a readable dataset there + })"); +} diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc index a0e976ecae4..9e108fbef39 100644 --- a/cpp/src/arrow/engine/substrait/serde.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -56,7 +56,13 @@ Result Convert(const substrait::PlanRel& relation) { return Status::NotImplemented(""); } -Result> ConvertPlan(const Buffer& buf) { +Result DeserializeRelation( + const Buffer& buf, std::function()>) { + return Status::NotImplemented(""); +} + +Result> DeserializePlan( + const Buffer& buf, std::function()>) { ARROW_ASSIGN_OR_RAISE(auto plan, ParseFromBuffer(buf)); std::vector decls; @@ -133,10 +139,29 @@ Status CheckMessagesEquivalent(util::string_view message_name, const Buffer& l_b return CheckMessagesEquivalent(l_buf, r_buf); } + if (message_name == "NamedStruct") { + return CheckMessagesEquivalent(l_buf, r_buf); + } + + if (message_name == "Schema") { + return Status::Invalid( + "There is no substrait message named Schema. The substrait message type which " + "corresponds to Schemas is NamedStruct"); + } + if (message_name == "Expression") { return CheckMessagesEquivalent(l_buf, r_buf); } + if (message_name == "Rel") { + return CheckMessagesEquivalent(l_buf, r_buf); + } + + if (message_name == "Relation") { + return Status::Invalid( + "There is no substrait message named Relation. You probably meant \"Rel\""); + } + return Status::Invalid("Unsupported message name ", message_name, " for CheckMessagesEquivalent"); } diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index e0239b7b787..0673ac78cb1 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -19,11 +19,13 @@ #pragma once +#include #include #include #include "arrow/buffer.h" #include "arrow/compute/exec/exec_plan.h" +#include "arrow/compute/exec/options.h" #include "arrow/engine/substrait/extension_types.h" #include "arrow/engine/visibility.h" #include "arrow/result.h" @@ -32,7 +34,9 @@ namespace arrow { namespace engine { -ARROW_ENGINE_EXPORT Result> ConvertPlan(const Buffer&); +ARROW_ENGINE_EXPORT Result> DeserializePlan( + const Buffer&, + std::function()> consumer_factory); ARROW_ENGINE_EXPORT Result> DeserializeType(const Buffer&, const ExtensionSet&); @@ -52,6 +56,10 @@ Result DeserializeExpression(const Buffer&); ARROW_ENGINE_EXPORT Result> SerializeExpression(const compute::Expression&); +ARROW_ENGINE_EXPORT Result DeserializeRelation( + const Buffer&, + std::function()> consumer_factory); + namespace internal { ARROW_ENGINE_EXPORT From ee32bb5df339ced5cadf8523264dfc985c20e7e4 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 14 Jan 2022 14:38:30 -0500 Subject: [PATCH 046/113] add sketch of Relation conversion --- cpp/src/arrow/engine/CMakeLists.txt | 3 + .../arrow/engine/substrait/extension_types.cc | 6 +- .../arrow/engine/substrait/plan_internal.h | 1 + .../engine/substrait/relation_internal.cc | 186 ++++++++++++++++++ .../engine/substrait/relation_internal.h | 37 ++++ cpp/src/arrow/engine/substrait/serde.cc | 15 +- cpp/src/arrow/engine/substrait/serde.h | 10 +- 7 files changed, 243 insertions(+), 15 deletions(-) create mode 100644 cpp/src/arrow/engine/substrait/relation_internal.cc create mode 100644 cpp/src/arrow/engine/substrait/relation_internal.h diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 6b975764d44..36cc44e6dd6 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -30,6 +30,7 @@ set(ARROW_ENGINE_SRCS substrait/extension_types.cc substrait/serde.cc substrait/plan_internal.cc + substrait/relation_internal.cc substrait/type_internal.cc) set(SUBSTRAIT_LOCAL_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait") @@ -103,9 +104,11 @@ add_arrow_lib(arrow_engine ${ARROW_VERSION_SCRIPT_FLAGS} # Defined in cpp/arrow/CMakeLists.txt SHARED_LINK_LIBS arrow_shared + arrow_dataset_shared ${ARROW_ENGINE_LINK_LIBS} STATIC_LINK_LIBS arrow_static + arrow_dataset_static ${ARROW_ENGINE_LINK_LIBS}) foreach(LIB_TARGET ${ARROW_ENGINE_LIBRARIES}) diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index bcfbbd6ce16..d276841c72d 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -161,9 +161,9 @@ struct IdHashEq { using Id = ExtensionSet::Id; size_t operator()(Id id) const { - constexpr internal::StringViewHash hash = {}; + constexpr ::arrow::internal::StringViewHash hash = {}; auto out = hash(id.uri); - internal::hash_combine(out, hash(id.name)); + ::arrow::internal::hash_combine(out, hash(id.name)); return out; } @@ -204,7 +204,7 @@ struct ExtensionSet::Impl { return it_success.first->second; } - std::unordered_set uris_; + std::unordered_set uris_; std::unordered_map types_; }; diff --git a/cpp/src/arrow/engine/substrait/plan_internal.h b/cpp/src/arrow/engine/substrait/plan_internal.h index 8ebe56b627a..ff1946aa64e 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.h +++ b/cpp/src/arrow/engine/substrait/plan_internal.h @@ -22,6 +22,7 @@ #include "arrow/engine/substrait/extension_types.h" #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" + #include "generated/substrait/plan.pb.h" // IWYU pragma: export namespace arrow { diff --git a/cpp/src/arrow/engine/substrait/relation_internal.cc b/cpp/src/arrow/engine/substrait/relation_internal.cc new file mode 100644 index 00000000000..dc59e12c26b --- /dev/null +++ b/cpp/src/arrow/engine/substrait/relation_internal.cc @@ -0,0 +1,186 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "arrow/engine/substrait/relation_internal.h" + +#include "arrow/compute/api_scalar.h" +#include "arrow/compute/exec/options.h" +#include "arrow/dataset/file_parquet.h" +#include "arrow/dataset/plan.h" +#include "arrow/dataset/scanner.h" +#include "arrow/engine/substrait/expression_internal.h" +#include "arrow/engine/substrait/type_internal.h" +#include "arrow/filesystem/localfs.h" + +namespace arrow { +namespace engine { + +template +Status CheckRelCommon(const RelMessage& rel) { + if (rel.has_common()) { + if (rel.common().has_emit()) { + return Status::NotImplemented("substrait::RelCommon::Emit"); + } + if (rel.common().has_hint()) { + return Status::NotImplemented("substrait::RelCommon::Hint"); + } + if (rel.common().has_advanced_extension()) { + return Status::NotImplemented("substrait::RelCommon::advanced_extension"); + } + } + if (rel.has_advanced_extension()) { + return Status::NotImplemented("substrait AdvancedExtensions"); + } + return Status::OK(); +} + +Result FromProto(const substrait::Rel& rel, + const ExtensionSet& ext_set) { + static bool dataset_init = false; + if (!dataset_init) { + dataset_init = true; + dataset::internal::Initialize(); + } + + switch (rel.rel_type_case()) { + case substrait::Rel::RelTypeCase::kRead: { + const auto& read = rel.read(); + RETURN_NOT_OK(CheckRelCommon(read)); + + ARROW_ASSIGN_OR_RAISE(auto base_schema, FromProto(read.base_schema())); + + auto scan_options = std::make_shared(); + + if (read.has_filter()) { + ARROW_ASSIGN_OR_RAISE(scan_options->filter, FromProto(read.filter())); + } + + if (read.has_projection()) { + return Status::NotImplemented("substrait::ReadRel::projection"); + } + + { + // just project all fields + std::vector expressions{base_schema->fields().size()}; + for (int i = 0; i < base_schema->num_fields(); ++i) { + expressions.push_back(compute::field_ref(i)); + } + scan_options->projection = + compute::call("make_struct", std::move(expressions), + compute::MakeStructOptions{base_schema->field_names()}); + } + + if (!read.has_local_files()) { + return Status::NotImplemented( + "substrait::ReadRel with read_type other than LocalFiles"); + } + + if (read.local_files().has_advanced_extension()) { + return Status::NotImplemented( + "substrait::ReadRel::LocalFiles::advanced_extension"); + } + + auto format = std::make_shared(); + auto filesystem = std::make_shared(); + std::vector> fragments; + + for (const auto& item : read.local_files().items()) { + if (!item.has_uri_file()) { + return Status::NotImplemented( + "substrait::ReadRel::LocalFiles::FileOrFiles with " + "path_type other than uri_file"); + } + + if (item.format() != + substrait::ReadRel::LocalFiles::FileOrFiles::FILE_FORMAT_PARQUET) { + return Status::NotImplemented( + "substrait::ReadRel::LocalFiles::FileOrFiles::format " + "other than FILE_FORMAT_PARQUET"); + } + + if (!util::string_view{item.uri_file()}.starts_with("file:///")) { + return Status::NotImplemented( + "substrait::ReadRel::LocalFiles::FileOrFiles::uri_file " + "with other than local filesystem (file:///)"); + } + auto path = item.uri_file().substr(7); + + ARROW_ASSIGN_OR_RAISE(auto fragment, format->MakeFragment(dataset::FileSource{ + std::move(path), filesystem})); + fragments.push_back(std::move(fragment)); + } + + ARROW_ASSIGN_OR_RAISE( + auto ds, dataset::FileSystemDataset::Make( + std::move(base_schema), /*root_partition=*/compute::literal(true), + std::move(format), std::move(filesystem), std::move(fragments))); + + return compute::Declaration{ + "project", dataset::ScanNodeOptions{std::move(ds), std::move(scan_options)}}; + } + + case substrait::Rel::RelTypeCase::kFilter: { + const auto& filter = rel.filter(); + RETURN_NOT_OK(CheckRelCommon(filter)); + + if (!filter.has_input()) { + return Status::Invalid("substrait::FilterRel with no input relation"); + } + ARROW_ASSIGN_OR_RAISE(auto input, FromProto(filter.input(), ext_set)); + + if (!filter.has_condition()) { + return Status::Invalid("substrait::FilterRel with no condition expression"); + } + ARROW_ASSIGN_OR_RAISE(auto condition, FromProto(filter.condition())); + + return compute::Declaration::Sequence({ + std::move(input), + {"filter", compute::FilterNodeOptions{std::move(condition)}}, + }); + } + + case substrait::Rel::RelTypeCase::kProject: { + const auto& project = rel.project(); + RETURN_NOT_OK(CheckRelCommon(project)); + + if (!project.has_input()) { + return Status::Invalid("substrait::ProjectRel with no input relation"); + } + ARROW_ASSIGN_OR_RAISE(auto input, FromProto(project.input(), ext_set)); + + std::vector expressions; + for (const auto& expr : project.expressions()) { + expressions.emplace_back(); + ARROW_ASSIGN_OR_RAISE(expressions.back(), FromProto(expr)); + } + + return compute::Declaration::Sequence({ + std::move(input), + {"project", compute::ProjectNodeOptions{std::move(expressions)}}, + }); + } + + default: + break; + } + + return Status::NotImplemented("conversion to arrow::compute::Declaration from ", + rel.DebugString()); +} + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/relation_internal.h b/cpp/src/arrow/engine/substrait/relation_internal.h new file mode 100644 index 00000000000..b0e899a6af3 --- /dev/null +++ b/cpp/src/arrow/engine/substrait/relation_internal.h @@ -0,0 +1,37 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// This API is EXPERIMENTAL. + +#pragma once + +#include "arrow/compute/exec/exec_plan.h" +#include "arrow/engine/substrait/extension_types.h" +#include "arrow/engine/substrait/serde.h" +#include "arrow/engine/visibility.h" +#include "arrow/type_fwd.h" + +#include "generated/substrait/relations.pb.h" // IWYU pragma: export + +namespace arrow { +namespace engine { + +ARROW_ENGINE_EXPORT +Result FromProto(const substrait::Rel&, const ExtensionSet&); + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc index 9e108fbef39..a46df728678 100644 --- a/cpp/src/arrow/engine/substrait/serde.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -18,6 +18,8 @@ #include "arrow/engine/substrait/serde.h" #include "arrow/engine/substrait/expression_internal.h" +#include "arrow/engine/substrait/plan_internal.h" +#include "arrow/engine/substrait/relation_internal.h" #include "arrow/engine/substrait/type_internal.h" #include "arrow/util/string_view.h" @@ -28,8 +30,6 @@ #include #include -#include "generated/substrait/plan.pb.h" - namespace arrow { namespace engine { @@ -56,13 +56,14 @@ Result Convert(const substrait::PlanRel& relation) { return Status::NotImplemented(""); } -Result DeserializeRelation( - const Buffer& buf, std::function()>) { - return Status::NotImplemented(""); +Result DeserializeRelation(const Buffer& buf, + const ExtensionSet& ext_set) { + ARROW_ASSIGN_OR_RAISE(auto rel, ParseFromBuffer(buf)); + return FromProto(rel, ext_set); } -Result> DeserializePlan( - const Buffer& buf, std::function()>) { +Result> DeserializePlan(const Buffer& buf, + const ConsumerFactory&) { ARROW_ASSIGN_OR_RAISE(auto plan, ParseFromBuffer(buf)); std::vector decls; diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index 0673ac78cb1..3dd27a07adf 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -34,9 +34,10 @@ namespace arrow { namespace engine { +using ConsumerFactory = std::function()>; + ARROW_ENGINE_EXPORT Result> DeserializePlan( - const Buffer&, - std::function()> consumer_factory); + const Buffer&, const ConsumerFactory&); ARROW_ENGINE_EXPORT Result> DeserializeType(const Buffer&, const ExtensionSet&); @@ -56,9 +57,8 @@ Result DeserializeExpression(const Buffer&); ARROW_ENGINE_EXPORT Result> SerializeExpression(const compute::Expression&); -ARROW_ENGINE_EXPORT Result DeserializeRelation( - const Buffer&, - std::function()> consumer_factory); +ARROW_ENGINE_EXPORT Result DeserializeRelation(const Buffer&, + const ExtensionSet&); namespace internal { From cf33bd15a2eabe308acc0ddbf4bfcc400e1f45cb Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 13 Jan 2022 20:33:38 +0100 Subject: [PATCH 047/113] WIP on case_when support --- .../engine/substrait/expression_internal.cc | 54 ++++++++++++------- cpp/src/arrow/engine/substrait/serde_test.cc | 11 ++++ 2 files changed, 47 insertions(+), 18 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 0f8185b14cf..bef69892a50 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -136,12 +136,30 @@ Result FromProto(const substrait::Expression& expr) { case substrait::Expression::kIfThen: { const auto& if_then = expr.if_then(); if (!if_then.has_else_()) break; - if (if_then.ifs_size() != 1) break; - ARROW_ASSIGN_OR_RAISE(auto if_, FromProto(if_then.ifs(0).if_())); - ARROW_ASSIGN_OR_RAISE(auto then, FromProto(if_then.ifs(0).then())); - ARROW_ASSIGN_OR_RAISE(auto else_, FromProto(if_then.else_())); - return compute::call("if_else", - {std::move(if_), std::move(then), std::move(else_)}); + if (if_then.ifs_size() == 0) break; + + if (if_then.ifs_size() == 1) { + ARROW_ASSIGN_OR_RAISE(auto if_, FromProto(if_then.ifs(0).if_())); + ARROW_ASSIGN_OR_RAISE(auto then, FromProto(if_then.ifs(0).then())); + ARROW_ASSIGN_OR_RAISE(auto else_, FromProto(if_then.else_())); + return compute::call("if_else", + {std::move(if_), std::move(then), std::move(else_)}); + } + + std::vector ifs, args; + ifs.reserve(if_then.ifs_size()); + args.reserve(if_then.ifs_size() + 2); + args.emplace_back(); + for (auto if_ : if_then.ifs()) { + ARROW_ASSIGN_OR_RAISE(auto compute_if, FromProto(if_.if_())); + ARROW_ASSIGN_OR_RAISE(auto compute_then, FromProto(if_.then())); + ifs.emplace_back(std::move(compute_if)); + args.emplace_back(std::move(compute_then)); + } + ARROW_ASSIGN_OR_RAISE(auto compute_else, FromProto(if_then.else_())); + args.emplace_back(std::move(compute_else)); + args.emplace(args.begin(), compute::call("make_struct", std::move(ifs))); + return compute::call("case_when", std::move(args)); } case substrait::Expression::kScalarFunction: { @@ -841,29 +859,29 @@ Result> ToProto(const compute::Expression return std::move(out); } - /* if (call->function_name == "case_when") { auto conditions = call->arguments[0].call(); if (conditions && conditions->function_name == "make_struct") { - // catch the special case of calls convertible to SwitchExpression - auto switch_ = internal::make_unique(); + // catch the special case of calls convertible to IfThen + auto if_then_ = internal::make_unique(); + size_t arg_idx = 1; for (auto& cond : conditions->arguments) { - auto if_value = - internal::make_unique(); - if_value->set_allocated_if_(arguments[0].release()); - if_value->set_allocated_then(arguments[1].release()); - - switch_->mutable_ifs()->AddAllocated(if_value.release()); + ARROW_ASSIGN_OR_RAISE(auto cond_substrait, ToProto(cond)); + auto clause = internal::make_unique(); + clause->set_allocated_if_(cond_substrait.release()); + clause->set_allocated_then(arguments[arg_idx++].release()); + if_then_->mutable_ifs()->AddAllocated(clause.release()); } - switch_->set_allocated_else_(arguments[2].release()); + if_then_->set_allocated_else_(arguments[arg_idx].release()); - auto out = std::move(arguments[0]); // reuse an emptied substrait::Expression - out->set_allocated_switch_expression(switch_.release()); + out->set_allocated_if_then(if_then_.release()); return std::move(out); } } + + /* // other expression types dive into extensions immediately ExtensionSet* ext_set = nullptr; ARROW_ASSIGN_OR_RAISE(auto anchor, ext_set->EncodeFunction({"", call->function_name})); diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index ad8546775ab..6a5e7a362bb 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -516,6 +516,17 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { compute::field_ref("str"), }), + compute::call( + "case_when", + { + compute::call("make_struct", + {compute::literal(false), compute::literal(true)}, + compute::MakeStructOptions({"a", "b"})), + compute::field_ref({"struct", "str"}), + compute::field_ref({"struct", "struct_i32_str", "str"}), + compute::field_ref("str"), + }), + compute::call("list_element", { compute::field_ref("list_i32"), From 2fc0123304b745aa1188d8b0c6b15dd29d53d896 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Fri, 14 Jan 2022 18:24:13 +0100 Subject: [PATCH 048/113] Fully implement case_when(make_struct(...), ...) --- .../engine/substrait/expression_internal.cc | 67 +++++++++++-------- cpp/src/arrow/engine/substrait/serde_test.cc | 2 +- 2 files changed, 41 insertions(+), 28 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index bef69892a50..8ace14ee5ea 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -146,19 +146,24 @@ Result FromProto(const substrait::Expression& expr) { {std::move(if_), std::move(then), std::move(else_)}); } - std::vector ifs, args; - ifs.reserve(if_then.ifs_size()); + std::vector conditions, args; + std::vector condition_names; + conditions.reserve(if_then.ifs_size()); + condition_names.reserve(if_then.ifs_size()); + size_t name_counter = 0; args.reserve(if_then.ifs_size() + 2); args.emplace_back(); for (auto if_ : if_then.ifs()) { ARROW_ASSIGN_OR_RAISE(auto compute_if, FromProto(if_.if_())); ARROW_ASSIGN_OR_RAISE(auto compute_then, FromProto(if_.then())); - ifs.emplace_back(std::move(compute_if)); + conditions.emplace_back(std::move(compute_if)); args.emplace_back(std::move(compute_then)); + condition_names.emplace_back("cond" + std::to_string(++name_counter)); } ARROW_ASSIGN_OR_RAISE(auto compute_else, FromProto(if_then.else_())); args.emplace_back(std::move(compute_else)); - args.emplace(args.begin(), compute::call("make_struct", std::move(ifs))); + args[0] = compute::call("make_struct", std::move(conditions), + compute::MakeStructOptions(condition_names)); return compute::call("case_when", std::move(args)); } @@ -816,7 +821,37 @@ Result> ToProto(const compute::Expression auto call = CallNotNull(expr); - // convert all arguments first + if (call->function_name == "case_when") { + auto conditions = call->arguments[0].call(); + if (conditions && conditions->function_name == "make_struct") { + // catch the special case of calls convertible to IfThen + auto if_then_ = internal::make_unique(); + + // don't try to convert argument 0 of the case_when; we have to convert the elements + // of make_struct individually + std::vector> arguments( + call->arguments.size() - 1); + for (size_t i = 1; i < call->arguments.size(); ++i) { + ARROW_ASSIGN_OR_RAISE(arguments[i - 1], ToProto(call->arguments[i])); + } + + for (size_t i = 0; i < conditions->arguments.size(); ++i) { + ARROW_ASSIGN_OR_RAISE(auto cond_substrait, ToProto(conditions->arguments[i])); + auto clause = internal::make_unique(); + clause->set_allocated_if_(cond_substrait.release()); + clause->set_allocated_then(arguments[i].release()); + if_then_->mutable_ifs()->AddAllocated(clause.release()); + } + + if_then_->set_allocated_else_(arguments.back().release()); + + out->set_allocated_if_then(if_then_.release()); + return std::move(out); + } + } + + // the remaining function pattern matchers only convert the function itself, so we + // should be able to convert all its arguments first here std::vector> arguments(call->arguments.size()); for (size_t i = 0; i < arguments.size(); ++i) { ARROW_ASSIGN_OR_RAISE(arguments[i], ToProto(call->arguments[i])); @@ -859,28 +894,6 @@ Result> ToProto(const compute::Expression return std::move(out); } - if (call->function_name == "case_when") { - auto conditions = call->arguments[0].call(); - if (conditions && conditions->function_name == "make_struct") { - // catch the special case of calls convertible to IfThen - auto if_then_ = internal::make_unique(); - - size_t arg_idx = 1; - for (auto& cond : conditions->arguments) { - ARROW_ASSIGN_OR_RAISE(auto cond_substrait, ToProto(cond)); - auto clause = internal::make_unique(); - clause->set_allocated_if_(cond_substrait.release()); - clause->set_allocated_then(arguments[arg_idx++].release()); - if_then_->mutable_ifs()->AddAllocated(clause.release()); - } - - if_then_->set_allocated_else_(arguments[arg_idx].release()); - - out->set_allocated_if_then(if_then_.release()); - return std::move(out); - } - } - /* // other expression types dive into extensions immediately ExtensionSet* ext_set = nullptr; diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 6a5e7a362bb..fa5f6d5b4a7 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -521,7 +521,7 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { { compute::call("make_struct", {compute::literal(false), compute::literal(true)}, - compute::MakeStructOptions({"a", "b"})), + compute::MakeStructOptions({"cond1", "cond2"})), compute::field_ref({"struct", "str"}), compute::field_ref({"struct", "struct_i32_str", "str"}), compute::field_ref("str"), From 9468920534e08bc09499ad29ef373e291eea2d96 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 18 Jan 2022 11:08:23 +0100 Subject: [PATCH 049/113] Simplify ReferenceSegment manipulation functions --- .../engine/substrait/expression_internal.cc | 27 ++++++------------- 1 file changed, 8 insertions(+), 19 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 8ace14ee5ea..3edcc28df8a 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -692,42 +692,33 @@ static Status AddChildToReferenceSegment( auto status = Status::Invalid("Attempt to add child to incomplete reference segment"); switch (segment.reference_type_case()) { case substrait::Expression::ReferenceSegment::kMapKey: { - auto map_key = segment.release_map_key(); + auto map_key = segment.mutable_map_key(); if (map_key->has_child()) { - auto intermediate_segment = map_key->release_child(); - status = AddChildToReferenceSegment(*intermediate_segment, std::move(child)); - map_key->set_allocated_child(intermediate_segment); + status = AddChildToReferenceSegment(*map_key->mutable_child(), std::move(child)); } else { map_key->set_allocated_child(child.release()); status = Status::OK(); } - segment.set_allocated_map_key(map_key); break; } case substrait::Expression::ReferenceSegment::kStructField: { - auto struct_field = segment.release_struct_field(); + auto struct_field = segment.mutable_struct_field(); if (struct_field->has_child()) { - auto intermediate_segment = struct_field->release_child(); - status = AddChildToReferenceSegment(*intermediate_segment, std::move(child)); - struct_field->set_allocated_child(intermediate_segment); + status = AddChildToReferenceSegment(*struct_field->mutable_child(), std::move(child)); } else { struct_field->set_allocated_child(child.release()); status = Status::OK(); } - segment.set_allocated_struct_field(struct_field); break; } case substrait::Expression::ReferenceSegment::kListElement: { - auto list_element = segment.release_list_element(); + auto list_element = segment.mutable_list_element(); if (list_element->has_child()) { - auto intermediate_segment = list_element->release_child(); - status = AddChildToReferenceSegment(*intermediate_segment, std::move(child)); - list_element->set_allocated_child(intermediate_segment); + status = AddChildToReferenceSegment(*list_element->mutable_child(), std::move(child)); } else { list_element->set_allocated_child(child.release()); status = Status::OK(); } - segment.set_allocated_list_element(list_element); break; } default: @@ -743,11 +734,9 @@ static Result> MakeDirectReference( std::unique_ptr&& ref_segment) { // If expr is already a selection expression, add the index to its index stack. if (expr && expr->has_selection() && expr->selection().has_direct_reference()) { - auto selection = expr->release_selection(); - auto root_ref_segment = selection->release_direct_reference(); + auto selection = expr->mutable_selection(); + auto root_ref_segment = selection->mutable_direct_reference(); auto status = AddChildToReferenceSegment(*root_ref_segment, std::move(ref_segment)); - selection->set_allocated_direct_reference(root_ref_segment); - expr->set_allocated_selection(selection); if (status.ok()) { return std::move(expr); } From 4da0939457fcff5375d808a11a2269a41d267bb7 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Wed, 19 Jan 2022 15:27:53 -0500 Subject: [PATCH 050/113] add test for ReadRel conversion --- .../engine/substrait/relation_internal.cc | 4 +- cpp/src/arrow/engine/substrait/serde_test.cc | 66 +++++++++++++++++++ 2 files changed, 68 insertions(+), 2 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/relation_internal.cc b/cpp/src/arrow/engine/substrait/relation_internal.cc index dc59e12c26b..9a68c3f643f 100644 --- a/cpp/src/arrow/engine/substrait/relation_internal.cc +++ b/cpp/src/arrow/engine/substrait/relation_internal.cc @@ -77,7 +77,7 @@ Result FromProto(const substrait::Rel& rel, // just project all fields std::vector expressions{base_schema->fields().size()}; for (int i = 0; i < base_schema->num_fields(); ++i) { - expressions.push_back(compute::field_ref(i)); + expressions[i] = compute::field_ref(i); } scan_options->projection = compute::call("make_struct", std::move(expressions), @@ -130,7 +130,7 @@ Result FromProto(const substrait::Rel& rel, std::move(format), std::move(filesystem), std::move(fragments))); return compute::Declaration{ - "project", dataset::ScanNodeOptions{std::move(ds), std::move(scan_options)}}; + "scan", dataset::ScanNodeOptions{std::move(ds), std::move(scan_options)}}; } case substrait::Rel::RelTypeCase::kFilter: { diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index fa5f6d5b4a7..2cd26ee2af5 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -23,15 +23,21 @@ #include #include "arrow/compute/exec/expression_internal.h" +#include "arrow/dataset/file_base.h" +#include "arrow/dataset/scanner.h" #include "arrow/engine/substrait/extension_types.h" #include "arrow/testing/gtest_util.h" #include "arrow/testing/matchers.h" #include "arrow/util/key_value_metadata.h" +using testing::ElementsAre; using testing::Eq; using testing::HasSubstr; namespace arrow { + +using internal::checked_cast; + namespace engine { const std::shared_ptr kBoringSchema = schema({ @@ -567,5 +573,65 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { } } +TEST(Substrait, ReadRel) { + auto buf = SubstraitFromJSON("Rel", R"({ + "read": { + "base_schema": { + "struct": { + "types": [ {"i64": {}}, {"bool": {}} ] + }, + "names": ["i", "b"] + }, + "filter": { + "selection": { + "directReference": { + "structField": { + "field": 1 + } + } + } + }, + "local_files": { + "items": [ + { + "uri_file": "file:///tmp/dat1.parquet", + "format": "FILE_FORMAT_PARQUET" + }, + { + "uri_file": "file:///tmp/dat2.parquet", + "format": "FILE_FORMAT_PARQUET" + } + ] + } + } + })"); + ExtensionSet ext_set; + ASSERT_OK_AND_ASSIGN(auto rel, DeserializeRelation(*buf, ext_set)); + + // converting a ReadRel produces a scan Declaration + ASSERT_EQ(rel.factory_name, "scan"); + const auto& scan_node_options = + checked_cast(*rel.options); + + // filter on the boolean field (#1) + EXPECT_EQ(scan_node_options.scan_options->filter, compute::field_ref(1)); + // project all fields + EXPECT_EQ(scan_node_options.scan_options->projection, + compute::call("make_struct", + { + compute::field_ref(0), + compute::field_ref(1), + }, + compute::MakeStructOptions{{"i", "b"}})); + + // dataset is a FileSystemDataset in parquet format with the specified schema + ASSERT_EQ(scan_node_options.dataset->type_name(), "filesystem"); + const auto& dataset = + checked_cast(*scan_node_options.dataset); + EXPECT_THAT(dataset.files(), ElementsAre("/tmp/dat1.parquet", "/tmp/dat2.parquet")); + EXPECT_EQ(dataset.format()->type_name(), "parquet"); + EXPECT_EQ(*dataset.schema(), Schema({field("i", int64()), field("b", boolean())})); +} + } // namespace engine } // namespace arrow From 1487b37d777ba4577b45fc8df1d2116dcd538170 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Thu, 20 Jan 2022 15:18:17 -0500 Subject: [PATCH 051/113] add function extensions to ExtensionSet --- .../arrow/engine/substrait/extension_types.cc | 132 +++++++++++++++--- .../arrow/engine/substrait/extension_types.h | 28 ++-- .../arrow/engine/substrait/plan_internal.cc | 26 ++-- 3 files changed, 139 insertions(+), 47 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index d276841c72d..909264ea8fd 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -191,6 +191,8 @@ struct ExtensionSet::Impl { uint32_t EncodeType(Id id, const std::shared_ptr& type, bool is_variation, ExtensionSet* self) { + // note: at this point we're guaranteed to have an Id which points to memory owned by + // the set's registry. AddUri(id.uri, self); auto it_success = types_.emplace(id, static_cast(types_.size())); @@ -211,7 +213,7 @@ struct ExtensionSet::Impl { ExtensionSet::ExtensionSet(ExtensionIdRegistry* registry) : registry_(registry), impl_(new Impl(), [](Impl* impl) { delete impl; }) {} -Result ExtensionSet::Make(std::vector uris, +Result ExtensionSet::Make(std::vector uris, std::vector type_ids, std::vector type_is_variation, std::vector function_ids, @@ -219,16 +221,28 @@ Result ExtensionSet::Make(std::vector uris, ExtensionSet set; set.registry_ = registry; - for (auto uri : uris) { + // TODO(bkietz) move this into the registry as registry->OwnUris(&uris) or so + std::unordered_set + uris_owned_by_registry; + for (util::string_view uri : registry->Uris()) { + uris_owned_by_registry.insert(uri); + } + + for (auto& uri : uris) { if (uri.empty()) continue; + auto it = uris_owned_by_registry.find(uri); + if (it == uris_owned_by_registry.end()) { + return Status::KeyError("Uri '", uri, "' not found in registry"); + } + uri = *it; // Ensure uris point into the registry's memory set.impl_->AddUri(uri, &set); } - set.uris_ = std::move(uris); if (type_ids.size() != type_is_variation.size()) { return Status::Invalid("Received ", type_ids.size(), " type ids but a ", type_is_variation.size(), "-long is_variation vector"); } + set.types_.resize(type_ids.size()); for (size_t i = 0; i < type_ids.size(); ++i) { @@ -240,27 +254,47 @@ Result ExtensionSet::Make(std::vector uris, type_ids[i] = rec->id; // use Id which references memory owned by the registry continue; } - return Status::Invalid("Type not found"); + return Status::Invalid("Type ", (type_is_variation[i] ? "variation" : ""), " (", + type_ids[i].uri, ", ", type_ids[i].name, ") not found"); } + set.function_names_.resize(function_ids.size()); + + for (size_t i = 0; i < function_ids.size(); ++i) { + if (function_ids[i].empty()) continue; + RETURN_NOT_OK(set.impl_->CheckHasUri(function_ids[i].uri)); + + if (auto rec = registry->GetFunction(function_ids[i])) { + set.function_names_[i] = rec->function_name; + function_ids[i] = rec->id; // use Id which references memory owned by the registry + continue; + } + return Status::Invalid("Function (", function_ids[i].uri, ", ", type_ids[i].name, + ") not found"); + } + + set.function_ids_ = std::move(function_ids); set.type_ids_ = std::move(type_ids); set.type_is_variation_ = std::move(type_is_variation); + set.uris_ = std::move(uris); return std::move(set); } -uint32_t ExtensionSet::EncodeType(Id id, const std::shared_ptr& type, - bool is_variation) { - return impl_->EncodeType(id, type, is_variation, this); -} - Result ExtensionSet::EncodeType(const DataType& type) { if (auto rec = registry_->GetType(type)) { - return EncodeType(rec->id, rec->type, rec->is_variation); + return impl_->EncodeType(rec->id, rec->type, rec->is_variation, this); } return Status::KeyError("type ", type.ToString(), " not found in the registry"); } +template +const int* GetIndex(const KeyToIndex& key_to_index, const Key& key) { + auto it = key_to_index.find(key); + if (it == key_to_index.end()) return nullptr; + return &it->second; +} + ExtensionIdRegistry* default_extension_id_registry() { static struct Impl : ExtensionIdRegistry { Impl() { @@ -279,21 +313,24 @@ ExtensionIdRegistry* default_extension_id_registry() { /*is_variation=*/true)); } } - util::optional GetType(const DataType& type) const override { - auto it = type_to_index_.find(&type); - if (it == type_to_index_.end()) return {}; - int index = it->second; - return TypeRecord{ids_[index], types_[index], type_is_variation_[index]}; + std::vector Uris() const override { + return {uris_.begin(), uris_.end()}; } - util::optional GetType(Id id, bool is_variation) const override { - auto* id_to_index = is_variation ? &variation_id_to_index_ : &id_to_index_; - auto it = id_to_index->find(id); - if (it == id_to_index->end()) return {}; + util::optional GetType(const DataType& type) const override { + if (auto index = GetIndex(type_to_index_, &type)) { + return TypeRecord{ids_[*index], types_[*index], type_is_variation_[*index]}; + } + return {}; + } - int index = it->second; - return TypeRecord{ids_[index], types_[index], type_is_variation_[index]}; + util::optional GetType(Id id, bool is_variation) const override { + if (auto index = + GetIndex(is_variation ? variation_id_to_index_ : id_to_index_, id)) { + return TypeRecord{ids_[*index], types_[*index], type_is_variation_[*index]}; + } + return {}; } Status RegisterType(Id id, std::shared_ptr type, @@ -324,8 +361,52 @@ ExtensionIdRegistry* default_extension_id_registry() { return Status::OK(); } - // owning storage of uris, names, types - std::unordered_set uris_, names_; + util::optional GetFunction( + util::string_view arrow_function_name) const override { + if (auto index = GetIndex(function_name_to_index_, arrow_function_name)) { + return FunctionRecord{ids_[*index], *index_to_function_name_[*index]}; + } + return {}; + } + + util::optional GetFunction(Id id) const override { + if (auto index = GetIndex(function_id_to_index_, id)) { + return FunctionRecord{ids_[*index], *index_to_function_name_[*index]}; + } + return {}; + } + + Status RegisterFunction(Id id, std::string arrow_function_name) override { + DCHECK_EQ(ids_.size(), types_.size()); + DCHECK_EQ(ids_.size(), type_is_variation_.size()); + + Id copied_id{*uris_.emplace(id.uri.to_string()).first, + *names_.emplace(id.name.to_string()).first}; + + util::string_view copied_function_name{ + *function_names_.emplace(std::move(arrow_function_name)).first}; + + size_t index = ids_.size(); + + auto it_success = function_id_to_index_.emplace(copied_id, index); + + if (!it_success.second) { + return Status::Invalid("Function id was already registered"); + } + + if (!function_name_to_index_.emplace(copied_function_name, index).second) { + function_id_to_index_.erase(it_success.first); + return Status::Invalid("Type was already registered"); + } + + ids_.push_back(copied_id); + return Status::OK(); + } + + // owning storage of uris, names, (arrow::)function_names, types + // note that storing strings like this is safe since references into an + // unordered_set are not invalidated on insertion + std::unordered_set uris_, names_, function_names_; DataTypeVector types_; std::vector type_is_variation_; @@ -333,6 +414,11 @@ ExtensionIdRegistry* default_extension_id_registry() { std::vector ids_; std::unordered_map id_to_index_, variation_id_to_index_; std::unordered_map type_to_index_; + + std::vector index_to_function_name_; + std::unordered_map function_id_to_index_; + std::unordered_map + function_name_to_index_; } impl_; return &impl_; diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index b466fc3bc91..7ea7700e5a4 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -83,6 +83,9 @@ bool UnwrapIntervalDay(const DataType&); /// registered with their corresponding arrow::DataType before they can be used! class ARROW_ENGINE_EXPORT ExtensionIdRegistry { public: + /// All uris registered in this ExtensionIdRegistry + virtual std::vector Uris() const = 0; + struct Id { util::string_view uri, name; @@ -105,8 +108,14 @@ class ARROW_ENGINE_EXPORT ExtensionIdRegistry { // // ... for another example, depending on the value of the first argument to // substrait::add it either corresponds to arrow::add or arrow::add_checked - // virtual util::optional GetFunction(const compute::Expression&) const = 0; - // virtual Status RegisterFunction(Id, const std::string&) = 0; + struct FunctionRecord { + Id id; + const std::string& function_name; + }; + virtual util::optional GetFunction(Id) const = 0; + virtual util::optional GetFunction( + util::string_view arrow_function_name) const = 0; + virtual Status RegisterFunction(Id, std::string arrow_function_name) = 0; }; constexpr util::string_view kArrowExtTypesUri = @@ -116,6 +125,9 @@ constexpr util::string_view kArrowExtTypesUri = ARROW_ENGINE_EXPORT ExtensionIdRegistry* default_extension_id_registry(); /// A subset of an ExtensionIdRegistry with extensions identifiable by an integer. +/// +/// ExtensionSet does not own strings; it only refers to strings in an +/// ExtensionIdRegistry. class ARROW_ENGINE_EXPORT ExtensionSet { public: using Id = ExtensionIdRegistry::Id; @@ -133,24 +145,19 @@ class ARROW_ENGINE_EXPORT ExtensionSet { /// Views will be replaced with equivalent views pointing to memory owned by the /// registry. static Result Make( - std::vector uris, std::vector type_ids, + std::vector uris, std::vector type_ids, std::vector type_is_variation, std::vector function_ids, ExtensionIdRegistry* = default_extension_id_registry()); // index in these vectors == value of _anchor/_reference fields /// FIXME this assumes that _anchor/_references won't be huge, which is not guaranteed. /// Could it be? - const std::vector& uris() const { return uris_; } + const std::vector& uris() const { return uris_; } const DataTypeVector& types() const { return types_; } const std::vector& type_ids() const { return type_ids_; } bool type_is_variation(uint32_t i) const { return type_is_variation_[i]; } - /// Encode a type as a substrait::ExtensionType or a substrait::ExtensionTypeVariation. - /// Returns an integer usable for Type.user_defined_type_reference. This method will be - /// invoked during serialization when non substrait-core types are encountered. - uint32_t EncodeType(Id, const std::shared_ptr&, bool is_variation); - /// Encode a type, looking it up first in this set's ExtensionIdRegistry. /// If no type is found, an error will be raised. Result EncodeType(const DataType& type); @@ -161,12 +168,13 @@ class ARROW_ENGINE_EXPORT ExtensionSet { private: ExtensionIdRegistry* registry_; - std::vector uris_; + std::vector uris_; DataTypeVector types_; std::vector type_ids_; std::vector type_is_variation_; std::vector function_ids_; + std::vector function_names_; // pimpl pattern to hide lookup details struct Impl; diff --git a/cpp/src/arrow/engine/substrait/plan_internal.cc b/cpp/src/arrow/engine/substrait/plan_internal.cc index edbfe7d85ad..e7605095078 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.cc +++ b/cpp/src/arrow/engine/substrait/plan_internal.cc @@ -41,11 +41,11 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan) auto uris = plan->mutable_extension_uris(); uris->Reserve(static_cast(ext_set.uris().size())); for (size_t anchor = 0; anchor < ext_set.uris().size(); ++anchor) { - const auto& uri = ext_set.uris()[anchor]; + auto uri = ext_set.uris()[anchor]; if (uri.empty()) continue; auto ext_uri = internal::make_unique(); - ext_uri->set_uri(uri); + ext_uri->set_uri(uri.to_string()); ext_uri->set_extension_uri_anchor(anchor); uris->AddAllocated(ext_uri.release()); @@ -99,19 +99,19 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan) } namespace { -template -void SetElement(size_t i, T element, std::vector* vector) { +template +void SetElement(size_t i, const Element& element, std::vector* vector) { DCHECK_LE(i, 1 << 20); if (i >= vector->size()) { vector->resize(i + 1); } - (*vector)[i] = std::move(element); + (*vector)[i] = static_cast(element); } } // namespace Result GetExtensionSetFromPlan(const substrait::Plan& plan, ExtensionIdRegistry* registry) { - std::vector uris; + std::vector uris; for (const auto& uri : plan.extension_uris()) { SetElement(uri.extension_uri_anchor(), uri.uri(), &uris); } @@ -119,14 +119,16 @@ Result GetExtensionSetFromPlan(const substrait::Plan& plan, // NOTE: it's acceptable to use views to memory owned by plan; ExtensionSet::Make // will only store views to memory owned by registry. - std::vector type_ids, function_ids; + using Id = ExtensionSet::Id; + + std::vector type_ids, function_ids; std::vector type_is_variation; for (const auto& ext : plan.extensions()) { switch (ext.mapping_type_case()) { case substrait::extensions::SimpleExtensionDeclaration::kExtensionTypeVariation: { const auto& type_var = ext.extension_type_variation(); util::string_view uri = uris[type_var.extension_uri_reference()]; - SetElement(type_var.type_variation_anchor(), {uri, type_var.name()}, &type_ids); + SetElement(type_var.type_variation_anchor(), Id{uri, type_var.name()}, &type_ids); SetElement(type_var.type_variation_anchor(), true, &type_is_variation); break; } @@ -134,7 +136,7 @@ Result GetExtensionSetFromPlan(const substrait::Plan& plan, case substrait::extensions::SimpleExtensionDeclaration::kExtensionType: { const auto& type = ext.extension_type(); util::string_view uri = uris[type.extension_uri_reference()]; - SetElement(type.type_anchor(), {uri, type.name()}, &type_ids); + SetElement(type.type_anchor(), Id{uri, type.name()}, &type_ids); SetElement(type.type_anchor(), false, &type_is_variation); break; } @@ -142,7 +144,7 @@ Result GetExtensionSetFromPlan(const substrait::Plan& plan, case substrait::extensions::SimpleExtensionDeclaration::kExtensionFunction: { const auto& fn = ext.extension_function(); util::string_view uri = uris[fn.extension_uri_reference()]; - SetElement(fn.function_anchor(), {uri, fn.name()}, &function_ids); + SetElement(fn.function_anchor(), Id{uri, fn.name()}, &function_ids); break; } @@ -156,9 +158,5 @@ Result GetExtensionSetFromPlan(const substrait::Plan& plan, registry); } -// if read relation is LocalFiles -> produce dataset scan node Declaration -// otherwise -> invoke callback, probably does Voltron specific -// things with other read relation types - } // namespace engine } // namespace arrow From d237377ce838a9abb33bda2512240222c0a1e761 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Thu, 20 Jan 2022 16:56:56 -0500 Subject: [PATCH 052/113] Add a test for extraction of an ExtensionSet from a Plan --- .../engine/substrait/expression_internal.cc | 68 +++++---- .../engine/substrait/expression_internal.h | 11 +- .../arrow/engine/substrait/extension_types.cc | 47 +++--- .../arrow/engine/substrait/extension_types.h | 1 + .../engine/substrait/relation_internal.cc | 8 +- cpp/src/arrow/engine/substrait/serde.cc | 53 ++++--- cpp/src/arrow/engine/substrait/serde.h | 11 +- cpp/src/arrow/engine/substrait/serde_test.cc | 141 +++++++++++++++--- .../arrow/engine/substrait/type_internal.cc | 11 +- .../arrow/engine/substrait/type_internal.h | 5 +- 10 files changed, 244 insertions(+), 112 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 3edcc28df8a..881b629674a 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -55,10 +55,11 @@ std::shared_ptr FixedSizeBinaryScalarFromBytes( } // namespace -Result FromProto(const substrait::Expression& expr) { +Result FromProto(const substrait::Expression& expr, + const ExtensionSet& ext_set) { switch (expr.rex_type_case()) { case substrait::Expression::kLiteral: { - ARROW_ASSIGN_OR_RAISE(auto datum, FromProto(expr.literal())); + ARROW_ASSIGN_OR_RAISE(auto datum, FromProto(expr.literal(), ext_set)); return compute::literal(std::move(datum)); } @@ -67,7 +68,7 @@ Result FromProto(const substrait::Expression& expr) { util::optional out; if (expr.selection().has_expression()) { - ARROW_ASSIGN_OR_RAISE(out, FromProto(expr.selection().expression())); + ARROW_ASSIGN_OR_RAISE(out, FromProto(expr.selection().expression(), ext_set)); } const auto* ref = &expr.selection().direct_reference(); @@ -139,9 +140,9 @@ Result FromProto(const substrait::Expression& expr) { if (if_then.ifs_size() == 0) break; if (if_then.ifs_size() == 1) { - ARROW_ASSIGN_OR_RAISE(auto if_, FromProto(if_then.ifs(0).if_())); - ARROW_ASSIGN_OR_RAISE(auto then, FromProto(if_then.ifs(0).then())); - ARROW_ASSIGN_OR_RAISE(auto else_, FromProto(if_then.else_())); + ARROW_ASSIGN_OR_RAISE(auto if_, FromProto(if_then.ifs(0).if_(), ext_set)); + ARROW_ASSIGN_OR_RAISE(auto then, FromProto(if_then.ifs(0).then(), ext_set)); + ARROW_ASSIGN_OR_RAISE(auto else_, FromProto(if_then.else_(), ext_set)); return compute::call("if_else", {std::move(if_), std::move(then), std::move(else_)}); } @@ -154,13 +155,13 @@ Result FromProto(const substrait::Expression& expr) { args.reserve(if_then.ifs_size() + 2); args.emplace_back(); for (auto if_ : if_then.ifs()) { - ARROW_ASSIGN_OR_RAISE(auto compute_if, FromProto(if_.if_())); - ARROW_ASSIGN_OR_RAISE(auto compute_then, FromProto(if_.then())); + ARROW_ASSIGN_OR_RAISE(auto compute_if, FromProto(if_.if_(), ext_set)); + ARROW_ASSIGN_OR_RAISE(auto compute_then, FromProto(if_.then(), ext_set)); conditions.emplace_back(std::move(compute_if)); args.emplace_back(std::move(compute_then)); condition_names.emplace_back("cond" + std::to_string(++name_counter)); } - ARROW_ASSIGN_OR_RAISE(auto compute_else, FromProto(if_then.else_())); + ARROW_ASSIGN_OR_RAISE(auto compute_else, FromProto(if_then.else_(), ext_set)); args.emplace_back(std::move(compute_else)); args[0] = compute::call("make_struct", std::move(conditions), compute::MakeStructOptions(condition_names)); @@ -175,7 +176,7 @@ Result FromProto(const substrait::Expression& expr) { std::vector arguments(scalar_fn.args_size()); for (size_t i = 0; i < arguments.size(); ++i) { - ARROW_ASSIGN_OR_RAISE(arguments[i], FromProto(scalar_fn.args(i))); + ARROW_ASSIGN_OR_RAISE(arguments[i], FromProto(scalar_fn.args(i), ext_set)); } return compute::call(id.name.to_string(), std::move(arguments)); @@ -189,7 +190,8 @@ Result FromProto(const substrait::Expression& expr) { expr.DebugString()); } -Result FromProto(const substrait::Expression::Literal& lit) { +Result FromProto(const substrait::Expression::Literal& lit, + const ExtensionSet& ext_set) { if (lit.nullable()) { // FIXME not sure how this field should be interpreted and there's no way to round // trip it through arrow @@ -197,8 +199,6 @@ Result FromProto(const substrait::Expression::Literal& lit) { "Nullable Literals - Literal.nullable must be left at the default"); } - ExtensionSet ext_set; - switch (lit.literal_type_case()) { case substrait::Expression::Literal::kBoolean: return Datum(lit.boolean()); @@ -292,7 +292,7 @@ Result FromProto(const substrait::Expression::Literal& lit) { ScalarVector fields(struct_.fields_size()); std::vector field_names(fields.size(), ""); for (size_t i = 0; i < fields.size(); ++i) { - ARROW_ASSIGN_OR_RAISE(auto field, FromProto(struct_.fields(i))); + ARROW_ASSIGN_OR_RAISE(auto field, FromProto(struct_.fields(i), ext_set)); DCHECK(field.is_scalar()); fields[i] = field.scalar(); } @@ -313,7 +313,7 @@ Result FromProto(const substrait::Expression::Literal& lit) { ScalarVector values(list.values_size()); for (size_t i = 0; i < values.size(); ++i) { - ARROW_ASSIGN_OR_RAISE(auto value, FromProto(list.values(i))); + ARROW_ASSIGN_OR_RAISE(auto value, FromProto(list.values(i), ext_set)); DCHECK(value.is_scalar()); values[i] = value.scalar(); if (element_type) { @@ -352,8 +352,8 @@ Result FromProto(const substrait::Expression::Literal& lit) { return Status::Invalid("While converting to MapScalar encountered missing ", missing, " in ", map.DebugString()); } - ARROW_ASSIGN_OR_RAISE(auto key, FromProto(kv.key())); - ARROW_ASSIGN_OR_RAISE(auto value, FromProto(kv.value())); + ARROW_ASSIGN_OR_RAISE(auto key, FromProto(kv.key(), ext_set)); + ARROW_ASSIGN_OR_RAISE(auto value, FromProto(kv.value(), ext_set)); DCHECK(key.is_scalar()); DCHECK(value.is_scalar()); @@ -547,8 +547,8 @@ struct ToProtoImpl { values->Reserve(static_cast(s.value->length())); for (int64_t i = 0; i < s.value->length(); ++i) { - ARROW_ASSIGN_OR_RAISE(auto scalar, s.value->GetScalar(i)); - ARROW_ASSIGN_OR_RAISE(auto lit, ToProto(Datum(std::move(scalar)))); + ARROW_ASSIGN_OR_RAISE(Datum list_element, s.value->GetScalar(i)); + ARROW_ASSIGN_OR_RAISE(auto lit, ToProto(list_element, ext_set_)); values->AddAllocated(lit.release()); } return Status::OK(); @@ -561,7 +561,7 @@ struct ToProtoImpl { fields->Reserve(static_cast(s.value.size())); for (Datum field : s.value) { - ARROW_ASSIGN_OR_RAISE(auto lit, ToProto(field)); + ARROW_ASSIGN_OR_RAISE(auto lit, ToProto(field, ext_set_)); fields->AddAllocated(lit.release()); } return Status::OK(); @@ -590,11 +590,11 @@ struct ToProtoImpl { auto kv = internal::make_unique(); ARROW_ASSIGN_OR_RAISE(Datum key_scalar, kv_arr.field(0)->GetScalar(i)); - ARROW_ASSIGN_OR_RAISE(auto key, ToProto(key_scalar)); + ARROW_ASSIGN_OR_RAISE(auto key, ToProto(key_scalar, ext_set_)); kv->set_allocated_key(key.release()); ARROW_ASSIGN_OR_RAISE(Datum value_scalar, kv_arr.field(1)->GetScalar(i)); - ARROW_ASSIGN_OR_RAISE(auto value, ToProto(value_scalar)); + ARROW_ASSIGN_OR_RAISE(auto value, ToProto(value_scalar, ext_set_)); kv->set_allocated_value(value.release()); key_values->AddAllocated(kv.release()); @@ -664,10 +664,12 @@ struct ToProtoImpl { Status operator()(const Scalar& scalar) { return VisitScalarInline(scalar, this); } substrait::Expression::Literal* lit_; + ExtensionSet* ext_set_; }; } // namespace -Result> ToProto(const Datum& datum) { +Result> ToProto(const Datum& datum, + ExtensionSet* ext_set) { if (!datum.is_scalar()) { return Status::NotImplemented("representing ", datum.ToString(), " as a substrait::Expression::Literal"); @@ -676,7 +678,7 @@ Result> ToProto(const Datum& dat auto out = internal::make_unique(); if (datum.scalar()->is_valid) { - RETURN_NOT_OK((ToProtoImpl{out.get()})(*datum.scalar())); + RETURN_NOT_OK((ToProtoImpl{out.get(), ext_set})(*datum.scalar())); } else { ExtensionSet ext_set; ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*datum.type(), /*nullable=*/true, &ext_set)); @@ -704,7 +706,8 @@ static Status AddChildToReferenceSegment( case substrait::Expression::ReferenceSegment::kStructField: { auto struct_field = segment.mutable_struct_field(); if (struct_field->has_child()) { - status = AddChildToReferenceSegment(*struct_field->mutable_child(), std::move(child)); + status = + AddChildToReferenceSegment(*struct_field->mutable_child(), std::move(child)); } else { struct_field->set_allocated_child(child.release()); status = Status::OK(); @@ -714,7 +717,8 @@ static Status AddChildToReferenceSegment( case substrait::Expression::ReferenceSegment::kListElement: { auto list_element = segment.mutable_list_element(); if (list_element->has_child()) { - status = AddChildToReferenceSegment(*list_element->mutable_child(), std::move(child)); + status = + AddChildToReferenceSegment(*list_element->mutable_child(), std::move(child)); } else { list_element->set_allocated_child(child.release()); status = Status::OK(); @@ -784,7 +788,8 @@ static Result> MakeListElementReference( return MakeDirectReference(std::move(expr), std::move(ref_segment)); } -Result> ToProto(const compute::Expression& expr) { +Result> ToProto(const compute::Expression& expr, + ExtensionSet* ext_set) { if (!expr.IsBound()) { return Status::Invalid("ToProto requires a bound Expression"); } @@ -792,7 +797,7 @@ Result> ToProto(const compute::Expression auto out = internal::make_unique(); if (auto datum = expr.literal()) { - ARROW_ASSIGN_OR_RAISE(auto literal, ToProto(*datum)); + ARROW_ASSIGN_OR_RAISE(auto literal, ToProto(*datum, ext_set)); out->set_allocated_literal(literal.release()); return std::move(out); } @@ -821,11 +826,12 @@ Result> ToProto(const compute::Expression std::vector> arguments( call->arguments.size() - 1); for (size_t i = 1; i < call->arguments.size(); ++i) { - ARROW_ASSIGN_OR_RAISE(arguments[i - 1], ToProto(call->arguments[i])); + ARROW_ASSIGN_OR_RAISE(arguments[i - 1], ToProto(call->arguments[i], ext_set)); } for (size_t i = 0; i < conditions->arguments.size(); ++i) { - ARROW_ASSIGN_OR_RAISE(auto cond_substrait, ToProto(conditions->arguments[i])); + ARROW_ASSIGN_OR_RAISE(auto cond_substrait, + ToProto(conditions->arguments[i], ext_set)); auto clause = internal::make_unique(); clause->set_allocated_if_(cond_substrait.release()); clause->set_allocated_then(arguments[i].release()); @@ -843,7 +849,7 @@ Result> ToProto(const compute::Expression // should be able to convert all its arguments first here std::vector> arguments(call->arguments.size()); for (size_t i = 0; i < arguments.size(); ++i) { - ARROW_ASSIGN_OR_RAISE(arguments[i], ToProto(call->arguments[i])); + ARROW_ASSIGN_OR_RAISE(arguments[i], ToProto(call->arguments[i], ext_set)); } if (call->function_name == "struct_field") { diff --git a/cpp/src/arrow/engine/substrait/expression_internal.h b/cpp/src/arrow/engine/substrait/expression_internal.h index 407a775df4b..057bec1bb1f 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.h +++ b/cpp/src/arrow/engine/substrait/expression_internal.h @@ -22,6 +22,7 @@ #include #include "arrow/compute/type_fwd.h" +#include "arrow/engine/substrait/extension_types.h" #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" @@ -31,16 +32,18 @@ namespace arrow { namespace engine { ARROW_ENGINE_EXPORT -Result FromProto(const substrait::Expression&); +Result FromProto(const substrait::Expression&, const ExtensionSet&); ARROW_ENGINE_EXPORT -Result> ToProto(const compute::Expression&); +Result> ToProto(const compute::Expression&, + ExtensionSet*); ARROW_ENGINE_EXPORT -Result FromProto(const substrait::Expression::Literal&); +Result FromProto(const substrait::Expression::Literal&, const ExtensionSet&); ARROW_ENGINE_EXPORT -Result> ToProto(const Datum&); +Result> ToProto(const Datum&, + ExtensionSet*); } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index 909264ea8fd..113bdf14d60 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -176,7 +176,7 @@ struct ExtensionSet::Impl { void AddUri(util::string_view uri, ExtensionSet* self) { if (uris_.find(uri) != uris_.end()) return; - self->uris_.push_back(uri.to_string()); + self->uris_.push_back(uri); uris_.insert(self->uris_.back()); // lookup helper's keys should reference memory // owned by this ExtensionSet } @@ -235,7 +235,7 @@ Result ExtensionSet::Make(std::vector uris, return Status::KeyError("Uri '", uri, "' not found in registry"); } uri = *it; // Ensure uris point into the registry's memory - set.impl_->AddUri(uri, &set); + set.impl_->AddUri(*it, &set); } if (type_ids.size() != type_is_variation.size()) { @@ -254,8 +254,8 @@ Result ExtensionSet::Make(std::vector uris, type_ids[i] = rec->id; // use Id which references memory owned by the registry continue; } - return Status::Invalid("Type ", (type_is_variation[i] ? "variation" : ""), " (", - type_ids[i].uri, ", ", type_ids[i].name, ") not found"); + return Status::Invalid("Type", (type_is_variation[i] ? " variation" : ""), " ", + type_ids[i].uri, "#", type_ids[i].name, " not found"); } set.function_names_.resize(function_ids.size()); @@ -269,8 +269,8 @@ Result ExtensionSet::Make(std::vector uris, function_ids[i] = rec->id; // use Id which references memory owned by the registry continue; } - return Status::Invalid("Function (", function_ids[i].uri, ", ", type_ids[i].name, - ") not found"); + return Status::Invalid("Function ", function_ids[i].uri, "#", type_ids[i].name, + " not found"); } set.function_ids_ = std::move(function_ids); @@ -302,8 +302,8 @@ ExtensionIdRegistry* default_extension_id_registry() { std::shared_ptr type; util::string_view name; }; + for (TypeName e : { - TypeName{null(), "null"}, TypeName{uint8(), "u8"}, TypeName{uint16(), "u16"}, TypeName{uint32(), "u32"}, @@ -312,6 +312,19 @@ ExtensionIdRegistry* default_extension_id_registry() { DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type), /*is_variation=*/true)); } + + for (TypeName e : { + TypeName{null(), "null"}, + }) { + DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type), + /*is_variation=*/false)); + } + + for (util::string_view name : { + "add", + }) { + DCHECK_OK(RegisterFunction({kArrowExtTypesUri, name}, name.to_string())); + } } std::vector Uris() const override { @@ -364,29 +377,28 @@ ExtensionIdRegistry* default_extension_id_registry() { util::optional GetFunction( util::string_view arrow_function_name) const override { if (auto index = GetIndex(function_name_to_index_, arrow_function_name)) { - return FunctionRecord{ids_[*index], *index_to_function_name_[*index]}; + return FunctionRecord{function_ids_[*index], *function_name_ptrs_[*index]}; } return {}; } util::optional GetFunction(Id id) const override { if (auto index = GetIndex(function_id_to_index_, id)) { - return FunctionRecord{ids_[*index], *index_to_function_name_[*index]}; + return FunctionRecord{function_ids_[*index], *function_name_ptrs_[*index]}; } return {}; } Status RegisterFunction(Id id, std::string arrow_function_name) override { - DCHECK_EQ(ids_.size(), types_.size()); - DCHECK_EQ(ids_.size(), type_is_variation_.size()); + DCHECK_EQ(function_ids_.size(), function_name_ptrs_.size()); Id copied_id{*uris_.emplace(id.uri.to_string()).first, *names_.emplace(id.name.to_string()).first}; - util::string_view copied_function_name{ + const std::string& copied_function_name{ *function_names_.emplace(std::move(arrow_function_name)).first}; - size_t index = ids_.size(); + size_t index = function_ids_.size(); auto it_success = function_id_to_index_.emplace(copied_id, index); @@ -396,10 +408,11 @@ ExtensionIdRegistry* default_extension_id_registry() { if (!function_name_to_index_.emplace(copied_function_name, index).second) { function_id_to_index_.erase(it_success.first); - return Status::Invalid("Type was already registered"); + return Status::Invalid("Function name was already registered"); } - ids_.push_back(copied_id); + function_name_ptrs_.push_back(&copied_function_name); + function_ids_.push_back(copied_id); return Status::OK(); } @@ -411,11 +424,11 @@ ExtensionIdRegistry* default_extension_id_registry() { std::vector type_is_variation_; // non-owning lookup helpers - std::vector ids_; + std::vector ids_, function_ids_; std::unordered_map id_to_index_, variation_id_to_index_; std::unordered_map type_to_index_; - std::vector index_to_function_name_; + std::vector function_name_ptrs_; std::unordered_map function_id_to_index_; std::unordered_map function_name_to_index_; diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index 7ea7700e5a4..f2ea92a09f7 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -163,6 +163,7 @@ class ARROW_ENGINE_EXPORT ExtensionSet { Result EncodeType(const DataType& type); const std::vector& function_ids() const { return function_ids_; } + const std::vector& function_names() const { return function_names_; } Result EncodeFunction(Id); diff --git a/cpp/src/arrow/engine/substrait/relation_internal.cc b/cpp/src/arrow/engine/substrait/relation_internal.cc index 9a68c3f643f..75dc0ecff76 100644 --- a/cpp/src/arrow/engine/substrait/relation_internal.cc +++ b/cpp/src/arrow/engine/substrait/relation_internal.cc @@ -61,12 +61,12 @@ Result FromProto(const substrait::Rel& rel, const auto& read = rel.read(); RETURN_NOT_OK(CheckRelCommon(read)); - ARROW_ASSIGN_OR_RAISE(auto base_schema, FromProto(read.base_schema())); + ARROW_ASSIGN_OR_RAISE(auto base_schema, FromProto(read.base_schema(), ext_set)); auto scan_options = std::make_shared(); if (read.has_filter()) { - ARROW_ASSIGN_OR_RAISE(scan_options->filter, FromProto(read.filter())); + ARROW_ASSIGN_OR_RAISE(scan_options->filter, FromProto(read.filter(), ext_set)); } if (read.has_projection()) { @@ -145,7 +145,7 @@ Result FromProto(const substrait::Rel& rel, if (!filter.has_condition()) { return Status::Invalid("substrait::FilterRel with no condition expression"); } - ARROW_ASSIGN_OR_RAISE(auto condition, FromProto(filter.condition())); + ARROW_ASSIGN_OR_RAISE(auto condition, FromProto(filter.condition(), ext_set)); return compute::Declaration::Sequence({ std::move(input), @@ -165,7 +165,7 @@ Result FromProto(const substrait::Rel& rel, std::vector expressions; for (const auto& expr : project.expressions()) { expressions.emplace_back(); - ARROW_ASSIGN_OR_RAISE(expressions.back(), FromProto(expr)); + ARROW_ASSIGN_OR_RAISE(expressions.back(), FromProto(expr, ext_set)); } return compute::Declaration::Sequence({ diff --git a/cpp/src/arrow/engine/substrait/serde.cc b/cpp/src/arrow/engine/substrait/serde.cc index a46df728678..ea916d86757 100644 --- a/cpp/src/arrow/engine/substrait/serde.cc +++ b/cpp/src/arrow/engine/substrait/serde.cc @@ -52,36 +52,49 @@ Result ParseFromBuffer(const Buffer& buf) { return message; } -Result Convert(const substrait::PlanRel& relation) { - return Status::NotImplemented(""); -} - Result DeserializeRelation(const Buffer& buf, const ExtensionSet& ext_set) { ARROW_ASSIGN_OR_RAISE(auto rel, ParseFromBuffer(buf)); return FromProto(rel, ext_set); } -Result> DeserializePlan(const Buffer& buf, - const ConsumerFactory&) { +Result> DeserializePlan( + const Buffer& buf, const ConsumerFactory& consumer_factory, + ExtensionSet* ext_set_out) { ARROW_ASSIGN_OR_RAISE(auto plan, ParseFromBuffer(buf)); - std::vector decls; - for (const auto& relation : plan.relations()) { - ARROW_ASSIGN_OR_RAISE(auto decl, Convert(relation)); - decls.push_back(std::move(decl)); + ARROW_ASSIGN_OR_RAISE(auto ext_set, GetExtensionSetFromPlan(plan)); + + std::vector sink_decls; + for (const substrait::PlanRel& plan_rel : plan.relations()) { + if (plan_rel.has_root()) { + return Status::NotImplemented("substrait::PlanRel with custom output field names"); + } + ARROW_ASSIGN_OR_RAISE(auto decl, FromProto(plan_rel.rel(), ext_set)); + + // pipe each relation into a consuming_sink node + auto sink_decl = compute::Declaration::Sequence({ + std::move(decl), + {"consuming_sink", compute::ConsumingSinkNodeOptions{consumer_factory()}}, + }); + sink_decls.push_back(std::move(sink_decl)); } - return decls; + if (ext_set_out) { + *ext_set_out = std::move(ext_set); + } + return sink_decls; } -Result> DeserializeSchema(const Buffer& buf) { +Result> DeserializeSchema(const Buffer& buf, + const ExtensionSet& ext_set) { ARROW_ASSIGN_OR_RAISE(auto named_struct, ParseFromBuffer(buf)); - return FromProto(named_struct); + return FromProto(named_struct, ext_set); } -Result> SerializeSchema(const Schema& schema) { - ARROW_ASSIGN_OR_RAISE(auto named_struct, ToProto(schema)); +Result> SerializeSchema(const Schema& schema, + ExtensionSet* ext_set) { + ARROW_ASSIGN_OR_RAISE(auto named_struct, ToProto(schema, ext_set)); std::string serialized = named_struct->SerializeAsString(); return Buffer::FromString(std::move(serialized)); } @@ -100,13 +113,15 @@ Result> SerializeType(const DataType& type, return Buffer::FromString(std::move(serialized)); } -Result DeserializeExpression(const Buffer& buf) { +Result DeserializeExpression(const Buffer& buf, + const ExtensionSet& ext_set) { ARROW_ASSIGN_OR_RAISE(auto expr, ParseFromBuffer(buf)); - return FromProto(expr); + return FromProto(expr, ext_set); } -Result> SerializeExpression(const compute::Expression& expr) { - ARROW_ASSIGN_OR_RAISE(auto st_expr, ToProto(expr)); +Result> SerializeExpression(const compute::Expression& expr, + ExtensionSet* ext_set) { + ARROW_ASSIGN_OR_RAISE(auto st_expr, ToProto(expr, ext_set)); std::string serialized = st_expr->SerializeAsString(); return Buffer::FromString(std::move(serialized)); } diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index 3dd27a07adf..68970cb6137 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -37,7 +37,7 @@ namespace engine { using ConsumerFactory = std::function()>; ARROW_ENGINE_EXPORT Result> DeserializePlan( - const Buffer&, const ConsumerFactory&); + const Buffer&, const ConsumerFactory&, ExtensionSet* ext_set = NULLPTR); ARROW_ENGINE_EXPORT Result> DeserializeType(const Buffer&, const ExtensionSet&); @@ -46,16 +46,17 @@ ARROW_ENGINE_EXPORT Result> SerializeType(const DataType&, ExtensionSet*); ARROW_ENGINE_EXPORT -Result> DeserializeSchema(const Buffer&); +Result> DeserializeSchema(const Buffer&, const ExtensionSet&); ARROW_ENGINE_EXPORT -Result> SerializeSchema(const Schema&); +Result> SerializeSchema(const Schema&, ExtensionSet*); ARROW_ENGINE_EXPORT -Result DeserializeExpression(const Buffer&); +Result DeserializeExpression(const Buffer&, const ExtensionSet&); ARROW_ENGINE_EXPORT -Result> SerializeExpression(const compute::Expression&); +Result> SerializeExpression(const compute::Expression&, + ExtensionSet*); ARROW_ENGINE_EXPORT Result DeserializeRelation(const Buffer&, const ExtensionSet&); diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 2cd26ee2af5..9d4f2e4dcce 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -209,6 +209,8 @@ TEST(Substrait, SupportedExtensionTypes) { } TEST(Substrait, NamedStruct) { + ExtensionSet ext_set; + auto buf = SubstraitFromJSON("NamedStruct", R"({ "struct": { "types": [ @@ -225,7 +227,7 @@ TEST(Substrait, NamedStruct) { }, "names": ["a", "b", "c", "d", "e", "f"] })"); - ASSERT_OK_AND_ASSIGN(auto schema, DeserializeSchema(*buf)); + ASSERT_OK_AND_ASSIGN(auto schema, DeserializeSchema(*buf, ext_set)); Schema expected_schema({ field("a", int64()), field("b", list(utf8())), @@ -237,8 +239,8 @@ TEST(Substrait, NamedStruct) { }); EXPECT_EQ(*schema, expected_schema); - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeSchema(*schema)); - ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeSchema(*serialized)); + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeSchema(*schema, &ext_set)); + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeSchema(*serialized, ext_set)); EXPECT_EQ(*roundtripped, expected_schema); // too few names @@ -246,23 +248,24 @@ TEST(Substrait, NamedStruct) { "struct": {"types": [{"i32": {}}, {"i32": {}}, {"i32": {}}]}, "names": [] })"); - EXPECT_THAT(DeserializeSchema(*buf), Raises(StatusCode::Invalid)); + EXPECT_THAT(DeserializeSchema(*buf, ext_set), Raises(StatusCode::Invalid)); // too many names buf = SubstraitFromJSON("NamedStruct", R"({ "struct": {"types": []}, "names": ["a", "b", "c"] })"); - EXPECT_THAT(DeserializeSchema(*buf), Raises(StatusCode::Invalid)); + EXPECT_THAT(DeserializeSchema(*buf, ext_set), Raises(StatusCode::Invalid)); // no schema metadata allowed - EXPECT_THAT(SerializeSchema(Schema({}, key_value_metadata({{"ext", "yes"}}))), + EXPECT_THAT(SerializeSchema(Schema({}, key_value_metadata({{"ext", "yes"}})), &ext_set), Raises(StatusCode::Invalid)); // no schema metadata allowed - EXPECT_THAT(SerializeSchema( - Schema({field("a", int32(), key_value_metadata({{"ext", "yes"}}))})), - Raises(StatusCode::Invalid)); + EXPECT_THAT( + SerializeSchema(Schema({field("a", int32(), key_value_metadata({{"ext", "yes"}}))}), + &ext_set), + Raises(StatusCode::Invalid)); } TEST(Substrait, NoEquivalentArrowType) { @@ -308,13 +311,17 @@ TEST(Substrait, SupportedLiterals) { ARROW_SCOPED_TRACE(json); auto buf = SubstraitFromJSON("Expression", "{\"literal\":" + json.to_string() + "}"); - ASSERT_OK_AND_ASSIGN(auto expr, DeserializeExpression(*buf)); + ExtensionSet ext_set; + ASSERT_OK_AND_ASSIGN(auto expr, DeserializeExpression(*buf, ext_set)); ASSERT_TRUE(expr.literal()); ASSERT_THAT(*expr.literal(), DataEq(expected_value)); - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); - ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized)); + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); + EXPECT_EQ(ext_set.function_ids().size(), + 0); // shouldn't need extensions for core literals + + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set)); ASSERT_TRUE(roundtripped.literal()); ASSERT_THAT(*roundtripped.literal(), DataEq(expected_value)); @@ -408,16 +415,22 @@ TEST(Substrait, SupportedLiterals) { } TEST(Substrait, CannotDeserializeLiteral) { + ExtensionSet ext_set; + // Invalid: missing List.element_type - EXPECT_THAT(DeserializeExpression(*SubstraitFromJSON( - "Expression", R"({"literal": {"list": {"values": []}}})")), - Raises(StatusCode::Invalid)); + EXPECT_THAT( + DeserializeExpression( + *SubstraitFromJSON("Expression", R"({"literal": {"list": {"values": []}}})"), + ext_set), + Raises(StatusCode::Invalid)); // Invalid: required null literal EXPECT_THAT( - DeserializeExpression(*SubstraitFromJSON( - "Expression", - R"({"literal": {"null": {"bool": {"nullability": "NULLABILITY_REQUIRED"}}}})")), + DeserializeExpression( + *SubstraitFromJSON( + "Expression", + R"({"literal": {"null": {"bool": {"nullability": "NULLABILITY_REQUIRED"}}}})"), + ext_set), Raises(StatusCode::Invalid)); // no equivalent arrow scalar @@ -444,8 +457,12 @@ TEST(Substrait, FieldRefRoundTrip) { }) { ARROW_SCOPED_TRACE(ref.ToString()); ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); - ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized)); + + ExtensionSet ext_set; + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); + EXPECT_EQ(ext_set.function_ids().size(), + 0); // shouldn't need extensions for core field references + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set)); ASSERT_TRUE(roundtripped.field_ref()); ASSERT_OK_AND_ASSIGN(auto expected, ref.FindOne(*kBoringSchema)); @@ -459,7 +476,8 @@ TEST(Substrait, RecursiveFieldRef) { ARROW_SCOPED_TRACE(ref.ToString()); ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); + ExtensionSet ext_set; + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); auto expected = SubstraitFromJSON("Expression", R"({ "selection": { "directReference": { @@ -489,7 +507,9 @@ TEST(Substrait, FieldRefsInExpressions) { })}, compute::StructFieldOptions({0})) .Bind(*kBoringSchema)); - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); + + ExtensionSet ext_set; + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); auto expected = SubstraitFromJSON("Expression", R"({ "selection": { "directReference": { @@ -566,8 +586,15 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { }) { ARROW_SCOPED_TRACE(expr.ToString()); ASSERT_OK_AND_ASSIGN(expr, expr.Bind(*kBoringSchema)); - ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr)); - ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized)); + + ExtensionSet ext_set; + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); + + // These are special cased as core expressions in substrait; shouldn't require any + // extensions. + EXPECT_EQ(ext_set.function_ids().size(), 0); + + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set)); ASSERT_OK_AND_ASSIGN(roundtripped, roundtripped.Bind(*kBoringSchema)); EXPECT_EQ(UseBoringRefs(roundtripped), UseBoringRefs(expr)); } @@ -633,5 +660,71 @@ TEST(Substrait, ReadRel) { EXPECT_EQ(*dataset.schema(), Schema({field("i", int64()), field("b", boolean())})); } +TEST(Substrait, ExtensionSetFromPlan) { + auto buf = SubstraitFromJSON("Plan", R"({ + "relations": [ + {"rel": { + "read": { + "base_schema": { + "struct": { + "types": [ {"i64": {}}, {"bool": {}} ] + }, + "names": ["i", "b"] + }, + "local_files": { "items": [] } + } + }} + ], + "extension_uris": [ + { + "extension_uri_anchor": 7, + "uri": "https://github.com/apache/arrow/blob/master/format/substrait/extension_types.yaml" + } + ], + "extensions": [ + {"extension_type": { + "extension_uri_reference": 7, + "type_anchor": 42, + "name": "null" + }}, + {"extension_type_variation": { + "extension_uri_reference": 7, + "type_variation_anchor": 23, + "name": "u8" + }}, + {"extension_function": { + "extension_uri_reference": 7, + "function_anchor": 42, + "name": "add" + }} + ] + })"); + + ExtensionSet ext_set; + ASSERT_OK_AND_ASSIGN( + auto sink_decls, + DeserializePlan( + *buf, [] { return std::shared_ptr{nullptr}; }, + &ext_set)); + + EXPECT_EQ(ext_set.uris()[7], kArrowExtTypesUri); + + ASSERT_NE(ext_set.types()[42], nullptr); + EXPECT_EQ(ext_set.type_ids()[42].uri, kArrowExtTypesUri); + EXPECT_EQ(ext_set.type_ids()[42].name, "null"); + EXPECT_EQ(*ext_set.types()[42], NullType()); + EXPECT_FALSE(ext_set.type_is_variation(42)); + + ASSERT_NE(ext_set.types()[23], nullptr); + EXPECT_EQ(ext_set.type_ids()[23].uri, kArrowExtTypesUri); + EXPECT_EQ(ext_set.type_ids()[23].name, "u8"); + EXPECT_EQ(*ext_set.types()[23], UInt8Type()); + EXPECT_TRUE(ext_set.type_is_variation(23)); + + EXPECT_EQ(ext_set.function_ids()[42].uri, kArrowExtTypesUri); + EXPECT_EQ(ext_set.function_ids()[42].name, "add"); + EXPECT_EQ(ext_set.function_names()[42], "add"); +} + } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 1cad0049a73..6f5904ff403 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -422,7 +422,8 @@ Result> ToProto(const DataType& type, bool null return std::move(out); } -Result> FromProto(const substrait::NamedStruct& named_struct) { +Result> FromProto(const substrait::NamedStruct& named_struct, + const ExtensionSet& ext_set) { if (!named_struct.has_struct_()) { return Status::Invalid("While converting ", named_struct.DebugString(), " no anonymous struct type was provided to which to names " @@ -431,7 +432,6 @@ Result> FromProto(const substrait::NamedStruct& named_st const auto& struct_ = named_struct.struct_(); RETURN_NOT_OK(CheckVariation(struct_)); - ExtensionSet ext_set; int requested_names_count = 0; ARROW_ASSIGN_OR_RAISE(auto fields, FieldsFromProto( struct_.types_size(), struct_.types(), @@ -466,7 +466,8 @@ void ToProtoGetDepthFirstNames(const FieldVector& fields, } } // namespace -Result> ToProto(const Schema& schema) { +Result> ToProto(const Schema& schema, + ExtensionSet* ext_set) { if (schema.metadata()) { return Status::Invalid("substrait::NamedStruct does not support schema metadata"); } @@ -486,9 +487,7 @@ Result> ToProto(const Schema& schema) { return Status::Invalid("substrait::NamedStruct does not support field metadata"); } - ExtensionSet ext_set; - ARROW_ASSIGN_OR_RAISE(auto type, - ToProto(*field->type(), field->nullable(), &ext_set)); + ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*field->type(), field->nullable(), ext_set)); types->AddAllocated(type.release()); } diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h index 026e6c054bf..c3ee0c619a6 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -39,10 +39,11 @@ Result> ToProto(const DataType&, bool nullable, ExtensionSet*); ARROW_ENGINE_EXPORT -Result> FromProto(const substrait::NamedStruct&); +Result> FromProto(const substrait::NamedStruct&, + const ExtensionSet&); ARROW_ENGINE_EXPORT -Result> ToProto(const Schema&); +Result> ToProto(const Schema&, ExtensionSet*); inline std::string TimestampTzTimezoneString() { return "UTC"; } From 5e0d6e54acc5d0ab5ca8f791de84708b77ff1239 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Thu, 20 Jan 2022 17:09:51 -0500 Subject: [PATCH 053/113] add a roundtrip test for calling an extension function --- .../engine/substrait/expression_internal.cc | 18 ++++---------- .../arrow/engine/substrait/extension_types.cc | 24 ++++++++++++++++++- .../arrow/engine/substrait/extension_types.h | 2 +- cpp/src/arrow/engine/substrait/serde_test.cc | 19 +++++++++++++++ 4 files changed, 48 insertions(+), 15 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 881b629674a..e9f836af99c 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -171,7 +171,6 @@ Result FromProto(const substrait::Expression& expr, case substrait::Expression::kScalarFunction: { const auto& scalar_fn = expr.scalar_function(); - ExtensionSet ext_set; auto id = ext_set.function_ids()[scalar_fn.function_reference()]; std::vector arguments(scalar_fn.args_size()); @@ -528,10 +527,9 @@ struct ToProtoImpl { Status Visit(const Decimal256Scalar& s) { return NotImplemented(s); } Status Visit(const ListScalar& s) { - ExtensionSet ext_set; if (s.value->length() == 0) { ARROW_ASSIGN_OR_RAISE(auto list_type, - ToProto(*s.type, /*nullable=*/true, &ext_set)); + ToProto(*s.type, /*nullable=*/true, ext_set_)); lit_->set_allocated_empty_list(list_type->release_list()); return Status::OK(); } @@ -541,7 +539,7 @@ struct ToProtoImpl { const auto& list_type = checked_cast(*s.type); ARROW_ASSIGN_OR_RAISE( auto element_type, - ToProto(*list_type.value_type(), list_type.value_field()->nullable(), &ext_set)); + ToProto(*list_type.value_type(), list_type.value_field()->nullable(), ext_set_)); auto values = lit_->mutable_list()->mutable_values(); values->Reserve(static_cast(s.value->length())); @@ -572,9 +570,8 @@ struct ToProtoImpl { Status Visit(const DictionaryScalar& s) { return NotImplemented(s); } Status Visit(const MapScalar& s) { - ExtensionSet ext_set; if (s.value->length() == 0) { - ARROW_ASSIGN_OR_RAISE(auto map_type, ToProto(*s.type, /*nullable=*/true, &ext_set)); + ARROW_ASSIGN_OR_RAISE(auto map_type, ToProto(*s.type, /*nullable=*/true, ext_set_)); lit_->set_allocated_empty_map(map_type->release_map()); return Status::OK(); } @@ -680,8 +677,7 @@ Result> ToProto(const Datum& dat if (datum.scalar()->is_valid) { RETURN_NOT_OK((ToProtoImpl{out.get(), ext_set})(*datum.scalar())); } else { - ExtensionSet ext_set; - ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*datum.type(), /*nullable=*/true, &ext_set)); + ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*datum.type(), /*nullable=*/true, ext_set)); out->set_allocated_null(type.release()); } @@ -889,10 +885,8 @@ Result> ToProto(const compute::Expression return std::move(out); } - /* // other expression types dive into extensions immediately - ExtensionSet* ext_set = nullptr; - ARROW_ASSIGN_OR_RAISE(auto anchor, ext_set->EncodeFunction({"", call->function_name})); + ARROW_ASSIGN_OR_RAISE(auto anchor, ext_set->EncodeFunction(call->function_name)); auto scalar_fn = internal::make_unique(); scalar_fn->set_function_reference(anchor); @@ -903,8 +897,6 @@ Result> ToProto(const compute::Expression out->set_allocated_scalar_function(scalar_fn.release()); return std::move(out); - */ - return Status::NotImplemented(""); } } // namespace engine diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index 113bdf14d60..7ade57952cf 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -206,8 +206,23 @@ struct ExtensionSet::Impl { return it_success.first->second; } + uint32_t EncodeFunction(Id id, util::string_view function_name, ExtensionSet* self) { + // note: at this point we're guaranteed to have an Id which points to memory owned by + // the set's registry. + AddUri(id.uri, self); + auto it_success = functions_.emplace(id, static_cast(functions_.size())); + + if (it_success.second) { + DCHECK_EQ(self->function_ids_.size(), self->function_names_.size()); + self->function_ids_.push_back(id); + self->function_names_.push_back(function_name); + } + + return it_success.first->second; + } + std::unordered_set uris_; - std::unordered_map types_; + std::unordered_map types_, functions_; }; ExtensionSet::ExtensionSet(ExtensionIdRegistry* registry) @@ -288,6 +303,13 @@ Result ExtensionSet::EncodeType(const DataType& type) { return Status::KeyError("type ", type.ToString(), " not found in the registry"); } +Result ExtensionSet::EncodeFunction(util::string_view function_name) { + if (auto rec = registry_->GetFunction(function_name)) { + return impl_->EncodeFunction(rec->id, rec->function_name, this); + } + return Status::KeyError("function ", function_name, " not found in the registry"); +} + template const int* GetIndex(const KeyToIndex& key_to_index, const Key& key) { auto it = key_to_index.find(key); diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index f2ea92a09f7..b392fffe797 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -165,7 +165,7 @@ class ARROW_ENGINE_EXPORT ExtensionSet { const std::vector& function_ids() const { return function_ids_; } const std::vector& function_names() const { return function_names_; } - Result EncodeFunction(Id); + Result EncodeFunction(util::string_view function_name); private: ExtensionIdRegistry* registry_; diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 9d4f2e4dcce..e0b3952bcb2 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -600,6 +600,25 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { } } +TEST(Substrait, CallExtensionFunction) { + for (compute::Expression expr : { + compute::call("add", {compute::literal(0), compute::literal(1)}), + }) { + ARROW_SCOPED_TRACE(expr.ToString()); + ASSERT_OK_AND_ASSIGN(expr, expr.Bind(*kBoringSchema)); + + ExtensionSet ext_set; + ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); + + // These require an extension, so we should have a single-element ext_set. + EXPECT_EQ(ext_set.function_ids().size(), 1); + + ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set)); + ASSERT_OK_AND_ASSIGN(roundtripped, roundtripped.Bind(*kBoringSchema)); + EXPECT_EQ(UseBoringRefs(roundtripped), UseBoringRefs(expr)); + } +} + TEST(Substrait, ReadRel) { auto buf = SubstraitFromJSON("Rel", R"({ "read": { From cd22ef00820c28ec8b583cbd2273d08bda30722d Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 10:05:50 -0500 Subject: [PATCH 054/113] repair status_test::MatcherExplanations --- cpp/src/arrow/status_test.cc | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/cpp/src/arrow/status_test.cc b/cpp/src/arrow/status_test.cc index 10a79d9b990..a8e1d1ca9a8 100644 --- a/cpp/src/arrow/status_test.cc +++ b/cpp/src/arrow/status_test.cc @@ -179,20 +179,19 @@ TEST(StatusTest, MatcherExplanations) { { testing::StringMatchResultListener listener; EXPECT_TRUE(matcher.MatchAndExplain(Status::Invalid("XXX"), &listener)); - EXPECT_THAT(listener.str(), testing::StrEq("whose value \"Invalid: XXX\" matches")); + EXPECT_THAT(listener.str(), testing::StrEq("whose error matches")); } { testing::StringMatchResultListener listener; EXPECT_FALSE(matcher.MatchAndExplain(Status::OK(), &listener)); - EXPECT_THAT(listener.str(), testing::StrEq("whose value \"OK\" doesn't match")); + EXPECT_THAT(listener.str(), testing::StrEq("whose non-error doesn't match")); } { testing::StringMatchResultListener listener; EXPECT_FALSE(matcher.MatchAndExplain(Status::TypeError("XXX"), &listener)); - EXPECT_THAT(listener.str(), - testing::StrEq("whose value \"Type error: XXX\" doesn't match")); + EXPECT_THAT(listener.str(), testing::StrEq("whose error doesn't match")); } } From 1dc4c9d4cbaaff2800a219952ed95785653b4b73 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 10:12:23 -0500 Subject: [PATCH 055/113] removing old generated extension files --- cpp/src/generated/substrait/extensions.pb.cc | 1895 ------------------ cpp/src/generated/substrait/extensions.pb.h | 1835 ----------------- 2 files changed, 3730 deletions(-) delete mode 100644 cpp/src/generated/substrait/extensions.pb.cc delete mode 100644 cpp/src/generated/substrait/extensions.pb.h diff --git a/cpp/src/generated/substrait/extensions.pb.cc b/cpp/src/generated/substrait/extensions.pb.cc deleted file mode 100644 index a5d7c540cf2..00000000000 --- a/cpp/src/generated/substrait/extensions.pb.cc +++ /dev/null @@ -1,1895 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: extensions.proto - -#include "extensions.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace io { -namespace substrait { -namespace extensions { -constexpr SimpleExtensionURI::SimpleExtensionURI( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , extension_uri_anchor_(0u){} -struct SimpleExtensionURIDefaultTypeInternal { - constexpr SimpleExtensionURIDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SimpleExtensionURIDefaultTypeInternal() {} - union { - SimpleExtensionURI _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionURIDefaultTypeInternal _SimpleExtensionURI_default_instance_; -constexpr SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , extension_uri_reference_(0u) - , type_anchor_(0u){} -struct SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal { - constexpr SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal() {} - union { - SimpleExtensionDeclaration_ExtensionType _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionType_default_instance_; -constexpr SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , extension_uri_pointer_(0u) - , type_variation_anchor_(0u){} -struct SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal { - constexpr SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal() {} - union { - SimpleExtensionDeclaration_ExtensionTypeVariation _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_; -constexpr SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , extension_uri_pointer_(0u) - , function_anchor_(0u){} -struct SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal { - constexpr SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal() {} - union { - SimpleExtensionDeclaration_ExtensionFunction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionFunction_default_instance_; -constexpr SimpleExtensionDeclaration::SimpleExtensionDeclaration( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct SimpleExtensionDeclarationDefaultTypeInternal { - constexpr SimpleExtensionDeclarationDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SimpleExtensionDeclarationDefaultTypeInternal() {} - union { - SimpleExtensionDeclaration _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclarationDefaultTypeInternal _SimpleExtensionDeclaration_default_instance_; -constexpr AdvancedExtension::AdvancedExtension( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : optimization_(nullptr) - , enhancement_(nullptr){} -struct AdvancedExtensionDefaultTypeInternal { - constexpr AdvancedExtensionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~AdvancedExtensionDefaultTypeInternal() {} - union { - AdvancedExtension _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AdvancedExtensionDefaultTypeInternal _AdvancedExtension_default_instance_; -} // namespace extensions -} // namespace substrait -} // namespace io -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_extensions_2eproto[6]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_extensions_2eproto = nullptr; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_extensions_2eproto = nullptr; - -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_extensions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionURI, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionURI, extension_uri_anchor_), - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionURI, uri_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_), - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, type_anchor_), - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, name_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_), - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, name_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, extension_uri_pointer_), - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, function_anchor_), - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, name_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::SimpleExtensionDeclaration, mapping_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::AdvancedExtension, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::AdvancedExtension, optimization_), - PROTOBUF_FIELD_OFFSET(::io::substrait::extensions::AdvancedExtension, enhancement_), -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::io::substrait::extensions::SimpleExtensionURI)}, - { 7, -1, sizeof(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType)}, - { 15, -1, sizeof(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation)}, - { 23, -1, sizeof(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction)}, - { 31, -1, sizeof(::io::substrait::extensions::SimpleExtensionDeclaration)}, - { 40, -1, sizeof(::io::substrait::extensions::AdvancedExtension)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::io::substrait::extensions::_SimpleExtensionURI_default_instance_), - reinterpret_cast(&::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_), - reinterpret_cast(&::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_), - reinterpret_cast(&::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_), - reinterpret_cast(&::io::substrait::extensions::_SimpleExtensionDeclaration_default_instance_), - reinterpret_cast(&::io::substrait::extensions::_AdvancedExtension_default_instance_), -}; - -const char descriptor_table_protodef_extensions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\020extensions.proto\022\027io.substrait.extensi" - "ons\032\031google/protobuf/any.proto\"\?\n\022Simple" - "ExtensionURI\022\034\n\024extension_uri_anchor\030\001 \001" - "(\r\022\013\n\003uri\030\002 \001(\t\"\364\004\n\032SimpleExtensionDecla" - "ration\022[\n\016extension_type\030\001 \001(\0132A.io.subs" - "trait.extensions.SimpleExtensionDeclarat" - "ion.ExtensionTypeH\000\022n\n\030extension_type_va" - "riation\030\002 \001(\0132J.io.substrait.extensions." - "SimpleExtensionDeclaration.ExtensionType" - "VariationH\000\022c\n\022extension_function\030\003 \001(\0132" - "E.io.substrait.extensions.SimpleExtensio" - "nDeclaration.ExtensionFunctionH\000\032S\n\rExte" - "nsionType\022\037\n\027extension_uri_reference\030\001 \001" - "(\r\022\023\n\013type_anchor\030\002 \001(\r\022\014\n\004name\030\003 \001(\t\032d\n" - "\026ExtensionTypeVariation\022\035\n\025extension_uri" - "_pointer\030\001 \001(\r\022\035\n\025type_variation_anchor\030" - "\002 \001(\r\022\014\n\004name\030\003 \001(\t\032Y\n\021ExtensionFunction" - "\022\035\n\025extension_uri_pointer\030\001 \001(\r\022\027\n\017funct" - "ion_anchor\030\002 \001(\r\022\014\n\004name\030\003 \001(\tB\016\n\014mappin" - "g_type\"j\n\021AdvancedExtension\022*\n\014optimizat" - "ion\030\001 \001(\0132\024.google.protobuf.Any\022)\n\013enhan" - "cement\030\002 \001(\0132\024.google.protobuf.AnyB+\n\022io" - ".substrait.protoP\001\252\002\022Substrait.Protobufb" - "\006proto3" - ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_extensions_2eproto_deps[1] = { - &::descriptor_table_google_2fprotobuf_2fany_2eproto, -}; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_extensions_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_extensions_2eproto = { - false, false, 927, descriptor_table_protodef_extensions_2eproto, "extensions.proto", - &descriptor_table_extensions_2eproto_once, descriptor_table_extensions_2eproto_deps, 1, 6, - schemas, file_default_instances, TableStruct_extensions_2eproto::offsets, - file_level_metadata_extensions_2eproto, file_level_enum_descriptors_extensions_2eproto, file_level_service_descriptors_extensions_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_extensions_2eproto_getter() { - return &descriptor_table_extensions_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_extensions_2eproto(&descriptor_table_extensions_2eproto); -namespace io { -namespace substrait { -namespace extensions { - -// =================================================================== - -class SimpleExtensionURI::_Internal { - public: -}; - -SimpleExtensionURI::SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.SimpleExtensionURI) -} -SimpleExtensionURI::SimpleExtensionURI(const SimpleExtensionURI& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_uri().empty()) { - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), - GetArena()); - } - extension_uri_anchor_ = from.extension_uri_anchor_; - // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.SimpleExtensionURI) -} - -void SimpleExtensionURI::SharedCtor() { -uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -extension_uri_anchor_ = 0u; -} - -SimpleExtensionURI::~SimpleExtensionURI() { - // @@protoc_insertion_point(destructor:io.substrait.extensions.SimpleExtensionURI) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void SimpleExtensionURI::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void SimpleExtensionURI::ArenaDtor(void* object) { - SimpleExtensionURI* _this = reinterpret_cast< SimpleExtensionURI* >(object); - (void)_this; -} -void SimpleExtensionURI::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SimpleExtensionURI::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SimpleExtensionURI::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.SimpleExtensionURI) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - uri_.ClearToEmpty(); - extension_uri_anchor_ = 0u; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SimpleExtensionURI::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 extension_uri_anchor = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - extension_uri_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // string uri = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - auto str = _internal_mutable_uri(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.extensions.SimpleExtensionURI.uri")); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionURI::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.SimpleExtensionURI) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 extension_uri_anchor = 1; - if (this->extension_uri_anchor() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_anchor(), target); - } - - // string uri = 2; - if (this->uri().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_uri().data(), static_cast(this->_internal_uri().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.extensions.SimpleExtensionURI.uri"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_uri(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.SimpleExtensionURI) - return target; -} - -size_t SimpleExtensionURI::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.SimpleExtensionURI) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // string uri = 2; - if (this->uri().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_uri()); - } - - // uint32 extension_uri_anchor = 1; - if (this->extension_uri_anchor() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_extension_uri_anchor()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void SimpleExtensionURI::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.SimpleExtensionURI) - GOOGLE_DCHECK_NE(&from, this); - const SimpleExtensionURI* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.SimpleExtensionURI) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.SimpleExtensionURI) - MergeFrom(*source); - } -} - -void SimpleExtensionURI::MergeFrom(const SimpleExtensionURI& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.SimpleExtensionURI) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.uri().size() > 0) { - _internal_set_uri(from._internal_uri()); - } - if (from.extension_uri_anchor() != 0) { - _internal_set_extension_uri_anchor(from._internal_extension_uri_anchor()); - } -} - -void SimpleExtensionURI::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.SimpleExtensionURI) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void SimpleExtensionURI::CopyFrom(const SimpleExtensionURI& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.SimpleExtensionURI) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SimpleExtensionURI::IsInitialized() const { - return true; -} - -void SimpleExtensionURI::InternalSwap(SimpleExtensionURI* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - uri_.Swap(&other->uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - swap(extension_uri_anchor_, other->extension_uri_anchor_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionURI::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[0]); -} - -// =================================================================== - -class SimpleExtensionDeclaration_ExtensionType::_Internal { - public: -}; - -SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) -} -SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); - } - ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, - static_cast(reinterpret_cast(&type_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) -} - -void SimpleExtensionDeclaration_ExtensionType::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&type_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); -} - -SimpleExtensionDeclaration_ExtensionType::~SimpleExtensionDeclaration_ExtensionType() { - // @@protoc_insertion_point(destructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void SimpleExtensionDeclaration_ExtensionType::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void SimpleExtensionDeclaration_ExtensionType::ArenaDtor(void* object) { - SimpleExtensionDeclaration_ExtensionType* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionType* >(object); - (void)_this; -} -void SimpleExtensionDeclaration_ExtensionType::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SimpleExtensionDeclaration_ExtensionType::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SimpleExtensionDeclaration_ExtensionType::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmpty(); - ::memset(&extension_uri_reference_, 0, static_cast( - reinterpret_cast(&type_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SimpleExtensionDeclaration_ExtensionType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 extension_uri_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // uint32 type_anchor = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - type_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name")); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionType::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 extension_uri_reference = 1; - if (this->extension_uri_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); - } - - // uint32 type_anchor = 2; - if (this->type_anchor() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_anchor(), target); - } - - // string name = 3; - if (this->name().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_name(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - return target; -} - -size_t SimpleExtensionDeclaration_ExtensionType::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // string name = 3; - if (this->name().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // uint32 extension_uri_reference = 1; - if (this->extension_uri_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_extension_uri_reference()); - } - - // uint32 type_anchor = 2; - if (this->type_anchor() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_anchor()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void SimpleExtensionDeclaration_ExtensionType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - GOOGLE_DCHECK_NE(&from, this); - const SimpleExtensionDeclaration_ExtensionType* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - MergeFrom(*source); - } -} - -void SimpleExtensionDeclaration_ExtensionType::MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.name().size() > 0) { - _internal_set_name(from._internal_name()); - } - if (from.extension_uri_reference() != 0) { - _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); - } - if (from.type_anchor() != 0) { - _internal_set_type_anchor(from._internal_type_anchor()); - } -} - -void SimpleExtensionDeclaration_ExtensionType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void SimpleExtensionDeclaration_ExtensionType::CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SimpleExtensionDeclaration_ExtensionType::IsInitialized() const { - return true; -} - -void SimpleExtensionDeclaration_ExtensionType::InternalSwap(SimpleExtensionDeclaration_ExtensionType* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, type_anchor_) - + sizeof(SimpleExtensionDeclaration_ExtensionType::type_anchor_) - - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_)>( - reinterpret_cast(&extension_uri_reference_), - reinterpret_cast(&other->extension_uri_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionType::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[1]); -} - -// =================================================================== - -class SimpleExtensionDeclaration_ExtensionTypeVariation::_Internal { - public: -}; - -SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) -} -SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); - } - ::memcpy(&extension_uri_pointer_, &from.extension_uri_pointer_, - static_cast(reinterpret_cast(&type_variation_anchor_) - - reinterpret_cast(&extension_uri_pointer_)) + sizeof(type_variation_anchor_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&extension_uri_pointer_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&type_variation_anchor_) - - reinterpret_cast(&extension_uri_pointer_)) + sizeof(type_variation_anchor_)); -} - -SimpleExtensionDeclaration_ExtensionTypeVariation::~SimpleExtensionDeclaration_ExtensionTypeVariation() { - // @@protoc_insertion_point(destructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::ArenaDtor(void* object) { - SimpleExtensionDeclaration_ExtensionTypeVariation* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionTypeVariation* >(object); - (void)_this; -} -void SimpleExtensionDeclaration_ExtensionTypeVariation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SimpleExtensionDeclaration_ExtensionTypeVariation::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmpty(); - ::memset(&extension_uri_pointer_, 0, static_cast( - reinterpret_cast(&type_variation_anchor_) - - reinterpret_cast(&extension_uri_pointer_)) + sizeof(type_variation_anchor_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 extension_uri_pointer = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - extension_uri_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // uint32 type_variation_anchor = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - type_variation_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name")); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 extension_uri_pointer = 1; - if (this->extension_uri_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_pointer(), target); - } - - // uint32 type_variation_anchor = 2; - if (this->type_variation_anchor() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_anchor(), target); - } - - // string name = 3; - if (this->name().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_name(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - return target; -} - -size_t SimpleExtensionDeclaration_ExtensionTypeVariation::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // string name = 3; - if (this->name().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // uint32 extension_uri_pointer = 1; - if (this->extension_uri_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_extension_uri_pointer()); - } - - // uint32 type_variation_anchor = 2; - if (this->type_variation_anchor() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_anchor()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - GOOGLE_DCHECK_NE(&from, this); - const SimpleExtensionDeclaration_ExtensionTypeVariation* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - MergeFrom(*source); - } -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.name().size() > 0) { - _internal_set_name(from._internal_name()); - } - if (from.extension_uri_pointer() != 0) { - _internal_set_extension_uri_pointer(from._internal_extension_uri_pointer()); - } - if (from.type_variation_anchor() != 0) { - _internal_set_type_variation_anchor(from._internal_type_variation_anchor()); - } -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SimpleExtensionDeclaration_ExtensionTypeVariation::IsInitialized() const { - return true; -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_) - + sizeof(SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor_) - - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_pointer_)>( - reinterpret_cast(&extension_uri_pointer_), - reinterpret_cast(&other->extension_uri_pointer_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionTypeVariation::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[2]); -} - -// =================================================================== - -class SimpleExtensionDeclaration_ExtensionFunction::_Internal { - public: -}; - -SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) -} -SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); - } - ::memcpy(&extension_uri_pointer_, &from.extension_uri_pointer_, - static_cast(reinterpret_cast(&function_anchor_) - - reinterpret_cast(&extension_uri_pointer_)) + sizeof(function_anchor_)); - // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) -} - -void SimpleExtensionDeclaration_ExtensionFunction::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&extension_uri_pointer_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&function_anchor_) - - reinterpret_cast(&extension_uri_pointer_)) + sizeof(function_anchor_)); -} - -SimpleExtensionDeclaration_ExtensionFunction::~SimpleExtensionDeclaration_ExtensionFunction() { - // @@protoc_insertion_point(destructor:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void SimpleExtensionDeclaration_ExtensionFunction::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void SimpleExtensionDeclaration_ExtensionFunction::ArenaDtor(void* object) { - SimpleExtensionDeclaration_ExtensionFunction* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionFunction* >(object); - (void)_this; -} -void SimpleExtensionDeclaration_ExtensionFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SimpleExtensionDeclaration_ExtensionFunction::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SimpleExtensionDeclaration_ExtensionFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmpty(); - ::memset(&extension_uri_pointer_, 0, static_cast( - reinterpret_cast(&function_anchor_) - - reinterpret_cast(&extension_uri_pointer_)) + sizeof(function_anchor_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SimpleExtensionDeclaration_ExtensionFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 extension_uri_pointer = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - extension_uri_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // uint32 function_anchor = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - function_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name")); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionFunction::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 extension_uri_pointer = 1; - if (this->extension_uri_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_pointer(), target); - } - - // uint32 function_anchor = 2; - if (this->function_anchor() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_function_anchor(), target); - } - - // string name = 3; - if (this->name().size() > 0) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_name(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - return target; -} - -size_t SimpleExtensionDeclaration_ExtensionFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // string name = 3; - if (this->name().size() > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // uint32 extension_uri_pointer = 1; - if (this->extension_uri_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_extension_uri_pointer()); - } - - // uint32 function_anchor = 2; - if (this->function_anchor() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_function_anchor()); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - GOOGLE_DCHECK_NE(&from, this); - const SimpleExtensionDeclaration_ExtensionFunction* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - MergeFrom(*source); - } -} - -void SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.name().size() > 0) { - _internal_set_name(from._internal_name()); - } - if (from.extension_uri_pointer() != 0) { - _internal_set_extension_uri_pointer(from._internal_extension_uri_pointer()); - } - if (from.function_anchor() != 0) { - _internal_set_function_anchor(from._internal_function_anchor()); - } -} - -void SimpleExtensionDeclaration_ExtensionFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void SimpleExtensionDeclaration_ExtensionFunction::CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SimpleExtensionDeclaration_ExtensionFunction::IsInitialized() const { - return true; -} - -void SimpleExtensionDeclaration_ExtensionFunction::InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, function_anchor_) - + sizeof(SimpleExtensionDeclaration_ExtensionFunction::function_anchor_) - - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, extension_uri_pointer_)>( - reinterpret_cast(&extension_uri_pointer_), - reinterpret_cast(&other->extension_uri_pointer_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionFunction::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[3]); -} - -// =================================================================== - -class SimpleExtensionDeclaration::_Internal { - public: - static const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type(const SimpleExtensionDeclaration* msg); - static const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation(const SimpleExtensionDeclaration* msg); - static const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function(const SimpleExtensionDeclaration* msg); -}; - -const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& -SimpleExtensionDeclaration::_Internal::extension_type(const SimpleExtensionDeclaration* msg) { - return *msg->mapping_type_.extension_type_; -} -const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& -SimpleExtensionDeclaration::_Internal::extension_type_variation(const SimpleExtensionDeclaration* msg) { - return *msg->mapping_type_.extension_type_variation_; -} -const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& -SimpleExtensionDeclaration::_Internal::extension_function(const SimpleExtensionDeclaration* msg) { - return *msg->mapping_type_.extension_function_; -} -void SimpleExtensionDeclaration::set_allocated_extension_type(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_mapping_type(); - if (extension_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_type); - if (message_arena != submessage_arena) { - extension_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_type, submessage_arena); - } - set_has_extension_type(); - mapping_type_.extension_type_ = extension_type; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) -} -void SimpleExtensionDeclaration::set_allocated_extension_type_variation(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_mapping_type(); - if (extension_type_variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_type_variation); - if (message_arena != submessage_arena) { - extension_type_variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_type_variation, submessage_arena); - } - set_has_extension_type_variation(); - mapping_type_.extension_type_variation_ = extension_type_variation; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) -} -void SimpleExtensionDeclaration::set_allocated_extension_function(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - clear_mapping_type(); - if (extension_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_function); - if (message_arena != submessage_arena) { - extension_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_function, submessage_arena); - } - set_has_extension_function(); - mapping_type_.extension_function_ = extension_function; - } - // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) -} -SimpleExtensionDeclaration::SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.SimpleExtensionDeclaration) -} -SimpleExtensionDeclaration::SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_mapping_type(); - switch (from.mapping_type_case()) { - case kExtensionType: { - _internal_mutable_extension_type()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType::MergeFrom(from._internal_extension_type()); - break; - } - case kExtensionTypeVariation: { - _internal_mutable_extension_type_variation()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(from._internal_extension_type_variation()); - break; - } - case kExtensionFunction: { - _internal_mutable_extension_function()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(from._internal_extension_function()); - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.SimpleExtensionDeclaration) -} - -void SimpleExtensionDeclaration::SharedCtor() { -clear_has_mapping_type(); -} - -SimpleExtensionDeclaration::~SimpleExtensionDeclaration() { - // @@protoc_insertion_point(destructor:io.substrait.extensions.SimpleExtensionDeclaration) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void SimpleExtensionDeclaration::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (has_mapping_type()) { - clear_mapping_type(); - } -} - -void SimpleExtensionDeclaration::ArenaDtor(void* object) { - SimpleExtensionDeclaration* _this = reinterpret_cast< SimpleExtensionDeclaration* >(object); - (void)_this; -} -void SimpleExtensionDeclaration::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SimpleExtensionDeclaration::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SimpleExtensionDeclaration::clear_mapping_type() { -// @@protoc_insertion_point(one_of_clear_start:io.substrait.extensions.SimpleExtensionDeclaration) - switch (mapping_type_case()) { - case kExtensionType: { - if (GetArena() == nullptr) { - delete mapping_type_.extension_type_; - } - break; - } - case kExtensionTypeVariation: { - if (GetArena() == nullptr) { - delete mapping_type_.extension_type_variation_; - } - break; - } - case kExtensionFunction: { - if (GetArena() == nullptr) { - delete mapping_type_.extension_function_; - } - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = MAPPING_TYPE_NOT_SET; -} - - -void SimpleExtensionDeclaration::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.SimpleExtensionDeclaration) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_mapping_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SimpleExtensionDeclaration::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_type(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_type_variation(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_function(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.SimpleExtensionDeclaration) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; - if (_internal_has_extension_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::extension_type(this), target, stream); - } - - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; - if (_internal_has_extension_type_variation()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::extension_type_variation(this), target, stream); - } - - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; - if (_internal_has_extension_function()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::extension_function(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.SimpleExtensionDeclaration) - return target; -} - -size_t SimpleExtensionDeclaration::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.SimpleExtensionDeclaration) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (mapping_type_case()) { - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; - case kExtensionType: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *mapping_type_.extension_type_); - break; - } - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; - case kExtensionTypeVariation: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *mapping_type_.extension_type_variation_); - break; - } - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; - case kExtensionFunction: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *mapping_type_.extension_function_); - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void SimpleExtensionDeclaration::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration) - GOOGLE_DCHECK_NE(&from, this); - const SimpleExtensionDeclaration* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.SimpleExtensionDeclaration) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.SimpleExtensionDeclaration) - MergeFrom(*source); - } -} - -void SimpleExtensionDeclaration::MergeFrom(const SimpleExtensionDeclaration& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.SimpleExtensionDeclaration) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.mapping_type_case()) { - case kExtensionType: { - _internal_mutable_extension_type()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType::MergeFrom(from._internal_extension_type()); - break; - } - case kExtensionTypeVariation: { - _internal_mutable_extension_type_variation()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(from._internal_extension_type_variation()); - break; - } - case kExtensionFunction: { - _internal_mutable_extension_function()->::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(from._internal_extension_function()); - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } -} - -void SimpleExtensionDeclaration::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void SimpleExtensionDeclaration::CopyFrom(const SimpleExtensionDeclaration& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.SimpleExtensionDeclaration) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SimpleExtensionDeclaration::IsInitialized() const { - return true; -} - -void SimpleExtensionDeclaration::InternalSwap(SimpleExtensionDeclaration* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - swap(mapping_type_, other->mapping_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[4]); -} - -// =================================================================== - -class AdvancedExtension::_Internal { - public: - static const PROTOBUF_NAMESPACE_ID::Any& optimization(const AdvancedExtension* msg); - static const PROTOBUF_NAMESPACE_ID::Any& enhancement(const AdvancedExtension* msg); -}; - -const PROTOBUF_NAMESPACE_ID::Any& -AdvancedExtension::_Internal::optimization(const AdvancedExtension* msg) { - return *msg->optimization_; -} -const PROTOBUF_NAMESPACE_ID::Any& -AdvancedExtension::_Internal::enhancement(const AdvancedExtension* msg) { - return *msg->enhancement_; -} -void AdvancedExtension::clear_optimization() { - if (GetArena() == nullptr && optimization_ != nullptr) { - delete optimization_; - } - optimization_ = nullptr; -} -void AdvancedExtension::clear_enhancement() { - if (GetArena() == nullptr && enhancement_ != nullptr) { - delete enhancement_; - } - enhancement_ = nullptr; -} -AdvancedExtension::AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); - // @@protoc_insertion_point(arena_constructor:io.substrait.extensions.AdvancedExtension) -} -AdvancedExtension::AdvancedExtension(const AdvancedExtension& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_optimization()) { - optimization_ = new PROTOBUF_NAMESPACE_ID::Any(*from.optimization_); - } else { - optimization_ = nullptr; - } - if (from._internal_has_enhancement()) { - enhancement_ = new PROTOBUF_NAMESPACE_ID::Any(*from.enhancement_); - } else { - enhancement_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:io.substrait.extensions.AdvancedExtension) -} - -void AdvancedExtension::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&optimization_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&enhancement_) - - reinterpret_cast(&optimization_)) + sizeof(enhancement_)); -} - -AdvancedExtension::~AdvancedExtension() { - // @@protoc_insertion_point(destructor:io.substrait.extensions.AdvancedExtension) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void AdvancedExtension::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); - if (this != internal_default_instance()) delete optimization_; - if (this != internal_default_instance()) delete enhancement_; -} - -void AdvancedExtension::ArenaDtor(void* object) { - AdvancedExtension* _this = reinterpret_cast< AdvancedExtension* >(object); - (void)_this; -} -void AdvancedExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void AdvancedExtension::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void AdvancedExtension::Clear() { -// @@protoc_insertion_point(message_clear_start:io.substrait.extensions.AdvancedExtension) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArena() == nullptr && optimization_ != nullptr) { - delete optimization_; - } - optimization_ = nullptr; - if (GetArena() == nullptr && enhancement_ != nullptr) { - delete enhancement_; - } - enhancement_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* AdvancedExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .google.protobuf.Any optimization = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_optimization(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - // .google.protobuf.Any enhancement = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_enhancement(), ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } - } // switch - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* AdvancedExtension::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:io.substrait.extensions.AdvancedExtension) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .google.protobuf.Any optimization = 1; - if (this->has_optimization()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::optimization(this), target, stream); - } - - // .google.protobuf.Any enhancement = 2; - if (this->has_enhancement()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::enhancement(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:io.substrait.extensions.AdvancedExtension) - return target; -} - -size_t AdvancedExtension::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:io.substrait.extensions.AdvancedExtension) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .google.protobuf.Any optimization = 1; - if (this->has_optimization()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *optimization_); - } - - // .google.protobuf.Any enhancement = 2; - if (this->has_enhancement()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *enhancement_); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void AdvancedExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:io.substrait.extensions.AdvancedExtension) - GOOGLE_DCHECK_NE(&from, this); - const AdvancedExtension* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:io.substrait.extensions.AdvancedExtension) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:io.substrait.extensions.AdvancedExtension) - MergeFrom(*source); - } -} - -void AdvancedExtension::MergeFrom(const AdvancedExtension& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:io.substrait.extensions.AdvancedExtension) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_optimization()) { - _internal_mutable_optimization()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_optimization()); - } - if (from.has_enhancement()) { - _internal_mutable_enhancement()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_enhancement()); - } -} - -void AdvancedExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:io.substrait.extensions.AdvancedExtension) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void AdvancedExtension::CopyFrom(const AdvancedExtension& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:io.substrait.extensions.AdvancedExtension) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool AdvancedExtension::IsInitialized() const { - return true; -} - -void AdvancedExtension::InternalSwap(AdvancedExtension* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(AdvancedExtension, enhancement_) - + sizeof(AdvancedExtension::enhancement_) - - PROTOBUF_FIELD_OFFSET(AdvancedExtension, optimization_)>( - reinterpret_cast(&optimization_), - reinterpret_cast(&other->optimization_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata AdvancedExtension::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_extensions_2eproto_getter, &descriptor_table_extensions_2eproto_once, - file_level_metadata_extensions_2eproto[5]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace extensions -} // namespace substrait -} // namespace io -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::io::substrait::extensions::SimpleExtensionURI* Arena::CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionURI >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::extensions::SimpleExtensionURI >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Arena::CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* Arena::CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Arena::CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::extensions::SimpleExtensionDeclaration* Arena::CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::extensions::SimpleExtensionDeclaration >(arena); -} -template<> PROTOBUF_NOINLINE ::io::substrait::extensions::AdvancedExtension* Arena::CreateMaybeMessage< ::io::substrait::extensions::AdvancedExtension >(Arena* arena) { - return Arena::CreateMessageInternal< ::io::substrait::extensions::AdvancedExtension >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/extensions.pb.h b/cpp/src/generated/substrait/extensions.pb.h deleted file mode 100644 index 977bfa80603..00000000000 --- a/cpp/src/generated/substrait/extensions.pb.h +++ /dev/null @@ -1,1835 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: extensions.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_extensions_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_extensions_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3016000 -#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 3016000 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_extensions_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_extensions_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_extensions_2eproto; -namespace io { -namespace substrait { -namespace extensions { -class AdvancedExtension; -struct AdvancedExtensionDefaultTypeInternal; -extern AdvancedExtensionDefaultTypeInternal _AdvancedExtension_default_instance_; -class SimpleExtensionDeclaration; -struct SimpleExtensionDeclarationDefaultTypeInternal; -extern SimpleExtensionDeclarationDefaultTypeInternal _SimpleExtensionDeclaration_default_instance_; -class SimpleExtensionDeclaration_ExtensionFunction; -struct SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal; -extern SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionFunction_default_instance_; -class SimpleExtensionDeclaration_ExtensionType; -struct SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal; -extern SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionType_default_instance_; -class SimpleExtensionDeclaration_ExtensionTypeVariation; -struct SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal; -extern SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_; -class SimpleExtensionURI; -struct SimpleExtensionURIDefaultTypeInternal; -extern SimpleExtensionURIDefaultTypeInternal _SimpleExtensionURI_default_instance_; -} // namespace extensions -} // namespace substrait -} // namespace io -PROTOBUF_NAMESPACE_OPEN -template<> ::io::substrait::extensions::AdvancedExtension* Arena::CreateMaybeMessage<::io::substrait::extensions::AdvancedExtension>(Arena*); -template<> ::io::substrait::extensions::SimpleExtensionDeclaration* Arena::CreateMaybeMessage<::io::substrait::extensions::SimpleExtensionDeclaration>(Arena*); -template<> ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Arena::CreateMaybeMessage<::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction>(Arena*); -template<> ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Arena::CreateMaybeMessage<::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType>(Arena*); -template<> ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* Arena::CreateMaybeMessage<::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation>(Arena*); -template<> ::io::substrait::extensions::SimpleExtensionURI* Arena::CreateMaybeMessage<::io::substrait::extensions::SimpleExtensionURI>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace io { -namespace substrait { -namespace extensions { - -// =================================================================== - -class SimpleExtensionURI PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.SimpleExtensionURI) */ { - public: - inline SimpleExtensionURI() : SimpleExtensionURI(nullptr) {} - ~SimpleExtensionURI() override; - explicit constexpr SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SimpleExtensionURI(const SimpleExtensionURI& from); - SimpleExtensionURI(SimpleExtensionURI&& from) noexcept - : SimpleExtensionURI() { - *this = ::std::move(from); - } - - inline SimpleExtensionURI& operator=(const SimpleExtensionURI& from) { - CopyFrom(from); - return *this; - } - inline SimpleExtensionURI& operator=(SimpleExtensionURI&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 SimpleExtensionURI& default_instance() { - return *internal_default_instance(); - } - static inline const SimpleExtensionURI* internal_default_instance() { - return reinterpret_cast( - &_SimpleExtensionURI_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(SimpleExtensionURI& a, SimpleExtensionURI& b) { - a.Swap(&b); - } - inline void Swap(SimpleExtensionURI* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SimpleExtensionURI* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline SimpleExtensionURI* New() const final { - return CreateMaybeMessage(nullptr); - } - - SimpleExtensionURI* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const SimpleExtensionURI& from); - void MergeFrom(const SimpleExtensionURI& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SimpleExtensionURI* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.extensions.SimpleExtensionURI"; - } - protected: - explicit SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kUriFieldNumber = 2, - kExtensionUriAnchorFieldNumber = 1, - }; - // string uri = 2; - void clear_uri(); - const std::string& uri() const; - template - void set_uri(ArgT0&& arg0, ArgT... args); - std::string* mutable_uri(); - std::string* release_uri(); - void set_allocated_uri(std::string* uri); - private: - const std::string& _internal_uri() const; - void _internal_set_uri(const std::string& value); - std::string* _internal_mutable_uri(); - public: - - // uint32 extension_uri_anchor = 1; - void clear_extension_uri_anchor(); - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_anchor() const; - void set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); - private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_anchor() const; - void _internal_set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.extensions.SimpleExtensionURI) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_anchor_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_extensions_2eproto; -}; -// ------------------------------------------------------------------- - -class SimpleExtensionDeclaration_ExtensionType PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) */ { - public: - inline SimpleExtensionDeclaration_ExtensionType() : SimpleExtensionDeclaration_ExtensionType(nullptr) {} - ~SimpleExtensionDeclaration_ExtensionType() override; - explicit constexpr SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from); - SimpleExtensionDeclaration_ExtensionType(SimpleExtensionDeclaration_ExtensionType&& from) noexcept - : SimpleExtensionDeclaration_ExtensionType() { - *this = ::std::move(from); - } - - inline SimpleExtensionDeclaration_ExtensionType& operator=(const SimpleExtensionDeclaration_ExtensionType& from) { - CopyFrom(from); - return *this; - } - inline SimpleExtensionDeclaration_ExtensionType& operator=(SimpleExtensionDeclaration_ExtensionType&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 SimpleExtensionDeclaration_ExtensionType& default_instance() { - return *internal_default_instance(); - } - static inline const SimpleExtensionDeclaration_ExtensionType* internal_default_instance() { - return reinterpret_cast( - &_SimpleExtensionDeclaration_ExtensionType_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(SimpleExtensionDeclaration_ExtensionType& a, SimpleExtensionDeclaration_ExtensionType& b) { - a.Swap(&b); - } - inline void Swap(SimpleExtensionDeclaration_ExtensionType* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionType* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline SimpleExtensionDeclaration_ExtensionType* New() const final { - return CreateMaybeMessage(nullptr); - } - - SimpleExtensionDeclaration_ExtensionType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from); - void MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SimpleExtensionDeclaration_ExtensionType* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType"; - } - protected: - explicit SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 3, - kExtensionUriReferenceFieldNumber = 1, - kTypeAnchorFieldNumber = 2, - }; - // string name = 3; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // uint32 extension_uri_reference = 1; - void clear_extension_uri_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference() const; - void set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); - private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_reference() const; - void _internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); - public: - - // uint32 type_anchor = 2; - void clear_type_anchor(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_anchor() const; - void set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); - private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_anchor() const; - void _internal_set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_anchor_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_extensions_2eproto; -}; -// ------------------------------------------------------------------- - -class SimpleExtensionDeclaration_ExtensionTypeVariation PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) */ { - public: - inline SimpleExtensionDeclaration_ExtensionTypeVariation() : SimpleExtensionDeclaration_ExtensionTypeVariation(nullptr) {} - ~SimpleExtensionDeclaration_ExtensionTypeVariation() override; - explicit constexpr SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); - SimpleExtensionDeclaration_ExtensionTypeVariation(SimpleExtensionDeclaration_ExtensionTypeVariation&& from) noexcept - : SimpleExtensionDeclaration_ExtensionTypeVariation() { - *this = ::std::move(from); - } - - inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { - CopyFrom(from); - return *this; - } - inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(SimpleExtensionDeclaration_ExtensionTypeVariation&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 SimpleExtensionDeclaration_ExtensionTypeVariation& default_instance() { - return *internal_default_instance(); - } - static inline const SimpleExtensionDeclaration_ExtensionTypeVariation* internal_default_instance() { - return reinterpret_cast( - &_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(SimpleExtensionDeclaration_ExtensionTypeVariation& a, SimpleExtensionDeclaration_ExtensionTypeVariation& b) { - a.Swap(&b); - } - inline void Swap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline SimpleExtensionDeclaration_ExtensionTypeVariation* New() const final { - return CreateMaybeMessage(nullptr); - } - - SimpleExtensionDeclaration_ExtensionTypeVariation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); - void MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation"; - } - protected: - explicit SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 3, - kExtensionUriPointerFieldNumber = 1, - kTypeVariationAnchorFieldNumber = 2, - }; - // string name = 3; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // uint32 extension_uri_pointer = 1; - void clear_extension_uri_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_pointer() const; - void set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); - private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_pointer() const; - void _internal_set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); - public: - - // uint32 type_variation_anchor = 2; - void clear_type_variation_anchor(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_anchor() const; - void set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); - private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_anchor() const; - void _internal_set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_pointer_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_anchor_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_extensions_2eproto; -}; -// ------------------------------------------------------------------- - -class SimpleExtensionDeclaration_ExtensionFunction PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) */ { - public: - inline SimpleExtensionDeclaration_ExtensionFunction() : SimpleExtensionDeclaration_ExtensionFunction(nullptr) {} - ~SimpleExtensionDeclaration_ExtensionFunction() override; - explicit constexpr SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from); - SimpleExtensionDeclaration_ExtensionFunction(SimpleExtensionDeclaration_ExtensionFunction&& from) noexcept - : SimpleExtensionDeclaration_ExtensionFunction() { - *this = ::std::move(from); - } - - inline SimpleExtensionDeclaration_ExtensionFunction& operator=(const SimpleExtensionDeclaration_ExtensionFunction& from) { - CopyFrom(from); - return *this; - } - inline SimpleExtensionDeclaration_ExtensionFunction& operator=(SimpleExtensionDeclaration_ExtensionFunction&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 SimpleExtensionDeclaration_ExtensionFunction& default_instance() { - return *internal_default_instance(); - } - static inline const SimpleExtensionDeclaration_ExtensionFunction* internal_default_instance() { - return reinterpret_cast( - &_SimpleExtensionDeclaration_ExtensionFunction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(SimpleExtensionDeclaration_ExtensionFunction& a, SimpleExtensionDeclaration_ExtensionFunction& b) { - a.Swap(&b); - } - inline void Swap(SimpleExtensionDeclaration_ExtensionFunction* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionFunction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline SimpleExtensionDeclaration_ExtensionFunction* New() const final { - return CreateMaybeMessage(nullptr); - } - - SimpleExtensionDeclaration_ExtensionFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from); - void MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction"; - } - protected: - explicit SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 3, - kExtensionUriPointerFieldNumber = 1, - kFunctionAnchorFieldNumber = 2, - }; - // string name = 3; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // uint32 extension_uri_pointer = 1; - void clear_extension_uri_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_pointer() const; - void set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); - private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_pointer() const; - void _internal_set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); - public: - - // uint32 function_anchor = 2; - void clear_function_anchor(); - ::PROTOBUF_NAMESPACE_ID::uint32 function_anchor() const; - void set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); - private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_function_anchor() const; - void _internal_set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); - public: - - // @@protoc_insertion_point(class_scope:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_pointer_; - ::PROTOBUF_NAMESPACE_ID::uint32 function_anchor_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_extensions_2eproto; -}; -// ------------------------------------------------------------------- - -class SimpleExtensionDeclaration PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.SimpleExtensionDeclaration) */ { - public: - inline SimpleExtensionDeclaration() : SimpleExtensionDeclaration(nullptr) {} - ~SimpleExtensionDeclaration() override; - explicit constexpr SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from); - SimpleExtensionDeclaration(SimpleExtensionDeclaration&& from) noexcept - : SimpleExtensionDeclaration() { - *this = ::std::move(from); - } - - inline SimpleExtensionDeclaration& operator=(const SimpleExtensionDeclaration& from) { - CopyFrom(from); - return *this; - } - inline SimpleExtensionDeclaration& operator=(SimpleExtensionDeclaration&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 SimpleExtensionDeclaration& default_instance() { - return *internal_default_instance(); - } - enum MappingTypeCase { - kExtensionType = 1, - kExtensionTypeVariation = 2, - kExtensionFunction = 3, - MAPPING_TYPE_NOT_SET = 0, - }; - - static inline const SimpleExtensionDeclaration* internal_default_instance() { - return reinterpret_cast( - &_SimpleExtensionDeclaration_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(SimpleExtensionDeclaration& a, SimpleExtensionDeclaration& b) { - a.Swap(&b); - } - inline void Swap(SimpleExtensionDeclaration* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SimpleExtensionDeclaration* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline SimpleExtensionDeclaration* New() const final { - return CreateMaybeMessage(nullptr); - } - - SimpleExtensionDeclaration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const SimpleExtensionDeclaration& from); - void MergeFrom(const SimpleExtensionDeclaration& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SimpleExtensionDeclaration* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.extensions.SimpleExtensionDeclaration"; - } - protected: - explicit SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef SimpleExtensionDeclaration_ExtensionType ExtensionType; - typedef SimpleExtensionDeclaration_ExtensionTypeVariation ExtensionTypeVariation; - typedef SimpleExtensionDeclaration_ExtensionFunction ExtensionFunction; - - // accessors ------------------------------------------------------- - - enum : int { - kExtensionTypeFieldNumber = 1, - kExtensionTypeVariationFieldNumber = 2, - kExtensionFunctionFieldNumber = 3, - }; - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; - bool has_extension_type() const; - private: - bool _internal_has_extension_type() const; - public: - void clear_extension_type(); - const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type() const; - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* release_extension_type(); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* mutable_extension_type(); - void set_allocated_extension_type(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type); - private: - const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& _internal_extension_type() const; - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* _internal_mutable_extension_type(); - public: - void unsafe_arena_set_allocated_extension_type( - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* unsafe_arena_release_extension_type(); - - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; - bool has_extension_type_variation() const; - private: - bool _internal_has_extension_type_variation() const; - public: - void clear_extension_type_variation(); - const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation() const; - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* release_extension_type_variation(); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* mutable_extension_type_variation(); - void set_allocated_extension_type_variation(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation); - private: - const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& _internal_extension_type_variation() const; - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* _internal_mutable_extension_type_variation(); - public: - void unsafe_arena_set_allocated_extension_type_variation( - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* unsafe_arena_release_extension_type_variation(); - - // .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; - bool has_extension_function() const; - private: - bool _internal_has_extension_function() const; - public: - void clear_extension_function(); - const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function() const; - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* release_extension_function(); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* mutable_extension_function(); - void set_allocated_extension_function(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function); - private: - const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& _internal_extension_function() const; - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* _internal_mutable_extension_function(); - public: - void unsafe_arena_set_allocated_extension_function( - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* unsafe_arena_release_extension_function(); - - void clear_mapping_type(); - MappingTypeCase mapping_type_case() const; - // @@protoc_insertion_point(class_scope:io.substrait.extensions.SimpleExtensionDeclaration) - private: - class _Internal; - void set_has_extension_type(); - void set_has_extension_type_variation(); - void set_has_extension_function(); - - inline bool has_mapping_type() const; - inline void clear_has_mapping_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union MappingTypeUnion { - constexpr MappingTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type_; - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation_; - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function_; - } mapping_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; - - friend struct ::TableStruct_extensions_2eproto; -}; -// ------------------------------------------------------------------- - -class AdvancedExtension PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:io.substrait.extensions.AdvancedExtension) */ { - public: - inline AdvancedExtension() : AdvancedExtension(nullptr) {} - ~AdvancedExtension() override; - explicit constexpr AdvancedExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - AdvancedExtension(const AdvancedExtension& from); - AdvancedExtension(AdvancedExtension&& from) noexcept - : AdvancedExtension() { - *this = ::std::move(from); - } - - inline AdvancedExtension& operator=(const AdvancedExtension& from) { - CopyFrom(from); - return *this; - } - inline AdvancedExtension& operator=(AdvancedExtension&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) 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 AdvancedExtension& default_instance() { - return *internal_default_instance(); - } - static inline const AdvancedExtension* internal_default_instance() { - return reinterpret_cast( - &_AdvancedExtension_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(AdvancedExtension& a, AdvancedExtension& b) { - a.Swap(&b); - } - inline void Swap(AdvancedExtension* other) { - if (other == this) return; - if (GetArena() == other->GetArena()) { - InternalSwap(other); - } else { - ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(AdvancedExtension* other) { - if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - inline AdvancedExtension* New() const final { - return CreateMaybeMessage(nullptr); - } - - AdvancedExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { - return CreateMaybeMessage(arena); - } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const AdvancedExtension& from); - void MergeFrom(const AdvancedExtension& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } - - private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(AdvancedExtension* other); - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "io.substrait.extensions.AdvancedExtension"; - } - protected: - explicit AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - enum : int { - kOptimizationFieldNumber = 1, - kEnhancementFieldNumber = 2, - }; - // .google.protobuf.Any optimization = 1; - bool has_optimization() const; - private: - bool _internal_has_optimization() const; - public: - void clear_optimization(); - const PROTOBUF_NAMESPACE_ID::Any& optimization() const; - PROTOBUF_NAMESPACE_ID::Any* release_optimization(); - PROTOBUF_NAMESPACE_ID::Any* mutable_optimization(); - void set_allocated_optimization(PROTOBUF_NAMESPACE_ID::Any* optimization); - private: - const PROTOBUF_NAMESPACE_ID::Any& _internal_optimization() const; - PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_optimization(); - public: - void unsafe_arena_set_allocated_optimization( - PROTOBUF_NAMESPACE_ID::Any* optimization); - PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_optimization(); - - // .google.protobuf.Any enhancement = 2; - bool has_enhancement() const; - private: - bool _internal_has_enhancement() const; - public: - void clear_enhancement(); - const PROTOBUF_NAMESPACE_ID::Any& enhancement() const; - PROTOBUF_NAMESPACE_ID::Any* release_enhancement(); - PROTOBUF_NAMESPACE_ID::Any* mutable_enhancement(); - void set_allocated_enhancement(PROTOBUF_NAMESPACE_ID::Any* enhancement); - private: - const PROTOBUF_NAMESPACE_ID::Any& _internal_enhancement() const; - PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_enhancement(); - public: - void unsafe_arena_set_allocated_enhancement( - PROTOBUF_NAMESPACE_ID::Any* enhancement); - PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_enhancement(); - - // @@protoc_insertion_point(class_scope:io.substrait.extensions.AdvancedExtension) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - PROTOBUF_NAMESPACE_ID::Any* optimization_; - PROTOBUF_NAMESPACE_ID::Any* enhancement_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_extensions_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// SimpleExtensionURI - -// uint32 extension_uri_anchor = 1; -inline void SimpleExtensionURI::clear_extension_uri_anchor() { - extension_uri_anchor_ = 0u; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionURI::_internal_extension_uri_anchor() const { - return extension_uri_anchor_; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionURI::extension_uri_anchor() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionURI.extension_uri_anchor) - return _internal_extension_uri_anchor(); -} -inline void SimpleExtensionURI::_internal_set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { - - extension_uri_anchor_ = value; -} -inline void SimpleExtensionURI::set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { - _internal_set_extension_uri_anchor(value); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionURI.extension_uri_anchor) -} - -// string uri = 2; -inline void SimpleExtensionURI::clear_uri() { - uri_.ClearToEmpty(); -} -inline const std::string& SimpleExtensionURI::uri() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionURI.uri) - return _internal_uri(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void SimpleExtensionURI::set_uri(ArgT0&& arg0, ArgT... args) { - - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionURI.uri) -} -inline std::string* SimpleExtensionURI::mutable_uri() { - // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionURI.uri) - return _internal_mutable_uri(); -} -inline const std::string& SimpleExtensionURI::_internal_uri() const { - return uri_.Get(); -} -inline void SimpleExtensionURI::_internal_set_uri(const std::string& value) { - - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* SimpleExtensionURI::_internal_mutable_uri() { - - return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* SimpleExtensionURI::release_uri() { - // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionURI.uri) - return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void SimpleExtensionURI::set_allocated_uri(std::string* uri) { - if (uri != nullptr) { - - } else { - - } - uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionURI.uri) -} - -// ------------------------------------------------------------------- - -// SimpleExtensionDeclaration_ExtensionType - -// uint32 extension_uri_reference = 1; -inline void SimpleExtensionDeclaration_ExtensionType::clear_extension_uri_reference() { - extension_uri_reference_ = 0u; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::_internal_extension_uri_reference() const { - return extension_uri_reference_; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::extension_uri_reference() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference) - return _internal_extension_uri_reference(); -} -inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - - extension_uri_reference_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionType::set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { - _internal_set_extension_uri_reference(value); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference) -} - -// uint32 type_anchor = 2; -inline void SimpleExtensionDeclaration_ExtensionType::clear_type_anchor() { - type_anchor_ = 0u; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::_internal_type_anchor() const { - return type_anchor_; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::type_anchor() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor) - return _internal_type_anchor(); -} -inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { - - type_anchor_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionType::set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { - _internal_set_type_anchor(value); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor) -} - -// string name = 3; -inline void SimpleExtensionDeclaration_ExtensionType::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& SimpleExtensionDeclaration_ExtensionType::name() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) - return _internal_name(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void SimpleExtensionDeclaration_ExtensionType::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) -} -inline std::string* SimpleExtensionDeclaration_ExtensionType::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) - return _internal_mutable_name(); -} -inline const std::string& SimpleExtensionDeclaration_ExtensionType::_internal_name() const { - return name_.Get(); -} -inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionType::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionType::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void SimpleExtensionDeclaration_ExtensionType::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) -} - -// ------------------------------------------------------------------- - -// SimpleExtensionDeclaration_ExtensionTypeVariation - -// uint32 extension_uri_pointer = 1; -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_extension_uri_pointer() { - extension_uri_pointer_ = 0u; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_extension_uri_pointer() const { - return extension_uri_pointer_; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::extension_uri_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_pointer) - return _internal_extension_uri_pointer(); -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - - extension_uri_pointer_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - _internal_set_extension_uri_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_pointer) -} - -// uint32 type_variation_anchor = 2; -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_type_variation_anchor() { - type_variation_anchor_ = 0u; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_type_variation_anchor() const { - return type_variation_anchor_; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor) - return _internal_type_variation_anchor(); -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { - - type_variation_anchor_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { - _internal_set_type_variation_anchor(value); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor) -} - -// string name = 3; -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::name() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) - return _internal_name(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) -} -inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) - return _internal_mutable_name(); -} -inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_name() const { - return name_.Get(); -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) -} - -// ------------------------------------------------------------------- - -// SimpleExtensionDeclaration_ExtensionFunction - -// uint32 extension_uri_pointer = 1; -inline void SimpleExtensionDeclaration_ExtensionFunction::clear_extension_uri_pointer() { - extension_uri_pointer_ = 0u; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::_internal_extension_uri_pointer() const { - return extension_uri_pointer_; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::extension_uri_pointer() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_pointer) - return _internal_extension_uri_pointer(); -} -inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - - extension_uri_pointer_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionFunction::set_extension_uri_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { - _internal_set_extension_uri_pointer(value); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_pointer) -} - -// uint32 function_anchor = 2; -inline void SimpleExtensionDeclaration_ExtensionFunction::clear_function_anchor() { - function_anchor_ = 0u; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::_internal_function_anchor() const { - return function_anchor_; -} -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::function_anchor() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor) - return _internal_function_anchor(); -} -inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { - - function_anchor_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionFunction::set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { - _internal_set_function_anchor(value); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor) -} - -// string name = 3; -inline void SimpleExtensionDeclaration_ExtensionFunction::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::name() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) - return _internal_name(); -} -template -PROTOBUF_ALWAYS_INLINE -inline void SimpleExtensionDeclaration_ExtensionFunction::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); - // @@protoc_insertion_point(field_set:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) -} -inline std::string* SimpleExtensionDeclaration_ExtensionFunction::mutable_name() { - // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) - return _internal_mutable_name(); -} -inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::_internal_name() const { - return name_.Get(); -} -inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionFunction::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionFunction::release_name() { - // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); -} -inline void SimpleExtensionDeclaration_ExtensionFunction::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); - // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) -} - -// ------------------------------------------------------------------- - -// SimpleExtensionDeclaration - -// .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; -inline bool SimpleExtensionDeclaration::_internal_has_extension_type() const { - return mapping_type_case() == kExtensionType; -} -inline bool SimpleExtensionDeclaration::has_extension_type() const { - return _internal_has_extension_type(); -} -inline void SimpleExtensionDeclaration::set_has_extension_type() { - _oneof_case_[0] = kExtensionType; -} -inline void SimpleExtensionDeclaration::clear_extension_type() { - if (_internal_has_extension_type()) { - if (GetArena() == nullptr) { - delete mapping_type_.extension_type_; - } - clear_has_mapping_type(); - } -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::release_extension_type() { - // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) - if (_internal_has_extension_type()) { - clear_has_mapping_type(); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - mapping_type_.extension_type_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& SimpleExtensionDeclaration::_internal_extension_type() const { - return _internal_has_extension_type() - ? *mapping_type_.extension_type_ - : reinterpret_cast< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType&>(::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_); -} -inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& SimpleExtensionDeclaration::extension_type() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) - return _internal_extension_type(); -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::unsafe_arena_release_extension_type() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) - if (_internal_has_extension_type()) { - clear_has_mapping_type(); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_; - mapping_type_.extension_type_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_type(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) { - clear_mapping_type(); - if (extension_type) { - set_has_extension_type(); - mapping_type_.extension_type_ = extension_type; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::_internal_mutable_extension_type() { - if (!_internal_has_extension_type()) { - clear_mapping_type(); - set_has_extension_type(); - mapping_type_.extension_type_ = CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(GetArena()); - } - return mapping_type_.extension_type_; -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::mutable_extension_type() { - // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.extension_type) - return _internal_mutable_extension_type(); -} - -// .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; -inline bool SimpleExtensionDeclaration::_internal_has_extension_type_variation() const { - return mapping_type_case() == kExtensionTypeVariation; -} -inline bool SimpleExtensionDeclaration::has_extension_type_variation() const { - return _internal_has_extension_type_variation(); -} -inline void SimpleExtensionDeclaration::set_has_extension_type_variation() { - _oneof_case_[0] = kExtensionTypeVariation; -} -inline void SimpleExtensionDeclaration::clear_extension_type_variation() { - if (_internal_has_extension_type_variation()) { - if (GetArena() == nullptr) { - delete mapping_type_.extension_type_variation_; - } - clear_has_mapping_type(); - } -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::release_extension_type_variation() { - // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) - if (_internal_has_extension_type_variation()) { - clear_has_mapping_type(); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - mapping_type_.extension_type_variation_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& SimpleExtensionDeclaration::_internal_extension_type_variation() const { - return _internal_has_extension_type_variation() - ? *mapping_type_.extension_type_variation_ - : reinterpret_cast< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation&>(::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_); -} -inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& SimpleExtensionDeclaration::extension_type_variation() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) - return _internal_extension_type_variation(); -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::unsafe_arena_release_extension_type_variation() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) - if (_internal_has_extension_type_variation()) { - clear_has_mapping_type(); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_; - mapping_type_.extension_type_variation_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_type_variation(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) { - clear_mapping_type(); - if (extension_type_variation) { - set_has_extension_type_variation(); - mapping_type_.extension_type_variation_ = extension_type_variation; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::_internal_mutable_extension_type_variation() { - if (!_internal_has_extension_type_variation()) { - clear_mapping_type(); - set_has_extension_type_variation(); - mapping_type_.extension_type_variation_ = CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(GetArena()); - } - return mapping_type_.extension_type_variation_; -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::mutable_extension_type_variation() { - // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) - return _internal_mutable_extension_type_variation(); -} - -// .io.substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; -inline bool SimpleExtensionDeclaration::_internal_has_extension_function() const { - return mapping_type_case() == kExtensionFunction; -} -inline bool SimpleExtensionDeclaration::has_extension_function() const { - return _internal_has_extension_function(); -} -inline void SimpleExtensionDeclaration::set_has_extension_function() { - _oneof_case_[0] = kExtensionFunction; -} -inline void SimpleExtensionDeclaration::clear_extension_function() { - if (_internal_has_extension_function()) { - if (GetArena() == nullptr) { - delete mapping_type_.extension_function_; - } - clear_has_mapping_type(); - } -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::release_extension_function() { - // @@protoc_insertion_point(field_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) - if (_internal_has_extension_function()) { - clear_has_mapping_type(); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - mapping_type_.extension_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& SimpleExtensionDeclaration::_internal_extension_function() const { - return _internal_has_extension_function() - ? *mapping_type_.extension_function_ - : reinterpret_cast< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction&>(::io::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_); -} -inline const ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& SimpleExtensionDeclaration::extension_function() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) - return _internal_extension_function(); -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::unsafe_arena_release_extension_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) - if (_internal_has_extension_function()) { - clear_has_mapping_type(); - ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_; - mapping_type_.extension_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_function(::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) { - clear_mapping_type(); - if (extension_function) { - set_has_extension_function(); - mapping_type_.extension_function_ = extension_function; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::_internal_mutable_extension_function() { - if (!_internal_has_extension_function()) { - clear_mapping_type(); - set_has_extension_function(); - mapping_type_.extension_function_ = CreateMaybeMessage< ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(GetArena()); - } - return mapping_type_.extension_function_; -} -inline ::io::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::mutable_extension_function() { - // @@protoc_insertion_point(field_mutable:io.substrait.extensions.SimpleExtensionDeclaration.extension_function) - return _internal_mutable_extension_function(); -} - -inline bool SimpleExtensionDeclaration::has_mapping_type() const { - return mapping_type_case() != MAPPING_TYPE_NOT_SET; -} -inline void SimpleExtensionDeclaration::clear_has_mapping_type() { - _oneof_case_[0] = MAPPING_TYPE_NOT_SET; -} -inline SimpleExtensionDeclaration::MappingTypeCase SimpleExtensionDeclaration::mapping_type_case() const { - return SimpleExtensionDeclaration::MappingTypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// AdvancedExtension - -// .google.protobuf.Any optimization = 1; -inline bool AdvancedExtension::_internal_has_optimization() const { - return this != internal_default_instance() && optimization_ != nullptr; -} -inline bool AdvancedExtension::has_optimization() const { - return _internal_has_optimization(); -} -inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_optimization() const { - const PROTOBUF_NAMESPACE_ID::Any* p = optimization_; - return p != nullptr ? *p : reinterpret_cast( - PROTOBUF_NAMESPACE_ID::_Any_default_instance_); -} -inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::optimization() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.AdvancedExtension.optimization) - return _internal_optimization(); -} -inline void AdvancedExtension::unsafe_arena_set_allocated_optimization( - PROTOBUF_NAMESPACE_ID::Any* optimization) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_); - } - optimization_ = optimization; - if (optimization) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.extensions.AdvancedExtension.optimization) -} -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_optimization() { - - PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; - optimization_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_optimization() { - // @@protoc_insertion_point(field_release:io.substrait.extensions.AdvancedExtension.optimization) - - PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; - optimization_ = nullptr; - return temp; -} -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_optimization() { - - if (optimization_ == nullptr) { - auto* p = CreateMaybeMessage(GetArena()); - optimization_ = p; - } - return optimization_; -} -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_optimization() { - // @@protoc_insertion_point(field_mutable:io.substrait.extensions.AdvancedExtension.optimization) - return _internal_mutable_optimization(); -} -inline void AdvancedExtension::set_allocated_optimization(PROTOBUF_NAMESPACE_ID::Any* optimization) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_); - } - if (optimization) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization)->GetArena(); - if (message_arena != submessage_arena) { - optimization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, optimization, submessage_arena); - } - - } else { - - } - optimization_ = optimization; - // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.AdvancedExtension.optimization) -} - -// .google.protobuf.Any enhancement = 2; -inline bool AdvancedExtension::_internal_has_enhancement() const { - return this != internal_default_instance() && enhancement_ != nullptr; -} -inline bool AdvancedExtension::has_enhancement() const { - return _internal_has_enhancement(); -} -inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_enhancement() const { - const PROTOBUF_NAMESPACE_ID::Any* p = enhancement_; - return p != nullptr ? *p : reinterpret_cast( - PROTOBUF_NAMESPACE_ID::_Any_default_instance_); -} -inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::enhancement() const { - // @@protoc_insertion_point(field_get:io.substrait.extensions.AdvancedExtension.enhancement) - return _internal_enhancement(); -} -inline void AdvancedExtension::unsafe_arena_set_allocated_enhancement( - PROTOBUF_NAMESPACE_ID::Any* enhancement) { - if (GetArena() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_); - } - enhancement_ = enhancement; - if (enhancement) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:io.substrait.extensions.AdvancedExtension.enhancement) -} -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_enhancement() { - - PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; - enhancement_ = nullptr; - if (GetArena() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - return temp; -} -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_enhancement() { - // @@protoc_insertion_point(field_release:io.substrait.extensions.AdvancedExtension.enhancement) - - PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; - enhancement_ = nullptr; - return temp; -} -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_enhancement() { - - if (enhancement_ == nullptr) { - auto* p = CreateMaybeMessage(GetArena()); - enhancement_ = p; - } - return enhancement_; -} -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_enhancement() { - // @@protoc_insertion_point(field_mutable:io.substrait.extensions.AdvancedExtension.enhancement) - return _internal_mutable_enhancement(); -} -inline void AdvancedExtension::set_allocated_enhancement(PROTOBUF_NAMESPACE_ID::Any* enhancement) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_); - } - if (enhancement) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement)->GetArena(); - if (message_arena != submessage_arena) { - enhancement = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, enhancement, submessage_arena); - } - - } else { - - } - enhancement_ = enhancement; - // @@protoc_insertion_point(field_set_allocated:io.substrait.extensions.AdvancedExtension.enhancement) -} - -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace extensions -} // namespace substrait -} // namespace io - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_extensions_2eproto From ed5b0d599d8f7d897d9d545060f7984cc85a7dfb Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 10:43:21 -0500 Subject: [PATCH 056/113] unity: ensure globals are unique within a TU --- cpp/src/arrow/engine/CMakeLists.txt | 5 ++++- .../engine/simple_extension_type_internal.h | 10 +++++----- .../engine/substrait/expression_internal.cc | 4 ++-- .../arrow/engine/substrait/extension_types.cc | 20 +++++++++++-------- .../arrow/engine/substrait/type_internal.cc | 4 ++-- cpp/src/arrow/flight/CMakeLists.txt | 4 ++-- 6 files changed, 27 insertions(+), 20 deletions(-) diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 36cc44e6dd6..437094e5c51 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -66,7 +66,10 @@ foreach(SUBSTRAIT_PROTO ${SUBSTRAIT_PROTOS}) set(SUBSTRAIT_PROTO_GEN "${SUBSTRAIT_GEN_DIR}/substrait/${SUBSTRAIT_PROTO}.pb") foreach(EXT h cc) - set_source_files_properties("${SUBSTRAIT_PROTO_GEN}.${EXT}" PROPERTIES GENERATED TRUE) + set_source_files_properties("${SUBSTRAIT_PROTO_GEN}.${EXT}" + PROPERTIES + GENERATED TRUE + SKIP_UNITY_BUILD_INCLUSION TRUE) add_custom_command(OUTPUT "${SUBSTRAIT_PROTO_GEN}.${EXT}" COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${SUBSTRAIT_LOCAL_DIR}/proto" diff --git a/cpp/src/arrow/engine/simple_extension_type_internal.h b/cpp/src/arrow/engine/simple_extension_type_internal.h index 3e8b69ae36c..ecffba3d109 100644 --- a/cpp/src/arrow/engine/simple_extension_type_internal.h +++ b/cpp/src/arrow/engine/simple_extension_type_internal.h @@ -50,10 +50,10 @@ class SimpleExtensionType : public ExtensionType { static const Params* GetIf(const DataType& type) { if (type.id() != Type::EXTENSION) return nullptr; - const auto& ext_type = internal::checked_cast(type); + const auto& ext_type = ::arrow::internal::checked_cast(type); if (ext_type.extension_name() != kExtensionName) return nullptr; - return &internal::checked_cast(type).params_; + return &::arrow::internal::checked_cast(type).params_; } std::string extension_name() const override { return kExtensionName.to_string(); } @@ -105,7 +105,7 @@ class SimpleExtensionType : public ExtensionType { if (repr.back() != '}') return Fail(); repr = repr.substr(1, repr.size() - 2); - members_ = internal::SplitString(repr, ','); + members_ = ::arrow::internal::SplitString(repr, ','); if (members_.size() != num_properties) return Fail(); } @@ -166,8 +166,8 @@ class SimpleExtensionType : public ExtensionType { } std::string Finish() { - return kExtensionName.to_string() + "{" + internal::JoinStrings(members_, ",") + - "}"; + return kExtensionName.to_string() + "{" + + ::arrow::internal::JoinStrings(members_, ",") + "}"; } const Params& params_; diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index e9f836af99c..881f43eeff3 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -438,7 +438,7 @@ Result FromProto(const substrait::Expression::Literal& lit, } namespace { -struct ToProtoImpl { +struct ScalarToProtoImpl { Status Visit(const NullScalar& s) { return NotImplemented(s); } using Lit = substrait::Expression::Literal; @@ -675,7 +675,7 @@ Result> ToProto(const Datum& dat auto out = internal::make_unique(); if (datum.scalar()->is_valid) { - RETURN_NOT_OK((ToProtoImpl{out.get(), ext_set})(*datum.scalar())); + RETURN_NOT_OK((ScalarToProtoImpl{out.get(), ext_set})(*datum.scalar())); } else { ARROW_ASSIGN_OR_RAISE(auto type, ToProto(*datum.type(), /*nullable=*/true, ext_set)); out->set_allocated_null(type.release()); diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index 7ade57952cf..5b5eff0fbb6 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -26,6 +26,10 @@ #include "arrow/util/string_view.h" namespace arrow { + +using internal::DataMember; +using internal::MakeProperties; + namespace engine { namespace { @@ -34,7 +38,7 @@ struct UuidExtensionParams {}; std::shared_ptr UuidGetStorage(const UuidExtensionParams&) { return fixed_size_binary(16); } -static auto kUuidExtensionParamsProperties = internal::MakeProperties(); +static auto kUuidExtensionParamsProperties = MakeProperties(); using UuidType = SimpleExtensionType FixedCharGetStorage(const FixedCharExtensionParams& params) { return fixed_size_binary(params.length); } -static auto kFixedCharExtensionParamsProperties = internal::MakeProperties( - internal::DataMember("length", &FixedCharExtensionParams::length)); +static auto kFixedCharExtensionParamsProperties = + MakeProperties(DataMember("length", &FixedCharExtensionParams::length)); using FixedCharType = SimpleExtensionType VarCharGetStorage(const VarCharExtensionParams&) { return utf8(); } -static auto kVarCharExtensionParamsProperties = internal::MakeProperties( - internal::DataMember("length", &VarCharExtensionParams::length)); +static auto kVarCharExtensionParamsProperties = + MakeProperties(DataMember("length", &VarCharExtensionParams::length)); using VarCharType = SimpleExtensionType IntervalYearGetStorage(const IntervalYearExtensionParams&) { return fixed_size_list(int32(), 2); } -static auto kIntervalYearExtensionParamsProperties = internal::MakeProperties(); +static auto kIntervalYearExtensionParamsProperties = MakeProperties(); using IntervalYearType = SimpleExtensionType IntervalDayGetStorage(const IntervalDayExtensionParams&) { return fixed_size_list(int32(), 2); } -static auto kIntervalDayExtensionParamsProperties = internal::MakeProperties(); +static auto kIntervalDayExtensionParamsProperties = MakeProperties(); using IntervalDayType = SimpleExtensionType(hash(id.uri)); ::arrow::internal::hash_combine(out, hash(id.name)); return out; } diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 6f5904ff403..e43e0b0c442 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -227,7 +227,7 @@ Result, bool>> FromProto( namespace { -struct ToProtoImpl { +struct DataTypeToProtoImpl { Status Visit(const NullType& t) { return EncodeUserDefined(t); } Status Visit(const BooleanType& t) { @@ -418,7 +418,7 @@ struct ToProtoImpl { Result> ToProto(const DataType& type, bool nullable, ExtensionSet* ext_set) { auto out = internal::make_unique(); - RETURN_NOT_OK((ToProtoImpl{out.get(), nullable, ext_set})(type)); + RETURN_NOT_OK((DataTypeToProtoImpl{out.get(), nullable, ext_set})(type)); return std::move(out); } diff --git a/cpp/src/arrow/flight/CMakeLists.txt b/cpp/src/arrow/flight/CMakeLists.txt index b57fa733468..bcebe3e73aa 100644 --- a/cpp/src/arrow/flight/CMakeLists.txt +++ b/cpp/src/arrow/flight/CMakeLists.txt @@ -152,9 +152,9 @@ endif() set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_BACKUP}") # Note, we do not compile the generated Protobuf sources directly, instead -# compiling then via protocol_internal.cc which contains some gRPC template +# compiling them via protocol_internal.cc which contains some gRPC template # overrides to enable Flight-specific optimizations. See comments in -# protobuf-internal.cc +# protocol_internal.cc set(ARROW_FLIGHT_SRCS client.cc client_cookie_middleware.cc From 5d61724942377cb2c7dc513459192a708144c606 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 10:49:26 -0500 Subject: [PATCH 057/113] ensure generated files are also excluded from lint_cpp_cli --- cpp/build-support/lint_cpp_cli.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cpp/build-support/lint_cpp_cli.py b/cpp/build-support/lint_cpp_cli.py index a0eb8f0efe6..0dd9b5b9128 100755 --- a/cpp/build-support/lint_cpp_cli.py +++ b/cpp/build-support/lint_cpp_cli.py @@ -89,7 +89,8 @@ def lint_file(path): jni/ test internal - _generated''') + _generated + generated/substrait/''') def lint_files(): From 37b567309c8674a446bb85266f8e355d44c73a42 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 11:36:13 -0500 Subject: [PATCH 058/113] substrait consumer api cleanup --- cpp/src/arrow/engine/CMakeLists.txt | 1 + cpp/src/arrow/engine/api.h | 3 +- .../engine/substrait/expression_internal.cc | 1 - .../engine/substrait/expression_internal.h | 2 +- .../arrow/engine/substrait/extension_set.cc | 346 ++++++++++++++++++ .../arrow/engine/substrait/extension_set.h | 137 +++++++ .../arrow/engine/substrait/extension_types.cc | 316 ---------------- .../arrow/engine/substrait/extension_types.h | 104 ------ .../arrow/engine/substrait/plan_internal.h | 2 +- cpp/src/arrow/engine/substrait/serde.h | 2 +- .../arrow/engine/substrait/type_internal.cc | 1 - .../arrow/engine/substrait/type_internal.h | 2 +- 12 files changed, 490 insertions(+), 427 deletions(-) create mode 100644 cpp/src/arrow/engine/substrait/extension_set.cc create mode 100644 cpp/src/arrow/engine/substrait/extension_set.h diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 437094e5c51..feaf1814549 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -27,6 +27,7 @@ set(ARROW_ENGINE_LINK_LIBS ${ARROW_PROTOBUF_LIBPROTOBUF}) set(ARROW_ENGINE_SRCS substrait/expression_internal.cc + substrait/extension_set.cc substrait/extension_types.cc substrait/serde.cc substrait/plan_internal.cc diff --git a/cpp/src/arrow/engine/api.h b/cpp/src/arrow/engine/api.h index f9f36a68340..de996e4d264 100644 --- a/cpp/src/arrow/engine/api.h +++ b/cpp/src/arrow/engine/api.h @@ -19,4 +19,5 @@ #pragma once -#include "arrow/engine/substrait_consumer.h" +#include "arrow/engine/substrait/extension_types.h" +#include "arrow/engine/substrait/serde.h" diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 881f43eeff3..a2e040ba2e5 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -32,7 +32,6 @@ #include "arrow/status.h" #include "arrow/util/make_unique.h" #include "arrow/visit_scalar_inline.h" -#include "generated/substrait/expression.pb.h" // IWYU pragma: export namespace arrow { diff --git a/cpp/src/arrow/engine/substrait/expression_internal.h b/cpp/src/arrow/engine/substrait/expression_internal.h index 057bec1bb1f..332b173b677 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.h +++ b/cpp/src/arrow/engine/substrait/expression_internal.h @@ -22,7 +22,7 @@ #include #include "arrow/compute/type_fwd.h" -#include "arrow/engine/substrait/extension_types.h" +#include "arrow/engine/substrait/extension_set.h" #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" diff --git a/cpp/src/arrow/engine/substrait/extension_set.cc b/cpp/src/arrow/engine/substrait/extension_set.cc new file mode 100644 index 00000000000..2106086ac3a --- /dev/null +++ b/cpp/src/arrow/engine/substrait/extension_set.cc @@ -0,0 +1,346 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "arrow/engine/substrait/extension_set.h" + +#include +#include + +#include "arrow/util/hash_util.h" +#include "arrow/util/hashing.h" +#include "arrow/util/string_view.h" + +namespace arrow { +namespace engine { +namespace { + +struct TypePtrHashEq { + template + size_t operator()(const Ptr& type) const { + return type->Hash(); + } + + template + bool operator()(const Ptr& l, const Ptr& r) const { + return *l == *r; + } +}; + +struct IdHashEq { + using Id = ExtensionSet::Id; + + size_t operator()(Id id) const { + constexpr ::arrow::internal::StringViewHash hash = {}; + auto out = static_cast(hash(id.uri)); + ::arrow::internal::hash_combine(out, hash(id.name)); + return out; + } + + bool operator()(Id l, Id r) const { return l.uri == r.uri && l.name == r.name; } +}; + +} // namespace + +struct ExtensionSet::Impl { + void AddUri(util::string_view uri, ExtensionSet* self) { + if (uris_.find(uri) != uris_.end()) return; + + self->uris_.push_back(uri); + uris_.insert(self->uris_.back()); // lookup helper's keys should reference memory + // owned by this ExtensionSet + } + + Status CheckHasUri(util::string_view uri) { + if (uris_.find(uri) != uris_.end()) return Status::OK(); + + return Status::Invalid( + "Uri ", uri, + " was referenced by an extension but was not declared in the ExtensionSet."); + } + + uint32_t EncodeType(Id id, const std::shared_ptr& type, bool is_variation, + ExtensionSet* self) { + // note: at this point we're guaranteed to have an Id which points to memory owned by + // the set's registry. + AddUri(id.uri, self); + auto it_success = types_.emplace(id, static_cast(types_.size())); + + if (it_success.second) { + DCHECK_EQ(self->type_ids_.size(), self->types_.size()); + self->type_ids_.push_back(id); + self->types_.push_back(type); + self->type_is_variation_.push_back(is_variation); + } + + return it_success.first->second; + } + + uint32_t EncodeFunction(Id id, util::string_view function_name, ExtensionSet* self) { + // note: at this point we're guaranteed to have an Id which points to memory owned by + // the set's registry. + AddUri(id.uri, self); + auto it_success = functions_.emplace(id, static_cast(functions_.size())); + + if (it_success.second) { + DCHECK_EQ(self->function_ids_.size(), self->function_names_.size()); + self->function_ids_.push_back(id); + self->function_names_.push_back(function_name); + } + + return it_success.first->second; + } + + std::unordered_set uris_; + std::unordered_map types_, functions_; +}; + +ExtensionSet::ExtensionSet(ExtensionIdRegistry* registry) + : registry_(registry), impl_(new Impl(), [](Impl* impl) { delete impl; }) {} + +Result ExtensionSet::Make(std::vector uris, + std::vector type_ids, + std::vector type_is_variation, + std::vector function_ids, + ExtensionIdRegistry* registry) { + ExtensionSet set; + set.registry_ = registry; + + // TODO(bkietz) move this into the registry as registry->OwnUris(&uris) or so + std::unordered_set + uris_owned_by_registry; + for (util::string_view uri : registry->Uris()) { + uris_owned_by_registry.insert(uri); + } + + for (auto& uri : uris) { + if (uri.empty()) continue; + auto it = uris_owned_by_registry.find(uri); + if (it == uris_owned_by_registry.end()) { + return Status::KeyError("Uri '", uri, "' not found in registry"); + } + uri = *it; // Ensure uris point into the registry's memory + set.impl_->AddUri(*it, &set); + } + + if (type_ids.size() != type_is_variation.size()) { + return Status::Invalid("Received ", type_ids.size(), " type ids but a ", + type_is_variation.size(), "-long is_variation vector"); + } + + set.types_.resize(type_ids.size()); + + for (size_t i = 0; i < type_ids.size(); ++i) { + if (type_ids[i].empty()) continue; + RETURN_NOT_OK(set.impl_->CheckHasUri(type_ids[i].uri)); + + if (auto rec = registry->GetType(type_ids[i], type_is_variation[i])) { + set.types_[i] = rec->type; + type_ids[i] = rec->id; // use Id which references memory owned by the registry + continue; + } + return Status::Invalid("Type", (type_is_variation[i] ? " variation" : ""), " ", + type_ids[i].uri, "#", type_ids[i].name, " not found"); + } + + set.function_names_.resize(function_ids.size()); + + for (size_t i = 0; i < function_ids.size(); ++i) { + if (function_ids[i].empty()) continue; + RETURN_NOT_OK(set.impl_->CheckHasUri(function_ids[i].uri)); + + if (auto rec = registry->GetFunction(function_ids[i])) { + set.function_names_[i] = rec->function_name; + function_ids[i] = rec->id; // use Id which references memory owned by the registry + continue; + } + return Status::Invalid("Function ", function_ids[i].uri, "#", type_ids[i].name, + " not found"); + } + + set.function_ids_ = std::move(function_ids); + set.type_ids_ = std::move(type_ids); + set.type_is_variation_ = std::move(type_is_variation); + set.uris_ = std::move(uris); + + return std::move(set); +} + +Result ExtensionSet::EncodeType(const DataType& type) { + if (auto rec = registry_->GetType(type)) { + return impl_->EncodeType(rec->id, rec->type, rec->is_variation, this); + } + return Status::KeyError("type ", type.ToString(), " not found in the registry"); +} + +Result ExtensionSet::EncodeFunction(util::string_view function_name) { + if (auto rec = registry_->GetFunction(function_name)) { + return impl_->EncodeFunction(rec->id, rec->function_name, this); + } + return Status::KeyError("function ", function_name, " not found in the registry"); +} + +template +const int* GetIndex(const KeyToIndex& key_to_index, const Key& key) { + auto it = key_to_index.find(key); + if (it == key_to_index.end()) return nullptr; + return &it->second; +} + +ExtensionIdRegistry* default_extension_id_registry() { + static struct Impl : ExtensionIdRegistry { + Impl() { + struct TypeName { + std::shared_ptr type; + util::string_view name; + }; + + for (TypeName e : { + TypeName{uint8(), "u8"}, + TypeName{uint16(), "u16"}, + TypeName{uint32(), "u32"}, + TypeName{uint64(), "u64"}, + }) { + DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type), + /*is_variation=*/true)); + } + + for (TypeName e : { + TypeName{null(), "null"}, + }) { + DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type), + /*is_variation=*/false)); + } + + for (util::string_view name : { + "add", + }) { + DCHECK_OK(RegisterFunction({kArrowExtTypesUri, name}, name.to_string())); + } + } + + std::vector Uris() const override { + return {uris_.begin(), uris_.end()}; + } + + util::optional GetType(const DataType& type) const override { + if (auto index = GetIndex(type_to_index_, &type)) { + return TypeRecord{ids_[*index], types_[*index], type_is_variation_[*index]}; + } + return {}; + } + + util::optional GetType(Id id, bool is_variation) const override { + if (auto index = + GetIndex(is_variation ? variation_id_to_index_ : id_to_index_, id)) { + return TypeRecord{ids_[*index], types_[*index], type_is_variation_[*index]}; + } + return {}; + } + + Status RegisterType(Id id, std::shared_ptr type, + bool is_variation) override { + DCHECK_EQ(ids_.size(), types_.size()); + DCHECK_EQ(ids_.size(), type_is_variation_.size()); + + Id copied_id{*uris_.emplace(id.uri.to_string()).first, + *names_.emplace(id.name.to_string()).first}; + + size_t index = ids_.size(); + + auto* id_to_index = is_variation ? &variation_id_to_index_ : &id_to_index_; + auto it_success = id_to_index->emplace(copied_id, index); + + if (!it_success.second) { + return Status::Invalid("Type id was already registered"); + } + + if (!type_to_index_.emplace(type.get(), index).second) { + id_to_index->erase(it_success.first); + return Status::Invalid("Type was already registered"); + } + + ids_.push_back(copied_id); + types_.push_back(std::move(type)); + type_is_variation_.push_back(is_variation); + return Status::OK(); + } + + util::optional GetFunction( + util::string_view arrow_function_name) const override { + if (auto index = GetIndex(function_name_to_index_, arrow_function_name)) { + return FunctionRecord{function_ids_[*index], *function_name_ptrs_[*index]}; + } + return {}; + } + + util::optional GetFunction(Id id) const override { + if (auto index = GetIndex(function_id_to_index_, id)) { + return FunctionRecord{function_ids_[*index], *function_name_ptrs_[*index]}; + } + return {}; + } + + Status RegisterFunction(Id id, std::string arrow_function_name) override { + DCHECK_EQ(function_ids_.size(), function_name_ptrs_.size()); + + Id copied_id{*uris_.emplace(id.uri.to_string()).first, + *names_.emplace(id.name.to_string()).first}; + + const std::string& copied_function_name{ + *function_names_.emplace(std::move(arrow_function_name)).first}; + + size_t index = function_ids_.size(); + + auto it_success = function_id_to_index_.emplace(copied_id, index); + + if (!it_success.second) { + return Status::Invalid("Function id was already registered"); + } + + if (!function_name_to_index_.emplace(copied_function_name, index).second) { + function_id_to_index_.erase(it_success.first); + return Status::Invalid("Function name was already registered"); + } + + function_name_ptrs_.push_back(&copied_function_name); + function_ids_.push_back(copied_id); + return Status::OK(); + } + + // owning storage of uris, names, (arrow::)function_names, types + // note that storing strings like this is safe since references into an + // unordered_set are not invalidated on insertion + std::unordered_set uris_, names_, function_names_; + DataTypeVector types_; + std::vector type_is_variation_; + + // non-owning lookup helpers + std::vector ids_, function_ids_; + std::unordered_map id_to_index_, variation_id_to_index_; + std::unordered_map type_to_index_; + + std::vector function_name_ptrs_; + std::unordered_map function_id_to_index_; + std::unordered_map + function_name_to_index_; + } impl_; + + return &impl_; +} + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/extension_set.h b/cpp/src/arrow/engine/substrait/extension_set.h new file mode 100644 index 00000000000..e9ea80a0043 --- /dev/null +++ b/cpp/src/arrow/engine/substrait/extension_set.h @@ -0,0 +1,137 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// This API is EXPERIMENTAL. + +#pragma once + +#include + +#include "arrow/engine/visibility.h" +#include "arrow/type_fwd.h" +#include "arrow/util/optional.h" +#include "arrow/util/string_view.h" + +namespace arrow { +namespace engine { + +/// A mapping from arrow types and functions to the (uri, name) which identifies +/// the corresponding substrait extension. Substrait types and variations must be +/// registered with their corresponding arrow::DataType before they can be used! +class ARROW_ENGINE_EXPORT ExtensionIdRegistry { + public: + /// All uris registered in this ExtensionIdRegistry + virtual std::vector Uris() const = 0; + + struct Id { + util::string_view uri, name; + + bool empty() const { return uri.empty() && name.empty(); } + }; + + struct TypeRecord { + Id id; + const std::shared_ptr& type; + bool is_variation; + }; + virtual util::optional GetType(const DataType&) const = 0; + virtual util::optional GetType(Id, bool is_variation) const = 0; + virtual Status RegisterType(Id, std::shared_ptr, bool is_variation) = 0; + + // FIXME some functions will not be simple enough to convert without access to their + // arguments/options. For example is_in embeds the set in options rather than using an + // argument: + // is_in(x, SetLookupOptions(set)) <-> (k...Uri, "is_in")(x, set) + // + // ... for another example, depending on the value of the first argument to + // substrait::add it either corresponds to arrow::add or arrow::add_checked + struct FunctionRecord { + Id id; + const std::string& function_name; + }; + virtual util::optional GetFunction(Id) const = 0; + virtual util::optional GetFunction( + util::string_view arrow_function_name) const = 0; + virtual Status RegisterFunction(Id, std::string arrow_function_name) = 0; +}; + +constexpr util::string_view kArrowExtTypesUri = + "https://github.com/apache/arrow/blob/master/format/substrait/" + "extension_types.yaml"; + +ARROW_ENGINE_EXPORT ExtensionIdRegistry* default_extension_id_registry(); + +/// A subset of an ExtensionIdRegistry with extensions identifiable by an integer. +/// +/// ExtensionSet does not own strings; it only refers to strings in an +/// ExtensionIdRegistry. +class ARROW_ENGINE_EXPORT ExtensionSet { + public: + using Id = ExtensionIdRegistry::Id; + + /// Construct an empty ExtensionSet to be populated during serialization. + explicit ExtensionSet(ExtensionIdRegistry* = default_extension_id_registry()); + ARROW_DEFAULT_MOVE_AND_ASSIGN(ExtensionSet); + + /// Construct an ExtensionSet with explicit extension ids for efficient referencing + /// during deserialization. Note that input vectors need not be densely packed; an empty + /// (default constructed) Id may be used as a placeholder to indicate an unused + /// _anchor/_reference. This factory will be used to wrap the extensions declared in a + /// substrait::Plan before deserializing the plan's relations. + /// + /// Views will be replaced with equivalent views pointing to memory owned by the + /// registry. + static Result Make( + std::vector uris, std::vector type_ids, + std::vector type_is_variation, std::vector function_ids, + ExtensionIdRegistry* = default_extension_id_registry()); + + // index in these vectors == value of _anchor/_reference fields + /// FIXME this assumes that _anchor/_references won't be huge, which is not guaranteed. + /// Could it be? + const std::vector& uris() const { return uris_; } + + const DataTypeVector& types() const { return types_; } + const std::vector& type_ids() const { return type_ids_; } + bool type_is_variation(uint32_t i) const { return type_is_variation_[i]; } + + /// Encode a type, looking it up first in this set's ExtensionIdRegistry. + /// If no type is found, an error will be raised. + Result EncodeType(const DataType& type); + + const std::vector& function_ids() const { return function_ids_; } + const std::vector& function_names() const { return function_names_; } + + Result EncodeFunction(util::string_view function_name); + + private: + ExtensionIdRegistry* registry_; + std::vector uris_; + DataTypeVector types_; + std::vector type_ids_; + std::vector type_is_variation_; + + std::vector function_ids_; + std::vector function_names_; + + // pimpl pattern to hide lookup details + struct Impl; + std::unique_ptr impl_; +}; + +} // namespace engine +} // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index 5b5eff0fbb6..32de8980e3e 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -147,321 +147,5 @@ bool UnwrapIntervalDay(const DataType& t) { return false; } -namespace { - -struct TypePtrHashEq { - template - size_t operator()(const Ptr& type) const { - return type->Hash(); - } - - template - bool operator()(const Ptr& l, const Ptr& r) const { - return *l == *r; - } -}; - -struct IdHashEq { - using Id = ExtensionSet::Id; - - size_t operator()(Id id) const { - constexpr ::arrow::internal::StringViewHash hash = {}; - auto out = static_cast(hash(id.uri)); - ::arrow::internal::hash_combine(out, hash(id.name)); - return out; - } - - bool operator()(Id l, Id r) const { return l.uri == r.uri && l.name == r.name; } -}; - -} // namespace - -struct ExtensionSet::Impl { - void AddUri(util::string_view uri, ExtensionSet* self) { - if (uris_.find(uri) != uris_.end()) return; - - self->uris_.push_back(uri); - uris_.insert(self->uris_.back()); // lookup helper's keys should reference memory - // owned by this ExtensionSet - } - - Status CheckHasUri(util::string_view uri) { - if (uris_.find(uri) != uris_.end()) return Status::OK(); - - return Status::Invalid( - "Uri ", uri, - " was referenced by an extension but was not declared in the ExtensionSet."); - } - - uint32_t EncodeType(Id id, const std::shared_ptr& type, bool is_variation, - ExtensionSet* self) { - // note: at this point we're guaranteed to have an Id which points to memory owned by - // the set's registry. - AddUri(id.uri, self); - auto it_success = types_.emplace(id, static_cast(types_.size())); - - if (it_success.second) { - DCHECK_EQ(self->type_ids_.size(), self->types_.size()); - self->type_ids_.push_back(id); - self->types_.push_back(type); - self->type_is_variation_.push_back(is_variation); - } - - return it_success.first->second; - } - - uint32_t EncodeFunction(Id id, util::string_view function_name, ExtensionSet* self) { - // note: at this point we're guaranteed to have an Id which points to memory owned by - // the set's registry. - AddUri(id.uri, self); - auto it_success = functions_.emplace(id, static_cast(functions_.size())); - - if (it_success.second) { - DCHECK_EQ(self->function_ids_.size(), self->function_names_.size()); - self->function_ids_.push_back(id); - self->function_names_.push_back(function_name); - } - - return it_success.first->second; - } - - std::unordered_set uris_; - std::unordered_map types_, functions_; -}; - -ExtensionSet::ExtensionSet(ExtensionIdRegistry* registry) - : registry_(registry), impl_(new Impl(), [](Impl* impl) { delete impl; }) {} - -Result ExtensionSet::Make(std::vector uris, - std::vector type_ids, - std::vector type_is_variation, - std::vector function_ids, - ExtensionIdRegistry* registry) { - ExtensionSet set; - set.registry_ = registry; - - // TODO(bkietz) move this into the registry as registry->OwnUris(&uris) or so - std::unordered_set - uris_owned_by_registry; - for (util::string_view uri : registry->Uris()) { - uris_owned_by_registry.insert(uri); - } - - for (auto& uri : uris) { - if (uri.empty()) continue; - auto it = uris_owned_by_registry.find(uri); - if (it == uris_owned_by_registry.end()) { - return Status::KeyError("Uri '", uri, "' not found in registry"); - } - uri = *it; // Ensure uris point into the registry's memory - set.impl_->AddUri(*it, &set); - } - - if (type_ids.size() != type_is_variation.size()) { - return Status::Invalid("Received ", type_ids.size(), " type ids but a ", - type_is_variation.size(), "-long is_variation vector"); - } - - set.types_.resize(type_ids.size()); - - for (size_t i = 0; i < type_ids.size(); ++i) { - if (type_ids[i].empty()) continue; - RETURN_NOT_OK(set.impl_->CheckHasUri(type_ids[i].uri)); - - if (auto rec = registry->GetType(type_ids[i], type_is_variation[i])) { - set.types_[i] = rec->type; - type_ids[i] = rec->id; // use Id which references memory owned by the registry - continue; - } - return Status::Invalid("Type", (type_is_variation[i] ? " variation" : ""), " ", - type_ids[i].uri, "#", type_ids[i].name, " not found"); - } - - set.function_names_.resize(function_ids.size()); - - for (size_t i = 0; i < function_ids.size(); ++i) { - if (function_ids[i].empty()) continue; - RETURN_NOT_OK(set.impl_->CheckHasUri(function_ids[i].uri)); - - if (auto rec = registry->GetFunction(function_ids[i])) { - set.function_names_[i] = rec->function_name; - function_ids[i] = rec->id; // use Id which references memory owned by the registry - continue; - } - return Status::Invalid("Function ", function_ids[i].uri, "#", type_ids[i].name, - " not found"); - } - - set.function_ids_ = std::move(function_ids); - set.type_ids_ = std::move(type_ids); - set.type_is_variation_ = std::move(type_is_variation); - set.uris_ = std::move(uris); - - return std::move(set); -} - -Result ExtensionSet::EncodeType(const DataType& type) { - if (auto rec = registry_->GetType(type)) { - return impl_->EncodeType(rec->id, rec->type, rec->is_variation, this); - } - return Status::KeyError("type ", type.ToString(), " not found in the registry"); -} - -Result ExtensionSet::EncodeFunction(util::string_view function_name) { - if (auto rec = registry_->GetFunction(function_name)) { - return impl_->EncodeFunction(rec->id, rec->function_name, this); - } - return Status::KeyError("function ", function_name, " not found in the registry"); -} - -template -const int* GetIndex(const KeyToIndex& key_to_index, const Key& key) { - auto it = key_to_index.find(key); - if (it == key_to_index.end()) return nullptr; - return &it->second; -} - -ExtensionIdRegistry* default_extension_id_registry() { - static struct Impl : ExtensionIdRegistry { - Impl() { - struct TypeName { - std::shared_ptr type; - util::string_view name; - }; - - for (TypeName e : { - TypeName{uint8(), "u8"}, - TypeName{uint16(), "u16"}, - TypeName{uint32(), "u32"}, - TypeName{uint64(), "u64"}, - }) { - DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type), - /*is_variation=*/true)); - } - - for (TypeName e : { - TypeName{null(), "null"}, - }) { - DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type), - /*is_variation=*/false)); - } - - for (util::string_view name : { - "add", - }) { - DCHECK_OK(RegisterFunction({kArrowExtTypesUri, name}, name.to_string())); - } - } - - std::vector Uris() const override { - return {uris_.begin(), uris_.end()}; - } - - util::optional GetType(const DataType& type) const override { - if (auto index = GetIndex(type_to_index_, &type)) { - return TypeRecord{ids_[*index], types_[*index], type_is_variation_[*index]}; - } - return {}; - } - - util::optional GetType(Id id, bool is_variation) const override { - if (auto index = - GetIndex(is_variation ? variation_id_to_index_ : id_to_index_, id)) { - return TypeRecord{ids_[*index], types_[*index], type_is_variation_[*index]}; - } - return {}; - } - - Status RegisterType(Id id, std::shared_ptr type, - bool is_variation) override { - DCHECK_EQ(ids_.size(), types_.size()); - DCHECK_EQ(ids_.size(), type_is_variation_.size()); - - Id copied_id{*uris_.emplace(id.uri.to_string()).first, - *names_.emplace(id.name.to_string()).first}; - - size_t index = ids_.size(); - - auto* id_to_index = is_variation ? &variation_id_to_index_ : &id_to_index_; - auto it_success = id_to_index->emplace(copied_id, index); - - if (!it_success.second) { - return Status::Invalid("Type id was already registered"); - } - - if (!type_to_index_.emplace(type.get(), index).second) { - id_to_index->erase(it_success.first); - return Status::Invalid("Type was already registered"); - } - - ids_.push_back(copied_id); - types_.push_back(std::move(type)); - type_is_variation_.push_back(is_variation); - return Status::OK(); - } - - util::optional GetFunction( - util::string_view arrow_function_name) const override { - if (auto index = GetIndex(function_name_to_index_, arrow_function_name)) { - return FunctionRecord{function_ids_[*index], *function_name_ptrs_[*index]}; - } - return {}; - } - - util::optional GetFunction(Id id) const override { - if (auto index = GetIndex(function_id_to_index_, id)) { - return FunctionRecord{function_ids_[*index], *function_name_ptrs_[*index]}; - } - return {}; - } - - Status RegisterFunction(Id id, std::string arrow_function_name) override { - DCHECK_EQ(function_ids_.size(), function_name_ptrs_.size()); - - Id copied_id{*uris_.emplace(id.uri.to_string()).first, - *names_.emplace(id.name.to_string()).first}; - - const std::string& copied_function_name{ - *function_names_.emplace(std::move(arrow_function_name)).first}; - - size_t index = function_ids_.size(); - - auto it_success = function_id_to_index_.emplace(copied_id, index); - - if (!it_success.second) { - return Status::Invalid("Function id was already registered"); - } - - if (!function_name_to_index_.emplace(copied_function_name, index).second) { - function_id_to_index_.erase(it_success.first); - return Status::Invalid("Function name was already registered"); - } - - function_name_ptrs_.push_back(&copied_function_name); - function_ids_.push_back(copied_id); - return Status::OK(); - } - - // owning storage of uris, names, (arrow::)function_names, types - // note that storing strings like this is safe since references into an - // unordered_set are not invalidated on insertion - std::unordered_set uris_, names_, function_names_; - DataTypeVector types_; - std::vector type_is_variation_; - - // non-owning lookup helpers - std::vector ids_, function_ids_; - std::unordered_map id_to_index_, variation_id_to_index_; - std::unordered_map type_to_index_; - - std::vector function_name_ptrs_; - std::unordered_map function_id_to_index_; - std::unordered_map - function_name_to_index_; - } impl_; - - return &impl_; -} - } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/extension_types.h b/cpp/src/arrow/engine/substrait/extension_types.h index b392fffe797..e689e94722e 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.h +++ b/cpp/src/arrow/engine/substrait/extension_types.h @@ -78,109 +78,5 @@ bool UnwrapIntervalYear(const DataType&); ARROW_ENGINE_EXPORT bool UnwrapIntervalDay(const DataType&); -/// A mapping from arrow types and functions to the (uri, name) which identifies -/// the corresponding substrait extension. Substrait types and variations must be -/// registered with their corresponding arrow::DataType before they can be used! -class ARROW_ENGINE_EXPORT ExtensionIdRegistry { - public: - /// All uris registered in this ExtensionIdRegistry - virtual std::vector Uris() const = 0; - - struct Id { - util::string_view uri, name; - - bool empty() const { return uri.empty() && name.empty(); } - }; - - struct TypeRecord { - Id id; - const std::shared_ptr& type; - bool is_variation; - }; - virtual util::optional GetType(const DataType&) const = 0; - virtual util::optional GetType(Id, bool is_variation) const = 0; - virtual Status RegisterType(Id, std::shared_ptr, bool is_variation) = 0; - - // FIXME some functions will not be simple enough to convert without access to their - // arguments/options. For example is_in embeds the set in options rather than using an - // argument: - // is_in(x, SetLookupOptions(set)) <-> (k...Uri, "is_in")(x, set) - // - // ... for another example, depending on the value of the first argument to - // substrait::add it either corresponds to arrow::add or arrow::add_checked - struct FunctionRecord { - Id id; - const std::string& function_name; - }; - virtual util::optional GetFunction(Id) const = 0; - virtual util::optional GetFunction( - util::string_view arrow_function_name) const = 0; - virtual Status RegisterFunction(Id, std::string arrow_function_name) = 0; -}; - -constexpr util::string_view kArrowExtTypesUri = - "https://github.com/apache/arrow/blob/master/format/substrait/" - "extension_types.yaml"; - -ARROW_ENGINE_EXPORT ExtensionIdRegistry* default_extension_id_registry(); - -/// A subset of an ExtensionIdRegistry with extensions identifiable by an integer. -/// -/// ExtensionSet does not own strings; it only refers to strings in an -/// ExtensionIdRegistry. -class ARROW_ENGINE_EXPORT ExtensionSet { - public: - using Id = ExtensionIdRegistry::Id; - - /// Construct an empty ExtensionSet to be populated during serialization. - explicit ExtensionSet(ExtensionIdRegistry* = default_extension_id_registry()); - ARROW_DEFAULT_MOVE_AND_ASSIGN(ExtensionSet); - - /// Construct an ExtensionSet with explicit extension ids for efficient referencing - /// during deserialization. Note that input vectors need not be densely packed; an empty - /// (default constructed) Id may be used as a placeholder to indicate an unused - /// _anchor/_reference. This factory will be used to wrap the extensions declared in a - /// substrait::Plan before deserializing the plan's relations. - /// - /// Views will be replaced with equivalent views pointing to memory owned by the - /// registry. - static Result Make( - std::vector uris, std::vector type_ids, - std::vector type_is_variation, std::vector function_ids, - ExtensionIdRegistry* = default_extension_id_registry()); - - // index in these vectors == value of _anchor/_reference fields - /// FIXME this assumes that _anchor/_references won't be huge, which is not guaranteed. - /// Could it be? - const std::vector& uris() const { return uris_; } - - const DataTypeVector& types() const { return types_; } - const std::vector& type_ids() const { return type_ids_; } - bool type_is_variation(uint32_t i) const { return type_is_variation_[i]; } - - /// Encode a type, looking it up first in this set's ExtensionIdRegistry. - /// If no type is found, an error will be raised. - Result EncodeType(const DataType& type); - - const std::vector& function_ids() const { return function_ids_; } - const std::vector& function_names() const { return function_names_; } - - Result EncodeFunction(util::string_view function_name); - - private: - ExtensionIdRegistry* registry_; - std::vector uris_; - DataTypeVector types_; - std::vector type_ids_; - std::vector type_is_variation_; - - std::vector function_ids_; - std::vector function_names_; - - // pimpl pattern to hide lookup details - struct Impl; - std::unique_ptr impl_; -}; - } // namespace engine } // namespace arrow diff --git a/cpp/src/arrow/engine/substrait/plan_internal.h b/cpp/src/arrow/engine/substrait/plan_internal.h index ff1946aa64e..5819ea209f2 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.h +++ b/cpp/src/arrow/engine/substrait/plan_internal.h @@ -19,7 +19,7 @@ #pragma once -#include "arrow/engine/substrait/extension_types.h" +#include "arrow/engine/substrait/extension_set.h" #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index 68970cb6137..a9f0fcfca5a 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -26,7 +26,7 @@ #include "arrow/buffer.h" #include "arrow/compute/exec/exec_plan.h" #include "arrow/compute/exec/options.h" -#include "arrow/engine/substrait/extension_types.h" +#include "arrow/engine/substrait/extension_set.h" #include "arrow/engine/visibility.h" #include "arrow/result.h" #include "arrow/util/string_view.h" diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index e43e0b0c442..0b516436140 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -20,7 +20,6 @@ #include #include -#include "arrow/buffer.h" #include "arrow/engine/substrait/extension_types.h" #include "arrow/result.h" #include "arrow/status.h" diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h index c3ee0c619a6..380c07024d0 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -21,7 +21,7 @@ #include -#include "arrow/engine/substrait/extension_types.h" +#include "arrow/engine/substrait/extension_set.h" #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" From 5b362f907c8867a554ed6187c1bf2d85fc68600c Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 11:41:00 -0500 Subject: [PATCH 059/113] ensure generated files are also excluded from rat --- dev/release/rat_exclude_files.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt index 6229e0aec39..671b11cd362 100644 --- a/dev/release/rat_exclude_files.txt +++ b/dev/release/rat_exclude_files.txt @@ -31,6 +31,7 @@ cpp/src/generated/parquet_constants.cpp cpp/src/generated/parquet_constants.h cpp/src/generated/parquet_types.cpp cpp/src/generated/parquet_types.h +cpp/src/generated/substrait/* cpp/src/plasma/thirdparty/ae/ae.c cpp/src/plasma/thirdparty/ae/ae.h cpp/src/plasma/thirdparty/ae/ae_epoll.c From b1a9bbac3e60f6b4fcb2a393ae5132ea10044542 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 11:48:51 -0500 Subject: [PATCH 060/113] put actual json in engine_substrait_consumption.cc --- .../arrow/engine_substrait_consumption.cc | 60 +++++++++++++++++-- .../arrow/engine/ArrowEngineConfig.cmake.in | 2 + 2 files changed, 58 insertions(+), 4 deletions(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index 0ab789a4372..1dfaff1b67d 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -127,9 +127,61 @@ int main(int argc, char** argv) { arrow::Future> GetSubstraitFromServer() { // Emulate server interaction by parsing hard coded JSON return eng::internal::SubstraitFromJSON("Plan", R"({ - // FIXME - // in particular, this example will need some LocalFiles to read from as an input - // this function should probably write them to a tmp dir or at least assert that - // there's a readable dataset there + "relations": [ + {"rel": { + "read": { + "base_schema": { + "struct": { + "types": [ {"i64": {}}, {"bool": {}} ] + }, + "names": ["i", "b"] + }, + "filter": { + "selection": { + "directReference": { + "structField": { + "field": 1 + } + } + } + }, + "local_files": { + "items": [ + { + "uri_file": "file:///tmp/dat1.parquet", + "format": "FILE_FORMAT_PARQUET" + }, + { + "uri_file": "file:///tmp/dat2.parquet", + "format": "FILE_FORMAT_PARQUET" + } + ] + } + } + }} + ], + "extension_uris": [ + { + "extension_uri_anchor": 7, + "uri": "https://github.com/apache/arrow/blob/master/format/substrait/extension_types.yaml" + } + ], + "extensions": [ + {"extension_type": { + "extension_uri_reference": 7, + "type_anchor": 42, + "name": "null" + }}, + {"extension_type_variation": { + "extension_uri_reference": 7, + "type_variation_anchor": 23, + "name": "u8" + }}, + {"extension_function": { + "extension_uri_reference": 7, + "function_anchor": 42, + "name": "add" + }} + ] })"); } diff --git a/cpp/src/arrow/engine/ArrowEngineConfig.cmake.in b/cpp/src/arrow/engine/ArrowEngineConfig.cmake.in index b7c9cb19b26..8fafcda3864 100644 --- a/cpp/src/arrow/engine/ArrowEngineConfig.cmake.in +++ b/cpp/src/arrow/engine/ArrowEngineConfig.cmake.in @@ -28,6 +28,8 @@ include(CMakeFindDependencyMacro) find_dependency(Arrow) +find_dependency(ArrowDataset) +find_dependency(Parquet) # Load targets only once. If we load targets multiple times, CMake reports # already existent target error. From b6499aeb368070ccff11cf3b894edded11c1b12e Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 12:01:21 -0500 Subject: [PATCH 061/113] msvc: suppress C4251 (needs dll-interface) --- cpp/cmake_modules/SetupCxxFlags.cmake | 1 + 1 file changed, 1 insertion(+) diff --git a/cpp/cmake_modules/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake index 0111d1f9dbb..5093c06dea2 100644 --- a/cpp/cmake_modules/SetupCxxFlags.cmake +++ b/cpp/cmake_modules/SetupCxxFlags.cmake @@ -277,6 +277,7 @@ if("${BUILD_WARNING_LEVEL}" STREQUAL "CHECKIN") set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4365") set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4267") set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4838") + set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4251") elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall") From 1473dc24b89dd47698ec4475ac20d84b7b2e4043 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 12:03:28 -0500 Subject: [PATCH 062/113] remove duplicate ARROW_ENGINE option --- cpp/cmake_modules/DefineOptions.cmake | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake index 44fedec80c3..4347c6f2b3e 100644 --- a/cpp/cmake_modules/DefineOptions.cmake +++ b/cpp/cmake_modules/DefineOptions.cmake @@ -219,15 +219,13 @@ if("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") define_option(ARROW_COMPUTE "Build the Arrow Compute Modules" OFF) - define_option(ARROW_ENGINE "Build the Arrow Query Engine Module" OFF) - define_option(ARROW_CSV "Build the Arrow CSV Parser Module" OFF) define_option(ARROW_CUDA "Build the Arrow CUDA extensions (requires CUDA toolkit)" OFF) define_option(ARROW_DATASET "Build the Arrow Dataset Modules" OFF) - define_option(ARROW_ENGINE "Build the Arrow Execution Engine" OFF) + define_option(ARROW_ENGINE "Build the Arrow Query Engine Module" OFF) define_option(ARROW_FILESYSTEM "Build the Arrow Filesystem Layer" OFF) From 107c5b7a04be84718f309a9c1650b200668e3e64 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 12:05:34 -0500 Subject: [PATCH 063/113] ensure ARROW_DATASET is available if ARROW_ENGINE=on --- cpp/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt index fd7027c30eb..c26c6403676 100644 --- a/cpp/CMakeLists.txt +++ b/cpp/CMakeLists.txt @@ -352,6 +352,7 @@ endif() if(ARROW_ENGINE) set(ARROW_COMPUTE ON) + set(ARROW_DATASET ON) endif() if(ARROW_SKYHOOK) From 5012be646364cc7c657fb513a6a56d9389e08e80 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 12:55:49 -0500 Subject: [PATCH 064/113] try to localize suppressions, try defining LIBPROTOBUF_EXPORTS --- cpp/cmake_modules/SetupCxxFlags.cmake | 1 - cpp/src/arrow/engine/CMakeLists.txt | 14 +++++++++++++- 2 files changed, 13 insertions(+), 2 deletions(-) diff --git a/cpp/cmake_modules/SetupCxxFlags.cmake b/cpp/cmake_modules/SetupCxxFlags.cmake index 5093c06dea2..0111d1f9dbb 100644 --- a/cpp/cmake_modules/SetupCxxFlags.cmake +++ b/cpp/cmake_modules/SetupCxxFlags.cmake @@ -277,7 +277,6 @@ if("${BUILD_WARNING_LEVEL}" STREQUAL "CHECKIN") set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4365") set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4267") set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4838") - set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} /wd4251") elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang" OR CMAKE_CXX_COMPILER_ID STREQUAL "Clang") set(CXX_COMMON_FLAGS "${CXX_COMMON_FLAGS} -Wall") diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index feaf1814549..2146cd0cfcc 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -62,6 +62,14 @@ externalproject_add(substrait_ep BUILD_COMMAND "" INSTALL_COMMAND "") +set(SUBSTRAIT_SUPPRESSED_WARNINGS) +if(MSVC) + # Protobuf generated files trigger some spurious warnings on MSVC. + + # Implicit conversion from uint64_t to uint32_t: + list(APPEND SUBSTRAIT_SUPPRESSED_WARNINGS "/wd4244") +endif() + set(SUBSTRAIT_PROTO_GEN_ALL) foreach(SUBSTRAIT_PROTO ${SUBSTRAIT_PROTOS}) set(SUBSTRAIT_PROTO_GEN "${SUBSTRAIT_GEN_DIR}/substrait/${SUBSTRAIT_PROTO}.pb") @@ -69,6 +77,7 @@ foreach(SUBSTRAIT_PROTO ${SUBSTRAIT_PROTOS}) foreach(EXT h cc) set_source_files_properties("${SUBSTRAIT_PROTO_GEN}.${EXT}" PROPERTIES + COMPILE_OPTIONS "${SUBSTRAIT_SUPPRESSED_WARNINGS}" GENERATED TRUE SKIP_UNITY_BUILD_INCLUSION TRUE) add_custom_command(OUTPUT "${SUBSTRAIT_PROTO_GEN}.${EXT}" @@ -116,7 +125,10 @@ add_arrow_lib(arrow_engine ${ARROW_ENGINE_LINK_LIBS}) foreach(LIB_TARGET ${ARROW_ENGINE_LIBRARIES}) - target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_ENGINE_EXPORTING) + target_compile_definitions(${LIB_TARGET} + PRIVATE + ARROW_ENGINE_EXPORTING + LIBPROTOBUF_EXPORTS) endforeach() set(ARROW_ENGINE_TEST_LINK_LIBS ${ARROW_ENGINE_LINK_lIBS} ${ARROW_TEST_LINK_LIBS}) From 2c73334793338014cbe686f9e7106cdfcc5632e4 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 12:59:01 -0500 Subject: [PATCH 065/113] run cmake-format --- cpp/cmake_modules/DefineOptions.cmake | 3 +- cpp/cmake_modules/FindArrowEngine.cmake | 3 +- cpp/examples/arrow/CMakeLists.txt | 4 +-- cpp/src/arrow/engine/CMakeLists.txt | 39 ++++++++++++------------- 4 files changed, 23 insertions(+), 26 deletions(-) diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake index 4347c6f2b3e..8a7f31041d7 100644 --- a/cpp/cmake_modules/DefineOptions.cmake +++ b/cpp/cmake_modules/DefineOptions.cmake @@ -479,7 +479,8 @@ that have not been built" OFF) set(ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT - "https://github.com/substrait-io/substrait e1b4c04a1b518912f4c4065b16a1b2c0ac8e14cf") + "https://github.com/substrait-io/substrait e1b4c04a1b518912f4c4065b16a1b2c0ac8e14cf" + ) define_option_string(ARROW_SUBSTRAIT_REPO_AND_TAG "Custom 'repository_url tag' for generating substrait accessors" "${ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT}") diff --git a/cpp/cmake_modules/FindArrowEngine.cmake b/cpp/cmake_modules/FindArrowEngine.cmake index 3621730b264..3ee09e0de3d 100644 --- a/cpp/cmake_modules/FindArrowEngine.cmake +++ b/cpp/cmake_modules/FindArrowEngine.cmake @@ -76,8 +76,7 @@ mark_as_advanced(ARROW_ENGINE_IMPORT_LIB find_package_handle_standard_args( ArrowEngine - REQUIRED_VARS ARROW_ENGINE_INCLUDE_DIR ARROW_ENGINE_LIB_DIR - ARROW_ENGINE_VERSION_MATCH + REQUIRED_VARS ARROW_ENGINE_INCLUDE_DIR ARROW_ENGINE_LIB_DIR ARROW_ENGINE_VERSION_MATCH VERSION_VAR ARROW_ENGINE_VERSION) set(ARROW_ENGINE_FOUND ${ArrowEngine_FOUND}) diff --git a/cpp/examples/arrow/CMakeLists.txt b/cpp/examples/arrow/CMakeLists.txt index 58d916625af..838d7b982c9 100644 --- a/cpp/examples/arrow/CMakeLists.txt +++ b/cpp/examples/arrow/CMakeLists.txt @@ -22,9 +22,7 @@ if(ARROW_COMPUTE) endif() if(ARROW_ENGINE) - add_arrow_example(engine_substrait_consumption - EXTRA_LINK_LIBS - arrow_engine_shared) + add_arrow_example(engine_substrait_consumption EXTRA_LINK_LIBS arrow_engine_shared) endif() if(ARROW_COMPUTE AND ARROW_CSV) diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 2146cd0cfcc..d87093f5510 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -36,19 +36,21 @@ set(ARROW_ENGINE_SRCS set(SUBSTRAIT_LOCAL_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait") set(SUBSTRAIT_GEN_DIR "${ARROW_SOURCE_DIR}/src/generated") -set(SUBSTRAIT_PROTOS capabilities - expression - extensions/extensions - function - parameterized_types - plan - relations - type - type_expressions) +set(SUBSTRAIT_PROTOS + capabilities + expression + extensions/extensions + function + parameterized_types + plan + relations + type + type_expressions) string(FIND "${ARROW_SUBSTRAIT_REPO_AND_TAG}" " " TAG_START) if(TAG_START EQUAL -1) - message(FATAL_ERROR "Cannot parse ARROW_SUBSTRAIT_REPO_AND_TAG='${ARROW_SUBSTRAIT_REPO_AND_TAG}'") + message(FATAL_ERROR "Cannot parse ARROW_SUBSTRAIT_REPO_AND_TAG='${ARROW_SUBSTRAIT_REPO_AND_TAG}'" + ) endif() string(SUBSTRING "${ARROW_SUBSTRAIT_REPO_AND_TAG}" 0 ${TAG_START} ARROW_SUBSTRAIT_REPO) string(SUBSTRING "${ARROW_SUBSTRAIT_REPO_AND_TAG}" ${TAG_START} -1 ARROW_SUBSTRAIT_TAG) @@ -76,13 +78,12 @@ foreach(SUBSTRAIT_PROTO ${SUBSTRAIT_PROTOS}) foreach(EXT h cc) set_source_files_properties("${SUBSTRAIT_PROTO_GEN}.${EXT}" - PROPERTIES - COMPILE_OPTIONS "${SUBSTRAIT_SUPPRESSED_WARNINGS}" - GENERATED TRUE - SKIP_UNITY_BUILD_INCLUSION TRUE) + PROPERTIES COMPILE_OPTIONS + "${SUBSTRAIT_SUPPRESSED_WARNINGS}" + GENERATED TRUE + SKIP_UNITY_BUILD_INCLUSION TRUE) add_custom_command(OUTPUT "${SUBSTRAIT_PROTO_GEN}.${EXT}" - COMMAND ${ARROW_PROTOBUF_PROTOC} - "-I${SUBSTRAIT_LOCAL_DIR}/proto" + COMMAND ${ARROW_PROTOBUF_PROTOC} "-I${SUBSTRAIT_LOCAL_DIR}/proto" "--cpp_out=${SUBSTRAIT_GEN_DIR}" "${SUBSTRAIT_LOCAL_DIR}/proto/substrait/${SUBSTRAIT_PROTO}.proto" DEPENDS ${PROTO_DEPENDS} substrait_ep) @@ -125,10 +126,8 @@ add_arrow_lib(arrow_engine ${ARROW_ENGINE_LINK_LIBS}) foreach(LIB_TARGET ${ARROW_ENGINE_LIBRARIES}) - target_compile_definitions(${LIB_TARGET} - PRIVATE - ARROW_ENGINE_EXPORTING - LIBPROTOBUF_EXPORTS) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_ENGINE_EXPORTING + LIBPROTOBUF_EXPORTS) endforeach() set(ARROW_ENGINE_TEST_LINK_LIBS ${ARROW_ENGINE_LINK_lIBS} ${ARROW_TEST_LINK_LIBS}) From 65c2ee878de1d03a1f69679ea080d7c3f7edcd8d Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 13:59:29 -0500 Subject: [PATCH 066/113] msvc: just suppress C4251, more int/size_t fixes --- cpp/src/arrow/engine/CMakeLists.txt | 3 +++ .../engine/substrait/expression_internal.cc | 8 ++++---- cpp/src/arrow/engine/substrait/extension_set.cc | 16 ++++++++-------- cpp/src/arrow/engine/substrait/plan_internal.cc | 6 +++--- 4 files changed, 18 insertions(+), 15 deletions(-) diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index d87093f5510..8412edd197d 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -70,6 +70,9 @@ if(MSVC) # Implicit conversion from uint64_t to uint32_t: list(APPEND SUBSTRAIT_SUPPRESSED_WARNINGS "/wd4244") + + # Missing dll-interface: + list(APPEND SUBSTRAIT_SUPPRESSED_WARNINGS "/wd4251") endif() set(SUBSTRAIT_PROTO_GEN_ALL) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index a2e040ba2e5..8f6e35b566f 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -173,7 +173,7 @@ Result FromProto(const substrait::Expression& expr, auto id = ext_set.function_ids()[scalar_fn.function_reference()]; std::vector arguments(scalar_fn.args_size()); - for (size_t i = 0; i < arguments.size(); ++i) { + for (int i = 0; i < scalar_fn.args_size(); ++i) { ARROW_ASSIGN_OR_RAISE(arguments[i], FromProto(scalar_fn.args(i), ext_set)); } @@ -289,7 +289,7 @@ Result FromProto(const substrait::Expression::Literal& lit, ScalarVector fields(struct_.fields_size()); std::vector field_names(fields.size(), ""); - for (size_t i = 0; i < fields.size(); ++i) { + for (int i = 0; i < struct_.fields_size(); ++i) { ARROW_ASSIGN_OR_RAISE(auto field, FromProto(struct_.fields(i), ext_set)); DCHECK(field.is_scalar()); fields[i] = field.scalar(); @@ -310,7 +310,7 @@ Result FromProto(const substrait::Expression::Literal& lit, std::shared_ptr element_type; ScalarVector values(list.values_size()); - for (size_t i = 0; i < values.size(); ++i) { + for (int i = 0; i < list.values_size(); ++i) { ARROW_ASSIGN_OR_RAISE(auto value, FromProto(list.values(i), ext_set)); DCHECK(value.is_scalar()); values[i] = value.scalar(); @@ -889,7 +889,7 @@ Result> ToProto(const compute::Expression auto scalar_fn = internal::make_unique(); scalar_fn->set_function_reference(anchor); - scalar_fn->mutable_args()->Reserve(arguments.size()); + scalar_fn->mutable_args()->Reserve(static_cast(arguments.size())); for (auto& arg : arguments) { scalar_fn->mutable_args()->AddAllocated(arg.release()); } diff --git a/cpp/src/arrow/engine/substrait/extension_set.cc b/cpp/src/arrow/engine/substrait/extension_set.cc index 2106086ac3a..084f8f3bb4f 100644 --- a/cpp/src/arrow/engine/substrait/extension_set.cc +++ b/cpp/src/arrow/engine/substrait/extension_set.cc @@ -238,7 +238,7 @@ ExtensionIdRegistry* default_extension_id_registry() { util::optional GetType(const DataType& type) const override { if (auto index = GetIndex(type_to_index_, &type)) { - return TypeRecord{ids_[*index], types_[*index], type_is_variation_[*index]}; + return TypeRecord{type_ids_[*index], types_[*index], type_is_variation_[*index]}; } return {}; } @@ -246,20 +246,20 @@ ExtensionIdRegistry* default_extension_id_registry() { util::optional GetType(Id id, bool is_variation) const override { if (auto index = GetIndex(is_variation ? variation_id_to_index_ : id_to_index_, id)) { - return TypeRecord{ids_[*index], types_[*index], type_is_variation_[*index]}; + return TypeRecord{type_ids_[*index], types_[*index], type_is_variation_[*index]}; } return {}; } Status RegisterType(Id id, std::shared_ptr type, bool is_variation) override { - DCHECK_EQ(ids_.size(), types_.size()); - DCHECK_EQ(ids_.size(), type_is_variation_.size()); + DCHECK_EQ(type_ids_.size(), types_.size()); + DCHECK_EQ(type_ids_.size(), type_is_variation_.size()); Id copied_id{*uris_.emplace(id.uri.to_string()).first, *names_.emplace(id.name.to_string()).first}; - size_t index = ids_.size(); + auto index = static_cast(type_ids_.size()); auto* id_to_index = is_variation ? &variation_id_to_index_ : &id_to_index_; auto it_success = id_to_index->emplace(copied_id, index); @@ -273,7 +273,7 @@ ExtensionIdRegistry* default_extension_id_registry() { return Status::Invalid("Type was already registered"); } - ids_.push_back(copied_id); + type_ids_.push_back(copied_id); types_.push_back(std::move(type)); type_is_variation_.push_back(is_variation); return Status::OK(); @@ -303,7 +303,7 @@ ExtensionIdRegistry* default_extension_id_registry() { const std::string& copied_function_name{ *function_names_.emplace(std::move(arrow_function_name)).first}; - size_t index = function_ids_.size(); + auto index = static_cast(function_ids_.size()); auto it_success = function_id_to_index_.emplace(copied_id, index); @@ -329,7 +329,7 @@ ExtensionIdRegistry* default_extension_id_registry() { std::vector type_is_variation_; // non-owning lookup helpers - std::vector ids_, function_ids_; + std::vector type_ids_, function_ids_; std::unordered_map id_to_index_, variation_id_to_index_; std::unordered_map type_to_index_; diff --git a/cpp/src/arrow/engine/substrait/plan_internal.cc b/cpp/src/arrow/engine/substrait/plan_internal.cc index e7605095078..90fda742713 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.cc +++ b/cpp/src/arrow/engine/substrait/plan_internal.cc @@ -40,7 +40,7 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan) auto uris = plan->mutable_extension_uris(); uris->Reserve(static_cast(ext_set.uris().size())); - for (size_t anchor = 0; anchor < ext_set.uris().size(); ++anchor) { + for (uint32_t anchor = 0; anchor < ext_set.uris().size(); ++anchor) { auto uri = ext_set.uris()[anchor]; if (uri.empty()) continue; @@ -58,7 +58,7 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan) using ExtDecl = substrait::extensions::SimpleExtensionDeclaration; - for (size_t anchor = 0; anchor < ext_set.type_ids().size(); ++anchor) { + for (uint32_t anchor = 0; anchor < ext_set.type_ids().size(); ++anchor) { auto id = ext_set.type_ids()[anchor]; if (id.empty()) continue; @@ -81,7 +81,7 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan) extensions->AddAllocated(ext_decl.release()); } - for (size_t anchor = 0; anchor < ext_set.function_ids().size(); ++anchor) { + for (uint32_t anchor = 0; anchor < ext_set.function_ids().size(); ++anchor) { auto id = ext_set.function_ids()[anchor]; if (id.empty()) continue; From 6d8ebc7d8334214702af60539eac8d2ba34fed65 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 14:09:58 -0500 Subject: [PATCH 067/113] msvc: one more int/size_t fix --- cpp/src/arrow/engine/substrait/expression_internal.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 8f6e35b566f..796f9ab5a72 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -341,7 +341,7 @@ Result FromProto(const substrait::Expression::Literal& lit, std::shared_ptr key_type, value_type; ScalarVector keys(map.key_values_size()), values(map.key_values_size()); - for (size_t i = 0; i < values.size(); ++i) { + for (int i = 0; i < map.key_values_size(); ++i) { const auto& kv = map.key_values(i); static const std::array kMissing = {"key and value", "value", From adfe196a08334cd8f911a334b2d2c681ae37a0b0 Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 14:41:24 -0500 Subject: [PATCH 068/113] msvc: one more int/size_t fix --- cpp/src/arrow/engine/substrait/serde_test.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index e0b3952bcb2..983ff6d5a3d 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -73,7 +73,7 @@ const std::shared_ptr kBoringSchema = schema({ std::shared_ptr StripFieldNames(std::shared_ptr type) { if (type->id() == Type::STRUCT) { FieldVector fields(type->num_fields()); - for (size_t i = 0; i < fields.size(); ++i) { + for (int i = 0; i < type->num_fields(); ++i) { fields[i] = type->field(i)->WithName(""); } return struct_(std::move(fields)); From 0a965c5d118591aed99f398659e37ead38c8660c Mon Sep 17 00:00:00 2001 From: Benjamin Kietzman Date: Fri, 21 Jan 2022 15:41:23 -0500 Subject: [PATCH 069/113] use libprotobuf 3.19 --- .../generated/substrait/capabilities.pb.cc | 271 +- cpp/src/generated/substrait/capabilities.pb.h | 168 +- cpp/src/generated/substrait/expression.pb.cc | 6904 ++++++++--------- cpp/src/generated/substrait/expression.pb.h | 4379 +++++++---- .../substrait/extensions/extensions.pb.cc | 930 ++- .../substrait/extensions/extensions.pb.h | 695 +- cpp/src/generated/substrait/function.pb.cc | 1992 +++-- cpp/src/generated/substrait/function.pb.h | 1219 +-- .../substrait/parameterized_types.pb.cc | 2164 +++--- .../substrait/parameterized_types.pb.h | 1390 ++-- cpp/src/generated/substrait/plan.pb.cc | 279 +- cpp/src/generated/substrait/plan.pb.h | 163 +- cpp/src/generated/substrait/relations.pb.cc | 3978 +++++----- cpp/src/generated/substrait/relations.pb.h | 3051 +++++--- cpp/src/generated/substrait/type.pb.cc | 3705 +++++---- cpp/src/generated/substrait/type.pb.h | 2114 +++-- .../substrait/type_expressions.pb.cc | 2366 +++--- .../generated/substrait/type_expressions.pb.h | 1597 ++-- 18 files changed, 19587 insertions(+), 17778 deletions(-) diff --git a/cpp/src/generated/substrait/capabilities.pb.cc b/cpp/src/generated/substrait/capabilities.pb.cc index 29156824796..a87949956df 100644 --- a/cpp/src/generated/substrait/capabilities.pb.cc +++ b/cpp/src/generated/substrait/capabilities.pb.cc @@ -51,12 +51,13 @@ static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fcapabil static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fcapabilities_2eproto = nullptr; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fcapabilities_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fcapabilities_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const uint32_t TableStruct_substrait_2fcapabilities_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, uri_), PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, function_keys_), PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, type_keys_), @@ -66,13 +67,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fcapabilities_2epro ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, substrait_versions_), PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, advanced_extension_type_urls_), PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, simple_extensions_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::substrait::Capabilities_SimpleExtension)}, - { 9, -1, sizeof(::substrait::Capabilities)}, + { 0, -1, -1, sizeof(::substrait::Capabilities_SimpleExtension)}, + { 10, -1, -1, sizeof(::substrait::Capabilities)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -112,13 +114,16 @@ class Capabilities_SimpleExtension::_Internal { public: }; -Capabilities_SimpleExtension::Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Capabilities_SimpleExtension::Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), function_keys_(arena), type_keys_(arena), type_variation_keys_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Capabilities.SimpleExtension) } Capabilities_SimpleExtension::Capabilities_SimpleExtension(const Capabilities_SimpleExtension& from) @@ -128,25 +133,32 @@ Capabilities_SimpleExtension::Capabilities_SimpleExtension(const Capabilities_Si type_variation_keys_(from.type_variation_keys_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_uri().empty()) { uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), - GetArena()); + GetArenaForAllocation()); } // @@protoc_insertion_point(copy_constructor:substrait.Capabilities.SimpleExtension) } -void Capabilities_SimpleExtension::SharedCtor() { +inline void Capabilities_SimpleExtension::SharedCtor() { uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } Capabilities_SimpleExtension::~Capabilities_SimpleExtension() { // @@protoc_insertion_point(destructor:substrait.Capabilities.SimpleExtension) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Capabilities_SimpleExtension::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Capabilities_SimpleExtension::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -162,7 +174,7 @@ void Capabilities_SimpleExtension::SetCachedSize(int size) const { void Capabilities_SimpleExtension::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Capabilities.SimpleExtension) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -176,21 +188,22 @@ void Capabilities_SimpleExtension::Clear() { const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string uri = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_uri(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.uri")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated string function_keys = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -200,11 +213,12 @@ const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROT CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated string type_keys = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -214,11 +228,12 @@ const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROT CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated string type_variation_keys = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr -= 1; do { ptr += 1; @@ -228,39 +243,40 @@ const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROT CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Capabilities_SimpleExtension::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Capabilities_SimpleExtension::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Capabilities.SimpleExtension) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string uri = 1; - if (this->uri().size() > 0) { + if (!this->_internal_uri().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_uri().data(), static_cast(this->_internal_uri().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -311,7 +327,7 @@ size_t Capabilities_SimpleExtension::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Capabilities.SimpleExtension) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -340,56 +356,41 @@ size_t Capabilities_SimpleExtension::ByteSizeLong() const { } // string uri = 1; - if (this->uri().size() > 0) { + if (!this->_internal_uri().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_uri()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Capabilities_SimpleExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Capabilities.SimpleExtension) - GOOGLE_DCHECK_NE(&from, this); - const Capabilities_SimpleExtension* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Capabilities.SimpleExtension) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Capabilities.SimpleExtension) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Capabilities_SimpleExtension::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Capabilities_SimpleExtension::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Capabilities_SimpleExtension::GetClassData() const { return &_class_data_; } + +void Capabilities_SimpleExtension::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Capabilities_SimpleExtension::MergeFrom(const Capabilities_SimpleExtension& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Capabilities.SimpleExtension) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; function_keys_.MergeFrom(from.function_keys_); type_keys_.MergeFrom(from.type_keys_); type_variation_keys_.MergeFrom(from.type_variation_keys_); - if (from.uri().size() > 0) { + if (!from._internal_uri().empty()) { _internal_set_uri(from._internal_uri()); } -} - -void Capabilities_SimpleExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Capabilities.SimpleExtension) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Capabilities_SimpleExtension::CopyFrom(const Capabilities_SimpleExtension& from) { @@ -405,11 +406,17 @@ bool Capabilities_SimpleExtension::IsInitialized() const { void Capabilities_SimpleExtension::InternalSwap(Capabilities_SimpleExtension* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); function_keys_.InternalSwap(&other->function_keys_); type_keys_.InternalSwap(&other->type_keys_); type_variation_keys_.InternalSwap(&other->type_variation_keys_); - uri_.Swap(&other->uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &uri_, lhs_arena, + &other->uri_, rhs_arena + ); } ::PROTOBUF_NAMESPACE_ID::Metadata Capabilities_SimpleExtension::GetMetadata() const { @@ -424,13 +431,16 @@ class Capabilities::_Internal { public: }; -Capabilities::Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Capabilities::Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), substrait_versions_(arena), advanced_extension_type_urls_(arena), simple_extensions_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Capabilities) } Capabilities::Capabilities(const Capabilities& from) @@ -442,17 +452,18 @@ Capabilities::Capabilities(const Capabilities& from) // @@protoc_insertion_point(copy_constructor:substrait.Capabilities) } -void Capabilities::SharedCtor() { +inline void Capabilities::SharedCtor() { } Capabilities::~Capabilities() { // @@protoc_insertion_point(destructor:substrait.Capabilities) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Capabilities::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Capabilities::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Capabilities::ArenaDtor(void* object) { @@ -467,7 +478,7 @@ void Capabilities::SetCachedSize(int size) const { void Capabilities::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Capabilities) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -480,12 +491,12 @@ void Capabilities::Clear() { const char* Capabilities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated string substrait_versions = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -495,11 +506,12 @@ const char* Capabilities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated string advanced_extension_type_urls = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -509,11 +521,12 @@ const char* Capabilities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -521,35 +534,36 @@ const char* Capabilities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Capabilities::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Capabilities::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Capabilities) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated string substrait_versions = 1; @@ -592,7 +606,7 @@ size_t Capabilities::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Capabilities) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -619,47 +633,32 @@ size_t Capabilities::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Capabilities::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Capabilities) - GOOGLE_DCHECK_NE(&from, this); - const Capabilities* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Capabilities) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Capabilities) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Capabilities::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Capabilities::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Capabilities::GetClassData() const { return &_class_data_; } + +void Capabilities::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Capabilities::MergeFrom(const Capabilities& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Capabilities) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; substrait_versions_.MergeFrom(from.substrait_versions_); advanced_extension_type_urls_.MergeFrom(from.advanced_extension_type_urls_); simple_extensions_.MergeFrom(from.simple_extensions_); -} - -void Capabilities::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Capabilities) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Capabilities::CopyFrom(const Capabilities& from) { @@ -675,7 +674,7 @@ bool Capabilities::IsInitialized() const { void Capabilities::InternalSwap(Capabilities* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); substrait_versions_.InternalSwap(&other->substrait_versions_); advanced_extension_type_urls_.InternalSwap(&other->advanced_extension_type_urls_); simple_extensions_.InternalSwap(&other->simple_extensions_); diff --git a/cpp/src/generated/substrait/capabilities.pb.h b/cpp/src/generated/substrait/capabilities.pb.h index 1bad72cf967..1ac303703ff 100644 --- a/cpp/src/generated/substrait/capabilities.pb.h +++ b/cpp/src/generated/substrait/capabilities.pb.h @@ -8,12 +8,12 @@ #include #include -#if PROTOBUF_VERSION < 3016000 +#if PROTOBUF_VERSION < 3019000 #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 3016000 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019003 < 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. @@ -50,7 +50,7 @@ struct TableStruct_substrait_2fcapabilities_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; + static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fcapabilities_2eproto; namespace substrait { @@ -69,7 +69,7 @@ namespace substrait { // =================================================================== -class Capabilities_SimpleExtension PROTOBUF_FINAL : +class Capabilities_SimpleExtension final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Capabilities.SimpleExtension) */ { public: inline Capabilities_SimpleExtension() : Capabilities_SimpleExtension(nullptr) {} @@ -87,8 +87,13 @@ class Capabilities_SimpleExtension PROTOBUF_FINAL : return *this; } inline Capabilities_SimpleExtension& operator=(Capabilities_SimpleExtension&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -119,7 +124,12 @@ class Capabilities_SimpleExtension PROTOBUF_FINAL : } inline void Swap(Capabilities_SimpleExtension* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -127,48 +137,53 @@ class Capabilities_SimpleExtension PROTOBUF_FINAL : } void UnsafeArenaSwap(Capabilities_SimpleExtension* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Capabilities_SimpleExtension* New() const final { - return CreateMaybeMessage(nullptr); - } - - Capabilities_SimpleExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Capabilities_SimpleExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Capabilities_SimpleExtension& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Capabilities_SimpleExtension& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Capabilities_SimpleExtension* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Capabilities.SimpleExtension"; } protected: - explicit Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -259,11 +274,11 @@ class Capabilities_SimpleExtension PROTOBUF_FINAL : template void set_uri(ArgT0&& arg0, ArgT... args); std::string* mutable_uri(); - std::string* release_uri(); + PROTOBUF_NODISCARD std::string* release_uri(); void set_allocated_uri(std::string* uri); private: const std::string& _internal_uri() const; - void _internal_set_uri(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value); std::string* _internal_mutable_uri(); public: @@ -283,7 +298,7 @@ class Capabilities_SimpleExtension PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Capabilities PROTOBUF_FINAL : +class Capabilities final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Capabilities) */ { public: inline Capabilities() : Capabilities(nullptr) {} @@ -301,8 +316,13 @@ class Capabilities PROTOBUF_FINAL : return *this; } inline Capabilities& operator=(Capabilities&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -333,7 +353,12 @@ class Capabilities PROTOBUF_FINAL : } inline void Swap(Capabilities* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -341,48 +366,53 @@ class Capabilities PROTOBUF_FINAL : } void UnsafeArenaSwap(Capabilities* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Capabilities* New() const final { - return CreateMaybeMessage(nullptr); - } - - Capabilities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Capabilities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Capabilities& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Capabilities& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Capabilities* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Capabilities"; } protected: - explicit Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -495,30 +525,31 @@ inline const std::string& Capabilities_SimpleExtension::uri() const { return _internal_uri(); } template -PROTOBUF_ALWAYS_INLINE -inline void Capabilities_SimpleExtension::set_uri(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void Capabilities_SimpleExtension::set_uri(ArgT0&& arg0, ArgT... args) { - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.uri) } inline std::string* Capabilities_SimpleExtension::mutable_uri() { + std::string* _s = _internal_mutable_uri(); // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.uri) - return _internal_mutable_uri(); + return _s; } inline const std::string& Capabilities_SimpleExtension::_internal_uri() const { return uri_.Get(); } inline void Capabilities_SimpleExtension::_internal_set_uri(const std::string& value) { - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Capabilities_SimpleExtension::_internal_mutable_uri() { - return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Capabilities_SimpleExtension::release_uri() { // @@protoc_insertion_point(field_release:substrait.Capabilities.SimpleExtension.uri) - return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void Capabilities_SimpleExtension::set_allocated_uri(std::string* uri) { if (uri != nullptr) { @@ -527,7 +558,12 @@ inline void Capabilities_SimpleExtension::set_allocated_uri(std::string* uri) { } uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (uri_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.Capabilities.SimpleExtension.uri) } @@ -542,8 +578,9 @@ inline void Capabilities_SimpleExtension::clear_function_keys() { function_keys_.Clear(); } inline std::string* Capabilities_SimpleExtension::add_function_keys() { + std::string* _s = _internal_add_function_keys(); // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.function_keys) - return _internal_add_function_keys(); + return _s; } inline const std::string& Capabilities_SimpleExtension::_internal_function_keys(int index) const { return function_keys_.Get(index); @@ -557,12 +594,12 @@ inline std::string* Capabilities_SimpleExtension::mutable_function_keys(int inde return function_keys_.Mutable(index); } inline void Capabilities_SimpleExtension::set_function_keys(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.function_keys) function_keys_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.function_keys) } inline void Capabilities_SimpleExtension::set_function_keys(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.function_keys) function_keys_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.function_keys) } inline void Capabilities_SimpleExtension::set_function_keys(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -616,8 +653,9 @@ inline void Capabilities_SimpleExtension::clear_type_keys() { type_keys_.Clear(); } inline std::string* Capabilities_SimpleExtension::add_type_keys() { + std::string* _s = _internal_add_type_keys(); // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.type_keys) - return _internal_add_type_keys(); + return _s; } inline const std::string& Capabilities_SimpleExtension::_internal_type_keys(int index) const { return type_keys_.Get(index); @@ -631,12 +669,12 @@ inline std::string* Capabilities_SimpleExtension::mutable_type_keys(int index) { return type_keys_.Mutable(index); } inline void Capabilities_SimpleExtension::set_type_keys(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_keys) type_keys_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_keys) } inline void Capabilities_SimpleExtension::set_type_keys(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_keys) type_keys_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_keys) } inline void Capabilities_SimpleExtension::set_type_keys(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -690,8 +728,9 @@ inline void Capabilities_SimpleExtension::clear_type_variation_keys() { type_variation_keys_.Clear(); } inline std::string* Capabilities_SimpleExtension::add_type_variation_keys() { + std::string* _s = _internal_add_type_variation_keys(); // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.type_variation_keys) - return _internal_add_type_variation_keys(); + return _s; } inline const std::string& Capabilities_SimpleExtension::_internal_type_variation_keys(int index) const { return type_variation_keys_.Get(index); @@ -705,12 +744,12 @@ inline std::string* Capabilities_SimpleExtension::mutable_type_variation_keys(in return type_variation_keys_.Mutable(index); } inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_variation_keys) type_variation_keys_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_variation_keys) } inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_variation_keys) type_variation_keys_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_variation_keys) } inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -768,8 +807,9 @@ inline void Capabilities::clear_substrait_versions() { substrait_versions_.Clear(); } inline std::string* Capabilities::add_substrait_versions() { + std::string* _s = _internal_add_substrait_versions(); // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.substrait_versions) - return _internal_add_substrait_versions(); + return _s; } inline const std::string& Capabilities::_internal_substrait_versions(int index) const { return substrait_versions_.Get(index); @@ -783,12 +823,12 @@ inline std::string* Capabilities::mutable_substrait_versions(int index) { return substrait_versions_.Mutable(index); } inline void Capabilities::set_substrait_versions(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.Capabilities.substrait_versions) substrait_versions_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.Capabilities.substrait_versions) } inline void Capabilities::set_substrait_versions(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.Capabilities.substrait_versions) substrait_versions_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.Capabilities.substrait_versions) } inline void Capabilities::set_substrait_versions(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -842,8 +882,9 @@ inline void Capabilities::clear_advanced_extension_type_urls() { advanced_extension_type_urls_.Clear(); } inline std::string* Capabilities::add_advanced_extension_type_urls() { + std::string* _s = _internal_add_advanced_extension_type_urls(); // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.advanced_extension_type_urls) - return _internal_add_advanced_extension_type_urls(); + return _s; } inline const std::string& Capabilities::_internal_advanced_extension_type_urls(int index) const { return advanced_extension_type_urls_.Get(index); @@ -857,12 +898,12 @@ inline std::string* Capabilities::mutable_advanced_extension_type_urls(int index return advanced_extension_type_urls_.Mutable(index); } inline void Capabilities::set_advanced_extension_type_urls(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.Capabilities.advanced_extension_type_urls) advanced_extension_type_urls_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.Capabilities.advanced_extension_type_urls) } inline void Capabilities::set_advanced_extension_type_urls(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.Capabilities.advanced_extension_type_urls) advanced_extension_type_urls_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.Capabilities.advanced_extension_type_urls) } inline void Capabilities::set_advanced_extension_type_urls(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -935,8 +976,9 @@ inline ::substrait::Capabilities_SimpleExtension* Capabilities::_internal_add_si return simple_extensions_.Add(); } inline ::substrait::Capabilities_SimpleExtension* Capabilities::add_simple_extensions() { + ::substrait::Capabilities_SimpleExtension* _add = _internal_add_simple_extensions(); // @@protoc_insertion_point(field_add:substrait.Capabilities.simple_extensions) - return _internal_add_simple_extensions(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >& Capabilities::simple_extensions() const { diff --git a/cpp/src/generated/substrait/expression.pb.cc b/cpp/src/generated/substrait/expression.pb.cc index 8ab2069b7a3..c58095ef801 100644 --- a/cpp/src/generated/substrait/expression.pb.cc +++ b/cpp/src/generated/substrait/expression.pb.cc @@ -171,7 +171,7 @@ struct Expression_ScalarFunctionDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ScalarFunctionDefaultTypeInternal _Expression_ScalarFunction_default_instance_; constexpr Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : offset_(PROTOBUF_LONGLONG(0)){} + : offset_(int64_t{0}){} struct Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal { constexpr Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -183,7 +183,7 @@ struct Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal _Expression_WindowFunction_Bound_Preceding_default_instance_; constexpr Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : offset_(PROTOBUF_LONGLONG(0)){} + : offset_(int64_t{0}){} struct Expression_WindowFunction_Bound_FollowingDefaultTypeInternal { constexpr Expression_WindowFunction_Bound_FollowingDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -648,17 +648,19 @@ static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fexpress static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2fexpression_2eproto[2]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fexpression_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const uint32_t TableStruct_substrait_2fexpression_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum_Empty, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, enum_kind_), @@ -667,6 +669,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, value_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, length_), ~0u, // no _has_bits_ @@ -674,6 +677,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, value_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, precision_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, scale_), @@ -682,6 +686,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, key_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, value_), ~0u, // no _has_bits_ @@ -689,12 +694,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map, key_values_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, years_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, months_), ~0u, // no _has_bits_ @@ -702,6 +709,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, days_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, seconds_), ~0u, // no _has_bits_ @@ -709,18 +717,21 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Struct, fields_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_List, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_List, values_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -754,6 +765,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, function_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, args_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, output_type_), @@ -762,28 +774,33 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Preceding, offset_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Following, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Following, offset_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_CurrentRow, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Unbounded, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -794,6 +811,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, function_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, partitions_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, sorts_), @@ -807,6 +825,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, if__), PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, then_), ~0u, // no _has_bits_ @@ -814,6 +833,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, ifs_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, else__), ~0u, // no _has_bits_ @@ -821,6 +841,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, type_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, input_), ~0u, // no _has_bits_ @@ -828,6 +849,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, if__), PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, then_), ~0u, // no _has_bits_ @@ -835,6 +857,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, ifs_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, else__), ~0u, // no _has_bits_ @@ -842,6 +865,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, value_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, options_), ~0u, // no _has_bits_ @@ -849,12 +873,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList_Record, fields_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, value_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, options_), ~0u, // no _has_bits_ @@ -862,6 +888,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, function_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, prerequisite_), ~0u, // no _has_bits_ @@ -869,6 +896,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, script_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, prerequisite_), ~0u, // no _has_bits_ @@ -876,6 +904,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, arguments_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, output_type_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -886,6 +915,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, map_key_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, child_), ~0u, // no _has_bits_ @@ -893,6 +923,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, field_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, child_), ~0u, // no _has_bits_ @@ -900,6 +931,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, offset_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, child_), ~0u, // no _has_bits_ @@ -907,6 +939,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -916,6 +949,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -925,12 +959,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructSelect, struct_items_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, field_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, child_), ~0u, // no _has_bits_ @@ -938,12 +974,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, field_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, start_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_), ~0u, // no _has_bits_ @@ -951,6 +989,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, type_), @@ -959,6 +998,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, selection_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, child_), ~0u, // no _has_bits_ @@ -966,18 +1006,21 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKey, map_key_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, map_key_expression_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, child_), @@ -987,6 +1030,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, select_), PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, maintain_singular_struct_), ~0u, // no _has_bits_ @@ -994,11 +1038,13 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -1010,6 +1056,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Expression, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -1026,6 +1073,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::SortField, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::SortField, expr_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -1035,6 +1083,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, function_reference_), PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, args_), PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, sorts_), @@ -1042,55 +1091,55 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fexpression_2eproto PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, output_type_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::substrait::Expression_Enum_Empty)}, - { 5, -1, sizeof(::substrait::Expression_Enum)}, - { 13, -1, sizeof(::substrait::Expression_Literal_VarChar)}, - { 20, -1, sizeof(::substrait::Expression_Literal_Decimal)}, - { 28, -1, sizeof(::substrait::Expression_Literal_Map_KeyValue)}, - { 35, -1, sizeof(::substrait::Expression_Literal_Map)}, - { 41, -1, sizeof(::substrait::Expression_Literal_IntervalYearToMonth)}, - { 48, -1, sizeof(::substrait::Expression_Literal_IntervalDayToSecond)}, - { 55, -1, sizeof(::substrait::Expression_Literal_Struct)}, - { 61, -1, sizeof(::substrait::Expression_Literal_List)}, - { 67, -1, sizeof(::substrait::Expression_Literal)}, - { 100, -1, sizeof(::substrait::Expression_ScalarFunction)}, - { 108, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Preceding)}, - { 114, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Following)}, - { 120, -1, sizeof(::substrait::Expression_WindowFunction_Bound_CurrentRow)}, - { 125, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Unbounded)}, - { 130, -1, sizeof(::substrait::Expression_WindowFunction_Bound)}, - { 140, -1, sizeof(::substrait::Expression_WindowFunction)}, - { 153, -1, sizeof(::substrait::Expression_IfThen_IfClause)}, - { 160, -1, sizeof(::substrait::Expression_IfThen)}, - { 167, -1, sizeof(::substrait::Expression_Cast)}, - { 174, -1, sizeof(::substrait::Expression_SwitchExpression_IfValue)}, - { 181, -1, sizeof(::substrait::Expression_SwitchExpression)}, - { 188, -1, sizeof(::substrait::Expression_SingularOrList)}, - { 195, -1, sizeof(::substrait::Expression_MultiOrList_Record)}, - { 201, -1, sizeof(::substrait::Expression_MultiOrList)}, - { 208, -1, sizeof(::substrait::Expression_EmbeddedFunction_PythonPickleFunction)}, - { 215, -1, sizeof(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction)}, - { 222, -1, sizeof(::substrait::Expression_EmbeddedFunction)}, - { 232, -1, sizeof(::substrait::Expression_ReferenceSegment_MapKey)}, - { 239, -1, sizeof(::substrait::Expression_ReferenceSegment_StructField)}, - { 246, -1, sizeof(::substrait::Expression_ReferenceSegment_ListElement)}, - { 253, -1, sizeof(::substrait::Expression_ReferenceSegment)}, - { 262, -1, sizeof(::substrait::Expression_MaskExpression_Select)}, - { 271, -1, sizeof(::substrait::Expression_MaskExpression_StructSelect)}, - { 277, -1, sizeof(::substrait::Expression_MaskExpression_StructItem)}, - { 284, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement)}, - { 290, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice)}, - { 297, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem)}, - { 305, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect)}, - { 312, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKey)}, - { 318, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression)}, - { 324, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect)}, - { 333, -1, sizeof(::substrait::Expression_MaskExpression)}, - { 340, -1, sizeof(::substrait::Expression_FieldReference_RootReference)}, - { 345, -1, sizeof(::substrait::Expression_FieldReference)}, - { 356, -1, sizeof(::substrait::Expression)}, - { 372, -1, sizeof(::substrait::SortField)}, - { 381, -1, sizeof(::substrait::AggregateFunction)}, + { 0, -1, -1, sizeof(::substrait::Expression_Enum_Empty)}, + { 6, -1, -1, sizeof(::substrait::Expression_Enum)}, + { 15, -1, -1, sizeof(::substrait::Expression_Literal_VarChar)}, + { 23, -1, -1, sizeof(::substrait::Expression_Literal_Decimal)}, + { 32, -1, -1, sizeof(::substrait::Expression_Literal_Map_KeyValue)}, + { 40, -1, -1, sizeof(::substrait::Expression_Literal_Map)}, + { 47, -1, -1, sizeof(::substrait::Expression_Literal_IntervalYearToMonth)}, + { 55, -1, -1, sizeof(::substrait::Expression_Literal_IntervalDayToSecond)}, + { 63, -1, -1, sizeof(::substrait::Expression_Literal_Struct)}, + { 70, -1, -1, sizeof(::substrait::Expression_Literal_List)}, + { 77, -1, -1, sizeof(::substrait::Expression_Literal)}, + { 111, -1, -1, sizeof(::substrait::Expression_ScalarFunction)}, + { 120, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Preceding)}, + { 127, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Following)}, + { 134, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_CurrentRow)}, + { 140, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Unbounded)}, + { 146, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound)}, + { 157, -1, -1, sizeof(::substrait::Expression_WindowFunction)}, + { 171, -1, -1, sizeof(::substrait::Expression_IfThen_IfClause)}, + { 179, -1, -1, sizeof(::substrait::Expression_IfThen)}, + { 187, -1, -1, sizeof(::substrait::Expression_Cast)}, + { 195, -1, -1, sizeof(::substrait::Expression_SwitchExpression_IfValue)}, + { 203, -1, -1, sizeof(::substrait::Expression_SwitchExpression)}, + { 211, -1, -1, sizeof(::substrait::Expression_SingularOrList)}, + { 219, -1, -1, sizeof(::substrait::Expression_MultiOrList_Record)}, + { 226, -1, -1, sizeof(::substrait::Expression_MultiOrList)}, + { 234, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction_PythonPickleFunction)}, + { 242, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction)}, + { 250, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction)}, + { 261, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_MapKey)}, + { 269, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_StructField)}, + { 277, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_ListElement)}, + { 285, -1, -1, sizeof(::substrait::Expression_ReferenceSegment)}, + { 295, -1, -1, sizeof(::substrait::Expression_MaskExpression_Select)}, + { 305, -1, -1, sizeof(::substrait::Expression_MaskExpression_StructSelect)}, + { 312, -1, -1, sizeof(::substrait::Expression_MaskExpression_StructItem)}, + { 320, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement)}, + { 327, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice)}, + { 335, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem)}, + { 344, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect)}, + { 352, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKey)}, + { 359, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression)}, + { 366, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect)}, + { 376, -1, -1, sizeof(::substrait::Expression_MaskExpression)}, + { 384, -1, -1, sizeof(::substrait::Expression_FieldReference_RootReference)}, + { 390, -1, -1, sizeof(::substrait::Expression_FieldReference)}, + { 402, -1, -1, sizeof(::substrait::Expression)}, + { 419, -1, -1, sizeof(::substrait::SortField)}, + { 429, -1, -1, sizeof(::substrait::AggregateFunction)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -1363,7 +1412,7 @@ bool SortField_SortDirection_IsValid(int value) { } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr SortField_SortDirection SortField::SORT_DIRECTION_UNSPECIFIED; constexpr SortField_SortDirection SortField::SORT_DIRECTION_ASC_NULLS_FIRST; constexpr SortField_SortDirection SortField::SORT_DIRECTION_ASC_NULLS_LAST; @@ -1373,7 +1422,7 @@ constexpr SortField_SortDirection SortField::SORT_DIRECTION_CLUSTERED; constexpr SortField_SortDirection SortField::SortDirection_MIN; constexpr SortField_SortDirection SortField::SortDirection_MAX; constexpr int SortField::SortDirection_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggregationPhase_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2fexpression_2eproto); return file_level_enum_descriptors_substrait_2fexpression_2eproto[1]; @@ -1398,151 +1447,32 @@ class Expression_Enum_Empty::_Internal { public: }; -Expression_Enum_Empty::Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); +Expression_Enum_Empty::Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { // @@protoc_insertion_point(arena_constructor:substrait.Expression.Enum.Empty) } Expression_Enum_Empty::Expression_Enum_Empty(const Expression_Enum_Empty& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:substrait.Expression.Enum.Empty) } -void Expression_Enum_Empty::SharedCtor() { -} - -Expression_Enum_Empty::~Expression_Enum_Empty() { - // @@protoc_insertion_point(destructor:substrait.Expression.Enum.Empty) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Expression_Enum_Empty::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void Expression_Enum_Empty::ArenaDtor(void* object) { - Expression_Enum_Empty* _this = reinterpret_cast< Expression_Enum_Empty* >(object); - (void)_this; -} -void Expression_Enum_Empty::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Enum_Empty::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Enum_Empty::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Enum.Empty) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Enum_Empty::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Enum_Empty::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Enum.Empty) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Enum.Empty) - return target; -} -size_t Expression_Enum_Empty::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Enum.Empty) - size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} -void Expression_Enum_Empty::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Enum.Empty) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Enum_Empty* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Enum.Empty) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Enum.Empty) - MergeFrom(*source); - } -} +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Enum_Empty::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Enum_Empty::GetClassData() const { return &_class_data_; } -void Expression_Enum_Empty::MergeFrom(const Expression_Enum_Empty& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Enum.Empty) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; -} -void Expression_Enum_Empty::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Enum.Empty) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -void Expression_Enum_Empty::CopyFrom(const Expression_Enum_Empty& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Enum.Empty) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -bool Expression_Enum_Empty::IsInitialized() const { - return true; -} -void Expression_Enum_Empty::InternalSwap(Expression_Enum_Empty* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); -} ::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum_Empty::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( @@ -1562,11 +1492,11 @@ Expression_Enum::_Internal::unspecified(const Expression_Enum* msg) { return *msg->enum_kind_.unspecified_; } void Expression_Enum::set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_enum_kind(); if (unspecified) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(unspecified); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Enum_Empty>::GetOwningArena(unspecified); if (message_arena != submessage_arena) { unspecified = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, unspecified, submessage_arena); @@ -1576,10 +1506,13 @@ void Expression_Enum::set_allocated_unspecified(::substrait::Expression_Enum_Emp } // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Enum.unspecified) } -Expression_Enum::Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_Enum::Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Enum) } Expression_Enum::Expression_Enum(const Expression_Enum& from) @@ -1602,18 +1535,19 @@ Expression_Enum::Expression_Enum(const Expression_Enum& from) // @@protoc_insertion_point(copy_constructor:substrait.Expression.Enum) } -void Expression_Enum::SharedCtor() { +inline void Expression_Enum::SharedCtor() { clear_has_enum_kind(); } Expression_Enum::~Expression_Enum() { // @@protoc_insertion_point(destructor:substrait.Expression.Enum) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Enum::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Enum::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_enum_kind()) { clear_enum_kind(); } @@ -1633,11 +1567,11 @@ void Expression_Enum::clear_enum_kind() { // @@protoc_insertion_point(one_of_clear_start:substrait.Expression.Enum) switch (enum_kind_case()) { case kSpecified: { - enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kUnspecified: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete enum_kind_.unspecified_; } break; @@ -1652,7 +1586,7 @@ void Expression_Enum::clear_enum_kind() { void Expression_Enum::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Enum) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1663,52 +1597,54 @@ void Expression_Enum::Clear() { const char* Expression_Enum::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string specified = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_specified(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Enum.specified")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Enum.Empty unspecified = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_unspecified(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Enum::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Enum::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Enum) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string specified = 1; @@ -1741,7 +1677,7 @@ size_t Expression_Enum::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Enum) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1764,35 +1700,26 @@ size_t Expression_Enum::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Enum::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Enum) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Enum* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Enum) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Enum) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Enum::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Enum::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Enum::GetClassData() const { return &_class_data_; } + +void Expression_Enum::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Enum::MergeFrom(const Expression_Enum& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Enum) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.enum_kind_case()) { @@ -1808,13 +1735,7 @@ void Expression_Enum::MergeFrom(const Expression_Enum& from) { break; } } -} - -void Expression_Enum::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Enum) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Enum::CopyFrom(const Expression_Enum& from) { @@ -1830,7 +1751,7 @@ bool Expression_Enum::IsInitialized() const { void Expression_Enum::InternalSwap(Expression_Enum* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(enum_kind_, other->enum_kind_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -1847,37 +1768,47 @@ class Expression_Literal_VarChar::_Internal { public: }; -Expression_Literal_VarChar::Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_Literal_VarChar::Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.VarChar) } Expression_Literal_VarChar::Expression_Literal_VarChar(const Expression_Literal_VarChar& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_value().empty()) { value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), - GetArena()); + GetArenaForAllocation()); } length_ = from.length_; // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.VarChar) } -void Expression_Literal_VarChar::SharedCtor() { +inline void Expression_Literal_VarChar::SharedCtor() { value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING length_ = 0u; } Expression_Literal_VarChar::~Expression_Literal_VarChar() { // @@protoc_insertion_point(destructor:substrait.Expression.Literal.VarChar) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_VarChar::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Literal_VarChar::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -1893,7 +1824,7 @@ void Expression_Literal_VarChar::SetCachedSize(int size) const { void Expression_Literal_VarChar::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.VarChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1905,56 +1836,58 @@ void Expression_Literal_VarChar::Clear() { const char* Expression_Literal_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_value(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.VarChar.value")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 length = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_VarChar::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Literal_VarChar::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.VarChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string value = 1; - if (this->value().size() > 0) { + if (!this->_internal_value().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_value().data(), static_cast(this->_internal_value().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -1964,7 +1897,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_VarChar::_InternalSerialize( } // uint32 length = 2; - if (this->length() != 0) { + if (this->_internal_length() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_length(), target); } @@ -1981,68 +1914,51 @@ size_t Expression_Literal_VarChar::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.VarChar) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string value = 1; - if (this->value().size() > 0) { + if (!this->_internal_value().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_value()); } // uint32 length = 2; - if (this->length() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_length()); + if (this->_internal_length() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_length()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Literal_VarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.VarChar) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_VarChar* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.VarChar) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.VarChar) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_VarChar::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Literal_VarChar::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_VarChar::GetClassData() const { return &_class_data_; } + +void Expression_Literal_VarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Literal_VarChar::MergeFrom(const Expression_Literal_VarChar& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.VarChar) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.value().size() > 0) { + if (!from._internal_value().empty()) { _internal_set_value(from._internal_value()); } - if (from.length() != 0) { + if (from._internal_length() != 0) { _internal_set_length(from._internal_length()); } -} - -void Expression_Literal_VarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.VarChar) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Literal_VarChar::CopyFrom(const Expression_Literal_VarChar& from) { @@ -2058,8 +1974,14 @@ bool Expression_Literal_VarChar::IsInitialized() const { void Expression_Literal_VarChar::InternalSwap(Expression_Literal_VarChar* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &value_, lhs_arena, + &other->value_, rhs_arena + ); swap(length_, other->length_); } @@ -2075,19 +1997,25 @@ class Expression_Literal_Decimal::_Internal { public: }; -Expression_Literal_Decimal::Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_Literal_Decimal::Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Decimal) } Expression_Literal_Decimal::Expression_Literal_Decimal(const Expression_Literal_Decimal& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_value().empty()) { value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), - GetArena()); + GetArenaForAllocation()); } ::memcpy(&precision_, &from.precision_, static_cast(reinterpret_cast(&scale_) - @@ -2095,8 +2023,11 @@ Expression_Literal_Decimal::Expression_Literal_Decimal(const Expression_Literal_ // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Decimal) } -void Expression_Literal_Decimal::SharedCtor() { +inline void Expression_Literal_Decimal::SharedCtor() { value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&precision_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&scale_) - @@ -2105,12 +2036,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_Literal_Decimal::~Expression_Literal_Decimal() { // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Decimal) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_Decimal::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Literal_Decimal::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -2126,7 +2058,7 @@ void Expression_Literal_Decimal::SetCachedSize(int size) const { void Expression_Literal_Decimal::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Decimal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2140,74 +2072,77 @@ void Expression_Literal_Decimal::Clear() { const char* Expression_Literal_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // bytes value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_value(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 precision = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 scale = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Decimal::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Literal_Decimal::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Decimal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // bytes value = 1; - if (this->value().size() > 0) { + if (!this->_internal_value().empty()) { target = stream->WriteBytesMaybeAliased( 1, this->_internal_value(), target); } // int32 precision = 2; - if (this->precision() != 0) { + if (this->_internal_precision() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_precision(), target); } // int32 scale = 3; - if (this->scale() != 0) { + if (this->_internal_scale() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_scale(), target); } @@ -2224,78 +2159,59 @@ size_t Expression_Literal_Decimal::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Decimal) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bytes value = 1; - if (this->value().size() > 0) { + if (!this->_internal_value().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( this->_internal_value()); } // int32 precision = 2; - if (this->precision() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_precision()); + if (this->_internal_precision() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_precision()); } // int32 scale = 3; - if (this->scale() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_scale()); + if (this->_internal_scale() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_scale()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Literal_Decimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.Decimal) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_Decimal* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.Decimal) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.Decimal) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Decimal::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Literal_Decimal::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Decimal::GetClassData() const { return &_class_data_; } + +void Expression_Literal_Decimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Literal_Decimal::MergeFrom(const Expression_Literal_Decimal& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Decimal) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.value().size() > 0) { + if (!from._internal_value().empty()) { _internal_set_value(from._internal_value()); } - if (from.precision() != 0) { + if (from._internal_precision() != 0) { _internal_set_precision(from._internal_precision()); } - if (from.scale() != 0) { + if (from._internal_scale() != 0) { _internal_set_scale(from._internal_scale()); } -} - -void Expression_Literal_Decimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.Decimal) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Literal_Decimal::CopyFrom(const Expression_Literal_Decimal& from) { @@ -2311,8 +2227,14 @@ bool Expression_Literal_Decimal::IsInitialized() const { void Expression_Literal_Decimal::InternalSwap(Expression_Literal_Decimal* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - value_.Swap(&other->value_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &value_, lhs_arena, + &other->value_, rhs_arena + ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_Literal_Decimal, scale_) + sizeof(Expression_Literal_Decimal::scale_) @@ -2343,10 +2265,13 @@ const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_Internal::value(const Expression_Literal_Map_KeyValue* msg) { return *msg->value_; } -Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Map.KeyValue) } Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from) @@ -2365,7 +2290,7 @@ Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(const Expressio // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Map.KeyValue) } -void Expression_Literal_Map_KeyValue::SharedCtor() { +inline void Expression_Literal_Map_KeyValue::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&key_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&value_) - @@ -2374,12 +2299,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_Literal_Map_KeyValue::~Expression_Literal_Map_KeyValue() { // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Map.KeyValue) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_Map_KeyValue::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Literal_Map_KeyValue::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete key_; if (this != internal_default_instance()) delete value_; } @@ -2396,15 +2322,15 @@ void Expression_Literal_Map_KeyValue::SetCachedSize(int size) const { void Expression_Literal_Map_KeyValue::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Map.KeyValue) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && key_ != nullptr) { + if (GetArenaForAllocation() == nullptr && key_ != nullptr) { delete key_; } key_ = nullptr; - if (GetArena() == nullptr && value_ != nullptr) { + if (GetArenaForAllocation() == nullptr && value_ != nullptr) { delete value_; } value_ = nullptr; @@ -2414,54 +2340,56 @@ void Expression_Literal_Map_KeyValue::Clear() { const char* Expression_Literal_Map_KeyValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.Literal key = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Literal value = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map_KeyValue::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Literal_Map_KeyValue::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Map.KeyValue) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.Literal key = 1; - if (this->has_key()) { + if (this->_internal_has_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2469,7 +2397,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map_KeyValue::_InternalSerial } // .substrait.Expression.Literal value = 2; - if (this->has_value()) { + if (this->_internal_has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2488,68 +2416,53 @@ size_t Expression_Literal_Map_KeyValue::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Map.KeyValue) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Expression.Literal key = 1; - if (this->has_key()) { + if (this->_internal_has_key()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *key_); } // .substrait.Expression.Literal value = 2; - if (this->has_value()) { + if (this->_internal_has_value()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *value_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Literal_Map_KeyValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.Map.KeyValue) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_Map_KeyValue* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.Map.KeyValue) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.Map.KeyValue) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Map_KeyValue::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Literal_Map_KeyValue::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Map_KeyValue::GetClassData() const { return &_class_data_; } + +void Expression_Literal_Map_KeyValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Literal_Map_KeyValue::MergeFrom(const Expression_Literal_Map_KeyValue& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Map.KeyValue) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_key()) { + if (from._internal_has_key()) { _internal_mutable_key()->::substrait::Expression_Literal::MergeFrom(from._internal_key()); } - if (from.has_value()) { + if (from._internal_has_value()) { _internal_mutable_value()->::substrait::Expression_Literal::MergeFrom(from._internal_value()); } -} - -void Expression_Literal_Map_KeyValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.Map.KeyValue) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Literal_Map_KeyValue::CopyFrom(const Expression_Literal_Map_KeyValue& from) { @@ -2565,7 +2478,7 @@ bool Expression_Literal_Map_KeyValue::IsInitialized() const { void Expression_Literal_Map_KeyValue::InternalSwap(Expression_Literal_Map_KeyValue* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, value_) + sizeof(Expression_Literal_Map_KeyValue::value_) @@ -2586,11 +2499,14 @@ class Expression_Literal_Map::_Internal { public: }; -Expression_Literal_Map::Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_Literal_Map::Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), key_values_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Map) } Expression_Literal_Map::Expression_Literal_Map(const Expression_Literal_Map& from) @@ -2600,17 +2516,18 @@ Expression_Literal_Map::Expression_Literal_Map(const Expression_Literal_Map& fro // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Map) } -void Expression_Literal_Map::SharedCtor() { +inline void Expression_Literal_Map::SharedCtor() { } Expression_Literal_Map::~Expression_Literal_Map() { // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Map) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_Map::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Literal_Map::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_Literal_Map::ArenaDtor(void* object) { @@ -2625,7 +2542,7 @@ void Expression_Literal_Map::SetCachedSize(int size) const { void Expression_Literal_Map::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Map) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2636,12 +2553,12 @@ void Expression_Literal_Map::Clear() { const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -2649,35 +2566,36 @@ const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_N CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Map::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Literal_Map::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Map) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; @@ -2700,7 +2618,7 @@ size_t Expression_Literal_Map::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Map) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2711,45 +2629,30 @@ size_t Expression_Literal_Map::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Literal_Map::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.Map) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_Map* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.Map) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.Map) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Map::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Literal_Map::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Map::GetClassData() const { return &_class_data_; } + +void Expression_Literal_Map::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Literal_Map::MergeFrom(const Expression_Literal_Map& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Map) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; key_values_.MergeFrom(from.key_values_); -} - -void Expression_Literal_Map::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.Map) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Literal_Map::CopyFrom(const Expression_Literal_Map& from) { @@ -2765,7 +2668,7 @@ bool Expression_Literal_Map::IsInitialized() const { void Expression_Literal_Map::InternalSwap(Expression_Literal_Map* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); key_values_.InternalSwap(&other->key_values_); } @@ -2781,10 +2684,13 @@ class Expression_Literal_IntervalYearToMonth::_Internal { public: }; -Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.IntervalYearToMonth) } Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from) @@ -2796,7 +2702,7 @@ Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(c // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalYearToMonth) } -void Expression_Literal_IntervalYearToMonth::SharedCtor() { +inline void Expression_Literal_IntervalYearToMonth::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&years_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&months_) - @@ -2805,12 +2711,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_Literal_IntervalYearToMonth::~Expression_Literal_IntervalYearToMonth() { // @@protoc_insertion_point(destructor:substrait.Expression.Literal.IntervalYearToMonth) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_IntervalYearToMonth::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Literal_IntervalYearToMonth::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_Literal_IntervalYearToMonth::ArenaDtor(void* object) { @@ -2825,7 +2732,7 @@ void Expression_Literal_IntervalYearToMonth::SetCachedSize(int size) const { void Expression_Literal_IntervalYearToMonth::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.IntervalYearToMonth) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2838,60 +2745,62 @@ void Expression_Literal_IntervalYearToMonth::Clear() { const char* Expression_Literal_IntervalYearToMonth::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 years = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - years_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + years_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 months = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - months_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + months_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalYearToMonth::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Literal_IntervalYearToMonth::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.IntervalYearToMonth) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 years = 1; - if (this->years() != 0) { + if (this->_internal_years() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_years(), target); } // int32 months = 2; - if (this->months() != 0) { + if (this->_internal_months() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_months(), target); } @@ -2908,68 +2817,49 @@ size_t Expression_Literal_IntervalYearToMonth::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.IntervalYearToMonth) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int32 years = 1; - if (this->years() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_years()); + if (this->_internal_years() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_years()); } // int32 months = 2; - if (this->months() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_months()); + if (this->_internal_months() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_months()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Literal_IntervalYearToMonth::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.IntervalYearToMonth) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_IntervalYearToMonth* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.IntervalYearToMonth) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.IntervalYearToMonth) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_IntervalYearToMonth::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Literal_IntervalYearToMonth::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_IntervalYearToMonth::GetClassData() const { return &_class_data_; } + +void Expression_Literal_IntervalYearToMonth::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Literal_IntervalYearToMonth::MergeFrom(const Expression_Literal_IntervalYearToMonth& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.IntervalYearToMonth) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.years() != 0) { + if (from._internal_years() != 0) { _internal_set_years(from._internal_years()); } - if (from.months() != 0) { + if (from._internal_months() != 0) { _internal_set_months(from._internal_months()); } -} - -void Expression_Literal_IntervalYearToMonth::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.IntervalYearToMonth) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Literal_IntervalYearToMonth::CopyFrom(const Expression_Literal_IntervalYearToMonth& from) { @@ -2985,7 +2875,7 @@ bool Expression_Literal_IntervalYearToMonth::IsInitialized() const { void Expression_Literal_IntervalYearToMonth::InternalSwap(Expression_Literal_IntervalYearToMonth* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, months_) + sizeof(Expression_Literal_IntervalYearToMonth::months_) @@ -3006,10 +2896,13 @@ class Expression_Literal_IntervalDayToSecond::_Internal { public: }; -Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.IntervalDayToSecond) } Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from) @@ -3021,7 +2914,7 @@ Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(c // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalDayToSecond) } -void Expression_Literal_IntervalDayToSecond::SharedCtor() { +inline void Expression_Literal_IntervalDayToSecond::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&days_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&seconds_) - @@ -3030,12 +2923,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_Literal_IntervalDayToSecond::~Expression_Literal_IntervalDayToSecond() { // @@protoc_insertion_point(destructor:substrait.Expression.Literal.IntervalDayToSecond) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_IntervalDayToSecond::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Literal_IntervalDayToSecond::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_Literal_IntervalDayToSecond::ArenaDtor(void* object) { @@ -3050,7 +2944,7 @@ void Expression_Literal_IntervalDayToSecond::SetCachedSize(int size) const { void Expression_Literal_IntervalDayToSecond::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.IntervalDayToSecond) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3063,60 +2957,62 @@ void Expression_Literal_IntervalDayToSecond::Clear() { const char* Expression_Literal_IntervalDayToSecond::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 days = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - days_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + days_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 seconds = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_IntervalDayToSecond::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Literal_IntervalDayToSecond::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.IntervalDayToSecond) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 days = 1; - if (this->days() != 0) { + if (this->_internal_days() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_days(), target); } // int32 seconds = 2; - if (this->seconds() != 0) { + if (this->_internal_seconds() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_seconds(), target); } @@ -3133,68 +3029,49 @@ size_t Expression_Literal_IntervalDayToSecond::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.IntervalDayToSecond) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int32 days = 1; - if (this->days() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_days()); + if (this->_internal_days() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_days()); } // int32 seconds = 2; - if (this->seconds() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_seconds()); + if (this->_internal_seconds() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_seconds()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Literal_IntervalDayToSecond::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.IntervalDayToSecond) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_IntervalDayToSecond* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.IntervalDayToSecond) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.IntervalDayToSecond) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_IntervalDayToSecond::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Literal_IntervalDayToSecond::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_IntervalDayToSecond::GetClassData() const { return &_class_data_; } + +void Expression_Literal_IntervalDayToSecond::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Literal_IntervalDayToSecond::MergeFrom(const Expression_Literal_IntervalDayToSecond& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.IntervalDayToSecond) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.days() != 0) { + if (from._internal_days() != 0) { _internal_set_days(from._internal_days()); } - if (from.seconds() != 0) { + if (from._internal_seconds() != 0) { _internal_set_seconds(from._internal_seconds()); } -} - -void Expression_Literal_IntervalDayToSecond::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.IntervalDayToSecond) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Literal_IntervalDayToSecond::CopyFrom(const Expression_Literal_IntervalDayToSecond& from) { @@ -3210,7 +3087,7 @@ bool Expression_Literal_IntervalDayToSecond::IsInitialized() const { void Expression_Literal_IntervalDayToSecond::InternalSwap(Expression_Literal_IntervalDayToSecond* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, seconds_) + sizeof(Expression_Literal_IntervalDayToSecond::seconds_) @@ -3231,11 +3108,14 @@ class Expression_Literal_Struct::_Internal { public: }; -Expression_Literal_Struct::Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_Literal_Struct::Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), fields_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Struct) } Expression_Literal_Struct::Expression_Literal_Struct(const Expression_Literal_Struct& from) @@ -3245,17 +3125,18 @@ Expression_Literal_Struct::Expression_Literal_Struct(const Expression_Literal_St // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Struct) } -void Expression_Literal_Struct::SharedCtor() { +inline void Expression_Literal_Struct::SharedCtor() { } Expression_Literal_Struct::~Expression_Literal_Struct() { // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Struct) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_Struct::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Literal_Struct::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_Literal_Struct::ArenaDtor(void* object) { @@ -3270,7 +3151,7 @@ void Expression_Literal_Struct::SetCachedSize(int size) const { void Expression_Literal_Struct::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Struct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3281,12 +3162,12 @@ void Expression_Literal_Struct::Clear() { const char* Expression_Literal_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression.Literal fields = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -3294,35 +3175,36 @@ const char* Expression_Literal_Struct::_InternalParse(const char* ptr, ::PROTOBU CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_Struct::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Literal_Struct::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Struct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression.Literal fields = 1; @@ -3345,7 +3227,7 @@ size_t Expression_Literal_Struct::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Struct) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3356,45 +3238,30 @@ size_t Expression_Literal_Struct::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Literal_Struct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.Struct) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_Struct* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.Struct) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.Struct) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Struct::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Literal_Struct::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Struct::GetClassData() const { return &_class_data_; } + +void Expression_Literal_Struct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Literal_Struct::MergeFrom(const Expression_Literal_Struct& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Struct) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; fields_.MergeFrom(from.fields_); -} - -void Expression_Literal_Struct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.Struct) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Literal_Struct::CopyFrom(const Expression_Literal_Struct& from) { @@ -3410,7 +3277,7 @@ bool Expression_Literal_Struct::IsInitialized() const { void Expression_Literal_Struct::InternalSwap(Expression_Literal_Struct* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); fields_.InternalSwap(&other->fields_); } @@ -3426,11 +3293,14 @@ class Expression_Literal_List::_Internal { public: }; -Expression_Literal_List::Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_Literal_List::Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), values_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.List) } Expression_Literal_List::Expression_Literal_List(const Expression_Literal_List& from) @@ -3440,17 +3310,18 @@ Expression_Literal_List::Expression_Literal_List(const Expression_Literal_List& // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.List) } -void Expression_Literal_List::SharedCtor() { +inline void Expression_Literal_List::SharedCtor() { } Expression_Literal_List::~Expression_Literal_List() { // @@protoc_insertion_point(destructor:substrait.Expression.Literal.List) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal_List::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Literal_List::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_Literal_List::ArenaDtor(void* object) { @@ -3465,7 +3336,7 @@ void Expression_Literal_List::SetCachedSize(int size) const { void Expression_Literal_List::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.List) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3476,12 +3347,12 @@ void Expression_Literal_List::Clear() { const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression.Literal values = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -3489,35 +3360,36 @@ const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_ CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal_List::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Literal_List::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.List) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression.Literal values = 1; @@ -3540,7 +3412,7 @@ size_t Expression_Literal_List::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.List) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3551,45 +3423,30 @@ size_t Expression_Literal_List::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Literal_List::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal.List) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal_List* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal.List) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal.List) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_List::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Literal_List::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_List::GetClassData() const { return &_class_data_; } + +void Expression_Literal_List::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Literal_List::MergeFrom(const Expression_Literal_List& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.List) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; values_.MergeFrom(from.values_); -} - -void Expression_Literal_List::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal.List) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Literal_List::CopyFrom(const Expression_Literal_List& from) { @@ -3605,7 +3462,7 @@ bool Expression_Literal_List::IsInitialized() const { void Expression_Literal_List::InternalSwap(Expression_Literal_List* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); values_.InternalSwap(&other->values_); } @@ -3672,11 +3529,11 @@ Expression_Literal::_Internal::empty_map(const Expression_Literal* msg) { return *msg->literal_type_.empty_map_; } void Expression_Literal::set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_literal_type(); if (interval_year_to_month) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_year_to_month); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_IntervalYearToMonth>::GetOwningArena(interval_year_to_month); if (message_arena != submessage_arena) { interval_year_to_month = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, interval_year_to_month, submessage_arena); @@ -3687,11 +3544,11 @@ void Expression_Literal::set_allocated_interval_year_to_month(::substrait::Expre // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.interval_year_to_month) } void Expression_Literal::set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_literal_type(); if (interval_day_to_second) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_day_to_second); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_IntervalDayToSecond>::GetOwningArena(interval_day_to_second); if (message_arena != submessage_arena) { interval_day_to_second = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, interval_day_to_second, submessage_arena); @@ -3702,11 +3559,11 @@ void Expression_Literal::set_allocated_interval_day_to_second(::substrait::Expre // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.interval_day_to_second) } void Expression_Literal::set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_literal_type(); if (var_char) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(var_char); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_VarChar>::GetOwningArena(var_char); if (message_arena != submessage_arena) { var_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, var_char, submessage_arena); @@ -3717,11 +3574,11 @@ void Expression_Literal::set_allocated_var_char(::substrait::Expression_Literal_ // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.var_char) } void Expression_Literal::set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_literal_type(); if (decimal) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(decimal); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Decimal>::GetOwningArena(decimal); if (message_arena != submessage_arena) { decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, decimal, submessage_arena); @@ -3732,11 +3589,11 @@ void Expression_Literal::set_allocated_decimal(::substrait::Expression_Literal_D // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.decimal) } void Expression_Literal::set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_literal_type(); if (struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Struct>::GetOwningArena(struct_); if (message_arena != submessage_arena) { struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, struct_, submessage_arena); @@ -3747,11 +3604,11 @@ void Expression_Literal::set_allocated_struct_(::substrait::Expression_Literal_S // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.struct) } void Expression_Literal::set_allocated_map(::substrait::Expression_Literal_Map* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_literal_type(); if (map) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Map>::GetOwningArena(map); if (message_arena != submessage_arena) { map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, map, submessage_arena); @@ -3762,11 +3619,13 @@ void Expression_Literal::set_allocated_map(::substrait::Expression_Literal_Map* // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.map) } void Expression_Literal::set_allocated_null(::substrait::Type* null) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_literal_type(); if (null) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(null)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(null)); if (message_arena != submessage_arena) { null = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, null, submessage_arena); @@ -3778,18 +3637,18 @@ void Expression_Literal::set_allocated_null(::substrait::Type* null) { } void Expression_Literal::clear_null() { if (_internal_has_null()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.null_; } clear_has_literal_type(); } } void Expression_Literal::set_allocated_list(::substrait::Expression_Literal_List* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_literal_type(); if (list) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_List>::GetOwningArena(list); if (message_arena != submessage_arena) { list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, list, submessage_arena); @@ -3800,11 +3659,13 @@ void Expression_Literal::set_allocated_list(::substrait::Expression_Literal_List // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.list) } void Expression_Literal::set_allocated_empty_list(::substrait::Type_List* empty_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_literal_type(); if (empty_list) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_list)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_list)); if (message_arena != submessage_arena) { empty_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, empty_list, submessage_arena); @@ -3816,18 +3677,20 @@ void Expression_Literal::set_allocated_empty_list(::substrait::Type_List* empty_ } void Expression_Literal::clear_empty_list() { if (_internal_has_empty_list()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.empty_list_; } clear_has_literal_type(); } } void Expression_Literal::set_allocated_empty_map(::substrait::Type_Map* empty_map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_literal_type(); if (empty_map) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_map)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_map)); if (message_arena != submessage_arena) { empty_map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, empty_map, submessage_arena); @@ -3839,16 +3702,19 @@ void Expression_Literal::set_allocated_empty_map(::substrait::Type_Map* empty_ma } void Expression_Literal::clear_empty_map() { if (_internal_has_empty_map()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.empty_map_; } clear_has_literal_type(); } } -Expression_Literal::Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_Literal::Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal) } Expression_Literal::Expression_Literal(const Expression_Literal& from) @@ -3968,19 +3834,20 @@ Expression_Literal::Expression_Literal(const Expression_Literal& from) // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal) } -void Expression_Literal::SharedCtor() { +inline void Expression_Literal::SharedCtor() { nullable_ = false; clear_has_literal_type(); } Expression_Literal::~Expression_Literal() { // @@protoc_insertion_point(destructor:substrait.Expression.Literal) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Literal::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Literal::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_literal_type()) { clear_literal_type(); } @@ -4028,11 +3895,11 @@ void Expression_Literal::clear_literal_type() { break; } case kString: { - literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kBinary: { - literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kTimestamp: { @@ -4048,45 +3915,45 @@ void Expression_Literal::clear_literal_type() { break; } case kIntervalYearToMonth: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.interval_year_to_month_; } break; } case kIntervalDayToSecond: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.interval_day_to_second_; } break; } case kFixedChar: { - literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kVarChar: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.var_char_; } break; } case kFixedBinary: { - literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kDecimal: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.decimal_; } break; } case kStruct: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.struct__; } break; } case kMap: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.map_; } break; @@ -4096,29 +3963,29 @@ void Expression_Literal::clear_literal_type() { break; } case kUuid: { - literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kNull: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.null_; } break; } case kList: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.list_; } break; } case kEmptyList: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.empty_list_; } break; } case kEmptyMap: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.empty_map_; } break; @@ -4133,7 +4000,7 @@ void Expression_Literal::clear_literal_type() { void Expression_Literal::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4145,232 +4012,259 @@ void Expression_Literal::Clear() { const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // bool boolean = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { _internal_set_boolean(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 i8 = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - _internal_set_i8(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + _internal_set_i8(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 i16 = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - _internal_set_i16(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _internal_set_i16(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 i32 = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { - _internal_set_i32(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + _internal_set_i32(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int64 i64 = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { _internal_set_i64(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // float fp32 = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 85)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 85)) { _internal_set_fp32(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(float); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // double fp64 = 11; case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 89)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 89)) { _internal_set_fp64(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); ptr += sizeof(double); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string string = 12; case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { auto str = _internal_mutable_string(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.string")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bytes binary = 13; case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { auto str = _internal_mutable_binary(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int64 timestamp = 14; case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 date = 16; case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 128)) { - _internal_set_date(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { + _internal_set_date(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int64 time = 17; case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { _internal_set_time(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_interval_year_to_month(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_interval_day_to_second(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string fixed_char = 21; case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { auto str = _internal_mutable_fixed_char(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.fixed_char")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Literal.VarChar var_char = 22; case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_var_char(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bytes fixed_binary = 23; case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { auto str = _internal_mutable_fixed_binary(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Literal.Decimal decimal = 24; case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Literal.Struct struct = 25; case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Literal.Map map = 26; case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 210)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int64 timestamp_tz = 27; case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 216)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 216)) { _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bytes uuid = 28; case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { auto str = _internal_mutable_uuid(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type null = 29; case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { ptr = ctx->ParseMessage(_internal_mutable_null(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Literal.List list = 30; case 30: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 242)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.List empty_list = 31; case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { ptr = ctx->ParseMessage(_internal_mutable_empty_list(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Map empty_map = 32; case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { ptr = ctx->ParseMessage(_internal_mutable_empty_map(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool nullable = 50; case 50: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { nullable_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Literal::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // bool boolean = 1; @@ -4558,7 +4452,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Literal::_InternalSerialize( } // bool nullable = 50; - if (this->nullable() != 0) { + if (this->_internal_nullable() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(50, this->_internal_nullable(), target); } @@ -4575,12 +4469,12 @@ size_t Expression_Literal::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // bool nullable = 50; - if (this->nullable() != 0) { + if (this->_internal_nullable() != 0) { total_size += 2 + 1; } @@ -4592,30 +4486,22 @@ size_t Expression_Literal::ByteSizeLong() const { } // int32 i8 = 2; case kI8: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_i8()); + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i8()); break; } // int32 i16 = 3; case kI16: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_i16()); + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i16()); break; } // int32 i32 = 5; case kI32: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_i32()); + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i32()); break; } // int64 i64 = 7; case kI64: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_i64()); + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_i64()); break; } // float fp32 = 10; @@ -4644,9 +4530,7 @@ size_t Expression_Literal::ByteSizeLong() const { } // int64 timestamp = 14; case kTimestamp: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_timestamp()); + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); break; } // int32 date = 16; @@ -4765,38 +4649,29 @@ size_t Expression_Literal::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Literal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Literal) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Literal* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Literal) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Literal) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Literal::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal::GetClassData() const { return &_class_data_; } + +void Expression_Literal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Literal::MergeFrom(const Expression_Literal& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.nullable() != 0) { + if (from._internal_nullable() != 0) { _internal_set_nullable(from._internal_nullable()); } switch (from.literal_type_case()) { @@ -4908,13 +4783,7 @@ void Expression_Literal::MergeFrom(const Expression_Literal& from) { break; } } -} - -void Expression_Literal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Literal) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Literal::CopyFrom(const Expression_Literal& from) { @@ -4930,7 +4799,7 @@ bool Expression_Literal::IsInitialized() const { void Expression_Literal::InternalSwap(Expression_Literal* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(nullable_, other->nullable_); swap(literal_type_, other->literal_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); @@ -4954,16 +4823,19 @@ Expression_ScalarFunction::_Internal::output_type(const Expression_ScalarFunctio return *msg->output_type_; } void Expression_ScalarFunction::clear_output_type() { - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; } -Expression_ScalarFunction::Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_ScalarFunction::Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), args_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.ScalarFunction) } Expression_ScalarFunction::Expression_ScalarFunction(const Expression_ScalarFunction& from) @@ -4979,7 +4851,7 @@ Expression_ScalarFunction::Expression_ScalarFunction(const Expression_ScalarFunc // @@protoc_insertion_point(copy_constructor:substrait.Expression.ScalarFunction) } -void Expression_ScalarFunction::SharedCtor() { +inline void Expression_ScalarFunction::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&output_type_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&function_reference_) - @@ -4988,12 +4860,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_ScalarFunction::~Expression_ScalarFunction() { // @@protoc_insertion_point(destructor:substrait.Expression.ScalarFunction) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_ScalarFunction::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_ScalarFunction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete output_type_; } @@ -5009,12 +4882,12 @@ void Expression_ScalarFunction::SetCachedSize(int size) const { void Expression_ScalarFunction::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.ScalarFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; args_.Clear(); - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; @@ -5025,19 +4898,20 @@ void Expression_ScalarFunction::Clear() { const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 function_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.Expression args = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -5045,46 +4919,48 @@ const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBU CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type output_type = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_ScalarFunction::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_ScalarFunction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ScalarFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 function_reference = 1; - if (this->function_reference() != 0) { + if (this->_internal_function_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); } @@ -5098,7 +4974,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ScalarFunction::_InternalSerialize( } // .substrait.Type output_type = 3; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5117,7 +4993,7 @@ size_t Expression_ScalarFunction::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ScalarFunction) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5129,64 +5005,47 @@ size_t Expression_ScalarFunction::ByteSizeLong() const { } // .substrait.Type output_type = 3; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *output_type_); } // uint32 function_reference = 1; - if (this->function_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_function_reference()); + if (this->_internal_function_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_ScalarFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.ScalarFunction) - GOOGLE_DCHECK_NE(&from, this); - const Expression_ScalarFunction* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.ScalarFunction) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.ScalarFunction) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ScalarFunction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_ScalarFunction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ScalarFunction::GetClassData() const { return &_class_data_; } + +void Expression_ScalarFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_ScalarFunction::MergeFrom(const Expression_ScalarFunction& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ScalarFunction) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; args_.MergeFrom(from.args_); - if (from.has_output_type()) { + if (from._internal_has_output_type()) { _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); } - if (from.function_reference() != 0) { + if (from._internal_function_reference() != 0) { _internal_set_function_reference(from._internal_function_reference()); } -} - -void Expression_ScalarFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.ScalarFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_ScalarFunction::CopyFrom(const Expression_ScalarFunction& from) { @@ -5202,7 +5061,7 @@ bool Expression_ScalarFunction::IsInitialized() const { void Expression_ScalarFunction::InternalSwap(Expression_ScalarFunction* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); args_.InternalSwap(&other->args_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, function_reference_) @@ -5224,10 +5083,13 @@ class Expression_WindowFunction_Bound_Preceding::_Internal { public: }; -Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Preceding) } Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from) @@ -5237,18 +5099,19 @@ Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Prece // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Preceding) } -void Expression_WindowFunction_Bound_Preceding::SharedCtor() { -offset_ = PROTOBUF_LONGLONG(0); +inline void Expression_WindowFunction_Bound_Preceding::SharedCtor() { +offset_ = int64_t{0}; } Expression_WindowFunction_Bound_Preceding::~Expression_WindowFunction_Bound_Preceding() { // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.Preceding) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_WindowFunction_Bound_Preceding::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_WindowFunction_Bound_Preceding::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_WindowFunction_Bound_Preceding::ArenaDtor(void* object) { @@ -5263,58 +5126,59 @@ void Expression_WindowFunction_Bound_Preceding::SetCachedSize(int size) const { void Expression_WindowFunction_Bound_Preceding::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Preceding) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - offset_ = PROTOBUF_LONGLONG(0); + offset_ = int64_t{0}; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* Expression_WindowFunction_Bound_Preceding::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int64 offset = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Preceding::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_WindowFunction_Bound_Preceding::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Preceding) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int64 offset = 1; - if (this->offset() != 0) { + if (this->_internal_offset() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), target); } @@ -5331,58 +5195,41 @@ size_t Expression_WindowFunction_Bound_Preceding::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Preceding) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int64 offset = 1; - if (this->offset() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_offset()); + if (this->_internal_offset() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_WindowFunction_Bound_Preceding::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction.Bound.Preceding) - GOOGLE_DCHECK_NE(&from, this); - const Expression_WindowFunction_Bound_Preceding* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction.Bound.Preceding) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction.Bound.Preceding) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_Preceding::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_WindowFunction_Bound_Preceding::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_Preceding::GetClassData() const { return &_class_data_; } + +void Expression_WindowFunction_Bound_Preceding::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_WindowFunction_Bound_Preceding::MergeFrom(const Expression_WindowFunction_Bound_Preceding& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Preceding) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.offset() != 0) { + if (from._internal_offset() != 0) { _internal_set_offset(from._internal_offset()); } -} - -void Expression_WindowFunction_Bound_Preceding::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction.Bound.Preceding) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_WindowFunction_Bound_Preceding::CopyFrom(const Expression_WindowFunction_Bound_Preceding& from) { @@ -5398,7 +5245,7 @@ bool Expression_WindowFunction_Bound_Preceding::IsInitialized() const { void Expression_WindowFunction_Bound_Preceding::InternalSwap(Expression_WindowFunction_Bound_Preceding* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(offset_, other->offset_); } @@ -5414,10 +5261,13 @@ class Expression_WindowFunction_Bound_Following::_Internal { public: }; -Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Following) } Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(const Expression_WindowFunction_Bound_Following& from) @@ -5427,18 +5277,19 @@ Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Follo // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Following) } -void Expression_WindowFunction_Bound_Following::SharedCtor() { -offset_ = PROTOBUF_LONGLONG(0); +inline void Expression_WindowFunction_Bound_Following::SharedCtor() { +offset_ = int64_t{0}; } Expression_WindowFunction_Bound_Following::~Expression_WindowFunction_Bound_Following() { // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.Following) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_WindowFunction_Bound_Following::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_WindowFunction_Bound_Following::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_WindowFunction_Bound_Following::ArenaDtor(void* object) { @@ -5453,58 +5304,59 @@ void Expression_WindowFunction_Bound_Following::SetCachedSize(int size) const { void Expression_WindowFunction_Bound_Following::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Following) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - offset_ = PROTOBUF_LONGLONG(0); + offset_ = int64_t{0}; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* Expression_WindowFunction_Bound_Following::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int64 offset = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Following::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_WindowFunction_Bound_Following::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Following) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int64 offset = 1; - if (this->offset() != 0) { + if (this->_internal_offset() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), target); } @@ -5521,58 +5373,41 @@ size_t Expression_WindowFunction_Bound_Following::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Following) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int64 offset = 1; - if (this->offset() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_offset()); + if (this->_internal_offset() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_WindowFunction_Bound_Following::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction.Bound.Following) - GOOGLE_DCHECK_NE(&from, this); - const Expression_WindowFunction_Bound_Following* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction.Bound.Following) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction.Bound.Following) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_Following::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_WindowFunction_Bound_Following::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_Following::GetClassData() const { return &_class_data_; } + +void Expression_WindowFunction_Bound_Following::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_WindowFunction_Bound_Following::MergeFrom(const Expression_WindowFunction_Bound_Following& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Following) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.offset() != 0) { + if (from._internal_offset() != 0) { _internal_set_offset(from._internal_offset()); } -} - -void Expression_WindowFunction_Bound_Following::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction.Bound.Following) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_WindowFunction_Bound_Following::CopyFrom(const Expression_WindowFunction_Bound_Following& from) { @@ -5588,7 +5423,7 @@ bool Expression_WindowFunction_Bound_Following::IsInitialized() const { void Expression_WindowFunction_Bound_Following::InternalSwap(Expression_WindowFunction_Bound_Following* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(offset_, other->offset_); } @@ -5604,151 +5439,32 @@ class Expression_WindowFunction_Bound_CurrentRow::_Internal { public: }; -Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); +Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.CurrentRow) } Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(const Expression_WindowFunction_Bound_CurrentRow& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.CurrentRow) } -void Expression_WindowFunction_Bound_CurrentRow::SharedCtor() { -} - -Expression_WindowFunction_Bound_CurrentRow::~Expression_WindowFunction_Bound_CurrentRow() { - // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.CurrentRow) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Expression_WindowFunction_Bound_CurrentRow::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} -void Expression_WindowFunction_Bound_CurrentRow::ArenaDtor(void* object) { - Expression_WindowFunction_Bound_CurrentRow* _this = reinterpret_cast< Expression_WindowFunction_Bound_CurrentRow* >(object); - (void)_this; -} -void Expression_WindowFunction_Bound_CurrentRow::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_WindowFunction_Bound_CurrentRow::SetCachedSize(int size) const { - _cached_size_.Set(size); -} -void Expression_WindowFunction_Bound_CurrentRow::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.CurrentRow) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} -const char* Expression_WindowFunction_Bound_CurrentRow::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_CurrentRow::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.CurrentRow) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound.CurrentRow) - return target; -} - -size_t Expression_WindowFunction_Bound_CurrentRow::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.CurrentRow) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} - -void Expression_WindowFunction_Bound_CurrentRow::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction.Bound.CurrentRow) - GOOGLE_DCHECK_NE(&from, this); - const Expression_WindowFunction_Bound_CurrentRow* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction.Bound.CurrentRow) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction.Bound.CurrentRow) - MergeFrom(*source); - } -} +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_CurrentRow::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_CurrentRow::GetClassData() const { return &_class_data_; } -void Expression_WindowFunction_Bound_CurrentRow::MergeFrom(const Expression_WindowFunction_Bound_CurrentRow& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.CurrentRow) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; -} -void Expression_WindowFunction_Bound_CurrentRow::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction.Bound.CurrentRow) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -void Expression_WindowFunction_Bound_CurrentRow::CopyFrom(const Expression_WindowFunction_Bound_CurrentRow& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.CurrentRow) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -bool Expression_WindowFunction_Bound_CurrentRow::IsInitialized() const { - return true; -} -void Expression_WindowFunction_Bound_CurrentRow::InternalSwap(Expression_WindowFunction_Bound_CurrentRow* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); -} ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_CurrentRow::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( @@ -5762,151 +5478,32 @@ class Expression_WindowFunction_Bound_Unbounded::_Internal { public: }; -Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); +Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Unbounded) } Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(const Expression_WindowFunction_Bound_Unbounded& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Unbounded) } -void Expression_WindowFunction_Bound_Unbounded::SharedCtor() { -} - -Expression_WindowFunction_Bound_Unbounded::~Expression_WindowFunction_Bound_Unbounded() { - // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.Unbounded) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Expression_WindowFunction_Bound_Unbounded::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} -void Expression_WindowFunction_Bound_Unbounded::ArenaDtor(void* object) { - Expression_WindowFunction_Bound_Unbounded* _this = reinterpret_cast< Expression_WindowFunction_Bound_Unbounded* >(object); - (void)_this; -} -void Expression_WindowFunction_Bound_Unbounded::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_WindowFunction_Bound_Unbounded::SetCachedSize(int size) const { - _cached_size_.Set(size); -} -void Expression_WindowFunction_Bound_Unbounded::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Unbounded) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} -const char* Expression_WindowFunction_Bound_Unbounded::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound_Unbounded::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Unbounded) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound.Unbounded) - return target; -} - -size_t Expression_WindowFunction_Bound_Unbounded::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Unbounded) - size_t total_size = 0; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_Unbounded::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_Unbounded::GetClassData() const { return &_class_data_; } - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} -void Expression_WindowFunction_Bound_Unbounded::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction.Bound.Unbounded) - GOOGLE_DCHECK_NE(&from, this); - const Expression_WindowFunction_Bound_Unbounded* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction.Bound.Unbounded) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction.Bound.Unbounded) - MergeFrom(*source); - } -} -void Expression_WindowFunction_Bound_Unbounded::MergeFrom(const Expression_WindowFunction_Bound_Unbounded& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Unbounded) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; -} -void Expression_WindowFunction_Bound_Unbounded::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction.Bound.Unbounded) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Expression_WindowFunction_Bound_Unbounded::CopyFrom(const Expression_WindowFunction_Bound_Unbounded& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.Unbounded) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_WindowFunction_Bound_Unbounded::IsInitialized() const { - return true; -} - -void Expression_WindowFunction_Bound_Unbounded::InternalSwap(Expression_WindowFunction_Bound_Unbounded* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); -} ::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Unbounded::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( @@ -5941,11 +5538,11 @@ Expression_WindowFunction_Bound::_Internal::unbounded(const Expression_WindowFun return *msg->kind_.unbounded_; } void Expression_WindowFunction_Bound::set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (preceding) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(preceding); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Preceding>::GetOwningArena(preceding); if (message_arena != submessage_arena) { preceding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, preceding, submessage_arena); @@ -5956,11 +5553,11 @@ void Expression_WindowFunction_Bound::set_allocated_preceding(::substrait::Expre // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.preceding) } void Expression_WindowFunction_Bound::set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (following) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(following); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Following>::GetOwningArena(following); if (message_arena != submessage_arena) { following = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, following, submessage_arena); @@ -5971,11 +5568,11 @@ void Expression_WindowFunction_Bound::set_allocated_following(::substrait::Expre // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.following) } void Expression_WindowFunction_Bound::set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (current_row) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(current_row); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_CurrentRow>::GetOwningArena(current_row); if (message_arena != submessage_arena) { current_row = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, current_row, submessage_arena); @@ -5986,11 +5583,11 @@ void Expression_WindowFunction_Bound::set_allocated_current_row(::substrait::Exp // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.current_row) } void Expression_WindowFunction_Bound::set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (unbounded) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(unbounded); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Unbounded>::GetOwningArena(unbounded); if (message_arena != submessage_arena) { unbounded = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, unbounded, submessage_arena); @@ -6000,10 +5597,13 @@ void Expression_WindowFunction_Bound::set_allocated_unbounded(::substrait::Expre } // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.unbounded) } -Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound) } Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(const Expression_WindowFunction_Bound& from) @@ -6034,18 +5634,19 @@ Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(const Expressio // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound) } -void Expression_WindowFunction_Bound::SharedCtor() { +inline void Expression_WindowFunction_Bound::SharedCtor() { clear_has_kind(); } Expression_WindowFunction_Bound::~Expression_WindowFunction_Bound() { // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_WindowFunction_Bound::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_WindowFunction_Bound::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_kind()) { clear_kind(); } @@ -6065,25 +5666,25 @@ void Expression_WindowFunction_Bound::clear_kind() { // @@protoc_insertion_point(one_of_clear_start:substrait.Expression.WindowFunction.Bound) switch (kind_case()) { case kPreceding: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.preceding_; } break; } case kFollowing: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.following_; } break; } case kCurrentRow: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.current_row_; } break; } case kUnbounded: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.unbounded_; } break; @@ -6098,7 +5699,7 @@ void Expression_WindowFunction_Bound::clear_kind() { void Expression_WindowFunction_Bound::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6109,64 +5710,68 @@ void Expression_WindowFunction_Bound::Clear() { const char* Expression_WindowFunction_Bound::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_preceding(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.WindowFunction.Bound.Following following = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_following(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_current_row(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_unbounded(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction_Bound::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_WindowFunction_Bound::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; @@ -6213,7 +5818,7 @@ size_t Expression_WindowFunction_Bound::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6250,35 +5855,26 @@ size_t Expression_WindowFunction_Bound::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_WindowFunction_Bound::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction.Bound) - GOOGLE_DCHECK_NE(&from, this); - const Expression_WindowFunction_Bound* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction.Bound) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction.Bound) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_WindowFunction_Bound::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound::GetClassData() const { return &_class_data_; } + +void Expression_WindowFunction_Bound::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_WindowFunction_Bound::MergeFrom(const Expression_WindowFunction_Bound& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.kind_case()) { @@ -6302,13 +5898,7 @@ void Expression_WindowFunction_Bound::MergeFrom(const Expression_WindowFunction_ break; } } -} - -void Expression_WindowFunction_Bound::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction.Bound) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_WindowFunction_Bound::CopyFrom(const Expression_WindowFunction_Bound& from) { @@ -6324,7 +5914,7 @@ bool Expression_WindowFunction_Bound::IsInitialized() const { void Expression_WindowFunction_Bound::InternalSwap(Expression_WindowFunction_Bound* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(kind_, other->kind_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -6357,18 +5947,21 @@ Expression_WindowFunction::_Internal::output_type(const Expression_WindowFunctio return *msg->output_type_; } void Expression_WindowFunction::clear_output_type() { - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; } -Expression_WindowFunction::Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_WindowFunction::Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), partitions_(arena), sorts_(arena), args_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction) } Expression_WindowFunction::Expression_WindowFunction(const Expression_WindowFunction& from) @@ -6398,7 +5991,7 @@ Expression_WindowFunction::Expression_WindowFunction(const Expression_WindowFunc // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction) } -void Expression_WindowFunction::SharedCtor() { +inline void Expression_WindowFunction::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&upper_bound_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&phase_) - @@ -6407,12 +6000,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_WindowFunction::~Expression_WindowFunction() { // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_WindowFunction::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_WindowFunction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete upper_bound_; if (this != internal_default_instance()) delete lower_bound_; if (this != internal_default_instance()) delete output_type_; @@ -6430,22 +6024,22 @@ void Expression_WindowFunction::SetCachedSize(int size) const { void Expression_WindowFunction::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; partitions_.Clear(); sorts_.Clear(); args_.Clear(); - if (GetArena() == nullptr && upper_bound_ != nullptr) { + if (GetArenaForAllocation() == nullptr && upper_bound_ != nullptr) { delete upper_bound_; } upper_bound_ = nullptr; - if (GetArena() == nullptr && lower_bound_ != nullptr) { + if (GetArenaForAllocation() == nullptr && lower_bound_ != nullptr) { delete lower_bound_; } lower_bound_ = nullptr; - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; @@ -6458,19 +6052,20 @@ void Expression_WindowFunction::Clear() { const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 function_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.Expression partitions = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -6478,11 +6073,12 @@ const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBU CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.SortField sorts = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -6490,40 +6086,45 @@ const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBU CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.WindowFunction.Bound upper_bound = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_upper_bound(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.WindowFunction.Bound lower_bound = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_lower_bound(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.AggregationPhase phase = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_phase(static_cast<::substrait::AggregationPhase>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type output_type = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.Expression args = 8; case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr -= 1; do { ptr += 1; @@ -6531,39 +6132,40 @@ const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBU CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_WindowFunction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 function_reference = 1; - if (this->function_reference() != 0) { + if (this->_internal_function_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); } @@ -6585,7 +6187,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( } // .substrait.Expression.WindowFunction.Bound upper_bound = 4; - if (this->has_upper_bound()) { + if (this->_internal_has_upper_bound()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6593,7 +6195,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( } // .substrait.Expression.WindowFunction.Bound lower_bound = 5; - if (this->has_lower_bound()) { + if (this->_internal_has_lower_bound()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6601,14 +6203,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_WindowFunction::_InternalSerialize( } // .substrait.AggregationPhase phase = 6; - if (this->phase() != 0) { + if (this->_internal_phase() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 6, this->_internal_phase(), target); } // .substrait.Type output_type = 7; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6635,7 +6237,7 @@ size_t Expression_WindowFunction::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6661,95 +6263,78 @@ size_t Expression_WindowFunction::ByteSizeLong() const { } // .substrait.Expression.WindowFunction.Bound upper_bound = 4; - if (this->has_upper_bound()) { + if (this->_internal_has_upper_bound()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *upper_bound_); } // .substrait.Expression.WindowFunction.Bound lower_bound = 5; - if (this->has_lower_bound()) { + if (this->_internal_has_lower_bound()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *lower_bound_); } // .substrait.Type output_type = 7; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *output_type_); } // uint32 function_reference = 1; - if (this->function_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_function_reference()); + if (this->_internal_function_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference()); } // .substrait.AggregationPhase phase = 6; - if (this->phase() != 0) { + if (this->_internal_phase() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_WindowFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.WindowFunction) - GOOGLE_DCHECK_NE(&from, this); - const Expression_WindowFunction* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.WindowFunction) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.WindowFunction) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_WindowFunction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction::GetClassData() const { return &_class_data_; } + +void Expression_WindowFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_WindowFunction::MergeFrom(const Expression_WindowFunction& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; partitions_.MergeFrom(from.partitions_); sorts_.MergeFrom(from.sorts_); args_.MergeFrom(from.args_); - if (from.has_upper_bound()) { + if (from._internal_has_upper_bound()) { _internal_mutable_upper_bound()->::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_upper_bound()); } - if (from.has_lower_bound()) { + if (from._internal_has_lower_bound()) { _internal_mutable_lower_bound()->::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_lower_bound()); } - if (from.has_output_type()) { + if (from._internal_has_output_type()) { _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); } - if (from.function_reference() != 0) { + if (from._internal_function_reference() != 0) { _internal_set_function_reference(from._internal_function_reference()); } - if (from.phase() != 0) { + if (from._internal_phase() != 0) { _internal_set_phase(from._internal_phase()); } -} - -void Expression_WindowFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.WindowFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_WindowFunction::CopyFrom(const Expression_WindowFunction& from) { @@ -6765,7 +6350,7 @@ bool Expression_WindowFunction::IsInitialized() const { void Expression_WindowFunction::InternalSwap(Expression_WindowFunction* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); partitions_.InternalSwap(&other->partitions_); sorts_.InternalSwap(&other->sorts_); args_.InternalSwap(&other->args_); @@ -6799,10 +6384,13 @@ const ::substrait::Expression& Expression_IfThen_IfClause::_Internal::then(const Expression_IfThen_IfClause* msg) { return *msg->then_; } -Expression_IfThen_IfClause::Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_IfThen_IfClause::Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.IfThen.IfClause) } Expression_IfThen_IfClause::Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from) @@ -6821,7 +6409,7 @@ Expression_IfThen_IfClause::Expression_IfThen_IfClause(const Expression_IfThen_I // @@protoc_insertion_point(copy_constructor:substrait.Expression.IfThen.IfClause) } -void Expression_IfThen_IfClause::SharedCtor() { +inline void Expression_IfThen_IfClause::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&if__) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&then_) - @@ -6830,12 +6418,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_IfThen_IfClause::~Expression_IfThen_IfClause() { // @@protoc_insertion_point(destructor:substrait.Expression.IfThen.IfClause) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_IfThen_IfClause::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_IfThen_IfClause::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete if__; if (this != internal_default_instance()) delete then_; } @@ -6852,15 +6441,15 @@ void Expression_IfThen_IfClause::SetCachedSize(int size) const { void Expression_IfThen_IfClause::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.IfThen.IfClause) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && if__ != nullptr) { + if (GetArenaForAllocation() == nullptr && if__ != nullptr) { delete if__; } if__ = nullptr; - if (GetArena() == nullptr && then_ != nullptr) { + if (GetArenaForAllocation() == nullptr && then_ != nullptr) { delete then_; } then_ = nullptr; @@ -6870,54 +6459,56 @@ void Expression_IfThen_IfClause::Clear() { const char* Expression_IfThen_IfClause::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression if = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression then = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_then(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen_IfClause::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_IfThen_IfClause::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.IfThen.IfClause) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression if = 1; - if (this->has_if_()) { + if (this->_internal_has_if_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6925,7 +6516,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen_IfClause::_InternalSerialize( } // .substrait.Expression then = 2; - if (this->has_then()) { + if (this->_internal_has_then()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6944,68 +6535,53 @@ size_t Expression_IfThen_IfClause::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.IfThen.IfClause) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Expression if = 1; - if (this->has_if_()) { + if (this->_internal_has_if_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *if__); } // .substrait.Expression then = 2; - if (this->has_then()) { + if (this->_internal_has_then()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *then_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_IfThen_IfClause::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.IfThen.IfClause) - GOOGLE_DCHECK_NE(&from, this); - const Expression_IfThen_IfClause* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.IfThen.IfClause) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.IfThen.IfClause) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_IfThen_IfClause::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_IfThen_IfClause::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_IfThen_IfClause::GetClassData() const { return &_class_data_; } + +void Expression_IfThen_IfClause::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_IfThen_IfClause::MergeFrom(const Expression_IfThen_IfClause& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.IfThen.IfClause) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_if_()) { + if (from._internal_has_if_()) { _internal_mutable_if_()->::substrait::Expression::MergeFrom(from._internal_if_()); } - if (from.has_then()) { + if (from._internal_has_then()) { _internal_mutable_then()->::substrait::Expression::MergeFrom(from._internal_then()); } -} - -void Expression_IfThen_IfClause::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.IfThen.IfClause) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_IfThen_IfClause::CopyFrom(const Expression_IfThen_IfClause& from) { @@ -7021,7 +6597,7 @@ bool Expression_IfThen_IfClause::IsInitialized() const { void Expression_IfThen_IfClause::InternalSwap(Expression_IfThen_IfClause* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, then_) + sizeof(Expression_IfThen_IfClause::then_) @@ -7047,11 +6623,14 @@ const ::substrait::Expression& Expression_IfThen::_Internal::else_(const Expression_IfThen* msg) { return *msg->else__; } -Expression_IfThen::Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_IfThen::Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), ifs_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.IfThen) } Expression_IfThen::Expression_IfThen(const Expression_IfThen& from) @@ -7066,18 +6645,19 @@ Expression_IfThen::Expression_IfThen(const Expression_IfThen& from) // @@protoc_insertion_point(copy_constructor:substrait.Expression.IfThen) } -void Expression_IfThen::SharedCtor() { +inline void Expression_IfThen::SharedCtor() { else__ = nullptr; } Expression_IfThen::~Expression_IfThen() { // @@protoc_insertion_point(destructor:substrait.Expression.IfThen) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_IfThen::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_IfThen::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete else__; } @@ -7093,12 +6673,12 @@ void Expression_IfThen::SetCachedSize(int size) const { void Expression_IfThen::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.IfThen) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ifs_.Clear(); - if (GetArena() == nullptr && else__ != nullptr) { + if (GetArenaForAllocation() == nullptr && else__ != nullptr) { delete else__; } else__ = nullptr; @@ -7108,12 +6688,12 @@ void Expression_IfThen::Clear() { const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression.IfThen.IfClause ifs = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -7121,42 +6701,44 @@ const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression else = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_IfThen::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.IfThen) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression.IfThen.IfClause ifs = 1; @@ -7168,7 +6750,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_IfThen::_InternalSerialize( } // .substrait.Expression else = 2; - if (this->has_else_()) { + if (this->_internal_has_else_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7187,7 +6769,7 @@ size_t Expression_IfThen::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.IfThen) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7199,54 +6781,39 @@ size_t Expression_IfThen::ByteSizeLong() const { } // .substrait.Expression else = 2; - if (this->has_else_()) { + if (this->_internal_has_else_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *else__); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_IfThen::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.IfThen) - GOOGLE_DCHECK_NE(&from, this); - const Expression_IfThen* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.IfThen) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.IfThen) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_IfThen::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_IfThen::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_IfThen::GetClassData() const { return &_class_data_; } + +void Expression_IfThen::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_IfThen::MergeFrom(const Expression_IfThen& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.IfThen) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; ifs_.MergeFrom(from.ifs_); - if (from.has_else_()) { + if (from._internal_has_else_()) { _internal_mutable_else_()->::substrait::Expression::MergeFrom(from._internal_else_()); } -} - -void Expression_IfThen::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.IfThen) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_IfThen::CopyFrom(const Expression_IfThen& from) { @@ -7262,7 +6829,7 @@ bool Expression_IfThen::IsInitialized() const { void Expression_IfThen::InternalSwap(Expression_IfThen* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ifs_.InternalSwap(&other->ifs_); swap(else__, other->else__); } @@ -7290,15 +6857,18 @@ Expression_Cast::_Internal::input(const Expression_Cast* msg) { return *msg->input_; } void Expression_Cast::clear_type() { - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; } -Expression_Cast::Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_Cast::Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.Cast) } Expression_Cast::Expression_Cast(const Expression_Cast& from) @@ -7317,7 +6887,7 @@ Expression_Cast::Expression_Cast(const Expression_Cast& from) // @@protoc_insertion_point(copy_constructor:substrait.Expression.Cast) } -void Expression_Cast::SharedCtor() { +inline void Expression_Cast::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&input_) - @@ -7326,12 +6896,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_Cast::~Expression_Cast() { // @@protoc_insertion_point(destructor:substrait.Expression.Cast) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_Cast::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_Cast::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete type_; if (this != internal_default_instance()) delete input_; } @@ -7348,15 +6919,15 @@ void Expression_Cast::SetCachedSize(int size) const { void Expression_Cast::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.Cast) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; @@ -7366,54 +6937,56 @@ void Expression_Cast::Clear() { const char* Expression_Cast::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Type type = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression input = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_Cast::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_Cast::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Cast) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Type type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7421,7 +6994,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_Cast::_InternalSerialize( } // .substrait.Expression input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7440,68 +7013,53 @@ size_t Expression_Cast::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Cast) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Type type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *type_); } // .substrait.Expression input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_Cast::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.Cast) - GOOGLE_DCHECK_NE(&from, this); - const Expression_Cast* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.Cast) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.Cast) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Cast::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_Cast::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Cast::GetClassData() const { return &_class_data_; } + +void Expression_Cast::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_Cast::MergeFrom(const Expression_Cast& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Cast) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_type()) { + if (from._internal_has_type()) { _internal_mutable_type()->::substrait::Type::MergeFrom(from._internal_type()); } - if (from.has_input()) { + if (from._internal_has_input()) { _internal_mutable_input()->::substrait::Expression::MergeFrom(from._internal_input()); } -} - -void Expression_Cast::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.Cast) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_Cast::CopyFrom(const Expression_Cast& from) { @@ -7517,7 +7075,7 @@ bool Expression_Cast::IsInitialized() const { void Expression_Cast::InternalSwap(Expression_Cast* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_Cast, input_) + sizeof(Expression_Cast::input_) @@ -7548,10 +7106,13 @@ const ::substrait::Expression& Expression_SwitchExpression_IfValue::_Internal::then(const Expression_SwitchExpression_IfValue* msg) { return *msg->then_; } -Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.SwitchExpression.IfValue) } Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(const Expression_SwitchExpression_IfValue& from) @@ -7570,7 +7131,7 @@ Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(const E // @@protoc_insertion_point(copy_constructor:substrait.Expression.SwitchExpression.IfValue) } -void Expression_SwitchExpression_IfValue::SharedCtor() { +inline void Expression_SwitchExpression_IfValue::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&if__) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&then_) - @@ -7579,12 +7140,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_SwitchExpression_IfValue::~Expression_SwitchExpression_IfValue() { // @@protoc_insertion_point(destructor:substrait.Expression.SwitchExpression.IfValue) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_SwitchExpression_IfValue::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_SwitchExpression_IfValue::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete if__; if (this != internal_default_instance()) delete then_; } @@ -7601,15 +7163,15 @@ void Expression_SwitchExpression_IfValue::SetCachedSize(int size) const { void Expression_SwitchExpression_IfValue::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.SwitchExpression.IfValue) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && if__ != nullptr) { + if (GetArenaForAllocation() == nullptr && if__ != nullptr) { delete if__; } if__ = nullptr; - if (GetArena() == nullptr && then_ != nullptr) { + if (GetArenaForAllocation() == nullptr && then_ != nullptr) { delete then_; } then_ = nullptr; @@ -7619,54 +7181,56 @@ void Expression_SwitchExpression_IfValue::Clear() { const char* Expression_SwitchExpression_IfValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.Literal if = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression then = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_then(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression_IfValue::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_SwitchExpression_IfValue::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SwitchExpression.IfValue) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.Literal if = 1; - if (this->has_if_()) { + if (this->_internal_has_if_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7674,7 +7238,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression_IfValue::_InternalSe } // .substrait.Expression then = 2; - if (this->has_then()) { + if (this->_internal_has_then()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7693,68 +7257,53 @@ size_t Expression_SwitchExpression_IfValue::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SwitchExpression.IfValue) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Expression.Literal if = 1; - if (this->has_if_()) { + if (this->_internal_has_if_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *if__); } // .substrait.Expression then = 2; - if (this->has_then()) { + if (this->_internal_has_then()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *then_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_SwitchExpression_IfValue::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.SwitchExpression.IfValue) - GOOGLE_DCHECK_NE(&from, this); - const Expression_SwitchExpression_IfValue* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.SwitchExpression.IfValue) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.SwitchExpression.IfValue) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_SwitchExpression_IfValue::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_SwitchExpression_IfValue::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_SwitchExpression_IfValue::GetClassData() const { return &_class_data_; } + +void Expression_SwitchExpression_IfValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_SwitchExpression_IfValue::MergeFrom(const Expression_SwitchExpression_IfValue& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SwitchExpression.IfValue) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_if_()) { + if (from._internal_has_if_()) { _internal_mutable_if_()->::substrait::Expression_Literal::MergeFrom(from._internal_if_()); } - if (from.has_then()) { + if (from._internal_has_then()) { _internal_mutable_then()->::substrait::Expression::MergeFrom(from._internal_then()); } -} - -void Expression_SwitchExpression_IfValue::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.SwitchExpression.IfValue) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_SwitchExpression_IfValue::CopyFrom(const Expression_SwitchExpression_IfValue& from) { @@ -7770,7 +7319,7 @@ bool Expression_SwitchExpression_IfValue::IsInitialized() const { void Expression_SwitchExpression_IfValue::InternalSwap(Expression_SwitchExpression_IfValue* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_SwitchExpression_IfValue, then_) + sizeof(Expression_SwitchExpression_IfValue::then_) @@ -7796,11 +7345,14 @@ const ::substrait::Expression& Expression_SwitchExpression::_Internal::else_(const Expression_SwitchExpression* msg) { return *msg->else__; } -Expression_SwitchExpression::Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_SwitchExpression::Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), ifs_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.SwitchExpression) } Expression_SwitchExpression::Expression_SwitchExpression(const Expression_SwitchExpression& from) @@ -7815,18 +7367,19 @@ Expression_SwitchExpression::Expression_SwitchExpression(const Expression_Switch // @@protoc_insertion_point(copy_constructor:substrait.Expression.SwitchExpression) } -void Expression_SwitchExpression::SharedCtor() { +inline void Expression_SwitchExpression::SharedCtor() { else__ = nullptr; } Expression_SwitchExpression::~Expression_SwitchExpression() { // @@protoc_insertion_point(destructor:substrait.Expression.SwitchExpression) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_SwitchExpression::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_SwitchExpression::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete else__; } @@ -7842,12 +7395,12 @@ void Expression_SwitchExpression::SetCachedSize(int size) const { void Expression_SwitchExpression::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.SwitchExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; ifs_.Clear(); - if (GetArena() == nullptr && else__ != nullptr) { + if (GetArenaForAllocation() == nullptr && else__ != nullptr) { delete else__; } else__ = nullptr; @@ -7857,12 +7410,12 @@ void Expression_SwitchExpression::Clear() { const char* Expression_SwitchExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -7870,42 +7423,44 @@ const char* Expression_SwitchExpression::_InternalParse(const char* ptr, ::PROTO CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression else = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_SwitchExpression::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SwitchExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; @@ -7917,7 +7472,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_SwitchExpression::_InternalSerialize( } // .substrait.Expression else = 2; - if (this->has_else_()) { + if (this->_internal_has_else_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7936,7 +7491,7 @@ size_t Expression_SwitchExpression::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SwitchExpression) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7948,54 +7503,39 @@ size_t Expression_SwitchExpression::ByteSizeLong() const { } // .substrait.Expression else = 2; - if (this->has_else_()) { + if (this->_internal_has_else_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *else__); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_SwitchExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.SwitchExpression) - GOOGLE_DCHECK_NE(&from, this); - const Expression_SwitchExpression* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.SwitchExpression) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.SwitchExpression) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_SwitchExpression::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_SwitchExpression::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_SwitchExpression::GetClassData() const { return &_class_data_; } + +void Expression_SwitchExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_SwitchExpression::MergeFrom(const Expression_SwitchExpression& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SwitchExpression) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; ifs_.MergeFrom(from.ifs_); - if (from.has_else_()) { + if (from._internal_has_else_()) { _internal_mutable_else_()->::substrait::Expression::MergeFrom(from._internal_else_()); } -} - -void Expression_SwitchExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.SwitchExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_SwitchExpression::CopyFrom(const Expression_SwitchExpression& from) { @@ -8011,7 +7551,7 @@ bool Expression_SwitchExpression::IsInitialized() const { void Expression_SwitchExpression::InternalSwap(Expression_SwitchExpression* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ifs_.InternalSwap(&other->ifs_); swap(else__, other->else__); } @@ -8033,11 +7573,14 @@ const ::substrait::Expression& Expression_SingularOrList::_Internal::value(const Expression_SingularOrList* msg) { return *msg->value_; } -Expression_SingularOrList::Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_SingularOrList::Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), options_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.SingularOrList) } Expression_SingularOrList::Expression_SingularOrList(const Expression_SingularOrList& from) @@ -8052,18 +7595,19 @@ Expression_SingularOrList::Expression_SingularOrList(const Expression_SingularOr // @@protoc_insertion_point(copy_constructor:substrait.Expression.SingularOrList) } -void Expression_SingularOrList::SharedCtor() { +inline void Expression_SingularOrList::SharedCtor() { value_ = nullptr; } Expression_SingularOrList::~Expression_SingularOrList() { // @@protoc_insertion_point(destructor:substrait.Expression.SingularOrList) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_SingularOrList::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_SingularOrList::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete value_; } @@ -8079,12 +7623,12 @@ void Expression_SingularOrList::SetCachedSize(int size) const { void Expression_SingularOrList::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.SingularOrList) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; options_.Clear(); - if (GetArena() == nullptr && value_ != nullptr) { + if (GetArenaForAllocation() == nullptr && value_ != nullptr) { delete value_; } value_ = nullptr; @@ -8094,19 +7638,20 @@ void Expression_SingularOrList::Clear() { const char* Expression_SingularOrList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.Expression options = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -8114,39 +7659,40 @@ const char* Expression_SingularOrList::_InternalParse(const char* ptr, ::PROTOBU CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_SingularOrList::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_SingularOrList::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SingularOrList) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression value = 1; - if (this->has_value()) { + if (this->_internal_has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -8173,7 +7719,7 @@ size_t Expression_SingularOrList::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SingularOrList) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8185,54 +7731,39 @@ size_t Expression_SingularOrList::ByteSizeLong() const { } // .substrait.Expression value = 1; - if (this->has_value()) { + if (this->_internal_has_value()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *value_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_SingularOrList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.SingularOrList) - GOOGLE_DCHECK_NE(&from, this); - const Expression_SingularOrList* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.SingularOrList) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.SingularOrList) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_SingularOrList::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_SingularOrList::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_SingularOrList::GetClassData() const { return &_class_data_; } + +void Expression_SingularOrList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_SingularOrList::MergeFrom(const Expression_SingularOrList& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SingularOrList) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; options_.MergeFrom(from.options_); - if (from.has_value()) { + if (from._internal_has_value()) { _internal_mutable_value()->::substrait::Expression::MergeFrom(from._internal_value()); } -} - -void Expression_SingularOrList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.SingularOrList) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_SingularOrList::CopyFrom(const Expression_SingularOrList& from) { @@ -8248,7 +7779,7 @@ bool Expression_SingularOrList::IsInitialized() const { void Expression_SingularOrList::InternalSwap(Expression_SingularOrList* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); options_.InternalSwap(&other->options_); swap(value_, other->value_); } @@ -8265,11 +7796,14 @@ class Expression_MultiOrList_Record::_Internal { public: }; -Expression_MultiOrList_Record::Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_MultiOrList_Record::Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), fields_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MultiOrList.Record) } Expression_MultiOrList_Record::Expression_MultiOrList_Record(const Expression_MultiOrList_Record& from) @@ -8279,17 +7813,18 @@ Expression_MultiOrList_Record::Expression_MultiOrList_Record(const Expression_Mu // @@protoc_insertion_point(copy_constructor:substrait.Expression.MultiOrList.Record) } -void Expression_MultiOrList_Record::SharedCtor() { +inline void Expression_MultiOrList_Record::SharedCtor() { } Expression_MultiOrList_Record::~Expression_MultiOrList_Record() { // @@protoc_insertion_point(destructor:substrait.Expression.MultiOrList.Record) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MultiOrList_Record::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MultiOrList_Record::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_MultiOrList_Record::ArenaDtor(void* object) { @@ -8304,7 +7839,7 @@ void Expression_MultiOrList_Record::SetCachedSize(int size) const { void Expression_MultiOrList_Record::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MultiOrList.Record) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8315,12 +7850,12 @@ void Expression_MultiOrList_Record::Clear() { const char* Expression_MultiOrList_Record::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression fields = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -8328,35 +7863,36 @@ const char* Expression_MultiOrList_Record::_InternalParse(const char* ptr, ::PRO CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MultiOrList_Record::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MultiOrList_Record::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MultiOrList.Record) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression fields = 1; @@ -8379,7 +7915,7 @@ size_t Expression_MultiOrList_Record::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MultiOrList.Record) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8390,45 +7926,30 @@ size_t Expression_MultiOrList_Record::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MultiOrList_Record::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MultiOrList.Record) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MultiOrList_Record* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MultiOrList.Record) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MultiOrList.Record) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MultiOrList_Record::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MultiOrList_Record::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MultiOrList_Record::GetClassData() const { return &_class_data_; } + +void Expression_MultiOrList_Record::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MultiOrList_Record::MergeFrom(const Expression_MultiOrList_Record& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MultiOrList.Record) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; fields_.MergeFrom(from.fields_); -} - -void Expression_MultiOrList_Record::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MultiOrList.Record) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MultiOrList_Record::CopyFrom(const Expression_MultiOrList_Record& from) { @@ -8444,7 +7965,7 @@ bool Expression_MultiOrList_Record::IsInitialized() const { void Expression_MultiOrList_Record::InternalSwap(Expression_MultiOrList_Record* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); fields_.InternalSwap(&other->fields_); } @@ -8460,12 +7981,15 @@ class Expression_MultiOrList::_Internal { public: }; -Expression_MultiOrList::Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_MultiOrList::Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), value_(arena), options_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MultiOrList) } Expression_MultiOrList::Expression_MultiOrList(const Expression_MultiOrList& from) @@ -8476,17 +8000,18 @@ Expression_MultiOrList::Expression_MultiOrList(const Expression_MultiOrList& fro // @@protoc_insertion_point(copy_constructor:substrait.Expression.MultiOrList) } -void Expression_MultiOrList::SharedCtor() { +inline void Expression_MultiOrList::SharedCtor() { } Expression_MultiOrList::~Expression_MultiOrList() { // @@protoc_insertion_point(destructor:substrait.Expression.MultiOrList) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MultiOrList::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MultiOrList::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_MultiOrList::ArenaDtor(void* object) { @@ -8501,7 +8026,7 @@ void Expression_MultiOrList::SetCachedSize(int size) const { void Expression_MultiOrList::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MultiOrList) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8513,12 +8038,12 @@ void Expression_MultiOrList::Clear() { const char* Expression_MultiOrList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -8526,11 +8051,12 @@ const char* Expression_MultiOrList::_InternalParse(const char* ptr, ::PROTOBUF_N CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.Expression.MultiOrList.Record options = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -8538,35 +8064,36 @@ const char* Expression_MultiOrList::_InternalParse(const char* ptr, ::PROTOBUF_N CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MultiOrList::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MultiOrList::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MultiOrList) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression value = 1; @@ -8597,7 +8124,7 @@ size_t Expression_MultiOrList::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MultiOrList) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8615,46 +8142,31 @@ size_t Expression_MultiOrList::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MultiOrList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MultiOrList) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MultiOrList* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MultiOrList) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MultiOrList) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MultiOrList::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MultiOrList::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MultiOrList::GetClassData() const { return &_class_data_; } + +void Expression_MultiOrList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MultiOrList::MergeFrom(const Expression_MultiOrList& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MultiOrList) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; value_.MergeFrom(from.value_); options_.MergeFrom(from.options_); -} - -void Expression_MultiOrList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MultiOrList) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MultiOrList::CopyFrom(const Expression_MultiOrList& from) { @@ -8670,7 +8182,7 @@ bool Expression_MultiOrList::IsInitialized() const { void Expression_MultiOrList::InternalSwap(Expression_MultiOrList* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); value_.InternalSwap(&other->value_); options_.InternalSwap(&other->options_); } @@ -8687,11 +8199,14 @@ class Expression_EmbeddedFunction_PythonPickleFunction::_Internal { public: }; -Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), prerequisite_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction) } Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(const Expression_EmbeddedFunction_PythonPickleFunction& from) @@ -8699,25 +8214,32 @@ Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_Py prerequisite_(from.prerequisite_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_function().empty()) { function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_function(), - GetArena()); + GetArenaForAllocation()); } // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction) } -void Expression_EmbeddedFunction_PythonPickleFunction::SharedCtor() { +inline void Expression_EmbeddedFunction_PythonPickleFunction::SharedCtor() { function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } Expression_EmbeddedFunction_PythonPickleFunction::~Expression_EmbeddedFunction_PythonPickleFunction() { // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_EmbeddedFunction_PythonPickleFunction::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_EmbeddedFunction_PythonPickleFunction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); function_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -8733,7 +8255,7 @@ void Expression_EmbeddedFunction_PythonPickleFunction::SetCachedSize(int size) c void Expression_EmbeddedFunction_PythonPickleFunction::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8745,20 +8267,21 @@ void Expression_EmbeddedFunction_PythonPickleFunction::Clear() { const char* Expression_EmbeddedFunction_PythonPickleFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // bytes function = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_function(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated string prerequisite = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -8768,39 +8291,40 @@ const char* Expression_EmbeddedFunction_PythonPickleFunction::_InternalParse(con CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction_PythonPickleFunction::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_EmbeddedFunction_PythonPickleFunction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // bytes function = 1; - if (this->function().size() > 0) { + if (!this->_internal_function().empty()) { target = stream->WriteBytesMaybeAliased( 1, this->_internal_function(), target); } @@ -8827,7 +8351,7 @@ size_t Expression_EmbeddedFunction_PythonPickleFunction::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8840,54 +8364,39 @@ size_t Expression_EmbeddedFunction_PythonPickleFunction::ByteSizeLong() const { } // bytes function = 1; - if (this->function().size() > 0) { + if (!this->_internal_function().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( this->_internal_function()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - GOOGLE_DCHECK_NE(&from, this); - const Expression_EmbeddedFunction_PythonPickleFunction* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_EmbeddedFunction_PythonPickleFunction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_EmbeddedFunction_PythonPickleFunction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_EmbeddedFunction_PythonPickleFunction::GetClassData() const { return &_class_data_; } + +void Expression_EmbeddedFunction_PythonPickleFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; prerequisite_.MergeFrom(from.prerequisite_); - if (from.function().size() > 0) { + if (!from._internal_function().empty()) { _internal_set_function(from._internal_function()); } -} - -void Expression_EmbeddedFunction_PythonPickleFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_EmbeddedFunction_PythonPickleFunction::CopyFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from) { @@ -8903,9 +8412,15 @@ bool Expression_EmbeddedFunction_PythonPickleFunction::IsInitialized() const { void Expression_EmbeddedFunction_PythonPickleFunction::InternalSwap(Expression_EmbeddedFunction_PythonPickleFunction* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); prerequisite_.InternalSwap(&other->prerequisite_); - function_.Swap(&other->function_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &function_, lhs_arena, + &other->function_, rhs_arena + ); } ::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_PythonPickleFunction::GetMetadata() const { @@ -8920,11 +8435,14 @@ class Expression_EmbeddedFunction_WebAssemblyFunction::_Internal { public: }; -Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), prerequisite_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) } Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(const Expression_EmbeddedFunction_WebAssemblyFunction& from) @@ -8932,25 +8450,32 @@ Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_Web prerequisite_(from.prerequisite_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_script().empty()) { script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_script(), - GetArena()); + GetArenaForAllocation()); } // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) } -void Expression_EmbeddedFunction_WebAssemblyFunction::SharedCtor() { +inline void Expression_EmbeddedFunction_WebAssemblyFunction::SharedCtor() { script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } Expression_EmbeddedFunction_WebAssemblyFunction::~Expression_EmbeddedFunction_WebAssemblyFunction() { // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_EmbeddedFunction_WebAssemblyFunction::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_EmbeddedFunction_WebAssemblyFunction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); script_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -8966,7 +8491,7 @@ void Expression_EmbeddedFunction_WebAssemblyFunction::SetCachedSize(int size) co void Expression_EmbeddedFunction_WebAssemblyFunction::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8978,20 +8503,21 @@ void Expression_EmbeddedFunction_WebAssemblyFunction::Clear() { const char* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // bytes script = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_script(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated string prerequisite = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -9001,39 +8527,40 @@ const char* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalParse(cons CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // bytes script = 1; - if (this->script().size() > 0) { + if (!this->_internal_script().empty()) { target = stream->WriteBytesMaybeAliased( 1, this->_internal_script(), target); } @@ -9060,7 +8587,7 @@ size_t Expression_EmbeddedFunction_WebAssemblyFunction::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -9073,54 +8600,39 @@ size_t Expression_EmbeddedFunction_WebAssemblyFunction::ByteSizeLong() const { } // bytes script = 1; - if (this->script().size() > 0) { + if (!this->_internal_script().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( this->_internal_script()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - GOOGLE_DCHECK_NE(&from, this); - const Expression_EmbeddedFunction_WebAssemblyFunction* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_EmbeddedFunction_WebAssemblyFunction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_EmbeddedFunction_WebAssemblyFunction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_EmbeddedFunction_WebAssemblyFunction::GetClassData() const { return &_class_data_; } + +void Expression_EmbeddedFunction_WebAssemblyFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; prerequisite_.MergeFrom(from.prerequisite_); - if (from.script().size() > 0) { + if (!from._internal_script().empty()) { _internal_set_script(from._internal_script()); } -} - -void Expression_EmbeddedFunction_WebAssemblyFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_EmbeddedFunction_WebAssemblyFunction::CopyFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from) { @@ -9136,9 +8648,15 @@ bool Expression_EmbeddedFunction_WebAssemblyFunction::IsInitialized() const { void Expression_EmbeddedFunction_WebAssemblyFunction::InternalSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); prerequisite_.InternalSwap(&other->prerequisite_); - script_.Swap(&other->script_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &script_, lhs_arena, + &other->script_, rhs_arena + ); } ::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_WebAssemblyFunction::GetMetadata() const { @@ -9169,17 +8687,17 @@ Expression_EmbeddedFunction::_Internal::web_assembly_function(const Expression_E return *msg->kind_.web_assembly_function_; } void Expression_EmbeddedFunction::clear_output_type() { - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; } void Expression_EmbeddedFunction::set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (python_pickle_function) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(python_pickle_function); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_EmbeddedFunction_PythonPickleFunction>::GetOwningArena(python_pickle_function); if (message_arena != submessage_arena) { python_pickle_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, python_pickle_function, submessage_arena); @@ -9190,11 +8708,11 @@ void Expression_EmbeddedFunction::set_allocated_python_pickle_function(::substra // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.python_pickle_function) } void Expression_EmbeddedFunction::set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (web_assembly_function) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(web_assembly_function); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_EmbeddedFunction_WebAssemblyFunction>::GetOwningArena(web_assembly_function); if (message_arena != submessage_arena) { web_assembly_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, web_assembly_function, submessage_arena); @@ -9204,11 +8722,14 @@ void Expression_EmbeddedFunction::set_allocated_web_assembly_function(::substrai } // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.web_assembly_function) } -Expression_EmbeddedFunction::Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_EmbeddedFunction::Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), arguments_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction) } Expression_EmbeddedFunction::Expression_EmbeddedFunction(const Expression_EmbeddedFunction& from) @@ -9237,19 +8758,20 @@ Expression_EmbeddedFunction::Expression_EmbeddedFunction(const Expression_Embedd // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction) } -void Expression_EmbeddedFunction::SharedCtor() { +inline void Expression_EmbeddedFunction::SharedCtor() { output_type_ = nullptr; clear_has_kind(); } Expression_EmbeddedFunction::~Expression_EmbeddedFunction() { // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_EmbeddedFunction::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_EmbeddedFunction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete output_type_; if (has_kind()) { clear_kind(); @@ -9270,13 +8792,13 @@ void Expression_EmbeddedFunction::clear_kind() { // @@protoc_insertion_point(one_of_clear_start:substrait.Expression.EmbeddedFunction) switch (kind_case()) { case kPythonPickleFunction: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.python_pickle_function_; } break; } case kWebAssemblyFunction: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.web_assembly_function_; } break; @@ -9291,12 +8813,12 @@ void Expression_EmbeddedFunction::clear_kind() { void Expression_EmbeddedFunction::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; arguments_.Clear(); - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; @@ -9307,12 +8829,12 @@ void Expression_EmbeddedFunction::Clear() { const char* Expression_EmbeddedFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression arguments = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -9320,56 +8842,60 @@ const char* Expression_EmbeddedFunction::_InternalParse(const char* ptr, ::PROTO CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type output_type = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_python_pickle_function(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_web_assembly_function(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_EmbeddedFunction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression arguments = 1; @@ -9381,7 +8907,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_EmbeddedFunction::_InternalSerialize( } // .substrait.Type output_type = 2; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -9416,7 +8942,7 @@ size_t Expression_EmbeddedFunction::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -9428,7 +8954,7 @@ size_t Expression_EmbeddedFunction::ByteSizeLong() const { } // .substrait.Type output_type = 2; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *output_type_); @@ -9453,39 +8979,30 @@ size_t Expression_EmbeddedFunction::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_EmbeddedFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.EmbeddedFunction) - GOOGLE_DCHECK_NE(&from, this); - const Expression_EmbeddedFunction* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.EmbeddedFunction) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.EmbeddedFunction) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_EmbeddedFunction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_EmbeddedFunction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_EmbeddedFunction::GetClassData() const { return &_class_data_; } + +void Expression_EmbeddedFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_EmbeddedFunction::MergeFrom(const Expression_EmbeddedFunction& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; arguments_.MergeFrom(from.arguments_); - if (from.has_output_type()) { + if (from._internal_has_output_type()) { _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); } switch (from.kind_case()) { @@ -9501,13 +9018,7 @@ void Expression_EmbeddedFunction::MergeFrom(const Expression_EmbeddedFunction& f break; } } -} - -void Expression_EmbeddedFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.EmbeddedFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_EmbeddedFunction::CopyFrom(const Expression_EmbeddedFunction& from) { @@ -9523,7 +9034,7 @@ bool Expression_EmbeddedFunction::IsInitialized() const { void Expression_EmbeddedFunction::InternalSwap(Expression_EmbeddedFunction* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); arguments_.InternalSwap(&other->arguments_); swap(output_type_, other->output_type_); swap(kind_, other->kind_); @@ -9552,10 +9063,13 @@ const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::_Internal::child(const Expression_ReferenceSegment_MapKey* msg) { return *msg->child_; } -Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.MapKey) } Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(const Expression_ReferenceSegment_MapKey& from) @@ -9574,7 +9088,7 @@ Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(const Exp // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.MapKey) } -void Expression_ReferenceSegment_MapKey::SharedCtor() { +inline void Expression_ReferenceSegment_MapKey::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&map_key_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&child_) - @@ -9583,12 +9097,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_ReferenceSegment_MapKey::~Expression_ReferenceSegment_MapKey() { // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.MapKey) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_ReferenceSegment_MapKey::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_ReferenceSegment_MapKey::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete map_key_; if (this != internal_default_instance()) delete child_; } @@ -9605,15 +9120,15 @@ void Expression_ReferenceSegment_MapKey::SetCachedSize(int size) const { void Expression_ReferenceSegment_MapKey::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.MapKey) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && map_key_ != nullptr) { + if (GetArenaForAllocation() == nullptr && map_key_ != nullptr) { delete map_key_; } map_key_ = nullptr; - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -9623,54 +9138,56 @@ void Expression_ReferenceSegment_MapKey::Clear() { const char* Expression_ReferenceSegment_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.Literal map_key = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.ReferenceSegment child = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_MapKey::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_ReferenceSegment_MapKey::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.MapKey) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.Literal map_key = 1; - if (this->has_map_key()) { + if (this->_internal_has_map_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -9678,7 +9195,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_MapKey::_InternalSer } // .substrait.Expression.ReferenceSegment child = 2; - if (this->has_child()) { + if (this->_internal_has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -9697,68 +9214,53 @@ size_t Expression_ReferenceSegment_MapKey::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.MapKey) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Expression.Literal map_key = 1; - if (this->has_map_key()) { + if (this->_internal_has_map_key()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *map_key_); } // .substrait.Expression.ReferenceSegment child = 2; - if (this->has_child()) { + if (this->_internal_has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *child_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_ReferenceSegment_MapKey::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.ReferenceSegment.MapKey) - GOOGLE_DCHECK_NE(&from, this); - const Expression_ReferenceSegment_MapKey* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.ReferenceSegment.MapKey) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.ReferenceSegment.MapKey) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment_MapKey::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_ReferenceSegment_MapKey::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment_MapKey::GetClassData() const { return &_class_data_; } + +void Expression_ReferenceSegment_MapKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_ReferenceSegment_MapKey::MergeFrom(const Expression_ReferenceSegment_MapKey& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.MapKey) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_map_key()) { + if (from._internal_has_map_key()) { _internal_mutable_map_key()->::substrait::Expression_Literal::MergeFrom(from._internal_map_key()); } - if (from.has_child()) { + if (from._internal_has_child()) { _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); } -} - -void Expression_ReferenceSegment_MapKey::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.ReferenceSegment.MapKey) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_ReferenceSegment_MapKey::CopyFrom(const Expression_ReferenceSegment_MapKey& from) { @@ -9774,7 +9276,7 @@ bool Expression_ReferenceSegment_MapKey::IsInitialized() const { void Expression_ReferenceSegment_MapKey::InternalSwap(Expression_ReferenceSegment_MapKey* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_MapKey, child_) + sizeof(Expression_ReferenceSegment_MapKey::child_) @@ -9800,10 +9302,13 @@ const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::_Internal::child(const Expression_ReferenceSegment_StructField* msg) { return *msg->child_; } -Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.StructField) } Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(const Expression_ReferenceSegment_StructField& from) @@ -9818,7 +9323,7 @@ Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.StructField) } -void Expression_ReferenceSegment_StructField::SharedCtor() { +inline void Expression_ReferenceSegment_StructField::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&child_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&field_) - @@ -9827,12 +9332,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_ReferenceSegment_StructField::~Expression_ReferenceSegment_StructField() { // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.StructField) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_ReferenceSegment_StructField::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_ReferenceSegment_StructField::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete child_; } @@ -9848,11 +9354,11 @@ void Expression_ReferenceSegment_StructField::SetCachedSize(int size) const { void Expression_ReferenceSegment_StructField::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.StructField) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -9863,60 +9369,62 @@ void Expression_ReferenceSegment_StructField::Clear() { const char* Expression_ReferenceSegment_StructField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 field = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.ReferenceSegment child = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_StructField::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_ReferenceSegment_StructField::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.StructField) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 field = 1; - if (this->field() != 0) { + if (this->_internal_field() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); } // .substrait.Expression.ReferenceSegment child = 2; - if (this->has_child()) { + if (this->_internal_has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -9935,68 +9443,51 @@ size_t Expression_ReferenceSegment_StructField::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.StructField) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Expression.ReferenceSegment child = 2; - if (this->has_child()) { + if (this->_internal_has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *child_); } // int32 field = 1; - if (this->field() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_field()); + if (this->_internal_field() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_ReferenceSegment_StructField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.ReferenceSegment.StructField) - GOOGLE_DCHECK_NE(&from, this); - const Expression_ReferenceSegment_StructField* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.ReferenceSegment.StructField) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.ReferenceSegment.StructField) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment_StructField::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_ReferenceSegment_StructField::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment_StructField::GetClassData() const { return &_class_data_; } + +void Expression_ReferenceSegment_StructField::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_ReferenceSegment_StructField::MergeFrom(const Expression_ReferenceSegment_StructField& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.StructField) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_child()) { + if (from._internal_has_child()) { _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); } - if (from.field() != 0) { + if (from._internal_field() != 0) { _internal_set_field(from._internal_field()); } -} - -void Expression_ReferenceSegment_StructField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.ReferenceSegment.StructField) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_ReferenceSegment_StructField::CopyFrom(const Expression_ReferenceSegment_StructField& from) { @@ -10012,7 +9503,7 @@ bool Expression_ReferenceSegment_StructField::IsInitialized() const { void Expression_ReferenceSegment_StructField::InternalSwap(Expression_ReferenceSegment_StructField* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_StructField, field_) + sizeof(Expression_ReferenceSegment_StructField::field_) @@ -10038,10 +9529,13 @@ const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::_Internal::child(const Expression_ReferenceSegment_ListElement* msg) { return *msg->child_; } -Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.ListElement) } Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(const Expression_ReferenceSegment_ListElement& from) @@ -10056,7 +9550,7 @@ Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.ListElement) } -void Expression_ReferenceSegment_ListElement::SharedCtor() { +inline void Expression_ReferenceSegment_ListElement::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&child_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&offset_) - @@ -10065,12 +9559,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_ReferenceSegment_ListElement::~Expression_ReferenceSegment_ListElement() { // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.ListElement) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_ReferenceSegment_ListElement::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_ReferenceSegment_ListElement::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete child_; } @@ -10086,11 +9581,11 @@ void Expression_ReferenceSegment_ListElement::SetCachedSize(int size) const { void Expression_ReferenceSegment_ListElement::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.ListElement) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -10101,60 +9596,62 @@ void Expression_ReferenceSegment_ListElement::Clear() { const char* Expression_ReferenceSegment_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 offset = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.ReferenceSegment child = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment_ListElement::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_ReferenceSegment_ListElement::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.ListElement) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 offset = 1; - if (this->offset() != 0) { + if (this->_internal_offset() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_offset(), target); } // .substrait.Expression.ReferenceSegment child = 2; - if (this->has_child()) { + if (this->_internal_has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -10173,68 +9670,51 @@ size_t Expression_ReferenceSegment_ListElement::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.ListElement) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Expression.ReferenceSegment child = 2; - if (this->has_child()) { + if (this->_internal_has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *child_); } // int32 offset = 1; - if (this->offset() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_offset()); + if (this->_internal_offset() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_offset()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_ReferenceSegment_ListElement::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.ReferenceSegment.ListElement) - GOOGLE_DCHECK_NE(&from, this); - const Expression_ReferenceSegment_ListElement* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.ReferenceSegment.ListElement) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.ReferenceSegment.ListElement) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment_ListElement::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_ReferenceSegment_ListElement::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment_ListElement::GetClassData() const { return &_class_data_; } + +void Expression_ReferenceSegment_ListElement::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_ReferenceSegment_ListElement::MergeFrom(const Expression_ReferenceSegment_ListElement& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.ListElement) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_child()) { + if (from._internal_has_child()) { _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); } - if (from.offset() != 0) { + if (from._internal_offset() != 0) { _internal_set_offset(from._internal_offset()); } -} - -void Expression_ReferenceSegment_ListElement::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.ReferenceSegment.ListElement) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_ReferenceSegment_ListElement::CopyFrom(const Expression_ReferenceSegment_ListElement& from) { @@ -10250,7 +9730,7 @@ bool Expression_ReferenceSegment_ListElement::IsInitialized() const { void Expression_ReferenceSegment_ListElement::InternalSwap(Expression_ReferenceSegment_ListElement* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_ListElement, offset_) + sizeof(Expression_ReferenceSegment_ListElement::offset_) @@ -10287,11 +9767,11 @@ Expression_ReferenceSegment::_Internal::list_element(const Expression_ReferenceS return *msg->reference_type_.list_element_; } void Expression_ReferenceSegment::set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_reference_type(); if (map_key) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map_key); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_MapKey>::GetOwningArena(map_key); if (message_arena != submessage_arena) { map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, map_key, submessage_arena); @@ -10302,11 +9782,11 @@ void Expression_ReferenceSegment::set_allocated_map_key(::substrait::Expression_ // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.map_key) } void Expression_ReferenceSegment::set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_reference_type(); if (struct_field) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_field); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_StructField>::GetOwningArena(struct_field); if (message_arena != submessage_arena) { struct_field = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, struct_field, submessage_arena); @@ -10317,11 +9797,11 @@ void Expression_ReferenceSegment::set_allocated_struct_field(::substrait::Expres // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.struct_field) } void Expression_ReferenceSegment::set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_reference_type(); if (list_element) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list_element); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_ListElement>::GetOwningArena(list_element); if (message_arena != submessage_arena) { list_element = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, list_element, submessage_arena); @@ -10331,10 +9811,13 @@ void Expression_ReferenceSegment::set_allocated_list_element(::substrait::Expres } // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.list_element) } -Expression_ReferenceSegment::Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_ReferenceSegment::Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment) } Expression_ReferenceSegment::Expression_ReferenceSegment(const Expression_ReferenceSegment& from) @@ -10361,18 +9844,19 @@ Expression_ReferenceSegment::Expression_ReferenceSegment(const Expression_Refere // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment) } -void Expression_ReferenceSegment::SharedCtor() { +inline void Expression_ReferenceSegment::SharedCtor() { clear_has_reference_type(); } Expression_ReferenceSegment::~Expression_ReferenceSegment() { // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_ReferenceSegment::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_ReferenceSegment::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_reference_type()) { clear_reference_type(); } @@ -10392,19 +9876,19 @@ void Expression_ReferenceSegment::clear_reference_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.Expression.ReferenceSegment) switch (reference_type_case()) { case kMapKey: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reference_type_.map_key_; } break; } case kStructField: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reference_type_.struct_field_; } break; } case kListElement: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reference_type_.list_element_; } break; @@ -10419,7 +9903,7 @@ void Expression_ReferenceSegment::clear_reference_type() { void Expression_ReferenceSegment::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -10430,57 +9914,60 @@ void Expression_ReferenceSegment::Clear() { const char* Expression_ReferenceSegment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.ReferenceSegment.MapKey map_key = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.ReferenceSegment.StructField struct_field = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_struct_field(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.ReferenceSegment.ListElement list_element = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_list_element(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_ReferenceSegment::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_ReferenceSegment::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.ReferenceSegment.MapKey map_key = 1; @@ -10519,7 +10006,7 @@ size_t Expression_ReferenceSegment::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -10549,35 +10036,26 @@ size_t Expression_ReferenceSegment::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_ReferenceSegment::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.ReferenceSegment) - GOOGLE_DCHECK_NE(&from, this); - const Expression_ReferenceSegment* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.ReferenceSegment) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.ReferenceSegment) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_ReferenceSegment::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment::GetClassData() const { return &_class_data_; } + +void Expression_ReferenceSegment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_ReferenceSegment::MergeFrom(const Expression_ReferenceSegment& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.reference_type_case()) { @@ -10597,13 +10075,7 @@ void Expression_ReferenceSegment::MergeFrom(const Expression_ReferenceSegment& f break; } } -} - -void Expression_ReferenceSegment::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.ReferenceSegment) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_ReferenceSegment::CopyFrom(const Expression_ReferenceSegment& from) { @@ -10619,7 +10091,7 @@ bool Expression_ReferenceSegment::IsInitialized() const { void Expression_ReferenceSegment::InternalSwap(Expression_ReferenceSegment* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(reference_type_, other->reference_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -10652,11 +10124,11 @@ Expression_MaskExpression_Select::_Internal::map(const Expression_MaskExpression return *msg->type_.map_; } void Expression_MaskExpression_Select::set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_type(); if (struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_StructSelect>::GetOwningArena(struct_); if (message_arena != submessage_arena) { struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, struct_, submessage_arena); @@ -10667,11 +10139,11 @@ void Expression_MaskExpression_Select::set_allocated_struct_(::substrait::Expres // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.struct) } void Expression_MaskExpression_Select::set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_type(); if (list) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect>::GetOwningArena(list); if (message_arena != submessage_arena) { list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, list, submessage_arena); @@ -10682,11 +10154,11 @@ void Expression_MaskExpression_Select::set_allocated_list(::substrait::Expressio // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.list) } void Expression_MaskExpression_Select::set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_type(); if (map) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect>::GetOwningArena(map); if (message_arena != submessage_arena) { map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, map, submessage_arena); @@ -10696,10 +10168,13 @@ void Expression_MaskExpression_Select::set_allocated_map(::substrait::Expression } // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.map) } -Expression_MaskExpression_Select::Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_MaskExpression_Select::Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.Select) } Expression_MaskExpression_Select::Expression_MaskExpression_Select(const Expression_MaskExpression_Select& from) @@ -10726,18 +10201,19 @@ Expression_MaskExpression_Select::Expression_MaskExpression_Select(const Express // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.Select) } -void Expression_MaskExpression_Select::SharedCtor() { +inline void Expression_MaskExpression_Select::SharedCtor() { clear_has_type(); } Expression_MaskExpression_Select::~Expression_MaskExpression_Select() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.Select) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression_Select::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression_Select::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_type()) { clear_type(); } @@ -10757,19 +10233,19 @@ void Expression_MaskExpression_Select::clear_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.Select) switch (type_case()) { case kStruct: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete type_.struct__; } break; } case kList: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete type_.list_; } break; } case kMap: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete type_.map_; } break; @@ -10784,7 +10260,7 @@ void Expression_MaskExpression_Select::clear_type() { void Expression_MaskExpression_Select::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.Select) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -10795,57 +10271,60 @@ void Expression_MaskExpression_Select::Clear() { const char* Expression_MaskExpression_Select::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.MaskExpression.StructSelect struct = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.MaskExpression.ListSelect list = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.MaskExpression.MapSelect map = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_Select::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression_Select::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.Select) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.MaskExpression.StructSelect struct = 1; @@ -10884,7 +10363,7 @@ size_t Expression_MaskExpression_Select::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.Select) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -10914,35 +10393,26 @@ size_t Expression_MaskExpression_Select::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression_Select::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.Select) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression_Select* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.Select) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.Select) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_Select::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression_Select::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_Select::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression_Select::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression_Select::MergeFrom(const Expression_MaskExpression_Select& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.Select) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.type_case()) { @@ -10962,13 +10432,7 @@ void Expression_MaskExpression_Select::MergeFrom(const Expression_MaskExpression break; } } -} - -void Expression_MaskExpression_Select::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.Select) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression_Select::CopyFrom(const Expression_MaskExpression_Select& from) { @@ -10984,7 +10448,7 @@ bool Expression_MaskExpression_Select::IsInitialized() const { void Expression_MaskExpression_Select::InternalSwap(Expression_MaskExpression_Select* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(type_, other->type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -11001,11 +10465,14 @@ class Expression_MaskExpression_StructSelect::_Internal { public: }; -Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), struct_items_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.StructSelect) } Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(const Expression_MaskExpression_StructSelect& from) @@ -11015,17 +10482,18 @@ Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(c // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.StructSelect) } -void Expression_MaskExpression_StructSelect::SharedCtor() { +inline void Expression_MaskExpression_StructSelect::SharedCtor() { } Expression_MaskExpression_StructSelect::~Expression_MaskExpression_StructSelect() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.StructSelect) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression_StructSelect::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression_StructSelect::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_MaskExpression_StructSelect::ArenaDtor(void* object) { @@ -11040,7 +10508,7 @@ void Expression_MaskExpression_StructSelect::SetCachedSize(int size) const { void Expression_MaskExpression_StructSelect::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.StructSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11051,12 +10519,12 @@ void Expression_MaskExpression_StructSelect::Clear() { const char* Expression_MaskExpression_StructSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -11064,35 +10532,36 @@ const char* Expression_MaskExpression_StructSelect::_InternalParse(const char* p CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_StructSelect::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression_StructSelect::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.StructSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; @@ -11115,7 +10584,7 @@ size_t Expression_MaskExpression_StructSelect::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.StructSelect) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11126,45 +10595,30 @@ size_t Expression_MaskExpression_StructSelect::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression_StructSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.StructSelect) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression_StructSelect* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.StructSelect) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.StructSelect) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_StructSelect::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression_StructSelect::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_StructSelect::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression_StructSelect::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression_StructSelect::MergeFrom(const Expression_MaskExpression_StructSelect& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.StructSelect) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; struct_items_.MergeFrom(from.struct_items_); -} - -void Expression_MaskExpression_StructSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.StructSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression_StructSelect::CopyFrom(const Expression_MaskExpression_StructSelect& from) { @@ -11180,7 +10634,7 @@ bool Expression_MaskExpression_StructSelect::IsInitialized() const { void Expression_MaskExpression_StructSelect::InternalSwap(Expression_MaskExpression_StructSelect* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); struct_items_.InternalSwap(&other->struct_items_); } @@ -11201,10 +10655,13 @@ const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::_Internal::child(const Expression_MaskExpression_StructItem* msg) { return *msg->child_; } -Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.StructItem) } Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(const Expression_MaskExpression_StructItem& from) @@ -11219,7 +10676,7 @@ Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(const // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.StructItem) } -void Expression_MaskExpression_StructItem::SharedCtor() { +inline void Expression_MaskExpression_StructItem::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&child_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&field_) - @@ -11228,12 +10685,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_MaskExpression_StructItem::~Expression_MaskExpression_StructItem() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.StructItem) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression_StructItem::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression_StructItem::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete child_; } @@ -11249,11 +10707,11 @@ void Expression_MaskExpression_StructItem::SetCachedSize(int size) const { void Expression_MaskExpression_StructItem::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.StructItem) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -11264,60 +10722,62 @@ void Expression_MaskExpression_StructItem::Clear() { const char* Expression_MaskExpression_StructItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 field = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.MaskExpression.Select child = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_StructItem::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression_StructItem::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.StructItem) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 field = 1; - if (this->field() != 0) { + if (this->_internal_field() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); } // .substrait.Expression.MaskExpression.Select child = 2; - if (this->has_child()) { + if (this->_internal_has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -11336,68 +10796,51 @@ size_t Expression_MaskExpression_StructItem::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.StructItem) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Expression.MaskExpression.Select child = 2; - if (this->has_child()) { + if (this->_internal_has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *child_); } // int32 field = 1; - if (this->field() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_field()); + if (this->_internal_field() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression_StructItem::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.StructItem) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression_StructItem* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.StructItem) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.StructItem) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_StructItem::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression_StructItem::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_StructItem::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression_StructItem::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression_StructItem::MergeFrom(const Expression_MaskExpression_StructItem& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.StructItem) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_child()) { + if (from._internal_has_child()) { _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); } - if (from.field() != 0) { + if (from._internal_field() != 0) { _internal_set_field(from._internal_field()); } -} - -void Expression_MaskExpression_StructItem::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.StructItem) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression_StructItem::CopyFrom(const Expression_MaskExpression_StructItem& from) { @@ -11413,7 +10856,7 @@ bool Expression_MaskExpression_StructItem::IsInitialized() const { void Expression_MaskExpression_StructItem::InternalSwap(Expression_MaskExpression_StructItem* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_StructItem, field_) + sizeof(Expression_MaskExpression_StructItem::field_) @@ -11434,10 +10877,13 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_Internal public: }; -Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) } Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) @@ -11447,18 +10893,19 @@ Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_Mask // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) } -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedCtor() { +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedCtor() { field_ = 0; } Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::~Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ArenaDtor(void* object) { @@ -11473,7 +10920,7 @@ void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SetCachedS void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11484,47 +10931,48 @@ void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Clear() { const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 field = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 field = 1; - if (this->field() != 0) { + if (this->_internal_field() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); } @@ -11541,58 +10989,41 @@ size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ByteSize // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int32 field = 1; - if (this->field() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_field()); + if (this->_internal_field() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.field() != 0) { + if (from._internal_field() != 0) { _internal_set_field(from._internal_field()); } -} - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) { @@ -11608,7 +11039,7 @@ bool Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::IsInitiali void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(field_, other->field_); } @@ -11624,10 +11055,13 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_Internal { public: }; -Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) } Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) @@ -11639,7 +11073,7 @@ Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskEx // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) } -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedCtor() { +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&start_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&end_) - @@ -11648,12 +11082,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::~Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ArenaDtor(void* object) { @@ -11668,7 +11103,7 @@ void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SetCachedSiz void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11681,60 +11116,62 @@ void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Clear() { const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 start = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 end = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 start = 1; - if (this->start() != 0) { + if (this->_internal_start() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_start(), target); } // int32 end = 2; - if (this->end() != 0) { + if (this->_internal_end() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end(), target); } @@ -11751,68 +11188,49 @@ size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ByteSizeLo // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int32 start = 1; - if (this->start() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_start()); + if (this->_internal_start() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_start()); } // int32 end = 2; - if (this->end() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_end()); + if (this->_internal_end() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_end()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.start() != 0) { + if (from._internal_start() != 0) { _internal_set_start(from._internal_start()); } - if (from.end() != 0) { + if (from._internal_end() != 0) { _internal_set_end(from._internal_end()); } -} - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { @@ -11828,7 +11246,7 @@ bool Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::IsInitialize void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_) + sizeof(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::end_) @@ -11860,11 +11278,11 @@ Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::slice(const Expr return *msg->type_.slice_; } void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_type(); if (item) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(item); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement>::GetOwningArena(item); if (message_arena != submessage_arena) { item = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, item, submessage_arena); @@ -11875,11 +11293,11 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::s // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) } void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_type(); if (slice) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(slice); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice>::GetOwningArena(slice); if (message_arena != submessage_arena) { slice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, slice, submessage_arena); @@ -11889,10 +11307,13 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(:: } // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) } -Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) } Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(const Expression_MaskExpression_ListSelect_ListSelectItem& from) @@ -11915,18 +11336,19 @@ Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_L // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) } -void Expression_MaskExpression_ListSelect_ListSelectItem::SharedCtor() { +inline void Expression_MaskExpression_ListSelect_ListSelectItem::SharedCtor() { clear_has_type(); } Expression_MaskExpression_ListSelect_ListSelectItem::~Expression_MaskExpression_ListSelect_ListSelectItem() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression_ListSelect_ListSelectItem::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression_ListSelect_ListSelectItem::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_type()) { clear_type(); } @@ -11946,13 +11368,13 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::clear_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) switch (type_case()) { case kItem: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete type_.item_; } break; } case kSlice: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete type_.slice_; } break; @@ -11967,7 +11389,7 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::clear_type() { void Expression_MaskExpression_ListSelect_ListSelectItem::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -11978,50 +11400,52 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::Clear() { const char* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_item(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_slice(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; @@ -12052,7 +11476,7 @@ size_t Expression_MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -12075,35 +11499,26 @@ size_t Expression_MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression_ListSelect_ListSelectItem* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect_ListSelectItem::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression_ListSelect_ListSelectItem::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect_ListSelectItem::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression_ListSelect_ListSelectItem::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.type_case()) { @@ -12119,13 +11534,7 @@ void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const Expres break; } } -} - -void Expression_MaskExpression_ListSelect_ListSelectItem::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression_ListSelect_ListSelectItem::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) { @@ -12141,7 +11550,7 @@ bool Expression_MaskExpression_ListSelect_ListSelectItem::IsInitialized() const void Expression_MaskExpression_ListSelect_ListSelectItem::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(type_, other->type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -12163,11 +11572,14 @@ const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::_Internal::child(const Expression_MaskExpression_ListSelect* msg) { return *msg->child_; } -Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), selection_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect) } Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(const Expression_MaskExpression_ListSelect& from) @@ -12182,18 +11594,19 @@ Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(const // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect) } -void Expression_MaskExpression_ListSelect::SharedCtor() { +inline void Expression_MaskExpression_ListSelect::SharedCtor() { child_ = nullptr; } Expression_MaskExpression_ListSelect::~Expression_MaskExpression_ListSelect() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression_ListSelect::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression_ListSelect::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete child_; } @@ -12209,12 +11622,12 @@ void Expression_MaskExpression_ListSelect::SetCachedSize(int size) const { void Expression_MaskExpression_ListSelect::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; selection_.Clear(); - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -12224,12 +11637,12 @@ void Expression_MaskExpression_ListSelect::Clear() { const char* Expression_MaskExpression_ListSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -12237,42 +11650,44 @@ const char* Expression_MaskExpression_ListSelect::_InternalParse(const char* ptr CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.MaskExpression.Select child = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression_ListSelect::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; @@ -12284,7 +11699,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_ListSelect::_InternalS } // .substrait.Expression.MaskExpression.Select child = 2; - if (this->has_child()) { + if (this->_internal_has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -12303,7 +11718,7 @@ size_t Expression_MaskExpression_ListSelect::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -12315,54 +11730,39 @@ size_t Expression_MaskExpression_ListSelect::ByteSizeLong() const { } // .substrait.Expression.MaskExpression.Select child = 2; - if (this->has_child()) { + if (this->_internal_has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *child_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression_ListSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.ListSelect) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression_ListSelect* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.ListSelect) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.ListSelect) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression_ListSelect::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression_ListSelect::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression_ListSelect::MergeFrom(const Expression_MaskExpression_ListSelect& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; selection_.MergeFrom(from.selection_); - if (from.has_child()) { + if (from._internal_has_child()) { _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); } -} - -void Expression_MaskExpression_ListSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.ListSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression_ListSelect::CopyFrom(const Expression_MaskExpression_ListSelect& from) { @@ -12378,7 +11778,7 @@ bool Expression_MaskExpression_ListSelect::IsInitialized() const { void Expression_MaskExpression_ListSelect::InternalSwap(Expression_MaskExpression_ListSelect* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); selection_.InternalSwap(&other->selection_); swap(child_, other->child_); } @@ -12395,35 +11795,45 @@ class Expression_MaskExpression_MapSelect_MapKey::_Internal { public: }; -Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect.MapKey) } Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(const Expression_MaskExpression_MapSelect_MapKey& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_map_key().empty()) { map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key(), - GetArena()); + GetArenaForAllocation()); } // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect.MapKey) } -void Expression_MaskExpression_MapSelect_MapKey::SharedCtor() { +inline void Expression_MaskExpression_MapSelect_MapKey::SharedCtor() { map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } Expression_MaskExpression_MapSelect_MapKey::~Expression_MaskExpression_MapSelect_MapKey() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect.MapKey) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression_MapSelect_MapKey::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression_MapSelect_MapKey::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); map_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -12439,7 +11849,7 @@ void Expression_MaskExpression_MapSelect_MapKey::SetCachedSize(int size) const { void Expression_MaskExpression_MapSelect_MapKey::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect.MapKey) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -12450,49 +11860,50 @@ void Expression_MaskExpression_MapSelect_MapKey::Clear() { const char* Expression_MaskExpression_MapSelect_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string map_key = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_map_key(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.MaskExpression.MapSelect.MapKey.map_key")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect_MapKey::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression_MapSelect_MapKey::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect.MapKey) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string map_key = 1; - if (this->map_key().size() > 0) { + if (!this->_internal_map_key().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_map_key().data(), static_cast(this->_internal_map_key().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -12513,58 +11924,43 @@ size_t Expression_MaskExpression_MapSelect_MapKey::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect.MapKey) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string map_key = 1; - if (this->map_key().size() > 0) { + if (!this->_internal_map_key().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_map_key()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression_MapSelect_MapKey::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression_MapSelect_MapKey* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.MapSelect.MapKey) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.MapSelect.MapKey) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_MapSelect_MapKey::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression_MapSelect_MapKey::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_MapSelect_MapKey::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression_MapSelect_MapKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression_MapSelect_MapKey::MergeFrom(const Expression_MaskExpression_MapSelect_MapKey& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.map_key().size() > 0) { + if (!from._internal_map_key().empty()) { _internal_set_map_key(from._internal_map_key()); } -} - -void Expression_MaskExpression_MapSelect_MapKey::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression_MapSelect_MapKey::CopyFrom(const Expression_MaskExpression_MapSelect_MapKey& from) { @@ -12580,8 +11976,14 @@ bool Expression_MaskExpression_MapSelect_MapKey::IsInitialized() const { void Expression_MaskExpression_MapSelect_MapKey::InternalSwap(Expression_MaskExpression_MapSelect_MapKey* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - map_key_.Swap(&other->map_key_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &map_key_, lhs_arena, + &other->map_key_, rhs_arena + ); } ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKey::GetMetadata() const { @@ -12596,35 +11998,45 @@ class Expression_MaskExpression_MapSelect_MapKeyExpression::_Internal { public: }; -Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) } Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_map_key_expression().empty()) { map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key_expression(), - GetArena()); + GetArenaForAllocation()); } // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) } -void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedCtor() { +inline void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedCtor() { map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } Expression_MaskExpression_MapSelect_MapKeyExpression::~Expression_MaskExpression_MapSelect_MapKeyExpression() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); map_key_expression_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -12640,7 +12052,7 @@ void Expression_MaskExpression_MapSelect_MapKeyExpression::SetCachedSize(int siz void Expression_MaskExpression_MapSelect_MapKeyExpression::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -12651,49 +12063,50 @@ void Expression_MaskExpression_MapSelect_MapKeyExpression::Clear() { const char* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string map_key_expression = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_map_key_expression(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string map_key_expression = 1; - if (this->map_key_expression().size() > 0) { + if (!this->_internal_map_key_expression().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_map_key_expression().data(), static_cast(this->_internal_map_key_expression().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -12714,58 +12127,43 @@ size_t Expression_MaskExpression_MapSelect_MapKeyExpression::ByteSizeLong() cons // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string map_key_expression = 1; - if (this->map_key_expression().size() > 0) { + if (!this->_internal_map_key_expression().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_map_key_expression()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression_MapSelect_MapKeyExpression* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_MapSelect_MapKeyExpression::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression_MapSelect_MapKeyExpression::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_MapSelect_MapKeyExpression::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.map_key_expression().size() > 0) { + if (!from._internal_map_key_expression().empty()) { _internal_set_map_key_expression(from._internal_map_key_expression()); } -} - -void Expression_MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) { @@ -12781,8 +12179,14 @@ bool Expression_MaskExpression_MapSelect_MapKeyExpression::IsInitialized() const void Expression_MaskExpression_MapSelect_MapKeyExpression::InternalSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - map_key_expression_.Swap(&other->map_key_expression_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &map_key_expression_, lhs_arena, + &other->map_key_expression_, rhs_arena + ); } ::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKeyExpression::GetMetadata() const { @@ -12813,11 +12217,11 @@ Expression_MaskExpression_MapSelect::_Internal::child(const Expression_MaskExpre return *msg->child_; } void Expression_MaskExpression_MapSelect::set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_select(); if (key) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect_MapKey>::GetOwningArena(key); if (message_arena != submessage_arena) { key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, key, submessage_arena); @@ -12828,11 +12232,11 @@ void Expression_MaskExpression_MapSelect::set_allocated_key(::substrait::Express // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.key) } void Expression_MaskExpression_MapSelect::set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_select(); if (expression) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expression); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression>::GetOwningArena(expression); if (message_arena != submessage_arena) { expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expression, submessage_arena); @@ -12842,10 +12246,13 @@ void Expression_MaskExpression_MapSelect::set_allocated_expression(::substrait:: } // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.expression) } -Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect) } Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(const Expression_MaskExpression_MapSelect& from) @@ -12873,19 +12280,20 @@ Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(const E // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect) } -void Expression_MaskExpression_MapSelect::SharedCtor() { +inline void Expression_MaskExpression_MapSelect::SharedCtor() { child_ = nullptr; clear_has_select(); } Expression_MaskExpression_MapSelect::~Expression_MaskExpression_MapSelect() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression_MapSelect::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression_MapSelect::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete child_; if (has_select()) { clear_select(); @@ -12906,13 +12314,13 @@ void Expression_MaskExpression_MapSelect::clear_select() { // @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.MapSelect) switch (select_case()) { case kKey: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete select_.key_; } break; } case kExpression: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete select_.expression_; } break; @@ -12927,11 +12335,11 @@ void Expression_MaskExpression_MapSelect::clear_select() { void Expression_MaskExpression_MapSelect::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -12942,57 +12350,60 @@ void Expression_MaskExpression_MapSelect::Clear() { const char* Expression_MaskExpression_MapSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.MaskExpression.Select child = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression_MapSelect::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; @@ -13012,7 +12423,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression_MapSelect::_InternalSe } // .substrait.Expression.MaskExpression.Select child = 3; - if (this->has_child()) { + if (this->_internal_has_child()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -13031,12 +12442,12 @@ size_t Expression_MaskExpression_MapSelect::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Expression.MaskExpression.Select child = 3; - if (this->has_child()) { + if (this->_internal_has_child()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *child_); @@ -13061,38 +12472,29 @@ size_t Expression_MaskExpression_MapSelect::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression_MapSelect::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression.MapSelect) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression_MapSelect* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression.MapSelect) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression.MapSelect) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_MapSelect::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression_MapSelect::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_MapSelect::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression_MapSelect::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression_MapSelect::MergeFrom(const Expression_MaskExpression_MapSelect& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_child()) { + if (from._internal_has_child()) { _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); } switch (from.select_case()) { @@ -13108,13 +12510,7 @@ void Expression_MaskExpression_MapSelect::MergeFrom(const Expression_MaskExpress break; } } -} - -void Expression_MaskExpression_MapSelect::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression.MapSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression_MapSelect::CopyFrom(const Expression_MaskExpression_MapSelect& from) { @@ -13130,7 +12526,7 @@ bool Expression_MaskExpression_MapSelect::IsInitialized() const { void Expression_MaskExpression_MapSelect::InternalSwap(Expression_MaskExpression_MapSelect* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(child_, other->child_); swap(select_, other->select_); swap(_oneof_case_[0], other->_oneof_case_[0]); @@ -13153,10 +12549,13 @@ const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::_Internal::select(const Expression_MaskExpression* msg) { return *msg->select_; } -Expression_MaskExpression::Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_MaskExpression::Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression) } Expression_MaskExpression::Expression_MaskExpression(const Expression_MaskExpression& from) @@ -13171,7 +12570,7 @@ Expression_MaskExpression::Expression_MaskExpression(const Expression_MaskExpres // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression) } -void Expression_MaskExpression::SharedCtor() { +inline void Expression_MaskExpression::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&select_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&maintain_singular_struct_) - @@ -13180,12 +12579,13 @@ ::memset(reinterpret_cast(this) + static_cast( Expression_MaskExpression::~Expression_MaskExpression() { // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_MaskExpression::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_MaskExpression::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete select_; } @@ -13201,11 +12601,11 @@ void Expression_MaskExpression::SetCachedSize(int size) const { void Expression_MaskExpression::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && select_ != nullptr) { + if (GetArenaForAllocation() == nullptr && select_ != nullptr) { delete select_; } select_ = nullptr; @@ -13216,54 +12616,56 @@ void Expression_MaskExpression::Clear() { const char* Expression_MaskExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.MaskExpression.StructSelect select = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_select(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool maintain_singular_struct = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { maintain_singular_struct_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_MaskExpression::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.MaskExpression.StructSelect select = 1; - if (this->has_select()) { + if (this->_internal_has_select()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -13271,7 +12673,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Expression_MaskExpression::_InternalSerialize( } // bool maintain_singular_struct = 2; - if (this->maintain_singular_struct() != 0) { + if (this->_internal_maintain_singular_struct() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_maintain_singular_struct(), target); } @@ -13288,66 +12690,51 @@ size_t Expression_MaskExpression::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Expression.MaskExpression.StructSelect select = 1; - if (this->has_select()) { + if (this->_internal_has_select()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *select_); } // bool maintain_singular_struct = 2; - if (this->maintain_singular_struct() != 0) { + if (this->_internal_maintain_singular_struct() != 0) { total_size += 1 + 1; } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_MaskExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.MaskExpression) - GOOGLE_DCHECK_NE(&from, this); - const Expression_MaskExpression* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.MaskExpression) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.MaskExpression) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_MaskExpression::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression::GetClassData() const { return &_class_data_; } + +void Expression_MaskExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_MaskExpression::MergeFrom(const Expression_MaskExpression& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_select()) { + if (from._internal_has_select()) { _internal_mutable_select()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_select()); } - if (from.maintain_singular_struct() != 0) { + if (from._internal_maintain_singular_struct() != 0) { _internal_set_maintain_singular_struct(from._internal_maintain_singular_struct()); } -} - -void Expression_MaskExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.MaskExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_MaskExpression::CopyFrom(const Expression_MaskExpression& from) { @@ -13363,7 +12750,7 @@ bool Expression_MaskExpression::IsInitialized() const { void Expression_MaskExpression::InternalSwap(Expression_MaskExpression* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Expression_MaskExpression, maintain_singular_struct_) + sizeof(Expression_MaskExpression::maintain_singular_struct_) @@ -13384,151 +12771,32 @@ class Expression_FieldReference_RootReference::_Internal { public: }; -Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); +Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { // @@protoc_insertion_point(arena_constructor:substrait.Expression.FieldReference.RootReference) } Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(const Expression_FieldReference_RootReference& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference.RootReference) } -void Expression_FieldReference_RootReference::SharedCtor() { -} - -Expression_FieldReference_RootReference::~Expression_FieldReference_RootReference() { - // @@protoc_insertion_point(destructor:substrait.Expression.FieldReference.RootReference) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void Expression_FieldReference_RootReference::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void Expression_FieldReference_RootReference::ArenaDtor(void* object) { - Expression_FieldReference_RootReference* _this = reinterpret_cast< Expression_FieldReference_RootReference* >(object); - (void)_this; -} -void Expression_FieldReference_RootReference::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_FieldReference_RootReference::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_FieldReference_RootReference::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.FieldReference.RootReference) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_FieldReference_RootReference::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference_RootReference::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.FieldReference.RootReference) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.FieldReference.RootReference) - return target; -} -size_t Expression_FieldReference_RootReference::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.FieldReference.RootReference) - size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} -void Expression_FieldReference_RootReference::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.FieldReference.RootReference) - GOOGLE_DCHECK_NE(&from, this); - const Expression_FieldReference_RootReference* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.FieldReference.RootReference) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.FieldReference.RootReference) - MergeFrom(*source); - } -} +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_FieldReference_RootReference::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_FieldReference_RootReference::GetClassData() const { return &_class_data_; } -void Expression_FieldReference_RootReference::MergeFrom(const Expression_FieldReference_RootReference& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.FieldReference.RootReference) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; -} -void Expression_FieldReference_RootReference::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.FieldReference.RootReference) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -void Expression_FieldReference_RootReference::CopyFrom(const Expression_FieldReference_RootReference& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.FieldReference.RootReference) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -bool Expression_FieldReference_RootReference::IsInitialized() const { - return true; -} -void Expression_FieldReference_RootReference::InternalSwap(Expression_FieldReference_RootReference* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); -} ::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference_RootReference::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( @@ -13563,11 +12831,11 @@ Expression_FieldReference::_Internal::root_reference(const Expression_FieldRefer return *msg->root_type_.root_reference_; } void Expression_FieldReference::set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_reference_type(); if (direct_reference) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(direct_reference); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(direct_reference); if (message_arena != submessage_arena) { direct_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, direct_reference, submessage_arena); @@ -13578,11 +12846,11 @@ void Expression_FieldReference::set_allocated_direct_reference(::substrait::Expr // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.direct_reference) } void Expression_FieldReference::set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_reference_type(); if (masked_reference) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(masked_reference); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression>::GetOwningArena(masked_reference); if (message_arena != submessage_arena) { masked_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, masked_reference, submessage_arena); @@ -13593,11 +12861,11 @@ void Expression_FieldReference::set_allocated_masked_reference(::substrait::Expr // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.masked_reference) } void Expression_FieldReference::set_allocated_expression(::substrait::Expression* expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_root_type(); if (expression) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expression); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(expression); if (message_arena != submessage_arena) { expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expression, submessage_arena); @@ -13608,11 +12876,11 @@ void Expression_FieldReference::set_allocated_expression(::substrait::Expression // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.expression) } void Expression_FieldReference::set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_root_type(); if (root_reference) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(root_reference); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_FieldReference_RootReference>::GetOwningArena(root_reference); if (message_arena != submessage_arena) { root_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, root_reference, submessage_arena); @@ -13622,10 +12890,13 @@ void Expression_FieldReference::set_allocated_root_reference(::substrait::Expres } // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.root_reference) } -Expression_FieldReference::Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression_FieldReference::Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression.FieldReference) } Expression_FieldReference::Expression_FieldReference(const Expression_FieldReference& from) @@ -13662,19 +12933,20 @@ Expression_FieldReference::Expression_FieldReference(const Expression_FieldRefer // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference) } -void Expression_FieldReference::SharedCtor() { +inline void Expression_FieldReference::SharedCtor() { clear_has_reference_type(); clear_has_root_type(); } Expression_FieldReference::~Expression_FieldReference() { // @@protoc_insertion_point(destructor:substrait.Expression.FieldReference) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression_FieldReference::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression_FieldReference::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_reference_type()) { clear_reference_type(); } @@ -13697,13 +12969,13 @@ void Expression_FieldReference::clear_reference_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.Expression.FieldReference) switch (reference_type_case()) { case kDirectReference: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reference_type_.direct_reference_; } break; } case kMaskedReference: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reference_type_.masked_reference_; } break; @@ -13719,13 +12991,13 @@ void Expression_FieldReference::clear_root_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.Expression.FieldReference) switch (root_type_case()) { case kExpression: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete root_type_.expression_; } break; } case kRootReference: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete root_type_.root_reference_; } break; @@ -13740,7 +13012,7 @@ void Expression_FieldReference::clear_root_type() { void Expression_FieldReference::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression.FieldReference) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -13752,64 +13024,68 @@ void Expression_FieldReference::Clear() { const char* Expression_FieldReference::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.ReferenceSegment direct_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_direct_reference(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.MaskExpression masked_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_masked_reference(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression expression = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.FieldReference.RootReference root_reference = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_root_reference(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression_FieldReference::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression_FieldReference::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.FieldReference) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.ReferenceSegment direct_reference = 1; @@ -13856,7 +13132,7 @@ size_t Expression_FieldReference::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression.FieldReference) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -13898,35 +13174,26 @@ size_t Expression_FieldReference::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression_FieldReference::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression.FieldReference) - GOOGLE_DCHECK_NE(&from, this); - const Expression_FieldReference* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression.FieldReference) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression.FieldReference) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_FieldReference::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression_FieldReference::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_FieldReference::GetClassData() const { return &_class_data_; } + +void Expression_FieldReference::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression_FieldReference::MergeFrom(const Expression_FieldReference& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.FieldReference) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.reference_type_case()) { @@ -13955,13 +13222,7 @@ void Expression_FieldReference::MergeFrom(const Expression_FieldReference& from) break; } } -} - -void Expression_FieldReference::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression.FieldReference) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression_FieldReference::CopyFrom(const Expression_FieldReference& from) { @@ -13977,7 +13238,7 @@ bool Expression_FieldReference::IsInitialized() const { void Expression_FieldReference::InternalSwap(Expression_FieldReference* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(reference_type_, other->reference_type_); swap(root_type_, other->root_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); @@ -14047,11 +13308,11 @@ Expression::_Internal::cast(const Expression* msg) { return *msg->rex_type_.cast_; } void Expression::set_allocated_literal(::substrait::Expression_Literal* literal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rex_type(); if (literal) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(literal); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(literal); if (message_arena != submessage_arena) { literal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, literal, submessage_arena); @@ -14062,11 +13323,11 @@ void Expression::set_allocated_literal(::substrait::Expression_Literal* literal) // @@protoc_insertion_point(field_set_allocated:substrait.Expression.literal) } void Expression::set_allocated_selection(::substrait::Expression_FieldReference* selection) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rex_type(); if (selection) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(selection); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_FieldReference>::GetOwningArena(selection); if (message_arena != submessage_arena) { selection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, selection, submessage_arena); @@ -14077,11 +13338,11 @@ void Expression::set_allocated_selection(::substrait::Expression_FieldReference* // @@protoc_insertion_point(field_set_allocated:substrait.Expression.selection) } void Expression::set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rex_type(); if (scalar_function) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(scalar_function); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ScalarFunction>::GetOwningArena(scalar_function); if (message_arena != submessage_arena) { scalar_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, scalar_function, submessage_arena); @@ -14092,11 +13353,11 @@ void Expression::set_allocated_scalar_function(::substrait::Expression_ScalarFun // @@protoc_insertion_point(field_set_allocated:substrait.Expression.scalar_function) } void Expression::set_allocated_window_function(::substrait::Expression_WindowFunction* window_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rex_type(); if (window_function) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(window_function); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction>::GetOwningArena(window_function); if (message_arena != submessage_arena) { window_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, window_function, submessage_arena); @@ -14107,11 +13368,11 @@ void Expression::set_allocated_window_function(::substrait::Expression_WindowFun // @@protoc_insertion_point(field_set_allocated:substrait.Expression.window_function) } void Expression::set_allocated_if_then(::substrait::Expression_IfThen* if_then) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rex_type(); if (if_then) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_then); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_IfThen>::GetOwningArena(if_then); if (message_arena != submessage_arena) { if_then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, if_then, submessage_arena); @@ -14122,11 +13383,11 @@ void Expression::set_allocated_if_then(::substrait::Expression_IfThen* if_then) // @@protoc_insertion_point(field_set_allocated:substrait.Expression.if_then) } void Expression::set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rex_type(); if (switch_expression) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(switch_expression); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_SwitchExpression>::GetOwningArena(switch_expression); if (message_arena != submessage_arena) { switch_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, switch_expression, submessage_arena); @@ -14137,11 +13398,11 @@ void Expression::set_allocated_switch_expression(::substrait::Expression_SwitchE // @@protoc_insertion_point(field_set_allocated:substrait.Expression.switch_expression) } void Expression::set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rex_type(); if (singular_or_list) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(singular_or_list); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_SingularOrList>::GetOwningArena(singular_or_list); if (message_arena != submessage_arena) { singular_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, singular_or_list, submessage_arena); @@ -14152,11 +13413,11 @@ void Expression::set_allocated_singular_or_list(::substrait::Expression_Singular // @@protoc_insertion_point(field_set_allocated:substrait.Expression.singular_or_list) } void Expression::set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rex_type(); if (multi_or_list) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(multi_or_list); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MultiOrList>::GetOwningArena(multi_or_list); if (message_arena != submessage_arena) { multi_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, multi_or_list, submessage_arena); @@ -14167,11 +13428,11 @@ void Expression::set_allocated_multi_or_list(::substrait::Expression_MultiOrList // @@protoc_insertion_point(field_set_allocated:substrait.Expression.multi_or_list) } void Expression::set_allocated_enum_(::substrait::Expression_Enum* enum_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rex_type(); if (enum_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(enum_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Enum>::GetOwningArena(enum_); if (message_arena != submessage_arena) { enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, enum_, submessage_arena); @@ -14182,11 +13443,11 @@ void Expression::set_allocated_enum_(::substrait::Expression_Enum* enum_) { // @@protoc_insertion_point(field_set_allocated:substrait.Expression.enum) } void Expression::set_allocated_cast(::substrait::Expression_Cast* cast) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rex_type(); if (cast) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(cast); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Cast>::GetOwningArena(cast); if (message_arena != submessage_arena) { cast = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, cast, submessage_arena); @@ -14196,10 +13457,13 @@ void Expression::set_allocated_cast(::substrait::Expression_Cast* cast) { } // @@protoc_insertion_point(field_set_allocated:substrait.Expression.cast) } -Expression::Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Expression::Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Expression) } Expression::Expression(const Expression& from) @@ -14254,18 +13518,19 @@ Expression::Expression(const Expression& from) // @@protoc_insertion_point(copy_constructor:substrait.Expression) } -void Expression::SharedCtor() { +inline void Expression::SharedCtor() { clear_has_rex_type(); } Expression::~Expression() { // @@protoc_insertion_point(destructor:substrait.Expression) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Expression::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Expression::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_rex_type()) { clear_rex_type(); } @@ -14285,61 +13550,61 @@ void Expression::clear_rex_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.Expression) switch (rex_type_case()) { case kLiteral: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.literal_; } break; } case kSelection: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.selection_; } break; } case kScalarFunction: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.scalar_function_; } break; } case kWindowFunction: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.window_function_; } break; } case kIfThen: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.if_then_; } break; } case kSwitchExpression: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.switch_expression_; } break; } case kSingularOrList: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.singular_or_list_; } break; } case kMultiOrList: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.multi_or_list_; } break; } case kEnum: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.enum__; } break; } case kCast: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.cast_; } break; @@ -14354,7 +13619,7 @@ void Expression::clear_rex_type() { void Expression::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Expression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -14365,106 +13630,116 @@ void Expression::Clear() { const char* Expression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression.Literal literal = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_literal(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.FieldReference selection = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_selection(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.ScalarFunction scalar_function = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_scalar_function(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.WindowFunction window_function = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_window_function(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.IfThen if_then = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_if_then(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.SwitchExpression switch_expression = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_switch_expression(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.SingularOrList singular_or_list = 8; case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr = ctx->ParseMessage(_internal_mutable_singular_or_list(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.MultiOrList multi_or_list = 9; case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_multi_or_list(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Enum enum = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.Cast cast = 11; case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_cast(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Expression::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Expression::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression.Literal literal = 1; @@ -14559,7 +13834,7 @@ size_t Expression::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Expression) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -14638,35 +13913,26 @@ size_t Expression::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Expression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Expression) - GOOGLE_DCHECK_NE(&from, this); - const Expression* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Expression) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Expression) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Expression::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression::GetClassData() const { return &_class_data_; } + +void Expression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Expression::MergeFrom(const Expression& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.rex_type_case()) { @@ -14714,13 +13980,7 @@ void Expression::MergeFrom(const Expression& from) { break; } } -} - -void Expression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Expression) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Expression::CopyFrom(const Expression& from) { @@ -14736,7 +13996,7 @@ bool Expression::IsInitialized() const { void Expression::InternalSwap(Expression* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(rex_type_, other->rex_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -14758,10 +14018,13 @@ const ::substrait::Expression& SortField::_Internal::expr(const SortField* msg) { return *msg->expr_; } -SortField::SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +SortField::SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.SortField) } SortField::SortField(const SortField& from) @@ -14789,19 +14052,20 @@ SortField::SortField(const SortField& from) // @@protoc_insertion_point(copy_constructor:substrait.SortField) } -void SortField::SharedCtor() { +inline void SortField::SharedCtor() { expr_ = nullptr; clear_has_sort_kind(); } SortField::~SortField() { // @@protoc_insertion_point(destructor:substrait.SortField) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void SortField::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void SortField::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete expr_; if (has_sort_kind()) { clear_sort_kind(); @@ -14839,11 +14103,11 @@ void SortField::clear_sort_kind() { void SortField::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.SortField) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && expr_ != nullptr) { + if (GetArenaForAllocation() == nullptr && expr_ != nullptr) { delete expr_; } expr_ = nullptr; @@ -14854,62 +14118,65 @@ void SortField::Clear() { const char* SortField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Expression expr = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_expr(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.SortField.SortDirection direction = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_direction(static_cast<::substrait::SortField_SortDirection>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 comparison_function_reference = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { _internal_set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* SortField::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* SortField::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.SortField) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Expression expr = 1; - if (this->has_expr()) { + if (this->_internal_has_expr()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -14941,12 +14208,12 @@ size_t SortField::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.SortField) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Expression expr = 1; - if (this->has_expr()) { + if (this->_internal_has_expr()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *expr_); @@ -14961,47 +14228,36 @@ size_t SortField::ByteSizeLong() const { } // uint32 comparison_function_reference = 3; case kComparisonFunctionReference: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_comparison_function_reference()); + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_comparison_function_reference()); break; } case SORT_KIND_NOT_SET: { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void SortField::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.SortField) - GOOGLE_DCHECK_NE(&from, this); - const SortField* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.SortField) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.SortField) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SortField::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SortField::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SortField::GetClassData() const { return &_class_data_; } + +void SortField::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void SortField::MergeFrom(const SortField& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.SortField) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_expr()) { + if (from._internal_has_expr()) { _internal_mutable_expr()->::substrait::Expression::MergeFrom(from._internal_expr()); } switch (from.sort_kind_case()) { @@ -15017,13 +14273,7 @@ void SortField::MergeFrom(const SortField& from) { break; } } -} - -void SortField::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.SortField) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SortField::CopyFrom(const SortField& from) { @@ -15039,7 +14289,7 @@ bool SortField::IsInitialized() const { void SortField::InternalSwap(SortField* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(expr_, other->expr_); swap(sort_kind_, other->sort_kind_); swap(_oneof_case_[0], other->_oneof_case_[0]); @@ -15063,17 +14313,20 @@ AggregateFunction::_Internal::output_type(const AggregateFunction* msg) { return *msg->output_type_; } void AggregateFunction::clear_output_type() { - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; } -AggregateFunction::AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +AggregateFunction::AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), args_(arena), sorts_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.AggregateFunction) } AggregateFunction::AggregateFunction(const AggregateFunction& from) @@ -15092,7 +14345,7 @@ AggregateFunction::AggregateFunction(const AggregateFunction& from) // @@protoc_insertion_point(copy_constructor:substrait.AggregateFunction) } -void AggregateFunction::SharedCtor() { +inline void AggregateFunction::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&output_type_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&phase_) - @@ -15101,12 +14354,13 @@ ::memset(reinterpret_cast(this) + static_cast( AggregateFunction::~AggregateFunction() { // @@protoc_insertion_point(destructor:substrait.AggregateFunction) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void AggregateFunction::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void AggregateFunction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete output_type_; } @@ -15122,13 +14376,13 @@ void AggregateFunction::SetCachedSize(int size) const { void AggregateFunction::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.AggregateFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; args_.Clear(); sorts_.Clear(); - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; @@ -15141,19 +14395,20 @@ void AggregateFunction::Clear() { const char* AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 function_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.Expression args = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -15161,11 +14416,12 @@ const char* AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.SortField sorts = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -15173,54 +14429,57 @@ const char* AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.AggregationPhase phase = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_phase(static_cast<::substrait::AggregationPhase>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type output_type = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* AggregateFunction::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* AggregateFunction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 function_reference = 1; - if (this->function_reference() != 0) { + if (this->_internal_function_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); } @@ -15242,14 +14501,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateFunction::_InternalSerialize( } // .substrait.AggregationPhase phase = 4; - if (this->phase() != 0) { + if (this->_internal_phase() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 4, this->_internal_phase(), target); } // .substrait.Type output_type = 5; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -15268,7 +14527,7 @@ size_t AggregateFunction::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.AggregateFunction) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -15287,74 +14546,57 @@ size_t AggregateFunction::ByteSizeLong() const { } // .substrait.Type output_type = 5; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *output_type_); } // uint32 function_reference = 1; - if (this->function_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_function_reference()); + if (this->_internal_function_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference()); } // .substrait.AggregationPhase phase = 4; - if (this->phase() != 0) { + if (this->_internal_phase() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void AggregateFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.AggregateFunction) - GOOGLE_DCHECK_NE(&from, this); - const AggregateFunction* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.AggregateFunction) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.AggregateFunction) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateFunction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + AggregateFunction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateFunction::GetClassData() const { return &_class_data_; } + +void AggregateFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void AggregateFunction::MergeFrom(const AggregateFunction& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateFunction) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; args_.MergeFrom(from.args_); sorts_.MergeFrom(from.sorts_); - if (from.has_output_type()) { + if (from._internal_has_output_type()) { _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); } - if (from.function_reference() != 0) { + if (from._internal_function_reference() != 0) { _internal_set_function_reference(from._internal_function_reference()); } - if (from.phase() != 0) { + if (from._internal_phase() != 0) { _internal_set_phase(from._internal_phase()); } -} - -void AggregateFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.AggregateFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void AggregateFunction::CopyFrom(const AggregateFunction& from) { @@ -15370,7 +14612,7 @@ bool AggregateFunction::IsInitialized() const { void AggregateFunction::InternalSwap(AggregateFunction* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); args_.InternalSwap(&other->args_); sorts_.InternalSwap(&other->sorts_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< diff --git a/cpp/src/generated/substrait/expression.pb.h b/cpp/src/generated/substrait/expression.pb.h index 5818e2b20f5..b7c2a920316 100644 --- a/cpp/src/generated/substrait/expression.pb.h +++ b/cpp/src/generated/substrait/expression.pb.h @@ -8,12 +8,12 @@ #include #include -#if PROTOBUF_VERSION < 3016000 +#if PROTOBUF_VERSION < 3019000 #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 3016000 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019003 < 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. @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -52,7 +53,7 @@ struct TableStruct_substrait_2fexpression_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; + static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fexpression_2eproto; namespace substrait { @@ -264,8 +265,8 @@ enum SortField_SortDirection : int { SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_FIRST = 3, SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_LAST = 4, SortField_SortDirection_SORT_DIRECTION_CLUSTERED = 5, - SortField_SortDirection_SortField_SortDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - SortField_SortDirection_SortField_SortDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + SortField_SortDirection_SortField_SortDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + SortField_SortDirection_SortField_SortDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool SortField_SortDirection_IsValid(int value); constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MIN = SortField_SortDirection_SORT_DIRECTION_UNSPECIFIED; @@ -292,8 +293,8 @@ enum AggregationPhase : int { AGGREGATION_PHASE_INTERMEDIATE_TO_INTERMEDIATE = 2, AGGREGATION_PHASE_INITIAL_TO_RESULT = 3, AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT = 4, - AggregationPhase_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - AggregationPhase_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + AggregationPhase_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + AggregationPhase_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool AggregationPhase_IsValid(int value); constexpr AggregationPhase AggregationPhase_MIN = AGGREGATION_PHASE_UNSPECIFIED; @@ -316,11 +317,10 @@ inline bool AggregationPhase_Parse( } // =================================================================== -class Expression_Enum_Empty PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Enum.Empty) */ { +class Expression_Enum_Empty final : + public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.Enum.Empty) */ { public: inline Expression_Enum_Empty() : Expression_Enum_Empty(nullptr) {} - ~Expression_Enum_Empty() override; explicit constexpr Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Expression_Enum_Empty(const Expression_Enum_Empty& from); @@ -334,8 +334,13 @@ class Expression_Enum_Empty PROTOBUF_FINAL : return *this; } inline Expression_Enum_Empty& operator=(Expression_Enum_Empty&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -366,7 +371,12 @@ class Expression_Enum_Empty PROTOBUF_FINAL : } inline void Swap(Expression_Enum_Empty* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -374,48 +384,39 @@ class Expression_Enum_Empty PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Enum_Empty* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Enum_Empty* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Enum_Empty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Enum_Empty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Expression_Enum_Empty& from); - void MergeFrom(const Expression_Enum_Empty& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const Expression_Enum_Empty& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const Expression_Enum_Empty& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); + } + public: private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Enum_Empty* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Enum.Empty"; } protected: - explicit Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -434,7 +435,7 @@ class Expression_Enum_Empty PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_Enum PROTOBUF_FINAL : +class Expression_Enum final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Enum) */ { public: inline Expression_Enum() : Expression_Enum(nullptr) {} @@ -452,8 +453,13 @@ class Expression_Enum PROTOBUF_FINAL : return *this; } inline Expression_Enum& operator=(Expression_Enum&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -490,7 +496,12 @@ class Expression_Enum PROTOBUF_FINAL : } inline void Swap(Expression_Enum* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -498,48 +509,53 @@ class Expression_Enum PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Enum* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Enum* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Enum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Enum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Enum& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Enum& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Enum* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Enum"; } protected: - explicit Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -562,11 +578,11 @@ class Expression_Enum PROTOBUF_FINAL : template void set_specified(ArgT0&& arg0, ArgT... args); std::string* mutable_specified(); - std::string* release_specified(); + PROTOBUF_NODISCARD std::string* release_specified(); void set_allocated_specified(std::string* specified); private: const std::string& _internal_specified() const; - void _internal_set_specified(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_specified(const std::string& value); std::string* _internal_mutable_specified(); public: @@ -577,7 +593,7 @@ class Expression_Enum PROTOBUF_FINAL : public: void clear_unspecified(); const ::substrait::Expression_Enum_Empty& unspecified() const; - ::substrait::Expression_Enum_Empty* release_unspecified(); + PROTOBUF_NODISCARD ::substrait::Expression_Enum_Empty* release_unspecified(); ::substrait::Expression_Enum_Empty* mutable_unspecified(); void set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified); private: @@ -609,13 +625,13 @@ class Expression_Enum PROTOBUF_FINAL : ::substrait::Expression_Enum_Empty* unspecified_; } enum_kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_Literal_VarChar PROTOBUF_FINAL : +class Expression_Literal_VarChar final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.VarChar) */ { public: inline Expression_Literal_VarChar() : Expression_Literal_VarChar(nullptr) {} @@ -633,8 +649,13 @@ class Expression_Literal_VarChar PROTOBUF_FINAL : return *this; } inline Expression_Literal_VarChar& operator=(Expression_Literal_VarChar&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -665,7 +686,12 @@ class Expression_Literal_VarChar PROTOBUF_FINAL : } inline void Swap(Expression_Literal_VarChar* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -673,48 +699,53 @@ class Expression_Literal_VarChar PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Literal_VarChar* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Literal_VarChar* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Literal_VarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Literal_VarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Literal_VarChar& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Literal_VarChar& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Literal_VarChar* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Literal.VarChar"; } protected: - explicit Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -731,21 +762,21 @@ class Expression_Literal_VarChar PROTOBUF_FINAL : template void set_value(ArgT0&& arg0, ArgT... args); std::string* mutable_value(); - std::string* release_value(); + PROTOBUF_NODISCARD std::string* release_value(); void set_allocated_value(std::string* value); private: const std::string& _internal_value() const; - void _internal_set_value(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value); std::string* _internal_mutable_value(); public: // uint32 length = 2; void clear_length(); - ::PROTOBUF_NAMESPACE_ID::uint32 length() const; - void set_length(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t length() const; + void set_length(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_length() const; - void _internal_set_length(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_length() const; + void _internal_set_length(uint32_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.VarChar) @@ -756,13 +787,13 @@ class Expression_Literal_VarChar PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; - ::PROTOBUF_NAMESPACE_ID::uint32 length_; + uint32_t length_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_Literal_Decimal PROTOBUF_FINAL : +class Expression_Literal_Decimal final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Decimal) */ { public: inline Expression_Literal_Decimal() : Expression_Literal_Decimal(nullptr) {} @@ -780,8 +811,13 @@ class Expression_Literal_Decimal PROTOBUF_FINAL : return *this; } inline Expression_Literal_Decimal& operator=(Expression_Literal_Decimal&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -812,7 +848,12 @@ class Expression_Literal_Decimal PROTOBUF_FINAL : } inline void Swap(Expression_Literal_Decimal* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -820,48 +861,53 @@ class Expression_Literal_Decimal PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Literal_Decimal* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Literal_Decimal* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Literal_Decimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Literal_Decimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Literal_Decimal& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Literal_Decimal& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Literal_Decimal* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Literal.Decimal"; } protected: - explicit Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -879,30 +925,30 @@ class Expression_Literal_Decimal PROTOBUF_FINAL : template void set_value(ArgT0&& arg0, ArgT... args); std::string* mutable_value(); - std::string* release_value(); + PROTOBUF_NODISCARD std::string* release_value(); void set_allocated_value(std::string* value); private: const std::string& _internal_value() const; - void _internal_set_value(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value); std::string* _internal_mutable_value(); public: // int32 precision = 2; void clear_precision(); - ::PROTOBUF_NAMESPACE_ID::int32 precision() const; - void set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t precision() const; + void set_precision(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_precision() const; - void _internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_precision() const; + void _internal_set_precision(int32_t value); public: // int32 scale = 3; void clear_scale(); - ::PROTOBUF_NAMESPACE_ID::int32 scale() const; - void set_scale(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t scale() const; + void set_scale(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_scale() const; - void _internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_scale() const; + void _internal_set_scale(int32_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Decimal) @@ -913,14 +959,14 @@ class Expression_Literal_Decimal PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; - ::PROTOBUF_NAMESPACE_ID::int32 precision_; - ::PROTOBUF_NAMESPACE_ID::int32 scale_; + int32_t precision_; + int32_t scale_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : +class Expression_Literal_Map_KeyValue final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Map.KeyValue) */ { public: inline Expression_Literal_Map_KeyValue() : Expression_Literal_Map_KeyValue(nullptr) {} @@ -938,8 +984,13 @@ class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : return *this; } inline Expression_Literal_Map_KeyValue& operator=(Expression_Literal_Map_KeyValue&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -970,7 +1021,12 @@ class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : } inline void Swap(Expression_Literal_Map_KeyValue* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -978,48 +1034,53 @@ class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Literal_Map_KeyValue* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Literal_Map_KeyValue* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Literal_Map_KeyValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Literal_Map_KeyValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Literal_Map_KeyValue& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Literal_Map_KeyValue& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Literal_Map_KeyValue* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Literal.Map.KeyValue"; } protected: - explicit Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1037,7 +1098,7 @@ class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : public: void clear_key(); const ::substrait::Expression_Literal& key() const; - ::substrait::Expression_Literal* release_key(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_key(); ::substrait::Expression_Literal* mutable_key(); void set_allocated_key(::substrait::Expression_Literal* key); private: @@ -1055,7 +1116,7 @@ class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : public: void clear_value(); const ::substrait::Expression_Literal& value() const; - ::substrait::Expression_Literal* release_value(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_value(); ::substrait::Expression_Literal* mutable_value(); void set_allocated_value(::substrait::Expression_Literal* value); private: @@ -1080,7 +1141,7 @@ class Expression_Literal_Map_KeyValue PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_Literal_Map PROTOBUF_FINAL : +class Expression_Literal_Map final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Map) */ { public: inline Expression_Literal_Map() : Expression_Literal_Map(nullptr) {} @@ -1098,8 +1159,13 @@ class Expression_Literal_Map PROTOBUF_FINAL : return *this; } inline Expression_Literal_Map& operator=(Expression_Literal_Map&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1130,7 +1196,12 @@ class Expression_Literal_Map PROTOBUF_FINAL : } inline void Swap(Expression_Literal_Map* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1138,48 +1209,53 @@ class Expression_Literal_Map PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Literal_Map* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Literal_Map* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Literal_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Literal_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Literal_Map& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Literal_Map& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Literal_Map* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Literal.Map"; } protected: - explicit Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1222,7 +1298,7 @@ class Expression_Literal_Map PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : +class Expression_Literal_IntervalYearToMonth final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.IntervalYearToMonth) */ { public: inline Expression_Literal_IntervalYearToMonth() : Expression_Literal_IntervalYearToMonth(nullptr) {} @@ -1240,8 +1316,13 @@ class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : return *this; } inline Expression_Literal_IntervalYearToMonth& operator=(Expression_Literal_IntervalYearToMonth&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1272,7 +1353,12 @@ class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : } inline void Swap(Expression_Literal_IntervalYearToMonth* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1280,48 +1366,53 @@ class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Literal_IntervalYearToMonth* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Literal_IntervalYearToMonth* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Literal_IntervalYearToMonth* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Literal_IntervalYearToMonth* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Literal_IntervalYearToMonth& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Literal_IntervalYearToMonth& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Literal_IntervalYearToMonth* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Literal.IntervalYearToMonth"; } protected: - explicit Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1334,20 +1425,20 @@ class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : }; // int32 years = 1; void clear_years(); - ::PROTOBUF_NAMESPACE_ID::int32 years() const; - void set_years(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t years() const; + void set_years(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_years() const; - void _internal_set_years(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_years() const; + void _internal_set_years(int32_t value); public: // int32 months = 2; void clear_months(); - ::PROTOBUF_NAMESPACE_ID::int32 months() const; - void set_months(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t months() const; + void set_months(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_months() const; - void _internal_set_months(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_months() const; + void _internal_set_months(int32_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.IntervalYearToMonth) @@ -1357,14 +1448,14 @@ class Expression_Literal_IntervalYearToMonth PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 years_; - ::PROTOBUF_NAMESPACE_ID::int32 months_; + int32_t years_; + int32_t months_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : +class Expression_Literal_IntervalDayToSecond final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.IntervalDayToSecond) */ { public: inline Expression_Literal_IntervalDayToSecond() : Expression_Literal_IntervalDayToSecond(nullptr) {} @@ -1382,8 +1473,13 @@ class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : return *this; } inline Expression_Literal_IntervalDayToSecond& operator=(Expression_Literal_IntervalDayToSecond&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1414,7 +1510,12 @@ class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : } inline void Swap(Expression_Literal_IntervalDayToSecond* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1422,48 +1523,53 @@ class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Literal_IntervalDayToSecond* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Literal_IntervalDayToSecond* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Literal_IntervalDayToSecond* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Literal_IntervalDayToSecond* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Literal_IntervalDayToSecond& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Literal_IntervalDayToSecond& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Literal_IntervalDayToSecond* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Literal.IntervalDayToSecond"; } protected: - explicit Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1476,20 +1582,20 @@ class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : }; // int32 days = 1; void clear_days(); - ::PROTOBUF_NAMESPACE_ID::int32 days() const; - void set_days(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t days() const; + void set_days(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_days() const; - void _internal_set_days(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_days() const; + void _internal_set_days(int32_t value); public: // int32 seconds = 2; void clear_seconds(); - ::PROTOBUF_NAMESPACE_ID::int32 seconds() const; - void set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t seconds() const; + void set_seconds(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_seconds() const; - void _internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_seconds() const; + void _internal_set_seconds(int32_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.IntervalDayToSecond) @@ -1499,14 +1605,14 @@ class Expression_Literal_IntervalDayToSecond PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 days_; - ::PROTOBUF_NAMESPACE_ID::int32 seconds_; + int32_t days_; + int32_t seconds_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_Literal_Struct PROTOBUF_FINAL : +class Expression_Literal_Struct final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Struct) */ { public: inline Expression_Literal_Struct() : Expression_Literal_Struct(nullptr) {} @@ -1524,8 +1630,13 @@ class Expression_Literal_Struct PROTOBUF_FINAL : return *this; } inline Expression_Literal_Struct& operator=(Expression_Literal_Struct&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1556,7 +1667,12 @@ class Expression_Literal_Struct PROTOBUF_FINAL : } inline void Swap(Expression_Literal_Struct* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1564,48 +1680,53 @@ class Expression_Literal_Struct PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Literal_Struct* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Literal_Struct* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Literal_Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Literal_Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Literal_Struct& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Literal_Struct& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Literal_Struct* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Literal.Struct"; } protected: - explicit Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1646,7 +1767,7 @@ class Expression_Literal_Struct PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_Literal_List PROTOBUF_FINAL : +class Expression_Literal_List final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.List) */ { public: inline Expression_Literal_List() : Expression_Literal_List(nullptr) {} @@ -1664,8 +1785,13 @@ class Expression_Literal_List PROTOBUF_FINAL : return *this; } inline Expression_Literal_List& operator=(Expression_Literal_List&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1696,7 +1822,12 @@ class Expression_Literal_List PROTOBUF_FINAL : } inline void Swap(Expression_Literal_List* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1704,48 +1835,53 @@ class Expression_Literal_List PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Literal_List* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Literal_List* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Literal_List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Literal_List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Literal_List& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Literal_List& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Literal_List* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Literal.List"; } protected: - explicit Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1786,7 +1922,7 @@ class Expression_Literal_List PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_Literal PROTOBUF_FINAL : +class Expression_Literal final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal) */ { public: inline Expression_Literal() : Expression_Literal(nullptr) {} @@ -1804,8 +1940,13 @@ class Expression_Literal PROTOBUF_FINAL : return *this; } inline Expression_Literal& operator=(Expression_Literal&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1866,7 +2007,12 @@ class Expression_Literal PROTOBUF_FINAL : } inline void Swap(Expression_Literal* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1874,48 +2020,53 @@ class Expression_Literal PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Literal* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Literal* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Literal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Literal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Literal& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Literal& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Literal* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Literal"; } protected: - explicit Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1987,11 +2138,11 @@ class Expression_Literal PROTOBUF_FINAL : bool _internal_has_i8() const; public: void clear_i8(); - ::PROTOBUF_NAMESPACE_ID::int32 i8() const; - void set_i8(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t i8() const; + void set_i8(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_i8() const; - void _internal_set_i8(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_i8() const; + void _internal_set_i8(int32_t value); public: // int32 i16 = 3; @@ -2000,11 +2151,11 @@ class Expression_Literal PROTOBUF_FINAL : bool _internal_has_i16() const; public: void clear_i16(); - ::PROTOBUF_NAMESPACE_ID::int32 i16() const; - void set_i16(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t i16() const; + void set_i16(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_i16() const; - void _internal_set_i16(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_i16() const; + void _internal_set_i16(int32_t value); public: // int32 i32 = 5; @@ -2013,11 +2164,11 @@ class Expression_Literal PROTOBUF_FINAL : bool _internal_has_i32() const; public: void clear_i32(); - ::PROTOBUF_NAMESPACE_ID::int32 i32() const; - void set_i32(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t i32() const; + void set_i32(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_i32() const; - void _internal_set_i32(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_i32() const; + void _internal_set_i32(int32_t value); public: // int64 i64 = 7; @@ -2026,11 +2177,11 @@ class Expression_Literal PROTOBUF_FINAL : bool _internal_has_i64() const; public: void clear_i64(); - ::PROTOBUF_NAMESPACE_ID::int64 i64() const; - void set_i64(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t i64() const; + void set_i64(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_i64() const; - void _internal_set_i64(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_i64() const; + void _internal_set_i64(int64_t value); public: // float fp32 = 10; @@ -2069,11 +2220,11 @@ class Expression_Literal PROTOBUF_FINAL : template void set_string(ArgT0&& arg0, ArgT... args); std::string* mutable_string(); - std::string* release_string(); + PROTOBUF_NODISCARD std::string* release_string(); void set_allocated_string(std::string* string); private: const std::string& _internal_string() const; - void _internal_set_string(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_string(const std::string& value); std::string* _internal_mutable_string(); public: @@ -2087,11 +2238,11 @@ class Expression_Literal PROTOBUF_FINAL : template void set_binary(ArgT0&& arg0, ArgT... args); std::string* mutable_binary(); - std::string* release_binary(); + PROTOBUF_NODISCARD std::string* release_binary(); void set_allocated_binary(std::string* binary); private: const std::string& _internal_binary() const; - void _internal_set_binary(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary(const std::string& value); std::string* _internal_mutable_binary(); public: @@ -2101,11 +2252,11 @@ class Expression_Literal PROTOBUF_FINAL : bool _internal_has_timestamp() const; public: void clear_timestamp(); - ::PROTOBUF_NAMESPACE_ID::int64 timestamp() const; - void set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t timestamp() const; + void set_timestamp(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_timestamp() const; - void _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_timestamp() const; + void _internal_set_timestamp(int64_t value); public: // int32 date = 16; @@ -2114,11 +2265,11 @@ class Expression_Literal PROTOBUF_FINAL : bool _internal_has_date() const; public: void clear_date(); - ::PROTOBUF_NAMESPACE_ID::int32 date() const; - void set_date(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t date() const; + void set_date(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_date() const; - void _internal_set_date(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_date() const; + void _internal_set_date(int32_t value); public: // int64 time = 17; @@ -2127,11 +2278,11 @@ class Expression_Literal PROTOBUF_FINAL : bool _internal_has_time() const; public: void clear_time(); - ::PROTOBUF_NAMESPACE_ID::int64 time() const; - void set_time(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t time() const; + void set_time(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_time() const; - void _internal_set_time(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_time() const; + void _internal_set_time(int64_t value); public: // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; @@ -2141,7 +2292,7 @@ class Expression_Literal PROTOBUF_FINAL : public: void clear_interval_year_to_month(); const ::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month() const; - ::substrait::Expression_Literal_IntervalYearToMonth* release_interval_year_to_month(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal_IntervalYearToMonth* release_interval_year_to_month(); ::substrait::Expression_Literal_IntervalYearToMonth* mutable_interval_year_to_month(); void set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month); private: @@ -2159,7 +2310,7 @@ class Expression_Literal PROTOBUF_FINAL : public: void clear_interval_day_to_second(); const ::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second() const; - ::substrait::Expression_Literal_IntervalDayToSecond* release_interval_day_to_second(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal_IntervalDayToSecond* release_interval_day_to_second(); ::substrait::Expression_Literal_IntervalDayToSecond* mutable_interval_day_to_second(); void set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second); private: @@ -2180,11 +2331,11 @@ class Expression_Literal PROTOBUF_FINAL : template void set_fixed_char(ArgT0&& arg0, ArgT... args); std::string* mutable_fixed_char(); - std::string* release_fixed_char(); + PROTOBUF_NODISCARD std::string* release_fixed_char(); void set_allocated_fixed_char(std::string* fixed_char); private: const std::string& _internal_fixed_char() const; - void _internal_set_fixed_char(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fixed_char(const std::string& value); std::string* _internal_mutable_fixed_char(); public: @@ -2195,7 +2346,7 @@ class Expression_Literal PROTOBUF_FINAL : public: void clear_var_char(); const ::substrait::Expression_Literal_VarChar& var_char() const; - ::substrait::Expression_Literal_VarChar* release_var_char(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal_VarChar* release_var_char(); ::substrait::Expression_Literal_VarChar* mutable_var_char(); void set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char); private: @@ -2216,11 +2367,11 @@ class Expression_Literal PROTOBUF_FINAL : template void set_fixed_binary(ArgT0&& arg0, ArgT... args); std::string* mutable_fixed_binary(); - std::string* release_fixed_binary(); + PROTOBUF_NODISCARD std::string* release_fixed_binary(); void set_allocated_fixed_binary(std::string* fixed_binary); private: const std::string& _internal_fixed_binary() const; - void _internal_set_fixed_binary(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_fixed_binary(const std::string& value); std::string* _internal_mutable_fixed_binary(); public: @@ -2231,7 +2382,7 @@ class Expression_Literal PROTOBUF_FINAL : public: void clear_decimal(); const ::substrait::Expression_Literal_Decimal& decimal() const; - ::substrait::Expression_Literal_Decimal* release_decimal(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal_Decimal* release_decimal(); ::substrait::Expression_Literal_Decimal* mutable_decimal(); void set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal); private: @@ -2249,7 +2400,7 @@ class Expression_Literal PROTOBUF_FINAL : public: void clear_struct_(); const ::substrait::Expression_Literal_Struct& struct_() const; - ::substrait::Expression_Literal_Struct* release_struct_(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal_Struct* release_struct_(); ::substrait::Expression_Literal_Struct* mutable_struct_(); void set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_); private: @@ -2267,7 +2418,7 @@ class Expression_Literal PROTOBUF_FINAL : public: void clear_map(); const ::substrait::Expression_Literal_Map& map() const; - ::substrait::Expression_Literal_Map* release_map(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal_Map* release_map(); ::substrait::Expression_Literal_Map* mutable_map(); void set_allocated_map(::substrait::Expression_Literal_Map* map); private: @@ -2284,11 +2435,11 @@ class Expression_Literal PROTOBUF_FINAL : bool _internal_has_timestamp_tz() const; public: void clear_timestamp_tz(); - ::PROTOBUF_NAMESPACE_ID::int64 timestamp_tz() const; - void set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t timestamp_tz() const; + void set_timestamp_tz(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_timestamp_tz() const; - void _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_timestamp_tz() const; + void _internal_set_timestamp_tz(int64_t value); public: // bytes uuid = 28; @@ -2301,11 +2452,11 @@ class Expression_Literal PROTOBUF_FINAL : template void set_uuid(ArgT0&& arg0, ArgT... args); std::string* mutable_uuid(); - std::string* release_uuid(); + PROTOBUF_NODISCARD std::string* release_uuid(); void set_allocated_uuid(std::string* uuid); private: const std::string& _internal_uuid() const; - void _internal_set_uuid(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_uuid(const std::string& value); std::string* _internal_mutable_uuid(); public: @@ -2316,7 +2467,7 @@ class Expression_Literal PROTOBUF_FINAL : public: void clear_null(); const ::substrait::Type& null() const; - ::substrait::Type* release_null(); + PROTOBUF_NODISCARD ::substrait::Type* release_null(); ::substrait::Type* mutable_null(); void set_allocated_null(::substrait::Type* null); private: @@ -2334,7 +2485,7 @@ class Expression_Literal PROTOBUF_FINAL : public: void clear_list(); const ::substrait::Expression_Literal_List& list() const; - ::substrait::Expression_Literal_List* release_list(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal_List* release_list(); ::substrait::Expression_Literal_List* mutable_list(); void set_allocated_list(::substrait::Expression_Literal_List* list); private: @@ -2352,7 +2503,7 @@ class Expression_Literal PROTOBUF_FINAL : public: void clear_empty_list(); const ::substrait::Type_List& empty_list() const; - ::substrait::Type_List* release_empty_list(); + PROTOBUF_NODISCARD ::substrait::Type_List* release_empty_list(); ::substrait::Type_List* mutable_empty_list(); void set_allocated_empty_list(::substrait::Type_List* empty_list); private: @@ -2370,7 +2521,7 @@ class Expression_Literal PROTOBUF_FINAL : public: void clear_empty_map(); const ::substrait::Type_Map& empty_map() const; - ::substrait::Type_Map* release_empty_map(); + PROTOBUF_NODISCARD ::substrait::Type_Map* release_empty_map(); ::substrait::Type_Map* mutable_empty_map(); void set_allocated_empty_map(::substrait::Type_Map* empty_map); private: @@ -2424,17 +2575,17 @@ class Expression_Literal PROTOBUF_FINAL : constexpr LiteralTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; bool boolean_; - ::PROTOBUF_NAMESPACE_ID::int32 i8_; - ::PROTOBUF_NAMESPACE_ID::int32 i16_; - ::PROTOBUF_NAMESPACE_ID::int32 i32_; - ::PROTOBUF_NAMESPACE_ID::int64 i64_; + int32_t i8_; + int32_t i16_; + int32_t i32_; + int64_t i64_; float fp32_; double fp64_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_; - ::PROTOBUF_NAMESPACE_ID::int64 timestamp_; - ::PROTOBUF_NAMESPACE_ID::int32 date_; - ::PROTOBUF_NAMESPACE_ID::int64 time_; + int64_t timestamp_; + int32_t date_; + int64_t time_; ::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month_; ::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_char_; @@ -2443,7 +2594,7 @@ class Expression_Literal PROTOBUF_FINAL : ::substrait::Expression_Literal_Decimal* decimal_; ::substrait::Expression_Literal_Struct* struct__; ::substrait::Expression_Literal_Map* map_; - ::PROTOBUF_NAMESPACE_ID::int64 timestamp_tz_; + int64_t timestamp_tz_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uuid_; ::substrait::Type* null_; ::substrait::Expression_Literal_List* list_; @@ -2451,13 +2602,13 @@ class Expression_Literal PROTOBUF_FINAL : ::substrait::Type_Map* empty_map_; } literal_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_ScalarFunction PROTOBUF_FINAL : +class Expression_ScalarFunction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ScalarFunction) */ { public: inline Expression_ScalarFunction() : Expression_ScalarFunction(nullptr) {} @@ -2475,8 +2626,13 @@ class Expression_ScalarFunction PROTOBUF_FINAL : return *this; } inline Expression_ScalarFunction& operator=(Expression_ScalarFunction&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2507,7 +2663,12 @@ class Expression_ScalarFunction PROTOBUF_FINAL : } inline void Swap(Expression_ScalarFunction* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2515,48 +2676,53 @@ class Expression_ScalarFunction PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_ScalarFunction* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_ScalarFunction* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_ScalarFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_ScalarFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_ScalarFunction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_ScalarFunction& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_ScalarFunction* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.ScalarFunction"; } protected: - explicit Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2593,7 +2759,7 @@ class Expression_ScalarFunction PROTOBUF_FINAL : public: void clear_output_type(); const ::substrait::Type& output_type() const; - ::substrait::Type* release_output_type(); + PROTOBUF_NODISCARD ::substrait::Type* release_output_type(); ::substrait::Type* mutable_output_type(); void set_allocated_output_type(::substrait::Type* output_type); private: @@ -2606,11 +2772,11 @@ class Expression_ScalarFunction PROTOBUF_FINAL : // uint32 function_reference = 1; void clear_function_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 function_reference() const; - void set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t function_reference() const; + void set_function_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_function_reference() const; - void _internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_function_reference() const; + void _internal_set_function_reference(uint32_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.ScalarFunction) @@ -2622,13 +2788,13 @@ class Expression_ScalarFunction PROTOBUF_FINAL : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_; ::substrait::Type* output_type_; - ::PROTOBUF_NAMESPACE_ID::uint32 function_reference_; + uint32_t function_reference_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : +class Expression_WindowFunction_Bound_Preceding final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Preceding) */ { public: inline Expression_WindowFunction_Bound_Preceding() : Expression_WindowFunction_Bound_Preceding(nullptr) {} @@ -2646,8 +2812,13 @@ class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : return *this; } inline Expression_WindowFunction_Bound_Preceding& operator=(Expression_WindowFunction_Bound_Preceding&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2678,7 +2849,12 @@ class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : } inline void Swap(Expression_WindowFunction_Bound_Preceding* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2686,48 +2862,53 @@ class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_WindowFunction_Bound_Preceding* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_WindowFunction_Bound_Preceding* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_WindowFunction_Bound_Preceding* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_WindowFunction_Bound_Preceding* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_WindowFunction_Bound_Preceding& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_WindowFunction_Bound_Preceding& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_WindowFunction_Bound_Preceding* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.WindowFunction.Bound.Preceding"; } protected: - explicit Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2739,11 +2920,11 @@ class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : }; // int64 offset = 1; void clear_offset(); - ::PROTOBUF_NAMESPACE_ID::int64 offset() const; - void set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t offset() const; + void set_offset(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_offset() const; - void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_offset() const; + void _internal_set_offset(int64_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Preceding) @@ -2753,13 +2934,13 @@ class Expression_WindowFunction_Bound_Preceding PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int64 offset_; + int64_t offset_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : +class Expression_WindowFunction_Bound_Following final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Following) */ { public: inline Expression_WindowFunction_Bound_Following() : Expression_WindowFunction_Bound_Following(nullptr) {} @@ -2777,8 +2958,13 @@ class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : return *this; } inline Expression_WindowFunction_Bound_Following& operator=(Expression_WindowFunction_Bound_Following&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2809,7 +2995,12 @@ class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : } inline void Swap(Expression_WindowFunction_Bound_Following* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2817,48 +3008,53 @@ class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_WindowFunction_Bound_Following* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_WindowFunction_Bound_Following* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_WindowFunction_Bound_Following* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_WindowFunction_Bound_Following* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_WindowFunction_Bound_Following& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_WindowFunction_Bound_Following& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_WindowFunction_Bound_Following* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.WindowFunction.Bound.Following"; } protected: - explicit Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2870,11 +3066,11 @@ class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : }; // int64 offset = 1; void clear_offset(); - ::PROTOBUF_NAMESPACE_ID::int64 offset() const; - void set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t offset() const; + void set_offset(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_offset() const; - void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_offset() const; + void _internal_set_offset(int64_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Following) @@ -2884,17 +3080,16 @@ class Expression_WindowFunction_Bound_Following PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int64 offset_; + int64_t offset_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.CurrentRow) */ { +class Expression_WindowFunction_Bound_CurrentRow final : + public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.CurrentRow) */ { public: inline Expression_WindowFunction_Bound_CurrentRow() : Expression_WindowFunction_Bound_CurrentRow(nullptr) {} - ~Expression_WindowFunction_Bound_CurrentRow() override; explicit constexpr Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Expression_WindowFunction_Bound_CurrentRow(const Expression_WindowFunction_Bound_CurrentRow& from); @@ -2908,8 +3103,13 @@ class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : return *this; } inline Expression_WindowFunction_Bound_CurrentRow& operator=(Expression_WindowFunction_Bound_CurrentRow&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2940,7 +3140,12 @@ class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : } inline void Swap(Expression_WindowFunction_Bound_CurrentRow* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2948,48 +3153,39 @@ class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_WindowFunction_Bound_CurrentRow* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_WindowFunction_Bound_CurrentRow* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_WindowFunction_Bound_CurrentRow* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_WindowFunction_Bound_CurrentRow* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Expression_WindowFunction_Bound_CurrentRow& from); - void MergeFrom(const Expression_WindowFunction_Bound_CurrentRow& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const Expression_WindowFunction_Bound_CurrentRow& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const Expression_WindowFunction_Bound_CurrentRow& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); + } + public: private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_WindowFunction_Bound_CurrentRow* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.WindowFunction.Bound.CurrentRow"; } protected: - explicit Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3008,11 +3204,10 @@ class Expression_WindowFunction_Bound_CurrentRow PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Unbounded) */ { +class Expression_WindowFunction_Bound_Unbounded final : + public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Unbounded) */ { public: inline Expression_WindowFunction_Bound_Unbounded() : Expression_WindowFunction_Bound_Unbounded(nullptr) {} - ~Expression_WindowFunction_Bound_Unbounded() override; explicit constexpr Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Expression_WindowFunction_Bound_Unbounded(const Expression_WindowFunction_Bound_Unbounded& from); @@ -3026,8 +3221,13 @@ class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : return *this; } inline Expression_WindowFunction_Bound_Unbounded& operator=(Expression_WindowFunction_Bound_Unbounded&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3058,7 +3258,12 @@ class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : } inline void Swap(Expression_WindowFunction_Bound_Unbounded* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3066,48 +3271,39 @@ class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_WindowFunction_Bound_Unbounded* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_WindowFunction_Bound_Unbounded* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_WindowFunction_Bound_Unbounded* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_WindowFunction_Bound_Unbounded* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Expression_WindowFunction_Bound_Unbounded& from); - void MergeFrom(const Expression_WindowFunction_Bound_Unbounded& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const Expression_WindowFunction_Bound_Unbounded& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const Expression_WindowFunction_Bound_Unbounded& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); + } + public: private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_WindowFunction_Bound_Unbounded* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.WindowFunction.Bound.Unbounded"; } protected: - explicit Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3126,7 +3322,7 @@ class Expression_WindowFunction_Bound_Unbounded PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_WindowFunction_Bound PROTOBUF_FINAL : +class Expression_WindowFunction_Bound final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound) */ { public: inline Expression_WindowFunction_Bound() : Expression_WindowFunction_Bound(nullptr) {} @@ -3144,8 +3340,13 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : return *this; } inline Expression_WindowFunction_Bound& operator=(Expression_WindowFunction_Bound&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3184,7 +3385,12 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : } inline void Swap(Expression_WindowFunction_Bound* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3192,48 +3398,53 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_WindowFunction_Bound* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_WindowFunction_Bound* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_WindowFunction_Bound* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_WindowFunction_Bound* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_WindowFunction_Bound& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_WindowFunction_Bound& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_WindowFunction_Bound* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.WindowFunction.Bound"; } protected: - explicit Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3258,7 +3469,7 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : public: void clear_preceding(); const ::substrait::Expression_WindowFunction_Bound_Preceding& preceding() const; - ::substrait::Expression_WindowFunction_Bound_Preceding* release_preceding(); + PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_Preceding* release_preceding(); ::substrait::Expression_WindowFunction_Bound_Preceding* mutable_preceding(); void set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding); private: @@ -3276,7 +3487,7 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : public: void clear_following(); const ::substrait::Expression_WindowFunction_Bound_Following& following() const; - ::substrait::Expression_WindowFunction_Bound_Following* release_following(); + PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_Following* release_following(); ::substrait::Expression_WindowFunction_Bound_Following* mutable_following(); void set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following); private: @@ -3294,7 +3505,7 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : public: void clear_current_row(); const ::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row() const; - ::substrait::Expression_WindowFunction_Bound_CurrentRow* release_current_row(); + PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_CurrentRow* release_current_row(); ::substrait::Expression_WindowFunction_Bound_CurrentRow* mutable_current_row(); void set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row); private: @@ -3312,7 +3523,7 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : public: void clear_unbounded(); const ::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded() const; - ::substrait::Expression_WindowFunction_Bound_Unbounded* release_unbounded(); + PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_Unbounded* release_unbounded(); ::substrait::Expression_WindowFunction_Bound_Unbounded* mutable_unbounded(); void set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded); private: @@ -3348,13 +3559,13 @@ class Expression_WindowFunction_Bound PROTOBUF_FINAL : ::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_WindowFunction PROTOBUF_FINAL : +class Expression_WindowFunction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction) */ { public: inline Expression_WindowFunction() : Expression_WindowFunction(nullptr) {} @@ -3372,8 +3583,13 @@ class Expression_WindowFunction PROTOBUF_FINAL : return *this; } inline Expression_WindowFunction& operator=(Expression_WindowFunction&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3404,7 +3620,12 @@ class Expression_WindowFunction PROTOBUF_FINAL : } inline void Swap(Expression_WindowFunction* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3412,48 +3633,53 @@ class Expression_WindowFunction PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_WindowFunction* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_WindowFunction* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_WindowFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_WindowFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_WindowFunction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_WindowFunction& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_WindowFunction* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.WindowFunction"; } protected: - explicit Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3533,7 +3759,7 @@ class Expression_WindowFunction PROTOBUF_FINAL : public: void clear_upper_bound(); const ::substrait::Expression_WindowFunction_Bound& upper_bound() const; - ::substrait::Expression_WindowFunction_Bound* release_upper_bound(); + PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound* release_upper_bound(); ::substrait::Expression_WindowFunction_Bound* mutable_upper_bound(); void set_allocated_upper_bound(::substrait::Expression_WindowFunction_Bound* upper_bound); private: @@ -3551,7 +3777,7 @@ class Expression_WindowFunction PROTOBUF_FINAL : public: void clear_lower_bound(); const ::substrait::Expression_WindowFunction_Bound& lower_bound() const; - ::substrait::Expression_WindowFunction_Bound* release_lower_bound(); + PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound* release_lower_bound(); ::substrait::Expression_WindowFunction_Bound* mutable_lower_bound(); void set_allocated_lower_bound(::substrait::Expression_WindowFunction_Bound* lower_bound); private: @@ -3569,7 +3795,7 @@ class Expression_WindowFunction PROTOBUF_FINAL : public: void clear_output_type(); const ::substrait::Type& output_type() const; - ::substrait::Type* release_output_type(); + PROTOBUF_NODISCARD ::substrait::Type* release_output_type(); ::substrait::Type* mutable_output_type(); void set_allocated_output_type(::substrait::Type* output_type); private: @@ -3582,11 +3808,11 @@ class Expression_WindowFunction PROTOBUF_FINAL : // uint32 function_reference = 1; void clear_function_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 function_reference() const; - void set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t function_reference() const; + void set_function_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_function_reference() const; - void _internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_function_reference() const; + void _internal_set_function_reference(uint32_t value); public: // .substrait.AggregationPhase phase = 6; @@ -3611,14 +3837,14 @@ class Expression_WindowFunction PROTOBUF_FINAL : ::substrait::Expression_WindowFunction_Bound* upper_bound_; ::substrait::Expression_WindowFunction_Bound* lower_bound_; ::substrait::Type* output_type_; - ::PROTOBUF_NAMESPACE_ID::uint32 function_reference_; + uint32_t function_reference_; int phase_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_IfThen_IfClause PROTOBUF_FINAL : +class Expression_IfThen_IfClause final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.IfThen.IfClause) */ { public: inline Expression_IfThen_IfClause() : Expression_IfThen_IfClause(nullptr) {} @@ -3636,8 +3862,13 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : return *this; } inline Expression_IfThen_IfClause& operator=(Expression_IfThen_IfClause&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3668,7 +3899,12 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : } inline void Swap(Expression_IfThen_IfClause* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3676,48 +3912,53 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_IfThen_IfClause* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_IfThen_IfClause* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_IfThen_IfClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_IfThen_IfClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_IfThen_IfClause& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_IfThen_IfClause& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_IfThen_IfClause* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.IfThen.IfClause"; } protected: - explicit Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3735,7 +3976,7 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : public: void clear_if_(); const ::substrait::Expression& if_() const; - ::substrait::Expression* release_if_(); + PROTOBUF_NODISCARD ::substrait::Expression* release_if_(); ::substrait::Expression* mutable_if_(); void set_allocated_if_(::substrait::Expression* if_); private: @@ -3753,7 +3994,7 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : public: void clear_then(); const ::substrait::Expression& then() const; - ::substrait::Expression* release_then(); + PROTOBUF_NODISCARD ::substrait::Expression* release_then(); ::substrait::Expression* mutable_then(); void set_allocated_then(::substrait::Expression* then); private: @@ -3778,7 +4019,7 @@ class Expression_IfThen_IfClause PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_IfThen PROTOBUF_FINAL : +class Expression_IfThen final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.IfThen) */ { public: inline Expression_IfThen() : Expression_IfThen(nullptr) {} @@ -3796,8 +4037,13 @@ class Expression_IfThen PROTOBUF_FINAL : return *this; } inline Expression_IfThen& operator=(Expression_IfThen&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3828,7 +4074,12 @@ class Expression_IfThen PROTOBUF_FINAL : } inline void Swap(Expression_IfThen* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3836,48 +4087,53 @@ class Expression_IfThen PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_IfThen* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_IfThen* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_IfThen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_IfThen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_IfThen& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_IfThen& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_IfThen* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.IfThen"; } protected: - explicit Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3915,7 +4171,7 @@ class Expression_IfThen PROTOBUF_FINAL : public: void clear_else_(); const ::substrait::Expression& else_() const; - ::substrait::Expression* release_else_(); + PROTOBUF_NODISCARD ::substrait::Expression* release_else_(); ::substrait::Expression* mutable_else_(); void set_allocated_else_(::substrait::Expression* else_); private: @@ -3940,7 +4196,7 @@ class Expression_IfThen PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_Cast PROTOBUF_FINAL : +class Expression_Cast final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Cast) */ { public: inline Expression_Cast() : Expression_Cast(nullptr) {} @@ -3958,8 +4214,13 @@ class Expression_Cast PROTOBUF_FINAL : return *this; } inline Expression_Cast& operator=(Expression_Cast&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3990,7 +4251,12 @@ class Expression_Cast PROTOBUF_FINAL : } inline void Swap(Expression_Cast* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3998,48 +4264,53 @@ class Expression_Cast PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_Cast* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_Cast* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_Cast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_Cast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_Cast& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_Cast& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_Cast* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.Cast"; } protected: - explicit Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4057,7 +4328,7 @@ class Expression_Cast PROTOBUF_FINAL : public: void clear_type(); const ::substrait::Type& type() const; - ::substrait::Type* release_type(); + PROTOBUF_NODISCARD ::substrait::Type* release_type(); ::substrait::Type* mutable_type(); void set_allocated_type(::substrait::Type* type); private: @@ -4075,7 +4346,7 @@ class Expression_Cast PROTOBUF_FINAL : public: void clear_input(); const ::substrait::Expression& input() const; - ::substrait::Expression* release_input(); + PROTOBUF_NODISCARD ::substrait::Expression* release_input(); ::substrait::Expression* mutable_input(); void set_allocated_input(::substrait::Expression* input); private: @@ -4100,7 +4371,7 @@ class Expression_Cast PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : +class Expression_SwitchExpression_IfValue final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SwitchExpression.IfValue) */ { public: inline Expression_SwitchExpression_IfValue() : Expression_SwitchExpression_IfValue(nullptr) {} @@ -4118,8 +4389,13 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : return *this; } inline Expression_SwitchExpression_IfValue& operator=(Expression_SwitchExpression_IfValue&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4150,7 +4426,12 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : } inline void Swap(Expression_SwitchExpression_IfValue* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4158,48 +4439,53 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_SwitchExpression_IfValue* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_SwitchExpression_IfValue* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_SwitchExpression_IfValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_SwitchExpression_IfValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_SwitchExpression_IfValue& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_SwitchExpression_IfValue& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_SwitchExpression_IfValue* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.SwitchExpression.IfValue"; } protected: - explicit Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4217,7 +4503,7 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : public: void clear_if_(); const ::substrait::Expression_Literal& if_() const; - ::substrait::Expression_Literal* release_if_(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_if_(); ::substrait::Expression_Literal* mutable_if_(); void set_allocated_if_(::substrait::Expression_Literal* if_); private: @@ -4235,7 +4521,7 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : public: void clear_then(); const ::substrait::Expression& then() const; - ::substrait::Expression* release_then(); + PROTOBUF_NODISCARD ::substrait::Expression* release_then(); ::substrait::Expression* mutable_then(); void set_allocated_then(::substrait::Expression* then); private: @@ -4260,7 +4546,7 @@ class Expression_SwitchExpression_IfValue PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_SwitchExpression PROTOBUF_FINAL : +class Expression_SwitchExpression final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SwitchExpression) */ { public: inline Expression_SwitchExpression() : Expression_SwitchExpression(nullptr) {} @@ -4278,8 +4564,13 @@ class Expression_SwitchExpression PROTOBUF_FINAL : return *this; } inline Expression_SwitchExpression& operator=(Expression_SwitchExpression&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4310,7 +4601,12 @@ class Expression_SwitchExpression PROTOBUF_FINAL : } inline void Swap(Expression_SwitchExpression* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4318,48 +4614,53 @@ class Expression_SwitchExpression PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_SwitchExpression* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_SwitchExpression* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_SwitchExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_SwitchExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_SwitchExpression& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_SwitchExpression& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_SwitchExpression* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.SwitchExpression"; } protected: - explicit Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4397,7 +4698,7 @@ class Expression_SwitchExpression PROTOBUF_FINAL : public: void clear_else_(); const ::substrait::Expression& else_() const; - ::substrait::Expression* release_else_(); + PROTOBUF_NODISCARD ::substrait::Expression* release_else_(); ::substrait::Expression* mutable_else_(); void set_allocated_else_(::substrait::Expression* else_); private: @@ -4422,7 +4723,7 @@ class Expression_SwitchExpression PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_SingularOrList PROTOBUF_FINAL : +class Expression_SingularOrList final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SingularOrList) */ { public: inline Expression_SingularOrList() : Expression_SingularOrList(nullptr) {} @@ -4440,8 +4741,13 @@ class Expression_SingularOrList PROTOBUF_FINAL : return *this; } inline Expression_SingularOrList& operator=(Expression_SingularOrList&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4472,7 +4778,12 @@ class Expression_SingularOrList PROTOBUF_FINAL : } inline void Swap(Expression_SingularOrList* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4480,48 +4791,53 @@ class Expression_SingularOrList PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_SingularOrList* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_SingularOrList* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_SingularOrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_SingularOrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_SingularOrList& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_SingularOrList& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_SingularOrList* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.SingularOrList"; } protected: - explicit Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4557,7 +4873,7 @@ class Expression_SingularOrList PROTOBUF_FINAL : public: void clear_value(); const ::substrait::Expression& value() const; - ::substrait::Expression* release_value(); + PROTOBUF_NODISCARD ::substrait::Expression* release_value(); ::substrait::Expression* mutable_value(); void set_allocated_value(::substrait::Expression* value); private: @@ -4582,7 +4898,7 @@ class Expression_SingularOrList PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_MultiOrList_Record PROTOBUF_FINAL : +class Expression_MultiOrList_Record final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MultiOrList.Record) */ { public: inline Expression_MultiOrList_Record() : Expression_MultiOrList_Record(nullptr) {} @@ -4600,8 +4916,13 @@ class Expression_MultiOrList_Record PROTOBUF_FINAL : return *this; } inline Expression_MultiOrList_Record& operator=(Expression_MultiOrList_Record&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4632,7 +4953,12 @@ class Expression_MultiOrList_Record PROTOBUF_FINAL : } inline void Swap(Expression_MultiOrList_Record* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4640,48 +4966,53 @@ class Expression_MultiOrList_Record PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MultiOrList_Record* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MultiOrList_Record* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MultiOrList_Record* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MultiOrList_Record* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MultiOrList_Record& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MultiOrList_Record& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MultiOrList_Record* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MultiOrList.Record"; } protected: - explicit Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4722,7 +5053,7 @@ class Expression_MultiOrList_Record PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_MultiOrList PROTOBUF_FINAL : +class Expression_MultiOrList final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MultiOrList) */ { public: inline Expression_MultiOrList() : Expression_MultiOrList(nullptr) {} @@ -4740,8 +5071,13 @@ class Expression_MultiOrList PROTOBUF_FINAL : return *this; } inline Expression_MultiOrList& operator=(Expression_MultiOrList&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4772,7 +5108,12 @@ class Expression_MultiOrList PROTOBUF_FINAL : } inline void Swap(Expression_MultiOrList* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4780,48 +5121,53 @@ class Expression_MultiOrList PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MultiOrList* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MultiOrList* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MultiOrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MultiOrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MultiOrList& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MultiOrList& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MultiOrList* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MultiOrList"; } protected: - explicit Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4884,7 +5230,7 @@ class Expression_MultiOrList PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : +class Expression_EmbeddedFunction_PythonPickleFunction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction.PythonPickleFunction) */ { public: inline Expression_EmbeddedFunction_PythonPickleFunction() : Expression_EmbeddedFunction_PythonPickleFunction(nullptr) {} @@ -4902,8 +5248,13 @@ class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : return *this; } inline Expression_EmbeddedFunction_PythonPickleFunction& operator=(Expression_EmbeddedFunction_PythonPickleFunction&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4934,7 +5285,12 @@ class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : } inline void Swap(Expression_EmbeddedFunction_PythonPickleFunction* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4942,48 +5298,53 @@ class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_EmbeddedFunction_PythonPickleFunction* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_EmbeddedFunction_PythonPickleFunction* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_EmbeddedFunction_PythonPickleFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_EmbeddedFunction_PythonPickleFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_EmbeddedFunction_PythonPickleFunction* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.EmbeddedFunction.PythonPickleFunction"; } protected: - explicit Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -5024,11 +5385,11 @@ class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : template void set_function(ArgT0&& arg0, ArgT... args); std::string* mutable_function(); - std::string* release_function(); + PROTOBUF_NODISCARD std::string* release_function(); void set_allocated_function(std::string* function); private: const std::string& _internal_function() const; - void _internal_set_function(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_function(const std::string& value); std::string* _internal_mutable_function(); public: @@ -5046,7 +5407,7 @@ class Expression_EmbeddedFunction_PythonPickleFunction PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : +class Expression_EmbeddedFunction_WebAssemblyFunction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) */ { public: inline Expression_EmbeddedFunction_WebAssemblyFunction() : Expression_EmbeddedFunction_WebAssemblyFunction(nullptr) {} @@ -5064,8 +5425,13 @@ class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : return *this; } inline Expression_EmbeddedFunction_WebAssemblyFunction& operator=(Expression_EmbeddedFunction_WebAssemblyFunction&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -5096,7 +5462,12 @@ class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : } inline void Swap(Expression_EmbeddedFunction_WebAssemblyFunction* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -5104,48 +5475,53 @@ class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_EmbeddedFunction_WebAssemblyFunction* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_EmbeddedFunction_WebAssemblyFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_EmbeddedFunction_WebAssemblyFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.EmbeddedFunction.WebAssemblyFunction"; } protected: - explicit Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -5186,11 +5562,11 @@ class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : template void set_script(ArgT0&& arg0, ArgT... args); std::string* mutable_script(); - std::string* release_script(); + PROTOBUF_NODISCARD std::string* release_script(); void set_allocated_script(std::string* script); private: const std::string& _internal_script() const; - void _internal_set_script(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_script(const std::string& value); std::string* _internal_mutable_script(); public: @@ -5208,7 +5584,7 @@ class Expression_EmbeddedFunction_WebAssemblyFunction PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_EmbeddedFunction PROTOBUF_FINAL : +class Expression_EmbeddedFunction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction) */ { public: inline Expression_EmbeddedFunction() : Expression_EmbeddedFunction(nullptr) {} @@ -5226,8 +5602,13 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : return *this; } inline Expression_EmbeddedFunction& operator=(Expression_EmbeddedFunction&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -5264,7 +5645,12 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : } inline void Swap(Expression_EmbeddedFunction* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -5272,48 +5658,53 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_EmbeddedFunction* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_EmbeddedFunction* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_EmbeddedFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_EmbeddedFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_EmbeddedFunction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_EmbeddedFunction& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_EmbeddedFunction* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.EmbeddedFunction"; } protected: - explicit Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -5354,7 +5745,7 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : public: void clear_output_type(); const ::substrait::Type& output_type() const; - ::substrait::Type* release_output_type(); + PROTOBUF_NODISCARD ::substrait::Type* release_output_type(); ::substrait::Type* mutable_output_type(); void set_allocated_output_type(::substrait::Type* output_type); private: @@ -5372,7 +5763,7 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : public: void clear_python_pickle_function(); const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function() const; - ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* release_python_pickle_function(); + PROTOBUF_NODISCARD ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* release_python_pickle_function(); ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* mutable_python_pickle_function(); void set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function); private: @@ -5390,7 +5781,7 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : public: void clear_web_assembly_function(); const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function() const; - ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* release_web_assembly_function(); + PROTOBUF_NODISCARD ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* release_web_assembly_function(); ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* mutable_web_assembly_function(); void set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function); private: @@ -5424,13 +5815,13 @@ class Expression_EmbeddedFunction PROTOBUF_FINAL : ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : +class Expression_ReferenceSegment_MapKey final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.MapKey) */ { public: inline Expression_ReferenceSegment_MapKey() : Expression_ReferenceSegment_MapKey(nullptr) {} @@ -5448,8 +5839,13 @@ class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : return *this; } inline Expression_ReferenceSegment_MapKey& operator=(Expression_ReferenceSegment_MapKey&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -5480,7 +5876,12 @@ class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : } inline void Swap(Expression_ReferenceSegment_MapKey* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -5488,48 +5889,53 @@ class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_ReferenceSegment_MapKey* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_ReferenceSegment_MapKey* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_ReferenceSegment_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_ReferenceSegment_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_ReferenceSegment_MapKey& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_ReferenceSegment_MapKey& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_ReferenceSegment_MapKey* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.ReferenceSegment.MapKey"; } protected: - explicit Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -5547,7 +5953,7 @@ class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : public: void clear_map_key(); const ::substrait::Expression_Literal& map_key() const; - ::substrait::Expression_Literal* release_map_key(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_map_key(); ::substrait::Expression_Literal* mutable_map_key(); void set_allocated_map_key(::substrait::Expression_Literal* map_key); private: @@ -5565,7 +5971,7 @@ class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : public: void clear_child(); const ::substrait::Expression_ReferenceSegment& child() const; - ::substrait::Expression_ReferenceSegment* release_child(); + PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_child(); ::substrait::Expression_ReferenceSegment* mutable_child(); void set_allocated_child(::substrait::Expression_ReferenceSegment* child); private: @@ -5590,7 +5996,7 @@ class Expression_ReferenceSegment_MapKey PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : +class Expression_ReferenceSegment_StructField final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.StructField) */ { public: inline Expression_ReferenceSegment_StructField() : Expression_ReferenceSegment_StructField(nullptr) {} @@ -5608,8 +6014,13 @@ class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : return *this; } inline Expression_ReferenceSegment_StructField& operator=(Expression_ReferenceSegment_StructField&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -5640,7 +6051,12 @@ class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : } inline void Swap(Expression_ReferenceSegment_StructField* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -5648,48 +6064,53 @@ class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_ReferenceSegment_StructField* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_ReferenceSegment_StructField* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_ReferenceSegment_StructField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_ReferenceSegment_StructField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_ReferenceSegment_StructField& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_ReferenceSegment_StructField& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_ReferenceSegment_StructField* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.ReferenceSegment.StructField"; } protected: - explicit Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -5707,7 +6128,7 @@ class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : public: void clear_child(); const ::substrait::Expression_ReferenceSegment& child() const; - ::substrait::Expression_ReferenceSegment* release_child(); + PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_child(); ::substrait::Expression_ReferenceSegment* mutable_child(); void set_allocated_child(::substrait::Expression_ReferenceSegment* child); private: @@ -5720,11 +6141,11 @@ class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : // int32 field = 1; void clear_field(); - ::PROTOBUF_NAMESPACE_ID::int32 field() const; - void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t field() const; + void set_field(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; - void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_field() const; + void _internal_set_field(int32_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.StructField) @@ -5735,13 +6156,13 @@ class Expression_ReferenceSegment_StructField PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::Expression_ReferenceSegment* child_; - ::PROTOBUF_NAMESPACE_ID::int32 field_; + int32_t field_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : +class Expression_ReferenceSegment_ListElement final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.ListElement) */ { public: inline Expression_ReferenceSegment_ListElement() : Expression_ReferenceSegment_ListElement(nullptr) {} @@ -5759,8 +6180,13 @@ class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : return *this; } inline Expression_ReferenceSegment_ListElement& operator=(Expression_ReferenceSegment_ListElement&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -5791,7 +6217,12 @@ class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : } inline void Swap(Expression_ReferenceSegment_ListElement* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -5799,48 +6230,53 @@ class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_ReferenceSegment_ListElement* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_ReferenceSegment_ListElement* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_ReferenceSegment_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_ReferenceSegment_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_ReferenceSegment_ListElement& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_ReferenceSegment_ListElement& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_ReferenceSegment_ListElement* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.ReferenceSegment.ListElement"; } protected: - explicit Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -5858,7 +6294,7 @@ class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : public: void clear_child(); const ::substrait::Expression_ReferenceSegment& child() const; - ::substrait::Expression_ReferenceSegment* release_child(); + PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_child(); ::substrait::Expression_ReferenceSegment* mutable_child(); void set_allocated_child(::substrait::Expression_ReferenceSegment* child); private: @@ -5871,11 +6307,11 @@ class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : // int32 offset = 1; void clear_offset(); - ::PROTOBUF_NAMESPACE_ID::int32 offset() const; - void set_offset(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t offset() const; + void set_offset(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_offset() const; - void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_offset() const; + void _internal_set_offset(int32_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.ListElement) @@ -5886,13 +6322,13 @@ class Expression_ReferenceSegment_ListElement PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::Expression_ReferenceSegment* child_; - ::PROTOBUF_NAMESPACE_ID::int32 offset_; + int32_t offset_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_ReferenceSegment PROTOBUF_FINAL : +class Expression_ReferenceSegment final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment) */ { public: inline Expression_ReferenceSegment() : Expression_ReferenceSegment(nullptr) {} @@ -5910,8 +6346,13 @@ class Expression_ReferenceSegment PROTOBUF_FINAL : return *this; } inline Expression_ReferenceSegment& operator=(Expression_ReferenceSegment&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -5949,7 +6390,12 @@ class Expression_ReferenceSegment PROTOBUF_FINAL : } inline void Swap(Expression_ReferenceSegment* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -5957,48 +6403,53 @@ class Expression_ReferenceSegment PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_ReferenceSegment* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_ReferenceSegment* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_ReferenceSegment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_ReferenceSegment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_ReferenceSegment& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_ReferenceSegment& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_ReferenceSegment* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.ReferenceSegment"; } protected: - explicit Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -6021,7 +6472,7 @@ class Expression_ReferenceSegment PROTOBUF_FINAL : public: void clear_map_key(); const ::substrait::Expression_ReferenceSegment_MapKey& map_key() const; - ::substrait::Expression_ReferenceSegment_MapKey* release_map_key(); + PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment_MapKey* release_map_key(); ::substrait::Expression_ReferenceSegment_MapKey* mutable_map_key(); void set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key); private: @@ -6039,7 +6490,7 @@ class Expression_ReferenceSegment PROTOBUF_FINAL : public: void clear_struct_field(); const ::substrait::Expression_ReferenceSegment_StructField& struct_field() const; - ::substrait::Expression_ReferenceSegment_StructField* release_struct_field(); + PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment_StructField* release_struct_field(); ::substrait::Expression_ReferenceSegment_StructField* mutable_struct_field(); void set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field); private: @@ -6057,7 +6508,7 @@ class Expression_ReferenceSegment PROTOBUF_FINAL : public: void clear_list_element(); const ::substrait::Expression_ReferenceSegment_ListElement& list_element() const; - ::substrait::Expression_ReferenceSegment_ListElement* release_list_element(); + PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment_ListElement* release_list_element(); ::substrait::Expression_ReferenceSegment_ListElement* mutable_list_element(); void set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element); private: @@ -6091,13 +6542,13 @@ class Expression_ReferenceSegment PROTOBUF_FINAL : ::substrait::Expression_ReferenceSegment_ListElement* list_element_; } reference_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_MaskExpression_Select PROTOBUF_FINAL : +class Expression_MaskExpression_Select final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.Select) */ { public: inline Expression_MaskExpression_Select() : Expression_MaskExpression_Select(nullptr) {} @@ -6115,8 +6566,13 @@ class Expression_MaskExpression_Select PROTOBUF_FINAL : return *this; } inline Expression_MaskExpression_Select& operator=(Expression_MaskExpression_Select&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -6154,7 +6610,12 @@ class Expression_MaskExpression_Select PROTOBUF_FINAL : } inline void Swap(Expression_MaskExpression_Select* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -6162,48 +6623,53 @@ class Expression_MaskExpression_Select PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MaskExpression_Select* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression_Select* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression_Select* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression_Select* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression_Select& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression_Select& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression_Select* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression.Select"; } protected: - explicit Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -6222,7 +6688,7 @@ class Expression_MaskExpression_Select PROTOBUF_FINAL : public: void clear_struct_(); const ::substrait::Expression_MaskExpression_StructSelect& struct_() const; - ::substrait::Expression_MaskExpression_StructSelect* release_struct_(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_StructSelect* release_struct_(); ::substrait::Expression_MaskExpression_StructSelect* mutable_struct_(); void set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_); private: @@ -6240,7 +6706,7 @@ class Expression_MaskExpression_Select PROTOBUF_FINAL : public: void clear_list(); const ::substrait::Expression_MaskExpression_ListSelect& list() const; - ::substrait::Expression_MaskExpression_ListSelect* release_list(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_ListSelect* release_list(); ::substrait::Expression_MaskExpression_ListSelect* mutable_list(); void set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list); private: @@ -6258,7 +6724,7 @@ class Expression_MaskExpression_Select PROTOBUF_FINAL : public: void clear_map(); const ::substrait::Expression_MaskExpression_MapSelect& map() const; - ::substrait::Expression_MaskExpression_MapSelect* release_map(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_MapSelect* release_map(); ::substrait::Expression_MaskExpression_MapSelect* mutable_map(); void set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map); private: @@ -6292,13 +6758,13 @@ class Expression_MaskExpression_Select PROTOBUF_FINAL : ::substrait::Expression_MaskExpression_MapSelect* map_; } type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_MaskExpression_StructSelect PROTOBUF_FINAL : +class Expression_MaskExpression_StructSelect final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.StructSelect) */ { public: inline Expression_MaskExpression_StructSelect() : Expression_MaskExpression_StructSelect(nullptr) {} @@ -6316,8 +6782,13 @@ class Expression_MaskExpression_StructSelect PROTOBUF_FINAL : return *this; } inline Expression_MaskExpression_StructSelect& operator=(Expression_MaskExpression_StructSelect&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -6348,7 +6819,12 @@ class Expression_MaskExpression_StructSelect PROTOBUF_FINAL : } inline void Swap(Expression_MaskExpression_StructSelect* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -6356,48 +6832,53 @@ class Expression_MaskExpression_StructSelect PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MaskExpression_StructSelect* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression_StructSelect* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression_StructSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression_StructSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression_StructSelect& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression_StructSelect& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression_StructSelect* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression.StructSelect"; } protected: - explicit Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -6438,7 +6919,7 @@ class Expression_MaskExpression_StructSelect PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_MaskExpression_StructItem PROTOBUF_FINAL : +class Expression_MaskExpression_StructItem final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.StructItem) */ { public: inline Expression_MaskExpression_StructItem() : Expression_MaskExpression_StructItem(nullptr) {} @@ -6456,8 +6937,13 @@ class Expression_MaskExpression_StructItem PROTOBUF_FINAL : return *this; } inline Expression_MaskExpression_StructItem& operator=(Expression_MaskExpression_StructItem&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -6488,7 +6974,12 @@ class Expression_MaskExpression_StructItem PROTOBUF_FINAL : } inline void Swap(Expression_MaskExpression_StructItem* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -6496,48 +6987,53 @@ class Expression_MaskExpression_StructItem PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MaskExpression_StructItem* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression_StructItem* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression_StructItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression_StructItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression_StructItem& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression_StructItem& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression_StructItem* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression.StructItem"; } protected: - explicit Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -6555,7 +7051,7 @@ class Expression_MaskExpression_StructItem PROTOBUF_FINAL : public: void clear_child(); const ::substrait::Expression_MaskExpression_Select& child() const; - ::substrait::Expression_MaskExpression_Select* release_child(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_Select* release_child(); ::substrait::Expression_MaskExpression_Select* mutable_child(); void set_allocated_child(::substrait::Expression_MaskExpression_Select* child); private: @@ -6568,11 +7064,11 @@ class Expression_MaskExpression_StructItem PROTOBUF_FINAL : // int32 field = 1; void clear_field(); - ::PROTOBUF_NAMESPACE_ID::int32 field() const; - void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t field() const; + void set_field(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; - void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_field() const; + void _internal_set_field(int32_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.StructItem) @@ -6583,13 +7079,13 @@ class Expression_MaskExpression_StructItem PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::Expression_MaskExpression_Select* child_; - ::PROTOBUF_NAMESPACE_ID::int32 field_; + int32_t field_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_FINAL : +class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) */ { public: inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() : Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(nullptr) {} @@ -6607,8 +7103,13 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_F return *this; } inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -6639,7 +7140,12 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_F } inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -6647,48 +7153,53 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_F } void UnsafeArenaSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement"; } protected: - explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -6700,11 +7211,11 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_F }; // int32 field = 1; void clear_field(); - ::PROTOBUF_NAMESPACE_ID::int32 field() const; - void set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t field() const; + void set_field(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_field() const; - void _internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_field() const; + void _internal_set_field(int32_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) @@ -6714,13 +7225,13 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement PROTOBUF_F template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 field_; + int32_t field_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FINAL : +class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) */ { public: inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() : Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(nullptr) {} @@ -6738,8 +7249,13 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FIN return *this; } inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -6770,7 +7286,12 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FIN } inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -6778,48 +7299,53 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FIN } void UnsafeArenaSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice"; } protected: - explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -6832,20 +7358,20 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FIN }; // int32 start = 1; void clear_start(); - ::PROTOBUF_NAMESPACE_ID::int32 start() const; - void set_start(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t start() const; + void set_start(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_start() const; - void _internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_start() const; + void _internal_set_start(int32_t value); public: // int32 end = 2; void clear_end(); - ::PROTOBUF_NAMESPACE_ID::int32 end() const; - void set_end(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t end() const; + void set_end(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_end() const; - void _internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_end() const; + void _internal_set_end(int32_t value); public: // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) @@ -6855,14 +7381,14 @@ class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice PROTOBUF_FIN template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 start_; - ::PROTOBUF_NAMESPACE_ID::int32 end_; + int32_t start_; + int32_t end_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : +class Expression_MaskExpression_ListSelect_ListSelectItem final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) */ { public: inline Expression_MaskExpression_ListSelect_ListSelectItem() : Expression_MaskExpression_ListSelect_ListSelectItem(nullptr) {} @@ -6880,8 +7406,13 @@ class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : return *this; } inline Expression_MaskExpression_ListSelect_ListSelectItem& operator=(Expression_MaskExpression_ListSelect_ListSelectItem&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -6918,7 +7449,12 @@ class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : } inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -6926,48 +7462,53 @@ class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression_ListSelect_ListSelectItem* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression_ListSelect_ListSelectItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression_ListSelect_ListSelectItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem"; } protected: - explicit Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -6988,7 +7529,7 @@ class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : public: void clear_item(); const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item() const; - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* release_item(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* release_item(); ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* mutable_item(); void set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item); private: @@ -7006,7 +7547,7 @@ class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : public: void clear_slice(); const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice() const; - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* release_slice(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* release_slice(); ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* mutable_slice(); void set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); private: @@ -7038,13 +7579,13 @@ class Expression_MaskExpression_ListSelect_ListSelectItem PROTOBUF_FINAL : ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice_; } type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_MaskExpression_ListSelect PROTOBUF_FINAL : +class Expression_MaskExpression_ListSelect final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect) */ { public: inline Expression_MaskExpression_ListSelect() : Expression_MaskExpression_ListSelect(nullptr) {} @@ -7062,8 +7603,13 @@ class Expression_MaskExpression_ListSelect PROTOBUF_FINAL : return *this; } inline Expression_MaskExpression_ListSelect& operator=(Expression_MaskExpression_ListSelect&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -7094,7 +7640,12 @@ class Expression_MaskExpression_ListSelect PROTOBUF_FINAL : } inline void Swap(Expression_MaskExpression_ListSelect* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -7102,48 +7653,53 @@ class Expression_MaskExpression_ListSelect PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MaskExpression_ListSelect* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression_ListSelect* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression_ListSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression_ListSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression_ListSelect& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression_ListSelect& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression_ListSelect* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression.ListSelect"; } protected: - explicit Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -7181,7 +7737,7 @@ class Expression_MaskExpression_ListSelect PROTOBUF_FINAL : public: void clear_child(); const ::substrait::Expression_MaskExpression_Select& child() const; - ::substrait::Expression_MaskExpression_Select* release_child(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_Select* release_child(); ::substrait::Expression_MaskExpression_Select* mutable_child(); void set_allocated_child(::substrait::Expression_MaskExpression_Select* child); private: @@ -7206,7 +7762,7 @@ class Expression_MaskExpression_ListSelect PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : +class Expression_MaskExpression_MapSelect_MapKey final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect.MapKey) */ { public: inline Expression_MaskExpression_MapSelect_MapKey() : Expression_MaskExpression_MapSelect_MapKey(nullptr) {} @@ -7224,8 +7780,13 @@ class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : return *this; } inline Expression_MaskExpression_MapSelect_MapKey& operator=(Expression_MaskExpression_MapSelect_MapKey&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -7256,7 +7817,12 @@ class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : } inline void Swap(Expression_MaskExpression_MapSelect_MapKey* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -7264,48 +7830,53 @@ class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MaskExpression_MapSelect_MapKey* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression_MapSelect_MapKey* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression_MapSelect_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression_MapSelect_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression_MapSelect_MapKey& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression_MapSelect_MapKey& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression_MapSelect_MapKey* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression.MapSelect.MapKey"; } protected: - explicit Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -7321,11 +7892,11 @@ class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : template void set_map_key(ArgT0&& arg0, ArgT... args); std::string* mutable_map_key(); - std::string* release_map_key(); + PROTOBUF_NODISCARD std::string* release_map_key(); void set_allocated_map_key(std::string* map_key); private: const std::string& _internal_map_key() const; - void _internal_set_map_key(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_map_key(const std::string& value); std::string* _internal_mutable_map_key(); public: @@ -7342,7 +7913,7 @@ class Expression_MaskExpression_MapSelect_MapKey PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : +class Expression_MaskExpression_MapSelect_MapKeyExpression final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) */ { public: inline Expression_MaskExpression_MapSelect_MapKeyExpression() : Expression_MaskExpression_MapSelect_MapKeyExpression(nullptr) {} @@ -7360,8 +7931,13 @@ class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : return *this; } inline Expression_MaskExpression_MapSelect_MapKeyExpression& operator=(Expression_MaskExpression_MapSelect_MapKeyExpression&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -7392,7 +7968,12 @@ class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : } inline void Swap(Expression_MaskExpression_MapSelect_MapKeyExpression* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -7400,48 +7981,53 @@ class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression_MapSelect_MapKeyExpression* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression_MapSelect_MapKeyExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression_MapSelect_MapKeyExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression"; } protected: - explicit Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -7457,11 +8043,11 @@ class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : template void set_map_key_expression(ArgT0&& arg0, ArgT... args); std::string* mutable_map_key_expression(); - std::string* release_map_key_expression(); + PROTOBUF_NODISCARD std::string* release_map_key_expression(); void set_allocated_map_key_expression(std::string* map_key_expression); private: const std::string& _internal_map_key_expression() const; - void _internal_set_map_key_expression(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_map_key_expression(const std::string& value); std::string* _internal_mutable_map_key_expression(); public: @@ -7478,7 +8064,7 @@ class Expression_MaskExpression_MapSelect_MapKeyExpression PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : +class Expression_MaskExpression_MapSelect final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect) */ { public: inline Expression_MaskExpression_MapSelect() : Expression_MaskExpression_MapSelect(nullptr) {} @@ -7496,8 +8082,13 @@ class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : return *this; } inline Expression_MaskExpression_MapSelect& operator=(Expression_MaskExpression_MapSelect&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -7534,7 +8125,12 @@ class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : } inline void Swap(Expression_MaskExpression_MapSelect* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -7542,48 +8138,53 @@ class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MaskExpression_MapSelect* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression_MapSelect* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression_MapSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression_MapSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression_MapSelect& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression_MapSelect& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression_MapSelect* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression.MapSelect"; } protected: - explicit Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -7605,7 +8206,7 @@ class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : public: void clear_child(); const ::substrait::Expression_MaskExpression_Select& child() const; - ::substrait::Expression_MaskExpression_Select* release_child(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_Select* release_child(); ::substrait::Expression_MaskExpression_Select* mutable_child(); void set_allocated_child(::substrait::Expression_MaskExpression_Select* child); private: @@ -7623,7 +8224,7 @@ class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : public: void clear_key(); const ::substrait::Expression_MaskExpression_MapSelect_MapKey& key() const; - ::substrait::Expression_MaskExpression_MapSelect_MapKey* release_key(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_MapSelect_MapKey* release_key(); ::substrait::Expression_MaskExpression_MapSelect_MapKey* mutable_key(); void set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key); private: @@ -7641,7 +8242,7 @@ class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : public: void clear_expression(); const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression() const; - ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* release_expression(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* release_expression(); ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* mutable_expression(); void set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression); private: @@ -7674,13 +8275,13 @@ class Expression_MaskExpression_MapSelect PROTOBUF_FINAL : ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression_; } select_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression_MaskExpression PROTOBUF_FINAL : +class Expression_MaskExpression final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression) */ { public: inline Expression_MaskExpression() : Expression_MaskExpression(nullptr) {} @@ -7698,8 +8299,13 @@ class Expression_MaskExpression PROTOBUF_FINAL : return *this; } inline Expression_MaskExpression& operator=(Expression_MaskExpression&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -7730,7 +8336,12 @@ class Expression_MaskExpression PROTOBUF_FINAL : } inline void Swap(Expression_MaskExpression* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -7738,48 +8349,53 @@ class Expression_MaskExpression PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_MaskExpression* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_MaskExpression* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_MaskExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_MaskExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_MaskExpression& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_MaskExpression& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_MaskExpression* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.MaskExpression"; } protected: - explicit Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -7803,7 +8419,7 @@ class Expression_MaskExpression PROTOBUF_FINAL : public: void clear_select(); const ::substrait::Expression_MaskExpression_StructSelect& select() const; - ::substrait::Expression_MaskExpression_StructSelect* release_select(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_StructSelect* release_select(); ::substrait::Expression_MaskExpression_StructSelect* mutable_select(); void set_allocated_select(::substrait::Expression_MaskExpression_StructSelect* select); private: @@ -7837,11 +8453,10 @@ class Expression_MaskExpression PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_FieldReference_RootReference PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.FieldReference.RootReference) */ { +class Expression_FieldReference_RootReference final : + public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.FieldReference.RootReference) */ { public: inline Expression_FieldReference_RootReference() : Expression_FieldReference_RootReference(nullptr) {} - ~Expression_FieldReference_RootReference() override; explicit constexpr Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); Expression_FieldReference_RootReference(const Expression_FieldReference_RootReference& from); @@ -7855,8 +8470,13 @@ class Expression_FieldReference_RootReference PROTOBUF_FINAL : return *this; } inline Expression_FieldReference_RootReference& operator=(Expression_FieldReference_RootReference&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -7887,7 +8507,12 @@ class Expression_FieldReference_RootReference PROTOBUF_FINAL : } inline void Swap(Expression_FieldReference_RootReference* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -7895,48 +8520,39 @@ class Expression_FieldReference_RootReference PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_FieldReference_RootReference* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_FieldReference_RootReference* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_FieldReference_RootReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_FieldReference_RootReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const Expression_FieldReference_RootReference& from); - void MergeFrom(const Expression_FieldReference_RootReference& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const Expression_FieldReference_RootReference& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const Expression_FieldReference_RootReference& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); + } + public: private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_FieldReference_RootReference* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.FieldReference.RootReference"; } protected: - explicit Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -7955,7 +8571,7 @@ class Expression_FieldReference_RootReference PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Expression_FieldReference PROTOBUF_FINAL : +class Expression_FieldReference final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.FieldReference) */ { public: inline Expression_FieldReference() : Expression_FieldReference(nullptr) {} @@ -7973,8 +8589,13 @@ class Expression_FieldReference PROTOBUF_FINAL : return *this; } inline Expression_FieldReference& operator=(Expression_FieldReference&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -8017,7 +8638,12 @@ class Expression_FieldReference PROTOBUF_FINAL : } inline void Swap(Expression_FieldReference* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -8025,48 +8651,53 @@ class Expression_FieldReference PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression_FieldReference* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression_FieldReference* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression_FieldReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression_FieldReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression_FieldReference& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression_FieldReference& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression_FieldReference* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression.FieldReference"; } protected: - explicit Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -8088,7 +8719,7 @@ class Expression_FieldReference PROTOBUF_FINAL : public: void clear_direct_reference(); const ::substrait::Expression_ReferenceSegment& direct_reference() const; - ::substrait::Expression_ReferenceSegment* release_direct_reference(); + PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_direct_reference(); ::substrait::Expression_ReferenceSegment* mutable_direct_reference(); void set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference); private: @@ -8106,7 +8737,7 @@ class Expression_FieldReference PROTOBUF_FINAL : public: void clear_masked_reference(); const ::substrait::Expression_MaskExpression& masked_reference() const; - ::substrait::Expression_MaskExpression* release_masked_reference(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression* release_masked_reference(); ::substrait::Expression_MaskExpression* mutable_masked_reference(); void set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference); private: @@ -8124,7 +8755,7 @@ class Expression_FieldReference PROTOBUF_FINAL : public: void clear_expression(); const ::substrait::Expression& expression() const; - ::substrait::Expression* release_expression(); + PROTOBUF_NODISCARD ::substrait::Expression* release_expression(); ::substrait::Expression* mutable_expression(); void set_allocated_expression(::substrait::Expression* expression); private: @@ -8142,7 +8773,7 @@ class Expression_FieldReference PROTOBUF_FINAL : public: void clear_root_reference(); const ::substrait::Expression_FieldReference_RootReference& root_reference() const; - ::substrait::Expression_FieldReference_RootReference* release_root_reference(); + PROTOBUF_NODISCARD ::substrait::Expression_FieldReference_RootReference* release_root_reference(); ::substrait::Expression_FieldReference_RootReference* mutable_root_reference(); void set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference); private: @@ -8187,13 +8818,13 @@ class Expression_FieldReference PROTOBUF_FINAL : ::substrait::Expression_FieldReference_RootReference* root_reference_; } root_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2]; + uint32_t _oneof_case_[2]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class Expression PROTOBUF_FINAL : +class Expression final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression) */ { public: inline Expression() : Expression(nullptr) {} @@ -8211,8 +8842,13 @@ class Expression PROTOBUF_FINAL : return *this; } inline Expression& operator=(Expression&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -8257,7 +8893,12 @@ class Expression PROTOBUF_FINAL : } inline void Swap(Expression* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -8265,48 +8906,53 @@ class Expression PROTOBUF_FINAL : } void UnsafeArenaSwap(Expression* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Expression* New() const final { - return CreateMaybeMessage(nullptr); - } - - Expression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Expression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Expression& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Expression& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Expression* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Expression"; } protected: - explicit Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -8346,7 +8992,7 @@ class Expression PROTOBUF_FINAL : public: void clear_literal(); const ::substrait::Expression_Literal& literal() const; - ::substrait::Expression_Literal* release_literal(); + PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_literal(); ::substrait::Expression_Literal* mutable_literal(); void set_allocated_literal(::substrait::Expression_Literal* literal); private: @@ -8364,7 +9010,7 @@ class Expression PROTOBUF_FINAL : public: void clear_selection(); const ::substrait::Expression_FieldReference& selection() const; - ::substrait::Expression_FieldReference* release_selection(); + PROTOBUF_NODISCARD ::substrait::Expression_FieldReference* release_selection(); ::substrait::Expression_FieldReference* mutable_selection(); void set_allocated_selection(::substrait::Expression_FieldReference* selection); private: @@ -8382,7 +9028,7 @@ class Expression PROTOBUF_FINAL : public: void clear_scalar_function(); const ::substrait::Expression_ScalarFunction& scalar_function() const; - ::substrait::Expression_ScalarFunction* release_scalar_function(); + PROTOBUF_NODISCARD ::substrait::Expression_ScalarFunction* release_scalar_function(); ::substrait::Expression_ScalarFunction* mutable_scalar_function(); void set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function); private: @@ -8400,7 +9046,7 @@ class Expression PROTOBUF_FINAL : public: void clear_window_function(); const ::substrait::Expression_WindowFunction& window_function() const; - ::substrait::Expression_WindowFunction* release_window_function(); + PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction* release_window_function(); ::substrait::Expression_WindowFunction* mutable_window_function(); void set_allocated_window_function(::substrait::Expression_WindowFunction* window_function); private: @@ -8418,7 +9064,7 @@ class Expression PROTOBUF_FINAL : public: void clear_if_then(); const ::substrait::Expression_IfThen& if_then() const; - ::substrait::Expression_IfThen* release_if_then(); + PROTOBUF_NODISCARD ::substrait::Expression_IfThen* release_if_then(); ::substrait::Expression_IfThen* mutable_if_then(); void set_allocated_if_then(::substrait::Expression_IfThen* if_then); private: @@ -8436,7 +9082,7 @@ class Expression PROTOBUF_FINAL : public: void clear_switch_expression(); const ::substrait::Expression_SwitchExpression& switch_expression() const; - ::substrait::Expression_SwitchExpression* release_switch_expression(); + PROTOBUF_NODISCARD ::substrait::Expression_SwitchExpression* release_switch_expression(); ::substrait::Expression_SwitchExpression* mutable_switch_expression(); void set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression); private: @@ -8454,7 +9100,7 @@ class Expression PROTOBUF_FINAL : public: void clear_singular_or_list(); const ::substrait::Expression_SingularOrList& singular_or_list() const; - ::substrait::Expression_SingularOrList* release_singular_or_list(); + PROTOBUF_NODISCARD ::substrait::Expression_SingularOrList* release_singular_or_list(); ::substrait::Expression_SingularOrList* mutable_singular_or_list(); void set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list); private: @@ -8472,7 +9118,7 @@ class Expression PROTOBUF_FINAL : public: void clear_multi_or_list(); const ::substrait::Expression_MultiOrList& multi_or_list() const; - ::substrait::Expression_MultiOrList* release_multi_or_list(); + PROTOBUF_NODISCARD ::substrait::Expression_MultiOrList* release_multi_or_list(); ::substrait::Expression_MultiOrList* mutable_multi_or_list(); void set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list); private: @@ -8490,7 +9136,7 @@ class Expression PROTOBUF_FINAL : public: void clear_enum_(); const ::substrait::Expression_Enum& enum_() const; - ::substrait::Expression_Enum* release_enum_(); + PROTOBUF_NODISCARD ::substrait::Expression_Enum* release_enum_(); ::substrait::Expression_Enum* mutable_enum_(); void set_allocated_enum_(::substrait::Expression_Enum* enum_); private: @@ -8508,7 +9154,7 @@ class Expression PROTOBUF_FINAL : public: void clear_cast(); const ::substrait::Expression_Cast& cast() const; - ::substrait::Expression_Cast* release_cast(); + PROTOBUF_NODISCARD ::substrait::Expression_Cast* release_cast(); ::substrait::Expression_Cast* mutable_cast(); void set_allocated_cast(::substrait::Expression_Cast* cast); private: @@ -8556,13 +9202,13 @@ class Expression PROTOBUF_FINAL : ::substrait::Expression_Cast* cast_; } rex_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class SortField PROTOBUF_FINAL : +class SortField final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SortField) */ { public: inline SortField() : SortField(nullptr) {} @@ -8580,8 +9226,13 @@ class SortField PROTOBUF_FINAL : return *this; } inline SortField& operator=(SortField&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -8618,7 +9269,12 @@ class SortField PROTOBUF_FINAL : } inline void Swap(SortField* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -8626,48 +9282,53 @@ class SortField PROTOBUF_FINAL : } void UnsafeArenaSwap(SortField* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline SortField* New() const final { - return CreateMaybeMessage(nullptr); - } - - SortField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + SortField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SortField& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const SortField& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SortField* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.SortField"; } protected: - explicit SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -8724,7 +9385,7 @@ class SortField PROTOBUF_FINAL : public: void clear_expr(); const ::substrait::Expression& expr() const; - ::substrait::Expression* release_expr(); + PROTOBUF_NODISCARD ::substrait::Expression* release_expr(); ::substrait::Expression* mutable_expr(); void set_allocated_expr(::substrait::Expression* expr); private: @@ -8754,11 +9415,11 @@ class SortField PROTOBUF_FINAL : bool _internal_has_comparison_function_reference() const; public: void clear_comparison_function_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 comparison_function_reference() const; - void set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t comparison_function_reference() const; + void set_comparison_function_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_comparison_function_reference() const; - void _internal_set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_comparison_function_reference() const; + void _internal_set_comparison_function_reference(uint32_t value); public: void clear_sort_kind(); @@ -8780,16 +9441,16 @@ class SortField PROTOBUF_FINAL : constexpr SortKindUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; int direction_; - ::PROTOBUF_NAMESPACE_ID::uint32 comparison_function_reference_; + uint32_t comparison_function_reference_; } sort_kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fexpression_2eproto; }; // ------------------------------------------------------------------- -class AggregateFunction PROTOBUF_FINAL : +class AggregateFunction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateFunction) */ { public: inline AggregateFunction() : AggregateFunction(nullptr) {} @@ -8807,8 +9468,13 @@ class AggregateFunction PROTOBUF_FINAL : return *this; } inline AggregateFunction& operator=(AggregateFunction&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -8839,7 +9505,12 @@ class AggregateFunction PROTOBUF_FINAL : } inline void Swap(AggregateFunction* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -8847,48 +9518,53 @@ class AggregateFunction PROTOBUF_FINAL : } void UnsafeArenaSwap(AggregateFunction* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline AggregateFunction* New() const final { - return CreateMaybeMessage(nullptr); - } - - AggregateFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + AggregateFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AggregateFunction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const AggregateFunction& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AggregateFunction* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.AggregateFunction"; } protected: - explicit AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -8945,7 +9621,7 @@ class AggregateFunction PROTOBUF_FINAL : public: void clear_output_type(); const ::substrait::Type& output_type() const; - ::substrait::Type* release_output_type(); + PROTOBUF_NODISCARD ::substrait::Type* release_output_type(); ::substrait::Type* mutable_output_type(); void set_allocated_output_type(::substrait::Type* output_type); private: @@ -8958,11 +9634,11 @@ class AggregateFunction PROTOBUF_FINAL : // uint32 function_reference = 1; void clear_function_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 function_reference() const; - void set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t function_reference() const; + void set_function_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_function_reference() const; - void _internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_function_reference() const; + void _internal_set_function_reference(uint32_t value); public: // .substrait.AggregationPhase phase = 4; @@ -8984,7 +9660,7 @@ class AggregateFunction PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField > sorts_; ::substrait::Type* output_type_; - ::PROTOBUF_NAMESPACE_ID::uint32 function_reference_; + uint32_t function_reference_; int phase_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fexpression_2eproto; @@ -9016,7 +9692,7 @@ inline void Expression_Enum::set_has_specified() { } inline void Expression_Enum::clear_specified() { if (_internal_has_specified()) { - enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_enum_kind(); } } @@ -9031,12 +9707,13 @@ inline void Expression_Enum::set_specified(ArgT0&& arg0, ArgT... args) { set_has_specified(); enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.Enum.specified) } inline std::string* Expression_Enum::mutable_specified() { + std::string* _s = _internal_mutable_specified(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Enum.specified) - return _internal_mutable_specified(); + return _s; } inline const std::string& Expression_Enum::_internal_specified() const { if (_internal_has_specified()) { @@ -9050,7 +9727,7 @@ inline void Expression_Enum::_internal_set_specified(const std::string& value) { set_has_specified(); enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_Enum::_internal_mutable_specified() { if (!_internal_has_specified()) { @@ -9059,13 +9736,13 @@ inline std::string* Expression_Enum::_internal_mutable_specified() { enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return enum_kind_.specified_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_Enum::release_specified() { // @@protoc_insertion_point(field_release:substrait.Expression.Enum.specified) if (_internal_has_specified()) { clear_has_enum_kind(); - return enum_kind_.specified_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return enum_kind_.specified_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -9077,7 +9754,7 @@ inline void Expression_Enum::set_allocated_specified(std::string* specified) { if (specified != nullptr) { set_has_specified(); enum_kind_.specified_.UnsafeSetDefault(specified); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(specified); } @@ -9097,7 +9774,7 @@ inline void Expression_Enum::set_has_unspecified() { } inline void Expression_Enum::clear_unspecified() { if (_internal_has_unspecified()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete enum_kind_.unspecified_; } clear_has_enum_kind(); @@ -9108,7 +9785,7 @@ inline ::substrait::Expression_Enum_Empty* Expression_Enum::release_unspecified( if (_internal_has_unspecified()) { clear_has_enum_kind(); ::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } enum_kind_.unspecified_ = nullptr; @@ -9149,13 +9826,14 @@ inline ::substrait::Expression_Enum_Empty* Expression_Enum::_internal_mutable_un if (!_internal_has_unspecified()) { clear_enum_kind(); set_has_unspecified(); - enum_kind_.unspecified_ = CreateMaybeMessage< ::substrait::Expression_Enum_Empty >(GetArena()); + enum_kind_.unspecified_ = CreateMaybeMessage< ::substrait::Expression_Enum_Empty >(GetArenaForAllocation()); } return enum_kind_.unspecified_; } inline ::substrait::Expression_Enum_Empty* Expression_Enum::mutable_unspecified() { + ::substrait::Expression_Enum_Empty* _msg = _internal_mutable_unspecified(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Enum.unspecified) - return _internal_mutable_unspecified(); + return _msg; } inline bool Expression_Enum::has_enum_kind() const { @@ -9180,30 +9858,31 @@ inline const std::string& Expression_Literal_VarChar::value() const { return _internal_value(); } template -PROTOBUF_ALWAYS_INLINE -inline void Expression_Literal_VarChar::set_value(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void Expression_Literal_VarChar::set_value(ArgT0&& arg0, ArgT... args) { - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.VarChar.value) } inline std::string* Expression_Literal_VarChar::mutable_value() { + std::string* _s = _internal_mutable_value(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.VarChar.value) - return _internal_mutable_value(); + return _s; } inline const std::string& Expression_Literal_VarChar::_internal_value() const { return value_.Get(); } inline void Expression_Literal_VarChar::_internal_set_value(const std::string& value) { - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_Literal_VarChar::_internal_mutable_value() { - return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_Literal_VarChar::release_value() { // @@protoc_insertion_point(field_release:substrait.Expression.Literal.VarChar.value) - return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void Expression_Literal_VarChar::set_allocated_value(std::string* value) { if (value != nullptr) { @@ -9212,7 +9891,12 @@ inline void Expression_Literal_VarChar::set_allocated_value(std::string* value) } value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.VarChar.value) } @@ -9220,18 +9904,18 @@ inline void Expression_Literal_VarChar::set_allocated_value(std::string* value) inline void Expression_Literal_VarChar::clear_length() { length_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_Literal_VarChar::_internal_length() const { +inline uint32_t Expression_Literal_VarChar::_internal_length() const { return length_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_Literal_VarChar::length() const { +inline uint32_t Expression_Literal_VarChar::length() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.VarChar.length) return _internal_length(); } -inline void Expression_Literal_VarChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Expression_Literal_VarChar::_internal_set_length(uint32_t value) { length_ = value; } -inline void Expression_Literal_VarChar::set_length(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Expression_Literal_VarChar::set_length(uint32_t value) { _internal_set_length(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.VarChar.length) } @@ -9249,30 +9933,31 @@ inline const std::string& Expression_Literal_Decimal::value() const { return _internal_value(); } template -PROTOBUF_ALWAYS_INLINE -inline void Expression_Literal_Decimal::set_value(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void Expression_Literal_Decimal::set_value(ArgT0&& arg0, ArgT... args) { - value_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + value_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.value) } inline std::string* Expression_Literal_Decimal::mutable_value() { + std::string* _s = _internal_mutable_value(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Decimal.value) - return _internal_mutable_value(); + return _s; } inline const std::string& Expression_Literal_Decimal::_internal_value() const { return value_.Get(); } inline void Expression_Literal_Decimal::_internal_set_value(const std::string& value) { - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_Literal_Decimal::_internal_mutable_value() { - return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_Literal_Decimal::release_value() { // @@protoc_insertion_point(field_release:substrait.Expression.Literal.Decimal.value) - return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void Expression_Literal_Decimal::set_allocated_value(std::string* value) { if (value != nullptr) { @@ -9281,7 +9966,12 @@ inline void Expression_Literal_Decimal::set_allocated_value(std::string* value) } value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.Decimal.value) } @@ -9289,18 +9979,18 @@ inline void Expression_Literal_Decimal::set_allocated_value(std::string* value) inline void Expression_Literal_Decimal::clear_precision() { precision_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::_internal_precision() const { +inline int32_t Expression_Literal_Decimal::_internal_precision() const { return precision_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::precision() const { +inline int32_t Expression_Literal_Decimal::precision() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.precision) return _internal_precision(); } -inline void Expression_Literal_Decimal::_internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_Decimal::_internal_set_precision(int32_t value) { precision_ = value; } -inline void Expression_Literal_Decimal::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_Decimal::set_precision(int32_t value) { _internal_set_precision(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.precision) } @@ -9309,18 +9999,18 @@ inline void Expression_Literal_Decimal::set_precision(::PROTOBUF_NAMESPACE_ID::i inline void Expression_Literal_Decimal::clear_scale() { scale_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::_internal_scale() const { +inline int32_t Expression_Literal_Decimal::_internal_scale() const { return scale_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_Decimal::scale() const { +inline int32_t Expression_Literal_Decimal::scale() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.scale) return _internal_scale(); } -inline void Expression_Literal_Decimal::_internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_Decimal::_internal_set_scale(int32_t value) { scale_ = value; } -inline void Expression_Literal_Decimal::set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_Decimal::set_scale(int32_t value) { _internal_set_scale(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.scale) } @@ -9337,7 +10027,7 @@ inline bool Expression_Literal_Map_KeyValue::has_key() const { return _internal_has_key(); } inline void Expression_Literal_Map_KeyValue::clear_key() { - if (GetArena() == nullptr && key_ != nullptr) { + if (GetArenaForAllocation() == nullptr && key_ != nullptr) { delete key_; } key_ = nullptr; @@ -9353,7 +10043,7 @@ inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::k } inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_key( ::substrait::Expression_Literal* key) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); } key_ = key; @@ -9368,9 +10058,15 @@ inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release ::substrait::Expression_Literal* temp = key_; key_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_key() { @@ -9383,23 +10079,24 @@ inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_ inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_key() { if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation()); key_ = p; } return key_; } inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_key() { + ::substrait::Expression_Literal* _msg = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.KeyValue.key) - return _internal_mutable_key(); + return _msg; } inline void Expression_Literal_Map_KeyValue::set_allocated_key(::substrait::Expression_Literal* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete key_; } if (key) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(key); if (message_arena != submessage_arena) { key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, key, submessage_arena); @@ -9420,7 +10117,7 @@ inline bool Expression_Literal_Map_KeyValue::has_value() const { return _internal_has_value(); } inline void Expression_Literal_Map_KeyValue::clear_value() { - if (GetArena() == nullptr && value_ != nullptr) { + if (GetArenaForAllocation() == nullptr && value_ != nullptr) { delete value_; } value_ = nullptr; @@ -9436,7 +10133,7 @@ inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::v } inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_value( ::substrait::Expression_Literal* value) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } value_ = value; @@ -9451,9 +10148,15 @@ inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release ::substrait::Expression_Literal* temp = value_; value_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_value() { @@ -9466,23 +10169,24 @@ inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_ inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_value() { if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation()); value_ = p; } return value_; } inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_value() { + ::substrait::Expression_Literal* _msg = _internal_mutable_value(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.KeyValue.value) - return _internal_mutable_value(); + return _msg; } inline void Expression_Literal_Map_KeyValue::set_allocated_value(::substrait::Expression_Literal* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete value_; } if (value) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(value); if (message_arena != submessage_arena) { value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, value, submessage_arena); @@ -9529,8 +10233,9 @@ inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::_in return key_values_.Add(); } inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::add_key_values() { + ::substrait::Expression_Literal_Map_KeyValue* _add = _internal_add_key_values(); // @@protoc_insertion_point(field_add:substrait.Expression.Literal.Map.key_values) - return _internal_add_key_values(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >& Expression_Literal_Map::key_values() const { @@ -9546,18 +10251,18 @@ Expression_Literal_Map::key_values() const { inline void Expression_Literal_IntervalYearToMonth::clear_years() { years_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::_internal_years() const { +inline int32_t Expression_Literal_IntervalYearToMonth::_internal_years() const { return years_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::years() const { +inline int32_t Expression_Literal_IntervalYearToMonth::years() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalYearToMonth.years) return _internal_years(); } -inline void Expression_Literal_IntervalYearToMonth::_internal_set_years(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_IntervalYearToMonth::_internal_set_years(int32_t value) { years_ = value; } -inline void Expression_Literal_IntervalYearToMonth::set_years(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_IntervalYearToMonth::set_years(int32_t value) { _internal_set_years(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalYearToMonth.years) } @@ -9566,18 +10271,18 @@ inline void Expression_Literal_IntervalYearToMonth::set_years(::PROTOBUF_NAMESPA inline void Expression_Literal_IntervalYearToMonth::clear_months() { months_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::_internal_months() const { +inline int32_t Expression_Literal_IntervalYearToMonth::_internal_months() const { return months_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalYearToMonth::months() const { +inline int32_t Expression_Literal_IntervalYearToMonth::months() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalYearToMonth.months) return _internal_months(); } -inline void Expression_Literal_IntervalYearToMonth::_internal_set_months(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_IntervalYearToMonth::_internal_set_months(int32_t value) { months_ = value; } -inline void Expression_Literal_IntervalYearToMonth::set_months(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_IntervalYearToMonth::set_months(int32_t value) { _internal_set_months(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalYearToMonth.months) } @@ -9590,18 +10295,18 @@ inline void Expression_Literal_IntervalYearToMonth::set_months(::PROTOBUF_NAMESP inline void Expression_Literal_IntervalDayToSecond::clear_days() { days_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::_internal_days() const { +inline int32_t Expression_Literal_IntervalDayToSecond::_internal_days() const { return days_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::days() const { +inline int32_t Expression_Literal_IntervalDayToSecond::days() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalDayToSecond.days) return _internal_days(); } -inline void Expression_Literal_IntervalDayToSecond::_internal_set_days(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_IntervalDayToSecond::_internal_set_days(int32_t value) { days_ = value; } -inline void Expression_Literal_IntervalDayToSecond::set_days(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_IntervalDayToSecond::set_days(int32_t value) { _internal_set_days(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalDayToSecond.days) } @@ -9610,18 +10315,18 @@ inline void Expression_Literal_IntervalDayToSecond::set_days(::PROTOBUF_NAMESPAC inline void Expression_Literal_IntervalDayToSecond::clear_seconds() { seconds_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::_internal_seconds() const { +inline int32_t Expression_Literal_IntervalDayToSecond::_internal_seconds() const { return seconds_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal_IntervalDayToSecond::seconds() const { +inline int32_t Expression_Literal_IntervalDayToSecond::seconds() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalDayToSecond.seconds) return _internal_seconds(); } -inline void Expression_Literal_IntervalDayToSecond::_internal_set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_IntervalDayToSecond::_internal_set_seconds(int32_t value) { seconds_ = value; } -inline void Expression_Literal_IntervalDayToSecond::set_seconds(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal_IntervalDayToSecond::set_seconds(int32_t value) { _internal_set_seconds(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalDayToSecond.seconds) } @@ -9660,8 +10365,9 @@ inline ::substrait::Expression_Literal* Expression_Literal_Struct::_internal_add return fields_.Add(); } inline ::substrait::Expression_Literal* Expression_Literal_Struct::add_fields() { + ::substrait::Expression_Literal* _add = _internal_add_fields(); // @@protoc_insertion_point(field_add:substrait.Expression.Literal.Struct.fields) - return _internal_add_fields(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >& Expression_Literal_Struct::fields() const { @@ -9703,8 +10409,9 @@ inline ::substrait::Expression_Literal* Expression_Literal_List::_internal_add_v return values_.Add(); } inline ::substrait::Expression_Literal* Expression_Literal_List::add_values() { + ::substrait::Expression_Literal* _add = _internal_add_values(); // @@protoc_insertion_point(field_add:substrait.Expression.Literal.List.values) - return _internal_add_values(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >& Expression_Literal_List::values() const { @@ -9770,24 +10477,24 @@ inline void Expression_Literal::clear_i8() { clear_has_literal_type(); } } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i8() const { +inline int32_t Expression_Literal::_internal_i8() const { if (_internal_has_i8()) { return literal_type_.i8_; } return 0; } -inline void Expression_Literal::_internal_set_i8(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal::_internal_set_i8(int32_t value) { if (!_internal_has_i8()) { clear_literal_type(); set_has_i8(); } literal_type_.i8_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i8() const { +inline int32_t Expression_Literal::i8() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i8) return _internal_i8(); } -inline void Expression_Literal::set_i8(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal::set_i8(int32_t value) { _internal_set_i8(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i8) } @@ -9808,24 +10515,24 @@ inline void Expression_Literal::clear_i16() { clear_has_literal_type(); } } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i16() const { +inline int32_t Expression_Literal::_internal_i16() const { if (_internal_has_i16()) { return literal_type_.i16_; } return 0; } -inline void Expression_Literal::_internal_set_i16(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal::_internal_set_i16(int32_t value) { if (!_internal_has_i16()) { clear_literal_type(); set_has_i16(); } literal_type_.i16_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i16() const { +inline int32_t Expression_Literal::i16() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i16) return _internal_i16(); } -inline void Expression_Literal::set_i16(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal::set_i16(int32_t value) { _internal_set_i16(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i16) } @@ -9846,24 +10553,24 @@ inline void Expression_Literal::clear_i32() { clear_has_literal_type(); } } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_i32() const { +inline int32_t Expression_Literal::_internal_i32() const { if (_internal_has_i32()) { return literal_type_.i32_; } return 0; } -inline void Expression_Literal::_internal_set_i32(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal::_internal_set_i32(int32_t value) { if (!_internal_has_i32()) { clear_literal_type(); set_has_i32(); } literal_type_.i32_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::i32() const { +inline int32_t Expression_Literal::i32() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i32) return _internal_i32(); } -inline void Expression_Literal::set_i32(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal::set_i32(int32_t value) { _internal_set_i32(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i32) } @@ -9880,28 +10587,28 @@ inline void Expression_Literal::set_has_i64() { } inline void Expression_Literal::clear_i64() { if (_internal_has_i64()) { - literal_type_.i64_ = PROTOBUF_LONGLONG(0); + literal_type_.i64_ = int64_t{0}; clear_has_literal_type(); } } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_i64() const { +inline int64_t Expression_Literal::_internal_i64() const { if (_internal_has_i64()) { return literal_type_.i64_; } - return PROTOBUF_LONGLONG(0); + return int64_t{0}; } -inline void Expression_Literal::_internal_set_i64(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_Literal::_internal_set_i64(int64_t value) { if (!_internal_has_i64()) { clear_literal_type(); set_has_i64(); } literal_type_.i64_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::i64() const { +inline int64_t Expression_Literal::i64() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i64) return _internal_i64(); } -inline void Expression_Literal::set_i64(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_Literal::set_i64(int64_t value) { _internal_set_i64(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i64) } @@ -9994,7 +10701,7 @@ inline void Expression_Literal::set_has_string() { } inline void Expression_Literal::clear_string() { if (_internal_has_string()) { - literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_literal_type(); } } @@ -10009,12 +10716,13 @@ inline void Expression_Literal::set_string(ArgT0&& arg0, ArgT... args) { set_has_string(); literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.string) } inline std::string* Expression_Literal::mutable_string() { + std::string* _s = _internal_mutable_string(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.string) - return _internal_mutable_string(); + return _s; } inline const std::string& Expression_Literal::_internal_string() const { if (_internal_has_string()) { @@ -10028,7 +10736,7 @@ inline void Expression_Literal::_internal_set_string(const std::string& value) { set_has_string(); literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_Literal::_internal_mutable_string() { if (!_internal_has_string()) { @@ -10037,13 +10745,13 @@ inline std::string* Expression_Literal::_internal_mutable_string() { literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return literal_type_.string_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_Literal::release_string() { // @@protoc_insertion_point(field_release:substrait.Expression.Literal.string) if (_internal_has_string()) { clear_has_literal_type(); - return literal_type_.string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return literal_type_.string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -10055,7 +10763,7 @@ inline void Expression_Literal::set_allocated_string(std::string* string) { if (string != nullptr) { set_has_string(); literal_type_.string_.UnsafeSetDefault(string); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(string); } @@ -10075,7 +10783,7 @@ inline void Expression_Literal::set_has_binary() { } inline void Expression_Literal::clear_binary() { if (_internal_has_binary()) { - literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_literal_type(); } } @@ -10090,12 +10798,13 @@ inline void Expression_Literal::set_binary(ArgT0&& arg0, ArgT... args) { set_has_binary(); literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - literal_type_.binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + literal_type_.binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.binary) } inline std::string* Expression_Literal::mutable_binary() { + std::string* _s = _internal_mutable_binary(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.binary) - return _internal_mutable_binary(); + return _s; } inline const std::string& Expression_Literal::_internal_binary() const { if (_internal_has_binary()) { @@ -10109,7 +10818,7 @@ inline void Expression_Literal::_internal_set_binary(const std::string& value) { set_has_binary(); literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - literal_type_.binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + literal_type_.binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_Literal::_internal_mutable_binary() { if (!_internal_has_binary()) { @@ -10118,13 +10827,13 @@ inline std::string* Expression_Literal::_internal_mutable_binary() { literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return literal_type_.binary_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_Literal::release_binary() { // @@protoc_insertion_point(field_release:substrait.Expression.Literal.binary) if (_internal_has_binary()) { clear_has_literal_type(); - return literal_type_.binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return literal_type_.binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -10136,7 +10845,7 @@ inline void Expression_Literal::set_allocated_binary(std::string* binary) { if (binary != nullptr) { set_has_binary(); literal_type_.binary_.UnsafeSetDefault(binary); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(binary); } @@ -10156,28 +10865,28 @@ inline void Expression_Literal::set_has_timestamp() { } inline void Expression_Literal::clear_timestamp() { if (_internal_has_timestamp()) { - literal_type_.timestamp_ = PROTOBUF_LONGLONG(0); + literal_type_.timestamp_ = int64_t{0}; clear_has_literal_type(); } } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_timestamp() const { +inline int64_t Expression_Literal::_internal_timestamp() const { if (_internal_has_timestamp()) { return literal_type_.timestamp_; } - return PROTOBUF_LONGLONG(0); + return int64_t{0}; } -inline void Expression_Literal::_internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_Literal::_internal_set_timestamp(int64_t value) { if (!_internal_has_timestamp()) { clear_literal_type(); set_has_timestamp(); } literal_type_.timestamp_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::timestamp() const { +inline int64_t Expression_Literal::timestamp() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.timestamp) return _internal_timestamp(); } -inline void Expression_Literal::set_timestamp(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_Literal::set_timestamp(int64_t value) { _internal_set_timestamp(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.timestamp) } @@ -10198,24 +10907,24 @@ inline void Expression_Literal::clear_date() { clear_has_literal_type(); } } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::_internal_date() const { +inline int32_t Expression_Literal::_internal_date() const { if (_internal_has_date()) { return literal_type_.date_; } return 0; } -inline void Expression_Literal::_internal_set_date(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal::_internal_set_date(int32_t value) { if (!_internal_has_date()) { clear_literal_type(); set_has_date(); } literal_type_.date_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_Literal::date() const { +inline int32_t Expression_Literal::date() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.date) return _internal_date(); } -inline void Expression_Literal::set_date(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_Literal::set_date(int32_t value) { _internal_set_date(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.date) } @@ -10232,28 +10941,28 @@ inline void Expression_Literal::set_has_time() { } inline void Expression_Literal::clear_time() { if (_internal_has_time()) { - literal_type_.time_ = PROTOBUF_LONGLONG(0); + literal_type_.time_ = int64_t{0}; clear_has_literal_type(); } } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_time() const { +inline int64_t Expression_Literal::_internal_time() const { if (_internal_has_time()) { return literal_type_.time_; } - return PROTOBUF_LONGLONG(0); + return int64_t{0}; } -inline void Expression_Literal::_internal_set_time(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_Literal::_internal_set_time(int64_t value) { if (!_internal_has_time()) { clear_literal_type(); set_has_time(); } literal_type_.time_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::time() const { +inline int64_t Expression_Literal::time() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.time) return _internal_time(); } -inline void Expression_Literal::set_time(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_Literal::set_time(int64_t value) { _internal_set_time(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.time) } @@ -10270,7 +10979,7 @@ inline void Expression_Literal::set_has_interval_year_to_month() { } inline void Expression_Literal::clear_interval_year_to_month() { if (_internal_has_interval_year_to_month()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.interval_year_to_month_; } clear_has_literal_type(); @@ -10281,7 +10990,7 @@ inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal:: if (_internal_has_interval_year_to_month()) { clear_has_literal_type(); ::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } literal_type_.interval_year_to_month_ = nullptr; @@ -10322,13 +11031,14 @@ inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal:: if (!_internal_has_interval_year_to_month()) { clear_literal_type(); set_has_interval_year_to_month(); - literal_type_.interval_year_to_month_ = CreateMaybeMessage< ::substrait::Expression_Literal_IntervalYearToMonth >(GetArena()); + literal_type_.interval_year_to_month_ = CreateMaybeMessage< ::substrait::Expression_Literal_IntervalYearToMonth >(GetArenaForAllocation()); } return literal_type_.interval_year_to_month_; } inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::mutable_interval_year_to_month() { + ::substrait::Expression_Literal_IntervalYearToMonth* _msg = _internal_mutable_interval_year_to_month(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.interval_year_to_month) - return _internal_mutable_interval_year_to_month(); + return _msg; } // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; @@ -10343,7 +11053,7 @@ inline void Expression_Literal::set_has_interval_day_to_second() { } inline void Expression_Literal::clear_interval_day_to_second() { if (_internal_has_interval_day_to_second()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.interval_day_to_second_; } clear_has_literal_type(); @@ -10354,7 +11064,7 @@ inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal:: if (_internal_has_interval_day_to_second()) { clear_has_literal_type(); ::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } literal_type_.interval_day_to_second_ = nullptr; @@ -10395,13 +11105,14 @@ inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal:: if (!_internal_has_interval_day_to_second()) { clear_literal_type(); set_has_interval_day_to_second(); - literal_type_.interval_day_to_second_ = CreateMaybeMessage< ::substrait::Expression_Literal_IntervalDayToSecond >(GetArena()); + literal_type_.interval_day_to_second_ = CreateMaybeMessage< ::substrait::Expression_Literal_IntervalDayToSecond >(GetArenaForAllocation()); } return literal_type_.interval_day_to_second_; } inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::mutable_interval_day_to_second() { + ::substrait::Expression_Literal_IntervalDayToSecond* _msg = _internal_mutable_interval_day_to_second(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.interval_day_to_second) - return _internal_mutable_interval_day_to_second(); + return _msg; } // string fixed_char = 21; @@ -10416,7 +11127,7 @@ inline void Expression_Literal::set_has_fixed_char() { } inline void Expression_Literal::clear_fixed_char() { if (_internal_has_fixed_char()) { - literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_literal_type(); } } @@ -10431,12 +11142,13 @@ inline void Expression_Literal::set_fixed_char(ArgT0&& arg0, ArgT... args) { set_has_fixed_char(); literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fixed_char) } inline std::string* Expression_Literal::mutable_fixed_char() { + std::string* _s = _internal_mutable_fixed_char(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.fixed_char) - return _internal_mutable_fixed_char(); + return _s; } inline const std::string& Expression_Literal::_internal_fixed_char() const { if (_internal_has_fixed_char()) { @@ -10450,7 +11162,7 @@ inline void Expression_Literal::_internal_set_fixed_char(const std::string& valu set_has_fixed_char(); literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_Literal::_internal_mutable_fixed_char() { if (!_internal_has_fixed_char()) { @@ -10459,13 +11171,13 @@ inline std::string* Expression_Literal::_internal_mutable_fixed_char() { literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return literal_type_.fixed_char_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_Literal::release_fixed_char() { // @@protoc_insertion_point(field_release:substrait.Expression.Literal.fixed_char) if (_internal_has_fixed_char()) { clear_has_literal_type(); - return literal_type_.fixed_char_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return literal_type_.fixed_char_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -10477,7 +11189,7 @@ inline void Expression_Literal::set_allocated_fixed_char(std::string* fixed_char if (fixed_char != nullptr) { set_has_fixed_char(); literal_type_.fixed_char_.UnsafeSetDefault(fixed_char); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(fixed_char); } @@ -10497,7 +11209,7 @@ inline void Expression_Literal::set_has_var_char() { } inline void Expression_Literal::clear_var_char() { if (_internal_has_var_char()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.var_char_; } clear_has_literal_type(); @@ -10508,7 +11220,7 @@ inline ::substrait::Expression_Literal_VarChar* Expression_Literal::release_var_ if (_internal_has_var_char()) { clear_has_literal_type(); ::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } literal_type_.var_char_ = nullptr; @@ -10549,13 +11261,14 @@ inline ::substrait::Expression_Literal_VarChar* Expression_Literal::_internal_mu if (!_internal_has_var_char()) { clear_literal_type(); set_has_var_char(); - literal_type_.var_char_ = CreateMaybeMessage< ::substrait::Expression_Literal_VarChar >(GetArena()); + literal_type_.var_char_ = CreateMaybeMessage< ::substrait::Expression_Literal_VarChar >(GetArenaForAllocation()); } return literal_type_.var_char_; } inline ::substrait::Expression_Literal_VarChar* Expression_Literal::mutable_var_char() { + ::substrait::Expression_Literal_VarChar* _msg = _internal_mutable_var_char(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.var_char) - return _internal_mutable_var_char(); + return _msg; } // bytes fixed_binary = 23; @@ -10570,7 +11283,7 @@ inline void Expression_Literal::set_has_fixed_binary() { } inline void Expression_Literal::clear_fixed_binary() { if (_internal_has_fixed_binary()) { - literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_literal_type(); } } @@ -10585,12 +11298,13 @@ inline void Expression_Literal::set_fixed_binary(ArgT0&& arg0, ArgT... args) { set_has_fixed_binary(); literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - literal_type_.fixed_binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + literal_type_.fixed_binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fixed_binary) } inline std::string* Expression_Literal::mutable_fixed_binary() { + std::string* _s = _internal_mutable_fixed_binary(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.fixed_binary) - return _internal_mutable_fixed_binary(); + return _s; } inline const std::string& Expression_Literal::_internal_fixed_binary() const { if (_internal_has_fixed_binary()) { @@ -10604,7 +11318,7 @@ inline void Expression_Literal::_internal_set_fixed_binary(const std::string& va set_has_fixed_binary(); literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - literal_type_.fixed_binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + literal_type_.fixed_binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_Literal::_internal_mutable_fixed_binary() { if (!_internal_has_fixed_binary()) { @@ -10613,13 +11327,13 @@ inline std::string* Expression_Literal::_internal_mutable_fixed_binary() { literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return literal_type_.fixed_binary_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_Literal::release_fixed_binary() { // @@protoc_insertion_point(field_release:substrait.Expression.Literal.fixed_binary) if (_internal_has_fixed_binary()) { clear_has_literal_type(); - return literal_type_.fixed_binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return literal_type_.fixed_binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -10631,7 +11345,7 @@ inline void Expression_Literal::set_allocated_fixed_binary(std::string* fixed_bi if (fixed_binary != nullptr) { set_has_fixed_binary(); literal_type_.fixed_binary_.UnsafeSetDefault(fixed_binary); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(fixed_binary); } @@ -10651,7 +11365,7 @@ inline void Expression_Literal::set_has_decimal() { } inline void Expression_Literal::clear_decimal() { if (_internal_has_decimal()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.decimal_; } clear_has_literal_type(); @@ -10662,7 +11376,7 @@ inline ::substrait::Expression_Literal_Decimal* Expression_Literal::release_deci if (_internal_has_decimal()) { clear_has_literal_type(); ::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } literal_type_.decimal_ = nullptr; @@ -10703,13 +11417,14 @@ inline ::substrait::Expression_Literal_Decimal* Expression_Literal::_internal_mu if (!_internal_has_decimal()) { clear_literal_type(); set_has_decimal(); - literal_type_.decimal_ = CreateMaybeMessage< ::substrait::Expression_Literal_Decimal >(GetArena()); + literal_type_.decimal_ = CreateMaybeMessage< ::substrait::Expression_Literal_Decimal >(GetArenaForAllocation()); } return literal_type_.decimal_; } inline ::substrait::Expression_Literal_Decimal* Expression_Literal::mutable_decimal() { + ::substrait::Expression_Literal_Decimal* _msg = _internal_mutable_decimal(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.decimal) - return _internal_mutable_decimal(); + return _msg; } // .substrait.Expression.Literal.Struct struct = 25; @@ -10724,7 +11439,7 @@ inline void Expression_Literal::set_has_struct_() { } inline void Expression_Literal::clear_struct_() { if (_internal_has_struct_()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.struct__; } clear_has_literal_type(); @@ -10735,7 +11450,7 @@ inline ::substrait::Expression_Literal_Struct* Expression_Literal::release_struc if (_internal_has_struct_()) { clear_has_literal_type(); ::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } literal_type_.struct__ = nullptr; @@ -10776,13 +11491,14 @@ inline ::substrait::Expression_Literal_Struct* Expression_Literal::_internal_mut if (!_internal_has_struct_()) { clear_literal_type(); set_has_struct_(); - literal_type_.struct__ = CreateMaybeMessage< ::substrait::Expression_Literal_Struct >(GetArena()); + literal_type_.struct__ = CreateMaybeMessage< ::substrait::Expression_Literal_Struct >(GetArenaForAllocation()); } return literal_type_.struct__; } inline ::substrait::Expression_Literal_Struct* Expression_Literal::mutable_struct_() { + ::substrait::Expression_Literal_Struct* _msg = _internal_mutable_struct_(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.struct) - return _internal_mutable_struct_(); + return _msg; } // .substrait.Expression.Literal.Map map = 26; @@ -10797,7 +11513,7 @@ inline void Expression_Literal::set_has_map() { } inline void Expression_Literal::clear_map() { if (_internal_has_map()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.map_; } clear_has_literal_type(); @@ -10808,7 +11524,7 @@ inline ::substrait::Expression_Literal_Map* Expression_Literal::release_map() { if (_internal_has_map()) { clear_has_literal_type(); ::substrait::Expression_Literal_Map* temp = literal_type_.map_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } literal_type_.map_ = nullptr; @@ -10849,13 +11565,14 @@ inline ::substrait::Expression_Literal_Map* Expression_Literal::_internal_mutabl if (!_internal_has_map()) { clear_literal_type(); set_has_map(); - literal_type_.map_ = CreateMaybeMessage< ::substrait::Expression_Literal_Map >(GetArena()); + literal_type_.map_ = CreateMaybeMessage< ::substrait::Expression_Literal_Map >(GetArenaForAllocation()); } return literal_type_.map_; } inline ::substrait::Expression_Literal_Map* Expression_Literal::mutable_map() { + ::substrait::Expression_Literal_Map* _msg = _internal_mutable_map(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.map) - return _internal_mutable_map(); + return _msg; } // int64 timestamp_tz = 27; @@ -10870,28 +11587,28 @@ inline void Expression_Literal::set_has_timestamp_tz() { } inline void Expression_Literal::clear_timestamp_tz() { if (_internal_has_timestamp_tz()) { - literal_type_.timestamp_tz_ = PROTOBUF_LONGLONG(0); + literal_type_.timestamp_tz_ = int64_t{0}; clear_has_literal_type(); } } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::_internal_timestamp_tz() const { +inline int64_t Expression_Literal::_internal_timestamp_tz() const { if (_internal_has_timestamp_tz()) { return literal_type_.timestamp_tz_; } - return PROTOBUF_LONGLONG(0); + return int64_t{0}; } -inline void Expression_Literal::_internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_Literal::_internal_set_timestamp_tz(int64_t value) { if (!_internal_has_timestamp_tz()) { clear_literal_type(); set_has_timestamp_tz(); } literal_type_.timestamp_tz_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_Literal::timestamp_tz() const { +inline int64_t Expression_Literal::timestamp_tz() const { // @@protoc_insertion_point(field_get:substrait.Expression.Literal.timestamp_tz) return _internal_timestamp_tz(); } -inline void Expression_Literal::set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_Literal::set_timestamp_tz(int64_t value) { _internal_set_timestamp_tz(value); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.timestamp_tz) } @@ -10908,7 +11625,7 @@ inline void Expression_Literal::set_has_uuid() { } inline void Expression_Literal::clear_uuid() { if (_internal_has_uuid()) { - literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_literal_type(); } } @@ -10923,12 +11640,13 @@ inline void Expression_Literal::set_uuid(ArgT0&& arg0, ArgT... args) { set_has_uuid(); literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - literal_type_.uuid_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + literal_type_.uuid_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.Literal.uuid) } inline std::string* Expression_Literal::mutable_uuid() { + std::string* _s = _internal_mutable_uuid(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.uuid) - return _internal_mutable_uuid(); + return _s; } inline const std::string& Expression_Literal::_internal_uuid() const { if (_internal_has_uuid()) { @@ -10942,7 +11660,7 @@ inline void Expression_Literal::_internal_set_uuid(const std::string& value) { set_has_uuid(); literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - literal_type_.uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + literal_type_.uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_Literal::_internal_mutable_uuid() { if (!_internal_has_uuid()) { @@ -10951,13 +11669,13 @@ inline std::string* Expression_Literal::_internal_mutable_uuid() { literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return literal_type_.uuid_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_Literal::release_uuid() { // @@protoc_insertion_point(field_release:substrait.Expression.Literal.uuid) if (_internal_has_uuid()) { clear_has_literal_type(); - return literal_type_.uuid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return literal_type_.uuid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -10969,7 +11687,7 @@ inline void Expression_Literal::set_allocated_uuid(std::string* uuid) { if (uuid != nullptr) { set_has_uuid(); literal_type_.uuid_.UnsafeSetDefault(uuid); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(uuid); } @@ -10992,7 +11710,7 @@ inline ::substrait::Type* Expression_Literal::release_null() { if (_internal_has_null()) { clear_has_literal_type(); ::substrait::Type* temp = literal_type_.null_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } literal_type_.null_ = nullptr; @@ -11033,13 +11751,14 @@ inline ::substrait::Type* Expression_Literal::_internal_mutable_null() { if (!_internal_has_null()) { clear_literal_type(); set_has_null(); - literal_type_.null_ = CreateMaybeMessage< ::substrait::Type >(GetArena()); + literal_type_.null_ = CreateMaybeMessage< ::substrait::Type >(GetArenaForAllocation()); } return literal_type_.null_; } inline ::substrait::Type* Expression_Literal::mutable_null() { + ::substrait::Type* _msg = _internal_mutable_null(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.null) - return _internal_mutable_null(); + return _msg; } // .substrait.Expression.Literal.List list = 30; @@ -11054,7 +11773,7 @@ inline void Expression_Literal::set_has_list() { } inline void Expression_Literal::clear_list() { if (_internal_has_list()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete literal_type_.list_; } clear_has_literal_type(); @@ -11065,7 +11784,7 @@ inline ::substrait::Expression_Literal_List* Expression_Literal::release_list() if (_internal_has_list()) { clear_has_literal_type(); ::substrait::Expression_Literal_List* temp = literal_type_.list_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } literal_type_.list_ = nullptr; @@ -11106,13 +11825,14 @@ inline ::substrait::Expression_Literal_List* Expression_Literal::_internal_mutab if (!_internal_has_list()) { clear_literal_type(); set_has_list(); - literal_type_.list_ = CreateMaybeMessage< ::substrait::Expression_Literal_List >(GetArena()); + literal_type_.list_ = CreateMaybeMessage< ::substrait::Expression_Literal_List >(GetArenaForAllocation()); } return literal_type_.list_; } inline ::substrait::Expression_Literal_List* Expression_Literal::mutable_list() { + ::substrait::Expression_Literal_List* _msg = _internal_mutable_list(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.list) - return _internal_mutable_list(); + return _msg; } // .substrait.Type.List empty_list = 31; @@ -11130,7 +11850,7 @@ inline ::substrait::Type_List* Expression_Literal::release_empty_list() { if (_internal_has_empty_list()) { clear_has_literal_type(); ::substrait::Type_List* temp = literal_type_.empty_list_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } literal_type_.empty_list_ = nullptr; @@ -11171,13 +11891,14 @@ inline ::substrait::Type_List* Expression_Literal::_internal_mutable_empty_list( if (!_internal_has_empty_list()) { clear_literal_type(); set_has_empty_list(); - literal_type_.empty_list_ = CreateMaybeMessage< ::substrait::Type_List >(GetArena()); + literal_type_.empty_list_ = CreateMaybeMessage< ::substrait::Type_List >(GetArenaForAllocation()); } return literal_type_.empty_list_; } inline ::substrait::Type_List* Expression_Literal::mutable_empty_list() { + ::substrait::Type_List* _msg = _internal_mutable_empty_list(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.empty_list) - return _internal_mutable_empty_list(); + return _msg; } // .substrait.Type.Map empty_map = 32; @@ -11195,7 +11916,7 @@ inline ::substrait::Type_Map* Expression_Literal::release_empty_map() { if (_internal_has_empty_map()) { clear_has_literal_type(); ::substrait::Type_Map* temp = literal_type_.empty_map_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } literal_type_.empty_map_ = nullptr; @@ -11236,13 +11957,14 @@ inline ::substrait::Type_Map* Expression_Literal::_internal_mutable_empty_map() if (!_internal_has_empty_map()) { clear_literal_type(); set_has_empty_map(); - literal_type_.empty_map_ = CreateMaybeMessage< ::substrait::Type_Map >(GetArena()); + literal_type_.empty_map_ = CreateMaybeMessage< ::substrait::Type_Map >(GetArenaForAllocation()); } return literal_type_.empty_map_; } inline ::substrait::Type_Map* Expression_Literal::mutable_empty_map() { + ::substrait::Type_Map* _msg = _internal_mutable_empty_map(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.empty_map) - return _internal_mutable_empty_map(); + return _msg; } // bool nullable = 50; @@ -11282,18 +12004,18 @@ inline Expression_Literal::LiteralTypeCase Expression_Literal::literal_type_case inline void Expression_ScalarFunction::clear_function_reference() { function_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_ScalarFunction::_internal_function_reference() const { +inline uint32_t Expression_ScalarFunction::_internal_function_reference() const { return function_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_ScalarFunction::function_reference() const { +inline uint32_t Expression_ScalarFunction::function_reference() const { // @@protoc_insertion_point(field_get:substrait.Expression.ScalarFunction.function_reference) return _internal_function_reference(); } -inline void Expression_ScalarFunction::_internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Expression_ScalarFunction::_internal_set_function_reference(uint32_t value) { function_reference_ = value; } -inline void Expression_ScalarFunction::set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Expression_ScalarFunction::set_function_reference(uint32_t value) { _internal_set_function_reference(value); // @@protoc_insertion_point(field_set:substrait.Expression.ScalarFunction.function_reference) } @@ -11328,8 +12050,9 @@ inline ::substrait::Expression* Expression_ScalarFunction::_internal_add_args() return args_.Add(); } inline ::substrait::Expression* Expression_ScalarFunction::add_args() { + ::substrait::Expression* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:substrait.Expression.ScalarFunction.args) - return _internal_add_args(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_ScalarFunction::args() const { @@ -11355,7 +12078,7 @@ inline const ::substrait::Type& Expression_ScalarFunction::output_type() const { } inline void Expression_ScalarFunction::unsafe_arena_set_allocated_output_type( ::substrait::Type* output_type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } output_type_ = output_type; @@ -11370,9 +12093,15 @@ inline ::substrait::Type* Expression_ScalarFunction::release_output_type() { ::substrait::Type* temp = output_type_; output_type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Type* Expression_ScalarFunction::unsafe_arena_release_output_type() { @@ -11385,23 +12114,26 @@ inline ::substrait::Type* Expression_ScalarFunction::unsafe_arena_release_output inline ::substrait::Type* Expression_ScalarFunction::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); output_type_ = p; } return output_type_; } inline ::substrait::Type* Expression_ScalarFunction::mutable_output_type() { + ::substrait::Type* _msg = _internal_mutable_output_type(); // @@protoc_insertion_point(field_mutable:substrait.Expression.ScalarFunction.output_type) - return _internal_mutable_output_type(); + return _msg; } inline void Expression_ScalarFunction::set_allocated_output_type(::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } if (output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); if (message_arena != submessage_arena) { output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, output_type, submessage_arena); @@ -11420,20 +12152,20 @@ inline void Expression_ScalarFunction::set_allocated_output_type(::substrait::Ty // int64 offset = 1; inline void Expression_WindowFunction_Bound_Preceding::clear_offset() { - offset_ = PROTOBUF_LONGLONG(0); + offset_ = int64_t{0}; } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Preceding::_internal_offset() const { +inline int64_t Expression_WindowFunction_Bound_Preceding::_internal_offset() const { return offset_; } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Preceding::offset() const { +inline int64_t Expression_WindowFunction_Bound_Preceding::offset() const { // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.Preceding.offset) return _internal_offset(); } -inline void Expression_WindowFunction_Bound_Preceding::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_WindowFunction_Bound_Preceding::_internal_set_offset(int64_t value) { offset_ = value; } -inline void Expression_WindowFunction_Bound_Preceding::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_WindowFunction_Bound_Preceding::set_offset(int64_t value) { _internal_set_offset(value); // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.Bound.Preceding.offset) } @@ -11444,20 +12176,20 @@ inline void Expression_WindowFunction_Bound_Preceding::set_offset(::PROTOBUF_NAM // int64 offset = 1; inline void Expression_WindowFunction_Bound_Following::clear_offset() { - offset_ = PROTOBUF_LONGLONG(0); + offset_ = int64_t{0}; } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Following::_internal_offset() const { +inline int64_t Expression_WindowFunction_Bound_Following::_internal_offset() const { return offset_; } -inline ::PROTOBUF_NAMESPACE_ID::int64 Expression_WindowFunction_Bound_Following::offset() const { +inline int64_t Expression_WindowFunction_Bound_Following::offset() const { // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.Following.offset) return _internal_offset(); } -inline void Expression_WindowFunction_Bound_Following::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_WindowFunction_Bound_Following::_internal_set_offset(int64_t value) { offset_ = value; } -inline void Expression_WindowFunction_Bound_Following::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void Expression_WindowFunction_Bound_Following::set_offset(int64_t value) { _internal_set_offset(value); // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.Bound.Following.offset) } @@ -11486,7 +12218,7 @@ inline void Expression_WindowFunction_Bound::set_has_preceding() { } inline void Expression_WindowFunction_Bound::clear_preceding() { if (_internal_has_preceding()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.preceding_; } clear_has_kind(); @@ -11497,7 +12229,7 @@ inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_Window if (_internal_has_preceding()) { clear_has_kind(); ::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.preceding_ = nullptr; @@ -11538,13 +12270,14 @@ inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_Window if (!_internal_has_preceding()) { clear_kind(); set_has_preceding(); - kind_.preceding_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Preceding >(GetArena()); + kind_.preceding_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Preceding >(GetArenaForAllocation()); } return kind_.preceding_; } inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::mutable_preceding() { + ::substrait::Expression_WindowFunction_Bound_Preceding* _msg = _internal_mutable_preceding(); // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.preceding) - return _internal_mutable_preceding(); + return _msg; } // .substrait.Expression.WindowFunction.Bound.Following following = 2; @@ -11559,7 +12292,7 @@ inline void Expression_WindowFunction_Bound::set_has_following() { } inline void Expression_WindowFunction_Bound::clear_following() { if (_internal_has_following()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.following_; } clear_has_kind(); @@ -11570,7 +12303,7 @@ inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_Window if (_internal_has_following()) { clear_has_kind(); ::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.following_ = nullptr; @@ -11611,13 +12344,14 @@ inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_Window if (!_internal_has_following()) { clear_kind(); set_has_following(); - kind_.following_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Following >(GetArena()); + kind_.following_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Following >(GetArenaForAllocation()); } return kind_.following_; } inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::mutable_following() { + ::substrait::Expression_WindowFunction_Bound_Following* _msg = _internal_mutable_following(); // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.following) - return _internal_mutable_following(); + return _msg; } // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; @@ -11632,7 +12366,7 @@ inline void Expression_WindowFunction_Bound::set_has_current_row() { } inline void Expression_WindowFunction_Bound::clear_current_row() { if (_internal_has_current_row()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.current_row_; } clear_has_kind(); @@ -11643,7 +12377,7 @@ inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_Windo if (_internal_has_current_row()) { clear_has_kind(); ::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.current_row_ = nullptr; @@ -11684,13 +12418,14 @@ inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_Windo if (!_internal_has_current_row()) { clear_kind(); set_has_current_row(); - kind_.current_row_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(GetArena()); + kind_.current_row_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(GetArenaForAllocation()); } return kind_.current_row_; } inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::mutable_current_row() { + ::substrait::Expression_WindowFunction_Bound_CurrentRow* _msg = _internal_mutable_current_row(); // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.current_row) - return _internal_mutable_current_row(); + return _msg; } // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; @@ -11705,7 +12440,7 @@ inline void Expression_WindowFunction_Bound::set_has_unbounded() { } inline void Expression_WindowFunction_Bound::clear_unbounded() { if (_internal_has_unbounded()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.unbounded_; } clear_has_kind(); @@ -11716,7 +12451,7 @@ inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_Window if (_internal_has_unbounded()) { clear_has_kind(); ::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.unbounded_ = nullptr; @@ -11757,13 +12492,14 @@ inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_Window if (!_internal_has_unbounded()) { clear_kind(); set_has_unbounded(); - kind_.unbounded_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Unbounded >(GetArena()); + kind_.unbounded_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Unbounded >(GetArenaForAllocation()); } return kind_.unbounded_; } inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::mutable_unbounded() { + ::substrait::Expression_WindowFunction_Bound_Unbounded* _msg = _internal_mutable_unbounded(); // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.unbounded) - return _internal_mutable_unbounded(); + return _msg; } inline bool Expression_WindowFunction_Bound::has_kind() const { @@ -11783,18 +12519,18 @@ inline Expression_WindowFunction_Bound::KindCase Expression_WindowFunction_Bound inline void Expression_WindowFunction::clear_function_reference() { function_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_WindowFunction::_internal_function_reference() const { +inline uint32_t Expression_WindowFunction::_internal_function_reference() const { return function_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Expression_WindowFunction::function_reference() const { +inline uint32_t Expression_WindowFunction::function_reference() const { // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.function_reference) return _internal_function_reference(); } -inline void Expression_WindowFunction::_internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Expression_WindowFunction::_internal_set_function_reference(uint32_t value) { function_reference_ = value; } -inline void Expression_WindowFunction::set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Expression_WindowFunction::set_function_reference(uint32_t value) { _internal_set_function_reference(value); // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.function_reference) } @@ -11829,8 +12565,9 @@ inline ::substrait::Expression* Expression_WindowFunction::_internal_add_partiti return partitions_.Add(); } inline ::substrait::Expression* Expression_WindowFunction::add_partitions() { + ::substrait::Expression* _add = _internal_add_partitions(); // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.partitions) - return _internal_add_partitions(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_WindowFunction::partitions() const { @@ -11868,8 +12605,9 @@ inline ::substrait::SortField* Expression_WindowFunction::_internal_add_sorts() return sorts_.Add(); } inline ::substrait::SortField* Expression_WindowFunction::add_sorts() { + ::substrait::SortField* _add = _internal_add_sorts(); // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.sorts) - return _internal_add_sorts(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& Expression_WindowFunction::sorts() const { @@ -11885,7 +12623,7 @@ inline bool Expression_WindowFunction::has_upper_bound() const { return _internal_has_upper_bound(); } inline void Expression_WindowFunction::clear_upper_bound() { - if (GetArena() == nullptr && upper_bound_ != nullptr) { + if (GetArenaForAllocation() == nullptr && upper_bound_ != nullptr) { delete upper_bound_; } upper_bound_ = nullptr; @@ -11901,7 +12639,7 @@ inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunc } inline void Expression_WindowFunction::unsafe_arena_set_allocated_upper_bound( ::substrait::Expression_WindowFunction_Bound* upper_bound) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(upper_bound_); } upper_bound_ = upper_bound; @@ -11916,9 +12654,15 @@ inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction:: ::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; upper_bound_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_upper_bound() { @@ -11931,23 +12675,24 @@ inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction:: inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_upper_bound() { if (upper_bound_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(GetArenaForAllocation()); upper_bound_ = p; } return upper_bound_; } inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_upper_bound() { + ::substrait::Expression_WindowFunction_Bound* _msg = _internal_mutable_upper_bound(); // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.upper_bound) - return _internal_mutable_upper_bound(); + return _msg; } inline void Expression_WindowFunction::set_allocated_upper_bound(::substrait::Expression_WindowFunction_Bound* upper_bound) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete upper_bound_; } if (upper_bound) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(upper_bound); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound>::GetOwningArena(upper_bound); if (message_arena != submessage_arena) { upper_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, upper_bound, submessage_arena); @@ -11968,7 +12713,7 @@ inline bool Expression_WindowFunction::has_lower_bound() const { return _internal_has_lower_bound(); } inline void Expression_WindowFunction::clear_lower_bound() { - if (GetArena() == nullptr && lower_bound_ != nullptr) { + if (GetArenaForAllocation() == nullptr && lower_bound_ != nullptr) { delete lower_bound_; } lower_bound_ = nullptr; @@ -11984,7 +12729,7 @@ inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunc } inline void Expression_WindowFunction::unsafe_arena_set_allocated_lower_bound( ::substrait::Expression_WindowFunction_Bound* lower_bound) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lower_bound_); } lower_bound_ = lower_bound; @@ -11999,9 +12744,15 @@ inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction:: ::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; lower_bound_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_lower_bound() { @@ -12014,23 +12765,24 @@ inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction:: inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_lower_bound() { if (lower_bound_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(GetArenaForAllocation()); lower_bound_ = p; } return lower_bound_; } inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_lower_bound() { + ::substrait::Expression_WindowFunction_Bound* _msg = _internal_mutable_lower_bound(); // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.lower_bound) - return _internal_mutable_lower_bound(); + return _msg; } inline void Expression_WindowFunction::set_allocated_lower_bound(::substrait::Expression_WindowFunction_Bound* lower_bound) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete lower_bound_; } if (lower_bound) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(lower_bound); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound>::GetOwningArena(lower_bound); if (message_arena != submessage_arena) { lower_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, lower_bound, submessage_arena); @@ -12081,7 +12833,7 @@ inline const ::substrait::Type& Expression_WindowFunction::output_type() const { } inline void Expression_WindowFunction::unsafe_arena_set_allocated_output_type( ::substrait::Type* output_type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } output_type_ = output_type; @@ -12096,9 +12848,15 @@ inline ::substrait::Type* Expression_WindowFunction::release_output_type() { ::substrait::Type* temp = output_type_; output_type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Type* Expression_WindowFunction::unsafe_arena_release_output_type() { @@ -12111,23 +12869,26 @@ inline ::substrait::Type* Expression_WindowFunction::unsafe_arena_release_output inline ::substrait::Type* Expression_WindowFunction::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); output_type_ = p; } return output_type_; } inline ::substrait::Type* Expression_WindowFunction::mutable_output_type() { + ::substrait::Type* _msg = _internal_mutable_output_type(); // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.output_type) - return _internal_mutable_output_type(); + return _msg; } inline void Expression_WindowFunction::set_allocated_output_type(::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } if (output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); if (message_arena != submessage_arena) { output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, output_type, submessage_arena); @@ -12170,8 +12931,9 @@ inline ::substrait::Expression* Expression_WindowFunction::_internal_add_args() return args_.Add(); } inline ::substrait::Expression* Expression_WindowFunction::add_args() { + ::substrait::Expression* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.args) - return _internal_add_args(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_WindowFunction::args() const { @@ -12191,7 +12953,7 @@ inline bool Expression_IfThen_IfClause::has_if_() const { return _internal_has_if_(); } inline void Expression_IfThen_IfClause::clear_if_() { - if (GetArena() == nullptr && if__ != nullptr) { + if (GetArenaForAllocation() == nullptr && if__ != nullptr) { delete if__; } if__ = nullptr; @@ -12207,7 +12969,7 @@ inline const ::substrait::Expression& Expression_IfThen_IfClause::if_() const { } inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_if_( ::substrait::Expression* if_) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); } if__ = if_; @@ -12222,9 +12984,15 @@ inline ::substrait::Expression* Expression_IfThen_IfClause::release_if_() { ::substrait::Expression* temp = if__; if__ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_if_() { @@ -12237,23 +13005,24 @@ inline ::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release inline ::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_if_() { if (if__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); if__ = p; } return if__; } inline ::substrait::Expression* Expression_IfThen_IfClause::mutable_if_() { + ::substrait::Expression* _msg = _internal_mutable_if_(); // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.IfClause.if) - return _internal_mutable_if_(); + return _msg; } inline void Expression_IfThen_IfClause::set_allocated_if_(::substrait::Expression* if_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete if__; } if (if_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(if_); if (message_arena != submessage_arena) { if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, if_, submessage_arena); @@ -12274,7 +13043,7 @@ inline bool Expression_IfThen_IfClause::has_then() const { return _internal_has_then(); } inline void Expression_IfThen_IfClause::clear_then() { - if (GetArena() == nullptr && then_ != nullptr) { + if (GetArenaForAllocation() == nullptr && then_ != nullptr) { delete then_; } then_ = nullptr; @@ -12290,7 +13059,7 @@ inline const ::substrait::Expression& Expression_IfThen_IfClause::then() const { } inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_then( ::substrait::Expression* then) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); } then_ = then; @@ -12305,9 +13074,15 @@ inline ::substrait::Expression* Expression_IfThen_IfClause::release_then() { ::substrait::Expression* temp = then_; then_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_then() { @@ -12320,23 +13095,24 @@ inline ::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release inline ::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_then() { if (then_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); then_ = p; } return then_; } inline ::substrait::Expression* Expression_IfThen_IfClause::mutable_then() { + ::substrait::Expression* _msg = _internal_mutable_then(); // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.IfClause.then) - return _internal_mutable_then(); + return _msg; } inline void Expression_IfThen_IfClause::set_allocated_then(::substrait::Expression* then) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete then_; } if (then) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(then); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(then); if (message_arena != submessage_arena) { then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, then, submessage_arena); @@ -12383,8 +13159,9 @@ inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::_internal_add return ifs_.Add(); } inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::add_ifs() { + ::substrait::Expression_IfThen_IfClause* _add = _internal_add_ifs(); // @@protoc_insertion_point(field_add:substrait.Expression.IfThen.ifs) - return _internal_add_ifs(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >& Expression_IfThen::ifs() const { @@ -12400,7 +13177,7 @@ inline bool Expression_IfThen::has_else_() const { return _internal_has_else_(); } inline void Expression_IfThen::clear_else_() { - if (GetArena() == nullptr && else__ != nullptr) { + if (GetArenaForAllocation() == nullptr && else__ != nullptr) { delete else__; } else__ = nullptr; @@ -12416,7 +13193,7 @@ inline const ::substrait::Expression& Expression_IfThen::else_() const { } inline void Expression_IfThen::unsafe_arena_set_allocated_else_( ::substrait::Expression* else_) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); } else__ = else_; @@ -12431,9 +13208,15 @@ inline ::substrait::Expression* Expression_IfThen::release_else_() { ::substrait::Expression* temp = else__; else__ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* Expression_IfThen::unsafe_arena_release_else_() { @@ -12446,23 +13229,24 @@ inline ::substrait::Expression* Expression_IfThen::unsafe_arena_release_else_() inline ::substrait::Expression* Expression_IfThen::_internal_mutable_else_() { if (else__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); else__ = p; } return else__; } inline ::substrait::Expression* Expression_IfThen::mutable_else_() { + ::substrait::Expression* _msg = _internal_mutable_else_(); // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.else) - return _internal_mutable_else_(); + return _msg; } inline void Expression_IfThen::set_allocated_else_(::substrait::Expression* else_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete else__; } if (else_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(else_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(else_); if (message_arena != submessage_arena) { else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, else_, submessage_arena); @@ -12497,7 +13281,7 @@ inline const ::substrait::Type& Expression_Cast::type() const { } inline void Expression_Cast::unsafe_arena_set_allocated_type( ::substrait::Type* type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } type_ = type; @@ -12512,9 +13296,15 @@ inline ::substrait::Type* Expression_Cast::release_type() { ::substrait::Type* temp = type_; type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Type* Expression_Cast::unsafe_arena_release_type() { @@ -12527,23 +13317,26 @@ inline ::substrait::Type* Expression_Cast::unsafe_arena_release_type() { inline ::substrait::Type* Expression_Cast::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); type_ = p; } return type_; } inline ::substrait::Type* Expression_Cast::mutable_type() { + ::substrait::Type* _msg = _internal_mutable_type(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Cast.type) - return _internal_mutable_type(); + return _msg; } inline void Expression_Cast::set_allocated_type(::substrait::Type* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } if (type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)); if (message_arena != submessage_arena) { type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type, submessage_arena); @@ -12564,7 +13357,7 @@ inline bool Expression_Cast::has_input() const { return _internal_has_input(); } inline void Expression_Cast::clear_input() { - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; @@ -12580,7 +13373,7 @@ inline const ::substrait::Expression& Expression_Cast::input() const { } inline void Expression_Cast::unsafe_arena_set_allocated_input( ::substrait::Expression* input) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } input_ = input; @@ -12595,9 +13388,15 @@ inline ::substrait::Expression* Expression_Cast::release_input() { ::substrait::Expression* temp = input_; input_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* Expression_Cast::unsafe_arena_release_input() { @@ -12610,23 +13409,24 @@ inline ::substrait::Expression* Expression_Cast::unsafe_arena_release_input() { inline ::substrait::Expression* Expression_Cast::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); input_ = p; } return input_; } inline ::substrait::Expression* Expression_Cast::mutable_input() { + ::substrait::Expression* _msg = _internal_mutable_input(); // @@protoc_insertion_point(field_mutable:substrait.Expression.Cast.input) - return _internal_mutable_input(); + return _msg; } inline void Expression_Cast::set_allocated_input(::substrait::Expression* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete input_; } if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(input); if (message_arena != submessage_arena) { input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, input, submessage_arena); @@ -12651,7 +13451,7 @@ inline bool Expression_SwitchExpression_IfValue::has_if_() const { return _internal_has_if_(); } inline void Expression_SwitchExpression_IfValue::clear_if_() { - if (GetArena() == nullptr && if__ != nullptr) { + if (GetArenaForAllocation() == nullptr && if__ != nullptr) { delete if__; } if__ = nullptr; @@ -12667,7 +13467,7 @@ inline const ::substrait::Expression_Literal& Expression_SwitchExpression_IfValu } inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_if_( ::substrait::Expression_Literal* if_) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); } if__ = if_; @@ -12682,9 +13482,15 @@ inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::rel ::substrait::Expression_Literal* temp = if__; if__ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::unsafe_arena_release_if_() { @@ -12697,23 +13503,24 @@ inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::uns inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::_internal_mutable_if_() { if (if__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation()); if__ = p; } return if__; } inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::mutable_if_() { + ::substrait::Expression_Literal* _msg = _internal_mutable_if_(); // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.IfValue.if) - return _internal_mutable_if_(); + return _msg; } inline void Expression_SwitchExpression_IfValue::set_allocated_if_(::substrait::Expression_Literal* if_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete if__; } if (if_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(if_); if (message_arena != submessage_arena) { if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, if_, submessage_arena); @@ -12734,7 +13541,7 @@ inline bool Expression_SwitchExpression_IfValue::has_then() const { return _internal_has_then(); } inline void Expression_SwitchExpression_IfValue::clear_then() { - if (GetArena() == nullptr && then_ != nullptr) { + if (GetArenaForAllocation() == nullptr && then_ != nullptr) { delete then_; } then_ = nullptr; @@ -12750,7 +13557,7 @@ inline const ::substrait::Expression& Expression_SwitchExpression_IfValue::then( } inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_then( ::substrait::Expression* then) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); } then_ = then; @@ -12765,9 +13572,15 @@ inline ::substrait::Expression* Expression_SwitchExpression_IfValue::release_the ::substrait::Expression* temp = then_; then_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_arena_release_then() { @@ -12780,23 +13593,24 @@ inline ::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_aren inline ::substrait::Expression* Expression_SwitchExpression_IfValue::_internal_mutable_then() { if (then_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); then_ = p; } return then_; } inline ::substrait::Expression* Expression_SwitchExpression_IfValue::mutable_then() { + ::substrait::Expression* _msg = _internal_mutable_then(); // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.IfValue.then) - return _internal_mutable_then(); + return _msg; } inline void Expression_SwitchExpression_IfValue::set_allocated_then(::substrait::Expression* then) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete then_; } if (then) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(then); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(then); if (message_arena != submessage_arena) { then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, then, submessage_arena); @@ -12843,8 +13657,9 @@ inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpres return ifs_.Add(); } inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::add_ifs() { + ::substrait::Expression_SwitchExpression_IfValue* _add = _internal_add_ifs(); // @@protoc_insertion_point(field_add:substrait.Expression.SwitchExpression.ifs) - return _internal_add_ifs(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >& Expression_SwitchExpression::ifs() const { @@ -12860,7 +13675,7 @@ inline bool Expression_SwitchExpression::has_else_() const { return _internal_has_else_(); } inline void Expression_SwitchExpression::clear_else_() { - if (GetArena() == nullptr && else__ != nullptr) { + if (GetArenaForAllocation() == nullptr && else__ != nullptr) { delete else__; } else__ = nullptr; @@ -12876,7 +13691,7 @@ inline const ::substrait::Expression& Expression_SwitchExpression::else_() const } inline void Expression_SwitchExpression::unsafe_arena_set_allocated_else_( ::substrait::Expression* else_) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); } else__ = else_; @@ -12891,9 +13706,15 @@ inline ::substrait::Expression* Expression_SwitchExpression::release_else_() { ::substrait::Expression* temp = else__; else__ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* Expression_SwitchExpression::unsafe_arena_release_else_() { @@ -12906,23 +13727,24 @@ inline ::substrait::Expression* Expression_SwitchExpression::unsafe_arena_releas inline ::substrait::Expression* Expression_SwitchExpression::_internal_mutable_else_() { if (else__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); else__ = p; } return else__; } inline ::substrait::Expression* Expression_SwitchExpression::mutable_else_() { + ::substrait::Expression* _msg = _internal_mutable_else_(); // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.else) - return _internal_mutable_else_(); + return _msg; } inline void Expression_SwitchExpression::set_allocated_else_(::substrait::Expression* else_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete else__; } if (else_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(else_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(else_); if (message_arena != submessage_arena) { else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, else_, submessage_arena); @@ -12947,7 +13769,7 @@ inline bool Expression_SingularOrList::has_value() const { return _internal_has_value(); } inline void Expression_SingularOrList::clear_value() { - if (GetArena() == nullptr && value_ != nullptr) { + if (GetArenaForAllocation() == nullptr && value_ != nullptr) { delete value_; } value_ = nullptr; @@ -12963,7 +13785,7 @@ inline const ::substrait::Expression& Expression_SingularOrList::value() const { } inline void Expression_SingularOrList::unsafe_arena_set_allocated_value( ::substrait::Expression* value) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } value_ = value; @@ -12978,9 +13800,15 @@ inline ::substrait::Expression* Expression_SingularOrList::release_value() { ::substrait::Expression* temp = value_; value_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* Expression_SingularOrList::unsafe_arena_release_value() { @@ -12993,23 +13821,24 @@ inline ::substrait::Expression* Expression_SingularOrList::unsafe_arena_release_ inline ::substrait::Expression* Expression_SingularOrList::_internal_mutable_value() { if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); value_ = p; } return value_; } inline ::substrait::Expression* Expression_SingularOrList::mutable_value() { + ::substrait::Expression* _msg = _internal_mutable_value(); // @@protoc_insertion_point(field_mutable:substrait.Expression.SingularOrList.value) - return _internal_mutable_value(); + return _msg; } inline void Expression_SingularOrList::set_allocated_value(::substrait::Expression* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete value_; } if (value) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(value); if (message_arena != submessage_arena) { value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, value, submessage_arena); @@ -13052,8 +13881,9 @@ inline ::substrait::Expression* Expression_SingularOrList::_internal_add_options return options_.Add(); } inline ::substrait::Expression* Expression_SingularOrList::add_options() { + ::substrait::Expression* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:substrait.Expression.SingularOrList.options) - return _internal_add_options(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_SingularOrList::options() const { @@ -13095,8 +13925,9 @@ inline ::substrait::Expression* Expression_MultiOrList_Record::_internal_add_fie return fields_.Add(); } inline ::substrait::Expression* Expression_MultiOrList_Record::add_fields() { + ::substrait::Expression* _add = _internal_add_fields(); // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.Record.fields) - return _internal_add_fields(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_MultiOrList_Record::fields() const { @@ -13138,8 +13969,9 @@ inline ::substrait::Expression* Expression_MultiOrList::_internal_add_value() { return value_.Add(); } inline ::substrait::Expression* Expression_MultiOrList::add_value() { + ::substrait::Expression* _add = _internal_add_value(); // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.value) - return _internal_add_value(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_MultiOrList::value() const { @@ -13177,8 +14009,9 @@ inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::_inte return options_.Add(); } inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::add_options() { + ::substrait::Expression_MultiOrList_Record* _add = _internal_add_options(); // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.options) - return _internal_add_options(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >& Expression_MultiOrList::options() const { @@ -13199,30 +14032,31 @@ inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::func return _internal_function(); } template -PROTOBUF_ALWAYS_INLINE -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_function(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void Expression_EmbeddedFunction_PythonPickleFunction::set_function(ArgT0&& arg0, ArgT... args) { - function_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + function_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) } inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_function() { + std::string* _s = _internal_mutable_function(); // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) - return _internal_mutable_function(); + return _s; } inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_function() const { return function_.Get(); } inline void Expression_EmbeddedFunction_PythonPickleFunction::_internal_set_function(const std::string& value) { - function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_mutable_function() { - return function_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return function_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::release_function() { // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) - return function_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return function_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void Expression_EmbeddedFunction_PythonPickleFunction::set_allocated_function(std::string* function) { if (function != nullptr) { @@ -13231,7 +14065,12 @@ inline void Expression_EmbeddedFunction_PythonPickleFunction::set_allocated_func } function_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), function, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (function_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) } @@ -13246,8 +14085,9 @@ inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_prerequisite prerequisite_.Clear(); } inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite() { + std::string* _s = _internal_add_prerequisite(); // @@protoc_insertion_point(field_add_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return _internal_add_prerequisite(); + return _s; } inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite(int index) const { return prerequisite_.Get(index); @@ -13261,12 +14101,12 @@ inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_pr return prerequisite_.Mutable(index); } inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) prerequisite_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) prerequisite_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) } inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -13322,30 +14162,31 @@ inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::scrip return _internal_script(); } template -PROTOBUF_ALWAYS_INLINE -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_script(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void Expression_EmbeddedFunction_WebAssemblyFunction::set_script(ArgT0&& arg0, ArgT... args) { - script_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + script_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) } inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_script() { + std::string* _s = _internal_mutable_script(); // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) - return _internal_mutable_script(); + return _s; } inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_script() const { return script_.Get(); } inline void Expression_EmbeddedFunction_WebAssemblyFunction::_internal_set_script(const std::string& value) { - script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_mutable_script() { - return script_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return script_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::release_script() { // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) - return script_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return script_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_allocated_script(std::string* script) { if (script != nullptr) { @@ -13354,7 +14195,12 @@ inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_allocated_scrip } script_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), script, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (script_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) } @@ -13369,8 +14215,9 @@ inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_prerequisite( prerequisite_.Clear(); } inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite() { + std::string* _s = _internal_add_prerequisite(); // @@protoc_insertion_point(field_add_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return _internal_add_prerequisite(); + return _s; } inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite(int index) const { return prerequisite_.Get(index); @@ -13384,12 +14231,12 @@ inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_pre return prerequisite_.Mutable(index); } inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) prerequisite_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) } inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) prerequisite_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) } inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -13466,8 +14313,9 @@ inline ::substrait::Expression* Expression_EmbeddedFunction::_internal_add_argum return arguments_.Add(); } inline ::substrait::Expression* Expression_EmbeddedFunction::add_arguments() { + ::substrait::Expression* _add = _internal_add_arguments(); // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.arguments) - return _internal_add_arguments(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& Expression_EmbeddedFunction::arguments() const { @@ -13493,7 +14341,7 @@ inline const ::substrait::Type& Expression_EmbeddedFunction::output_type() const } inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_output_type( ::substrait::Type* output_type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } output_type_ = output_type; @@ -13508,9 +14356,15 @@ inline ::substrait::Type* Expression_EmbeddedFunction::release_output_type() { ::substrait::Type* temp = output_type_; output_type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Type* Expression_EmbeddedFunction::unsafe_arena_release_output_type() { @@ -13523,23 +14377,26 @@ inline ::substrait::Type* Expression_EmbeddedFunction::unsafe_arena_release_outp inline ::substrait::Type* Expression_EmbeddedFunction::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); output_type_ = p; } return output_type_; } inline ::substrait::Type* Expression_EmbeddedFunction::mutable_output_type() { + ::substrait::Type* _msg = _internal_mutable_output_type(); // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.output_type) - return _internal_mutable_output_type(); + return _msg; } inline void Expression_EmbeddedFunction::set_allocated_output_type(::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } if (output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); if (message_arena != submessage_arena) { output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, output_type, submessage_arena); @@ -13564,7 +14421,7 @@ inline void Expression_EmbeddedFunction::set_has_python_pickle_function() { } inline void Expression_EmbeddedFunction::clear_python_pickle_function() { if (_internal_has_python_pickle_function()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.python_pickle_function_; } clear_has_kind(); @@ -13575,7 +14432,7 @@ inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression if (_internal_has_python_pickle_function()) { clear_has_kind(); ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.python_pickle_function_ = nullptr; @@ -13616,13 +14473,14 @@ inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression if (!_internal_has_python_pickle_function()) { clear_kind(); set_has_python_pickle_function(); - kind_.python_pickle_function_ = CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(GetArena()); + kind_.python_pickle_function_ = CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(GetArenaForAllocation()); } return kind_.python_pickle_function_; } inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::mutable_python_pickle_function() { + ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* _msg = _internal_mutable_python_pickle_function(); // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.python_pickle_function) - return _internal_mutable_python_pickle_function(); + return _msg; } // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; @@ -13637,7 +14495,7 @@ inline void Expression_EmbeddedFunction::set_has_web_assembly_function() { } inline void Expression_EmbeddedFunction::clear_web_assembly_function() { if (_internal_has_web_assembly_function()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.web_assembly_function_; } clear_has_kind(); @@ -13648,7 +14506,7 @@ inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_ if (_internal_has_web_assembly_function()) { clear_has_kind(); ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.web_assembly_function_ = nullptr; @@ -13689,13 +14547,14 @@ inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_ if (!_internal_has_web_assembly_function()) { clear_kind(); set_has_web_assembly_function(); - kind_.web_assembly_function_ = CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(GetArena()); + kind_.web_assembly_function_ = CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(GetArenaForAllocation()); } return kind_.web_assembly_function_; } inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::mutable_web_assembly_function() { + ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* _msg = _internal_mutable_web_assembly_function(); // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.web_assembly_function) - return _internal_mutable_web_assembly_function(); + return _msg; } inline bool Expression_EmbeddedFunction::has_kind() const { @@ -13719,7 +14578,7 @@ inline bool Expression_ReferenceSegment_MapKey::has_map_key() const { return _internal_has_map_key(); } inline void Expression_ReferenceSegment_MapKey::clear_map_key() { - if (GetArena() == nullptr && map_key_ != nullptr) { + if (GetArenaForAllocation() == nullptr && map_key_ != nullptr) { delete map_key_; } map_key_ = nullptr; @@ -13735,7 +14594,7 @@ inline const ::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey } inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_map_key( ::substrait::Expression_Literal* map_key) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_key_); } map_key_ = map_key; @@ -13750,9 +14609,15 @@ inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::rele ::substrait::Expression_Literal* temp = map_key_; map_key_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::unsafe_arena_release_map_key() { @@ -13765,23 +14630,24 @@ inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::unsa inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::_internal_mutable_map_key() { if (map_key_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation()); map_key_ = p; } return map_key_; } inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::mutable_map_key() { + ::substrait::Expression_Literal* _msg = _internal_mutable_map_key(); // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.MapKey.map_key) - return _internal_mutable_map_key(); + return _msg; } inline void Expression_ReferenceSegment_MapKey::set_allocated_map_key(::substrait::Expression_Literal* map_key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete map_key_; } if (map_key) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map_key); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(map_key); if (message_arena != submessage_arena) { map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, map_key, submessage_arena); @@ -13802,7 +14668,7 @@ inline bool Expression_ReferenceSegment_MapKey::has_child() const { return _internal_has_child(); } inline void Expression_ReferenceSegment_MapKey::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -13818,7 +14684,7 @@ inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegme } inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_child( ::substrait::Expression_ReferenceSegment* child) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } child_ = child; @@ -13833,9 +14699,15 @@ inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_Map ::substrait::Expression_ReferenceSegment* temp = child_; child_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::unsafe_arena_release_child() { @@ -13848,23 +14720,24 @@ inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_Map inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArenaForAllocation()); child_ = p; } return child_; } inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::mutable_child() { + ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_child(); // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.MapKey.child) - return _internal_mutable_child(); + return _msg; } inline void Expression_ReferenceSegment_MapKey::set_allocated_child(::substrait::Expression_ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete child_; } if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(child); if (message_arena != submessage_arena) { child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, child, submessage_arena); @@ -13885,18 +14758,18 @@ inline void Expression_ReferenceSegment_MapKey::set_allocated_child(::substrait: inline void Expression_ReferenceSegment_StructField::clear_field() { field_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_StructField::_internal_field() const { +inline int32_t Expression_ReferenceSegment_StructField::_internal_field() const { return field_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_StructField::field() const { +inline int32_t Expression_ReferenceSegment_StructField::field() const { // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.StructField.field) return _internal_field(); } -inline void Expression_ReferenceSegment_StructField::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_ReferenceSegment_StructField::_internal_set_field(int32_t value) { field_ = value; } -inline void Expression_ReferenceSegment_StructField::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_ReferenceSegment_StructField::set_field(int32_t value) { _internal_set_field(value); // @@protoc_insertion_point(field_set:substrait.Expression.ReferenceSegment.StructField.field) } @@ -13909,7 +14782,7 @@ inline bool Expression_ReferenceSegment_StructField::has_child() const { return _internal_has_child(); } inline void Expression_ReferenceSegment_StructField::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -13925,7 +14798,7 @@ inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegme } inline void Expression_ReferenceSegment_StructField::unsafe_arena_set_allocated_child( ::substrait::Expression_ReferenceSegment* child) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } child_ = child; @@ -13940,9 +14813,15 @@ inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_Str ::substrait::Expression_ReferenceSegment* temp = child_; child_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::unsafe_arena_release_child() { @@ -13955,23 +14834,24 @@ inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_Str inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArenaForAllocation()); child_ = p; } return child_; } inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::mutable_child() { + ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_child(); // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.StructField.child) - return _internal_mutable_child(); + return _msg; } inline void Expression_ReferenceSegment_StructField::set_allocated_child(::substrait::Expression_ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete child_; } if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(child); if (message_arena != submessage_arena) { child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, child, submessage_arena); @@ -13992,18 +14872,18 @@ inline void Expression_ReferenceSegment_StructField::set_allocated_child(::subst inline void Expression_ReferenceSegment_ListElement::clear_offset() { offset_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_ListElement::_internal_offset() const { +inline int32_t Expression_ReferenceSegment_ListElement::_internal_offset() const { return offset_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_ReferenceSegment_ListElement::offset() const { +inline int32_t Expression_ReferenceSegment_ListElement::offset() const { // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.ListElement.offset) return _internal_offset(); } -inline void Expression_ReferenceSegment_ListElement::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_ReferenceSegment_ListElement::_internal_set_offset(int32_t value) { offset_ = value; } -inline void Expression_ReferenceSegment_ListElement::set_offset(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_ReferenceSegment_ListElement::set_offset(int32_t value) { _internal_set_offset(value); // @@protoc_insertion_point(field_set:substrait.Expression.ReferenceSegment.ListElement.offset) } @@ -14016,7 +14896,7 @@ inline bool Expression_ReferenceSegment_ListElement::has_child() const { return _internal_has_child(); } inline void Expression_ReferenceSegment_ListElement::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -14032,7 +14912,7 @@ inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegme } inline void Expression_ReferenceSegment_ListElement::unsafe_arena_set_allocated_child( ::substrait::Expression_ReferenceSegment* child) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } child_ = child; @@ -14047,9 +14927,15 @@ inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_Lis ::substrait::Expression_ReferenceSegment* temp = child_; child_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::unsafe_arena_release_child() { @@ -14062,23 +14948,24 @@ inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_Lis inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArenaForAllocation()); child_ = p; } return child_; } inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::mutable_child() { + ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_child(); // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.ListElement.child) - return _internal_mutable_child(); + return _msg; } inline void Expression_ReferenceSegment_ListElement::set_allocated_child(::substrait::Expression_ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete child_; } if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(child); if (message_arena != submessage_arena) { child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, child, submessage_arena); @@ -14107,7 +14994,7 @@ inline void Expression_ReferenceSegment::set_has_map_key() { } inline void Expression_ReferenceSegment::clear_map_key() { if (_internal_has_map_key()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reference_type_.map_key_; } clear_has_reference_type(); @@ -14118,7 +15005,7 @@ inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegm if (_internal_has_map_key()) { clear_has_reference_type(); ::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } reference_type_.map_key_ = nullptr; @@ -14159,13 +15046,14 @@ inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegm if (!_internal_has_map_key()) { clear_reference_type(); set_has_map_key(); - reference_type_.map_key_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_MapKey >(GetArena()); + reference_type_.map_key_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_MapKey >(GetArenaForAllocation()); } return reference_type_.map_key_; } inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::mutable_map_key() { + ::substrait::Expression_ReferenceSegment_MapKey* _msg = _internal_mutable_map_key(); // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.map_key) - return _internal_mutable_map_key(); + return _msg; } // .substrait.Expression.ReferenceSegment.StructField struct_field = 2; @@ -14180,7 +15068,7 @@ inline void Expression_ReferenceSegment::set_has_struct_field() { } inline void Expression_ReferenceSegment::clear_struct_field() { if (_internal_has_struct_field()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reference_type_.struct_field_; } clear_has_reference_type(); @@ -14191,7 +15079,7 @@ inline ::substrait::Expression_ReferenceSegment_StructField* Expression_Referenc if (_internal_has_struct_field()) { clear_has_reference_type(); ::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } reference_type_.struct_field_ = nullptr; @@ -14232,13 +15120,14 @@ inline ::substrait::Expression_ReferenceSegment_StructField* Expression_Referenc if (!_internal_has_struct_field()) { clear_reference_type(); set_has_struct_field(); - reference_type_.struct_field_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_StructField >(GetArena()); + reference_type_.struct_field_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_StructField >(GetArenaForAllocation()); } return reference_type_.struct_field_; } inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::mutable_struct_field() { + ::substrait::Expression_ReferenceSegment_StructField* _msg = _internal_mutable_struct_field(); // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.struct_field) - return _internal_mutable_struct_field(); + return _msg; } // .substrait.Expression.ReferenceSegment.ListElement list_element = 3; @@ -14253,7 +15142,7 @@ inline void Expression_ReferenceSegment::set_has_list_element() { } inline void Expression_ReferenceSegment::clear_list_element() { if (_internal_has_list_element()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reference_type_.list_element_; } clear_has_reference_type(); @@ -14264,7 +15153,7 @@ inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_Referenc if (_internal_has_list_element()) { clear_has_reference_type(); ::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } reference_type_.list_element_ = nullptr; @@ -14305,13 +15194,14 @@ inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_Referenc if (!_internal_has_list_element()) { clear_reference_type(); set_has_list_element(); - reference_type_.list_element_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_ListElement >(GetArena()); + reference_type_.list_element_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_ListElement >(GetArenaForAllocation()); } return reference_type_.list_element_; } inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::mutable_list_element() { + ::substrait::Expression_ReferenceSegment_ListElement* _msg = _internal_mutable_list_element(); // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.list_element) - return _internal_mutable_list_element(); + return _msg; } inline bool Expression_ReferenceSegment::has_reference_type() const { @@ -14339,7 +15229,7 @@ inline void Expression_MaskExpression_Select::set_has_struct_() { } inline void Expression_MaskExpression_Select::clear_struct_() { if (_internal_has_struct_()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete type_.struct__; } clear_has_type(); @@ -14350,7 +15240,7 @@ inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpre if (_internal_has_struct_()) { clear_has_type(); ::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } type_.struct__ = nullptr; @@ -14391,13 +15281,14 @@ inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpre if (!_internal_has_struct_()) { clear_type(); set_has_struct_(); - type_.struct__ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructSelect >(GetArena()); + type_.struct__ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructSelect >(GetArenaForAllocation()); } return type_.struct__; } inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::mutable_struct_() { + ::substrait::Expression_MaskExpression_StructSelect* _msg = _internal_mutable_struct_(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.struct) - return _internal_mutable_struct_(); + return _msg; } // .substrait.Expression.MaskExpression.ListSelect list = 2; @@ -14412,7 +15303,7 @@ inline void Expression_MaskExpression_Select::set_has_list() { } inline void Expression_MaskExpression_Select::clear_list() { if (_internal_has_list()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete type_.list_; } clear_has_type(); @@ -14423,7 +15314,7 @@ inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpress if (_internal_has_list()) { clear_has_type(); ::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } type_.list_ = nullptr; @@ -14464,13 +15355,14 @@ inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpress if (!_internal_has_list()) { clear_type(); set_has_list(); - type_.list_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect >(GetArena()); + type_.list_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect >(GetArenaForAllocation()); } return type_.list_; } inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::mutable_list() { + ::substrait::Expression_MaskExpression_ListSelect* _msg = _internal_mutable_list(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.list) - return _internal_mutable_list(); + return _msg; } // .substrait.Expression.MaskExpression.MapSelect map = 3; @@ -14485,7 +15377,7 @@ inline void Expression_MaskExpression_Select::set_has_map() { } inline void Expression_MaskExpression_Select::clear_map() { if (_internal_has_map()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete type_.map_; } clear_has_type(); @@ -14496,7 +15388,7 @@ inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpressi if (_internal_has_map()) { clear_has_type(); ::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } type_.map_ = nullptr; @@ -14537,13 +15429,14 @@ inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpressi if (!_internal_has_map()) { clear_type(); set_has_map(); - type_.map_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect >(GetArena()); + type_.map_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect >(GetArenaForAllocation()); } return type_.map_; } inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::mutable_map() { + ::substrait::Expression_MaskExpression_MapSelect* _msg = _internal_mutable_map(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.map) - return _internal_mutable_map(); + return _msg; } inline bool Expression_MaskExpression_Select::has_type() const { @@ -14589,8 +15482,9 @@ inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpress return struct_items_.Add(); } inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::add_struct_items() { + ::substrait::Expression_MaskExpression_StructItem* _add = _internal_add_struct_items(); // @@protoc_insertion_point(field_add:substrait.Expression.MaskExpression.StructSelect.struct_items) - return _internal_add_struct_items(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >& Expression_MaskExpression_StructSelect::struct_items() const { @@ -14606,18 +15500,18 @@ Expression_MaskExpression_StructSelect::struct_items() const { inline void Expression_MaskExpression_StructItem::clear_field() { field_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_StructItem::_internal_field() const { +inline int32_t Expression_MaskExpression_StructItem::_internal_field() const { return field_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_StructItem::field() const { +inline int32_t Expression_MaskExpression_StructItem::field() const { // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.StructItem.field) return _internal_field(); } -inline void Expression_MaskExpression_StructItem::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_MaskExpression_StructItem::_internal_set_field(int32_t value) { field_ = value; } -inline void Expression_MaskExpression_StructItem::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_MaskExpression_StructItem::set_field(int32_t value) { _internal_set_field(value); // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.StructItem.field) } @@ -14630,7 +15524,7 @@ inline bool Expression_MaskExpression_StructItem::has_child() const { return _internal_has_child(); } inline void Expression_MaskExpression_StructItem::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -14646,7 +15540,7 @@ inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpre } inline void Expression_MaskExpression_StructItem::unsafe_arena_set_allocated_child( ::substrait::Expression_MaskExpression_Select* child) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } child_ = child; @@ -14661,9 +15555,15 @@ inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ ::substrait::Expression_MaskExpression_Select* temp = child_; child_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::unsafe_arena_release_child() { @@ -14676,23 +15576,24 @@ inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArenaForAllocation()); child_ = p; } return child_; } inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::mutable_child() { + ::substrait::Expression_MaskExpression_Select* _msg = _internal_mutable_child(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.StructItem.child) - return _internal_mutable_child(); + return _msg; } inline void Expression_MaskExpression_StructItem::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete child_; } if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_Select>::GetOwningArena(child); if (message_arena != submessage_arena) { child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, child, submessage_arena); @@ -14713,18 +15614,18 @@ inline void Expression_MaskExpression_StructItem::set_allocated_child(::substrai inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::clear_field() { field_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_field() const { +inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_field() const { return field_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::field() const { +inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::field() const { // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field) return _internal_field(); } -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_set_field(int32_t value) { field_ = value; } -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::set_field(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::set_field(int32_t value) { _internal_set_field(value); // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field) } @@ -14737,18 +15638,18 @@ inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::set inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_start() { start_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_start() const { +inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_start() const { return start_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::start() const { +inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::start() const { // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) return _internal_start(); } -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_start(int32_t value) { start_ = value; } -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_start(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_start(int32_t value) { _internal_set_start(value); // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) } @@ -14757,18 +15658,18 @@ inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_s inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_end() { end_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_end() const { +inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_end() const { return end_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::end() const { +inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::end() const { // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) return _internal_end(); } -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_end(int32_t value) { end_ = value; } -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_end(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_end(int32_t value) { _internal_set_end(value); // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) } @@ -14789,7 +15690,7 @@ inline void Expression_MaskExpression_ListSelect_ListSelectItem::set_has_item() } inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_item() { if (_internal_has_item()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete type_.item_; } clear_has_type(); @@ -14800,7 +15701,7 @@ inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElem if (_internal_has_item()) { clear_has_type(); ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } type_.item_ = nullptr; @@ -14841,13 +15742,14 @@ inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElem if (!_internal_has_item()) { clear_type(); set_has_item(); - type_.item_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(GetArena()); + type_.item_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(GetArenaForAllocation()); } return type_.item_; } inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_item() { + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _msg = _internal_mutable_item(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) - return _internal_mutable_item(); + return _msg; } // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; @@ -14862,7 +15764,7 @@ inline void Expression_MaskExpression_ListSelect_ListSelectItem::set_has_slice() } inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_slice() { if (_internal_has_slice()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete type_.slice_; } clear_has_type(); @@ -14873,7 +15775,7 @@ inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlic if (_internal_has_slice()) { clear_has_type(); ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } type_.slice_ = nullptr; @@ -14914,13 +15816,14 @@ inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlic if (!_internal_has_slice()) { clear_type(); set_has_slice(); - type_.slice_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(GetArena()); + type_.slice_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(GetArenaForAllocation()); } return type_.slice_; } inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_slice() { + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _msg = _internal_mutable_slice(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) - return _internal_mutable_slice(); + return _msg; } inline bool Expression_MaskExpression_ListSelect_ListSelectItem::has_type() const { @@ -14966,8 +15869,9 @@ inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Express return selection_.Add(); } inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::add_selection() { + ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* _add = _internal_add_selection(); // @@protoc_insertion_point(field_add:substrait.Expression.MaskExpression.ListSelect.selection) - return _internal_add_selection(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >& Expression_MaskExpression_ListSelect::selection() const { @@ -14983,7 +15887,7 @@ inline bool Expression_MaskExpression_ListSelect::has_child() const { return _internal_has_child(); } inline void Expression_MaskExpression_ListSelect::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -14999,7 +15903,7 @@ inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpre } inline void Expression_MaskExpression_ListSelect::unsafe_arena_set_allocated_child( ::substrait::Expression_MaskExpression_Select* child) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } child_ = child; @@ -15014,9 +15918,15 @@ inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ ::substrait::Expression_MaskExpression_Select* temp = child_; child_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::unsafe_arena_release_child() { @@ -15029,23 +15939,24 @@ inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArenaForAllocation()); child_ = p; } return child_; } inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::mutable_child() { + ::substrait::Expression_MaskExpression_Select* _msg = _internal_mutable_child(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.child) - return _internal_mutable_child(); + return _msg; } inline void Expression_MaskExpression_ListSelect::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete child_; } if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_Select>::GetOwningArena(child); if (message_arena != submessage_arena) { child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, child, submessage_arena); @@ -15071,30 +15982,31 @@ inline const std::string& Expression_MaskExpression_MapSelect_MapKey::map_key() return _internal_map_key(); } template -PROTOBUF_ALWAYS_INLINE -inline void Expression_MaskExpression_MapSelect_MapKey::set_map_key(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void Expression_MaskExpression_MapSelect_MapKey::set_map_key(ArgT0&& arg0, ArgT... args) { - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) } inline std::string* Expression_MaskExpression_MapSelect_MapKey::mutable_map_key() { + std::string* _s = _internal_mutable_map_key(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) - return _internal_mutable_map_key(); + return _s; } inline const std::string& Expression_MaskExpression_MapSelect_MapKey::_internal_map_key() const { return map_key_.Get(); } inline void Expression_MaskExpression_MapSelect_MapKey::_internal_set_map_key(const std::string& value) { - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_MaskExpression_MapSelect_MapKey::_internal_mutable_map_key() { - return map_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return map_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_MaskExpression_MapSelect_MapKey::release_map_key() { // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) - return map_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return map_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void Expression_MaskExpression_MapSelect_MapKey::set_allocated_map_key(std::string* map_key) { if (map_key != nullptr) { @@ -15103,7 +16015,12 @@ inline void Expression_MaskExpression_MapSelect_MapKey::set_allocated_map_key(st } map_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (map_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) } @@ -15120,30 +16037,31 @@ inline const std::string& Expression_MaskExpression_MapSelect_MapKeyExpression:: return _internal_map_key_expression(); } template -PROTOBUF_ALWAYS_INLINE -inline void Expression_MaskExpression_MapSelect_MapKeyExpression::set_map_key_expression(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void Expression_MaskExpression_MapSelect_MapKeyExpression::set_map_key_expression(ArgT0&& arg0, ArgT... args) { - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) } inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::mutable_map_key_expression() { + std::string* _s = _internal_mutable_map_key_expression(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) - return _internal_mutable_map_key_expression(); + return _s; } inline const std::string& Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_map_key_expression() const { return map_key_expression_.Get(); } inline void Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_set_map_key_expression(const std::string& value) { - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_mutable_map_key_expression() { - return map_key_expression_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return map_key_expression_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::release_map_key_expression() { // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) - return map_key_expression_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return map_key_expression_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void Expression_MaskExpression_MapSelect_MapKeyExpression::set_allocated_map_key_expression(std::string* map_key_expression) { if (map_key_expression != nullptr) { @@ -15152,7 +16070,12 @@ inline void Expression_MaskExpression_MapSelect_MapKeyExpression::set_allocated_ } map_key_expression_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key_expression, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (map_key_expression_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) } @@ -15172,7 +16095,7 @@ inline void Expression_MaskExpression_MapSelect::set_has_key() { } inline void Expression_MaskExpression_MapSelect::clear_key() { if (_internal_has_key()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete select_.key_; } clear_has_select(); @@ -15183,7 +16106,7 @@ inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskE if (_internal_has_key()) { clear_has_select(); ::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } select_.key_ = nullptr; @@ -15224,13 +16147,14 @@ inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskE if (!_internal_has_key()) { clear_select(); set_has_key(); - select_.key_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(GetArena()); + select_.key_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(GetArenaForAllocation()); } return select_.key_; } inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::mutable_key() { + ::substrait::Expression_MaskExpression_MapSelect_MapKey* _msg = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.key) - return _internal_mutable_key(); + return _msg; } // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; @@ -15245,7 +16169,7 @@ inline void Expression_MaskExpression_MapSelect::set_has_expression() { } inline void Expression_MaskExpression_MapSelect::clear_expression() { if (_internal_has_expression()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete select_.expression_; } clear_has_select(); @@ -15256,7 +16180,7 @@ inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expres if (_internal_has_expression()) { clear_has_select(); ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } select_.expression_ = nullptr; @@ -15297,13 +16221,14 @@ inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expres if (!_internal_has_expression()) { clear_select(); set_has_expression(); - select_.expression_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(GetArena()); + select_.expression_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(GetArenaForAllocation()); } return select_.expression_; } inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::mutable_expression() { + ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* _msg = _internal_mutable_expression(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.expression) - return _internal_mutable_expression(); + return _msg; } // .substrait.Expression.MaskExpression.Select child = 3; @@ -15314,7 +16239,7 @@ inline bool Expression_MaskExpression_MapSelect::has_child() const { return _internal_has_child(); } inline void Expression_MaskExpression_MapSelect::clear_child() { - if (GetArena() == nullptr && child_ != nullptr) { + if (GetArenaForAllocation() == nullptr && child_ != nullptr) { delete child_; } child_ = nullptr; @@ -15330,7 +16255,7 @@ inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpre } inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_child( ::substrait::Expression_MaskExpression_Select* child) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); } child_ = child; @@ -15345,9 +16270,15 @@ inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ ::substrait::Expression_MaskExpression_Select* temp = child_; child_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::unsafe_arena_release_child() { @@ -15360,23 +16291,24 @@ inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::_internal_mutable_child() { if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArenaForAllocation()); child_ = p; } return child_; } inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::mutable_child() { + ::substrait::Expression_MaskExpression_Select* _msg = _internal_mutable_child(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.child) - return _internal_mutable_child(); + return _msg; } inline void Expression_MaskExpression_MapSelect::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete child_; } if (child) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(child); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_Select>::GetOwningArena(child); if (message_arena != submessage_arena) { child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, child, submessage_arena); @@ -15410,7 +16342,7 @@ inline bool Expression_MaskExpression::has_select() const { return _internal_has_select(); } inline void Expression_MaskExpression::clear_select() { - if (GetArena() == nullptr && select_ != nullptr) { + if (GetArenaForAllocation() == nullptr && select_ != nullptr) { delete select_; } select_ = nullptr; @@ -15426,7 +16358,7 @@ inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_Mas } inline void Expression_MaskExpression::unsafe_arena_set_allocated_select( ::substrait::Expression_MaskExpression_StructSelect* select) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(select_); } select_ = select; @@ -15441,9 +16373,15 @@ inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpre ::substrait::Expression_MaskExpression_StructSelect* temp = select_; select_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::unsafe_arena_release_select() { @@ -15456,23 +16394,24 @@ inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpre inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::_internal_mutable_select() { if (select_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_StructSelect>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_StructSelect>(GetArenaForAllocation()); select_ = p; } return select_; } inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::mutable_select() { + ::substrait::Expression_MaskExpression_StructSelect* _msg = _internal_mutable_select(); // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.select) - return _internal_mutable_select(); + return _msg; } inline void Expression_MaskExpression::set_allocated_select(::substrait::Expression_MaskExpression_StructSelect* select) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete select_; } if (select) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(select); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_StructSelect>::GetOwningArena(select); if (message_arena != submessage_arena) { select = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, select, submessage_arena); @@ -15525,7 +16464,7 @@ inline void Expression_FieldReference::set_has_direct_reference() { } inline void Expression_FieldReference::clear_direct_reference() { if (_internal_has_direct_reference()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reference_type_.direct_reference_; } clear_has_reference_type(); @@ -15536,7 +16475,7 @@ inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::rele if (_internal_has_direct_reference()) { clear_has_reference_type(); ::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } reference_type_.direct_reference_ = nullptr; @@ -15577,13 +16516,14 @@ inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::_int if (!_internal_has_direct_reference()) { clear_reference_type(); set_has_direct_reference(); - reference_type_.direct_reference_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment >(GetArena()); + reference_type_.direct_reference_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment >(GetArenaForAllocation()); } return reference_type_.direct_reference_; } inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::mutable_direct_reference() { + ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_direct_reference(); // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.direct_reference) - return _internal_mutable_direct_reference(); + return _msg; } // .substrait.Expression.MaskExpression masked_reference = 2; @@ -15598,7 +16538,7 @@ inline void Expression_FieldReference::set_has_masked_reference() { } inline void Expression_FieldReference::clear_masked_reference() { if (_internal_has_masked_reference()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reference_type_.masked_reference_; } clear_has_reference_type(); @@ -15609,7 +16549,7 @@ inline ::substrait::Expression_MaskExpression* Expression_FieldReference::releas if (_internal_has_masked_reference()) { clear_has_reference_type(); ::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } reference_type_.masked_reference_ = nullptr; @@ -15650,13 +16590,14 @@ inline ::substrait::Expression_MaskExpression* Expression_FieldReference::_inter if (!_internal_has_masked_reference()) { clear_reference_type(); set_has_masked_reference(); - reference_type_.masked_reference_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression >(GetArena()); + reference_type_.masked_reference_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression >(GetArenaForAllocation()); } return reference_type_.masked_reference_; } inline ::substrait::Expression_MaskExpression* Expression_FieldReference::mutable_masked_reference() { + ::substrait::Expression_MaskExpression* _msg = _internal_mutable_masked_reference(); // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.masked_reference) - return _internal_mutable_masked_reference(); + return _msg; } // .substrait.Expression expression = 3; @@ -15671,7 +16612,7 @@ inline void Expression_FieldReference::set_has_expression() { } inline void Expression_FieldReference::clear_expression() { if (_internal_has_expression()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete root_type_.expression_; } clear_has_root_type(); @@ -15682,7 +16623,7 @@ inline ::substrait::Expression* Expression_FieldReference::release_expression() if (_internal_has_expression()) { clear_has_root_type(); ::substrait::Expression* temp = root_type_.expression_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } root_type_.expression_ = nullptr; @@ -15723,13 +16664,14 @@ inline ::substrait::Expression* Expression_FieldReference::_internal_mutable_exp if (!_internal_has_expression()) { clear_root_type(); set_has_expression(); - root_type_.expression_ = CreateMaybeMessage< ::substrait::Expression >(GetArena()); + root_type_.expression_ = CreateMaybeMessage< ::substrait::Expression >(GetArenaForAllocation()); } return root_type_.expression_; } inline ::substrait::Expression* Expression_FieldReference::mutable_expression() { + ::substrait::Expression* _msg = _internal_mutable_expression(); // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.expression) - return _internal_mutable_expression(); + return _msg; } // .substrait.Expression.FieldReference.RootReference root_reference = 4; @@ -15744,7 +16686,7 @@ inline void Expression_FieldReference::set_has_root_reference() { } inline void Expression_FieldReference::clear_root_reference() { if (_internal_has_root_reference()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete root_type_.root_reference_; } clear_has_root_type(); @@ -15755,7 +16697,7 @@ inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldRef if (_internal_has_root_reference()) { clear_has_root_type(); ::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } root_type_.root_reference_ = nullptr; @@ -15796,13 +16738,14 @@ inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldRef if (!_internal_has_root_reference()) { clear_root_type(); set_has_root_reference(); - root_type_.root_reference_ = CreateMaybeMessage< ::substrait::Expression_FieldReference_RootReference >(GetArena()); + root_type_.root_reference_ = CreateMaybeMessage< ::substrait::Expression_FieldReference_RootReference >(GetArenaForAllocation()); } return root_type_.root_reference_; } inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::mutable_root_reference() { + ::substrait::Expression_FieldReference_RootReference* _msg = _internal_mutable_root_reference(); // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.root_reference) - return _internal_mutable_root_reference(); + return _msg; } inline bool Expression_FieldReference::has_reference_type() const { @@ -15839,7 +16782,7 @@ inline void Expression::set_has_literal() { } inline void Expression::clear_literal() { if (_internal_has_literal()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.literal_; } clear_has_rex_type(); @@ -15850,7 +16793,7 @@ inline ::substrait::Expression_Literal* Expression::release_literal() { if (_internal_has_literal()) { clear_has_rex_type(); ::substrait::Expression_Literal* temp = rex_type_.literal_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rex_type_.literal_ = nullptr; @@ -15891,13 +16834,14 @@ inline ::substrait::Expression_Literal* Expression::_internal_mutable_literal() if (!_internal_has_literal()) { clear_rex_type(); set_has_literal(); - rex_type_.literal_ = CreateMaybeMessage< ::substrait::Expression_Literal >(GetArena()); + rex_type_.literal_ = CreateMaybeMessage< ::substrait::Expression_Literal >(GetArenaForAllocation()); } return rex_type_.literal_; } inline ::substrait::Expression_Literal* Expression::mutable_literal() { + ::substrait::Expression_Literal* _msg = _internal_mutable_literal(); // @@protoc_insertion_point(field_mutable:substrait.Expression.literal) - return _internal_mutable_literal(); + return _msg; } // .substrait.Expression.FieldReference selection = 2; @@ -15912,7 +16856,7 @@ inline void Expression::set_has_selection() { } inline void Expression::clear_selection() { if (_internal_has_selection()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.selection_; } clear_has_rex_type(); @@ -15923,7 +16867,7 @@ inline ::substrait::Expression_FieldReference* Expression::release_selection() { if (_internal_has_selection()) { clear_has_rex_type(); ::substrait::Expression_FieldReference* temp = rex_type_.selection_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rex_type_.selection_ = nullptr; @@ -15964,13 +16908,14 @@ inline ::substrait::Expression_FieldReference* Expression::_internal_mutable_sel if (!_internal_has_selection()) { clear_rex_type(); set_has_selection(); - rex_type_.selection_ = CreateMaybeMessage< ::substrait::Expression_FieldReference >(GetArena()); + rex_type_.selection_ = CreateMaybeMessage< ::substrait::Expression_FieldReference >(GetArenaForAllocation()); } return rex_type_.selection_; } inline ::substrait::Expression_FieldReference* Expression::mutable_selection() { + ::substrait::Expression_FieldReference* _msg = _internal_mutable_selection(); // @@protoc_insertion_point(field_mutable:substrait.Expression.selection) - return _internal_mutable_selection(); + return _msg; } // .substrait.Expression.ScalarFunction scalar_function = 3; @@ -15985,7 +16930,7 @@ inline void Expression::set_has_scalar_function() { } inline void Expression::clear_scalar_function() { if (_internal_has_scalar_function()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.scalar_function_; } clear_has_rex_type(); @@ -15996,7 +16941,7 @@ inline ::substrait::Expression_ScalarFunction* Expression::release_scalar_functi if (_internal_has_scalar_function()) { clear_has_rex_type(); ::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rex_type_.scalar_function_ = nullptr; @@ -16037,13 +16982,14 @@ inline ::substrait::Expression_ScalarFunction* Expression::_internal_mutable_sca if (!_internal_has_scalar_function()) { clear_rex_type(); set_has_scalar_function(); - rex_type_.scalar_function_ = CreateMaybeMessage< ::substrait::Expression_ScalarFunction >(GetArena()); + rex_type_.scalar_function_ = CreateMaybeMessage< ::substrait::Expression_ScalarFunction >(GetArenaForAllocation()); } return rex_type_.scalar_function_; } inline ::substrait::Expression_ScalarFunction* Expression::mutable_scalar_function() { + ::substrait::Expression_ScalarFunction* _msg = _internal_mutable_scalar_function(); // @@protoc_insertion_point(field_mutable:substrait.Expression.scalar_function) - return _internal_mutable_scalar_function(); + return _msg; } // .substrait.Expression.WindowFunction window_function = 5; @@ -16058,7 +17004,7 @@ inline void Expression::set_has_window_function() { } inline void Expression::clear_window_function() { if (_internal_has_window_function()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.window_function_; } clear_has_rex_type(); @@ -16069,7 +17015,7 @@ inline ::substrait::Expression_WindowFunction* Expression::release_window_functi if (_internal_has_window_function()) { clear_has_rex_type(); ::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rex_type_.window_function_ = nullptr; @@ -16110,13 +17056,14 @@ inline ::substrait::Expression_WindowFunction* Expression::_internal_mutable_win if (!_internal_has_window_function()) { clear_rex_type(); set_has_window_function(); - rex_type_.window_function_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction >(GetArena()); + rex_type_.window_function_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction >(GetArenaForAllocation()); } return rex_type_.window_function_; } inline ::substrait::Expression_WindowFunction* Expression::mutable_window_function() { + ::substrait::Expression_WindowFunction* _msg = _internal_mutable_window_function(); // @@protoc_insertion_point(field_mutable:substrait.Expression.window_function) - return _internal_mutable_window_function(); + return _msg; } // .substrait.Expression.IfThen if_then = 6; @@ -16131,7 +17078,7 @@ inline void Expression::set_has_if_then() { } inline void Expression::clear_if_then() { if (_internal_has_if_then()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.if_then_; } clear_has_rex_type(); @@ -16142,7 +17089,7 @@ inline ::substrait::Expression_IfThen* Expression::release_if_then() { if (_internal_has_if_then()) { clear_has_rex_type(); ::substrait::Expression_IfThen* temp = rex_type_.if_then_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rex_type_.if_then_ = nullptr; @@ -16183,13 +17130,14 @@ inline ::substrait::Expression_IfThen* Expression::_internal_mutable_if_then() { if (!_internal_has_if_then()) { clear_rex_type(); set_has_if_then(); - rex_type_.if_then_ = CreateMaybeMessage< ::substrait::Expression_IfThen >(GetArena()); + rex_type_.if_then_ = CreateMaybeMessage< ::substrait::Expression_IfThen >(GetArenaForAllocation()); } return rex_type_.if_then_; } inline ::substrait::Expression_IfThen* Expression::mutable_if_then() { + ::substrait::Expression_IfThen* _msg = _internal_mutable_if_then(); // @@protoc_insertion_point(field_mutable:substrait.Expression.if_then) - return _internal_mutable_if_then(); + return _msg; } // .substrait.Expression.SwitchExpression switch_expression = 7; @@ -16204,7 +17152,7 @@ inline void Expression::set_has_switch_expression() { } inline void Expression::clear_switch_expression() { if (_internal_has_switch_expression()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.switch_expression_; } clear_has_rex_type(); @@ -16215,7 +17163,7 @@ inline ::substrait::Expression_SwitchExpression* Expression::release_switch_expr if (_internal_has_switch_expression()) { clear_has_rex_type(); ::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rex_type_.switch_expression_ = nullptr; @@ -16256,13 +17204,14 @@ inline ::substrait::Expression_SwitchExpression* Expression::_internal_mutable_s if (!_internal_has_switch_expression()) { clear_rex_type(); set_has_switch_expression(); - rex_type_.switch_expression_ = CreateMaybeMessage< ::substrait::Expression_SwitchExpression >(GetArena()); + rex_type_.switch_expression_ = CreateMaybeMessage< ::substrait::Expression_SwitchExpression >(GetArenaForAllocation()); } return rex_type_.switch_expression_; } inline ::substrait::Expression_SwitchExpression* Expression::mutable_switch_expression() { + ::substrait::Expression_SwitchExpression* _msg = _internal_mutable_switch_expression(); // @@protoc_insertion_point(field_mutable:substrait.Expression.switch_expression) - return _internal_mutable_switch_expression(); + return _msg; } // .substrait.Expression.SingularOrList singular_or_list = 8; @@ -16277,7 +17226,7 @@ inline void Expression::set_has_singular_or_list() { } inline void Expression::clear_singular_or_list() { if (_internal_has_singular_or_list()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.singular_or_list_; } clear_has_rex_type(); @@ -16288,7 +17237,7 @@ inline ::substrait::Expression_SingularOrList* Expression::release_singular_or_l if (_internal_has_singular_or_list()) { clear_has_rex_type(); ::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rex_type_.singular_or_list_ = nullptr; @@ -16329,13 +17278,14 @@ inline ::substrait::Expression_SingularOrList* Expression::_internal_mutable_sin if (!_internal_has_singular_or_list()) { clear_rex_type(); set_has_singular_or_list(); - rex_type_.singular_or_list_ = CreateMaybeMessage< ::substrait::Expression_SingularOrList >(GetArena()); + rex_type_.singular_or_list_ = CreateMaybeMessage< ::substrait::Expression_SingularOrList >(GetArenaForAllocation()); } return rex_type_.singular_or_list_; } inline ::substrait::Expression_SingularOrList* Expression::mutable_singular_or_list() { + ::substrait::Expression_SingularOrList* _msg = _internal_mutable_singular_or_list(); // @@protoc_insertion_point(field_mutable:substrait.Expression.singular_or_list) - return _internal_mutable_singular_or_list(); + return _msg; } // .substrait.Expression.MultiOrList multi_or_list = 9; @@ -16350,7 +17300,7 @@ inline void Expression::set_has_multi_or_list() { } inline void Expression::clear_multi_or_list() { if (_internal_has_multi_or_list()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.multi_or_list_; } clear_has_rex_type(); @@ -16361,7 +17311,7 @@ inline ::substrait::Expression_MultiOrList* Expression::release_multi_or_list() if (_internal_has_multi_or_list()) { clear_has_rex_type(); ::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rex_type_.multi_or_list_ = nullptr; @@ -16402,13 +17352,14 @@ inline ::substrait::Expression_MultiOrList* Expression::_internal_mutable_multi_ if (!_internal_has_multi_or_list()) { clear_rex_type(); set_has_multi_or_list(); - rex_type_.multi_or_list_ = CreateMaybeMessage< ::substrait::Expression_MultiOrList >(GetArena()); + rex_type_.multi_or_list_ = CreateMaybeMessage< ::substrait::Expression_MultiOrList >(GetArenaForAllocation()); } return rex_type_.multi_or_list_; } inline ::substrait::Expression_MultiOrList* Expression::mutable_multi_or_list() { + ::substrait::Expression_MultiOrList* _msg = _internal_mutable_multi_or_list(); // @@protoc_insertion_point(field_mutable:substrait.Expression.multi_or_list) - return _internal_mutable_multi_or_list(); + return _msg; } // .substrait.Expression.Enum enum = 10; @@ -16423,7 +17374,7 @@ inline void Expression::set_has_enum_() { } inline void Expression::clear_enum_() { if (_internal_has_enum_()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.enum__; } clear_has_rex_type(); @@ -16434,7 +17385,7 @@ inline ::substrait::Expression_Enum* Expression::release_enum_() { if (_internal_has_enum_()) { clear_has_rex_type(); ::substrait::Expression_Enum* temp = rex_type_.enum__; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rex_type_.enum__ = nullptr; @@ -16475,13 +17426,14 @@ inline ::substrait::Expression_Enum* Expression::_internal_mutable_enum_() { if (!_internal_has_enum_()) { clear_rex_type(); set_has_enum_(); - rex_type_.enum__ = CreateMaybeMessage< ::substrait::Expression_Enum >(GetArena()); + rex_type_.enum__ = CreateMaybeMessage< ::substrait::Expression_Enum >(GetArenaForAllocation()); } return rex_type_.enum__; } inline ::substrait::Expression_Enum* Expression::mutable_enum_() { + ::substrait::Expression_Enum* _msg = _internal_mutable_enum_(); // @@protoc_insertion_point(field_mutable:substrait.Expression.enum) - return _internal_mutable_enum_(); + return _msg; } // .substrait.Expression.Cast cast = 11; @@ -16496,7 +17448,7 @@ inline void Expression::set_has_cast() { } inline void Expression::clear_cast() { if (_internal_has_cast()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rex_type_.cast_; } clear_has_rex_type(); @@ -16507,7 +17459,7 @@ inline ::substrait::Expression_Cast* Expression::release_cast() { if (_internal_has_cast()) { clear_has_rex_type(); ::substrait::Expression_Cast* temp = rex_type_.cast_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rex_type_.cast_ = nullptr; @@ -16548,13 +17500,14 @@ inline ::substrait::Expression_Cast* Expression::_internal_mutable_cast() { if (!_internal_has_cast()) { clear_rex_type(); set_has_cast(); - rex_type_.cast_ = CreateMaybeMessage< ::substrait::Expression_Cast >(GetArena()); + rex_type_.cast_ = CreateMaybeMessage< ::substrait::Expression_Cast >(GetArenaForAllocation()); } return rex_type_.cast_; } inline ::substrait::Expression_Cast* Expression::mutable_cast() { + ::substrait::Expression_Cast* _msg = _internal_mutable_cast(); // @@protoc_insertion_point(field_mutable:substrait.Expression.cast) - return _internal_mutable_cast(); + return _msg; } inline bool Expression::has_rex_type() const { @@ -16578,7 +17531,7 @@ inline bool SortField::has_expr() const { return _internal_has_expr(); } inline void SortField::clear_expr() { - if (GetArena() == nullptr && expr_ != nullptr) { + if (GetArenaForAllocation() == nullptr && expr_ != nullptr) { delete expr_; } expr_ = nullptr; @@ -16594,7 +17547,7 @@ inline const ::substrait::Expression& SortField::expr() const { } inline void SortField::unsafe_arena_set_allocated_expr( ::substrait::Expression* expr) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_); } expr_ = expr; @@ -16609,9 +17562,15 @@ inline ::substrait::Expression* SortField::release_expr() { ::substrait::Expression* temp = expr_; expr_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* SortField::unsafe_arena_release_expr() { @@ -16624,23 +17583,24 @@ inline ::substrait::Expression* SortField::unsafe_arena_release_expr() { inline ::substrait::Expression* SortField::_internal_mutable_expr() { if (expr_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); expr_ = p; } return expr_; } inline ::substrait::Expression* SortField::mutable_expr() { + ::substrait::Expression* _msg = _internal_mutable_expr(); // @@protoc_insertion_point(field_mutable:substrait.SortField.expr) - return _internal_mutable_expr(); + return _msg; } inline void SortField::set_allocated_expr(::substrait::Expression* expr) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete expr_; } if (expr) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expr); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(expr); if (message_arena != submessage_arena) { expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expr, submessage_arena); @@ -16687,8 +17647,8 @@ inline void SortField::_internal_set_direction(::substrait::SortField_SortDirect sort_kind_.direction_ = value; } inline void SortField::set_direction(::substrait::SortField_SortDirection value) { - // @@protoc_insertion_point(field_set:substrait.SortField.direction) _internal_set_direction(value); + // @@protoc_insertion_point(field_set:substrait.SortField.direction) } // uint32 comparison_function_reference = 3; @@ -16707,24 +17667,24 @@ inline void SortField::clear_comparison_function_reference() { clear_has_sort_kind(); } } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SortField::_internal_comparison_function_reference() const { +inline uint32_t SortField::_internal_comparison_function_reference() const { if (_internal_has_comparison_function_reference()) { return sort_kind_.comparison_function_reference_; } return 0u; } -inline void SortField::_internal_set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SortField::_internal_set_comparison_function_reference(uint32_t value) { if (!_internal_has_comparison_function_reference()) { clear_sort_kind(); set_has_comparison_function_reference(); } sort_kind_.comparison_function_reference_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SortField::comparison_function_reference() const { +inline uint32_t SortField::comparison_function_reference() const { // @@protoc_insertion_point(field_get:substrait.SortField.comparison_function_reference) return _internal_comparison_function_reference(); } -inline void SortField::set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SortField::set_comparison_function_reference(uint32_t value) { _internal_set_comparison_function_reference(value); // @@protoc_insertion_point(field_set:substrait.SortField.comparison_function_reference) } @@ -16746,18 +17706,18 @@ inline SortField::SortKindCase SortField::sort_kind_case() const { inline void AggregateFunction::clear_function_reference() { function_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 AggregateFunction::_internal_function_reference() const { +inline uint32_t AggregateFunction::_internal_function_reference() const { return function_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 AggregateFunction::function_reference() const { +inline uint32_t AggregateFunction::function_reference() const { // @@protoc_insertion_point(field_get:substrait.AggregateFunction.function_reference) return _internal_function_reference(); } -inline void AggregateFunction::_internal_set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void AggregateFunction::_internal_set_function_reference(uint32_t value) { function_reference_ = value; } -inline void AggregateFunction::set_function_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void AggregateFunction::set_function_reference(uint32_t value) { _internal_set_function_reference(value); // @@protoc_insertion_point(field_set:substrait.AggregateFunction.function_reference) } @@ -16792,8 +17752,9 @@ inline ::substrait::Expression* AggregateFunction::_internal_add_args() { return args_.Add(); } inline ::substrait::Expression* AggregateFunction::add_args() { + ::substrait::Expression* _add = _internal_add_args(); // @@protoc_insertion_point(field_add:substrait.AggregateFunction.args) - return _internal_add_args(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& AggregateFunction::args() const { @@ -16831,8 +17792,9 @@ inline ::substrait::SortField* AggregateFunction::_internal_add_sorts() { return sorts_.Add(); } inline ::substrait::SortField* AggregateFunction::add_sorts() { + ::substrait::SortField* _add = _internal_add_sorts(); // @@protoc_insertion_point(field_add:substrait.AggregateFunction.sorts) - return _internal_add_sorts(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& AggregateFunction::sorts() const { @@ -16878,7 +17840,7 @@ inline const ::substrait::Type& AggregateFunction::output_type() const { } inline void AggregateFunction::unsafe_arena_set_allocated_output_type( ::substrait::Type* output_type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } output_type_ = output_type; @@ -16893,9 +17855,15 @@ inline ::substrait::Type* AggregateFunction::release_output_type() { ::substrait::Type* temp = output_type_; output_type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Type* AggregateFunction::unsafe_arena_release_output_type() { @@ -16908,23 +17876,26 @@ inline ::substrait::Type* AggregateFunction::unsafe_arena_release_output_type() inline ::substrait::Type* AggregateFunction::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); output_type_ = p; } return output_type_; } inline ::substrait::Type* AggregateFunction::mutable_output_type() { + ::substrait::Type* _msg = _internal_mutable_output_type(); // @@protoc_insertion_point(field_mutable:substrait.AggregateFunction.output_type) - return _internal_mutable_output_type(); + return _msg; } inline void AggregateFunction::set_allocated_output_type(::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } if (output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); if (message_arena != submessage_arena) { output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, output_type, submessage_arena); diff --git a/cpp/src/generated/substrait/extensions/extensions.pb.cc b/cpp/src/generated/substrait/extensions/extensions.pb.cc index 395295144e7..564fb8fb347 100644 --- a/cpp/src/generated/substrait/extensions/extensions.pb.cc +++ b/cpp/src/generated/substrait/extensions/extensions.pb.cc @@ -104,12 +104,13 @@ static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fextensi static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fextensions_2fextensions_2eproto = nullptr; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fextensions_2fextensions_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fextensions_2fextensions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const uint32_t TableStruct_substrait_2fextensions_2fextensions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, extension_uri_anchor_), PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, uri_), ~0u, // no _has_bits_ @@ -117,6 +118,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fextensions_2fexten ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_), PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, type_anchor_), PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, name_), @@ -125,6 +127,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fextensions_2fexten ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_reference_), PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_), PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, name_), @@ -133,6 +136,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fextensions_2fexten ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, extension_uri_reference_), PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, function_anchor_), PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, name_), @@ -141,6 +145,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fextensions_2fexten ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -150,16 +155,17 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fextensions_2fexten ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, optimization_), PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, enhancement_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::substrait::extensions::SimpleExtensionURI)}, - { 7, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType)}, - { 15, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation)}, - { 23, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction)}, - { 31, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration)}, - { 40, -1, sizeof(::substrait::extensions::AdvancedExtension)}, + { 0, -1, -1, sizeof(::substrait::extensions::SimpleExtensionURI)}, + { 8, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType)}, + { 17, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation)}, + { 26, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction)}, + { 35, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration)}, + { 45, -1, -1, sizeof(::substrait::extensions::AdvancedExtension)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -222,37 +228,47 @@ class SimpleExtensionURI::_Internal { public: }; -SimpleExtensionURI::SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +SimpleExtensionURI::SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionURI) } SimpleExtensionURI::SimpleExtensionURI(const SimpleExtensionURI& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_uri().empty()) { uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), - GetArena()); + GetArenaForAllocation()); } extension_uri_anchor_ = from.extension_uri_anchor_; // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionURI) } -void SimpleExtensionURI::SharedCtor() { +inline void SimpleExtensionURI::SharedCtor() { uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING extension_uri_anchor_ = 0u; } SimpleExtensionURI::~SimpleExtensionURI() { // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionURI) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void SimpleExtensionURI::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void SimpleExtensionURI::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -268,7 +284,7 @@ void SimpleExtensionURI::SetCachedSize(int size) const { void SimpleExtensionURI::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionURI) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -280,62 +296,64 @@ void SimpleExtensionURI::Clear() { const char* SimpleExtensionURI::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 extension_uri_anchor = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { extension_uri_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string uri = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { auto str = _internal_mutable_uri(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionURI.uri")); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionURI::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* SimpleExtensionURI::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionURI) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 extension_uri_anchor = 1; - if (this->extension_uri_anchor() != 0) { + if (this->_internal_extension_uri_anchor() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_anchor(), target); } // string uri = 2; - if (this->uri().size() > 0) { + if (!this->_internal_uri().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_uri().data(), static_cast(this->_internal_uri().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -356,68 +374,51 @@ size_t SimpleExtensionURI::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionURI) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string uri = 2; - if (this->uri().size() > 0) { + if (!this->_internal_uri().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_uri()); } // uint32 extension_uri_anchor = 1; - if (this->extension_uri_anchor() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_extension_uri_anchor()); + if (this->_internal_extension_uri_anchor() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_anchor()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void SimpleExtensionURI::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.SimpleExtensionURI) - GOOGLE_DCHECK_NE(&from, this); - const SimpleExtensionURI* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.SimpleExtensionURI) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.SimpleExtensionURI) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionURI::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SimpleExtensionURI::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionURI::GetClassData() const { return &_class_data_; } + +void SimpleExtensionURI::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void SimpleExtensionURI::MergeFrom(const SimpleExtensionURI& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionURI) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.uri().size() > 0) { + if (!from._internal_uri().empty()) { _internal_set_uri(from._internal_uri()); } - if (from.extension_uri_anchor() != 0) { + if (from._internal_extension_uri_anchor() != 0) { _internal_set_extension_uri_anchor(from._internal_extension_uri_anchor()); } -} - -void SimpleExtensionURI::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.SimpleExtensionURI) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SimpleExtensionURI::CopyFrom(const SimpleExtensionURI& from) { @@ -433,8 +434,14 @@ bool SimpleExtensionURI::IsInitialized() const { void SimpleExtensionURI::InternalSwap(SimpleExtensionURI* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - uri_.Swap(&other->uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &uri_, lhs_arena, + &other->uri_, rhs_arena + ); swap(extension_uri_anchor_, other->extension_uri_anchor_); } @@ -450,19 +457,25 @@ class SimpleExtensionDeclaration_ExtensionType::_Internal { public: }; -SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) } SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_name().empty()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); + GetArenaForAllocation()); } ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, static_cast(reinterpret_cast(&type_anchor_) - @@ -470,8 +483,11 @@ SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionTy // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) } -void SimpleExtensionDeclaration_ExtensionType::SharedCtor() { +inline void SimpleExtensionDeclaration_ExtensionType::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&type_anchor_) - @@ -480,12 +496,13 @@ ::memset(reinterpret_cast(this) + static_cast( SimpleExtensionDeclaration_ExtensionType::~SimpleExtensionDeclaration_ExtensionType() { // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void SimpleExtensionDeclaration_ExtensionType::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void SimpleExtensionDeclaration_ExtensionType::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -501,7 +518,7 @@ void SimpleExtensionDeclaration_ExtensionType::SetCachedSize(int size) const { void SimpleExtensionDeclaration_ExtensionType::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -515,75 +532,78 @@ void SimpleExtensionDeclaration_ExtensionType::Clear() { const char* SimpleExtensionDeclaration_ExtensionType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 extension_uri_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 type_anchor = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { type_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string name = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name")); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionType::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* SimpleExtensionDeclaration_ExtensionType::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 extension_uri_reference = 1; - if (this->extension_uri_reference() != 0) { + if (this->_internal_extension_uri_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); } // uint32 type_anchor = 2; - if (this->type_anchor() != 0) { + if (this->_internal_type_anchor() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_anchor(), target); } // string name = 3; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -604,78 +624,59 @@ size_t SimpleExtensionDeclaration_ExtensionType::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string name = 3; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // uint32 extension_uri_reference = 1; - if (this->extension_uri_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_extension_uri_reference()); + if (this->_internal_extension_uri_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_reference()); } // uint32 type_anchor = 2; - if (this->type_anchor() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_anchor()); + if (this->_internal_type_anchor() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_anchor()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void SimpleExtensionDeclaration_ExtensionType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - GOOGLE_DCHECK_NE(&from, this); - const SimpleExtensionDeclaration_ExtensionType* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration_ExtensionType::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SimpleExtensionDeclaration_ExtensionType::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration_ExtensionType::GetClassData() const { return &_class_data_; } + +void SimpleExtensionDeclaration_ExtensionType::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void SimpleExtensionDeclaration_ExtensionType::MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.name().size() > 0) { + if (!from._internal_name().empty()) { _internal_set_name(from._internal_name()); } - if (from.extension_uri_reference() != 0) { + if (from._internal_extension_uri_reference() != 0) { _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); } - if (from.type_anchor() != 0) { + if (from._internal_type_anchor() != 0) { _internal_set_type_anchor(from._internal_type_anchor()); } -} - -void SimpleExtensionDeclaration_ExtensionType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SimpleExtensionDeclaration_ExtensionType::CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from) { @@ -691,8 +692,14 @@ bool SimpleExtensionDeclaration_ExtensionType::IsInitialized() const { void SimpleExtensionDeclaration_ExtensionType::InternalSwap(SimpleExtensionDeclaration_ExtensionType* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, type_anchor_) + sizeof(SimpleExtensionDeclaration_ExtensionType::type_anchor_) @@ -713,19 +720,25 @@ class SimpleExtensionDeclaration_ExtensionTypeVariation::_Internal { public: }; -SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) } SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_name().empty()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); + GetArenaForAllocation()); } ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, static_cast(reinterpret_cast(&type_variation_anchor_) - @@ -733,8 +746,11 @@ SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_Ex // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) } -void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedCtor() { +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&type_variation_anchor_) - @@ -743,12 +759,13 @@ ::memset(reinterpret_cast(this) + static_cast( SimpleExtensionDeclaration_ExtensionTypeVariation::~SimpleExtensionDeclaration_ExtensionTypeVariation() { // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -764,7 +781,7 @@ void SimpleExtensionDeclaration_ExtensionTypeVariation::SetCachedSize(int size) void SimpleExtensionDeclaration_ExtensionTypeVariation::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -778,75 +795,78 @@ void SimpleExtensionDeclaration_ExtensionTypeVariation::Clear() { const char* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 extension_uri_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 type_variation_anchor = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { type_variation_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string name = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name")); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 extension_uri_reference = 1; - if (this->extension_uri_reference() != 0) { + if (this->_internal_extension_uri_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); } // uint32 type_variation_anchor = 2; - if (this->type_variation_anchor() != 0) { + if (this->_internal_type_variation_anchor() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_anchor(), target); } // string name = 3; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -867,78 +887,59 @@ size_t SimpleExtensionDeclaration_ExtensionTypeVariation::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string name = 3; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // uint32 extension_uri_reference = 1; - if (this->extension_uri_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_extension_uri_reference()); + if (this->_internal_extension_uri_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_reference()); } // uint32 type_variation_anchor = 2; - if (this->type_variation_anchor() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_anchor()); + if (this->_internal_type_variation_anchor() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_anchor()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - GOOGLE_DCHECK_NE(&from, this); - const SimpleExtensionDeclaration_ExtensionTypeVariation* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration_ExtensionTypeVariation::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SimpleExtensionDeclaration_ExtensionTypeVariation::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration_ExtensionTypeVariation::GetClassData() const { return &_class_data_; } + +void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.name().size() > 0) { + if (!from._internal_name().empty()) { _internal_set_name(from._internal_name()); } - if (from.extension_uri_reference() != 0) { + if (from._internal_extension_uri_reference() != 0) { _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); } - if (from.type_variation_anchor() != 0) { + if (from._internal_type_variation_anchor() != 0) { _internal_set_type_variation_anchor(from._internal_type_variation_anchor()); } -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SimpleExtensionDeclaration_ExtensionTypeVariation::CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { @@ -954,8 +955,14 @@ bool SimpleExtensionDeclaration_ExtensionTypeVariation::IsInitialized() const { void SimpleExtensionDeclaration_ExtensionTypeVariation::InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_) + sizeof(SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor_) @@ -976,19 +983,25 @@ class SimpleExtensionDeclaration_ExtensionFunction::_Internal { public: }; -SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) } SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_name().empty()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); + GetArenaForAllocation()); } ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, static_cast(reinterpret_cast(&function_anchor_) - @@ -996,8 +1009,11 @@ SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_Extensi // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) } -void SimpleExtensionDeclaration_ExtensionFunction::SharedCtor() { +inline void SimpleExtensionDeclaration_ExtensionFunction::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&function_anchor_) - @@ -1006,12 +1022,13 @@ ::memset(reinterpret_cast(this) + static_cast( SimpleExtensionDeclaration_ExtensionFunction::~SimpleExtensionDeclaration_ExtensionFunction() { // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void SimpleExtensionDeclaration_ExtensionFunction::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void SimpleExtensionDeclaration_ExtensionFunction::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -1027,7 +1044,7 @@ void SimpleExtensionDeclaration_ExtensionFunction::SetCachedSize(int size) const void SimpleExtensionDeclaration_ExtensionFunction::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1041,75 +1058,78 @@ void SimpleExtensionDeclaration_ExtensionFunction::Clear() { const char* SimpleExtensionDeclaration_ExtensionFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 extension_uri_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 function_anchor = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { function_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string name = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration_ExtensionFunction::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* SimpleExtensionDeclaration_ExtensionFunction::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 extension_uri_reference = 1; - if (this->extension_uri_reference() != 0) { + if (this->_internal_extension_uri_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); } // uint32 function_anchor = 2; - if (this->function_anchor() != 0) { + if (this->_internal_function_anchor() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_function_anchor(), target); } // string name = 3; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -1130,78 +1150,59 @@ size_t SimpleExtensionDeclaration_ExtensionFunction::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string name = 3; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // uint32 extension_uri_reference = 1; - if (this->extension_uri_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_extension_uri_reference()); + if (this->_internal_extension_uri_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_reference()); } // uint32 function_anchor = 2; - if (this->function_anchor() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_function_anchor()); + if (this->_internal_function_anchor() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_anchor()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - GOOGLE_DCHECK_NE(&from, this); - const SimpleExtensionDeclaration_ExtensionFunction* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration_ExtensionFunction::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SimpleExtensionDeclaration_ExtensionFunction::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration_ExtensionFunction::GetClassData() const { return &_class_data_; } + +void SimpleExtensionDeclaration_ExtensionFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.name().size() > 0) { + if (!from._internal_name().empty()) { _internal_set_name(from._internal_name()); } - if (from.extension_uri_reference() != 0) { + if (from._internal_extension_uri_reference() != 0) { _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); } - if (from.function_anchor() != 0) { + if (from._internal_function_anchor() != 0) { _internal_set_function_anchor(from._internal_function_anchor()); } -} - -void SimpleExtensionDeclaration_ExtensionFunction::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SimpleExtensionDeclaration_ExtensionFunction::CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) { @@ -1217,8 +1218,14 @@ bool SimpleExtensionDeclaration_ExtensionFunction::IsInitialized() const { void SimpleExtensionDeclaration_ExtensionFunction::InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, function_anchor_) + sizeof(SimpleExtensionDeclaration_ExtensionFunction::function_anchor_) @@ -1255,11 +1262,11 @@ SimpleExtensionDeclaration::_Internal::extension_function(const SimpleExtensionD return *msg->mapping_type_.extension_function_; } void SimpleExtensionDeclaration::set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_mapping_type(); if (extension_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_type); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::extensions::SimpleExtensionDeclaration_ExtensionType>::GetOwningArena(extension_type); if (message_arena != submessage_arena) { extension_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, extension_type, submessage_arena); @@ -1270,11 +1277,11 @@ void SimpleExtensionDeclaration::set_allocated_extension_type(::substrait::exten // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type) } void SimpleExtensionDeclaration::set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_mapping_type(); if (extension_type_variation) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_type_variation); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation>::GetOwningArena(extension_type_variation); if (message_arena != submessage_arena) { extension_type_variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, extension_type_variation, submessage_arena); @@ -1285,11 +1292,11 @@ void SimpleExtensionDeclaration::set_allocated_extension_type_variation(::substr // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) } void SimpleExtensionDeclaration::set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_mapping_type(); if (extension_function) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_function); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction>::GetOwningArena(extension_function); if (message_arena != submessage_arena) { extension_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, extension_function, submessage_arena); @@ -1299,10 +1306,13 @@ void SimpleExtensionDeclaration::set_allocated_extension_function(::substrait::e } // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_function) } -SimpleExtensionDeclaration::SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +SimpleExtensionDeclaration::SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration) } SimpleExtensionDeclaration::SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from) @@ -1329,18 +1339,19 @@ SimpleExtensionDeclaration::SimpleExtensionDeclaration(const SimpleExtensionDecl // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration) } -void SimpleExtensionDeclaration::SharedCtor() { +inline void SimpleExtensionDeclaration::SharedCtor() { clear_has_mapping_type(); } SimpleExtensionDeclaration::~SimpleExtensionDeclaration() { // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void SimpleExtensionDeclaration::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void SimpleExtensionDeclaration::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_mapping_type()) { clear_mapping_type(); } @@ -1360,19 +1371,19 @@ void SimpleExtensionDeclaration::clear_mapping_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.extensions.SimpleExtensionDeclaration) switch (mapping_type_case()) { case kExtensionType: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete mapping_type_.extension_type_; } break; } case kExtensionTypeVariation: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete mapping_type_.extension_type_variation_; } break; } case kExtensionFunction: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete mapping_type_.extension_function_; } break; @@ -1387,7 +1398,7 @@ void SimpleExtensionDeclaration::clear_mapping_type() { void SimpleExtensionDeclaration::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1398,57 +1409,60 @@ void SimpleExtensionDeclaration::Clear() { const char* SimpleExtensionDeclaration::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_extension_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_extension_type_variation(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_extension_function(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* SimpleExtensionDeclaration::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* SimpleExtensionDeclaration::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; @@ -1487,7 +1501,7 @@ size_t SimpleExtensionDeclaration::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1517,35 +1531,26 @@ size_t SimpleExtensionDeclaration::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void SimpleExtensionDeclaration::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.SimpleExtensionDeclaration) - GOOGLE_DCHECK_NE(&from, this); - const SimpleExtensionDeclaration* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.SimpleExtensionDeclaration) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.SimpleExtensionDeclaration) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SimpleExtensionDeclaration::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration::GetClassData() const { return &_class_data_; } + +void SimpleExtensionDeclaration::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void SimpleExtensionDeclaration::MergeFrom(const SimpleExtensionDeclaration& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.mapping_type_case()) { @@ -1565,13 +1570,7 @@ void SimpleExtensionDeclaration::MergeFrom(const SimpleExtensionDeclaration& fro break; } } -} - -void SimpleExtensionDeclaration::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.SimpleExtensionDeclaration) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SimpleExtensionDeclaration::CopyFrom(const SimpleExtensionDeclaration& from) { @@ -1587,7 +1586,7 @@ bool SimpleExtensionDeclaration::IsInitialized() const { void SimpleExtensionDeclaration::InternalSwap(SimpleExtensionDeclaration* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(mapping_type_, other->mapping_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -1602,53 +1601,56 @@ ::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration::GetMetadata() cons class AdvancedExtension::_Internal { public: - static const PROTOBUF_NAMESPACE_ID::Any& optimization(const AdvancedExtension* msg); - static const PROTOBUF_NAMESPACE_ID::Any& enhancement(const AdvancedExtension* msg); + static const ::PROTOBUF_NAMESPACE_ID::Any& optimization(const AdvancedExtension* msg); + static const ::PROTOBUF_NAMESPACE_ID::Any& enhancement(const AdvancedExtension* msg); }; -const PROTOBUF_NAMESPACE_ID::Any& +const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_Internal::optimization(const AdvancedExtension* msg) { return *msg->optimization_; } -const PROTOBUF_NAMESPACE_ID::Any& +const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_Internal::enhancement(const AdvancedExtension* msg) { return *msg->enhancement_; } void AdvancedExtension::clear_optimization() { - if (GetArena() == nullptr && optimization_ != nullptr) { + if (GetArenaForAllocation() == nullptr && optimization_ != nullptr) { delete optimization_; } optimization_ = nullptr; } void AdvancedExtension::clear_enhancement() { - if (GetArena() == nullptr && enhancement_ != nullptr) { + if (GetArenaForAllocation() == nullptr && enhancement_ != nullptr) { delete enhancement_; } enhancement_ = nullptr; } -AdvancedExtension::AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +AdvancedExtension::AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.extensions.AdvancedExtension) } AdvancedExtension::AdvancedExtension(const AdvancedExtension& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_optimization()) { - optimization_ = new PROTOBUF_NAMESPACE_ID::Any(*from.optimization_); + optimization_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.optimization_); } else { optimization_ = nullptr; } if (from._internal_has_enhancement()) { - enhancement_ = new PROTOBUF_NAMESPACE_ID::Any(*from.enhancement_); + enhancement_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.enhancement_); } else { enhancement_ = nullptr; } // @@protoc_insertion_point(copy_constructor:substrait.extensions.AdvancedExtension) } -void AdvancedExtension::SharedCtor() { +inline void AdvancedExtension::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&optimization_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&enhancement_) - @@ -1657,12 +1659,13 @@ ::memset(reinterpret_cast(this) + static_cast( AdvancedExtension::~AdvancedExtension() { // @@protoc_insertion_point(destructor:substrait.extensions.AdvancedExtension) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void AdvancedExtension::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void AdvancedExtension::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete optimization_; if (this != internal_default_instance()) delete enhancement_; } @@ -1679,15 +1682,15 @@ void AdvancedExtension::SetCachedSize(int size) const { void AdvancedExtension::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.extensions.AdvancedExtension) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && optimization_ != nullptr) { + if (GetArenaForAllocation() == nullptr && optimization_ != nullptr) { delete optimization_; } optimization_ = nullptr; - if (GetArena() == nullptr && enhancement_ != nullptr) { + if (GetArenaForAllocation() == nullptr && enhancement_ != nullptr) { delete enhancement_; } enhancement_ = nullptr; @@ -1697,54 +1700,56 @@ void AdvancedExtension::Clear() { const char* AdvancedExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .google.protobuf.Any optimization = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_optimization(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .google.protobuf.Any enhancement = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_enhancement(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* AdvancedExtension::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* AdvancedExtension::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.AdvancedExtension) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .google.protobuf.Any optimization = 1; - if (this->has_optimization()) { + if (this->_internal_has_optimization()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1752,7 +1757,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AdvancedExtension::_InternalSerialize( } // .google.protobuf.Any enhancement = 2; - if (this->has_enhancement()) { + if (this->_internal_has_enhancement()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1771,68 +1776,53 @@ size_t AdvancedExtension::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.extensions.AdvancedExtension) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .google.protobuf.Any optimization = 1; - if (this->has_optimization()) { + if (this->_internal_has_optimization()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *optimization_); } // .google.protobuf.Any enhancement = 2; - if (this->has_enhancement()) { + if (this->_internal_has_enhancement()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *enhancement_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void AdvancedExtension::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.extensions.AdvancedExtension) - GOOGLE_DCHECK_NE(&from, this); - const AdvancedExtension* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.extensions.AdvancedExtension) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.extensions.AdvancedExtension) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AdvancedExtension::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + AdvancedExtension::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AdvancedExtension::GetClassData() const { return &_class_data_; } + +void AdvancedExtension::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void AdvancedExtension::MergeFrom(const AdvancedExtension& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.AdvancedExtension) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_optimization()) { - _internal_mutable_optimization()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_optimization()); + if (from._internal_has_optimization()) { + _internal_mutable_optimization()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_optimization()); } - if (from.has_enhancement()) { - _internal_mutable_enhancement()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_enhancement()); + if (from._internal_has_enhancement()) { + _internal_mutable_enhancement()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_enhancement()); } -} - -void AdvancedExtension::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.extensions.AdvancedExtension) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void AdvancedExtension::CopyFrom(const AdvancedExtension& from) { @@ -1848,7 +1838,7 @@ bool AdvancedExtension::IsInitialized() const { void AdvancedExtension::InternalSwap(AdvancedExtension* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(AdvancedExtension, enhancement_) + sizeof(AdvancedExtension::enhancement_) diff --git a/cpp/src/generated/substrait/extensions/extensions.pb.h b/cpp/src/generated/substrait/extensions/extensions.pb.h index 45b2a664723..ee6e5499e61 100644 --- a/cpp/src/generated/substrait/extensions/extensions.pb.h +++ b/cpp/src/generated/substrait/extensions/extensions.pb.h @@ -8,12 +8,12 @@ #include #include -#if PROTOBUF_VERSION < 3016000 +#if PROTOBUF_VERSION < 3019000 #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 3016000 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019003 < 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. @@ -51,7 +51,7 @@ struct TableStruct_substrait_2fextensions_2fextensions_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; + static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fextensions_2fextensions_2eproto; namespace substrait { @@ -89,7 +89,7 @@ namespace extensions { // =================================================================== -class SimpleExtensionURI PROTOBUF_FINAL : +class SimpleExtensionURI final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionURI) */ { public: inline SimpleExtensionURI() : SimpleExtensionURI(nullptr) {} @@ -107,8 +107,13 @@ class SimpleExtensionURI PROTOBUF_FINAL : return *this; } inline SimpleExtensionURI& operator=(SimpleExtensionURI&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -139,7 +144,12 @@ class SimpleExtensionURI PROTOBUF_FINAL : } inline void Swap(SimpleExtensionURI* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -147,48 +157,53 @@ class SimpleExtensionURI PROTOBUF_FINAL : } void UnsafeArenaSwap(SimpleExtensionURI* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline SimpleExtensionURI* New() const final { - return CreateMaybeMessage(nullptr); - } - - SimpleExtensionURI* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + SimpleExtensionURI* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SimpleExtensionURI& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const SimpleExtensionURI& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SimpleExtensionURI* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.extensions.SimpleExtensionURI"; } protected: - explicit SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -205,21 +220,21 @@ class SimpleExtensionURI PROTOBUF_FINAL : template void set_uri(ArgT0&& arg0, ArgT... args); std::string* mutable_uri(); - std::string* release_uri(); + PROTOBUF_NODISCARD std::string* release_uri(); void set_allocated_uri(std::string* uri); private: const std::string& _internal_uri() const; - void _internal_set_uri(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value); std::string* _internal_mutable_uri(); public: // uint32 extension_uri_anchor = 1; void clear_extension_uri_anchor(); - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_anchor() const; - void set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t extension_uri_anchor() const; + void set_extension_uri_anchor(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_anchor() const; - void _internal_set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_extension_uri_anchor() const; + void _internal_set_extension_uri_anchor(uint32_t value); public: // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionURI) @@ -230,13 +245,13 @@ class SimpleExtensionURI PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_anchor_; + uint32_t extension_uri_anchor_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; }; // ------------------------------------------------------------------- -class SimpleExtensionDeclaration_ExtensionType PROTOBUF_FINAL : +class SimpleExtensionDeclaration_ExtensionType final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) */ { public: inline SimpleExtensionDeclaration_ExtensionType() : SimpleExtensionDeclaration_ExtensionType(nullptr) {} @@ -254,8 +269,13 @@ class SimpleExtensionDeclaration_ExtensionType PROTOBUF_FINAL : return *this; } inline SimpleExtensionDeclaration_ExtensionType& operator=(SimpleExtensionDeclaration_ExtensionType&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -286,7 +306,12 @@ class SimpleExtensionDeclaration_ExtensionType PROTOBUF_FINAL : } inline void Swap(SimpleExtensionDeclaration_ExtensionType* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -294,48 +319,53 @@ class SimpleExtensionDeclaration_ExtensionType PROTOBUF_FINAL : } void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionType* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline SimpleExtensionDeclaration_ExtensionType* New() const final { - return CreateMaybeMessage(nullptr); - } - - SimpleExtensionDeclaration_ExtensionType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + SimpleExtensionDeclaration_ExtensionType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SimpleExtensionDeclaration_ExtensionType* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.extensions.SimpleExtensionDeclaration.ExtensionType"; } protected: - explicit SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -353,30 +383,30 @@ class SimpleExtensionDeclaration_ExtensionType PROTOBUF_FINAL : template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); - std::string* release_name(); + PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // uint32 extension_uri_reference = 1; void clear_extension_uri_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference() const; - void set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t extension_uri_reference() const; + void set_extension_uri_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_reference() const; - void _internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_extension_uri_reference() const; + void _internal_set_extension_uri_reference(uint32_t value); public: // uint32 type_anchor = 2; void clear_type_anchor(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_anchor() const; - void set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_anchor() const; + void set_type_anchor(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_anchor() const; - void _internal_set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_anchor() const; + void _internal_set_type_anchor(uint32_t value); public: // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) @@ -387,14 +417,14 @@ class SimpleExtensionDeclaration_ExtensionType PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_anchor_; + uint32_t extension_uri_reference_; + uint32_t type_anchor_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; }; // ------------------------------------------------------------------- -class SimpleExtensionDeclaration_ExtensionTypeVariation PROTOBUF_FINAL : +class SimpleExtensionDeclaration_ExtensionTypeVariation final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) */ { public: inline SimpleExtensionDeclaration_ExtensionTypeVariation() : SimpleExtensionDeclaration_ExtensionTypeVariation(nullptr) {} @@ -412,8 +442,13 @@ class SimpleExtensionDeclaration_ExtensionTypeVariation PROTOBUF_FINAL : return *this; } inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(SimpleExtensionDeclaration_ExtensionTypeVariation&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -444,7 +479,12 @@ class SimpleExtensionDeclaration_ExtensionTypeVariation PROTOBUF_FINAL : } inline void Swap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -452,48 +492,53 @@ class SimpleExtensionDeclaration_ExtensionTypeVariation PROTOBUF_FINAL : } void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline SimpleExtensionDeclaration_ExtensionTypeVariation* New() const final { - return CreateMaybeMessage(nullptr); - } - - SimpleExtensionDeclaration_ExtensionTypeVariation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + SimpleExtensionDeclaration_ExtensionTypeVariation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation"; } protected: - explicit SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -511,30 +556,30 @@ class SimpleExtensionDeclaration_ExtensionTypeVariation PROTOBUF_FINAL : template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); - std::string* release_name(); + PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // uint32 extension_uri_reference = 1; void clear_extension_uri_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference() const; - void set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t extension_uri_reference() const; + void set_extension_uri_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_reference() const; - void _internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_extension_uri_reference() const; + void _internal_set_extension_uri_reference(uint32_t value); public: // uint32 type_variation_anchor = 2; void clear_type_variation_anchor(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_anchor() const; - void set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_anchor() const; + void set_type_variation_anchor(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_anchor() const; - void _internal_set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_anchor() const; + void _internal_set_type_variation_anchor(uint32_t value); public: // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) @@ -545,14 +590,14 @@ class SimpleExtensionDeclaration_ExtensionTypeVariation PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_anchor_; + uint32_t extension_uri_reference_; + uint32_t type_variation_anchor_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; }; // ------------------------------------------------------------------- -class SimpleExtensionDeclaration_ExtensionFunction PROTOBUF_FINAL : +class SimpleExtensionDeclaration_ExtensionFunction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) */ { public: inline SimpleExtensionDeclaration_ExtensionFunction() : SimpleExtensionDeclaration_ExtensionFunction(nullptr) {} @@ -570,8 +615,13 @@ class SimpleExtensionDeclaration_ExtensionFunction PROTOBUF_FINAL : return *this; } inline SimpleExtensionDeclaration_ExtensionFunction& operator=(SimpleExtensionDeclaration_ExtensionFunction&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -602,7 +652,12 @@ class SimpleExtensionDeclaration_ExtensionFunction PROTOBUF_FINAL : } inline void Swap(SimpleExtensionDeclaration_ExtensionFunction* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -610,48 +665,53 @@ class SimpleExtensionDeclaration_ExtensionFunction PROTOBUF_FINAL : } void UnsafeArenaSwap(SimpleExtensionDeclaration_ExtensionFunction* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline SimpleExtensionDeclaration_ExtensionFunction* New() const final { - return CreateMaybeMessage(nullptr); - } - - SimpleExtensionDeclaration_ExtensionFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + SimpleExtensionDeclaration_ExtensionFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction"; } protected: - explicit SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -669,30 +729,30 @@ class SimpleExtensionDeclaration_ExtensionFunction PROTOBUF_FINAL : template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); - std::string* release_name(); + PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: // uint32 extension_uri_reference = 1; void clear_extension_uri_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference() const; - void set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t extension_uri_reference() const; + void set_extension_uri_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_extension_uri_reference() const; - void _internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_extension_uri_reference() const; + void _internal_set_extension_uri_reference(uint32_t value); public: // uint32 function_anchor = 2; void clear_function_anchor(); - ::PROTOBUF_NAMESPACE_ID::uint32 function_anchor() const; - void set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t function_anchor() const; + void set_function_anchor(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_function_anchor() const; - void _internal_set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_function_anchor() const; + void _internal_set_function_anchor(uint32_t value); public: // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) @@ -703,14 +763,14 @@ class SimpleExtensionDeclaration_ExtensionFunction PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::PROTOBUF_NAMESPACE_ID::uint32 extension_uri_reference_; - ::PROTOBUF_NAMESPACE_ID::uint32 function_anchor_; + uint32_t extension_uri_reference_; + uint32_t function_anchor_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; }; // ------------------------------------------------------------------- -class SimpleExtensionDeclaration PROTOBUF_FINAL : +class SimpleExtensionDeclaration final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration) */ { public: inline SimpleExtensionDeclaration() : SimpleExtensionDeclaration(nullptr) {} @@ -728,8 +788,13 @@ class SimpleExtensionDeclaration PROTOBUF_FINAL : return *this; } inline SimpleExtensionDeclaration& operator=(SimpleExtensionDeclaration&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -767,7 +832,12 @@ class SimpleExtensionDeclaration PROTOBUF_FINAL : } inline void Swap(SimpleExtensionDeclaration* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -775,48 +845,53 @@ class SimpleExtensionDeclaration PROTOBUF_FINAL : } void UnsafeArenaSwap(SimpleExtensionDeclaration* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline SimpleExtensionDeclaration* New() const final { - return CreateMaybeMessage(nullptr); - } - - SimpleExtensionDeclaration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + SimpleExtensionDeclaration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SimpleExtensionDeclaration& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const SimpleExtensionDeclaration& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SimpleExtensionDeclaration* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.extensions.SimpleExtensionDeclaration"; } protected: - explicit SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -839,7 +914,7 @@ class SimpleExtensionDeclaration PROTOBUF_FINAL : public: void clear_extension_type(); const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type() const; - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* release_extension_type(); + PROTOBUF_NODISCARD ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* release_extension_type(); ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* mutable_extension_type(); void set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type); private: @@ -857,7 +932,7 @@ class SimpleExtensionDeclaration PROTOBUF_FINAL : public: void clear_extension_type_variation(); const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation() const; - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* release_extension_type_variation(); + PROTOBUF_NODISCARD ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* release_extension_type_variation(); ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* mutable_extension_type_variation(); void set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation); private: @@ -875,7 +950,7 @@ class SimpleExtensionDeclaration PROTOBUF_FINAL : public: void clear_extension_function(); const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function() const; - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* release_extension_function(); + PROTOBUF_NODISCARD ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* release_extension_function(); ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* mutable_extension_function(); void set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function); private: @@ -909,13 +984,13 @@ class SimpleExtensionDeclaration PROTOBUF_FINAL : ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function_; } mapping_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; }; // ------------------------------------------------------------------- -class AdvancedExtension PROTOBUF_FINAL : +class AdvancedExtension final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.AdvancedExtension) */ { public: inline AdvancedExtension() : AdvancedExtension(nullptr) {} @@ -933,8 +1008,13 @@ class AdvancedExtension PROTOBUF_FINAL : return *this; } inline AdvancedExtension& operator=(AdvancedExtension&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -965,7 +1045,12 @@ class AdvancedExtension PROTOBUF_FINAL : } inline void Swap(AdvancedExtension* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -973,48 +1058,53 @@ class AdvancedExtension PROTOBUF_FINAL : } void UnsafeArenaSwap(AdvancedExtension* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline AdvancedExtension* New() const final { - return CreateMaybeMessage(nullptr); - } - - AdvancedExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + AdvancedExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AdvancedExtension& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const AdvancedExtension& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AdvancedExtension* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.extensions.AdvancedExtension"; } protected: - explicit AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1031,17 +1121,17 @@ class AdvancedExtension PROTOBUF_FINAL : bool _internal_has_optimization() const; public: void clear_optimization(); - const PROTOBUF_NAMESPACE_ID::Any& optimization() const; - PROTOBUF_NAMESPACE_ID::Any* release_optimization(); - PROTOBUF_NAMESPACE_ID::Any* mutable_optimization(); - void set_allocated_optimization(PROTOBUF_NAMESPACE_ID::Any* optimization); + const ::PROTOBUF_NAMESPACE_ID::Any& optimization() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_optimization(); + ::PROTOBUF_NAMESPACE_ID::Any* mutable_optimization(); + void set_allocated_optimization(::PROTOBUF_NAMESPACE_ID::Any* optimization); private: - const PROTOBUF_NAMESPACE_ID::Any& _internal_optimization() const; - PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_optimization(); + const ::PROTOBUF_NAMESPACE_ID::Any& _internal_optimization() const; + ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_optimization(); public: void unsafe_arena_set_allocated_optimization( - PROTOBUF_NAMESPACE_ID::Any* optimization); - PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_optimization(); + ::PROTOBUF_NAMESPACE_ID::Any* optimization); + ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_optimization(); // .google.protobuf.Any enhancement = 2; bool has_enhancement() const; @@ -1049,17 +1139,17 @@ class AdvancedExtension PROTOBUF_FINAL : bool _internal_has_enhancement() const; public: void clear_enhancement(); - const PROTOBUF_NAMESPACE_ID::Any& enhancement() const; - PROTOBUF_NAMESPACE_ID::Any* release_enhancement(); - PROTOBUF_NAMESPACE_ID::Any* mutable_enhancement(); - void set_allocated_enhancement(PROTOBUF_NAMESPACE_ID::Any* enhancement); + const ::PROTOBUF_NAMESPACE_ID::Any& enhancement() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_enhancement(); + ::PROTOBUF_NAMESPACE_ID::Any* mutable_enhancement(); + void set_allocated_enhancement(::PROTOBUF_NAMESPACE_ID::Any* enhancement); private: - const PROTOBUF_NAMESPACE_ID::Any& _internal_enhancement() const; - PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_enhancement(); + const ::PROTOBUF_NAMESPACE_ID::Any& _internal_enhancement() const; + ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_enhancement(); public: void unsafe_arena_set_allocated_enhancement( - PROTOBUF_NAMESPACE_ID::Any* enhancement); - PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_enhancement(); + ::PROTOBUF_NAMESPACE_ID::Any* enhancement); + ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_enhancement(); // @@protoc_insertion_point(class_scope:substrait.extensions.AdvancedExtension) private: @@ -1068,8 +1158,8 @@ class AdvancedExtension PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - PROTOBUF_NAMESPACE_ID::Any* optimization_; - PROTOBUF_NAMESPACE_ID::Any* enhancement_; + ::PROTOBUF_NAMESPACE_ID::Any* optimization_; + ::PROTOBUF_NAMESPACE_ID::Any* enhancement_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; }; @@ -1088,18 +1178,18 @@ class AdvancedExtension PROTOBUF_FINAL : inline void SimpleExtensionURI::clear_extension_uri_anchor() { extension_uri_anchor_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionURI::_internal_extension_uri_anchor() const { +inline uint32_t SimpleExtensionURI::_internal_extension_uri_anchor() const { return extension_uri_anchor_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionURI::extension_uri_anchor() const { +inline uint32_t SimpleExtensionURI::extension_uri_anchor() const { // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionURI.extension_uri_anchor) return _internal_extension_uri_anchor(); } -inline void SimpleExtensionURI::_internal_set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionURI::_internal_set_extension_uri_anchor(uint32_t value) { extension_uri_anchor_ = value; } -inline void SimpleExtensionURI::set_extension_uri_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionURI::set_extension_uri_anchor(uint32_t value) { _internal_set_extension_uri_anchor(value); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionURI.extension_uri_anchor) } @@ -1113,30 +1203,31 @@ inline const std::string& SimpleExtensionURI::uri() const { return _internal_uri(); } template -PROTOBUF_ALWAYS_INLINE -inline void SimpleExtensionURI::set_uri(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void SimpleExtensionURI::set_uri(ArgT0&& arg0, ArgT... args) { - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionURI.uri) } inline std::string* SimpleExtensionURI::mutable_uri() { + std::string* _s = _internal_mutable_uri(); // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionURI.uri) - return _internal_mutable_uri(); + return _s; } inline const std::string& SimpleExtensionURI::_internal_uri() const { return uri_.Get(); } inline void SimpleExtensionURI::_internal_set_uri(const std::string& value) { - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* SimpleExtensionURI::_internal_mutable_uri() { - return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* SimpleExtensionURI::release_uri() { // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionURI.uri) - return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void SimpleExtensionURI::set_allocated_uri(std::string* uri) { if (uri != nullptr) { @@ -1145,7 +1236,12 @@ inline void SimpleExtensionURI::set_allocated_uri(std::string* uri) { } uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (uri_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionURI.uri) } @@ -1157,18 +1253,18 @@ inline void SimpleExtensionURI::set_allocated_uri(std::string* uri) { inline void SimpleExtensionDeclaration_ExtensionType::clear_extension_uri_reference() { extension_uri_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::_internal_extension_uri_reference() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionType::_internal_extension_uri_reference() const { return extension_uri_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::extension_uri_reference() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionType::extension_uri_reference() const { // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference) return _internal_extension_uri_reference(); } -inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_extension_uri_reference(uint32_t value) { extension_uri_reference_ = value; } -inline void SimpleExtensionDeclaration_ExtensionType::set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionType::set_extension_uri_reference(uint32_t value) { _internal_set_extension_uri_reference(value); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference) } @@ -1177,18 +1273,18 @@ inline void SimpleExtensionDeclaration_ExtensionType::set_extension_uri_referenc inline void SimpleExtensionDeclaration_ExtensionType::clear_type_anchor() { type_anchor_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::_internal_type_anchor() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionType::_internal_type_anchor() const { return type_anchor_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionType::type_anchor() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionType::type_anchor() const { // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor) return _internal_type_anchor(); } -inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_type_anchor(uint32_t value) { type_anchor_ = value; } -inline void SimpleExtensionDeclaration_ExtensionType::set_type_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionType::set_type_anchor(uint32_t value) { _internal_set_type_anchor(value); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor) } @@ -1202,30 +1298,31 @@ inline const std::string& SimpleExtensionDeclaration_ExtensionType::name() const return _internal_name(); } template -PROTOBUF_ALWAYS_INLINE -inline void SimpleExtensionDeclaration_ExtensionType::set_name(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void SimpleExtensionDeclaration_ExtensionType::set_name(ArgT0&& arg0, ArgT... args) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) } inline std::string* SimpleExtensionDeclaration_ExtensionType::mutable_name() { + std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) - return _internal_mutable_name(); + return _s; } inline const std::string& SimpleExtensionDeclaration_ExtensionType::_internal_name() const { return name_.Get(); } inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_name(const std::string& value) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* SimpleExtensionDeclaration_ExtensionType::_internal_mutable_name() { - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* SimpleExtensionDeclaration_ExtensionType::release_name() { // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void SimpleExtensionDeclaration_ExtensionType::set_allocated_name(std::string* name) { if (name != nullptr) { @@ -1234,7 +1331,12 @@ inline void SimpleExtensionDeclaration_ExtensionType::set_allocated_name(std::st } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) } @@ -1246,18 +1348,18 @@ inline void SimpleExtensionDeclaration_ExtensionType::set_allocated_name(std::st inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_extension_uri_reference() { extension_uri_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_extension_uri_reference() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_extension_uri_reference() const { return extension_uri_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::extension_uri_reference() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::extension_uri_reference() const { // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_reference) return _internal_extension_uri_reference(); } -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_extension_uri_reference(uint32_t value) { extension_uri_reference_ = value; } -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_extension_uri_reference(uint32_t value) { _internal_set_extension_uri_reference(value); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_reference) } @@ -1266,18 +1368,18 @@ inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_extension_uri inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_type_variation_anchor() { type_variation_anchor_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_type_variation_anchor() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_type_variation_anchor() const { return type_variation_anchor_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor() const { // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor) return _internal_type_variation_anchor(); } -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_type_variation_anchor(uint32_t value) { type_variation_anchor_ = value; } -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_type_variation_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_type_variation_anchor(uint32_t value) { _internal_set_type_variation_anchor(value); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor) } @@ -1291,30 +1393,31 @@ inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::nam return _internal_name(); } template -PROTOBUF_ALWAYS_INLINE -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_name(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void SimpleExtensionDeclaration_ExtensionTypeVariation::set_name(ArgT0&& arg0, ArgT... args) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) } inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::mutable_name() { + std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) - return _internal_mutable_name(); + return _s; } inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_name() const { return name_.Get(); } inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_name(const std::string& value) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_mutable_name() { - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::release_name() { // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_allocated_name(std::string* name) { if (name != nullptr) { @@ -1323,7 +1426,12 @@ inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_allocated_nam } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) } @@ -1335,18 +1443,18 @@ inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_allocated_nam inline void SimpleExtensionDeclaration_ExtensionFunction::clear_extension_uri_reference() { extension_uri_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::_internal_extension_uri_reference() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::_internal_extension_uri_reference() const { return extension_uri_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::extension_uri_reference() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::extension_uri_reference() const { // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_reference) return _internal_extension_uri_reference(); } -inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_extension_uri_reference(uint32_t value) { extension_uri_reference_ = value; } -inline void SimpleExtensionDeclaration_ExtensionFunction::set_extension_uri_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionFunction::set_extension_uri_reference(uint32_t value) { _internal_set_extension_uri_reference(value); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_reference) } @@ -1355,18 +1463,18 @@ inline void SimpleExtensionDeclaration_ExtensionFunction::set_extension_uri_refe inline void SimpleExtensionDeclaration_ExtensionFunction::clear_function_anchor() { function_anchor_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::_internal_function_anchor() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::_internal_function_anchor() const { return function_anchor_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 SimpleExtensionDeclaration_ExtensionFunction::function_anchor() const { +inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::function_anchor() const { // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor) return _internal_function_anchor(); } -inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_function_anchor(uint32_t value) { function_anchor_ = value; } -inline void SimpleExtensionDeclaration_ExtensionFunction::set_function_anchor(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void SimpleExtensionDeclaration_ExtensionFunction::set_function_anchor(uint32_t value) { _internal_set_function_anchor(value); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor) } @@ -1380,30 +1488,31 @@ inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::name() c return _internal_name(); } template -PROTOBUF_ALWAYS_INLINE -inline void SimpleExtensionDeclaration_ExtensionFunction::set_name(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void SimpleExtensionDeclaration_ExtensionFunction::set_name(ArgT0&& arg0, ArgT... args) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) } inline std::string* SimpleExtensionDeclaration_ExtensionFunction::mutable_name() { + std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) - return _internal_mutable_name(); + return _s; } inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::_internal_name() const { return name_.Get(); } inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_name(const std::string& value) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* SimpleExtensionDeclaration_ExtensionFunction::_internal_mutable_name() { - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* SimpleExtensionDeclaration_ExtensionFunction::release_name() { // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void SimpleExtensionDeclaration_ExtensionFunction::set_allocated_name(std::string* name) { if (name != nullptr) { @@ -1412,7 +1521,12 @@ inline void SimpleExtensionDeclaration_ExtensionFunction::set_allocated_name(std } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) } @@ -1432,7 +1546,7 @@ inline void SimpleExtensionDeclaration::set_has_extension_type() { } inline void SimpleExtensionDeclaration::clear_extension_type() { if (_internal_has_extension_type()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete mapping_type_.extension_type_; } clear_has_mapping_type(); @@ -1443,7 +1557,7 @@ inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Simple if (_internal_has_extension_type()) { clear_has_mapping_type(); ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } mapping_type_.extension_type_ = nullptr; @@ -1484,13 +1598,14 @@ inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Simple if (!_internal_has_extension_type()) { clear_mapping_type(); set_has_extension_type(); - mapping_type_.extension_type_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(GetArena()); + mapping_type_.extension_type_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(GetArenaForAllocation()); } return mapping_type_.extension_type_; } inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::mutable_extension_type() { + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* _msg = _internal_mutable_extension_type(); // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_type) - return _internal_mutable_extension_type(); + return _msg; } // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; @@ -1505,7 +1620,7 @@ inline void SimpleExtensionDeclaration::set_has_extension_type_variation() { } inline void SimpleExtensionDeclaration::clear_extension_type_variation() { if (_internal_has_extension_type_variation()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete mapping_type_.extension_type_variation_; } clear_has_mapping_type(); @@ -1516,7 +1631,7 @@ inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariatio if (_internal_has_extension_type_variation()) { clear_has_mapping_type(); ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } mapping_type_.extension_type_variation_ = nullptr; @@ -1557,13 +1672,14 @@ inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariatio if (!_internal_has_extension_type_variation()) { clear_mapping_type(); set_has_extension_type_variation(); - mapping_type_.extension_type_variation_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(GetArena()); + mapping_type_.extension_type_variation_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(GetArenaForAllocation()); } return mapping_type_.extension_type_variation_; } inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::mutable_extension_type_variation() { + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* _msg = _internal_mutable_extension_type_variation(); // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) - return _internal_mutable_extension_type_variation(); + return _msg; } // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; @@ -1578,7 +1694,7 @@ inline void SimpleExtensionDeclaration::set_has_extension_function() { } inline void SimpleExtensionDeclaration::clear_extension_function() { if (_internal_has_extension_function()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete mapping_type_.extension_function_; } clear_has_mapping_type(); @@ -1589,7 +1705,7 @@ inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Si if (_internal_has_extension_function()) { clear_has_mapping_type(); ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } mapping_type_.extension_function_ = nullptr; @@ -1630,13 +1746,14 @@ inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Si if (!_internal_has_extension_function()) { clear_mapping_type(); set_has_extension_function(); - mapping_type_.extension_function_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(GetArena()); + mapping_type_.extension_function_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(GetArenaForAllocation()); } return mapping_type_.extension_function_; } inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::mutable_extension_function() { + ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* _msg = _internal_mutable_extension_function(); // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_function) - return _internal_mutable_extension_function(); + return _msg; } inline bool SimpleExtensionDeclaration::has_mapping_type() const { @@ -1659,18 +1776,18 @@ inline bool AdvancedExtension::_internal_has_optimization() const { inline bool AdvancedExtension::has_optimization() const { return _internal_has_optimization(); } -inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_optimization() const { - const PROTOBUF_NAMESPACE_ID::Any* p = optimization_; - return p != nullptr ? *p : reinterpret_cast( - PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_optimization() const { + const ::PROTOBUF_NAMESPACE_ID::Any* p = optimization_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } -inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::optimization() const { +inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::optimization() const { // @@protoc_insertion_point(field_get:substrait.extensions.AdvancedExtension.optimization) return _internal_optimization(); } inline void AdvancedExtension::unsafe_arena_set_allocated_optimization( - PROTOBUF_NAMESPACE_ID::Any* optimization) { - if (GetArena() == nullptr) { + ::PROTOBUF_NAMESPACE_ID::Any* optimization) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_); } optimization_ = optimization; @@ -1681,42 +1798,51 @@ inline void AdvancedExtension::unsafe_arena_set_allocated_optimization( } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.AdvancedExtension.optimization) } -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_optimization() { +inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_optimization() { - PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; optimization_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_optimization() { +inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_optimization() { // @@protoc_insertion_point(field_release:substrait.extensions.AdvancedExtension.optimization) - PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; optimization_ = nullptr; return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_optimization() { +inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_optimization() { if (optimization_ == nullptr) { - auto* p = CreateMaybeMessage(GetArena()); + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); optimization_ = p; } return optimization_; } -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_optimization() { +inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_optimization() { + ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_optimization(); // @@protoc_insertion_point(field_mutable:substrait.extensions.AdvancedExtension.optimization) - return _internal_mutable_optimization(); + return _msg; } -inline void AdvancedExtension::set_allocated_optimization(PROTOBUF_NAMESPACE_ID::Any* optimization) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); +inline void AdvancedExtension::set_allocated_optimization(::PROTOBUF_NAMESPACE_ID::Any* optimization) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_); } if (optimization) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization)); if (message_arena != submessage_arena) { optimization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, optimization, submessage_arena); @@ -1736,18 +1862,18 @@ inline bool AdvancedExtension::_internal_has_enhancement() const { inline bool AdvancedExtension::has_enhancement() const { return _internal_has_enhancement(); } -inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_enhancement() const { - const PROTOBUF_NAMESPACE_ID::Any* p = enhancement_; - return p != nullptr ? *p : reinterpret_cast( - PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_enhancement() const { + const ::PROTOBUF_NAMESPACE_ID::Any* p = enhancement_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } -inline const PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::enhancement() const { +inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::enhancement() const { // @@protoc_insertion_point(field_get:substrait.extensions.AdvancedExtension.enhancement) return _internal_enhancement(); } inline void AdvancedExtension::unsafe_arena_set_allocated_enhancement( - PROTOBUF_NAMESPACE_ID::Any* enhancement) { - if (GetArena() == nullptr) { + ::PROTOBUF_NAMESPACE_ID::Any* enhancement) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_); } enhancement_ = enhancement; @@ -1758,42 +1884,51 @@ inline void AdvancedExtension::unsafe_arena_set_allocated_enhancement( } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.AdvancedExtension.enhancement) } -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_enhancement() { +inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_enhancement() { - PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; enhancement_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_enhancement() { +inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_enhancement() { // @@protoc_insertion_point(field_release:substrait.extensions.AdvancedExtension.enhancement) - PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; enhancement_ = nullptr; return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_enhancement() { +inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_enhancement() { if (enhancement_ == nullptr) { - auto* p = CreateMaybeMessage(GetArena()); + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); enhancement_ = p; } return enhancement_; } -inline PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_enhancement() { +inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_enhancement() { + ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_enhancement(); // @@protoc_insertion_point(field_mutable:substrait.extensions.AdvancedExtension.enhancement) - return _internal_mutable_enhancement(); + return _msg; } -inline void AdvancedExtension::set_allocated_enhancement(PROTOBUF_NAMESPACE_ID::Any* enhancement) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); +inline void AdvancedExtension::set_allocated_enhancement(::PROTOBUF_NAMESPACE_ID::Any* enhancement) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_); } if (enhancement) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement)); if (message_arena != submessage_arena) { enhancement = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, enhancement, submessage_arena); diff --git a/cpp/src/generated/substrait/function.pb.cc b/cpp/src/generated/substrait/function.pb.cc index 0a447b27bc2..eb85050ab71 100644 --- a/cpp/src/generated/substrait/function.pb.cc +++ b/cpp/src/generated/substrait/function.pb.cc @@ -19,8 +19,8 @@ PROTOBUF_PRAGMA_INIT_SEG namespace substrait { constexpr FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : min_args_(PROTOBUF_LONGLONG(0)) - , max_args_(PROTOBUF_LONGLONG(0)) + : min_args_(int64_t{0}) + , max_args_(int64_t{0}) , consistency_(0) {} struct FunctionSignature_FinalArgVariadicDefaultTypeInternal { @@ -73,7 +73,7 @@ constexpr FunctionSignature_Aggregate::FunctionSignature_Aggregate( , deterministic_(false) , session_dependent_(false) , ordered_(false) - , max_set_(PROTOBUF_ULONGLONG(0)) + , max_set_(uint64_t{0u}) , _oneof_case_{}{} struct FunctionSignature_AggregateDefaultTypeInternal { constexpr FunctionSignature_AggregateDefaultTypeInternal() @@ -97,7 +97,7 @@ constexpr FunctionSignature_Window::FunctionSignature_Window( , ordered_(false) , window_type_(0) - , max_set_(PROTOBUF_ULONGLONG(0)) + , max_set_(uint64_t{0u}) , _oneof_case_{}{} struct FunctionSignature_WindowDefaultTypeInternal { constexpr FunctionSignature_WindowDefaultTypeInternal() @@ -202,12 +202,13 @@ static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ffunctio static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ffunction_2eproto[3]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ffunction_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const uint32_t TableStruct_substrait_2ffunction_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, min_args_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, max_args_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, consistency_), @@ -216,11 +217,13 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto:: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, arguments_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, name_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, description_), @@ -236,6 +239,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto:: ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, arguments_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, name_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, description_), @@ -254,6 +258,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto:: ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, arguments_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, name_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, description_), @@ -273,6 +278,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto:: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, language_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, body_), ~0u, // no _has_bits_ @@ -280,6 +286,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto:: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, type_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, uri_), ~0u, // no _has_bits_ @@ -287,6 +294,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto:: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, type_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, constant_), ~0u, // no _has_bits_ @@ -294,12 +302,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto:: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_TypeArgument, type_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, options_), PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, optional_), ~0u, // no _has_bits_ @@ -307,6 +317,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto:: ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, name_), ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -317,20 +328,21 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ffunction_2eproto:: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::substrait::FunctionSignature_FinalArgVariadic)}, - { 8, -1, sizeof(::substrait::FunctionSignature_FinalArgNormal)}, - { 13, -1, sizeof(::substrait::FunctionSignature_Scalar)}, - { 28, -1, sizeof(::substrait::FunctionSignature_Aggregate)}, - { 46, -1, sizeof(::substrait::FunctionSignature_Window)}, - { 65, -1, sizeof(::substrait::FunctionSignature_Description)}, - { 72, -1, sizeof(::substrait::FunctionSignature_Implementation)}, - { 79, -1, sizeof(::substrait::FunctionSignature_Argument_ValueArgument)}, - { 86, -1, sizeof(::substrait::FunctionSignature_Argument_TypeArgument)}, - { 92, -1, sizeof(::substrait::FunctionSignature_Argument_EnumArgument)}, - { 99, -1, sizeof(::substrait::FunctionSignature_Argument)}, - { 109, -1, sizeof(::substrait::FunctionSignature)}, + { 0, -1, -1, sizeof(::substrait::FunctionSignature_FinalArgVariadic)}, + { 9, -1, -1, sizeof(::substrait::FunctionSignature_FinalArgNormal)}, + { 15, -1, -1, sizeof(::substrait::FunctionSignature_Scalar)}, + { 31, -1, -1, sizeof(::substrait::FunctionSignature_Aggregate)}, + { 50, -1, -1, sizeof(::substrait::FunctionSignature_Window)}, + { 70, -1, -1, sizeof(::substrait::FunctionSignature_Description)}, + { 78, -1, -1, sizeof(::substrait::FunctionSignature_Implementation)}, + { 86, -1, -1, sizeof(::substrait::FunctionSignature_Argument_ValueArgument)}, + { 94, -1, -1, sizeof(::substrait::FunctionSignature_Argument_TypeArgument)}, + { 101, -1, -1, sizeof(::substrait::FunctionSignature_Argument_EnumArgument)}, + { 109, -1, -1, sizeof(::substrait::FunctionSignature_Argument)}, + { 120, -1, -1, sizeof(::substrait::FunctionSignature)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -458,14 +470,14 @@ bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value) } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_UNSPECIFIED; constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_CONSISTENT; constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_INCONSISTENT; constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MIN; constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MAX; constexpr int FunctionSignature_FinalArgVariadic::ParameterConsistency_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto); return file_level_enum_descriptors_substrait_2ffunction_2eproto[1]; @@ -481,14 +493,14 @@ bool FunctionSignature_Window_WindowType_IsValid(int value) { } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_UNSPECIFIED; constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_STREAMING; constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_PARTITION; constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MIN; constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MAX; constexpr int FunctionSignature_Window::WindowType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto); return file_level_enum_descriptors_substrait_2ffunction_2eproto[2]; @@ -504,14 +516,14 @@ bool FunctionSignature_Implementation_Type_IsValid(int value) { } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_UNSPECIFIED; constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_WEB_ASSEMBLY; constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_TRINO_JAR; constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MIN; constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MAX; constexpr int FunctionSignature_Implementation::Type_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) // =================================================================== @@ -519,10 +531,13 @@ class FunctionSignature_FinalArgVariadic::_Internal { public: }; -FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.FinalArgVariadic) } FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(const FunctionSignature_FinalArgVariadic& from) @@ -534,7 +549,7 @@ FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(const Fun // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.FinalArgVariadic) } -void FunctionSignature_FinalArgVariadic::SharedCtor() { +inline void FunctionSignature_FinalArgVariadic::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&min_args_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&consistency_) - @@ -543,12 +558,13 @@ ::memset(reinterpret_cast(this) + static_cast( FunctionSignature_FinalArgVariadic::~FunctionSignature_FinalArgVariadic() { // @@protoc_insertion_point(destructor:substrait.FunctionSignature.FinalArgVariadic) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FunctionSignature_FinalArgVariadic::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FunctionSignature_FinalArgVariadic::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void FunctionSignature_FinalArgVariadic::ArenaDtor(void* object) { @@ -563,7 +579,7 @@ void FunctionSignature_FinalArgVariadic::SetCachedSize(int size) const { void FunctionSignature_FinalArgVariadic::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.FinalArgVariadic) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -576,74 +592,77 @@ void FunctionSignature_FinalArgVariadic::Clear() { const char* FunctionSignature_FinalArgVariadic::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int64 min_args = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { min_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int64 max_args = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { max_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_consistency(static_cast<::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_FinalArgVariadic::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FunctionSignature_FinalArgVariadic::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.FinalArgVariadic) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int64 min_args = 1; - if (this->min_args() != 0) { + if (this->_internal_min_args() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_min_args(), target); } // int64 max_args = 2; - if (this->max_args() != 0) { + if (this->_internal_max_args() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_max_args(), target); } // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; - if (this->consistency() != 0) { + if (this->_internal_consistency() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_consistency(), target); @@ -661,77 +680,58 @@ size_t FunctionSignature_FinalArgVariadic::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.FinalArgVariadic) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int64 min_args = 1; - if (this->min_args() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_min_args()); + if (this->_internal_min_args() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_min_args()); } // int64 max_args = 2; - if (this->max_args() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_max_args()); + if (this->_internal_max_args() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_max_args()); } // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; - if (this->consistency() != 0) { + if (this->_internal_consistency() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_consistency()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FunctionSignature_FinalArgVariadic::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.FinalArgVariadic) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_FinalArgVariadic* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.FinalArgVariadic) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.FinalArgVariadic) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_FinalArgVariadic::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FunctionSignature_FinalArgVariadic::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_FinalArgVariadic::GetClassData() const { return &_class_data_; } + +void FunctionSignature_FinalArgVariadic::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FunctionSignature_FinalArgVariadic::MergeFrom(const FunctionSignature_FinalArgVariadic& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.FinalArgVariadic) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.min_args() != 0) { + if (from._internal_min_args() != 0) { _internal_set_min_args(from._internal_min_args()); } - if (from.max_args() != 0) { + if (from._internal_max_args() != 0) { _internal_set_max_args(from._internal_max_args()); } - if (from.consistency() != 0) { + if (from._internal_consistency() != 0) { _internal_set_consistency(from._internal_consistency()); } -} - -void FunctionSignature_FinalArgVariadic::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.FinalArgVariadic) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FunctionSignature_FinalArgVariadic::CopyFrom(const FunctionSignature_FinalArgVariadic& from) { @@ -747,7 +747,7 @@ bool FunctionSignature_FinalArgVariadic::IsInitialized() const { void FunctionSignature_FinalArgVariadic::InternalSwap(FunctionSignature_FinalArgVariadic* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(FunctionSignature_FinalArgVariadic, consistency_) + sizeof(FunctionSignature_FinalArgVariadic::consistency_) @@ -768,151 +768,32 @@ class FunctionSignature_FinalArgNormal::_Internal { public: }; -FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); +FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.FinalArgNormal) } FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(const FunctionSignature_FinalArgNormal& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.FinalArgNormal) } -void FunctionSignature_FinalArgNormal::SharedCtor() { -} - -FunctionSignature_FinalArgNormal::~FunctionSignature_FinalArgNormal() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.FinalArgNormal) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void FunctionSignature_FinalArgNormal::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void FunctionSignature_FinalArgNormal::ArenaDtor(void* object) { - FunctionSignature_FinalArgNormal* _this = reinterpret_cast< FunctionSignature_FinalArgNormal* >(object); - (void)_this; -} -void FunctionSignature_FinalArgNormal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_FinalArgNormal::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_FinalArgNormal::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.FinalArgNormal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_FinalArgNormal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_FinalArgNormal::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.FinalArgNormal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.FinalArgNormal) - return target; -} -size_t FunctionSignature_FinalArgNormal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.FinalArgNormal) - size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_FinalArgNormal::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_FinalArgNormal::GetClassData() const { return &_class_data_; } -void FunctionSignature_FinalArgNormal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.FinalArgNormal) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_FinalArgNormal* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.FinalArgNormal) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.FinalArgNormal) - MergeFrom(*source); - } -} -void FunctionSignature_FinalArgNormal::MergeFrom(const FunctionSignature_FinalArgNormal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.FinalArgNormal) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; -} -void FunctionSignature_FinalArgNormal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.FinalArgNormal) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -void FunctionSignature_FinalArgNormal::CopyFrom(const FunctionSignature_FinalArgNormal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.FinalArgNormal) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -bool FunctionSignature_FinalArgNormal::IsInitialized() const { - return true; -} - -void FunctionSignature_FinalArgNormal::InternalSwap(FunctionSignature_FinalArgNormal* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); -} ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgNormal::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( @@ -947,17 +828,17 @@ FunctionSignature_Scalar::_Internal::normal(const FunctionSignature_Scalar* msg) return *msg->final_variable_behavior_.normal_; } void FunctionSignature_Scalar::clear_output_type() { - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; } void FunctionSignature_Scalar::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_final_variable_behavior(); if (variadic) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variadic); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic); if (message_arena != submessage_arena) { variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, variadic, submessage_arena); @@ -968,11 +849,11 @@ void FunctionSignature_Scalar::set_allocated_variadic(::substrait::FunctionSigna // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.variadic) } void FunctionSignature_Scalar::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_final_variable_behavior(); if (normal) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(normal); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal); if (message_arena != submessage_arena) { normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, normal, submessage_arena); @@ -982,13 +863,16 @@ void FunctionSignature_Scalar::set_allocated_normal(::substrait::FunctionSignatu } // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.normal) } -FunctionSignature_Scalar::FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +FunctionSignature_Scalar::FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), arguments_(arena), name_(arena), implementations_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Scalar) } FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scalar& from) @@ -1027,7 +911,7 @@ FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scala // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Scalar) } -void FunctionSignature_Scalar::SharedCtor() { +inline void FunctionSignature_Scalar::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&description_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&session_dependent_) - @@ -1037,12 +921,13 @@ clear_has_final_variable_behavior(); FunctionSignature_Scalar::~FunctionSignature_Scalar() { // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Scalar) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FunctionSignature_Scalar::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FunctionSignature_Scalar::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete description_; if (this != internal_default_instance()) delete output_type_; if (has_final_variable_behavior()) { @@ -1064,13 +949,13 @@ void FunctionSignature_Scalar::clear_final_variable_behavior() { // @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Scalar) switch (final_variable_behavior_case()) { case kVariadic: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.variadic_; } break; } case kNormal: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.normal_; } break; @@ -1085,18 +970,18 @@ void FunctionSignature_Scalar::clear_final_variable_behavior() { void FunctionSignature_Scalar::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Scalar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; arguments_.Clear(); name_.Clear(); implementations_.Clear(); - if (GetArena() == nullptr && description_ != nullptr) { + if (GetArenaForAllocation() == nullptr && description_ != nullptr) { delete description_; } description_ = nullptr; - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; @@ -1110,12 +995,12 @@ void FunctionSignature_Scalar::Clear() { const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.FunctionSignature.Argument arguments = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -1123,11 +1008,12 @@ const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated string name = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -1137,53 +1023,60 @@ const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.Description description = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool deterministic = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool session_dependent = 8; case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression output_type = 9; case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.FinalArgNormal normal = 11; case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.FunctionSignature.Implementation implementations = 12; case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { ptr -= 1; do { ptr += 1; @@ -1191,35 +1084,36 @@ const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FunctionSignature_Scalar::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Scalar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.FunctionSignature.Argument arguments = 2; @@ -1241,7 +1135,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( } // .substrait.FunctionSignature.Description description = 4; - if (this->has_description()) { + if (this->_internal_has_description()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1249,19 +1143,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Scalar::_InternalSerialize( } // bool deterministic = 7; - if (this->deterministic() != 0) { + if (this->_internal_deterministic() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target); } // bool session_dependent = 8; - if (this->session_dependent() != 0) { + if (this->_internal_session_dependent() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); } // .substrait.DerivationExpression output_type = 9; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1304,7 +1198,7 @@ size_t FunctionSignature_Scalar::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Scalar) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1331,26 +1225,26 @@ size_t FunctionSignature_Scalar::ByteSizeLong() const { } // .substrait.FunctionSignature.Description description = 4; - if (this->has_description()) { + if (this->_internal_has_description()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *description_); } // .substrait.DerivationExpression output_type = 9; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *output_type_); } // bool deterministic = 7; - if (this->deterministic() != 0) { + if (this->_internal_deterministic() != 0) { total_size += 1 + 1; } // bool session_dependent = 8; - if (this->session_dependent() != 0) { + if (this->_internal_session_dependent() != 0) { total_size += 1 + 1; } @@ -1373,50 +1267,41 @@ size_t FunctionSignature_Scalar::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FunctionSignature_Scalar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Scalar) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_Scalar* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Scalar) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Scalar) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Scalar::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FunctionSignature_Scalar::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Scalar::GetClassData() const { return &_class_data_; } + +void FunctionSignature_Scalar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FunctionSignature_Scalar::MergeFrom(const FunctionSignature_Scalar& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Scalar) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; arguments_.MergeFrom(from.arguments_); name_.MergeFrom(from.name_); implementations_.MergeFrom(from.implementations_); - if (from.has_description()) { + if (from._internal_has_description()) { _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); } - if (from.has_output_type()) { + if (from._internal_has_output_type()) { _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); } - if (from.deterministic() != 0) { + if (from._internal_deterministic() != 0) { _internal_set_deterministic(from._internal_deterministic()); } - if (from.session_dependent() != 0) { + if (from._internal_session_dependent() != 0) { _internal_set_session_dependent(from._internal_session_dependent()); } switch (from.final_variable_behavior_case()) { @@ -1432,13 +1317,7 @@ void FunctionSignature_Scalar::MergeFrom(const FunctionSignature_Scalar& from) { break; } } -} - -void FunctionSignature_Scalar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Scalar) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FunctionSignature_Scalar::CopyFrom(const FunctionSignature_Scalar& from) { @@ -1454,7 +1333,7 @@ bool FunctionSignature_Scalar::IsInitialized() const { void FunctionSignature_Scalar::InternalSwap(FunctionSignature_Scalar* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); arguments_.InternalSwap(&other->arguments_); name_.InternalSwap(&other->name_); implementations_.InternalSwap(&other->implementations_); @@ -1506,17 +1385,17 @@ FunctionSignature_Aggregate::_Internal::intermediate_type(const FunctionSignatur return *msg->intermediate_type_; } void FunctionSignature_Aggregate::clear_output_type() { - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; } void FunctionSignature_Aggregate::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_final_variable_behavior(); if (variadic) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variadic); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic); if (message_arena != submessage_arena) { variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, variadic, submessage_arena); @@ -1527,11 +1406,11 @@ void FunctionSignature_Aggregate::set_allocated_variadic(::substrait::FunctionSi // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.variadic) } void FunctionSignature_Aggregate::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_final_variable_behavior(); if (normal) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(normal); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal); if (message_arena != submessage_arena) { normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, normal, submessage_arena); @@ -1542,17 +1421,20 @@ void FunctionSignature_Aggregate::set_allocated_normal(::substrait::FunctionSign // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.normal) } void FunctionSignature_Aggregate::clear_intermediate_type() { - if (GetArena() == nullptr && intermediate_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) { delete intermediate_type_; } intermediate_type_ = nullptr; } -FunctionSignature_Aggregate::FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +FunctionSignature_Aggregate::FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), arguments_(arena), implementations_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Aggregate) } FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from) @@ -1561,9 +1443,12 @@ FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature implementations_(from.implementations_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_name().empty()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); + GetArenaForAllocation()); } if (from._internal_has_description()) { description_ = new ::substrait::FunctionSignature_Description(*from.description_); @@ -1600,8 +1485,11 @@ FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Aggregate) } -void FunctionSignature_Aggregate::SharedCtor() { +inline void FunctionSignature_Aggregate::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&description_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&max_set_) - @@ -1611,12 +1499,13 @@ clear_has_final_variable_behavior(); FunctionSignature_Aggregate::~FunctionSignature_Aggregate() { // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Aggregate) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FunctionSignature_Aggregate::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FunctionSignature_Aggregate::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete description_; if (this != internal_default_instance()) delete output_type_; @@ -1640,13 +1529,13 @@ void FunctionSignature_Aggregate::clear_final_variable_behavior() { // @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Aggregate) switch (final_variable_behavior_case()) { case kVariadic: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.variadic_; } break; } case kNormal: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.normal_; } break; @@ -1661,22 +1550,22 @@ void FunctionSignature_Aggregate::clear_final_variable_behavior() { void FunctionSignature_Aggregate::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Aggregate) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; arguments_.Clear(); implementations_.Clear(); name_.ClearToEmpty(); - if (GetArena() == nullptr && description_ != nullptr) { + if (GetArenaForAllocation() == nullptr && description_ != nullptr) { delete description_; } description_ = nullptr; - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; - if (GetArena() == nullptr && intermediate_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) { delete intermediate_type_; } intermediate_type_ = nullptr; @@ -1690,12 +1579,12 @@ void FunctionSignature_Aggregate::Clear() { const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.FunctionSignature.Argument arguments = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -1703,83 +1592,94 @@ const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTO CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string name = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Aggregate.name")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.Description description = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool deterministic = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool session_dependent = 8; case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression output_type = 9; case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.FinalArgNormal normal = 11; case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint64 max_set = 12; case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { max_set_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type intermediate_type = 13; case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool ordered = 14; case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { ordered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.FunctionSignature.Implementation implementations = 15; case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { ptr -= 1; do { ptr += 1; @@ -1787,35 +1687,36 @@ const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTO CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FunctionSignature_Aggregate::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Aggregate) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.FunctionSignature.Argument arguments = 2; @@ -1827,7 +1728,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( } // string name = 3; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -1837,7 +1738,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( } // .substrait.FunctionSignature.Description description = 4; - if (this->has_description()) { + if (this->_internal_has_description()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1845,19 +1746,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( } // bool deterministic = 7; - if (this->deterministic() != 0) { + if (this->_internal_deterministic() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target); } // bool session_dependent = 8; - if (this->session_dependent() != 0) { + if (this->_internal_session_dependent() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); } // .substrait.DerivationExpression output_type = 9; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1881,13 +1782,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( } // uint64 max_set = 12; - if (this->max_set() != 0) { + if (this->_internal_max_set() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target); } // .substrait.Type intermediate_type = 13; - if (this->has_intermediate_type()) { + if (this->_internal_has_intermediate_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1895,7 +1796,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Aggregate::_InternalSerialize( } // bool ordered = 14; - if (this->ordered() != 0) { + if (this->_internal_ordered() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(14, this->_internal_ordered(), target); } @@ -1920,7 +1821,7 @@ size_t FunctionSignature_Aggregate::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Aggregate) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1939,53 +1840,51 @@ size_t FunctionSignature_Aggregate::ByteSizeLong() const { } // string name = 3; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // .substrait.FunctionSignature.Description description = 4; - if (this->has_description()) { + if (this->_internal_has_description()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *description_); } // .substrait.DerivationExpression output_type = 9; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *output_type_); } // .substrait.Type intermediate_type = 13; - if (this->has_intermediate_type()) { + if (this->_internal_has_intermediate_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *intermediate_type_); } // bool deterministic = 7; - if (this->deterministic() != 0) { + if (this->_internal_deterministic() != 0) { total_size += 1 + 1; } // bool session_dependent = 8; - if (this->session_dependent() != 0) { + if (this->_internal_session_dependent() != 0) { total_size += 1 + 1; } // bool ordered = 14; - if (this->ordered() != 0) { + if (this->_internal_ordered() != 0) { total_size += 1 + 1; } // uint64 max_set = 12; - if (this->max_set() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( - this->_internal_max_set()); + if (this->_internal_max_set() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_max_set()); } switch (final_variable_behavior_case()) { @@ -2007,61 +1906,52 @@ size_t FunctionSignature_Aggregate::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FunctionSignature_Aggregate::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Aggregate) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_Aggregate* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Aggregate) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Aggregate) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Aggregate::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FunctionSignature_Aggregate::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Aggregate::GetClassData() const { return &_class_data_; } + +void FunctionSignature_Aggregate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Aggregate) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; arguments_.MergeFrom(from.arguments_); implementations_.MergeFrom(from.implementations_); - if (from.name().size() > 0) { + if (!from._internal_name().empty()) { _internal_set_name(from._internal_name()); } - if (from.has_description()) { + if (from._internal_has_description()) { _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); } - if (from.has_output_type()) { + if (from._internal_has_output_type()) { _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); } - if (from.has_intermediate_type()) { + if (from._internal_has_intermediate_type()) { _internal_mutable_intermediate_type()->::substrait::Type::MergeFrom(from._internal_intermediate_type()); } - if (from.deterministic() != 0) { + if (from._internal_deterministic() != 0) { _internal_set_deterministic(from._internal_deterministic()); } - if (from.session_dependent() != 0) { + if (from._internal_session_dependent() != 0) { _internal_set_session_dependent(from._internal_session_dependent()); } - if (from.ordered() != 0) { + if (from._internal_ordered() != 0) { _internal_set_ordered(from._internal_ordered()); } - if (from.max_set() != 0) { + if (from._internal_max_set() != 0) { _internal_set_max_set(from._internal_max_set()); } switch (from.final_variable_behavior_case()) { @@ -2077,13 +1967,7 @@ void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& f break; } } -} - -void FunctionSignature_Aggregate::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Aggregate) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FunctionSignature_Aggregate::CopyFrom(const FunctionSignature_Aggregate& from) { @@ -2099,10 +1983,16 @@ bool FunctionSignature_Aggregate::IsInitialized() const { void FunctionSignature_Aggregate::InternalSwap(FunctionSignature_Aggregate* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); arguments_.InternalSwap(&other->arguments_); implementations_.InternalSwap(&other->implementations_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, max_set_) + sizeof(FunctionSignature_Aggregate::max_set_) @@ -2151,23 +2041,23 @@ FunctionSignature_Window::_Internal::normal(const FunctionSignature_Window* msg) return *msg->final_variable_behavior_.normal_; } void FunctionSignature_Window::clear_intermediate_type() { - if (GetArena() == nullptr && intermediate_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) { delete intermediate_type_; } intermediate_type_ = nullptr; } void FunctionSignature_Window::clear_output_type() { - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; } void FunctionSignature_Window::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_final_variable_behavior(); if (variadic) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(variadic); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic); if (message_arena != submessage_arena) { variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, variadic, submessage_arena); @@ -2178,11 +2068,11 @@ void FunctionSignature_Window::set_allocated_variadic(::substrait::FunctionSigna // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.variadic) } void FunctionSignature_Window::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_final_variable_behavior(); if (normal) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(normal); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal); if (message_arena != submessage_arena) { normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, normal, submessage_arena); @@ -2192,13 +2082,16 @@ void FunctionSignature_Window::set_allocated_normal(::substrait::FunctionSignatu } // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.normal) } -FunctionSignature_Window::FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +FunctionSignature_Window::FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), arguments_(arena), name_(arena), implementations_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Window) } FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Window& from) @@ -2242,7 +2135,7 @@ FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Windo // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Window) } -void FunctionSignature_Window::SharedCtor() { +inline void FunctionSignature_Window::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&description_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&max_set_) - @@ -2252,12 +2145,13 @@ clear_has_final_variable_behavior(); FunctionSignature_Window::~FunctionSignature_Window() { // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Window) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FunctionSignature_Window::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FunctionSignature_Window::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete description_; if (this != internal_default_instance()) delete intermediate_type_; if (this != internal_default_instance()) delete output_type_; @@ -2280,13 +2174,13 @@ void FunctionSignature_Window::clear_final_variable_behavior() { // @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Window) switch (final_variable_behavior_case()) { case kVariadic: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.variadic_; } break; } case kNormal: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.normal_; } break; @@ -2301,22 +2195,22 @@ void FunctionSignature_Window::clear_final_variable_behavior() { void FunctionSignature_Window::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Window) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; arguments_.Clear(); name_.Clear(); implementations_.Clear(); - if (GetArena() == nullptr && description_ != nullptr) { + if (GetArenaForAllocation() == nullptr && description_ != nullptr) { delete description_; } description_ = nullptr; - if (GetArena() == nullptr && intermediate_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) { delete intermediate_type_; } intermediate_type_ = nullptr; - if (GetArena() == nullptr && output_type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { delete output_type_; } output_type_ = nullptr; @@ -2330,12 +2224,12 @@ void FunctionSignature_Window::Clear() { const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.FunctionSignature.Argument arguments = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -2343,11 +2237,12 @@ const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated string name = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -2357,68 +2252,77 @@ const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.Description description = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool deterministic = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool session_dependent = 8; case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression intermediate_type = 9; case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression output_type = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool ordered = 11; case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { ordered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint64 max_set = 12; case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { max_set_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.Window.WindowType window_type = 14; case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_window_type(static_cast<::substrait::FunctionSignature_Window_WindowType>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.FunctionSignature.Implementation implementations = 15; case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { ptr -= 1; do { ptr += 1; @@ -2426,49 +2330,52 @@ const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.FinalArgVariadic variadic = 16; case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.FinalArgNormal normal = 17; case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FunctionSignature_Window::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Window) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.FunctionSignature.Argument arguments = 2; @@ -2490,7 +2397,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( } // .substrait.FunctionSignature.Description description = 4; - if (this->has_description()) { + if (this->_internal_has_description()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2498,19 +2405,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( } // bool deterministic = 7; - if (this->deterministic() != 0) { + if (this->_internal_deterministic() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target); } // bool session_dependent = 8; - if (this->session_dependent() != 0) { + if (this->_internal_session_dependent() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); } // .substrait.DerivationExpression intermediate_type = 9; - if (this->has_intermediate_type()) { + if (this->_internal_has_intermediate_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2518,7 +2425,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( } // .substrait.DerivationExpression output_type = 10; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2526,19 +2433,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Window::_InternalSerialize( } // bool ordered = 11; - if (this->ordered() != 0) { + if (this->_internal_ordered() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(11, this->_internal_ordered(), target); } // uint64 max_set = 12; - if (this->max_set() != 0) { + if (this->_internal_max_set() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target); } // .substrait.FunctionSignature.Window.WindowType window_type = 14; - if (this->window_type() != 0) { + if (this->_internal_window_type() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 14, this->_internal_window_type(), target); @@ -2580,7 +2487,7 @@ size_t FunctionSignature_Window::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Window) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2607,52 +2514,50 @@ size_t FunctionSignature_Window::ByteSizeLong() const { } // .substrait.FunctionSignature.Description description = 4; - if (this->has_description()) { + if (this->_internal_has_description()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *description_); } // .substrait.DerivationExpression intermediate_type = 9; - if (this->has_intermediate_type()) { + if (this->_internal_has_intermediate_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *intermediate_type_); } // .substrait.DerivationExpression output_type = 10; - if (this->has_output_type()) { + if (this->_internal_has_output_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *output_type_); } // bool deterministic = 7; - if (this->deterministic() != 0) { + if (this->_internal_deterministic() != 0) { total_size += 1 + 1; } // bool session_dependent = 8; - if (this->session_dependent() != 0) { + if (this->_internal_session_dependent() != 0) { total_size += 1 + 1; } // bool ordered = 11; - if (this->ordered() != 0) { + if (this->_internal_ordered() != 0) { total_size += 1 + 1; } // .substrait.FunctionSignature.Window.WindowType window_type = 14; - if (this->window_type() != 0) { + if (this->_internal_window_type() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_window_type()); } // uint64 max_set = 12; - if (this->max_set() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( - this->_internal_max_set()); + if (this->_internal_max_set() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_max_set()); } switch (final_variable_behavior_case()) { @@ -2674,62 +2579,53 @@ size_t FunctionSignature_Window::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FunctionSignature_Window::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Window) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_Window* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Window) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Window) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Window::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FunctionSignature_Window::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Window::GetClassData() const { return &_class_data_; } + +void FunctionSignature_Window::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FunctionSignature_Window::MergeFrom(const FunctionSignature_Window& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Window) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; arguments_.MergeFrom(from.arguments_); name_.MergeFrom(from.name_); implementations_.MergeFrom(from.implementations_); - if (from.has_description()) { + if (from._internal_has_description()) { _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); } - if (from.has_intermediate_type()) { + if (from._internal_has_intermediate_type()) { _internal_mutable_intermediate_type()->::substrait::DerivationExpression::MergeFrom(from._internal_intermediate_type()); } - if (from.has_output_type()) { + if (from._internal_has_output_type()) { _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); } - if (from.deterministic() != 0) { + if (from._internal_deterministic() != 0) { _internal_set_deterministic(from._internal_deterministic()); } - if (from.session_dependent() != 0) { + if (from._internal_session_dependent() != 0) { _internal_set_session_dependent(from._internal_session_dependent()); } - if (from.ordered() != 0) { + if (from._internal_ordered() != 0) { _internal_set_ordered(from._internal_ordered()); } - if (from.window_type() != 0) { + if (from._internal_window_type() != 0) { _internal_set_window_type(from._internal_window_type()); } - if (from.max_set() != 0) { + if (from._internal_max_set() != 0) { _internal_set_max_set(from._internal_max_set()); } switch (from.final_variable_behavior_case()) { @@ -2745,13 +2641,7 @@ void FunctionSignature_Window::MergeFrom(const FunctionSignature_Window& from) { break; } } -} - -void FunctionSignature_Window::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Window) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FunctionSignature_Window::CopyFrom(const FunctionSignature_Window& from) { @@ -2767,7 +2657,7 @@ bool FunctionSignature_Window::IsInitialized() const { void FunctionSignature_Window::InternalSwap(FunctionSignature_Window* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); arguments_.InternalSwap(&other->arguments_); name_.InternalSwap(&other->name_); implementations_.InternalSwap(&other->implementations_); @@ -2793,41 +2683,57 @@ class FunctionSignature_Description::_Internal { public: }; -FunctionSignature_Description::FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +FunctionSignature_Description::FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Description) } FunctionSignature_Description::FunctionSignature_Description(const FunctionSignature_Description& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); language_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_language().empty()) { language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_language(), - GetArena()); + GetArenaForAllocation()); } body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_body().empty()) { body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_body(), - GetArena()); + GetArenaForAllocation()); } // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Description) } -void FunctionSignature_Description::SharedCtor() { +inline void FunctionSignature_Description::SharedCtor() { language_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } FunctionSignature_Description::~FunctionSignature_Description() { // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Description) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FunctionSignature_Description::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FunctionSignature_Description::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); language_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); body_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -2844,7 +2750,7 @@ void FunctionSignature_Description::SetCachedSize(int size) const { void FunctionSignature_Description::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Description) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2856,58 +2762,60 @@ void FunctionSignature_Description::Clear() { const char* FunctionSignature_Description::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string language = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_language(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Description.language")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string body = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { auto str = _internal_mutable_body(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Description.body")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Description::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FunctionSignature_Description::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Description) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string language = 1; - if (this->language().size() > 0) { + if (!this->_internal_language().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_language().data(), static_cast(this->_internal_language().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -2917,7 +2825,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Description::_InternalSerializ } // string body = 2; - if (this->body().size() > 0) { + if (!this->_internal_body().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_body().data(), static_cast(this->_internal_body().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -2938,68 +2846,53 @@ size_t FunctionSignature_Description::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Description) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string language = 1; - if (this->language().size() > 0) { + if (!this->_internal_language().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_language()); } // string body = 2; - if (this->body().size() > 0) { + if (!this->_internal_body().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_body()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FunctionSignature_Description::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Description) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_Description* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Description) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Description) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Description::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FunctionSignature_Description::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Description::GetClassData() const { return &_class_data_; } + +void FunctionSignature_Description::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FunctionSignature_Description::MergeFrom(const FunctionSignature_Description& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Description) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.language().size() > 0) { + if (!from._internal_language().empty()) { _internal_set_language(from._internal_language()); } - if (from.body().size() > 0) { + if (!from._internal_body().empty()) { _internal_set_body(from._internal_body()); } -} - -void FunctionSignature_Description::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Description) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FunctionSignature_Description::CopyFrom(const FunctionSignature_Description& from) { @@ -3015,9 +2908,19 @@ bool FunctionSignature_Description::IsInitialized() const { void FunctionSignature_Description::InternalSwap(FunctionSignature_Description* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - language_.Swap(&other->language_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); - body_.Swap(&other->body_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &language_, lhs_arena, + &other->language_, rhs_arena + ); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &body_, lhs_arena, + &other->body_, rhs_arena + ); } ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Description::GetMetadata() const { @@ -3032,37 +2935,47 @@ class FunctionSignature_Implementation::_Internal { public: }; -FunctionSignature_Implementation::FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +FunctionSignature_Implementation::FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Implementation) } FunctionSignature_Implementation::FunctionSignature_Implementation(const FunctionSignature_Implementation& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_uri().empty()) { uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), - GetArena()); + GetArenaForAllocation()); } type_ = from.type_; // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Implementation) } -void FunctionSignature_Implementation::SharedCtor() { +inline void FunctionSignature_Implementation::SharedCtor() { uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING type_ = 0; } FunctionSignature_Implementation::~FunctionSignature_Implementation() { // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Implementation) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FunctionSignature_Implementation::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FunctionSignature_Implementation::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -3078,7 +2991,7 @@ void FunctionSignature_Implementation::SetCachedSize(int size) const { void FunctionSignature_Implementation::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Implementation) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3090,64 +3003,66 @@ void FunctionSignature_Implementation::Clear() { const char* FunctionSignature_Implementation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.FunctionSignature.Implementation.Type type = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_type(static_cast<::substrait::FunctionSignature_Implementation_Type>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string uri = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { auto str = _internal_mutable_uri(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Implementation.uri")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Implementation::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FunctionSignature_Implementation::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Implementation) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.FunctionSignature.Implementation.Type type = 1; - if (this->type() != 0) { + if (this->_internal_type() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_type(), target); } // string uri = 2; - if (this->uri().size() > 0) { + if (!this->_internal_uri().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_uri().data(), static_cast(this->_internal_uri().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -3168,67 +3083,52 @@ size_t FunctionSignature_Implementation::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Implementation) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string uri = 2; - if (this->uri().size() > 0) { + if (!this->_internal_uri().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_uri()); } // .substrait.FunctionSignature.Implementation.Type type = 1; - if (this->type() != 0) { + if (this->_internal_type() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FunctionSignature_Implementation::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Implementation) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_Implementation* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Implementation) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Implementation) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Implementation::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FunctionSignature_Implementation::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Implementation::GetClassData() const { return &_class_data_; } + +void FunctionSignature_Implementation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FunctionSignature_Implementation::MergeFrom(const FunctionSignature_Implementation& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Implementation) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.uri().size() > 0) { + if (!from._internal_uri().empty()) { _internal_set_uri(from._internal_uri()); } - if (from.type() != 0) { + if (from._internal_type() != 0) { _internal_set_type(from._internal_type()); } -} - -void FunctionSignature_Implementation::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Implementation) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FunctionSignature_Implementation::CopyFrom(const FunctionSignature_Implementation& from) { @@ -3244,8 +3144,14 @@ bool FunctionSignature_Implementation::IsInitialized() const { void FunctionSignature_Implementation::InternalSwap(FunctionSignature_Implementation* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - uri_.Swap(&other->uri_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &uri_, lhs_arena, + &other->uri_, rhs_arena + ); swap(type_, other->type_); } @@ -3267,15 +3173,18 @@ FunctionSignature_Argument_ValueArgument::_Internal::type(const FunctionSignatur return *msg->type_; } void FunctionSignature_Argument_ValueArgument::clear_type() { - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; } -FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.ValueArgument) } FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(const FunctionSignature_Argument_ValueArgument& from) @@ -3290,7 +3199,7 @@ FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgume // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.ValueArgument) } -void FunctionSignature_Argument_ValueArgument::SharedCtor() { +inline void FunctionSignature_Argument_ValueArgument::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&constant_) - @@ -3299,12 +3208,13 @@ ::memset(reinterpret_cast(this) + static_cast( FunctionSignature_Argument_ValueArgument::~FunctionSignature_Argument_ValueArgument() { // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.ValueArgument) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FunctionSignature_Argument_ValueArgument::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FunctionSignature_Argument_ValueArgument::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete type_; } @@ -3320,11 +3230,11 @@ void FunctionSignature_Argument_ValueArgument::SetCachedSize(int size) const { void FunctionSignature_Argument_ValueArgument::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.ValueArgument) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; @@ -3335,54 +3245,56 @@ void FunctionSignature_Argument_ValueArgument::Clear() { const char* FunctionSignature_Argument_ValueArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.ParameterizedType type = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool constant = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { constant_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_ValueArgument::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FunctionSignature_Argument_ValueArgument::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.ValueArgument) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.ParameterizedType type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3390,7 +3302,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_ValueArgument::_Inter } // bool constant = 2; - if (this->constant() != 0) { + if (this->_internal_constant() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_constant(), target); } @@ -3407,66 +3319,51 @@ size_t FunctionSignature_Argument_ValueArgument::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.ValueArgument) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.ParameterizedType type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *type_); } // bool constant = 2; - if (this->constant() != 0) { + if (this->_internal_constant() != 0) { total_size += 1 + 1; } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FunctionSignature_Argument_ValueArgument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Argument.ValueArgument) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_Argument_ValueArgument* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Argument.ValueArgument) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Argument.ValueArgument) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument_ValueArgument::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FunctionSignature_Argument_ValueArgument::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument_ValueArgument::GetClassData() const { return &_class_data_; } + +void FunctionSignature_Argument_ValueArgument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FunctionSignature_Argument_ValueArgument::MergeFrom(const FunctionSignature_Argument_ValueArgument& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.ValueArgument) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_type()) { + if (from._internal_has_type()) { _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type()); } - if (from.constant() != 0) { + if (from._internal_constant() != 0) { _internal_set_constant(from._internal_constant()); } -} - -void FunctionSignature_Argument_ValueArgument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Argument.ValueArgument) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FunctionSignature_Argument_ValueArgument::CopyFrom(const FunctionSignature_Argument_ValueArgument& from) { @@ -3482,7 +3379,7 @@ bool FunctionSignature_Argument_ValueArgument::IsInitialized() const { void FunctionSignature_Argument_ValueArgument::InternalSwap(FunctionSignature_Argument_ValueArgument* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(FunctionSignature_Argument_ValueArgument, constant_) + sizeof(FunctionSignature_Argument_ValueArgument::constant_) @@ -3509,15 +3406,18 @@ FunctionSignature_Argument_TypeArgument::_Internal::type(const FunctionSignature return *msg->type_; } void FunctionSignature_Argument_TypeArgument::clear_type() { - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; } -FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.TypeArgument) } FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(const FunctionSignature_Argument_TypeArgument& from) @@ -3531,18 +3431,19 @@ FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.TypeArgument) } -void FunctionSignature_Argument_TypeArgument::SharedCtor() { +inline void FunctionSignature_Argument_TypeArgument::SharedCtor() { type_ = nullptr; } FunctionSignature_Argument_TypeArgument::~FunctionSignature_Argument_TypeArgument() { // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.TypeArgument) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FunctionSignature_Argument_TypeArgument::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FunctionSignature_Argument_TypeArgument::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete type_; } @@ -3558,11 +3459,11 @@ void FunctionSignature_Argument_TypeArgument::SetCachedSize(int size) const { void FunctionSignature_Argument_TypeArgument::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.TypeArgument) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; @@ -3572,47 +3473,48 @@ void FunctionSignature_Argument_TypeArgument::Clear() { const char* FunctionSignature_Argument_TypeArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.ParameterizedType type = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_TypeArgument::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FunctionSignature_Argument_TypeArgument::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.TypeArgument) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.ParameterizedType type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3631,58 +3533,43 @@ size_t FunctionSignature_Argument_TypeArgument::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.TypeArgument) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.ParameterizedType type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *type_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FunctionSignature_Argument_TypeArgument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Argument.TypeArgument) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_Argument_TypeArgument* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Argument.TypeArgument) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Argument.TypeArgument) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument_TypeArgument::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FunctionSignature_Argument_TypeArgument::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument_TypeArgument::GetClassData() const { return &_class_data_; } + +void FunctionSignature_Argument_TypeArgument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FunctionSignature_Argument_TypeArgument::MergeFrom(const FunctionSignature_Argument_TypeArgument& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.TypeArgument) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_type()) { + if (from._internal_has_type()) { _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type()); } -} - -void FunctionSignature_Argument_TypeArgument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Argument.TypeArgument) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FunctionSignature_Argument_TypeArgument::CopyFrom(const FunctionSignature_Argument_TypeArgument& from) { @@ -3698,7 +3585,7 @@ bool FunctionSignature_Argument_TypeArgument::IsInitialized() const { void FunctionSignature_Argument_TypeArgument::InternalSwap(FunctionSignature_Argument_TypeArgument* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(type_, other->type_); } @@ -3714,11 +3601,14 @@ class FunctionSignature_Argument_EnumArgument::_Internal { public: }; -FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), options_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.EnumArgument) } FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(const FunctionSignature_Argument_EnumArgument& from) @@ -3729,18 +3619,19 @@ FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.EnumArgument) } -void FunctionSignature_Argument_EnumArgument::SharedCtor() { +inline void FunctionSignature_Argument_EnumArgument::SharedCtor() { optional_ = false; } FunctionSignature_Argument_EnumArgument::~FunctionSignature_Argument_EnumArgument() { // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.EnumArgument) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FunctionSignature_Argument_EnumArgument::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FunctionSignature_Argument_EnumArgument::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void FunctionSignature_Argument_EnumArgument::ArenaDtor(void* object) { @@ -3755,7 +3646,7 @@ void FunctionSignature_Argument_EnumArgument::SetCachedSize(int size) const { void FunctionSignature_Argument_EnumArgument::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.EnumArgument) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3767,12 +3658,12 @@ void FunctionSignature_Argument_EnumArgument::Clear() { const char* FunctionSignature_Argument_EnumArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated string options = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -3782,42 +3673,44 @@ const char* FunctionSignature_Argument_EnumArgument::_InternalParse(const char* CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // bool optional = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { optional_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_EnumArgument::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FunctionSignature_Argument_EnumArgument::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.EnumArgument) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated string options = 1; @@ -3831,7 +3724,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument_EnumArgument::_Intern } // bool optional = 2; - if (this->optional() != 0) { + if (this->_internal_optional() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_optional(), target); } @@ -3848,7 +3741,7 @@ size_t FunctionSignature_Argument_EnumArgument::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.EnumArgument) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3861,52 +3754,37 @@ size_t FunctionSignature_Argument_EnumArgument::ByteSizeLong() const { } // bool optional = 2; - if (this->optional() != 0) { + if (this->_internal_optional() != 0) { total_size += 1 + 1; } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FunctionSignature_Argument_EnumArgument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Argument.EnumArgument) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_Argument_EnumArgument* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Argument.EnumArgument) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Argument.EnumArgument) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument_EnumArgument::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FunctionSignature_Argument_EnumArgument::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument_EnumArgument::GetClassData() const { return &_class_data_; } + +void FunctionSignature_Argument_EnumArgument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FunctionSignature_Argument_EnumArgument::MergeFrom(const FunctionSignature_Argument_EnumArgument& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.EnumArgument) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; options_.MergeFrom(from.options_); - if (from.optional() != 0) { + if (from._internal_optional() != 0) { _internal_set_optional(from._internal_optional()); } -} - -void FunctionSignature_Argument_EnumArgument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Argument.EnumArgument) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FunctionSignature_Argument_EnumArgument::CopyFrom(const FunctionSignature_Argument_EnumArgument& from) { @@ -3922,7 +3800,7 @@ bool FunctionSignature_Argument_EnumArgument::IsInitialized() const { void FunctionSignature_Argument_EnumArgument::InternalSwap(FunctionSignature_Argument_EnumArgument* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); options_.InternalSwap(&other->options_); swap(optional_, other->optional_); } @@ -3955,11 +3833,11 @@ FunctionSignature_Argument::_Internal::enum_(const FunctionSignature_Argument* m return *msg->argument_kind_.enum__; } void FunctionSignature_Argument::set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_argument_kind(); if (value) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_ValueArgument>::GetOwningArena(value); if (message_arena != submessage_arena) { value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, value, submessage_arena); @@ -3970,11 +3848,11 @@ void FunctionSignature_Argument::set_allocated_value(::substrait::FunctionSignat // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.value) } void FunctionSignature_Argument::set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_argument_kind(); if (type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_TypeArgument>::GetOwningArena(type); if (message_arena != submessage_arena) { type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type, submessage_arena); @@ -3985,11 +3863,11 @@ void FunctionSignature_Argument::set_allocated_type(::substrait::FunctionSignatu // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.type) } void FunctionSignature_Argument::set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_argument_kind(); if (enum_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(enum_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_EnumArgument>::GetOwningArena(enum_); if (message_arena != submessage_arena) { enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, enum_, submessage_arena); @@ -3999,19 +3877,25 @@ void FunctionSignature_Argument::set_allocated_enum_(::substrait::FunctionSignat } // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.enum) } -FunctionSignature_Argument::FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +FunctionSignature_Argument::FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument) } FunctionSignature_Argument::FunctionSignature_Argument(const FunctionSignature_Argument& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_name().empty()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); + GetArenaForAllocation()); } clear_has_argument_kind(); switch (from.argument_kind_case()) { @@ -4034,19 +3918,23 @@ FunctionSignature_Argument::FunctionSignature_Argument(const FunctionSignature_A // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument) } -void FunctionSignature_Argument::SharedCtor() { +inline void FunctionSignature_Argument::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING clear_has_argument_kind(); } FunctionSignature_Argument::~FunctionSignature_Argument() { // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FunctionSignature_Argument::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FunctionSignature_Argument::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (has_argument_kind()) { clear_argument_kind(); @@ -4067,19 +3955,19 @@ void FunctionSignature_Argument::clear_argument_kind() { // @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Argument) switch (argument_kind_case()) { case kValue: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete argument_kind_.value_; } break; } case kType: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete argument_kind_.type_; } break; } case kEnum: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete argument_kind_.enum__; } break; @@ -4094,7 +3982,7 @@ void FunctionSignature_Argument::clear_argument_kind() { void FunctionSignature_Argument::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4106,70 +3994,74 @@ void FunctionSignature_Argument::Clear() { const char* FunctionSignature_Argument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Argument.name")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.Argument.ValueArgument value = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.Argument.TypeArgument type = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FunctionSignature.Argument.EnumArgument enum = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature_Argument::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FunctionSignature_Argument::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -4214,12 +4106,12 @@ size_t FunctionSignature_Argument::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string name = 1; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); @@ -4251,38 +4143,29 @@ size_t FunctionSignature_Argument::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FunctionSignature_Argument::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature.Argument) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature_Argument* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature.Argument) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature.Argument) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FunctionSignature_Argument::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument::GetClassData() const { return &_class_data_; } + +void FunctionSignature_Argument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FunctionSignature_Argument::MergeFrom(const FunctionSignature_Argument& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.name().size() > 0) { + if (!from._internal_name().empty()) { _internal_set_name(from._internal_name()); } switch (from.argument_kind_case()) { @@ -4302,13 +4185,7 @@ void FunctionSignature_Argument::MergeFrom(const FunctionSignature_Argument& fro break; } } -} - -void FunctionSignature_Argument::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature.Argument) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FunctionSignature_Argument::CopyFrom(const FunctionSignature_Argument& from) { @@ -4324,8 +4201,14 @@ bool FunctionSignature_Argument::IsInitialized() const { void FunctionSignature_Argument::InternalSwap(FunctionSignature_Argument* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); swap(argument_kind_, other->argument_kind_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -4342,151 +4225,32 @@ class FunctionSignature::_Internal { public: }; -FunctionSignature::FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); +FunctionSignature::FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature) } FunctionSignature::FunctionSignature(const FunctionSignature& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature) } -void FunctionSignature::SharedCtor() { -} -FunctionSignature::~FunctionSignature() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void FunctionSignature::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void FunctionSignature::ArenaDtor(void* object) { - FunctionSignature* _this = reinterpret_cast< FunctionSignature* >(object); - (void)_this; -} -void FunctionSignature::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature::SetCachedSize(int size) const { - _cached_size_.Set(size); -} -void FunctionSignature::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} -const char* FunctionSignature::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* FunctionSignature::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature) - return target; -} - -size_t FunctionSignature::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature) - size_t total_size = 0; - - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature::GetClassData() const { return &_class_data_; } -void FunctionSignature::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FunctionSignature) - GOOGLE_DCHECK_NE(&from, this); - const FunctionSignature* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FunctionSignature) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FunctionSignature) - MergeFrom(*source); - } -} -void FunctionSignature::MergeFrom(const FunctionSignature& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; -} - -void FunctionSignature::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FunctionSignature) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -void FunctionSignature::CopyFrom(const FunctionSignature& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -bool FunctionSignature::IsInitialized() const { - return true; -} -void FunctionSignature::InternalSwap(FunctionSignature* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); -} ::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( diff --git a/cpp/src/generated/substrait/function.pb.h b/cpp/src/generated/substrait/function.pb.h index d9e2e5669d7..e566263d2f6 100644 --- a/cpp/src/generated/substrait/function.pb.h +++ b/cpp/src/generated/substrait/function.pb.h @@ -8,12 +8,12 @@ #include #include -#if PROTOBUF_VERSION < 3016000 +#if PROTOBUF_VERSION < 3019000 #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 3016000 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019003 < 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. @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -54,7 +55,7 @@ struct TableStruct_substrait_2ffunction_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; + static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ffunction_2eproto; namespace substrait { @@ -115,8 +116,8 @@ enum FunctionSignature_FinalArgVariadic_ParameterConsistency : int { FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED = 0, FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_CONSISTENT = 1, FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT = 2, - FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value); constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN = FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED; @@ -141,8 +142,8 @@ enum FunctionSignature_Window_WindowType : int { FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED = 0, FunctionSignature_Window_WindowType_WINDOW_TYPE_STREAMING = 1, FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION = 2, - FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool FunctionSignature_Window_WindowType_IsValid(int value); constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MIN = FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED; @@ -167,8 +168,8 @@ enum FunctionSignature_Implementation_Type : int { FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED = 0, FunctionSignature_Implementation_Type_TYPE_WEB_ASSEMBLY = 1, FunctionSignature_Implementation_Type_TYPE_TRINO_JAR = 2, - FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool FunctionSignature_Implementation_Type_IsValid(int value); constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MIN = FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED; @@ -191,7 +192,7 @@ inline bool FunctionSignature_Implementation_Type_Parse( } // =================================================================== -class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : +class FunctionSignature_FinalArgVariadic final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgVariadic) */ { public: inline FunctionSignature_FinalArgVariadic() : FunctionSignature_FinalArgVariadic(nullptr) {} @@ -209,8 +210,13 @@ class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : return *this; } inline FunctionSignature_FinalArgVariadic& operator=(FunctionSignature_FinalArgVariadic&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -241,7 +247,12 @@ class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : } inline void Swap(FunctionSignature_FinalArgVariadic* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -249,48 +260,53 @@ class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_FinalArgVariadic* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_FinalArgVariadic* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_FinalArgVariadic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_FinalArgVariadic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionSignature_FinalArgVariadic& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FunctionSignature_FinalArgVariadic& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionSignature_FinalArgVariadic* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.FinalArgVariadic"; } protected: - explicit FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -336,20 +352,20 @@ class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : }; // int64 min_args = 1; void clear_min_args(); - ::PROTOBUF_NAMESPACE_ID::int64 min_args() const; - void set_min_args(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t min_args() const; + void set_min_args(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_min_args() const; - void _internal_set_min_args(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_min_args() const; + void _internal_set_min_args(int64_t value); public: // int64 max_args = 2; void clear_max_args(); - ::PROTOBUF_NAMESPACE_ID::int64 max_args() const; - void set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t max_args() const; + void set_max_args(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_max_args() const; - void _internal_set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_max_args() const; + void _internal_set_max_args(int64_t value); public: // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; @@ -368,19 +384,18 @@ class FunctionSignature_FinalArgVariadic PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int64 min_args_; - ::PROTOBUF_NAMESPACE_ID::int64 max_args_; + int64_t min_args_; + int64_t max_args_; int consistency_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- -class FunctionSignature_FinalArgNormal PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgNormal) */ { +class FunctionSignature_FinalArgNormal final : + public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgNormal) */ { public: inline FunctionSignature_FinalArgNormal() : FunctionSignature_FinalArgNormal(nullptr) {} - ~FunctionSignature_FinalArgNormal() override; explicit constexpr FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); FunctionSignature_FinalArgNormal(const FunctionSignature_FinalArgNormal& from); @@ -394,8 +409,13 @@ class FunctionSignature_FinalArgNormal PROTOBUF_FINAL : return *this; } inline FunctionSignature_FinalArgNormal& operator=(FunctionSignature_FinalArgNormal&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -426,7 +446,12 @@ class FunctionSignature_FinalArgNormal PROTOBUF_FINAL : } inline void Swap(FunctionSignature_FinalArgNormal* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -434,48 +459,39 @@ class FunctionSignature_FinalArgNormal PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_FinalArgNormal* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_FinalArgNormal* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_FinalArgNormal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_FinalArgNormal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const FunctionSignature_FinalArgNormal& from); - void MergeFrom(const FunctionSignature_FinalArgNormal& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const FunctionSignature_FinalArgNormal& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const FunctionSignature_FinalArgNormal& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); + } + public: private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_FinalArgNormal* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.FinalArgNormal"; } protected: - explicit FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -494,7 +510,7 @@ class FunctionSignature_FinalArgNormal PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class FunctionSignature_Scalar PROTOBUF_FINAL : +class FunctionSignature_Scalar final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Scalar) */ { public: inline FunctionSignature_Scalar() : FunctionSignature_Scalar(nullptr) {} @@ -512,8 +528,13 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : return *this; } inline FunctionSignature_Scalar& operator=(FunctionSignature_Scalar&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -550,7 +571,12 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : } inline void Swap(FunctionSignature_Scalar* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -558,48 +584,53 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_Scalar* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_Scalar* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_Scalar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_Scalar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionSignature_Scalar& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FunctionSignature_Scalar& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionSignature_Scalar* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.Scalar"; } protected: - explicit FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -684,7 +715,7 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : public: void clear_description(); const ::substrait::FunctionSignature_Description& description() const; - ::substrait::FunctionSignature_Description* release_description(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description(); ::substrait::FunctionSignature_Description* mutable_description(); void set_allocated_description(::substrait::FunctionSignature_Description* description); private: @@ -702,7 +733,7 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : public: void clear_output_type(); const ::substrait::DerivationExpression& output_type() const; - ::substrait::DerivationExpression* release_output_type(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type(); ::substrait::DerivationExpression* mutable_output_type(); void set_allocated_output_type(::substrait::DerivationExpression* output_type); private: @@ -738,7 +769,7 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : public: void clear_variadic(); const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const; - ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic); private: @@ -756,7 +787,7 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : public: void clear_normal(); const ::substrait::FunctionSignature_FinalArgNormal& normal() const; - ::substrait::FunctionSignature_FinalArgNormal* release_normal(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal(); ::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal); private: @@ -795,13 +826,13 @@ class FunctionSignature_Scalar PROTOBUF_FINAL : ::substrait::FunctionSignature_FinalArgNormal* normal_; } final_variable_behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- -class FunctionSignature_Aggregate PROTOBUF_FINAL : +class FunctionSignature_Aggregate final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Aggregate) */ { public: inline FunctionSignature_Aggregate() : FunctionSignature_Aggregate(nullptr) {} @@ -819,8 +850,13 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : return *this; } inline FunctionSignature_Aggregate& operator=(FunctionSignature_Aggregate&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -857,7 +893,12 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : } inline void Swap(FunctionSignature_Aggregate* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -865,48 +906,53 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_Aggregate* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_Aggregate* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_Aggregate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_Aggregate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionSignature_Aggregate& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FunctionSignature_Aggregate& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionSignature_Aggregate* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.Aggregate"; } protected: - explicit FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -969,11 +1015,11 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); - std::string* release_name(); + PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: @@ -984,7 +1030,7 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : public: void clear_description(); const ::substrait::FunctionSignature_Description& description() const; - ::substrait::FunctionSignature_Description* release_description(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description(); ::substrait::FunctionSignature_Description* mutable_description(); void set_allocated_description(::substrait::FunctionSignature_Description* description); private: @@ -1002,7 +1048,7 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : public: void clear_output_type(); const ::substrait::DerivationExpression& output_type() const; - ::substrait::DerivationExpression* release_output_type(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type(); ::substrait::DerivationExpression* mutable_output_type(); void set_allocated_output_type(::substrait::DerivationExpression* output_type); private: @@ -1020,7 +1066,7 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : public: void clear_intermediate_type(); const ::substrait::Type& intermediate_type() const; - ::substrait::Type* release_intermediate_type(); + PROTOBUF_NODISCARD ::substrait::Type* release_intermediate_type(); ::substrait::Type* mutable_intermediate_type(); void set_allocated_intermediate_type(::substrait::Type* intermediate_type); private: @@ -1060,11 +1106,11 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : // uint64 max_set = 12; void clear_max_set(); - ::PROTOBUF_NAMESPACE_ID::uint64 max_set() const; - void set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); + uint64_t max_set() const; + void set_max_set(uint64_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_max_set() const; - void _internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); + uint64_t _internal_max_set() const; + void _internal_set_max_set(uint64_t value); public: // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; @@ -1074,7 +1120,7 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : public: void clear_variadic(); const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const; - ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic); private: @@ -1092,7 +1138,7 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : public: void clear_normal(); const ::substrait::FunctionSignature_FinalArgNormal& normal() const; - ::substrait::FunctionSignature_FinalArgNormal* release_normal(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal(); ::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal); private: @@ -1126,7 +1172,7 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : bool deterministic_; bool session_dependent_; bool ordered_; - ::PROTOBUF_NAMESPACE_ID::uint64 max_set_; + uint64_t max_set_; union FinalVariableBehaviorUnion { constexpr FinalVariableBehaviorUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; @@ -1134,13 +1180,13 @@ class FunctionSignature_Aggregate PROTOBUF_FINAL : ::substrait::FunctionSignature_FinalArgNormal* normal_; } final_variable_behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- -class FunctionSignature_Window PROTOBUF_FINAL : +class FunctionSignature_Window final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Window) */ { public: inline FunctionSignature_Window() : FunctionSignature_Window(nullptr) {} @@ -1158,8 +1204,13 @@ class FunctionSignature_Window PROTOBUF_FINAL : return *this; } inline FunctionSignature_Window& operator=(FunctionSignature_Window&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1196,7 +1247,12 @@ class FunctionSignature_Window PROTOBUF_FINAL : } inline void Swap(FunctionSignature_Window* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1204,48 +1260,53 @@ class FunctionSignature_Window PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_Window* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_Window* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_Window* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_Window* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionSignature_Window& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FunctionSignature_Window& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionSignature_Window* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.Window"; } protected: - explicit FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1366,7 +1427,7 @@ class FunctionSignature_Window PROTOBUF_FINAL : public: void clear_description(); const ::substrait::FunctionSignature_Description& description() const; - ::substrait::FunctionSignature_Description* release_description(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description(); ::substrait::FunctionSignature_Description* mutable_description(); void set_allocated_description(::substrait::FunctionSignature_Description* description); private: @@ -1384,7 +1445,7 @@ class FunctionSignature_Window PROTOBUF_FINAL : public: void clear_intermediate_type(); const ::substrait::DerivationExpression& intermediate_type() const; - ::substrait::DerivationExpression* release_intermediate_type(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_intermediate_type(); ::substrait::DerivationExpression* mutable_intermediate_type(); void set_allocated_intermediate_type(::substrait::DerivationExpression* intermediate_type); private: @@ -1402,7 +1463,7 @@ class FunctionSignature_Window PROTOBUF_FINAL : public: void clear_output_type(); const ::substrait::DerivationExpression& output_type() const; - ::substrait::DerivationExpression* release_output_type(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type(); ::substrait::DerivationExpression* mutable_output_type(); void set_allocated_output_type(::substrait::DerivationExpression* output_type); private: @@ -1451,11 +1512,11 @@ class FunctionSignature_Window PROTOBUF_FINAL : // uint64 max_set = 12; void clear_max_set(); - ::PROTOBUF_NAMESPACE_ID::uint64 max_set() const; - void set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); + uint64_t max_set() const; + void set_max_set(uint64_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_max_set() const; - void _internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value); + uint64_t _internal_max_set() const; + void _internal_set_max_set(uint64_t value); public: // .substrait.FunctionSignature.FinalArgVariadic variadic = 16; @@ -1465,7 +1526,7 @@ class FunctionSignature_Window PROTOBUF_FINAL : public: void clear_variadic(); const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const; - ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic); private: @@ -1483,7 +1544,7 @@ class FunctionSignature_Window PROTOBUF_FINAL : public: void clear_normal(); const ::substrait::FunctionSignature_FinalArgNormal& normal() const; - ::substrait::FunctionSignature_FinalArgNormal* release_normal(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal(); ::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal); private: @@ -1518,7 +1579,7 @@ class FunctionSignature_Window PROTOBUF_FINAL : bool session_dependent_; bool ordered_; int window_type_; - ::PROTOBUF_NAMESPACE_ID::uint64 max_set_; + uint64_t max_set_; union FinalVariableBehaviorUnion { constexpr FinalVariableBehaviorUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; @@ -1526,13 +1587,13 @@ class FunctionSignature_Window PROTOBUF_FINAL : ::substrait::FunctionSignature_FinalArgNormal* normal_; } final_variable_behavior_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- -class FunctionSignature_Description PROTOBUF_FINAL : +class FunctionSignature_Description final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Description) */ { public: inline FunctionSignature_Description() : FunctionSignature_Description(nullptr) {} @@ -1550,8 +1611,13 @@ class FunctionSignature_Description PROTOBUF_FINAL : return *this; } inline FunctionSignature_Description& operator=(FunctionSignature_Description&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1582,7 +1648,12 @@ class FunctionSignature_Description PROTOBUF_FINAL : } inline void Swap(FunctionSignature_Description* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1590,48 +1661,53 @@ class FunctionSignature_Description PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_Description* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_Description* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_Description* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_Description* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionSignature_Description& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FunctionSignature_Description& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionSignature_Description* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.Description"; } protected: - explicit FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1648,11 +1724,11 @@ class FunctionSignature_Description PROTOBUF_FINAL : template void set_language(ArgT0&& arg0, ArgT... args); std::string* mutable_language(); - std::string* release_language(); + PROTOBUF_NODISCARD std::string* release_language(); void set_allocated_language(std::string* language); private: const std::string& _internal_language() const; - void _internal_set_language(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_language(const std::string& value); std::string* _internal_mutable_language(); public: @@ -1662,11 +1738,11 @@ class FunctionSignature_Description PROTOBUF_FINAL : template void set_body(ArgT0&& arg0, ArgT... args); std::string* mutable_body(); - std::string* release_body(); + PROTOBUF_NODISCARD std::string* release_body(); void set_allocated_body(std::string* body); private: const std::string& _internal_body() const; - void _internal_set_body(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value); std::string* _internal_mutable_body(); public: @@ -1684,7 +1760,7 @@ class FunctionSignature_Description PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class FunctionSignature_Implementation PROTOBUF_FINAL : +class FunctionSignature_Implementation final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Implementation) */ { public: inline FunctionSignature_Implementation() : FunctionSignature_Implementation(nullptr) {} @@ -1702,8 +1778,13 @@ class FunctionSignature_Implementation PROTOBUF_FINAL : return *this; } inline FunctionSignature_Implementation& operator=(FunctionSignature_Implementation&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1734,7 +1815,12 @@ class FunctionSignature_Implementation PROTOBUF_FINAL : } inline void Swap(FunctionSignature_Implementation* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1742,48 +1828,53 @@ class FunctionSignature_Implementation PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_Implementation* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_Implementation* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_Implementation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_Implementation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionSignature_Implementation& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FunctionSignature_Implementation& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionSignature_Implementation* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.Implementation"; } protected: - explicit FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1832,11 +1923,11 @@ class FunctionSignature_Implementation PROTOBUF_FINAL : template void set_uri(ArgT0&& arg0, ArgT... args); std::string* mutable_uri(); - std::string* release_uri(); + PROTOBUF_NODISCARD std::string* release_uri(); void set_allocated_uri(std::string* uri); private: const std::string& _internal_uri() const; - void _internal_set_uri(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value); std::string* _internal_mutable_uri(); public: @@ -1863,7 +1954,7 @@ class FunctionSignature_Implementation PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : +class FunctionSignature_Argument_ValueArgument final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.ValueArgument) */ { public: inline FunctionSignature_Argument_ValueArgument() : FunctionSignature_Argument_ValueArgument(nullptr) {} @@ -1881,8 +1972,13 @@ class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : return *this; } inline FunctionSignature_Argument_ValueArgument& operator=(FunctionSignature_Argument_ValueArgument&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1913,7 +2009,12 @@ class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : } inline void Swap(FunctionSignature_Argument_ValueArgument* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1921,48 +2022,53 @@ class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_Argument_ValueArgument* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_Argument_ValueArgument* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_Argument_ValueArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_Argument_ValueArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionSignature_Argument_ValueArgument& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FunctionSignature_Argument_ValueArgument& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionSignature_Argument_ValueArgument* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.Argument.ValueArgument"; } protected: - explicit FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1980,7 +2086,7 @@ class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : public: void clear_type(); const ::substrait::ParameterizedType& type() const; - ::substrait::ParameterizedType* release_type(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type(); ::substrait::ParameterizedType* mutable_type(); void set_allocated_type(::substrait::ParameterizedType* type); private: @@ -2014,7 +2120,7 @@ class FunctionSignature_Argument_ValueArgument PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class FunctionSignature_Argument_TypeArgument PROTOBUF_FINAL : +class FunctionSignature_Argument_TypeArgument final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.TypeArgument) */ { public: inline FunctionSignature_Argument_TypeArgument() : FunctionSignature_Argument_TypeArgument(nullptr) {} @@ -2032,8 +2138,13 @@ class FunctionSignature_Argument_TypeArgument PROTOBUF_FINAL : return *this; } inline FunctionSignature_Argument_TypeArgument& operator=(FunctionSignature_Argument_TypeArgument&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2064,7 +2175,12 @@ class FunctionSignature_Argument_TypeArgument PROTOBUF_FINAL : } inline void Swap(FunctionSignature_Argument_TypeArgument* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2072,48 +2188,53 @@ class FunctionSignature_Argument_TypeArgument PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_Argument_TypeArgument* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_Argument_TypeArgument* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_Argument_TypeArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_Argument_TypeArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionSignature_Argument_TypeArgument& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FunctionSignature_Argument_TypeArgument& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionSignature_Argument_TypeArgument* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.Argument.TypeArgument"; } protected: - explicit FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2130,7 +2251,7 @@ class FunctionSignature_Argument_TypeArgument PROTOBUF_FINAL : public: void clear_type(); const ::substrait::ParameterizedType& type() const; - ::substrait::ParameterizedType* release_type(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type(); ::substrait::ParameterizedType* mutable_type(); void set_allocated_type(::substrait::ParameterizedType* type); private: @@ -2154,7 +2275,7 @@ class FunctionSignature_Argument_TypeArgument PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class FunctionSignature_Argument_EnumArgument PROTOBUF_FINAL : +class FunctionSignature_Argument_EnumArgument final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.EnumArgument) */ { public: inline FunctionSignature_Argument_EnumArgument() : FunctionSignature_Argument_EnumArgument(nullptr) {} @@ -2172,8 +2293,13 @@ class FunctionSignature_Argument_EnumArgument PROTOBUF_FINAL : return *this; } inline FunctionSignature_Argument_EnumArgument& operator=(FunctionSignature_Argument_EnumArgument&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2204,7 +2330,12 @@ class FunctionSignature_Argument_EnumArgument PROTOBUF_FINAL : } inline void Swap(FunctionSignature_Argument_EnumArgument* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2212,48 +2343,53 @@ class FunctionSignature_Argument_EnumArgument PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_Argument_EnumArgument* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_Argument_EnumArgument* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_Argument_EnumArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_Argument_EnumArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionSignature_Argument_EnumArgument& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FunctionSignature_Argument_EnumArgument& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionSignature_Argument_EnumArgument* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.Argument.EnumArgument"; } protected: - explicit FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2311,7 +2447,7 @@ class FunctionSignature_Argument_EnumArgument PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class FunctionSignature_Argument PROTOBUF_FINAL : +class FunctionSignature_Argument final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument) */ { public: inline FunctionSignature_Argument() : FunctionSignature_Argument(nullptr) {} @@ -2329,8 +2465,13 @@ class FunctionSignature_Argument PROTOBUF_FINAL : return *this; } inline FunctionSignature_Argument& operator=(FunctionSignature_Argument&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2368,7 +2509,12 @@ class FunctionSignature_Argument PROTOBUF_FINAL : } inline void Swap(FunctionSignature_Argument* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2376,48 +2522,53 @@ class FunctionSignature_Argument PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature_Argument* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature_Argument* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature_Argument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature_Argument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FunctionSignature_Argument& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FunctionSignature_Argument& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FunctionSignature_Argument* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature.Argument"; } protected: - explicit FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2440,11 +2591,11 @@ class FunctionSignature_Argument PROTOBUF_FINAL : template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); - std::string* release_name(); + PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: @@ -2455,7 +2606,7 @@ class FunctionSignature_Argument PROTOBUF_FINAL : public: void clear_value(); const ::substrait::FunctionSignature_Argument_ValueArgument& value() const; - ::substrait::FunctionSignature_Argument_ValueArgument* release_value(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_ValueArgument* release_value(); ::substrait::FunctionSignature_Argument_ValueArgument* mutable_value(); void set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value); private: @@ -2473,7 +2624,7 @@ class FunctionSignature_Argument PROTOBUF_FINAL : public: void clear_type(); const ::substrait::FunctionSignature_Argument_TypeArgument& type() const; - ::substrait::FunctionSignature_Argument_TypeArgument* release_type(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_TypeArgument* release_type(); ::substrait::FunctionSignature_Argument_TypeArgument* mutable_type(); void set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type); private: @@ -2491,7 +2642,7 @@ class FunctionSignature_Argument PROTOBUF_FINAL : public: void clear_enum_(); const ::substrait::FunctionSignature_Argument_EnumArgument& enum_() const; - ::substrait::FunctionSignature_Argument_EnumArgument* release_enum_(); + PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_EnumArgument* release_enum_(); ::substrait::FunctionSignature_Argument_EnumArgument* mutable_enum_(); void set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_); private: @@ -2526,17 +2677,16 @@ class FunctionSignature_Argument PROTOBUF_FINAL : ::substrait::FunctionSignature_Argument_EnumArgument* enum__; } argument_kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2ffunction_2eproto; }; // ------------------------------------------------------------------- -class FunctionSignature PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature) */ { +class FunctionSignature final : + public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature) */ { public: inline FunctionSignature() : FunctionSignature(nullptr) {} - ~FunctionSignature() override; explicit constexpr FunctionSignature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); FunctionSignature(const FunctionSignature& from); @@ -2550,8 +2700,13 @@ class FunctionSignature PROTOBUF_FINAL : return *this; } inline FunctionSignature& operator=(FunctionSignature&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2582,7 +2737,12 @@ class FunctionSignature PROTOBUF_FINAL : } inline void Swap(FunctionSignature* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2590,48 +2750,39 @@ class FunctionSignature PROTOBUF_FINAL : } void UnsafeArenaSwap(FunctionSignature* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FunctionSignature* New() const final { - return CreateMaybeMessage(nullptr); - } - - FunctionSignature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FunctionSignature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const FunctionSignature& from); - void MergeFrom(const FunctionSignature& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const FunctionSignature& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const FunctionSignature& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); + } + public: private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FunctionSignature"; } protected: - explicit FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2670,40 +2821,40 @@ class FunctionSignature PROTOBUF_FINAL : // int64 min_args = 1; inline void FunctionSignature_FinalArgVariadic::clear_min_args() { - min_args_ = PROTOBUF_LONGLONG(0); + min_args_ = int64_t{0}; } -inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::_internal_min_args() const { +inline int64_t FunctionSignature_FinalArgVariadic::_internal_min_args() const { return min_args_; } -inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::min_args() const { +inline int64_t FunctionSignature_FinalArgVariadic::min_args() const { // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.min_args) return _internal_min_args(); } -inline void FunctionSignature_FinalArgVariadic::_internal_set_min_args(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void FunctionSignature_FinalArgVariadic::_internal_set_min_args(int64_t value) { min_args_ = value; } -inline void FunctionSignature_FinalArgVariadic::set_min_args(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void FunctionSignature_FinalArgVariadic::set_min_args(int64_t value) { _internal_set_min_args(value); // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.min_args) } // int64 max_args = 2; inline void FunctionSignature_FinalArgVariadic::clear_max_args() { - max_args_ = PROTOBUF_LONGLONG(0); + max_args_ = int64_t{0}; } -inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::_internal_max_args() const { +inline int64_t FunctionSignature_FinalArgVariadic::_internal_max_args() const { return max_args_; } -inline ::PROTOBUF_NAMESPACE_ID::int64 FunctionSignature_FinalArgVariadic::max_args() const { +inline int64_t FunctionSignature_FinalArgVariadic::max_args() const { // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.max_args) return _internal_max_args(); } -inline void FunctionSignature_FinalArgVariadic::_internal_set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void FunctionSignature_FinalArgVariadic::_internal_set_max_args(int64_t value) { max_args_ = value; } -inline void FunctionSignature_FinalArgVariadic::set_max_args(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void FunctionSignature_FinalArgVariadic::set_max_args(int64_t value) { _internal_set_max_args(value); // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.max_args) } @@ -2766,8 +2917,9 @@ inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::_inter return arguments_.Add(); } inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::add_arguments() { + ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments(); // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.arguments) - return _internal_add_arguments(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& FunctionSignature_Scalar::arguments() const { @@ -2786,8 +2938,9 @@ inline void FunctionSignature_Scalar::clear_name() { name_.Clear(); } inline std::string* FunctionSignature_Scalar::add_name() { + std::string* _s = _internal_add_name(); // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Scalar.name) - return _internal_add_name(); + return _s; } inline const std::string& FunctionSignature_Scalar::_internal_name(int index) const { return name_.Get(index); @@ -2801,12 +2954,12 @@ inline std::string* FunctionSignature_Scalar::mutable_name(int index) { return name_.Mutable(index); } inline void FunctionSignature_Scalar::set_name(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name) name_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name) } inline void FunctionSignature_Scalar::set_name(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name) name_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name) } inline void FunctionSignature_Scalar::set_name(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -2857,7 +3010,7 @@ inline bool FunctionSignature_Scalar::has_description() const { return _internal_has_description(); } inline void FunctionSignature_Scalar::clear_description() { - if (GetArena() == nullptr && description_ != nullptr) { + if (GetArenaForAllocation() == nullptr && description_ != nullptr) { delete description_; } description_ = nullptr; @@ -2873,7 +3026,7 @@ inline const ::substrait::FunctionSignature_Description& FunctionSignature_Scala } inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_description( ::substrait::FunctionSignature_Description* description) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); } description_ = description; @@ -2888,9 +3041,15 @@ inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::rel ::substrait::FunctionSignature_Description* temp = description_; description_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::unsafe_arena_release_description() { @@ -2903,23 +3062,24 @@ inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::uns inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::_internal_mutable_description() { if (description_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation()); description_ = p; } return description_; } inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::mutable_description() { + ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.description) - return _internal_mutable_description(); + return _msg; } inline void FunctionSignature_Scalar::set_allocated_description(::substrait::FunctionSignature_Description* description) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete description_; } if (description) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(description); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description); if (message_arena != submessage_arena) { description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, description, submessage_arena); @@ -2990,7 +3150,7 @@ inline const ::substrait::DerivationExpression& FunctionSignature_Scalar::output } inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_output_type( ::substrait::DerivationExpression* output_type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } output_type_ = output_type; @@ -3005,9 +3165,15 @@ inline ::substrait::DerivationExpression* FunctionSignature_Scalar::release_outp ::substrait::DerivationExpression* temp = output_type_; output_type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* FunctionSignature_Scalar::unsafe_arena_release_output_type() { @@ -3020,23 +3186,26 @@ inline ::substrait::DerivationExpression* FunctionSignature_Scalar::unsafe_arena inline ::substrait::DerivationExpression* FunctionSignature_Scalar::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); output_type_ = p; } return output_type_; } inline ::substrait::DerivationExpression* FunctionSignature_Scalar::mutable_output_type() { + ::substrait::DerivationExpression* _msg = _internal_mutable_output_type(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.output_type) - return _internal_mutable_output_type(); + return _msg; } inline void FunctionSignature_Scalar::set_allocated_output_type(::substrait::DerivationExpression* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } if (output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); if (message_arena != submessage_arena) { output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, output_type, submessage_arena); @@ -3061,7 +3230,7 @@ inline void FunctionSignature_Scalar::set_has_variadic() { } inline void FunctionSignature_Scalar::clear_variadic() { if (_internal_has_variadic()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.variadic_; } clear_has_final_variable_behavior(); @@ -3072,7 +3241,7 @@ inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar if (_internal_has_variadic()) { clear_has_final_variable_behavior(); ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } final_variable_behavior_.variadic_ = nullptr; @@ -3113,13 +3282,14 @@ inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar if (!_internal_has_variadic()) { clear_final_variable_behavior(); set_has_variadic(); - final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); + final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation()); } return final_variable_behavior_.variadic_; } inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::mutable_variadic() { + ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.variadic) - return _internal_mutable_variadic(); + return _msg; } // .substrait.FunctionSignature.FinalArgNormal normal = 11; @@ -3134,7 +3304,7 @@ inline void FunctionSignature_Scalar::set_has_normal() { } inline void FunctionSignature_Scalar::clear_normal() { if (_internal_has_normal()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.normal_; } clear_has_final_variable_behavior(); @@ -3145,7 +3315,7 @@ inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar:: if (_internal_has_normal()) { clear_has_final_variable_behavior(); ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } final_variable_behavior_.normal_ = nullptr; @@ -3186,13 +3356,14 @@ inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar:: if (!_internal_has_normal()) { clear_final_variable_behavior(); set_has_normal(); - final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArena()); + final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation()); } return final_variable_behavior_.normal_; } inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::mutable_normal() { + ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.normal) - return _internal_mutable_normal(); + return _msg; } // repeated .substrait.FunctionSignature.Implementation implementations = 12; @@ -3225,8 +3396,9 @@ inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar:: return implementations_.Add(); } inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::add_implementations() { + ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations(); // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.implementations) - return _internal_add_implementations(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& FunctionSignature_Scalar::implementations() const { @@ -3277,8 +3449,9 @@ inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::_in return arguments_.Add(); } inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::add_arguments() { + ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments(); // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Aggregate.arguments) - return _internal_add_arguments(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& FunctionSignature_Aggregate::arguments() const { @@ -3295,30 +3468,31 @@ inline const std::string& FunctionSignature_Aggregate::name() const { return _internal_name(); } template -PROTOBUF_ALWAYS_INLINE -inline void FunctionSignature_Aggregate::set_name(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void FunctionSignature_Aggregate::set_name(ArgT0&& arg0, ArgT... args) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.name) } inline std::string* FunctionSignature_Aggregate::mutable_name() { + std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.name) - return _internal_mutable_name(); + return _s; } inline const std::string& FunctionSignature_Aggregate::_internal_name() const { return name_.Get(); } inline void FunctionSignature_Aggregate::_internal_set_name(const std::string& value) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* FunctionSignature_Aggregate::_internal_mutable_name() { - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* FunctionSignature_Aggregate::release_name() { // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void FunctionSignature_Aggregate::set_allocated_name(std::string* name) { if (name != nullptr) { @@ -3327,7 +3501,12 @@ inline void FunctionSignature_Aggregate::set_allocated_name(std::string* name) { } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.name) } @@ -3339,7 +3518,7 @@ inline bool FunctionSignature_Aggregate::has_description() const { return _internal_has_description(); } inline void FunctionSignature_Aggregate::clear_description() { - if (GetArena() == nullptr && description_ != nullptr) { + if (GetArenaForAllocation() == nullptr && description_ != nullptr) { delete description_; } description_ = nullptr; @@ -3355,7 +3534,7 @@ inline const ::substrait::FunctionSignature_Description& FunctionSignature_Aggre } inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_description( ::substrait::FunctionSignature_Description* description) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); } description_ = description; @@ -3370,9 +3549,15 @@ inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate:: ::substrait::FunctionSignature_Description* temp = description_; description_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::unsafe_arena_release_description() { @@ -3385,23 +3570,24 @@ inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate:: inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::_internal_mutable_description() { if (description_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation()); description_ = p; } return description_; } inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::mutable_description() { + ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.description) - return _internal_mutable_description(); + return _msg; } inline void FunctionSignature_Aggregate::set_allocated_description(::substrait::FunctionSignature_Description* description) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete description_; } if (description) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(description); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description); if (message_arena != submessage_arena) { description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, description, submessage_arena); @@ -3472,7 +3658,7 @@ inline const ::substrait::DerivationExpression& FunctionSignature_Aggregate::out } inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_output_type( ::substrait::DerivationExpression* output_type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } output_type_ = output_type; @@ -3487,9 +3673,15 @@ inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::release_o ::substrait::DerivationExpression* temp = output_type_; output_type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::unsafe_arena_release_output_type() { @@ -3502,23 +3694,26 @@ inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::unsafe_ar inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); output_type_ = p; } return output_type_; } inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::mutable_output_type() { + ::substrait::DerivationExpression* _msg = _internal_mutable_output_type(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.output_type) - return _internal_mutable_output_type(); + return _msg; } inline void FunctionSignature_Aggregate::set_allocated_output_type(::substrait::DerivationExpression* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } if (output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); if (message_arena != submessage_arena) { output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, output_type, submessage_arena); @@ -3543,7 +3738,7 @@ inline void FunctionSignature_Aggregate::set_has_variadic() { } inline void FunctionSignature_Aggregate::clear_variadic() { if (_internal_has_variadic()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.variadic_; } clear_has_final_variable_behavior(); @@ -3554,7 +3749,7 @@ inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggreg if (_internal_has_variadic()) { clear_has_final_variable_behavior(); ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } final_variable_behavior_.variadic_ = nullptr; @@ -3595,13 +3790,14 @@ inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggreg if (!_internal_has_variadic()) { clear_final_variable_behavior(); set_has_variadic(); - final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); + final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation()); } return final_variable_behavior_.variadic_; } inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::mutable_variadic() { + ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.variadic) - return _internal_mutable_variadic(); + return _msg; } // .substrait.FunctionSignature.FinalArgNormal normal = 11; @@ -3616,7 +3812,7 @@ inline void FunctionSignature_Aggregate::set_has_normal() { } inline void FunctionSignature_Aggregate::clear_normal() { if (_internal_has_normal()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.normal_; } clear_has_final_variable_behavior(); @@ -3627,7 +3823,7 @@ inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregat if (_internal_has_normal()) { clear_has_final_variable_behavior(); ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } final_variable_behavior_.normal_ = nullptr; @@ -3668,13 +3864,14 @@ inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregat if (!_internal_has_normal()) { clear_final_variable_behavior(); set_has_normal(); - final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArena()); + final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation()); } return final_variable_behavior_.normal_; } inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::mutable_normal() { + ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.normal) - return _internal_mutable_normal(); + return _msg; } // bool ordered = 14; @@ -3699,20 +3896,20 @@ inline void FunctionSignature_Aggregate::set_ordered(bool value) { // uint64 max_set = 12; inline void FunctionSignature_Aggregate::clear_max_set() { - max_set_ = PROTOBUF_ULONGLONG(0); + max_set_ = uint64_t{0u}; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Aggregate::_internal_max_set() const { +inline uint64_t FunctionSignature_Aggregate::_internal_max_set() const { return max_set_; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Aggregate::max_set() const { +inline uint64_t FunctionSignature_Aggregate::max_set() const { // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.max_set) return _internal_max_set(); } -inline void FunctionSignature_Aggregate::_internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline void FunctionSignature_Aggregate::_internal_set_max_set(uint64_t value) { max_set_ = value; } -inline void FunctionSignature_Aggregate::set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline void FunctionSignature_Aggregate::set_max_set(uint64_t value) { _internal_set_max_set(value); // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.max_set) } @@ -3735,7 +3932,7 @@ inline const ::substrait::Type& FunctionSignature_Aggregate::intermediate_type() } inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_intermediate_type( ::substrait::Type* intermediate_type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); } intermediate_type_ = intermediate_type; @@ -3750,9 +3947,15 @@ inline ::substrait::Type* FunctionSignature_Aggregate::release_intermediate_type ::substrait::Type* temp = intermediate_type_; intermediate_type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Type* FunctionSignature_Aggregate::unsafe_arena_release_intermediate_type() { @@ -3765,23 +3968,26 @@ inline ::substrait::Type* FunctionSignature_Aggregate::unsafe_arena_release_inte inline ::substrait::Type* FunctionSignature_Aggregate::_internal_mutable_intermediate_type() { if (intermediate_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); intermediate_type_ = p; } return intermediate_type_; } inline ::substrait::Type* FunctionSignature_Aggregate::mutable_intermediate_type() { + ::substrait::Type* _msg = _internal_mutable_intermediate_type(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.intermediate_type) - return _internal_mutable_intermediate_type(); + return _msg; } inline void FunctionSignature_Aggregate::set_allocated_intermediate_type(::substrait::Type* intermediate_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); } if (intermediate_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type)); if (message_arena != submessage_arena) { intermediate_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, intermediate_type, submessage_arena); @@ -3824,8 +4030,9 @@ inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregat return implementations_.Add(); } inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::add_implementations() { + ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations(); // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Aggregate.implementations) - return _internal_add_implementations(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& FunctionSignature_Aggregate::implementations() const { @@ -3876,8 +4083,9 @@ inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::_inter return arguments_.Add(); } inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::add_arguments() { + ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments(); // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.arguments) - return _internal_add_arguments(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& FunctionSignature_Window::arguments() const { @@ -3896,8 +4104,9 @@ inline void FunctionSignature_Window::clear_name() { name_.Clear(); } inline std::string* FunctionSignature_Window::add_name() { + std::string* _s = _internal_add_name(); // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Window.name) - return _internal_add_name(); + return _s; } inline const std::string& FunctionSignature_Window::_internal_name(int index) const { return name_.Get(index); @@ -3911,12 +4120,12 @@ inline std::string* FunctionSignature_Window::mutable_name(int index) { return name_.Mutable(index); } inline void FunctionSignature_Window::set_name(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name) name_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name) } inline void FunctionSignature_Window::set_name(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name) name_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name) } inline void FunctionSignature_Window::set_name(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -3967,7 +4176,7 @@ inline bool FunctionSignature_Window::has_description() const { return _internal_has_description(); } inline void FunctionSignature_Window::clear_description() { - if (GetArena() == nullptr && description_ != nullptr) { + if (GetArenaForAllocation() == nullptr && description_ != nullptr) { delete description_; } description_ = nullptr; @@ -3983,7 +4192,7 @@ inline const ::substrait::FunctionSignature_Description& FunctionSignature_Windo } inline void FunctionSignature_Window::unsafe_arena_set_allocated_description( ::substrait::FunctionSignature_Description* description) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); } description_ = description; @@ -3998,9 +4207,15 @@ inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::rel ::substrait::FunctionSignature_Description* temp = description_; description_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::unsafe_arena_release_description() { @@ -4013,23 +4228,24 @@ inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::uns inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::_internal_mutable_description() { if (description_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation()); description_ = p; } return description_; } inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::mutable_description() { + ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.description) - return _internal_mutable_description(); + return _msg; } inline void FunctionSignature_Window::set_allocated_description(::substrait::FunctionSignature_Description* description) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete description_; } if (description) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(description); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description); if (message_arena != submessage_arena) { description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, description, submessage_arena); @@ -4100,7 +4316,7 @@ inline const ::substrait::DerivationExpression& FunctionSignature_Window::interm } inline void FunctionSignature_Window::unsafe_arena_set_allocated_intermediate_type( ::substrait::DerivationExpression* intermediate_type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); } intermediate_type_ = intermediate_type; @@ -4115,9 +4331,15 @@ inline ::substrait::DerivationExpression* FunctionSignature_Window::release_inte ::substrait::DerivationExpression* temp = intermediate_type_; intermediate_type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_intermediate_type() { @@ -4130,23 +4352,26 @@ inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena inline ::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_intermediate_type() { if (intermediate_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); intermediate_type_ = p; } return intermediate_type_; } inline ::substrait::DerivationExpression* FunctionSignature_Window::mutable_intermediate_type() { + ::substrait::DerivationExpression* _msg = _internal_mutable_intermediate_type(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.intermediate_type) - return _internal_mutable_intermediate_type(); + return _msg; } inline void FunctionSignature_Window::set_allocated_intermediate_type(::substrait::DerivationExpression* intermediate_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); } if (intermediate_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type)); if (message_arena != submessage_arena) { intermediate_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, intermediate_type, submessage_arena); @@ -4177,7 +4402,7 @@ inline const ::substrait::DerivationExpression& FunctionSignature_Window::output } inline void FunctionSignature_Window::unsafe_arena_set_allocated_output_type( ::substrait::DerivationExpression* output_type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } output_type_ = output_type; @@ -4192,9 +4417,15 @@ inline ::substrait::DerivationExpression* FunctionSignature_Window::release_outp ::substrait::DerivationExpression* temp = output_type_; output_type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_output_type() { @@ -4207,23 +4438,26 @@ inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena inline ::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_output_type() { if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); output_type_ = p; } return output_type_; } inline ::substrait::DerivationExpression* FunctionSignature_Window::mutable_output_type() { + ::substrait::DerivationExpression* _msg = _internal_mutable_output_type(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.output_type) - return _internal_mutable_output_type(); + return _msg; } inline void FunctionSignature_Window::set_allocated_output_type(::substrait::DerivationExpression* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); } if (output_type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); if (message_arena != submessage_arena) { output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, output_type, submessage_arena); @@ -4248,7 +4482,7 @@ inline void FunctionSignature_Window::set_has_variadic() { } inline void FunctionSignature_Window::clear_variadic() { if (_internal_has_variadic()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.variadic_; } clear_has_final_variable_behavior(); @@ -4259,7 +4493,7 @@ inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window if (_internal_has_variadic()) { clear_has_final_variable_behavior(); ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } final_variable_behavior_.variadic_ = nullptr; @@ -4300,13 +4534,14 @@ inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window if (!_internal_has_variadic()) { clear_final_variable_behavior(); set_has_variadic(); - final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArena()); + final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation()); } return final_variable_behavior_.variadic_; } inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::mutable_variadic() { + ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.variadic) - return _internal_mutable_variadic(); + return _msg; } // .substrait.FunctionSignature.FinalArgNormal normal = 17; @@ -4321,7 +4556,7 @@ inline void FunctionSignature_Window::set_has_normal() { } inline void FunctionSignature_Window::clear_normal() { if (_internal_has_normal()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete final_variable_behavior_.normal_; } clear_has_final_variable_behavior(); @@ -4332,7 +4567,7 @@ inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window:: if (_internal_has_normal()) { clear_has_final_variable_behavior(); ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } final_variable_behavior_.normal_ = nullptr; @@ -4373,13 +4608,14 @@ inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window:: if (!_internal_has_normal()) { clear_final_variable_behavior(); set_has_normal(); - final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArena()); + final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation()); } return final_variable_behavior_.normal_; } inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::mutable_normal() { + ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.normal) - return _internal_mutable_normal(); + return _msg; } // bool ordered = 11; @@ -4404,20 +4640,20 @@ inline void FunctionSignature_Window::set_ordered(bool value) { // uint64 max_set = 12; inline void FunctionSignature_Window::clear_max_set() { - max_set_ = PROTOBUF_ULONGLONG(0); + max_set_ = uint64_t{0u}; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Window::_internal_max_set() const { +inline uint64_t FunctionSignature_Window::_internal_max_set() const { return max_set_; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 FunctionSignature_Window::max_set() const { +inline uint64_t FunctionSignature_Window::max_set() const { // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.max_set) return _internal_max_set(); } -inline void FunctionSignature_Window::_internal_set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline void FunctionSignature_Window::_internal_set_max_set(uint64_t value) { max_set_ = value; } -inline void FunctionSignature_Window::set_max_set(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline void FunctionSignature_Window::set_max_set(uint64_t value) { _internal_set_max_set(value); // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.max_set) } @@ -4472,8 +4708,9 @@ inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window:: return implementations_.Add(); } inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::add_implementations() { + ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations(); // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.implementations) - return _internal_add_implementations(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& FunctionSignature_Window::implementations() const { @@ -4503,30 +4740,31 @@ inline const std::string& FunctionSignature_Description::language() const { return _internal_language(); } template -PROTOBUF_ALWAYS_INLINE -inline void FunctionSignature_Description::set_language(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void FunctionSignature_Description::set_language(ArgT0&& arg0, ArgT... args) { - language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Description.language) } inline std::string* FunctionSignature_Description::mutable_language() { + std::string* _s = _internal_mutable_language(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Description.language) - return _internal_mutable_language(); + return _s; } inline const std::string& FunctionSignature_Description::_internal_language() const { return language_.Get(); } inline void FunctionSignature_Description::_internal_set_language(const std::string& value) { - language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* FunctionSignature_Description::_internal_mutable_language() { - return language_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return language_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* FunctionSignature_Description::release_language() { // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Description.language) - return language_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return language_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void FunctionSignature_Description::set_allocated_language(std::string* language) { if (language != nullptr) { @@ -4535,7 +4773,12 @@ inline void FunctionSignature_Description::set_allocated_language(std::string* l } language_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), language, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (language_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Description.language) } @@ -4548,30 +4791,31 @@ inline const std::string& FunctionSignature_Description::body() const { return _internal_body(); } template -PROTOBUF_ALWAYS_INLINE -inline void FunctionSignature_Description::set_body(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void FunctionSignature_Description::set_body(ArgT0&& arg0, ArgT... args) { - body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Description.body) } inline std::string* FunctionSignature_Description::mutable_body() { + std::string* _s = _internal_mutable_body(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Description.body) - return _internal_mutable_body(); + return _s; } inline const std::string& FunctionSignature_Description::_internal_body() const { return body_.Get(); } inline void FunctionSignature_Description::_internal_set_body(const std::string& value) { - body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* FunctionSignature_Description::_internal_mutable_body() { - return body_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return body_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* FunctionSignature_Description::release_body() { // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Description.body) - return body_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return body_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void FunctionSignature_Description::set_allocated_body(std::string* body) { if (body != nullptr) { @@ -4580,7 +4824,12 @@ inline void FunctionSignature_Description::set_allocated_body(std::string* body) } body_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), body, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (body_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Description.body) } @@ -4617,30 +4866,31 @@ inline const std::string& FunctionSignature_Implementation::uri() const { return _internal_uri(); } template -PROTOBUF_ALWAYS_INLINE -inline void FunctionSignature_Implementation::set_uri(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void FunctionSignature_Implementation::set_uri(ArgT0&& arg0, ArgT... args) { - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Implementation.uri) } inline std::string* FunctionSignature_Implementation::mutable_uri() { + std::string* _s = _internal_mutable_uri(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Implementation.uri) - return _internal_mutable_uri(); + return _s; } inline const std::string& FunctionSignature_Implementation::_internal_uri() const { return uri_.Get(); } inline void FunctionSignature_Implementation::_internal_set_uri(const std::string& value) { - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* FunctionSignature_Implementation::_internal_mutable_uri() { - return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* FunctionSignature_Implementation::release_uri() { // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Implementation.uri) - return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void FunctionSignature_Implementation::set_allocated_uri(std::string* uri) { if (uri != nullptr) { @@ -4649,7 +4899,12 @@ inline void FunctionSignature_Implementation::set_allocated_uri(std::string* uri } uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (uri_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Implementation.uri) } @@ -4675,7 +4930,7 @@ inline const ::substrait::ParameterizedType& FunctionSignature_Argument_ValueArg } inline void FunctionSignature_Argument_ValueArgument::unsafe_arena_set_allocated_type( ::substrait::ParameterizedType* type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } type_ = type; @@ -4690,9 +4945,15 @@ inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument: ::substrait::ParameterizedType* temp = type_; type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::unsafe_arena_release_type() { @@ -4705,23 +4966,26 @@ inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument: inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation()); type_ = p; } return type_; } inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::mutable_type() { + ::substrait::ParameterizedType* _msg = _internal_mutable_type(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.ValueArgument.type) - return _internal_mutable_type(); + return _msg; } inline void FunctionSignature_Argument_ValueArgument::set_allocated_type(::substrait::ParameterizedType* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } if (type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)); if (message_arena != submessage_arena) { type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type, submessage_arena); @@ -4776,7 +5040,7 @@ inline const ::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgu } inline void FunctionSignature_Argument_TypeArgument::unsafe_arena_set_allocated_type( ::substrait::ParameterizedType* type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } type_ = type; @@ -4791,9 +5055,15 @@ inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument:: ::substrait::ParameterizedType* temp = type_; type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::unsafe_arena_release_type() { @@ -4806,23 +5076,26 @@ inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument:: inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation()); type_ = p; } return type_; } inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::mutable_type() { + ::substrait::ParameterizedType* _msg = _internal_mutable_type(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.TypeArgument.type) - return _internal_mutable_type(); + return _msg; } inline void FunctionSignature_Argument_TypeArgument::set_allocated_type(::substrait::ParameterizedType* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } if (type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)); if (message_arena != submessage_arena) { type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type, submessage_arena); @@ -4850,8 +5123,9 @@ inline void FunctionSignature_Argument_EnumArgument::clear_options() { options_.Clear(); } inline std::string* FunctionSignature_Argument_EnumArgument::add_options() { + std::string* _s = _internal_add_options(); // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Argument.EnumArgument.options) - return _internal_add_options(); + return _s; } inline const std::string& FunctionSignature_Argument_EnumArgument::_internal_options(int index) const { return options_.Get(index); @@ -4865,12 +5139,12 @@ inline std::string* FunctionSignature_Argument_EnumArgument::mutable_options(int return options_.Mutable(index); } inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options) options_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options) } inline void FunctionSignature_Argument_EnumArgument::set_options(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options) options_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options) } inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -4946,30 +5220,31 @@ inline const std::string& FunctionSignature_Argument::name() const { return _internal_name(); } template -PROTOBUF_ALWAYS_INLINE -inline void FunctionSignature_Argument::set_name(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void FunctionSignature_Argument::set_name(ArgT0&& arg0, ArgT... args) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.name) } inline std::string* FunctionSignature_Argument::mutable_name() { + std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.name) - return _internal_mutable_name(); + return _s; } inline const std::string& FunctionSignature_Argument::_internal_name() const { return name_.Get(); } inline void FunctionSignature_Argument::_internal_set_name(const std::string& value) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* FunctionSignature_Argument::_internal_mutable_name() { - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* FunctionSignature_Argument::release_name() { // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void FunctionSignature_Argument::set_allocated_name(std::string* name) { if (name != nullptr) { @@ -4978,7 +5253,12 @@ inline void FunctionSignature_Argument::set_allocated_name(std::string* name) { } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.name) } @@ -4994,7 +5274,7 @@ inline void FunctionSignature_Argument::set_has_value() { } inline void FunctionSignature_Argument::clear_value() { if (_internal_has_value()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete argument_kind_.value_; } clear_has_argument_kind(); @@ -5005,7 +5285,7 @@ inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_ if (_internal_has_value()) { clear_has_argument_kind(); ::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } argument_kind_.value_ = nullptr; @@ -5046,13 +5326,14 @@ inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_ if (!_internal_has_value()) { clear_argument_kind(); set_has_value(); - argument_kind_.value_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_ValueArgument >(GetArena()); + argument_kind_.value_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_ValueArgument >(GetArenaForAllocation()); } return argument_kind_.value_; } inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::mutable_value() { + ::substrait::FunctionSignature_Argument_ValueArgument* _msg = _internal_mutable_value(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.value) - return _internal_mutable_value(); + return _msg; } // .substrait.FunctionSignature.Argument.TypeArgument type = 3; @@ -5067,7 +5348,7 @@ inline void FunctionSignature_Argument::set_has_type() { } inline void FunctionSignature_Argument::clear_type() { if (_internal_has_type()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete argument_kind_.type_; } clear_has_argument_kind(); @@ -5078,7 +5359,7 @@ inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_A if (_internal_has_type()) { clear_has_argument_kind(); ::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } argument_kind_.type_ = nullptr; @@ -5119,13 +5400,14 @@ inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_A if (!_internal_has_type()) { clear_argument_kind(); set_has_type(); - argument_kind_.type_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_TypeArgument >(GetArena()); + argument_kind_.type_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_TypeArgument >(GetArenaForAllocation()); } return argument_kind_.type_; } inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::mutable_type() { + ::substrait::FunctionSignature_Argument_TypeArgument* _msg = _internal_mutable_type(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.type) - return _internal_mutable_type(); + return _msg; } // .substrait.FunctionSignature.Argument.EnumArgument enum = 4; @@ -5140,7 +5422,7 @@ inline void FunctionSignature_Argument::set_has_enum_() { } inline void FunctionSignature_Argument::clear_enum_() { if (_internal_has_enum_()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete argument_kind_.enum__; } clear_has_argument_kind(); @@ -5151,7 +5433,7 @@ inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_A if (_internal_has_enum_()) { clear_has_argument_kind(); ::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } argument_kind_.enum__ = nullptr; @@ -5192,13 +5474,14 @@ inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_A if (!_internal_has_enum_()) { clear_argument_kind(); set_has_enum_(); - argument_kind_.enum__ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_EnumArgument >(GetArena()); + argument_kind_.enum__ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_EnumArgument >(GetArenaForAllocation()); } return argument_kind_.enum__; } inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::mutable_enum_() { + ::substrait::FunctionSignature_Argument_EnumArgument* _msg = _internal_mutable_enum_(); // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.enum) - return _internal_mutable_enum_(); + return _msg; } inline bool FunctionSignature_Argument::has_argument_kind() const { diff --git a/cpp/src/generated/substrait/parameterized_types.pb.cc b/cpp/src/generated/substrait/parameterized_types.pb.cc index 4f55cf851de..a37885aca41 100644 --- a/cpp/src/generated/substrait/parameterized_types.pb.cc +++ b/cpp/src/generated/substrait/parameterized_types.pb.cc @@ -46,7 +46,7 @@ struct ParameterizedType_IntegerParameterDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_IntegerParameterDefaultTypeInternal _ParameterizedType_IntegerParameter_default_instance_; constexpr ParameterizedType_NullableInteger::ParameterizedType_NullableInteger( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : value_(PROTOBUF_LONGLONG(0)){} + : value_(int64_t{0}){} struct ParameterizedType_NullableIntegerDefaultTypeInternal { constexpr ParameterizedType_NullableIntegerDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -205,12 +205,13 @@ static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fparamet static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fparameterized_5ftypes_2eproto = nullptr; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fparameterized_5ftypes_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5ftypes_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const uint32_t TableStruct_substrait_2fparameterized_5ftypes_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, name_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, bounds_), ~0u, // no _has_bits_ @@ -218,6 +219,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, name_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, range_start_inclusive_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, range_end_exclusive_), @@ -226,12 +228,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_NullableInteger, value_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, length_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, variation_pointer_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, nullability_), @@ -240,6 +244,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, length_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, variation_pointer_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, nullability_), @@ -248,6 +253,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, length_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, variation_pointer_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, nullability_), @@ -256,6 +262,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, scale_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, precision_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, variation_pointer_), @@ -265,6 +272,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, types_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, variation_pointer_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, nullability_), @@ -273,6 +281,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, names_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, struct__), ~0u, // no _has_bits_ @@ -280,6 +289,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, type_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, variation_pointer_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, nullability_), @@ -288,6 +298,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, key_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, value_), PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, variation_pointer_), @@ -297,6 +308,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, integer_type_), @@ -305,6 +317,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -333,19 +346,19 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fparameterized_5fty PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, kind_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::substrait::ParameterizedType_TypeParameter)}, - { 7, -1, sizeof(::substrait::ParameterizedType_IntegerParameter)}, - { 15, -1, sizeof(::substrait::ParameterizedType_NullableInteger)}, - { 21, -1, sizeof(::substrait::ParameterizedType_ParameterizedFixedChar)}, - { 29, -1, sizeof(::substrait::ParameterizedType_ParameterizedVarChar)}, - { 37, -1, sizeof(::substrait::ParameterizedType_ParameterizedFixedBinary)}, - { 45, -1, sizeof(::substrait::ParameterizedType_ParameterizedDecimal)}, - { 54, -1, sizeof(::substrait::ParameterizedType_ParameterizedStruct)}, - { 62, -1, sizeof(::substrait::ParameterizedType_ParameterizedNamedStruct)}, - { 69, -1, sizeof(::substrait::ParameterizedType_ParameterizedList)}, - { 77, -1, sizeof(::substrait::ParameterizedType_ParameterizedMap)}, - { 86, -1, sizeof(::substrait::ParameterizedType_IntegerOption)}, - { 94, -1, sizeof(::substrait::ParameterizedType)}, + { 0, -1, -1, sizeof(::substrait::ParameterizedType_TypeParameter)}, + { 8, -1, -1, sizeof(::substrait::ParameterizedType_IntegerParameter)}, + { 17, -1, -1, sizeof(::substrait::ParameterizedType_NullableInteger)}, + { 24, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedFixedChar)}, + { 33, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedVarChar)}, + { 42, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedFixedBinary)}, + { 51, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedDecimal)}, + { 61, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedStruct)}, + { 70, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedNamedStruct)}, + { 78, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedList)}, + { 87, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedMap)}, + { 97, -1, -1, sizeof(::substrait::ParameterizedType_IntegerOption)}, + { 106, -1, -1, sizeof(::substrait::ParameterizedType)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -469,11 +482,14 @@ class ParameterizedType_TypeParameter::_Internal { public: }; -ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), bounds_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.TypeParameter) } ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(const ParameterizedType_TypeParameter& from) @@ -481,25 +497,32 @@ ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(const Parameter bounds_(from.bounds_) { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_name().empty()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); + GetArenaForAllocation()); } // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.TypeParameter) } -void ParameterizedType_TypeParameter::SharedCtor() { +inline void ParameterizedType_TypeParameter::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING } ParameterizedType_TypeParameter::~ParameterizedType_TypeParameter() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.TypeParameter) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_TypeParameter::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_TypeParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } @@ -515,7 +538,7 @@ void ParameterizedType_TypeParameter::SetCachedSize(int size) const { void ParameterizedType_TypeParameter::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.TypeParameter) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -527,21 +550,22 @@ void ParameterizedType_TypeParameter::Clear() { const char* ParameterizedType_TypeParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.TypeParameter.name")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.ParameterizedType bounds = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -549,39 +573,40 @@ const char* ParameterizedType_TypeParameter::_InternalParse(const char* ptr, ::P CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_TypeParameter::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_TypeParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.TypeParameter) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -610,7 +635,7 @@ size_t ParameterizedType_TypeParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.TypeParameter) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -622,54 +647,39 @@ size_t ParameterizedType_TypeParameter::ByteSizeLong() const { } // string name = 1; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_TypeParameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.TypeParameter) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_TypeParameter* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.TypeParameter) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.TypeParameter) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_TypeParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_TypeParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_TypeParameter::GetClassData() const { return &_class_data_; } + +void ParameterizedType_TypeParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_TypeParameter::MergeFrom(const ParameterizedType_TypeParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.TypeParameter) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; bounds_.MergeFrom(from.bounds_); - if (from.name().size() > 0) { + if (!from._internal_name().empty()) { _internal_set_name(from._internal_name()); } -} - -void ParameterizedType_TypeParameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.TypeParameter) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_TypeParameter::CopyFrom(const ParameterizedType_TypeParameter& from) { @@ -685,9 +695,15 @@ bool ParameterizedType_TypeParameter::IsInitialized() const { void ParameterizedType_TypeParameter::InternalSwap(ParameterizedType_TypeParameter* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); bounds_.InternalSwap(&other->bounds_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); } ::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_TypeParameter::GetMetadata() const { @@ -712,19 +728,25 @@ const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_Internal::range_end_exclusive(const ParameterizedType_IntegerParameter* msg) { return *msg->range_end_exclusive_; } -ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.IntegerParameter) } ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(const ParameterizedType_IntegerParameter& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_name().empty()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); + GetArenaForAllocation()); } if (from._internal_has_range_start_inclusive()) { range_start_inclusive_ = new ::substrait::ParameterizedType_NullableInteger(*from.range_start_inclusive_); @@ -739,8 +761,11 @@ ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(const Par // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.IntegerParameter) } -void ParameterizedType_IntegerParameter::SharedCtor() { +inline void ParameterizedType_IntegerParameter::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&range_start_inclusive_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&range_end_exclusive_) - @@ -749,12 +774,13 @@ ::memset(reinterpret_cast(this) + static_cast( ParameterizedType_IntegerParameter::~ParameterizedType_IntegerParameter() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.IntegerParameter) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_IntegerParameter::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_IntegerParameter::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete range_start_inclusive_; if (this != internal_default_instance()) delete range_end_exclusive_; @@ -772,16 +798,16 @@ void ParameterizedType_IntegerParameter::SetCachedSize(int size) const { void ParameterizedType_IntegerParameter::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.IntegerParameter) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; name_.ClearToEmpty(); - if (GetArena() == nullptr && range_start_inclusive_ != nullptr) { + if (GetArenaForAllocation() == nullptr && range_start_inclusive_ != nullptr) { delete range_start_inclusive_; } range_start_inclusive_ = nullptr; - if (GetArena() == nullptr && range_end_exclusive_ != nullptr) { + if (GetArenaForAllocation() == nullptr && range_end_exclusive_ != nullptr) { delete range_end_exclusive_; } range_end_exclusive_ = nullptr; @@ -791,63 +817,66 @@ void ParameterizedType_IntegerParameter::Clear() { const char* ParameterizedType_IntegerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.IntegerParameter.name")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_range_start_inclusive(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_range_end_exclusive(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerParameter::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_IntegerParameter::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.IntegerParameter) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -857,7 +886,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerParameter::_InternalSer } // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; - if (this->has_range_start_inclusive()) { + if (this->_internal_has_range_start_inclusive()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -865,7 +894,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerParameter::_InternalSer } // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; - if (this->has_range_end_exclusive()) { + if (this->_internal_has_range_end_exclusive()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -884,78 +913,63 @@ size_t ParameterizedType_IntegerParameter::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.IntegerParameter) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string name = 1; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; - if (this->has_range_start_inclusive()) { + if (this->_internal_has_range_start_inclusive()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *range_start_inclusive_); } // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; - if (this->has_range_end_exclusive()) { + if (this->_internal_has_range_end_exclusive()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *range_end_exclusive_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_IntegerParameter::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.IntegerParameter) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_IntegerParameter* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.IntegerParameter) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.IntegerParameter) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_IntegerParameter::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_IntegerParameter::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_IntegerParameter::GetClassData() const { return &_class_data_; } + +void ParameterizedType_IntegerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_IntegerParameter::MergeFrom(const ParameterizedType_IntegerParameter& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.IntegerParameter) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.name().size() > 0) { + if (!from._internal_name().empty()) { _internal_set_name(from._internal_name()); } - if (from.has_range_start_inclusive()) { + if (from._internal_has_range_start_inclusive()) { _internal_mutable_range_start_inclusive()->::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_start_inclusive()); } - if (from.has_range_end_exclusive()) { + if (from._internal_has_range_end_exclusive()) { _internal_mutable_range_end_exclusive()->::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_end_exclusive()); } -} - -void ParameterizedType_IntegerParameter::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.IntegerParameter) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_IntegerParameter::CopyFrom(const ParameterizedType_IntegerParameter& from) { @@ -971,8 +985,14 @@ bool ParameterizedType_IntegerParameter::IsInitialized() const { void ParameterizedType_IntegerParameter::InternalSwap(ParameterizedType_IntegerParameter* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ParameterizedType_IntegerParameter, range_end_exclusive_) + sizeof(ParameterizedType_IntegerParameter::range_end_exclusive_) @@ -993,10 +1013,13 @@ class ParameterizedType_NullableInteger::_Internal { public: }; -ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.NullableInteger) } ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(const ParameterizedType_NullableInteger& from) @@ -1006,18 +1029,19 @@ ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(const Param // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.NullableInteger) } -void ParameterizedType_NullableInteger::SharedCtor() { -value_ = PROTOBUF_LONGLONG(0); +inline void ParameterizedType_NullableInteger::SharedCtor() { +value_ = int64_t{0}; } ParameterizedType_NullableInteger::~ParameterizedType_NullableInteger() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.NullableInteger) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_NullableInteger::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_NullableInteger::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ParameterizedType_NullableInteger::ArenaDtor(void* object) { @@ -1032,58 +1056,59 @@ void ParameterizedType_NullableInteger::SetCachedSize(int size) const { void ParameterizedType_NullableInteger::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.NullableInteger) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - value_ = PROTOBUF_LONGLONG(0); + value_ = int64_t{0}; _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } const char* ParameterizedType_NullableInteger::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int64 value = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_NullableInteger::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_NullableInteger::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.NullableInteger) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int64 value = 1; - if (this->value() != 0) { + if (this->_internal_value() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_value(), target); } @@ -1100,58 +1125,41 @@ size_t ParameterizedType_NullableInteger::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.NullableInteger) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int64 value = 1; - if (this->value() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_value()); + if (this->_internal_value() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_value()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_NullableInteger::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.NullableInteger) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_NullableInteger* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.NullableInteger) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.NullableInteger) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_NullableInteger::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_NullableInteger::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_NullableInteger::GetClassData() const { return &_class_data_; } + +void ParameterizedType_NullableInteger::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_NullableInteger::MergeFrom(const ParameterizedType_NullableInteger& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.NullableInteger) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.value() != 0) { + if (from._internal_value() != 0) { _internal_set_value(from._internal_value()); } -} - -void ParameterizedType_NullableInteger::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.NullableInteger) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_NullableInteger::CopyFrom(const ParameterizedType_NullableInteger& from) { @@ -1167,7 +1175,7 @@ bool ParameterizedType_NullableInteger::IsInitialized() const { void ParameterizedType_NullableInteger::InternalSwap(ParameterizedType_NullableInteger* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(value_, other->value_); } @@ -1188,10 +1196,13 @@ const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::_Internal::length(const ParameterizedType_ParameterizedFixedChar* msg) { return *msg->length_; } -ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedFixedChar) } ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(const ParameterizedType_ParameterizedFixedChar& from) @@ -1208,7 +1219,7 @@ ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedCh // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedFixedChar) } -void ParameterizedType_ParameterizedFixedChar::SharedCtor() { +inline void ParameterizedType_ParameterizedFixedChar::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1217,12 +1228,13 @@ ::memset(reinterpret_cast(this) + static_cast( ParameterizedType_ParameterizedFixedChar::~ParameterizedType_ParameterizedFixedChar() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedFixedChar) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_ParameterizedFixedChar::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_ParameterizedFixedChar::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete length_; } @@ -1238,11 +1250,11 @@ void ParameterizedType_ParameterizedFixedChar::SetCachedSize(int size) const { void ParameterizedType_ParameterizedFixedChar::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedFixedChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -1255,62 +1267,65 @@ void ParameterizedType_ParameterizedFixedChar::Clear() { const char* ParameterizedType_ParameterizedFixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.ParameterizedType.IntegerOption length = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedChar::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_ParameterizedFixedChar::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedFixedChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1318,13 +1333,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedChar::_Inter } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -1342,77 +1357,60 @@ size_t ParameterizedType_ParameterizedFixedChar::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedFixedChar) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *length_); } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_ParameterizedFixedChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedFixedChar) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_ParameterizedFixedChar* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedFixedChar) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedFixedChar) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedFixedChar::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_ParameterizedFixedChar::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedFixedChar::GetClassData() const { return &_class_data_; } + +void ParameterizedType_ParameterizedFixedChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_ParameterizedFixedChar::MergeFrom(const ParameterizedType_ParameterizedFixedChar& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedFixedChar) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_length()) { + if (from._internal_has_length()) { _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void ParameterizedType_ParameterizedFixedChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedFixedChar) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_ParameterizedFixedChar::CopyFrom(const ParameterizedType_ParameterizedFixedChar& from) { @@ -1428,7 +1426,7 @@ bool ParameterizedType_ParameterizedFixedChar::IsInitialized() const { void ParameterizedType_ParameterizedFixedChar::InternalSwap(ParameterizedType_ParameterizedFixedChar* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedChar, nullability_) + sizeof(ParameterizedType_ParameterizedFixedChar::nullability_) @@ -1454,10 +1452,13 @@ const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::_Internal::length(const ParameterizedType_ParameterizedVarChar* msg) { return *msg->length_; } -ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedVarChar) } ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(const ParameterizedType_ParameterizedVarChar& from) @@ -1474,7 +1475,7 @@ ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(c // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedVarChar) } -void ParameterizedType_ParameterizedVarChar::SharedCtor() { +inline void ParameterizedType_ParameterizedVarChar::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1483,12 +1484,13 @@ ::memset(reinterpret_cast(this) + static_cast( ParameterizedType_ParameterizedVarChar::~ParameterizedType_ParameterizedVarChar() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedVarChar) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_ParameterizedVarChar::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_ParameterizedVarChar::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete length_; } @@ -1504,11 +1506,11 @@ void ParameterizedType_ParameterizedVarChar::SetCachedSize(int size) const { void ParameterizedType_ParameterizedVarChar::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedVarChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -1521,62 +1523,65 @@ void ParameterizedType_ParameterizedVarChar::Clear() { const char* ParameterizedType_ParameterizedVarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.ParameterizedType.IntegerOption length = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedVarChar::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_ParameterizedVarChar::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedVarChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1584,13 +1589,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedVarChar::_Interna } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -1608,77 +1613,60 @@ size_t ParameterizedType_ParameterizedVarChar::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedVarChar) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *length_); } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_ParameterizedVarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedVarChar) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_ParameterizedVarChar* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedVarChar) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedVarChar) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedVarChar::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_ParameterizedVarChar::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedVarChar::GetClassData() const { return &_class_data_; } + +void ParameterizedType_ParameterizedVarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_ParameterizedVarChar::MergeFrom(const ParameterizedType_ParameterizedVarChar& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedVarChar) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_length()) { + if (from._internal_has_length()) { _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void ParameterizedType_ParameterizedVarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedVarChar) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_ParameterizedVarChar::CopyFrom(const ParameterizedType_ParameterizedVarChar& from) { @@ -1694,7 +1682,7 @@ bool ParameterizedType_ParameterizedVarChar::IsInitialized() const { void ParameterizedType_ParameterizedVarChar::InternalSwap(ParameterizedType_ParameterizedVarChar* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedVarChar, nullability_) + sizeof(ParameterizedType_ParameterizedVarChar::nullability_) @@ -1720,10 +1708,13 @@ const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::_Internal::length(const ParameterizedType_ParameterizedFixedBinary* msg) { return *msg->length_; } -ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedFixedBinary) } ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(const ParameterizedType_ParameterizedFixedBinary& from) @@ -1740,7 +1731,7 @@ ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixed // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedFixedBinary) } -void ParameterizedType_ParameterizedFixedBinary::SharedCtor() { +inline void ParameterizedType_ParameterizedFixedBinary::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1749,12 +1740,13 @@ ::memset(reinterpret_cast(this) + static_cast( ParameterizedType_ParameterizedFixedBinary::~ParameterizedType_ParameterizedFixedBinary() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedFixedBinary) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_ParameterizedFixedBinary::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_ParameterizedFixedBinary::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete length_; } @@ -1770,11 +1762,11 @@ void ParameterizedType_ParameterizedFixedBinary::SetCachedSize(int size) const { void ParameterizedType_ParameterizedFixedBinary::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedFixedBinary) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -1787,62 +1779,65 @@ void ParameterizedType_ParameterizedFixedBinary::Clear() { const char* ParameterizedType_ParameterizedFixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.ParameterizedType.IntegerOption length = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedBinary::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_ParameterizedFixedBinary::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedFixedBinary) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1850,13 +1845,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedFixedBinary::_Int } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -1874,77 +1869,60 @@ size_t ParameterizedType_ParameterizedFixedBinary::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedFixedBinary) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *length_); } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_ParameterizedFixedBinary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedFixedBinary) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_ParameterizedFixedBinary* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedFixedBinary) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedFixedBinary) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedFixedBinary::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_ParameterizedFixedBinary::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedFixedBinary::GetClassData() const { return &_class_data_; } + +void ParameterizedType_ParameterizedFixedBinary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_ParameterizedFixedBinary::MergeFrom(const ParameterizedType_ParameterizedFixedBinary& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedFixedBinary) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_length()) { + if (from._internal_has_length()) { _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void ParameterizedType_ParameterizedFixedBinary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedFixedBinary) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_ParameterizedFixedBinary::CopyFrom(const ParameterizedType_ParameterizedFixedBinary& from) { @@ -1960,7 +1938,7 @@ bool ParameterizedType_ParameterizedFixedBinary::IsInitialized() const { void ParameterizedType_ParameterizedFixedBinary::InternalSwap(ParameterizedType_ParameterizedFixedBinary* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedBinary, nullability_) + sizeof(ParameterizedType_ParameterizedFixedBinary::nullability_) @@ -1991,10 +1969,13 @@ const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_Internal::precision(const ParameterizedType_ParameterizedDecimal* msg) { return *msg->precision_; } -ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedDecimal) } ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(const ParameterizedType_ParameterizedDecimal& from) @@ -2016,7 +1997,7 @@ ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(c // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedDecimal) } -void ParameterizedType_ParameterizedDecimal::SharedCtor() { +inline void ParameterizedType_ParameterizedDecimal::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&scale_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -2025,12 +2006,13 @@ ::memset(reinterpret_cast(this) + static_cast( ParameterizedType_ParameterizedDecimal::~ParameterizedType_ParameterizedDecimal() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedDecimal) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_ParameterizedDecimal::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_ParameterizedDecimal::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete scale_; if (this != internal_default_instance()) delete precision_; } @@ -2047,15 +2029,15 @@ void ParameterizedType_ParameterizedDecimal::SetCachedSize(int size) const { void ParameterizedType_ParameterizedDecimal::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedDecimal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && scale_ != nullptr) { + if (GetArenaForAllocation() == nullptr && scale_ != nullptr) { delete scale_; } scale_ = nullptr; - if (GetArena() == nullptr && precision_ != nullptr) { + if (GetArenaForAllocation() == nullptr && precision_ != nullptr) { delete precision_; } precision_ = nullptr; @@ -2068,69 +2050,73 @@ void ParameterizedType_ParameterizedDecimal::Clear() { const char* ParameterizedType_ParameterizedDecimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.ParameterizedType.IntegerOption scale = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.IntegerOption precision = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedDecimal::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_ParameterizedDecimal::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedDecimal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.ParameterizedType.IntegerOption scale = 1; - if (this->has_scale()) { + if (this->_internal_has_scale()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2138,7 +2124,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedDecimal::_Interna } // .substrait.ParameterizedType.IntegerOption precision = 2; - if (this->has_precision()) { + if (this->_internal_has_precision()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2146,13 +2132,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedDecimal::_Interna } // uint32 variation_pointer = 3; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 4, this->_internal_nullability(), target); @@ -2170,87 +2156,70 @@ size_t ParameterizedType_ParameterizedDecimal::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedDecimal) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.ParameterizedType.IntegerOption scale = 1; - if (this->has_scale()) { + if (this->_internal_has_scale()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *scale_); } // .substrait.ParameterizedType.IntegerOption precision = 2; - if (this->has_precision()) { + if (this->_internal_has_precision()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *precision_); } // uint32 variation_pointer = 3; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_ParameterizedDecimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedDecimal) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_ParameterizedDecimal* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedDecimal) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedDecimal) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedDecimal::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_ParameterizedDecimal::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedDecimal::GetClassData() const { return &_class_data_; } + +void ParameterizedType_ParameterizedDecimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_ParameterizedDecimal::MergeFrom(const ParameterizedType_ParameterizedDecimal& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedDecimal) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_scale()) { + if (from._internal_has_scale()) { _internal_mutable_scale()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_scale()); } - if (from.has_precision()) { + if (from._internal_has_precision()) { _internal_mutable_precision()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_precision()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void ParameterizedType_ParameterizedDecimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedDecimal) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_ParameterizedDecimal::CopyFrom(const ParameterizedType_ParameterizedDecimal& from) { @@ -2266,7 +2235,7 @@ bool ParameterizedType_ParameterizedDecimal::IsInitialized() const { void ParameterizedType_ParameterizedDecimal::InternalSwap(ParameterizedType_ParameterizedDecimal* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedDecimal, nullability_) + sizeof(ParameterizedType_ParameterizedDecimal::nullability_) @@ -2287,11 +2256,14 @@ class ParameterizedType_ParameterizedStruct::_Internal { public: }; -ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), types_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedStruct) } ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(const ParameterizedType_ParameterizedStruct& from) @@ -2304,7 +2276,7 @@ ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(con // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedStruct) } -void ParameterizedType_ParameterizedStruct::SharedCtor() { +inline void ParameterizedType_ParameterizedStruct::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&variation_pointer_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -2313,12 +2285,13 @@ ::memset(reinterpret_cast(this) + static_cast( ParameterizedType_ParameterizedStruct::~ParameterizedType_ParameterizedStruct() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedStruct) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_ParameterizedStruct::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_ParameterizedStruct::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ParameterizedType_ParameterizedStruct::ArenaDtor(void* object) { @@ -2333,7 +2306,7 @@ void ParameterizedType_ParameterizedStruct::SetCachedSize(int size) const { void ParameterizedType_ParameterizedStruct::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2347,12 +2320,12 @@ void ParameterizedType_ParameterizedStruct::Clear() { const char* ParameterizedType_ParameterizedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.ParameterizedType types = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -2360,50 +2333,53 @@ const char* ParameterizedType_ParameterizedStruct::_InternalParse(const char* pt CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedStruct::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_ParameterizedStruct::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.ParameterizedType types = 1; @@ -2415,13 +2391,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedStruct::_Internal } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -2439,7 +2415,7 @@ size_t ParameterizedType_ParameterizedStruct::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedStruct) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2451,63 +2427,46 @@ size_t ParameterizedType_ParameterizedStruct::ByteSizeLong() const { } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_ParameterizedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedStruct) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_ParameterizedStruct* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedStruct) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedStruct) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedStruct::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_ParameterizedStruct::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedStruct::GetClassData() const { return &_class_data_; } + +void ParameterizedType_ParameterizedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_ParameterizedStruct::MergeFrom(const ParameterizedType_ParameterizedStruct& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedStruct) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; types_.MergeFrom(from.types_); - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void ParameterizedType_ParameterizedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_ParameterizedStruct::CopyFrom(const ParameterizedType_ParameterizedStruct& from) { @@ -2523,7 +2482,7 @@ bool ParameterizedType_ParameterizedStruct::IsInitialized() const { void ParameterizedType_ParameterizedStruct::InternalSwap(ParameterizedType_ParameterizedStruct* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); types_.InternalSwap(&other->types_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedStruct, nullability_) @@ -2550,11 +2509,14 @@ const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::_Internal::struct_(const ParameterizedType_ParameterizedNamedStruct* msg) { return *msg->struct__; } -ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), names_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedNamedStruct) } ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(const ParameterizedType_ParameterizedNamedStruct& from) @@ -2569,18 +2531,19 @@ ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamed // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedNamedStruct) } -void ParameterizedType_ParameterizedNamedStruct::SharedCtor() { +inline void ParameterizedType_ParameterizedNamedStruct::SharedCtor() { struct__ = nullptr; } ParameterizedType_ParameterizedNamedStruct::~ParameterizedType_ParameterizedNamedStruct() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedNamedStruct) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_ParameterizedNamedStruct::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_ParameterizedNamedStruct::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete struct__; } @@ -2596,12 +2559,12 @@ void ParameterizedType_ParameterizedNamedStruct::SetCachedSize(int size) const { void ParameterizedType_ParameterizedNamedStruct::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedNamedStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; names_.Clear(); - if (GetArena() == nullptr && struct__ != nullptr) { + if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { delete struct__; } struct__ = nullptr; @@ -2611,12 +2574,12 @@ void ParameterizedType_ParameterizedNamedStruct::Clear() { const char* ParameterizedType_ParameterizedNamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated string names = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -2626,42 +2589,44 @@ const char* ParameterizedType_ParameterizedNamedStruct::_InternalParse(const cha CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.ParameterizedStruct struct = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedNamedStruct::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_ParameterizedNamedStruct::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedNamedStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated string names = 1; @@ -2675,7 +2640,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedNamedStruct::_Int } // .substrait.ParameterizedType.ParameterizedStruct struct = 2; - if (this->has_struct_()) { + if (this->_internal_has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2694,7 +2659,7 @@ size_t ParameterizedType_ParameterizedNamedStruct::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedNamedStruct) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2707,54 +2672,39 @@ size_t ParameterizedType_ParameterizedNamedStruct::ByteSizeLong() const { } // .substrait.ParameterizedType.ParameterizedStruct struct = 2; - if (this->has_struct_()) { + if (this->_internal_has_struct_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *struct__); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_ParameterizedNamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedNamedStruct) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_ParameterizedNamedStruct* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedNamedStruct) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedNamedStruct) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedNamedStruct::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_ParameterizedNamedStruct::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedNamedStruct::GetClassData() const { return &_class_data_; } + +void ParameterizedType_ParameterizedNamedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_ParameterizedNamedStruct::MergeFrom(const ParameterizedType_ParameterizedNamedStruct& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedNamedStruct) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; names_.MergeFrom(from.names_); - if (from.has_struct_()) { + if (from._internal_has_struct_()) { _internal_mutable_struct_()->::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); } -} - -void ParameterizedType_ParameterizedNamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedNamedStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_ParameterizedNamedStruct::CopyFrom(const ParameterizedType_ParameterizedNamedStruct& from) { @@ -2770,7 +2720,7 @@ bool ParameterizedType_ParameterizedNamedStruct::IsInitialized() const { void ParameterizedType_ParameterizedNamedStruct::InternalSwap(ParameterizedType_ParameterizedNamedStruct* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); names_.InternalSwap(&other->names_); swap(struct__, other->struct__); } @@ -2792,10 +2742,13 @@ const ::substrait::ParameterizedType& ParameterizedType_ParameterizedList::_Internal::type(const ParameterizedType_ParameterizedList* msg) { return *msg->type_; } -ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedList) } ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(const ParameterizedType_ParameterizedList& from) @@ -2812,7 +2765,7 @@ ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(const P // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedList) } -void ParameterizedType_ParameterizedList::SharedCtor() { +inline void ParameterizedType_ParameterizedList::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -2821,12 +2774,13 @@ ::memset(reinterpret_cast(this) + static_cast( ParameterizedType_ParameterizedList::~ParameterizedType_ParameterizedList() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedList) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_ParameterizedList::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_ParameterizedList::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete type_; } @@ -2842,11 +2796,11 @@ void ParameterizedType_ParameterizedList::SetCachedSize(int size) const { void ParameterizedType_ParameterizedList::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedList) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; @@ -2859,62 +2813,65 @@ void ParameterizedType_ParameterizedList::Clear() { const char* ParameterizedType_ParameterizedList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.ParameterizedType type = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedList::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_ParameterizedList::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedList) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.ParameterizedType type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2922,13 +2879,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedList::_InternalSe } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -2946,77 +2903,60 @@ size_t ParameterizedType_ParameterizedList::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedList) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.ParameterizedType type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *type_); } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_ParameterizedList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedList) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_ParameterizedList* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedList) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedList) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedList::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_ParameterizedList::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedList::GetClassData() const { return &_class_data_; } + +void ParameterizedType_ParameterizedList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_ParameterizedList::MergeFrom(const ParameterizedType_ParameterizedList& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedList) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_type()) { + if (from._internal_has_type()) { _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void ParameterizedType_ParameterizedList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedList) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_ParameterizedList::CopyFrom(const ParameterizedType_ParameterizedList& from) { @@ -3032,7 +2972,7 @@ bool ParameterizedType_ParameterizedList::IsInitialized() const { void ParameterizedType_ParameterizedList::InternalSwap(ParameterizedType_ParameterizedList* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedList, nullability_) + sizeof(ParameterizedType_ParameterizedList::nullability_) @@ -3063,10 +3003,13 @@ const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_Internal::value(const ParameterizedType_ParameterizedMap* msg) { return *msg->value_; } -ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedMap) } ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(const ParameterizedType_ParameterizedMap& from) @@ -3088,7 +3031,7 @@ ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(const Par // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedMap) } -void ParameterizedType_ParameterizedMap::SharedCtor() { +inline void ParameterizedType_ParameterizedMap::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&key_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -3097,12 +3040,13 @@ ::memset(reinterpret_cast(this) + static_cast( ParameterizedType_ParameterizedMap::~ParameterizedType_ParameterizedMap() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedMap) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_ParameterizedMap::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_ParameterizedMap::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete key_; if (this != internal_default_instance()) delete value_; } @@ -3119,15 +3063,15 @@ void ParameterizedType_ParameterizedMap::SetCachedSize(int size) const { void ParameterizedType_ParameterizedMap::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedMap) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && key_ != nullptr) { + if (GetArenaForAllocation() == nullptr && key_ != nullptr) { delete key_; } key_ = nullptr; - if (GetArena() == nullptr && value_ != nullptr) { + if (GetArenaForAllocation() == nullptr && value_ != nullptr) { delete value_; } value_ = nullptr; @@ -3140,69 +3084,73 @@ void ParameterizedType_ParameterizedMap::Clear() { const char* ParameterizedType_ParameterizedMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.ParameterizedType key = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType value = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedMap::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_ParameterizedMap::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedMap) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.ParameterizedType key = 1; - if (this->has_key()) { + if (this->_internal_has_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3210,7 +3158,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedMap::_InternalSer } // .substrait.ParameterizedType value = 2; - if (this->has_value()) { + if (this->_internal_has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3218,13 +3166,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_ParameterizedMap::_InternalSer } // uint32 variation_pointer = 3; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 4, this->_internal_nullability(), target); @@ -3242,87 +3190,70 @@ size_t ParameterizedType_ParameterizedMap::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedMap) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.ParameterizedType key = 1; - if (this->has_key()) { + if (this->_internal_has_key()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *key_); } // .substrait.ParameterizedType value = 2; - if (this->has_value()) { + if (this->_internal_has_value()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *value_); } // uint32 variation_pointer = 3; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_ParameterizedMap::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.ParameterizedMap) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_ParameterizedMap* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.ParameterizedMap) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.ParameterizedMap) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedMap::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_ParameterizedMap::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedMap::GetClassData() const { return &_class_data_; } + +void ParameterizedType_ParameterizedMap::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_ParameterizedMap::MergeFrom(const ParameterizedType_ParameterizedMap& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedMap) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_key()) { + if (from._internal_has_key()) { _internal_mutable_key()->::substrait::ParameterizedType::MergeFrom(from._internal_key()); } - if (from.has_value()) { + if (from._internal_has_value()) { _internal_mutable_value()->::substrait::ParameterizedType::MergeFrom(from._internal_value()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void ParameterizedType_ParameterizedMap::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.ParameterizedMap) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_ParameterizedMap::CopyFrom(const ParameterizedType_ParameterizedMap& from) { @@ -3338,7 +3269,7 @@ bool ParameterizedType_ParameterizedMap::IsInitialized() const { void ParameterizedType_ParameterizedMap::InternalSwap(ParameterizedType_ParameterizedMap* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedMap, nullability_) + sizeof(ParameterizedType_ParameterizedMap::nullability_) @@ -3365,11 +3296,11 @@ ParameterizedType_IntegerOption::_Internal::parameter(const ParameterizedType_In return *msg->integer_type_.parameter_; } void ParameterizedType_IntegerOption::set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_integer_type(); if (parameter) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(parameter); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerParameter>::GetOwningArena(parameter); if (message_arena != submessage_arena) { parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, parameter, submessage_arena); @@ -3379,10 +3310,13 @@ void ParameterizedType_IntegerOption::set_allocated_parameter(::substrait::Param } // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerOption.parameter) } -ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.IntegerOption) } ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(const ParameterizedType_IntegerOption& from) @@ -3405,18 +3339,19 @@ ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(const Parameter // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.IntegerOption) } -void ParameterizedType_IntegerOption::SharedCtor() { +inline void ParameterizedType_IntegerOption::SharedCtor() { clear_has_integer_type(); } ParameterizedType_IntegerOption::~ParameterizedType_IntegerOption() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType.IntegerOption) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType_IntegerOption::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType_IntegerOption::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_integer_type()) { clear_integer_type(); } @@ -3440,7 +3375,7 @@ void ParameterizedType_IntegerOption::clear_integer_type() { break; } case kParameter: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete integer_type_.parameter_; } break; @@ -3455,7 +3390,7 @@ void ParameterizedType_IntegerOption::clear_integer_type() { void ParameterizedType_IntegerOption::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.IntegerOption) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3466,50 +3401,52 @@ void ParameterizedType_IntegerOption::Clear() { const char* ParameterizedType_IntegerOption::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 literal = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - _internal_set_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + _internal_set_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.IntegerParameter parameter = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_parameter(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType_IntegerOption::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType_IntegerOption::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.IntegerOption) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 literal = 1; @@ -3538,16 +3475,14 @@ size_t ParameterizedType_IntegerOption::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.IntegerOption) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; switch (integer_type_case()) { // int32 literal = 1; case kLiteral: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_literal()); + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_literal()); break; } // .substrait.ParameterizedType.IntegerParameter parameter = 2; @@ -3561,35 +3496,26 @@ size_t ParameterizedType_IntegerOption::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType_IntegerOption::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType.IntegerOption) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType_IntegerOption* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType.IntegerOption) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType.IntegerOption) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_IntegerOption::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType_IntegerOption::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_IntegerOption::GetClassData() const { return &_class_data_; } + +void ParameterizedType_IntegerOption::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType_IntegerOption::MergeFrom(const ParameterizedType_IntegerOption& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.IntegerOption) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.integer_type_case()) { @@ -3605,13 +3531,7 @@ void ParameterizedType_IntegerOption::MergeFrom(const ParameterizedType_IntegerO break; } } -} - -void ParameterizedType_IntegerOption::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType.IntegerOption) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType_IntegerOption::CopyFrom(const ParameterizedType_IntegerOption& from) { @@ -3627,7 +3547,7 @@ bool ParameterizedType_IntegerOption::IsInitialized() const { void ParameterizedType_IntegerOption::InternalSwap(ParameterizedType_IntegerOption* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(integer_type_, other->integer_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -3765,11 +3685,13 @@ ParameterizedType::_Internal::type_parameter(const ParameterizedType* msg) { return *msg->kind_.type_parameter_; } void ParameterizedType::set_allocated_bool_(::substrait::Type_Boolean* bool_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (bool_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_)); if (message_arena != submessage_arena) { bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, bool_, submessage_arena); @@ -3781,18 +3703,20 @@ void ParameterizedType::set_allocated_bool_(::substrait::Type_Boolean* bool_) { } void ParameterizedType::clear_bool_() { if (_internal_has_bool_()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.bool__; } clear_has_kind(); } } void ParameterizedType::set_allocated_i8(::substrait::Type_I8* i8) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i8) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8)); if (message_arena != submessage_arena) { i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i8, submessage_arena); @@ -3804,18 +3728,20 @@ void ParameterizedType::set_allocated_i8(::substrait::Type_I8* i8) { } void ParameterizedType::clear_i8() { if (_internal_has_i8()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i8_; } clear_has_kind(); } } void ParameterizedType::set_allocated_i16(::substrait::Type_I16* i16) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i16) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16)); if (message_arena != submessage_arena) { i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i16, submessage_arena); @@ -3827,18 +3753,20 @@ void ParameterizedType::set_allocated_i16(::substrait::Type_I16* i16) { } void ParameterizedType::clear_i16() { if (_internal_has_i16()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i16_; } clear_has_kind(); } } void ParameterizedType::set_allocated_i32(::substrait::Type_I32* i32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i32) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32)); if (message_arena != submessage_arena) { i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i32, submessage_arena); @@ -3850,18 +3778,20 @@ void ParameterizedType::set_allocated_i32(::substrait::Type_I32* i32) { } void ParameterizedType::clear_i32() { if (_internal_has_i32()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i32_; } clear_has_kind(); } } void ParameterizedType::set_allocated_i64(::substrait::Type_I64* i64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i64) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64)); if (message_arena != submessage_arena) { i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i64, submessage_arena); @@ -3873,18 +3803,20 @@ void ParameterizedType::set_allocated_i64(::substrait::Type_I64* i64) { } void ParameterizedType::clear_i64() { if (_internal_has_i64()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i64_; } clear_has_kind(); } } void ParameterizedType::set_allocated_fp32(::substrait::Type_FP32* fp32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fp32) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32)); if (message_arena != submessage_arena) { fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fp32, submessage_arena); @@ -3896,18 +3828,20 @@ void ParameterizedType::set_allocated_fp32(::substrait::Type_FP32* fp32) { } void ParameterizedType::clear_fp32() { if (_internal_has_fp32()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp32_; } clear_has_kind(); } } void ParameterizedType::set_allocated_fp64(::substrait::Type_FP64* fp64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fp64) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64)); if (message_arena != submessage_arena) { fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fp64, submessage_arena); @@ -3919,18 +3853,20 @@ void ParameterizedType::set_allocated_fp64(::substrait::Type_FP64* fp64) { } void ParameterizedType::clear_fp64() { if (_internal_has_fp64()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp64_; } clear_has_kind(); } } void ParameterizedType::set_allocated_string(::substrait::Type_String* string) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (string) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string)); if (message_arena != submessage_arena) { string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, string, submessage_arena); @@ -3942,18 +3878,20 @@ void ParameterizedType::set_allocated_string(::substrait::Type_String* string) { } void ParameterizedType::clear_string() { if (_internal_has_string()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.string_; } clear_has_kind(); } } void ParameterizedType::set_allocated_binary(::substrait::Type_Binary* binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (binary) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary)); if (message_arena != submessage_arena) { binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, binary, submessage_arena); @@ -3965,18 +3903,20 @@ void ParameterizedType::set_allocated_binary(::substrait::Type_Binary* binary) { } void ParameterizedType::clear_binary() { if (_internal_has_binary()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.binary_; } clear_has_kind(); } } void ParameterizedType::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (timestamp) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp)); if (message_arena != submessage_arena) { timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, timestamp, submessage_arena); @@ -3988,18 +3928,20 @@ void ParameterizedType::set_allocated_timestamp(::substrait::Type_Timestamp* tim } void ParameterizedType::clear_timestamp() { if (_internal_has_timestamp()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_; } clear_has_kind(); } } void ParameterizedType::set_allocated_date(::substrait::Type_Date* date) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (date) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date)); if (message_arena != submessage_arena) { date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, date, submessage_arena); @@ -4011,18 +3953,20 @@ void ParameterizedType::set_allocated_date(::substrait::Type_Date* date) { } void ParameterizedType::clear_date() { if (_internal_has_date()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.date_; } clear_has_kind(); } } void ParameterizedType::set_allocated_time(::substrait::Type_Time* time) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (time) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time)); if (message_arena != submessage_arena) { time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, time, submessage_arena); @@ -4034,18 +3978,20 @@ void ParameterizedType::set_allocated_time(::substrait::Type_Time* time) { } void ParameterizedType::clear_time() { if (_internal_has_time()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.time_; } clear_has_kind(); } } void ParameterizedType::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (interval_year) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year)); if (message_arena != submessage_arena) { interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, interval_year, submessage_arena); @@ -4057,18 +4003,20 @@ void ParameterizedType::set_allocated_interval_year(::substrait::Type_IntervalYe } void ParameterizedType::clear_interval_year() { if (_internal_has_interval_year()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_year_; } clear_has_kind(); } } void ParameterizedType::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (interval_day) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day)); if (message_arena != submessage_arena) { interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, interval_day, submessage_arena); @@ -4080,18 +4028,20 @@ void ParameterizedType::set_allocated_interval_day(::substrait::Type_IntervalDay } void ParameterizedType::clear_interval_day() { if (_internal_has_interval_day()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_day_; } clear_has_kind(); } } void ParameterizedType::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (timestamp_tz) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz)); if (message_arena != submessage_arena) { timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, timestamp_tz, submessage_arena); @@ -4103,18 +4053,20 @@ void ParameterizedType::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ } void ParameterizedType::clear_timestamp_tz() { if (_internal_has_timestamp_tz()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_tz_; } clear_has_kind(); } } void ParameterizedType::set_allocated_uuid(::substrait::Type_UUID* uuid) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (uuid) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid)); if (message_arena != submessage_arena) { uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, uuid, submessage_arena); @@ -4126,18 +4078,18 @@ void ParameterizedType::set_allocated_uuid(::substrait::Type_UUID* uuid) { } void ParameterizedType::clear_uuid() { if (_internal_has_uuid()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.uuid_; } clear_has_kind(); } } void ParameterizedType::set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fixed_char) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_char); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedFixedChar>::GetOwningArena(fixed_char); if (message_arena != submessage_arena) { fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fixed_char, submessage_arena); @@ -4148,11 +4100,11 @@ void ParameterizedType::set_allocated_fixed_char(::substrait::ParameterizedType_ // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fixed_char) } void ParameterizedType::set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (varchar) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(varchar); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedVarChar>::GetOwningArena(varchar); if (message_arena != submessage_arena) { varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, varchar, submessage_arena); @@ -4163,11 +4115,11 @@ void ParameterizedType::set_allocated_varchar(::substrait::ParameterizedType_Par // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.varchar) } void ParameterizedType::set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fixed_binary) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_binary); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedFixedBinary>::GetOwningArena(fixed_binary); if (message_arena != submessage_arena) { fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fixed_binary, submessage_arena); @@ -4178,11 +4130,11 @@ void ParameterizedType::set_allocated_fixed_binary(::substrait::ParameterizedTyp // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fixed_binary) } void ParameterizedType::set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (decimal) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(decimal); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedDecimal>::GetOwningArena(decimal); if (message_arena != submessage_arena) { decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, decimal, submessage_arena); @@ -4193,11 +4145,11 @@ void ParameterizedType::set_allocated_decimal(::substrait::ParameterizedType_Par // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.decimal) } void ParameterizedType::set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedStruct>::GetOwningArena(struct_); if (message_arena != submessage_arena) { struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, struct_, submessage_arena); @@ -4208,11 +4160,11 @@ void ParameterizedType::set_allocated_struct_(::substrait::ParameterizedType_Par // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.struct) } void ParameterizedType::set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (list) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedList>::GetOwningArena(list); if (message_arena != submessage_arena) { list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, list, submessage_arena); @@ -4223,11 +4175,11 @@ void ParameterizedType::set_allocated_list(::substrait::ParameterizedType_Parame // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.list) } void ParameterizedType::set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (map) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedMap>::GetOwningArena(map); if (message_arena != submessage_arena) { map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, map, submessage_arena); @@ -4238,11 +4190,11 @@ void ParameterizedType::set_allocated_map(::substrait::ParameterizedType_Paramet // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.map) } void ParameterizedType::set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (type_parameter) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type_parameter); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_TypeParameter>::GetOwningArena(type_parameter); if (message_arena != submessage_arena) { type_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type_parameter, submessage_arena); @@ -4252,10 +4204,13 @@ void ParameterizedType::set_allocated_type_parameter(::substrait::ParameterizedT } // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.type_parameter) } -ParameterizedType::ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ParameterizedType::ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType) } ParameterizedType::ParameterizedType(const ParameterizedType& from) @@ -4370,18 +4325,19 @@ ParameterizedType::ParameterizedType(const ParameterizedType& from) // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType) } -void ParameterizedType::SharedCtor() { +inline void ParameterizedType::SharedCtor() { clear_has_kind(); } ParameterizedType::~ParameterizedType() { // @@protoc_insertion_point(destructor:substrait.ParameterizedType) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ParameterizedType::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ParameterizedType::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_kind()) { clear_kind(); } @@ -4401,139 +4357,139 @@ void ParameterizedType::clear_kind() { // @@protoc_insertion_point(one_of_clear_start:substrait.ParameterizedType) switch (kind_case()) { case kBool: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.bool__; } break; } case kI8: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i8_; } break; } case kI16: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i16_; } break; } case kI32: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i32_; } break; } case kI64: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i64_; } break; } case kFp32: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp32_; } break; } case kFp64: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp64_; } break; } case kString: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.string_; } break; } case kBinary: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.binary_; } break; } case kTimestamp: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_; } break; } case kDate: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.date_; } break; } case kTime: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.time_; } break; } case kIntervalYear: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_year_; } break; } case kIntervalDay: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_day_; } break; } case kTimestampTz: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_tz_; } break; } case kUuid: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.uuid_; } break; } case kFixedChar: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_char_; } break; } case kVarchar: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.varchar_; } break; } case kFixedBinary: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_binary_; } break; } case kDecimal: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.decimal_; } break; } case kStruct: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.struct__; } break; } case kList: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.list_; } break; } case kMap: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.map_; } break; @@ -4543,7 +4499,7 @@ void ParameterizedType::clear_kind() { break; } case kTypeParameter: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.type_parameter_; } break; @@ -4558,7 +4514,7 @@ void ParameterizedType::clear_kind() { void ParameterizedType::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4569,211 +4525,236 @@ void ParameterizedType::Clear() { const char* ParameterizedType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Type.Boolean bool = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I8 i8 = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I16 i16 = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I32 i32 = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I64 i64 = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.FP32 fp32 = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.FP64 fp64 = 11; case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.String string = 12; case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Binary binary = 13; case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Timestamp timestamp = 14; case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Date date = 16; case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Time time = 17; case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.IntervalYear interval_year = 19; case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.IntervalDay interval_day = 20; case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.ParameterizedStruct struct = 25; case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.ParameterizedList list = 27; case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.ParameterizedMap map = 28; case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.TimestampTZ timestamp_tz = 29; case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 user_defined_pointer = 31; case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 248)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.UUID uuid = 32; case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ParameterizedType.TypeParameter type_parameter = 33; case 33: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type_parameter(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ParameterizedType::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ParameterizedType::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Type.Boolean bool = 1; @@ -4986,7 +4967,7 @@ size_t ParameterizedType::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5170,35 +5151,26 @@ size_t ParameterizedType::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ParameterizedType::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ParameterizedType) - GOOGLE_DCHECK_NE(&from, this); - const ParameterizedType* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ParameterizedType) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ParameterizedType) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ParameterizedType::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType::GetClassData() const { return &_class_data_; } + +void ParameterizedType::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ParameterizedType::MergeFrom(const ParameterizedType& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.kind_case()) { @@ -5306,13 +5278,7 @@ void ParameterizedType::MergeFrom(const ParameterizedType& from) { break; } } -} - -void ParameterizedType::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ParameterizedType) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ParameterizedType::CopyFrom(const ParameterizedType& from) { @@ -5328,7 +5294,7 @@ bool ParameterizedType::IsInitialized() const { void ParameterizedType::InternalSwap(ParameterizedType* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(kind_, other->kind_); swap(_oneof_case_[0], other->_oneof_case_[0]); } diff --git a/cpp/src/generated/substrait/parameterized_types.pb.h b/cpp/src/generated/substrait/parameterized_types.pb.h index 3d3d6a499fc..ae85f689870 100644 --- a/cpp/src/generated/substrait/parameterized_types.pb.h +++ b/cpp/src/generated/substrait/parameterized_types.pb.h @@ -8,12 +8,12 @@ #include #include -#if PROTOBUF_VERSION < 3016000 +#if PROTOBUF_VERSION < 3019000 #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 3016000 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019003 < 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. @@ -51,7 +51,7 @@ struct TableStruct_substrait_2fparameterized_5ftypes_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; + static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fparameterized_5ftypes_2eproto; namespace substrait { @@ -114,7 +114,7 @@ namespace substrait { // =================================================================== -class ParameterizedType_TypeParameter PROTOBUF_FINAL : +class ParameterizedType_TypeParameter final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.TypeParameter) */ { public: inline ParameterizedType_TypeParameter() : ParameterizedType_TypeParameter(nullptr) {} @@ -132,8 +132,13 @@ class ParameterizedType_TypeParameter PROTOBUF_FINAL : return *this; } inline ParameterizedType_TypeParameter& operator=(ParameterizedType_TypeParameter&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -164,7 +169,12 @@ class ParameterizedType_TypeParameter PROTOBUF_FINAL : } inline void Swap(ParameterizedType_TypeParameter* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -172,48 +182,53 @@ class ParameterizedType_TypeParameter PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_TypeParameter* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_TypeParameter* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_TypeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_TypeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_TypeParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_TypeParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_TypeParameter* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.TypeParameter"; } protected: - explicit ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -248,11 +263,11 @@ class ParameterizedType_TypeParameter PROTOBUF_FINAL : template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); - std::string* release_name(); + PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: @@ -270,7 +285,7 @@ class ParameterizedType_TypeParameter PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class ParameterizedType_IntegerParameter PROTOBUF_FINAL : +class ParameterizedType_IntegerParameter final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.IntegerParameter) */ { public: inline ParameterizedType_IntegerParameter() : ParameterizedType_IntegerParameter(nullptr) {} @@ -288,8 +303,13 @@ class ParameterizedType_IntegerParameter PROTOBUF_FINAL : return *this; } inline ParameterizedType_IntegerParameter& operator=(ParameterizedType_IntegerParameter&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -320,7 +340,12 @@ class ParameterizedType_IntegerParameter PROTOBUF_FINAL : } inline void Swap(ParameterizedType_IntegerParameter* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -328,48 +353,53 @@ class ParameterizedType_IntegerParameter PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_IntegerParameter* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_IntegerParameter* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_IntegerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_IntegerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_IntegerParameter& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_IntegerParameter& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_IntegerParameter* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.IntegerParameter"; } protected: - explicit ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -387,11 +417,11 @@ class ParameterizedType_IntegerParameter PROTOBUF_FINAL : template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); - std::string* release_name(); + PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: @@ -402,7 +432,7 @@ class ParameterizedType_IntegerParameter PROTOBUF_FINAL : public: void clear_range_start_inclusive(); const ::substrait::ParameterizedType_NullableInteger& range_start_inclusive() const; - ::substrait::ParameterizedType_NullableInteger* release_range_start_inclusive(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_NullableInteger* release_range_start_inclusive(); ::substrait::ParameterizedType_NullableInteger* mutable_range_start_inclusive(); void set_allocated_range_start_inclusive(::substrait::ParameterizedType_NullableInteger* range_start_inclusive); private: @@ -420,7 +450,7 @@ class ParameterizedType_IntegerParameter PROTOBUF_FINAL : public: void clear_range_end_exclusive(); const ::substrait::ParameterizedType_NullableInteger& range_end_exclusive() const; - ::substrait::ParameterizedType_NullableInteger* release_range_end_exclusive(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_NullableInteger* release_range_end_exclusive(); ::substrait::ParameterizedType_NullableInteger* mutable_range_end_exclusive(); void set_allocated_range_end_exclusive(::substrait::ParameterizedType_NullableInteger* range_end_exclusive); private: @@ -446,7 +476,7 @@ class ParameterizedType_IntegerParameter PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class ParameterizedType_NullableInteger PROTOBUF_FINAL : +class ParameterizedType_NullableInteger final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.NullableInteger) */ { public: inline ParameterizedType_NullableInteger() : ParameterizedType_NullableInteger(nullptr) {} @@ -464,8 +494,13 @@ class ParameterizedType_NullableInteger PROTOBUF_FINAL : return *this; } inline ParameterizedType_NullableInteger& operator=(ParameterizedType_NullableInteger&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -496,7 +531,12 @@ class ParameterizedType_NullableInteger PROTOBUF_FINAL : } inline void Swap(ParameterizedType_NullableInteger* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -504,48 +544,53 @@ class ParameterizedType_NullableInteger PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_NullableInteger* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_NullableInteger* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_NullableInteger* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_NullableInteger* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_NullableInteger& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_NullableInteger& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_NullableInteger* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.NullableInteger"; } protected: - explicit ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -557,11 +602,11 @@ class ParameterizedType_NullableInteger PROTOBUF_FINAL : }; // int64 value = 1; void clear_value(); - ::PROTOBUF_NAMESPACE_ID::int64 value() const; - void set_value(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t value() const; + void set_value(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_value() const; - void _internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_value() const; + void _internal_set_value(int64_t value); public: // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.NullableInteger) @@ -571,13 +616,13 @@ class ParameterizedType_NullableInteger PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int64 value_; + int64_t value_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- -class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : +class ParameterizedType_ParameterizedFixedChar final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedFixedChar) */ { public: inline ParameterizedType_ParameterizedFixedChar() : ParameterizedType_ParameterizedFixedChar(nullptr) {} @@ -595,8 +640,13 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : return *this; } inline ParameterizedType_ParameterizedFixedChar& operator=(ParameterizedType_ParameterizedFixedChar&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -627,7 +677,12 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : } inline void Swap(ParameterizedType_ParameterizedFixedChar* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -635,48 +690,53 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_ParameterizedFixedChar* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_ParameterizedFixedChar* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_ParameterizedFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_ParameterizedFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_ParameterizedFixedChar& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_ParameterizedFixedChar& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_ParameterizedFixedChar* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.ParameterizedFixedChar"; } protected: - explicit ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -695,7 +755,7 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : public: void clear_length(); const ::substrait::ParameterizedType_IntegerOption& length() const; - ::substrait::ParameterizedType_IntegerOption* release_length(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_length(); ::substrait::ParameterizedType_IntegerOption* mutable_length(); void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length); private: @@ -708,11 +768,11 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : // uint32 variation_pointer = 2; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -732,14 +792,14 @@ class ParameterizedType_ParameterizedFixedChar PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::ParameterizedType_IntegerOption* length_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- -class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : +class ParameterizedType_ParameterizedVarChar final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedVarChar) */ { public: inline ParameterizedType_ParameterizedVarChar() : ParameterizedType_ParameterizedVarChar(nullptr) {} @@ -757,8 +817,13 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : return *this; } inline ParameterizedType_ParameterizedVarChar& operator=(ParameterizedType_ParameterizedVarChar&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -789,7 +854,12 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : } inline void Swap(ParameterizedType_ParameterizedVarChar* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -797,48 +867,53 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_ParameterizedVarChar* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_ParameterizedVarChar* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_ParameterizedVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_ParameterizedVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_ParameterizedVarChar& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_ParameterizedVarChar& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_ParameterizedVarChar* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.ParameterizedVarChar"; } protected: - explicit ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -857,7 +932,7 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : public: void clear_length(); const ::substrait::ParameterizedType_IntegerOption& length() const; - ::substrait::ParameterizedType_IntegerOption* release_length(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_length(); ::substrait::ParameterizedType_IntegerOption* mutable_length(); void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length); private: @@ -870,11 +945,11 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : // uint32 variation_pointer = 2; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -894,14 +969,14 @@ class ParameterizedType_ParameterizedVarChar PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::ParameterizedType_IntegerOption* length_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- -class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : +class ParameterizedType_ParameterizedFixedBinary final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedFixedBinary) */ { public: inline ParameterizedType_ParameterizedFixedBinary() : ParameterizedType_ParameterizedFixedBinary(nullptr) {} @@ -919,8 +994,13 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : return *this; } inline ParameterizedType_ParameterizedFixedBinary& operator=(ParameterizedType_ParameterizedFixedBinary&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -951,7 +1031,12 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : } inline void Swap(ParameterizedType_ParameterizedFixedBinary* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -959,48 +1044,53 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_ParameterizedFixedBinary* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_ParameterizedFixedBinary* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_ParameterizedFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_ParameterizedFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_ParameterizedFixedBinary& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_ParameterizedFixedBinary& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_ParameterizedFixedBinary* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.ParameterizedFixedBinary"; } protected: - explicit ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1019,7 +1109,7 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : public: void clear_length(); const ::substrait::ParameterizedType_IntegerOption& length() const; - ::substrait::ParameterizedType_IntegerOption* release_length(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_length(); ::substrait::ParameterizedType_IntegerOption* mutable_length(); void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length); private: @@ -1032,11 +1122,11 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : // uint32 variation_pointer = 2; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -1056,14 +1146,14 @@ class ParameterizedType_ParameterizedFixedBinary PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::ParameterizedType_IntegerOption* length_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- -class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : +class ParameterizedType_ParameterizedDecimal final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedDecimal) */ { public: inline ParameterizedType_ParameterizedDecimal() : ParameterizedType_ParameterizedDecimal(nullptr) {} @@ -1081,8 +1171,13 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : return *this; } inline ParameterizedType_ParameterizedDecimal& operator=(ParameterizedType_ParameterizedDecimal&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1113,7 +1208,12 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : } inline void Swap(ParameterizedType_ParameterizedDecimal* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1121,48 +1221,53 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_ParameterizedDecimal* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_ParameterizedDecimal* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_ParameterizedDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_ParameterizedDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_ParameterizedDecimal& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_ParameterizedDecimal& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_ParameterizedDecimal* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.ParameterizedDecimal"; } protected: - explicit ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1182,7 +1287,7 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : public: void clear_scale(); const ::substrait::ParameterizedType_IntegerOption& scale() const; - ::substrait::ParameterizedType_IntegerOption* release_scale(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_scale(); ::substrait::ParameterizedType_IntegerOption* mutable_scale(); void set_allocated_scale(::substrait::ParameterizedType_IntegerOption* scale); private: @@ -1200,7 +1305,7 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : public: void clear_precision(); const ::substrait::ParameterizedType_IntegerOption& precision() const; - ::substrait::ParameterizedType_IntegerOption* release_precision(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_precision(); ::substrait::ParameterizedType_IntegerOption* mutable_precision(); void set_allocated_precision(::substrait::ParameterizedType_IntegerOption* precision); private: @@ -1213,11 +1318,11 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : // uint32 variation_pointer = 3; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 4; @@ -1238,14 +1343,14 @@ class ParameterizedType_ParameterizedDecimal PROTOBUF_FINAL : typedef void DestructorSkippable_; ::substrait::ParameterizedType_IntegerOption* scale_; ::substrait::ParameterizedType_IntegerOption* precision_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- -class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : +class ParameterizedType_ParameterizedStruct final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedStruct) */ { public: inline ParameterizedType_ParameterizedStruct() : ParameterizedType_ParameterizedStruct(nullptr) {} @@ -1263,8 +1368,13 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : return *this; } inline ParameterizedType_ParameterizedStruct& operator=(ParameterizedType_ParameterizedStruct&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1295,7 +1405,12 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : } inline void Swap(ParameterizedType_ParameterizedStruct* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1303,48 +1418,53 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_ParameterizedStruct* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_ParameterizedStruct* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_ParameterizedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_ParameterizedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_ParameterizedStruct& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_ParameterizedStruct& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_ParameterizedStruct* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.ParameterizedStruct"; } protected: - explicit ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1376,11 +1496,11 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : // uint32 variation_pointer = 2; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -1400,14 +1520,14 @@ class ParameterizedType_ParameterizedStruct PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType > types_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- -class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : +class ParameterizedType_ParameterizedNamedStruct final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedNamedStruct) */ { public: inline ParameterizedType_ParameterizedNamedStruct() : ParameterizedType_ParameterizedNamedStruct(nullptr) {} @@ -1425,8 +1545,13 @@ class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : return *this; } inline ParameterizedType_ParameterizedNamedStruct& operator=(ParameterizedType_ParameterizedNamedStruct&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1457,7 +1582,12 @@ class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : } inline void Swap(ParameterizedType_ParameterizedNamedStruct* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1465,48 +1595,53 @@ class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_ParameterizedNamedStruct* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_ParameterizedNamedStruct* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_ParameterizedNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_ParameterizedNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_ParameterizedNamedStruct& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_ParameterizedNamedStruct& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_ParameterizedNamedStruct* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.ParameterizedNamedStruct"; } protected: - explicit ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1548,7 +1683,7 @@ class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : public: void clear_struct_(); const ::substrait::ParameterizedType_ParameterizedStruct& struct_() const; - ::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); ::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_(); void set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_); private: @@ -1573,7 +1708,7 @@ class ParameterizedType_ParameterizedNamedStruct PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class ParameterizedType_ParameterizedList PROTOBUF_FINAL : +class ParameterizedType_ParameterizedList final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedList) */ { public: inline ParameterizedType_ParameterizedList() : ParameterizedType_ParameterizedList(nullptr) {} @@ -1591,8 +1726,13 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : return *this; } inline ParameterizedType_ParameterizedList& operator=(ParameterizedType_ParameterizedList&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1623,7 +1763,12 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : } inline void Swap(ParameterizedType_ParameterizedList* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1631,48 +1776,53 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_ParameterizedList* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_ParameterizedList* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_ParameterizedList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_ParameterizedList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_ParameterizedList& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_ParameterizedList& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_ParameterizedList* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.ParameterizedList"; } protected: - explicit ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1691,7 +1841,7 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : public: void clear_type(); const ::substrait::ParameterizedType& type() const; - ::substrait::ParameterizedType* release_type(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type(); ::substrait::ParameterizedType* mutable_type(); void set_allocated_type(::substrait::ParameterizedType* type); private: @@ -1704,11 +1854,11 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : // uint32 variation_pointer = 2; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -1728,14 +1878,14 @@ class ParameterizedType_ParameterizedList PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::ParameterizedType* type_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- -class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : +class ParameterizedType_ParameterizedMap final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedMap) */ { public: inline ParameterizedType_ParameterizedMap() : ParameterizedType_ParameterizedMap(nullptr) {} @@ -1753,8 +1903,13 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : return *this; } inline ParameterizedType_ParameterizedMap& operator=(ParameterizedType_ParameterizedMap&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1785,7 +1940,12 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : } inline void Swap(ParameterizedType_ParameterizedMap* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1793,48 +1953,53 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_ParameterizedMap* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_ParameterizedMap* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_ParameterizedMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_ParameterizedMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_ParameterizedMap& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_ParameterizedMap& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_ParameterizedMap* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.ParameterizedMap"; } protected: - explicit ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1854,7 +2019,7 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : public: void clear_key(); const ::substrait::ParameterizedType& key() const; - ::substrait::ParameterizedType* release_key(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_key(); ::substrait::ParameterizedType* mutable_key(); void set_allocated_key(::substrait::ParameterizedType* key); private: @@ -1872,7 +2037,7 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : public: void clear_value(); const ::substrait::ParameterizedType& value() const; - ::substrait::ParameterizedType* release_value(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_value(); ::substrait::ParameterizedType* mutable_value(); void set_allocated_value(::substrait::ParameterizedType* value); private: @@ -1885,11 +2050,11 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : // uint32 variation_pointer = 3; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 4; @@ -1910,14 +2075,14 @@ class ParameterizedType_ParameterizedMap PROTOBUF_FINAL : typedef void DestructorSkippable_; ::substrait::ParameterizedType* key_; ::substrait::ParameterizedType* value_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- -class ParameterizedType_IntegerOption PROTOBUF_FINAL : +class ParameterizedType_IntegerOption final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.IntegerOption) */ { public: inline ParameterizedType_IntegerOption() : ParameterizedType_IntegerOption(nullptr) {} @@ -1935,8 +2100,13 @@ class ParameterizedType_IntegerOption PROTOBUF_FINAL : return *this; } inline ParameterizedType_IntegerOption& operator=(ParameterizedType_IntegerOption&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1973,7 +2143,12 @@ class ParameterizedType_IntegerOption PROTOBUF_FINAL : } inline void Swap(ParameterizedType_IntegerOption* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1981,48 +2156,53 @@ class ParameterizedType_IntegerOption PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType_IntegerOption* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType_IntegerOption* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType_IntegerOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType_IntegerOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType_IntegerOption& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType_IntegerOption& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType_IntegerOption* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType.IntegerOption"; } protected: - explicit ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2039,11 +2219,11 @@ class ParameterizedType_IntegerOption PROTOBUF_FINAL : bool _internal_has_literal() const; public: void clear_literal(); - ::PROTOBUF_NAMESPACE_ID::int32 literal() const; - void set_literal(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t literal() const; + void set_literal(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_literal() const; - void _internal_set_literal(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_literal() const; + void _internal_set_literal(int32_t value); public: // .substrait.ParameterizedType.IntegerParameter parameter = 2; @@ -2053,7 +2233,7 @@ class ParameterizedType_IntegerOption PROTOBUF_FINAL : public: void clear_parameter(); const ::substrait::ParameterizedType_IntegerParameter& parameter() const; - ::substrait::ParameterizedType_IntegerParameter* release_parameter(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerParameter* release_parameter(); ::substrait::ParameterizedType_IntegerParameter* mutable_parameter(); void set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter); private: @@ -2081,17 +2261,17 @@ class ParameterizedType_IntegerOption PROTOBUF_FINAL : union IntegerTypeUnion { constexpr IntegerTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::PROTOBUF_NAMESPACE_ID::int32 literal_; + int32_t literal_; ::substrait::ParameterizedType_IntegerParameter* parameter_; } integer_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; // ------------------------------------------------------------------- -class ParameterizedType PROTOBUF_FINAL : +class ParameterizedType final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType) */ { public: inline ParameterizedType() : ParameterizedType(nullptr) {} @@ -2109,8 +2289,13 @@ class ParameterizedType PROTOBUF_FINAL : return *this; } inline ParameterizedType& operator=(ParameterizedType&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2170,7 +2355,12 @@ class ParameterizedType PROTOBUF_FINAL : } inline void Swap(ParameterizedType* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2178,48 +2368,53 @@ class ParameterizedType PROTOBUF_FINAL : } void UnsafeArenaSwap(ParameterizedType* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ParameterizedType* New() const final { - return CreateMaybeMessage(nullptr); - } - - ParameterizedType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ParameterizedType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ParameterizedType& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ParameterizedType& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ParameterizedType* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ParameterizedType"; } protected: - explicit ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2273,7 +2468,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_bool_(); const ::substrait::Type_Boolean& bool_() const; - ::substrait::Type_Boolean* release_bool_(); + PROTOBUF_NODISCARD ::substrait::Type_Boolean* release_bool_(); ::substrait::Type_Boolean* mutable_bool_(); void set_allocated_bool_(::substrait::Type_Boolean* bool_); private: @@ -2291,7 +2486,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_i8(); const ::substrait::Type_I8& i8() const; - ::substrait::Type_I8* release_i8(); + PROTOBUF_NODISCARD ::substrait::Type_I8* release_i8(); ::substrait::Type_I8* mutable_i8(); void set_allocated_i8(::substrait::Type_I8* i8); private: @@ -2309,7 +2504,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_i16(); const ::substrait::Type_I16& i16() const; - ::substrait::Type_I16* release_i16(); + PROTOBUF_NODISCARD ::substrait::Type_I16* release_i16(); ::substrait::Type_I16* mutable_i16(); void set_allocated_i16(::substrait::Type_I16* i16); private: @@ -2327,7 +2522,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_i32(); const ::substrait::Type_I32& i32() const; - ::substrait::Type_I32* release_i32(); + PROTOBUF_NODISCARD ::substrait::Type_I32* release_i32(); ::substrait::Type_I32* mutable_i32(); void set_allocated_i32(::substrait::Type_I32* i32); private: @@ -2345,7 +2540,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_i64(); const ::substrait::Type_I64& i64() const; - ::substrait::Type_I64* release_i64(); + PROTOBUF_NODISCARD ::substrait::Type_I64* release_i64(); ::substrait::Type_I64* mutable_i64(); void set_allocated_i64(::substrait::Type_I64* i64); private: @@ -2363,7 +2558,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_fp32(); const ::substrait::Type_FP32& fp32() const; - ::substrait::Type_FP32* release_fp32(); + PROTOBUF_NODISCARD ::substrait::Type_FP32* release_fp32(); ::substrait::Type_FP32* mutable_fp32(); void set_allocated_fp32(::substrait::Type_FP32* fp32); private: @@ -2381,7 +2576,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_fp64(); const ::substrait::Type_FP64& fp64() const; - ::substrait::Type_FP64* release_fp64(); + PROTOBUF_NODISCARD ::substrait::Type_FP64* release_fp64(); ::substrait::Type_FP64* mutable_fp64(); void set_allocated_fp64(::substrait::Type_FP64* fp64); private: @@ -2399,7 +2594,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_string(); const ::substrait::Type_String& string() const; - ::substrait::Type_String* release_string(); + PROTOBUF_NODISCARD ::substrait::Type_String* release_string(); ::substrait::Type_String* mutable_string(); void set_allocated_string(::substrait::Type_String* string); private: @@ -2417,7 +2612,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_binary(); const ::substrait::Type_Binary& binary() const; - ::substrait::Type_Binary* release_binary(); + PROTOBUF_NODISCARD ::substrait::Type_Binary* release_binary(); ::substrait::Type_Binary* mutable_binary(); void set_allocated_binary(::substrait::Type_Binary* binary); private: @@ -2435,7 +2630,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_timestamp(); const ::substrait::Type_Timestamp& timestamp() const; - ::substrait::Type_Timestamp* release_timestamp(); + PROTOBUF_NODISCARD ::substrait::Type_Timestamp* release_timestamp(); ::substrait::Type_Timestamp* mutable_timestamp(); void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp); private: @@ -2453,7 +2648,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_date(); const ::substrait::Type_Date& date() const; - ::substrait::Type_Date* release_date(); + PROTOBUF_NODISCARD ::substrait::Type_Date* release_date(); ::substrait::Type_Date* mutable_date(); void set_allocated_date(::substrait::Type_Date* date); private: @@ -2471,7 +2666,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_time(); const ::substrait::Type_Time& time() const; - ::substrait::Type_Time* release_time(); + PROTOBUF_NODISCARD ::substrait::Type_Time* release_time(); ::substrait::Type_Time* mutable_time(); void set_allocated_time(::substrait::Type_Time* time); private: @@ -2489,7 +2684,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_interval_year(); const ::substrait::Type_IntervalYear& interval_year() const; - ::substrait::Type_IntervalYear* release_interval_year(); + PROTOBUF_NODISCARD ::substrait::Type_IntervalYear* release_interval_year(); ::substrait::Type_IntervalYear* mutable_interval_year(); void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year); private: @@ -2507,7 +2702,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_interval_day(); const ::substrait::Type_IntervalDay& interval_day() const; - ::substrait::Type_IntervalDay* release_interval_day(); + PROTOBUF_NODISCARD ::substrait::Type_IntervalDay* release_interval_day(); ::substrait::Type_IntervalDay* mutable_interval_day(); void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day); private: @@ -2525,7 +2720,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_timestamp_tz(); const ::substrait::Type_TimestampTZ& timestamp_tz() const; - ::substrait::Type_TimestampTZ* release_timestamp_tz(); + PROTOBUF_NODISCARD ::substrait::Type_TimestampTZ* release_timestamp_tz(); ::substrait::Type_TimestampTZ* mutable_timestamp_tz(); void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz); private: @@ -2543,7 +2738,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_uuid(); const ::substrait::Type_UUID& uuid() const; - ::substrait::Type_UUID* release_uuid(); + PROTOBUF_NODISCARD ::substrait::Type_UUID* release_uuid(); ::substrait::Type_UUID* mutable_uuid(); void set_allocated_uuid(::substrait::Type_UUID* uuid); private: @@ -2561,7 +2756,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_fixed_char(); const ::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char() const; - ::substrait::ParameterizedType_ParameterizedFixedChar* release_fixed_char(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedFixedChar* release_fixed_char(); ::substrait::ParameterizedType_ParameterizedFixedChar* mutable_fixed_char(); void set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char); private: @@ -2579,7 +2774,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_varchar(); const ::substrait::ParameterizedType_ParameterizedVarChar& varchar() const; - ::substrait::ParameterizedType_ParameterizedVarChar* release_varchar(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedVarChar* release_varchar(); ::substrait::ParameterizedType_ParameterizedVarChar* mutable_varchar(); void set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar); private: @@ -2597,7 +2792,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_fixed_binary(); const ::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary() const; - ::substrait::ParameterizedType_ParameterizedFixedBinary* release_fixed_binary(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedFixedBinary* release_fixed_binary(); ::substrait::ParameterizedType_ParameterizedFixedBinary* mutable_fixed_binary(); void set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary); private: @@ -2615,7 +2810,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_decimal(); const ::substrait::ParameterizedType_ParameterizedDecimal& decimal() const; - ::substrait::ParameterizedType_ParameterizedDecimal* release_decimal(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedDecimal* release_decimal(); ::substrait::ParameterizedType_ParameterizedDecimal* mutable_decimal(); void set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal); private: @@ -2633,7 +2828,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_struct_(); const ::substrait::ParameterizedType_ParameterizedStruct& struct_() const; - ::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); ::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_(); void set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_); private: @@ -2651,7 +2846,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_list(); const ::substrait::ParameterizedType_ParameterizedList& list() const; - ::substrait::ParameterizedType_ParameterizedList* release_list(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedList* release_list(); ::substrait::ParameterizedType_ParameterizedList* mutable_list(); void set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list); private: @@ -2669,7 +2864,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_map(); const ::substrait::ParameterizedType_ParameterizedMap& map() const; - ::substrait::ParameterizedType_ParameterizedMap* release_map(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedMap* release_map(); ::substrait::ParameterizedType_ParameterizedMap* mutable_map(); void set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map); private: @@ -2686,11 +2881,11 @@ class ParameterizedType PROTOBUF_FINAL : bool _internal_has_user_defined_pointer() const; public: void clear_user_defined_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_pointer() const; - void set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t user_defined_pointer() const; + void set_user_defined_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_user_defined_pointer() const; - void _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_user_defined_pointer() const; + void _internal_set_user_defined_pointer(uint32_t value); public: // .substrait.ParameterizedType.TypeParameter type_parameter = 33; @@ -2700,7 +2895,7 @@ class ParameterizedType PROTOBUF_FINAL : public: void clear_type_parameter(); const ::substrait::ParameterizedType_TypeParameter& type_parameter() const; - ::substrait::ParameterizedType_TypeParameter* release_type_parameter(); + PROTOBUF_NODISCARD ::substrait::ParameterizedType_TypeParameter* release_type_parameter(); ::substrait::ParameterizedType_TypeParameter* mutable_type_parameter(); void set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter); private: @@ -2774,11 +2969,11 @@ class ParameterizedType PROTOBUF_FINAL : ::substrait::ParameterizedType_ParameterizedStruct* struct__; ::substrait::ParameterizedType_ParameterizedList* list_; ::substrait::ParameterizedType_ParameterizedMap* map_; - ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_pointer_; + uint32_t user_defined_pointer_; ::substrait::ParameterizedType_TypeParameter* type_parameter_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; }; @@ -2802,30 +2997,31 @@ inline const std::string& ParameterizedType_TypeParameter::name() const { return _internal_name(); } template -PROTOBUF_ALWAYS_INLINE -inline void ParameterizedType_TypeParameter::set_name(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void ParameterizedType_TypeParameter::set_name(ArgT0&& arg0, ArgT... args) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.TypeParameter.name) } inline std::string* ParameterizedType_TypeParameter::mutable_name() { + std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.TypeParameter.name) - return _internal_mutable_name(); + return _s; } inline const std::string& ParameterizedType_TypeParameter::_internal_name() const { return name_.Get(); } inline void ParameterizedType_TypeParameter::_internal_set_name(const std::string& value) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* ParameterizedType_TypeParameter::_internal_mutable_name() { - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* ParameterizedType_TypeParameter::release_name() { // @@protoc_insertion_point(field_release:substrait.ParameterizedType.TypeParameter.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void ParameterizedType_TypeParameter::set_allocated_name(std::string* name) { if (name != nullptr) { @@ -2834,7 +3030,12 @@ inline void ParameterizedType_TypeParameter::set_allocated_name(std::string* nam } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.TypeParameter.name) } @@ -2868,8 +3069,9 @@ inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::_interna return bounds_.Add(); } inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::add_bounds() { + ::substrait::ParameterizedType* _add = _internal_add_bounds(); // @@protoc_insertion_point(field_add:substrait.ParameterizedType.TypeParameter.bounds) - return _internal_add_bounds(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >& ParameterizedType_TypeParameter::bounds() const { @@ -2890,30 +3092,31 @@ inline const std::string& ParameterizedType_IntegerParameter::name() const { return _internal_name(); } template -PROTOBUF_ALWAYS_INLINE -inline void ParameterizedType_IntegerParameter::set_name(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void ParameterizedType_IntegerParameter::set_name(ArgT0&& arg0, ArgT... args) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.IntegerParameter.name) } inline std::string* ParameterizedType_IntegerParameter::mutable_name() { + std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.name) - return _internal_mutable_name(); + return _s; } inline const std::string& ParameterizedType_IntegerParameter::_internal_name() const { return name_.Get(); } inline void ParameterizedType_IntegerParameter::_internal_set_name(const std::string& value) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* ParameterizedType_IntegerParameter::_internal_mutable_name() { - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* ParameterizedType_IntegerParameter::release_name() { // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerParameter.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void ParameterizedType_IntegerParameter::set_allocated_name(std::string* name) { if (name != nullptr) { @@ -2922,7 +3125,12 @@ inline void ParameterizedType_IntegerParameter::set_allocated_name(std::string* } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerParameter.name) } @@ -2934,7 +3142,7 @@ inline bool ParameterizedType_IntegerParameter::has_range_start_inclusive() cons return _internal_has_range_start_inclusive(); } inline void ParameterizedType_IntegerParameter::clear_range_start_inclusive() { - if (GetArena() == nullptr && range_start_inclusive_ != nullptr) { + if (GetArenaForAllocation() == nullptr && range_start_inclusive_ != nullptr) { delete range_start_inclusive_; } range_start_inclusive_ = nullptr; @@ -2950,7 +3158,7 @@ inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_I } inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range_start_inclusive( ::substrait::ParameterizedType_NullableInteger* range_start_inclusive) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(range_start_inclusive_); } range_start_inclusive_ = range_start_inclusive; @@ -2965,9 +3173,15 @@ inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_Integer ::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_; range_start_inclusive_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_start_inclusive() { @@ -2980,23 +3194,24 @@ inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_Integer inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_start_inclusive() { if (range_start_inclusive_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(GetArenaForAllocation()); range_start_inclusive_ = p; } return range_start_inclusive_; } inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_start_inclusive() { + ::substrait::ParameterizedType_NullableInteger* _msg = _internal_mutable_range_start_inclusive(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) - return _internal_mutable_range_start_inclusive(); + return _msg; } inline void ParameterizedType_IntegerParameter::set_allocated_range_start_inclusive(::substrait::ParameterizedType_NullableInteger* range_start_inclusive) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete range_start_inclusive_; } if (range_start_inclusive) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(range_start_inclusive); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_NullableInteger>::GetOwningArena(range_start_inclusive); if (message_arena != submessage_arena) { range_start_inclusive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, range_start_inclusive, submessage_arena); @@ -3017,7 +3232,7 @@ inline bool ParameterizedType_IntegerParameter::has_range_end_exclusive() const return _internal_has_range_end_exclusive(); } inline void ParameterizedType_IntegerParameter::clear_range_end_exclusive() { - if (GetArena() == nullptr && range_end_exclusive_ != nullptr) { + if (GetArenaForAllocation() == nullptr && range_end_exclusive_ != nullptr) { delete range_end_exclusive_; } range_end_exclusive_ = nullptr; @@ -3033,7 +3248,7 @@ inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_I } inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range_end_exclusive( ::substrait::ParameterizedType_NullableInteger* range_end_exclusive) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(range_end_exclusive_); } range_end_exclusive_ = range_end_exclusive; @@ -3048,9 +3263,15 @@ inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_Integer ::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_; range_end_exclusive_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_end_exclusive() { @@ -3063,23 +3284,24 @@ inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_Integer inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_end_exclusive() { if (range_end_exclusive_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(GetArenaForAllocation()); range_end_exclusive_ = p; } return range_end_exclusive_; } inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_end_exclusive() { + ::substrait::ParameterizedType_NullableInteger* _msg = _internal_mutable_range_end_exclusive(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) - return _internal_mutable_range_end_exclusive(); + return _msg; } inline void ParameterizedType_IntegerParameter::set_allocated_range_end_exclusive(::substrait::ParameterizedType_NullableInteger* range_end_exclusive) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete range_end_exclusive_; } if (range_end_exclusive) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(range_end_exclusive); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_NullableInteger>::GetOwningArena(range_end_exclusive); if (message_arena != submessage_arena) { range_end_exclusive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, range_end_exclusive, submessage_arena); @@ -3098,20 +3320,20 @@ inline void ParameterizedType_IntegerParameter::set_allocated_range_end_exclusiv // int64 value = 1; inline void ParameterizedType_NullableInteger::clear_value() { - value_ = PROTOBUF_LONGLONG(0); + value_ = int64_t{0}; } -inline ::PROTOBUF_NAMESPACE_ID::int64 ParameterizedType_NullableInteger::_internal_value() const { +inline int64_t ParameterizedType_NullableInteger::_internal_value() const { return value_; } -inline ::PROTOBUF_NAMESPACE_ID::int64 ParameterizedType_NullableInteger::value() const { +inline int64_t ParameterizedType_NullableInteger::value() const { // @@protoc_insertion_point(field_get:substrait.ParameterizedType.NullableInteger.value) return _internal_value(); } -inline void ParameterizedType_NullableInteger::_internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void ParameterizedType_NullableInteger::_internal_set_value(int64_t value) { value_ = value; } -inline void ParameterizedType_NullableInteger::set_value(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void ParameterizedType_NullableInteger::set_value(int64_t value) { _internal_set_value(value); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.NullableInteger.value) } @@ -3128,7 +3350,7 @@ inline bool ParameterizedType_ParameterizedFixedChar::has_length() const { return _internal_has_length(); } inline void ParameterizedType_ParameterizedFixedChar::clear_length() { - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -3144,7 +3366,7 @@ inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_Par } inline void ParameterizedType_ParameterizedFixedChar::unsafe_arena_set_allocated_length( ::substrait::ParameterizedType_IntegerOption* length) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } length_ = length; @@ -3159,9 +3381,15 @@ inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_Parameter ::substrait::ParameterizedType_IntegerOption* temp = length_; length_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::unsafe_arena_release_length() { @@ -3174,23 +3402,24 @@ inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_Parameter inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation()); length_ = p; } return length_; } inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::mutable_length() { + ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_length(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedFixedChar.length) - return _internal_mutable_length(); + return _msg; } inline void ParameterizedType_ParameterizedFixedChar::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete length_; } if (length) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(length); if (message_arena != submessage_arena) { length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, length, submessage_arena); @@ -3207,18 +3436,18 @@ inline void ParameterizedType_ParameterizedFixedChar::set_allocated_length(::sub inline void ParameterizedType_ParameterizedFixedChar::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedChar::_internal_variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedFixedChar::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedChar::variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedFixedChar::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer) return _internal_variation_pointer(); } -inline void ParameterizedType_ParameterizedFixedChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedFixedChar::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void ParameterizedType_ParameterizedFixedChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedFixedChar::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer) } @@ -3255,7 +3484,7 @@ inline bool ParameterizedType_ParameterizedVarChar::has_length() const { return _internal_has_length(); } inline void ParameterizedType_ParameterizedVarChar::clear_length() { - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -3271,7 +3500,7 @@ inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_Par } inline void ParameterizedType_ParameterizedVarChar::unsafe_arena_set_allocated_length( ::substrait::ParameterizedType_IntegerOption* length) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } length_ = length; @@ -3286,9 +3515,15 @@ inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_Parameter ::substrait::ParameterizedType_IntegerOption* temp = length_; length_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::unsafe_arena_release_length() { @@ -3301,23 +3536,24 @@ inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_Parameter inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation()); length_ = p; } return length_; } inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::mutable_length() { + ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_length(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedVarChar.length) - return _internal_mutable_length(); + return _msg; } inline void ParameterizedType_ParameterizedVarChar::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete length_; } if (length) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(length); if (message_arena != submessage_arena) { length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, length, submessage_arena); @@ -3334,18 +3570,18 @@ inline void ParameterizedType_ParameterizedVarChar::set_allocated_length(::subst inline void ParameterizedType_ParameterizedVarChar::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedVarChar::_internal_variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedVarChar::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedVarChar::variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedVarChar::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedVarChar.variation_pointer) return _internal_variation_pointer(); } -inline void ParameterizedType_ParameterizedVarChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedVarChar::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void ParameterizedType_ParameterizedVarChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedVarChar::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedVarChar.variation_pointer) } @@ -3382,7 +3618,7 @@ inline bool ParameterizedType_ParameterizedFixedBinary::has_length() const { return _internal_has_length(); } inline void ParameterizedType_ParameterizedFixedBinary::clear_length() { - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -3398,7 +3634,7 @@ inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_Par } inline void ParameterizedType_ParameterizedFixedBinary::unsafe_arena_set_allocated_length( ::substrait::ParameterizedType_IntegerOption* length) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } length_ = length; @@ -3413,9 +3649,15 @@ inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_Parameter ::substrait::ParameterizedType_IntegerOption* temp = length_; length_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::unsafe_arena_release_length() { @@ -3428,23 +3670,24 @@ inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_Parameter inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation()); length_ = p; } return length_; } inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::mutable_length() { + ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_length(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedFixedBinary.length) - return _internal_mutable_length(); + return _msg; } inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete length_; } if (length) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(length); if (message_arena != submessage_arena) { length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, length, submessage_arena); @@ -3461,18 +3704,18 @@ inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_length(::s inline void ParameterizedType_ParameterizedFixedBinary::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedBinary::_internal_variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedFixedBinary::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedFixedBinary::variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedFixedBinary::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer) return _internal_variation_pointer(); } -inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void ParameterizedType_ParameterizedFixedBinary::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedFixedBinary::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer) } @@ -3509,7 +3752,7 @@ inline bool ParameterizedType_ParameterizedDecimal::has_scale() const { return _internal_has_scale(); } inline void ParameterizedType_ParameterizedDecimal::clear_scale() { - if (GetArena() == nullptr && scale_ != nullptr) { + if (GetArenaForAllocation() == nullptr && scale_ != nullptr) { delete scale_; } scale_ = nullptr; @@ -3525,7 +3768,7 @@ inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_Par } inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_scale( ::substrait::ParameterizedType_IntegerOption* scale) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_); } scale_ = scale; @@ -3540,9 +3783,15 @@ inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_Parameter ::substrait::ParameterizedType_IntegerOption* temp = scale_; scale_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_scale() { @@ -3555,23 +3804,24 @@ inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_Parameter inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_scale() { if (scale_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation()); scale_ = p; } return scale_; } inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_scale() { + ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_scale(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedDecimal.scale) - return _internal_mutable_scale(); + return _msg; } inline void ParameterizedType_ParameterizedDecimal::set_allocated_scale(::substrait::ParameterizedType_IntegerOption* scale) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete scale_; } if (scale) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(scale); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(scale); if (message_arena != submessage_arena) { scale = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, scale, submessage_arena); @@ -3592,7 +3842,7 @@ inline bool ParameterizedType_ParameterizedDecimal::has_precision() const { return _internal_has_precision(); } inline void ParameterizedType_ParameterizedDecimal::clear_precision() { - if (GetArena() == nullptr && precision_ != nullptr) { + if (GetArenaForAllocation() == nullptr && precision_ != nullptr) { delete precision_; } precision_ = nullptr; @@ -3608,7 +3858,7 @@ inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_Par } inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_precision( ::substrait::ParameterizedType_IntegerOption* precision) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_); } precision_ = precision; @@ -3623,9 +3873,15 @@ inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_Parameter ::substrait::ParameterizedType_IntegerOption* temp = precision_; precision_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_precision() { @@ -3638,23 +3894,24 @@ inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_Parameter inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_precision() { if (precision_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation()); precision_ = p; } return precision_; } inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_precision() { + ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_precision(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedDecimal.precision) - return _internal_mutable_precision(); + return _msg; } inline void ParameterizedType_ParameterizedDecimal::set_allocated_precision(::substrait::ParameterizedType_IntegerOption* precision) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete precision_; } if (precision) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(precision); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(precision); if (message_arena != submessage_arena) { precision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, precision, submessage_arena); @@ -3671,18 +3928,18 @@ inline void ParameterizedType_ParameterizedDecimal::set_allocated_precision(::su inline void ParameterizedType_ParameterizedDecimal::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedDecimal::_internal_variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedDecimal::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedDecimal::variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedDecimal::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.variation_pointer) return _internal_variation_pointer(); } -inline void ParameterizedType_ParameterizedDecimal::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedDecimal::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void ParameterizedType_ParameterizedDecimal::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedDecimal::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedDecimal.variation_pointer) } @@ -3741,8 +3998,9 @@ inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::_i return types_.Add(); } inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::add_types() { + ::substrait::ParameterizedType* _add = _internal_add_types(); // @@protoc_insertion_point(field_add:substrait.ParameterizedType.ParameterizedStruct.types) - return _internal_add_types(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >& ParameterizedType_ParameterizedStruct::types() const { @@ -3754,18 +4012,18 @@ ParameterizedType_ParameterizedStruct::types() const { inline void ParameterizedType_ParameterizedStruct::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedStruct::_internal_variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedStruct::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedStruct::variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedStruct::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedStruct.variation_pointer) return _internal_variation_pointer(); } -inline void ParameterizedType_ParameterizedStruct::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedStruct::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void ParameterizedType_ParameterizedStruct::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedStruct::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedStruct.variation_pointer) } @@ -3805,8 +4063,9 @@ inline void ParameterizedType_ParameterizedNamedStruct::clear_names() { names_.Clear(); } inline std::string* ParameterizedType_ParameterizedNamedStruct::add_names() { + std::string* _s = _internal_add_names(); // @@protoc_insertion_point(field_add_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.names) - return _internal_add_names(); + return _s; } inline const std::string& ParameterizedType_ParameterizedNamedStruct::_internal_names(int index) const { return names_.Get(index); @@ -3820,12 +4079,12 @@ inline std::string* ParameterizedType_ParameterizedNamedStruct::mutable_names(in return names_.Mutable(index); } inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedNamedStruct.names) names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedNamedStruct.names) } inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedNamedStruct.names) names_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedNamedStruct.names) } inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -3876,7 +4135,7 @@ inline bool ParameterizedType_ParameterizedNamedStruct::has_struct_() const { return _internal_has_struct_(); } inline void ParameterizedType_ParameterizedNamedStruct::clear_struct_() { - if (GetArena() == nullptr && struct__ != nullptr) { + if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { delete struct__; } struct__ = nullptr; @@ -3892,7 +4151,7 @@ inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedTy } inline void ParameterizedType_ParameterizedNamedStruct::unsafe_arena_set_allocated_struct_( ::substrait::ParameterizedType_ParameterizedStruct* struct_) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); } struct__ = struct_; @@ -3907,9 +4166,15 @@ inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_Par ::substrait::ParameterizedType_ParameterizedStruct* temp = struct__; struct__ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::unsafe_arena_release_struct_() { @@ -3922,23 +4187,24 @@ inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_Par inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::_internal_mutable_struct_() { if (struct__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedStruct>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedStruct>(GetArenaForAllocation()); struct__ = p; } return struct__; } inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::mutable_struct_() { + ::substrait::ParameterizedType_ParameterizedStruct* _msg = _internal_mutable_struct_(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.struct) - return _internal_mutable_struct_(); + return _msg; } inline void ParameterizedType_ParameterizedNamedStruct::set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete struct__; } if (struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedStruct>::GetOwningArena(struct_); if (message_arena != submessage_arena) { struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, struct_, submessage_arena); @@ -3963,7 +4229,7 @@ inline bool ParameterizedType_ParameterizedList::has_type() const { return _internal_has_type(); } inline void ParameterizedType_ParameterizedList::clear_type() { - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; @@ -3979,7 +4245,7 @@ inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedList } inline void ParameterizedType_ParameterizedList::unsafe_arena_set_allocated_type( ::substrait::ParameterizedType* type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } type_ = type; @@ -3994,9 +4260,15 @@ inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::rele ::substrait::ParameterizedType* temp = type_; type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::unsafe_arena_release_type() { @@ -4009,23 +4281,24 @@ inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::unsa inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation()); type_ = p; } return type_; } inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::mutable_type() { + ::substrait::ParameterizedType* _msg = _internal_mutable_type(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedList.type) - return _internal_mutable_type(); + return _msg; } inline void ParameterizedType_ParameterizedList::set_allocated_type(::substrait::ParameterizedType* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete type_; } if (type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType>::GetOwningArena(type); if (message_arena != submessage_arena) { type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type, submessage_arena); @@ -4042,18 +4315,18 @@ inline void ParameterizedType_ParameterizedList::set_allocated_type(::substrait: inline void ParameterizedType_ParameterizedList::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedList::_internal_variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedList::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedList::variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedList::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedList.variation_pointer) return _internal_variation_pointer(); } -inline void ParameterizedType_ParameterizedList::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedList::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void ParameterizedType_ParameterizedList::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedList::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedList.variation_pointer) } @@ -4090,7 +4363,7 @@ inline bool ParameterizedType_ParameterizedMap::has_key() const { return _internal_has_key(); } inline void ParameterizedType_ParameterizedMap::clear_key() { - if (GetArena() == nullptr && key_ != nullptr) { + if (GetArenaForAllocation() == nullptr && key_ != nullptr) { delete key_; } key_ = nullptr; @@ -4106,7 +4379,7 @@ inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap: } inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_key( ::substrait::ParameterizedType* key) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); } key_ = key; @@ -4121,9 +4394,15 @@ inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::relea ::substrait::ParameterizedType* temp = key_; key_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_key() { @@ -4136,23 +4415,24 @@ inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsaf inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_key() { if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation()); key_ = p; } return key_; } inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_key() { + ::substrait::ParameterizedType* _msg = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedMap.key) - return _internal_mutable_key(); + return _msg; } inline void ParameterizedType_ParameterizedMap::set_allocated_key(::substrait::ParameterizedType* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete key_; } if (key) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType>::GetOwningArena(key); if (message_arena != submessage_arena) { key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, key, submessage_arena); @@ -4173,7 +4453,7 @@ inline bool ParameterizedType_ParameterizedMap::has_value() const { return _internal_has_value(); } inline void ParameterizedType_ParameterizedMap::clear_value() { - if (GetArena() == nullptr && value_ != nullptr) { + if (GetArenaForAllocation() == nullptr && value_ != nullptr) { delete value_; } value_ = nullptr; @@ -4189,7 +4469,7 @@ inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap: } inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_value( ::substrait::ParameterizedType* value) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } value_ = value; @@ -4204,9 +4484,15 @@ inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::relea ::substrait::ParameterizedType* temp = value_; value_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_value() { @@ -4219,23 +4505,24 @@ inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsaf inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_value() { if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation()); value_ = p; } return value_; } inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_value() { + ::substrait::ParameterizedType* _msg = _internal_mutable_value(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedMap.value) - return _internal_mutable_value(); + return _msg; } inline void ParameterizedType_ParameterizedMap::set_allocated_value(::substrait::ParameterizedType* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete value_; } if (value) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType>::GetOwningArena(value); if (message_arena != submessage_arena) { value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, value, submessage_arena); @@ -4252,18 +4539,18 @@ inline void ParameterizedType_ParameterizedMap::set_allocated_value(::substrait: inline void ParameterizedType_ParameterizedMap::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedMap::_internal_variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedMap::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType_ParameterizedMap::variation_pointer() const { +inline uint32_t ParameterizedType_ParameterizedMap::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.variation_pointer) return _internal_variation_pointer(); } -inline void ParameterizedType_ParameterizedMap::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedMap::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void ParameterizedType_ParameterizedMap::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType_ParameterizedMap::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedMap.variation_pointer) } @@ -4308,24 +4595,24 @@ inline void ParameterizedType_IntegerOption::clear_literal() { clear_has_integer_type(); } } -inline ::PROTOBUF_NAMESPACE_ID::int32 ParameterizedType_IntegerOption::_internal_literal() const { +inline int32_t ParameterizedType_IntegerOption::_internal_literal() const { if (_internal_has_literal()) { return integer_type_.literal_; } return 0; } -inline void ParameterizedType_IntegerOption::_internal_set_literal(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void ParameterizedType_IntegerOption::_internal_set_literal(int32_t value) { if (!_internal_has_literal()) { clear_integer_type(); set_has_literal(); } integer_type_.literal_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int32 ParameterizedType_IntegerOption::literal() const { +inline int32_t ParameterizedType_IntegerOption::literal() const { // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerOption.literal) return _internal_literal(); } -inline void ParameterizedType_IntegerOption::set_literal(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void ParameterizedType_IntegerOption::set_literal(int32_t value) { _internal_set_literal(value); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.IntegerOption.literal) } @@ -4342,7 +4629,7 @@ inline void ParameterizedType_IntegerOption::set_has_parameter() { } inline void ParameterizedType_IntegerOption::clear_parameter() { if (_internal_has_parameter()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete integer_type_.parameter_; } clear_has_integer_type(); @@ -4353,7 +4640,7 @@ inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_Intege if (_internal_has_parameter()) { clear_has_integer_type(); ::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } integer_type_.parameter_ = nullptr; @@ -4394,13 +4681,14 @@ inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_Intege if (!_internal_has_parameter()) { clear_integer_type(); set_has_parameter(); - integer_type_.parameter_ = CreateMaybeMessage< ::substrait::ParameterizedType_IntegerParameter >(GetArena()); + integer_type_.parameter_ = CreateMaybeMessage< ::substrait::ParameterizedType_IntegerParameter >(GetArenaForAllocation()); } return integer_type_.parameter_; } inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::mutable_parameter() { + ::substrait::ParameterizedType_IntegerParameter* _msg = _internal_mutable_parameter(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerOption.parameter) - return _internal_mutable_parameter(); + return _msg; } inline bool ParameterizedType_IntegerOption::has_integer_type() const { @@ -4431,7 +4719,7 @@ inline ::substrait::Type_Boolean* ParameterizedType::release_bool_() { if (_internal_has_bool_()) { clear_has_kind(); ::substrait::Type_Boolean* temp = kind_.bool__; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.bool__ = nullptr; @@ -4472,13 +4760,14 @@ inline ::substrait::Type_Boolean* ParameterizedType::_internal_mutable_bool_() { if (!_internal_has_bool_()) { clear_kind(); set_has_bool_(); - kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArena()); + kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArenaForAllocation()); } return kind_.bool__; } inline ::substrait::Type_Boolean* ParameterizedType::mutable_bool_() { + ::substrait::Type_Boolean* _msg = _internal_mutable_bool_(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.bool) - return _internal_mutable_bool_(); + return _msg; } // .substrait.Type.I8 i8 = 2; @@ -4496,7 +4785,7 @@ inline ::substrait::Type_I8* ParameterizedType::release_i8() { if (_internal_has_i8()) { clear_has_kind(); ::substrait::Type_I8* temp = kind_.i8_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i8_ = nullptr; @@ -4537,13 +4826,14 @@ inline ::substrait::Type_I8* ParameterizedType::_internal_mutable_i8() { if (!_internal_has_i8()) { clear_kind(); set_has_i8(); - kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArena()); + kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArenaForAllocation()); } return kind_.i8_; } inline ::substrait::Type_I8* ParameterizedType::mutable_i8() { + ::substrait::Type_I8* _msg = _internal_mutable_i8(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i8) - return _internal_mutable_i8(); + return _msg; } // .substrait.Type.I16 i16 = 3; @@ -4561,7 +4851,7 @@ inline ::substrait::Type_I16* ParameterizedType::release_i16() { if (_internal_has_i16()) { clear_has_kind(); ::substrait::Type_I16* temp = kind_.i16_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i16_ = nullptr; @@ -4602,13 +4892,14 @@ inline ::substrait::Type_I16* ParameterizedType::_internal_mutable_i16() { if (!_internal_has_i16()) { clear_kind(); set_has_i16(); - kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArena()); + kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArenaForAllocation()); } return kind_.i16_; } inline ::substrait::Type_I16* ParameterizedType::mutable_i16() { + ::substrait::Type_I16* _msg = _internal_mutable_i16(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i16) - return _internal_mutable_i16(); + return _msg; } // .substrait.Type.I32 i32 = 5; @@ -4626,7 +4917,7 @@ inline ::substrait::Type_I32* ParameterizedType::release_i32() { if (_internal_has_i32()) { clear_has_kind(); ::substrait::Type_I32* temp = kind_.i32_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i32_ = nullptr; @@ -4667,13 +4958,14 @@ inline ::substrait::Type_I32* ParameterizedType::_internal_mutable_i32() { if (!_internal_has_i32()) { clear_kind(); set_has_i32(); - kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArena()); + kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArenaForAllocation()); } return kind_.i32_; } inline ::substrait::Type_I32* ParameterizedType::mutable_i32() { + ::substrait::Type_I32* _msg = _internal_mutable_i32(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i32) - return _internal_mutable_i32(); + return _msg; } // .substrait.Type.I64 i64 = 7; @@ -4691,7 +4983,7 @@ inline ::substrait::Type_I64* ParameterizedType::release_i64() { if (_internal_has_i64()) { clear_has_kind(); ::substrait::Type_I64* temp = kind_.i64_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i64_ = nullptr; @@ -4732,13 +5024,14 @@ inline ::substrait::Type_I64* ParameterizedType::_internal_mutable_i64() { if (!_internal_has_i64()) { clear_kind(); set_has_i64(); - kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArena()); + kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArenaForAllocation()); } return kind_.i64_; } inline ::substrait::Type_I64* ParameterizedType::mutable_i64() { + ::substrait::Type_I64* _msg = _internal_mutable_i64(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i64) - return _internal_mutable_i64(); + return _msg; } // .substrait.Type.FP32 fp32 = 10; @@ -4756,7 +5049,7 @@ inline ::substrait::Type_FP32* ParameterizedType::release_fp32() { if (_internal_has_fp32()) { clear_has_kind(); ::substrait::Type_FP32* temp = kind_.fp32_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fp32_ = nullptr; @@ -4797,13 +5090,14 @@ inline ::substrait::Type_FP32* ParameterizedType::_internal_mutable_fp32() { if (!_internal_has_fp32()) { clear_kind(); set_has_fp32(); - kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArena()); + kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArenaForAllocation()); } return kind_.fp32_; } inline ::substrait::Type_FP32* ParameterizedType::mutable_fp32() { + ::substrait::Type_FP32* _msg = _internal_mutable_fp32(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fp32) - return _internal_mutable_fp32(); + return _msg; } // .substrait.Type.FP64 fp64 = 11; @@ -4821,7 +5115,7 @@ inline ::substrait::Type_FP64* ParameterizedType::release_fp64() { if (_internal_has_fp64()) { clear_has_kind(); ::substrait::Type_FP64* temp = kind_.fp64_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fp64_ = nullptr; @@ -4862,13 +5156,14 @@ inline ::substrait::Type_FP64* ParameterizedType::_internal_mutable_fp64() { if (!_internal_has_fp64()) { clear_kind(); set_has_fp64(); - kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArena()); + kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArenaForAllocation()); } return kind_.fp64_; } inline ::substrait::Type_FP64* ParameterizedType::mutable_fp64() { + ::substrait::Type_FP64* _msg = _internal_mutable_fp64(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fp64) - return _internal_mutable_fp64(); + return _msg; } // .substrait.Type.String string = 12; @@ -4886,7 +5181,7 @@ inline ::substrait::Type_String* ParameterizedType::release_string() { if (_internal_has_string()) { clear_has_kind(); ::substrait::Type_String* temp = kind_.string_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.string_ = nullptr; @@ -4927,13 +5222,14 @@ inline ::substrait::Type_String* ParameterizedType::_internal_mutable_string() { if (!_internal_has_string()) { clear_kind(); set_has_string(); - kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArena()); + kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArenaForAllocation()); } return kind_.string_; } inline ::substrait::Type_String* ParameterizedType::mutable_string() { + ::substrait::Type_String* _msg = _internal_mutable_string(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.string) - return _internal_mutable_string(); + return _msg; } // .substrait.Type.Binary binary = 13; @@ -4951,7 +5247,7 @@ inline ::substrait::Type_Binary* ParameterizedType::release_binary() { if (_internal_has_binary()) { clear_has_kind(); ::substrait::Type_Binary* temp = kind_.binary_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.binary_ = nullptr; @@ -4992,13 +5288,14 @@ inline ::substrait::Type_Binary* ParameterizedType::_internal_mutable_binary() { if (!_internal_has_binary()) { clear_kind(); set_has_binary(); - kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArena()); + kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArenaForAllocation()); } return kind_.binary_; } inline ::substrait::Type_Binary* ParameterizedType::mutable_binary() { + ::substrait::Type_Binary* _msg = _internal_mutable_binary(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.binary) - return _internal_mutable_binary(); + return _msg; } // .substrait.Type.Timestamp timestamp = 14; @@ -5016,7 +5313,7 @@ inline ::substrait::Type_Timestamp* ParameterizedType::release_timestamp() { if (_internal_has_timestamp()) { clear_has_kind(); ::substrait::Type_Timestamp* temp = kind_.timestamp_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.timestamp_ = nullptr; @@ -5057,13 +5354,14 @@ inline ::substrait::Type_Timestamp* ParameterizedType::_internal_mutable_timesta if (!_internal_has_timestamp()) { clear_kind(); set_has_timestamp(); - kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArena()); + kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArenaForAllocation()); } return kind_.timestamp_; } inline ::substrait::Type_Timestamp* ParameterizedType::mutable_timestamp() { + ::substrait::Type_Timestamp* _msg = _internal_mutable_timestamp(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.timestamp) - return _internal_mutable_timestamp(); + return _msg; } // .substrait.Type.Date date = 16; @@ -5081,7 +5379,7 @@ inline ::substrait::Type_Date* ParameterizedType::release_date() { if (_internal_has_date()) { clear_has_kind(); ::substrait::Type_Date* temp = kind_.date_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.date_ = nullptr; @@ -5122,13 +5420,14 @@ inline ::substrait::Type_Date* ParameterizedType::_internal_mutable_date() { if (!_internal_has_date()) { clear_kind(); set_has_date(); - kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArena()); + kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArenaForAllocation()); } return kind_.date_; } inline ::substrait::Type_Date* ParameterizedType::mutable_date() { + ::substrait::Type_Date* _msg = _internal_mutable_date(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.date) - return _internal_mutable_date(); + return _msg; } // .substrait.Type.Time time = 17; @@ -5146,7 +5445,7 @@ inline ::substrait::Type_Time* ParameterizedType::release_time() { if (_internal_has_time()) { clear_has_kind(); ::substrait::Type_Time* temp = kind_.time_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.time_ = nullptr; @@ -5187,13 +5486,14 @@ inline ::substrait::Type_Time* ParameterizedType::_internal_mutable_time() { if (!_internal_has_time()) { clear_kind(); set_has_time(); - kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArena()); + kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArenaForAllocation()); } return kind_.time_; } inline ::substrait::Type_Time* ParameterizedType::mutable_time() { + ::substrait::Type_Time* _msg = _internal_mutable_time(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.time) - return _internal_mutable_time(); + return _msg; } // .substrait.Type.IntervalYear interval_year = 19; @@ -5211,7 +5511,7 @@ inline ::substrait::Type_IntervalYear* ParameterizedType::release_interval_year( if (_internal_has_interval_year()) { clear_has_kind(); ::substrait::Type_IntervalYear* temp = kind_.interval_year_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.interval_year_ = nullptr; @@ -5252,13 +5552,14 @@ inline ::substrait::Type_IntervalYear* ParameterizedType::_internal_mutable_inte if (!_internal_has_interval_year()) { clear_kind(); set_has_interval_year(); - kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArena()); + kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArenaForAllocation()); } return kind_.interval_year_; } inline ::substrait::Type_IntervalYear* ParameterizedType::mutable_interval_year() { + ::substrait::Type_IntervalYear* _msg = _internal_mutable_interval_year(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.interval_year) - return _internal_mutable_interval_year(); + return _msg; } // .substrait.Type.IntervalDay interval_day = 20; @@ -5276,7 +5577,7 @@ inline ::substrait::Type_IntervalDay* ParameterizedType::release_interval_day() if (_internal_has_interval_day()) { clear_has_kind(); ::substrait::Type_IntervalDay* temp = kind_.interval_day_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.interval_day_ = nullptr; @@ -5317,13 +5618,14 @@ inline ::substrait::Type_IntervalDay* ParameterizedType::_internal_mutable_inter if (!_internal_has_interval_day()) { clear_kind(); set_has_interval_day(); - kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArena()); + kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArenaForAllocation()); } return kind_.interval_day_; } inline ::substrait::Type_IntervalDay* ParameterizedType::mutable_interval_day() { + ::substrait::Type_IntervalDay* _msg = _internal_mutable_interval_day(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.interval_day) - return _internal_mutable_interval_day(); + return _msg; } // .substrait.Type.TimestampTZ timestamp_tz = 29; @@ -5341,7 +5643,7 @@ inline ::substrait::Type_TimestampTZ* ParameterizedType::release_timestamp_tz() if (_internal_has_timestamp_tz()) { clear_has_kind(); ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.timestamp_tz_ = nullptr; @@ -5382,13 +5684,14 @@ inline ::substrait::Type_TimestampTZ* ParameterizedType::_internal_mutable_times if (!_internal_has_timestamp_tz()) { clear_kind(); set_has_timestamp_tz(); - kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArena()); + kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArenaForAllocation()); } return kind_.timestamp_tz_; } inline ::substrait::Type_TimestampTZ* ParameterizedType::mutable_timestamp_tz() { + ::substrait::Type_TimestampTZ* _msg = _internal_mutable_timestamp_tz(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.timestamp_tz) - return _internal_mutable_timestamp_tz(); + return _msg; } // .substrait.Type.UUID uuid = 32; @@ -5406,7 +5709,7 @@ inline ::substrait::Type_UUID* ParameterizedType::release_uuid() { if (_internal_has_uuid()) { clear_has_kind(); ::substrait::Type_UUID* temp = kind_.uuid_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.uuid_ = nullptr; @@ -5447,13 +5750,14 @@ inline ::substrait::Type_UUID* ParameterizedType::_internal_mutable_uuid() { if (!_internal_has_uuid()) { clear_kind(); set_has_uuid(); - kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArena()); + kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArenaForAllocation()); } return kind_.uuid_; } inline ::substrait::Type_UUID* ParameterizedType::mutable_uuid() { + ::substrait::Type_UUID* _msg = _internal_mutable_uuid(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.uuid) - return _internal_mutable_uuid(); + return _msg; } // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; @@ -5468,7 +5772,7 @@ inline void ParameterizedType::set_has_fixed_char() { } inline void ParameterizedType::clear_fixed_char() { if (_internal_has_fixed_char()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_char_; } clear_has_kind(); @@ -5479,7 +5783,7 @@ inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType: if (_internal_has_fixed_char()) { clear_has_kind(); ::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fixed_char_ = nullptr; @@ -5520,13 +5824,14 @@ inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType: if (!_internal_has_fixed_char()) { clear_kind(); set_has_fixed_char(); - kind_.fixed_char_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedChar >(GetArena()); + kind_.fixed_char_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedChar >(GetArenaForAllocation()); } return kind_.fixed_char_; } inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::mutable_fixed_char() { + ::substrait::ParameterizedType_ParameterizedFixedChar* _msg = _internal_mutable_fixed_char(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fixed_char) - return _internal_mutable_fixed_char(); + return _msg; } // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; @@ -5541,7 +5846,7 @@ inline void ParameterizedType::set_has_varchar() { } inline void ParameterizedType::clear_varchar() { if (_internal_has_varchar()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.varchar_; } clear_has_kind(); @@ -5552,7 +5857,7 @@ inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::r if (_internal_has_varchar()) { clear_has_kind(); ::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.varchar_ = nullptr; @@ -5593,13 +5898,14 @@ inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::_ if (!_internal_has_varchar()) { clear_kind(); set_has_varchar(); - kind_.varchar_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedVarChar >(GetArena()); + kind_.varchar_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedVarChar >(GetArenaForAllocation()); } return kind_.varchar_; } inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::mutable_varchar() { + ::substrait::ParameterizedType_ParameterizedVarChar* _msg = _internal_mutable_varchar(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.varchar) - return _internal_mutable_varchar(); + return _msg; } // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; @@ -5614,7 +5920,7 @@ inline void ParameterizedType::set_has_fixed_binary() { } inline void ParameterizedType::clear_fixed_binary() { if (_internal_has_fixed_binary()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_binary_; } clear_has_kind(); @@ -5625,7 +5931,7 @@ inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedTyp if (_internal_has_fixed_binary()) { clear_has_kind(); ::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fixed_binary_ = nullptr; @@ -5666,13 +5972,14 @@ inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedTyp if (!_internal_has_fixed_binary()) { clear_kind(); set_has_fixed_binary(); - kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedBinary >(GetArena()); + kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedBinary >(GetArenaForAllocation()); } return kind_.fixed_binary_; } inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::mutable_fixed_binary() { + ::substrait::ParameterizedType_ParameterizedFixedBinary* _msg = _internal_mutable_fixed_binary(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fixed_binary) - return _internal_mutable_fixed_binary(); + return _msg; } // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; @@ -5687,7 +5994,7 @@ inline void ParameterizedType::set_has_decimal() { } inline void ParameterizedType::clear_decimal() { if (_internal_has_decimal()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.decimal_; } clear_has_kind(); @@ -5698,7 +6005,7 @@ inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::r if (_internal_has_decimal()) { clear_has_kind(); ::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.decimal_ = nullptr; @@ -5739,13 +6046,14 @@ inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::_ if (!_internal_has_decimal()) { clear_kind(); set_has_decimal(); - kind_.decimal_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedDecimal >(GetArena()); + kind_.decimal_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedDecimal >(GetArenaForAllocation()); } return kind_.decimal_; } inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::mutable_decimal() { + ::substrait::ParameterizedType_ParameterizedDecimal* _msg = _internal_mutable_decimal(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.decimal) - return _internal_mutable_decimal(); + return _msg; } // .substrait.ParameterizedType.ParameterizedStruct struct = 25; @@ -5760,7 +6068,7 @@ inline void ParameterizedType::set_has_struct_() { } inline void ParameterizedType::clear_struct_() { if (_internal_has_struct_()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.struct__; } clear_has_kind(); @@ -5771,7 +6079,7 @@ inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::re if (_internal_has_struct_()) { clear_has_kind(); ::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.struct__ = nullptr; @@ -5812,13 +6120,14 @@ inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::_i if (!_internal_has_struct_()) { clear_kind(); set_has_struct_(); - kind_.struct__ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedStruct >(GetArena()); + kind_.struct__ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedStruct >(GetArenaForAllocation()); } return kind_.struct__; } inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::mutable_struct_() { + ::substrait::ParameterizedType_ParameterizedStruct* _msg = _internal_mutable_struct_(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.struct) - return _internal_mutable_struct_(); + return _msg; } // .substrait.ParameterizedType.ParameterizedList list = 27; @@ -5833,7 +6142,7 @@ inline void ParameterizedType::set_has_list() { } inline void ParameterizedType::clear_list() { if (_internal_has_list()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.list_; } clear_has_kind(); @@ -5844,7 +6153,7 @@ inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::rele if (_internal_has_list()) { clear_has_kind(); ::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.list_ = nullptr; @@ -5885,13 +6194,14 @@ inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::_int if (!_internal_has_list()) { clear_kind(); set_has_list(); - kind_.list_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedList >(GetArena()); + kind_.list_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedList >(GetArenaForAllocation()); } return kind_.list_; } inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::mutable_list() { + ::substrait::ParameterizedType_ParameterizedList* _msg = _internal_mutable_list(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.list) - return _internal_mutable_list(); + return _msg; } // .substrait.ParameterizedType.ParameterizedMap map = 28; @@ -5906,7 +6216,7 @@ inline void ParameterizedType::set_has_map() { } inline void ParameterizedType::clear_map() { if (_internal_has_map()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.map_; } clear_has_kind(); @@ -5917,7 +6227,7 @@ inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::relea if (_internal_has_map()) { clear_has_kind(); ::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.map_ = nullptr; @@ -5958,13 +6268,14 @@ inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::_inte if (!_internal_has_map()) { clear_kind(); set_has_map(); - kind_.map_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedMap >(GetArena()); + kind_.map_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedMap >(GetArenaForAllocation()); } return kind_.map_; } inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::mutable_map() { + ::substrait::ParameterizedType_ParameterizedMap* _msg = _internal_mutable_map(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.map) - return _internal_mutable_map(); + return _msg; } // uint32 user_defined_pointer = 31; @@ -5983,24 +6294,24 @@ inline void ParameterizedType::clear_user_defined_pointer() { clear_has_kind(); } } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType::_internal_user_defined_pointer() const { +inline uint32_t ParameterizedType::_internal_user_defined_pointer() const { if (_internal_has_user_defined_pointer()) { return kind_.user_defined_pointer_; } return 0u; } -inline void ParameterizedType::_internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType::_internal_set_user_defined_pointer(uint32_t value) { if (!_internal_has_user_defined_pointer()) { clear_kind(); set_has_user_defined_pointer(); } kind_.user_defined_pointer_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 ParameterizedType::user_defined_pointer() const { +inline uint32_t ParameterizedType::user_defined_pointer() const { // @@protoc_insertion_point(field_get:substrait.ParameterizedType.user_defined_pointer) return _internal_user_defined_pointer(); } -inline void ParameterizedType::set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void ParameterizedType::set_user_defined_pointer(uint32_t value) { _internal_set_user_defined_pointer(value); // @@protoc_insertion_point(field_set:substrait.ParameterizedType.user_defined_pointer) } @@ -6017,7 +6328,7 @@ inline void ParameterizedType::set_has_type_parameter() { } inline void ParameterizedType::clear_type_parameter() { if (_internal_has_type_parameter()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.type_parameter_; } clear_has_kind(); @@ -6028,7 +6339,7 @@ inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::release_ if (_internal_has_type_parameter()) { clear_has_kind(); ::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.type_parameter_ = nullptr; @@ -6069,13 +6380,14 @@ inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::_interna if (!_internal_has_type_parameter()) { clear_kind(); set_has_type_parameter(); - kind_.type_parameter_ = CreateMaybeMessage< ::substrait::ParameterizedType_TypeParameter >(GetArena()); + kind_.type_parameter_ = CreateMaybeMessage< ::substrait::ParameterizedType_TypeParameter >(GetArenaForAllocation()); } return kind_.type_parameter_; } inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::mutable_type_parameter() { + ::substrait::ParameterizedType_TypeParameter* _msg = _internal_mutable_type_parameter(); // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.type_parameter) - return _internal_mutable_type_parameter(); + return _msg; } inline bool ParameterizedType::has_kind() const { diff --git a/cpp/src/generated/substrait/plan.pb.cc b/cpp/src/generated/substrait/plan.pb.cc index 0e3d7c7c768..4b77e56bfbd 100644 --- a/cpp/src/generated/substrait/plan.pb.cc +++ b/cpp/src/generated/substrait/plan.pb.cc @@ -50,12 +50,13 @@ static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fplan_2e static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fplan_2eproto = nullptr; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fplan_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fplan_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const uint32_t TableStruct_substrait_2fplan_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, rel_type_), @@ -64,6 +65,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fplan_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Plan, extension_uris_), PROTOBUF_FIELD_OFFSET(::substrait::Plan, extensions_), PROTOBUF_FIELD_OFFSET(::substrait::Plan, relations_), @@ -71,8 +73,8 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2fplan_2eproto::offs PROTOBUF_FIELD_OFFSET(::substrait::Plan, expected_type_urls_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::substrait::PlanRel)}, - { 8, -1, sizeof(::substrait::Plan)}, + { 0, -1, -1, sizeof(::substrait::PlanRel)}, + { 9, -1, -1, sizeof(::substrait::Plan)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -132,11 +134,13 @@ PlanRel::_Internal::root(const PlanRel* msg) { return *msg->rel_type_.root_; } void PlanRel::set_allocated_rel(::substrait::Rel* rel) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (rel) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rel)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rel)); if (message_arena != submessage_arena) { rel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, rel, submessage_arena); @@ -148,18 +152,20 @@ void PlanRel::set_allocated_rel(::substrait::Rel* rel) { } void PlanRel::clear_rel() { if (_internal_has_rel()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.rel_; } clear_has_rel_type(); } } void PlanRel::set_allocated_root(::substrait::RelRoot* root) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (root) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(root)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(root)); if (message_arena != submessage_arena) { root = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, root, submessage_arena); @@ -171,16 +177,19 @@ void PlanRel::set_allocated_root(::substrait::RelRoot* root) { } void PlanRel::clear_root() { if (_internal_has_root()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.root_; } clear_has_rel_type(); } } -PlanRel::PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +PlanRel::PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.PlanRel) } PlanRel::PlanRel(const PlanRel& from) @@ -203,18 +212,19 @@ PlanRel::PlanRel(const PlanRel& from) // @@protoc_insertion_point(copy_constructor:substrait.PlanRel) } -void PlanRel::SharedCtor() { +inline void PlanRel::SharedCtor() { clear_has_rel_type(); } PlanRel::~PlanRel() { // @@protoc_insertion_point(destructor:substrait.PlanRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void PlanRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void PlanRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_rel_type()) { clear_rel_type(); } @@ -234,13 +244,13 @@ void PlanRel::clear_rel_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.PlanRel) switch (rel_type_case()) { case kRel: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.rel_; } break; } case kRoot: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.root_; } break; @@ -255,7 +265,7 @@ void PlanRel::clear_rel_type() { void PlanRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.PlanRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -266,50 +276,52 @@ void PlanRel::Clear() { const char* PlanRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Rel rel = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_rel(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.RelRoot root = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_root(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* PlanRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* PlanRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.PlanRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Rel rel = 1; @@ -340,7 +352,7 @@ size_t PlanRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.PlanRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -363,35 +375,26 @@ size_t PlanRel::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void PlanRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.PlanRel) - GOOGLE_DCHECK_NE(&from, this); - const PlanRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.PlanRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.PlanRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PlanRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + PlanRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PlanRel::GetClassData() const { return &_class_data_; } + +void PlanRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void PlanRel::MergeFrom(const PlanRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.PlanRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.rel_type_case()) { @@ -407,13 +410,7 @@ void PlanRel::MergeFrom(const PlanRel& from) { break; } } -} - -void PlanRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.PlanRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void PlanRel::CopyFrom(const PlanRel& from) { @@ -429,7 +426,7 @@ bool PlanRel::IsInitialized() const { void PlanRel::InternalSwap(PlanRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(rel_type_, other->rel_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -458,19 +455,22 @@ void Plan::clear_extensions() { extensions_.Clear(); } void Plan::clear_advanced_extensions() { - if (GetArena() == nullptr && advanced_extensions_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extensions_ != nullptr) { delete advanced_extensions_; } advanced_extensions_ = nullptr; } -Plan::Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Plan::Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), extension_uris_(arena), extensions_(arena), relations_(arena), expected_type_urls_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Plan) } Plan::Plan(const Plan& from) @@ -488,18 +488,19 @@ Plan::Plan(const Plan& from) // @@protoc_insertion_point(copy_constructor:substrait.Plan) } -void Plan::SharedCtor() { +inline void Plan::SharedCtor() { advanced_extensions_ = nullptr; } Plan::~Plan() { // @@protoc_insertion_point(destructor:substrait.Plan) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Plan::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Plan::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete advanced_extensions_; } @@ -515,7 +516,7 @@ void Plan::SetCachedSize(int size) const { void Plan::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Plan) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -523,7 +524,7 @@ void Plan::Clear() { extensions_.Clear(); relations_.Clear(); expected_type_urls_.Clear(); - if (GetArena() == nullptr && advanced_extensions_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extensions_ != nullptr) { delete advanced_extensions_; } advanced_extensions_ = nullptr; @@ -533,12 +534,12 @@ void Plan::Clear() { const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -546,11 +547,12 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -558,11 +560,12 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.PlanRel relations = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -570,18 +573,20 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extensions = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extensions(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated string expected_type_urls = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr -= 1; do { ptr += 1; @@ -591,35 +596,36 @@ const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::inter CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Plan::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Plan) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; @@ -647,7 +653,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Plan::_InternalSerialize( } // .substrait.extensions.AdvancedExtension advanced_extensions = 4; - if (this->has_advanced_extensions()) { + if (this->_internal_has_advanced_extensions()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -676,7 +682,7 @@ size_t Plan::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Plan) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -710,57 +716,42 @@ size_t Plan::ByteSizeLong() const { } // .substrait.extensions.AdvancedExtension advanced_extensions = 4; - if (this->has_advanced_extensions()) { + if (this->_internal_has_advanced_extensions()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extensions_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Plan::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Plan) - GOOGLE_DCHECK_NE(&from, this); - const Plan* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Plan) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Plan) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Plan::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Plan::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Plan::GetClassData() const { return &_class_data_; } + +void Plan::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Plan::MergeFrom(const Plan& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Plan) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; extension_uris_.MergeFrom(from.extension_uris_); extensions_.MergeFrom(from.extensions_); relations_.MergeFrom(from.relations_); expected_type_urls_.MergeFrom(from.expected_type_urls_); - if (from.has_advanced_extensions()) { + if (from._internal_has_advanced_extensions()) { _internal_mutable_advanced_extensions()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extensions()); } -} - -void Plan::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Plan) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Plan::CopyFrom(const Plan& from) { @@ -776,7 +767,7 @@ bool Plan::IsInitialized() const { void Plan::InternalSwap(Plan* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); extension_uris_.InternalSwap(&other->extension_uris_); extensions_.InternalSwap(&other->extensions_); relations_.InternalSwap(&other->relations_); diff --git a/cpp/src/generated/substrait/plan.pb.h b/cpp/src/generated/substrait/plan.pb.h index e8592745fe6..b31f812c569 100644 --- a/cpp/src/generated/substrait/plan.pb.h +++ b/cpp/src/generated/substrait/plan.pb.h @@ -8,12 +8,12 @@ #include #include -#if PROTOBUF_VERSION < 3016000 +#if PROTOBUF_VERSION < 3019000 #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 3016000 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019003 < 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. @@ -52,7 +52,7 @@ struct TableStruct_substrait_2fplan_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; + static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fplan_2eproto; namespace substrait { @@ -71,7 +71,7 @@ namespace substrait { // =================================================================== -class PlanRel PROTOBUF_FINAL : +class PlanRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.PlanRel) */ { public: inline PlanRel() : PlanRel(nullptr) {} @@ -89,8 +89,13 @@ class PlanRel PROTOBUF_FINAL : return *this; } inline PlanRel& operator=(PlanRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -127,7 +132,12 @@ class PlanRel PROTOBUF_FINAL : } inline void Swap(PlanRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -135,48 +145,53 @@ class PlanRel PROTOBUF_FINAL : } void UnsafeArenaSwap(PlanRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline PlanRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - PlanRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + PlanRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const PlanRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const PlanRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(PlanRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.PlanRel"; } protected: - explicit PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -194,7 +209,7 @@ class PlanRel PROTOBUF_FINAL : public: void clear_rel(); const ::substrait::Rel& rel() const; - ::substrait::Rel* release_rel(); + PROTOBUF_NODISCARD ::substrait::Rel* release_rel(); ::substrait::Rel* mutable_rel(); void set_allocated_rel(::substrait::Rel* rel); private: @@ -212,7 +227,7 @@ class PlanRel PROTOBUF_FINAL : public: void clear_root(); const ::substrait::RelRoot& root() const; - ::substrait::RelRoot* release_root(); + PROTOBUF_NODISCARD ::substrait::RelRoot* release_root(); ::substrait::RelRoot* mutable_root(); void set_allocated_root(::substrait::RelRoot* root); private: @@ -244,13 +259,13 @@ class PlanRel PROTOBUF_FINAL : ::substrait::RelRoot* root_; } rel_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2fplan_2eproto; }; // ------------------------------------------------------------------- -class Plan PROTOBUF_FINAL : +class Plan final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Plan) */ { public: inline Plan() : Plan(nullptr) {} @@ -268,8 +283,13 @@ class Plan PROTOBUF_FINAL : return *this; } inline Plan& operator=(Plan&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -300,7 +320,12 @@ class Plan PROTOBUF_FINAL : } inline void Swap(Plan* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -308,48 +333,53 @@ class Plan PROTOBUF_FINAL : } void UnsafeArenaSwap(Plan* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Plan* New() const final { - return CreateMaybeMessage(nullptr); - } - - Plan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Plan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Plan& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Plan& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Plan* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Plan"; } protected: - explicit Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -448,7 +478,7 @@ class Plan PROTOBUF_FINAL : public: void clear_advanced_extensions(); const ::substrait::extensions::AdvancedExtension& advanced_extensions() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extensions(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extensions(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extensions(); void set_allocated_advanced_extensions(::substrait::extensions::AdvancedExtension* advanced_extensions); private: @@ -500,7 +530,7 @@ inline ::substrait::Rel* PlanRel::release_rel() { if (_internal_has_rel()) { clear_has_rel_type(); ::substrait::Rel* temp = rel_type_.rel_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.rel_ = nullptr; @@ -541,13 +571,14 @@ inline ::substrait::Rel* PlanRel::_internal_mutable_rel() { if (!_internal_has_rel()) { clear_rel_type(); set_has_rel(); - rel_type_.rel_ = CreateMaybeMessage< ::substrait::Rel >(GetArena()); + rel_type_.rel_ = CreateMaybeMessage< ::substrait::Rel >(GetArenaForAllocation()); } return rel_type_.rel_; } inline ::substrait::Rel* PlanRel::mutable_rel() { + ::substrait::Rel* _msg = _internal_mutable_rel(); // @@protoc_insertion_point(field_mutable:substrait.PlanRel.rel) - return _internal_mutable_rel(); + return _msg; } // .substrait.RelRoot root = 2; @@ -565,7 +596,7 @@ inline ::substrait::RelRoot* PlanRel::release_root() { if (_internal_has_root()) { clear_has_rel_type(); ::substrait::RelRoot* temp = rel_type_.root_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.root_ = nullptr; @@ -606,13 +637,14 @@ inline ::substrait::RelRoot* PlanRel::_internal_mutable_root() { if (!_internal_has_root()) { clear_rel_type(); set_has_root(); - rel_type_.root_ = CreateMaybeMessage< ::substrait::RelRoot >(GetArena()); + rel_type_.root_ = CreateMaybeMessage< ::substrait::RelRoot >(GetArenaForAllocation()); } return rel_type_.root_; } inline ::substrait::RelRoot* PlanRel::mutable_root() { + ::substrait::RelRoot* _msg = _internal_mutable_root(); // @@protoc_insertion_point(field_mutable:substrait.PlanRel.root) - return _internal_mutable_root(); + return _msg; } inline bool PlanRel::has_rel_type() const { @@ -655,8 +687,9 @@ inline ::substrait::extensions::SimpleExtensionURI* Plan::_internal_add_extensio return extension_uris_.Add(); } inline ::substrait::extensions::SimpleExtensionURI* Plan::add_extension_uris() { + ::substrait::extensions::SimpleExtensionURI* _add = _internal_add_extension_uris(); // @@protoc_insertion_point(field_add:substrait.Plan.extension_uris) - return _internal_add_extension_uris(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >& Plan::extension_uris() const { @@ -691,8 +724,9 @@ inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::_internal_add_ return extensions_.Add(); } inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::add_extensions() { + ::substrait::extensions::SimpleExtensionDeclaration* _add = _internal_add_extensions(); // @@protoc_insertion_point(field_add:substrait.Plan.extensions) - return _internal_add_extensions(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >& Plan::extensions() const { @@ -730,8 +764,9 @@ inline ::substrait::PlanRel* Plan::_internal_add_relations() { return relations_.Add(); } inline ::substrait::PlanRel* Plan::add_relations() { + ::substrait::PlanRel* _add = _internal_add_relations(); // @@protoc_insertion_point(field_add:substrait.Plan.relations) - return _internal_add_relations(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >& Plan::relations() const { @@ -757,7 +792,7 @@ inline const ::substrait::extensions::AdvancedExtension& Plan::advanced_extensio } inline void Plan::unsafe_arena_set_allocated_advanced_extensions( ::substrait::extensions::AdvancedExtension* advanced_extensions) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions_); } advanced_extensions_ = advanced_extensions; @@ -772,9 +807,15 @@ inline ::substrait::extensions::AdvancedExtension* Plan::release_advanced_extens ::substrait::extensions::AdvancedExtension* temp = advanced_extensions_; advanced_extensions_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* Plan::unsafe_arena_release_advanced_extensions() { @@ -787,23 +828,26 @@ inline ::substrait::extensions::AdvancedExtension* Plan::unsafe_arena_release_ad inline ::substrait::extensions::AdvancedExtension* Plan::_internal_mutable_advanced_extensions() { if (advanced_extensions_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extensions_ = p; } return advanced_extensions_; } inline ::substrait::extensions::AdvancedExtension* Plan::mutable_advanced_extensions() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extensions(); // @@protoc_insertion_point(field_mutable:substrait.Plan.advanced_extensions) - return _internal_mutable_advanced_extensions(); + return _msg; } inline void Plan::set_allocated_advanced_extensions(::substrait::extensions::AdvancedExtension* advanced_extensions) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions_); } if (advanced_extensions) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions)); if (message_arena != submessage_arena) { advanced_extensions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extensions, submessage_arena); @@ -827,8 +871,9 @@ inline void Plan::clear_expected_type_urls() { expected_type_urls_.Clear(); } inline std::string* Plan::add_expected_type_urls() { + std::string* _s = _internal_add_expected_type_urls(); // @@protoc_insertion_point(field_add_mutable:substrait.Plan.expected_type_urls) - return _internal_add_expected_type_urls(); + return _s; } inline const std::string& Plan::_internal_expected_type_urls(int index) const { return expected_type_urls_.Get(index); @@ -842,12 +887,12 @@ inline std::string* Plan::mutable_expected_type_urls(int index) { return expected_type_urls_.Mutable(index); } inline void Plan::set_expected_type_urls(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.Plan.expected_type_urls) expected_type_urls_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.Plan.expected_type_urls) } inline void Plan::set_expected_type_urls(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.Plan.expected_type_urls) expected_type_urls_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.Plan.expected_type_urls) } inline void Plan::set_expected_type_urls(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); diff --git a/cpp/src/generated/substrait/relations.pb.cc b/cpp/src/generated/substrait/relations.pb.cc index 6ecc0e52d04..f4d4e904448 100644 --- a/cpp/src/generated/substrait/relations.pb.cc +++ b/cpp/src/generated/substrait/relations.pb.cc @@ -31,7 +31,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_DirectDefaultTypeInte constexpr RelCommon_Emit::RelCommon_Emit( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : output_mapping_() - , _output_mapping_cached_byte_size_(){} + , _output_mapping_cached_byte_size_(0){} struct RelCommon_EmitDefaultTypeInternal { constexpr RelCommon_EmitDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -136,9 +136,9 @@ constexpr ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) : format_(0) - , partition_index_(PROTOBUF_ULONGLONG(0)) - , start_(PROTOBUF_ULONGLONG(0)) - , length_(PROTOBUF_ULONGLONG(0)) + , partition_index_(uint64_t{0u}) + , start_(uint64_t{0u}) + , length_(uint64_t{0u}) , _oneof_case_{}{} struct ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal { constexpr ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal() @@ -218,8 +218,8 @@ constexpr FetchRel::FetchRel( : common_(nullptr) , input_(nullptr) , advanced_extension_(nullptr) - , offset_(PROTOBUF_LONGLONG(0)) - , count_(PROTOBUF_LONGLONG(0)){} + , offset_(int64_t{0}) + , count_(int64_t{0}){} struct FetchRelDefaultTypeInternal { constexpr FetchRelDefaultTypeInternal() : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} @@ -387,23 +387,26 @@ static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2frelatio static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2frelations_2eproto[3]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2frelations_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const uint32_t TableStruct_substrait_2frelations_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Direct, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Emit, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Emit, output_mapping_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, row_count_), PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, record_size_), PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, advanced_extension_), @@ -412,12 +415,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_RuntimeConstraint, advanced_extension_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, stats_), PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, constraint_), PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, advanced_extension_), @@ -426,6 +431,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, hint_), @@ -436,6 +442,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, names_), PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, advanced_extension_), ~0u, // no _has_bits_ @@ -443,18 +450,21 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_VirtualTable, values_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_ExtensionTable, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_ExtensionTable, detail_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, _internal_metadata_), ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -469,6 +479,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, items_), PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, advanced_extension_), ~0u, // no _has_bits_ @@ -476,6 +487,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, base_schema_), PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, filter_), @@ -491,6 +503,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, input_), PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, expressions_), @@ -500,6 +513,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, left_), PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, right_), @@ -512,6 +526,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, input_), PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, offset_), @@ -522,12 +537,14 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Grouping, grouping_expressions_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, measure_), PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, filter_), ~0u, // no _has_bits_ @@ -535,6 +552,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, input_), PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, groupings_), @@ -545,6 +563,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::SortRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::SortRel, input_), PROTOBUF_FIELD_OFFSET(::substrait::SortRel, sorts_), @@ -554,6 +573,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, input_), PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, condition_), @@ -563,6 +583,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::SetRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::SetRel, inputs_), PROTOBUF_FIELD_OFFSET(::substrait::SetRel, op_), @@ -572,6 +593,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, input_), PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, detail_), @@ -580,6 +602,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, detail_), ~0u, // no _has_bits_ @@ -587,6 +610,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, common_), PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, inputs_), PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, detail_), @@ -595,6 +619,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, input_), PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, names_), ~0u, // no _has_bits_ @@ -602,6 +627,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Rel, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -616,32 +642,32 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2frelations_2eproto: PROTOBUF_FIELD_OFFSET(::substrait::Rel, rel_type_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::substrait::RelCommon_Direct)}, - { 5, -1, sizeof(::substrait::RelCommon_Emit)}, - { 11, -1, sizeof(::substrait::RelCommon_Hint_Stats)}, - { 19, -1, sizeof(::substrait::RelCommon_Hint_RuntimeConstraint)}, - { 25, -1, sizeof(::substrait::RelCommon_Hint)}, - { 33, -1, sizeof(::substrait::RelCommon)}, - { 43, -1, sizeof(::substrait::ReadRel_NamedTable)}, - { 50, -1, sizeof(::substrait::ReadRel_VirtualTable)}, - { 56, -1, sizeof(::substrait::ReadRel_ExtensionTable)}, - { 62, -1, sizeof(::substrait::ReadRel_LocalFiles_FileOrFiles)}, - { 76, -1, sizeof(::substrait::ReadRel_LocalFiles)}, - { 83, -1, sizeof(::substrait::ReadRel)}, - { 98, -1, sizeof(::substrait::ProjectRel)}, - { 107, -1, sizeof(::substrait::JoinRel)}, - { 119, -1, sizeof(::substrait::FetchRel)}, - { 129, -1, sizeof(::substrait::AggregateRel_Grouping)}, - { 135, -1, sizeof(::substrait::AggregateRel_Measure)}, - { 142, -1, sizeof(::substrait::AggregateRel)}, - { 152, -1, sizeof(::substrait::SortRel)}, - { 161, -1, sizeof(::substrait::FilterRel)}, - { 170, -1, sizeof(::substrait::SetRel)}, - { 179, -1, sizeof(::substrait::ExtensionSingleRel)}, - { 187, -1, sizeof(::substrait::ExtensionLeafRel)}, - { 194, -1, sizeof(::substrait::ExtensionMultiRel)}, - { 202, -1, sizeof(::substrait::RelRoot)}, - { 209, -1, sizeof(::substrait::Rel)}, + { 0, -1, -1, sizeof(::substrait::RelCommon_Direct)}, + { 6, -1, -1, sizeof(::substrait::RelCommon_Emit)}, + { 13, -1, -1, sizeof(::substrait::RelCommon_Hint_Stats)}, + { 22, -1, -1, sizeof(::substrait::RelCommon_Hint_RuntimeConstraint)}, + { 29, -1, -1, sizeof(::substrait::RelCommon_Hint)}, + { 38, -1, -1, sizeof(::substrait::RelCommon)}, + { 49, -1, -1, sizeof(::substrait::ReadRel_NamedTable)}, + { 57, -1, -1, sizeof(::substrait::ReadRel_VirtualTable)}, + { 64, -1, -1, sizeof(::substrait::ReadRel_ExtensionTable)}, + { 71, -1, -1, sizeof(::substrait::ReadRel_LocalFiles_FileOrFiles)}, + { 86, -1, -1, sizeof(::substrait::ReadRel_LocalFiles)}, + { 94, -1, -1, sizeof(::substrait::ReadRel)}, + { 110, -1, -1, sizeof(::substrait::ProjectRel)}, + { 120, -1, -1, sizeof(::substrait::JoinRel)}, + { 133, -1, -1, sizeof(::substrait::FetchRel)}, + { 144, -1, -1, sizeof(::substrait::AggregateRel_Grouping)}, + { 151, -1, -1, sizeof(::substrait::AggregateRel_Measure)}, + { 159, -1, -1, sizeof(::substrait::AggregateRel)}, + { 170, -1, -1, sizeof(::substrait::SortRel)}, + { 180, -1, -1, sizeof(::substrait::FilterRel)}, + { 190, -1, -1, sizeof(::substrait::SetRel)}, + { 200, -1, -1, sizeof(::substrait::ExtensionSingleRel)}, + { 209, -1, -1, sizeof(::substrait::ExtensionLeafRel)}, + { 217, -1, -1, sizeof(::substrait::ExtensionMultiRel)}, + { 226, -1, -1, sizeof(::substrait::RelRoot)}, + { 234, -1, -1, sizeof(::substrait::Rel)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -835,13 +861,13 @@ bool ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(int value) { } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FILE_FORMAT_UNSPECIFIED; constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FILE_FORMAT_PARQUET; constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FileFormat_MIN; constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FileFormat_MAX; constexpr int ReadRel_LocalFiles_FileOrFiles::FileFormat_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto); return file_level_enum_descriptors_substrait_2frelations_2eproto[1]; @@ -861,7 +887,7 @@ bool JoinRel_JoinType_IsValid(int value) { } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_UNSPECIFIED; constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_INNER; constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_OUTER; @@ -872,7 +898,7 @@ constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_ANTI; constexpr JoinRel_JoinType JoinRel::JoinType_MIN; constexpr JoinRel_JoinType JoinRel::JoinType_MAX; constexpr int JoinRel::JoinType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetRel_SetOp_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto); return file_level_enum_descriptors_substrait_2frelations_2eproto[2]; @@ -892,7 +918,7 @@ bool SetRel_SetOp_IsValid(int value) { } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr SetRel_SetOp SetRel::SET_OP_UNSPECIFIED; constexpr SetRel_SetOp SetRel::SET_OP_MINUS_PRIMARY; constexpr SetRel_SetOp SetRel::SET_OP_MINUS_MULTISET; @@ -903,7 +929,7 @@ constexpr SetRel_SetOp SetRel::SET_OP_UNION_ALL; constexpr SetRel_SetOp SetRel::SetOp_MIN; constexpr SetRel_SetOp SetRel::SetOp_MAX; constexpr int SetRel::SetOp_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) // =================================================================== @@ -911,151 +937,32 @@ class RelCommon_Direct::_Internal { public: }; -RelCommon_Direct::RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { - SharedCtor(); - RegisterArenaDtor(arena); +RelCommon_Direct::RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Direct) } RelCommon_Direct::RelCommon_Direct(const RelCommon_Direct& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { + : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Direct) } -void RelCommon_Direct::SharedCtor() { -} - -RelCommon_Direct::~RelCommon_Direct() { - // @@protoc_insertion_point(destructor:substrait.RelCommon.Direct) - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -void RelCommon_Direct::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); -} - -void RelCommon_Direct::ArenaDtor(void* object) { - RelCommon_Direct* _this = reinterpret_cast< RelCommon_Direct* >(object); - (void)_this; -} -void RelCommon_Direct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void RelCommon_Direct::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void RelCommon_Direct::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Direct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* RelCommon_Direct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - continue; - } // while -success: - return ptr; -failure: - ptr = nullptr; - goto success; -#undef CHK_ -} - -::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Direct::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Direct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Direct) - return target; -} -size_t RelCommon_Direct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Direct) - size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; -} -void RelCommon_Direct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon.Direct) - GOOGLE_DCHECK_NE(&from, this); - const RelCommon_Direct* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon.Direct) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon.Direct) - MergeFrom(*source); - } -} +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Direct::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Direct::GetClassData() const { return &_class_data_; } -void RelCommon_Direct::MergeFrom(const RelCommon_Direct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Direct) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; - (void) cached_has_bits; -} -void RelCommon_Direct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon.Direct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -void RelCommon_Direct::CopyFrom(const RelCommon_Direct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Direct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} -bool RelCommon_Direct::IsInitialized() const { - return true; -} -void RelCommon_Direct::InternalSwap(RelCommon_Direct* other) { - using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); -} ::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Direct::GetMetadata() const { return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( @@ -1069,11 +976,14 @@ class RelCommon_Emit::_Internal { public: }; -RelCommon_Emit::RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +RelCommon_Emit::RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), output_mapping_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Emit) } RelCommon_Emit::RelCommon_Emit(const RelCommon_Emit& from) @@ -1083,17 +993,18 @@ RelCommon_Emit::RelCommon_Emit(const RelCommon_Emit& from) // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Emit) } -void RelCommon_Emit::SharedCtor() { +inline void RelCommon_Emit::SharedCtor() { } RelCommon_Emit::~RelCommon_Emit() { // @@protoc_insertion_point(destructor:substrait.RelCommon.Emit) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void RelCommon_Emit::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void RelCommon_Emit::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void RelCommon_Emit::ArenaDtor(void* object) { @@ -1108,7 +1019,7 @@ void RelCommon_Emit::SetCachedSize(int size) const { void RelCommon_Emit::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Emit) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1119,46 +1030,47 @@ void RelCommon_Emit::Clear() { const char* RelCommon_Emit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated int32 output_mapping = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_output_mapping(), ptr, ctx); CHK_(ptr); - } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8) { - _internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { + } else if (static_cast(tag) == 8) { + _internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Emit::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* RelCommon_Emit::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Emit) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated int32 output_mapping = 1; @@ -1182,7 +1094,7 @@ size_t RelCommon_Emit::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Emit) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1193,7 +1105,7 @@ size_t RelCommon_Emit::ByteSizeLong() const { if (data_size > 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - static_cast<::PROTOBUF_NAMESPACE_ID::int32>(data_size)); + static_cast(data_size)); } int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); _output_mapping_cached_byte_size_.store(cached_size, @@ -1201,45 +1113,30 @@ size_t RelCommon_Emit::ByteSizeLong() const { total_size += data_size; } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void RelCommon_Emit::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon.Emit) - GOOGLE_DCHECK_NE(&from, this); - const RelCommon_Emit* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon.Emit) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon.Emit) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Emit::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + RelCommon_Emit::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Emit::GetClassData() const { return &_class_data_; } + +void RelCommon_Emit::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void RelCommon_Emit::MergeFrom(const RelCommon_Emit& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Emit) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; output_mapping_.MergeFrom(from.output_mapping_); -} - -void RelCommon_Emit::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon.Emit) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void RelCommon_Emit::CopyFrom(const RelCommon_Emit& from) { @@ -1255,7 +1152,7 @@ bool RelCommon_Emit::IsInitialized() const { void RelCommon_Emit::InternalSwap(RelCommon_Emit* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); output_mapping_.InternalSwap(&other->output_mapping_); } @@ -1277,15 +1174,18 @@ RelCommon_Hint_Stats::_Internal::advanced_extension(const RelCommon_Hint_Stats* return *msg->advanced_extension_; } void RelCommon_Hint_Stats::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -RelCommon_Hint_Stats::RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +RelCommon_Hint_Stats::RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint.Stats) } RelCommon_Hint_Stats::RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from) @@ -1302,7 +1202,7 @@ RelCommon_Hint_Stats::RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from) // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.Stats) } -void RelCommon_Hint_Stats::SharedCtor() { +inline void RelCommon_Hint_Stats::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&advanced_extension_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&record_size_) - @@ -1311,12 +1211,13 @@ ::memset(reinterpret_cast(this) + static_cast( RelCommon_Hint_Stats::~RelCommon_Hint_Stats() { // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint.Stats) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void RelCommon_Hint_Stats::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void RelCommon_Hint_Stats::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete advanced_extension_; } @@ -1332,11 +1233,11 @@ void RelCommon_Hint_Stats::SetCachedSize(int size) const { void RelCommon_Hint_Stats::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint.Stats) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -1349,73 +1250,84 @@ void RelCommon_Hint_Stats::Clear() { const char* RelCommon_Hint_Stats::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // double row_count = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 9)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 9)) { row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(double); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // double record_size = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 17)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { record_size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); ptr += sizeof(double); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_Stats::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* RelCommon_Hint_Stats::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint.Stats) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // double row_count = 1; - if (!(this->row_count() <= 0 && this->row_count() >= 0)) { + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_row_count = this->_internal_row_count(); + uint64_t raw_row_count; + memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count)); + if (raw_row_count != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_row_count(), target); } // double record_size = 2; - if (!(this->record_size() <= 0 && this->record_size() >= 0)) { + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_record_size = this->_internal_record_size(); + uint64_t raw_record_size; + memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size)); + if (raw_record_size != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_record_size(), target); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1434,74 +1346,75 @@ size_t RelCommon_Hint_Stats::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint.Stats) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } // double row_count = 1; - if (!(this->row_count() <= 0 && this->row_count() >= 0)) { + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_row_count = this->_internal_row_count(); + uint64_t raw_row_count; + memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count)); + if (raw_row_count != 0) { total_size += 1 + 8; } // double record_size = 2; - if (!(this->record_size() <= 0 && this->record_size() >= 0)) { + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_record_size = this->_internal_record_size(); + uint64_t raw_record_size; + memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size)); + if (raw_record_size != 0) { total_size += 1 + 8; } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void RelCommon_Hint_Stats::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon.Hint.Stats) - GOOGLE_DCHECK_NE(&from, this); - const RelCommon_Hint_Stats* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon.Hint.Stats) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon.Hint.Stats) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Hint_Stats::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + RelCommon_Hint_Stats::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Hint_Stats::GetClassData() const { return &_class_data_; } + +void RelCommon_Hint_Stats::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void RelCommon_Hint_Stats::MergeFrom(const RelCommon_Hint_Stats& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint.Stats) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } - if (!(from.row_count() <= 0 && from.row_count() >= 0)) { + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_row_count = from._internal_row_count(); + uint64_t raw_row_count; + memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count)); + if (raw_row_count != 0) { _internal_set_row_count(from._internal_row_count()); } - if (!(from.record_size() <= 0 && from.record_size() >= 0)) { + static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); + double tmp_record_size = from._internal_record_size(); + uint64_t raw_record_size; + memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size)); + if (raw_record_size != 0) { _internal_set_record_size(from._internal_record_size()); } -} - -void RelCommon_Hint_Stats::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon.Hint.Stats) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void RelCommon_Hint_Stats::CopyFrom(const RelCommon_Hint_Stats& from) { @@ -1517,7 +1430,7 @@ bool RelCommon_Hint_Stats::IsInitialized() const { void RelCommon_Hint_Stats::InternalSwap(RelCommon_Hint_Stats* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(RelCommon_Hint_Stats, record_size_) + sizeof(RelCommon_Hint_Stats::record_size_) @@ -1544,15 +1457,18 @@ RelCommon_Hint_RuntimeConstraint::_Internal::advanced_extension(const RelCommon_ return *msg->advanced_extension_; } void RelCommon_Hint_RuntimeConstraint::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint.RuntimeConstraint) } RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(const RelCommon_Hint_RuntimeConstraint& from) @@ -1566,18 +1482,19 @@ RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(const RelComm // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.RuntimeConstraint) } -void RelCommon_Hint_RuntimeConstraint::SharedCtor() { +inline void RelCommon_Hint_RuntimeConstraint::SharedCtor() { advanced_extension_ = nullptr; } RelCommon_Hint_RuntimeConstraint::~RelCommon_Hint_RuntimeConstraint() { // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint.RuntimeConstraint) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void RelCommon_Hint_RuntimeConstraint::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void RelCommon_Hint_RuntimeConstraint::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete advanced_extension_; } @@ -1593,11 +1510,11 @@ void RelCommon_Hint_RuntimeConstraint::SetCachedSize(int size) const { void RelCommon_Hint_RuntimeConstraint::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint.RuntimeConstraint) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -1607,47 +1524,48 @@ void RelCommon_Hint_RuntimeConstraint::Clear() { const char* RelCommon_Hint_RuntimeConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint_RuntimeConstraint::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* RelCommon_Hint_RuntimeConstraint::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint.RuntimeConstraint) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1666,58 +1584,43 @@ size_t RelCommon_Hint_RuntimeConstraint::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint.RuntimeConstraint) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void RelCommon_Hint_RuntimeConstraint::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon.Hint.RuntimeConstraint) - GOOGLE_DCHECK_NE(&from, this); - const RelCommon_Hint_RuntimeConstraint* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon.Hint.RuntimeConstraint) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon.Hint.RuntimeConstraint) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Hint_RuntimeConstraint::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + RelCommon_Hint_RuntimeConstraint::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Hint_RuntimeConstraint::GetClassData() const { return &_class_data_; } + +void RelCommon_Hint_RuntimeConstraint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void RelCommon_Hint_RuntimeConstraint::MergeFrom(const RelCommon_Hint_RuntimeConstraint& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint.RuntimeConstraint) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } -} - -void RelCommon_Hint_RuntimeConstraint::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon.Hint.RuntimeConstraint) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void RelCommon_Hint_RuntimeConstraint::CopyFrom(const RelCommon_Hint_RuntimeConstraint& from) { @@ -1733,7 +1636,7 @@ bool RelCommon_Hint_RuntimeConstraint::IsInitialized() const { void RelCommon_Hint_RuntimeConstraint::InternalSwap(RelCommon_Hint_RuntimeConstraint* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(advanced_extension_, other->advanced_extension_); } @@ -1765,15 +1668,18 @@ RelCommon_Hint::_Internal::advanced_extension(const RelCommon_Hint* msg) { return *msg->advanced_extension_; } void RelCommon_Hint::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -RelCommon_Hint::RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +RelCommon_Hint::RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint) } RelCommon_Hint::RelCommon_Hint(const RelCommon_Hint& from) @@ -1797,7 +1703,7 @@ RelCommon_Hint::RelCommon_Hint(const RelCommon_Hint& from) // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint) } -void RelCommon_Hint::SharedCtor() { +inline void RelCommon_Hint::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&stats_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&advanced_extension_) - @@ -1806,12 +1712,13 @@ ::memset(reinterpret_cast(this) + static_cast( RelCommon_Hint::~RelCommon_Hint() { // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void RelCommon_Hint::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void RelCommon_Hint::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete stats_; if (this != internal_default_instance()) delete constraint_; if (this != internal_default_instance()) delete advanced_extension_; @@ -1829,19 +1736,19 @@ void RelCommon_Hint::SetCachedSize(int size) const { void RelCommon_Hint::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && stats_ != nullptr) { + if (GetArenaForAllocation() == nullptr && stats_ != nullptr) { delete stats_; } stats_ = nullptr; - if (GetArena() == nullptr && constraint_ != nullptr) { + if (GetArenaForAllocation() == nullptr && constraint_ != nullptr) { delete constraint_; } constraint_ = nullptr; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -1851,61 +1758,64 @@ void RelCommon_Hint::Clear() { const char* RelCommon_Hint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon.Hint.Stats stats = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_stats(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_constraint(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* RelCommon_Hint::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon.Hint.Stats stats = 1; - if (this->has_stats()) { + if (this->_internal_has_stats()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1913,7 +1823,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint::_InternalSerialize( } // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; - if (this->has_constraint()) { + if (this->_internal_has_constraint()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1921,7 +1831,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon_Hint::_InternalSerialize( } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1940,78 +1850,63 @@ size_t RelCommon_Hint::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.RelCommon.Hint.Stats stats = 1; - if (this->has_stats()) { + if (this->_internal_has_stats()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *stats_); } // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; - if (this->has_constraint()) { + if (this->_internal_has_constraint()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *constraint_); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void RelCommon_Hint::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon.Hint) - GOOGLE_DCHECK_NE(&from, this); - const RelCommon_Hint* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon.Hint) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon.Hint) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Hint::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + RelCommon_Hint::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Hint::GetClassData() const { return &_class_data_; } + +void RelCommon_Hint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void RelCommon_Hint::MergeFrom(const RelCommon_Hint& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_stats()) { + if (from._internal_has_stats()) { _internal_mutable_stats()->::substrait::RelCommon_Hint_Stats::MergeFrom(from._internal_stats()); } - if (from.has_constraint()) { + if (from._internal_has_constraint()) { _internal_mutable_constraint()->::substrait::RelCommon_Hint_RuntimeConstraint::MergeFrom(from._internal_constraint()); } - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } -} - -void RelCommon_Hint::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon.Hint) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void RelCommon_Hint::CopyFrom(const RelCommon_Hint& from) { @@ -2027,7 +1922,7 @@ bool RelCommon_Hint::IsInitialized() const { void RelCommon_Hint::InternalSwap(RelCommon_Hint* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(RelCommon_Hint, advanced_extension_) + sizeof(RelCommon_Hint::advanced_extension_) @@ -2069,11 +1964,11 @@ RelCommon::_Internal::advanced_extension(const RelCommon* msg) { return *msg->advanced_extension_; } void RelCommon::set_allocated_direct(::substrait::RelCommon_Direct* direct) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_emit_kind(); if (direct) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(direct); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Direct>::GetOwningArena(direct); if (message_arena != submessage_arena) { direct = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, direct, submessage_arena); @@ -2084,11 +1979,11 @@ void RelCommon::set_allocated_direct(::substrait::RelCommon_Direct* direct) { // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.direct) } void RelCommon::set_allocated_emit(::substrait::RelCommon_Emit* emit) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_emit_kind(); if (emit) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(emit); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Emit>::GetOwningArena(emit); if (message_arena != submessage_arena) { emit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, emit, submessage_arena); @@ -2099,15 +1994,18 @@ void RelCommon::set_allocated_emit(::substrait::RelCommon_Emit* emit) { // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.emit) } void RelCommon::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -RelCommon::RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +RelCommon::RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.RelCommon) } RelCommon::RelCommon(const RelCommon& from) @@ -2140,7 +2038,7 @@ RelCommon::RelCommon(const RelCommon& from) // @@protoc_insertion_point(copy_constructor:substrait.RelCommon) } -void RelCommon::SharedCtor() { +inline void RelCommon::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&hint_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&advanced_extension_) - @@ -2150,12 +2048,13 @@ clear_has_emit_kind(); RelCommon::~RelCommon() { // @@protoc_insertion_point(destructor:substrait.RelCommon) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void RelCommon::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void RelCommon::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete hint_; if (this != internal_default_instance()) delete advanced_extension_; if (has_emit_kind()) { @@ -2177,13 +2076,13 @@ void RelCommon::clear_emit_kind() { // @@protoc_insertion_point(one_of_clear_start:substrait.RelCommon) switch (emit_kind_case()) { case kDirect: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete emit_kind_.direct_; } break; } case kEmit: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete emit_kind_.emit_; } break; @@ -2198,15 +2097,15 @@ void RelCommon::clear_emit_kind() { void RelCommon::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.RelCommon) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && hint_ != nullptr) { + if (GetArenaForAllocation() == nullptr && hint_ != nullptr) { delete hint_; } hint_ = nullptr; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -2217,64 +2116,68 @@ void RelCommon::Clear() { const char* RelCommon::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon.Direct direct = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_direct(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.RelCommon.Emit emit = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_emit(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.RelCommon.Hint hint = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_hint(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* RelCommon::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* RelCommon::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon.Direct direct = 1; @@ -2294,7 +2197,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon::_InternalSerialize( } // .substrait.RelCommon.Hint hint = 3; - if (this->has_hint()) { + if (this->_internal_has_hint()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2302,7 +2205,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* RelCommon::_InternalSerialize( } // .substrait.extensions.AdvancedExtension advanced_extension = 4; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2321,19 +2224,19 @@ size_t RelCommon::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.RelCommon.Hint hint = 3; - if (this->has_hint()) { + if (this->_internal_has_hint()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *hint_); } // .substrait.extensions.AdvancedExtension advanced_extension = 4; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); @@ -2358,41 +2261,32 @@ size_t RelCommon::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void RelCommon::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelCommon) - GOOGLE_DCHECK_NE(&from, this); - const RelCommon* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelCommon) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelCommon) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + RelCommon::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon::GetClassData() const { return &_class_data_; } + +void RelCommon::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void RelCommon::MergeFrom(const RelCommon& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_hint()) { + if (from._internal_has_hint()) { _internal_mutable_hint()->::substrait::RelCommon_Hint::MergeFrom(from._internal_hint()); } - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } switch (from.emit_kind_case()) { @@ -2408,13 +2302,7 @@ void RelCommon::MergeFrom(const RelCommon& from) { break; } } -} - -void RelCommon::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelCommon) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void RelCommon::CopyFrom(const RelCommon& from) { @@ -2430,7 +2318,7 @@ bool RelCommon::IsInitialized() const { void RelCommon::InternalSwap(RelCommon* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(RelCommon, advanced_extension_) + sizeof(RelCommon::advanced_extension_) @@ -2459,16 +2347,19 @@ ReadRel_NamedTable::_Internal::advanced_extension(const ReadRel_NamedTable* msg) return *msg->advanced_extension_; } void ReadRel_NamedTable::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -ReadRel_NamedTable::ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +ReadRel_NamedTable::ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), names_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.NamedTable) } ReadRel_NamedTable::ReadRel_NamedTable(const ReadRel_NamedTable& from) @@ -2483,18 +2374,19 @@ ReadRel_NamedTable::ReadRel_NamedTable(const ReadRel_NamedTable& from) // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.NamedTable) } -void ReadRel_NamedTable::SharedCtor() { +inline void ReadRel_NamedTable::SharedCtor() { advanced_extension_ = nullptr; } ReadRel_NamedTable::~ReadRel_NamedTable() { // @@protoc_insertion_point(destructor:substrait.ReadRel.NamedTable) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ReadRel_NamedTable::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ReadRel_NamedTable::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete advanced_extension_; } @@ -2510,12 +2402,12 @@ void ReadRel_NamedTable::SetCachedSize(int size) const { void ReadRel_NamedTable::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ReadRel.NamedTable) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; names_.Clear(); - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -2525,12 +2417,12 @@ void ReadRel_NamedTable::Clear() { const char* ReadRel_NamedTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated string names = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -2540,42 +2432,44 @@ const char* ReadRel_NamedTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMES CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_NamedTable::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ReadRel_NamedTable::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.NamedTable) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated string names = 1; @@ -2589,7 +2483,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_NamedTable::_InternalSerialize( } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2608,7 +2502,7 @@ size_t ReadRel_NamedTable::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.NamedTable) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2621,54 +2515,39 @@ size_t ReadRel_NamedTable::ByteSizeLong() const { } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ReadRel_NamedTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel.NamedTable) - GOOGLE_DCHECK_NE(&from, this); - const ReadRel_NamedTable* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel.NamedTable) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel.NamedTable) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_NamedTable::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ReadRel_NamedTable::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_NamedTable::GetClassData() const { return &_class_data_; } + +void ReadRel_NamedTable::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ReadRel_NamedTable::MergeFrom(const ReadRel_NamedTable& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.NamedTable) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; names_.MergeFrom(from.names_); - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } -} - -void ReadRel_NamedTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel.NamedTable) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ReadRel_NamedTable::CopyFrom(const ReadRel_NamedTable& from) { @@ -2684,7 +2563,7 @@ bool ReadRel_NamedTable::IsInitialized() const { void ReadRel_NamedTable::InternalSwap(ReadRel_NamedTable* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); names_.InternalSwap(&other->names_); swap(advanced_extension_, other->advanced_extension_); } @@ -2704,11 +2583,14 @@ class ReadRel_VirtualTable::_Internal { void ReadRel_VirtualTable::clear_values() { values_.Clear(); } -ReadRel_VirtualTable::ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +ReadRel_VirtualTable::ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), values_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.VirtualTable) } ReadRel_VirtualTable::ReadRel_VirtualTable(const ReadRel_VirtualTable& from) @@ -2718,17 +2600,18 @@ ReadRel_VirtualTable::ReadRel_VirtualTable(const ReadRel_VirtualTable& from) // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.VirtualTable) } -void ReadRel_VirtualTable::SharedCtor() { +inline void ReadRel_VirtualTable::SharedCtor() { } ReadRel_VirtualTable::~ReadRel_VirtualTable() { // @@protoc_insertion_point(destructor:substrait.ReadRel.VirtualTable) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ReadRel_VirtualTable::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ReadRel_VirtualTable::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void ReadRel_VirtualTable::ArenaDtor(void* object) { @@ -2743,7 +2626,7 @@ void ReadRel_VirtualTable::SetCachedSize(int size) const { void ReadRel_VirtualTable::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ReadRel.VirtualTable) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2754,12 +2637,12 @@ void ReadRel_VirtualTable::Clear() { const char* ReadRel_VirtualTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression.Literal.Struct values = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -2767,35 +2650,36 @@ const char* ReadRel_VirtualTable::_InternalParse(const char* ptr, ::PROTOBUF_NAM CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_VirtualTable::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ReadRel_VirtualTable::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.VirtualTable) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression.Literal.Struct values = 1; @@ -2818,7 +2702,7 @@ size_t ReadRel_VirtualTable::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.VirtualTable) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2829,45 +2713,30 @@ size_t ReadRel_VirtualTable::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ReadRel_VirtualTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel.VirtualTable) - GOOGLE_DCHECK_NE(&from, this); - const ReadRel_VirtualTable* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel.VirtualTable) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel.VirtualTable) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_VirtualTable::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ReadRel_VirtualTable::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_VirtualTable::GetClassData() const { return &_class_data_; } + +void ReadRel_VirtualTable::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ReadRel_VirtualTable::MergeFrom(const ReadRel_VirtualTable& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.VirtualTable) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; values_.MergeFrom(from.values_); -} - -void ReadRel_VirtualTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel.VirtualTable) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ReadRel_VirtualTable::CopyFrom(const ReadRel_VirtualTable& from) { @@ -2883,7 +2752,7 @@ bool ReadRel_VirtualTable::IsInitialized() const { void ReadRel_VirtualTable::InternalSwap(ReadRel_VirtualTable* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); values_.InternalSwap(&other->values_); } @@ -2897,48 +2766,52 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_VirtualTable::GetMetadata() const { class ReadRel_ExtensionTable::_Internal { public: - static const PROTOBUF_NAMESPACE_ID::Any& detail(const ReadRel_ExtensionTable* msg); + static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ReadRel_ExtensionTable* msg); }; -const PROTOBUF_NAMESPACE_ID::Any& +const ::PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::_Internal::detail(const ReadRel_ExtensionTable* msg) { return *msg->detail_; } void ReadRel_ExtensionTable::clear_detail() { - if (GetArena() == nullptr && detail_ != nullptr) { + if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { delete detail_; } detail_ = nullptr; } -ReadRel_ExtensionTable::ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ReadRel_ExtensionTable::ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.ExtensionTable) } ReadRel_ExtensionTable::ReadRel_ExtensionTable(const ReadRel_ExtensionTable& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); if (from._internal_has_detail()) { - detail_ = new PROTOBUF_NAMESPACE_ID::Any(*from.detail_); + detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_); } else { detail_ = nullptr; } // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.ExtensionTable) } -void ReadRel_ExtensionTable::SharedCtor() { +inline void ReadRel_ExtensionTable::SharedCtor() { detail_ = nullptr; } ReadRel_ExtensionTable::~ReadRel_ExtensionTable() { // @@protoc_insertion_point(destructor:substrait.ReadRel.ExtensionTable) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ReadRel_ExtensionTable::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ReadRel_ExtensionTable::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete detail_; } @@ -2954,11 +2827,11 @@ void ReadRel_ExtensionTable::SetCachedSize(int size) const { void ReadRel_ExtensionTable::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ReadRel.ExtensionTable) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && detail_ != nullptr) { + if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { delete detail_; } detail_ = nullptr; @@ -2968,47 +2841,48 @@ void ReadRel_ExtensionTable::Clear() { const char* ReadRel_ExtensionTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .google.protobuf.Any detail = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_ExtensionTable::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ReadRel_ExtensionTable::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.ExtensionTable) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .google.protobuf.Any detail = 1; - if (this->has_detail()) { + if (this->_internal_has_detail()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3027,58 +2901,43 @@ size_t ReadRel_ExtensionTable::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.ExtensionTable) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .google.protobuf.Any detail = 1; - if (this->has_detail()) { + if (this->_internal_has_detail()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *detail_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ReadRel_ExtensionTable::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel.ExtensionTable) - GOOGLE_DCHECK_NE(&from, this); - const ReadRel_ExtensionTable* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel.ExtensionTable) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel.ExtensionTable) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_ExtensionTable::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ReadRel_ExtensionTable::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_ExtensionTable::GetClassData() const { return &_class_data_; } + +void ReadRel_ExtensionTable::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ReadRel_ExtensionTable::MergeFrom(const ReadRel_ExtensionTable& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.ExtensionTable) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_detail()) { - _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); + if (from._internal_has_detail()) { + _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); } -} - -void ReadRel_ExtensionTable::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel.ExtensionTable) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ReadRel_ExtensionTable::CopyFrom(const ReadRel_ExtensionTable& from) { @@ -3094,7 +2953,7 @@ bool ReadRel_ExtensionTable::IsInitialized() const { void ReadRel_ExtensionTable::InternalSwap(ReadRel_ExtensionTable* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(detail_, other->detail_); } @@ -3110,10 +2969,13 @@ class ReadRel_LocalFiles_FileOrFiles::_Internal { public: }; -ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.LocalFiles.FileOrFiles) } ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from) @@ -3147,7 +3009,7 @@ ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(const ReadRel_Loc // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.LocalFiles.FileOrFiles) } -void ReadRel_LocalFiles_FileOrFiles::SharedCtor() { +inline void ReadRel_LocalFiles_FileOrFiles::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&format_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&length_) - @@ -3157,12 +3019,13 @@ clear_has_path_type(); ReadRel_LocalFiles_FileOrFiles::~ReadRel_LocalFiles_FileOrFiles() { // @@protoc_insertion_point(destructor:substrait.ReadRel.LocalFiles.FileOrFiles) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ReadRel_LocalFiles_FileOrFiles::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ReadRel_LocalFiles_FileOrFiles::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_path_type()) { clear_path_type(); } @@ -3182,19 +3045,19 @@ void ReadRel_LocalFiles_FileOrFiles::clear_path_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.ReadRel.LocalFiles.FileOrFiles) switch (path_type_case()) { case kUriPath: { - path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kUriPathGlob: { - path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kUriFile: { - path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kUriFolder: { - path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case PATH_TYPE_NOT_SET: { @@ -3207,7 +3070,7 @@ void ReadRel_LocalFiles_FileOrFiles::clear_path_type() { void ReadRel_LocalFiles_FileOrFiles::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ReadRel.LocalFiles.FileOrFiles) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3221,101 +3084,109 @@ void ReadRel_LocalFiles_FileOrFiles::Clear() { const char* ReadRel_LocalFiles_FileOrFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string uri_path = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_uri_path(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string uri_path_glob = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { auto str = _internal_mutable_uri_path_glob(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string uri_file = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { auto str = _internal_mutable_uri_file(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_file")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string uri_folder = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { auto str = _internal_mutable_uri_folder(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_format(static_cast<::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint64 partition_index = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { partition_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint64 start = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 56)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint64 length = 8; case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles_FileOrFiles::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ReadRel_LocalFiles_FileOrFiles::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.LocalFiles.FileOrFiles) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string uri_path = 1; @@ -3359,26 +3230,26 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles_FileOrFiles::_InternalSeriali } // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; - if (this->format() != 0) { + if (this->_internal_format() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 5, this->_internal_format(), target); } // uint64 partition_index = 6; - if (this->partition_index() != 0) { + if (this->_internal_partition_index() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(6, this->_internal_partition_index(), target); } // uint64 start = 7; - if (this->start() != 0) { + if (this->_internal_start() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(7, this->_internal_start(), target); } // uint64 length = 8; - if (this->length() != 0) { + if (this->_internal_length() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->_internal_length(), target); } @@ -3395,35 +3266,29 @@ size_t ReadRel_LocalFiles_FileOrFiles::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.LocalFiles.FileOrFiles) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; - if (this->format() != 0) { + if (this->_internal_format() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_format()); } // uint64 partition_index = 6; - if (this->partition_index() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( - this->_internal_partition_index()); + if (this->_internal_partition_index() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_partition_index()); } // uint64 start = 7; - if (this->start() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( - this->_internal_start()); + if (this->_internal_start() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_start()); } // uint64 length = 8; - if (this->length() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size( - this->_internal_length()); + if (this->_internal_length() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_length()); } switch (path_type_case()) { @@ -3459,47 +3324,38 @@ size_t ReadRel_LocalFiles_FileOrFiles::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel.LocalFiles.FileOrFiles) - GOOGLE_DCHECK_NE(&from, this); - const ReadRel_LocalFiles_FileOrFiles* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel.LocalFiles.FileOrFiles) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel.LocalFiles.FileOrFiles) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_LocalFiles_FileOrFiles::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ReadRel_LocalFiles_FileOrFiles::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_LocalFiles_FileOrFiles::GetClassData() const { return &_class_data_; } + +void ReadRel_LocalFiles_FileOrFiles::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ReadRel_LocalFiles_FileOrFiles& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.LocalFiles.FileOrFiles) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.format() != 0) { + if (from._internal_format() != 0) { _internal_set_format(from._internal_format()); } - if (from.partition_index() != 0) { + if (from._internal_partition_index() != 0) { _internal_set_partition_index(from._internal_partition_index()); } - if (from.start() != 0) { + if (from._internal_start() != 0) { _internal_set_start(from._internal_start()); } - if (from.length() != 0) { + if (from._internal_length() != 0) { _internal_set_length(from._internal_length()); } switch (from.path_type_case()) { @@ -3523,13 +3379,7 @@ void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ReadRel_LocalFiles_FileOrFi break; } } -} - -void ReadRel_LocalFiles_FileOrFiles::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel.LocalFiles.FileOrFiles) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ReadRel_LocalFiles_FileOrFiles::CopyFrom(const ReadRel_LocalFiles_FileOrFiles& from) { @@ -3545,7 +3395,7 @@ bool ReadRel_LocalFiles_FileOrFiles::IsInitialized() const { void ReadRel_LocalFiles_FileOrFiles::InternalSwap(ReadRel_LocalFiles_FileOrFiles* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ReadRel_LocalFiles_FileOrFiles, length_) + sizeof(ReadRel_LocalFiles_FileOrFiles::length_) @@ -3574,16 +3424,19 @@ ReadRel_LocalFiles::_Internal::advanced_extension(const ReadRel_LocalFiles* msg) return *msg->advanced_extension_; } void ReadRel_LocalFiles::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -ReadRel_LocalFiles::ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +ReadRel_LocalFiles::ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), items_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.LocalFiles) } ReadRel_LocalFiles::ReadRel_LocalFiles(const ReadRel_LocalFiles& from) @@ -3598,18 +3451,19 @@ ReadRel_LocalFiles::ReadRel_LocalFiles(const ReadRel_LocalFiles& from) // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.LocalFiles) } -void ReadRel_LocalFiles::SharedCtor() { +inline void ReadRel_LocalFiles::SharedCtor() { advanced_extension_ = nullptr; } ReadRel_LocalFiles::~ReadRel_LocalFiles() { // @@protoc_insertion_point(destructor:substrait.ReadRel.LocalFiles) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ReadRel_LocalFiles::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ReadRel_LocalFiles::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete advanced_extension_; } @@ -3625,12 +3479,12 @@ void ReadRel_LocalFiles::SetCachedSize(int size) const { void ReadRel_LocalFiles::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ReadRel.LocalFiles) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; items_.Clear(); - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -3640,12 +3494,12 @@ void ReadRel_LocalFiles::Clear() { const char* ReadRel_LocalFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -3653,42 +3507,44 @@ const char* ReadRel_LocalFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMES CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ReadRel_LocalFiles::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.LocalFiles) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; @@ -3700,7 +3556,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel_LocalFiles::_InternalSerialize( } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3719,7 +3575,7 @@ size_t ReadRel_LocalFiles::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.LocalFiles) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3731,54 +3587,39 @@ size_t ReadRel_LocalFiles::ByteSizeLong() const { } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ReadRel_LocalFiles::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel.LocalFiles) - GOOGLE_DCHECK_NE(&from, this); - const ReadRel_LocalFiles* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel.LocalFiles) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel.LocalFiles) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_LocalFiles::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ReadRel_LocalFiles::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_LocalFiles::GetClassData() const { return &_class_data_; } + +void ReadRel_LocalFiles::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ReadRel_LocalFiles::MergeFrom(const ReadRel_LocalFiles& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.LocalFiles) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; items_.MergeFrom(from.items_); - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } -} - -void ReadRel_LocalFiles::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel.LocalFiles) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ReadRel_LocalFiles::CopyFrom(const ReadRel_LocalFiles& from) { @@ -3794,7 +3635,7 @@ bool ReadRel_LocalFiles::IsInitialized() const { void ReadRel_LocalFiles::InternalSwap(ReadRel_LocalFiles* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); items_.InternalSwap(&other->items_); swap(advanced_extension_, other->advanced_extension_); } @@ -3857,35 +3698,35 @@ ReadRel::_Internal::extension_table(const ReadRel* msg) { return *msg->read_type_.extension_table_; } void ReadRel::clear_base_schema() { - if (GetArena() == nullptr && base_schema_ != nullptr) { + if (GetArenaForAllocation() == nullptr && base_schema_ != nullptr) { delete base_schema_; } base_schema_ = nullptr; } void ReadRel::clear_filter() { - if (GetArena() == nullptr && filter_ != nullptr) { + if (GetArenaForAllocation() == nullptr && filter_ != nullptr) { delete filter_; } filter_ = nullptr; } void ReadRel::clear_projection() { - if (GetArena() == nullptr && projection_ != nullptr) { + if (GetArenaForAllocation() == nullptr && projection_ != nullptr) { delete projection_; } projection_ = nullptr; } void ReadRel::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } void ReadRel::set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_read_type(); if (virtual_table) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(virtual_table); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_VirtualTable>::GetOwningArena(virtual_table); if (message_arena != submessage_arena) { virtual_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, virtual_table, submessage_arena); @@ -3896,11 +3737,11 @@ void ReadRel::set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* vir // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.virtual_table) } void ReadRel::set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_read_type(); if (local_files) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(local_files); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_LocalFiles>::GetOwningArena(local_files); if (message_arena != submessage_arena) { local_files = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, local_files, submessage_arena); @@ -3911,11 +3752,11 @@ void ReadRel::set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_f // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.local_files) } void ReadRel::set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_read_type(); if (named_table) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(named_table); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_NamedTable>::GetOwningArena(named_table); if (message_arena != submessage_arena) { named_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, named_table, submessage_arena); @@ -3926,11 +3767,11 @@ void ReadRel::set_allocated_named_table(::substrait::ReadRel_NamedTable* named_t // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.named_table) } void ReadRel::set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_read_type(); if (extension_table) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_table); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_ExtensionTable>::GetOwningArena(extension_table); if (message_arena != submessage_arena) { extension_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, extension_table, submessage_arena); @@ -3940,10 +3781,13 @@ void ReadRel::set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* } // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.extension_table) } -ReadRel::ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ReadRel::ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ReadRel) } ReadRel::ReadRel(const ReadRel& from) @@ -3999,7 +3843,7 @@ ReadRel::ReadRel(const ReadRel& from) // @@protoc_insertion_point(copy_constructor:substrait.ReadRel) } -void ReadRel::SharedCtor() { +inline void ReadRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&advanced_extension_) - @@ -4009,12 +3853,13 @@ clear_has_read_type(); ReadRel::~ReadRel() { // @@protoc_insertion_point(destructor:substrait.ReadRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ReadRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ReadRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete base_schema_; if (this != internal_default_instance()) delete filter_; @@ -4039,25 +3884,25 @@ void ReadRel::clear_read_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.ReadRel) switch (read_type_case()) { case kVirtualTable: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete read_type_.virtual_table_; } break; } case kLocalFiles: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete read_type_.local_files_; } break; } case kNamedTable: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete read_type_.named_table_; } break; } case kExtensionTable: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete read_type_.extension_table_; } break; @@ -4072,27 +3917,27 @@ void ReadRel::clear_read_type() { void ReadRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ReadRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && base_schema_ != nullptr) { + if (GetArenaForAllocation() == nullptr && base_schema_ != nullptr) { delete base_schema_; } base_schema_ = nullptr; - if (GetArena() == nullptr && filter_ != nullptr) { + if (GetArenaForAllocation() == nullptr && filter_ != nullptr) { delete filter_; } filter_ = nullptr; - if (GetArena() == nullptr && projection_ != nullptr) { + if (GetArenaForAllocation() == nullptr && projection_ != nullptr) { delete projection_; } projection_ = nullptr; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -4103,103 +3948,112 @@ void ReadRel::Clear() { const char* ReadRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.NamedStruct base_schema = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_base_schema(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression filter = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression.MaskExpression projection = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_projection(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ReadRel.VirtualTable virtual_table = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_virtual_table(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ReadRel.LocalFiles local_files = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_local_files(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ReadRel.NamedTable named_table = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_named_table(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ReadRel.ExtensionTable extension_table = 8; case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr = ctx->ParseMessage(_internal_mutable_extension_table(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ReadRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -4207,7 +4061,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( } // .substrait.NamedStruct base_schema = 2; - if (this->has_base_schema()) { + if (this->_internal_has_base_schema()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -4215,7 +4069,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( } // .substrait.Expression filter = 3; - if (this->has_filter()) { + if (this->_internal_has_filter()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -4223,7 +4077,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( } // .substrait.Expression.MaskExpression projection = 4; - if (this->has_projection()) { + if (this->_internal_has_projection()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -4263,7 +4117,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ReadRel::_InternalSerialize( } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -4282,40 +4136,40 @@ size_t ReadRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .substrait.NamedStruct base_schema = 2; - if (this->has_base_schema()) { + if (this->_internal_has_base_schema()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *base_schema_); } // .substrait.Expression filter = 3; - if (this->has_filter()) { + if (this->_internal_has_filter()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *filter_); } // .substrait.Expression.MaskExpression projection = 4; - if (this->has_projection()) { + if (this->_internal_has_projection()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *projection_); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); @@ -4354,50 +4208,41 @@ size_t ReadRel::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ReadRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ReadRel) - GOOGLE_DCHECK_NE(&from, this); - const ReadRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ReadRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ReadRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ReadRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel::GetClassData() const { return &_class_data_; } + +void ReadRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ReadRel::MergeFrom(const ReadRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_base_schema()) { + if (from._internal_has_base_schema()) { _internal_mutable_base_schema()->::substrait::NamedStruct::MergeFrom(from._internal_base_schema()); } - if (from.has_filter()) { + if (from._internal_has_filter()) { _internal_mutable_filter()->::substrait::Expression::MergeFrom(from._internal_filter()); } - if (from.has_projection()) { + if (from._internal_has_projection()) { _internal_mutable_projection()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_projection()); } - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } switch (from.read_type_case()) { @@ -4421,13 +4266,7 @@ void ReadRel::MergeFrom(const ReadRel& from) { break; } } -} - -void ReadRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ReadRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ReadRel::CopyFrom(const ReadRel& from) { @@ -4443,7 +4282,7 @@ bool ReadRel::IsInitialized() const { void ReadRel::InternalSwap(ReadRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ReadRel, advanced_extension_) + sizeof(ReadRel::advanced_extension_) @@ -4485,16 +4324,19 @@ void ProjectRel::clear_expressions() { expressions_.Clear(); } void ProjectRel::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -ProjectRel::ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +ProjectRel::ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), expressions_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ProjectRel) } ProjectRel::ProjectRel(const ProjectRel& from) @@ -4519,7 +4361,7 @@ ProjectRel::ProjectRel(const ProjectRel& from) // @@protoc_insertion_point(copy_constructor:substrait.ProjectRel) } -void ProjectRel::SharedCtor() { +inline void ProjectRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&advanced_extension_) - @@ -4528,12 +4370,13 @@ ::memset(reinterpret_cast(this) + static_cast( ProjectRel::~ProjectRel() { // @@protoc_insertion_point(destructor:substrait.ProjectRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ProjectRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ProjectRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; if (this != internal_default_instance()) delete advanced_extension_; @@ -4551,20 +4394,20 @@ void ProjectRel::SetCachedSize(int size) const { void ProjectRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ProjectRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; expressions_.Clear(); - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -4574,26 +4417,28 @@ void ProjectRel::Clear() { const char* ProjectRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Rel input = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.Expression expressions = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -4601,46 +4446,48 @@ const char* ProjectRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID: CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ProjectRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ProjectRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ProjectRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -4648,7 +4495,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ProjectRel::_InternalSerialize( } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -4664,7 +4511,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ProjectRel::_InternalSerialize( } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -4683,7 +4530,7 @@ size_t ProjectRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ProjectRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4695,74 +4542,59 @@ size_t ProjectRel::ByteSizeLong() const { } // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ProjectRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ProjectRel) - GOOGLE_DCHECK_NE(&from, this); - const ProjectRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ProjectRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ProjectRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ProjectRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ProjectRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ProjectRel::GetClassData() const { return &_class_data_; } + +void ProjectRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ProjectRel::MergeFrom(const ProjectRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ProjectRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; expressions_.MergeFrom(from.expressions_); - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_input()) { + if (from._internal_has_input()) { _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } -} - -void ProjectRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ProjectRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ProjectRel::CopyFrom(const ProjectRel& from) { @@ -4778,7 +4610,7 @@ bool ProjectRel::IsInitialized() const { void ProjectRel::InternalSwap(ProjectRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); expressions_.InternalSwap(&other->expressions_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ProjectRel, advanced_extension_) @@ -4831,27 +4663,30 @@ JoinRel::_Internal::advanced_extension(const JoinRel* msg) { return *msg->advanced_extension_; } void JoinRel::clear_expression() { - if (GetArena() == nullptr && expression_ != nullptr) { + if (GetArenaForAllocation() == nullptr && expression_ != nullptr) { delete expression_; } expression_ = nullptr; } void JoinRel::clear_post_join_filter() { - if (GetArena() == nullptr && post_join_filter_ != nullptr) { + if (GetArenaForAllocation() == nullptr && post_join_filter_ != nullptr) { delete post_join_filter_; } post_join_filter_ = nullptr; } void JoinRel::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -JoinRel::JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +JoinRel::JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.JoinRel) } JoinRel::JoinRel(const JoinRel& from) @@ -4891,7 +4726,7 @@ JoinRel::JoinRel(const JoinRel& from) // @@protoc_insertion_point(copy_constructor:substrait.JoinRel) } -void JoinRel::SharedCtor() { +inline void JoinRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&type_) - @@ -4900,12 +4735,13 @@ ::memset(reinterpret_cast(this) + static_cast( JoinRel::~JoinRel() { // @@protoc_insertion_point(destructor:substrait.JoinRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void JoinRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void JoinRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete left_; if (this != internal_default_instance()) delete right_; @@ -4926,31 +4762,31 @@ void JoinRel::SetCachedSize(int size) const { void JoinRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.JoinRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && left_ != nullptr) { + if (GetArenaForAllocation() == nullptr && left_ != nullptr) { delete left_; } left_ = nullptr; - if (GetArena() == nullptr && right_ != nullptr) { + if (GetArenaForAllocation() == nullptr && right_ != nullptr) { delete right_; } right_ = nullptr; - if (GetArena() == nullptr && expression_ != nullptr) { + if (GetArenaForAllocation() == nullptr && expression_ != nullptr) { delete expression_; } expression_ = nullptr; - if (GetArena() == nullptr && post_join_filter_ != nullptr) { + if (GetArenaForAllocation() == nullptr && post_join_filter_ != nullptr) { delete post_join_filter_; } post_join_filter_ = nullptr; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -4961,90 +4797,97 @@ void JoinRel::Clear() { const char* JoinRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Rel left = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_left(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Rel right = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_right(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression expression = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression post_join_filter = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_post_join_filter(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.JoinRel.JoinType type = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_type(static_cast<::substrait::JoinRel_JoinType>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* JoinRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.JoinRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5052,7 +4895,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( } // .substrait.Rel left = 2; - if (this->has_left()) { + if (this->_internal_has_left()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5060,7 +4903,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( } // .substrait.Rel right = 3; - if (this->has_right()) { + if (this->_internal_has_right()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5068,7 +4911,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( } // .substrait.Expression expression = 4; - if (this->has_expression()) { + if (this->_internal_has_expression()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5076,7 +4919,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( } // .substrait.Expression post_join_filter = 5; - if (this->has_post_join_filter()) { + if (this->_internal_has_post_join_filter()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5084,14 +4927,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* JoinRel::_InternalSerialize( } // .substrait.JoinRel.JoinType type = 6; - if (this->type() != 0) { + if (this->_internal_type() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 6, this->_internal_type(), target); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5110,117 +4953,102 @@ size_t JoinRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.JoinRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .substrait.Rel left = 2; - if (this->has_left()) { + if (this->_internal_has_left()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *left_); } // .substrait.Rel right = 3; - if (this->has_right()) { + if (this->_internal_has_right()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *right_); } // .substrait.Expression expression = 4; - if (this->has_expression()) { + if (this->_internal_has_expression()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *expression_); } // .substrait.Expression post_join_filter = 5; - if (this->has_post_join_filter()) { + if (this->_internal_has_post_join_filter()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *post_join_filter_); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } // .substrait.JoinRel.JoinType type = 6; - if (this->type() != 0) { + if (this->_internal_type() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void JoinRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.JoinRel) - GOOGLE_DCHECK_NE(&from, this); - const JoinRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.JoinRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.JoinRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData JoinRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + JoinRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*JoinRel::GetClassData() const { return &_class_data_; } + +void JoinRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void JoinRel::MergeFrom(const JoinRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.JoinRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_left()) { + if (from._internal_has_left()) { _internal_mutable_left()->::substrait::Rel::MergeFrom(from._internal_left()); } - if (from.has_right()) { + if (from._internal_has_right()) { _internal_mutable_right()->::substrait::Rel::MergeFrom(from._internal_right()); } - if (from.has_expression()) { + if (from._internal_has_expression()) { _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression()); } - if (from.has_post_join_filter()) { + if (from._internal_has_post_join_filter()) { _internal_mutable_post_join_filter()->::substrait::Expression::MergeFrom(from._internal_post_join_filter()); } - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } - if (from.type() != 0) { + if (from._internal_type() != 0) { _internal_set_type(from._internal_type()); } -} - -void JoinRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.JoinRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void JoinRel::CopyFrom(const JoinRel& from) { @@ -5236,7 +5064,7 @@ bool JoinRel::IsInitialized() const { void JoinRel::InternalSwap(JoinRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(JoinRel, type_) + sizeof(JoinRel::type_) @@ -5273,15 +5101,18 @@ FetchRel::_Internal::advanced_extension(const FetchRel* msg) { return *msg->advanced_extension_; } void FetchRel::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -FetchRel::FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +FetchRel::FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FetchRel) } FetchRel::FetchRel(const FetchRel& from) @@ -5308,7 +5139,7 @@ FetchRel::FetchRel(const FetchRel& from) // @@protoc_insertion_point(copy_constructor:substrait.FetchRel) } -void FetchRel::SharedCtor() { +inline void FetchRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&count_) - @@ -5317,12 +5148,13 @@ ::memset(reinterpret_cast(this) + static_cast( FetchRel::~FetchRel() { // @@protoc_insertion_point(destructor:substrait.FetchRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FetchRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FetchRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; if (this != internal_default_instance()) delete advanced_extension_; @@ -5340,19 +5172,19 @@ void FetchRel::SetCachedSize(int size) const { void FetchRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FetchRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -5365,75 +5197,80 @@ void FetchRel::Clear() { const char* FetchRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Rel input = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int64 offset = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int64 count = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FetchRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FetchRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FetchRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5441,7 +5278,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FetchRel::_InternalSerialize( } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5449,19 +5286,19 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FetchRel::_InternalSerialize( } // int64 offset = 3; - if (this->offset() != 0) { + if (this->_internal_offset() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_offset(), target); } // int64 count = 4; - if (this->count() != 0) { + if (this->_internal_count() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_count(), target); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5480,98 +5317,79 @@ size_t FetchRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FetchRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } // int64 offset = 3; - if (this->offset() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_offset()); + if (this->_internal_offset() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset()); } // int64 count = 4; - if (this->count() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_count()); + if (this->_internal_count() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_count()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FetchRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FetchRel) - GOOGLE_DCHECK_NE(&from, this); - const FetchRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FetchRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FetchRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FetchRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FetchRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FetchRel::GetClassData() const { return &_class_data_; } + +void FetchRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FetchRel::MergeFrom(const FetchRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FetchRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_input()) { + if (from._internal_has_input()) { _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } - if (from.offset() != 0) { + if (from._internal_offset() != 0) { _internal_set_offset(from._internal_offset()); } - if (from.count() != 0) { + if (from._internal_count() != 0) { _internal_set_count(from._internal_count()); } -} - -void FetchRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FetchRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FetchRel::CopyFrom(const FetchRel& from) { @@ -5587,7 +5405,7 @@ bool FetchRel::IsInitialized() const { void FetchRel::InternalSwap(FetchRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(FetchRel, count_) + sizeof(FetchRel::count_) @@ -5611,11 +5429,14 @@ class AggregateRel_Grouping::_Internal { void AggregateRel_Grouping::clear_grouping_expressions() { grouping_expressions_.Clear(); } -AggregateRel_Grouping::AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +AggregateRel_Grouping::AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), grouping_expressions_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel.Grouping) } AggregateRel_Grouping::AggregateRel_Grouping(const AggregateRel_Grouping& from) @@ -5625,17 +5446,18 @@ AggregateRel_Grouping::AggregateRel_Grouping(const AggregateRel_Grouping& from) // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel.Grouping) } -void AggregateRel_Grouping::SharedCtor() { +inline void AggregateRel_Grouping::SharedCtor() { } AggregateRel_Grouping::~AggregateRel_Grouping() { // @@protoc_insertion_point(destructor:substrait.AggregateRel.Grouping) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void AggregateRel_Grouping::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void AggregateRel_Grouping::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void AggregateRel_Grouping::ArenaDtor(void* object) { @@ -5650,7 +5472,7 @@ void AggregateRel_Grouping::SetCachedSize(int size) const { void AggregateRel_Grouping::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.AggregateRel.Grouping) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5661,12 +5483,12 @@ void AggregateRel_Grouping::Clear() { const char* AggregateRel_Grouping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Expression grouping_expressions = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -5674,35 +5496,36 @@ const char* AggregateRel_Grouping::_InternalParse(const char* ptr, ::PROTOBUF_NA CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Grouping::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* AggregateRel_Grouping::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel.Grouping) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Expression grouping_expressions = 1; @@ -5725,7 +5548,7 @@ size_t AggregateRel_Grouping::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel.Grouping) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5736,45 +5559,30 @@ size_t AggregateRel_Grouping::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void AggregateRel_Grouping::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.AggregateRel.Grouping) - GOOGLE_DCHECK_NE(&from, this); - const AggregateRel_Grouping* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.AggregateRel.Grouping) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.AggregateRel.Grouping) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateRel_Grouping::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + AggregateRel_Grouping::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateRel_Grouping::GetClassData() const { return &_class_data_; } + +void AggregateRel_Grouping::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void AggregateRel_Grouping::MergeFrom(const AggregateRel_Grouping& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel.Grouping) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; grouping_expressions_.MergeFrom(from.grouping_expressions_); -} - -void AggregateRel_Grouping::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.AggregateRel.Grouping) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void AggregateRel_Grouping::CopyFrom(const AggregateRel_Grouping& from) { @@ -5790,7 +5598,7 @@ bool AggregateRel_Grouping::IsInitialized() const { void AggregateRel_Grouping::InternalSwap(AggregateRel_Grouping* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); grouping_expressions_.InternalSwap(&other->grouping_expressions_); } @@ -5817,21 +5625,24 @@ AggregateRel_Measure::_Internal::filter(const AggregateRel_Measure* msg) { return *msg->filter_; } void AggregateRel_Measure::clear_measure() { - if (GetArena() == nullptr && measure_ != nullptr) { + if (GetArenaForAllocation() == nullptr && measure_ != nullptr) { delete measure_; } measure_ = nullptr; } void AggregateRel_Measure::clear_filter() { - if (GetArena() == nullptr && filter_ != nullptr) { + if (GetArenaForAllocation() == nullptr && filter_ != nullptr) { delete filter_; } filter_ = nullptr; } -AggregateRel_Measure::AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +AggregateRel_Measure::AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel.Measure) } AggregateRel_Measure::AggregateRel_Measure(const AggregateRel_Measure& from) @@ -5850,7 +5661,7 @@ AggregateRel_Measure::AggregateRel_Measure(const AggregateRel_Measure& from) // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel.Measure) } -void AggregateRel_Measure::SharedCtor() { +inline void AggregateRel_Measure::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&measure_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&filter_) - @@ -5859,12 +5670,13 @@ ::memset(reinterpret_cast(this) + static_cast( AggregateRel_Measure::~AggregateRel_Measure() { // @@protoc_insertion_point(destructor:substrait.AggregateRel.Measure) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void AggregateRel_Measure::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void AggregateRel_Measure::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete measure_; if (this != internal_default_instance()) delete filter_; } @@ -5881,15 +5693,15 @@ void AggregateRel_Measure::SetCachedSize(int size) const { void AggregateRel_Measure::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.AggregateRel.Measure) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && measure_ != nullptr) { + if (GetArenaForAllocation() == nullptr && measure_ != nullptr) { delete measure_; } measure_ = nullptr; - if (GetArena() == nullptr && filter_ != nullptr) { + if (GetArenaForAllocation() == nullptr && filter_ != nullptr) { delete filter_; } filter_ = nullptr; @@ -5899,54 +5711,56 @@ void AggregateRel_Measure::Clear() { const char* AggregateRel_Measure::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.AggregateFunction measure = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_measure(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression filter = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Measure::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* AggregateRel_Measure::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel.Measure) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.AggregateFunction measure = 1; - if (this->has_measure()) { + if (this->_internal_has_measure()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5954,7 +5768,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel_Measure::_InternalSerialize( } // .substrait.Expression filter = 2; - if (this->has_filter()) { + if (this->_internal_has_filter()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5973,68 +5787,53 @@ size_t AggregateRel_Measure::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel.Measure) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.AggregateFunction measure = 1; - if (this->has_measure()) { + if (this->_internal_has_measure()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *measure_); } // .substrait.Expression filter = 2; - if (this->has_filter()) { + if (this->_internal_has_filter()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *filter_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void AggregateRel_Measure::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.AggregateRel.Measure) - GOOGLE_DCHECK_NE(&from, this); - const AggregateRel_Measure* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.AggregateRel.Measure) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.AggregateRel.Measure) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateRel_Measure::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + AggregateRel_Measure::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateRel_Measure::GetClassData() const { return &_class_data_; } + +void AggregateRel_Measure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void AggregateRel_Measure::MergeFrom(const AggregateRel_Measure& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel.Measure) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_measure()) { + if (from._internal_has_measure()) { _internal_mutable_measure()->::substrait::AggregateFunction::MergeFrom(from._internal_measure()); } - if (from.has_filter()) { + if (from._internal_has_filter()) { _internal_mutable_filter()->::substrait::Expression::MergeFrom(from._internal_filter()); } -} - -void AggregateRel_Measure::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.AggregateRel.Measure) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void AggregateRel_Measure::CopyFrom(const AggregateRel_Measure& from) { @@ -6050,7 +5849,7 @@ bool AggregateRel_Measure::IsInitialized() const { void AggregateRel_Measure::InternalSwap(AggregateRel_Measure* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(AggregateRel_Measure, filter_) + sizeof(AggregateRel_Measure::filter_) @@ -6087,17 +5886,20 @@ AggregateRel::_Internal::advanced_extension(const AggregateRel* msg) { return *msg->advanced_extension_; } void AggregateRel::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -AggregateRel::AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +AggregateRel::AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), groupings_(arena), measures_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel) } AggregateRel::AggregateRel(const AggregateRel& from) @@ -6123,7 +5925,7 @@ AggregateRel::AggregateRel(const AggregateRel& from) // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel) } -void AggregateRel::SharedCtor() { +inline void AggregateRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&advanced_extension_) - @@ -6132,12 +5934,13 @@ ::memset(reinterpret_cast(this) + static_cast( AggregateRel::~AggregateRel() { // @@protoc_insertion_point(destructor:substrait.AggregateRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void AggregateRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void AggregateRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; if (this != internal_default_instance()) delete advanced_extension_; @@ -6155,21 +5958,21 @@ void AggregateRel::SetCachedSize(int size) const { void AggregateRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.AggregateRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; groupings_.Clear(); measures_.Clear(); - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -6179,26 +5982,28 @@ void AggregateRel::Clear() { const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Rel input = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.AggregateRel.Grouping groupings = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -6206,11 +6011,12 @@ const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.AggregateRel.Measure measures = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr -= 1; do { ptr += 1; @@ -6218,46 +6024,48 @@ const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_I CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* AggregateRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6265,7 +6073,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6289,7 +6097,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* AggregateRel::_InternalSerialize( } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6308,7 +6116,7 @@ size_t AggregateRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6327,75 +6135,60 @@ size_t AggregateRel::ByteSizeLong() const { } // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void AggregateRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.AggregateRel) - GOOGLE_DCHECK_NE(&from, this); - const AggregateRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.AggregateRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.AggregateRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + AggregateRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateRel::GetClassData() const { return &_class_data_; } + +void AggregateRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void AggregateRel::MergeFrom(const AggregateRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; groupings_.MergeFrom(from.groupings_); measures_.MergeFrom(from.measures_); - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_input()) { + if (from._internal_has_input()) { _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } -} - -void AggregateRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.AggregateRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void AggregateRel::CopyFrom(const AggregateRel& from) { @@ -6411,7 +6204,7 @@ bool AggregateRel::IsInitialized() const { void AggregateRel::InternalSwap(AggregateRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); groupings_.InternalSwap(&other->groupings_); measures_.InternalSwap(&other->measures_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< @@ -6453,16 +6246,19 @@ void SortRel::clear_sorts() { sorts_.Clear(); } void SortRel::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -SortRel::SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +SortRel::SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), sorts_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.SortRel) } SortRel::SortRel(const SortRel& from) @@ -6487,7 +6283,7 @@ SortRel::SortRel(const SortRel& from) // @@protoc_insertion_point(copy_constructor:substrait.SortRel) } -void SortRel::SharedCtor() { +inline void SortRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&advanced_extension_) - @@ -6496,12 +6292,13 @@ ::memset(reinterpret_cast(this) + static_cast( SortRel::~SortRel() { // @@protoc_insertion_point(destructor:substrait.SortRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void SortRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void SortRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; if (this != internal_default_instance()) delete advanced_extension_; @@ -6519,20 +6316,20 @@ void SortRel::SetCachedSize(int size) const { void SortRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.SortRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; sorts_.Clear(); - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -6542,26 +6339,28 @@ void SortRel::Clear() { const char* SortRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Rel input = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.SortField sorts = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr -= 1; do { ptr += 1; @@ -6569,46 +6368,48 @@ const char* SortRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* SortRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.SortRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6616,7 +6417,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6632,7 +6433,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SortRel::_InternalSerialize( } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6651,7 +6452,7 @@ size_t SortRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.SortRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -6663,74 +6464,59 @@ size_t SortRel::ByteSizeLong() const { } // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void SortRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.SortRel) - GOOGLE_DCHECK_NE(&from, this); - const SortRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.SortRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.SortRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SortRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SortRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SortRel::GetClassData() const { return &_class_data_; } + +void SortRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void SortRel::MergeFrom(const SortRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.SortRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; sorts_.MergeFrom(from.sorts_); - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_input()) { + if (from._internal_has_input()) { _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } -} - -void SortRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.SortRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SortRel::CopyFrom(const SortRel& from) { @@ -6746,7 +6532,7 @@ bool SortRel::IsInitialized() const { void SortRel::InternalSwap(SortRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); sorts_.InternalSwap(&other->sorts_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(SortRel, advanced_extension_) @@ -6789,21 +6575,24 @@ FilterRel::_Internal::advanced_extension(const FilterRel* msg) { return *msg->advanced_extension_; } void FilterRel::clear_condition() { - if (GetArena() == nullptr && condition_ != nullptr) { + if (GetArenaForAllocation() == nullptr && condition_ != nullptr) { delete condition_; } condition_ = nullptr; } void FilterRel::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -FilterRel::FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +FilterRel::FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.FilterRel) } FilterRel::FilterRel(const FilterRel& from) @@ -6832,7 +6621,7 @@ FilterRel::FilterRel(const FilterRel& from) // @@protoc_insertion_point(copy_constructor:substrait.FilterRel) } -void FilterRel::SharedCtor() { +inline void FilterRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&advanced_extension_) - @@ -6841,12 +6630,13 @@ ::memset(reinterpret_cast(this) + static_cast( FilterRel::~FilterRel() { // @@protoc_insertion_point(destructor:substrait.FilterRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void FilterRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void FilterRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; if (this != internal_default_instance()) delete condition_; @@ -6865,23 +6655,23 @@ void FilterRel::SetCachedSize(int size) const { void FilterRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.FilterRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; - if (GetArena() == nullptr && condition_ != nullptr) { + if (GetArenaForAllocation() == nullptr && condition_ != nullptr) { delete condition_; } condition_ = nullptr; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -6891,68 +6681,72 @@ void FilterRel::Clear() { const char* FilterRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Rel input = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Expression condition = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_condition(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* FilterRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.FilterRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6960,7 +6754,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6968,7 +6762,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( } // .substrait.Expression condition = 3; - if (this->has_condition()) { + if (this->_internal_has_condition()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6976,7 +6770,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* FilterRel::_InternalSerialize( } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6995,88 +6789,73 @@ size_t FilterRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.FilterRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } // .substrait.Expression condition = 3; - if (this->has_condition()) { + if (this->_internal_has_condition()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *condition_); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void FilterRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.FilterRel) - GOOGLE_DCHECK_NE(&from, this); - const FilterRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.FilterRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.FilterRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FilterRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + FilterRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FilterRel::GetClassData() const { return &_class_data_; } + +void FilterRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void FilterRel::MergeFrom(const FilterRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.FilterRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_input()) { + if (from._internal_has_input()) { _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } - if (from.has_condition()) { + if (from._internal_has_condition()) { _internal_mutable_condition()->::substrait::Expression::MergeFrom(from._internal_condition()); } - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } -} - -void FilterRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.FilterRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void FilterRel::CopyFrom(const FilterRel& from) { @@ -7092,7 +6871,7 @@ bool FilterRel::IsInitialized() const { void FilterRel::InternalSwap(FilterRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(FilterRel, advanced_extension_) + sizeof(FilterRel::advanced_extension_) @@ -7124,16 +6903,19 @@ SetRel::_Internal::advanced_extension(const SetRel* msg) { return *msg->advanced_extension_; } void SetRel::clear_advanced_extension() { - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; } -SetRel::SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +SetRel::SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), inputs_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.SetRel) } SetRel::SetRel(const SetRel& from) @@ -7154,7 +6936,7 @@ SetRel::SetRel(const SetRel& from) // @@protoc_insertion_point(copy_constructor:substrait.SetRel) } -void SetRel::SharedCtor() { +inline void SetRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&op_) - @@ -7163,12 +6945,13 @@ ::memset(reinterpret_cast(this) + static_cast( SetRel::~SetRel() { // @@protoc_insertion_point(destructor:substrait.SetRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void SetRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void SetRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete advanced_extension_; } @@ -7185,16 +6968,16 @@ void SetRel::SetCachedSize(int size) const { void SetRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.SetRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; inputs_.Clear(); - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && advanced_extension_ != nullptr) { + if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { delete advanced_extension_; } advanced_extension_ = nullptr; @@ -7205,19 +6988,20 @@ void SetRel::Clear() { const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.Rel inputs = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -7225,54 +7009,57 @@ const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::int CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.SetRel.SetOp op = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_op(static_cast<::substrait::SetRel_SetOp>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.extensions.AdvancedExtension advanced_extension = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* SetRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* SetRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.SetRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7288,14 +7075,14 @@ ::PROTOBUF_NAMESPACE_ID::uint8* SetRel::_InternalSerialize( } // .substrait.SetRel.SetOp op = 3; - if (this->op() != 0) { + if (this->_internal_op() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_op(), target); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7314,7 +7101,7 @@ size_t SetRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.SetRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7326,73 +7113,58 @@ size_t SetRel::ByteSizeLong() const { } // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->has_advanced_extension()) { + if (this->_internal_has_advanced_extension()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *advanced_extension_); } // .substrait.SetRel.SetOp op = 3; - if (this->op() != 0) { + if (this->_internal_op() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void SetRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.SetRel) - GOOGLE_DCHECK_NE(&from, this); - const SetRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.SetRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.SetRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SetRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + SetRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetRel::GetClassData() const { return &_class_data_; } + +void SetRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void SetRel::MergeFrom(const SetRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.SetRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; inputs_.MergeFrom(from.inputs_); - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_advanced_extension()) { + if (from._internal_has_advanced_extension()) { _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); } - if (from.op() != 0) { + if (from._internal_op() != 0) { _internal_set_op(from._internal_op()); } -} - -void SetRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.SetRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void SetRel::CopyFrom(const SetRel& from) { @@ -7408,7 +7180,7 @@ bool SetRel::IsInitialized() const { void SetRel::InternalSwap(SetRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); inputs_.InternalSwap(&other->inputs_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(SetRel, op_) @@ -7430,7 +7202,7 @@ class ExtensionSingleRel::_Internal { public: static const ::substrait::RelCommon& common(const ExtensionSingleRel* msg); static const ::substrait::Rel& input(const ExtensionSingleRel* msg); - static const PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionSingleRel* msg); + static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionSingleRel* msg); }; const ::substrait::RelCommon& @@ -7441,20 +7213,23 @@ const ::substrait::Rel& ExtensionSingleRel::_Internal::input(const ExtensionSingleRel* msg) { return *msg->input_; } -const PROTOBUF_NAMESPACE_ID::Any& +const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::_Internal::detail(const ExtensionSingleRel* msg) { return *msg->detail_; } void ExtensionSingleRel::clear_detail() { - if (GetArena() == nullptr && detail_ != nullptr) { + if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { delete detail_; } detail_ = nullptr; } -ExtensionSingleRel::ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ExtensionSingleRel::ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ExtensionSingleRel) } ExtensionSingleRel::ExtensionSingleRel(const ExtensionSingleRel& from) @@ -7471,14 +7246,14 @@ ExtensionSingleRel::ExtensionSingleRel(const ExtensionSingleRel& from) input_ = nullptr; } if (from._internal_has_detail()) { - detail_ = new PROTOBUF_NAMESPACE_ID::Any(*from.detail_); + detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_); } else { detail_ = nullptr; } // @@protoc_insertion_point(copy_constructor:substrait.ExtensionSingleRel) } -void ExtensionSingleRel::SharedCtor() { +inline void ExtensionSingleRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&detail_) - @@ -7487,12 +7262,13 @@ ::memset(reinterpret_cast(this) + static_cast( ExtensionSingleRel::~ExtensionSingleRel() { // @@protoc_insertion_point(destructor:substrait.ExtensionSingleRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ExtensionSingleRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ExtensionSingleRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete input_; if (this != internal_default_instance()) delete detail_; @@ -7510,19 +7286,19 @@ void ExtensionSingleRel::SetCachedSize(int size) const { void ExtensionSingleRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ExtensionSingleRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; - if (GetArena() == nullptr && detail_ != nullptr) { + if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { delete detail_; } detail_ = nullptr; @@ -7532,61 +7308,64 @@ void ExtensionSingleRel::Clear() { const char* ExtensionSingleRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Rel input = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .google.protobuf.Any detail = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ExtensionSingleRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ExtensionSingleRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionSingleRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7594,7 +7373,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionSingleRel::_InternalSerialize( } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7602,7 +7381,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionSingleRel::_InternalSerialize( } // .google.protobuf.Any detail = 3; - if (this->has_detail()) { + if (this->_internal_has_detail()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7621,78 +7400,63 @@ size_t ExtensionSingleRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionSingleRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .substrait.Rel input = 2; - if (this->has_input()) { + if (this->_internal_has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } // .google.protobuf.Any detail = 3; - if (this->has_detail()) { + if (this->_internal_has_detail()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *detail_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ExtensionSingleRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ExtensionSingleRel) - GOOGLE_DCHECK_NE(&from, this); - const ExtensionSingleRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ExtensionSingleRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ExtensionSingleRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExtensionSingleRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ExtensionSingleRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExtensionSingleRel::GetClassData() const { return &_class_data_; } + +void ExtensionSingleRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ExtensionSingleRel::MergeFrom(const ExtensionSingleRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionSingleRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_input()) { + if (from._internal_has_input()) { _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } - if (from.has_detail()) { - _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); + if (from._internal_has_detail()) { + _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); } -} - -void ExtensionSingleRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ExtensionSingleRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ExtensionSingleRel::CopyFrom(const ExtensionSingleRel& from) { @@ -7708,7 +7472,7 @@ bool ExtensionSingleRel::IsInitialized() const { void ExtensionSingleRel::InternalSwap(ExtensionSingleRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ExtensionSingleRel, detail_) + sizeof(ExtensionSingleRel::detail_) @@ -7728,27 +7492,30 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ExtensionSingleRel::GetMetadata() const { class ExtensionLeafRel::_Internal { public: static const ::substrait::RelCommon& common(const ExtensionLeafRel* msg); - static const PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionLeafRel* msg); + static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionLeafRel* msg); }; const ::substrait::RelCommon& ExtensionLeafRel::_Internal::common(const ExtensionLeafRel* msg) { return *msg->common_; } -const PROTOBUF_NAMESPACE_ID::Any& +const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::_Internal::detail(const ExtensionLeafRel* msg) { return *msg->detail_; } void ExtensionLeafRel::clear_detail() { - if (GetArena() == nullptr && detail_ != nullptr) { + if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { delete detail_; } detail_ = nullptr; } -ExtensionLeafRel::ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +ExtensionLeafRel::ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ExtensionLeafRel) } ExtensionLeafRel::ExtensionLeafRel(const ExtensionLeafRel& from) @@ -7760,14 +7527,14 @@ ExtensionLeafRel::ExtensionLeafRel(const ExtensionLeafRel& from) common_ = nullptr; } if (from._internal_has_detail()) { - detail_ = new PROTOBUF_NAMESPACE_ID::Any(*from.detail_); + detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_); } else { detail_ = nullptr; } // @@protoc_insertion_point(copy_constructor:substrait.ExtensionLeafRel) } -void ExtensionLeafRel::SharedCtor() { +inline void ExtensionLeafRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&detail_) - @@ -7776,12 +7543,13 @@ ::memset(reinterpret_cast(this) + static_cast( ExtensionLeafRel::~ExtensionLeafRel() { // @@protoc_insertion_point(destructor:substrait.ExtensionLeafRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ExtensionLeafRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ExtensionLeafRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete detail_; } @@ -7798,15 +7566,15 @@ void ExtensionLeafRel::SetCachedSize(int size) const { void ExtensionLeafRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ExtensionLeafRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && detail_ != nullptr) { + if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { delete detail_; } detail_ = nullptr; @@ -7816,54 +7584,56 @@ void ExtensionLeafRel::Clear() { const char* ExtensionLeafRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .google.protobuf.Any detail = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ExtensionLeafRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ExtensionLeafRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionLeafRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7871,7 +7641,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionLeafRel::_InternalSerialize( } // .google.protobuf.Any detail = 2; - if (this->has_detail()) { + if (this->_internal_has_detail()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7890,68 +7660,53 @@ size_t ExtensionLeafRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionLeafRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .google.protobuf.Any detail = 2; - if (this->has_detail()) { + if (this->_internal_has_detail()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *detail_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ExtensionLeafRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ExtensionLeafRel) - GOOGLE_DCHECK_NE(&from, this); - const ExtensionLeafRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ExtensionLeafRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ExtensionLeafRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExtensionLeafRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ExtensionLeafRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExtensionLeafRel::GetClassData() const { return &_class_data_; } + +void ExtensionLeafRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ExtensionLeafRel::MergeFrom(const ExtensionLeafRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionLeafRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_detail()) { - _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); + if (from._internal_has_detail()) { + _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); } -} - -void ExtensionLeafRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ExtensionLeafRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ExtensionLeafRel::CopyFrom(const ExtensionLeafRel& from) { @@ -7967,7 +7722,7 @@ bool ExtensionLeafRel::IsInitialized() const { void ExtensionLeafRel::InternalSwap(ExtensionLeafRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ExtensionLeafRel, detail_) + sizeof(ExtensionLeafRel::detail_) @@ -7987,28 +7742,31 @@ ::PROTOBUF_NAMESPACE_ID::Metadata ExtensionLeafRel::GetMetadata() const { class ExtensionMultiRel::_Internal { public: static const ::substrait::RelCommon& common(const ExtensionMultiRel* msg); - static const PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionMultiRel* msg); + static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionMultiRel* msg); }; const ::substrait::RelCommon& ExtensionMultiRel::_Internal::common(const ExtensionMultiRel* msg) { return *msg->common_; } -const PROTOBUF_NAMESPACE_ID::Any& +const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::_Internal::detail(const ExtensionMultiRel* msg) { return *msg->detail_; } void ExtensionMultiRel::clear_detail() { - if (GetArena() == nullptr && detail_ != nullptr) { + if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { delete detail_; } detail_ = nullptr; } -ExtensionMultiRel::ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +ExtensionMultiRel::ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), inputs_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.ExtensionMultiRel) } ExtensionMultiRel::ExtensionMultiRel(const ExtensionMultiRel& from) @@ -8021,14 +7779,14 @@ ExtensionMultiRel::ExtensionMultiRel(const ExtensionMultiRel& from) common_ = nullptr; } if (from._internal_has_detail()) { - detail_ = new PROTOBUF_NAMESPACE_ID::Any(*from.detail_); + detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_); } else { detail_ = nullptr; } // @@protoc_insertion_point(copy_constructor:substrait.ExtensionMultiRel) } -void ExtensionMultiRel::SharedCtor() { +inline void ExtensionMultiRel::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&common_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&detail_) - @@ -8037,12 +7795,13 @@ ::memset(reinterpret_cast(this) + static_cast( ExtensionMultiRel::~ExtensionMultiRel() { // @@protoc_insertion_point(destructor:substrait.ExtensionMultiRel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void ExtensionMultiRel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void ExtensionMultiRel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete common_; if (this != internal_default_instance()) delete detail_; } @@ -8059,16 +7818,16 @@ void ExtensionMultiRel::SetCachedSize(int size) const { void ExtensionMultiRel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.ExtensionMultiRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; inputs_.Clear(); - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; - if (GetArena() == nullptr && detail_ != nullptr) { + if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { delete detail_; } detail_ = nullptr; @@ -8078,19 +7837,20 @@ void ExtensionMultiRel::Clear() { const char* ExtensionMultiRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.RelCommon common = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated .substrait.Rel inputs = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -8098,46 +7858,48 @@ const char* ExtensionMultiRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESP CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .google.protobuf.Any detail = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* ExtensionMultiRel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* ExtensionMultiRel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionMultiRel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -8153,7 +7915,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* ExtensionMultiRel::_InternalSerialize( } // .google.protobuf.Any detail = 3; - if (this->has_detail()) { + if (this->_internal_has_detail()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -8172,7 +7934,7 @@ size_t ExtensionMultiRel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionMultiRel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8184,64 +7946,49 @@ size_t ExtensionMultiRel::ByteSizeLong() const { } // .substrait.RelCommon common = 1; - if (this->has_common()) { + if (this->_internal_has_common()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *common_); } // .google.protobuf.Any detail = 3; - if (this->has_detail()) { + if (this->_internal_has_detail()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *detail_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void ExtensionMultiRel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.ExtensionMultiRel) - GOOGLE_DCHECK_NE(&from, this); - const ExtensionMultiRel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.ExtensionMultiRel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.ExtensionMultiRel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExtensionMultiRel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + ExtensionMultiRel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExtensionMultiRel::GetClassData() const { return &_class_data_; } + +void ExtensionMultiRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void ExtensionMultiRel::MergeFrom(const ExtensionMultiRel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionMultiRel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; inputs_.MergeFrom(from.inputs_); - if (from.has_common()) { + if (from._internal_has_common()) { _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); } - if (from.has_detail()) { - _internal_mutable_detail()->PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); + if (from._internal_has_detail()) { + _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); } -} - -void ExtensionMultiRel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.ExtensionMultiRel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void ExtensionMultiRel::CopyFrom(const ExtensionMultiRel& from) { @@ -8257,7 +8004,7 @@ bool ExtensionMultiRel::IsInitialized() const { void ExtensionMultiRel::InternalSwap(ExtensionMultiRel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); inputs_.InternalSwap(&other->inputs_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(ExtensionMultiRel, detail_) @@ -8284,11 +8031,14 @@ const ::substrait::Rel& RelRoot::_Internal::input(const RelRoot* msg) { return *msg->input_; } -RelRoot::RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +RelRoot::RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), names_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.RelRoot) } RelRoot::RelRoot(const RelRoot& from) @@ -8303,18 +8053,19 @@ RelRoot::RelRoot(const RelRoot& from) // @@protoc_insertion_point(copy_constructor:substrait.RelRoot) } -void RelRoot::SharedCtor() { +inline void RelRoot::SharedCtor() { input_ = nullptr; } RelRoot::~RelRoot() { // @@protoc_insertion_point(destructor:substrait.RelRoot) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void RelRoot::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void RelRoot::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete input_; } @@ -8330,12 +8081,12 @@ void RelRoot::SetCachedSize(int size) const { void RelRoot::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.RelRoot) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; names_.Clear(); - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; @@ -8345,19 +8096,20 @@ void RelRoot::Clear() { const char* RelRoot::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Rel input = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // repeated string names = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr -= 1; do { ptr += 1; @@ -8367,39 +8119,40 @@ const char* RelRoot::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::in CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* RelRoot::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* RelRoot::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.RelRoot) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Rel input = 1; - if (this->has_input()) { + if (this->_internal_has_input()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -8428,7 +8181,7 @@ size_t RelRoot::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.RelRoot) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8441,54 +8194,39 @@ size_t RelRoot::ByteSizeLong() const { } // .substrait.Rel input = 1; - if (this->has_input()) { + if (this->_internal_has_input()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *input_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void RelRoot::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.RelRoot) - GOOGLE_DCHECK_NE(&from, this); - const RelRoot* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.RelRoot) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.RelRoot) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelRoot::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + RelRoot::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelRoot::GetClassData() const { return &_class_data_; } + +void RelRoot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void RelRoot::MergeFrom(const RelRoot& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelRoot) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; names_.MergeFrom(from.names_); - if (from.has_input()) { + if (from._internal_has_input()) { _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); } -} - -void RelRoot::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.RelRoot) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void RelRoot::CopyFrom(const RelRoot& from) { @@ -8504,7 +8242,7 @@ bool RelRoot::IsInitialized() const { void RelRoot::InternalSwap(RelRoot* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); names_.InternalSwap(&other->names_); swap(input_, other->input_); } @@ -8577,11 +8315,11 @@ Rel::_Internal::extension_leaf(const Rel* msg) { return *msg->rel_type_.extension_leaf_; } void Rel::set_allocated_read(::substrait::ReadRel* read) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (read) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(read); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel>::GetOwningArena(read); if (message_arena != submessage_arena) { read = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, read, submessage_arena); @@ -8592,11 +8330,11 @@ void Rel::set_allocated_read(::substrait::ReadRel* read) { // @@protoc_insertion_point(field_set_allocated:substrait.Rel.read) } void Rel::set_allocated_filter(::substrait::FilterRel* filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (filter) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(filter); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FilterRel>::GetOwningArena(filter); if (message_arena != submessage_arena) { filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, filter, submessage_arena); @@ -8607,11 +8345,11 @@ void Rel::set_allocated_filter(::substrait::FilterRel* filter) { // @@protoc_insertion_point(field_set_allocated:substrait.Rel.filter) } void Rel::set_allocated_fetch(::substrait::FetchRel* fetch) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (fetch) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fetch); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FetchRel>::GetOwningArena(fetch); if (message_arena != submessage_arena) { fetch = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fetch, submessage_arena); @@ -8622,11 +8360,11 @@ void Rel::set_allocated_fetch(::substrait::FetchRel* fetch) { // @@protoc_insertion_point(field_set_allocated:substrait.Rel.fetch) } void Rel::set_allocated_aggregate(::substrait::AggregateRel* aggregate) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (aggregate) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(aggregate); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::AggregateRel>::GetOwningArena(aggregate); if (message_arena != submessage_arena) { aggregate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, aggregate, submessage_arena); @@ -8637,11 +8375,11 @@ void Rel::set_allocated_aggregate(::substrait::AggregateRel* aggregate) { // @@protoc_insertion_point(field_set_allocated:substrait.Rel.aggregate) } void Rel::set_allocated_sort(::substrait::SortRel* sort) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (sort) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(sort); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::SortRel>::GetOwningArena(sort); if (message_arena != submessage_arena) { sort = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, sort, submessage_arena); @@ -8652,11 +8390,11 @@ void Rel::set_allocated_sort(::substrait::SortRel* sort) { // @@protoc_insertion_point(field_set_allocated:substrait.Rel.sort) } void Rel::set_allocated_join(::substrait::JoinRel* join) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (join) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(join); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::JoinRel>::GetOwningArena(join); if (message_arena != submessage_arena) { join = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, join, submessage_arena); @@ -8667,11 +8405,11 @@ void Rel::set_allocated_join(::substrait::JoinRel* join) { // @@protoc_insertion_point(field_set_allocated:substrait.Rel.join) } void Rel::set_allocated_project(::substrait::ProjectRel* project) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (project) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(project); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ProjectRel>::GetOwningArena(project); if (message_arena != submessage_arena) { project = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, project, submessage_arena); @@ -8682,11 +8420,11 @@ void Rel::set_allocated_project(::substrait::ProjectRel* project) { // @@protoc_insertion_point(field_set_allocated:substrait.Rel.project) } void Rel::set_allocated_set(::substrait::SetRel* set) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (set) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(set); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::SetRel>::GetOwningArena(set); if (message_arena != submessage_arena) { set = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, set, submessage_arena); @@ -8697,11 +8435,11 @@ void Rel::set_allocated_set(::substrait::SetRel* set) { // @@protoc_insertion_point(field_set_allocated:substrait.Rel.set) } void Rel::set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (extension_single) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_single); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionSingleRel>::GetOwningArena(extension_single); if (message_arena != submessage_arena) { extension_single = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, extension_single, submessage_arena); @@ -8712,11 +8450,11 @@ void Rel::set_allocated_extension_single(::substrait::ExtensionSingleRel* extens // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_single) } void Rel::set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (extension_multi) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_multi); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionMultiRel>::GetOwningArena(extension_multi); if (message_arena != submessage_arena) { extension_multi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, extension_multi, submessage_arena); @@ -8727,11 +8465,11 @@ void Rel::set_allocated_extension_multi(::substrait::ExtensionMultiRel* extensio // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_multi) } void Rel::set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_rel_type(); if (extension_leaf) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(extension_leaf); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionLeafRel>::GetOwningArena(extension_leaf); if (message_arena != submessage_arena) { extension_leaf = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, extension_leaf, submessage_arena); @@ -8741,10 +8479,13 @@ void Rel::set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_ } // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_leaf) } -Rel::Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Rel::Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Rel) } Rel::Rel(const Rel& from) @@ -8803,18 +8544,19 @@ Rel::Rel(const Rel& from) // @@protoc_insertion_point(copy_constructor:substrait.Rel) } -void Rel::SharedCtor() { +inline void Rel::SharedCtor() { clear_has_rel_type(); } Rel::~Rel() { // @@protoc_insertion_point(destructor:substrait.Rel) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Rel::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Rel::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_rel_type()) { clear_rel_type(); } @@ -8834,67 +8576,67 @@ void Rel::clear_rel_type() { // @@protoc_insertion_point(one_of_clear_start:substrait.Rel) switch (rel_type_case()) { case kRead: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.read_; } break; } case kFilter: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.filter_; } break; } case kFetch: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.fetch_; } break; } case kAggregate: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.aggregate_; } break; } case kSort: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.sort_; } break; } case kJoin: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.join_; } break; } case kProject: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.project_; } break; } case kSet: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.set_; } break; } case kExtensionSingle: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.extension_single_; } break; } case kExtensionMulti: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.extension_multi_; } break; } case kExtensionLeaf: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.extension_leaf_; } break; @@ -8909,7 +8651,7 @@ void Rel::clear_rel_type() { void Rel::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Rel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -8920,113 +8662,124 @@ void Rel::Clear() { const char* Rel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.ReadRel read = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_read(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FilterRel filter = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.FetchRel fetch = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_fetch(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.AggregateRel aggregate = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_aggregate(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.SortRel sort = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_sort(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.JoinRel join = 6; case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_join(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ProjectRel project = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_project(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.SetRel set = 8; case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { ptr = ctx->ParseMessage(_internal_mutable_set(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ExtensionSingleRel extension_single = 9; case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { ptr = ctx->ParseMessage(_internal_mutable_extension_single(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ExtensionMultiRel extension_multi = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_extension_multi(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.ExtensionLeafRel extension_leaf = 11; case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_extension_leaf(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Rel::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Rel::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Rel) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.ReadRel read = 1; @@ -9129,7 +8882,7 @@ size_t Rel::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Rel) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -9215,35 +8968,26 @@ size_t Rel::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Rel::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Rel) - GOOGLE_DCHECK_NE(&from, this); - const Rel* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Rel) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Rel) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Rel::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Rel::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Rel::GetClassData() const { return &_class_data_; } + +void Rel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Rel::MergeFrom(const Rel& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Rel) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.rel_type_case()) { @@ -9295,13 +9039,7 @@ void Rel::MergeFrom(const Rel& from) { break; } } -} - -void Rel::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Rel) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Rel::CopyFrom(const Rel& from) { @@ -9317,7 +9055,7 @@ bool Rel::IsInitialized() const { void Rel::InternalSwap(Rel* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(rel_type_, other->rel_type_); swap(_oneof_case_[0], other->_oneof_case_[0]); } diff --git a/cpp/src/generated/substrait/relations.pb.h b/cpp/src/generated/substrait/relations.pb.h index 8128e2999dc..11f499cb1ab 100644 --- a/cpp/src/generated/substrait/relations.pb.h +++ b/cpp/src/generated/substrait/relations.pb.h @@ -8,12 +8,12 @@ #include #include -#if PROTOBUF_VERSION < 3016000 +#if PROTOBUF_VERSION < 3019000 #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 3016000 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019003 < 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. @@ -23,6 +23,7 @@ #include #include #include +#include #include #include #include @@ -55,7 +56,7 @@ struct TableStruct_substrait_2frelations_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; + static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2frelations_2eproto; namespace substrait { @@ -171,8 +172,8 @@ namespace substrait { enum ReadRel_LocalFiles_FileOrFiles_FileFormat : int { ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED = 0, ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_PARQUET = 1, - ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(int value); constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MIN = ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED; @@ -201,8 +202,8 @@ enum JoinRel_JoinType : int { JoinRel_JoinType_JOIN_TYPE_RIGHT = 4, JoinRel_JoinType_JOIN_TYPE_SEMI = 5, JoinRel_JoinType_JOIN_TYPE_ANTI = 6, - JoinRel_JoinType_JoinRel_JoinType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - JoinRel_JoinType_JoinRel_JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + JoinRel_JoinType_JoinRel_JoinType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + JoinRel_JoinType_JoinRel_JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool JoinRel_JoinType_IsValid(int value); constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MIN = JoinRel_JoinType_JOIN_TYPE_UNSPECIFIED; @@ -231,8 +232,8 @@ enum SetRel_SetOp : int { SetRel_SetOp_SET_OP_INTERSECTION_MULTISET = 4, SetRel_SetOp_SET_OP_UNION_DISTINCT = 5, SetRel_SetOp_SET_OP_UNION_ALL = 6, - SetRel_SetOp_SetRel_SetOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - SetRel_SetOp_SetRel_SetOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + SetRel_SetOp_SetRel_SetOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + SetRel_SetOp_SetRel_SetOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool SetRel_SetOp_IsValid(int value); constexpr SetRel_SetOp SetRel_SetOp_SetOp_MIN = SetRel_SetOp_SET_OP_UNSPECIFIED; @@ -255,11 +256,10 @@ inline bool SetRel_SetOp_Parse( } // =================================================================== -class RelCommon_Direct PROTOBUF_FINAL : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Direct) */ { +class RelCommon_Direct final : + public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Direct) */ { public: inline RelCommon_Direct() : RelCommon_Direct(nullptr) {} - ~RelCommon_Direct() override; explicit constexpr RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); RelCommon_Direct(const RelCommon_Direct& from); @@ -273,8 +273,13 @@ class RelCommon_Direct PROTOBUF_FINAL : return *this; } inline RelCommon_Direct& operator=(RelCommon_Direct&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -305,7 +310,12 @@ class RelCommon_Direct PROTOBUF_FINAL : } inline void Swap(RelCommon_Direct* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -313,48 +323,39 @@ class RelCommon_Direct PROTOBUF_FINAL : } void UnsafeArenaSwap(RelCommon_Direct* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline RelCommon_Direct* New() const final { - return CreateMaybeMessage(nullptr); - } - - RelCommon_Direct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + RelCommon_Direct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void CopyFrom(const RelCommon_Direct& from); - void MergeFrom(const RelCommon_Direct& from); - 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; - int GetCachedSize() const final { return _cached_size_.Get(); } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; + inline void CopyFrom(const RelCommon_Direct& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); + } + using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; + void MergeFrom(const RelCommon_Direct& from) { + ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); + } + public: private: - inline void SharedCtor(); - inline void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(RelCommon_Direct* other); friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.RelCommon.Direct"; } protected: - explicit RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -373,7 +374,7 @@ class RelCommon_Direct PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class RelCommon_Emit PROTOBUF_FINAL : +class RelCommon_Emit final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Emit) */ { public: inline RelCommon_Emit() : RelCommon_Emit(nullptr) {} @@ -391,8 +392,13 @@ class RelCommon_Emit PROTOBUF_FINAL : return *this; } inline RelCommon_Emit& operator=(RelCommon_Emit&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -423,7 +429,12 @@ class RelCommon_Emit PROTOBUF_FINAL : } inline void Swap(RelCommon_Emit* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -431,48 +442,53 @@ class RelCommon_Emit PROTOBUF_FINAL : } void UnsafeArenaSwap(RelCommon_Emit* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline RelCommon_Emit* New() const final { - return CreateMaybeMessage(nullptr); - } - - RelCommon_Emit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + RelCommon_Emit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RelCommon_Emit& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const RelCommon_Emit& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RelCommon_Emit* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.RelCommon.Emit"; } protected: - explicit RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -489,19 +505,19 @@ class RelCommon_Emit PROTOBUF_FINAL : public: void clear_output_mapping(); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_output_mapping(int index) const; - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + int32_t _internal_output_mapping(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& _internal_output_mapping() const; - void _internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value); - ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + void _internal_add_output_mapping(int32_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* _internal_mutable_output_mapping(); public: - ::PROTOBUF_NAMESPACE_ID::int32 output_mapping(int index) const; - void set_output_mapping(int index, ::PROTOBUF_NAMESPACE_ID::int32 value); - void add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value); - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& + int32_t output_mapping(int index) const; + void set_output_mapping(int index, int32_t value); + void add_output_mapping(int32_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& output_mapping() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* mutable_output_mapping(); // @@protoc_insertion_point(class_scope:substrait.RelCommon.Emit) @@ -511,14 +527,14 @@ class RelCommon_Emit PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > output_mapping_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > output_mapping_; mutable std::atomic _output_mapping_cached_byte_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- -class RelCommon_Hint_Stats PROTOBUF_FINAL : +class RelCommon_Hint_Stats final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint.Stats) */ { public: inline RelCommon_Hint_Stats() : RelCommon_Hint_Stats(nullptr) {} @@ -536,8 +552,13 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : return *this; } inline RelCommon_Hint_Stats& operator=(RelCommon_Hint_Stats&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -568,7 +589,12 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : } inline void Swap(RelCommon_Hint_Stats* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -576,48 +602,53 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : } void UnsafeArenaSwap(RelCommon_Hint_Stats* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline RelCommon_Hint_Stats* New() const final { - return CreateMaybeMessage(nullptr); - } - - RelCommon_Hint_Stats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + RelCommon_Hint_Stats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RelCommon_Hint_Stats& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const RelCommon_Hint_Stats& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RelCommon_Hint_Stats* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.RelCommon.Hint.Stats"; } protected: - explicit RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -636,7 +667,7 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -680,7 +711,7 @@ class RelCommon_Hint_Stats PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class RelCommon_Hint_RuntimeConstraint PROTOBUF_FINAL : +class RelCommon_Hint_RuntimeConstraint final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint.RuntimeConstraint) */ { public: inline RelCommon_Hint_RuntimeConstraint() : RelCommon_Hint_RuntimeConstraint(nullptr) {} @@ -698,8 +729,13 @@ class RelCommon_Hint_RuntimeConstraint PROTOBUF_FINAL : return *this; } inline RelCommon_Hint_RuntimeConstraint& operator=(RelCommon_Hint_RuntimeConstraint&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -730,7 +766,12 @@ class RelCommon_Hint_RuntimeConstraint PROTOBUF_FINAL : } inline void Swap(RelCommon_Hint_RuntimeConstraint* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -738,48 +779,53 @@ class RelCommon_Hint_RuntimeConstraint PROTOBUF_FINAL : } void UnsafeArenaSwap(RelCommon_Hint_RuntimeConstraint* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline RelCommon_Hint_RuntimeConstraint* New() const final { - return CreateMaybeMessage(nullptr); - } - - RelCommon_Hint_RuntimeConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + RelCommon_Hint_RuntimeConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RelCommon_Hint_RuntimeConstraint& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const RelCommon_Hint_RuntimeConstraint& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RelCommon_Hint_RuntimeConstraint* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.RelCommon.Hint.RuntimeConstraint"; } protected: - explicit RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -796,7 +842,7 @@ class RelCommon_Hint_RuntimeConstraint PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -820,7 +866,7 @@ class RelCommon_Hint_RuntimeConstraint PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class RelCommon_Hint PROTOBUF_FINAL : +class RelCommon_Hint final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint) */ { public: inline RelCommon_Hint() : RelCommon_Hint(nullptr) {} @@ -838,8 +884,13 @@ class RelCommon_Hint PROTOBUF_FINAL : return *this; } inline RelCommon_Hint& operator=(RelCommon_Hint&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -870,7 +921,12 @@ class RelCommon_Hint PROTOBUF_FINAL : } inline void Swap(RelCommon_Hint* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -878,48 +934,53 @@ class RelCommon_Hint PROTOBUF_FINAL : } void UnsafeArenaSwap(RelCommon_Hint* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline RelCommon_Hint* New() const final { - return CreateMaybeMessage(nullptr); - } - - RelCommon_Hint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + RelCommon_Hint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RelCommon_Hint& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const RelCommon_Hint& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RelCommon_Hint* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.RelCommon.Hint"; } protected: - explicit RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -941,7 +1002,7 @@ class RelCommon_Hint PROTOBUF_FINAL : public: void clear_stats(); const ::substrait::RelCommon_Hint_Stats& stats() const; - ::substrait::RelCommon_Hint_Stats* release_stats(); + PROTOBUF_NODISCARD ::substrait::RelCommon_Hint_Stats* release_stats(); ::substrait::RelCommon_Hint_Stats* mutable_stats(); void set_allocated_stats(::substrait::RelCommon_Hint_Stats* stats); private: @@ -959,7 +1020,7 @@ class RelCommon_Hint PROTOBUF_FINAL : public: void clear_constraint(); const ::substrait::RelCommon_Hint_RuntimeConstraint& constraint() const; - ::substrait::RelCommon_Hint_RuntimeConstraint* release_constraint(); + PROTOBUF_NODISCARD ::substrait::RelCommon_Hint_RuntimeConstraint* release_constraint(); ::substrait::RelCommon_Hint_RuntimeConstraint* mutable_constraint(); void set_allocated_constraint(::substrait::RelCommon_Hint_RuntimeConstraint* constraint); private: @@ -977,7 +1038,7 @@ class RelCommon_Hint PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -1003,7 +1064,7 @@ class RelCommon_Hint PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class RelCommon PROTOBUF_FINAL : +class RelCommon final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon) */ { public: inline RelCommon() : RelCommon(nullptr) {} @@ -1021,8 +1082,13 @@ class RelCommon PROTOBUF_FINAL : return *this; } inline RelCommon& operator=(RelCommon&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1059,7 +1125,12 @@ class RelCommon PROTOBUF_FINAL : } inline void Swap(RelCommon* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1067,48 +1138,53 @@ class RelCommon PROTOBUF_FINAL : } void UnsafeArenaSwap(RelCommon* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline RelCommon* New() const final { - return CreateMaybeMessage(nullptr); - } - - RelCommon* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + RelCommon* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RelCommon& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const RelCommon& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RelCommon* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.RelCommon"; } protected: - explicit RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1132,7 +1208,7 @@ class RelCommon PROTOBUF_FINAL : public: void clear_hint(); const ::substrait::RelCommon_Hint& hint() const; - ::substrait::RelCommon_Hint* release_hint(); + PROTOBUF_NODISCARD ::substrait::RelCommon_Hint* release_hint(); ::substrait::RelCommon_Hint* mutable_hint(); void set_allocated_hint(::substrait::RelCommon_Hint* hint); private: @@ -1150,7 +1226,7 @@ class RelCommon PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -1168,7 +1244,7 @@ class RelCommon PROTOBUF_FINAL : public: void clear_direct(); const ::substrait::RelCommon_Direct& direct() const; - ::substrait::RelCommon_Direct* release_direct(); + PROTOBUF_NODISCARD ::substrait::RelCommon_Direct* release_direct(); ::substrait::RelCommon_Direct* mutable_direct(); void set_allocated_direct(::substrait::RelCommon_Direct* direct); private: @@ -1186,7 +1262,7 @@ class RelCommon PROTOBUF_FINAL : public: void clear_emit(); const ::substrait::RelCommon_Emit& emit() const; - ::substrait::RelCommon_Emit* release_emit(); + PROTOBUF_NODISCARD ::substrait::RelCommon_Emit* release_emit(); ::substrait::RelCommon_Emit* mutable_emit(); void set_allocated_emit(::substrait::RelCommon_Emit* emit); private: @@ -1220,13 +1296,13 @@ class RelCommon PROTOBUF_FINAL : ::substrait::RelCommon_Emit* emit_; } emit_kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- -class ReadRel_NamedTable PROTOBUF_FINAL : +class ReadRel_NamedTable final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.NamedTable) */ { public: inline ReadRel_NamedTable() : ReadRel_NamedTable(nullptr) {} @@ -1244,8 +1320,13 @@ class ReadRel_NamedTable PROTOBUF_FINAL : return *this; } inline ReadRel_NamedTable& operator=(ReadRel_NamedTable&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1276,7 +1357,12 @@ class ReadRel_NamedTable PROTOBUF_FINAL : } inline void Swap(ReadRel_NamedTable* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1284,48 +1370,53 @@ class ReadRel_NamedTable PROTOBUF_FINAL : } void UnsafeArenaSwap(ReadRel_NamedTable* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ReadRel_NamedTable* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReadRel_NamedTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ReadRel_NamedTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ReadRel_NamedTable& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ReadRel_NamedTable& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ReadRel_NamedTable* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ReadRel.NamedTable"; } protected: - explicit ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1367,7 +1458,7 @@ class ReadRel_NamedTable PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -1392,7 +1483,7 @@ class ReadRel_NamedTable PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class ReadRel_VirtualTable PROTOBUF_FINAL : +class ReadRel_VirtualTable final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.VirtualTable) */ { public: inline ReadRel_VirtualTable() : ReadRel_VirtualTable(nullptr) {} @@ -1410,8 +1501,13 @@ class ReadRel_VirtualTable PROTOBUF_FINAL : return *this; } inline ReadRel_VirtualTable& operator=(ReadRel_VirtualTable&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1442,7 +1538,12 @@ class ReadRel_VirtualTable PROTOBUF_FINAL : } inline void Swap(ReadRel_VirtualTable* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1450,48 +1551,53 @@ class ReadRel_VirtualTable PROTOBUF_FINAL : } void UnsafeArenaSwap(ReadRel_VirtualTable* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ReadRel_VirtualTable* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReadRel_VirtualTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ReadRel_VirtualTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ReadRel_VirtualTable& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ReadRel_VirtualTable& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ReadRel_VirtualTable* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ReadRel.VirtualTable"; } protected: - explicit ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1532,7 +1638,7 @@ class ReadRel_VirtualTable PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class ReadRel_ExtensionTable PROTOBUF_FINAL : +class ReadRel_ExtensionTable final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.ExtensionTable) */ { public: inline ReadRel_ExtensionTable() : ReadRel_ExtensionTable(nullptr) {} @@ -1550,8 +1656,13 @@ class ReadRel_ExtensionTable PROTOBUF_FINAL : return *this; } inline ReadRel_ExtensionTable& operator=(ReadRel_ExtensionTable&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1582,7 +1693,12 @@ class ReadRel_ExtensionTable PROTOBUF_FINAL : } inline void Swap(ReadRel_ExtensionTable* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1590,48 +1706,53 @@ class ReadRel_ExtensionTable PROTOBUF_FINAL : } void UnsafeArenaSwap(ReadRel_ExtensionTable* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ReadRel_ExtensionTable* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReadRel_ExtensionTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ReadRel_ExtensionTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ReadRel_ExtensionTable& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ReadRel_ExtensionTable& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ReadRel_ExtensionTable* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ReadRel.ExtensionTable"; } protected: - explicit ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1647,17 +1768,17 @@ class ReadRel_ExtensionTable PROTOBUF_FINAL : bool _internal_has_detail() const; public: void clear_detail(); - const PROTOBUF_NAMESPACE_ID::Any& detail() const; - PROTOBUF_NAMESPACE_ID::Any* release_detail(); - PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); - void set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail); + const ::PROTOBUF_NAMESPACE_ID::Any& detail() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail(); + ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); + void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail); private: - const PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; - PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); + const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; + ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); public: void unsafe_arena_set_allocated_detail( - PROTOBUF_NAMESPACE_ID::Any* detail); - PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); + ::PROTOBUF_NAMESPACE_ID::Any* detail); + ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); // @@protoc_insertion_point(class_scope:substrait.ReadRel.ExtensionTable) private: @@ -1666,13 +1787,13 @@ class ReadRel_ExtensionTable PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - PROTOBUF_NAMESPACE_ID::Any* detail_; + ::PROTOBUF_NAMESPACE_ID::Any* detail_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- -class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : +class ReadRel_LocalFiles_FileOrFiles final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.LocalFiles.FileOrFiles) */ { public: inline ReadRel_LocalFiles_FileOrFiles() : ReadRel_LocalFiles_FileOrFiles(nullptr) {} @@ -1690,8 +1811,13 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : return *this; } inline ReadRel_LocalFiles_FileOrFiles& operator=(ReadRel_LocalFiles_FileOrFiles&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1730,7 +1856,12 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : } inline void Swap(ReadRel_LocalFiles_FileOrFiles* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1738,48 +1869,53 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : } void UnsafeArenaSwap(ReadRel_LocalFiles_FileOrFiles* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ReadRel_LocalFiles_FileOrFiles* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReadRel_LocalFiles_FileOrFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ReadRel_LocalFiles_FileOrFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ReadRel_LocalFiles_FileOrFiles& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ReadRel_LocalFiles_FileOrFiles& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ReadRel_LocalFiles_FileOrFiles* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ReadRel.LocalFiles.FileOrFiles"; } protected: - explicit ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1837,29 +1973,29 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : // uint64 partition_index = 6; void clear_partition_index(); - ::PROTOBUF_NAMESPACE_ID::uint64 partition_index() const; - void set_partition_index(::PROTOBUF_NAMESPACE_ID::uint64 value); + uint64_t partition_index() const; + void set_partition_index(uint64_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_partition_index() const; - void _internal_set_partition_index(::PROTOBUF_NAMESPACE_ID::uint64 value); + uint64_t _internal_partition_index() const; + void _internal_set_partition_index(uint64_t value); public: // uint64 start = 7; void clear_start(); - ::PROTOBUF_NAMESPACE_ID::uint64 start() const; - void set_start(::PROTOBUF_NAMESPACE_ID::uint64 value); + uint64_t start() const; + void set_start(uint64_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_start() const; - void _internal_set_start(::PROTOBUF_NAMESPACE_ID::uint64 value); + uint64_t _internal_start() const; + void _internal_set_start(uint64_t value); public: // uint64 length = 8; void clear_length(); - ::PROTOBUF_NAMESPACE_ID::uint64 length() const; - void set_length(::PROTOBUF_NAMESPACE_ID::uint64 value); + uint64_t length() const; + void set_length(uint64_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint64 _internal_length() const; - void _internal_set_length(::PROTOBUF_NAMESPACE_ID::uint64 value); + uint64_t _internal_length() const; + void _internal_set_length(uint64_t value); public: // string uri_path = 1; @@ -1872,11 +2008,11 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : template void set_uri_path(ArgT0&& arg0, ArgT... args); std::string* mutable_uri_path(); - std::string* release_uri_path(); + PROTOBUF_NODISCARD std::string* release_uri_path(); void set_allocated_uri_path(std::string* uri_path); private: const std::string& _internal_uri_path() const; - void _internal_set_uri_path(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_path(const std::string& value); std::string* _internal_mutable_uri_path(); public: @@ -1890,11 +2026,11 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : template void set_uri_path_glob(ArgT0&& arg0, ArgT... args); std::string* mutable_uri_path_glob(); - std::string* release_uri_path_glob(); + PROTOBUF_NODISCARD std::string* release_uri_path_glob(); void set_allocated_uri_path_glob(std::string* uri_path_glob); private: const std::string& _internal_uri_path_glob() const; - void _internal_set_uri_path_glob(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_path_glob(const std::string& value); std::string* _internal_mutable_uri_path_glob(); public: @@ -1908,11 +2044,11 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : template void set_uri_file(ArgT0&& arg0, ArgT... args); std::string* mutable_uri_file(); - std::string* release_uri_file(); + PROTOBUF_NODISCARD std::string* release_uri_file(); void set_allocated_uri_file(std::string* uri_file); private: const std::string& _internal_uri_file() const; - void _internal_set_uri_file(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_file(const std::string& value); std::string* _internal_mutable_uri_file(); public: @@ -1926,11 +2062,11 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : template void set_uri_folder(ArgT0&& arg0, ArgT... args); std::string* mutable_uri_folder(); - std::string* release_uri_folder(); + PROTOBUF_NODISCARD std::string* release_uri_folder(); void set_allocated_uri_folder(std::string* uri_folder); private: const std::string& _internal_uri_folder() const; - void _internal_set_uri_folder(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_folder(const std::string& value); std::string* _internal_mutable_uri_folder(); public: @@ -1951,9 +2087,9 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; int format_; - ::PROTOBUF_NAMESPACE_ID::uint64 partition_index_; - ::PROTOBUF_NAMESPACE_ID::uint64 start_; - ::PROTOBUF_NAMESPACE_ID::uint64 length_; + uint64_t partition_index_; + uint64_t start_; + uint64_t length_; union PathTypeUnion { constexpr PathTypeUnion() : _constinit_{} {} ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; @@ -1963,13 +2099,13 @@ class ReadRel_LocalFiles_FileOrFiles PROTOBUF_FINAL : ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_folder_; } path_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- -class ReadRel_LocalFiles PROTOBUF_FINAL : +class ReadRel_LocalFiles final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.LocalFiles) */ { public: inline ReadRel_LocalFiles() : ReadRel_LocalFiles(nullptr) {} @@ -1987,8 +2123,13 @@ class ReadRel_LocalFiles PROTOBUF_FINAL : return *this; } inline ReadRel_LocalFiles& operator=(ReadRel_LocalFiles&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2019,7 +2160,12 @@ class ReadRel_LocalFiles PROTOBUF_FINAL : } inline void Swap(ReadRel_LocalFiles* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2027,48 +2173,53 @@ class ReadRel_LocalFiles PROTOBUF_FINAL : } void UnsafeArenaSwap(ReadRel_LocalFiles* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ReadRel_LocalFiles* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReadRel_LocalFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ReadRel_LocalFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ReadRel_LocalFiles& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ReadRel_LocalFiles& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ReadRel_LocalFiles* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ReadRel.LocalFiles"; } protected: - explicit ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2106,7 +2257,7 @@ class ReadRel_LocalFiles PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -2131,7 +2282,7 @@ class ReadRel_LocalFiles PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class ReadRel PROTOBUF_FINAL : +class ReadRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel) */ { public: inline ReadRel() : ReadRel(nullptr) {} @@ -2149,8 +2300,13 @@ class ReadRel PROTOBUF_FINAL : return *this; } inline ReadRel& operator=(ReadRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2189,7 +2345,12 @@ class ReadRel PROTOBUF_FINAL : } inline void Swap(ReadRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2197,48 +2358,53 @@ class ReadRel PROTOBUF_FINAL : } void UnsafeArenaSwap(ReadRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ReadRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - ReadRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ReadRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ReadRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ReadRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ReadRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ReadRel"; } protected: - explicit ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2268,7 +2434,7 @@ class ReadRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -2286,7 +2452,7 @@ class ReadRel PROTOBUF_FINAL : public: void clear_base_schema(); const ::substrait::NamedStruct& base_schema() const; - ::substrait::NamedStruct* release_base_schema(); + PROTOBUF_NODISCARD ::substrait::NamedStruct* release_base_schema(); ::substrait::NamedStruct* mutable_base_schema(); void set_allocated_base_schema(::substrait::NamedStruct* base_schema); private: @@ -2304,7 +2470,7 @@ class ReadRel PROTOBUF_FINAL : public: void clear_filter(); const ::substrait::Expression& filter() const; - ::substrait::Expression* release_filter(); + PROTOBUF_NODISCARD ::substrait::Expression* release_filter(); ::substrait::Expression* mutable_filter(); void set_allocated_filter(::substrait::Expression* filter); private: @@ -2322,7 +2488,7 @@ class ReadRel PROTOBUF_FINAL : public: void clear_projection(); const ::substrait::Expression_MaskExpression& projection() const; - ::substrait::Expression_MaskExpression* release_projection(); + PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression* release_projection(); ::substrait::Expression_MaskExpression* mutable_projection(); void set_allocated_projection(::substrait::Expression_MaskExpression* projection); private: @@ -2340,7 +2506,7 @@ class ReadRel PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -2358,7 +2524,7 @@ class ReadRel PROTOBUF_FINAL : public: void clear_virtual_table(); const ::substrait::ReadRel_VirtualTable& virtual_table() const; - ::substrait::ReadRel_VirtualTable* release_virtual_table(); + PROTOBUF_NODISCARD ::substrait::ReadRel_VirtualTable* release_virtual_table(); ::substrait::ReadRel_VirtualTable* mutable_virtual_table(); void set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table); private: @@ -2376,7 +2542,7 @@ class ReadRel PROTOBUF_FINAL : public: void clear_local_files(); const ::substrait::ReadRel_LocalFiles& local_files() const; - ::substrait::ReadRel_LocalFiles* release_local_files(); + PROTOBUF_NODISCARD ::substrait::ReadRel_LocalFiles* release_local_files(); ::substrait::ReadRel_LocalFiles* mutable_local_files(); void set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files); private: @@ -2394,7 +2560,7 @@ class ReadRel PROTOBUF_FINAL : public: void clear_named_table(); const ::substrait::ReadRel_NamedTable& named_table() const; - ::substrait::ReadRel_NamedTable* release_named_table(); + PROTOBUF_NODISCARD ::substrait::ReadRel_NamedTable* release_named_table(); ::substrait::ReadRel_NamedTable* mutable_named_table(); void set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table); private: @@ -2412,7 +2578,7 @@ class ReadRel PROTOBUF_FINAL : public: void clear_extension_table(); const ::substrait::ReadRel_ExtensionTable& extension_table() const; - ::substrait::ReadRel_ExtensionTable* release_extension_table(); + PROTOBUF_NODISCARD ::substrait::ReadRel_ExtensionTable* release_extension_table(); ::substrait::ReadRel_ExtensionTable* mutable_extension_table(); void set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table); private: @@ -2453,13 +2619,13 @@ class ReadRel PROTOBUF_FINAL : ::substrait::ReadRel_ExtensionTable* extension_table_; } read_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- -class ProjectRel PROTOBUF_FINAL : +class ProjectRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ProjectRel) */ { public: inline ProjectRel() : ProjectRel(nullptr) {} @@ -2477,8 +2643,13 @@ class ProjectRel PROTOBUF_FINAL : return *this; } inline ProjectRel& operator=(ProjectRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2509,7 +2680,12 @@ class ProjectRel PROTOBUF_FINAL : } inline void Swap(ProjectRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2517,48 +2693,53 @@ class ProjectRel PROTOBUF_FINAL : } void UnsafeArenaSwap(ProjectRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ProjectRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - ProjectRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ProjectRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ProjectRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ProjectRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ProjectRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ProjectRel"; } protected: - explicit ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2596,7 +2777,7 @@ class ProjectRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -2614,7 +2795,7 @@ class ProjectRel PROTOBUF_FINAL : public: void clear_input(); const ::substrait::Rel& input() const; - ::substrait::Rel* release_input(); + PROTOBUF_NODISCARD ::substrait::Rel* release_input(); ::substrait::Rel* mutable_input(); void set_allocated_input(::substrait::Rel* input); private: @@ -2632,7 +2813,7 @@ class ProjectRel PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -2659,7 +2840,7 @@ class ProjectRel PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class JoinRel PROTOBUF_FINAL : +class JoinRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.JoinRel) */ { public: inline JoinRel() : JoinRel(nullptr) {} @@ -2677,8 +2858,13 @@ class JoinRel PROTOBUF_FINAL : return *this; } inline JoinRel& operator=(JoinRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2709,7 +2895,12 @@ class JoinRel PROTOBUF_FINAL : } inline void Swap(JoinRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2717,48 +2908,53 @@ class JoinRel PROTOBUF_FINAL : } void UnsafeArenaSwap(JoinRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline JoinRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - JoinRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + JoinRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const JoinRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const JoinRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(JoinRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.JoinRel"; } protected: - explicit JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2821,7 +3017,7 @@ class JoinRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -2839,7 +3035,7 @@ class JoinRel PROTOBUF_FINAL : public: void clear_left(); const ::substrait::Rel& left() const; - ::substrait::Rel* release_left(); + PROTOBUF_NODISCARD ::substrait::Rel* release_left(); ::substrait::Rel* mutable_left(); void set_allocated_left(::substrait::Rel* left); private: @@ -2857,7 +3053,7 @@ class JoinRel PROTOBUF_FINAL : public: void clear_right(); const ::substrait::Rel& right() const; - ::substrait::Rel* release_right(); + PROTOBUF_NODISCARD ::substrait::Rel* release_right(); ::substrait::Rel* mutable_right(); void set_allocated_right(::substrait::Rel* right); private: @@ -2875,7 +3071,7 @@ class JoinRel PROTOBUF_FINAL : public: void clear_expression(); const ::substrait::Expression& expression() const; - ::substrait::Expression* release_expression(); + PROTOBUF_NODISCARD ::substrait::Expression* release_expression(); ::substrait::Expression* mutable_expression(); void set_allocated_expression(::substrait::Expression* expression); private: @@ -2893,7 +3089,7 @@ class JoinRel PROTOBUF_FINAL : public: void clear_post_join_filter(); const ::substrait::Expression& post_join_filter() const; - ::substrait::Expression* release_post_join_filter(); + PROTOBUF_NODISCARD ::substrait::Expression* release_post_join_filter(); ::substrait::Expression* mutable_post_join_filter(); void set_allocated_post_join_filter(::substrait::Expression* post_join_filter); private: @@ -2911,7 +3107,7 @@ class JoinRel PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -2950,7 +3146,7 @@ class JoinRel PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class FetchRel PROTOBUF_FINAL : +class FetchRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FetchRel) */ { public: inline FetchRel() : FetchRel(nullptr) {} @@ -2968,8 +3164,13 @@ class FetchRel PROTOBUF_FINAL : return *this; } inline FetchRel& operator=(FetchRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3000,7 +3201,12 @@ class FetchRel PROTOBUF_FINAL : } inline void Swap(FetchRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3008,48 +3214,53 @@ class FetchRel PROTOBUF_FINAL : } void UnsafeArenaSwap(FetchRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FetchRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - FetchRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FetchRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FetchRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FetchRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FetchRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FetchRel"; } protected: - explicit FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3070,7 +3281,7 @@ class FetchRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -3088,7 +3299,7 @@ class FetchRel PROTOBUF_FINAL : public: void clear_input(); const ::substrait::Rel& input() const; - ::substrait::Rel* release_input(); + PROTOBUF_NODISCARD ::substrait::Rel* release_input(); ::substrait::Rel* mutable_input(); void set_allocated_input(::substrait::Rel* input); private: @@ -3106,7 +3317,7 @@ class FetchRel PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -3119,20 +3330,20 @@ class FetchRel PROTOBUF_FINAL : // int64 offset = 3; void clear_offset(); - ::PROTOBUF_NAMESPACE_ID::int64 offset() const; - void set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t offset() const; + void set_offset(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_offset() const; - void _internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_offset() const; + void _internal_set_offset(int64_t value); public: // int64 count = 4; void clear_count(); - ::PROTOBUF_NAMESPACE_ID::int64 count() const; - void set_count(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t count() const; + void set_count(int64_t value); private: - ::PROTOBUF_NAMESPACE_ID::int64 _internal_count() const; - void _internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value); + int64_t _internal_count() const; + void _internal_set_count(int64_t value); public: // @@protoc_insertion_point(class_scope:substrait.FetchRel) @@ -3145,14 +3356,14 @@ class FetchRel PROTOBUF_FINAL : ::substrait::RelCommon* common_; ::substrait::Rel* input_; ::substrait::extensions::AdvancedExtension* advanced_extension_; - ::PROTOBUF_NAMESPACE_ID::int64 offset_; - ::PROTOBUF_NAMESPACE_ID::int64 count_; + int64_t offset_; + int64_t count_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- -class AggregateRel_Grouping PROTOBUF_FINAL : +class AggregateRel_Grouping final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel.Grouping) */ { public: inline AggregateRel_Grouping() : AggregateRel_Grouping(nullptr) {} @@ -3170,8 +3381,13 @@ class AggregateRel_Grouping PROTOBUF_FINAL : return *this; } inline AggregateRel_Grouping& operator=(AggregateRel_Grouping&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3202,7 +3418,12 @@ class AggregateRel_Grouping PROTOBUF_FINAL : } inline void Swap(AggregateRel_Grouping* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3210,48 +3431,53 @@ class AggregateRel_Grouping PROTOBUF_FINAL : } void UnsafeArenaSwap(AggregateRel_Grouping* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline AggregateRel_Grouping* New() const final { - return CreateMaybeMessage(nullptr); - } - - AggregateRel_Grouping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + AggregateRel_Grouping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AggregateRel_Grouping& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const AggregateRel_Grouping& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AggregateRel_Grouping* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.AggregateRel.Grouping"; } protected: - explicit AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3292,7 +3518,7 @@ class AggregateRel_Grouping PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class AggregateRel_Measure PROTOBUF_FINAL : +class AggregateRel_Measure final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel.Measure) */ { public: inline AggregateRel_Measure() : AggregateRel_Measure(nullptr) {} @@ -3310,8 +3536,13 @@ class AggregateRel_Measure PROTOBUF_FINAL : return *this; } inline AggregateRel_Measure& operator=(AggregateRel_Measure&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3342,7 +3573,12 @@ class AggregateRel_Measure PROTOBUF_FINAL : } inline void Swap(AggregateRel_Measure* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3350,48 +3586,53 @@ class AggregateRel_Measure PROTOBUF_FINAL : } void UnsafeArenaSwap(AggregateRel_Measure* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline AggregateRel_Measure* New() const final { - return CreateMaybeMessage(nullptr); - } - - AggregateRel_Measure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + AggregateRel_Measure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AggregateRel_Measure& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const AggregateRel_Measure& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AggregateRel_Measure* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.AggregateRel.Measure"; } protected: - explicit AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3409,7 +3650,7 @@ class AggregateRel_Measure PROTOBUF_FINAL : public: void clear_measure(); const ::substrait::AggregateFunction& measure() const; - ::substrait::AggregateFunction* release_measure(); + PROTOBUF_NODISCARD ::substrait::AggregateFunction* release_measure(); ::substrait::AggregateFunction* mutable_measure(); void set_allocated_measure(::substrait::AggregateFunction* measure); private: @@ -3427,7 +3668,7 @@ class AggregateRel_Measure PROTOBUF_FINAL : public: void clear_filter(); const ::substrait::Expression& filter() const; - ::substrait::Expression* release_filter(); + PROTOBUF_NODISCARD ::substrait::Expression* release_filter(); ::substrait::Expression* mutable_filter(); void set_allocated_filter(::substrait::Expression* filter); private: @@ -3452,7 +3693,7 @@ class AggregateRel_Measure PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class AggregateRel PROTOBUF_FINAL : +class AggregateRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel) */ { public: inline AggregateRel() : AggregateRel(nullptr) {} @@ -3470,8 +3711,13 @@ class AggregateRel PROTOBUF_FINAL : return *this; } inline AggregateRel& operator=(AggregateRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3502,7 +3748,12 @@ class AggregateRel PROTOBUF_FINAL : } inline void Swap(AggregateRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3510,48 +3761,53 @@ class AggregateRel PROTOBUF_FINAL : } void UnsafeArenaSwap(AggregateRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline AggregateRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - AggregateRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + AggregateRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const AggregateRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const AggregateRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(AggregateRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.AggregateRel"; } protected: - explicit AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3611,7 +3867,7 @@ class AggregateRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -3629,7 +3885,7 @@ class AggregateRel PROTOBUF_FINAL : public: void clear_input(); const ::substrait::Rel& input() const; - ::substrait::Rel* release_input(); + PROTOBUF_NODISCARD ::substrait::Rel* release_input(); ::substrait::Rel* mutable_input(); void set_allocated_input(::substrait::Rel* input); private: @@ -3647,7 +3903,7 @@ class AggregateRel PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -3675,7 +3931,7 @@ class AggregateRel PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class SortRel PROTOBUF_FINAL : +class SortRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SortRel) */ { public: inline SortRel() : SortRel(nullptr) {} @@ -3693,8 +3949,13 @@ class SortRel PROTOBUF_FINAL : return *this; } inline SortRel& operator=(SortRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3725,7 +3986,12 @@ class SortRel PROTOBUF_FINAL : } inline void Swap(SortRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3733,48 +3999,53 @@ class SortRel PROTOBUF_FINAL : } void UnsafeArenaSwap(SortRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline SortRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - SortRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + SortRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SortRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const SortRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SortRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.SortRel"; } protected: - explicit SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3812,7 +4083,7 @@ class SortRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -3830,7 +4101,7 @@ class SortRel PROTOBUF_FINAL : public: void clear_input(); const ::substrait::Rel& input() const; - ::substrait::Rel* release_input(); + PROTOBUF_NODISCARD ::substrait::Rel* release_input(); ::substrait::Rel* mutable_input(); void set_allocated_input(::substrait::Rel* input); private: @@ -3848,7 +4119,7 @@ class SortRel PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -3875,7 +4146,7 @@ class SortRel PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class FilterRel PROTOBUF_FINAL : +class FilterRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FilterRel) */ { public: inline FilterRel() : FilterRel(nullptr) {} @@ -3893,8 +4164,13 @@ class FilterRel PROTOBUF_FINAL : return *this; } inline FilterRel& operator=(FilterRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3925,7 +4201,12 @@ class FilterRel PROTOBUF_FINAL : } inline void Swap(FilterRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3933,48 +4214,53 @@ class FilterRel PROTOBUF_FINAL : } void UnsafeArenaSwap(FilterRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline FilterRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - FilterRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + FilterRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const FilterRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const FilterRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(FilterRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.FilterRel"; } protected: - explicit FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3994,7 +4280,7 @@ class FilterRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -4012,7 +4298,7 @@ class FilterRel PROTOBUF_FINAL : public: void clear_input(); const ::substrait::Rel& input() const; - ::substrait::Rel* release_input(); + PROTOBUF_NODISCARD ::substrait::Rel* release_input(); ::substrait::Rel* mutable_input(); void set_allocated_input(::substrait::Rel* input); private: @@ -4030,7 +4316,7 @@ class FilterRel PROTOBUF_FINAL : public: void clear_condition(); const ::substrait::Expression& condition() const; - ::substrait::Expression* release_condition(); + PROTOBUF_NODISCARD ::substrait::Expression* release_condition(); ::substrait::Expression* mutable_condition(); void set_allocated_condition(::substrait::Expression* condition); private: @@ -4048,7 +4334,7 @@ class FilterRel PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -4075,7 +4361,7 @@ class FilterRel PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class SetRel PROTOBUF_FINAL : +class SetRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SetRel) */ { public: inline SetRel() : SetRel(nullptr) {} @@ -4093,8 +4379,13 @@ class SetRel PROTOBUF_FINAL : return *this; } inline SetRel& operator=(SetRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4125,7 +4416,12 @@ class SetRel PROTOBUF_FINAL : } inline void Swap(SetRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4133,48 +4429,53 @@ class SetRel PROTOBUF_FINAL : } void UnsafeArenaSwap(SetRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline SetRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - SetRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + SetRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const SetRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const SetRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(SetRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.SetRel"; } protected: - explicit SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4252,7 +4553,7 @@ class SetRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -4270,7 +4571,7 @@ class SetRel PROTOBUF_FINAL : public: void clear_advanced_extension(); const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - ::substrait::extensions::AdvancedExtension* release_advanced_extension(); + PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); private: @@ -4306,7 +4607,7 @@ class SetRel PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class ExtensionSingleRel PROTOBUF_FINAL : +class ExtensionSingleRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionSingleRel) */ { public: inline ExtensionSingleRel() : ExtensionSingleRel(nullptr) {} @@ -4324,8 +4625,13 @@ class ExtensionSingleRel PROTOBUF_FINAL : return *this; } inline ExtensionSingleRel& operator=(ExtensionSingleRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4356,7 +4662,12 @@ class ExtensionSingleRel PROTOBUF_FINAL : } inline void Swap(ExtensionSingleRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4364,48 +4675,53 @@ class ExtensionSingleRel PROTOBUF_FINAL : } void UnsafeArenaSwap(ExtensionSingleRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ExtensionSingleRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - ExtensionSingleRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ExtensionSingleRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ExtensionSingleRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ExtensionSingleRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ExtensionSingleRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ExtensionSingleRel"; } protected: - explicit ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4424,7 +4740,7 @@ class ExtensionSingleRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -4442,7 +4758,7 @@ class ExtensionSingleRel PROTOBUF_FINAL : public: void clear_input(); const ::substrait::Rel& input() const; - ::substrait::Rel* release_input(); + PROTOBUF_NODISCARD ::substrait::Rel* release_input(); ::substrait::Rel* mutable_input(); void set_allocated_input(::substrait::Rel* input); private: @@ -4459,17 +4775,17 @@ class ExtensionSingleRel PROTOBUF_FINAL : bool _internal_has_detail() const; public: void clear_detail(); - const PROTOBUF_NAMESPACE_ID::Any& detail() const; - PROTOBUF_NAMESPACE_ID::Any* release_detail(); - PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); - void set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail); + const ::PROTOBUF_NAMESPACE_ID::Any& detail() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail(); + ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); + void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail); private: - const PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; - PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); + const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; + ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); public: void unsafe_arena_set_allocated_detail( - PROTOBUF_NAMESPACE_ID::Any* detail); - PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); + ::PROTOBUF_NAMESPACE_ID::Any* detail); + ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); // @@protoc_insertion_point(class_scope:substrait.ExtensionSingleRel) private: @@ -4480,13 +4796,13 @@ class ExtensionSingleRel PROTOBUF_FINAL : typedef void DestructorSkippable_; ::substrait::RelCommon* common_; ::substrait::Rel* input_; - PROTOBUF_NAMESPACE_ID::Any* detail_; + ::PROTOBUF_NAMESPACE_ID::Any* detail_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- -class ExtensionLeafRel PROTOBUF_FINAL : +class ExtensionLeafRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionLeafRel) */ { public: inline ExtensionLeafRel() : ExtensionLeafRel(nullptr) {} @@ -4504,8 +4820,13 @@ class ExtensionLeafRel PROTOBUF_FINAL : return *this; } inline ExtensionLeafRel& operator=(ExtensionLeafRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4536,7 +4857,12 @@ class ExtensionLeafRel PROTOBUF_FINAL : } inline void Swap(ExtensionLeafRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4544,48 +4870,53 @@ class ExtensionLeafRel PROTOBUF_FINAL : } void UnsafeArenaSwap(ExtensionLeafRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ExtensionLeafRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - ExtensionLeafRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ExtensionLeafRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ExtensionLeafRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ExtensionLeafRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ExtensionLeafRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ExtensionLeafRel"; } protected: - explicit ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4603,7 +4934,7 @@ class ExtensionLeafRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -4620,17 +4951,17 @@ class ExtensionLeafRel PROTOBUF_FINAL : bool _internal_has_detail() const; public: void clear_detail(); - const PROTOBUF_NAMESPACE_ID::Any& detail() const; - PROTOBUF_NAMESPACE_ID::Any* release_detail(); - PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); - void set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail); + const ::PROTOBUF_NAMESPACE_ID::Any& detail() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail(); + ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); + void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail); private: - const PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; - PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); + const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; + ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); public: void unsafe_arena_set_allocated_detail( - PROTOBUF_NAMESPACE_ID::Any* detail); - PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); + ::PROTOBUF_NAMESPACE_ID::Any* detail); + ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); // @@protoc_insertion_point(class_scope:substrait.ExtensionLeafRel) private: @@ -4640,13 +4971,13 @@ class ExtensionLeafRel PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::RelCommon* common_; - PROTOBUF_NAMESPACE_ID::Any* detail_; + ::PROTOBUF_NAMESPACE_ID::Any* detail_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- -class ExtensionMultiRel PROTOBUF_FINAL : +class ExtensionMultiRel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionMultiRel) */ { public: inline ExtensionMultiRel() : ExtensionMultiRel(nullptr) {} @@ -4664,8 +4995,13 @@ class ExtensionMultiRel PROTOBUF_FINAL : return *this; } inline ExtensionMultiRel& operator=(ExtensionMultiRel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4696,7 +5032,12 @@ class ExtensionMultiRel PROTOBUF_FINAL : } inline void Swap(ExtensionMultiRel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4704,48 +5045,53 @@ class ExtensionMultiRel PROTOBUF_FINAL : } void UnsafeArenaSwap(ExtensionMultiRel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline ExtensionMultiRel* New() const final { - return CreateMaybeMessage(nullptr); - } - - ExtensionMultiRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + ExtensionMultiRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ExtensionMultiRel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const ExtensionMultiRel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ExtensionMultiRel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.ExtensionMultiRel"; } protected: - explicit ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4782,7 +5128,7 @@ class ExtensionMultiRel PROTOBUF_FINAL : public: void clear_common(); const ::substrait::RelCommon& common() const; - ::substrait::RelCommon* release_common(); + PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); ::substrait::RelCommon* mutable_common(); void set_allocated_common(::substrait::RelCommon* common); private: @@ -4799,17 +5145,17 @@ class ExtensionMultiRel PROTOBUF_FINAL : bool _internal_has_detail() const; public: void clear_detail(); - const PROTOBUF_NAMESPACE_ID::Any& detail() const; - PROTOBUF_NAMESPACE_ID::Any* release_detail(); - PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); - void set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail); + const ::PROTOBUF_NAMESPACE_ID::Any& detail() const; + PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail(); + ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); + void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail); private: - const PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; - PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); + const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; + ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); public: void unsafe_arena_set_allocated_detail( - PROTOBUF_NAMESPACE_ID::Any* detail); - PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); + ::PROTOBUF_NAMESPACE_ID::Any* detail); + ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); // @@protoc_insertion_point(class_scope:substrait.ExtensionMultiRel) private: @@ -4820,13 +5166,13 @@ class ExtensionMultiRel PROTOBUF_FINAL : typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel > inputs_; ::substrait::RelCommon* common_; - PROTOBUF_NAMESPACE_ID::Any* detail_; + ::PROTOBUF_NAMESPACE_ID::Any* detail_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2frelations_2eproto; }; // ------------------------------------------------------------------- -class RelRoot PROTOBUF_FINAL : +class RelRoot final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelRoot) */ { public: inline RelRoot() : RelRoot(nullptr) {} @@ -4844,8 +5190,13 @@ class RelRoot PROTOBUF_FINAL : return *this; } inline RelRoot& operator=(RelRoot&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4876,7 +5227,12 @@ class RelRoot PROTOBUF_FINAL : } inline void Swap(RelRoot* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4884,48 +5240,53 @@ class RelRoot PROTOBUF_FINAL : } void UnsafeArenaSwap(RelRoot* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline RelRoot* New() const final { - return CreateMaybeMessage(nullptr); - } - - RelRoot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + RelRoot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const RelRoot& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const RelRoot& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(RelRoot* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.RelRoot"; } protected: - explicit RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4967,7 +5328,7 @@ class RelRoot PROTOBUF_FINAL : public: void clear_input(); const ::substrait::Rel& input() const; - ::substrait::Rel* release_input(); + PROTOBUF_NODISCARD ::substrait::Rel* release_input(); ::substrait::Rel* mutable_input(); void set_allocated_input(::substrait::Rel* input); private: @@ -4992,7 +5353,7 @@ class RelRoot PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class Rel PROTOBUF_FINAL : +class Rel final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Rel) */ { public: inline Rel() : Rel(nullptr) {} @@ -5010,8 +5371,13 @@ class Rel PROTOBUF_FINAL : return *this; } inline Rel& operator=(Rel&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -5057,7 +5423,12 @@ class Rel PROTOBUF_FINAL : } inline void Swap(Rel* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -5065,48 +5436,53 @@ class Rel PROTOBUF_FINAL : } void UnsafeArenaSwap(Rel* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Rel* New() const final { - return CreateMaybeMessage(nullptr); - } - - Rel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Rel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Rel& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Rel& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Rel* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Rel"; } protected: - explicit Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -5133,7 +5509,7 @@ class Rel PROTOBUF_FINAL : public: void clear_read(); const ::substrait::ReadRel& read() const; - ::substrait::ReadRel* release_read(); + PROTOBUF_NODISCARD ::substrait::ReadRel* release_read(); ::substrait::ReadRel* mutable_read(); void set_allocated_read(::substrait::ReadRel* read); private: @@ -5151,7 +5527,7 @@ class Rel PROTOBUF_FINAL : public: void clear_filter(); const ::substrait::FilterRel& filter() const; - ::substrait::FilterRel* release_filter(); + PROTOBUF_NODISCARD ::substrait::FilterRel* release_filter(); ::substrait::FilterRel* mutable_filter(); void set_allocated_filter(::substrait::FilterRel* filter); private: @@ -5169,7 +5545,7 @@ class Rel PROTOBUF_FINAL : public: void clear_fetch(); const ::substrait::FetchRel& fetch() const; - ::substrait::FetchRel* release_fetch(); + PROTOBUF_NODISCARD ::substrait::FetchRel* release_fetch(); ::substrait::FetchRel* mutable_fetch(); void set_allocated_fetch(::substrait::FetchRel* fetch); private: @@ -5187,7 +5563,7 @@ class Rel PROTOBUF_FINAL : public: void clear_aggregate(); const ::substrait::AggregateRel& aggregate() const; - ::substrait::AggregateRel* release_aggregate(); + PROTOBUF_NODISCARD ::substrait::AggregateRel* release_aggregate(); ::substrait::AggregateRel* mutable_aggregate(); void set_allocated_aggregate(::substrait::AggregateRel* aggregate); private: @@ -5205,7 +5581,7 @@ class Rel PROTOBUF_FINAL : public: void clear_sort(); const ::substrait::SortRel& sort() const; - ::substrait::SortRel* release_sort(); + PROTOBUF_NODISCARD ::substrait::SortRel* release_sort(); ::substrait::SortRel* mutable_sort(); void set_allocated_sort(::substrait::SortRel* sort); private: @@ -5223,7 +5599,7 @@ class Rel PROTOBUF_FINAL : public: void clear_join(); const ::substrait::JoinRel& join() const; - ::substrait::JoinRel* release_join(); + PROTOBUF_NODISCARD ::substrait::JoinRel* release_join(); ::substrait::JoinRel* mutable_join(); void set_allocated_join(::substrait::JoinRel* join); private: @@ -5241,7 +5617,7 @@ class Rel PROTOBUF_FINAL : public: void clear_project(); const ::substrait::ProjectRel& project() const; - ::substrait::ProjectRel* release_project(); + PROTOBUF_NODISCARD ::substrait::ProjectRel* release_project(); ::substrait::ProjectRel* mutable_project(); void set_allocated_project(::substrait::ProjectRel* project); private: @@ -5259,7 +5635,7 @@ class Rel PROTOBUF_FINAL : public: void clear_set(); const ::substrait::SetRel& set() const; - ::substrait::SetRel* release_set(); + PROTOBUF_NODISCARD ::substrait::SetRel* release_set(); ::substrait::SetRel* mutable_set(); void set_allocated_set(::substrait::SetRel* set); private: @@ -5277,7 +5653,7 @@ class Rel PROTOBUF_FINAL : public: void clear_extension_single(); const ::substrait::ExtensionSingleRel& extension_single() const; - ::substrait::ExtensionSingleRel* release_extension_single(); + PROTOBUF_NODISCARD ::substrait::ExtensionSingleRel* release_extension_single(); ::substrait::ExtensionSingleRel* mutable_extension_single(); void set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single); private: @@ -5295,7 +5671,7 @@ class Rel PROTOBUF_FINAL : public: void clear_extension_multi(); const ::substrait::ExtensionMultiRel& extension_multi() const; - ::substrait::ExtensionMultiRel* release_extension_multi(); + PROTOBUF_NODISCARD ::substrait::ExtensionMultiRel* release_extension_multi(); ::substrait::ExtensionMultiRel* mutable_extension_multi(); void set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi); private: @@ -5313,7 +5689,7 @@ class Rel PROTOBUF_FINAL : public: void clear_extension_leaf(); const ::substrait::ExtensionLeafRel& extension_leaf() const; - ::substrait::ExtensionLeafRel* release_extension_leaf(); + PROTOBUF_NODISCARD ::substrait::ExtensionLeafRel* release_extension_leaf(); ::substrait::ExtensionLeafRel* mutable_extension_leaf(); void set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf); private: @@ -5363,7 +5739,7 @@ class Rel PROTOBUF_FINAL : ::substrait::ExtensionLeafRel* extension_leaf_; } rel_type_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2frelations_2eproto; }; @@ -5392,38 +5768,38 @@ inline int RelCommon_Emit::output_mapping_size() const { inline void RelCommon_Emit::clear_output_mapping() { output_mapping_.Clear(); } -inline ::PROTOBUF_NAMESPACE_ID::int32 RelCommon_Emit::_internal_output_mapping(int index) const { +inline int32_t RelCommon_Emit::_internal_output_mapping(int index) const { return output_mapping_.Get(index); } -inline ::PROTOBUF_NAMESPACE_ID::int32 RelCommon_Emit::output_mapping(int index) const { +inline int32_t RelCommon_Emit::output_mapping(int index) const { // @@protoc_insertion_point(field_get:substrait.RelCommon.Emit.output_mapping) return _internal_output_mapping(index); } -inline void RelCommon_Emit::set_output_mapping(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void RelCommon_Emit::set_output_mapping(int index, int32_t value) { output_mapping_.Set(index, value); // @@protoc_insertion_point(field_set:substrait.RelCommon.Emit.output_mapping) } -inline void RelCommon_Emit::_internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void RelCommon_Emit::_internal_add_output_mapping(int32_t value) { output_mapping_.Add(value); } -inline void RelCommon_Emit::add_output_mapping(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void RelCommon_Emit::add_output_mapping(int32_t value) { _internal_add_output_mapping(value); // @@protoc_insertion_point(field_add:substrait.RelCommon.Emit.output_mapping) } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& RelCommon_Emit::_internal_output_mapping() const { return output_mapping_; } -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >& +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& RelCommon_Emit::output_mapping() const { // @@protoc_insertion_point(field_list:substrait.RelCommon.Emit.output_mapping) return _internal_output_mapping(); } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* RelCommon_Emit::_internal_mutable_output_mapping() { return &output_mapping_; } -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >* +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* RelCommon_Emit::mutable_output_mapping() { // @@protoc_insertion_point(field_mutable_list:substrait.RelCommon.Emit.output_mapping) return _internal_mutable_output_mapping(); @@ -5491,7 +5867,7 @@ inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::a } inline void RelCommon_Hint_Stats::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -5506,9 +5882,15 @@ inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::release ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::unsafe_arena_release_advanced_extension() { @@ -5521,23 +5903,26 @@ inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::unsafe_ inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.Stats.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void RelCommon_Hint_Stats::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -5572,7 +5957,7 @@ inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeC } inline void RelCommon_Hint_RuntimeConstraint::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -5587,9 +5972,15 @@ inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstra ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::unsafe_arena_release_advanced_extension() { @@ -5602,23 +5993,26 @@ inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstra inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void RelCommon_Hint_RuntimeConstraint::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -5643,7 +6037,7 @@ inline bool RelCommon_Hint::has_stats() const { return _internal_has_stats(); } inline void RelCommon_Hint::clear_stats() { - if (GetArena() == nullptr && stats_ != nullptr) { + if (GetArenaForAllocation() == nullptr && stats_ != nullptr) { delete stats_; } stats_ = nullptr; @@ -5659,7 +6053,7 @@ inline const ::substrait::RelCommon_Hint_Stats& RelCommon_Hint::stats() const { } inline void RelCommon_Hint::unsafe_arena_set_allocated_stats( ::substrait::RelCommon_Hint_Stats* stats) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(stats_); } stats_ = stats; @@ -5674,9 +6068,15 @@ inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::release_stats() { ::substrait::RelCommon_Hint_Stats* temp = stats_; stats_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::unsafe_arena_release_stats() { @@ -5689,23 +6089,24 @@ inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::unsafe_arena_release_s inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::_internal_mutable_stats() { if (stats_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint_Stats>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint_Stats>(GetArenaForAllocation()); stats_ = p; } return stats_; } inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::mutable_stats() { + ::substrait::RelCommon_Hint_Stats* _msg = _internal_mutable_stats(); // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.stats) - return _internal_mutable_stats(); + return _msg; } inline void RelCommon_Hint::set_allocated_stats(::substrait::RelCommon_Hint_Stats* stats) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete stats_; } if (stats) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(stats); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Hint_Stats>::GetOwningArena(stats); if (message_arena != submessage_arena) { stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, stats, submessage_arena); @@ -5726,7 +6127,7 @@ inline bool RelCommon_Hint::has_constraint() const { return _internal_has_constraint(); } inline void RelCommon_Hint::clear_constraint() { - if (GetArena() == nullptr && constraint_ != nullptr) { + if (GetArenaForAllocation() == nullptr && constraint_ != nullptr) { delete constraint_; } constraint_ = nullptr; @@ -5742,7 +6143,7 @@ inline const ::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::cons } inline void RelCommon_Hint::unsafe_arena_set_allocated_constraint( ::substrait::RelCommon_Hint_RuntimeConstraint* constraint) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(constraint_); } constraint_ = constraint; @@ -5757,9 +6158,15 @@ inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::release_co ::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_; constraint_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::unsafe_arena_release_constraint() { @@ -5772,23 +6179,24 @@ inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::unsafe_are inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::_internal_mutable_constraint() { if (constraint_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint_RuntimeConstraint>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint_RuntimeConstraint>(GetArenaForAllocation()); constraint_ = p; } return constraint_; } inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::mutable_constraint() { + ::substrait::RelCommon_Hint_RuntimeConstraint* _msg = _internal_mutable_constraint(); // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.constraint) - return _internal_mutable_constraint(); + return _msg; } inline void RelCommon_Hint::set_allocated_constraint(::substrait::RelCommon_Hint_RuntimeConstraint* constraint) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete constraint_; } if (constraint) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(constraint); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Hint_RuntimeConstraint>::GetOwningArena(constraint); if (message_arena != submessage_arena) { constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, constraint, submessage_arena); @@ -5819,7 +6227,7 @@ inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint::advance } inline void RelCommon_Hint::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -5834,9 +6242,15 @@ inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::release_advan ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::unsafe_arena_release_advanced_extension() { @@ -5849,23 +6263,26 @@ inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::unsafe_arena_ inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void RelCommon_Hint::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -5894,7 +6311,7 @@ inline void RelCommon::set_has_direct() { } inline void RelCommon::clear_direct() { if (_internal_has_direct()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete emit_kind_.direct_; } clear_has_emit_kind(); @@ -5905,7 +6322,7 @@ inline ::substrait::RelCommon_Direct* RelCommon::release_direct() { if (_internal_has_direct()) { clear_has_emit_kind(); ::substrait::RelCommon_Direct* temp = emit_kind_.direct_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } emit_kind_.direct_ = nullptr; @@ -5946,13 +6363,14 @@ inline ::substrait::RelCommon_Direct* RelCommon::_internal_mutable_direct() { if (!_internal_has_direct()) { clear_emit_kind(); set_has_direct(); - emit_kind_.direct_ = CreateMaybeMessage< ::substrait::RelCommon_Direct >(GetArena()); + emit_kind_.direct_ = CreateMaybeMessage< ::substrait::RelCommon_Direct >(GetArenaForAllocation()); } return emit_kind_.direct_; } inline ::substrait::RelCommon_Direct* RelCommon::mutable_direct() { + ::substrait::RelCommon_Direct* _msg = _internal_mutable_direct(); // @@protoc_insertion_point(field_mutable:substrait.RelCommon.direct) - return _internal_mutable_direct(); + return _msg; } // .substrait.RelCommon.Emit emit = 2; @@ -5967,7 +6385,7 @@ inline void RelCommon::set_has_emit() { } inline void RelCommon::clear_emit() { if (_internal_has_emit()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete emit_kind_.emit_; } clear_has_emit_kind(); @@ -5978,7 +6396,7 @@ inline ::substrait::RelCommon_Emit* RelCommon::release_emit() { if (_internal_has_emit()) { clear_has_emit_kind(); ::substrait::RelCommon_Emit* temp = emit_kind_.emit_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } emit_kind_.emit_ = nullptr; @@ -6019,13 +6437,14 @@ inline ::substrait::RelCommon_Emit* RelCommon::_internal_mutable_emit() { if (!_internal_has_emit()) { clear_emit_kind(); set_has_emit(); - emit_kind_.emit_ = CreateMaybeMessage< ::substrait::RelCommon_Emit >(GetArena()); + emit_kind_.emit_ = CreateMaybeMessage< ::substrait::RelCommon_Emit >(GetArenaForAllocation()); } return emit_kind_.emit_; } inline ::substrait::RelCommon_Emit* RelCommon::mutable_emit() { + ::substrait::RelCommon_Emit* _msg = _internal_mutable_emit(); // @@protoc_insertion_point(field_mutable:substrait.RelCommon.emit) - return _internal_mutable_emit(); + return _msg; } // .substrait.RelCommon.Hint hint = 3; @@ -6036,7 +6455,7 @@ inline bool RelCommon::has_hint() const { return _internal_has_hint(); } inline void RelCommon::clear_hint() { - if (GetArena() == nullptr && hint_ != nullptr) { + if (GetArenaForAllocation() == nullptr && hint_ != nullptr) { delete hint_; } hint_ = nullptr; @@ -6052,7 +6471,7 @@ inline const ::substrait::RelCommon_Hint& RelCommon::hint() const { } inline void RelCommon::unsafe_arena_set_allocated_hint( ::substrait::RelCommon_Hint* hint) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hint_); } hint_ = hint; @@ -6067,9 +6486,15 @@ inline ::substrait::RelCommon_Hint* RelCommon::release_hint() { ::substrait::RelCommon_Hint* temp = hint_; hint_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon_Hint* RelCommon::unsafe_arena_release_hint() { @@ -6082,23 +6507,24 @@ inline ::substrait::RelCommon_Hint* RelCommon::unsafe_arena_release_hint() { inline ::substrait::RelCommon_Hint* RelCommon::_internal_mutable_hint() { if (hint_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint>(GetArenaForAllocation()); hint_ = p; } return hint_; } inline ::substrait::RelCommon_Hint* RelCommon::mutable_hint() { + ::substrait::RelCommon_Hint* _msg = _internal_mutable_hint(); // @@protoc_insertion_point(field_mutable:substrait.RelCommon.hint) - return _internal_mutable_hint(); + return _msg; } inline void RelCommon::set_allocated_hint(::substrait::RelCommon_Hint* hint) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete hint_; } if (hint) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(hint); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Hint>::GetOwningArena(hint); if (message_arena != submessage_arena) { hint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, hint, submessage_arena); @@ -6129,7 +6555,7 @@ inline const ::substrait::extensions::AdvancedExtension& RelCommon::advanced_ext } inline void RelCommon::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -6144,9 +6570,15 @@ inline ::substrait::extensions::AdvancedExtension* RelCommon::release_advanced_e ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* RelCommon::unsafe_arena_release_advanced_extension() { @@ -6159,23 +6591,26 @@ inline ::substrait::extensions::AdvancedExtension* RelCommon::unsafe_arena_relea inline ::substrait::extensions::AdvancedExtension* RelCommon::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* RelCommon::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.RelCommon.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void RelCommon::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -6212,8 +6647,9 @@ inline void ReadRel_NamedTable::clear_names() { names_.Clear(); } inline std::string* ReadRel_NamedTable::add_names() { + std::string* _s = _internal_add_names(); // @@protoc_insertion_point(field_add_mutable:substrait.ReadRel.NamedTable.names) - return _internal_add_names(); + return _s; } inline const std::string& ReadRel_NamedTable::_internal_names(int index) const { return names_.Get(index); @@ -6227,12 +6663,12 @@ inline std::string* ReadRel_NamedTable::mutable_names(int index) { return names_.Mutable(index); } inline void ReadRel_NamedTable::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.ReadRel.NamedTable.names) names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.ReadRel.NamedTable.names) } inline void ReadRel_NamedTable::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.ReadRel.NamedTable.names) names_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.ReadRel.NamedTable.names) } inline void ReadRel_NamedTable::set_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -6293,7 +6729,7 @@ inline const ::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::adv } inline void ReadRel_NamedTable::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -6308,9 +6744,15 @@ inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::release_a ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::unsafe_arena_release_advanced_extension() { @@ -6323,23 +6765,26 @@ inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::unsafe_ar inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.NamedTable.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void ReadRel_NamedTable::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -6383,8 +6828,9 @@ inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::_internal_a return values_.Add(); } inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::add_values() { + ::substrait::Expression_Literal_Struct* _add = _internal_add_values(); // @@protoc_insertion_point(field_add:substrait.ReadRel.VirtualTable.values) - return _internal_add_values(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >& ReadRel_VirtualTable::values() const { @@ -6403,18 +6849,18 @@ inline bool ReadRel_ExtensionTable::_internal_has_detail() const { inline bool ReadRel_ExtensionTable::has_detail() const { return _internal_has_detail(); } -inline const PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::_internal_detail() const { - const PROTOBUF_NAMESPACE_ID::Any* p = detail_; - return p != nullptr ? *p : reinterpret_cast( - PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +inline const ::PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::_internal_detail() const { + const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } -inline const PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::detail() const { +inline const ::PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::detail() const { // @@protoc_insertion_point(field_get:substrait.ReadRel.ExtensionTable.detail) return _internal_detail(); } inline void ReadRel_ExtensionTable::unsafe_arena_set_allocated_detail( - PROTOBUF_NAMESPACE_ID::Any* detail) { - if (GetArena() == nullptr) { + ::PROTOBUF_NAMESPACE_ID::Any* detail) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } detail_ = detail; @@ -6425,42 +6871,51 @@ inline void ReadRel_ExtensionTable::unsafe_arena_set_allocated_detail( } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.ExtensionTable.detail) } -inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::release_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::release_detail() { - PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::unsafe_arena_release_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::unsafe_arena_release_detail() { // @@protoc_insertion_point(field_release:substrait.ReadRel.ExtensionTable.detail) - PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::_internal_mutable_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::_internal_mutable_detail() { if (detail_ == nullptr) { - auto* p = CreateMaybeMessage(GetArena()); + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); detail_ = p; } return detail_; } -inline PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::mutable_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::mutable_detail() { + ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.ExtensionTable.detail) - return _internal_mutable_detail(); + return _msg; } -inline void ReadRel_ExtensionTable::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); +inline void ReadRel_ExtensionTable::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } if (detail) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)); if (message_arena != submessage_arena) { detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, detail, submessage_arena); @@ -6489,7 +6944,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path() { } inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path() { if (_internal_has_uri_path()) { - path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_path_type(); } } @@ -6504,12 +6959,13 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path(ArgT0&& arg0, ArgT... a set_has_uri_path(); path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) } inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path() { + std::string* _s = _internal_mutable_uri_path(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) - return _internal_mutable_uri_path(); + return _s; } inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path() const { if (_internal_has_uri_path()) { @@ -6523,7 +6979,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path(const std::st set_has_uri_path(); path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path() { if (!_internal_has_uri_path()) { @@ -6532,13 +6988,13 @@ inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path() path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return path_type_.uri_path_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path() { // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) if (_internal_has_uri_path()) { clear_has_path_type(); - return path_type_.uri_path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return path_type_.uri_path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -6550,7 +7006,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path(std::string* if (uri_path != nullptr) { set_has_uri_path(); path_type_.uri_path_.UnsafeSetDefault(uri_path); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(uri_path); } @@ -6570,7 +7026,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path_glob() { } inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path_glob() { if (_internal_has_uri_path_glob()) { - path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_path_type(); } } @@ -6585,12 +7041,13 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path_glob(ArgT0&& arg0, ArgT set_has_uri_path_glob(); path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) } inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path_glob() { + std::string* _s = _internal_mutable_uri_path_glob(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) - return _internal_mutable_uri_path_glob(); + return _s; } inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path_glob() const { if (_internal_has_uri_path_glob()) { @@ -6604,7 +7061,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path_glob(const st set_has_uri_path_glob(); path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path_glob() { if (!_internal_has_uri_path_glob()) { @@ -6613,13 +7070,13 @@ inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path_g path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return path_type_.uri_path_glob_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path_glob() { // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) if (_internal_has_uri_path_glob()) { clear_has_path_type(); - return path_type_.uri_path_glob_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return path_type_.uri_path_glob_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -6631,7 +7088,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path_glob(std::str if (uri_path_glob != nullptr) { set_has_uri_path_glob(); path_type_.uri_path_glob_.UnsafeSetDefault(uri_path_glob); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(uri_path_glob); } @@ -6651,7 +7108,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_file() { } inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_file() { if (_internal_has_uri_file()) { - path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_path_type(); } } @@ -6666,12 +7123,13 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_uri_file(ArgT0&& arg0, ArgT... a set_has_uri_file(); path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) } inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_file() { + std::string* _s = _internal_mutable_uri_file(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) - return _internal_mutable_uri_file(); + return _s; } inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_file() const { if (_internal_has_uri_file()) { @@ -6685,7 +7143,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_file(const std::st set_has_uri_file(); path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_file() { if (!_internal_has_uri_file()) { @@ -6694,13 +7152,13 @@ inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_file() path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return path_type_.uri_file_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_file() { // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) if (_internal_has_uri_file()) { clear_has_path_type(); - return path_type_.uri_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return path_type_.uri_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -6712,7 +7170,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_file(std::string* if (uri_file != nullptr) { set_has_uri_file(); path_type_.uri_file_.UnsafeSetDefault(uri_file); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(uri_file); } @@ -6732,7 +7190,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_folder() { } inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_folder() { if (_internal_has_uri_folder()) { - path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_path_type(); } } @@ -6747,12 +7205,13 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_uri_folder(ArgT0&& arg0, ArgT... set_has_uri_folder(); path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) } inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_folder() { + std::string* _s = _internal_mutable_uri_folder(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) - return _internal_mutable_uri_folder(); + return _s; } inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_folder() const { if (_internal_has_uri_folder()) { @@ -6766,7 +7225,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_folder(const std:: set_has_uri_folder(); path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_folder() { if (!_internal_has_uri_folder()) { @@ -6775,13 +7234,13 @@ inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_folder path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return path_type_.uri_folder_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_folder() { // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) if (_internal_has_uri_folder()) { clear_has_path_type(); - return path_type_.uri_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return path_type_.uri_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -6793,7 +7252,7 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_folder(std::string if (uri_folder != nullptr) { set_has_uri_folder(); path_type_.uri_folder_.UnsafeSetDefault(uri_folder); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(uri_folder); } @@ -6823,60 +7282,60 @@ inline void ReadRel_LocalFiles_FileOrFiles::set_format(::substrait::ReadRel_Loca // uint64 partition_index = 6; inline void ReadRel_LocalFiles_FileOrFiles::clear_partition_index() { - partition_index_ = PROTOBUF_ULONGLONG(0); + partition_index_ = uint64_t{0u}; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::_internal_partition_index() const { +inline uint64_t ReadRel_LocalFiles_FileOrFiles::_internal_partition_index() const { return partition_index_; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::partition_index() const { +inline uint64_t ReadRel_LocalFiles_FileOrFiles::partition_index() const { // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.partition_index) return _internal_partition_index(); } -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_partition_index(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_partition_index(uint64_t value) { partition_index_ = value; } -inline void ReadRel_LocalFiles_FileOrFiles::set_partition_index(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline void ReadRel_LocalFiles_FileOrFiles::set_partition_index(uint64_t value) { _internal_set_partition_index(value); // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.partition_index) } // uint64 start = 7; inline void ReadRel_LocalFiles_FileOrFiles::clear_start() { - start_ = PROTOBUF_ULONGLONG(0); + start_ = uint64_t{0u}; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::_internal_start() const { +inline uint64_t ReadRel_LocalFiles_FileOrFiles::_internal_start() const { return start_; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::start() const { +inline uint64_t ReadRel_LocalFiles_FileOrFiles::start() const { // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.start) return _internal_start(); } -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_start(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_start(uint64_t value) { start_ = value; } -inline void ReadRel_LocalFiles_FileOrFiles::set_start(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline void ReadRel_LocalFiles_FileOrFiles::set_start(uint64_t value) { _internal_set_start(value); // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.start) } // uint64 length = 8; inline void ReadRel_LocalFiles_FileOrFiles::clear_length() { - length_ = PROTOBUF_ULONGLONG(0); + length_ = uint64_t{0u}; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::_internal_length() const { +inline uint64_t ReadRel_LocalFiles_FileOrFiles::_internal_length() const { return length_; } -inline ::PROTOBUF_NAMESPACE_ID::uint64 ReadRel_LocalFiles_FileOrFiles::length() const { +inline uint64_t ReadRel_LocalFiles_FileOrFiles::length() const { // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.length) return _internal_length(); } -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_length(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_length(uint64_t value) { length_ = value; } -inline void ReadRel_LocalFiles_FileOrFiles::set_length(::PROTOBUF_NAMESPACE_ID::uint64 value) { +inline void ReadRel_LocalFiles_FileOrFiles::set_length(uint64_t value) { _internal_set_length(value); // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.length) } @@ -6924,8 +7383,9 @@ inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::_interna return items_.Add(); } inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::add_items() { + ::substrait::ReadRel_LocalFiles_FileOrFiles* _add = _internal_add_items(); // @@protoc_insertion_point(field_add:substrait.ReadRel.LocalFiles.items) - return _internal_add_items(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >& ReadRel_LocalFiles::items() const { @@ -6951,7 +7411,7 @@ inline const ::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::adv } inline void ReadRel_LocalFiles::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -6966,9 +7426,15 @@ inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::release_a ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::unsafe_arena_release_advanced_extension() { @@ -6981,23 +7447,26 @@ inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::unsafe_ar inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void ReadRel_LocalFiles::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -7022,7 +7491,7 @@ inline bool ReadRel::has_common() const { return _internal_has_common(); } inline void ReadRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -7038,7 +7507,7 @@ inline const ::substrait::RelCommon& ReadRel::common() const { } inline void ReadRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -7053,9 +7522,15 @@ inline ::substrait::RelCommon* ReadRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* ReadRel::unsafe_arena_release_common() { @@ -7068,23 +7543,24 @@ inline ::substrait::RelCommon* ReadRel::unsafe_arena_release_common() { inline ::substrait::RelCommon* ReadRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* ReadRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.common) - return _internal_mutable_common(); + return _msg; } inline void ReadRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -7115,7 +7591,7 @@ inline const ::substrait::NamedStruct& ReadRel::base_schema() const { } inline void ReadRel::unsafe_arena_set_allocated_base_schema( ::substrait::NamedStruct* base_schema) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); } base_schema_ = base_schema; @@ -7130,9 +7606,15 @@ inline ::substrait::NamedStruct* ReadRel::release_base_schema() { ::substrait::NamedStruct* temp = base_schema_; base_schema_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::NamedStruct* ReadRel::unsafe_arena_release_base_schema() { @@ -7145,23 +7627,26 @@ inline ::substrait::NamedStruct* ReadRel::unsafe_arena_release_base_schema() { inline ::substrait::NamedStruct* ReadRel::_internal_mutable_base_schema() { if (base_schema_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::NamedStruct>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::NamedStruct>(GetArenaForAllocation()); base_schema_ = p; } return base_schema_; } inline ::substrait::NamedStruct* ReadRel::mutable_base_schema() { + ::substrait::NamedStruct* _msg = _internal_mutable_base_schema(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.base_schema) - return _internal_mutable_base_schema(); + return _msg; } inline void ReadRel::set_allocated_base_schema(::substrait::NamedStruct* base_schema) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); } if (base_schema) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema)); if (message_arena != submessage_arena) { base_schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, base_schema, submessage_arena); @@ -7192,7 +7677,7 @@ inline const ::substrait::Expression& ReadRel::filter() const { } inline void ReadRel::unsafe_arena_set_allocated_filter( ::substrait::Expression* filter) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); } filter_ = filter; @@ -7207,9 +7692,15 @@ inline ::substrait::Expression* ReadRel::release_filter() { ::substrait::Expression* temp = filter_; filter_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* ReadRel::unsafe_arena_release_filter() { @@ -7222,23 +7713,26 @@ inline ::substrait::Expression* ReadRel::unsafe_arena_release_filter() { inline ::substrait::Expression* ReadRel::_internal_mutable_filter() { if (filter_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); filter_ = p; } return filter_; } inline ::substrait::Expression* ReadRel::mutable_filter() { + ::substrait::Expression* _msg = _internal_mutable_filter(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.filter) - return _internal_mutable_filter(); + return _msg; } inline void ReadRel::set_allocated_filter(::substrait::Expression* filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); } if (filter) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter)); if (message_arena != submessage_arena) { filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, filter, submessage_arena); @@ -7269,7 +7763,7 @@ inline const ::substrait::Expression_MaskExpression& ReadRel::projection() const } inline void ReadRel::unsafe_arena_set_allocated_projection( ::substrait::Expression_MaskExpression* projection) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); } projection_ = projection; @@ -7284,9 +7778,15 @@ inline ::substrait::Expression_MaskExpression* ReadRel::release_projection() { ::substrait::Expression_MaskExpression* temp = projection_; projection_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression_MaskExpression* ReadRel::unsafe_arena_release_projection() { @@ -7299,23 +7799,26 @@ inline ::substrait::Expression_MaskExpression* ReadRel::unsafe_arena_release_pro inline ::substrait::Expression_MaskExpression* ReadRel::_internal_mutable_projection() { if (projection_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression>(GetArenaForAllocation()); projection_ = p; } return projection_; } inline ::substrait::Expression_MaskExpression* ReadRel::mutable_projection() { + ::substrait::Expression_MaskExpression* _msg = _internal_mutable_projection(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.projection) - return _internal_mutable_projection(); + return _msg; } inline void ReadRel::set_allocated_projection(::substrait::Expression_MaskExpression* projection) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); } if (projection) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection)); if (message_arena != submessage_arena) { projection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, projection, submessage_arena); @@ -7346,7 +7849,7 @@ inline const ::substrait::extensions::AdvancedExtension& ReadRel::advanced_exten } inline void ReadRel::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -7361,9 +7864,15 @@ inline ::substrait::extensions::AdvancedExtension* ReadRel::release_advanced_ext ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* ReadRel::unsafe_arena_release_advanced_extension() { @@ -7376,23 +7885,26 @@ inline ::substrait::extensions::AdvancedExtension* ReadRel::unsafe_arena_release inline ::substrait::extensions::AdvancedExtension* ReadRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* ReadRel::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void ReadRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -7417,7 +7929,7 @@ inline void ReadRel::set_has_virtual_table() { } inline void ReadRel::clear_virtual_table() { if (_internal_has_virtual_table()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete read_type_.virtual_table_; } clear_has_read_type(); @@ -7428,7 +7940,7 @@ inline ::substrait::ReadRel_VirtualTable* ReadRel::release_virtual_table() { if (_internal_has_virtual_table()) { clear_has_read_type(); ::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } read_type_.virtual_table_ = nullptr; @@ -7469,13 +7981,14 @@ inline ::substrait::ReadRel_VirtualTable* ReadRel::_internal_mutable_virtual_tab if (!_internal_has_virtual_table()) { clear_read_type(); set_has_virtual_table(); - read_type_.virtual_table_ = CreateMaybeMessage< ::substrait::ReadRel_VirtualTable >(GetArena()); + read_type_.virtual_table_ = CreateMaybeMessage< ::substrait::ReadRel_VirtualTable >(GetArenaForAllocation()); } return read_type_.virtual_table_; } inline ::substrait::ReadRel_VirtualTable* ReadRel::mutable_virtual_table() { + ::substrait::ReadRel_VirtualTable* _msg = _internal_mutable_virtual_table(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.virtual_table) - return _internal_mutable_virtual_table(); + return _msg; } // .substrait.ReadRel.LocalFiles local_files = 6; @@ -7490,7 +8003,7 @@ inline void ReadRel::set_has_local_files() { } inline void ReadRel::clear_local_files() { if (_internal_has_local_files()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete read_type_.local_files_; } clear_has_read_type(); @@ -7501,7 +8014,7 @@ inline ::substrait::ReadRel_LocalFiles* ReadRel::release_local_files() { if (_internal_has_local_files()) { clear_has_read_type(); ::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } read_type_.local_files_ = nullptr; @@ -7542,13 +8055,14 @@ inline ::substrait::ReadRel_LocalFiles* ReadRel::_internal_mutable_local_files() if (!_internal_has_local_files()) { clear_read_type(); set_has_local_files(); - read_type_.local_files_ = CreateMaybeMessage< ::substrait::ReadRel_LocalFiles >(GetArena()); + read_type_.local_files_ = CreateMaybeMessage< ::substrait::ReadRel_LocalFiles >(GetArenaForAllocation()); } return read_type_.local_files_; } inline ::substrait::ReadRel_LocalFiles* ReadRel::mutable_local_files() { + ::substrait::ReadRel_LocalFiles* _msg = _internal_mutable_local_files(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.local_files) - return _internal_mutable_local_files(); + return _msg; } // .substrait.ReadRel.NamedTable named_table = 7; @@ -7563,7 +8077,7 @@ inline void ReadRel::set_has_named_table() { } inline void ReadRel::clear_named_table() { if (_internal_has_named_table()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete read_type_.named_table_; } clear_has_read_type(); @@ -7574,7 +8088,7 @@ inline ::substrait::ReadRel_NamedTable* ReadRel::release_named_table() { if (_internal_has_named_table()) { clear_has_read_type(); ::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } read_type_.named_table_ = nullptr; @@ -7615,13 +8129,14 @@ inline ::substrait::ReadRel_NamedTable* ReadRel::_internal_mutable_named_table() if (!_internal_has_named_table()) { clear_read_type(); set_has_named_table(); - read_type_.named_table_ = CreateMaybeMessage< ::substrait::ReadRel_NamedTable >(GetArena()); + read_type_.named_table_ = CreateMaybeMessage< ::substrait::ReadRel_NamedTable >(GetArenaForAllocation()); } return read_type_.named_table_; } inline ::substrait::ReadRel_NamedTable* ReadRel::mutable_named_table() { + ::substrait::ReadRel_NamedTable* _msg = _internal_mutable_named_table(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.named_table) - return _internal_mutable_named_table(); + return _msg; } // .substrait.ReadRel.ExtensionTable extension_table = 8; @@ -7636,7 +8151,7 @@ inline void ReadRel::set_has_extension_table() { } inline void ReadRel::clear_extension_table() { if (_internal_has_extension_table()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete read_type_.extension_table_; } clear_has_read_type(); @@ -7647,7 +8162,7 @@ inline ::substrait::ReadRel_ExtensionTable* ReadRel::release_extension_table() { if (_internal_has_extension_table()) { clear_has_read_type(); ::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } read_type_.extension_table_ = nullptr; @@ -7688,13 +8203,14 @@ inline ::substrait::ReadRel_ExtensionTable* ReadRel::_internal_mutable_extension if (!_internal_has_extension_table()) { clear_read_type(); set_has_extension_table(); - read_type_.extension_table_ = CreateMaybeMessage< ::substrait::ReadRel_ExtensionTable >(GetArena()); + read_type_.extension_table_ = CreateMaybeMessage< ::substrait::ReadRel_ExtensionTable >(GetArenaForAllocation()); } return read_type_.extension_table_; } inline ::substrait::ReadRel_ExtensionTable* ReadRel::mutable_extension_table() { + ::substrait::ReadRel_ExtensionTable* _msg = _internal_mutable_extension_table(); // @@protoc_insertion_point(field_mutable:substrait.ReadRel.extension_table) - return _internal_mutable_extension_table(); + return _msg; } inline bool ReadRel::has_read_type() const { @@ -7718,7 +8234,7 @@ inline bool ProjectRel::has_common() const { return _internal_has_common(); } inline void ProjectRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -7734,7 +8250,7 @@ inline const ::substrait::RelCommon& ProjectRel::common() const { } inline void ProjectRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -7749,9 +8265,15 @@ inline ::substrait::RelCommon* ProjectRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* ProjectRel::unsafe_arena_release_common() { @@ -7764,23 +8286,24 @@ inline ::substrait::RelCommon* ProjectRel::unsafe_arena_release_common() { inline ::substrait::RelCommon* ProjectRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* ProjectRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.common) - return _internal_mutable_common(); + return _msg; } inline void ProjectRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -7801,7 +8324,7 @@ inline bool ProjectRel::has_input() const { return _internal_has_input(); } inline void ProjectRel::clear_input() { - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; @@ -7817,7 +8340,7 @@ inline const ::substrait::Rel& ProjectRel::input() const { } inline void ProjectRel::unsafe_arena_set_allocated_input( ::substrait::Rel* input) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } input_ = input; @@ -7832,9 +8355,15 @@ inline ::substrait::Rel* ProjectRel::release_input() { ::substrait::Rel* temp = input_; input_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Rel* ProjectRel::unsafe_arena_release_input() { @@ -7847,23 +8376,24 @@ inline ::substrait::Rel* ProjectRel::unsafe_arena_release_input() { inline ::substrait::Rel* ProjectRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); input_ = p; } return input_; } inline ::substrait::Rel* ProjectRel::mutable_input() { + ::substrait::Rel* _msg = _internal_mutable_input(); // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.input) - return _internal_mutable_input(); + return _msg; } inline void ProjectRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete input_; } if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); if (message_arena != submessage_arena) { input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, input, submessage_arena); @@ -7903,8 +8433,9 @@ inline ::substrait::Expression* ProjectRel::_internal_add_expressions() { return expressions_.Add(); } inline ::substrait::Expression* ProjectRel::add_expressions() { + ::substrait::Expression* _add = _internal_add_expressions(); // @@protoc_insertion_point(field_add:substrait.ProjectRel.expressions) - return _internal_add_expressions(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& ProjectRel::expressions() const { @@ -7930,7 +8461,7 @@ inline const ::substrait::extensions::AdvancedExtension& ProjectRel::advanced_ex } inline void ProjectRel::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -7945,9 +8476,15 @@ inline ::substrait::extensions::AdvancedExtension* ProjectRel::release_advanced_ ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* ProjectRel::unsafe_arena_release_advanced_extension() { @@ -7960,23 +8497,26 @@ inline ::substrait::extensions::AdvancedExtension* ProjectRel::unsafe_arena_rele inline ::substrait::extensions::AdvancedExtension* ProjectRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* ProjectRel::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void ProjectRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -8001,7 +8541,7 @@ inline bool JoinRel::has_common() const { return _internal_has_common(); } inline void JoinRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -8017,7 +8557,7 @@ inline const ::substrait::RelCommon& JoinRel::common() const { } inline void JoinRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -8032,9 +8572,15 @@ inline ::substrait::RelCommon* JoinRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* JoinRel::unsafe_arena_release_common() { @@ -8047,23 +8593,24 @@ inline ::substrait::RelCommon* JoinRel::unsafe_arena_release_common() { inline ::substrait::RelCommon* JoinRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* JoinRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.JoinRel.common) - return _internal_mutable_common(); + return _msg; } inline void JoinRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -8084,7 +8631,7 @@ inline bool JoinRel::has_left() const { return _internal_has_left(); } inline void JoinRel::clear_left() { - if (GetArena() == nullptr && left_ != nullptr) { + if (GetArenaForAllocation() == nullptr && left_ != nullptr) { delete left_; } left_ = nullptr; @@ -8100,7 +8647,7 @@ inline const ::substrait::Rel& JoinRel::left() const { } inline void JoinRel::unsafe_arena_set_allocated_left( ::substrait::Rel* left) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(left_); } left_ = left; @@ -8115,9 +8662,15 @@ inline ::substrait::Rel* JoinRel::release_left() { ::substrait::Rel* temp = left_; left_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Rel* JoinRel::unsafe_arena_release_left() { @@ -8130,23 +8683,24 @@ inline ::substrait::Rel* JoinRel::unsafe_arena_release_left() { inline ::substrait::Rel* JoinRel::_internal_mutable_left() { if (left_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); left_ = p; } return left_; } inline ::substrait::Rel* JoinRel::mutable_left() { + ::substrait::Rel* _msg = _internal_mutable_left(); // @@protoc_insertion_point(field_mutable:substrait.JoinRel.left) - return _internal_mutable_left(); + return _msg; } inline void JoinRel::set_allocated_left(::substrait::Rel* left) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete left_; } if (left) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(left); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(left); if (message_arena != submessage_arena) { left = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, left, submessage_arena); @@ -8167,7 +8721,7 @@ inline bool JoinRel::has_right() const { return _internal_has_right(); } inline void JoinRel::clear_right() { - if (GetArena() == nullptr && right_ != nullptr) { + if (GetArenaForAllocation() == nullptr && right_ != nullptr) { delete right_; } right_ = nullptr; @@ -8183,7 +8737,7 @@ inline const ::substrait::Rel& JoinRel::right() const { } inline void JoinRel::unsafe_arena_set_allocated_right( ::substrait::Rel* right) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(right_); } right_ = right; @@ -8198,9 +8752,15 @@ inline ::substrait::Rel* JoinRel::release_right() { ::substrait::Rel* temp = right_; right_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Rel* JoinRel::unsafe_arena_release_right() { @@ -8213,23 +8773,24 @@ inline ::substrait::Rel* JoinRel::unsafe_arena_release_right() { inline ::substrait::Rel* JoinRel::_internal_mutable_right() { if (right_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); right_ = p; } return right_; } inline ::substrait::Rel* JoinRel::mutable_right() { + ::substrait::Rel* _msg = _internal_mutable_right(); // @@protoc_insertion_point(field_mutable:substrait.JoinRel.right) - return _internal_mutable_right(); + return _msg; } inline void JoinRel::set_allocated_right(::substrait::Rel* right) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete right_; } if (right) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(right); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(right); if (message_arena != submessage_arena) { right = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, right, submessage_arena); @@ -8260,7 +8821,7 @@ inline const ::substrait::Expression& JoinRel::expression() const { } inline void JoinRel::unsafe_arena_set_allocated_expression( ::substrait::Expression* expression) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); } expression_ = expression; @@ -8275,9 +8836,15 @@ inline ::substrait::Expression* JoinRel::release_expression() { ::substrait::Expression* temp = expression_; expression_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* JoinRel::unsafe_arena_release_expression() { @@ -8290,23 +8857,26 @@ inline ::substrait::Expression* JoinRel::unsafe_arena_release_expression() { inline ::substrait::Expression* JoinRel::_internal_mutable_expression() { if (expression_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); expression_ = p; } return expression_; } inline ::substrait::Expression* JoinRel::mutable_expression() { + ::substrait::Expression* _msg = _internal_mutable_expression(); // @@protoc_insertion_point(field_mutable:substrait.JoinRel.expression) - return _internal_mutable_expression(); + return _msg; } inline void JoinRel::set_allocated_expression(::substrait::Expression* expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); } if (expression) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression)); if (message_arena != submessage_arena) { expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expression, submessage_arena); @@ -8337,7 +8907,7 @@ inline const ::substrait::Expression& JoinRel::post_join_filter() const { } inline void JoinRel::unsafe_arena_set_allocated_post_join_filter( ::substrait::Expression* post_join_filter) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); } post_join_filter_ = post_join_filter; @@ -8352,9 +8922,15 @@ inline ::substrait::Expression* JoinRel::release_post_join_filter() { ::substrait::Expression* temp = post_join_filter_; post_join_filter_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* JoinRel::unsafe_arena_release_post_join_filter() { @@ -8367,23 +8943,26 @@ inline ::substrait::Expression* JoinRel::unsafe_arena_release_post_join_filter() inline ::substrait::Expression* JoinRel::_internal_mutable_post_join_filter() { if (post_join_filter_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); post_join_filter_ = p; } return post_join_filter_; } inline ::substrait::Expression* JoinRel::mutable_post_join_filter() { + ::substrait::Expression* _msg = _internal_mutable_post_join_filter(); // @@protoc_insertion_point(field_mutable:substrait.JoinRel.post_join_filter) - return _internal_mutable_post_join_filter(); + return _msg; } inline void JoinRel::set_allocated_post_join_filter(::substrait::Expression* post_join_filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); } if (post_join_filter) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter)); if (message_arena != submessage_arena) { post_join_filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, post_join_filter, submessage_arena); @@ -8434,7 +9013,7 @@ inline const ::substrait::extensions::AdvancedExtension& JoinRel::advanced_exten } inline void JoinRel::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -8449,9 +9028,15 @@ inline ::substrait::extensions::AdvancedExtension* JoinRel::release_advanced_ext ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* JoinRel::unsafe_arena_release_advanced_extension() { @@ -8464,23 +9049,26 @@ inline ::substrait::extensions::AdvancedExtension* JoinRel::unsafe_arena_release inline ::substrait::extensions::AdvancedExtension* JoinRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* JoinRel::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.JoinRel.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void JoinRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -8505,7 +9093,7 @@ inline bool FetchRel::has_common() const { return _internal_has_common(); } inline void FetchRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -8521,7 +9109,7 @@ inline const ::substrait::RelCommon& FetchRel::common() const { } inline void FetchRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -8536,9 +9124,15 @@ inline ::substrait::RelCommon* FetchRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* FetchRel::unsafe_arena_release_common() { @@ -8551,23 +9145,24 @@ inline ::substrait::RelCommon* FetchRel::unsafe_arena_release_common() { inline ::substrait::RelCommon* FetchRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* FetchRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.FetchRel.common) - return _internal_mutable_common(); + return _msg; } inline void FetchRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -8588,7 +9183,7 @@ inline bool FetchRel::has_input() const { return _internal_has_input(); } inline void FetchRel::clear_input() { - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; @@ -8604,7 +9199,7 @@ inline const ::substrait::Rel& FetchRel::input() const { } inline void FetchRel::unsafe_arena_set_allocated_input( ::substrait::Rel* input) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } input_ = input; @@ -8619,9 +9214,15 @@ inline ::substrait::Rel* FetchRel::release_input() { ::substrait::Rel* temp = input_; input_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Rel* FetchRel::unsafe_arena_release_input() { @@ -8634,23 +9235,24 @@ inline ::substrait::Rel* FetchRel::unsafe_arena_release_input() { inline ::substrait::Rel* FetchRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); input_ = p; } return input_; } inline ::substrait::Rel* FetchRel::mutable_input() { + ::substrait::Rel* _msg = _internal_mutable_input(); // @@protoc_insertion_point(field_mutable:substrait.FetchRel.input) - return _internal_mutable_input(); + return _msg; } inline void FetchRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete input_; } if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); if (message_arena != submessage_arena) { input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, input, submessage_arena); @@ -8665,40 +9267,40 @@ inline void FetchRel::set_allocated_input(::substrait::Rel* input) { // int64 offset = 3; inline void FetchRel::clear_offset() { - offset_ = PROTOBUF_LONGLONG(0); + offset_ = int64_t{0}; } -inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::_internal_offset() const { +inline int64_t FetchRel::_internal_offset() const { return offset_; } -inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::offset() const { +inline int64_t FetchRel::offset() const { // @@protoc_insertion_point(field_get:substrait.FetchRel.offset) return _internal_offset(); } -inline void FetchRel::_internal_set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void FetchRel::_internal_set_offset(int64_t value) { offset_ = value; } -inline void FetchRel::set_offset(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void FetchRel::set_offset(int64_t value) { _internal_set_offset(value); // @@protoc_insertion_point(field_set:substrait.FetchRel.offset) } // int64 count = 4; inline void FetchRel::clear_count() { - count_ = PROTOBUF_LONGLONG(0); + count_ = int64_t{0}; } -inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::_internal_count() const { +inline int64_t FetchRel::_internal_count() const { return count_; } -inline ::PROTOBUF_NAMESPACE_ID::int64 FetchRel::count() const { +inline int64_t FetchRel::count() const { // @@protoc_insertion_point(field_get:substrait.FetchRel.count) return _internal_count(); } -inline void FetchRel::_internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void FetchRel::_internal_set_count(int64_t value) { count_ = value; } -inline void FetchRel::set_count(::PROTOBUF_NAMESPACE_ID::int64 value) { +inline void FetchRel::set_count(int64_t value) { _internal_set_count(value); // @@protoc_insertion_point(field_set:substrait.FetchRel.count) } @@ -8721,7 +9323,7 @@ inline const ::substrait::extensions::AdvancedExtension& FetchRel::advanced_exte } inline void FetchRel::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -8736,9 +9338,15 @@ inline ::substrait::extensions::AdvancedExtension* FetchRel::release_advanced_ex ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* FetchRel::unsafe_arena_release_advanced_extension() { @@ -8751,23 +9359,26 @@ inline ::substrait::extensions::AdvancedExtension* FetchRel::unsafe_arena_releas inline ::substrait::extensions::AdvancedExtension* FetchRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* FetchRel::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.FetchRel.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void FetchRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -8811,8 +9422,9 @@ inline ::substrait::Expression* AggregateRel_Grouping::_internal_add_grouping_ex return grouping_expressions_.Add(); } inline ::substrait::Expression* AggregateRel_Grouping::add_grouping_expressions() { + ::substrait::Expression* _add = _internal_add_grouping_expressions(); // @@protoc_insertion_point(field_add:substrait.AggregateRel.Grouping.grouping_expressions) - return _internal_add_grouping_expressions(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& AggregateRel_Grouping::grouping_expressions() const { @@ -8842,7 +9454,7 @@ inline const ::substrait::AggregateFunction& AggregateRel_Measure::measure() con } inline void AggregateRel_Measure::unsafe_arena_set_allocated_measure( ::substrait::AggregateFunction* measure) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); } measure_ = measure; @@ -8857,9 +9469,15 @@ inline ::substrait::AggregateFunction* AggregateRel_Measure::release_measure() { ::substrait::AggregateFunction* temp = measure_; measure_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::AggregateFunction* AggregateRel_Measure::unsafe_arena_release_measure() { @@ -8872,23 +9490,26 @@ inline ::substrait::AggregateFunction* AggregateRel_Measure::unsafe_arena_releas inline ::substrait::AggregateFunction* AggregateRel_Measure::_internal_mutable_measure() { if (measure_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::AggregateFunction>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::AggregateFunction>(GetArenaForAllocation()); measure_ = p; } return measure_; } inline ::substrait::AggregateFunction* AggregateRel_Measure::mutable_measure() { + ::substrait::AggregateFunction* _msg = _internal_mutable_measure(); // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Measure.measure) - return _internal_mutable_measure(); + return _msg; } inline void AggregateRel_Measure::set_allocated_measure(::substrait::AggregateFunction* measure) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); } if (measure) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure)); if (message_arena != submessage_arena) { measure = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, measure, submessage_arena); @@ -8919,7 +9540,7 @@ inline const ::substrait::Expression& AggregateRel_Measure::filter() const { } inline void AggregateRel_Measure::unsafe_arena_set_allocated_filter( ::substrait::Expression* filter) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); } filter_ = filter; @@ -8934,9 +9555,15 @@ inline ::substrait::Expression* AggregateRel_Measure::release_filter() { ::substrait::Expression* temp = filter_; filter_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* AggregateRel_Measure::unsafe_arena_release_filter() { @@ -8949,23 +9576,26 @@ inline ::substrait::Expression* AggregateRel_Measure::unsafe_arena_release_filte inline ::substrait::Expression* AggregateRel_Measure::_internal_mutable_filter() { if (filter_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); filter_ = p; } return filter_; } inline ::substrait::Expression* AggregateRel_Measure::mutable_filter() { + ::substrait::Expression* _msg = _internal_mutable_filter(); // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Measure.filter) - return _internal_mutable_filter(); + return _msg; } inline void AggregateRel_Measure::set_allocated_filter(::substrait::Expression* filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); } if (filter) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter)); if (message_arena != submessage_arena) { filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, filter, submessage_arena); @@ -8990,7 +9620,7 @@ inline bool AggregateRel::has_common() const { return _internal_has_common(); } inline void AggregateRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -9006,7 +9636,7 @@ inline const ::substrait::RelCommon& AggregateRel::common() const { } inline void AggregateRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -9021,9 +9651,15 @@ inline ::substrait::RelCommon* AggregateRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* AggregateRel::unsafe_arena_release_common() { @@ -9036,23 +9672,24 @@ inline ::substrait::RelCommon* AggregateRel::unsafe_arena_release_common() { inline ::substrait::RelCommon* AggregateRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* AggregateRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.common) - return _internal_mutable_common(); + return _msg; } inline void AggregateRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -9073,7 +9710,7 @@ inline bool AggregateRel::has_input() const { return _internal_has_input(); } inline void AggregateRel::clear_input() { - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; @@ -9089,7 +9726,7 @@ inline const ::substrait::Rel& AggregateRel::input() const { } inline void AggregateRel::unsafe_arena_set_allocated_input( ::substrait::Rel* input) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } input_ = input; @@ -9104,9 +9741,15 @@ inline ::substrait::Rel* AggregateRel::release_input() { ::substrait::Rel* temp = input_; input_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Rel* AggregateRel::unsafe_arena_release_input() { @@ -9119,23 +9762,24 @@ inline ::substrait::Rel* AggregateRel::unsafe_arena_release_input() { inline ::substrait::Rel* AggregateRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); input_ = p; } return input_; } inline ::substrait::Rel* AggregateRel::mutable_input() { + ::substrait::Rel* _msg = _internal_mutable_input(); // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.input) - return _internal_mutable_input(); + return _msg; } inline void AggregateRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete input_; } if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); if (message_arena != submessage_arena) { input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, input, submessage_arena); @@ -9178,8 +9822,9 @@ inline ::substrait::AggregateRel_Grouping* AggregateRel::_internal_add_groupings return groupings_.Add(); } inline ::substrait::AggregateRel_Grouping* AggregateRel::add_groupings() { + ::substrait::AggregateRel_Grouping* _add = _internal_add_groupings(); // @@protoc_insertion_point(field_add:substrait.AggregateRel.groupings) - return _internal_add_groupings(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >& AggregateRel::groupings() const { @@ -9217,8 +9862,9 @@ inline ::substrait::AggregateRel_Measure* AggregateRel::_internal_add_measures() return measures_.Add(); } inline ::substrait::AggregateRel_Measure* AggregateRel::add_measures() { + ::substrait::AggregateRel_Measure* _add = _internal_add_measures(); // @@protoc_insertion_point(field_add:substrait.AggregateRel.measures) - return _internal_add_measures(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >& AggregateRel::measures() const { @@ -9244,7 +9890,7 @@ inline const ::substrait::extensions::AdvancedExtension& AggregateRel::advanced_ } inline void AggregateRel::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -9259,9 +9905,15 @@ inline ::substrait::extensions::AdvancedExtension* AggregateRel::release_advance ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* AggregateRel::unsafe_arena_release_advanced_extension() { @@ -9274,23 +9926,26 @@ inline ::substrait::extensions::AdvancedExtension* AggregateRel::unsafe_arena_re inline ::substrait::extensions::AdvancedExtension* AggregateRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* AggregateRel::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void AggregateRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -9315,7 +9970,7 @@ inline bool SortRel::has_common() const { return _internal_has_common(); } inline void SortRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -9331,7 +9986,7 @@ inline const ::substrait::RelCommon& SortRel::common() const { } inline void SortRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -9346,9 +10001,15 @@ inline ::substrait::RelCommon* SortRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* SortRel::unsafe_arena_release_common() { @@ -9361,23 +10022,24 @@ inline ::substrait::RelCommon* SortRel::unsafe_arena_release_common() { inline ::substrait::RelCommon* SortRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* SortRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.SortRel.common) - return _internal_mutable_common(); + return _msg; } inline void SortRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -9398,7 +10060,7 @@ inline bool SortRel::has_input() const { return _internal_has_input(); } inline void SortRel::clear_input() { - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; @@ -9414,7 +10076,7 @@ inline const ::substrait::Rel& SortRel::input() const { } inline void SortRel::unsafe_arena_set_allocated_input( ::substrait::Rel* input) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } input_ = input; @@ -9429,9 +10091,15 @@ inline ::substrait::Rel* SortRel::release_input() { ::substrait::Rel* temp = input_; input_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Rel* SortRel::unsafe_arena_release_input() { @@ -9444,23 +10112,24 @@ inline ::substrait::Rel* SortRel::unsafe_arena_release_input() { inline ::substrait::Rel* SortRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); input_ = p; } return input_; } inline ::substrait::Rel* SortRel::mutable_input() { + ::substrait::Rel* _msg = _internal_mutable_input(); // @@protoc_insertion_point(field_mutable:substrait.SortRel.input) - return _internal_mutable_input(); + return _msg; } inline void SortRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete input_; } if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); if (message_arena != submessage_arena) { input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, input, submessage_arena); @@ -9500,8 +10169,9 @@ inline ::substrait::SortField* SortRel::_internal_add_sorts() { return sorts_.Add(); } inline ::substrait::SortField* SortRel::add_sorts() { + ::substrait::SortField* _add = _internal_add_sorts(); // @@protoc_insertion_point(field_add:substrait.SortRel.sorts) - return _internal_add_sorts(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& SortRel::sorts() const { @@ -9527,7 +10197,7 @@ inline const ::substrait::extensions::AdvancedExtension& SortRel::advanced_exten } inline void SortRel::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -9542,9 +10212,15 @@ inline ::substrait::extensions::AdvancedExtension* SortRel::release_advanced_ext ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* SortRel::unsafe_arena_release_advanced_extension() { @@ -9557,23 +10233,26 @@ inline ::substrait::extensions::AdvancedExtension* SortRel::unsafe_arena_release inline ::substrait::extensions::AdvancedExtension* SortRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* SortRel::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.SortRel.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void SortRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -9598,7 +10277,7 @@ inline bool FilterRel::has_common() const { return _internal_has_common(); } inline void FilterRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -9614,7 +10293,7 @@ inline const ::substrait::RelCommon& FilterRel::common() const { } inline void FilterRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -9629,9 +10308,15 @@ inline ::substrait::RelCommon* FilterRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* FilterRel::unsafe_arena_release_common() { @@ -9644,23 +10329,24 @@ inline ::substrait::RelCommon* FilterRel::unsafe_arena_release_common() { inline ::substrait::RelCommon* FilterRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* FilterRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.FilterRel.common) - return _internal_mutable_common(); + return _msg; } inline void FilterRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -9681,7 +10367,7 @@ inline bool FilterRel::has_input() const { return _internal_has_input(); } inline void FilterRel::clear_input() { - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; @@ -9697,7 +10383,7 @@ inline const ::substrait::Rel& FilterRel::input() const { } inline void FilterRel::unsafe_arena_set_allocated_input( ::substrait::Rel* input) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } input_ = input; @@ -9712,9 +10398,15 @@ inline ::substrait::Rel* FilterRel::release_input() { ::substrait::Rel* temp = input_; input_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Rel* FilterRel::unsafe_arena_release_input() { @@ -9727,23 +10419,24 @@ inline ::substrait::Rel* FilterRel::unsafe_arena_release_input() { inline ::substrait::Rel* FilterRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); input_ = p; } return input_; } inline ::substrait::Rel* FilterRel::mutable_input() { + ::substrait::Rel* _msg = _internal_mutable_input(); // @@protoc_insertion_point(field_mutable:substrait.FilterRel.input) - return _internal_mutable_input(); + return _msg; } inline void FilterRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete input_; } if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); if (message_arena != submessage_arena) { input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, input, submessage_arena); @@ -9774,7 +10467,7 @@ inline const ::substrait::Expression& FilterRel::condition() const { } inline void FilterRel::unsafe_arena_set_allocated_condition( ::substrait::Expression* condition) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); } condition_ = condition; @@ -9789,9 +10482,15 @@ inline ::substrait::Expression* FilterRel::release_condition() { ::substrait::Expression* temp = condition_; condition_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Expression* FilterRel::unsafe_arena_release_condition() { @@ -9804,23 +10503,26 @@ inline ::substrait::Expression* FilterRel::unsafe_arena_release_condition() { inline ::substrait::Expression* FilterRel::_internal_mutable_condition() { if (condition_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); condition_ = p; } return condition_; } inline ::substrait::Expression* FilterRel::mutable_condition() { + ::substrait::Expression* _msg = _internal_mutable_condition(); // @@protoc_insertion_point(field_mutable:substrait.FilterRel.condition) - return _internal_mutable_condition(); + return _msg; } inline void FilterRel::set_allocated_condition(::substrait::Expression* condition) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); } if (condition) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition)); if (message_arena != submessage_arena) { condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, condition, submessage_arena); @@ -9851,7 +10553,7 @@ inline const ::substrait::extensions::AdvancedExtension& FilterRel::advanced_ext } inline void FilterRel::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -9866,9 +10568,15 @@ inline ::substrait::extensions::AdvancedExtension* FilterRel::release_advanced_e ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* FilterRel::unsafe_arena_release_advanced_extension() { @@ -9881,23 +10589,26 @@ inline ::substrait::extensions::AdvancedExtension* FilterRel::unsafe_arena_relea inline ::substrait::extensions::AdvancedExtension* FilterRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* FilterRel::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.FilterRel.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void FilterRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -9922,7 +10633,7 @@ inline bool SetRel::has_common() const { return _internal_has_common(); } inline void SetRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -9938,7 +10649,7 @@ inline const ::substrait::RelCommon& SetRel::common() const { } inline void SetRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -9953,9 +10664,15 @@ inline ::substrait::RelCommon* SetRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* SetRel::unsafe_arena_release_common() { @@ -9968,23 +10685,24 @@ inline ::substrait::RelCommon* SetRel::unsafe_arena_release_common() { inline ::substrait::RelCommon* SetRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* SetRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.SetRel.common) - return _internal_mutable_common(); + return _msg; } inline void SetRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -10027,8 +10745,9 @@ inline ::substrait::Rel* SetRel::_internal_add_inputs() { return inputs_.Add(); } inline ::substrait::Rel* SetRel::add_inputs() { + ::substrait::Rel* _add = _internal_add_inputs(); // @@protoc_insertion_point(field_add:substrait.SetRel.inputs) - return _internal_add_inputs(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >& SetRel::inputs() const { @@ -10074,7 +10793,7 @@ inline const ::substrait::extensions::AdvancedExtension& SetRel::advanced_extens } inline void SetRel::unsafe_arena_set_allocated_advanced_extension( ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } advanced_extension_ = advanced_extension; @@ -10089,9 +10808,15 @@ inline ::substrait::extensions::AdvancedExtension* SetRel::release_advanced_exte ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; advanced_extension_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::extensions::AdvancedExtension* SetRel::unsafe_arena_release_advanced_extension() { @@ -10104,23 +10829,26 @@ inline ::substrait::extensions::AdvancedExtension* SetRel::unsafe_arena_release_ inline ::substrait::extensions::AdvancedExtension* SetRel::_internal_mutable_advanced_extension() { if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); advanced_extension_ = p; } return advanced_extension_; } inline ::substrait::extensions::AdvancedExtension* SetRel::mutable_advanced_extension() { + ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); // @@protoc_insertion_point(field_mutable:substrait.SetRel.advanced_extension) - return _internal_mutable_advanced_extension(); + return _msg; } inline void SetRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); } if (advanced_extension) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); if (message_arena != submessage_arena) { advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, advanced_extension, submessage_arena); @@ -10145,7 +10873,7 @@ inline bool ExtensionSingleRel::has_common() const { return _internal_has_common(); } inline void ExtensionSingleRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -10161,7 +10889,7 @@ inline const ::substrait::RelCommon& ExtensionSingleRel::common() const { } inline void ExtensionSingleRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -10176,9 +10904,15 @@ inline ::substrait::RelCommon* ExtensionSingleRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* ExtensionSingleRel::unsafe_arena_release_common() { @@ -10191,23 +10925,24 @@ inline ::substrait::RelCommon* ExtensionSingleRel::unsafe_arena_release_common() inline ::substrait::RelCommon* ExtensionSingleRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* ExtensionSingleRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.common) - return _internal_mutable_common(); + return _msg; } inline void ExtensionSingleRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -10228,7 +10963,7 @@ inline bool ExtensionSingleRel::has_input() const { return _internal_has_input(); } inline void ExtensionSingleRel::clear_input() { - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; @@ -10244,7 +10979,7 @@ inline const ::substrait::Rel& ExtensionSingleRel::input() const { } inline void ExtensionSingleRel::unsafe_arena_set_allocated_input( ::substrait::Rel* input) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } input_ = input; @@ -10259,9 +10994,15 @@ inline ::substrait::Rel* ExtensionSingleRel::release_input() { ::substrait::Rel* temp = input_; input_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Rel* ExtensionSingleRel::unsafe_arena_release_input() { @@ -10274,23 +11015,24 @@ inline ::substrait::Rel* ExtensionSingleRel::unsafe_arena_release_input() { inline ::substrait::Rel* ExtensionSingleRel::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); input_ = p; } return input_; } inline ::substrait::Rel* ExtensionSingleRel::mutable_input() { + ::substrait::Rel* _msg = _internal_mutable_input(); // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.input) - return _internal_mutable_input(); + return _msg; } inline void ExtensionSingleRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete input_; } if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); if (message_arena != submessage_arena) { input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, input, submessage_arena); @@ -10310,18 +11052,18 @@ inline bool ExtensionSingleRel::_internal_has_detail() const { inline bool ExtensionSingleRel::has_detail() const { return _internal_has_detail(); } -inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::_internal_detail() const { - const PROTOBUF_NAMESPACE_ID::Any* p = detail_; - return p != nullptr ? *p : reinterpret_cast( - PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::_internal_detail() const { + const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } -inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::detail() const { +inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::detail() const { // @@protoc_insertion_point(field_get:substrait.ExtensionSingleRel.detail) return _internal_detail(); } inline void ExtensionSingleRel::unsafe_arena_set_allocated_detail( - PROTOBUF_NAMESPACE_ID::Any* detail) { - if (GetArena() == nullptr) { + ::PROTOBUF_NAMESPACE_ID::Any* detail) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } detail_ = detail; @@ -10332,42 +11074,51 @@ inline void ExtensionSingleRel::unsafe_arena_set_allocated_detail( } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionSingleRel.detail) } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::release_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::release_detail() { - PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::unsafe_arena_release_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::unsafe_arena_release_detail() { // @@protoc_insertion_point(field_release:substrait.ExtensionSingleRel.detail) - PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::_internal_mutable_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::_internal_mutable_detail() { if (detail_ == nullptr) { - auto* p = CreateMaybeMessage(GetArena()); + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); detail_ = p; } return detail_; } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::mutable_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::mutable_detail() { + ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail(); // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.detail) - return _internal_mutable_detail(); + return _msg; } -inline void ExtensionSingleRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); +inline void ExtensionSingleRel::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } if (detail) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)); if (message_arena != submessage_arena) { detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, detail, submessage_arena); @@ -10392,7 +11143,7 @@ inline bool ExtensionLeafRel::has_common() const { return _internal_has_common(); } inline void ExtensionLeafRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -10408,7 +11159,7 @@ inline const ::substrait::RelCommon& ExtensionLeafRel::common() const { } inline void ExtensionLeafRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -10423,9 +11174,15 @@ inline ::substrait::RelCommon* ExtensionLeafRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* ExtensionLeafRel::unsafe_arena_release_common() { @@ -10438,23 +11195,24 @@ inline ::substrait::RelCommon* ExtensionLeafRel::unsafe_arena_release_common() { inline ::substrait::RelCommon* ExtensionLeafRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* ExtensionLeafRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.ExtensionLeafRel.common) - return _internal_mutable_common(); + return _msg; } inline void ExtensionLeafRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -10474,18 +11232,18 @@ inline bool ExtensionLeafRel::_internal_has_detail() const { inline bool ExtensionLeafRel::has_detail() const { return _internal_has_detail(); } -inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::_internal_detail() const { - const PROTOBUF_NAMESPACE_ID::Any* p = detail_; - return p != nullptr ? *p : reinterpret_cast( - PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::_internal_detail() const { + const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } -inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::detail() const { +inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::detail() const { // @@protoc_insertion_point(field_get:substrait.ExtensionLeafRel.detail) return _internal_detail(); } inline void ExtensionLeafRel::unsafe_arena_set_allocated_detail( - PROTOBUF_NAMESPACE_ID::Any* detail) { - if (GetArena() == nullptr) { + ::PROTOBUF_NAMESPACE_ID::Any* detail) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } detail_ = detail; @@ -10496,42 +11254,51 @@ inline void ExtensionLeafRel::unsafe_arena_set_allocated_detail( } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionLeafRel.detail) } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::release_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::release_detail() { - PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::unsafe_arena_release_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::unsafe_arena_release_detail() { // @@protoc_insertion_point(field_release:substrait.ExtensionLeafRel.detail) - PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::_internal_mutable_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::_internal_mutable_detail() { if (detail_ == nullptr) { - auto* p = CreateMaybeMessage(GetArena()); + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); detail_ = p; } return detail_; } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::mutable_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::mutable_detail() { + ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail(); // @@protoc_insertion_point(field_mutable:substrait.ExtensionLeafRel.detail) - return _internal_mutable_detail(); + return _msg; } -inline void ExtensionLeafRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); +inline void ExtensionLeafRel::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } if (detail) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)); if (message_arena != submessage_arena) { detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, detail, submessage_arena); @@ -10556,7 +11323,7 @@ inline bool ExtensionMultiRel::has_common() const { return _internal_has_common(); } inline void ExtensionMultiRel::clear_common() { - if (GetArena() == nullptr && common_ != nullptr) { + if (GetArenaForAllocation() == nullptr && common_ != nullptr) { delete common_; } common_ = nullptr; @@ -10572,7 +11339,7 @@ inline const ::substrait::RelCommon& ExtensionMultiRel::common() const { } inline void ExtensionMultiRel::unsafe_arena_set_allocated_common( ::substrait::RelCommon* common) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); } common_ = common; @@ -10587,9 +11354,15 @@ inline ::substrait::RelCommon* ExtensionMultiRel::release_common() { ::substrait::RelCommon* temp = common_; common_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::RelCommon* ExtensionMultiRel::unsafe_arena_release_common() { @@ -10602,23 +11375,24 @@ inline ::substrait::RelCommon* ExtensionMultiRel::unsafe_arena_release_common() inline ::substrait::RelCommon* ExtensionMultiRel::_internal_mutable_common() { if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); common_ = p; } return common_; } inline ::substrait::RelCommon* ExtensionMultiRel::mutable_common() { + ::substrait::RelCommon* _msg = _internal_mutable_common(); // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.common) - return _internal_mutable_common(); + return _msg; } inline void ExtensionMultiRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete common_; } if (common) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(common); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); if (message_arena != submessage_arena) { common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, common, submessage_arena); @@ -10661,8 +11435,9 @@ inline ::substrait::Rel* ExtensionMultiRel::_internal_add_inputs() { return inputs_.Add(); } inline ::substrait::Rel* ExtensionMultiRel::add_inputs() { + ::substrait::Rel* _add = _internal_add_inputs(); // @@protoc_insertion_point(field_add:substrait.ExtensionMultiRel.inputs) - return _internal_add_inputs(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >& ExtensionMultiRel::inputs() const { @@ -10677,18 +11452,18 @@ inline bool ExtensionMultiRel::_internal_has_detail() const { inline bool ExtensionMultiRel::has_detail() const { return _internal_has_detail(); } -inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::_internal_detail() const { - const PROTOBUF_NAMESPACE_ID::Any* p = detail_; - return p != nullptr ? *p : reinterpret_cast( - PROTOBUF_NAMESPACE_ID::_Any_default_instance_); +inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::_internal_detail() const { + const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_; + return p != nullptr ? *p : reinterpret_cast( + ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); } -inline const PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::detail() const { +inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::detail() const { // @@protoc_insertion_point(field_get:substrait.ExtensionMultiRel.detail) return _internal_detail(); } inline void ExtensionMultiRel::unsafe_arena_set_allocated_detail( - PROTOBUF_NAMESPACE_ID::Any* detail) { - if (GetArena() == nullptr) { + ::PROTOBUF_NAMESPACE_ID::Any* detail) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } detail_ = detail; @@ -10699,42 +11474,51 @@ inline void ExtensionMultiRel::unsafe_arena_set_allocated_detail( } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionMultiRel.detail) } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::release_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::release_detail() { - PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::unsafe_arena_release_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::unsafe_arena_release_detail() { // @@protoc_insertion_point(field_release:substrait.ExtensionMultiRel.detail) - PROTOBUF_NAMESPACE_ID::Any* temp = detail_; + ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; detail_ = nullptr; return temp; } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::_internal_mutable_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::_internal_mutable_detail() { if (detail_ == nullptr) { - auto* p = CreateMaybeMessage(GetArena()); + auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); detail_ = p; } return detail_; } -inline PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::mutable_detail() { +inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::mutable_detail() { + ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail(); // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.detail) - return _internal_mutable_detail(); + return _msg; } -inline void ExtensionMultiRel::set_allocated_detail(PROTOBUF_NAMESPACE_ID::Any* detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); +inline void ExtensionMultiRel::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); } if (detail) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)); if (message_arena != submessage_arena) { detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, detail, submessage_arena); @@ -10759,7 +11543,7 @@ inline bool RelRoot::has_input() const { return _internal_has_input(); } inline void RelRoot::clear_input() { - if (GetArena() == nullptr && input_ != nullptr) { + if (GetArenaForAllocation() == nullptr && input_ != nullptr) { delete input_; } input_ = nullptr; @@ -10775,7 +11559,7 @@ inline const ::substrait::Rel& RelRoot::input() const { } inline void RelRoot::unsafe_arena_set_allocated_input( ::substrait::Rel* input) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); } input_ = input; @@ -10790,9 +11574,15 @@ inline ::substrait::Rel* RelRoot::release_input() { ::substrait::Rel* temp = input_; input_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Rel* RelRoot::unsafe_arena_release_input() { @@ -10805,23 +11595,24 @@ inline ::substrait::Rel* RelRoot::unsafe_arena_release_input() { inline ::substrait::Rel* RelRoot::_internal_mutable_input() { if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); input_ = p; } return input_; } inline ::substrait::Rel* RelRoot::mutable_input() { + ::substrait::Rel* _msg = _internal_mutable_input(); // @@protoc_insertion_point(field_mutable:substrait.RelRoot.input) - return _internal_mutable_input(); + return _msg; } inline void RelRoot::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete input_; } if (input) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(input); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); if (message_arena != submessage_arena) { input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, input, submessage_arena); @@ -10845,8 +11636,9 @@ inline void RelRoot::clear_names() { names_.Clear(); } inline std::string* RelRoot::add_names() { + std::string* _s = _internal_add_names(); // @@protoc_insertion_point(field_add_mutable:substrait.RelRoot.names) - return _internal_add_names(); + return _s; } inline const std::string& RelRoot::_internal_names(int index) const { return names_.Get(index); @@ -10860,12 +11652,12 @@ inline std::string* RelRoot::mutable_names(int index) { return names_.Mutable(index); } inline void RelRoot::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.RelRoot.names) names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.RelRoot.names) } inline void RelRoot::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.RelRoot.names) names_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.RelRoot.names) } inline void RelRoot::set_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -10924,7 +11716,7 @@ inline void Rel::set_has_read() { } inline void Rel::clear_read() { if (_internal_has_read()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.read_; } clear_has_rel_type(); @@ -10935,7 +11727,7 @@ inline ::substrait::ReadRel* Rel::release_read() { if (_internal_has_read()) { clear_has_rel_type(); ::substrait::ReadRel* temp = rel_type_.read_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.read_ = nullptr; @@ -10976,13 +11768,14 @@ inline ::substrait::ReadRel* Rel::_internal_mutable_read() { if (!_internal_has_read()) { clear_rel_type(); set_has_read(); - rel_type_.read_ = CreateMaybeMessage< ::substrait::ReadRel >(GetArena()); + rel_type_.read_ = CreateMaybeMessage< ::substrait::ReadRel >(GetArenaForAllocation()); } return rel_type_.read_; } inline ::substrait::ReadRel* Rel::mutable_read() { + ::substrait::ReadRel* _msg = _internal_mutable_read(); // @@protoc_insertion_point(field_mutable:substrait.Rel.read) - return _internal_mutable_read(); + return _msg; } // .substrait.FilterRel filter = 2; @@ -10997,7 +11790,7 @@ inline void Rel::set_has_filter() { } inline void Rel::clear_filter() { if (_internal_has_filter()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.filter_; } clear_has_rel_type(); @@ -11008,7 +11801,7 @@ inline ::substrait::FilterRel* Rel::release_filter() { if (_internal_has_filter()) { clear_has_rel_type(); ::substrait::FilterRel* temp = rel_type_.filter_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.filter_ = nullptr; @@ -11049,13 +11842,14 @@ inline ::substrait::FilterRel* Rel::_internal_mutable_filter() { if (!_internal_has_filter()) { clear_rel_type(); set_has_filter(); - rel_type_.filter_ = CreateMaybeMessage< ::substrait::FilterRel >(GetArena()); + rel_type_.filter_ = CreateMaybeMessage< ::substrait::FilterRel >(GetArenaForAllocation()); } return rel_type_.filter_; } inline ::substrait::FilterRel* Rel::mutable_filter() { + ::substrait::FilterRel* _msg = _internal_mutable_filter(); // @@protoc_insertion_point(field_mutable:substrait.Rel.filter) - return _internal_mutable_filter(); + return _msg; } // .substrait.FetchRel fetch = 3; @@ -11070,7 +11864,7 @@ inline void Rel::set_has_fetch() { } inline void Rel::clear_fetch() { if (_internal_has_fetch()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.fetch_; } clear_has_rel_type(); @@ -11081,7 +11875,7 @@ inline ::substrait::FetchRel* Rel::release_fetch() { if (_internal_has_fetch()) { clear_has_rel_type(); ::substrait::FetchRel* temp = rel_type_.fetch_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.fetch_ = nullptr; @@ -11122,13 +11916,14 @@ inline ::substrait::FetchRel* Rel::_internal_mutable_fetch() { if (!_internal_has_fetch()) { clear_rel_type(); set_has_fetch(); - rel_type_.fetch_ = CreateMaybeMessage< ::substrait::FetchRel >(GetArena()); + rel_type_.fetch_ = CreateMaybeMessage< ::substrait::FetchRel >(GetArenaForAllocation()); } return rel_type_.fetch_; } inline ::substrait::FetchRel* Rel::mutable_fetch() { + ::substrait::FetchRel* _msg = _internal_mutable_fetch(); // @@protoc_insertion_point(field_mutable:substrait.Rel.fetch) - return _internal_mutable_fetch(); + return _msg; } // .substrait.AggregateRel aggregate = 4; @@ -11143,7 +11938,7 @@ inline void Rel::set_has_aggregate() { } inline void Rel::clear_aggregate() { if (_internal_has_aggregate()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.aggregate_; } clear_has_rel_type(); @@ -11154,7 +11949,7 @@ inline ::substrait::AggregateRel* Rel::release_aggregate() { if (_internal_has_aggregate()) { clear_has_rel_type(); ::substrait::AggregateRel* temp = rel_type_.aggregate_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.aggregate_ = nullptr; @@ -11195,13 +11990,14 @@ inline ::substrait::AggregateRel* Rel::_internal_mutable_aggregate() { if (!_internal_has_aggregate()) { clear_rel_type(); set_has_aggregate(); - rel_type_.aggregate_ = CreateMaybeMessage< ::substrait::AggregateRel >(GetArena()); + rel_type_.aggregate_ = CreateMaybeMessage< ::substrait::AggregateRel >(GetArenaForAllocation()); } return rel_type_.aggregate_; } inline ::substrait::AggregateRel* Rel::mutable_aggregate() { + ::substrait::AggregateRel* _msg = _internal_mutable_aggregate(); // @@protoc_insertion_point(field_mutable:substrait.Rel.aggregate) - return _internal_mutable_aggregate(); + return _msg; } // .substrait.SortRel sort = 5; @@ -11216,7 +12012,7 @@ inline void Rel::set_has_sort() { } inline void Rel::clear_sort() { if (_internal_has_sort()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.sort_; } clear_has_rel_type(); @@ -11227,7 +12023,7 @@ inline ::substrait::SortRel* Rel::release_sort() { if (_internal_has_sort()) { clear_has_rel_type(); ::substrait::SortRel* temp = rel_type_.sort_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.sort_ = nullptr; @@ -11268,13 +12064,14 @@ inline ::substrait::SortRel* Rel::_internal_mutable_sort() { if (!_internal_has_sort()) { clear_rel_type(); set_has_sort(); - rel_type_.sort_ = CreateMaybeMessage< ::substrait::SortRel >(GetArena()); + rel_type_.sort_ = CreateMaybeMessage< ::substrait::SortRel >(GetArenaForAllocation()); } return rel_type_.sort_; } inline ::substrait::SortRel* Rel::mutable_sort() { + ::substrait::SortRel* _msg = _internal_mutable_sort(); // @@protoc_insertion_point(field_mutable:substrait.Rel.sort) - return _internal_mutable_sort(); + return _msg; } // .substrait.JoinRel join = 6; @@ -11289,7 +12086,7 @@ inline void Rel::set_has_join() { } inline void Rel::clear_join() { if (_internal_has_join()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.join_; } clear_has_rel_type(); @@ -11300,7 +12097,7 @@ inline ::substrait::JoinRel* Rel::release_join() { if (_internal_has_join()) { clear_has_rel_type(); ::substrait::JoinRel* temp = rel_type_.join_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.join_ = nullptr; @@ -11341,13 +12138,14 @@ inline ::substrait::JoinRel* Rel::_internal_mutable_join() { if (!_internal_has_join()) { clear_rel_type(); set_has_join(); - rel_type_.join_ = CreateMaybeMessage< ::substrait::JoinRel >(GetArena()); + rel_type_.join_ = CreateMaybeMessage< ::substrait::JoinRel >(GetArenaForAllocation()); } return rel_type_.join_; } inline ::substrait::JoinRel* Rel::mutable_join() { + ::substrait::JoinRel* _msg = _internal_mutable_join(); // @@protoc_insertion_point(field_mutable:substrait.Rel.join) - return _internal_mutable_join(); + return _msg; } // .substrait.ProjectRel project = 7; @@ -11362,7 +12160,7 @@ inline void Rel::set_has_project() { } inline void Rel::clear_project() { if (_internal_has_project()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.project_; } clear_has_rel_type(); @@ -11373,7 +12171,7 @@ inline ::substrait::ProjectRel* Rel::release_project() { if (_internal_has_project()) { clear_has_rel_type(); ::substrait::ProjectRel* temp = rel_type_.project_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.project_ = nullptr; @@ -11414,13 +12212,14 @@ inline ::substrait::ProjectRel* Rel::_internal_mutable_project() { if (!_internal_has_project()) { clear_rel_type(); set_has_project(); - rel_type_.project_ = CreateMaybeMessage< ::substrait::ProjectRel >(GetArena()); + rel_type_.project_ = CreateMaybeMessage< ::substrait::ProjectRel >(GetArenaForAllocation()); } return rel_type_.project_; } inline ::substrait::ProjectRel* Rel::mutable_project() { + ::substrait::ProjectRel* _msg = _internal_mutable_project(); // @@protoc_insertion_point(field_mutable:substrait.Rel.project) - return _internal_mutable_project(); + return _msg; } // .substrait.SetRel set = 8; @@ -11435,7 +12234,7 @@ inline void Rel::set_has_set() { } inline void Rel::clear_set() { if (_internal_has_set()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.set_; } clear_has_rel_type(); @@ -11446,7 +12245,7 @@ inline ::substrait::SetRel* Rel::release_set() { if (_internal_has_set()) { clear_has_rel_type(); ::substrait::SetRel* temp = rel_type_.set_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.set_ = nullptr; @@ -11487,13 +12286,14 @@ inline ::substrait::SetRel* Rel::_internal_mutable_set() { if (!_internal_has_set()) { clear_rel_type(); set_has_set(); - rel_type_.set_ = CreateMaybeMessage< ::substrait::SetRel >(GetArena()); + rel_type_.set_ = CreateMaybeMessage< ::substrait::SetRel >(GetArenaForAllocation()); } return rel_type_.set_; } inline ::substrait::SetRel* Rel::mutable_set() { + ::substrait::SetRel* _msg = _internal_mutable_set(); // @@protoc_insertion_point(field_mutable:substrait.Rel.set) - return _internal_mutable_set(); + return _msg; } // .substrait.ExtensionSingleRel extension_single = 9; @@ -11508,7 +12308,7 @@ inline void Rel::set_has_extension_single() { } inline void Rel::clear_extension_single() { if (_internal_has_extension_single()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.extension_single_; } clear_has_rel_type(); @@ -11519,7 +12319,7 @@ inline ::substrait::ExtensionSingleRel* Rel::release_extension_single() { if (_internal_has_extension_single()) { clear_has_rel_type(); ::substrait::ExtensionSingleRel* temp = rel_type_.extension_single_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.extension_single_ = nullptr; @@ -11560,13 +12360,14 @@ inline ::substrait::ExtensionSingleRel* Rel::_internal_mutable_extension_single( if (!_internal_has_extension_single()) { clear_rel_type(); set_has_extension_single(); - rel_type_.extension_single_ = CreateMaybeMessage< ::substrait::ExtensionSingleRel >(GetArena()); + rel_type_.extension_single_ = CreateMaybeMessage< ::substrait::ExtensionSingleRel >(GetArenaForAllocation()); } return rel_type_.extension_single_; } inline ::substrait::ExtensionSingleRel* Rel::mutable_extension_single() { + ::substrait::ExtensionSingleRel* _msg = _internal_mutable_extension_single(); // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_single) - return _internal_mutable_extension_single(); + return _msg; } // .substrait.ExtensionMultiRel extension_multi = 10; @@ -11581,7 +12382,7 @@ inline void Rel::set_has_extension_multi() { } inline void Rel::clear_extension_multi() { if (_internal_has_extension_multi()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.extension_multi_; } clear_has_rel_type(); @@ -11592,7 +12393,7 @@ inline ::substrait::ExtensionMultiRel* Rel::release_extension_multi() { if (_internal_has_extension_multi()) { clear_has_rel_type(); ::substrait::ExtensionMultiRel* temp = rel_type_.extension_multi_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.extension_multi_ = nullptr; @@ -11633,13 +12434,14 @@ inline ::substrait::ExtensionMultiRel* Rel::_internal_mutable_extension_multi() if (!_internal_has_extension_multi()) { clear_rel_type(); set_has_extension_multi(); - rel_type_.extension_multi_ = CreateMaybeMessage< ::substrait::ExtensionMultiRel >(GetArena()); + rel_type_.extension_multi_ = CreateMaybeMessage< ::substrait::ExtensionMultiRel >(GetArenaForAllocation()); } return rel_type_.extension_multi_; } inline ::substrait::ExtensionMultiRel* Rel::mutable_extension_multi() { + ::substrait::ExtensionMultiRel* _msg = _internal_mutable_extension_multi(); // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_multi) - return _internal_mutable_extension_multi(); + return _msg; } // .substrait.ExtensionLeafRel extension_leaf = 11; @@ -11654,7 +12456,7 @@ inline void Rel::set_has_extension_leaf() { } inline void Rel::clear_extension_leaf() { if (_internal_has_extension_leaf()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete rel_type_.extension_leaf_; } clear_has_rel_type(); @@ -11665,7 +12467,7 @@ inline ::substrait::ExtensionLeafRel* Rel::release_extension_leaf() { if (_internal_has_extension_leaf()) { clear_has_rel_type(); ::substrait::ExtensionLeafRel* temp = rel_type_.extension_leaf_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } rel_type_.extension_leaf_ = nullptr; @@ -11706,13 +12508,14 @@ inline ::substrait::ExtensionLeafRel* Rel::_internal_mutable_extension_leaf() { if (!_internal_has_extension_leaf()) { clear_rel_type(); set_has_extension_leaf(); - rel_type_.extension_leaf_ = CreateMaybeMessage< ::substrait::ExtensionLeafRel >(GetArena()); + rel_type_.extension_leaf_ = CreateMaybeMessage< ::substrait::ExtensionLeafRel >(GetArenaForAllocation()); } return rel_type_.extension_leaf_; } inline ::substrait::ExtensionLeafRel* Rel::mutable_extension_leaf() { + ::substrait::ExtensionLeafRel* _msg = _internal_mutable_extension_leaf(); // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_leaf) - return _internal_mutable_extension_leaf(); + return _msg; } inline bool Rel::has_rel_type() const { diff --git a/cpp/src/generated/substrait/type.pb.cc b/cpp/src/generated/substrait/type.pb.cc index 4f567b5d0a8..5bb5b015941 100644 --- a/cpp/src/generated/substrait/type.pb.cc +++ b/cpp/src/generated/substrait/type.pb.cc @@ -378,12 +378,13 @@ static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ftype_2e static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ftype_2eproto[1]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ftype_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const uint32_t TableStruct_substrait_2ftype_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, nullability_), ~0u, // no _has_bits_ @@ -391,6 +392,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, nullability_), ~0u, // no _has_bits_ @@ -398,6 +400,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, nullability_), ~0u, // no _has_bits_ @@ -405,6 +408,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, nullability_), ~0u, // no _has_bits_ @@ -412,6 +416,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, nullability_), ~0u, // no _has_bits_ @@ -419,6 +424,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, nullability_), ~0u, // no _has_bits_ @@ -426,6 +432,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, nullability_), ~0u, // no _has_bits_ @@ -433,6 +440,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_String, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_String, nullability_), ~0u, // no _has_bits_ @@ -440,6 +448,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, nullability_), ~0u, // no _has_bits_ @@ -447,6 +456,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, nullability_), ~0u, // no _has_bits_ @@ -454,6 +464,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, nullability_), ~0u, // no _has_bits_ @@ -461,6 +472,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, nullability_), ~0u, // no _has_bits_ @@ -468,6 +480,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, nullability_), ~0u, // no _has_bits_ @@ -475,6 +488,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, nullability_), ~0u, // no _has_bits_ @@ -482,6 +496,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, nullability_), ~0u, // no _has_bits_ @@ -489,6 +504,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, nullability_), ~0u, // no _has_bits_ @@ -496,6 +512,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, length_), PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, nullability_), @@ -504,6 +521,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, length_), PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, nullability_), @@ -512,6 +530,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, length_), PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, nullability_), @@ -520,6 +539,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, scale_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, precision_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, type_variation_reference_), @@ -529,6 +549,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, types_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, nullability_), @@ -537,6 +558,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_List, type_), PROTOBUF_FIELD_OFFSET(::substrait::Type_List, type_variation_reference_), PROTOBUF_FIELD_OFFSET(::substrait::Type_List, nullability_), @@ -545,6 +567,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, key_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, value_), PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, type_variation_reference_), @@ -554,6 +577,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::Type, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -584,35 +608,36 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_2eproto::offs ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, names_), PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, struct__), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::substrait::Type_Boolean)}, - { 7, -1, sizeof(::substrait::Type_I8)}, - { 14, -1, sizeof(::substrait::Type_I16)}, - { 21, -1, sizeof(::substrait::Type_I32)}, - { 28, -1, sizeof(::substrait::Type_I64)}, - { 35, -1, sizeof(::substrait::Type_FP32)}, - { 42, -1, sizeof(::substrait::Type_FP64)}, - { 49, -1, sizeof(::substrait::Type_String)}, - { 56, -1, sizeof(::substrait::Type_Binary)}, - { 63, -1, sizeof(::substrait::Type_Timestamp)}, - { 70, -1, sizeof(::substrait::Type_Date)}, - { 77, -1, sizeof(::substrait::Type_Time)}, - { 84, -1, sizeof(::substrait::Type_TimestampTZ)}, - { 91, -1, sizeof(::substrait::Type_IntervalYear)}, - { 98, -1, sizeof(::substrait::Type_IntervalDay)}, - { 105, -1, sizeof(::substrait::Type_UUID)}, - { 112, -1, sizeof(::substrait::Type_FixedChar)}, - { 120, -1, sizeof(::substrait::Type_VarChar)}, - { 128, -1, sizeof(::substrait::Type_FixedBinary)}, - { 136, -1, sizeof(::substrait::Type_Decimal)}, - { 145, -1, sizeof(::substrait::Type_Struct)}, - { 153, -1, sizeof(::substrait::Type_List)}, - { 161, -1, sizeof(::substrait::Type_Map)}, - { 170, -1, sizeof(::substrait::Type)}, - { 200, -1, sizeof(::substrait::NamedStruct)}, + { 0, -1, -1, sizeof(::substrait::Type_Boolean)}, + { 8, -1, -1, sizeof(::substrait::Type_I8)}, + { 16, -1, -1, sizeof(::substrait::Type_I16)}, + { 24, -1, -1, sizeof(::substrait::Type_I32)}, + { 32, -1, -1, sizeof(::substrait::Type_I64)}, + { 40, -1, -1, sizeof(::substrait::Type_FP32)}, + { 48, -1, -1, sizeof(::substrait::Type_FP64)}, + { 56, -1, -1, sizeof(::substrait::Type_String)}, + { 64, -1, -1, sizeof(::substrait::Type_Binary)}, + { 72, -1, -1, sizeof(::substrait::Type_Timestamp)}, + { 80, -1, -1, sizeof(::substrait::Type_Date)}, + { 88, -1, -1, sizeof(::substrait::Type_Time)}, + { 96, -1, -1, sizeof(::substrait::Type_TimestampTZ)}, + { 104, -1, -1, sizeof(::substrait::Type_IntervalYear)}, + { 112, -1, -1, sizeof(::substrait::Type_IntervalDay)}, + { 120, -1, -1, sizeof(::substrait::Type_UUID)}, + { 128, -1, -1, sizeof(::substrait::Type_FixedChar)}, + { 137, -1, -1, sizeof(::substrait::Type_VarChar)}, + { 146, -1, -1, sizeof(::substrait::Type_FixedBinary)}, + { 155, -1, -1, sizeof(::substrait::Type_Decimal)}, + { 165, -1, -1, sizeof(::substrait::Type_Struct)}, + { 174, -1, -1, sizeof(::substrait::Type_List)}, + { 183, -1, -1, sizeof(::substrait::Type_Map)}, + { 193, -1, -1, sizeof(::substrait::Type)}, + { 224, -1, -1, sizeof(::substrait::NamedStruct)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -766,14 +791,14 @@ bool Type_Nullability_IsValid(int value) { } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr Type_Nullability Type::NULLABILITY_UNSPECIFIED; constexpr Type_Nullability Type::NULLABILITY_NULLABLE; constexpr Type_Nullability Type::NULLABILITY_REQUIRED; constexpr Type_Nullability Type::Nullability_MIN; constexpr Type_Nullability Type::Nullability_MAX; constexpr int Type::Nullability_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) // =================================================================== @@ -781,10 +806,13 @@ class Type_Boolean::_Internal { public: }; -Type_Boolean::Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_Boolean::Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.Boolean) } Type_Boolean::Type_Boolean(const Type_Boolean& from) @@ -796,7 +824,7 @@ Type_Boolean::Type_Boolean(const Type_Boolean& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.Boolean) } -void Type_Boolean::SharedCtor() { +inline void Type_Boolean::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -805,12 +833,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_Boolean::~Type_Boolean() { // @@protoc_insertion_point(destructor:substrait.Type.Boolean) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_Boolean::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_Boolean::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_Boolean::ArenaDtor(void* object) { @@ -825,7 +854,7 @@ void Type_Boolean::SetCachedSize(int size) const { void Type_Boolean::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.Boolean) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -838,61 +867,63 @@ void Type_Boolean::Clear() { const char* Type_Boolean::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_Boolean::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_Boolean::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Boolean) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -910,67 +941,50 @@ size_t Type_Boolean::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.Boolean) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_Boolean::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Boolean) - GOOGLE_DCHECK_NE(&from, this); - const Type_Boolean* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Boolean) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Boolean) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Boolean::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_Boolean::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Boolean::GetClassData() const { return &_class_data_; } + +void Type_Boolean::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_Boolean::MergeFrom(const Type_Boolean& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Boolean) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_Boolean::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Boolean) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_Boolean::CopyFrom(const Type_Boolean& from) { @@ -986,7 +1000,7 @@ bool Type_Boolean::IsInitialized() const { void Type_Boolean::InternalSwap(Type_Boolean* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Boolean, nullability_) + sizeof(Type_Boolean::nullability_) @@ -1007,10 +1021,13 @@ class Type_I8::_Internal { public: }; -Type_I8::Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_I8::Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.I8) } Type_I8::Type_I8(const Type_I8& from) @@ -1022,7 +1039,7 @@ Type_I8::Type_I8(const Type_I8& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.I8) } -void Type_I8::SharedCtor() { +inline void Type_I8::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1031,12 +1048,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_I8::~Type_I8() { // @@protoc_insertion_point(destructor:substrait.Type.I8) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_I8::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_I8::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_I8::ArenaDtor(void* object) { @@ -1051,7 +1069,7 @@ void Type_I8::SetCachedSize(int size) const { void Type_I8::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.I8) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1064,61 +1082,63 @@ void Type_I8::Clear() { const char* Type_I8::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_I8::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_I8::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I8) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -1136,67 +1156,50 @@ size_t Type_I8::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.I8) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_I8::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.I8) - GOOGLE_DCHECK_NE(&from, this); - const Type_I8* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.I8) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.I8) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I8::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_I8::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I8::GetClassData() const { return &_class_data_; } + +void Type_I8::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_I8::MergeFrom(const Type_I8& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I8) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_I8::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.I8) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_I8::CopyFrom(const Type_I8& from) { @@ -1212,7 +1215,7 @@ bool Type_I8::IsInitialized() const { void Type_I8::InternalSwap(Type_I8* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_I8, nullability_) + sizeof(Type_I8::nullability_) @@ -1233,10 +1236,13 @@ class Type_I16::_Internal { public: }; -Type_I16::Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_I16::Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.I16) } Type_I16::Type_I16(const Type_I16& from) @@ -1248,7 +1254,7 @@ Type_I16::Type_I16(const Type_I16& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.I16) } -void Type_I16::SharedCtor() { +inline void Type_I16::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1257,12 +1263,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_I16::~Type_I16() { // @@protoc_insertion_point(destructor:substrait.Type.I16) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_I16::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_I16::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_I16::ArenaDtor(void* object) { @@ -1277,7 +1284,7 @@ void Type_I16::SetCachedSize(int size) const { void Type_I16::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.I16) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1290,61 +1297,63 @@ void Type_I16::Clear() { const char* Type_I16::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_I16::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_I16::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I16) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -1362,67 +1371,50 @@ size_t Type_I16::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.I16) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_I16::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.I16) - GOOGLE_DCHECK_NE(&from, this); - const Type_I16* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.I16) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.I16) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I16::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_I16::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I16::GetClassData() const { return &_class_data_; } + +void Type_I16::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_I16::MergeFrom(const Type_I16& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I16) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_I16::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.I16) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_I16::CopyFrom(const Type_I16& from) { @@ -1438,7 +1430,7 @@ bool Type_I16::IsInitialized() const { void Type_I16::InternalSwap(Type_I16* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_I16, nullability_) + sizeof(Type_I16::nullability_) @@ -1459,10 +1451,13 @@ class Type_I32::_Internal { public: }; -Type_I32::Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_I32::Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.I32) } Type_I32::Type_I32(const Type_I32& from) @@ -1474,7 +1469,7 @@ Type_I32::Type_I32(const Type_I32& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.I32) } -void Type_I32::SharedCtor() { +inline void Type_I32::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1483,12 +1478,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_I32::~Type_I32() { // @@protoc_insertion_point(destructor:substrait.Type.I32) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_I32::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_I32::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_I32::ArenaDtor(void* object) { @@ -1503,7 +1499,7 @@ void Type_I32::SetCachedSize(int size) const { void Type_I32::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.I32) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1516,61 +1512,63 @@ void Type_I32::Clear() { const char* Type_I32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_I32::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_I32::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I32) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -1588,67 +1586,50 @@ size_t Type_I32::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.I32) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_I32::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.I32) - GOOGLE_DCHECK_NE(&from, this); - const Type_I32* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.I32) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.I32) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I32::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_I32::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I32::GetClassData() const { return &_class_data_; } + +void Type_I32::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_I32::MergeFrom(const Type_I32& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I32) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_I32::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.I32) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_I32::CopyFrom(const Type_I32& from) { @@ -1664,7 +1645,7 @@ bool Type_I32::IsInitialized() const { void Type_I32::InternalSwap(Type_I32* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_I32, nullability_) + sizeof(Type_I32::nullability_) @@ -1685,10 +1666,13 @@ class Type_I64::_Internal { public: }; -Type_I64::Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_I64::Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.I64) } Type_I64::Type_I64(const Type_I64& from) @@ -1700,7 +1684,7 @@ Type_I64::Type_I64(const Type_I64& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.I64) } -void Type_I64::SharedCtor() { +inline void Type_I64::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1709,12 +1693,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_I64::~Type_I64() { // @@protoc_insertion_point(destructor:substrait.Type.I64) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_I64::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_I64::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_I64::ArenaDtor(void* object) { @@ -1729,7 +1714,7 @@ void Type_I64::SetCachedSize(int size) const { void Type_I64::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.I64) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1742,61 +1727,63 @@ void Type_I64::Clear() { const char* Type_I64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_I64::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_I64::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I64) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -1814,67 +1801,50 @@ size_t Type_I64::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.I64) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_I64::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.I64) - GOOGLE_DCHECK_NE(&from, this); - const Type_I64* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.I64) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.I64) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I64::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_I64::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I64::GetClassData() const { return &_class_data_; } + +void Type_I64::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_I64::MergeFrom(const Type_I64& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I64) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_I64::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.I64) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_I64::CopyFrom(const Type_I64& from) { @@ -1890,7 +1860,7 @@ bool Type_I64::IsInitialized() const { void Type_I64::InternalSwap(Type_I64* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_I64, nullability_) + sizeof(Type_I64::nullability_) @@ -1911,10 +1881,13 @@ class Type_FP32::_Internal { public: }; -Type_FP32::Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_FP32::Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.FP32) } Type_FP32::Type_FP32(const Type_FP32& from) @@ -1926,7 +1899,7 @@ Type_FP32::Type_FP32(const Type_FP32& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.FP32) } -void Type_FP32::SharedCtor() { +inline void Type_FP32::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1935,12 +1908,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_FP32::~Type_FP32() { // @@protoc_insertion_point(destructor:substrait.Type.FP32) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_FP32::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_FP32::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_FP32::ArenaDtor(void* object) { @@ -1955,7 +1929,7 @@ void Type_FP32::SetCachedSize(int size) const { void Type_FP32::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.FP32) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1968,61 +1942,63 @@ void Type_FP32::Clear() { const char* Type_FP32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_FP32::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_FP32::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FP32) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -2040,67 +2016,50 @@ size_t Type_FP32::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.FP32) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_FP32::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.FP32) - GOOGLE_DCHECK_NE(&from, this); - const Type_FP32* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.FP32) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.FP32) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FP32::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_FP32::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FP32::GetClassData() const { return &_class_data_; } + +void Type_FP32::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_FP32::MergeFrom(const Type_FP32& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FP32) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_FP32::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.FP32) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_FP32::CopyFrom(const Type_FP32& from) { @@ -2116,7 +2075,7 @@ bool Type_FP32::IsInitialized() const { void Type_FP32::InternalSwap(Type_FP32* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_FP32, nullability_) + sizeof(Type_FP32::nullability_) @@ -2137,10 +2096,13 @@ class Type_FP64::_Internal { public: }; -Type_FP64::Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_FP64::Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.FP64) } Type_FP64::Type_FP64(const Type_FP64& from) @@ -2152,7 +2114,7 @@ Type_FP64::Type_FP64(const Type_FP64& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.FP64) } -void Type_FP64::SharedCtor() { +inline void Type_FP64::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -2161,12 +2123,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_FP64::~Type_FP64() { // @@protoc_insertion_point(destructor:substrait.Type.FP64) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_FP64::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_FP64::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_FP64::ArenaDtor(void* object) { @@ -2181,7 +2144,7 @@ void Type_FP64::SetCachedSize(int size) const { void Type_FP64::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.FP64) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2194,61 +2157,63 @@ void Type_FP64::Clear() { const char* Type_FP64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_FP64::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_FP64::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FP64) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -2266,67 +2231,50 @@ size_t Type_FP64::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.FP64) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_FP64::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.FP64) - GOOGLE_DCHECK_NE(&from, this); - const Type_FP64* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.FP64) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.FP64) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FP64::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_FP64::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FP64::GetClassData() const { return &_class_data_; } + +void Type_FP64::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_FP64::MergeFrom(const Type_FP64& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FP64) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_FP64::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.FP64) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_FP64::CopyFrom(const Type_FP64& from) { @@ -2342,7 +2290,7 @@ bool Type_FP64::IsInitialized() const { void Type_FP64::InternalSwap(Type_FP64* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_FP64, nullability_) + sizeof(Type_FP64::nullability_) @@ -2363,10 +2311,13 @@ class Type_String::_Internal { public: }; -Type_String::Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_String::Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.String) } Type_String::Type_String(const Type_String& from) @@ -2378,7 +2329,7 @@ Type_String::Type_String(const Type_String& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.String) } -void Type_String::SharedCtor() { +inline void Type_String::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -2387,12 +2338,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_String::~Type_String() { // @@protoc_insertion_point(destructor:substrait.Type.String) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_String::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_String::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_String::ArenaDtor(void* object) { @@ -2407,7 +2359,7 @@ void Type_String::SetCachedSize(int size) const { void Type_String::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.String) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2420,61 +2372,63 @@ void Type_String::Clear() { const char* Type_String::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_String::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_String::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.String) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -2492,67 +2446,50 @@ size_t Type_String::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.String) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_String::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.String) - GOOGLE_DCHECK_NE(&from, this); - const Type_String* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.String) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.String) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_String::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_String::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_String::GetClassData() const { return &_class_data_; } + +void Type_String::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_String::MergeFrom(const Type_String& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.String) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_String::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.String) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_String::CopyFrom(const Type_String& from) { @@ -2568,7 +2505,7 @@ bool Type_String::IsInitialized() const { void Type_String::InternalSwap(Type_String* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_String, nullability_) + sizeof(Type_String::nullability_) @@ -2589,10 +2526,13 @@ class Type_Binary::_Internal { public: }; -Type_Binary::Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_Binary::Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.Binary) } Type_Binary::Type_Binary(const Type_Binary& from) @@ -2604,7 +2544,7 @@ Type_Binary::Type_Binary(const Type_Binary& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.Binary) } -void Type_Binary::SharedCtor() { +inline void Type_Binary::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -2613,12 +2553,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_Binary::~Type_Binary() { // @@protoc_insertion_point(destructor:substrait.Type.Binary) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_Binary::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_Binary::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_Binary::ArenaDtor(void* object) { @@ -2633,7 +2574,7 @@ void Type_Binary::SetCachedSize(int size) const { void Type_Binary::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.Binary) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2646,61 +2587,63 @@ void Type_Binary::Clear() { const char* Type_Binary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_Binary::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_Binary::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Binary) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -2718,67 +2661,50 @@ size_t Type_Binary::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.Binary) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_Binary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Binary) - GOOGLE_DCHECK_NE(&from, this); - const Type_Binary* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Binary) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Binary) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Binary::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_Binary::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Binary::GetClassData() const { return &_class_data_; } + +void Type_Binary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_Binary::MergeFrom(const Type_Binary& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Binary) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_Binary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Binary) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_Binary::CopyFrom(const Type_Binary& from) { @@ -2794,7 +2720,7 @@ bool Type_Binary::IsInitialized() const { void Type_Binary::InternalSwap(Type_Binary* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Binary, nullability_) + sizeof(Type_Binary::nullability_) @@ -2815,10 +2741,13 @@ class Type_Timestamp::_Internal { public: }; -Type_Timestamp::Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_Timestamp::Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.Timestamp) } Type_Timestamp::Type_Timestamp(const Type_Timestamp& from) @@ -2830,7 +2759,7 @@ Type_Timestamp::Type_Timestamp(const Type_Timestamp& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.Timestamp) } -void Type_Timestamp::SharedCtor() { +inline void Type_Timestamp::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -2839,12 +2768,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_Timestamp::~Type_Timestamp() { // @@protoc_insertion_point(destructor:substrait.Type.Timestamp) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_Timestamp::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_Timestamp::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_Timestamp::ArenaDtor(void* object) { @@ -2859,7 +2789,7 @@ void Type_Timestamp::SetCachedSize(int size) const { void Type_Timestamp::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.Timestamp) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2872,61 +2802,63 @@ void Type_Timestamp::Clear() { const char* Type_Timestamp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_Timestamp::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_Timestamp::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Timestamp) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -2944,67 +2876,50 @@ size_t Type_Timestamp::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.Timestamp) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_Timestamp::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Timestamp) - GOOGLE_DCHECK_NE(&from, this); - const Type_Timestamp* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Timestamp) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Timestamp) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Timestamp::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_Timestamp::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Timestamp::GetClassData() const { return &_class_data_; } + +void Type_Timestamp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_Timestamp::MergeFrom(const Type_Timestamp& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Timestamp) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_Timestamp::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Timestamp) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_Timestamp::CopyFrom(const Type_Timestamp& from) { @@ -3020,7 +2935,7 @@ bool Type_Timestamp::IsInitialized() const { void Type_Timestamp::InternalSwap(Type_Timestamp* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Timestamp, nullability_) + sizeof(Type_Timestamp::nullability_) @@ -3041,10 +2956,13 @@ class Type_Date::_Internal { public: }; -Type_Date::Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_Date::Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.Date) } Type_Date::Type_Date(const Type_Date& from) @@ -3056,7 +2974,7 @@ Type_Date::Type_Date(const Type_Date& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.Date) } -void Type_Date::SharedCtor() { +inline void Type_Date::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -3065,12 +2983,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_Date::~Type_Date() { // @@protoc_insertion_point(destructor:substrait.Type.Date) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_Date::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_Date::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_Date::ArenaDtor(void* object) { @@ -3085,7 +3004,7 @@ void Type_Date::SetCachedSize(int size) const { void Type_Date::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.Date) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3098,61 +3017,63 @@ void Type_Date::Clear() { const char* Type_Date::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_Date::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_Date::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Date) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -3170,67 +3091,50 @@ size_t Type_Date::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.Date) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_Date::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Date) - GOOGLE_DCHECK_NE(&from, this); - const Type_Date* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Date) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Date) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Date::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_Date::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Date::GetClassData() const { return &_class_data_; } + +void Type_Date::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_Date::MergeFrom(const Type_Date& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Date) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_Date::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Date) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_Date::CopyFrom(const Type_Date& from) { @@ -3246,7 +3150,7 @@ bool Type_Date::IsInitialized() const { void Type_Date::InternalSwap(Type_Date* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Date, nullability_) + sizeof(Type_Date::nullability_) @@ -3267,10 +3171,13 @@ class Type_Time::_Internal { public: }; -Type_Time::Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_Time::Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.Time) } Type_Time::Type_Time(const Type_Time& from) @@ -3282,7 +3189,7 @@ Type_Time::Type_Time(const Type_Time& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.Time) } -void Type_Time::SharedCtor() { +inline void Type_Time::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -3291,12 +3198,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_Time::~Type_Time() { // @@protoc_insertion_point(destructor:substrait.Type.Time) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_Time::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_Time::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_Time::ArenaDtor(void* object) { @@ -3311,7 +3219,7 @@ void Type_Time::SetCachedSize(int size) const { void Type_Time::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.Time) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3324,61 +3232,63 @@ void Type_Time::Clear() { const char* Type_Time::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_Time::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_Time::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Time) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -3396,67 +3306,50 @@ size_t Type_Time::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.Time) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_Time::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Time) - GOOGLE_DCHECK_NE(&from, this); - const Type_Time* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Time) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Time) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Time::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_Time::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Time::GetClassData() const { return &_class_data_; } + +void Type_Time::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_Time::MergeFrom(const Type_Time& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Time) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_Time::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Time) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_Time::CopyFrom(const Type_Time& from) { @@ -3472,7 +3365,7 @@ bool Type_Time::IsInitialized() const { void Type_Time::InternalSwap(Type_Time* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Time, nullability_) + sizeof(Type_Time::nullability_) @@ -3493,10 +3386,13 @@ class Type_TimestampTZ::_Internal { public: }; -Type_TimestampTZ::Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_TimestampTZ::Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.TimestampTZ) } Type_TimestampTZ::Type_TimestampTZ(const Type_TimestampTZ& from) @@ -3508,7 +3404,7 @@ Type_TimestampTZ::Type_TimestampTZ(const Type_TimestampTZ& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.TimestampTZ) } -void Type_TimestampTZ::SharedCtor() { +inline void Type_TimestampTZ::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -3517,12 +3413,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_TimestampTZ::~Type_TimestampTZ() { // @@protoc_insertion_point(destructor:substrait.Type.TimestampTZ) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_TimestampTZ::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_TimestampTZ::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_TimestampTZ::ArenaDtor(void* object) { @@ -3537,7 +3434,7 @@ void Type_TimestampTZ::SetCachedSize(int size) const { void Type_TimestampTZ::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.TimestampTZ) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3550,61 +3447,63 @@ void Type_TimestampTZ::Clear() { const char* Type_TimestampTZ::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_TimestampTZ::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_TimestampTZ::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.TimestampTZ) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -3622,67 +3521,50 @@ size_t Type_TimestampTZ::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.TimestampTZ) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_TimestampTZ::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.TimestampTZ) - GOOGLE_DCHECK_NE(&from, this); - const Type_TimestampTZ* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.TimestampTZ) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.TimestampTZ) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_TimestampTZ::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_TimestampTZ::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_TimestampTZ::GetClassData() const { return &_class_data_; } + +void Type_TimestampTZ::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_TimestampTZ::MergeFrom(const Type_TimestampTZ& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.TimestampTZ) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_TimestampTZ::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.TimestampTZ) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_TimestampTZ::CopyFrom(const Type_TimestampTZ& from) { @@ -3698,7 +3580,7 @@ bool Type_TimestampTZ::IsInitialized() const { void Type_TimestampTZ::InternalSwap(Type_TimestampTZ* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_TimestampTZ, nullability_) + sizeof(Type_TimestampTZ::nullability_) @@ -3719,10 +3601,13 @@ class Type_IntervalYear::_Internal { public: }; -Type_IntervalYear::Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_IntervalYear::Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.IntervalYear) } Type_IntervalYear::Type_IntervalYear(const Type_IntervalYear& from) @@ -3734,7 +3619,7 @@ Type_IntervalYear::Type_IntervalYear(const Type_IntervalYear& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.IntervalYear) } -void Type_IntervalYear::SharedCtor() { +inline void Type_IntervalYear::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -3743,12 +3628,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_IntervalYear::~Type_IntervalYear() { // @@protoc_insertion_point(destructor:substrait.Type.IntervalYear) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_IntervalYear::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_IntervalYear::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_IntervalYear::ArenaDtor(void* object) { @@ -3763,7 +3649,7 @@ void Type_IntervalYear::SetCachedSize(int size) const { void Type_IntervalYear::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.IntervalYear) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3776,61 +3662,63 @@ void Type_IntervalYear::Clear() { const char* Type_IntervalYear::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalYear::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_IntervalYear::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.IntervalYear) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -3848,67 +3736,50 @@ size_t Type_IntervalYear::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.IntervalYear) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_IntervalYear::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.IntervalYear) - GOOGLE_DCHECK_NE(&from, this); - const Type_IntervalYear* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.IntervalYear) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.IntervalYear) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_IntervalYear::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_IntervalYear::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_IntervalYear::GetClassData() const { return &_class_data_; } + +void Type_IntervalYear::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_IntervalYear::MergeFrom(const Type_IntervalYear& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.IntervalYear) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_IntervalYear::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.IntervalYear) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_IntervalYear::CopyFrom(const Type_IntervalYear& from) { @@ -3924,7 +3795,7 @@ bool Type_IntervalYear::IsInitialized() const { void Type_IntervalYear::InternalSwap(Type_IntervalYear* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_IntervalYear, nullability_) + sizeof(Type_IntervalYear::nullability_) @@ -3945,10 +3816,13 @@ class Type_IntervalDay::_Internal { public: }; -Type_IntervalDay::Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_IntervalDay::Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.IntervalDay) } Type_IntervalDay::Type_IntervalDay(const Type_IntervalDay& from) @@ -3960,7 +3834,7 @@ Type_IntervalDay::Type_IntervalDay(const Type_IntervalDay& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.IntervalDay) } -void Type_IntervalDay::SharedCtor() { +inline void Type_IntervalDay::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -3969,12 +3843,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_IntervalDay::~Type_IntervalDay() { // @@protoc_insertion_point(destructor:substrait.Type.IntervalDay) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_IntervalDay::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_IntervalDay::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_IntervalDay::ArenaDtor(void* object) { @@ -3989,7 +3864,7 @@ void Type_IntervalDay::SetCachedSize(int size) const { void Type_IntervalDay::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.IntervalDay) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4002,61 +3877,63 @@ void Type_IntervalDay::Clear() { const char* Type_IntervalDay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_IntervalDay::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_IntervalDay::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.IntervalDay) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -4074,67 +3951,50 @@ size_t Type_IntervalDay::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.IntervalDay) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_IntervalDay::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.IntervalDay) - GOOGLE_DCHECK_NE(&from, this); - const Type_IntervalDay* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.IntervalDay) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.IntervalDay) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_IntervalDay::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_IntervalDay::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_IntervalDay::GetClassData() const { return &_class_data_; } + +void Type_IntervalDay::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_IntervalDay::MergeFrom(const Type_IntervalDay& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.IntervalDay) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_IntervalDay::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.IntervalDay) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_IntervalDay::CopyFrom(const Type_IntervalDay& from) { @@ -4150,7 +4010,7 @@ bool Type_IntervalDay::IsInitialized() const { void Type_IntervalDay::InternalSwap(Type_IntervalDay* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_IntervalDay, nullability_) + sizeof(Type_IntervalDay::nullability_) @@ -4171,10 +4031,13 @@ class Type_UUID::_Internal { public: }; -Type_UUID::Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_UUID::Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.UUID) } Type_UUID::Type_UUID(const Type_UUID& from) @@ -4186,7 +4049,7 @@ Type_UUID::Type_UUID(const Type_UUID& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.UUID) } -void Type_UUID::SharedCtor() { +inline void Type_UUID::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -4195,12 +4058,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_UUID::~Type_UUID() { // @@protoc_insertion_point(destructor:substrait.Type.UUID) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_UUID::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_UUID::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_UUID::ArenaDtor(void* object) { @@ -4215,7 +4079,7 @@ void Type_UUID::SetCachedSize(int size) const { void Type_UUID::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.UUID) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4228,61 +4092,63 @@ void Type_UUID::Clear() { const char* Type_UUID::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // uint32 type_variation_reference = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_UUID::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_UUID::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.UUID) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 2, this->_internal_nullability(), target); @@ -4300,67 +4166,50 @@ size_t Type_UUID::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.UUID) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // uint32 type_variation_reference = 1; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 2; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_UUID::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.UUID) - GOOGLE_DCHECK_NE(&from, this); - const Type_UUID* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.UUID) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.UUID) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_UUID::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_UUID::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_UUID::GetClassData() const { return &_class_data_; } + +void Type_UUID::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_UUID::MergeFrom(const Type_UUID& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.UUID) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_UUID::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.UUID) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_UUID::CopyFrom(const Type_UUID& from) { @@ -4376,7 +4225,7 @@ bool Type_UUID::IsInitialized() const { void Type_UUID::InternalSwap(Type_UUID* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_UUID, nullability_) + sizeof(Type_UUID::nullability_) @@ -4397,10 +4246,13 @@ class Type_FixedChar::_Internal { public: }; -Type_FixedChar::Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_FixedChar::Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.FixedChar) } Type_FixedChar::Type_FixedChar(const Type_FixedChar& from) @@ -4412,7 +4264,7 @@ Type_FixedChar::Type_FixedChar(const Type_FixedChar& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.FixedChar) } -void Type_FixedChar::SharedCtor() { +inline void Type_FixedChar::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -4421,12 +4273,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_FixedChar::~Type_FixedChar() { // @@protoc_insertion_point(destructor:substrait.Type.FixedChar) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_FixedChar::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_FixedChar::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_FixedChar::ArenaDtor(void* object) { @@ -4441,7 +4294,7 @@ void Type_FixedChar::SetCachedSize(int size) const { void Type_FixedChar::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.FixedChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4454,74 +4307,77 @@ void Type_FixedChar::Clear() { const char* Type_FixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 length = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 type_variation_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedChar::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_FixedChar::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FixedChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 length = 1; - if (this->length() != 0) { + if (this->_internal_length() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); } // uint32 type_variation_reference = 2; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -4539,77 +4395,58 @@ size_t Type_FixedChar::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.FixedChar) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int32 length = 1; - if (this->length() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_length()); + if (this->_internal_length() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_length()); } // uint32 type_variation_reference = 2; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_FixedChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.FixedChar) - GOOGLE_DCHECK_NE(&from, this); - const Type_FixedChar* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.FixedChar) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.FixedChar) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FixedChar::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_FixedChar::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FixedChar::GetClassData() const { return &_class_data_; } + +void Type_FixedChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_FixedChar::MergeFrom(const Type_FixedChar& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FixedChar) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.length() != 0) { + if (from._internal_length() != 0) { _internal_set_length(from._internal_length()); } - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_FixedChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.FixedChar) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_FixedChar::CopyFrom(const Type_FixedChar& from) { @@ -4625,7 +4462,7 @@ bool Type_FixedChar::IsInitialized() const { void Type_FixedChar::InternalSwap(Type_FixedChar* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_FixedChar, nullability_) + sizeof(Type_FixedChar::nullability_) @@ -4646,10 +4483,13 @@ class Type_VarChar::_Internal { public: }; -Type_VarChar::Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_VarChar::Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.VarChar) } Type_VarChar::Type_VarChar(const Type_VarChar& from) @@ -4661,7 +4501,7 @@ Type_VarChar::Type_VarChar(const Type_VarChar& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.VarChar) } -void Type_VarChar::SharedCtor() { +inline void Type_VarChar::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -4670,12 +4510,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_VarChar::~Type_VarChar() { // @@protoc_insertion_point(destructor:substrait.Type.VarChar) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_VarChar::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_VarChar::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_VarChar::ArenaDtor(void* object) { @@ -4690,7 +4531,7 @@ void Type_VarChar::SetCachedSize(int size) const { void Type_VarChar::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.VarChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4703,74 +4544,77 @@ void Type_VarChar::Clear() { const char* Type_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 length = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 type_variation_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_VarChar::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_VarChar::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.VarChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 length = 1; - if (this->length() != 0) { + if (this->_internal_length() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); } // uint32 type_variation_reference = 2; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -4788,77 +4632,58 @@ size_t Type_VarChar::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.VarChar) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int32 length = 1; - if (this->length() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_length()); + if (this->_internal_length() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_length()); } // uint32 type_variation_reference = 2; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_VarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.VarChar) - GOOGLE_DCHECK_NE(&from, this); - const Type_VarChar* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.VarChar) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.VarChar) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_VarChar::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_VarChar::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_VarChar::GetClassData() const { return &_class_data_; } + +void Type_VarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_VarChar::MergeFrom(const Type_VarChar& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.VarChar) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.length() != 0) { + if (from._internal_length() != 0) { _internal_set_length(from._internal_length()); } - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_VarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.VarChar) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_VarChar::CopyFrom(const Type_VarChar& from) { @@ -4874,7 +4699,7 @@ bool Type_VarChar::IsInitialized() const { void Type_VarChar::InternalSwap(Type_VarChar* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_VarChar, nullability_) + sizeof(Type_VarChar::nullability_) @@ -4895,10 +4720,13 @@ class Type_FixedBinary::_Internal { public: }; -Type_FixedBinary::Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_FixedBinary::Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.FixedBinary) } Type_FixedBinary::Type_FixedBinary(const Type_FixedBinary& from) @@ -4910,7 +4738,7 @@ Type_FixedBinary::Type_FixedBinary(const Type_FixedBinary& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.FixedBinary) } -void Type_FixedBinary::SharedCtor() { +inline void Type_FixedBinary::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -4919,12 +4747,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_FixedBinary::~Type_FixedBinary() { // @@protoc_insertion_point(destructor:substrait.Type.FixedBinary) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_FixedBinary::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_FixedBinary::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_FixedBinary::ArenaDtor(void* object) { @@ -4939,7 +4768,7 @@ void Type_FixedBinary::SetCachedSize(int size) const { void Type_FixedBinary::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.FixedBinary) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -4952,74 +4781,77 @@ void Type_FixedBinary::Clear() { const char* Type_FixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 length = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 type_variation_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_FixedBinary::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_FixedBinary::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FixedBinary) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 length = 1; - if (this->length() != 0) { + if (this->_internal_length() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); } // uint32 type_variation_reference = 2; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -5037,77 +4869,58 @@ size_t Type_FixedBinary::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.FixedBinary) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int32 length = 1; - if (this->length() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_length()); + if (this->_internal_length() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_length()); } // uint32 type_variation_reference = 2; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_FixedBinary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.FixedBinary) - GOOGLE_DCHECK_NE(&from, this); - const Type_FixedBinary* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.FixedBinary) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.FixedBinary) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FixedBinary::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_FixedBinary::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FixedBinary::GetClassData() const { return &_class_data_; } + +void Type_FixedBinary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_FixedBinary::MergeFrom(const Type_FixedBinary& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FixedBinary) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.length() != 0) { + if (from._internal_length() != 0) { _internal_set_length(from._internal_length()); } - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_FixedBinary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.FixedBinary) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_FixedBinary::CopyFrom(const Type_FixedBinary& from) { @@ -5123,7 +4936,7 @@ bool Type_FixedBinary::IsInitialized() const { void Type_FixedBinary::InternalSwap(Type_FixedBinary* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_FixedBinary, nullability_) + sizeof(Type_FixedBinary::nullability_) @@ -5144,10 +4957,13 @@ class Type_Decimal::_Internal { public: }; -Type_Decimal::Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_Decimal::Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.Decimal) } Type_Decimal::Type_Decimal(const Type_Decimal& from) @@ -5159,7 +4975,7 @@ Type_Decimal::Type_Decimal(const Type_Decimal& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.Decimal) } -void Type_Decimal::SharedCtor() { +inline void Type_Decimal::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&scale_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -5168,12 +4984,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_Decimal::~Type_Decimal() { // @@protoc_insertion_point(destructor:substrait.Type.Decimal) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_Decimal::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_Decimal::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_Decimal::ArenaDtor(void* object) { @@ -5188,7 +5005,7 @@ void Type_Decimal::SetCachedSize(int size) const { void Type_Decimal::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.Decimal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5201,87 +5018,91 @@ void Type_Decimal::Clear() { const char* Type_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // int32 scale = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 precision = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { - precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { + precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 type_variation_reference = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_Decimal::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_Decimal::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Decimal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // int32 scale = 1; - if (this->scale() != 0) { + if (this->_internal_scale() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_scale(), target); } // int32 precision = 2; - if (this->precision() != 0) { + if (this->_internal_precision() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_precision(), target); } // uint32 type_variation_reference = 3; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 4, this->_internal_nullability(), target); @@ -5299,87 +5120,66 @@ size_t Type_Decimal::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.Decimal) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // int32 scale = 1; - if (this->scale() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_scale()); + if (this->_internal_scale() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_scale()); } // int32 precision = 2; - if (this->precision() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_precision()); + if (this->_internal_precision() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_precision()); } // uint32 type_variation_reference = 3; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_Decimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Decimal) - GOOGLE_DCHECK_NE(&from, this); - const Type_Decimal* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Decimal) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Decimal) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Decimal::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_Decimal::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Decimal::GetClassData() const { return &_class_data_; } + +void Type_Decimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_Decimal::MergeFrom(const Type_Decimal& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Decimal) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.scale() != 0) { + if (from._internal_scale() != 0) { _internal_set_scale(from._internal_scale()); } - if (from.precision() != 0) { + if (from._internal_precision() != 0) { _internal_set_precision(from._internal_precision()); } - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_Decimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Decimal) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_Decimal::CopyFrom(const Type_Decimal& from) { @@ -5395,7 +5195,7 @@ bool Type_Decimal::IsInitialized() const { void Type_Decimal::InternalSwap(Type_Decimal* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Decimal, nullability_) + sizeof(Type_Decimal::nullability_) @@ -5416,11 +5216,14 @@ class Type_Struct::_Internal { public: }; -Type_Struct::Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +Type_Struct::Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), types_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.Struct) } Type_Struct::Type_Struct(const Type_Struct& from) @@ -5433,7 +5236,7 @@ Type_Struct::Type_Struct(const Type_Struct& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.Struct) } -void Type_Struct::SharedCtor() { +inline void Type_Struct::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -5442,12 +5245,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_Struct::~Type_Struct() { // @@protoc_insertion_point(destructor:substrait.Type.Struct) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_Struct::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_Struct::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void Type_Struct::ArenaDtor(void* object) { @@ -5462,7 +5266,7 @@ void Type_Struct::SetCachedSize(int size) const { void Type_Struct::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.Struct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5476,12 +5280,12 @@ void Type_Struct::Clear() { const char* Type_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.Type types = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -5489,50 +5293,53 @@ const char* Type_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 type_variation_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_Struct::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_Struct::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Struct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.Type types = 1; @@ -5544,13 +5351,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Struct::_InternalSerialize( } // uint32 type_variation_reference = 2; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -5568,7 +5375,7 @@ size_t Type_Struct::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.Struct) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5580,63 +5387,46 @@ size_t Type_Struct::ByteSizeLong() const { } // uint32 type_variation_reference = 2; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_Struct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Struct) - GOOGLE_DCHECK_NE(&from, this); - const Type_Struct* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Struct) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Struct) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Struct::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_Struct::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Struct::GetClassData() const { return &_class_data_; } + +void Type_Struct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_Struct::MergeFrom(const Type_Struct& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Struct) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; types_.MergeFrom(from.types_); - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_Struct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Struct) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_Struct::CopyFrom(const Type_Struct& from) { @@ -5652,7 +5442,7 @@ bool Type_Struct::IsInitialized() const { void Type_Struct::InternalSwap(Type_Struct* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); types_.InternalSwap(&other->types_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Struct, nullability_) @@ -5679,10 +5469,13 @@ const ::substrait::Type& Type_List::_Internal::type(const Type_List* msg) { return *msg->type_; } -Type_List::Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_List::Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.List) } Type_List::Type_List(const Type_List& from) @@ -5699,7 +5492,7 @@ Type_List::Type_List(const Type_List& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.List) } -void Type_List::SharedCtor() { +inline void Type_List::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -5708,12 +5501,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_List::~Type_List() { // @@protoc_insertion_point(destructor:substrait.Type.List) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_List::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_List::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete type_; } @@ -5729,11 +5523,11 @@ void Type_List::SetCachedSize(int size) const { void Type_List::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.List) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; @@ -5746,62 +5540,65 @@ void Type_List::Clear() { const char* Type_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Type type = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 type_variation_reference = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_List::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_List::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.List) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Type type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -5809,13 +5606,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_List::_InternalSerialize( } // uint32 type_variation_reference = 2; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -5833,77 +5630,60 @@ size_t Type_List::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.List) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Type type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *type_); } // uint32 type_variation_reference = 2; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_List::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.List) - GOOGLE_DCHECK_NE(&from, this); - const Type_List* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.List) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.List) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_List::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_List::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_List::GetClassData() const { return &_class_data_; } + +void Type_List::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_List::MergeFrom(const Type_List& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.List) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_type()) { + if (from._internal_has_type()) { _internal_mutable_type()->::substrait::Type::MergeFrom(from._internal_type()); } - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_List::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.List) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_List::CopyFrom(const Type_List& from) { @@ -5919,7 +5699,7 @@ bool Type_List::IsInitialized() const { void Type_List::InternalSwap(Type_List* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_List, nullability_) + sizeof(Type_List::nullability_) @@ -5950,10 +5730,13 @@ const ::substrait::Type& Type_Map::_Internal::value(const Type_Map* msg) { return *msg->value_; } -Type_Map::Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type_Map::Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type.Map) } Type_Map::Type_Map(const Type_Map& from) @@ -5975,7 +5758,7 @@ Type_Map::Type_Map(const Type_Map& from) // @@protoc_insertion_point(copy_constructor:substrait.Type.Map) } -void Type_Map::SharedCtor() { +inline void Type_Map::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&key_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -5984,12 +5767,13 @@ ::memset(reinterpret_cast(this) + static_cast( Type_Map::~Type_Map() { // @@protoc_insertion_point(destructor:substrait.Type.Map) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type_Map::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type_Map::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete key_; if (this != internal_default_instance()) delete value_; } @@ -6006,15 +5790,15 @@ void Type_Map::SetCachedSize(int size) const { void Type_Map::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type.Map) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && key_ != nullptr) { + if (GetArenaForAllocation() == nullptr && key_ != nullptr) { delete key_; } key_ = nullptr; - if (GetArena() == nullptr && value_ != nullptr) { + if (GetArenaForAllocation() == nullptr && value_ != nullptr) { delete value_; } value_ = nullptr; @@ -6027,69 +5811,73 @@ void Type_Map::Clear() { const char* Type_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Type key = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type value = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 type_variation_reference = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type_Map::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type_Map::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Map) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Type key = 1; - if (this->has_key()) { + if (this->_internal_has_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6097,7 +5885,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Map::_InternalSerialize( } // .substrait.Type value = 2; - if (this->has_value()) { + if (this->_internal_has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -6105,13 +5893,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* Type_Map::_InternalSerialize( } // uint32 type_variation_reference = 3; - if (this->type_variation_reference() != 0) { + if (this->_internal_type_variation_reference() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_type_variation_reference(), target); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 4, this->_internal_nullability(), target); @@ -6129,87 +5917,70 @@ size_t Type_Map::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type.Map) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.Type key = 1; - if (this->has_key()) { + if (this->_internal_has_key()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *key_); } // .substrait.Type value = 2; - if (this->has_value()) { + if (this->_internal_has_value()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *value_); } // uint32 type_variation_reference = 3; - if (this->type_variation_reference() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_type_variation_reference()); + if (this->_internal_type_variation_reference() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type_Map::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type.Map) - GOOGLE_DCHECK_NE(&from, this); - const Type_Map* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type.Map) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type.Map) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Map::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type_Map::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Map::GetClassData() const { return &_class_data_; } + +void Type_Map::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type_Map::MergeFrom(const Type_Map& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Map) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_key()) { + if (from._internal_has_key()) { _internal_mutable_key()->::substrait::Type::MergeFrom(from._internal_key()); } - if (from.has_value()) { + if (from._internal_has_value()) { _internal_mutable_value()->::substrait::Type::MergeFrom(from._internal_value()); } - if (from.type_variation_reference() != 0) { + if (from._internal_type_variation_reference() != 0) { _internal_set_type_variation_reference(from._internal_type_variation_reference()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void Type_Map::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type.Map) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type_Map::CopyFrom(const Type_Map& from) { @@ -6225,7 +5996,7 @@ bool Type_Map::IsInitialized() const { void Type_Map::InternalSwap(Type_Map* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(Type_Map, nullability_) + sizeof(Type_Map::nullability_) @@ -6362,11 +6133,11 @@ Type::_Internal::map(const Type* msg) { return *msg->kind_.map_; } void Type::set_allocated_bool_(::substrait::Type_Boolean* bool_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (bool_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(bool_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Boolean>::GetOwningArena(bool_); if (message_arena != submessage_arena) { bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, bool_, submessage_arena); @@ -6377,11 +6148,11 @@ void Type::set_allocated_bool_(::substrait::Type_Boolean* bool_) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.bool) } void Type::set_allocated_i8(::substrait::Type_I8* i8) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i8) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(i8); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I8>::GetOwningArena(i8); if (message_arena != submessage_arena) { i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i8, submessage_arena); @@ -6392,11 +6163,11 @@ void Type::set_allocated_i8(::substrait::Type_I8* i8) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.i8) } void Type::set_allocated_i16(::substrait::Type_I16* i16) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i16) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(i16); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I16>::GetOwningArena(i16); if (message_arena != submessage_arena) { i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i16, submessage_arena); @@ -6407,11 +6178,11 @@ void Type::set_allocated_i16(::substrait::Type_I16* i16) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.i16) } void Type::set_allocated_i32(::substrait::Type_I32* i32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i32) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(i32); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I32>::GetOwningArena(i32); if (message_arena != submessage_arena) { i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i32, submessage_arena); @@ -6422,11 +6193,11 @@ void Type::set_allocated_i32(::substrait::Type_I32* i32) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.i32) } void Type::set_allocated_i64(::substrait::Type_I64* i64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i64) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(i64); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I64>::GetOwningArena(i64); if (message_arena != submessage_arena) { i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i64, submessage_arena); @@ -6437,11 +6208,11 @@ void Type::set_allocated_i64(::substrait::Type_I64* i64) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.i64) } void Type::set_allocated_fp32(::substrait::Type_FP32* fp32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fp32) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fp32); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FP32>::GetOwningArena(fp32); if (message_arena != submessage_arena) { fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fp32, submessage_arena); @@ -6452,11 +6223,11 @@ void Type::set_allocated_fp32(::substrait::Type_FP32* fp32) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.fp32) } void Type::set_allocated_fp64(::substrait::Type_FP64* fp64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fp64) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fp64); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FP64>::GetOwningArena(fp64); if (message_arena != submessage_arena) { fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fp64, submessage_arena); @@ -6467,11 +6238,11 @@ void Type::set_allocated_fp64(::substrait::Type_FP64* fp64) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.fp64) } void Type::set_allocated_string(::substrait::Type_String* string) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (string) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(string); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_String>::GetOwningArena(string); if (message_arena != submessage_arena) { string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, string, submessage_arena); @@ -6482,11 +6253,11 @@ void Type::set_allocated_string(::substrait::Type_String* string) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.string) } void Type::set_allocated_binary(::substrait::Type_Binary* binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (binary) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(binary); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Binary>::GetOwningArena(binary); if (message_arena != submessage_arena) { binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, binary, submessage_arena); @@ -6497,11 +6268,11 @@ void Type::set_allocated_binary(::substrait::Type_Binary* binary) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.binary) } void Type::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (timestamp) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(timestamp); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Timestamp>::GetOwningArena(timestamp); if (message_arena != submessage_arena) { timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, timestamp, submessage_arena); @@ -6512,11 +6283,11 @@ void Type::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.timestamp) } void Type::set_allocated_date(::substrait::Type_Date* date) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (date) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(date); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Date>::GetOwningArena(date); if (message_arena != submessage_arena) { date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, date, submessage_arena); @@ -6527,11 +6298,11 @@ void Type::set_allocated_date(::substrait::Type_Date* date) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.date) } void Type::set_allocated_time(::substrait::Type_Time* time) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (time) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(time); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Time>::GetOwningArena(time); if (message_arena != submessage_arena) { time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, time, submessage_arena); @@ -6542,11 +6313,11 @@ void Type::set_allocated_time(::substrait::Type_Time* time) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.time) } void Type::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (interval_year) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_year); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_IntervalYear>::GetOwningArena(interval_year); if (message_arena != submessage_arena) { interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, interval_year, submessage_arena); @@ -6557,11 +6328,11 @@ void Type::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_ // @@protoc_insertion_point(field_set_allocated:substrait.Type.interval_year) } void Type::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (interval_day) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(interval_day); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_IntervalDay>::GetOwningArena(interval_day); if (message_arena != submessage_arena) { interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, interval_day, submessage_arena); @@ -6572,11 +6343,11 @@ void Type::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_da // @@protoc_insertion_point(field_set_allocated:substrait.Type.interval_day) } void Type::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (timestamp_tz) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(timestamp_tz); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_TimestampTZ>::GetOwningArena(timestamp_tz); if (message_arena != submessage_arena) { timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, timestamp_tz, submessage_arena); @@ -6587,11 +6358,11 @@ void Type::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_t // @@protoc_insertion_point(field_set_allocated:substrait.Type.timestamp_tz) } void Type::set_allocated_uuid(::substrait::Type_UUID* uuid) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (uuid) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(uuid); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_UUID>::GetOwningArena(uuid); if (message_arena != submessage_arena) { uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, uuid, submessage_arena); @@ -6602,11 +6373,11 @@ void Type::set_allocated_uuid(::substrait::Type_UUID* uuid) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.uuid) } void Type::set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fixed_char) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_char); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FixedChar>::GetOwningArena(fixed_char); if (message_arena != submessage_arena) { fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fixed_char, submessage_arena); @@ -6617,11 +6388,11 @@ void Type::set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.fixed_char) } void Type::set_allocated_varchar(::substrait::Type_VarChar* varchar) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (varchar) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(varchar); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_VarChar>::GetOwningArena(varchar); if (message_arena != submessage_arena) { varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, varchar, submessage_arena); @@ -6632,11 +6403,11 @@ void Type::set_allocated_varchar(::substrait::Type_VarChar* varchar) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.varchar) } void Type::set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fixed_binary) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_binary); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FixedBinary>::GetOwningArena(fixed_binary); if (message_arena != submessage_arena) { fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fixed_binary, submessage_arena); @@ -6647,11 +6418,11 @@ void Type::set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binar // @@protoc_insertion_point(field_set_allocated:substrait.Type.fixed_binary) } void Type::set_allocated_decimal(::substrait::Type_Decimal* decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (decimal) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(decimal); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Decimal>::GetOwningArena(decimal); if (message_arena != submessage_arena) { decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, decimal, submessage_arena); @@ -6662,11 +6433,11 @@ void Type::set_allocated_decimal(::substrait::Type_Decimal* decimal) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.decimal) } void Type::set_allocated_struct_(::substrait::Type_Struct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Struct>::GetOwningArena(struct_); if (message_arena != submessage_arena) { struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, struct_, submessage_arena); @@ -6677,11 +6448,11 @@ void Type::set_allocated_struct_(::substrait::Type_Struct* struct_) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.struct) } void Type::set_allocated_list(::substrait::Type_List* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (list) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_List>::GetOwningArena(list); if (message_arena != submessage_arena) { list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, list, submessage_arena); @@ -6692,11 +6463,11 @@ void Type::set_allocated_list(::substrait::Type_List* list) { // @@protoc_insertion_point(field_set_allocated:substrait.Type.list) } void Type::set_allocated_map(::substrait::Type_Map* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (map) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Map>::GetOwningArena(map); if (message_arena != submessage_arena) { map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, map, submessage_arena); @@ -6706,10 +6477,13 @@ void Type::set_allocated_map(::substrait::Type_Map* map) { } // @@protoc_insertion_point(field_set_allocated:substrait.Type.map) } -Type::Type(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +Type::Type(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.Type) } Type::Type(const Type& from) @@ -6820,18 +6594,19 @@ Type::Type(const Type& from) // @@protoc_insertion_point(copy_constructor:substrait.Type) } -void Type::SharedCtor() { +inline void Type::SharedCtor() { clear_has_kind(); } Type::~Type() { // @@protoc_insertion_point(destructor:substrait.Type) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void Type::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void Type::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_kind()) { clear_kind(); } @@ -6851,139 +6626,139 @@ void Type::clear_kind() { // @@protoc_insertion_point(one_of_clear_start:substrait.Type) switch (kind_case()) { case kBool: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.bool__; } break; } case kI8: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i8_; } break; } case kI16: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i16_; } break; } case kI32: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i32_; } break; } case kI64: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i64_; } break; } case kFp32: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp32_; } break; } case kFp64: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp64_; } break; } case kString: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.string_; } break; } case kBinary: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.binary_; } break; } case kTimestamp: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_; } break; } case kDate: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.date_; } break; } case kTime: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.time_; } break; } case kIntervalYear: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_year_; } break; } case kIntervalDay: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_day_; } break; } case kTimestampTz: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_tz_; } break; } case kUuid: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.uuid_; } break; } case kFixedChar: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_char_; } break; } case kVarchar: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.varchar_; } break; } case kFixedBinary: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_binary_; } break; } case kDecimal: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.decimal_; } break; } case kStruct: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.struct__; } break; } case kList: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.list_; } break; } case kMap: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.map_; } break; @@ -7002,7 +6777,7 @@ void Type::clear_kind() { void Type::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.Type) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7013,204 +6788,228 @@ void Type::Clear() { const char* Type::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Type.Boolean bool = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I8 i8 = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I16 i16 = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I32 i32 = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I64 i64 = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.FP32 fp32 = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.FP64 fp64 = 11; case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.String string = 12; case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Binary binary = 13; case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Timestamp timestamp = 14; case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Date date = 16; case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Time time = 17; case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.IntervalYear interval_year = 19; case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.IntervalDay interval_day = 20; case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.FixedChar fixed_char = 21; case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.VarChar varchar = 22; case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.FixedBinary fixed_binary = 23; case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Decimal decimal = 24; case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Struct struct = 25; case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.List list = 27; case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Map map = 28; case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.TimestampTZ timestamp_tz = 29; case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 user_defined_type_reference = 31; case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 248)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { _internal_set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.UUID uuid = 32; case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* Type::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* Type::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.Type) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Type.Boolean bool = 1; @@ -7415,7 +7214,7 @@ size_t Type::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.Type) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7592,35 +7391,26 @@ size_t Type::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void Type::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.Type) - GOOGLE_DCHECK_NE(&from, this); - const Type* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.Type) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.Type) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + Type::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type::GetClassData() const { return &_class_data_; } + +void Type::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void Type::MergeFrom(const Type& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.kind_case()) { @@ -7724,13 +7514,7 @@ void Type::MergeFrom(const Type& from) { break; } } -} - -void Type::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.Type) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void Type::CopyFrom(const Type& from) { @@ -7746,7 +7530,7 @@ bool Type::IsInitialized() const { void Type::InternalSwap(Type* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(kind_, other->kind_); swap(_oneof_case_[0], other->_oneof_case_[0]); } @@ -7768,11 +7552,14 @@ const ::substrait::Type_Struct& NamedStruct::_Internal::struct_(const NamedStruct* msg) { return *msg->struct__; } -NamedStruct::NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +NamedStruct::NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), names_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.NamedStruct) } NamedStruct::NamedStruct(const NamedStruct& from) @@ -7787,18 +7574,19 @@ NamedStruct::NamedStruct(const NamedStruct& from) // @@protoc_insertion_point(copy_constructor:substrait.NamedStruct) } -void NamedStruct::SharedCtor() { +inline void NamedStruct::SharedCtor() { struct__ = nullptr; } NamedStruct::~NamedStruct() { // @@protoc_insertion_point(destructor:substrait.NamedStruct) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void NamedStruct::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void NamedStruct::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete struct__; } @@ -7814,12 +7602,12 @@ void NamedStruct::SetCachedSize(int size) const { void NamedStruct::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.NamedStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; names_.Clear(); - if (GetArena() == nullptr && struct__ != nullptr) { + if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { delete struct__; } struct__ = nullptr; @@ -7829,12 +7617,12 @@ void NamedStruct::Clear() { const char* NamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated string names = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -7844,42 +7632,44 @@ const char* NamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Struct struct = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* NamedStruct::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* NamedStruct::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.NamedStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated string names = 1; @@ -7893,7 +7683,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* NamedStruct::_InternalSerialize( } // .substrait.Type.Struct struct = 2; - if (this->has_struct_()) { + if (this->_internal_has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -7912,7 +7702,7 @@ size_t NamedStruct::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.NamedStruct) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -7925,54 +7715,39 @@ size_t NamedStruct::ByteSizeLong() const { } // .substrait.Type.Struct struct = 2; - if (this->has_struct_()) { + if (this->_internal_has_struct_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *struct__); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void NamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.NamedStruct) - GOOGLE_DCHECK_NE(&from, this); - const NamedStruct* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.NamedStruct) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.NamedStruct) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NamedStruct::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + NamedStruct::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NamedStruct::GetClassData() const { return &_class_data_; } + +void NamedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void NamedStruct::MergeFrom(const NamedStruct& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.NamedStruct) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; names_.MergeFrom(from.names_); - if (from.has_struct_()) { + if (from._internal_has_struct_()) { _internal_mutable_struct_()->::substrait::Type_Struct::MergeFrom(from._internal_struct_()); } -} - -void NamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.NamedStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void NamedStruct::CopyFrom(const NamedStruct& from) { @@ -7988,7 +7763,7 @@ bool NamedStruct::IsInitialized() const { void NamedStruct::InternalSwap(NamedStruct* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); names_.InternalSwap(&other->names_); swap(struct__, other->struct__); } diff --git a/cpp/src/generated/substrait/type.pb.h b/cpp/src/generated/substrait/type.pb.h index 9a144ebbf75..b528e2f1b56 100644 --- a/cpp/src/generated/substrait/type.pb.h +++ b/cpp/src/generated/substrait/type.pb.h @@ -8,12 +8,12 @@ #include #include -#if PROTOBUF_VERSION < 3016000 +#if PROTOBUF_VERSION < 3019000 #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 3016000 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019003 < 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. @@ -51,7 +51,7 @@ struct TableStruct_substrait_2ftype_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; + static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_2eproto; namespace substrait { @@ -164,8 +164,8 @@ enum Type_Nullability : int { Type_Nullability_NULLABILITY_UNSPECIFIED = 0, Type_Nullability_NULLABILITY_NULLABLE = 1, Type_Nullability_NULLABILITY_REQUIRED = 2, - Type_Nullability_Type_Nullability_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - Type_Nullability_Type_Nullability_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + Type_Nullability_Type_Nullability_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + Type_Nullability_Type_Nullability_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool Type_Nullability_IsValid(int value); constexpr Type_Nullability Type_Nullability_Nullability_MIN = Type_Nullability_NULLABILITY_UNSPECIFIED; @@ -188,7 +188,7 @@ inline bool Type_Nullability_Parse( } // =================================================================== -class Type_Boolean PROTOBUF_FINAL : +class Type_Boolean final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Boolean) */ { public: inline Type_Boolean() : Type_Boolean(nullptr) {} @@ -206,8 +206,13 @@ class Type_Boolean PROTOBUF_FINAL : return *this; } inline Type_Boolean& operator=(Type_Boolean&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -238,7 +243,12 @@ class Type_Boolean PROTOBUF_FINAL : } inline void Swap(Type_Boolean* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -246,48 +256,53 @@ class Type_Boolean PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_Boolean* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_Boolean* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_Boolean* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_Boolean* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_Boolean& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_Boolean& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_Boolean* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.Boolean"; } protected: - explicit Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -300,11 +315,11 @@ class Type_Boolean PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -323,14 +338,14 @@ class Type_Boolean PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_I8 PROTOBUF_FINAL : +class Type_I8 final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I8) */ { public: inline Type_I8() : Type_I8(nullptr) {} @@ -348,8 +363,13 @@ class Type_I8 PROTOBUF_FINAL : return *this; } inline Type_I8& operator=(Type_I8&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -380,7 +400,12 @@ class Type_I8 PROTOBUF_FINAL : } inline void Swap(Type_I8* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -388,48 +413,53 @@ class Type_I8 PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_I8* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_I8* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_I8* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_I8* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_I8& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_I8& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_I8* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.I8"; } protected: - explicit Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -442,11 +472,11 @@ class Type_I8 PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -465,14 +495,14 @@ class Type_I8 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_I16 PROTOBUF_FINAL : +class Type_I16 final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I16) */ { public: inline Type_I16() : Type_I16(nullptr) {} @@ -490,8 +520,13 @@ class Type_I16 PROTOBUF_FINAL : return *this; } inline Type_I16& operator=(Type_I16&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -522,7 +557,12 @@ class Type_I16 PROTOBUF_FINAL : } inline void Swap(Type_I16* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -530,48 +570,53 @@ class Type_I16 PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_I16* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_I16* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_I16* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_I16* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_I16& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_I16& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_I16* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.I16"; } protected: - explicit Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -584,11 +629,11 @@ class Type_I16 PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -607,14 +652,14 @@ class Type_I16 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_I32 PROTOBUF_FINAL : +class Type_I32 final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I32) */ { public: inline Type_I32() : Type_I32(nullptr) {} @@ -632,8 +677,13 @@ class Type_I32 PROTOBUF_FINAL : return *this; } inline Type_I32& operator=(Type_I32&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -664,7 +714,12 @@ class Type_I32 PROTOBUF_FINAL : } inline void Swap(Type_I32* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -672,48 +727,53 @@ class Type_I32 PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_I32* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_I32* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_I32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_I32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_I32& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_I32& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_I32* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.I32"; } protected: - explicit Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -726,11 +786,11 @@ class Type_I32 PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -749,14 +809,14 @@ class Type_I32 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_I64 PROTOBUF_FINAL : +class Type_I64 final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I64) */ { public: inline Type_I64() : Type_I64(nullptr) {} @@ -774,8 +834,13 @@ class Type_I64 PROTOBUF_FINAL : return *this; } inline Type_I64& operator=(Type_I64&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -806,7 +871,12 @@ class Type_I64 PROTOBUF_FINAL : } inline void Swap(Type_I64* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -814,48 +884,53 @@ class Type_I64 PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_I64* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_I64* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_I64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_I64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_I64& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_I64& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_I64* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.I64"; } protected: - explicit Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -868,11 +943,11 @@ class Type_I64 PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -891,14 +966,14 @@ class Type_I64 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_FP32 PROTOBUF_FINAL : +class Type_FP32 final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FP32) */ { public: inline Type_FP32() : Type_FP32(nullptr) {} @@ -916,8 +991,13 @@ class Type_FP32 PROTOBUF_FINAL : return *this; } inline Type_FP32& operator=(Type_FP32&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -948,7 +1028,12 @@ class Type_FP32 PROTOBUF_FINAL : } inline void Swap(Type_FP32* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -956,48 +1041,53 @@ class Type_FP32 PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_FP32* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_FP32* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_FP32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_FP32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_FP32& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_FP32& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_FP32* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.FP32"; } protected: - explicit Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1010,11 +1100,11 @@ class Type_FP32 PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -1033,14 +1123,14 @@ class Type_FP32 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_FP64 PROTOBUF_FINAL : +class Type_FP64 final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FP64) */ { public: inline Type_FP64() : Type_FP64(nullptr) {} @@ -1058,8 +1148,13 @@ class Type_FP64 PROTOBUF_FINAL : return *this; } inline Type_FP64& operator=(Type_FP64&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1090,7 +1185,12 @@ class Type_FP64 PROTOBUF_FINAL : } inline void Swap(Type_FP64* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1098,48 +1198,53 @@ class Type_FP64 PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_FP64* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_FP64* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_FP64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_FP64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_FP64& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_FP64& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_FP64* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.FP64"; } protected: - explicit Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1152,11 +1257,11 @@ class Type_FP64 PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -1175,14 +1280,14 @@ class Type_FP64 PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_String PROTOBUF_FINAL : +class Type_String final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.String) */ { public: inline Type_String() : Type_String(nullptr) {} @@ -1200,8 +1305,13 @@ class Type_String PROTOBUF_FINAL : return *this; } inline Type_String& operator=(Type_String&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1232,7 +1342,12 @@ class Type_String PROTOBUF_FINAL : } inline void Swap(Type_String* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1240,48 +1355,53 @@ class Type_String PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_String* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_String* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_String* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_String* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_String& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_String& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_String* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.String"; } protected: - explicit Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1294,11 +1414,11 @@ class Type_String PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -1317,14 +1437,14 @@ class Type_String PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_Binary PROTOBUF_FINAL : +class Type_Binary final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Binary) */ { public: inline Type_Binary() : Type_Binary(nullptr) {} @@ -1342,8 +1462,13 @@ class Type_Binary PROTOBUF_FINAL : return *this; } inline Type_Binary& operator=(Type_Binary&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1374,7 +1499,12 @@ class Type_Binary PROTOBUF_FINAL : } inline void Swap(Type_Binary* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1382,48 +1512,53 @@ class Type_Binary PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_Binary* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_Binary* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_Binary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_Binary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_Binary& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_Binary& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_Binary* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.Binary"; } protected: - explicit Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1436,11 +1571,11 @@ class Type_Binary PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -1459,14 +1594,14 @@ class Type_Binary PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_Timestamp PROTOBUF_FINAL : +class Type_Timestamp final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Timestamp) */ { public: inline Type_Timestamp() : Type_Timestamp(nullptr) {} @@ -1484,8 +1619,13 @@ class Type_Timestamp PROTOBUF_FINAL : return *this; } inline Type_Timestamp& operator=(Type_Timestamp&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1516,7 +1656,12 @@ class Type_Timestamp PROTOBUF_FINAL : } inline void Swap(Type_Timestamp* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1524,48 +1669,53 @@ class Type_Timestamp PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_Timestamp* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_Timestamp* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_Timestamp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_Timestamp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_Timestamp& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_Timestamp& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_Timestamp* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.Timestamp"; } protected: - explicit Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1578,11 +1728,11 @@ class Type_Timestamp PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -1601,14 +1751,14 @@ class Type_Timestamp PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_Date PROTOBUF_FINAL : +class Type_Date final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Date) */ { public: inline Type_Date() : Type_Date(nullptr) {} @@ -1626,8 +1776,13 @@ class Type_Date PROTOBUF_FINAL : return *this; } inline Type_Date& operator=(Type_Date&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1658,7 +1813,12 @@ class Type_Date PROTOBUF_FINAL : } inline void Swap(Type_Date* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1666,48 +1826,53 @@ class Type_Date PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_Date* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_Date* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_Date* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_Date* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_Date& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_Date& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_Date* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.Date"; } protected: - explicit Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1720,11 +1885,11 @@ class Type_Date PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -1743,14 +1908,14 @@ class Type_Date PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_Time PROTOBUF_FINAL : +class Type_Time final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Time) */ { public: inline Type_Time() : Type_Time(nullptr) {} @@ -1768,8 +1933,13 @@ class Type_Time PROTOBUF_FINAL : return *this; } inline Type_Time& operator=(Type_Time&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1800,7 +1970,12 @@ class Type_Time PROTOBUF_FINAL : } inline void Swap(Type_Time* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1808,48 +1983,53 @@ class Type_Time PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_Time* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_Time* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_Time* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_Time* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_Time& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_Time& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_Time* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.Time"; } protected: - explicit Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1862,11 +2042,11 @@ class Type_Time PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -1885,14 +2065,14 @@ class Type_Time PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_TimestampTZ PROTOBUF_FINAL : +class Type_TimestampTZ final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.TimestampTZ) */ { public: inline Type_TimestampTZ() : Type_TimestampTZ(nullptr) {} @@ -1910,8 +2090,13 @@ class Type_TimestampTZ PROTOBUF_FINAL : return *this; } inline Type_TimestampTZ& operator=(Type_TimestampTZ&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1942,7 +2127,12 @@ class Type_TimestampTZ PROTOBUF_FINAL : } inline void Swap(Type_TimestampTZ* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1950,48 +2140,53 @@ class Type_TimestampTZ PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_TimestampTZ* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_TimestampTZ* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_TimestampTZ* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_TimestampTZ* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_TimestampTZ& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_TimestampTZ& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_TimestampTZ* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.TimestampTZ"; } protected: - explicit Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2004,11 +2199,11 @@ class Type_TimestampTZ PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -2027,14 +2222,14 @@ class Type_TimestampTZ PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_IntervalYear PROTOBUF_FINAL : +class Type_IntervalYear final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.IntervalYear) */ { public: inline Type_IntervalYear() : Type_IntervalYear(nullptr) {} @@ -2052,8 +2247,13 @@ class Type_IntervalYear PROTOBUF_FINAL : return *this; } inline Type_IntervalYear& operator=(Type_IntervalYear&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2084,7 +2284,12 @@ class Type_IntervalYear PROTOBUF_FINAL : } inline void Swap(Type_IntervalYear* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2092,48 +2297,53 @@ class Type_IntervalYear PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_IntervalYear* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_IntervalYear* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_IntervalYear* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_IntervalYear* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_IntervalYear& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_IntervalYear& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_IntervalYear* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.IntervalYear"; } protected: - explicit Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2146,11 +2356,11 @@ class Type_IntervalYear PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -2169,14 +2379,14 @@ class Type_IntervalYear PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_IntervalDay PROTOBUF_FINAL : +class Type_IntervalDay final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.IntervalDay) */ { public: inline Type_IntervalDay() : Type_IntervalDay(nullptr) {} @@ -2194,8 +2404,13 @@ class Type_IntervalDay PROTOBUF_FINAL : return *this; } inline Type_IntervalDay& operator=(Type_IntervalDay&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2226,7 +2441,12 @@ class Type_IntervalDay PROTOBUF_FINAL : } inline void Swap(Type_IntervalDay* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2234,48 +2454,53 @@ class Type_IntervalDay PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_IntervalDay* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_IntervalDay* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_IntervalDay* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_IntervalDay* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_IntervalDay& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_IntervalDay& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_IntervalDay* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.IntervalDay"; } protected: - explicit Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2288,11 +2513,11 @@ class Type_IntervalDay PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -2311,14 +2536,14 @@ class Type_IntervalDay PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_UUID PROTOBUF_FINAL : +class Type_UUID final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.UUID) */ { public: inline Type_UUID() : Type_UUID(nullptr) {} @@ -2336,8 +2561,13 @@ class Type_UUID PROTOBUF_FINAL : return *this; } inline Type_UUID& operator=(Type_UUID&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2368,7 +2598,12 @@ class Type_UUID PROTOBUF_FINAL : } inline void Swap(Type_UUID* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2376,48 +2611,53 @@ class Type_UUID PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_UUID* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_UUID* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_UUID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_UUID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_UUID& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_UUID& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_UUID* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.UUID"; } protected: - explicit Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2430,11 +2670,11 @@ class Type_UUID PROTOBUF_FINAL : }; // uint32 type_variation_reference = 1; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 2; @@ -2453,14 +2693,14 @@ class Type_UUID PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_FixedChar PROTOBUF_FINAL : +class Type_FixedChar final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FixedChar) */ { public: inline Type_FixedChar() : Type_FixedChar(nullptr) {} @@ -2478,8 +2718,13 @@ class Type_FixedChar PROTOBUF_FINAL : return *this; } inline Type_FixedChar& operator=(Type_FixedChar&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2510,7 +2755,12 @@ class Type_FixedChar PROTOBUF_FINAL : } inline void Swap(Type_FixedChar* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2518,48 +2768,53 @@ class Type_FixedChar PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_FixedChar* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_FixedChar* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_FixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_FixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_FixedChar& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_FixedChar& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_FixedChar* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.FixedChar"; } protected: - explicit Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2573,20 +2828,20 @@ class Type_FixedChar PROTOBUF_FINAL : }; // int32 length = 1; void clear_length(); - ::PROTOBUF_NAMESPACE_ID::int32 length() const; - void set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t length() const; + void set_length(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_length() const; - void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_length() const; + void _internal_set_length(int32_t value); public: // uint32 type_variation_reference = 2; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -2605,15 +2860,15 @@ class Type_FixedChar PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 length_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + int32_t length_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_VarChar PROTOBUF_FINAL : +class Type_VarChar final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.VarChar) */ { public: inline Type_VarChar() : Type_VarChar(nullptr) {} @@ -2631,8 +2886,13 @@ class Type_VarChar PROTOBUF_FINAL : return *this; } inline Type_VarChar& operator=(Type_VarChar&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2663,7 +2923,12 @@ class Type_VarChar PROTOBUF_FINAL : } inline void Swap(Type_VarChar* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2671,48 +2936,53 @@ class Type_VarChar PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_VarChar* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_VarChar* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_VarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_VarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_VarChar& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_VarChar& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_VarChar* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.VarChar"; } protected: - explicit Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2726,20 +2996,20 @@ class Type_VarChar PROTOBUF_FINAL : }; // int32 length = 1; void clear_length(); - ::PROTOBUF_NAMESPACE_ID::int32 length() const; - void set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t length() const; + void set_length(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_length() const; - void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_length() const; + void _internal_set_length(int32_t value); public: // uint32 type_variation_reference = 2; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -2758,15 +3028,15 @@ class Type_VarChar PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 length_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + int32_t length_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_FixedBinary PROTOBUF_FINAL : +class Type_FixedBinary final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FixedBinary) */ { public: inline Type_FixedBinary() : Type_FixedBinary(nullptr) {} @@ -2784,8 +3054,13 @@ class Type_FixedBinary PROTOBUF_FINAL : return *this; } inline Type_FixedBinary& operator=(Type_FixedBinary&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2816,7 +3091,12 @@ class Type_FixedBinary PROTOBUF_FINAL : } inline void Swap(Type_FixedBinary* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2824,48 +3104,53 @@ class Type_FixedBinary PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_FixedBinary* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_FixedBinary* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_FixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_FixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_FixedBinary& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_FixedBinary& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_FixedBinary* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.FixedBinary"; } protected: - explicit Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2879,20 +3164,20 @@ class Type_FixedBinary PROTOBUF_FINAL : }; // int32 length = 1; void clear_length(); - ::PROTOBUF_NAMESPACE_ID::int32 length() const; - void set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t length() const; + void set_length(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_length() const; - void _internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_length() const; + void _internal_set_length(int32_t value); public: // uint32 type_variation_reference = 2; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -2911,15 +3196,15 @@ class Type_FixedBinary PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 length_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + int32_t length_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_Decimal PROTOBUF_FINAL : +class Type_Decimal final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Decimal) */ { public: inline Type_Decimal() : Type_Decimal(nullptr) {} @@ -2937,8 +3222,13 @@ class Type_Decimal PROTOBUF_FINAL : return *this; } inline Type_Decimal& operator=(Type_Decimal&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2969,7 +3259,12 @@ class Type_Decimal PROTOBUF_FINAL : } inline void Swap(Type_Decimal* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2977,48 +3272,53 @@ class Type_Decimal PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_Decimal* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_Decimal* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_Decimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_Decimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_Decimal& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_Decimal& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_Decimal* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.Decimal"; } protected: - explicit Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3033,29 +3333,29 @@ class Type_Decimal PROTOBUF_FINAL : }; // int32 scale = 1; void clear_scale(); - ::PROTOBUF_NAMESPACE_ID::int32 scale() const; - void set_scale(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t scale() const; + void set_scale(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_scale() const; - void _internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_scale() const; + void _internal_set_scale(int32_t value); public: // int32 precision = 2; void clear_precision(); - ::PROTOBUF_NAMESPACE_ID::int32 precision() const; - void set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t precision() const; + void set_precision(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_precision() const; - void _internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_precision() const; + void _internal_set_precision(int32_t value); public: // uint32 type_variation_reference = 3; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 4; @@ -3074,16 +3374,16 @@ class Type_Decimal PROTOBUF_FINAL : template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::int32 scale_; - ::PROTOBUF_NAMESPACE_ID::int32 precision_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + int32_t scale_; + int32_t precision_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_Struct PROTOBUF_FINAL : +class Type_Struct final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Struct) */ { public: inline Type_Struct() : Type_Struct(nullptr) {} @@ -3101,8 +3401,13 @@ class Type_Struct PROTOBUF_FINAL : return *this; } inline Type_Struct& operator=(Type_Struct&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3133,7 +3438,12 @@ class Type_Struct PROTOBUF_FINAL : } inline void Swap(Type_Struct* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3141,48 +3451,53 @@ class Type_Struct PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_Struct* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_Struct* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_Struct& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_Struct& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_Struct* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.Struct"; } protected: - explicit Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3214,11 +3529,11 @@ class Type_Struct PROTOBUF_FINAL : // uint32 type_variation_reference = 2; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -3238,14 +3553,14 @@ class Type_Struct PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type > types_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_List PROTOBUF_FINAL : +class Type_List final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.List) */ { public: inline Type_List() : Type_List(nullptr) {} @@ -3263,8 +3578,13 @@ class Type_List PROTOBUF_FINAL : return *this; } inline Type_List& operator=(Type_List&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3295,7 +3615,12 @@ class Type_List PROTOBUF_FINAL : } inline void Swap(Type_List* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3303,48 +3628,53 @@ class Type_List PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_List* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_List* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_List& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_List& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_List* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.List"; } protected: - explicit Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3363,7 +3693,7 @@ class Type_List PROTOBUF_FINAL : public: void clear_type(); const ::substrait::Type& type() const; - ::substrait::Type* release_type(); + PROTOBUF_NODISCARD ::substrait::Type* release_type(); ::substrait::Type* mutable_type(); void set_allocated_type(::substrait::Type* type); private: @@ -3376,11 +3706,11 @@ class Type_List PROTOBUF_FINAL : // uint32 type_variation_reference = 2; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -3400,14 +3730,14 @@ class Type_List PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::Type* type_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type_Map PROTOBUF_FINAL : +class Type_Map final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Map) */ { public: inline Type_Map() : Type_Map(nullptr) {} @@ -3425,8 +3755,13 @@ class Type_Map PROTOBUF_FINAL : return *this; } inline Type_Map& operator=(Type_Map&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3457,7 +3792,12 @@ class Type_Map PROTOBUF_FINAL : } inline void Swap(Type_Map* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3465,48 +3805,53 @@ class Type_Map PROTOBUF_FINAL : } void UnsafeArenaSwap(Type_Map* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type_Map* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type_Map& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type_Map& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type_Map* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type.Map"; } protected: - explicit Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3526,7 +3871,7 @@ class Type_Map PROTOBUF_FINAL : public: void clear_key(); const ::substrait::Type& key() const; - ::substrait::Type* release_key(); + PROTOBUF_NODISCARD ::substrait::Type* release_key(); ::substrait::Type* mutable_key(); void set_allocated_key(::substrait::Type* key); private: @@ -3544,7 +3889,7 @@ class Type_Map PROTOBUF_FINAL : public: void clear_value(); const ::substrait::Type& value() const; - ::substrait::Type* release_value(); + PROTOBUF_NODISCARD ::substrait::Type* release_value(); ::substrait::Type* mutable_value(); void set_allocated_value(::substrait::Type* value); private: @@ -3557,11 +3902,11 @@ class Type_Map PROTOBUF_FINAL : // uint32 type_variation_reference = 3; void clear_type_variation_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference() const; - void set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t type_variation_reference() const; + void set_type_variation_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_type_variation_reference() const; + void _internal_set_type_variation_reference(uint32_t value); public: // .substrait.Type.Nullability nullability = 4; @@ -3582,14 +3927,14 @@ class Type_Map PROTOBUF_FINAL : typedef void DestructorSkippable_; ::substrait::Type* key_; ::substrait::Type* value_; - ::PROTOBUF_NAMESPACE_ID::uint32 type_variation_reference_; + uint32_t type_variation_reference_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class Type PROTOBUF_FINAL : +class Type final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type) */ { public: inline Type() : Type(nullptr) {} @@ -3607,8 +3952,13 @@ class Type PROTOBUF_FINAL : return *this; } inline Type& operator=(Type&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -3667,7 +4017,12 @@ class Type PROTOBUF_FINAL : } inline void Swap(Type* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -3675,48 +4030,53 @@ class Type PROTOBUF_FINAL : } void UnsafeArenaSwap(Type* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline Type* New() const final { - return CreateMaybeMessage(nullptr); - } - - Type* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + Type* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const Type& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const Type& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(Type* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.Type"; } protected: - explicit Type(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit Type(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -3812,7 +4172,7 @@ class Type PROTOBUF_FINAL : public: void clear_bool_(); const ::substrait::Type_Boolean& bool_() const; - ::substrait::Type_Boolean* release_bool_(); + PROTOBUF_NODISCARD ::substrait::Type_Boolean* release_bool_(); ::substrait::Type_Boolean* mutable_bool_(); void set_allocated_bool_(::substrait::Type_Boolean* bool_); private: @@ -3830,7 +4190,7 @@ class Type PROTOBUF_FINAL : public: void clear_i8(); const ::substrait::Type_I8& i8() const; - ::substrait::Type_I8* release_i8(); + PROTOBUF_NODISCARD ::substrait::Type_I8* release_i8(); ::substrait::Type_I8* mutable_i8(); void set_allocated_i8(::substrait::Type_I8* i8); private: @@ -3848,7 +4208,7 @@ class Type PROTOBUF_FINAL : public: void clear_i16(); const ::substrait::Type_I16& i16() const; - ::substrait::Type_I16* release_i16(); + PROTOBUF_NODISCARD ::substrait::Type_I16* release_i16(); ::substrait::Type_I16* mutable_i16(); void set_allocated_i16(::substrait::Type_I16* i16); private: @@ -3866,7 +4226,7 @@ class Type PROTOBUF_FINAL : public: void clear_i32(); const ::substrait::Type_I32& i32() const; - ::substrait::Type_I32* release_i32(); + PROTOBUF_NODISCARD ::substrait::Type_I32* release_i32(); ::substrait::Type_I32* mutable_i32(); void set_allocated_i32(::substrait::Type_I32* i32); private: @@ -3884,7 +4244,7 @@ class Type PROTOBUF_FINAL : public: void clear_i64(); const ::substrait::Type_I64& i64() const; - ::substrait::Type_I64* release_i64(); + PROTOBUF_NODISCARD ::substrait::Type_I64* release_i64(); ::substrait::Type_I64* mutable_i64(); void set_allocated_i64(::substrait::Type_I64* i64); private: @@ -3902,7 +4262,7 @@ class Type PROTOBUF_FINAL : public: void clear_fp32(); const ::substrait::Type_FP32& fp32() const; - ::substrait::Type_FP32* release_fp32(); + PROTOBUF_NODISCARD ::substrait::Type_FP32* release_fp32(); ::substrait::Type_FP32* mutable_fp32(); void set_allocated_fp32(::substrait::Type_FP32* fp32); private: @@ -3920,7 +4280,7 @@ class Type PROTOBUF_FINAL : public: void clear_fp64(); const ::substrait::Type_FP64& fp64() const; - ::substrait::Type_FP64* release_fp64(); + PROTOBUF_NODISCARD ::substrait::Type_FP64* release_fp64(); ::substrait::Type_FP64* mutable_fp64(); void set_allocated_fp64(::substrait::Type_FP64* fp64); private: @@ -3938,7 +4298,7 @@ class Type PROTOBUF_FINAL : public: void clear_string(); const ::substrait::Type_String& string() const; - ::substrait::Type_String* release_string(); + PROTOBUF_NODISCARD ::substrait::Type_String* release_string(); ::substrait::Type_String* mutable_string(); void set_allocated_string(::substrait::Type_String* string); private: @@ -3956,7 +4316,7 @@ class Type PROTOBUF_FINAL : public: void clear_binary(); const ::substrait::Type_Binary& binary() const; - ::substrait::Type_Binary* release_binary(); + PROTOBUF_NODISCARD ::substrait::Type_Binary* release_binary(); ::substrait::Type_Binary* mutable_binary(); void set_allocated_binary(::substrait::Type_Binary* binary); private: @@ -3974,7 +4334,7 @@ class Type PROTOBUF_FINAL : public: void clear_timestamp(); const ::substrait::Type_Timestamp& timestamp() const; - ::substrait::Type_Timestamp* release_timestamp(); + PROTOBUF_NODISCARD ::substrait::Type_Timestamp* release_timestamp(); ::substrait::Type_Timestamp* mutable_timestamp(); void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp); private: @@ -3992,7 +4352,7 @@ class Type PROTOBUF_FINAL : public: void clear_date(); const ::substrait::Type_Date& date() const; - ::substrait::Type_Date* release_date(); + PROTOBUF_NODISCARD ::substrait::Type_Date* release_date(); ::substrait::Type_Date* mutable_date(); void set_allocated_date(::substrait::Type_Date* date); private: @@ -4010,7 +4370,7 @@ class Type PROTOBUF_FINAL : public: void clear_time(); const ::substrait::Type_Time& time() const; - ::substrait::Type_Time* release_time(); + PROTOBUF_NODISCARD ::substrait::Type_Time* release_time(); ::substrait::Type_Time* mutable_time(); void set_allocated_time(::substrait::Type_Time* time); private: @@ -4028,7 +4388,7 @@ class Type PROTOBUF_FINAL : public: void clear_interval_year(); const ::substrait::Type_IntervalYear& interval_year() const; - ::substrait::Type_IntervalYear* release_interval_year(); + PROTOBUF_NODISCARD ::substrait::Type_IntervalYear* release_interval_year(); ::substrait::Type_IntervalYear* mutable_interval_year(); void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year); private: @@ -4046,7 +4406,7 @@ class Type PROTOBUF_FINAL : public: void clear_interval_day(); const ::substrait::Type_IntervalDay& interval_day() const; - ::substrait::Type_IntervalDay* release_interval_day(); + PROTOBUF_NODISCARD ::substrait::Type_IntervalDay* release_interval_day(); ::substrait::Type_IntervalDay* mutable_interval_day(); void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day); private: @@ -4064,7 +4424,7 @@ class Type PROTOBUF_FINAL : public: void clear_timestamp_tz(); const ::substrait::Type_TimestampTZ& timestamp_tz() const; - ::substrait::Type_TimestampTZ* release_timestamp_tz(); + PROTOBUF_NODISCARD ::substrait::Type_TimestampTZ* release_timestamp_tz(); ::substrait::Type_TimestampTZ* mutable_timestamp_tz(); void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz); private: @@ -4082,7 +4442,7 @@ class Type PROTOBUF_FINAL : public: void clear_uuid(); const ::substrait::Type_UUID& uuid() const; - ::substrait::Type_UUID* release_uuid(); + PROTOBUF_NODISCARD ::substrait::Type_UUID* release_uuid(); ::substrait::Type_UUID* mutable_uuid(); void set_allocated_uuid(::substrait::Type_UUID* uuid); private: @@ -4100,7 +4460,7 @@ class Type PROTOBUF_FINAL : public: void clear_fixed_char(); const ::substrait::Type_FixedChar& fixed_char() const; - ::substrait::Type_FixedChar* release_fixed_char(); + PROTOBUF_NODISCARD ::substrait::Type_FixedChar* release_fixed_char(); ::substrait::Type_FixedChar* mutable_fixed_char(); void set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char); private: @@ -4118,7 +4478,7 @@ class Type PROTOBUF_FINAL : public: void clear_varchar(); const ::substrait::Type_VarChar& varchar() const; - ::substrait::Type_VarChar* release_varchar(); + PROTOBUF_NODISCARD ::substrait::Type_VarChar* release_varchar(); ::substrait::Type_VarChar* mutable_varchar(); void set_allocated_varchar(::substrait::Type_VarChar* varchar); private: @@ -4136,7 +4496,7 @@ class Type PROTOBUF_FINAL : public: void clear_fixed_binary(); const ::substrait::Type_FixedBinary& fixed_binary() const; - ::substrait::Type_FixedBinary* release_fixed_binary(); + PROTOBUF_NODISCARD ::substrait::Type_FixedBinary* release_fixed_binary(); ::substrait::Type_FixedBinary* mutable_fixed_binary(); void set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary); private: @@ -4154,7 +4514,7 @@ class Type PROTOBUF_FINAL : public: void clear_decimal(); const ::substrait::Type_Decimal& decimal() const; - ::substrait::Type_Decimal* release_decimal(); + PROTOBUF_NODISCARD ::substrait::Type_Decimal* release_decimal(); ::substrait::Type_Decimal* mutable_decimal(); void set_allocated_decimal(::substrait::Type_Decimal* decimal); private: @@ -4172,7 +4532,7 @@ class Type PROTOBUF_FINAL : public: void clear_struct_(); const ::substrait::Type_Struct& struct_() const; - ::substrait::Type_Struct* release_struct_(); + PROTOBUF_NODISCARD ::substrait::Type_Struct* release_struct_(); ::substrait::Type_Struct* mutable_struct_(); void set_allocated_struct_(::substrait::Type_Struct* struct_); private: @@ -4190,7 +4550,7 @@ class Type PROTOBUF_FINAL : public: void clear_list(); const ::substrait::Type_List& list() const; - ::substrait::Type_List* release_list(); + PROTOBUF_NODISCARD ::substrait::Type_List* release_list(); ::substrait::Type_List* mutable_list(); void set_allocated_list(::substrait::Type_List* list); private: @@ -4208,7 +4568,7 @@ class Type PROTOBUF_FINAL : public: void clear_map(); const ::substrait::Type_Map& map() const; - ::substrait::Type_Map* release_map(); + PROTOBUF_NODISCARD ::substrait::Type_Map* release_map(); ::substrait::Type_Map* mutable_map(); void set_allocated_map(::substrait::Type_Map* map); private: @@ -4225,11 +4585,11 @@ class Type PROTOBUF_FINAL : bool _internal_has_user_defined_type_reference() const; public: void clear_user_defined_type_reference(); - ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_type_reference() const; - void set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t user_defined_type_reference() const; + void set_user_defined_type_reference(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_user_defined_type_reference() const; - void _internal_set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_user_defined_type_reference() const; + void _internal_set_user_defined_type_reference(uint32_t value); public: void clear_kind(); @@ -4294,16 +4654,16 @@ class Type PROTOBUF_FINAL : ::substrait::Type_Struct* struct__; ::substrait::Type_List* list_; ::substrait::Type_Map* map_; - ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_type_reference_; + uint32_t user_defined_type_reference_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2ftype_2eproto; }; // ------------------------------------------------------------------- -class NamedStruct PROTOBUF_FINAL : +class NamedStruct final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.NamedStruct) */ { public: inline NamedStruct() : NamedStruct(nullptr) {} @@ -4321,8 +4681,13 @@ class NamedStruct PROTOBUF_FINAL : return *this; } inline NamedStruct& operator=(NamedStruct&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -4353,7 +4718,12 @@ class NamedStruct PROTOBUF_FINAL : } inline void Swap(NamedStruct* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -4361,48 +4731,53 @@ class NamedStruct PROTOBUF_FINAL : } void UnsafeArenaSwap(NamedStruct* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline NamedStruct* New() const final { - return CreateMaybeMessage(nullptr); - } - - NamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + NamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const NamedStruct& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const NamedStruct& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(NamedStruct* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.NamedStruct"; } protected: - explicit NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -4444,7 +4819,7 @@ class NamedStruct PROTOBUF_FINAL : public: void clear_struct_(); const ::substrait::Type_Struct& struct_() const; - ::substrait::Type_Struct* release_struct_(); + PROTOBUF_NODISCARD ::substrait::Type_Struct* release_struct_(); ::substrait::Type_Struct* mutable_struct_(); void set_allocated_struct_(::substrait::Type_Struct* struct_); private: @@ -4482,18 +4857,18 @@ class NamedStruct PROTOBUF_FINAL : inline void Type_Boolean::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Boolean::_internal_type_variation_reference() const { +inline uint32_t Type_Boolean::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Boolean::type_variation_reference() const { +inline uint32_t Type_Boolean::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.Boolean.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_Boolean::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Boolean::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_Boolean::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Boolean::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.Boolean.type_variation_reference) } @@ -4526,18 +4901,18 @@ inline void Type_Boolean::set_nullability(::substrait::Type_Nullability value) { inline void Type_I8::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I8::_internal_type_variation_reference() const { +inline uint32_t Type_I8::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I8::type_variation_reference() const { +inline uint32_t Type_I8::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.I8.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_I8::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_I8::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_I8::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_I8::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.I8.type_variation_reference) } @@ -4570,18 +4945,18 @@ inline void Type_I8::set_nullability(::substrait::Type_Nullability value) { inline void Type_I16::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I16::_internal_type_variation_reference() const { +inline uint32_t Type_I16::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I16::type_variation_reference() const { +inline uint32_t Type_I16::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.I16.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_I16::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_I16::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_I16::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_I16::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.I16.type_variation_reference) } @@ -4614,18 +4989,18 @@ inline void Type_I16::set_nullability(::substrait::Type_Nullability value) { inline void Type_I32::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I32::_internal_type_variation_reference() const { +inline uint32_t Type_I32::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I32::type_variation_reference() const { +inline uint32_t Type_I32::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.I32.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_I32::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_I32::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_I32::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_I32::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.I32.type_variation_reference) } @@ -4658,18 +5033,18 @@ inline void Type_I32::set_nullability(::substrait::Type_Nullability value) { inline void Type_I64::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I64::_internal_type_variation_reference() const { +inline uint32_t Type_I64::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_I64::type_variation_reference() const { +inline uint32_t Type_I64::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.I64.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_I64::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_I64::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_I64::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_I64::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.I64.type_variation_reference) } @@ -4702,18 +5077,18 @@ inline void Type_I64::set_nullability(::substrait::Type_Nullability value) { inline void Type_FP32::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP32::_internal_type_variation_reference() const { +inline uint32_t Type_FP32::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP32::type_variation_reference() const { +inline uint32_t Type_FP32::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.FP32.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_FP32::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_FP32::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_FP32::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_FP32::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.FP32.type_variation_reference) } @@ -4746,18 +5121,18 @@ inline void Type_FP32::set_nullability(::substrait::Type_Nullability value) { inline void Type_FP64::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP64::_internal_type_variation_reference() const { +inline uint32_t Type_FP64::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FP64::type_variation_reference() const { +inline uint32_t Type_FP64::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.FP64.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_FP64::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_FP64::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_FP64::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_FP64::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.FP64.type_variation_reference) } @@ -4790,18 +5165,18 @@ inline void Type_FP64::set_nullability(::substrait::Type_Nullability value) { inline void Type_String::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_String::_internal_type_variation_reference() const { +inline uint32_t Type_String::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_String::type_variation_reference() const { +inline uint32_t Type_String::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.String.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_String::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_String::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_String::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_String::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.String.type_variation_reference) } @@ -4834,18 +5209,18 @@ inline void Type_String::set_nullability(::substrait::Type_Nullability value) { inline void Type_Binary::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Binary::_internal_type_variation_reference() const { +inline uint32_t Type_Binary::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Binary::type_variation_reference() const { +inline uint32_t Type_Binary::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.Binary.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_Binary::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Binary::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_Binary::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Binary::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.Binary.type_variation_reference) } @@ -4878,18 +5253,18 @@ inline void Type_Binary::set_nullability(::substrait::Type_Nullability value) { inline void Type_Timestamp::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Timestamp::_internal_type_variation_reference() const { +inline uint32_t Type_Timestamp::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Timestamp::type_variation_reference() const { +inline uint32_t Type_Timestamp::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.Timestamp.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_Timestamp::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Timestamp::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_Timestamp::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Timestamp::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.Timestamp.type_variation_reference) } @@ -4922,18 +5297,18 @@ inline void Type_Timestamp::set_nullability(::substrait::Type_Nullability value) inline void Type_Date::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Date::_internal_type_variation_reference() const { +inline uint32_t Type_Date::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Date::type_variation_reference() const { +inline uint32_t Type_Date::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.Date.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_Date::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Date::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_Date::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Date::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.Date.type_variation_reference) } @@ -4966,18 +5341,18 @@ inline void Type_Date::set_nullability(::substrait::Type_Nullability value) { inline void Type_Time::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Time::_internal_type_variation_reference() const { +inline uint32_t Type_Time::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Time::type_variation_reference() const { +inline uint32_t Type_Time::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.Time.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_Time::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Time::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_Time::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Time::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.Time.type_variation_reference) } @@ -5010,18 +5385,18 @@ inline void Type_Time::set_nullability(::substrait::Type_Nullability value) { inline void Type_TimestampTZ::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_TimestampTZ::_internal_type_variation_reference() const { +inline uint32_t Type_TimestampTZ::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_TimestampTZ::type_variation_reference() const { +inline uint32_t Type_TimestampTZ::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.TimestampTZ.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_TimestampTZ::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_TimestampTZ::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_TimestampTZ::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_TimestampTZ::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.TimestampTZ.type_variation_reference) } @@ -5054,18 +5429,18 @@ inline void Type_TimestampTZ::set_nullability(::substrait::Type_Nullability valu inline void Type_IntervalYear::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalYear::_internal_type_variation_reference() const { +inline uint32_t Type_IntervalYear::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalYear::type_variation_reference() const { +inline uint32_t Type_IntervalYear::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.IntervalYear.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_IntervalYear::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_IntervalYear::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_IntervalYear::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_IntervalYear::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.IntervalYear.type_variation_reference) } @@ -5098,18 +5473,18 @@ inline void Type_IntervalYear::set_nullability(::substrait::Type_Nullability val inline void Type_IntervalDay::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalDay::_internal_type_variation_reference() const { +inline uint32_t Type_IntervalDay::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_IntervalDay::type_variation_reference() const { +inline uint32_t Type_IntervalDay::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.IntervalDay.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_IntervalDay::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_IntervalDay::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_IntervalDay::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_IntervalDay::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.IntervalDay.type_variation_reference) } @@ -5142,18 +5517,18 @@ inline void Type_IntervalDay::set_nullability(::substrait::Type_Nullability valu inline void Type_UUID::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_UUID::_internal_type_variation_reference() const { +inline uint32_t Type_UUID::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_UUID::type_variation_reference() const { +inline uint32_t Type_UUID::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.UUID.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_UUID::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_UUID::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_UUID::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_UUID::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.UUID.type_variation_reference) } @@ -5186,18 +5561,18 @@ inline void Type_UUID::set_nullability(::substrait::Type_Nullability value) { inline void Type_FixedChar::clear_length() { length_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedChar::_internal_length() const { +inline int32_t Type_FixedChar::_internal_length() const { return length_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedChar::length() const { +inline int32_t Type_FixedChar::length() const { // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.length) return _internal_length(); } -inline void Type_FixedChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Type_FixedChar::_internal_set_length(int32_t value) { length_ = value; } -inline void Type_FixedChar::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Type_FixedChar::set_length(int32_t value) { _internal_set_length(value); // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.length) } @@ -5206,18 +5581,18 @@ inline void Type_FixedChar::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { inline void Type_FixedChar::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedChar::_internal_type_variation_reference() const { +inline uint32_t Type_FixedChar::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedChar::type_variation_reference() const { +inline uint32_t Type_FixedChar::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_FixedChar::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_FixedChar::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_FixedChar::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_FixedChar::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.type_variation_reference) } @@ -5250,18 +5625,18 @@ inline void Type_FixedChar::set_nullability(::substrait::Type_Nullability value) inline void Type_VarChar::clear_length() { length_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_VarChar::_internal_length() const { +inline int32_t Type_VarChar::_internal_length() const { return length_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_VarChar::length() const { +inline int32_t Type_VarChar::length() const { // @@protoc_insertion_point(field_get:substrait.Type.VarChar.length) return _internal_length(); } -inline void Type_VarChar::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Type_VarChar::_internal_set_length(int32_t value) { length_ = value; } -inline void Type_VarChar::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Type_VarChar::set_length(int32_t value) { _internal_set_length(value); // @@protoc_insertion_point(field_set:substrait.Type.VarChar.length) } @@ -5270,18 +5645,18 @@ inline void Type_VarChar::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { inline void Type_VarChar::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_VarChar::_internal_type_variation_reference() const { +inline uint32_t Type_VarChar::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_VarChar::type_variation_reference() const { +inline uint32_t Type_VarChar::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.VarChar.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_VarChar::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_VarChar::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_VarChar::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_VarChar::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.VarChar.type_variation_reference) } @@ -5314,18 +5689,18 @@ inline void Type_VarChar::set_nullability(::substrait::Type_Nullability value) { inline void Type_FixedBinary::clear_length() { length_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedBinary::_internal_length() const { +inline int32_t Type_FixedBinary::_internal_length() const { return length_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_FixedBinary::length() const { +inline int32_t Type_FixedBinary::length() const { // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.length) return _internal_length(); } -inline void Type_FixedBinary::_internal_set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Type_FixedBinary::_internal_set_length(int32_t value) { length_ = value; } -inline void Type_FixedBinary::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Type_FixedBinary::set_length(int32_t value) { _internal_set_length(value); // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.length) } @@ -5334,18 +5709,18 @@ inline void Type_FixedBinary::set_length(::PROTOBUF_NAMESPACE_ID::int32 value) { inline void Type_FixedBinary::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedBinary::_internal_type_variation_reference() const { +inline uint32_t Type_FixedBinary::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_FixedBinary::type_variation_reference() const { +inline uint32_t Type_FixedBinary::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_FixedBinary::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_FixedBinary::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_FixedBinary::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_FixedBinary::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.type_variation_reference) } @@ -5378,18 +5753,18 @@ inline void Type_FixedBinary::set_nullability(::substrait::Type_Nullability valu inline void Type_Decimal::clear_scale() { scale_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::_internal_scale() const { +inline int32_t Type_Decimal::_internal_scale() const { return scale_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::scale() const { +inline int32_t Type_Decimal::scale() const { // @@protoc_insertion_point(field_get:substrait.Type.Decimal.scale) return _internal_scale(); } -inline void Type_Decimal::_internal_set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Type_Decimal::_internal_set_scale(int32_t value) { scale_ = value; } -inline void Type_Decimal::set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Type_Decimal::set_scale(int32_t value) { _internal_set_scale(value); // @@protoc_insertion_point(field_set:substrait.Type.Decimal.scale) } @@ -5398,18 +5773,18 @@ inline void Type_Decimal::set_scale(::PROTOBUF_NAMESPACE_ID::int32 value) { inline void Type_Decimal::clear_precision() { precision_ = 0; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::_internal_precision() const { +inline int32_t Type_Decimal::_internal_precision() const { return precision_; } -inline ::PROTOBUF_NAMESPACE_ID::int32 Type_Decimal::precision() const { +inline int32_t Type_Decimal::precision() const { // @@protoc_insertion_point(field_get:substrait.Type.Decimal.precision) return _internal_precision(); } -inline void Type_Decimal::_internal_set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Type_Decimal::_internal_set_precision(int32_t value) { precision_ = value; } -inline void Type_Decimal::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void Type_Decimal::set_precision(int32_t value) { _internal_set_precision(value); // @@protoc_insertion_point(field_set:substrait.Type.Decimal.precision) } @@ -5418,18 +5793,18 @@ inline void Type_Decimal::set_precision(::PROTOBUF_NAMESPACE_ID::int32 value) { inline void Type_Decimal::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Decimal::_internal_type_variation_reference() const { +inline uint32_t Type_Decimal::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Decimal::type_variation_reference() const { +inline uint32_t Type_Decimal::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.Decimal.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_Decimal::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Decimal::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_Decimal::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Decimal::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.Decimal.type_variation_reference) } @@ -5488,8 +5863,9 @@ inline ::substrait::Type* Type_Struct::_internal_add_types() { return types_.Add(); } inline ::substrait::Type* Type_Struct::add_types() { + ::substrait::Type* _add = _internal_add_types(); // @@protoc_insertion_point(field_add:substrait.Type.Struct.types) - return _internal_add_types(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >& Type_Struct::types() const { @@ -5501,18 +5877,18 @@ Type_Struct::types() const { inline void Type_Struct::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Struct::_internal_type_variation_reference() const { +inline uint32_t Type_Struct::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Struct::type_variation_reference() const { +inline uint32_t Type_Struct::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.Struct.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_Struct::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Struct::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_Struct::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Struct::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.Struct.type_variation_reference) } @@ -5549,7 +5925,7 @@ inline bool Type_List::has_type() const { return _internal_has_type(); } inline void Type_List::clear_type() { - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; @@ -5565,7 +5941,7 @@ inline const ::substrait::Type& Type_List::type() const { } inline void Type_List::unsafe_arena_set_allocated_type( ::substrait::Type* type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } type_ = type; @@ -5580,9 +5956,15 @@ inline ::substrait::Type* Type_List::release_type() { ::substrait::Type* temp = type_; type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Type* Type_List::unsafe_arena_release_type() { @@ -5595,23 +5977,24 @@ inline ::substrait::Type* Type_List::unsafe_arena_release_type() { inline ::substrait::Type* Type_List::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); type_ = p; } return type_; } inline ::substrait::Type* Type_List::mutable_type() { + ::substrait::Type* _msg = _internal_mutable_type(); // @@protoc_insertion_point(field_mutable:substrait.Type.List.type) - return _internal_mutable_type(); + return _msg; } inline void Type_List::set_allocated_type(::substrait::Type* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete type_; } if (type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type>::GetOwningArena(type); if (message_arena != submessage_arena) { type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type, submessage_arena); @@ -5628,18 +6011,18 @@ inline void Type_List::set_allocated_type(::substrait::Type* type) { inline void Type_List::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_List::_internal_type_variation_reference() const { +inline uint32_t Type_List::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_List::type_variation_reference() const { +inline uint32_t Type_List::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.List.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_List::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_List::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_List::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_List::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.List.type_variation_reference) } @@ -5676,7 +6059,7 @@ inline bool Type_Map::has_key() const { return _internal_has_key(); } inline void Type_Map::clear_key() { - if (GetArena() == nullptr && key_ != nullptr) { + if (GetArenaForAllocation() == nullptr && key_ != nullptr) { delete key_; } key_ = nullptr; @@ -5692,7 +6075,7 @@ inline const ::substrait::Type& Type_Map::key() const { } inline void Type_Map::unsafe_arena_set_allocated_key( ::substrait::Type* key) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); } key_ = key; @@ -5707,9 +6090,15 @@ inline ::substrait::Type* Type_Map::release_key() { ::substrait::Type* temp = key_; key_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Type* Type_Map::unsafe_arena_release_key() { @@ -5722,23 +6111,24 @@ inline ::substrait::Type* Type_Map::unsafe_arena_release_key() { inline ::substrait::Type* Type_Map::_internal_mutable_key() { if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); key_ = p; } return key_; } inline ::substrait::Type* Type_Map::mutable_key() { + ::substrait::Type* _msg = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:substrait.Type.Map.key) - return _internal_mutable_key(); + return _msg; } inline void Type_Map::set_allocated_key(::substrait::Type* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete key_; } if (key) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type>::GetOwningArena(key); if (message_arena != submessage_arena) { key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, key, submessage_arena); @@ -5759,7 +6149,7 @@ inline bool Type_Map::has_value() const { return _internal_has_value(); } inline void Type_Map::clear_value() { - if (GetArena() == nullptr && value_ != nullptr) { + if (GetArenaForAllocation() == nullptr && value_ != nullptr) { delete value_; } value_ = nullptr; @@ -5775,7 +6165,7 @@ inline const ::substrait::Type& Type_Map::value() const { } inline void Type_Map::unsafe_arena_set_allocated_value( ::substrait::Type* value) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } value_ = value; @@ -5790,9 +6180,15 @@ inline ::substrait::Type* Type_Map::release_value() { ::substrait::Type* temp = value_; value_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Type* Type_Map::unsafe_arena_release_value() { @@ -5805,23 +6201,24 @@ inline ::substrait::Type* Type_Map::unsafe_arena_release_value() { inline ::substrait::Type* Type_Map::_internal_mutable_value() { if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); value_ = p; } return value_; } inline ::substrait::Type* Type_Map::mutable_value() { + ::substrait::Type* _msg = _internal_mutable_value(); // @@protoc_insertion_point(field_mutable:substrait.Type.Map.value) - return _internal_mutable_value(); + return _msg; } inline void Type_Map::set_allocated_value(::substrait::Type* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete value_; } if (value) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type>::GetOwningArena(value); if (message_arena != submessage_arena) { value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, value, submessage_arena); @@ -5838,18 +6235,18 @@ inline void Type_Map::set_allocated_value(::substrait::Type* value) { inline void Type_Map::clear_type_variation_reference() { type_variation_reference_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Map::_internal_type_variation_reference() const { +inline uint32_t Type_Map::_internal_type_variation_reference() const { return type_variation_reference_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type_Map::type_variation_reference() const { +inline uint32_t Type_Map::type_variation_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.Map.type_variation_reference) return _internal_type_variation_reference(); } -inline void Type_Map::_internal_set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Map::_internal_set_type_variation_reference(uint32_t value) { type_variation_reference_ = value; } -inline void Type_Map::set_type_variation_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type_Map::set_type_variation_reference(uint32_t value) { _internal_set_type_variation_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.Map.type_variation_reference) } @@ -5890,7 +6287,7 @@ inline void Type::set_has_bool_() { } inline void Type::clear_bool_() { if (_internal_has_bool_()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.bool__; } clear_has_kind(); @@ -5901,7 +6298,7 @@ inline ::substrait::Type_Boolean* Type::release_bool_() { if (_internal_has_bool_()) { clear_has_kind(); ::substrait::Type_Boolean* temp = kind_.bool__; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.bool__ = nullptr; @@ -5942,13 +6339,14 @@ inline ::substrait::Type_Boolean* Type::_internal_mutable_bool_() { if (!_internal_has_bool_()) { clear_kind(); set_has_bool_(); - kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArena()); + kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArenaForAllocation()); } return kind_.bool__; } inline ::substrait::Type_Boolean* Type::mutable_bool_() { + ::substrait::Type_Boolean* _msg = _internal_mutable_bool_(); // @@protoc_insertion_point(field_mutable:substrait.Type.bool) - return _internal_mutable_bool_(); + return _msg; } // .substrait.Type.I8 i8 = 2; @@ -5963,7 +6361,7 @@ inline void Type::set_has_i8() { } inline void Type::clear_i8() { if (_internal_has_i8()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i8_; } clear_has_kind(); @@ -5974,7 +6372,7 @@ inline ::substrait::Type_I8* Type::release_i8() { if (_internal_has_i8()) { clear_has_kind(); ::substrait::Type_I8* temp = kind_.i8_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i8_ = nullptr; @@ -6015,13 +6413,14 @@ inline ::substrait::Type_I8* Type::_internal_mutable_i8() { if (!_internal_has_i8()) { clear_kind(); set_has_i8(); - kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArena()); + kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArenaForAllocation()); } return kind_.i8_; } inline ::substrait::Type_I8* Type::mutable_i8() { + ::substrait::Type_I8* _msg = _internal_mutable_i8(); // @@protoc_insertion_point(field_mutable:substrait.Type.i8) - return _internal_mutable_i8(); + return _msg; } // .substrait.Type.I16 i16 = 3; @@ -6036,7 +6435,7 @@ inline void Type::set_has_i16() { } inline void Type::clear_i16() { if (_internal_has_i16()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i16_; } clear_has_kind(); @@ -6047,7 +6446,7 @@ inline ::substrait::Type_I16* Type::release_i16() { if (_internal_has_i16()) { clear_has_kind(); ::substrait::Type_I16* temp = kind_.i16_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i16_ = nullptr; @@ -6088,13 +6487,14 @@ inline ::substrait::Type_I16* Type::_internal_mutable_i16() { if (!_internal_has_i16()) { clear_kind(); set_has_i16(); - kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArena()); + kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArenaForAllocation()); } return kind_.i16_; } inline ::substrait::Type_I16* Type::mutable_i16() { + ::substrait::Type_I16* _msg = _internal_mutable_i16(); // @@protoc_insertion_point(field_mutable:substrait.Type.i16) - return _internal_mutable_i16(); + return _msg; } // .substrait.Type.I32 i32 = 5; @@ -6109,7 +6509,7 @@ inline void Type::set_has_i32() { } inline void Type::clear_i32() { if (_internal_has_i32()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i32_; } clear_has_kind(); @@ -6120,7 +6520,7 @@ inline ::substrait::Type_I32* Type::release_i32() { if (_internal_has_i32()) { clear_has_kind(); ::substrait::Type_I32* temp = kind_.i32_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i32_ = nullptr; @@ -6161,13 +6561,14 @@ inline ::substrait::Type_I32* Type::_internal_mutable_i32() { if (!_internal_has_i32()) { clear_kind(); set_has_i32(); - kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArena()); + kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArenaForAllocation()); } return kind_.i32_; } inline ::substrait::Type_I32* Type::mutable_i32() { + ::substrait::Type_I32* _msg = _internal_mutable_i32(); // @@protoc_insertion_point(field_mutable:substrait.Type.i32) - return _internal_mutable_i32(); + return _msg; } // .substrait.Type.I64 i64 = 7; @@ -6182,7 +6583,7 @@ inline void Type::set_has_i64() { } inline void Type::clear_i64() { if (_internal_has_i64()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i64_; } clear_has_kind(); @@ -6193,7 +6594,7 @@ inline ::substrait::Type_I64* Type::release_i64() { if (_internal_has_i64()) { clear_has_kind(); ::substrait::Type_I64* temp = kind_.i64_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i64_ = nullptr; @@ -6234,13 +6635,14 @@ inline ::substrait::Type_I64* Type::_internal_mutable_i64() { if (!_internal_has_i64()) { clear_kind(); set_has_i64(); - kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArena()); + kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArenaForAllocation()); } return kind_.i64_; } inline ::substrait::Type_I64* Type::mutable_i64() { + ::substrait::Type_I64* _msg = _internal_mutable_i64(); // @@protoc_insertion_point(field_mutable:substrait.Type.i64) - return _internal_mutable_i64(); + return _msg; } // .substrait.Type.FP32 fp32 = 10; @@ -6255,7 +6657,7 @@ inline void Type::set_has_fp32() { } inline void Type::clear_fp32() { if (_internal_has_fp32()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp32_; } clear_has_kind(); @@ -6266,7 +6668,7 @@ inline ::substrait::Type_FP32* Type::release_fp32() { if (_internal_has_fp32()) { clear_has_kind(); ::substrait::Type_FP32* temp = kind_.fp32_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fp32_ = nullptr; @@ -6307,13 +6709,14 @@ inline ::substrait::Type_FP32* Type::_internal_mutable_fp32() { if (!_internal_has_fp32()) { clear_kind(); set_has_fp32(); - kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArena()); + kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArenaForAllocation()); } return kind_.fp32_; } inline ::substrait::Type_FP32* Type::mutable_fp32() { + ::substrait::Type_FP32* _msg = _internal_mutable_fp32(); // @@protoc_insertion_point(field_mutable:substrait.Type.fp32) - return _internal_mutable_fp32(); + return _msg; } // .substrait.Type.FP64 fp64 = 11; @@ -6328,7 +6731,7 @@ inline void Type::set_has_fp64() { } inline void Type::clear_fp64() { if (_internal_has_fp64()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp64_; } clear_has_kind(); @@ -6339,7 +6742,7 @@ inline ::substrait::Type_FP64* Type::release_fp64() { if (_internal_has_fp64()) { clear_has_kind(); ::substrait::Type_FP64* temp = kind_.fp64_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fp64_ = nullptr; @@ -6380,13 +6783,14 @@ inline ::substrait::Type_FP64* Type::_internal_mutable_fp64() { if (!_internal_has_fp64()) { clear_kind(); set_has_fp64(); - kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArena()); + kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArenaForAllocation()); } return kind_.fp64_; } inline ::substrait::Type_FP64* Type::mutable_fp64() { + ::substrait::Type_FP64* _msg = _internal_mutable_fp64(); // @@protoc_insertion_point(field_mutable:substrait.Type.fp64) - return _internal_mutable_fp64(); + return _msg; } // .substrait.Type.String string = 12; @@ -6401,7 +6805,7 @@ inline void Type::set_has_string() { } inline void Type::clear_string() { if (_internal_has_string()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.string_; } clear_has_kind(); @@ -6412,7 +6816,7 @@ inline ::substrait::Type_String* Type::release_string() { if (_internal_has_string()) { clear_has_kind(); ::substrait::Type_String* temp = kind_.string_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.string_ = nullptr; @@ -6453,13 +6857,14 @@ inline ::substrait::Type_String* Type::_internal_mutable_string() { if (!_internal_has_string()) { clear_kind(); set_has_string(); - kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArena()); + kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArenaForAllocation()); } return kind_.string_; } inline ::substrait::Type_String* Type::mutable_string() { + ::substrait::Type_String* _msg = _internal_mutable_string(); // @@protoc_insertion_point(field_mutable:substrait.Type.string) - return _internal_mutable_string(); + return _msg; } // .substrait.Type.Binary binary = 13; @@ -6474,7 +6879,7 @@ inline void Type::set_has_binary() { } inline void Type::clear_binary() { if (_internal_has_binary()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.binary_; } clear_has_kind(); @@ -6485,7 +6890,7 @@ inline ::substrait::Type_Binary* Type::release_binary() { if (_internal_has_binary()) { clear_has_kind(); ::substrait::Type_Binary* temp = kind_.binary_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.binary_ = nullptr; @@ -6526,13 +6931,14 @@ inline ::substrait::Type_Binary* Type::_internal_mutable_binary() { if (!_internal_has_binary()) { clear_kind(); set_has_binary(); - kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArena()); + kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArenaForAllocation()); } return kind_.binary_; } inline ::substrait::Type_Binary* Type::mutable_binary() { + ::substrait::Type_Binary* _msg = _internal_mutable_binary(); // @@protoc_insertion_point(field_mutable:substrait.Type.binary) - return _internal_mutable_binary(); + return _msg; } // .substrait.Type.Timestamp timestamp = 14; @@ -6547,7 +6953,7 @@ inline void Type::set_has_timestamp() { } inline void Type::clear_timestamp() { if (_internal_has_timestamp()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_; } clear_has_kind(); @@ -6558,7 +6964,7 @@ inline ::substrait::Type_Timestamp* Type::release_timestamp() { if (_internal_has_timestamp()) { clear_has_kind(); ::substrait::Type_Timestamp* temp = kind_.timestamp_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.timestamp_ = nullptr; @@ -6599,13 +7005,14 @@ inline ::substrait::Type_Timestamp* Type::_internal_mutable_timestamp() { if (!_internal_has_timestamp()) { clear_kind(); set_has_timestamp(); - kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArena()); + kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArenaForAllocation()); } return kind_.timestamp_; } inline ::substrait::Type_Timestamp* Type::mutable_timestamp() { + ::substrait::Type_Timestamp* _msg = _internal_mutable_timestamp(); // @@protoc_insertion_point(field_mutable:substrait.Type.timestamp) - return _internal_mutable_timestamp(); + return _msg; } // .substrait.Type.Date date = 16; @@ -6620,7 +7027,7 @@ inline void Type::set_has_date() { } inline void Type::clear_date() { if (_internal_has_date()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.date_; } clear_has_kind(); @@ -6631,7 +7038,7 @@ inline ::substrait::Type_Date* Type::release_date() { if (_internal_has_date()) { clear_has_kind(); ::substrait::Type_Date* temp = kind_.date_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.date_ = nullptr; @@ -6672,13 +7079,14 @@ inline ::substrait::Type_Date* Type::_internal_mutable_date() { if (!_internal_has_date()) { clear_kind(); set_has_date(); - kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArena()); + kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArenaForAllocation()); } return kind_.date_; } inline ::substrait::Type_Date* Type::mutable_date() { + ::substrait::Type_Date* _msg = _internal_mutable_date(); // @@protoc_insertion_point(field_mutable:substrait.Type.date) - return _internal_mutable_date(); + return _msg; } // .substrait.Type.Time time = 17; @@ -6693,7 +7101,7 @@ inline void Type::set_has_time() { } inline void Type::clear_time() { if (_internal_has_time()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.time_; } clear_has_kind(); @@ -6704,7 +7112,7 @@ inline ::substrait::Type_Time* Type::release_time() { if (_internal_has_time()) { clear_has_kind(); ::substrait::Type_Time* temp = kind_.time_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.time_ = nullptr; @@ -6745,13 +7153,14 @@ inline ::substrait::Type_Time* Type::_internal_mutable_time() { if (!_internal_has_time()) { clear_kind(); set_has_time(); - kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArena()); + kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArenaForAllocation()); } return kind_.time_; } inline ::substrait::Type_Time* Type::mutable_time() { + ::substrait::Type_Time* _msg = _internal_mutable_time(); // @@protoc_insertion_point(field_mutable:substrait.Type.time) - return _internal_mutable_time(); + return _msg; } // .substrait.Type.IntervalYear interval_year = 19; @@ -6766,7 +7175,7 @@ inline void Type::set_has_interval_year() { } inline void Type::clear_interval_year() { if (_internal_has_interval_year()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_year_; } clear_has_kind(); @@ -6777,7 +7186,7 @@ inline ::substrait::Type_IntervalYear* Type::release_interval_year() { if (_internal_has_interval_year()) { clear_has_kind(); ::substrait::Type_IntervalYear* temp = kind_.interval_year_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.interval_year_ = nullptr; @@ -6818,13 +7227,14 @@ inline ::substrait::Type_IntervalYear* Type::_internal_mutable_interval_year() { if (!_internal_has_interval_year()) { clear_kind(); set_has_interval_year(); - kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArena()); + kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArenaForAllocation()); } return kind_.interval_year_; } inline ::substrait::Type_IntervalYear* Type::mutable_interval_year() { + ::substrait::Type_IntervalYear* _msg = _internal_mutable_interval_year(); // @@protoc_insertion_point(field_mutable:substrait.Type.interval_year) - return _internal_mutable_interval_year(); + return _msg; } // .substrait.Type.IntervalDay interval_day = 20; @@ -6839,7 +7249,7 @@ inline void Type::set_has_interval_day() { } inline void Type::clear_interval_day() { if (_internal_has_interval_day()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_day_; } clear_has_kind(); @@ -6850,7 +7260,7 @@ inline ::substrait::Type_IntervalDay* Type::release_interval_day() { if (_internal_has_interval_day()) { clear_has_kind(); ::substrait::Type_IntervalDay* temp = kind_.interval_day_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.interval_day_ = nullptr; @@ -6891,13 +7301,14 @@ inline ::substrait::Type_IntervalDay* Type::_internal_mutable_interval_day() { if (!_internal_has_interval_day()) { clear_kind(); set_has_interval_day(); - kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArena()); + kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArenaForAllocation()); } return kind_.interval_day_; } inline ::substrait::Type_IntervalDay* Type::mutable_interval_day() { + ::substrait::Type_IntervalDay* _msg = _internal_mutable_interval_day(); // @@protoc_insertion_point(field_mutable:substrait.Type.interval_day) - return _internal_mutable_interval_day(); + return _msg; } // .substrait.Type.TimestampTZ timestamp_tz = 29; @@ -6912,7 +7323,7 @@ inline void Type::set_has_timestamp_tz() { } inline void Type::clear_timestamp_tz() { if (_internal_has_timestamp_tz()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_tz_; } clear_has_kind(); @@ -6923,7 +7334,7 @@ inline ::substrait::Type_TimestampTZ* Type::release_timestamp_tz() { if (_internal_has_timestamp_tz()) { clear_has_kind(); ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.timestamp_tz_ = nullptr; @@ -6964,13 +7375,14 @@ inline ::substrait::Type_TimestampTZ* Type::_internal_mutable_timestamp_tz() { if (!_internal_has_timestamp_tz()) { clear_kind(); set_has_timestamp_tz(); - kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArena()); + kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArenaForAllocation()); } return kind_.timestamp_tz_; } inline ::substrait::Type_TimestampTZ* Type::mutable_timestamp_tz() { + ::substrait::Type_TimestampTZ* _msg = _internal_mutable_timestamp_tz(); // @@protoc_insertion_point(field_mutable:substrait.Type.timestamp_tz) - return _internal_mutable_timestamp_tz(); + return _msg; } // .substrait.Type.UUID uuid = 32; @@ -6985,7 +7397,7 @@ inline void Type::set_has_uuid() { } inline void Type::clear_uuid() { if (_internal_has_uuid()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.uuid_; } clear_has_kind(); @@ -6996,7 +7408,7 @@ inline ::substrait::Type_UUID* Type::release_uuid() { if (_internal_has_uuid()) { clear_has_kind(); ::substrait::Type_UUID* temp = kind_.uuid_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.uuid_ = nullptr; @@ -7037,13 +7449,14 @@ inline ::substrait::Type_UUID* Type::_internal_mutable_uuid() { if (!_internal_has_uuid()) { clear_kind(); set_has_uuid(); - kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArena()); + kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArenaForAllocation()); } return kind_.uuid_; } inline ::substrait::Type_UUID* Type::mutable_uuid() { + ::substrait::Type_UUID* _msg = _internal_mutable_uuid(); // @@protoc_insertion_point(field_mutable:substrait.Type.uuid) - return _internal_mutable_uuid(); + return _msg; } // .substrait.Type.FixedChar fixed_char = 21; @@ -7058,7 +7471,7 @@ inline void Type::set_has_fixed_char() { } inline void Type::clear_fixed_char() { if (_internal_has_fixed_char()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_char_; } clear_has_kind(); @@ -7069,7 +7482,7 @@ inline ::substrait::Type_FixedChar* Type::release_fixed_char() { if (_internal_has_fixed_char()) { clear_has_kind(); ::substrait::Type_FixedChar* temp = kind_.fixed_char_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fixed_char_ = nullptr; @@ -7110,13 +7523,14 @@ inline ::substrait::Type_FixedChar* Type::_internal_mutable_fixed_char() { if (!_internal_has_fixed_char()) { clear_kind(); set_has_fixed_char(); - kind_.fixed_char_ = CreateMaybeMessage< ::substrait::Type_FixedChar >(GetArena()); + kind_.fixed_char_ = CreateMaybeMessage< ::substrait::Type_FixedChar >(GetArenaForAllocation()); } return kind_.fixed_char_; } inline ::substrait::Type_FixedChar* Type::mutable_fixed_char() { + ::substrait::Type_FixedChar* _msg = _internal_mutable_fixed_char(); // @@protoc_insertion_point(field_mutable:substrait.Type.fixed_char) - return _internal_mutable_fixed_char(); + return _msg; } // .substrait.Type.VarChar varchar = 22; @@ -7131,7 +7545,7 @@ inline void Type::set_has_varchar() { } inline void Type::clear_varchar() { if (_internal_has_varchar()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.varchar_; } clear_has_kind(); @@ -7142,7 +7556,7 @@ inline ::substrait::Type_VarChar* Type::release_varchar() { if (_internal_has_varchar()) { clear_has_kind(); ::substrait::Type_VarChar* temp = kind_.varchar_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.varchar_ = nullptr; @@ -7183,13 +7597,14 @@ inline ::substrait::Type_VarChar* Type::_internal_mutable_varchar() { if (!_internal_has_varchar()) { clear_kind(); set_has_varchar(); - kind_.varchar_ = CreateMaybeMessage< ::substrait::Type_VarChar >(GetArena()); + kind_.varchar_ = CreateMaybeMessage< ::substrait::Type_VarChar >(GetArenaForAllocation()); } return kind_.varchar_; } inline ::substrait::Type_VarChar* Type::mutable_varchar() { + ::substrait::Type_VarChar* _msg = _internal_mutable_varchar(); // @@protoc_insertion_point(field_mutable:substrait.Type.varchar) - return _internal_mutable_varchar(); + return _msg; } // .substrait.Type.FixedBinary fixed_binary = 23; @@ -7204,7 +7619,7 @@ inline void Type::set_has_fixed_binary() { } inline void Type::clear_fixed_binary() { if (_internal_has_fixed_binary()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_binary_; } clear_has_kind(); @@ -7215,7 +7630,7 @@ inline ::substrait::Type_FixedBinary* Type::release_fixed_binary() { if (_internal_has_fixed_binary()) { clear_has_kind(); ::substrait::Type_FixedBinary* temp = kind_.fixed_binary_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fixed_binary_ = nullptr; @@ -7256,13 +7671,14 @@ inline ::substrait::Type_FixedBinary* Type::_internal_mutable_fixed_binary() { if (!_internal_has_fixed_binary()) { clear_kind(); set_has_fixed_binary(); - kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::Type_FixedBinary >(GetArena()); + kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::Type_FixedBinary >(GetArenaForAllocation()); } return kind_.fixed_binary_; } inline ::substrait::Type_FixedBinary* Type::mutable_fixed_binary() { + ::substrait::Type_FixedBinary* _msg = _internal_mutable_fixed_binary(); // @@protoc_insertion_point(field_mutable:substrait.Type.fixed_binary) - return _internal_mutable_fixed_binary(); + return _msg; } // .substrait.Type.Decimal decimal = 24; @@ -7277,7 +7693,7 @@ inline void Type::set_has_decimal() { } inline void Type::clear_decimal() { if (_internal_has_decimal()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.decimal_; } clear_has_kind(); @@ -7288,7 +7704,7 @@ inline ::substrait::Type_Decimal* Type::release_decimal() { if (_internal_has_decimal()) { clear_has_kind(); ::substrait::Type_Decimal* temp = kind_.decimal_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.decimal_ = nullptr; @@ -7329,13 +7745,14 @@ inline ::substrait::Type_Decimal* Type::_internal_mutable_decimal() { if (!_internal_has_decimal()) { clear_kind(); set_has_decimal(); - kind_.decimal_ = CreateMaybeMessage< ::substrait::Type_Decimal >(GetArena()); + kind_.decimal_ = CreateMaybeMessage< ::substrait::Type_Decimal >(GetArenaForAllocation()); } return kind_.decimal_; } inline ::substrait::Type_Decimal* Type::mutable_decimal() { + ::substrait::Type_Decimal* _msg = _internal_mutable_decimal(); // @@protoc_insertion_point(field_mutable:substrait.Type.decimal) - return _internal_mutable_decimal(); + return _msg; } // .substrait.Type.Struct struct = 25; @@ -7350,7 +7767,7 @@ inline void Type::set_has_struct_() { } inline void Type::clear_struct_() { if (_internal_has_struct_()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.struct__; } clear_has_kind(); @@ -7361,7 +7778,7 @@ inline ::substrait::Type_Struct* Type::release_struct_() { if (_internal_has_struct_()) { clear_has_kind(); ::substrait::Type_Struct* temp = kind_.struct__; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.struct__ = nullptr; @@ -7402,13 +7819,14 @@ inline ::substrait::Type_Struct* Type::_internal_mutable_struct_() { if (!_internal_has_struct_()) { clear_kind(); set_has_struct_(); - kind_.struct__ = CreateMaybeMessage< ::substrait::Type_Struct >(GetArena()); + kind_.struct__ = CreateMaybeMessage< ::substrait::Type_Struct >(GetArenaForAllocation()); } return kind_.struct__; } inline ::substrait::Type_Struct* Type::mutable_struct_() { + ::substrait::Type_Struct* _msg = _internal_mutable_struct_(); // @@protoc_insertion_point(field_mutable:substrait.Type.struct) - return _internal_mutable_struct_(); + return _msg; } // .substrait.Type.List list = 27; @@ -7423,7 +7841,7 @@ inline void Type::set_has_list() { } inline void Type::clear_list() { if (_internal_has_list()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.list_; } clear_has_kind(); @@ -7434,7 +7852,7 @@ inline ::substrait::Type_List* Type::release_list() { if (_internal_has_list()) { clear_has_kind(); ::substrait::Type_List* temp = kind_.list_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.list_ = nullptr; @@ -7475,13 +7893,14 @@ inline ::substrait::Type_List* Type::_internal_mutable_list() { if (!_internal_has_list()) { clear_kind(); set_has_list(); - kind_.list_ = CreateMaybeMessage< ::substrait::Type_List >(GetArena()); + kind_.list_ = CreateMaybeMessage< ::substrait::Type_List >(GetArenaForAllocation()); } return kind_.list_; } inline ::substrait::Type_List* Type::mutable_list() { + ::substrait::Type_List* _msg = _internal_mutable_list(); // @@protoc_insertion_point(field_mutable:substrait.Type.list) - return _internal_mutable_list(); + return _msg; } // .substrait.Type.Map map = 28; @@ -7496,7 +7915,7 @@ inline void Type::set_has_map() { } inline void Type::clear_map() { if (_internal_has_map()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.map_; } clear_has_kind(); @@ -7507,7 +7926,7 @@ inline ::substrait::Type_Map* Type::release_map() { if (_internal_has_map()) { clear_has_kind(); ::substrait::Type_Map* temp = kind_.map_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.map_ = nullptr; @@ -7548,13 +7967,14 @@ inline ::substrait::Type_Map* Type::_internal_mutable_map() { if (!_internal_has_map()) { clear_kind(); set_has_map(); - kind_.map_ = CreateMaybeMessage< ::substrait::Type_Map >(GetArena()); + kind_.map_ = CreateMaybeMessage< ::substrait::Type_Map >(GetArenaForAllocation()); } return kind_.map_; } inline ::substrait::Type_Map* Type::mutable_map() { + ::substrait::Type_Map* _msg = _internal_mutable_map(); // @@protoc_insertion_point(field_mutable:substrait.Type.map) - return _internal_mutable_map(); + return _msg; } // uint32 user_defined_type_reference = 31; @@ -7573,24 +7993,24 @@ inline void Type::clear_user_defined_type_reference() { clear_has_kind(); } } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type::_internal_user_defined_type_reference() const { +inline uint32_t Type::_internal_user_defined_type_reference() const { if (_internal_has_user_defined_type_reference()) { return kind_.user_defined_type_reference_; } return 0u; } -inline void Type::_internal_set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type::_internal_set_user_defined_type_reference(uint32_t value) { if (!_internal_has_user_defined_type_reference()) { clear_kind(); set_has_user_defined_type_reference(); } kind_.user_defined_type_reference_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 Type::user_defined_type_reference() const { +inline uint32_t Type::user_defined_type_reference() const { // @@protoc_insertion_point(field_get:substrait.Type.user_defined_type_reference) return _internal_user_defined_type_reference(); } -inline void Type::set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void Type::set_user_defined_type_reference(uint32_t value) { _internal_set_user_defined_type_reference(value); // @@protoc_insertion_point(field_set:substrait.Type.user_defined_type_reference) } @@ -7619,8 +8039,9 @@ inline void NamedStruct::clear_names() { names_.Clear(); } inline std::string* NamedStruct::add_names() { + std::string* _s = _internal_add_names(); // @@protoc_insertion_point(field_add_mutable:substrait.NamedStruct.names) - return _internal_add_names(); + return _s; } inline const std::string& NamedStruct::_internal_names(int index) const { return names_.Get(index); @@ -7634,12 +8055,12 @@ inline std::string* NamedStruct::mutable_names(int index) { return names_.Mutable(index); } inline void NamedStruct::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.NamedStruct.names) names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.NamedStruct.names) } inline void NamedStruct::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.NamedStruct.names) names_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.NamedStruct.names) } inline void NamedStruct::set_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -7690,7 +8111,7 @@ inline bool NamedStruct::has_struct_() const { return _internal_has_struct_(); } inline void NamedStruct::clear_struct_() { - if (GetArena() == nullptr && struct__ != nullptr) { + if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { delete struct__; } struct__ = nullptr; @@ -7706,7 +8127,7 @@ inline const ::substrait::Type_Struct& NamedStruct::struct_() const { } inline void NamedStruct::unsafe_arena_set_allocated_struct_( ::substrait::Type_Struct* struct_) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); } struct__ = struct_; @@ -7721,9 +8142,15 @@ inline ::substrait::Type_Struct* NamedStruct::release_struct_() { ::substrait::Type_Struct* temp = struct__; struct__ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::Type_Struct* NamedStruct::unsafe_arena_release_struct_() { @@ -7736,23 +8163,24 @@ inline ::substrait::Type_Struct* NamedStruct::unsafe_arena_release_struct_() { inline ::substrait::Type_Struct* NamedStruct::_internal_mutable_struct_() { if (struct__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type_Struct>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::Type_Struct>(GetArenaForAllocation()); struct__ = p; } return struct__; } inline ::substrait::Type_Struct* NamedStruct::mutable_struct_() { + ::substrait::Type_Struct* _msg = _internal_mutable_struct_(); // @@protoc_insertion_point(field_mutable:substrait.NamedStruct.struct) - return _internal_mutable_struct_(); + return _msg; } inline void NamedStruct::set_allocated_struct_(::substrait::Type_Struct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete struct__; } if (struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Struct>::GetOwningArena(struct_); if (message_arena != submessage_arena) { struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, struct_, submessage_arena); diff --git a/cpp/src/generated/substrait/type_expressions.pb.cc b/cpp/src/generated/substrait/type_expressions.pb.cc index ff92154ed83..1179ab8e3ad 100644 --- a/cpp/src/generated/substrait/type_expressions.pb.cc +++ b/cpp/src/generated/substrait/type_expressions.pb.cc @@ -223,12 +223,13 @@ static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ftype_5f static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[2]; static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ftype_5fexpressions_2eproto = nullptr; -const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { +const uint32_t TableStruct_substrait_2ftype_5fexpressions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, _internal_metadata_), ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, length_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, variation_pointer_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, nullability_), @@ -237,6 +238,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, length_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, variation_pointer_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, nullability_), @@ -245,6 +247,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, length_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, variation_pointer_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, nullability_), @@ -253,6 +256,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, scale_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, precision_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, variation_pointer_), @@ -262,6 +266,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, types_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, variation_pointer_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, nullability_), @@ -270,6 +275,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, names_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, struct__), ~0u, // no _has_bits_ @@ -277,6 +283,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, type_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, variation_pointer_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, nullability_), @@ -285,6 +292,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, key_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, value_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, variation_pointer_), @@ -294,6 +302,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, if_condition_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, if_return_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, else_return_), @@ -302,6 +311,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, op_type_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, arg_), ~0u, // no _has_bits_ @@ -309,6 +319,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, op_type_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, arg1_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, arg2_), @@ -317,6 +328,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, name_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, expression_), ~0u, // no _has_bits_ @@ -324,6 +336,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ ~0u, // no _oneof_case_ ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, assignments_), PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, final_expression_), ~0u, // no _has_bits_ @@ -331,6 +344,7 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions ~0u, // no _extensions_ PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, _oneof_case_[0]), ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, @@ -365,20 +379,20 @@ const ::PROTOBUF_NAMESPACE_ID::uint32 TableStruct_substrait_2ftype_5fexpressions PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, kind_), }; static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedChar)}, - { 8, -1, sizeof(::substrait::DerivationExpression_ExpressionVarChar)}, - { 16, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedBinary)}, - { 24, -1, sizeof(::substrait::DerivationExpression_ExpressionDecimal)}, - { 33, -1, sizeof(::substrait::DerivationExpression_ExpressionStruct)}, - { 41, -1, sizeof(::substrait::DerivationExpression_ExpressionNamedStruct)}, - { 48, -1, sizeof(::substrait::DerivationExpression_ExpressionList)}, - { 56, -1, sizeof(::substrait::DerivationExpression_ExpressionMap)}, - { 65, -1, sizeof(::substrait::DerivationExpression_IfElse)}, - { 73, -1, sizeof(::substrait::DerivationExpression_UnaryOp)}, - { 80, -1, sizeof(::substrait::DerivationExpression_BinaryOp)}, - { 88, -1, sizeof(::substrait::DerivationExpression_ReturnProgram_Assignment)}, - { 95, -1, sizeof(::substrait::DerivationExpression_ReturnProgram)}, - { 102, -1, sizeof(::substrait::DerivationExpression)}, + { 0, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedChar)}, + { 9, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionVarChar)}, + { 18, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedBinary)}, + { 27, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionDecimal)}, + { 37, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionStruct)}, + { 46, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionNamedStruct)}, + { 54, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionList)}, + { 63, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionMap)}, + { 73, -1, -1, sizeof(::substrait::DerivationExpression_IfElse)}, + { 82, -1, -1, sizeof(::substrait::DerivationExpression_UnaryOp)}, + { 90, -1, -1, sizeof(::substrait::DerivationExpression_BinaryOp)}, + { 99, -1, -1, sizeof(::substrait::DerivationExpression_ReturnProgram_Assignment)}, + { 107, -1, -1, sizeof(::substrait::DerivationExpression_ReturnProgram)}, + { 115, -1, -1, sizeof(::substrait::DerivationExpression)}, }; static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { @@ -534,13 +548,13 @@ bool DerivationExpression_UnaryOp_UnaryOpType_IsValid(int value) { } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UNARY_OP_TYPE_UNSPECIFIED; constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UNARY_OP_TYPE_BOOLEAN_NOT; constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UnaryOpType_MIN; constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UnaryOpType_MAX; constexpr int DerivationExpression_UnaryOp::UnaryOpType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_BinaryOpType_descriptor() { ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_5fexpressions_2eproto); return file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[1]; @@ -566,7 +580,7 @@ bool DerivationExpression_BinaryOp_BinaryOpType_IsValid(int value) { } } -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_UNSPECIFIED; constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_PLUS; constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MINUS; @@ -583,7 +597,7 @@ constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_Binary constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BinaryOpType_MIN; constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BinaryOpType_MAX; constexpr int DerivationExpression_BinaryOp::BinaryOpType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || _MSC_VER >= 1900) +#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) // =================================================================== @@ -596,10 +610,13 @@ const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::_Internal::length(const DerivationExpression_ExpressionFixedChar* msg) { return *msg->length_; } -DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionFixedChar) } DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(const DerivationExpression_ExpressionFixedChar& from) @@ -616,7 +633,7 @@ DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedCh // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedChar) } -void DerivationExpression_ExpressionFixedChar::SharedCtor() { +inline void DerivationExpression_ExpressionFixedChar::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -625,12 +642,13 @@ ::memset(reinterpret_cast(this) + static_cast( DerivationExpression_ExpressionFixedChar::~DerivationExpression_ExpressionFixedChar() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionFixedChar) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_ExpressionFixedChar::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_ExpressionFixedChar::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete length_; } @@ -646,11 +664,11 @@ void DerivationExpression_ExpressionFixedChar::SetCachedSize(int size) const { void DerivationExpression_ExpressionFixedChar::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionFixedChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -663,62 +681,65 @@ void DerivationExpression_ExpressionFixedChar::Clear() { const char* DerivationExpression_ExpressionFixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.DerivationExpression length = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedChar::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_ExpressionFixedChar::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionFixedChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.DerivationExpression length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -726,13 +747,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedChar::_Inter } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -750,77 +771,60 @@ size_t DerivationExpression_ExpressionFixedChar::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionFixedChar) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.DerivationExpression length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *length_); } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_ExpressionFixedChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionFixedChar) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_ExpressionFixedChar* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionFixedChar) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionFixedChar) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionFixedChar::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_ExpressionFixedChar::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionFixedChar::GetClassData() const { return &_class_data_; } + +void DerivationExpression_ExpressionFixedChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_ExpressionFixedChar::MergeFrom(const DerivationExpression_ExpressionFixedChar& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionFixedChar) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_length()) { + if (from._internal_has_length()) { _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void DerivationExpression_ExpressionFixedChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionFixedChar) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_ExpressionFixedChar::CopyFrom(const DerivationExpression_ExpressionFixedChar& from) { @@ -836,7 +840,7 @@ bool DerivationExpression_ExpressionFixedChar::IsInitialized() const { void DerivationExpression_ExpressionFixedChar::InternalSwap(DerivationExpression_ExpressionFixedChar* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedChar, nullability_) + sizeof(DerivationExpression_ExpressionFixedChar::nullability_) @@ -862,10 +866,13 @@ const ::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::_Internal::length(const DerivationExpression_ExpressionVarChar* msg) { return *msg->length_; } -DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionVarChar) } DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(const DerivationExpression_ExpressionVarChar& from) @@ -882,7 +889,7 @@ DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(c // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionVarChar) } -void DerivationExpression_ExpressionVarChar::SharedCtor() { +inline void DerivationExpression_ExpressionVarChar::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -891,12 +898,13 @@ ::memset(reinterpret_cast(this) + static_cast( DerivationExpression_ExpressionVarChar::~DerivationExpression_ExpressionVarChar() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionVarChar) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_ExpressionVarChar::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_ExpressionVarChar::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete length_; } @@ -912,11 +920,11 @@ void DerivationExpression_ExpressionVarChar::SetCachedSize(int size) const { void DerivationExpression_ExpressionVarChar::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionVarChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -929,62 +937,65 @@ void DerivationExpression_ExpressionVarChar::Clear() { const char* DerivationExpression_ExpressionVarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.DerivationExpression length = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionVarChar::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_ExpressionVarChar::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionVarChar) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.DerivationExpression length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -992,13 +1003,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionVarChar::_Interna } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -1016,77 +1027,60 @@ size_t DerivationExpression_ExpressionVarChar::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionVarChar) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.DerivationExpression length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *length_); } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_ExpressionVarChar::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionVarChar) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_ExpressionVarChar* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionVarChar) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionVarChar) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionVarChar::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_ExpressionVarChar::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionVarChar::GetClassData() const { return &_class_data_; } + +void DerivationExpression_ExpressionVarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_ExpressionVarChar::MergeFrom(const DerivationExpression_ExpressionVarChar& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionVarChar) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_length()) { + if (from._internal_has_length()) { _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void DerivationExpression_ExpressionVarChar::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionVarChar) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_ExpressionVarChar::CopyFrom(const DerivationExpression_ExpressionVarChar& from) { @@ -1102,7 +1096,7 @@ bool DerivationExpression_ExpressionVarChar::IsInitialized() const { void DerivationExpression_ExpressionVarChar::InternalSwap(DerivationExpression_ExpressionVarChar* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionVarChar, nullability_) + sizeof(DerivationExpression_ExpressionVarChar::nullability_) @@ -1128,10 +1122,13 @@ const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::_Internal::length(const DerivationExpression_ExpressionFixedBinary* msg) { return *msg->length_; } -DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionFixedBinary) } DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(const DerivationExpression_ExpressionFixedBinary& from) @@ -1148,7 +1145,7 @@ DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixed // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedBinary) } -void DerivationExpression_ExpressionFixedBinary::SharedCtor() { +inline void DerivationExpression_ExpressionFixedBinary::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&length_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1157,12 +1154,13 @@ ::memset(reinterpret_cast(this) + static_cast( DerivationExpression_ExpressionFixedBinary::~DerivationExpression_ExpressionFixedBinary() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionFixedBinary) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_ExpressionFixedBinary::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_ExpressionFixedBinary::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete length_; } @@ -1178,11 +1176,11 @@ void DerivationExpression_ExpressionFixedBinary::SetCachedSize(int size) const { void DerivationExpression_ExpressionFixedBinary::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionFixedBinary) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -1195,62 +1193,65 @@ void DerivationExpression_ExpressionFixedBinary::Clear() { const char* DerivationExpression_ExpressionFixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.DerivationExpression length = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedBinary::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_ExpressionFixedBinary::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionFixedBinary) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.DerivationExpression length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1258,13 +1259,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionFixedBinary::_Int } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -1282,77 +1283,60 @@ size_t DerivationExpression_ExpressionFixedBinary::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionFixedBinary) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.DerivationExpression length = 1; - if (this->has_length()) { + if (this->_internal_has_length()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *length_); } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_ExpressionFixedBinary::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionFixedBinary) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_ExpressionFixedBinary* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionFixedBinary) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionFixedBinary) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionFixedBinary::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_ExpressionFixedBinary::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionFixedBinary::GetClassData() const { return &_class_data_; } + +void DerivationExpression_ExpressionFixedBinary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_ExpressionFixedBinary::MergeFrom(const DerivationExpression_ExpressionFixedBinary& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionFixedBinary) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_length()) { + if (from._internal_has_length()) { _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void DerivationExpression_ExpressionFixedBinary::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionFixedBinary) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_ExpressionFixedBinary::CopyFrom(const DerivationExpression_ExpressionFixedBinary& from) { @@ -1368,7 +1352,7 @@ bool DerivationExpression_ExpressionFixedBinary::IsInitialized() const { void DerivationExpression_ExpressionFixedBinary::InternalSwap(DerivationExpression_ExpressionFixedBinary* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedBinary, nullability_) + sizeof(DerivationExpression_ExpressionFixedBinary::nullability_) @@ -1399,10 +1383,13 @@ const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_Internal::precision(const DerivationExpression_ExpressionDecimal* msg) { return *msg->precision_; } -DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionDecimal) } DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(const DerivationExpression_ExpressionDecimal& from) @@ -1424,7 +1411,7 @@ DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(c // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionDecimal) } -void DerivationExpression_ExpressionDecimal::SharedCtor() { +inline void DerivationExpression_ExpressionDecimal::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&scale_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1433,12 +1420,13 @@ ::memset(reinterpret_cast(this) + static_cast( DerivationExpression_ExpressionDecimal::~DerivationExpression_ExpressionDecimal() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionDecimal) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_ExpressionDecimal::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_ExpressionDecimal::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete scale_; if (this != internal_default_instance()) delete precision_; } @@ -1455,15 +1443,15 @@ void DerivationExpression_ExpressionDecimal::SetCachedSize(int size) const { void DerivationExpression_ExpressionDecimal::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionDecimal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && scale_ != nullptr) { + if (GetArenaForAllocation() == nullptr && scale_ != nullptr) { delete scale_; } scale_ = nullptr; - if (GetArena() == nullptr && precision_ != nullptr) { + if (GetArenaForAllocation() == nullptr && precision_ != nullptr) { delete precision_; } precision_ = nullptr; @@ -1476,69 +1464,73 @@ void DerivationExpression_ExpressionDecimal::Clear() { const char* DerivationExpression_ExpressionDecimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.DerivationExpression scale = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression precision = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionDecimal::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_ExpressionDecimal::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionDecimal) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.DerivationExpression scale = 1; - if (this->has_scale()) { + if (this->_internal_has_scale()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1546,7 +1538,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionDecimal::_Interna } // .substrait.DerivationExpression precision = 2; - if (this->has_precision()) { + if (this->_internal_has_precision()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -1554,13 +1546,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionDecimal::_Interna } // uint32 variation_pointer = 3; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 4, this->_internal_nullability(), target); @@ -1578,87 +1570,70 @@ size_t DerivationExpression_ExpressionDecimal::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionDecimal) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.DerivationExpression scale = 1; - if (this->has_scale()) { + if (this->_internal_has_scale()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *scale_); } // .substrait.DerivationExpression precision = 2; - if (this->has_precision()) { + if (this->_internal_has_precision()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *precision_); } // uint32 variation_pointer = 3; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_ExpressionDecimal::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionDecimal) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_ExpressionDecimal* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionDecimal) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionDecimal) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionDecimal::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_ExpressionDecimal::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionDecimal::GetClassData() const { return &_class_data_; } + +void DerivationExpression_ExpressionDecimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_ExpressionDecimal::MergeFrom(const DerivationExpression_ExpressionDecimal& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionDecimal) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_scale()) { + if (from._internal_has_scale()) { _internal_mutable_scale()->::substrait::DerivationExpression::MergeFrom(from._internal_scale()); } - if (from.has_precision()) { + if (from._internal_has_precision()) { _internal_mutable_precision()->::substrait::DerivationExpression::MergeFrom(from._internal_precision()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void DerivationExpression_ExpressionDecimal::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionDecimal) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_ExpressionDecimal::CopyFrom(const DerivationExpression_ExpressionDecimal& from) { @@ -1674,7 +1649,7 @@ bool DerivationExpression_ExpressionDecimal::IsInitialized() const { void DerivationExpression_ExpressionDecimal::InternalSwap(DerivationExpression_ExpressionDecimal* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionDecimal, nullability_) + sizeof(DerivationExpression_ExpressionDecimal::nullability_) @@ -1695,11 +1670,14 @@ class DerivationExpression_ExpressionStruct::_Internal { public: }; -DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), types_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionStruct) } DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(const DerivationExpression_ExpressionStruct& from) @@ -1712,7 +1690,7 @@ DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(con // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionStruct) } -void DerivationExpression_ExpressionStruct::SharedCtor() { +inline void DerivationExpression_ExpressionStruct::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&variation_pointer_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -1721,12 +1699,13 @@ ::memset(reinterpret_cast(this) + static_cast( DerivationExpression_ExpressionStruct::~DerivationExpression_ExpressionStruct() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionStruct) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_ExpressionStruct::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_ExpressionStruct::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); } void DerivationExpression_ExpressionStruct::ArenaDtor(void* object) { @@ -1741,7 +1720,7 @@ void DerivationExpression_ExpressionStruct::SetCachedSize(int size) const { void DerivationExpression_ExpressionStruct::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1755,12 +1734,12 @@ void DerivationExpression_ExpressionStruct::Clear() { const char* DerivationExpression_ExpressionStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.DerivationExpression types = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -1768,50 +1747,53 @@ const char* DerivationExpression_ExpressionStruct::_InternalParse(const char* pt CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionStruct::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_ExpressionStruct::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.DerivationExpression types = 1; @@ -1823,13 +1805,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionStruct::_Internal } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -1847,7 +1829,7 @@ size_t DerivationExpression_ExpressionStruct::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionStruct) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -1859,63 +1841,46 @@ size_t DerivationExpression_ExpressionStruct::ByteSizeLong() const { } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_ExpressionStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionStruct) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_ExpressionStruct* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionStruct) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionStruct) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionStruct::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_ExpressionStruct::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionStruct::GetClassData() const { return &_class_data_; } + +void DerivationExpression_ExpressionStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_ExpressionStruct::MergeFrom(const DerivationExpression_ExpressionStruct& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionStruct) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; types_.MergeFrom(from.types_); - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void DerivationExpression_ExpressionStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_ExpressionStruct::CopyFrom(const DerivationExpression_ExpressionStruct& from) { @@ -1931,7 +1896,7 @@ bool DerivationExpression_ExpressionStruct::IsInitialized() const { void DerivationExpression_ExpressionStruct::InternalSwap(DerivationExpression_ExpressionStruct* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); types_.InternalSwap(&other->types_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, nullability_) @@ -1958,11 +1923,14 @@ const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::_Internal::struct_(const DerivationExpression_ExpressionNamedStruct* msg) { return *msg->struct__; } -DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), names_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionNamedStruct) } DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(const DerivationExpression_ExpressionNamedStruct& from) @@ -1977,18 +1945,19 @@ DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamed // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionNamedStruct) } -void DerivationExpression_ExpressionNamedStruct::SharedCtor() { +inline void DerivationExpression_ExpressionNamedStruct::SharedCtor() { struct__ = nullptr; } DerivationExpression_ExpressionNamedStruct::~DerivationExpression_ExpressionNamedStruct() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionNamedStruct) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_ExpressionNamedStruct::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_ExpressionNamedStruct::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete struct__; } @@ -2004,12 +1973,12 @@ void DerivationExpression_ExpressionNamedStruct::SetCachedSize(int size) const { void DerivationExpression_ExpressionNamedStruct::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionNamedStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; names_.Clear(); - if (GetArena() == nullptr && struct__ != nullptr) { + if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { delete struct__; } struct__ = nullptr; @@ -2019,12 +1988,12 @@ void DerivationExpression_ExpressionNamedStruct::Clear() { const char* DerivationExpression_ExpressionNamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated string names = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -2034,42 +2003,44 @@ const char* DerivationExpression_ExpressionNamedStruct::_InternalParse(const cha CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.ExpressionStruct struct = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionNamedStruct::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_ExpressionNamedStruct::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionNamedStruct) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated string names = 1; @@ -2083,7 +2054,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionNamedStruct::_Int } // .substrait.DerivationExpression.ExpressionStruct struct = 2; - if (this->has_struct_()) { + if (this->_internal_has_struct_()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2102,7 +2073,7 @@ size_t DerivationExpression_ExpressionNamedStruct::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionNamedStruct) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -2115,54 +2086,39 @@ size_t DerivationExpression_ExpressionNamedStruct::ByteSizeLong() const { } // .substrait.DerivationExpression.ExpressionStruct struct = 2; - if (this->has_struct_()) { + if (this->_internal_has_struct_()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *struct__); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_ExpressionNamedStruct::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionNamedStruct) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_ExpressionNamedStruct* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionNamedStruct) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionNamedStruct) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionNamedStruct::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_ExpressionNamedStruct::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionNamedStruct::GetClassData() const { return &_class_data_; } + +void DerivationExpression_ExpressionNamedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_ExpressionNamedStruct::MergeFrom(const DerivationExpression_ExpressionNamedStruct& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionNamedStruct) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; names_.MergeFrom(from.names_); - if (from.has_struct_()) { + if (from._internal_has_struct_()) { _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); } -} - -void DerivationExpression_ExpressionNamedStruct::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionNamedStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_ExpressionNamedStruct::CopyFrom(const DerivationExpression_ExpressionNamedStruct& from) { @@ -2178,7 +2134,7 @@ bool DerivationExpression_ExpressionNamedStruct::IsInitialized() const { void DerivationExpression_ExpressionNamedStruct::InternalSwap(DerivationExpression_ExpressionNamedStruct* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); names_.InternalSwap(&other->names_); swap(struct__, other->struct__); } @@ -2200,10 +2156,13 @@ const ::substrait::DerivationExpression& DerivationExpression_ExpressionList::_Internal::type(const DerivationExpression_ExpressionList* msg) { return *msg->type_; } -DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionList) } DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(const DerivationExpression_ExpressionList& from) @@ -2220,7 +2179,7 @@ DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(const D // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionList) } -void DerivationExpression_ExpressionList::SharedCtor() { +inline void DerivationExpression_ExpressionList::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&type_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -2229,12 +2188,13 @@ ::memset(reinterpret_cast(this) + static_cast( DerivationExpression_ExpressionList::~DerivationExpression_ExpressionList() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionList) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_ExpressionList::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_ExpressionList::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete type_; } @@ -2250,11 +2210,11 @@ void DerivationExpression_ExpressionList::SetCachedSize(int size) const { void DerivationExpression_ExpressionList::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionList) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; @@ -2267,62 +2227,65 @@ void DerivationExpression_ExpressionList::Clear() { const char* DerivationExpression_ExpressionList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.DerivationExpression type = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionList::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_ExpressionList::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionList) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.DerivationExpression type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2330,13 +2293,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionList::_InternalSe } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 3, this->_internal_nullability(), target); @@ -2354,77 +2317,60 @@ size_t DerivationExpression_ExpressionList::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionList) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.DerivationExpression type = 1; - if (this->has_type()) { + if (this->_internal_has_type()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *type_); } // uint32 variation_pointer = 2; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 3; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_ExpressionList::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionList) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_ExpressionList* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionList) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionList) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionList::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_ExpressionList::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionList::GetClassData() const { return &_class_data_; } + +void DerivationExpression_ExpressionList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_ExpressionList::MergeFrom(const DerivationExpression_ExpressionList& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionList) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_type()) { + if (from._internal_has_type()) { _internal_mutable_type()->::substrait::DerivationExpression::MergeFrom(from._internal_type()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void DerivationExpression_ExpressionList::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionList) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_ExpressionList::CopyFrom(const DerivationExpression_ExpressionList& from) { @@ -2440,7 +2386,7 @@ bool DerivationExpression_ExpressionList::IsInitialized() const { void DerivationExpression_ExpressionList::InternalSwap(DerivationExpression_ExpressionList* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionList, nullability_) + sizeof(DerivationExpression_ExpressionList::nullability_) @@ -2471,10 +2417,13 @@ const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_Internal::value(const DerivationExpression_ExpressionMap* msg) { return *msg->value_; } -DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionMap) } DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(const DerivationExpression_ExpressionMap& from) @@ -2496,7 +2445,7 @@ DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(const Der // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionMap) } -void DerivationExpression_ExpressionMap::SharedCtor() { +inline void DerivationExpression_ExpressionMap::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&key_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&nullability_) - @@ -2505,12 +2454,13 @@ ::memset(reinterpret_cast(this) + static_cast( DerivationExpression_ExpressionMap::~DerivationExpression_ExpressionMap() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionMap) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_ExpressionMap::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_ExpressionMap::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete key_; if (this != internal_default_instance()) delete value_; } @@ -2527,15 +2477,15 @@ void DerivationExpression_ExpressionMap::SetCachedSize(int size) const { void DerivationExpression_ExpressionMap::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionMap) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && key_ != nullptr) { + if (GetArenaForAllocation() == nullptr && key_ != nullptr) { delete key_; } key_ = nullptr; - if (GetArena() == nullptr && value_ != nullptr) { + if (GetArenaForAllocation() == nullptr && value_ != nullptr) { delete value_; } value_ = nullptr; @@ -2548,69 +2498,73 @@ void DerivationExpression_ExpressionMap::Clear() { const char* DerivationExpression_ExpressionMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.DerivationExpression key = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression value = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 variation_pointer = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Nullability nullability = 4; case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionMap::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_ExpressionMap::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionMap) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.DerivationExpression key = 1; - if (this->has_key()) { + if (this->_internal_has_key()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2618,7 +2572,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionMap::_InternalSer } // .substrait.DerivationExpression value = 2; - if (this->has_value()) { + if (this->_internal_has_value()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2626,13 +2580,13 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ExpressionMap::_InternalSer } // uint32 variation_pointer = 3; - if (this->variation_pointer() != 0) { + if (this->_internal_variation_pointer() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 4, this->_internal_nullability(), target); @@ -2650,87 +2604,70 @@ size_t DerivationExpression_ExpressionMap::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionMap) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.DerivationExpression key = 1; - if (this->has_key()) { + if (this->_internal_has_key()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *key_); } // .substrait.DerivationExpression value = 2; - if (this->has_value()) { + if (this->_internal_has_value()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *value_); } // uint32 variation_pointer = 3; - if (this->variation_pointer() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_variation_pointer()); + if (this->_internal_variation_pointer() != 0) { + total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); } // .substrait.Type.Nullability nullability = 4; - if (this->nullability() != 0) { + if (this->_internal_nullability() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_ExpressionMap::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ExpressionMap) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_ExpressionMap* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ExpressionMap) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ExpressionMap) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionMap::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_ExpressionMap::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionMap::GetClassData() const { return &_class_data_; } + +void DerivationExpression_ExpressionMap::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_ExpressionMap::MergeFrom(const DerivationExpression_ExpressionMap& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionMap) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_key()) { + if (from._internal_has_key()) { _internal_mutable_key()->::substrait::DerivationExpression::MergeFrom(from._internal_key()); } - if (from.has_value()) { + if (from._internal_has_value()) { _internal_mutable_value()->::substrait::DerivationExpression::MergeFrom(from._internal_value()); } - if (from.variation_pointer() != 0) { + if (from._internal_variation_pointer() != 0) { _internal_set_variation_pointer(from._internal_variation_pointer()); } - if (from.nullability() != 0) { + if (from._internal_nullability() != 0) { _internal_set_nullability(from._internal_nullability()); } -} - -void DerivationExpression_ExpressionMap::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ExpressionMap) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_ExpressionMap::CopyFrom(const DerivationExpression_ExpressionMap& from) { @@ -2746,7 +2683,7 @@ bool DerivationExpression_ExpressionMap::IsInitialized() const { void DerivationExpression_ExpressionMap::InternalSwap(DerivationExpression_ExpressionMap* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionMap, nullability_) + sizeof(DerivationExpression_ExpressionMap::nullability_) @@ -2782,10 +2719,13 @@ const ::substrait::DerivationExpression& DerivationExpression_IfElse::_Internal::else_return(const DerivationExpression_IfElse* msg) { return *msg->else_return_; } -DerivationExpression_IfElse::DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression_IfElse::DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.IfElse) } DerivationExpression_IfElse::DerivationExpression_IfElse(const DerivationExpression_IfElse& from) @@ -2809,7 +2749,7 @@ DerivationExpression_IfElse::DerivationExpression_IfElse(const DerivationExpress // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.IfElse) } -void DerivationExpression_IfElse::SharedCtor() { +inline void DerivationExpression_IfElse::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&if_condition_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&else_return_) - @@ -2818,12 +2758,13 @@ ::memset(reinterpret_cast(this) + static_cast( DerivationExpression_IfElse::~DerivationExpression_IfElse() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.IfElse) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_IfElse::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_IfElse::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete if_condition_; if (this != internal_default_instance()) delete if_return_; if (this != internal_default_instance()) delete else_return_; @@ -2841,19 +2782,19 @@ void DerivationExpression_IfElse::SetCachedSize(int size) const { void DerivationExpression_IfElse::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.IfElse) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && if_condition_ != nullptr) { + if (GetArenaForAllocation() == nullptr && if_condition_ != nullptr) { delete if_condition_; } if_condition_ = nullptr; - if (GetArena() == nullptr && if_return_ != nullptr) { + if (GetArenaForAllocation() == nullptr && if_return_ != nullptr) { delete if_return_; } if_return_ = nullptr; - if (GetArena() == nullptr && else_return_ != nullptr) { + if (GetArenaForAllocation() == nullptr && else_return_ != nullptr) { delete else_return_; } else_return_ = nullptr; @@ -2863,61 +2804,64 @@ void DerivationExpression_IfElse::Clear() { const char* DerivationExpression_IfElse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.DerivationExpression if_condition = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_if_condition(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression if_return = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_if_return(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression else_return = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_else_return(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_IfElse::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_IfElse::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.IfElse) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.DerivationExpression if_condition = 1; - if (this->has_if_condition()) { + if (this->_internal_has_if_condition()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2925,7 +2869,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_IfElse::_InternalSerialize( } // .substrait.DerivationExpression if_return = 2; - if (this->has_if_return()) { + if (this->_internal_has_if_return()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2933,7 +2877,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_IfElse::_InternalSerialize( } // .substrait.DerivationExpression else_return = 3; - if (this->has_else_return()) { + if (this->_internal_has_else_return()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -2952,78 +2896,63 @@ size_t DerivationExpression_IfElse::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.IfElse) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.DerivationExpression if_condition = 1; - if (this->has_if_condition()) { + if (this->_internal_has_if_condition()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *if_condition_); } // .substrait.DerivationExpression if_return = 2; - if (this->has_if_return()) { + if (this->_internal_has_if_return()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *if_return_); } // .substrait.DerivationExpression else_return = 3; - if (this->has_else_return()) { + if (this->_internal_has_else_return()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *else_return_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_IfElse::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.IfElse) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_IfElse* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.IfElse) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.IfElse) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_IfElse::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_IfElse::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_IfElse::GetClassData() const { return &_class_data_; } + +void DerivationExpression_IfElse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_IfElse::MergeFrom(const DerivationExpression_IfElse& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.IfElse) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_if_condition()) { + if (from._internal_has_if_condition()) { _internal_mutable_if_condition()->::substrait::DerivationExpression::MergeFrom(from._internal_if_condition()); } - if (from.has_if_return()) { + if (from._internal_has_if_return()) { _internal_mutable_if_return()->::substrait::DerivationExpression::MergeFrom(from._internal_if_return()); } - if (from.has_else_return()) { + if (from._internal_has_else_return()) { _internal_mutable_else_return()->::substrait::DerivationExpression::MergeFrom(from._internal_else_return()); } -} - -void DerivationExpression_IfElse::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.IfElse) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_IfElse::CopyFrom(const DerivationExpression_IfElse& from) { @@ -3039,7 +2968,7 @@ bool DerivationExpression_IfElse::IsInitialized() const { void DerivationExpression_IfElse::InternalSwap(DerivationExpression_IfElse* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_IfElse, else_return_) + sizeof(DerivationExpression_IfElse::else_return_) @@ -3065,10 +2994,13 @@ const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::_Internal::arg(const DerivationExpression_UnaryOp* msg) { return *msg->arg_; } -DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.UnaryOp) } DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(const DerivationExpression_UnaryOp& from) @@ -3083,7 +3015,7 @@ DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(const DerivationExpre // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.UnaryOp) } -void DerivationExpression_UnaryOp::SharedCtor() { +inline void DerivationExpression_UnaryOp::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&arg_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&op_type_) - @@ -3092,12 +3024,13 @@ ::memset(reinterpret_cast(this) + static_cast( DerivationExpression_UnaryOp::~DerivationExpression_UnaryOp() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.UnaryOp) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_UnaryOp::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_UnaryOp::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete arg_; } @@ -3113,11 +3046,11 @@ void DerivationExpression_UnaryOp::SetCachedSize(int size) const { void DerivationExpression_UnaryOp::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.UnaryOp) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && arg_ != nullptr) { + if (GetArenaForAllocation() == nullptr && arg_ != nullptr) { delete arg_; } arg_ = nullptr; @@ -3128,62 +3061,64 @@ void DerivationExpression_UnaryOp::Clear() { const char* DerivationExpression_UnaryOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_op_type(static_cast<::substrait::DerivationExpression_UnaryOp_UnaryOpType>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression arg = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_arg(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_UnaryOp::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_UnaryOp::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.UnaryOp) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; - if (this->op_type() != 0) { + if (this->_internal_op_type() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_op_type(), target); } // .substrait.DerivationExpression arg = 2; - if (this->has_arg()) { + if (this->_internal_has_arg()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3202,67 +3137,52 @@ size_t DerivationExpression_UnaryOp::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.UnaryOp) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.DerivationExpression arg = 2; - if (this->has_arg()) { + if (this->_internal_has_arg()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *arg_); } // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; - if (this->op_type() != 0) { + if (this->_internal_op_type() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_UnaryOp::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.UnaryOp) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_UnaryOp* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.UnaryOp) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.UnaryOp) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_UnaryOp::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_UnaryOp::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_UnaryOp::GetClassData() const { return &_class_data_; } + +void DerivationExpression_UnaryOp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_UnaryOp::MergeFrom(const DerivationExpression_UnaryOp& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.UnaryOp) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_arg()) { + if (from._internal_has_arg()) { _internal_mutable_arg()->::substrait::DerivationExpression::MergeFrom(from._internal_arg()); } - if (from.op_type() != 0) { + if (from._internal_op_type() != 0) { _internal_set_op_type(from._internal_op_type()); } -} - -void DerivationExpression_UnaryOp::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.UnaryOp) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_UnaryOp::CopyFrom(const DerivationExpression_UnaryOp& from) { @@ -3278,7 +3198,7 @@ bool DerivationExpression_UnaryOp::IsInitialized() const { void DerivationExpression_UnaryOp::InternalSwap(DerivationExpression_UnaryOp* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_UnaryOp, op_type_) + sizeof(DerivationExpression_UnaryOp::op_type_) @@ -3309,10 +3229,13 @@ const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_Internal::arg2(const DerivationExpression_BinaryOp* msg) { return *msg->arg2_; } -DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.BinaryOp) } DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(const DerivationExpression_BinaryOp& from) @@ -3332,7 +3255,7 @@ DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(const DerivationExp // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.BinaryOp) } -void DerivationExpression_BinaryOp::SharedCtor() { +inline void DerivationExpression_BinaryOp::SharedCtor() { ::memset(reinterpret_cast(this) + static_cast( reinterpret_cast(&arg1_) - reinterpret_cast(this)), 0, static_cast(reinterpret_cast(&op_type_) - @@ -3341,12 +3264,13 @@ ::memset(reinterpret_cast(this) + static_cast( DerivationExpression_BinaryOp::~DerivationExpression_BinaryOp() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.BinaryOp) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_BinaryOp::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_BinaryOp::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete arg1_; if (this != internal_default_instance()) delete arg2_; } @@ -3363,15 +3287,15 @@ void DerivationExpression_BinaryOp::SetCachedSize(int size) const { void DerivationExpression_BinaryOp::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.BinaryOp) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; - if (GetArena() == nullptr && arg1_ != nullptr) { + if (GetArenaForAllocation() == nullptr && arg1_ != nullptr) { delete arg1_; } arg1_ = nullptr; - if (GetArena() == nullptr && arg2_ != nullptr) { + if (GetArenaForAllocation() == nullptr && arg2_ != nullptr) { delete arg2_; } arg2_ = nullptr; @@ -3382,69 +3306,72 @@ void DerivationExpression_BinaryOp::Clear() { const char* DerivationExpression_BinaryOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) { - ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { + uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); CHK_(ptr); _internal_set_op_type(static_cast<::substrait::DerivationExpression_BinaryOp_BinaryOpType>(val)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression arg1 = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_arg1(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression arg2 = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_arg2(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_BinaryOp::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_BinaryOp::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.BinaryOp) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; - if (this->op_type() != 0) { + if (this->_internal_op_type() != 0) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( 1, this->_internal_op_type(), target); } // .substrait.DerivationExpression arg1 = 2; - if (this->has_arg1()) { + if (this->_internal_has_arg1()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3452,7 +3379,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_BinaryOp::_InternalSerializ } // .substrait.DerivationExpression arg2 = 3; - if (this->has_arg2()) { + if (this->_internal_has_arg2()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3471,77 +3398,62 @@ size_t DerivationExpression_BinaryOp::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.BinaryOp) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // .substrait.DerivationExpression arg1 = 2; - if (this->has_arg1()) { + if (this->_internal_has_arg1()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *arg1_); } // .substrait.DerivationExpression arg2 = 3; - if (this->has_arg2()) { + if (this->_internal_has_arg2()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *arg2_); } // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; - if (this->op_type() != 0) { + if (this->_internal_op_type() != 0) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type()); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_BinaryOp::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.BinaryOp) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_BinaryOp* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.BinaryOp) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.BinaryOp) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_BinaryOp::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_BinaryOp::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_BinaryOp::GetClassData() const { return &_class_data_; } + +void DerivationExpression_BinaryOp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_BinaryOp::MergeFrom(const DerivationExpression_BinaryOp& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.BinaryOp) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.has_arg1()) { + if (from._internal_has_arg1()) { _internal_mutable_arg1()->::substrait::DerivationExpression::MergeFrom(from._internal_arg1()); } - if (from.has_arg2()) { + if (from._internal_has_arg2()) { _internal_mutable_arg2()->::substrait::DerivationExpression::MergeFrom(from._internal_arg2()); } - if (from.op_type() != 0) { + if (from._internal_op_type() != 0) { _internal_set_op_type(from._internal_op_type()); } -} - -void DerivationExpression_BinaryOp::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.BinaryOp) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_BinaryOp::CopyFrom(const DerivationExpression_BinaryOp& from) { @@ -3557,7 +3469,7 @@ bool DerivationExpression_BinaryOp::IsInitialized() const { void DerivationExpression_BinaryOp::InternalSwap(DerivationExpression_BinaryOp* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); ::PROTOBUF_NAMESPACE_ID::internal::memswap< PROTOBUF_FIELD_OFFSET(DerivationExpression_BinaryOp, op_type_) + sizeof(DerivationExpression_BinaryOp::op_type_) @@ -3583,19 +3495,25 @@ const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::_Internal::expression(const DerivationExpression_ReturnProgram_Assignment* msg) { return *msg->expression_; } -DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ReturnProgram.Assignment) } DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(const DerivationExpression_ReturnProgram_Assignment& from) : ::PROTOBUF_NAMESPACE_ID::Message() { _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); + #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING if (!from._internal_name().empty()) { name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArena()); + GetArenaForAllocation()); } if (from._internal_has_expression()) { expression_ = new ::substrait::DerivationExpression(*from.expression_); @@ -3605,19 +3523,23 @@ DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgra // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ReturnProgram.Assignment) } -void DerivationExpression_ReturnProgram_Assignment::SharedCtor() { +inline void DerivationExpression_ReturnProgram_Assignment::SharedCtor() { name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING expression_ = nullptr; } DerivationExpression_ReturnProgram_Assignment::~DerivationExpression_ReturnProgram_Assignment() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ReturnProgram.Assignment) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_ReturnProgram_Assignment::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_ReturnProgram_Assignment::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); if (this != internal_default_instance()) delete expression_; } @@ -3634,12 +3556,12 @@ void DerivationExpression_ReturnProgram_Assignment::SetCachedSize(int size) cons void DerivationExpression_ReturnProgram_Assignment::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ReturnProgram.Assignment) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; name_.ClearToEmpty(); - if (GetArena() == nullptr && expression_ != nullptr) { + if (GetArenaForAllocation() == nullptr && expression_ != nullptr) { delete expression_; } expression_ = nullptr; @@ -3649,56 +3571,58 @@ void DerivationExpression_ReturnProgram_Assignment::Clear() { const char* DerivationExpression_ReturnProgram_Assignment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // string name = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.ReturnProgram.Assignment.name")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression expression = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram_Assignment::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_ReturnProgram_Assignment::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ReturnProgram.Assignment) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // string name = 1; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( this->_internal_name().data(), static_cast(this->_internal_name().length()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, @@ -3708,7 +3632,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram_Assignment::_ } // .substrait.DerivationExpression expression = 2; - if (this->has_expression()) { + if (this->_internal_has_expression()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3727,68 +3651,53 @@ size_t DerivationExpression_ReturnProgram_Assignment::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ReturnProgram.Assignment) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; // string name = 1; - if (this->name().size() > 0) { + if (!this->_internal_name().empty()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( this->_internal_name()); } // .substrait.DerivationExpression expression = 2; - if (this->has_expression()) { + if (this->_internal_has_expression()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *expression_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_ReturnProgram_Assignment::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ReturnProgram.Assignment) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_ReturnProgram_Assignment* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ReturnProgram.Assignment) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ReturnProgram.Assignment) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ReturnProgram_Assignment::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_ReturnProgram_Assignment::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ReturnProgram_Assignment::GetClassData() const { return &_class_data_; } + +void DerivationExpression_ReturnProgram_Assignment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_ReturnProgram_Assignment::MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ReturnProgram.Assignment) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; - if (from.name().size() > 0) { + if (!from._internal_name().empty()) { _internal_set_name(from._internal_name()); } - if (from.has_expression()) { + if (from._internal_has_expression()) { _internal_mutable_expression()->::substrait::DerivationExpression::MergeFrom(from._internal_expression()); } -} - -void DerivationExpression_ReturnProgram_Assignment::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ReturnProgram.Assignment) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_ReturnProgram_Assignment::CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from) { @@ -3804,8 +3713,14 @@ bool DerivationExpression_ReturnProgram_Assignment::IsInitialized() const { void DerivationExpression_ReturnProgram_Assignment::InternalSwap(DerivationExpression_ReturnProgram_Assignment* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); - name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + auto* lhs_arena = GetArenaForAllocation(); + auto* rhs_arena = other->GetArenaForAllocation(); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( + &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), + &name_, lhs_arena, + &other->name_, rhs_arena + ); swap(expression_, other->expression_); } @@ -3826,11 +3741,14 @@ const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram::_Internal::final_expression(const DerivationExpression_ReturnProgram* msg) { return *msg->final_expression_; } -DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena), +DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), assignments_(arena) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ReturnProgram) } DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(const DerivationExpression_ReturnProgram& from) @@ -3845,18 +3763,19 @@ DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(const Der // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ReturnProgram) } -void DerivationExpression_ReturnProgram::SharedCtor() { +inline void DerivationExpression_ReturnProgram::SharedCtor() { final_expression_ = nullptr; } DerivationExpression_ReturnProgram::~DerivationExpression_ReturnProgram() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ReturnProgram) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression_ReturnProgram::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression_ReturnProgram::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (this != internal_default_instance()) delete final_expression_; } @@ -3872,12 +3791,12 @@ void DerivationExpression_ReturnProgram::SetCachedSize(int size) const { void DerivationExpression_ReturnProgram::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ReturnProgram) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; assignments_.Clear(); - if (GetArena() == nullptr && final_expression_ != nullptr) { + if (GetArenaForAllocation() == nullptr && final_expression_ != nullptr) { delete final_expression_; } final_expression_ = nullptr; @@ -3887,12 +3806,12 @@ void DerivationExpression_ReturnProgram::Clear() { const char* DerivationExpression_ReturnProgram::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr -= 1; do { ptr += 1; @@ -3900,42 +3819,44 @@ const char* DerivationExpression_ReturnProgram::_InternalParse(const char* ptr, CHK_(ptr); if (!ctx->DataAvailable(ptr)) break; } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression final_expression = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_final_expression(), ptr); CHK_(ptr); - } else goto handle_unusual; - continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); + } 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression_ReturnProgram::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ReturnProgram) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; @@ -3947,7 +3868,7 @@ ::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression_ReturnProgram::_InternalSer } // .substrait.DerivationExpression final_expression = 2; - if (this->has_final_expression()) { + if (this->_internal_has_final_expression()) { target = stream->EnsureSpace(target); target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: InternalWriteMessage( @@ -3966,7 +3887,7 @@ size_t DerivationExpression_ReturnProgram::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ReturnProgram) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -3978,54 +3899,39 @@ size_t DerivationExpression_ReturnProgram::ByteSizeLong() const { } // .substrait.DerivationExpression final_expression = 2; - if (this->has_final_expression()) { + if (this->_internal_has_final_expression()) { total_size += 1 + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( *final_expression_); } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression_ReturnProgram::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression.ReturnProgram) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression_ReturnProgram* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression.ReturnProgram) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression.ReturnProgram) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ReturnProgram::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression_ReturnProgram::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ReturnProgram::GetClassData() const { return &_class_data_; } + +void DerivationExpression_ReturnProgram::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression_ReturnProgram::MergeFrom(const DerivationExpression_ReturnProgram& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ReturnProgram) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; assignments_.MergeFrom(from.assignments_); - if (from.has_final_expression()) { + if (from._internal_has_final_expression()) { _internal_mutable_final_expression()->::substrait::DerivationExpression::MergeFrom(from._internal_final_expression()); } -} - -void DerivationExpression_ReturnProgram::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression.ReturnProgram) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression_ReturnProgram::CopyFrom(const DerivationExpression_ReturnProgram& from) { @@ -4041,7 +3947,7 @@ bool DerivationExpression_ReturnProgram::IsInitialized() const { void DerivationExpression_ReturnProgram::InternalSwap(DerivationExpression_ReturnProgram* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); assignments_.InternalSwap(&other->assignments_); swap(final_expression_, other->final_expression_); } @@ -4194,11 +4100,13 @@ DerivationExpression::_Internal::return_program(const DerivationExpression* msg) return *msg->kind_.return_program_; } void DerivationExpression::set_allocated_bool_(::substrait::Type_Boolean* bool_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (bool_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_)); if (message_arena != submessage_arena) { bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, bool_, submessage_arena); @@ -4210,18 +4118,20 @@ void DerivationExpression::set_allocated_bool_(::substrait::Type_Boolean* bool_) } void DerivationExpression::clear_bool_() { if (_internal_has_bool_()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.bool__; } clear_has_kind(); } } void DerivationExpression::set_allocated_i8(::substrait::Type_I8* i8) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i8) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8)); if (message_arena != submessage_arena) { i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i8, submessage_arena); @@ -4233,18 +4143,20 @@ void DerivationExpression::set_allocated_i8(::substrait::Type_I8* i8) { } void DerivationExpression::clear_i8() { if (_internal_has_i8()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i8_; } clear_has_kind(); } } void DerivationExpression::set_allocated_i16(::substrait::Type_I16* i16) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i16) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16)); if (message_arena != submessage_arena) { i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i16, submessage_arena); @@ -4256,18 +4168,20 @@ void DerivationExpression::set_allocated_i16(::substrait::Type_I16* i16) { } void DerivationExpression::clear_i16() { if (_internal_has_i16()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i16_; } clear_has_kind(); } } void DerivationExpression::set_allocated_i32(::substrait::Type_I32* i32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i32) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32)); if (message_arena != submessage_arena) { i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i32, submessage_arena); @@ -4279,18 +4193,20 @@ void DerivationExpression::set_allocated_i32(::substrait::Type_I32* i32) { } void DerivationExpression::clear_i32() { if (_internal_has_i32()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i32_; } clear_has_kind(); } } void DerivationExpression::set_allocated_i64(::substrait::Type_I64* i64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (i64) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64)); if (message_arena != submessage_arena) { i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, i64, submessage_arena); @@ -4302,18 +4218,20 @@ void DerivationExpression::set_allocated_i64(::substrait::Type_I64* i64) { } void DerivationExpression::clear_i64() { if (_internal_has_i64()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i64_; } clear_has_kind(); } } void DerivationExpression::set_allocated_fp32(::substrait::Type_FP32* fp32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fp32) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32)); if (message_arena != submessage_arena) { fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fp32, submessage_arena); @@ -4325,18 +4243,20 @@ void DerivationExpression::set_allocated_fp32(::substrait::Type_FP32* fp32) { } void DerivationExpression::clear_fp32() { if (_internal_has_fp32()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp32_; } clear_has_kind(); } } void DerivationExpression::set_allocated_fp64(::substrait::Type_FP64* fp64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fp64) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64)); if (message_arena != submessage_arena) { fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fp64, submessage_arena); @@ -4348,18 +4268,20 @@ void DerivationExpression::set_allocated_fp64(::substrait::Type_FP64* fp64) { } void DerivationExpression::clear_fp64() { if (_internal_has_fp64()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp64_; } clear_has_kind(); } } void DerivationExpression::set_allocated_string(::substrait::Type_String* string) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (string) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string)); if (message_arena != submessage_arena) { string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, string, submessage_arena); @@ -4371,18 +4293,20 @@ void DerivationExpression::set_allocated_string(::substrait::Type_String* string } void DerivationExpression::clear_string() { if (_internal_has_string()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.string_; } clear_has_kind(); } } void DerivationExpression::set_allocated_binary(::substrait::Type_Binary* binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (binary) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary)); if (message_arena != submessage_arena) { binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, binary, submessage_arena); @@ -4394,18 +4318,20 @@ void DerivationExpression::set_allocated_binary(::substrait::Type_Binary* binary } void DerivationExpression::clear_binary() { if (_internal_has_binary()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.binary_; } clear_has_kind(); } } void DerivationExpression::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (timestamp) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp)); if (message_arena != submessage_arena) { timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, timestamp, submessage_arena); @@ -4417,18 +4343,20 @@ void DerivationExpression::set_allocated_timestamp(::substrait::Type_Timestamp* } void DerivationExpression::clear_timestamp() { if (_internal_has_timestamp()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_; } clear_has_kind(); } } void DerivationExpression::set_allocated_date(::substrait::Type_Date* date) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (date) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date)); if (message_arena != submessage_arena) { date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, date, submessage_arena); @@ -4440,18 +4368,20 @@ void DerivationExpression::set_allocated_date(::substrait::Type_Date* date) { } void DerivationExpression::clear_date() { if (_internal_has_date()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.date_; } clear_has_kind(); } } void DerivationExpression::set_allocated_time(::substrait::Type_Time* time) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (time) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time)); if (message_arena != submessage_arena) { time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, time, submessage_arena); @@ -4463,18 +4393,20 @@ void DerivationExpression::set_allocated_time(::substrait::Type_Time* time) { } void DerivationExpression::clear_time() { if (_internal_has_time()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.time_; } clear_has_kind(); } } void DerivationExpression::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (interval_year) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year)); if (message_arena != submessage_arena) { interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, interval_year, submessage_arena); @@ -4486,18 +4418,20 @@ void DerivationExpression::set_allocated_interval_year(::substrait::Type_Interva } void DerivationExpression::clear_interval_year() { if (_internal_has_interval_year()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_year_; } clear_has_kind(); } } void DerivationExpression::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (interval_day) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day)); if (message_arena != submessage_arena) { interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, interval_day, submessage_arena); @@ -4509,18 +4443,20 @@ void DerivationExpression::set_allocated_interval_day(::substrait::Type_Interval } void DerivationExpression::clear_interval_day() { if (_internal_has_interval_day()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_day_; } clear_has_kind(); } } void DerivationExpression::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (timestamp_tz) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz)); if (message_arena != submessage_arena) { timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, timestamp_tz, submessage_arena); @@ -4532,18 +4468,20 @@ void DerivationExpression::set_allocated_timestamp_tz(::substrait::Type_Timestam } void DerivationExpression::clear_timestamp_tz() { if (_internal_has_timestamp_tz()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_tz_; } clear_has_kind(); } } void DerivationExpression::set_allocated_uuid(::substrait::Type_UUID* uuid) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (uuid) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid)->GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< + ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid)); if (message_arena != submessage_arena) { uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, uuid, submessage_arena); @@ -4555,18 +4493,18 @@ void DerivationExpression::set_allocated_uuid(::substrait::Type_UUID* uuid) { } void DerivationExpression::clear_uuid() { if (_internal_has_uuid()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.uuid_; } clear_has_kind(); } } void DerivationExpression::set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fixed_char) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_char); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionFixedChar>::GetOwningArena(fixed_char); if (message_arena != submessage_arena) { fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fixed_char, submessage_arena); @@ -4577,11 +4515,11 @@ void DerivationExpression::set_allocated_fixed_char(::substrait::DerivationExpre // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fixed_char) } void DerivationExpression::set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (varchar) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(varchar); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionVarChar>::GetOwningArena(varchar); if (message_arena != submessage_arena) { varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, varchar, submessage_arena); @@ -4592,11 +4530,11 @@ void DerivationExpression::set_allocated_varchar(::substrait::DerivationExpressi // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.varchar) } void DerivationExpression::set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (fixed_binary) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(fixed_binary); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionFixedBinary>::GetOwningArena(fixed_binary); if (message_arena != submessage_arena) { fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, fixed_binary, submessage_arena); @@ -4607,11 +4545,11 @@ void DerivationExpression::set_allocated_fixed_binary(::substrait::DerivationExp // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fixed_binary) } void DerivationExpression::set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (decimal) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(decimal); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionDecimal>::GetOwningArena(decimal); if (message_arena != submessage_arena) { decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, decimal, submessage_arena); @@ -4622,11 +4560,11 @@ void DerivationExpression::set_allocated_decimal(::substrait::DerivationExpressi // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.decimal) } void DerivationExpression::set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionStruct>::GetOwningArena(struct_); if (message_arena != submessage_arena) { struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, struct_, submessage_arena); @@ -4637,11 +4575,11 @@ void DerivationExpression::set_allocated_struct_(::substrait::DerivationExpressi // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.struct) } void DerivationExpression::set_allocated_list(::substrait::DerivationExpression_ExpressionList* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (list) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(list); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionList>::GetOwningArena(list); if (message_arena != submessage_arena) { list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, list, submessage_arena); @@ -4652,11 +4590,11 @@ void DerivationExpression::set_allocated_list(::substrait::DerivationExpression_ // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.list) } void DerivationExpression::set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (map) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(map); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionMap>::GetOwningArena(map); if (message_arena != submessage_arena) { map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, map, submessage_arena); @@ -4667,11 +4605,11 @@ void DerivationExpression::set_allocated_map(::substrait::DerivationExpression_E // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.map) } void DerivationExpression::set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (unary_op) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(unary_op); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_UnaryOp>::GetOwningArena(unary_op); if (message_arena != submessage_arena) { unary_op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, unary_op, submessage_arena); @@ -4682,11 +4620,11 @@ void DerivationExpression::set_allocated_unary_op(::substrait::DerivationExpress // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.unary_op) } void DerivationExpression::set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (binary_op) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(binary_op); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_BinaryOp>::GetOwningArena(binary_op); if (message_arena != submessage_arena) { binary_op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, binary_op, submessage_arena); @@ -4697,11 +4635,11 @@ void DerivationExpression::set_allocated_binary_op(::substrait::DerivationExpres // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.binary_op) } void DerivationExpression::set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (if_else) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_else); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_IfElse>::GetOwningArena(if_else); if (message_arena != submessage_arena) { if_else = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, if_else, submessage_arena); @@ -4712,11 +4650,11 @@ void DerivationExpression::set_allocated_if_else(::substrait::DerivationExpressi // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.if_else) } void DerivationExpression::set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_kind(); if (return_program) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(return_program); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ReturnProgram>::GetOwningArena(return_program); if (message_arena != submessage_arena) { return_program = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, return_program, submessage_arena); @@ -4726,10 +4664,13 @@ void DerivationExpression::set_allocated_return_program(::substrait::DerivationE } // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.return_program) } -DerivationExpression::DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena) - : ::PROTOBUF_NAMESPACE_ID::Message(arena) { +DerivationExpression::DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { SharedCtor(); - RegisterArenaDtor(arena); + if (!is_message_owned) { + RegisterArenaDtor(arena); + } // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression) } DerivationExpression::DerivationExpression(const DerivationExpression& from) @@ -4868,18 +4809,19 @@ DerivationExpression::DerivationExpression(const DerivationExpression& from) // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression) } -void DerivationExpression::SharedCtor() { +inline void DerivationExpression::SharedCtor() { clear_has_kind(); } DerivationExpression::~DerivationExpression() { // @@protoc_insertion_point(destructor:substrait.DerivationExpression) + if (GetArenaForAllocation() != nullptr) return; SharedDtor(); _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } -void DerivationExpression::SharedDtor() { - GOOGLE_DCHECK(GetArena() == nullptr); +inline void DerivationExpression::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); if (has_kind()) { clear_kind(); } @@ -4899,139 +4841,139 @@ void DerivationExpression::clear_kind() { // @@protoc_insertion_point(one_of_clear_start:substrait.DerivationExpression) switch (kind_case()) { case kBool: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.bool__; } break; } case kI8: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i8_; } break; } case kI16: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i16_; } break; } case kI32: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i32_; } break; } case kI64: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.i64_; } break; } case kFp32: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp32_; } break; } case kFp64: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fp64_; } break; } case kString: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.string_; } break; } case kBinary: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.binary_; } break; } case kTimestamp: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_; } break; } case kDate: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.date_; } break; } case kTime: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.time_; } break; } case kIntervalYear: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_year_; } break; } case kIntervalDay: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.interval_day_; } break; } case kTimestampTz: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.timestamp_tz_; } break; } case kUuid: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.uuid_; } break; } case kFixedChar: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_char_; } break; } case kVarchar: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.varchar_; } break; } case kFixedBinary: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_binary_; } break; } case kDecimal: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.decimal_; } break; } case kStruct: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.struct__; } break; } case kList: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.list_; } break; } case kMap: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.map_; } break; @@ -5041,11 +4983,11 @@ void DerivationExpression::clear_kind() { break; } case kTypeParameterName: { - kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kIntegerParameterName: { - kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); break; } case kIntegerLiteral: { @@ -5053,25 +4995,25 @@ void DerivationExpression::clear_kind() { break; } case kUnaryOp: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.unary_op_; } break; } case kBinaryOp: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.binary_op_; } break; } case kIfElse: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.if_else_; } break; } case kReturnProgram: { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.return_program_; } break; @@ -5086,7 +5028,7 @@ void DerivationExpression::clear_kind() { void DerivationExpression::Clear() { // @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5097,257 +5039,288 @@ void DerivationExpression::Clear() { const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure while (!ctx->Done(&ptr)) { - ::PROTOBUF_NAMESPACE_ID::uint32 tag; + uint32_t tag; ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); switch (tag >> 3) { // .substrait.Type.Boolean bool = 1; case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I8 i8 = 2; case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I16 i16 = 3; case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I32 i32 = 5; case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.I64 i64 = 7; case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.FP32 fp32 = 10; case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.FP64 fp64 = 11; case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.String string = 12; case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Binary binary = 13; case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Timestamp timestamp = 14; case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Date date = 16; case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.Time time = 17; case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.IntervalYear interval_year = 19; case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.IntervalDay interval_day = 20; case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.ExpressionVarChar varchar = 22; case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.ExpressionDecimal decimal = 24; case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.ExpressionStruct struct = 25; case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.ExpressionList list = 27; case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.ExpressionMap map = 28; case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.TimestampTZ timestamp_tz = 29; case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // uint32 user_defined_pointer = 31; case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 248)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.Type.UUID uuid = 32; case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 2)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string type_parameter_name = 33; case 33: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { auto str = _internal_mutable_type_parameter_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.type_parameter_name")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // string integer_parameter_name = 34; case 34: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { auto str = _internal_mutable_integer_parameter_name(); ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.integer_parameter_name")); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // int32 integer_literal = 35; case 35: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) { - _internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { + _internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.UnaryOp unary_op = 36; case 36: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { ptr = ctx->ParseMessage(_internal_mutable_unary_op(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.BinaryOp binary_op = 37; case 37: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { ptr = ctx->ParseMessage(_internal_mutable_binary_op(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.IfElse if_else = 38; case 38: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { ptr = ctx->ParseMessage(_internal_mutable_if_else(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; // .substrait.DerivationExpression.ReturnProgram return_program = 39; case 39: - if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { ptr = ctx->ParseMessage(_internal_mutable_return_program(), ptr); CHK_(ptr); - } else goto handle_unusual; + } else + goto handle_unusual; continue; - default: { - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto success; - } - ptr = UnknownFieldParse(tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - 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 -success: +message_done: return ptr; failure: ptr = nullptr; - goto success; + goto message_done; #undef CHK_ } -::PROTOBUF_NAMESPACE_ID::uint8* DerivationExpression::_InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { +uint8_t* DerivationExpression::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression) - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; // .substrait.Type.Boolean bool = 1; @@ -5610,7 +5583,7 @@ size_t DerivationExpression::ByteSizeLong() const { // @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression) size_t total_size = 0; - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; @@ -5836,35 +5809,26 @@ size_t DerivationExpression::ByteSizeLong() const { break; } } - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - return ::PROTOBUF_NAMESPACE_ID::internal::ComputeUnknownFieldsSize( - _internal_metadata_, total_size, &_cached_size_); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size); - SetCachedSize(cached_size); - return total_size; + return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); } -void DerivationExpression::MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:substrait.DerivationExpression) - GOOGLE_DCHECK_NE(&from, this); - const DerivationExpression* source = - ::PROTOBUF_NAMESPACE_ID::DynamicCastToGenerated( - &from); - if (source == nullptr) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:substrait.DerivationExpression) - ::PROTOBUF_NAMESPACE_ID::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:substrait.DerivationExpression) - MergeFrom(*source); - } +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, + DerivationExpression::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression::GetClassData() const { return &_class_data_; } + +void DerivationExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, + const ::PROTOBUF_NAMESPACE_ID::Message& from) { + static_cast(to)->MergeFrom( + static_cast(from)); } + void DerivationExpression::MergeFrom(const DerivationExpression& from) { // @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression) GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; + uint32_t cached_has_bits = 0; (void) cached_has_bits; switch (from.kind_case()) { @@ -5996,13 +5960,7 @@ void DerivationExpression::MergeFrom(const DerivationExpression& from) { break; } } -} - -void DerivationExpression::CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:substrait.DerivationExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } void DerivationExpression::CopyFrom(const DerivationExpression& from) { @@ -6018,7 +5976,7 @@ bool DerivationExpression::IsInitialized() const { void DerivationExpression::InternalSwap(DerivationExpression* other) { using std::swap; - _internal_metadata_.Swap<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(&other->_internal_metadata_); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(kind_, other->kind_); swap(_oneof_case_[0], other->_oneof_case_[0]); } diff --git a/cpp/src/generated/substrait/type_expressions.pb.h b/cpp/src/generated/substrait/type_expressions.pb.h index 4046899622b..0548e41e676 100644 --- a/cpp/src/generated/substrait/type_expressions.pb.h +++ b/cpp/src/generated/substrait/type_expressions.pb.h @@ -8,12 +8,12 @@ #include #include -#if PROTOBUF_VERSION < 3016000 +#if PROTOBUF_VERSION < 3019000 #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 3016000 < PROTOBUF_MIN_PROTOC_VERSION +#if 3019003 < 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. @@ -52,7 +52,7 @@ struct TableStruct_substrait_2ftype_5fexpressions_2eproto { PROTOBUF_SECTION_VARIABLE(protodesc_cold); static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[]; + static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_5fexpressions_2eproto; namespace substrait { @@ -120,8 +120,8 @@ namespace substrait { enum DerivationExpression_UnaryOp_UnaryOpType : int { DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED = 0, DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT = 1, - DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DerivationExpression_UnaryOp_UnaryOpType_IsValid(int value); constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MIN = DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED; @@ -156,8 +156,8 @@ enum DerivationExpression_BinaryOp_BinaryOpType : int { DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_OR = 10, DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_EQUALS = 11, DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS = 12, - DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(), - DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max() + DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), + DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DerivationExpression_BinaryOp_BinaryOpType_IsValid(int value); constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MIN = DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED; @@ -180,7 +180,7 @@ inline bool DerivationExpression_BinaryOp_BinaryOpType_Parse( } // =================================================================== -class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : +class DerivationExpression_ExpressionFixedChar final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionFixedChar) */ { public: inline DerivationExpression_ExpressionFixedChar() : DerivationExpression_ExpressionFixedChar(nullptr) {} @@ -198,8 +198,13 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : return *this; } inline DerivationExpression_ExpressionFixedChar& operator=(DerivationExpression_ExpressionFixedChar&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -230,7 +235,12 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : } inline void Swap(DerivationExpression_ExpressionFixedChar* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -238,48 +248,53 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_ExpressionFixedChar* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_ExpressionFixedChar* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_ExpressionFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_ExpressionFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_ExpressionFixedChar& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_ExpressionFixedChar& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_ExpressionFixedChar* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.ExpressionFixedChar"; } protected: - explicit DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -298,7 +313,7 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : public: void clear_length(); const ::substrait::DerivationExpression& length() const; - ::substrait::DerivationExpression* release_length(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length(); ::substrait::DerivationExpression* mutable_length(); void set_allocated_length(::substrait::DerivationExpression* length); private: @@ -311,11 +326,11 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : // uint32 variation_pointer = 2; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -335,14 +350,14 @@ class DerivationExpression_ExpressionFixedChar PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::DerivationExpression* length_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- -class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : +class DerivationExpression_ExpressionVarChar final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionVarChar) */ { public: inline DerivationExpression_ExpressionVarChar() : DerivationExpression_ExpressionVarChar(nullptr) {} @@ -360,8 +375,13 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : return *this; } inline DerivationExpression_ExpressionVarChar& operator=(DerivationExpression_ExpressionVarChar&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -392,7 +412,12 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : } inline void Swap(DerivationExpression_ExpressionVarChar* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -400,48 +425,53 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_ExpressionVarChar* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_ExpressionVarChar* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_ExpressionVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_ExpressionVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_ExpressionVarChar& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_ExpressionVarChar& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_ExpressionVarChar* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.ExpressionVarChar"; } protected: - explicit DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -460,7 +490,7 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : public: void clear_length(); const ::substrait::DerivationExpression& length() const; - ::substrait::DerivationExpression* release_length(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length(); ::substrait::DerivationExpression* mutable_length(); void set_allocated_length(::substrait::DerivationExpression* length); private: @@ -473,11 +503,11 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : // uint32 variation_pointer = 2; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -497,14 +527,14 @@ class DerivationExpression_ExpressionVarChar PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::DerivationExpression* length_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- -class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : +class DerivationExpression_ExpressionFixedBinary final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionFixedBinary) */ { public: inline DerivationExpression_ExpressionFixedBinary() : DerivationExpression_ExpressionFixedBinary(nullptr) {} @@ -522,8 +552,13 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : return *this; } inline DerivationExpression_ExpressionFixedBinary& operator=(DerivationExpression_ExpressionFixedBinary&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -554,7 +589,12 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : } inline void Swap(DerivationExpression_ExpressionFixedBinary* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -562,48 +602,53 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_ExpressionFixedBinary* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_ExpressionFixedBinary* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_ExpressionFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_ExpressionFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_ExpressionFixedBinary& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_ExpressionFixedBinary& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_ExpressionFixedBinary* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.ExpressionFixedBinary"; } protected: - explicit DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -622,7 +667,7 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : public: void clear_length(); const ::substrait::DerivationExpression& length() const; - ::substrait::DerivationExpression* release_length(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length(); ::substrait::DerivationExpression* mutable_length(); void set_allocated_length(::substrait::DerivationExpression* length); private: @@ -635,11 +680,11 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : // uint32 variation_pointer = 2; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -659,14 +704,14 @@ class DerivationExpression_ExpressionFixedBinary PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::DerivationExpression* length_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- -class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : +class DerivationExpression_ExpressionDecimal final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionDecimal) */ { public: inline DerivationExpression_ExpressionDecimal() : DerivationExpression_ExpressionDecimal(nullptr) {} @@ -684,8 +729,13 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : return *this; } inline DerivationExpression_ExpressionDecimal& operator=(DerivationExpression_ExpressionDecimal&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -716,7 +766,12 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : } inline void Swap(DerivationExpression_ExpressionDecimal* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -724,48 +779,53 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_ExpressionDecimal* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_ExpressionDecimal* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_ExpressionDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_ExpressionDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_ExpressionDecimal& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_ExpressionDecimal& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_ExpressionDecimal* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.ExpressionDecimal"; } protected: - explicit DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -785,7 +845,7 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : public: void clear_scale(); const ::substrait::DerivationExpression& scale() const; - ::substrait::DerivationExpression* release_scale(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_scale(); ::substrait::DerivationExpression* mutable_scale(); void set_allocated_scale(::substrait::DerivationExpression* scale); private: @@ -803,7 +863,7 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : public: void clear_precision(); const ::substrait::DerivationExpression& precision() const; - ::substrait::DerivationExpression* release_precision(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_precision(); ::substrait::DerivationExpression* mutable_precision(); void set_allocated_precision(::substrait::DerivationExpression* precision); private: @@ -816,11 +876,11 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : // uint32 variation_pointer = 3; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 4; @@ -841,14 +901,14 @@ class DerivationExpression_ExpressionDecimal PROTOBUF_FINAL : typedef void DestructorSkippable_; ::substrait::DerivationExpression* scale_; ::substrait::DerivationExpression* precision_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- -class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : +class DerivationExpression_ExpressionStruct final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionStruct) */ { public: inline DerivationExpression_ExpressionStruct() : DerivationExpression_ExpressionStruct(nullptr) {} @@ -866,8 +926,13 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : return *this; } inline DerivationExpression_ExpressionStruct& operator=(DerivationExpression_ExpressionStruct&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -898,7 +963,12 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : } inline void Swap(DerivationExpression_ExpressionStruct* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -906,48 +976,53 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_ExpressionStruct* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_ExpressionStruct* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_ExpressionStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_ExpressionStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_ExpressionStruct& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_ExpressionStruct& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_ExpressionStruct* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.ExpressionStruct"; } protected: - explicit DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -979,11 +1054,11 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : // uint32 variation_pointer = 2; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -1003,14 +1078,14 @@ class DerivationExpression_ExpressionStruct PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression > types_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- -class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : +class DerivationExpression_ExpressionNamedStruct final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionNamedStruct) */ { public: inline DerivationExpression_ExpressionNamedStruct() : DerivationExpression_ExpressionNamedStruct(nullptr) {} @@ -1028,8 +1103,13 @@ class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : return *this; } inline DerivationExpression_ExpressionNamedStruct& operator=(DerivationExpression_ExpressionNamedStruct&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1060,7 +1140,12 @@ class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : } inline void Swap(DerivationExpression_ExpressionNamedStruct* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1068,48 +1153,53 @@ class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_ExpressionNamedStruct* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_ExpressionNamedStruct* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_ExpressionNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_ExpressionNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_ExpressionNamedStruct& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_ExpressionNamedStruct& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_ExpressionNamedStruct* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.ExpressionNamedStruct"; } protected: - explicit DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1151,7 +1241,7 @@ class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : public: void clear_struct_(); const ::substrait::DerivationExpression_ExpressionStruct& struct_() const; - ::substrait::DerivationExpression_ExpressionStruct* release_struct_(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionStruct* release_struct_(); ::substrait::DerivationExpression_ExpressionStruct* mutable_struct_(); void set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_); private: @@ -1176,7 +1266,7 @@ class DerivationExpression_ExpressionNamedStruct PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class DerivationExpression_ExpressionList PROTOBUF_FINAL : +class DerivationExpression_ExpressionList final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionList) */ { public: inline DerivationExpression_ExpressionList() : DerivationExpression_ExpressionList(nullptr) {} @@ -1194,8 +1284,13 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : return *this; } inline DerivationExpression_ExpressionList& operator=(DerivationExpression_ExpressionList&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1226,7 +1321,12 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : } inline void Swap(DerivationExpression_ExpressionList* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1234,48 +1334,53 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_ExpressionList* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_ExpressionList* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_ExpressionList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_ExpressionList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_ExpressionList& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_ExpressionList& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_ExpressionList* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.ExpressionList"; } protected: - explicit DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1294,7 +1399,7 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : public: void clear_type(); const ::substrait::DerivationExpression& type() const; - ::substrait::DerivationExpression* release_type(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_type(); ::substrait::DerivationExpression* mutable_type(); void set_allocated_type(::substrait::DerivationExpression* type); private: @@ -1307,11 +1412,11 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : // uint32 variation_pointer = 2; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 3; @@ -1331,14 +1436,14 @@ class DerivationExpression_ExpressionList PROTOBUF_FINAL : typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; ::substrait::DerivationExpression* type_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- -class DerivationExpression_ExpressionMap PROTOBUF_FINAL : +class DerivationExpression_ExpressionMap final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionMap) */ { public: inline DerivationExpression_ExpressionMap() : DerivationExpression_ExpressionMap(nullptr) {} @@ -1356,8 +1461,13 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : return *this; } inline DerivationExpression_ExpressionMap& operator=(DerivationExpression_ExpressionMap&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1388,7 +1498,12 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : } inline void Swap(DerivationExpression_ExpressionMap* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1396,48 +1511,53 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_ExpressionMap* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_ExpressionMap* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_ExpressionMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_ExpressionMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_ExpressionMap& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_ExpressionMap& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_ExpressionMap* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.ExpressionMap"; } protected: - explicit DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1457,7 +1577,7 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : public: void clear_key(); const ::substrait::DerivationExpression& key() const; - ::substrait::DerivationExpression* release_key(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_key(); ::substrait::DerivationExpression* mutable_key(); void set_allocated_key(::substrait::DerivationExpression* key); private: @@ -1475,7 +1595,7 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : public: void clear_value(); const ::substrait::DerivationExpression& value() const; - ::substrait::DerivationExpression* release_value(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_value(); ::substrait::DerivationExpression* mutable_value(); void set_allocated_value(::substrait::DerivationExpression* value); private: @@ -1488,11 +1608,11 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : // uint32 variation_pointer = 3; void clear_variation_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer() const; - void set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t variation_pointer() const; + void set_variation_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_variation_pointer() const; - void _internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_variation_pointer() const; + void _internal_set_variation_pointer(uint32_t value); public: // .substrait.Type.Nullability nullability = 4; @@ -1513,14 +1633,14 @@ class DerivationExpression_ExpressionMap PROTOBUF_FINAL : typedef void DestructorSkippable_; ::substrait::DerivationExpression* key_; ::substrait::DerivationExpression* value_; - ::PROTOBUF_NAMESPACE_ID::uint32 variation_pointer_; + uint32_t variation_pointer_; int nullability_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; // ------------------------------------------------------------------- -class DerivationExpression_IfElse PROTOBUF_FINAL : +class DerivationExpression_IfElse final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.IfElse) */ { public: inline DerivationExpression_IfElse() : DerivationExpression_IfElse(nullptr) {} @@ -1538,8 +1658,13 @@ class DerivationExpression_IfElse PROTOBUF_FINAL : return *this; } inline DerivationExpression_IfElse& operator=(DerivationExpression_IfElse&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1570,7 +1695,12 @@ class DerivationExpression_IfElse PROTOBUF_FINAL : } inline void Swap(DerivationExpression_IfElse* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1578,48 +1708,53 @@ class DerivationExpression_IfElse PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_IfElse* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_IfElse* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_IfElse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_IfElse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_IfElse& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_IfElse& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_IfElse* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.IfElse"; } protected: - explicit DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1638,7 +1773,7 @@ class DerivationExpression_IfElse PROTOBUF_FINAL : public: void clear_if_condition(); const ::substrait::DerivationExpression& if_condition() const; - ::substrait::DerivationExpression* release_if_condition(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_if_condition(); ::substrait::DerivationExpression* mutable_if_condition(); void set_allocated_if_condition(::substrait::DerivationExpression* if_condition); private: @@ -1656,7 +1791,7 @@ class DerivationExpression_IfElse PROTOBUF_FINAL : public: void clear_if_return(); const ::substrait::DerivationExpression& if_return() const; - ::substrait::DerivationExpression* release_if_return(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_if_return(); ::substrait::DerivationExpression* mutable_if_return(); void set_allocated_if_return(::substrait::DerivationExpression* if_return); private: @@ -1674,7 +1809,7 @@ class DerivationExpression_IfElse PROTOBUF_FINAL : public: void clear_else_return(); const ::substrait::DerivationExpression& else_return() const; - ::substrait::DerivationExpression* release_else_return(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_else_return(); ::substrait::DerivationExpression* mutable_else_return(); void set_allocated_else_return(::substrait::DerivationExpression* else_return); private: @@ -1700,7 +1835,7 @@ class DerivationExpression_IfElse PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class DerivationExpression_UnaryOp PROTOBUF_FINAL : +class DerivationExpression_UnaryOp final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.UnaryOp) */ { public: inline DerivationExpression_UnaryOp() : DerivationExpression_UnaryOp(nullptr) {} @@ -1718,8 +1853,13 @@ class DerivationExpression_UnaryOp PROTOBUF_FINAL : return *this; } inline DerivationExpression_UnaryOp& operator=(DerivationExpression_UnaryOp&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1750,7 +1890,12 @@ class DerivationExpression_UnaryOp PROTOBUF_FINAL : } inline void Swap(DerivationExpression_UnaryOp* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1758,48 +1903,53 @@ class DerivationExpression_UnaryOp PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_UnaryOp* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_UnaryOp* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_UnaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_UnaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_UnaryOp& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_UnaryOp& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_UnaryOp* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.UnaryOp"; } protected: - explicit DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -1847,7 +1997,7 @@ class DerivationExpression_UnaryOp PROTOBUF_FINAL : public: void clear_arg(); const ::substrait::DerivationExpression& arg() const; - ::substrait::DerivationExpression* release_arg(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg(); ::substrait::DerivationExpression* mutable_arg(); void set_allocated_arg(::substrait::DerivationExpression* arg); private: @@ -1881,7 +2031,7 @@ class DerivationExpression_UnaryOp PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class DerivationExpression_BinaryOp PROTOBUF_FINAL : +class DerivationExpression_BinaryOp final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.BinaryOp) */ { public: inline DerivationExpression_BinaryOp() : DerivationExpression_BinaryOp(nullptr) {} @@ -1899,8 +2049,13 @@ class DerivationExpression_BinaryOp PROTOBUF_FINAL : return *this; } inline DerivationExpression_BinaryOp& operator=(DerivationExpression_BinaryOp&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -1931,7 +2086,12 @@ class DerivationExpression_BinaryOp PROTOBUF_FINAL : } inline void Swap(DerivationExpression_BinaryOp* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -1939,48 +2099,53 @@ class DerivationExpression_BinaryOp PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_BinaryOp* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_BinaryOp* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_BinaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_BinaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_BinaryOp& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_BinaryOp& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_BinaryOp* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.BinaryOp"; } protected: - explicit DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2051,7 +2216,7 @@ class DerivationExpression_BinaryOp PROTOBUF_FINAL : public: void clear_arg1(); const ::substrait::DerivationExpression& arg1() const; - ::substrait::DerivationExpression* release_arg1(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg1(); ::substrait::DerivationExpression* mutable_arg1(); void set_allocated_arg1(::substrait::DerivationExpression* arg1); private: @@ -2069,7 +2234,7 @@ class DerivationExpression_BinaryOp PROTOBUF_FINAL : public: void clear_arg2(); const ::substrait::DerivationExpression& arg2() const; - ::substrait::DerivationExpression* release_arg2(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg2(); ::substrait::DerivationExpression* mutable_arg2(); void set_allocated_arg2(::substrait::DerivationExpression* arg2); private: @@ -2104,7 +2269,7 @@ class DerivationExpression_BinaryOp PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : +class DerivationExpression_ReturnProgram_Assignment final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ReturnProgram.Assignment) */ { public: inline DerivationExpression_ReturnProgram_Assignment() : DerivationExpression_ReturnProgram_Assignment(nullptr) {} @@ -2122,8 +2287,13 @@ class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : return *this; } inline DerivationExpression_ReturnProgram_Assignment& operator=(DerivationExpression_ReturnProgram_Assignment&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2154,7 +2324,12 @@ class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : } inline void Swap(DerivationExpression_ReturnProgram_Assignment* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2162,48 +2337,53 @@ class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_ReturnProgram_Assignment* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_ReturnProgram_Assignment* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_ReturnProgram_Assignment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_ReturnProgram_Assignment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_ReturnProgram_Assignment* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.ReturnProgram.Assignment"; } protected: - explicit DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2220,11 +2400,11 @@ class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : template void set_name(ArgT0&& arg0, ArgT... args); std::string* mutable_name(); - std::string* release_name(); + PROTOBUF_NODISCARD std::string* release_name(); void set_allocated_name(std::string* name); private: const std::string& _internal_name() const; - void _internal_set_name(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); std::string* _internal_mutable_name(); public: @@ -2235,7 +2415,7 @@ class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : public: void clear_expression(); const ::substrait::DerivationExpression& expression() const; - ::substrait::DerivationExpression* release_expression(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_expression(); ::substrait::DerivationExpression* mutable_expression(); void set_allocated_expression(::substrait::DerivationExpression* expression); private: @@ -2260,7 +2440,7 @@ class DerivationExpression_ReturnProgram_Assignment PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class DerivationExpression_ReturnProgram PROTOBUF_FINAL : +class DerivationExpression_ReturnProgram final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ReturnProgram) */ { public: inline DerivationExpression_ReturnProgram() : DerivationExpression_ReturnProgram(nullptr) {} @@ -2278,8 +2458,13 @@ class DerivationExpression_ReturnProgram PROTOBUF_FINAL : return *this; } inline DerivationExpression_ReturnProgram& operator=(DerivationExpression_ReturnProgram&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2310,7 +2495,12 @@ class DerivationExpression_ReturnProgram PROTOBUF_FINAL : } inline void Swap(DerivationExpression_ReturnProgram* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2318,48 +2508,53 @@ class DerivationExpression_ReturnProgram PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression_ReturnProgram* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression_ReturnProgram* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression_ReturnProgram* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression_ReturnProgram* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression_ReturnProgram& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression_ReturnProgram& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression_ReturnProgram* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression.ReturnProgram"; } protected: - explicit DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2397,7 +2592,7 @@ class DerivationExpression_ReturnProgram PROTOBUF_FINAL : public: void clear_final_expression(); const ::substrait::DerivationExpression& final_expression() const; - ::substrait::DerivationExpression* release_final_expression(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_final_expression(); ::substrait::DerivationExpression* mutable_final_expression(); void set_allocated_final_expression(::substrait::DerivationExpression* final_expression); private: @@ -2422,7 +2617,7 @@ class DerivationExpression_ReturnProgram PROTOBUF_FINAL : }; // ------------------------------------------------------------------- -class DerivationExpression PROTOBUF_FINAL : +class DerivationExpression final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression) */ { public: inline DerivationExpression() : DerivationExpression(nullptr) {} @@ -2440,8 +2635,13 @@ class DerivationExpression PROTOBUF_FINAL : return *this; } inline DerivationExpression& operator=(DerivationExpression&& from) noexcept { - if (GetArena() == from.GetArena()) { - if (this != &from) InternalSwap(&from); + 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); } @@ -2507,7 +2707,12 @@ class DerivationExpression PROTOBUF_FINAL : } inline void Swap(DerivationExpression* other) { if (other == this) return; - if (GetArena() == other->GetArena()) { + #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); @@ -2515,48 +2720,53 @@ class DerivationExpression PROTOBUF_FINAL : } void UnsafeArenaSwap(DerivationExpression* other) { if (other == this) return; - GOOGLE_DCHECK(GetArena() == other->GetArena()); + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- - inline DerivationExpression* New() const final { - return CreateMaybeMessage(nullptr); - } - - DerivationExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final { + DerivationExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } - void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; - void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final; + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DerivationExpression& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom(const DerivationExpression& from); + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); + 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; - ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize( - ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _cached_size_.Get(); } private: - inline void SharedCtor(); - inline void SharedDtor(); + void SharedCtor(); + void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DerivationExpression* other); + + private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "substrait.DerivationExpression"; } protected: - explicit DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena); + explicit DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); private: static void ArenaDtor(void* object); inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); public: + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- @@ -2616,7 +2826,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_bool_(); const ::substrait::Type_Boolean& bool_() const; - ::substrait::Type_Boolean* release_bool_(); + PROTOBUF_NODISCARD ::substrait::Type_Boolean* release_bool_(); ::substrait::Type_Boolean* mutable_bool_(); void set_allocated_bool_(::substrait::Type_Boolean* bool_); private: @@ -2634,7 +2844,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_i8(); const ::substrait::Type_I8& i8() const; - ::substrait::Type_I8* release_i8(); + PROTOBUF_NODISCARD ::substrait::Type_I8* release_i8(); ::substrait::Type_I8* mutable_i8(); void set_allocated_i8(::substrait::Type_I8* i8); private: @@ -2652,7 +2862,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_i16(); const ::substrait::Type_I16& i16() const; - ::substrait::Type_I16* release_i16(); + PROTOBUF_NODISCARD ::substrait::Type_I16* release_i16(); ::substrait::Type_I16* mutable_i16(); void set_allocated_i16(::substrait::Type_I16* i16); private: @@ -2670,7 +2880,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_i32(); const ::substrait::Type_I32& i32() const; - ::substrait::Type_I32* release_i32(); + PROTOBUF_NODISCARD ::substrait::Type_I32* release_i32(); ::substrait::Type_I32* mutable_i32(); void set_allocated_i32(::substrait::Type_I32* i32); private: @@ -2688,7 +2898,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_i64(); const ::substrait::Type_I64& i64() const; - ::substrait::Type_I64* release_i64(); + PROTOBUF_NODISCARD ::substrait::Type_I64* release_i64(); ::substrait::Type_I64* mutable_i64(); void set_allocated_i64(::substrait::Type_I64* i64); private: @@ -2706,7 +2916,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_fp32(); const ::substrait::Type_FP32& fp32() const; - ::substrait::Type_FP32* release_fp32(); + PROTOBUF_NODISCARD ::substrait::Type_FP32* release_fp32(); ::substrait::Type_FP32* mutable_fp32(); void set_allocated_fp32(::substrait::Type_FP32* fp32); private: @@ -2724,7 +2934,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_fp64(); const ::substrait::Type_FP64& fp64() const; - ::substrait::Type_FP64* release_fp64(); + PROTOBUF_NODISCARD ::substrait::Type_FP64* release_fp64(); ::substrait::Type_FP64* mutable_fp64(); void set_allocated_fp64(::substrait::Type_FP64* fp64); private: @@ -2742,7 +2952,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_string(); const ::substrait::Type_String& string() const; - ::substrait::Type_String* release_string(); + PROTOBUF_NODISCARD ::substrait::Type_String* release_string(); ::substrait::Type_String* mutable_string(); void set_allocated_string(::substrait::Type_String* string); private: @@ -2760,7 +2970,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_binary(); const ::substrait::Type_Binary& binary() const; - ::substrait::Type_Binary* release_binary(); + PROTOBUF_NODISCARD ::substrait::Type_Binary* release_binary(); ::substrait::Type_Binary* mutable_binary(); void set_allocated_binary(::substrait::Type_Binary* binary); private: @@ -2778,7 +2988,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_timestamp(); const ::substrait::Type_Timestamp& timestamp() const; - ::substrait::Type_Timestamp* release_timestamp(); + PROTOBUF_NODISCARD ::substrait::Type_Timestamp* release_timestamp(); ::substrait::Type_Timestamp* mutable_timestamp(); void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp); private: @@ -2796,7 +3006,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_date(); const ::substrait::Type_Date& date() const; - ::substrait::Type_Date* release_date(); + PROTOBUF_NODISCARD ::substrait::Type_Date* release_date(); ::substrait::Type_Date* mutable_date(); void set_allocated_date(::substrait::Type_Date* date); private: @@ -2814,7 +3024,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_time(); const ::substrait::Type_Time& time() const; - ::substrait::Type_Time* release_time(); + PROTOBUF_NODISCARD ::substrait::Type_Time* release_time(); ::substrait::Type_Time* mutable_time(); void set_allocated_time(::substrait::Type_Time* time); private: @@ -2832,7 +3042,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_interval_year(); const ::substrait::Type_IntervalYear& interval_year() const; - ::substrait::Type_IntervalYear* release_interval_year(); + PROTOBUF_NODISCARD ::substrait::Type_IntervalYear* release_interval_year(); ::substrait::Type_IntervalYear* mutable_interval_year(); void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year); private: @@ -2850,7 +3060,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_interval_day(); const ::substrait::Type_IntervalDay& interval_day() const; - ::substrait::Type_IntervalDay* release_interval_day(); + PROTOBUF_NODISCARD ::substrait::Type_IntervalDay* release_interval_day(); ::substrait::Type_IntervalDay* mutable_interval_day(); void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day); private: @@ -2868,7 +3078,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_timestamp_tz(); const ::substrait::Type_TimestampTZ& timestamp_tz() const; - ::substrait::Type_TimestampTZ* release_timestamp_tz(); + PROTOBUF_NODISCARD ::substrait::Type_TimestampTZ* release_timestamp_tz(); ::substrait::Type_TimestampTZ* mutable_timestamp_tz(); void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz); private: @@ -2886,7 +3096,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_uuid(); const ::substrait::Type_UUID& uuid() const; - ::substrait::Type_UUID* release_uuid(); + PROTOBUF_NODISCARD ::substrait::Type_UUID* release_uuid(); ::substrait::Type_UUID* mutable_uuid(); void set_allocated_uuid(::substrait::Type_UUID* uuid); private: @@ -2904,7 +3114,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_fixed_char(); const ::substrait::DerivationExpression_ExpressionFixedChar& fixed_char() const; - ::substrait::DerivationExpression_ExpressionFixedChar* release_fixed_char(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionFixedChar* release_fixed_char(); ::substrait::DerivationExpression_ExpressionFixedChar* mutable_fixed_char(); void set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char); private: @@ -2922,7 +3132,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_varchar(); const ::substrait::DerivationExpression_ExpressionVarChar& varchar() const; - ::substrait::DerivationExpression_ExpressionVarChar* release_varchar(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionVarChar* release_varchar(); ::substrait::DerivationExpression_ExpressionVarChar* mutable_varchar(); void set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar); private: @@ -2940,7 +3150,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_fixed_binary(); const ::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary() const; - ::substrait::DerivationExpression_ExpressionFixedBinary* release_fixed_binary(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionFixedBinary* release_fixed_binary(); ::substrait::DerivationExpression_ExpressionFixedBinary* mutable_fixed_binary(); void set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary); private: @@ -2958,7 +3168,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_decimal(); const ::substrait::DerivationExpression_ExpressionDecimal& decimal() const; - ::substrait::DerivationExpression_ExpressionDecimal* release_decimal(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionDecimal* release_decimal(); ::substrait::DerivationExpression_ExpressionDecimal* mutable_decimal(); void set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal); private: @@ -2976,7 +3186,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_struct_(); const ::substrait::DerivationExpression_ExpressionStruct& struct_() const; - ::substrait::DerivationExpression_ExpressionStruct* release_struct_(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionStruct* release_struct_(); ::substrait::DerivationExpression_ExpressionStruct* mutable_struct_(); void set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_); private: @@ -2994,7 +3204,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_list(); const ::substrait::DerivationExpression_ExpressionList& list() const; - ::substrait::DerivationExpression_ExpressionList* release_list(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionList* release_list(); ::substrait::DerivationExpression_ExpressionList* mutable_list(); void set_allocated_list(::substrait::DerivationExpression_ExpressionList* list); private: @@ -3012,7 +3222,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_map(); const ::substrait::DerivationExpression_ExpressionMap& map() const; - ::substrait::DerivationExpression_ExpressionMap* release_map(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionMap* release_map(); ::substrait::DerivationExpression_ExpressionMap* mutable_map(); void set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map); private: @@ -3029,11 +3239,11 @@ class DerivationExpression PROTOBUF_FINAL : bool _internal_has_user_defined_pointer() const; public: void clear_user_defined_pointer(); - ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_pointer() const; - void set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t user_defined_pointer() const; + void set_user_defined_pointer(uint32_t value); private: - ::PROTOBUF_NAMESPACE_ID::uint32 _internal_user_defined_pointer() const; - void _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value); + uint32_t _internal_user_defined_pointer() const; + void _internal_set_user_defined_pointer(uint32_t value); public: // string type_parameter_name = 33; @@ -3046,11 +3256,11 @@ class DerivationExpression PROTOBUF_FINAL : template void set_type_parameter_name(ArgT0&& arg0, ArgT... args); std::string* mutable_type_parameter_name(); - std::string* release_type_parameter_name(); + PROTOBUF_NODISCARD std::string* release_type_parameter_name(); void set_allocated_type_parameter_name(std::string* type_parameter_name); private: const std::string& _internal_type_parameter_name() const; - void _internal_set_type_parameter_name(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_parameter_name(const std::string& value); std::string* _internal_mutable_type_parameter_name(); public: @@ -3064,11 +3274,11 @@ class DerivationExpression PROTOBUF_FINAL : template void set_integer_parameter_name(ArgT0&& arg0, ArgT... args); std::string* mutable_integer_parameter_name(); - std::string* release_integer_parameter_name(); + PROTOBUF_NODISCARD std::string* release_integer_parameter_name(); void set_allocated_integer_parameter_name(std::string* integer_parameter_name); private: const std::string& _internal_integer_parameter_name() const; - void _internal_set_integer_parameter_name(const std::string& value); + inline PROTOBUF_ALWAYS_INLINE void _internal_set_integer_parameter_name(const std::string& value); std::string* _internal_mutable_integer_parameter_name(); public: @@ -3078,11 +3288,11 @@ class DerivationExpression PROTOBUF_FINAL : bool _internal_has_integer_literal() const; public: void clear_integer_literal(); - ::PROTOBUF_NAMESPACE_ID::int32 integer_literal() const; - void set_integer_literal(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t integer_literal() const; + void set_integer_literal(int32_t value); private: - ::PROTOBUF_NAMESPACE_ID::int32 _internal_integer_literal() const; - void _internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::int32 value); + int32_t _internal_integer_literal() const; + void _internal_set_integer_literal(int32_t value); public: // .substrait.DerivationExpression.UnaryOp unary_op = 36; @@ -3092,7 +3302,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_unary_op(); const ::substrait::DerivationExpression_UnaryOp& unary_op() const; - ::substrait::DerivationExpression_UnaryOp* release_unary_op(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_UnaryOp* release_unary_op(); ::substrait::DerivationExpression_UnaryOp* mutable_unary_op(); void set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op); private: @@ -3110,7 +3320,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_binary_op(); const ::substrait::DerivationExpression_BinaryOp& binary_op() const; - ::substrait::DerivationExpression_BinaryOp* release_binary_op(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_BinaryOp* release_binary_op(); ::substrait::DerivationExpression_BinaryOp* mutable_binary_op(); void set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op); private: @@ -3128,7 +3338,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_if_else(); const ::substrait::DerivationExpression_IfElse& if_else() const; - ::substrait::DerivationExpression_IfElse* release_if_else(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_IfElse* release_if_else(); ::substrait::DerivationExpression_IfElse* mutable_if_else(); void set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else); private: @@ -3146,7 +3356,7 @@ class DerivationExpression PROTOBUF_FINAL : public: void clear_return_program(); const ::substrait::DerivationExpression_ReturnProgram& return_program() const; - ::substrait::DerivationExpression_ReturnProgram* release_return_program(); + PROTOBUF_NODISCARD ::substrait::DerivationExpression_ReturnProgram* release_return_program(); ::substrait::DerivationExpression_ReturnProgram* mutable_return_program(); void set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program); private: @@ -3226,17 +3436,17 @@ class DerivationExpression PROTOBUF_FINAL : ::substrait::DerivationExpression_ExpressionStruct* struct__; ::substrait::DerivationExpression_ExpressionList* list_; ::substrait::DerivationExpression_ExpressionMap* map_; - ::PROTOBUF_NAMESPACE_ID::uint32 user_defined_pointer_; + uint32_t user_defined_pointer_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_parameter_name_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr integer_parameter_name_; - ::PROTOBUF_NAMESPACE_ID::int32 integer_literal_; + int32_t integer_literal_; ::substrait::DerivationExpression_UnaryOp* unary_op_; ::substrait::DerivationExpression_BinaryOp* binary_op_; ::substrait::DerivationExpression_IfElse* if_else_; ::substrait::DerivationExpression_ReturnProgram* return_program_; } kind_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1]; + uint32_t _oneof_case_[1]; friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; }; @@ -3259,7 +3469,7 @@ inline bool DerivationExpression_ExpressionFixedChar::has_length() const { return _internal_has_length(); } inline void DerivationExpression_ExpressionFixedChar::clear_length() { - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -3275,7 +3485,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionF } inline void DerivationExpression_ExpressionFixedChar::unsafe_arena_set_allocated_length( ::substrait::DerivationExpression* length) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } length_ = length; @@ -3290,9 +3500,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedCh ::substrait::DerivationExpression* temp = length_; length_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::unsafe_arena_release_length() { @@ -3305,23 +3521,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedCh inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); length_ = p; } return length_; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::mutable_length() { + ::substrait::DerivationExpression* _msg = _internal_mutable_length(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionFixedChar.length) - return _internal_mutable_length(); + return _msg; } inline void DerivationExpression_ExpressionFixedChar::set_allocated_length(::substrait::DerivationExpression* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete length_; } if (length) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length); if (message_arena != submessage_arena) { length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, length, submessage_arena); @@ -3338,18 +3555,18 @@ inline void DerivationExpression_ExpressionFixedChar::set_allocated_length(::sub inline void DerivationExpression_ExpressionFixedChar::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedChar::_internal_variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionFixedChar::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedChar::variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionFixedChar::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.variation_pointer) return _internal_variation_pointer(); } -inline void DerivationExpression_ExpressionFixedChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionFixedChar::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void DerivationExpression_ExpressionFixedChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionFixedChar::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedChar.variation_pointer) } @@ -3386,7 +3603,7 @@ inline bool DerivationExpression_ExpressionVarChar::has_length() const { return _internal_has_length(); } inline void DerivationExpression_ExpressionVarChar::clear_length() { - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -3402,7 +3619,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionV } inline void DerivationExpression_ExpressionVarChar::unsafe_arena_set_allocated_length( ::substrait::DerivationExpression* length) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } length_ = length; @@ -3417,9 +3634,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar ::substrait::DerivationExpression* temp = length_; length_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::unsafe_arena_release_length() { @@ -3432,23 +3655,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); length_ = p; } return length_; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::mutable_length() { + ::substrait::DerivationExpression* _msg = _internal_mutable_length(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionVarChar.length) - return _internal_mutable_length(); + return _msg; } inline void DerivationExpression_ExpressionVarChar::set_allocated_length(::substrait::DerivationExpression* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete length_; } if (length) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length); if (message_arena != submessage_arena) { length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, length, submessage_arena); @@ -3465,18 +3689,18 @@ inline void DerivationExpression_ExpressionVarChar::set_allocated_length(::subst inline void DerivationExpression_ExpressionVarChar::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionVarChar::_internal_variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionVarChar::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionVarChar::variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionVarChar::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.variation_pointer) return _internal_variation_pointer(); } -inline void DerivationExpression_ExpressionVarChar::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionVarChar::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void DerivationExpression_ExpressionVarChar::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionVarChar::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionVarChar.variation_pointer) } @@ -3513,7 +3737,7 @@ inline bool DerivationExpression_ExpressionFixedBinary::has_length() const { return _internal_has_length(); } inline void DerivationExpression_ExpressionFixedBinary::clear_length() { - if (GetArena() == nullptr && length_ != nullptr) { + if (GetArenaForAllocation() == nullptr && length_ != nullptr) { delete length_; } length_ = nullptr; @@ -3529,7 +3753,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionF } inline void DerivationExpression_ExpressionFixedBinary::unsafe_arena_set_allocated_length( ::substrait::DerivationExpression* length) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); } length_ = length; @@ -3544,9 +3768,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBi ::substrait::DerivationExpression* temp = length_; length_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::unsafe_arena_release_length() { @@ -3559,23 +3789,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBi inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::_internal_mutable_length() { if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); length_ = p; } return length_; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::mutable_length() { + ::substrait::DerivationExpression* _msg = _internal_mutable_length(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionFixedBinary.length) - return _internal_mutable_length(); + return _msg; } inline void DerivationExpression_ExpressionFixedBinary::set_allocated_length(::substrait::DerivationExpression* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete length_; } if (length) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(length); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length); if (message_arena != submessage_arena) { length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, length, submessage_arena); @@ -3592,18 +3823,18 @@ inline void DerivationExpression_ExpressionFixedBinary::set_allocated_length(::s inline void DerivationExpression_ExpressionFixedBinary::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedBinary::_internal_variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionFixedBinary::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionFixedBinary::variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionFixedBinary::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer) return _internal_variation_pointer(); } -inline void DerivationExpression_ExpressionFixedBinary::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionFixedBinary::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void DerivationExpression_ExpressionFixedBinary::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionFixedBinary::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer) } @@ -3640,7 +3871,7 @@ inline bool DerivationExpression_ExpressionDecimal::has_scale() const { return _internal_has_scale(); } inline void DerivationExpression_ExpressionDecimal::clear_scale() { - if (GetArena() == nullptr && scale_ != nullptr) { + if (GetArenaForAllocation() == nullptr && scale_ != nullptr) { delete scale_; } scale_ = nullptr; @@ -3656,7 +3887,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionD } inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_scale( ::substrait::DerivationExpression* scale) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_); } scale_ = scale; @@ -3671,9 +3902,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal ::substrait::DerivationExpression* temp = scale_; scale_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_scale() { @@ -3686,23 +3923,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_scale() { if (scale_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); scale_ = p; } return scale_; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_scale() { + ::substrait::DerivationExpression* _msg = _internal_mutable_scale(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionDecimal.scale) - return _internal_mutable_scale(); + return _msg; } inline void DerivationExpression_ExpressionDecimal::set_allocated_scale(::substrait::DerivationExpression* scale) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete scale_; } if (scale) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(scale); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(scale); if (message_arena != submessage_arena) { scale = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, scale, submessage_arena); @@ -3723,7 +3961,7 @@ inline bool DerivationExpression_ExpressionDecimal::has_precision() const { return _internal_has_precision(); } inline void DerivationExpression_ExpressionDecimal::clear_precision() { - if (GetArena() == nullptr && precision_ != nullptr) { + if (GetArenaForAllocation() == nullptr && precision_ != nullptr) { delete precision_; } precision_ = nullptr; @@ -3739,7 +3977,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionD } inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_precision( ::substrait::DerivationExpression* precision) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_); } precision_ = precision; @@ -3754,9 +3992,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal ::substrait::DerivationExpression* temp = precision_; precision_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_precision() { @@ -3769,23 +4013,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_precision() { if (precision_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); precision_ = p; } return precision_; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_precision() { + ::substrait::DerivationExpression* _msg = _internal_mutable_precision(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionDecimal.precision) - return _internal_mutable_precision(); + return _msg; } inline void DerivationExpression_ExpressionDecimal::set_allocated_precision(::substrait::DerivationExpression* precision) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete precision_; } if (precision) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(precision); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(precision); if (message_arena != submessage_arena) { precision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, precision, submessage_arena); @@ -3802,18 +4047,18 @@ inline void DerivationExpression_ExpressionDecimal::set_allocated_precision(::su inline void DerivationExpression_ExpressionDecimal::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionDecimal::_internal_variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionDecimal::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionDecimal::variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionDecimal::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.variation_pointer) return _internal_variation_pointer(); } -inline void DerivationExpression_ExpressionDecimal::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionDecimal::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void DerivationExpression_ExpressionDecimal::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionDecimal::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionDecimal.variation_pointer) } @@ -3872,8 +4117,9 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct: return types_.Add(); } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::add_types() { + ::substrait::DerivationExpression* _add = _internal_add_types(); // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionStruct.types) - return _internal_add_types(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >& DerivationExpression_ExpressionStruct::types() const { @@ -3885,18 +4131,18 @@ DerivationExpression_ExpressionStruct::types() const { inline void DerivationExpression_ExpressionStruct::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionStruct::_internal_variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionStruct::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionStruct::variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionStruct::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.variation_pointer) return _internal_variation_pointer(); } -inline void DerivationExpression_ExpressionStruct::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionStruct::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void DerivationExpression_ExpressionStruct::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionStruct::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionStruct.variation_pointer) } @@ -3936,8 +4182,9 @@ inline void DerivationExpression_ExpressionNamedStruct::clear_names() { names_.Clear(); } inline std::string* DerivationExpression_ExpressionNamedStruct::add_names() { + std::string* _s = _internal_add_names(); // @@protoc_insertion_point(field_add_mutable:substrait.DerivationExpression.ExpressionNamedStruct.names) - return _internal_add_names(); + return _s; } inline const std::string& DerivationExpression_ExpressionNamedStruct::_internal_names(int index) const { return names_.Get(index); @@ -3951,12 +4198,12 @@ inline std::string* DerivationExpression_ExpressionNamedStruct::mutable_names(in return names_.Mutable(index); } inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const std::string& value) { - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names) names_.Mutable(index)->assign(value); + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names) } inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, std::string&& value) { - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names) names_.Mutable(index)->assign(std::move(value)); + // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names) } inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); @@ -4007,7 +4254,7 @@ inline bool DerivationExpression_ExpressionNamedStruct::has_struct_() const { return _internal_has_struct_(); } inline void DerivationExpression_ExpressionNamedStruct::clear_struct_() { - if (GetArena() == nullptr && struct__ != nullptr) { + if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { delete struct__; } struct__ = nullptr; @@ -4023,7 +4270,7 @@ inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpre } inline void DerivationExpression_ExpressionNamedStruct::unsafe_arena_set_allocated_struct_( ::substrait::DerivationExpression_ExpressionStruct* struct_) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); } struct__ = struct_; @@ -4038,9 +4285,15 @@ inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ ::substrait::DerivationExpression_ExpressionStruct* temp = struct__; struct__ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::unsafe_arena_release_struct_() { @@ -4053,23 +4306,24 @@ inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::_internal_mutable_struct_() { if (struct__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression_ExpressionStruct>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression_ExpressionStruct>(GetArenaForAllocation()); struct__ = p; } return struct__; } inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::mutable_struct_() { + ::substrait::DerivationExpression_ExpressionStruct* _msg = _internal_mutable_struct_(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionNamedStruct.struct) - return _internal_mutable_struct_(); + return _msg; } inline void DerivationExpression_ExpressionNamedStruct::set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete struct__; } if (struct_) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(struct_); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionStruct>::GetOwningArena(struct_); if (message_arena != submessage_arena) { struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, struct_, submessage_arena); @@ -4094,7 +4348,7 @@ inline bool DerivationExpression_ExpressionList::has_type() const { return _internal_has_type(); } inline void DerivationExpression_ExpressionList::clear_type() { - if (GetArena() == nullptr && type_ != nullptr) { + if (GetArenaForAllocation() == nullptr && type_ != nullptr) { delete type_; } type_ = nullptr; @@ -4110,7 +4364,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionL } inline void DerivationExpression_ExpressionList::unsafe_arena_set_allocated_type( ::substrait::DerivationExpression* type) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); } type_ = type; @@ -4125,9 +4379,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::r ::substrait::DerivationExpression* temp = type_; type_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::unsafe_arena_release_type() { @@ -4140,23 +4400,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::u inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::_internal_mutable_type() { if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); type_ = p; } return type_; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::mutable_type() { + ::substrait::DerivationExpression* _msg = _internal_mutable_type(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionList.type) - return _internal_mutable_type(); + return _msg; } inline void DerivationExpression_ExpressionList::set_allocated_type(::substrait::DerivationExpression* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete type_; } if (type) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(type); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(type); if (message_arena != submessage_arena) { type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, type, submessage_arena); @@ -4173,18 +4434,18 @@ inline void DerivationExpression_ExpressionList::set_allocated_type(::substrait: inline void DerivationExpression_ExpressionList::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionList::_internal_variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionList::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionList::variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionList::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.variation_pointer) return _internal_variation_pointer(); } -inline void DerivationExpression_ExpressionList::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionList::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void DerivationExpression_ExpressionList::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionList::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionList.variation_pointer) } @@ -4221,7 +4482,7 @@ inline bool DerivationExpression_ExpressionMap::has_key() const { return _internal_has_key(); } inline void DerivationExpression_ExpressionMap::clear_key() { - if (GetArena() == nullptr && key_ != nullptr) { + if (GetArenaForAllocation() == nullptr && key_ != nullptr) { delete key_; } key_ = nullptr; @@ -4237,7 +4498,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionM } inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_key( ::substrait::DerivationExpression* key) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); } key_ = key; @@ -4252,9 +4513,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::re ::substrait::DerivationExpression* temp = key_; key_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_key() { @@ -4267,23 +4534,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::un inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_key() { if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); key_ = p; } return key_; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_key() { + ::substrait::DerivationExpression* _msg = _internal_mutable_key(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionMap.key) - return _internal_mutable_key(); + return _msg; } inline void DerivationExpression_ExpressionMap::set_allocated_key(::substrait::DerivationExpression* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete key_; } if (key) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(key); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(key); if (message_arena != submessage_arena) { key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, key, submessage_arena); @@ -4304,7 +4572,7 @@ inline bool DerivationExpression_ExpressionMap::has_value() const { return _internal_has_value(); } inline void DerivationExpression_ExpressionMap::clear_value() { - if (GetArena() == nullptr && value_ != nullptr) { + if (GetArenaForAllocation() == nullptr && value_ != nullptr) { delete value_; } value_ = nullptr; @@ -4320,7 +4588,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionM } inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_value( ::substrait::DerivationExpression* value) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); } value_ = value; @@ -4335,9 +4603,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::re ::substrait::DerivationExpression* temp = value_; value_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_value() { @@ -4350,23 +4624,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::un inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_value() { if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); value_ = p; } return value_; } inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_value() { + ::substrait::DerivationExpression* _msg = _internal_mutable_value(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionMap.value) - return _internal_mutable_value(); + return _msg; } inline void DerivationExpression_ExpressionMap::set_allocated_value(::substrait::DerivationExpression* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete value_; } if (value) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(value); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(value); if (message_arena != submessage_arena) { value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, value, submessage_arena); @@ -4383,18 +4658,18 @@ inline void DerivationExpression_ExpressionMap::set_allocated_value(::substrait: inline void DerivationExpression_ExpressionMap::clear_variation_pointer() { variation_pointer_ = 0u; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionMap::_internal_variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionMap::_internal_variation_pointer() const { return variation_pointer_; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression_ExpressionMap::variation_pointer() const { +inline uint32_t DerivationExpression_ExpressionMap::variation_pointer() const { // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.variation_pointer) return _internal_variation_pointer(); } -inline void DerivationExpression_ExpressionMap::_internal_set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionMap::_internal_set_variation_pointer(uint32_t value) { variation_pointer_ = value; } -inline void DerivationExpression_ExpressionMap::set_variation_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression_ExpressionMap::set_variation_pointer(uint32_t value) { _internal_set_variation_pointer(value); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionMap.variation_pointer) } @@ -4431,7 +4706,7 @@ inline bool DerivationExpression_IfElse::has_if_condition() const { return _internal_has_if_condition(); } inline void DerivationExpression_IfElse::clear_if_condition() { - if (GetArena() == nullptr && if_condition_ != nullptr) { + if (GetArenaForAllocation() == nullptr && if_condition_ != nullptr) { delete if_condition_; } if_condition_ = nullptr; @@ -4447,7 +4722,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::if_ } inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_condition( ::substrait::DerivationExpression* if_condition) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_condition_); } if_condition_ = if_condition; @@ -4462,9 +4737,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_i ::substrait::DerivationExpression* temp = if_condition_; if_condition_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_condition() { @@ -4477,23 +4758,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_ar inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_condition() { if (if_condition_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); if_condition_ = p; } return if_condition_; } inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_condition() { + ::substrait::DerivationExpression* _msg = _internal_mutable_if_condition(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.if_condition) - return _internal_mutable_if_condition(); + return _msg; } inline void DerivationExpression_IfElse::set_allocated_if_condition(::substrait::DerivationExpression* if_condition) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete if_condition_; } if (if_condition) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_condition); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(if_condition); if (message_arena != submessage_arena) { if_condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, if_condition, submessage_arena); @@ -4514,7 +4796,7 @@ inline bool DerivationExpression_IfElse::has_if_return() const { return _internal_has_if_return(); } inline void DerivationExpression_IfElse::clear_if_return() { - if (GetArena() == nullptr && if_return_ != nullptr) { + if (GetArenaForAllocation() == nullptr && if_return_ != nullptr) { delete if_return_; } if_return_ = nullptr; @@ -4530,7 +4812,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::if_ } inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_return( ::substrait::DerivationExpression* if_return) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_return_); } if_return_ = if_return; @@ -4545,9 +4827,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_i ::substrait::DerivationExpression* temp = if_return_; if_return_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_return() { @@ -4560,23 +4848,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_ar inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_return() { if (if_return_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); if_return_ = p; } return if_return_; } inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_return() { + ::substrait::DerivationExpression* _msg = _internal_mutable_if_return(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.if_return) - return _internal_mutable_if_return(); + return _msg; } inline void DerivationExpression_IfElse::set_allocated_if_return(::substrait::DerivationExpression* if_return) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete if_return_; } if (if_return) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(if_return); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(if_return); if (message_arena != submessage_arena) { if_return = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, if_return, submessage_arena); @@ -4597,7 +4886,7 @@ inline bool DerivationExpression_IfElse::has_else_return() const { return _internal_has_else_return(); } inline void DerivationExpression_IfElse::clear_else_return() { - if (GetArena() == nullptr && else_return_ != nullptr) { + if (GetArenaForAllocation() == nullptr && else_return_ != nullptr) { delete else_return_; } else_return_ = nullptr; @@ -4613,7 +4902,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::els } inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_else_return( ::substrait::DerivationExpression* else_return) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else_return_); } else_return_ = else_return; @@ -4628,9 +4917,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_e ::substrait::DerivationExpression* temp = else_return_; else_return_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_else_return() { @@ -4643,23 +4938,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_ar inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_else_return() { if (else_return_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); else_return_ = p; } return else_return_; } inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_else_return() { + ::substrait::DerivationExpression* _msg = _internal_mutable_else_return(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.else_return) - return _internal_mutable_else_return(); + return _msg; } inline void DerivationExpression_IfElse::set_allocated_else_return(::substrait::DerivationExpression* else_return) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete else_return_; } if (else_return) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(else_return); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(else_return); if (message_arena != submessage_arena) { else_return = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, else_return, submessage_arena); @@ -4704,7 +5000,7 @@ inline bool DerivationExpression_UnaryOp::has_arg() const { return _internal_has_arg(); } inline void DerivationExpression_UnaryOp::clear_arg() { - if (GetArena() == nullptr && arg_ != nullptr) { + if (GetArenaForAllocation() == nullptr && arg_ != nullptr) { delete arg_; } arg_ = nullptr; @@ -4720,7 +5016,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::ar } inline void DerivationExpression_UnaryOp::unsafe_arena_set_allocated_arg( ::substrait::DerivationExpression* arg) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_); } arg_ = arg; @@ -4735,9 +5031,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::release_ ::substrait::DerivationExpression* temp = arg_; arg_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::unsafe_arena_release_arg() { @@ -4750,23 +5052,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::unsafe_a inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::_internal_mutable_arg() { if (arg_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); arg_ = p; } return arg_; } inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::mutable_arg() { + ::substrait::DerivationExpression* _msg = _internal_mutable_arg(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.UnaryOp.arg) - return _internal_mutable_arg(); + return _msg; } inline void DerivationExpression_UnaryOp::set_allocated_arg(::substrait::DerivationExpression* arg) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete arg_; } if (arg) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg); if (message_arena != submessage_arena) { arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg, submessage_arena); @@ -4811,7 +5114,7 @@ inline bool DerivationExpression_BinaryOp::has_arg1() const { return _internal_has_arg1(); } inline void DerivationExpression_BinaryOp::clear_arg1() { - if (GetArena() == nullptr && arg1_ != nullptr) { + if (GetArenaForAllocation() == nullptr && arg1_ != nullptr) { delete arg1_; } arg1_ = nullptr; @@ -4827,7 +5130,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::a } inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg1( ::substrait::DerivationExpression* arg1) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg1_); } arg1_ = arg1; @@ -4842,9 +5145,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::release ::substrait::DerivationExpression* temp = arg1_; arg1_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg1() { @@ -4857,23 +5166,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_ inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg1() { if (arg1_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); arg1_ = p; } return arg1_; } inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg1() { + ::substrait::DerivationExpression* _msg = _internal_mutable_arg1(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.BinaryOp.arg1) - return _internal_mutable_arg1(); + return _msg; } inline void DerivationExpression_BinaryOp::set_allocated_arg1(::substrait::DerivationExpression* arg1) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete arg1_; } if (arg1) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg1); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg1); if (message_arena != submessage_arena) { arg1 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg1, submessage_arena); @@ -4894,7 +5204,7 @@ inline bool DerivationExpression_BinaryOp::has_arg2() const { return _internal_has_arg2(); } inline void DerivationExpression_BinaryOp::clear_arg2() { - if (GetArena() == nullptr && arg2_ != nullptr) { + if (GetArenaForAllocation() == nullptr && arg2_ != nullptr) { delete arg2_; } arg2_ = nullptr; @@ -4910,7 +5220,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::a } inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg2( ::substrait::DerivationExpression* arg2) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg2_); } arg2_ = arg2; @@ -4925,9 +5235,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::release ::substrait::DerivationExpression* temp = arg2_; arg2_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg2() { @@ -4940,23 +5256,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_ inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg2() { if (arg2_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); arg2_ = p; } return arg2_; } inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg2() { + ::substrait::DerivationExpression* _msg = _internal_mutable_arg2(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.BinaryOp.arg2) - return _internal_mutable_arg2(); + return _msg; } inline void DerivationExpression_BinaryOp::set_allocated_arg2(::substrait::DerivationExpression* arg2) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete arg2_; } if (arg2) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(arg2); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg2); if (message_arena != submessage_arena) { arg2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, arg2, submessage_arena); @@ -4982,30 +5299,31 @@ inline const std::string& DerivationExpression_ReturnProgram_Assignment::name() return _internal_name(); } template -PROTOBUF_ALWAYS_INLINE -inline void DerivationExpression_ReturnProgram_Assignment::set_name(ArgT0&& arg0, ArgT... args) { +inline PROTOBUF_ALWAYS_INLINE +void DerivationExpression_ReturnProgram_Assignment::set_name(ArgT0&& arg0, ArgT... args) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ReturnProgram.Assignment.name) } inline std::string* DerivationExpression_ReturnProgram_Assignment::mutable_name() { + std::string* _s = _internal_mutable_name(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.Assignment.name) - return _internal_mutable_name(); + return _s; } inline const std::string& DerivationExpression_ReturnProgram_Assignment::_internal_name() const { return name_.Get(); } inline void DerivationExpression_ReturnProgram_Assignment::_internal_set_name(const std::string& value) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_name() { - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* DerivationExpression_ReturnProgram_Assignment::release_name() { // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.Assignment.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_name(std::string* name) { if (name != nullptr) { @@ -5014,7 +5332,12 @@ inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_name(st } name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArena()); + GetArenaForAllocation()); +#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING + if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { + name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); + } +#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.name) } @@ -5026,7 +5349,7 @@ inline bool DerivationExpression_ReturnProgram_Assignment::has_expression() cons return _internal_has_expression(); } inline void DerivationExpression_ReturnProgram_Assignment::clear_expression() { - if (GetArena() == nullptr && expression_ != nullptr) { + if (GetArenaForAllocation() == nullptr && expression_ != nullptr) { delete expression_; } expression_ = nullptr; @@ -5042,7 +5365,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgr } inline void DerivationExpression_ReturnProgram_Assignment::unsafe_arena_set_allocated_expression( ::substrait::DerivationExpression* expression) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); } expression_ = expression; @@ -5057,9 +5380,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Ass ::substrait::DerivationExpression* temp = expression_; expression_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::unsafe_arena_release_expression() { @@ -5072,23 +5401,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Ass inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_expression() { if (expression_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); expression_ = p; } return expression_; } inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::mutable_expression() { + ::substrait::DerivationExpression* _msg = _internal_mutable_expression(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.Assignment.expression) - return _internal_mutable_expression(); + return _msg; } inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_expression(::substrait::DerivationExpression* expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete expression_; } if (expression) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(expression); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(expression); if (message_arena != submessage_arena) { expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, expression, submessage_arena); @@ -5135,8 +5465,9 @@ inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExp return assignments_.Add(); } inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::add_assignments() { + ::substrait::DerivationExpression_ReturnProgram_Assignment* _add = _internal_add_assignments(); // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ReturnProgram.assignments) - return _internal_add_assignments(); + return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >& DerivationExpression_ReturnProgram::assignments() const { @@ -5152,7 +5483,7 @@ inline bool DerivationExpression_ReturnProgram::has_final_expression() const { return _internal_has_final_expression(); } inline void DerivationExpression_ReturnProgram::clear_final_expression() { - if (GetArena() == nullptr && final_expression_ != nullptr) { + if (GetArenaForAllocation() == nullptr && final_expression_ != nullptr) { delete final_expression_; } final_expression_ = nullptr; @@ -5168,7 +5499,7 @@ inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgr } inline void DerivationExpression_ReturnProgram::unsafe_arena_set_allocated_final_expression( ::substrait::DerivationExpression* final_expression) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(final_expression_); } final_expression_ = final_expression; @@ -5183,9 +5514,15 @@ inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::re ::substrait::DerivationExpression* temp = final_expression_; final_expression_ = nullptr; - if (GetArena() != nullptr) { +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::unsafe_arena_release_final_expression() { @@ -5198,23 +5535,24 @@ inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::un inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::_internal_mutable_final_expression() { if (final_expression_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArena()); + auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); final_expression_ = p; } return final_expression_; } inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::mutable_final_expression() { + ::substrait::DerivationExpression* _msg = _internal_mutable_final_expression(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.final_expression) - return _internal_mutable_final_expression(); + return _msg; } inline void DerivationExpression_ReturnProgram::set_allocated_final_expression(::substrait::DerivationExpression* final_expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete final_expression_; } if (final_expression) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(final_expression); + ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(final_expression); if (message_arena != submessage_arena) { final_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, final_expression, submessage_arena); @@ -5246,7 +5584,7 @@ inline ::substrait::Type_Boolean* DerivationExpression::release_bool_() { if (_internal_has_bool_()) { clear_has_kind(); ::substrait::Type_Boolean* temp = kind_.bool__; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.bool__ = nullptr; @@ -5287,13 +5625,14 @@ inline ::substrait::Type_Boolean* DerivationExpression::_internal_mutable_bool_( if (!_internal_has_bool_()) { clear_kind(); set_has_bool_(); - kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArena()); + kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArenaForAllocation()); } return kind_.bool__; } inline ::substrait::Type_Boolean* DerivationExpression::mutable_bool_() { + ::substrait::Type_Boolean* _msg = _internal_mutable_bool_(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.bool) - return _internal_mutable_bool_(); + return _msg; } // .substrait.Type.I8 i8 = 2; @@ -5311,7 +5650,7 @@ inline ::substrait::Type_I8* DerivationExpression::release_i8() { if (_internal_has_i8()) { clear_has_kind(); ::substrait::Type_I8* temp = kind_.i8_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i8_ = nullptr; @@ -5352,13 +5691,14 @@ inline ::substrait::Type_I8* DerivationExpression::_internal_mutable_i8() { if (!_internal_has_i8()) { clear_kind(); set_has_i8(); - kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArena()); + kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArenaForAllocation()); } return kind_.i8_; } inline ::substrait::Type_I8* DerivationExpression::mutable_i8() { + ::substrait::Type_I8* _msg = _internal_mutable_i8(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i8) - return _internal_mutable_i8(); + return _msg; } // .substrait.Type.I16 i16 = 3; @@ -5376,7 +5716,7 @@ inline ::substrait::Type_I16* DerivationExpression::release_i16() { if (_internal_has_i16()) { clear_has_kind(); ::substrait::Type_I16* temp = kind_.i16_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i16_ = nullptr; @@ -5417,13 +5757,14 @@ inline ::substrait::Type_I16* DerivationExpression::_internal_mutable_i16() { if (!_internal_has_i16()) { clear_kind(); set_has_i16(); - kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArena()); + kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArenaForAllocation()); } return kind_.i16_; } inline ::substrait::Type_I16* DerivationExpression::mutable_i16() { + ::substrait::Type_I16* _msg = _internal_mutable_i16(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i16) - return _internal_mutable_i16(); + return _msg; } // .substrait.Type.I32 i32 = 5; @@ -5441,7 +5782,7 @@ inline ::substrait::Type_I32* DerivationExpression::release_i32() { if (_internal_has_i32()) { clear_has_kind(); ::substrait::Type_I32* temp = kind_.i32_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i32_ = nullptr; @@ -5482,13 +5823,14 @@ inline ::substrait::Type_I32* DerivationExpression::_internal_mutable_i32() { if (!_internal_has_i32()) { clear_kind(); set_has_i32(); - kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArena()); + kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArenaForAllocation()); } return kind_.i32_; } inline ::substrait::Type_I32* DerivationExpression::mutable_i32() { + ::substrait::Type_I32* _msg = _internal_mutable_i32(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i32) - return _internal_mutable_i32(); + return _msg; } // .substrait.Type.I64 i64 = 7; @@ -5506,7 +5848,7 @@ inline ::substrait::Type_I64* DerivationExpression::release_i64() { if (_internal_has_i64()) { clear_has_kind(); ::substrait::Type_I64* temp = kind_.i64_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.i64_ = nullptr; @@ -5547,13 +5889,14 @@ inline ::substrait::Type_I64* DerivationExpression::_internal_mutable_i64() { if (!_internal_has_i64()) { clear_kind(); set_has_i64(); - kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArena()); + kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArenaForAllocation()); } return kind_.i64_; } inline ::substrait::Type_I64* DerivationExpression::mutable_i64() { + ::substrait::Type_I64* _msg = _internal_mutable_i64(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i64) - return _internal_mutable_i64(); + return _msg; } // .substrait.Type.FP32 fp32 = 10; @@ -5571,7 +5914,7 @@ inline ::substrait::Type_FP32* DerivationExpression::release_fp32() { if (_internal_has_fp32()) { clear_has_kind(); ::substrait::Type_FP32* temp = kind_.fp32_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fp32_ = nullptr; @@ -5612,13 +5955,14 @@ inline ::substrait::Type_FP32* DerivationExpression::_internal_mutable_fp32() { if (!_internal_has_fp32()) { clear_kind(); set_has_fp32(); - kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArena()); + kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArenaForAllocation()); } return kind_.fp32_; } inline ::substrait::Type_FP32* DerivationExpression::mutable_fp32() { + ::substrait::Type_FP32* _msg = _internal_mutable_fp32(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fp32) - return _internal_mutable_fp32(); + return _msg; } // .substrait.Type.FP64 fp64 = 11; @@ -5636,7 +5980,7 @@ inline ::substrait::Type_FP64* DerivationExpression::release_fp64() { if (_internal_has_fp64()) { clear_has_kind(); ::substrait::Type_FP64* temp = kind_.fp64_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fp64_ = nullptr; @@ -5677,13 +6021,14 @@ inline ::substrait::Type_FP64* DerivationExpression::_internal_mutable_fp64() { if (!_internal_has_fp64()) { clear_kind(); set_has_fp64(); - kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArena()); + kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArenaForAllocation()); } return kind_.fp64_; } inline ::substrait::Type_FP64* DerivationExpression::mutable_fp64() { + ::substrait::Type_FP64* _msg = _internal_mutable_fp64(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fp64) - return _internal_mutable_fp64(); + return _msg; } // .substrait.Type.String string = 12; @@ -5701,7 +6046,7 @@ inline ::substrait::Type_String* DerivationExpression::release_string() { if (_internal_has_string()) { clear_has_kind(); ::substrait::Type_String* temp = kind_.string_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.string_ = nullptr; @@ -5742,13 +6087,14 @@ inline ::substrait::Type_String* DerivationExpression::_internal_mutable_string( if (!_internal_has_string()) { clear_kind(); set_has_string(); - kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArena()); + kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArenaForAllocation()); } return kind_.string_; } inline ::substrait::Type_String* DerivationExpression::mutable_string() { + ::substrait::Type_String* _msg = _internal_mutable_string(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.string) - return _internal_mutable_string(); + return _msg; } // .substrait.Type.Binary binary = 13; @@ -5766,7 +6112,7 @@ inline ::substrait::Type_Binary* DerivationExpression::release_binary() { if (_internal_has_binary()) { clear_has_kind(); ::substrait::Type_Binary* temp = kind_.binary_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.binary_ = nullptr; @@ -5807,13 +6153,14 @@ inline ::substrait::Type_Binary* DerivationExpression::_internal_mutable_binary( if (!_internal_has_binary()) { clear_kind(); set_has_binary(); - kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArena()); + kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArenaForAllocation()); } return kind_.binary_; } inline ::substrait::Type_Binary* DerivationExpression::mutable_binary() { + ::substrait::Type_Binary* _msg = _internal_mutable_binary(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.binary) - return _internal_mutable_binary(); + return _msg; } // .substrait.Type.Timestamp timestamp = 14; @@ -5831,7 +6178,7 @@ inline ::substrait::Type_Timestamp* DerivationExpression::release_timestamp() { if (_internal_has_timestamp()) { clear_has_kind(); ::substrait::Type_Timestamp* temp = kind_.timestamp_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.timestamp_ = nullptr; @@ -5872,13 +6219,14 @@ inline ::substrait::Type_Timestamp* DerivationExpression::_internal_mutable_time if (!_internal_has_timestamp()) { clear_kind(); set_has_timestamp(); - kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArena()); + kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArenaForAllocation()); } return kind_.timestamp_; } inline ::substrait::Type_Timestamp* DerivationExpression::mutable_timestamp() { + ::substrait::Type_Timestamp* _msg = _internal_mutable_timestamp(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.timestamp) - return _internal_mutable_timestamp(); + return _msg; } // .substrait.Type.Date date = 16; @@ -5896,7 +6244,7 @@ inline ::substrait::Type_Date* DerivationExpression::release_date() { if (_internal_has_date()) { clear_has_kind(); ::substrait::Type_Date* temp = kind_.date_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.date_ = nullptr; @@ -5937,13 +6285,14 @@ inline ::substrait::Type_Date* DerivationExpression::_internal_mutable_date() { if (!_internal_has_date()) { clear_kind(); set_has_date(); - kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArena()); + kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArenaForAllocation()); } return kind_.date_; } inline ::substrait::Type_Date* DerivationExpression::mutable_date() { + ::substrait::Type_Date* _msg = _internal_mutable_date(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.date) - return _internal_mutable_date(); + return _msg; } // .substrait.Type.Time time = 17; @@ -5961,7 +6310,7 @@ inline ::substrait::Type_Time* DerivationExpression::release_time() { if (_internal_has_time()) { clear_has_kind(); ::substrait::Type_Time* temp = kind_.time_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.time_ = nullptr; @@ -6002,13 +6351,14 @@ inline ::substrait::Type_Time* DerivationExpression::_internal_mutable_time() { if (!_internal_has_time()) { clear_kind(); set_has_time(); - kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArena()); + kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArenaForAllocation()); } return kind_.time_; } inline ::substrait::Type_Time* DerivationExpression::mutable_time() { + ::substrait::Type_Time* _msg = _internal_mutable_time(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.time) - return _internal_mutable_time(); + return _msg; } // .substrait.Type.IntervalYear interval_year = 19; @@ -6026,7 +6376,7 @@ inline ::substrait::Type_IntervalYear* DerivationExpression::release_interval_ye if (_internal_has_interval_year()) { clear_has_kind(); ::substrait::Type_IntervalYear* temp = kind_.interval_year_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.interval_year_ = nullptr; @@ -6067,13 +6417,14 @@ inline ::substrait::Type_IntervalYear* DerivationExpression::_internal_mutable_i if (!_internal_has_interval_year()) { clear_kind(); set_has_interval_year(); - kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArena()); + kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArenaForAllocation()); } return kind_.interval_year_; } inline ::substrait::Type_IntervalYear* DerivationExpression::mutable_interval_year() { + ::substrait::Type_IntervalYear* _msg = _internal_mutable_interval_year(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.interval_year) - return _internal_mutable_interval_year(); + return _msg; } // .substrait.Type.IntervalDay interval_day = 20; @@ -6091,7 +6442,7 @@ inline ::substrait::Type_IntervalDay* DerivationExpression::release_interval_day if (_internal_has_interval_day()) { clear_has_kind(); ::substrait::Type_IntervalDay* temp = kind_.interval_day_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.interval_day_ = nullptr; @@ -6132,13 +6483,14 @@ inline ::substrait::Type_IntervalDay* DerivationExpression::_internal_mutable_in if (!_internal_has_interval_day()) { clear_kind(); set_has_interval_day(); - kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArena()); + kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArenaForAllocation()); } return kind_.interval_day_; } inline ::substrait::Type_IntervalDay* DerivationExpression::mutable_interval_day() { + ::substrait::Type_IntervalDay* _msg = _internal_mutable_interval_day(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.interval_day) - return _internal_mutable_interval_day(); + return _msg; } // .substrait.Type.TimestampTZ timestamp_tz = 29; @@ -6156,7 +6508,7 @@ inline ::substrait::Type_TimestampTZ* DerivationExpression::release_timestamp_tz if (_internal_has_timestamp_tz()) { clear_has_kind(); ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.timestamp_tz_ = nullptr; @@ -6197,13 +6549,14 @@ inline ::substrait::Type_TimestampTZ* DerivationExpression::_internal_mutable_ti if (!_internal_has_timestamp_tz()) { clear_kind(); set_has_timestamp_tz(); - kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArena()); + kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArenaForAllocation()); } return kind_.timestamp_tz_; } inline ::substrait::Type_TimestampTZ* DerivationExpression::mutable_timestamp_tz() { + ::substrait::Type_TimestampTZ* _msg = _internal_mutable_timestamp_tz(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.timestamp_tz) - return _internal_mutable_timestamp_tz(); + return _msg; } // .substrait.Type.UUID uuid = 32; @@ -6221,7 +6574,7 @@ inline ::substrait::Type_UUID* DerivationExpression::release_uuid() { if (_internal_has_uuid()) { clear_has_kind(); ::substrait::Type_UUID* temp = kind_.uuid_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.uuid_ = nullptr; @@ -6262,13 +6615,14 @@ inline ::substrait::Type_UUID* DerivationExpression::_internal_mutable_uuid() { if (!_internal_has_uuid()) { clear_kind(); set_has_uuid(); - kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArena()); + kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArenaForAllocation()); } return kind_.uuid_; } inline ::substrait::Type_UUID* DerivationExpression::mutable_uuid() { + ::substrait::Type_UUID* _msg = _internal_mutable_uuid(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.uuid) - return _internal_mutable_uuid(); + return _msg; } // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; @@ -6283,7 +6637,7 @@ inline void DerivationExpression::set_has_fixed_char() { } inline void DerivationExpression::clear_fixed_char() { if (_internal_has_fixed_char()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_char_; } clear_has_kind(); @@ -6294,7 +6648,7 @@ inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpressi if (_internal_has_fixed_char()) { clear_has_kind(); ::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fixed_char_ = nullptr; @@ -6335,13 +6689,14 @@ inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpressi if (!_internal_has_fixed_char()) { clear_kind(); set_has_fixed_char(); - kind_.fixed_char_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedChar >(GetArena()); + kind_.fixed_char_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedChar >(GetArenaForAllocation()); } return kind_.fixed_char_; } inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::mutable_fixed_char() { + ::substrait::DerivationExpression_ExpressionFixedChar* _msg = _internal_mutable_fixed_char(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fixed_char) - return _internal_mutable_fixed_char(); + return _msg; } // .substrait.DerivationExpression.ExpressionVarChar varchar = 22; @@ -6356,7 +6711,7 @@ inline void DerivationExpression::set_has_varchar() { } inline void DerivationExpression::clear_varchar() { if (_internal_has_varchar()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.varchar_; } clear_has_kind(); @@ -6367,7 +6722,7 @@ inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression if (_internal_has_varchar()) { clear_has_kind(); ::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.varchar_ = nullptr; @@ -6408,13 +6763,14 @@ inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression if (!_internal_has_varchar()) { clear_kind(); set_has_varchar(); - kind_.varchar_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionVarChar >(GetArena()); + kind_.varchar_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionVarChar >(GetArenaForAllocation()); } return kind_.varchar_; } inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::mutable_varchar() { + ::substrait::DerivationExpression_ExpressionVarChar* _msg = _internal_mutable_varchar(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.varchar) - return _internal_mutable_varchar(); + return _msg; } // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; @@ -6429,7 +6785,7 @@ inline void DerivationExpression::set_has_fixed_binary() { } inline void DerivationExpression::clear_fixed_binary() { if (_internal_has_fixed_binary()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.fixed_binary_; } clear_has_kind(); @@ -6440,7 +6796,7 @@ inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpres if (_internal_has_fixed_binary()) { clear_has_kind(); ::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.fixed_binary_ = nullptr; @@ -6481,13 +6837,14 @@ inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpres if (!_internal_has_fixed_binary()) { clear_kind(); set_has_fixed_binary(); - kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedBinary >(GetArena()); + kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedBinary >(GetArenaForAllocation()); } return kind_.fixed_binary_; } inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::mutable_fixed_binary() { + ::substrait::DerivationExpression_ExpressionFixedBinary* _msg = _internal_mutable_fixed_binary(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fixed_binary) - return _internal_mutable_fixed_binary(); + return _msg; } // .substrait.DerivationExpression.ExpressionDecimal decimal = 24; @@ -6502,7 +6859,7 @@ inline void DerivationExpression::set_has_decimal() { } inline void DerivationExpression::clear_decimal() { if (_internal_has_decimal()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.decimal_; } clear_has_kind(); @@ -6513,7 +6870,7 @@ inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression if (_internal_has_decimal()) { clear_has_kind(); ::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.decimal_ = nullptr; @@ -6554,13 +6911,14 @@ inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression if (!_internal_has_decimal()) { clear_kind(); set_has_decimal(); - kind_.decimal_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionDecimal >(GetArena()); + kind_.decimal_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionDecimal >(GetArenaForAllocation()); } return kind_.decimal_; } inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::mutable_decimal() { + ::substrait::DerivationExpression_ExpressionDecimal* _msg = _internal_mutable_decimal(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.decimal) - return _internal_mutable_decimal(); + return _msg; } // .substrait.DerivationExpression.ExpressionStruct struct = 25; @@ -6575,7 +6933,7 @@ inline void DerivationExpression::set_has_struct_() { } inline void DerivationExpression::clear_struct_() { if (_internal_has_struct_()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.struct__; } clear_has_kind(); @@ -6586,7 +6944,7 @@ inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression: if (_internal_has_struct_()) { clear_has_kind(); ::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.struct__ = nullptr; @@ -6627,13 +6985,14 @@ inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression: if (!_internal_has_struct_()) { clear_kind(); set_has_struct_(); - kind_.struct__ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionStruct >(GetArena()); + kind_.struct__ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionStruct >(GetArenaForAllocation()); } return kind_.struct__; } inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::mutable_struct_() { + ::substrait::DerivationExpression_ExpressionStruct* _msg = _internal_mutable_struct_(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.struct) - return _internal_mutable_struct_(); + return _msg; } // .substrait.DerivationExpression.ExpressionList list = 27; @@ -6648,7 +7007,7 @@ inline void DerivationExpression::set_has_list() { } inline void DerivationExpression::clear_list() { if (_internal_has_list()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.list_; } clear_has_kind(); @@ -6659,7 +7018,7 @@ inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::r if (_internal_has_list()) { clear_has_kind(); ::substrait::DerivationExpression_ExpressionList* temp = kind_.list_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.list_ = nullptr; @@ -6700,13 +7059,14 @@ inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::_ if (!_internal_has_list()) { clear_kind(); set_has_list(); - kind_.list_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionList >(GetArena()); + kind_.list_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionList >(GetArenaForAllocation()); } return kind_.list_; } inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::mutable_list() { + ::substrait::DerivationExpression_ExpressionList* _msg = _internal_mutable_list(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.list) - return _internal_mutable_list(); + return _msg; } // .substrait.DerivationExpression.ExpressionMap map = 28; @@ -6721,7 +7081,7 @@ inline void DerivationExpression::set_has_map() { } inline void DerivationExpression::clear_map() { if (_internal_has_map()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.map_; } clear_has_kind(); @@ -6732,7 +7092,7 @@ inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::re if (_internal_has_map()) { clear_has_kind(); ::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.map_ = nullptr; @@ -6773,13 +7133,14 @@ inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::_i if (!_internal_has_map()) { clear_kind(); set_has_map(); - kind_.map_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionMap >(GetArena()); + kind_.map_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionMap >(GetArenaForAllocation()); } return kind_.map_; } inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::mutable_map() { + ::substrait::DerivationExpression_ExpressionMap* _msg = _internal_mutable_map(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.map) - return _internal_mutable_map(); + return _msg; } // uint32 user_defined_pointer = 31; @@ -6798,24 +7159,24 @@ inline void DerivationExpression::clear_user_defined_pointer() { clear_has_kind(); } } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression::_internal_user_defined_pointer() const { +inline uint32_t DerivationExpression::_internal_user_defined_pointer() const { if (_internal_has_user_defined_pointer()) { return kind_.user_defined_pointer_; } return 0u; } -inline void DerivationExpression::_internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression::_internal_set_user_defined_pointer(uint32_t value) { if (!_internal_has_user_defined_pointer()) { clear_kind(); set_has_user_defined_pointer(); } kind_.user_defined_pointer_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::uint32 DerivationExpression::user_defined_pointer() const { +inline uint32_t DerivationExpression::user_defined_pointer() const { // @@protoc_insertion_point(field_get:substrait.DerivationExpression.user_defined_pointer) return _internal_user_defined_pointer(); } -inline void DerivationExpression::set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::uint32 value) { +inline void DerivationExpression::set_user_defined_pointer(uint32_t value) { _internal_set_user_defined_pointer(value); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.user_defined_pointer) } @@ -6832,7 +7193,7 @@ inline void DerivationExpression::set_has_type_parameter_name() { } inline void DerivationExpression::clear_type_parameter_name() { if (_internal_has_type_parameter_name()) { - kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_kind(); } } @@ -6847,12 +7208,13 @@ inline void DerivationExpression::set_type_parameter_name(ArgT0&& arg0, ArgT... set_has_type_parameter_name(); kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.type_parameter_name) } inline std::string* DerivationExpression::mutable_type_parameter_name() { + std::string* _s = _internal_mutable_type_parameter_name(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.type_parameter_name) - return _internal_mutable_type_parameter_name(); + return _s; } inline const std::string& DerivationExpression::_internal_type_parameter_name() const { if (_internal_has_type_parameter_name()) { @@ -6866,7 +7228,7 @@ inline void DerivationExpression::_internal_set_type_parameter_name(const std::s set_has_type_parameter_name(); kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* DerivationExpression::_internal_mutable_type_parameter_name() { if (!_internal_has_type_parameter_name()) { @@ -6875,13 +7237,13 @@ inline std::string* DerivationExpression::_internal_mutable_type_parameter_name( kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return kind_.type_parameter_name_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* DerivationExpression::release_type_parameter_name() { // @@protoc_insertion_point(field_release:substrait.DerivationExpression.type_parameter_name) if (_internal_has_type_parameter_name()) { clear_has_kind(); - return kind_.type_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return kind_.type_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -6893,7 +7255,7 @@ inline void DerivationExpression::set_allocated_type_parameter_name(std::string* if (type_parameter_name != nullptr) { set_has_type_parameter_name(); kind_.type_parameter_name_.UnsafeSetDefault(type_parameter_name); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(type_parameter_name); } @@ -6913,7 +7275,7 @@ inline void DerivationExpression::set_has_integer_parameter_name() { } inline void DerivationExpression::clear_integer_parameter_name() { if (_internal_has_integer_parameter_name()) { - kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); clear_has_kind(); } } @@ -6928,12 +7290,13 @@ inline void DerivationExpression::set_integer_parameter_name(ArgT0&& arg0, ArgT. set_has_integer_parameter_name(); kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArena()); + kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.integer_parameter_name) } inline std::string* DerivationExpression::mutable_integer_parameter_name() { + std::string* _s = _internal_mutable_integer_parameter_name(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.integer_parameter_name) - return _internal_mutable_integer_parameter_name(); + return _s; } inline const std::string& DerivationExpression::_internal_integer_parameter_name() const { if (_internal_has_integer_parameter_name()) { @@ -6947,7 +7310,7 @@ inline void DerivationExpression::_internal_set_integer_parameter_name(const std set_has_integer_parameter_name(); kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } - kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); + kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); } inline std::string* DerivationExpression::_internal_mutable_integer_parameter_name() { if (!_internal_has_integer_parameter_name()) { @@ -6956,13 +7319,13 @@ inline std::string* DerivationExpression::_internal_mutable_integer_parameter_na kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); } return kind_.integer_parameter_name_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); + ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); } inline std::string* DerivationExpression::release_integer_parameter_name() { // @@protoc_insertion_point(field_release:substrait.DerivationExpression.integer_parameter_name) if (_internal_has_integer_parameter_name()) { clear_has_kind(); - return kind_.integer_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); + return kind_.integer_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); } else { return nullptr; } @@ -6974,7 +7337,7 @@ inline void DerivationExpression::set_allocated_integer_parameter_name(std::stri if (integer_parameter_name != nullptr) { set_has_integer_parameter_name(); kind_.integer_parameter_name_.UnsafeSetDefault(integer_parameter_name); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArena(); + ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); if (arena != nullptr) { arena->Own(integer_parameter_name); } @@ -6998,24 +7361,24 @@ inline void DerivationExpression::clear_integer_literal() { clear_has_kind(); } } -inline ::PROTOBUF_NAMESPACE_ID::int32 DerivationExpression::_internal_integer_literal() const { +inline int32_t DerivationExpression::_internal_integer_literal() const { if (_internal_has_integer_literal()) { return kind_.integer_literal_; } return 0; } -inline void DerivationExpression::_internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void DerivationExpression::_internal_set_integer_literal(int32_t value) { if (!_internal_has_integer_literal()) { clear_kind(); set_has_integer_literal(); } kind_.integer_literal_ = value; } -inline ::PROTOBUF_NAMESPACE_ID::int32 DerivationExpression::integer_literal() const { +inline int32_t DerivationExpression::integer_literal() const { // @@protoc_insertion_point(field_get:substrait.DerivationExpression.integer_literal) return _internal_integer_literal(); } -inline void DerivationExpression::set_integer_literal(::PROTOBUF_NAMESPACE_ID::int32 value) { +inline void DerivationExpression::set_integer_literal(int32_t value) { _internal_set_integer_literal(value); // @@protoc_insertion_point(field_set:substrait.DerivationExpression.integer_literal) } @@ -7032,7 +7395,7 @@ inline void DerivationExpression::set_has_unary_op() { } inline void DerivationExpression::clear_unary_op() { if (_internal_has_unary_op()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.unary_op_; } clear_has_kind(); @@ -7043,7 +7406,7 @@ inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::release_ if (_internal_has_unary_op()) { clear_has_kind(); ::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.unary_op_ = nullptr; @@ -7084,13 +7447,14 @@ inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::_interna if (!_internal_has_unary_op()) { clear_kind(); set_has_unary_op(); - kind_.unary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_UnaryOp >(GetArena()); + kind_.unary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_UnaryOp >(GetArenaForAllocation()); } return kind_.unary_op_; } inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::mutable_unary_op() { + ::substrait::DerivationExpression_UnaryOp* _msg = _internal_mutable_unary_op(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.unary_op) - return _internal_mutable_unary_op(); + return _msg; } // .substrait.DerivationExpression.BinaryOp binary_op = 37; @@ -7105,7 +7469,7 @@ inline void DerivationExpression::set_has_binary_op() { } inline void DerivationExpression::clear_binary_op() { if (_internal_has_binary_op()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.binary_op_; } clear_has_kind(); @@ -7116,7 +7480,7 @@ inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::release if (_internal_has_binary_op()) { clear_has_kind(); ::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.binary_op_ = nullptr; @@ -7157,13 +7521,14 @@ inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::_intern if (!_internal_has_binary_op()) { clear_kind(); set_has_binary_op(); - kind_.binary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_BinaryOp >(GetArena()); + kind_.binary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_BinaryOp >(GetArenaForAllocation()); } return kind_.binary_op_; } inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::mutable_binary_op() { + ::substrait::DerivationExpression_BinaryOp* _msg = _internal_mutable_binary_op(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.binary_op) - return _internal_mutable_binary_op(); + return _msg; } // .substrait.DerivationExpression.IfElse if_else = 38; @@ -7178,7 +7543,7 @@ inline void DerivationExpression::set_has_if_else() { } inline void DerivationExpression::clear_if_else() { if (_internal_has_if_else()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.if_else_; } clear_has_kind(); @@ -7189,7 +7554,7 @@ inline ::substrait::DerivationExpression_IfElse* DerivationExpression::release_i if (_internal_has_if_else()) { clear_has_kind(); ::substrait::DerivationExpression_IfElse* temp = kind_.if_else_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.if_else_ = nullptr; @@ -7230,13 +7595,14 @@ inline ::substrait::DerivationExpression_IfElse* DerivationExpression::_internal if (!_internal_has_if_else()) { clear_kind(); set_has_if_else(); - kind_.if_else_ = CreateMaybeMessage< ::substrait::DerivationExpression_IfElse >(GetArena()); + kind_.if_else_ = CreateMaybeMessage< ::substrait::DerivationExpression_IfElse >(GetArenaForAllocation()); } return kind_.if_else_; } inline ::substrait::DerivationExpression_IfElse* DerivationExpression::mutable_if_else() { + ::substrait::DerivationExpression_IfElse* _msg = _internal_mutable_if_else(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.if_else) - return _internal_mutable_if_else(); + return _msg; } // .substrait.DerivationExpression.ReturnProgram return_program = 39; @@ -7251,7 +7617,7 @@ inline void DerivationExpression::set_has_return_program() { } inline void DerivationExpression::clear_return_program() { if (_internal_has_return_program()) { - if (GetArena() == nullptr) { + if (GetArenaForAllocation() == nullptr) { delete kind_.return_program_; } clear_has_kind(); @@ -7262,7 +7628,7 @@ inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::re if (_internal_has_return_program()) { clear_has_kind(); ::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_; - if (GetArena() != nullptr) { + if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } kind_.return_program_ = nullptr; @@ -7303,13 +7669,14 @@ inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::_i if (!_internal_has_return_program()) { clear_kind(); set_has_return_program(); - kind_.return_program_ = CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram >(GetArena()); + kind_.return_program_ = CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram >(GetArenaForAllocation()); } return kind_.return_program_; } inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::mutable_return_program() { + ::substrait::DerivationExpression_ReturnProgram* _msg = _internal_mutable_return_program(); // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.return_program) - return _internal_mutable_return_program(); + return _msg; } inline bool DerivationExpression::has_kind() const { From ecb52146de704dc0d8e27ef76bd94d37d3450673 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 27 Jan 2022 20:32:44 +0100 Subject: [PATCH 070/113] Remove files generated by protoc Files generated by protoc won't compile unless the version of protoc matches the runtime version almost exactly. Therefore, they almost always need to be regenerated, leaving the worktree in a dirty state all the while. It makes more sense to just always regenerate them. --- cpp/build-support/lint_cpp_cli.py | 3 +- cpp/build-support/lint_exclusions.txt | 1 - cpp/src/arrow/engine/CMakeLists.txt | 6 +- .../engine/substrait/expression_internal.h | 2 +- .../arrow/engine/substrait/plan_internal.h | 2 +- .../engine/substrait/relation_internal.h | 2 +- .../arrow/engine/substrait/type_internal.h | 2 +- .../generated/substrait/capabilities.pb.cc | 701 - cpp/src/generated/substrait/capabilities.pb.h | 1002 - cpp/src/generated/substrait/expression.pb.cc | 14785 ------------- cpp/src/generated/substrait/expression.pb.h | 18033 ---------------- .../substrait/extensions/extensions.pb.cc | 1881 -- .../substrait/extensions/extensions.pb.h | 1966 -- cpp/src/generated/substrait/function.pb.cc | 4303 ---- cpp/src/generated/substrait/function.pb.h | 5553 ----- .../substrait/parameterized_types.pb.cc | 5353 ----- .../substrait/parameterized_types.pb.h | 6437 ------ cpp/src/generated/substrait/plan.pb.cc | 796 - cpp/src/generated/substrait/plan.pb.h | 951 - cpp/src/generated/substrait/relations.pb.cc | 9153 -------- cpp/src/generated/substrait/relations.pb.h | 12611 ----------- cpp/src/generated/substrait/type.pb.cc | 7858 ------- cpp/src/generated/substrait/type.pb.h | 8265 ------- .../substrait/type_expressions.pb.cc | 6038 ------ .../generated/substrait/type_expressions.pb.h | 7743 ------- 25 files changed, 9 insertions(+), 113438 deletions(-) delete mode 100644 cpp/src/generated/substrait/capabilities.pb.cc delete mode 100644 cpp/src/generated/substrait/capabilities.pb.h delete mode 100644 cpp/src/generated/substrait/expression.pb.cc delete mode 100644 cpp/src/generated/substrait/expression.pb.h delete mode 100644 cpp/src/generated/substrait/extensions/extensions.pb.cc delete mode 100644 cpp/src/generated/substrait/extensions/extensions.pb.h delete mode 100644 cpp/src/generated/substrait/function.pb.cc delete mode 100644 cpp/src/generated/substrait/function.pb.h delete mode 100644 cpp/src/generated/substrait/parameterized_types.pb.cc delete mode 100644 cpp/src/generated/substrait/parameterized_types.pb.h delete mode 100644 cpp/src/generated/substrait/plan.pb.cc delete mode 100644 cpp/src/generated/substrait/plan.pb.h delete mode 100644 cpp/src/generated/substrait/relations.pb.cc delete mode 100644 cpp/src/generated/substrait/relations.pb.h delete mode 100644 cpp/src/generated/substrait/type.pb.cc delete mode 100644 cpp/src/generated/substrait/type.pb.h delete mode 100644 cpp/src/generated/substrait/type_expressions.pb.cc delete mode 100644 cpp/src/generated/substrait/type_expressions.pb.h diff --git a/cpp/build-support/lint_cpp_cli.py b/cpp/build-support/lint_cpp_cli.py index 0dd9b5b9128..a0eb8f0efe6 100755 --- a/cpp/build-support/lint_cpp_cli.py +++ b/cpp/build-support/lint_cpp_cli.py @@ -89,8 +89,7 @@ def lint_file(path): jni/ test internal - _generated - generated/substrait/''') + _generated''') def lint_files(): diff --git a/cpp/build-support/lint_exclusions.txt b/cpp/build-support/lint_exclusions.txt index 46c9532266d..73cbd884f44 100644 --- a/cpp/build-support/lint_exclusions.txt +++ b/cpp/build-support/lint_exclusions.txt @@ -1,5 +1,4 @@ *_generated* -*generated/substrait/*.pb.* *.grpc.fb.* *arrowExports.cpp* *parquet_constants.* diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index 8412edd197d..cc6c781613a 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -35,7 +35,7 @@ set(ARROW_ENGINE_SRCS substrait/type_internal.cc) set(SUBSTRAIT_LOCAL_DIR "${CMAKE_CURRENT_BINARY_DIR}/substrait") -set(SUBSTRAIT_GEN_DIR "${ARROW_SOURCE_DIR}/src/generated") +set(SUBSTRAIT_GEN_DIR "${CMAKE_CURRENT_BINARY_DIR}/generated") set(SUBSTRAIT_PROTOS capabilities expression @@ -126,7 +126,9 @@ add_arrow_lib(arrow_engine STATIC_LINK_LIBS arrow_static arrow_dataset_static - ${ARROW_ENGINE_LINK_LIBS}) + ${ARROW_ENGINE_LINK_LIBS} + PRIVATE_INCLUDES + ${SUBSTRAIT_GEN_DIR}) foreach(LIB_TARGET ${ARROW_ENGINE_LIBRARIES}) target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_ENGINE_EXPORTING diff --git a/cpp/src/arrow/engine/substrait/expression_internal.h b/cpp/src/arrow/engine/substrait/expression_internal.h index 332b173b677..e491fa674cf 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.h +++ b/cpp/src/arrow/engine/substrait/expression_internal.h @@ -26,7 +26,7 @@ #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" -#include "generated/substrait/expression.pb.h" // IWYU pragma: export +#include "substrait/expression.pb.h" // IWYU pragma: export namespace arrow { namespace engine { diff --git a/cpp/src/arrow/engine/substrait/plan_internal.h b/cpp/src/arrow/engine/substrait/plan_internal.h index 5819ea209f2..cdec386b1ea 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.h +++ b/cpp/src/arrow/engine/substrait/plan_internal.h @@ -23,7 +23,7 @@ #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" -#include "generated/substrait/plan.pb.h" // IWYU pragma: export +#include "substrait/plan.pb.h" // IWYU pragma: export namespace arrow { namespace engine { diff --git a/cpp/src/arrow/engine/substrait/relation_internal.h b/cpp/src/arrow/engine/substrait/relation_internal.h index b0e899a6af3..d9b90f50779 100644 --- a/cpp/src/arrow/engine/substrait/relation_internal.h +++ b/cpp/src/arrow/engine/substrait/relation_internal.h @@ -25,7 +25,7 @@ #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" -#include "generated/substrait/relations.pb.h" // IWYU pragma: export +#include "substrait/relations.pb.h" // IWYU pragma: export namespace arrow { namespace engine { diff --git a/cpp/src/arrow/engine/substrait/type_internal.h b/cpp/src/arrow/engine/substrait/type_internal.h index 380c07024d0..058019c759f 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.h +++ b/cpp/src/arrow/engine/substrait/type_internal.h @@ -25,7 +25,7 @@ #include "arrow/engine/visibility.h" #include "arrow/type_fwd.h" -#include "generated/substrait/type.pb.h" // IWYU pragma: export +#include "substrait/type.pb.h" // IWYU pragma: export namespace arrow { namespace engine { diff --git a/cpp/src/generated/substrait/capabilities.pb.cc b/cpp/src/generated/substrait/capabilities.pb.cc deleted file mode 100644 index a87949956df..00000000000 --- a/cpp/src/generated/substrait/capabilities.pb.cc +++ /dev/null @@ -1,701 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/capabilities.proto - -#include "substrait/capabilities.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace substrait { -constexpr Capabilities_SimpleExtension::Capabilities_SimpleExtension( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : function_keys_() - , type_keys_() - , type_variation_keys_() - , uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct Capabilities_SimpleExtensionDefaultTypeInternal { - constexpr Capabilities_SimpleExtensionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Capabilities_SimpleExtensionDefaultTypeInternal() {} - union { - Capabilities_SimpleExtension _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Capabilities_SimpleExtensionDefaultTypeInternal _Capabilities_SimpleExtension_default_instance_; -constexpr Capabilities::Capabilities( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : substrait_versions_() - , advanced_extension_type_urls_() - , simple_extensions_(){} -struct CapabilitiesDefaultTypeInternal { - constexpr CapabilitiesDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~CapabilitiesDefaultTypeInternal() {} - union { - Capabilities _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT CapabilitiesDefaultTypeInternal _Capabilities_default_instance_; -} // namespace substrait -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fcapabilities_2eproto[2]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fcapabilities_2eproto = nullptr; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fcapabilities_2eproto = nullptr; - -const uint32_t TableStruct_substrait_2fcapabilities_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, uri_), - PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, function_keys_), - PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, type_keys_), - PROTOBUF_FIELD_OFFSET(::substrait::Capabilities_SimpleExtension, type_variation_keys_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, substrait_versions_), - PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, advanced_extension_type_urls_), - PROTOBUF_FIELD_OFFSET(::substrait::Capabilities, simple_extensions_), -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, -1, sizeof(::substrait::Capabilities_SimpleExtension)}, - { 10, -1, -1, sizeof(::substrait::Capabilities)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::substrait::_Capabilities_SimpleExtension_default_instance_), - reinterpret_cast(&::substrait::_Capabilities_default_instance_), -}; - -const char descriptor_table_protodef_substrait_2fcapabilities_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\034substrait/capabilities.proto\022\tsubstrai" - "t\"\373\001\n\014Capabilities\022\032\n\022substrait_versions" - "\030\001 \003(\t\022$\n\034advanced_extension_type_urls\030\002" - " \003(\t\022B\n\021simple_extensions\030\003 \003(\0132\'.substr" - "ait.Capabilities.SimpleExtension\032e\n\017Simp" - "leExtension\022\013\n\003uri\030\001 \001(\t\022\025\n\rfunction_key" - "s\030\002 \003(\t\022\021\n\ttype_keys\030\003 \003(\t\022\033\n\023type_varia" - "tion_keys\030\004 \003(\tB+\n\022io.substrait.protoP\001\252" - "\002\022Substrait.Protobufb\006proto3" - ; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fcapabilities_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fcapabilities_2eproto = { - false, false, 348, descriptor_table_protodef_substrait_2fcapabilities_2eproto, "substrait/capabilities.proto", - &descriptor_table_substrait_2fcapabilities_2eproto_once, nullptr, 0, 2, - schemas, file_default_instances, TableStruct_substrait_2fcapabilities_2eproto::offsets, - file_level_metadata_substrait_2fcapabilities_2eproto, file_level_enum_descriptors_substrait_2fcapabilities_2eproto, file_level_service_descriptors_substrait_2fcapabilities_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fcapabilities_2eproto_getter() { - return &descriptor_table_substrait_2fcapabilities_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fcapabilities_2eproto(&descriptor_table_substrait_2fcapabilities_2eproto); -namespace substrait { - -// =================================================================== - -class Capabilities_SimpleExtension::_Internal { - public: -}; - -Capabilities_SimpleExtension::Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - function_keys_(arena), - type_keys_(arena), - type_variation_keys_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Capabilities.SimpleExtension) -} -Capabilities_SimpleExtension::Capabilities_SimpleExtension(const Capabilities_SimpleExtension& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - function_keys_(from.function_keys_), - type_keys_(from.type_keys_), - type_variation_keys_(from.type_variation_keys_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_uri().empty()) { - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), - GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:substrait.Capabilities.SimpleExtension) -} - -inline void Capabilities_SimpleExtension::SharedCtor() { -uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Capabilities_SimpleExtension::~Capabilities_SimpleExtension() { - // @@protoc_insertion_point(destructor:substrait.Capabilities.SimpleExtension) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Capabilities_SimpleExtension::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void Capabilities_SimpleExtension::ArenaDtor(void* object) { - Capabilities_SimpleExtension* _this = reinterpret_cast< Capabilities_SimpleExtension* >(object); - (void)_this; -} -void Capabilities_SimpleExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Capabilities_SimpleExtension::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Capabilities_SimpleExtension::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Capabilities.SimpleExtension) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - function_keys_.Clear(); - type_keys_.Clear(); - type_variation_keys_.Clear(); - uri_.ClearToEmpty(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Capabilities_SimpleExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string uri = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_uri(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.uri")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated string function_keys = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_function_keys(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.function_keys")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // repeated string type_keys = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_type_keys(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.type_keys")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // repeated string type_variation_keys = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_type_variation_keys(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.SimpleExtension.type_variation_keys")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(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* Capabilities_SimpleExtension::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Capabilities.SimpleExtension) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string uri = 1; - if (!this->_internal_uri().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_uri().data(), static_cast(this->_internal_uri().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Capabilities.SimpleExtension.uri"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_uri(), target); - } - - // repeated string function_keys = 2; - for (int i = 0, n = this->_internal_function_keys_size(); i < n; i++) { - const auto& s = this->_internal_function_keys(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Capabilities.SimpleExtension.function_keys"); - target = stream->WriteString(2, s, target); - } - - // repeated string type_keys = 3; - for (int i = 0, n = this->_internal_type_keys_size(); i < n; i++) { - const auto& s = this->_internal_type_keys(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Capabilities.SimpleExtension.type_keys"); - target = stream->WriteString(3, s, target); - } - - // repeated string type_variation_keys = 4; - for (int i = 0, n = this->_internal_type_variation_keys_size(); i < n; i++) { - const auto& s = this->_internal_type_variation_keys(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Capabilities.SimpleExtension.type_variation_keys"); - target = stream->WriteString(4, s, target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Capabilities.SimpleExtension) - return target; -} - -size_t Capabilities_SimpleExtension::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Capabilities.SimpleExtension) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string function_keys = 2; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(function_keys_.size()); - for (int i = 0, n = function_keys_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - function_keys_.Get(i)); - } - - // repeated string type_keys = 3; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(type_keys_.size()); - for (int i = 0, n = type_keys_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - type_keys_.Get(i)); - } - - // repeated string type_variation_keys = 4; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(type_variation_keys_.size()); - for (int i = 0, n = type_variation_keys_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - type_variation_keys_.Get(i)); - } - - // string uri = 1; - if (!this->_internal_uri().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_uri()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Capabilities_SimpleExtension::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Capabilities_SimpleExtension::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Capabilities_SimpleExtension::GetClassData() const { return &_class_data_; } - -void Capabilities_SimpleExtension::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Capabilities_SimpleExtension::MergeFrom(const Capabilities_SimpleExtension& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Capabilities.SimpleExtension) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - function_keys_.MergeFrom(from.function_keys_); - type_keys_.MergeFrom(from.type_keys_); - type_variation_keys_.MergeFrom(from.type_variation_keys_); - if (!from._internal_uri().empty()) { - _internal_set_uri(from._internal_uri()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Capabilities_SimpleExtension::CopyFrom(const Capabilities_SimpleExtension& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Capabilities.SimpleExtension) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Capabilities_SimpleExtension::IsInitialized() const { - return true; -} - -void Capabilities_SimpleExtension::InternalSwap(Capabilities_SimpleExtension* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - function_keys_.InternalSwap(&other->function_keys_); - type_keys_.InternalSwap(&other->type_keys_); - type_variation_keys_.InternalSwap(&other->type_variation_keys_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &uri_, lhs_arena, - &other->uri_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Capabilities_SimpleExtension::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fcapabilities_2eproto_getter, &descriptor_table_substrait_2fcapabilities_2eproto_once, - file_level_metadata_substrait_2fcapabilities_2eproto[0]); -} - -// =================================================================== - -class Capabilities::_Internal { - public: -}; - -Capabilities::Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - substrait_versions_(arena), - advanced_extension_type_urls_(arena), - simple_extensions_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Capabilities) -} -Capabilities::Capabilities(const Capabilities& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - substrait_versions_(from.substrait_versions_), - advanced_extension_type_urls_(from.advanced_extension_type_urls_), - simple_extensions_(from.simple_extensions_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Capabilities) -} - -inline void Capabilities::SharedCtor() { -} - -Capabilities::~Capabilities() { - // @@protoc_insertion_point(destructor:substrait.Capabilities) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Capabilities::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Capabilities::ArenaDtor(void* object) { - Capabilities* _this = reinterpret_cast< Capabilities* >(object); - (void)_this; -} -void Capabilities::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Capabilities::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Capabilities::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Capabilities) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - substrait_versions_.Clear(); - advanced_extension_type_urls_.Clear(); - simple_extensions_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Capabilities::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string substrait_versions = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_substrait_versions(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.substrait_versions")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // repeated string advanced_extension_type_urls = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_advanced_extension_type_urls(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Capabilities.advanced_extension_type_urls")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_simple_extensions(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(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* Capabilities::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Capabilities) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string substrait_versions = 1; - for (int i = 0, n = this->_internal_substrait_versions_size(); i < n; i++) { - const auto& s = this->_internal_substrait_versions(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Capabilities.substrait_versions"); - target = stream->WriteString(1, s, target); - } - - // repeated string advanced_extension_type_urls = 2; - for (int i = 0, n = this->_internal_advanced_extension_type_urls_size(); i < n; i++) { - const auto& s = this->_internal_advanced_extension_type_urls(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Capabilities.advanced_extension_type_urls"); - target = stream->WriteString(2, s, target); - } - - // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; - for (unsigned int i = 0, - n = static_cast(this->_internal_simple_extensions_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, this->_internal_simple_extensions(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Capabilities) - return target; -} - -size_t Capabilities::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Capabilities) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string substrait_versions = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(substrait_versions_.size()); - for (int i = 0, n = substrait_versions_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - substrait_versions_.Get(i)); - } - - // repeated string advanced_extension_type_urls = 2; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(advanced_extension_type_urls_.size()); - for (int i = 0, n = advanced_extension_type_urls_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - advanced_extension_type_urls_.Get(i)); - } - - // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; - total_size += 1UL * this->_internal_simple_extensions_size(); - for (const auto& msg : this->simple_extensions_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Capabilities::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Capabilities::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Capabilities::GetClassData() const { return &_class_data_; } - -void Capabilities::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Capabilities::MergeFrom(const Capabilities& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Capabilities) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - substrait_versions_.MergeFrom(from.substrait_versions_); - advanced_extension_type_urls_.MergeFrom(from.advanced_extension_type_urls_); - simple_extensions_.MergeFrom(from.simple_extensions_); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Capabilities::CopyFrom(const Capabilities& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Capabilities) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Capabilities::IsInitialized() const { - return true; -} - -void Capabilities::InternalSwap(Capabilities* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - substrait_versions_.InternalSwap(&other->substrait_versions_); - advanced_extension_type_urls_.InternalSwap(&other->advanced_extension_type_urls_); - simple_extensions_.InternalSwap(&other->simple_extensions_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Capabilities::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fcapabilities_2eproto_getter, &descriptor_table_substrait_2fcapabilities_2eproto_once, - file_level_metadata_substrait_2fcapabilities_2eproto[1]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::substrait::Capabilities_SimpleExtension* Arena::CreateMaybeMessage< ::substrait::Capabilities_SimpleExtension >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Capabilities_SimpleExtension >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Capabilities* Arena::CreateMaybeMessage< ::substrait::Capabilities >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Capabilities >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/capabilities.pb.h b/cpp/src/generated/substrait/capabilities.pb.h deleted file mode 100644 index 1ac303703ff..00000000000 --- a/cpp/src/generated/substrait/capabilities.pb.h +++ /dev/null @@ -1,1002 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/capabilities.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fcapabilities_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fcapabilities_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3019000 -#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 3019003 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_substrait_2fcapabilities_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_substrait_2fcapabilities_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const uint32_t offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fcapabilities_2eproto; -namespace substrait { -class Capabilities; -struct CapabilitiesDefaultTypeInternal; -extern CapabilitiesDefaultTypeInternal _Capabilities_default_instance_; -class Capabilities_SimpleExtension; -struct Capabilities_SimpleExtensionDefaultTypeInternal; -extern Capabilities_SimpleExtensionDefaultTypeInternal _Capabilities_SimpleExtension_default_instance_; -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> ::substrait::Capabilities* Arena::CreateMaybeMessage<::substrait::Capabilities>(Arena*); -template<> ::substrait::Capabilities_SimpleExtension* Arena::CreateMaybeMessage<::substrait::Capabilities_SimpleExtension>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace substrait { - -// =================================================================== - -class Capabilities_SimpleExtension final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Capabilities.SimpleExtension) */ { - public: - inline Capabilities_SimpleExtension() : Capabilities_SimpleExtension(nullptr) {} - ~Capabilities_SimpleExtension() override; - explicit constexpr Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Capabilities_SimpleExtension(const Capabilities_SimpleExtension& from); - Capabilities_SimpleExtension(Capabilities_SimpleExtension&& from) noexcept - : Capabilities_SimpleExtension() { - *this = ::std::move(from); - } - - inline Capabilities_SimpleExtension& operator=(const Capabilities_SimpleExtension& from) { - CopyFrom(from); - return *this; - } - inline Capabilities_SimpleExtension& operator=(Capabilities_SimpleExtension&& 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 Capabilities_SimpleExtension& default_instance() { - return *internal_default_instance(); - } - static inline const Capabilities_SimpleExtension* internal_default_instance() { - return reinterpret_cast( - &_Capabilities_SimpleExtension_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(Capabilities_SimpleExtension& a, Capabilities_SimpleExtension& b) { - a.Swap(&b); - } - inline void Swap(Capabilities_SimpleExtension* 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(Capabilities_SimpleExtension* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Capabilities_SimpleExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Capabilities_SimpleExtension& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Capabilities_SimpleExtension& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Capabilities_SimpleExtension* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Capabilities.SimpleExtension"; - } - protected: - explicit Capabilities_SimpleExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kFunctionKeysFieldNumber = 2, - kTypeKeysFieldNumber = 3, - kTypeVariationKeysFieldNumber = 4, - kUriFieldNumber = 1, - }; - // repeated string function_keys = 2; - int function_keys_size() const; - private: - int _internal_function_keys_size() const; - public: - void clear_function_keys(); - const std::string& function_keys(int index) const; - std::string* mutable_function_keys(int index); - void set_function_keys(int index, const std::string& value); - void set_function_keys(int index, std::string&& value); - void set_function_keys(int index, const char* value); - void set_function_keys(int index, const char* value, size_t size); - std::string* add_function_keys(); - void add_function_keys(const std::string& value); - void add_function_keys(std::string&& value); - void add_function_keys(const char* value); - void add_function_keys(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& function_keys() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_function_keys(); - private: - const std::string& _internal_function_keys(int index) const; - std::string* _internal_add_function_keys(); - public: - - // repeated string type_keys = 3; - int type_keys_size() const; - private: - int _internal_type_keys_size() const; - public: - void clear_type_keys(); - const std::string& type_keys(int index) const; - std::string* mutable_type_keys(int index); - void set_type_keys(int index, const std::string& value); - void set_type_keys(int index, std::string&& value); - void set_type_keys(int index, const char* value); - void set_type_keys(int index, const char* value, size_t size); - std::string* add_type_keys(); - void add_type_keys(const std::string& value); - void add_type_keys(std::string&& value); - void add_type_keys(const char* value); - void add_type_keys(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& type_keys() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_type_keys(); - private: - const std::string& _internal_type_keys(int index) const; - std::string* _internal_add_type_keys(); - public: - - // repeated string type_variation_keys = 4; - int type_variation_keys_size() const; - private: - int _internal_type_variation_keys_size() const; - public: - void clear_type_variation_keys(); - const std::string& type_variation_keys(int index) const; - std::string* mutable_type_variation_keys(int index); - void set_type_variation_keys(int index, const std::string& value); - void set_type_variation_keys(int index, std::string&& value); - void set_type_variation_keys(int index, const char* value); - void set_type_variation_keys(int index, const char* value, size_t size); - std::string* add_type_variation_keys(); - void add_type_variation_keys(const std::string& value); - void add_type_variation_keys(std::string&& value); - void add_type_variation_keys(const char* value); - void add_type_variation_keys(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& type_variation_keys() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_type_variation_keys(); - private: - const std::string& _internal_type_variation_keys(int index) const; - std::string* _internal_add_type_variation_keys(); - public: - - // string uri = 1; - void clear_uri(); - const std::string& uri() const; - template - void set_uri(ArgT0&& arg0, ArgT... args); - std::string* mutable_uri(); - PROTOBUF_NODISCARD std::string* release_uri(); - void set_allocated_uri(std::string* uri); - private: - const std::string& _internal_uri() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value); - std::string* _internal_mutable_uri(); - public: - - // @@protoc_insertion_point(class_scope:substrait.Capabilities.SimpleExtension) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField function_keys_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField type_keys_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField type_variation_keys_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fcapabilities_2eproto; -}; -// ------------------------------------------------------------------- - -class Capabilities final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Capabilities) */ { - public: - inline Capabilities() : Capabilities(nullptr) {} - ~Capabilities() override; - explicit constexpr Capabilities(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Capabilities(const Capabilities& from); - Capabilities(Capabilities&& from) noexcept - : Capabilities() { - *this = ::std::move(from); - } - - inline Capabilities& operator=(const Capabilities& from) { - CopyFrom(from); - return *this; - } - inline Capabilities& operator=(Capabilities&& 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 Capabilities& default_instance() { - return *internal_default_instance(); - } - static inline const Capabilities* internal_default_instance() { - return reinterpret_cast( - &_Capabilities_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(Capabilities& a, Capabilities& b) { - a.Swap(&b); - } - inline void Swap(Capabilities* 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(Capabilities* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Capabilities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Capabilities& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Capabilities& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Capabilities* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Capabilities"; - } - protected: - explicit Capabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Capabilities_SimpleExtension SimpleExtension; - - // accessors ------------------------------------------------------- - - enum : int { - kSubstraitVersionsFieldNumber = 1, - kAdvancedExtensionTypeUrlsFieldNumber = 2, - kSimpleExtensionsFieldNumber = 3, - }; - // repeated string substrait_versions = 1; - int substrait_versions_size() const; - private: - int _internal_substrait_versions_size() const; - public: - void clear_substrait_versions(); - const std::string& substrait_versions(int index) const; - std::string* mutable_substrait_versions(int index); - void set_substrait_versions(int index, const std::string& value); - void set_substrait_versions(int index, std::string&& value); - void set_substrait_versions(int index, const char* value); - void set_substrait_versions(int index, const char* value, size_t size); - std::string* add_substrait_versions(); - void add_substrait_versions(const std::string& value); - void add_substrait_versions(std::string&& value); - void add_substrait_versions(const char* value); - void add_substrait_versions(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& substrait_versions() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_substrait_versions(); - private: - const std::string& _internal_substrait_versions(int index) const; - std::string* _internal_add_substrait_versions(); - public: - - // repeated string advanced_extension_type_urls = 2; - int advanced_extension_type_urls_size() const; - private: - int _internal_advanced_extension_type_urls_size() const; - public: - void clear_advanced_extension_type_urls(); - const std::string& advanced_extension_type_urls(int index) const; - std::string* mutable_advanced_extension_type_urls(int index); - void set_advanced_extension_type_urls(int index, const std::string& value); - void set_advanced_extension_type_urls(int index, std::string&& value); - void set_advanced_extension_type_urls(int index, const char* value); - void set_advanced_extension_type_urls(int index, const char* value, size_t size); - std::string* add_advanced_extension_type_urls(); - void add_advanced_extension_type_urls(const std::string& value); - void add_advanced_extension_type_urls(std::string&& value); - void add_advanced_extension_type_urls(const char* value); - void add_advanced_extension_type_urls(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& advanced_extension_type_urls() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_advanced_extension_type_urls(); - private: - const std::string& _internal_advanced_extension_type_urls(int index) const; - std::string* _internal_add_advanced_extension_type_urls(); - public: - - // repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; - int simple_extensions_size() const; - private: - int _internal_simple_extensions_size() const; - public: - void clear_simple_extensions(); - ::substrait::Capabilities_SimpleExtension* mutable_simple_extensions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >* - mutable_simple_extensions(); - private: - const ::substrait::Capabilities_SimpleExtension& _internal_simple_extensions(int index) const; - ::substrait::Capabilities_SimpleExtension* _internal_add_simple_extensions(); - public: - const ::substrait::Capabilities_SimpleExtension& simple_extensions(int index) const; - ::substrait::Capabilities_SimpleExtension* add_simple_extensions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >& - simple_extensions() const; - - // @@protoc_insertion_point(class_scope:substrait.Capabilities) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField substrait_versions_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField advanced_extension_type_urls_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension > simple_extensions_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fcapabilities_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// Capabilities_SimpleExtension - -// string uri = 1; -inline void Capabilities_SimpleExtension::clear_uri() { - uri_.ClearToEmpty(); -} -inline const std::string& Capabilities_SimpleExtension::uri() const { - // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.uri) - return _internal_uri(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Capabilities_SimpleExtension::set_uri(ArgT0&& arg0, ArgT... args) { - - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.uri) -} -inline std::string* Capabilities_SimpleExtension::mutable_uri() { - std::string* _s = _internal_mutable_uri(); - // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.uri) - return _s; -} -inline const std::string& Capabilities_SimpleExtension::_internal_uri() const { - return uri_.Get(); -} -inline void Capabilities_SimpleExtension::_internal_set_uri(const std::string& value) { - - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Capabilities_SimpleExtension::_internal_mutable_uri() { - - return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Capabilities_SimpleExtension::release_uri() { - // @@protoc_insertion_point(field_release:substrait.Capabilities.SimpleExtension.uri) - return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void Capabilities_SimpleExtension::set_allocated_uri(std::string* uri) { - if (uri != nullptr) { - - } else { - - } - uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (uri_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.Capabilities.SimpleExtension.uri) -} - -// repeated string function_keys = 2; -inline int Capabilities_SimpleExtension::_internal_function_keys_size() const { - return function_keys_.size(); -} -inline int Capabilities_SimpleExtension::function_keys_size() const { - return _internal_function_keys_size(); -} -inline void Capabilities_SimpleExtension::clear_function_keys() { - function_keys_.Clear(); -} -inline std::string* Capabilities_SimpleExtension::add_function_keys() { - std::string* _s = _internal_add_function_keys(); - // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.function_keys) - return _s; -} -inline const std::string& Capabilities_SimpleExtension::_internal_function_keys(int index) const { - return function_keys_.Get(index); -} -inline const std::string& Capabilities_SimpleExtension::function_keys(int index) const { - // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.function_keys) - return _internal_function_keys(index); -} -inline std::string* Capabilities_SimpleExtension::mutable_function_keys(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.function_keys) - return function_keys_.Mutable(index); -} -inline void Capabilities_SimpleExtension::set_function_keys(int index, const std::string& value) { - function_keys_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.function_keys) -} -inline void Capabilities_SimpleExtension::set_function_keys(int index, std::string&& value) { - function_keys_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.function_keys) -} -inline void Capabilities_SimpleExtension::set_function_keys(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - function_keys_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.Capabilities.SimpleExtension.function_keys) -} -inline void Capabilities_SimpleExtension::set_function_keys(int index, const char* value, size_t size) { - function_keys_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.SimpleExtension.function_keys) -} -inline std::string* Capabilities_SimpleExtension::_internal_add_function_keys() { - return function_keys_.Add(); -} -inline void Capabilities_SimpleExtension::add_function_keys(const std::string& value) { - function_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.function_keys) -} -inline void Capabilities_SimpleExtension::add_function_keys(std::string&& value) { - function_keys_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.function_keys) -} -inline void Capabilities_SimpleExtension::add_function_keys(const char* value) { - GOOGLE_DCHECK(value != nullptr); - function_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.Capabilities.SimpleExtension.function_keys) -} -inline void Capabilities_SimpleExtension::add_function_keys(const char* value, size_t size) { - function_keys_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.function_keys) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Capabilities_SimpleExtension::function_keys() const { - // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.function_keys) - return function_keys_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Capabilities_SimpleExtension::mutable_function_keys() { - // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.SimpleExtension.function_keys) - return &function_keys_; -} - -// repeated string type_keys = 3; -inline int Capabilities_SimpleExtension::_internal_type_keys_size() const { - return type_keys_.size(); -} -inline int Capabilities_SimpleExtension::type_keys_size() const { - return _internal_type_keys_size(); -} -inline void Capabilities_SimpleExtension::clear_type_keys() { - type_keys_.Clear(); -} -inline std::string* Capabilities_SimpleExtension::add_type_keys() { - std::string* _s = _internal_add_type_keys(); - // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.type_keys) - return _s; -} -inline const std::string& Capabilities_SimpleExtension::_internal_type_keys(int index) const { - return type_keys_.Get(index); -} -inline const std::string& Capabilities_SimpleExtension::type_keys(int index) const { - // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.type_keys) - return _internal_type_keys(index); -} -inline std::string* Capabilities_SimpleExtension::mutable_type_keys(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.type_keys) - return type_keys_.Mutable(index); -} -inline void Capabilities_SimpleExtension::set_type_keys(int index, const std::string& value) { - type_keys_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_keys) -} -inline void Capabilities_SimpleExtension::set_type_keys(int index, std::string&& value) { - type_keys_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_keys) -} -inline void Capabilities_SimpleExtension::set_type_keys(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - type_keys_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.Capabilities.SimpleExtension.type_keys) -} -inline void Capabilities_SimpleExtension::set_type_keys(int index, const char* value, size_t size) { - type_keys_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.SimpleExtension.type_keys) -} -inline std::string* Capabilities_SimpleExtension::_internal_add_type_keys() { - return type_keys_.Add(); -} -inline void Capabilities_SimpleExtension::add_type_keys(const std::string& value) { - type_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_keys) -} -inline void Capabilities_SimpleExtension::add_type_keys(std::string&& value) { - type_keys_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_keys) -} -inline void Capabilities_SimpleExtension::add_type_keys(const char* value) { - GOOGLE_DCHECK(value != nullptr); - type_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.Capabilities.SimpleExtension.type_keys) -} -inline void Capabilities_SimpleExtension::add_type_keys(const char* value, size_t size) { - type_keys_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.type_keys) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Capabilities_SimpleExtension::type_keys() const { - // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.type_keys) - return type_keys_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Capabilities_SimpleExtension::mutable_type_keys() { - // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.SimpleExtension.type_keys) - return &type_keys_; -} - -// repeated string type_variation_keys = 4; -inline int Capabilities_SimpleExtension::_internal_type_variation_keys_size() const { - return type_variation_keys_.size(); -} -inline int Capabilities_SimpleExtension::type_variation_keys_size() const { - return _internal_type_variation_keys_size(); -} -inline void Capabilities_SimpleExtension::clear_type_variation_keys() { - type_variation_keys_.Clear(); -} -inline std::string* Capabilities_SimpleExtension::add_type_variation_keys() { - std::string* _s = _internal_add_type_variation_keys(); - // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.SimpleExtension.type_variation_keys) - return _s; -} -inline const std::string& Capabilities_SimpleExtension::_internal_type_variation_keys(int index) const { - return type_variation_keys_.Get(index); -} -inline const std::string& Capabilities_SimpleExtension::type_variation_keys(int index) const { - // @@protoc_insertion_point(field_get:substrait.Capabilities.SimpleExtension.type_variation_keys) - return _internal_type_variation_keys(index); -} -inline std::string* Capabilities_SimpleExtension::mutable_type_variation_keys(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Capabilities.SimpleExtension.type_variation_keys) - return type_variation_keys_.Mutable(index); -} -inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const std::string& value) { - type_variation_keys_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_variation_keys) -} -inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, std::string&& value) { - type_variation_keys_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.Capabilities.SimpleExtension.type_variation_keys) -} -inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - type_variation_keys_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.Capabilities.SimpleExtension.type_variation_keys) -} -inline void Capabilities_SimpleExtension::set_type_variation_keys(int index, const char* value, size_t size) { - type_variation_keys_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.SimpleExtension.type_variation_keys) -} -inline std::string* Capabilities_SimpleExtension::_internal_add_type_variation_keys() { - return type_variation_keys_.Add(); -} -inline void Capabilities_SimpleExtension::add_type_variation_keys(const std::string& value) { - type_variation_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_variation_keys) -} -inline void Capabilities_SimpleExtension::add_type_variation_keys(std::string&& value) { - type_variation_keys_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.Capabilities.SimpleExtension.type_variation_keys) -} -inline void Capabilities_SimpleExtension::add_type_variation_keys(const char* value) { - GOOGLE_DCHECK(value != nullptr); - type_variation_keys_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.Capabilities.SimpleExtension.type_variation_keys) -} -inline void Capabilities_SimpleExtension::add_type_variation_keys(const char* value, size_t size) { - type_variation_keys_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.SimpleExtension.type_variation_keys) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Capabilities_SimpleExtension::type_variation_keys() const { - // @@protoc_insertion_point(field_list:substrait.Capabilities.SimpleExtension.type_variation_keys) - return type_variation_keys_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Capabilities_SimpleExtension::mutable_type_variation_keys() { - // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.SimpleExtension.type_variation_keys) - return &type_variation_keys_; -} - -// ------------------------------------------------------------------- - -// Capabilities - -// repeated string substrait_versions = 1; -inline int Capabilities::_internal_substrait_versions_size() const { - return substrait_versions_.size(); -} -inline int Capabilities::substrait_versions_size() const { - return _internal_substrait_versions_size(); -} -inline void Capabilities::clear_substrait_versions() { - substrait_versions_.Clear(); -} -inline std::string* Capabilities::add_substrait_versions() { - std::string* _s = _internal_add_substrait_versions(); - // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.substrait_versions) - return _s; -} -inline const std::string& Capabilities::_internal_substrait_versions(int index) const { - return substrait_versions_.Get(index); -} -inline const std::string& Capabilities::substrait_versions(int index) const { - // @@protoc_insertion_point(field_get:substrait.Capabilities.substrait_versions) - return _internal_substrait_versions(index); -} -inline std::string* Capabilities::mutable_substrait_versions(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Capabilities.substrait_versions) - return substrait_versions_.Mutable(index); -} -inline void Capabilities::set_substrait_versions(int index, const std::string& value) { - substrait_versions_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.Capabilities.substrait_versions) -} -inline void Capabilities::set_substrait_versions(int index, std::string&& value) { - substrait_versions_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.Capabilities.substrait_versions) -} -inline void Capabilities::set_substrait_versions(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - substrait_versions_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.Capabilities.substrait_versions) -} -inline void Capabilities::set_substrait_versions(int index, const char* value, size_t size) { - substrait_versions_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.substrait_versions) -} -inline std::string* Capabilities::_internal_add_substrait_versions() { - return substrait_versions_.Add(); -} -inline void Capabilities::add_substrait_versions(const std::string& value) { - substrait_versions_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.Capabilities.substrait_versions) -} -inline void Capabilities::add_substrait_versions(std::string&& value) { - substrait_versions_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.Capabilities.substrait_versions) -} -inline void Capabilities::add_substrait_versions(const char* value) { - GOOGLE_DCHECK(value != nullptr); - substrait_versions_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.Capabilities.substrait_versions) -} -inline void Capabilities::add_substrait_versions(const char* value, size_t size) { - substrait_versions_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.substrait_versions) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Capabilities::substrait_versions() const { - // @@protoc_insertion_point(field_list:substrait.Capabilities.substrait_versions) - return substrait_versions_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Capabilities::mutable_substrait_versions() { - // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.substrait_versions) - return &substrait_versions_; -} - -// repeated string advanced_extension_type_urls = 2; -inline int Capabilities::_internal_advanced_extension_type_urls_size() const { - return advanced_extension_type_urls_.size(); -} -inline int Capabilities::advanced_extension_type_urls_size() const { - return _internal_advanced_extension_type_urls_size(); -} -inline void Capabilities::clear_advanced_extension_type_urls() { - advanced_extension_type_urls_.Clear(); -} -inline std::string* Capabilities::add_advanced_extension_type_urls() { - std::string* _s = _internal_add_advanced_extension_type_urls(); - // @@protoc_insertion_point(field_add_mutable:substrait.Capabilities.advanced_extension_type_urls) - return _s; -} -inline const std::string& Capabilities::_internal_advanced_extension_type_urls(int index) const { - return advanced_extension_type_urls_.Get(index); -} -inline const std::string& Capabilities::advanced_extension_type_urls(int index) const { - // @@protoc_insertion_point(field_get:substrait.Capabilities.advanced_extension_type_urls) - return _internal_advanced_extension_type_urls(index); -} -inline std::string* Capabilities::mutable_advanced_extension_type_urls(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Capabilities.advanced_extension_type_urls) - return advanced_extension_type_urls_.Mutable(index); -} -inline void Capabilities::set_advanced_extension_type_urls(int index, const std::string& value) { - advanced_extension_type_urls_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.Capabilities.advanced_extension_type_urls) -} -inline void Capabilities::set_advanced_extension_type_urls(int index, std::string&& value) { - advanced_extension_type_urls_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.Capabilities.advanced_extension_type_urls) -} -inline void Capabilities::set_advanced_extension_type_urls(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - advanced_extension_type_urls_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.Capabilities.advanced_extension_type_urls) -} -inline void Capabilities::set_advanced_extension_type_urls(int index, const char* value, size_t size) { - advanced_extension_type_urls_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.Capabilities.advanced_extension_type_urls) -} -inline std::string* Capabilities::_internal_add_advanced_extension_type_urls() { - return advanced_extension_type_urls_.Add(); -} -inline void Capabilities::add_advanced_extension_type_urls(const std::string& value) { - advanced_extension_type_urls_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.Capabilities.advanced_extension_type_urls) -} -inline void Capabilities::add_advanced_extension_type_urls(std::string&& value) { - advanced_extension_type_urls_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.Capabilities.advanced_extension_type_urls) -} -inline void Capabilities::add_advanced_extension_type_urls(const char* value) { - GOOGLE_DCHECK(value != nullptr); - advanced_extension_type_urls_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.Capabilities.advanced_extension_type_urls) -} -inline void Capabilities::add_advanced_extension_type_urls(const char* value, size_t size) { - advanced_extension_type_urls_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.Capabilities.advanced_extension_type_urls) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Capabilities::advanced_extension_type_urls() const { - // @@protoc_insertion_point(field_list:substrait.Capabilities.advanced_extension_type_urls) - return advanced_extension_type_urls_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Capabilities::mutable_advanced_extension_type_urls() { - // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.advanced_extension_type_urls) - return &advanced_extension_type_urls_; -} - -// repeated .substrait.Capabilities.SimpleExtension simple_extensions = 3; -inline int Capabilities::_internal_simple_extensions_size() const { - return simple_extensions_.size(); -} -inline int Capabilities::simple_extensions_size() const { - return _internal_simple_extensions_size(); -} -inline void Capabilities::clear_simple_extensions() { - simple_extensions_.Clear(); -} -inline ::substrait::Capabilities_SimpleExtension* Capabilities::mutable_simple_extensions(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Capabilities.simple_extensions) - return simple_extensions_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >* -Capabilities::mutable_simple_extensions() { - // @@protoc_insertion_point(field_mutable_list:substrait.Capabilities.simple_extensions) - return &simple_extensions_; -} -inline const ::substrait::Capabilities_SimpleExtension& Capabilities::_internal_simple_extensions(int index) const { - return simple_extensions_.Get(index); -} -inline const ::substrait::Capabilities_SimpleExtension& Capabilities::simple_extensions(int index) const { - // @@protoc_insertion_point(field_get:substrait.Capabilities.simple_extensions) - return _internal_simple_extensions(index); -} -inline ::substrait::Capabilities_SimpleExtension* Capabilities::_internal_add_simple_extensions() { - return simple_extensions_.Add(); -} -inline ::substrait::Capabilities_SimpleExtension* Capabilities::add_simple_extensions() { - ::substrait::Capabilities_SimpleExtension* _add = _internal_add_simple_extensions(); - // @@protoc_insertion_point(field_add:substrait.Capabilities.simple_extensions) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Capabilities_SimpleExtension >& -Capabilities::simple_extensions() const { - // @@protoc_insertion_point(field_list:substrait.Capabilities.simple_extensions) - return simple_extensions_; -} - -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace substrait - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fcapabilities_2eproto diff --git a/cpp/src/generated/substrait/expression.pb.cc b/cpp/src/generated/substrait/expression.pb.cc deleted file mode 100644 index c58095ef801..00000000000 --- a/cpp/src/generated/substrait/expression.pb.cc +++ /dev/null @@ -1,14785 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/expression.proto - -#include "substrait/expression.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace substrait { -constexpr Expression_Enum_Empty::Expression_Enum_Empty( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} -struct Expression_Enum_EmptyDefaultTypeInternal { - constexpr Expression_Enum_EmptyDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_Enum_EmptyDefaultTypeInternal() {} - union { - Expression_Enum_Empty _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Enum_EmptyDefaultTypeInternal _Expression_Enum_Empty_default_instance_; -constexpr Expression_Enum::Expression_Enum( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct Expression_EnumDefaultTypeInternal { - constexpr Expression_EnumDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_EnumDefaultTypeInternal() {} - union { - Expression_Enum _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EnumDefaultTypeInternal _Expression_Enum_default_instance_; -constexpr Expression_Literal_VarChar::Expression_Literal_VarChar( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , length_(0u){} -struct Expression_Literal_VarCharDefaultTypeInternal { - constexpr Expression_Literal_VarCharDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_Literal_VarCharDefaultTypeInternal() {} - union { - Expression_Literal_VarChar _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_VarCharDefaultTypeInternal _Expression_Literal_VarChar_default_instance_; -constexpr Expression_Literal_Decimal::Expression_Literal_Decimal( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : value_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , precision_(0) - , scale_(0){} -struct Expression_Literal_DecimalDefaultTypeInternal { - constexpr Expression_Literal_DecimalDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_Literal_DecimalDefaultTypeInternal() {} - union { - Expression_Literal_Decimal _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_DecimalDefaultTypeInternal _Expression_Literal_Decimal_default_instance_; -constexpr Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : key_(nullptr) - , value_(nullptr){} -struct Expression_Literal_Map_KeyValueDefaultTypeInternal { - constexpr Expression_Literal_Map_KeyValueDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_Literal_Map_KeyValueDefaultTypeInternal() {} - union { - Expression_Literal_Map_KeyValue _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_Map_KeyValueDefaultTypeInternal _Expression_Literal_Map_KeyValue_default_instance_; -constexpr Expression_Literal_Map::Expression_Literal_Map( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : key_values_(){} -struct Expression_Literal_MapDefaultTypeInternal { - constexpr Expression_Literal_MapDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_Literal_MapDefaultTypeInternal() {} - union { - Expression_Literal_Map _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_MapDefaultTypeInternal _Expression_Literal_Map_default_instance_; -constexpr Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : years_(0) - , months_(0){} -struct Expression_Literal_IntervalYearToMonthDefaultTypeInternal { - constexpr Expression_Literal_IntervalYearToMonthDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_Literal_IntervalYearToMonthDefaultTypeInternal() {} - union { - Expression_Literal_IntervalYearToMonth _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_IntervalYearToMonthDefaultTypeInternal _Expression_Literal_IntervalYearToMonth_default_instance_; -constexpr Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : days_(0) - , seconds_(0){} -struct Expression_Literal_IntervalDayToSecondDefaultTypeInternal { - constexpr Expression_Literal_IntervalDayToSecondDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_Literal_IntervalDayToSecondDefaultTypeInternal() {} - union { - Expression_Literal_IntervalDayToSecond _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_IntervalDayToSecondDefaultTypeInternal _Expression_Literal_IntervalDayToSecond_default_instance_; -constexpr Expression_Literal_Struct::Expression_Literal_Struct( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : fields_(){} -struct Expression_Literal_StructDefaultTypeInternal { - constexpr Expression_Literal_StructDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_Literal_StructDefaultTypeInternal() {} - union { - Expression_Literal_Struct _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_StructDefaultTypeInternal _Expression_Literal_Struct_default_instance_; -constexpr Expression_Literal_List::Expression_Literal_List( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : values_(){} -struct Expression_Literal_ListDefaultTypeInternal { - constexpr Expression_Literal_ListDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_Literal_ListDefaultTypeInternal() {} - union { - Expression_Literal_List _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_Literal_ListDefaultTypeInternal _Expression_Literal_List_default_instance_; -constexpr Expression_Literal::Expression_Literal( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : nullable_(false) - , _oneof_case_{}{} -struct Expression_LiteralDefaultTypeInternal { - constexpr Expression_LiteralDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_LiteralDefaultTypeInternal() {} - union { - Expression_Literal _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_LiteralDefaultTypeInternal _Expression_Literal_default_instance_; -constexpr Expression_ScalarFunction::Expression_ScalarFunction( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : args_() - , output_type_(nullptr) - , function_reference_(0u){} -struct Expression_ScalarFunctionDefaultTypeInternal { - constexpr Expression_ScalarFunctionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_ScalarFunctionDefaultTypeInternal() {} - union { - Expression_ScalarFunction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ScalarFunctionDefaultTypeInternal _Expression_ScalarFunction_default_instance_; -constexpr Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : offset_(int64_t{0}){} -struct Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal { - constexpr Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal() {} - union { - Expression_WindowFunction_Bound_Preceding _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal _Expression_WindowFunction_Bound_Preceding_default_instance_; -constexpr Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : offset_(int64_t{0}){} -struct Expression_WindowFunction_Bound_FollowingDefaultTypeInternal { - constexpr Expression_WindowFunction_Bound_FollowingDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_WindowFunction_Bound_FollowingDefaultTypeInternal() {} - union { - Expression_WindowFunction_Bound_Following _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_FollowingDefaultTypeInternal _Expression_WindowFunction_Bound_Following_default_instance_; -constexpr Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} -struct Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal { - constexpr Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal() {} - union { - Expression_WindowFunction_Bound_CurrentRow _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal _Expression_WindowFunction_Bound_CurrentRow_default_instance_; -constexpr Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} -struct Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal { - constexpr Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal() {} - union { - Expression_WindowFunction_Bound_Unbounded _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal _Expression_WindowFunction_Bound_Unbounded_default_instance_; -constexpr Expression_WindowFunction_Bound::Expression_WindowFunction_Bound( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct Expression_WindowFunction_BoundDefaultTypeInternal { - constexpr Expression_WindowFunction_BoundDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_WindowFunction_BoundDefaultTypeInternal() {} - union { - Expression_WindowFunction_Bound _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunction_BoundDefaultTypeInternal _Expression_WindowFunction_Bound_default_instance_; -constexpr Expression_WindowFunction::Expression_WindowFunction( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : partitions_() - , sorts_() - , args_() - , upper_bound_(nullptr) - , lower_bound_(nullptr) - , output_type_(nullptr) - , function_reference_(0u) - , phase_(0) -{} -struct Expression_WindowFunctionDefaultTypeInternal { - constexpr Expression_WindowFunctionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_WindowFunctionDefaultTypeInternal() {} - union { - Expression_WindowFunction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_WindowFunctionDefaultTypeInternal _Expression_WindowFunction_default_instance_; -constexpr Expression_IfThen_IfClause::Expression_IfThen_IfClause( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : if__(nullptr) - , then_(nullptr){} -struct Expression_IfThen_IfClauseDefaultTypeInternal { - constexpr Expression_IfThen_IfClauseDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_IfThen_IfClauseDefaultTypeInternal() {} - union { - Expression_IfThen_IfClause _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_IfThen_IfClauseDefaultTypeInternal _Expression_IfThen_IfClause_default_instance_; -constexpr Expression_IfThen::Expression_IfThen( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : ifs_() - , else__(nullptr){} -struct Expression_IfThenDefaultTypeInternal { - constexpr Expression_IfThenDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_IfThenDefaultTypeInternal() {} - union { - Expression_IfThen _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_IfThenDefaultTypeInternal _Expression_IfThen_default_instance_; -constexpr Expression_Cast::Expression_Cast( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_(nullptr) - , input_(nullptr){} -struct Expression_CastDefaultTypeInternal { - constexpr Expression_CastDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_CastDefaultTypeInternal() {} - union { - Expression_Cast _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_CastDefaultTypeInternal _Expression_Cast_default_instance_; -constexpr Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : if__(nullptr) - , then_(nullptr){} -struct Expression_SwitchExpression_IfValueDefaultTypeInternal { - constexpr Expression_SwitchExpression_IfValueDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_SwitchExpression_IfValueDefaultTypeInternal() {} - union { - Expression_SwitchExpression_IfValue _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SwitchExpression_IfValueDefaultTypeInternal _Expression_SwitchExpression_IfValue_default_instance_; -constexpr Expression_SwitchExpression::Expression_SwitchExpression( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : ifs_() - , else__(nullptr){} -struct Expression_SwitchExpressionDefaultTypeInternal { - constexpr Expression_SwitchExpressionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_SwitchExpressionDefaultTypeInternal() {} - union { - Expression_SwitchExpression _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SwitchExpressionDefaultTypeInternal _Expression_SwitchExpression_default_instance_; -constexpr Expression_SingularOrList::Expression_SingularOrList( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : options_() - , value_(nullptr){} -struct Expression_SingularOrListDefaultTypeInternal { - constexpr Expression_SingularOrListDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_SingularOrListDefaultTypeInternal() {} - union { - Expression_SingularOrList _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_SingularOrListDefaultTypeInternal _Expression_SingularOrList_default_instance_; -constexpr Expression_MultiOrList_Record::Expression_MultiOrList_Record( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : fields_(){} -struct Expression_MultiOrList_RecordDefaultTypeInternal { - constexpr Expression_MultiOrList_RecordDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MultiOrList_RecordDefaultTypeInternal() {} - union { - Expression_MultiOrList_Record _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MultiOrList_RecordDefaultTypeInternal _Expression_MultiOrList_Record_default_instance_; -constexpr Expression_MultiOrList::Expression_MultiOrList( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : value_() - , options_(){} -struct Expression_MultiOrListDefaultTypeInternal { - constexpr Expression_MultiOrListDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MultiOrListDefaultTypeInternal() {} - union { - Expression_MultiOrList _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MultiOrListDefaultTypeInternal _Expression_MultiOrList_default_instance_; -constexpr Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : prerequisite_() - , function_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal { - constexpr Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal() {} - union { - Expression_EmbeddedFunction_PythonPickleFunction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal _Expression_EmbeddedFunction_PythonPickleFunction_default_instance_; -constexpr Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : prerequisite_() - , script_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal { - constexpr Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal() {} - union { - Expression_EmbeddedFunction_WebAssemblyFunction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal _Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_; -constexpr Expression_EmbeddedFunction::Expression_EmbeddedFunction( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : arguments_() - , output_type_(nullptr) - , _oneof_case_{}{} -struct Expression_EmbeddedFunctionDefaultTypeInternal { - constexpr Expression_EmbeddedFunctionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_EmbeddedFunctionDefaultTypeInternal() {} - union { - Expression_EmbeddedFunction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_EmbeddedFunctionDefaultTypeInternal _Expression_EmbeddedFunction_default_instance_; -constexpr Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : map_key_(nullptr) - , child_(nullptr){} -struct Expression_ReferenceSegment_MapKeyDefaultTypeInternal { - constexpr Expression_ReferenceSegment_MapKeyDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_ReferenceSegment_MapKeyDefaultTypeInternal() {} - union { - Expression_ReferenceSegment_MapKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_MapKeyDefaultTypeInternal _Expression_ReferenceSegment_MapKey_default_instance_; -constexpr Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : child_(nullptr) - , field_(0){} -struct Expression_ReferenceSegment_StructFieldDefaultTypeInternal { - constexpr Expression_ReferenceSegment_StructFieldDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_ReferenceSegment_StructFieldDefaultTypeInternal() {} - union { - Expression_ReferenceSegment_StructField _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_StructFieldDefaultTypeInternal _Expression_ReferenceSegment_StructField_default_instance_; -constexpr Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : child_(nullptr) - , offset_(0){} -struct Expression_ReferenceSegment_ListElementDefaultTypeInternal { - constexpr Expression_ReferenceSegment_ListElementDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_ReferenceSegment_ListElementDefaultTypeInternal() {} - union { - Expression_ReferenceSegment_ListElement _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegment_ListElementDefaultTypeInternal _Expression_ReferenceSegment_ListElement_default_instance_; -constexpr Expression_ReferenceSegment::Expression_ReferenceSegment( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct Expression_ReferenceSegmentDefaultTypeInternal { - constexpr Expression_ReferenceSegmentDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_ReferenceSegmentDefaultTypeInternal() {} - union { - Expression_ReferenceSegment _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_ReferenceSegmentDefaultTypeInternal _Expression_ReferenceSegment_default_instance_; -constexpr Expression_MaskExpression_Select::Expression_MaskExpression_Select( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct Expression_MaskExpression_SelectDefaultTypeInternal { - constexpr Expression_MaskExpression_SelectDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpression_SelectDefaultTypeInternal() {} - union { - Expression_MaskExpression_Select _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_SelectDefaultTypeInternal _Expression_MaskExpression_Select_default_instance_; -constexpr Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : struct_items_(){} -struct Expression_MaskExpression_StructSelectDefaultTypeInternal { - constexpr Expression_MaskExpression_StructSelectDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpression_StructSelectDefaultTypeInternal() {} - union { - Expression_MaskExpression_StructSelect _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_StructSelectDefaultTypeInternal _Expression_MaskExpression_StructSelect_default_instance_; -constexpr Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : child_(nullptr) - , field_(0){} -struct Expression_MaskExpression_StructItemDefaultTypeInternal { - constexpr Expression_MaskExpression_StructItemDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpression_StructItemDefaultTypeInternal() {} - union { - Expression_MaskExpression_StructItem _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_StructItemDefaultTypeInternal _Expression_MaskExpression_StructItem_default_instance_; -constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : field_(0){} -struct Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal { - constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal() {} - union { - Expression_MaskExpression_ListSelect_ListSelectItem_ListElement _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_; -constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : start_(0) - , end_(0){} -struct Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal { - constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal() {} - union { - Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_; -constexpr Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal { - constexpr Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal() {} - union { - Expression_MaskExpression_ListSelect_ListSelectItem _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_; -constexpr Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : selection_() - , child_(nullptr){} -struct Expression_MaskExpression_ListSelectDefaultTypeInternal { - constexpr Expression_MaskExpression_ListSelectDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpression_ListSelectDefaultTypeInternal() {} - union { - Expression_MaskExpression_ListSelect _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_ListSelectDefaultTypeInternal _Expression_MaskExpression_ListSelect_default_instance_; -constexpr Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : map_key_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal { - constexpr Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal() {} - union { - Expression_MaskExpression_MapSelect_MapKey _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKey_default_instance_; -constexpr Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : map_key_expression_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal { - constexpr Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal() {} - union { - Expression_MaskExpression_MapSelect_MapKeyExpression _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_; -constexpr Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : child_(nullptr) - , _oneof_case_{}{} -struct Expression_MaskExpression_MapSelectDefaultTypeInternal { - constexpr Expression_MaskExpression_MapSelectDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpression_MapSelectDefaultTypeInternal() {} - union { - Expression_MaskExpression_MapSelect _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpression_MapSelectDefaultTypeInternal _Expression_MaskExpression_MapSelect_default_instance_; -constexpr Expression_MaskExpression::Expression_MaskExpression( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : select_(nullptr) - , maintain_singular_struct_(false){} -struct Expression_MaskExpressionDefaultTypeInternal { - constexpr Expression_MaskExpressionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_MaskExpressionDefaultTypeInternal() {} - union { - Expression_MaskExpression _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_MaskExpressionDefaultTypeInternal _Expression_MaskExpression_default_instance_; -constexpr Expression_FieldReference_RootReference::Expression_FieldReference_RootReference( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} -struct Expression_FieldReference_RootReferenceDefaultTypeInternal { - constexpr Expression_FieldReference_RootReferenceDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_FieldReference_RootReferenceDefaultTypeInternal() {} - union { - Expression_FieldReference_RootReference _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_FieldReference_RootReferenceDefaultTypeInternal _Expression_FieldReference_RootReference_default_instance_; -constexpr Expression_FieldReference::Expression_FieldReference( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct Expression_FieldReferenceDefaultTypeInternal { - constexpr Expression_FieldReferenceDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Expression_FieldReferenceDefaultTypeInternal() {} - union { - Expression_FieldReference _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Expression_FieldReferenceDefaultTypeInternal _Expression_FieldReference_default_instance_; -constexpr Expression::Expression( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct ExpressionDefaultTypeInternal { - constexpr ExpressionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ExpressionDefaultTypeInternal() {} - union { - Expression _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExpressionDefaultTypeInternal _Expression_default_instance_; -constexpr SortField::SortField( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : expr_(nullptr) - , _oneof_case_{}{} -struct SortFieldDefaultTypeInternal { - constexpr SortFieldDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SortFieldDefaultTypeInternal() {} - union { - SortField _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SortFieldDefaultTypeInternal _SortField_default_instance_; -constexpr AggregateFunction::AggregateFunction( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : args_() - , sorts_() - , output_type_(nullptr) - , function_reference_(0u) - , phase_(0) -{} -struct AggregateFunctionDefaultTypeInternal { - constexpr AggregateFunctionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~AggregateFunctionDefaultTypeInternal() {} - union { - AggregateFunction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateFunctionDefaultTypeInternal _AggregateFunction_default_instance_; -} // namespace substrait -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fexpression_2eproto[49]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2fexpression_2eproto[2]; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fexpression_2eproto = nullptr; - -const uint32_t TableStruct_substrait_2fexpression_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum_Empty, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Enum, enum_kind_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, value_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_VarChar, length_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, value_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, precision_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Decimal, scale_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, key_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map_KeyValue, value_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Map, key_values_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, years_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalYearToMonth, months_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, days_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_IntervalDayToSecond, seconds_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Struct, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_Struct, fields_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_List, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal_List, values_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, nullable_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Literal, literal_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, function_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, args_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ScalarFunction, output_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Preceding, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Preceding, offset_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Following, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Following, offset_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_CurrentRow, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound_Unbounded, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction_Bound, kind_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, function_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, partitions_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, sorts_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, upper_bound_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, lower_bound_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, phase_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, output_type_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_WindowFunction, args_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, if__), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen_IfClause, then_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, ifs_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_IfThen, else__), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, type_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_Cast, input_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, if__), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression_IfValue, then_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, ifs_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_SwitchExpression, else__), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, value_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_SingularOrList, options_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList_Record, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList_Record, fields_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, value_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MultiOrList, options_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, function_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_PythonPickleFunction, prerequisite_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, script_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction, prerequisite_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, arguments_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, output_type_), - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Expression_EmbeddedFunction, kind_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, map_key_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_MapKey, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, field_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_StructField, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, offset_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment_ListElement, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Expression_ReferenceSegment, reference_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_Select, type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructSelect, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructSelect, struct_items_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, field_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_StructItem, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement, field_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, start_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem, type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, selection_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_ListSelect, child_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKey, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKey, map_key_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression, map_key_expression_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, child_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression_MapSelect, select_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, select_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_MaskExpression, maintain_singular_struct_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference_RootReference, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, reference_type_), - PROTOBUF_FIELD_OFFSET(::substrait::Expression_FieldReference, root_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Expression, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Expression, rex_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::SortField, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::SortField, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::SortField, expr_), - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::SortField, sort_kind_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, function_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, args_), - PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, sorts_), - PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, phase_), - PROTOBUF_FIELD_OFFSET(::substrait::AggregateFunction, output_type_), -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, -1, sizeof(::substrait::Expression_Enum_Empty)}, - { 6, -1, -1, sizeof(::substrait::Expression_Enum)}, - { 15, -1, -1, sizeof(::substrait::Expression_Literal_VarChar)}, - { 23, -1, -1, sizeof(::substrait::Expression_Literal_Decimal)}, - { 32, -1, -1, sizeof(::substrait::Expression_Literal_Map_KeyValue)}, - { 40, -1, -1, sizeof(::substrait::Expression_Literal_Map)}, - { 47, -1, -1, sizeof(::substrait::Expression_Literal_IntervalYearToMonth)}, - { 55, -1, -1, sizeof(::substrait::Expression_Literal_IntervalDayToSecond)}, - { 63, -1, -1, sizeof(::substrait::Expression_Literal_Struct)}, - { 70, -1, -1, sizeof(::substrait::Expression_Literal_List)}, - { 77, -1, -1, sizeof(::substrait::Expression_Literal)}, - { 111, -1, -1, sizeof(::substrait::Expression_ScalarFunction)}, - { 120, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Preceding)}, - { 127, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Following)}, - { 134, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_CurrentRow)}, - { 140, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound_Unbounded)}, - { 146, -1, -1, sizeof(::substrait::Expression_WindowFunction_Bound)}, - { 157, -1, -1, sizeof(::substrait::Expression_WindowFunction)}, - { 171, -1, -1, sizeof(::substrait::Expression_IfThen_IfClause)}, - { 179, -1, -1, sizeof(::substrait::Expression_IfThen)}, - { 187, -1, -1, sizeof(::substrait::Expression_Cast)}, - { 195, -1, -1, sizeof(::substrait::Expression_SwitchExpression_IfValue)}, - { 203, -1, -1, sizeof(::substrait::Expression_SwitchExpression)}, - { 211, -1, -1, sizeof(::substrait::Expression_SingularOrList)}, - { 219, -1, -1, sizeof(::substrait::Expression_MultiOrList_Record)}, - { 226, -1, -1, sizeof(::substrait::Expression_MultiOrList)}, - { 234, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction_PythonPickleFunction)}, - { 242, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction)}, - { 250, -1, -1, sizeof(::substrait::Expression_EmbeddedFunction)}, - { 261, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_MapKey)}, - { 269, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_StructField)}, - { 277, -1, -1, sizeof(::substrait::Expression_ReferenceSegment_ListElement)}, - { 285, -1, -1, sizeof(::substrait::Expression_ReferenceSegment)}, - { 295, -1, -1, sizeof(::substrait::Expression_MaskExpression_Select)}, - { 305, -1, -1, sizeof(::substrait::Expression_MaskExpression_StructSelect)}, - { 312, -1, -1, sizeof(::substrait::Expression_MaskExpression_StructItem)}, - { 320, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement)}, - { 327, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice)}, - { 335, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem)}, - { 344, -1, -1, sizeof(::substrait::Expression_MaskExpression_ListSelect)}, - { 352, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKey)}, - { 359, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression)}, - { 366, -1, -1, sizeof(::substrait::Expression_MaskExpression_MapSelect)}, - { 376, -1, -1, sizeof(::substrait::Expression_MaskExpression)}, - { 384, -1, -1, sizeof(::substrait::Expression_FieldReference_RootReference)}, - { 390, -1, -1, sizeof(::substrait::Expression_FieldReference)}, - { 402, -1, -1, sizeof(::substrait::Expression)}, - { 419, -1, -1, sizeof(::substrait::SortField)}, - { 429, -1, -1, sizeof(::substrait::AggregateFunction)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::substrait::_Expression_Enum_Empty_default_instance_), - reinterpret_cast(&::substrait::_Expression_Enum_default_instance_), - reinterpret_cast(&::substrait::_Expression_Literal_VarChar_default_instance_), - reinterpret_cast(&::substrait::_Expression_Literal_Decimal_default_instance_), - reinterpret_cast(&::substrait::_Expression_Literal_Map_KeyValue_default_instance_), - reinterpret_cast(&::substrait::_Expression_Literal_Map_default_instance_), - reinterpret_cast(&::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_), - reinterpret_cast(&::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_), - reinterpret_cast(&::substrait::_Expression_Literal_Struct_default_instance_), - reinterpret_cast(&::substrait::_Expression_Literal_List_default_instance_), - reinterpret_cast(&::substrait::_Expression_Literal_default_instance_), - reinterpret_cast(&::substrait::_Expression_ScalarFunction_default_instance_), - reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_), - reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_Following_default_instance_), - reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_), - reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_), - reinterpret_cast(&::substrait::_Expression_WindowFunction_Bound_default_instance_), - reinterpret_cast(&::substrait::_Expression_WindowFunction_default_instance_), - reinterpret_cast(&::substrait::_Expression_IfThen_IfClause_default_instance_), - reinterpret_cast(&::substrait::_Expression_IfThen_default_instance_), - reinterpret_cast(&::substrait::_Expression_Cast_default_instance_), - reinterpret_cast(&::substrait::_Expression_SwitchExpression_IfValue_default_instance_), - reinterpret_cast(&::substrait::_Expression_SwitchExpression_default_instance_), - reinterpret_cast(&::substrait::_Expression_SingularOrList_default_instance_), - reinterpret_cast(&::substrait::_Expression_MultiOrList_Record_default_instance_), - reinterpret_cast(&::substrait::_Expression_MultiOrList_default_instance_), - reinterpret_cast(&::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_), - reinterpret_cast(&::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_), - reinterpret_cast(&::substrait::_Expression_EmbeddedFunction_default_instance_), - reinterpret_cast(&::substrait::_Expression_ReferenceSegment_MapKey_default_instance_), - reinterpret_cast(&::substrait::_Expression_ReferenceSegment_StructField_default_instance_), - reinterpret_cast(&::substrait::_Expression_ReferenceSegment_ListElement_default_instance_), - reinterpret_cast(&::substrait::_Expression_ReferenceSegment_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_Select_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_StructSelect_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_StructItem_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_ListSelect_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_MapSelect_default_instance_), - reinterpret_cast(&::substrait::_Expression_MaskExpression_default_instance_), - reinterpret_cast(&::substrait::_Expression_FieldReference_RootReference_default_instance_), - reinterpret_cast(&::substrait::_Expression_FieldReference_default_instance_), - reinterpret_cast(&::substrait::_Expression_default_instance_), - reinterpret_cast(&::substrait::_SortField_default_instance_), - reinterpret_cast(&::substrait::_AggregateFunction_default_instance_), -}; - -const char descriptor_table_protodef_substrait_2fexpression_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\032substrait/expression.proto\022\tsubstrait\032" - "\024substrait/type.proto\"\2101\n\nExpression\0220\n\007" - "literal\030\001 \001(\0132\035.substrait.Expression.Lit" - "eralH\000\0229\n\tselection\030\002 \001(\0132$.substrait.Ex" - "pression.FieldReferenceH\000\022\?\n\017scalar_func" - "tion\030\003 \001(\0132$.substrait.Expression.Scalar" - "FunctionH\000\022\?\n\017window_function\030\005 \001(\0132$.su" - "bstrait.Expression.WindowFunctionH\000\022/\n\007i" - "f_then\030\006 \001(\0132\034.substrait.Expression.IfTh" - "enH\000\022C\n\021switch_expression\030\007 \001(\0132&.substr" - "ait.Expression.SwitchExpressionH\000\022@\n\020sin" - "gular_or_list\030\010 \001(\0132$.substrait.Expressi" - "on.SingularOrListH\000\022:\n\rmulti_or_list\030\t \001" - "(\0132!.substrait.Expression.MultiOrListH\000\022" - "*\n\004enum\030\n \001(\0132\032.substrait.Expression.Enu" - "mH\000\022*\n\004cast\030\013 \001(\0132\032.substrait.Expression" - ".CastH\000\032j\n\004Enum\022\023\n\tspecified\030\001 \001(\tH\000\0227\n\013" - "unspecified\030\002 \001(\0132 .substrait.Expression" - ".Enum.EmptyH\000\032\007\n\005EmptyB\013\n\tenum_kind\032\354\n\n\007" - "Literal\022\021\n\007boolean\030\001 \001(\010H\000\022\014\n\002i8\030\002 \001(\005H\000" - "\022\r\n\003i16\030\003 \001(\005H\000\022\r\n\003i32\030\005 \001(\005H\000\022\r\n\003i64\030\007 " - "\001(\003H\000\022\016\n\004fp32\030\n \001(\002H\000\022\016\n\004fp64\030\013 \001(\001H\000\022\020\n" - "\006string\030\014 \001(\tH\000\022\020\n\006binary\030\r \001(\014H\000\022\023\n\ttim" - "estamp\030\016 \001(\003H\000\022\016\n\004date\030\020 \001(\005H\000\022\016\n\004time\030\021" - " \001(\003H\000\022S\n\026interval_year_to_month\030\023 \001(\01321" - ".substrait.Expression.Literal.IntervalYe" - "arToMonthH\000\022S\n\026interval_day_to_second\030\024 " - "\001(\01321.substrait.Expression.Literal.Inter" - "valDayToSecondH\000\022\024\n\nfixed_char\030\025 \001(\tH\000\0229" - "\n\010var_char\030\026 \001(\0132%.substrait.Expression." - "Literal.VarCharH\000\022\026\n\014fixed_binary\030\027 \001(\014H" - "\000\0228\n\007decimal\030\030 \001(\0132%.substrait.Expressio" - "n.Literal.DecimalH\000\0226\n\006struct\030\031 \001(\0132$.su" - "bstrait.Expression.Literal.StructH\000\0220\n\003m" - "ap\030\032 \001(\0132!.substrait.Expression.Literal." - "MapH\000\022\026\n\014timestamp_tz\030\033 \001(\003H\000\022\016\n\004uuid\030\034 " - "\001(\014H\000\022\037\n\004null\030\035 \001(\0132\017.substrait.TypeH\000\0222" - "\n\004list\030\036 \001(\0132\".substrait.Expression.Lite" - "ral.ListH\000\022*\n\nempty_list\030\037 \001(\0132\024.substra" - "it.Type.ListH\000\022(\n\tempty_map\030 \001(\0132\023.subs" - "trait.Type.MapH\000\022\020\n\010nullable\0302 \001(\010\032(\n\007Va" - "rChar\022\r\n\005value\030\001 \001(\t\022\016\n\006length\030\002 \001(\r\032:\n\007" - "Decimal\022\r\n\005value\030\001 \001(\014\022\021\n\tprecision\030\002 \001(" - "\005\022\r\n\005scale\030\003 \001(\005\032\253\001\n\003Map\022>\n\nkey_values\030\001" - " \003(\0132*.substrait.Expression.Literal.Map." - "KeyValue\032d\n\010KeyValue\022*\n\003key\030\001 \001(\0132\035.subs" - "trait.Expression.Literal\022,\n\005value\030\002 \001(\0132" - "\035.substrait.Expression.Literal\0324\n\023Interv" - "alYearToMonth\022\r\n\005years\030\001 \001(\005\022\016\n\006months\030\002" - " \001(\005\0324\n\023IntervalDayToSecond\022\014\n\004days\030\001 \001(" - "\005\022\017\n\007seconds\030\002 \001(\005\0327\n\006Struct\022-\n\006fields\030\001" - " \003(\0132\035.substrait.Expression.Literal\0325\n\004L" - "ist\022-\n\006values\030\001 \003(\0132\035.substrait.Expressi" - "on.LiteralB\016\n\014literal_type\032w\n\016ScalarFunc" - "tion\022\032\n\022function_reference\030\001 \001(\r\022#\n\004args" - "\030\002 \003(\0132\025.substrait.Expression\022$\n\013output_" - "type\030\003 \001(\0132\017.substrait.Type\032\213\006\n\016WindowFu" - "nction\022\032\n\022function_reference\030\001 \001(\r\022)\n\npa" - "rtitions\030\002 \003(\0132\025.substrait.Expression\022#\n" - "\005sorts\030\003 \003(\0132\024.substrait.SortField\022\?\n\013up" - "per_bound\030\004 \001(\0132*.substrait.Expression.W" - "indowFunction.Bound\022\?\n\013lower_bound\030\005 \001(\013" - "2*.substrait.Expression.WindowFunction.B" - "ound\022*\n\005phase\030\006 \001(\0162\033.substrait.Aggregat" - "ionPhase\022$\n\013output_type\030\007 \001(\0132\017.substrai" - "t.Type\022#\n\004args\030\010 \003(\0132\025.substrait.Express" - "ion\032\223\003\n\005Bound\022I\n\tpreceding\030\001 \001(\01324.subst" - "rait.Expression.WindowFunction.Bound.Pre" - "cedingH\000\022I\n\tfollowing\030\002 \001(\01324.substrait." - "Expression.WindowFunction.Bound.Followin" - "gH\000\022L\n\013current_row\030\003 \001(\01325.substrait.Exp" - "ression.WindowFunction.Bound.CurrentRowH" - "\000\022I\n\tunbounded\030\004 \001(\01324.substrait.Express" - "ion.WindowFunction.Bound.UnboundedH\000\032\033\n\t" - "Preceding\022\016\n\006offset\030\001 \001(\003\032\033\n\tFollowing\022\016" - "\n\006offset\030\001 \001(\003\032\014\n\nCurrentRow\032\013\n\tUnbounde" - "dB\006\n\004kind\032\265\001\n\006IfThen\0222\n\003ifs\030\001 \003(\0132%.subs" - "trait.Expression.IfThen.IfClause\022#\n\004else" - "\030\002 \001(\0132\025.substrait.Expression\032R\n\010IfClaus" - "e\022!\n\002if\030\001 \001(\0132\025.substrait.Expression\022#\n\004" - "then\030\002 \001(\0132\025.substrait.Expression\032K\n\004Cas" - "t\022\035\n\004type\030\001 \001(\0132\017.substrait.Type\022$\n\005inpu" - "t\030\002 \001(\0132\025.substrait.Expression\032\317\001\n\020Switc" - "hExpression\022;\n\003ifs\030\001 \003(\0132..substrait.Exp" - "ression.SwitchExpression.IfValue\022#\n\004else" - "\030\002 \001(\0132\025.substrait.Expression\032Y\n\007IfValue" - "\022)\n\002if\030\001 \001(\0132\035.substrait.Expression.Lite" - "ral\022#\n\004then\030\002 \001(\0132\025.substrait.Expression" - "\032^\n\016SingularOrList\022$\n\005value\030\001 \001(\0132\025.subs" - "trait.Expression\022&\n\007options\030\002 \003(\0132\025.subs" - "trait.Expression\032\237\001\n\013MultiOrList\022$\n\005valu" - "e\030\001 \003(\0132\025.substrait.Expression\0229\n\007option" - "s\030\002 \003(\0132(.substrait.Expression.MultiOrLi" - "st.Record\032/\n\006Record\022%\n\006fields\030\001 \003(\0132\025.su" - "bstrait.Expression\032\243\003\n\020EmbeddedFunction\022" - "(\n\targuments\030\001 \003(\0132\025.substrait.Expressio" - "n\022$\n\013output_type\030\002 \001(\0132\017.substrait.Type\022" - "]\n\026python_pickle_function\030\003 \001(\0132;.substr" - "ait.Expression.EmbeddedFunction.PythonPi" - "ckleFunctionH\000\022[\n\025web_assembly_function\030" - "\004 \001(\0132:.substrait.Expression.EmbeddedFun" - "ction.WebAssemblyFunctionH\000\032>\n\024PythonPic" - "kleFunction\022\020\n\010function\030\001 \001(\014\022\024\n\014prerequ" - "isite\030\002 \003(\t\032;\n\023WebAssemblyFunction\022\016\n\006sc" - "ript\030\001 \001(\014\022\024\n\014prerequisite\030\002 \003(\tB\006\n\004kind" - "\032\232\004\n\020ReferenceSegment\022@\n\007map_key\030\001 \001(\0132-" - ".substrait.Expression.ReferenceSegment.M" - "apKeyH\000\022J\n\014struct_field\030\002 \001(\01322.substrai" - "t.Expression.ReferenceSegment.StructFiel" - "dH\000\022J\n\014list_element\030\003 \001(\01322.substrait.Ex" - "pression.ReferenceSegment.ListElementH\000\032" - "o\n\006MapKey\022.\n\007map_key\030\001 \001(\0132\035.substrait.E" - "xpression.Literal\0225\n\005child\030\002 \001(\0132&.subst" - "rait.Expression.ReferenceSegment\032S\n\013Stru" - "ctField\022\r\n\005field\030\001 \001(\005\0225\n\005child\030\002 \001(\0132&." - "substrait.Expression.ReferenceSegment\032T\n" - "\013ListElement\022\016\n\006offset\030\001 \001(\005\0225\n\005child\030\002 " - "\001(\0132&.substrait.Expression.ReferenceSegm" - "entB\020\n\016reference_type\032\360\t\n\016MaskExpression" - "\022A\n\006select\030\001 \001(\01321.substrait.Expression." - "MaskExpression.StructSelect\022 \n\030maintain_" - "singular_struct\030\002 \001(\010\032\325\001\n\006Select\022C\n\006stru" - "ct\030\001 \001(\01321.substrait.Expression.MaskExpr" - "ession.StructSelectH\000\022\?\n\004list\030\002 \001(\0132/.su" - "bstrait.Expression.MaskExpression.ListSe" - "lectH\000\022=\n\003map\030\003 \001(\0132..substrait.Expressi" - "on.MaskExpression.MapSelectH\000B\006\n\004type\032U\n" - "\014StructSelect\022E\n\014struct_items\030\001 \003(\0132/.su" - "bstrait.Expression.MaskExpression.Struct" - "Item\032W\n\nStructItem\022\r\n\005field\030\001 \001(\005\022:\n\005chi" - "ld\030\002 \001(\0132+.substrait.Expression.MaskExpr" - "ession.Select\032\264\003\n\nListSelect\022Q\n\tselectio" - "n\030\001 \003(\0132>.substrait.Expression.MaskExpre" - "ssion.ListSelect.ListSelectItem\022:\n\005child" - "\030\002 \001(\0132+.substrait.Expression.MaskExpres" - "sion.Select\032\226\002\n\016ListSelectItem\022Z\n\004item\030\001" - " \001(\0132J.substrait.Expression.MaskExpressi" - "on.ListSelect.ListSelectItem.ListElement" - "H\000\022Y\n\005slice\030\002 \001(\0132H.substrait.Expression" - ".MaskExpression.ListSelect.ListSelectIte" - "m.ListSliceH\000\032\034\n\013ListElement\022\r\n\005field\030\001 " - "\001(\005\032\'\n\tListSlice\022\r\n\005start\030\001 \001(\005\022\013\n\003end\030\002" - " \001(\005B\006\n\004type\032\271\002\n\tMapSelect\022D\n\003key\030\001 \001(\0132" - "5.substrait.Expression.MaskExpression.Ma" - "pSelect.MapKeyH\000\022U\n\nexpression\030\002 \001(\0132\?.s" - "ubstrait.Expression.MaskExpression.MapSe" - "lect.MapKeyExpressionH\000\022:\n\005child\030\003 \001(\0132+" - ".substrait.Expression.MaskExpression.Sel" - "ect\032\031\n\006MapKey\022\017\n\007map_key\030\001 \001(\t\032.\n\020MapKey" - "Expression\022\032\n\022map_key_expression\030\001 \001(\tB\010" - "\n\006select\032\301\002\n\016FieldReference\022B\n\020direct_re" - "ference\030\001 \001(\0132&.substrait.Expression.Ref" - "erenceSegmentH\000\022@\n\020masked_reference\030\002 \001(" - "\0132$.substrait.Expression.MaskExpressionH" - "\000\022+\n\nexpression\030\003 \001(\0132\025.substrait.Expres" - "sionH\001\022L\n\016root_reference\030\004 \001(\01322.substra" - "it.Expression.FieldReference.RootReferen" - "ceH\001\032\017\n\rRootReferenceB\020\n\016reference_typeB" - "\013\n\troot_typeB\n\n\010rex_type\"\377\002\n\tSortField\022#" - "\n\004expr\030\001 \001(\0132\025.substrait.Expression\0227\n\td" - "irection\030\002 \001(\0162\".substrait.SortField.Sor" - "tDirectionH\000\022\'\n\035comparison_function_refe" - "rence\030\003 \001(\rH\000\"\335\001\n\rSortDirection\022\036\n\032SORT_" - "DIRECTION_UNSPECIFIED\020\000\022\"\n\036SORT_DIRECTIO" - "N_ASC_NULLS_FIRST\020\001\022!\n\035SORT_DIRECTION_AS" - "C_NULLS_LAST\020\002\022#\n\037SORT_DIRECTION_DESC_NU" - "LLS_FIRST\020\003\022\"\n\036SORT_DIRECTION_DESC_NULLS" - "_LAST\020\004\022\034\n\030SORT_DIRECTION_CLUSTERED\020\005B\013\n" - "\tsort_kind\"\313\001\n\021AggregateFunction\022\032\n\022func" - "tion_reference\030\001 \001(\r\022#\n\004args\030\002 \003(\0132\025.sub" - "strait.Expression\022#\n\005sorts\030\003 \003(\0132\024.subst" - "rait.SortField\022*\n\005phase\030\004 \001(\0162\033.substrai" - "t.AggregationPhase\022$\n\013output_type\030\005 \001(\0132" - "\017.substrait.Type*\357\001\n\020AggregationPhase\022!\n" - "\035AGGREGATION_PHASE_UNSPECIFIED\020\000\022-\n)AGGR" - "EGATION_PHASE_INITIAL_TO_INTERMEDIATE\020\001\022" - "2\n.AGGREGATION_PHASE_INTERMEDIATE_TO_INT" - "ERMEDIATE\020\002\022\'\n#AGGREGATION_PHASE_INITIAL" - "_TO_RESULT\020\003\022,\n(AGGREGATION_PHASE_INTERM" - "EDIATE_TO_RESULT\020\004B+\n\022io.substrait.proto" - "P\001\252\002\022Substrait.Protobufb\006proto3" - ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fexpression_2eproto_deps[1] = { - &::descriptor_table_substrait_2ftype_2eproto, -}; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fexpression_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fexpression_2eproto = { - false, false, 7231, descriptor_table_protodef_substrait_2fexpression_2eproto, "substrait/expression.proto", - &descriptor_table_substrait_2fexpression_2eproto_once, descriptor_table_substrait_2fexpression_2eproto_deps, 1, 49, - schemas, file_default_instances, TableStruct_substrait_2fexpression_2eproto::offsets, - file_level_metadata_substrait_2fexpression_2eproto, file_level_enum_descriptors_substrait_2fexpression_2eproto, file_level_service_descriptors_substrait_2fexpression_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fexpression_2eproto_getter() { - return &descriptor_table_substrait_2fexpression_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fexpression_2eproto(&descriptor_table_substrait_2fexpression_2eproto); -namespace substrait { -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortField_SortDirection_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2fexpression_2eproto); - return file_level_enum_descriptors_substrait_2fexpression_2eproto[0]; -} -bool SortField_SortDirection_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr SortField_SortDirection SortField::SORT_DIRECTION_UNSPECIFIED; -constexpr SortField_SortDirection SortField::SORT_DIRECTION_ASC_NULLS_FIRST; -constexpr SortField_SortDirection SortField::SORT_DIRECTION_ASC_NULLS_LAST; -constexpr SortField_SortDirection SortField::SORT_DIRECTION_DESC_NULLS_FIRST; -constexpr SortField_SortDirection SortField::SORT_DIRECTION_DESC_NULLS_LAST; -constexpr SortField_SortDirection SortField::SORT_DIRECTION_CLUSTERED; -constexpr SortField_SortDirection SortField::SortDirection_MIN; -constexpr SortField_SortDirection SortField::SortDirection_MAX; -constexpr int SortField::SortDirection_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggregationPhase_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2fexpression_2eproto); - return file_level_enum_descriptors_substrait_2fexpression_2eproto[1]; -} -bool AggregationPhase_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - return true; - default: - return false; - } -} - - -// =================================================================== - -class Expression_Enum_Empty::_Internal { - public: -}; - -Expression_Enum_Empty::Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Enum.Empty) -} -Expression_Enum_Empty::Expression_Enum_Empty(const Expression_Enum_Empty& from) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Enum.Empty) -} - - - - - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Enum_Empty::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Enum_Empty::GetClassData() const { return &_class_data_; } - - - - - - - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum_Empty::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[0]); -} - -// =================================================================== - -class Expression_Enum::_Internal { - public: - static const ::substrait::Expression_Enum_Empty& unspecified(const Expression_Enum* msg); -}; - -const ::substrait::Expression_Enum_Empty& -Expression_Enum::_Internal::unspecified(const Expression_Enum* msg) { - return *msg->enum_kind_.unspecified_; -} -void Expression_Enum::set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_enum_kind(); - if (unspecified) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Enum_Empty>::GetOwningArena(unspecified); - if (message_arena != submessage_arena) { - unspecified = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, unspecified, submessage_arena); - } - set_has_unspecified(); - enum_kind_.unspecified_ = unspecified; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Enum.unspecified) -} -Expression_Enum::Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Enum) -} -Expression_Enum::Expression_Enum(const Expression_Enum& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_enum_kind(); - switch (from.enum_kind_case()) { - case kSpecified: { - _internal_set_specified(from._internal_specified()); - break; - } - case kUnspecified: { - _internal_mutable_unspecified()->::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified()); - break; - } - case ENUM_KIND_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Enum) -} - -inline void Expression_Enum::SharedCtor() { -clear_has_enum_kind(); -} - -Expression_Enum::~Expression_Enum() { - // @@protoc_insertion_point(destructor:substrait.Expression.Enum) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Enum::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_enum_kind()) { - clear_enum_kind(); - } -} - -void Expression_Enum::ArenaDtor(void* object) { - Expression_Enum* _this = reinterpret_cast< Expression_Enum* >(object); - (void)_this; -} -void Expression_Enum::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Enum::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Enum::clear_enum_kind() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.Enum) - switch (enum_kind_case()) { - case kSpecified: { - enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kUnspecified: { - if (GetArenaForAllocation() == nullptr) { - delete enum_kind_.unspecified_; - } - break; - } - case ENUM_KIND_NOT_SET: { - break; - } - } - _oneof_case_[0] = ENUM_KIND_NOT_SET; -} - - -void Expression_Enum::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Enum) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_enum_kind(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Enum::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string specified = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_specified(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Enum.specified")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Enum.Empty unspecified = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_unspecified(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_Enum::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Enum) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string specified = 1; - if (_internal_has_specified()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_specified().data(), static_cast(this->_internal_specified().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Expression.Enum.specified"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_specified(), target); - } - - // .substrait.Expression.Enum.Empty unspecified = 2; - if (_internal_has_unspecified()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::unspecified(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Enum) - return target; -} - -size_t Expression_Enum::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Enum) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (enum_kind_case()) { - // string specified = 1; - case kSpecified: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_specified()); - break; - } - // .substrait.Expression.Enum.Empty unspecified = 2; - case kUnspecified: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *enum_kind_.unspecified_); - break; - } - case ENUM_KIND_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Enum::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Enum::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Enum::GetClassData() const { return &_class_data_; } - -void Expression_Enum::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Enum::MergeFrom(const Expression_Enum& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Enum) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.enum_kind_case()) { - case kSpecified: { - _internal_set_specified(from._internal_specified()); - break; - } - case kUnspecified: { - _internal_mutable_unspecified()->::substrait::Expression_Enum_Empty::MergeFrom(from._internal_unspecified()); - break; - } - case ENUM_KIND_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Enum::CopyFrom(const Expression_Enum& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Enum) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Enum::IsInitialized() const { - return true; -} - -void Expression_Enum::InternalSwap(Expression_Enum* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(enum_kind_, other->enum_kind_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Enum::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[1]); -} - -// =================================================================== - -class Expression_Literal_VarChar::_Internal { - public: -}; - -Expression_Literal_VarChar::Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.VarChar) -} -Expression_Literal_VarChar::Expression_Literal_VarChar(const Expression_Literal_VarChar& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_value().empty()) { - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), - GetArenaForAllocation()); - } - length_ = from.length_; - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.VarChar) -} - -inline void Expression_Literal_VarChar::SharedCtor() { -value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -length_ = 0u; -} - -Expression_Literal_VarChar::~Expression_Literal_VarChar() { - // @@protoc_insertion_point(destructor:substrait.Expression.Literal.VarChar) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Literal_VarChar::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void Expression_Literal_VarChar::ArenaDtor(void* object) { - Expression_Literal_VarChar* _this = reinterpret_cast< Expression_Literal_VarChar* >(object); - (void)_this; -} -void Expression_Literal_VarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Literal_VarChar::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Literal_VarChar::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.VarChar) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - value_.ClearToEmpty(); - length_ = 0u; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Literal_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string value = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_value(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.VarChar.value")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 length = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_Literal_VarChar::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.VarChar) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string value = 1; - if (!this->_internal_value().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_value().data(), static_cast(this->_internal_value().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Expression.Literal.VarChar.value"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_value(), target); - } - - // uint32 length = 2; - if (this->_internal_length() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_length(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.VarChar) - return target; -} - -size_t Expression_Literal_VarChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.VarChar) - 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 value = 1; - if (!this->_internal_value().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_value()); - } - - // uint32 length = 2; - if (this->_internal_length() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_length()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_VarChar::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Literal_VarChar::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_VarChar::GetClassData() const { return &_class_data_; } - -void Expression_Literal_VarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Literal_VarChar::MergeFrom(const Expression_Literal_VarChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.VarChar) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_value().empty()) { - _internal_set_value(from._internal_value()); - } - if (from._internal_length() != 0) { - _internal_set_length(from._internal_length()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Literal_VarChar::CopyFrom(const Expression_Literal_VarChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.VarChar) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Literal_VarChar::IsInitialized() const { - return true; -} - -void Expression_Literal_VarChar::InternalSwap(Expression_Literal_VarChar* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &value_, lhs_arena, - &other->value_, rhs_arena - ); - swap(length_, other->length_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_VarChar::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[2]); -} - -// =================================================================== - -class Expression_Literal_Decimal::_Internal { - public: -}; - -Expression_Literal_Decimal::Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Decimal) -} -Expression_Literal_Decimal::Expression_Literal_Decimal(const Expression_Literal_Decimal& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_value().empty()) { - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_value(), - GetArenaForAllocation()); - } - ::memcpy(&precision_, &from.precision_, - static_cast(reinterpret_cast(&scale_) - - reinterpret_cast(&precision_)) + sizeof(scale_)); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Decimal) -} - -inline void Expression_Literal_Decimal::SharedCtor() { -value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&precision_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&scale_) - - reinterpret_cast(&precision_)) + sizeof(scale_)); -} - -Expression_Literal_Decimal::~Expression_Literal_Decimal() { - // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Decimal) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Literal_Decimal::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - value_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void Expression_Literal_Decimal::ArenaDtor(void* object) { - Expression_Literal_Decimal* _this = reinterpret_cast< Expression_Literal_Decimal* >(object); - (void)_this; -} -void Expression_Literal_Decimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Literal_Decimal::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Literal_Decimal::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Decimal) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - value_.ClearToEmpty(); - ::memset(&precision_, 0, static_cast( - reinterpret_cast(&scale_) - - reinterpret_cast(&precision_)) + sizeof(scale_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Literal_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // bytes value = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_value(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 precision = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 scale = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_Literal_Decimal::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Decimal) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // bytes value = 1; - if (!this->_internal_value().empty()) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_value(), target); - } - - // int32 precision = 2; - if (this->_internal_precision() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_precision(), target); - } - - // int32 scale = 3; - if (this->_internal_scale() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_scale(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Decimal) - return target; -} - -size_t Expression_Literal_Decimal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Decimal) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // bytes value = 1; - if (!this->_internal_value().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_value()); - } - - // int32 precision = 2; - if (this->_internal_precision() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_precision()); - } - - // int32 scale = 3; - if (this->_internal_scale() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_scale()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Decimal::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Literal_Decimal::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Decimal::GetClassData() const { return &_class_data_; } - -void Expression_Literal_Decimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Literal_Decimal::MergeFrom(const Expression_Literal_Decimal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Decimal) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_value().empty()) { - _internal_set_value(from._internal_value()); - } - if (from._internal_precision() != 0) { - _internal_set_precision(from._internal_precision()); - } - if (from._internal_scale() != 0) { - _internal_set_scale(from._internal_scale()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Literal_Decimal::CopyFrom(const Expression_Literal_Decimal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Decimal) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Literal_Decimal::IsInitialized() const { - return true; -} - -void Expression_Literal_Decimal::InternalSwap(Expression_Literal_Decimal* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &value_, lhs_arena, - &other->value_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_Literal_Decimal, scale_) - + sizeof(Expression_Literal_Decimal::scale_) - - PROTOBUF_FIELD_OFFSET(Expression_Literal_Decimal, precision_)>( - reinterpret_cast(&precision_), - reinterpret_cast(&other->precision_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Decimal::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[3]); -} - -// =================================================================== - -class Expression_Literal_Map_KeyValue::_Internal { - public: - static const ::substrait::Expression_Literal& key(const Expression_Literal_Map_KeyValue* msg); - static const ::substrait::Expression_Literal& value(const Expression_Literal_Map_KeyValue* msg); -}; - -const ::substrait::Expression_Literal& -Expression_Literal_Map_KeyValue::_Internal::key(const Expression_Literal_Map_KeyValue* msg) { - return *msg->key_; -} -const ::substrait::Expression_Literal& -Expression_Literal_Map_KeyValue::_Internal::value(const Expression_Literal_Map_KeyValue* msg) { - return *msg->value_; -} -Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Map.KeyValue) -} -Expression_Literal_Map_KeyValue::Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key()) { - key_ = new ::substrait::Expression_Literal(*from.key_); - } else { - key_ = nullptr; - } - if (from._internal_has_value()) { - value_ = new ::substrait::Expression_Literal(*from.value_); - } else { - value_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Map.KeyValue) -} - -inline void Expression_Literal_Map_KeyValue::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&key_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&value_) - - reinterpret_cast(&key_)) + sizeof(value_)); -} - -Expression_Literal_Map_KeyValue::~Expression_Literal_Map_KeyValue() { - // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Map.KeyValue) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Literal_Map_KeyValue::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete key_; - if (this != internal_default_instance()) delete value_; -} - -void Expression_Literal_Map_KeyValue::ArenaDtor(void* object) { - Expression_Literal_Map_KeyValue* _this = reinterpret_cast< Expression_Literal_Map_KeyValue* >(object); - (void)_this; -} -void Expression_Literal_Map_KeyValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Literal_Map_KeyValue::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Literal_Map_KeyValue::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Map.KeyValue) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && key_ != nullptr) { - delete key_; - } - key_ = nullptr; - if (GetArenaForAllocation() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Literal_Map_KeyValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.Literal key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Literal value = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_Literal_Map_KeyValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Map.KeyValue) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.Literal key = 1; - if (this->_internal_has_key()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::key(this), target, stream); - } - - // .substrait.Expression.Literal value = 2; - if (this->_internal_has_value()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::value(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Map.KeyValue) - return target; -} - -size_t Expression_Literal_Map_KeyValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Map.KeyValue) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Expression.Literal key = 1; - if (this->_internal_has_key()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *key_); - } - - // .substrait.Expression.Literal value = 2; - if (this->_internal_has_value()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *value_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Map_KeyValue::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Literal_Map_KeyValue::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Map_KeyValue::GetClassData() const { return &_class_data_; } - -void Expression_Literal_Map_KeyValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Literal_Map_KeyValue::MergeFrom(const Expression_Literal_Map_KeyValue& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Map.KeyValue) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_key()) { - _internal_mutable_key()->::substrait::Expression_Literal::MergeFrom(from._internal_key()); - } - if (from._internal_has_value()) { - _internal_mutable_value()->::substrait::Expression_Literal::MergeFrom(from._internal_value()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Literal_Map_KeyValue::CopyFrom(const Expression_Literal_Map_KeyValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Map.KeyValue) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Literal_Map_KeyValue::IsInitialized() const { - return true; -} - -void Expression_Literal_Map_KeyValue::InternalSwap(Expression_Literal_Map_KeyValue* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, value_) - + sizeof(Expression_Literal_Map_KeyValue::value_) - - PROTOBUF_FIELD_OFFSET(Expression_Literal_Map_KeyValue, key_)>( - reinterpret_cast(&key_), - reinterpret_cast(&other->key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map_KeyValue::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[4]); -} - -// =================================================================== - -class Expression_Literal_Map::_Internal { - public: -}; - -Expression_Literal_Map::Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - key_values_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Map) -} -Expression_Literal_Map::Expression_Literal_Map(const Expression_Literal_Map& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - key_values_(from.key_values_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Map) -} - -inline void Expression_Literal_Map::SharedCtor() { -} - -Expression_Literal_Map::~Expression_Literal_Map() { - // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Map) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Literal_Map::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_Literal_Map::ArenaDtor(void* object) { - Expression_Literal_Map* _this = reinterpret_cast< Expression_Literal_Map* >(object); - (void)_this; -} -void Expression_Literal_Map::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Literal_Map::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Literal_Map::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Map) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - key_values_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Literal_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_key_values(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* Expression_Literal_Map::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Map) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_key_values_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_key_values(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Map) - return target; -} - -size_t Expression_Literal_Map::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Map) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; - total_size += 1UL * this->_internal_key_values_size(); - for (const auto& msg : this->key_values_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Map::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Literal_Map::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Map::GetClassData() const { return &_class_data_; } - -void Expression_Literal_Map::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Literal_Map::MergeFrom(const Expression_Literal_Map& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Map) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - key_values_.MergeFrom(from.key_values_); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Literal_Map::CopyFrom(const Expression_Literal_Map& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Map) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Literal_Map::IsInitialized() const { - return true; -} - -void Expression_Literal_Map::InternalSwap(Expression_Literal_Map* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - key_values_.InternalSwap(&other->key_values_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Map::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[5]); -} - -// =================================================================== - -class Expression_Literal_IntervalYearToMonth::_Internal { - public: -}; - -Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.IntervalYearToMonth) -} -Expression_Literal_IntervalYearToMonth::Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&years_, &from.years_, - static_cast(reinterpret_cast(&months_) - - reinterpret_cast(&years_)) + sizeof(months_)); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalYearToMonth) -} - -inline void Expression_Literal_IntervalYearToMonth::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&years_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&months_) - - reinterpret_cast(&years_)) + sizeof(months_)); -} - -Expression_Literal_IntervalYearToMonth::~Expression_Literal_IntervalYearToMonth() { - // @@protoc_insertion_point(destructor:substrait.Expression.Literal.IntervalYearToMonth) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Literal_IntervalYearToMonth::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_Literal_IntervalYearToMonth::ArenaDtor(void* object) { - Expression_Literal_IntervalYearToMonth* _this = reinterpret_cast< Expression_Literal_IntervalYearToMonth* >(object); - (void)_this; -} -void Expression_Literal_IntervalYearToMonth::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Literal_IntervalYearToMonth::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Literal_IntervalYearToMonth::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.IntervalYearToMonth) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&years_, 0, static_cast( - reinterpret_cast(&months_) - - reinterpret_cast(&years_)) + sizeof(months_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Literal_IntervalYearToMonth::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 years = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - years_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 months = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - months_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_Literal_IntervalYearToMonth::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.IntervalYearToMonth) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 years = 1; - if (this->_internal_years() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_years(), target); - } - - // int32 months = 2; - if (this->_internal_months() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_months(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.IntervalYearToMonth) - return target; -} - -size_t Expression_Literal_IntervalYearToMonth::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.IntervalYearToMonth) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int32 years = 1; - if (this->_internal_years() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_years()); - } - - // int32 months = 2; - if (this->_internal_months() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_months()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_IntervalYearToMonth::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Literal_IntervalYearToMonth::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_IntervalYearToMonth::GetClassData() const { return &_class_data_; } - -void Expression_Literal_IntervalYearToMonth::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Literal_IntervalYearToMonth::MergeFrom(const Expression_Literal_IntervalYearToMonth& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.IntervalYearToMonth) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_years() != 0) { - _internal_set_years(from._internal_years()); - } - if (from._internal_months() != 0) { - _internal_set_months(from._internal_months()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Literal_IntervalYearToMonth::CopyFrom(const Expression_Literal_IntervalYearToMonth& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.IntervalYearToMonth) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Literal_IntervalYearToMonth::IsInitialized() const { - return true; -} - -void Expression_Literal_IntervalYearToMonth::InternalSwap(Expression_Literal_IntervalYearToMonth* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, months_) - + sizeof(Expression_Literal_IntervalYearToMonth::months_) - - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalYearToMonth, years_)>( - reinterpret_cast(&years_), - reinterpret_cast(&other->years_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalYearToMonth::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[6]); -} - -// =================================================================== - -class Expression_Literal_IntervalDayToSecond::_Internal { - public: -}; - -Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.IntervalDayToSecond) -} -Expression_Literal_IntervalDayToSecond::Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&days_, &from.days_, - static_cast(reinterpret_cast(&seconds_) - - reinterpret_cast(&days_)) + sizeof(seconds_)); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.IntervalDayToSecond) -} - -inline void Expression_Literal_IntervalDayToSecond::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&days_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&seconds_) - - reinterpret_cast(&days_)) + sizeof(seconds_)); -} - -Expression_Literal_IntervalDayToSecond::~Expression_Literal_IntervalDayToSecond() { - // @@protoc_insertion_point(destructor:substrait.Expression.Literal.IntervalDayToSecond) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Literal_IntervalDayToSecond::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_Literal_IntervalDayToSecond::ArenaDtor(void* object) { - Expression_Literal_IntervalDayToSecond* _this = reinterpret_cast< Expression_Literal_IntervalDayToSecond* >(object); - (void)_this; -} -void Expression_Literal_IntervalDayToSecond::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Literal_IntervalDayToSecond::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Literal_IntervalDayToSecond::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.IntervalDayToSecond) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&days_, 0, static_cast( - reinterpret_cast(&seconds_) - - reinterpret_cast(&days_)) + sizeof(seconds_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Literal_IntervalDayToSecond::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 days = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - days_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 seconds = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - seconds_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_Literal_IntervalDayToSecond::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.IntervalDayToSecond) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 days = 1; - if (this->_internal_days() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_days(), target); - } - - // int32 seconds = 2; - if (this->_internal_seconds() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_seconds(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.IntervalDayToSecond) - return target; -} - -size_t Expression_Literal_IntervalDayToSecond::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.IntervalDayToSecond) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int32 days = 1; - if (this->_internal_days() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_days()); - } - - // int32 seconds = 2; - if (this->_internal_seconds() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_seconds()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_IntervalDayToSecond::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Literal_IntervalDayToSecond::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_IntervalDayToSecond::GetClassData() const { return &_class_data_; } - -void Expression_Literal_IntervalDayToSecond::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Literal_IntervalDayToSecond::MergeFrom(const Expression_Literal_IntervalDayToSecond& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.IntervalDayToSecond) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_days() != 0) { - _internal_set_days(from._internal_days()); - } - if (from._internal_seconds() != 0) { - _internal_set_seconds(from._internal_seconds()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Literal_IntervalDayToSecond::CopyFrom(const Expression_Literal_IntervalDayToSecond& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.IntervalDayToSecond) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Literal_IntervalDayToSecond::IsInitialized() const { - return true; -} - -void Expression_Literal_IntervalDayToSecond::InternalSwap(Expression_Literal_IntervalDayToSecond* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, seconds_) - + sizeof(Expression_Literal_IntervalDayToSecond::seconds_) - - PROTOBUF_FIELD_OFFSET(Expression_Literal_IntervalDayToSecond, days_)>( - reinterpret_cast(&days_), - reinterpret_cast(&other->days_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_IntervalDayToSecond::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[7]); -} - -// =================================================================== - -class Expression_Literal_Struct::_Internal { - public: -}; - -Expression_Literal_Struct::Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - fields_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.Struct) -} -Expression_Literal_Struct::Expression_Literal_Struct(const Expression_Literal_Struct& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - fields_(from.fields_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.Struct) -} - -inline void Expression_Literal_Struct::SharedCtor() { -} - -Expression_Literal_Struct::~Expression_Literal_Struct() { - // @@protoc_insertion_point(destructor:substrait.Expression.Literal.Struct) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Literal_Struct::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_Literal_Struct::ArenaDtor(void* object) { - Expression_Literal_Struct* _this = reinterpret_cast< Expression_Literal_Struct* >(object); - (void)_this; -} -void Expression_Literal_Struct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Literal_Struct::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Literal_Struct::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.Struct) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - fields_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Literal_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression.Literal fields = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_fields(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* Expression_Literal_Struct::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.Struct) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression.Literal fields = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_fields_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_fields(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.Struct) - return target; -} - -size_t Expression_Literal_Struct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.Struct) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression.Literal fields = 1; - total_size += 1UL * this->_internal_fields_size(); - for (const auto& msg : this->fields_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_Struct::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Literal_Struct::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_Struct::GetClassData() const { return &_class_data_; } - -void Expression_Literal_Struct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Literal_Struct::MergeFrom(const Expression_Literal_Struct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.Struct) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - fields_.MergeFrom(from.fields_); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Literal_Struct::CopyFrom(const Expression_Literal_Struct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.Struct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Literal_Struct::IsInitialized() const { - return true; -} - -void Expression_Literal_Struct::InternalSwap(Expression_Literal_Struct* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - fields_.InternalSwap(&other->fields_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_Struct::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[8]); -} - -// =================================================================== - -class Expression_Literal_List::_Internal { - public: -}; - -Expression_Literal_List::Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - values_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal.List) -} -Expression_Literal_List::Expression_Literal_List(const Expression_Literal_List& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - values_(from.values_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal.List) -} - -inline void Expression_Literal_List::SharedCtor() { -} - -Expression_Literal_List::~Expression_Literal_List() { - // @@protoc_insertion_point(destructor:substrait.Expression.Literal.List) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Literal_List::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_Literal_List::ArenaDtor(void* object) { - Expression_Literal_List* _this = reinterpret_cast< Expression_Literal_List* >(object); - (void)_this; -} -void Expression_Literal_List::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Literal_List::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Literal_List::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal.List) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - values_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Literal_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression.Literal values = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_values(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* Expression_Literal_List::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal.List) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression.Literal values = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_values_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_values(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal.List) - return target; -} - -size_t Expression_Literal_List::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal.List) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression.Literal values = 1; - total_size += 1UL * this->_internal_values_size(); - for (const auto& msg : this->values_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal_List::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Literal_List::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal_List::GetClassData() const { return &_class_data_; } - -void Expression_Literal_List::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Literal_List::MergeFrom(const Expression_Literal_List& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal.List) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - values_.MergeFrom(from.values_); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Literal_List::CopyFrom(const Expression_Literal_List& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal.List) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Literal_List::IsInitialized() const { - return true; -} - -void Expression_Literal_List::InternalSwap(Expression_Literal_List* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - values_.InternalSwap(&other->values_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal_List::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[9]); -} - -// =================================================================== - -class Expression_Literal::_Internal { - public: - static const ::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month(const Expression_Literal* msg); - static const ::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second(const Expression_Literal* msg); - static const ::substrait::Expression_Literal_VarChar& var_char(const Expression_Literal* msg); - static const ::substrait::Expression_Literal_Decimal& decimal(const Expression_Literal* msg); - static const ::substrait::Expression_Literal_Struct& struct_(const Expression_Literal* msg); - static const ::substrait::Expression_Literal_Map& map(const Expression_Literal* msg); - static const ::substrait::Type& null(const Expression_Literal* msg); - static const ::substrait::Expression_Literal_List& list(const Expression_Literal* msg); - static const ::substrait::Type_List& empty_list(const Expression_Literal* msg); - static const ::substrait::Type_Map& empty_map(const Expression_Literal* msg); -}; - -const ::substrait::Expression_Literal_IntervalYearToMonth& -Expression_Literal::_Internal::interval_year_to_month(const Expression_Literal* msg) { - return *msg->literal_type_.interval_year_to_month_; -} -const ::substrait::Expression_Literal_IntervalDayToSecond& -Expression_Literal::_Internal::interval_day_to_second(const Expression_Literal* msg) { - return *msg->literal_type_.interval_day_to_second_; -} -const ::substrait::Expression_Literal_VarChar& -Expression_Literal::_Internal::var_char(const Expression_Literal* msg) { - return *msg->literal_type_.var_char_; -} -const ::substrait::Expression_Literal_Decimal& -Expression_Literal::_Internal::decimal(const Expression_Literal* msg) { - return *msg->literal_type_.decimal_; -} -const ::substrait::Expression_Literal_Struct& -Expression_Literal::_Internal::struct_(const Expression_Literal* msg) { - return *msg->literal_type_.struct__; -} -const ::substrait::Expression_Literal_Map& -Expression_Literal::_Internal::map(const Expression_Literal* msg) { - return *msg->literal_type_.map_; -} -const ::substrait::Type& -Expression_Literal::_Internal::null(const Expression_Literal* msg) { - return *msg->literal_type_.null_; -} -const ::substrait::Expression_Literal_List& -Expression_Literal::_Internal::list(const Expression_Literal* msg) { - return *msg->literal_type_.list_; -} -const ::substrait::Type_List& -Expression_Literal::_Internal::empty_list(const Expression_Literal* msg) { - return *msg->literal_type_.empty_list_; -} -const ::substrait::Type_Map& -Expression_Literal::_Internal::empty_map(const Expression_Literal* msg) { - return *msg->literal_type_.empty_map_; -} -void Expression_Literal::set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_literal_type(); - if (interval_year_to_month) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_IntervalYearToMonth>::GetOwningArena(interval_year_to_month); - if (message_arena != submessage_arena) { - interval_year_to_month = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interval_year_to_month, submessage_arena); - } - set_has_interval_year_to_month(); - literal_type_.interval_year_to_month_ = interval_year_to_month; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.interval_year_to_month) -} -void Expression_Literal::set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_literal_type(); - if (interval_day_to_second) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_IntervalDayToSecond>::GetOwningArena(interval_day_to_second); - if (message_arena != submessage_arena) { - interval_day_to_second = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interval_day_to_second, submessage_arena); - } - set_has_interval_day_to_second(); - literal_type_.interval_day_to_second_ = interval_day_to_second; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.interval_day_to_second) -} -void Expression_Literal::set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_literal_type(); - if (var_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_VarChar>::GetOwningArena(var_char); - if (message_arena != submessage_arena) { - var_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, var_char, submessage_arena); - } - set_has_var_char(); - literal_type_.var_char_ = var_char; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.var_char) -} -void Expression_Literal::set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_literal_type(); - if (decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Decimal>::GetOwningArena(decimal); - if (message_arena != submessage_arena) { - decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, decimal, submessage_arena); - } - set_has_decimal(); - literal_type_.decimal_ = decimal; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.decimal) -} -void Expression_Literal::set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_literal_type(); - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Struct>::GetOwningArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - set_has_struct_(); - literal_type_.struct__ = struct_; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.struct) -} -void Expression_Literal::set_allocated_map(::substrait::Expression_Literal_Map* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_literal_type(); - if (map) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_Map>::GetOwningArena(map); - if (message_arena != submessage_arena) { - map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, map, submessage_arena); - } - set_has_map(); - literal_type_.map_ = map; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.map) -} -void Expression_Literal::set_allocated_null(::substrait::Type* null) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_literal_type(); - if (null) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(null)); - if (message_arena != submessage_arena) { - null = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, null, submessage_arena); - } - set_has_null(); - literal_type_.null_ = null; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.null) -} -void Expression_Literal::clear_null() { - if (_internal_has_null()) { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.null_; - } - clear_has_literal_type(); - } -} -void Expression_Literal::set_allocated_list(::substrait::Expression_Literal_List* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_literal_type(); - if (list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal_List>::GetOwningArena(list); - if (message_arena != submessage_arena) { - list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, list, submessage_arena); - } - set_has_list(); - literal_type_.list_ = list; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.list) -} -void Expression_Literal::set_allocated_empty_list(::substrait::Type_List* empty_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_literal_type(); - if (empty_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_list)); - if (message_arena != submessage_arena) { - empty_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, empty_list, submessage_arena); - } - set_has_empty_list(); - literal_type_.empty_list_ = empty_list; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.empty_list) -} -void Expression_Literal::clear_empty_list() { - if (_internal_has_empty_list()) { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.empty_list_; - } - clear_has_literal_type(); - } -} -void Expression_Literal::set_allocated_empty_map(::substrait::Type_Map* empty_map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_literal_type(); - if (empty_map) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(empty_map)); - if (message_arena != submessage_arena) { - empty_map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, empty_map, submessage_arena); - } - set_has_empty_map(); - literal_type_.empty_map_ = empty_map; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.empty_map) -} -void Expression_Literal::clear_empty_map() { - if (_internal_has_empty_map()) { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.empty_map_; - } - clear_has_literal_type(); - } -} -Expression_Literal::Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Literal) -} -Expression_Literal::Expression_Literal(const Expression_Literal& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - nullable_ = from.nullable_; - clear_has_literal_type(); - switch (from.literal_type_case()) { - case kBoolean: { - _internal_set_boolean(from._internal_boolean()); - break; - } - case kI8: { - _internal_set_i8(from._internal_i8()); - break; - } - case kI16: { - _internal_set_i16(from._internal_i16()); - break; - } - case kI32: { - _internal_set_i32(from._internal_i32()); - break; - } - case kI64: { - _internal_set_i64(from._internal_i64()); - break; - } - case kFp32: { - _internal_set_fp32(from._internal_fp32()); - break; - } - case kFp64: { - _internal_set_fp64(from._internal_fp64()); - break; - } - case kString: { - _internal_set_string(from._internal_string()); - break; - } - case kBinary: { - _internal_set_binary(from._internal_binary()); - break; - } - case kTimestamp: { - _internal_set_timestamp(from._internal_timestamp()); - break; - } - case kDate: { - _internal_set_date(from._internal_date()); - break; - } - case kTime: { - _internal_set_time(from._internal_time()); - break; - } - case kIntervalYearToMonth: { - _internal_mutable_interval_year_to_month()->::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); - break; - } - case kIntervalDayToSecond: { - _internal_mutable_interval_day_to_second()->::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); - break; - } - case kFixedChar: { - _internal_set_fixed_char(from._internal_fixed_char()); - break; - } - case kVarChar: { - _internal_mutable_var_char()->::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char()); - break; - } - case kFixedBinary: { - _internal_set_fixed_binary(from._internal_fixed_binary()); - break; - } - case kDecimal: { - _internal_mutable_decimal()->::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal()); - break; - } - case kStruct: { - _internal_mutable_struct_()->::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); - break; - } - case kMap: { - _internal_mutable_map()->::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); - break; - } - case kTimestampTz: { - _internal_set_timestamp_tz(from._internal_timestamp_tz()); - break; - } - case kUuid: { - _internal_set_uuid(from._internal_uuid()); - break; - } - case kNull: { - _internal_mutable_null()->::substrait::Type::MergeFrom(from._internal_null()); - break; - } - case kList: { - _internal_mutable_list()->::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); - break; - } - case kEmptyList: { - _internal_mutable_empty_list()->::substrait::Type_List::MergeFrom(from._internal_empty_list()); - break; - } - case kEmptyMap: { - _internal_mutable_empty_map()->::substrait::Type_Map::MergeFrom(from._internal_empty_map()); - break; - } - case LITERAL_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Literal) -} - -inline void Expression_Literal::SharedCtor() { -nullable_ = false; -clear_has_literal_type(); -} - -Expression_Literal::~Expression_Literal() { - // @@protoc_insertion_point(destructor:substrait.Expression.Literal) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Literal::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_literal_type()) { - clear_literal_type(); - } -} - -void Expression_Literal::ArenaDtor(void* object) { - Expression_Literal* _this = reinterpret_cast< Expression_Literal* >(object); - (void)_this; -} -void Expression_Literal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Literal::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Literal::clear_literal_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.Literal) - switch (literal_type_case()) { - case kBoolean: { - // No need to clear - break; - } - case kI8: { - // No need to clear - break; - } - case kI16: { - // No need to clear - break; - } - case kI32: { - // No need to clear - break; - } - case kI64: { - // No need to clear - break; - } - case kFp32: { - // No need to clear - break; - } - case kFp64: { - // No need to clear - break; - } - case kString: { - literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kBinary: { - literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kTimestamp: { - // No need to clear - break; - } - case kDate: { - // No need to clear - break; - } - case kTime: { - // No need to clear - break; - } - case kIntervalYearToMonth: { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.interval_year_to_month_; - } - break; - } - case kIntervalDayToSecond: { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.interval_day_to_second_; - } - break; - } - case kFixedChar: { - literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kVarChar: { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.var_char_; - } - break; - } - case kFixedBinary: { - literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kDecimal: { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.decimal_; - } - break; - } - case kStruct: { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.struct__; - } - break; - } - case kMap: { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.map_; - } - break; - } - case kTimestampTz: { - // No need to clear - break; - } - case kUuid: { - literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kNull: { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.null_; - } - break; - } - case kList: { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.list_; - } - break; - } - case kEmptyList: { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.empty_list_; - } - break; - } - case kEmptyMap: { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.empty_map_; - } - break; - } - case LITERAL_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = LITERAL_TYPE_NOT_SET; -} - - -void Expression_Literal::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Literal) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - nullable_ = false; - clear_literal_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Literal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // bool boolean = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _internal_set_boolean(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 i8 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - _internal_set_i8(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 i16 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _internal_set_i16(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 i32 = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - _internal_set_i32(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int64 i64 = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - _internal_set_i64(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // float fp32 = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 85)) { - _internal_set_fp32(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); - ptr += sizeof(float); - } else - goto handle_unusual; - continue; - // double fp64 = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 89)) { - _internal_set_fp64(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr)); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // string string = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - auto str = _internal_mutable_string(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.string")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bytes binary = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - auto str = _internal_mutable_binary(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int64 timestamp = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { - _internal_set_timestamp(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 date = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 128)) { - _internal_set_date(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int64 time = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 136)) { - _internal_set_time(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - ptr = ctx->ParseMessage(_internal_mutable_interval_year_to_month(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { - ptr = ctx->ParseMessage(_internal_mutable_interval_day_to_second(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string fixed_char = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - auto str = _internal_mutable_fixed_char(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.Literal.fixed_char")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Literal.VarChar var_char = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { - ptr = ctx->ParseMessage(_internal_mutable_var_char(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bytes fixed_binary = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - auto str = _internal_mutable_fixed_binary(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Literal.Decimal decimal = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { - ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Literal.Struct struct = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Literal.Map map = 26; - case 26: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 210)) { - ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int64 timestamp_tz = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 216)) { - _internal_set_timestamp_tz(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bytes uuid = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { - auto str = _internal_mutable_uuid(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type null = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { - ptr = ctx->ParseMessage(_internal_mutable_null(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Literal.List list = 30; - case 30: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { - ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.List empty_list = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 250)) { - ptr = ctx->ParseMessage(_internal_mutable_empty_list(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Map empty_map = 32; - case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { - ptr = ctx->ParseMessage(_internal_mutable_empty_map(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool nullable = 50; - case 50: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 144)) { - nullable_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_Literal::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Literal) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // bool boolean = 1; - if (_internal_has_boolean()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(1, this->_internal_boolean(), target); - } - - // int32 i8 = 2; - if (_internal_has_i8()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_i8(), target); - } - - // int32 i16 = 3; - if (_internal_has_i16()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_i16(), target); - } - - // int32 i32 = 5; - if (_internal_has_i32()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(5, this->_internal_i32(), target); - } - - // int64 i64 = 7; - if (_internal_has_i64()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(7, this->_internal_i64(), target); - } - - // float fp32 = 10; - if (_internal_has_fp32()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_fp32(), target); - } - - // double fp64 = 11; - if (_internal_has_fp64()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(11, this->_internal_fp64(), target); - } - - // string string = 12; - if (_internal_has_string()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_string().data(), static_cast(this->_internal_string().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Expression.Literal.string"); - target = stream->WriteStringMaybeAliased( - 12, this->_internal_string(), target); - } - - // bytes binary = 13; - if (_internal_has_binary()) { - target = stream->WriteBytesMaybeAliased( - 13, this->_internal_binary(), target); - } - - // int64 timestamp = 14; - if (_internal_has_timestamp()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(14, this->_internal_timestamp(), target); - } - - // int32 date = 16; - if (_internal_has_date()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(16, this->_internal_date(), target); - } - - // int64 time = 17; - if (_internal_has_time()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(17, this->_internal_time(), target); - } - - // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; - if (_internal_has_interval_year_to_month()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 19, _Internal::interval_year_to_month(this), target, stream); - } - - // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; - if (_internal_has_interval_day_to_second()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 20, _Internal::interval_day_to_second(this), target, stream); - } - - // string fixed_char = 21; - if (_internal_has_fixed_char()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_fixed_char().data(), static_cast(this->_internal_fixed_char().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Expression.Literal.fixed_char"); - target = stream->WriteStringMaybeAliased( - 21, this->_internal_fixed_char(), target); - } - - // .substrait.Expression.Literal.VarChar var_char = 22; - if (_internal_has_var_char()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 22, _Internal::var_char(this), target, stream); - } - - // bytes fixed_binary = 23; - if (_internal_has_fixed_binary()) { - target = stream->WriteBytesMaybeAliased( - 23, this->_internal_fixed_binary(), target); - } - - // .substrait.Expression.Literal.Decimal decimal = 24; - if (_internal_has_decimal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 24, _Internal::decimal(this), target, stream); - } - - // .substrait.Expression.Literal.Struct struct = 25; - if (_internal_has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 25, _Internal::struct_(this), target, stream); - } - - // .substrait.Expression.Literal.Map map = 26; - if (_internal_has_map()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 26, _Internal::map(this), target, stream); - } - - // int64 timestamp_tz = 27; - if (_internal_has_timestamp_tz()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(27, this->_internal_timestamp_tz(), target); - } - - // bytes uuid = 28; - if (_internal_has_uuid()) { - target = stream->WriteBytesMaybeAliased( - 28, this->_internal_uuid(), target); - } - - // .substrait.Type null = 29; - if (_internal_has_null()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 29, _Internal::null(this), target, stream); - } - - // .substrait.Expression.Literal.List list = 30; - if (_internal_has_list()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 30, _Internal::list(this), target, stream); - } - - // .substrait.Type.List empty_list = 31; - if (_internal_has_empty_list()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 31, _Internal::empty_list(this), target, stream); - } - - // .substrait.Type.Map empty_map = 32; - if (_internal_has_empty_map()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 32, _Internal::empty_map(this), target, stream); - } - - // bool nullable = 50; - if (this->_internal_nullable() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(50, this->_internal_nullable(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Literal) - return target; -} - -size_t Expression_Literal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Literal) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // bool nullable = 50; - if (this->_internal_nullable() != 0) { - total_size += 2 + 1; - } - - switch (literal_type_case()) { - // bool boolean = 1; - case kBoolean: { - total_size += 1 + 1; - break; - } - // int32 i8 = 2; - case kI8: { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i8()); - break; - } - // int32 i16 = 3; - case kI16: { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i16()); - break; - } - // int32 i32 = 5; - case kI32: { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_i32()); - break; - } - // int64 i64 = 7; - case kI64: { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_i64()); - break; - } - // float fp32 = 10; - case kFp32: { - total_size += 1 + 4; - break; - } - // double fp64 = 11; - case kFp64: { - total_size += 1 + 8; - break; - } - // string string = 12; - case kString: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_string()); - break; - } - // bytes binary = 13; - case kBinary: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_binary()); - break; - } - // int64 timestamp = 14; - case kTimestamp: { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp()); - break; - } - // int32 date = 16; - case kDate: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_date()); - break; - } - // int64 time = 17; - case kTime: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_time()); - break; - } - // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; - case kIntervalYearToMonth: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.interval_year_to_month_); - break; - } - // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; - case kIntervalDayToSecond: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.interval_day_to_second_); - break; - } - // string fixed_char = 21; - case kFixedChar: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_fixed_char()); - break; - } - // .substrait.Expression.Literal.VarChar var_char = 22; - case kVarChar: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.var_char_); - break; - } - // bytes fixed_binary = 23; - case kFixedBinary: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_fixed_binary()); - break; - } - // .substrait.Expression.Literal.Decimal decimal = 24; - case kDecimal: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.decimal_); - break; - } - // .substrait.Expression.Literal.Struct struct = 25; - case kStruct: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.struct__); - break; - } - // .substrait.Expression.Literal.Map map = 26; - case kMap: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.map_); - break; - } - // int64 timestamp_tz = 27; - case kTimestampTz: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64Size( - this->_internal_timestamp_tz()); - break; - } - // bytes uuid = 28; - case kUuid: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_uuid()); - break; - } - // .substrait.Type null = 29; - case kNull: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.null_); - break; - } - // .substrait.Expression.Literal.List list = 30; - case kList: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.list_); - break; - } - // .substrait.Type.List empty_list = 31; - case kEmptyList: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.empty_list_); - break; - } - // .substrait.Type.Map empty_map = 32; - case kEmptyMap: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *literal_type_.empty_map_); - break; - } - case LITERAL_TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Literal::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Literal::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Literal::GetClassData() const { return &_class_data_; } - -void Expression_Literal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Literal::MergeFrom(const Expression_Literal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Literal) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_nullable() != 0) { - _internal_set_nullable(from._internal_nullable()); - } - switch (from.literal_type_case()) { - case kBoolean: { - _internal_set_boolean(from._internal_boolean()); - break; - } - case kI8: { - _internal_set_i8(from._internal_i8()); - break; - } - case kI16: { - _internal_set_i16(from._internal_i16()); - break; - } - case kI32: { - _internal_set_i32(from._internal_i32()); - break; - } - case kI64: { - _internal_set_i64(from._internal_i64()); - break; - } - case kFp32: { - _internal_set_fp32(from._internal_fp32()); - break; - } - case kFp64: { - _internal_set_fp64(from._internal_fp64()); - break; - } - case kString: { - _internal_set_string(from._internal_string()); - break; - } - case kBinary: { - _internal_set_binary(from._internal_binary()); - break; - } - case kTimestamp: { - _internal_set_timestamp(from._internal_timestamp()); - break; - } - case kDate: { - _internal_set_date(from._internal_date()); - break; - } - case kTime: { - _internal_set_time(from._internal_time()); - break; - } - case kIntervalYearToMonth: { - _internal_mutable_interval_year_to_month()->::substrait::Expression_Literal_IntervalYearToMonth::MergeFrom(from._internal_interval_year_to_month()); - break; - } - case kIntervalDayToSecond: { - _internal_mutable_interval_day_to_second()->::substrait::Expression_Literal_IntervalDayToSecond::MergeFrom(from._internal_interval_day_to_second()); - break; - } - case kFixedChar: { - _internal_set_fixed_char(from._internal_fixed_char()); - break; - } - case kVarChar: { - _internal_mutable_var_char()->::substrait::Expression_Literal_VarChar::MergeFrom(from._internal_var_char()); - break; - } - case kFixedBinary: { - _internal_set_fixed_binary(from._internal_fixed_binary()); - break; - } - case kDecimal: { - _internal_mutable_decimal()->::substrait::Expression_Literal_Decimal::MergeFrom(from._internal_decimal()); - break; - } - case kStruct: { - _internal_mutable_struct_()->::substrait::Expression_Literal_Struct::MergeFrom(from._internal_struct_()); - break; - } - case kMap: { - _internal_mutable_map()->::substrait::Expression_Literal_Map::MergeFrom(from._internal_map()); - break; - } - case kTimestampTz: { - _internal_set_timestamp_tz(from._internal_timestamp_tz()); - break; - } - case kUuid: { - _internal_set_uuid(from._internal_uuid()); - break; - } - case kNull: { - _internal_mutable_null()->::substrait::Type::MergeFrom(from._internal_null()); - break; - } - case kList: { - _internal_mutable_list()->::substrait::Expression_Literal_List::MergeFrom(from._internal_list()); - break; - } - case kEmptyList: { - _internal_mutable_empty_list()->::substrait::Type_List::MergeFrom(from._internal_empty_list()); - break; - } - case kEmptyMap: { - _internal_mutable_empty_map()->::substrait::Type_Map::MergeFrom(from._internal_empty_map()); - break; - } - case LITERAL_TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Literal::CopyFrom(const Expression_Literal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Literal) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Literal::IsInitialized() const { - return true; -} - -void Expression_Literal::InternalSwap(Expression_Literal* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(nullable_, other->nullable_); - swap(literal_type_, other->literal_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Literal::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[10]); -} - -// =================================================================== - -class Expression_ScalarFunction::_Internal { - public: - static const ::substrait::Type& output_type(const Expression_ScalarFunction* msg); -}; - -const ::substrait::Type& -Expression_ScalarFunction::_Internal::output_type(const Expression_ScalarFunction* msg) { - return *msg->output_type_; -} -void Expression_ScalarFunction::clear_output_type() { - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; -} -Expression_ScalarFunction::Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - args_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.ScalarFunction) -} -Expression_ScalarFunction::Expression_ScalarFunction(const Expression_ScalarFunction& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - args_(from.args_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_output_type()) { - output_type_ = new ::substrait::Type(*from.output_type_); - } else { - output_type_ = nullptr; - } - function_reference_ = from.function_reference_; - // @@protoc_insertion_point(copy_constructor:substrait.Expression.ScalarFunction) -} - -inline void Expression_ScalarFunction::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&output_type_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&function_reference_) - - reinterpret_cast(&output_type_)) + sizeof(function_reference_)); -} - -Expression_ScalarFunction::~Expression_ScalarFunction() { - // @@protoc_insertion_point(destructor:substrait.Expression.ScalarFunction) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_ScalarFunction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete output_type_; -} - -void Expression_ScalarFunction::ArenaDtor(void* object) { - Expression_ScalarFunction* _this = reinterpret_cast< Expression_ScalarFunction* >(object); - (void)_this; -} -void Expression_ScalarFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_ScalarFunction::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_ScalarFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.ScalarFunction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - args_.Clear(); - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; - function_reference_ = 0u; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_ScalarFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 function_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.Expression args = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_args(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.Type output_type = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_ScalarFunction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ScalarFunction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 function_reference = 1; - if (this->_internal_function_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); - } - - // repeated .substrait.Expression args = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_args_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_args(i), target, stream); - } - - // .substrait.Type output_type = 3; - if (this->_internal_has_output_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::output_type(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ScalarFunction) - return target; -} - -size_t Expression_ScalarFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ScalarFunction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression args = 2; - total_size += 1UL * this->_internal_args_size(); - for (const auto& msg : this->args_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.Type output_type = 3; - if (this->_internal_has_output_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *output_type_); - } - - // uint32 function_reference = 1; - if (this->_internal_function_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ScalarFunction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_ScalarFunction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ScalarFunction::GetClassData() const { return &_class_data_; } - -void Expression_ScalarFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_ScalarFunction::MergeFrom(const Expression_ScalarFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ScalarFunction) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - args_.MergeFrom(from.args_); - if (from._internal_has_output_type()) { - _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); - } - if (from._internal_function_reference() != 0) { - _internal_set_function_reference(from._internal_function_reference()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_ScalarFunction::CopyFrom(const Expression_ScalarFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ScalarFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_ScalarFunction::IsInitialized() const { - return true; -} - -void Expression_ScalarFunction::InternalSwap(Expression_ScalarFunction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - args_.InternalSwap(&other->args_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, function_reference_) - + sizeof(Expression_ScalarFunction::function_reference_) - - PROTOBUF_FIELD_OFFSET(Expression_ScalarFunction, output_type_)>( - reinterpret_cast(&output_type_), - reinterpret_cast(&other->output_type_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_ScalarFunction::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[11]); -} - -// =================================================================== - -class Expression_WindowFunction_Bound_Preceding::_Internal { - public: -}; - -Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Preceding) -} -Expression_WindowFunction_Bound_Preceding::Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - offset_ = from.offset_; - // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Preceding) -} - -inline void Expression_WindowFunction_Bound_Preceding::SharedCtor() { -offset_ = int64_t{0}; -} - -Expression_WindowFunction_Bound_Preceding::~Expression_WindowFunction_Bound_Preceding() { - // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.Preceding) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_WindowFunction_Bound_Preceding::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_WindowFunction_Bound_Preceding::ArenaDtor(void* object) { - Expression_WindowFunction_Bound_Preceding* _this = reinterpret_cast< Expression_WindowFunction_Bound_Preceding* >(object); - (void)_this; -} -void Expression_WindowFunction_Bound_Preceding::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_WindowFunction_Bound_Preceding::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_WindowFunction_Bound_Preceding::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Preceding) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - offset_ = int64_t{0}; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_WindowFunction_Bound_Preceding::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int64 offset = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_WindowFunction_Bound_Preceding::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Preceding) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int64 offset = 1; - if (this->_internal_offset() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound.Preceding) - return target; -} - -size_t Expression_WindowFunction_Bound_Preceding::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Preceding) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int64 offset = 1; - if (this->_internal_offset() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_Preceding::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_WindowFunction_Bound_Preceding::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_Preceding::GetClassData() const { return &_class_data_; } - -void Expression_WindowFunction_Bound_Preceding::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_WindowFunction_Bound_Preceding::MergeFrom(const Expression_WindowFunction_Bound_Preceding& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Preceding) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_offset() != 0) { - _internal_set_offset(from._internal_offset()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_WindowFunction_Bound_Preceding::CopyFrom(const Expression_WindowFunction_Bound_Preceding& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.Preceding) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_WindowFunction_Bound_Preceding::IsInitialized() const { - return true; -} - -void Expression_WindowFunction_Bound_Preceding::InternalSwap(Expression_WindowFunction_Bound_Preceding* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(offset_, other->offset_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Preceding::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[12]); -} - -// =================================================================== - -class Expression_WindowFunction_Bound_Following::_Internal { - public: -}; - -Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Following) -} -Expression_WindowFunction_Bound_Following::Expression_WindowFunction_Bound_Following(const Expression_WindowFunction_Bound_Following& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - offset_ = from.offset_; - // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Following) -} - -inline void Expression_WindowFunction_Bound_Following::SharedCtor() { -offset_ = int64_t{0}; -} - -Expression_WindowFunction_Bound_Following::~Expression_WindowFunction_Bound_Following() { - // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound.Following) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_WindowFunction_Bound_Following::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_WindowFunction_Bound_Following::ArenaDtor(void* object) { - Expression_WindowFunction_Bound_Following* _this = reinterpret_cast< Expression_WindowFunction_Bound_Following* >(object); - (void)_this; -} -void Expression_WindowFunction_Bound_Following::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_WindowFunction_Bound_Following::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_WindowFunction_Bound_Following::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound.Following) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - offset_ = int64_t{0}; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_WindowFunction_Bound_Following::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int64 offset = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_WindowFunction_Bound_Following::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound.Following) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int64 offset = 1; - if (this->_internal_offset() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_offset(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound.Following) - return target; -} - -size_t Expression_WindowFunction_Bound_Following::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound.Following) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int64 offset = 1; - if (this->_internal_offset() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_Following::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_WindowFunction_Bound_Following::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_Following::GetClassData() const { return &_class_data_; } - -void Expression_WindowFunction_Bound_Following::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_WindowFunction_Bound_Following::MergeFrom(const Expression_WindowFunction_Bound_Following& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound.Following) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_offset() != 0) { - _internal_set_offset(from._internal_offset()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_WindowFunction_Bound_Following::CopyFrom(const Expression_WindowFunction_Bound_Following& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound.Following) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_WindowFunction_Bound_Following::IsInitialized() const { - return true; -} - -void Expression_WindowFunction_Bound_Following::InternalSwap(Expression_WindowFunction_Bound_Following* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(offset_, other->offset_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Following::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[13]); -} - -// =================================================================== - -class Expression_WindowFunction_Bound_CurrentRow::_Internal { - public: -}; - -Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { - // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.CurrentRow) -} -Expression_WindowFunction_Bound_CurrentRow::Expression_WindowFunction_Bound_CurrentRow(const Expression_WindowFunction_Bound_CurrentRow& from) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.CurrentRow) -} - - - - - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_CurrentRow::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_CurrentRow::GetClassData() const { return &_class_data_; } - - - - - - - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_CurrentRow::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[14]); -} - -// =================================================================== - -class Expression_WindowFunction_Bound_Unbounded::_Internal { - public: -}; - -Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { - // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound.Unbounded) -} -Expression_WindowFunction_Bound_Unbounded::Expression_WindowFunction_Bound_Unbounded(const Expression_WindowFunction_Bound_Unbounded& from) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound.Unbounded) -} - - - - - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound_Unbounded::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound_Unbounded::GetClassData() const { return &_class_data_; } - - - - - - - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound_Unbounded::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[15]); -} - -// =================================================================== - -class Expression_WindowFunction_Bound::_Internal { - public: - static const ::substrait::Expression_WindowFunction_Bound_Preceding& preceding(const Expression_WindowFunction_Bound* msg); - static const ::substrait::Expression_WindowFunction_Bound_Following& following(const Expression_WindowFunction_Bound* msg); - static const ::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row(const Expression_WindowFunction_Bound* msg); - static const ::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded(const Expression_WindowFunction_Bound* msg); -}; - -const ::substrait::Expression_WindowFunction_Bound_Preceding& -Expression_WindowFunction_Bound::_Internal::preceding(const Expression_WindowFunction_Bound* msg) { - return *msg->kind_.preceding_; -} -const ::substrait::Expression_WindowFunction_Bound_Following& -Expression_WindowFunction_Bound::_Internal::following(const Expression_WindowFunction_Bound* msg) { - return *msg->kind_.following_; -} -const ::substrait::Expression_WindowFunction_Bound_CurrentRow& -Expression_WindowFunction_Bound::_Internal::current_row(const Expression_WindowFunction_Bound* msg) { - return *msg->kind_.current_row_; -} -const ::substrait::Expression_WindowFunction_Bound_Unbounded& -Expression_WindowFunction_Bound::_Internal::unbounded(const Expression_WindowFunction_Bound* msg) { - return *msg->kind_.unbounded_; -} -void Expression_WindowFunction_Bound::set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (preceding) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Preceding>::GetOwningArena(preceding); - if (message_arena != submessage_arena) { - preceding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, preceding, submessage_arena); - } - set_has_preceding(); - kind_.preceding_ = preceding; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.preceding) -} -void Expression_WindowFunction_Bound::set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (following) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Following>::GetOwningArena(following); - if (message_arena != submessage_arena) { - following = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, following, submessage_arena); - } - set_has_following(); - kind_.following_ = following; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.following) -} -void Expression_WindowFunction_Bound::set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (current_row) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_CurrentRow>::GetOwningArena(current_row); - if (message_arena != submessage_arena) { - current_row = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, current_row, submessage_arena); - } - set_has_current_row(); - kind_.current_row_ = current_row; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.current_row) -} -void Expression_WindowFunction_Bound::set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (unbounded) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound_Unbounded>::GetOwningArena(unbounded); - if (message_arena != submessage_arena) { - unbounded = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, unbounded, submessage_arena); - } - set_has_unbounded(); - kind_.unbounded_ = unbounded; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.Bound.unbounded) -} -Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction.Bound) -} -Expression_WindowFunction_Bound::Expression_WindowFunction_Bound(const Expression_WindowFunction_Bound& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_kind(); - switch (from.kind_case()) { - case kPreceding: { - _internal_mutable_preceding()->::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding()); - break; - } - case kFollowing: { - _internal_mutable_following()->::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following()); - break; - } - case kCurrentRow: { - _internal_mutable_current_row()->::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row()); - break; - } - case kUnbounded: { - _internal_mutable_unbounded()->::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded()); - break; - } - case KIND_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction.Bound) -} - -inline void Expression_WindowFunction_Bound::SharedCtor() { -clear_has_kind(); -} - -Expression_WindowFunction_Bound::~Expression_WindowFunction_Bound() { - // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction.Bound) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_WindowFunction_Bound::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_kind()) { - clear_kind(); - } -} - -void Expression_WindowFunction_Bound::ArenaDtor(void* object) { - Expression_WindowFunction_Bound* _this = reinterpret_cast< Expression_WindowFunction_Bound* >(object); - (void)_this; -} -void Expression_WindowFunction_Bound::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_WindowFunction_Bound::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_WindowFunction_Bound::clear_kind() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.WindowFunction.Bound) - switch (kind_case()) { - case kPreceding: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.preceding_; - } - break; - } - case kFollowing: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.following_; - } - break; - } - case kCurrentRow: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.current_row_; - } - break; - } - case kUnbounded: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.unbounded_; - } - break; - } - case KIND_NOT_SET: { - break; - } - } - _oneof_case_[0] = KIND_NOT_SET; -} - - -void Expression_WindowFunction_Bound::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction.Bound) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_kind(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_WindowFunction_Bound::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_preceding(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.WindowFunction.Bound.Following following = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_following(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_current_row(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_unbounded(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_WindowFunction_Bound::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction.Bound) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; - if (_internal_has_preceding()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::preceding(this), target, stream); - } - - // .substrait.Expression.WindowFunction.Bound.Following following = 2; - if (_internal_has_following()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::following(this), target, stream); - } - - // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; - if (_internal_has_current_row()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::current_row(this), target, stream); - } - - // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; - if (_internal_has_unbounded()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::unbounded(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction.Bound) - return target; -} - -size_t Expression_WindowFunction_Bound::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction.Bound) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (kind_case()) { - // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; - case kPreceding: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.preceding_); - break; - } - // .substrait.Expression.WindowFunction.Bound.Following following = 2; - case kFollowing: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.following_); - break; - } - // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; - case kCurrentRow: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.current_row_); - break; - } - // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; - case kUnbounded: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.unbounded_); - break; - } - case KIND_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction_Bound::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_WindowFunction_Bound::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction_Bound::GetClassData() const { return &_class_data_; } - -void Expression_WindowFunction_Bound::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_WindowFunction_Bound::MergeFrom(const Expression_WindowFunction_Bound& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction.Bound) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.kind_case()) { - case kPreceding: { - _internal_mutable_preceding()->::substrait::Expression_WindowFunction_Bound_Preceding::MergeFrom(from._internal_preceding()); - break; - } - case kFollowing: { - _internal_mutable_following()->::substrait::Expression_WindowFunction_Bound_Following::MergeFrom(from._internal_following()); - break; - } - case kCurrentRow: { - _internal_mutable_current_row()->::substrait::Expression_WindowFunction_Bound_CurrentRow::MergeFrom(from._internal_current_row()); - break; - } - case kUnbounded: { - _internal_mutable_unbounded()->::substrait::Expression_WindowFunction_Bound_Unbounded::MergeFrom(from._internal_unbounded()); - break; - } - case KIND_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_WindowFunction_Bound::CopyFrom(const Expression_WindowFunction_Bound& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction.Bound) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_WindowFunction_Bound::IsInitialized() const { - return true; -} - -void Expression_WindowFunction_Bound::InternalSwap(Expression_WindowFunction_Bound* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(kind_, other->kind_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction_Bound::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[16]); -} - -// =================================================================== - -class Expression_WindowFunction::_Internal { - public: - static const ::substrait::Expression_WindowFunction_Bound& upper_bound(const Expression_WindowFunction* msg); - static const ::substrait::Expression_WindowFunction_Bound& lower_bound(const Expression_WindowFunction* msg); - static const ::substrait::Type& output_type(const Expression_WindowFunction* msg); -}; - -const ::substrait::Expression_WindowFunction_Bound& -Expression_WindowFunction::_Internal::upper_bound(const Expression_WindowFunction* msg) { - return *msg->upper_bound_; -} -const ::substrait::Expression_WindowFunction_Bound& -Expression_WindowFunction::_Internal::lower_bound(const Expression_WindowFunction* msg) { - return *msg->lower_bound_; -} -const ::substrait::Type& -Expression_WindowFunction::_Internal::output_type(const Expression_WindowFunction* msg) { - return *msg->output_type_; -} -void Expression_WindowFunction::clear_output_type() { - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; -} -Expression_WindowFunction::Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - partitions_(arena), - sorts_(arena), - args_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.WindowFunction) -} -Expression_WindowFunction::Expression_WindowFunction(const Expression_WindowFunction& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - partitions_(from.partitions_), - sorts_(from.sorts_), - args_(from.args_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_upper_bound()) { - upper_bound_ = new ::substrait::Expression_WindowFunction_Bound(*from.upper_bound_); - } else { - upper_bound_ = nullptr; - } - if (from._internal_has_lower_bound()) { - lower_bound_ = new ::substrait::Expression_WindowFunction_Bound(*from.lower_bound_); - } else { - lower_bound_ = nullptr; - } - if (from._internal_has_output_type()) { - output_type_ = new ::substrait::Type(*from.output_type_); - } else { - output_type_ = nullptr; - } - ::memcpy(&function_reference_, &from.function_reference_, - static_cast(reinterpret_cast(&phase_) - - reinterpret_cast(&function_reference_)) + sizeof(phase_)); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.WindowFunction) -} - -inline void Expression_WindowFunction::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&upper_bound_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&phase_) - - reinterpret_cast(&upper_bound_)) + sizeof(phase_)); -} - -Expression_WindowFunction::~Expression_WindowFunction() { - // @@protoc_insertion_point(destructor:substrait.Expression.WindowFunction) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_WindowFunction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete upper_bound_; - if (this != internal_default_instance()) delete lower_bound_; - if (this != internal_default_instance()) delete output_type_; -} - -void Expression_WindowFunction::ArenaDtor(void* object) { - Expression_WindowFunction* _this = reinterpret_cast< Expression_WindowFunction* >(object); - (void)_this; -} -void Expression_WindowFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_WindowFunction::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_WindowFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.WindowFunction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - partitions_.Clear(); - sorts_.Clear(); - args_.Clear(); - if (GetArenaForAllocation() == nullptr && upper_bound_ != nullptr) { - delete upper_bound_; - } - upper_bound_ = nullptr; - if (GetArenaForAllocation() == nullptr && lower_bound_ != nullptr) { - delete lower_bound_; - } - lower_bound_ = nullptr; - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; - ::memset(&function_reference_, 0, static_cast( - reinterpret_cast(&phase_) - - reinterpret_cast(&function_reference_)) + sizeof(phase_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_WindowFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 function_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.Expression partitions = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_partitions(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // repeated .substrait.SortField sorts = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_sorts(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.Expression.WindowFunction.Bound upper_bound = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_upper_bound(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.WindowFunction.Bound lower_bound = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_lower_bound(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.AggregationPhase phase = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_phase(static_cast<::substrait::AggregationPhase>(val)); - } else - goto handle_unusual; - continue; - // .substrait.Type output_type = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.Expression args = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_args(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<66>(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* Expression_WindowFunction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.WindowFunction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 function_reference = 1; - if (this->_internal_function_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); - } - - // repeated .substrait.Expression partitions = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_partitions_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_partitions(i), target, stream); - } - - // repeated .substrait.SortField sorts = 3; - for (unsigned int i = 0, - n = static_cast(this->_internal_sorts_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, this->_internal_sorts(i), target, stream); - } - - // .substrait.Expression.WindowFunction.Bound upper_bound = 4; - if (this->_internal_has_upper_bound()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::upper_bound(this), target, stream); - } - - // .substrait.Expression.WindowFunction.Bound lower_bound = 5; - if (this->_internal_has_lower_bound()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::lower_bound(this), target, stream); - } - - // .substrait.AggregationPhase phase = 6; - if (this->_internal_phase() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 6, this->_internal_phase(), target); - } - - // .substrait.Type output_type = 7; - if (this->_internal_has_output_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 7, _Internal::output_type(this), target, stream); - } - - // repeated .substrait.Expression args = 8; - for (unsigned int i = 0, - n = static_cast(this->_internal_args_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(8, this->_internal_args(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.WindowFunction) - return target; -} - -size_t Expression_WindowFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.WindowFunction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression partitions = 2; - total_size += 1UL * this->_internal_partitions_size(); - for (const auto& msg : this->partitions_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .substrait.SortField sorts = 3; - total_size += 1UL * this->_internal_sorts_size(); - for (const auto& msg : this->sorts_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .substrait.Expression args = 8; - total_size += 1UL * this->_internal_args_size(); - for (const auto& msg : this->args_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.Expression.WindowFunction.Bound upper_bound = 4; - if (this->_internal_has_upper_bound()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *upper_bound_); - } - - // .substrait.Expression.WindowFunction.Bound lower_bound = 5; - if (this->_internal_has_lower_bound()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *lower_bound_); - } - - // .substrait.Type output_type = 7; - if (this->_internal_has_output_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *output_type_); - } - - // uint32 function_reference = 1; - if (this->_internal_function_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference()); - } - - // .substrait.AggregationPhase phase = 6; - if (this->_internal_phase() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_WindowFunction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_WindowFunction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_WindowFunction::GetClassData() const { return &_class_data_; } - -void Expression_WindowFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_WindowFunction::MergeFrom(const Expression_WindowFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.WindowFunction) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - partitions_.MergeFrom(from.partitions_); - sorts_.MergeFrom(from.sorts_); - args_.MergeFrom(from.args_); - if (from._internal_has_upper_bound()) { - _internal_mutable_upper_bound()->::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_upper_bound()); - } - if (from._internal_has_lower_bound()) { - _internal_mutable_lower_bound()->::substrait::Expression_WindowFunction_Bound::MergeFrom(from._internal_lower_bound()); - } - if (from._internal_has_output_type()) { - _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); - } - if (from._internal_function_reference() != 0) { - _internal_set_function_reference(from._internal_function_reference()); - } - if (from._internal_phase() != 0) { - _internal_set_phase(from._internal_phase()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_WindowFunction::CopyFrom(const Expression_WindowFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.WindowFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_WindowFunction::IsInitialized() const { - return true; -} - -void Expression_WindowFunction::InternalSwap(Expression_WindowFunction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - partitions_.InternalSwap(&other->partitions_); - sorts_.InternalSwap(&other->sorts_); - args_.InternalSwap(&other->args_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, phase_) - + sizeof(Expression_WindowFunction::phase_) - - PROTOBUF_FIELD_OFFSET(Expression_WindowFunction, upper_bound_)>( - reinterpret_cast(&upper_bound_), - reinterpret_cast(&other->upper_bound_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_WindowFunction::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[17]); -} - -// =================================================================== - -class Expression_IfThen_IfClause::_Internal { - public: - static const ::substrait::Expression& if_(const Expression_IfThen_IfClause* msg); - static const ::substrait::Expression& then(const Expression_IfThen_IfClause* msg); -}; - -const ::substrait::Expression& -Expression_IfThen_IfClause::_Internal::if_(const Expression_IfThen_IfClause* msg) { - return *msg->if__; -} -const ::substrait::Expression& -Expression_IfThen_IfClause::_Internal::then(const Expression_IfThen_IfClause* msg) { - return *msg->then_; -} -Expression_IfThen_IfClause::Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.IfThen.IfClause) -} -Expression_IfThen_IfClause::Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_if_()) { - if__ = new ::substrait::Expression(*from.if__); - } else { - if__ = nullptr; - } - if (from._internal_has_then()) { - then_ = new ::substrait::Expression(*from.then_); - } else { - then_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.IfThen.IfClause) -} - -inline void Expression_IfThen_IfClause::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&if__) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&then_) - - reinterpret_cast(&if__)) + sizeof(then_)); -} - -Expression_IfThen_IfClause::~Expression_IfThen_IfClause() { - // @@protoc_insertion_point(destructor:substrait.Expression.IfThen.IfClause) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_IfThen_IfClause::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete if__; - if (this != internal_default_instance()) delete then_; -} - -void Expression_IfThen_IfClause::ArenaDtor(void* object) { - Expression_IfThen_IfClause* _this = reinterpret_cast< Expression_IfThen_IfClause* >(object); - (void)_this; -} -void Expression_IfThen_IfClause::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_IfThen_IfClause::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_IfThen_IfClause::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.IfThen.IfClause) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && if__ != nullptr) { - delete if__; - } - if__ = nullptr; - if (GetArenaForAllocation() == nullptr && then_ != nullptr) { - delete then_; - } - then_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_IfThen_IfClause::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression if = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression then = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_then(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_IfThen_IfClause::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.IfThen.IfClause) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression if = 1; - if (this->_internal_has_if_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::if_(this), target, stream); - } - - // .substrait.Expression then = 2; - if (this->_internal_has_then()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::then(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.IfThen.IfClause) - return target; -} - -size_t Expression_IfThen_IfClause::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.IfThen.IfClause) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Expression if = 1; - if (this->_internal_has_if_()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *if__); - } - - // .substrait.Expression then = 2; - if (this->_internal_has_then()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *then_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_IfThen_IfClause::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_IfThen_IfClause::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_IfThen_IfClause::GetClassData() const { return &_class_data_; } - -void Expression_IfThen_IfClause::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_IfThen_IfClause::MergeFrom(const Expression_IfThen_IfClause& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.IfThen.IfClause) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_if_()) { - _internal_mutable_if_()->::substrait::Expression::MergeFrom(from._internal_if_()); - } - if (from._internal_has_then()) { - _internal_mutable_then()->::substrait::Expression::MergeFrom(from._internal_then()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_IfThen_IfClause::CopyFrom(const Expression_IfThen_IfClause& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.IfThen.IfClause) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_IfThen_IfClause::IsInitialized() const { - return true; -} - -void Expression_IfThen_IfClause::InternalSwap(Expression_IfThen_IfClause* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, then_) - + sizeof(Expression_IfThen_IfClause::then_) - - PROTOBUF_FIELD_OFFSET(Expression_IfThen_IfClause, if__)>( - reinterpret_cast(&if__), - reinterpret_cast(&other->if__)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen_IfClause::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[18]); -} - -// =================================================================== - -class Expression_IfThen::_Internal { - public: - static const ::substrait::Expression& else_(const Expression_IfThen* msg); -}; - -const ::substrait::Expression& -Expression_IfThen::_Internal::else_(const Expression_IfThen* msg) { - return *msg->else__; -} -Expression_IfThen::Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - ifs_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.IfThen) -} -Expression_IfThen::Expression_IfThen(const Expression_IfThen& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - ifs_(from.ifs_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_else_()) { - else__ = new ::substrait::Expression(*from.else__); - } else { - else__ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.IfThen) -} - -inline void Expression_IfThen::SharedCtor() { -else__ = nullptr; -} - -Expression_IfThen::~Expression_IfThen() { - // @@protoc_insertion_point(destructor:substrait.Expression.IfThen) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_IfThen::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete else__; -} - -void Expression_IfThen::ArenaDtor(void* object) { - Expression_IfThen* _this = reinterpret_cast< Expression_IfThen* >(object); - (void)_this; -} -void Expression_IfThen::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_IfThen::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_IfThen::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.IfThen) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ifs_.Clear(); - if (GetArenaForAllocation() == nullptr && else__ != nullptr) { - delete else__; - } - else__ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_IfThen::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression.IfThen.IfClause ifs = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_ifs(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.Expression else = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_IfThen::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.IfThen) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression.IfThen.IfClause ifs = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_ifs_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_ifs(i), target, stream); - } - - // .substrait.Expression else = 2; - if (this->_internal_has_else_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::else_(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.IfThen) - return target; -} - -size_t Expression_IfThen::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.IfThen) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression.IfThen.IfClause ifs = 1; - total_size += 1UL * this->_internal_ifs_size(); - for (const auto& msg : this->ifs_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.Expression else = 2; - if (this->_internal_has_else_()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *else__); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_IfThen::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_IfThen::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_IfThen::GetClassData() const { return &_class_data_; } - -void Expression_IfThen::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_IfThen::MergeFrom(const Expression_IfThen& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.IfThen) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - ifs_.MergeFrom(from.ifs_); - if (from._internal_has_else_()) { - _internal_mutable_else_()->::substrait::Expression::MergeFrom(from._internal_else_()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_IfThen::CopyFrom(const Expression_IfThen& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.IfThen) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_IfThen::IsInitialized() const { - return true; -} - -void Expression_IfThen::InternalSwap(Expression_IfThen* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ifs_.InternalSwap(&other->ifs_); - swap(else__, other->else__); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_IfThen::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[19]); -} - -// =================================================================== - -class Expression_Cast::_Internal { - public: - static const ::substrait::Type& type(const Expression_Cast* msg); - static const ::substrait::Expression& input(const Expression_Cast* msg); -}; - -const ::substrait::Type& -Expression_Cast::_Internal::type(const Expression_Cast* msg) { - return *msg->type_; -} -const ::substrait::Expression& -Expression_Cast::_Internal::input(const Expression_Cast* msg) { - return *msg->input_; -} -void Expression_Cast::clear_type() { - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; -} -Expression_Cast::Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.Cast) -} -Expression_Cast::Expression_Cast(const Expression_Cast& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_type()) { - type_ = new ::substrait::Type(*from.type_); - } else { - type_ = nullptr; - } - if (from._internal_has_input()) { - input_ = new ::substrait::Expression(*from.input_); - } else { - input_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.Cast) -} - -inline void Expression_Cast::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&input_) - - reinterpret_cast(&type_)) + sizeof(input_)); -} - -Expression_Cast::~Expression_Cast() { - // @@protoc_insertion_point(destructor:substrait.Expression.Cast) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_Cast::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete type_; - if (this != internal_default_instance()) delete input_; -} - -void Expression_Cast::ArenaDtor(void* object) { - Expression_Cast* _this = reinterpret_cast< Expression_Cast* >(object); - (void)_this; -} -void Expression_Cast::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_Cast::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_Cast::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.Cast) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_Cast::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Type type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression input = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_Cast::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.Cast) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Type type = 1; - if (this->_internal_has_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::type(this), target, stream); - } - - // .substrait.Expression input = 2; - if (this->_internal_has_input()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::input(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.Cast) - return target; -} - -size_t Expression_Cast::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.Cast) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Type type = 1; - if (this->_internal_has_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_); - } - - // .substrait.Expression input = 2; - if (this->_internal_has_input()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *input_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_Cast::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_Cast::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_Cast::GetClassData() const { return &_class_data_; } - -void Expression_Cast::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_Cast::MergeFrom(const Expression_Cast& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.Cast) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_type()) { - _internal_mutable_type()->::substrait::Type::MergeFrom(from._internal_type()); - } - if (from._internal_has_input()) { - _internal_mutable_input()->::substrait::Expression::MergeFrom(from._internal_input()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_Cast::CopyFrom(const Expression_Cast& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.Cast) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_Cast::IsInitialized() const { - return true; -} - -void Expression_Cast::InternalSwap(Expression_Cast* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_Cast, input_) - + sizeof(Expression_Cast::input_) - - PROTOBUF_FIELD_OFFSET(Expression_Cast, type_)>( - reinterpret_cast(&type_), - reinterpret_cast(&other->type_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_Cast::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[20]); -} - -// =================================================================== - -class Expression_SwitchExpression_IfValue::_Internal { - public: - static const ::substrait::Expression_Literal& if_(const Expression_SwitchExpression_IfValue* msg); - static const ::substrait::Expression& then(const Expression_SwitchExpression_IfValue* msg); -}; - -const ::substrait::Expression_Literal& -Expression_SwitchExpression_IfValue::_Internal::if_(const Expression_SwitchExpression_IfValue* msg) { - return *msg->if__; -} -const ::substrait::Expression& -Expression_SwitchExpression_IfValue::_Internal::then(const Expression_SwitchExpression_IfValue* msg) { - return *msg->then_; -} -Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.SwitchExpression.IfValue) -} -Expression_SwitchExpression_IfValue::Expression_SwitchExpression_IfValue(const Expression_SwitchExpression_IfValue& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_if_()) { - if__ = new ::substrait::Expression_Literal(*from.if__); - } else { - if__ = nullptr; - } - if (from._internal_has_then()) { - then_ = new ::substrait::Expression(*from.then_); - } else { - then_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.SwitchExpression.IfValue) -} - -inline void Expression_SwitchExpression_IfValue::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&if__) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&then_) - - reinterpret_cast(&if__)) + sizeof(then_)); -} - -Expression_SwitchExpression_IfValue::~Expression_SwitchExpression_IfValue() { - // @@protoc_insertion_point(destructor:substrait.Expression.SwitchExpression.IfValue) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_SwitchExpression_IfValue::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete if__; - if (this != internal_default_instance()) delete then_; -} - -void Expression_SwitchExpression_IfValue::ArenaDtor(void* object) { - Expression_SwitchExpression_IfValue* _this = reinterpret_cast< Expression_SwitchExpression_IfValue* >(object); - (void)_this; -} -void Expression_SwitchExpression_IfValue::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_SwitchExpression_IfValue::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_SwitchExpression_IfValue::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.SwitchExpression.IfValue) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && if__ != nullptr) { - delete if__; - } - if__ = nullptr; - if (GetArenaForAllocation() == nullptr && then_ != nullptr) { - delete then_; - } - then_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_SwitchExpression_IfValue::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.Literal if = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_if_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression then = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_then(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_SwitchExpression_IfValue::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SwitchExpression.IfValue) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.Literal if = 1; - if (this->_internal_has_if_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::if_(this), target, stream); - } - - // .substrait.Expression then = 2; - if (this->_internal_has_then()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::then(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.SwitchExpression.IfValue) - return target; -} - -size_t Expression_SwitchExpression_IfValue::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SwitchExpression.IfValue) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Expression.Literal if = 1; - if (this->_internal_has_if_()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *if__); - } - - // .substrait.Expression then = 2; - if (this->_internal_has_then()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *then_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_SwitchExpression_IfValue::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_SwitchExpression_IfValue::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_SwitchExpression_IfValue::GetClassData() const { return &_class_data_; } - -void Expression_SwitchExpression_IfValue::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_SwitchExpression_IfValue::MergeFrom(const Expression_SwitchExpression_IfValue& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SwitchExpression.IfValue) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_if_()) { - _internal_mutable_if_()->::substrait::Expression_Literal::MergeFrom(from._internal_if_()); - } - if (from._internal_has_then()) { - _internal_mutable_then()->::substrait::Expression::MergeFrom(from._internal_then()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_SwitchExpression_IfValue::CopyFrom(const Expression_SwitchExpression_IfValue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.SwitchExpression.IfValue) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_SwitchExpression_IfValue::IsInitialized() const { - return true; -} - -void Expression_SwitchExpression_IfValue::InternalSwap(Expression_SwitchExpression_IfValue* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_SwitchExpression_IfValue, then_) - + sizeof(Expression_SwitchExpression_IfValue::then_) - - PROTOBUF_FIELD_OFFSET(Expression_SwitchExpression_IfValue, if__)>( - reinterpret_cast(&if__), - reinterpret_cast(&other->if__)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression_IfValue::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[21]); -} - -// =================================================================== - -class Expression_SwitchExpression::_Internal { - public: - static const ::substrait::Expression& else_(const Expression_SwitchExpression* msg); -}; - -const ::substrait::Expression& -Expression_SwitchExpression::_Internal::else_(const Expression_SwitchExpression* msg) { - return *msg->else__; -} -Expression_SwitchExpression::Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - ifs_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.SwitchExpression) -} -Expression_SwitchExpression::Expression_SwitchExpression(const Expression_SwitchExpression& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - ifs_(from.ifs_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_else_()) { - else__ = new ::substrait::Expression(*from.else__); - } else { - else__ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.SwitchExpression) -} - -inline void Expression_SwitchExpression::SharedCtor() { -else__ = nullptr; -} - -Expression_SwitchExpression::~Expression_SwitchExpression() { - // @@protoc_insertion_point(destructor:substrait.Expression.SwitchExpression) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_SwitchExpression::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete else__; -} - -void Expression_SwitchExpression::ArenaDtor(void* object) { - Expression_SwitchExpression* _this = reinterpret_cast< Expression_SwitchExpression* >(object); - (void)_this; -} -void Expression_SwitchExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_SwitchExpression::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_SwitchExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.SwitchExpression) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ifs_.Clear(); - if (GetArenaForAllocation() == nullptr && else__ != nullptr) { - delete else__; - } - else__ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_SwitchExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_ifs(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.Expression else = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_else_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_SwitchExpression::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SwitchExpression) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_ifs_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_ifs(i), target, stream); - } - - // .substrait.Expression else = 2; - if (this->_internal_has_else_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::else_(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.SwitchExpression) - return target; -} - -size_t Expression_SwitchExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SwitchExpression) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; - total_size += 1UL * this->_internal_ifs_size(); - for (const auto& msg : this->ifs_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.Expression else = 2; - if (this->_internal_has_else_()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *else__); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_SwitchExpression::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_SwitchExpression::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_SwitchExpression::GetClassData() const { return &_class_data_; } - -void Expression_SwitchExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_SwitchExpression::MergeFrom(const Expression_SwitchExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SwitchExpression) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - ifs_.MergeFrom(from.ifs_); - if (from._internal_has_else_()) { - _internal_mutable_else_()->::substrait::Expression::MergeFrom(from._internal_else_()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_SwitchExpression::CopyFrom(const Expression_SwitchExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.SwitchExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_SwitchExpression::IsInitialized() const { - return true; -} - -void Expression_SwitchExpression::InternalSwap(Expression_SwitchExpression* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ifs_.InternalSwap(&other->ifs_); - swap(else__, other->else__); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_SwitchExpression::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[22]); -} - -// =================================================================== - -class Expression_SingularOrList::_Internal { - public: - static const ::substrait::Expression& value(const Expression_SingularOrList* msg); -}; - -const ::substrait::Expression& -Expression_SingularOrList::_Internal::value(const Expression_SingularOrList* msg) { - return *msg->value_; -} -Expression_SingularOrList::Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - options_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.SingularOrList) -} -Expression_SingularOrList::Expression_SingularOrList(const Expression_SingularOrList& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - options_(from.options_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_value()) { - value_ = new ::substrait::Expression(*from.value_); - } else { - value_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.SingularOrList) -} - -inline void Expression_SingularOrList::SharedCtor() { -value_ = nullptr; -} - -Expression_SingularOrList::~Expression_SingularOrList() { - // @@protoc_insertion_point(destructor:substrait.Expression.SingularOrList) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_SingularOrList::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete value_; -} - -void Expression_SingularOrList::ArenaDtor(void* object) { - Expression_SingularOrList* _this = reinterpret_cast< Expression_SingularOrList* >(object); - (void)_this; -} -void Expression_SingularOrList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_SingularOrList::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_SingularOrList::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.SingularOrList) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - options_.Clear(); - if (GetArenaForAllocation() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_SingularOrList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression value = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.Expression options = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_options(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* Expression_SingularOrList::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.SingularOrList) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression value = 1; - if (this->_internal_has_value()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::value(this), target, stream); - } - - // repeated .substrait.Expression options = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_options_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_options(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.SingularOrList) - return target; -} - -size_t Expression_SingularOrList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.SingularOrList) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression options = 2; - total_size += 1UL * this->_internal_options_size(); - for (const auto& msg : this->options_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.Expression value = 1; - if (this->_internal_has_value()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *value_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_SingularOrList::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_SingularOrList::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_SingularOrList::GetClassData() const { return &_class_data_; } - -void Expression_SingularOrList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_SingularOrList::MergeFrom(const Expression_SingularOrList& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.SingularOrList) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - options_.MergeFrom(from.options_); - if (from._internal_has_value()) { - _internal_mutable_value()->::substrait::Expression::MergeFrom(from._internal_value()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_SingularOrList::CopyFrom(const Expression_SingularOrList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.SingularOrList) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_SingularOrList::IsInitialized() const { - return true; -} - -void Expression_SingularOrList::InternalSwap(Expression_SingularOrList* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - options_.InternalSwap(&other->options_); - swap(value_, other->value_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_SingularOrList::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[23]); -} - -// =================================================================== - -class Expression_MultiOrList_Record::_Internal { - public: -}; - -Expression_MultiOrList_Record::Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - fields_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MultiOrList.Record) -} -Expression_MultiOrList_Record::Expression_MultiOrList_Record(const Expression_MultiOrList_Record& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - fields_(from.fields_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MultiOrList.Record) -} - -inline void Expression_MultiOrList_Record::SharedCtor() { -} - -Expression_MultiOrList_Record::~Expression_MultiOrList_Record() { - // @@protoc_insertion_point(destructor:substrait.Expression.MultiOrList.Record) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MultiOrList_Record::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_MultiOrList_Record::ArenaDtor(void* object) { - Expression_MultiOrList_Record* _this = reinterpret_cast< Expression_MultiOrList_Record* >(object); - (void)_this; -} -void Expression_MultiOrList_Record::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MultiOrList_Record::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MultiOrList_Record::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MultiOrList.Record) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - fields_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MultiOrList_Record::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression fields = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_fields(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* Expression_MultiOrList_Record::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MultiOrList.Record) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression fields = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_fields_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_fields(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MultiOrList.Record) - return target; -} - -size_t Expression_MultiOrList_Record::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MultiOrList.Record) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression fields = 1; - total_size += 1UL * this->_internal_fields_size(); - for (const auto& msg : this->fields_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MultiOrList_Record::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MultiOrList_Record::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MultiOrList_Record::GetClassData() const { return &_class_data_; } - -void Expression_MultiOrList_Record::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MultiOrList_Record::MergeFrom(const Expression_MultiOrList_Record& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MultiOrList.Record) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - fields_.MergeFrom(from.fields_); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MultiOrList_Record::CopyFrom(const Expression_MultiOrList_Record& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MultiOrList.Record) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MultiOrList_Record::IsInitialized() const { - return true; -} - -void Expression_MultiOrList_Record::InternalSwap(Expression_MultiOrList_Record* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - fields_.InternalSwap(&other->fields_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList_Record::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[24]); -} - -// =================================================================== - -class Expression_MultiOrList::_Internal { - public: -}; - -Expression_MultiOrList::Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - value_(arena), - options_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MultiOrList) -} -Expression_MultiOrList::Expression_MultiOrList(const Expression_MultiOrList& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - value_(from.value_), - options_(from.options_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MultiOrList) -} - -inline void Expression_MultiOrList::SharedCtor() { -} - -Expression_MultiOrList::~Expression_MultiOrList() { - // @@protoc_insertion_point(destructor:substrait.Expression.MultiOrList) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MultiOrList::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_MultiOrList::ArenaDtor(void* object) { - Expression_MultiOrList* _this = reinterpret_cast< Expression_MultiOrList* >(object); - (void)_this; -} -void Expression_MultiOrList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MultiOrList::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MultiOrList::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MultiOrList) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - value_.Clear(); - options_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MultiOrList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression value = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_value(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // repeated .substrait.Expression.MultiOrList.Record options = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_options(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* Expression_MultiOrList::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MultiOrList) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression value = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_value_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_value(i), target, stream); - } - - // repeated .substrait.Expression.MultiOrList.Record options = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_options_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_options(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MultiOrList) - return target; -} - -size_t Expression_MultiOrList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MultiOrList) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression value = 1; - total_size += 1UL * this->_internal_value_size(); - for (const auto& msg : this->value_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .substrait.Expression.MultiOrList.Record options = 2; - total_size += 1UL * this->_internal_options_size(); - for (const auto& msg : this->options_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MultiOrList::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MultiOrList::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MultiOrList::GetClassData() const { return &_class_data_; } - -void Expression_MultiOrList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MultiOrList::MergeFrom(const Expression_MultiOrList& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MultiOrList) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - value_.MergeFrom(from.value_); - options_.MergeFrom(from.options_); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MultiOrList::CopyFrom(const Expression_MultiOrList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MultiOrList) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MultiOrList::IsInitialized() const { - return true; -} - -void Expression_MultiOrList::InternalSwap(Expression_MultiOrList* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - value_.InternalSwap(&other->value_); - options_.InternalSwap(&other->options_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MultiOrList::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[25]); -} - -// =================================================================== - -class Expression_EmbeddedFunction_PythonPickleFunction::_Internal { - public: -}; - -Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - prerequisite_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction) -} -Expression_EmbeddedFunction_PythonPickleFunction::Expression_EmbeddedFunction_PythonPickleFunction(const Expression_EmbeddedFunction_PythonPickleFunction& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - prerequisite_(from.prerequisite_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_function().empty()) { - function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_function(), - GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction) -} - -inline void Expression_EmbeddedFunction_PythonPickleFunction::SharedCtor() { -function_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Expression_EmbeddedFunction_PythonPickleFunction::~Expression_EmbeddedFunction_PythonPickleFunction() { - // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_EmbeddedFunction_PythonPickleFunction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - function_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void Expression_EmbeddedFunction_PythonPickleFunction::ArenaDtor(void* object) { - Expression_EmbeddedFunction_PythonPickleFunction* _this = reinterpret_cast< Expression_EmbeddedFunction_PythonPickleFunction* >(object); - (void)_this; -} -void Expression_EmbeddedFunction_PythonPickleFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_EmbeddedFunction_PythonPickleFunction::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_EmbeddedFunction_PythonPickleFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - prerequisite_.Clear(); - function_.ClearToEmpty(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_EmbeddedFunction_PythonPickleFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // bytes function = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_function(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated string prerequisite = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_prerequisite(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* Expression_EmbeddedFunction_PythonPickleFunction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // bytes function = 1; - if (!this->_internal_function().empty()) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_function(), target); - } - - // repeated string prerequisite = 2; - for (int i = 0, n = this->_internal_prerequisite_size(); i < n; i++) { - const auto& s = this->_internal_prerequisite(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite"); - target = stream->WriteString(2, s, target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - return target; -} - -size_t Expression_EmbeddedFunction_PythonPickleFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string prerequisite = 2; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(prerequisite_.size()); - for (int i = 0, n = prerequisite_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - prerequisite_.Get(i)); - } - - // bytes function = 1; - if (!this->_internal_function().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_function()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_EmbeddedFunction_PythonPickleFunction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_EmbeddedFunction_PythonPickleFunction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_EmbeddedFunction_PythonPickleFunction::GetClassData() const { return &_class_data_; } - -void Expression_EmbeddedFunction_PythonPickleFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - prerequisite_.MergeFrom(from.prerequisite_); - if (!from._internal_function().empty()) { - _internal_set_function(from._internal_function()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_EmbeddedFunction_PythonPickleFunction::CopyFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_EmbeddedFunction_PythonPickleFunction::IsInitialized() const { - return true; -} - -void Expression_EmbeddedFunction_PythonPickleFunction::InternalSwap(Expression_EmbeddedFunction_PythonPickleFunction* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - prerequisite_.InternalSwap(&other->prerequisite_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &function_, lhs_arena, - &other->function_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_PythonPickleFunction::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[26]); -} - -// =================================================================== - -class Expression_EmbeddedFunction_WebAssemblyFunction::_Internal { - public: -}; - -Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - prerequisite_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) -} -Expression_EmbeddedFunction_WebAssemblyFunction::Expression_EmbeddedFunction_WebAssemblyFunction(const Expression_EmbeddedFunction_WebAssemblyFunction& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - prerequisite_(from.prerequisite_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_script().empty()) { - script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_script(), - GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) -} - -inline void Expression_EmbeddedFunction_WebAssemblyFunction::SharedCtor() { -script_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Expression_EmbeddedFunction_WebAssemblyFunction::~Expression_EmbeddedFunction_WebAssemblyFunction() { - // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_EmbeddedFunction_WebAssemblyFunction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - script_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void Expression_EmbeddedFunction_WebAssemblyFunction::ArenaDtor(void* object) { - Expression_EmbeddedFunction_WebAssemblyFunction* _this = reinterpret_cast< Expression_EmbeddedFunction_WebAssemblyFunction* >(object); - (void)_this; -} -void Expression_EmbeddedFunction_WebAssemblyFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_EmbeddedFunction_WebAssemblyFunction::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_EmbeddedFunction_WebAssemblyFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - prerequisite_.Clear(); - script_.ClearToEmpty(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // bytes script = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_script(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated string prerequisite = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_prerequisite(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* Expression_EmbeddedFunction_WebAssemblyFunction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // bytes script = 1; - if (!this->_internal_script().empty()) { - target = stream->WriteBytesMaybeAliased( - 1, this->_internal_script(), target); - } - - // repeated string prerequisite = 2; - for (int i = 0, n = this->_internal_prerequisite_size(); i < n; i++) { - const auto& s = this->_internal_prerequisite(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite"); - target = stream->WriteString(2, s, target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - return target; -} - -size_t Expression_EmbeddedFunction_WebAssemblyFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string prerequisite = 2; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(prerequisite_.size()); - for (int i = 0, n = prerequisite_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - prerequisite_.Get(i)); - } - - // bytes script = 1; - if (!this->_internal_script().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize( - this->_internal_script()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_EmbeddedFunction_WebAssemblyFunction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_EmbeddedFunction_WebAssemblyFunction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_EmbeddedFunction_WebAssemblyFunction::GetClassData() const { return &_class_data_; } - -void Expression_EmbeddedFunction_WebAssemblyFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - prerequisite_.MergeFrom(from.prerequisite_); - if (!from._internal_script().empty()) { - _internal_set_script(from._internal_script()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_EmbeddedFunction_WebAssemblyFunction::CopyFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_EmbeddedFunction_WebAssemblyFunction::IsInitialized() const { - return true; -} - -void Expression_EmbeddedFunction_WebAssemblyFunction::InternalSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - prerequisite_.InternalSwap(&other->prerequisite_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &script_, lhs_arena, - &other->script_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction_WebAssemblyFunction::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[27]); -} - -// =================================================================== - -class Expression_EmbeddedFunction::_Internal { - public: - static const ::substrait::Type& output_type(const Expression_EmbeddedFunction* msg); - static const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function(const Expression_EmbeddedFunction* msg); - static const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function(const Expression_EmbeddedFunction* msg); -}; - -const ::substrait::Type& -Expression_EmbeddedFunction::_Internal::output_type(const Expression_EmbeddedFunction* msg) { - return *msg->output_type_; -} -const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& -Expression_EmbeddedFunction::_Internal::python_pickle_function(const Expression_EmbeddedFunction* msg) { - return *msg->kind_.python_pickle_function_; -} -const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& -Expression_EmbeddedFunction::_Internal::web_assembly_function(const Expression_EmbeddedFunction* msg) { - return *msg->kind_.web_assembly_function_; -} -void Expression_EmbeddedFunction::clear_output_type() { - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; -} -void Expression_EmbeddedFunction::set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (python_pickle_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_EmbeddedFunction_PythonPickleFunction>::GetOwningArena(python_pickle_function); - if (message_arena != submessage_arena) { - python_pickle_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, python_pickle_function, submessage_arena); - } - set_has_python_pickle_function(); - kind_.python_pickle_function_ = python_pickle_function; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.python_pickle_function) -} -void Expression_EmbeddedFunction::set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (web_assembly_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_EmbeddedFunction_WebAssemblyFunction>::GetOwningArena(web_assembly_function); - if (message_arena != submessage_arena) { - web_assembly_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, web_assembly_function, submessage_arena); - } - set_has_web_assembly_function(); - kind_.web_assembly_function_ = web_assembly_function; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.web_assembly_function) -} -Expression_EmbeddedFunction::Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - arguments_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.EmbeddedFunction) -} -Expression_EmbeddedFunction::Expression_EmbeddedFunction(const Expression_EmbeddedFunction& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - arguments_(from.arguments_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_output_type()) { - output_type_ = new ::substrait::Type(*from.output_type_); - } else { - output_type_ = nullptr; - } - clear_has_kind(); - switch (from.kind_case()) { - case kPythonPickleFunction: { - _internal_mutable_python_pickle_function()->::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function()); - break; - } - case kWebAssemblyFunction: { - _internal_mutable_web_assembly_function()->::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function()); - break; - } - case KIND_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.EmbeddedFunction) -} - -inline void Expression_EmbeddedFunction::SharedCtor() { -output_type_ = nullptr; -clear_has_kind(); -} - -Expression_EmbeddedFunction::~Expression_EmbeddedFunction() { - // @@protoc_insertion_point(destructor:substrait.Expression.EmbeddedFunction) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_EmbeddedFunction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete output_type_; - if (has_kind()) { - clear_kind(); - } -} - -void Expression_EmbeddedFunction::ArenaDtor(void* object) { - Expression_EmbeddedFunction* _this = reinterpret_cast< Expression_EmbeddedFunction* >(object); - (void)_this; -} -void Expression_EmbeddedFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_EmbeddedFunction::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_EmbeddedFunction::clear_kind() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.EmbeddedFunction) - switch (kind_case()) { - case kPythonPickleFunction: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.python_pickle_function_; - } - break; - } - case kWebAssemblyFunction: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.web_assembly_function_; - } - break; - } - case KIND_NOT_SET: { - break; - } - } - _oneof_case_[0] = KIND_NOT_SET; -} - - -void Expression_EmbeddedFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.EmbeddedFunction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - arguments_.Clear(); - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; - clear_kind(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_EmbeddedFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression arguments = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_arguments(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.Type output_type = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_python_pickle_function(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_web_assembly_function(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_EmbeddedFunction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.EmbeddedFunction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression arguments = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_arguments_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_arguments(i), target, stream); - } - - // .substrait.Type output_type = 2; - if (this->_internal_has_output_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::output_type(this), target, stream); - } - - // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; - if (_internal_has_python_pickle_function()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::python_pickle_function(this), target, stream); - } - - // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; - if (_internal_has_web_assembly_function()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::web_assembly_function(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.EmbeddedFunction) - return target; -} - -size_t Expression_EmbeddedFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.EmbeddedFunction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression arguments = 1; - total_size += 1UL * this->_internal_arguments_size(); - for (const auto& msg : this->arguments_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.Type output_type = 2; - if (this->_internal_has_output_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *output_type_); - } - - switch (kind_case()) { - // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; - case kPythonPickleFunction: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.python_pickle_function_); - break; - } - // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; - case kWebAssemblyFunction: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.web_assembly_function_); - break; - } - case KIND_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_EmbeddedFunction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_EmbeddedFunction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_EmbeddedFunction::GetClassData() const { return &_class_data_; } - -void Expression_EmbeddedFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_EmbeddedFunction::MergeFrom(const Expression_EmbeddedFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.EmbeddedFunction) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - arguments_.MergeFrom(from.arguments_); - if (from._internal_has_output_type()) { - _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); - } - switch (from.kind_case()) { - case kPythonPickleFunction: { - _internal_mutable_python_pickle_function()->::substrait::Expression_EmbeddedFunction_PythonPickleFunction::MergeFrom(from._internal_python_pickle_function()); - break; - } - case kWebAssemblyFunction: { - _internal_mutable_web_assembly_function()->::substrait::Expression_EmbeddedFunction_WebAssemblyFunction::MergeFrom(from._internal_web_assembly_function()); - break; - } - case KIND_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_EmbeddedFunction::CopyFrom(const Expression_EmbeddedFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.EmbeddedFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_EmbeddedFunction::IsInitialized() const { - return true; -} - -void Expression_EmbeddedFunction::InternalSwap(Expression_EmbeddedFunction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - arguments_.InternalSwap(&other->arguments_); - swap(output_type_, other->output_type_); - swap(kind_, other->kind_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_EmbeddedFunction::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[28]); -} - -// =================================================================== - -class Expression_ReferenceSegment_MapKey::_Internal { - public: - static const ::substrait::Expression_Literal& map_key(const Expression_ReferenceSegment_MapKey* msg); - static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_MapKey* msg); -}; - -const ::substrait::Expression_Literal& -Expression_ReferenceSegment_MapKey::_Internal::map_key(const Expression_ReferenceSegment_MapKey* msg) { - return *msg->map_key_; -} -const ::substrait::Expression_ReferenceSegment& -Expression_ReferenceSegment_MapKey::_Internal::child(const Expression_ReferenceSegment_MapKey* msg) { - return *msg->child_; -} -Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.MapKey) -} -Expression_ReferenceSegment_MapKey::Expression_ReferenceSegment_MapKey(const Expression_ReferenceSegment_MapKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_map_key()) { - map_key_ = new ::substrait::Expression_Literal(*from.map_key_); - } else { - map_key_ = nullptr; - } - if (from._internal_has_child()) { - child_ = new ::substrait::Expression_ReferenceSegment(*from.child_); - } else { - child_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.MapKey) -} - -inline void Expression_ReferenceSegment_MapKey::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&map_key_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&child_) - - reinterpret_cast(&map_key_)) + sizeof(child_)); -} - -Expression_ReferenceSegment_MapKey::~Expression_ReferenceSegment_MapKey() { - // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.MapKey) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_ReferenceSegment_MapKey::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete map_key_; - if (this != internal_default_instance()) delete child_; -} - -void Expression_ReferenceSegment_MapKey::ArenaDtor(void* object) { - Expression_ReferenceSegment_MapKey* _this = reinterpret_cast< Expression_ReferenceSegment_MapKey* >(object); - (void)_this; -} -void Expression_ReferenceSegment_MapKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_ReferenceSegment_MapKey::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_ReferenceSegment_MapKey::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.MapKey) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && map_key_ != nullptr) { - delete map_key_; - } - map_key_ = nullptr; - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_ReferenceSegment_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.Literal map_key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.ReferenceSegment child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_ReferenceSegment_MapKey::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.MapKey) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.Literal map_key = 1; - if (this->_internal_has_map_key()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::map_key(this), target, stream); - } - - // .substrait.Expression.ReferenceSegment child = 2; - if (this->_internal_has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment.MapKey) - return target; -} - -size_t Expression_ReferenceSegment_MapKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.MapKey) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Expression.Literal map_key = 1; - if (this->_internal_has_map_key()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *map_key_); - } - - // .substrait.Expression.ReferenceSegment child = 2; - if (this->_internal_has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment_MapKey::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_ReferenceSegment_MapKey::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment_MapKey::GetClassData() const { return &_class_data_; } - -void Expression_ReferenceSegment_MapKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_ReferenceSegment_MapKey::MergeFrom(const Expression_ReferenceSegment_MapKey& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.MapKey) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_map_key()) { - _internal_mutable_map_key()->::substrait::Expression_Literal::MergeFrom(from._internal_map_key()); - } - if (from._internal_has_child()) { - _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_ReferenceSegment_MapKey::CopyFrom(const Expression_ReferenceSegment_MapKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment.MapKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_ReferenceSegment_MapKey::IsInitialized() const { - return true; -} - -void Expression_ReferenceSegment_MapKey::InternalSwap(Expression_ReferenceSegment_MapKey* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_MapKey, child_) - + sizeof(Expression_ReferenceSegment_MapKey::child_) - - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_MapKey, map_key_)>( - reinterpret_cast(&map_key_), - reinterpret_cast(&other->map_key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_MapKey::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[29]); -} - -// =================================================================== - -class Expression_ReferenceSegment_StructField::_Internal { - public: - static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_StructField* msg); -}; - -const ::substrait::Expression_ReferenceSegment& -Expression_ReferenceSegment_StructField::_Internal::child(const Expression_ReferenceSegment_StructField* msg) { - return *msg->child_; -} -Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.StructField) -} -Expression_ReferenceSegment_StructField::Expression_ReferenceSegment_StructField(const Expression_ReferenceSegment_StructField& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::substrait::Expression_ReferenceSegment(*from.child_); - } else { - child_ = nullptr; - } - field_ = from.field_; - // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.StructField) -} - -inline void Expression_ReferenceSegment_StructField::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&child_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&field_) - - reinterpret_cast(&child_)) + sizeof(field_)); -} - -Expression_ReferenceSegment_StructField::~Expression_ReferenceSegment_StructField() { - // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.StructField) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_ReferenceSegment_StructField::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete child_; -} - -void Expression_ReferenceSegment_StructField::ArenaDtor(void* object) { - Expression_ReferenceSegment_StructField* _this = reinterpret_cast< Expression_ReferenceSegment_StructField* >(object); - (void)_this; -} -void Expression_ReferenceSegment_StructField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_ReferenceSegment_StructField::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_ReferenceSegment_StructField::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.StructField) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - field_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_ReferenceSegment_StructField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 field = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.ReferenceSegment child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_ReferenceSegment_StructField::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.StructField) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 field = 1; - if (this->_internal_field() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); - } - - // .substrait.Expression.ReferenceSegment child = 2; - if (this->_internal_has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment.StructField) - return target; -} - -size_t Expression_ReferenceSegment_StructField::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.StructField) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Expression.ReferenceSegment child = 2; - if (this->_internal_has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - // int32 field = 1; - if (this->_internal_field() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment_StructField::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_ReferenceSegment_StructField::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment_StructField::GetClassData() const { return &_class_data_; } - -void Expression_ReferenceSegment_StructField::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_ReferenceSegment_StructField::MergeFrom(const Expression_ReferenceSegment_StructField& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.StructField) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_child()) { - _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); - } - if (from._internal_field() != 0) { - _internal_set_field(from._internal_field()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_ReferenceSegment_StructField::CopyFrom(const Expression_ReferenceSegment_StructField& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment.StructField) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_ReferenceSegment_StructField::IsInitialized() const { - return true; -} - -void Expression_ReferenceSegment_StructField::InternalSwap(Expression_ReferenceSegment_StructField* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_StructField, field_) - + sizeof(Expression_ReferenceSegment_StructField::field_) - - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_StructField, child_)>( - reinterpret_cast(&child_), - reinterpret_cast(&other->child_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_StructField::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[30]); -} - -// =================================================================== - -class Expression_ReferenceSegment_ListElement::_Internal { - public: - static const ::substrait::Expression_ReferenceSegment& child(const Expression_ReferenceSegment_ListElement* msg); -}; - -const ::substrait::Expression_ReferenceSegment& -Expression_ReferenceSegment_ListElement::_Internal::child(const Expression_ReferenceSegment_ListElement* msg) { - return *msg->child_; -} -Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment.ListElement) -} -Expression_ReferenceSegment_ListElement::Expression_ReferenceSegment_ListElement(const Expression_ReferenceSegment_ListElement& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::substrait::Expression_ReferenceSegment(*from.child_); - } else { - child_ = nullptr; - } - offset_ = from.offset_; - // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment.ListElement) -} - -inline void Expression_ReferenceSegment_ListElement::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&child_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&offset_) - - reinterpret_cast(&child_)) + sizeof(offset_)); -} - -Expression_ReferenceSegment_ListElement::~Expression_ReferenceSegment_ListElement() { - // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment.ListElement) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_ReferenceSegment_ListElement::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete child_; -} - -void Expression_ReferenceSegment_ListElement::ArenaDtor(void* object) { - Expression_ReferenceSegment_ListElement* _this = reinterpret_cast< Expression_ReferenceSegment_ListElement* >(object); - (void)_this; -} -void Expression_ReferenceSegment_ListElement::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_ReferenceSegment_ListElement::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_ReferenceSegment_ListElement::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment.ListElement) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - offset_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_ReferenceSegment_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 offset = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.ReferenceSegment child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_ReferenceSegment_ListElement::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment.ListElement) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 offset = 1; - if (this->_internal_offset() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_offset(), target); - } - - // .substrait.Expression.ReferenceSegment child = 2; - if (this->_internal_has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment.ListElement) - return target; -} - -size_t Expression_ReferenceSegment_ListElement::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment.ListElement) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Expression.ReferenceSegment child = 2; - if (this->_internal_has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - // int32 offset = 1; - if (this->_internal_offset() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_offset()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment_ListElement::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_ReferenceSegment_ListElement::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment_ListElement::GetClassData() const { return &_class_data_; } - -void Expression_ReferenceSegment_ListElement::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_ReferenceSegment_ListElement::MergeFrom(const Expression_ReferenceSegment_ListElement& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment.ListElement) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_child()) { - _internal_mutable_child()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_child()); - } - if (from._internal_offset() != 0) { - _internal_set_offset(from._internal_offset()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_ReferenceSegment_ListElement::CopyFrom(const Expression_ReferenceSegment_ListElement& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment.ListElement) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_ReferenceSegment_ListElement::IsInitialized() const { - return true; -} - -void Expression_ReferenceSegment_ListElement::InternalSwap(Expression_ReferenceSegment_ListElement* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_ListElement, offset_) - + sizeof(Expression_ReferenceSegment_ListElement::offset_) - - PROTOBUF_FIELD_OFFSET(Expression_ReferenceSegment_ListElement, child_)>( - reinterpret_cast(&child_), - reinterpret_cast(&other->child_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment_ListElement::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[31]); -} - -// =================================================================== - -class Expression_ReferenceSegment::_Internal { - public: - static const ::substrait::Expression_ReferenceSegment_MapKey& map_key(const Expression_ReferenceSegment* msg); - static const ::substrait::Expression_ReferenceSegment_StructField& struct_field(const Expression_ReferenceSegment* msg); - static const ::substrait::Expression_ReferenceSegment_ListElement& list_element(const Expression_ReferenceSegment* msg); -}; - -const ::substrait::Expression_ReferenceSegment_MapKey& -Expression_ReferenceSegment::_Internal::map_key(const Expression_ReferenceSegment* msg) { - return *msg->reference_type_.map_key_; -} -const ::substrait::Expression_ReferenceSegment_StructField& -Expression_ReferenceSegment::_Internal::struct_field(const Expression_ReferenceSegment* msg) { - return *msg->reference_type_.struct_field_; -} -const ::substrait::Expression_ReferenceSegment_ListElement& -Expression_ReferenceSegment::_Internal::list_element(const Expression_ReferenceSegment* msg) { - return *msg->reference_type_.list_element_; -} -void Expression_ReferenceSegment::set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_reference_type(); - if (map_key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_MapKey>::GetOwningArena(map_key); - if (message_arena != submessage_arena) { - map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, map_key, submessage_arena); - } - set_has_map_key(); - reference_type_.map_key_ = map_key; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.map_key) -} -void Expression_ReferenceSegment::set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_reference_type(); - if (struct_field) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_StructField>::GetOwningArena(struct_field); - if (message_arena != submessage_arena) { - struct_field = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_field, submessage_arena); - } - set_has_struct_field(); - reference_type_.struct_field_ = struct_field; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.struct_field) -} -void Expression_ReferenceSegment::set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_reference_type(); - if (list_element) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment_ListElement>::GetOwningArena(list_element); - if (message_arena != submessage_arena) { - list_element = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, list_element, submessage_arena); - } - set_has_list_element(); - reference_type_.list_element_ = list_element; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.list_element) -} -Expression_ReferenceSegment::Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.ReferenceSegment) -} -Expression_ReferenceSegment::Expression_ReferenceSegment(const Expression_ReferenceSegment& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_reference_type(); - switch (from.reference_type_case()) { - case kMapKey: { - _internal_mutable_map_key()->::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); - break; - } - case kStructField: { - _internal_mutable_struct_field()->::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); - break; - } - case kListElement: { - _internal_mutable_list_element()->::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.ReferenceSegment) -} - -inline void Expression_ReferenceSegment::SharedCtor() { -clear_has_reference_type(); -} - -Expression_ReferenceSegment::~Expression_ReferenceSegment() { - // @@protoc_insertion_point(destructor:substrait.Expression.ReferenceSegment) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_ReferenceSegment::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_reference_type()) { - clear_reference_type(); - } -} - -void Expression_ReferenceSegment::ArenaDtor(void* object) { - Expression_ReferenceSegment* _this = reinterpret_cast< Expression_ReferenceSegment* >(object); - (void)_this; -} -void Expression_ReferenceSegment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_ReferenceSegment::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_ReferenceSegment::clear_reference_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.ReferenceSegment) - switch (reference_type_case()) { - case kMapKey: { - if (GetArenaForAllocation() == nullptr) { - delete reference_type_.map_key_; - } - break; - } - case kStructField: { - if (GetArenaForAllocation() == nullptr) { - delete reference_type_.struct_field_; - } - break; - } - case kListElement: { - if (GetArenaForAllocation() == nullptr) { - delete reference_type_.list_element_; - } - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; -} - - -void Expression_ReferenceSegment::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.ReferenceSegment) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_reference_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_ReferenceSegment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.ReferenceSegment.MapKey map_key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_map_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.ReferenceSegment.StructField struct_field = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_field(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.ReferenceSegment.ListElement list_element = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_list_element(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_ReferenceSegment::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.ReferenceSegment) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.ReferenceSegment.MapKey map_key = 1; - if (_internal_has_map_key()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::map_key(this), target, stream); - } - - // .substrait.Expression.ReferenceSegment.StructField struct_field = 2; - if (_internal_has_struct_field()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::struct_field(this), target, stream); - } - - // .substrait.Expression.ReferenceSegment.ListElement list_element = 3; - if (_internal_has_list_element()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::list_element(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.ReferenceSegment) - return target; -} - -size_t Expression_ReferenceSegment::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.ReferenceSegment) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (reference_type_case()) { - // .substrait.Expression.ReferenceSegment.MapKey map_key = 1; - case kMapKey: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.map_key_); - break; - } - // .substrait.Expression.ReferenceSegment.StructField struct_field = 2; - case kStructField: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.struct_field_); - break; - } - // .substrait.Expression.ReferenceSegment.ListElement list_element = 3; - case kListElement: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.list_element_); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_ReferenceSegment::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_ReferenceSegment::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_ReferenceSegment::GetClassData() const { return &_class_data_; } - -void Expression_ReferenceSegment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_ReferenceSegment::MergeFrom(const Expression_ReferenceSegment& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.ReferenceSegment) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.reference_type_case()) { - case kMapKey: { - _internal_mutable_map_key()->::substrait::Expression_ReferenceSegment_MapKey::MergeFrom(from._internal_map_key()); - break; - } - case kStructField: { - _internal_mutable_struct_field()->::substrait::Expression_ReferenceSegment_StructField::MergeFrom(from._internal_struct_field()); - break; - } - case kListElement: { - _internal_mutable_list_element()->::substrait::Expression_ReferenceSegment_ListElement::MergeFrom(from._internal_list_element()); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_ReferenceSegment::CopyFrom(const Expression_ReferenceSegment& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.ReferenceSegment) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_ReferenceSegment::IsInitialized() const { - return true; -} - -void Expression_ReferenceSegment::InternalSwap(Expression_ReferenceSegment* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(reference_type_, other->reference_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_ReferenceSegment::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[32]); -} - -// =================================================================== - -class Expression_MaskExpression_Select::_Internal { - public: - static const ::substrait::Expression_MaskExpression_StructSelect& struct_(const Expression_MaskExpression_Select* msg); - static const ::substrait::Expression_MaskExpression_ListSelect& list(const Expression_MaskExpression_Select* msg); - static const ::substrait::Expression_MaskExpression_MapSelect& map(const Expression_MaskExpression_Select* msg); -}; - -const ::substrait::Expression_MaskExpression_StructSelect& -Expression_MaskExpression_Select::_Internal::struct_(const Expression_MaskExpression_Select* msg) { - return *msg->type_.struct__; -} -const ::substrait::Expression_MaskExpression_ListSelect& -Expression_MaskExpression_Select::_Internal::list(const Expression_MaskExpression_Select* msg) { - return *msg->type_.list_; -} -const ::substrait::Expression_MaskExpression_MapSelect& -Expression_MaskExpression_Select::_Internal::map(const Expression_MaskExpression_Select* msg) { - return *msg->type_.map_; -} -void Expression_MaskExpression_Select::set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_type(); - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_StructSelect>::GetOwningArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - set_has_struct_(); - type_.struct__ = struct_; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.struct) -} -void Expression_MaskExpression_Select::set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_type(); - if (list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect>::GetOwningArena(list); - if (message_arena != submessage_arena) { - list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, list, submessage_arena); - } - set_has_list(); - type_.list_ = list; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.list) -} -void Expression_MaskExpression_Select::set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_type(); - if (map) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect>::GetOwningArena(map); - if (message_arena != submessage_arena) { - map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, map, submessage_arena); - } - set_has_map(); - type_.map_ = map; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.Select.map) -} -Expression_MaskExpression_Select::Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.Select) -} -Expression_MaskExpression_Select::Expression_MaskExpression_Select(const Expression_MaskExpression_Select& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_type(); - switch (from.type_case()) { - case kStruct: { - _internal_mutable_struct_()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); - break; - } - case kList: { - _internal_mutable_list()->::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list()); - break; - } - case kMap: { - _internal_mutable_map()->::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map()); - break; - } - case TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.Select) -} - -inline void Expression_MaskExpression_Select::SharedCtor() { -clear_has_type(); -} - -Expression_MaskExpression_Select::~Expression_MaskExpression_Select() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.Select) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression_Select::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_type()) { - clear_type(); - } -} - -void Expression_MaskExpression_Select::ArenaDtor(void* object) { - Expression_MaskExpression_Select* _this = reinterpret_cast< Expression_MaskExpression_Select* >(object); - (void)_this; -} -void Expression_MaskExpression_Select::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression_Select::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression_Select::clear_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.Select) - switch (type_case()) { - case kStruct: { - if (GetArenaForAllocation() == nullptr) { - delete type_.struct__; - } - break; - } - case kList: { - if (GetArenaForAllocation() == nullptr) { - delete type_.list_; - } - break; - } - case kMap: { - if (GetArenaForAllocation() == nullptr) { - delete type_.map_; - } - break; - } - case TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = TYPE_NOT_SET; -} - - -void Expression_MaskExpression_Select::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.Select) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression_Select::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.MaskExpression.StructSelect struct = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.MaskExpression.ListSelect list = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.MaskExpression.MapSelect map = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_MaskExpression_Select::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.Select) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.MaskExpression.StructSelect struct = 1; - if (_internal_has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::struct_(this), target, stream); - } - - // .substrait.Expression.MaskExpression.ListSelect list = 2; - if (_internal_has_list()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::list(this), target, stream); - } - - // .substrait.Expression.MaskExpression.MapSelect map = 3; - if (_internal_has_map()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::map(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.Select) - return target; -} - -size_t Expression_MaskExpression_Select::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.Select) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (type_case()) { - // .substrait.Expression.MaskExpression.StructSelect struct = 1; - case kStruct: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_.struct__); - break; - } - // .substrait.Expression.MaskExpression.ListSelect list = 2; - case kList: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_.list_); - break; - } - // .substrait.Expression.MaskExpression.MapSelect map = 3; - case kMap: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_.map_); - break; - } - case TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_Select::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression_Select::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_Select::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression_Select::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression_Select::MergeFrom(const Expression_MaskExpression_Select& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.Select) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.type_case()) { - case kStruct: { - _internal_mutable_struct_()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_struct_()); - break; - } - case kList: { - _internal_mutable_list()->::substrait::Expression_MaskExpression_ListSelect::MergeFrom(from._internal_list()); - break; - } - case kMap: { - _internal_mutable_map()->::substrait::Expression_MaskExpression_MapSelect::MergeFrom(from._internal_map()); - break; - } - case TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression_Select::CopyFrom(const Expression_MaskExpression_Select& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.Select) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression_Select::IsInitialized() const { - return true; -} - -void Expression_MaskExpression_Select::InternalSwap(Expression_MaskExpression_Select* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(type_, other->type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_Select::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[33]); -} - -// =================================================================== - -class Expression_MaskExpression_StructSelect::_Internal { - public: -}; - -Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - struct_items_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.StructSelect) -} -Expression_MaskExpression_StructSelect::Expression_MaskExpression_StructSelect(const Expression_MaskExpression_StructSelect& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - struct_items_(from.struct_items_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.StructSelect) -} - -inline void Expression_MaskExpression_StructSelect::SharedCtor() { -} - -Expression_MaskExpression_StructSelect::~Expression_MaskExpression_StructSelect() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.StructSelect) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression_StructSelect::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_MaskExpression_StructSelect::ArenaDtor(void* object) { - Expression_MaskExpression_StructSelect* _this = reinterpret_cast< Expression_MaskExpression_StructSelect* >(object); - (void)_this; -} -void Expression_MaskExpression_StructSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression_StructSelect::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression_StructSelect::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.StructSelect) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - struct_items_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression_StructSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_struct_items(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* Expression_MaskExpression_StructSelect::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.StructSelect) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_struct_items_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_struct_items(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.StructSelect) - return target; -} - -size_t Expression_MaskExpression_StructSelect::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.StructSelect) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; - total_size += 1UL * this->_internal_struct_items_size(); - for (const auto& msg : this->struct_items_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_StructSelect::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression_StructSelect::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_StructSelect::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression_StructSelect::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression_StructSelect::MergeFrom(const Expression_MaskExpression_StructSelect& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.StructSelect) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - struct_items_.MergeFrom(from.struct_items_); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression_StructSelect::CopyFrom(const Expression_MaskExpression_StructSelect& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.StructSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression_StructSelect::IsInitialized() const { - return true; -} - -void Expression_MaskExpression_StructSelect::InternalSwap(Expression_MaskExpression_StructSelect* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - struct_items_.InternalSwap(&other->struct_items_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_StructSelect::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[34]); -} - -// =================================================================== - -class Expression_MaskExpression_StructItem::_Internal { - public: - static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_StructItem* msg); -}; - -const ::substrait::Expression_MaskExpression_Select& -Expression_MaskExpression_StructItem::_Internal::child(const Expression_MaskExpression_StructItem* msg) { - return *msg->child_; -} -Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.StructItem) -} -Expression_MaskExpression_StructItem::Expression_MaskExpression_StructItem(const Expression_MaskExpression_StructItem& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_); - } else { - child_ = nullptr; - } - field_ = from.field_; - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.StructItem) -} - -inline void Expression_MaskExpression_StructItem::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&child_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&field_) - - reinterpret_cast(&child_)) + sizeof(field_)); -} - -Expression_MaskExpression_StructItem::~Expression_MaskExpression_StructItem() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.StructItem) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression_StructItem::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete child_; -} - -void Expression_MaskExpression_StructItem::ArenaDtor(void* object) { - Expression_MaskExpression_StructItem* _this = reinterpret_cast< Expression_MaskExpression_StructItem* >(object); - (void)_this; -} -void Expression_MaskExpression_StructItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression_StructItem::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression_StructItem::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.StructItem) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - field_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression_StructItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 field = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.MaskExpression.Select child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_MaskExpression_StructItem::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.StructItem) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 field = 1; - if (this->_internal_field() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); - } - - // .substrait.Expression.MaskExpression.Select child = 2; - if (this->_internal_has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.StructItem) - return target; -} - -size_t Expression_MaskExpression_StructItem::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.StructItem) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Expression.MaskExpression.Select child = 2; - if (this->_internal_has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - // int32 field = 1; - if (this->_internal_field() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_StructItem::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression_StructItem::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_StructItem::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression_StructItem::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression_StructItem::MergeFrom(const Expression_MaskExpression_StructItem& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.StructItem) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_child()) { - _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); - } - if (from._internal_field() != 0) { - _internal_set_field(from._internal_field()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression_StructItem::CopyFrom(const Expression_MaskExpression_StructItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.StructItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression_StructItem::IsInitialized() const { - return true; -} - -void Expression_MaskExpression_StructItem::InternalSwap(Expression_MaskExpression_StructItem* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_StructItem, field_) - + sizeof(Expression_MaskExpression_StructItem::field_) - - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_StructItem, child_)>( - reinterpret_cast(&child_), - reinterpret_cast(&other->child_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_StructItem::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[35]); -} - -// =================================================================== - -class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_Internal { - public: -}; - -Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) -} -Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - field_ = from.field_; - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) -} - -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedCtor() { -field_ = 0; -} - -Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::~Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ArenaDtor(void* object) { - Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _this = reinterpret_cast< Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* >(object); - (void)_this; -} -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - field_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 field = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - field_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 field = 1; - if (this->_internal_field() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_field(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - return target; -} - -size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int32 field = 1; - if (this->_internal_field() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_field()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_field() != 0) { - _internal_set_field(from._internal_field()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::IsInitialized() const { - return true; -} - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(field_, other->field_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[36]); -} - -// =================================================================== - -class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_Internal { - public: -}; - -Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) -} -Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&start_, &from.start_, - static_cast(reinterpret_cast(&end_) - - reinterpret_cast(&start_)) + sizeof(end_)); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) -} - -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&start_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&end_) - - reinterpret_cast(&start_)) + sizeof(end_)); -} - -Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::~Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ArenaDtor(void* object) { - Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _this = reinterpret_cast< Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* >(object); - (void)_this; -} -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&start_, 0, static_cast( - reinterpret_cast(&end_) - - reinterpret_cast(&start_)) + sizeof(end_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 start = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 end = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 start = 1; - if (this->_internal_start() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_start(), target); - } - - // int32 end = 2; - if (this->_internal_end() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_end(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - return target; -} - -size_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int32 start = 1; - if (this->_internal_start() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_start()); - } - - // int32 end = 2; - if (this->_internal_end() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_end()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_start() != 0) { - _internal_set_start(from._internal_start()); - } - if (from._internal_end() != 0) { - _internal_set_end(from._internal_end()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::IsInitialized() const { - return true; -} - -void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, end_) - + sizeof(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::end_) - - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice, start_)>( - reinterpret_cast(&start_), - reinterpret_cast(&other->start_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[37]); -} - -// =================================================================== - -class Expression_MaskExpression_ListSelect_ListSelectItem::_Internal { - public: - static const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg); - static const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg); -}; - -const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& -Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::item(const Expression_MaskExpression_ListSelect_ListSelectItem* msg) { - return *msg->type_.item_; -} -const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& -Expression_MaskExpression_ListSelect_ListSelectItem::_Internal::slice(const Expression_MaskExpression_ListSelect_ListSelectItem* msg) { - return *msg->type_.slice_; -} -void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_type(); - if (item) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement>::GetOwningArena(item); - if (message_arena != submessage_arena) { - item = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, item, submessage_arena); - } - set_has_item(); - type_.item_ = item; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) -} -void Expression_MaskExpression_ListSelect_ListSelectItem::set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_type(); - if (slice) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice>::GetOwningArena(slice); - if (message_arena != submessage_arena) { - slice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, slice, submessage_arena); - } - set_has_slice(); - type_.slice_ = slice; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) -} -Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) -} -Expression_MaskExpression_ListSelect_ListSelectItem::Expression_MaskExpression_ListSelect_ListSelectItem(const Expression_MaskExpression_ListSelect_ListSelectItem& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_type(); - switch (from.type_case()) { - case kItem: { - _internal_mutable_item()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); - break; - } - case kSlice: { - _internal_mutable_slice()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); - break; - } - case TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) -} - -inline void Expression_MaskExpression_ListSelect_ListSelectItem::SharedCtor() { -clear_has_type(); -} - -Expression_MaskExpression_ListSelect_ListSelectItem::~Expression_MaskExpression_ListSelect_ListSelectItem() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression_ListSelect_ListSelectItem::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_type()) { - clear_type(); - } -} - -void Expression_MaskExpression_ListSelect_ListSelectItem::ArenaDtor(void* object) { - Expression_MaskExpression_ListSelect_ListSelectItem* _this = reinterpret_cast< Expression_MaskExpression_ListSelect_ListSelectItem* >(object); - (void)_this; -} -void Expression_MaskExpression_ListSelect_ListSelectItem::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression_ListSelect_ListSelectItem::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression_ListSelect_ListSelectItem::clear_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - switch (type_case()) { - case kItem: { - if (GetArenaForAllocation() == nullptr) { - delete type_.item_; - } - break; - } - case kSlice: { - if (GetArenaForAllocation() == nullptr) { - delete type_.slice_; - } - break; - } - case TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = TYPE_NOT_SET; -} - - -void Expression_MaskExpression_ListSelect_ListSelectItem::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_item(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_slice(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_MaskExpression_ListSelect_ListSelectItem::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; - if (_internal_has_item()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::item(this), target, stream); - } - - // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; - if (_internal_has_slice()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::slice(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - return target; -} - -size_t Expression_MaskExpression_ListSelect_ListSelectItem::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (type_case()) { - // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; - case kItem: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_.item_); - break; - } - // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; - case kSlice: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_.slice_); - break; - } - case TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect_ListSelectItem::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression_ListSelect_ListSelectItem::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect_ListSelectItem::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression_ListSelect_ListSelectItem::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression_ListSelect_ListSelectItem::MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.type_case()) { - case kItem: { - _internal_mutable_item()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::MergeFrom(from._internal_item()); - break; - } - case kSlice: { - _internal_mutable_slice()->::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::MergeFrom(from._internal_slice()); - break; - } - case TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression_ListSelect_ListSelectItem::CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression_ListSelect_ListSelectItem::IsInitialized() const { - return true; -} - -void Expression_MaskExpression_ListSelect_ListSelectItem::InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(type_, other->type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect_ListSelectItem::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[38]); -} - -// =================================================================== - -class Expression_MaskExpression_ListSelect::_Internal { - public: - static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_ListSelect* msg); -}; - -const ::substrait::Expression_MaskExpression_Select& -Expression_MaskExpression_ListSelect::_Internal::child(const Expression_MaskExpression_ListSelect* msg) { - return *msg->child_; -} -Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - selection_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.ListSelect) -} -Expression_MaskExpression_ListSelect::Expression_MaskExpression_ListSelect(const Expression_MaskExpression_ListSelect& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - selection_(from.selection_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_); - } else { - child_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.ListSelect) -} - -inline void Expression_MaskExpression_ListSelect::SharedCtor() { -child_ = nullptr; -} - -Expression_MaskExpression_ListSelect::~Expression_MaskExpression_ListSelect() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.ListSelect) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression_ListSelect::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete child_; -} - -void Expression_MaskExpression_ListSelect::ArenaDtor(void* object) { - Expression_MaskExpression_ListSelect* _this = reinterpret_cast< Expression_MaskExpression_ListSelect* >(object); - (void)_this; -} -void Expression_MaskExpression_ListSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression_ListSelect::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression_ListSelect::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.ListSelect) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - selection_.Clear(); - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression_ListSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_selection(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.Expression.MaskExpression.Select child = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_MaskExpression_ListSelect::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.ListSelect) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_selection_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_selection(i), target, stream); - } - - // .substrait.Expression.MaskExpression.Select child = 2; - if (this->_internal_has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.ListSelect) - return target; -} - -size_t Expression_MaskExpression_ListSelect::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.ListSelect) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; - total_size += 1UL * this->_internal_selection_size(); - for (const auto& msg : this->selection_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.Expression.MaskExpression.Select child = 2; - if (this->_internal_has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_ListSelect::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression_ListSelect::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_ListSelect::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression_ListSelect::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression_ListSelect::MergeFrom(const Expression_MaskExpression_ListSelect& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.ListSelect) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - selection_.MergeFrom(from.selection_); - if (from._internal_has_child()) { - _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression_ListSelect::CopyFrom(const Expression_MaskExpression_ListSelect& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.ListSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression_ListSelect::IsInitialized() const { - return true; -} - -void Expression_MaskExpression_ListSelect::InternalSwap(Expression_MaskExpression_ListSelect* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - selection_.InternalSwap(&other->selection_); - swap(child_, other->child_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_ListSelect::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[39]); -} - -// =================================================================== - -class Expression_MaskExpression_MapSelect_MapKey::_Internal { - public: -}; - -Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect.MapKey) -} -Expression_MaskExpression_MapSelect_MapKey::Expression_MaskExpression_MapSelect_MapKey(const Expression_MaskExpression_MapSelect_MapKey& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_map_key().empty()) { - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key(), - GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect.MapKey) -} - -inline void Expression_MaskExpression_MapSelect_MapKey::SharedCtor() { -map_key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Expression_MaskExpression_MapSelect_MapKey::~Expression_MaskExpression_MapSelect_MapKey() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect.MapKey) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression_MapSelect_MapKey::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - map_key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void Expression_MaskExpression_MapSelect_MapKey::ArenaDtor(void* object) { - Expression_MaskExpression_MapSelect_MapKey* _this = reinterpret_cast< Expression_MaskExpression_MapSelect_MapKey* >(object); - (void)_this; -} -void Expression_MaskExpression_MapSelect_MapKey::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression_MapSelect_MapKey::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression_MapSelect_MapKey::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect.MapKey) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - map_key_.ClearToEmpty(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression_MapSelect_MapKey::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string map_key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_map_key(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.MaskExpression.MapSelect.MapKey.map_key")); - 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* Expression_MaskExpression_MapSelect_MapKey::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect.MapKey) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string map_key = 1; - if (!this->_internal_map_key().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_map_key().data(), static_cast(this->_internal_map_key().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Expression.MaskExpression.MapSelect.MapKey.map_key"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_map_key(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.MapSelect.MapKey) - return target; -} - -size_t Expression_MaskExpression_MapSelect_MapKey::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect.MapKey) - 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 map_key = 1; - if (!this->_internal_map_key().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_map_key()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_MapSelect_MapKey::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression_MapSelect_MapKey::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_MapSelect_MapKey::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression_MapSelect_MapKey::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression_MapSelect_MapKey::MergeFrom(const Expression_MaskExpression_MapSelect_MapKey& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_map_key().empty()) { - _internal_set_map_key(from._internal_map_key()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression_MapSelect_MapKey::CopyFrom(const Expression_MaskExpression_MapSelect_MapKey& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKey) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression_MapSelect_MapKey::IsInitialized() const { - return true; -} - -void Expression_MaskExpression_MapSelect_MapKey::InternalSwap(Expression_MaskExpression_MapSelect_MapKey* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &map_key_, lhs_arena, - &other->map_key_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKey::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[40]); -} - -// =================================================================== - -class Expression_MaskExpression_MapSelect_MapKeyExpression::_Internal { - public: -}; - -Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) -} -Expression_MaskExpression_MapSelect_MapKeyExpression::Expression_MaskExpression_MapSelect_MapKeyExpression(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_map_key_expression().empty()) { - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_map_key_expression(), - GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) -} - -inline void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedCtor() { -map_key_expression_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -Expression_MaskExpression_MapSelect_MapKeyExpression::~Expression_MaskExpression_MapSelect_MapKeyExpression() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression_MapSelect_MapKeyExpression::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - map_key_expression_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void Expression_MaskExpression_MapSelect_MapKeyExpression::ArenaDtor(void* object) { - Expression_MaskExpression_MapSelect_MapKeyExpression* _this = reinterpret_cast< Expression_MaskExpression_MapSelect_MapKeyExpression* >(object); - (void)_this; -} -void Expression_MaskExpression_MapSelect_MapKeyExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression_MapSelect_MapKeyExpression::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression_MapSelect_MapKeyExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - map_key_expression_.ClearToEmpty(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string map_key_expression = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_map_key_expression(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression")); - 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* Expression_MaskExpression_MapSelect_MapKeyExpression::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string map_key_expression = 1; - if (!this->_internal_map_key_expression().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_map_key_expression().data(), static_cast(this->_internal_map_key_expression().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_map_key_expression(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - return target; -} - -size_t Expression_MaskExpression_MapSelect_MapKeyExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - 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 map_key_expression = 1; - if (!this->_internal_map_key_expression().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_map_key_expression()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_MapSelect_MapKeyExpression::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression_MapSelect_MapKeyExpression::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_MapSelect_MapKeyExpression::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_map_key_expression().empty()) { - _internal_set_map_key_expression(from._internal_map_key_expression()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression_MapSelect_MapKeyExpression::CopyFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression_MapSelect_MapKeyExpression::IsInitialized() const { - return true; -} - -void Expression_MaskExpression_MapSelect_MapKeyExpression::InternalSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &map_key_expression_, lhs_arena, - &other->map_key_expression_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect_MapKeyExpression::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[41]); -} - -// =================================================================== - -class Expression_MaskExpression_MapSelect::_Internal { - public: - static const ::substrait::Expression_MaskExpression_MapSelect_MapKey& key(const Expression_MaskExpression_MapSelect* msg); - static const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression(const Expression_MaskExpression_MapSelect* msg); - static const ::substrait::Expression_MaskExpression_Select& child(const Expression_MaskExpression_MapSelect* msg); -}; - -const ::substrait::Expression_MaskExpression_MapSelect_MapKey& -Expression_MaskExpression_MapSelect::_Internal::key(const Expression_MaskExpression_MapSelect* msg) { - return *msg->select_.key_; -} -const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& -Expression_MaskExpression_MapSelect::_Internal::expression(const Expression_MaskExpression_MapSelect* msg) { - return *msg->select_.expression_; -} -const ::substrait::Expression_MaskExpression_Select& -Expression_MaskExpression_MapSelect::_Internal::child(const Expression_MaskExpression_MapSelect* msg) { - return *msg->child_; -} -void Expression_MaskExpression_MapSelect::set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_select(); - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect_MapKey>::GetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - set_has_key(); - select_.key_ = key; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.key) -} -void Expression_MaskExpression_MapSelect::set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_select(); - if (expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression>::GetOwningArena(expression); - if (message_arena != submessage_arena) { - expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, expression, submessage_arena); - } - set_has_expression(); - select_.expression_ = expression; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.expression) -} -Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression.MapSelect) -} -Expression_MaskExpression_MapSelect::Expression_MaskExpression_MapSelect(const Expression_MaskExpression_MapSelect& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_child()) { - child_ = new ::substrait::Expression_MaskExpression_Select(*from.child_); - } else { - child_ = nullptr; - } - clear_has_select(); - switch (from.select_case()) { - case kKey: { - _internal_mutable_key()->::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); - break; - } - case kExpression: { - _internal_mutable_expression()->::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); - break; - } - case SELECT_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression.MapSelect) -} - -inline void Expression_MaskExpression_MapSelect::SharedCtor() { -child_ = nullptr; -clear_has_select(); -} - -Expression_MaskExpression_MapSelect::~Expression_MaskExpression_MapSelect() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression.MapSelect) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression_MapSelect::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete child_; - if (has_select()) { - clear_select(); - } -} - -void Expression_MaskExpression_MapSelect::ArenaDtor(void* object) { - Expression_MaskExpression_MapSelect* _this = reinterpret_cast< Expression_MaskExpression_MapSelect* >(object); - (void)_this; -} -void Expression_MaskExpression_MapSelect::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression_MapSelect::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression_MapSelect::clear_select() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.MaskExpression.MapSelect) - switch (select_case()) { - case kKey: { - if (GetArenaForAllocation() == nullptr) { - delete select_.key_; - } - break; - } - case kExpression: { - if (GetArenaForAllocation() == nullptr) { - delete select_.expression_; - } - break; - } - case SELECT_NOT_SET: { - break; - } - } - _oneof_case_[0] = SELECT_NOT_SET; -} - - -void Expression_MaskExpression_MapSelect::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression.MapSelect) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; - clear_select(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression_MapSelect::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.MaskExpression.Select child = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_child(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_MaskExpression_MapSelect::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression.MapSelect) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; - if (_internal_has_key()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::key(this), target, stream); - } - - // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; - if (_internal_has_expression()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::expression(this), target, stream); - } - - // .substrait.Expression.MaskExpression.Select child = 3; - if (this->_internal_has_child()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::child(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression.MapSelect) - return target; -} - -size_t Expression_MaskExpression_MapSelect::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression.MapSelect) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Expression.MaskExpression.Select child = 3; - if (this->_internal_has_child()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *child_); - } - - switch (select_case()) { - // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; - case kKey: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *select_.key_); - break; - } - // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; - case kExpression: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *select_.expression_); - break; - } - case SELECT_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression_MapSelect::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression_MapSelect::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression_MapSelect::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression_MapSelect::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression_MapSelect::MergeFrom(const Expression_MaskExpression_MapSelect& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression.MapSelect) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_child()) { - _internal_mutable_child()->::substrait::Expression_MaskExpression_Select::MergeFrom(from._internal_child()); - } - switch (from.select_case()) { - case kKey: { - _internal_mutable_key()->::substrait::Expression_MaskExpression_MapSelect_MapKey::MergeFrom(from._internal_key()); - break; - } - case kExpression: { - _internal_mutable_expression()->::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression::MergeFrom(from._internal_expression()); - break; - } - case SELECT_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression_MapSelect::CopyFrom(const Expression_MaskExpression_MapSelect& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression.MapSelect) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression_MapSelect::IsInitialized() const { - return true; -} - -void Expression_MaskExpression_MapSelect::InternalSwap(Expression_MaskExpression_MapSelect* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(child_, other->child_); - swap(select_, other->select_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression_MapSelect::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[42]); -} - -// =================================================================== - -class Expression_MaskExpression::_Internal { - public: - static const ::substrait::Expression_MaskExpression_StructSelect& select(const Expression_MaskExpression* msg); -}; - -const ::substrait::Expression_MaskExpression_StructSelect& -Expression_MaskExpression::_Internal::select(const Expression_MaskExpression* msg) { - return *msg->select_; -} -Expression_MaskExpression::Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.MaskExpression) -} -Expression_MaskExpression::Expression_MaskExpression(const Expression_MaskExpression& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_select()) { - select_ = new ::substrait::Expression_MaskExpression_StructSelect(*from.select_); - } else { - select_ = nullptr; - } - maintain_singular_struct_ = from.maintain_singular_struct_; - // @@protoc_insertion_point(copy_constructor:substrait.Expression.MaskExpression) -} - -inline void Expression_MaskExpression::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&select_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&maintain_singular_struct_) - - reinterpret_cast(&select_)) + sizeof(maintain_singular_struct_)); -} - -Expression_MaskExpression::~Expression_MaskExpression() { - // @@protoc_insertion_point(destructor:substrait.Expression.MaskExpression) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_MaskExpression::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete select_; -} - -void Expression_MaskExpression::ArenaDtor(void* object) { - Expression_MaskExpression* _this = reinterpret_cast< Expression_MaskExpression* >(object); - (void)_this; -} -void Expression_MaskExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_MaskExpression::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_MaskExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.MaskExpression) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && select_ != nullptr) { - delete select_; - } - select_ = nullptr; - maintain_singular_struct_ = false; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_MaskExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.MaskExpression.StructSelect select = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_select(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool maintain_singular_struct = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - maintain_singular_struct_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_MaskExpression::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.MaskExpression) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.MaskExpression.StructSelect select = 1; - if (this->_internal_has_select()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::select(this), target, stream); - } - - // bool maintain_singular_struct = 2; - if (this->_internal_maintain_singular_struct() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_maintain_singular_struct(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.MaskExpression) - return target; -} - -size_t Expression_MaskExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.MaskExpression) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Expression.MaskExpression.StructSelect select = 1; - if (this->_internal_has_select()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *select_); - } - - // bool maintain_singular_struct = 2; - if (this->_internal_maintain_singular_struct() != 0) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_MaskExpression::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_MaskExpression::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_MaskExpression::GetClassData() const { return &_class_data_; } - -void Expression_MaskExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_MaskExpression::MergeFrom(const Expression_MaskExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.MaskExpression) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_select()) { - _internal_mutable_select()->::substrait::Expression_MaskExpression_StructSelect::MergeFrom(from._internal_select()); - } - if (from._internal_maintain_singular_struct() != 0) { - _internal_set_maintain_singular_struct(from._internal_maintain_singular_struct()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_MaskExpression::CopyFrom(const Expression_MaskExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.MaskExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_MaskExpression::IsInitialized() const { - return true; -} - -void Expression_MaskExpression::InternalSwap(Expression_MaskExpression* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression, maintain_singular_struct_) - + sizeof(Expression_MaskExpression::maintain_singular_struct_) - - PROTOBUF_FIELD_OFFSET(Expression_MaskExpression, select_)>( - reinterpret_cast(&select_), - reinterpret_cast(&other->select_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_MaskExpression::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[43]); -} - -// =================================================================== - -class Expression_FieldReference_RootReference::_Internal { - public: -}; - -Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { - // @@protoc_insertion_point(arena_constructor:substrait.Expression.FieldReference.RootReference) -} -Expression_FieldReference_RootReference::Expression_FieldReference_RootReference(const Expression_FieldReference_RootReference& from) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference.RootReference) -} - - - - - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_FieldReference_RootReference::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_FieldReference_RootReference::GetClassData() const { return &_class_data_; } - - - - - - - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference_RootReference::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[44]); -} - -// =================================================================== - -class Expression_FieldReference::_Internal { - public: - static const ::substrait::Expression_ReferenceSegment& direct_reference(const Expression_FieldReference* msg); - static const ::substrait::Expression_MaskExpression& masked_reference(const Expression_FieldReference* msg); - static const ::substrait::Expression& expression(const Expression_FieldReference* msg); - static const ::substrait::Expression_FieldReference_RootReference& root_reference(const Expression_FieldReference* msg); -}; - -const ::substrait::Expression_ReferenceSegment& -Expression_FieldReference::_Internal::direct_reference(const Expression_FieldReference* msg) { - return *msg->reference_type_.direct_reference_; -} -const ::substrait::Expression_MaskExpression& -Expression_FieldReference::_Internal::masked_reference(const Expression_FieldReference* msg) { - return *msg->reference_type_.masked_reference_; -} -const ::substrait::Expression& -Expression_FieldReference::_Internal::expression(const Expression_FieldReference* msg) { - return *msg->root_type_.expression_; -} -const ::substrait::Expression_FieldReference_RootReference& -Expression_FieldReference::_Internal::root_reference(const Expression_FieldReference* msg) { - return *msg->root_type_.root_reference_; -} -void Expression_FieldReference::set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_reference_type(); - if (direct_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(direct_reference); - if (message_arena != submessage_arena) { - direct_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, direct_reference, submessage_arena); - } - set_has_direct_reference(); - reference_type_.direct_reference_ = direct_reference; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.direct_reference) -} -void Expression_FieldReference::set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_reference_type(); - if (masked_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression>::GetOwningArena(masked_reference); - if (message_arena != submessage_arena) { - masked_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, masked_reference, submessage_arena); - } - set_has_masked_reference(); - reference_type_.masked_reference_ = masked_reference; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.masked_reference) -} -void Expression_FieldReference::set_allocated_expression(::substrait::Expression* expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_root_type(); - if (expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(expression); - if (message_arena != submessage_arena) { - expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, expression, submessage_arena); - } - set_has_expression(); - root_type_.expression_ = expression; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.expression) -} -void Expression_FieldReference::set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_root_type(); - if (root_reference) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_FieldReference_RootReference>::GetOwningArena(root_reference); - if (message_arena != submessage_arena) { - root_reference = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, root_reference, submessage_arena); - } - set_has_root_reference(); - root_type_.root_reference_ = root_reference; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.FieldReference.root_reference) -} -Expression_FieldReference::Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression.FieldReference) -} -Expression_FieldReference::Expression_FieldReference(const Expression_FieldReference& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_reference_type(); - switch (from.reference_type_case()) { - case kDirectReference: { - _internal_mutable_direct_reference()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference()); - break; - } - case kMaskedReference: { - _internal_mutable_masked_reference()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference()); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - clear_has_root_type(); - switch (from.root_type_case()) { - case kExpression: { - _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression()); - break; - } - case kRootReference: { - _internal_mutable_root_reference()->::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference()); - break; - } - case ROOT_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression.FieldReference) -} - -inline void Expression_FieldReference::SharedCtor() { -clear_has_reference_type(); -clear_has_root_type(); -} - -Expression_FieldReference::~Expression_FieldReference() { - // @@protoc_insertion_point(destructor:substrait.Expression.FieldReference) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression_FieldReference::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_reference_type()) { - clear_reference_type(); - } - if (has_root_type()) { - clear_root_type(); - } -} - -void Expression_FieldReference::ArenaDtor(void* object) { - Expression_FieldReference* _this = reinterpret_cast< Expression_FieldReference* >(object); - (void)_this; -} -void Expression_FieldReference::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression_FieldReference::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression_FieldReference::clear_reference_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.FieldReference) - switch (reference_type_case()) { - case kDirectReference: { - if (GetArenaForAllocation() == nullptr) { - delete reference_type_.direct_reference_; - } - break; - } - case kMaskedReference: { - if (GetArenaForAllocation() == nullptr) { - delete reference_type_.masked_reference_; - } - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; -} - -void Expression_FieldReference::clear_root_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression.FieldReference) - switch (root_type_case()) { - case kExpression: { - if (GetArenaForAllocation() == nullptr) { - delete root_type_.expression_; - } - break; - } - case kRootReference: { - if (GetArenaForAllocation() == nullptr) { - delete root_type_.root_reference_; - } - break; - } - case ROOT_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[1] = ROOT_TYPE_NOT_SET; -} - - -void Expression_FieldReference::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression.FieldReference) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_reference_type(); - clear_root_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression_FieldReference::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.ReferenceSegment direct_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_direct_reference(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.MaskExpression masked_reference = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_masked_reference(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression expression = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.FieldReference.RootReference root_reference = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_root_reference(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression_FieldReference::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression.FieldReference) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.ReferenceSegment direct_reference = 1; - if (_internal_has_direct_reference()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::direct_reference(this), target, stream); - } - - // .substrait.Expression.MaskExpression masked_reference = 2; - if (_internal_has_masked_reference()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::masked_reference(this), target, stream); - } - - // .substrait.Expression expression = 3; - if (_internal_has_expression()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::expression(this), target, stream); - } - - // .substrait.Expression.FieldReference.RootReference root_reference = 4; - if (_internal_has_root_reference()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::root_reference(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression.FieldReference) - return target; -} - -size_t Expression_FieldReference::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression.FieldReference) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (reference_type_case()) { - // .substrait.Expression.ReferenceSegment direct_reference = 1; - case kDirectReference: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.direct_reference_); - break; - } - // .substrait.Expression.MaskExpression masked_reference = 2; - case kMaskedReference: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *reference_type_.masked_reference_); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - switch (root_type_case()) { - // .substrait.Expression expression = 3; - case kExpression: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *root_type_.expression_); - break; - } - // .substrait.Expression.FieldReference.RootReference root_reference = 4; - case kRootReference: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *root_type_.root_reference_); - break; - } - case ROOT_TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression_FieldReference::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression_FieldReference::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression_FieldReference::GetClassData() const { return &_class_data_; } - -void Expression_FieldReference::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression_FieldReference::MergeFrom(const Expression_FieldReference& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression.FieldReference) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.reference_type_case()) { - case kDirectReference: { - _internal_mutable_direct_reference()->::substrait::Expression_ReferenceSegment::MergeFrom(from._internal_direct_reference()); - break; - } - case kMaskedReference: { - _internal_mutable_masked_reference()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_masked_reference()); - break; - } - case REFERENCE_TYPE_NOT_SET: { - break; - } - } - switch (from.root_type_case()) { - case kExpression: { - _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression()); - break; - } - case kRootReference: { - _internal_mutable_root_reference()->::substrait::Expression_FieldReference_RootReference::MergeFrom(from._internal_root_reference()); - break; - } - case ROOT_TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression_FieldReference::CopyFrom(const Expression_FieldReference& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression.FieldReference) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression_FieldReference::IsInitialized() const { - return true; -} - -void Expression_FieldReference::InternalSwap(Expression_FieldReference* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(reference_type_, other->reference_type_); - swap(root_type_, other->root_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); - swap(_oneof_case_[1], other->_oneof_case_[1]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression_FieldReference::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[45]); -} - -// =================================================================== - -class Expression::_Internal { - public: - static const ::substrait::Expression_Literal& literal(const Expression* msg); - static const ::substrait::Expression_FieldReference& selection(const Expression* msg); - static const ::substrait::Expression_ScalarFunction& scalar_function(const Expression* msg); - static const ::substrait::Expression_WindowFunction& window_function(const Expression* msg); - static const ::substrait::Expression_IfThen& if_then(const Expression* msg); - static const ::substrait::Expression_SwitchExpression& switch_expression(const Expression* msg); - static const ::substrait::Expression_SingularOrList& singular_or_list(const Expression* msg); - static const ::substrait::Expression_MultiOrList& multi_or_list(const Expression* msg); - static const ::substrait::Expression_Enum& enum_(const Expression* msg); - static const ::substrait::Expression_Cast& cast(const Expression* msg); -}; - -const ::substrait::Expression_Literal& -Expression::_Internal::literal(const Expression* msg) { - return *msg->rex_type_.literal_; -} -const ::substrait::Expression_FieldReference& -Expression::_Internal::selection(const Expression* msg) { - return *msg->rex_type_.selection_; -} -const ::substrait::Expression_ScalarFunction& -Expression::_Internal::scalar_function(const Expression* msg) { - return *msg->rex_type_.scalar_function_; -} -const ::substrait::Expression_WindowFunction& -Expression::_Internal::window_function(const Expression* msg) { - return *msg->rex_type_.window_function_; -} -const ::substrait::Expression_IfThen& -Expression::_Internal::if_then(const Expression* msg) { - return *msg->rex_type_.if_then_; -} -const ::substrait::Expression_SwitchExpression& -Expression::_Internal::switch_expression(const Expression* msg) { - return *msg->rex_type_.switch_expression_; -} -const ::substrait::Expression_SingularOrList& -Expression::_Internal::singular_or_list(const Expression* msg) { - return *msg->rex_type_.singular_or_list_; -} -const ::substrait::Expression_MultiOrList& -Expression::_Internal::multi_or_list(const Expression* msg) { - return *msg->rex_type_.multi_or_list_; -} -const ::substrait::Expression_Enum& -Expression::_Internal::enum_(const Expression* msg) { - return *msg->rex_type_.enum__; -} -const ::substrait::Expression_Cast& -Expression::_Internal::cast(const Expression* msg) { - return *msg->rex_type_.cast_; -} -void Expression::set_allocated_literal(::substrait::Expression_Literal* literal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rex_type(); - if (literal) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(literal); - if (message_arena != submessage_arena) { - literal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, literal, submessage_arena); - } - set_has_literal(); - rex_type_.literal_ = literal; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.literal) -} -void Expression::set_allocated_selection(::substrait::Expression_FieldReference* selection) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rex_type(); - if (selection) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_FieldReference>::GetOwningArena(selection); - if (message_arena != submessage_arena) { - selection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, selection, submessage_arena); - } - set_has_selection(); - rex_type_.selection_ = selection; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.selection) -} -void Expression::set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rex_type(); - if (scalar_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ScalarFunction>::GetOwningArena(scalar_function); - if (message_arena != submessage_arena) { - scalar_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, scalar_function, submessage_arena); - } - set_has_scalar_function(); - rex_type_.scalar_function_ = scalar_function; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.scalar_function) -} -void Expression::set_allocated_window_function(::substrait::Expression_WindowFunction* window_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rex_type(); - if (window_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction>::GetOwningArena(window_function); - if (message_arena != submessage_arena) { - window_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, window_function, submessage_arena); - } - set_has_window_function(); - rex_type_.window_function_ = window_function; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.window_function) -} -void Expression::set_allocated_if_then(::substrait::Expression_IfThen* if_then) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rex_type(); - if (if_then) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_IfThen>::GetOwningArena(if_then); - if (message_arena != submessage_arena) { - if_then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, if_then, submessage_arena); - } - set_has_if_then(); - rex_type_.if_then_ = if_then; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.if_then) -} -void Expression::set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rex_type(); - if (switch_expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_SwitchExpression>::GetOwningArena(switch_expression); - if (message_arena != submessage_arena) { - switch_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, switch_expression, submessage_arena); - } - set_has_switch_expression(); - rex_type_.switch_expression_ = switch_expression; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.switch_expression) -} -void Expression::set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rex_type(); - if (singular_or_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_SingularOrList>::GetOwningArena(singular_or_list); - if (message_arena != submessage_arena) { - singular_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, singular_or_list, submessage_arena); - } - set_has_singular_or_list(); - rex_type_.singular_or_list_ = singular_or_list; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.singular_or_list) -} -void Expression::set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rex_type(); - if (multi_or_list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MultiOrList>::GetOwningArena(multi_or_list); - if (message_arena != submessage_arena) { - multi_or_list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, multi_or_list, submessage_arena); - } - set_has_multi_or_list(); - rex_type_.multi_or_list_ = multi_or_list; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.multi_or_list) -} -void Expression::set_allocated_enum_(::substrait::Expression_Enum* enum_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rex_type(); - if (enum_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Enum>::GetOwningArena(enum_); - if (message_arena != submessage_arena) { - enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, enum_, submessage_arena); - } - set_has_enum_(); - rex_type_.enum__ = enum_; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.enum) -} -void Expression::set_allocated_cast(::substrait::Expression_Cast* cast) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rex_type(); - if (cast) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Cast>::GetOwningArena(cast); - if (message_arena != submessage_arena) { - cast = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, cast, submessage_arena); - } - set_has_cast(); - rex_type_.cast_ = cast; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.cast) -} -Expression::Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Expression) -} -Expression::Expression(const Expression& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_rex_type(); - switch (from.rex_type_case()) { - case kLiteral: { - _internal_mutable_literal()->::substrait::Expression_Literal::MergeFrom(from._internal_literal()); - break; - } - case kSelection: { - _internal_mutable_selection()->::substrait::Expression_FieldReference::MergeFrom(from._internal_selection()); - break; - } - case kScalarFunction: { - _internal_mutable_scalar_function()->::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function()); - break; - } - case kWindowFunction: { - _internal_mutable_window_function()->::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function()); - break; - } - case kIfThen: { - _internal_mutable_if_then()->::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); - break; - } - case kSwitchExpression: { - _internal_mutable_switch_expression()->::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); - break; - } - case kSingularOrList: { - _internal_mutable_singular_or_list()->::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); - break; - } - case kMultiOrList: { - _internal_mutable_multi_or_list()->::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); - break; - } - case kEnum: { - _internal_mutable_enum_()->::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); - break; - } - case kCast: { - _internal_mutable_cast()->::substrait::Expression_Cast::MergeFrom(from._internal_cast()); - break; - } - case REX_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Expression) -} - -inline void Expression::SharedCtor() { -clear_has_rex_type(); -} - -Expression::~Expression() { - // @@protoc_insertion_point(destructor:substrait.Expression) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Expression::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_rex_type()) { - clear_rex_type(); - } -} - -void Expression::ArenaDtor(void* object) { - Expression* _this = reinterpret_cast< Expression* >(object); - (void)_this; -} -void Expression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Expression::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Expression::clear_rex_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Expression) - switch (rex_type_case()) { - case kLiteral: { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.literal_; - } - break; - } - case kSelection: { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.selection_; - } - break; - } - case kScalarFunction: { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.scalar_function_; - } - break; - } - case kWindowFunction: { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.window_function_; - } - break; - } - case kIfThen: { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.if_then_; - } - break; - } - case kSwitchExpression: { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.switch_expression_; - } - break; - } - case kSingularOrList: { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.singular_or_list_; - } - break; - } - case kMultiOrList: { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.multi_or_list_; - } - break; - } - case kEnum: { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.enum__; - } - break; - } - case kCast: { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.cast_; - } - break; - } - case REX_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = REX_TYPE_NOT_SET; -} - - -void Expression::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Expression) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_rex_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Expression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression.Literal literal = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_literal(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.FieldReference selection = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_selection(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.ScalarFunction scalar_function = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_scalar_function(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.WindowFunction window_function = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_window_function(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.IfThen if_then = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_if_then(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.SwitchExpression switch_expression = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_switch_expression(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.SingularOrList singular_or_list = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_singular_or_list(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.MultiOrList multi_or_list = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_multi_or_list(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Enum enum = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.Cast cast = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_cast(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Expression::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Expression) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression.Literal literal = 1; - if (_internal_has_literal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::literal(this), target, stream); - } - - // .substrait.Expression.FieldReference selection = 2; - if (_internal_has_selection()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::selection(this), target, stream); - } - - // .substrait.Expression.ScalarFunction scalar_function = 3; - if (_internal_has_scalar_function()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::scalar_function(this), target, stream); - } - - // .substrait.Expression.WindowFunction window_function = 5; - if (_internal_has_window_function()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::window_function(this), target, stream); - } - - // .substrait.Expression.IfThen if_then = 6; - if (_internal_has_if_then()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 6, _Internal::if_then(this), target, stream); - } - - // .substrait.Expression.SwitchExpression switch_expression = 7; - if (_internal_has_switch_expression()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 7, _Internal::switch_expression(this), target, stream); - } - - // .substrait.Expression.SingularOrList singular_or_list = 8; - if (_internal_has_singular_or_list()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 8, _Internal::singular_or_list(this), target, stream); - } - - // .substrait.Expression.MultiOrList multi_or_list = 9; - if (_internal_has_multi_or_list()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 9, _Internal::multi_or_list(this), target, stream); - } - - // .substrait.Expression.Enum enum = 10; - if (_internal_has_enum_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::enum_(this), target, stream); - } - - // .substrait.Expression.Cast cast = 11; - if (_internal_has_cast()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 11, _Internal::cast(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Expression) - return target; -} - -size_t Expression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Expression) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (rex_type_case()) { - // .substrait.Expression.Literal literal = 1; - case kLiteral: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.literal_); - break; - } - // .substrait.Expression.FieldReference selection = 2; - case kSelection: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.selection_); - break; - } - // .substrait.Expression.ScalarFunction scalar_function = 3; - case kScalarFunction: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.scalar_function_); - break; - } - // .substrait.Expression.WindowFunction window_function = 5; - case kWindowFunction: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.window_function_); - break; - } - // .substrait.Expression.IfThen if_then = 6; - case kIfThen: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.if_then_); - break; - } - // .substrait.Expression.SwitchExpression switch_expression = 7; - case kSwitchExpression: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.switch_expression_); - break; - } - // .substrait.Expression.SingularOrList singular_or_list = 8; - case kSingularOrList: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.singular_or_list_); - break; - } - // .substrait.Expression.MultiOrList multi_or_list = 9; - case kMultiOrList: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.multi_or_list_); - break; - } - // .substrait.Expression.Enum enum = 10; - case kEnum: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.enum__); - break; - } - // .substrait.Expression.Cast cast = 11; - case kCast: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rex_type_.cast_); - break; - } - case REX_TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Expression::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Expression::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Expression::GetClassData() const { return &_class_data_; } - -void Expression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Expression::MergeFrom(const Expression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Expression) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.rex_type_case()) { - case kLiteral: { - _internal_mutable_literal()->::substrait::Expression_Literal::MergeFrom(from._internal_literal()); - break; - } - case kSelection: { - _internal_mutable_selection()->::substrait::Expression_FieldReference::MergeFrom(from._internal_selection()); - break; - } - case kScalarFunction: { - _internal_mutable_scalar_function()->::substrait::Expression_ScalarFunction::MergeFrom(from._internal_scalar_function()); - break; - } - case kWindowFunction: { - _internal_mutable_window_function()->::substrait::Expression_WindowFunction::MergeFrom(from._internal_window_function()); - break; - } - case kIfThen: { - _internal_mutable_if_then()->::substrait::Expression_IfThen::MergeFrom(from._internal_if_then()); - break; - } - case kSwitchExpression: { - _internal_mutable_switch_expression()->::substrait::Expression_SwitchExpression::MergeFrom(from._internal_switch_expression()); - break; - } - case kSingularOrList: { - _internal_mutable_singular_or_list()->::substrait::Expression_SingularOrList::MergeFrom(from._internal_singular_or_list()); - break; - } - case kMultiOrList: { - _internal_mutable_multi_or_list()->::substrait::Expression_MultiOrList::MergeFrom(from._internal_multi_or_list()); - break; - } - case kEnum: { - _internal_mutable_enum_()->::substrait::Expression_Enum::MergeFrom(from._internal_enum_()); - break; - } - case kCast: { - _internal_mutable_cast()->::substrait::Expression_Cast::MergeFrom(from._internal_cast()); - break; - } - case REX_TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Expression::CopyFrom(const Expression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Expression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Expression::IsInitialized() const { - return true; -} - -void Expression::InternalSwap(Expression* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(rex_type_, other->rex_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Expression::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[46]); -} - -// =================================================================== - -class SortField::_Internal { - public: - static const ::substrait::Expression& expr(const SortField* msg); -}; - -const ::substrait::Expression& -SortField::_Internal::expr(const SortField* msg) { - return *msg->expr_; -} -SortField::SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.SortField) -} -SortField::SortField(const SortField& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_expr()) { - expr_ = new ::substrait::Expression(*from.expr_); - } else { - expr_ = nullptr; - } - clear_has_sort_kind(); - switch (from.sort_kind_case()) { - case kDirection: { - _internal_set_direction(from._internal_direction()); - break; - } - case kComparisonFunctionReference: { - _internal_set_comparison_function_reference(from._internal_comparison_function_reference()); - break; - } - case SORT_KIND_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.SortField) -} - -inline void SortField::SharedCtor() { -expr_ = nullptr; -clear_has_sort_kind(); -} - -SortField::~SortField() { - // @@protoc_insertion_point(destructor:substrait.SortField) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void SortField::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete expr_; - if (has_sort_kind()) { - clear_sort_kind(); - } -} - -void SortField::ArenaDtor(void* object) { - SortField* _this = reinterpret_cast< SortField* >(object); - (void)_this; -} -void SortField::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SortField::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SortField::clear_sort_kind() { -// @@protoc_insertion_point(one_of_clear_start:substrait.SortField) - switch (sort_kind_case()) { - case kDirection: { - // No need to clear - break; - } - case kComparisonFunctionReference: { - // No need to clear - break; - } - case SORT_KIND_NOT_SET: { - break; - } - } - _oneof_case_[0] = SORT_KIND_NOT_SET; -} - - -void SortField::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.SortField) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && expr_ != nullptr) { - delete expr_; - } - expr_ = nullptr; - clear_sort_kind(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SortField::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Expression expr = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_expr(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.SortField.SortDirection direction = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_direction(static_cast<::substrait::SortField_SortDirection>(val)); - } else - goto handle_unusual; - continue; - // uint32 comparison_function_reference = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _internal_set_comparison_function_reference(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SortField::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.SortField) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Expression expr = 1; - if (this->_internal_has_expr()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::expr(this), target, stream); - } - - // .substrait.SortField.SortDirection direction = 2; - if (_internal_has_direction()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_direction(), target); - } - - // uint32 comparison_function_reference = 3; - if (_internal_has_comparison_function_reference()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_comparison_function_reference(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.SortField) - return target; -} - -size_t SortField::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.SortField) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Expression expr = 1; - if (this->_internal_has_expr()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *expr_); - } - - switch (sort_kind_case()) { - // .substrait.SortField.SortDirection direction = 2; - case kDirection: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_direction()); - break; - } - // uint32 comparison_function_reference = 3; - case kComparisonFunctionReference: { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_comparison_function_reference()); - break; - } - case SORT_KIND_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SortField::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - SortField::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SortField::GetClassData() const { return &_class_data_; } - -void SortField::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void SortField::MergeFrom(const SortField& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.SortField) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_expr()) { - _internal_mutable_expr()->::substrait::Expression::MergeFrom(from._internal_expr()); - } - switch (from.sort_kind_case()) { - case kDirection: { - _internal_set_direction(from._internal_direction()); - break; - } - case kComparisonFunctionReference: { - _internal_set_comparison_function_reference(from._internal_comparison_function_reference()); - break; - } - case SORT_KIND_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SortField::CopyFrom(const SortField& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.SortField) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SortField::IsInitialized() const { - return true; -} - -void SortField::InternalSwap(SortField* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(expr_, other->expr_); - swap(sort_kind_, other->sort_kind_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SortField::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[47]); -} - -// =================================================================== - -class AggregateFunction::_Internal { - public: - static const ::substrait::Type& output_type(const AggregateFunction* msg); -}; - -const ::substrait::Type& -AggregateFunction::_Internal::output_type(const AggregateFunction* msg) { - return *msg->output_type_; -} -void AggregateFunction::clear_output_type() { - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; -} -AggregateFunction::AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - args_(arena), - sorts_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.AggregateFunction) -} -AggregateFunction::AggregateFunction(const AggregateFunction& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - args_(from.args_), - sorts_(from.sorts_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_output_type()) { - output_type_ = new ::substrait::Type(*from.output_type_); - } else { - output_type_ = nullptr; - } - ::memcpy(&function_reference_, &from.function_reference_, - static_cast(reinterpret_cast(&phase_) - - reinterpret_cast(&function_reference_)) + sizeof(phase_)); - // @@protoc_insertion_point(copy_constructor:substrait.AggregateFunction) -} - -inline void AggregateFunction::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&output_type_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&phase_) - - reinterpret_cast(&output_type_)) + sizeof(phase_)); -} - -AggregateFunction::~AggregateFunction() { - // @@protoc_insertion_point(destructor:substrait.AggregateFunction) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void AggregateFunction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete output_type_; -} - -void AggregateFunction::ArenaDtor(void* object) { - AggregateFunction* _this = reinterpret_cast< AggregateFunction* >(object); - (void)_this; -} -void AggregateFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void AggregateFunction::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void AggregateFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.AggregateFunction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - args_.Clear(); - sorts_.Clear(); - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; - ::memset(&function_reference_, 0, static_cast( - reinterpret_cast(&phase_) - - reinterpret_cast(&function_reference_)) + sizeof(phase_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* AggregateFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 function_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - function_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.Expression args = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_args(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // repeated .substrait.SortField sorts = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_sorts(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.AggregationPhase phase = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_phase(static_cast<::substrait::AggregationPhase>(val)); - } else - goto handle_unusual; - continue; - // .substrait.Type output_type = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* AggregateFunction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateFunction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 function_reference = 1; - if (this->_internal_function_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_function_reference(), target); - } - - // repeated .substrait.Expression args = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_args_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_args(i), target, stream); - } - - // repeated .substrait.SortField sorts = 3; - for (unsigned int i = 0, - n = static_cast(this->_internal_sorts_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, this->_internal_sorts(i), target, stream); - } - - // .substrait.AggregationPhase phase = 4; - if (this->_internal_phase() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 4, this->_internal_phase(), target); - } - - // .substrait.Type output_type = 5; - if (this->_internal_has_output_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::output_type(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateFunction) - return target; -} - -size_t AggregateFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateFunction) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression args = 2; - total_size += 1UL * this->_internal_args_size(); - for (const auto& msg : this->args_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .substrait.SortField sorts = 3; - total_size += 1UL * this->_internal_sorts_size(); - for (const auto& msg : this->sorts_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.Type output_type = 5; - if (this->_internal_has_output_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *output_type_); - } - - // uint32 function_reference = 1; - if (this->_internal_function_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_reference()); - } - - // .substrait.AggregationPhase phase = 4; - if (this->_internal_phase() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_phase()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateFunction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - AggregateFunction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateFunction::GetClassData() const { return &_class_data_; } - -void AggregateFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void AggregateFunction::MergeFrom(const AggregateFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateFunction) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - args_.MergeFrom(from.args_); - sorts_.MergeFrom(from.sorts_); - if (from._internal_has_output_type()) { - _internal_mutable_output_type()->::substrait::Type::MergeFrom(from._internal_output_type()); - } - if (from._internal_function_reference() != 0) { - _internal_set_function_reference(from._internal_function_reference()); - } - if (from._internal_phase() != 0) { - _internal_set_phase(from._internal_phase()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void AggregateFunction::CopyFrom(const AggregateFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool AggregateFunction::IsInitialized() const { - return true; -} - -void AggregateFunction::InternalSwap(AggregateFunction* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - args_.InternalSwap(&other->args_); - sorts_.InternalSwap(&other->sorts_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(AggregateFunction, phase_) - + sizeof(AggregateFunction::phase_) - - PROTOBUF_FIELD_OFFSET(AggregateFunction, output_type_)>( - reinterpret_cast(&output_type_), - reinterpret_cast(&other->output_type_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata AggregateFunction::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fexpression_2eproto_getter, &descriptor_table_substrait_2fexpression_2eproto_once, - file_level_metadata_substrait_2fexpression_2eproto[48]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage< ::substrait::Expression_Enum_Empty >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Enum_Empty >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Enum* Arena::CreateMaybeMessage< ::substrait::Expression_Enum >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Enum >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_VarChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Literal_VarChar >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Decimal >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Decimal >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Map_KeyValue >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Map_KeyValue >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Map >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Map >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_IntervalYearToMonth >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Literal_IntervalYearToMonth >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_IntervalDayToSecond >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Literal_IntervalDayToSecond >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_Struct >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Literal_Struct >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal_List* Arena::CreateMaybeMessage< ::substrait::Expression_Literal_List >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Literal_List >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Literal* Arena::CreateMaybeMessage< ::substrait::Expression_Literal >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Literal >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage< ::substrait::Expression_ScalarFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_ScalarFunction >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Preceding >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Preceding >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Following >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Following >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Unbounded >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound_Unbounded >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction_Bound >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage< ::substrait::Expression_WindowFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_WindowFunction >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage< ::substrait::Expression_IfThen_IfClause >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_IfThen_IfClause >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_IfThen* Arena::CreateMaybeMessage< ::substrait::Expression_IfThen >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_IfThen >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_Cast* Arena::CreateMaybeMessage< ::substrait::Expression_Cast >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_Cast >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage< ::substrait::Expression_SwitchExpression_IfValue >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_SwitchExpression_IfValue >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage< ::substrait::Expression_SwitchExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_SwitchExpression >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage< ::substrait::Expression_SingularOrList >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_SingularOrList >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage< ::substrait::Expression_MultiOrList_Record >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MultiOrList_Record >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage< ::substrait::Expression_MultiOrList >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MultiOrList >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_EmbeddedFunction >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_MapKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_MapKey >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_StructField >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_StructField >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_ListElement >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment_ListElement >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage< ::substrait::Expression_ReferenceSegment >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_ReferenceSegment >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_Select >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_Select >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructSelect >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_StructSelect >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructItem >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_StructItem >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_ListSelect >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression_MapSelect >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage< ::substrait::Expression_MaskExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_MaskExpression >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage< ::substrait::Expression_FieldReference_RootReference >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_FieldReference_RootReference >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression_FieldReference* Arena::CreateMaybeMessage< ::substrait::Expression_FieldReference >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression_FieldReference >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Expression* Arena::CreateMaybeMessage< ::substrait::Expression >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Expression >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::SortField* Arena::CreateMaybeMessage< ::substrait::SortField >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::SortField >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::AggregateFunction* Arena::CreateMaybeMessage< ::substrait::AggregateFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::AggregateFunction >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/expression.pb.h b/cpp/src/generated/substrait/expression.pb.h deleted file mode 100644 index b7c2a920316..00000000000 --- a/cpp/src/generated/substrait/expression.pb.h +++ /dev/null @@ -1,18033 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/expression.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fexpression_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fexpression_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3019000 -#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 3019003 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include -#include "substrait/type.pb.h" -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_substrait_2fexpression_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_substrait_2fexpression_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[49] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const uint32_t offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fexpression_2eproto; -namespace substrait { -class AggregateFunction; -struct AggregateFunctionDefaultTypeInternal; -extern AggregateFunctionDefaultTypeInternal _AggregateFunction_default_instance_; -class Expression; -struct ExpressionDefaultTypeInternal; -extern ExpressionDefaultTypeInternal _Expression_default_instance_; -class Expression_Cast; -struct Expression_CastDefaultTypeInternal; -extern Expression_CastDefaultTypeInternal _Expression_Cast_default_instance_; -class Expression_EmbeddedFunction; -struct Expression_EmbeddedFunctionDefaultTypeInternal; -extern Expression_EmbeddedFunctionDefaultTypeInternal _Expression_EmbeddedFunction_default_instance_; -class Expression_EmbeddedFunction_PythonPickleFunction; -struct Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal; -extern Expression_EmbeddedFunction_PythonPickleFunctionDefaultTypeInternal _Expression_EmbeddedFunction_PythonPickleFunction_default_instance_; -class Expression_EmbeddedFunction_WebAssemblyFunction; -struct Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal; -extern Expression_EmbeddedFunction_WebAssemblyFunctionDefaultTypeInternal _Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_; -class Expression_Enum; -struct Expression_EnumDefaultTypeInternal; -extern Expression_EnumDefaultTypeInternal _Expression_Enum_default_instance_; -class Expression_Enum_Empty; -struct Expression_Enum_EmptyDefaultTypeInternal; -extern Expression_Enum_EmptyDefaultTypeInternal _Expression_Enum_Empty_default_instance_; -class Expression_FieldReference; -struct Expression_FieldReferenceDefaultTypeInternal; -extern Expression_FieldReferenceDefaultTypeInternal _Expression_FieldReference_default_instance_; -class Expression_FieldReference_RootReference; -struct Expression_FieldReference_RootReferenceDefaultTypeInternal; -extern Expression_FieldReference_RootReferenceDefaultTypeInternal _Expression_FieldReference_RootReference_default_instance_; -class Expression_IfThen; -struct Expression_IfThenDefaultTypeInternal; -extern Expression_IfThenDefaultTypeInternal _Expression_IfThen_default_instance_; -class Expression_IfThen_IfClause; -struct Expression_IfThen_IfClauseDefaultTypeInternal; -extern Expression_IfThen_IfClauseDefaultTypeInternal _Expression_IfThen_IfClause_default_instance_; -class Expression_Literal; -struct Expression_LiteralDefaultTypeInternal; -extern Expression_LiteralDefaultTypeInternal _Expression_Literal_default_instance_; -class Expression_Literal_Decimal; -struct Expression_Literal_DecimalDefaultTypeInternal; -extern Expression_Literal_DecimalDefaultTypeInternal _Expression_Literal_Decimal_default_instance_; -class Expression_Literal_IntervalDayToSecond; -struct Expression_Literal_IntervalDayToSecondDefaultTypeInternal; -extern Expression_Literal_IntervalDayToSecondDefaultTypeInternal _Expression_Literal_IntervalDayToSecond_default_instance_; -class Expression_Literal_IntervalYearToMonth; -struct Expression_Literal_IntervalYearToMonthDefaultTypeInternal; -extern Expression_Literal_IntervalYearToMonthDefaultTypeInternal _Expression_Literal_IntervalYearToMonth_default_instance_; -class Expression_Literal_List; -struct Expression_Literal_ListDefaultTypeInternal; -extern Expression_Literal_ListDefaultTypeInternal _Expression_Literal_List_default_instance_; -class Expression_Literal_Map; -struct Expression_Literal_MapDefaultTypeInternal; -extern Expression_Literal_MapDefaultTypeInternal _Expression_Literal_Map_default_instance_; -class Expression_Literal_Map_KeyValue; -struct Expression_Literal_Map_KeyValueDefaultTypeInternal; -extern Expression_Literal_Map_KeyValueDefaultTypeInternal _Expression_Literal_Map_KeyValue_default_instance_; -class Expression_Literal_Struct; -struct Expression_Literal_StructDefaultTypeInternal; -extern Expression_Literal_StructDefaultTypeInternal _Expression_Literal_Struct_default_instance_; -class Expression_Literal_VarChar; -struct Expression_Literal_VarCharDefaultTypeInternal; -extern Expression_Literal_VarCharDefaultTypeInternal _Expression_Literal_VarChar_default_instance_; -class Expression_MaskExpression; -struct Expression_MaskExpressionDefaultTypeInternal; -extern Expression_MaskExpressionDefaultTypeInternal _Expression_MaskExpression_default_instance_; -class Expression_MaskExpression_ListSelect; -struct Expression_MaskExpression_ListSelectDefaultTypeInternal; -extern Expression_MaskExpression_ListSelectDefaultTypeInternal _Expression_MaskExpression_ListSelect_default_instance_; -class Expression_MaskExpression_ListSelect_ListSelectItem; -struct Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal; -extern Expression_MaskExpression_ListSelect_ListSelectItemDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_; -class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement; -struct Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal; -extern Expression_MaskExpression_ListSelect_ListSelectItem_ListElementDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_; -class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice; -struct Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal; -extern Expression_MaskExpression_ListSelect_ListSelectItem_ListSliceDefaultTypeInternal _Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_; -class Expression_MaskExpression_MapSelect; -struct Expression_MaskExpression_MapSelectDefaultTypeInternal; -extern Expression_MaskExpression_MapSelectDefaultTypeInternal _Expression_MaskExpression_MapSelect_default_instance_; -class Expression_MaskExpression_MapSelect_MapKey; -struct Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal; -extern Expression_MaskExpression_MapSelect_MapKeyDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKey_default_instance_; -class Expression_MaskExpression_MapSelect_MapKeyExpression; -struct Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal; -extern Expression_MaskExpression_MapSelect_MapKeyExpressionDefaultTypeInternal _Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_; -class Expression_MaskExpression_Select; -struct Expression_MaskExpression_SelectDefaultTypeInternal; -extern Expression_MaskExpression_SelectDefaultTypeInternal _Expression_MaskExpression_Select_default_instance_; -class Expression_MaskExpression_StructItem; -struct Expression_MaskExpression_StructItemDefaultTypeInternal; -extern Expression_MaskExpression_StructItemDefaultTypeInternal _Expression_MaskExpression_StructItem_default_instance_; -class Expression_MaskExpression_StructSelect; -struct Expression_MaskExpression_StructSelectDefaultTypeInternal; -extern Expression_MaskExpression_StructSelectDefaultTypeInternal _Expression_MaskExpression_StructSelect_default_instance_; -class Expression_MultiOrList; -struct Expression_MultiOrListDefaultTypeInternal; -extern Expression_MultiOrListDefaultTypeInternal _Expression_MultiOrList_default_instance_; -class Expression_MultiOrList_Record; -struct Expression_MultiOrList_RecordDefaultTypeInternal; -extern Expression_MultiOrList_RecordDefaultTypeInternal _Expression_MultiOrList_Record_default_instance_; -class Expression_ReferenceSegment; -struct Expression_ReferenceSegmentDefaultTypeInternal; -extern Expression_ReferenceSegmentDefaultTypeInternal _Expression_ReferenceSegment_default_instance_; -class Expression_ReferenceSegment_ListElement; -struct Expression_ReferenceSegment_ListElementDefaultTypeInternal; -extern Expression_ReferenceSegment_ListElementDefaultTypeInternal _Expression_ReferenceSegment_ListElement_default_instance_; -class Expression_ReferenceSegment_MapKey; -struct Expression_ReferenceSegment_MapKeyDefaultTypeInternal; -extern Expression_ReferenceSegment_MapKeyDefaultTypeInternal _Expression_ReferenceSegment_MapKey_default_instance_; -class Expression_ReferenceSegment_StructField; -struct Expression_ReferenceSegment_StructFieldDefaultTypeInternal; -extern Expression_ReferenceSegment_StructFieldDefaultTypeInternal _Expression_ReferenceSegment_StructField_default_instance_; -class Expression_ScalarFunction; -struct Expression_ScalarFunctionDefaultTypeInternal; -extern Expression_ScalarFunctionDefaultTypeInternal _Expression_ScalarFunction_default_instance_; -class Expression_SingularOrList; -struct Expression_SingularOrListDefaultTypeInternal; -extern Expression_SingularOrListDefaultTypeInternal _Expression_SingularOrList_default_instance_; -class Expression_SwitchExpression; -struct Expression_SwitchExpressionDefaultTypeInternal; -extern Expression_SwitchExpressionDefaultTypeInternal _Expression_SwitchExpression_default_instance_; -class Expression_SwitchExpression_IfValue; -struct Expression_SwitchExpression_IfValueDefaultTypeInternal; -extern Expression_SwitchExpression_IfValueDefaultTypeInternal _Expression_SwitchExpression_IfValue_default_instance_; -class Expression_WindowFunction; -struct Expression_WindowFunctionDefaultTypeInternal; -extern Expression_WindowFunctionDefaultTypeInternal _Expression_WindowFunction_default_instance_; -class Expression_WindowFunction_Bound; -struct Expression_WindowFunction_BoundDefaultTypeInternal; -extern Expression_WindowFunction_BoundDefaultTypeInternal _Expression_WindowFunction_Bound_default_instance_; -class Expression_WindowFunction_Bound_CurrentRow; -struct Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal; -extern Expression_WindowFunction_Bound_CurrentRowDefaultTypeInternal _Expression_WindowFunction_Bound_CurrentRow_default_instance_; -class Expression_WindowFunction_Bound_Following; -struct Expression_WindowFunction_Bound_FollowingDefaultTypeInternal; -extern Expression_WindowFunction_Bound_FollowingDefaultTypeInternal _Expression_WindowFunction_Bound_Following_default_instance_; -class Expression_WindowFunction_Bound_Preceding; -struct Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal; -extern Expression_WindowFunction_Bound_PrecedingDefaultTypeInternal _Expression_WindowFunction_Bound_Preceding_default_instance_; -class Expression_WindowFunction_Bound_Unbounded; -struct Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal; -extern Expression_WindowFunction_Bound_UnboundedDefaultTypeInternal _Expression_WindowFunction_Bound_Unbounded_default_instance_; -class SortField; -struct SortFieldDefaultTypeInternal; -extern SortFieldDefaultTypeInternal _SortField_default_instance_; -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> ::substrait::AggregateFunction* Arena::CreateMaybeMessage<::substrait::AggregateFunction>(Arena*); -template<> ::substrait::Expression* Arena::CreateMaybeMessage<::substrait::Expression>(Arena*); -template<> ::substrait::Expression_Cast* Arena::CreateMaybeMessage<::substrait::Expression_Cast>(Arena*); -template<> ::substrait::Expression_EmbeddedFunction* Arena::CreateMaybeMessage<::substrait::Expression_EmbeddedFunction>(Arena*); -template<> ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Arena::CreateMaybeMessage<::substrait::Expression_EmbeddedFunction_PythonPickleFunction>(Arena*); -template<> ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Arena::CreateMaybeMessage<::substrait::Expression_EmbeddedFunction_WebAssemblyFunction>(Arena*); -template<> ::substrait::Expression_Enum* Arena::CreateMaybeMessage<::substrait::Expression_Enum>(Arena*); -template<> ::substrait::Expression_Enum_Empty* Arena::CreateMaybeMessage<::substrait::Expression_Enum_Empty>(Arena*); -template<> ::substrait::Expression_FieldReference* Arena::CreateMaybeMessage<::substrait::Expression_FieldReference>(Arena*); -template<> ::substrait::Expression_FieldReference_RootReference* Arena::CreateMaybeMessage<::substrait::Expression_FieldReference_RootReference>(Arena*); -template<> ::substrait::Expression_IfThen* Arena::CreateMaybeMessage<::substrait::Expression_IfThen>(Arena*); -template<> ::substrait::Expression_IfThen_IfClause* Arena::CreateMaybeMessage<::substrait::Expression_IfThen_IfClause>(Arena*); -template<> ::substrait::Expression_Literal* Arena::CreateMaybeMessage<::substrait::Expression_Literal>(Arena*); -template<> ::substrait::Expression_Literal_Decimal* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Decimal>(Arena*); -template<> ::substrait::Expression_Literal_IntervalDayToSecond* Arena::CreateMaybeMessage<::substrait::Expression_Literal_IntervalDayToSecond>(Arena*); -template<> ::substrait::Expression_Literal_IntervalYearToMonth* Arena::CreateMaybeMessage<::substrait::Expression_Literal_IntervalYearToMonth>(Arena*); -template<> ::substrait::Expression_Literal_List* Arena::CreateMaybeMessage<::substrait::Expression_Literal_List>(Arena*); -template<> ::substrait::Expression_Literal_Map* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Map>(Arena*); -template<> ::substrait::Expression_Literal_Map_KeyValue* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Map_KeyValue>(Arena*); -template<> ::substrait::Expression_Literal_Struct* Arena::CreateMaybeMessage<::substrait::Expression_Literal_Struct>(Arena*); -template<> ::substrait::Expression_Literal_VarChar* Arena::CreateMaybeMessage<::substrait::Expression_Literal_VarChar>(Arena*); -template<> ::substrait::Expression_MaskExpression* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression>(Arena*); -template<> ::substrait::Expression_MaskExpression_ListSelect* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect>(Arena*); -template<> ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem>(Arena*); -template<> ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement>(Arena*); -template<> ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice>(Arena*); -template<> ::substrait::Expression_MaskExpression_MapSelect* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_MapSelect>(Arena*); -template<> ::substrait::Expression_MaskExpression_MapSelect_MapKey* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_MapSelect_MapKey>(Arena*); -template<> ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression>(Arena*); -template<> ::substrait::Expression_MaskExpression_Select* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(Arena*); -template<> ::substrait::Expression_MaskExpression_StructItem* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_StructItem>(Arena*); -template<> ::substrait::Expression_MaskExpression_StructSelect* Arena::CreateMaybeMessage<::substrait::Expression_MaskExpression_StructSelect>(Arena*); -template<> ::substrait::Expression_MultiOrList* Arena::CreateMaybeMessage<::substrait::Expression_MultiOrList>(Arena*); -template<> ::substrait::Expression_MultiOrList_Record* Arena::CreateMaybeMessage<::substrait::Expression_MultiOrList_Record>(Arena*); -template<> ::substrait::Expression_ReferenceSegment* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(Arena*); -template<> ::substrait::Expression_ReferenceSegment_ListElement* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment_ListElement>(Arena*); -template<> ::substrait::Expression_ReferenceSegment_MapKey* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment_MapKey>(Arena*); -template<> ::substrait::Expression_ReferenceSegment_StructField* Arena::CreateMaybeMessage<::substrait::Expression_ReferenceSegment_StructField>(Arena*); -template<> ::substrait::Expression_ScalarFunction* Arena::CreateMaybeMessage<::substrait::Expression_ScalarFunction>(Arena*); -template<> ::substrait::Expression_SingularOrList* Arena::CreateMaybeMessage<::substrait::Expression_SingularOrList>(Arena*); -template<> ::substrait::Expression_SwitchExpression* Arena::CreateMaybeMessage<::substrait::Expression_SwitchExpression>(Arena*); -template<> ::substrait::Expression_SwitchExpression_IfValue* Arena::CreateMaybeMessage<::substrait::Expression_SwitchExpression_IfValue>(Arena*); -template<> ::substrait::Expression_WindowFunction* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction>(Arena*); -template<> ::substrait::Expression_WindowFunction_Bound* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(Arena*); -template<> ::substrait::Expression_WindowFunction_Bound_CurrentRow* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_CurrentRow>(Arena*); -template<> ::substrait::Expression_WindowFunction_Bound_Following* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_Following>(Arena*); -template<> ::substrait::Expression_WindowFunction_Bound_Preceding* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_Preceding>(Arena*); -template<> ::substrait::Expression_WindowFunction_Bound_Unbounded* Arena::CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound_Unbounded>(Arena*); -template<> ::substrait::SortField* Arena::CreateMaybeMessage<::substrait::SortField>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace substrait { - -enum SortField_SortDirection : int { - SortField_SortDirection_SORT_DIRECTION_UNSPECIFIED = 0, - SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_FIRST = 1, - SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_LAST = 2, - SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_FIRST = 3, - SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_LAST = 4, - SortField_SortDirection_SORT_DIRECTION_CLUSTERED = 5, - SortField_SortDirection_SortField_SortDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - SortField_SortDirection_SortField_SortDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool SortField_SortDirection_IsValid(int value); -constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MIN = SortField_SortDirection_SORT_DIRECTION_UNSPECIFIED; -constexpr SortField_SortDirection SortField_SortDirection_SortDirection_MAX = SortField_SortDirection_SORT_DIRECTION_CLUSTERED; -constexpr int SortField_SortDirection_SortDirection_ARRAYSIZE = SortField_SortDirection_SortDirection_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SortField_SortDirection_descriptor(); -template -inline const std::string& SortField_SortDirection_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function SortField_SortDirection_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - SortField_SortDirection_descriptor(), enum_t_value); -} -inline bool SortField_SortDirection_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SortField_SortDirection* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - SortField_SortDirection_descriptor(), name, value); -} -enum AggregationPhase : int { - AGGREGATION_PHASE_UNSPECIFIED = 0, - AGGREGATION_PHASE_INITIAL_TO_INTERMEDIATE = 1, - AGGREGATION_PHASE_INTERMEDIATE_TO_INTERMEDIATE = 2, - AGGREGATION_PHASE_INITIAL_TO_RESULT = 3, - AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT = 4, - AggregationPhase_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - AggregationPhase_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool AggregationPhase_IsValid(int value); -constexpr AggregationPhase AggregationPhase_MIN = AGGREGATION_PHASE_UNSPECIFIED; -constexpr AggregationPhase AggregationPhase_MAX = AGGREGATION_PHASE_INTERMEDIATE_TO_RESULT; -constexpr int AggregationPhase_ARRAYSIZE = AggregationPhase_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AggregationPhase_descriptor(); -template -inline const std::string& AggregationPhase_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function AggregationPhase_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - AggregationPhase_descriptor(), enum_t_value); -} -inline bool AggregationPhase_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AggregationPhase* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - AggregationPhase_descriptor(), name, value); -} -// =================================================================== - -class Expression_Enum_Empty final : - public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.Enum.Empty) */ { - public: - inline Expression_Enum_Empty() : Expression_Enum_Empty(nullptr) {} - explicit constexpr Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Enum_Empty(const Expression_Enum_Empty& from); - Expression_Enum_Empty(Expression_Enum_Empty&& from) noexcept - : Expression_Enum_Empty() { - *this = ::std::move(from); - } - - inline Expression_Enum_Empty& operator=(const Expression_Enum_Empty& from) { - CopyFrom(from); - return *this; - } - inline Expression_Enum_Empty& operator=(Expression_Enum_Empty&& 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 Expression_Enum_Empty& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_Enum_Empty* internal_default_instance() { - return reinterpret_cast( - &_Expression_Enum_Empty_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(Expression_Enum_Empty& a, Expression_Enum_Empty& b) { - a.Swap(&b); - } - inline void Swap(Expression_Enum_Empty* 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(Expression_Enum_Empty* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Enum_Empty* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; - inline void CopyFrom(const Expression_Enum_Empty& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; - void MergeFrom(const Expression_Enum_Empty& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); - } - public: - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Enum.Empty"; - } - protected: - explicit Expression_Enum_Empty(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - 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 ------------------------------------------------------- - - // @@protoc_insertion_point(class_scope:substrait.Expression.Enum.Empty) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Enum final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Enum) */ { - public: - inline Expression_Enum() : Expression_Enum(nullptr) {} - ~Expression_Enum() override; - explicit constexpr Expression_Enum(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Enum(const Expression_Enum& from); - Expression_Enum(Expression_Enum&& from) noexcept - : Expression_Enum() { - *this = ::std::move(from); - } - - inline Expression_Enum& operator=(const Expression_Enum& from) { - CopyFrom(from); - return *this; - } - inline Expression_Enum& operator=(Expression_Enum&& 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 Expression_Enum& default_instance() { - return *internal_default_instance(); - } - enum EnumKindCase { - kSpecified = 1, - kUnspecified = 2, - ENUM_KIND_NOT_SET = 0, - }; - - static inline const Expression_Enum* internal_default_instance() { - return reinterpret_cast( - &_Expression_Enum_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(Expression_Enum& a, Expression_Enum& b) { - a.Swap(&b); - } - inline void Swap(Expression_Enum* 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(Expression_Enum* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Enum* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Enum& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Enum& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Enum* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Enum"; - } - protected: - explicit Expression_Enum(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_Enum_Empty Empty; - - // accessors ------------------------------------------------------- - - enum : int { - kSpecifiedFieldNumber = 1, - kUnspecifiedFieldNumber = 2, - }; - // string specified = 1; - bool has_specified() const; - private: - bool _internal_has_specified() const; - public: - void clear_specified(); - const std::string& specified() const; - template - void set_specified(ArgT0&& arg0, ArgT... args); - std::string* mutable_specified(); - PROTOBUF_NODISCARD std::string* release_specified(); - void set_allocated_specified(std::string* specified); - private: - const std::string& _internal_specified() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_specified(const std::string& value); - std::string* _internal_mutable_specified(); - public: - - // .substrait.Expression.Enum.Empty unspecified = 2; - bool has_unspecified() const; - private: - bool _internal_has_unspecified() const; - public: - void clear_unspecified(); - const ::substrait::Expression_Enum_Empty& unspecified() const; - PROTOBUF_NODISCARD ::substrait::Expression_Enum_Empty* release_unspecified(); - ::substrait::Expression_Enum_Empty* mutable_unspecified(); - void set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified); - private: - const ::substrait::Expression_Enum_Empty& _internal_unspecified() const; - ::substrait::Expression_Enum_Empty* _internal_mutable_unspecified(); - public: - void unsafe_arena_set_allocated_unspecified( - ::substrait::Expression_Enum_Empty* unspecified); - ::substrait::Expression_Enum_Empty* unsafe_arena_release_unspecified(); - - void clear_enum_kind(); - EnumKindCase enum_kind_case() const; - // @@protoc_insertion_point(class_scope:substrait.Expression.Enum) - private: - class _Internal; - void set_has_specified(); - void set_has_unspecified(); - - inline bool has_enum_kind() const; - inline void clear_has_enum_kind(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union EnumKindUnion { - constexpr EnumKindUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr specified_; - ::substrait::Expression_Enum_Empty* unspecified_; - } enum_kind_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Literal_VarChar final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.VarChar) */ { - public: - inline Expression_Literal_VarChar() : Expression_Literal_VarChar(nullptr) {} - ~Expression_Literal_VarChar() override; - explicit constexpr Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Literal_VarChar(const Expression_Literal_VarChar& from); - Expression_Literal_VarChar(Expression_Literal_VarChar&& from) noexcept - : Expression_Literal_VarChar() { - *this = ::std::move(from); - } - - inline Expression_Literal_VarChar& operator=(const Expression_Literal_VarChar& from) { - CopyFrom(from); - return *this; - } - inline Expression_Literal_VarChar& operator=(Expression_Literal_VarChar&& 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 Expression_Literal_VarChar& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_Literal_VarChar* internal_default_instance() { - return reinterpret_cast( - &_Expression_Literal_VarChar_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(Expression_Literal_VarChar& a, Expression_Literal_VarChar& b) { - a.Swap(&b); - } - inline void Swap(Expression_Literal_VarChar* 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(Expression_Literal_VarChar* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Literal_VarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Literal_VarChar& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Literal_VarChar& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Literal_VarChar* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Literal.VarChar"; - } - protected: - explicit Expression_Literal_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kValueFieldNumber = 1, - kLengthFieldNumber = 2, - }; - // string value = 1; - void clear_value(); - const std::string& value() const; - template - 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: - - // uint32 length = 2; - void clear_length(); - uint32_t length() const; - void set_length(uint32_t value); - private: - uint32_t _internal_length() const; - void _internal_set_length(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.VarChar) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; - uint32_t length_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Literal_Decimal final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Decimal) */ { - public: - inline Expression_Literal_Decimal() : Expression_Literal_Decimal(nullptr) {} - ~Expression_Literal_Decimal() override; - explicit constexpr Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Literal_Decimal(const Expression_Literal_Decimal& from); - Expression_Literal_Decimal(Expression_Literal_Decimal&& from) noexcept - : Expression_Literal_Decimal() { - *this = ::std::move(from); - } - - inline Expression_Literal_Decimal& operator=(const Expression_Literal_Decimal& from) { - CopyFrom(from); - return *this; - } - inline Expression_Literal_Decimal& operator=(Expression_Literal_Decimal&& 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 Expression_Literal_Decimal& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_Literal_Decimal* internal_default_instance() { - return reinterpret_cast( - &_Expression_Literal_Decimal_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(Expression_Literal_Decimal& a, Expression_Literal_Decimal& b) { - a.Swap(&b); - } - inline void Swap(Expression_Literal_Decimal* 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(Expression_Literal_Decimal* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Literal_Decimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Literal_Decimal& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Literal_Decimal& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Literal_Decimal* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Literal.Decimal"; - } - protected: - explicit Expression_Literal_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kValueFieldNumber = 1, - kPrecisionFieldNumber = 2, - kScaleFieldNumber = 3, - }; - // bytes value = 1; - void clear_value(); - const std::string& value() const; - template - 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: - - // int32 precision = 2; - void clear_precision(); - int32_t precision() const; - void set_precision(int32_t value); - private: - int32_t _internal_precision() const; - void _internal_set_precision(int32_t value); - public: - - // int32 scale = 3; - void clear_scale(); - int32_t scale() const; - void set_scale(int32_t value); - private: - int32_t _internal_scale() const; - void _internal_set_scale(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Decimal) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_; - int32_t precision_; - int32_t scale_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Literal_Map_KeyValue final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Map.KeyValue) */ { - public: - inline Expression_Literal_Map_KeyValue() : Expression_Literal_Map_KeyValue(nullptr) {} - ~Expression_Literal_Map_KeyValue() override; - explicit constexpr Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Literal_Map_KeyValue(const Expression_Literal_Map_KeyValue& from); - Expression_Literal_Map_KeyValue(Expression_Literal_Map_KeyValue&& from) noexcept - : Expression_Literal_Map_KeyValue() { - *this = ::std::move(from); - } - - inline Expression_Literal_Map_KeyValue& operator=(const Expression_Literal_Map_KeyValue& from) { - CopyFrom(from); - return *this; - } - inline Expression_Literal_Map_KeyValue& operator=(Expression_Literal_Map_KeyValue&& 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 Expression_Literal_Map_KeyValue& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_Literal_Map_KeyValue* internal_default_instance() { - return reinterpret_cast( - &_Expression_Literal_Map_KeyValue_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(Expression_Literal_Map_KeyValue& a, Expression_Literal_Map_KeyValue& b) { - a.Swap(&b); - } - inline void Swap(Expression_Literal_Map_KeyValue* 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(Expression_Literal_Map_KeyValue* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Literal_Map_KeyValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Literal_Map_KeyValue& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Literal_Map_KeyValue& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Literal_Map_KeyValue* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Literal.Map.KeyValue"; - } - protected: - explicit Expression_Literal_Map_KeyValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kKeyFieldNumber = 1, - kValueFieldNumber = 2, - }; - // .substrait.Expression.Literal key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::substrait::Expression_Literal& key() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_key(); - ::substrait::Expression_Literal* mutable_key(); - void set_allocated_key(::substrait::Expression_Literal* key); - private: - const ::substrait::Expression_Literal& _internal_key() const; - ::substrait::Expression_Literal* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::substrait::Expression_Literal* key); - ::substrait::Expression_Literal* unsafe_arena_release_key(); - - // .substrait.Expression.Literal value = 2; - bool has_value() const; - private: - bool _internal_has_value() const; - public: - void clear_value(); - const ::substrait::Expression_Literal& value() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_value(); - ::substrait::Expression_Literal* mutable_value(); - void set_allocated_value(::substrait::Expression_Literal* value); - private: - const ::substrait::Expression_Literal& _internal_value() const; - ::substrait::Expression_Literal* _internal_mutable_value(); - public: - void unsafe_arena_set_allocated_value( - ::substrait::Expression_Literal* value); - ::substrait::Expression_Literal* unsafe_arena_release_value(); - - // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Map.KeyValue) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Expression_Literal* key_; - ::substrait::Expression_Literal* value_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Literal_Map final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Map) */ { - public: - inline Expression_Literal_Map() : Expression_Literal_Map(nullptr) {} - ~Expression_Literal_Map() override; - explicit constexpr Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Literal_Map(const Expression_Literal_Map& from); - Expression_Literal_Map(Expression_Literal_Map&& from) noexcept - : Expression_Literal_Map() { - *this = ::std::move(from); - } - - inline Expression_Literal_Map& operator=(const Expression_Literal_Map& from) { - CopyFrom(from); - return *this; - } - inline Expression_Literal_Map& operator=(Expression_Literal_Map&& 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 Expression_Literal_Map& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_Literal_Map* internal_default_instance() { - return reinterpret_cast( - &_Expression_Literal_Map_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(Expression_Literal_Map& a, Expression_Literal_Map& b) { - a.Swap(&b); - } - inline void Swap(Expression_Literal_Map* 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(Expression_Literal_Map* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Literal_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Literal_Map& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Literal_Map& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Literal_Map* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Literal.Map"; - } - protected: - explicit Expression_Literal_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_Literal_Map_KeyValue KeyValue; - - // accessors ------------------------------------------------------- - - enum : int { - kKeyValuesFieldNumber = 1, - }; - // repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; - int key_values_size() const; - private: - int _internal_key_values_size() const; - public: - void clear_key_values(); - ::substrait::Expression_Literal_Map_KeyValue* mutable_key_values(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >* - mutable_key_values(); - private: - const ::substrait::Expression_Literal_Map_KeyValue& _internal_key_values(int index) const; - ::substrait::Expression_Literal_Map_KeyValue* _internal_add_key_values(); - public: - const ::substrait::Expression_Literal_Map_KeyValue& key_values(int index) const; - ::substrait::Expression_Literal_Map_KeyValue* add_key_values(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >& - key_values() const; - - // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Map) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue > key_values_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Literal_IntervalYearToMonth final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.IntervalYearToMonth) */ { - public: - inline Expression_Literal_IntervalYearToMonth() : Expression_Literal_IntervalYearToMonth(nullptr) {} - ~Expression_Literal_IntervalYearToMonth() override; - explicit constexpr Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Literal_IntervalYearToMonth(const Expression_Literal_IntervalYearToMonth& from); - Expression_Literal_IntervalYearToMonth(Expression_Literal_IntervalYearToMonth&& from) noexcept - : Expression_Literal_IntervalYearToMonth() { - *this = ::std::move(from); - } - - inline Expression_Literal_IntervalYearToMonth& operator=(const Expression_Literal_IntervalYearToMonth& from) { - CopyFrom(from); - return *this; - } - inline Expression_Literal_IntervalYearToMonth& operator=(Expression_Literal_IntervalYearToMonth&& 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 Expression_Literal_IntervalYearToMonth& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_Literal_IntervalYearToMonth* internal_default_instance() { - return reinterpret_cast( - &_Expression_Literal_IntervalYearToMonth_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(Expression_Literal_IntervalYearToMonth& a, Expression_Literal_IntervalYearToMonth& b) { - a.Swap(&b); - } - inline void Swap(Expression_Literal_IntervalYearToMonth* 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(Expression_Literal_IntervalYearToMonth* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Literal_IntervalYearToMonth* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Literal_IntervalYearToMonth& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Literal_IntervalYearToMonth& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Literal_IntervalYearToMonth* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Literal.IntervalYearToMonth"; - } - protected: - explicit Expression_Literal_IntervalYearToMonth(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kYearsFieldNumber = 1, - kMonthsFieldNumber = 2, - }; - // int32 years = 1; - void clear_years(); - int32_t years() const; - void set_years(int32_t value); - private: - int32_t _internal_years() const; - void _internal_set_years(int32_t value); - public: - - // int32 months = 2; - void clear_months(); - int32_t months() const; - void set_months(int32_t value); - private: - int32_t _internal_months() const; - void _internal_set_months(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.IntervalYearToMonth) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int32_t years_; - int32_t months_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Literal_IntervalDayToSecond final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.IntervalDayToSecond) */ { - public: - inline Expression_Literal_IntervalDayToSecond() : Expression_Literal_IntervalDayToSecond(nullptr) {} - ~Expression_Literal_IntervalDayToSecond() override; - explicit constexpr Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Literal_IntervalDayToSecond(const Expression_Literal_IntervalDayToSecond& from); - Expression_Literal_IntervalDayToSecond(Expression_Literal_IntervalDayToSecond&& from) noexcept - : Expression_Literal_IntervalDayToSecond() { - *this = ::std::move(from); - } - - inline Expression_Literal_IntervalDayToSecond& operator=(const Expression_Literal_IntervalDayToSecond& from) { - CopyFrom(from); - return *this; - } - inline Expression_Literal_IntervalDayToSecond& operator=(Expression_Literal_IntervalDayToSecond&& 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 Expression_Literal_IntervalDayToSecond& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_Literal_IntervalDayToSecond* internal_default_instance() { - return reinterpret_cast( - &_Expression_Literal_IntervalDayToSecond_default_instance_); - } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(Expression_Literal_IntervalDayToSecond& a, Expression_Literal_IntervalDayToSecond& b) { - a.Swap(&b); - } - inline void Swap(Expression_Literal_IntervalDayToSecond* 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(Expression_Literal_IntervalDayToSecond* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Literal_IntervalDayToSecond* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Literal_IntervalDayToSecond& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Literal_IntervalDayToSecond& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Literal_IntervalDayToSecond* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Literal.IntervalDayToSecond"; - } - protected: - explicit Expression_Literal_IntervalDayToSecond(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kDaysFieldNumber = 1, - kSecondsFieldNumber = 2, - }; - // int32 days = 1; - void clear_days(); - int32_t days() const; - void set_days(int32_t value); - private: - int32_t _internal_days() const; - void _internal_set_days(int32_t value); - public: - - // int32 seconds = 2; - void clear_seconds(); - int32_t seconds() const; - void set_seconds(int32_t value); - private: - int32_t _internal_seconds() const; - void _internal_set_seconds(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.IntervalDayToSecond) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int32_t days_; - int32_t seconds_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Literal_Struct final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.Struct) */ { - public: - inline Expression_Literal_Struct() : Expression_Literal_Struct(nullptr) {} - ~Expression_Literal_Struct() override; - explicit constexpr Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Literal_Struct(const Expression_Literal_Struct& from); - Expression_Literal_Struct(Expression_Literal_Struct&& from) noexcept - : Expression_Literal_Struct() { - *this = ::std::move(from); - } - - inline Expression_Literal_Struct& operator=(const Expression_Literal_Struct& from) { - CopyFrom(from); - return *this; - } - inline Expression_Literal_Struct& operator=(Expression_Literal_Struct&& 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 Expression_Literal_Struct& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_Literal_Struct* internal_default_instance() { - return reinterpret_cast( - &_Expression_Literal_Struct_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(Expression_Literal_Struct& a, Expression_Literal_Struct& b) { - a.Swap(&b); - } - inline void Swap(Expression_Literal_Struct* 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(Expression_Literal_Struct* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Literal_Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Literal_Struct& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Literal_Struct& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Literal_Struct* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Literal.Struct"; - } - protected: - explicit Expression_Literal_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kFieldsFieldNumber = 1, - }; - // repeated .substrait.Expression.Literal fields = 1; - int fields_size() const; - private: - int _internal_fields_size() const; - public: - void clear_fields(); - ::substrait::Expression_Literal* mutable_fields(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >* - mutable_fields(); - private: - const ::substrait::Expression_Literal& _internal_fields(int index) const; - ::substrait::Expression_Literal* _internal_add_fields(); - public: - const ::substrait::Expression_Literal& fields(int index) const; - ::substrait::Expression_Literal* add_fields(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >& - fields() const; - - // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.Struct) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal > fields_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Literal_List final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal.List) */ { - public: - inline Expression_Literal_List() : Expression_Literal_List(nullptr) {} - ~Expression_Literal_List() override; - explicit constexpr Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Literal_List(const Expression_Literal_List& from); - Expression_Literal_List(Expression_Literal_List&& from) noexcept - : Expression_Literal_List() { - *this = ::std::move(from); - } - - inline Expression_Literal_List& operator=(const Expression_Literal_List& from) { - CopyFrom(from); - return *this; - } - inline Expression_Literal_List& operator=(Expression_Literal_List&& 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 Expression_Literal_List& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_Literal_List* internal_default_instance() { - return reinterpret_cast( - &_Expression_Literal_List_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(Expression_Literal_List& a, Expression_Literal_List& b) { - a.Swap(&b); - } - inline void Swap(Expression_Literal_List* 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(Expression_Literal_List* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Literal_List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Literal_List& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Literal_List& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Literal_List* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Literal.List"; - } - protected: - explicit Expression_Literal_List(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kValuesFieldNumber = 1, - }; - // repeated .substrait.Expression.Literal values = 1; - int values_size() const; - private: - int _internal_values_size() const; - public: - void clear_values(); - ::substrait::Expression_Literal* mutable_values(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >* - mutable_values(); - private: - const ::substrait::Expression_Literal& _internal_values(int index) const; - ::substrait::Expression_Literal* _internal_add_values(); - public: - const ::substrait::Expression_Literal& values(int index) const; - ::substrait::Expression_Literal* add_values(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >& - values() const; - - // @@protoc_insertion_point(class_scope:substrait.Expression.Literal.List) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal > values_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Literal final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Literal) */ { - public: - inline Expression_Literal() : Expression_Literal(nullptr) {} - ~Expression_Literal() override; - explicit constexpr Expression_Literal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Literal(const Expression_Literal& from); - Expression_Literal(Expression_Literal&& from) noexcept - : Expression_Literal() { - *this = ::std::move(from); - } - - inline Expression_Literal& operator=(const Expression_Literal& from) { - CopyFrom(from); - return *this; - } - inline Expression_Literal& operator=(Expression_Literal&& 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 Expression_Literal& default_instance() { - return *internal_default_instance(); - } - enum LiteralTypeCase { - kBoolean = 1, - kI8 = 2, - kI16 = 3, - kI32 = 5, - kI64 = 7, - kFp32 = 10, - kFp64 = 11, - kString = 12, - kBinary = 13, - kTimestamp = 14, - kDate = 16, - kTime = 17, - kIntervalYearToMonth = 19, - kIntervalDayToSecond = 20, - kFixedChar = 21, - kVarChar = 22, - kFixedBinary = 23, - kDecimal = 24, - kStruct = 25, - kMap = 26, - kTimestampTz = 27, - kUuid = 28, - kNull = 29, - kList = 30, - kEmptyList = 31, - kEmptyMap = 32, - LITERAL_TYPE_NOT_SET = 0, - }; - - static inline const Expression_Literal* internal_default_instance() { - return reinterpret_cast( - &_Expression_Literal_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(Expression_Literal& a, Expression_Literal& b) { - a.Swap(&b); - } - inline void Swap(Expression_Literal* 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(Expression_Literal* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Literal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Literal& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Literal& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Literal* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Literal"; - } - protected: - explicit Expression_Literal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_Literal_VarChar VarChar; - typedef Expression_Literal_Decimal Decimal; - typedef Expression_Literal_Map Map; - typedef Expression_Literal_IntervalYearToMonth IntervalYearToMonth; - typedef Expression_Literal_IntervalDayToSecond IntervalDayToSecond; - typedef Expression_Literal_Struct Struct; - typedef Expression_Literal_List List; - - // accessors ------------------------------------------------------- - - enum : int { - kNullableFieldNumber = 50, - kBooleanFieldNumber = 1, - kI8FieldNumber = 2, - kI16FieldNumber = 3, - kI32FieldNumber = 5, - kI64FieldNumber = 7, - kFp32FieldNumber = 10, - kFp64FieldNumber = 11, - kStringFieldNumber = 12, - kBinaryFieldNumber = 13, - kTimestampFieldNumber = 14, - kDateFieldNumber = 16, - kTimeFieldNumber = 17, - kIntervalYearToMonthFieldNumber = 19, - kIntervalDayToSecondFieldNumber = 20, - kFixedCharFieldNumber = 21, - kVarCharFieldNumber = 22, - kFixedBinaryFieldNumber = 23, - kDecimalFieldNumber = 24, - kStructFieldNumber = 25, - kMapFieldNumber = 26, - kTimestampTzFieldNumber = 27, - kUuidFieldNumber = 28, - kNullFieldNumber = 29, - kListFieldNumber = 30, - kEmptyListFieldNumber = 31, - kEmptyMapFieldNumber = 32, - }; - // bool nullable = 50; - void clear_nullable(); - bool nullable() const; - void set_nullable(bool value); - private: - bool _internal_nullable() const; - void _internal_set_nullable(bool value); - public: - - // bool boolean = 1; - bool has_boolean() const; - private: - bool _internal_has_boolean() const; - public: - void clear_boolean(); - bool boolean() const; - void set_boolean(bool value); - private: - bool _internal_boolean() const; - void _internal_set_boolean(bool value); - public: - - // int32 i8 = 2; - bool has_i8() const; - private: - bool _internal_has_i8() const; - public: - void clear_i8(); - int32_t i8() const; - void set_i8(int32_t value); - private: - int32_t _internal_i8() const; - void _internal_set_i8(int32_t value); - public: - - // int32 i16 = 3; - bool has_i16() const; - private: - bool _internal_has_i16() const; - public: - void clear_i16(); - int32_t i16() const; - void set_i16(int32_t value); - private: - int32_t _internal_i16() const; - void _internal_set_i16(int32_t value); - public: - - // int32 i32 = 5; - bool has_i32() const; - private: - bool _internal_has_i32() const; - public: - void clear_i32(); - int32_t i32() const; - void set_i32(int32_t value); - private: - int32_t _internal_i32() const; - void _internal_set_i32(int32_t value); - public: - - // int64 i64 = 7; - bool has_i64() const; - private: - bool _internal_has_i64() const; - public: - void clear_i64(); - int64_t i64() const; - void set_i64(int64_t value); - private: - int64_t _internal_i64() const; - void _internal_set_i64(int64_t value); - public: - - // float fp32 = 10; - bool has_fp32() const; - private: - bool _internal_has_fp32() const; - public: - void clear_fp32(); - float fp32() const; - void set_fp32(float value); - private: - float _internal_fp32() const; - void _internal_set_fp32(float value); - public: - - // double fp64 = 11; - bool has_fp64() const; - private: - bool _internal_has_fp64() const; - public: - void clear_fp64(); - double fp64() const; - void set_fp64(double value); - private: - double _internal_fp64() const; - void _internal_set_fp64(double value); - public: - - // string string = 12; - bool has_string() const; - private: - bool _internal_has_string() const; - public: - void clear_string(); - const std::string& string() const; - template - void set_string(ArgT0&& arg0, ArgT... args); - std::string* mutable_string(); - PROTOBUF_NODISCARD std::string* release_string(); - void set_allocated_string(std::string* string); - private: - const std::string& _internal_string() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_string(const std::string& value); - std::string* _internal_mutable_string(); - public: - - // bytes binary = 13; - bool has_binary() const; - private: - bool _internal_has_binary() const; - public: - void clear_binary(); - const std::string& binary() const; - template - void set_binary(ArgT0&& arg0, ArgT... args); - std::string* mutable_binary(); - PROTOBUF_NODISCARD std::string* release_binary(); - void set_allocated_binary(std::string* binary); - private: - const std::string& _internal_binary() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary(const std::string& value); - std::string* _internal_mutable_binary(); - public: - - // int64 timestamp = 14; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - int64_t timestamp() const; - void set_timestamp(int64_t value); - private: - int64_t _internal_timestamp() const; - void _internal_set_timestamp(int64_t value); - public: - - // int32 date = 16; - bool has_date() const; - private: - bool _internal_has_date() const; - public: - void clear_date(); - int32_t date() const; - void set_date(int32_t value); - private: - int32_t _internal_date() const; - void _internal_set_date(int32_t value); - public: - - // int64 time = 17; - bool has_time() const; - private: - bool _internal_has_time() const; - public: - void clear_time(); - int64_t time() const; - void set_time(int64_t value); - private: - int64_t _internal_time() const; - void _internal_set_time(int64_t value); - public: - - // .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; - bool has_interval_year_to_month() const; - private: - bool _internal_has_interval_year_to_month() const; - public: - void clear_interval_year_to_month(); - const ::substrait::Expression_Literal_IntervalYearToMonth& interval_year_to_month() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal_IntervalYearToMonth* release_interval_year_to_month(); - ::substrait::Expression_Literal_IntervalYearToMonth* mutable_interval_year_to_month(); - void set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month); - private: - const ::substrait::Expression_Literal_IntervalYearToMonth& _internal_interval_year_to_month() const; - ::substrait::Expression_Literal_IntervalYearToMonth* _internal_mutable_interval_year_to_month(); - public: - void unsafe_arena_set_allocated_interval_year_to_month( - ::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month); - ::substrait::Expression_Literal_IntervalYearToMonth* unsafe_arena_release_interval_year_to_month(); - - // .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; - bool has_interval_day_to_second() const; - private: - bool _internal_has_interval_day_to_second() const; - public: - void clear_interval_day_to_second(); - const ::substrait::Expression_Literal_IntervalDayToSecond& interval_day_to_second() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal_IntervalDayToSecond* release_interval_day_to_second(); - ::substrait::Expression_Literal_IntervalDayToSecond* mutable_interval_day_to_second(); - void set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second); - private: - const ::substrait::Expression_Literal_IntervalDayToSecond& _internal_interval_day_to_second() const; - ::substrait::Expression_Literal_IntervalDayToSecond* _internal_mutable_interval_day_to_second(); - public: - void unsafe_arena_set_allocated_interval_day_to_second( - ::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second); - ::substrait::Expression_Literal_IntervalDayToSecond* unsafe_arena_release_interval_day_to_second(); - - // string fixed_char = 21; - bool has_fixed_char() const; - private: - bool _internal_has_fixed_char() const; - public: - void clear_fixed_char(); - const std::string& fixed_char() const; - template - void set_fixed_char(ArgT0&& arg0, ArgT... args); - std::string* mutable_fixed_char(); - PROTOBUF_NODISCARD std::string* release_fixed_char(); - void set_allocated_fixed_char(std::string* fixed_char); - private: - const std::string& _internal_fixed_char() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fixed_char(const std::string& value); - std::string* _internal_mutable_fixed_char(); - public: - - // .substrait.Expression.Literal.VarChar var_char = 22; - bool has_var_char() const; - private: - bool _internal_has_var_char() const; - public: - void clear_var_char(); - const ::substrait::Expression_Literal_VarChar& var_char() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal_VarChar* release_var_char(); - ::substrait::Expression_Literal_VarChar* mutable_var_char(); - void set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char); - private: - const ::substrait::Expression_Literal_VarChar& _internal_var_char() const; - ::substrait::Expression_Literal_VarChar* _internal_mutable_var_char(); - public: - void unsafe_arena_set_allocated_var_char( - ::substrait::Expression_Literal_VarChar* var_char); - ::substrait::Expression_Literal_VarChar* unsafe_arena_release_var_char(); - - // bytes fixed_binary = 23; - bool has_fixed_binary() const; - private: - bool _internal_has_fixed_binary() const; - public: - void clear_fixed_binary(); - const std::string& fixed_binary() const; - template - void set_fixed_binary(ArgT0&& arg0, ArgT... args); - std::string* mutable_fixed_binary(); - PROTOBUF_NODISCARD std::string* release_fixed_binary(); - void set_allocated_fixed_binary(std::string* fixed_binary); - private: - const std::string& _internal_fixed_binary() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_fixed_binary(const std::string& value); - std::string* _internal_mutable_fixed_binary(); - public: - - // .substrait.Expression.Literal.Decimal decimal = 24; - bool has_decimal() const; - private: - bool _internal_has_decimal() const; - public: - void clear_decimal(); - const ::substrait::Expression_Literal_Decimal& decimal() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal_Decimal* release_decimal(); - ::substrait::Expression_Literal_Decimal* mutable_decimal(); - void set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal); - private: - const ::substrait::Expression_Literal_Decimal& _internal_decimal() const; - ::substrait::Expression_Literal_Decimal* _internal_mutable_decimal(); - public: - void unsafe_arena_set_allocated_decimal( - ::substrait::Expression_Literal_Decimal* decimal); - ::substrait::Expression_Literal_Decimal* unsafe_arena_release_decimal(); - - // .substrait.Expression.Literal.Struct struct = 25; - bool has_struct_() const; - private: - bool _internal_has_struct_() const; - public: - void clear_struct_(); - const ::substrait::Expression_Literal_Struct& struct_() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal_Struct* release_struct_(); - ::substrait::Expression_Literal_Struct* mutable_struct_(); - void set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_); - private: - const ::substrait::Expression_Literal_Struct& _internal_struct_() const; - ::substrait::Expression_Literal_Struct* _internal_mutable_struct_(); - public: - void unsafe_arena_set_allocated_struct_( - ::substrait::Expression_Literal_Struct* struct_); - ::substrait::Expression_Literal_Struct* unsafe_arena_release_struct_(); - - // .substrait.Expression.Literal.Map map = 26; - bool has_map() const; - private: - bool _internal_has_map() const; - public: - void clear_map(); - const ::substrait::Expression_Literal_Map& map() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal_Map* release_map(); - ::substrait::Expression_Literal_Map* mutable_map(); - void set_allocated_map(::substrait::Expression_Literal_Map* map); - private: - const ::substrait::Expression_Literal_Map& _internal_map() const; - ::substrait::Expression_Literal_Map* _internal_mutable_map(); - public: - void unsafe_arena_set_allocated_map( - ::substrait::Expression_Literal_Map* map); - ::substrait::Expression_Literal_Map* unsafe_arena_release_map(); - - // int64 timestamp_tz = 27; - bool has_timestamp_tz() const; - private: - bool _internal_has_timestamp_tz() const; - public: - void clear_timestamp_tz(); - int64_t timestamp_tz() const; - void set_timestamp_tz(int64_t value); - private: - int64_t _internal_timestamp_tz() const; - void _internal_set_timestamp_tz(int64_t value); - public: - - // bytes uuid = 28; - bool has_uuid() const; - private: - bool _internal_has_uuid() const; - public: - void clear_uuid(); - const std::string& uuid() const; - template - void set_uuid(ArgT0&& arg0, ArgT... args); - std::string* mutable_uuid(); - PROTOBUF_NODISCARD std::string* release_uuid(); - void set_allocated_uuid(std::string* uuid); - private: - const std::string& _internal_uuid() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_uuid(const std::string& value); - std::string* _internal_mutable_uuid(); - public: - - // .substrait.Type null = 29; - bool has_null() const; - private: - bool _internal_has_null() const; - public: - void clear_null(); - const ::substrait::Type& null() const; - PROTOBUF_NODISCARD ::substrait::Type* release_null(); - ::substrait::Type* mutable_null(); - void set_allocated_null(::substrait::Type* null); - private: - const ::substrait::Type& _internal_null() const; - ::substrait::Type* _internal_mutable_null(); - public: - void unsafe_arena_set_allocated_null( - ::substrait::Type* null); - ::substrait::Type* unsafe_arena_release_null(); - - // .substrait.Expression.Literal.List list = 30; - bool has_list() const; - private: - bool _internal_has_list() const; - public: - void clear_list(); - const ::substrait::Expression_Literal_List& list() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal_List* release_list(); - ::substrait::Expression_Literal_List* mutable_list(); - void set_allocated_list(::substrait::Expression_Literal_List* list); - private: - const ::substrait::Expression_Literal_List& _internal_list() const; - ::substrait::Expression_Literal_List* _internal_mutable_list(); - public: - void unsafe_arena_set_allocated_list( - ::substrait::Expression_Literal_List* list); - ::substrait::Expression_Literal_List* unsafe_arena_release_list(); - - // .substrait.Type.List empty_list = 31; - bool has_empty_list() const; - private: - bool _internal_has_empty_list() const; - public: - void clear_empty_list(); - const ::substrait::Type_List& empty_list() const; - PROTOBUF_NODISCARD ::substrait::Type_List* release_empty_list(); - ::substrait::Type_List* mutable_empty_list(); - void set_allocated_empty_list(::substrait::Type_List* empty_list); - private: - const ::substrait::Type_List& _internal_empty_list() const; - ::substrait::Type_List* _internal_mutable_empty_list(); - public: - void unsafe_arena_set_allocated_empty_list( - ::substrait::Type_List* empty_list); - ::substrait::Type_List* unsafe_arena_release_empty_list(); - - // .substrait.Type.Map empty_map = 32; - bool has_empty_map() const; - private: - bool _internal_has_empty_map() const; - public: - void clear_empty_map(); - const ::substrait::Type_Map& empty_map() const; - PROTOBUF_NODISCARD ::substrait::Type_Map* release_empty_map(); - ::substrait::Type_Map* mutable_empty_map(); - void set_allocated_empty_map(::substrait::Type_Map* empty_map); - private: - const ::substrait::Type_Map& _internal_empty_map() const; - ::substrait::Type_Map* _internal_mutable_empty_map(); - public: - void unsafe_arena_set_allocated_empty_map( - ::substrait::Type_Map* empty_map); - ::substrait::Type_Map* unsafe_arena_release_empty_map(); - - void clear_literal_type(); - LiteralTypeCase literal_type_case() const; - // @@protoc_insertion_point(class_scope:substrait.Expression.Literal) - private: - class _Internal; - void set_has_boolean(); - void set_has_i8(); - void set_has_i16(); - void set_has_i32(); - void set_has_i64(); - void set_has_fp32(); - void set_has_fp64(); - void set_has_string(); - void set_has_binary(); - void set_has_timestamp(); - void set_has_date(); - void set_has_time(); - void set_has_interval_year_to_month(); - void set_has_interval_day_to_second(); - void set_has_fixed_char(); - void set_has_var_char(); - void set_has_fixed_binary(); - void set_has_decimal(); - void set_has_struct_(); - void set_has_map(); - void set_has_timestamp_tz(); - void set_has_uuid(); - void set_has_null(); - void set_has_list(); - void set_has_empty_list(); - void set_has_empty_map(); - - inline bool has_literal_type() const; - inline void clear_has_literal_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - bool nullable_; - union LiteralTypeUnion { - constexpr LiteralTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - bool boolean_; - int32_t i8_; - int32_t i16_; - int32_t i32_; - int64_t i64_; - float fp32_; - double fp64_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr string_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_; - int64_t timestamp_; - int32_t date_; - int64_t time_; - ::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month_; - ::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_char_; - ::substrait::Expression_Literal_VarChar* var_char_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fixed_binary_; - ::substrait::Expression_Literal_Decimal* decimal_; - ::substrait::Expression_Literal_Struct* struct__; - ::substrait::Expression_Literal_Map* map_; - int64_t timestamp_tz_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uuid_; - ::substrait::Type* null_; - ::substrait::Expression_Literal_List* list_; - ::substrait::Type_List* empty_list_; - ::substrait::Type_Map* empty_map_; - } literal_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_ScalarFunction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ScalarFunction) */ { - public: - inline Expression_ScalarFunction() : Expression_ScalarFunction(nullptr) {} - ~Expression_ScalarFunction() override; - explicit constexpr Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_ScalarFunction(const Expression_ScalarFunction& from); - Expression_ScalarFunction(Expression_ScalarFunction&& from) noexcept - : Expression_ScalarFunction() { - *this = ::std::move(from); - } - - inline Expression_ScalarFunction& operator=(const Expression_ScalarFunction& from) { - CopyFrom(from); - return *this; - } - inline Expression_ScalarFunction& operator=(Expression_ScalarFunction&& 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 Expression_ScalarFunction& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_ScalarFunction* internal_default_instance() { - return reinterpret_cast( - &_Expression_ScalarFunction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(Expression_ScalarFunction& a, Expression_ScalarFunction& b) { - a.Swap(&b); - } - inline void Swap(Expression_ScalarFunction* 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(Expression_ScalarFunction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_ScalarFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_ScalarFunction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_ScalarFunction& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_ScalarFunction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.ScalarFunction"; - } - protected: - explicit Expression_ScalarFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kArgsFieldNumber = 2, - kOutputTypeFieldNumber = 3, - kFunctionReferenceFieldNumber = 1, - }; - // repeated .substrait.Expression args = 2; - int args_size() const; - private: - int _internal_args_size() const; - public: - void clear_args(); - ::substrait::Expression* mutable_args(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* - mutable_args(); - private: - const ::substrait::Expression& _internal_args(int index) const; - ::substrait::Expression* _internal_add_args(); - public: - const ::substrait::Expression& args(int index) const; - ::substrait::Expression* add_args(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& - args() const; - - // .substrait.Type output_type = 3; - bool has_output_type() const; - private: - bool _internal_has_output_type() const; - public: - void clear_output_type(); - const ::substrait::Type& output_type() const; - PROTOBUF_NODISCARD ::substrait::Type* release_output_type(); - ::substrait::Type* mutable_output_type(); - void set_allocated_output_type(::substrait::Type* output_type); - private: - const ::substrait::Type& _internal_output_type() const; - ::substrait::Type* _internal_mutable_output_type(); - public: - void unsafe_arena_set_allocated_output_type( - ::substrait::Type* output_type); - ::substrait::Type* unsafe_arena_release_output_type(); - - // uint32 function_reference = 1; - void clear_function_reference(); - uint32_t function_reference() const; - void set_function_reference(uint32_t value); - private: - uint32_t _internal_function_reference() const; - void _internal_set_function_reference(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.ScalarFunction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_; - ::substrait::Type* output_type_; - uint32_t function_reference_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_WindowFunction_Bound_Preceding final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Preceding) */ { - public: - inline Expression_WindowFunction_Bound_Preceding() : Expression_WindowFunction_Bound_Preceding(nullptr) {} - ~Expression_WindowFunction_Bound_Preceding() override; - explicit constexpr Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_WindowFunction_Bound_Preceding(const Expression_WindowFunction_Bound_Preceding& from); - Expression_WindowFunction_Bound_Preceding(Expression_WindowFunction_Bound_Preceding&& from) noexcept - : Expression_WindowFunction_Bound_Preceding() { - *this = ::std::move(from); - } - - inline Expression_WindowFunction_Bound_Preceding& operator=(const Expression_WindowFunction_Bound_Preceding& from) { - CopyFrom(from); - return *this; - } - inline Expression_WindowFunction_Bound_Preceding& operator=(Expression_WindowFunction_Bound_Preceding&& 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 Expression_WindowFunction_Bound_Preceding& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_WindowFunction_Bound_Preceding* internal_default_instance() { - return reinterpret_cast( - &_Expression_WindowFunction_Bound_Preceding_default_instance_); - } - static constexpr int kIndexInFileMessages = - 12; - - friend void swap(Expression_WindowFunction_Bound_Preceding& a, Expression_WindowFunction_Bound_Preceding& b) { - a.Swap(&b); - } - inline void Swap(Expression_WindowFunction_Bound_Preceding* 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(Expression_WindowFunction_Bound_Preceding* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_WindowFunction_Bound_Preceding* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_WindowFunction_Bound_Preceding& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_WindowFunction_Bound_Preceding& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_WindowFunction_Bound_Preceding* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.WindowFunction.Bound.Preceding"; - } - protected: - explicit Expression_WindowFunction_Bound_Preceding(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kOffsetFieldNumber = 1, - }; - // int64 offset = 1; - void clear_offset(); - int64_t offset() const; - void set_offset(int64_t value); - private: - int64_t _internal_offset() const; - void _internal_set_offset(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Preceding) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int64_t offset_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_WindowFunction_Bound_Following final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Following) */ { - public: - inline Expression_WindowFunction_Bound_Following() : Expression_WindowFunction_Bound_Following(nullptr) {} - ~Expression_WindowFunction_Bound_Following() override; - explicit constexpr Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_WindowFunction_Bound_Following(const Expression_WindowFunction_Bound_Following& from); - Expression_WindowFunction_Bound_Following(Expression_WindowFunction_Bound_Following&& from) noexcept - : Expression_WindowFunction_Bound_Following() { - *this = ::std::move(from); - } - - inline Expression_WindowFunction_Bound_Following& operator=(const Expression_WindowFunction_Bound_Following& from) { - CopyFrom(from); - return *this; - } - inline Expression_WindowFunction_Bound_Following& operator=(Expression_WindowFunction_Bound_Following&& 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 Expression_WindowFunction_Bound_Following& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_WindowFunction_Bound_Following* internal_default_instance() { - return reinterpret_cast( - &_Expression_WindowFunction_Bound_Following_default_instance_); - } - static constexpr int kIndexInFileMessages = - 13; - - friend void swap(Expression_WindowFunction_Bound_Following& a, Expression_WindowFunction_Bound_Following& b) { - a.Swap(&b); - } - inline void Swap(Expression_WindowFunction_Bound_Following* 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(Expression_WindowFunction_Bound_Following* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_WindowFunction_Bound_Following* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_WindowFunction_Bound_Following& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_WindowFunction_Bound_Following& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_WindowFunction_Bound_Following* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.WindowFunction.Bound.Following"; - } - protected: - explicit Expression_WindowFunction_Bound_Following(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kOffsetFieldNumber = 1, - }; - // int64 offset = 1; - void clear_offset(); - int64_t offset() const; - void set_offset(int64_t value); - private: - int64_t _internal_offset() const; - void _internal_set_offset(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Following) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int64_t offset_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_WindowFunction_Bound_CurrentRow final : - public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.CurrentRow) */ { - public: - inline Expression_WindowFunction_Bound_CurrentRow() : Expression_WindowFunction_Bound_CurrentRow(nullptr) {} - explicit constexpr Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_WindowFunction_Bound_CurrentRow(const Expression_WindowFunction_Bound_CurrentRow& from); - Expression_WindowFunction_Bound_CurrentRow(Expression_WindowFunction_Bound_CurrentRow&& from) noexcept - : Expression_WindowFunction_Bound_CurrentRow() { - *this = ::std::move(from); - } - - inline Expression_WindowFunction_Bound_CurrentRow& operator=(const Expression_WindowFunction_Bound_CurrentRow& from) { - CopyFrom(from); - return *this; - } - inline Expression_WindowFunction_Bound_CurrentRow& operator=(Expression_WindowFunction_Bound_CurrentRow&& 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 Expression_WindowFunction_Bound_CurrentRow& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_WindowFunction_Bound_CurrentRow* internal_default_instance() { - return reinterpret_cast( - &_Expression_WindowFunction_Bound_CurrentRow_default_instance_); - } - static constexpr int kIndexInFileMessages = - 14; - - friend void swap(Expression_WindowFunction_Bound_CurrentRow& a, Expression_WindowFunction_Bound_CurrentRow& b) { - a.Swap(&b); - } - inline void Swap(Expression_WindowFunction_Bound_CurrentRow* 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(Expression_WindowFunction_Bound_CurrentRow* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_WindowFunction_Bound_CurrentRow* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; - inline void CopyFrom(const Expression_WindowFunction_Bound_CurrentRow& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; - void MergeFrom(const Expression_WindowFunction_Bound_CurrentRow& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); - } - public: - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.WindowFunction.Bound.CurrentRow"; - } - protected: - explicit Expression_WindowFunction_Bound_CurrentRow(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - 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 ------------------------------------------------------- - - // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.CurrentRow) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_WindowFunction_Bound_Unbounded final : - public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound.Unbounded) */ { - public: - inline Expression_WindowFunction_Bound_Unbounded() : Expression_WindowFunction_Bound_Unbounded(nullptr) {} - explicit constexpr Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_WindowFunction_Bound_Unbounded(const Expression_WindowFunction_Bound_Unbounded& from); - Expression_WindowFunction_Bound_Unbounded(Expression_WindowFunction_Bound_Unbounded&& from) noexcept - : Expression_WindowFunction_Bound_Unbounded() { - *this = ::std::move(from); - } - - inline Expression_WindowFunction_Bound_Unbounded& operator=(const Expression_WindowFunction_Bound_Unbounded& from) { - CopyFrom(from); - return *this; - } - inline Expression_WindowFunction_Bound_Unbounded& operator=(Expression_WindowFunction_Bound_Unbounded&& 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 Expression_WindowFunction_Bound_Unbounded& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_WindowFunction_Bound_Unbounded* internal_default_instance() { - return reinterpret_cast( - &_Expression_WindowFunction_Bound_Unbounded_default_instance_); - } - static constexpr int kIndexInFileMessages = - 15; - - friend void swap(Expression_WindowFunction_Bound_Unbounded& a, Expression_WindowFunction_Bound_Unbounded& b) { - a.Swap(&b); - } - inline void Swap(Expression_WindowFunction_Bound_Unbounded* 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(Expression_WindowFunction_Bound_Unbounded* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_WindowFunction_Bound_Unbounded* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; - inline void CopyFrom(const Expression_WindowFunction_Bound_Unbounded& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; - void MergeFrom(const Expression_WindowFunction_Bound_Unbounded& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); - } - public: - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.WindowFunction.Bound.Unbounded"; - } - protected: - explicit Expression_WindowFunction_Bound_Unbounded(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - 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 ------------------------------------------------------- - - // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound.Unbounded) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_WindowFunction_Bound final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction.Bound) */ { - public: - inline Expression_WindowFunction_Bound() : Expression_WindowFunction_Bound(nullptr) {} - ~Expression_WindowFunction_Bound() override; - explicit constexpr Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_WindowFunction_Bound(const Expression_WindowFunction_Bound& from); - Expression_WindowFunction_Bound(Expression_WindowFunction_Bound&& from) noexcept - : Expression_WindowFunction_Bound() { - *this = ::std::move(from); - } - - inline Expression_WindowFunction_Bound& operator=(const Expression_WindowFunction_Bound& from) { - CopyFrom(from); - return *this; - } - inline Expression_WindowFunction_Bound& operator=(Expression_WindowFunction_Bound&& 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 Expression_WindowFunction_Bound& default_instance() { - return *internal_default_instance(); - } - enum KindCase { - kPreceding = 1, - kFollowing = 2, - kCurrentRow = 3, - kUnbounded = 4, - KIND_NOT_SET = 0, - }; - - static inline const Expression_WindowFunction_Bound* internal_default_instance() { - return reinterpret_cast( - &_Expression_WindowFunction_Bound_default_instance_); - } - static constexpr int kIndexInFileMessages = - 16; - - friend void swap(Expression_WindowFunction_Bound& a, Expression_WindowFunction_Bound& b) { - a.Swap(&b); - } - inline void Swap(Expression_WindowFunction_Bound* 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(Expression_WindowFunction_Bound* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_WindowFunction_Bound* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_WindowFunction_Bound& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_WindowFunction_Bound& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_WindowFunction_Bound* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.WindowFunction.Bound"; - } - protected: - explicit Expression_WindowFunction_Bound(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_WindowFunction_Bound_Preceding Preceding; - typedef Expression_WindowFunction_Bound_Following Following; - typedef Expression_WindowFunction_Bound_CurrentRow CurrentRow; - typedef Expression_WindowFunction_Bound_Unbounded Unbounded; - - // accessors ------------------------------------------------------- - - enum : int { - kPrecedingFieldNumber = 1, - kFollowingFieldNumber = 2, - kCurrentRowFieldNumber = 3, - kUnboundedFieldNumber = 4, - }; - // .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; - bool has_preceding() const; - private: - bool _internal_has_preceding() const; - public: - void clear_preceding(); - const ::substrait::Expression_WindowFunction_Bound_Preceding& preceding() const; - PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_Preceding* release_preceding(); - ::substrait::Expression_WindowFunction_Bound_Preceding* mutable_preceding(); - void set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding); - private: - const ::substrait::Expression_WindowFunction_Bound_Preceding& _internal_preceding() const; - ::substrait::Expression_WindowFunction_Bound_Preceding* _internal_mutable_preceding(); - public: - void unsafe_arena_set_allocated_preceding( - ::substrait::Expression_WindowFunction_Bound_Preceding* preceding); - ::substrait::Expression_WindowFunction_Bound_Preceding* unsafe_arena_release_preceding(); - - // .substrait.Expression.WindowFunction.Bound.Following following = 2; - bool has_following() const; - private: - bool _internal_has_following() const; - public: - void clear_following(); - const ::substrait::Expression_WindowFunction_Bound_Following& following() const; - PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_Following* release_following(); - ::substrait::Expression_WindowFunction_Bound_Following* mutable_following(); - void set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following); - private: - const ::substrait::Expression_WindowFunction_Bound_Following& _internal_following() const; - ::substrait::Expression_WindowFunction_Bound_Following* _internal_mutable_following(); - public: - void unsafe_arena_set_allocated_following( - ::substrait::Expression_WindowFunction_Bound_Following* following); - ::substrait::Expression_WindowFunction_Bound_Following* unsafe_arena_release_following(); - - // .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; - bool has_current_row() const; - private: - bool _internal_has_current_row() const; - public: - void clear_current_row(); - const ::substrait::Expression_WindowFunction_Bound_CurrentRow& current_row() const; - PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_CurrentRow* release_current_row(); - ::substrait::Expression_WindowFunction_Bound_CurrentRow* mutable_current_row(); - void set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row); - private: - const ::substrait::Expression_WindowFunction_Bound_CurrentRow& _internal_current_row() const; - ::substrait::Expression_WindowFunction_Bound_CurrentRow* _internal_mutable_current_row(); - public: - void unsafe_arena_set_allocated_current_row( - ::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row); - ::substrait::Expression_WindowFunction_Bound_CurrentRow* unsafe_arena_release_current_row(); - - // .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; - bool has_unbounded() const; - private: - bool _internal_has_unbounded() const; - public: - void clear_unbounded(); - const ::substrait::Expression_WindowFunction_Bound_Unbounded& unbounded() const; - PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound_Unbounded* release_unbounded(); - ::substrait::Expression_WindowFunction_Bound_Unbounded* mutable_unbounded(); - void set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded); - private: - const ::substrait::Expression_WindowFunction_Bound_Unbounded& _internal_unbounded() const; - ::substrait::Expression_WindowFunction_Bound_Unbounded* _internal_mutable_unbounded(); - public: - void unsafe_arena_set_allocated_unbounded( - ::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded); - ::substrait::Expression_WindowFunction_Bound_Unbounded* unsafe_arena_release_unbounded(); - - void clear_kind(); - KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction.Bound) - private: - class _Internal; - void set_has_preceding(); - void set_has_following(); - void set_has_current_row(); - void set_has_unbounded(); - - inline bool has_kind() const; - inline void clear_has_kind(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union KindUnion { - constexpr KindUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Expression_WindowFunction_Bound_Preceding* preceding_; - ::substrait::Expression_WindowFunction_Bound_Following* following_; - ::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row_; - ::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded_; - } kind_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_WindowFunction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.WindowFunction) */ { - public: - inline Expression_WindowFunction() : Expression_WindowFunction(nullptr) {} - ~Expression_WindowFunction() override; - explicit constexpr Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_WindowFunction(const Expression_WindowFunction& from); - Expression_WindowFunction(Expression_WindowFunction&& from) noexcept - : Expression_WindowFunction() { - *this = ::std::move(from); - } - - inline Expression_WindowFunction& operator=(const Expression_WindowFunction& from) { - CopyFrom(from); - return *this; - } - inline Expression_WindowFunction& operator=(Expression_WindowFunction&& 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 Expression_WindowFunction& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_WindowFunction* internal_default_instance() { - return reinterpret_cast( - &_Expression_WindowFunction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 17; - - friend void swap(Expression_WindowFunction& a, Expression_WindowFunction& b) { - a.Swap(&b); - } - inline void Swap(Expression_WindowFunction* 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(Expression_WindowFunction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_WindowFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_WindowFunction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_WindowFunction& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_WindowFunction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.WindowFunction"; - } - protected: - explicit Expression_WindowFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_WindowFunction_Bound Bound; - - // accessors ------------------------------------------------------- - - enum : int { - kPartitionsFieldNumber = 2, - kSortsFieldNumber = 3, - kArgsFieldNumber = 8, - kUpperBoundFieldNumber = 4, - kLowerBoundFieldNumber = 5, - kOutputTypeFieldNumber = 7, - kFunctionReferenceFieldNumber = 1, - kPhaseFieldNumber = 6, - }; - // repeated .substrait.Expression partitions = 2; - int partitions_size() const; - private: - int _internal_partitions_size() const; - public: - void clear_partitions(); - ::substrait::Expression* mutable_partitions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* - mutable_partitions(); - private: - const ::substrait::Expression& _internal_partitions(int index) const; - ::substrait::Expression* _internal_add_partitions(); - public: - const ::substrait::Expression& partitions(int index) const; - ::substrait::Expression* add_partitions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& - partitions() const; - - // repeated .substrait.SortField sorts = 3; - int sorts_size() const; - private: - int _internal_sorts_size() const; - public: - void clear_sorts(); - ::substrait::SortField* mutable_sorts(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* - mutable_sorts(); - private: - const ::substrait::SortField& _internal_sorts(int index) const; - ::substrait::SortField* _internal_add_sorts(); - public: - const ::substrait::SortField& sorts(int index) const; - ::substrait::SortField* add_sorts(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& - sorts() const; - - // repeated .substrait.Expression args = 8; - int args_size() const; - private: - int _internal_args_size() const; - public: - void clear_args(); - ::substrait::Expression* mutable_args(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* - mutable_args(); - private: - const ::substrait::Expression& _internal_args(int index) const; - ::substrait::Expression* _internal_add_args(); - public: - const ::substrait::Expression& args(int index) const; - ::substrait::Expression* add_args(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& - args() const; - - // .substrait.Expression.WindowFunction.Bound upper_bound = 4; - bool has_upper_bound() const; - private: - bool _internal_has_upper_bound() const; - public: - void clear_upper_bound(); - const ::substrait::Expression_WindowFunction_Bound& upper_bound() const; - PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound* release_upper_bound(); - ::substrait::Expression_WindowFunction_Bound* mutable_upper_bound(); - void set_allocated_upper_bound(::substrait::Expression_WindowFunction_Bound* upper_bound); - private: - const ::substrait::Expression_WindowFunction_Bound& _internal_upper_bound() const; - ::substrait::Expression_WindowFunction_Bound* _internal_mutable_upper_bound(); - public: - void unsafe_arena_set_allocated_upper_bound( - ::substrait::Expression_WindowFunction_Bound* upper_bound); - ::substrait::Expression_WindowFunction_Bound* unsafe_arena_release_upper_bound(); - - // .substrait.Expression.WindowFunction.Bound lower_bound = 5; - bool has_lower_bound() const; - private: - bool _internal_has_lower_bound() const; - public: - void clear_lower_bound(); - const ::substrait::Expression_WindowFunction_Bound& lower_bound() const; - PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction_Bound* release_lower_bound(); - ::substrait::Expression_WindowFunction_Bound* mutable_lower_bound(); - void set_allocated_lower_bound(::substrait::Expression_WindowFunction_Bound* lower_bound); - private: - const ::substrait::Expression_WindowFunction_Bound& _internal_lower_bound() const; - ::substrait::Expression_WindowFunction_Bound* _internal_mutable_lower_bound(); - public: - void unsafe_arena_set_allocated_lower_bound( - ::substrait::Expression_WindowFunction_Bound* lower_bound); - ::substrait::Expression_WindowFunction_Bound* unsafe_arena_release_lower_bound(); - - // .substrait.Type output_type = 7; - bool has_output_type() const; - private: - bool _internal_has_output_type() const; - public: - void clear_output_type(); - const ::substrait::Type& output_type() const; - PROTOBUF_NODISCARD ::substrait::Type* release_output_type(); - ::substrait::Type* mutable_output_type(); - void set_allocated_output_type(::substrait::Type* output_type); - private: - const ::substrait::Type& _internal_output_type() const; - ::substrait::Type* _internal_mutable_output_type(); - public: - void unsafe_arena_set_allocated_output_type( - ::substrait::Type* output_type); - ::substrait::Type* unsafe_arena_release_output_type(); - - // uint32 function_reference = 1; - void clear_function_reference(); - uint32_t function_reference() const; - void set_function_reference(uint32_t value); - private: - uint32_t _internal_function_reference() const; - void _internal_set_function_reference(uint32_t value); - public: - - // .substrait.AggregationPhase phase = 6; - void clear_phase(); - ::substrait::AggregationPhase phase() const; - void set_phase(::substrait::AggregationPhase value); - private: - ::substrait::AggregationPhase _internal_phase() const; - void _internal_set_phase(::substrait::AggregationPhase value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.WindowFunction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > partitions_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField > sorts_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_; - ::substrait::Expression_WindowFunction_Bound* upper_bound_; - ::substrait::Expression_WindowFunction_Bound* lower_bound_; - ::substrait::Type* output_type_; - uint32_t function_reference_; - int phase_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_IfThen_IfClause final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.IfThen.IfClause) */ { - public: - inline Expression_IfThen_IfClause() : Expression_IfThen_IfClause(nullptr) {} - ~Expression_IfThen_IfClause() override; - explicit constexpr Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_IfThen_IfClause(const Expression_IfThen_IfClause& from); - Expression_IfThen_IfClause(Expression_IfThen_IfClause&& from) noexcept - : Expression_IfThen_IfClause() { - *this = ::std::move(from); - } - - inline Expression_IfThen_IfClause& operator=(const Expression_IfThen_IfClause& from) { - CopyFrom(from); - return *this; - } - inline Expression_IfThen_IfClause& operator=(Expression_IfThen_IfClause&& 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 Expression_IfThen_IfClause& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_IfThen_IfClause* internal_default_instance() { - return reinterpret_cast( - &_Expression_IfThen_IfClause_default_instance_); - } - static constexpr int kIndexInFileMessages = - 18; - - friend void swap(Expression_IfThen_IfClause& a, Expression_IfThen_IfClause& b) { - a.Swap(&b); - } - inline void Swap(Expression_IfThen_IfClause* 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(Expression_IfThen_IfClause* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_IfThen_IfClause* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_IfThen_IfClause& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_IfThen_IfClause& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_IfThen_IfClause* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.IfThen.IfClause"; - } - protected: - explicit Expression_IfThen_IfClause(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kIfFieldNumber = 1, - kThenFieldNumber = 2, - }; - // .substrait.Expression if = 1; - bool has_if_() const; - private: - bool _internal_has_if_() const; - public: - void clear_if_(); - const ::substrait::Expression& if_() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_if_(); - ::substrait::Expression* mutable_if_(); - void set_allocated_if_(::substrait::Expression* if_); - private: - const ::substrait::Expression& _internal_if_() const; - ::substrait::Expression* _internal_mutable_if_(); - public: - void unsafe_arena_set_allocated_if_( - ::substrait::Expression* if_); - ::substrait::Expression* unsafe_arena_release_if_(); - - // .substrait.Expression then = 2; - bool has_then() const; - private: - bool _internal_has_then() const; - public: - void clear_then(); - const ::substrait::Expression& then() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_then(); - ::substrait::Expression* mutable_then(); - void set_allocated_then(::substrait::Expression* then); - private: - const ::substrait::Expression& _internal_then() const; - ::substrait::Expression* _internal_mutable_then(); - public: - void unsafe_arena_set_allocated_then( - ::substrait::Expression* then); - ::substrait::Expression* unsafe_arena_release_then(); - - // @@protoc_insertion_point(class_scope:substrait.Expression.IfThen.IfClause) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Expression* if__; - ::substrait::Expression* then_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_IfThen final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.IfThen) */ { - public: - inline Expression_IfThen() : Expression_IfThen(nullptr) {} - ~Expression_IfThen() override; - explicit constexpr Expression_IfThen(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_IfThen(const Expression_IfThen& from); - Expression_IfThen(Expression_IfThen&& from) noexcept - : Expression_IfThen() { - *this = ::std::move(from); - } - - inline Expression_IfThen& operator=(const Expression_IfThen& from) { - CopyFrom(from); - return *this; - } - inline Expression_IfThen& operator=(Expression_IfThen&& 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 Expression_IfThen& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_IfThen* internal_default_instance() { - return reinterpret_cast( - &_Expression_IfThen_default_instance_); - } - static constexpr int kIndexInFileMessages = - 19; - - friend void swap(Expression_IfThen& a, Expression_IfThen& b) { - a.Swap(&b); - } - inline void Swap(Expression_IfThen* 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(Expression_IfThen* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_IfThen* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_IfThen& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_IfThen& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_IfThen* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.IfThen"; - } - protected: - explicit Expression_IfThen(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_IfThen_IfClause IfClause; - - // accessors ------------------------------------------------------- - - enum : int { - kIfsFieldNumber = 1, - kElseFieldNumber = 2, - }; - // repeated .substrait.Expression.IfThen.IfClause ifs = 1; - int ifs_size() const; - private: - int _internal_ifs_size() const; - public: - void clear_ifs(); - ::substrait::Expression_IfThen_IfClause* mutable_ifs(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >* - mutable_ifs(); - private: - const ::substrait::Expression_IfThen_IfClause& _internal_ifs(int index) const; - ::substrait::Expression_IfThen_IfClause* _internal_add_ifs(); - public: - const ::substrait::Expression_IfThen_IfClause& ifs(int index) const; - ::substrait::Expression_IfThen_IfClause* add_ifs(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >& - ifs() const; - - // .substrait.Expression else = 2; - bool has_else_() const; - private: - bool _internal_has_else_() const; - public: - void clear_else_(); - const ::substrait::Expression& else_() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_else_(); - ::substrait::Expression* mutable_else_(); - void set_allocated_else_(::substrait::Expression* else_); - private: - const ::substrait::Expression& _internal_else_() const; - ::substrait::Expression* _internal_mutable_else_(); - public: - void unsafe_arena_set_allocated_else_( - ::substrait::Expression* else_); - ::substrait::Expression* unsafe_arena_release_else_(); - - // @@protoc_insertion_point(class_scope:substrait.Expression.IfThen) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause > ifs_; - ::substrait::Expression* else__; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_Cast final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.Cast) */ { - public: - inline Expression_Cast() : Expression_Cast(nullptr) {} - ~Expression_Cast() override; - explicit constexpr Expression_Cast(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_Cast(const Expression_Cast& from); - Expression_Cast(Expression_Cast&& from) noexcept - : Expression_Cast() { - *this = ::std::move(from); - } - - inline Expression_Cast& operator=(const Expression_Cast& from) { - CopyFrom(from); - return *this; - } - inline Expression_Cast& operator=(Expression_Cast&& 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 Expression_Cast& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_Cast* internal_default_instance() { - return reinterpret_cast( - &_Expression_Cast_default_instance_); - } - static constexpr int kIndexInFileMessages = - 20; - - friend void swap(Expression_Cast& a, Expression_Cast& b) { - a.Swap(&b); - } - inline void Swap(Expression_Cast* 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(Expression_Cast* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_Cast* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_Cast& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_Cast& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_Cast* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.Cast"; - } - protected: - explicit Expression_Cast(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeFieldNumber = 1, - kInputFieldNumber = 2, - }; - // .substrait.Type type = 1; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - const ::substrait::Type& type() const; - PROTOBUF_NODISCARD ::substrait::Type* release_type(); - ::substrait::Type* mutable_type(); - void set_allocated_type(::substrait::Type* type); - private: - const ::substrait::Type& _internal_type() const; - ::substrait::Type* _internal_mutable_type(); - public: - void unsafe_arena_set_allocated_type( - ::substrait::Type* type); - ::substrait::Type* unsafe_arena_release_type(); - - // .substrait.Expression input = 2; - bool has_input() const; - private: - bool _internal_has_input() const; - public: - void clear_input(); - const ::substrait::Expression& input() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_input(); - ::substrait::Expression* mutable_input(); - void set_allocated_input(::substrait::Expression* input); - private: - const ::substrait::Expression& _internal_input() const; - ::substrait::Expression* _internal_mutable_input(); - public: - void unsafe_arena_set_allocated_input( - ::substrait::Expression* input); - ::substrait::Expression* unsafe_arena_release_input(); - - // @@protoc_insertion_point(class_scope:substrait.Expression.Cast) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Type* type_; - ::substrait::Expression* input_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_SwitchExpression_IfValue final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SwitchExpression.IfValue) */ { - public: - inline Expression_SwitchExpression_IfValue() : Expression_SwitchExpression_IfValue(nullptr) {} - ~Expression_SwitchExpression_IfValue() override; - explicit constexpr Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_SwitchExpression_IfValue(const Expression_SwitchExpression_IfValue& from); - Expression_SwitchExpression_IfValue(Expression_SwitchExpression_IfValue&& from) noexcept - : Expression_SwitchExpression_IfValue() { - *this = ::std::move(from); - } - - inline Expression_SwitchExpression_IfValue& operator=(const Expression_SwitchExpression_IfValue& from) { - CopyFrom(from); - return *this; - } - inline Expression_SwitchExpression_IfValue& operator=(Expression_SwitchExpression_IfValue&& 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 Expression_SwitchExpression_IfValue& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_SwitchExpression_IfValue* internal_default_instance() { - return reinterpret_cast( - &_Expression_SwitchExpression_IfValue_default_instance_); - } - static constexpr int kIndexInFileMessages = - 21; - - friend void swap(Expression_SwitchExpression_IfValue& a, Expression_SwitchExpression_IfValue& b) { - a.Swap(&b); - } - inline void Swap(Expression_SwitchExpression_IfValue* 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(Expression_SwitchExpression_IfValue* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_SwitchExpression_IfValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_SwitchExpression_IfValue& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_SwitchExpression_IfValue& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_SwitchExpression_IfValue* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.SwitchExpression.IfValue"; - } - protected: - explicit Expression_SwitchExpression_IfValue(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kIfFieldNumber = 1, - kThenFieldNumber = 2, - }; - // .substrait.Expression.Literal if = 1; - bool has_if_() const; - private: - bool _internal_has_if_() const; - public: - void clear_if_(); - const ::substrait::Expression_Literal& if_() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_if_(); - ::substrait::Expression_Literal* mutable_if_(); - void set_allocated_if_(::substrait::Expression_Literal* if_); - private: - const ::substrait::Expression_Literal& _internal_if_() const; - ::substrait::Expression_Literal* _internal_mutable_if_(); - public: - void unsafe_arena_set_allocated_if_( - ::substrait::Expression_Literal* if_); - ::substrait::Expression_Literal* unsafe_arena_release_if_(); - - // .substrait.Expression then = 2; - bool has_then() const; - private: - bool _internal_has_then() const; - public: - void clear_then(); - const ::substrait::Expression& then() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_then(); - ::substrait::Expression* mutable_then(); - void set_allocated_then(::substrait::Expression* then); - private: - const ::substrait::Expression& _internal_then() const; - ::substrait::Expression* _internal_mutable_then(); - public: - void unsafe_arena_set_allocated_then( - ::substrait::Expression* then); - ::substrait::Expression* unsafe_arena_release_then(); - - // @@protoc_insertion_point(class_scope:substrait.Expression.SwitchExpression.IfValue) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Expression_Literal* if__; - ::substrait::Expression* then_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_SwitchExpression final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SwitchExpression) */ { - public: - inline Expression_SwitchExpression() : Expression_SwitchExpression(nullptr) {} - ~Expression_SwitchExpression() override; - explicit constexpr Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_SwitchExpression(const Expression_SwitchExpression& from); - Expression_SwitchExpression(Expression_SwitchExpression&& from) noexcept - : Expression_SwitchExpression() { - *this = ::std::move(from); - } - - inline Expression_SwitchExpression& operator=(const Expression_SwitchExpression& from) { - CopyFrom(from); - return *this; - } - inline Expression_SwitchExpression& operator=(Expression_SwitchExpression&& 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 Expression_SwitchExpression& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_SwitchExpression* internal_default_instance() { - return reinterpret_cast( - &_Expression_SwitchExpression_default_instance_); - } - static constexpr int kIndexInFileMessages = - 22; - - friend void swap(Expression_SwitchExpression& a, Expression_SwitchExpression& b) { - a.Swap(&b); - } - inline void Swap(Expression_SwitchExpression* 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(Expression_SwitchExpression* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_SwitchExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_SwitchExpression& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_SwitchExpression& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_SwitchExpression* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.SwitchExpression"; - } - protected: - explicit Expression_SwitchExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_SwitchExpression_IfValue IfValue; - - // accessors ------------------------------------------------------- - - enum : int { - kIfsFieldNumber = 1, - kElseFieldNumber = 2, - }; - // repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; - int ifs_size() const; - private: - int _internal_ifs_size() const; - public: - void clear_ifs(); - ::substrait::Expression_SwitchExpression_IfValue* mutable_ifs(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >* - mutable_ifs(); - private: - const ::substrait::Expression_SwitchExpression_IfValue& _internal_ifs(int index) const; - ::substrait::Expression_SwitchExpression_IfValue* _internal_add_ifs(); - public: - const ::substrait::Expression_SwitchExpression_IfValue& ifs(int index) const; - ::substrait::Expression_SwitchExpression_IfValue* add_ifs(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >& - ifs() const; - - // .substrait.Expression else = 2; - bool has_else_() const; - private: - bool _internal_has_else_() const; - public: - void clear_else_(); - const ::substrait::Expression& else_() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_else_(); - ::substrait::Expression* mutable_else_(); - void set_allocated_else_(::substrait::Expression* else_); - private: - const ::substrait::Expression& _internal_else_() const; - ::substrait::Expression* _internal_mutable_else_(); - public: - void unsafe_arena_set_allocated_else_( - ::substrait::Expression* else_); - ::substrait::Expression* unsafe_arena_release_else_(); - - // @@protoc_insertion_point(class_scope:substrait.Expression.SwitchExpression) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue > ifs_; - ::substrait::Expression* else__; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_SingularOrList final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.SingularOrList) */ { - public: - inline Expression_SingularOrList() : Expression_SingularOrList(nullptr) {} - ~Expression_SingularOrList() override; - explicit constexpr Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_SingularOrList(const Expression_SingularOrList& from); - Expression_SingularOrList(Expression_SingularOrList&& from) noexcept - : Expression_SingularOrList() { - *this = ::std::move(from); - } - - inline Expression_SingularOrList& operator=(const Expression_SingularOrList& from) { - CopyFrom(from); - return *this; - } - inline Expression_SingularOrList& operator=(Expression_SingularOrList&& 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 Expression_SingularOrList& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_SingularOrList* internal_default_instance() { - return reinterpret_cast( - &_Expression_SingularOrList_default_instance_); - } - static constexpr int kIndexInFileMessages = - 23; - - friend void swap(Expression_SingularOrList& a, Expression_SingularOrList& b) { - a.Swap(&b); - } - inline void Swap(Expression_SingularOrList* 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(Expression_SingularOrList* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_SingularOrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_SingularOrList& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_SingularOrList& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_SingularOrList* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.SingularOrList"; - } - protected: - explicit Expression_SingularOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kOptionsFieldNumber = 2, - kValueFieldNumber = 1, - }; - // repeated .substrait.Expression options = 2; - int options_size() const; - private: - int _internal_options_size() const; - public: - void clear_options(); - ::substrait::Expression* mutable_options(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* - mutable_options(); - private: - const ::substrait::Expression& _internal_options(int index) const; - ::substrait::Expression* _internal_add_options(); - public: - const ::substrait::Expression& options(int index) const; - ::substrait::Expression* add_options(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& - options() const; - - // .substrait.Expression value = 1; - bool has_value() const; - private: - bool _internal_has_value() const; - public: - void clear_value(); - const ::substrait::Expression& value() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_value(); - ::substrait::Expression* mutable_value(); - void set_allocated_value(::substrait::Expression* value); - private: - const ::substrait::Expression& _internal_value() const; - ::substrait::Expression* _internal_mutable_value(); - public: - void unsafe_arena_set_allocated_value( - ::substrait::Expression* value); - ::substrait::Expression* unsafe_arena_release_value(); - - // @@protoc_insertion_point(class_scope:substrait.Expression.SingularOrList) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > options_; - ::substrait::Expression* value_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MultiOrList_Record final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MultiOrList.Record) */ { - public: - inline Expression_MultiOrList_Record() : Expression_MultiOrList_Record(nullptr) {} - ~Expression_MultiOrList_Record() override; - explicit constexpr Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MultiOrList_Record(const Expression_MultiOrList_Record& from); - Expression_MultiOrList_Record(Expression_MultiOrList_Record&& from) noexcept - : Expression_MultiOrList_Record() { - *this = ::std::move(from); - } - - inline Expression_MultiOrList_Record& operator=(const Expression_MultiOrList_Record& from) { - CopyFrom(from); - return *this; - } - inline Expression_MultiOrList_Record& operator=(Expression_MultiOrList_Record&& 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 Expression_MultiOrList_Record& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_MultiOrList_Record* internal_default_instance() { - return reinterpret_cast( - &_Expression_MultiOrList_Record_default_instance_); - } - static constexpr int kIndexInFileMessages = - 24; - - friend void swap(Expression_MultiOrList_Record& a, Expression_MultiOrList_Record& b) { - a.Swap(&b); - } - inline void Swap(Expression_MultiOrList_Record* 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(Expression_MultiOrList_Record* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MultiOrList_Record* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MultiOrList_Record& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MultiOrList_Record& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MultiOrList_Record* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MultiOrList.Record"; - } - protected: - explicit Expression_MultiOrList_Record(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kFieldsFieldNumber = 1, - }; - // repeated .substrait.Expression fields = 1; - int fields_size() const; - private: - int _internal_fields_size() const; - public: - void clear_fields(); - ::substrait::Expression* mutable_fields(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* - mutable_fields(); - private: - const ::substrait::Expression& _internal_fields(int index) const; - ::substrait::Expression* _internal_add_fields(); - public: - const ::substrait::Expression& fields(int index) const; - ::substrait::Expression* add_fields(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& - fields() const; - - // @@protoc_insertion_point(class_scope:substrait.Expression.MultiOrList.Record) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > fields_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MultiOrList final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MultiOrList) */ { - public: - inline Expression_MultiOrList() : Expression_MultiOrList(nullptr) {} - ~Expression_MultiOrList() override; - explicit constexpr Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MultiOrList(const Expression_MultiOrList& from); - Expression_MultiOrList(Expression_MultiOrList&& from) noexcept - : Expression_MultiOrList() { - *this = ::std::move(from); - } - - inline Expression_MultiOrList& operator=(const Expression_MultiOrList& from) { - CopyFrom(from); - return *this; - } - inline Expression_MultiOrList& operator=(Expression_MultiOrList&& 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 Expression_MultiOrList& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_MultiOrList* internal_default_instance() { - return reinterpret_cast( - &_Expression_MultiOrList_default_instance_); - } - static constexpr int kIndexInFileMessages = - 25; - - friend void swap(Expression_MultiOrList& a, Expression_MultiOrList& b) { - a.Swap(&b); - } - inline void Swap(Expression_MultiOrList* 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(Expression_MultiOrList* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MultiOrList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MultiOrList& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MultiOrList& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MultiOrList* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MultiOrList"; - } - protected: - explicit Expression_MultiOrList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_MultiOrList_Record Record; - - // accessors ------------------------------------------------------- - - enum : int { - kValueFieldNumber = 1, - kOptionsFieldNumber = 2, - }; - // repeated .substrait.Expression value = 1; - int value_size() const; - private: - int _internal_value_size() const; - public: - void clear_value(); - ::substrait::Expression* mutable_value(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* - mutable_value(); - private: - const ::substrait::Expression& _internal_value(int index) const; - ::substrait::Expression* _internal_add_value(); - public: - const ::substrait::Expression& value(int index) const; - ::substrait::Expression* add_value(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& - value() const; - - // repeated .substrait.Expression.MultiOrList.Record options = 2; - int options_size() const; - private: - int _internal_options_size() const; - public: - void clear_options(); - ::substrait::Expression_MultiOrList_Record* mutable_options(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >* - mutable_options(); - private: - const ::substrait::Expression_MultiOrList_Record& _internal_options(int index) const; - ::substrait::Expression_MultiOrList_Record* _internal_add_options(); - public: - const ::substrait::Expression_MultiOrList_Record& options(int index) const; - ::substrait::Expression_MultiOrList_Record* add_options(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >& - options() const; - - // @@protoc_insertion_point(class_scope:substrait.Expression.MultiOrList) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > value_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record > options_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_EmbeddedFunction_PythonPickleFunction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction.PythonPickleFunction) */ { - public: - inline Expression_EmbeddedFunction_PythonPickleFunction() : Expression_EmbeddedFunction_PythonPickleFunction(nullptr) {} - ~Expression_EmbeddedFunction_PythonPickleFunction() override; - explicit constexpr Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_EmbeddedFunction_PythonPickleFunction(const Expression_EmbeddedFunction_PythonPickleFunction& from); - Expression_EmbeddedFunction_PythonPickleFunction(Expression_EmbeddedFunction_PythonPickleFunction&& from) noexcept - : Expression_EmbeddedFunction_PythonPickleFunction() { - *this = ::std::move(from); - } - - inline Expression_EmbeddedFunction_PythonPickleFunction& operator=(const Expression_EmbeddedFunction_PythonPickleFunction& from) { - CopyFrom(from); - return *this; - } - inline Expression_EmbeddedFunction_PythonPickleFunction& operator=(Expression_EmbeddedFunction_PythonPickleFunction&& 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 Expression_EmbeddedFunction_PythonPickleFunction& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_EmbeddedFunction_PythonPickleFunction* internal_default_instance() { - return reinterpret_cast( - &_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 26; - - friend void swap(Expression_EmbeddedFunction_PythonPickleFunction& a, Expression_EmbeddedFunction_PythonPickleFunction& b) { - a.Swap(&b); - } - inline void Swap(Expression_EmbeddedFunction_PythonPickleFunction* 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(Expression_EmbeddedFunction_PythonPickleFunction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_EmbeddedFunction_PythonPickleFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_EmbeddedFunction_PythonPickleFunction& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_EmbeddedFunction_PythonPickleFunction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.EmbeddedFunction.PythonPickleFunction"; - } - protected: - explicit Expression_EmbeddedFunction_PythonPickleFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kPrerequisiteFieldNumber = 2, - kFunctionFieldNumber = 1, - }; - // repeated string prerequisite = 2; - int prerequisite_size() const; - private: - int _internal_prerequisite_size() const; - public: - void clear_prerequisite(); - const std::string& prerequisite(int index) const; - std::string* mutable_prerequisite(int index); - void set_prerequisite(int index, const std::string& value); - void set_prerequisite(int index, std::string&& value); - void set_prerequisite(int index, const char* value); - void set_prerequisite(int index, const char* value, size_t size); - std::string* add_prerequisite(); - void add_prerequisite(const std::string& value); - void add_prerequisite(std::string&& value); - void add_prerequisite(const char* value); - void add_prerequisite(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& prerequisite() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_prerequisite(); - private: - const std::string& _internal_prerequisite(int index) const; - std::string* _internal_add_prerequisite(); - public: - - // bytes function = 1; - void clear_function(); - const std::string& function() const; - template - void set_function(ArgT0&& arg0, ArgT... args); - std::string* mutable_function(); - PROTOBUF_NODISCARD std::string* release_function(); - void set_allocated_function(std::string* function); - private: - const std::string& _internal_function() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_function(const std::string& value); - std::string* _internal_mutable_function(); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.EmbeddedFunction.PythonPickleFunction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField prerequisite_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr function_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_EmbeddedFunction_WebAssemblyFunction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) */ { - public: - inline Expression_EmbeddedFunction_WebAssemblyFunction() : Expression_EmbeddedFunction_WebAssemblyFunction(nullptr) {} - ~Expression_EmbeddedFunction_WebAssemblyFunction() override; - explicit constexpr Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_EmbeddedFunction_WebAssemblyFunction(const Expression_EmbeddedFunction_WebAssemblyFunction& from); - Expression_EmbeddedFunction_WebAssemblyFunction(Expression_EmbeddedFunction_WebAssemblyFunction&& from) noexcept - : Expression_EmbeddedFunction_WebAssemblyFunction() { - *this = ::std::move(from); - } - - inline Expression_EmbeddedFunction_WebAssemblyFunction& operator=(const Expression_EmbeddedFunction_WebAssemblyFunction& from) { - CopyFrom(from); - return *this; - } - inline Expression_EmbeddedFunction_WebAssemblyFunction& operator=(Expression_EmbeddedFunction_WebAssemblyFunction&& 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 Expression_EmbeddedFunction_WebAssemblyFunction& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_EmbeddedFunction_WebAssemblyFunction* internal_default_instance() { - return reinterpret_cast( - &_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 27; - - friend void swap(Expression_EmbeddedFunction_WebAssemblyFunction& a, Expression_EmbeddedFunction_WebAssemblyFunction& b) { - a.Swap(&b); - } - inline void Swap(Expression_EmbeddedFunction_WebAssemblyFunction* 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(Expression_EmbeddedFunction_WebAssemblyFunction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_EmbeddedFunction_WebAssemblyFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_EmbeddedFunction_WebAssemblyFunction& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_EmbeddedFunction_WebAssemblyFunction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.EmbeddedFunction.WebAssemblyFunction"; - } - protected: - explicit Expression_EmbeddedFunction_WebAssemblyFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kPrerequisiteFieldNumber = 2, - kScriptFieldNumber = 1, - }; - // repeated string prerequisite = 2; - int prerequisite_size() const; - private: - int _internal_prerequisite_size() const; - public: - void clear_prerequisite(); - const std::string& prerequisite(int index) const; - std::string* mutable_prerequisite(int index); - void set_prerequisite(int index, const std::string& value); - void set_prerequisite(int index, std::string&& value); - void set_prerequisite(int index, const char* value); - void set_prerequisite(int index, const char* value, size_t size); - std::string* add_prerequisite(); - void add_prerequisite(const std::string& value); - void add_prerequisite(std::string&& value); - void add_prerequisite(const char* value); - void add_prerequisite(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& prerequisite() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_prerequisite(); - private: - const std::string& _internal_prerequisite(int index) const; - std::string* _internal_add_prerequisite(); - public: - - // bytes script = 1; - void clear_script(); - const std::string& script() const; - template - void set_script(ArgT0&& arg0, ArgT... args); - std::string* mutable_script(); - PROTOBUF_NODISCARD std::string* release_script(); - void set_allocated_script(std::string* script); - private: - const std::string& _internal_script() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_script(const std::string& value); - std::string* _internal_mutable_script(); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.EmbeddedFunction.WebAssemblyFunction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField prerequisite_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr script_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_EmbeddedFunction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.EmbeddedFunction) */ { - public: - inline Expression_EmbeddedFunction() : Expression_EmbeddedFunction(nullptr) {} - ~Expression_EmbeddedFunction() override; - explicit constexpr Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_EmbeddedFunction(const Expression_EmbeddedFunction& from); - Expression_EmbeddedFunction(Expression_EmbeddedFunction&& from) noexcept - : Expression_EmbeddedFunction() { - *this = ::std::move(from); - } - - inline Expression_EmbeddedFunction& operator=(const Expression_EmbeddedFunction& from) { - CopyFrom(from); - return *this; - } - inline Expression_EmbeddedFunction& operator=(Expression_EmbeddedFunction&& 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 Expression_EmbeddedFunction& default_instance() { - return *internal_default_instance(); - } - enum KindCase { - kPythonPickleFunction = 3, - kWebAssemblyFunction = 4, - KIND_NOT_SET = 0, - }; - - static inline const Expression_EmbeddedFunction* internal_default_instance() { - return reinterpret_cast( - &_Expression_EmbeddedFunction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 28; - - friend void swap(Expression_EmbeddedFunction& a, Expression_EmbeddedFunction& b) { - a.Swap(&b); - } - inline void Swap(Expression_EmbeddedFunction* 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(Expression_EmbeddedFunction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_EmbeddedFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_EmbeddedFunction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_EmbeddedFunction& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_EmbeddedFunction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.EmbeddedFunction"; - } - protected: - explicit Expression_EmbeddedFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_EmbeddedFunction_PythonPickleFunction PythonPickleFunction; - typedef Expression_EmbeddedFunction_WebAssemblyFunction WebAssemblyFunction; - - // accessors ------------------------------------------------------- - - enum : int { - kArgumentsFieldNumber = 1, - kOutputTypeFieldNumber = 2, - kPythonPickleFunctionFieldNumber = 3, - kWebAssemblyFunctionFieldNumber = 4, - }; - // repeated .substrait.Expression arguments = 1; - int arguments_size() const; - private: - int _internal_arguments_size() const; - public: - void clear_arguments(); - ::substrait::Expression* mutable_arguments(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* - mutable_arguments(); - private: - const ::substrait::Expression& _internal_arguments(int index) const; - ::substrait::Expression* _internal_add_arguments(); - public: - const ::substrait::Expression& arguments(int index) const; - ::substrait::Expression* add_arguments(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& - arguments() const; - - // .substrait.Type output_type = 2; - bool has_output_type() const; - private: - bool _internal_has_output_type() const; - public: - void clear_output_type(); - const ::substrait::Type& output_type() const; - PROTOBUF_NODISCARD ::substrait::Type* release_output_type(); - ::substrait::Type* mutable_output_type(); - void set_allocated_output_type(::substrait::Type* output_type); - private: - const ::substrait::Type& _internal_output_type() const; - ::substrait::Type* _internal_mutable_output_type(); - public: - void unsafe_arena_set_allocated_output_type( - ::substrait::Type* output_type); - ::substrait::Type* unsafe_arena_release_output_type(); - - // .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; - bool has_python_pickle_function() const; - private: - bool _internal_has_python_pickle_function() const; - public: - void clear_python_pickle_function(); - const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& python_pickle_function() const; - PROTOBUF_NODISCARD ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* release_python_pickle_function(); - ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* mutable_python_pickle_function(); - void set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function); - private: - const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& _internal_python_pickle_function() const; - ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* _internal_mutable_python_pickle_function(); - public: - void unsafe_arena_set_allocated_python_pickle_function( - ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function); - ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* unsafe_arena_release_python_pickle_function(); - - // .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; - bool has_web_assembly_function() const; - private: - bool _internal_has_web_assembly_function() const; - public: - void clear_web_assembly_function(); - const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& web_assembly_function() const; - PROTOBUF_NODISCARD ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* release_web_assembly_function(); - ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* mutable_web_assembly_function(); - void set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function); - private: - const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& _internal_web_assembly_function() const; - ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* _internal_mutable_web_assembly_function(); - public: - void unsafe_arena_set_allocated_web_assembly_function( - ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function); - ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* unsafe_arena_release_web_assembly_function(); - - void clear_kind(); - KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:substrait.Expression.EmbeddedFunction) - private: - class _Internal; - void set_has_python_pickle_function(); - void set_has_web_assembly_function(); - - inline bool has_kind() const; - inline void clear_has_kind(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > arguments_; - ::substrait::Type* output_type_; - union KindUnion { - constexpr KindUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function_; - ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function_; - } kind_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_ReferenceSegment_MapKey final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.MapKey) */ { - public: - inline Expression_ReferenceSegment_MapKey() : Expression_ReferenceSegment_MapKey(nullptr) {} - ~Expression_ReferenceSegment_MapKey() override; - explicit constexpr Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_ReferenceSegment_MapKey(const Expression_ReferenceSegment_MapKey& from); - Expression_ReferenceSegment_MapKey(Expression_ReferenceSegment_MapKey&& from) noexcept - : Expression_ReferenceSegment_MapKey() { - *this = ::std::move(from); - } - - inline Expression_ReferenceSegment_MapKey& operator=(const Expression_ReferenceSegment_MapKey& from) { - CopyFrom(from); - return *this; - } - inline Expression_ReferenceSegment_MapKey& operator=(Expression_ReferenceSegment_MapKey&& 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 Expression_ReferenceSegment_MapKey& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_ReferenceSegment_MapKey* internal_default_instance() { - return reinterpret_cast( - &_Expression_ReferenceSegment_MapKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 29; - - friend void swap(Expression_ReferenceSegment_MapKey& a, Expression_ReferenceSegment_MapKey& b) { - a.Swap(&b); - } - inline void Swap(Expression_ReferenceSegment_MapKey* 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(Expression_ReferenceSegment_MapKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_ReferenceSegment_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_ReferenceSegment_MapKey& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_ReferenceSegment_MapKey& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_ReferenceSegment_MapKey* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.ReferenceSegment.MapKey"; - } - protected: - explicit Expression_ReferenceSegment_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kMapKeyFieldNumber = 1, - kChildFieldNumber = 2, - }; - // .substrait.Expression.Literal map_key = 1; - bool has_map_key() const; - private: - bool _internal_has_map_key() const; - public: - void clear_map_key(); - const ::substrait::Expression_Literal& map_key() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_map_key(); - ::substrait::Expression_Literal* mutable_map_key(); - void set_allocated_map_key(::substrait::Expression_Literal* map_key); - private: - const ::substrait::Expression_Literal& _internal_map_key() const; - ::substrait::Expression_Literal* _internal_mutable_map_key(); - public: - void unsafe_arena_set_allocated_map_key( - ::substrait::Expression_Literal* map_key); - ::substrait::Expression_Literal* unsafe_arena_release_map_key(); - - // .substrait.Expression.ReferenceSegment child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::substrait::Expression_ReferenceSegment& child() const; - PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_child(); - ::substrait::Expression_ReferenceSegment* mutable_child(); - void set_allocated_child(::substrait::Expression_ReferenceSegment* child); - private: - const ::substrait::Expression_ReferenceSegment& _internal_child() const; - ::substrait::Expression_ReferenceSegment* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::substrait::Expression_ReferenceSegment* child); - ::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); - - // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.MapKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Expression_Literal* map_key_; - ::substrait::Expression_ReferenceSegment* child_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_ReferenceSegment_StructField final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.StructField) */ { - public: - inline Expression_ReferenceSegment_StructField() : Expression_ReferenceSegment_StructField(nullptr) {} - ~Expression_ReferenceSegment_StructField() override; - explicit constexpr Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_ReferenceSegment_StructField(const Expression_ReferenceSegment_StructField& from); - Expression_ReferenceSegment_StructField(Expression_ReferenceSegment_StructField&& from) noexcept - : Expression_ReferenceSegment_StructField() { - *this = ::std::move(from); - } - - inline Expression_ReferenceSegment_StructField& operator=(const Expression_ReferenceSegment_StructField& from) { - CopyFrom(from); - return *this; - } - inline Expression_ReferenceSegment_StructField& operator=(Expression_ReferenceSegment_StructField&& 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 Expression_ReferenceSegment_StructField& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_ReferenceSegment_StructField* internal_default_instance() { - return reinterpret_cast( - &_Expression_ReferenceSegment_StructField_default_instance_); - } - static constexpr int kIndexInFileMessages = - 30; - - friend void swap(Expression_ReferenceSegment_StructField& a, Expression_ReferenceSegment_StructField& b) { - a.Swap(&b); - } - inline void Swap(Expression_ReferenceSegment_StructField* 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(Expression_ReferenceSegment_StructField* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_ReferenceSegment_StructField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_ReferenceSegment_StructField& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_ReferenceSegment_StructField& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_ReferenceSegment_StructField* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.ReferenceSegment.StructField"; - } - protected: - explicit Expression_ReferenceSegment_StructField(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kChildFieldNumber = 2, - kFieldFieldNumber = 1, - }; - // .substrait.Expression.ReferenceSegment child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::substrait::Expression_ReferenceSegment& child() const; - PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_child(); - ::substrait::Expression_ReferenceSegment* mutable_child(); - void set_allocated_child(::substrait::Expression_ReferenceSegment* child); - private: - const ::substrait::Expression_ReferenceSegment& _internal_child() const; - ::substrait::Expression_ReferenceSegment* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::substrait::Expression_ReferenceSegment* child); - ::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); - - // int32 field = 1; - void clear_field(); - int32_t field() const; - void set_field(int32_t value); - private: - int32_t _internal_field() const; - void _internal_set_field(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.StructField) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Expression_ReferenceSegment* child_; - int32_t field_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_ReferenceSegment_ListElement final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment.ListElement) */ { - public: - inline Expression_ReferenceSegment_ListElement() : Expression_ReferenceSegment_ListElement(nullptr) {} - ~Expression_ReferenceSegment_ListElement() override; - explicit constexpr Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_ReferenceSegment_ListElement(const Expression_ReferenceSegment_ListElement& from); - Expression_ReferenceSegment_ListElement(Expression_ReferenceSegment_ListElement&& from) noexcept - : Expression_ReferenceSegment_ListElement() { - *this = ::std::move(from); - } - - inline Expression_ReferenceSegment_ListElement& operator=(const Expression_ReferenceSegment_ListElement& from) { - CopyFrom(from); - return *this; - } - inline Expression_ReferenceSegment_ListElement& operator=(Expression_ReferenceSegment_ListElement&& 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 Expression_ReferenceSegment_ListElement& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_ReferenceSegment_ListElement* internal_default_instance() { - return reinterpret_cast( - &_Expression_ReferenceSegment_ListElement_default_instance_); - } - static constexpr int kIndexInFileMessages = - 31; - - friend void swap(Expression_ReferenceSegment_ListElement& a, Expression_ReferenceSegment_ListElement& b) { - a.Swap(&b); - } - inline void Swap(Expression_ReferenceSegment_ListElement* 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(Expression_ReferenceSegment_ListElement* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_ReferenceSegment_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_ReferenceSegment_ListElement& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_ReferenceSegment_ListElement& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_ReferenceSegment_ListElement* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.ReferenceSegment.ListElement"; - } - protected: - explicit Expression_ReferenceSegment_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kChildFieldNumber = 2, - kOffsetFieldNumber = 1, - }; - // .substrait.Expression.ReferenceSegment child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::substrait::Expression_ReferenceSegment& child() const; - PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_child(); - ::substrait::Expression_ReferenceSegment* mutable_child(); - void set_allocated_child(::substrait::Expression_ReferenceSegment* child); - private: - const ::substrait::Expression_ReferenceSegment& _internal_child() const; - ::substrait::Expression_ReferenceSegment* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::substrait::Expression_ReferenceSegment* child); - ::substrait::Expression_ReferenceSegment* unsafe_arena_release_child(); - - // int32 offset = 1; - void clear_offset(); - int32_t offset() const; - void set_offset(int32_t value); - private: - int32_t _internal_offset() const; - void _internal_set_offset(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment.ListElement) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Expression_ReferenceSegment* child_; - int32_t offset_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_ReferenceSegment final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.ReferenceSegment) */ { - public: - inline Expression_ReferenceSegment() : Expression_ReferenceSegment(nullptr) {} - ~Expression_ReferenceSegment() override; - explicit constexpr Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_ReferenceSegment(const Expression_ReferenceSegment& from); - Expression_ReferenceSegment(Expression_ReferenceSegment&& from) noexcept - : Expression_ReferenceSegment() { - *this = ::std::move(from); - } - - inline Expression_ReferenceSegment& operator=(const Expression_ReferenceSegment& from) { - CopyFrom(from); - return *this; - } - inline Expression_ReferenceSegment& operator=(Expression_ReferenceSegment&& 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 Expression_ReferenceSegment& default_instance() { - return *internal_default_instance(); - } - enum ReferenceTypeCase { - kMapKey = 1, - kStructField = 2, - kListElement = 3, - REFERENCE_TYPE_NOT_SET = 0, - }; - - static inline const Expression_ReferenceSegment* internal_default_instance() { - return reinterpret_cast( - &_Expression_ReferenceSegment_default_instance_); - } - static constexpr int kIndexInFileMessages = - 32; - - friend void swap(Expression_ReferenceSegment& a, Expression_ReferenceSegment& b) { - a.Swap(&b); - } - inline void Swap(Expression_ReferenceSegment* 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(Expression_ReferenceSegment* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_ReferenceSegment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_ReferenceSegment& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_ReferenceSegment& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_ReferenceSegment* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.ReferenceSegment"; - } - protected: - explicit Expression_ReferenceSegment(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_ReferenceSegment_MapKey MapKey; - typedef Expression_ReferenceSegment_StructField StructField; - typedef Expression_ReferenceSegment_ListElement ListElement; - - // accessors ------------------------------------------------------- - - enum : int { - kMapKeyFieldNumber = 1, - kStructFieldFieldNumber = 2, - kListElementFieldNumber = 3, - }; - // .substrait.Expression.ReferenceSegment.MapKey map_key = 1; - bool has_map_key() const; - private: - bool _internal_has_map_key() const; - public: - void clear_map_key(); - const ::substrait::Expression_ReferenceSegment_MapKey& map_key() const; - PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment_MapKey* release_map_key(); - ::substrait::Expression_ReferenceSegment_MapKey* mutable_map_key(); - void set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key); - private: - const ::substrait::Expression_ReferenceSegment_MapKey& _internal_map_key() const; - ::substrait::Expression_ReferenceSegment_MapKey* _internal_mutable_map_key(); - public: - void unsafe_arena_set_allocated_map_key( - ::substrait::Expression_ReferenceSegment_MapKey* map_key); - ::substrait::Expression_ReferenceSegment_MapKey* unsafe_arena_release_map_key(); - - // .substrait.Expression.ReferenceSegment.StructField struct_field = 2; - bool has_struct_field() const; - private: - bool _internal_has_struct_field() const; - public: - void clear_struct_field(); - const ::substrait::Expression_ReferenceSegment_StructField& struct_field() const; - PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment_StructField* release_struct_field(); - ::substrait::Expression_ReferenceSegment_StructField* mutable_struct_field(); - void set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field); - private: - const ::substrait::Expression_ReferenceSegment_StructField& _internal_struct_field() const; - ::substrait::Expression_ReferenceSegment_StructField* _internal_mutable_struct_field(); - public: - void unsafe_arena_set_allocated_struct_field( - ::substrait::Expression_ReferenceSegment_StructField* struct_field); - ::substrait::Expression_ReferenceSegment_StructField* unsafe_arena_release_struct_field(); - - // .substrait.Expression.ReferenceSegment.ListElement list_element = 3; - bool has_list_element() const; - private: - bool _internal_has_list_element() const; - public: - void clear_list_element(); - const ::substrait::Expression_ReferenceSegment_ListElement& list_element() const; - PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment_ListElement* release_list_element(); - ::substrait::Expression_ReferenceSegment_ListElement* mutable_list_element(); - void set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element); - private: - const ::substrait::Expression_ReferenceSegment_ListElement& _internal_list_element() const; - ::substrait::Expression_ReferenceSegment_ListElement* _internal_mutable_list_element(); - public: - void unsafe_arena_set_allocated_list_element( - ::substrait::Expression_ReferenceSegment_ListElement* list_element); - ::substrait::Expression_ReferenceSegment_ListElement* unsafe_arena_release_list_element(); - - void clear_reference_type(); - ReferenceTypeCase reference_type_case() const; - // @@protoc_insertion_point(class_scope:substrait.Expression.ReferenceSegment) - private: - class _Internal; - void set_has_map_key(); - void set_has_struct_field(); - void set_has_list_element(); - - inline bool has_reference_type() const; - inline void clear_has_reference_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union ReferenceTypeUnion { - constexpr ReferenceTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Expression_ReferenceSegment_MapKey* map_key_; - ::substrait::Expression_ReferenceSegment_StructField* struct_field_; - ::substrait::Expression_ReferenceSegment_ListElement* list_element_; - } reference_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression_Select final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.Select) */ { - public: - inline Expression_MaskExpression_Select() : Expression_MaskExpression_Select(nullptr) {} - ~Expression_MaskExpression_Select() override; - explicit constexpr Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression_Select(const Expression_MaskExpression_Select& from); - Expression_MaskExpression_Select(Expression_MaskExpression_Select&& from) noexcept - : Expression_MaskExpression_Select() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression_Select& operator=(const Expression_MaskExpression_Select& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression_Select& operator=(Expression_MaskExpression_Select&& 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 Expression_MaskExpression_Select& default_instance() { - return *internal_default_instance(); - } - enum TypeCase { - kStruct = 1, - kList = 2, - kMap = 3, - TYPE_NOT_SET = 0, - }; - - static inline const Expression_MaskExpression_Select* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_Select_default_instance_); - } - static constexpr int kIndexInFileMessages = - 33; - - friend void swap(Expression_MaskExpression_Select& a, Expression_MaskExpression_Select& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression_Select* 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(Expression_MaskExpression_Select* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression_Select* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression_Select& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression_Select& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression_Select* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression.Select"; - } - protected: - explicit Expression_MaskExpression_Select(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kStructFieldNumber = 1, - kListFieldNumber = 2, - kMapFieldNumber = 3, - }; - // .substrait.Expression.MaskExpression.StructSelect struct = 1; - bool has_struct_() const; - private: - bool _internal_has_struct_() const; - public: - void clear_struct_(); - const ::substrait::Expression_MaskExpression_StructSelect& struct_() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_StructSelect* release_struct_(); - ::substrait::Expression_MaskExpression_StructSelect* mutable_struct_(); - void set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_); - private: - const ::substrait::Expression_MaskExpression_StructSelect& _internal_struct_() const; - ::substrait::Expression_MaskExpression_StructSelect* _internal_mutable_struct_(); - public: - void unsafe_arena_set_allocated_struct_( - ::substrait::Expression_MaskExpression_StructSelect* struct_); - ::substrait::Expression_MaskExpression_StructSelect* unsafe_arena_release_struct_(); - - // .substrait.Expression.MaskExpression.ListSelect list = 2; - bool has_list() const; - private: - bool _internal_has_list() const; - public: - void clear_list(); - const ::substrait::Expression_MaskExpression_ListSelect& list() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_ListSelect* release_list(); - ::substrait::Expression_MaskExpression_ListSelect* mutable_list(); - void set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list); - private: - const ::substrait::Expression_MaskExpression_ListSelect& _internal_list() const; - ::substrait::Expression_MaskExpression_ListSelect* _internal_mutable_list(); - public: - void unsafe_arena_set_allocated_list( - ::substrait::Expression_MaskExpression_ListSelect* list); - ::substrait::Expression_MaskExpression_ListSelect* unsafe_arena_release_list(); - - // .substrait.Expression.MaskExpression.MapSelect map = 3; - bool has_map() const; - private: - bool _internal_has_map() const; - public: - void clear_map(); - const ::substrait::Expression_MaskExpression_MapSelect& map() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_MapSelect* release_map(); - ::substrait::Expression_MaskExpression_MapSelect* mutable_map(); - void set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map); - private: - const ::substrait::Expression_MaskExpression_MapSelect& _internal_map() const; - ::substrait::Expression_MaskExpression_MapSelect* _internal_mutable_map(); - public: - void unsafe_arena_set_allocated_map( - ::substrait::Expression_MaskExpression_MapSelect* map); - ::substrait::Expression_MaskExpression_MapSelect* unsafe_arena_release_map(); - - void clear_type(); - TypeCase type_case() const; - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.Select) - private: - class _Internal; - void set_has_struct_(); - void set_has_list(); - void set_has_map(); - - inline bool has_type() const; - inline void clear_has_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union TypeUnion { - constexpr TypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Expression_MaskExpression_StructSelect* struct__; - ::substrait::Expression_MaskExpression_ListSelect* list_; - ::substrait::Expression_MaskExpression_MapSelect* map_; - } type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression_StructSelect final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.StructSelect) */ { - public: - inline Expression_MaskExpression_StructSelect() : Expression_MaskExpression_StructSelect(nullptr) {} - ~Expression_MaskExpression_StructSelect() override; - explicit constexpr Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression_StructSelect(const Expression_MaskExpression_StructSelect& from); - Expression_MaskExpression_StructSelect(Expression_MaskExpression_StructSelect&& from) noexcept - : Expression_MaskExpression_StructSelect() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression_StructSelect& operator=(const Expression_MaskExpression_StructSelect& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression_StructSelect& operator=(Expression_MaskExpression_StructSelect&& 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 Expression_MaskExpression_StructSelect& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_MaskExpression_StructSelect* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_StructSelect_default_instance_); - } - static constexpr int kIndexInFileMessages = - 34; - - friend void swap(Expression_MaskExpression_StructSelect& a, Expression_MaskExpression_StructSelect& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression_StructSelect* 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(Expression_MaskExpression_StructSelect* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression_StructSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression_StructSelect& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression_StructSelect& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression_StructSelect* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression.StructSelect"; - } - protected: - explicit Expression_MaskExpression_StructSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kStructItemsFieldNumber = 1, - }; - // repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; - int struct_items_size() const; - private: - int _internal_struct_items_size() const; - public: - void clear_struct_items(); - ::substrait::Expression_MaskExpression_StructItem* mutable_struct_items(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >* - mutable_struct_items(); - private: - const ::substrait::Expression_MaskExpression_StructItem& _internal_struct_items(int index) const; - ::substrait::Expression_MaskExpression_StructItem* _internal_add_struct_items(); - public: - const ::substrait::Expression_MaskExpression_StructItem& struct_items(int index) const; - ::substrait::Expression_MaskExpression_StructItem* add_struct_items(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >& - struct_items() const; - - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.StructSelect) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem > struct_items_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression_StructItem final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.StructItem) */ { - public: - inline Expression_MaskExpression_StructItem() : Expression_MaskExpression_StructItem(nullptr) {} - ~Expression_MaskExpression_StructItem() override; - explicit constexpr Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression_StructItem(const Expression_MaskExpression_StructItem& from); - Expression_MaskExpression_StructItem(Expression_MaskExpression_StructItem&& from) noexcept - : Expression_MaskExpression_StructItem() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression_StructItem& operator=(const Expression_MaskExpression_StructItem& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression_StructItem& operator=(Expression_MaskExpression_StructItem&& 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 Expression_MaskExpression_StructItem& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_MaskExpression_StructItem* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_StructItem_default_instance_); - } - static constexpr int kIndexInFileMessages = - 35; - - friend void swap(Expression_MaskExpression_StructItem& a, Expression_MaskExpression_StructItem& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression_StructItem* 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(Expression_MaskExpression_StructItem* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression_StructItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression_StructItem& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression_StructItem& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression_StructItem* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression.StructItem"; - } - protected: - explicit Expression_MaskExpression_StructItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kChildFieldNumber = 2, - kFieldFieldNumber = 1, - }; - // .substrait.Expression.MaskExpression.Select child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::substrait::Expression_MaskExpression_Select& child() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_Select* release_child(); - ::substrait::Expression_MaskExpression_Select* mutable_child(); - void set_allocated_child(::substrait::Expression_MaskExpression_Select* child); - private: - const ::substrait::Expression_MaskExpression_Select& _internal_child() const; - ::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::substrait::Expression_MaskExpression_Select* child); - ::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); - - // int32 field = 1; - void clear_field(); - int32_t field() const; - void set_field(int32_t value); - private: - int32_t _internal_field() const; - void _internal_set_field(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.StructItem) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Expression_MaskExpression_Select* child_; - int32_t field_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression_ListSelect_ListSelectItem_ListElement final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) */ { - public: - inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() : Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(nullptr) {} - ~Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() override; - explicit constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from); - Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&& from) noexcept - : Expression_MaskExpression_ListSelect_ListSelectItem_ListElement() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& operator=(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&& 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 Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_); - } - static constexpr int kIndexInFileMessages = - 36; - - friend void swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& a, Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* 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(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement"; - } - protected: - explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListElement(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kFieldFieldNumber = 1, - }; - // int32 field = 1; - void clear_field(); - int32_t field() const; - void set_field(int32_t value); - private: - int32_t _internal_field() const; - void _internal_set_field(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int32_t field_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) */ { - public: - inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() : Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(nullptr) {} - ~Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() override; - explicit constexpr Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from); - Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&& from) noexcept - : Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& operator=(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&& 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 Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_); - } - static constexpr int kIndexInFileMessages = - 37; - - friend void swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& a, Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* 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(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice"; - } - protected: - explicit Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kStartFieldNumber = 1, - kEndFieldNumber = 2, - }; - // int32 start = 1; - void clear_start(); - int32_t start() const; - void set_start(int32_t value); - private: - int32_t _internal_start() const; - void _internal_set_start(int32_t value); - public: - - // int32 end = 2; - void clear_end(); - int32_t end() const; - void set_end(int32_t value); - private: - int32_t _internal_end() const; - void _internal_set_end(int32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int32_t start_; - int32_t end_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression_ListSelect_ListSelectItem final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) */ { - public: - inline Expression_MaskExpression_ListSelect_ListSelectItem() : Expression_MaskExpression_ListSelect_ListSelectItem(nullptr) {} - ~Expression_MaskExpression_ListSelect_ListSelectItem() override; - explicit constexpr Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression_ListSelect_ListSelectItem(const Expression_MaskExpression_ListSelect_ListSelectItem& from); - Expression_MaskExpression_ListSelect_ListSelectItem(Expression_MaskExpression_ListSelect_ListSelectItem&& from) noexcept - : Expression_MaskExpression_ListSelect_ListSelectItem() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression_ListSelect_ListSelectItem& operator=(const Expression_MaskExpression_ListSelect_ListSelectItem& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression_ListSelect_ListSelectItem& operator=(Expression_MaskExpression_ListSelect_ListSelectItem&& 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 Expression_MaskExpression_ListSelect_ListSelectItem& default_instance() { - return *internal_default_instance(); - } - enum TypeCase { - kItem = 1, - kSlice = 2, - TYPE_NOT_SET = 0, - }; - - static inline const Expression_MaskExpression_ListSelect_ListSelectItem* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_ListSelect_ListSelectItem_default_instance_); - } - static constexpr int kIndexInFileMessages = - 38; - - friend void swap(Expression_MaskExpression_ListSelect_ListSelectItem& a, Expression_MaskExpression_ListSelect_ListSelectItem& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression_ListSelect_ListSelectItem* 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(Expression_MaskExpression_ListSelect_ListSelectItem* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression_ListSelect_ListSelectItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression_ListSelect_ListSelectItem& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression_ListSelect_ListSelectItem* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression.ListSelect.ListSelectItem"; - } - protected: - explicit Expression_MaskExpression_ListSelect_ListSelectItem(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_MaskExpression_ListSelect_ListSelectItem_ListElement ListElement; - typedef Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice ListSlice; - - // accessors ------------------------------------------------------- - - enum : int { - kItemFieldNumber = 1, - kSliceFieldNumber = 2, - }; - // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; - bool has_item() const; - private: - bool _internal_has_item() const; - public: - void clear_item(); - const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& item() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* release_item(); - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* mutable_item(); - void set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item); - private: - const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& _internal_item() const; - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _internal_mutable_item(); - public: - void unsafe_arena_set_allocated_item( - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item); - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* unsafe_arena_release_item(); - - // .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; - bool has_slice() const; - private: - bool _internal_has_slice() const; - public: - void clear_slice(); - const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& slice() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* release_slice(); - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* mutable_slice(); - void set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); - private: - const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& _internal_slice() const; - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _internal_mutable_slice(); - public: - void unsafe_arena_set_allocated_slice( - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice); - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* unsafe_arena_release_slice(); - - void clear_type(); - TypeCase type_case() const; - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect.ListSelectItem) - private: - class _Internal; - void set_has_item(); - void set_has_slice(); - - inline bool has_type() const; - inline void clear_has_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union TypeUnion { - constexpr TypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item_; - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice_; - } type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression_ListSelect final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.ListSelect) */ { - public: - inline Expression_MaskExpression_ListSelect() : Expression_MaskExpression_ListSelect(nullptr) {} - ~Expression_MaskExpression_ListSelect() override; - explicit constexpr Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression_ListSelect(const Expression_MaskExpression_ListSelect& from); - Expression_MaskExpression_ListSelect(Expression_MaskExpression_ListSelect&& from) noexcept - : Expression_MaskExpression_ListSelect() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression_ListSelect& operator=(const Expression_MaskExpression_ListSelect& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression_ListSelect& operator=(Expression_MaskExpression_ListSelect&& 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 Expression_MaskExpression_ListSelect& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_MaskExpression_ListSelect* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_ListSelect_default_instance_); - } - static constexpr int kIndexInFileMessages = - 39; - - friend void swap(Expression_MaskExpression_ListSelect& a, Expression_MaskExpression_ListSelect& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression_ListSelect* 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(Expression_MaskExpression_ListSelect* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression_ListSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression_ListSelect& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression_ListSelect& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression_ListSelect* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression.ListSelect"; - } - protected: - explicit Expression_MaskExpression_ListSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_MaskExpression_ListSelect_ListSelectItem ListSelectItem; - - // accessors ------------------------------------------------------- - - enum : int { - kSelectionFieldNumber = 1, - kChildFieldNumber = 2, - }; - // repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; - int selection_size() const; - private: - int _internal_selection_size() const; - public: - void clear_selection(); - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* mutable_selection(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >* - mutable_selection(); - private: - const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& _internal_selection(int index) const; - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* _internal_add_selection(); - public: - const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& selection(int index) const; - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* add_selection(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >& - selection() const; - - // .substrait.Expression.MaskExpression.Select child = 2; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::substrait::Expression_MaskExpression_Select& child() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_Select* release_child(); - ::substrait::Expression_MaskExpression_Select* mutable_child(); - void set_allocated_child(::substrait::Expression_MaskExpression_Select* child); - private: - const ::substrait::Expression_MaskExpression_Select& _internal_child() const; - ::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::substrait::Expression_MaskExpression_Select* child); - ::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); - - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.ListSelect) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem > selection_; - ::substrait::Expression_MaskExpression_Select* child_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression_MapSelect_MapKey final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect.MapKey) */ { - public: - inline Expression_MaskExpression_MapSelect_MapKey() : Expression_MaskExpression_MapSelect_MapKey(nullptr) {} - ~Expression_MaskExpression_MapSelect_MapKey() override; - explicit constexpr Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression_MapSelect_MapKey(const Expression_MaskExpression_MapSelect_MapKey& from); - Expression_MaskExpression_MapSelect_MapKey(Expression_MaskExpression_MapSelect_MapKey&& from) noexcept - : Expression_MaskExpression_MapSelect_MapKey() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression_MapSelect_MapKey& operator=(const Expression_MaskExpression_MapSelect_MapKey& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression_MapSelect_MapKey& operator=(Expression_MaskExpression_MapSelect_MapKey&& 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 Expression_MaskExpression_MapSelect_MapKey& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_MaskExpression_MapSelect_MapKey* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_MapSelect_MapKey_default_instance_); - } - static constexpr int kIndexInFileMessages = - 40; - - friend void swap(Expression_MaskExpression_MapSelect_MapKey& a, Expression_MaskExpression_MapSelect_MapKey& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression_MapSelect_MapKey* 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(Expression_MaskExpression_MapSelect_MapKey* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression_MapSelect_MapKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression_MapSelect_MapKey& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression_MapSelect_MapKey& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression_MapSelect_MapKey* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression.MapSelect.MapKey"; - } - protected: - explicit Expression_MaskExpression_MapSelect_MapKey(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kMapKeyFieldNumber = 1, - }; - // string map_key = 1; - void clear_map_key(); - const std::string& map_key() const; - template - void set_map_key(ArgT0&& arg0, ArgT... args); - std::string* mutable_map_key(); - PROTOBUF_NODISCARD std::string* release_map_key(); - void set_allocated_map_key(std::string* map_key); - private: - const std::string& _internal_map_key() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_map_key(const std::string& value); - std::string* _internal_mutable_map_key(); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.MapSelect.MapKey) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression_MapSelect_MapKeyExpression final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) */ { - public: - inline Expression_MaskExpression_MapSelect_MapKeyExpression() : Expression_MaskExpression_MapSelect_MapKeyExpression(nullptr) {} - ~Expression_MaskExpression_MapSelect_MapKeyExpression() override; - explicit constexpr Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression_MapSelect_MapKeyExpression(const Expression_MaskExpression_MapSelect_MapKeyExpression& from); - Expression_MaskExpression_MapSelect_MapKeyExpression(Expression_MaskExpression_MapSelect_MapKeyExpression&& from) noexcept - : Expression_MaskExpression_MapSelect_MapKeyExpression() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression_MapSelect_MapKeyExpression& operator=(const Expression_MaskExpression_MapSelect_MapKeyExpression& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression_MapSelect_MapKeyExpression& operator=(Expression_MaskExpression_MapSelect_MapKeyExpression&& 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 Expression_MaskExpression_MapSelect_MapKeyExpression& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_MaskExpression_MapSelect_MapKeyExpression* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_); - } - static constexpr int kIndexInFileMessages = - 41; - - friend void swap(Expression_MaskExpression_MapSelect_MapKeyExpression& a, Expression_MaskExpression_MapSelect_MapKeyExpression& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression_MapSelect_MapKeyExpression* 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(Expression_MaskExpression_MapSelect_MapKeyExpression* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression_MapSelect_MapKeyExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression_MapSelect_MapKeyExpression& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression_MapSelect_MapKeyExpression* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression.MapSelect.MapKeyExpression"; - } - protected: - explicit Expression_MaskExpression_MapSelect_MapKeyExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kMapKeyExpressionFieldNumber = 1, - }; - // string map_key_expression = 1; - void clear_map_key_expression(); - const std::string& map_key_expression() const; - template - void set_map_key_expression(ArgT0&& arg0, ArgT... args); - std::string* mutable_map_key_expression(); - PROTOBUF_NODISCARD std::string* release_map_key_expression(); - void set_allocated_map_key_expression(std::string* map_key_expression); - private: - const std::string& _internal_map_key_expression() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_map_key_expression(const std::string& value); - std::string* _internal_mutable_map_key_expression(); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr map_key_expression_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression_MapSelect final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression.MapSelect) */ { - public: - inline Expression_MaskExpression_MapSelect() : Expression_MaskExpression_MapSelect(nullptr) {} - ~Expression_MaskExpression_MapSelect() override; - explicit constexpr Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression_MapSelect(const Expression_MaskExpression_MapSelect& from); - Expression_MaskExpression_MapSelect(Expression_MaskExpression_MapSelect&& from) noexcept - : Expression_MaskExpression_MapSelect() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression_MapSelect& operator=(const Expression_MaskExpression_MapSelect& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression_MapSelect& operator=(Expression_MaskExpression_MapSelect&& 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 Expression_MaskExpression_MapSelect& default_instance() { - return *internal_default_instance(); - } - enum SelectCase { - kKey = 1, - kExpression = 2, - SELECT_NOT_SET = 0, - }; - - static inline const Expression_MaskExpression_MapSelect* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_MapSelect_default_instance_); - } - static constexpr int kIndexInFileMessages = - 42; - - friend void swap(Expression_MaskExpression_MapSelect& a, Expression_MaskExpression_MapSelect& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression_MapSelect* 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(Expression_MaskExpression_MapSelect* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression_MapSelect* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression_MapSelect& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression_MapSelect& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression_MapSelect* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression.MapSelect"; - } - protected: - explicit Expression_MaskExpression_MapSelect(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_MaskExpression_MapSelect_MapKey MapKey; - typedef Expression_MaskExpression_MapSelect_MapKeyExpression MapKeyExpression; - - // accessors ------------------------------------------------------- - - enum : int { - kChildFieldNumber = 3, - kKeyFieldNumber = 1, - kExpressionFieldNumber = 2, - }; - // .substrait.Expression.MaskExpression.Select child = 3; - bool has_child() const; - private: - bool _internal_has_child() const; - public: - void clear_child(); - const ::substrait::Expression_MaskExpression_Select& child() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_Select* release_child(); - ::substrait::Expression_MaskExpression_Select* mutable_child(); - void set_allocated_child(::substrait::Expression_MaskExpression_Select* child); - private: - const ::substrait::Expression_MaskExpression_Select& _internal_child() const; - ::substrait::Expression_MaskExpression_Select* _internal_mutable_child(); - public: - void unsafe_arena_set_allocated_child( - ::substrait::Expression_MaskExpression_Select* child); - ::substrait::Expression_MaskExpression_Select* unsafe_arena_release_child(); - - // .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::substrait::Expression_MaskExpression_MapSelect_MapKey& key() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_MapSelect_MapKey* release_key(); - ::substrait::Expression_MaskExpression_MapSelect_MapKey* mutable_key(); - void set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key); - private: - const ::substrait::Expression_MaskExpression_MapSelect_MapKey& _internal_key() const; - ::substrait::Expression_MaskExpression_MapSelect_MapKey* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::substrait::Expression_MaskExpression_MapSelect_MapKey* key); - ::substrait::Expression_MaskExpression_MapSelect_MapKey* unsafe_arena_release_key(); - - // .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; - bool has_expression() const; - private: - bool _internal_has_expression() const; - public: - void clear_expression(); - const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& expression() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* release_expression(); - ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* mutable_expression(); - void set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression); - private: - const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& _internal_expression() const; - ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* _internal_mutable_expression(); - public: - void unsafe_arena_set_allocated_expression( - ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression); - ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* unsafe_arena_release_expression(); - - void clear_select(); - SelectCase select_case() const; - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression.MapSelect) - private: - class _Internal; - void set_has_key(); - void set_has_expression(); - - inline bool has_select() const; - inline void clear_has_select(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Expression_MaskExpression_Select* child_; - union SelectUnion { - constexpr SelectUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Expression_MaskExpression_MapSelect_MapKey* key_; - ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression_; - } select_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_MaskExpression final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.MaskExpression) */ { - public: - inline Expression_MaskExpression() : Expression_MaskExpression(nullptr) {} - ~Expression_MaskExpression() override; - explicit constexpr Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_MaskExpression(const Expression_MaskExpression& from); - Expression_MaskExpression(Expression_MaskExpression&& from) noexcept - : Expression_MaskExpression() { - *this = ::std::move(from); - } - - inline Expression_MaskExpression& operator=(const Expression_MaskExpression& from) { - CopyFrom(from); - return *this; - } - inline Expression_MaskExpression& operator=(Expression_MaskExpression&& 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 Expression_MaskExpression& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_MaskExpression* internal_default_instance() { - return reinterpret_cast( - &_Expression_MaskExpression_default_instance_); - } - static constexpr int kIndexInFileMessages = - 43; - - friend void swap(Expression_MaskExpression& a, Expression_MaskExpression& b) { - a.Swap(&b); - } - inline void Swap(Expression_MaskExpression* 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(Expression_MaskExpression* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_MaskExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_MaskExpression& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_MaskExpression& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_MaskExpression* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.MaskExpression"; - } - protected: - explicit Expression_MaskExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_MaskExpression_Select Select; - typedef Expression_MaskExpression_StructSelect StructSelect; - typedef Expression_MaskExpression_StructItem StructItem; - typedef Expression_MaskExpression_ListSelect ListSelect; - typedef Expression_MaskExpression_MapSelect MapSelect; - - // accessors ------------------------------------------------------- - - enum : int { - kSelectFieldNumber = 1, - kMaintainSingularStructFieldNumber = 2, - }; - // .substrait.Expression.MaskExpression.StructSelect select = 1; - bool has_select() const; - private: - bool _internal_has_select() const; - public: - void clear_select(); - const ::substrait::Expression_MaskExpression_StructSelect& select() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression_StructSelect* release_select(); - ::substrait::Expression_MaskExpression_StructSelect* mutable_select(); - void set_allocated_select(::substrait::Expression_MaskExpression_StructSelect* select); - private: - const ::substrait::Expression_MaskExpression_StructSelect& _internal_select() const; - ::substrait::Expression_MaskExpression_StructSelect* _internal_mutable_select(); - public: - void unsafe_arena_set_allocated_select( - ::substrait::Expression_MaskExpression_StructSelect* select); - ::substrait::Expression_MaskExpression_StructSelect* unsafe_arena_release_select(); - - // bool maintain_singular_struct = 2; - void clear_maintain_singular_struct(); - bool maintain_singular_struct() const; - void set_maintain_singular_struct(bool value); - private: - bool _internal_maintain_singular_struct() const; - void _internal_set_maintain_singular_struct(bool value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Expression.MaskExpression) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Expression_MaskExpression_StructSelect* select_; - bool maintain_singular_struct_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_FieldReference_RootReference final : - public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.Expression.FieldReference.RootReference) */ { - public: - inline Expression_FieldReference_RootReference() : Expression_FieldReference_RootReference(nullptr) {} - explicit constexpr Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_FieldReference_RootReference(const Expression_FieldReference_RootReference& from); - Expression_FieldReference_RootReference(Expression_FieldReference_RootReference&& from) noexcept - : Expression_FieldReference_RootReference() { - *this = ::std::move(from); - } - - inline Expression_FieldReference_RootReference& operator=(const Expression_FieldReference_RootReference& from) { - CopyFrom(from); - return *this; - } - inline Expression_FieldReference_RootReference& operator=(Expression_FieldReference_RootReference&& 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 Expression_FieldReference_RootReference& default_instance() { - return *internal_default_instance(); - } - static inline const Expression_FieldReference_RootReference* internal_default_instance() { - return reinterpret_cast( - &_Expression_FieldReference_RootReference_default_instance_); - } - static constexpr int kIndexInFileMessages = - 44; - - friend void swap(Expression_FieldReference_RootReference& a, Expression_FieldReference_RootReference& b) { - a.Swap(&b); - } - inline void Swap(Expression_FieldReference_RootReference* 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(Expression_FieldReference_RootReference* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_FieldReference_RootReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; - inline void CopyFrom(const Expression_FieldReference_RootReference& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; - void MergeFrom(const Expression_FieldReference_RootReference& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); - } - public: - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.FieldReference.RootReference"; - } - protected: - explicit Expression_FieldReference_RootReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - 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 ------------------------------------------------------- - - // @@protoc_insertion_point(class_scope:substrait.Expression.FieldReference.RootReference) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression_FieldReference final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression.FieldReference) */ { - public: - inline Expression_FieldReference() : Expression_FieldReference(nullptr) {} - ~Expression_FieldReference() override; - explicit constexpr Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression_FieldReference(const Expression_FieldReference& from); - Expression_FieldReference(Expression_FieldReference&& from) noexcept - : Expression_FieldReference() { - *this = ::std::move(from); - } - - inline Expression_FieldReference& operator=(const Expression_FieldReference& from) { - CopyFrom(from); - return *this; - } - inline Expression_FieldReference& operator=(Expression_FieldReference&& 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 Expression_FieldReference& default_instance() { - return *internal_default_instance(); - } - enum ReferenceTypeCase { - kDirectReference = 1, - kMaskedReference = 2, - REFERENCE_TYPE_NOT_SET = 0, - }; - - enum RootTypeCase { - kExpression = 3, - kRootReference = 4, - ROOT_TYPE_NOT_SET = 0, - }; - - static inline const Expression_FieldReference* internal_default_instance() { - return reinterpret_cast( - &_Expression_FieldReference_default_instance_); - } - static constexpr int kIndexInFileMessages = - 45; - - friend void swap(Expression_FieldReference& a, Expression_FieldReference& b) { - a.Swap(&b); - } - inline void Swap(Expression_FieldReference* 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(Expression_FieldReference* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression_FieldReference* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression_FieldReference& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression_FieldReference& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression_FieldReference* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression.FieldReference"; - } - protected: - explicit Expression_FieldReference(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_FieldReference_RootReference RootReference; - - // accessors ------------------------------------------------------- - - enum : int { - kDirectReferenceFieldNumber = 1, - kMaskedReferenceFieldNumber = 2, - kExpressionFieldNumber = 3, - kRootReferenceFieldNumber = 4, - }; - // .substrait.Expression.ReferenceSegment direct_reference = 1; - bool has_direct_reference() const; - private: - bool _internal_has_direct_reference() const; - public: - void clear_direct_reference(); - const ::substrait::Expression_ReferenceSegment& direct_reference() const; - PROTOBUF_NODISCARD ::substrait::Expression_ReferenceSegment* release_direct_reference(); - ::substrait::Expression_ReferenceSegment* mutable_direct_reference(); - void set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference); - private: - const ::substrait::Expression_ReferenceSegment& _internal_direct_reference() const; - ::substrait::Expression_ReferenceSegment* _internal_mutable_direct_reference(); - public: - void unsafe_arena_set_allocated_direct_reference( - ::substrait::Expression_ReferenceSegment* direct_reference); - ::substrait::Expression_ReferenceSegment* unsafe_arena_release_direct_reference(); - - // .substrait.Expression.MaskExpression masked_reference = 2; - bool has_masked_reference() const; - private: - bool _internal_has_masked_reference() const; - public: - void clear_masked_reference(); - const ::substrait::Expression_MaskExpression& masked_reference() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression* release_masked_reference(); - ::substrait::Expression_MaskExpression* mutable_masked_reference(); - void set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference); - private: - const ::substrait::Expression_MaskExpression& _internal_masked_reference() const; - ::substrait::Expression_MaskExpression* _internal_mutable_masked_reference(); - public: - void unsafe_arena_set_allocated_masked_reference( - ::substrait::Expression_MaskExpression* masked_reference); - ::substrait::Expression_MaskExpression* unsafe_arena_release_masked_reference(); - - // .substrait.Expression expression = 3; - bool has_expression() const; - private: - bool _internal_has_expression() const; - public: - void clear_expression(); - const ::substrait::Expression& expression() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_expression(); - ::substrait::Expression* mutable_expression(); - void set_allocated_expression(::substrait::Expression* expression); - private: - const ::substrait::Expression& _internal_expression() const; - ::substrait::Expression* _internal_mutable_expression(); - public: - void unsafe_arena_set_allocated_expression( - ::substrait::Expression* expression); - ::substrait::Expression* unsafe_arena_release_expression(); - - // .substrait.Expression.FieldReference.RootReference root_reference = 4; - bool has_root_reference() const; - private: - bool _internal_has_root_reference() const; - public: - void clear_root_reference(); - const ::substrait::Expression_FieldReference_RootReference& root_reference() const; - PROTOBUF_NODISCARD ::substrait::Expression_FieldReference_RootReference* release_root_reference(); - ::substrait::Expression_FieldReference_RootReference* mutable_root_reference(); - void set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference); - private: - const ::substrait::Expression_FieldReference_RootReference& _internal_root_reference() const; - ::substrait::Expression_FieldReference_RootReference* _internal_mutable_root_reference(); - public: - void unsafe_arena_set_allocated_root_reference( - ::substrait::Expression_FieldReference_RootReference* root_reference); - ::substrait::Expression_FieldReference_RootReference* unsafe_arena_release_root_reference(); - - void clear_reference_type(); - ReferenceTypeCase reference_type_case() const; - void clear_root_type(); - RootTypeCase root_type_case() const; - // @@protoc_insertion_point(class_scope:substrait.Expression.FieldReference) - private: - class _Internal; - void set_has_direct_reference(); - void set_has_masked_reference(); - void set_has_expression(); - void set_has_root_reference(); - - inline bool has_reference_type() const; - inline void clear_has_reference_type(); - - inline bool has_root_type() const; - inline void clear_has_root_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union ReferenceTypeUnion { - constexpr ReferenceTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Expression_ReferenceSegment* direct_reference_; - ::substrait::Expression_MaskExpression* masked_reference_; - } reference_type_; - union RootTypeUnion { - constexpr RootTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Expression* expression_; - ::substrait::Expression_FieldReference_RootReference* root_reference_; - } root_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[2]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class Expression final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Expression) */ { - public: - inline Expression() : Expression(nullptr) {} - ~Expression() override; - explicit constexpr Expression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Expression(const Expression& from); - Expression(Expression&& from) noexcept - : Expression() { - *this = ::std::move(from); - } - - inline Expression& operator=(const Expression& from) { - CopyFrom(from); - return *this; - } - inline Expression& operator=(Expression&& 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 Expression& default_instance() { - return *internal_default_instance(); - } - enum RexTypeCase { - kLiteral = 1, - kSelection = 2, - kScalarFunction = 3, - kWindowFunction = 5, - kIfThen = 6, - kSwitchExpression = 7, - kSingularOrList = 8, - kMultiOrList = 9, - kEnum = 10, - kCast = 11, - REX_TYPE_NOT_SET = 0, - }; - - static inline const Expression* internal_default_instance() { - return reinterpret_cast( - &_Expression_default_instance_); - } - static constexpr int kIndexInFileMessages = - 46; - - friend void swap(Expression& a, Expression& b) { - a.Swap(&b); - } - inline void Swap(Expression* 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(Expression* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Expression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Expression& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Expression& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Expression* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Expression"; - } - protected: - explicit Expression(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Expression_Enum Enum; - typedef Expression_Literal Literal; - typedef Expression_ScalarFunction ScalarFunction; - typedef Expression_WindowFunction WindowFunction; - typedef Expression_IfThen IfThen; - typedef Expression_Cast Cast; - typedef Expression_SwitchExpression SwitchExpression; - typedef Expression_SingularOrList SingularOrList; - typedef Expression_MultiOrList MultiOrList; - typedef Expression_EmbeddedFunction EmbeddedFunction; - typedef Expression_ReferenceSegment ReferenceSegment; - typedef Expression_MaskExpression MaskExpression; - typedef Expression_FieldReference FieldReference; - - // accessors ------------------------------------------------------- - - enum : int { - kLiteralFieldNumber = 1, - kSelectionFieldNumber = 2, - kScalarFunctionFieldNumber = 3, - kWindowFunctionFieldNumber = 5, - kIfThenFieldNumber = 6, - kSwitchExpressionFieldNumber = 7, - kSingularOrListFieldNumber = 8, - kMultiOrListFieldNumber = 9, - kEnumFieldNumber = 10, - kCastFieldNumber = 11, - }; - // .substrait.Expression.Literal literal = 1; - bool has_literal() const; - private: - bool _internal_has_literal() const; - public: - void clear_literal(); - const ::substrait::Expression_Literal& literal() const; - PROTOBUF_NODISCARD ::substrait::Expression_Literal* release_literal(); - ::substrait::Expression_Literal* mutable_literal(); - void set_allocated_literal(::substrait::Expression_Literal* literal); - private: - const ::substrait::Expression_Literal& _internal_literal() const; - ::substrait::Expression_Literal* _internal_mutable_literal(); - public: - void unsafe_arena_set_allocated_literal( - ::substrait::Expression_Literal* literal); - ::substrait::Expression_Literal* unsafe_arena_release_literal(); - - // .substrait.Expression.FieldReference selection = 2; - bool has_selection() const; - private: - bool _internal_has_selection() const; - public: - void clear_selection(); - const ::substrait::Expression_FieldReference& selection() const; - PROTOBUF_NODISCARD ::substrait::Expression_FieldReference* release_selection(); - ::substrait::Expression_FieldReference* mutable_selection(); - void set_allocated_selection(::substrait::Expression_FieldReference* selection); - private: - const ::substrait::Expression_FieldReference& _internal_selection() const; - ::substrait::Expression_FieldReference* _internal_mutable_selection(); - public: - void unsafe_arena_set_allocated_selection( - ::substrait::Expression_FieldReference* selection); - ::substrait::Expression_FieldReference* unsafe_arena_release_selection(); - - // .substrait.Expression.ScalarFunction scalar_function = 3; - bool has_scalar_function() const; - private: - bool _internal_has_scalar_function() const; - public: - void clear_scalar_function(); - const ::substrait::Expression_ScalarFunction& scalar_function() const; - PROTOBUF_NODISCARD ::substrait::Expression_ScalarFunction* release_scalar_function(); - ::substrait::Expression_ScalarFunction* mutable_scalar_function(); - void set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function); - private: - const ::substrait::Expression_ScalarFunction& _internal_scalar_function() const; - ::substrait::Expression_ScalarFunction* _internal_mutable_scalar_function(); - public: - void unsafe_arena_set_allocated_scalar_function( - ::substrait::Expression_ScalarFunction* scalar_function); - ::substrait::Expression_ScalarFunction* unsafe_arena_release_scalar_function(); - - // .substrait.Expression.WindowFunction window_function = 5; - bool has_window_function() const; - private: - bool _internal_has_window_function() const; - public: - void clear_window_function(); - const ::substrait::Expression_WindowFunction& window_function() const; - PROTOBUF_NODISCARD ::substrait::Expression_WindowFunction* release_window_function(); - ::substrait::Expression_WindowFunction* mutable_window_function(); - void set_allocated_window_function(::substrait::Expression_WindowFunction* window_function); - private: - const ::substrait::Expression_WindowFunction& _internal_window_function() const; - ::substrait::Expression_WindowFunction* _internal_mutable_window_function(); - public: - void unsafe_arena_set_allocated_window_function( - ::substrait::Expression_WindowFunction* window_function); - ::substrait::Expression_WindowFunction* unsafe_arena_release_window_function(); - - // .substrait.Expression.IfThen if_then = 6; - bool has_if_then() const; - private: - bool _internal_has_if_then() const; - public: - void clear_if_then(); - const ::substrait::Expression_IfThen& if_then() const; - PROTOBUF_NODISCARD ::substrait::Expression_IfThen* release_if_then(); - ::substrait::Expression_IfThen* mutable_if_then(); - void set_allocated_if_then(::substrait::Expression_IfThen* if_then); - private: - const ::substrait::Expression_IfThen& _internal_if_then() const; - ::substrait::Expression_IfThen* _internal_mutable_if_then(); - public: - void unsafe_arena_set_allocated_if_then( - ::substrait::Expression_IfThen* if_then); - ::substrait::Expression_IfThen* unsafe_arena_release_if_then(); - - // .substrait.Expression.SwitchExpression switch_expression = 7; - bool has_switch_expression() const; - private: - bool _internal_has_switch_expression() const; - public: - void clear_switch_expression(); - const ::substrait::Expression_SwitchExpression& switch_expression() const; - PROTOBUF_NODISCARD ::substrait::Expression_SwitchExpression* release_switch_expression(); - ::substrait::Expression_SwitchExpression* mutable_switch_expression(); - void set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression); - private: - const ::substrait::Expression_SwitchExpression& _internal_switch_expression() const; - ::substrait::Expression_SwitchExpression* _internal_mutable_switch_expression(); - public: - void unsafe_arena_set_allocated_switch_expression( - ::substrait::Expression_SwitchExpression* switch_expression); - ::substrait::Expression_SwitchExpression* unsafe_arena_release_switch_expression(); - - // .substrait.Expression.SingularOrList singular_or_list = 8; - bool has_singular_or_list() const; - private: - bool _internal_has_singular_or_list() const; - public: - void clear_singular_or_list(); - const ::substrait::Expression_SingularOrList& singular_or_list() const; - PROTOBUF_NODISCARD ::substrait::Expression_SingularOrList* release_singular_or_list(); - ::substrait::Expression_SingularOrList* mutable_singular_or_list(); - void set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list); - private: - const ::substrait::Expression_SingularOrList& _internal_singular_or_list() const; - ::substrait::Expression_SingularOrList* _internal_mutable_singular_or_list(); - public: - void unsafe_arena_set_allocated_singular_or_list( - ::substrait::Expression_SingularOrList* singular_or_list); - ::substrait::Expression_SingularOrList* unsafe_arena_release_singular_or_list(); - - // .substrait.Expression.MultiOrList multi_or_list = 9; - bool has_multi_or_list() const; - private: - bool _internal_has_multi_or_list() const; - public: - void clear_multi_or_list(); - const ::substrait::Expression_MultiOrList& multi_or_list() const; - PROTOBUF_NODISCARD ::substrait::Expression_MultiOrList* release_multi_or_list(); - ::substrait::Expression_MultiOrList* mutable_multi_or_list(); - void set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list); - private: - const ::substrait::Expression_MultiOrList& _internal_multi_or_list() const; - ::substrait::Expression_MultiOrList* _internal_mutable_multi_or_list(); - public: - void unsafe_arena_set_allocated_multi_or_list( - ::substrait::Expression_MultiOrList* multi_or_list); - ::substrait::Expression_MultiOrList* unsafe_arena_release_multi_or_list(); - - // .substrait.Expression.Enum enum = 10; - bool has_enum_() const; - private: - bool _internal_has_enum_() const; - public: - void clear_enum_(); - const ::substrait::Expression_Enum& enum_() const; - PROTOBUF_NODISCARD ::substrait::Expression_Enum* release_enum_(); - ::substrait::Expression_Enum* mutable_enum_(); - void set_allocated_enum_(::substrait::Expression_Enum* enum_); - private: - const ::substrait::Expression_Enum& _internal_enum_() const; - ::substrait::Expression_Enum* _internal_mutable_enum_(); - public: - void unsafe_arena_set_allocated_enum_( - ::substrait::Expression_Enum* enum_); - ::substrait::Expression_Enum* unsafe_arena_release_enum_(); - - // .substrait.Expression.Cast cast = 11; - bool has_cast() const; - private: - bool _internal_has_cast() const; - public: - void clear_cast(); - const ::substrait::Expression_Cast& cast() const; - PROTOBUF_NODISCARD ::substrait::Expression_Cast* release_cast(); - ::substrait::Expression_Cast* mutable_cast(); - void set_allocated_cast(::substrait::Expression_Cast* cast); - private: - const ::substrait::Expression_Cast& _internal_cast() const; - ::substrait::Expression_Cast* _internal_mutable_cast(); - public: - void unsafe_arena_set_allocated_cast( - ::substrait::Expression_Cast* cast); - ::substrait::Expression_Cast* unsafe_arena_release_cast(); - - void clear_rex_type(); - RexTypeCase rex_type_case() const; - // @@protoc_insertion_point(class_scope:substrait.Expression) - private: - class _Internal; - void set_has_literal(); - void set_has_selection(); - void set_has_scalar_function(); - void set_has_window_function(); - void set_has_if_then(); - void set_has_switch_expression(); - void set_has_singular_or_list(); - void set_has_multi_or_list(); - void set_has_enum_(); - void set_has_cast(); - - inline bool has_rex_type() const; - inline void clear_has_rex_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union RexTypeUnion { - constexpr RexTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Expression_Literal* literal_; - ::substrait::Expression_FieldReference* selection_; - ::substrait::Expression_ScalarFunction* scalar_function_; - ::substrait::Expression_WindowFunction* window_function_; - ::substrait::Expression_IfThen* if_then_; - ::substrait::Expression_SwitchExpression* switch_expression_; - ::substrait::Expression_SingularOrList* singular_or_list_; - ::substrait::Expression_MultiOrList* multi_or_list_; - ::substrait::Expression_Enum* enum__; - ::substrait::Expression_Cast* cast_; - } rex_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class SortField final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SortField) */ { - public: - inline SortField() : SortField(nullptr) {} - ~SortField() override; - explicit constexpr SortField(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SortField(const SortField& from); - SortField(SortField&& from) noexcept - : SortField() { - *this = ::std::move(from); - } - - inline SortField& operator=(const SortField& from) { - CopyFrom(from); - return *this; - } - inline SortField& operator=(SortField&& 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 SortField& default_instance() { - return *internal_default_instance(); - } - enum SortKindCase { - kDirection = 2, - kComparisonFunctionReference = 3, - SORT_KIND_NOT_SET = 0, - }; - - static inline const SortField* internal_default_instance() { - return reinterpret_cast( - &_SortField_default_instance_); - } - static constexpr int kIndexInFileMessages = - 47; - - friend void swap(SortField& a, SortField& b) { - a.Swap(&b); - } - inline void Swap(SortField* 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(SortField* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SortField* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SortField& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const SortField& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SortField* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.SortField"; - } - protected: - explicit SortField(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef SortField_SortDirection SortDirection; - static constexpr SortDirection SORT_DIRECTION_UNSPECIFIED = - SortField_SortDirection_SORT_DIRECTION_UNSPECIFIED; - static constexpr SortDirection SORT_DIRECTION_ASC_NULLS_FIRST = - SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_FIRST; - static constexpr SortDirection SORT_DIRECTION_ASC_NULLS_LAST = - SortField_SortDirection_SORT_DIRECTION_ASC_NULLS_LAST; - static constexpr SortDirection SORT_DIRECTION_DESC_NULLS_FIRST = - SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_FIRST; - static constexpr SortDirection SORT_DIRECTION_DESC_NULLS_LAST = - SortField_SortDirection_SORT_DIRECTION_DESC_NULLS_LAST; - static constexpr SortDirection SORT_DIRECTION_CLUSTERED = - SortField_SortDirection_SORT_DIRECTION_CLUSTERED; - static inline bool SortDirection_IsValid(int value) { - return SortField_SortDirection_IsValid(value); - } - static constexpr SortDirection SortDirection_MIN = - SortField_SortDirection_SortDirection_MIN; - static constexpr SortDirection SortDirection_MAX = - SortField_SortDirection_SortDirection_MAX; - static constexpr int SortDirection_ARRAYSIZE = - SortField_SortDirection_SortDirection_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - SortDirection_descriptor() { - return SortField_SortDirection_descriptor(); - } - template - static inline const std::string& SortDirection_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function SortDirection_Name."); - return SortField_SortDirection_Name(enum_t_value); - } - static inline bool SortDirection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - SortDirection* value) { - return SortField_SortDirection_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kExprFieldNumber = 1, - kDirectionFieldNumber = 2, - kComparisonFunctionReferenceFieldNumber = 3, - }; - // .substrait.Expression expr = 1; - bool has_expr() const; - private: - bool _internal_has_expr() const; - public: - void clear_expr(); - const ::substrait::Expression& expr() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_expr(); - ::substrait::Expression* mutable_expr(); - void set_allocated_expr(::substrait::Expression* expr); - private: - const ::substrait::Expression& _internal_expr() const; - ::substrait::Expression* _internal_mutable_expr(); - public: - void unsafe_arena_set_allocated_expr( - ::substrait::Expression* expr); - ::substrait::Expression* unsafe_arena_release_expr(); - - // .substrait.SortField.SortDirection direction = 2; - bool has_direction() const; - private: - bool _internal_has_direction() const; - public: - void clear_direction(); - ::substrait::SortField_SortDirection direction() const; - void set_direction(::substrait::SortField_SortDirection value); - private: - ::substrait::SortField_SortDirection _internal_direction() const; - void _internal_set_direction(::substrait::SortField_SortDirection value); - public: - - // uint32 comparison_function_reference = 3; - bool has_comparison_function_reference() const; - private: - bool _internal_has_comparison_function_reference() const; - public: - void clear_comparison_function_reference(); - uint32_t comparison_function_reference() const; - void set_comparison_function_reference(uint32_t value); - private: - uint32_t _internal_comparison_function_reference() const; - void _internal_set_comparison_function_reference(uint32_t value); - public: - - void clear_sort_kind(); - SortKindCase sort_kind_case() const; - // @@protoc_insertion_point(class_scope:substrait.SortField) - private: - class _Internal; - void set_has_direction(); - void set_has_comparison_function_reference(); - - inline bool has_sort_kind() const; - inline void clear_has_sort_kind(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Expression* expr_; - union SortKindUnion { - constexpr SortKindUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - int direction_; - uint32_t comparison_function_reference_; - } sort_kind_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// ------------------------------------------------------------------- - -class AggregateFunction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateFunction) */ { - public: - inline AggregateFunction() : AggregateFunction(nullptr) {} - ~AggregateFunction() override; - explicit constexpr AggregateFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - AggregateFunction(const AggregateFunction& from); - AggregateFunction(AggregateFunction&& from) noexcept - : AggregateFunction() { - *this = ::std::move(from); - } - - inline AggregateFunction& operator=(const AggregateFunction& from) { - CopyFrom(from); - return *this; - } - inline AggregateFunction& operator=(AggregateFunction&& 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 AggregateFunction& default_instance() { - return *internal_default_instance(); - } - static inline const AggregateFunction* internal_default_instance() { - return reinterpret_cast( - &_AggregateFunction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 48; - - friend void swap(AggregateFunction& a, AggregateFunction& b) { - a.Swap(&b); - } - inline void Swap(AggregateFunction* 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(AggregateFunction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - AggregateFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const AggregateFunction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const AggregateFunction& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(AggregateFunction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.AggregateFunction"; - } - protected: - explicit AggregateFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kArgsFieldNumber = 2, - kSortsFieldNumber = 3, - kOutputTypeFieldNumber = 5, - kFunctionReferenceFieldNumber = 1, - kPhaseFieldNumber = 4, - }; - // repeated .substrait.Expression args = 2; - int args_size() const; - private: - int _internal_args_size() const; - public: - void clear_args(); - ::substrait::Expression* mutable_args(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* - mutable_args(); - private: - const ::substrait::Expression& _internal_args(int index) const; - ::substrait::Expression* _internal_add_args(); - public: - const ::substrait::Expression& args(int index) const; - ::substrait::Expression* add_args(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& - args() const; - - // repeated .substrait.SortField sorts = 3; - int sorts_size() const; - private: - int _internal_sorts_size() const; - public: - void clear_sorts(); - ::substrait::SortField* mutable_sorts(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* - mutable_sorts(); - private: - const ::substrait::SortField& _internal_sorts(int index) const; - ::substrait::SortField* _internal_add_sorts(); - public: - const ::substrait::SortField& sorts(int index) const; - ::substrait::SortField* add_sorts(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& - sorts() const; - - // .substrait.Type output_type = 5; - bool has_output_type() const; - private: - bool _internal_has_output_type() const; - public: - void clear_output_type(); - const ::substrait::Type& output_type() const; - PROTOBUF_NODISCARD ::substrait::Type* release_output_type(); - ::substrait::Type* mutable_output_type(); - void set_allocated_output_type(::substrait::Type* output_type); - private: - const ::substrait::Type& _internal_output_type() const; - ::substrait::Type* _internal_mutable_output_type(); - public: - void unsafe_arena_set_allocated_output_type( - ::substrait::Type* output_type); - ::substrait::Type* unsafe_arena_release_output_type(); - - // uint32 function_reference = 1; - void clear_function_reference(); - uint32_t function_reference() const; - void set_function_reference(uint32_t value); - private: - uint32_t _internal_function_reference() const; - void _internal_set_function_reference(uint32_t value); - public: - - // .substrait.AggregationPhase phase = 4; - void clear_phase(); - ::substrait::AggregationPhase phase() const; - void set_phase(::substrait::AggregationPhase value); - private: - ::substrait::AggregationPhase _internal_phase() const; - void _internal_set_phase(::substrait::AggregationPhase value); - public: - - // @@protoc_insertion_point(class_scope:substrait.AggregateFunction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > args_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField > sorts_; - ::substrait::Type* output_type_; - uint32_t function_reference_; - int phase_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fexpression_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// Expression_Enum_Empty - -// ------------------------------------------------------------------- - -// Expression_Enum - -// string specified = 1; -inline bool Expression_Enum::_internal_has_specified() const { - return enum_kind_case() == kSpecified; -} -inline bool Expression_Enum::has_specified() const { - return _internal_has_specified(); -} -inline void Expression_Enum::set_has_specified() { - _oneof_case_[0] = kSpecified; -} -inline void Expression_Enum::clear_specified() { - if (_internal_has_specified()) { - enum_kind_.specified_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_enum_kind(); - } -} -inline const std::string& Expression_Enum::specified() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Enum.specified) - return _internal_specified(); -} -template -inline void Expression_Enum::set_specified(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_specified()) { - clear_enum_kind(); - set_has_specified(); - enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.Enum.specified) -} -inline std::string* Expression_Enum::mutable_specified() { - std::string* _s = _internal_mutable_specified(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Enum.specified) - return _s; -} -inline const std::string& Expression_Enum::_internal_specified() const { - if (_internal_has_specified()) { - return enum_kind_.specified_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Expression_Enum::_internal_set_specified(const std::string& value) { - if (!_internal_has_specified()) { - clear_enum_kind(); - set_has_specified(); - enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - enum_kind_.specified_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_Enum::_internal_mutable_specified() { - if (!_internal_has_specified()) { - clear_enum_kind(); - set_has_specified(); - enum_kind_.specified_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return enum_kind_.specified_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_Enum::release_specified() { - // @@protoc_insertion_point(field_release:substrait.Expression.Enum.specified) - if (_internal_has_specified()) { - clear_has_enum_kind(); - return enum_kind_.specified_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void Expression_Enum::set_allocated_specified(std::string* specified) { - if (has_enum_kind()) { - clear_enum_kind(); - } - if (specified != nullptr) { - set_has_specified(); - enum_kind_.specified_.UnsafeSetDefault(specified); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(specified); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Enum.specified) -} - -// .substrait.Expression.Enum.Empty unspecified = 2; -inline bool Expression_Enum::_internal_has_unspecified() const { - return enum_kind_case() == kUnspecified; -} -inline bool Expression_Enum::has_unspecified() const { - return _internal_has_unspecified(); -} -inline void Expression_Enum::set_has_unspecified() { - _oneof_case_[0] = kUnspecified; -} -inline void Expression_Enum::clear_unspecified() { - if (_internal_has_unspecified()) { - if (GetArenaForAllocation() == nullptr) { - delete enum_kind_.unspecified_; - } - clear_has_enum_kind(); - } -} -inline ::substrait::Expression_Enum_Empty* Expression_Enum::release_unspecified() { - // @@protoc_insertion_point(field_release:substrait.Expression.Enum.unspecified) - if (_internal_has_unspecified()) { - clear_has_enum_kind(); - ::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - enum_kind_.unspecified_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Enum_Empty& Expression_Enum::_internal_unspecified() const { - return _internal_has_unspecified() - ? *enum_kind_.unspecified_ - : reinterpret_cast< ::substrait::Expression_Enum_Empty&>(::substrait::_Expression_Enum_Empty_default_instance_); -} -inline const ::substrait::Expression_Enum_Empty& Expression_Enum::unspecified() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Enum.unspecified) - return _internal_unspecified(); -} -inline ::substrait::Expression_Enum_Empty* Expression_Enum::unsafe_arena_release_unspecified() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Enum.unspecified) - if (_internal_has_unspecified()) { - clear_has_enum_kind(); - ::substrait::Expression_Enum_Empty* temp = enum_kind_.unspecified_; - enum_kind_.unspecified_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Enum::unsafe_arena_set_allocated_unspecified(::substrait::Expression_Enum_Empty* unspecified) { - clear_enum_kind(); - if (unspecified) { - set_has_unspecified(); - enum_kind_.unspecified_ = unspecified; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Enum.unspecified) -} -inline ::substrait::Expression_Enum_Empty* Expression_Enum::_internal_mutable_unspecified() { - if (!_internal_has_unspecified()) { - clear_enum_kind(); - set_has_unspecified(); - enum_kind_.unspecified_ = CreateMaybeMessage< ::substrait::Expression_Enum_Empty >(GetArenaForAllocation()); - } - return enum_kind_.unspecified_; -} -inline ::substrait::Expression_Enum_Empty* Expression_Enum::mutable_unspecified() { - ::substrait::Expression_Enum_Empty* _msg = _internal_mutable_unspecified(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Enum.unspecified) - return _msg; -} - -inline bool Expression_Enum::has_enum_kind() const { - return enum_kind_case() != ENUM_KIND_NOT_SET; -} -inline void Expression_Enum::clear_has_enum_kind() { - _oneof_case_[0] = ENUM_KIND_NOT_SET; -} -inline Expression_Enum::EnumKindCase Expression_Enum::enum_kind_case() const { - return Expression_Enum::EnumKindCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Expression_Literal_VarChar - -// string value = 1; -inline void Expression_Literal_VarChar::clear_value() { - value_.ClearToEmpty(); -} -inline const std::string& Expression_Literal_VarChar::value() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.VarChar.value) - return _internal_value(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Expression_Literal_VarChar::set_value(ArgT0&& arg0, ArgT... args) { - - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.VarChar.value) -} -inline std::string* Expression_Literal_VarChar::mutable_value() { - std::string* _s = _internal_mutable_value(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.VarChar.value) - return _s; -} -inline const std::string& Expression_Literal_VarChar::_internal_value() const { - return value_.Get(); -} -inline void Expression_Literal_VarChar::_internal_set_value(const std::string& value) { - - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_Literal_VarChar::_internal_mutable_value() { - - return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_Literal_VarChar::release_value() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.VarChar.value) - return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void Expression_Literal_VarChar::set_allocated_value(std::string* value) { - if (value != nullptr) { - - } else { - - } - value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.VarChar.value) -} - -// uint32 length = 2; -inline void Expression_Literal_VarChar::clear_length() { - length_ = 0u; -} -inline uint32_t Expression_Literal_VarChar::_internal_length() const { - return length_; -} -inline uint32_t Expression_Literal_VarChar::length() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.VarChar.length) - return _internal_length(); -} -inline void Expression_Literal_VarChar::_internal_set_length(uint32_t value) { - - length_ = value; -} -inline void Expression_Literal_VarChar::set_length(uint32_t value) { - _internal_set_length(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.VarChar.length) -} - -// ------------------------------------------------------------------- - -// Expression_Literal_Decimal - -// bytes value = 1; -inline void Expression_Literal_Decimal::clear_value() { - value_.ClearToEmpty(); -} -inline const std::string& Expression_Literal_Decimal::value() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.value) - return _internal_value(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Expression_Literal_Decimal::set_value(ArgT0&& arg0, ArgT... args) { - - value_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.value) -} -inline std::string* Expression_Literal_Decimal::mutable_value() { - std::string* _s = _internal_mutable_value(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Decimal.value) - return _s; -} -inline const std::string& Expression_Literal_Decimal::_internal_value() const { - return value_.Get(); -} -inline void Expression_Literal_Decimal::_internal_set_value(const std::string& value) { - - value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_Literal_Decimal::_internal_mutable_value() { - - return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_Literal_Decimal::release_value() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.Decimal.value) - return value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void Expression_Literal_Decimal::set_allocated_value(std::string* value) { - if (value != nullptr) { - - } else { - - } - value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (value_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.Decimal.value) -} - -// int32 precision = 2; -inline void Expression_Literal_Decimal::clear_precision() { - precision_ = 0; -} -inline int32_t Expression_Literal_Decimal::_internal_precision() const { - return precision_; -} -inline int32_t Expression_Literal_Decimal::precision() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.precision) - return _internal_precision(); -} -inline void Expression_Literal_Decimal::_internal_set_precision(int32_t value) { - - precision_ = value; -} -inline void Expression_Literal_Decimal::set_precision(int32_t value) { - _internal_set_precision(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.precision) -} - -// int32 scale = 3; -inline void Expression_Literal_Decimal::clear_scale() { - scale_ = 0; -} -inline int32_t Expression_Literal_Decimal::_internal_scale() const { - return scale_; -} -inline int32_t Expression_Literal_Decimal::scale() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Decimal.scale) - return _internal_scale(); -} -inline void Expression_Literal_Decimal::_internal_set_scale(int32_t value) { - - scale_ = value; -} -inline void Expression_Literal_Decimal::set_scale(int32_t value) { - _internal_set_scale(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.Decimal.scale) -} - -// ------------------------------------------------------------------- - -// Expression_Literal_Map_KeyValue - -// .substrait.Expression.Literal key = 1; -inline bool Expression_Literal_Map_KeyValue::_internal_has_key() const { - return this != internal_default_instance() && key_ != nullptr; -} -inline bool Expression_Literal_Map_KeyValue::has_key() const { - return _internal_has_key(); -} -inline void Expression_Literal_Map_KeyValue::clear_key() { - if (GetArenaForAllocation() == nullptr && key_ != nullptr) { - delete key_; - } - key_ = nullptr; -} -inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_key() const { - const ::substrait::Expression_Literal* p = key_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_Literal_default_instance_); -} -inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::key() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Map.KeyValue.key) - return _internal_key(); -} -inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_key( - ::substrait::Expression_Literal* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); - } - key_ = key; - if (key) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.Map.KeyValue.key) -} -inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_key() { - - ::substrait::Expression_Literal* temp = key_; - key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.Map.KeyValue.key) - - ::substrait::Expression_Literal* temp = key_; - key_ = nullptr; - return temp; -} -inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_key() { - - if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation()); - key_ = p; - } - return key_; -} -inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_key() { - ::substrait::Expression_Literal* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.KeyValue.key) - return _msg; -} -inline void Expression_Literal_Map_KeyValue::set_allocated_key(::substrait::Expression_Literal* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - - } else { - - } - key_ = key; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.Map.KeyValue.key) -} - -// .substrait.Expression.Literal value = 2; -inline bool Expression_Literal_Map_KeyValue::_internal_has_value() const { - return this != internal_default_instance() && value_ != nullptr; -} -inline bool Expression_Literal_Map_KeyValue::has_value() const { - return _internal_has_value(); -} -inline void Expression_Literal_Map_KeyValue::clear_value() { - if (GetArenaForAllocation() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; -} -inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::_internal_value() const { - const ::substrait::Expression_Literal* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_Literal_default_instance_); -} -inline const ::substrait::Expression_Literal& Expression_Literal_Map_KeyValue::value() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Map.KeyValue.value) - return _internal_value(); -} -inline void Expression_Literal_Map_KeyValue::unsafe_arena_set_allocated_value( - ::substrait::Expression_Literal* value) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); - } - value_ = value; - if (value) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.Map.KeyValue.value) -} -inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::release_value() { - - ::substrait::Expression_Literal* temp = value_; - value_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.Map.KeyValue.value) - - ::substrait::Expression_Literal* temp = value_; - value_ = nullptr; - return temp; -} -inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::_internal_mutable_value() { - - if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation()); - value_ = p; - } - return value_; -} -inline ::substrait::Expression_Literal* Expression_Literal_Map_KeyValue::mutable_value() { - ::substrait::Expression_Literal* _msg = _internal_mutable_value(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.KeyValue.value) - return _msg; -} -inline void Expression_Literal_Map_KeyValue::set_allocated_value(::substrait::Expression_Literal* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete value_; - } - if (value) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(value); - if (message_arena != submessage_arena) { - value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value, submessage_arena); - } - - } else { - - } - value_ = value; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.Map.KeyValue.value) -} - -// ------------------------------------------------------------------- - -// Expression_Literal_Map - -// repeated .substrait.Expression.Literal.Map.KeyValue key_values = 1; -inline int Expression_Literal_Map::_internal_key_values_size() const { - return key_values_.size(); -} -inline int Expression_Literal_Map::key_values_size() const { - return _internal_key_values_size(); -} -inline void Expression_Literal_Map::clear_key_values() { - key_values_.Clear(); -} -inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::mutable_key_values(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Map.key_values) - return key_values_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >* -Expression_Literal_Map::mutable_key_values() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.Literal.Map.key_values) - return &key_values_; -} -inline const ::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::_internal_key_values(int index) const { - return key_values_.Get(index); -} -inline const ::substrait::Expression_Literal_Map_KeyValue& Expression_Literal_Map::key_values(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Map.key_values) - return _internal_key_values(index); -} -inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::_internal_add_key_values() { - return key_values_.Add(); -} -inline ::substrait::Expression_Literal_Map_KeyValue* Expression_Literal_Map::add_key_values() { - ::substrait::Expression_Literal_Map_KeyValue* _add = _internal_add_key_values(); - // @@protoc_insertion_point(field_add:substrait.Expression.Literal.Map.key_values) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Map_KeyValue >& -Expression_Literal_Map::key_values() const { - // @@protoc_insertion_point(field_list:substrait.Expression.Literal.Map.key_values) - return key_values_; -} - -// ------------------------------------------------------------------- - -// Expression_Literal_IntervalYearToMonth - -// int32 years = 1; -inline void Expression_Literal_IntervalYearToMonth::clear_years() { - years_ = 0; -} -inline int32_t Expression_Literal_IntervalYearToMonth::_internal_years() const { - return years_; -} -inline int32_t Expression_Literal_IntervalYearToMonth::years() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalYearToMonth.years) - return _internal_years(); -} -inline void Expression_Literal_IntervalYearToMonth::_internal_set_years(int32_t value) { - - years_ = value; -} -inline void Expression_Literal_IntervalYearToMonth::set_years(int32_t value) { - _internal_set_years(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalYearToMonth.years) -} - -// int32 months = 2; -inline void Expression_Literal_IntervalYearToMonth::clear_months() { - months_ = 0; -} -inline int32_t Expression_Literal_IntervalYearToMonth::_internal_months() const { - return months_; -} -inline int32_t Expression_Literal_IntervalYearToMonth::months() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalYearToMonth.months) - return _internal_months(); -} -inline void Expression_Literal_IntervalYearToMonth::_internal_set_months(int32_t value) { - - months_ = value; -} -inline void Expression_Literal_IntervalYearToMonth::set_months(int32_t value) { - _internal_set_months(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalYearToMonth.months) -} - -// ------------------------------------------------------------------- - -// Expression_Literal_IntervalDayToSecond - -// int32 days = 1; -inline void Expression_Literal_IntervalDayToSecond::clear_days() { - days_ = 0; -} -inline int32_t Expression_Literal_IntervalDayToSecond::_internal_days() const { - return days_; -} -inline int32_t Expression_Literal_IntervalDayToSecond::days() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalDayToSecond.days) - return _internal_days(); -} -inline void Expression_Literal_IntervalDayToSecond::_internal_set_days(int32_t value) { - - days_ = value; -} -inline void Expression_Literal_IntervalDayToSecond::set_days(int32_t value) { - _internal_set_days(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalDayToSecond.days) -} - -// int32 seconds = 2; -inline void Expression_Literal_IntervalDayToSecond::clear_seconds() { - seconds_ = 0; -} -inline int32_t Expression_Literal_IntervalDayToSecond::_internal_seconds() const { - return seconds_; -} -inline int32_t Expression_Literal_IntervalDayToSecond::seconds() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.IntervalDayToSecond.seconds) - return _internal_seconds(); -} -inline void Expression_Literal_IntervalDayToSecond::_internal_set_seconds(int32_t value) { - - seconds_ = value; -} -inline void Expression_Literal_IntervalDayToSecond::set_seconds(int32_t value) { - _internal_set_seconds(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.IntervalDayToSecond.seconds) -} - -// ------------------------------------------------------------------- - -// Expression_Literal_Struct - -// repeated .substrait.Expression.Literal fields = 1; -inline int Expression_Literal_Struct::_internal_fields_size() const { - return fields_.size(); -} -inline int Expression_Literal_Struct::fields_size() const { - return _internal_fields_size(); -} -inline void Expression_Literal_Struct::clear_fields() { - fields_.Clear(); -} -inline ::substrait::Expression_Literal* Expression_Literal_Struct::mutable_fields(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.Struct.fields) - return fields_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >* -Expression_Literal_Struct::mutable_fields() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.Literal.Struct.fields) - return &fields_; -} -inline const ::substrait::Expression_Literal& Expression_Literal_Struct::_internal_fields(int index) const { - return fields_.Get(index); -} -inline const ::substrait::Expression_Literal& Expression_Literal_Struct::fields(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.Struct.fields) - return _internal_fields(index); -} -inline ::substrait::Expression_Literal* Expression_Literal_Struct::_internal_add_fields() { - return fields_.Add(); -} -inline ::substrait::Expression_Literal* Expression_Literal_Struct::add_fields() { - ::substrait::Expression_Literal* _add = _internal_add_fields(); - // @@protoc_insertion_point(field_add:substrait.Expression.Literal.Struct.fields) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >& -Expression_Literal_Struct::fields() const { - // @@protoc_insertion_point(field_list:substrait.Expression.Literal.Struct.fields) - return fields_; -} - -// ------------------------------------------------------------------- - -// Expression_Literal_List - -// repeated .substrait.Expression.Literal values = 1; -inline int Expression_Literal_List::_internal_values_size() const { - return values_.size(); -} -inline int Expression_Literal_List::values_size() const { - return _internal_values_size(); -} -inline void Expression_Literal_List::clear_values() { - values_.Clear(); -} -inline ::substrait::Expression_Literal* Expression_Literal_List::mutable_values(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.List.values) - return values_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >* -Expression_Literal_List::mutable_values() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.Literal.List.values) - return &values_; -} -inline const ::substrait::Expression_Literal& Expression_Literal_List::_internal_values(int index) const { - return values_.Get(index); -} -inline const ::substrait::Expression_Literal& Expression_Literal_List::values(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.List.values) - return _internal_values(index); -} -inline ::substrait::Expression_Literal* Expression_Literal_List::_internal_add_values() { - return values_.Add(); -} -inline ::substrait::Expression_Literal* Expression_Literal_List::add_values() { - ::substrait::Expression_Literal* _add = _internal_add_values(); - // @@protoc_insertion_point(field_add:substrait.Expression.Literal.List.values) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal >& -Expression_Literal_List::values() const { - // @@protoc_insertion_point(field_list:substrait.Expression.Literal.List.values) - return values_; -} - -// ------------------------------------------------------------------- - -// Expression_Literal - -// bool boolean = 1; -inline bool Expression_Literal::_internal_has_boolean() const { - return literal_type_case() == kBoolean; -} -inline bool Expression_Literal::has_boolean() const { - return _internal_has_boolean(); -} -inline void Expression_Literal::set_has_boolean() { - _oneof_case_[0] = kBoolean; -} -inline void Expression_Literal::clear_boolean() { - if (_internal_has_boolean()) { - literal_type_.boolean_ = false; - clear_has_literal_type(); - } -} -inline bool Expression_Literal::_internal_boolean() const { - if (_internal_has_boolean()) { - return literal_type_.boolean_; - } - return false; -} -inline void Expression_Literal::_internal_set_boolean(bool value) { - if (!_internal_has_boolean()) { - clear_literal_type(); - set_has_boolean(); - } - literal_type_.boolean_ = value; -} -inline bool Expression_Literal::boolean() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.boolean) - return _internal_boolean(); -} -inline void Expression_Literal::set_boolean(bool value) { - _internal_set_boolean(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.boolean) -} - -// int32 i8 = 2; -inline bool Expression_Literal::_internal_has_i8() const { - return literal_type_case() == kI8; -} -inline bool Expression_Literal::has_i8() const { - return _internal_has_i8(); -} -inline void Expression_Literal::set_has_i8() { - _oneof_case_[0] = kI8; -} -inline void Expression_Literal::clear_i8() { - if (_internal_has_i8()) { - literal_type_.i8_ = 0; - clear_has_literal_type(); - } -} -inline int32_t Expression_Literal::_internal_i8() const { - if (_internal_has_i8()) { - return literal_type_.i8_; - } - return 0; -} -inline void Expression_Literal::_internal_set_i8(int32_t value) { - if (!_internal_has_i8()) { - clear_literal_type(); - set_has_i8(); - } - literal_type_.i8_ = value; -} -inline int32_t Expression_Literal::i8() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i8) - return _internal_i8(); -} -inline void Expression_Literal::set_i8(int32_t value) { - _internal_set_i8(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i8) -} - -// int32 i16 = 3; -inline bool Expression_Literal::_internal_has_i16() const { - return literal_type_case() == kI16; -} -inline bool Expression_Literal::has_i16() const { - return _internal_has_i16(); -} -inline void Expression_Literal::set_has_i16() { - _oneof_case_[0] = kI16; -} -inline void Expression_Literal::clear_i16() { - if (_internal_has_i16()) { - literal_type_.i16_ = 0; - clear_has_literal_type(); - } -} -inline int32_t Expression_Literal::_internal_i16() const { - if (_internal_has_i16()) { - return literal_type_.i16_; - } - return 0; -} -inline void Expression_Literal::_internal_set_i16(int32_t value) { - if (!_internal_has_i16()) { - clear_literal_type(); - set_has_i16(); - } - literal_type_.i16_ = value; -} -inline int32_t Expression_Literal::i16() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i16) - return _internal_i16(); -} -inline void Expression_Literal::set_i16(int32_t value) { - _internal_set_i16(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i16) -} - -// int32 i32 = 5; -inline bool Expression_Literal::_internal_has_i32() const { - return literal_type_case() == kI32; -} -inline bool Expression_Literal::has_i32() const { - return _internal_has_i32(); -} -inline void Expression_Literal::set_has_i32() { - _oneof_case_[0] = kI32; -} -inline void Expression_Literal::clear_i32() { - if (_internal_has_i32()) { - literal_type_.i32_ = 0; - clear_has_literal_type(); - } -} -inline int32_t Expression_Literal::_internal_i32() const { - if (_internal_has_i32()) { - return literal_type_.i32_; - } - return 0; -} -inline void Expression_Literal::_internal_set_i32(int32_t value) { - if (!_internal_has_i32()) { - clear_literal_type(); - set_has_i32(); - } - literal_type_.i32_ = value; -} -inline int32_t Expression_Literal::i32() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i32) - return _internal_i32(); -} -inline void Expression_Literal::set_i32(int32_t value) { - _internal_set_i32(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i32) -} - -// int64 i64 = 7; -inline bool Expression_Literal::_internal_has_i64() const { - return literal_type_case() == kI64; -} -inline bool Expression_Literal::has_i64() const { - return _internal_has_i64(); -} -inline void Expression_Literal::set_has_i64() { - _oneof_case_[0] = kI64; -} -inline void Expression_Literal::clear_i64() { - if (_internal_has_i64()) { - literal_type_.i64_ = int64_t{0}; - clear_has_literal_type(); - } -} -inline int64_t Expression_Literal::_internal_i64() const { - if (_internal_has_i64()) { - return literal_type_.i64_; - } - return int64_t{0}; -} -inline void Expression_Literal::_internal_set_i64(int64_t value) { - if (!_internal_has_i64()) { - clear_literal_type(); - set_has_i64(); - } - literal_type_.i64_ = value; -} -inline int64_t Expression_Literal::i64() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.i64) - return _internal_i64(); -} -inline void Expression_Literal::set_i64(int64_t value) { - _internal_set_i64(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.i64) -} - -// float fp32 = 10; -inline bool Expression_Literal::_internal_has_fp32() const { - return literal_type_case() == kFp32; -} -inline bool Expression_Literal::has_fp32() const { - return _internal_has_fp32(); -} -inline void Expression_Literal::set_has_fp32() { - _oneof_case_[0] = kFp32; -} -inline void Expression_Literal::clear_fp32() { - if (_internal_has_fp32()) { - literal_type_.fp32_ = 0; - clear_has_literal_type(); - } -} -inline float Expression_Literal::_internal_fp32() const { - if (_internal_has_fp32()) { - return literal_type_.fp32_; - } - return 0; -} -inline void Expression_Literal::_internal_set_fp32(float value) { - if (!_internal_has_fp32()) { - clear_literal_type(); - set_has_fp32(); - } - literal_type_.fp32_ = value; -} -inline float Expression_Literal::fp32() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fp32) - return _internal_fp32(); -} -inline void Expression_Literal::set_fp32(float value) { - _internal_set_fp32(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fp32) -} - -// double fp64 = 11; -inline bool Expression_Literal::_internal_has_fp64() const { - return literal_type_case() == kFp64; -} -inline bool Expression_Literal::has_fp64() const { - return _internal_has_fp64(); -} -inline void Expression_Literal::set_has_fp64() { - _oneof_case_[0] = kFp64; -} -inline void Expression_Literal::clear_fp64() { - if (_internal_has_fp64()) { - literal_type_.fp64_ = 0; - clear_has_literal_type(); - } -} -inline double Expression_Literal::_internal_fp64() const { - if (_internal_has_fp64()) { - return literal_type_.fp64_; - } - return 0; -} -inline void Expression_Literal::_internal_set_fp64(double value) { - if (!_internal_has_fp64()) { - clear_literal_type(); - set_has_fp64(); - } - literal_type_.fp64_ = value; -} -inline double Expression_Literal::fp64() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fp64) - return _internal_fp64(); -} -inline void Expression_Literal::set_fp64(double value) { - _internal_set_fp64(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fp64) -} - -// string string = 12; -inline bool Expression_Literal::_internal_has_string() const { - return literal_type_case() == kString; -} -inline bool Expression_Literal::has_string() const { - return _internal_has_string(); -} -inline void Expression_Literal::set_has_string() { - _oneof_case_[0] = kString; -} -inline void Expression_Literal::clear_string() { - if (_internal_has_string()) { - literal_type_.string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_literal_type(); - } -} -inline const std::string& Expression_Literal::string() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.string) - return _internal_string(); -} -template -inline void Expression_Literal::set_string(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_string()) { - clear_literal_type(); - set_has_string(); - literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.string) -} -inline std::string* Expression_Literal::mutable_string() { - std::string* _s = _internal_mutable_string(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.string) - return _s; -} -inline const std::string& Expression_Literal::_internal_string() const { - if (_internal_has_string()) { - return literal_type_.string_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Expression_Literal::_internal_set_string(const std::string& value) { - if (!_internal_has_string()) { - clear_literal_type(); - set_has_string(); - literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_Literal::_internal_mutable_string() { - if (!_internal_has_string()) { - clear_literal_type(); - set_has_string(); - literal_type_.string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return literal_type_.string_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_Literal::release_string() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.string) - if (_internal_has_string()) { - clear_has_literal_type(); - return literal_type_.string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void Expression_Literal::set_allocated_string(std::string* string) { - if (has_literal_type()) { - clear_literal_type(); - } - if (string != nullptr) { - set_has_string(); - literal_type_.string_.UnsafeSetDefault(string); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(string); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.string) -} - -// bytes binary = 13; -inline bool Expression_Literal::_internal_has_binary() const { - return literal_type_case() == kBinary; -} -inline bool Expression_Literal::has_binary() const { - return _internal_has_binary(); -} -inline void Expression_Literal::set_has_binary() { - _oneof_case_[0] = kBinary; -} -inline void Expression_Literal::clear_binary() { - if (_internal_has_binary()) { - literal_type_.binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_literal_type(); - } -} -inline const std::string& Expression_Literal::binary() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.binary) - return _internal_binary(); -} -template -inline void Expression_Literal::set_binary(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_binary()) { - clear_literal_type(); - set_has_binary(); - literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.binary) -} -inline std::string* Expression_Literal::mutable_binary() { - std::string* _s = _internal_mutable_binary(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.binary) - return _s; -} -inline const std::string& Expression_Literal::_internal_binary() const { - if (_internal_has_binary()) { - return literal_type_.binary_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Expression_Literal::_internal_set_binary(const std::string& value) { - if (!_internal_has_binary()) { - clear_literal_type(); - set_has_binary(); - literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_Literal::_internal_mutable_binary() { - if (!_internal_has_binary()) { - clear_literal_type(); - set_has_binary(); - literal_type_.binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return literal_type_.binary_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_Literal::release_binary() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.binary) - if (_internal_has_binary()) { - clear_has_literal_type(); - return literal_type_.binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void Expression_Literal::set_allocated_binary(std::string* binary) { - if (has_literal_type()) { - clear_literal_type(); - } - if (binary != nullptr) { - set_has_binary(); - literal_type_.binary_.UnsafeSetDefault(binary); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(binary); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.binary) -} - -// int64 timestamp = 14; -inline bool Expression_Literal::_internal_has_timestamp() const { - return literal_type_case() == kTimestamp; -} -inline bool Expression_Literal::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void Expression_Literal::set_has_timestamp() { - _oneof_case_[0] = kTimestamp; -} -inline void Expression_Literal::clear_timestamp() { - if (_internal_has_timestamp()) { - literal_type_.timestamp_ = int64_t{0}; - clear_has_literal_type(); - } -} -inline int64_t Expression_Literal::_internal_timestamp() const { - if (_internal_has_timestamp()) { - return literal_type_.timestamp_; - } - return int64_t{0}; -} -inline void Expression_Literal::_internal_set_timestamp(int64_t value) { - if (!_internal_has_timestamp()) { - clear_literal_type(); - set_has_timestamp(); - } - literal_type_.timestamp_ = value; -} -inline int64_t Expression_Literal::timestamp() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.timestamp) - return _internal_timestamp(); -} -inline void Expression_Literal::set_timestamp(int64_t value) { - _internal_set_timestamp(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.timestamp) -} - -// int32 date = 16; -inline bool Expression_Literal::_internal_has_date() const { - return literal_type_case() == kDate; -} -inline bool Expression_Literal::has_date() const { - return _internal_has_date(); -} -inline void Expression_Literal::set_has_date() { - _oneof_case_[0] = kDate; -} -inline void Expression_Literal::clear_date() { - if (_internal_has_date()) { - literal_type_.date_ = 0; - clear_has_literal_type(); - } -} -inline int32_t Expression_Literal::_internal_date() const { - if (_internal_has_date()) { - return literal_type_.date_; - } - return 0; -} -inline void Expression_Literal::_internal_set_date(int32_t value) { - if (!_internal_has_date()) { - clear_literal_type(); - set_has_date(); - } - literal_type_.date_ = value; -} -inline int32_t Expression_Literal::date() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.date) - return _internal_date(); -} -inline void Expression_Literal::set_date(int32_t value) { - _internal_set_date(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.date) -} - -// int64 time = 17; -inline bool Expression_Literal::_internal_has_time() const { - return literal_type_case() == kTime; -} -inline bool Expression_Literal::has_time() const { - return _internal_has_time(); -} -inline void Expression_Literal::set_has_time() { - _oneof_case_[0] = kTime; -} -inline void Expression_Literal::clear_time() { - if (_internal_has_time()) { - literal_type_.time_ = int64_t{0}; - clear_has_literal_type(); - } -} -inline int64_t Expression_Literal::_internal_time() const { - if (_internal_has_time()) { - return literal_type_.time_; - } - return int64_t{0}; -} -inline void Expression_Literal::_internal_set_time(int64_t value) { - if (!_internal_has_time()) { - clear_literal_type(); - set_has_time(); - } - literal_type_.time_ = value; -} -inline int64_t Expression_Literal::time() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.time) - return _internal_time(); -} -inline void Expression_Literal::set_time(int64_t value) { - _internal_set_time(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.time) -} - -// .substrait.Expression.Literal.IntervalYearToMonth interval_year_to_month = 19; -inline bool Expression_Literal::_internal_has_interval_year_to_month() const { - return literal_type_case() == kIntervalYearToMonth; -} -inline bool Expression_Literal::has_interval_year_to_month() const { - return _internal_has_interval_year_to_month(); -} -inline void Expression_Literal::set_has_interval_year_to_month() { - _oneof_case_[0] = kIntervalYearToMonth; -} -inline void Expression_Literal::clear_interval_year_to_month() { - if (_internal_has_interval_year_to_month()) { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.interval_year_to_month_; - } - clear_has_literal_type(); - } -} -inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::release_interval_year_to_month() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.interval_year_to_month) - if (_internal_has_interval_year_to_month()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.interval_year_to_month_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::_internal_interval_year_to_month() const { - return _internal_has_interval_year_to_month() - ? *literal_type_.interval_year_to_month_ - : reinterpret_cast< ::substrait::Expression_Literal_IntervalYearToMonth&>(::substrait::_Expression_Literal_IntervalYearToMonth_default_instance_); -} -inline const ::substrait::Expression_Literal_IntervalYearToMonth& Expression_Literal::interval_year_to_month() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.interval_year_to_month) - return _internal_interval_year_to_month(); -} -inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::unsafe_arena_release_interval_year_to_month() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.interval_year_to_month) - if (_internal_has_interval_year_to_month()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_IntervalYearToMonth* temp = literal_type_.interval_year_to_month_; - literal_type_.interval_year_to_month_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Literal::unsafe_arena_set_allocated_interval_year_to_month(::substrait::Expression_Literal_IntervalYearToMonth* interval_year_to_month) { - clear_literal_type(); - if (interval_year_to_month) { - set_has_interval_year_to_month(); - literal_type_.interval_year_to_month_ = interval_year_to_month; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.interval_year_to_month) -} -inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::_internal_mutable_interval_year_to_month() { - if (!_internal_has_interval_year_to_month()) { - clear_literal_type(); - set_has_interval_year_to_month(); - literal_type_.interval_year_to_month_ = CreateMaybeMessage< ::substrait::Expression_Literal_IntervalYearToMonth >(GetArenaForAllocation()); - } - return literal_type_.interval_year_to_month_; -} -inline ::substrait::Expression_Literal_IntervalYearToMonth* Expression_Literal::mutable_interval_year_to_month() { - ::substrait::Expression_Literal_IntervalYearToMonth* _msg = _internal_mutable_interval_year_to_month(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.interval_year_to_month) - return _msg; -} - -// .substrait.Expression.Literal.IntervalDayToSecond interval_day_to_second = 20; -inline bool Expression_Literal::_internal_has_interval_day_to_second() const { - return literal_type_case() == kIntervalDayToSecond; -} -inline bool Expression_Literal::has_interval_day_to_second() const { - return _internal_has_interval_day_to_second(); -} -inline void Expression_Literal::set_has_interval_day_to_second() { - _oneof_case_[0] = kIntervalDayToSecond; -} -inline void Expression_Literal::clear_interval_day_to_second() { - if (_internal_has_interval_day_to_second()) { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.interval_day_to_second_; - } - clear_has_literal_type(); - } -} -inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::release_interval_day_to_second() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.interval_day_to_second) - if (_internal_has_interval_day_to_second()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.interval_day_to_second_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::_internal_interval_day_to_second() const { - return _internal_has_interval_day_to_second() - ? *literal_type_.interval_day_to_second_ - : reinterpret_cast< ::substrait::Expression_Literal_IntervalDayToSecond&>(::substrait::_Expression_Literal_IntervalDayToSecond_default_instance_); -} -inline const ::substrait::Expression_Literal_IntervalDayToSecond& Expression_Literal::interval_day_to_second() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.interval_day_to_second) - return _internal_interval_day_to_second(); -} -inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::unsafe_arena_release_interval_day_to_second() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.interval_day_to_second) - if (_internal_has_interval_day_to_second()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_IntervalDayToSecond* temp = literal_type_.interval_day_to_second_; - literal_type_.interval_day_to_second_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Literal::unsafe_arena_set_allocated_interval_day_to_second(::substrait::Expression_Literal_IntervalDayToSecond* interval_day_to_second) { - clear_literal_type(); - if (interval_day_to_second) { - set_has_interval_day_to_second(); - literal_type_.interval_day_to_second_ = interval_day_to_second; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.interval_day_to_second) -} -inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::_internal_mutable_interval_day_to_second() { - if (!_internal_has_interval_day_to_second()) { - clear_literal_type(); - set_has_interval_day_to_second(); - literal_type_.interval_day_to_second_ = CreateMaybeMessage< ::substrait::Expression_Literal_IntervalDayToSecond >(GetArenaForAllocation()); - } - return literal_type_.interval_day_to_second_; -} -inline ::substrait::Expression_Literal_IntervalDayToSecond* Expression_Literal::mutable_interval_day_to_second() { - ::substrait::Expression_Literal_IntervalDayToSecond* _msg = _internal_mutable_interval_day_to_second(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.interval_day_to_second) - return _msg; -} - -// string fixed_char = 21; -inline bool Expression_Literal::_internal_has_fixed_char() const { - return literal_type_case() == kFixedChar; -} -inline bool Expression_Literal::has_fixed_char() const { - return _internal_has_fixed_char(); -} -inline void Expression_Literal::set_has_fixed_char() { - _oneof_case_[0] = kFixedChar; -} -inline void Expression_Literal::clear_fixed_char() { - if (_internal_has_fixed_char()) { - literal_type_.fixed_char_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_literal_type(); - } -} -inline const std::string& Expression_Literal::fixed_char() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fixed_char) - return _internal_fixed_char(); -} -template -inline void Expression_Literal::set_fixed_char(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_fixed_char()) { - clear_literal_type(); - set_has_fixed_char(); - literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fixed_char) -} -inline std::string* Expression_Literal::mutable_fixed_char() { - std::string* _s = _internal_mutable_fixed_char(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.fixed_char) - return _s; -} -inline const std::string& Expression_Literal::_internal_fixed_char() const { - if (_internal_has_fixed_char()) { - return literal_type_.fixed_char_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Expression_Literal::_internal_set_fixed_char(const std::string& value) { - if (!_internal_has_fixed_char()) { - clear_literal_type(); - set_has_fixed_char(); - literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.fixed_char_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_Literal::_internal_mutable_fixed_char() { - if (!_internal_has_fixed_char()) { - clear_literal_type(); - set_has_fixed_char(); - literal_type_.fixed_char_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return literal_type_.fixed_char_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_Literal::release_fixed_char() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.fixed_char) - if (_internal_has_fixed_char()) { - clear_has_literal_type(); - return literal_type_.fixed_char_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void Expression_Literal::set_allocated_fixed_char(std::string* fixed_char) { - if (has_literal_type()) { - clear_literal_type(); - } - if (fixed_char != nullptr) { - set_has_fixed_char(); - literal_type_.fixed_char_.UnsafeSetDefault(fixed_char); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(fixed_char); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.fixed_char) -} - -// .substrait.Expression.Literal.VarChar var_char = 22; -inline bool Expression_Literal::_internal_has_var_char() const { - return literal_type_case() == kVarChar; -} -inline bool Expression_Literal::has_var_char() const { - return _internal_has_var_char(); -} -inline void Expression_Literal::set_has_var_char() { - _oneof_case_[0] = kVarChar; -} -inline void Expression_Literal::clear_var_char() { - if (_internal_has_var_char()) { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.var_char_; - } - clear_has_literal_type(); - } -} -inline ::substrait::Expression_Literal_VarChar* Expression_Literal::release_var_char() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.var_char) - if (_internal_has_var_char()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.var_char_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Literal_VarChar& Expression_Literal::_internal_var_char() const { - return _internal_has_var_char() - ? *literal_type_.var_char_ - : reinterpret_cast< ::substrait::Expression_Literal_VarChar&>(::substrait::_Expression_Literal_VarChar_default_instance_); -} -inline const ::substrait::Expression_Literal_VarChar& Expression_Literal::var_char() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.var_char) - return _internal_var_char(); -} -inline ::substrait::Expression_Literal_VarChar* Expression_Literal::unsafe_arena_release_var_char() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.var_char) - if (_internal_has_var_char()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_VarChar* temp = literal_type_.var_char_; - literal_type_.var_char_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Literal::unsafe_arena_set_allocated_var_char(::substrait::Expression_Literal_VarChar* var_char) { - clear_literal_type(); - if (var_char) { - set_has_var_char(); - literal_type_.var_char_ = var_char; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.var_char) -} -inline ::substrait::Expression_Literal_VarChar* Expression_Literal::_internal_mutable_var_char() { - if (!_internal_has_var_char()) { - clear_literal_type(); - set_has_var_char(); - literal_type_.var_char_ = CreateMaybeMessage< ::substrait::Expression_Literal_VarChar >(GetArenaForAllocation()); - } - return literal_type_.var_char_; -} -inline ::substrait::Expression_Literal_VarChar* Expression_Literal::mutable_var_char() { - ::substrait::Expression_Literal_VarChar* _msg = _internal_mutable_var_char(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.var_char) - return _msg; -} - -// bytes fixed_binary = 23; -inline bool Expression_Literal::_internal_has_fixed_binary() const { - return literal_type_case() == kFixedBinary; -} -inline bool Expression_Literal::has_fixed_binary() const { - return _internal_has_fixed_binary(); -} -inline void Expression_Literal::set_has_fixed_binary() { - _oneof_case_[0] = kFixedBinary; -} -inline void Expression_Literal::clear_fixed_binary() { - if (_internal_has_fixed_binary()) { - literal_type_.fixed_binary_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_literal_type(); - } -} -inline const std::string& Expression_Literal::fixed_binary() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.fixed_binary) - return _internal_fixed_binary(); -} -template -inline void Expression_Literal::set_fixed_binary(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_fixed_binary()) { - clear_literal_type(); - set_has_fixed_binary(); - literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.fixed_binary_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.fixed_binary) -} -inline std::string* Expression_Literal::mutable_fixed_binary() { - std::string* _s = _internal_mutable_fixed_binary(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.fixed_binary) - return _s; -} -inline const std::string& Expression_Literal::_internal_fixed_binary() const { - if (_internal_has_fixed_binary()) { - return literal_type_.fixed_binary_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Expression_Literal::_internal_set_fixed_binary(const std::string& value) { - if (!_internal_has_fixed_binary()) { - clear_literal_type(); - set_has_fixed_binary(); - literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.fixed_binary_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_Literal::_internal_mutable_fixed_binary() { - if (!_internal_has_fixed_binary()) { - clear_literal_type(); - set_has_fixed_binary(); - literal_type_.fixed_binary_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return literal_type_.fixed_binary_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_Literal::release_fixed_binary() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.fixed_binary) - if (_internal_has_fixed_binary()) { - clear_has_literal_type(); - return literal_type_.fixed_binary_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void Expression_Literal::set_allocated_fixed_binary(std::string* fixed_binary) { - if (has_literal_type()) { - clear_literal_type(); - } - if (fixed_binary != nullptr) { - set_has_fixed_binary(); - literal_type_.fixed_binary_.UnsafeSetDefault(fixed_binary); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(fixed_binary); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.fixed_binary) -} - -// .substrait.Expression.Literal.Decimal decimal = 24; -inline bool Expression_Literal::_internal_has_decimal() const { - return literal_type_case() == kDecimal; -} -inline bool Expression_Literal::has_decimal() const { - return _internal_has_decimal(); -} -inline void Expression_Literal::set_has_decimal() { - _oneof_case_[0] = kDecimal; -} -inline void Expression_Literal::clear_decimal() { - if (_internal_has_decimal()) { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.decimal_; - } - clear_has_literal_type(); - } -} -inline ::substrait::Expression_Literal_Decimal* Expression_Literal::release_decimal() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.decimal) - if (_internal_has_decimal()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.decimal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Literal_Decimal& Expression_Literal::_internal_decimal() const { - return _internal_has_decimal() - ? *literal_type_.decimal_ - : reinterpret_cast< ::substrait::Expression_Literal_Decimal&>(::substrait::_Expression_Literal_Decimal_default_instance_); -} -inline const ::substrait::Expression_Literal_Decimal& Expression_Literal::decimal() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.decimal) - return _internal_decimal(); -} -inline ::substrait::Expression_Literal_Decimal* Expression_Literal::unsafe_arena_release_decimal() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.decimal) - if (_internal_has_decimal()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_Decimal* temp = literal_type_.decimal_; - literal_type_.decimal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Literal::unsafe_arena_set_allocated_decimal(::substrait::Expression_Literal_Decimal* decimal) { - clear_literal_type(); - if (decimal) { - set_has_decimal(); - literal_type_.decimal_ = decimal; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.decimal) -} -inline ::substrait::Expression_Literal_Decimal* Expression_Literal::_internal_mutable_decimal() { - if (!_internal_has_decimal()) { - clear_literal_type(); - set_has_decimal(); - literal_type_.decimal_ = CreateMaybeMessage< ::substrait::Expression_Literal_Decimal >(GetArenaForAllocation()); - } - return literal_type_.decimal_; -} -inline ::substrait::Expression_Literal_Decimal* Expression_Literal::mutable_decimal() { - ::substrait::Expression_Literal_Decimal* _msg = _internal_mutable_decimal(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.decimal) - return _msg; -} - -// .substrait.Expression.Literal.Struct struct = 25; -inline bool Expression_Literal::_internal_has_struct_() const { - return literal_type_case() == kStruct; -} -inline bool Expression_Literal::has_struct_() const { - return _internal_has_struct_(); -} -inline void Expression_Literal::set_has_struct_() { - _oneof_case_[0] = kStruct; -} -inline void Expression_Literal::clear_struct_() { - if (_internal_has_struct_()) { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.struct__; - } - clear_has_literal_type(); - } -} -inline ::substrait::Expression_Literal_Struct* Expression_Literal::release_struct_() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.struct) - if (_internal_has_struct_()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Literal_Struct& Expression_Literal::_internal_struct_() const { - return _internal_has_struct_() - ? *literal_type_.struct__ - : reinterpret_cast< ::substrait::Expression_Literal_Struct&>(::substrait::_Expression_Literal_Struct_default_instance_); -} -inline const ::substrait::Expression_Literal_Struct& Expression_Literal::struct_() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.struct) - return _internal_struct_(); -} -inline ::substrait::Expression_Literal_Struct* Expression_Literal::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.struct) - if (_internal_has_struct_()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_Struct* temp = literal_type_.struct__; - literal_type_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Literal::unsafe_arena_set_allocated_struct_(::substrait::Expression_Literal_Struct* struct_) { - clear_literal_type(); - if (struct_) { - set_has_struct_(); - literal_type_.struct__ = struct_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.struct) -} -inline ::substrait::Expression_Literal_Struct* Expression_Literal::_internal_mutable_struct_() { - if (!_internal_has_struct_()) { - clear_literal_type(); - set_has_struct_(); - literal_type_.struct__ = CreateMaybeMessage< ::substrait::Expression_Literal_Struct >(GetArenaForAllocation()); - } - return literal_type_.struct__; -} -inline ::substrait::Expression_Literal_Struct* Expression_Literal::mutable_struct_() { - ::substrait::Expression_Literal_Struct* _msg = _internal_mutable_struct_(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.struct) - return _msg; -} - -// .substrait.Expression.Literal.Map map = 26; -inline bool Expression_Literal::_internal_has_map() const { - return literal_type_case() == kMap; -} -inline bool Expression_Literal::has_map() const { - return _internal_has_map(); -} -inline void Expression_Literal::set_has_map() { - _oneof_case_[0] = kMap; -} -inline void Expression_Literal::clear_map() { - if (_internal_has_map()) { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.map_; - } - clear_has_literal_type(); - } -} -inline ::substrait::Expression_Literal_Map* Expression_Literal::release_map() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.map) - if (_internal_has_map()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_Map* temp = literal_type_.map_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Literal_Map& Expression_Literal::_internal_map() const { - return _internal_has_map() - ? *literal_type_.map_ - : reinterpret_cast< ::substrait::Expression_Literal_Map&>(::substrait::_Expression_Literal_Map_default_instance_); -} -inline const ::substrait::Expression_Literal_Map& Expression_Literal::map() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.map) - return _internal_map(); -} -inline ::substrait::Expression_Literal_Map* Expression_Literal::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.map) - if (_internal_has_map()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_Map* temp = literal_type_.map_; - literal_type_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Literal::unsafe_arena_set_allocated_map(::substrait::Expression_Literal_Map* map) { - clear_literal_type(); - if (map) { - set_has_map(); - literal_type_.map_ = map; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.map) -} -inline ::substrait::Expression_Literal_Map* Expression_Literal::_internal_mutable_map() { - if (!_internal_has_map()) { - clear_literal_type(); - set_has_map(); - literal_type_.map_ = CreateMaybeMessage< ::substrait::Expression_Literal_Map >(GetArenaForAllocation()); - } - return literal_type_.map_; -} -inline ::substrait::Expression_Literal_Map* Expression_Literal::mutable_map() { - ::substrait::Expression_Literal_Map* _msg = _internal_mutable_map(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.map) - return _msg; -} - -// int64 timestamp_tz = 27; -inline bool Expression_Literal::_internal_has_timestamp_tz() const { - return literal_type_case() == kTimestampTz; -} -inline bool Expression_Literal::has_timestamp_tz() const { - return _internal_has_timestamp_tz(); -} -inline void Expression_Literal::set_has_timestamp_tz() { - _oneof_case_[0] = kTimestampTz; -} -inline void Expression_Literal::clear_timestamp_tz() { - if (_internal_has_timestamp_tz()) { - literal_type_.timestamp_tz_ = int64_t{0}; - clear_has_literal_type(); - } -} -inline int64_t Expression_Literal::_internal_timestamp_tz() const { - if (_internal_has_timestamp_tz()) { - return literal_type_.timestamp_tz_; - } - return int64_t{0}; -} -inline void Expression_Literal::_internal_set_timestamp_tz(int64_t value) { - if (!_internal_has_timestamp_tz()) { - clear_literal_type(); - set_has_timestamp_tz(); - } - literal_type_.timestamp_tz_ = value; -} -inline int64_t Expression_Literal::timestamp_tz() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.timestamp_tz) - return _internal_timestamp_tz(); -} -inline void Expression_Literal::set_timestamp_tz(int64_t value) { - _internal_set_timestamp_tz(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.timestamp_tz) -} - -// bytes uuid = 28; -inline bool Expression_Literal::_internal_has_uuid() const { - return literal_type_case() == kUuid; -} -inline bool Expression_Literal::has_uuid() const { - return _internal_has_uuid(); -} -inline void Expression_Literal::set_has_uuid() { - _oneof_case_[0] = kUuid; -} -inline void Expression_Literal::clear_uuid() { - if (_internal_has_uuid()) { - literal_type_.uuid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_literal_type(); - } -} -inline const std::string& Expression_Literal::uuid() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.uuid) - return _internal_uuid(); -} -template -inline void Expression_Literal::set_uuid(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_uuid()) { - clear_literal_type(); - set_has_uuid(); - literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.uuid_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.uuid) -} -inline std::string* Expression_Literal::mutable_uuid() { - std::string* _s = _internal_mutable_uuid(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.uuid) - return _s; -} -inline const std::string& Expression_Literal::_internal_uuid() const { - if (_internal_has_uuid()) { - return literal_type_.uuid_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void Expression_Literal::_internal_set_uuid(const std::string& value) { - if (!_internal_has_uuid()) { - clear_literal_type(); - set_has_uuid(); - literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - literal_type_.uuid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_Literal::_internal_mutable_uuid() { - if (!_internal_has_uuid()) { - clear_literal_type(); - set_has_uuid(); - literal_type_.uuid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return literal_type_.uuid_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_Literal::release_uuid() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.uuid) - if (_internal_has_uuid()) { - clear_has_literal_type(); - return literal_type_.uuid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void Expression_Literal::set_allocated_uuid(std::string* uuid) { - if (has_literal_type()) { - clear_literal_type(); - } - if (uuid != nullptr) { - set_has_uuid(); - literal_type_.uuid_.UnsafeSetDefault(uuid); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(uuid); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Literal.uuid) -} - -// .substrait.Type null = 29; -inline bool Expression_Literal::_internal_has_null() const { - return literal_type_case() == kNull; -} -inline bool Expression_Literal::has_null() const { - return _internal_has_null(); -} -inline void Expression_Literal::set_has_null() { - _oneof_case_[0] = kNull; -} -inline ::substrait::Type* Expression_Literal::release_null() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.null) - if (_internal_has_null()) { - clear_has_literal_type(); - ::substrait::Type* temp = literal_type_.null_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.null_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type& Expression_Literal::_internal_null() const { - return _internal_has_null() - ? *literal_type_.null_ - : reinterpret_cast< ::substrait::Type&>(::substrait::_Type_default_instance_); -} -inline const ::substrait::Type& Expression_Literal::null() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.null) - return _internal_null(); -} -inline ::substrait::Type* Expression_Literal::unsafe_arena_release_null() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.null) - if (_internal_has_null()) { - clear_has_literal_type(); - ::substrait::Type* temp = literal_type_.null_; - literal_type_.null_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Literal::unsafe_arena_set_allocated_null(::substrait::Type* null) { - clear_literal_type(); - if (null) { - set_has_null(); - literal_type_.null_ = null; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.null) -} -inline ::substrait::Type* Expression_Literal::_internal_mutable_null() { - if (!_internal_has_null()) { - clear_literal_type(); - set_has_null(); - literal_type_.null_ = CreateMaybeMessage< ::substrait::Type >(GetArenaForAllocation()); - } - return literal_type_.null_; -} -inline ::substrait::Type* Expression_Literal::mutable_null() { - ::substrait::Type* _msg = _internal_mutable_null(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.null) - return _msg; -} - -// .substrait.Expression.Literal.List list = 30; -inline bool Expression_Literal::_internal_has_list() const { - return literal_type_case() == kList; -} -inline bool Expression_Literal::has_list() const { - return _internal_has_list(); -} -inline void Expression_Literal::set_has_list() { - _oneof_case_[0] = kList; -} -inline void Expression_Literal::clear_list() { - if (_internal_has_list()) { - if (GetArenaForAllocation() == nullptr) { - delete literal_type_.list_; - } - clear_has_literal_type(); - } -} -inline ::substrait::Expression_Literal_List* Expression_Literal::release_list() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.list) - if (_internal_has_list()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_List* temp = literal_type_.list_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Literal_List& Expression_Literal::_internal_list() const { - return _internal_has_list() - ? *literal_type_.list_ - : reinterpret_cast< ::substrait::Expression_Literal_List&>(::substrait::_Expression_Literal_List_default_instance_); -} -inline const ::substrait::Expression_Literal_List& Expression_Literal::list() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.list) - return _internal_list(); -} -inline ::substrait::Expression_Literal_List* Expression_Literal::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.list) - if (_internal_has_list()) { - clear_has_literal_type(); - ::substrait::Expression_Literal_List* temp = literal_type_.list_; - literal_type_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Literal::unsafe_arena_set_allocated_list(::substrait::Expression_Literal_List* list) { - clear_literal_type(); - if (list) { - set_has_list(); - literal_type_.list_ = list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.list) -} -inline ::substrait::Expression_Literal_List* Expression_Literal::_internal_mutable_list() { - if (!_internal_has_list()) { - clear_literal_type(); - set_has_list(); - literal_type_.list_ = CreateMaybeMessage< ::substrait::Expression_Literal_List >(GetArenaForAllocation()); - } - return literal_type_.list_; -} -inline ::substrait::Expression_Literal_List* Expression_Literal::mutable_list() { - ::substrait::Expression_Literal_List* _msg = _internal_mutable_list(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.list) - return _msg; -} - -// .substrait.Type.List empty_list = 31; -inline bool Expression_Literal::_internal_has_empty_list() const { - return literal_type_case() == kEmptyList; -} -inline bool Expression_Literal::has_empty_list() const { - return _internal_has_empty_list(); -} -inline void Expression_Literal::set_has_empty_list() { - _oneof_case_[0] = kEmptyList; -} -inline ::substrait::Type_List* Expression_Literal::release_empty_list() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.empty_list) - if (_internal_has_empty_list()) { - clear_has_literal_type(); - ::substrait::Type_List* temp = literal_type_.empty_list_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.empty_list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_List& Expression_Literal::_internal_empty_list() const { - return _internal_has_empty_list() - ? *literal_type_.empty_list_ - : reinterpret_cast< ::substrait::Type_List&>(::substrait::_Type_List_default_instance_); -} -inline const ::substrait::Type_List& Expression_Literal::empty_list() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.empty_list) - return _internal_empty_list(); -} -inline ::substrait::Type_List* Expression_Literal::unsafe_arena_release_empty_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.empty_list) - if (_internal_has_empty_list()) { - clear_has_literal_type(); - ::substrait::Type_List* temp = literal_type_.empty_list_; - literal_type_.empty_list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Literal::unsafe_arena_set_allocated_empty_list(::substrait::Type_List* empty_list) { - clear_literal_type(); - if (empty_list) { - set_has_empty_list(); - literal_type_.empty_list_ = empty_list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.empty_list) -} -inline ::substrait::Type_List* Expression_Literal::_internal_mutable_empty_list() { - if (!_internal_has_empty_list()) { - clear_literal_type(); - set_has_empty_list(); - literal_type_.empty_list_ = CreateMaybeMessage< ::substrait::Type_List >(GetArenaForAllocation()); - } - return literal_type_.empty_list_; -} -inline ::substrait::Type_List* Expression_Literal::mutable_empty_list() { - ::substrait::Type_List* _msg = _internal_mutable_empty_list(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.empty_list) - return _msg; -} - -// .substrait.Type.Map empty_map = 32; -inline bool Expression_Literal::_internal_has_empty_map() const { - return literal_type_case() == kEmptyMap; -} -inline bool Expression_Literal::has_empty_map() const { - return _internal_has_empty_map(); -} -inline void Expression_Literal::set_has_empty_map() { - _oneof_case_[0] = kEmptyMap; -} -inline ::substrait::Type_Map* Expression_Literal::release_empty_map() { - // @@protoc_insertion_point(field_release:substrait.Expression.Literal.empty_map) - if (_internal_has_empty_map()) { - clear_has_literal_type(); - ::substrait::Type_Map* temp = literal_type_.empty_map_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - literal_type_.empty_map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Map& Expression_Literal::_internal_empty_map() const { - return _internal_has_empty_map() - ? *literal_type_.empty_map_ - : reinterpret_cast< ::substrait::Type_Map&>(::substrait::_Type_Map_default_instance_); -} -inline const ::substrait::Type_Map& Expression_Literal::empty_map() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.empty_map) - return _internal_empty_map(); -} -inline ::substrait::Type_Map* Expression_Literal::unsafe_arena_release_empty_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.Literal.empty_map) - if (_internal_has_empty_map()) { - clear_has_literal_type(); - ::substrait::Type_Map* temp = literal_type_.empty_map_; - literal_type_.empty_map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_Literal::unsafe_arena_set_allocated_empty_map(::substrait::Type_Map* empty_map) { - clear_literal_type(); - if (empty_map) { - set_has_empty_map(); - literal_type_.empty_map_ = empty_map; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Literal.empty_map) -} -inline ::substrait::Type_Map* Expression_Literal::_internal_mutable_empty_map() { - if (!_internal_has_empty_map()) { - clear_literal_type(); - set_has_empty_map(); - literal_type_.empty_map_ = CreateMaybeMessage< ::substrait::Type_Map >(GetArenaForAllocation()); - } - return literal_type_.empty_map_; -} -inline ::substrait::Type_Map* Expression_Literal::mutable_empty_map() { - ::substrait::Type_Map* _msg = _internal_mutable_empty_map(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Literal.empty_map) - return _msg; -} - -// bool nullable = 50; -inline void Expression_Literal::clear_nullable() { - nullable_ = false; -} -inline bool Expression_Literal::_internal_nullable() const { - return nullable_; -} -inline bool Expression_Literal::nullable() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Literal.nullable) - return _internal_nullable(); -} -inline void Expression_Literal::_internal_set_nullable(bool value) { - - nullable_ = value; -} -inline void Expression_Literal::set_nullable(bool value) { - _internal_set_nullable(value); - // @@protoc_insertion_point(field_set:substrait.Expression.Literal.nullable) -} - -inline bool Expression_Literal::has_literal_type() const { - return literal_type_case() != LITERAL_TYPE_NOT_SET; -} -inline void Expression_Literal::clear_has_literal_type() { - _oneof_case_[0] = LITERAL_TYPE_NOT_SET; -} -inline Expression_Literal::LiteralTypeCase Expression_Literal::literal_type_case() const { - return Expression_Literal::LiteralTypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Expression_ScalarFunction - -// uint32 function_reference = 1; -inline void Expression_ScalarFunction::clear_function_reference() { - function_reference_ = 0u; -} -inline uint32_t Expression_ScalarFunction::_internal_function_reference() const { - return function_reference_; -} -inline uint32_t Expression_ScalarFunction::function_reference() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ScalarFunction.function_reference) - return _internal_function_reference(); -} -inline void Expression_ScalarFunction::_internal_set_function_reference(uint32_t value) { - - function_reference_ = value; -} -inline void Expression_ScalarFunction::set_function_reference(uint32_t value) { - _internal_set_function_reference(value); - // @@protoc_insertion_point(field_set:substrait.Expression.ScalarFunction.function_reference) -} - -// repeated .substrait.Expression args = 2; -inline int Expression_ScalarFunction::_internal_args_size() const { - return args_.size(); -} -inline int Expression_ScalarFunction::args_size() const { - return _internal_args_size(); -} -inline void Expression_ScalarFunction::clear_args() { - args_.Clear(); -} -inline ::substrait::Expression* Expression_ScalarFunction::mutable_args(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.ScalarFunction.args) - return args_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* -Expression_ScalarFunction::mutable_args() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.ScalarFunction.args) - return &args_; -} -inline const ::substrait::Expression& Expression_ScalarFunction::_internal_args(int index) const { - return args_.Get(index); -} -inline const ::substrait::Expression& Expression_ScalarFunction::args(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.ScalarFunction.args) - return _internal_args(index); -} -inline ::substrait::Expression* Expression_ScalarFunction::_internal_add_args() { - return args_.Add(); -} -inline ::substrait::Expression* Expression_ScalarFunction::add_args() { - ::substrait::Expression* _add = _internal_add_args(); - // @@protoc_insertion_point(field_add:substrait.Expression.ScalarFunction.args) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& -Expression_ScalarFunction::args() const { - // @@protoc_insertion_point(field_list:substrait.Expression.ScalarFunction.args) - return args_; -} - -// .substrait.Type output_type = 3; -inline bool Expression_ScalarFunction::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; -} -inline bool Expression_ScalarFunction::has_output_type() const { - return _internal_has_output_type(); -} -inline const ::substrait::Type& Expression_ScalarFunction::_internal_output_type() const { - const ::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Type_default_instance_); -} -inline const ::substrait::Type& Expression_ScalarFunction::output_type() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ScalarFunction.output_type) - return _internal_output_type(); -} -inline void Expression_ScalarFunction::unsafe_arena_set_allocated_output_type( - ::substrait::Type* output_type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - output_type_ = output_type; - if (output_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ScalarFunction.output_type) -} -inline ::substrait::Type* Expression_ScalarFunction::release_output_type() { - - ::substrait::Type* temp = output_type_; - output_type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Type* Expression_ScalarFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:substrait.Expression.ScalarFunction.output_type) - - ::substrait::Type* temp = output_type_; - output_type_ = nullptr; - return temp; -} -inline ::substrait::Type* Expression_ScalarFunction::_internal_mutable_output_type() { - - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); - output_type_ = p; - } - return output_type_; -} -inline ::substrait::Type* Expression_ScalarFunction::mutable_output_type() { - ::substrait::Type* _msg = _internal_mutable_output_type(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.ScalarFunction.output_type) - return _msg; -} -inline void Expression_ScalarFunction::set_allocated_output_type(::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - if (output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); - if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); - } - - } else { - - } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ScalarFunction.output_type) -} - -// ------------------------------------------------------------------- - -// Expression_WindowFunction_Bound_Preceding - -// int64 offset = 1; -inline void Expression_WindowFunction_Bound_Preceding::clear_offset() { - offset_ = int64_t{0}; -} -inline int64_t Expression_WindowFunction_Bound_Preceding::_internal_offset() const { - return offset_; -} -inline int64_t Expression_WindowFunction_Bound_Preceding::offset() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.Preceding.offset) - return _internal_offset(); -} -inline void Expression_WindowFunction_Bound_Preceding::_internal_set_offset(int64_t value) { - - offset_ = value; -} -inline void Expression_WindowFunction_Bound_Preceding::set_offset(int64_t value) { - _internal_set_offset(value); - // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.Bound.Preceding.offset) -} - -// ------------------------------------------------------------------- - -// Expression_WindowFunction_Bound_Following - -// int64 offset = 1; -inline void Expression_WindowFunction_Bound_Following::clear_offset() { - offset_ = int64_t{0}; -} -inline int64_t Expression_WindowFunction_Bound_Following::_internal_offset() const { - return offset_; -} -inline int64_t Expression_WindowFunction_Bound_Following::offset() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.Following.offset) - return _internal_offset(); -} -inline void Expression_WindowFunction_Bound_Following::_internal_set_offset(int64_t value) { - - offset_ = value; -} -inline void Expression_WindowFunction_Bound_Following::set_offset(int64_t value) { - _internal_set_offset(value); - // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.Bound.Following.offset) -} - -// ------------------------------------------------------------------- - -// Expression_WindowFunction_Bound_CurrentRow - -// ------------------------------------------------------------------- - -// Expression_WindowFunction_Bound_Unbounded - -// ------------------------------------------------------------------- - -// Expression_WindowFunction_Bound - -// .substrait.Expression.WindowFunction.Bound.Preceding preceding = 1; -inline bool Expression_WindowFunction_Bound::_internal_has_preceding() const { - return kind_case() == kPreceding; -} -inline bool Expression_WindowFunction_Bound::has_preceding() const { - return _internal_has_preceding(); -} -inline void Expression_WindowFunction_Bound::set_has_preceding() { - _oneof_case_[0] = kPreceding; -} -inline void Expression_WindowFunction_Bound::clear_preceding() { - if (_internal_has_preceding()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.preceding_; - } - clear_has_kind(); - } -} -inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::release_preceding() { - // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.preceding) - if (_internal_has_preceding()) { - clear_has_kind(); - ::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.preceding_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::_internal_preceding() const { - return _internal_has_preceding() - ? *kind_.preceding_ - : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_Preceding&>(::substrait::_Expression_WindowFunction_Bound_Preceding_default_instance_); -} -inline const ::substrait::Expression_WindowFunction_Bound_Preceding& Expression_WindowFunction_Bound::preceding() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.preceding) - return _internal_preceding(); -} -inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::unsafe_arena_release_preceding() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.preceding) - if (_internal_has_preceding()) { - clear_has_kind(); - ::substrait::Expression_WindowFunction_Bound_Preceding* temp = kind_.preceding_; - kind_.preceding_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_preceding(::substrait::Expression_WindowFunction_Bound_Preceding* preceding) { - clear_kind(); - if (preceding) { - set_has_preceding(); - kind_.preceding_ = preceding; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.preceding) -} -inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::_internal_mutable_preceding() { - if (!_internal_has_preceding()) { - clear_kind(); - set_has_preceding(); - kind_.preceding_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Preceding >(GetArenaForAllocation()); - } - return kind_.preceding_; -} -inline ::substrait::Expression_WindowFunction_Bound_Preceding* Expression_WindowFunction_Bound::mutable_preceding() { - ::substrait::Expression_WindowFunction_Bound_Preceding* _msg = _internal_mutable_preceding(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.preceding) - return _msg; -} - -// .substrait.Expression.WindowFunction.Bound.Following following = 2; -inline bool Expression_WindowFunction_Bound::_internal_has_following() const { - return kind_case() == kFollowing; -} -inline bool Expression_WindowFunction_Bound::has_following() const { - return _internal_has_following(); -} -inline void Expression_WindowFunction_Bound::set_has_following() { - _oneof_case_[0] = kFollowing; -} -inline void Expression_WindowFunction_Bound::clear_following() { - if (_internal_has_following()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.following_; - } - clear_has_kind(); - } -} -inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::release_following() { - // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.following) - if (_internal_has_following()) { - clear_has_kind(); - ::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.following_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::_internal_following() const { - return _internal_has_following() - ? *kind_.following_ - : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_Following&>(::substrait::_Expression_WindowFunction_Bound_Following_default_instance_); -} -inline const ::substrait::Expression_WindowFunction_Bound_Following& Expression_WindowFunction_Bound::following() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.following) - return _internal_following(); -} -inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::unsafe_arena_release_following() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.following) - if (_internal_has_following()) { - clear_has_kind(); - ::substrait::Expression_WindowFunction_Bound_Following* temp = kind_.following_; - kind_.following_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_following(::substrait::Expression_WindowFunction_Bound_Following* following) { - clear_kind(); - if (following) { - set_has_following(); - kind_.following_ = following; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.following) -} -inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::_internal_mutable_following() { - if (!_internal_has_following()) { - clear_kind(); - set_has_following(); - kind_.following_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Following >(GetArenaForAllocation()); - } - return kind_.following_; -} -inline ::substrait::Expression_WindowFunction_Bound_Following* Expression_WindowFunction_Bound::mutable_following() { - ::substrait::Expression_WindowFunction_Bound_Following* _msg = _internal_mutable_following(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.following) - return _msg; -} - -// .substrait.Expression.WindowFunction.Bound.CurrentRow current_row = 3; -inline bool Expression_WindowFunction_Bound::_internal_has_current_row() const { - return kind_case() == kCurrentRow; -} -inline bool Expression_WindowFunction_Bound::has_current_row() const { - return _internal_has_current_row(); -} -inline void Expression_WindowFunction_Bound::set_has_current_row() { - _oneof_case_[0] = kCurrentRow; -} -inline void Expression_WindowFunction_Bound::clear_current_row() { - if (_internal_has_current_row()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.current_row_; - } - clear_has_kind(); - } -} -inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::release_current_row() { - // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.current_row) - if (_internal_has_current_row()) { - clear_has_kind(); - ::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.current_row_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::_internal_current_row() const { - return _internal_has_current_row() - ? *kind_.current_row_ - : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_CurrentRow&>(::substrait::_Expression_WindowFunction_Bound_CurrentRow_default_instance_); -} -inline const ::substrait::Expression_WindowFunction_Bound_CurrentRow& Expression_WindowFunction_Bound::current_row() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.current_row) - return _internal_current_row(); -} -inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::unsafe_arena_release_current_row() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.current_row) - if (_internal_has_current_row()) { - clear_has_kind(); - ::substrait::Expression_WindowFunction_Bound_CurrentRow* temp = kind_.current_row_; - kind_.current_row_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_current_row(::substrait::Expression_WindowFunction_Bound_CurrentRow* current_row) { - clear_kind(); - if (current_row) { - set_has_current_row(); - kind_.current_row_ = current_row; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.current_row) -} -inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::_internal_mutable_current_row() { - if (!_internal_has_current_row()) { - clear_kind(); - set_has_current_row(); - kind_.current_row_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_CurrentRow >(GetArenaForAllocation()); - } - return kind_.current_row_; -} -inline ::substrait::Expression_WindowFunction_Bound_CurrentRow* Expression_WindowFunction_Bound::mutable_current_row() { - ::substrait::Expression_WindowFunction_Bound_CurrentRow* _msg = _internal_mutable_current_row(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.current_row) - return _msg; -} - -// .substrait.Expression.WindowFunction.Bound.Unbounded unbounded = 4; -inline bool Expression_WindowFunction_Bound::_internal_has_unbounded() const { - return kind_case() == kUnbounded; -} -inline bool Expression_WindowFunction_Bound::has_unbounded() const { - return _internal_has_unbounded(); -} -inline void Expression_WindowFunction_Bound::set_has_unbounded() { - _oneof_case_[0] = kUnbounded; -} -inline void Expression_WindowFunction_Bound::clear_unbounded() { - if (_internal_has_unbounded()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.unbounded_; - } - clear_has_kind(); - } -} -inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::release_unbounded() { - // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.Bound.unbounded) - if (_internal_has_unbounded()) { - clear_has_kind(); - ::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.unbounded_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::_internal_unbounded() const { - return _internal_has_unbounded() - ? *kind_.unbounded_ - : reinterpret_cast< ::substrait::Expression_WindowFunction_Bound_Unbounded&>(::substrait::_Expression_WindowFunction_Bound_Unbounded_default_instance_); -} -inline const ::substrait::Expression_WindowFunction_Bound_Unbounded& Expression_WindowFunction_Bound::unbounded() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.Bound.unbounded) - return _internal_unbounded(); -} -inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::unsafe_arena_release_unbounded() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.WindowFunction.Bound.unbounded) - if (_internal_has_unbounded()) { - clear_has_kind(); - ::substrait::Expression_WindowFunction_Bound_Unbounded* temp = kind_.unbounded_; - kind_.unbounded_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_WindowFunction_Bound::unsafe_arena_set_allocated_unbounded(::substrait::Expression_WindowFunction_Bound_Unbounded* unbounded) { - clear_kind(); - if (unbounded) { - set_has_unbounded(); - kind_.unbounded_ = unbounded; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.Bound.unbounded) -} -inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::_internal_mutable_unbounded() { - if (!_internal_has_unbounded()) { - clear_kind(); - set_has_unbounded(); - kind_.unbounded_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction_Bound_Unbounded >(GetArenaForAllocation()); - } - return kind_.unbounded_; -} -inline ::substrait::Expression_WindowFunction_Bound_Unbounded* Expression_WindowFunction_Bound::mutable_unbounded() { - ::substrait::Expression_WindowFunction_Bound_Unbounded* _msg = _internal_mutable_unbounded(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.Bound.unbounded) - return _msg; -} - -inline bool Expression_WindowFunction_Bound::has_kind() const { - return kind_case() != KIND_NOT_SET; -} -inline void Expression_WindowFunction_Bound::clear_has_kind() { - _oneof_case_[0] = KIND_NOT_SET; -} -inline Expression_WindowFunction_Bound::KindCase Expression_WindowFunction_Bound::kind_case() const { - return Expression_WindowFunction_Bound::KindCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Expression_WindowFunction - -// uint32 function_reference = 1; -inline void Expression_WindowFunction::clear_function_reference() { - function_reference_ = 0u; -} -inline uint32_t Expression_WindowFunction::_internal_function_reference() const { - return function_reference_; -} -inline uint32_t Expression_WindowFunction::function_reference() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.function_reference) - return _internal_function_reference(); -} -inline void Expression_WindowFunction::_internal_set_function_reference(uint32_t value) { - - function_reference_ = value; -} -inline void Expression_WindowFunction::set_function_reference(uint32_t value) { - _internal_set_function_reference(value); - // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.function_reference) -} - -// repeated .substrait.Expression partitions = 2; -inline int Expression_WindowFunction::_internal_partitions_size() const { - return partitions_.size(); -} -inline int Expression_WindowFunction::partitions_size() const { - return _internal_partitions_size(); -} -inline void Expression_WindowFunction::clear_partitions() { - partitions_.Clear(); -} -inline ::substrait::Expression* Expression_WindowFunction::mutable_partitions(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.partitions) - return partitions_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* -Expression_WindowFunction::mutable_partitions() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.WindowFunction.partitions) - return &partitions_; -} -inline const ::substrait::Expression& Expression_WindowFunction::_internal_partitions(int index) const { - return partitions_.Get(index); -} -inline const ::substrait::Expression& Expression_WindowFunction::partitions(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.partitions) - return _internal_partitions(index); -} -inline ::substrait::Expression* Expression_WindowFunction::_internal_add_partitions() { - return partitions_.Add(); -} -inline ::substrait::Expression* Expression_WindowFunction::add_partitions() { - ::substrait::Expression* _add = _internal_add_partitions(); - // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.partitions) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& -Expression_WindowFunction::partitions() const { - // @@protoc_insertion_point(field_list:substrait.Expression.WindowFunction.partitions) - return partitions_; -} - -// repeated .substrait.SortField sorts = 3; -inline int Expression_WindowFunction::_internal_sorts_size() const { - return sorts_.size(); -} -inline int Expression_WindowFunction::sorts_size() const { - return _internal_sorts_size(); -} -inline void Expression_WindowFunction::clear_sorts() { - sorts_.Clear(); -} -inline ::substrait::SortField* Expression_WindowFunction::mutable_sorts(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.sorts) - return sorts_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* -Expression_WindowFunction::mutable_sorts() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.WindowFunction.sorts) - return &sorts_; -} -inline const ::substrait::SortField& Expression_WindowFunction::_internal_sorts(int index) const { - return sorts_.Get(index); -} -inline const ::substrait::SortField& Expression_WindowFunction::sorts(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.sorts) - return _internal_sorts(index); -} -inline ::substrait::SortField* Expression_WindowFunction::_internal_add_sorts() { - return sorts_.Add(); -} -inline ::substrait::SortField* Expression_WindowFunction::add_sorts() { - ::substrait::SortField* _add = _internal_add_sorts(); - // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.sorts) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& -Expression_WindowFunction::sorts() const { - // @@protoc_insertion_point(field_list:substrait.Expression.WindowFunction.sorts) - return sorts_; -} - -// .substrait.Expression.WindowFunction.Bound upper_bound = 4; -inline bool Expression_WindowFunction::_internal_has_upper_bound() const { - return this != internal_default_instance() && upper_bound_ != nullptr; -} -inline bool Expression_WindowFunction::has_upper_bound() const { - return _internal_has_upper_bound(); -} -inline void Expression_WindowFunction::clear_upper_bound() { - if (GetArenaForAllocation() == nullptr && upper_bound_ != nullptr) { - delete upper_bound_; - } - upper_bound_ = nullptr; -} -inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_upper_bound() const { - const ::substrait::Expression_WindowFunction_Bound* p = upper_bound_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_WindowFunction_Bound_default_instance_); -} -inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::upper_bound() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.upper_bound) - return _internal_upper_bound(); -} -inline void Expression_WindowFunction::unsafe_arena_set_allocated_upper_bound( - ::substrait::Expression_WindowFunction_Bound* upper_bound) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(upper_bound_); - } - upper_bound_ = upper_bound; - if (upper_bound) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.upper_bound) -} -inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_upper_bound() { - - ::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; - upper_bound_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_upper_bound() { - // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.upper_bound) - - ::substrait::Expression_WindowFunction_Bound* temp = upper_bound_; - upper_bound_ = nullptr; - return temp; -} -inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_upper_bound() { - - if (upper_bound_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(GetArenaForAllocation()); - upper_bound_ = p; - } - return upper_bound_; -} -inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_upper_bound() { - ::substrait::Expression_WindowFunction_Bound* _msg = _internal_mutable_upper_bound(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.upper_bound) - return _msg; -} -inline void Expression_WindowFunction::set_allocated_upper_bound(::substrait::Expression_WindowFunction_Bound* upper_bound) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete upper_bound_; - } - if (upper_bound) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound>::GetOwningArena(upper_bound); - if (message_arena != submessage_arena) { - upper_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, upper_bound, submessage_arena); - } - - } else { - - } - upper_bound_ = upper_bound; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.upper_bound) -} - -// .substrait.Expression.WindowFunction.Bound lower_bound = 5; -inline bool Expression_WindowFunction::_internal_has_lower_bound() const { - return this != internal_default_instance() && lower_bound_ != nullptr; -} -inline bool Expression_WindowFunction::has_lower_bound() const { - return _internal_has_lower_bound(); -} -inline void Expression_WindowFunction::clear_lower_bound() { - if (GetArenaForAllocation() == nullptr && lower_bound_ != nullptr) { - delete lower_bound_; - } - lower_bound_ = nullptr; -} -inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::_internal_lower_bound() const { - const ::substrait::Expression_WindowFunction_Bound* p = lower_bound_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_WindowFunction_Bound_default_instance_); -} -inline const ::substrait::Expression_WindowFunction_Bound& Expression_WindowFunction::lower_bound() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.lower_bound) - return _internal_lower_bound(); -} -inline void Expression_WindowFunction::unsafe_arena_set_allocated_lower_bound( - ::substrait::Expression_WindowFunction_Bound* lower_bound) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(lower_bound_); - } - lower_bound_ = lower_bound; - if (lower_bound) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.lower_bound) -} -inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::release_lower_bound() { - - ::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; - lower_bound_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::unsafe_arena_release_lower_bound() { - // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.lower_bound) - - ::substrait::Expression_WindowFunction_Bound* temp = lower_bound_; - lower_bound_ = nullptr; - return temp; -} -inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::_internal_mutable_lower_bound() { - - if (lower_bound_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_WindowFunction_Bound>(GetArenaForAllocation()); - lower_bound_ = p; - } - return lower_bound_; -} -inline ::substrait::Expression_WindowFunction_Bound* Expression_WindowFunction::mutable_lower_bound() { - ::substrait::Expression_WindowFunction_Bound* _msg = _internal_mutable_lower_bound(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.lower_bound) - return _msg; -} -inline void Expression_WindowFunction::set_allocated_lower_bound(::substrait::Expression_WindowFunction_Bound* lower_bound) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete lower_bound_; - } - if (lower_bound) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_WindowFunction_Bound>::GetOwningArena(lower_bound); - if (message_arena != submessage_arena) { - lower_bound = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, lower_bound, submessage_arena); - } - - } else { - - } - lower_bound_ = lower_bound; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.lower_bound) -} - -// .substrait.AggregationPhase phase = 6; -inline void Expression_WindowFunction::clear_phase() { - phase_ = 0; -} -inline ::substrait::AggregationPhase Expression_WindowFunction::_internal_phase() const { - return static_cast< ::substrait::AggregationPhase >(phase_); -} -inline ::substrait::AggregationPhase Expression_WindowFunction::phase() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.phase) - return _internal_phase(); -} -inline void Expression_WindowFunction::_internal_set_phase(::substrait::AggregationPhase value) { - - phase_ = value; -} -inline void Expression_WindowFunction::set_phase(::substrait::AggregationPhase value) { - _internal_set_phase(value); - // @@protoc_insertion_point(field_set:substrait.Expression.WindowFunction.phase) -} - -// .substrait.Type output_type = 7; -inline bool Expression_WindowFunction::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; -} -inline bool Expression_WindowFunction::has_output_type() const { - return _internal_has_output_type(); -} -inline const ::substrait::Type& Expression_WindowFunction::_internal_output_type() const { - const ::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Type_default_instance_); -} -inline const ::substrait::Type& Expression_WindowFunction::output_type() const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.output_type) - return _internal_output_type(); -} -inline void Expression_WindowFunction::unsafe_arena_set_allocated_output_type( - ::substrait::Type* output_type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - output_type_ = output_type; - if (output_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.WindowFunction.output_type) -} -inline ::substrait::Type* Expression_WindowFunction::release_output_type() { - - ::substrait::Type* temp = output_type_; - output_type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Type* Expression_WindowFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:substrait.Expression.WindowFunction.output_type) - - ::substrait::Type* temp = output_type_; - output_type_ = nullptr; - return temp; -} -inline ::substrait::Type* Expression_WindowFunction::_internal_mutable_output_type() { - - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); - output_type_ = p; - } - return output_type_; -} -inline ::substrait::Type* Expression_WindowFunction::mutable_output_type() { - ::substrait::Type* _msg = _internal_mutable_output_type(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.output_type) - return _msg; -} -inline void Expression_WindowFunction::set_allocated_output_type(::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - if (output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); - if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); - } - - } else { - - } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.WindowFunction.output_type) -} - -// repeated .substrait.Expression args = 8; -inline int Expression_WindowFunction::_internal_args_size() const { - return args_.size(); -} -inline int Expression_WindowFunction::args_size() const { - return _internal_args_size(); -} -inline void Expression_WindowFunction::clear_args() { - args_.Clear(); -} -inline ::substrait::Expression* Expression_WindowFunction::mutable_args(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.WindowFunction.args) - return args_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* -Expression_WindowFunction::mutable_args() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.WindowFunction.args) - return &args_; -} -inline const ::substrait::Expression& Expression_WindowFunction::_internal_args(int index) const { - return args_.Get(index); -} -inline const ::substrait::Expression& Expression_WindowFunction::args(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.WindowFunction.args) - return _internal_args(index); -} -inline ::substrait::Expression* Expression_WindowFunction::_internal_add_args() { - return args_.Add(); -} -inline ::substrait::Expression* Expression_WindowFunction::add_args() { - ::substrait::Expression* _add = _internal_add_args(); - // @@protoc_insertion_point(field_add:substrait.Expression.WindowFunction.args) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& -Expression_WindowFunction::args() const { - // @@protoc_insertion_point(field_list:substrait.Expression.WindowFunction.args) - return args_; -} - -// ------------------------------------------------------------------- - -// Expression_IfThen_IfClause - -// .substrait.Expression if = 1; -inline bool Expression_IfThen_IfClause::_internal_has_if_() const { - return this != internal_default_instance() && if__ != nullptr; -} -inline bool Expression_IfThen_IfClause::has_if_() const { - return _internal_has_if_(); -} -inline void Expression_IfThen_IfClause::clear_if_() { - if (GetArenaForAllocation() == nullptr && if__ != nullptr) { - delete if__; - } - if__ = nullptr; -} -inline const ::substrait::Expression& Expression_IfThen_IfClause::_internal_if_() const { - const ::substrait::Expression* p = if__; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& Expression_IfThen_IfClause::if_() const { - // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.IfClause.if) - return _internal_if_(); -} -inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_if_( - ::substrait::Expression* if_) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); - } - if__ = if_; - if (if_) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.IfThen.IfClause.if) -} -inline ::substrait::Expression* Expression_IfThen_IfClause::release_if_() { - - ::substrait::Expression* temp = if__; - if__ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_if_() { - // @@protoc_insertion_point(field_release:substrait.Expression.IfThen.IfClause.if) - - ::substrait::Expression* temp = if__; - if__ = nullptr; - return temp; -} -inline ::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_if_() { - - if (if__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - if__ = p; - } - return if__; -} -inline ::substrait::Expression* Expression_IfThen_IfClause::mutable_if_() { - ::substrait::Expression* _msg = _internal_mutable_if_(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.IfClause.if) - return _msg; -} -inline void Expression_IfThen_IfClause::set_allocated_if_(::substrait::Expression* if_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete if__; - } - if (if_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(if_); - if (message_arena != submessage_arena) { - if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, if_, submessage_arena); - } - - } else { - - } - if__ = if_; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.IfThen.IfClause.if) -} - -// .substrait.Expression then = 2; -inline bool Expression_IfThen_IfClause::_internal_has_then() const { - return this != internal_default_instance() && then_ != nullptr; -} -inline bool Expression_IfThen_IfClause::has_then() const { - return _internal_has_then(); -} -inline void Expression_IfThen_IfClause::clear_then() { - if (GetArenaForAllocation() == nullptr && then_ != nullptr) { - delete then_; - } - then_ = nullptr; -} -inline const ::substrait::Expression& Expression_IfThen_IfClause::_internal_then() const { - const ::substrait::Expression* p = then_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& Expression_IfThen_IfClause::then() const { - // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.IfClause.then) - return _internal_then(); -} -inline void Expression_IfThen_IfClause::unsafe_arena_set_allocated_then( - ::substrait::Expression* then) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); - } - then_ = then; - if (then) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.IfThen.IfClause.then) -} -inline ::substrait::Expression* Expression_IfThen_IfClause::release_then() { - - ::substrait::Expression* temp = then_; - then_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* Expression_IfThen_IfClause::unsafe_arena_release_then() { - // @@protoc_insertion_point(field_release:substrait.Expression.IfThen.IfClause.then) - - ::substrait::Expression* temp = then_; - then_ = nullptr; - return temp; -} -inline ::substrait::Expression* Expression_IfThen_IfClause::_internal_mutable_then() { - - if (then_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - then_ = p; - } - return then_; -} -inline ::substrait::Expression* Expression_IfThen_IfClause::mutable_then() { - ::substrait::Expression* _msg = _internal_mutable_then(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.IfClause.then) - return _msg; -} -inline void Expression_IfThen_IfClause::set_allocated_then(::substrait::Expression* then) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete then_; - } - if (then) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(then); - if (message_arena != submessage_arena) { - then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, then, submessage_arena); - } - - } else { - - } - then_ = then; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.IfThen.IfClause.then) -} - -// ------------------------------------------------------------------- - -// Expression_IfThen - -// repeated .substrait.Expression.IfThen.IfClause ifs = 1; -inline int Expression_IfThen::_internal_ifs_size() const { - return ifs_.size(); -} -inline int Expression_IfThen::ifs_size() const { - return _internal_ifs_size(); -} -inline void Expression_IfThen::clear_ifs() { - ifs_.Clear(); -} -inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::mutable_ifs(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.ifs) - return ifs_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >* -Expression_IfThen::mutable_ifs() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.IfThen.ifs) - return &ifs_; -} -inline const ::substrait::Expression_IfThen_IfClause& Expression_IfThen::_internal_ifs(int index) const { - return ifs_.Get(index); -} -inline const ::substrait::Expression_IfThen_IfClause& Expression_IfThen::ifs(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.ifs) - return _internal_ifs(index); -} -inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::_internal_add_ifs() { - return ifs_.Add(); -} -inline ::substrait::Expression_IfThen_IfClause* Expression_IfThen::add_ifs() { - ::substrait::Expression_IfThen_IfClause* _add = _internal_add_ifs(); - // @@protoc_insertion_point(field_add:substrait.Expression.IfThen.ifs) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_IfThen_IfClause >& -Expression_IfThen::ifs() const { - // @@protoc_insertion_point(field_list:substrait.Expression.IfThen.ifs) - return ifs_; -} - -// .substrait.Expression else = 2; -inline bool Expression_IfThen::_internal_has_else_() const { - return this != internal_default_instance() && else__ != nullptr; -} -inline bool Expression_IfThen::has_else_() const { - return _internal_has_else_(); -} -inline void Expression_IfThen::clear_else_() { - if (GetArenaForAllocation() == nullptr && else__ != nullptr) { - delete else__; - } - else__ = nullptr; -} -inline const ::substrait::Expression& Expression_IfThen::_internal_else_() const { - const ::substrait::Expression* p = else__; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& Expression_IfThen::else_() const { - // @@protoc_insertion_point(field_get:substrait.Expression.IfThen.else) - return _internal_else_(); -} -inline void Expression_IfThen::unsafe_arena_set_allocated_else_( - ::substrait::Expression* else_) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); - } - else__ = else_; - if (else_) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.IfThen.else) -} -inline ::substrait::Expression* Expression_IfThen::release_else_() { - - ::substrait::Expression* temp = else__; - else__ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* Expression_IfThen::unsafe_arena_release_else_() { - // @@protoc_insertion_point(field_release:substrait.Expression.IfThen.else) - - ::substrait::Expression* temp = else__; - else__ = nullptr; - return temp; -} -inline ::substrait::Expression* Expression_IfThen::_internal_mutable_else_() { - - if (else__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - else__ = p; - } - return else__; -} -inline ::substrait::Expression* Expression_IfThen::mutable_else_() { - ::substrait::Expression* _msg = _internal_mutable_else_(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.IfThen.else) - return _msg; -} -inline void Expression_IfThen::set_allocated_else_(::substrait::Expression* else_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete else__; - } - if (else_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(else_); - if (message_arena != submessage_arena) { - else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, else_, submessage_arena); - } - - } else { - - } - else__ = else_; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.IfThen.else) -} - -// ------------------------------------------------------------------- - -// Expression_Cast - -// .substrait.Type type = 1; -inline bool Expression_Cast::_internal_has_type() const { - return this != internal_default_instance() && type_ != nullptr; -} -inline bool Expression_Cast::has_type() const { - return _internal_has_type(); -} -inline const ::substrait::Type& Expression_Cast::_internal_type() const { - const ::substrait::Type* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Type_default_instance_); -} -inline const ::substrait::Type& Expression_Cast::type() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Cast.type) - return _internal_type(); -} -inline void Expression_Cast::unsafe_arena_set_allocated_type( - ::substrait::Type* type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); - } - type_ = type; - if (type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Cast.type) -} -inline ::substrait::Type* Expression_Cast::release_type() { - - ::substrait::Type* temp = type_; - type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Type* Expression_Cast::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:substrait.Expression.Cast.type) - - ::substrait::Type* temp = type_; - type_ = nullptr; - return temp; -} -inline ::substrait::Type* Expression_Cast::_internal_mutable_type() { - - if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); - type_ = p; - } - return type_; -} -inline ::substrait::Type* Expression_Cast::mutable_type() { - ::substrait::Type* _msg = _internal_mutable_type(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Cast.type) - return _msg; -} -inline void Expression_Cast::set_allocated_type(::substrait::Type* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); - } - if (type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)); - if (message_arena != submessage_arena) { - type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type, submessage_arena); - } - - } else { - - } - type_ = type; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Cast.type) -} - -// .substrait.Expression input = 2; -inline bool Expression_Cast::_internal_has_input() const { - return this != internal_default_instance() && input_ != nullptr; -} -inline bool Expression_Cast::has_input() const { - return _internal_has_input(); -} -inline void Expression_Cast::clear_input() { - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; -} -inline const ::substrait::Expression& Expression_Cast::_internal_input() const { - const ::substrait::Expression* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& Expression_Cast::input() const { - // @@protoc_insertion_point(field_get:substrait.Expression.Cast.input) - return _internal_input(); -} -inline void Expression_Cast::unsafe_arena_set_allocated_input( - ::substrait::Expression* input) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); - } - input_ = input; - if (input) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.Cast.input) -} -inline ::substrait::Expression* Expression_Cast::release_input() { - - ::substrait::Expression* temp = input_; - input_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* Expression_Cast::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:substrait.Expression.Cast.input) - - ::substrait::Expression* temp = input_; - input_ = nullptr; - return temp; -} -inline ::substrait::Expression* Expression_Cast::_internal_mutable_input() { - - if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - input_ = p; - } - return input_; -} -inline ::substrait::Expression* Expression_Cast::mutable_input() { - ::substrait::Expression* _msg = _internal_mutable_input(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.Cast.input) - return _msg; -} -inline void Expression_Cast::set_allocated_input(::substrait::Expression* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete input_; - } - if (input) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(input); - if (message_arena != submessage_arena) { - input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, input, submessage_arena); - } - - } else { - - } - input_ = input; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.Cast.input) -} - -// ------------------------------------------------------------------- - -// Expression_SwitchExpression_IfValue - -// .substrait.Expression.Literal if = 1; -inline bool Expression_SwitchExpression_IfValue::_internal_has_if_() const { - return this != internal_default_instance() && if__ != nullptr; -} -inline bool Expression_SwitchExpression_IfValue::has_if_() const { - return _internal_has_if_(); -} -inline void Expression_SwitchExpression_IfValue::clear_if_() { - if (GetArenaForAllocation() == nullptr && if__ != nullptr) { - delete if__; - } - if__ = nullptr; -} -inline const ::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::_internal_if_() const { - const ::substrait::Expression_Literal* p = if__; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_Literal_default_instance_); -} -inline const ::substrait::Expression_Literal& Expression_SwitchExpression_IfValue::if_() const { - // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.IfValue.if) - return _internal_if_(); -} -inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_if_( - ::substrait::Expression_Literal* if_) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if__); - } - if__ = if_; - if (if_) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SwitchExpression.IfValue.if) -} -inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::release_if_() { - - ::substrait::Expression_Literal* temp = if__; - if__ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::unsafe_arena_release_if_() { - // @@protoc_insertion_point(field_release:substrait.Expression.SwitchExpression.IfValue.if) - - ::substrait::Expression_Literal* temp = if__; - if__ = nullptr; - return temp; -} -inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::_internal_mutable_if_() { - - if (if__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation()); - if__ = p; - } - return if__; -} -inline ::substrait::Expression_Literal* Expression_SwitchExpression_IfValue::mutable_if_() { - ::substrait::Expression_Literal* _msg = _internal_mutable_if_(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.IfValue.if) - return _msg; -} -inline void Expression_SwitchExpression_IfValue::set_allocated_if_(::substrait::Expression_Literal* if_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete if__; - } - if (if_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(if_); - if (message_arena != submessage_arena) { - if_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, if_, submessage_arena); - } - - } else { - - } - if__ = if_; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SwitchExpression.IfValue.if) -} - -// .substrait.Expression then = 2; -inline bool Expression_SwitchExpression_IfValue::_internal_has_then() const { - return this != internal_default_instance() && then_ != nullptr; -} -inline bool Expression_SwitchExpression_IfValue::has_then() const { - return _internal_has_then(); -} -inline void Expression_SwitchExpression_IfValue::clear_then() { - if (GetArenaForAllocation() == nullptr && then_ != nullptr) { - delete then_; - } - then_ = nullptr; -} -inline const ::substrait::Expression& Expression_SwitchExpression_IfValue::_internal_then() const { - const ::substrait::Expression* p = then_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& Expression_SwitchExpression_IfValue::then() const { - // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.IfValue.then) - return _internal_then(); -} -inline void Expression_SwitchExpression_IfValue::unsafe_arena_set_allocated_then( - ::substrait::Expression* then) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(then_); - } - then_ = then; - if (then) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SwitchExpression.IfValue.then) -} -inline ::substrait::Expression* Expression_SwitchExpression_IfValue::release_then() { - - ::substrait::Expression* temp = then_; - then_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* Expression_SwitchExpression_IfValue::unsafe_arena_release_then() { - // @@protoc_insertion_point(field_release:substrait.Expression.SwitchExpression.IfValue.then) - - ::substrait::Expression* temp = then_; - then_ = nullptr; - return temp; -} -inline ::substrait::Expression* Expression_SwitchExpression_IfValue::_internal_mutable_then() { - - if (then_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - then_ = p; - } - return then_; -} -inline ::substrait::Expression* Expression_SwitchExpression_IfValue::mutable_then() { - ::substrait::Expression* _msg = _internal_mutable_then(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.IfValue.then) - return _msg; -} -inline void Expression_SwitchExpression_IfValue::set_allocated_then(::substrait::Expression* then) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete then_; - } - if (then) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(then); - if (message_arena != submessage_arena) { - then = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, then, submessage_arena); - } - - } else { - - } - then_ = then; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SwitchExpression.IfValue.then) -} - -// ------------------------------------------------------------------- - -// Expression_SwitchExpression - -// repeated .substrait.Expression.SwitchExpression.IfValue ifs = 1; -inline int Expression_SwitchExpression::_internal_ifs_size() const { - return ifs_.size(); -} -inline int Expression_SwitchExpression::ifs_size() const { - return _internal_ifs_size(); -} -inline void Expression_SwitchExpression::clear_ifs() { - ifs_.Clear(); -} -inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::mutable_ifs(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.ifs) - return ifs_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >* -Expression_SwitchExpression::mutable_ifs() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.SwitchExpression.ifs) - return &ifs_; -} -inline const ::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::_internal_ifs(int index) const { - return ifs_.Get(index); -} -inline const ::substrait::Expression_SwitchExpression_IfValue& Expression_SwitchExpression::ifs(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.ifs) - return _internal_ifs(index); -} -inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::_internal_add_ifs() { - return ifs_.Add(); -} -inline ::substrait::Expression_SwitchExpression_IfValue* Expression_SwitchExpression::add_ifs() { - ::substrait::Expression_SwitchExpression_IfValue* _add = _internal_add_ifs(); - // @@protoc_insertion_point(field_add:substrait.Expression.SwitchExpression.ifs) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_SwitchExpression_IfValue >& -Expression_SwitchExpression::ifs() const { - // @@protoc_insertion_point(field_list:substrait.Expression.SwitchExpression.ifs) - return ifs_; -} - -// .substrait.Expression else = 2; -inline bool Expression_SwitchExpression::_internal_has_else_() const { - return this != internal_default_instance() && else__ != nullptr; -} -inline bool Expression_SwitchExpression::has_else_() const { - return _internal_has_else_(); -} -inline void Expression_SwitchExpression::clear_else_() { - if (GetArenaForAllocation() == nullptr && else__ != nullptr) { - delete else__; - } - else__ = nullptr; -} -inline const ::substrait::Expression& Expression_SwitchExpression::_internal_else_() const { - const ::substrait::Expression* p = else__; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& Expression_SwitchExpression::else_() const { - // @@protoc_insertion_point(field_get:substrait.Expression.SwitchExpression.else) - return _internal_else_(); -} -inline void Expression_SwitchExpression::unsafe_arena_set_allocated_else_( - ::substrait::Expression* else_) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else__); - } - else__ = else_; - if (else_) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SwitchExpression.else) -} -inline ::substrait::Expression* Expression_SwitchExpression::release_else_() { - - ::substrait::Expression* temp = else__; - else__ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* Expression_SwitchExpression::unsafe_arena_release_else_() { - // @@protoc_insertion_point(field_release:substrait.Expression.SwitchExpression.else) - - ::substrait::Expression* temp = else__; - else__ = nullptr; - return temp; -} -inline ::substrait::Expression* Expression_SwitchExpression::_internal_mutable_else_() { - - if (else__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - else__ = p; - } - return else__; -} -inline ::substrait::Expression* Expression_SwitchExpression::mutable_else_() { - ::substrait::Expression* _msg = _internal_mutable_else_(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.SwitchExpression.else) - return _msg; -} -inline void Expression_SwitchExpression::set_allocated_else_(::substrait::Expression* else_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete else__; - } - if (else_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(else_); - if (message_arena != submessage_arena) { - else_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, else_, submessage_arena); - } - - } else { - - } - else__ = else_; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SwitchExpression.else) -} - -// ------------------------------------------------------------------- - -// Expression_SingularOrList - -// .substrait.Expression value = 1; -inline bool Expression_SingularOrList::_internal_has_value() const { - return this != internal_default_instance() && value_ != nullptr; -} -inline bool Expression_SingularOrList::has_value() const { - return _internal_has_value(); -} -inline void Expression_SingularOrList::clear_value() { - if (GetArenaForAllocation() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; -} -inline const ::substrait::Expression& Expression_SingularOrList::_internal_value() const { - const ::substrait::Expression* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& Expression_SingularOrList::value() const { - // @@protoc_insertion_point(field_get:substrait.Expression.SingularOrList.value) - return _internal_value(); -} -inline void Expression_SingularOrList::unsafe_arena_set_allocated_value( - ::substrait::Expression* value) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); - } - value_ = value; - if (value) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.SingularOrList.value) -} -inline ::substrait::Expression* Expression_SingularOrList::release_value() { - - ::substrait::Expression* temp = value_; - value_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* Expression_SingularOrList::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:substrait.Expression.SingularOrList.value) - - ::substrait::Expression* temp = value_; - value_ = nullptr; - return temp; -} -inline ::substrait::Expression* Expression_SingularOrList::_internal_mutable_value() { - - if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - value_ = p; - } - return value_; -} -inline ::substrait::Expression* Expression_SingularOrList::mutable_value() { - ::substrait::Expression* _msg = _internal_mutable_value(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.SingularOrList.value) - return _msg; -} -inline void Expression_SingularOrList::set_allocated_value(::substrait::Expression* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete value_; - } - if (value) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(value); - if (message_arena != submessage_arena) { - value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value, submessage_arena); - } - - } else { - - } - value_ = value; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.SingularOrList.value) -} - -// repeated .substrait.Expression options = 2; -inline int Expression_SingularOrList::_internal_options_size() const { - return options_.size(); -} -inline int Expression_SingularOrList::options_size() const { - return _internal_options_size(); -} -inline void Expression_SingularOrList::clear_options() { - options_.Clear(); -} -inline ::substrait::Expression* Expression_SingularOrList::mutable_options(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.SingularOrList.options) - return options_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* -Expression_SingularOrList::mutable_options() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.SingularOrList.options) - return &options_; -} -inline const ::substrait::Expression& Expression_SingularOrList::_internal_options(int index) const { - return options_.Get(index); -} -inline const ::substrait::Expression& Expression_SingularOrList::options(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.SingularOrList.options) - return _internal_options(index); -} -inline ::substrait::Expression* Expression_SingularOrList::_internal_add_options() { - return options_.Add(); -} -inline ::substrait::Expression* Expression_SingularOrList::add_options() { - ::substrait::Expression* _add = _internal_add_options(); - // @@protoc_insertion_point(field_add:substrait.Expression.SingularOrList.options) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& -Expression_SingularOrList::options() const { - // @@protoc_insertion_point(field_list:substrait.Expression.SingularOrList.options) - return options_; -} - -// ------------------------------------------------------------------- - -// Expression_MultiOrList_Record - -// repeated .substrait.Expression fields = 1; -inline int Expression_MultiOrList_Record::_internal_fields_size() const { - return fields_.size(); -} -inline int Expression_MultiOrList_Record::fields_size() const { - return _internal_fields_size(); -} -inline void Expression_MultiOrList_Record::clear_fields() { - fields_.Clear(); -} -inline ::substrait::Expression* Expression_MultiOrList_Record::mutable_fields(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.MultiOrList.Record.fields) - return fields_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* -Expression_MultiOrList_Record::mutable_fields() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MultiOrList.Record.fields) - return &fields_; -} -inline const ::substrait::Expression& Expression_MultiOrList_Record::_internal_fields(int index) const { - return fields_.Get(index); -} -inline const ::substrait::Expression& Expression_MultiOrList_Record::fields(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.MultiOrList.Record.fields) - return _internal_fields(index); -} -inline ::substrait::Expression* Expression_MultiOrList_Record::_internal_add_fields() { - return fields_.Add(); -} -inline ::substrait::Expression* Expression_MultiOrList_Record::add_fields() { - ::substrait::Expression* _add = _internal_add_fields(); - // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.Record.fields) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& -Expression_MultiOrList_Record::fields() const { - // @@protoc_insertion_point(field_list:substrait.Expression.MultiOrList.Record.fields) - return fields_; -} - -// ------------------------------------------------------------------- - -// Expression_MultiOrList - -// repeated .substrait.Expression value = 1; -inline int Expression_MultiOrList::_internal_value_size() const { - return value_.size(); -} -inline int Expression_MultiOrList::value_size() const { - return _internal_value_size(); -} -inline void Expression_MultiOrList::clear_value() { - value_.Clear(); -} -inline ::substrait::Expression* Expression_MultiOrList::mutable_value(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.MultiOrList.value) - return value_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* -Expression_MultiOrList::mutable_value() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MultiOrList.value) - return &value_; -} -inline const ::substrait::Expression& Expression_MultiOrList::_internal_value(int index) const { - return value_.Get(index); -} -inline const ::substrait::Expression& Expression_MultiOrList::value(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.MultiOrList.value) - return _internal_value(index); -} -inline ::substrait::Expression* Expression_MultiOrList::_internal_add_value() { - return value_.Add(); -} -inline ::substrait::Expression* Expression_MultiOrList::add_value() { - ::substrait::Expression* _add = _internal_add_value(); - // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.value) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& -Expression_MultiOrList::value() const { - // @@protoc_insertion_point(field_list:substrait.Expression.MultiOrList.value) - return value_; -} - -// repeated .substrait.Expression.MultiOrList.Record options = 2; -inline int Expression_MultiOrList::_internal_options_size() const { - return options_.size(); -} -inline int Expression_MultiOrList::options_size() const { - return _internal_options_size(); -} -inline void Expression_MultiOrList::clear_options() { - options_.Clear(); -} -inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::mutable_options(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.MultiOrList.options) - return options_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >* -Expression_MultiOrList::mutable_options() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MultiOrList.options) - return &options_; -} -inline const ::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::_internal_options(int index) const { - return options_.Get(index); -} -inline const ::substrait::Expression_MultiOrList_Record& Expression_MultiOrList::options(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.MultiOrList.options) - return _internal_options(index); -} -inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::_internal_add_options() { - return options_.Add(); -} -inline ::substrait::Expression_MultiOrList_Record* Expression_MultiOrList::add_options() { - ::substrait::Expression_MultiOrList_Record* _add = _internal_add_options(); - // @@protoc_insertion_point(field_add:substrait.Expression.MultiOrList.options) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MultiOrList_Record >& -Expression_MultiOrList::options() const { - // @@protoc_insertion_point(field_list:substrait.Expression.MultiOrList.options) - return options_; -} - -// ------------------------------------------------------------------- - -// Expression_EmbeddedFunction_PythonPickleFunction - -// bytes function = 1; -inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_function() { - function_.ClearToEmpty(); -} -inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::function() const { - // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) - return _internal_function(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Expression_EmbeddedFunction_PythonPickleFunction::set_function(ArgT0&& arg0, ArgT... args) { - - function_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) -} -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_function() { - std::string* _s = _internal_mutable_function(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) - return _s; -} -inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_function() const { - return function_.Get(); -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::_internal_set_function(const std::string& value) { - - function_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_mutable_function() { - - return function_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::release_function() { - // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) - return function_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_allocated_function(std::string* function) { - if (function != nullptr) { - - } else { - - } - function_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), function, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (function_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - function_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.PythonPickleFunction.function) -} - -// repeated string prerequisite = 2; -inline int Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite_size() const { - return prerequisite_.size(); -} -inline int Expression_EmbeddedFunction_PythonPickleFunction::prerequisite_size() const { - return _internal_prerequisite_size(); -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::clear_prerequisite() { - prerequisite_.Clear(); -} -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite() { - std::string* _s = _internal_add_prerequisite(); - // @@protoc_insertion_point(field_add_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return _s; -} -inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::_internal_prerequisite(int index) const { - return prerequisite_.Get(index); -} -inline const std::string& Expression_EmbeddedFunction_PythonPickleFunction::prerequisite(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return _internal_prerequisite(index); -} -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return prerequisite_.Mutable(index); -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const std::string& value) { - prerequisite_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, std::string&& value) { - prerequisite_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - prerequisite_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::set_prerequisite(int index, const char* value, size_t size) { - prerequisite_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) -} -inline std::string* Expression_EmbeddedFunction_PythonPickleFunction::_internal_add_prerequisite() { - return prerequisite_.Add(); -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const std::string& value) { - prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(std::string&& value) { - prerequisite_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value) { - GOOGLE_DCHECK(value != nullptr); - prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_PythonPickleFunction::add_prerequisite(const char* value, size_t size) { - prerequisite_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Expression_EmbeddedFunction_PythonPickleFunction::prerequisite() const { - // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return prerequisite_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Expression_EmbeddedFunction_PythonPickleFunction::mutable_prerequisite() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.EmbeddedFunction.PythonPickleFunction.prerequisite) - return &prerequisite_; -} - -// ------------------------------------------------------------------- - -// Expression_EmbeddedFunction_WebAssemblyFunction - -// bytes script = 1; -inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_script() { - script_.ClearToEmpty(); -} -inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::script() const { - // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) - return _internal_script(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Expression_EmbeddedFunction_WebAssemblyFunction::set_script(ArgT0&& arg0, ArgT... args) { - - script_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) -} -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_script() { - std::string* _s = _internal_mutable_script(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) - return _s; -} -inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_script() const { - return script_.Get(); -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::_internal_set_script(const std::string& value) { - - script_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_mutable_script() { - - return script_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::release_script() { - // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) - return script_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_allocated_script(std::string* script) { - if (script != nullptr) { - - } else { - - } - script_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), script, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (script_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - script_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.script) -} - -// repeated string prerequisite = 2; -inline int Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite_size() const { - return prerequisite_.size(); -} -inline int Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite_size() const { - return _internal_prerequisite_size(); -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::clear_prerequisite() { - prerequisite_.Clear(); -} -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite() { - std::string* _s = _internal_add_prerequisite(); - // @@protoc_insertion_point(field_add_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return _s; -} -inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::_internal_prerequisite(int index) const { - return prerequisite_.Get(index); -} -inline const std::string& Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return _internal_prerequisite(index); -} -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return prerequisite_.Mutable(index); -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const std::string& value) { - prerequisite_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, std::string&& value) { - prerequisite_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - prerequisite_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::set_prerequisite(int index, const char* value, size_t size) { - prerequisite_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) -} -inline std::string* Expression_EmbeddedFunction_WebAssemblyFunction::_internal_add_prerequisite() { - return prerequisite_.Add(); -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const std::string& value) { - prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(std::string&& value) { - prerequisite_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value) { - GOOGLE_DCHECK(value != nullptr); - prerequisite_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) -} -inline void Expression_EmbeddedFunction_WebAssemblyFunction::add_prerequisite(const char* value, size_t size) { - prerequisite_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Expression_EmbeddedFunction_WebAssemblyFunction::prerequisite() const { - // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return prerequisite_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Expression_EmbeddedFunction_WebAssemblyFunction::mutable_prerequisite() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.EmbeddedFunction.WebAssemblyFunction.prerequisite) - return &prerequisite_; -} - -// ------------------------------------------------------------------- - -// Expression_EmbeddedFunction - -// repeated .substrait.Expression arguments = 1; -inline int Expression_EmbeddedFunction::_internal_arguments_size() const { - return arguments_.size(); -} -inline int Expression_EmbeddedFunction::arguments_size() const { - return _internal_arguments_size(); -} -inline void Expression_EmbeddedFunction::clear_arguments() { - arguments_.Clear(); -} -inline ::substrait::Expression* Expression_EmbeddedFunction::mutable_arguments(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.arguments) - return arguments_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* -Expression_EmbeddedFunction::mutable_arguments() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.EmbeddedFunction.arguments) - return &arguments_; -} -inline const ::substrait::Expression& Expression_EmbeddedFunction::_internal_arguments(int index) const { - return arguments_.Get(index); -} -inline const ::substrait::Expression& Expression_EmbeddedFunction::arguments(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.arguments) - return _internal_arguments(index); -} -inline ::substrait::Expression* Expression_EmbeddedFunction::_internal_add_arguments() { - return arguments_.Add(); -} -inline ::substrait::Expression* Expression_EmbeddedFunction::add_arguments() { - ::substrait::Expression* _add = _internal_add_arguments(); - // @@protoc_insertion_point(field_add:substrait.Expression.EmbeddedFunction.arguments) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& -Expression_EmbeddedFunction::arguments() const { - // @@protoc_insertion_point(field_list:substrait.Expression.EmbeddedFunction.arguments) - return arguments_; -} - -// .substrait.Type output_type = 2; -inline bool Expression_EmbeddedFunction::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; -} -inline bool Expression_EmbeddedFunction::has_output_type() const { - return _internal_has_output_type(); -} -inline const ::substrait::Type& Expression_EmbeddedFunction::_internal_output_type() const { - const ::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Type_default_instance_); -} -inline const ::substrait::Type& Expression_EmbeddedFunction::output_type() const { - // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.output_type) - return _internal_output_type(); -} -inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_output_type( - ::substrait::Type* output_type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - output_type_ = output_type; - if (output_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.EmbeddedFunction.output_type) -} -inline ::substrait::Type* Expression_EmbeddedFunction::release_output_type() { - - ::substrait::Type* temp = output_type_; - output_type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Type* Expression_EmbeddedFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.output_type) - - ::substrait::Type* temp = output_type_; - output_type_ = nullptr; - return temp; -} -inline ::substrait::Type* Expression_EmbeddedFunction::_internal_mutable_output_type() { - - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); - output_type_ = p; - } - return output_type_; -} -inline ::substrait::Type* Expression_EmbeddedFunction::mutable_output_type() { - ::substrait::Type* _msg = _internal_mutable_output_type(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.output_type) - return _msg; -} -inline void Expression_EmbeddedFunction::set_allocated_output_type(::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - if (output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); - if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); - } - - } else { - - } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.EmbeddedFunction.output_type) -} - -// .substrait.Expression.EmbeddedFunction.PythonPickleFunction python_pickle_function = 3; -inline bool Expression_EmbeddedFunction::_internal_has_python_pickle_function() const { - return kind_case() == kPythonPickleFunction; -} -inline bool Expression_EmbeddedFunction::has_python_pickle_function() const { - return _internal_has_python_pickle_function(); -} -inline void Expression_EmbeddedFunction::set_has_python_pickle_function() { - _oneof_case_[0] = kPythonPickleFunction; -} -inline void Expression_EmbeddedFunction::clear_python_pickle_function() { - if (_internal_has_python_pickle_function()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.python_pickle_function_; - } - clear_has_kind(); - } -} -inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::release_python_pickle_function() { - // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.python_pickle_function) - if (_internal_has_python_pickle_function()) { - clear_has_kind(); - ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.python_pickle_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::_internal_python_pickle_function() const { - return _internal_has_python_pickle_function() - ? *kind_.python_pickle_function_ - : reinterpret_cast< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction&>(::substrait::_Expression_EmbeddedFunction_PythonPickleFunction_default_instance_); -} -inline const ::substrait::Expression_EmbeddedFunction_PythonPickleFunction& Expression_EmbeddedFunction::python_pickle_function() const { - // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.python_pickle_function) - return _internal_python_pickle_function(); -} -inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::unsafe_arena_release_python_pickle_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.EmbeddedFunction.python_pickle_function) - if (_internal_has_python_pickle_function()) { - clear_has_kind(); - ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* temp = kind_.python_pickle_function_; - kind_.python_pickle_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_python_pickle_function(::substrait::Expression_EmbeddedFunction_PythonPickleFunction* python_pickle_function) { - clear_kind(); - if (python_pickle_function) { - set_has_python_pickle_function(); - kind_.python_pickle_function_ = python_pickle_function; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.EmbeddedFunction.python_pickle_function) -} -inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::_internal_mutable_python_pickle_function() { - if (!_internal_has_python_pickle_function()) { - clear_kind(); - set_has_python_pickle_function(); - kind_.python_pickle_function_ = CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_PythonPickleFunction >(GetArenaForAllocation()); - } - return kind_.python_pickle_function_; -} -inline ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* Expression_EmbeddedFunction::mutable_python_pickle_function() { - ::substrait::Expression_EmbeddedFunction_PythonPickleFunction* _msg = _internal_mutable_python_pickle_function(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.python_pickle_function) - return _msg; -} - -// .substrait.Expression.EmbeddedFunction.WebAssemblyFunction web_assembly_function = 4; -inline bool Expression_EmbeddedFunction::_internal_has_web_assembly_function() const { - return kind_case() == kWebAssemblyFunction; -} -inline bool Expression_EmbeddedFunction::has_web_assembly_function() const { - return _internal_has_web_assembly_function(); -} -inline void Expression_EmbeddedFunction::set_has_web_assembly_function() { - _oneof_case_[0] = kWebAssemblyFunction; -} -inline void Expression_EmbeddedFunction::clear_web_assembly_function() { - if (_internal_has_web_assembly_function()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.web_assembly_function_; - } - clear_has_kind(); - } -} -inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::release_web_assembly_function() { - // @@protoc_insertion_point(field_release:substrait.Expression.EmbeddedFunction.web_assembly_function) - if (_internal_has_web_assembly_function()) { - clear_has_kind(); - ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.web_assembly_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::_internal_web_assembly_function() const { - return _internal_has_web_assembly_function() - ? *kind_.web_assembly_function_ - : reinterpret_cast< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction&>(::substrait::_Expression_EmbeddedFunction_WebAssemblyFunction_default_instance_); -} -inline const ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction& Expression_EmbeddedFunction::web_assembly_function() const { - // @@protoc_insertion_point(field_get:substrait.Expression.EmbeddedFunction.web_assembly_function) - return _internal_web_assembly_function(); -} -inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::unsafe_arena_release_web_assembly_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.EmbeddedFunction.web_assembly_function) - if (_internal_has_web_assembly_function()) { - clear_has_kind(); - ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* temp = kind_.web_assembly_function_; - kind_.web_assembly_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_EmbeddedFunction::unsafe_arena_set_allocated_web_assembly_function(::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* web_assembly_function) { - clear_kind(); - if (web_assembly_function) { - set_has_web_assembly_function(); - kind_.web_assembly_function_ = web_assembly_function; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.EmbeddedFunction.web_assembly_function) -} -inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::_internal_mutable_web_assembly_function() { - if (!_internal_has_web_assembly_function()) { - clear_kind(); - set_has_web_assembly_function(); - kind_.web_assembly_function_ = CreateMaybeMessage< ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction >(GetArenaForAllocation()); - } - return kind_.web_assembly_function_; -} -inline ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* Expression_EmbeddedFunction::mutable_web_assembly_function() { - ::substrait::Expression_EmbeddedFunction_WebAssemblyFunction* _msg = _internal_mutable_web_assembly_function(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.EmbeddedFunction.web_assembly_function) - return _msg; -} - -inline bool Expression_EmbeddedFunction::has_kind() const { - return kind_case() != KIND_NOT_SET; -} -inline void Expression_EmbeddedFunction::clear_has_kind() { - _oneof_case_[0] = KIND_NOT_SET; -} -inline Expression_EmbeddedFunction::KindCase Expression_EmbeddedFunction::kind_case() const { - return Expression_EmbeddedFunction::KindCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Expression_ReferenceSegment_MapKey - -// .substrait.Expression.Literal map_key = 1; -inline bool Expression_ReferenceSegment_MapKey::_internal_has_map_key() const { - return this != internal_default_instance() && map_key_ != nullptr; -} -inline bool Expression_ReferenceSegment_MapKey::has_map_key() const { - return _internal_has_map_key(); -} -inline void Expression_ReferenceSegment_MapKey::clear_map_key() { - if (GetArenaForAllocation() == nullptr && map_key_ != nullptr) { - delete map_key_; - } - map_key_ = nullptr; -} -inline const ::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::_internal_map_key() const { - const ::substrait::Expression_Literal* p = map_key_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_Literal_default_instance_); -} -inline const ::substrait::Expression_Literal& Expression_ReferenceSegment_MapKey::map_key() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.MapKey.map_key) - return _internal_map_key(); -} -inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_map_key( - ::substrait::Expression_Literal* map_key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(map_key_); - } - map_key_ = map_key; - if (map_key) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.MapKey.map_key) -} -inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::release_map_key() { - - ::substrait::Expression_Literal* temp = map_key_; - map_key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::unsafe_arena_release_map_key() { - // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.MapKey.map_key) - - ::substrait::Expression_Literal* temp = map_key_; - map_key_ = nullptr; - return temp; -} -inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::_internal_mutable_map_key() { - - if (map_key_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_Literal>(GetArenaForAllocation()); - map_key_ = p; - } - return map_key_; -} -inline ::substrait::Expression_Literal* Expression_ReferenceSegment_MapKey::mutable_map_key() { - ::substrait::Expression_Literal* _msg = _internal_mutable_map_key(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.MapKey.map_key) - return _msg; -} -inline void Expression_ReferenceSegment_MapKey::set_allocated_map_key(::substrait::Expression_Literal* map_key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete map_key_; - } - if (map_key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_Literal>::GetOwningArena(map_key); - if (message_arena != submessage_arena) { - map_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, map_key, submessage_arena); - } - - } else { - - } - map_key_ = map_key; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.MapKey.map_key) -} - -// .substrait.Expression.ReferenceSegment child = 2; -inline bool Expression_ReferenceSegment_MapKey::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool Expression_ReferenceSegment_MapKey::has_child() const { - return _internal_has_child(); -} -inline void Expression_ReferenceSegment_MapKey::clear_child() { - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::_internal_child() const { - const ::substrait::Expression_ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_ReferenceSegment_default_instance_); -} -inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_MapKey::child() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.MapKey.child) - return _internal_child(); -} -inline void Expression_ReferenceSegment_MapKey::unsafe_arena_set_allocated_child( - ::substrait::Expression_ReferenceSegment* child) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.MapKey.child) -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::release_child() { - - ::substrait::Expression_ReferenceSegment* temp = child_; - child_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.MapKey.child) - - ::substrait::Expression_ReferenceSegment* temp = child_; - child_ = nullptr; - return temp; -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArenaForAllocation()); - child_ = p; - } - return child_; -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_MapKey::mutable_child() { - ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_child(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.MapKey.child) - return _msg; -} -inline void Expression_ReferenceSegment_MapKey::set_allocated_child(::substrait::Expression_ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.MapKey.child) -} - -// ------------------------------------------------------------------- - -// Expression_ReferenceSegment_StructField - -// int32 field = 1; -inline void Expression_ReferenceSegment_StructField::clear_field() { - field_ = 0; -} -inline int32_t Expression_ReferenceSegment_StructField::_internal_field() const { - return field_; -} -inline int32_t Expression_ReferenceSegment_StructField::field() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.StructField.field) - return _internal_field(); -} -inline void Expression_ReferenceSegment_StructField::_internal_set_field(int32_t value) { - - field_ = value; -} -inline void Expression_ReferenceSegment_StructField::set_field(int32_t value) { - _internal_set_field(value); - // @@protoc_insertion_point(field_set:substrait.Expression.ReferenceSegment.StructField.field) -} - -// .substrait.Expression.ReferenceSegment child = 2; -inline bool Expression_ReferenceSegment_StructField::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool Expression_ReferenceSegment_StructField::has_child() const { - return _internal_has_child(); -} -inline void Expression_ReferenceSegment_StructField::clear_child() { - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::_internal_child() const { - const ::substrait::Expression_ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_ReferenceSegment_default_instance_); -} -inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_StructField::child() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.StructField.child) - return _internal_child(); -} -inline void Expression_ReferenceSegment_StructField::unsafe_arena_set_allocated_child( - ::substrait::Expression_ReferenceSegment* child) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.StructField.child) -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::release_child() { - - ::substrait::Expression_ReferenceSegment* temp = child_; - child_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.StructField.child) - - ::substrait::Expression_ReferenceSegment* temp = child_; - child_ = nullptr; - return temp; -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArenaForAllocation()); - child_ = p; - } - return child_; -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_StructField::mutable_child() { - ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_child(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.StructField.child) - return _msg; -} -inline void Expression_ReferenceSegment_StructField::set_allocated_child(::substrait::Expression_ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.StructField.child) -} - -// ------------------------------------------------------------------- - -// Expression_ReferenceSegment_ListElement - -// int32 offset = 1; -inline void Expression_ReferenceSegment_ListElement::clear_offset() { - offset_ = 0; -} -inline int32_t Expression_ReferenceSegment_ListElement::_internal_offset() const { - return offset_; -} -inline int32_t Expression_ReferenceSegment_ListElement::offset() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.ListElement.offset) - return _internal_offset(); -} -inline void Expression_ReferenceSegment_ListElement::_internal_set_offset(int32_t value) { - - offset_ = value; -} -inline void Expression_ReferenceSegment_ListElement::set_offset(int32_t value) { - _internal_set_offset(value); - // @@protoc_insertion_point(field_set:substrait.Expression.ReferenceSegment.ListElement.offset) -} - -// .substrait.Expression.ReferenceSegment child = 2; -inline bool Expression_ReferenceSegment_ListElement::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool Expression_ReferenceSegment_ListElement::has_child() const { - return _internal_has_child(); -} -inline void Expression_ReferenceSegment_ListElement::clear_child() { - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::_internal_child() const { - const ::substrait::Expression_ReferenceSegment* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_ReferenceSegment_default_instance_); -} -inline const ::substrait::Expression_ReferenceSegment& Expression_ReferenceSegment_ListElement::child() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.ListElement.child) - return _internal_child(); -} -inline void Expression_ReferenceSegment_ListElement::unsafe_arena_set_allocated_child( - ::substrait::Expression_ReferenceSegment* child) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.ListElement.child) -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::release_child() { - - ::substrait::Expression_ReferenceSegment* temp = child_; - child_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.ListElement.child) - - ::substrait::Expression_ReferenceSegment* temp = child_; - child_ = nullptr; - return temp; -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_ReferenceSegment>(GetArenaForAllocation()); - child_ = p; - } - return child_; -} -inline ::substrait::Expression_ReferenceSegment* Expression_ReferenceSegment_ListElement::mutable_child() { - ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_child(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.ListElement.child) - return _msg; -} -inline void Expression_ReferenceSegment_ListElement::set_allocated_child(::substrait::Expression_ReferenceSegment* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_ReferenceSegment>::GetOwningArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.ReferenceSegment.ListElement.child) -} - -// ------------------------------------------------------------------- - -// Expression_ReferenceSegment - -// .substrait.Expression.ReferenceSegment.MapKey map_key = 1; -inline bool Expression_ReferenceSegment::_internal_has_map_key() const { - return reference_type_case() == kMapKey; -} -inline bool Expression_ReferenceSegment::has_map_key() const { - return _internal_has_map_key(); -} -inline void Expression_ReferenceSegment::set_has_map_key() { - _oneof_case_[0] = kMapKey; -} -inline void Expression_ReferenceSegment::clear_map_key() { - if (_internal_has_map_key()) { - if (GetArenaForAllocation() == nullptr) { - delete reference_type_.map_key_; - } - clear_has_reference_type(); - } -} -inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::release_map_key() { - // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.map_key) - if (_internal_has_map_key()) { - clear_has_reference_type(); - ::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.map_key_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::_internal_map_key() const { - return _internal_has_map_key() - ? *reference_type_.map_key_ - : reinterpret_cast< ::substrait::Expression_ReferenceSegment_MapKey&>(::substrait::_Expression_ReferenceSegment_MapKey_default_instance_); -} -inline const ::substrait::Expression_ReferenceSegment_MapKey& Expression_ReferenceSegment::map_key() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.map_key) - return _internal_map_key(); -} -inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::unsafe_arena_release_map_key() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.ReferenceSegment.map_key) - if (_internal_has_map_key()) { - clear_has_reference_type(); - ::substrait::Expression_ReferenceSegment_MapKey* temp = reference_type_.map_key_; - reference_type_.map_key_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_map_key(::substrait::Expression_ReferenceSegment_MapKey* map_key) { - clear_reference_type(); - if (map_key) { - set_has_map_key(); - reference_type_.map_key_ = map_key; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.map_key) -} -inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::_internal_mutable_map_key() { - if (!_internal_has_map_key()) { - clear_reference_type(); - set_has_map_key(); - reference_type_.map_key_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_MapKey >(GetArenaForAllocation()); - } - return reference_type_.map_key_; -} -inline ::substrait::Expression_ReferenceSegment_MapKey* Expression_ReferenceSegment::mutable_map_key() { - ::substrait::Expression_ReferenceSegment_MapKey* _msg = _internal_mutable_map_key(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.map_key) - return _msg; -} - -// .substrait.Expression.ReferenceSegment.StructField struct_field = 2; -inline bool Expression_ReferenceSegment::_internal_has_struct_field() const { - return reference_type_case() == kStructField; -} -inline bool Expression_ReferenceSegment::has_struct_field() const { - return _internal_has_struct_field(); -} -inline void Expression_ReferenceSegment::set_has_struct_field() { - _oneof_case_[0] = kStructField; -} -inline void Expression_ReferenceSegment::clear_struct_field() { - if (_internal_has_struct_field()) { - if (GetArenaForAllocation() == nullptr) { - delete reference_type_.struct_field_; - } - clear_has_reference_type(); - } -} -inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::release_struct_field() { - // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.struct_field) - if (_internal_has_struct_field()) { - clear_has_reference_type(); - ::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.struct_field_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::_internal_struct_field() const { - return _internal_has_struct_field() - ? *reference_type_.struct_field_ - : reinterpret_cast< ::substrait::Expression_ReferenceSegment_StructField&>(::substrait::_Expression_ReferenceSegment_StructField_default_instance_); -} -inline const ::substrait::Expression_ReferenceSegment_StructField& Expression_ReferenceSegment::struct_field() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.struct_field) - return _internal_struct_field(); -} -inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::unsafe_arena_release_struct_field() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.ReferenceSegment.struct_field) - if (_internal_has_struct_field()) { - clear_has_reference_type(); - ::substrait::Expression_ReferenceSegment_StructField* temp = reference_type_.struct_field_; - reference_type_.struct_field_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_struct_field(::substrait::Expression_ReferenceSegment_StructField* struct_field) { - clear_reference_type(); - if (struct_field) { - set_has_struct_field(); - reference_type_.struct_field_ = struct_field; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.struct_field) -} -inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::_internal_mutable_struct_field() { - if (!_internal_has_struct_field()) { - clear_reference_type(); - set_has_struct_field(); - reference_type_.struct_field_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_StructField >(GetArenaForAllocation()); - } - return reference_type_.struct_field_; -} -inline ::substrait::Expression_ReferenceSegment_StructField* Expression_ReferenceSegment::mutable_struct_field() { - ::substrait::Expression_ReferenceSegment_StructField* _msg = _internal_mutable_struct_field(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.struct_field) - return _msg; -} - -// .substrait.Expression.ReferenceSegment.ListElement list_element = 3; -inline bool Expression_ReferenceSegment::_internal_has_list_element() const { - return reference_type_case() == kListElement; -} -inline bool Expression_ReferenceSegment::has_list_element() const { - return _internal_has_list_element(); -} -inline void Expression_ReferenceSegment::set_has_list_element() { - _oneof_case_[0] = kListElement; -} -inline void Expression_ReferenceSegment::clear_list_element() { - if (_internal_has_list_element()) { - if (GetArenaForAllocation() == nullptr) { - delete reference_type_.list_element_; - } - clear_has_reference_type(); - } -} -inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::release_list_element() { - // @@protoc_insertion_point(field_release:substrait.Expression.ReferenceSegment.list_element) - if (_internal_has_list_element()) { - clear_has_reference_type(); - ::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.list_element_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::_internal_list_element() const { - return _internal_has_list_element() - ? *reference_type_.list_element_ - : reinterpret_cast< ::substrait::Expression_ReferenceSegment_ListElement&>(::substrait::_Expression_ReferenceSegment_ListElement_default_instance_); -} -inline const ::substrait::Expression_ReferenceSegment_ListElement& Expression_ReferenceSegment::list_element() const { - // @@protoc_insertion_point(field_get:substrait.Expression.ReferenceSegment.list_element) - return _internal_list_element(); -} -inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::unsafe_arena_release_list_element() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.ReferenceSegment.list_element) - if (_internal_has_list_element()) { - clear_has_reference_type(); - ::substrait::Expression_ReferenceSegment_ListElement* temp = reference_type_.list_element_; - reference_type_.list_element_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_ReferenceSegment::unsafe_arena_set_allocated_list_element(::substrait::Expression_ReferenceSegment_ListElement* list_element) { - clear_reference_type(); - if (list_element) { - set_has_list_element(); - reference_type_.list_element_ = list_element; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.ReferenceSegment.list_element) -} -inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::_internal_mutable_list_element() { - if (!_internal_has_list_element()) { - clear_reference_type(); - set_has_list_element(); - reference_type_.list_element_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment_ListElement >(GetArenaForAllocation()); - } - return reference_type_.list_element_; -} -inline ::substrait::Expression_ReferenceSegment_ListElement* Expression_ReferenceSegment::mutable_list_element() { - ::substrait::Expression_ReferenceSegment_ListElement* _msg = _internal_mutable_list_element(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.ReferenceSegment.list_element) - return _msg; -} - -inline bool Expression_ReferenceSegment::has_reference_type() const { - return reference_type_case() != REFERENCE_TYPE_NOT_SET; -} -inline void Expression_ReferenceSegment::clear_has_reference_type() { - _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; -} -inline Expression_ReferenceSegment::ReferenceTypeCase Expression_ReferenceSegment::reference_type_case() const { - return Expression_ReferenceSegment::ReferenceTypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Expression_MaskExpression_Select - -// .substrait.Expression.MaskExpression.StructSelect struct = 1; -inline bool Expression_MaskExpression_Select::_internal_has_struct_() const { - return type_case() == kStruct; -} -inline bool Expression_MaskExpression_Select::has_struct_() const { - return _internal_has_struct_(); -} -inline void Expression_MaskExpression_Select::set_has_struct_() { - _oneof_case_[0] = kStruct; -} -inline void Expression_MaskExpression_Select::clear_struct_() { - if (_internal_has_struct_()) { - if (GetArenaForAllocation() == nullptr) { - delete type_.struct__; - } - clear_has_type(); - } -} -inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::release_struct_() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.Select.struct) - if (_internal_has_struct_()) { - clear_has_type(); - ::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - type_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::_internal_struct_() const { - return _internal_has_struct_() - ? *type_.struct__ - : reinterpret_cast< ::substrait::Expression_MaskExpression_StructSelect&>(::substrait::_Expression_MaskExpression_StructSelect_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression_Select::struct_() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.Select.struct) - return _internal_struct_(); -} -inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.Select.struct) - if (_internal_has_struct_()) { - clear_has_type(); - ::substrait::Expression_MaskExpression_StructSelect* temp = type_.struct__; - type_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_struct_(::substrait::Expression_MaskExpression_StructSelect* struct_) { - clear_type(); - if (struct_) { - set_has_struct_(); - type_.struct__ = struct_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.Select.struct) -} -inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::_internal_mutable_struct_() { - if (!_internal_has_struct_()) { - clear_type(); - set_has_struct_(); - type_.struct__ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_StructSelect >(GetArenaForAllocation()); - } - return type_.struct__; -} -inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression_Select::mutable_struct_() { - ::substrait::Expression_MaskExpression_StructSelect* _msg = _internal_mutable_struct_(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.struct) - return _msg; -} - -// .substrait.Expression.MaskExpression.ListSelect list = 2; -inline bool Expression_MaskExpression_Select::_internal_has_list() const { - return type_case() == kList; -} -inline bool Expression_MaskExpression_Select::has_list() const { - return _internal_has_list(); -} -inline void Expression_MaskExpression_Select::set_has_list() { - _oneof_case_[0] = kList; -} -inline void Expression_MaskExpression_Select::clear_list() { - if (_internal_has_list()) { - if (GetArenaForAllocation() == nullptr) { - delete type_.list_; - } - clear_has_type(); - } -} -inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::release_list() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.Select.list) - if (_internal_has_list()) { - clear_has_type(); - ::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - type_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::_internal_list() const { - return _internal_has_list() - ? *type_.list_ - : reinterpret_cast< ::substrait::Expression_MaskExpression_ListSelect&>(::substrait::_Expression_MaskExpression_ListSelect_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_ListSelect& Expression_MaskExpression_Select::list() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.Select.list) - return _internal_list(); -} -inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.Select.list) - if (_internal_has_list()) { - clear_has_type(); - ::substrait::Expression_MaskExpression_ListSelect* temp = type_.list_; - type_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_list(::substrait::Expression_MaskExpression_ListSelect* list) { - clear_type(); - if (list) { - set_has_list(); - type_.list_ = list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.Select.list) -} -inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::_internal_mutable_list() { - if (!_internal_has_list()) { - clear_type(); - set_has_list(); - type_.list_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect >(GetArenaForAllocation()); - } - return type_.list_; -} -inline ::substrait::Expression_MaskExpression_ListSelect* Expression_MaskExpression_Select::mutable_list() { - ::substrait::Expression_MaskExpression_ListSelect* _msg = _internal_mutable_list(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.list) - return _msg; -} - -// .substrait.Expression.MaskExpression.MapSelect map = 3; -inline bool Expression_MaskExpression_Select::_internal_has_map() const { - return type_case() == kMap; -} -inline bool Expression_MaskExpression_Select::has_map() const { - return _internal_has_map(); -} -inline void Expression_MaskExpression_Select::set_has_map() { - _oneof_case_[0] = kMap; -} -inline void Expression_MaskExpression_Select::clear_map() { - if (_internal_has_map()) { - if (GetArenaForAllocation() == nullptr) { - delete type_.map_; - } - clear_has_type(); - } -} -inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::release_map() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.Select.map) - if (_internal_has_map()) { - clear_has_type(); - ::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - type_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::_internal_map() const { - return _internal_has_map() - ? *type_.map_ - : reinterpret_cast< ::substrait::Expression_MaskExpression_MapSelect&>(::substrait::_Expression_MaskExpression_MapSelect_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_MapSelect& Expression_MaskExpression_Select::map() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.Select.map) - return _internal_map(); -} -inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.Select.map) - if (_internal_has_map()) { - clear_has_type(); - ::substrait::Expression_MaskExpression_MapSelect* temp = type_.map_; - type_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_MaskExpression_Select::unsafe_arena_set_allocated_map(::substrait::Expression_MaskExpression_MapSelect* map) { - clear_type(); - if (map) { - set_has_map(); - type_.map_ = map; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.Select.map) -} -inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::_internal_mutable_map() { - if (!_internal_has_map()) { - clear_type(); - set_has_map(); - type_.map_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect >(GetArenaForAllocation()); - } - return type_.map_; -} -inline ::substrait::Expression_MaskExpression_MapSelect* Expression_MaskExpression_Select::mutable_map() { - ::substrait::Expression_MaskExpression_MapSelect* _msg = _internal_mutable_map(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.Select.map) - return _msg; -} - -inline bool Expression_MaskExpression_Select::has_type() const { - return type_case() != TYPE_NOT_SET; -} -inline void Expression_MaskExpression_Select::clear_has_type() { - _oneof_case_[0] = TYPE_NOT_SET; -} -inline Expression_MaskExpression_Select::TypeCase Expression_MaskExpression_Select::type_case() const { - return Expression_MaskExpression_Select::TypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Expression_MaskExpression_StructSelect - -// repeated .substrait.Expression.MaskExpression.StructItem struct_items = 1; -inline int Expression_MaskExpression_StructSelect::_internal_struct_items_size() const { - return struct_items_.size(); -} -inline int Expression_MaskExpression_StructSelect::struct_items_size() const { - return _internal_struct_items_size(); -} -inline void Expression_MaskExpression_StructSelect::clear_struct_items() { - struct_items_.Clear(); -} -inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::mutable_struct_items(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.StructSelect.struct_items) - return struct_items_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >* -Expression_MaskExpression_StructSelect::mutable_struct_items() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MaskExpression.StructSelect.struct_items) - return &struct_items_; -} -inline const ::substrait::Expression_MaskExpression_StructItem& Expression_MaskExpression_StructSelect::_internal_struct_items(int index) const { - return struct_items_.Get(index); -} -inline const ::substrait::Expression_MaskExpression_StructItem& Expression_MaskExpression_StructSelect::struct_items(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.StructSelect.struct_items) - return _internal_struct_items(index); -} -inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::_internal_add_struct_items() { - return struct_items_.Add(); -} -inline ::substrait::Expression_MaskExpression_StructItem* Expression_MaskExpression_StructSelect::add_struct_items() { - ::substrait::Expression_MaskExpression_StructItem* _add = _internal_add_struct_items(); - // @@protoc_insertion_point(field_add:substrait.Expression.MaskExpression.StructSelect.struct_items) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_StructItem >& -Expression_MaskExpression_StructSelect::struct_items() const { - // @@protoc_insertion_point(field_list:substrait.Expression.MaskExpression.StructSelect.struct_items) - return struct_items_; -} - -// ------------------------------------------------------------------- - -// Expression_MaskExpression_StructItem - -// int32 field = 1; -inline void Expression_MaskExpression_StructItem::clear_field() { - field_ = 0; -} -inline int32_t Expression_MaskExpression_StructItem::_internal_field() const { - return field_; -} -inline int32_t Expression_MaskExpression_StructItem::field() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.StructItem.field) - return _internal_field(); -} -inline void Expression_MaskExpression_StructItem::_internal_set_field(int32_t value) { - - field_ = value; -} -inline void Expression_MaskExpression_StructItem::set_field(int32_t value) { - _internal_set_field(value); - // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.StructItem.field) -} - -// .substrait.Expression.MaskExpression.Select child = 2; -inline bool Expression_MaskExpression_StructItem::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool Expression_MaskExpression_StructItem::has_child() const { - return _internal_has_child(); -} -inline void Expression_MaskExpression_StructItem::clear_child() { - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::_internal_child() const { - const ::substrait::Expression_MaskExpression_Select* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_MaskExpression_Select_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_StructItem::child() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.StructItem.child) - return _internal_child(); -} -inline void Expression_MaskExpression_StructItem::unsafe_arena_set_allocated_child( - ::substrait::Expression_MaskExpression_Select* child) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.StructItem.child) -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::release_child() { - - ::substrait::Expression_MaskExpression_Select* temp = child_; - child_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.StructItem.child) - - ::substrait::Expression_MaskExpression_Select* temp = child_; - child_ = nullptr; - return temp; -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArenaForAllocation()); - child_ = p; - } - return child_; -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_StructItem::mutable_child() { - ::substrait::Expression_MaskExpression_Select* _msg = _internal_mutable_child(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.StructItem.child) - return _msg; -} -inline void Expression_MaskExpression_StructItem::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_Select>::GetOwningArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.StructItem.child) -} - -// ------------------------------------------------------------------- - -// Expression_MaskExpression_ListSelect_ListSelectItem_ListElement - -// int32 field = 1; -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::clear_field() { - field_ = 0; -} -inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_field() const { - return field_; -} -inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::field() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field) - return _internal_field(); -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::_internal_set_field(int32_t value) { - - field_ = value; -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListElement::set_field(int32_t value) { - _internal_set_field(value); - // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement.field) -} - -// ------------------------------------------------------------------- - -// Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice - -// int32 start = 1; -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_start() { - start_ = 0; -} -inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_start() const { - return start_; -} -inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::start() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) - return _internal_start(); -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_start(int32_t value) { - - start_ = value; -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_start(int32_t value) { - _internal_set_start(value); - // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.start) -} - -// int32 end = 2; -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::clear_end() { - end_ = 0; -} -inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_end() const { - return end_; -} -inline int32_t Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::end() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) - return _internal_end(); -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::_internal_set_end(int32_t value) { - - end_ = value; -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice::set_end(int32_t value) { - _internal_set_end(value); - // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice.end) -} - -// ------------------------------------------------------------------- - -// Expression_MaskExpression_ListSelect_ListSelectItem - -// .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListElement item = 1; -inline bool Expression_MaskExpression_ListSelect_ListSelectItem::_internal_has_item() const { - return type_case() == kItem; -} -inline bool Expression_MaskExpression_ListSelect_ListSelectItem::has_item() const { - return _internal_has_item(); -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem::set_has_item() { - _oneof_case_[0] = kItem; -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_item() { - if (_internal_has_item()) { - if (GetArenaForAllocation() == nullptr) { - delete type_.item_; - } - clear_has_type(); - } -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::release_item() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) - if (_internal_has_item()) { - clear_has_type(); - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - type_.item_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::_internal_item() const { - return _internal_has_item() - ? *type_.item_ - : reinterpret_cast< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement&>(::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListElement_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement& Expression_MaskExpression_ListSelect_ListSelectItem::item() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) - return _internal_item(); -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_item() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) - if (_internal_has_item()) { - clear_has_type(); - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* temp = type_.item_; - type_.item_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_item(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* item) { - clear_type(); - if (item) { - set_has_item(); - type_.item_ = item; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::_internal_mutable_item() { - if (!_internal_has_item()) { - clear_type(); - set_has_item(); - type_.item_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement >(GetArenaForAllocation()); - } - return type_.item_; -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_item() { - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListElement* _msg = _internal_mutable_item(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.item) - return _msg; -} - -// .substrait.Expression.MaskExpression.ListSelect.ListSelectItem.ListSlice slice = 2; -inline bool Expression_MaskExpression_ListSelect_ListSelectItem::_internal_has_slice() const { - return type_case() == kSlice; -} -inline bool Expression_MaskExpression_ListSelect_ListSelectItem::has_slice() const { - return _internal_has_slice(); -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem::set_has_slice() { - _oneof_case_[0] = kSlice; -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_slice() { - if (_internal_has_slice()) { - if (GetArenaForAllocation() == nullptr) { - delete type_.slice_; - } - clear_has_type(); - } -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::release_slice() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) - if (_internal_has_slice()) { - clear_has_type(); - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - type_.slice_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::_internal_slice() const { - return _internal_has_slice() - ? *type_.slice_ - : reinterpret_cast< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice&>(::substrait::_Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice& Expression_MaskExpression_ListSelect_ListSelectItem::slice() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) - return _internal_slice(); -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_release_slice() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) - if (_internal_has_slice()) { - clear_has_type(); - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* temp = type_.slice_; - type_.slice_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem::unsafe_arena_set_allocated_slice(::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* slice) { - clear_type(); - if (slice) { - set_has_slice(); - type_.slice_ = slice; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::_internal_mutable_slice() { - if (!_internal_has_slice()) { - clear_type(); - set_has_slice(); - type_.slice_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice >(GetArenaForAllocation()); - } - return type_.slice_; -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* Expression_MaskExpression_ListSelect_ListSelectItem::mutable_slice() { - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem_ListSlice* _msg = _internal_mutable_slice(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.ListSelectItem.slice) - return _msg; -} - -inline bool Expression_MaskExpression_ListSelect_ListSelectItem::has_type() const { - return type_case() != TYPE_NOT_SET; -} -inline void Expression_MaskExpression_ListSelect_ListSelectItem::clear_has_type() { - _oneof_case_[0] = TYPE_NOT_SET; -} -inline Expression_MaskExpression_ListSelect_ListSelectItem::TypeCase Expression_MaskExpression_ListSelect_ListSelectItem::type_case() const { - return Expression_MaskExpression_ListSelect_ListSelectItem::TypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Expression_MaskExpression_ListSelect - -// repeated .substrait.Expression.MaskExpression.ListSelect.ListSelectItem selection = 1; -inline int Expression_MaskExpression_ListSelect::_internal_selection_size() const { - return selection_.size(); -} -inline int Expression_MaskExpression_ListSelect::selection_size() const { - return _internal_selection_size(); -} -inline void Expression_MaskExpression_ListSelect::clear_selection() { - selection_.Clear(); -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::mutable_selection(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.selection) - return selection_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >* -Expression_MaskExpression_ListSelect::mutable_selection() { - // @@protoc_insertion_point(field_mutable_list:substrait.Expression.MaskExpression.ListSelect.selection) - return &selection_; -} -inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& Expression_MaskExpression_ListSelect::_internal_selection(int index) const { - return selection_.Get(index); -} -inline const ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem& Expression_MaskExpression_ListSelect::selection(int index) const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.selection) - return _internal_selection(index); -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::_internal_add_selection() { - return selection_.Add(); -} -inline ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* Expression_MaskExpression_ListSelect::add_selection() { - ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem* _add = _internal_add_selection(); - // @@protoc_insertion_point(field_add:substrait.Expression.MaskExpression.ListSelect.selection) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_MaskExpression_ListSelect_ListSelectItem >& -Expression_MaskExpression_ListSelect::selection() const { - // @@protoc_insertion_point(field_list:substrait.Expression.MaskExpression.ListSelect.selection) - return selection_; -} - -// .substrait.Expression.MaskExpression.Select child = 2; -inline bool Expression_MaskExpression_ListSelect::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool Expression_MaskExpression_ListSelect::has_child() const { - return _internal_has_child(); -} -inline void Expression_MaskExpression_ListSelect::clear_child() { - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::_internal_child() const { - const ::substrait::Expression_MaskExpression_Select* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_MaskExpression_Select_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_ListSelect::child() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.ListSelect.child) - return _internal_child(); -} -inline void Expression_MaskExpression_ListSelect::unsafe_arena_set_allocated_child( - ::substrait::Expression_MaskExpression_Select* child) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.ListSelect.child) -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::release_child() { - - ::substrait::Expression_MaskExpression_Select* temp = child_; - child_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.ListSelect.child) - - ::substrait::Expression_MaskExpression_Select* temp = child_; - child_ = nullptr; - return temp; -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArenaForAllocation()); - child_ = p; - } - return child_; -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_ListSelect::mutable_child() { - ::substrait::Expression_MaskExpression_Select* _msg = _internal_mutable_child(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.ListSelect.child) - return _msg; -} -inline void Expression_MaskExpression_ListSelect::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_Select>::GetOwningArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.ListSelect.child) -} - -// ------------------------------------------------------------------- - -// Expression_MaskExpression_MapSelect_MapKey - -// string map_key = 1; -inline void Expression_MaskExpression_MapSelect_MapKey::clear_map_key() { - map_key_.ClearToEmpty(); -} -inline const std::string& Expression_MaskExpression_MapSelect_MapKey::map_key() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) - return _internal_map_key(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Expression_MaskExpression_MapSelect_MapKey::set_map_key(ArgT0&& arg0, ArgT... args) { - - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) -} -inline std::string* Expression_MaskExpression_MapSelect_MapKey::mutable_map_key() { - std::string* _s = _internal_mutable_map_key(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) - return _s; -} -inline const std::string& Expression_MaskExpression_MapSelect_MapKey::_internal_map_key() const { - return map_key_.Get(); -} -inline void Expression_MaskExpression_MapSelect_MapKey::_internal_set_map_key(const std::string& value) { - - map_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_MaskExpression_MapSelect_MapKey::_internal_mutable_map_key() { - - return map_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_MaskExpression_MapSelect_MapKey::release_map_key() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) - return map_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void Expression_MaskExpression_MapSelect_MapKey::set_allocated_map_key(std::string* map_key) { - if (map_key != nullptr) { - - } else { - - } - map_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (map_key_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - map_key_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.MapKey.map_key) -} - -// ------------------------------------------------------------------- - -// Expression_MaskExpression_MapSelect_MapKeyExpression - -// string map_key_expression = 1; -inline void Expression_MaskExpression_MapSelect_MapKeyExpression::clear_map_key_expression() { - map_key_expression_.ClearToEmpty(); -} -inline const std::string& Expression_MaskExpression_MapSelect_MapKeyExpression::map_key_expression() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) - return _internal_map_key_expression(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void Expression_MaskExpression_MapSelect_MapKeyExpression::set_map_key_expression(ArgT0&& arg0, ArgT... args) { - - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) -} -inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::mutable_map_key_expression() { - std::string* _s = _internal_mutable_map_key_expression(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) - return _s; -} -inline const std::string& Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_map_key_expression() const { - return map_key_expression_.Get(); -} -inline void Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_set_map_key_expression(const std::string& value) { - - map_key_expression_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::_internal_mutable_map_key_expression() { - - return map_key_expression_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* Expression_MaskExpression_MapSelect_MapKeyExpression::release_map_key_expression() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) - return map_key_expression_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void Expression_MaskExpression_MapSelect_MapKeyExpression::set_allocated_map_key_expression(std::string* map_key_expression) { - if (map_key_expression != nullptr) { - - } else { - - } - map_key_expression_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), map_key_expression, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (map_key_expression_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - map_key_expression_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.MapKeyExpression.map_key_expression) -} - -// ------------------------------------------------------------------- - -// Expression_MaskExpression_MapSelect - -// .substrait.Expression.MaskExpression.MapSelect.MapKey key = 1; -inline bool Expression_MaskExpression_MapSelect::_internal_has_key() const { - return select_case() == kKey; -} -inline bool Expression_MaskExpression_MapSelect::has_key() const { - return _internal_has_key(); -} -inline void Expression_MaskExpression_MapSelect::set_has_key() { - _oneof_case_[0] = kKey; -} -inline void Expression_MaskExpression_MapSelect::clear_key() { - if (_internal_has_key()) { - if (GetArenaForAllocation() == nullptr) { - delete select_.key_; - } - clear_has_select(); - } -} -inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::release_key() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.key) - if (_internal_has_key()) { - clear_has_select(); - ::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - select_.key_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::_internal_key() const { - return _internal_has_key() - ? *select_.key_ - : reinterpret_cast< ::substrait::Expression_MaskExpression_MapSelect_MapKey&>(::substrait::_Expression_MaskExpression_MapSelect_MapKey_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_MapSelect_MapKey& Expression_MaskExpression_MapSelect::key() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.key) - return _internal_key(); -} -inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.MapSelect.key) - if (_internal_has_key()) { - clear_has_select(); - ::substrait::Expression_MaskExpression_MapSelect_MapKey* temp = select_.key_; - select_.key_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_key(::substrait::Expression_MaskExpression_MapSelect_MapKey* key) { - clear_select(); - if (key) { - set_has_key(); - select_.key_ = key; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.MapSelect.key) -} -inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::_internal_mutable_key() { - if (!_internal_has_key()) { - clear_select(); - set_has_key(); - select_.key_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKey >(GetArenaForAllocation()); - } - return select_.key_; -} -inline ::substrait::Expression_MaskExpression_MapSelect_MapKey* Expression_MaskExpression_MapSelect::mutable_key() { - ::substrait::Expression_MaskExpression_MapSelect_MapKey* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.key) - return _msg; -} - -// .substrait.Expression.MaskExpression.MapSelect.MapKeyExpression expression = 2; -inline bool Expression_MaskExpression_MapSelect::_internal_has_expression() const { - return select_case() == kExpression; -} -inline bool Expression_MaskExpression_MapSelect::has_expression() const { - return _internal_has_expression(); -} -inline void Expression_MaskExpression_MapSelect::set_has_expression() { - _oneof_case_[0] = kExpression; -} -inline void Expression_MaskExpression_MapSelect::clear_expression() { - if (_internal_has_expression()) { - if (GetArenaForAllocation() == nullptr) { - delete select_.expression_; - } - clear_has_select(); - } -} -inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::release_expression() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.expression) - if (_internal_has_expression()) { - clear_has_select(); - ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - select_.expression_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::_internal_expression() const { - return _internal_has_expression() - ? *select_.expression_ - : reinterpret_cast< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression&>(::substrait::_Expression_MaskExpression_MapSelect_MapKeyExpression_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression& Expression_MaskExpression_MapSelect::expression() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.expression) - return _internal_expression(); -} -inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.MaskExpression.MapSelect.expression) - if (_internal_has_expression()) { - clear_has_select(); - ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* temp = select_.expression_; - select_.expression_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_expression(::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* expression) { - clear_select(); - if (expression) { - set_has_expression(); - select_.expression_ = expression; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.MapSelect.expression) -} -inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::_internal_mutable_expression() { - if (!_internal_has_expression()) { - clear_select(); - set_has_expression(); - select_.expression_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression >(GetArenaForAllocation()); - } - return select_.expression_; -} -inline ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* Expression_MaskExpression_MapSelect::mutable_expression() { - ::substrait::Expression_MaskExpression_MapSelect_MapKeyExpression* _msg = _internal_mutable_expression(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.expression) - return _msg; -} - -// .substrait.Expression.MaskExpression.Select child = 3; -inline bool Expression_MaskExpression_MapSelect::_internal_has_child() const { - return this != internal_default_instance() && child_ != nullptr; -} -inline bool Expression_MaskExpression_MapSelect::has_child() const { - return _internal_has_child(); -} -inline void Expression_MaskExpression_MapSelect::clear_child() { - if (GetArenaForAllocation() == nullptr && child_ != nullptr) { - delete child_; - } - child_ = nullptr; -} -inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::_internal_child() const { - const ::substrait::Expression_MaskExpression_Select* p = child_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_MaskExpression_Select_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_Select& Expression_MaskExpression_MapSelect::child() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.MapSelect.child) - return _internal_child(); -} -inline void Expression_MaskExpression_MapSelect::unsafe_arena_set_allocated_child( - ::substrait::Expression_MaskExpression_Select* child) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(child_); - } - child_ = child; - if (child) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.MapSelect.child) -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::release_child() { - - ::substrait::Expression_MaskExpression_Select* temp = child_; - child_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::unsafe_arena_release_child() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.MapSelect.child) - - ::substrait::Expression_MaskExpression_Select* temp = child_; - child_ = nullptr; - return temp; -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::_internal_mutable_child() { - - if (child_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_Select>(GetArenaForAllocation()); - child_ = p; - } - return child_; -} -inline ::substrait::Expression_MaskExpression_Select* Expression_MaskExpression_MapSelect::mutable_child() { - ::substrait::Expression_MaskExpression_Select* _msg = _internal_mutable_child(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.MapSelect.child) - return _msg; -} -inline void Expression_MaskExpression_MapSelect::set_allocated_child(::substrait::Expression_MaskExpression_Select* child) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete child_; - } - if (child) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_Select>::GetOwningArena(child); - if (message_arena != submessage_arena) { - child = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, child, submessage_arena); - } - - } else { - - } - child_ = child; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.MapSelect.child) -} - -inline bool Expression_MaskExpression_MapSelect::has_select() const { - return select_case() != SELECT_NOT_SET; -} -inline void Expression_MaskExpression_MapSelect::clear_has_select() { - _oneof_case_[0] = SELECT_NOT_SET; -} -inline Expression_MaskExpression_MapSelect::SelectCase Expression_MaskExpression_MapSelect::select_case() const { - return Expression_MaskExpression_MapSelect::SelectCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Expression_MaskExpression - -// .substrait.Expression.MaskExpression.StructSelect select = 1; -inline bool Expression_MaskExpression::_internal_has_select() const { - return this != internal_default_instance() && select_ != nullptr; -} -inline bool Expression_MaskExpression::has_select() const { - return _internal_has_select(); -} -inline void Expression_MaskExpression::clear_select() { - if (GetArenaForAllocation() == nullptr && select_ != nullptr) { - delete select_; - } - select_ = nullptr; -} -inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::_internal_select() const { - const ::substrait::Expression_MaskExpression_StructSelect* p = select_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_MaskExpression_StructSelect_default_instance_); -} -inline const ::substrait::Expression_MaskExpression_StructSelect& Expression_MaskExpression::select() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.select) - return _internal_select(); -} -inline void Expression_MaskExpression::unsafe_arena_set_allocated_select( - ::substrait::Expression_MaskExpression_StructSelect* select) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(select_); - } - select_ = select; - if (select) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.MaskExpression.select) -} -inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::release_select() { - - ::substrait::Expression_MaskExpression_StructSelect* temp = select_; - select_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::unsafe_arena_release_select() { - // @@protoc_insertion_point(field_release:substrait.Expression.MaskExpression.select) - - ::substrait::Expression_MaskExpression_StructSelect* temp = select_; - select_ = nullptr; - return temp; -} -inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::_internal_mutable_select() { - - if (select_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression_StructSelect>(GetArenaForAllocation()); - select_ = p; - } - return select_; -} -inline ::substrait::Expression_MaskExpression_StructSelect* Expression_MaskExpression::mutable_select() { - ::substrait::Expression_MaskExpression_StructSelect* _msg = _internal_mutable_select(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.MaskExpression.select) - return _msg; -} -inline void Expression_MaskExpression::set_allocated_select(::substrait::Expression_MaskExpression_StructSelect* select) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete select_; - } - if (select) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression_MaskExpression_StructSelect>::GetOwningArena(select); - if (message_arena != submessage_arena) { - select = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, select, submessage_arena); - } - - } else { - - } - select_ = select; - // @@protoc_insertion_point(field_set_allocated:substrait.Expression.MaskExpression.select) -} - -// bool maintain_singular_struct = 2; -inline void Expression_MaskExpression::clear_maintain_singular_struct() { - maintain_singular_struct_ = false; -} -inline bool Expression_MaskExpression::_internal_maintain_singular_struct() const { - return maintain_singular_struct_; -} -inline bool Expression_MaskExpression::maintain_singular_struct() const { - // @@protoc_insertion_point(field_get:substrait.Expression.MaskExpression.maintain_singular_struct) - return _internal_maintain_singular_struct(); -} -inline void Expression_MaskExpression::_internal_set_maintain_singular_struct(bool value) { - - maintain_singular_struct_ = value; -} -inline void Expression_MaskExpression::set_maintain_singular_struct(bool value) { - _internal_set_maintain_singular_struct(value); - // @@protoc_insertion_point(field_set:substrait.Expression.MaskExpression.maintain_singular_struct) -} - -// ------------------------------------------------------------------- - -// Expression_FieldReference_RootReference - -// ------------------------------------------------------------------- - -// Expression_FieldReference - -// .substrait.Expression.ReferenceSegment direct_reference = 1; -inline bool Expression_FieldReference::_internal_has_direct_reference() const { - return reference_type_case() == kDirectReference; -} -inline bool Expression_FieldReference::has_direct_reference() const { - return _internal_has_direct_reference(); -} -inline void Expression_FieldReference::set_has_direct_reference() { - _oneof_case_[0] = kDirectReference; -} -inline void Expression_FieldReference::clear_direct_reference() { - if (_internal_has_direct_reference()) { - if (GetArenaForAllocation() == nullptr) { - delete reference_type_.direct_reference_; - } - clear_has_reference_type(); - } -} -inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::release_direct_reference() { - // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.direct_reference) - if (_internal_has_direct_reference()) { - clear_has_reference_type(); - ::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.direct_reference_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_ReferenceSegment& Expression_FieldReference::_internal_direct_reference() const { - return _internal_has_direct_reference() - ? *reference_type_.direct_reference_ - : reinterpret_cast< ::substrait::Expression_ReferenceSegment&>(::substrait::_Expression_ReferenceSegment_default_instance_); -} -inline const ::substrait::Expression_ReferenceSegment& Expression_FieldReference::direct_reference() const { - // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.direct_reference) - return _internal_direct_reference(); -} -inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::unsafe_arena_release_direct_reference() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.direct_reference) - if (_internal_has_direct_reference()) { - clear_has_reference_type(); - ::substrait::Expression_ReferenceSegment* temp = reference_type_.direct_reference_; - reference_type_.direct_reference_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_FieldReference::unsafe_arena_set_allocated_direct_reference(::substrait::Expression_ReferenceSegment* direct_reference) { - clear_reference_type(); - if (direct_reference) { - set_has_direct_reference(); - reference_type_.direct_reference_ = direct_reference; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.direct_reference) -} -inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::_internal_mutable_direct_reference() { - if (!_internal_has_direct_reference()) { - clear_reference_type(); - set_has_direct_reference(); - reference_type_.direct_reference_ = CreateMaybeMessage< ::substrait::Expression_ReferenceSegment >(GetArenaForAllocation()); - } - return reference_type_.direct_reference_; -} -inline ::substrait::Expression_ReferenceSegment* Expression_FieldReference::mutable_direct_reference() { - ::substrait::Expression_ReferenceSegment* _msg = _internal_mutable_direct_reference(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.direct_reference) - return _msg; -} - -// .substrait.Expression.MaskExpression masked_reference = 2; -inline bool Expression_FieldReference::_internal_has_masked_reference() const { - return reference_type_case() == kMaskedReference; -} -inline bool Expression_FieldReference::has_masked_reference() const { - return _internal_has_masked_reference(); -} -inline void Expression_FieldReference::set_has_masked_reference() { - _oneof_case_[0] = kMaskedReference; -} -inline void Expression_FieldReference::clear_masked_reference() { - if (_internal_has_masked_reference()) { - if (GetArenaForAllocation() == nullptr) { - delete reference_type_.masked_reference_; - } - clear_has_reference_type(); - } -} -inline ::substrait::Expression_MaskExpression* Expression_FieldReference::release_masked_reference() { - // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.masked_reference) - if (_internal_has_masked_reference()) { - clear_has_reference_type(); - ::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - reference_type_.masked_reference_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_MaskExpression& Expression_FieldReference::_internal_masked_reference() const { - return _internal_has_masked_reference() - ? *reference_type_.masked_reference_ - : reinterpret_cast< ::substrait::Expression_MaskExpression&>(::substrait::_Expression_MaskExpression_default_instance_); -} -inline const ::substrait::Expression_MaskExpression& Expression_FieldReference::masked_reference() const { - // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.masked_reference) - return _internal_masked_reference(); -} -inline ::substrait::Expression_MaskExpression* Expression_FieldReference::unsafe_arena_release_masked_reference() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.masked_reference) - if (_internal_has_masked_reference()) { - clear_has_reference_type(); - ::substrait::Expression_MaskExpression* temp = reference_type_.masked_reference_; - reference_type_.masked_reference_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_FieldReference::unsafe_arena_set_allocated_masked_reference(::substrait::Expression_MaskExpression* masked_reference) { - clear_reference_type(); - if (masked_reference) { - set_has_masked_reference(); - reference_type_.masked_reference_ = masked_reference; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.masked_reference) -} -inline ::substrait::Expression_MaskExpression* Expression_FieldReference::_internal_mutable_masked_reference() { - if (!_internal_has_masked_reference()) { - clear_reference_type(); - set_has_masked_reference(); - reference_type_.masked_reference_ = CreateMaybeMessage< ::substrait::Expression_MaskExpression >(GetArenaForAllocation()); - } - return reference_type_.masked_reference_; -} -inline ::substrait::Expression_MaskExpression* Expression_FieldReference::mutable_masked_reference() { - ::substrait::Expression_MaskExpression* _msg = _internal_mutable_masked_reference(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.masked_reference) - return _msg; -} - -// .substrait.Expression expression = 3; -inline bool Expression_FieldReference::_internal_has_expression() const { - return root_type_case() == kExpression; -} -inline bool Expression_FieldReference::has_expression() const { - return _internal_has_expression(); -} -inline void Expression_FieldReference::set_has_expression() { - _oneof_case_[1] = kExpression; -} -inline void Expression_FieldReference::clear_expression() { - if (_internal_has_expression()) { - if (GetArenaForAllocation() == nullptr) { - delete root_type_.expression_; - } - clear_has_root_type(); - } -} -inline ::substrait::Expression* Expression_FieldReference::release_expression() { - // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.expression) - if (_internal_has_expression()) { - clear_has_root_type(); - ::substrait::Expression* temp = root_type_.expression_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - root_type_.expression_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression& Expression_FieldReference::_internal_expression() const { - return _internal_has_expression() - ? *root_type_.expression_ - : reinterpret_cast< ::substrait::Expression&>(::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& Expression_FieldReference::expression() const { - // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.expression) - return _internal_expression(); -} -inline ::substrait::Expression* Expression_FieldReference::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.expression) - if (_internal_has_expression()) { - clear_has_root_type(); - ::substrait::Expression* temp = root_type_.expression_; - root_type_.expression_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_FieldReference::unsafe_arena_set_allocated_expression(::substrait::Expression* expression) { - clear_root_type(); - if (expression) { - set_has_expression(); - root_type_.expression_ = expression; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.expression) -} -inline ::substrait::Expression* Expression_FieldReference::_internal_mutable_expression() { - if (!_internal_has_expression()) { - clear_root_type(); - set_has_expression(); - root_type_.expression_ = CreateMaybeMessage< ::substrait::Expression >(GetArenaForAllocation()); - } - return root_type_.expression_; -} -inline ::substrait::Expression* Expression_FieldReference::mutable_expression() { - ::substrait::Expression* _msg = _internal_mutable_expression(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.expression) - return _msg; -} - -// .substrait.Expression.FieldReference.RootReference root_reference = 4; -inline bool Expression_FieldReference::_internal_has_root_reference() const { - return root_type_case() == kRootReference; -} -inline bool Expression_FieldReference::has_root_reference() const { - return _internal_has_root_reference(); -} -inline void Expression_FieldReference::set_has_root_reference() { - _oneof_case_[1] = kRootReference; -} -inline void Expression_FieldReference::clear_root_reference() { - if (_internal_has_root_reference()) { - if (GetArenaForAllocation() == nullptr) { - delete root_type_.root_reference_; - } - clear_has_root_type(); - } -} -inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::release_root_reference() { - // @@protoc_insertion_point(field_release:substrait.Expression.FieldReference.root_reference) - if (_internal_has_root_reference()) { - clear_has_root_type(); - ::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - root_type_.root_reference_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::_internal_root_reference() const { - return _internal_has_root_reference() - ? *root_type_.root_reference_ - : reinterpret_cast< ::substrait::Expression_FieldReference_RootReference&>(::substrait::_Expression_FieldReference_RootReference_default_instance_); -} -inline const ::substrait::Expression_FieldReference_RootReference& Expression_FieldReference::root_reference() const { - // @@protoc_insertion_point(field_get:substrait.Expression.FieldReference.root_reference) - return _internal_root_reference(); -} -inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::unsafe_arena_release_root_reference() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.FieldReference.root_reference) - if (_internal_has_root_reference()) { - clear_has_root_type(); - ::substrait::Expression_FieldReference_RootReference* temp = root_type_.root_reference_; - root_type_.root_reference_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression_FieldReference::unsafe_arena_set_allocated_root_reference(::substrait::Expression_FieldReference_RootReference* root_reference) { - clear_root_type(); - if (root_reference) { - set_has_root_reference(); - root_type_.root_reference_ = root_reference; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.FieldReference.root_reference) -} -inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::_internal_mutable_root_reference() { - if (!_internal_has_root_reference()) { - clear_root_type(); - set_has_root_reference(); - root_type_.root_reference_ = CreateMaybeMessage< ::substrait::Expression_FieldReference_RootReference >(GetArenaForAllocation()); - } - return root_type_.root_reference_; -} -inline ::substrait::Expression_FieldReference_RootReference* Expression_FieldReference::mutable_root_reference() { - ::substrait::Expression_FieldReference_RootReference* _msg = _internal_mutable_root_reference(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.FieldReference.root_reference) - return _msg; -} - -inline bool Expression_FieldReference::has_reference_type() const { - return reference_type_case() != REFERENCE_TYPE_NOT_SET; -} -inline void Expression_FieldReference::clear_has_reference_type() { - _oneof_case_[0] = REFERENCE_TYPE_NOT_SET; -} -inline bool Expression_FieldReference::has_root_type() const { - return root_type_case() != ROOT_TYPE_NOT_SET; -} -inline void Expression_FieldReference::clear_has_root_type() { - _oneof_case_[1] = ROOT_TYPE_NOT_SET; -} -inline Expression_FieldReference::ReferenceTypeCase Expression_FieldReference::reference_type_case() const { - return Expression_FieldReference::ReferenceTypeCase(_oneof_case_[0]); -} -inline Expression_FieldReference::RootTypeCase Expression_FieldReference::root_type_case() const { - return Expression_FieldReference::RootTypeCase(_oneof_case_[1]); -} -// ------------------------------------------------------------------- - -// Expression - -// .substrait.Expression.Literal literal = 1; -inline bool Expression::_internal_has_literal() const { - return rex_type_case() == kLiteral; -} -inline bool Expression::has_literal() const { - return _internal_has_literal(); -} -inline void Expression::set_has_literal() { - _oneof_case_[0] = kLiteral; -} -inline void Expression::clear_literal() { - if (_internal_has_literal()) { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.literal_; - } - clear_has_rex_type(); - } -} -inline ::substrait::Expression_Literal* Expression::release_literal() { - // @@protoc_insertion_point(field_release:substrait.Expression.literal) - if (_internal_has_literal()) { - clear_has_rex_type(); - ::substrait::Expression_Literal* temp = rex_type_.literal_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.literal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Literal& Expression::_internal_literal() const { - return _internal_has_literal() - ? *rex_type_.literal_ - : reinterpret_cast< ::substrait::Expression_Literal&>(::substrait::_Expression_Literal_default_instance_); -} -inline const ::substrait::Expression_Literal& Expression::literal() const { - // @@protoc_insertion_point(field_get:substrait.Expression.literal) - return _internal_literal(); -} -inline ::substrait::Expression_Literal* Expression::unsafe_arena_release_literal() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.literal) - if (_internal_has_literal()) { - clear_has_rex_type(); - ::substrait::Expression_Literal* temp = rex_type_.literal_; - rex_type_.literal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression::unsafe_arena_set_allocated_literal(::substrait::Expression_Literal* literal) { - clear_rex_type(); - if (literal) { - set_has_literal(); - rex_type_.literal_ = literal; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.literal) -} -inline ::substrait::Expression_Literal* Expression::_internal_mutable_literal() { - if (!_internal_has_literal()) { - clear_rex_type(); - set_has_literal(); - rex_type_.literal_ = CreateMaybeMessage< ::substrait::Expression_Literal >(GetArenaForAllocation()); - } - return rex_type_.literal_; -} -inline ::substrait::Expression_Literal* Expression::mutable_literal() { - ::substrait::Expression_Literal* _msg = _internal_mutable_literal(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.literal) - return _msg; -} - -// .substrait.Expression.FieldReference selection = 2; -inline bool Expression::_internal_has_selection() const { - return rex_type_case() == kSelection; -} -inline bool Expression::has_selection() const { - return _internal_has_selection(); -} -inline void Expression::set_has_selection() { - _oneof_case_[0] = kSelection; -} -inline void Expression::clear_selection() { - if (_internal_has_selection()) { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.selection_; - } - clear_has_rex_type(); - } -} -inline ::substrait::Expression_FieldReference* Expression::release_selection() { - // @@protoc_insertion_point(field_release:substrait.Expression.selection) - if (_internal_has_selection()) { - clear_has_rex_type(); - ::substrait::Expression_FieldReference* temp = rex_type_.selection_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.selection_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_FieldReference& Expression::_internal_selection() const { - return _internal_has_selection() - ? *rex_type_.selection_ - : reinterpret_cast< ::substrait::Expression_FieldReference&>(::substrait::_Expression_FieldReference_default_instance_); -} -inline const ::substrait::Expression_FieldReference& Expression::selection() const { - // @@protoc_insertion_point(field_get:substrait.Expression.selection) - return _internal_selection(); -} -inline ::substrait::Expression_FieldReference* Expression::unsafe_arena_release_selection() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.selection) - if (_internal_has_selection()) { - clear_has_rex_type(); - ::substrait::Expression_FieldReference* temp = rex_type_.selection_; - rex_type_.selection_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression::unsafe_arena_set_allocated_selection(::substrait::Expression_FieldReference* selection) { - clear_rex_type(); - if (selection) { - set_has_selection(); - rex_type_.selection_ = selection; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.selection) -} -inline ::substrait::Expression_FieldReference* Expression::_internal_mutable_selection() { - if (!_internal_has_selection()) { - clear_rex_type(); - set_has_selection(); - rex_type_.selection_ = CreateMaybeMessage< ::substrait::Expression_FieldReference >(GetArenaForAllocation()); - } - return rex_type_.selection_; -} -inline ::substrait::Expression_FieldReference* Expression::mutable_selection() { - ::substrait::Expression_FieldReference* _msg = _internal_mutable_selection(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.selection) - return _msg; -} - -// .substrait.Expression.ScalarFunction scalar_function = 3; -inline bool Expression::_internal_has_scalar_function() const { - return rex_type_case() == kScalarFunction; -} -inline bool Expression::has_scalar_function() const { - return _internal_has_scalar_function(); -} -inline void Expression::set_has_scalar_function() { - _oneof_case_[0] = kScalarFunction; -} -inline void Expression::clear_scalar_function() { - if (_internal_has_scalar_function()) { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.scalar_function_; - } - clear_has_rex_type(); - } -} -inline ::substrait::Expression_ScalarFunction* Expression::release_scalar_function() { - // @@protoc_insertion_point(field_release:substrait.Expression.scalar_function) - if (_internal_has_scalar_function()) { - clear_has_rex_type(); - ::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.scalar_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_ScalarFunction& Expression::_internal_scalar_function() const { - return _internal_has_scalar_function() - ? *rex_type_.scalar_function_ - : reinterpret_cast< ::substrait::Expression_ScalarFunction&>(::substrait::_Expression_ScalarFunction_default_instance_); -} -inline const ::substrait::Expression_ScalarFunction& Expression::scalar_function() const { - // @@protoc_insertion_point(field_get:substrait.Expression.scalar_function) - return _internal_scalar_function(); -} -inline ::substrait::Expression_ScalarFunction* Expression::unsafe_arena_release_scalar_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.scalar_function) - if (_internal_has_scalar_function()) { - clear_has_rex_type(); - ::substrait::Expression_ScalarFunction* temp = rex_type_.scalar_function_; - rex_type_.scalar_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression::unsafe_arena_set_allocated_scalar_function(::substrait::Expression_ScalarFunction* scalar_function) { - clear_rex_type(); - if (scalar_function) { - set_has_scalar_function(); - rex_type_.scalar_function_ = scalar_function; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.scalar_function) -} -inline ::substrait::Expression_ScalarFunction* Expression::_internal_mutable_scalar_function() { - if (!_internal_has_scalar_function()) { - clear_rex_type(); - set_has_scalar_function(); - rex_type_.scalar_function_ = CreateMaybeMessage< ::substrait::Expression_ScalarFunction >(GetArenaForAllocation()); - } - return rex_type_.scalar_function_; -} -inline ::substrait::Expression_ScalarFunction* Expression::mutable_scalar_function() { - ::substrait::Expression_ScalarFunction* _msg = _internal_mutable_scalar_function(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.scalar_function) - return _msg; -} - -// .substrait.Expression.WindowFunction window_function = 5; -inline bool Expression::_internal_has_window_function() const { - return rex_type_case() == kWindowFunction; -} -inline bool Expression::has_window_function() const { - return _internal_has_window_function(); -} -inline void Expression::set_has_window_function() { - _oneof_case_[0] = kWindowFunction; -} -inline void Expression::clear_window_function() { - if (_internal_has_window_function()) { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.window_function_; - } - clear_has_rex_type(); - } -} -inline ::substrait::Expression_WindowFunction* Expression::release_window_function() { - // @@protoc_insertion_point(field_release:substrait.Expression.window_function) - if (_internal_has_window_function()) { - clear_has_rex_type(); - ::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.window_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_WindowFunction& Expression::_internal_window_function() const { - return _internal_has_window_function() - ? *rex_type_.window_function_ - : reinterpret_cast< ::substrait::Expression_WindowFunction&>(::substrait::_Expression_WindowFunction_default_instance_); -} -inline const ::substrait::Expression_WindowFunction& Expression::window_function() const { - // @@protoc_insertion_point(field_get:substrait.Expression.window_function) - return _internal_window_function(); -} -inline ::substrait::Expression_WindowFunction* Expression::unsafe_arena_release_window_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.window_function) - if (_internal_has_window_function()) { - clear_has_rex_type(); - ::substrait::Expression_WindowFunction* temp = rex_type_.window_function_; - rex_type_.window_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression::unsafe_arena_set_allocated_window_function(::substrait::Expression_WindowFunction* window_function) { - clear_rex_type(); - if (window_function) { - set_has_window_function(); - rex_type_.window_function_ = window_function; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.window_function) -} -inline ::substrait::Expression_WindowFunction* Expression::_internal_mutable_window_function() { - if (!_internal_has_window_function()) { - clear_rex_type(); - set_has_window_function(); - rex_type_.window_function_ = CreateMaybeMessage< ::substrait::Expression_WindowFunction >(GetArenaForAllocation()); - } - return rex_type_.window_function_; -} -inline ::substrait::Expression_WindowFunction* Expression::mutable_window_function() { - ::substrait::Expression_WindowFunction* _msg = _internal_mutable_window_function(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.window_function) - return _msg; -} - -// .substrait.Expression.IfThen if_then = 6; -inline bool Expression::_internal_has_if_then() const { - return rex_type_case() == kIfThen; -} -inline bool Expression::has_if_then() const { - return _internal_has_if_then(); -} -inline void Expression::set_has_if_then() { - _oneof_case_[0] = kIfThen; -} -inline void Expression::clear_if_then() { - if (_internal_has_if_then()) { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.if_then_; - } - clear_has_rex_type(); - } -} -inline ::substrait::Expression_IfThen* Expression::release_if_then() { - // @@protoc_insertion_point(field_release:substrait.Expression.if_then) - if (_internal_has_if_then()) { - clear_has_rex_type(); - ::substrait::Expression_IfThen* temp = rex_type_.if_then_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.if_then_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_IfThen& Expression::_internal_if_then() const { - return _internal_has_if_then() - ? *rex_type_.if_then_ - : reinterpret_cast< ::substrait::Expression_IfThen&>(::substrait::_Expression_IfThen_default_instance_); -} -inline const ::substrait::Expression_IfThen& Expression::if_then() const { - // @@protoc_insertion_point(field_get:substrait.Expression.if_then) - return _internal_if_then(); -} -inline ::substrait::Expression_IfThen* Expression::unsafe_arena_release_if_then() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.if_then) - if (_internal_has_if_then()) { - clear_has_rex_type(); - ::substrait::Expression_IfThen* temp = rex_type_.if_then_; - rex_type_.if_then_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression::unsafe_arena_set_allocated_if_then(::substrait::Expression_IfThen* if_then) { - clear_rex_type(); - if (if_then) { - set_has_if_then(); - rex_type_.if_then_ = if_then; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.if_then) -} -inline ::substrait::Expression_IfThen* Expression::_internal_mutable_if_then() { - if (!_internal_has_if_then()) { - clear_rex_type(); - set_has_if_then(); - rex_type_.if_then_ = CreateMaybeMessage< ::substrait::Expression_IfThen >(GetArenaForAllocation()); - } - return rex_type_.if_then_; -} -inline ::substrait::Expression_IfThen* Expression::mutable_if_then() { - ::substrait::Expression_IfThen* _msg = _internal_mutable_if_then(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.if_then) - return _msg; -} - -// .substrait.Expression.SwitchExpression switch_expression = 7; -inline bool Expression::_internal_has_switch_expression() const { - return rex_type_case() == kSwitchExpression; -} -inline bool Expression::has_switch_expression() const { - return _internal_has_switch_expression(); -} -inline void Expression::set_has_switch_expression() { - _oneof_case_[0] = kSwitchExpression; -} -inline void Expression::clear_switch_expression() { - if (_internal_has_switch_expression()) { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.switch_expression_; - } - clear_has_rex_type(); - } -} -inline ::substrait::Expression_SwitchExpression* Expression::release_switch_expression() { - // @@protoc_insertion_point(field_release:substrait.Expression.switch_expression) - if (_internal_has_switch_expression()) { - clear_has_rex_type(); - ::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.switch_expression_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_SwitchExpression& Expression::_internal_switch_expression() const { - return _internal_has_switch_expression() - ? *rex_type_.switch_expression_ - : reinterpret_cast< ::substrait::Expression_SwitchExpression&>(::substrait::_Expression_SwitchExpression_default_instance_); -} -inline const ::substrait::Expression_SwitchExpression& Expression::switch_expression() const { - // @@protoc_insertion_point(field_get:substrait.Expression.switch_expression) - return _internal_switch_expression(); -} -inline ::substrait::Expression_SwitchExpression* Expression::unsafe_arena_release_switch_expression() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.switch_expression) - if (_internal_has_switch_expression()) { - clear_has_rex_type(); - ::substrait::Expression_SwitchExpression* temp = rex_type_.switch_expression_; - rex_type_.switch_expression_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression::unsafe_arena_set_allocated_switch_expression(::substrait::Expression_SwitchExpression* switch_expression) { - clear_rex_type(); - if (switch_expression) { - set_has_switch_expression(); - rex_type_.switch_expression_ = switch_expression; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.switch_expression) -} -inline ::substrait::Expression_SwitchExpression* Expression::_internal_mutable_switch_expression() { - if (!_internal_has_switch_expression()) { - clear_rex_type(); - set_has_switch_expression(); - rex_type_.switch_expression_ = CreateMaybeMessage< ::substrait::Expression_SwitchExpression >(GetArenaForAllocation()); - } - return rex_type_.switch_expression_; -} -inline ::substrait::Expression_SwitchExpression* Expression::mutable_switch_expression() { - ::substrait::Expression_SwitchExpression* _msg = _internal_mutable_switch_expression(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.switch_expression) - return _msg; -} - -// .substrait.Expression.SingularOrList singular_or_list = 8; -inline bool Expression::_internal_has_singular_or_list() const { - return rex_type_case() == kSingularOrList; -} -inline bool Expression::has_singular_or_list() const { - return _internal_has_singular_or_list(); -} -inline void Expression::set_has_singular_or_list() { - _oneof_case_[0] = kSingularOrList; -} -inline void Expression::clear_singular_or_list() { - if (_internal_has_singular_or_list()) { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.singular_or_list_; - } - clear_has_rex_type(); - } -} -inline ::substrait::Expression_SingularOrList* Expression::release_singular_or_list() { - // @@protoc_insertion_point(field_release:substrait.Expression.singular_or_list) - if (_internal_has_singular_or_list()) { - clear_has_rex_type(); - ::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.singular_or_list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_SingularOrList& Expression::_internal_singular_or_list() const { - return _internal_has_singular_or_list() - ? *rex_type_.singular_or_list_ - : reinterpret_cast< ::substrait::Expression_SingularOrList&>(::substrait::_Expression_SingularOrList_default_instance_); -} -inline const ::substrait::Expression_SingularOrList& Expression::singular_or_list() const { - // @@protoc_insertion_point(field_get:substrait.Expression.singular_or_list) - return _internal_singular_or_list(); -} -inline ::substrait::Expression_SingularOrList* Expression::unsafe_arena_release_singular_or_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.singular_or_list) - if (_internal_has_singular_or_list()) { - clear_has_rex_type(); - ::substrait::Expression_SingularOrList* temp = rex_type_.singular_or_list_; - rex_type_.singular_or_list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression::unsafe_arena_set_allocated_singular_or_list(::substrait::Expression_SingularOrList* singular_or_list) { - clear_rex_type(); - if (singular_or_list) { - set_has_singular_or_list(); - rex_type_.singular_or_list_ = singular_or_list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.singular_or_list) -} -inline ::substrait::Expression_SingularOrList* Expression::_internal_mutable_singular_or_list() { - if (!_internal_has_singular_or_list()) { - clear_rex_type(); - set_has_singular_or_list(); - rex_type_.singular_or_list_ = CreateMaybeMessage< ::substrait::Expression_SingularOrList >(GetArenaForAllocation()); - } - return rex_type_.singular_or_list_; -} -inline ::substrait::Expression_SingularOrList* Expression::mutable_singular_or_list() { - ::substrait::Expression_SingularOrList* _msg = _internal_mutable_singular_or_list(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.singular_or_list) - return _msg; -} - -// .substrait.Expression.MultiOrList multi_or_list = 9; -inline bool Expression::_internal_has_multi_or_list() const { - return rex_type_case() == kMultiOrList; -} -inline bool Expression::has_multi_or_list() const { - return _internal_has_multi_or_list(); -} -inline void Expression::set_has_multi_or_list() { - _oneof_case_[0] = kMultiOrList; -} -inline void Expression::clear_multi_or_list() { - if (_internal_has_multi_or_list()) { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.multi_or_list_; - } - clear_has_rex_type(); - } -} -inline ::substrait::Expression_MultiOrList* Expression::release_multi_or_list() { - // @@protoc_insertion_point(field_release:substrait.Expression.multi_or_list) - if (_internal_has_multi_or_list()) { - clear_has_rex_type(); - ::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.multi_or_list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_MultiOrList& Expression::_internal_multi_or_list() const { - return _internal_has_multi_or_list() - ? *rex_type_.multi_or_list_ - : reinterpret_cast< ::substrait::Expression_MultiOrList&>(::substrait::_Expression_MultiOrList_default_instance_); -} -inline const ::substrait::Expression_MultiOrList& Expression::multi_or_list() const { - // @@protoc_insertion_point(field_get:substrait.Expression.multi_or_list) - return _internal_multi_or_list(); -} -inline ::substrait::Expression_MultiOrList* Expression::unsafe_arena_release_multi_or_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.multi_or_list) - if (_internal_has_multi_or_list()) { - clear_has_rex_type(); - ::substrait::Expression_MultiOrList* temp = rex_type_.multi_or_list_; - rex_type_.multi_or_list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression::unsafe_arena_set_allocated_multi_or_list(::substrait::Expression_MultiOrList* multi_or_list) { - clear_rex_type(); - if (multi_or_list) { - set_has_multi_or_list(); - rex_type_.multi_or_list_ = multi_or_list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.multi_or_list) -} -inline ::substrait::Expression_MultiOrList* Expression::_internal_mutable_multi_or_list() { - if (!_internal_has_multi_or_list()) { - clear_rex_type(); - set_has_multi_or_list(); - rex_type_.multi_or_list_ = CreateMaybeMessage< ::substrait::Expression_MultiOrList >(GetArenaForAllocation()); - } - return rex_type_.multi_or_list_; -} -inline ::substrait::Expression_MultiOrList* Expression::mutable_multi_or_list() { - ::substrait::Expression_MultiOrList* _msg = _internal_mutable_multi_or_list(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.multi_or_list) - return _msg; -} - -// .substrait.Expression.Enum enum = 10; -inline bool Expression::_internal_has_enum_() const { - return rex_type_case() == kEnum; -} -inline bool Expression::has_enum_() const { - return _internal_has_enum_(); -} -inline void Expression::set_has_enum_() { - _oneof_case_[0] = kEnum; -} -inline void Expression::clear_enum_() { - if (_internal_has_enum_()) { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.enum__; - } - clear_has_rex_type(); - } -} -inline ::substrait::Expression_Enum* Expression::release_enum_() { - // @@protoc_insertion_point(field_release:substrait.Expression.enum) - if (_internal_has_enum_()) { - clear_has_rex_type(); - ::substrait::Expression_Enum* temp = rex_type_.enum__; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.enum__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Enum& Expression::_internal_enum_() const { - return _internal_has_enum_() - ? *rex_type_.enum__ - : reinterpret_cast< ::substrait::Expression_Enum&>(::substrait::_Expression_Enum_default_instance_); -} -inline const ::substrait::Expression_Enum& Expression::enum_() const { - // @@protoc_insertion_point(field_get:substrait.Expression.enum) - return _internal_enum_(); -} -inline ::substrait::Expression_Enum* Expression::unsafe_arena_release_enum_() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.enum) - if (_internal_has_enum_()) { - clear_has_rex_type(); - ::substrait::Expression_Enum* temp = rex_type_.enum__; - rex_type_.enum__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression::unsafe_arena_set_allocated_enum_(::substrait::Expression_Enum* enum_) { - clear_rex_type(); - if (enum_) { - set_has_enum_(); - rex_type_.enum__ = enum_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.enum) -} -inline ::substrait::Expression_Enum* Expression::_internal_mutable_enum_() { - if (!_internal_has_enum_()) { - clear_rex_type(); - set_has_enum_(); - rex_type_.enum__ = CreateMaybeMessage< ::substrait::Expression_Enum >(GetArenaForAllocation()); - } - return rex_type_.enum__; -} -inline ::substrait::Expression_Enum* Expression::mutable_enum_() { - ::substrait::Expression_Enum* _msg = _internal_mutable_enum_(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.enum) - return _msg; -} - -// .substrait.Expression.Cast cast = 11; -inline bool Expression::_internal_has_cast() const { - return rex_type_case() == kCast; -} -inline bool Expression::has_cast() const { - return _internal_has_cast(); -} -inline void Expression::set_has_cast() { - _oneof_case_[0] = kCast; -} -inline void Expression::clear_cast() { - if (_internal_has_cast()) { - if (GetArenaForAllocation() == nullptr) { - delete rex_type_.cast_; - } - clear_has_rex_type(); - } -} -inline ::substrait::Expression_Cast* Expression::release_cast() { - // @@protoc_insertion_point(field_release:substrait.Expression.cast) - if (_internal_has_cast()) { - clear_has_rex_type(); - ::substrait::Expression_Cast* temp = rex_type_.cast_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rex_type_.cast_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Expression_Cast& Expression::_internal_cast() const { - return _internal_has_cast() - ? *rex_type_.cast_ - : reinterpret_cast< ::substrait::Expression_Cast&>(::substrait::_Expression_Cast_default_instance_); -} -inline const ::substrait::Expression_Cast& Expression::cast() const { - // @@protoc_insertion_point(field_get:substrait.Expression.cast) - return _internal_cast(); -} -inline ::substrait::Expression_Cast* Expression::unsafe_arena_release_cast() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Expression.cast) - if (_internal_has_cast()) { - clear_has_rex_type(); - ::substrait::Expression_Cast* temp = rex_type_.cast_; - rex_type_.cast_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Expression::unsafe_arena_set_allocated_cast(::substrait::Expression_Cast* cast) { - clear_rex_type(); - if (cast) { - set_has_cast(); - rex_type_.cast_ = cast; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Expression.cast) -} -inline ::substrait::Expression_Cast* Expression::_internal_mutable_cast() { - if (!_internal_has_cast()) { - clear_rex_type(); - set_has_cast(); - rex_type_.cast_ = CreateMaybeMessage< ::substrait::Expression_Cast >(GetArenaForAllocation()); - } - return rex_type_.cast_; -} -inline ::substrait::Expression_Cast* Expression::mutable_cast() { - ::substrait::Expression_Cast* _msg = _internal_mutable_cast(); - // @@protoc_insertion_point(field_mutable:substrait.Expression.cast) - return _msg; -} - -inline bool Expression::has_rex_type() const { - return rex_type_case() != REX_TYPE_NOT_SET; -} -inline void Expression::clear_has_rex_type() { - _oneof_case_[0] = REX_TYPE_NOT_SET; -} -inline Expression::RexTypeCase Expression::rex_type_case() const { - return Expression::RexTypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// SortField - -// .substrait.Expression expr = 1; -inline bool SortField::_internal_has_expr() const { - return this != internal_default_instance() && expr_ != nullptr; -} -inline bool SortField::has_expr() const { - return _internal_has_expr(); -} -inline void SortField::clear_expr() { - if (GetArenaForAllocation() == nullptr && expr_ != nullptr) { - delete expr_; - } - expr_ = nullptr; -} -inline const ::substrait::Expression& SortField::_internal_expr() const { - const ::substrait::Expression* p = expr_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& SortField::expr() const { - // @@protoc_insertion_point(field_get:substrait.SortField.expr) - return _internal_expr(); -} -inline void SortField::unsafe_arena_set_allocated_expr( - ::substrait::Expression* expr) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expr_); - } - expr_ = expr; - if (expr) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortField.expr) -} -inline ::substrait::Expression* SortField::release_expr() { - - ::substrait::Expression* temp = expr_; - expr_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* SortField::unsafe_arena_release_expr() { - // @@protoc_insertion_point(field_release:substrait.SortField.expr) - - ::substrait::Expression* temp = expr_; - expr_ = nullptr; - return temp; -} -inline ::substrait::Expression* SortField::_internal_mutable_expr() { - - if (expr_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - expr_ = p; - } - return expr_; -} -inline ::substrait::Expression* SortField::mutable_expr() { - ::substrait::Expression* _msg = _internal_mutable_expr(); - // @@protoc_insertion_point(field_mutable:substrait.SortField.expr) - return _msg; -} -inline void SortField::set_allocated_expr(::substrait::Expression* expr) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete expr_; - } - if (expr) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Expression>::GetOwningArena(expr); - if (message_arena != submessage_arena) { - expr = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, expr, submessage_arena); - } - - } else { - - } - expr_ = expr; - // @@protoc_insertion_point(field_set_allocated:substrait.SortField.expr) -} - -// .substrait.SortField.SortDirection direction = 2; -inline bool SortField::_internal_has_direction() const { - return sort_kind_case() == kDirection; -} -inline bool SortField::has_direction() const { - return _internal_has_direction(); -} -inline void SortField::set_has_direction() { - _oneof_case_[0] = kDirection; -} -inline void SortField::clear_direction() { - if (_internal_has_direction()) { - sort_kind_.direction_ = 0; - clear_has_sort_kind(); - } -} -inline ::substrait::SortField_SortDirection SortField::_internal_direction() const { - if (_internal_has_direction()) { - return static_cast< ::substrait::SortField_SortDirection >(sort_kind_.direction_); - } - return static_cast< ::substrait::SortField_SortDirection >(0); -} -inline ::substrait::SortField_SortDirection SortField::direction() const { - // @@protoc_insertion_point(field_get:substrait.SortField.direction) - return _internal_direction(); -} -inline void SortField::_internal_set_direction(::substrait::SortField_SortDirection value) { - if (!_internal_has_direction()) { - clear_sort_kind(); - set_has_direction(); - } - sort_kind_.direction_ = value; -} -inline void SortField::set_direction(::substrait::SortField_SortDirection value) { - _internal_set_direction(value); - // @@protoc_insertion_point(field_set:substrait.SortField.direction) -} - -// uint32 comparison_function_reference = 3; -inline bool SortField::_internal_has_comparison_function_reference() const { - return sort_kind_case() == kComparisonFunctionReference; -} -inline bool SortField::has_comparison_function_reference() const { - return _internal_has_comparison_function_reference(); -} -inline void SortField::set_has_comparison_function_reference() { - _oneof_case_[0] = kComparisonFunctionReference; -} -inline void SortField::clear_comparison_function_reference() { - if (_internal_has_comparison_function_reference()) { - sort_kind_.comparison_function_reference_ = 0u; - clear_has_sort_kind(); - } -} -inline uint32_t SortField::_internal_comparison_function_reference() const { - if (_internal_has_comparison_function_reference()) { - return sort_kind_.comparison_function_reference_; - } - return 0u; -} -inline void SortField::_internal_set_comparison_function_reference(uint32_t value) { - if (!_internal_has_comparison_function_reference()) { - clear_sort_kind(); - set_has_comparison_function_reference(); - } - sort_kind_.comparison_function_reference_ = value; -} -inline uint32_t SortField::comparison_function_reference() const { - // @@protoc_insertion_point(field_get:substrait.SortField.comparison_function_reference) - return _internal_comparison_function_reference(); -} -inline void SortField::set_comparison_function_reference(uint32_t value) { - _internal_set_comparison_function_reference(value); - // @@protoc_insertion_point(field_set:substrait.SortField.comparison_function_reference) -} - -inline bool SortField::has_sort_kind() const { - return sort_kind_case() != SORT_KIND_NOT_SET; -} -inline void SortField::clear_has_sort_kind() { - _oneof_case_[0] = SORT_KIND_NOT_SET; -} -inline SortField::SortKindCase SortField::sort_kind_case() const { - return SortField::SortKindCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// AggregateFunction - -// uint32 function_reference = 1; -inline void AggregateFunction::clear_function_reference() { - function_reference_ = 0u; -} -inline uint32_t AggregateFunction::_internal_function_reference() const { - return function_reference_; -} -inline uint32_t AggregateFunction::function_reference() const { - // @@protoc_insertion_point(field_get:substrait.AggregateFunction.function_reference) - return _internal_function_reference(); -} -inline void AggregateFunction::_internal_set_function_reference(uint32_t value) { - - function_reference_ = value; -} -inline void AggregateFunction::set_function_reference(uint32_t value) { - _internal_set_function_reference(value); - // @@protoc_insertion_point(field_set:substrait.AggregateFunction.function_reference) -} - -// repeated .substrait.Expression args = 2; -inline int AggregateFunction::_internal_args_size() const { - return args_.size(); -} -inline int AggregateFunction::args_size() const { - return _internal_args_size(); -} -inline void AggregateFunction::clear_args() { - args_.Clear(); -} -inline ::substrait::Expression* AggregateFunction::mutable_args(int index) { - // @@protoc_insertion_point(field_mutable:substrait.AggregateFunction.args) - return args_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* -AggregateFunction::mutable_args() { - // @@protoc_insertion_point(field_mutable_list:substrait.AggregateFunction.args) - return &args_; -} -inline const ::substrait::Expression& AggregateFunction::_internal_args(int index) const { - return args_.Get(index); -} -inline const ::substrait::Expression& AggregateFunction::args(int index) const { - // @@protoc_insertion_point(field_get:substrait.AggregateFunction.args) - return _internal_args(index); -} -inline ::substrait::Expression* AggregateFunction::_internal_add_args() { - return args_.Add(); -} -inline ::substrait::Expression* AggregateFunction::add_args() { - ::substrait::Expression* _add = _internal_add_args(); - // @@protoc_insertion_point(field_add:substrait.AggregateFunction.args) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& -AggregateFunction::args() const { - // @@protoc_insertion_point(field_list:substrait.AggregateFunction.args) - return args_; -} - -// repeated .substrait.SortField sorts = 3; -inline int AggregateFunction::_internal_sorts_size() const { - return sorts_.size(); -} -inline int AggregateFunction::sorts_size() const { - return _internal_sorts_size(); -} -inline void AggregateFunction::clear_sorts() { - sorts_.Clear(); -} -inline ::substrait::SortField* AggregateFunction::mutable_sorts(int index) { - // @@protoc_insertion_point(field_mutable:substrait.AggregateFunction.sorts) - return sorts_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* -AggregateFunction::mutable_sorts() { - // @@protoc_insertion_point(field_mutable_list:substrait.AggregateFunction.sorts) - return &sorts_; -} -inline const ::substrait::SortField& AggregateFunction::_internal_sorts(int index) const { - return sorts_.Get(index); -} -inline const ::substrait::SortField& AggregateFunction::sorts(int index) const { - // @@protoc_insertion_point(field_get:substrait.AggregateFunction.sorts) - return _internal_sorts(index); -} -inline ::substrait::SortField* AggregateFunction::_internal_add_sorts() { - return sorts_.Add(); -} -inline ::substrait::SortField* AggregateFunction::add_sorts() { - ::substrait::SortField* _add = _internal_add_sorts(); - // @@protoc_insertion_point(field_add:substrait.AggregateFunction.sorts) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& -AggregateFunction::sorts() const { - // @@protoc_insertion_point(field_list:substrait.AggregateFunction.sorts) - return sorts_; -} - -// .substrait.AggregationPhase phase = 4; -inline void AggregateFunction::clear_phase() { - phase_ = 0; -} -inline ::substrait::AggregationPhase AggregateFunction::_internal_phase() const { - return static_cast< ::substrait::AggregationPhase >(phase_); -} -inline ::substrait::AggregationPhase AggregateFunction::phase() const { - // @@protoc_insertion_point(field_get:substrait.AggregateFunction.phase) - return _internal_phase(); -} -inline void AggregateFunction::_internal_set_phase(::substrait::AggregationPhase value) { - - phase_ = value; -} -inline void AggregateFunction::set_phase(::substrait::AggregationPhase value) { - _internal_set_phase(value); - // @@protoc_insertion_point(field_set:substrait.AggregateFunction.phase) -} - -// .substrait.Type output_type = 5; -inline bool AggregateFunction::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; -} -inline bool AggregateFunction::has_output_type() const { - return _internal_has_output_type(); -} -inline const ::substrait::Type& AggregateFunction::_internal_output_type() const { - const ::substrait::Type* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Type_default_instance_); -} -inline const ::substrait::Type& AggregateFunction::output_type() const { - // @@protoc_insertion_point(field_get:substrait.AggregateFunction.output_type) - return _internal_output_type(); -} -inline void AggregateFunction::unsafe_arena_set_allocated_output_type( - ::substrait::Type* output_type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - output_type_ = output_type; - if (output_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateFunction.output_type) -} -inline ::substrait::Type* AggregateFunction::release_output_type() { - - ::substrait::Type* temp = output_type_; - output_type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Type* AggregateFunction::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:substrait.AggregateFunction.output_type) - - ::substrait::Type* temp = output_type_; - output_type_ = nullptr; - return temp; -} -inline ::substrait::Type* AggregateFunction::_internal_mutable_output_type() { - - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); - output_type_ = p; - } - return output_type_; -} -inline ::substrait::Type* AggregateFunction::mutable_output_type() { - ::substrait::Type* _msg = _internal_mutable_output_type(); - // @@protoc_insertion_point(field_mutable:substrait.AggregateFunction.output_type) - return _msg; -} -inline void AggregateFunction::set_allocated_output_type(::substrait::Type* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - if (output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); - if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); - } - - } else { - - } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:substrait.AggregateFunction.output_type) -} - -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace substrait - -PROTOBUF_NAMESPACE_OPEN - -template <> struct is_proto_enum< ::substrait::SortField_SortDirection> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::SortField_SortDirection>() { - return ::substrait::SortField_SortDirection_descriptor(); -} -template <> struct is_proto_enum< ::substrait::AggregationPhase> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::AggregationPhase>() { - return ::substrait::AggregationPhase_descriptor(); -} - -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fexpression_2eproto diff --git a/cpp/src/generated/substrait/extensions/extensions.pb.cc b/cpp/src/generated/substrait/extensions/extensions.pb.cc deleted file mode 100644 index 564fb8fb347..00000000000 --- a/cpp/src/generated/substrait/extensions/extensions.pb.cc +++ /dev/null @@ -1,1881 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/extensions/extensions.proto - -#include "substrait/extensions/extensions.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace substrait { -namespace extensions { -constexpr SimpleExtensionURI::SimpleExtensionURI( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , extension_uri_anchor_(0u){} -struct SimpleExtensionURIDefaultTypeInternal { - constexpr SimpleExtensionURIDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SimpleExtensionURIDefaultTypeInternal() {} - union { - SimpleExtensionURI _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionURIDefaultTypeInternal _SimpleExtensionURI_default_instance_; -constexpr SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , extension_uri_reference_(0u) - , type_anchor_(0u){} -struct SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal { - constexpr SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal() {} - union { - SimpleExtensionDeclaration_ExtensionType _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionType_default_instance_; -constexpr SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , extension_uri_reference_(0u) - , type_variation_anchor_(0u){} -struct SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal { - constexpr SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal() {} - union { - SimpleExtensionDeclaration_ExtensionTypeVariation _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_; -constexpr SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , extension_uri_reference_(0u) - , function_anchor_(0u){} -struct SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal { - constexpr SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal() {} - union { - SimpleExtensionDeclaration_ExtensionFunction _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionFunction_default_instance_; -constexpr SimpleExtensionDeclaration::SimpleExtensionDeclaration( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct SimpleExtensionDeclarationDefaultTypeInternal { - constexpr SimpleExtensionDeclarationDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SimpleExtensionDeclarationDefaultTypeInternal() {} - union { - SimpleExtensionDeclaration _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SimpleExtensionDeclarationDefaultTypeInternal _SimpleExtensionDeclaration_default_instance_; -constexpr AdvancedExtension::AdvancedExtension( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : optimization_(nullptr) - , enhancement_(nullptr){} -struct AdvancedExtensionDefaultTypeInternal { - constexpr AdvancedExtensionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~AdvancedExtensionDefaultTypeInternal() {} - union { - AdvancedExtension _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AdvancedExtensionDefaultTypeInternal _AdvancedExtension_default_instance_; -} // namespace extensions -} // namespace substrait -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fextensions_2fextensions_2eproto[6]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fextensions_2fextensions_2eproto = nullptr; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fextensions_2fextensions_2eproto = nullptr; - -const uint32_t TableStruct_substrait_2fextensions_2fextensions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, extension_uri_anchor_), - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionURI, uri_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, type_anchor_), - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType, name_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_), - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation, name_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, extension_uri_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, function_anchor_), - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction, name_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::extensions::SimpleExtensionDeclaration, mapping_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, optimization_), - PROTOBUF_FIELD_OFFSET(::substrait::extensions::AdvancedExtension, enhancement_), -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, -1, sizeof(::substrait::extensions::SimpleExtensionURI)}, - { 8, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType)}, - { 17, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation)}, - { 26, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction)}, - { 35, -1, -1, sizeof(::substrait::extensions::SimpleExtensionDeclaration)}, - { 45, -1, -1, sizeof(::substrait::extensions::AdvancedExtension)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::substrait::extensions::_SimpleExtensionURI_default_instance_), - reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_), - reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_), - reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_), - reinterpret_cast(&::substrait::extensions::_SimpleExtensionDeclaration_default_instance_), - reinterpret_cast(&::substrait::extensions::_AdvancedExtension_default_instance_), -}; - -const char descriptor_table_protodef_substrait_2fextensions_2fextensions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n%substrait/extensions/extensions.proto\022" - "\024substrait.extensions\032\031google/protobuf/a" - "ny.proto\"\?\n\022SimpleExtensionURI\022\034\n\024extens" - "ion_uri_anchor\030\001 \001(\r\022\013\n\003uri\030\002 \001(\t\"\357\004\n\032Si" - "mpleExtensionDeclaration\022X\n\016extension_ty" - "pe\030\001 \001(\0132>.substrait.extensions.SimpleEx" - "tensionDeclaration.ExtensionTypeH\000\022k\n\030ex" - "tension_type_variation\030\002 \001(\0132G.substrait" - ".extensions.SimpleExtensionDeclaration.E" - "xtensionTypeVariationH\000\022`\n\022extension_fun" - "ction\030\003 \001(\0132B.substrait.extensions.Simpl" - "eExtensionDeclaration.ExtensionFunctionH" - "\000\032S\n\rExtensionType\022\037\n\027extension_uri_refe" - "rence\030\001 \001(\r\022\023\n\013type_anchor\030\002 \001(\r\022\014\n\004name" - "\030\003 \001(\t\032f\n\026ExtensionTypeVariation\022\037\n\027exte" - "nsion_uri_reference\030\001 \001(\r\022\035\n\025type_variat" - "ion_anchor\030\002 \001(\r\022\014\n\004name\030\003 \001(\t\032[\n\021Extens" - "ionFunction\022\037\n\027extension_uri_reference\030\001" - " \001(\r\022\027\n\017function_anchor\030\002 \001(\r\022\014\n\004name\030\003 " - "\001(\tB\016\n\014mapping_type\"j\n\021AdvancedExtension" - "\022*\n\014optimization\030\001 \001(\0132\024.google.protobuf" - ".Any\022)\n\013enhancement\030\002 \001(\0132\024.google.proto" - "buf.AnyB+\n\022io.substrait.protoP\001\252\002\022Substr" - "ait.Protobufb\006proto3" - ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fextensions_2fextensions_2eproto_deps[1] = { - &::descriptor_table_google_2fprotobuf_2fany_2eproto, -}; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fextensions_2fextensions_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fextensions_2fextensions_2eproto = { - false, false, 940, descriptor_table_protodef_substrait_2fextensions_2fextensions_2eproto, "substrait/extensions/extensions.proto", - &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, descriptor_table_substrait_2fextensions_2fextensions_2eproto_deps, 1, 6, - schemas, file_default_instances, TableStruct_substrait_2fextensions_2fextensions_2eproto::offsets, - file_level_metadata_substrait_2fextensions_2fextensions_2eproto, file_level_enum_descriptors_substrait_2fextensions_2fextensions_2eproto, file_level_service_descriptors_substrait_2fextensions_2fextensions_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter() { - return &descriptor_table_substrait_2fextensions_2fextensions_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fextensions_2fextensions_2eproto(&descriptor_table_substrait_2fextensions_2fextensions_2eproto); -namespace substrait { -namespace extensions { - -// =================================================================== - -class SimpleExtensionURI::_Internal { - public: -}; - -SimpleExtensionURI::SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionURI) -} -SimpleExtensionURI::SimpleExtensionURI(const SimpleExtensionURI& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_uri().empty()) { - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), - GetArenaForAllocation()); - } - extension_uri_anchor_ = from.extension_uri_anchor_; - // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionURI) -} - -inline void SimpleExtensionURI::SharedCtor() { -uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -extension_uri_anchor_ = 0u; -} - -SimpleExtensionURI::~SimpleExtensionURI() { - // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionURI) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void SimpleExtensionURI::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void SimpleExtensionURI::ArenaDtor(void* object) { - SimpleExtensionURI* _this = reinterpret_cast< SimpleExtensionURI* >(object); - (void)_this; -} -void SimpleExtensionURI::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SimpleExtensionURI::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SimpleExtensionURI::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionURI) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - uri_.ClearToEmpty(); - extension_uri_anchor_ = 0u; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SimpleExtensionURI::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 extension_uri_anchor = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - extension_uri_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string uri = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_uri(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionURI.uri")); - 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* SimpleExtensionURI::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionURI) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 extension_uri_anchor = 1; - if (this->_internal_extension_uri_anchor() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_anchor(), target); - } - - // string uri = 2; - if (!this->_internal_uri().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_uri().data(), static_cast(this->_internal_uri().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.extensions.SimpleExtensionURI.uri"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_uri(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionURI) - return target; -} - -size_t SimpleExtensionURI::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionURI) - 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 uri = 2; - if (!this->_internal_uri().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_uri()); - } - - // uint32 extension_uri_anchor = 1; - if (this->_internal_extension_uri_anchor() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_anchor()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionURI::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - SimpleExtensionURI::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionURI::GetClassData() const { return &_class_data_; } - -void SimpleExtensionURI::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void SimpleExtensionURI::MergeFrom(const SimpleExtensionURI& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionURI) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_uri().empty()) { - _internal_set_uri(from._internal_uri()); - } - if (from._internal_extension_uri_anchor() != 0) { - _internal_set_extension_uri_anchor(from._internal_extension_uri_anchor()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SimpleExtensionURI::CopyFrom(const SimpleExtensionURI& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionURI) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SimpleExtensionURI::IsInitialized() const { - return true; -} - -void SimpleExtensionURI::InternalSwap(SimpleExtensionURI* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &uri_, lhs_arena, - &other->uri_, rhs_arena - ); - swap(extension_uri_anchor_, other->extension_uri_anchor_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionURI::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, - file_level_metadata_substrait_2fextensions_2fextensions_2eproto[0]); -} - -// =================================================================== - -class SimpleExtensionDeclaration_ExtensionType::_Internal { - public: -}; - -SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) -} -SimpleExtensionDeclaration_ExtensionType::SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArenaForAllocation()); - } - ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, - static_cast(reinterpret_cast(&type_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); - // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) -} - -inline void SimpleExtensionDeclaration_ExtensionType::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&type_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); -} - -SimpleExtensionDeclaration_ExtensionType::~SimpleExtensionDeclaration_ExtensionType() { - // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void SimpleExtensionDeclaration_ExtensionType::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void SimpleExtensionDeclaration_ExtensionType::ArenaDtor(void* object) { - SimpleExtensionDeclaration_ExtensionType* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionType* >(object); - (void)_this; -} -void SimpleExtensionDeclaration_ExtensionType::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SimpleExtensionDeclaration_ExtensionType::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SimpleExtensionDeclaration_ExtensionType::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmpty(); - ::memset(&extension_uri_reference_, 0, static_cast( - reinterpret_cast(&type_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(type_anchor_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SimpleExtensionDeclaration_ExtensionType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 extension_uri_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 type_anchor = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - type_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name")); - 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* SimpleExtensionDeclaration_ExtensionType::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 extension_uri_reference = 1; - if (this->_internal_extension_uri_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); - } - - // uint32 type_anchor = 2; - if (this->_internal_type_anchor() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_anchor(), target); - } - - // string name = 3; - if (!this->_internal_name().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_name(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - return target; -} - -size_t SimpleExtensionDeclaration_ExtensionType::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - 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 name = 3; - if (!this->_internal_name().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // uint32 extension_uri_reference = 1; - if (this->_internal_extension_uri_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_reference()); - } - - // uint32 type_anchor = 2; - if (this->_internal_type_anchor() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_anchor()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration_ExtensionType::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - SimpleExtensionDeclaration_ExtensionType::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration_ExtensionType::GetClassData() const { return &_class_data_; } - -void SimpleExtensionDeclaration_ExtensionType::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void SimpleExtensionDeclaration_ExtensionType::MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_name().empty()) { - _internal_set_name(from._internal_name()); - } - if (from._internal_extension_uri_reference() != 0) { - _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); - } - if (from._internal_type_anchor() != 0) { - _internal_set_type_anchor(from._internal_type_anchor()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SimpleExtensionDeclaration_ExtensionType::CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SimpleExtensionDeclaration_ExtensionType::IsInitialized() const { - return true; -} - -void SimpleExtensionDeclaration_ExtensionType::InternalSwap(SimpleExtensionDeclaration_ExtensionType* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &name_, lhs_arena, - &other->name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, type_anchor_) - + sizeof(SimpleExtensionDeclaration_ExtensionType::type_anchor_) - - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionType, extension_uri_reference_)>( - reinterpret_cast(&extension_uri_reference_), - reinterpret_cast(&other->extension_uri_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionType::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, - file_level_metadata_substrait_2fextensions_2fextensions_2eproto[1]); -} - -// =================================================================== - -class SimpleExtensionDeclaration_ExtensionTypeVariation::_Internal { - public: -}; - -SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) -} -SimpleExtensionDeclaration_ExtensionTypeVariation::SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArenaForAllocation()); - } - ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, - static_cast(reinterpret_cast(&type_variation_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(type_variation_anchor_)); - // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) -} - -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&type_variation_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(type_variation_anchor_)); -} - -SimpleExtensionDeclaration_ExtensionTypeVariation::~SimpleExtensionDeclaration_ExtensionTypeVariation() { - // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::ArenaDtor(void* object) { - SimpleExtensionDeclaration_ExtensionTypeVariation* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionTypeVariation* >(object); - (void)_this; -} -void SimpleExtensionDeclaration_ExtensionTypeVariation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SimpleExtensionDeclaration_ExtensionTypeVariation::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmpty(); - ::memset(&extension_uri_reference_, 0, static_cast( - reinterpret_cast(&type_variation_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(type_variation_anchor_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 extension_uri_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 type_variation_anchor = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - type_variation_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name")); - 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* SimpleExtensionDeclaration_ExtensionTypeVariation::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 extension_uri_reference = 1; - if (this->_internal_extension_uri_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); - } - - // uint32 type_variation_anchor = 2; - if (this->_internal_type_variation_anchor() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_anchor(), target); - } - - // string name = 3; - if (!this->_internal_name().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_name(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - return target; -} - -size_t SimpleExtensionDeclaration_ExtensionTypeVariation::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - 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 name = 3; - if (!this->_internal_name().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // uint32 extension_uri_reference = 1; - if (this->_internal_extension_uri_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_reference()); - } - - // uint32 type_variation_anchor = 2; - if (this->_internal_type_variation_anchor() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_anchor()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration_ExtensionTypeVariation::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - SimpleExtensionDeclaration_ExtensionTypeVariation::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration_ExtensionTypeVariation::GetClassData() const { return &_class_data_; } - -void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_name().empty()) { - _internal_set_name(from._internal_name()); - } - if (from._internal_extension_uri_reference() != 0) { - _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); - } - if (from._internal_type_variation_anchor() != 0) { - _internal_set_type_variation_anchor(from._internal_type_variation_anchor()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SimpleExtensionDeclaration_ExtensionTypeVariation::IsInitialized() const { - return true; -} - -void SimpleExtensionDeclaration_ExtensionTypeVariation::InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &name_, lhs_arena, - &other->name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, type_variation_anchor_) - + sizeof(SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor_) - - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionTypeVariation, extension_uri_reference_)>( - reinterpret_cast(&extension_uri_reference_), - reinterpret_cast(&other->extension_uri_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionTypeVariation::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, - file_level_metadata_substrait_2fextensions_2fextensions_2eproto[2]); -} - -// =================================================================== - -class SimpleExtensionDeclaration_ExtensionFunction::_Internal { - public: -}; - -SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) -} -SimpleExtensionDeclaration_ExtensionFunction::SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArenaForAllocation()); - } - ::memcpy(&extension_uri_reference_, &from.extension_uri_reference_, - static_cast(reinterpret_cast(&function_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(function_anchor_)); - // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) -} - -inline void SimpleExtensionDeclaration_ExtensionFunction::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&extension_uri_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&function_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(function_anchor_)); -} - -SimpleExtensionDeclaration_ExtensionFunction::~SimpleExtensionDeclaration_ExtensionFunction() { - // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void SimpleExtensionDeclaration_ExtensionFunction::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void SimpleExtensionDeclaration_ExtensionFunction::ArenaDtor(void* object) { - SimpleExtensionDeclaration_ExtensionFunction* _this = reinterpret_cast< SimpleExtensionDeclaration_ExtensionFunction* >(object); - (void)_this; -} -void SimpleExtensionDeclaration_ExtensionFunction::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SimpleExtensionDeclaration_ExtensionFunction::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SimpleExtensionDeclaration_ExtensionFunction::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmpty(); - ::memset(&extension_uri_reference_, 0, static_cast( - reinterpret_cast(&function_anchor_) - - reinterpret_cast(&extension_uri_reference_)) + sizeof(function_anchor_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SimpleExtensionDeclaration_ExtensionFunction::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 extension_uri_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - extension_uri_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 function_anchor = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - function_anchor_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name")); - 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* SimpleExtensionDeclaration_ExtensionFunction::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 extension_uri_reference = 1; - if (this->_internal_extension_uri_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_extension_uri_reference(), target); - } - - // uint32 function_anchor = 2; - if (this->_internal_function_anchor() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_function_anchor(), target); - } - - // string name = 3; - if (!this->_internal_name().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_name(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - return target; -} - -size_t SimpleExtensionDeclaration_ExtensionFunction::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - 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 name = 3; - if (!this->_internal_name().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // uint32 extension_uri_reference = 1; - if (this->_internal_extension_uri_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_extension_uri_reference()); - } - - // uint32 function_anchor = 2; - if (this->_internal_function_anchor() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_function_anchor()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration_ExtensionFunction::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - SimpleExtensionDeclaration_ExtensionFunction::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration_ExtensionFunction::GetClassData() const { return &_class_data_; } - -void SimpleExtensionDeclaration_ExtensionFunction::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_name().empty()) { - _internal_set_name(from._internal_name()); - } - if (from._internal_extension_uri_reference() != 0) { - _internal_set_extension_uri_reference(from._internal_extension_uri_reference()); - } - if (from._internal_function_anchor() != 0) { - _internal_set_function_anchor(from._internal_function_anchor()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SimpleExtensionDeclaration_ExtensionFunction::CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SimpleExtensionDeclaration_ExtensionFunction::IsInitialized() const { - return true; -} - -void SimpleExtensionDeclaration_ExtensionFunction::InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &name_, lhs_arena, - &other->name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, function_anchor_) - + sizeof(SimpleExtensionDeclaration_ExtensionFunction::function_anchor_) - - PROTOBUF_FIELD_OFFSET(SimpleExtensionDeclaration_ExtensionFunction, extension_uri_reference_)>( - reinterpret_cast(&extension_uri_reference_), - reinterpret_cast(&other->extension_uri_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration_ExtensionFunction::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, - file_level_metadata_substrait_2fextensions_2fextensions_2eproto[3]); -} - -// =================================================================== - -class SimpleExtensionDeclaration::_Internal { - public: - static const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type(const SimpleExtensionDeclaration* msg); - static const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation(const SimpleExtensionDeclaration* msg); - static const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function(const SimpleExtensionDeclaration* msg); -}; - -const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& -SimpleExtensionDeclaration::_Internal::extension_type(const SimpleExtensionDeclaration* msg) { - return *msg->mapping_type_.extension_type_; -} -const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& -SimpleExtensionDeclaration::_Internal::extension_type_variation(const SimpleExtensionDeclaration* msg) { - return *msg->mapping_type_.extension_type_variation_; -} -const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& -SimpleExtensionDeclaration::_Internal::extension_function(const SimpleExtensionDeclaration* msg) { - return *msg->mapping_type_.extension_function_; -} -void SimpleExtensionDeclaration::set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_mapping_type(); - if (extension_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::extensions::SimpleExtensionDeclaration_ExtensionType>::GetOwningArena(extension_type); - if (message_arena != submessage_arena) { - extension_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_type, submessage_arena); - } - set_has_extension_type(); - mapping_type_.extension_type_ = extension_type; - } - // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type) -} -void SimpleExtensionDeclaration::set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_mapping_type(); - if (extension_type_variation) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation>::GetOwningArena(extension_type_variation); - if (message_arena != submessage_arena) { - extension_type_variation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_type_variation, submessage_arena); - } - set_has_extension_type_variation(); - mapping_type_.extension_type_variation_ = extension_type_variation; - } - // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) -} -void SimpleExtensionDeclaration::set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_mapping_type(); - if (extension_function) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction>::GetOwningArena(extension_function); - if (message_arena != submessage_arena) { - extension_function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_function, submessage_arena); - } - set_has_extension_function(); - mapping_type_.extension_function_ = extension_function; - } - // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_function) -} -SimpleExtensionDeclaration::SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.extensions.SimpleExtensionDeclaration) -} -SimpleExtensionDeclaration::SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_mapping_type(); - switch (from.mapping_type_case()) { - case kExtensionType: { - _internal_mutable_extension_type()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionType::MergeFrom(from._internal_extension_type()); - break; - } - case kExtensionTypeVariation: { - _internal_mutable_extension_type_variation()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(from._internal_extension_type_variation()); - break; - } - case kExtensionFunction: { - _internal_mutable_extension_function()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(from._internal_extension_function()); - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.extensions.SimpleExtensionDeclaration) -} - -inline void SimpleExtensionDeclaration::SharedCtor() { -clear_has_mapping_type(); -} - -SimpleExtensionDeclaration::~SimpleExtensionDeclaration() { - // @@protoc_insertion_point(destructor:substrait.extensions.SimpleExtensionDeclaration) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void SimpleExtensionDeclaration::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_mapping_type()) { - clear_mapping_type(); - } -} - -void SimpleExtensionDeclaration::ArenaDtor(void* object) { - SimpleExtensionDeclaration* _this = reinterpret_cast< SimpleExtensionDeclaration* >(object); - (void)_this; -} -void SimpleExtensionDeclaration::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SimpleExtensionDeclaration::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SimpleExtensionDeclaration::clear_mapping_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.extensions.SimpleExtensionDeclaration) - switch (mapping_type_case()) { - case kExtensionType: { - if (GetArenaForAllocation() == nullptr) { - delete mapping_type_.extension_type_; - } - break; - } - case kExtensionTypeVariation: { - if (GetArenaForAllocation() == nullptr) { - delete mapping_type_.extension_type_variation_; - } - break; - } - case kExtensionFunction: { - if (GetArenaForAllocation() == nullptr) { - delete mapping_type_.extension_function_; - } - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = MAPPING_TYPE_NOT_SET; -} - - -void SimpleExtensionDeclaration::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.extensions.SimpleExtensionDeclaration) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_mapping_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SimpleExtensionDeclaration::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_type_variation(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_function(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SimpleExtensionDeclaration::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.SimpleExtensionDeclaration) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; - if (_internal_has_extension_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::extension_type(this), target, stream); - } - - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; - if (_internal_has_extension_type_variation()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::extension_type_variation(this), target, stream); - } - - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; - if (_internal_has_extension_function()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::extension_function(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.SimpleExtensionDeclaration) - return target; -} - -size_t SimpleExtensionDeclaration::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.SimpleExtensionDeclaration) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (mapping_type_case()) { - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; - case kExtensionType: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *mapping_type_.extension_type_); - break; - } - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; - case kExtensionTypeVariation: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *mapping_type_.extension_type_variation_); - break; - } - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; - case kExtensionFunction: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *mapping_type_.extension_function_); - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SimpleExtensionDeclaration::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - SimpleExtensionDeclaration::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SimpleExtensionDeclaration::GetClassData() const { return &_class_data_; } - -void SimpleExtensionDeclaration::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void SimpleExtensionDeclaration::MergeFrom(const SimpleExtensionDeclaration& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.SimpleExtensionDeclaration) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.mapping_type_case()) { - case kExtensionType: { - _internal_mutable_extension_type()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionType::MergeFrom(from._internal_extension_type()); - break; - } - case kExtensionTypeVariation: { - _internal_mutable_extension_type_variation()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation::MergeFrom(from._internal_extension_type_variation()); - break; - } - case kExtensionFunction: { - _internal_mutable_extension_function()->::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction::MergeFrom(from._internal_extension_function()); - break; - } - case MAPPING_TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SimpleExtensionDeclaration::CopyFrom(const SimpleExtensionDeclaration& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.SimpleExtensionDeclaration) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SimpleExtensionDeclaration::IsInitialized() const { - return true; -} - -void SimpleExtensionDeclaration::InternalSwap(SimpleExtensionDeclaration* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(mapping_type_, other->mapping_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SimpleExtensionDeclaration::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, - file_level_metadata_substrait_2fextensions_2fextensions_2eproto[4]); -} - -// =================================================================== - -class AdvancedExtension::_Internal { - public: - static const ::PROTOBUF_NAMESPACE_ID::Any& optimization(const AdvancedExtension* msg); - static const ::PROTOBUF_NAMESPACE_ID::Any& enhancement(const AdvancedExtension* msg); -}; - -const ::PROTOBUF_NAMESPACE_ID::Any& -AdvancedExtension::_Internal::optimization(const AdvancedExtension* msg) { - return *msg->optimization_; -} -const ::PROTOBUF_NAMESPACE_ID::Any& -AdvancedExtension::_Internal::enhancement(const AdvancedExtension* msg) { - return *msg->enhancement_; -} -void AdvancedExtension::clear_optimization() { - if (GetArenaForAllocation() == nullptr && optimization_ != nullptr) { - delete optimization_; - } - optimization_ = nullptr; -} -void AdvancedExtension::clear_enhancement() { - if (GetArenaForAllocation() == nullptr && enhancement_ != nullptr) { - delete enhancement_; - } - enhancement_ = nullptr; -} -AdvancedExtension::AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.extensions.AdvancedExtension) -} -AdvancedExtension::AdvancedExtension(const AdvancedExtension& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_optimization()) { - optimization_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.optimization_); - } else { - optimization_ = nullptr; - } - if (from._internal_has_enhancement()) { - enhancement_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.enhancement_); - } else { - enhancement_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.extensions.AdvancedExtension) -} - -inline void AdvancedExtension::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&optimization_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&enhancement_) - - reinterpret_cast(&optimization_)) + sizeof(enhancement_)); -} - -AdvancedExtension::~AdvancedExtension() { - // @@protoc_insertion_point(destructor:substrait.extensions.AdvancedExtension) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void AdvancedExtension::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete optimization_; - if (this != internal_default_instance()) delete enhancement_; -} - -void AdvancedExtension::ArenaDtor(void* object) { - AdvancedExtension* _this = reinterpret_cast< AdvancedExtension* >(object); - (void)_this; -} -void AdvancedExtension::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void AdvancedExtension::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void AdvancedExtension::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.extensions.AdvancedExtension) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && optimization_ != nullptr) { - delete optimization_; - } - optimization_ = nullptr; - if (GetArenaForAllocation() == nullptr && enhancement_ != nullptr) { - delete enhancement_; - } - enhancement_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* AdvancedExtension::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .google.protobuf.Any optimization = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_optimization(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .google.protobuf.Any enhancement = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_enhancement(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* AdvancedExtension::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.extensions.AdvancedExtension) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .google.protobuf.Any optimization = 1; - if (this->_internal_has_optimization()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::optimization(this), target, stream); - } - - // .google.protobuf.Any enhancement = 2; - if (this->_internal_has_enhancement()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::enhancement(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.extensions.AdvancedExtension) - return target; -} - -size_t AdvancedExtension::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.extensions.AdvancedExtension) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .google.protobuf.Any optimization = 1; - if (this->_internal_has_optimization()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *optimization_); - } - - // .google.protobuf.Any enhancement = 2; - if (this->_internal_has_enhancement()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *enhancement_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AdvancedExtension::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - AdvancedExtension::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AdvancedExtension::GetClassData() const { return &_class_data_; } - -void AdvancedExtension::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void AdvancedExtension::MergeFrom(const AdvancedExtension& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.extensions.AdvancedExtension) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_optimization()) { - _internal_mutable_optimization()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_optimization()); - } - if (from._internal_has_enhancement()) { - _internal_mutable_enhancement()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_enhancement()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void AdvancedExtension::CopyFrom(const AdvancedExtension& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.extensions.AdvancedExtension) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool AdvancedExtension::IsInitialized() const { - return true; -} - -void AdvancedExtension::InternalSwap(AdvancedExtension* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(AdvancedExtension, enhancement_) - + sizeof(AdvancedExtension::enhancement_) - - PROTOBUF_FIELD_OFFSET(AdvancedExtension, optimization_)>( - reinterpret_cast(&optimization_), - reinterpret_cast(&other->optimization_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata AdvancedExtension::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fextensions_2fextensions_2eproto_getter, &descriptor_table_substrait_2fextensions_2fextensions_2eproto_once, - file_level_metadata_substrait_2fextensions_2fextensions_2eproto[5]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace extensions -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionURI* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionURI >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionURI >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::extensions::SimpleExtensionDeclaration* Arena::CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::extensions::SimpleExtensionDeclaration >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::extensions::AdvancedExtension* Arena::CreateMaybeMessage< ::substrait::extensions::AdvancedExtension >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::extensions::AdvancedExtension >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/extensions/extensions.pb.h b/cpp/src/generated/substrait/extensions/extensions.pb.h deleted file mode 100644 index ee6e5499e61..00000000000 --- a/cpp/src/generated/substrait/extensions/extensions.pb.h +++ /dev/null @@ -1,1966 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/extensions/extensions.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fextensions_2fextensions_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fextensions_2fextensions_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3019000 -#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 3019003 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_substrait_2fextensions_2fextensions_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_substrait_2fextensions_2fextensions_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const uint32_t offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fextensions_2fextensions_2eproto; -namespace substrait { -namespace extensions { -class AdvancedExtension; -struct AdvancedExtensionDefaultTypeInternal; -extern AdvancedExtensionDefaultTypeInternal _AdvancedExtension_default_instance_; -class SimpleExtensionDeclaration; -struct SimpleExtensionDeclarationDefaultTypeInternal; -extern SimpleExtensionDeclarationDefaultTypeInternal _SimpleExtensionDeclaration_default_instance_; -class SimpleExtensionDeclaration_ExtensionFunction; -struct SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal; -extern SimpleExtensionDeclaration_ExtensionFunctionDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionFunction_default_instance_; -class SimpleExtensionDeclaration_ExtensionType; -struct SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal; -extern SimpleExtensionDeclaration_ExtensionTypeDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionType_default_instance_; -class SimpleExtensionDeclaration_ExtensionTypeVariation; -struct SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal; -extern SimpleExtensionDeclaration_ExtensionTypeVariationDefaultTypeInternal _SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_; -class SimpleExtensionURI; -struct SimpleExtensionURIDefaultTypeInternal; -extern SimpleExtensionURIDefaultTypeInternal _SimpleExtensionURI_default_instance_; -} // namespace extensions -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> ::substrait::extensions::AdvancedExtension* Arena::CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(Arena*); -template<> ::substrait::extensions::SimpleExtensionDeclaration* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration>(Arena*); -template<> ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction>(Arena*); -template<> ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration_ExtensionType>(Arena*); -template<> ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation>(Arena*); -template<> ::substrait::extensions::SimpleExtensionURI* Arena::CreateMaybeMessage<::substrait::extensions::SimpleExtensionURI>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace substrait { -namespace extensions { - -// =================================================================== - -class SimpleExtensionURI final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionURI) */ { - public: - inline SimpleExtensionURI() : SimpleExtensionURI(nullptr) {} - ~SimpleExtensionURI() override; - explicit constexpr SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SimpleExtensionURI(const SimpleExtensionURI& from); - SimpleExtensionURI(SimpleExtensionURI&& from) noexcept - : SimpleExtensionURI() { - *this = ::std::move(from); - } - - inline SimpleExtensionURI& operator=(const SimpleExtensionURI& from) { - CopyFrom(from); - return *this; - } - inline SimpleExtensionURI& operator=(SimpleExtensionURI&& 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 SimpleExtensionURI& default_instance() { - return *internal_default_instance(); - } - static inline const SimpleExtensionURI* internal_default_instance() { - return reinterpret_cast( - &_SimpleExtensionURI_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(SimpleExtensionURI& a, SimpleExtensionURI& b) { - a.Swap(&b); - } - inline void Swap(SimpleExtensionURI* 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(SimpleExtensionURI* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SimpleExtensionURI* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SimpleExtensionURI& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const SimpleExtensionURI& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SimpleExtensionURI* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.extensions.SimpleExtensionURI"; - } - protected: - explicit SimpleExtensionURI(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kUriFieldNumber = 2, - kExtensionUriAnchorFieldNumber = 1, - }; - // string uri = 2; - void clear_uri(); - const std::string& uri() const; - template - void set_uri(ArgT0&& arg0, ArgT... args); - std::string* mutable_uri(); - PROTOBUF_NODISCARD std::string* release_uri(); - void set_allocated_uri(std::string* uri); - private: - const std::string& _internal_uri() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value); - std::string* _internal_mutable_uri(); - public: - - // uint32 extension_uri_anchor = 1; - void clear_extension_uri_anchor(); - uint32_t extension_uri_anchor() const; - void set_extension_uri_anchor(uint32_t value); - private: - uint32_t _internal_extension_uri_anchor() const; - void _internal_set_extension_uri_anchor(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionURI) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; - uint32_t extension_uri_anchor_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; -}; -// ------------------------------------------------------------------- - -class SimpleExtensionDeclaration_ExtensionType final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) */ { - public: - inline SimpleExtensionDeclaration_ExtensionType() : SimpleExtensionDeclaration_ExtensionType(nullptr) {} - ~SimpleExtensionDeclaration_ExtensionType() override; - explicit constexpr SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SimpleExtensionDeclaration_ExtensionType(const SimpleExtensionDeclaration_ExtensionType& from); - SimpleExtensionDeclaration_ExtensionType(SimpleExtensionDeclaration_ExtensionType&& from) noexcept - : SimpleExtensionDeclaration_ExtensionType() { - *this = ::std::move(from); - } - - inline SimpleExtensionDeclaration_ExtensionType& operator=(const SimpleExtensionDeclaration_ExtensionType& from) { - CopyFrom(from); - return *this; - } - inline SimpleExtensionDeclaration_ExtensionType& operator=(SimpleExtensionDeclaration_ExtensionType&& 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 SimpleExtensionDeclaration_ExtensionType& default_instance() { - return *internal_default_instance(); - } - static inline const SimpleExtensionDeclaration_ExtensionType* internal_default_instance() { - return reinterpret_cast( - &_SimpleExtensionDeclaration_ExtensionType_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(SimpleExtensionDeclaration_ExtensionType& a, SimpleExtensionDeclaration_ExtensionType& b) { - a.Swap(&b); - } - inline void Swap(SimpleExtensionDeclaration_ExtensionType* 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(SimpleExtensionDeclaration_ExtensionType* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SimpleExtensionDeclaration_ExtensionType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SimpleExtensionDeclaration_ExtensionType& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const SimpleExtensionDeclaration_ExtensionType& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SimpleExtensionDeclaration_ExtensionType* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.extensions.SimpleExtensionDeclaration.ExtensionType"; - } - protected: - explicit SimpleExtensionDeclaration_ExtensionType(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kNameFieldNumber = 3, - kExtensionUriReferenceFieldNumber = 1, - kTypeAnchorFieldNumber = 2, - }; - // string name = 3; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // uint32 extension_uri_reference = 1; - void clear_extension_uri_reference(); - uint32_t extension_uri_reference() const; - void set_extension_uri_reference(uint32_t value); - private: - uint32_t _internal_extension_uri_reference() const; - void _internal_set_extension_uri_reference(uint32_t value); - public: - - // uint32 type_anchor = 2; - void clear_type_anchor(); - uint32_t type_anchor() const; - void set_type_anchor(uint32_t value); - private: - uint32_t _internal_type_anchor() const; - void _internal_set_type_anchor(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionType) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - uint32_t extension_uri_reference_; - uint32_t type_anchor_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; -}; -// ------------------------------------------------------------------- - -class SimpleExtensionDeclaration_ExtensionTypeVariation final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) */ { - public: - inline SimpleExtensionDeclaration_ExtensionTypeVariation() : SimpleExtensionDeclaration_ExtensionTypeVariation(nullptr) {} - ~SimpleExtensionDeclaration_ExtensionTypeVariation() override; - explicit constexpr SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SimpleExtensionDeclaration_ExtensionTypeVariation(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); - SimpleExtensionDeclaration_ExtensionTypeVariation(SimpleExtensionDeclaration_ExtensionTypeVariation&& from) noexcept - : SimpleExtensionDeclaration_ExtensionTypeVariation() { - *this = ::std::move(from); - } - - inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(const SimpleExtensionDeclaration_ExtensionTypeVariation& from) { - CopyFrom(from); - return *this; - } - inline SimpleExtensionDeclaration_ExtensionTypeVariation& operator=(SimpleExtensionDeclaration_ExtensionTypeVariation&& 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 SimpleExtensionDeclaration_ExtensionTypeVariation& default_instance() { - return *internal_default_instance(); - } - static inline const SimpleExtensionDeclaration_ExtensionTypeVariation* internal_default_instance() { - return reinterpret_cast( - &_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(SimpleExtensionDeclaration_ExtensionTypeVariation& a, SimpleExtensionDeclaration_ExtensionTypeVariation& b) { - a.Swap(&b); - } - inline void Swap(SimpleExtensionDeclaration_ExtensionTypeVariation* 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(SimpleExtensionDeclaration_ExtensionTypeVariation* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SimpleExtensionDeclaration_ExtensionTypeVariation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const SimpleExtensionDeclaration_ExtensionTypeVariation& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SimpleExtensionDeclaration_ExtensionTypeVariation* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation"; - } - protected: - explicit SimpleExtensionDeclaration_ExtensionTypeVariation(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kNameFieldNumber = 3, - kExtensionUriReferenceFieldNumber = 1, - kTypeVariationAnchorFieldNumber = 2, - }; - // string name = 3; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // uint32 extension_uri_reference = 1; - void clear_extension_uri_reference(); - uint32_t extension_uri_reference() const; - void set_extension_uri_reference(uint32_t value); - private: - uint32_t _internal_extension_uri_reference() const; - void _internal_set_extension_uri_reference(uint32_t value); - public: - - // uint32 type_variation_anchor = 2; - void clear_type_variation_anchor(); - uint32_t type_variation_anchor() const; - void set_type_variation_anchor(uint32_t value); - private: - uint32_t _internal_type_variation_anchor() const; - void _internal_set_type_variation_anchor(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - uint32_t extension_uri_reference_; - uint32_t type_variation_anchor_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; -}; -// ------------------------------------------------------------------- - -class SimpleExtensionDeclaration_ExtensionFunction final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) */ { - public: - inline SimpleExtensionDeclaration_ExtensionFunction() : SimpleExtensionDeclaration_ExtensionFunction(nullptr) {} - ~SimpleExtensionDeclaration_ExtensionFunction() override; - explicit constexpr SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SimpleExtensionDeclaration_ExtensionFunction(const SimpleExtensionDeclaration_ExtensionFunction& from); - SimpleExtensionDeclaration_ExtensionFunction(SimpleExtensionDeclaration_ExtensionFunction&& from) noexcept - : SimpleExtensionDeclaration_ExtensionFunction() { - *this = ::std::move(from); - } - - inline SimpleExtensionDeclaration_ExtensionFunction& operator=(const SimpleExtensionDeclaration_ExtensionFunction& from) { - CopyFrom(from); - return *this; - } - inline SimpleExtensionDeclaration_ExtensionFunction& operator=(SimpleExtensionDeclaration_ExtensionFunction&& 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 SimpleExtensionDeclaration_ExtensionFunction& default_instance() { - return *internal_default_instance(); - } - static inline const SimpleExtensionDeclaration_ExtensionFunction* internal_default_instance() { - return reinterpret_cast( - &_SimpleExtensionDeclaration_ExtensionFunction_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(SimpleExtensionDeclaration_ExtensionFunction& a, SimpleExtensionDeclaration_ExtensionFunction& b) { - a.Swap(&b); - } - inline void Swap(SimpleExtensionDeclaration_ExtensionFunction* 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(SimpleExtensionDeclaration_ExtensionFunction* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SimpleExtensionDeclaration_ExtensionFunction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SimpleExtensionDeclaration_ExtensionFunction& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const SimpleExtensionDeclaration_ExtensionFunction& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SimpleExtensionDeclaration_ExtensionFunction* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction"; - } - protected: - explicit SimpleExtensionDeclaration_ExtensionFunction(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kNameFieldNumber = 3, - kExtensionUriReferenceFieldNumber = 1, - kFunctionAnchorFieldNumber = 2, - }; - // string name = 3; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // uint32 extension_uri_reference = 1; - void clear_extension_uri_reference(); - uint32_t extension_uri_reference() const; - void set_extension_uri_reference(uint32_t value); - private: - uint32_t _internal_extension_uri_reference() const; - void _internal_set_extension_uri_reference(uint32_t value); - public: - - // uint32 function_anchor = 2; - void clear_function_anchor(); - uint32_t function_anchor() const; - void set_function_anchor(uint32_t value); - private: - uint32_t _internal_function_anchor() const; - void _internal_set_function_anchor(uint32_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - uint32_t extension_uri_reference_; - uint32_t function_anchor_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; -}; -// ------------------------------------------------------------------- - -class SimpleExtensionDeclaration final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.SimpleExtensionDeclaration) */ { - public: - inline SimpleExtensionDeclaration() : SimpleExtensionDeclaration(nullptr) {} - ~SimpleExtensionDeclaration() override; - explicit constexpr SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SimpleExtensionDeclaration(const SimpleExtensionDeclaration& from); - SimpleExtensionDeclaration(SimpleExtensionDeclaration&& from) noexcept - : SimpleExtensionDeclaration() { - *this = ::std::move(from); - } - - inline SimpleExtensionDeclaration& operator=(const SimpleExtensionDeclaration& from) { - CopyFrom(from); - return *this; - } - inline SimpleExtensionDeclaration& operator=(SimpleExtensionDeclaration&& 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 SimpleExtensionDeclaration& default_instance() { - return *internal_default_instance(); - } - enum MappingTypeCase { - kExtensionType = 1, - kExtensionTypeVariation = 2, - kExtensionFunction = 3, - MAPPING_TYPE_NOT_SET = 0, - }; - - static inline const SimpleExtensionDeclaration* internal_default_instance() { - return reinterpret_cast( - &_SimpleExtensionDeclaration_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(SimpleExtensionDeclaration& a, SimpleExtensionDeclaration& b) { - a.Swap(&b); - } - inline void Swap(SimpleExtensionDeclaration* 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(SimpleExtensionDeclaration* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SimpleExtensionDeclaration* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SimpleExtensionDeclaration& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const SimpleExtensionDeclaration& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SimpleExtensionDeclaration* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.extensions.SimpleExtensionDeclaration"; - } - protected: - explicit SimpleExtensionDeclaration(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef SimpleExtensionDeclaration_ExtensionType ExtensionType; - typedef SimpleExtensionDeclaration_ExtensionTypeVariation ExtensionTypeVariation; - typedef SimpleExtensionDeclaration_ExtensionFunction ExtensionFunction; - - // accessors ------------------------------------------------------- - - enum : int { - kExtensionTypeFieldNumber = 1, - kExtensionTypeVariationFieldNumber = 2, - kExtensionFunctionFieldNumber = 3, - }; - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; - bool has_extension_type() const; - private: - bool _internal_has_extension_type() const; - public: - void clear_extension_type(); - const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& extension_type() const; - PROTOBUF_NODISCARD ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* release_extension_type(); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* mutable_extension_type(); - void set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type); - private: - const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& _internal_extension_type() const; - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* _internal_mutable_extension_type(); - public: - void unsafe_arena_set_allocated_extension_type( - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* unsafe_arena_release_extension_type(); - - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; - bool has_extension_type_variation() const; - private: - bool _internal_has_extension_type_variation() const; - public: - void clear_extension_type_variation(); - const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& extension_type_variation() const; - PROTOBUF_NODISCARD ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* release_extension_type_variation(); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* mutable_extension_type_variation(); - void set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation); - private: - const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& _internal_extension_type_variation() const; - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* _internal_mutable_extension_type_variation(); - public: - void unsafe_arena_set_allocated_extension_type_variation( - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* unsafe_arena_release_extension_type_variation(); - - // .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; - bool has_extension_function() const; - private: - bool _internal_has_extension_function() const; - public: - void clear_extension_function(); - const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& extension_function() const; - PROTOBUF_NODISCARD ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* release_extension_function(); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* mutable_extension_function(); - void set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function); - private: - const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& _internal_extension_function() const; - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* _internal_mutable_extension_function(); - public: - void unsafe_arena_set_allocated_extension_function( - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* unsafe_arena_release_extension_function(); - - void clear_mapping_type(); - MappingTypeCase mapping_type_case() const; - // @@protoc_insertion_point(class_scope:substrait.extensions.SimpleExtensionDeclaration) - private: - class _Internal; - void set_has_extension_type(); - void set_has_extension_type_variation(); - void set_has_extension_function(); - - inline bool has_mapping_type() const; - inline void clear_has_mapping_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union MappingTypeUnion { - constexpr MappingTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type_; - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation_; - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function_; - } mapping_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; -}; -// ------------------------------------------------------------------- - -class AdvancedExtension final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.extensions.AdvancedExtension) */ { - public: - inline AdvancedExtension() : AdvancedExtension(nullptr) {} - ~AdvancedExtension() override; - explicit constexpr AdvancedExtension(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - AdvancedExtension(const AdvancedExtension& from); - AdvancedExtension(AdvancedExtension&& from) noexcept - : AdvancedExtension() { - *this = ::std::move(from); - } - - inline AdvancedExtension& operator=(const AdvancedExtension& from) { - CopyFrom(from); - return *this; - } - inline AdvancedExtension& operator=(AdvancedExtension&& 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 AdvancedExtension& default_instance() { - return *internal_default_instance(); - } - static inline const AdvancedExtension* internal_default_instance() { - return reinterpret_cast( - &_AdvancedExtension_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(AdvancedExtension& a, AdvancedExtension& b) { - a.Swap(&b); - } - inline void Swap(AdvancedExtension* 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(AdvancedExtension* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - AdvancedExtension* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const AdvancedExtension& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const AdvancedExtension& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(AdvancedExtension* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.extensions.AdvancedExtension"; - } - protected: - explicit AdvancedExtension(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kOptimizationFieldNumber = 1, - kEnhancementFieldNumber = 2, - }; - // .google.protobuf.Any optimization = 1; - bool has_optimization() const; - private: - bool _internal_has_optimization() const; - public: - void clear_optimization(); - const ::PROTOBUF_NAMESPACE_ID::Any& optimization() const; - PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_optimization(); - ::PROTOBUF_NAMESPACE_ID::Any* mutable_optimization(); - void set_allocated_optimization(::PROTOBUF_NAMESPACE_ID::Any* optimization); - private: - const ::PROTOBUF_NAMESPACE_ID::Any& _internal_optimization() const; - ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_optimization(); - public: - void unsafe_arena_set_allocated_optimization( - ::PROTOBUF_NAMESPACE_ID::Any* optimization); - ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_optimization(); - - // .google.protobuf.Any enhancement = 2; - bool has_enhancement() const; - private: - bool _internal_has_enhancement() const; - public: - void clear_enhancement(); - const ::PROTOBUF_NAMESPACE_ID::Any& enhancement() const; - PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_enhancement(); - ::PROTOBUF_NAMESPACE_ID::Any* mutable_enhancement(); - void set_allocated_enhancement(::PROTOBUF_NAMESPACE_ID::Any* enhancement); - private: - const ::PROTOBUF_NAMESPACE_ID::Any& _internal_enhancement() const; - ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_enhancement(); - public: - void unsafe_arena_set_allocated_enhancement( - ::PROTOBUF_NAMESPACE_ID::Any* enhancement); - ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_enhancement(); - - // @@protoc_insertion_point(class_scope:substrait.extensions.AdvancedExtension) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::Any* optimization_; - ::PROTOBUF_NAMESPACE_ID::Any* enhancement_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fextensions_2fextensions_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// SimpleExtensionURI - -// uint32 extension_uri_anchor = 1; -inline void SimpleExtensionURI::clear_extension_uri_anchor() { - extension_uri_anchor_ = 0u; -} -inline uint32_t SimpleExtensionURI::_internal_extension_uri_anchor() const { - return extension_uri_anchor_; -} -inline uint32_t SimpleExtensionURI::extension_uri_anchor() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionURI.extension_uri_anchor) - return _internal_extension_uri_anchor(); -} -inline void SimpleExtensionURI::_internal_set_extension_uri_anchor(uint32_t value) { - - extension_uri_anchor_ = value; -} -inline void SimpleExtensionURI::set_extension_uri_anchor(uint32_t value) { - _internal_set_extension_uri_anchor(value); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionURI.extension_uri_anchor) -} - -// string uri = 2; -inline void SimpleExtensionURI::clear_uri() { - uri_.ClearToEmpty(); -} -inline const std::string& SimpleExtensionURI::uri() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionURI.uri) - return _internal_uri(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SimpleExtensionURI::set_uri(ArgT0&& arg0, ArgT... args) { - - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionURI.uri) -} -inline std::string* SimpleExtensionURI::mutable_uri() { - std::string* _s = _internal_mutable_uri(); - // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionURI.uri) - return _s; -} -inline const std::string& SimpleExtensionURI::_internal_uri() const { - return uri_.Get(); -} -inline void SimpleExtensionURI::_internal_set_uri(const std::string& value) { - - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* SimpleExtensionURI::_internal_mutable_uri() { - - return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* SimpleExtensionURI::release_uri() { - // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionURI.uri) - return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void SimpleExtensionURI::set_allocated_uri(std::string* uri) { - if (uri != nullptr) { - - } else { - - } - uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (uri_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionURI.uri) -} - -// ------------------------------------------------------------------- - -// SimpleExtensionDeclaration_ExtensionType - -// uint32 extension_uri_reference = 1; -inline void SimpleExtensionDeclaration_ExtensionType::clear_extension_uri_reference() { - extension_uri_reference_ = 0u; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionType::_internal_extension_uri_reference() const { - return extension_uri_reference_; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionType::extension_uri_reference() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference) - return _internal_extension_uri_reference(); -} -inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_extension_uri_reference(uint32_t value) { - - extension_uri_reference_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionType::set_extension_uri_reference(uint32_t value) { - _internal_set_extension_uri_reference(value); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.extension_uri_reference) -} - -// uint32 type_anchor = 2; -inline void SimpleExtensionDeclaration_ExtensionType::clear_type_anchor() { - type_anchor_ = 0u; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionType::_internal_type_anchor() const { - return type_anchor_; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionType::type_anchor() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor) - return _internal_type_anchor(); -} -inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_type_anchor(uint32_t value) { - - type_anchor_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionType::set_type_anchor(uint32_t value) { - _internal_set_type_anchor(value); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.type_anchor) -} - -// string name = 3; -inline void SimpleExtensionDeclaration_ExtensionType::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& SimpleExtensionDeclaration_ExtensionType::name() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SimpleExtensionDeclaration_ExtensionType::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) -} -inline std::string* SimpleExtensionDeclaration_ExtensionType::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) - return _s; -} -inline const std::string& SimpleExtensionDeclaration_ExtensionType::_internal_name() const { - return name_.Get(); -} -inline void SimpleExtensionDeclaration_ExtensionType::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionType::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionType::release_name() { - // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void SimpleExtensionDeclaration_ExtensionType::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionType.name) -} - -// ------------------------------------------------------------------- - -// SimpleExtensionDeclaration_ExtensionTypeVariation - -// uint32 extension_uri_reference = 1; -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_extension_uri_reference() { - extension_uri_reference_ = 0u; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_extension_uri_reference() const { - return extension_uri_reference_; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::extension_uri_reference() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_reference) - return _internal_extension_uri_reference(); -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_extension_uri_reference(uint32_t value) { - - extension_uri_reference_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_extension_uri_reference(uint32_t value) { - _internal_set_extension_uri_reference(value); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.extension_uri_reference) -} - -// uint32 type_variation_anchor = 2; -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_type_variation_anchor() { - type_variation_anchor_ = 0u; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_type_variation_anchor() const { - return type_variation_anchor_; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionTypeVariation::type_variation_anchor() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor) - return _internal_type_variation_anchor(); -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_type_variation_anchor(uint32_t value) { - - type_variation_anchor_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_type_variation_anchor(uint32_t value) { - _internal_set_type_variation_anchor(value); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.type_variation_anchor) -} - -// string name = 3; -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::name() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SimpleExtensionDeclaration_ExtensionTypeVariation::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) -} -inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) - return _s; -} -inline const std::string& SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_name() const { - return name_.Get(); -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionTypeVariation::release_name() { - // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void SimpleExtensionDeclaration_ExtensionTypeVariation::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation.name) -} - -// ------------------------------------------------------------------- - -// SimpleExtensionDeclaration_ExtensionFunction - -// uint32 extension_uri_reference = 1; -inline void SimpleExtensionDeclaration_ExtensionFunction::clear_extension_uri_reference() { - extension_uri_reference_ = 0u; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::_internal_extension_uri_reference() const { - return extension_uri_reference_; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::extension_uri_reference() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_reference) - return _internal_extension_uri_reference(); -} -inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_extension_uri_reference(uint32_t value) { - - extension_uri_reference_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionFunction::set_extension_uri_reference(uint32_t value) { - _internal_set_extension_uri_reference(value); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.extension_uri_reference) -} - -// uint32 function_anchor = 2; -inline void SimpleExtensionDeclaration_ExtensionFunction::clear_function_anchor() { - function_anchor_ = 0u; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::_internal_function_anchor() const { - return function_anchor_; -} -inline uint32_t SimpleExtensionDeclaration_ExtensionFunction::function_anchor() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor) - return _internal_function_anchor(); -} -inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_function_anchor(uint32_t value) { - - function_anchor_ = value; -} -inline void SimpleExtensionDeclaration_ExtensionFunction::set_function_anchor(uint32_t value) { - _internal_set_function_anchor(value); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.function_anchor) -} - -// string name = 3; -inline void SimpleExtensionDeclaration_ExtensionFunction::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::name() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void SimpleExtensionDeclaration_ExtensionFunction::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) -} -inline std::string* SimpleExtensionDeclaration_ExtensionFunction::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) - return _s; -} -inline const std::string& SimpleExtensionDeclaration_ExtensionFunction::_internal_name() const { - return name_.Get(); -} -inline void SimpleExtensionDeclaration_ExtensionFunction::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionFunction::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* SimpleExtensionDeclaration_ExtensionFunction::release_name() { - // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void SimpleExtensionDeclaration_ExtensionFunction::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction.name) -} - -// ------------------------------------------------------------------- - -// SimpleExtensionDeclaration - -// .substrait.extensions.SimpleExtensionDeclaration.ExtensionType extension_type = 1; -inline bool SimpleExtensionDeclaration::_internal_has_extension_type() const { - return mapping_type_case() == kExtensionType; -} -inline bool SimpleExtensionDeclaration::has_extension_type() const { - return _internal_has_extension_type(); -} -inline void SimpleExtensionDeclaration::set_has_extension_type() { - _oneof_case_[0] = kExtensionType; -} -inline void SimpleExtensionDeclaration::clear_extension_type() { - if (_internal_has_extension_type()) { - if (GetArenaForAllocation() == nullptr) { - delete mapping_type_.extension_type_; - } - clear_has_mapping_type(); - } -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::release_extension_type() { - // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.extension_type) - if (_internal_has_extension_type()) { - clear_has_mapping_type(); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - mapping_type_.extension_type_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& SimpleExtensionDeclaration::_internal_extension_type() const { - return _internal_has_extension_type() - ? *mapping_type_.extension_type_ - : reinterpret_cast< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType&>(::substrait::extensions::_SimpleExtensionDeclaration_ExtensionType_default_instance_); -} -inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType& SimpleExtensionDeclaration::extension_type() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.extension_type) - return _internal_extension_type(); -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::unsafe_arena_release_extension_type() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.extensions.SimpleExtensionDeclaration.extension_type) - if (_internal_has_extension_type()) { - clear_has_mapping_type(); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* temp = mapping_type_.extension_type_; - mapping_type_.extension_type_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_type(::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* extension_type) { - clear_mapping_type(); - if (extension_type) { - set_has_extension_type(); - mapping_type_.extension_type_ = extension_type; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type) -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::_internal_mutable_extension_type() { - if (!_internal_has_extension_type()) { - clear_mapping_type(); - set_has_extension_type(); - mapping_type_.extension_type_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType >(GetArenaForAllocation()); - } - return mapping_type_.extension_type_; -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* SimpleExtensionDeclaration::mutable_extension_type() { - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionType* _msg = _internal_mutable_extension_type(); - // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_type) - return _msg; -} - -// .substrait.extensions.SimpleExtensionDeclaration.ExtensionTypeVariation extension_type_variation = 2; -inline bool SimpleExtensionDeclaration::_internal_has_extension_type_variation() const { - return mapping_type_case() == kExtensionTypeVariation; -} -inline bool SimpleExtensionDeclaration::has_extension_type_variation() const { - return _internal_has_extension_type_variation(); -} -inline void SimpleExtensionDeclaration::set_has_extension_type_variation() { - _oneof_case_[0] = kExtensionTypeVariation; -} -inline void SimpleExtensionDeclaration::clear_extension_type_variation() { - if (_internal_has_extension_type_variation()) { - if (GetArenaForAllocation() == nullptr) { - delete mapping_type_.extension_type_variation_; - } - clear_has_mapping_type(); - } -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::release_extension_type_variation() { - // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) - if (_internal_has_extension_type_variation()) { - clear_has_mapping_type(); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - mapping_type_.extension_type_variation_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& SimpleExtensionDeclaration::_internal_extension_type_variation() const { - return _internal_has_extension_type_variation() - ? *mapping_type_.extension_type_variation_ - : reinterpret_cast< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation&>(::substrait::extensions::_SimpleExtensionDeclaration_ExtensionTypeVariation_default_instance_); -} -inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation& SimpleExtensionDeclaration::extension_type_variation() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) - return _internal_extension_type_variation(); -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::unsafe_arena_release_extension_type_variation() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) - if (_internal_has_extension_type_variation()) { - clear_has_mapping_type(); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* temp = mapping_type_.extension_type_variation_; - mapping_type_.extension_type_variation_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_type_variation(::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* extension_type_variation) { - clear_mapping_type(); - if (extension_type_variation) { - set_has_extension_type_variation(); - mapping_type_.extension_type_variation_ = extension_type_variation; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::_internal_mutable_extension_type_variation() { - if (!_internal_has_extension_type_variation()) { - clear_mapping_type(); - set_has_extension_type_variation(); - mapping_type_.extension_type_variation_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation >(GetArenaForAllocation()); - } - return mapping_type_.extension_type_variation_; -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* SimpleExtensionDeclaration::mutable_extension_type_variation() { - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionTypeVariation* _msg = _internal_mutable_extension_type_variation(); - // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_type_variation) - return _msg; -} - -// .substrait.extensions.SimpleExtensionDeclaration.ExtensionFunction extension_function = 3; -inline bool SimpleExtensionDeclaration::_internal_has_extension_function() const { - return mapping_type_case() == kExtensionFunction; -} -inline bool SimpleExtensionDeclaration::has_extension_function() const { - return _internal_has_extension_function(); -} -inline void SimpleExtensionDeclaration::set_has_extension_function() { - _oneof_case_[0] = kExtensionFunction; -} -inline void SimpleExtensionDeclaration::clear_extension_function() { - if (_internal_has_extension_function()) { - if (GetArenaForAllocation() == nullptr) { - delete mapping_type_.extension_function_; - } - clear_has_mapping_type(); - } -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::release_extension_function() { - // @@protoc_insertion_point(field_release:substrait.extensions.SimpleExtensionDeclaration.extension_function) - if (_internal_has_extension_function()) { - clear_has_mapping_type(); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - mapping_type_.extension_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& SimpleExtensionDeclaration::_internal_extension_function() const { - return _internal_has_extension_function() - ? *mapping_type_.extension_function_ - : reinterpret_cast< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction&>(::substrait::extensions::_SimpleExtensionDeclaration_ExtensionFunction_default_instance_); -} -inline const ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction& SimpleExtensionDeclaration::extension_function() const { - // @@protoc_insertion_point(field_get:substrait.extensions.SimpleExtensionDeclaration.extension_function) - return _internal_extension_function(); -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::unsafe_arena_release_extension_function() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.extensions.SimpleExtensionDeclaration.extension_function) - if (_internal_has_extension_function()) { - clear_has_mapping_type(); - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* temp = mapping_type_.extension_function_; - mapping_type_.extension_function_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void SimpleExtensionDeclaration::unsafe_arena_set_allocated_extension_function(::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* extension_function) { - clear_mapping_type(); - if (extension_function) { - set_has_extension_function(); - mapping_type_.extension_function_ = extension_function; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.SimpleExtensionDeclaration.extension_function) -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::_internal_mutable_extension_function() { - if (!_internal_has_extension_function()) { - clear_mapping_type(); - set_has_extension_function(); - mapping_type_.extension_function_ = CreateMaybeMessage< ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction >(GetArenaForAllocation()); - } - return mapping_type_.extension_function_; -} -inline ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* SimpleExtensionDeclaration::mutable_extension_function() { - ::substrait::extensions::SimpleExtensionDeclaration_ExtensionFunction* _msg = _internal_mutable_extension_function(); - // @@protoc_insertion_point(field_mutable:substrait.extensions.SimpleExtensionDeclaration.extension_function) - return _msg; -} - -inline bool SimpleExtensionDeclaration::has_mapping_type() const { - return mapping_type_case() != MAPPING_TYPE_NOT_SET; -} -inline void SimpleExtensionDeclaration::clear_has_mapping_type() { - _oneof_case_[0] = MAPPING_TYPE_NOT_SET; -} -inline SimpleExtensionDeclaration::MappingTypeCase SimpleExtensionDeclaration::mapping_type_case() const { - return SimpleExtensionDeclaration::MappingTypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// AdvancedExtension - -// .google.protobuf.Any optimization = 1; -inline bool AdvancedExtension::_internal_has_optimization() const { - return this != internal_default_instance() && optimization_ != nullptr; -} -inline bool AdvancedExtension::has_optimization() const { - return _internal_has_optimization(); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_optimization() const { - const ::PROTOBUF_NAMESPACE_ID::Any* p = optimization_; - return p != nullptr ? *p : reinterpret_cast( - ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::optimization() const { - // @@protoc_insertion_point(field_get:substrait.extensions.AdvancedExtension.optimization) - return _internal_optimization(); -} -inline void AdvancedExtension::unsafe_arena_set_allocated_optimization( - ::PROTOBUF_NAMESPACE_ID::Any* optimization) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_); - } - optimization_ = optimization; - if (optimization) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.AdvancedExtension.optimization) -} -inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_optimization() { - - ::PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; - optimization_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_optimization() { - // @@protoc_insertion_point(field_release:substrait.extensions.AdvancedExtension.optimization) - - ::PROTOBUF_NAMESPACE_ID::Any* temp = optimization_; - optimization_ = nullptr; - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_optimization() { - - if (optimization_ == nullptr) { - auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); - optimization_ = p; - } - return optimization_; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_optimization() { - ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_optimization(); - // @@protoc_insertion_point(field_mutable:substrait.extensions.AdvancedExtension.optimization) - return _msg; -} -inline void AdvancedExtension::set_allocated_optimization(::PROTOBUF_NAMESPACE_ID::Any* optimization) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization_); - } - if (optimization) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optimization)); - if (message_arena != submessage_arena) { - optimization = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, optimization, submessage_arena); - } - - } else { - - } - optimization_ = optimization; - // @@protoc_insertion_point(field_set_allocated:substrait.extensions.AdvancedExtension.optimization) -} - -// .google.protobuf.Any enhancement = 2; -inline bool AdvancedExtension::_internal_has_enhancement() const { - return this != internal_default_instance() && enhancement_ != nullptr; -} -inline bool AdvancedExtension::has_enhancement() const { - return _internal_has_enhancement(); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::_internal_enhancement() const { - const ::PROTOBUF_NAMESPACE_ID::Any* p = enhancement_; - return p != nullptr ? *p : reinterpret_cast( - ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& AdvancedExtension::enhancement() const { - // @@protoc_insertion_point(field_get:substrait.extensions.AdvancedExtension.enhancement) - return _internal_enhancement(); -} -inline void AdvancedExtension::unsafe_arena_set_allocated_enhancement( - ::PROTOBUF_NAMESPACE_ID::Any* enhancement) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_); - } - enhancement_ = enhancement; - if (enhancement) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.extensions.AdvancedExtension.enhancement) -} -inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::release_enhancement() { - - ::PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; - enhancement_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::unsafe_arena_release_enhancement() { - // @@protoc_insertion_point(field_release:substrait.extensions.AdvancedExtension.enhancement) - - ::PROTOBUF_NAMESPACE_ID::Any* temp = enhancement_; - enhancement_ = nullptr; - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::_internal_mutable_enhancement() { - - if (enhancement_ == nullptr) { - auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); - enhancement_ = p; - } - return enhancement_; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* AdvancedExtension::mutable_enhancement() { - ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_enhancement(); - // @@protoc_insertion_point(field_mutable:substrait.extensions.AdvancedExtension.enhancement) - return _msg; -} -inline void AdvancedExtension::set_allocated_enhancement(::PROTOBUF_NAMESPACE_ID::Any* enhancement) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement_); - } - if (enhancement) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(enhancement)); - if (message_arena != submessage_arena) { - enhancement = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, enhancement, submessage_arena); - } - - } else { - - } - enhancement_ = enhancement; - // @@protoc_insertion_point(field_set_allocated:substrait.extensions.AdvancedExtension.enhancement) -} - -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace extensions -} // namespace substrait - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fextensions_2fextensions_2eproto diff --git a/cpp/src/generated/substrait/function.pb.cc b/cpp/src/generated/substrait/function.pb.cc deleted file mode 100644 index eb85050ab71..00000000000 --- a/cpp/src/generated/substrait/function.pb.cc +++ /dev/null @@ -1,4303 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/function.proto - -#include "substrait/function.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace substrait { -constexpr FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : min_args_(int64_t{0}) - , max_args_(int64_t{0}) - , consistency_(0) -{} -struct FunctionSignature_FinalArgVariadicDefaultTypeInternal { - constexpr FunctionSignature_FinalArgVariadicDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_FinalArgVariadicDefaultTypeInternal() {} - union { - FunctionSignature_FinalArgVariadic _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_FinalArgVariadicDefaultTypeInternal _FunctionSignature_FinalArgVariadic_default_instance_; -constexpr FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} -struct FunctionSignature_FinalArgNormalDefaultTypeInternal { - constexpr FunctionSignature_FinalArgNormalDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_FinalArgNormalDefaultTypeInternal() {} - union { - FunctionSignature_FinalArgNormal _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_FinalArgNormalDefaultTypeInternal _FunctionSignature_FinalArgNormal_default_instance_; -constexpr FunctionSignature_Scalar::FunctionSignature_Scalar( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : arguments_() - , name_() - , implementations_() - , description_(nullptr) - , output_type_(nullptr) - , deterministic_(false) - , session_dependent_(false) - , _oneof_case_{}{} -struct FunctionSignature_ScalarDefaultTypeInternal { - constexpr FunctionSignature_ScalarDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_ScalarDefaultTypeInternal() {} - union { - FunctionSignature_Scalar _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ScalarDefaultTypeInternal _FunctionSignature_Scalar_default_instance_; -constexpr FunctionSignature_Aggregate::FunctionSignature_Aggregate( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : arguments_() - , implementations_() - , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , description_(nullptr) - , output_type_(nullptr) - , intermediate_type_(nullptr) - , deterministic_(false) - , session_dependent_(false) - , ordered_(false) - , max_set_(uint64_t{0u}) - , _oneof_case_{}{} -struct FunctionSignature_AggregateDefaultTypeInternal { - constexpr FunctionSignature_AggregateDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_AggregateDefaultTypeInternal() {} - union { - FunctionSignature_Aggregate _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_AggregateDefaultTypeInternal _FunctionSignature_Aggregate_default_instance_; -constexpr FunctionSignature_Window::FunctionSignature_Window( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : arguments_() - , name_() - , implementations_() - , description_(nullptr) - , intermediate_type_(nullptr) - , output_type_(nullptr) - , deterministic_(false) - , session_dependent_(false) - , ordered_(false) - , window_type_(0) - - , max_set_(uint64_t{0u}) - , _oneof_case_{}{} -struct FunctionSignature_WindowDefaultTypeInternal { - constexpr FunctionSignature_WindowDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_WindowDefaultTypeInternal() {} - union { - FunctionSignature_Window _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_WindowDefaultTypeInternal _FunctionSignature_Window_default_instance_; -constexpr FunctionSignature_Description::FunctionSignature_Description( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : language_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , body_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct FunctionSignature_DescriptionDefaultTypeInternal { - constexpr FunctionSignature_DescriptionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_DescriptionDefaultTypeInternal() {} - union { - FunctionSignature_Description _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_DescriptionDefaultTypeInternal _FunctionSignature_Description_default_instance_; -constexpr FunctionSignature_Implementation::FunctionSignature_Implementation( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : uri_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , type_(0) -{} -struct FunctionSignature_ImplementationDefaultTypeInternal { - constexpr FunctionSignature_ImplementationDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_ImplementationDefaultTypeInternal() {} - union { - FunctionSignature_Implementation _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ImplementationDefaultTypeInternal _FunctionSignature_Implementation_default_instance_; -constexpr FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_(nullptr) - , constant_(false){} -struct FunctionSignature_Argument_ValueArgumentDefaultTypeInternal { - constexpr FunctionSignature_Argument_ValueArgumentDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_Argument_ValueArgumentDefaultTypeInternal() {} - union { - FunctionSignature_Argument_ValueArgument _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_ValueArgumentDefaultTypeInternal _FunctionSignature_Argument_ValueArgument_default_instance_; -constexpr FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_(nullptr){} -struct FunctionSignature_Argument_TypeArgumentDefaultTypeInternal { - constexpr FunctionSignature_Argument_TypeArgumentDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_Argument_TypeArgumentDefaultTypeInternal() {} - union { - FunctionSignature_Argument_TypeArgument _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_TypeArgumentDefaultTypeInternal _FunctionSignature_Argument_TypeArgument_default_instance_; -constexpr FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : options_() - , optional_(false){} -struct FunctionSignature_Argument_EnumArgumentDefaultTypeInternal { - constexpr FunctionSignature_Argument_EnumArgumentDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_Argument_EnumArgumentDefaultTypeInternal() {} - union { - FunctionSignature_Argument_EnumArgument _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_Argument_EnumArgumentDefaultTypeInternal _FunctionSignature_Argument_EnumArgument_default_instance_; -constexpr FunctionSignature_Argument::FunctionSignature_Argument( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , _oneof_case_{}{} -struct FunctionSignature_ArgumentDefaultTypeInternal { - constexpr FunctionSignature_ArgumentDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignature_ArgumentDefaultTypeInternal() {} - union { - FunctionSignature_Argument _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignature_ArgumentDefaultTypeInternal _FunctionSignature_Argument_default_instance_; -constexpr FunctionSignature::FunctionSignature( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} -struct FunctionSignatureDefaultTypeInternal { - constexpr FunctionSignatureDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FunctionSignatureDefaultTypeInternal() {} - union { - FunctionSignature _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FunctionSignatureDefaultTypeInternal _FunctionSignature_default_instance_; -} // namespace substrait -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ffunction_2eproto[12]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ffunction_2eproto[3]; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ffunction_2eproto = nullptr; - -const uint32_t TableStruct_substrait_2ffunction_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, min_args_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, max_args_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgVariadic, consistency_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_FinalArgNormal, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, arguments_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, name_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, description_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, deterministic_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, session_dependent_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, output_type_), - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, implementations_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Scalar, final_variable_behavior_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, arguments_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, name_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, description_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, deterministic_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, session_dependent_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, output_type_), - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, ordered_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, max_set_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, intermediate_type_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, implementations_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Aggregate, final_variable_behavior_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, arguments_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, name_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, description_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, deterministic_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, session_dependent_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, intermediate_type_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, output_type_), - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, ordered_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, max_set_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, window_type_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, implementations_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Window, final_variable_behavior_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, language_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Description, body_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, type_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Implementation, uri_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, type_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_ValueArgument, constant_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_TypeArgument, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_TypeArgument, type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, options_), - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument_EnumArgument, optional_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, name_), - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature_Argument, argument_kind_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FunctionSignature, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, -1, sizeof(::substrait::FunctionSignature_FinalArgVariadic)}, - { 9, -1, -1, sizeof(::substrait::FunctionSignature_FinalArgNormal)}, - { 15, -1, -1, sizeof(::substrait::FunctionSignature_Scalar)}, - { 31, -1, -1, sizeof(::substrait::FunctionSignature_Aggregate)}, - { 50, -1, -1, sizeof(::substrait::FunctionSignature_Window)}, - { 70, -1, -1, sizeof(::substrait::FunctionSignature_Description)}, - { 78, -1, -1, sizeof(::substrait::FunctionSignature_Implementation)}, - { 86, -1, -1, sizeof(::substrait::FunctionSignature_Argument_ValueArgument)}, - { 94, -1, -1, sizeof(::substrait::FunctionSignature_Argument_TypeArgument)}, - { 101, -1, -1, sizeof(::substrait::FunctionSignature_Argument_EnumArgument)}, - { 109, -1, -1, sizeof(::substrait::FunctionSignature_Argument)}, - { 120, -1, -1, sizeof(::substrait::FunctionSignature)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::substrait::_FunctionSignature_FinalArgVariadic_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_FinalArgNormal_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_Scalar_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_Aggregate_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_Window_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_Description_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_Implementation_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_Argument_default_instance_), - reinterpret_cast(&::substrait::_FunctionSignature_default_instance_), -}; - -const char descriptor_table_protodef_substrait_2ffunction_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\030substrait/function.proto\022\tsubstrait\032\024s" - "ubstrait/type.proto\032#substrait/parameter" - "ized_types.proto\032 substrait/type_express" - "ions.proto\"\301\025\n\021FunctionSignature\032\235\002\n\020Fin" - "alArgVariadic\022\020\n\010min_args\030\001 \001(\003\022\020\n\010max_a" - "rgs\030\002 \001(\003\022W\n\013consistency\030\003 \001(\0162B.substra" - "it.FunctionSignature.FinalArgVariadic.Pa" - "rameterConsistency\"\213\001\n\024ParameterConsiste" - "ncy\022%\n!PARAMETER_CONSISTENCY_UNSPECIFIED" - "\020\000\022$\n PARAMETER_CONSISTENCY_CONSISTENT\020\001" - "\022&\n\"PARAMETER_CONSISTENCY_INCONSISTENT\020\002" - "\032\020\n\016FinalArgNormal\032\332\003\n\006Scalar\0228\n\targumen" - "ts\030\002 \003(\0132%.substrait.FunctionSignature.A" - "rgument\022\014\n\004name\030\003 \003(\t\022=\n\013description\030\004 \001" - "(\0132(.substrait.FunctionSignature.Descrip" - "tion\022\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_d" - "ependent\030\010 \001(\010\0224\n\013output_type\030\t \001(\0132\037.su" - "bstrait.DerivationExpression\022A\n\010variadic" - "\030\n \001(\0132-.substrait.FunctionSignature.Fin" - "alArgVariadicH\000\022=\n\006normal\030\013 \001(\0132+.substr" - "ait.FunctionSignature.FinalArgNormalH\000\022D" - "\n\017implementations\030\014 \003(\0132+.substrait.Func" - "tionSignature.ImplementationB\031\n\027final_va" - "riable_behavior\032\253\004\n\tAggregate\0228\n\targumen" - "ts\030\002 \003(\0132%.substrait.FunctionSignature.A" - "rgument\022\014\n\004name\030\003 \001(\t\022=\n\013description\030\004 \001" - "(\0132(.substrait.FunctionSignature.Descrip" - "tion\022\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_d" - "ependent\030\010 \001(\010\0224\n\013output_type\030\t \001(\0132\037.su" - "bstrait.DerivationExpression\022A\n\010variadic" - "\030\n \001(\0132-.substrait.FunctionSignature.Fin" - "alArgVariadicH\000\022=\n\006normal\030\013 \001(\0132+.substr" - "ait.FunctionSignature.FinalArgNormalH\000\022\017" - "\n\007ordered\030\016 \001(\010\022\017\n\007max_set\030\014 \001(\004\022*\n\021inte" - "rmediate_type\030\r \001(\0132\017.substrait.Type\022D\n\017" - "implementations\030\017 \003(\0132+.substrait.Functi" - "onSignature.ImplementationB\031\n\027final_vari" - "able_behavior\032\336\005\n\006Window\0228\n\targuments\030\002 " - "\003(\0132%.substrait.FunctionSignature.Argume" - "nt\022\014\n\004name\030\003 \003(\t\022=\n\013description\030\004 \001(\0132(." - "substrait.FunctionSignature.Description\022" - "\025\n\rdeterministic\030\007 \001(\010\022\031\n\021session_depend" - "ent\030\010 \001(\010\022:\n\021intermediate_type\030\t \001(\0132\037.s" - "ubstrait.DerivationExpression\0224\n\013output_" - "type\030\n \001(\0132\037.substrait.DerivationExpress" - "ion\022A\n\010variadic\030\020 \001(\0132-.substrait.Functi" - "onSignature.FinalArgVariadicH\000\022=\n\006normal" - "\030\021 \001(\0132+.substrait.FunctionSignature.Fin" - "alArgNormalH\000\022\017\n\007ordered\030\013 \001(\010\022\017\n\007max_se" - "t\030\014 \001(\004\022C\n\013window_type\030\016 \001(\0162..substrait" - ".FunctionSignature.Window.WindowType\022D\n\017" - "implementations\030\017 \003(\0132+.substrait.Functi" - "onSignature.Implementation\"_\n\nWindowType" - "\022\033\n\027WINDOW_TYPE_UNSPECIFIED\020\000\022\031\n\025WINDOW_" - "TYPE_STREAMING\020\001\022\031\n\025WINDOW_TYPE_PARTITIO" - "N\020\002B\031\n\027final_variable_behavior\032-\n\013Descri" - "ption\022\020\n\010language\030\001 \001(\t\022\014\n\004body\030\002 \001(\t\032\246\001" - "\n\016Implementation\022>\n\004type\030\001 \001(\01620.substra" - "it.FunctionSignature.Implementation.Type" - "\022\013\n\003uri\030\002 \001(\t\"G\n\004Type\022\024\n\020TYPE_UNSPECIFIE" - "D\020\000\022\025\n\021TYPE_WEB_ASSEMBLY\020\001\022\022\n\016TYPE_TRINO" - "_JAR\020\002\032\265\003\n\010Argument\022\014\n\004name\030\001 \001(\t\022D\n\005val" - "ue\030\002 \001(\01323.substrait.FunctionSignature.A" - "rgument.ValueArgumentH\000\022B\n\004type\030\003 \001(\01322." - "substrait.FunctionSignature.Argument.Typ" - "eArgumentH\000\022B\n\004enum\030\004 \001(\01322.substrait.Fu" - "nctionSignature.Argument.EnumArgumentH\000\032" - "M\n\rValueArgument\022*\n\004type\030\001 \001(\0132\034.substra" - "it.ParameterizedType\022\020\n\010constant\030\002 \001(\010\032:" - "\n\014TypeArgument\022*\n\004type\030\001 \001(\0132\034.substrait" - ".ParameterizedType\0321\n\014EnumArgument\022\017\n\007op" - "tions\030\001 \003(\t\022\020\n\010optional\030\002 \001(\010B\017\n\rargumen" - "t_kindB+\n\022io.substrait.protoP\001\252\002\022Substra" - "it.Protobufb\006proto3" - ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2ffunction_2eproto_deps[3] = { - &::descriptor_table_substrait_2fparameterized_5ftypes_2eproto, - &::descriptor_table_substrait_2ftype_2eproto, - &::descriptor_table_substrait_2ftype_5fexpressions_2eproto, -}; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ffunction_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ffunction_2eproto = { - false, false, 2939, descriptor_table_protodef_substrait_2ffunction_2eproto, "substrait/function.proto", - &descriptor_table_substrait_2ffunction_2eproto_once, descriptor_table_substrait_2ffunction_2eproto_deps, 3, 12, - schemas, file_default_instances, TableStruct_substrait_2ffunction_2eproto::offsets, - file_level_metadata_substrait_2ffunction_2eproto, file_level_enum_descriptors_substrait_2ffunction_2eproto, file_level_service_descriptors_substrait_2ffunction_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ffunction_2eproto_getter() { - return &descriptor_table_substrait_2ffunction_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ffunction_2eproto(&descriptor_table_substrait_2ffunction_2eproto); -namespace substrait { -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto); - return file_level_enum_descriptors_substrait_2ffunction_2eproto[0]; -} -bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_UNSPECIFIED; -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_CONSISTENT; -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::PARAMETER_CONSISTENCY_INCONSISTENT; -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MIN; -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::ParameterConsistency_MAX; -constexpr int FunctionSignature_FinalArgVariadic::ParameterConsistency_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto); - return file_level_enum_descriptors_substrait_2ffunction_2eproto[1]; -} -bool FunctionSignature_Window_WindowType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_UNSPECIFIED; -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_STREAMING; -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WINDOW_TYPE_PARTITION; -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MIN; -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window::WindowType_MAX; -constexpr int FunctionSignature_Window::WindowType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ffunction_2eproto); - return file_level_enum_descriptors_substrait_2ffunction_2eproto[2]; -} -bool FunctionSignature_Implementation_Type_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_UNSPECIFIED; -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_WEB_ASSEMBLY; -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::TYPE_TRINO_JAR; -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MIN; -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation::Type_MAX; -constexpr int FunctionSignature_Implementation::Type_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) - -// =================================================================== - -class FunctionSignature_FinalArgVariadic::_Internal { - public: -}; - -FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.FinalArgVariadic) -} -FunctionSignature_FinalArgVariadic::FunctionSignature_FinalArgVariadic(const FunctionSignature_FinalArgVariadic& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&min_args_, &from.min_args_, - static_cast(reinterpret_cast(&consistency_) - - reinterpret_cast(&min_args_)) + sizeof(consistency_)); - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.FinalArgVariadic) -} - -inline void FunctionSignature_FinalArgVariadic::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&min_args_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&consistency_) - - reinterpret_cast(&min_args_)) + sizeof(consistency_)); -} - -FunctionSignature_FinalArgVariadic::~FunctionSignature_FinalArgVariadic() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.FinalArgVariadic) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FunctionSignature_FinalArgVariadic::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void FunctionSignature_FinalArgVariadic::ArenaDtor(void* object) { - FunctionSignature_FinalArgVariadic* _this = reinterpret_cast< FunctionSignature_FinalArgVariadic* >(object); - (void)_this; -} -void FunctionSignature_FinalArgVariadic::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_FinalArgVariadic::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_FinalArgVariadic::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.FinalArgVariadic) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&min_args_, 0, static_cast( - reinterpret_cast(&consistency_) - - reinterpret_cast(&min_args_)) + sizeof(consistency_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_FinalArgVariadic::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int64 min_args = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - min_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int64 max_args = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - max_args_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_consistency(static_cast<::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>(val)); - } 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* FunctionSignature_FinalArgVariadic::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.FinalArgVariadic) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int64 min_args = 1; - if (this->_internal_min_args() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_min_args(), target); - } - - // int64 max_args = 2; - if (this->_internal_max_args() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(2, this->_internal_max_args(), target); - } - - // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; - if (this->_internal_consistency() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_consistency(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.FinalArgVariadic) - return target; -} - -size_t FunctionSignature_FinalArgVariadic::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.FinalArgVariadic) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int64 min_args = 1; - if (this->_internal_min_args() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_min_args()); - } - - // int64 max_args = 2; - if (this->_internal_max_args() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_max_args()); - } - - // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; - if (this->_internal_consistency() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_consistency()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_FinalArgVariadic::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FunctionSignature_FinalArgVariadic::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_FinalArgVariadic::GetClassData() const { return &_class_data_; } - -void FunctionSignature_FinalArgVariadic::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FunctionSignature_FinalArgVariadic::MergeFrom(const FunctionSignature_FinalArgVariadic& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.FinalArgVariadic) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_min_args() != 0) { - _internal_set_min_args(from._internal_min_args()); - } - if (from._internal_max_args() != 0) { - _internal_set_max_args(from._internal_max_args()); - } - if (from._internal_consistency() != 0) { - _internal_set_consistency(from._internal_consistency()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FunctionSignature_FinalArgVariadic::CopyFrom(const FunctionSignature_FinalArgVariadic& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.FinalArgVariadic) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FunctionSignature_FinalArgVariadic::IsInitialized() const { - return true; -} - -void FunctionSignature_FinalArgVariadic::InternalSwap(FunctionSignature_FinalArgVariadic* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(FunctionSignature_FinalArgVariadic, consistency_) - + sizeof(FunctionSignature_FinalArgVariadic::consistency_) - - PROTOBUF_FIELD_OFFSET(FunctionSignature_FinalArgVariadic, min_args_)>( - reinterpret_cast(&min_args_), - reinterpret_cast(&other->min_args_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgVariadic::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[0]); -} - -// =================================================================== - -class FunctionSignature_FinalArgNormal::_Internal { - public: -}; - -FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.FinalArgNormal) -} -FunctionSignature_FinalArgNormal::FunctionSignature_FinalArgNormal(const FunctionSignature_FinalArgNormal& from) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.FinalArgNormal) -} - - - - - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_FinalArgNormal::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_FinalArgNormal::GetClassData() const { return &_class_data_; } - - - - - - - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_FinalArgNormal::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[1]); -} - -// =================================================================== - -class FunctionSignature_Scalar::_Internal { - public: - static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Scalar* msg); - static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Scalar* msg); - static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Scalar* msg); - static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Scalar* msg); -}; - -const ::substrait::FunctionSignature_Description& -FunctionSignature_Scalar::_Internal::description(const FunctionSignature_Scalar* msg) { - return *msg->description_; -} -const ::substrait::DerivationExpression& -FunctionSignature_Scalar::_Internal::output_type(const FunctionSignature_Scalar* msg) { - return *msg->output_type_; -} -const ::substrait::FunctionSignature_FinalArgVariadic& -FunctionSignature_Scalar::_Internal::variadic(const FunctionSignature_Scalar* msg) { - return *msg->final_variable_behavior_.variadic_; -} -const ::substrait::FunctionSignature_FinalArgNormal& -FunctionSignature_Scalar::_Internal::normal(const FunctionSignature_Scalar* msg) { - return *msg->final_variable_behavior_.normal_; -} -void FunctionSignature_Scalar::clear_output_type() { - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; -} -void FunctionSignature_Scalar::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_final_variable_behavior(); - if (variadic) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic); - if (message_arena != submessage_arena) { - variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variadic, submessage_arena); - } - set_has_variadic(); - final_variable_behavior_.variadic_ = variadic; - } - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.variadic) -} -void FunctionSignature_Scalar::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_final_variable_behavior(); - if (normal) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal); - if (message_arena != submessage_arena) { - normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, normal, submessage_arena); - } - set_has_normal(); - final_variable_behavior_.normal_ = normal; - } - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.normal) -} -FunctionSignature_Scalar::FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - arguments_(arena), - name_(arena), - implementations_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Scalar) -} -FunctionSignature_Scalar::FunctionSignature_Scalar(const FunctionSignature_Scalar& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - arguments_(from.arguments_), - name_(from.name_), - implementations_(from.implementations_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_description()) { - description_ = new ::substrait::FunctionSignature_Description(*from.description_); - } else { - description_ = nullptr; - } - if (from._internal_has_output_type()) { - output_type_ = new ::substrait::DerivationExpression(*from.output_type_); - } else { - output_type_ = nullptr; - } - ::memcpy(&deterministic_, &from.deterministic_, - static_cast(reinterpret_cast(&session_dependent_) - - reinterpret_cast(&deterministic_)) + sizeof(session_dependent_)); - clear_has_final_variable_behavior(); - switch (from.final_variable_behavior_case()) { - case kVariadic: { - _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); - break; - } - case kNormal: { - _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Scalar) -} - -inline void FunctionSignature_Scalar::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&description_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&session_dependent_) - - reinterpret_cast(&description_)) + sizeof(session_dependent_)); -clear_has_final_variable_behavior(); -} - -FunctionSignature_Scalar::~FunctionSignature_Scalar() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Scalar) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FunctionSignature_Scalar::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete description_; - if (this != internal_default_instance()) delete output_type_; - if (has_final_variable_behavior()) { - clear_final_variable_behavior(); - } -} - -void FunctionSignature_Scalar::ArenaDtor(void* object) { - FunctionSignature_Scalar* _this = reinterpret_cast< FunctionSignature_Scalar* >(object); - (void)_this; -} -void FunctionSignature_Scalar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_Scalar::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_Scalar::clear_final_variable_behavior() { -// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Scalar) - switch (final_variable_behavior_case()) { - case kVariadic: { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.variadic_; - } - break; - } - case kNormal: { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.normal_; - } - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; -} - - -void FunctionSignature_Scalar::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Scalar) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - arguments_.Clear(); - name_.Clear(); - implementations_.Clear(); - if (GetArenaForAllocation() == nullptr && description_ != nullptr) { - delete description_; - } - description_ = nullptr; - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; - ::memset(&deterministic_, 0, static_cast( - reinterpret_cast(&session_dependent_) - - reinterpret_cast(&deterministic_)) + sizeof(session_dependent_)); - clear_final_variable_behavior(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_Scalar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.FunctionSignature.Argument arguments = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_arguments(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // repeated string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Scalar.name")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.Description description = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool deterministic = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool session_dependent = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression output_type = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.FinalArgNormal normal = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.FunctionSignature.Implementation implementations = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_implementations(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<98>(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* FunctionSignature_Scalar::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Scalar) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.FunctionSignature.Argument arguments = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_arguments_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_arguments(i), target, stream); - } - - // repeated string name = 3; - for (int i = 0, n = this->_internal_name_size(); i < n; i++) { - const auto& s = this->_internal_name(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.FunctionSignature.Scalar.name"); - target = stream->WriteString(3, s, target); - } - - // .substrait.FunctionSignature.Description description = 4; - if (this->_internal_has_description()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::description(this), target, stream); - } - - // bool deterministic = 7; - if (this->_internal_deterministic() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target); - } - - // bool session_dependent = 8; - if (this->_internal_session_dependent() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); - } - - // .substrait.DerivationExpression output_type = 9; - if (this->_internal_has_output_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 9, _Internal::output_type(this), target, stream); - } - - // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; - if (_internal_has_variadic()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::variadic(this), target, stream); - } - - // .substrait.FunctionSignature.FinalArgNormal normal = 11; - if (_internal_has_normal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 11, _Internal::normal(this), target, stream); - } - - // repeated .substrait.FunctionSignature.Implementation implementations = 12; - for (unsigned int i = 0, - n = static_cast(this->_internal_implementations_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(12, this->_internal_implementations(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Scalar) - return target; -} - -size_t FunctionSignature_Scalar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Scalar) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.FunctionSignature.Argument arguments = 2; - total_size += 1UL * this->_internal_arguments_size(); - for (const auto& msg : this->arguments_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated string name = 3; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(name_.size()); - for (int i = 0, n = name_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - name_.Get(i)); - } - - // repeated .substrait.FunctionSignature.Implementation implementations = 12; - total_size += 1UL * this->_internal_implementations_size(); - for (const auto& msg : this->implementations_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.FunctionSignature.Description description = 4; - if (this->_internal_has_description()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *description_); - } - - // .substrait.DerivationExpression output_type = 9; - if (this->_internal_has_output_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *output_type_); - } - - // bool deterministic = 7; - if (this->_internal_deterministic() != 0) { - total_size += 1 + 1; - } - - // bool session_dependent = 8; - if (this->_internal_session_dependent() != 0) { - total_size += 1 + 1; - } - - switch (final_variable_behavior_case()) { - // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; - case kVariadic: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *final_variable_behavior_.variadic_); - break; - } - // .substrait.FunctionSignature.FinalArgNormal normal = 11; - case kNormal: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *final_variable_behavior_.normal_); - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Scalar::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FunctionSignature_Scalar::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Scalar::GetClassData() const { return &_class_data_; } - -void FunctionSignature_Scalar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FunctionSignature_Scalar::MergeFrom(const FunctionSignature_Scalar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Scalar) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - arguments_.MergeFrom(from.arguments_); - name_.MergeFrom(from.name_); - implementations_.MergeFrom(from.implementations_); - if (from._internal_has_description()) { - _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); - } - if (from._internal_has_output_type()) { - _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); - } - if (from._internal_deterministic() != 0) { - _internal_set_deterministic(from._internal_deterministic()); - } - if (from._internal_session_dependent() != 0) { - _internal_set_session_dependent(from._internal_session_dependent()); - } - switch (from.final_variable_behavior_case()) { - case kVariadic: { - _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); - break; - } - case kNormal: { - _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FunctionSignature_Scalar::CopyFrom(const FunctionSignature_Scalar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Scalar) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FunctionSignature_Scalar::IsInitialized() const { - return true; -} - -void FunctionSignature_Scalar::InternalSwap(FunctionSignature_Scalar* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - arguments_.InternalSwap(&other->arguments_); - name_.InternalSwap(&other->name_); - implementations_.InternalSwap(&other->implementations_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, session_dependent_) - + sizeof(FunctionSignature_Scalar::session_dependent_) - - PROTOBUF_FIELD_OFFSET(FunctionSignature_Scalar, description_)>( - reinterpret_cast(&description_), - reinterpret_cast(&other->description_)); - swap(final_variable_behavior_, other->final_variable_behavior_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Scalar::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[2]); -} - -// =================================================================== - -class FunctionSignature_Aggregate::_Internal { - public: - static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Aggregate* msg); - static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Aggregate* msg); - static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Aggregate* msg); - static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Aggregate* msg); - static const ::substrait::Type& intermediate_type(const FunctionSignature_Aggregate* msg); -}; - -const ::substrait::FunctionSignature_Description& -FunctionSignature_Aggregate::_Internal::description(const FunctionSignature_Aggregate* msg) { - return *msg->description_; -} -const ::substrait::DerivationExpression& -FunctionSignature_Aggregate::_Internal::output_type(const FunctionSignature_Aggregate* msg) { - return *msg->output_type_; -} -const ::substrait::FunctionSignature_FinalArgVariadic& -FunctionSignature_Aggregate::_Internal::variadic(const FunctionSignature_Aggregate* msg) { - return *msg->final_variable_behavior_.variadic_; -} -const ::substrait::FunctionSignature_FinalArgNormal& -FunctionSignature_Aggregate::_Internal::normal(const FunctionSignature_Aggregate* msg) { - return *msg->final_variable_behavior_.normal_; -} -const ::substrait::Type& -FunctionSignature_Aggregate::_Internal::intermediate_type(const FunctionSignature_Aggregate* msg) { - return *msg->intermediate_type_; -} -void FunctionSignature_Aggregate::clear_output_type() { - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; -} -void FunctionSignature_Aggregate::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_final_variable_behavior(); - if (variadic) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic); - if (message_arena != submessage_arena) { - variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variadic, submessage_arena); - } - set_has_variadic(); - final_variable_behavior_.variadic_ = variadic; - } - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.variadic) -} -void FunctionSignature_Aggregate::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_final_variable_behavior(); - if (normal) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal); - if (message_arena != submessage_arena) { - normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, normal, submessage_arena); - } - set_has_normal(); - final_variable_behavior_.normal_ = normal; - } - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.normal) -} -void FunctionSignature_Aggregate::clear_intermediate_type() { - if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) { - delete intermediate_type_; - } - intermediate_type_ = nullptr; -} -FunctionSignature_Aggregate::FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - arguments_(arena), - implementations_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Aggregate) -} -FunctionSignature_Aggregate::FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - arguments_(from.arguments_), - implementations_(from.implementations_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArenaForAllocation()); - } - if (from._internal_has_description()) { - description_ = new ::substrait::FunctionSignature_Description(*from.description_); - } else { - description_ = nullptr; - } - if (from._internal_has_output_type()) { - output_type_ = new ::substrait::DerivationExpression(*from.output_type_); - } else { - output_type_ = nullptr; - } - if (from._internal_has_intermediate_type()) { - intermediate_type_ = new ::substrait::Type(*from.intermediate_type_); - } else { - intermediate_type_ = nullptr; - } - ::memcpy(&deterministic_, &from.deterministic_, - static_cast(reinterpret_cast(&max_set_) - - reinterpret_cast(&deterministic_)) + sizeof(max_set_)); - clear_has_final_variable_behavior(); - switch (from.final_variable_behavior_case()) { - case kVariadic: { - _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); - break; - } - case kNormal: { - _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Aggregate) -} - -inline void FunctionSignature_Aggregate::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&description_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&max_set_) - - reinterpret_cast(&description_)) + sizeof(max_set_)); -clear_has_final_variable_behavior(); -} - -FunctionSignature_Aggregate::~FunctionSignature_Aggregate() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Aggregate) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FunctionSignature_Aggregate::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (this != internal_default_instance()) delete description_; - if (this != internal_default_instance()) delete output_type_; - if (this != internal_default_instance()) delete intermediate_type_; - if (has_final_variable_behavior()) { - clear_final_variable_behavior(); - } -} - -void FunctionSignature_Aggregate::ArenaDtor(void* object) { - FunctionSignature_Aggregate* _this = reinterpret_cast< FunctionSignature_Aggregate* >(object); - (void)_this; -} -void FunctionSignature_Aggregate::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_Aggregate::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_Aggregate::clear_final_variable_behavior() { -// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Aggregate) - switch (final_variable_behavior_case()) { - case kVariadic: { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.variadic_; - } - break; - } - case kNormal: { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.normal_; - } - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; -} - - -void FunctionSignature_Aggregate::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Aggregate) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - arguments_.Clear(); - implementations_.Clear(); - name_.ClearToEmpty(); - if (GetArenaForAllocation() == nullptr && description_ != nullptr) { - delete description_; - } - description_ = nullptr; - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; - if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) { - delete intermediate_type_; - } - intermediate_type_ = nullptr; - ::memset(&deterministic_, 0, static_cast( - reinterpret_cast(&max_set_) - - reinterpret_cast(&deterministic_)) + sizeof(max_set_)); - clear_final_variable_behavior(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_Aggregate::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.FunctionSignature.Argument arguments = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_arguments(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Aggregate.name")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.Description description = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool deterministic = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool session_dependent = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression output_type = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.FinalArgNormal normal = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint64 max_set = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - max_set_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type intermediate_type = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool ordered = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { - ordered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.FunctionSignature.Implementation implementations = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_implementations(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(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* FunctionSignature_Aggregate::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Aggregate) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.FunctionSignature.Argument arguments = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_arguments_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_arguments(i), target, stream); - } - - // string name = 3; - if (!this->_internal_name().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.FunctionSignature.Aggregate.name"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_name(), target); - } - - // .substrait.FunctionSignature.Description description = 4; - if (this->_internal_has_description()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::description(this), target, stream); - } - - // bool deterministic = 7; - if (this->_internal_deterministic() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target); - } - - // bool session_dependent = 8; - if (this->_internal_session_dependent() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); - } - - // .substrait.DerivationExpression output_type = 9; - if (this->_internal_has_output_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 9, _Internal::output_type(this), target, stream); - } - - // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; - if (_internal_has_variadic()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::variadic(this), target, stream); - } - - // .substrait.FunctionSignature.FinalArgNormal normal = 11; - if (_internal_has_normal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 11, _Internal::normal(this), target, stream); - } - - // uint64 max_set = 12; - if (this->_internal_max_set() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target); - } - - // .substrait.Type intermediate_type = 13; - if (this->_internal_has_intermediate_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 13, _Internal::intermediate_type(this), target, stream); - } - - // bool ordered = 14; - if (this->_internal_ordered() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(14, this->_internal_ordered(), target); - } - - // repeated .substrait.FunctionSignature.Implementation implementations = 15; - for (unsigned int i = 0, - n = static_cast(this->_internal_implementations_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(15, this->_internal_implementations(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Aggregate) - return target; -} - -size_t FunctionSignature_Aggregate::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Aggregate) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.FunctionSignature.Argument arguments = 2; - total_size += 1UL * this->_internal_arguments_size(); - for (const auto& msg : this->arguments_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .substrait.FunctionSignature.Implementation implementations = 15; - total_size += 1UL * this->_internal_implementations_size(); - for (const auto& msg : this->implementations_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // string name = 3; - if (!this->_internal_name().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // .substrait.FunctionSignature.Description description = 4; - if (this->_internal_has_description()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *description_); - } - - // .substrait.DerivationExpression output_type = 9; - if (this->_internal_has_output_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *output_type_); - } - - // .substrait.Type intermediate_type = 13; - if (this->_internal_has_intermediate_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *intermediate_type_); - } - - // bool deterministic = 7; - if (this->_internal_deterministic() != 0) { - total_size += 1 + 1; - } - - // bool session_dependent = 8; - if (this->_internal_session_dependent() != 0) { - total_size += 1 + 1; - } - - // bool ordered = 14; - if (this->_internal_ordered() != 0) { - total_size += 1 + 1; - } - - // uint64 max_set = 12; - if (this->_internal_max_set() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_max_set()); - } - - switch (final_variable_behavior_case()) { - // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; - case kVariadic: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *final_variable_behavior_.variadic_); - break; - } - // .substrait.FunctionSignature.FinalArgNormal normal = 11; - case kNormal: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *final_variable_behavior_.normal_); - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Aggregate::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FunctionSignature_Aggregate::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Aggregate::GetClassData() const { return &_class_data_; } - -void FunctionSignature_Aggregate::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FunctionSignature_Aggregate::MergeFrom(const FunctionSignature_Aggregate& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Aggregate) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - arguments_.MergeFrom(from.arguments_); - implementations_.MergeFrom(from.implementations_); - if (!from._internal_name().empty()) { - _internal_set_name(from._internal_name()); - } - if (from._internal_has_description()) { - _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); - } - if (from._internal_has_output_type()) { - _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); - } - if (from._internal_has_intermediate_type()) { - _internal_mutable_intermediate_type()->::substrait::Type::MergeFrom(from._internal_intermediate_type()); - } - if (from._internal_deterministic() != 0) { - _internal_set_deterministic(from._internal_deterministic()); - } - if (from._internal_session_dependent() != 0) { - _internal_set_session_dependent(from._internal_session_dependent()); - } - if (from._internal_ordered() != 0) { - _internal_set_ordered(from._internal_ordered()); - } - if (from._internal_max_set() != 0) { - _internal_set_max_set(from._internal_max_set()); - } - switch (from.final_variable_behavior_case()) { - case kVariadic: { - _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); - break; - } - case kNormal: { - _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FunctionSignature_Aggregate::CopyFrom(const FunctionSignature_Aggregate& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Aggregate) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FunctionSignature_Aggregate::IsInitialized() const { - return true; -} - -void FunctionSignature_Aggregate::InternalSwap(FunctionSignature_Aggregate* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - arguments_.InternalSwap(&other->arguments_); - implementations_.InternalSwap(&other->implementations_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &name_, lhs_arena, - &other->name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, max_set_) - + sizeof(FunctionSignature_Aggregate::max_set_) - - PROTOBUF_FIELD_OFFSET(FunctionSignature_Aggregate, description_)>( - reinterpret_cast(&description_), - reinterpret_cast(&other->description_)); - swap(final_variable_behavior_, other->final_variable_behavior_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Aggregate::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[3]); -} - -// =================================================================== - -class FunctionSignature_Window::_Internal { - public: - static const ::substrait::FunctionSignature_Description& description(const FunctionSignature_Window* msg); - static const ::substrait::DerivationExpression& intermediate_type(const FunctionSignature_Window* msg); - static const ::substrait::DerivationExpression& output_type(const FunctionSignature_Window* msg); - static const ::substrait::FunctionSignature_FinalArgVariadic& variadic(const FunctionSignature_Window* msg); - static const ::substrait::FunctionSignature_FinalArgNormal& normal(const FunctionSignature_Window* msg); -}; - -const ::substrait::FunctionSignature_Description& -FunctionSignature_Window::_Internal::description(const FunctionSignature_Window* msg) { - return *msg->description_; -} -const ::substrait::DerivationExpression& -FunctionSignature_Window::_Internal::intermediate_type(const FunctionSignature_Window* msg) { - return *msg->intermediate_type_; -} -const ::substrait::DerivationExpression& -FunctionSignature_Window::_Internal::output_type(const FunctionSignature_Window* msg) { - return *msg->output_type_; -} -const ::substrait::FunctionSignature_FinalArgVariadic& -FunctionSignature_Window::_Internal::variadic(const FunctionSignature_Window* msg) { - return *msg->final_variable_behavior_.variadic_; -} -const ::substrait::FunctionSignature_FinalArgNormal& -FunctionSignature_Window::_Internal::normal(const FunctionSignature_Window* msg) { - return *msg->final_variable_behavior_.normal_; -} -void FunctionSignature_Window::clear_intermediate_type() { - if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) { - delete intermediate_type_; - } - intermediate_type_ = nullptr; -} -void FunctionSignature_Window::clear_output_type() { - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; -} -void FunctionSignature_Window::set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_final_variable_behavior(); - if (variadic) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgVariadic>::GetOwningArena(variadic); - if (message_arena != submessage_arena) { - variadic = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, variadic, submessage_arena); - } - set_has_variadic(); - final_variable_behavior_.variadic_ = variadic; - } - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.variadic) -} -void FunctionSignature_Window::set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_final_variable_behavior(); - if (normal) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_FinalArgNormal>::GetOwningArena(normal); - if (message_arena != submessage_arena) { - normal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, normal, submessage_arena); - } - set_has_normal(); - final_variable_behavior_.normal_ = normal; - } - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.normal) -} -FunctionSignature_Window::FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - arguments_(arena), - name_(arena), - implementations_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Window) -} -FunctionSignature_Window::FunctionSignature_Window(const FunctionSignature_Window& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - arguments_(from.arguments_), - name_(from.name_), - implementations_(from.implementations_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_description()) { - description_ = new ::substrait::FunctionSignature_Description(*from.description_); - } else { - description_ = nullptr; - } - if (from._internal_has_intermediate_type()) { - intermediate_type_ = new ::substrait::DerivationExpression(*from.intermediate_type_); - } else { - intermediate_type_ = nullptr; - } - if (from._internal_has_output_type()) { - output_type_ = new ::substrait::DerivationExpression(*from.output_type_); - } else { - output_type_ = nullptr; - } - ::memcpy(&deterministic_, &from.deterministic_, - static_cast(reinterpret_cast(&max_set_) - - reinterpret_cast(&deterministic_)) + sizeof(max_set_)); - clear_has_final_variable_behavior(); - switch (from.final_variable_behavior_case()) { - case kVariadic: { - _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); - break; - } - case kNormal: { - _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Window) -} - -inline void FunctionSignature_Window::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&description_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&max_set_) - - reinterpret_cast(&description_)) + sizeof(max_set_)); -clear_has_final_variable_behavior(); -} - -FunctionSignature_Window::~FunctionSignature_Window() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Window) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FunctionSignature_Window::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete description_; - if (this != internal_default_instance()) delete intermediate_type_; - if (this != internal_default_instance()) delete output_type_; - if (has_final_variable_behavior()) { - clear_final_variable_behavior(); - } -} - -void FunctionSignature_Window::ArenaDtor(void* object) { - FunctionSignature_Window* _this = reinterpret_cast< FunctionSignature_Window* >(object); - (void)_this; -} -void FunctionSignature_Window::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_Window::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_Window::clear_final_variable_behavior() { -// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Window) - switch (final_variable_behavior_case()) { - case kVariadic: { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.variadic_; - } - break; - } - case kNormal: { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.normal_; - } - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; -} - - -void FunctionSignature_Window::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Window) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - arguments_.Clear(); - name_.Clear(); - implementations_.Clear(); - if (GetArenaForAllocation() == nullptr && description_ != nullptr) { - delete description_; - } - description_ = nullptr; - if (GetArenaForAllocation() == nullptr && intermediate_type_ != nullptr) { - delete intermediate_type_; - } - intermediate_type_ = nullptr; - if (GetArenaForAllocation() == nullptr && output_type_ != nullptr) { - delete output_type_; - } - output_type_ = nullptr; - ::memset(&deterministic_, 0, static_cast( - reinterpret_cast(&max_set_) - - reinterpret_cast(&deterministic_)) + sizeof(max_set_)); - clear_final_variable_behavior(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_Window::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.FunctionSignature.Argument arguments = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_arguments(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // repeated string name = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Window.name")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.Description description = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_description(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool deterministic = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - deterministic_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool session_dependent = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - session_dependent_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression intermediate_type = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_intermediate_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression output_type = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_output_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool ordered = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 88)) { - ordered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint64 max_set = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 96)) { - max_set_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.Window.WindowType window_type = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 112)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_window_type(static_cast<::substrait::FunctionSignature_Window_WindowType>(val)); - } else - goto handle_unusual; - continue; - // repeated .substrait.FunctionSignature.Implementation implementations = 15; - case 15: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 122)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_implementations(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<122>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.FinalArgVariadic variadic = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - ptr = ctx->ParseMessage(_internal_mutable_variadic(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.FinalArgNormal normal = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_normal(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* FunctionSignature_Window::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Window) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.FunctionSignature.Argument arguments = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_arguments_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_arguments(i), target, stream); - } - - // repeated string name = 3; - for (int i = 0, n = this->_internal_name_size(); i < n; i++) { - const auto& s = this->_internal_name(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.FunctionSignature.Window.name"); - target = stream->WriteString(3, s, target); - } - - // .substrait.FunctionSignature.Description description = 4; - if (this->_internal_has_description()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::description(this), target, stream); - } - - // bool deterministic = 7; - if (this->_internal_deterministic() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(7, this->_internal_deterministic(), target); - } - - // bool session_dependent = 8; - if (this->_internal_session_dependent() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(8, this->_internal_session_dependent(), target); - } - - // .substrait.DerivationExpression intermediate_type = 9; - if (this->_internal_has_intermediate_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 9, _Internal::intermediate_type(this), target, stream); - } - - // .substrait.DerivationExpression output_type = 10; - if (this->_internal_has_output_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::output_type(this), target, stream); - } - - // bool ordered = 11; - if (this->_internal_ordered() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(11, this->_internal_ordered(), target); - } - - // uint64 max_set = 12; - if (this->_internal_max_set() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(12, this->_internal_max_set(), target); - } - - // .substrait.FunctionSignature.Window.WindowType window_type = 14; - if (this->_internal_window_type() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 14, this->_internal_window_type(), target); - } - - // repeated .substrait.FunctionSignature.Implementation implementations = 15; - for (unsigned int i = 0, - n = static_cast(this->_internal_implementations_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(15, this->_internal_implementations(i), target, stream); - } - - // .substrait.FunctionSignature.FinalArgVariadic variadic = 16; - if (_internal_has_variadic()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 16, _Internal::variadic(this), target, stream); - } - - // .substrait.FunctionSignature.FinalArgNormal normal = 17; - if (_internal_has_normal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 17, _Internal::normal(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Window) - return target; -} - -size_t FunctionSignature_Window::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Window) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.FunctionSignature.Argument arguments = 2; - total_size += 1UL * this->_internal_arguments_size(); - for (const auto& msg : this->arguments_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated string name = 3; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(name_.size()); - for (int i = 0, n = name_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - name_.Get(i)); - } - - // repeated .substrait.FunctionSignature.Implementation implementations = 15; - total_size += 1UL * this->_internal_implementations_size(); - for (const auto& msg : this->implementations_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.FunctionSignature.Description description = 4; - if (this->_internal_has_description()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *description_); - } - - // .substrait.DerivationExpression intermediate_type = 9; - if (this->_internal_has_intermediate_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *intermediate_type_); - } - - // .substrait.DerivationExpression output_type = 10; - if (this->_internal_has_output_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *output_type_); - } - - // bool deterministic = 7; - if (this->_internal_deterministic() != 0) { - total_size += 1 + 1; - } - - // bool session_dependent = 8; - if (this->_internal_session_dependent() != 0) { - total_size += 1 + 1; - } - - // bool ordered = 11; - if (this->_internal_ordered() != 0) { - total_size += 1 + 1; - } - - // .substrait.FunctionSignature.Window.WindowType window_type = 14; - if (this->_internal_window_type() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_window_type()); - } - - // uint64 max_set = 12; - if (this->_internal_max_set() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_max_set()); - } - - switch (final_variable_behavior_case()) { - // .substrait.FunctionSignature.FinalArgVariadic variadic = 16; - case kVariadic: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *final_variable_behavior_.variadic_); - break; - } - // .substrait.FunctionSignature.FinalArgNormal normal = 17; - case kNormal: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *final_variable_behavior_.normal_); - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Window::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FunctionSignature_Window::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Window::GetClassData() const { return &_class_data_; } - -void FunctionSignature_Window::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FunctionSignature_Window::MergeFrom(const FunctionSignature_Window& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Window) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - arguments_.MergeFrom(from.arguments_); - name_.MergeFrom(from.name_); - implementations_.MergeFrom(from.implementations_); - if (from._internal_has_description()) { - _internal_mutable_description()->::substrait::FunctionSignature_Description::MergeFrom(from._internal_description()); - } - if (from._internal_has_intermediate_type()) { - _internal_mutable_intermediate_type()->::substrait::DerivationExpression::MergeFrom(from._internal_intermediate_type()); - } - if (from._internal_has_output_type()) { - _internal_mutable_output_type()->::substrait::DerivationExpression::MergeFrom(from._internal_output_type()); - } - if (from._internal_deterministic() != 0) { - _internal_set_deterministic(from._internal_deterministic()); - } - if (from._internal_session_dependent() != 0) { - _internal_set_session_dependent(from._internal_session_dependent()); - } - if (from._internal_ordered() != 0) { - _internal_set_ordered(from._internal_ordered()); - } - if (from._internal_window_type() != 0) { - _internal_set_window_type(from._internal_window_type()); - } - if (from._internal_max_set() != 0) { - _internal_set_max_set(from._internal_max_set()); - } - switch (from.final_variable_behavior_case()) { - case kVariadic: { - _internal_mutable_variadic()->::substrait::FunctionSignature_FinalArgVariadic::MergeFrom(from._internal_variadic()); - break; - } - case kNormal: { - _internal_mutable_normal()->::substrait::FunctionSignature_FinalArgNormal::MergeFrom(from._internal_normal()); - break; - } - case FINAL_VARIABLE_BEHAVIOR_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FunctionSignature_Window::CopyFrom(const FunctionSignature_Window& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Window) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FunctionSignature_Window::IsInitialized() const { - return true; -} - -void FunctionSignature_Window::InternalSwap(FunctionSignature_Window* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - arguments_.InternalSwap(&other->arguments_); - name_.InternalSwap(&other->name_); - implementations_.InternalSwap(&other->implementations_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, max_set_) - + sizeof(FunctionSignature_Window::max_set_) - - PROTOBUF_FIELD_OFFSET(FunctionSignature_Window, description_)>( - reinterpret_cast(&description_), - reinterpret_cast(&other->description_)); - swap(final_variable_behavior_, other->final_variable_behavior_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Window::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[4]); -} - -// =================================================================== - -class FunctionSignature_Description::_Internal { - public: -}; - -FunctionSignature_Description::FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Description) -} -FunctionSignature_Description::FunctionSignature_Description(const FunctionSignature_Description& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - language_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_language().empty()) { - language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_language(), - GetArenaForAllocation()); - } - body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_body().empty()) { - body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_body(), - GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Description) -} - -inline void FunctionSignature_Description::SharedCtor() { -language_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -body_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -FunctionSignature_Description::~FunctionSignature_Description() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Description) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FunctionSignature_Description::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - language_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - body_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void FunctionSignature_Description::ArenaDtor(void* object) { - FunctionSignature_Description* _this = reinterpret_cast< FunctionSignature_Description* >(object); - (void)_this; -} -void FunctionSignature_Description::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_Description::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_Description::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Description) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - language_.ClearToEmpty(); - body_.ClearToEmpty(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_Description::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string language = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_language(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Description.language")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string body = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_body(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Description.body")); - 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* FunctionSignature_Description::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Description) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string language = 1; - if (!this->_internal_language().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_language().data(), static_cast(this->_internal_language().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.FunctionSignature.Description.language"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_language(), target); - } - - // string body = 2; - if (!this->_internal_body().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_body().data(), static_cast(this->_internal_body().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.FunctionSignature.Description.body"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_body(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Description) - return target; -} - -size_t FunctionSignature_Description::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Description) - 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 language = 1; - if (!this->_internal_language().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_language()); - } - - // string body = 2; - if (!this->_internal_body().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_body()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Description::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FunctionSignature_Description::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Description::GetClassData() const { return &_class_data_; } - -void FunctionSignature_Description::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FunctionSignature_Description::MergeFrom(const FunctionSignature_Description& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Description) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_language().empty()) { - _internal_set_language(from._internal_language()); - } - if (!from._internal_body().empty()) { - _internal_set_body(from._internal_body()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FunctionSignature_Description::CopyFrom(const FunctionSignature_Description& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Description) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FunctionSignature_Description::IsInitialized() const { - return true; -} - -void FunctionSignature_Description::InternalSwap(FunctionSignature_Description* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &language_, lhs_arena, - &other->language_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &body_, lhs_arena, - &other->body_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Description::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[5]); -} - -// =================================================================== - -class FunctionSignature_Implementation::_Internal { - public: -}; - -FunctionSignature_Implementation::FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Implementation) -} -FunctionSignature_Implementation::FunctionSignature_Implementation(const FunctionSignature_Implementation& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_uri().empty()) { - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_uri(), - GetArenaForAllocation()); - } - type_ = from.type_; - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Implementation) -} - -inline void FunctionSignature_Implementation::SharedCtor() { -uri_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -type_ = 0; -} - -FunctionSignature_Implementation::~FunctionSignature_Implementation() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Implementation) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FunctionSignature_Implementation::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - uri_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void FunctionSignature_Implementation::ArenaDtor(void* object) { - FunctionSignature_Implementation* _this = reinterpret_cast< FunctionSignature_Implementation* >(object); - (void)_this; -} -void FunctionSignature_Implementation::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_Implementation::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_Implementation::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Implementation) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - uri_.ClearToEmpty(); - type_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_Implementation::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.FunctionSignature.Implementation.Type type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_type(static_cast<::substrait::FunctionSignature_Implementation_Type>(val)); - } else - goto handle_unusual; - continue; - // string uri = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_uri(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Implementation.uri")); - 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* FunctionSignature_Implementation::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Implementation) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.FunctionSignature.Implementation.Type type = 1; - if (this->_internal_type() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 1, this->_internal_type(), target); - } - - // string uri = 2; - if (!this->_internal_uri().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_uri().data(), static_cast(this->_internal_uri().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.FunctionSignature.Implementation.uri"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_uri(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Implementation) - return target; -} - -size_t FunctionSignature_Implementation::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Implementation) - 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 uri = 2; - if (!this->_internal_uri().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_uri()); - } - - // .substrait.FunctionSignature.Implementation.Type type = 1; - if (this->_internal_type() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Implementation::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FunctionSignature_Implementation::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Implementation::GetClassData() const { return &_class_data_; } - -void FunctionSignature_Implementation::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FunctionSignature_Implementation::MergeFrom(const FunctionSignature_Implementation& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Implementation) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_uri().empty()) { - _internal_set_uri(from._internal_uri()); - } - if (from._internal_type() != 0) { - _internal_set_type(from._internal_type()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FunctionSignature_Implementation::CopyFrom(const FunctionSignature_Implementation& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Implementation) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FunctionSignature_Implementation::IsInitialized() const { - return true; -} - -void FunctionSignature_Implementation::InternalSwap(FunctionSignature_Implementation* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &uri_, lhs_arena, - &other->uri_, rhs_arena - ); - swap(type_, other->type_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Implementation::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[6]); -} - -// =================================================================== - -class FunctionSignature_Argument_ValueArgument::_Internal { - public: - static const ::substrait::ParameterizedType& type(const FunctionSignature_Argument_ValueArgument* msg); -}; - -const ::substrait::ParameterizedType& -FunctionSignature_Argument_ValueArgument::_Internal::type(const FunctionSignature_Argument_ValueArgument* msg) { - return *msg->type_; -} -void FunctionSignature_Argument_ValueArgument::clear_type() { - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; -} -FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.ValueArgument) -} -FunctionSignature_Argument_ValueArgument::FunctionSignature_Argument_ValueArgument(const FunctionSignature_Argument_ValueArgument& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_type()) { - type_ = new ::substrait::ParameterizedType(*from.type_); - } else { - type_ = nullptr; - } - constant_ = from.constant_; - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.ValueArgument) -} - -inline void FunctionSignature_Argument_ValueArgument::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&constant_) - - reinterpret_cast(&type_)) + sizeof(constant_)); -} - -FunctionSignature_Argument_ValueArgument::~FunctionSignature_Argument_ValueArgument() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.ValueArgument) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FunctionSignature_Argument_ValueArgument::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete type_; -} - -void FunctionSignature_Argument_ValueArgument::ArenaDtor(void* object) { - FunctionSignature_Argument_ValueArgument* _this = reinterpret_cast< FunctionSignature_Argument_ValueArgument* >(object); - (void)_this; -} -void FunctionSignature_Argument_ValueArgument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_Argument_ValueArgument::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_Argument_ValueArgument::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.ValueArgument) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; - constant_ = false; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_Argument_ValueArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.ParameterizedType type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // bool constant = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - constant_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* FunctionSignature_Argument_ValueArgument::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.ValueArgument) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.ParameterizedType type = 1; - if (this->_internal_has_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::type(this), target, stream); - } - - // bool constant = 2; - if (this->_internal_constant() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_constant(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument.ValueArgument) - return target; -} - -size_t FunctionSignature_Argument_ValueArgument::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.ValueArgument) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.ParameterizedType type = 1; - if (this->_internal_has_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_); - } - - // bool constant = 2; - if (this->_internal_constant() != 0) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument_ValueArgument::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FunctionSignature_Argument_ValueArgument::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument_ValueArgument::GetClassData() const { return &_class_data_; } - -void FunctionSignature_Argument_ValueArgument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FunctionSignature_Argument_ValueArgument::MergeFrom(const FunctionSignature_Argument_ValueArgument& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.ValueArgument) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_type()) { - _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type()); - } - if (from._internal_constant() != 0) { - _internal_set_constant(from._internal_constant()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FunctionSignature_Argument_ValueArgument::CopyFrom(const FunctionSignature_Argument_ValueArgument& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument.ValueArgument) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FunctionSignature_Argument_ValueArgument::IsInitialized() const { - return true; -} - -void FunctionSignature_Argument_ValueArgument::InternalSwap(FunctionSignature_Argument_ValueArgument* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(FunctionSignature_Argument_ValueArgument, constant_) - + sizeof(FunctionSignature_Argument_ValueArgument::constant_) - - PROTOBUF_FIELD_OFFSET(FunctionSignature_Argument_ValueArgument, type_)>( - reinterpret_cast(&type_), - reinterpret_cast(&other->type_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_ValueArgument::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[7]); -} - -// =================================================================== - -class FunctionSignature_Argument_TypeArgument::_Internal { - public: - static const ::substrait::ParameterizedType& type(const FunctionSignature_Argument_TypeArgument* msg); -}; - -const ::substrait::ParameterizedType& -FunctionSignature_Argument_TypeArgument::_Internal::type(const FunctionSignature_Argument_TypeArgument* msg) { - return *msg->type_; -} -void FunctionSignature_Argument_TypeArgument::clear_type() { - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; -} -FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.TypeArgument) -} -FunctionSignature_Argument_TypeArgument::FunctionSignature_Argument_TypeArgument(const FunctionSignature_Argument_TypeArgument& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_type()) { - type_ = new ::substrait::ParameterizedType(*from.type_); - } else { - type_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.TypeArgument) -} - -inline void FunctionSignature_Argument_TypeArgument::SharedCtor() { -type_ = nullptr; -} - -FunctionSignature_Argument_TypeArgument::~FunctionSignature_Argument_TypeArgument() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.TypeArgument) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FunctionSignature_Argument_TypeArgument::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete type_; -} - -void FunctionSignature_Argument_TypeArgument::ArenaDtor(void* object) { - FunctionSignature_Argument_TypeArgument* _this = reinterpret_cast< FunctionSignature_Argument_TypeArgument* >(object); - (void)_this; -} -void FunctionSignature_Argument_TypeArgument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_Argument_TypeArgument::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_Argument_TypeArgument::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.TypeArgument) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_Argument_TypeArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.ParameterizedType type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* FunctionSignature_Argument_TypeArgument::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.TypeArgument) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.ParameterizedType type = 1; - if (this->_internal_has_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::type(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument.TypeArgument) - return target; -} - -size_t FunctionSignature_Argument_TypeArgument::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.TypeArgument) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.ParameterizedType type = 1; - if (this->_internal_has_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument_TypeArgument::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FunctionSignature_Argument_TypeArgument::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument_TypeArgument::GetClassData() const { return &_class_data_; } - -void FunctionSignature_Argument_TypeArgument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FunctionSignature_Argument_TypeArgument::MergeFrom(const FunctionSignature_Argument_TypeArgument& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.TypeArgument) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_type()) { - _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FunctionSignature_Argument_TypeArgument::CopyFrom(const FunctionSignature_Argument_TypeArgument& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument.TypeArgument) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FunctionSignature_Argument_TypeArgument::IsInitialized() const { - return true; -} - -void FunctionSignature_Argument_TypeArgument::InternalSwap(FunctionSignature_Argument_TypeArgument* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(type_, other->type_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_TypeArgument::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[8]); -} - -// =================================================================== - -class FunctionSignature_Argument_EnumArgument::_Internal { - public: -}; - -FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - options_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument.EnumArgument) -} -FunctionSignature_Argument_EnumArgument::FunctionSignature_Argument_EnumArgument(const FunctionSignature_Argument_EnumArgument& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - options_(from.options_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - optional_ = from.optional_; - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument.EnumArgument) -} - -inline void FunctionSignature_Argument_EnumArgument::SharedCtor() { -optional_ = false; -} - -FunctionSignature_Argument_EnumArgument::~FunctionSignature_Argument_EnumArgument() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument.EnumArgument) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FunctionSignature_Argument_EnumArgument::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void FunctionSignature_Argument_EnumArgument::ArenaDtor(void* object) { - FunctionSignature_Argument_EnumArgument* _this = reinterpret_cast< FunctionSignature_Argument_EnumArgument* >(object); - (void)_this; -} -void FunctionSignature_Argument_EnumArgument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_Argument_EnumArgument::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_Argument_EnumArgument::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument.EnumArgument) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - options_.Clear(); - optional_ = false; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_Argument_EnumArgument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string options = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_options(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Argument.EnumArgument.options")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // bool optional = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - optional_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* FunctionSignature_Argument_EnumArgument::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument.EnumArgument) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string options = 1; - for (int i = 0, n = this->_internal_options_size(); i < n; i++) { - const auto& s = this->_internal_options(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.FunctionSignature.Argument.EnumArgument.options"); - target = stream->WriteString(1, s, target); - } - - // bool optional = 2; - if (this->_internal_optional() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_optional(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument.EnumArgument) - return target; -} - -size_t FunctionSignature_Argument_EnumArgument::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument.EnumArgument) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string options = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(options_.size()); - for (int i = 0, n = options_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - options_.Get(i)); - } - - // bool optional = 2; - if (this->_internal_optional() != 0) { - total_size += 1 + 1; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument_EnumArgument::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FunctionSignature_Argument_EnumArgument::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument_EnumArgument::GetClassData() const { return &_class_data_; } - -void FunctionSignature_Argument_EnumArgument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FunctionSignature_Argument_EnumArgument::MergeFrom(const FunctionSignature_Argument_EnumArgument& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument.EnumArgument) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - options_.MergeFrom(from.options_); - if (from._internal_optional() != 0) { - _internal_set_optional(from._internal_optional()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FunctionSignature_Argument_EnumArgument::CopyFrom(const FunctionSignature_Argument_EnumArgument& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument.EnumArgument) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FunctionSignature_Argument_EnumArgument::IsInitialized() const { - return true; -} - -void FunctionSignature_Argument_EnumArgument::InternalSwap(FunctionSignature_Argument_EnumArgument* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - options_.InternalSwap(&other->options_); - swap(optional_, other->optional_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument_EnumArgument::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[9]); -} - -// =================================================================== - -class FunctionSignature_Argument::_Internal { - public: - static const ::substrait::FunctionSignature_Argument_ValueArgument& value(const FunctionSignature_Argument* msg); - static const ::substrait::FunctionSignature_Argument_TypeArgument& type(const FunctionSignature_Argument* msg); - static const ::substrait::FunctionSignature_Argument_EnumArgument& enum_(const FunctionSignature_Argument* msg); -}; - -const ::substrait::FunctionSignature_Argument_ValueArgument& -FunctionSignature_Argument::_Internal::value(const FunctionSignature_Argument* msg) { - return *msg->argument_kind_.value_; -} -const ::substrait::FunctionSignature_Argument_TypeArgument& -FunctionSignature_Argument::_Internal::type(const FunctionSignature_Argument* msg) { - return *msg->argument_kind_.type_; -} -const ::substrait::FunctionSignature_Argument_EnumArgument& -FunctionSignature_Argument::_Internal::enum_(const FunctionSignature_Argument* msg) { - return *msg->argument_kind_.enum__; -} -void FunctionSignature_Argument::set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_argument_kind(); - if (value) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_ValueArgument>::GetOwningArena(value); - if (message_arena != submessage_arena) { - value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value, submessage_arena); - } - set_has_value(); - argument_kind_.value_ = value; - } - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.value) -} -void FunctionSignature_Argument::set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_argument_kind(); - if (type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_TypeArgument>::GetOwningArena(type); - if (message_arena != submessage_arena) { - type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type, submessage_arena); - } - set_has_type(); - argument_kind_.type_ = type; - } - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.type) -} -void FunctionSignature_Argument::set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_argument_kind(); - if (enum_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Argument_EnumArgument>::GetOwningArena(enum_); - if (message_arena != submessage_arena) { - enum_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, enum_, submessage_arena); - } - set_has_enum_(); - argument_kind_.enum__ = enum_; - } - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.enum) -} -FunctionSignature_Argument::FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature.Argument) -} -FunctionSignature_Argument::FunctionSignature_Argument(const FunctionSignature_Argument& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArenaForAllocation()); - } - clear_has_argument_kind(); - switch (from.argument_kind_case()) { - case kValue: { - _internal_mutable_value()->::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value()); - break; - } - case kType: { - _internal_mutable_type()->::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type()); - break; - } - case kEnum: { - _internal_mutable_enum_()->::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_()); - break; - } - case ARGUMENT_KIND_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature.Argument) -} - -inline void FunctionSignature_Argument::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -clear_has_argument_kind(); -} - -FunctionSignature_Argument::~FunctionSignature_Argument() { - // @@protoc_insertion_point(destructor:substrait.FunctionSignature.Argument) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FunctionSignature_Argument::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (has_argument_kind()) { - clear_argument_kind(); - } -} - -void FunctionSignature_Argument::ArenaDtor(void* object) { - FunctionSignature_Argument* _this = reinterpret_cast< FunctionSignature_Argument* >(object); - (void)_this; -} -void FunctionSignature_Argument::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FunctionSignature_Argument::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FunctionSignature_Argument::clear_argument_kind() { -// @@protoc_insertion_point(one_of_clear_start:substrait.FunctionSignature.Argument) - switch (argument_kind_case()) { - case kValue: { - if (GetArenaForAllocation() == nullptr) { - delete argument_kind_.value_; - } - break; - } - case kType: { - if (GetArenaForAllocation() == nullptr) { - delete argument_kind_.type_; - } - break; - } - case kEnum: { - if (GetArenaForAllocation() == nullptr) { - delete argument_kind_.enum__; - } - break; - } - case ARGUMENT_KIND_NOT_SET: { - break; - } - } - _oneof_case_[0] = ARGUMENT_KIND_NOT_SET; -} - - -void FunctionSignature_Argument::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FunctionSignature.Argument) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmpty(); - clear_argument_kind(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FunctionSignature_Argument::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.FunctionSignature.Argument.name")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.Argument.ValueArgument value = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.Argument.TypeArgument type = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FunctionSignature.Argument.EnumArgument enum = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_enum_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* FunctionSignature_Argument::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FunctionSignature.Argument) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string name = 1; - if (!this->_internal_name().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.FunctionSignature.Argument.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - // .substrait.FunctionSignature.Argument.ValueArgument value = 2; - if (_internal_has_value()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::value(this), target, stream); - } - - // .substrait.FunctionSignature.Argument.TypeArgument type = 3; - if (_internal_has_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::type(this), target, stream); - } - - // .substrait.FunctionSignature.Argument.EnumArgument enum = 4; - if (_internal_has_enum_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::enum_(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FunctionSignature.Argument) - return target; -} - -size_t FunctionSignature_Argument::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FunctionSignature.Argument) - 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 name = 1; - if (!this->_internal_name().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - switch (argument_kind_case()) { - // .substrait.FunctionSignature.Argument.ValueArgument value = 2; - case kValue: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *argument_kind_.value_); - break; - } - // .substrait.FunctionSignature.Argument.TypeArgument type = 3; - case kType: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *argument_kind_.type_); - break; - } - // .substrait.FunctionSignature.Argument.EnumArgument enum = 4; - case kEnum: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *argument_kind_.enum__); - break; - } - case ARGUMENT_KIND_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature_Argument::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FunctionSignature_Argument::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature_Argument::GetClassData() const { return &_class_data_; } - -void FunctionSignature_Argument::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FunctionSignature_Argument::MergeFrom(const FunctionSignature_Argument& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FunctionSignature.Argument) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_name().empty()) { - _internal_set_name(from._internal_name()); - } - switch (from.argument_kind_case()) { - case kValue: { - _internal_mutable_value()->::substrait::FunctionSignature_Argument_ValueArgument::MergeFrom(from._internal_value()); - break; - } - case kType: { - _internal_mutable_type()->::substrait::FunctionSignature_Argument_TypeArgument::MergeFrom(from._internal_type()); - break; - } - case kEnum: { - _internal_mutable_enum_()->::substrait::FunctionSignature_Argument_EnumArgument::MergeFrom(from._internal_enum_()); - break; - } - case ARGUMENT_KIND_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FunctionSignature_Argument::CopyFrom(const FunctionSignature_Argument& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FunctionSignature.Argument) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FunctionSignature_Argument::IsInitialized() const { - return true; -} - -void FunctionSignature_Argument::InternalSwap(FunctionSignature_Argument* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &name_, lhs_arena, - &other->name_, rhs_arena - ); - swap(argument_kind_, other->argument_kind_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature_Argument::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[10]); -} - -// =================================================================== - -class FunctionSignature::_Internal { - public: -}; - -FunctionSignature::FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { - // @@protoc_insertion_point(arena_constructor:substrait.FunctionSignature) -} -FunctionSignature::FunctionSignature(const FunctionSignature& from) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.FunctionSignature) -} - - - - - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FunctionSignature::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FunctionSignature::GetClassData() const { return &_class_data_; } - - - - - - - -::PROTOBUF_NAMESPACE_ID::Metadata FunctionSignature::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ffunction_2eproto_getter, &descriptor_table_substrait_2ffunction_2eproto_once, - file_level_metadata_substrait_2ffunction_2eproto[11]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_FinalArgVariadic >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_FinalArgNormal >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Scalar >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Scalar >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Aggregate >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Aggregate >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Window >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Window >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Description >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Description >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Implementation >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Implementation >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_ValueArgument >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_ValueArgument >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_TypeArgument >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_TypeArgument >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument_EnumArgument >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument_EnumArgument >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage< ::substrait::FunctionSignature_Argument >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature_Argument >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FunctionSignature* Arena::CreateMaybeMessage< ::substrait::FunctionSignature >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FunctionSignature >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/function.pb.h b/cpp/src/generated/substrait/function.pb.h deleted file mode 100644 index e566263d2f6..00000000000 --- a/cpp/src/generated/substrait/function.pb.h +++ /dev/null @@ -1,5553 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/function.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3019000 -#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 3019003 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include -#include "substrait/type.pb.h" -#include "substrait/parameterized_types.pb.h" -#include "substrait/type_expressions.pb.h" -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_substrait_2ffunction_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_substrait_2ffunction_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[12] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const uint32_t offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ffunction_2eproto; -namespace substrait { -class FunctionSignature; -struct FunctionSignatureDefaultTypeInternal; -extern FunctionSignatureDefaultTypeInternal _FunctionSignature_default_instance_; -class FunctionSignature_Aggregate; -struct FunctionSignature_AggregateDefaultTypeInternal; -extern FunctionSignature_AggregateDefaultTypeInternal _FunctionSignature_Aggregate_default_instance_; -class FunctionSignature_Argument; -struct FunctionSignature_ArgumentDefaultTypeInternal; -extern FunctionSignature_ArgumentDefaultTypeInternal _FunctionSignature_Argument_default_instance_; -class FunctionSignature_Argument_EnumArgument; -struct FunctionSignature_Argument_EnumArgumentDefaultTypeInternal; -extern FunctionSignature_Argument_EnumArgumentDefaultTypeInternal _FunctionSignature_Argument_EnumArgument_default_instance_; -class FunctionSignature_Argument_TypeArgument; -struct FunctionSignature_Argument_TypeArgumentDefaultTypeInternal; -extern FunctionSignature_Argument_TypeArgumentDefaultTypeInternal _FunctionSignature_Argument_TypeArgument_default_instance_; -class FunctionSignature_Argument_ValueArgument; -struct FunctionSignature_Argument_ValueArgumentDefaultTypeInternal; -extern FunctionSignature_Argument_ValueArgumentDefaultTypeInternal _FunctionSignature_Argument_ValueArgument_default_instance_; -class FunctionSignature_Description; -struct FunctionSignature_DescriptionDefaultTypeInternal; -extern FunctionSignature_DescriptionDefaultTypeInternal _FunctionSignature_Description_default_instance_; -class FunctionSignature_FinalArgNormal; -struct FunctionSignature_FinalArgNormalDefaultTypeInternal; -extern FunctionSignature_FinalArgNormalDefaultTypeInternal _FunctionSignature_FinalArgNormal_default_instance_; -class FunctionSignature_FinalArgVariadic; -struct FunctionSignature_FinalArgVariadicDefaultTypeInternal; -extern FunctionSignature_FinalArgVariadicDefaultTypeInternal _FunctionSignature_FinalArgVariadic_default_instance_; -class FunctionSignature_Implementation; -struct FunctionSignature_ImplementationDefaultTypeInternal; -extern FunctionSignature_ImplementationDefaultTypeInternal _FunctionSignature_Implementation_default_instance_; -class FunctionSignature_Scalar; -struct FunctionSignature_ScalarDefaultTypeInternal; -extern FunctionSignature_ScalarDefaultTypeInternal _FunctionSignature_Scalar_default_instance_; -class FunctionSignature_Window; -struct FunctionSignature_WindowDefaultTypeInternal; -extern FunctionSignature_WindowDefaultTypeInternal _FunctionSignature_Window_default_instance_; -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> ::substrait::FunctionSignature* Arena::CreateMaybeMessage<::substrait::FunctionSignature>(Arena*); -template<> ::substrait::FunctionSignature_Aggregate* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Aggregate>(Arena*); -template<> ::substrait::FunctionSignature_Argument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument>(Arena*); -template<> ::substrait::FunctionSignature_Argument_EnumArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_EnumArgument>(Arena*); -template<> ::substrait::FunctionSignature_Argument_TypeArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_TypeArgument>(Arena*); -template<> ::substrait::FunctionSignature_Argument_ValueArgument* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Argument_ValueArgument>(Arena*); -template<> ::substrait::FunctionSignature_Description* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Description>(Arena*); -template<> ::substrait::FunctionSignature_FinalArgNormal* Arena::CreateMaybeMessage<::substrait::FunctionSignature_FinalArgNormal>(Arena*); -template<> ::substrait::FunctionSignature_FinalArgVariadic* Arena::CreateMaybeMessage<::substrait::FunctionSignature_FinalArgVariadic>(Arena*); -template<> ::substrait::FunctionSignature_Implementation* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Implementation>(Arena*); -template<> ::substrait::FunctionSignature_Scalar* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Scalar>(Arena*); -template<> ::substrait::FunctionSignature_Window* Arena::CreateMaybeMessage<::substrait::FunctionSignature_Window>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace substrait { - -enum FunctionSignature_FinalArgVariadic_ParameterConsistency : int { - FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED = 0, - FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_CONSISTENT = 1, - FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT = 2, - FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - FunctionSignature_FinalArgVariadic_ParameterConsistency_FunctionSignature_FinalArgVariadic_ParameterConsistency_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(int value); -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN = FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED; -constexpr FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX = FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT; -constexpr int FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_ARRAYSIZE = FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(); -template -inline const std::string& FunctionSignature_FinalArgVariadic_ParameterConsistency_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function FunctionSignature_FinalArgVariadic_ParameterConsistency_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(), enum_t_value); -} -inline bool FunctionSignature_FinalArgVariadic_ParameterConsistency_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_FinalArgVariadic_ParameterConsistency* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(), name, value); -} -enum FunctionSignature_Window_WindowType : int { - FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED = 0, - FunctionSignature_Window_WindowType_WINDOW_TYPE_STREAMING = 1, - FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION = 2, - FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - FunctionSignature_Window_WindowType_FunctionSignature_Window_WindowType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool FunctionSignature_Window_WindowType_IsValid(int value); -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MIN = FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED; -constexpr FunctionSignature_Window_WindowType FunctionSignature_Window_WindowType_WindowType_MAX = FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION; -constexpr int FunctionSignature_Window_WindowType_WindowType_ARRAYSIZE = FunctionSignature_Window_WindowType_WindowType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Window_WindowType_descriptor(); -template -inline const std::string& FunctionSignature_Window_WindowType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function FunctionSignature_Window_WindowType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - FunctionSignature_Window_WindowType_descriptor(), enum_t_value); -} -inline bool FunctionSignature_Window_WindowType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_Window_WindowType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - FunctionSignature_Window_WindowType_descriptor(), name, value); -} -enum FunctionSignature_Implementation_Type : int { - FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED = 0, - FunctionSignature_Implementation_Type_TYPE_WEB_ASSEMBLY = 1, - FunctionSignature_Implementation_Type_TYPE_TRINO_JAR = 2, - FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - FunctionSignature_Implementation_Type_FunctionSignature_Implementation_Type_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool FunctionSignature_Implementation_Type_IsValid(int value); -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MIN = FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED; -constexpr FunctionSignature_Implementation_Type FunctionSignature_Implementation_Type_Type_MAX = FunctionSignature_Implementation_Type_TYPE_TRINO_JAR; -constexpr int FunctionSignature_Implementation_Type_Type_ARRAYSIZE = FunctionSignature_Implementation_Type_Type_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FunctionSignature_Implementation_Type_descriptor(); -template -inline const std::string& FunctionSignature_Implementation_Type_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function FunctionSignature_Implementation_Type_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - FunctionSignature_Implementation_Type_descriptor(), enum_t_value); -} -inline bool FunctionSignature_Implementation_Type_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FunctionSignature_Implementation_Type* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - FunctionSignature_Implementation_Type_descriptor(), name, value); -} -// =================================================================== - -class FunctionSignature_FinalArgVariadic final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgVariadic) */ { - public: - inline FunctionSignature_FinalArgVariadic() : FunctionSignature_FinalArgVariadic(nullptr) {} - ~FunctionSignature_FinalArgVariadic() override; - explicit constexpr FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_FinalArgVariadic(const FunctionSignature_FinalArgVariadic& from); - FunctionSignature_FinalArgVariadic(FunctionSignature_FinalArgVariadic&& from) noexcept - : FunctionSignature_FinalArgVariadic() { - *this = ::std::move(from); - } - - inline FunctionSignature_FinalArgVariadic& operator=(const FunctionSignature_FinalArgVariadic& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_FinalArgVariadic& operator=(FunctionSignature_FinalArgVariadic&& 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 FunctionSignature_FinalArgVariadic& default_instance() { - return *internal_default_instance(); - } - static inline const FunctionSignature_FinalArgVariadic* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_FinalArgVariadic_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(FunctionSignature_FinalArgVariadic& a, FunctionSignature_FinalArgVariadic& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_FinalArgVariadic* 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(FunctionSignature_FinalArgVariadic* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_FinalArgVariadic* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FunctionSignature_FinalArgVariadic& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FunctionSignature_FinalArgVariadic& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_FinalArgVariadic* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.FinalArgVariadic"; - } - protected: - explicit FunctionSignature_FinalArgVariadic(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef FunctionSignature_FinalArgVariadic_ParameterConsistency ParameterConsistency; - static constexpr ParameterConsistency PARAMETER_CONSISTENCY_UNSPECIFIED = - FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_UNSPECIFIED; - static constexpr ParameterConsistency PARAMETER_CONSISTENCY_CONSISTENT = - FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_CONSISTENT; - static constexpr ParameterConsistency PARAMETER_CONSISTENCY_INCONSISTENT = - FunctionSignature_FinalArgVariadic_ParameterConsistency_PARAMETER_CONSISTENCY_INCONSISTENT; - static inline bool ParameterConsistency_IsValid(int value) { - return FunctionSignature_FinalArgVariadic_ParameterConsistency_IsValid(value); - } - static constexpr ParameterConsistency ParameterConsistency_MIN = - FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MIN; - static constexpr ParameterConsistency ParameterConsistency_MAX = - FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_MAX; - static constexpr int ParameterConsistency_ARRAYSIZE = - FunctionSignature_FinalArgVariadic_ParameterConsistency_ParameterConsistency_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - ParameterConsistency_descriptor() { - return FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(); - } - template - static inline const std::string& ParameterConsistency_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ParameterConsistency_Name."); - return FunctionSignature_FinalArgVariadic_ParameterConsistency_Name(enum_t_value); - } - static inline bool ParameterConsistency_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - ParameterConsistency* value) { - return FunctionSignature_FinalArgVariadic_ParameterConsistency_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kMinArgsFieldNumber = 1, - kMaxArgsFieldNumber = 2, - kConsistencyFieldNumber = 3, - }; - // int64 min_args = 1; - void clear_min_args(); - int64_t min_args() const; - void set_min_args(int64_t value); - private: - int64_t _internal_min_args() const; - void _internal_set_min_args(int64_t value); - public: - - // int64 max_args = 2; - void clear_max_args(); - int64_t max_args() const; - void set_max_args(int64_t value); - private: - int64_t _internal_max_args() const; - void _internal_set_max_args(int64_t value); - public: - - // .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; - void clear_consistency(); - ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency consistency() const; - void set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value); - private: - ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency _internal_consistency() const; - void _internal_set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value); - public: - - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.FinalArgVariadic) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int64_t min_args_; - int64_t max_args_; - int consistency_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature_FinalArgNormal final : - public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.FinalArgNormal) */ { - public: - inline FunctionSignature_FinalArgNormal() : FunctionSignature_FinalArgNormal(nullptr) {} - explicit constexpr FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_FinalArgNormal(const FunctionSignature_FinalArgNormal& from); - FunctionSignature_FinalArgNormal(FunctionSignature_FinalArgNormal&& from) noexcept - : FunctionSignature_FinalArgNormal() { - *this = ::std::move(from); - } - - inline FunctionSignature_FinalArgNormal& operator=(const FunctionSignature_FinalArgNormal& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_FinalArgNormal& operator=(FunctionSignature_FinalArgNormal&& 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 FunctionSignature_FinalArgNormal& default_instance() { - return *internal_default_instance(); - } - static inline const FunctionSignature_FinalArgNormal* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_FinalArgNormal_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(FunctionSignature_FinalArgNormal& a, FunctionSignature_FinalArgNormal& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_FinalArgNormal* 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(FunctionSignature_FinalArgNormal* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_FinalArgNormal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; - inline void CopyFrom(const FunctionSignature_FinalArgNormal& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; - void MergeFrom(const FunctionSignature_FinalArgNormal& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); - } - public: - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.FinalArgNormal"; - } - protected: - explicit FunctionSignature_FinalArgNormal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - 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 ------------------------------------------------------- - - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.FinalArgNormal) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature_Scalar final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Scalar) */ { - public: - inline FunctionSignature_Scalar() : FunctionSignature_Scalar(nullptr) {} - ~FunctionSignature_Scalar() override; - explicit constexpr FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_Scalar(const FunctionSignature_Scalar& from); - FunctionSignature_Scalar(FunctionSignature_Scalar&& from) noexcept - : FunctionSignature_Scalar() { - *this = ::std::move(from); - } - - inline FunctionSignature_Scalar& operator=(const FunctionSignature_Scalar& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_Scalar& operator=(FunctionSignature_Scalar&& 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 FunctionSignature_Scalar& default_instance() { - return *internal_default_instance(); - } - enum FinalVariableBehaviorCase { - kVariadic = 10, - kNormal = 11, - FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0, - }; - - static inline const FunctionSignature_Scalar* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_Scalar_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(FunctionSignature_Scalar& a, FunctionSignature_Scalar& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_Scalar* 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(FunctionSignature_Scalar* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_Scalar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FunctionSignature_Scalar& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FunctionSignature_Scalar& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_Scalar* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.Scalar"; - } - protected: - explicit FunctionSignature_Scalar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kArgumentsFieldNumber = 2, - kNameFieldNumber = 3, - kImplementationsFieldNumber = 12, - kDescriptionFieldNumber = 4, - kOutputTypeFieldNumber = 9, - kDeterministicFieldNumber = 7, - kSessionDependentFieldNumber = 8, - kVariadicFieldNumber = 10, - kNormalFieldNumber = 11, - }; - // repeated .substrait.FunctionSignature.Argument arguments = 2; - int arguments_size() const; - private: - int _internal_arguments_size() const; - public: - void clear_arguments(); - ::substrait::FunctionSignature_Argument* mutable_arguments(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* - mutable_arguments(); - private: - const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; - ::substrait::FunctionSignature_Argument* _internal_add_arguments(); - public: - const ::substrait::FunctionSignature_Argument& arguments(int index) const; - ::substrait::FunctionSignature_Argument* add_arguments(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& - arguments() const; - - // repeated string name = 3; - int name_size() const; - private: - int _internal_name_size() const; - public: - void clear_name(); - const std::string& name(int index) const; - std::string* mutable_name(int index); - void set_name(int index, const std::string& value); - void set_name(int index, std::string&& value); - void set_name(int index, const char* value); - void set_name(int index, const char* value, size_t size); - std::string* add_name(); - void add_name(const std::string& value); - void add_name(std::string&& value); - void add_name(const char* value); - void add_name(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& name() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_name(); - private: - const std::string& _internal_name(int index) const; - std::string* _internal_add_name(); - public: - - // repeated .substrait.FunctionSignature.Implementation implementations = 12; - int implementations_size() const; - private: - int _internal_implementations_size() const; - public: - void clear_implementations(); - ::substrait::FunctionSignature_Implementation* mutable_implementations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* - mutable_implementations(); - private: - const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; - ::substrait::FunctionSignature_Implementation* _internal_add_implementations(); - public: - const ::substrait::FunctionSignature_Implementation& implementations(int index) const; - ::substrait::FunctionSignature_Implementation* add_implementations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& - implementations() const; - - // .substrait.FunctionSignature.Description description = 4; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const ::substrait::FunctionSignature_Description& description() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description(); - ::substrait::FunctionSignature_Description* mutable_description(); - void set_allocated_description(::substrait::FunctionSignature_Description* description); - private: - const ::substrait::FunctionSignature_Description& _internal_description() const; - ::substrait::FunctionSignature_Description* _internal_mutable_description(); - public: - void unsafe_arena_set_allocated_description( - ::substrait::FunctionSignature_Description* description); - ::substrait::FunctionSignature_Description* unsafe_arena_release_description(); - - // .substrait.DerivationExpression output_type = 9; - bool has_output_type() const; - private: - bool _internal_has_output_type() const; - public: - void clear_output_type(); - const ::substrait::DerivationExpression& output_type() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type(); - ::substrait::DerivationExpression* mutable_output_type(); - void set_allocated_output_type(::substrait::DerivationExpression* output_type); - private: - const ::substrait::DerivationExpression& _internal_output_type() const; - ::substrait::DerivationExpression* _internal_mutable_output_type(); - public: - void unsafe_arena_set_allocated_output_type( - ::substrait::DerivationExpression* output_type); - ::substrait::DerivationExpression* unsafe_arena_release_output_type(); - - // bool deterministic = 7; - void clear_deterministic(); - bool deterministic() const; - void set_deterministic(bool value); - private: - bool _internal_deterministic() const; - void _internal_set_deterministic(bool value); - public: - - // bool session_dependent = 8; - void clear_session_dependent(); - bool session_dependent() const; - void set_session_dependent(bool value); - private: - bool _internal_session_dependent() const; - void _internal_set_session_dependent(bool value); - public: - - // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; - bool has_variadic() const; - private: - bool _internal_has_variadic() const; - public: - void clear_variadic(); - const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); - ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); - void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic); - private: - const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; - ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); - public: - void unsafe_arena_set_allocated_variadic( - ::substrait::FunctionSignature_FinalArgVariadic* variadic); - ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); - - // .substrait.FunctionSignature.FinalArgNormal normal = 11; - bool has_normal() const; - private: - bool _internal_has_normal() const; - public: - void clear_normal(); - const ::substrait::FunctionSignature_FinalArgNormal& normal() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal(); - ::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); - void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal); - private: - const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; - ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); - public: - void unsafe_arena_set_allocated_normal( - ::substrait::FunctionSignature_FinalArgNormal* normal); - ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); - - void clear_final_variable_behavior(); - FinalVariableBehaviorCase final_variable_behavior_case() const; - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Scalar) - private: - class _Internal; - void set_has_variadic(); - void set_has_normal(); - - inline bool has_final_variable_behavior() const; - inline void clear_has_final_variable_behavior(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField name_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_; - ::substrait::FunctionSignature_Description* description_; - ::substrait::DerivationExpression* output_type_; - bool deterministic_; - bool session_dependent_; - union FinalVariableBehaviorUnion { - constexpr FinalVariableBehaviorUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::FunctionSignature_FinalArgVariadic* variadic_; - ::substrait::FunctionSignature_FinalArgNormal* normal_; - } final_variable_behavior_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature_Aggregate final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Aggregate) */ { - public: - inline FunctionSignature_Aggregate() : FunctionSignature_Aggregate(nullptr) {} - ~FunctionSignature_Aggregate() override; - explicit constexpr FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_Aggregate(const FunctionSignature_Aggregate& from); - FunctionSignature_Aggregate(FunctionSignature_Aggregate&& from) noexcept - : FunctionSignature_Aggregate() { - *this = ::std::move(from); - } - - inline FunctionSignature_Aggregate& operator=(const FunctionSignature_Aggregate& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_Aggregate& operator=(FunctionSignature_Aggregate&& 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 FunctionSignature_Aggregate& default_instance() { - return *internal_default_instance(); - } - enum FinalVariableBehaviorCase { - kVariadic = 10, - kNormal = 11, - FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0, - }; - - static inline const FunctionSignature_Aggregate* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_Aggregate_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(FunctionSignature_Aggregate& a, FunctionSignature_Aggregate& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_Aggregate* 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(FunctionSignature_Aggregate* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_Aggregate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FunctionSignature_Aggregate& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FunctionSignature_Aggregate& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_Aggregate* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.Aggregate"; - } - protected: - explicit FunctionSignature_Aggregate(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kArgumentsFieldNumber = 2, - kImplementationsFieldNumber = 15, - kNameFieldNumber = 3, - kDescriptionFieldNumber = 4, - kOutputTypeFieldNumber = 9, - kIntermediateTypeFieldNumber = 13, - kDeterministicFieldNumber = 7, - kSessionDependentFieldNumber = 8, - kOrderedFieldNumber = 14, - kMaxSetFieldNumber = 12, - kVariadicFieldNumber = 10, - kNormalFieldNumber = 11, - }; - // repeated .substrait.FunctionSignature.Argument arguments = 2; - int arguments_size() const; - private: - int _internal_arguments_size() const; - public: - void clear_arguments(); - ::substrait::FunctionSignature_Argument* mutable_arguments(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* - mutable_arguments(); - private: - const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; - ::substrait::FunctionSignature_Argument* _internal_add_arguments(); - public: - const ::substrait::FunctionSignature_Argument& arguments(int index) const; - ::substrait::FunctionSignature_Argument* add_arguments(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& - arguments() const; - - // repeated .substrait.FunctionSignature.Implementation implementations = 15; - int implementations_size() const; - private: - int _internal_implementations_size() const; - public: - void clear_implementations(); - ::substrait::FunctionSignature_Implementation* mutable_implementations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* - mutable_implementations(); - private: - const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; - ::substrait::FunctionSignature_Implementation* _internal_add_implementations(); - public: - const ::substrait::FunctionSignature_Implementation& implementations(int index) const; - ::substrait::FunctionSignature_Implementation* add_implementations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& - implementations() const; - - // string name = 3; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // .substrait.FunctionSignature.Description description = 4; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const ::substrait::FunctionSignature_Description& description() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description(); - ::substrait::FunctionSignature_Description* mutable_description(); - void set_allocated_description(::substrait::FunctionSignature_Description* description); - private: - const ::substrait::FunctionSignature_Description& _internal_description() const; - ::substrait::FunctionSignature_Description* _internal_mutable_description(); - public: - void unsafe_arena_set_allocated_description( - ::substrait::FunctionSignature_Description* description); - ::substrait::FunctionSignature_Description* unsafe_arena_release_description(); - - // .substrait.DerivationExpression output_type = 9; - bool has_output_type() const; - private: - bool _internal_has_output_type() const; - public: - void clear_output_type(); - const ::substrait::DerivationExpression& output_type() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type(); - ::substrait::DerivationExpression* mutable_output_type(); - void set_allocated_output_type(::substrait::DerivationExpression* output_type); - private: - const ::substrait::DerivationExpression& _internal_output_type() const; - ::substrait::DerivationExpression* _internal_mutable_output_type(); - public: - void unsafe_arena_set_allocated_output_type( - ::substrait::DerivationExpression* output_type); - ::substrait::DerivationExpression* unsafe_arena_release_output_type(); - - // .substrait.Type intermediate_type = 13; - bool has_intermediate_type() const; - private: - bool _internal_has_intermediate_type() const; - public: - void clear_intermediate_type(); - const ::substrait::Type& intermediate_type() const; - PROTOBUF_NODISCARD ::substrait::Type* release_intermediate_type(); - ::substrait::Type* mutable_intermediate_type(); - void set_allocated_intermediate_type(::substrait::Type* intermediate_type); - private: - const ::substrait::Type& _internal_intermediate_type() const; - ::substrait::Type* _internal_mutable_intermediate_type(); - public: - void unsafe_arena_set_allocated_intermediate_type( - ::substrait::Type* intermediate_type); - ::substrait::Type* unsafe_arena_release_intermediate_type(); - - // bool deterministic = 7; - void clear_deterministic(); - bool deterministic() const; - void set_deterministic(bool value); - private: - bool _internal_deterministic() const; - void _internal_set_deterministic(bool value); - public: - - // bool session_dependent = 8; - void clear_session_dependent(); - bool session_dependent() const; - void set_session_dependent(bool value); - private: - bool _internal_session_dependent() const; - void _internal_set_session_dependent(bool value); - public: - - // bool ordered = 14; - void clear_ordered(); - bool ordered() const; - void set_ordered(bool value); - private: - bool _internal_ordered() const; - void _internal_set_ordered(bool value); - public: - - // uint64 max_set = 12; - void clear_max_set(); - uint64_t max_set() const; - void set_max_set(uint64_t value); - private: - uint64_t _internal_max_set() const; - void _internal_set_max_set(uint64_t value); - public: - - // .substrait.FunctionSignature.FinalArgVariadic variadic = 10; - bool has_variadic() const; - private: - bool _internal_has_variadic() const; - public: - void clear_variadic(); - const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); - ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); - void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic); - private: - const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; - ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); - public: - void unsafe_arena_set_allocated_variadic( - ::substrait::FunctionSignature_FinalArgVariadic* variadic); - ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); - - // .substrait.FunctionSignature.FinalArgNormal normal = 11; - bool has_normal() const; - private: - bool _internal_has_normal() const; - public: - void clear_normal(); - const ::substrait::FunctionSignature_FinalArgNormal& normal() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal(); - ::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); - void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal); - private: - const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; - ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); - public: - void unsafe_arena_set_allocated_normal( - ::substrait::FunctionSignature_FinalArgNormal* normal); - ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); - - void clear_final_variable_behavior(); - FinalVariableBehaviorCase final_variable_behavior_case() const; - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Aggregate) - private: - class _Internal; - void set_has_variadic(); - void set_has_normal(); - - inline bool has_final_variable_behavior() const; - inline void clear_has_final_variable_behavior(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::substrait::FunctionSignature_Description* description_; - ::substrait::DerivationExpression* output_type_; - ::substrait::Type* intermediate_type_; - bool deterministic_; - bool session_dependent_; - bool ordered_; - uint64_t max_set_; - union FinalVariableBehaviorUnion { - constexpr FinalVariableBehaviorUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::FunctionSignature_FinalArgVariadic* variadic_; - ::substrait::FunctionSignature_FinalArgNormal* normal_; - } final_variable_behavior_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature_Window final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Window) */ { - public: - inline FunctionSignature_Window() : FunctionSignature_Window(nullptr) {} - ~FunctionSignature_Window() override; - explicit constexpr FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_Window(const FunctionSignature_Window& from); - FunctionSignature_Window(FunctionSignature_Window&& from) noexcept - : FunctionSignature_Window() { - *this = ::std::move(from); - } - - inline FunctionSignature_Window& operator=(const FunctionSignature_Window& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_Window& operator=(FunctionSignature_Window&& 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 FunctionSignature_Window& default_instance() { - return *internal_default_instance(); - } - enum FinalVariableBehaviorCase { - kVariadic = 16, - kNormal = 17, - FINAL_VARIABLE_BEHAVIOR_NOT_SET = 0, - }; - - static inline const FunctionSignature_Window* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_Window_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(FunctionSignature_Window& a, FunctionSignature_Window& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_Window* 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(FunctionSignature_Window* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_Window* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FunctionSignature_Window& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FunctionSignature_Window& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_Window* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.Window"; - } - protected: - explicit FunctionSignature_Window(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef FunctionSignature_Window_WindowType WindowType; - static constexpr WindowType WINDOW_TYPE_UNSPECIFIED = - FunctionSignature_Window_WindowType_WINDOW_TYPE_UNSPECIFIED; - static constexpr WindowType WINDOW_TYPE_STREAMING = - FunctionSignature_Window_WindowType_WINDOW_TYPE_STREAMING; - static constexpr WindowType WINDOW_TYPE_PARTITION = - FunctionSignature_Window_WindowType_WINDOW_TYPE_PARTITION; - static inline bool WindowType_IsValid(int value) { - return FunctionSignature_Window_WindowType_IsValid(value); - } - static constexpr WindowType WindowType_MIN = - FunctionSignature_Window_WindowType_WindowType_MIN; - static constexpr WindowType WindowType_MAX = - FunctionSignature_Window_WindowType_WindowType_MAX; - static constexpr int WindowType_ARRAYSIZE = - FunctionSignature_Window_WindowType_WindowType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - WindowType_descriptor() { - return FunctionSignature_Window_WindowType_descriptor(); - } - template - static inline const std::string& WindowType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function WindowType_Name."); - return FunctionSignature_Window_WindowType_Name(enum_t_value); - } - static inline bool WindowType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - WindowType* value) { - return FunctionSignature_Window_WindowType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kArgumentsFieldNumber = 2, - kNameFieldNumber = 3, - kImplementationsFieldNumber = 15, - kDescriptionFieldNumber = 4, - kIntermediateTypeFieldNumber = 9, - kOutputTypeFieldNumber = 10, - kDeterministicFieldNumber = 7, - kSessionDependentFieldNumber = 8, - kOrderedFieldNumber = 11, - kWindowTypeFieldNumber = 14, - kMaxSetFieldNumber = 12, - kVariadicFieldNumber = 16, - kNormalFieldNumber = 17, - }; - // repeated .substrait.FunctionSignature.Argument arguments = 2; - int arguments_size() const; - private: - int _internal_arguments_size() const; - public: - void clear_arguments(); - ::substrait::FunctionSignature_Argument* mutable_arguments(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* - mutable_arguments(); - private: - const ::substrait::FunctionSignature_Argument& _internal_arguments(int index) const; - ::substrait::FunctionSignature_Argument* _internal_add_arguments(); - public: - const ::substrait::FunctionSignature_Argument& arguments(int index) const; - ::substrait::FunctionSignature_Argument* add_arguments(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& - arguments() const; - - // repeated string name = 3; - int name_size() const; - private: - int _internal_name_size() const; - public: - void clear_name(); - const std::string& name(int index) const; - std::string* mutable_name(int index); - void set_name(int index, const std::string& value); - void set_name(int index, std::string&& value); - void set_name(int index, const char* value); - void set_name(int index, const char* value, size_t size); - std::string* add_name(); - void add_name(const std::string& value); - void add_name(std::string&& value); - void add_name(const char* value); - void add_name(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& name() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_name(); - private: - const std::string& _internal_name(int index) const; - std::string* _internal_add_name(); - public: - - // repeated .substrait.FunctionSignature.Implementation implementations = 15; - int implementations_size() const; - private: - int _internal_implementations_size() const; - public: - void clear_implementations(); - ::substrait::FunctionSignature_Implementation* mutable_implementations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* - mutable_implementations(); - private: - const ::substrait::FunctionSignature_Implementation& _internal_implementations(int index) const; - ::substrait::FunctionSignature_Implementation* _internal_add_implementations(); - public: - const ::substrait::FunctionSignature_Implementation& implementations(int index) const; - ::substrait::FunctionSignature_Implementation* add_implementations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& - implementations() const; - - // .substrait.FunctionSignature.Description description = 4; - bool has_description() const; - private: - bool _internal_has_description() const; - public: - void clear_description(); - const ::substrait::FunctionSignature_Description& description() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_Description* release_description(); - ::substrait::FunctionSignature_Description* mutable_description(); - void set_allocated_description(::substrait::FunctionSignature_Description* description); - private: - const ::substrait::FunctionSignature_Description& _internal_description() const; - ::substrait::FunctionSignature_Description* _internal_mutable_description(); - public: - void unsafe_arena_set_allocated_description( - ::substrait::FunctionSignature_Description* description); - ::substrait::FunctionSignature_Description* unsafe_arena_release_description(); - - // .substrait.DerivationExpression intermediate_type = 9; - bool has_intermediate_type() const; - private: - bool _internal_has_intermediate_type() const; - public: - void clear_intermediate_type(); - const ::substrait::DerivationExpression& intermediate_type() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_intermediate_type(); - ::substrait::DerivationExpression* mutable_intermediate_type(); - void set_allocated_intermediate_type(::substrait::DerivationExpression* intermediate_type); - private: - const ::substrait::DerivationExpression& _internal_intermediate_type() const; - ::substrait::DerivationExpression* _internal_mutable_intermediate_type(); - public: - void unsafe_arena_set_allocated_intermediate_type( - ::substrait::DerivationExpression* intermediate_type); - ::substrait::DerivationExpression* unsafe_arena_release_intermediate_type(); - - // .substrait.DerivationExpression output_type = 10; - bool has_output_type() const; - private: - bool _internal_has_output_type() const; - public: - void clear_output_type(); - const ::substrait::DerivationExpression& output_type() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_output_type(); - ::substrait::DerivationExpression* mutable_output_type(); - void set_allocated_output_type(::substrait::DerivationExpression* output_type); - private: - const ::substrait::DerivationExpression& _internal_output_type() const; - ::substrait::DerivationExpression* _internal_mutable_output_type(); - public: - void unsafe_arena_set_allocated_output_type( - ::substrait::DerivationExpression* output_type); - ::substrait::DerivationExpression* unsafe_arena_release_output_type(); - - // bool deterministic = 7; - void clear_deterministic(); - bool deterministic() const; - void set_deterministic(bool value); - private: - bool _internal_deterministic() const; - void _internal_set_deterministic(bool value); - public: - - // bool session_dependent = 8; - void clear_session_dependent(); - bool session_dependent() const; - void set_session_dependent(bool value); - private: - bool _internal_session_dependent() const; - void _internal_set_session_dependent(bool value); - public: - - // bool ordered = 11; - void clear_ordered(); - bool ordered() const; - void set_ordered(bool value); - private: - bool _internal_ordered() const; - void _internal_set_ordered(bool value); - public: - - // .substrait.FunctionSignature.Window.WindowType window_type = 14; - void clear_window_type(); - ::substrait::FunctionSignature_Window_WindowType window_type() const; - void set_window_type(::substrait::FunctionSignature_Window_WindowType value); - private: - ::substrait::FunctionSignature_Window_WindowType _internal_window_type() const; - void _internal_set_window_type(::substrait::FunctionSignature_Window_WindowType value); - public: - - // uint64 max_set = 12; - void clear_max_set(); - uint64_t max_set() const; - void set_max_set(uint64_t value); - private: - uint64_t _internal_max_set() const; - void _internal_set_max_set(uint64_t value); - public: - - // .substrait.FunctionSignature.FinalArgVariadic variadic = 16; - bool has_variadic() const; - private: - bool _internal_has_variadic() const; - public: - void clear_variadic(); - const ::substrait::FunctionSignature_FinalArgVariadic& variadic() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgVariadic* release_variadic(); - ::substrait::FunctionSignature_FinalArgVariadic* mutable_variadic(); - void set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic); - private: - const ::substrait::FunctionSignature_FinalArgVariadic& _internal_variadic() const; - ::substrait::FunctionSignature_FinalArgVariadic* _internal_mutable_variadic(); - public: - void unsafe_arena_set_allocated_variadic( - ::substrait::FunctionSignature_FinalArgVariadic* variadic); - ::substrait::FunctionSignature_FinalArgVariadic* unsafe_arena_release_variadic(); - - // .substrait.FunctionSignature.FinalArgNormal normal = 17; - bool has_normal() const; - private: - bool _internal_has_normal() const; - public: - void clear_normal(); - const ::substrait::FunctionSignature_FinalArgNormal& normal() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_FinalArgNormal* release_normal(); - ::substrait::FunctionSignature_FinalArgNormal* mutable_normal(); - void set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal); - private: - const ::substrait::FunctionSignature_FinalArgNormal& _internal_normal() const; - ::substrait::FunctionSignature_FinalArgNormal* _internal_mutable_normal(); - public: - void unsafe_arena_set_allocated_normal( - ::substrait::FunctionSignature_FinalArgNormal* normal); - ::substrait::FunctionSignature_FinalArgNormal* unsafe_arena_release_normal(); - - void clear_final_variable_behavior(); - FinalVariableBehaviorCase final_variable_behavior_case() const; - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Window) - private: - class _Internal; - void set_has_variadic(); - void set_has_normal(); - - inline bool has_final_variable_behavior() const; - inline void clear_has_final_variable_behavior(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument > arguments_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField name_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation > implementations_; - ::substrait::FunctionSignature_Description* description_; - ::substrait::DerivationExpression* intermediate_type_; - ::substrait::DerivationExpression* output_type_; - bool deterministic_; - bool session_dependent_; - bool ordered_; - int window_type_; - uint64_t max_set_; - union FinalVariableBehaviorUnion { - constexpr FinalVariableBehaviorUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::FunctionSignature_FinalArgVariadic* variadic_; - ::substrait::FunctionSignature_FinalArgNormal* normal_; - } final_variable_behavior_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature_Description final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Description) */ { - public: - inline FunctionSignature_Description() : FunctionSignature_Description(nullptr) {} - ~FunctionSignature_Description() override; - explicit constexpr FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_Description(const FunctionSignature_Description& from); - FunctionSignature_Description(FunctionSignature_Description&& from) noexcept - : FunctionSignature_Description() { - *this = ::std::move(from); - } - - inline FunctionSignature_Description& operator=(const FunctionSignature_Description& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_Description& operator=(FunctionSignature_Description&& 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 FunctionSignature_Description& default_instance() { - return *internal_default_instance(); - } - static inline const FunctionSignature_Description* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_Description_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(FunctionSignature_Description& a, FunctionSignature_Description& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_Description* 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(FunctionSignature_Description* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_Description* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FunctionSignature_Description& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FunctionSignature_Description& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_Description* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.Description"; - } - protected: - explicit FunctionSignature_Description(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLanguageFieldNumber = 1, - kBodyFieldNumber = 2, - }; - // string language = 1; - void clear_language(); - const std::string& language() const; - template - void set_language(ArgT0&& arg0, ArgT... args); - std::string* mutable_language(); - PROTOBUF_NODISCARD std::string* release_language(); - void set_allocated_language(std::string* language); - private: - const std::string& _internal_language() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_language(const std::string& value); - std::string* _internal_mutable_language(); - public: - - // string body = 2; - void clear_body(); - const std::string& body() const; - template - void set_body(ArgT0&& arg0, ArgT... args); - std::string* mutable_body(); - PROTOBUF_NODISCARD std::string* release_body(); - void set_allocated_body(std::string* body); - private: - const std::string& _internal_body() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_body(const std::string& value); - std::string* _internal_mutable_body(); - public: - - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Description) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr language_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr body_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature_Implementation final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Implementation) */ { - public: - inline FunctionSignature_Implementation() : FunctionSignature_Implementation(nullptr) {} - ~FunctionSignature_Implementation() override; - explicit constexpr FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_Implementation(const FunctionSignature_Implementation& from); - FunctionSignature_Implementation(FunctionSignature_Implementation&& from) noexcept - : FunctionSignature_Implementation() { - *this = ::std::move(from); - } - - inline FunctionSignature_Implementation& operator=(const FunctionSignature_Implementation& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_Implementation& operator=(FunctionSignature_Implementation&& 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 FunctionSignature_Implementation& default_instance() { - return *internal_default_instance(); - } - static inline const FunctionSignature_Implementation* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_Implementation_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(FunctionSignature_Implementation& a, FunctionSignature_Implementation& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_Implementation* 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(FunctionSignature_Implementation* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_Implementation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FunctionSignature_Implementation& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FunctionSignature_Implementation& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_Implementation* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.Implementation"; - } - protected: - explicit FunctionSignature_Implementation(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef FunctionSignature_Implementation_Type Type; - static constexpr Type TYPE_UNSPECIFIED = - FunctionSignature_Implementation_Type_TYPE_UNSPECIFIED; - static constexpr Type TYPE_WEB_ASSEMBLY = - FunctionSignature_Implementation_Type_TYPE_WEB_ASSEMBLY; - static constexpr Type TYPE_TRINO_JAR = - FunctionSignature_Implementation_Type_TYPE_TRINO_JAR; - static inline bool Type_IsValid(int value) { - return FunctionSignature_Implementation_Type_IsValid(value); - } - static constexpr Type Type_MIN = - FunctionSignature_Implementation_Type_Type_MIN; - static constexpr Type Type_MAX = - FunctionSignature_Implementation_Type_Type_MAX; - static constexpr int Type_ARRAYSIZE = - FunctionSignature_Implementation_Type_Type_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Type_descriptor() { - return FunctionSignature_Implementation_Type_descriptor(); - } - template - static inline const std::string& Type_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Type_Name."); - return FunctionSignature_Implementation_Type_Name(enum_t_value); - } - static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Type* value) { - return FunctionSignature_Implementation_Type_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kUriFieldNumber = 2, - kTypeFieldNumber = 1, - }; - // string uri = 2; - void clear_uri(); - const std::string& uri() const; - template - void set_uri(ArgT0&& arg0, ArgT... args); - std::string* mutable_uri(); - PROTOBUF_NODISCARD std::string* release_uri(); - void set_allocated_uri(std::string* uri); - private: - const std::string& _internal_uri() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri(const std::string& value); - std::string* _internal_mutable_uri(); - public: - - // .substrait.FunctionSignature.Implementation.Type type = 1; - void clear_type(); - ::substrait::FunctionSignature_Implementation_Type type() const; - void set_type(::substrait::FunctionSignature_Implementation_Type value); - private: - ::substrait::FunctionSignature_Implementation_Type _internal_type() const; - void _internal_set_type(::substrait::FunctionSignature_Implementation_Type value); - public: - - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Implementation) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_; - int type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature_Argument_ValueArgument final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.ValueArgument) */ { - public: - inline FunctionSignature_Argument_ValueArgument() : FunctionSignature_Argument_ValueArgument(nullptr) {} - ~FunctionSignature_Argument_ValueArgument() override; - explicit constexpr FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_Argument_ValueArgument(const FunctionSignature_Argument_ValueArgument& from); - FunctionSignature_Argument_ValueArgument(FunctionSignature_Argument_ValueArgument&& from) noexcept - : FunctionSignature_Argument_ValueArgument() { - *this = ::std::move(from); - } - - inline FunctionSignature_Argument_ValueArgument& operator=(const FunctionSignature_Argument_ValueArgument& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_Argument_ValueArgument& operator=(FunctionSignature_Argument_ValueArgument&& 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 FunctionSignature_Argument_ValueArgument& default_instance() { - return *internal_default_instance(); - } - static inline const FunctionSignature_Argument_ValueArgument* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_Argument_ValueArgument_default_instance_); - } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(FunctionSignature_Argument_ValueArgument& a, FunctionSignature_Argument_ValueArgument& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_Argument_ValueArgument* 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(FunctionSignature_Argument_ValueArgument* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_Argument_ValueArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FunctionSignature_Argument_ValueArgument& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FunctionSignature_Argument_ValueArgument& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_Argument_ValueArgument* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.Argument.ValueArgument"; - } - protected: - explicit FunctionSignature_Argument_ValueArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeFieldNumber = 1, - kConstantFieldNumber = 2, - }; - // .substrait.ParameterizedType type = 1; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - const ::substrait::ParameterizedType& type() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type(); - ::substrait::ParameterizedType* mutable_type(); - void set_allocated_type(::substrait::ParameterizedType* type); - private: - const ::substrait::ParameterizedType& _internal_type() const; - ::substrait::ParameterizedType* _internal_mutable_type(); - public: - void unsafe_arena_set_allocated_type( - ::substrait::ParameterizedType* type); - ::substrait::ParameterizedType* unsafe_arena_release_type(); - - // bool constant = 2; - void clear_constant(); - bool constant() const; - void set_constant(bool value); - private: - bool _internal_constant() const; - void _internal_set_constant(bool value); - public: - - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.ValueArgument) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::ParameterizedType* type_; - bool constant_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature_Argument_TypeArgument final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.TypeArgument) */ { - public: - inline FunctionSignature_Argument_TypeArgument() : FunctionSignature_Argument_TypeArgument(nullptr) {} - ~FunctionSignature_Argument_TypeArgument() override; - explicit constexpr FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_Argument_TypeArgument(const FunctionSignature_Argument_TypeArgument& from); - FunctionSignature_Argument_TypeArgument(FunctionSignature_Argument_TypeArgument&& from) noexcept - : FunctionSignature_Argument_TypeArgument() { - *this = ::std::move(from); - } - - inline FunctionSignature_Argument_TypeArgument& operator=(const FunctionSignature_Argument_TypeArgument& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_Argument_TypeArgument& operator=(FunctionSignature_Argument_TypeArgument&& 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 FunctionSignature_Argument_TypeArgument& default_instance() { - return *internal_default_instance(); - } - static inline const FunctionSignature_Argument_TypeArgument* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_Argument_TypeArgument_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(FunctionSignature_Argument_TypeArgument& a, FunctionSignature_Argument_TypeArgument& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_Argument_TypeArgument* 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(FunctionSignature_Argument_TypeArgument* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_Argument_TypeArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FunctionSignature_Argument_TypeArgument& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FunctionSignature_Argument_TypeArgument& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_Argument_TypeArgument* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.Argument.TypeArgument"; - } - protected: - explicit FunctionSignature_Argument_TypeArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeFieldNumber = 1, - }; - // .substrait.ParameterizedType type = 1; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - const ::substrait::ParameterizedType& type() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type(); - ::substrait::ParameterizedType* mutable_type(); - void set_allocated_type(::substrait::ParameterizedType* type); - private: - const ::substrait::ParameterizedType& _internal_type() const; - ::substrait::ParameterizedType* _internal_mutable_type(); - public: - void unsafe_arena_set_allocated_type( - ::substrait::ParameterizedType* type); - ::substrait::ParameterizedType* unsafe_arena_release_type(); - - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.TypeArgument) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::ParameterizedType* type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature_Argument_EnumArgument final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument.EnumArgument) */ { - public: - inline FunctionSignature_Argument_EnumArgument() : FunctionSignature_Argument_EnumArgument(nullptr) {} - ~FunctionSignature_Argument_EnumArgument() override; - explicit constexpr FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_Argument_EnumArgument(const FunctionSignature_Argument_EnumArgument& from); - FunctionSignature_Argument_EnumArgument(FunctionSignature_Argument_EnumArgument&& from) noexcept - : FunctionSignature_Argument_EnumArgument() { - *this = ::std::move(from); - } - - inline FunctionSignature_Argument_EnumArgument& operator=(const FunctionSignature_Argument_EnumArgument& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_Argument_EnumArgument& operator=(FunctionSignature_Argument_EnumArgument&& 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 FunctionSignature_Argument_EnumArgument& default_instance() { - return *internal_default_instance(); - } - static inline const FunctionSignature_Argument_EnumArgument* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_Argument_EnumArgument_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(FunctionSignature_Argument_EnumArgument& a, FunctionSignature_Argument_EnumArgument& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_Argument_EnumArgument* 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(FunctionSignature_Argument_EnumArgument* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_Argument_EnumArgument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FunctionSignature_Argument_EnumArgument& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FunctionSignature_Argument_EnumArgument& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_Argument_EnumArgument* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.Argument.EnumArgument"; - } - protected: - explicit FunctionSignature_Argument_EnumArgument(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kOptionsFieldNumber = 1, - kOptionalFieldNumber = 2, - }; - // repeated string options = 1; - int options_size() const; - private: - int _internal_options_size() const; - public: - void clear_options(); - const std::string& options(int index) const; - std::string* mutable_options(int index); - void set_options(int index, const std::string& value); - void set_options(int index, std::string&& value); - void set_options(int index, const char* value); - void set_options(int index, const char* value, size_t size); - std::string* add_options(); - void add_options(const std::string& value); - void add_options(std::string&& value); - void add_options(const char* value); - void add_options(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& options() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_options(); - private: - const std::string& _internal_options(int index) const; - std::string* _internal_add_options(); - public: - - // bool optional = 2; - void clear_optional(); - bool optional() const; - void set_optional(bool value); - private: - bool _internal_optional() const; - void _internal_set_optional(bool value); - public: - - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument.EnumArgument) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField options_; - bool optional_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature_Argument final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature.Argument) */ { - public: - inline FunctionSignature_Argument() : FunctionSignature_Argument(nullptr) {} - ~FunctionSignature_Argument() override; - explicit constexpr FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature_Argument(const FunctionSignature_Argument& from); - FunctionSignature_Argument(FunctionSignature_Argument&& from) noexcept - : FunctionSignature_Argument() { - *this = ::std::move(from); - } - - inline FunctionSignature_Argument& operator=(const FunctionSignature_Argument& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature_Argument& operator=(FunctionSignature_Argument&& 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 FunctionSignature_Argument& default_instance() { - return *internal_default_instance(); - } - enum ArgumentKindCase { - kValue = 2, - kType = 3, - kEnum = 4, - ARGUMENT_KIND_NOT_SET = 0, - }; - - static inline const FunctionSignature_Argument* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_Argument_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(FunctionSignature_Argument& a, FunctionSignature_Argument& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature_Argument* 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(FunctionSignature_Argument* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature_Argument* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FunctionSignature_Argument& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FunctionSignature_Argument& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FunctionSignature_Argument* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature.Argument"; - } - protected: - explicit FunctionSignature_Argument(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef FunctionSignature_Argument_ValueArgument ValueArgument; - typedef FunctionSignature_Argument_TypeArgument TypeArgument; - typedef FunctionSignature_Argument_EnumArgument EnumArgument; - - // accessors ------------------------------------------------------- - - enum : int { - kNameFieldNumber = 1, - kValueFieldNumber = 2, - kTypeFieldNumber = 3, - kEnumFieldNumber = 4, - }; - // string name = 1; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // .substrait.FunctionSignature.Argument.ValueArgument value = 2; - bool has_value() const; - private: - bool _internal_has_value() const; - public: - void clear_value(); - const ::substrait::FunctionSignature_Argument_ValueArgument& value() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_ValueArgument* release_value(); - ::substrait::FunctionSignature_Argument_ValueArgument* mutable_value(); - void set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value); - private: - const ::substrait::FunctionSignature_Argument_ValueArgument& _internal_value() const; - ::substrait::FunctionSignature_Argument_ValueArgument* _internal_mutable_value(); - public: - void unsafe_arena_set_allocated_value( - ::substrait::FunctionSignature_Argument_ValueArgument* value); - ::substrait::FunctionSignature_Argument_ValueArgument* unsafe_arena_release_value(); - - // .substrait.FunctionSignature.Argument.TypeArgument type = 3; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - const ::substrait::FunctionSignature_Argument_TypeArgument& type() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_TypeArgument* release_type(); - ::substrait::FunctionSignature_Argument_TypeArgument* mutable_type(); - void set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type); - private: - const ::substrait::FunctionSignature_Argument_TypeArgument& _internal_type() const; - ::substrait::FunctionSignature_Argument_TypeArgument* _internal_mutable_type(); - public: - void unsafe_arena_set_allocated_type( - ::substrait::FunctionSignature_Argument_TypeArgument* type); - ::substrait::FunctionSignature_Argument_TypeArgument* unsafe_arena_release_type(); - - // .substrait.FunctionSignature.Argument.EnumArgument enum = 4; - bool has_enum_() const; - private: - bool _internal_has_enum_() const; - public: - void clear_enum_(); - const ::substrait::FunctionSignature_Argument_EnumArgument& enum_() const; - PROTOBUF_NODISCARD ::substrait::FunctionSignature_Argument_EnumArgument* release_enum_(); - ::substrait::FunctionSignature_Argument_EnumArgument* mutable_enum_(); - void set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_); - private: - const ::substrait::FunctionSignature_Argument_EnumArgument& _internal_enum_() const; - ::substrait::FunctionSignature_Argument_EnumArgument* _internal_mutable_enum_(); - public: - void unsafe_arena_set_allocated_enum_( - ::substrait::FunctionSignature_Argument_EnumArgument* enum_); - ::substrait::FunctionSignature_Argument_EnumArgument* unsafe_arena_release_enum_(); - - void clear_argument_kind(); - ArgumentKindCase argument_kind_case() const; - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature.Argument) - private: - class _Internal; - void set_has_value(); - void set_has_type(); - void set_has_enum_(); - - inline bool has_argument_kind() const; - inline void clear_has_argument_kind(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - union ArgumentKindUnion { - constexpr ArgumentKindUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::FunctionSignature_Argument_ValueArgument* value_; - ::substrait::FunctionSignature_Argument_TypeArgument* type_; - ::substrait::FunctionSignature_Argument_EnumArgument* enum__; - } argument_kind_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// ------------------------------------------------------------------- - -class FunctionSignature final : - public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.FunctionSignature) */ { - public: - inline FunctionSignature() : FunctionSignature(nullptr) {} - explicit constexpr FunctionSignature(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FunctionSignature(const FunctionSignature& from); - FunctionSignature(FunctionSignature&& from) noexcept - : FunctionSignature() { - *this = ::std::move(from); - } - - inline FunctionSignature& operator=(const FunctionSignature& from) { - CopyFrom(from); - return *this; - } - inline FunctionSignature& operator=(FunctionSignature&& 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 FunctionSignature& default_instance() { - return *internal_default_instance(); - } - static inline const FunctionSignature* internal_default_instance() { - return reinterpret_cast( - &_FunctionSignature_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(FunctionSignature& a, FunctionSignature& b) { - a.Swap(&b); - } - inline void Swap(FunctionSignature* 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(FunctionSignature* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FunctionSignature* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; - inline void CopyFrom(const FunctionSignature& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; - void MergeFrom(const FunctionSignature& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); - } - public: - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FunctionSignature"; - } - protected: - explicit FunctionSignature(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef FunctionSignature_FinalArgVariadic FinalArgVariadic; - typedef FunctionSignature_FinalArgNormal FinalArgNormal; - typedef FunctionSignature_Scalar Scalar; - typedef FunctionSignature_Aggregate Aggregate; - typedef FunctionSignature_Window Window; - typedef FunctionSignature_Description Description; - typedef FunctionSignature_Implementation Implementation; - typedef FunctionSignature_Argument Argument; - - // accessors ------------------------------------------------------- - - // @@protoc_insertion_point(class_scope:substrait.FunctionSignature) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ffunction_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// FunctionSignature_FinalArgVariadic - -// int64 min_args = 1; -inline void FunctionSignature_FinalArgVariadic::clear_min_args() { - min_args_ = int64_t{0}; -} -inline int64_t FunctionSignature_FinalArgVariadic::_internal_min_args() const { - return min_args_; -} -inline int64_t FunctionSignature_FinalArgVariadic::min_args() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.min_args) - return _internal_min_args(); -} -inline void FunctionSignature_FinalArgVariadic::_internal_set_min_args(int64_t value) { - - min_args_ = value; -} -inline void FunctionSignature_FinalArgVariadic::set_min_args(int64_t value) { - _internal_set_min_args(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.min_args) -} - -// int64 max_args = 2; -inline void FunctionSignature_FinalArgVariadic::clear_max_args() { - max_args_ = int64_t{0}; -} -inline int64_t FunctionSignature_FinalArgVariadic::_internal_max_args() const { - return max_args_; -} -inline int64_t FunctionSignature_FinalArgVariadic::max_args() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.max_args) - return _internal_max_args(); -} -inline void FunctionSignature_FinalArgVariadic::_internal_set_max_args(int64_t value) { - - max_args_ = value; -} -inline void FunctionSignature_FinalArgVariadic::set_max_args(int64_t value) { - _internal_set_max_args(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.max_args) -} - -// .substrait.FunctionSignature.FinalArgVariadic.ParameterConsistency consistency = 3; -inline void FunctionSignature_FinalArgVariadic::clear_consistency() { - consistency_ = 0; -} -inline ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::_internal_consistency() const { - return static_cast< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency >(consistency_); -} -inline ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency FunctionSignature_FinalArgVariadic::consistency() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.FinalArgVariadic.consistency) - return _internal_consistency(); -} -inline void FunctionSignature_FinalArgVariadic::_internal_set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) { - - consistency_ = value; -} -inline void FunctionSignature_FinalArgVariadic::set_consistency(::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency value) { - _internal_set_consistency(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.FinalArgVariadic.consistency) -} - -// ------------------------------------------------------------------- - -// FunctionSignature_FinalArgNormal - -// ------------------------------------------------------------------- - -// FunctionSignature_Scalar - -// repeated .substrait.FunctionSignature.Argument arguments = 2; -inline int FunctionSignature_Scalar::_internal_arguments_size() const { - return arguments_.size(); -} -inline int FunctionSignature_Scalar::arguments_size() const { - return _internal_arguments_size(); -} -inline void FunctionSignature_Scalar::clear_arguments() { - arguments_.Clear(); -} -inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::mutable_arguments(int index) { - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.arguments) - return arguments_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* -FunctionSignature_Scalar::mutable_arguments() { - // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.arguments) - return &arguments_; -} -inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::_internal_arguments(int index) const { - return arguments_.Get(index); -} -inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Scalar::arguments(int index) const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.arguments) - return _internal_arguments(index); -} -inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::_internal_add_arguments() { - return arguments_.Add(); -} -inline ::substrait::FunctionSignature_Argument* FunctionSignature_Scalar::add_arguments() { - ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments(); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.arguments) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& -FunctionSignature_Scalar::arguments() const { - // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.arguments) - return arguments_; -} - -// repeated string name = 3; -inline int FunctionSignature_Scalar::_internal_name_size() const { - return name_.size(); -} -inline int FunctionSignature_Scalar::name_size() const { - return _internal_name_size(); -} -inline void FunctionSignature_Scalar::clear_name() { - name_.Clear(); -} -inline std::string* FunctionSignature_Scalar::add_name() { - std::string* _s = _internal_add_name(); - // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Scalar.name) - return _s; -} -inline const std::string& FunctionSignature_Scalar::_internal_name(int index) const { - return name_.Get(index); -} -inline const std::string& FunctionSignature_Scalar::name(int index) const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.name) - return _internal_name(index); -} -inline std::string* FunctionSignature_Scalar::mutable_name(int index) { - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.name) - return name_.Mutable(index); -} -inline void FunctionSignature_Scalar::set_name(int index, const std::string& value) { - name_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name) -} -inline void FunctionSignature_Scalar::set_name(int index, std::string&& value) { - name_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.name) -} -inline void FunctionSignature_Scalar::set_name(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - name_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Scalar.name) -} -inline void FunctionSignature_Scalar::set_name(int index, const char* value, size_t size) { - name_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Scalar.name) -} -inline std::string* FunctionSignature_Scalar::_internal_add_name() { - return name_.Add(); -} -inline void FunctionSignature_Scalar::add_name(const std::string& value) { - name_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.name) -} -inline void FunctionSignature_Scalar::add_name(std::string&& value) { - name_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.name) -} -inline void FunctionSignature_Scalar::add_name(const char* value) { - GOOGLE_DCHECK(value != nullptr); - name_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Scalar.name) -} -inline void FunctionSignature_Scalar::add_name(const char* value, size_t size) { - name_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Scalar.name) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -FunctionSignature_Scalar::name() const { - // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.name) - return name_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -FunctionSignature_Scalar::mutable_name() { - // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.name) - return &name_; -} - -// .substrait.FunctionSignature.Description description = 4; -inline bool FunctionSignature_Scalar::_internal_has_description() const { - return this != internal_default_instance() && description_ != nullptr; -} -inline bool FunctionSignature_Scalar::has_description() const { - return _internal_has_description(); -} -inline void FunctionSignature_Scalar::clear_description() { - if (GetArenaForAllocation() == nullptr && description_ != nullptr) { - delete description_; - } - description_ = nullptr; -} -inline const ::substrait::FunctionSignature_Description& FunctionSignature_Scalar::_internal_description() const { - const ::substrait::FunctionSignature_Description* p = description_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_FunctionSignature_Description_default_instance_); -} -inline const ::substrait::FunctionSignature_Description& FunctionSignature_Scalar::description() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.description) - return _internal_description(); -} -inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_description( - ::substrait::FunctionSignature_Description* description) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); - } - description_ = description; - if (description) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.description) -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::release_description() { - - ::substrait::FunctionSignature_Description* temp = description_; - description_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::unsafe_arena_release_description() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.description) - - ::substrait::FunctionSignature_Description* temp = description_; - description_ = nullptr; - return temp; -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::_internal_mutable_description() { - - if (description_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation()); - description_ = p; - } - return description_; -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Scalar::mutable_description() { - ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.description) - return _msg; -} -inline void FunctionSignature_Scalar::set_allocated_description(::substrait::FunctionSignature_Description* description) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete description_; - } - if (description) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description); - if (message_arena != submessage_arena) { - description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, description, submessage_arena); - } - - } else { - - } - description_ = description; - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.description) -} - -// bool deterministic = 7; -inline void FunctionSignature_Scalar::clear_deterministic() { - deterministic_ = false; -} -inline bool FunctionSignature_Scalar::_internal_deterministic() const { - return deterministic_; -} -inline bool FunctionSignature_Scalar::deterministic() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.deterministic) - return _internal_deterministic(); -} -inline void FunctionSignature_Scalar::_internal_set_deterministic(bool value) { - - deterministic_ = value; -} -inline void FunctionSignature_Scalar::set_deterministic(bool value) { - _internal_set_deterministic(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.deterministic) -} - -// bool session_dependent = 8; -inline void FunctionSignature_Scalar::clear_session_dependent() { - session_dependent_ = false; -} -inline bool FunctionSignature_Scalar::_internal_session_dependent() const { - return session_dependent_; -} -inline bool FunctionSignature_Scalar::session_dependent() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.session_dependent) - return _internal_session_dependent(); -} -inline void FunctionSignature_Scalar::_internal_set_session_dependent(bool value) { - - session_dependent_ = value; -} -inline void FunctionSignature_Scalar::set_session_dependent(bool value) { - _internal_set_session_dependent(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Scalar.session_dependent) -} - -// .substrait.DerivationExpression output_type = 9; -inline bool FunctionSignature_Scalar::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; -} -inline bool FunctionSignature_Scalar::has_output_type() const { - return _internal_has_output_type(); -} -inline const ::substrait::DerivationExpression& FunctionSignature_Scalar::_internal_output_type() const { - const ::substrait::DerivationExpression* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& FunctionSignature_Scalar::output_type() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.output_type) - return _internal_output_type(); -} -inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_output_type( - ::substrait::DerivationExpression* output_type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - output_type_ = output_type; - if (output_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.output_type) -} -inline ::substrait::DerivationExpression* FunctionSignature_Scalar::release_output_type() { - - ::substrait::DerivationExpression* temp = output_type_; - output_type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* FunctionSignature_Scalar::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.output_type) - - ::substrait::DerivationExpression* temp = output_type_; - output_type_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* FunctionSignature_Scalar::_internal_mutable_output_type() { - - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - output_type_ = p; - } - return output_type_; -} -inline ::substrait::DerivationExpression* FunctionSignature_Scalar::mutable_output_type() { - ::substrait::DerivationExpression* _msg = _internal_mutable_output_type(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.output_type) - return _msg; -} -inline void FunctionSignature_Scalar::set_allocated_output_type(::substrait::DerivationExpression* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - if (output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); - if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); - } - - } else { - - } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Scalar.output_type) -} - -// .substrait.FunctionSignature.FinalArgVariadic variadic = 10; -inline bool FunctionSignature_Scalar::_internal_has_variadic() const { - return final_variable_behavior_case() == kVariadic; -} -inline bool FunctionSignature_Scalar::has_variadic() const { - return _internal_has_variadic(); -} -inline void FunctionSignature_Scalar::set_has_variadic() { - _oneof_case_[0] = kVariadic; -} -inline void FunctionSignature_Scalar::clear_variadic() { - if (_internal_has_variadic()) { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.variadic_; - } - clear_has_final_variable_behavior(); - } -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::release_variadic() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.variadic) - if (_internal_has_variadic()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - final_variable_behavior_.variadic_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::_internal_variadic() const { - return _internal_has_variadic() - ? *final_variable_behavior_.variadic_ - : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); -} -inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Scalar::variadic() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.variadic) - return _internal_variadic(); -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::unsafe_arena_release_variadic() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Scalar.variadic) - if (_internal_has_variadic()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; - final_variable_behavior_.variadic_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { - clear_final_variable_behavior(); - if (variadic) { - set_has_variadic(); - final_variable_behavior_.variadic_ = variadic; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.variadic) -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::_internal_mutable_variadic() { - if (!_internal_has_variadic()) { - clear_final_variable_behavior(); - set_has_variadic(); - final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation()); - } - return final_variable_behavior_.variadic_; -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Scalar::mutable_variadic() { - ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.variadic) - return _msg; -} - -// .substrait.FunctionSignature.FinalArgNormal normal = 11; -inline bool FunctionSignature_Scalar::_internal_has_normal() const { - return final_variable_behavior_case() == kNormal; -} -inline bool FunctionSignature_Scalar::has_normal() const { - return _internal_has_normal(); -} -inline void FunctionSignature_Scalar::set_has_normal() { - _oneof_case_[0] = kNormal; -} -inline void FunctionSignature_Scalar::clear_normal() { - if (_internal_has_normal()) { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.normal_; - } - clear_has_final_variable_behavior(); - } -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::release_normal() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Scalar.normal) - if (_internal_has_normal()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - final_variable_behavior_.normal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::_internal_normal() const { - return _internal_has_normal() - ? *final_variable_behavior_.normal_ - : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_); -} -inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Scalar::normal() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.normal) - return _internal_normal(); -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::unsafe_arena_release_normal() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Scalar.normal) - if (_internal_has_normal()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; - final_variable_behavior_.normal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FunctionSignature_Scalar::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { - clear_final_variable_behavior(); - if (normal) { - set_has_normal(); - final_variable_behavior_.normal_ = normal; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Scalar.normal) -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::_internal_mutable_normal() { - if (!_internal_has_normal()) { - clear_final_variable_behavior(); - set_has_normal(); - final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation()); - } - return final_variable_behavior_.normal_; -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Scalar::mutable_normal() { - ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.normal) - return _msg; -} - -// repeated .substrait.FunctionSignature.Implementation implementations = 12; -inline int FunctionSignature_Scalar::_internal_implementations_size() const { - return implementations_.size(); -} -inline int FunctionSignature_Scalar::implementations_size() const { - return _internal_implementations_size(); -} -inline void FunctionSignature_Scalar::clear_implementations() { - implementations_.Clear(); -} -inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::mutable_implementations(int index) { - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Scalar.implementations) - return implementations_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* -FunctionSignature_Scalar::mutable_implementations() { - // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Scalar.implementations) - return &implementations_; -} -inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::_internal_implementations(int index) const { - return implementations_.Get(index); -} -inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Scalar::implementations(int index) const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Scalar.implementations) - return _internal_implementations(index); -} -inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::_internal_add_implementations() { - return implementations_.Add(); -} -inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Scalar::add_implementations() { - ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations(); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Scalar.implementations) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& -FunctionSignature_Scalar::implementations() const { - // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Scalar.implementations) - return implementations_; -} - -inline bool FunctionSignature_Scalar::has_final_variable_behavior() const { - return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET; -} -inline void FunctionSignature_Scalar::clear_has_final_variable_behavior() { - _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; -} -inline FunctionSignature_Scalar::FinalVariableBehaviorCase FunctionSignature_Scalar::final_variable_behavior_case() const { - return FunctionSignature_Scalar::FinalVariableBehaviorCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// FunctionSignature_Aggregate - -// repeated .substrait.FunctionSignature.Argument arguments = 2; -inline int FunctionSignature_Aggregate::_internal_arguments_size() const { - return arguments_.size(); -} -inline int FunctionSignature_Aggregate::arguments_size() const { - return _internal_arguments_size(); -} -inline void FunctionSignature_Aggregate::clear_arguments() { - arguments_.Clear(); -} -inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::mutable_arguments(int index) { - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.arguments) - return arguments_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* -FunctionSignature_Aggregate::mutable_arguments() { - // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Aggregate.arguments) - return &arguments_; -} -inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::_internal_arguments(int index) const { - return arguments_.Get(index); -} -inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Aggregate::arguments(int index) const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.arguments) - return _internal_arguments(index); -} -inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::_internal_add_arguments() { - return arguments_.Add(); -} -inline ::substrait::FunctionSignature_Argument* FunctionSignature_Aggregate::add_arguments() { - ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments(); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Aggregate.arguments) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& -FunctionSignature_Aggregate::arguments() const { - // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Aggregate.arguments) - return arguments_; -} - -// string name = 3; -inline void FunctionSignature_Aggregate::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& FunctionSignature_Aggregate::name() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void FunctionSignature_Aggregate::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.name) -} -inline std::string* FunctionSignature_Aggregate::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.name) - return _s; -} -inline const std::string& FunctionSignature_Aggregate::_internal_name() const { - return name_.Get(); -} -inline void FunctionSignature_Aggregate::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* FunctionSignature_Aggregate::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* FunctionSignature_Aggregate::release_name() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void FunctionSignature_Aggregate::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.name) -} - -// .substrait.FunctionSignature.Description description = 4; -inline bool FunctionSignature_Aggregate::_internal_has_description() const { - return this != internal_default_instance() && description_ != nullptr; -} -inline bool FunctionSignature_Aggregate::has_description() const { - return _internal_has_description(); -} -inline void FunctionSignature_Aggregate::clear_description() { - if (GetArenaForAllocation() == nullptr && description_ != nullptr) { - delete description_; - } - description_ = nullptr; -} -inline const ::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::_internal_description() const { - const ::substrait::FunctionSignature_Description* p = description_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_FunctionSignature_Description_default_instance_); -} -inline const ::substrait::FunctionSignature_Description& FunctionSignature_Aggregate::description() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.description) - return _internal_description(); -} -inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_description( - ::substrait::FunctionSignature_Description* description) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); - } - description_ = description; - if (description) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.description) -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::release_description() { - - ::substrait::FunctionSignature_Description* temp = description_; - description_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::unsafe_arena_release_description() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.description) - - ::substrait::FunctionSignature_Description* temp = description_; - description_ = nullptr; - return temp; -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::_internal_mutable_description() { - - if (description_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation()); - description_ = p; - } - return description_; -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Aggregate::mutable_description() { - ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.description) - return _msg; -} -inline void FunctionSignature_Aggregate::set_allocated_description(::substrait::FunctionSignature_Description* description) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete description_; - } - if (description) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description); - if (message_arena != submessage_arena) { - description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, description, submessage_arena); - } - - } else { - - } - description_ = description; - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.description) -} - -// bool deterministic = 7; -inline void FunctionSignature_Aggregate::clear_deterministic() { - deterministic_ = false; -} -inline bool FunctionSignature_Aggregate::_internal_deterministic() const { - return deterministic_; -} -inline bool FunctionSignature_Aggregate::deterministic() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.deterministic) - return _internal_deterministic(); -} -inline void FunctionSignature_Aggregate::_internal_set_deterministic(bool value) { - - deterministic_ = value; -} -inline void FunctionSignature_Aggregate::set_deterministic(bool value) { - _internal_set_deterministic(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.deterministic) -} - -// bool session_dependent = 8; -inline void FunctionSignature_Aggregate::clear_session_dependent() { - session_dependent_ = false; -} -inline bool FunctionSignature_Aggregate::_internal_session_dependent() const { - return session_dependent_; -} -inline bool FunctionSignature_Aggregate::session_dependent() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.session_dependent) - return _internal_session_dependent(); -} -inline void FunctionSignature_Aggregate::_internal_set_session_dependent(bool value) { - - session_dependent_ = value; -} -inline void FunctionSignature_Aggregate::set_session_dependent(bool value) { - _internal_set_session_dependent(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.session_dependent) -} - -// .substrait.DerivationExpression output_type = 9; -inline bool FunctionSignature_Aggregate::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; -} -inline bool FunctionSignature_Aggregate::has_output_type() const { - return _internal_has_output_type(); -} -inline const ::substrait::DerivationExpression& FunctionSignature_Aggregate::_internal_output_type() const { - const ::substrait::DerivationExpression* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& FunctionSignature_Aggregate::output_type() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.output_type) - return _internal_output_type(); -} -inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_output_type( - ::substrait::DerivationExpression* output_type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - output_type_ = output_type; - if (output_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.output_type) -} -inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::release_output_type() { - - ::substrait::DerivationExpression* temp = output_type_; - output_type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.output_type) - - ::substrait::DerivationExpression* temp = output_type_; - output_type_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::_internal_mutable_output_type() { - - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - output_type_ = p; - } - return output_type_; -} -inline ::substrait::DerivationExpression* FunctionSignature_Aggregate::mutable_output_type() { - ::substrait::DerivationExpression* _msg = _internal_mutable_output_type(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.output_type) - return _msg; -} -inline void FunctionSignature_Aggregate::set_allocated_output_type(::substrait::DerivationExpression* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - if (output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); - if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); - } - - } else { - - } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.output_type) -} - -// .substrait.FunctionSignature.FinalArgVariadic variadic = 10; -inline bool FunctionSignature_Aggregate::_internal_has_variadic() const { - return final_variable_behavior_case() == kVariadic; -} -inline bool FunctionSignature_Aggregate::has_variadic() const { - return _internal_has_variadic(); -} -inline void FunctionSignature_Aggregate::set_has_variadic() { - _oneof_case_[0] = kVariadic; -} -inline void FunctionSignature_Aggregate::clear_variadic() { - if (_internal_has_variadic()) { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.variadic_; - } - clear_has_final_variable_behavior(); - } -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::release_variadic() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.variadic) - if (_internal_has_variadic()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - final_variable_behavior_.variadic_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::_internal_variadic() const { - return _internal_has_variadic() - ? *final_variable_behavior_.variadic_ - : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); -} -inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Aggregate::variadic() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.variadic) - return _internal_variadic(); -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::unsafe_arena_release_variadic() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Aggregate.variadic) - if (_internal_has_variadic()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; - final_variable_behavior_.variadic_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { - clear_final_variable_behavior(); - if (variadic) { - set_has_variadic(); - final_variable_behavior_.variadic_ = variadic; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.variadic) -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::_internal_mutable_variadic() { - if (!_internal_has_variadic()) { - clear_final_variable_behavior(); - set_has_variadic(); - final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation()); - } - return final_variable_behavior_.variadic_; -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Aggregate::mutable_variadic() { - ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.variadic) - return _msg; -} - -// .substrait.FunctionSignature.FinalArgNormal normal = 11; -inline bool FunctionSignature_Aggregate::_internal_has_normal() const { - return final_variable_behavior_case() == kNormal; -} -inline bool FunctionSignature_Aggregate::has_normal() const { - return _internal_has_normal(); -} -inline void FunctionSignature_Aggregate::set_has_normal() { - _oneof_case_[0] = kNormal; -} -inline void FunctionSignature_Aggregate::clear_normal() { - if (_internal_has_normal()) { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.normal_; - } - clear_has_final_variable_behavior(); - } -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::release_normal() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.normal) - if (_internal_has_normal()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - final_variable_behavior_.normal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::_internal_normal() const { - return _internal_has_normal() - ? *final_variable_behavior_.normal_ - : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_); -} -inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Aggregate::normal() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.normal) - return _internal_normal(); -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::unsafe_arena_release_normal() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Aggregate.normal) - if (_internal_has_normal()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; - final_variable_behavior_.normal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { - clear_final_variable_behavior(); - if (normal) { - set_has_normal(); - final_variable_behavior_.normal_ = normal; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.normal) -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::_internal_mutable_normal() { - if (!_internal_has_normal()) { - clear_final_variable_behavior(); - set_has_normal(); - final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation()); - } - return final_variable_behavior_.normal_; -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Aggregate::mutable_normal() { - ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.normal) - return _msg; -} - -// bool ordered = 14; -inline void FunctionSignature_Aggregate::clear_ordered() { - ordered_ = false; -} -inline bool FunctionSignature_Aggregate::_internal_ordered() const { - return ordered_; -} -inline bool FunctionSignature_Aggregate::ordered() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.ordered) - return _internal_ordered(); -} -inline void FunctionSignature_Aggregate::_internal_set_ordered(bool value) { - - ordered_ = value; -} -inline void FunctionSignature_Aggregate::set_ordered(bool value) { - _internal_set_ordered(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.ordered) -} - -// uint64 max_set = 12; -inline void FunctionSignature_Aggregate::clear_max_set() { - max_set_ = uint64_t{0u}; -} -inline uint64_t FunctionSignature_Aggregate::_internal_max_set() const { - return max_set_; -} -inline uint64_t FunctionSignature_Aggregate::max_set() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.max_set) - return _internal_max_set(); -} -inline void FunctionSignature_Aggregate::_internal_set_max_set(uint64_t value) { - - max_set_ = value; -} -inline void FunctionSignature_Aggregate::set_max_set(uint64_t value) { - _internal_set_max_set(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Aggregate.max_set) -} - -// .substrait.Type intermediate_type = 13; -inline bool FunctionSignature_Aggregate::_internal_has_intermediate_type() const { - return this != internal_default_instance() && intermediate_type_ != nullptr; -} -inline bool FunctionSignature_Aggregate::has_intermediate_type() const { - return _internal_has_intermediate_type(); -} -inline const ::substrait::Type& FunctionSignature_Aggregate::_internal_intermediate_type() const { - const ::substrait::Type* p = intermediate_type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Type_default_instance_); -} -inline const ::substrait::Type& FunctionSignature_Aggregate::intermediate_type() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.intermediate_type) - return _internal_intermediate_type(); -} -inline void FunctionSignature_Aggregate::unsafe_arena_set_allocated_intermediate_type( - ::substrait::Type* intermediate_type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); - } - intermediate_type_ = intermediate_type; - if (intermediate_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Aggregate.intermediate_type) -} -inline ::substrait::Type* FunctionSignature_Aggregate::release_intermediate_type() { - - ::substrait::Type* temp = intermediate_type_; - intermediate_type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Type* FunctionSignature_Aggregate::unsafe_arena_release_intermediate_type() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Aggregate.intermediate_type) - - ::substrait::Type* temp = intermediate_type_; - intermediate_type_ = nullptr; - return temp; -} -inline ::substrait::Type* FunctionSignature_Aggregate::_internal_mutable_intermediate_type() { - - if (intermediate_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); - intermediate_type_ = p; - } - return intermediate_type_; -} -inline ::substrait::Type* FunctionSignature_Aggregate::mutable_intermediate_type() { - ::substrait::Type* _msg = _internal_mutable_intermediate_type(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.intermediate_type) - return _msg; -} -inline void FunctionSignature_Aggregate::set_allocated_intermediate_type(::substrait::Type* intermediate_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); - } - if (intermediate_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type)); - if (message_arena != submessage_arena) { - intermediate_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, intermediate_type, submessage_arena); - } - - } else { - - } - intermediate_type_ = intermediate_type; - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Aggregate.intermediate_type) -} - -// repeated .substrait.FunctionSignature.Implementation implementations = 15; -inline int FunctionSignature_Aggregate::_internal_implementations_size() const { - return implementations_.size(); -} -inline int FunctionSignature_Aggregate::implementations_size() const { - return _internal_implementations_size(); -} -inline void FunctionSignature_Aggregate::clear_implementations() { - implementations_.Clear(); -} -inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::mutable_implementations(int index) { - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Aggregate.implementations) - return implementations_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* -FunctionSignature_Aggregate::mutable_implementations() { - // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Aggregate.implementations) - return &implementations_; -} -inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::_internal_implementations(int index) const { - return implementations_.Get(index); -} -inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Aggregate::implementations(int index) const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Aggregate.implementations) - return _internal_implementations(index); -} -inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::_internal_add_implementations() { - return implementations_.Add(); -} -inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Aggregate::add_implementations() { - ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations(); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Aggregate.implementations) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& -FunctionSignature_Aggregate::implementations() const { - // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Aggregate.implementations) - return implementations_; -} - -inline bool FunctionSignature_Aggregate::has_final_variable_behavior() const { - return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET; -} -inline void FunctionSignature_Aggregate::clear_has_final_variable_behavior() { - _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; -} -inline FunctionSignature_Aggregate::FinalVariableBehaviorCase FunctionSignature_Aggregate::final_variable_behavior_case() const { - return FunctionSignature_Aggregate::FinalVariableBehaviorCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// FunctionSignature_Window - -// repeated .substrait.FunctionSignature.Argument arguments = 2; -inline int FunctionSignature_Window::_internal_arguments_size() const { - return arguments_.size(); -} -inline int FunctionSignature_Window::arguments_size() const { - return _internal_arguments_size(); -} -inline void FunctionSignature_Window::clear_arguments() { - arguments_.Clear(); -} -inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::mutable_arguments(int index) { - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.arguments) - return arguments_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >* -FunctionSignature_Window::mutable_arguments() { - // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.arguments) - return &arguments_; -} -inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Window::_internal_arguments(int index) const { - return arguments_.Get(index); -} -inline const ::substrait::FunctionSignature_Argument& FunctionSignature_Window::arguments(int index) const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.arguments) - return _internal_arguments(index); -} -inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::_internal_add_arguments() { - return arguments_.Add(); -} -inline ::substrait::FunctionSignature_Argument* FunctionSignature_Window::add_arguments() { - ::substrait::FunctionSignature_Argument* _add = _internal_add_arguments(); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.arguments) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Argument >& -FunctionSignature_Window::arguments() const { - // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.arguments) - return arguments_; -} - -// repeated string name = 3; -inline int FunctionSignature_Window::_internal_name_size() const { - return name_.size(); -} -inline int FunctionSignature_Window::name_size() const { - return _internal_name_size(); -} -inline void FunctionSignature_Window::clear_name() { - name_.Clear(); -} -inline std::string* FunctionSignature_Window::add_name() { - std::string* _s = _internal_add_name(); - // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Window.name) - return _s; -} -inline const std::string& FunctionSignature_Window::_internal_name(int index) const { - return name_.Get(index); -} -inline const std::string& FunctionSignature_Window::name(int index) const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.name) - return _internal_name(index); -} -inline std::string* FunctionSignature_Window::mutable_name(int index) { - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.name) - return name_.Mutable(index); -} -inline void FunctionSignature_Window::set_name(int index, const std::string& value) { - name_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name) -} -inline void FunctionSignature_Window::set_name(int index, std::string&& value) { - name_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.name) -} -inline void FunctionSignature_Window::set_name(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - name_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Window.name) -} -inline void FunctionSignature_Window::set_name(int index, const char* value, size_t size) { - name_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Window.name) -} -inline std::string* FunctionSignature_Window::_internal_add_name() { - return name_.Add(); -} -inline void FunctionSignature_Window::add_name(const std::string& value) { - name_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.name) -} -inline void FunctionSignature_Window::add_name(std::string&& value) { - name_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.name) -} -inline void FunctionSignature_Window::add_name(const char* value) { - GOOGLE_DCHECK(value != nullptr); - name_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Window.name) -} -inline void FunctionSignature_Window::add_name(const char* value, size_t size) { - name_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Window.name) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -FunctionSignature_Window::name() const { - // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.name) - return name_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -FunctionSignature_Window::mutable_name() { - // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.name) - return &name_; -} - -// .substrait.FunctionSignature.Description description = 4; -inline bool FunctionSignature_Window::_internal_has_description() const { - return this != internal_default_instance() && description_ != nullptr; -} -inline bool FunctionSignature_Window::has_description() const { - return _internal_has_description(); -} -inline void FunctionSignature_Window::clear_description() { - if (GetArenaForAllocation() == nullptr && description_ != nullptr) { - delete description_; - } - description_ = nullptr; -} -inline const ::substrait::FunctionSignature_Description& FunctionSignature_Window::_internal_description() const { - const ::substrait::FunctionSignature_Description* p = description_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_FunctionSignature_Description_default_instance_); -} -inline const ::substrait::FunctionSignature_Description& FunctionSignature_Window::description() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.description) - return _internal_description(); -} -inline void FunctionSignature_Window::unsafe_arena_set_allocated_description( - ::substrait::FunctionSignature_Description* description) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(description_); - } - description_ = description; - if (description) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.description) -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::release_description() { - - ::substrait::FunctionSignature_Description* temp = description_; - description_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::unsafe_arena_release_description() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.description) - - ::substrait::FunctionSignature_Description* temp = description_; - description_ = nullptr; - return temp; -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::_internal_mutable_description() { - - if (description_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::FunctionSignature_Description>(GetArenaForAllocation()); - description_ = p; - } - return description_; -} -inline ::substrait::FunctionSignature_Description* FunctionSignature_Window::mutable_description() { - ::substrait::FunctionSignature_Description* _msg = _internal_mutable_description(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.description) - return _msg; -} -inline void FunctionSignature_Window::set_allocated_description(::substrait::FunctionSignature_Description* description) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete description_; - } - if (description) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FunctionSignature_Description>::GetOwningArena(description); - if (message_arena != submessage_arena) { - description = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, description, submessage_arena); - } - - } else { - - } - description_ = description; - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.description) -} - -// bool deterministic = 7; -inline void FunctionSignature_Window::clear_deterministic() { - deterministic_ = false; -} -inline bool FunctionSignature_Window::_internal_deterministic() const { - return deterministic_; -} -inline bool FunctionSignature_Window::deterministic() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.deterministic) - return _internal_deterministic(); -} -inline void FunctionSignature_Window::_internal_set_deterministic(bool value) { - - deterministic_ = value; -} -inline void FunctionSignature_Window::set_deterministic(bool value) { - _internal_set_deterministic(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.deterministic) -} - -// bool session_dependent = 8; -inline void FunctionSignature_Window::clear_session_dependent() { - session_dependent_ = false; -} -inline bool FunctionSignature_Window::_internal_session_dependent() const { - return session_dependent_; -} -inline bool FunctionSignature_Window::session_dependent() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.session_dependent) - return _internal_session_dependent(); -} -inline void FunctionSignature_Window::_internal_set_session_dependent(bool value) { - - session_dependent_ = value; -} -inline void FunctionSignature_Window::set_session_dependent(bool value) { - _internal_set_session_dependent(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.session_dependent) -} - -// .substrait.DerivationExpression intermediate_type = 9; -inline bool FunctionSignature_Window::_internal_has_intermediate_type() const { - return this != internal_default_instance() && intermediate_type_ != nullptr; -} -inline bool FunctionSignature_Window::has_intermediate_type() const { - return _internal_has_intermediate_type(); -} -inline const ::substrait::DerivationExpression& FunctionSignature_Window::_internal_intermediate_type() const { - const ::substrait::DerivationExpression* p = intermediate_type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& FunctionSignature_Window::intermediate_type() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.intermediate_type) - return _internal_intermediate_type(); -} -inline void FunctionSignature_Window::unsafe_arena_set_allocated_intermediate_type( - ::substrait::DerivationExpression* intermediate_type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); - } - intermediate_type_ = intermediate_type; - if (intermediate_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.intermediate_type) -} -inline ::substrait::DerivationExpression* FunctionSignature_Window::release_intermediate_type() { - - ::substrait::DerivationExpression* temp = intermediate_type_; - intermediate_type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_intermediate_type() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.intermediate_type) - - ::substrait::DerivationExpression* temp = intermediate_type_; - intermediate_type_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_intermediate_type() { - - if (intermediate_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - intermediate_type_ = p; - } - return intermediate_type_; -} -inline ::substrait::DerivationExpression* FunctionSignature_Window::mutable_intermediate_type() { - ::substrait::DerivationExpression* _msg = _internal_mutable_intermediate_type(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.intermediate_type) - return _msg; -} -inline void FunctionSignature_Window::set_allocated_intermediate_type(::substrait::DerivationExpression* intermediate_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type_); - } - if (intermediate_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(intermediate_type)); - if (message_arena != submessage_arena) { - intermediate_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, intermediate_type, submessage_arena); - } - - } else { - - } - intermediate_type_ = intermediate_type; - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.intermediate_type) -} - -// .substrait.DerivationExpression output_type = 10; -inline bool FunctionSignature_Window::_internal_has_output_type() const { - return this != internal_default_instance() && output_type_ != nullptr; -} -inline bool FunctionSignature_Window::has_output_type() const { - return _internal_has_output_type(); -} -inline const ::substrait::DerivationExpression& FunctionSignature_Window::_internal_output_type() const { - const ::substrait::DerivationExpression* p = output_type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& FunctionSignature_Window::output_type() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.output_type) - return _internal_output_type(); -} -inline void FunctionSignature_Window::unsafe_arena_set_allocated_output_type( - ::substrait::DerivationExpression* output_type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - output_type_ = output_type; - if (output_type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.output_type) -} -inline ::substrait::DerivationExpression* FunctionSignature_Window::release_output_type() { - - ::substrait::DerivationExpression* temp = output_type_; - output_type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* FunctionSignature_Window::unsafe_arena_release_output_type() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.output_type) - - ::substrait::DerivationExpression* temp = output_type_; - output_type_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* FunctionSignature_Window::_internal_mutable_output_type() { - - if (output_type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - output_type_ = p; - } - return output_type_; -} -inline ::substrait::DerivationExpression* FunctionSignature_Window::mutable_output_type() { - ::substrait::DerivationExpression* _msg = _internal_mutable_output_type(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.output_type) - return _msg; -} -inline void FunctionSignature_Window::set_allocated_output_type(::substrait::DerivationExpression* output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type_); - } - if (output_type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_type)); - if (message_arena != submessage_arena) { - output_type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, output_type, submessage_arena); - } - - } else { - - } - output_type_ = output_type; - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Window.output_type) -} - -// .substrait.FunctionSignature.FinalArgVariadic variadic = 16; -inline bool FunctionSignature_Window::_internal_has_variadic() const { - return final_variable_behavior_case() == kVariadic; -} -inline bool FunctionSignature_Window::has_variadic() const { - return _internal_has_variadic(); -} -inline void FunctionSignature_Window::set_has_variadic() { - _oneof_case_[0] = kVariadic; -} -inline void FunctionSignature_Window::clear_variadic() { - if (_internal_has_variadic()) { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.variadic_; - } - clear_has_final_variable_behavior(); - } -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::release_variadic() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.variadic) - if (_internal_has_variadic()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - final_variable_behavior_.variadic_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::_internal_variadic() const { - return _internal_has_variadic() - ? *final_variable_behavior_.variadic_ - : reinterpret_cast< ::substrait::FunctionSignature_FinalArgVariadic&>(::substrait::_FunctionSignature_FinalArgVariadic_default_instance_); -} -inline const ::substrait::FunctionSignature_FinalArgVariadic& FunctionSignature_Window::variadic() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.variadic) - return _internal_variadic(); -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::unsafe_arena_release_variadic() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Window.variadic) - if (_internal_has_variadic()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgVariadic* temp = final_variable_behavior_.variadic_; - final_variable_behavior_.variadic_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FunctionSignature_Window::unsafe_arena_set_allocated_variadic(::substrait::FunctionSignature_FinalArgVariadic* variadic) { - clear_final_variable_behavior(); - if (variadic) { - set_has_variadic(); - final_variable_behavior_.variadic_ = variadic; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.variadic) -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::_internal_mutable_variadic() { - if (!_internal_has_variadic()) { - clear_final_variable_behavior(); - set_has_variadic(); - final_variable_behavior_.variadic_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgVariadic >(GetArenaForAllocation()); - } - return final_variable_behavior_.variadic_; -} -inline ::substrait::FunctionSignature_FinalArgVariadic* FunctionSignature_Window::mutable_variadic() { - ::substrait::FunctionSignature_FinalArgVariadic* _msg = _internal_mutable_variadic(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.variadic) - return _msg; -} - -// .substrait.FunctionSignature.FinalArgNormal normal = 17; -inline bool FunctionSignature_Window::_internal_has_normal() const { - return final_variable_behavior_case() == kNormal; -} -inline bool FunctionSignature_Window::has_normal() const { - return _internal_has_normal(); -} -inline void FunctionSignature_Window::set_has_normal() { - _oneof_case_[0] = kNormal; -} -inline void FunctionSignature_Window::clear_normal() { - if (_internal_has_normal()) { - if (GetArenaForAllocation() == nullptr) { - delete final_variable_behavior_.normal_; - } - clear_has_final_variable_behavior(); - } -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::release_normal() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Window.normal) - if (_internal_has_normal()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - final_variable_behavior_.normal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::_internal_normal() const { - return _internal_has_normal() - ? *final_variable_behavior_.normal_ - : reinterpret_cast< ::substrait::FunctionSignature_FinalArgNormal&>(::substrait::_FunctionSignature_FinalArgNormal_default_instance_); -} -inline const ::substrait::FunctionSignature_FinalArgNormal& FunctionSignature_Window::normal() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.normal) - return _internal_normal(); -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::unsafe_arena_release_normal() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Window.normal) - if (_internal_has_normal()) { - clear_has_final_variable_behavior(); - ::substrait::FunctionSignature_FinalArgNormal* temp = final_variable_behavior_.normal_; - final_variable_behavior_.normal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FunctionSignature_Window::unsafe_arena_set_allocated_normal(::substrait::FunctionSignature_FinalArgNormal* normal) { - clear_final_variable_behavior(); - if (normal) { - set_has_normal(); - final_variable_behavior_.normal_ = normal; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Window.normal) -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::_internal_mutable_normal() { - if (!_internal_has_normal()) { - clear_final_variable_behavior(); - set_has_normal(); - final_variable_behavior_.normal_ = CreateMaybeMessage< ::substrait::FunctionSignature_FinalArgNormal >(GetArenaForAllocation()); - } - return final_variable_behavior_.normal_; -} -inline ::substrait::FunctionSignature_FinalArgNormal* FunctionSignature_Window::mutable_normal() { - ::substrait::FunctionSignature_FinalArgNormal* _msg = _internal_mutable_normal(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.normal) - return _msg; -} - -// bool ordered = 11; -inline void FunctionSignature_Window::clear_ordered() { - ordered_ = false; -} -inline bool FunctionSignature_Window::_internal_ordered() const { - return ordered_; -} -inline bool FunctionSignature_Window::ordered() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.ordered) - return _internal_ordered(); -} -inline void FunctionSignature_Window::_internal_set_ordered(bool value) { - - ordered_ = value; -} -inline void FunctionSignature_Window::set_ordered(bool value) { - _internal_set_ordered(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.ordered) -} - -// uint64 max_set = 12; -inline void FunctionSignature_Window::clear_max_set() { - max_set_ = uint64_t{0u}; -} -inline uint64_t FunctionSignature_Window::_internal_max_set() const { - return max_set_; -} -inline uint64_t FunctionSignature_Window::max_set() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.max_set) - return _internal_max_set(); -} -inline void FunctionSignature_Window::_internal_set_max_set(uint64_t value) { - - max_set_ = value; -} -inline void FunctionSignature_Window::set_max_set(uint64_t value) { - _internal_set_max_set(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.max_set) -} - -// .substrait.FunctionSignature.Window.WindowType window_type = 14; -inline void FunctionSignature_Window::clear_window_type() { - window_type_ = 0; -} -inline ::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::_internal_window_type() const { - return static_cast< ::substrait::FunctionSignature_Window_WindowType >(window_type_); -} -inline ::substrait::FunctionSignature_Window_WindowType FunctionSignature_Window::window_type() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.window_type) - return _internal_window_type(); -} -inline void FunctionSignature_Window::_internal_set_window_type(::substrait::FunctionSignature_Window_WindowType value) { - - window_type_ = value; -} -inline void FunctionSignature_Window::set_window_type(::substrait::FunctionSignature_Window_WindowType value) { - _internal_set_window_type(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Window.window_type) -} - -// repeated .substrait.FunctionSignature.Implementation implementations = 15; -inline int FunctionSignature_Window::_internal_implementations_size() const { - return implementations_.size(); -} -inline int FunctionSignature_Window::implementations_size() const { - return _internal_implementations_size(); -} -inline void FunctionSignature_Window::clear_implementations() { - implementations_.Clear(); -} -inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::mutable_implementations(int index) { - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Window.implementations) - return implementations_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >* -FunctionSignature_Window::mutable_implementations() { - // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Window.implementations) - return &implementations_; -} -inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Window::_internal_implementations(int index) const { - return implementations_.Get(index); -} -inline const ::substrait::FunctionSignature_Implementation& FunctionSignature_Window::implementations(int index) const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Window.implementations) - return _internal_implementations(index); -} -inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::_internal_add_implementations() { - return implementations_.Add(); -} -inline ::substrait::FunctionSignature_Implementation* FunctionSignature_Window::add_implementations() { - ::substrait::FunctionSignature_Implementation* _add = _internal_add_implementations(); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Window.implementations) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::FunctionSignature_Implementation >& -FunctionSignature_Window::implementations() const { - // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Window.implementations) - return implementations_; -} - -inline bool FunctionSignature_Window::has_final_variable_behavior() const { - return final_variable_behavior_case() != FINAL_VARIABLE_BEHAVIOR_NOT_SET; -} -inline void FunctionSignature_Window::clear_has_final_variable_behavior() { - _oneof_case_[0] = FINAL_VARIABLE_BEHAVIOR_NOT_SET; -} -inline FunctionSignature_Window::FinalVariableBehaviorCase FunctionSignature_Window::final_variable_behavior_case() const { - return FunctionSignature_Window::FinalVariableBehaviorCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// FunctionSignature_Description - -// string language = 1; -inline void FunctionSignature_Description::clear_language() { - language_.ClearToEmpty(); -} -inline const std::string& FunctionSignature_Description::language() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Description.language) - return _internal_language(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void FunctionSignature_Description::set_language(ArgT0&& arg0, ArgT... args) { - - language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Description.language) -} -inline std::string* FunctionSignature_Description::mutable_language() { - std::string* _s = _internal_mutable_language(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Description.language) - return _s; -} -inline const std::string& FunctionSignature_Description::_internal_language() const { - return language_.Get(); -} -inline void FunctionSignature_Description::_internal_set_language(const std::string& value) { - - language_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* FunctionSignature_Description::_internal_mutable_language() { - - return language_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* FunctionSignature_Description::release_language() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Description.language) - return language_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void FunctionSignature_Description::set_allocated_language(std::string* language) { - if (language != nullptr) { - - } else { - - } - language_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), language, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (language_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - language_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Description.language) -} - -// string body = 2; -inline void FunctionSignature_Description::clear_body() { - body_.ClearToEmpty(); -} -inline const std::string& FunctionSignature_Description::body() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Description.body) - return _internal_body(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void FunctionSignature_Description::set_body(ArgT0&& arg0, ArgT... args) { - - body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Description.body) -} -inline std::string* FunctionSignature_Description::mutable_body() { - std::string* _s = _internal_mutable_body(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Description.body) - return _s; -} -inline const std::string& FunctionSignature_Description::_internal_body() const { - return body_.Get(); -} -inline void FunctionSignature_Description::_internal_set_body(const std::string& value) { - - body_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* FunctionSignature_Description::_internal_mutable_body() { - - return body_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* FunctionSignature_Description::release_body() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Description.body) - return body_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void FunctionSignature_Description::set_allocated_body(std::string* body) { - if (body != nullptr) { - - } else { - - } - body_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), body, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (body_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - body_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Description.body) -} - -// ------------------------------------------------------------------- - -// FunctionSignature_Implementation - -// .substrait.FunctionSignature.Implementation.Type type = 1; -inline void FunctionSignature_Implementation::clear_type() { - type_ = 0; -} -inline ::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::_internal_type() const { - return static_cast< ::substrait::FunctionSignature_Implementation_Type >(type_); -} -inline ::substrait::FunctionSignature_Implementation_Type FunctionSignature_Implementation::type() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Implementation.type) - return _internal_type(); -} -inline void FunctionSignature_Implementation::_internal_set_type(::substrait::FunctionSignature_Implementation_Type value) { - - type_ = value; -} -inline void FunctionSignature_Implementation::set_type(::substrait::FunctionSignature_Implementation_Type value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Implementation.type) -} - -// string uri = 2; -inline void FunctionSignature_Implementation::clear_uri() { - uri_.ClearToEmpty(); -} -inline const std::string& FunctionSignature_Implementation::uri() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Implementation.uri) - return _internal_uri(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void FunctionSignature_Implementation::set_uri(ArgT0&& arg0, ArgT... args) { - - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Implementation.uri) -} -inline std::string* FunctionSignature_Implementation::mutable_uri() { - std::string* _s = _internal_mutable_uri(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Implementation.uri) - return _s; -} -inline const std::string& FunctionSignature_Implementation::_internal_uri() const { - return uri_.Get(); -} -inline void FunctionSignature_Implementation::_internal_set_uri(const std::string& value) { - - uri_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* FunctionSignature_Implementation::_internal_mutable_uri() { - - return uri_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* FunctionSignature_Implementation::release_uri() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Implementation.uri) - return uri_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void FunctionSignature_Implementation::set_allocated_uri(std::string* uri) { - if (uri != nullptr) { - - } else { - - } - uri_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uri, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (uri_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - uri_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Implementation.uri) -} - -// ------------------------------------------------------------------- - -// FunctionSignature_Argument_ValueArgument - -// .substrait.ParameterizedType type = 1; -inline bool FunctionSignature_Argument_ValueArgument::_internal_has_type() const { - return this != internal_default_instance() && type_ != nullptr; -} -inline bool FunctionSignature_Argument_ValueArgument::has_type() const { - return _internal_has_type(); -} -inline const ::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::_internal_type() const { - const ::substrait::ParameterizedType* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_default_instance_); -} -inline const ::substrait::ParameterizedType& FunctionSignature_Argument_ValueArgument::type() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.ValueArgument.type) - return _internal_type(); -} -inline void FunctionSignature_Argument_ValueArgument::unsafe_arena_set_allocated_type( - ::substrait::ParameterizedType* type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); - } - type_ = type; - if (type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.ValueArgument.type) -} -inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::release_type() { - - ::substrait::ParameterizedType* temp = type_; - type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.ValueArgument.type) - - ::substrait::ParameterizedType* temp = type_; - type_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::_internal_mutable_type() { - - if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation()); - type_ = p; - } - return type_; -} -inline ::substrait::ParameterizedType* FunctionSignature_Argument_ValueArgument::mutable_type() { - ::substrait::ParameterizedType* _msg = _internal_mutable_type(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.ValueArgument.type) - return _msg; -} -inline void FunctionSignature_Argument_ValueArgument::set_allocated_type(::substrait::ParameterizedType* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); - } - if (type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)); - if (message_arena != submessage_arena) { - type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type, submessage_arena); - } - - } else { - - } - type_ = type; - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.ValueArgument.type) -} - -// bool constant = 2; -inline void FunctionSignature_Argument_ValueArgument::clear_constant() { - constant_ = false; -} -inline bool FunctionSignature_Argument_ValueArgument::_internal_constant() const { - return constant_; -} -inline bool FunctionSignature_Argument_ValueArgument::constant() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.ValueArgument.constant) - return _internal_constant(); -} -inline void FunctionSignature_Argument_ValueArgument::_internal_set_constant(bool value) { - - constant_ = value; -} -inline void FunctionSignature_Argument_ValueArgument::set_constant(bool value) { - _internal_set_constant(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.ValueArgument.constant) -} - -// ------------------------------------------------------------------- - -// FunctionSignature_Argument_TypeArgument - -// .substrait.ParameterizedType type = 1; -inline bool FunctionSignature_Argument_TypeArgument::_internal_has_type() const { - return this != internal_default_instance() && type_ != nullptr; -} -inline bool FunctionSignature_Argument_TypeArgument::has_type() const { - return _internal_has_type(); -} -inline const ::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::_internal_type() const { - const ::substrait::ParameterizedType* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_default_instance_); -} -inline const ::substrait::ParameterizedType& FunctionSignature_Argument_TypeArgument::type() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.TypeArgument.type) - return _internal_type(); -} -inline void FunctionSignature_Argument_TypeArgument::unsafe_arena_set_allocated_type( - ::substrait::ParameterizedType* type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); - } - type_ = type; - if (type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.TypeArgument.type) -} -inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::release_type() { - - ::substrait::ParameterizedType* temp = type_; - type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.TypeArgument.type) - - ::substrait::ParameterizedType* temp = type_; - type_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::_internal_mutable_type() { - - if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation()); - type_ = p; - } - return type_; -} -inline ::substrait::ParameterizedType* FunctionSignature_Argument_TypeArgument::mutable_type() { - ::substrait::ParameterizedType* _msg = _internal_mutable_type(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.TypeArgument.type) - return _msg; -} -inline void FunctionSignature_Argument_TypeArgument::set_allocated_type(::substrait::ParameterizedType* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); - } - if (type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type)); - if (message_arena != submessage_arena) { - type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type, submessage_arena); - } - - } else { - - } - type_ = type; - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.TypeArgument.type) -} - -// ------------------------------------------------------------------- - -// FunctionSignature_Argument_EnumArgument - -// repeated string options = 1; -inline int FunctionSignature_Argument_EnumArgument::_internal_options_size() const { - return options_.size(); -} -inline int FunctionSignature_Argument_EnumArgument::options_size() const { - return _internal_options_size(); -} -inline void FunctionSignature_Argument_EnumArgument::clear_options() { - options_.Clear(); -} -inline std::string* FunctionSignature_Argument_EnumArgument::add_options() { - std::string* _s = _internal_add_options(); - // @@protoc_insertion_point(field_add_mutable:substrait.FunctionSignature.Argument.EnumArgument.options) - return _s; -} -inline const std::string& FunctionSignature_Argument_EnumArgument::_internal_options(int index) const { - return options_.Get(index); -} -inline const std::string& FunctionSignature_Argument_EnumArgument::options(int index) const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.EnumArgument.options) - return _internal_options(index); -} -inline std::string* FunctionSignature_Argument_EnumArgument::mutable_options(int index) { - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.EnumArgument.options) - return options_.Mutable(index); -} -inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const std::string& value) { - options_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options) -} -inline void FunctionSignature_Argument_EnumArgument::set_options(int index, std::string&& value) { - options_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.options) -} -inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - options_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.FunctionSignature.Argument.EnumArgument.options) -} -inline void FunctionSignature_Argument_EnumArgument::set_options(int index, const char* value, size_t size) { - options_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.FunctionSignature.Argument.EnumArgument.options) -} -inline std::string* FunctionSignature_Argument_EnumArgument::_internal_add_options() { - return options_.Add(); -} -inline void FunctionSignature_Argument_EnumArgument::add_options(const std::string& value) { - options_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Argument.EnumArgument.options) -} -inline void FunctionSignature_Argument_EnumArgument::add_options(std::string&& value) { - options_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.FunctionSignature.Argument.EnumArgument.options) -} -inline void FunctionSignature_Argument_EnumArgument::add_options(const char* value) { - GOOGLE_DCHECK(value != nullptr); - options_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.FunctionSignature.Argument.EnumArgument.options) -} -inline void FunctionSignature_Argument_EnumArgument::add_options(const char* value, size_t size) { - options_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.FunctionSignature.Argument.EnumArgument.options) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -FunctionSignature_Argument_EnumArgument::options() const { - // @@protoc_insertion_point(field_list:substrait.FunctionSignature.Argument.EnumArgument.options) - return options_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -FunctionSignature_Argument_EnumArgument::mutable_options() { - // @@protoc_insertion_point(field_mutable_list:substrait.FunctionSignature.Argument.EnumArgument.options) - return &options_; -} - -// bool optional = 2; -inline void FunctionSignature_Argument_EnumArgument::clear_optional() { - optional_ = false; -} -inline bool FunctionSignature_Argument_EnumArgument::_internal_optional() const { - return optional_; -} -inline bool FunctionSignature_Argument_EnumArgument::optional() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.EnumArgument.optional) - return _internal_optional(); -} -inline void FunctionSignature_Argument_EnumArgument::_internal_set_optional(bool value) { - - optional_ = value; -} -inline void FunctionSignature_Argument_EnumArgument::set_optional(bool value) { - _internal_set_optional(value); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.EnumArgument.optional) -} - -// ------------------------------------------------------------------- - -// FunctionSignature_Argument - -// string name = 1; -inline void FunctionSignature_Argument::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& FunctionSignature_Argument::name() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void FunctionSignature_Argument::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.FunctionSignature.Argument.name) -} -inline std::string* FunctionSignature_Argument::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.name) - return _s; -} -inline const std::string& FunctionSignature_Argument::_internal_name() const { - return name_.Get(); -} -inline void FunctionSignature_Argument::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* FunctionSignature_Argument::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* FunctionSignature_Argument::release_name() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void FunctionSignature_Argument::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.FunctionSignature.Argument.name) -} - -// .substrait.FunctionSignature.Argument.ValueArgument value = 2; -inline bool FunctionSignature_Argument::_internal_has_value() const { - return argument_kind_case() == kValue; -} -inline bool FunctionSignature_Argument::has_value() const { - return _internal_has_value(); -} -inline void FunctionSignature_Argument::set_has_value() { - _oneof_case_[0] = kValue; -} -inline void FunctionSignature_Argument::clear_value() { - if (_internal_has_value()) { - if (GetArenaForAllocation() == nullptr) { - delete argument_kind_.value_; - } - clear_has_argument_kind(); - } -} -inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::release_value() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.value) - if (_internal_has_value()) { - clear_has_argument_kind(); - ::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - argument_kind_.value_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::_internal_value() const { - return _internal_has_value() - ? *argument_kind_.value_ - : reinterpret_cast< ::substrait::FunctionSignature_Argument_ValueArgument&>(::substrait::_FunctionSignature_Argument_ValueArgument_default_instance_); -} -inline const ::substrait::FunctionSignature_Argument_ValueArgument& FunctionSignature_Argument::value() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.value) - return _internal_value(); -} -inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.value) - if (_internal_has_value()) { - clear_has_argument_kind(); - ::substrait::FunctionSignature_Argument_ValueArgument* temp = argument_kind_.value_; - argument_kind_.value_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FunctionSignature_Argument::unsafe_arena_set_allocated_value(::substrait::FunctionSignature_Argument_ValueArgument* value) { - clear_argument_kind(); - if (value) { - set_has_value(); - argument_kind_.value_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.value) -} -inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::_internal_mutable_value() { - if (!_internal_has_value()) { - clear_argument_kind(); - set_has_value(); - argument_kind_.value_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_ValueArgument >(GetArenaForAllocation()); - } - return argument_kind_.value_; -} -inline ::substrait::FunctionSignature_Argument_ValueArgument* FunctionSignature_Argument::mutable_value() { - ::substrait::FunctionSignature_Argument_ValueArgument* _msg = _internal_mutable_value(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.value) - return _msg; -} - -// .substrait.FunctionSignature.Argument.TypeArgument type = 3; -inline bool FunctionSignature_Argument::_internal_has_type() const { - return argument_kind_case() == kType; -} -inline bool FunctionSignature_Argument::has_type() const { - return _internal_has_type(); -} -inline void FunctionSignature_Argument::set_has_type() { - _oneof_case_[0] = kType; -} -inline void FunctionSignature_Argument::clear_type() { - if (_internal_has_type()) { - if (GetArenaForAllocation() == nullptr) { - delete argument_kind_.type_; - } - clear_has_argument_kind(); - } -} -inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::release_type() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.type) - if (_internal_has_type()) { - clear_has_argument_kind(); - ::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - argument_kind_.type_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::_internal_type() const { - return _internal_has_type() - ? *argument_kind_.type_ - : reinterpret_cast< ::substrait::FunctionSignature_Argument_TypeArgument&>(::substrait::_FunctionSignature_Argument_TypeArgument_default_instance_); -} -inline const ::substrait::FunctionSignature_Argument_TypeArgument& FunctionSignature_Argument::type() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.type) - return _internal_type(); -} -inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.type) - if (_internal_has_type()) { - clear_has_argument_kind(); - ::substrait::FunctionSignature_Argument_TypeArgument* temp = argument_kind_.type_; - argument_kind_.type_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FunctionSignature_Argument::unsafe_arena_set_allocated_type(::substrait::FunctionSignature_Argument_TypeArgument* type) { - clear_argument_kind(); - if (type) { - set_has_type(); - argument_kind_.type_ = type; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.type) -} -inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::_internal_mutable_type() { - if (!_internal_has_type()) { - clear_argument_kind(); - set_has_type(); - argument_kind_.type_ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_TypeArgument >(GetArenaForAllocation()); - } - return argument_kind_.type_; -} -inline ::substrait::FunctionSignature_Argument_TypeArgument* FunctionSignature_Argument::mutable_type() { - ::substrait::FunctionSignature_Argument_TypeArgument* _msg = _internal_mutable_type(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.type) - return _msg; -} - -// .substrait.FunctionSignature.Argument.EnumArgument enum = 4; -inline bool FunctionSignature_Argument::_internal_has_enum_() const { - return argument_kind_case() == kEnum; -} -inline bool FunctionSignature_Argument::has_enum_() const { - return _internal_has_enum_(); -} -inline void FunctionSignature_Argument::set_has_enum_() { - _oneof_case_[0] = kEnum; -} -inline void FunctionSignature_Argument::clear_enum_() { - if (_internal_has_enum_()) { - if (GetArenaForAllocation() == nullptr) { - delete argument_kind_.enum__; - } - clear_has_argument_kind(); - } -} -inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::release_enum_() { - // @@protoc_insertion_point(field_release:substrait.FunctionSignature.Argument.enum) - if (_internal_has_enum_()) { - clear_has_argument_kind(); - ::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - argument_kind_.enum__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::_internal_enum_() const { - return _internal_has_enum_() - ? *argument_kind_.enum__ - : reinterpret_cast< ::substrait::FunctionSignature_Argument_EnumArgument&>(::substrait::_FunctionSignature_Argument_EnumArgument_default_instance_); -} -inline const ::substrait::FunctionSignature_Argument_EnumArgument& FunctionSignature_Argument::enum_() const { - // @@protoc_insertion_point(field_get:substrait.FunctionSignature.Argument.enum) - return _internal_enum_(); -} -inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::unsafe_arena_release_enum_() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.FunctionSignature.Argument.enum) - if (_internal_has_enum_()) { - clear_has_argument_kind(); - ::substrait::FunctionSignature_Argument_EnumArgument* temp = argument_kind_.enum__; - argument_kind_.enum__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void FunctionSignature_Argument::unsafe_arena_set_allocated_enum_(::substrait::FunctionSignature_Argument_EnumArgument* enum_) { - clear_argument_kind(); - if (enum_) { - set_has_enum_(); - argument_kind_.enum__ = enum_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FunctionSignature.Argument.enum) -} -inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::_internal_mutable_enum_() { - if (!_internal_has_enum_()) { - clear_argument_kind(); - set_has_enum_(); - argument_kind_.enum__ = CreateMaybeMessage< ::substrait::FunctionSignature_Argument_EnumArgument >(GetArenaForAllocation()); - } - return argument_kind_.enum__; -} -inline ::substrait::FunctionSignature_Argument_EnumArgument* FunctionSignature_Argument::mutable_enum_() { - ::substrait::FunctionSignature_Argument_EnumArgument* _msg = _internal_mutable_enum_(); - // @@protoc_insertion_point(field_mutable:substrait.FunctionSignature.Argument.enum) - return _msg; -} - -inline bool FunctionSignature_Argument::has_argument_kind() const { - return argument_kind_case() != ARGUMENT_KIND_NOT_SET; -} -inline void FunctionSignature_Argument::clear_has_argument_kind() { - _oneof_case_[0] = ARGUMENT_KIND_NOT_SET; -} -inline FunctionSignature_Argument::ArgumentKindCase FunctionSignature_Argument::argument_kind_case() const { - return FunctionSignature_Argument::ArgumentKindCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// FunctionSignature - -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace substrait - -PROTOBUF_NAMESPACE_OPEN - -template <> struct is_proto_enum< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency>() { - return ::substrait::FunctionSignature_FinalArgVariadic_ParameterConsistency_descriptor(); -} -template <> struct is_proto_enum< ::substrait::FunctionSignature_Window_WindowType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_Window_WindowType>() { - return ::substrait::FunctionSignature_Window_WindowType_descriptor(); -} -template <> struct is_proto_enum< ::substrait::FunctionSignature_Implementation_Type> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::FunctionSignature_Implementation_Type>() { - return ::substrait::FunctionSignature_Implementation_Type_descriptor(); -} - -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ffunction_2eproto diff --git a/cpp/src/generated/substrait/parameterized_types.pb.cc b/cpp/src/generated/substrait/parameterized_types.pb.cc deleted file mode 100644 index a37885aca41..00000000000 --- a/cpp/src/generated/substrait/parameterized_types.pb.cc +++ /dev/null @@ -1,5353 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/parameterized_types.proto - -#include "substrait/parameterized_types.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace substrait { -constexpr ParameterizedType_TypeParameter::ParameterizedType_TypeParameter( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : bounds_() - , name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){} -struct ParameterizedType_TypeParameterDefaultTypeInternal { - constexpr ParameterizedType_TypeParameterDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_TypeParameterDefaultTypeInternal() {} - union { - ParameterizedType_TypeParameter _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_TypeParameterDefaultTypeInternal _ParameterizedType_TypeParameter_default_instance_; -constexpr ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , range_start_inclusive_(nullptr) - , range_end_exclusive_(nullptr){} -struct ParameterizedType_IntegerParameterDefaultTypeInternal { - constexpr ParameterizedType_IntegerParameterDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_IntegerParameterDefaultTypeInternal() {} - union { - ParameterizedType_IntegerParameter _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_IntegerParameterDefaultTypeInternal _ParameterizedType_IntegerParameter_default_instance_; -constexpr ParameterizedType_NullableInteger::ParameterizedType_NullableInteger( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : value_(int64_t{0}){} -struct ParameterizedType_NullableIntegerDefaultTypeInternal { - constexpr ParameterizedType_NullableIntegerDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_NullableIntegerDefaultTypeInternal() {} - union { - ParameterizedType_NullableInteger _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_NullableIntegerDefaultTypeInternal _ParameterizedType_NullableInteger_default_instance_; -constexpr ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : length_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct ParameterizedType_ParameterizedFixedCharDefaultTypeInternal { - constexpr ParameterizedType_ParameterizedFixedCharDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_ParameterizedFixedCharDefaultTypeInternal() {} - union { - ParameterizedType_ParameterizedFixedChar _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedFixedCharDefaultTypeInternal _ParameterizedType_ParameterizedFixedChar_default_instance_; -constexpr ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : length_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct ParameterizedType_ParameterizedVarCharDefaultTypeInternal { - constexpr ParameterizedType_ParameterizedVarCharDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_ParameterizedVarCharDefaultTypeInternal() {} - union { - ParameterizedType_ParameterizedVarChar _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedVarCharDefaultTypeInternal _ParameterizedType_ParameterizedVarChar_default_instance_; -constexpr ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : length_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal { - constexpr ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal() {} - union { - ParameterizedType_ParameterizedFixedBinary _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal _ParameterizedType_ParameterizedFixedBinary_default_instance_; -constexpr ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : scale_(nullptr) - , precision_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct ParameterizedType_ParameterizedDecimalDefaultTypeInternal { - constexpr ParameterizedType_ParameterizedDecimalDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_ParameterizedDecimalDefaultTypeInternal() {} - union { - ParameterizedType_ParameterizedDecimal _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedDecimalDefaultTypeInternal _ParameterizedType_ParameterizedDecimal_default_instance_; -constexpr ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : types_() - , variation_pointer_(0u) - , nullability_(0) -{} -struct ParameterizedType_ParameterizedStructDefaultTypeInternal { - constexpr ParameterizedType_ParameterizedStructDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_ParameterizedStructDefaultTypeInternal() {} - union { - ParameterizedType_ParameterizedStruct _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedStructDefaultTypeInternal _ParameterizedType_ParameterizedStruct_default_instance_; -constexpr ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : names_() - , struct__(nullptr){} -struct ParameterizedType_ParameterizedNamedStructDefaultTypeInternal { - constexpr ParameterizedType_ParameterizedNamedStructDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_ParameterizedNamedStructDefaultTypeInternal() {} - union { - ParameterizedType_ParameterizedNamedStruct _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedNamedStructDefaultTypeInternal _ParameterizedType_ParameterizedNamedStruct_default_instance_; -constexpr ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct ParameterizedType_ParameterizedListDefaultTypeInternal { - constexpr ParameterizedType_ParameterizedListDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_ParameterizedListDefaultTypeInternal() {} - union { - ParameterizedType_ParameterizedList _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedListDefaultTypeInternal _ParameterizedType_ParameterizedList_default_instance_; -constexpr ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : key_(nullptr) - , value_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct ParameterizedType_ParameterizedMapDefaultTypeInternal { - constexpr ParameterizedType_ParameterizedMapDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_ParameterizedMapDefaultTypeInternal() {} - union { - ParameterizedType_ParameterizedMap _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_ParameterizedMapDefaultTypeInternal _ParameterizedType_ParameterizedMap_default_instance_; -constexpr ParameterizedType_IntegerOption::ParameterizedType_IntegerOption( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct ParameterizedType_IntegerOptionDefaultTypeInternal { - constexpr ParameterizedType_IntegerOptionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedType_IntegerOptionDefaultTypeInternal() {} - union { - ParameterizedType_IntegerOption _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedType_IntegerOptionDefaultTypeInternal _ParameterizedType_IntegerOption_default_instance_; -constexpr ParameterizedType::ParameterizedType( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct ParameterizedTypeDefaultTypeInternal { - constexpr ParameterizedTypeDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ParameterizedTypeDefaultTypeInternal() {} - union { - ParameterizedType _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ParameterizedTypeDefaultTypeInternal _ParameterizedType_default_instance_; -} // namespace substrait -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[13]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fparameterized_5ftypes_2eproto = nullptr; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fparameterized_5ftypes_2eproto = nullptr; - -const uint32_t TableStruct_substrait_2fparameterized_5ftypes_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, name_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_TypeParameter, bounds_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, name_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, range_start_inclusive_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerParameter, range_end_exclusive_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_NullableInteger, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_NullableInteger, value_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, length_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedChar, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, length_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedVarChar, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, length_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedFixedBinary, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, scale_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, precision_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedDecimal, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, types_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedStruct, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, names_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedNamedStruct, struct__), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, type_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedList, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, key_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, value_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_ParameterizedMap, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType_IntegerOption, integer_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::ParameterizedType, kind_), -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, -1, sizeof(::substrait::ParameterizedType_TypeParameter)}, - { 8, -1, -1, sizeof(::substrait::ParameterizedType_IntegerParameter)}, - { 17, -1, -1, sizeof(::substrait::ParameterizedType_NullableInteger)}, - { 24, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedFixedChar)}, - { 33, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedVarChar)}, - { 42, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedFixedBinary)}, - { 51, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedDecimal)}, - { 61, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedStruct)}, - { 70, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedNamedStruct)}, - { 78, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedList)}, - { 87, -1, -1, sizeof(::substrait::ParameterizedType_ParameterizedMap)}, - { 97, -1, -1, sizeof(::substrait::ParameterizedType_IntegerOption)}, - { 106, -1, -1, sizeof(::substrait::ParameterizedType)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::substrait::_ParameterizedType_TypeParameter_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_IntegerParameter_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_NullableInteger_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedStruct_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedNamedStruct_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedList_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_ParameterizedMap_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_IntegerOption_default_instance_), - reinterpret_cast(&::substrait::_ParameterizedType_default_instance_), -}; - -const char descriptor_table_protodef_substrait_2fparameterized_5ftypes_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n#substrait/parameterized_types.proto\022\ts" - "ubstrait\032\024substrait/type.proto\"\271\027\n\021Param" - "eterizedType\022\'\n\004bool\030\001 \001(\0132\027.substrait.T" - "ype.BooleanH\000\022 \n\002i8\030\002 \001(\0132\022.substrait.Ty" - "pe.I8H\000\022\"\n\003i16\030\003 \001(\0132\023.substrait.Type.I1" - "6H\000\022\"\n\003i32\030\005 \001(\0132\023.substrait.Type.I32H\000\022" - "\"\n\003i64\030\007 \001(\0132\023.substrait.Type.I64H\000\022$\n\004f" - "p32\030\n \001(\0132\024.substrait.Type.FP32H\000\022$\n\004fp6" - "4\030\013 \001(\0132\024.substrait.Type.FP64H\000\022(\n\006strin" - "g\030\014 \001(\0132\026.substrait.Type.StringH\000\022(\n\006bin" - "ary\030\r \001(\0132\026.substrait.Type.BinaryH\000\022.\n\tt" - "imestamp\030\016 \001(\0132\031.substrait.Type.Timestam" - "pH\000\022$\n\004date\030\020 \001(\0132\024.substrait.Type.DateH" - "\000\022$\n\004time\030\021 \001(\0132\024.substrait.Type.TimeH\000\022" - "5\n\rinterval_year\030\023 \001(\0132\034.substrait.Type." - "IntervalYearH\000\0223\n\014interval_day\030\024 \001(\0132\033.s" - "ubstrait.Type.IntervalDayH\000\0223\n\014timestamp" - "_tz\030\035 \001(\0132\033.substrait.Type.TimestampTZH\000" - "\022$\n\004uuid\030 \001(\0132\024.substrait.Type.UUIDH\000\022I" - "\n\nfixed_char\030\025 \001(\01323.substrait.Parameter" - "izedType.ParameterizedFixedCharH\000\022D\n\007var" - "char\030\026 \001(\01321.substrait.ParameterizedType" - ".ParameterizedVarCharH\000\022M\n\014fixed_binary\030" - "\027 \001(\01325.substrait.ParameterizedType.Para" - "meterizedFixedBinaryH\000\022D\n\007decimal\030\030 \001(\0132" - "1.substrait.ParameterizedType.Parameteri" - "zedDecimalH\000\022B\n\006struct\030\031 \001(\01320.substrait" - ".ParameterizedType.ParameterizedStructH\000" - "\022>\n\004list\030\033 \001(\0132..substrait.Parameterized" - "Type.ParameterizedListH\000\022<\n\003map\030\034 \001(\0132-." - "substrait.ParameterizedType.Parameterize" - "dMapH\000\022\036\n\024user_defined_pointer\030\037 \001(\rH\000\022D" - "\n\016type_parameter\030! \001(\0132*.substrait.Param" - "eterizedType.TypeParameterH\000\032K\n\rTypePara" - "meter\022\014\n\004name\030\001 \001(\t\022,\n\006bounds\030\002 \003(\0132\034.su" - "bstrait.ParameterizedType\032\270\001\n\020IntegerPar" - "ameter\022\014\n\004name\030\001 \001(\t\022K\n\025range_start_incl" - "usive\030\002 \001(\0132,.substrait.ParameterizedTyp" - "e.NullableInteger\022I\n\023range_end_exclusive" - "\030\003 \001(\0132,.substrait.ParameterizedType.Nul" - "lableInteger\032 \n\017NullableInteger\022\r\n\005value" - "\030\001 \001(\003\032\241\001\n\026ParameterizedFixedChar\022:\n\006len" - "gth\030\001 \001(\0132*.substrait.ParameterizedType." - "IntegerOption\022\031\n\021variation_pointer\030\002 \001(\r" - "\0220\n\013nullability\030\003 \001(\0162\033.substrait.Type.N" - "ullability\032\237\001\n\024ParameterizedVarChar\022:\n\006l" - "ength\030\001 \001(\0132*.substrait.ParameterizedTyp" - "e.IntegerOption\022\031\n\021variation_pointer\030\002 \001" - "(\r\0220\n\013nullability\030\003 \001(\0162\033.substrait.Type" - ".Nullability\032\243\001\n\030ParameterizedFixedBinar" - "y\022:\n\006length\030\001 \001(\0132*.substrait.Parameteri" - "zedType.IntegerOption\022\031\n\021variation_point" - "er\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrai" - "t.Type.Nullability\032\335\001\n\024ParameterizedDeci" - "mal\0229\n\005scale\030\001 \001(\0132*.substrait.Parameter" - "izedType.IntegerOption\022=\n\tprecision\030\002 \001(" - "\0132*.substrait.ParameterizedType.IntegerO" - "ption\022\031\n\021variation_pointer\030\003 \001(\r\0220\n\013null" - "ability\030\004 \001(\0162\033.substrait.Type.Nullabili" - "ty\032\217\001\n\023ParameterizedStruct\022+\n\005types\030\001 \003(" - "\0132\034.substrait.ParameterizedType\022\031\n\021varia" - "tion_pointer\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162" - "\033.substrait.Type.Nullability\032k\n\030Paramete" - "rizedNamedStruct\022\r\n\005names\030\001 \003(\t\022@\n\006struc" - "t\030\002 \001(\01320.substrait.ParameterizedType.Pa" - "rameterizedStruct\032\214\001\n\021ParameterizedList\022" - "*\n\004type\030\001 \001(\0132\034.substrait.ParameterizedT" - "ype\022\031\n\021variation_pointer\030\002 \001(\r\0220\n\013nullab" - "ility\030\003 \001(\0162\033.substrait.Type.Nullability" - "\032\267\001\n\020ParameterizedMap\022)\n\003key\030\001 \001(\0132\034.sub" - "strait.ParameterizedType\022+\n\005value\030\002 \001(\0132" - "\034.substrait.ParameterizedType\022\031\n\021variati" - "on_pointer\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033." - "substrait.Type.Nullability\032v\n\rIntegerOpt" - "ion\022\021\n\007literal\030\001 \001(\005H\000\022B\n\tparameter\030\002 \001(" - "\0132-.substrait.ParameterizedType.IntegerP" - "arameterH\000B\016\n\014integer_typeB\006\n\004kindB+\n\022io" - ".substrait.protoP\001\252\002\022Substrait.Protobufb" - "\006proto3" - ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fparameterized_5ftypes_2eproto_deps[1] = { - &::descriptor_table_substrait_2ftype_2eproto, -}; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fparameterized_5ftypes_2eproto = { - false, false, 3127, descriptor_table_protodef_substrait_2fparameterized_5ftypes_2eproto, "substrait/parameterized_types.proto", - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, descriptor_table_substrait_2fparameterized_5ftypes_2eproto_deps, 1, 13, - schemas, file_default_instances, TableStruct_substrait_2fparameterized_5ftypes_2eproto::offsets, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto, file_level_enum_descriptors_substrait_2fparameterized_5ftypes_2eproto, file_level_service_descriptors_substrait_2fparameterized_5ftypes_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter() { - return &descriptor_table_substrait_2fparameterized_5ftypes_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fparameterized_5ftypes_2eproto(&descriptor_table_substrait_2fparameterized_5ftypes_2eproto); -namespace substrait { - -// =================================================================== - -class ParameterizedType_TypeParameter::_Internal { - public: -}; - -ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - bounds_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.TypeParameter) -} -ParameterizedType_TypeParameter::ParameterizedType_TypeParameter(const ParameterizedType_TypeParameter& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - bounds_(from.bounds_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArenaForAllocation()); - } - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.TypeParameter) -} - -inline void ParameterizedType_TypeParameter::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -} - -ParameterizedType_TypeParameter::~ParameterizedType_TypeParameter() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.TypeParameter) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_TypeParameter::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -} - -void ParameterizedType_TypeParameter::ArenaDtor(void* object) { - ParameterizedType_TypeParameter* _this = reinterpret_cast< ParameterizedType_TypeParameter* >(object); - (void)_this; -} -void ParameterizedType_TypeParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_TypeParameter::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_TypeParameter::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.TypeParameter) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - bounds_.Clear(); - name_.ClearToEmpty(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_TypeParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.TypeParameter.name")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.ParameterizedType bounds = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_bounds(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* ParameterizedType_TypeParameter::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.TypeParameter) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string name = 1; - if (!this->_internal_name().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.ParameterizedType.TypeParameter.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - // repeated .substrait.ParameterizedType bounds = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_bounds_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_bounds(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.TypeParameter) - return target; -} - -size_t ParameterizedType_TypeParameter::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.TypeParameter) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.ParameterizedType bounds = 2; - total_size += 1UL * this->_internal_bounds_size(); - for (const auto& msg : this->bounds_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // string name = 1; - if (!this->_internal_name().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_TypeParameter::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_TypeParameter::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_TypeParameter::GetClassData() const { return &_class_data_; } - -void ParameterizedType_TypeParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_TypeParameter::MergeFrom(const ParameterizedType_TypeParameter& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.TypeParameter) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - bounds_.MergeFrom(from.bounds_); - if (!from._internal_name().empty()) { - _internal_set_name(from._internal_name()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_TypeParameter::CopyFrom(const ParameterizedType_TypeParameter& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.TypeParameter) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_TypeParameter::IsInitialized() const { - return true; -} - -void ParameterizedType_TypeParameter::InternalSwap(ParameterizedType_TypeParameter* other) { - using std::swap; - auto* lhs_arena = GetArenaForAllocation(); - auto* rhs_arena = other->GetArenaForAllocation(); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - bounds_.InternalSwap(&other->bounds_); - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &name_, lhs_arena, - &other->name_, rhs_arena - ); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_TypeParameter::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[0]); -} - -// =================================================================== - -class ParameterizedType_IntegerParameter::_Internal { - public: - static const ::substrait::ParameterizedType_NullableInteger& range_start_inclusive(const ParameterizedType_IntegerParameter* msg); - static const ::substrait::ParameterizedType_NullableInteger& range_end_exclusive(const ParameterizedType_IntegerParameter* msg); -}; - -const ::substrait::ParameterizedType_NullableInteger& -ParameterizedType_IntegerParameter::_Internal::range_start_inclusive(const ParameterizedType_IntegerParameter* msg) { - return *msg->range_start_inclusive_; -} -const ::substrait::ParameterizedType_NullableInteger& -ParameterizedType_IntegerParameter::_Internal::range_end_exclusive(const ParameterizedType_IntegerParameter* msg) { - return *msg->range_end_exclusive_; -} -ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.IntegerParameter) -} -ParameterizedType_IntegerParameter::ParameterizedType_IntegerParameter(const ParameterizedType_IntegerParameter& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArenaForAllocation()); - } - if (from._internal_has_range_start_inclusive()) { - range_start_inclusive_ = new ::substrait::ParameterizedType_NullableInteger(*from.range_start_inclusive_); - } else { - range_start_inclusive_ = nullptr; - } - if (from._internal_has_range_end_exclusive()) { - range_end_exclusive_ = new ::substrait::ParameterizedType_NullableInteger(*from.range_end_exclusive_); - } else { - range_end_exclusive_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.IntegerParameter) -} - -inline void ParameterizedType_IntegerParameter::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&range_start_inclusive_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&range_end_exclusive_) - - reinterpret_cast(&range_start_inclusive_)) + sizeof(range_end_exclusive_)); -} - -ParameterizedType_IntegerParameter::~ParameterizedType_IntegerParameter() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.IntegerParameter) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_IntegerParameter::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (this != internal_default_instance()) delete range_start_inclusive_; - if (this != internal_default_instance()) delete range_end_exclusive_; -} - -void ParameterizedType_IntegerParameter::ArenaDtor(void* object) { - ParameterizedType_IntegerParameter* _this = reinterpret_cast< ParameterizedType_IntegerParameter* >(object); - (void)_this; -} -void ParameterizedType_IntegerParameter::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_IntegerParameter::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_IntegerParameter::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.IntegerParameter) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmpty(); - if (GetArenaForAllocation() == nullptr && range_start_inclusive_ != nullptr) { - delete range_start_inclusive_; - } - range_start_inclusive_ = nullptr; - if (GetArenaForAllocation() == nullptr && range_end_exclusive_ != nullptr) { - delete range_end_exclusive_; - } - range_end_exclusive_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_IntegerParameter::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.IntegerParameter.name")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_range_start_inclusive(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_range_end_exclusive(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ParameterizedType_IntegerParameter::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.IntegerParameter) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string name = 1; - if (!this->_internal_name().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.ParameterizedType.IntegerParameter.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; - if (this->_internal_has_range_start_inclusive()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::range_start_inclusive(this), target, stream); - } - - // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; - if (this->_internal_has_range_end_exclusive()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::range_end_exclusive(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.IntegerParameter) - return target; -} - -size_t ParameterizedType_IntegerParameter::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.IntegerParameter) - 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 name = 1; - if (!this->_internal_name().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; - if (this->_internal_has_range_start_inclusive()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *range_start_inclusive_); - } - - // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; - if (this->_internal_has_range_end_exclusive()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *range_end_exclusive_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_IntegerParameter::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_IntegerParameter::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_IntegerParameter::GetClassData() const { return &_class_data_; } - -void ParameterizedType_IntegerParameter::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_IntegerParameter::MergeFrom(const ParameterizedType_IntegerParameter& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.IntegerParameter) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_name().empty()) { - _internal_set_name(from._internal_name()); - } - if (from._internal_has_range_start_inclusive()) { - _internal_mutable_range_start_inclusive()->::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_start_inclusive()); - } - if (from._internal_has_range_end_exclusive()) { - _internal_mutable_range_end_exclusive()->::substrait::ParameterizedType_NullableInteger::MergeFrom(from._internal_range_end_exclusive()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_IntegerParameter::CopyFrom(const ParameterizedType_IntegerParameter& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.IntegerParameter) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_IntegerParameter::IsInitialized() const { - return true; -} - -void ParameterizedType_IntegerParameter::InternalSwap(ParameterizedType_IntegerParameter* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &name_, lhs_arena, - &other->name_, rhs_arena - ); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ParameterizedType_IntegerParameter, range_end_exclusive_) - + sizeof(ParameterizedType_IntegerParameter::range_end_exclusive_) - - PROTOBUF_FIELD_OFFSET(ParameterizedType_IntegerParameter, range_start_inclusive_)>( - reinterpret_cast(&range_start_inclusive_), - reinterpret_cast(&other->range_start_inclusive_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_IntegerParameter::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[1]); -} - -// =================================================================== - -class ParameterizedType_NullableInteger::_Internal { - public: -}; - -ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.NullableInteger) -} -ParameterizedType_NullableInteger::ParameterizedType_NullableInteger(const ParameterizedType_NullableInteger& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - value_ = from.value_; - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.NullableInteger) -} - -inline void ParameterizedType_NullableInteger::SharedCtor() { -value_ = int64_t{0}; -} - -ParameterizedType_NullableInteger::~ParameterizedType_NullableInteger() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.NullableInteger) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_NullableInteger::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void ParameterizedType_NullableInteger::ArenaDtor(void* object) { - ParameterizedType_NullableInteger* _this = reinterpret_cast< ParameterizedType_NullableInteger* >(object); - (void)_this; -} -void ParameterizedType_NullableInteger::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_NullableInteger::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_NullableInteger::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.NullableInteger) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - value_ = int64_t{0}; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_NullableInteger::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int64 value = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ParameterizedType_NullableInteger::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.NullableInteger) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int64 value = 1; - if (this->_internal_value() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(1, this->_internal_value(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.NullableInteger) - return target; -} - -size_t ParameterizedType_NullableInteger::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.NullableInteger) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int64 value = 1; - if (this->_internal_value() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_value()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_NullableInteger::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_NullableInteger::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_NullableInteger::GetClassData() const { return &_class_data_; } - -void ParameterizedType_NullableInteger::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_NullableInteger::MergeFrom(const ParameterizedType_NullableInteger& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.NullableInteger) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_value() != 0) { - _internal_set_value(from._internal_value()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_NullableInteger::CopyFrom(const ParameterizedType_NullableInteger& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.NullableInteger) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_NullableInteger::IsInitialized() const { - return true; -} - -void ParameterizedType_NullableInteger::InternalSwap(ParameterizedType_NullableInteger* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(value_, other->value_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_NullableInteger::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[2]); -} - -// =================================================================== - -class ParameterizedType_ParameterizedFixedChar::_Internal { - public: - static const ::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedChar* msg); -}; - -const ::substrait::ParameterizedType_IntegerOption& -ParameterizedType_ParameterizedFixedChar::_Internal::length(const ParameterizedType_ParameterizedFixedChar* msg) { - return *msg->length_; -} -ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedFixedChar) -} -ParameterizedType_ParameterizedFixedChar::ParameterizedType_ParameterizedFixedChar(const ParameterizedType_ParameterizedFixedChar& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_length()) { - length_ = new ::substrait::ParameterizedType_IntegerOption(*from.length_); - } else { - length_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedFixedChar) -} - -inline void ParameterizedType_ParameterizedFixedChar::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&length_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); -} - -ParameterizedType_ParameterizedFixedChar::~ParameterizedType_ParameterizedFixedChar() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedFixedChar) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_ParameterizedFixedChar::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete length_; -} - -void ParameterizedType_ParameterizedFixedChar::ArenaDtor(void* object) { - ParameterizedType_ParameterizedFixedChar* _this = reinterpret_cast< ParameterizedType_ParameterizedFixedChar* >(object); - (void)_this; -} -void ParameterizedType_ParameterizedFixedChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_ParameterizedFixedChar::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_ParameterizedFixedChar::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedFixedChar) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_ParameterizedFixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.ParameterizedType.IntegerOption length = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* ParameterizedType_ParameterizedFixedChar::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedFixedChar) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->_internal_has_length()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::length(this), target, stream); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedFixedChar) - return target; -} - -size_t ParameterizedType_ParameterizedFixedChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedFixedChar) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->_internal_has_length()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *length_); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedFixedChar::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_ParameterizedFixedChar::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedFixedChar::GetClassData() const { return &_class_data_; } - -void ParameterizedType_ParameterizedFixedChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_ParameterizedFixedChar::MergeFrom(const ParameterizedType_ParameterizedFixedChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedFixedChar) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_length()) { - _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_ParameterizedFixedChar::CopyFrom(const ParameterizedType_ParameterizedFixedChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedFixedChar) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_ParameterizedFixedChar::IsInitialized() const { - return true; -} - -void ParameterizedType_ParameterizedFixedChar::InternalSwap(ParameterizedType_ParameterizedFixedChar* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedChar, nullability_) - + sizeof(ParameterizedType_ParameterizedFixedChar::nullability_) - - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedChar, length_)>( - reinterpret_cast(&length_), - reinterpret_cast(&other->length_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedFixedChar::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[3]); -} - -// =================================================================== - -class ParameterizedType_ParameterizedVarChar::_Internal { - public: - static const ::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedVarChar* msg); -}; - -const ::substrait::ParameterizedType_IntegerOption& -ParameterizedType_ParameterizedVarChar::_Internal::length(const ParameterizedType_ParameterizedVarChar* msg) { - return *msg->length_; -} -ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedVarChar) -} -ParameterizedType_ParameterizedVarChar::ParameterizedType_ParameterizedVarChar(const ParameterizedType_ParameterizedVarChar& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_length()) { - length_ = new ::substrait::ParameterizedType_IntegerOption(*from.length_); - } else { - length_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedVarChar) -} - -inline void ParameterizedType_ParameterizedVarChar::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&length_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); -} - -ParameterizedType_ParameterizedVarChar::~ParameterizedType_ParameterizedVarChar() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedVarChar) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_ParameterizedVarChar::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete length_; -} - -void ParameterizedType_ParameterizedVarChar::ArenaDtor(void* object) { - ParameterizedType_ParameterizedVarChar* _this = reinterpret_cast< ParameterizedType_ParameterizedVarChar* >(object); - (void)_this; -} -void ParameterizedType_ParameterizedVarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_ParameterizedVarChar::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_ParameterizedVarChar::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedVarChar) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_ParameterizedVarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.ParameterizedType.IntegerOption length = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* ParameterizedType_ParameterizedVarChar::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedVarChar) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->_internal_has_length()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::length(this), target, stream); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedVarChar) - return target; -} - -size_t ParameterizedType_ParameterizedVarChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedVarChar) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->_internal_has_length()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *length_); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedVarChar::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_ParameterizedVarChar::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedVarChar::GetClassData() const { return &_class_data_; } - -void ParameterizedType_ParameterizedVarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_ParameterizedVarChar::MergeFrom(const ParameterizedType_ParameterizedVarChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedVarChar) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_length()) { - _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_ParameterizedVarChar::CopyFrom(const ParameterizedType_ParameterizedVarChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedVarChar) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_ParameterizedVarChar::IsInitialized() const { - return true; -} - -void ParameterizedType_ParameterizedVarChar::InternalSwap(ParameterizedType_ParameterizedVarChar* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedVarChar, nullability_) - + sizeof(ParameterizedType_ParameterizedVarChar::nullability_) - - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedVarChar, length_)>( - reinterpret_cast(&length_), - reinterpret_cast(&other->length_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedVarChar::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[4]); -} - -// =================================================================== - -class ParameterizedType_ParameterizedFixedBinary::_Internal { - public: - static const ::substrait::ParameterizedType_IntegerOption& length(const ParameterizedType_ParameterizedFixedBinary* msg); -}; - -const ::substrait::ParameterizedType_IntegerOption& -ParameterizedType_ParameterizedFixedBinary::_Internal::length(const ParameterizedType_ParameterizedFixedBinary* msg) { - return *msg->length_; -} -ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedFixedBinary) -} -ParameterizedType_ParameterizedFixedBinary::ParameterizedType_ParameterizedFixedBinary(const ParameterizedType_ParameterizedFixedBinary& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_length()) { - length_ = new ::substrait::ParameterizedType_IntegerOption(*from.length_); - } else { - length_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedFixedBinary) -} - -inline void ParameterizedType_ParameterizedFixedBinary::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&length_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); -} - -ParameterizedType_ParameterizedFixedBinary::~ParameterizedType_ParameterizedFixedBinary() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedFixedBinary) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_ParameterizedFixedBinary::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete length_; -} - -void ParameterizedType_ParameterizedFixedBinary::ArenaDtor(void* object) { - ParameterizedType_ParameterizedFixedBinary* _this = reinterpret_cast< ParameterizedType_ParameterizedFixedBinary* >(object); - (void)_this; -} -void ParameterizedType_ParameterizedFixedBinary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_ParameterizedFixedBinary::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_ParameterizedFixedBinary::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedFixedBinary) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_ParameterizedFixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.ParameterizedType.IntegerOption length = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* ParameterizedType_ParameterizedFixedBinary::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedFixedBinary) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->_internal_has_length()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::length(this), target, stream); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedFixedBinary) - return target; -} - -size_t ParameterizedType_ParameterizedFixedBinary::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedFixedBinary) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.ParameterizedType.IntegerOption length = 1; - if (this->_internal_has_length()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *length_); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedFixedBinary::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_ParameterizedFixedBinary::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedFixedBinary::GetClassData() const { return &_class_data_; } - -void ParameterizedType_ParameterizedFixedBinary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_ParameterizedFixedBinary::MergeFrom(const ParameterizedType_ParameterizedFixedBinary& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedFixedBinary) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_length()) { - _internal_mutable_length()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_length()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_ParameterizedFixedBinary::CopyFrom(const ParameterizedType_ParameterizedFixedBinary& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedFixedBinary) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_ParameterizedFixedBinary::IsInitialized() const { - return true; -} - -void ParameterizedType_ParameterizedFixedBinary::InternalSwap(ParameterizedType_ParameterizedFixedBinary* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedBinary, nullability_) - + sizeof(ParameterizedType_ParameterizedFixedBinary::nullability_) - - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedFixedBinary, length_)>( - reinterpret_cast(&length_), - reinterpret_cast(&other->length_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedFixedBinary::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[5]); -} - -// =================================================================== - -class ParameterizedType_ParameterizedDecimal::_Internal { - public: - static const ::substrait::ParameterizedType_IntegerOption& scale(const ParameterizedType_ParameterizedDecimal* msg); - static const ::substrait::ParameterizedType_IntegerOption& precision(const ParameterizedType_ParameterizedDecimal* msg); -}; - -const ::substrait::ParameterizedType_IntegerOption& -ParameterizedType_ParameterizedDecimal::_Internal::scale(const ParameterizedType_ParameterizedDecimal* msg) { - return *msg->scale_; -} -const ::substrait::ParameterizedType_IntegerOption& -ParameterizedType_ParameterizedDecimal::_Internal::precision(const ParameterizedType_ParameterizedDecimal* msg) { - return *msg->precision_; -} -ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedDecimal) -} -ParameterizedType_ParameterizedDecimal::ParameterizedType_ParameterizedDecimal(const ParameterizedType_ParameterizedDecimal& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_scale()) { - scale_ = new ::substrait::ParameterizedType_IntegerOption(*from.scale_); - } else { - scale_ = nullptr; - } - if (from._internal_has_precision()) { - precision_ = new ::substrait::ParameterizedType_IntegerOption(*from.precision_); - } else { - precision_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedDecimal) -} - -inline void ParameterizedType_ParameterizedDecimal::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&scale_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&scale_)) + sizeof(nullability_)); -} - -ParameterizedType_ParameterizedDecimal::~ParameterizedType_ParameterizedDecimal() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedDecimal) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_ParameterizedDecimal::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete scale_; - if (this != internal_default_instance()) delete precision_; -} - -void ParameterizedType_ParameterizedDecimal::ArenaDtor(void* object) { - ParameterizedType_ParameterizedDecimal* _this = reinterpret_cast< ParameterizedType_ParameterizedDecimal* >(object); - (void)_this; -} -void ParameterizedType_ParameterizedDecimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_ParameterizedDecimal::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_ParameterizedDecimal::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedDecimal) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && scale_ != nullptr) { - delete scale_; - } - scale_ = nullptr; - if (GetArenaForAllocation() == nullptr && precision_ != nullptr) { - delete precision_; - } - precision_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_ParameterizedDecimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.ParameterizedType.IntegerOption scale = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.IntegerOption precision = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* ParameterizedType_ParameterizedDecimal::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedDecimal) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.ParameterizedType.IntegerOption scale = 1; - if (this->_internal_has_scale()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::scale(this), target, stream); - } - - // .substrait.ParameterizedType.IntegerOption precision = 2; - if (this->_internal_has_precision()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::precision(this), target, stream); - } - - // uint32 variation_pointer = 3; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 4, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedDecimal) - return target; -} - -size_t ParameterizedType_ParameterizedDecimal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedDecimal) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.ParameterizedType.IntegerOption scale = 1; - if (this->_internal_has_scale()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *scale_); - } - - // .substrait.ParameterizedType.IntegerOption precision = 2; - if (this->_internal_has_precision()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *precision_); - } - - // uint32 variation_pointer = 3; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedDecimal::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_ParameterizedDecimal::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedDecimal::GetClassData() const { return &_class_data_; } - -void ParameterizedType_ParameterizedDecimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_ParameterizedDecimal::MergeFrom(const ParameterizedType_ParameterizedDecimal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedDecimal) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_scale()) { - _internal_mutable_scale()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_scale()); - } - if (from._internal_has_precision()) { - _internal_mutable_precision()->::substrait::ParameterizedType_IntegerOption::MergeFrom(from._internal_precision()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_ParameterizedDecimal::CopyFrom(const ParameterizedType_ParameterizedDecimal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedDecimal) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_ParameterizedDecimal::IsInitialized() const { - return true; -} - -void ParameterizedType_ParameterizedDecimal::InternalSwap(ParameterizedType_ParameterizedDecimal* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedDecimal, nullability_) - + sizeof(ParameterizedType_ParameterizedDecimal::nullability_) - - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedDecimal, scale_)>( - reinterpret_cast(&scale_), - reinterpret_cast(&other->scale_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedDecimal::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[6]); -} - -// =================================================================== - -class ParameterizedType_ParameterizedStruct::_Internal { - public: -}; - -ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - types_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedStruct) -} -ParameterizedType_ParameterizedStruct::ParameterizedType_ParameterizedStruct(const ParameterizedType_ParameterizedStruct& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - types_(from.types_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedStruct) -} - -inline void ParameterizedType_ParameterizedStruct::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_pointer_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); -} - -ParameterizedType_ParameterizedStruct::~ParameterizedType_ParameterizedStruct() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedStruct) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_ParameterizedStruct::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void ParameterizedType_ParameterizedStruct::ArenaDtor(void* object) { - ParameterizedType_ParameterizedStruct* _this = reinterpret_cast< ParameterizedType_ParameterizedStruct* >(object); - (void)_this; -} -void ParameterizedType_ParameterizedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_ParameterizedStruct::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_ParameterizedStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedStruct) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - types_.Clear(); - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_ParameterizedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.ParameterizedType types = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_types(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* ParameterizedType_ParameterizedStruct::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedStruct) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.ParameterizedType types = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_types_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_types(i), target, stream); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedStruct) - return target; -} - -size_t ParameterizedType_ParameterizedStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedStruct) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.ParameterizedType types = 1; - total_size += 1UL * this->_internal_types_size(); - for (const auto& msg : this->types_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedStruct::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_ParameterizedStruct::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedStruct::GetClassData() const { return &_class_data_; } - -void ParameterizedType_ParameterizedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_ParameterizedStruct::MergeFrom(const ParameterizedType_ParameterizedStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedStruct) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - types_.MergeFrom(from.types_); - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_ParameterizedStruct::CopyFrom(const ParameterizedType_ParameterizedStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_ParameterizedStruct::IsInitialized() const { - return true; -} - -void ParameterizedType_ParameterizedStruct::InternalSwap(ParameterizedType_ParameterizedStruct* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - types_.InternalSwap(&other->types_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedStruct, nullability_) - + sizeof(ParameterizedType_ParameterizedStruct::nullability_) - - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedStruct, variation_pointer_)>( - reinterpret_cast(&variation_pointer_), - reinterpret_cast(&other->variation_pointer_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedStruct::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[7]); -} - -// =================================================================== - -class ParameterizedType_ParameterizedNamedStruct::_Internal { - public: - static const ::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType_ParameterizedNamedStruct* msg); -}; - -const ::substrait::ParameterizedType_ParameterizedStruct& -ParameterizedType_ParameterizedNamedStruct::_Internal::struct_(const ParameterizedType_ParameterizedNamedStruct* msg) { - return *msg->struct__; -} -ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - names_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedNamedStruct) -} -ParameterizedType_ParameterizedNamedStruct::ParameterizedType_ParameterizedNamedStruct(const ParameterizedType_ParameterizedNamedStruct& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - names_(from.names_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_struct_()) { - struct__ = new ::substrait::ParameterizedType_ParameterizedStruct(*from.struct__); - } else { - struct__ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedNamedStruct) -} - -inline void ParameterizedType_ParameterizedNamedStruct::SharedCtor() { -struct__ = nullptr; -} - -ParameterizedType_ParameterizedNamedStruct::~ParameterizedType_ParameterizedNamedStruct() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedNamedStruct) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_ParameterizedNamedStruct::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete struct__; -} - -void ParameterizedType_ParameterizedNamedStruct::ArenaDtor(void* object) { - ParameterizedType_ParameterizedNamedStruct* _this = reinterpret_cast< ParameterizedType_ParameterizedNamedStruct* >(object); - (void)_this; -} -void ParameterizedType_ParameterizedNamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_ParameterizedNamedStruct::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_ParameterizedNamedStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedNamedStruct) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - names_.Clear(); - if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { - delete struct__; - } - struct__ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_ParameterizedNamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string names = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_names(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ParameterizedType.ParameterizedNamedStruct.names")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.ParameterizedStruct struct = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ParameterizedType_ParameterizedNamedStruct::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedNamedStruct) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string names = 1; - for (int i = 0, n = this->_internal_names_size(); i < n; i++) { - const auto& s = this->_internal_names(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.ParameterizedType.ParameterizedNamedStruct.names"); - target = stream->WriteString(1, s, target); - } - - // .substrait.ParameterizedType.ParameterizedStruct struct = 2; - if (this->_internal_has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::struct_(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedNamedStruct) - return target; -} - -size_t ParameterizedType_ParameterizedNamedStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedNamedStruct) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string names = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); - for (int i = 0, n = names_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - names_.Get(i)); - } - - // .substrait.ParameterizedType.ParameterizedStruct struct = 2; - if (this->_internal_has_struct_()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *struct__); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedNamedStruct::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_ParameterizedNamedStruct::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedNamedStruct::GetClassData() const { return &_class_data_; } - -void ParameterizedType_ParameterizedNamedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_ParameterizedNamedStruct::MergeFrom(const ParameterizedType_ParameterizedNamedStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedNamedStruct) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - names_.MergeFrom(from.names_); - if (from._internal_has_struct_()) { - _internal_mutable_struct_()->::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_ParameterizedNamedStruct::CopyFrom(const ParameterizedType_ParameterizedNamedStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedNamedStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_ParameterizedNamedStruct::IsInitialized() const { - return true; -} - -void ParameterizedType_ParameterizedNamedStruct::InternalSwap(ParameterizedType_ParameterizedNamedStruct* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - names_.InternalSwap(&other->names_); - swap(struct__, other->struct__); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedNamedStruct::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[8]); -} - -// =================================================================== - -class ParameterizedType_ParameterizedList::_Internal { - public: - static const ::substrait::ParameterizedType& type(const ParameterizedType_ParameterizedList* msg); -}; - -const ::substrait::ParameterizedType& -ParameterizedType_ParameterizedList::_Internal::type(const ParameterizedType_ParameterizedList* msg) { - return *msg->type_; -} -ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedList) -} -ParameterizedType_ParameterizedList::ParameterizedType_ParameterizedList(const ParameterizedType_ParameterizedList& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_type()) { - type_ = new ::substrait::ParameterizedType(*from.type_); - } else { - type_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedList) -} - -inline void ParameterizedType_ParameterizedList::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_)) + sizeof(nullability_)); -} - -ParameterizedType_ParameterizedList::~ParameterizedType_ParameterizedList() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedList) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_ParameterizedList::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete type_; -} - -void ParameterizedType_ParameterizedList::ArenaDtor(void* object) { - ParameterizedType_ParameterizedList* _this = reinterpret_cast< ParameterizedType_ParameterizedList* >(object); - (void)_this; -} -void ParameterizedType_ParameterizedList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_ParameterizedList::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_ParameterizedList::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedList) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_ParameterizedList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.ParameterizedType type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* ParameterizedType_ParameterizedList::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedList) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.ParameterizedType type = 1; - if (this->_internal_has_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::type(this), target, stream); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedList) - return target; -} - -size_t ParameterizedType_ParameterizedList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedList) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.ParameterizedType type = 1; - if (this->_internal_has_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedList::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_ParameterizedList::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedList::GetClassData() const { return &_class_data_; } - -void ParameterizedType_ParameterizedList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_ParameterizedList::MergeFrom(const ParameterizedType_ParameterizedList& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedList) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_type()) { - _internal_mutable_type()->::substrait::ParameterizedType::MergeFrom(from._internal_type()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_ParameterizedList::CopyFrom(const ParameterizedType_ParameterizedList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedList) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_ParameterizedList::IsInitialized() const { - return true; -} - -void ParameterizedType_ParameterizedList::InternalSwap(ParameterizedType_ParameterizedList* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedList, nullability_) - + sizeof(ParameterizedType_ParameterizedList::nullability_) - - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedList, type_)>( - reinterpret_cast(&type_), - reinterpret_cast(&other->type_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedList::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[9]); -} - -// =================================================================== - -class ParameterizedType_ParameterizedMap::_Internal { - public: - static const ::substrait::ParameterizedType& key(const ParameterizedType_ParameterizedMap* msg); - static const ::substrait::ParameterizedType& value(const ParameterizedType_ParameterizedMap* msg); -}; - -const ::substrait::ParameterizedType& -ParameterizedType_ParameterizedMap::_Internal::key(const ParameterizedType_ParameterizedMap* msg) { - return *msg->key_; -} -const ::substrait::ParameterizedType& -ParameterizedType_ParameterizedMap::_Internal::value(const ParameterizedType_ParameterizedMap* msg) { - return *msg->value_; -} -ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.ParameterizedMap) -} -ParameterizedType_ParameterizedMap::ParameterizedType_ParameterizedMap(const ParameterizedType_ParameterizedMap& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key()) { - key_ = new ::substrait::ParameterizedType(*from.key_); - } else { - key_ = nullptr; - } - if (from._internal_has_value()) { - value_ = new ::substrait::ParameterizedType(*from.value_); - } else { - value_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.ParameterizedMap) -} - -inline void ParameterizedType_ParameterizedMap::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&key_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&key_)) + sizeof(nullability_)); -} - -ParameterizedType_ParameterizedMap::~ParameterizedType_ParameterizedMap() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.ParameterizedMap) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_ParameterizedMap::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete key_; - if (this != internal_default_instance()) delete value_; -} - -void ParameterizedType_ParameterizedMap::ArenaDtor(void* object) { - ParameterizedType_ParameterizedMap* _this = reinterpret_cast< ParameterizedType_ParameterizedMap* >(object); - (void)_this; -} -void ParameterizedType_ParameterizedMap::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_ParameterizedMap::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_ParameterizedMap::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.ParameterizedMap) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && key_ != nullptr) { - delete key_; - } - key_ = nullptr; - if (GetArenaForAllocation() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_ParameterizedMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.ParameterizedType key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType value = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* ParameterizedType_ParameterizedMap::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.ParameterizedMap) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.ParameterizedType key = 1; - if (this->_internal_has_key()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::key(this), target, stream); - } - - // .substrait.ParameterizedType value = 2; - if (this->_internal_has_value()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::value(this), target, stream); - } - - // uint32 variation_pointer = 3; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 4, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.ParameterizedMap) - return target; -} - -size_t ParameterizedType_ParameterizedMap::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.ParameterizedMap) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.ParameterizedType key = 1; - if (this->_internal_has_key()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *key_); - } - - // .substrait.ParameterizedType value = 2; - if (this->_internal_has_value()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *value_); - } - - // uint32 variation_pointer = 3; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_ParameterizedMap::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_ParameterizedMap::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_ParameterizedMap::GetClassData() const { return &_class_data_; } - -void ParameterizedType_ParameterizedMap::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_ParameterizedMap::MergeFrom(const ParameterizedType_ParameterizedMap& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.ParameterizedMap) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_key()) { - _internal_mutable_key()->::substrait::ParameterizedType::MergeFrom(from._internal_key()); - } - if (from._internal_has_value()) { - _internal_mutable_value()->::substrait::ParameterizedType::MergeFrom(from._internal_value()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_ParameterizedMap::CopyFrom(const ParameterizedType_ParameterizedMap& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.ParameterizedMap) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_ParameterizedMap::IsInitialized() const { - return true; -} - -void ParameterizedType_ParameterizedMap::InternalSwap(ParameterizedType_ParameterizedMap* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedMap, nullability_) - + sizeof(ParameterizedType_ParameterizedMap::nullability_) - - PROTOBUF_FIELD_OFFSET(ParameterizedType_ParameterizedMap, key_)>( - reinterpret_cast(&key_), - reinterpret_cast(&other->key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_ParameterizedMap::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[10]); -} - -// =================================================================== - -class ParameterizedType_IntegerOption::_Internal { - public: - static const ::substrait::ParameterizedType_IntegerParameter& parameter(const ParameterizedType_IntegerOption* msg); -}; - -const ::substrait::ParameterizedType_IntegerParameter& -ParameterizedType_IntegerOption::_Internal::parameter(const ParameterizedType_IntegerOption* msg) { - return *msg->integer_type_.parameter_; -} -void ParameterizedType_IntegerOption::set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_integer_type(); - if (parameter) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerParameter>::GetOwningArena(parameter); - if (message_arena != submessage_arena) { - parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, parameter, submessage_arena); - } - set_has_parameter(); - integer_type_.parameter_ = parameter; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerOption.parameter) -} -ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType.IntegerOption) -} -ParameterizedType_IntegerOption::ParameterizedType_IntegerOption(const ParameterizedType_IntegerOption& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_integer_type(); - switch (from.integer_type_case()) { - case kLiteral: { - _internal_set_literal(from._internal_literal()); - break; - } - case kParameter: { - _internal_mutable_parameter()->::substrait::ParameterizedType_IntegerParameter::MergeFrom(from._internal_parameter()); - break; - } - case INTEGER_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType.IntegerOption) -} - -inline void ParameterizedType_IntegerOption::SharedCtor() { -clear_has_integer_type(); -} - -ParameterizedType_IntegerOption::~ParameterizedType_IntegerOption() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType.IntegerOption) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType_IntegerOption::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_integer_type()) { - clear_integer_type(); - } -} - -void ParameterizedType_IntegerOption::ArenaDtor(void* object) { - ParameterizedType_IntegerOption* _this = reinterpret_cast< ParameterizedType_IntegerOption* >(object); - (void)_this; -} -void ParameterizedType_IntegerOption::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType_IntegerOption::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType_IntegerOption::clear_integer_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.ParameterizedType.IntegerOption) - switch (integer_type_case()) { - case kLiteral: { - // No need to clear - break; - } - case kParameter: { - if (GetArenaForAllocation() == nullptr) { - delete integer_type_.parameter_; - } - break; - } - case INTEGER_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = INTEGER_TYPE_NOT_SET; -} - - -void ParameterizedType_IntegerOption::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType.IntegerOption) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_integer_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType_IntegerOption::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 literal = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - _internal_set_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.IntegerParameter parameter = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_parameter(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ParameterizedType_IntegerOption::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType.IntegerOption) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 literal = 1; - if (_internal_has_literal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_literal(), target); - } - - // .substrait.ParameterizedType.IntegerParameter parameter = 2; - if (_internal_has_parameter()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::parameter(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType.IntegerOption) - return target; -} - -size_t ParameterizedType_IntegerOption::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType.IntegerOption) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (integer_type_case()) { - // int32 literal = 1; - case kLiteral: { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_literal()); - break; - } - // .substrait.ParameterizedType.IntegerParameter parameter = 2; - case kParameter: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *integer_type_.parameter_); - break; - } - case INTEGER_TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType_IntegerOption::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType_IntegerOption::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType_IntegerOption::GetClassData() const { return &_class_data_; } - -void ParameterizedType_IntegerOption::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType_IntegerOption::MergeFrom(const ParameterizedType_IntegerOption& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType.IntegerOption) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.integer_type_case()) { - case kLiteral: { - _internal_set_literal(from._internal_literal()); - break; - } - case kParameter: { - _internal_mutable_parameter()->::substrait::ParameterizedType_IntegerParameter::MergeFrom(from._internal_parameter()); - break; - } - case INTEGER_TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType_IntegerOption::CopyFrom(const ParameterizedType_IntegerOption& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType.IntegerOption) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType_IntegerOption::IsInitialized() const { - return true; -} - -void ParameterizedType_IntegerOption::InternalSwap(ParameterizedType_IntegerOption* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(integer_type_, other->integer_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType_IntegerOption::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[11]); -} - -// =================================================================== - -class ParameterizedType::_Internal { - public: - static const ::substrait::Type_Boolean& bool_(const ParameterizedType* msg); - static const ::substrait::Type_I8& i8(const ParameterizedType* msg); - static const ::substrait::Type_I16& i16(const ParameterizedType* msg); - static const ::substrait::Type_I32& i32(const ParameterizedType* msg); - static const ::substrait::Type_I64& i64(const ParameterizedType* msg); - static const ::substrait::Type_FP32& fp32(const ParameterizedType* msg); - static const ::substrait::Type_FP64& fp64(const ParameterizedType* msg); - static const ::substrait::Type_String& string(const ParameterizedType* msg); - static const ::substrait::Type_Binary& binary(const ParameterizedType* msg); - static const ::substrait::Type_Timestamp& timestamp(const ParameterizedType* msg); - static const ::substrait::Type_Date& date(const ParameterizedType* msg); - static const ::substrait::Type_Time& time(const ParameterizedType* msg); - static const ::substrait::Type_IntervalYear& interval_year(const ParameterizedType* msg); - static const ::substrait::Type_IntervalDay& interval_day(const ParameterizedType* msg); - static const ::substrait::Type_TimestampTZ& timestamp_tz(const ParameterizedType* msg); - static const ::substrait::Type_UUID& uuid(const ParameterizedType* msg); - static const ::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char(const ParameterizedType* msg); - static const ::substrait::ParameterizedType_ParameterizedVarChar& varchar(const ParameterizedType* msg); - static const ::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary(const ParameterizedType* msg); - static const ::substrait::ParameterizedType_ParameterizedDecimal& decimal(const ParameterizedType* msg); - static const ::substrait::ParameterizedType_ParameterizedStruct& struct_(const ParameterizedType* msg); - static const ::substrait::ParameterizedType_ParameterizedList& list(const ParameterizedType* msg); - static const ::substrait::ParameterizedType_ParameterizedMap& map(const ParameterizedType* msg); - static const ::substrait::ParameterizedType_TypeParameter& type_parameter(const ParameterizedType* msg); -}; - -const ::substrait::Type_Boolean& -ParameterizedType::_Internal::bool_(const ParameterizedType* msg) { - return *msg->kind_.bool__; -} -const ::substrait::Type_I8& -ParameterizedType::_Internal::i8(const ParameterizedType* msg) { - return *msg->kind_.i8_; -} -const ::substrait::Type_I16& -ParameterizedType::_Internal::i16(const ParameterizedType* msg) { - return *msg->kind_.i16_; -} -const ::substrait::Type_I32& -ParameterizedType::_Internal::i32(const ParameterizedType* msg) { - return *msg->kind_.i32_; -} -const ::substrait::Type_I64& -ParameterizedType::_Internal::i64(const ParameterizedType* msg) { - return *msg->kind_.i64_; -} -const ::substrait::Type_FP32& -ParameterizedType::_Internal::fp32(const ParameterizedType* msg) { - return *msg->kind_.fp32_; -} -const ::substrait::Type_FP64& -ParameterizedType::_Internal::fp64(const ParameterizedType* msg) { - return *msg->kind_.fp64_; -} -const ::substrait::Type_String& -ParameterizedType::_Internal::string(const ParameterizedType* msg) { - return *msg->kind_.string_; -} -const ::substrait::Type_Binary& -ParameterizedType::_Internal::binary(const ParameterizedType* msg) { - return *msg->kind_.binary_; -} -const ::substrait::Type_Timestamp& -ParameterizedType::_Internal::timestamp(const ParameterizedType* msg) { - return *msg->kind_.timestamp_; -} -const ::substrait::Type_Date& -ParameterizedType::_Internal::date(const ParameterizedType* msg) { - return *msg->kind_.date_; -} -const ::substrait::Type_Time& -ParameterizedType::_Internal::time(const ParameterizedType* msg) { - return *msg->kind_.time_; -} -const ::substrait::Type_IntervalYear& -ParameterizedType::_Internal::interval_year(const ParameterizedType* msg) { - return *msg->kind_.interval_year_; -} -const ::substrait::Type_IntervalDay& -ParameterizedType::_Internal::interval_day(const ParameterizedType* msg) { - return *msg->kind_.interval_day_; -} -const ::substrait::Type_TimestampTZ& -ParameterizedType::_Internal::timestamp_tz(const ParameterizedType* msg) { - return *msg->kind_.timestamp_tz_; -} -const ::substrait::Type_UUID& -ParameterizedType::_Internal::uuid(const ParameterizedType* msg) { - return *msg->kind_.uuid_; -} -const ::substrait::ParameterizedType_ParameterizedFixedChar& -ParameterizedType::_Internal::fixed_char(const ParameterizedType* msg) { - return *msg->kind_.fixed_char_; -} -const ::substrait::ParameterizedType_ParameterizedVarChar& -ParameterizedType::_Internal::varchar(const ParameterizedType* msg) { - return *msg->kind_.varchar_; -} -const ::substrait::ParameterizedType_ParameterizedFixedBinary& -ParameterizedType::_Internal::fixed_binary(const ParameterizedType* msg) { - return *msg->kind_.fixed_binary_; -} -const ::substrait::ParameterizedType_ParameterizedDecimal& -ParameterizedType::_Internal::decimal(const ParameterizedType* msg) { - return *msg->kind_.decimal_; -} -const ::substrait::ParameterizedType_ParameterizedStruct& -ParameterizedType::_Internal::struct_(const ParameterizedType* msg) { - return *msg->kind_.struct__; -} -const ::substrait::ParameterizedType_ParameterizedList& -ParameterizedType::_Internal::list(const ParameterizedType* msg) { - return *msg->kind_.list_; -} -const ::substrait::ParameterizedType_ParameterizedMap& -ParameterizedType::_Internal::map(const ParameterizedType* msg) { - return *msg->kind_.map_; -} -const ::substrait::ParameterizedType_TypeParameter& -ParameterizedType::_Internal::type_parameter(const ParameterizedType* msg) { - return *msg->kind_.type_parameter_; -} -void ParameterizedType::set_allocated_bool_(::substrait::Type_Boolean* bool_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (bool_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_)); - if (message_arena != submessage_arena) { - bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, bool_, submessage_arena); - } - set_has_bool_(); - kind_.bool__ = bool_; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.bool) -} -void ParameterizedType::clear_bool_() { - if (_internal_has_bool_()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.bool__; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_i8(::substrait::Type_I8* i8) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i8) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8)); - if (message_arena != submessage_arena) { - i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i8, submessage_arena); - } - set_has_i8(); - kind_.i8_ = i8; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i8) -} -void ParameterizedType::clear_i8() { - if (_internal_has_i8()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i8_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_i16(::substrait::Type_I16* i16) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i16) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16)); - if (message_arena != submessage_arena) { - i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i16, submessage_arena); - } - set_has_i16(); - kind_.i16_ = i16; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i16) -} -void ParameterizedType::clear_i16() { - if (_internal_has_i16()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i16_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_i32(::substrait::Type_I32* i32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i32) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32)); - if (message_arena != submessage_arena) { - i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i32, submessage_arena); - } - set_has_i32(); - kind_.i32_ = i32; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i32) -} -void ParameterizedType::clear_i32() { - if (_internal_has_i32()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i32_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_i64(::substrait::Type_I64* i64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i64) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64)); - if (message_arena != submessage_arena) { - i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i64, submessage_arena); - } - set_has_i64(); - kind_.i64_ = i64; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.i64) -} -void ParameterizedType::clear_i64() { - if (_internal_has_i64()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i64_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_fp32(::substrait::Type_FP32* fp32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fp32) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32)); - if (message_arena != submessage_arena) { - fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fp32, submessage_arena); - } - set_has_fp32(); - kind_.fp32_ = fp32; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fp32) -} -void ParameterizedType::clear_fp32() { - if (_internal_has_fp32()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp32_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_fp64(::substrait::Type_FP64* fp64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fp64) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64)); - if (message_arena != submessage_arena) { - fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fp64, submessage_arena); - } - set_has_fp64(); - kind_.fp64_ = fp64; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fp64) -} -void ParameterizedType::clear_fp64() { - if (_internal_has_fp64()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp64_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_string(::substrait::Type_String* string) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (string) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string)); - if (message_arena != submessage_arena) { - string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, string, submessage_arena); - } - set_has_string(); - kind_.string_ = string; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.string) -} -void ParameterizedType::clear_string() { - if (_internal_has_string()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.string_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_binary(::substrait::Type_Binary* binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary)); - if (message_arena != submessage_arena) { - binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, binary, submessage_arena); - } - set_has_binary(); - kind_.binary_ = binary; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.binary) -} -void ParameterizedType::clear_binary() { - if (_internal_has_binary()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.binary_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (timestamp) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp)); - if (message_arena != submessage_arena) { - timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, timestamp, submessage_arena); - } - set_has_timestamp(); - kind_.timestamp_ = timestamp; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.timestamp) -} -void ParameterizedType::clear_timestamp() { - if (_internal_has_timestamp()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_date(::substrait::Type_Date* date) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (date) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date)); - if (message_arena != submessage_arena) { - date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, date, submessage_arena); - } - set_has_date(); - kind_.date_ = date; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.date) -} -void ParameterizedType::clear_date() { - if (_internal_has_date()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.date_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_time(::substrait::Type_Time* time) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (time) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time)); - if (message_arena != submessage_arena) { - time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, time, submessage_arena); - } - set_has_time(); - kind_.time_ = time; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.time) -} -void ParameterizedType::clear_time() { - if (_internal_has_time()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.time_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (interval_year) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year)); - if (message_arena != submessage_arena) { - interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interval_year, submessage_arena); - } - set_has_interval_year(); - kind_.interval_year_ = interval_year; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.interval_year) -} -void ParameterizedType::clear_interval_year() { - if (_internal_has_interval_year()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_year_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (interval_day) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day)); - if (message_arena != submessage_arena) { - interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interval_day, submessage_arena); - } - set_has_interval_day(); - kind_.interval_day_ = interval_day; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.interval_day) -} -void ParameterizedType::clear_interval_day() { - if (_internal_has_interval_day()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_day_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (timestamp_tz) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz)); - if (message_arena != submessage_arena) { - timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, timestamp_tz, submessage_arena); - } - set_has_timestamp_tz(); - kind_.timestamp_tz_ = timestamp_tz; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.timestamp_tz) -} -void ParameterizedType::clear_timestamp_tz() { - if (_internal_has_timestamp_tz()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_tz_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_uuid(::substrait::Type_UUID* uuid) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (uuid) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid)); - if (message_arena != submessage_arena) { - uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, uuid, submessage_arena); - } - set_has_uuid(); - kind_.uuid_ = uuid; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.uuid) -} -void ParameterizedType::clear_uuid() { - if (_internal_has_uuid()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.uuid_; - } - clear_has_kind(); - } -} -void ParameterizedType::set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fixed_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedFixedChar>::GetOwningArena(fixed_char); - if (message_arena != submessage_arena) { - fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fixed_char, submessage_arena); - } - set_has_fixed_char(); - kind_.fixed_char_ = fixed_char; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fixed_char) -} -void ParameterizedType::set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (varchar) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedVarChar>::GetOwningArena(varchar); - if (message_arena != submessage_arena) { - varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, varchar, submessage_arena); - } - set_has_varchar(); - kind_.varchar_ = varchar; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.varchar) -} -void ParameterizedType::set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fixed_binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedFixedBinary>::GetOwningArena(fixed_binary); - if (message_arena != submessage_arena) { - fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fixed_binary, submessage_arena); - } - set_has_fixed_binary(); - kind_.fixed_binary_ = fixed_binary; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.fixed_binary) -} -void ParameterizedType::set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedDecimal>::GetOwningArena(decimal); - if (message_arena != submessage_arena) { - decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, decimal, submessage_arena); - } - set_has_decimal(); - kind_.decimal_ = decimal; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.decimal) -} -void ParameterizedType::set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedStruct>::GetOwningArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - set_has_struct_(); - kind_.struct__ = struct_; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.struct) -} -void ParameterizedType::set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedList>::GetOwningArena(list); - if (message_arena != submessage_arena) { - list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, list, submessage_arena); - } - set_has_list(); - kind_.list_ = list; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.list) -} -void ParameterizedType::set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (map) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedMap>::GetOwningArena(map); - if (message_arena != submessage_arena) { - map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, map, submessage_arena); - } - set_has_map(); - kind_.map_ = map; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.map) -} -void ParameterizedType::set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (type_parameter) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_TypeParameter>::GetOwningArena(type_parameter); - if (message_arena != submessage_arena) { - type_parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type_parameter, submessage_arena); - } - set_has_type_parameter(); - kind_.type_parameter_ = type_parameter; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.type_parameter) -} -ParameterizedType::ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ParameterizedType) -} -ParameterizedType::ParameterizedType(const ParameterizedType& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_kind(); - switch (from.kind_case()) { - case kBool: { - _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); - break; - } - case kI8: { - _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); - break; - } - case kI16: { - _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); - break; - } - case kI32: { - _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); - break; - } - case kI64: { - _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); - break; - } - case kFp32: { - _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); - break; - } - case kFp64: { - _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); - break; - } - case kString: { - _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); - break; - } - case kBinary: { - _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); - break; - } - case kTimestamp: { - _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); - break; - } - case kDate: { - _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); - break; - } - case kTime: { - _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); - break; - } - case kIntervalYear: { - _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); - break; - } - case kIntervalDay: { - _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); - break; - } - case kTimestampTz: { - _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); - break; - } - case kUuid: { - _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); - break; - } - case kFixedChar: { - _internal_mutable_fixed_char()->::substrait::ParameterizedType_ParameterizedFixedChar::MergeFrom(from._internal_fixed_char()); - break; - } - case kVarchar: { - _internal_mutable_varchar()->::substrait::ParameterizedType_ParameterizedVarChar::MergeFrom(from._internal_varchar()); - break; - } - case kFixedBinary: { - _internal_mutable_fixed_binary()->::substrait::ParameterizedType_ParameterizedFixedBinary::MergeFrom(from._internal_fixed_binary()); - break; - } - case kDecimal: { - _internal_mutable_decimal()->::substrait::ParameterizedType_ParameterizedDecimal::MergeFrom(from._internal_decimal()); - break; - } - case kStruct: { - _internal_mutable_struct_()->::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); - break; - } - case kList: { - _internal_mutable_list()->::substrait::ParameterizedType_ParameterizedList::MergeFrom(from._internal_list()); - break; - } - case kMap: { - _internal_mutable_map()->::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map()); - break; - } - case kUserDefinedPointer: { - _internal_set_user_defined_pointer(from._internal_user_defined_pointer()); - break; - } - case kTypeParameter: { - _internal_mutable_type_parameter()->::substrait::ParameterizedType_TypeParameter::MergeFrom(from._internal_type_parameter()); - break; - } - case KIND_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.ParameterizedType) -} - -inline void ParameterizedType::SharedCtor() { -clear_has_kind(); -} - -ParameterizedType::~ParameterizedType() { - // @@protoc_insertion_point(destructor:substrait.ParameterizedType) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ParameterizedType::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_kind()) { - clear_kind(); - } -} - -void ParameterizedType::ArenaDtor(void* object) { - ParameterizedType* _this = reinterpret_cast< ParameterizedType* >(object); - (void)_this; -} -void ParameterizedType::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ParameterizedType::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ParameterizedType::clear_kind() { -// @@protoc_insertion_point(one_of_clear_start:substrait.ParameterizedType) - switch (kind_case()) { - case kBool: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.bool__; - } - break; - } - case kI8: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i8_; - } - break; - } - case kI16: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i16_; - } - break; - } - case kI32: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i32_; - } - break; - } - case kI64: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i64_; - } - break; - } - case kFp32: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp32_; - } - break; - } - case kFp64: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp64_; - } - break; - } - case kString: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.string_; - } - break; - } - case kBinary: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.binary_; - } - break; - } - case kTimestamp: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_; - } - break; - } - case kDate: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.date_; - } - break; - } - case kTime: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.time_; - } - break; - } - case kIntervalYear: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_year_; - } - break; - } - case kIntervalDay: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_day_; - } - break; - } - case kTimestampTz: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_tz_; - } - break; - } - case kUuid: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.uuid_; - } - break; - } - case kFixedChar: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_char_; - } - break; - } - case kVarchar: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.varchar_; - } - break; - } - case kFixedBinary: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_binary_; - } - break; - } - case kDecimal: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.decimal_; - } - break; - } - case kStruct: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.struct__; - } - break; - } - case kList: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.list_; - } - break; - } - case kMap: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.map_; - } - break; - } - case kUserDefinedPointer: { - // No need to clear - break; - } - case kTypeParameter: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.type_parameter_; - } - break; - } - case KIND_NOT_SET: { - break; - } - } - _oneof_case_[0] = KIND_NOT_SET; -} - - -void ParameterizedType::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ParameterizedType) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_kind(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ParameterizedType::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Type.Boolean bool = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I8 i8 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I16 i16 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I32 i32 = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I64 i64 = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.FP32 fp32 = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.FP64 fp64 = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.String string = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Binary binary = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Timestamp timestamp = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { - ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Date date = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Time time = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.IntervalYear interval_year = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.IntervalDay interval_day = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { - ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { - ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { - ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.ParameterizedStruct struct = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.ParameterizedList list = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { - ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.ParameterizedMap map = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { - ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.TimestampTZ timestamp_tz = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { - ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 user_defined_pointer = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { - _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.UUID uuid = 32; - case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { - ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ParameterizedType.TypeParameter type_parameter = 33; - case 33: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_type_parameter(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ParameterizedType::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ParameterizedType) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Type.Boolean bool = 1; - if (_internal_has_bool_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::bool_(this), target, stream); - } - - // .substrait.Type.I8 i8 = 2; - if (_internal_has_i8()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::i8(this), target, stream); - } - - // .substrait.Type.I16 i16 = 3; - if (_internal_has_i16()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::i16(this), target, stream); - } - - // .substrait.Type.I32 i32 = 5; - if (_internal_has_i32()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::i32(this), target, stream); - } - - // .substrait.Type.I64 i64 = 7; - if (_internal_has_i64()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 7, _Internal::i64(this), target, stream); - } - - // .substrait.Type.FP32 fp32 = 10; - if (_internal_has_fp32()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::fp32(this), target, stream); - } - - // .substrait.Type.FP64 fp64 = 11; - if (_internal_has_fp64()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 11, _Internal::fp64(this), target, stream); - } - - // .substrait.Type.String string = 12; - if (_internal_has_string()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 12, _Internal::string(this), target, stream); - } - - // .substrait.Type.Binary binary = 13; - if (_internal_has_binary()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 13, _Internal::binary(this), target, stream); - } - - // .substrait.Type.Timestamp timestamp = 14; - if (_internal_has_timestamp()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 14, _Internal::timestamp(this), target, stream); - } - - // .substrait.Type.Date date = 16; - if (_internal_has_date()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 16, _Internal::date(this), target, stream); - } - - // .substrait.Type.Time time = 17; - if (_internal_has_time()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 17, _Internal::time(this), target, stream); - } - - // .substrait.Type.IntervalYear interval_year = 19; - if (_internal_has_interval_year()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 19, _Internal::interval_year(this), target, stream); - } - - // .substrait.Type.IntervalDay interval_day = 20; - if (_internal_has_interval_day()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 20, _Internal::interval_day(this), target, stream); - } - - // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; - if (_internal_has_fixed_char()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 21, _Internal::fixed_char(this), target, stream); - } - - // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; - if (_internal_has_varchar()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 22, _Internal::varchar(this), target, stream); - } - - // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; - if (_internal_has_fixed_binary()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 23, _Internal::fixed_binary(this), target, stream); - } - - // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; - if (_internal_has_decimal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 24, _Internal::decimal(this), target, stream); - } - - // .substrait.ParameterizedType.ParameterizedStruct struct = 25; - if (_internal_has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 25, _Internal::struct_(this), target, stream); - } - - // .substrait.ParameterizedType.ParameterizedList list = 27; - if (_internal_has_list()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 27, _Internal::list(this), target, stream); - } - - // .substrait.ParameterizedType.ParameterizedMap map = 28; - if (_internal_has_map()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 28, _Internal::map(this), target, stream); - } - - // .substrait.Type.TimestampTZ timestamp_tz = 29; - if (_internal_has_timestamp_tz()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 29, _Internal::timestamp_tz(this), target, stream); - } - - // uint32 user_defined_pointer = 31; - if (_internal_has_user_defined_pointer()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_pointer(), target); - } - - // .substrait.Type.UUID uuid = 32; - if (_internal_has_uuid()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 32, _Internal::uuid(this), target, stream); - } - - // .substrait.ParameterizedType.TypeParameter type_parameter = 33; - if (_internal_has_type_parameter()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 33, _Internal::type_parameter(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ParameterizedType) - return target; -} - -size_t ParameterizedType::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ParameterizedType) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (kind_case()) { - // .substrait.Type.Boolean bool = 1; - case kBool: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.bool__); - break; - } - // .substrait.Type.I8 i8 = 2; - case kI8: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i8_); - break; - } - // .substrait.Type.I16 i16 = 3; - case kI16: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i16_); - break; - } - // .substrait.Type.I32 i32 = 5; - case kI32: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i32_); - break; - } - // .substrait.Type.I64 i64 = 7; - case kI64: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i64_); - break; - } - // .substrait.Type.FP32 fp32 = 10; - case kFp32: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fp32_); - break; - } - // .substrait.Type.FP64 fp64 = 11; - case kFp64: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fp64_); - break; - } - // .substrait.Type.String string = 12; - case kString: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.string_); - break; - } - // .substrait.Type.Binary binary = 13; - case kBinary: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.binary_); - break; - } - // .substrait.Type.Timestamp timestamp = 14; - case kTimestamp: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.timestamp_); - break; - } - // .substrait.Type.Date date = 16; - case kDate: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.date_); - break; - } - // .substrait.Type.Time time = 17; - case kTime: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.time_); - break; - } - // .substrait.Type.IntervalYear interval_year = 19; - case kIntervalYear: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.interval_year_); - break; - } - // .substrait.Type.IntervalDay interval_day = 20; - case kIntervalDay: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.interval_day_); - break; - } - // .substrait.Type.TimestampTZ timestamp_tz = 29; - case kTimestampTz: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.timestamp_tz_); - break; - } - // .substrait.Type.UUID uuid = 32; - case kUuid: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.uuid_); - break; - } - // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; - case kFixedChar: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fixed_char_); - break; - } - // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; - case kVarchar: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.varchar_); - break; - } - // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; - case kFixedBinary: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fixed_binary_); - break; - } - // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; - case kDecimal: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.decimal_); - break; - } - // .substrait.ParameterizedType.ParameterizedStruct struct = 25; - case kStruct: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.struct__); - break; - } - // .substrait.ParameterizedType.ParameterizedList list = 27; - case kList: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.list_); - break; - } - // .substrait.ParameterizedType.ParameterizedMap map = 28; - case kMap: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.map_); - break; - } - // uint32 user_defined_pointer = 31; - case kUserDefinedPointer: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_user_defined_pointer()); - break; - } - // .substrait.ParameterizedType.TypeParameter type_parameter = 33; - case kTypeParameter: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.type_parameter_); - break; - } - case KIND_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ParameterizedType::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ParameterizedType::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ParameterizedType::GetClassData() const { return &_class_data_; } - -void ParameterizedType::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ParameterizedType::MergeFrom(const ParameterizedType& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ParameterizedType) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.kind_case()) { - case kBool: { - _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); - break; - } - case kI8: { - _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); - break; - } - case kI16: { - _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); - break; - } - case kI32: { - _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); - break; - } - case kI64: { - _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); - break; - } - case kFp32: { - _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); - break; - } - case kFp64: { - _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); - break; - } - case kString: { - _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); - break; - } - case kBinary: { - _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); - break; - } - case kTimestamp: { - _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); - break; - } - case kDate: { - _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); - break; - } - case kTime: { - _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); - break; - } - case kIntervalYear: { - _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); - break; - } - case kIntervalDay: { - _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); - break; - } - case kTimestampTz: { - _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); - break; - } - case kUuid: { - _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); - break; - } - case kFixedChar: { - _internal_mutable_fixed_char()->::substrait::ParameterizedType_ParameterizedFixedChar::MergeFrom(from._internal_fixed_char()); - break; - } - case kVarchar: { - _internal_mutable_varchar()->::substrait::ParameterizedType_ParameterizedVarChar::MergeFrom(from._internal_varchar()); - break; - } - case kFixedBinary: { - _internal_mutable_fixed_binary()->::substrait::ParameterizedType_ParameterizedFixedBinary::MergeFrom(from._internal_fixed_binary()); - break; - } - case kDecimal: { - _internal_mutable_decimal()->::substrait::ParameterizedType_ParameterizedDecimal::MergeFrom(from._internal_decimal()); - break; - } - case kStruct: { - _internal_mutable_struct_()->::substrait::ParameterizedType_ParameterizedStruct::MergeFrom(from._internal_struct_()); - break; - } - case kList: { - _internal_mutable_list()->::substrait::ParameterizedType_ParameterizedList::MergeFrom(from._internal_list()); - break; - } - case kMap: { - _internal_mutable_map()->::substrait::ParameterizedType_ParameterizedMap::MergeFrom(from._internal_map()); - break; - } - case kUserDefinedPointer: { - _internal_set_user_defined_pointer(from._internal_user_defined_pointer()); - break; - } - case kTypeParameter: { - _internal_mutable_type_parameter()->::substrait::ParameterizedType_TypeParameter::MergeFrom(from._internal_type_parameter()); - break; - } - case KIND_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ParameterizedType::CopyFrom(const ParameterizedType& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ParameterizedType) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ParameterizedType::IsInitialized() const { - return true; -} - -void ParameterizedType::InternalSwap(ParameterizedType* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(kind_, other->kind_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ParameterizedType::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_getter, &descriptor_table_substrait_2fparameterized_5ftypes_2eproto_once, - file_level_metadata_substrait_2fparameterized_5ftypes_2eproto[12]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_TypeParameter* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_TypeParameter >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_TypeParameter >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_IntegerParameter* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_IntegerParameter >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_IntegerParameter >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_NullableInteger* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_NullableInteger >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_NullableInteger >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedFixedChar* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedFixedChar >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedVarChar* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedVarChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedVarChar >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedFixedBinary* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedBinary >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedFixedBinary >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedDecimal* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedDecimal >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedDecimal >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedStruct* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedStruct >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedNamedStruct* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedNamedStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedNamedStruct >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedList* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedList >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedList >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_ParameterizedMap* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedMap >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_ParameterizedMap >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType_IntegerOption* Arena::CreateMaybeMessage< ::substrait::ParameterizedType_IntegerOption >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType_IntegerOption >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ParameterizedType* Arena::CreateMaybeMessage< ::substrait::ParameterizedType >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ParameterizedType >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/parameterized_types.pb.h b/cpp/src/generated/substrait/parameterized_types.pb.h deleted file mode 100644 index ae85f689870..00000000000 --- a/cpp/src/generated/substrait/parameterized_types.pb.h +++ /dev/null @@ -1,6437 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/parameterized_types.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fparameterized_5ftypes_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fparameterized_5ftypes_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3019000 -#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 3019003 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include "substrait/type.pb.h" -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_substrait_2fparameterized_5ftypes_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_substrait_2fparameterized_5ftypes_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[13] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const uint32_t offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fparameterized_5ftypes_2eproto; -namespace substrait { -class ParameterizedType; -struct ParameterizedTypeDefaultTypeInternal; -extern ParameterizedTypeDefaultTypeInternal _ParameterizedType_default_instance_; -class ParameterizedType_IntegerOption; -struct ParameterizedType_IntegerOptionDefaultTypeInternal; -extern ParameterizedType_IntegerOptionDefaultTypeInternal _ParameterizedType_IntegerOption_default_instance_; -class ParameterizedType_IntegerParameter; -struct ParameterizedType_IntegerParameterDefaultTypeInternal; -extern ParameterizedType_IntegerParameterDefaultTypeInternal _ParameterizedType_IntegerParameter_default_instance_; -class ParameterizedType_NullableInteger; -struct ParameterizedType_NullableIntegerDefaultTypeInternal; -extern ParameterizedType_NullableIntegerDefaultTypeInternal _ParameterizedType_NullableInteger_default_instance_; -class ParameterizedType_ParameterizedDecimal; -struct ParameterizedType_ParameterizedDecimalDefaultTypeInternal; -extern ParameterizedType_ParameterizedDecimalDefaultTypeInternal _ParameterizedType_ParameterizedDecimal_default_instance_; -class ParameterizedType_ParameterizedFixedBinary; -struct ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal; -extern ParameterizedType_ParameterizedFixedBinaryDefaultTypeInternal _ParameterizedType_ParameterizedFixedBinary_default_instance_; -class ParameterizedType_ParameterizedFixedChar; -struct ParameterizedType_ParameterizedFixedCharDefaultTypeInternal; -extern ParameterizedType_ParameterizedFixedCharDefaultTypeInternal _ParameterizedType_ParameterizedFixedChar_default_instance_; -class ParameterizedType_ParameterizedList; -struct ParameterizedType_ParameterizedListDefaultTypeInternal; -extern ParameterizedType_ParameterizedListDefaultTypeInternal _ParameterizedType_ParameterizedList_default_instance_; -class ParameterizedType_ParameterizedMap; -struct ParameterizedType_ParameterizedMapDefaultTypeInternal; -extern ParameterizedType_ParameterizedMapDefaultTypeInternal _ParameterizedType_ParameterizedMap_default_instance_; -class ParameterizedType_ParameterizedNamedStruct; -struct ParameterizedType_ParameterizedNamedStructDefaultTypeInternal; -extern ParameterizedType_ParameterizedNamedStructDefaultTypeInternal _ParameterizedType_ParameterizedNamedStruct_default_instance_; -class ParameterizedType_ParameterizedStruct; -struct ParameterizedType_ParameterizedStructDefaultTypeInternal; -extern ParameterizedType_ParameterizedStructDefaultTypeInternal _ParameterizedType_ParameterizedStruct_default_instance_; -class ParameterizedType_ParameterizedVarChar; -struct ParameterizedType_ParameterizedVarCharDefaultTypeInternal; -extern ParameterizedType_ParameterizedVarCharDefaultTypeInternal _ParameterizedType_ParameterizedVarChar_default_instance_; -class ParameterizedType_TypeParameter; -struct ParameterizedType_TypeParameterDefaultTypeInternal; -extern ParameterizedType_TypeParameterDefaultTypeInternal _ParameterizedType_TypeParameter_default_instance_; -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> ::substrait::ParameterizedType* Arena::CreateMaybeMessage<::substrait::ParameterizedType>(Arena*); -template<> ::substrait::ParameterizedType_IntegerOption* Arena::CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(Arena*); -template<> ::substrait::ParameterizedType_IntegerParameter* Arena::CreateMaybeMessage<::substrait::ParameterizedType_IntegerParameter>(Arena*); -template<> ::substrait::ParameterizedType_NullableInteger* Arena::CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(Arena*); -template<> ::substrait::ParameterizedType_ParameterizedDecimal* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedDecimal>(Arena*); -template<> ::substrait::ParameterizedType_ParameterizedFixedBinary* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedFixedBinary>(Arena*); -template<> ::substrait::ParameterizedType_ParameterizedFixedChar* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedFixedChar>(Arena*); -template<> ::substrait::ParameterizedType_ParameterizedList* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedList>(Arena*); -template<> ::substrait::ParameterizedType_ParameterizedMap* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedMap>(Arena*); -template<> ::substrait::ParameterizedType_ParameterizedNamedStruct* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedNamedStruct>(Arena*); -template<> ::substrait::ParameterizedType_ParameterizedStruct* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedStruct>(Arena*); -template<> ::substrait::ParameterizedType_ParameterizedVarChar* Arena::CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedVarChar>(Arena*); -template<> ::substrait::ParameterizedType_TypeParameter* Arena::CreateMaybeMessage<::substrait::ParameterizedType_TypeParameter>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace substrait { - -// =================================================================== - -class ParameterizedType_TypeParameter final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.TypeParameter) */ { - public: - inline ParameterizedType_TypeParameter() : ParameterizedType_TypeParameter(nullptr) {} - ~ParameterizedType_TypeParameter() override; - explicit constexpr ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_TypeParameter(const ParameterizedType_TypeParameter& from); - ParameterizedType_TypeParameter(ParameterizedType_TypeParameter&& from) noexcept - : ParameterizedType_TypeParameter() { - *this = ::std::move(from); - } - - inline ParameterizedType_TypeParameter& operator=(const ParameterizedType_TypeParameter& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_TypeParameter& operator=(ParameterizedType_TypeParameter&& 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 ParameterizedType_TypeParameter& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_TypeParameter* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_TypeParameter_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(ParameterizedType_TypeParameter& a, ParameterizedType_TypeParameter& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_TypeParameter* 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(ParameterizedType_TypeParameter* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_TypeParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_TypeParameter& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_TypeParameter& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_TypeParameter* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.TypeParameter"; - } - protected: - explicit ParameterizedType_TypeParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kBoundsFieldNumber = 2, - kNameFieldNumber = 1, - }; - // repeated .substrait.ParameterizedType bounds = 2; - int bounds_size() const; - private: - int _internal_bounds_size() const; - public: - void clear_bounds(); - ::substrait::ParameterizedType* mutable_bounds(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >* - mutable_bounds(); - private: - const ::substrait::ParameterizedType& _internal_bounds(int index) const; - ::substrait::ParameterizedType* _internal_add_bounds(); - public: - const ::substrait::ParameterizedType& bounds(int index) const; - ::substrait::ParameterizedType* add_bounds(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >& - bounds() const; - - // string name = 1; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.TypeParameter) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType > bounds_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_IntegerParameter final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.IntegerParameter) */ { - public: - inline ParameterizedType_IntegerParameter() : ParameterizedType_IntegerParameter(nullptr) {} - ~ParameterizedType_IntegerParameter() override; - explicit constexpr ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_IntegerParameter(const ParameterizedType_IntegerParameter& from); - ParameterizedType_IntegerParameter(ParameterizedType_IntegerParameter&& from) noexcept - : ParameterizedType_IntegerParameter() { - *this = ::std::move(from); - } - - inline ParameterizedType_IntegerParameter& operator=(const ParameterizedType_IntegerParameter& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_IntegerParameter& operator=(ParameterizedType_IntegerParameter&& 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 ParameterizedType_IntegerParameter& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_IntegerParameter* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_IntegerParameter_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(ParameterizedType_IntegerParameter& a, ParameterizedType_IntegerParameter& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_IntegerParameter* 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(ParameterizedType_IntegerParameter* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_IntegerParameter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_IntegerParameter& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_IntegerParameter& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_IntegerParameter* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.IntegerParameter"; - } - protected: - explicit ParameterizedType_IntegerParameter(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kNameFieldNumber = 1, - kRangeStartInclusiveFieldNumber = 2, - kRangeEndExclusiveFieldNumber = 3, - }; - // string name = 1; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; - bool has_range_start_inclusive() const; - private: - bool _internal_has_range_start_inclusive() const; - public: - void clear_range_start_inclusive(); - const ::substrait::ParameterizedType_NullableInteger& range_start_inclusive() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_NullableInteger* release_range_start_inclusive(); - ::substrait::ParameterizedType_NullableInteger* mutable_range_start_inclusive(); - void set_allocated_range_start_inclusive(::substrait::ParameterizedType_NullableInteger* range_start_inclusive); - private: - const ::substrait::ParameterizedType_NullableInteger& _internal_range_start_inclusive() const; - ::substrait::ParameterizedType_NullableInteger* _internal_mutable_range_start_inclusive(); - public: - void unsafe_arena_set_allocated_range_start_inclusive( - ::substrait::ParameterizedType_NullableInteger* range_start_inclusive); - ::substrait::ParameterizedType_NullableInteger* unsafe_arena_release_range_start_inclusive(); - - // .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; - bool has_range_end_exclusive() const; - private: - bool _internal_has_range_end_exclusive() const; - public: - void clear_range_end_exclusive(); - const ::substrait::ParameterizedType_NullableInteger& range_end_exclusive() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_NullableInteger* release_range_end_exclusive(); - ::substrait::ParameterizedType_NullableInteger* mutable_range_end_exclusive(); - void set_allocated_range_end_exclusive(::substrait::ParameterizedType_NullableInteger* range_end_exclusive); - private: - const ::substrait::ParameterizedType_NullableInteger& _internal_range_end_exclusive() const; - ::substrait::ParameterizedType_NullableInteger* _internal_mutable_range_end_exclusive(); - public: - void unsafe_arena_set_allocated_range_end_exclusive( - ::substrait::ParameterizedType_NullableInteger* range_end_exclusive); - ::substrait::ParameterizedType_NullableInteger* unsafe_arena_release_range_end_exclusive(); - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.IntegerParameter) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::substrait::ParameterizedType_NullableInteger* range_start_inclusive_; - ::substrait::ParameterizedType_NullableInteger* range_end_exclusive_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_NullableInteger final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.NullableInteger) */ { - public: - inline ParameterizedType_NullableInteger() : ParameterizedType_NullableInteger(nullptr) {} - ~ParameterizedType_NullableInteger() override; - explicit constexpr ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_NullableInteger(const ParameterizedType_NullableInteger& from); - ParameterizedType_NullableInteger(ParameterizedType_NullableInteger&& from) noexcept - : ParameterizedType_NullableInteger() { - *this = ::std::move(from); - } - - inline ParameterizedType_NullableInteger& operator=(const ParameterizedType_NullableInteger& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_NullableInteger& operator=(ParameterizedType_NullableInteger&& 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 ParameterizedType_NullableInteger& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_NullableInteger* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_NullableInteger_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(ParameterizedType_NullableInteger& a, ParameterizedType_NullableInteger& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_NullableInteger* 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(ParameterizedType_NullableInteger* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_NullableInteger* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_NullableInteger& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_NullableInteger& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_NullableInteger* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.NullableInteger"; - } - protected: - explicit ParameterizedType_NullableInteger(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kValueFieldNumber = 1, - }; - // int64 value = 1; - void clear_value(); - int64_t value() const; - void set_value(int64_t value); - private: - int64_t _internal_value() const; - void _internal_set_value(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.NullableInteger) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int64_t value_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_ParameterizedFixedChar final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedFixedChar) */ { - public: - inline ParameterizedType_ParameterizedFixedChar() : ParameterizedType_ParameterizedFixedChar(nullptr) {} - ~ParameterizedType_ParameterizedFixedChar() override; - explicit constexpr ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_ParameterizedFixedChar(const ParameterizedType_ParameterizedFixedChar& from); - ParameterizedType_ParameterizedFixedChar(ParameterizedType_ParameterizedFixedChar&& from) noexcept - : ParameterizedType_ParameterizedFixedChar() { - *this = ::std::move(from); - } - - inline ParameterizedType_ParameterizedFixedChar& operator=(const ParameterizedType_ParameterizedFixedChar& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_ParameterizedFixedChar& operator=(ParameterizedType_ParameterizedFixedChar&& 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 ParameterizedType_ParameterizedFixedChar& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_ParameterizedFixedChar* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_ParameterizedFixedChar_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(ParameterizedType_ParameterizedFixedChar& a, ParameterizedType_ParameterizedFixedChar& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_ParameterizedFixedChar* 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(ParameterizedType_ParameterizedFixedChar* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_ParameterizedFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_ParameterizedFixedChar& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_ParameterizedFixedChar& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_ParameterizedFixedChar* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.ParameterizedFixedChar"; - } - protected: - explicit ParameterizedType_ParameterizedFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLengthFieldNumber = 1, - kVariationPointerFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // .substrait.ParameterizedType.IntegerOption length = 1; - bool has_length() const; - private: - bool _internal_has_length() const; - public: - void clear_length(); - const ::substrait::ParameterizedType_IntegerOption& length() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_length(); - ::substrait::ParameterizedType_IntegerOption* mutable_length(); - void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length); - private: - const ::substrait::ParameterizedType_IntegerOption& _internal_length() const; - ::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); - public: - void unsafe_arena_set_allocated_length( - ::substrait::ParameterizedType_IntegerOption* length); - ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); - - // uint32 variation_pointer = 2; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedFixedChar) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::ParameterizedType_IntegerOption* length_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_ParameterizedVarChar final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedVarChar) */ { - public: - inline ParameterizedType_ParameterizedVarChar() : ParameterizedType_ParameterizedVarChar(nullptr) {} - ~ParameterizedType_ParameterizedVarChar() override; - explicit constexpr ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_ParameterizedVarChar(const ParameterizedType_ParameterizedVarChar& from); - ParameterizedType_ParameterizedVarChar(ParameterizedType_ParameterizedVarChar&& from) noexcept - : ParameterizedType_ParameterizedVarChar() { - *this = ::std::move(from); - } - - inline ParameterizedType_ParameterizedVarChar& operator=(const ParameterizedType_ParameterizedVarChar& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_ParameterizedVarChar& operator=(ParameterizedType_ParameterizedVarChar&& 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 ParameterizedType_ParameterizedVarChar& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_ParameterizedVarChar* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_ParameterizedVarChar_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(ParameterizedType_ParameterizedVarChar& a, ParameterizedType_ParameterizedVarChar& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_ParameterizedVarChar* 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(ParameterizedType_ParameterizedVarChar* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_ParameterizedVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_ParameterizedVarChar& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_ParameterizedVarChar& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_ParameterizedVarChar* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.ParameterizedVarChar"; - } - protected: - explicit ParameterizedType_ParameterizedVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLengthFieldNumber = 1, - kVariationPointerFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // .substrait.ParameterizedType.IntegerOption length = 1; - bool has_length() const; - private: - bool _internal_has_length() const; - public: - void clear_length(); - const ::substrait::ParameterizedType_IntegerOption& length() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_length(); - ::substrait::ParameterizedType_IntegerOption* mutable_length(); - void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length); - private: - const ::substrait::ParameterizedType_IntegerOption& _internal_length() const; - ::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); - public: - void unsafe_arena_set_allocated_length( - ::substrait::ParameterizedType_IntegerOption* length); - ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); - - // uint32 variation_pointer = 2; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedVarChar) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::ParameterizedType_IntegerOption* length_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_ParameterizedFixedBinary final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedFixedBinary) */ { - public: - inline ParameterizedType_ParameterizedFixedBinary() : ParameterizedType_ParameterizedFixedBinary(nullptr) {} - ~ParameterizedType_ParameterizedFixedBinary() override; - explicit constexpr ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_ParameterizedFixedBinary(const ParameterizedType_ParameterizedFixedBinary& from); - ParameterizedType_ParameterizedFixedBinary(ParameterizedType_ParameterizedFixedBinary&& from) noexcept - : ParameterizedType_ParameterizedFixedBinary() { - *this = ::std::move(from); - } - - inline ParameterizedType_ParameterizedFixedBinary& operator=(const ParameterizedType_ParameterizedFixedBinary& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_ParameterizedFixedBinary& operator=(ParameterizedType_ParameterizedFixedBinary&& 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 ParameterizedType_ParameterizedFixedBinary& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_ParameterizedFixedBinary* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_ParameterizedFixedBinary_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(ParameterizedType_ParameterizedFixedBinary& a, ParameterizedType_ParameterizedFixedBinary& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_ParameterizedFixedBinary* 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(ParameterizedType_ParameterizedFixedBinary* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_ParameterizedFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_ParameterizedFixedBinary& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_ParameterizedFixedBinary& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_ParameterizedFixedBinary* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.ParameterizedFixedBinary"; - } - protected: - explicit ParameterizedType_ParameterizedFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLengthFieldNumber = 1, - kVariationPointerFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // .substrait.ParameterizedType.IntegerOption length = 1; - bool has_length() const; - private: - bool _internal_has_length() const; - public: - void clear_length(); - const ::substrait::ParameterizedType_IntegerOption& length() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_length(); - ::substrait::ParameterizedType_IntegerOption* mutable_length(); - void set_allocated_length(::substrait::ParameterizedType_IntegerOption* length); - private: - const ::substrait::ParameterizedType_IntegerOption& _internal_length() const; - ::substrait::ParameterizedType_IntegerOption* _internal_mutable_length(); - public: - void unsafe_arena_set_allocated_length( - ::substrait::ParameterizedType_IntegerOption* length); - ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_length(); - - // uint32 variation_pointer = 2; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedFixedBinary) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::ParameterizedType_IntegerOption* length_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_ParameterizedDecimal final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedDecimal) */ { - public: - inline ParameterizedType_ParameterizedDecimal() : ParameterizedType_ParameterizedDecimal(nullptr) {} - ~ParameterizedType_ParameterizedDecimal() override; - explicit constexpr ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_ParameterizedDecimal(const ParameterizedType_ParameterizedDecimal& from); - ParameterizedType_ParameterizedDecimal(ParameterizedType_ParameterizedDecimal&& from) noexcept - : ParameterizedType_ParameterizedDecimal() { - *this = ::std::move(from); - } - - inline ParameterizedType_ParameterizedDecimal& operator=(const ParameterizedType_ParameterizedDecimal& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_ParameterizedDecimal& operator=(ParameterizedType_ParameterizedDecimal&& 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 ParameterizedType_ParameterizedDecimal& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_ParameterizedDecimal* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_ParameterizedDecimal_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(ParameterizedType_ParameterizedDecimal& a, ParameterizedType_ParameterizedDecimal& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_ParameterizedDecimal* 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(ParameterizedType_ParameterizedDecimal* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_ParameterizedDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_ParameterizedDecimal& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_ParameterizedDecimal& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_ParameterizedDecimal* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.ParameterizedDecimal"; - } - protected: - explicit ParameterizedType_ParameterizedDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kScaleFieldNumber = 1, - kPrecisionFieldNumber = 2, - kVariationPointerFieldNumber = 3, - kNullabilityFieldNumber = 4, - }; - // .substrait.ParameterizedType.IntegerOption scale = 1; - bool has_scale() const; - private: - bool _internal_has_scale() const; - public: - void clear_scale(); - const ::substrait::ParameterizedType_IntegerOption& scale() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_scale(); - ::substrait::ParameterizedType_IntegerOption* mutable_scale(); - void set_allocated_scale(::substrait::ParameterizedType_IntegerOption* scale); - private: - const ::substrait::ParameterizedType_IntegerOption& _internal_scale() const; - ::substrait::ParameterizedType_IntegerOption* _internal_mutable_scale(); - public: - void unsafe_arena_set_allocated_scale( - ::substrait::ParameterizedType_IntegerOption* scale); - ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_scale(); - - // .substrait.ParameterizedType.IntegerOption precision = 2; - bool has_precision() const; - private: - bool _internal_has_precision() const; - public: - void clear_precision(); - const ::substrait::ParameterizedType_IntegerOption& precision() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerOption* release_precision(); - ::substrait::ParameterizedType_IntegerOption* mutable_precision(); - void set_allocated_precision(::substrait::ParameterizedType_IntegerOption* precision); - private: - const ::substrait::ParameterizedType_IntegerOption& _internal_precision() const; - ::substrait::ParameterizedType_IntegerOption* _internal_mutable_precision(); - public: - void unsafe_arena_set_allocated_precision( - ::substrait::ParameterizedType_IntegerOption* precision); - ::substrait::ParameterizedType_IntegerOption* unsafe_arena_release_precision(); - - // uint32 variation_pointer = 3; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 4; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedDecimal) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::ParameterizedType_IntegerOption* scale_; - ::substrait::ParameterizedType_IntegerOption* precision_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_ParameterizedStruct final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedStruct) */ { - public: - inline ParameterizedType_ParameterizedStruct() : ParameterizedType_ParameterizedStruct(nullptr) {} - ~ParameterizedType_ParameterizedStruct() override; - explicit constexpr ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_ParameterizedStruct(const ParameterizedType_ParameterizedStruct& from); - ParameterizedType_ParameterizedStruct(ParameterizedType_ParameterizedStruct&& from) noexcept - : ParameterizedType_ParameterizedStruct() { - *this = ::std::move(from); - } - - inline ParameterizedType_ParameterizedStruct& operator=(const ParameterizedType_ParameterizedStruct& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_ParameterizedStruct& operator=(ParameterizedType_ParameterizedStruct&& 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 ParameterizedType_ParameterizedStruct& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_ParameterizedStruct* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_ParameterizedStruct_default_instance_); - } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(ParameterizedType_ParameterizedStruct& a, ParameterizedType_ParameterizedStruct& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_ParameterizedStruct* 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(ParameterizedType_ParameterizedStruct* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_ParameterizedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_ParameterizedStruct& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_ParameterizedStruct& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_ParameterizedStruct* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.ParameterizedStruct"; - } - protected: - explicit ParameterizedType_ParameterizedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypesFieldNumber = 1, - kVariationPointerFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // repeated .substrait.ParameterizedType types = 1; - int types_size() const; - private: - int _internal_types_size() const; - public: - void clear_types(); - ::substrait::ParameterizedType* mutable_types(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >* - mutable_types(); - private: - const ::substrait::ParameterizedType& _internal_types(int index) const; - ::substrait::ParameterizedType* _internal_add_types(); - public: - const ::substrait::ParameterizedType& types(int index) const; - ::substrait::ParameterizedType* add_types(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >& - types() const; - - // uint32 variation_pointer = 2; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedStruct) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType > types_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_ParameterizedNamedStruct final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedNamedStruct) */ { - public: - inline ParameterizedType_ParameterizedNamedStruct() : ParameterizedType_ParameterizedNamedStruct(nullptr) {} - ~ParameterizedType_ParameterizedNamedStruct() override; - explicit constexpr ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_ParameterizedNamedStruct(const ParameterizedType_ParameterizedNamedStruct& from); - ParameterizedType_ParameterizedNamedStruct(ParameterizedType_ParameterizedNamedStruct&& from) noexcept - : ParameterizedType_ParameterizedNamedStruct() { - *this = ::std::move(from); - } - - inline ParameterizedType_ParameterizedNamedStruct& operator=(const ParameterizedType_ParameterizedNamedStruct& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_ParameterizedNamedStruct& operator=(ParameterizedType_ParameterizedNamedStruct&& 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 ParameterizedType_ParameterizedNamedStruct& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_ParameterizedNamedStruct* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_ParameterizedNamedStruct_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(ParameterizedType_ParameterizedNamedStruct& a, ParameterizedType_ParameterizedNamedStruct& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_ParameterizedNamedStruct* 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(ParameterizedType_ParameterizedNamedStruct* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_ParameterizedNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_ParameterizedNamedStruct& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_ParameterizedNamedStruct& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_ParameterizedNamedStruct* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.ParameterizedNamedStruct"; - } - protected: - explicit ParameterizedType_ParameterizedNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kNamesFieldNumber = 1, - kStructFieldNumber = 2, - }; - // repeated string names = 1; - int names_size() const; - private: - int _internal_names_size() const; - public: - void clear_names(); - const std::string& names(int index) const; - std::string* mutable_names(int index); - void set_names(int index, const std::string& value); - void set_names(int index, std::string&& value); - void set_names(int index, const char* value); - void set_names(int index, const char* value, size_t size); - std::string* add_names(); - void add_names(const std::string& value); - void add_names(std::string&& value); - void add_names(const char* value); - void add_names(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); - private: - const std::string& _internal_names(int index) const; - std::string* _internal_add_names(); - public: - - // .substrait.ParameterizedType.ParameterizedStruct struct = 2; - bool has_struct_() const; - private: - bool _internal_has_struct_() const; - public: - void clear_struct_(); - const ::substrait::ParameterizedType_ParameterizedStruct& struct_() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); - ::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_(); - void set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_); - private: - const ::substrait::ParameterizedType_ParameterizedStruct& _internal_struct_() const; - ::substrait::ParameterizedType_ParameterizedStruct* _internal_mutable_struct_(); - public: - void unsafe_arena_set_allocated_struct_( - ::substrait::ParameterizedType_ParameterizedStruct* struct_); - ::substrait::ParameterizedType_ParameterizedStruct* unsafe_arena_release_struct_(); - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedNamedStruct) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::substrait::ParameterizedType_ParameterizedStruct* struct__; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_ParameterizedList final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedList) */ { - public: - inline ParameterizedType_ParameterizedList() : ParameterizedType_ParameterizedList(nullptr) {} - ~ParameterizedType_ParameterizedList() override; - explicit constexpr ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_ParameterizedList(const ParameterizedType_ParameterizedList& from); - ParameterizedType_ParameterizedList(ParameterizedType_ParameterizedList&& from) noexcept - : ParameterizedType_ParameterizedList() { - *this = ::std::move(from); - } - - inline ParameterizedType_ParameterizedList& operator=(const ParameterizedType_ParameterizedList& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_ParameterizedList& operator=(ParameterizedType_ParameterizedList&& 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 ParameterizedType_ParameterizedList& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_ParameterizedList* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_ParameterizedList_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(ParameterizedType_ParameterizedList& a, ParameterizedType_ParameterizedList& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_ParameterizedList* 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(ParameterizedType_ParameterizedList* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_ParameterizedList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_ParameterizedList& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_ParameterizedList& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_ParameterizedList* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.ParameterizedList"; - } - protected: - explicit ParameterizedType_ParameterizedList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeFieldNumber = 1, - kVariationPointerFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // .substrait.ParameterizedType type = 1; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - const ::substrait::ParameterizedType& type() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_type(); - ::substrait::ParameterizedType* mutable_type(); - void set_allocated_type(::substrait::ParameterizedType* type); - private: - const ::substrait::ParameterizedType& _internal_type() const; - ::substrait::ParameterizedType* _internal_mutable_type(); - public: - void unsafe_arena_set_allocated_type( - ::substrait::ParameterizedType* type); - ::substrait::ParameterizedType* unsafe_arena_release_type(); - - // uint32 variation_pointer = 2; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedList) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::ParameterizedType* type_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_ParameterizedMap final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.ParameterizedMap) */ { - public: - inline ParameterizedType_ParameterizedMap() : ParameterizedType_ParameterizedMap(nullptr) {} - ~ParameterizedType_ParameterizedMap() override; - explicit constexpr ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_ParameterizedMap(const ParameterizedType_ParameterizedMap& from); - ParameterizedType_ParameterizedMap(ParameterizedType_ParameterizedMap&& from) noexcept - : ParameterizedType_ParameterizedMap() { - *this = ::std::move(from); - } - - inline ParameterizedType_ParameterizedMap& operator=(const ParameterizedType_ParameterizedMap& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_ParameterizedMap& operator=(ParameterizedType_ParameterizedMap&& 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 ParameterizedType_ParameterizedMap& default_instance() { - return *internal_default_instance(); - } - static inline const ParameterizedType_ParameterizedMap* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_ParameterizedMap_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(ParameterizedType_ParameterizedMap& a, ParameterizedType_ParameterizedMap& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_ParameterizedMap* 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(ParameterizedType_ParameterizedMap* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_ParameterizedMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_ParameterizedMap& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_ParameterizedMap& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_ParameterizedMap* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.ParameterizedMap"; - } - protected: - explicit ParameterizedType_ParameterizedMap(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kKeyFieldNumber = 1, - kValueFieldNumber = 2, - kVariationPointerFieldNumber = 3, - kNullabilityFieldNumber = 4, - }; - // .substrait.ParameterizedType key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::substrait::ParameterizedType& key() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_key(); - ::substrait::ParameterizedType* mutable_key(); - void set_allocated_key(::substrait::ParameterizedType* key); - private: - const ::substrait::ParameterizedType& _internal_key() const; - ::substrait::ParameterizedType* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::substrait::ParameterizedType* key); - ::substrait::ParameterizedType* unsafe_arena_release_key(); - - // .substrait.ParameterizedType value = 2; - bool has_value() const; - private: - bool _internal_has_value() const; - public: - void clear_value(); - const ::substrait::ParameterizedType& value() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType* release_value(); - ::substrait::ParameterizedType* mutable_value(); - void set_allocated_value(::substrait::ParameterizedType* value); - private: - const ::substrait::ParameterizedType& _internal_value() const; - ::substrait::ParameterizedType* _internal_mutable_value(); - public: - void unsafe_arena_set_allocated_value( - ::substrait::ParameterizedType* value); - ::substrait::ParameterizedType* unsafe_arena_release_value(); - - // uint32 variation_pointer = 3; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 4; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.ParameterizedMap) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::ParameterizedType* key_; - ::substrait::ParameterizedType* value_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType_IntegerOption final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType.IntegerOption) */ { - public: - inline ParameterizedType_IntegerOption() : ParameterizedType_IntegerOption(nullptr) {} - ~ParameterizedType_IntegerOption() override; - explicit constexpr ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType_IntegerOption(const ParameterizedType_IntegerOption& from); - ParameterizedType_IntegerOption(ParameterizedType_IntegerOption&& from) noexcept - : ParameterizedType_IntegerOption() { - *this = ::std::move(from); - } - - inline ParameterizedType_IntegerOption& operator=(const ParameterizedType_IntegerOption& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType_IntegerOption& operator=(ParameterizedType_IntegerOption&& 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 ParameterizedType_IntegerOption& default_instance() { - return *internal_default_instance(); - } - enum IntegerTypeCase { - kLiteral = 1, - kParameter = 2, - INTEGER_TYPE_NOT_SET = 0, - }; - - static inline const ParameterizedType_IntegerOption* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_IntegerOption_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(ParameterizedType_IntegerOption& a, ParameterizedType_IntegerOption& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType_IntegerOption* 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(ParameterizedType_IntegerOption* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType_IntegerOption* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType_IntegerOption& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType_IntegerOption& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType_IntegerOption* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType.IntegerOption"; - } - protected: - explicit ParameterizedType_IntegerOption(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLiteralFieldNumber = 1, - kParameterFieldNumber = 2, - }; - // int32 literal = 1; - bool has_literal() const; - private: - bool _internal_has_literal() const; - public: - void clear_literal(); - int32_t literal() const; - void set_literal(int32_t value); - private: - int32_t _internal_literal() const; - void _internal_set_literal(int32_t value); - public: - - // .substrait.ParameterizedType.IntegerParameter parameter = 2; - bool has_parameter() const; - private: - bool _internal_has_parameter() const; - public: - void clear_parameter(); - const ::substrait::ParameterizedType_IntegerParameter& parameter() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_IntegerParameter* release_parameter(); - ::substrait::ParameterizedType_IntegerParameter* mutable_parameter(); - void set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter); - private: - const ::substrait::ParameterizedType_IntegerParameter& _internal_parameter() const; - ::substrait::ParameterizedType_IntegerParameter* _internal_mutable_parameter(); - public: - void unsafe_arena_set_allocated_parameter( - ::substrait::ParameterizedType_IntegerParameter* parameter); - ::substrait::ParameterizedType_IntegerParameter* unsafe_arena_release_parameter(); - - void clear_integer_type(); - IntegerTypeCase integer_type_case() const; - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType.IntegerOption) - private: - class _Internal; - void set_has_literal(); - void set_has_parameter(); - - inline bool has_integer_type() const; - inline void clear_has_integer_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union IntegerTypeUnion { - constexpr IntegerTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - int32_t literal_; - ::substrait::ParameterizedType_IntegerParameter* parameter_; - } integer_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// ------------------------------------------------------------------- - -class ParameterizedType final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ParameterizedType) */ { - public: - inline ParameterizedType() : ParameterizedType(nullptr) {} - ~ParameterizedType() override; - explicit constexpr ParameterizedType(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ParameterizedType(const ParameterizedType& from); - ParameterizedType(ParameterizedType&& from) noexcept - : ParameterizedType() { - *this = ::std::move(from); - } - - inline ParameterizedType& operator=(const ParameterizedType& from) { - CopyFrom(from); - return *this; - } - inline ParameterizedType& operator=(ParameterizedType&& 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 ParameterizedType& default_instance() { - return *internal_default_instance(); - } - enum KindCase { - kBool = 1, - kI8 = 2, - kI16 = 3, - kI32 = 5, - kI64 = 7, - kFp32 = 10, - kFp64 = 11, - kString = 12, - kBinary = 13, - kTimestamp = 14, - kDate = 16, - kTime = 17, - kIntervalYear = 19, - kIntervalDay = 20, - kTimestampTz = 29, - kUuid = 32, - kFixedChar = 21, - kVarchar = 22, - kFixedBinary = 23, - kDecimal = 24, - kStruct = 25, - kList = 27, - kMap = 28, - kUserDefinedPointer = 31, - kTypeParameter = 33, - KIND_NOT_SET = 0, - }; - - static inline const ParameterizedType* internal_default_instance() { - return reinterpret_cast( - &_ParameterizedType_default_instance_); - } - static constexpr int kIndexInFileMessages = - 12; - - friend void swap(ParameterizedType& a, ParameterizedType& b) { - a.Swap(&b); - } - inline void Swap(ParameterizedType* 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(ParameterizedType* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ParameterizedType* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ParameterizedType& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ParameterizedType& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ParameterizedType* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ParameterizedType"; - } - protected: - explicit ParameterizedType(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ParameterizedType_TypeParameter TypeParameter; - typedef ParameterizedType_IntegerParameter IntegerParameter; - typedef ParameterizedType_NullableInteger NullableInteger; - typedef ParameterizedType_ParameterizedFixedChar ParameterizedFixedChar; - typedef ParameterizedType_ParameterizedVarChar ParameterizedVarChar; - typedef ParameterizedType_ParameterizedFixedBinary ParameterizedFixedBinary; - typedef ParameterizedType_ParameterizedDecimal ParameterizedDecimal; - typedef ParameterizedType_ParameterizedStruct ParameterizedStruct; - typedef ParameterizedType_ParameterizedNamedStruct ParameterizedNamedStruct; - typedef ParameterizedType_ParameterizedList ParameterizedList; - typedef ParameterizedType_ParameterizedMap ParameterizedMap; - typedef ParameterizedType_IntegerOption IntegerOption; - - // accessors ------------------------------------------------------- - - enum : int { - kBoolFieldNumber = 1, - kI8FieldNumber = 2, - kI16FieldNumber = 3, - kI32FieldNumber = 5, - kI64FieldNumber = 7, - kFp32FieldNumber = 10, - kFp64FieldNumber = 11, - kStringFieldNumber = 12, - kBinaryFieldNumber = 13, - kTimestampFieldNumber = 14, - kDateFieldNumber = 16, - kTimeFieldNumber = 17, - kIntervalYearFieldNumber = 19, - kIntervalDayFieldNumber = 20, - kTimestampTzFieldNumber = 29, - kUuidFieldNumber = 32, - kFixedCharFieldNumber = 21, - kVarcharFieldNumber = 22, - kFixedBinaryFieldNumber = 23, - kDecimalFieldNumber = 24, - kStructFieldNumber = 25, - kListFieldNumber = 27, - kMapFieldNumber = 28, - kUserDefinedPointerFieldNumber = 31, - kTypeParameterFieldNumber = 33, - }; - // .substrait.Type.Boolean bool = 1; - bool has_bool_() const; - private: - bool _internal_has_bool_() const; - public: - void clear_bool_(); - const ::substrait::Type_Boolean& bool_() const; - PROTOBUF_NODISCARD ::substrait::Type_Boolean* release_bool_(); - ::substrait::Type_Boolean* mutable_bool_(); - void set_allocated_bool_(::substrait::Type_Boolean* bool_); - private: - const ::substrait::Type_Boolean& _internal_bool_() const; - ::substrait::Type_Boolean* _internal_mutable_bool_(); - public: - void unsafe_arena_set_allocated_bool_( - ::substrait::Type_Boolean* bool_); - ::substrait::Type_Boolean* unsafe_arena_release_bool_(); - - // .substrait.Type.I8 i8 = 2; - bool has_i8() const; - private: - bool _internal_has_i8() const; - public: - void clear_i8(); - const ::substrait::Type_I8& i8() const; - PROTOBUF_NODISCARD ::substrait::Type_I8* release_i8(); - ::substrait::Type_I8* mutable_i8(); - void set_allocated_i8(::substrait::Type_I8* i8); - private: - const ::substrait::Type_I8& _internal_i8() const; - ::substrait::Type_I8* _internal_mutable_i8(); - public: - void unsafe_arena_set_allocated_i8( - ::substrait::Type_I8* i8); - ::substrait::Type_I8* unsafe_arena_release_i8(); - - // .substrait.Type.I16 i16 = 3; - bool has_i16() const; - private: - bool _internal_has_i16() const; - public: - void clear_i16(); - const ::substrait::Type_I16& i16() const; - PROTOBUF_NODISCARD ::substrait::Type_I16* release_i16(); - ::substrait::Type_I16* mutable_i16(); - void set_allocated_i16(::substrait::Type_I16* i16); - private: - const ::substrait::Type_I16& _internal_i16() const; - ::substrait::Type_I16* _internal_mutable_i16(); - public: - void unsafe_arena_set_allocated_i16( - ::substrait::Type_I16* i16); - ::substrait::Type_I16* unsafe_arena_release_i16(); - - // .substrait.Type.I32 i32 = 5; - bool has_i32() const; - private: - bool _internal_has_i32() const; - public: - void clear_i32(); - const ::substrait::Type_I32& i32() const; - PROTOBUF_NODISCARD ::substrait::Type_I32* release_i32(); - ::substrait::Type_I32* mutable_i32(); - void set_allocated_i32(::substrait::Type_I32* i32); - private: - const ::substrait::Type_I32& _internal_i32() const; - ::substrait::Type_I32* _internal_mutable_i32(); - public: - void unsafe_arena_set_allocated_i32( - ::substrait::Type_I32* i32); - ::substrait::Type_I32* unsafe_arena_release_i32(); - - // .substrait.Type.I64 i64 = 7; - bool has_i64() const; - private: - bool _internal_has_i64() const; - public: - void clear_i64(); - const ::substrait::Type_I64& i64() const; - PROTOBUF_NODISCARD ::substrait::Type_I64* release_i64(); - ::substrait::Type_I64* mutable_i64(); - void set_allocated_i64(::substrait::Type_I64* i64); - private: - const ::substrait::Type_I64& _internal_i64() const; - ::substrait::Type_I64* _internal_mutable_i64(); - public: - void unsafe_arena_set_allocated_i64( - ::substrait::Type_I64* i64); - ::substrait::Type_I64* unsafe_arena_release_i64(); - - // .substrait.Type.FP32 fp32 = 10; - bool has_fp32() const; - private: - bool _internal_has_fp32() const; - public: - void clear_fp32(); - const ::substrait::Type_FP32& fp32() const; - PROTOBUF_NODISCARD ::substrait::Type_FP32* release_fp32(); - ::substrait::Type_FP32* mutable_fp32(); - void set_allocated_fp32(::substrait::Type_FP32* fp32); - private: - const ::substrait::Type_FP32& _internal_fp32() const; - ::substrait::Type_FP32* _internal_mutable_fp32(); - public: - void unsafe_arena_set_allocated_fp32( - ::substrait::Type_FP32* fp32); - ::substrait::Type_FP32* unsafe_arena_release_fp32(); - - // .substrait.Type.FP64 fp64 = 11; - bool has_fp64() const; - private: - bool _internal_has_fp64() const; - public: - void clear_fp64(); - const ::substrait::Type_FP64& fp64() const; - PROTOBUF_NODISCARD ::substrait::Type_FP64* release_fp64(); - ::substrait::Type_FP64* mutable_fp64(); - void set_allocated_fp64(::substrait::Type_FP64* fp64); - private: - const ::substrait::Type_FP64& _internal_fp64() const; - ::substrait::Type_FP64* _internal_mutable_fp64(); - public: - void unsafe_arena_set_allocated_fp64( - ::substrait::Type_FP64* fp64); - ::substrait::Type_FP64* unsafe_arena_release_fp64(); - - // .substrait.Type.String string = 12; - bool has_string() const; - private: - bool _internal_has_string() const; - public: - void clear_string(); - const ::substrait::Type_String& string() const; - PROTOBUF_NODISCARD ::substrait::Type_String* release_string(); - ::substrait::Type_String* mutable_string(); - void set_allocated_string(::substrait::Type_String* string); - private: - const ::substrait::Type_String& _internal_string() const; - ::substrait::Type_String* _internal_mutable_string(); - public: - void unsafe_arena_set_allocated_string( - ::substrait::Type_String* string); - ::substrait::Type_String* unsafe_arena_release_string(); - - // .substrait.Type.Binary binary = 13; - bool has_binary() const; - private: - bool _internal_has_binary() const; - public: - void clear_binary(); - const ::substrait::Type_Binary& binary() const; - PROTOBUF_NODISCARD ::substrait::Type_Binary* release_binary(); - ::substrait::Type_Binary* mutable_binary(); - void set_allocated_binary(::substrait::Type_Binary* binary); - private: - const ::substrait::Type_Binary& _internal_binary() const; - ::substrait::Type_Binary* _internal_mutable_binary(); - public: - void unsafe_arena_set_allocated_binary( - ::substrait::Type_Binary* binary); - ::substrait::Type_Binary* unsafe_arena_release_binary(); - - // .substrait.Type.Timestamp timestamp = 14; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - const ::substrait::Type_Timestamp& timestamp() const; - PROTOBUF_NODISCARD ::substrait::Type_Timestamp* release_timestamp(); - ::substrait::Type_Timestamp* mutable_timestamp(); - void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp); - private: - const ::substrait::Type_Timestamp& _internal_timestamp() const; - ::substrait::Type_Timestamp* _internal_mutable_timestamp(); - public: - void unsafe_arena_set_allocated_timestamp( - ::substrait::Type_Timestamp* timestamp); - ::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); - - // .substrait.Type.Date date = 16; - bool has_date() const; - private: - bool _internal_has_date() const; - public: - void clear_date(); - const ::substrait::Type_Date& date() const; - PROTOBUF_NODISCARD ::substrait::Type_Date* release_date(); - ::substrait::Type_Date* mutable_date(); - void set_allocated_date(::substrait::Type_Date* date); - private: - const ::substrait::Type_Date& _internal_date() const; - ::substrait::Type_Date* _internal_mutable_date(); - public: - void unsafe_arena_set_allocated_date( - ::substrait::Type_Date* date); - ::substrait::Type_Date* unsafe_arena_release_date(); - - // .substrait.Type.Time time = 17; - bool has_time() const; - private: - bool _internal_has_time() const; - public: - void clear_time(); - const ::substrait::Type_Time& time() const; - PROTOBUF_NODISCARD ::substrait::Type_Time* release_time(); - ::substrait::Type_Time* mutable_time(); - void set_allocated_time(::substrait::Type_Time* time); - private: - const ::substrait::Type_Time& _internal_time() const; - ::substrait::Type_Time* _internal_mutable_time(); - public: - void unsafe_arena_set_allocated_time( - ::substrait::Type_Time* time); - ::substrait::Type_Time* unsafe_arena_release_time(); - - // .substrait.Type.IntervalYear interval_year = 19; - bool has_interval_year() const; - private: - bool _internal_has_interval_year() const; - public: - void clear_interval_year(); - const ::substrait::Type_IntervalYear& interval_year() const; - PROTOBUF_NODISCARD ::substrait::Type_IntervalYear* release_interval_year(); - ::substrait::Type_IntervalYear* mutable_interval_year(); - void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year); - private: - const ::substrait::Type_IntervalYear& _internal_interval_year() const; - ::substrait::Type_IntervalYear* _internal_mutable_interval_year(); - public: - void unsafe_arena_set_allocated_interval_year( - ::substrait::Type_IntervalYear* interval_year); - ::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); - - // .substrait.Type.IntervalDay interval_day = 20; - bool has_interval_day() const; - private: - bool _internal_has_interval_day() const; - public: - void clear_interval_day(); - const ::substrait::Type_IntervalDay& interval_day() const; - PROTOBUF_NODISCARD ::substrait::Type_IntervalDay* release_interval_day(); - ::substrait::Type_IntervalDay* mutable_interval_day(); - void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day); - private: - const ::substrait::Type_IntervalDay& _internal_interval_day() const; - ::substrait::Type_IntervalDay* _internal_mutable_interval_day(); - public: - void unsafe_arena_set_allocated_interval_day( - ::substrait::Type_IntervalDay* interval_day); - ::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); - - // .substrait.Type.TimestampTZ timestamp_tz = 29; - bool has_timestamp_tz() const; - private: - bool _internal_has_timestamp_tz() const; - public: - void clear_timestamp_tz(); - const ::substrait::Type_TimestampTZ& timestamp_tz() const; - PROTOBUF_NODISCARD ::substrait::Type_TimestampTZ* release_timestamp_tz(); - ::substrait::Type_TimestampTZ* mutable_timestamp_tz(); - void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz); - private: - const ::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; - ::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); - public: - void unsafe_arena_set_allocated_timestamp_tz( - ::substrait::Type_TimestampTZ* timestamp_tz); - ::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); - - // .substrait.Type.UUID uuid = 32; - bool has_uuid() const; - private: - bool _internal_has_uuid() const; - public: - void clear_uuid(); - const ::substrait::Type_UUID& uuid() const; - PROTOBUF_NODISCARD ::substrait::Type_UUID* release_uuid(); - ::substrait::Type_UUID* mutable_uuid(); - void set_allocated_uuid(::substrait::Type_UUID* uuid); - private: - const ::substrait::Type_UUID& _internal_uuid() const; - ::substrait::Type_UUID* _internal_mutable_uuid(); - public: - void unsafe_arena_set_allocated_uuid( - ::substrait::Type_UUID* uuid); - ::substrait::Type_UUID* unsafe_arena_release_uuid(); - - // .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; - bool has_fixed_char() const; - private: - bool _internal_has_fixed_char() const; - public: - void clear_fixed_char(); - const ::substrait::ParameterizedType_ParameterizedFixedChar& fixed_char() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedFixedChar* release_fixed_char(); - ::substrait::ParameterizedType_ParameterizedFixedChar* mutable_fixed_char(); - void set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char); - private: - const ::substrait::ParameterizedType_ParameterizedFixedChar& _internal_fixed_char() const; - ::substrait::ParameterizedType_ParameterizedFixedChar* _internal_mutable_fixed_char(); - public: - void unsafe_arena_set_allocated_fixed_char( - ::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char); - ::substrait::ParameterizedType_ParameterizedFixedChar* unsafe_arena_release_fixed_char(); - - // .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; - bool has_varchar() const; - private: - bool _internal_has_varchar() const; - public: - void clear_varchar(); - const ::substrait::ParameterizedType_ParameterizedVarChar& varchar() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedVarChar* release_varchar(); - ::substrait::ParameterizedType_ParameterizedVarChar* mutable_varchar(); - void set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar); - private: - const ::substrait::ParameterizedType_ParameterizedVarChar& _internal_varchar() const; - ::substrait::ParameterizedType_ParameterizedVarChar* _internal_mutable_varchar(); - public: - void unsafe_arena_set_allocated_varchar( - ::substrait::ParameterizedType_ParameterizedVarChar* varchar); - ::substrait::ParameterizedType_ParameterizedVarChar* unsafe_arena_release_varchar(); - - // .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; - bool has_fixed_binary() const; - private: - bool _internal_has_fixed_binary() const; - public: - void clear_fixed_binary(); - const ::substrait::ParameterizedType_ParameterizedFixedBinary& fixed_binary() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedFixedBinary* release_fixed_binary(); - ::substrait::ParameterizedType_ParameterizedFixedBinary* mutable_fixed_binary(); - void set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary); - private: - const ::substrait::ParameterizedType_ParameterizedFixedBinary& _internal_fixed_binary() const; - ::substrait::ParameterizedType_ParameterizedFixedBinary* _internal_mutable_fixed_binary(); - public: - void unsafe_arena_set_allocated_fixed_binary( - ::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary); - ::substrait::ParameterizedType_ParameterizedFixedBinary* unsafe_arena_release_fixed_binary(); - - // .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; - bool has_decimal() const; - private: - bool _internal_has_decimal() const; - public: - void clear_decimal(); - const ::substrait::ParameterizedType_ParameterizedDecimal& decimal() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedDecimal* release_decimal(); - ::substrait::ParameterizedType_ParameterizedDecimal* mutable_decimal(); - void set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal); - private: - const ::substrait::ParameterizedType_ParameterizedDecimal& _internal_decimal() const; - ::substrait::ParameterizedType_ParameterizedDecimal* _internal_mutable_decimal(); - public: - void unsafe_arena_set_allocated_decimal( - ::substrait::ParameterizedType_ParameterizedDecimal* decimal); - ::substrait::ParameterizedType_ParameterizedDecimal* unsafe_arena_release_decimal(); - - // .substrait.ParameterizedType.ParameterizedStruct struct = 25; - bool has_struct_() const; - private: - bool _internal_has_struct_() const; - public: - void clear_struct_(); - const ::substrait::ParameterizedType_ParameterizedStruct& struct_() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedStruct* release_struct_(); - ::substrait::ParameterizedType_ParameterizedStruct* mutable_struct_(); - void set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_); - private: - const ::substrait::ParameterizedType_ParameterizedStruct& _internal_struct_() const; - ::substrait::ParameterizedType_ParameterizedStruct* _internal_mutable_struct_(); - public: - void unsafe_arena_set_allocated_struct_( - ::substrait::ParameterizedType_ParameterizedStruct* struct_); - ::substrait::ParameterizedType_ParameterizedStruct* unsafe_arena_release_struct_(); - - // .substrait.ParameterizedType.ParameterizedList list = 27; - bool has_list() const; - private: - bool _internal_has_list() const; - public: - void clear_list(); - const ::substrait::ParameterizedType_ParameterizedList& list() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedList* release_list(); - ::substrait::ParameterizedType_ParameterizedList* mutable_list(); - void set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list); - private: - const ::substrait::ParameterizedType_ParameterizedList& _internal_list() const; - ::substrait::ParameterizedType_ParameterizedList* _internal_mutable_list(); - public: - void unsafe_arena_set_allocated_list( - ::substrait::ParameterizedType_ParameterizedList* list); - ::substrait::ParameterizedType_ParameterizedList* unsafe_arena_release_list(); - - // .substrait.ParameterizedType.ParameterizedMap map = 28; - bool has_map() const; - private: - bool _internal_has_map() const; - public: - void clear_map(); - const ::substrait::ParameterizedType_ParameterizedMap& map() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_ParameterizedMap* release_map(); - ::substrait::ParameterizedType_ParameterizedMap* mutable_map(); - void set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map); - private: - const ::substrait::ParameterizedType_ParameterizedMap& _internal_map() const; - ::substrait::ParameterizedType_ParameterizedMap* _internal_mutable_map(); - public: - void unsafe_arena_set_allocated_map( - ::substrait::ParameterizedType_ParameterizedMap* map); - ::substrait::ParameterizedType_ParameterizedMap* unsafe_arena_release_map(); - - // uint32 user_defined_pointer = 31; - bool has_user_defined_pointer() const; - private: - bool _internal_has_user_defined_pointer() const; - public: - void clear_user_defined_pointer(); - uint32_t user_defined_pointer() const; - void set_user_defined_pointer(uint32_t value); - private: - uint32_t _internal_user_defined_pointer() const; - void _internal_set_user_defined_pointer(uint32_t value); - public: - - // .substrait.ParameterizedType.TypeParameter type_parameter = 33; - bool has_type_parameter() const; - private: - bool _internal_has_type_parameter() const; - public: - void clear_type_parameter(); - const ::substrait::ParameterizedType_TypeParameter& type_parameter() const; - PROTOBUF_NODISCARD ::substrait::ParameterizedType_TypeParameter* release_type_parameter(); - ::substrait::ParameterizedType_TypeParameter* mutable_type_parameter(); - void set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter); - private: - const ::substrait::ParameterizedType_TypeParameter& _internal_type_parameter() const; - ::substrait::ParameterizedType_TypeParameter* _internal_mutable_type_parameter(); - public: - void unsafe_arena_set_allocated_type_parameter( - ::substrait::ParameterizedType_TypeParameter* type_parameter); - ::substrait::ParameterizedType_TypeParameter* unsafe_arena_release_type_parameter(); - - void clear_kind(); - KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:substrait.ParameterizedType) - private: - class _Internal; - void set_has_bool_(); - void set_has_i8(); - void set_has_i16(); - void set_has_i32(); - void set_has_i64(); - void set_has_fp32(); - void set_has_fp64(); - void set_has_string(); - void set_has_binary(); - void set_has_timestamp(); - void set_has_date(); - void set_has_time(); - void set_has_interval_year(); - void set_has_interval_day(); - void set_has_timestamp_tz(); - void set_has_uuid(); - void set_has_fixed_char(); - void set_has_varchar(); - void set_has_fixed_binary(); - void set_has_decimal(); - void set_has_struct_(); - void set_has_list(); - void set_has_map(); - void set_has_user_defined_pointer(); - void set_has_type_parameter(); - - inline bool has_kind() const; - inline void clear_has_kind(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union KindUnion { - constexpr KindUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Type_Boolean* bool__; - ::substrait::Type_I8* i8_; - ::substrait::Type_I16* i16_; - ::substrait::Type_I32* i32_; - ::substrait::Type_I64* i64_; - ::substrait::Type_FP32* fp32_; - ::substrait::Type_FP64* fp64_; - ::substrait::Type_String* string_; - ::substrait::Type_Binary* binary_; - ::substrait::Type_Timestamp* timestamp_; - ::substrait::Type_Date* date_; - ::substrait::Type_Time* time_; - ::substrait::Type_IntervalYear* interval_year_; - ::substrait::Type_IntervalDay* interval_day_; - ::substrait::Type_TimestampTZ* timestamp_tz_; - ::substrait::Type_UUID* uuid_; - ::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char_; - ::substrait::ParameterizedType_ParameterizedVarChar* varchar_; - ::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary_; - ::substrait::ParameterizedType_ParameterizedDecimal* decimal_; - ::substrait::ParameterizedType_ParameterizedStruct* struct__; - ::substrait::ParameterizedType_ParameterizedList* list_; - ::substrait::ParameterizedType_ParameterizedMap* map_; - uint32_t user_defined_pointer_; - ::substrait::ParameterizedType_TypeParameter* type_parameter_; - } kind_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fparameterized_5ftypes_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// ParameterizedType_TypeParameter - -// string name = 1; -inline void ParameterizedType_TypeParameter::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& ParameterizedType_TypeParameter::name() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.TypeParameter.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ParameterizedType_TypeParameter::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.TypeParameter.name) -} -inline std::string* ParameterizedType_TypeParameter::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.TypeParameter.name) - return _s; -} -inline const std::string& ParameterizedType_TypeParameter::_internal_name() const { - return name_.Get(); -} -inline void ParameterizedType_TypeParameter::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* ParameterizedType_TypeParameter::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* ParameterizedType_TypeParameter::release_name() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.TypeParameter.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void ParameterizedType_TypeParameter::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.TypeParameter.name) -} - -// repeated .substrait.ParameterizedType bounds = 2; -inline int ParameterizedType_TypeParameter::_internal_bounds_size() const { - return bounds_.size(); -} -inline int ParameterizedType_TypeParameter::bounds_size() const { - return _internal_bounds_size(); -} -inline void ParameterizedType_TypeParameter::clear_bounds() { - bounds_.Clear(); -} -inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::mutable_bounds(int index) { - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.TypeParameter.bounds) - return bounds_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >* -ParameterizedType_TypeParameter::mutable_bounds() { - // @@protoc_insertion_point(field_mutable_list:substrait.ParameterizedType.TypeParameter.bounds) - return &bounds_; -} -inline const ::substrait::ParameterizedType& ParameterizedType_TypeParameter::_internal_bounds(int index) const { - return bounds_.Get(index); -} -inline const ::substrait::ParameterizedType& ParameterizedType_TypeParameter::bounds(int index) const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.TypeParameter.bounds) - return _internal_bounds(index); -} -inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::_internal_add_bounds() { - return bounds_.Add(); -} -inline ::substrait::ParameterizedType* ParameterizedType_TypeParameter::add_bounds() { - ::substrait::ParameterizedType* _add = _internal_add_bounds(); - // @@protoc_insertion_point(field_add:substrait.ParameterizedType.TypeParameter.bounds) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >& -ParameterizedType_TypeParameter::bounds() const { - // @@protoc_insertion_point(field_list:substrait.ParameterizedType.TypeParameter.bounds) - return bounds_; -} - -// ------------------------------------------------------------------- - -// ParameterizedType_IntegerParameter - -// string name = 1; -inline void ParameterizedType_IntegerParameter::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& ParameterizedType_IntegerParameter::name() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerParameter.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void ParameterizedType_IntegerParameter::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.IntegerParameter.name) -} -inline std::string* ParameterizedType_IntegerParameter::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.name) - return _s; -} -inline const std::string& ParameterizedType_IntegerParameter::_internal_name() const { - return name_.Get(); -} -inline void ParameterizedType_IntegerParameter::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* ParameterizedType_IntegerParameter::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* ParameterizedType_IntegerParameter::release_name() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerParameter.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void ParameterizedType_IntegerParameter::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerParameter.name) -} - -// .substrait.ParameterizedType.NullableInteger range_start_inclusive = 2; -inline bool ParameterizedType_IntegerParameter::_internal_has_range_start_inclusive() const { - return this != internal_default_instance() && range_start_inclusive_ != nullptr; -} -inline bool ParameterizedType_IntegerParameter::has_range_start_inclusive() const { - return _internal_has_range_start_inclusive(); -} -inline void ParameterizedType_IntegerParameter::clear_range_start_inclusive() { - if (GetArenaForAllocation() == nullptr && range_start_inclusive_ != nullptr) { - delete range_start_inclusive_; - } - range_start_inclusive_ = nullptr; -} -inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_internal_range_start_inclusive() const { - const ::substrait::ParameterizedType_NullableInteger* p = range_start_inclusive_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_NullableInteger_default_instance_); -} -inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::range_start_inclusive() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) - return _internal_range_start_inclusive(); -} -inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range_start_inclusive( - ::substrait::ParameterizedType_NullableInteger* range_start_inclusive) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(range_start_inclusive_); - } - range_start_inclusive_ = range_start_inclusive; - if (range_start_inclusive) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) -} -inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::release_range_start_inclusive() { - - ::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_; - range_start_inclusive_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_start_inclusive() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) - - ::substrait::ParameterizedType_NullableInteger* temp = range_start_inclusive_; - range_start_inclusive_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_start_inclusive() { - - if (range_start_inclusive_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(GetArenaForAllocation()); - range_start_inclusive_ = p; - } - return range_start_inclusive_; -} -inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_start_inclusive() { - ::substrait::ParameterizedType_NullableInteger* _msg = _internal_mutable_range_start_inclusive(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) - return _msg; -} -inline void ParameterizedType_IntegerParameter::set_allocated_range_start_inclusive(::substrait::ParameterizedType_NullableInteger* range_start_inclusive) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete range_start_inclusive_; - } - if (range_start_inclusive) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_NullableInteger>::GetOwningArena(range_start_inclusive); - if (message_arena != submessage_arena) { - range_start_inclusive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, range_start_inclusive, submessage_arena); - } - - } else { - - } - range_start_inclusive_ = range_start_inclusive; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerParameter.range_start_inclusive) -} - -// .substrait.ParameterizedType.NullableInteger range_end_exclusive = 3; -inline bool ParameterizedType_IntegerParameter::_internal_has_range_end_exclusive() const { - return this != internal_default_instance() && range_end_exclusive_ != nullptr; -} -inline bool ParameterizedType_IntegerParameter::has_range_end_exclusive() const { - return _internal_has_range_end_exclusive(); -} -inline void ParameterizedType_IntegerParameter::clear_range_end_exclusive() { - if (GetArenaForAllocation() == nullptr && range_end_exclusive_ != nullptr) { - delete range_end_exclusive_; - } - range_end_exclusive_ = nullptr; -} -inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::_internal_range_end_exclusive() const { - const ::substrait::ParameterizedType_NullableInteger* p = range_end_exclusive_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_NullableInteger_default_instance_); -} -inline const ::substrait::ParameterizedType_NullableInteger& ParameterizedType_IntegerParameter::range_end_exclusive() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) - return _internal_range_end_exclusive(); -} -inline void ParameterizedType_IntegerParameter::unsafe_arena_set_allocated_range_end_exclusive( - ::substrait::ParameterizedType_NullableInteger* range_end_exclusive) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(range_end_exclusive_); - } - range_end_exclusive_ = range_end_exclusive; - if (range_end_exclusive) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) -} -inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::release_range_end_exclusive() { - - ::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_; - range_end_exclusive_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::unsafe_arena_release_range_end_exclusive() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) - - ::substrait::ParameterizedType_NullableInteger* temp = range_end_exclusive_; - range_end_exclusive_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::_internal_mutable_range_end_exclusive() { - - if (range_end_exclusive_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_NullableInteger>(GetArenaForAllocation()); - range_end_exclusive_ = p; - } - return range_end_exclusive_; -} -inline ::substrait::ParameterizedType_NullableInteger* ParameterizedType_IntegerParameter::mutable_range_end_exclusive() { - ::substrait::ParameterizedType_NullableInteger* _msg = _internal_mutable_range_end_exclusive(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) - return _msg; -} -inline void ParameterizedType_IntegerParameter::set_allocated_range_end_exclusive(::substrait::ParameterizedType_NullableInteger* range_end_exclusive) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete range_end_exclusive_; - } - if (range_end_exclusive) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_NullableInteger>::GetOwningArena(range_end_exclusive); - if (message_arena != submessage_arena) { - range_end_exclusive = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, range_end_exclusive, submessage_arena); - } - - } else { - - } - range_end_exclusive_ = range_end_exclusive; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.IntegerParameter.range_end_exclusive) -} - -// ------------------------------------------------------------------- - -// ParameterizedType_NullableInteger - -// int64 value = 1; -inline void ParameterizedType_NullableInteger::clear_value() { - value_ = int64_t{0}; -} -inline int64_t ParameterizedType_NullableInteger::_internal_value() const { - return value_; -} -inline int64_t ParameterizedType_NullableInteger::value() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.NullableInteger.value) - return _internal_value(); -} -inline void ParameterizedType_NullableInteger::_internal_set_value(int64_t value) { - - value_ = value; -} -inline void ParameterizedType_NullableInteger::set_value(int64_t value) { - _internal_set_value(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.NullableInteger.value) -} - -// ------------------------------------------------------------------- - -// ParameterizedType_ParameterizedFixedChar - -// .substrait.ParameterizedType.IntegerOption length = 1; -inline bool ParameterizedType_ParameterizedFixedChar::_internal_has_length() const { - return this != internal_default_instance() && length_ != nullptr; -} -inline bool ParameterizedType_ParameterizedFixedChar::has_length() const { - return _internal_has_length(); -} -inline void ParameterizedType_ParameterizedFixedChar::clear_length() { - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; -} -inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::_internal_length() const { - const ::substrait::ParameterizedType_IntegerOption* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_IntegerOption_default_instance_); -} -inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedChar::length() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedChar.length) - return _internal_length(); -} -inline void ParameterizedType_ParameterizedFixedChar::unsafe_arena_set_allocated_length( - ::substrait::ParameterizedType_IntegerOption* length) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); - } - length_ = length; - if (length) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedFixedChar.length) -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::release_length() { - - ::substrait::ParameterizedType_IntegerOption* temp = length_; - length_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedFixedChar.length) - - ::substrait::ParameterizedType_IntegerOption* temp = length_; - length_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::_internal_mutable_length() { - - if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation()); - length_ = p; - } - return length_; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedChar::mutable_length() { - ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_length(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedFixedChar.length) - return _msg; -} -inline void ParameterizedType_ParameterizedFixedChar::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete length_; - } - if (length) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(length); - if (message_arena != submessage_arena) { - length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, length, submessage_arena); - } - - } else { - - } - length_ = length; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedFixedChar.length) -} - -// uint32 variation_pointer = 2; -inline void ParameterizedType_ParameterizedFixedChar::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t ParameterizedType_ParameterizedFixedChar::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t ParameterizedType_ParameterizedFixedChar::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer) - return _internal_variation_pointer(); -} -inline void ParameterizedType_ParameterizedFixedChar::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void ParameterizedType_ParameterizedFixedChar::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedChar.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 3; -inline void ParameterizedType_ParameterizedFixedChar::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedChar::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedChar::nullability() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedChar.nullability) - return _internal_nullability(); -} -inline void ParameterizedType_ParameterizedFixedChar::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void ParameterizedType_ParameterizedFixedChar::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedChar.nullability) -} - -// ------------------------------------------------------------------- - -// ParameterizedType_ParameterizedVarChar - -// .substrait.ParameterizedType.IntegerOption length = 1; -inline bool ParameterizedType_ParameterizedVarChar::_internal_has_length() const { - return this != internal_default_instance() && length_ != nullptr; -} -inline bool ParameterizedType_ParameterizedVarChar::has_length() const { - return _internal_has_length(); -} -inline void ParameterizedType_ParameterizedVarChar::clear_length() { - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; -} -inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::_internal_length() const { - const ::substrait::ParameterizedType_IntegerOption* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_IntegerOption_default_instance_); -} -inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedVarChar::length() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedVarChar.length) - return _internal_length(); -} -inline void ParameterizedType_ParameterizedVarChar::unsafe_arena_set_allocated_length( - ::substrait::ParameterizedType_IntegerOption* length) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); - } - length_ = length; - if (length) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedVarChar.length) -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::release_length() { - - ::substrait::ParameterizedType_IntegerOption* temp = length_; - length_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedVarChar.length) - - ::substrait::ParameterizedType_IntegerOption* temp = length_; - length_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::_internal_mutable_length() { - - if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation()); - length_ = p; - } - return length_; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedVarChar::mutable_length() { - ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_length(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedVarChar.length) - return _msg; -} -inline void ParameterizedType_ParameterizedVarChar::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete length_; - } - if (length) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(length); - if (message_arena != submessage_arena) { - length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, length, submessage_arena); - } - - } else { - - } - length_ = length; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedVarChar.length) -} - -// uint32 variation_pointer = 2; -inline void ParameterizedType_ParameterizedVarChar::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t ParameterizedType_ParameterizedVarChar::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t ParameterizedType_ParameterizedVarChar::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedVarChar.variation_pointer) - return _internal_variation_pointer(); -} -inline void ParameterizedType_ParameterizedVarChar::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void ParameterizedType_ParameterizedVarChar::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedVarChar.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 3; -inline void ParameterizedType_ParameterizedVarChar::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedVarChar::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedVarChar::nullability() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedVarChar.nullability) - return _internal_nullability(); -} -inline void ParameterizedType_ParameterizedVarChar::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void ParameterizedType_ParameterizedVarChar::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedVarChar.nullability) -} - -// ------------------------------------------------------------------- - -// ParameterizedType_ParameterizedFixedBinary - -// .substrait.ParameterizedType.IntegerOption length = 1; -inline bool ParameterizedType_ParameterizedFixedBinary::_internal_has_length() const { - return this != internal_default_instance() && length_ != nullptr; -} -inline bool ParameterizedType_ParameterizedFixedBinary::has_length() const { - return _internal_has_length(); -} -inline void ParameterizedType_ParameterizedFixedBinary::clear_length() { - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; -} -inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::_internal_length() const { - const ::substrait::ParameterizedType_IntegerOption* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_IntegerOption_default_instance_); -} -inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedFixedBinary::length() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedBinary.length) - return _internal_length(); -} -inline void ParameterizedType_ParameterizedFixedBinary::unsafe_arena_set_allocated_length( - ::substrait::ParameterizedType_IntegerOption* length) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); - } - length_ = length; - if (length) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedFixedBinary.length) -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::release_length() { - - ::substrait::ParameterizedType_IntegerOption* temp = length_; - length_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedFixedBinary.length) - - ::substrait::ParameterizedType_IntegerOption* temp = length_; - length_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::_internal_mutable_length() { - - if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation()); - length_ = p; - } - return length_; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedFixedBinary::mutable_length() { - ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_length(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedFixedBinary.length) - return _msg; -} -inline void ParameterizedType_ParameterizedFixedBinary::set_allocated_length(::substrait::ParameterizedType_IntegerOption* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete length_; - } - if (length) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(length); - if (message_arena != submessage_arena) { - length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, length, submessage_arena); - } - - } else { - - } - length_ = length; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedFixedBinary.length) -} - -// uint32 variation_pointer = 2; -inline void ParameterizedType_ParameterizedFixedBinary::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t ParameterizedType_ParameterizedFixedBinary::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t ParameterizedType_ParameterizedFixedBinary::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer) - return _internal_variation_pointer(); -} -inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void ParameterizedType_ParameterizedFixedBinary::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedBinary.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 3; -inline void ParameterizedType_ParameterizedFixedBinary::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedBinary::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedFixedBinary::nullability() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedFixedBinary.nullability) - return _internal_nullability(); -} -inline void ParameterizedType_ParameterizedFixedBinary::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void ParameterizedType_ParameterizedFixedBinary::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedFixedBinary.nullability) -} - -// ------------------------------------------------------------------- - -// ParameterizedType_ParameterizedDecimal - -// .substrait.ParameterizedType.IntegerOption scale = 1; -inline bool ParameterizedType_ParameterizedDecimal::_internal_has_scale() const { - return this != internal_default_instance() && scale_ != nullptr; -} -inline bool ParameterizedType_ParameterizedDecimal::has_scale() const { - return _internal_has_scale(); -} -inline void ParameterizedType_ParameterizedDecimal::clear_scale() { - if (GetArenaForAllocation() == nullptr && scale_ != nullptr) { - delete scale_; - } - scale_ = nullptr; -} -inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_internal_scale() const { - const ::substrait::ParameterizedType_IntegerOption* p = scale_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_IntegerOption_default_instance_); -} -inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::scale() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.scale) - return _internal_scale(); -} -inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_scale( - ::substrait::ParameterizedType_IntegerOption* scale) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_); - } - scale_ = scale; - if (scale) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.scale) -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::release_scale() { - - ::substrait::ParameterizedType_IntegerOption* temp = scale_; - scale_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_scale() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedDecimal.scale) - - ::substrait::ParameterizedType_IntegerOption* temp = scale_; - scale_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_scale() { - - if (scale_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation()); - scale_ = p; - } - return scale_; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_scale() { - ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_scale(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedDecimal.scale) - return _msg; -} -inline void ParameterizedType_ParameterizedDecimal::set_allocated_scale(::substrait::ParameterizedType_IntegerOption* scale) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete scale_; - } - if (scale) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(scale); - if (message_arena != submessage_arena) { - scale = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, scale, submessage_arena); - } - - } else { - - } - scale_ = scale; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.scale) -} - -// .substrait.ParameterizedType.IntegerOption precision = 2; -inline bool ParameterizedType_ParameterizedDecimal::_internal_has_precision() const { - return this != internal_default_instance() && precision_ != nullptr; -} -inline bool ParameterizedType_ParameterizedDecimal::has_precision() const { - return _internal_has_precision(); -} -inline void ParameterizedType_ParameterizedDecimal::clear_precision() { - if (GetArenaForAllocation() == nullptr && precision_ != nullptr) { - delete precision_; - } - precision_ = nullptr; -} -inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::_internal_precision() const { - const ::substrait::ParameterizedType_IntegerOption* p = precision_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_IntegerOption_default_instance_); -} -inline const ::substrait::ParameterizedType_IntegerOption& ParameterizedType_ParameterizedDecimal::precision() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.precision) - return _internal_precision(); -} -inline void ParameterizedType_ParameterizedDecimal::unsafe_arena_set_allocated_precision( - ::substrait::ParameterizedType_IntegerOption* precision) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_); - } - precision_ = precision; - if (precision) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.precision) -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::release_precision() { - - ::substrait::ParameterizedType_IntegerOption* temp = precision_; - precision_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::unsafe_arena_release_precision() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedDecimal.precision) - - ::substrait::ParameterizedType_IntegerOption* temp = precision_; - precision_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::_internal_mutable_precision() { - - if (precision_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_IntegerOption>(GetArenaForAllocation()); - precision_ = p; - } - return precision_; -} -inline ::substrait::ParameterizedType_IntegerOption* ParameterizedType_ParameterizedDecimal::mutable_precision() { - ::substrait::ParameterizedType_IntegerOption* _msg = _internal_mutable_precision(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedDecimal.precision) - return _msg; -} -inline void ParameterizedType_ParameterizedDecimal::set_allocated_precision(::substrait::ParameterizedType_IntegerOption* precision) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete precision_; - } - if (precision) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_IntegerOption>::GetOwningArena(precision); - if (message_arena != submessage_arena) { - precision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, precision, submessage_arena); - } - - } else { - - } - precision_ = precision; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedDecimal.precision) -} - -// uint32 variation_pointer = 3; -inline void ParameterizedType_ParameterizedDecimal::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t ParameterizedType_ParameterizedDecimal::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t ParameterizedType_ParameterizedDecimal::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.variation_pointer) - return _internal_variation_pointer(); -} -inline void ParameterizedType_ParameterizedDecimal::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void ParameterizedType_ParameterizedDecimal::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedDecimal.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 4; -inline void ParameterizedType_ParameterizedDecimal::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedDecimal::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedDecimal::nullability() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedDecimal.nullability) - return _internal_nullability(); -} -inline void ParameterizedType_ParameterizedDecimal::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void ParameterizedType_ParameterizedDecimal::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedDecimal.nullability) -} - -// ------------------------------------------------------------------- - -// ParameterizedType_ParameterizedStruct - -// repeated .substrait.ParameterizedType types = 1; -inline int ParameterizedType_ParameterizedStruct::_internal_types_size() const { - return types_.size(); -} -inline int ParameterizedType_ParameterizedStruct::types_size() const { - return _internal_types_size(); -} -inline void ParameterizedType_ParameterizedStruct::clear_types() { - types_.Clear(); -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::mutable_types(int index) { - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedStruct.types) - return types_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >* -ParameterizedType_ParameterizedStruct::mutable_types() { - // @@protoc_insertion_point(field_mutable_list:substrait.ParameterizedType.ParameterizedStruct.types) - return &types_; -} -inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedStruct::_internal_types(int index) const { - return types_.Get(index); -} -inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedStruct::types(int index) const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedStruct.types) - return _internal_types(index); -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::_internal_add_types() { - return types_.Add(); -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedStruct::add_types() { - ::substrait::ParameterizedType* _add = _internal_add_types(); - // @@protoc_insertion_point(field_add:substrait.ParameterizedType.ParameterizedStruct.types) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ParameterizedType >& -ParameterizedType_ParameterizedStruct::types() const { - // @@protoc_insertion_point(field_list:substrait.ParameterizedType.ParameterizedStruct.types) - return types_; -} - -// uint32 variation_pointer = 2; -inline void ParameterizedType_ParameterizedStruct::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t ParameterizedType_ParameterizedStruct::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t ParameterizedType_ParameterizedStruct::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedStruct.variation_pointer) - return _internal_variation_pointer(); -} -inline void ParameterizedType_ParameterizedStruct::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void ParameterizedType_ParameterizedStruct::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedStruct.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 3; -inline void ParameterizedType_ParameterizedStruct::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedStruct::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedStruct::nullability() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedStruct.nullability) - return _internal_nullability(); -} -inline void ParameterizedType_ParameterizedStruct::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void ParameterizedType_ParameterizedStruct::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedStruct.nullability) -} - -// ------------------------------------------------------------------- - -// ParameterizedType_ParameterizedNamedStruct - -// repeated string names = 1; -inline int ParameterizedType_ParameterizedNamedStruct::_internal_names_size() const { - return names_.size(); -} -inline int ParameterizedType_ParameterizedNamedStruct::names_size() const { - return _internal_names_size(); -} -inline void ParameterizedType_ParameterizedNamedStruct::clear_names() { - names_.Clear(); -} -inline std::string* ParameterizedType_ParameterizedNamedStruct::add_names() { - std::string* _s = _internal_add_names(); - // @@protoc_insertion_point(field_add_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.names) - return _s; -} -inline const std::string& ParameterizedType_ParameterizedNamedStruct::_internal_names(int index) const { - return names_.Get(index); -} -inline const std::string& ParameterizedType_ParameterizedNamedStruct::names(int index) const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedNamedStruct.names) - return _internal_names(index); -} -inline std::string* ParameterizedType_ParameterizedNamedStruct::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.names) - return names_.Mutable(index); -} -inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const std::string& value) { - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedNamedStruct.names) -} -inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, std::string&& value) { - names_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedNamedStruct.names) -} -inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.ParameterizedType.ParameterizedNamedStruct.names) -} -inline void ParameterizedType_ParameterizedNamedStruct::set_names(int index, const char* value, size_t size) { - names_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.ParameterizedType.ParameterizedNamedStruct.names) -} -inline std::string* ParameterizedType_ParameterizedNamedStruct::_internal_add_names() { - return names_.Add(); -} -inline void ParameterizedType_ParameterizedNamedStruct::add_names(const std::string& value) { - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.ParameterizedType.ParameterizedNamedStruct.names) -} -inline void ParameterizedType_ParameterizedNamedStruct::add_names(std::string&& value) { - names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.ParameterizedType.ParameterizedNamedStruct.names) -} -inline void ParameterizedType_ParameterizedNamedStruct::add_names(const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.ParameterizedType.ParameterizedNamedStruct.names) -} -inline void ParameterizedType_ParameterizedNamedStruct::add_names(const char* value, size_t size) { - names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.ParameterizedType.ParameterizedNamedStruct.names) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -ParameterizedType_ParameterizedNamedStruct::names() const { - // @@protoc_insertion_point(field_list:substrait.ParameterizedType.ParameterizedNamedStruct.names) - return names_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -ParameterizedType_ParameterizedNamedStruct::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:substrait.ParameterizedType.ParameterizedNamedStruct.names) - return &names_; -} - -// .substrait.ParameterizedType.ParameterizedStruct struct = 2; -inline bool ParameterizedType_ParameterizedNamedStruct::_internal_has_struct_() const { - return this != internal_default_instance() && struct__ != nullptr; -} -inline bool ParameterizedType_ParameterizedNamedStruct::has_struct_() const { - return _internal_has_struct_(); -} -inline void ParameterizedType_ParameterizedNamedStruct::clear_struct_() { - if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { - delete struct__; - } - struct__ = nullptr; -} -inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::_internal_struct_() const { - const ::substrait::ParameterizedType_ParameterizedStruct* p = struct__; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_ParameterizedStruct_default_instance_); -} -inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType_ParameterizedNamedStruct::struct_() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedNamedStruct.struct) - return _internal_struct_(); -} -inline void ParameterizedType_ParameterizedNamedStruct::unsafe_arena_set_allocated_struct_( - ::substrait::ParameterizedType_ParameterizedStruct* struct_) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); - } - struct__ = struct_; - if (struct_) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedNamedStruct.struct) -} -inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::release_struct_() { - - ::substrait::ParameterizedType_ParameterizedStruct* temp = struct__; - struct__ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedNamedStruct.struct) - - ::substrait::ParameterizedType_ParameterizedStruct* temp = struct__; - struct__ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::_internal_mutable_struct_() { - - if (struct__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType_ParameterizedStruct>(GetArenaForAllocation()); - struct__ = p; - } - return struct__; -} -inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType_ParameterizedNamedStruct::mutable_struct_() { - ::substrait::ParameterizedType_ParameterizedStruct* _msg = _internal_mutable_struct_(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedNamedStruct.struct) - return _msg; -} -inline void ParameterizedType_ParameterizedNamedStruct::set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete struct__; - } - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType_ParameterizedStruct>::GetOwningArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - - } else { - - } - struct__ = struct_; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedNamedStruct.struct) -} - -// ------------------------------------------------------------------- - -// ParameterizedType_ParameterizedList - -// .substrait.ParameterizedType type = 1; -inline bool ParameterizedType_ParameterizedList::_internal_has_type() const { - return this != internal_default_instance() && type_ != nullptr; -} -inline bool ParameterizedType_ParameterizedList::has_type() const { - return _internal_has_type(); -} -inline void ParameterizedType_ParameterizedList::clear_type() { - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; -} -inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedList::_internal_type() const { - const ::substrait::ParameterizedType* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_default_instance_); -} -inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedList::type() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedList.type) - return _internal_type(); -} -inline void ParameterizedType_ParameterizedList::unsafe_arena_set_allocated_type( - ::substrait::ParameterizedType* type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); - } - type_ = type; - if (type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedList.type) -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::release_type() { - - ::substrait::ParameterizedType* temp = type_; - type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedList.type) - - ::substrait::ParameterizedType* temp = type_; - type_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::_internal_mutable_type() { - - if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation()); - type_ = p; - } - return type_; -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedList::mutable_type() { - ::substrait::ParameterizedType* _msg = _internal_mutable_type(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedList.type) - return _msg; -} -inline void ParameterizedType_ParameterizedList::set_allocated_type(::substrait::ParameterizedType* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete type_; - } - if (type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType>::GetOwningArena(type); - if (message_arena != submessage_arena) { - type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type, submessage_arena); - } - - } else { - - } - type_ = type; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedList.type) -} - -// uint32 variation_pointer = 2; -inline void ParameterizedType_ParameterizedList::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t ParameterizedType_ParameterizedList::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t ParameterizedType_ParameterizedList::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedList.variation_pointer) - return _internal_variation_pointer(); -} -inline void ParameterizedType_ParameterizedList::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void ParameterizedType_ParameterizedList::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedList.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 3; -inline void ParameterizedType_ParameterizedList::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedList::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedList::nullability() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedList.nullability) - return _internal_nullability(); -} -inline void ParameterizedType_ParameterizedList::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void ParameterizedType_ParameterizedList::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedList.nullability) -} - -// ------------------------------------------------------------------- - -// ParameterizedType_ParameterizedMap - -// .substrait.ParameterizedType key = 1; -inline bool ParameterizedType_ParameterizedMap::_internal_has_key() const { - return this != internal_default_instance() && key_ != nullptr; -} -inline bool ParameterizedType_ParameterizedMap::has_key() const { - return _internal_has_key(); -} -inline void ParameterizedType_ParameterizedMap::clear_key() { - if (GetArenaForAllocation() == nullptr && key_ != nullptr) { - delete key_; - } - key_ = nullptr; -} -inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_internal_key() const { - const ::substrait::ParameterizedType* p = key_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_default_instance_); -} -inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::key() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.key) - return _internal_key(); -} -inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_key( - ::substrait::ParameterizedType* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); - } - key_ = key; - if (key) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedMap.key) -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::release_key() { - - ::substrait::ParameterizedType* temp = key_; - key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedMap.key) - - ::substrait::ParameterizedType* temp = key_; - key_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_key() { - - if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation()); - key_ = p; - } - return key_; -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_key() { - ::substrait::ParameterizedType* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedMap.key) - return _msg; -} -inline void ParameterizedType_ParameterizedMap::set_allocated_key(::substrait::ParameterizedType* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType>::GetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - - } else { - - } - key_ = key; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedMap.key) -} - -// .substrait.ParameterizedType value = 2; -inline bool ParameterizedType_ParameterizedMap::_internal_has_value() const { - return this != internal_default_instance() && value_ != nullptr; -} -inline bool ParameterizedType_ParameterizedMap::has_value() const { - return _internal_has_value(); -} -inline void ParameterizedType_ParameterizedMap::clear_value() { - if (GetArenaForAllocation() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; -} -inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::_internal_value() const { - const ::substrait::ParameterizedType* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_ParameterizedType_default_instance_); -} -inline const ::substrait::ParameterizedType& ParameterizedType_ParameterizedMap::value() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.value) - return _internal_value(); -} -inline void ParameterizedType_ParameterizedMap::unsafe_arena_set_allocated_value( - ::substrait::ParameterizedType* value) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); - } - value_ = value; - if (value) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.ParameterizedMap.value) -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::release_value() { - - ::substrait::ParameterizedType* temp = value_; - value_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.ParameterizedMap.value) - - ::substrait::ParameterizedType* temp = value_; - value_ = nullptr; - return temp; -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::_internal_mutable_value() { - - if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::ParameterizedType>(GetArenaForAllocation()); - value_ = p; - } - return value_; -} -inline ::substrait::ParameterizedType* ParameterizedType_ParameterizedMap::mutable_value() { - ::substrait::ParameterizedType* _msg = _internal_mutable_value(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.ParameterizedMap.value) - return _msg; -} -inline void ParameterizedType_ParameterizedMap::set_allocated_value(::substrait::ParameterizedType* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete value_; - } - if (value) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ParameterizedType>::GetOwningArena(value); - if (message_arena != submessage_arena) { - value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value, submessage_arena); - } - - } else { - - } - value_ = value; - // @@protoc_insertion_point(field_set_allocated:substrait.ParameterizedType.ParameterizedMap.value) -} - -// uint32 variation_pointer = 3; -inline void ParameterizedType_ParameterizedMap::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t ParameterizedType_ParameterizedMap::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t ParameterizedType_ParameterizedMap::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.variation_pointer) - return _internal_variation_pointer(); -} -inline void ParameterizedType_ParameterizedMap::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void ParameterizedType_ParameterizedMap::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedMap.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 4; -inline void ParameterizedType_ParameterizedMap::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedMap::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability ParameterizedType_ParameterizedMap::nullability() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.ParameterizedMap.nullability) - return _internal_nullability(); -} -inline void ParameterizedType_ParameterizedMap::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void ParameterizedType_ParameterizedMap::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.ParameterizedMap.nullability) -} - -// ------------------------------------------------------------------- - -// ParameterizedType_IntegerOption - -// int32 literal = 1; -inline bool ParameterizedType_IntegerOption::_internal_has_literal() const { - return integer_type_case() == kLiteral; -} -inline bool ParameterizedType_IntegerOption::has_literal() const { - return _internal_has_literal(); -} -inline void ParameterizedType_IntegerOption::set_has_literal() { - _oneof_case_[0] = kLiteral; -} -inline void ParameterizedType_IntegerOption::clear_literal() { - if (_internal_has_literal()) { - integer_type_.literal_ = 0; - clear_has_integer_type(); - } -} -inline int32_t ParameterizedType_IntegerOption::_internal_literal() const { - if (_internal_has_literal()) { - return integer_type_.literal_; - } - return 0; -} -inline void ParameterizedType_IntegerOption::_internal_set_literal(int32_t value) { - if (!_internal_has_literal()) { - clear_integer_type(); - set_has_literal(); - } - integer_type_.literal_ = value; -} -inline int32_t ParameterizedType_IntegerOption::literal() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerOption.literal) - return _internal_literal(); -} -inline void ParameterizedType_IntegerOption::set_literal(int32_t value) { - _internal_set_literal(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.IntegerOption.literal) -} - -// .substrait.ParameterizedType.IntegerParameter parameter = 2; -inline bool ParameterizedType_IntegerOption::_internal_has_parameter() const { - return integer_type_case() == kParameter; -} -inline bool ParameterizedType_IntegerOption::has_parameter() const { - return _internal_has_parameter(); -} -inline void ParameterizedType_IntegerOption::set_has_parameter() { - _oneof_case_[0] = kParameter; -} -inline void ParameterizedType_IntegerOption::clear_parameter() { - if (_internal_has_parameter()) { - if (GetArenaForAllocation() == nullptr) { - delete integer_type_.parameter_; - } - clear_has_integer_type(); - } -} -inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::release_parameter() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.IntegerOption.parameter) - if (_internal_has_parameter()) { - clear_has_integer_type(); - ::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - integer_type_.parameter_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::_internal_parameter() const { - return _internal_has_parameter() - ? *integer_type_.parameter_ - : reinterpret_cast< ::substrait::ParameterizedType_IntegerParameter&>(::substrait::_ParameterizedType_IntegerParameter_default_instance_); -} -inline const ::substrait::ParameterizedType_IntegerParameter& ParameterizedType_IntegerOption::parameter() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.IntegerOption.parameter) - return _internal_parameter(); -} -inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::unsafe_arena_release_parameter() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.IntegerOption.parameter) - if (_internal_has_parameter()) { - clear_has_integer_type(); - ::substrait::ParameterizedType_IntegerParameter* temp = integer_type_.parameter_; - integer_type_.parameter_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType_IntegerOption::unsafe_arena_set_allocated_parameter(::substrait::ParameterizedType_IntegerParameter* parameter) { - clear_integer_type(); - if (parameter) { - set_has_parameter(); - integer_type_.parameter_ = parameter; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.IntegerOption.parameter) -} -inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::_internal_mutable_parameter() { - if (!_internal_has_parameter()) { - clear_integer_type(); - set_has_parameter(); - integer_type_.parameter_ = CreateMaybeMessage< ::substrait::ParameterizedType_IntegerParameter >(GetArenaForAllocation()); - } - return integer_type_.parameter_; -} -inline ::substrait::ParameterizedType_IntegerParameter* ParameterizedType_IntegerOption::mutable_parameter() { - ::substrait::ParameterizedType_IntegerParameter* _msg = _internal_mutable_parameter(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.IntegerOption.parameter) - return _msg; -} - -inline bool ParameterizedType_IntegerOption::has_integer_type() const { - return integer_type_case() != INTEGER_TYPE_NOT_SET; -} -inline void ParameterizedType_IntegerOption::clear_has_integer_type() { - _oneof_case_[0] = INTEGER_TYPE_NOT_SET; -} -inline ParameterizedType_IntegerOption::IntegerTypeCase ParameterizedType_IntegerOption::integer_type_case() const { - return ParameterizedType_IntegerOption::IntegerTypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// ParameterizedType - -// .substrait.Type.Boolean bool = 1; -inline bool ParameterizedType::_internal_has_bool_() const { - return kind_case() == kBool; -} -inline bool ParameterizedType::has_bool_() const { - return _internal_has_bool_(); -} -inline void ParameterizedType::set_has_bool_() { - _oneof_case_[0] = kBool; -} -inline ::substrait::Type_Boolean* ParameterizedType::release_bool_() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.bool) - if (_internal_has_bool_()) { - clear_has_kind(); - ::substrait::Type_Boolean* temp = kind_.bool__; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.bool__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Boolean& ParameterizedType::_internal_bool_() const { - return _internal_has_bool_() - ? *kind_.bool__ - : reinterpret_cast< ::substrait::Type_Boolean&>(::substrait::_Type_Boolean_default_instance_); -} -inline const ::substrait::Type_Boolean& ParameterizedType::bool_() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.bool) - return _internal_bool_(); -} -inline ::substrait::Type_Boolean* ParameterizedType::unsafe_arena_release_bool_() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.bool) - if (_internal_has_bool_()) { - clear_has_kind(); - ::substrait::Type_Boolean* temp = kind_.bool__; - kind_.bool__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_bool_(::substrait::Type_Boolean* bool_) { - clear_kind(); - if (bool_) { - set_has_bool_(); - kind_.bool__ = bool_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.bool) -} -inline ::substrait::Type_Boolean* ParameterizedType::_internal_mutable_bool_() { - if (!_internal_has_bool_()) { - clear_kind(); - set_has_bool_(); - kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArenaForAllocation()); - } - return kind_.bool__; -} -inline ::substrait::Type_Boolean* ParameterizedType::mutable_bool_() { - ::substrait::Type_Boolean* _msg = _internal_mutable_bool_(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.bool) - return _msg; -} - -// .substrait.Type.I8 i8 = 2; -inline bool ParameterizedType::_internal_has_i8() const { - return kind_case() == kI8; -} -inline bool ParameterizedType::has_i8() const { - return _internal_has_i8(); -} -inline void ParameterizedType::set_has_i8() { - _oneof_case_[0] = kI8; -} -inline ::substrait::Type_I8* ParameterizedType::release_i8() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i8) - if (_internal_has_i8()) { - clear_has_kind(); - ::substrait::Type_I8* temp = kind_.i8_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i8_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I8& ParameterizedType::_internal_i8() const { - return _internal_has_i8() - ? *kind_.i8_ - : reinterpret_cast< ::substrait::Type_I8&>(::substrait::_Type_I8_default_instance_); -} -inline const ::substrait::Type_I8& ParameterizedType::i8() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i8) - return _internal_i8(); -} -inline ::substrait::Type_I8* ParameterizedType::unsafe_arena_release_i8() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i8) - if (_internal_has_i8()) { - clear_has_kind(); - ::substrait::Type_I8* temp = kind_.i8_; - kind_.i8_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_i8(::substrait::Type_I8* i8) { - clear_kind(); - if (i8) { - set_has_i8(); - kind_.i8_ = i8; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i8) -} -inline ::substrait::Type_I8* ParameterizedType::_internal_mutable_i8() { - if (!_internal_has_i8()) { - clear_kind(); - set_has_i8(); - kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArenaForAllocation()); - } - return kind_.i8_; -} -inline ::substrait::Type_I8* ParameterizedType::mutable_i8() { - ::substrait::Type_I8* _msg = _internal_mutable_i8(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i8) - return _msg; -} - -// .substrait.Type.I16 i16 = 3; -inline bool ParameterizedType::_internal_has_i16() const { - return kind_case() == kI16; -} -inline bool ParameterizedType::has_i16() const { - return _internal_has_i16(); -} -inline void ParameterizedType::set_has_i16() { - _oneof_case_[0] = kI16; -} -inline ::substrait::Type_I16* ParameterizedType::release_i16() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i16) - if (_internal_has_i16()) { - clear_has_kind(); - ::substrait::Type_I16* temp = kind_.i16_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i16_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I16& ParameterizedType::_internal_i16() const { - return _internal_has_i16() - ? *kind_.i16_ - : reinterpret_cast< ::substrait::Type_I16&>(::substrait::_Type_I16_default_instance_); -} -inline const ::substrait::Type_I16& ParameterizedType::i16() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i16) - return _internal_i16(); -} -inline ::substrait::Type_I16* ParameterizedType::unsafe_arena_release_i16() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i16) - if (_internal_has_i16()) { - clear_has_kind(); - ::substrait::Type_I16* temp = kind_.i16_; - kind_.i16_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_i16(::substrait::Type_I16* i16) { - clear_kind(); - if (i16) { - set_has_i16(); - kind_.i16_ = i16; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i16) -} -inline ::substrait::Type_I16* ParameterizedType::_internal_mutable_i16() { - if (!_internal_has_i16()) { - clear_kind(); - set_has_i16(); - kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArenaForAllocation()); - } - return kind_.i16_; -} -inline ::substrait::Type_I16* ParameterizedType::mutable_i16() { - ::substrait::Type_I16* _msg = _internal_mutable_i16(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i16) - return _msg; -} - -// .substrait.Type.I32 i32 = 5; -inline bool ParameterizedType::_internal_has_i32() const { - return kind_case() == kI32; -} -inline bool ParameterizedType::has_i32() const { - return _internal_has_i32(); -} -inline void ParameterizedType::set_has_i32() { - _oneof_case_[0] = kI32; -} -inline ::substrait::Type_I32* ParameterizedType::release_i32() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i32) - if (_internal_has_i32()) { - clear_has_kind(); - ::substrait::Type_I32* temp = kind_.i32_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I32& ParameterizedType::_internal_i32() const { - return _internal_has_i32() - ? *kind_.i32_ - : reinterpret_cast< ::substrait::Type_I32&>(::substrait::_Type_I32_default_instance_); -} -inline const ::substrait::Type_I32& ParameterizedType::i32() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i32) - return _internal_i32(); -} -inline ::substrait::Type_I32* ParameterizedType::unsafe_arena_release_i32() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i32) - if (_internal_has_i32()) { - clear_has_kind(); - ::substrait::Type_I32* temp = kind_.i32_; - kind_.i32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_i32(::substrait::Type_I32* i32) { - clear_kind(); - if (i32) { - set_has_i32(); - kind_.i32_ = i32; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i32) -} -inline ::substrait::Type_I32* ParameterizedType::_internal_mutable_i32() { - if (!_internal_has_i32()) { - clear_kind(); - set_has_i32(); - kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArenaForAllocation()); - } - return kind_.i32_; -} -inline ::substrait::Type_I32* ParameterizedType::mutable_i32() { - ::substrait::Type_I32* _msg = _internal_mutable_i32(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i32) - return _msg; -} - -// .substrait.Type.I64 i64 = 7; -inline bool ParameterizedType::_internal_has_i64() const { - return kind_case() == kI64; -} -inline bool ParameterizedType::has_i64() const { - return _internal_has_i64(); -} -inline void ParameterizedType::set_has_i64() { - _oneof_case_[0] = kI64; -} -inline ::substrait::Type_I64* ParameterizedType::release_i64() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.i64) - if (_internal_has_i64()) { - clear_has_kind(); - ::substrait::Type_I64* temp = kind_.i64_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I64& ParameterizedType::_internal_i64() const { - return _internal_has_i64() - ? *kind_.i64_ - : reinterpret_cast< ::substrait::Type_I64&>(::substrait::_Type_I64_default_instance_); -} -inline const ::substrait::Type_I64& ParameterizedType::i64() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.i64) - return _internal_i64(); -} -inline ::substrait::Type_I64* ParameterizedType::unsafe_arena_release_i64() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.i64) - if (_internal_has_i64()) { - clear_has_kind(); - ::substrait::Type_I64* temp = kind_.i64_; - kind_.i64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_i64(::substrait::Type_I64* i64) { - clear_kind(); - if (i64) { - set_has_i64(); - kind_.i64_ = i64; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.i64) -} -inline ::substrait::Type_I64* ParameterizedType::_internal_mutable_i64() { - if (!_internal_has_i64()) { - clear_kind(); - set_has_i64(); - kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArenaForAllocation()); - } - return kind_.i64_; -} -inline ::substrait::Type_I64* ParameterizedType::mutable_i64() { - ::substrait::Type_I64* _msg = _internal_mutable_i64(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.i64) - return _msg; -} - -// .substrait.Type.FP32 fp32 = 10; -inline bool ParameterizedType::_internal_has_fp32() const { - return kind_case() == kFp32; -} -inline bool ParameterizedType::has_fp32() const { - return _internal_has_fp32(); -} -inline void ParameterizedType::set_has_fp32() { - _oneof_case_[0] = kFp32; -} -inline ::substrait::Type_FP32* ParameterizedType::release_fp32() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fp32) - if (_internal_has_fp32()) { - clear_has_kind(); - ::substrait::Type_FP32* temp = kind_.fp32_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fp32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_FP32& ParameterizedType::_internal_fp32() const { - return _internal_has_fp32() - ? *kind_.fp32_ - : reinterpret_cast< ::substrait::Type_FP32&>(::substrait::_Type_FP32_default_instance_); -} -inline const ::substrait::Type_FP32& ParameterizedType::fp32() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fp32) - return _internal_fp32(); -} -inline ::substrait::Type_FP32* ParameterizedType::unsafe_arena_release_fp32() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fp32) - if (_internal_has_fp32()) { - clear_has_kind(); - ::substrait::Type_FP32* temp = kind_.fp32_; - kind_.fp32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_fp32(::substrait::Type_FP32* fp32) { - clear_kind(); - if (fp32) { - set_has_fp32(); - kind_.fp32_ = fp32; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fp32) -} -inline ::substrait::Type_FP32* ParameterizedType::_internal_mutable_fp32() { - if (!_internal_has_fp32()) { - clear_kind(); - set_has_fp32(); - kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArenaForAllocation()); - } - return kind_.fp32_; -} -inline ::substrait::Type_FP32* ParameterizedType::mutable_fp32() { - ::substrait::Type_FP32* _msg = _internal_mutable_fp32(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fp32) - return _msg; -} - -// .substrait.Type.FP64 fp64 = 11; -inline bool ParameterizedType::_internal_has_fp64() const { - return kind_case() == kFp64; -} -inline bool ParameterizedType::has_fp64() const { - return _internal_has_fp64(); -} -inline void ParameterizedType::set_has_fp64() { - _oneof_case_[0] = kFp64; -} -inline ::substrait::Type_FP64* ParameterizedType::release_fp64() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fp64) - if (_internal_has_fp64()) { - clear_has_kind(); - ::substrait::Type_FP64* temp = kind_.fp64_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fp64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_FP64& ParameterizedType::_internal_fp64() const { - return _internal_has_fp64() - ? *kind_.fp64_ - : reinterpret_cast< ::substrait::Type_FP64&>(::substrait::_Type_FP64_default_instance_); -} -inline const ::substrait::Type_FP64& ParameterizedType::fp64() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fp64) - return _internal_fp64(); -} -inline ::substrait::Type_FP64* ParameterizedType::unsafe_arena_release_fp64() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fp64) - if (_internal_has_fp64()) { - clear_has_kind(); - ::substrait::Type_FP64* temp = kind_.fp64_; - kind_.fp64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_fp64(::substrait::Type_FP64* fp64) { - clear_kind(); - if (fp64) { - set_has_fp64(); - kind_.fp64_ = fp64; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fp64) -} -inline ::substrait::Type_FP64* ParameterizedType::_internal_mutable_fp64() { - if (!_internal_has_fp64()) { - clear_kind(); - set_has_fp64(); - kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArenaForAllocation()); - } - return kind_.fp64_; -} -inline ::substrait::Type_FP64* ParameterizedType::mutable_fp64() { - ::substrait::Type_FP64* _msg = _internal_mutable_fp64(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fp64) - return _msg; -} - -// .substrait.Type.String string = 12; -inline bool ParameterizedType::_internal_has_string() const { - return kind_case() == kString; -} -inline bool ParameterizedType::has_string() const { - return _internal_has_string(); -} -inline void ParameterizedType::set_has_string() { - _oneof_case_[0] = kString; -} -inline ::substrait::Type_String* ParameterizedType::release_string() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.string) - if (_internal_has_string()) { - clear_has_kind(); - ::substrait::Type_String* temp = kind_.string_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.string_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_String& ParameterizedType::_internal_string() const { - return _internal_has_string() - ? *kind_.string_ - : reinterpret_cast< ::substrait::Type_String&>(::substrait::_Type_String_default_instance_); -} -inline const ::substrait::Type_String& ParameterizedType::string() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.string) - return _internal_string(); -} -inline ::substrait::Type_String* ParameterizedType::unsafe_arena_release_string() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.string) - if (_internal_has_string()) { - clear_has_kind(); - ::substrait::Type_String* temp = kind_.string_; - kind_.string_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_string(::substrait::Type_String* string) { - clear_kind(); - if (string) { - set_has_string(); - kind_.string_ = string; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.string) -} -inline ::substrait::Type_String* ParameterizedType::_internal_mutable_string() { - if (!_internal_has_string()) { - clear_kind(); - set_has_string(); - kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArenaForAllocation()); - } - return kind_.string_; -} -inline ::substrait::Type_String* ParameterizedType::mutable_string() { - ::substrait::Type_String* _msg = _internal_mutable_string(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.string) - return _msg; -} - -// .substrait.Type.Binary binary = 13; -inline bool ParameterizedType::_internal_has_binary() const { - return kind_case() == kBinary; -} -inline bool ParameterizedType::has_binary() const { - return _internal_has_binary(); -} -inline void ParameterizedType::set_has_binary() { - _oneof_case_[0] = kBinary; -} -inline ::substrait::Type_Binary* ParameterizedType::release_binary() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.binary) - if (_internal_has_binary()) { - clear_has_kind(); - ::substrait::Type_Binary* temp = kind_.binary_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Binary& ParameterizedType::_internal_binary() const { - return _internal_has_binary() - ? *kind_.binary_ - : reinterpret_cast< ::substrait::Type_Binary&>(::substrait::_Type_Binary_default_instance_); -} -inline const ::substrait::Type_Binary& ParameterizedType::binary() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.binary) - return _internal_binary(); -} -inline ::substrait::Type_Binary* ParameterizedType::unsafe_arena_release_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.binary) - if (_internal_has_binary()) { - clear_has_kind(); - ::substrait::Type_Binary* temp = kind_.binary_; - kind_.binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_binary(::substrait::Type_Binary* binary) { - clear_kind(); - if (binary) { - set_has_binary(); - kind_.binary_ = binary; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.binary) -} -inline ::substrait::Type_Binary* ParameterizedType::_internal_mutable_binary() { - if (!_internal_has_binary()) { - clear_kind(); - set_has_binary(); - kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArenaForAllocation()); - } - return kind_.binary_; -} -inline ::substrait::Type_Binary* ParameterizedType::mutable_binary() { - ::substrait::Type_Binary* _msg = _internal_mutable_binary(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.binary) - return _msg; -} - -// .substrait.Type.Timestamp timestamp = 14; -inline bool ParameterizedType::_internal_has_timestamp() const { - return kind_case() == kTimestamp; -} -inline bool ParameterizedType::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void ParameterizedType::set_has_timestamp() { - _oneof_case_[0] = kTimestamp; -} -inline ::substrait::Type_Timestamp* ParameterizedType::release_timestamp() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.timestamp) - if (_internal_has_timestamp()) { - clear_has_kind(); - ::substrait::Type_Timestamp* temp = kind_.timestamp_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.timestamp_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Timestamp& ParameterizedType::_internal_timestamp() const { - return _internal_has_timestamp() - ? *kind_.timestamp_ - : reinterpret_cast< ::substrait::Type_Timestamp&>(::substrait::_Type_Timestamp_default_instance_); -} -inline const ::substrait::Type_Timestamp& ParameterizedType::timestamp() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.timestamp) - return _internal_timestamp(); -} -inline ::substrait::Type_Timestamp* ParameterizedType::unsafe_arena_release_timestamp() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.timestamp) - if (_internal_has_timestamp()) { - clear_has_kind(); - ::substrait::Type_Timestamp* temp = kind_.timestamp_; - kind_.timestamp_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { - clear_kind(); - if (timestamp) { - set_has_timestamp(); - kind_.timestamp_ = timestamp; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.timestamp) -} -inline ::substrait::Type_Timestamp* ParameterizedType::_internal_mutable_timestamp() { - if (!_internal_has_timestamp()) { - clear_kind(); - set_has_timestamp(); - kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArenaForAllocation()); - } - return kind_.timestamp_; -} -inline ::substrait::Type_Timestamp* ParameterizedType::mutable_timestamp() { - ::substrait::Type_Timestamp* _msg = _internal_mutable_timestamp(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.timestamp) - return _msg; -} - -// .substrait.Type.Date date = 16; -inline bool ParameterizedType::_internal_has_date() const { - return kind_case() == kDate; -} -inline bool ParameterizedType::has_date() const { - return _internal_has_date(); -} -inline void ParameterizedType::set_has_date() { - _oneof_case_[0] = kDate; -} -inline ::substrait::Type_Date* ParameterizedType::release_date() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.date) - if (_internal_has_date()) { - clear_has_kind(); - ::substrait::Type_Date* temp = kind_.date_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.date_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Date& ParameterizedType::_internal_date() const { - return _internal_has_date() - ? *kind_.date_ - : reinterpret_cast< ::substrait::Type_Date&>(::substrait::_Type_Date_default_instance_); -} -inline const ::substrait::Type_Date& ParameterizedType::date() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.date) - return _internal_date(); -} -inline ::substrait::Type_Date* ParameterizedType::unsafe_arena_release_date() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.date) - if (_internal_has_date()) { - clear_has_kind(); - ::substrait::Type_Date* temp = kind_.date_; - kind_.date_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_date(::substrait::Type_Date* date) { - clear_kind(); - if (date) { - set_has_date(); - kind_.date_ = date; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.date) -} -inline ::substrait::Type_Date* ParameterizedType::_internal_mutable_date() { - if (!_internal_has_date()) { - clear_kind(); - set_has_date(); - kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArenaForAllocation()); - } - return kind_.date_; -} -inline ::substrait::Type_Date* ParameterizedType::mutable_date() { - ::substrait::Type_Date* _msg = _internal_mutable_date(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.date) - return _msg; -} - -// .substrait.Type.Time time = 17; -inline bool ParameterizedType::_internal_has_time() const { - return kind_case() == kTime; -} -inline bool ParameterizedType::has_time() const { - return _internal_has_time(); -} -inline void ParameterizedType::set_has_time() { - _oneof_case_[0] = kTime; -} -inline ::substrait::Type_Time* ParameterizedType::release_time() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.time) - if (_internal_has_time()) { - clear_has_kind(); - ::substrait::Type_Time* temp = kind_.time_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.time_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Time& ParameterizedType::_internal_time() const { - return _internal_has_time() - ? *kind_.time_ - : reinterpret_cast< ::substrait::Type_Time&>(::substrait::_Type_Time_default_instance_); -} -inline const ::substrait::Type_Time& ParameterizedType::time() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.time) - return _internal_time(); -} -inline ::substrait::Type_Time* ParameterizedType::unsafe_arena_release_time() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.time) - if (_internal_has_time()) { - clear_has_kind(); - ::substrait::Type_Time* temp = kind_.time_; - kind_.time_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_time(::substrait::Type_Time* time) { - clear_kind(); - if (time) { - set_has_time(); - kind_.time_ = time; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.time) -} -inline ::substrait::Type_Time* ParameterizedType::_internal_mutable_time() { - if (!_internal_has_time()) { - clear_kind(); - set_has_time(); - kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArenaForAllocation()); - } - return kind_.time_; -} -inline ::substrait::Type_Time* ParameterizedType::mutable_time() { - ::substrait::Type_Time* _msg = _internal_mutable_time(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.time) - return _msg; -} - -// .substrait.Type.IntervalYear interval_year = 19; -inline bool ParameterizedType::_internal_has_interval_year() const { - return kind_case() == kIntervalYear; -} -inline bool ParameterizedType::has_interval_year() const { - return _internal_has_interval_year(); -} -inline void ParameterizedType::set_has_interval_year() { - _oneof_case_[0] = kIntervalYear; -} -inline ::substrait::Type_IntervalYear* ParameterizedType::release_interval_year() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.interval_year) - if (_internal_has_interval_year()) { - clear_has_kind(); - ::substrait::Type_IntervalYear* temp = kind_.interval_year_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.interval_year_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_IntervalYear& ParameterizedType::_internal_interval_year() const { - return _internal_has_interval_year() - ? *kind_.interval_year_ - : reinterpret_cast< ::substrait::Type_IntervalYear&>(::substrait::_Type_IntervalYear_default_instance_); -} -inline const ::substrait::Type_IntervalYear& ParameterizedType::interval_year() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.interval_year) - return _internal_interval_year(); -} -inline ::substrait::Type_IntervalYear* ParameterizedType::unsafe_arena_release_interval_year() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.interval_year) - if (_internal_has_interval_year()) { - clear_has_kind(); - ::substrait::Type_IntervalYear* temp = kind_.interval_year_; - kind_.interval_year_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { - clear_kind(); - if (interval_year) { - set_has_interval_year(); - kind_.interval_year_ = interval_year; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.interval_year) -} -inline ::substrait::Type_IntervalYear* ParameterizedType::_internal_mutable_interval_year() { - if (!_internal_has_interval_year()) { - clear_kind(); - set_has_interval_year(); - kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArenaForAllocation()); - } - return kind_.interval_year_; -} -inline ::substrait::Type_IntervalYear* ParameterizedType::mutable_interval_year() { - ::substrait::Type_IntervalYear* _msg = _internal_mutable_interval_year(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.interval_year) - return _msg; -} - -// .substrait.Type.IntervalDay interval_day = 20; -inline bool ParameterizedType::_internal_has_interval_day() const { - return kind_case() == kIntervalDay; -} -inline bool ParameterizedType::has_interval_day() const { - return _internal_has_interval_day(); -} -inline void ParameterizedType::set_has_interval_day() { - _oneof_case_[0] = kIntervalDay; -} -inline ::substrait::Type_IntervalDay* ParameterizedType::release_interval_day() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.interval_day) - if (_internal_has_interval_day()) { - clear_has_kind(); - ::substrait::Type_IntervalDay* temp = kind_.interval_day_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.interval_day_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_IntervalDay& ParameterizedType::_internal_interval_day() const { - return _internal_has_interval_day() - ? *kind_.interval_day_ - : reinterpret_cast< ::substrait::Type_IntervalDay&>(::substrait::_Type_IntervalDay_default_instance_); -} -inline const ::substrait::Type_IntervalDay& ParameterizedType::interval_day() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.interval_day) - return _internal_interval_day(); -} -inline ::substrait::Type_IntervalDay* ParameterizedType::unsafe_arena_release_interval_day() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.interval_day) - if (_internal_has_interval_day()) { - clear_has_kind(); - ::substrait::Type_IntervalDay* temp = kind_.interval_day_; - kind_.interval_day_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { - clear_kind(); - if (interval_day) { - set_has_interval_day(); - kind_.interval_day_ = interval_day; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.interval_day) -} -inline ::substrait::Type_IntervalDay* ParameterizedType::_internal_mutable_interval_day() { - if (!_internal_has_interval_day()) { - clear_kind(); - set_has_interval_day(); - kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArenaForAllocation()); - } - return kind_.interval_day_; -} -inline ::substrait::Type_IntervalDay* ParameterizedType::mutable_interval_day() { - ::substrait::Type_IntervalDay* _msg = _internal_mutable_interval_day(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.interval_day) - return _msg; -} - -// .substrait.Type.TimestampTZ timestamp_tz = 29; -inline bool ParameterizedType::_internal_has_timestamp_tz() const { - return kind_case() == kTimestampTz; -} -inline bool ParameterizedType::has_timestamp_tz() const { - return _internal_has_timestamp_tz(); -} -inline void ParameterizedType::set_has_timestamp_tz() { - _oneof_case_[0] = kTimestampTz; -} -inline ::substrait::Type_TimestampTZ* ParameterizedType::release_timestamp_tz() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.timestamp_tz) - if (_internal_has_timestamp_tz()) { - clear_has_kind(); - ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.timestamp_tz_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_TimestampTZ& ParameterizedType::_internal_timestamp_tz() const { - return _internal_has_timestamp_tz() - ? *kind_.timestamp_tz_ - : reinterpret_cast< ::substrait::Type_TimestampTZ&>(::substrait::_Type_TimestampTZ_default_instance_); -} -inline const ::substrait::Type_TimestampTZ& ParameterizedType::timestamp_tz() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.timestamp_tz) - return _internal_timestamp_tz(); -} -inline ::substrait::Type_TimestampTZ* ParameterizedType::unsafe_arena_release_timestamp_tz() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.timestamp_tz) - if (_internal_has_timestamp_tz()) { - clear_has_kind(); - ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; - kind_.timestamp_tz_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { - clear_kind(); - if (timestamp_tz) { - set_has_timestamp_tz(); - kind_.timestamp_tz_ = timestamp_tz; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.timestamp_tz) -} -inline ::substrait::Type_TimestampTZ* ParameterizedType::_internal_mutable_timestamp_tz() { - if (!_internal_has_timestamp_tz()) { - clear_kind(); - set_has_timestamp_tz(); - kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArenaForAllocation()); - } - return kind_.timestamp_tz_; -} -inline ::substrait::Type_TimestampTZ* ParameterizedType::mutable_timestamp_tz() { - ::substrait::Type_TimestampTZ* _msg = _internal_mutable_timestamp_tz(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.timestamp_tz) - return _msg; -} - -// .substrait.Type.UUID uuid = 32; -inline bool ParameterizedType::_internal_has_uuid() const { - return kind_case() == kUuid; -} -inline bool ParameterizedType::has_uuid() const { - return _internal_has_uuid(); -} -inline void ParameterizedType::set_has_uuid() { - _oneof_case_[0] = kUuid; -} -inline ::substrait::Type_UUID* ParameterizedType::release_uuid() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.uuid) - if (_internal_has_uuid()) { - clear_has_kind(); - ::substrait::Type_UUID* temp = kind_.uuid_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.uuid_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_UUID& ParameterizedType::_internal_uuid() const { - return _internal_has_uuid() - ? *kind_.uuid_ - : reinterpret_cast< ::substrait::Type_UUID&>(::substrait::_Type_UUID_default_instance_); -} -inline const ::substrait::Type_UUID& ParameterizedType::uuid() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.uuid) - return _internal_uuid(); -} -inline ::substrait::Type_UUID* ParameterizedType::unsafe_arena_release_uuid() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.uuid) - if (_internal_has_uuid()) { - clear_has_kind(); - ::substrait::Type_UUID* temp = kind_.uuid_; - kind_.uuid_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_uuid(::substrait::Type_UUID* uuid) { - clear_kind(); - if (uuid) { - set_has_uuid(); - kind_.uuid_ = uuid; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.uuid) -} -inline ::substrait::Type_UUID* ParameterizedType::_internal_mutable_uuid() { - if (!_internal_has_uuid()) { - clear_kind(); - set_has_uuid(); - kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArenaForAllocation()); - } - return kind_.uuid_; -} -inline ::substrait::Type_UUID* ParameterizedType::mutable_uuid() { - ::substrait::Type_UUID* _msg = _internal_mutable_uuid(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.uuid) - return _msg; -} - -// .substrait.ParameterizedType.ParameterizedFixedChar fixed_char = 21; -inline bool ParameterizedType::_internal_has_fixed_char() const { - return kind_case() == kFixedChar; -} -inline bool ParameterizedType::has_fixed_char() const { - return _internal_has_fixed_char(); -} -inline void ParameterizedType::set_has_fixed_char() { - _oneof_case_[0] = kFixedChar; -} -inline void ParameterizedType::clear_fixed_char() { - if (_internal_has_fixed_char()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_char_; - } - clear_has_kind(); - } -} -inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::release_fixed_char() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fixed_char) - if (_internal_has_fixed_char()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fixed_char_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::_internal_fixed_char() const { - return _internal_has_fixed_char() - ? *kind_.fixed_char_ - : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedFixedChar&>(::substrait::_ParameterizedType_ParameterizedFixedChar_default_instance_); -} -inline const ::substrait::ParameterizedType_ParameterizedFixedChar& ParameterizedType::fixed_char() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fixed_char) - return _internal_fixed_char(); -} -inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::unsafe_arena_release_fixed_char() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fixed_char) - if (_internal_has_fixed_char()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedFixedChar* temp = kind_.fixed_char_; - kind_.fixed_char_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_fixed_char(::substrait::ParameterizedType_ParameterizedFixedChar* fixed_char) { - clear_kind(); - if (fixed_char) { - set_has_fixed_char(); - kind_.fixed_char_ = fixed_char; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fixed_char) -} -inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::_internal_mutable_fixed_char() { - if (!_internal_has_fixed_char()) { - clear_kind(); - set_has_fixed_char(); - kind_.fixed_char_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedChar >(GetArenaForAllocation()); - } - return kind_.fixed_char_; -} -inline ::substrait::ParameterizedType_ParameterizedFixedChar* ParameterizedType::mutable_fixed_char() { - ::substrait::ParameterizedType_ParameterizedFixedChar* _msg = _internal_mutable_fixed_char(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fixed_char) - return _msg; -} - -// .substrait.ParameterizedType.ParameterizedVarChar varchar = 22; -inline bool ParameterizedType::_internal_has_varchar() const { - return kind_case() == kVarchar; -} -inline bool ParameterizedType::has_varchar() const { - return _internal_has_varchar(); -} -inline void ParameterizedType::set_has_varchar() { - _oneof_case_[0] = kVarchar; -} -inline void ParameterizedType::clear_varchar() { - if (_internal_has_varchar()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.varchar_; - } - clear_has_kind(); - } -} -inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::release_varchar() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.varchar) - if (_internal_has_varchar()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.varchar_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::_internal_varchar() const { - return _internal_has_varchar() - ? *kind_.varchar_ - : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedVarChar&>(::substrait::_ParameterizedType_ParameterizedVarChar_default_instance_); -} -inline const ::substrait::ParameterizedType_ParameterizedVarChar& ParameterizedType::varchar() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.varchar) - return _internal_varchar(); -} -inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::unsafe_arena_release_varchar() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.varchar) - if (_internal_has_varchar()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedVarChar* temp = kind_.varchar_; - kind_.varchar_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_varchar(::substrait::ParameterizedType_ParameterizedVarChar* varchar) { - clear_kind(); - if (varchar) { - set_has_varchar(); - kind_.varchar_ = varchar; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.varchar) -} -inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::_internal_mutable_varchar() { - if (!_internal_has_varchar()) { - clear_kind(); - set_has_varchar(); - kind_.varchar_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedVarChar >(GetArenaForAllocation()); - } - return kind_.varchar_; -} -inline ::substrait::ParameterizedType_ParameterizedVarChar* ParameterizedType::mutable_varchar() { - ::substrait::ParameterizedType_ParameterizedVarChar* _msg = _internal_mutable_varchar(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.varchar) - return _msg; -} - -// .substrait.ParameterizedType.ParameterizedFixedBinary fixed_binary = 23; -inline bool ParameterizedType::_internal_has_fixed_binary() const { - return kind_case() == kFixedBinary; -} -inline bool ParameterizedType::has_fixed_binary() const { - return _internal_has_fixed_binary(); -} -inline void ParameterizedType::set_has_fixed_binary() { - _oneof_case_[0] = kFixedBinary; -} -inline void ParameterizedType::clear_fixed_binary() { - if (_internal_has_fixed_binary()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_binary_; - } - clear_has_kind(); - } -} -inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::release_fixed_binary() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.fixed_binary) - if (_internal_has_fixed_binary()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fixed_binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::_internal_fixed_binary() const { - return _internal_has_fixed_binary() - ? *kind_.fixed_binary_ - : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedFixedBinary&>(::substrait::_ParameterizedType_ParameterizedFixedBinary_default_instance_); -} -inline const ::substrait::ParameterizedType_ParameterizedFixedBinary& ParameterizedType::fixed_binary() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.fixed_binary) - return _internal_fixed_binary(); -} -inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::unsafe_arena_release_fixed_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.fixed_binary) - if (_internal_has_fixed_binary()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedFixedBinary* temp = kind_.fixed_binary_; - kind_.fixed_binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_fixed_binary(::substrait::ParameterizedType_ParameterizedFixedBinary* fixed_binary) { - clear_kind(); - if (fixed_binary) { - set_has_fixed_binary(); - kind_.fixed_binary_ = fixed_binary; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.fixed_binary) -} -inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::_internal_mutable_fixed_binary() { - if (!_internal_has_fixed_binary()) { - clear_kind(); - set_has_fixed_binary(); - kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedFixedBinary >(GetArenaForAllocation()); - } - return kind_.fixed_binary_; -} -inline ::substrait::ParameterizedType_ParameterizedFixedBinary* ParameterizedType::mutable_fixed_binary() { - ::substrait::ParameterizedType_ParameterizedFixedBinary* _msg = _internal_mutable_fixed_binary(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.fixed_binary) - return _msg; -} - -// .substrait.ParameterizedType.ParameterizedDecimal decimal = 24; -inline bool ParameterizedType::_internal_has_decimal() const { - return kind_case() == kDecimal; -} -inline bool ParameterizedType::has_decimal() const { - return _internal_has_decimal(); -} -inline void ParameterizedType::set_has_decimal() { - _oneof_case_[0] = kDecimal; -} -inline void ParameterizedType::clear_decimal() { - if (_internal_has_decimal()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.decimal_; - } - clear_has_kind(); - } -} -inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::release_decimal() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.decimal) - if (_internal_has_decimal()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.decimal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::_internal_decimal() const { - return _internal_has_decimal() - ? *kind_.decimal_ - : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedDecimal&>(::substrait::_ParameterizedType_ParameterizedDecimal_default_instance_); -} -inline const ::substrait::ParameterizedType_ParameterizedDecimal& ParameterizedType::decimal() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.decimal) - return _internal_decimal(); -} -inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::unsafe_arena_release_decimal() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.decimal) - if (_internal_has_decimal()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedDecimal* temp = kind_.decimal_; - kind_.decimal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_decimal(::substrait::ParameterizedType_ParameterizedDecimal* decimal) { - clear_kind(); - if (decimal) { - set_has_decimal(); - kind_.decimal_ = decimal; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.decimal) -} -inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::_internal_mutable_decimal() { - if (!_internal_has_decimal()) { - clear_kind(); - set_has_decimal(); - kind_.decimal_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedDecimal >(GetArenaForAllocation()); - } - return kind_.decimal_; -} -inline ::substrait::ParameterizedType_ParameterizedDecimal* ParameterizedType::mutable_decimal() { - ::substrait::ParameterizedType_ParameterizedDecimal* _msg = _internal_mutable_decimal(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.decimal) - return _msg; -} - -// .substrait.ParameterizedType.ParameterizedStruct struct = 25; -inline bool ParameterizedType::_internal_has_struct_() const { - return kind_case() == kStruct; -} -inline bool ParameterizedType::has_struct_() const { - return _internal_has_struct_(); -} -inline void ParameterizedType::set_has_struct_() { - _oneof_case_[0] = kStruct; -} -inline void ParameterizedType::clear_struct_() { - if (_internal_has_struct_()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.struct__; - } - clear_has_kind(); - } -} -inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::release_struct_() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.struct) - if (_internal_has_struct_()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::_internal_struct_() const { - return _internal_has_struct_() - ? *kind_.struct__ - : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedStruct&>(::substrait::_ParameterizedType_ParameterizedStruct_default_instance_); -} -inline const ::substrait::ParameterizedType_ParameterizedStruct& ParameterizedType::struct_() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.struct) - return _internal_struct_(); -} -inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.struct) - if (_internal_has_struct_()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedStruct* temp = kind_.struct__; - kind_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_struct_(::substrait::ParameterizedType_ParameterizedStruct* struct_) { - clear_kind(); - if (struct_) { - set_has_struct_(); - kind_.struct__ = struct_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.struct) -} -inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::_internal_mutable_struct_() { - if (!_internal_has_struct_()) { - clear_kind(); - set_has_struct_(); - kind_.struct__ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedStruct >(GetArenaForAllocation()); - } - return kind_.struct__; -} -inline ::substrait::ParameterizedType_ParameterizedStruct* ParameterizedType::mutable_struct_() { - ::substrait::ParameterizedType_ParameterizedStruct* _msg = _internal_mutable_struct_(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.struct) - return _msg; -} - -// .substrait.ParameterizedType.ParameterizedList list = 27; -inline bool ParameterizedType::_internal_has_list() const { - return kind_case() == kList; -} -inline bool ParameterizedType::has_list() const { - return _internal_has_list(); -} -inline void ParameterizedType::set_has_list() { - _oneof_case_[0] = kList; -} -inline void ParameterizedType::clear_list() { - if (_internal_has_list()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.list_; - } - clear_has_kind(); - } -} -inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::release_list() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.list) - if (_internal_has_list()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ParameterizedType_ParameterizedList& ParameterizedType::_internal_list() const { - return _internal_has_list() - ? *kind_.list_ - : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedList&>(::substrait::_ParameterizedType_ParameterizedList_default_instance_); -} -inline const ::substrait::ParameterizedType_ParameterizedList& ParameterizedType::list() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.list) - return _internal_list(); -} -inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.list) - if (_internal_has_list()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedList* temp = kind_.list_; - kind_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_list(::substrait::ParameterizedType_ParameterizedList* list) { - clear_kind(); - if (list) { - set_has_list(); - kind_.list_ = list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.list) -} -inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::_internal_mutable_list() { - if (!_internal_has_list()) { - clear_kind(); - set_has_list(); - kind_.list_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedList >(GetArenaForAllocation()); - } - return kind_.list_; -} -inline ::substrait::ParameterizedType_ParameterizedList* ParameterizedType::mutable_list() { - ::substrait::ParameterizedType_ParameterizedList* _msg = _internal_mutable_list(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.list) - return _msg; -} - -// .substrait.ParameterizedType.ParameterizedMap map = 28; -inline bool ParameterizedType::_internal_has_map() const { - return kind_case() == kMap; -} -inline bool ParameterizedType::has_map() const { - return _internal_has_map(); -} -inline void ParameterizedType::set_has_map() { - _oneof_case_[0] = kMap; -} -inline void ParameterizedType::clear_map() { - if (_internal_has_map()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.map_; - } - clear_has_kind(); - } -} -inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::release_map() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.map) - if (_internal_has_map()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::_internal_map() const { - return _internal_has_map() - ? *kind_.map_ - : reinterpret_cast< ::substrait::ParameterizedType_ParameterizedMap&>(::substrait::_ParameterizedType_ParameterizedMap_default_instance_); -} -inline const ::substrait::ParameterizedType_ParameterizedMap& ParameterizedType::map() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.map) - return _internal_map(); -} -inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.map) - if (_internal_has_map()) { - clear_has_kind(); - ::substrait::ParameterizedType_ParameterizedMap* temp = kind_.map_; - kind_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_map(::substrait::ParameterizedType_ParameterizedMap* map) { - clear_kind(); - if (map) { - set_has_map(); - kind_.map_ = map; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.map) -} -inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::_internal_mutable_map() { - if (!_internal_has_map()) { - clear_kind(); - set_has_map(); - kind_.map_ = CreateMaybeMessage< ::substrait::ParameterizedType_ParameterizedMap >(GetArenaForAllocation()); - } - return kind_.map_; -} -inline ::substrait::ParameterizedType_ParameterizedMap* ParameterizedType::mutable_map() { - ::substrait::ParameterizedType_ParameterizedMap* _msg = _internal_mutable_map(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.map) - return _msg; -} - -// uint32 user_defined_pointer = 31; -inline bool ParameterizedType::_internal_has_user_defined_pointer() const { - return kind_case() == kUserDefinedPointer; -} -inline bool ParameterizedType::has_user_defined_pointer() const { - return _internal_has_user_defined_pointer(); -} -inline void ParameterizedType::set_has_user_defined_pointer() { - _oneof_case_[0] = kUserDefinedPointer; -} -inline void ParameterizedType::clear_user_defined_pointer() { - if (_internal_has_user_defined_pointer()) { - kind_.user_defined_pointer_ = 0u; - clear_has_kind(); - } -} -inline uint32_t ParameterizedType::_internal_user_defined_pointer() const { - if (_internal_has_user_defined_pointer()) { - return kind_.user_defined_pointer_; - } - return 0u; -} -inline void ParameterizedType::_internal_set_user_defined_pointer(uint32_t value) { - if (!_internal_has_user_defined_pointer()) { - clear_kind(); - set_has_user_defined_pointer(); - } - kind_.user_defined_pointer_ = value; -} -inline uint32_t ParameterizedType::user_defined_pointer() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.user_defined_pointer) - return _internal_user_defined_pointer(); -} -inline void ParameterizedType::set_user_defined_pointer(uint32_t value) { - _internal_set_user_defined_pointer(value); - // @@protoc_insertion_point(field_set:substrait.ParameterizedType.user_defined_pointer) -} - -// .substrait.ParameterizedType.TypeParameter type_parameter = 33; -inline bool ParameterizedType::_internal_has_type_parameter() const { - return kind_case() == kTypeParameter; -} -inline bool ParameterizedType::has_type_parameter() const { - return _internal_has_type_parameter(); -} -inline void ParameterizedType::set_has_type_parameter() { - _oneof_case_[0] = kTypeParameter; -} -inline void ParameterizedType::clear_type_parameter() { - if (_internal_has_type_parameter()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.type_parameter_; - } - clear_has_kind(); - } -} -inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::release_type_parameter() { - // @@protoc_insertion_point(field_release:substrait.ParameterizedType.type_parameter) - if (_internal_has_type_parameter()) { - clear_has_kind(); - ::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.type_parameter_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ParameterizedType_TypeParameter& ParameterizedType::_internal_type_parameter() const { - return _internal_has_type_parameter() - ? *kind_.type_parameter_ - : reinterpret_cast< ::substrait::ParameterizedType_TypeParameter&>(::substrait::_ParameterizedType_TypeParameter_default_instance_); -} -inline const ::substrait::ParameterizedType_TypeParameter& ParameterizedType::type_parameter() const { - // @@protoc_insertion_point(field_get:substrait.ParameterizedType.type_parameter) - return _internal_type_parameter(); -} -inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::unsafe_arena_release_type_parameter() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ParameterizedType.type_parameter) - if (_internal_has_type_parameter()) { - clear_has_kind(); - ::substrait::ParameterizedType_TypeParameter* temp = kind_.type_parameter_; - kind_.type_parameter_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ParameterizedType::unsafe_arena_set_allocated_type_parameter(::substrait::ParameterizedType_TypeParameter* type_parameter) { - clear_kind(); - if (type_parameter) { - set_has_type_parameter(); - kind_.type_parameter_ = type_parameter; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ParameterizedType.type_parameter) -} -inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::_internal_mutable_type_parameter() { - if (!_internal_has_type_parameter()) { - clear_kind(); - set_has_type_parameter(); - kind_.type_parameter_ = CreateMaybeMessage< ::substrait::ParameterizedType_TypeParameter >(GetArenaForAllocation()); - } - return kind_.type_parameter_; -} -inline ::substrait::ParameterizedType_TypeParameter* ParameterizedType::mutable_type_parameter() { - ::substrait::ParameterizedType_TypeParameter* _msg = _internal_mutable_type_parameter(); - // @@protoc_insertion_point(field_mutable:substrait.ParameterizedType.type_parameter) - return _msg; -} - -inline bool ParameterizedType::has_kind() const { - return kind_case() != KIND_NOT_SET; -} -inline void ParameterizedType::clear_has_kind() { - _oneof_case_[0] = KIND_NOT_SET; -} -inline ParameterizedType::KindCase ParameterizedType::kind_case() const { - return ParameterizedType::KindCase(_oneof_case_[0]); -} -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace substrait - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fparameterized_5ftypes_2eproto diff --git a/cpp/src/generated/substrait/plan.pb.cc b/cpp/src/generated/substrait/plan.pb.cc deleted file mode 100644 index 4b77e56bfbd..00000000000 --- a/cpp/src/generated/substrait/plan.pb.cc +++ /dev/null @@ -1,796 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/plan.proto - -#include "substrait/plan.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace substrait { -constexpr PlanRel::PlanRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct PlanRelDefaultTypeInternal { - constexpr PlanRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~PlanRelDefaultTypeInternal() {} - union { - PlanRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PlanRelDefaultTypeInternal _PlanRel_default_instance_; -constexpr Plan::Plan( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : extension_uris_() - , extensions_() - , relations_() - , expected_type_urls_() - , advanced_extensions_(nullptr){} -struct PlanDefaultTypeInternal { - constexpr PlanDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~PlanDefaultTypeInternal() {} - union { - Plan _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PlanDefaultTypeInternal _Plan_default_instance_; -} // namespace substrait -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2fplan_2eproto[2]; -static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_substrait_2fplan_2eproto = nullptr; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2fplan_2eproto = nullptr; - -const uint32_t TableStruct_substrait_2fplan_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::PlanRel, rel_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Plan, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Plan, extension_uris_), - PROTOBUF_FIELD_OFFSET(::substrait::Plan, extensions_), - PROTOBUF_FIELD_OFFSET(::substrait::Plan, relations_), - PROTOBUF_FIELD_OFFSET(::substrait::Plan, advanced_extensions_), - PROTOBUF_FIELD_OFFSET(::substrait::Plan, expected_type_urls_), -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, -1, sizeof(::substrait::PlanRel)}, - { 9, -1, -1, sizeof(::substrait::Plan)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::substrait::_PlanRel_default_instance_), - reinterpret_cast(&::substrait::_Plan_default_instance_), -}; - -const char descriptor_table_protodef_substrait_2fplan_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\024substrait/plan.proto\022\tsubstrait\032\031subst" - "rait/relations.proto\032%substrait/extensio" - "ns/extensions.proto\"X\n\007PlanRel\022\035\n\003rel\030\001 " - "\001(\0132\016.substrait.RelH\000\022\"\n\004root\030\002 \001(\0132\022.su" - "bstrait.RelRootH\000B\n\n\010rel_type\"\227\002\n\004Plan\022@" - "\n\016extension_uris\030\001 \003(\0132(.substrait.exten" - "sions.SimpleExtensionURI\022D\n\nextensions\030\002" - " \003(\01320.substrait.extensions.SimpleExtens" - "ionDeclaration\022%\n\trelations\030\003 \003(\0132\022.subs" - "trait.PlanRel\022D\n\023advanced_extensions\030\004 \001" - "(\0132\'.substrait.extensions.AdvancedExtens" - "ion\022\032\n\022expected_type_urls\030\005 \003(\tB+\n\022io.su" - "bstrait.protoP\001\252\002\022Substrait.Protobufb\006pr" - "oto3" - ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2fplan_2eproto_deps[2] = { - &::descriptor_table_substrait_2fextensions_2fextensions_2eproto, - &::descriptor_table_substrait_2frelations_2eproto, -}; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2fplan_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fplan_2eproto = { - false, false, 524, descriptor_table_protodef_substrait_2fplan_2eproto, "substrait/plan.proto", - &descriptor_table_substrait_2fplan_2eproto_once, descriptor_table_substrait_2fplan_2eproto_deps, 2, 2, - schemas, file_default_instances, TableStruct_substrait_2fplan_2eproto::offsets, - file_level_metadata_substrait_2fplan_2eproto, file_level_enum_descriptors_substrait_2fplan_2eproto, file_level_service_descriptors_substrait_2fplan_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2fplan_2eproto_getter() { - return &descriptor_table_substrait_2fplan_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2fplan_2eproto(&descriptor_table_substrait_2fplan_2eproto); -namespace substrait { - -// =================================================================== - -class PlanRel::_Internal { - public: - static const ::substrait::Rel& rel(const PlanRel* msg); - static const ::substrait::RelRoot& root(const PlanRel* msg); -}; - -const ::substrait::Rel& -PlanRel::_Internal::rel(const PlanRel* msg) { - return *msg->rel_type_.rel_; -} -const ::substrait::RelRoot& -PlanRel::_Internal::root(const PlanRel* msg) { - return *msg->rel_type_.root_; -} -void PlanRel::set_allocated_rel(::substrait::Rel* rel) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (rel) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rel)); - if (message_arena != submessage_arena) { - rel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, rel, submessage_arena); - } - set_has_rel(); - rel_type_.rel_ = rel; - } - // @@protoc_insertion_point(field_set_allocated:substrait.PlanRel.rel) -} -void PlanRel::clear_rel() { - if (_internal_has_rel()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.rel_; - } - clear_has_rel_type(); - } -} -void PlanRel::set_allocated_root(::substrait::RelRoot* root) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (root) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(root)); - if (message_arena != submessage_arena) { - root = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, root, submessage_arena); - } - set_has_root(); - rel_type_.root_ = root; - } - // @@protoc_insertion_point(field_set_allocated:substrait.PlanRel.root) -} -void PlanRel::clear_root() { - if (_internal_has_root()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.root_; - } - clear_has_rel_type(); - } -} -PlanRel::PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.PlanRel) -} -PlanRel::PlanRel(const PlanRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_rel_type(); - switch (from.rel_type_case()) { - case kRel: { - _internal_mutable_rel()->::substrait::Rel::MergeFrom(from._internal_rel()); - break; - } - case kRoot: { - _internal_mutable_root()->::substrait::RelRoot::MergeFrom(from._internal_root()); - break; - } - case REL_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.PlanRel) -} - -inline void PlanRel::SharedCtor() { -clear_has_rel_type(); -} - -PlanRel::~PlanRel() { - // @@protoc_insertion_point(destructor:substrait.PlanRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void PlanRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_rel_type()) { - clear_rel_type(); - } -} - -void PlanRel::ArenaDtor(void* object) { - PlanRel* _this = reinterpret_cast< PlanRel* >(object); - (void)_this; -} -void PlanRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void PlanRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void PlanRel::clear_rel_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.PlanRel) - switch (rel_type_case()) { - case kRel: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.rel_; - } - break; - } - case kRoot: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.root_; - } - break; - } - case REL_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = REL_TYPE_NOT_SET; -} - - -void PlanRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.PlanRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_rel_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* PlanRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Rel rel = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_rel(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.RelRoot root = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_root(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* PlanRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.PlanRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Rel rel = 1; - if (_internal_has_rel()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::rel(this), target, stream); - } - - // .substrait.RelRoot root = 2; - if (_internal_has_root()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::root(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.PlanRel) - return target; -} - -size_t PlanRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.PlanRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (rel_type_case()) { - // .substrait.Rel rel = 1; - case kRel: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.rel_); - break; - } - // .substrait.RelRoot root = 2; - case kRoot: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.root_); - break; - } - case REL_TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData PlanRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - PlanRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*PlanRel::GetClassData() const { return &_class_data_; } - -void PlanRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void PlanRel::MergeFrom(const PlanRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.PlanRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.rel_type_case()) { - case kRel: { - _internal_mutable_rel()->::substrait::Rel::MergeFrom(from._internal_rel()); - break; - } - case kRoot: { - _internal_mutable_root()->::substrait::RelRoot::MergeFrom(from._internal_root()); - break; - } - case REL_TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void PlanRel::CopyFrom(const PlanRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.PlanRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PlanRel::IsInitialized() const { - return true; -} - -void PlanRel::InternalSwap(PlanRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(rel_type_, other->rel_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata PlanRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fplan_2eproto_getter, &descriptor_table_substrait_2fplan_2eproto_once, - file_level_metadata_substrait_2fplan_2eproto[0]); -} - -// =================================================================== - -class Plan::_Internal { - public: - static const ::substrait::extensions::AdvancedExtension& advanced_extensions(const Plan* msg); -}; - -const ::substrait::extensions::AdvancedExtension& -Plan::_Internal::advanced_extensions(const Plan* msg) { - return *msg->advanced_extensions_; -} -void Plan::clear_extension_uris() { - extension_uris_.Clear(); -} -void Plan::clear_extensions() { - extensions_.Clear(); -} -void Plan::clear_advanced_extensions() { - if (GetArenaForAllocation() == nullptr && advanced_extensions_ != nullptr) { - delete advanced_extensions_; - } - advanced_extensions_ = nullptr; -} -Plan::Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - extension_uris_(arena), - extensions_(arena), - relations_(arena), - expected_type_urls_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Plan) -} -Plan::Plan(const Plan& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - extension_uris_(from.extension_uris_), - extensions_(from.extensions_), - relations_(from.relations_), - expected_type_urls_(from.expected_type_urls_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_advanced_extensions()) { - advanced_extensions_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extensions_); - } else { - advanced_extensions_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.Plan) -} - -inline void Plan::SharedCtor() { -advanced_extensions_ = nullptr; -} - -Plan::~Plan() { - // @@protoc_insertion_point(destructor:substrait.Plan) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Plan::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete advanced_extensions_; -} - -void Plan::ArenaDtor(void* object) { - Plan* _this = reinterpret_cast< Plan* >(object); - (void)_this; -} -void Plan::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Plan::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Plan::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Plan) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - extension_uris_.Clear(); - extensions_.Clear(); - relations_.Clear(); - expected_type_urls_.Clear(); - if (GetArenaForAllocation() == nullptr && advanced_extensions_ != nullptr) { - delete advanced_extensions_; - } - advanced_extensions_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Plan::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_extension_uris(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_extensions(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // repeated .substrait.PlanRel relations = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_relations(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extensions = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extensions(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated string expected_type_urls = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_expected_type_urls(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.Plan.expected_type_urls")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(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* Plan::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Plan) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_extension_uris_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_extension_uris(i), target, stream); - } - - // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_extensions_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_extensions(i), target, stream); - } - - // repeated .substrait.PlanRel relations = 3; - for (unsigned int i = 0, - n = static_cast(this->_internal_relations_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, this->_internal_relations(i), target, stream); - } - - // .substrait.extensions.AdvancedExtension advanced_extensions = 4; - if (this->_internal_has_advanced_extensions()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::advanced_extensions(this), target, stream); - } - - // repeated string expected_type_urls = 5; - for (int i = 0, n = this->_internal_expected_type_urls_size(); i < n; i++) { - const auto& s = this->_internal_expected_type_urls(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.Plan.expected_type_urls"); - target = stream->WriteString(5, s, target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Plan) - return target; -} - -size_t Plan::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Plan) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; - total_size += 1UL * this->_internal_extension_uris_size(); - for (const auto& msg : this->extension_uris_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; - total_size += 1UL * this->_internal_extensions_size(); - for (const auto& msg : this->extensions_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .substrait.PlanRel relations = 3; - total_size += 1UL * this->_internal_relations_size(); - for (const auto& msg : this->relations_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated string expected_type_urls = 5; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(expected_type_urls_.size()); - for (int i = 0, n = expected_type_urls_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - expected_type_urls_.Get(i)); - } - - // .substrait.extensions.AdvancedExtension advanced_extensions = 4; - if (this->_internal_has_advanced_extensions()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extensions_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Plan::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Plan::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Plan::GetClassData() const { return &_class_data_; } - -void Plan::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Plan::MergeFrom(const Plan& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Plan) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - extension_uris_.MergeFrom(from.extension_uris_); - extensions_.MergeFrom(from.extensions_); - relations_.MergeFrom(from.relations_); - expected_type_urls_.MergeFrom(from.expected_type_urls_); - if (from._internal_has_advanced_extensions()) { - _internal_mutable_advanced_extensions()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extensions()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Plan::CopyFrom(const Plan& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Plan) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Plan::IsInitialized() const { - return true; -} - -void Plan::InternalSwap(Plan* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - extension_uris_.InternalSwap(&other->extension_uris_); - extensions_.InternalSwap(&other->extensions_); - relations_.InternalSwap(&other->relations_); - expected_type_urls_.InternalSwap(&other->expected_type_urls_); - swap(advanced_extensions_, other->advanced_extensions_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Plan::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2fplan_2eproto_getter, &descriptor_table_substrait_2fplan_2eproto_once, - file_level_metadata_substrait_2fplan_2eproto[1]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::substrait::PlanRel* Arena::CreateMaybeMessage< ::substrait::PlanRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::PlanRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Plan* Arena::CreateMaybeMessage< ::substrait::Plan >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Plan >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/plan.pb.h b/cpp/src/generated/substrait/plan.pb.h deleted file mode 100644 index b31f812c569..00000000000 --- a/cpp/src/generated/substrait/plan.pb.h +++ /dev/null @@ -1,951 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/plan.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2fplan_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_substrait_2fplan_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3019000 -#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 3019003 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include "substrait/relations.pb.h" -#include "substrait/extensions/extensions.pb.h" -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_substrait_2fplan_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_substrait_2fplan_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const uint32_t offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2fplan_2eproto; -namespace substrait { -class Plan; -struct PlanDefaultTypeInternal; -extern PlanDefaultTypeInternal _Plan_default_instance_; -class PlanRel; -struct PlanRelDefaultTypeInternal; -extern PlanRelDefaultTypeInternal _PlanRel_default_instance_; -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> ::substrait::Plan* Arena::CreateMaybeMessage<::substrait::Plan>(Arena*); -template<> ::substrait::PlanRel* Arena::CreateMaybeMessage<::substrait::PlanRel>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace substrait { - -// =================================================================== - -class PlanRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.PlanRel) */ { - public: - inline PlanRel() : PlanRel(nullptr) {} - ~PlanRel() override; - explicit constexpr PlanRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - PlanRel(const PlanRel& from); - PlanRel(PlanRel&& from) noexcept - : PlanRel() { - *this = ::std::move(from); - } - - inline PlanRel& operator=(const PlanRel& from) { - CopyFrom(from); - return *this; - } - inline PlanRel& operator=(PlanRel&& 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 PlanRel& default_instance() { - return *internal_default_instance(); - } - enum RelTypeCase { - kRel = 1, - kRoot = 2, - REL_TYPE_NOT_SET = 0, - }; - - static inline const PlanRel* internal_default_instance() { - return reinterpret_cast( - &_PlanRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(PlanRel& a, PlanRel& b) { - a.Swap(&b); - } - inline void Swap(PlanRel* 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(PlanRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PlanRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const PlanRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const PlanRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(PlanRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.PlanRel"; - } - protected: - explicit PlanRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kRelFieldNumber = 1, - kRootFieldNumber = 2, - }; - // .substrait.Rel rel = 1; - bool has_rel() const; - private: - bool _internal_has_rel() const; - public: - void clear_rel(); - const ::substrait::Rel& rel() const; - PROTOBUF_NODISCARD ::substrait::Rel* release_rel(); - ::substrait::Rel* mutable_rel(); - void set_allocated_rel(::substrait::Rel* rel); - private: - const ::substrait::Rel& _internal_rel() const; - ::substrait::Rel* _internal_mutable_rel(); - public: - void unsafe_arena_set_allocated_rel( - ::substrait::Rel* rel); - ::substrait::Rel* unsafe_arena_release_rel(); - - // .substrait.RelRoot root = 2; - bool has_root() const; - private: - bool _internal_has_root() const; - public: - void clear_root(); - const ::substrait::RelRoot& root() const; - PROTOBUF_NODISCARD ::substrait::RelRoot* release_root(); - ::substrait::RelRoot* mutable_root(); - void set_allocated_root(::substrait::RelRoot* root); - private: - const ::substrait::RelRoot& _internal_root() const; - ::substrait::RelRoot* _internal_mutable_root(); - public: - void unsafe_arena_set_allocated_root( - ::substrait::RelRoot* root); - ::substrait::RelRoot* unsafe_arena_release_root(); - - void clear_rel_type(); - RelTypeCase rel_type_case() const; - // @@protoc_insertion_point(class_scope:substrait.PlanRel) - private: - class _Internal; - void set_has_rel(); - void set_has_root(); - - inline bool has_rel_type() const; - inline void clear_has_rel_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union RelTypeUnion { - constexpr RelTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Rel* rel_; - ::substrait::RelRoot* root_; - } rel_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2fplan_2eproto; -}; -// ------------------------------------------------------------------- - -class Plan final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Plan) */ { - public: - inline Plan() : Plan(nullptr) {} - ~Plan() override; - explicit constexpr Plan(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Plan(const Plan& from); - Plan(Plan&& from) noexcept - : Plan() { - *this = ::std::move(from); - } - - inline Plan& operator=(const Plan& from) { - CopyFrom(from); - return *this; - } - inline Plan& operator=(Plan&& 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 Plan& default_instance() { - return *internal_default_instance(); - } - static inline const Plan* internal_default_instance() { - return reinterpret_cast( - &_Plan_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(Plan& a, Plan& b) { - a.Swap(&b); - } - inline void Swap(Plan* 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(Plan* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Plan* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Plan& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Plan& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Plan* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Plan"; - } - protected: - explicit Plan(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kExtensionUrisFieldNumber = 1, - kExtensionsFieldNumber = 2, - kRelationsFieldNumber = 3, - kExpectedTypeUrlsFieldNumber = 5, - kAdvancedExtensionsFieldNumber = 4, - }; - // repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; - int extension_uris_size() const; - private: - int _internal_extension_uris_size() const; - public: - void clear_extension_uris(); - ::substrait::extensions::SimpleExtensionURI* mutable_extension_uris(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >* - mutable_extension_uris(); - private: - const ::substrait::extensions::SimpleExtensionURI& _internal_extension_uris(int index) const; - ::substrait::extensions::SimpleExtensionURI* _internal_add_extension_uris(); - public: - const ::substrait::extensions::SimpleExtensionURI& extension_uris(int index) const; - ::substrait::extensions::SimpleExtensionURI* add_extension_uris(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >& - extension_uris() const; - - // repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; - int extensions_size() const; - private: - int _internal_extensions_size() const; - public: - void clear_extensions(); - ::substrait::extensions::SimpleExtensionDeclaration* mutable_extensions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >* - mutable_extensions(); - private: - const ::substrait::extensions::SimpleExtensionDeclaration& _internal_extensions(int index) const; - ::substrait::extensions::SimpleExtensionDeclaration* _internal_add_extensions(); - public: - const ::substrait::extensions::SimpleExtensionDeclaration& extensions(int index) const; - ::substrait::extensions::SimpleExtensionDeclaration* add_extensions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >& - extensions() const; - - // repeated .substrait.PlanRel relations = 3; - int relations_size() const; - private: - int _internal_relations_size() const; - public: - void clear_relations(); - ::substrait::PlanRel* mutable_relations(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >* - mutable_relations(); - private: - const ::substrait::PlanRel& _internal_relations(int index) const; - ::substrait::PlanRel* _internal_add_relations(); - public: - const ::substrait::PlanRel& relations(int index) const; - ::substrait::PlanRel* add_relations(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >& - relations() const; - - // repeated string expected_type_urls = 5; - int expected_type_urls_size() const; - private: - int _internal_expected_type_urls_size() const; - public: - void clear_expected_type_urls(); - const std::string& expected_type_urls(int index) const; - std::string* mutable_expected_type_urls(int index); - void set_expected_type_urls(int index, const std::string& value); - void set_expected_type_urls(int index, std::string&& value); - void set_expected_type_urls(int index, const char* value); - void set_expected_type_urls(int index, const char* value, size_t size); - std::string* add_expected_type_urls(); - void add_expected_type_urls(const std::string& value); - void add_expected_type_urls(std::string&& value); - void add_expected_type_urls(const char* value); - void add_expected_type_urls(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& expected_type_urls() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_expected_type_urls(); - private: - const std::string& _internal_expected_type_urls(int index) const; - std::string* _internal_add_expected_type_urls(); - public: - - // .substrait.extensions.AdvancedExtension advanced_extensions = 4; - bool has_advanced_extensions() const; - private: - bool _internal_has_advanced_extensions() const; - public: - void clear_advanced_extensions(); - const ::substrait::extensions::AdvancedExtension& advanced_extensions() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extensions(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extensions(); - void set_allocated_advanced_extensions(::substrait::extensions::AdvancedExtension* advanced_extensions); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extensions() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extensions(); - public: - void unsafe_arena_set_allocated_advanced_extensions( - ::substrait::extensions::AdvancedExtension* advanced_extensions); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extensions(); - - // @@protoc_insertion_point(class_scope:substrait.Plan) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI > extension_uris_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration > extensions_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel > relations_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField expected_type_urls_; - ::substrait::extensions::AdvancedExtension* advanced_extensions_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2fplan_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// PlanRel - -// .substrait.Rel rel = 1; -inline bool PlanRel::_internal_has_rel() const { - return rel_type_case() == kRel; -} -inline bool PlanRel::has_rel() const { - return _internal_has_rel(); -} -inline void PlanRel::set_has_rel() { - _oneof_case_[0] = kRel; -} -inline ::substrait::Rel* PlanRel::release_rel() { - // @@protoc_insertion_point(field_release:substrait.PlanRel.rel) - if (_internal_has_rel()) { - clear_has_rel_type(); - ::substrait::Rel* temp = rel_type_.rel_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.rel_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Rel& PlanRel::_internal_rel() const { - return _internal_has_rel() - ? *rel_type_.rel_ - : reinterpret_cast< ::substrait::Rel&>(::substrait::_Rel_default_instance_); -} -inline const ::substrait::Rel& PlanRel::rel() const { - // @@protoc_insertion_point(field_get:substrait.PlanRel.rel) - return _internal_rel(); -} -inline ::substrait::Rel* PlanRel::unsafe_arena_release_rel() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.PlanRel.rel) - if (_internal_has_rel()) { - clear_has_rel_type(); - ::substrait::Rel* temp = rel_type_.rel_; - rel_type_.rel_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void PlanRel::unsafe_arena_set_allocated_rel(::substrait::Rel* rel) { - clear_rel_type(); - if (rel) { - set_has_rel(); - rel_type_.rel_ = rel; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.PlanRel.rel) -} -inline ::substrait::Rel* PlanRel::_internal_mutable_rel() { - if (!_internal_has_rel()) { - clear_rel_type(); - set_has_rel(); - rel_type_.rel_ = CreateMaybeMessage< ::substrait::Rel >(GetArenaForAllocation()); - } - return rel_type_.rel_; -} -inline ::substrait::Rel* PlanRel::mutable_rel() { - ::substrait::Rel* _msg = _internal_mutable_rel(); - // @@protoc_insertion_point(field_mutable:substrait.PlanRel.rel) - return _msg; -} - -// .substrait.RelRoot root = 2; -inline bool PlanRel::_internal_has_root() const { - return rel_type_case() == kRoot; -} -inline bool PlanRel::has_root() const { - return _internal_has_root(); -} -inline void PlanRel::set_has_root() { - _oneof_case_[0] = kRoot; -} -inline ::substrait::RelRoot* PlanRel::release_root() { - // @@protoc_insertion_point(field_release:substrait.PlanRel.root) - if (_internal_has_root()) { - clear_has_rel_type(); - ::substrait::RelRoot* temp = rel_type_.root_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.root_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::RelRoot& PlanRel::_internal_root() const { - return _internal_has_root() - ? *rel_type_.root_ - : reinterpret_cast< ::substrait::RelRoot&>(::substrait::_RelRoot_default_instance_); -} -inline const ::substrait::RelRoot& PlanRel::root() const { - // @@protoc_insertion_point(field_get:substrait.PlanRel.root) - return _internal_root(); -} -inline ::substrait::RelRoot* PlanRel::unsafe_arena_release_root() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.PlanRel.root) - if (_internal_has_root()) { - clear_has_rel_type(); - ::substrait::RelRoot* temp = rel_type_.root_; - rel_type_.root_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void PlanRel::unsafe_arena_set_allocated_root(::substrait::RelRoot* root) { - clear_rel_type(); - if (root) { - set_has_root(); - rel_type_.root_ = root; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.PlanRel.root) -} -inline ::substrait::RelRoot* PlanRel::_internal_mutable_root() { - if (!_internal_has_root()) { - clear_rel_type(); - set_has_root(); - rel_type_.root_ = CreateMaybeMessage< ::substrait::RelRoot >(GetArenaForAllocation()); - } - return rel_type_.root_; -} -inline ::substrait::RelRoot* PlanRel::mutable_root() { - ::substrait::RelRoot* _msg = _internal_mutable_root(); - // @@protoc_insertion_point(field_mutable:substrait.PlanRel.root) - return _msg; -} - -inline bool PlanRel::has_rel_type() const { - return rel_type_case() != REL_TYPE_NOT_SET; -} -inline void PlanRel::clear_has_rel_type() { - _oneof_case_[0] = REL_TYPE_NOT_SET; -} -inline PlanRel::RelTypeCase PlanRel::rel_type_case() const { - return PlanRel::RelTypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// Plan - -// repeated .substrait.extensions.SimpleExtensionURI extension_uris = 1; -inline int Plan::_internal_extension_uris_size() const { - return extension_uris_.size(); -} -inline int Plan::extension_uris_size() const { - return _internal_extension_uris_size(); -} -inline ::substrait::extensions::SimpleExtensionURI* Plan::mutable_extension_uris(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Plan.extension_uris) - return extension_uris_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >* -Plan::mutable_extension_uris() { - // @@protoc_insertion_point(field_mutable_list:substrait.Plan.extension_uris) - return &extension_uris_; -} -inline const ::substrait::extensions::SimpleExtensionURI& Plan::_internal_extension_uris(int index) const { - return extension_uris_.Get(index); -} -inline const ::substrait::extensions::SimpleExtensionURI& Plan::extension_uris(int index) const { - // @@protoc_insertion_point(field_get:substrait.Plan.extension_uris) - return _internal_extension_uris(index); -} -inline ::substrait::extensions::SimpleExtensionURI* Plan::_internal_add_extension_uris() { - return extension_uris_.Add(); -} -inline ::substrait::extensions::SimpleExtensionURI* Plan::add_extension_uris() { - ::substrait::extensions::SimpleExtensionURI* _add = _internal_add_extension_uris(); - // @@protoc_insertion_point(field_add:substrait.Plan.extension_uris) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionURI >& -Plan::extension_uris() const { - // @@protoc_insertion_point(field_list:substrait.Plan.extension_uris) - return extension_uris_; -} - -// repeated .substrait.extensions.SimpleExtensionDeclaration extensions = 2; -inline int Plan::_internal_extensions_size() const { - return extensions_.size(); -} -inline int Plan::extensions_size() const { - return _internal_extensions_size(); -} -inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::mutable_extensions(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Plan.extensions) - return extensions_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >* -Plan::mutable_extensions() { - // @@protoc_insertion_point(field_mutable_list:substrait.Plan.extensions) - return &extensions_; -} -inline const ::substrait::extensions::SimpleExtensionDeclaration& Plan::_internal_extensions(int index) const { - return extensions_.Get(index); -} -inline const ::substrait::extensions::SimpleExtensionDeclaration& Plan::extensions(int index) const { - // @@protoc_insertion_point(field_get:substrait.Plan.extensions) - return _internal_extensions(index); -} -inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::_internal_add_extensions() { - return extensions_.Add(); -} -inline ::substrait::extensions::SimpleExtensionDeclaration* Plan::add_extensions() { - ::substrait::extensions::SimpleExtensionDeclaration* _add = _internal_add_extensions(); - // @@protoc_insertion_point(field_add:substrait.Plan.extensions) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::extensions::SimpleExtensionDeclaration >& -Plan::extensions() const { - // @@protoc_insertion_point(field_list:substrait.Plan.extensions) - return extensions_; -} - -// repeated .substrait.PlanRel relations = 3; -inline int Plan::_internal_relations_size() const { - return relations_.size(); -} -inline int Plan::relations_size() const { - return _internal_relations_size(); -} -inline void Plan::clear_relations() { - relations_.Clear(); -} -inline ::substrait::PlanRel* Plan::mutable_relations(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Plan.relations) - return relations_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >* -Plan::mutable_relations() { - // @@protoc_insertion_point(field_mutable_list:substrait.Plan.relations) - return &relations_; -} -inline const ::substrait::PlanRel& Plan::_internal_relations(int index) const { - return relations_.Get(index); -} -inline const ::substrait::PlanRel& Plan::relations(int index) const { - // @@protoc_insertion_point(field_get:substrait.Plan.relations) - return _internal_relations(index); -} -inline ::substrait::PlanRel* Plan::_internal_add_relations() { - return relations_.Add(); -} -inline ::substrait::PlanRel* Plan::add_relations() { - ::substrait::PlanRel* _add = _internal_add_relations(); - // @@protoc_insertion_point(field_add:substrait.Plan.relations) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::PlanRel >& -Plan::relations() const { - // @@protoc_insertion_point(field_list:substrait.Plan.relations) - return relations_; -} - -// .substrait.extensions.AdvancedExtension advanced_extensions = 4; -inline bool Plan::_internal_has_advanced_extensions() const { - return this != internal_default_instance() && advanced_extensions_ != nullptr; -} -inline bool Plan::has_advanced_extensions() const { - return _internal_has_advanced_extensions(); -} -inline const ::substrait::extensions::AdvancedExtension& Plan::_internal_advanced_extensions() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extensions_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& Plan::advanced_extensions() const { - // @@protoc_insertion_point(field_get:substrait.Plan.advanced_extensions) - return _internal_advanced_extensions(); -} -inline void Plan::unsafe_arena_set_allocated_advanced_extensions( - ::substrait::extensions::AdvancedExtension* advanced_extensions) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions_); - } - advanced_extensions_ = advanced_extensions; - if (advanced_extensions) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Plan.advanced_extensions) -} -inline ::substrait::extensions::AdvancedExtension* Plan::release_advanced_extensions() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extensions_; - advanced_extensions_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* Plan::unsafe_arena_release_advanced_extensions() { - // @@protoc_insertion_point(field_release:substrait.Plan.advanced_extensions) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extensions_; - advanced_extensions_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* Plan::_internal_mutable_advanced_extensions() { - - if (advanced_extensions_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extensions_ = p; - } - return advanced_extensions_; -} -inline ::substrait::extensions::AdvancedExtension* Plan::mutable_advanced_extensions() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extensions(); - // @@protoc_insertion_point(field_mutable:substrait.Plan.advanced_extensions) - return _msg; -} -inline void Plan::set_allocated_advanced_extensions(::substrait::extensions::AdvancedExtension* advanced_extensions) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions_); - } - if (advanced_extensions) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extensions)); - if (message_arena != submessage_arena) { - advanced_extensions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extensions, submessage_arena); - } - - } else { - - } - advanced_extensions_ = advanced_extensions; - // @@protoc_insertion_point(field_set_allocated:substrait.Plan.advanced_extensions) -} - -// repeated string expected_type_urls = 5; -inline int Plan::_internal_expected_type_urls_size() const { - return expected_type_urls_.size(); -} -inline int Plan::expected_type_urls_size() const { - return _internal_expected_type_urls_size(); -} -inline void Plan::clear_expected_type_urls() { - expected_type_urls_.Clear(); -} -inline std::string* Plan::add_expected_type_urls() { - std::string* _s = _internal_add_expected_type_urls(); - // @@protoc_insertion_point(field_add_mutable:substrait.Plan.expected_type_urls) - return _s; -} -inline const std::string& Plan::_internal_expected_type_urls(int index) const { - return expected_type_urls_.Get(index); -} -inline const std::string& Plan::expected_type_urls(int index) const { - // @@protoc_insertion_point(field_get:substrait.Plan.expected_type_urls) - return _internal_expected_type_urls(index); -} -inline std::string* Plan::mutable_expected_type_urls(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Plan.expected_type_urls) - return expected_type_urls_.Mutable(index); -} -inline void Plan::set_expected_type_urls(int index, const std::string& value) { - expected_type_urls_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.Plan.expected_type_urls) -} -inline void Plan::set_expected_type_urls(int index, std::string&& value) { - expected_type_urls_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.Plan.expected_type_urls) -} -inline void Plan::set_expected_type_urls(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - expected_type_urls_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.Plan.expected_type_urls) -} -inline void Plan::set_expected_type_urls(int index, const char* value, size_t size) { - expected_type_urls_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.Plan.expected_type_urls) -} -inline std::string* Plan::_internal_add_expected_type_urls() { - return expected_type_urls_.Add(); -} -inline void Plan::add_expected_type_urls(const std::string& value) { - expected_type_urls_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.Plan.expected_type_urls) -} -inline void Plan::add_expected_type_urls(std::string&& value) { - expected_type_urls_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.Plan.expected_type_urls) -} -inline void Plan::add_expected_type_urls(const char* value) { - GOOGLE_DCHECK(value != nullptr); - expected_type_urls_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.Plan.expected_type_urls) -} -inline void Plan::add_expected_type_urls(const char* value, size_t size) { - expected_type_urls_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.Plan.expected_type_urls) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -Plan::expected_type_urls() const { - // @@protoc_insertion_point(field_list:substrait.Plan.expected_type_urls) - return expected_type_urls_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -Plan::mutable_expected_type_urls() { - // @@protoc_insertion_point(field_mutable_list:substrait.Plan.expected_type_urls) - return &expected_type_urls_; -} - -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace substrait - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2fplan_2eproto diff --git a/cpp/src/generated/substrait/relations.pb.cc b/cpp/src/generated/substrait/relations.pb.cc deleted file mode 100644 index f4d4e904448..00000000000 --- a/cpp/src/generated/substrait/relations.pb.cc +++ /dev/null @@ -1,9153 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/relations.proto - -#include "substrait/relations.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace substrait { -constexpr RelCommon_Direct::RelCommon_Direct( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized){} -struct RelCommon_DirectDefaultTypeInternal { - constexpr RelCommon_DirectDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~RelCommon_DirectDefaultTypeInternal() {} - union { - RelCommon_Direct _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_DirectDefaultTypeInternal _RelCommon_Direct_default_instance_; -constexpr RelCommon_Emit::RelCommon_Emit( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : output_mapping_() - , _output_mapping_cached_byte_size_(0){} -struct RelCommon_EmitDefaultTypeInternal { - constexpr RelCommon_EmitDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~RelCommon_EmitDefaultTypeInternal() {} - union { - RelCommon_Emit _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_EmitDefaultTypeInternal _RelCommon_Emit_default_instance_; -constexpr RelCommon_Hint_Stats::RelCommon_Hint_Stats( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : advanced_extension_(nullptr) - , row_count_(0) - , record_size_(0){} -struct RelCommon_Hint_StatsDefaultTypeInternal { - constexpr RelCommon_Hint_StatsDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~RelCommon_Hint_StatsDefaultTypeInternal() {} - union { - RelCommon_Hint_Stats _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_StatsDefaultTypeInternal _RelCommon_Hint_Stats_default_instance_; -constexpr RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : advanced_extension_(nullptr){} -struct RelCommon_Hint_RuntimeConstraintDefaultTypeInternal { - constexpr RelCommon_Hint_RuntimeConstraintDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~RelCommon_Hint_RuntimeConstraintDefaultTypeInternal() {} - union { - RelCommon_Hint_RuntimeConstraint _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_Hint_RuntimeConstraintDefaultTypeInternal _RelCommon_Hint_RuntimeConstraint_default_instance_; -constexpr RelCommon_Hint::RelCommon_Hint( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : stats_(nullptr) - , constraint_(nullptr) - , advanced_extension_(nullptr){} -struct RelCommon_HintDefaultTypeInternal { - constexpr RelCommon_HintDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~RelCommon_HintDefaultTypeInternal() {} - union { - RelCommon_Hint _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommon_HintDefaultTypeInternal _RelCommon_Hint_default_instance_; -constexpr RelCommon::RelCommon( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : hint_(nullptr) - , advanced_extension_(nullptr) - , _oneof_case_{}{} -struct RelCommonDefaultTypeInternal { - constexpr RelCommonDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~RelCommonDefaultTypeInternal() {} - union { - RelCommon _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelCommonDefaultTypeInternal _RelCommon_default_instance_; -constexpr ReadRel_NamedTable::ReadRel_NamedTable( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : names_() - , advanced_extension_(nullptr){} -struct ReadRel_NamedTableDefaultTypeInternal { - constexpr ReadRel_NamedTableDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReadRel_NamedTableDefaultTypeInternal() {} - union { - ReadRel_NamedTable _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_NamedTableDefaultTypeInternal _ReadRel_NamedTable_default_instance_; -constexpr ReadRel_VirtualTable::ReadRel_VirtualTable( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : values_(){} -struct ReadRel_VirtualTableDefaultTypeInternal { - constexpr ReadRel_VirtualTableDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReadRel_VirtualTableDefaultTypeInternal() {} - union { - ReadRel_VirtualTable _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_VirtualTableDefaultTypeInternal _ReadRel_VirtualTable_default_instance_; -constexpr ReadRel_ExtensionTable::ReadRel_ExtensionTable( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : detail_(nullptr){} -struct ReadRel_ExtensionTableDefaultTypeInternal { - constexpr ReadRel_ExtensionTableDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReadRel_ExtensionTableDefaultTypeInternal() {} - union { - ReadRel_ExtensionTable _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_ExtensionTableDefaultTypeInternal _ReadRel_ExtensionTable_default_instance_; -constexpr ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : format_(0) - - , partition_index_(uint64_t{0u}) - , start_(uint64_t{0u}) - , length_(uint64_t{0u}) - , _oneof_case_{}{} -struct ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal { - constexpr ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal() {} - union { - ReadRel_LocalFiles_FileOrFiles _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal _ReadRel_LocalFiles_FileOrFiles_default_instance_; -constexpr ReadRel_LocalFiles::ReadRel_LocalFiles( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : items_() - , advanced_extension_(nullptr){} -struct ReadRel_LocalFilesDefaultTypeInternal { - constexpr ReadRel_LocalFilesDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReadRel_LocalFilesDefaultTypeInternal() {} - union { - ReadRel_LocalFiles _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRel_LocalFilesDefaultTypeInternal _ReadRel_LocalFiles_default_instance_; -constexpr ReadRel::ReadRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : common_(nullptr) - , base_schema_(nullptr) - , filter_(nullptr) - , projection_(nullptr) - , advanced_extension_(nullptr) - , _oneof_case_{}{} -struct ReadRelDefaultTypeInternal { - constexpr ReadRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ReadRelDefaultTypeInternal() {} - union { - ReadRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ReadRelDefaultTypeInternal _ReadRel_default_instance_; -constexpr ProjectRel::ProjectRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : expressions_() - , common_(nullptr) - , input_(nullptr) - , advanced_extension_(nullptr){} -struct ProjectRelDefaultTypeInternal { - constexpr ProjectRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ProjectRelDefaultTypeInternal() {} - union { - ProjectRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ProjectRelDefaultTypeInternal _ProjectRel_default_instance_; -constexpr JoinRel::JoinRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : common_(nullptr) - , left_(nullptr) - , right_(nullptr) - , expression_(nullptr) - , post_join_filter_(nullptr) - , advanced_extension_(nullptr) - , type_(0) -{} -struct JoinRelDefaultTypeInternal { - constexpr JoinRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~JoinRelDefaultTypeInternal() {} - union { - JoinRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT JoinRelDefaultTypeInternal _JoinRel_default_instance_; -constexpr FetchRel::FetchRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : common_(nullptr) - , input_(nullptr) - , advanced_extension_(nullptr) - , offset_(int64_t{0}) - , count_(int64_t{0}){} -struct FetchRelDefaultTypeInternal { - constexpr FetchRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FetchRelDefaultTypeInternal() {} - union { - FetchRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FetchRelDefaultTypeInternal _FetchRel_default_instance_; -constexpr AggregateRel_Grouping::AggregateRel_Grouping( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : grouping_expressions_(){} -struct AggregateRel_GroupingDefaultTypeInternal { - constexpr AggregateRel_GroupingDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~AggregateRel_GroupingDefaultTypeInternal() {} - union { - AggregateRel_Grouping _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRel_GroupingDefaultTypeInternal _AggregateRel_Grouping_default_instance_; -constexpr AggregateRel_Measure::AggregateRel_Measure( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : measure_(nullptr) - , filter_(nullptr){} -struct AggregateRel_MeasureDefaultTypeInternal { - constexpr AggregateRel_MeasureDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~AggregateRel_MeasureDefaultTypeInternal() {} - union { - AggregateRel_Measure _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRel_MeasureDefaultTypeInternal _AggregateRel_Measure_default_instance_; -constexpr AggregateRel::AggregateRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : groupings_() - , measures_() - , common_(nullptr) - , input_(nullptr) - , advanced_extension_(nullptr){} -struct AggregateRelDefaultTypeInternal { - constexpr AggregateRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~AggregateRelDefaultTypeInternal() {} - union { - AggregateRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT AggregateRelDefaultTypeInternal _AggregateRel_default_instance_; -constexpr SortRel::SortRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : sorts_() - , common_(nullptr) - , input_(nullptr) - , advanced_extension_(nullptr){} -struct SortRelDefaultTypeInternal { - constexpr SortRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SortRelDefaultTypeInternal() {} - union { - SortRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SortRelDefaultTypeInternal _SortRel_default_instance_; -constexpr FilterRel::FilterRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : common_(nullptr) - , input_(nullptr) - , condition_(nullptr) - , advanced_extension_(nullptr){} -struct FilterRelDefaultTypeInternal { - constexpr FilterRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~FilterRelDefaultTypeInternal() {} - union { - FilterRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT FilterRelDefaultTypeInternal _FilterRel_default_instance_; -constexpr SetRel::SetRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : inputs_() - , common_(nullptr) - , advanced_extension_(nullptr) - , op_(0) -{} -struct SetRelDefaultTypeInternal { - constexpr SetRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~SetRelDefaultTypeInternal() {} - union { - SetRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT SetRelDefaultTypeInternal _SetRel_default_instance_; -constexpr ExtensionSingleRel::ExtensionSingleRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : common_(nullptr) - , input_(nullptr) - , detail_(nullptr){} -struct ExtensionSingleRelDefaultTypeInternal { - constexpr ExtensionSingleRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ExtensionSingleRelDefaultTypeInternal() {} - union { - ExtensionSingleRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionSingleRelDefaultTypeInternal _ExtensionSingleRel_default_instance_; -constexpr ExtensionLeafRel::ExtensionLeafRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : common_(nullptr) - , detail_(nullptr){} -struct ExtensionLeafRelDefaultTypeInternal { - constexpr ExtensionLeafRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ExtensionLeafRelDefaultTypeInternal() {} - union { - ExtensionLeafRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionLeafRelDefaultTypeInternal _ExtensionLeafRel_default_instance_; -constexpr ExtensionMultiRel::ExtensionMultiRel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : inputs_() - , common_(nullptr) - , detail_(nullptr){} -struct ExtensionMultiRelDefaultTypeInternal { - constexpr ExtensionMultiRelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~ExtensionMultiRelDefaultTypeInternal() {} - union { - ExtensionMultiRel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ExtensionMultiRelDefaultTypeInternal _ExtensionMultiRel_default_instance_; -constexpr RelRoot::RelRoot( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : names_() - , input_(nullptr){} -struct RelRootDefaultTypeInternal { - constexpr RelRootDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~RelRootDefaultTypeInternal() {} - union { - RelRoot _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelRootDefaultTypeInternal _RelRoot_default_instance_; -constexpr Rel::Rel( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct RelDefaultTypeInternal { - constexpr RelDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~RelDefaultTypeInternal() {} - union { - Rel _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT RelDefaultTypeInternal _Rel_default_instance_; -} // namespace substrait -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2frelations_2eproto[26]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2frelations_2eproto[3]; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2frelations_2eproto = nullptr; - -const uint32_t TableStruct_substrait_2frelations_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Direct, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Emit, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Emit, output_mapping_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, row_count_), - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, record_size_), - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_Stats, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_RuntimeConstraint, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint_RuntimeConstraint, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, stats_), - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, constraint_), - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon_Hint, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, hint_), - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, advanced_extension_), - PROTOBUF_FIELD_OFFSET(::substrait::RelCommon, emit_kind_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, names_), - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_NamedTable, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_VirtualTable, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_VirtualTable, values_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_ExtensionTable, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_ExtensionTable, detail_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, format_), - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, partition_index_), - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, start_), - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, length_), - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles_FileOrFiles, path_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, items_), - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel_LocalFiles, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, base_schema_), - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, filter_), - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, projection_), - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, advanced_extension_), - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::ReadRel, read_type_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, input_), - PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, expressions_), - PROTOBUF_FIELD_OFFSET(::substrait::ProjectRel, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, left_), - PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, right_), - PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, expression_), - PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, post_join_filter_), - PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, type_), - PROTOBUF_FIELD_OFFSET(::substrait::JoinRel, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, input_), - PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, offset_), - PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, count_), - PROTOBUF_FIELD_OFFSET(::substrait::FetchRel, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Grouping, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Grouping, grouping_expressions_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, measure_), - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel_Measure, filter_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, input_), - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, groupings_), - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, measures_), - PROTOBUF_FIELD_OFFSET(::substrait::AggregateRel, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::SortRel, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::SortRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::SortRel, input_), - PROTOBUF_FIELD_OFFSET(::substrait::SortRel, sorts_), - PROTOBUF_FIELD_OFFSET(::substrait::SortRel, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, input_), - PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, condition_), - PROTOBUF_FIELD_OFFSET(::substrait::FilterRel, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::SetRel, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::SetRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::SetRel, inputs_), - PROTOBUF_FIELD_OFFSET(::substrait::SetRel, op_), - PROTOBUF_FIELD_OFFSET(::substrait::SetRel, advanced_extension_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, input_), - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionSingleRel, detail_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionLeafRel, detail_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, common_), - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, inputs_), - PROTOBUF_FIELD_OFFSET(::substrait::ExtensionMultiRel, detail_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, input_), - PROTOBUF_FIELD_OFFSET(::substrait::RelRoot, names_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Rel, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Rel, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Rel, rel_type_), -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, -1, sizeof(::substrait::RelCommon_Direct)}, - { 6, -1, -1, sizeof(::substrait::RelCommon_Emit)}, - { 13, -1, -1, sizeof(::substrait::RelCommon_Hint_Stats)}, - { 22, -1, -1, sizeof(::substrait::RelCommon_Hint_RuntimeConstraint)}, - { 29, -1, -1, sizeof(::substrait::RelCommon_Hint)}, - { 38, -1, -1, sizeof(::substrait::RelCommon)}, - { 49, -1, -1, sizeof(::substrait::ReadRel_NamedTable)}, - { 57, -1, -1, sizeof(::substrait::ReadRel_VirtualTable)}, - { 64, -1, -1, sizeof(::substrait::ReadRel_ExtensionTable)}, - { 71, -1, -1, sizeof(::substrait::ReadRel_LocalFiles_FileOrFiles)}, - { 86, -1, -1, sizeof(::substrait::ReadRel_LocalFiles)}, - { 94, -1, -1, sizeof(::substrait::ReadRel)}, - { 110, -1, -1, sizeof(::substrait::ProjectRel)}, - { 120, -1, -1, sizeof(::substrait::JoinRel)}, - { 133, -1, -1, sizeof(::substrait::FetchRel)}, - { 144, -1, -1, sizeof(::substrait::AggregateRel_Grouping)}, - { 151, -1, -1, sizeof(::substrait::AggregateRel_Measure)}, - { 159, -1, -1, sizeof(::substrait::AggregateRel)}, - { 170, -1, -1, sizeof(::substrait::SortRel)}, - { 180, -1, -1, sizeof(::substrait::FilterRel)}, - { 190, -1, -1, sizeof(::substrait::SetRel)}, - { 200, -1, -1, sizeof(::substrait::ExtensionSingleRel)}, - { 209, -1, -1, sizeof(::substrait::ExtensionLeafRel)}, - { 217, -1, -1, sizeof(::substrait::ExtensionMultiRel)}, - { 226, -1, -1, sizeof(::substrait::RelRoot)}, - { 234, -1, -1, sizeof(::substrait::Rel)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::substrait::_RelCommon_Direct_default_instance_), - reinterpret_cast(&::substrait::_RelCommon_Emit_default_instance_), - reinterpret_cast(&::substrait::_RelCommon_Hint_Stats_default_instance_), - reinterpret_cast(&::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_), - reinterpret_cast(&::substrait::_RelCommon_Hint_default_instance_), - reinterpret_cast(&::substrait::_RelCommon_default_instance_), - reinterpret_cast(&::substrait::_ReadRel_NamedTable_default_instance_), - reinterpret_cast(&::substrait::_ReadRel_VirtualTable_default_instance_), - reinterpret_cast(&::substrait::_ReadRel_ExtensionTable_default_instance_), - reinterpret_cast(&::substrait::_ReadRel_LocalFiles_FileOrFiles_default_instance_), - reinterpret_cast(&::substrait::_ReadRel_LocalFiles_default_instance_), - reinterpret_cast(&::substrait::_ReadRel_default_instance_), - reinterpret_cast(&::substrait::_ProjectRel_default_instance_), - reinterpret_cast(&::substrait::_JoinRel_default_instance_), - reinterpret_cast(&::substrait::_FetchRel_default_instance_), - reinterpret_cast(&::substrait::_AggregateRel_Grouping_default_instance_), - reinterpret_cast(&::substrait::_AggregateRel_Measure_default_instance_), - reinterpret_cast(&::substrait::_AggregateRel_default_instance_), - reinterpret_cast(&::substrait::_SortRel_default_instance_), - reinterpret_cast(&::substrait::_FilterRel_default_instance_), - reinterpret_cast(&::substrait::_SetRel_default_instance_), - reinterpret_cast(&::substrait::_ExtensionSingleRel_default_instance_), - reinterpret_cast(&::substrait::_ExtensionLeafRel_default_instance_), - reinterpret_cast(&::substrait::_ExtensionMultiRel_default_instance_), - reinterpret_cast(&::substrait::_RelRoot_default_instance_), - reinterpret_cast(&::substrait::_Rel_default_instance_), -}; - -const char descriptor_table_protodef_substrait_2frelations_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\031substrait/relations.proto\022\tsubstrait\032\024" - "substrait/type.proto\032\032substrait/expressi" - "on.proto\032%substrait/extensions/extension" - "s.proto\032\031google/protobuf/any.proto\"\231\005\n\tR" - "elCommon\022-\n\006direct\030\001 \001(\0132\033.substrait.Rel" - "Common.DirectH\000\022)\n\004emit\030\002 \001(\0132\031.substrai" - "t.RelCommon.EmitH\000\022\'\n\004hint\030\003 \001(\0132\031.subst" - "rait.RelCommon.Hint\022C\n\022advanced_extensio" - "n\030\004 \001(\0132\'.substrait.extensions.AdvancedE" - "xtension\032\010\n\006Direct\032\036\n\004Emit\022\026\n\016output_map" - "ping\030\001 \003(\005\032\214\003\n\004Hint\022.\n\005stats\030\001 \001(\0132\037.sub" - "strait.RelCommon.Hint.Stats\022\?\n\nconstrain" - "t\030\002 \001(\0132+.substrait.RelCommon.Hint.Runti" - "meConstraint\022C\n\022advanced_extension\030\n \001(\013" - "2\'.substrait.extensions.AdvancedExtensio" - "n\032t\n\005Stats\022\021\n\trow_count\030\001 \001(\001\022\023\n\013record_" - "size\030\002 \001(\001\022C\n\022advanced_extension\030\n \001(\0132\'" - ".substrait.extensions.AdvancedExtension\032" - "X\n\021RuntimeConstraint\022C\n\022advanced_extensi" - "on\030\n \001(\0132\'.substrait.extensions.Advanced" - "ExtensionB\013\n\temit_kind\"\227\t\n\007ReadRel\022$\n\006co" - "mmon\030\001 \001(\0132\024.substrait.RelCommon\022+\n\013base" - "_schema\030\002 \001(\0132\026.substrait.NamedStruct\022%\n" - "\006filter\030\003 \001(\0132\025.substrait.Expression\0228\n\n" - "projection\030\004 \001(\0132$.substrait.Expression." - "MaskExpression\022C\n\022advanced_extension\030\n \001" - "(\0132\'.substrait.extensions.AdvancedExtens" - "ion\0228\n\rvirtual_table\030\005 \001(\0132\037.substrait.R" - "eadRel.VirtualTableH\000\0224\n\013local_files\030\006 \001" - "(\0132\035.substrait.ReadRel.LocalFilesH\000\0224\n\013n" - "amed_table\030\007 \001(\0132\035.substrait.ReadRel.Nam" - "edTableH\000\022<\n\017extension_table\030\010 \001(\0132!.sub" - "strait.ReadRel.ExtensionTableH\000\032`\n\nNamed" - "Table\022\r\n\005names\030\001 \003(\t\022C\n\022advanced_extensi" - "on\030\n \001(\0132\'.substrait.extensions.Advanced" - "Extension\032D\n\014VirtualTable\0224\n\006values\030\001 \003(" - "\0132$.substrait.Expression.Literal.Struct\032" - "6\n\016ExtensionTable\022$\n\006detail\030\001 \001(\0132\024.goog" - "le.protobuf.Any\032\301\003\n\nLocalFiles\0228\n\005items\030" - "\001 \003(\0132).substrait.ReadRel.LocalFiles.Fil" - "eOrFiles\022C\n\022advanced_extension\030\n \001(\0132\'.s" - "ubstrait.extensions.AdvancedExtension\032\263\002" - "\n\013FileOrFiles\022\022\n\010uri_path\030\001 \001(\tH\000\022\027\n\ruri" - "_path_glob\030\002 \001(\tH\000\022\022\n\010uri_file\030\003 \001(\tH\000\022\024" - "\n\nuri_folder\030\004 \001(\tH\000\022D\n\006format\030\005 \001(\01624.s" - "ubstrait.ReadRel.LocalFiles.FileOrFiles." - "FileFormat\022\027\n\017partition_index\030\006 \001(\004\022\r\n\005s" - "tart\030\007 \001(\004\022\016\n\006length\030\010 \001(\004\"B\n\nFileFormat" - "\022\033\n\027FILE_FORMAT_UNSPECIFIED\020\000\022\027\n\023FILE_FO" - "RMAT_PARQUET\020\001B\013\n\tpath_typeB\013\n\tread_type" - "\"\302\001\n\nProjectRel\022$\n\006common\030\001 \001(\0132\024.substr" - "ait.RelCommon\022\035\n\005input\030\002 \001(\0132\016.substrait" - ".Rel\022*\n\013expressions\030\003 \003(\0132\025.substrait.Ex" - "pression\022C\n\022advanced_extension\030\n \001(\0132\'.s" - "ubstrait.extensions.AdvancedExtension\"\333\003" - "\n\007JoinRel\022$\n\006common\030\001 \001(\0132\024.substrait.Re" - "lCommon\022\034\n\004left\030\002 \001(\0132\016.substrait.Rel\022\035\n" - "\005right\030\003 \001(\0132\016.substrait.Rel\022)\n\nexpressi" - "on\030\004 \001(\0132\025.substrait.Expression\022/\n\020post_" - "join_filter\030\005 \001(\0132\025.substrait.Expression" - "\022)\n\004type\030\006 \001(\0162\033.substrait.JoinRel.JoinT" - "ype\022C\n\022advanced_extension\030\n \001(\0132\'.substr" - "ait.extensions.AdvancedExtension\"\240\001\n\010Joi" - "nType\022\031\n\025JOIN_TYPE_UNSPECIFIED\020\000\022\023\n\017JOIN" - "_TYPE_INNER\020\001\022\023\n\017JOIN_TYPE_OUTER\020\002\022\022\n\016JO" - "IN_TYPE_LEFT\020\003\022\023\n\017JOIN_TYPE_RIGHT\020\004\022\022\n\016J" - "OIN_TYPE_SEMI\020\005\022\022\n\016JOIN_TYPE_ANTI\020\006\"\263\001\n\010" - "FetchRel\022$\n\006common\030\001 \001(\0132\024.substrait.Rel" - "Common\022\035\n\005input\030\002 \001(\0132\016.substrait.Rel\022\016\n" - "\006offset\030\003 \001(\003\022\r\n\005count\030\004 \001(\003\022C\n\022advanced" - "_extension\030\n \001(\0132\'.substrait.extensions." - "AdvancedExtension\"\242\003\n\014AggregateRel\022$\n\006co" - "mmon\030\001 \001(\0132\024.substrait.RelCommon\022\035\n\005inpu" - "t\030\002 \001(\0132\016.substrait.Rel\0223\n\tgroupings\030\003 \003" - "(\0132 .substrait.AggregateRel.Grouping\0221\n\010" - "measures\030\004 \003(\0132\037.substrait.AggregateRel." - "Measure\022C\n\022advanced_extension\030\n \001(\0132\'.su" - "bstrait.extensions.AdvancedExtension\032\?\n\010" - "Grouping\0223\n\024grouping_expressions\030\001 \003(\0132\025" - ".substrait.Expression\032_\n\007Measure\022-\n\007meas" - "ure\030\001 \001(\0132\034.substrait.AggregateFunction\022" - "%\n\006filter\030\002 \001(\0132\025.substrait.Expression\"\270" - "\001\n\007SortRel\022$\n\006common\030\001 \001(\0132\024.substrait.R" - "elCommon\022\035\n\005input\030\002 \001(\0132\016.substrait.Rel\022" - "#\n\005sorts\030\003 \003(\0132\024.substrait.SortField\022C\n\022" - "advanced_extension\030\n \001(\0132\'.substrait.ext" - "ensions.AdvancedExtension\"\277\001\n\tFilterRel\022" - "$\n\006common\030\001 \001(\0132\024.substrait.RelCommon\022\035\n" - "\005input\030\002 \001(\0132\016.substrait.Rel\022(\n\tconditio" - "n\030\003 \001(\0132\025.substrait.Expression\022C\n\022advanc" - "ed_extension\030\n \001(\0132\'.substrait.extension" - "s.AdvancedExtension\"\203\003\n\006SetRel\022$\n\006common" - "\030\001 \001(\0132\024.substrait.RelCommon\022\036\n\006inputs\030\002" - " \003(\0132\016.substrait.Rel\022#\n\002op\030\003 \001(\0162\027.subst" - "rait.SetRel.SetOp\022C\n\022advanced_extension\030" - "\n \001(\0132\'.substrait.extensions.AdvancedExt" - "ension\"\310\001\n\005SetOp\022\026\n\022SET_OP_UNSPECIFIED\020\000" - "\022\030\n\024SET_OP_MINUS_PRIMARY\020\001\022\031\n\025SET_OP_MIN" - "US_MULTISET\020\002\022\037\n\033SET_OP_INTERSECTION_PRI" - "MARY\020\003\022 \n\034SET_OP_INTERSECTION_MULTISET\020\004" - "\022\031\n\025SET_OP_UNION_DISTINCT\020\005\022\024\n\020SET_OP_UN" - "ION_ALL\020\006\"\177\n\022ExtensionSingleRel\022$\n\006commo" - "n\030\001 \001(\0132\024.substrait.RelCommon\022\035\n\005input\030\002" - " \001(\0132\016.substrait.Rel\022$\n\006detail\030\003 \001(\0132\024.g" - "oogle.protobuf.Any\"^\n\020ExtensionLeafRel\022$" - "\n\006common\030\001 \001(\0132\024.substrait.RelCommon\022$\n\006" - "detail\030\002 \001(\0132\024.google.protobuf.Any\"\177\n\021Ex" - "tensionMultiRel\022$\n\006common\030\001 \001(\0132\024.substr" - "ait.RelCommon\022\036\n\006inputs\030\002 \003(\0132\016.substrai" - "t.Rel\022$\n\006detail\030\003 \001(\0132\024.google.protobuf." - "Any\"7\n\007RelRoot\022\035\n\005input\030\001 \001(\0132\016.substrai" - "t.Rel\022\r\n\005names\030\002 \003(\t\"\360\003\n\003Rel\022\"\n\004read\030\001 \001" - "(\0132\022.substrait.ReadRelH\000\022&\n\006filter\030\002 \001(\013" - "2\024.substrait.FilterRelH\000\022$\n\005fetch\030\003 \001(\0132" - "\023.substrait.FetchRelH\000\022,\n\taggregate\030\004 \001(" - "\0132\027.substrait.AggregateRelH\000\022\"\n\004sort\030\005 \001" - "(\0132\022.substrait.SortRelH\000\022\"\n\004join\030\006 \001(\0132\022" - ".substrait.JoinRelH\000\022(\n\007project\030\007 \001(\0132\025." - "substrait.ProjectRelH\000\022 \n\003set\030\010 \001(\0132\021.su" - "bstrait.SetRelH\000\0229\n\020extension_single\030\t \001" - "(\0132\035.substrait.ExtensionSingleRelH\000\0227\n\017e" - "xtension_multi\030\n \001(\0132\034.substrait.Extensi" - "onMultiRelH\000\0225\n\016extension_leaf\030\013 \001(\0132\033.s" - "ubstrait.ExtensionLeafRelH\000B\n\n\010rel_typeB" - "+\n\022io.substrait.protoP\001\252\002\022Substrait.Prot" - "obufb\006proto3" - ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2frelations_2eproto_deps[4] = { - &::descriptor_table_google_2fprotobuf_2fany_2eproto, - &::descriptor_table_substrait_2fexpression_2eproto, - &::descriptor_table_substrait_2fextensions_2fextensions_2eproto, - &::descriptor_table_substrait_2ftype_2eproto, -}; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2frelations_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2frelations_2eproto = { - false, false, 5012, descriptor_table_protodef_substrait_2frelations_2eproto, "substrait/relations.proto", - &descriptor_table_substrait_2frelations_2eproto_once, descriptor_table_substrait_2frelations_2eproto_deps, 4, 26, - schemas, file_default_instances, TableStruct_substrait_2frelations_2eproto::offsets, - file_level_metadata_substrait_2frelations_2eproto, file_level_enum_descriptors_substrait_2frelations_2eproto, file_level_service_descriptors_substrait_2frelations_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2frelations_2eproto_getter() { - return &descriptor_table_substrait_2frelations_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2frelations_2eproto(&descriptor_table_substrait_2frelations_2eproto); -namespace substrait { -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto); - return file_level_enum_descriptors_substrait_2frelations_2eproto[0]; -} -bool ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FILE_FORMAT_UNSPECIFIED; -constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FILE_FORMAT_PARQUET; -constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FileFormat_MIN; -constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::FileFormat_MAX; -constexpr int ReadRel_LocalFiles_FileOrFiles::FileFormat_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto); - return file_level_enum_descriptors_substrait_2frelations_2eproto[1]; -} -bool JoinRel_JoinType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_UNSPECIFIED; -constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_INNER; -constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_OUTER; -constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_LEFT; -constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_RIGHT; -constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_SEMI; -constexpr JoinRel_JoinType JoinRel::JOIN_TYPE_ANTI; -constexpr JoinRel_JoinType JoinRel::JoinType_MIN; -constexpr JoinRel_JoinType JoinRel::JoinType_MAX; -constexpr int JoinRel::JoinType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetRel_SetOp_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2frelations_2eproto); - return file_level_enum_descriptors_substrait_2frelations_2eproto[2]; -} -bool SetRel_SetOp_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr SetRel_SetOp SetRel::SET_OP_UNSPECIFIED; -constexpr SetRel_SetOp SetRel::SET_OP_MINUS_PRIMARY; -constexpr SetRel_SetOp SetRel::SET_OP_MINUS_MULTISET; -constexpr SetRel_SetOp SetRel::SET_OP_INTERSECTION_PRIMARY; -constexpr SetRel_SetOp SetRel::SET_OP_INTERSECTION_MULTISET; -constexpr SetRel_SetOp SetRel::SET_OP_UNION_DISTINCT; -constexpr SetRel_SetOp SetRel::SET_OP_UNION_ALL; -constexpr SetRel_SetOp SetRel::SetOp_MIN; -constexpr SetRel_SetOp SetRel::SetOp_MAX; -constexpr int SetRel::SetOp_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) - -// =================================================================== - -class RelCommon_Direct::_Internal { - public: -}; - -RelCommon_Direct::RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase(arena, is_message_owned) { - // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Direct) -} -RelCommon_Direct::RelCommon_Direct(const RelCommon_Direct& from) - : ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Direct) -} - - - - - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Direct::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl, - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl, -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Direct::GetClassData() const { return &_class_data_; } - - - - - - - -::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Direct::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[0]); -} - -// =================================================================== - -class RelCommon_Emit::_Internal { - public: -}; - -RelCommon_Emit::RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - output_mapping_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Emit) -} -RelCommon_Emit::RelCommon_Emit(const RelCommon_Emit& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - output_mapping_(from.output_mapping_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Emit) -} - -inline void RelCommon_Emit::SharedCtor() { -} - -RelCommon_Emit::~RelCommon_Emit() { - // @@protoc_insertion_point(destructor:substrait.RelCommon.Emit) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void RelCommon_Emit::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void RelCommon_Emit::ArenaDtor(void* object) { - RelCommon_Emit* _this = reinterpret_cast< RelCommon_Emit* >(object); - (void)_this; -} -void RelCommon_Emit::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void RelCommon_Emit::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void RelCommon_Emit::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Emit) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - output_mapping_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* RelCommon_Emit::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated int32 output_mapping = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_output_mapping(), ptr, ctx); - CHK_(ptr); - } else if (static_cast(tag) == 8) { - _internal_add_output_mapping(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* RelCommon_Emit::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Emit) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated int32 output_mapping = 1; - { - int byte_size = _output_mapping_cached_byte_size_.load(std::memory_order_relaxed); - if (byte_size > 0) { - target = stream->WriteInt32Packed( - 1, _internal_output_mapping(), byte_size, target); - } - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Emit) - return target; -} - -size_t RelCommon_Emit::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Emit) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated int32 output_mapping = 1; - { - size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - Int32Size(this->output_mapping_); - if (data_size > 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - static_cast(data_size)); - } - int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size); - _output_mapping_cached_byte_size_.store(cached_size, - std::memory_order_relaxed); - total_size += data_size; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Emit::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - RelCommon_Emit::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Emit::GetClassData() const { return &_class_data_; } - -void RelCommon_Emit::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void RelCommon_Emit::MergeFrom(const RelCommon_Emit& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Emit) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - output_mapping_.MergeFrom(from.output_mapping_); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void RelCommon_Emit::CopyFrom(const RelCommon_Emit& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Emit) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool RelCommon_Emit::IsInitialized() const { - return true; -} - -void RelCommon_Emit::InternalSwap(RelCommon_Emit* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - output_mapping_.InternalSwap(&other->output_mapping_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Emit::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[1]); -} - -// =================================================================== - -class RelCommon_Hint_Stats::_Internal { - public: - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_Stats* msg); -}; - -const ::substrait::extensions::AdvancedExtension& -RelCommon_Hint_Stats::_Internal::advanced_extension(const RelCommon_Hint_Stats* msg) { - return *msg->advanced_extension_; -} -void RelCommon_Hint_Stats::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -RelCommon_Hint_Stats::RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint.Stats) -} -RelCommon_Hint_Stats::RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - ::memcpy(&row_count_, &from.row_count_, - static_cast(reinterpret_cast(&record_size_) - - reinterpret_cast(&row_count_)) + sizeof(record_size_)); - // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.Stats) -} - -inline void RelCommon_Hint_Stats::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&advanced_extension_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&record_size_) - - reinterpret_cast(&advanced_extension_)) + sizeof(record_size_)); -} - -RelCommon_Hint_Stats::~RelCommon_Hint_Stats() { - // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint.Stats) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void RelCommon_Hint_Stats::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete advanced_extension_; -} - -void RelCommon_Hint_Stats::ArenaDtor(void* object) { - RelCommon_Hint_Stats* _this = reinterpret_cast< RelCommon_Hint_Stats* >(object); - (void)_this; -} -void RelCommon_Hint_Stats::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void RelCommon_Hint_Stats::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void RelCommon_Hint_Stats::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint.Stats) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - ::memset(&row_count_, 0, static_cast( - reinterpret_cast(&record_size_) - - reinterpret_cast(&row_count_)) + sizeof(record_size_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* RelCommon_Hint_Stats::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // double row_count = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 9)) { - row_count_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // double record_size = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 17)) { - record_size_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad(ptr); - ptr += sizeof(double); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* RelCommon_Hint_Stats::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint.Stats) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // double row_count = 1; - static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); - double tmp_row_count = this->_internal_row_count(); - uint64_t raw_row_count; - memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count)); - if (raw_row_count != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(1, this->_internal_row_count(), target); - } - - // double record_size = 2; - static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); - double tmp_record_size = this->_internal_record_size(); - uint64_t raw_record_size; - memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size)); - if (raw_record_size != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteDoubleToArray(2, this->_internal_record_size(), target); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Hint.Stats) - return target; -} - -size_t RelCommon_Hint_Stats::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint.Stats) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - // double row_count = 1; - static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); - double tmp_row_count = this->_internal_row_count(); - uint64_t raw_row_count; - memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count)); - if (raw_row_count != 0) { - total_size += 1 + 8; - } - - // double record_size = 2; - static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); - double tmp_record_size = this->_internal_record_size(); - uint64_t raw_record_size; - memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size)); - if (raw_record_size != 0) { - total_size += 1 + 8; - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Hint_Stats::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - RelCommon_Hint_Stats::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Hint_Stats::GetClassData() const { return &_class_data_; } - -void RelCommon_Hint_Stats::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void RelCommon_Hint_Stats::MergeFrom(const RelCommon_Hint_Stats& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint.Stats) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); - double tmp_row_count = from._internal_row_count(); - uint64_t raw_row_count; - memcpy(&raw_row_count, &tmp_row_count, sizeof(tmp_row_count)); - if (raw_row_count != 0) { - _internal_set_row_count(from._internal_row_count()); - } - static_assert(sizeof(uint64_t) == sizeof(double), "Code assumes uint64_t and double are the same size."); - double tmp_record_size = from._internal_record_size(); - uint64_t raw_record_size; - memcpy(&raw_record_size, &tmp_record_size, sizeof(tmp_record_size)); - if (raw_record_size != 0) { - _internal_set_record_size(from._internal_record_size()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void RelCommon_Hint_Stats::CopyFrom(const RelCommon_Hint_Stats& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Hint.Stats) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool RelCommon_Hint_Stats::IsInitialized() const { - return true; -} - -void RelCommon_Hint_Stats::InternalSwap(RelCommon_Hint_Stats* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(RelCommon_Hint_Stats, record_size_) - + sizeof(RelCommon_Hint_Stats::record_size_) - - PROTOBUF_FIELD_OFFSET(RelCommon_Hint_Stats, advanced_extension_)>( - reinterpret_cast(&advanced_extension_), - reinterpret_cast(&other->advanced_extension_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_Stats::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[2]); -} - -// =================================================================== - -class RelCommon_Hint_RuntimeConstraint::_Internal { - public: - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg); -}; - -const ::substrait::extensions::AdvancedExtension& -RelCommon_Hint_RuntimeConstraint::_Internal::advanced_extension(const RelCommon_Hint_RuntimeConstraint* msg) { - return *msg->advanced_extension_; -} -void RelCommon_Hint_RuntimeConstraint::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint.RuntimeConstraint) -} -RelCommon_Hint_RuntimeConstraint::RelCommon_Hint_RuntimeConstraint(const RelCommon_Hint_RuntimeConstraint& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint.RuntimeConstraint) -} - -inline void RelCommon_Hint_RuntimeConstraint::SharedCtor() { -advanced_extension_ = nullptr; -} - -RelCommon_Hint_RuntimeConstraint::~RelCommon_Hint_RuntimeConstraint() { - // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint.RuntimeConstraint) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void RelCommon_Hint_RuntimeConstraint::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete advanced_extension_; -} - -void RelCommon_Hint_RuntimeConstraint::ArenaDtor(void* object) { - RelCommon_Hint_RuntimeConstraint* _this = reinterpret_cast< RelCommon_Hint_RuntimeConstraint* >(object); - (void)_this; -} -void RelCommon_Hint_RuntimeConstraint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void RelCommon_Hint_RuntimeConstraint::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void RelCommon_Hint_RuntimeConstraint::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint.RuntimeConstraint) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* RelCommon_Hint_RuntimeConstraint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* RelCommon_Hint_RuntimeConstraint::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint.RuntimeConstraint) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Hint.RuntimeConstraint) - return target; -} - -size_t RelCommon_Hint_RuntimeConstraint::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint.RuntimeConstraint) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Hint_RuntimeConstraint::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - RelCommon_Hint_RuntimeConstraint::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Hint_RuntimeConstraint::GetClassData() const { return &_class_data_; } - -void RelCommon_Hint_RuntimeConstraint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void RelCommon_Hint_RuntimeConstraint::MergeFrom(const RelCommon_Hint_RuntimeConstraint& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint.RuntimeConstraint) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void RelCommon_Hint_RuntimeConstraint::CopyFrom(const RelCommon_Hint_RuntimeConstraint& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Hint.RuntimeConstraint) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool RelCommon_Hint_RuntimeConstraint::IsInitialized() const { - return true; -} - -void RelCommon_Hint_RuntimeConstraint::InternalSwap(RelCommon_Hint_RuntimeConstraint* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(advanced_extension_, other->advanced_extension_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint_RuntimeConstraint::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[3]); -} - -// =================================================================== - -class RelCommon_Hint::_Internal { - public: - static const ::substrait::RelCommon_Hint_Stats& stats(const RelCommon_Hint* msg); - static const ::substrait::RelCommon_Hint_RuntimeConstraint& constraint(const RelCommon_Hint* msg); - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon_Hint* msg); -}; - -const ::substrait::RelCommon_Hint_Stats& -RelCommon_Hint::_Internal::stats(const RelCommon_Hint* msg) { - return *msg->stats_; -} -const ::substrait::RelCommon_Hint_RuntimeConstraint& -RelCommon_Hint::_Internal::constraint(const RelCommon_Hint* msg) { - return *msg->constraint_; -} -const ::substrait::extensions::AdvancedExtension& -RelCommon_Hint::_Internal::advanced_extension(const RelCommon_Hint* msg) { - return *msg->advanced_extension_; -} -void RelCommon_Hint::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -RelCommon_Hint::RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.RelCommon.Hint) -} -RelCommon_Hint::RelCommon_Hint(const RelCommon_Hint& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_stats()) { - stats_ = new ::substrait::RelCommon_Hint_Stats(*from.stats_); - } else { - stats_ = nullptr; - } - if (from._internal_has_constraint()) { - constraint_ = new ::substrait::RelCommon_Hint_RuntimeConstraint(*from.constraint_); - } else { - constraint_ = nullptr; - } - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.RelCommon.Hint) -} - -inline void RelCommon_Hint::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&stats_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&advanced_extension_) - - reinterpret_cast(&stats_)) + sizeof(advanced_extension_)); -} - -RelCommon_Hint::~RelCommon_Hint() { - // @@protoc_insertion_point(destructor:substrait.RelCommon.Hint) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void RelCommon_Hint::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete stats_; - if (this != internal_default_instance()) delete constraint_; - if (this != internal_default_instance()) delete advanced_extension_; -} - -void RelCommon_Hint::ArenaDtor(void* object) { - RelCommon_Hint* _this = reinterpret_cast< RelCommon_Hint* >(object); - (void)_this; -} -void RelCommon_Hint::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void RelCommon_Hint::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void RelCommon_Hint::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.RelCommon.Hint) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && stats_ != nullptr) { - delete stats_; - } - stats_ = nullptr; - if (GetArenaForAllocation() == nullptr && constraint_ != nullptr) { - delete constraint_; - } - constraint_ = nullptr; - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* RelCommon_Hint::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon.Hint.Stats stats = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_stats(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_constraint(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* RelCommon_Hint::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon.Hint) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon.Hint.Stats stats = 1; - if (this->_internal_has_stats()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::stats(this), target, stream); - } - - // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; - if (this->_internal_has_constraint()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::constraint(this), target, stream); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon.Hint) - return target; -} - -size_t RelCommon_Hint::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon.Hint) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.RelCommon.Hint.Stats stats = 1; - if (this->_internal_has_stats()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *stats_); - } - - // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; - if (this->_internal_has_constraint()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *constraint_); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon_Hint::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - RelCommon_Hint::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon_Hint::GetClassData() const { return &_class_data_; } - -void RelCommon_Hint::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void RelCommon_Hint::MergeFrom(const RelCommon_Hint& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon.Hint) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_stats()) { - _internal_mutable_stats()->::substrait::RelCommon_Hint_Stats::MergeFrom(from._internal_stats()); - } - if (from._internal_has_constraint()) { - _internal_mutable_constraint()->::substrait::RelCommon_Hint_RuntimeConstraint::MergeFrom(from._internal_constraint()); - } - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void RelCommon_Hint::CopyFrom(const RelCommon_Hint& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon.Hint) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool RelCommon_Hint::IsInitialized() const { - return true; -} - -void RelCommon_Hint::InternalSwap(RelCommon_Hint* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(RelCommon_Hint, advanced_extension_) - + sizeof(RelCommon_Hint::advanced_extension_) - - PROTOBUF_FIELD_OFFSET(RelCommon_Hint, stats_)>( - reinterpret_cast(&stats_), - reinterpret_cast(&other->stats_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata RelCommon_Hint::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[4]); -} - -// =================================================================== - -class RelCommon::_Internal { - public: - static const ::substrait::RelCommon_Direct& direct(const RelCommon* msg); - static const ::substrait::RelCommon_Emit& emit(const RelCommon* msg); - static const ::substrait::RelCommon_Hint& hint(const RelCommon* msg); - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const RelCommon* msg); -}; - -const ::substrait::RelCommon_Direct& -RelCommon::_Internal::direct(const RelCommon* msg) { - return *msg->emit_kind_.direct_; -} -const ::substrait::RelCommon_Emit& -RelCommon::_Internal::emit(const RelCommon* msg) { - return *msg->emit_kind_.emit_; -} -const ::substrait::RelCommon_Hint& -RelCommon::_Internal::hint(const RelCommon* msg) { - return *msg->hint_; -} -const ::substrait::extensions::AdvancedExtension& -RelCommon::_Internal::advanced_extension(const RelCommon* msg) { - return *msg->advanced_extension_; -} -void RelCommon::set_allocated_direct(::substrait::RelCommon_Direct* direct) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_emit_kind(); - if (direct) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Direct>::GetOwningArena(direct); - if (message_arena != submessage_arena) { - direct = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, direct, submessage_arena); - } - set_has_direct(); - emit_kind_.direct_ = direct; - } - // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.direct) -} -void RelCommon::set_allocated_emit(::substrait::RelCommon_Emit* emit) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_emit_kind(); - if (emit) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Emit>::GetOwningArena(emit); - if (message_arena != submessage_arena) { - emit = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, emit, submessage_arena); - } - set_has_emit(); - emit_kind_.emit_ = emit; - } - // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.emit) -} -void RelCommon::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -RelCommon::RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.RelCommon) -} -RelCommon::RelCommon(const RelCommon& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_hint()) { - hint_ = new ::substrait::RelCommon_Hint(*from.hint_); - } else { - hint_ = nullptr; - } - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - clear_has_emit_kind(); - switch (from.emit_kind_case()) { - case kDirect: { - _internal_mutable_direct()->::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); - break; - } - case kEmit: { - _internal_mutable_emit()->::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); - break; - } - case EMIT_KIND_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.RelCommon) -} - -inline void RelCommon::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&hint_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&advanced_extension_) - - reinterpret_cast(&hint_)) + sizeof(advanced_extension_)); -clear_has_emit_kind(); -} - -RelCommon::~RelCommon() { - // @@protoc_insertion_point(destructor:substrait.RelCommon) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void RelCommon::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete hint_; - if (this != internal_default_instance()) delete advanced_extension_; - if (has_emit_kind()) { - clear_emit_kind(); - } -} - -void RelCommon::ArenaDtor(void* object) { - RelCommon* _this = reinterpret_cast< RelCommon* >(object); - (void)_this; -} -void RelCommon::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void RelCommon::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void RelCommon::clear_emit_kind() { -// @@protoc_insertion_point(one_of_clear_start:substrait.RelCommon) - switch (emit_kind_case()) { - case kDirect: { - if (GetArenaForAllocation() == nullptr) { - delete emit_kind_.direct_; - } - break; - } - case kEmit: { - if (GetArenaForAllocation() == nullptr) { - delete emit_kind_.emit_; - } - break; - } - case EMIT_KIND_NOT_SET: { - break; - } - } - _oneof_case_[0] = EMIT_KIND_NOT_SET; -} - - -void RelCommon::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.RelCommon) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && hint_ != nullptr) { - delete hint_; - } - hint_ = nullptr; - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - clear_emit_kind(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* RelCommon::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon.Direct direct = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_direct(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.RelCommon.Emit emit = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_emit(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.RelCommon.Hint hint = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_hint(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* RelCommon::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.RelCommon) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon.Direct direct = 1; - if (_internal_has_direct()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::direct(this), target, stream); - } - - // .substrait.RelCommon.Emit emit = 2; - if (_internal_has_emit()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::emit(this), target, stream); - } - - // .substrait.RelCommon.Hint hint = 3; - if (this->_internal_has_hint()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::hint(this), target, stream); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 4; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.RelCommon) - return target; -} - -size_t RelCommon::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.RelCommon) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.RelCommon.Hint hint = 3; - if (this->_internal_has_hint()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *hint_); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 4; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - switch (emit_kind_case()) { - // .substrait.RelCommon.Direct direct = 1; - case kDirect: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *emit_kind_.direct_); - break; - } - // .substrait.RelCommon.Emit emit = 2; - case kEmit: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *emit_kind_.emit_); - break; - } - case EMIT_KIND_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelCommon::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - RelCommon::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelCommon::GetClassData() const { return &_class_data_; } - -void RelCommon::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void RelCommon::MergeFrom(const RelCommon& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelCommon) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_hint()) { - _internal_mutable_hint()->::substrait::RelCommon_Hint::MergeFrom(from._internal_hint()); - } - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - switch (from.emit_kind_case()) { - case kDirect: { - _internal_mutable_direct()->::substrait::RelCommon_Direct::MergeFrom(from._internal_direct()); - break; - } - case kEmit: { - _internal_mutable_emit()->::substrait::RelCommon_Emit::MergeFrom(from._internal_emit()); - break; - } - case EMIT_KIND_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void RelCommon::CopyFrom(const RelCommon& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelCommon) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool RelCommon::IsInitialized() const { - return true; -} - -void RelCommon::InternalSwap(RelCommon* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(RelCommon, advanced_extension_) - + sizeof(RelCommon::advanced_extension_) - - PROTOBUF_FIELD_OFFSET(RelCommon, hint_)>( - reinterpret_cast(&hint_), - reinterpret_cast(&other->hint_)); - swap(emit_kind_, other->emit_kind_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata RelCommon::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[5]); -} - -// =================================================================== - -class ReadRel_NamedTable::_Internal { - public: - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_NamedTable* msg); -}; - -const ::substrait::extensions::AdvancedExtension& -ReadRel_NamedTable::_Internal::advanced_extension(const ReadRel_NamedTable* msg) { - return *msg->advanced_extension_; -} -void ReadRel_NamedTable::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -ReadRel_NamedTable::ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - names_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.NamedTable) -} -ReadRel_NamedTable::ReadRel_NamedTable(const ReadRel_NamedTable& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - names_(from.names_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.NamedTable) -} - -inline void ReadRel_NamedTable::SharedCtor() { -advanced_extension_ = nullptr; -} - -ReadRel_NamedTable::~ReadRel_NamedTable() { - // @@protoc_insertion_point(destructor:substrait.ReadRel.NamedTable) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ReadRel_NamedTable::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete advanced_extension_; -} - -void ReadRel_NamedTable::ArenaDtor(void* object) { - ReadRel_NamedTable* _this = reinterpret_cast< ReadRel_NamedTable* >(object); - (void)_this; -} -void ReadRel_NamedTable::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReadRel_NamedTable::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReadRel_NamedTable::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.NamedTable) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - names_.Clear(); - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReadRel_NamedTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string names = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_names(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.NamedTable.names")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ReadRel_NamedTable::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.NamedTable) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string names = 1; - for (int i = 0, n = this->_internal_names_size(); i < n; i++) { - const auto& s = this->_internal_names(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.ReadRel.NamedTable.names"); - target = stream->WriteString(1, s, target); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.NamedTable) - return target; -} - -size_t ReadRel_NamedTable::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.NamedTable) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string names = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); - for (int i = 0, n = names_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - names_.Get(i)); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_NamedTable::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ReadRel_NamedTable::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_NamedTable::GetClassData() const { return &_class_data_; } - -void ReadRel_NamedTable::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ReadRel_NamedTable::MergeFrom(const ReadRel_NamedTable& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.NamedTable) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - names_.MergeFrom(from.names_); - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ReadRel_NamedTable::CopyFrom(const ReadRel_NamedTable& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.NamedTable) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReadRel_NamedTable::IsInitialized() const { - return true; -} - -void ReadRel_NamedTable::InternalSwap(ReadRel_NamedTable* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - names_.InternalSwap(&other->names_); - swap(advanced_extension_, other->advanced_extension_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_NamedTable::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[6]); -} - -// =================================================================== - -class ReadRel_VirtualTable::_Internal { - public: -}; - -void ReadRel_VirtualTable::clear_values() { - values_.Clear(); -} -ReadRel_VirtualTable::ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - values_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.VirtualTable) -} -ReadRel_VirtualTable::ReadRel_VirtualTable(const ReadRel_VirtualTable& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - values_(from.values_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.VirtualTable) -} - -inline void ReadRel_VirtualTable::SharedCtor() { -} - -ReadRel_VirtualTable::~ReadRel_VirtualTable() { - // @@protoc_insertion_point(destructor:substrait.ReadRel.VirtualTable) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ReadRel_VirtualTable::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void ReadRel_VirtualTable::ArenaDtor(void* object) { - ReadRel_VirtualTable* _this = reinterpret_cast< ReadRel_VirtualTable* >(object); - (void)_this; -} -void ReadRel_VirtualTable::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReadRel_VirtualTable::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReadRel_VirtualTable::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.VirtualTable) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - values_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReadRel_VirtualTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression.Literal.Struct values = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_values(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* ReadRel_VirtualTable::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.VirtualTable) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression.Literal.Struct values = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_values_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_values(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.VirtualTable) - return target; -} - -size_t ReadRel_VirtualTable::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.VirtualTable) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression.Literal.Struct values = 1; - total_size += 1UL * this->_internal_values_size(); - for (const auto& msg : this->values_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_VirtualTable::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ReadRel_VirtualTable::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_VirtualTable::GetClassData() const { return &_class_data_; } - -void ReadRel_VirtualTable::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ReadRel_VirtualTable::MergeFrom(const ReadRel_VirtualTable& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.VirtualTable) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - values_.MergeFrom(from.values_); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ReadRel_VirtualTable::CopyFrom(const ReadRel_VirtualTable& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.VirtualTable) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReadRel_VirtualTable::IsInitialized() const { - return true; -} - -void ReadRel_VirtualTable::InternalSwap(ReadRel_VirtualTable* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - values_.InternalSwap(&other->values_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_VirtualTable::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[7]); -} - -// =================================================================== - -class ReadRel_ExtensionTable::_Internal { - public: - static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ReadRel_ExtensionTable* msg); -}; - -const ::PROTOBUF_NAMESPACE_ID::Any& -ReadRel_ExtensionTable::_Internal::detail(const ReadRel_ExtensionTable* msg) { - return *msg->detail_; -} -void ReadRel_ExtensionTable::clear_detail() { - if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { - delete detail_; - } - detail_ = nullptr; -} -ReadRel_ExtensionTable::ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.ExtensionTable) -} -ReadRel_ExtensionTable::ReadRel_ExtensionTable(const ReadRel_ExtensionTable& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_detail()) { - detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_); - } else { - detail_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.ExtensionTable) -} - -inline void ReadRel_ExtensionTable::SharedCtor() { -detail_ = nullptr; -} - -ReadRel_ExtensionTable::~ReadRel_ExtensionTable() { - // @@protoc_insertion_point(destructor:substrait.ReadRel.ExtensionTable) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ReadRel_ExtensionTable::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete detail_; -} - -void ReadRel_ExtensionTable::ArenaDtor(void* object) { - ReadRel_ExtensionTable* _this = reinterpret_cast< ReadRel_ExtensionTable* >(object); - (void)_this; -} -void ReadRel_ExtensionTable::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReadRel_ExtensionTable::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReadRel_ExtensionTable::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.ExtensionTable) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { - delete detail_; - } - detail_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReadRel_ExtensionTable::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .google.protobuf.Any detail = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ReadRel_ExtensionTable::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.ExtensionTable) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .google.protobuf.Any detail = 1; - if (this->_internal_has_detail()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::detail(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.ExtensionTable) - return target; -} - -size_t ReadRel_ExtensionTable::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.ExtensionTable) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .google.protobuf.Any detail = 1; - if (this->_internal_has_detail()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *detail_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_ExtensionTable::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ReadRel_ExtensionTable::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_ExtensionTable::GetClassData() const { return &_class_data_; } - -void ReadRel_ExtensionTable::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ReadRel_ExtensionTable::MergeFrom(const ReadRel_ExtensionTable& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.ExtensionTable) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_detail()) { - _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ReadRel_ExtensionTable::CopyFrom(const ReadRel_ExtensionTable& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.ExtensionTable) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReadRel_ExtensionTable::IsInitialized() const { - return true; -} - -void ReadRel_ExtensionTable::InternalSwap(ReadRel_ExtensionTable* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(detail_, other->detail_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_ExtensionTable::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[8]); -} - -// =================================================================== - -class ReadRel_LocalFiles_FileOrFiles::_Internal { - public: -}; - -ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.LocalFiles.FileOrFiles) -} -ReadRel_LocalFiles_FileOrFiles::ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&format_, &from.format_, - static_cast(reinterpret_cast(&length_) - - reinterpret_cast(&format_)) + sizeof(length_)); - clear_has_path_type(); - switch (from.path_type_case()) { - case kUriPath: { - _internal_set_uri_path(from._internal_uri_path()); - break; - } - case kUriPathGlob: { - _internal_set_uri_path_glob(from._internal_uri_path_glob()); - break; - } - case kUriFile: { - _internal_set_uri_file(from._internal_uri_file()); - break; - } - case kUriFolder: { - _internal_set_uri_folder(from._internal_uri_folder()); - break; - } - case PATH_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.LocalFiles.FileOrFiles) -} - -inline void ReadRel_LocalFiles_FileOrFiles::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&format_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&length_) - - reinterpret_cast(&format_)) + sizeof(length_)); -clear_has_path_type(); -} - -ReadRel_LocalFiles_FileOrFiles::~ReadRel_LocalFiles_FileOrFiles() { - // @@protoc_insertion_point(destructor:substrait.ReadRel.LocalFiles.FileOrFiles) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ReadRel_LocalFiles_FileOrFiles::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_path_type()) { - clear_path_type(); - } -} - -void ReadRel_LocalFiles_FileOrFiles::ArenaDtor(void* object) { - ReadRel_LocalFiles_FileOrFiles* _this = reinterpret_cast< ReadRel_LocalFiles_FileOrFiles* >(object); - (void)_this; -} -void ReadRel_LocalFiles_FileOrFiles::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReadRel_LocalFiles_FileOrFiles::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReadRel_LocalFiles_FileOrFiles::clear_path_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.ReadRel.LocalFiles.FileOrFiles) - switch (path_type_case()) { - case kUriPath: { - path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kUriPathGlob: { - path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kUriFile: { - path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kUriFolder: { - path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case PATH_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = PATH_TYPE_NOT_SET; -} - - -void ReadRel_LocalFiles_FileOrFiles::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.LocalFiles.FileOrFiles) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&format_, 0, static_cast( - reinterpret_cast(&length_) - - reinterpret_cast(&format_)) + sizeof(length_)); - clear_path_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReadRel_LocalFiles_FileOrFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string uri_path = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_uri_path(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string uri_path_glob = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_uri_path_glob(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string uri_file = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - auto str = _internal_mutable_uri_file(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_file")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string uri_folder = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - auto str = _internal_mutable_uri_folder(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 40)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_format(static_cast<::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat>(val)); - } else - goto handle_unusual; - continue; - // uint64 partition_index = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - partition_index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint64 start = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 56)) { - start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint64 length = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 64)) { - length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ReadRel_LocalFiles_FileOrFiles::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.LocalFiles.FileOrFiles) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string uri_path = 1; - if (_internal_has_uri_path()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_uri_path().data(), static_cast(this->_internal_uri_path().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_uri_path(), target); - } - - // string uri_path_glob = 2; - if (_internal_has_uri_path_glob()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_uri_path_glob().data(), static_cast(this->_internal_uri_path_glob().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob"); - target = stream->WriteStringMaybeAliased( - 2, this->_internal_uri_path_glob(), target); - } - - // string uri_file = 3; - if (_internal_has_uri_file()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_uri_file().data(), static_cast(this->_internal_uri_file().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.ReadRel.LocalFiles.FileOrFiles.uri_file"); - target = stream->WriteStringMaybeAliased( - 3, this->_internal_uri_file(), target); - } - - // string uri_folder = 4; - if (_internal_has_uri_folder()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_uri_folder().data(), static_cast(this->_internal_uri_folder().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder"); - target = stream->WriteStringMaybeAliased( - 4, this->_internal_uri_folder(), target); - } - - // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; - if (this->_internal_format() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 5, this->_internal_format(), target); - } - - // uint64 partition_index = 6; - if (this->_internal_partition_index() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(6, this->_internal_partition_index(), target); - } - - // uint64 start = 7; - if (this->_internal_start() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(7, this->_internal_start(), target); - } - - // uint64 length = 8; - if (this->_internal_length() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(8, this->_internal_length(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.LocalFiles.FileOrFiles) - return target; -} - -size_t ReadRel_LocalFiles_FileOrFiles::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.LocalFiles.FileOrFiles) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; - if (this->_internal_format() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_format()); - } - - // uint64 partition_index = 6; - if (this->_internal_partition_index() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_partition_index()); - } - - // uint64 start = 7; - if (this->_internal_start() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_start()); - } - - // uint64 length = 8; - if (this->_internal_length() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_length()); - } - - switch (path_type_case()) { - // string uri_path = 1; - case kUriPath: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_uri_path()); - break; - } - // string uri_path_glob = 2; - case kUriPathGlob: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_uri_path_glob()); - break; - } - // string uri_file = 3; - case kUriFile: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_uri_file()); - break; - } - // string uri_folder = 4; - case kUriFolder: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_uri_folder()); - break; - } - case PATH_TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_LocalFiles_FileOrFiles::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ReadRel_LocalFiles_FileOrFiles::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_LocalFiles_FileOrFiles::GetClassData() const { return &_class_data_; } - -void ReadRel_LocalFiles_FileOrFiles::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ReadRel_LocalFiles_FileOrFiles::MergeFrom(const ReadRel_LocalFiles_FileOrFiles& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.LocalFiles.FileOrFiles) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_format() != 0) { - _internal_set_format(from._internal_format()); - } - if (from._internal_partition_index() != 0) { - _internal_set_partition_index(from._internal_partition_index()); - } - if (from._internal_start() != 0) { - _internal_set_start(from._internal_start()); - } - if (from._internal_length() != 0) { - _internal_set_length(from._internal_length()); - } - switch (from.path_type_case()) { - case kUriPath: { - _internal_set_uri_path(from._internal_uri_path()); - break; - } - case kUriPathGlob: { - _internal_set_uri_path_glob(from._internal_uri_path_glob()); - break; - } - case kUriFile: { - _internal_set_uri_file(from._internal_uri_file()); - break; - } - case kUriFolder: { - _internal_set_uri_folder(from._internal_uri_folder()); - break; - } - case PATH_TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ReadRel_LocalFiles_FileOrFiles::CopyFrom(const ReadRel_LocalFiles_FileOrFiles& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.LocalFiles.FileOrFiles) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReadRel_LocalFiles_FileOrFiles::IsInitialized() const { - return true; -} - -void ReadRel_LocalFiles_FileOrFiles::InternalSwap(ReadRel_LocalFiles_FileOrFiles* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ReadRel_LocalFiles_FileOrFiles, length_) - + sizeof(ReadRel_LocalFiles_FileOrFiles::length_) - - PROTOBUF_FIELD_OFFSET(ReadRel_LocalFiles_FileOrFiles, format_)>( - reinterpret_cast(&format_), - reinterpret_cast(&other->format_)); - swap(path_type_, other->path_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles_FileOrFiles::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[9]); -} - -// =================================================================== - -class ReadRel_LocalFiles::_Internal { - public: - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel_LocalFiles* msg); -}; - -const ::substrait::extensions::AdvancedExtension& -ReadRel_LocalFiles::_Internal::advanced_extension(const ReadRel_LocalFiles* msg) { - return *msg->advanced_extension_; -} -void ReadRel_LocalFiles::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -ReadRel_LocalFiles::ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - items_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ReadRel.LocalFiles) -} -ReadRel_LocalFiles::ReadRel_LocalFiles(const ReadRel_LocalFiles& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - items_(from.items_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.ReadRel.LocalFiles) -} - -inline void ReadRel_LocalFiles::SharedCtor() { -advanced_extension_ = nullptr; -} - -ReadRel_LocalFiles::~ReadRel_LocalFiles() { - // @@protoc_insertion_point(destructor:substrait.ReadRel.LocalFiles) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ReadRel_LocalFiles::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete advanced_extension_; -} - -void ReadRel_LocalFiles::ArenaDtor(void* object) { - ReadRel_LocalFiles* _this = reinterpret_cast< ReadRel_LocalFiles* >(object); - (void)_this; -} -void ReadRel_LocalFiles::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReadRel_LocalFiles::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReadRel_LocalFiles::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ReadRel.LocalFiles) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - items_.Clear(); - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReadRel_LocalFiles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_items(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ReadRel_LocalFiles::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel.LocalFiles) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_items_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_items(i), target, stream); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel.LocalFiles) - return target; -} - -size_t ReadRel_LocalFiles::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel.LocalFiles) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; - total_size += 1UL * this->_internal_items_size(); - for (const auto& msg : this->items_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel_LocalFiles::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ReadRel_LocalFiles::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel_LocalFiles::GetClassData() const { return &_class_data_; } - -void ReadRel_LocalFiles::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ReadRel_LocalFiles::MergeFrom(const ReadRel_LocalFiles& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel.LocalFiles) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - items_.MergeFrom(from.items_); - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ReadRel_LocalFiles::CopyFrom(const ReadRel_LocalFiles& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel.LocalFiles) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReadRel_LocalFiles::IsInitialized() const { - return true; -} - -void ReadRel_LocalFiles::InternalSwap(ReadRel_LocalFiles* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - items_.InternalSwap(&other->items_); - swap(advanced_extension_, other->advanced_extension_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReadRel_LocalFiles::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[10]); -} - -// =================================================================== - -class ReadRel::_Internal { - public: - static const ::substrait::RelCommon& common(const ReadRel* msg); - static const ::substrait::NamedStruct& base_schema(const ReadRel* msg); - static const ::substrait::Expression& filter(const ReadRel* msg); - static const ::substrait::Expression_MaskExpression& projection(const ReadRel* msg); - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ReadRel* msg); - static const ::substrait::ReadRel_VirtualTable& virtual_table(const ReadRel* msg); - static const ::substrait::ReadRel_LocalFiles& local_files(const ReadRel* msg); - static const ::substrait::ReadRel_NamedTable& named_table(const ReadRel* msg); - static const ::substrait::ReadRel_ExtensionTable& extension_table(const ReadRel* msg); -}; - -const ::substrait::RelCommon& -ReadRel::_Internal::common(const ReadRel* msg) { - return *msg->common_; -} -const ::substrait::NamedStruct& -ReadRel::_Internal::base_schema(const ReadRel* msg) { - return *msg->base_schema_; -} -const ::substrait::Expression& -ReadRel::_Internal::filter(const ReadRel* msg) { - return *msg->filter_; -} -const ::substrait::Expression_MaskExpression& -ReadRel::_Internal::projection(const ReadRel* msg) { - return *msg->projection_; -} -const ::substrait::extensions::AdvancedExtension& -ReadRel::_Internal::advanced_extension(const ReadRel* msg) { - return *msg->advanced_extension_; -} -const ::substrait::ReadRel_VirtualTable& -ReadRel::_Internal::virtual_table(const ReadRel* msg) { - return *msg->read_type_.virtual_table_; -} -const ::substrait::ReadRel_LocalFiles& -ReadRel::_Internal::local_files(const ReadRel* msg) { - return *msg->read_type_.local_files_; -} -const ::substrait::ReadRel_NamedTable& -ReadRel::_Internal::named_table(const ReadRel* msg) { - return *msg->read_type_.named_table_; -} -const ::substrait::ReadRel_ExtensionTable& -ReadRel::_Internal::extension_table(const ReadRel* msg) { - return *msg->read_type_.extension_table_; -} -void ReadRel::clear_base_schema() { - if (GetArenaForAllocation() == nullptr && base_schema_ != nullptr) { - delete base_schema_; - } - base_schema_ = nullptr; -} -void ReadRel::clear_filter() { - if (GetArenaForAllocation() == nullptr && filter_ != nullptr) { - delete filter_; - } - filter_ = nullptr; -} -void ReadRel::clear_projection() { - if (GetArenaForAllocation() == nullptr && projection_ != nullptr) { - delete projection_; - } - projection_ = nullptr; -} -void ReadRel::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -void ReadRel::set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_read_type(); - if (virtual_table) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_VirtualTable>::GetOwningArena(virtual_table); - if (message_arena != submessage_arena) { - virtual_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, virtual_table, submessage_arena); - } - set_has_virtual_table(); - read_type_.virtual_table_ = virtual_table; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.virtual_table) -} -void ReadRel::set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_read_type(); - if (local_files) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_LocalFiles>::GetOwningArena(local_files); - if (message_arena != submessage_arena) { - local_files = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, local_files, submessage_arena); - } - set_has_local_files(); - read_type_.local_files_ = local_files; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.local_files) -} -void ReadRel::set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_read_type(); - if (named_table) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_NamedTable>::GetOwningArena(named_table); - if (message_arena != submessage_arena) { - named_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, named_table, submessage_arena); - } - set_has_named_table(); - read_type_.named_table_ = named_table; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.named_table) -} -void ReadRel::set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_read_type(); - if (extension_table) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel_ExtensionTable>::GetOwningArena(extension_table); - if (message_arena != submessage_arena) { - extension_table = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_table, submessage_arena); - } - set_has_extension_table(); - read_type_.extension_table_ = extension_table; - } - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.extension_table) -} -ReadRel::ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ReadRel) -} -ReadRel::ReadRel(const ReadRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_base_schema()) { - base_schema_ = new ::substrait::NamedStruct(*from.base_schema_); - } else { - base_schema_ = nullptr; - } - if (from._internal_has_filter()) { - filter_ = new ::substrait::Expression(*from.filter_); - } else { - filter_ = nullptr; - } - if (from._internal_has_projection()) { - projection_ = new ::substrait::Expression_MaskExpression(*from.projection_); - } else { - projection_ = nullptr; - } - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - clear_has_read_type(); - switch (from.read_type_case()) { - case kVirtualTable: { - _internal_mutable_virtual_table()->::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table()); - break; - } - case kLocalFiles: { - _internal_mutable_local_files()->::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files()); - break; - } - case kNamedTable: { - _internal_mutable_named_table()->::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table()); - break; - } - case kExtensionTable: { - _internal_mutable_extension_table()->::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table()); - break; - } - case READ_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.ReadRel) -} - -inline void ReadRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&advanced_extension_) - - reinterpret_cast(&common_)) + sizeof(advanced_extension_)); -clear_has_read_type(); -} - -ReadRel::~ReadRel() { - // @@protoc_insertion_point(destructor:substrait.ReadRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ReadRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete base_schema_; - if (this != internal_default_instance()) delete filter_; - if (this != internal_default_instance()) delete projection_; - if (this != internal_default_instance()) delete advanced_extension_; - if (has_read_type()) { - clear_read_type(); - } -} - -void ReadRel::ArenaDtor(void* object) { - ReadRel* _this = reinterpret_cast< ReadRel* >(object); - (void)_this; -} -void ReadRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ReadRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ReadRel::clear_read_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.ReadRel) - switch (read_type_case()) { - case kVirtualTable: { - if (GetArenaForAllocation() == nullptr) { - delete read_type_.virtual_table_; - } - break; - } - case kLocalFiles: { - if (GetArenaForAllocation() == nullptr) { - delete read_type_.local_files_; - } - break; - } - case kNamedTable: { - if (GetArenaForAllocation() == nullptr) { - delete read_type_.named_table_; - } - break; - } - case kExtensionTable: { - if (GetArenaForAllocation() == nullptr) { - delete read_type_.extension_table_; - } - break; - } - case READ_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = READ_TYPE_NOT_SET; -} - - -void ReadRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ReadRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && base_schema_ != nullptr) { - delete base_schema_; - } - base_schema_ = nullptr; - if (GetArenaForAllocation() == nullptr && filter_ != nullptr) { - delete filter_; - } - filter_ = nullptr; - if (GetArenaForAllocation() == nullptr && projection_ != nullptr) { - delete projection_; - } - projection_ = nullptr; - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - clear_read_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ReadRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.NamedStruct base_schema = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_base_schema(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression filter = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression.MaskExpression projection = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_projection(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ReadRel.VirtualTable virtual_table = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_virtual_table(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ReadRel.LocalFiles local_files = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_local_files(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ReadRel.NamedTable named_table = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_named_table(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ReadRel.ExtensionTable extension_table = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_table(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ReadRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ReadRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // .substrait.NamedStruct base_schema = 2; - if (this->_internal_has_base_schema()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::base_schema(this), target, stream); - } - - // .substrait.Expression filter = 3; - if (this->_internal_has_filter()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::filter(this), target, stream); - } - - // .substrait.Expression.MaskExpression projection = 4; - if (this->_internal_has_projection()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::projection(this), target, stream); - } - - // .substrait.ReadRel.VirtualTable virtual_table = 5; - if (_internal_has_virtual_table()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::virtual_table(this), target, stream); - } - - // .substrait.ReadRel.LocalFiles local_files = 6; - if (_internal_has_local_files()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 6, _Internal::local_files(this), target, stream); - } - - // .substrait.ReadRel.NamedTable named_table = 7; - if (_internal_has_named_table()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 7, _Internal::named_table(this), target, stream); - } - - // .substrait.ReadRel.ExtensionTable extension_table = 8; - if (_internal_has_extension_table()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 8, _Internal::extension_table(this), target, stream); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ReadRel) - return target; -} - -size_t ReadRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ReadRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .substrait.NamedStruct base_schema = 2; - if (this->_internal_has_base_schema()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *base_schema_); - } - - // .substrait.Expression filter = 3; - if (this->_internal_has_filter()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *filter_); - } - - // .substrait.Expression.MaskExpression projection = 4; - if (this->_internal_has_projection()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *projection_); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - switch (read_type_case()) { - // .substrait.ReadRel.VirtualTable virtual_table = 5; - case kVirtualTable: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *read_type_.virtual_table_); - break; - } - // .substrait.ReadRel.LocalFiles local_files = 6; - case kLocalFiles: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *read_type_.local_files_); - break; - } - // .substrait.ReadRel.NamedTable named_table = 7; - case kNamedTable: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *read_type_.named_table_); - break; - } - // .substrait.ReadRel.ExtensionTable extension_table = 8; - case kExtensionTable: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *read_type_.extension_table_); - break; - } - case READ_TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ReadRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ReadRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ReadRel::GetClassData() const { return &_class_data_; } - -void ReadRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ReadRel::MergeFrom(const ReadRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ReadRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_base_schema()) { - _internal_mutable_base_schema()->::substrait::NamedStruct::MergeFrom(from._internal_base_schema()); - } - if (from._internal_has_filter()) { - _internal_mutable_filter()->::substrait::Expression::MergeFrom(from._internal_filter()); - } - if (from._internal_has_projection()) { - _internal_mutable_projection()->::substrait::Expression_MaskExpression::MergeFrom(from._internal_projection()); - } - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - switch (from.read_type_case()) { - case kVirtualTable: { - _internal_mutable_virtual_table()->::substrait::ReadRel_VirtualTable::MergeFrom(from._internal_virtual_table()); - break; - } - case kLocalFiles: { - _internal_mutable_local_files()->::substrait::ReadRel_LocalFiles::MergeFrom(from._internal_local_files()); - break; - } - case kNamedTable: { - _internal_mutable_named_table()->::substrait::ReadRel_NamedTable::MergeFrom(from._internal_named_table()); - break; - } - case kExtensionTable: { - _internal_mutable_extension_table()->::substrait::ReadRel_ExtensionTable::MergeFrom(from._internal_extension_table()); - break; - } - case READ_TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ReadRel::CopyFrom(const ReadRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ReadRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ReadRel::IsInitialized() const { - return true; -} - -void ReadRel::InternalSwap(ReadRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ReadRel, advanced_extension_) - + sizeof(ReadRel::advanced_extension_) - - PROTOBUF_FIELD_OFFSET(ReadRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); - swap(read_type_, other->read_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ReadRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[11]); -} - -// =================================================================== - -class ProjectRel::_Internal { - public: - static const ::substrait::RelCommon& common(const ProjectRel* msg); - static const ::substrait::Rel& input(const ProjectRel* msg); - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const ProjectRel* msg); -}; - -const ::substrait::RelCommon& -ProjectRel::_Internal::common(const ProjectRel* msg) { - return *msg->common_; -} -const ::substrait::Rel& -ProjectRel::_Internal::input(const ProjectRel* msg) { - return *msg->input_; -} -const ::substrait::extensions::AdvancedExtension& -ProjectRel::_Internal::advanced_extension(const ProjectRel* msg) { - return *msg->advanced_extension_; -} -void ProjectRel::clear_expressions() { - expressions_.Clear(); -} -void ProjectRel::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -ProjectRel::ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - expressions_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ProjectRel) -} -ProjectRel::ProjectRel(const ProjectRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - expressions_(from.expressions_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_input()) { - input_ = new ::substrait::Rel(*from.input_); - } else { - input_ = nullptr; - } - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.ProjectRel) -} - -inline void ProjectRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&advanced_extension_) - - reinterpret_cast(&common_)) + sizeof(advanced_extension_)); -} - -ProjectRel::~ProjectRel() { - // @@protoc_insertion_point(destructor:substrait.ProjectRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ProjectRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete input_; - if (this != internal_default_instance()) delete advanced_extension_; -} - -void ProjectRel::ArenaDtor(void* object) { - ProjectRel* _this = reinterpret_cast< ProjectRel* >(object); - (void)_this; -} -void ProjectRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ProjectRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ProjectRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ProjectRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - expressions_.Clear(); - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ProjectRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Rel input = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.Expression expressions = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_expressions(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ProjectRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ProjectRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::input(this), target, stream); - } - - // repeated .substrait.Expression expressions = 3; - for (unsigned int i = 0, - n = static_cast(this->_internal_expressions_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, this->_internal_expressions(i), target, stream); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ProjectRel) - return target; -} - -size_t ProjectRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ProjectRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression expressions = 3; - total_size += 1UL * this->_internal_expressions_size(); - for (const auto& msg : this->expressions_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *input_); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ProjectRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ProjectRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ProjectRel::GetClassData() const { return &_class_data_; } - -void ProjectRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ProjectRel::MergeFrom(const ProjectRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ProjectRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - expressions_.MergeFrom(from.expressions_); - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_input()) { - _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); - } - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ProjectRel::CopyFrom(const ProjectRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ProjectRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ProjectRel::IsInitialized() const { - return true; -} - -void ProjectRel::InternalSwap(ProjectRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - expressions_.InternalSwap(&other->expressions_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ProjectRel, advanced_extension_) - + sizeof(ProjectRel::advanced_extension_) - - PROTOBUF_FIELD_OFFSET(ProjectRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ProjectRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[12]); -} - -// =================================================================== - -class JoinRel::_Internal { - public: - static const ::substrait::RelCommon& common(const JoinRel* msg); - static const ::substrait::Rel& left(const JoinRel* msg); - static const ::substrait::Rel& right(const JoinRel* msg); - static const ::substrait::Expression& expression(const JoinRel* msg); - static const ::substrait::Expression& post_join_filter(const JoinRel* msg); - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const JoinRel* msg); -}; - -const ::substrait::RelCommon& -JoinRel::_Internal::common(const JoinRel* msg) { - return *msg->common_; -} -const ::substrait::Rel& -JoinRel::_Internal::left(const JoinRel* msg) { - return *msg->left_; -} -const ::substrait::Rel& -JoinRel::_Internal::right(const JoinRel* msg) { - return *msg->right_; -} -const ::substrait::Expression& -JoinRel::_Internal::expression(const JoinRel* msg) { - return *msg->expression_; -} -const ::substrait::Expression& -JoinRel::_Internal::post_join_filter(const JoinRel* msg) { - return *msg->post_join_filter_; -} -const ::substrait::extensions::AdvancedExtension& -JoinRel::_Internal::advanced_extension(const JoinRel* msg) { - return *msg->advanced_extension_; -} -void JoinRel::clear_expression() { - if (GetArenaForAllocation() == nullptr && expression_ != nullptr) { - delete expression_; - } - expression_ = nullptr; -} -void JoinRel::clear_post_join_filter() { - if (GetArenaForAllocation() == nullptr && post_join_filter_ != nullptr) { - delete post_join_filter_; - } - post_join_filter_ = nullptr; -} -void JoinRel::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -JoinRel::JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.JoinRel) -} -JoinRel::JoinRel(const JoinRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_left()) { - left_ = new ::substrait::Rel(*from.left_); - } else { - left_ = nullptr; - } - if (from._internal_has_right()) { - right_ = new ::substrait::Rel(*from.right_); - } else { - right_ = nullptr; - } - if (from._internal_has_expression()) { - expression_ = new ::substrait::Expression(*from.expression_); - } else { - expression_ = nullptr; - } - if (from._internal_has_post_join_filter()) { - post_join_filter_ = new ::substrait::Expression(*from.post_join_filter_); - } else { - post_join_filter_ = nullptr; - } - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - type_ = from.type_; - // @@protoc_insertion_point(copy_constructor:substrait.JoinRel) -} - -inline void JoinRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&type_) - - reinterpret_cast(&common_)) + sizeof(type_)); -} - -JoinRel::~JoinRel() { - // @@protoc_insertion_point(destructor:substrait.JoinRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void JoinRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete left_; - if (this != internal_default_instance()) delete right_; - if (this != internal_default_instance()) delete expression_; - if (this != internal_default_instance()) delete post_join_filter_; - if (this != internal_default_instance()) delete advanced_extension_; -} - -void JoinRel::ArenaDtor(void* object) { - JoinRel* _this = reinterpret_cast< JoinRel* >(object); - (void)_this; -} -void JoinRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void JoinRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void JoinRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.JoinRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && left_ != nullptr) { - delete left_; - } - left_ = nullptr; - if (GetArenaForAllocation() == nullptr && right_ != nullptr) { - delete right_; - } - right_ = nullptr; - if (GetArenaForAllocation() == nullptr && expression_ != nullptr) { - delete expression_; - } - expression_ = nullptr; - if (GetArenaForAllocation() == nullptr && post_join_filter_ != nullptr) { - delete post_join_filter_; - } - post_join_filter_ = nullptr; - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - type_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* JoinRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Rel left = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_left(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Rel right = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_right(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression expression = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression post_join_filter = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_post_join_filter(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.JoinRel.JoinType type = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 48)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_type(static_cast<::substrait::JoinRel_JoinType>(val)); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* JoinRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.JoinRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // .substrait.Rel left = 2; - if (this->_internal_has_left()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::left(this), target, stream); - } - - // .substrait.Rel right = 3; - if (this->_internal_has_right()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::right(this), target, stream); - } - - // .substrait.Expression expression = 4; - if (this->_internal_has_expression()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::expression(this), target, stream); - } - - // .substrait.Expression post_join_filter = 5; - if (this->_internal_has_post_join_filter()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::post_join_filter(this), target, stream); - } - - // .substrait.JoinRel.JoinType type = 6; - if (this->_internal_type() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 6, this->_internal_type(), target); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.JoinRel) - return target; -} - -size_t JoinRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.JoinRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .substrait.Rel left = 2; - if (this->_internal_has_left()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *left_); - } - - // .substrait.Rel right = 3; - if (this->_internal_has_right()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *right_); - } - - // .substrait.Expression expression = 4; - if (this->_internal_has_expression()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *expression_); - } - - // .substrait.Expression post_join_filter = 5; - if (this->_internal_has_post_join_filter()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *post_join_filter_); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - // .substrait.JoinRel.JoinType type = 6; - if (this->_internal_type() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData JoinRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - JoinRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*JoinRel::GetClassData() const { return &_class_data_; } - -void JoinRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void JoinRel::MergeFrom(const JoinRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.JoinRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_left()) { - _internal_mutable_left()->::substrait::Rel::MergeFrom(from._internal_left()); - } - if (from._internal_has_right()) { - _internal_mutable_right()->::substrait::Rel::MergeFrom(from._internal_right()); - } - if (from._internal_has_expression()) { - _internal_mutable_expression()->::substrait::Expression::MergeFrom(from._internal_expression()); - } - if (from._internal_has_post_join_filter()) { - _internal_mutable_post_join_filter()->::substrait::Expression::MergeFrom(from._internal_post_join_filter()); - } - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - if (from._internal_type() != 0) { - _internal_set_type(from._internal_type()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void JoinRel::CopyFrom(const JoinRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.JoinRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool JoinRel::IsInitialized() const { - return true; -} - -void JoinRel::InternalSwap(JoinRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(JoinRel, type_) - + sizeof(JoinRel::type_) - - PROTOBUF_FIELD_OFFSET(JoinRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata JoinRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[13]); -} - -// =================================================================== - -class FetchRel::_Internal { - public: - static const ::substrait::RelCommon& common(const FetchRel* msg); - static const ::substrait::Rel& input(const FetchRel* msg); - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const FetchRel* msg); -}; - -const ::substrait::RelCommon& -FetchRel::_Internal::common(const FetchRel* msg) { - return *msg->common_; -} -const ::substrait::Rel& -FetchRel::_Internal::input(const FetchRel* msg) { - return *msg->input_; -} -const ::substrait::extensions::AdvancedExtension& -FetchRel::_Internal::advanced_extension(const FetchRel* msg) { - return *msg->advanced_extension_; -} -void FetchRel::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -FetchRel::FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FetchRel) -} -FetchRel::FetchRel(const FetchRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_input()) { - input_ = new ::substrait::Rel(*from.input_); - } else { - input_ = nullptr; - } - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - ::memcpy(&offset_, &from.offset_, - static_cast(reinterpret_cast(&count_) - - reinterpret_cast(&offset_)) + sizeof(count_)); - // @@protoc_insertion_point(copy_constructor:substrait.FetchRel) -} - -inline void FetchRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&count_) - - reinterpret_cast(&common_)) + sizeof(count_)); -} - -FetchRel::~FetchRel() { - // @@protoc_insertion_point(destructor:substrait.FetchRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FetchRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete input_; - if (this != internal_default_instance()) delete advanced_extension_; -} - -void FetchRel::ArenaDtor(void* object) { - FetchRel* _this = reinterpret_cast< FetchRel* >(object); - (void)_this; -} -void FetchRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FetchRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FetchRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FetchRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - ::memset(&offset_, 0, static_cast( - reinterpret_cast(&count_) - - reinterpret_cast(&offset_)) + sizeof(count_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FetchRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Rel input = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int64 offset = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int64 count = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* FetchRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FetchRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::input(this), target, stream); - } - - // int64 offset = 3; - if (this->_internal_offset() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(3, this->_internal_offset(), target); - } - - // int64 count = 4; - if (this->_internal_count() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt64ToArray(4, this->_internal_count(), target); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FetchRel) - return target; -} - -size_t FetchRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FetchRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *input_); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - // int64 offset = 3; - if (this->_internal_offset() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_offset()); - } - - // int64 count = 4; - if (this->_internal_count() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int64SizePlusOne(this->_internal_count()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FetchRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FetchRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FetchRel::GetClassData() const { return &_class_data_; } - -void FetchRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FetchRel::MergeFrom(const FetchRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FetchRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_input()) { - _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); - } - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - if (from._internal_offset() != 0) { - _internal_set_offset(from._internal_offset()); - } - if (from._internal_count() != 0) { - _internal_set_count(from._internal_count()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FetchRel::CopyFrom(const FetchRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FetchRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FetchRel::IsInitialized() const { - return true; -} - -void FetchRel::InternalSwap(FetchRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(FetchRel, count_) - + sizeof(FetchRel::count_) - - PROTOBUF_FIELD_OFFSET(FetchRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FetchRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[14]); -} - -// =================================================================== - -class AggregateRel_Grouping::_Internal { - public: -}; - -void AggregateRel_Grouping::clear_grouping_expressions() { - grouping_expressions_.Clear(); -} -AggregateRel_Grouping::AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - grouping_expressions_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel.Grouping) -} -AggregateRel_Grouping::AggregateRel_Grouping(const AggregateRel_Grouping& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - grouping_expressions_(from.grouping_expressions_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel.Grouping) -} - -inline void AggregateRel_Grouping::SharedCtor() { -} - -AggregateRel_Grouping::~AggregateRel_Grouping() { - // @@protoc_insertion_point(destructor:substrait.AggregateRel.Grouping) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void AggregateRel_Grouping::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void AggregateRel_Grouping::ArenaDtor(void* object) { - AggregateRel_Grouping* _this = reinterpret_cast< AggregateRel_Grouping* >(object); - (void)_this; -} -void AggregateRel_Grouping::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void AggregateRel_Grouping::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void AggregateRel_Grouping::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.AggregateRel.Grouping) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - grouping_expressions_.Clear(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* AggregateRel_Grouping::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Expression grouping_expressions = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_grouping_expressions(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(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* AggregateRel_Grouping::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel.Grouping) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Expression grouping_expressions = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_grouping_expressions_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_grouping_expressions(i), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateRel.Grouping) - return target; -} - -size_t AggregateRel_Grouping::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel.Grouping) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Expression grouping_expressions = 1; - total_size += 1UL * this->_internal_grouping_expressions_size(); - for (const auto& msg : this->grouping_expressions_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateRel_Grouping::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - AggregateRel_Grouping::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateRel_Grouping::GetClassData() const { return &_class_data_; } - -void AggregateRel_Grouping::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void AggregateRel_Grouping::MergeFrom(const AggregateRel_Grouping& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel.Grouping) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - grouping_expressions_.MergeFrom(from.grouping_expressions_); - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void AggregateRel_Grouping::CopyFrom(const AggregateRel_Grouping& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateRel.Grouping) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool AggregateRel_Grouping::IsInitialized() const { - return true; -} - -void AggregateRel_Grouping::InternalSwap(AggregateRel_Grouping* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - grouping_expressions_.InternalSwap(&other->grouping_expressions_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Grouping::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[15]); -} - -// =================================================================== - -class AggregateRel_Measure::_Internal { - public: - static const ::substrait::AggregateFunction& measure(const AggregateRel_Measure* msg); - static const ::substrait::Expression& filter(const AggregateRel_Measure* msg); -}; - -const ::substrait::AggregateFunction& -AggregateRel_Measure::_Internal::measure(const AggregateRel_Measure* msg) { - return *msg->measure_; -} -const ::substrait::Expression& -AggregateRel_Measure::_Internal::filter(const AggregateRel_Measure* msg) { - return *msg->filter_; -} -void AggregateRel_Measure::clear_measure() { - if (GetArenaForAllocation() == nullptr && measure_ != nullptr) { - delete measure_; - } - measure_ = nullptr; -} -void AggregateRel_Measure::clear_filter() { - if (GetArenaForAllocation() == nullptr && filter_ != nullptr) { - delete filter_; - } - filter_ = nullptr; -} -AggregateRel_Measure::AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel.Measure) -} -AggregateRel_Measure::AggregateRel_Measure(const AggregateRel_Measure& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_measure()) { - measure_ = new ::substrait::AggregateFunction(*from.measure_); - } else { - measure_ = nullptr; - } - if (from._internal_has_filter()) { - filter_ = new ::substrait::Expression(*from.filter_); - } else { - filter_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel.Measure) -} - -inline void AggregateRel_Measure::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&measure_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&filter_) - - reinterpret_cast(&measure_)) + sizeof(filter_)); -} - -AggregateRel_Measure::~AggregateRel_Measure() { - // @@protoc_insertion_point(destructor:substrait.AggregateRel.Measure) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void AggregateRel_Measure::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete measure_; - if (this != internal_default_instance()) delete filter_; -} - -void AggregateRel_Measure::ArenaDtor(void* object) { - AggregateRel_Measure* _this = reinterpret_cast< AggregateRel_Measure* >(object); - (void)_this; -} -void AggregateRel_Measure::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void AggregateRel_Measure::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void AggregateRel_Measure::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.AggregateRel.Measure) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && measure_ != nullptr) { - delete measure_; - } - measure_ = nullptr; - if (GetArenaForAllocation() == nullptr && filter_ != nullptr) { - delete filter_; - } - filter_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* AggregateRel_Measure::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.AggregateFunction measure = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_measure(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression filter = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* AggregateRel_Measure::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel.Measure) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.AggregateFunction measure = 1; - if (this->_internal_has_measure()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::measure(this), target, stream); - } - - // .substrait.Expression filter = 2; - if (this->_internal_has_filter()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::filter(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateRel.Measure) - return target; -} - -size_t AggregateRel_Measure::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel.Measure) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.AggregateFunction measure = 1; - if (this->_internal_has_measure()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *measure_); - } - - // .substrait.Expression filter = 2; - if (this->_internal_has_filter()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *filter_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateRel_Measure::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - AggregateRel_Measure::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateRel_Measure::GetClassData() const { return &_class_data_; } - -void AggregateRel_Measure::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void AggregateRel_Measure::MergeFrom(const AggregateRel_Measure& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel.Measure) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_measure()) { - _internal_mutable_measure()->::substrait::AggregateFunction::MergeFrom(from._internal_measure()); - } - if (from._internal_has_filter()) { - _internal_mutable_filter()->::substrait::Expression::MergeFrom(from._internal_filter()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void AggregateRel_Measure::CopyFrom(const AggregateRel_Measure& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateRel.Measure) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool AggregateRel_Measure::IsInitialized() const { - return true; -} - -void AggregateRel_Measure::InternalSwap(AggregateRel_Measure* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(AggregateRel_Measure, filter_) - + sizeof(AggregateRel_Measure::filter_) - - PROTOBUF_FIELD_OFFSET(AggregateRel_Measure, measure_)>( - reinterpret_cast(&measure_), - reinterpret_cast(&other->measure_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel_Measure::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[16]); -} - -// =================================================================== - -class AggregateRel::_Internal { - public: - static const ::substrait::RelCommon& common(const AggregateRel* msg); - static const ::substrait::Rel& input(const AggregateRel* msg); - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const AggregateRel* msg); -}; - -const ::substrait::RelCommon& -AggregateRel::_Internal::common(const AggregateRel* msg) { - return *msg->common_; -} -const ::substrait::Rel& -AggregateRel::_Internal::input(const AggregateRel* msg) { - return *msg->input_; -} -const ::substrait::extensions::AdvancedExtension& -AggregateRel::_Internal::advanced_extension(const AggregateRel* msg) { - return *msg->advanced_extension_; -} -void AggregateRel::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -AggregateRel::AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - groupings_(arena), - measures_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.AggregateRel) -} -AggregateRel::AggregateRel(const AggregateRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - groupings_(from.groupings_), - measures_(from.measures_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_input()) { - input_ = new ::substrait::Rel(*from.input_); - } else { - input_ = nullptr; - } - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.AggregateRel) -} - -inline void AggregateRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&advanced_extension_) - - reinterpret_cast(&common_)) + sizeof(advanced_extension_)); -} - -AggregateRel::~AggregateRel() { - // @@protoc_insertion_point(destructor:substrait.AggregateRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void AggregateRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete input_; - if (this != internal_default_instance()) delete advanced_extension_; -} - -void AggregateRel::ArenaDtor(void* object) { - AggregateRel* _this = reinterpret_cast< AggregateRel* >(object); - (void)_this; -} -void AggregateRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void AggregateRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void AggregateRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.AggregateRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - groupings_.Clear(); - measures_.Clear(); - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* AggregateRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Rel input = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.AggregateRel.Grouping groupings = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_groupings(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // repeated .substrait.AggregateRel.Measure measures = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_measures(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* AggregateRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.AggregateRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::input(this), target, stream); - } - - // repeated .substrait.AggregateRel.Grouping groupings = 3; - for (unsigned int i = 0, - n = static_cast(this->_internal_groupings_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, this->_internal_groupings(i), target, stream); - } - - // repeated .substrait.AggregateRel.Measure measures = 4; - for (unsigned int i = 0, - n = static_cast(this->_internal_measures_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(4, this->_internal_measures(i), target, stream); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.AggregateRel) - return target; -} - -size_t AggregateRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.AggregateRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.AggregateRel.Grouping groupings = 3; - total_size += 1UL * this->_internal_groupings_size(); - for (const auto& msg : this->groupings_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // repeated .substrait.AggregateRel.Measure measures = 4; - total_size += 1UL * this->_internal_measures_size(); - for (const auto& msg : this->measures_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *input_); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData AggregateRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - AggregateRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*AggregateRel::GetClassData() const { return &_class_data_; } - -void AggregateRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void AggregateRel::MergeFrom(const AggregateRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.AggregateRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - groupings_.MergeFrom(from.groupings_); - measures_.MergeFrom(from.measures_); - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_input()) { - _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); - } - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void AggregateRel::CopyFrom(const AggregateRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.AggregateRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool AggregateRel::IsInitialized() const { - return true; -} - -void AggregateRel::InternalSwap(AggregateRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - groupings_.InternalSwap(&other->groupings_); - measures_.InternalSwap(&other->measures_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(AggregateRel, advanced_extension_) - + sizeof(AggregateRel::advanced_extension_) - - PROTOBUF_FIELD_OFFSET(AggregateRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata AggregateRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[17]); -} - -// =================================================================== - -class SortRel::_Internal { - public: - static const ::substrait::RelCommon& common(const SortRel* msg); - static const ::substrait::Rel& input(const SortRel* msg); - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const SortRel* msg); -}; - -const ::substrait::RelCommon& -SortRel::_Internal::common(const SortRel* msg) { - return *msg->common_; -} -const ::substrait::Rel& -SortRel::_Internal::input(const SortRel* msg) { - return *msg->input_; -} -const ::substrait::extensions::AdvancedExtension& -SortRel::_Internal::advanced_extension(const SortRel* msg) { - return *msg->advanced_extension_; -} -void SortRel::clear_sorts() { - sorts_.Clear(); -} -void SortRel::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -SortRel::SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - sorts_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.SortRel) -} -SortRel::SortRel(const SortRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - sorts_(from.sorts_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_input()) { - input_ = new ::substrait::Rel(*from.input_); - } else { - input_ = nullptr; - } - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.SortRel) -} - -inline void SortRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&advanced_extension_) - - reinterpret_cast(&common_)) + sizeof(advanced_extension_)); -} - -SortRel::~SortRel() { - // @@protoc_insertion_point(destructor:substrait.SortRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void SortRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete input_; - if (this != internal_default_instance()) delete advanced_extension_; -} - -void SortRel::ArenaDtor(void* object) { - SortRel* _this = reinterpret_cast< SortRel* >(object); - (void)_this; -} -void SortRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SortRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SortRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.SortRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - sorts_.Clear(); - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SortRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Rel input = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.SortField sorts = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_sorts(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SortRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.SortRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::input(this), target, stream); - } - - // repeated .substrait.SortField sorts = 3; - for (unsigned int i = 0, - n = static_cast(this->_internal_sorts_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(3, this->_internal_sorts(i), target, stream); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.SortRel) - return target; -} - -size_t SortRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.SortRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.SortField sorts = 3; - total_size += 1UL * this->_internal_sorts_size(); - for (const auto& msg : this->sorts_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *input_); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SortRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - SortRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SortRel::GetClassData() const { return &_class_data_; } - -void SortRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void SortRel::MergeFrom(const SortRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.SortRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - sorts_.MergeFrom(from.sorts_); - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_input()) { - _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); - } - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SortRel::CopyFrom(const SortRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.SortRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SortRel::IsInitialized() const { - return true; -} - -void SortRel::InternalSwap(SortRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - sorts_.InternalSwap(&other->sorts_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SortRel, advanced_extension_) - + sizeof(SortRel::advanced_extension_) - - PROTOBUF_FIELD_OFFSET(SortRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SortRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[18]); -} - -// =================================================================== - -class FilterRel::_Internal { - public: - static const ::substrait::RelCommon& common(const FilterRel* msg); - static const ::substrait::Rel& input(const FilterRel* msg); - static const ::substrait::Expression& condition(const FilterRel* msg); - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const FilterRel* msg); -}; - -const ::substrait::RelCommon& -FilterRel::_Internal::common(const FilterRel* msg) { - return *msg->common_; -} -const ::substrait::Rel& -FilterRel::_Internal::input(const FilterRel* msg) { - return *msg->input_; -} -const ::substrait::Expression& -FilterRel::_Internal::condition(const FilterRel* msg) { - return *msg->condition_; -} -const ::substrait::extensions::AdvancedExtension& -FilterRel::_Internal::advanced_extension(const FilterRel* msg) { - return *msg->advanced_extension_; -} -void FilterRel::clear_condition() { - if (GetArenaForAllocation() == nullptr && condition_ != nullptr) { - delete condition_; - } - condition_ = nullptr; -} -void FilterRel::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -FilterRel::FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.FilterRel) -} -FilterRel::FilterRel(const FilterRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_input()) { - input_ = new ::substrait::Rel(*from.input_); - } else { - input_ = nullptr; - } - if (from._internal_has_condition()) { - condition_ = new ::substrait::Expression(*from.condition_); - } else { - condition_ = nullptr; - } - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.FilterRel) -} - -inline void FilterRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&advanced_extension_) - - reinterpret_cast(&common_)) + sizeof(advanced_extension_)); -} - -FilterRel::~FilterRel() { - // @@protoc_insertion_point(destructor:substrait.FilterRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void FilterRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete input_; - if (this != internal_default_instance()) delete condition_; - if (this != internal_default_instance()) delete advanced_extension_; -} - -void FilterRel::ArenaDtor(void* object) { - FilterRel* _this = reinterpret_cast< FilterRel* >(object); - (void)_this; -} -void FilterRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void FilterRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void FilterRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.FilterRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; - if (GetArenaForAllocation() == nullptr && condition_ != nullptr) { - delete condition_; - } - condition_ = nullptr; - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* FilterRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Rel input = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Expression condition = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_condition(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* FilterRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.FilterRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::input(this), target, stream); - } - - // .substrait.Expression condition = 3; - if (this->_internal_has_condition()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::condition(this), target, stream); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.FilterRel) - return target; -} - -size_t FilterRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.FilterRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *input_); - } - - // .substrait.Expression condition = 3; - if (this->_internal_has_condition()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *condition_); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FilterRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - FilterRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FilterRel::GetClassData() const { return &_class_data_; } - -void FilterRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void FilterRel::MergeFrom(const FilterRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.FilterRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_input()) { - _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); - } - if (from._internal_has_condition()) { - _internal_mutable_condition()->::substrait::Expression::MergeFrom(from._internal_condition()); - } - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void FilterRel::CopyFrom(const FilterRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.FilterRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool FilterRel::IsInitialized() const { - return true; -} - -void FilterRel::InternalSwap(FilterRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(FilterRel, advanced_extension_) - + sizeof(FilterRel::advanced_extension_) - - PROTOBUF_FIELD_OFFSET(FilterRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata FilterRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[19]); -} - -// =================================================================== - -class SetRel::_Internal { - public: - static const ::substrait::RelCommon& common(const SetRel* msg); - static const ::substrait::extensions::AdvancedExtension& advanced_extension(const SetRel* msg); -}; - -const ::substrait::RelCommon& -SetRel::_Internal::common(const SetRel* msg) { - return *msg->common_; -} -const ::substrait::extensions::AdvancedExtension& -SetRel::_Internal::advanced_extension(const SetRel* msg) { - return *msg->advanced_extension_; -} -void SetRel::clear_advanced_extension() { - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; -} -SetRel::SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - inputs_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.SetRel) -} -SetRel::SetRel(const SetRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - inputs_(from.inputs_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_advanced_extension()) { - advanced_extension_ = new ::substrait::extensions::AdvancedExtension(*from.advanced_extension_); - } else { - advanced_extension_ = nullptr; - } - op_ = from.op_; - // @@protoc_insertion_point(copy_constructor:substrait.SetRel) -} - -inline void SetRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&op_) - - reinterpret_cast(&common_)) + sizeof(op_)); -} - -SetRel::~SetRel() { - // @@protoc_insertion_point(destructor:substrait.SetRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void SetRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete advanced_extension_; -} - -void SetRel::ArenaDtor(void* object) { - SetRel* _this = reinterpret_cast< SetRel* >(object); - (void)_this; -} -void SetRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void SetRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void SetRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.SetRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - inputs_.Clear(); - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && advanced_extension_ != nullptr) { - delete advanced_extension_; - } - advanced_extension_ = nullptr; - op_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* SetRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.Rel inputs = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_inputs(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.SetRel.SetOp op = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_op(static_cast<::substrait::SetRel_SetOp>(val)); - } else - goto handle_unusual; - continue; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_advanced_extension(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* SetRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.SetRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // repeated .substrait.Rel inputs = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_inputs_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_inputs(i), target, stream); - } - - // .substrait.SetRel.SetOp op = 3; - if (this->_internal_op() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_op(), target); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::advanced_extension(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.SetRel) - return target; -} - -size_t SetRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.SetRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Rel inputs = 2; - total_size += 1UL * this->_internal_inputs_size(); - for (const auto& msg : this->inputs_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - if (this->_internal_has_advanced_extension()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *advanced_extension_); - } - - // .substrait.SetRel.SetOp op = 3; - if (this->_internal_op() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData SetRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - SetRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*SetRel::GetClassData() const { return &_class_data_; } - -void SetRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void SetRel::MergeFrom(const SetRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.SetRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - inputs_.MergeFrom(from.inputs_); - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_advanced_extension()) { - _internal_mutable_advanced_extension()->::substrait::extensions::AdvancedExtension::MergeFrom(from._internal_advanced_extension()); - } - if (from._internal_op() != 0) { - _internal_set_op(from._internal_op()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void SetRel::CopyFrom(const SetRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.SetRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SetRel::IsInitialized() const { - return true; -} - -void SetRel::InternalSwap(SetRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - inputs_.InternalSwap(&other->inputs_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(SetRel, op_) - + sizeof(SetRel::op_) - - PROTOBUF_FIELD_OFFSET(SetRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata SetRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[20]); -} - -// =================================================================== - -class ExtensionSingleRel::_Internal { - public: - static const ::substrait::RelCommon& common(const ExtensionSingleRel* msg); - static const ::substrait::Rel& input(const ExtensionSingleRel* msg); - static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionSingleRel* msg); -}; - -const ::substrait::RelCommon& -ExtensionSingleRel::_Internal::common(const ExtensionSingleRel* msg) { - return *msg->common_; -} -const ::substrait::Rel& -ExtensionSingleRel::_Internal::input(const ExtensionSingleRel* msg) { - return *msg->input_; -} -const ::PROTOBUF_NAMESPACE_ID::Any& -ExtensionSingleRel::_Internal::detail(const ExtensionSingleRel* msg) { - return *msg->detail_; -} -void ExtensionSingleRel::clear_detail() { - if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { - delete detail_; - } - detail_ = nullptr; -} -ExtensionSingleRel::ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ExtensionSingleRel) -} -ExtensionSingleRel::ExtensionSingleRel(const ExtensionSingleRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_input()) { - input_ = new ::substrait::Rel(*from.input_); - } else { - input_ = nullptr; - } - if (from._internal_has_detail()) { - detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_); - } else { - detail_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.ExtensionSingleRel) -} - -inline void ExtensionSingleRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&detail_) - - reinterpret_cast(&common_)) + sizeof(detail_)); -} - -ExtensionSingleRel::~ExtensionSingleRel() { - // @@protoc_insertion_point(destructor:substrait.ExtensionSingleRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ExtensionSingleRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete input_; - if (this != internal_default_instance()) delete detail_; -} - -void ExtensionSingleRel::ArenaDtor(void* object) { - ExtensionSingleRel* _this = reinterpret_cast< ExtensionSingleRel* >(object); - (void)_this; -} -void ExtensionSingleRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ExtensionSingleRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ExtensionSingleRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ExtensionSingleRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; - if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { - delete detail_; - } - detail_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ExtensionSingleRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Rel input = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .google.protobuf.Any detail = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ExtensionSingleRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionSingleRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::input(this), target, stream); - } - - // .google.protobuf.Any detail = 3; - if (this->_internal_has_detail()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::detail(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ExtensionSingleRel) - return target; -} - -size_t ExtensionSingleRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionSingleRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .substrait.Rel input = 2; - if (this->_internal_has_input()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *input_); - } - - // .google.protobuf.Any detail = 3; - if (this->_internal_has_detail()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *detail_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExtensionSingleRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ExtensionSingleRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExtensionSingleRel::GetClassData() const { return &_class_data_; } - -void ExtensionSingleRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ExtensionSingleRel::MergeFrom(const ExtensionSingleRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionSingleRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_input()) { - _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); - } - if (from._internal_has_detail()) { - _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ExtensionSingleRel::CopyFrom(const ExtensionSingleRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ExtensionSingleRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ExtensionSingleRel::IsInitialized() const { - return true; -} - -void ExtensionSingleRel::InternalSwap(ExtensionSingleRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ExtensionSingleRel, detail_) - + sizeof(ExtensionSingleRel::detail_) - - PROTOBUF_FIELD_OFFSET(ExtensionSingleRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ExtensionSingleRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[21]); -} - -// =================================================================== - -class ExtensionLeafRel::_Internal { - public: - static const ::substrait::RelCommon& common(const ExtensionLeafRel* msg); - static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionLeafRel* msg); -}; - -const ::substrait::RelCommon& -ExtensionLeafRel::_Internal::common(const ExtensionLeafRel* msg) { - return *msg->common_; -} -const ::PROTOBUF_NAMESPACE_ID::Any& -ExtensionLeafRel::_Internal::detail(const ExtensionLeafRel* msg) { - return *msg->detail_; -} -void ExtensionLeafRel::clear_detail() { - if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { - delete detail_; - } - detail_ = nullptr; -} -ExtensionLeafRel::ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ExtensionLeafRel) -} -ExtensionLeafRel::ExtensionLeafRel(const ExtensionLeafRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_detail()) { - detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_); - } else { - detail_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.ExtensionLeafRel) -} - -inline void ExtensionLeafRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&detail_) - - reinterpret_cast(&common_)) + sizeof(detail_)); -} - -ExtensionLeafRel::~ExtensionLeafRel() { - // @@protoc_insertion_point(destructor:substrait.ExtensionLeafRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ExtensionLeafRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete detail_; -} - -void ExtensionLeafRel::ArenaDtor(void* object) { - ExtensionLeafRel* _this = reinterpret_cast< ExtensionLeafRel* >(object); - (void)_this; -} -void ExtensionLeafRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ExtensionLeafRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ExtensionLeafRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ExtensionLeafRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { - delete detail_; - } - detail_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ExtensionLeafRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .google.protobuf.Any detail = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ExtensionLeafRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionLeafRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // .google.protobuf.Any detail = 2; - if (this->_internal_has_detail()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::detail(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ExtensionLeafRel) - return target; -} - -size_t ExtensionLeafRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionLeafRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .google.protobuf.Any detail = 2; - if (this->_internal_has_detail()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *detail_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExtensionLeafRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ExtensionLeafRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExtensionLeafRel::GetClassData() const { return &_class_data_; } - -void ExtensionLeafRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ExtensionLeafRel::MergeFrom(const ExtensionLeafRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionLeafRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_detail()) { - _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ExtensionLeafRel::CopyFrom(const ExtensionLeafRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ExtensionLeafRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ExtensionLeafRel::IsInitialized() const { - return true; -} - -void ExtensionLeafRel::InternalSwap(ExtensionLeafRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ExtensionLeafRel, detail_) - + sizeof(ExtensionLeafRel::detail_) - - PROTOBUF_FIELD_OFFSET(ExtensionLeafRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ExtensionLeafRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[22]); -} - -// =================================================================== - -class ExtensionMultiRel::_Internal { - public: - static const ::substrait::RelCommon& common(const ExtensionMultiRel* msg); - static const ::PROTOBUF_NAMESPACE_ID::Any& detail(const ExtensionMultiRel* msg); -}; - -const ::substrait::RelCommon& -ExtensionMultiRel::_Internal::common(const ExtensionMultiRel* msg) { - return *msg->common_; -} -const ::PROTOBUF_NAMESPACE_ID::Any& -ExtensionMultiRel::_Internal::detail(const ExtensionMultiRel* msg) { - return *msg->detail_; -} -void ExtensionMultiRel::clear_detail() { - if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { - delete detail_; - } - detail_ = nullptr; -} -ExtensionMultiRel::ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - inputs_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.ExtensionMultiRel) -} -ExtensionMultiRel::ExtensionMultiRel(const ExtensionMultiRel& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - inputs_(from.inputs_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_common()) { - common_ = new ::substrait::RelCommon(*from.common_); - } else { - common_ = nullptr; - } - if (from._internal_has_detail()) { - detail_ = new ::PROTOBUF_NAMESPACE_ID::Any(*from.detail_); - } else { - detail_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.ExtensionMultiRel) -} - -inline void ExtensionMultiRel::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&common_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&detail_) - - reinterpret_cast(&common_)) + sizeof(detail_)); -} - -ExtensionMultiRel::~ExtensionMultiRel() { - // @@protoc_insertion_point(destructor:substrait.ExtensionMultiRel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void ExtensionMultiRel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete common_; - if (this != internal_default_instance()) delete detail_; -} - -void ExtensionMultiRel::ArenaDtor(void* object) { - ExtensionMultiRel* _this = reinterpret_cast< ExtensionMultiRel* >(object); - (void)_this; -} -void ExtensionMultiRel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void ExtensionMultiRel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void ExtensionMultiRel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.ExtensionMultiRel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - inputs_.Clear(); - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; - if (GetArenaForAllocation() == nullptr && detail_ != nullptr) { - delete detail_; - } - detail_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* ExtensionMultiRel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.RelCommon common = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_common(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated .substrait.Rel inputs = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_inputs(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr)); - } else - goto handle_unusual; - continue; - // .google.protobuf.Any detail = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_detail(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* ExtensionMultiRel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.ExtensionMultiRel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::common(this), target, stream); - } - - // repeated .substrait.Rel inputs = 2; - for (unsigned int i = 0, - n = static_cast(this->_internal_inputs_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(2, this->_internal_inputs(i), target, stream); - } - - // .google.protobuf.Any detail = 3; - if (this->_internal_has_detail()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::detail(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.ExtensionMultiRel) - return target; -} - -size_t ExtensionMultiRel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.ExtensionMultiRel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Rel inputs = 2; - total_size += 1UL * this->_internal_inputs_size(); - for (const auto& msg : this->inputs_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.RelCommon common = 1; - if (this->_internal_has_common()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *common_); - } - - // .google.protobuf.Any detail = 3; - if (this->_internal_has_detail()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *detail_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ExtensionMultiRel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - ExtensionMultiRel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ExtensionMultiRel::GetClassData() const { return &_class_data_; } - -void ExtensionMultiRel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void ExtensionMultiRel::MergeFrom(const ExtensionMultiRel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.ExtensionMultiRel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - inputs_.MergeFrom(from.inputs_); - if (from._internal_has_common()) { - _internal_mutable_common()->::substrait::RelCommon::MergeFrom(from._internal_common()); - } - if (from._internal_has_detail()) { - _internal_mutable_detail()->::PROTOBUF_NAMESPACE_ID::Any::MergeFrom(from._internal_detail()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void ExtensionMultiRel::CopyFrom(const ExtensionMultiRel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.ExtensionMultiRel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ExtensionMultiRel::IsInitialized() const { - return true; -} - -void ExtensionMultiRel::InternalSwap(ExtensionMultiRel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - inputs_.InternalSwap(&other->inputs_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(ExtensionMultiRel, detail_) - + sizeof(ExtensionMultiRel::detail_) - - PROTOBUF_FIELD_OFFSET(ExtensionMultiRel, common_)>( - reinterpret_cast(&common_), - reinterpret_cast(&other->common_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata ExtensionMultiRel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[23]); -} - -// =================================================================== - -class RelRoot::_Internal { - public: - static const ::substrait::Rel& input(const RelRoot* msg); -}; - -const ::substrait::Rel& -RelRoot::_Internal::input(const RelRoot* msg) { - return *msg->input_; -} -RelRoot::RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - names_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.RelRoot) -} -RelRoot::RelRoot(const RelRoot& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - names_(from.names_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_input()) { - input_ = new ::substrait::Rel(*from.input_); - } else { - input_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.RelRoot) -} - -inline void RelRoot::SharedCtor() { -input_ = nullptr; -} - -RelRoot::~RelRoot() { - // @@protoc_insertion_point(destructor:substrait.RelRoot) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void RelRoot::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete input_; -} - -void RelRoot::ArenaDtor(void* object) { - RelRoot* _this = reinterpret_cast< RelRoot* >(object); - (void)_this; -} -void RelRoot::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void RelRoot::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void RelRoot::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.RelRoot) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - names_.Clear(); - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* RelRoot::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Rel input = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_input(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // repeated string names = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_names(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.RelRoot.names")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(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* RelRoot::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.RelRoot) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Rel input = 1; - if (this->_internal_has_input()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::input(this), target, stream); - } - - // repeated string names = 2; - for (int i = 0, n = this->_internal_names_size(); i < n; i++) { - const auto& s = this->_internal_names(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.RelRoot.names"); - target = stream->WriteString(2, s, target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.RelRoot) - return target; -} - -size_t RelRoot::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.RelRoot) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string names = 2; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); - for (int i = 0, n = names_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - names_.Get(i)); - } - - // .substrait.Rel input = 1; - if (this->_internal_has_input()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *input_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData RelRoot::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - RelRoot::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*RelRoot::GetClassData() const { return &_class_data_; } - -void RelRoot::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void RelRoot::MergeFrom(const RelRoot& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.RelRoot) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - names_.MergeFrom(from.names_); - if (from._internal_has_input()) { - _internal_mutable_input()->::substrait::Rel::MergeFrom(from._internal_input()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void RelRoot::CopyFrom(const RelRoot& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.RelRoot) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool RelRoot::IsInitialized() const { - return true; -} - -void RelRoot::InternalSwap(RelRoot* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - names_.InternalSwap(&other->names_); - swap(input_, other->input_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata RelRoot::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[24]); -} - -// =================================================================== - -class Rel::_Internal { - public: - static const ::substrait::ReadRel& read(const Rel* msg); - static const ::substrait::FilterRel& filter(const Rel* msg); - static const ::substrait::FetchRel& fetch(const Rel* msg); - static const ::substrait::AggregateRel& aggregate(const Rel* msg); - static const ::substrait::SortRel& sort(const Rel* msg); - static const ::substrait::JoinRel& join(const Rel* msg); - static const ::substrait::ProjectRel& project(const Rel* msg); - static const ::substrait::SetRel& set(const Rel* msg); - static const ::substrait::ExtensionSingleRel& extension_single(const Rel* msg); - static const ::substrait::ExtensionMultiRel& extension_multi(const Rel* msg); - static const ::substrait::ExtensionLeafRel& extension_leaf(const Rel* msg); -}; - -const ::substrait::ReadRel& -Rel::_Internal::read(const Rel* msg) { - return *msg->rel_type_.read_; -} -const ::substrait::FilterRel& -Rel::_Internal::filter(const Rel* msg) { - return *msg->rel_type_.filter_; -} -const ::substrait::FetchRel& -Rel::_Internal::fetch(const Rel* msg) { - return *msg->rel_type_.fetch_; -} -const ::substrait::AggregateRel& -Rel::_Internal::aggregate(const Rel* msg) { - return *msg->rel_type_.aggregate_; -} -const ::substrait::SortRel& -Rel::_Internal::sort(const Rel* msg) { - return *msg->rel_type_.sort_; -} -const ::substrait::JoinRel& -Rel::_Internal::join(const Rel* msg) { - return *msg->rel_type_.join_; -} -const ::substrait::ProjectRel& -Rel::_Internal::project(const Rel* msg) { - return *msg->rel_type_.project_; -} -const ::substrait::SetRel& -Rel::_Internal::set(const Rel* msg) { - return *msg->rel_type_.set_; -} -const ::substrait::ExtensionSingleRel& -Rel::_Internal::extension_single(const Rel* msg) { - return *msg->rel_type_.extension_single_; -} -const ::substrait::ExtensionMultiRel& -Rel::_Internal::extension_multi(const Rel* msg) { - return *msg->rel_type_.extension_multi_; -} -const ::substrait::ExtensionLeafRel& -Rel::_Internal::extension_leaf(const Rel* msg) { - return *msg->rel_type_.extension_leaf_; -} -void Rel::set_allocated_read(::substrait::ReadRel* read) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (read) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ReadRel>::GetOwningArena(read); - if (message_arena != submessage_arena) { - read = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, read, submessage_arena); - } - set_has_read(); - rel_type_.read_ = read; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.read) -} -void Rel::set_allocated_filter(::substrait::FilterRel* filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FilterRel>::GetOwningArena(filter); - if (message_arena != submessage_arena) { - filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, filter, submessage_arena); - } - set_has_filter(); - rel_type_.filter_ = filter; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.filter) -} -void Rel::set_allocated_fetch(::substrait::FetchRel* fetch) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (fetch) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::FetchRel>::GetOwningArena(fetch); - if (message_arena != submessage_arena) { - fetch = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fetch, submessage_arena); - } - set_has_fetch(); - rel_type_.fetch_ = fetch; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.fetch) -} -void Rel::set_allocated_aggregate(::substrait::AggregateRel* aggregate) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (aggregate) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::AggregateRel>::GetOwningArena(aggregate); - if (message_arena != submessage_arena) { - aggregate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, aggregate, submessage_arena); - } - set_has_aggregate(); - rel_type_.aggregate_ = aggregate; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.aggregate) -} -void Rel::set_allocated_sort(::substrait::SortRel* sort) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (sort) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::SortRel>::GetOwningArena(sort); - if (message_arena != submessage_arena) { - sort = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, sort, submessage_arena); - } - set_has_sort(); - rel_type_.sort_ = sort; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.sort) -} -void Rel::set_allocated_join(::substrait::JoinRel* join) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (join) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::JoinRel>::GetOwningArena(join); - if (message_arena != submessage_arena) { - join = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, join, submessage_arena); - } - set_has_join(); - rel_type_.join_ = join; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.join) -} -void Rel::set_allocated_project(::substrait::ProjectRel* project) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (project) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ProjectRel>::GetOwningArena(project); - if (message_arena != submessage_arena) { - project = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, project, submessage_arena); - } - set_has_project(); - rel_type_.project_ = project; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.project) -} -void Rel::set_allocated_set(::substrait::SetRel* set) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (set) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::SetRel>::GetOwningArena(set); - if (message_arena != submessage_arena) { - set = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, set, submessage_arena); - } - set_has_set(); - rel_type_.set_ = set; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.set) -} -void Rel::set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (extension_single) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionSingleRel>::GetOwningArena(extension_single); - if (message_arena != submessage_arena) { - extension_single = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_single, submessage_arena); - } - set_has_extension_single(); - rel_type_.extension_single_ = extension_single; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_single) -} -void Rel::set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (extension_multi) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionMultiRel>::GetOwningArena(extension_multi); - if (message_arena != submessage_arena) { - extension_multi = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_multi, submessage_arena); - } - set_has_extension_multi(); - rel_type_.extension_multi_ = extension_multi; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_multi) -} -void Rel::set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_rel_type(); - if (extension_leaf) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::ExtensionLeafRel>::GetOwningArena(extension_leaf); - if (message_arena != submessage_arena) { - extension_leaf = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, extension_leaf, submessage_arena); - } - set_has_extension_leaf(); - rel_type_.extension_leaf_ = extension_leaf; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Rel.extension_leaf) -} -Rel::Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Rel) -} -Rel::Rel(const Rel& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_rel_type(); - switch (from.rel_type_case()) { - case kRead: { - _internal_mutable_read()->::substrait::ReadRel::MergeFrom(from._internal_read()); - break; - } - case kFilter: { - _internal_mutable_filter()->::substrait::FilterRel::MergeFrom(from._internal_filter()); - break; - } - case kFetch: { - _internal_mutable_fetch()->::substrait::FetchRel::MergeFrom(from._internal_fetch()); - break; - } - case kAggregate: { - _internal_mutable_aggregate()->::substrait::AggregateRel::MergeFrom(from._internal_aggregate()); - break; - } - case kSort: { - _internal_mutable_sort()->::substrait::SortRel::MergeFrom(from._internal_sort()); - break; - } - case kJoin: { - _internal_mutable_join()->::substrait::JoinRel::MergeFrom(from._internal_join()); - break; - } - case kProject: { - _internal_mutable_project()->::substrait::ProjectRel::MergeFrom(from._internal_project()); - break; - } - case kSet: { - _internal_mutable_set()->::substrait::SetRel::MergeFrom(from._internal_set()); - break; - } - case kExtensionSingle: { - _internal_mutable_extension_single()->::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single()); - break; - } - case kExtensionMulti: { - _internal_mutable_extension_multi()->::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi()); - break; - } - case kExtensionLeaf: { - _internal_mutable_extension_leaf()->::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf()); - break; - } - case REL_TYPE_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Rel) -} - -inline void Rel::SharedCtor() { -clear_has_rel_type(); -} - -Rel::~Rel() { - // @@protoc_insertion_point(destructor:substrait.Rel) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Rel::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_rel_type()) { - clear_rel_type(); - } -} - -void Rel::ArenaDtor(void* object) { - Rel* _this = reinterpret_cast< Rel* >(object); - (void)_this; -} -void Rel::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Rel::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Rel::clear_rel_type() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Rel) - switch (rel_type_case()) { - case kRead: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.read_; - } - break; - } - case kFilter: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.filter_; - } - break; - } - case kFetch: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.fetch_; - } - break; - } - case kAggregate: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.aggregate_; - } - break; - } - case kSort: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.sort_; - } - break; - } - case kJoin: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.join_; - } - break; - } - case kProject: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.project_; - } - break; - } - case kSet: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.set_; - } - break; - } - case kExtensionSingle: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.extension_single_; - } - break; - } - case kExtensionMulti: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.extension_multi_; - } - break; - } - case kExtensionLeaf: { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.extension_leaf_; - } - break; - } - case REL_TYPE_NOT_SET: { - break; - } - } - _oneof_case_[0] = REL_TYPE_NOT_SET; -} - - -void Rel::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Rel) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_rel_type(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Rel::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.ReadRel read = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_read(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FilterRel filter = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_filter(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.FetchRel fetch = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_fetch(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.AggregateRel aggregate = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_aggregate(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.SortRel sort = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_sort(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.JoinRel join = 6; - case 6: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_join(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ProjectRel project = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_project(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.SetRel set = 8; - case 8: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 66)) { - ptr = ctx->ParseMessage(_internal_mutable_set(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ExtensionSingleRel extension_single = 9; - case 9: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 74)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_single(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ExtensionMultiRel extension_multi = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_multi(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.ExtensionLeafRel extension_leaf = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_extension_leaf(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Rel::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Rel) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.ReadRel read = 1; - if (_internal_has_read()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::read(this), target, stream); - } - - // .substrait.FilterRel filter = 2; - if (_internal_has_filter()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::filter(this), target, stream); - } - - // .substrait.FetchRel fetch = 3; - if (_internal_has_fetch()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::fetch(this), target, stream); - } - - // .substrait.AggregateRel aggregate = 4; - if (_internal_has_aggregate()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 4, _Internal::aggregate(this), target, stream); - } - - // .substrait.SortRel sort = 5; - if (_internal_has_sort()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::sort(this), target, stream); - } - - // .substrait.JoinRel join = 6; - if (_internal_has_join()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 6, _Internal::join(this), target, stream); - } - - // .substrait.ProjectRel project = 7; - if (_internal_has_project()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 7, _Internal::project(this), target, stream); - } - - // .substrait.SetRel set = 8; - if (_internal_has_set()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 8, _Internal::set(this), target, stream); - } - - // .substrait.ExtensionSingleRel extension_single = 9; - if (_internal_has_extension_single()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 9, _Internal::extension_single(this), target, stream); - } - - // .substrait.ExtensionMultiRel extension_multi = 10; - if (_internal_has_extension_multi()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::extension_multi(this), target, stream); - } - - // .substrait.ExtensionLeafRel extension_leaf = 11; - if (_internal_has_extension_leaf()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 11, _Internal::extension_leaf(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Rel) - return target; -} - -size_t Rel::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Rel) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (rel_type_case()) { - // .substrait.ReadRel read = 1; - case kRead: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.read_); - break; - } - // .substrait.FilterRel filter = 2; - case kFilter: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.filter_); - break; - } - // .substrait.FetchRel fetch = 3; - case kFetch: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.fetch_); - break; - } - // .substrait.AggregateRel aggregate = 4; - case kAggregate: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.aggregate_); - break; - } - // .substrait.SortRel sort = 5; - case kSort: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.sort_); - break; - } - // .substrait.JoinRel join = 6; - case kJoin: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.join_); - break; - } - // .substrait.ProjectRel project = 7; - case kProject: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.project_); - break; - } - // .substrait.SetRel set = 8; - case kSet: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.set_); - break; - } - // .substrait.ExtensionSingleRel extension_single = 9; - case kExtensionSingle: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.extension_single_); - break; - } - // .substrait.ExtensionMultiRel extension_multi = 10; - case kExtensionMulti: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.extension_multi_); - break; - } - // .substrait.ExtensionLeafRel extension_leaf = 11; - case kExtensionLeaf: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *rel_type_.extension_leaf_); - break; - } - case REL_TYPE_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Rel::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Rel::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Rel::GetClassData() const { return &_class_data_; } - -void Rel::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Rel::MergeFrom(const Rel& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Rel) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.rel_type_case()) { - case kRead: { - _internal_mutable_read()->::substrait::ReadRel::MergeFrom(from._internal_read()); - break; - } - case kFilter: { - _internal_mutable_filter()->::substrait::FilterRel::MergeFrom(from._internal_filter()); - break; - } - case kFetch: { - _internal_mutable_fetch()->::substrait::FetchRel::MergeFrom(from._internal_fetch()); - break; - } - case kAggregate: { - _internal_mutable_aggregate()->::substrait::AggregateRel::MergeFrom(from._internal_aggregate()); - break; - } - case kSort: { - _internal_mutable_sort()->::substrait::SortRel::MergeFrom(from._internal_sort()); - break; - } - case kJoin: { - _internal_mutable_join()->::substrait::JoinRel::MergeFrom(from._internal_join()); - break; - } - case kProject: { - _internal_mutable_project()->::substrait::ProjectRel::MergeFrom(from._internal_project()); - break; - } - case kSet: { - _internal_mutable_set()->::substrait::SetRel::MergeFrom(from._internal_set()); - break; - } - case kExtensionSingle: { - _internal_mutable_extension_single()->::substrait::ExtensionSingleRel::MergeFrom(from._internal_extension_single()); - break; - } - case kExtensionMulti: { - _internal_mutable_extension_multi()->::substrait::ExtensionMultiRel::MergeFrom(from._internal_extension_multi()); - break; - } - case kExtensionLeaf: { - _internal_mutable_extension_leaf()->::substrait::ExtensionLeafRel::MergeFrom(from._internal_extension_leaf()); - break; - } - case REL_TYPE_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Rel::CopyFrom(const Rel& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Rel) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Rel::IsInitialized() const { - return true; -} - -void Rel::InternalSwap(Rel* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(rel_type_, other->rel_type_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Rel::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2frelations_2eproto_getter, &descriptor_table_substrait_2frelations_2eproto_once, - file_level_metadata_substrait_2frelations_2eproto[25]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Direct* Arena::CreateMaybeMessage< ::substrait::RelCommon_Direct >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::RelCommon_Direct >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Emit* Arena::CreateMaybeMessage< ::substrait::RelCommon_Emit >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::RelCommon_Emit >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint_Stats >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint_Stats >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint_RuntimeConstraint >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint_RuntimeConstraint >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::RelCommon_Hint* Arena::CreateMaybeMessage< ::substrait::RelCommon_Hint >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::RelCommon_Hint >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::RelCommon* Arena::CreateMaybeMessage< ::substrait::RelCommon >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::RelCommon >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_NamedTable >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ReadRel_NamedTable >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_VirtualTable >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ReadRel_VirtualTable >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage< ::substrait::ReadRel_ExtensionTable >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ReadRel_ExtensionTable >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage< ::substrait::ReadRel_LocalFiles_FileOrFiles >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ReadRel_LocalFiles_FileOrFiles >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage< ::substrait::ReadRel_LocalFiles >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ReadRel_LocalFiles >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ReadRel* Arena::CreateMaybeMessage< ::substrait::ReadRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ReadRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ProjectRel* Arena::CreateMaybeMessage< ::substrait::ProjectRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ProjectRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::JoinRel* Arena::CreateMaybeMessage< ::substrait::JoinRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::JoinRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FetchRel* Arena::CreateMaybeMessage< ::substrait::FetchRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FetchRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage< ::substrait::AggregateRel_Grouping >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::AggregateRel_Grouping >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage< ::substrait::AggregateRel_Measure >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::AggregateRel_Measure >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::AggregateRel* Arena::CreateMaybeMessage< ::substrait::AggregateRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::AggregateRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::SortRel* Arena::CreateMaybeMessage< ::substrait::SortRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::SortRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::FilterRel* Arena::CreateMaybeMessage< ::substrait::FilterRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::FilterRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::SetRel* Arena::CreateMaybeMessage< ::substrait::SetRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::SetRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage< ::substrait::ExtensionSingleRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ExtensionSingleRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage< ::substrait::ExtensionLeafRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ExtensionLeafRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage< ::substrait::ExtensionMultiRel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::ExtensionMultiRel >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::RelRoot* Arena::CreateMaybeMessage< ::substrait::RelRoot >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::RelRoot >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Rel* Arena::CreateMaybeMessage< ::substrait::Rel >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Rel >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/relations.pb.h b/cpp/src/generated/substrait/relations.pb.h deleted file mode 100644 index 11f499cb1ab..00000000000 --- a/cpp/src/generated/substrait/relations.pb.h +++ /dev/null @@ -1,12611 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/relations.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2frelations_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_substrait_2frelations_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3019000 -#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 3019003 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include -#include "substrait/type.pb.h" -#include "substrait/expression.pb.h" -#include "substrait/extensions/extensions.pb.h" -#include -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_substrait_2frelations_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_substrait_2frelations_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[26] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const uint32_t offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2frelations_2eproto; -namespace substrait { -class AggregateRel; -struct AggregateRelDefaultTypeInternal; -extern AggregateRelDefaultTypeInternal _AggregateRel_default_instance_; -class AggregateRel_Grouping; -struct AggregateRel_GroupingDefaultTypeInternal; -extern AggregateRel_GroupingDefaultTypeInternal _AggregateRel_Grouping_default_instance_; -class AggregateRel_Measure; -struct AggregateRel_MeasureDefaultTypeInternal; -extern AggregateRel_MeasureDefaultTypeInternal _AggregateRel_Measure_default_instance_; -class ExtensionLeafRel; -struct ExtensionLeafRelDefaultTypeInternal; -extern ExtensionLeafRelDefaultTypeInternal _ExtensionLeafRel_default_instance_; -class ExtensionMultiRel; -struct ExtensionMultiRelDefaultTypeInternal; -extern ExtensionMultiRelDefaultTypeInternal _ExtensionMultiRel_default_instance_; -class ExtensionSingleRel; -struct ExtensionSingleRelDefaultTypeInternal; -extern ExtensionSingleRelDefaultTypeInternal _ExtensionSingleRel_default_instance_; -class FetchRel; -struct FetchRelDefaultTypeInternal; -extern FetchRelDefaultTypeInternal _FetchRel_default_instance_; -class FilterRel; -struct FilterRelDefaultTypeInternal; -extern FilterRelDefaultTypeInternal _FilterRel_default_instance_; -class JoinRel; -struct JoinRelDefaultTypeInternal; -extern JoinRelDefaultTypeInternal _JoinRel_default_instance_; -class ProjectRel; -struct ProjectRelDefaultTypeInternal; -extern ProjectRelDefaultTypeInternal _ProjectRel_default_instance_; -class ReadRel; -struct ReadRelDefaultTypeInternal; -extern ReadRelDefaultTypeInternal _ReadRel_default_instance_; -class ReadRel_ExtensionTable; -struct ReadRel_ExtensionTableDefaultTypeInternal; -extern ReadRel_ExtensionTableDefaultTypeInternal _ReadRel_ExtensionTable_default_instance_; -class ReadRel_LocalFiles; -struct ReadRel_LocalFilesDefaultTypeInternal; -extern ReadRel_LocalFilesDefaultTypeInternal _ReadRel_LocalFiles_default_instance_; -class ReadRel_LocalFiles_FileOrFiles; -struct ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal; -extern ReadRel_LocalFiles_FileOrFilesDefaultTypeInternal _ReadRel_LocalFiles_FileOrFiles_default_instance_; -class ReadRel_NamedTable; -struct ReadRel_NamedTableDefaultTypeInternal; -extern ReadRel_NamedTableDefaultTypeInternal _ReadRel_NamedTable_default_instance_; -class ReadRel_VirtualTable; -struct ReadRel_VirtualTableDefaultTypeInternal; -extern ReadRel_VirtualTableDefaultTypeInternal _ReadRel_VirtualTable_default_instance_; -class Rel; -struct RelDefaultTypeInternal; -extern RelDefaultTypeInternal _Rel_default_instance_; -class RelCommon; -struct RelCommonDefaultTypeInternal; -extern RelCommonDefaultTypeInternal _RelCommon_default_instance_; -class RelCommon_Direct; -struct RelCommon_DirectDefaultTypeInternal; -extern RelCommon_DirectDefaultTypeInternal _RelCommon_Direct_default_instance_; -class RelCommon_Emit; -struct RelCommon_EmitDefaultTypeInternal; -extern RelCommon_EmitDefaultTypeInternal _RelCommon_Emit_default_instance_; -class RelCommon_Hint; -struct RelCommon_HintDefaultTypeInternal; -extern RelCommon_HintDefaultTypeInternal _RelCommon_Hint_default_instance_; -class RelCommon_Hint_RuntimeConstraint; -struct RelCommon_Hint_RuntimeConstraintDefaultTypeInternal; -extern RelCommon_Hint_RuntimeConstraintDefaultTypeInternal _RelCommon_Hint_RuntimeConstraint_default_instance_; -class RelCommon_Hint_Stats; -struct RelCommon_Hint_StatsDefaultTypeInternal; -extern RelCommon_Hint_StatsDefaultTypeInternal _RelCommon_Hint_Stats_default_instance_; -class RelRoot; -struct RelRootDefaultTypeInternal; -extern RelRootDefaultTypeInternal _RelRoot_default_instance_; -class SetRel; -struct SetRelDefaultTypeInternal; -extern SetRelDefaultTypeInternal _SetRel_default_instance_; -class SortRel; -struct SortRelDefaultTypeInternal; -extern SortRelDefaultTypeInternal _SortRel_default_instance_; -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> ::substrait::AggregateRel* Arena::CreateMaybeMessage<::substrait::AggregateRel>(Arena*); -template<> ::substrait::AggregateRel_Grouping* Arena::CreateMaybeMessage<::substrait::AggregateRel_Grouping>(Arena*); -template<> ::substrait::AggregateRel_Measure* Arena::CreateMaybeMessage<::substrait::AggregateRel_Measure>(Arena*); -template<> ::substrait::ExtensionLeafRel* Arena::CreateMaybeMessage<::substrait::ExtensionLeafRel>(Arena*); -template<> ::substrait::ExtensionMultiRel* Arena::CreateMaybeMessage<::substrait::ExtensionMultiRel>(Arena*); -template<> ::substrait::ExtensionSingleRel* Arena::CreateMaybeMessage<::substrait::ExtensionSingleRel>(Arena*); -template<> ::substrait::FetchRel* Arena::CreateMaybeMessage<::substrait::FetchRel>(Arena*); -template<> ::substrait::FilterRel* Arena::CreateMaybeMessage<::substrait::FilterRel>(Arena*); -template<> ::substrait::JoinRel* Arena::CreateMaybeMessage<::substrait::JoinRel>(Arena*); -template<> ::substrait::ProjectRel* Arena::CreateMaybeMessage<::substrait::ProjectRel>(Arena*); -template<> ::substrait::ReadRel* Arena::CreateMaybeMessage<::substrait::ReadRel>(Arena*); -template<> ::substrait::ReadRel_ExtensionTable* Arena::CreateMaybeMessage<::substrait::ReadRel_ExtensionTable>(Arena*); -template<> ::substrait::ReadRel_LocalFiles* Arena::CreateMaybeMessage<::substrait::ReadRel_LocalFiles>(Arena*); -template<> ::substrait::ReadRel_LocalFiles_FileOrFiles* Arena::CreateMaybeMessage<::substrait::ReadRel_LocalFiles_FileOrFiles>(Arena*); -template<> ::substrait::ReadRel_NamedTable* Arena::CreateMaybeMessage<::substrait::ReadRel_NamedTable>(Arena*); -template<> ::substrait::ReadRel_VirtualTable* Arena::CreateMaybeMessage<::substrait::ReadRel_VirtualTable>(Arena*); -template<> ::substrait::Rel* Arena::CreateMaybeMessage<::substrait::Rel>(Arena*); -template<> ::substrait::RelCommon* Arena::CreateMaybeMessage<::substrait::RelCommon>(Arena*); -template<> ::substrait::RelCommon_Direct* Arena::CreateMaybeMessage<::substrait::RelCommon_Direct>(Arena*); -template<> ::substrait::RelCommon_Emit* Arena::CreateMaybeMessage<::substrait::RelCommon_Emit>(Arena*); -template<> ::substrait::RelCommon_Hint* Arena::CreateMaybeMessage<::substrait::RelCommon_Hint>(Arena*); -template<> ::substrait::RelCommon_Hint_RuntimeConstraint* Arena::CreateMaybeMessage<::substrait::RelCommon_Hint_RuntimeConstraint>(Arena*); -template<> ::substrait::RelCommon_Hint_Stats* Arena::CreateMaybeMessage<::substrait::RelCommon_Hint_Stats>(Arena*); -template<> ::substrait::RelRoot* Arena::CreateMaybeMessage<::substrait::RelRoot>(Arena*); -template<> ::substrait::SetRel* Arena::CreateMaybeMessage<::substrait::SetRel>(Arena*); -template<> ::substrait::SortRel* Arena::CreateMaybeMessage<::substrait::SortRel>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace substrait { - -enum ReadRel_LocalFiles_FileOrFiles_FileFormat : int { - ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED = 0, - ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_PARQUET = 1, - ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - ReadRel_LocalFiles_FileOrFiles_FileFormat_ReadRel_LocalFiles_FileOrFiles_FileFormat_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(int value); -constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MIN = ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED; -constexpr ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MAX = ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_PARQUET; -constexpr int ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_ARRAYSIZE = ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(); -template -inline const std::string& ReadRel_LocalFiles_FileOrFiles_FileFormat_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function ReadRel_LocalFiles_FileOrFiles_FileFormat_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(), enum_t_value); -} -inline bool ReadRel_LocalFiles_FileOrFiles_FileFormat_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ReadRel_LocalFiles_FileOrFiles_FileFormat* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(), name, value); -} -enum JoinRel_JoinType : int { - JoinRel_JoinType_JOIN_TYPE_UNSPECIFIED = 0, - JoinRel_JoinType_JOIN_TYPE_INNER = 1, - JoinRel_JoinType_JOIN_TYPE_OUTER = 2, - JoinRel_JoinType_JOIN_TYPE_LEFT = 3, - JoinRel_JoinType_JOIN_TYPE_RIGHT = 4, - JoinRel_JoinType_JOIN_TYPE_SEMI = 5, - JoinRel_JoinType_JOIN_TYPE_ANTI = 6, - JoinRel_JoinType_JoinRel_JoinType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - JoinRel_JoinType_JoinRel_JoinType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool JoinRel_JoinType_IsValid(int value); -constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MIN = JoinRel_JoinType_JOIN_TYPE_UNSPECIFIED; -constexpr JoinRel_JoinType JoinRel_JoinType_JoinType_MAX = JoinRel_JoinType_JOIN_TYPE_ANTI; -constexpr int JoinRel_JoinType_JoinType_ARRAYSIZE = JoinRel_JoinType_JoinType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* JoinRel_JoinType_descriptor(); -template -inline const std::string& JoinRel_JoinType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function JoinRel_JoinType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - JoinRel_JoinType_descriptor(), enum_t_value); -} -inline bool JoinRel_JoinType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, JoinRel_JoinType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - JoinRel_JoinType_descriptor(), name, value); -} -enum SetRel_SetOp : int { - SetRel_SetOp_SET_OP_UNSPECIFIED = 0, - SetRel_SetOp_SET_OP_MINUS_PRIMARY = 1, - SetRel_SetOp_SET_OP_MINUS_MULTISET = 2, - SetRel_SetOp_SET_OP_INTERSECTION_PRIMARY = 3, - SetRel_SetOp_SET_OP_INTERSECTION_MULTISET = 4, - SetRel_SetOp_SET_OP_UNION_DISTINCT = 5, - SetRel_SetOp_SET_OP_UNION_ALL = 6, - SetRel_SetOp_SetRel_SetOp_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - SetRel_SetOp_SetRel_SetOp_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool SetRel_SetOp_IsValid(int value); -constexpr SetRel_SetOp SetRel_SetOp_SetOp_MIN = SetRel_SetOp_SET_OP_UNSPECIFIED; -constexpr SetRel_SetOp SetRel_SetOp_SetOp_MAX = SetRel_SetOp_SET_OP_UNION_ALL; -constexpr int SetRel_SetOp_SetOp_ARRAYSIZE = SetRel_SetOp_SetOp_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SetRel_SetOp_descriptor(); -template -inline const std::string& SetRel_SetOp_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function SetRel_SetOp_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - SetRel_SetOp_descriptor(), enum_t_value); -} -inline bool SetRel_SetOp_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SetRel_SetOp* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - SetRel_SetOp_descriptor(), name, value); -} -// =================================================================== - -class RelCommon_Direct final : - public ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Direct) */ { - public: - inline RelCommon_Direct() : RelCommon_Direct(nullptr) {} - explicit constexpr RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - RelCommon_Direct(const RelCommon_Direct& from); - RelCommon_Direct(RelCommon_Direct&& from) noexcept - : RelCommon_Direct() { - *this = ::std::move(from); - } - - inline RelCommon_Direct& operator=(const RelCommon_Direct& from) { - CopyFrom(from); - return *this; - } - inline RelCommon_Direct& operator=(RelCommon_Direct&& 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 RelCommon_Direct& default_instance() { - return *internal_default_instance(); - } - static inline const RelCommon_Direct* internal_default_instance() { - return reinterpret_cast( - &_RelCommon_Direct_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(RelCommon_Direct& a, RelCommon_Direct& b) { - a.Swap(&b); - } - inline void Swap(RelCommon_Direct* 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(RelCommon_Direct* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RelCommon_Direct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyFrom; - inline void CopyFrom(const RelCommon_Direct& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::CopyImpl(this, from); - } - using ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeFrom; - void MergeFrom(const RelCommon_Direct& from) { - ::PROTOBUF_NAMESPACE_ID::internal::ZeroFieldsBase::MergeImpl(this, from); - } - public: - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.RelCommon.Direct"; - } - protected: - explicit RelCommon_Direct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - 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 ------------------------------------------------------- - - // @@protoc_insertion_point(class_scope:substrait.RelCommon.Direct) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class RelCommon_Emit final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Emit) */ { - public: - inline RelCommon_Emit() : RelCommon_Emit(nullptr) {} - ~RelCommon_Emit() override; - explicit constexpr RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - RelCommon_Emit(const RelCommon_Emit& from); - RelCommon_Emit(RelCommon_Emit&& from) noexcept - : RelCommon_Emit() { - *this = ::std::move(from); - } - - inline RelCommon_Emit& operator=(const RelCommon_Emit& from) { - CopyFrom(from); - return *this; - } - inline RelCommon_Emit& operator=(RelCommon_Emit&& 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 RelCommon_Emit& default_instance() { - return *internal_default_instance(); - } - static inline const RelCommon_Emit* internal_default_instance() { - return reinterpret_cast( - &_RelCommon_Emit_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(RelCommon_Emit& a, RelCommon_Emit& b) { - a.Swap(&b); - } - inline void Swap(RelCommon_Emit* 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(RelCommon_Emit* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RelCommon_Emit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const RelCommon_Emit& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const RelCommon_Emit& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(RelCommon_Emit* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.RelCommon.Emit"; - } - protected: - explicit RelCommon_Emit(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kOutputMappingFieldNumber = 1, - }; - // repeated int32 output_mapping = 1; - int output_mapping_size() const; - private: - int _internal_output_mapping_size() const; - public: - void clear_output_mapping(); - private: - int32_t _internal_output_mapping(int index) const; - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& - _internal_output_mapping() const; - void _internal_add_output_mapping(int32_t value); - ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* - _internal_mutable_output_mapping(); - public: - int32_t output_mapping(int index) const; - void set_output_mapping(int index, int32_t value); - void add_output_mapping(int32_t value); - const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& - output_mapping() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* - mutable_output_mapping(); - - // @@protoc_insertion_point(class_scope:substrait.RelCommon.Emit) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > output_mapping_; - mutable std::atomic _output_mapping_cached_byte_size_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class RelCommon_Hint_Stats final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint.Stats) */ { - public: - inline RelCommon_Hint_Stats() : RelCommon_Hint_Stats(nullptr) {} - ~RelCommon_Hint_Stats() override; - explicit constexpr RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - RelCommon_Hint_Stats(const RelCommon_Hint_Stats& from); - RelCommon_Hint_Stats(RelCommon_Hint_Stats&& from) noexcept - : RelCommon_Hint_Stats() { - *this = ::std::move(from); - } - - inline RelCommon_Hint_Stats& operator=(const RelCommon_Hint_Stats& from) { - CopyFrom(from); - return *this; - } - inline RelCommon_Hint_Stats& operator=(RelCommon_Hint_Stats&& 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 RelCommon_Hint_Stats& default_instance() { - return *internal_default_instance(); - } - static inline const RelCommon_Hint_Stats* internal_default_instance() { - return reinterpret_cast( - &_RelCommon_Hint_Stats_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(RelCommon_Hint_Stats& a, RelCommon_Hint_Stats& b) { - a.Swap(&b); - } - inline void Swap(RelCommon_Hint_Stats* 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(RelCommon_Hint_Stats* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RelCommon_Hint_Stats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const RelCommon_Hint_Stats& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const RelCommon_Hint_Stats& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(RelCommon_Hint_Stats* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.RelCommon.Hint.Stats"; - } - protected: - explicit RelCommon_Hint_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kAdvancedExtensionFieldNumber = 10, - kRowCountFieldNumber = 1, - kRecordSizeFieldNumber = 2, - }; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // double row_count = 1; - void clear_row_count(); - double row_count() const; - void set_row_count(double value); - private: - double _internal_row_count() const; - void _internal_set_row_count(double value); - public: - - // double record_size = 2; - void clear_record_size(); - double record_size() const; - void set_record_size(double value); - private: - double _internal_record_size() const; - void _internal_set_record_size(double value); - public: - - // @@protoc_insertion_point(class_scope:substrait.RelCommon.Hint.Stats) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - double row_count_; - double record_size_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class RelCommon_Hint_RuntimeConstraint final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint.RuntimeConstraint) */ { - public: - inline RelCommon_Hint_RuntimeConstraint() : RelCommon_Hint_RuntimeConstraint(nullptr) {} - ~RelCommon_Hint_RuntimeConstraint() override; - explicit constexpr RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - RelCommon_Hint_RuntimeConstraint(const RelCommon_Hint_RuntimeConstraint& from); - RelCommon_Hint_RuntimeConstraint(RelCommon_Hint_RuntimeConstraint&& from) noexcept - : RelCommon_Hint_RuntimeConstraint() { - *this = ::std::move(from); - } - - inline RelCommon_Hint_RuntimeConstraint& operator=(const RelCommon_Hint_RuntimeConstraint& from) { - CopyFrom(from); - return *this; - } - inline RelCommon_Hint_RuntimeConstraint& operator=(RelCommon_Hint_RuntimeConstraint&& 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 RelCommon_Hint_RuntimeConstraint& default_instance() { - return *internal_default_instance(); - } - static inline const RelCommon_Hint_RuntimeConstraint* internal_default_instance() { - return reinterpret_cast( - &_RelCommon_Hint_RuntimeConstraint_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(RelCommon_Hint_RuntimeConstraint& a, RelCommon_Hint_RuntimeConstraint& b) { - a.Swap(&b); - } - inline void Swap(RelCommon_Hint_RuntimeConstraint* 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(RelCommon_Hint_RuntimeConstraint* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RelCommon_Hint_RuntimeConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const RelCommon_Hint_RuntimeConstraint& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const RelCommon_Hint_RuntimeConstraint& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(RelCommon_Hint_RuntimeConstraint* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.RelCommon.Hint.RuntimeConstraint"; - } - protected: - explicit RelCommon_Hint_RuntimeConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kAdvancedExtensionFieldNumber = 10, - }; - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // @@protoc_insertion_point(class_scope:substrait.RelCommon.Hint.RuntimeConstraint) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class RelCommon_Hint final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon.Hint) */ { - public: - inline RelCommon_Hint() : RelCommon_Hint(nullptr) {} - ~RelCommon_Hint() override; - explicit constexpr RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - RelCommon_Hint(const RelCommon_Hint& from); - RelCommon_Hint(RelCommon_Hint&& from) noexcept - : RelCommon_Hint() { - *this = ::std::move(from); - } - - inline RelCommon_Hint& operator=(const RelCommon_Hint& from) { - CopyFrom(from); - return *this; - } - inline RelCommon_Hint& operator=(RelCommon_Hint&& 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 RelCommon_Hint& default_instance() { - return *internal_default_instance(); - } - static inline const RelCommon_Hint* internal_default_instance() { - return reinterpret_cast( - &_RelCommon_Hint_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(RelCommon_Hint& a, RelCommon_Hint& b) { - a.Swap(&b); - } - inline void Swap(RelCommon_Hint* 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(RelCommon_Hint* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RelCommon_Hint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const RelCommon_Hint& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const RelCommon_Hint& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(RelCommon_Hint* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.RelCommon.Hint"; - } - protected: - explicit RelCommon_Hint(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef RelCommon_Hint_Stats Stats; - typedef RelCommon_Hint_RuntimeConstraint RuntimeConstraint; - - // accessors ------------------------------------------------------- - - enum : int { - kStatsFieldNumber = 1, - kConstraintFieldNumber = 2, - kAdvancedExtensionFieldNumber = 10, - }; - // .substrait.RelCommon.Hint.Stats stats = 1; - bool has_stats() const; - private: - bool _internal_has_stats() const; - public: - void clear_stats(); - const ::substrait::RelCommon_Hint_Stats& stats() const; - PROTOBUF_NODISCARD ::substrait::RelCommon_Hint_Stats* release_stats(); - ::substrait::RelCommon_Hint_Stats* mutable_stats(); - void set_allocated_stats(::substrait::RelCommon_Hint_Stats* stats); - private: - const ::substrait::RelCommon_Hint_Stats& _internal_stats() const; - ::substrait::RelCommon_Hint_Stats* _internal_mutable_stats(); - public: - void unsafe_arena_set_allocated_stats( - ::substrait::RelCommon_Hint_Stats* stats); - ::substrait::RelCommon_Hint_Stats* unsafe_arena_release_stats(); - - // .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; - bool has_constraint() const; - private: - bool _internal_has_constraint() const; - public: - void clear_constraint(); - const ::substrait::RelCommon_Hint_RuntimeConstraint& constraint() const; - PROTOBUF_NODISCARD ::substrait::RelCommon_Hint_RuntimeConstraint* release_constraint(); - ::substrait::RelCommon_Hint_RuntimeConstraint* mutable_constraint(); - void set_allocated_constraint(::substrait::RelCommon_Hint_RuntimeConstraint* constraint); - private: - const ::substrait::RelCommon_Hint_RuntimeConstraint& _internal_constraint() const; - ::substrait::RelCommon_Hint_RuntimeConstraint* _internal_mutable_constraint(); - public: - void unsafe_arena_set_allocated_constraint( - ::substrait::RelCommon_Hint_RuntimeConstraint* constraint); - ::substrait::RelCommon_Hint_RuntimeConstraint* unsafe_arena_release_constraint(); - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // @@protoc_insertion_point(class_scope:substrait.RelCommon.Hint) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::RelCommon_Hint_Stats* stats_; - ::substrait::RelCommon_Hint_RuntimeConstraint* constraint_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class RelCommon final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelCommon) */ { - public: - inline RelCommon() : RelCommon(nullptr) {} - ~RelCommon() override; - explicit constexpr RelCommon(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - RelCommon(const RelCommon& from); - RelCommon(RelCommon&& from) noexcept - : RelCommon() { - *this = ::std::move(from); - } - - inline RelCommon& operator=(const RelCommon& from) { - CopyFrom(from); - return *this; - } - inline RelCommon& operator=(RelCommon&& 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 RelCommon& default_instance() { - return *internal_default_instance(); - } - enum EmitKindCase { - kDirect = 1, - kEmit = 2, - EMIT_KIND_NOT_SET = 0, - }; - - static inline const RelCommon* internal_default_instance() { - return reinterpret_cast( - &_RelCommon_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(RelCommon& a, RelCommon& b) { - a.Swap(&b); - } - inline void Swap(RelCommon* 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(RelCommon* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RelCommon* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const RelCommon& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const RelCommon& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(RelCommon* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.RelCommon"; - } - protected: - explicit RelCommon(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef RelCommon_Direct Direct; - typedef RelCommon_Emit Emit; - typedef RelCommon_Hint Hint; - - // accessors ------------------------------------------------------- - - enum : int { - kHintFieldNumber = 3, - kAdvancedExtensionFieldNumber = 4, - kDirectFieldNumber = 1, - kEmitFieldNumber = 2, - }; - // .substrait.RelCommon.Hint hint = 3; - bool has_hint() const; - private: - bool _internal_has_hint() const; - public: - void clear_hint(); - const ::substrait::RelCommon_Hint& hint() const; - PROTOBUF_NODISCARD ::substrait::RelCommon_Hint* release_hint(); - ::substrait::RelCommon_Hint* mutable_hint(); - void set_allocated_hint(::substrait::RelCommon_Hint* hint); - private: - const ::substrait::RelCommon_Hint& _internal_hint() const; - ::substrait::RelCommon_Hint* _internal_mutable_hint(); - public: - void unsafe_arena_set_allocated_hint( - ::substrait::RelCommon_Hint* hint); - ::substrait::RelCommon_Hint* unsafe_arena_release_hint(); - - // .substrait.extensions.AdvancedExtension advanced_extension = 4; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // .substrait.RelCommon.Direct direct = 1; - bool has_direct() const; - private: - bool _internal_has_direct() const; - public: - void clear_direct(); - const ::substrait::RelCommon_Direct& direct() const; - PROTOBUF_NODISCARD ::substrait::RelCommon_Direct* release_direct(); - ::substrait::RelCommon_Direct* mutable_direct(); - void set_allocated_direct(::substrait::RelCommon_Direct* direct); - private: - const ::substrait::RelCommon_Direct& _internal_direct() const; - ::substrait::RelCommon_Direct* _internal_mutable_direct(); - public: - void unsafe_arena_set_allocated_direct( - ::substrait::RelCommon_Direct* direct); - ::substrait::RelCommon_Direct* unsafe_arena_release_direct(); - - // .substrait.RelCommon.Emit emit = 2; - bool has_emit() const; - private: - bool _internal_has_emit() const; - public: - void clear_emit(); - const ::substrait::RelCommon_Emit& emit() const; - PROTOBUF_NODISCARD ::substrait::RelCommon_Emit* release_emit(); - ::substrait::RelCommon_Emit* mutable_emit(); - void set_allocated_emit(::substrait::RelCommon_Emit* emit); - private: - const ::substrait::RelCommon_Emit& _internal_emit() const; - ::substrait::RelCommon_Emit* _internal_mutable_emit(); - public: - void unsafe_arena_set_allocated_emit( - ::substrait::RelCommon_Emit* emit); - ::substrait::RelCommon_Emit* unsafe_arena_release_emit(); - - void clear_emit_kind(); - EmitKindCase emit_kind_case() const; - // @@protoc_insertion_point(class_scope:substrait.RelCommon) - private: - class _Internal; - void set_has_direct(); - void set_has_emit(); - - inline bool has_emit_kind() const; - inline void clear_has_emit_kind(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::RelCommon_Hint* hint_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - union EmitKindUnion { - constexpr EmitKindUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::RelCommon_Direct* direct_; - ::substrait::RelCommon_Emit* emit_; - } emit_kind_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class ReadRel_NamedTable final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.NamedTable) */ { - public: - inline ReadRel_NamedTable() : ReadRel_NamedTable(nullptr) {} - ~ReadRel_NamedTable() override; - explicit constexpr ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReadRel_NamedTable(const ReadRel_NamedTable& from); - ReadRel_NamedTable(ReadRel_NamedTable&& from) noexcept - : ReadRel_NamedTable() { - *this = ::std::move(from); - } - - inline ReadRel_NamedTable& operator=(const ReadRel_NamedTable& from) { - CopyFrom(from); - return *this; - } - inline ReadRel_NamedTable& operator=(ReadRel_NamedTable&& 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 ReadRel_NamedTable& default_instance() { - return *internal_default_instance(); - } - static inline const ReadRel_NamedTable* internal_default_instance() { - return reinterpret_cast( - &_ReadRel_NamedTable_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(ReadRel_NamedTable& a, ReadRel_NamedTable& b) { - a.Swap(&b); - } - inline void Swap(ReadRel_NamedTable* 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(ReadRel_NamedTable* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ReadRel_NamedTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ReadRel_NamedTable& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ReadRel_NamedTable& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReadRel_NamedTable* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ReadRel.NamedTable"; - } - protected: - explicit ReadRel_NamedTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kNamesFieldNumber = 1, - kAdvancedExtensionFieldNumber = 10, - }; - // repeated string names = 1; - int names_size() const; - private: - int _internal_names_size() const; - public: - void clear_names(); - const std::string& names(int index) const; - std::string* mutable_names(int index); - void set_names(int index, const std::string& value); - void set_names(int index, std::string&& value); - void set_names(int index, const char* value); - void set_names(int index, const char* value, size_t size); - std::string* add_names(); - void add_names(const std::string& value); - void add_names(std::string&& value); - void add_names(const char* value); - void add_names(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); - private: - const std::string& _internal_names(int index) const; - std::string* _internal_add_names(); - public: - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // @@protoc_insertion_point(class_scope:substrait.ReadRel.NamedTable) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class ReadRel_VirtualTable final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.VirtualTable) */ { - public: - inline ReadRel_VirtualTable() : ReadRel_VirtualTable(nullptr) {} - ~ReadRel_VirtualTable() override; - explicit constexpr ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReadRel_VirtualTable(const ReadRel_VirtualTable& from); - ReadRel_VirtualTable(ReadRel_VirtualTable&& from) noexcept - : ReadRel_VirtualTable() { - *this = ::std::move(from); - } - - inline ReadRel_VirtualTable& operator=(const ReadRel_VirtualTable& from) { - CopyFrom(from); - return *this; - } - inline ReadRel_VirtualTable& operator=(ReadRel_VirtualTable&& 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 ReadRel_VirtualTable& default_instance() { - return *internal_default_instance(); - } - static inline const ReadRel_VirtualTable* internal_default_instance() { - return reinterpret_cast( - &_ReadRel_VirtualTable_default_instance_); - } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(ReadRel_VirtualTable& a, ReadRel_VirtualTable& b) { - a.Swap(&b); - } - inline void Swap(ReadRel_VirtualTable* 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(ReadRel_VirtualTable* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ReadRel_VirtualTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ReadRel_VirtualTable& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ReadRel_VirtualTable& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReadRel_VirtualTable* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ReadRel.VirtualTable"; - } - protected: - explicit ReadRel_VirtualTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kValuesFieldNumber = 1, - }; - // repeated .substrait.Expression.Literal.Struct values = 1; - int values_size() const; - private: - int _internal_values_size() const; - public: - void clear_values(); - ::substrait::Expression_Literal_Struct* mutable_values(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >* - mutable_values(); - private: - const ::substrait::Expression_Literal_Struct& _internal_values(int index) const; - ::substrait::Expression_Literal_Struct* _internal_add_values(); - public: - const ::substrait::Expression_Literal_Struct& values(int index) const; - ::substrait::Expression_Literal_Struct* add_values(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >& - values() const; - - // @@protoc_insertion_point(class_scope:substrait.ReadRel.VirtualTable) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct > values_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class ReadRel_ExtensionTable final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.ExtensionTable) */ { - public: - inline ReadRel_ExtensionTable() : ReadRel_ExtensionTable(nullptr) {} - ~ReadRel_ExtensionTable() override; - explicit constexpr ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReadRel_ExtensionTable(const ReadRel_ExtensionTable& from); - ReadRel_ExtensionTable(ReadRel_ExtensionTable&& from) noexcept - : ReadRel_ExtensionTable() { - *this = ::std::move(from); - } - - inline ReadRel_ExtensionTable& operator=(const ReadRel_ExtensionTable& from) { - CopyFrom(from); - return *this; - } - inline ReadRel_ExtensionTable& operator=(ReadRel_ExtensionTable&& 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 ReadRel_ExtensionTable& default_instance() { - return *internal_default_instance(); - } - static inline const ReadRel_ExtensionTable* internal_default_instance() { - return reinterpret_cast( - &_ReadRel_ExtensionTable_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(ReadRel_ExtensionTable& a, ReadRel_ExtensionTable& b) { - a.Swap(&b); - } - inline void Swap(ReadRel_ExtensionTable* 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(ReadRel_ExtensionTable* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ReadRel_ExtensionTable* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ReadRel_ExtensionTable& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ReadRel_ExtensionTable& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReadRel_ExtensionTable* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ReadRel.ExtensionTable"; - } - protected: - explicit ReadRel_ExtensionTable(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kDetailFieldNumber = 1, - }; - // .google.protobuf.Any detail = 1; - bool has_detail() const; - private: - bool _internal_has_detail() const; - public: - void clear_detail(); - const ::PROTOBUF_NAMESPACE_ID::Any& detail() const; - PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail(); - ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); - void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail); - private: - const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; - ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); - public: - void unsafe_arena_set_allocated_detail( - ::PROTOBUF_NAMESPACE_ID::Any* detail); - ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); - - // @@protoc_insertion_point(class_scope:substrait.ReadRel.ExtensionTable) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::Any* detail_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class ReadRel_LocalFiles_FileOrFiles final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.LocalFiles.FileOrFiles) */ { - public: - inline ReadRel_LocalFiles_FileOrFiles() : ReadRel_LocalFiles_FileOrFiles(nullptr) {} - ~ReadRel_LocalFiles_FileOrFiles() override; - explicit constexpr ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReadRel_LocalFiles_FileOrFiles(const ReadRel_LocalFiles_FileOrFiles& from); - ReadRel_LocalFiles_FileOrFiles(ReadRel_LocalFiles_FileOrFiles&& from) noexcept - : ReadRel_LocalFiles_FileOrFiles() { - *this = ::std::move(from); - } - - inline ReadRel_LocalFiles_FileOrFiles& operator=(const ReadRel_LocalFiles_FileOrFiles& from) { - CopyFrom(from); - return *this; - } - inline ReadRel_LocalFiles_FileOrFiles& operator=(ReadRel_LocalFiles_FileOrFiles&& 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 ReadRel_LocalFiles_FileOrFiles& default_instance() { - return *internal_default_instance(); - } - enum PathTypeCase { - kUriPath = 1, - kUriPathGlob = 2, - kUriFile = 3, - kUriFolder = 4, - PATH_TYPE_NOT_SET = 0, - }; - - static inline const ReadRel_LocalFiles_FileOrFiles* internal_default_instance() { - return reinterpret_cast( - &_ReadRel_LocalFiles_FileOrFiles_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(ReadRel_LocalFiles_FileOrFiles& a, ReadRel_LocalFiles_FileOrFiles& b) { - a.Swap(&b); - } - inline void Swap(ReadRel_LocalFiles_FileOrFiles* 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(ReadRel_LocalFiles_FileOrFiles* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ReadRel_LocalFiles_FileOrFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ReadRel_LocalFiles_FileOrFiles& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ReadRel_LocalFiles_FileOrFiles& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReadRel_LocalFiles_FileOrFiles* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ReadRel.LocalFiles.FileOrFiles"; - } - protected: - explicit ReadRel_LocalFiles_FileOrFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ReadRel_LocalFiles_FileOrFiles_FileFormat FileFormat; - static constexpr FileFormat FILE_FORMAT_UNSPECIFIED = - ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_UNSPECIFIED; - static constexpr FileFormat FILE_FORMAT_PARQUET = - ReadRel_LocalFiles_FileOrFiles_FileFormat_FILE_FORMAT_PARQUET; - static inline bool FileFormat_IsValid(int value) { - return ReadRel_LocalFiles_FileOrFiles_FileFormat_IsValid(value); - } - static constexpr FileFormat FileFormat_MIN = - ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MIN; - static constexpr FileFormat FileFormat_MAX = - ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_MAX; - static constexpr int FileFormat_ARRAYSIZE = - ReadRel_LocalFiles_FileOrFiles_FileFormat_FileFormat_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - FileFormat_descriptor() { - return ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(); - } - template - static inline const std::string& FileFormat_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function FileFormat_Name."); - return ReadRel_LocalFiles_FileOrFiles_FileFormat_Name(enum_t_value); - } - static inline bool FileFormat_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - FileFormat* value) { - return ReadRel_LocalFiles_FileOrFiles_FileFormat_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kFormatFieldNumber = 5, - kPartitionIndexFieldNumber = 6, - kStartFieldNumber = 7, - kLengthFieldNumber = 8, - kUriPathFieldNumber = 1, - kUriPathGlobFieldNumber = 2, - kUriFileFieldNumber = 3, - kUriFolderFieldNumber = 4, - }; - // .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; - void clear_format(); - ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat format() const; - void set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value); - private: - ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat _internal_format() const; - void _internal_set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value); - public: - - // uint64 partition_index = 6; - void clear_partition_index(); - uint64_t partition_index() const; - void set_partition_index(uint64_t value); - private: - uint64_t _internal_partition_index() const; - void _internal_set_partition_index(uint64_t value); - public: - - // uint64 start = 7; - void clear_start(); - uint64_t start() const; - void set_start(uint64_t value); - private: - uint64_t _internal_start() const; - void _internal_set_start(uint64_t value); - public: - - // uint64 length = 8; - void clear_length(); - uint64_t length() const; - void set_length(uint64_t value); - private: - uint64_t _internal_length() const; - void _internal_set_length(uint64_t value); - public: - - // string uri_path = 1; - bool has_uri_path() const; - private: - bool _internal_has_uri_path() const; - public: - void clear_uri_path(); - const std::string& uri_path() const; - template - void set_uri_path(ArgT0&& arg0, ArgT... args); - std::string* mutable_uri_path(); - PROTOBUF_NODISCARD std::string* release_uri_path(); - void set_allocated_uri_path(std::string* uri_path); - private: - const std::string& _internal_uri_path() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_path(const std::string& value); - std::string* _internal_mutable_uri_path(); - public: - - // string uri_path_glob = 2; - bool has_uri_path_glob() const; - private: - bool _internal_has_uri_path_glob() const; - public: - void clear_uri_path_glob(); - const std::string& uri_path_glob() const; - template - void set_uri_path_glob(ArgT0&& arg0, ArgT... args); - std::string* mutable_uri_path_glob(); - PROTOBUF_NODISCARD std::string* release_uri_path_glob(); - void set_allocated_uri_path_glob(std::string* uri_path_glob); - private: - const std::string& _internal_uri_path_glob() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_path_glob(const std::string& value); - std::string* _internal_mutable_uri_path_glob(); - public: - - // string uri_file = 3; - bool has_uri_file() const; - private: - bool _internal_has_uri_file() const; - public: - void clear_uri_file(); - const std::string& uri_file() const; - template - void set_uri_file(ArgT0&& arg0, ArgT... args); - std::string* mutable_uri_file(); - PROTOBUF_NODISCARD std::string* release_uri_file(); - void set_allocated_uri_file(std::string* uri_file); - private: - const std::string& _internal_uri_file() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_file(const std::string& value); - std::string* _internal_mutable_uri_file(); - public: - - // string uri_folder = 4; - bool has_uri_folder() const; - private: - bool _internal_has_uri_folder() const; - public: - void clear_uri_folder(); - const std::string& uri_folder() const; - template - void set_uri_folder(ArgT0&& arg0, ArgT... args); - std::string* mutable_uri_folder(); - PROTOBUF_NODISCARD std::string* release_uri_folder(); - void set_allocated_uri_folder(std::string* uri_folder); - private: - const std::string& _internal_uri_folder() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_uri_folder(const std::string& value); - std::string* _internal_mutable_uri_folder(); - public: - - void clear_path_type(); - PathTypeCase path_type_case() const; - // @@protoc_insertion_point(class_scope:substrait.ReadRel.LocalFiles.FileOrFiles) - private: - class _Internal; - void set_has_uri_path(); - void set_has_uri_path_glob(); - void set_has_uri_file(); - void set_has_uri_folder(); - - inline bool has_path_type() const; - inline void clear_has_path_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int format_; - uint64_t partition_index_; - uint64_t start_; - uint64_t length_; - union PathTypeUnion { - constexpr PathTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_path_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_path_glob_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_file_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uri_folder_; - } path_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class ReadRel_LocalFiles final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel.LocalFiles) */ { - public: - inline ReadRel_LocalFiles() : ReadRel_LocalFiles(nullptr) {} - ~ReadRel_LocalFiles() override; - explicit constexpr ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReadRel_LocalFiles(const ReadRel_LocalFiles& from); - ReadRel_LocalFiles(ReadRel_LocalFiles&& from) noexcept - : ReadRel_LocalFiles() { - *this = ::std::move(from); - } - - inline ReadRel_LocalFiles& operator=(const ReadRel_LocalFiles& from) { - CopyFrom(from); - return *this; - } - inline ReadRel_LocalFiles& operator=(ReadRel_LocalFiles&& 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 ReadRel_LocalFiles& default_instance() { - return *internal_default_instance(); - } - static inline const ReadRel_LocalFiles* internal_default_instance() { - return reinterpret_cast( - &_ReadRel_LocalFiles_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(ReadRel_LocalFiles& a, ReadRel_LocalFiles& b) { - a.Swap(&b); - } - inline void Swap(ReadRel_LocalFiles* 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(ReadRel_LocalFiles* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ReadRel_LocalFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ReadRel_LocalFiles& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ReadRel_LocalFiles& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReadRel_LocalFiles* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ReadRel.LocalFiles"; - } - protected: - explicit ReadRel_LocalFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ReadRel_LocalFiles_FileOrFiles FileOrFiles; - - // accessors ------------------------------------------------------- - - enum : int { - kItemsFieldNumber = 1, - kAdvancedExtensionFieldNumber = 10, - }; - // repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; - int items_size() const; - private: - int _internal_items_size() const; - public: - void clear_items(); - ::substrait::ReadRel_LocalFiles_FileOrFiles* mutable_items(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >* - mutable_items(); - private: - const ::substrait::ReadRel_LocalFiles_FileOrFiles& _internal_items(int index) const; - ::substrait::ReadRel_LocalFiles_FileOrFiles* _internal_add_items(); - public: - const ::substrait::ReadRel_LocalFiles_FileOrFiles& items(int index) const; - ::substrait::ReadRel_LocalFiles_FileOrFiles* add_items(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >& - items() const; - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // @@protoc_insertion_point(class_scope:substrait.ReadRel.LocalFiles) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles > items_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class ReadRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ReadRel) */ { - public: - inline ReadRel() : ReadRel(nullptr) {} - ~ReadRel() override; - explicit constexpr ReadRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ReadRel(const ReadRel& from); - ReadRel(ReadRel&& from) noexcept - : ReadRel() { - *this = ::std::move(from); - } - - inline ReadRel& operator=(const ReadRel& from) { - CopyFrom(from); - return *this; - } - inline ReadRel& operator=(ReadRel&& 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 ReadRel& default_instance() { - return *internal_default_instance(); - } - enum ReadTypeCase { - kVirtualTable = 5, - kLocalFiles = 6, - kNamedTable = 7, - kExtensionTable = 8, - READ_TYPE_NOT_SET = 0, - }; - - static inline const ReadRel* internal_default_instance() { - return reinterpret_cast( - &_ReadRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(ReadRel& a, ReadRel& b) { - a.Swap(&b); - } - inline void Swap(ReadRel* 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(ReadRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ReadRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ReadRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ReadRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ReadRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ReadRel"; - } - protected: - explicit ReadRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef ReadRel_NamedTable NamedTable; - typedef ReadRel_VirtualTable VirtualTable; - typedef ReadRel_ExtensionTable ExtensionTable; - typedef ReadRel_LocalFiles LocalFiles; - - // accessors ------------------------------------------------------- - - enum : int { - kCommonFieldNumber = 1, - kBaseSchemaFieldNumber = 2, - kFilterFieldNumber = 3, - kProjectionFieldNumber = 4, - kAdvancedExtensionFieldNumber = 10, - kVirtualTableFieldNumber = 5, - kLocalFilesFieldNumber = 6, - kNamedTableFieldNumber = 7, - kExtensionTableFieldNumber = 8, - }; - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .substrait.NamedStruct base_schema = 2; - bool has_base_schema() const; - private: - bool _internal_has_base_schema() const; - public: - void clear_base_schema(); - const ::substrait::NamedStruct& base_schema() const; - PROTOBUF_NODISCARD ::substrait::NamedStruct* release_base_schema(); - ::substrait::NamedStruct* mutable_base_schema(); - void set_allocated_base_schema(::substrait::NamedStruct* base_schema); - private: - const ::substrait::NamedStruct& _internal_base_schema() const; - ::substrait::NamedStruct* _internal_mutable_base_schema(); - public: - void unsafe_arena_set_allocated_base_schema( - ::substrait::NamedStruct* base_schema); - ::substrait::NamedStruct* unsafe_arena_release_base_schema(); - - // .substrait.Expression filter = 3; - bool has_filter() const; - private: - bool _internal_has_filter() const; - public: - void clear_filter(); - const ::substrait::Expression& filter() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_filter(); - ::substrait::Expression* mutable_filter(); - void set_allocated_filter(::substrait::Expression* filter); - private: - const ::substrait::Expression& _internal_filter() const; - ::substrait::Expression* _internal_mutable_filter(); - public: - void unsafe_arena_set_allocated_filter( - ::substrait::Expression* filter); - ::substrait::Expression* unsafe_arena_release_filter(); - - // .substrait.Expression.MaskExpression projection = 4; - bool has_projection() const; - private: - bool _internal_has_projection() const; - public: - void clear_projection(); - const ::substrait::Expression_MaskExpression& projection() const; - PROTOBUF_NODISCARD ::substrait::Expression_MaskExpression* release_projection(); - ::substrait::Expression_MaskExpression* mutable_projection(); - void set_allocated_projection(::substrait::Expression_MaskExpression* projection); - private: - const ::substrait::Expression_MaskExpression& _internal_projection() const; - ::substrait::Expression_MaskExpression* _internal_mutable_projection(); - public: - void unsafe_arena_set_allocated_projection( - ::substrait::Expression_MaskExpression* projection); - ::substrait::Expression_MaskExpression* unsafe_arena_release_projection(); - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // .substrait.ReadRel.VirtualTable virtual_table = 5; - bool has_virtual_table() const; - private: - bool _internal_has_virtual_table() const; - public: - void clear_virtual_table(); - const ::substrait::ReadRel_VirtualTable& virtual_table() const; - PROTOBUF_NODISCARD ::substrait::ReadRel_VirtualTable* release_virtual_table(); - ::substrait::ReadRel_VirtualTable* mutable_virtual_table(); - void set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table); - private: - const ::substrait::ReadRel_VirtualTable& _internal_virtual_table() const; - ::substrait::ReadRel_VirtualTable* _internal_mutable_virtual_table(); - public: - void unsafe_arena_set_allocated_virtual_table( - ::substrait::ReadRel_VirtualTable* virtual_table); - ::substrait::ReadRel_VirtualTable* unsafe_arena_release_virtual_table(); - - // .substrait.ReadRel.LocalFiles local_files = 6; - bool has_local_files() const; - private: - bool _internal_has_local_files() const; - public: - void clear_local_files(); - const ::substrait::ReadRel_LocalFiles& local_files() const; - PROTOBUF_NODISCARD ::substrait::ReadRel_LocalFiles* release_local_files(); - ::substrait::ReadRel_LocalFiles* mutable_local_files(); - void set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files); - private: - const ::substrait::ReadRel_LocalFiles& _internal_local_files() const; - ::substrait::ReadRel_LocalFiles* _internal_mutable_local_files(); - public: - void unsafe_arena_set_allocated_local_files( - ::substrait::ReadRel_LocalFiles* local_files); - ::substrait::ReadRel_LocalFiles* unsafe_arena_release_local_files(); - - // .substrait.ReadRel.NamedTable named_table = 7; - bool has_named_table() const; - private: - bool _internal_has_named_table() const; - public: - void clear_named_table(); - const ::substrait::ReadRel_NamedTable& named_table() const; - PROTOBUF_NODISCARD ::substrait::ReadRel_NamedTable* release_named_table(); - ::substrait::ReadRel_NamedTable* mutable_named_table(); - void set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table); - private: - const ::substrait::ReadRel_NamedTable& _internal_named_table() const; - ::substrait::ReadRel_NamedTable* _internal_mutable_named_table(); - public: - void unsafe_arena_set_allocated_named_table( - ::substrait::ReadRel_NamedTable* named_table); - ::substrait::ReadRel_NamedTable* unsafe_arena_release_named_table(); - - // .substrait.ReadRel.ExtensionTable extension_table = 8; - bool has_extension_table() const; - private: - bool _internal_has_extension_table() const; - public: - void clear_extension_table(); - const ::substrait::ReadRel_ExtensionTable& extension_table() const; - PROTOBUF_NODISCARD ::substrait::ReadRel_ExtensionTable* release_extension_table(); - ::substrait::ReadRel_ExtensionTable* mutable_extension_table(); - void set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table); - private: - const ::substrait::ReadRel_ExtensionTable& _internal_extension_table() const; - ::substrait::ReadRel_ExtensionTable* _internal_mutable_extension_table(); - public: - void unsafe_arena_set_allocated_extension_table( - ::substrait::ReadRel_ExtensionTable* extension_table); - ::substrait::ReadRel_ExtensionTable* unsafe_arena_release_extension_table(); - - void clear_read_type(); - ReadTypeCase read_type_case() const; - // @@protoc_insertion_point(class_scope:substrait.ReadRel) - private: - class _Internal; - void set_has_virtual_table(); - void set_has_local_files(); - void set_has_named_table(); - void set_has_extension_table(); - - inline bool has_read_type() const; - inline void clear_has_read_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::RelCommon* common_; - ::substrait::NamedStruct* base_schema_; - ::substrait::Expression* filter_; - ::substrait::Expression_MaskExpression* projection_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - union ReadTypeUnion { - constexpr ReadTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::ReadRel_VirtualTable* virtual_table_; - ::substrait::ReadRel_LocalFiles* local_files_; - ::substrait::ReadRel_NamedTable* named_table_; - ::substrait::ReadRel_ExtensionTable* extension_table_; - } read_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class ProjectRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ProjectRel) */ { - public: - inline ProjectRel() : ProjectRel(nullptr) {} - ~ProjectRel() override; - explicit constexpr ProjectRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ProjectRel(const ProjectRel& from); - ProjectRel(ProjectRel&& from) noexcept - : ProjectRel() { - *this = ::std::move(from); - } - - inline ProjectRel& operator=(const ProjectRel& from) { - CopyFrom(from); - return *this; - } - inline ProjectRel& operator=(ProjectRel&& 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 ProjectRel& default_instance() { - return *internal_default_instance(); - } - static inline const ProjectRel* internal_default_instance() { - return reinterpret_cast( - &_ProjectRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 12; - - friend void swap(ProjectRel& a, ProjectRel& b) { - a.Swap(&b); - } - inline void Swap(ProjectRel* 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(ProjectRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ProjectRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ProjectRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ProjectRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ProjectRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ProjectRel"; - } - protected: - explicit ProjectRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kExpressionsFieldNumber = 3, - kCommonFieldNumber = 1, - kInputFieldNumber = 2, - kAdvancedExtensionFieldNumber = 10, - }; - // repeated .substrait.Expression expressions = 3; - int expressions_size() const; - private: - int _internal_expressions_size() const; - public: - void clear_expressions(); - ::substrait::Expression* mutable_expressions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* - mutable_expressions(); - private: - const ::substrait::Expression& _internal_expressions(int index) const; - ::substrait::Expression* _internal_add_expressions(); - public: - const ::substrait::Expression& expressions(int index) const; - ::substrait::Expression* add_expressions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& - expressions() const; - - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .substrait.Rel input = 2; - bool has_input() const; - private: - bool _internal_has_input() const; - public: - void clear_input(); - const ::substrait::Rel& input() const; - PROTOBUF_NODISCARD ::substrait::Rel* release_input(); - ::substrait::Rel* mutable_input(); - void set_allocated_input(::substrait::Rel* input); - private: - const ::substrait::Rel& _internal_input() const; - ::substrait::Rel* _internal_mutable_input(); - public: - void unsafe_arena_set_allocated_input( - ::substrait::Rel* input); - ::substrait::Rel* unsafe_arena_release_input(); - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // @@protoc_insertion_point(class_scope:substrait.ProjectRel) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > expressions_; - ::substrait::RelCommon* common_; - ::substrait::Rel* input_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class JoinRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.JoinRel) */ { - public: - inline JoinRel() : JoinRel(nullptr) {} - ~JoinRel() override; - explicit constexpr JoinRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - JoinRel(const JoinRel& from); - JoinRel(JoinRel&& from) noexcept - : JoinRel() { - *this = ::std::move(from); - } - - inline JoinRel& operator=(const JoinRel& from) { - CopyFrom(from); - return *this; - } - inline JoinRel& operator=(JoinRel&& 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 JoinRel& default_instance() { - return *internal_default_instance(); - } - static inline const JoinRel* internal_default_instance() { - return reinterpret_cast( - &_JoinRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 13; - - friend void swap(JoinRel& a, JoinRel& b) { - a.Swap(&b); - } - inline void Swap(JoinRel* 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(JoinRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - JoinRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const JoinRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const JoinRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(JoinRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.JoinRel"; - } - protected: - explicit JoinRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef JoinRel_JoinType JoinType; - static constexpr JoinType JOIN_TYPE_UNSPECIFIED = - JoinRel_JoinType_JOIN_TYPE_UNSPECIFIED; - static constexpr JoinType JOIN_TYPE_INNER = - JoinRel_JoinType_JOIN_TYPE_INNER; - static constexpr JoinType JOIN_TYPE_OUTER = - JoinRel_JoinType_JOIN_TYPE_OUTER; - static constexpr JoinType JOIN_TYPE_LEFT = - JoinRel_JoinType_JOIN_TYPE_LEFT; - static constexpr JoinType JOIN_TYPE_RIGHT = - JoinRel_JoinType_JOIN_TYPE_RIGHT; - static constexpr JoinType JOIN_TYPE_SEMI = - JoinRel_JoinType_JOIN_TYPE_SEMI; - static constexpr JoinType JOIN_TYPE_ANTI = - JoinRel_JoinType_JOIN_TYPE_ANTI; - static inline bool JoinType_IsValid(int value) { - return JoinRel_JoinType_IsValid(value); - } - static constexpr JoinType JoinType_MIN = - JoinRel_JoinType_JoinType_MIN; - static constexpr JoinType JoinType_MAX = - JoinRel_JoinType_JoinType_MAX; - static constexpr int JoinType_ARRAYSIZE = - JoinRel_JoinType_JoinType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - JoinType_descriptor() { - return JoinRel_JoinType_descriptor(); - } - template - static inline const std::string& JoinType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function JoinType_Name."); - return JoinRel_JoinType_Name(enum_t_value); - } - static inline bool JoinType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - JoinType* value) { - return JoinRel_JoinType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kCommonFieldNumber = 1, - kLeftFieldNumber = 2, - kRightFieldNumber = 3, - kExpressionFieldNumber = 4, - kPostJoinFilterFieldNumber = 5, - kAdvancedExtensionFieldNumber = 10, - kTypeFieldNumber = 6, - }; - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .substrait.Rel left = 2; - bool has_left() const; - private: - bool _internal_has_left() const; - public: - void clear_left(); - const ::substrait::Rel& left() const; - PROTOBUF_NODISCARD ::substrait::Rel* release_left(); - ::substrait::Rel* mutable_left(); - void set_allocated_left(::substrait::Rel* left); - private: - const ::substrait::Rel& _internal_left() const; - ::substrait::Rel* _internal_mutable_left(); - public: - void unsafe_arena_set_allocated_left( - ::substrait::Rel* left); - ::substrait::Rel* unsafe_arena_release_left(); - - // .substrait.Rel right = 3; - bool has_right() const; - private: - bool _internal_has_right() const; - public: - void clear_right(); - const ::substrait::Rel& right() const; - PROTOBUF_NODISCARD ::substrait::Rel* release_right(); - ::substrait::Rel* mutable_right(); - void set_allocated_right(::substrait::Rel* right); - private: - const ::substrait::Rel& _internal_right() const; - ::substrait::Rel* _internal_mutable_right(); - public: - void unsafe_arena_set_allocated_right( - ::substrait::Rel* right); - ::substrait::Rel* unsafe_arena_release_right(); - - // .substrait.Expression expression = 4; - bool has_expression() const; - private: - bool _internal_has_expression() const; - public: - void clear_expression(); - const ::substrait::Expression& expression() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_expression(); - ::substrait::Expression* mutable_expression(); - void set_allocated_expression(::substrait::Expression* expression); - private: - const ::substrait::Expression& _internal_expression() const; - ::substrait::Expression* _internal_mutable_expression(); - public: - void unsafe_arena_set_allocated_expression( - ::substrait::Expression* expression); - ::substrait::Expression* unsafe_arena_release_expression(); - - // .substrait.Expression post_join_filter = 5; - bool has_post_join_filter() const; - private: - bool _internal_has_post_join_filter() const; - public: - void clear_post_join_filter(); - const ::substrait::Expression& post_join_filter() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_post_join_filter(); - ::substrait::Expression* mutable_post_join_filter(); - void set_allocated_post_join_filter(::substrait::Expression* post_join_filter); - private: - const ::substrait::Expression& _internal_post_join_filter() const; - ::substrait::Expression* _internal_mutable_post_join_filter(); - public: - void unsafe_arena_set_allocated_post_join_filter( - ::substrait::Expression* post_join_filter); - ::substrait::Expression* unsafe_arena_release_post_join_filter(); - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // .substrait.JoinRel.JoinType type = 6; - void clear_type(); - ::substrait::JoinRel_JoinType type() const; - void set_type(::substrait::JoinRel_JoinType value); - private: - ::substrait::JoinRel_JoinType _internal_type() const; - void _internal_set_type(::substrait::JoinRel_JoinType value); - public: - - // @@protoc_insertion_point(class_scope:substrait.JoinRel) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::RelCommon* common_; - ::substrait::Rel* left_; - ::substrait::Rel* right_; - ::substrait::Expression* expression_; - ::substrait::Expression* post_join_filter_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - int type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class FetchRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FetchRel) */ { - public: - inline FetchRel() : FetchRel(nullptr) {} - ~FetchRel() override; - explicit constexpr FetchRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FetchRel(const FetchRel& from); - FetchRel(FetchRel&& from) noexcept - : FetchRel() { - *this = ::std::move(from); - } - - inline FetchRel& operator=(const FetchRel& from) { - CopyFrom(from); - return *this; - } - inline FetchRel& operator=(FetchRel&& 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 FetchRel& default_instance() { - return *internal_default_instance(); - } - static inline const FetchRel* internal_default_instance() { - return reinterpret_cast( - &_FetchRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 14; - - friend void swap(FetchRel& a, FetchRel& b) { - a.Swap(&b); - } - inline void Swap(FetchRel* 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(FetchRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FetchRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FetchRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FetchRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FetchRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FetchRel"; - } - protected: - explicit FetchRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kCommonFieldNumber = 1, - kInputFieldNumber = 2, - kAdvancedExtensionFieldNumber = 10, - kOffsetFieldNumber = 3, - kCountFieldNumber = 4, - }; - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .substrait.Rel input = 2; - bool has_input() const; - private: - bool _internal_has_input() const; - public: - void clear_input(); - const ::substrait::Rel& input() const; - PROTOBUF_NODISCARD ::substrait::Rel* release_input(); - ::substrait::Rel* mutable_input(); - void set_allocated_input(::substrait::Rel* input); - private: - const ::substrait::Rel& _internal_input() const; - ::substrait::Rel* _internal_mutable_input(); - public: - void unsafe_arena_set_allocated_input( - ::substrait::Rel* input); - ::substrait::Rel* unsafe_arena_release_input(); - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // int64 offset = 3; - void clear_offset(); - int64_t offset() const; - void set_offset(int64_t value); - private: - int64_t _internal_offset() const; - void _internal_set_offset(int64_t value); - public: - - // int64 count = 4; - void clear_count(); - int64_t count() const; - void set_count(int64_t value); - private: - int64_t _internal_count() const; - void _internal_set_count(int64_t value); - public: - - // @@protoc_insertion_point(class_scope:substrait.FetchRel) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::RelCommon* common_; - ::substrait::Rel* input_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - int64_t offset_; - int64_t count_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class AggregateRel_Grouping final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel.Grouping) */ { - public: - inline AggregateRel_Grouping() : AggregateRel_Grouping(nullptr) {} - ~AggregateRel_Grouping() override; - explicit constexpr AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - AggregateRel_Grouping(const AggregateRel_Grouping& from); - AggregateRel_Grouping(AggregateRel_Grouping&& from) noexcept - : AggregateRel_Grouping() { - *this = ::std::move(from); - } - - inline AggregateRel_Grouping& operator=(const AggregateRel_Grouping& from) { - CopyFrom(from); - return *this; - } - inline AggregateRel_Grouping& operator=(AggregateRel_Grouping&& 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 AggregateRel_Grouping& default_instance() { - return *internal_default_instance(); - } - static inline const AggregateRel_Grouping* internal_default_instance() { - return reinterpret_cast( - &_AggregateRel_Grouping_default_instance_); - } - static constexpr int kIndexInFileMessages = - 15; - - friend void swap(AggregateRel_Grouping& a, AggregateRel_Grouping& b) { - a.Swap(&b); - } - inline void Swap(AggregateRel_Grouping* 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(AggregateRel_Grouping* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - AggregateRel_Grouping* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const AggregateRel_Grouping& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const AggregateRel_Grouping& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(AggregateRel_Grouping* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.AggregateRel.Grouping"; - } - protected: - explicit AggregateRel_Grouping(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kGroupingExpressionsFieldNumber = 1, - }; - // repeated .substrait.Expression grouping_expressions = 1; - int grouping_expressions_size() const; - private: - int _internal_grouping_expressions_size() const; - public: - void clear_grouping_expressions(); - ::substrait::Expression* mutable_grouping_expressions(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* - mutable_grouping_expressions(); - private: - const ::substrait::Expression& _internal_grouping_expressions(int index) const; - ::substrait::Expression* _internal_add_grouping_expressions(); - public: - const ::substrait::Expression& grouping_expressions(int index) const; - ::substrait::Expression* add_grouping_expressions(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& - grouping_expressions() const; - - // @@protoc_insertion_point(class_scope:substrait.AggregateRel.Grouping) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression > grouping_expressions_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class AggregateRel_Measure final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel.Measure) */ { - public: - inline AggregateRel_Measure() : AggregateRel_Measure(nullptr) {} - ~AggregateRel_Measure() override; - explicit constexpr AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - AggregateRel_Measure(const AggregateRel_Measure& from); - AggregateRel_Measure(AggregateRel_Measure&& from) noexcept - : AggregateRel_Measure() { - *this = ::std::move(from); - } - - inline AggregateRel_Measure& operator=(const AggregateRel_Measure& from) { - CopyFrom(from); - return *this; - } - inline AggregateRel_Measure& operator=(AggregateRel_Measure&& 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 AggregateRel_Measure& default_instance() { - return *internal_default_instance(); - } - static inline const AggregateRel_Measure* internal_default_instance() { - return reinterpret_cast( - &_AggregateRel_Measure_default_instance_); - } - static constexpr int kIndexInFileMessages = - 16; - - friend void swap(AggregateRel_Measure& a, AggregateRel_Measure& b) { - a.Swap(&b); - } - inline void Swap(AggregateRel_Measure* 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(AggregateRel_Measure* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - AggregateRel_Measure* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const AggregateRel_Measure& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const AggregateRel_Measure& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(AggregateRel_Measure* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.AggregateRel.Measure"; - } - protected: - explicit AggregateRel_Measure(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kMeasureFieldNumber = 1, - kFilterFieldNumber = 2, - }; - // .substrait.AggregateFunction measure = 1; - bool has_measure() const; - private: - bool _internal_has_measure() const; - public: - void clear_measure(); - const ::substrait::AggregateFunction& measure() const; - PROTOBUF_NODISCARD ::substrait::AggregateFunction* release_measure(); - ::substrait::AggregateFunction* mutable_measure(); - void set_allocated_measure(::substrait::AggregateFunction* measure); - private: - const ::substrait::AggregateFunction& _internal_measure() const; - ::substrait::AggregateFunction* _internal_mutable_measure(); - public: - void unsafe_arena_set_allocated_measure( - ::substrait::AggregateFunction* measure); - ::substrait::AggregateFunction* unsafe_arena_release_measure(); - - // .substrait.Expression filter = 2; - bool has_filter() const; - private: - bool _internal_has_filter() const; - public: - void clear_filter(); - const ::substrait::Expression& filter() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_filter(); - ::substrait::Expression* mutable_filter(); - void set_allocated_filter(::substrait::Expression* filter); - private: - const ::substrait::Expression& _internal_filter() const; - ::substrait::Expression* _internal_mutable_filter(); - public: - void unsafe_arena_set_allocated_filter( - ::substrait::Expression* filter); - ::substrait::Expression* unsafe_arena_release_filter(); - - // @@protoc_insertion_point(class_scope:substrait.AggregateRel.Measure) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::AggregateFunction* measure_; - ::substrait::Expression* filter_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class AggregateRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.AggregateRel) */ { - public: - inline AggregateRel() : AggregateRel(nullptr) {} - ~AggregateRel() override; - explicit constexpr AggregateRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - AggregateRel(const AggregateRel& from); - AggregateRel(AggregateRel&& from) noexcept - : AggregateRel() { - *this = ::std::move(from); - } - - inline AggregateRel& operator=(const AggregateRel& from) { - CopyFrom(from); - return *this; - } - inline AggregateRel& operator=(AggregateRel&& 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 AggregateRel& default_instance() { - return *internal_default_instance(); - } - static inline const AggregateRel* internal_default_instance() { - return reinterpret_cast( - &_AggregateRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 17; - - friend void swap(AggregateRel& a, AggregateRel& b) { - a.Swap(&b); - } - inline void Swap(AggregateRel* 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(AggregateRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - AggregateRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const AggregateRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const AggregateRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(AggregateRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.AggregateRel"; - } - protected: - explicit AggregateRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef AggregateRel_Grouping Grouping; - typedef AggregateRel_Measure Measure; - - // accessors ------------------------------------------------------- - - enum : int { - kGroupingsFieldNumber = 3, - kMeasuresFieldNumber = 4, - kCommonFieldNumber = 1, - kInputFieldNumber = 2, - kAdvancedExtensionFieldNumber = 10, - }; - // repeated .substrait.AggregateRel.Grouping groupings = 3; - int groupings_size() const; - private: - int _internal_groupings_size() const; - public: - void clear_groupings(); - ::substrait::AggregateRel_Grouping* mutable_groupings(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >* - mutable_groupings(); - private: - const ::substrait::AggregateRel_Grouping& _internal_groupings(int index) const; - ::substrait::AggregateRel_Grouping* _internal_add_groupings(); - public: - const ::substrait::AggregateRel_Grouping& groupings(int index) const; - ::substrait::AggregateRel_Grouping* add_groupings(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >& - groupings() const; - - // repeated .substrait.AggregateRel.Measure measures = 4; - int measures_size() const; - private: - int _internal_measures_size() const; - public: - void clear_measures(); - ::substrait::AggregateRel_Measure* mutable_measures(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >* - mutable_measures(); - private: - const ::substrait::AggregateRel_Measure& _internal_measures(int index) const; - ::substrait::AggregateRel_Measure* _internal_add_measures(); - public: - const ::substrait::AggregateRel_Measure& measures(int index) const; - ::substrait::AggregateRel_Measure* add_measures(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >& - measures() const; - - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .substrait.Rel input = 2; - bool has_input() const; - private: - bool _internal_has_input() const; - public: - void clear_input(); - const ::substrait::Rel& input() const; - PROTOBUF_NODISCARD ::substrait::Rel* release_input(); - ::substrait::Rel* mutable_input(); - void set_allocated_input(::substrait::Rel* input); - private: - const ::substrait::Rel& _internal_input() const; - ::substrait::Rel* _internal_mutable_input(); - public: - void unsafe_arena_set_allocated_input( - ::substrait::Rel* input); - ::substrait::Rel* unsafe_arena_release_input(); - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // @@protoc_insertion_point(class_scope:substrait.AggregateRel) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping > groupings_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure > measures_; - ::substrait::RelCommon* common_; - ::substrait::Rel* input_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class SortRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SortRel) */ { - public: - inline SortRel() : SortRel(nullptr) {} - ~SortRel() override; - explicit constexpr SortRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SortRel(const SortRel& from); - SortRel(SortRel&& from) noexcept - : SortRel() { - *this = ::std::move(from); - } - - inline SortRel& operator=(const SortRel& from) { - CopyFrom(from); - return *this; - } - inline SortRel& operator=(SortRel&& 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 SortRel& default_instance() { - return *internal_default_instance(); - } - static inline const SortRel* internal_default_instance() { - return reinterpret_cast( - &_SortRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 18; - - friend void swap(SortRel& a, SortRel& b) { - a.Swap(&b); - } - inline void Swap(SortRel* 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(SortRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SortRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SortRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const SortRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SortRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.SortRel"; - } - protected: - explicit SortRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kSortsFieldNumber = 3, - kCommonFieldNumber = 1, - kInputFieldNumber = 2, - kAdvancedExtensionFieldNumber = 10, - }; - // repeated .substrait.SortField sorts = 3; - int sorts_size() const; - private: - int _internal_sorts_size() const; - public: - void clear_sorts(); - ::substrait::SortField* mutable_sorts(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* - mutable_sorts(); - private: - const ::substrait::SortField& _internal_sorts(int index) const; - ::substrait::SortField* _internal_add_sorts(); - public: - const ::substrait::SortField& sorts(int index) const; - ::substrait::SortField* add_sorts(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& - sorts() const; - - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .substrait.Rel input = 2; - bool has_input() const; - private: - bool _internal_has_input() const; - public: - void clear_input(); - const ::substrait::Rel& input() const; - PROTOBUF_NODISCARD ::substrait::Rel* release_input(); - ::substrait::Rel* mutable_input(); - void set_allocated_input(::substrait::Rel* input); - private: - const ::substrait::Rel& _internal_input() const; - ::substrait::Rel* _internal_mutable_input(); - public: - void unsafe_arena_set_allocated_input( - ::substrait::Rel* input); - ::substrait::Rel* unsafe_arena_release_input(); - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // @@protoc_insertion_point(class_scope:substrait.SortRel) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField > sorts_; - ::substrait::RelCommon* common_; - ::substrait::Rel* input_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class FilterRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.FilterRel) */ { - public: - inline FilterRel() : FilterRel(nullptr) {} - ~FilterRel() override; - explicit constexpr FilterRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - FilterRel(const FilterRel& from); - FilterRel(FilterRel&& from) noexcept - : FilterRel() { - *this = ::std::move(from); - } - - inline FilterRel& operator=(const FilterRel& from) { - CopyFrom(from); - return *this; - } - inline FilterRel& operator=(FilterRel&& 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 FilterRel& default_instance() { - return *internal_default_instance(); - } - static inline const FilterRel* internal_default_instance() { - return reinterpret_cast( - &_FilterRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 19; - - friend void swap(FilterRel& a, FilterRel& b) { - a.Swap(&b); - } - inline void Swap(FilterRel* 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(FilterRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FilterRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const FilterRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const FilterRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(FilterRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.FilterRel"; - } - protected: - explicit FilterRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kCommonFieldNumber = 1, - kInputFieldNumber = 2, - kConditionFieldNumber = 3, - kAdvancedExtensionFieldNumber = 10, - }; - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .substrait.Rel input = 2; - bool has_input() const; - private: - bool _internal_has_input() const; - public: - void clear_input(); - const ::substrait::Rel& input() const; - PROTOBUF_NODISCARD ::substrait::Rel* release_input(); - ::substrait::Rel* mutable_input(); - void set_allocated_input(::substrait::Rel* input); - private: - const ::substrait::Rel& _internal_input() const; - ::substrait::Rel* _internal_mutable_input(); - public: - void unsafe_arena_set_allocated_input( - ::substrait::Rel* input); - ::substrait::Rel* unsafe_arena_release_input(); - - // .substrait.Expression condition = 3; - bool has_condition() const; - private: - bool _internal_has_condition() const; - public: - void clear_condition(); - const ::substrait::Expression& condition() const; - PROTOBUF_NODISCARD ::substrait::Expression* release_condition(); - ::substrait::Expression* mutable_condition(); - void set_allocated_condition(::substrait::Expression* condition); - private: - const ::substrait::Expression& _internal_condition() const; - ::substrait::Expression* _internal_mutable_condition(); - public: - void unsafe_arena_set_allocated_condition( - ::substrait::Expression* condition); - ::substrait::Expression* unsafe_arena_release_condition(); - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // @@protoc_insertion_point(class_scope:substrait.FilterRel) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::RelCommon* common_; - ::substrait::Rel* input_; - ::substrait::Expression* condition_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class SetRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.SetRel) */ { - public: - inline SetRel() : SetRel(nullptr) {} - ~SetRel() override; - explicit constexpr SetRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - SetRel(const SetRel& from); - SetRel(SetRel&& from) noexcept - : SetRel() { - *this = ::std::move(from); - } - - inline SetRel& operator=(const SetRel& from) { - CopyFrom(from); - return *this; - } - inline SetRel& operator=(SetRel&& 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 SetRel& default_instance() { - return *internal_default_instance(); - } - static inline const SetRel* internal_default_instance() { - return reinterpret_cast( - &_SetRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 20; - - friend void swap(SetRel& a, SetRel& b) { - a.Swap(&b); - } - inline void Swap(SetRel* 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(SetRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SetRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const SetRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const SetRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(SetRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.SetRel"; - } - protected: - explicit SetRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef SetRel_SetOp SetOp; - static constexpr SetOp SET_OP_UNSPECIFIED = - SetRel_SetOp_SET_OP_UNSPECIFIED; - static constexpr SetOp SET_OP_MINUS_PRIMARY = - SetRel_SetOp_SET_OP_MINUS_PRIMARY; - static constexpr SetOp SET_OP_MINUS_MULTISET = - SetRel_SetOp_SET_OP_MINUS_MULTISET; - static constexpr SetOp SET_OP_INTERSECTION_PRIMARY = - SetRel_SetOp_SET_OP_INTERSECTION_PRIMARY; - static constexpr SetOp SET_OP_INTERSECTION_MULTISET = - SetRel_SetOp_SET_OP_INTERSECTION_MULTISET; - static constexpr SetOp SET_OP_UNION_DISTINCT = - SetRel_SetOp_SET_OP_UNION_DISTINCT; - static constexpr SetOp SET_OP_UNION_ALL = - SetRel_SetOp_SET_OP_UNION_ALL; - static inline bool SetOp_IsValid(int value) { - return SetRel_SetOp_IsValid(value); - } - static constexpr SetOp SetOp_MIN = - SetRel_SetOp_SetOp_MIN; - static constexpr SetOp SetOp_MAX = - SetRel_SetOp_SetOp_MAX; - static constexpr int SetOp_ARRAYSIZE = - SetRel_SetOp_SetOp_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - SetOp_descriptor() { - return SetRel_SetOp_descriptor(); - } - template - static inline const std::string& SetOp_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function SetOp_Name."); - return SetRel_SetOp_Name(enum_t_value); - } - static inline bool SetOp_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - SetOp* value) { - return SetRel_SetOp_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kInputsFieldNumber = 2, - kCommonFieldNumber = 1, - kAdvancedExtensionFieldNumber = 10, - kOpFieldNumber = 3, - }; - // repeated .substrait.Rel inputs = 2; - int inputs_size() const; - private: - int _internal_inputs_size() const; - public: - void clear_inputs(); - ::substrait::Rel* mutable_inputs(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >* - mutable_inputs(); - private: - const ::substrait::Rel& _internal_inputs(int index) const; - ::substrait::Rel* _internal_add_inputs(); - public: - const ::substrait::Rel& inputs(int index) const; - ::substrait::Rel* add_inputs(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >& - inputs() const; - - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .substrait.extensions.AdvancedExtension advanced_extension = 10; - bool has_advanced_extension() const; - private: - bool _internal_has_advanced_extension() const; - public: - void clear_advanced_extension(); - const ::substrait::extensions::AdvancedExtension& advanced_extension() const; - PROTOBUF_NODISCARD ::substrait::extensions::AdvancedExtension* release_advanced_extension(); - ::substrait::extensions::AdvancedExtension* mutable_advanced_extension(); - void set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension); - private: - const ::substrait::extensions::AdvancedExtension& _internal_advanced_extension() const; - ::substrait::extensions::AdvancedExtension* _internal_mutable_advanced_extension(); - public: - void unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension); - ::substrait::extensions::AdvancedExtension* unsafe_arena_release_advanced_extension(); - - // .substrait.SetRel.SetOp op = 3; - void clear_op(); - ::substrait::SetRel_SetOp op() const; - void set_op(::substrait::SetRel_SetOp value); - private: - ::substrait::SetRel_SetOp _internal_op() const; - void _internal_set_op(::substrait::SetRel_SetOp value); - public: - - // @@protoc_insertion_point(class_scope:substrait.SetRel) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel > inputs_; - ::substrait::RelCommon* common_; - ::substrait::extensions::AdvancedExtension* advanced_extension_; - int op_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class ExtensionSingleRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionSingleRel) */ { - public: - inline ExtensionSingleRel() : ExtensionSingleRel(nullptr) {} - ~ExtensionSingleRel() override; - explicit constexpr ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ExtensionSingleRel(const ExtensionSingleRel& from); - ExtensionSingleRel(ExtensionSingleRel&& from) noexcept - : ExtensionSingleRel() { - *this = ::std::move(from); - } - - inline ExtensionSingleRel& operator=(const ExtensionSingleRel& from) { - CopyFrom(from); - return *this; - } - inline ExtensionSingleRel& operator=(ExtensionSingleRel&& 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 ExtensionSingleRel& default_instance() { - return *internal_default_instance(); - } - static inline const ExtensionSingleRel* internal_default_instance() { - return reinterpret_cast( - &_ExtensionSingleRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 21; - - friend void swap(ExtensionSingleRel& a, ExtensionSingleRel& b) { - a.Swap(&b); - } - inline void Swap(ExtensionSingleRel* 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(ExtensionSingleRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ExtensionSingleRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ExtensionSingleRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ExtensionSingleRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ExtensionSingleRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ExtensionSingleRel"; - } - protected: - explicit ExtensionSingleRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kCommonFieldNumber = 1, - kInputFieldNumber = 2, - kDetailFieldNumber = 3, - }; - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .substrait.Rel input = 2; - bool has_input() const; - private: - bool _internal_has_input() const; - public: - void clear_input(); - const ::substrait::Rel& input() const; - PROTOBUF_NODISCARD ::substrait::Rel* release_input(); - ::substrait::Rel* mutable_input(); - void set_allocated_input(::substrait::Rel* input); - private: - const ::substrait::Rel& _internal_input() const; - ::substrait::Rel* _internal_mutable_input(); - public: - void unsafe_arena_set_allocated_input( - ::substrait::Rel* input); - ::substrait::Rel* unsafe_arena_release_input(); - - // .google.protobuf.Any detail = 3; - bool has_detail() const; - private: - bool _internal_has_detail() const; - public: - void clear_detail(); - const ::PROTOBUF_NAMESPACE_ID::Any& detail() const; - PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail(); - ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); - void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail); - private: - const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; - ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); - public: - void unsafe_arena_set_allocated_detail( - ::PROTOBUF_NAMESPACE_ID::Any* detail); - ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); - - // @@protoc_insertion_point(class_scope:substrait.ExtensionSingleRel) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::RelCommon* common_; - ::substrait::Rel* input_; - ::PROTOBUF_NAMESPACE_ID::Any* detail_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class ExtensionLeafRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionLeafRel) */ { - public: - inline ExtensionLeafRel() : ExtensionLeafRel(nullptr) {} - ~ExtensionLeafRel() override; - explicit constexpr ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ExtensionLeafRel(const ExtensionLeafRel& from); - ExtensionLeafRel(ExtensionLeafRel&& from) noexcept - : ExtensionLeafRel() { - *this = ::std::move(from); - } - - inline ExtensionLeafRel& operator=(const ExtensionLeafRel& from) { - CopyFrom(from); - return *this; - } - inline ExtensionLeafRel& operator=(ExtensionLeafRel&& 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 ExtensionLeafRel& default_instance() { - return *internal_default_instance(); - } - static inline const ExtensionLeafRel* internal_default_instance() { - return reinterpret_cast( - &_ExtensionLeafRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 22; - - friend void swap(ExtensionLeafRel& a, ExtensionLeafRel& b) { - a.Swap(&b); - } - inline void Swap(ExtensionLeafRel* 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(ExtensionLeafRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ExtensionLeafRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ExtensionLeafRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ExtensionLeafRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ExtensionLeafRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ExtensionLeafRel"; - } - protected: - explicit ExtensionLeafRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kCommonFieldNumber = 1, - kDetailFieldNumber = 2, - }; - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .google.protobuf.Any detail = 2; - bool has_detail() const; - private: - bool _internal_has_detail() const; - public: - void clear_detail(); - const ::PROTOBUF_NAMESPACE_ID::Any& detail() const; - PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail(); - ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); - void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail); - private: - const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; - ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); - public: - void unsafe_arena_set_allocated_detail( - ::PROTOBUF_NAMESPACE_ID::Any* detail); - ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); - - // @@protoc_insertion_point(class_scope:substrait.ExtensionLeafRel) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::RelCommon* common_; - ::PROTOBUF_NAMESPACE_ID::Any* detail_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class ExtensionMultiRel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.ExtensionMultiRel) */ { - public: - inline ExtensionMultiRel() : ExtensionMultiRel(nullptr) {} - ~ExtensionMultiRel() override; - explicit constexpr ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - ExtensionMultiRel(const ExtensionMultiRel& from); - ExtensionMultiRel(ExtensionMultiRel&& from) noexcept - : ExtensionMultiRel() { - *this = ::std::move(from); - } - - inline ExtensionMultiRel& operator=(const ExtensionMultiRel& from) { - CopyFrom(from); - return *this; - } - inline ExtensionMultiRel& operator=(ExtensionMultiRel&& 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 ExtensionMultiRel& default_instance() { - return *internal_default_instance(); - } - static inline const ExtensionMultiRel* internal_default_instance() { - return reinterpret_cast( - &_ExtensionMultiRel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 23; - - friend void swap(ExtensionMultiRel& a, ExtensionMultiRel& b) { - a.Swap(&b); - } - inline void Swap(ExtensionMultiRel* 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(ExtensionMultiRel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ExtensionMultiRel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const ExtensionMultiRel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const ExtensionMultiRel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(ExtensionMultiRel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.ExtensionMultiRel"; - } - protected: - explicit ExtensionMultiRel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kInputsFieldNumber = 2, - kCommonFieldNumber = 1, - kDetailFieldNumber = 3, - }; - // repeated .substrait.Rel inputs = 2; - int inputs_size() const; - private: - int _internal_inputs_size() const; - public: - void clear_inputs(); - ::substrait::Rel* mutable_inputs(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >* - mutable_inputs(); - private: - const ::substrait::Rel& _internal_inputs(int index) const; - ::substrait::Rel* _internal_add_inputs(); - public: - const ::substrait::Rel& inputs(int index) const; - ::substrait::Rel* add_inputs(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >& - inputs() const; - - // .substrait.RelCommon common = 1; - bool has_common() const; - private: - bool _internal_has_common() const; - public: - void clear_common(); - const ::substrait::RelCommon& common() const; - PROTOBUF_NODISCARD ::substrait::RelCommon* release_common(); - ::substrait::RelCommon* mutable_common(); - void set_allocated_common(::substrait::RelCommon* common); - private: - const ::substrait::RelCommon& _internal_common() const; - ::substrait::RelCommon* _internal_mutable_common(); - public: - void unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common); - ::substrait::RelCommon* unsafe_arena_release_common(); - - // .google.protobuf.Any detail = 3; - bool has_detail() const; - private: - bool _internal_has_detail() const; - public: - void clear_detail(); - const ::PROTOBUF_NAMESPACE_ID::Any& detail() const; - PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_detail(); - ::PROTOBUF_NAMESPACE_ID::Any* mutable_detail(); - void set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail); - private: - const ::PROTOBUF_NAMESPACE_ID::Any& _internal_detail() const; - ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_detail(); - public: - void unsafe_arena_set_allocated_detail( - ::PROTOBUF_NAMESPACE_ID::Any* detail); - ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_detail(); - - // @@protoc_insertion_point(class_scope:substrait.ExtensionMultiRel) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel > inputs_; - ::substrait::RelCommon* common_; - ::PROTOBUF_NAMESPACE_ID::Any* detail_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class RelRoot final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.RelRoot) */ { - public: - inline RelRoot() : RelRoot(nullptr) {} - ~RelRoot() override; - explicit constexpr RelRoot(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - RelRoot(const RelRoot& from); - RelRoot(RelRoot&& from) noexcept - : RelRoot() { - *this = ::std::move(from); - } - - inline RelRoot& operator=(const RelRoot& from) { - CopyFrom(from); - return *this; - } - inline RelRoot& operator=(RelRoot&& 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 RelRoot& default_instance() { - return *internal_default_instance(); - } - static inline const RelRoot* internal_default_instance() { - return reinterpret_cast( - &_RelRoot_default_instance_); - } - static constexpr int kIndexInFileMessages = - 24; - - friend void swap(RelRoot& a, RelRoot& b) { - a.Swap(&b); - } - inline void Swap(RelRoot* 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(RelRoot* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RelRoot* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const RelRoot& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const RelRoot& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(RelRoot* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.RelRoot"; - } - protected: - explicit RelRoot(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kNamesFieldNumber = 2, - kInputFieldNumber = 1, - }; - // repeated string names = 2; - int names_size() const; - private: - int _internal_names_size() const; - public: - void clear_names(); - const std::string& names(int index) const; - std::string* mutable_names(int index); - void set_names(int index, const std::string& value); - void set_names(int index, std::string&& value); - void set_names(int index, const char* value); - void set_names(int index, const char* value, size_t size); - std::string* add_names(); - void add_names(const std::string& value); - void add_names(std::string&& value); - void add_names(const char* value); - void add_names(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); - private: - const std::string& _internal_names(int index) const; - std::string* _internal_add_names(); - public: - - // .substrait.Rel input = 1; - bool has_input() const; - private: - bool _internal_has_input() const; - public: - void clear_input(); - const ::substrait::Rel& input() const; - PROTOBUF_NODISCARD ::substrait::Rel* release_input(); - ::substrait::Rel* mutable_input(); - void set_allocated_input(::substrait::Rel* input); - private: - const ::substrait::Rel& _internal_input() const; - ::substrait::Rel* _internal_mutable_input(); - public: - void unsafe_arena_set_allocated_input( - ::substrait::Rel* input); - ::substrait::Rel* unsafe_arena_release_input(); - - // @@protoc_insertion_point(class_scope:substrait.RelRoot) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::substrait::Rel* input_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// ------------------------------------------------------------------- - -class Rel final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Rel) */ { - public: - inline Rel() : Rel(nullptr) {} - ~Rel() override; - explicit constexpr Rel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Rel(const Rel& from); - Rel(Rel&& from) noexcept - : Rel() { - *this = ::std::move(from); - } - - inline Rel& operator=(const Rel& from) { - CopyFrom(from); - return *this; - } - inline Rel& operator=(Rel&& 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 Rel& default_instance() { - return *internal_default_instance(); - } - enum RelTypeCase { - kRead = 1, - kFilter = 2, - kFetch = 3, - kAggregate = 4, - kSort = 5, - kJoin = 6, - kProject = 7, - kSet = 8, - kExtensionSingle = 9, - kExtensionMulti = 10, - kExtensionLeaf = 11, - REL_TYPE_NOT_SET = 0, - }; - - static inline const Rel* internal_default_instance() { - return reinterpret_cast( - &_Rel_default_instance_); - } - static constexpr int kIndexInFileMessages = - 25; - - friend void swap(Rel& a, Rel& b) { - a.Swap(&b); - } - inline void Swap(Rel* 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(Rel* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Rel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Rel& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Rel& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Rel* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Rel"; - } - protected: - explicit Rel(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kReadFieldNumber = 1, - kFilterFieldNumber = 2, - kFetchFieldNumber = 3, - kAggregateFieldNumber = 4, - kSortFieldNumber = 5, - kJoinFieldNumber = 6, - kProjectFieldNumber = 7, - kSetFieldNumber = 8, - kExtensionSingleFieldNumber = 9, - kExtensionMultiFieldNumber = 10, - kExtensionLeafFieldNumber = 11, - }; - // .substrait.ReadRel read = 1; - bool has_read() const; - private: - bool _internal_has_read() const; - public: - void clear_read(); - const ::substrait::ReadRel& read() const; - PROTOBUF_NODISCARD ::substrait::ReadRel* release_read(); - ::substrait::ReadRel* mutable_read(); - void set_allocated_read(::substrait::ReadRel* read); - private: - const ::substrait::ReadRel& _internal_read() const; - ::substrait::ReadRel* _internal_mutable_read(); - public: - void unsafe_arena_set_allocated_read( - ::substrait::ReadRel* read); - ::substrait::ReadRel* unsafe_arena_release_read(); - - // .substrait.FilterRel filter = 2; - bool has_filter() const; - private: - bool _internal_has_filter() const; - public: - void clear_filter(); - const ::substrait::FilterRel& filter() const; - PROTOBUF_NODISCARD ::substrait::FilterRel* release_filter(); - ::substrait::FilterRel* mutable_filter(); - void set_allocated_filter(::substrait::FilterRel* filter); - private: - const ::substrait::FilterRel& _internal_filter() const; - ::substrait::FilterRel* _internal_mutable_filter(); - public: - void unsafe_arena_set_allocated_filter( - ::substrait::FilterRel* filter); - ::substrait::FilterRel* unsafe_arena_release_filter(); - - // .substrait.FetchRel fetch = 3; - bool has_fetch() const; - private: - bool _internal_has_fetch() const; - public: - void clear_fetch(); - const ::substrait::FetchRel& fetch() const; - PROTOBUF_NODISCARD ::substrait::FetchRel* release_fetch(); - ::substrait::FetchRel* mutable_fetch(); - void set_allocated_fetch(::substrait::FetchRel* fetch); - private: - const ::substrait::FetchRel& _internal_fetch() const; - ::substrait::FetchRel* _internal_mutable_fetch(); - public: - void unsafe_arena_set_allocated_fetch( - ::substrait::FetchRel* fetch); - ::substrait::FetchRel* unsafe_arena_release_fetch(); - - // .substrait.AggregateRel aggregate = 4; - bool has_aggregate() const; - private: - bool _internal_has_aggregate() const; - public: - void clear_aggregate(); - const ::substrait::AggregateRel& aggregate() const; - PROTOBUF_NODISCARD ::substrait::AggregateRel* release_aggregate(); - ::substrait::AggregateRel* mutable_aggregate(); - void set_allocated_aggregate(::substrait::AggregateRel* aggregate); - private: - const ::substrait::AggregateRel& _internal_aggregate() const; - ::substrait::AggregateRel* _internal_mutable_aggregate(); - public: - void unsafe_arena_set_allocated_aggregate( - ::substrait::AggregateRel* aggregate); - ::substrait::AggregateRel* unsafe_arena_release_aggregate(); - - // .substrait.SortRel sort = 5; - bool has_sort() const; - private: - bool _internal_has_sort() const; - public: - void clear_sort(); - const ::substrait::SortRel& sort() const; - PROTOBUF_NODISCARD ::substrait::SortRel* release_sort(); - ::substrait::SortRel* mutable_sort(); - void set_allocated_sort(::substrait::SortRel* sort); - private: - const ::substrait::SortRel& _internal_sort() const; - ::substrait::SortRel* _internal_mutable_sort(); - public: - void unsafe_arena_set_allocated_sort( - ::substrait::SortRel* sort); - ::substrait::SortRel* unsafe_arena_release_sort(); - - // .substrait.JoinRel join = 6; - bool has_join() const; - private: - bool _internal_has_join() const; - public: - void clear_join(); - const ::substrait::JoinRel& join() const; - PROTOBUF_NODISCARD ::substrait::JoinRel* release_join(); - ::substrait::JoinRel* mutable_join(); - void set_allocated_join(::substrait::JoinRel* join); - private: - const ::substrait::JoinRel& _internal_join() const; - ::substrait::JoinRel* _internal_mutable_join(); - public: - void unsafe_arena_set_allocated_join( - ::substrait::JoinRel* join); - ::substrait::JoinRel* unsafe_arena_release_join(); - - // .substrait.ProjectRel project = 7; - bool has_project() const; - private: - bool _internal_has_project() const; - public: - void clear_project(); - const ::substrait::ProjectRel& project() const; - PROTOBUF_NODISCARD ::substrait::ProjectRel* release_project(); - ::substrait::ProjectRel* mutable_project(); - void set_allocated_project(::substrait::ProjectRel* project); - private: - const ::substrait::ProjectRel& _internal_project() const; - ::substrait::ProjectRel* _internal_mutable_project(); - public: - void unsafe_arena_set_allocated_project( - ::substrait::ProjectRel* project); - ::substrait::ProjectRel* unsafe_arena_release_project(); - - // .substrait.SetRel set = 8; - bool has_set() const; - private: - bool _internal_has_set() const; - public: - void clear_set(); - const ::substrait::SetRel& set() const; - PROTOBUF_NODISCARD ::substrait::SetRel* release_set(); - ::substrait::SetRel* mutable_set(); - void set_allocated_set(::substrait::SetRel* set); - private: - const ::substrait::SetRel& _internal_set() const; - ::substrait::SetRel* _internal_mutable_set(); - public: - void unsafe_arena_set_allocated_set( - ::substrait::SetRel* set); - ::substrait::SetRel* unsafe_arena_release_set(); - - // .substrait.ExtensionSingleRel extension_single = 9; - bool has_extension_single() const; - private: - bool _internal_has_extension_single() const; - public: - void clear_extension_single(); - const ::substrait::ExtensionSingleRel& extension_single() const; - PROTOBUF_NODISCARD ::substrait::ExtensionSingleRel* release_extension_single(); - ::substrait::ExtensionSingleRel* mutable_extension_single(); - void set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single); - private: - const ::substrait::ExtensionSingleRel& _internal_extension_single() const; - ::substrait::ExtensionSingleRel* _internal_mutable_extension_single(); - public: - void unsafe_arena_set_allocated_extension_single( - ::substrait::ExtensionSingleRel* extension_single); - ::substrait::ExtensionSingleRel* unsafe_arena_release_extension_single(); - - // .substrait.ExtensionMultiRel extension_multi = 10; - bool has_extension_multi() const; - private: - bool _internal_has_extension_multi() const; - public: - void clear_extension_multi(); - const ::substrait::ExtensionMultiRel& extension_multi() const; - PROTOBUF_NODISCARD ::substrait::ExtensionMultiRel* release_extension_multi(); - ::substrait::ExtensionMultiRel* mutable_extension_multi(); - void set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi); - private: - const ::substrait::ExtensionMultiRel& _internal_extension_multi() const; - ::substrait::ExtensionMultiRel* _internal_mutable_extension_multi(); - public: - void unsafe_arena_set_allocated_extension_multi( - ::substrait::ExtensionMultiRel* extension_multi); - ::substrait::ExtensionMultiRel* unsafe_arena_release_extension_multi(); - - // .substrait.ExtensionLeafRel extension_leaf = 11; - bool has_extension_leaf() const; - private: - bool _internal_has_extension_leaf() const; - public: - void clear_extension_leaf(); - const ::substrait::ExtensionLeafRel& extension_leaf() const; - PROTOBUF_NODISCARD ::substrait::ExtensionLeafRel* release_extension_leaf(); - ::substrait::ExtensionLeafRel* mutable_extension_leaf(); - void set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf); - private: - const ::substrait::ExtensionLeafRel& _internal_extension_leaf() const; - ::substrait::ExtensionLeafRel* _internal_mutable_extension_leaf(); - public: - void unsafe_arena_set_allocated_extension_leaf( - ::substrait::ExtensionLeafRel* extension_leaf); - ::substrait::ExtensionLeafRel* unsafe_arena_release_extension_leaf(); - - void clear_rel_type(); - RelTypeCase rel_type_case() const; - // @@protoc_insertion_point(class_scope:substrait.Rel) - private: - class _Internal; - void set_has_read(); - void set_has_filter(); - void set_has_fetch(); - void set_has_aggregate(); - void set_has_sort(); - void set_has_join(); - void set_has_project(); - void set_has_set(); - void set_has_extension_single(); - void set_has_extension_multi(); - void set_has_extension_leaf(); - - inline bool has_rel_type() const; - inline void clear_has_rel_type(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union RelTypeUnion { - constexpr RelTypeUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::ReadRel* read_; - ::substrait::FilterRel* filter_; - ::substrait::FetchRel* fetch_; - ::substrait::AggregateRel* aggregate_; - ::substrait::SortRel* sort_; - ::substrait::JoinRel* join_; - ::substrait::ProjectRel* project_; - ::substrait::SetRel* set_; - ::substrait::ExtensionSingleRel* extension_single_; - ::substrait::ExtensionMultiRel* extension_multi_; - ::substrait::ExtensionLeafRel* extension_leaf_; - } rel_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2frelations_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// RelCommon_Direct - -// ------------------------------------------------------------------- - -// RelCommon_Emit - -// repeated int32 output_mapping = 1; -inline int RelCommon_Emit::_internal_output_mapping_size() const { - return output_mapping_.size(); -} -inline int RelCommon_Emit::output_mapping_size() const { - return _internal_output_mapping_size(); -} -inline void RelCommon_Emit::clear_output_mapping() { - output_mapping_.Clear(); -} -inline int32_t RelCommon_Emit::_internal_output_mapping(int index) const { - return output_mapping_.Get(index); -} -inline int32_t RelCommon_Emit::output_mapping(int index) const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.Emit.output_mapping) - return _internal_output_mapping(index); -} -inline void RelCommon_Emit::set_output_mapping(int index, int32_t value) { - output_mapping_.Set(index, value); - // @@protoc_insertion_point(field_set:substrait.RelCommon.Emit.output_mapping) -} -inline void RelCommon_Emit::_internal_add_output_mapping(int32_t value) { - output_mapping_.Add(value); -} -inline void RelCommon_Emit::add_output_mapping(int32_t value) { - _internal_add_output_mapping(value); - // @@protoc_insertion_point(field_add:substrait.RelCommon.Emit.output_mapping) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& -RelCommon_Emit::_internal_output_mapping() const { - return output_mapping_; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >& -RelCommon_Emit::output_mapping() const { - // @@protoc_insertion_point(field_list:substrait.RelCommon.Emit.output_mapping) - return _internal_output_mapping(); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* -RelCommon_Emit::_internal_mutable_output_mapping() { - return &output_mapping_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >* -RelCommon_Emit::mutable_output_mapping() { - // @@protoc_insertion_point(field_mutable_list:substrait.RelCommon.Emit.output_mapping) - return _internal_mutable_output_mapping(); -} - -// ------------------------------------------------------------------- - -// RelCommon_Hint_Stats - -// double row_count = 1; -inline void RelCommon_Hint_Stats::clear_row_count() { - row_count_ = 0; -} -inline double RelCommon_Hint_Stats::_internal_row_count() const { - return row_count_; -} -inline double RelCommon_Hint_Stats::row_count() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.Stats.row_count) - return _internal_row_count(); -} -inline void RelCommon_Hint_Stats::_internal_set_row_count(double value) { - - row_count_ = value; -} -inline void RelCommon_Hint_Stats::set_row_count(double value) { - _internal_set_row_count(value); - // @@protoc_insertion_point(field_set:substrait.RelCommon.Hint.Stats.row_count) -} - -// double record_size = 2; -inline void RelCommon_Hint_Stats::clear_record_size() { - record_size_ = 0; -} -inline double RelCommon_Hint_Stats::_internal_record_size() const { - return record_size_; -} -inline double RelCommon_Hint_Stats::record_size() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.Stats.record_size) - return _internal_record_size(); -} -inline void RelCommon_Hint_Stats::_internal_set_record_size(double value) { - - record_size_ = value; -} -inline void RelCommon_Hint_Stats::set_record_size(double value) { - _internal_set_record_size(value); - // @@protoc_insertion_point(field_set:substrait.RelCommon.Hint.Stats.record_size) -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool RelCommon_Hint_Stats::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool RelCommon_Hint_Stats::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_Stats::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.Stats.advanced_extension) - return _internal_advanced_extension(); -} -inline void RelCommon_Hint_Stats::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.Stats.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.Stats.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_Stats::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.Stats.advanced_extension) - return _msg; -} -inline void RelCommon_Hint_Stats::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.Stats.advanced_extension) -} - -// ------------------------------------------------------------------- - -// RelCommon_Hint_RuntimeConstraint - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool RelCommon_Hint_RuntimeConstraint::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool RelCommon_Hint_RuntimeConstraint::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint_RuntimeConstraint::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) - return _internal_advanced_extension(); -} -inline void RelCommon_Hint_RuntimeConstraint::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint_RuntimeConstraint::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) - return _msg; -} -inline void RelCommon_Hint_RuntimeConstraint::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.RuntimeConstraint.advanced_extension) -} - -// ------------------------------------------------------------------- - -// RelCommon_Hint - -// .substrait.RelCommon.Hint.Stats stats = 1; -inline bool RelCommon_Hint::_internal_has_stats() const { - return this != internal_default_instance() && stats_ != nullptr; -} -inline bool RelCommon_Hint::has_stats() const { - return _internal_has_stats(); -} -inline void RelCommon_Hint::clear_stats() { - if (GetArenaForAllocation() == nullptr && stats_ != nullptr) { - delete stats_; - } - stats_ = nullptr; -} -inline const ::substrait::RelCommon_Hint_Stats& RelCommon_Hint::_internal_stats() const { - const ::substrait::RelCommon_Hint_Stats* p = stats_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_Hint_Stats_default_instance_); -} -inline const ::substrait::RelCommon_Hint_Stats& RelCommon_Hint::stats() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.stats) - return _internal_stats(); -} -inline void RelCommon_Hint::unsafe_arena_set_allocated_stats( - ::substrait::RelCommon_Hint_Stats* stats) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(stats_); - } - stats_ = stats; - if (stats) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.stats) -} -inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::release_stats() { - - ::substrait::RelCommon_Hint_Stats* temp = stats_; - stats_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::unsafe_arena_release_stats() { - // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.stats) - - ::substrait::RelCommon_Hint_Stats* temp = stats_; - stats_ = nullptr; - return temp; -} -inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::_internal_mutable_stats() { - - if (stats_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint_Stats>(GetArenaForAllocation()); - stats_ = p; - } - return stats_; -} -inline ::substrait::RelCommon_Hint_Stats* RelCommon_Hint::mutable_stats() { - ::substrait::RelCommon_Hint_Stats* _msg = _internal_mutable_stats(); - // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.stats) - return _msg; -} -inline void RelCommon_Hint::set_allocated_stats(::substrait::RelCommon_Hint_Stats* stats) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete stats_; - } - if (stats) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Hint_Stats>::GetOwningArena(stats); - if (message_arena != submessage_arena) { - stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, stats, submessage_arena); - } - - } else { - - } - stats_ = stats; - // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.stats) -} - -// .substrait.RelCommon.Hint.RuntimeConstraint constraint = 2; -inline bool RelCommon_Hint::_internal_has_constraint() const { - return this != internal_default_instance() && constraint_ != nullptr; -} -inline bool RelCommon_Hint::has_constraint() const { - return _internal_has_constraint(); -} -inline void RelCommon_Hint::clear_constraint() { - if (GetArenaForAllocation() == nullptr && constraint_ != nullptr) { - delete constraint_; - } - constraint_ = nullptr; -} -inline const ::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::_internal_constraint() const { - const ::substrait::RelCommon_Hint_RuntimeConstraint* p = constraint_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_Hint_RuntimeConstraint_default_instance_); -} -inline const ::substrait::RelCommon_Hint_RuntimeConstraint& RelCommon_Hint::constraint() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.constraint) - return _internal_constraint(); -} -inline void RelCommon_Hint::unsafe_arena_set_allocated_constraint( - ::substrait::RelCommon_Hint_RuntimeConstraint* constraint) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(constraint_); - } - constraint_ = constraint; - if (constraint) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.constraint) -} -inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::release_constraint() { - - ::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_; - constraint_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::unsafe_arena_release_constraint() { - // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.constraint) - - ::substrait::RelCommon_Hint_RuntimeConstraint* temp = constraint_; - constraint_ = nullptr; - return temp; -} -inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::_internal_mutable_constraint() { - - if (constraint_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint_RuntimeConstraint>(GetArenaForAllocation()); - constraint_ = p; - } - return constraint_; -} -inline ::substrait::RelCommon_Hint_RuntimeConstraint* RelCommon_Hint::mutable_constraint() { - ::substrait::RelCommon_Hint_RuntimeConstraint* _msg = _internal_mutable_constraint(); - // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.constraint) - return _msg; -} -inline void RelCommon_Hint::set_allocated_constraint(::substrait::RelCommon_Hint_RuntimeConstraint* constraint) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete constraint_; - } - if (constraint) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Hint_RuntimeConstraint>::GetOwningArena(constraint); - if (message_arena != submessage_arena) { - constraint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, constraint, submessage_arena); - } - - } else { - - } - constraint_ = constraint; - // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.constraint) -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool RelCommon_Hint::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool RelCommon_Hint::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& RelCommon_Hint::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.Hint.advanced_extension) - return _internal_advanced_extension(); -} -inline void RelCommon_Hint::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.Hint.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.RelCommon.Hint.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon_Hint::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.RelCommon.Hint.advanced_extension) - return _msg; -} -inline void RelCommon_Hint::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.Hint.advanced_extension) -} - -// ------------------------------------------------------------------- - -// RelCommon - -// .substrait.RelCommon.Direct direct = 1; -inline bool RelCommon::_internal_has_direct() const { - return emit_kind_case() == kDirect; -} -inline bool RelCommon::has_direct() const { - return _internal_has_direct(); -} -inline void RelCommon::set_has_direct() { - _oneof_case_[0] = kDirect; -} -inline void RelCommon::clear_direct() { - if (_internal_has_direct()) { - if (GetArenaForAllocation() == nullptr) { - delete emit_kind_.direct_; - } - clear_has_emit_kind(); - } -} -inline ::substrait::RelCommon_Direct* RelCommon::release_direct() { - // @@protoc_insertion_point(field_release:substrait.RelCommon.direct) - if (_internal_has_direct()) { - clear_has_emit_kind(); - ::substrait::RelCommon_Direct* temp = emit_kind_.direct_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - emit_kind_.direct_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::RelCommon_Direct& RelCommon::_internal_direct() const { - return _internal_has_direct() - ? *emit_kind_.direct_ - : reinterpret_cast< ::substrait::RelCommon_Direct&>(::substrait::_RelCommon_Direct_default_instance_); -} -inline const ::substrait::RelCommon_Direct& RelCommon::direct() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.direct) - return _internal_direct(); -} -inline ::substrait::RelCommon_Direct* RelCommon::unsafe_arena_release_direct() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.RelCommon.direct) - if (_internal_has_direct()) { - clear_has_emit_kind(); - ::substrait::RelCommon_Direct* temp = emit_kind_.direct_; - emit_kind_.direct_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void RelCommon::unsafe_arena_set_allocated_direct(::substrait::RelCommon_Direct* direct) { - clear_emit_kind(); - if (direct) { - set_has_direct(); - emit_kind_.direct_ = direct; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.direct) -} -inline ::substrait::RelCommon_Direct* RelCommon::_internal_mutable_direct() { - if (!_internal_has_direct()) { - clear_emit_kind(); - set_has_direct(); - emit_kind_.direct_ = CreateMaybeMessage< ::substrait::RelCommon_Direct >(GetArenaForAllocation()); - } - return emit_kind_.direct_; -} -inline ::substrait::RelCommon_Direct* RelCommon::mutable_direct() { - ::substrait::RelCommon_Direct* _msg = _internal_mutable_direct(); - // @@protoc_insertion_point(field_mutable:substrait.RelCommon.direct) - return _msg; -} - -// .substrait.RelCommon.Emit emit = 2; -inline bool RelCommon::_internal_has_emit() const { - return emit_kind_case() == kEmit; -} -inline bool RelCommon::has_emit() const { - return _internal_has_emit(); -} -inline void RelCommon::set_has_emit() { - _oneof_case_[0] = kEmit; -} -inline void RelCommon::clear_emit() { - if (_internal_has_emit()) { - if (GetArenaForAllocation() == nullptr) { - delete emit_kind_.emit_; - } - clear_has_emit_kind(); - } -} -inline ::substrait::RelCommon_Emit* RelCommon::release_emit() { - // @@protoc_insertion_point(field_release:substrait.RelCommon.emit) - if (_internal_has_emit()) { - clear_has_emit_kind(); - ::substrait::RelCommon_Emit* temp = emit_kind_.emit_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - emit_kind_.emit_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::RelCommon_Emit& RelCommon::_internal_emit() const { - return _internal_has_emit() - ? *emit_kind_.emit_ - : reinterpret_cast< ::substrait::RelCommon_Emit&>(::substrait::_RelCommon_Emit_default_instance_); -} -inline const ::substrait::RelCommon_Emit& RelCommon::emit() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.emit) - return _internal_emit(); -} -inline ::substrait::RelCommon_Emit* RelCommon::unsafe_arena_release_emit() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.RelCommon.emit) - if (_internal_has_emit()) { - clear_has_emit_kind(); - ::substrait::RelCommon_Emit* temp = emit_kind_.emit_; - emit_kind_.emit_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void RelCommon::unsafe_arena_set_allocated_emit(::substrait::RelCommon_Emit* emit) { - clear_emit_kind(); - if (emit) { - set_has_emit(); - emit_kind_.emit_ = emit; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.emit) -} -inline ::substrait::RelCommon_Emit* RelCommon::_internal_mutable_emit() { - if (!_internal_has_emit()) { - clear_emit_kind(); - set_has_emit(); - emit_kind_.emit_ = CreateMaybeMessage< ::substrait::RelCommon_Emit >(GetArenaForAllocation()); - } - return emit_kind_.emit_; -} -inline ::substrait::RelCommon_Emit* RelCommon::mutable_emit() { - ::substrait::RelCommon_Emit* _msg = _internal_mutable_emit(); - // @@protoc_insertion_point(field_mutable:substrait.RelCommon.emit) - return _msg; -} - -// .substrait.RelCommon.Hint hint = 3; -inline bool RelCommon::_internal_has_hint() const { - return this != internal_default_instance() && hint_ != nullptr; -} -inline bool RelCommon::has_hint() const { - return _internal_has_hint(); -} -inline void RelCommon::clear_hint() { - if (GetArenaForAllocation() == nullptr && hint_ != nullptr) { - delete hint_; - } - hint_ = nullptr; -} -inline const ::substrait::RelCommon_Hint& RelCommon::_internal_hint() const { - const ::substrait::RelCommon_Hint* p = hint_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_Hint_default_instance_); -} -inline const ::substrait::RelCommon_Hint& RelCommon::hint() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.hint) - return _internal_hint(); -} -inline void RelCommon::unsafe_arena_set_allocated_hint( - ::substrait::RelCommon_Hint* hint) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hint_); - } - hint_ = hint; - if (hint) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.hint) -} -inline ::substrait::RelCommon_Hint* RelCommon::release_hint() { - - ::substrait::RelCommon_Hint* temp = hint_; - hint_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon_Hint* RelCommon::unsafe_arena_release_hint() { - // @@protoc_insertion_point(field_release:substrait.RelCommon.hint) - - ::substrait::RelCommon_Hint* temp = hint_; - hint_ = nullptr; - return temp; -} -inline ::substrait::RelCommon_Hint* RelCommon::_internal_mutable_hint() { - - if (hint_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon_Hint>(GetArenaForAllocation()); - hint_ = p; - } - return hint_; -} -inline ::substrait::RelCommon_Hint* RelCommon::mutable_hint() { - ::substrait::RelCommon_Hint* _msg = _internal_mutable_hint(); - // @@protoc_insertion_point(field_mutable:substrait.RelCommon.hint) - return _msg; -} -inline void RelCommon::set_allocated_hint(::substrait::RelCommon_Hint* hint) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete hint_; - } - if (hint) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon_Hint>::GetOwningArena(hint); - if (message_arena != submessage_arena) { - hint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, hint, submessage_arena); - } - - } else { - - } - hint_ = hint; - // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.hint) -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 4; -inline bool RelCommon::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool RelCommon::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& RelCommon::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& RelCommon::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.RelCommon.advanced_extension) - return _internal_advanced_extension(); -} -inline void RelCommon::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelCommon.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* RelCommon::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.RelCommon.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* RelCommon::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.RelCommon.advanced_extension) - return _msg; -} -inline void RelCommon::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.RelCommon.advanced_extension) -} - -inline bool RelCommon::has_emit_kind() const { - return emit_kind_case() != EMIT_KIND_NOT_SET; -} -inline void RelCommon::clear_has_emit_kind() { - _oneof_case_[0] = EMIT_KIND_NOT_SET; -} -inline RelCommon::EmitKindCase RelCommon::emit_kind_case() const { - return RelCommon::EmitKindCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// ReadRel_NamedTable - -// repeated string names = 1; -inline int ReadRel_NamedTable::_internal_names_size() const { - return names_.size(); -} -inline int ReadRel_NamedTable::names_size() const { - return _internal_names_size(); -} -inline void ReadRel_NamedTable::clear_names() { - names_.Clear(); -} -inline std::string* ReadRel_NamedTable::add_names() { - std::string* _s = _internal_add_names(); - // @@protoc_insertion_point(field_add_mutable:substrait.ReadRel.NamedTable.names) - return _s; -} -inline const std::string& ReadRel_NamedTable::_internal_names(int index) const { - return names_.Get(index); -} -inline const std::string& ReadRel_NamedTable::names(int index) const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.NamedTable.names) - return _internal_names(index); -} -inline std::string* ReadRel_NamedTable::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.NamedTable.names) - return names_.Mutable(index); -} -inline void ReadRel_NamedTable::set_names(int index, const std::string& value) { - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.ReadRel.NamedTable.names) -} -inline void ReadRel_NamedTable::set_names(int index, std::string&& value) { - names_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.ReadRel.NamedTable.names) -} -inline void ReadRel_NamedTable::set_names(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.ReadRel.NamedTable.names) -} -inline void ReadRel_NamedTable::set_names(int index, const char* value, size_t size) { - names_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.ReadRel.NamedTable.names) -} -inline std::string* ReadRel_NamedTable::_internal_add_names() { - return names_.Add(); -} -inline void ReadRel_NamedTable::add_names(const std::string& value) { - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.ReadRel.NamedTable.names) -} -inline void ReadRel_NamedTable::add_names(std::string&& value) { - names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.ReadRel.NamedTable.names) -} -inline void ReadRel_NamedTable::add_names(const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.ReadRel.NamedTable.names) -} -inline void ReadRel_NamedTable::add_names(const char* value, size_t size) { - names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.ReadRel.NamedTable.names) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -ReadRel_NamedTable::names() const { - // @@protoc_insertion_point(field_list:substrait.ReadRel.NamedTable.names) - return names_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -ReadRel_NamedTable::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:substrait.ReadRel.NamedTable.names) - return &names_; -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool ReadRel_NamedTable::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool ReadRel_NamedTable::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& ReadRel_NamedTable::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.NamedTable.advanced_extension) - return _internal_advanced_extension(); -} -inline void ReadRel_NamedTable::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.NamedTable.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.NamedTable.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* ReadRel_NamedTable::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.NamedTable.advanced_extension) - return _msg; -} -inline void ReadRel_NamedTable::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.NamedTable.advanced_extension) -} - -// ------------------------------------------------------------------- - -// ReadRel_VirtualTable - -// repeated .substrait.Expression.Literal.Struct values = 1; -inline int ReadRel_VirtualTable::_internal_values_size() const { - return values_.size(); -} -inline int ReadRel_VirtualTable::values_size() const { - return _internal_values_size(); -} -inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::mutable_values(int index) { - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.VirtualTable.values) - return values_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >* -ReadRel_VirtualTable::mutable_values() { - // @@protoc_insertion_point(field_mutable_list:substrait.ReadRel.VirtualTable.values) - return &values_; -} -inline const ::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::_internal_values(int index) const { - return values_.Get(index); -} -inline const ::substrait::Expression_Literal_Struct& ReadRel_VirtualTable::values(int index) const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.VirtualTable.values) - return _internal_values(index); -} -inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::_internal_add_values() { - return values_.Add(); -} -inline ::substrait::Expression_Literal_Struct* ReadRel_VirtualTable::add_values() { - ::substrait::Expression_Literal_Struct* _add = _internal_add_values(); - // @@protoc_insertion_point(field_add:substrait.ReadRel.VirtualTable.values) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression_Literal_Struct >& -ReadRel_VirtualTable::values() const { - // @@protoc_insertion_point(field_list:substrait.ReadRel.VirtualTable.values) - return values_; -} - -// ------------------------------------------------------------------- - -// ReadRel_ExtensionTable - -// .google.protobuf.Any detail = 1; -inline bool ReadRel_ExtensionTable::_internal_has_detail() const { - return this != internal_default_instance() && detail_ != nullptr; -} -inline bool ReadRel_ExtensionTable::has_detail() const { - return _internal_has_detail(); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::_internal_detail() const { - const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_; - return p != nullptr ? *p : reinterpret_cast( - ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& ReadRel_ExtensionTable::detail() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.ExtensionTable.detail) - return _internal_detail(); -} -inline void ReadRel_ExtensionTable::unsafe_arena_set_allocated_detail( - ::PROTOBUF_NAMESPACE_ID::Any* detail) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); - } - detail_ = detail; - if (detail) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.ExtensionTable.detail) -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::release_detail() { - - ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; - detail_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::unsafe_arena_release_detail() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.ExtensionTable.detail) - - ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; - detail_ = nullptr; - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::_internal_mutable_detail() { - - if (detail_ == nullptr) { - auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); - detail_ = p; - } - return detail_; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ReadRel_ExtensionTable::mutable_detail() { - ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.ExtensionTable.detail) - return _msg; -} -inline void ReadRel_ExtensionTable::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); - } - if (detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)); - if (message_arena != submessage_arena) { - detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, detail, submessage_arena); - } - - } else { - - } - detail_ = detail; - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.ExtensionTable.detail) -} - -// ------------------------------------------------------------------- - -// ReadRel_LocalFiles_FileOrFiles - -// string uri_path = 1; -inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_path() const { - return path_type_case() == kUriPath; -} -inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_path() const { - return _internal_has_uri_path(); -} -inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path() { - _oneof_case_[0] = kUriPath; -} -inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path() { - if (_internal_has_uri_path()) { - path_type_.uri_path_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_path_type(); - } -} -inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) - return _internal_uri_path(); -} -template -inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_uri_path()) { - clear_path_type(); - set_has_uri_path(); - path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path() { - std::string* _s = _internal_mutable_uri_path(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) - return _s; -} -inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path() const { - if (_internal_has_uri_path()) { - return path_type_.uri_path_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path(const std::string& value) { - if (!_internal_has_uri_path()) { - clear_path_type(); - set_has_uri_path(); - path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - path_type_.uri_path_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path() { - if (!_internal_has_uri_path()) { - clear_path_type(); - set_has_uri_path(); - path_type_.uri_path_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return path_type_.uri_path_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) - if (_internal_has_uri_path()) { - clear_has_path_type(); - return path_type_.uri_path_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path(std::string* uri_path) { - if (has_path_type()) { - clear_path_type(); - } - if (uri_path != nullptr) { - set_has_uri_path(); - path_type_.uri_path_.UnsafeSetDefault(uri_path); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(uri_path); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path) -} - -// string uri_path_glob = 2; -inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_path_glob() const { - return path_type_case() == kUriPathGlob; -} -inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_path_glob() const { - return _internal_has_uri_path_glob(); -} -inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_path_glob() { - _oneof_case_[0] = kUriPathGlob; -} -inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_path_glob() { - if (_internal_has_uri_path_glob()) { - path_type_.uri_path_glob_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_path_type(); - } -} -inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_path_glob() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) - return _internal_uri_path_glob(); -} -template -inline void ReadRel_LocalFiles_FileOrFiles::set_uri_path_glob(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_uri_path_glob()) { - clear_path_type(); - set_has_uri_path_glob(); - path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_path_glob() { - std::string* _s = _internal_mutable_uri_path_glob(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) - return _s; -} -inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_path_glob() const { - if (_internal_has_uri_path_glob()) { - return path_type_.uri_path_glob_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_path_glob(const std::string& value) { - if (!_internal_has_uri_path_glob()) { - clear_path_type(); - set_has_uri_path_glob(); - path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - path_type_.uri_path_glob_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_path_glob() { - if (!_internal_has_uri_path_glob()) { - clear_path_type(); - set_has_uri_path_glob(); - path_type_.uri_path_glob_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return path_type_.uri_path_glob_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_path_glob() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) - if (_internal_has_uri_path_glob()) { - clear_has_path_type(); - return path_type_.uri_path_glob_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_path_glob(std::string* uri_path_glob) { - if (has_path_type()) { - clear_path_type(); - } - if (uri_path_glob != nullptr) { - set_has_uri_path_glob(); - path_type_.uri_path_glob_.UnsafeSetDefault(uri_path_glob); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(uri_path_glob); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_path_glob) -} - -// string uri_file = 3; -inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_file() const { - return path_type_case() == kUriFile; -} -inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_file() const { - return _internal_has_uri_file(); -} -inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_file() { - _oneof_case_[0] = kUriFile; -} -inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_file() { - if (_internal_has_uri_file()) { - path_type_.uri_file_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_path_type(); - } -} -inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_file() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) - return _internal_uri_file(); -} -template -inline void ReadRel_LocalFiles_FileOrFiles::set_uri_file(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_uri_file()) { - clear_path_type(); - set_has_uri_file(); - path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_file() { - std::string* _s = _internal_mutable_uri_file(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) - return _s; -} -inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_file() const { - if (_internal_has_uri_file()) { - return path_type_.uri_file_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_file(const std::string& value) { - if (!_internal_has_uri_file()) { - clear_path_type(); - set_has_uri_file(); - path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - path_type_.uri_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_file() { - if (!_internal_has_uri_file()) { - clear_path_type(); - set_has_uri_file(); - path_type_.uri_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return path_type_.uri_file_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_file() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) - if (_internal_has_uri_file()) { - clear_has_path_type(); - return path_type_.uri_file_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_file(std::string* uri_file) { - if (has_path_type()) { - clear_path_type(); - } - if (uri_file != nullptr) { - set_has_uri_file(); - path_type_.uri_file_.UnsafeSetDefault(uri_file); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(uri_file); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_file) -} - -// string uri_folder = 4; -inline bool ReadRel_LocalFiles_FileOrFiles::_internal_has_uri_folder() const { - return path_type_case() == kUriFolder; -} -inline bool ReadRel_LocalFiles_FileOrFiles::has_uri_folder() const { - return _internal_has_uri_folder(); -} -inline void ReadRel_LocalFiles_FileOrFiles::set_has_uri_folder() { - _oneof_case_[0] = kUriFolder; -} -inline void ReadRel_LocalFiles_FileOrFiles::clear_uri_folder() { - if (_internal_has_uri_folder()) { - path_type_.uri_folder_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_path_type(); - } -} -inline const std::string& ReadRel_LocalFiles_FileOrFiles::uri_folder() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) - return _internal_uri_folder(); -} -template -inline void ReadRel_LocalFiles_FileOrFiles::set_uri_folder(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_uri_folder()) { - clear_path_type(); - set_has_uri_folder(); - path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::mutable_uri_folder() { - std::string* _s = _internal_mutable_uri_folder(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) - return _s; -} -inline const std::string& ReadRel_LocalFiles_FileOrFiles::_internal_uri_folder() const { - if (_internal_has_uri_folder()) { - return path_type_.uri_folder_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_uri_folder(const std::string& value) { - if (!_internal_has_uri_folder()) { - clear_path_type(); - set_has_uri_folder(); - path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - path_type_.uri_folder_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::_internal_mutable_uri_folder() { - if (!_internal_has_uri_folder()) { - clear_path_type(); - set_has_uri_folder(); - path_type_.uri_folder_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return path_type_.uri_folder_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* ReadRel_LocalFiles_FileOrFiles::release_uri_folder() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) - if (_internal_has_uri_folder()) { - clear_has_path_type(); - return path_type_.uri_folder_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void ReadRel_LocalFiles_FileOrFiles::set_allocated_uri_folder(std::string* uri_folder) { - if (has_path_type()) { - clear_path_type(); - } - if (uri_folder != nullptr) { - set_has_uri_folder(); - path_type_.uri_folder_.UnsafeSetDefault(uri_folder); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(uri_folder); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.FileOrFiles.uri_folder) -} - -// .substrait.ReadRel.LocalFiles.FileOrFiles.FileFormat format = 5; -inline void ReadRel_LocalFiles_FileOrFiles::clear_format() { - format_ = 0; -} -inline ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::_internal_format() const { - return static_cast< ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat >(format_); -} -inline ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat ReadRel_LocalFiles_FileOrFiles::format() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.format) - return _internal_format(); -} -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value) { - - format_ = value; -} -inline void ReadRel_LocalFiles_FileOrFiles::set_format(::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat value) { - _internal_set_format(value); - // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.format) -} - -// uint64 partition_index = 6; -inline void ReadRel_LocalFiles_FileOrFiles::clear_partition_index() { - partition_index_ = uint64_t{0u}; -} -inline uint64_t ReadRel_LocalFiles_FileOrFiles::_internal_partition_index() const { - return partition_index_; -} -inline uint64_t ReadRel_LocalFiles_FileOrFiles::partition_index() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.partition_index) - return _internal_partition_index(); -} -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_partition_index(uint64_t value) { - - partition_index_ = value; -} -inline void ReadRel_LocalFiles_FileOrFiles::set_partition_index(uint64_t value) { - _internal_set_partition_index(value); - // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.partition_index) -} - -// uint64 start = 7; -inline void ReadRel_LocalFiles_FileOrFiles::clear_start() { - start_ = uint64_t{0u}; -} -inline uint64_t ReadRel_LocalFiles_FileOrFiles::_internal_start() const { - return start_; -} -inline uint64_t ReadRel_LocalFiles_FileOrFiles::start() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.start) - return _internal_start(); -} -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_start(uint64_t value) { - - start_ = value; -} -inline void ReadRel_LocalFiles_FileOrFiles::set_start(uint64_t value) { - _internal_set_start(value); - // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.start) -} - -// uint64 length = 8; -inline void ReadRel_LocalFiles_FileOrFiles::clear_length() { - length_ = uint64_t{0u}; -} -inline uint64_t ReadRel_LocalFiles_FileOrFiles::_internal_length() const { - return length_; -} -inline uint64_t ReadRel_LocalFiles_FileOrFiles::length() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.FileOrFiles.length) - return _internal_length(); -} -inline void ReadRel_LocalFiles_FileOrFiles::_internal_set_length(uint64_t value) { - - length_ = value; -} -inline void ReadRel_LocalFiles_FileOrFiles::set_length(uint64_t value) { - _internal_set_length(value); - // @@protoc_insertion_point(field_set:substrait.ReadRel.LocalFiles.FileOrFiles.length) -} - -inline bool ReadRel_LocalFiles_FileOrFiles::has_path_type() const { - return path_type_case() != PATH_TYPE_NOT_SET; -} -inline void ReadRel_LocalFiles_FileOrFiles::clear_has_path_type() { - _oneof_case_[0] = PATH_TYPE_NOT_SET; -} -inline ReadRel_LocalFiles_FileOrFiles::PathTypeCase ReadRel_LocalFiles_FileOrFiles::path_type_case() const { - return ReadRel_LocalFiles_FileOrFiles::PathTypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// ReadRel_LocalFiles - -// repeated .substrait.ReadRel.LocalFiles.FileOrFiles items = 1; -inline int ReadRel_LocalFiles::_internal_items_size() const { - return items_.size(); -} -inline int ReadRel_LocalFiles::items_size() const { - return _internal_items_size(); -} -inline void ReadRel_LocalFiles::clear_items() { - items_.Clear(); -} -inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::mutable_items(int index) { - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.items) - return items_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >* -ReadRel_LocalFiles::mutable_items() { - // @@protoc_insertion_point(field_mutable_list:substrait.ReadRel.LocalFiles.items) - return &items_; -} -inline const ::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::_internal_items(int index) const { - return items_.Get(index); -} -inline const ::substrait::ReadRel_LocalFiles_FileOrFiles& ReadRel_LocalFiles::items(int index) const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.items) - return _internal_items(index); -} -inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::_internal_add_items() { - return items_.Add(); -} -inline ::substrait::ReadRel_LocalFiles_FileOrFiles* ReadRel_LocalFiles::add_items() { - ::substrait::ReadRel_LocalFiles_FileOrFiles* _add = _internal_add_items(); - // @@protoc_insertion_point(field_add:substrait.ReadRel.LocalFiles.items) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::ReadRel_LocalFiles_FileOrFiles >& -ReadRel_LocalFiles::items() const { - // @@protoc_insertion_point(field_list:substrait.ReadRel.LocalFiles.items) - return items_; -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool ReadRel_LocalFiles::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool ReadRel_LocalFiles::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& ReadRel_LocalFiles::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.LocalFiles.advanced_extension) - return _internal_advanced_extension(); -} -inline void ReadRel_LocalFiles::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.LocalFiles.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.LocalFiles.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* ReadRel_LocalFiles::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.LocalFiles.advanced_extension) - return _msg; -} -inline void ReadRel_LocalFiles::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.LocalFiles.advanced_extension) -} - -// ------------------------------------------------------------------- - -// ReadRel - -// .substrait.RelCommon common = 1; -inline bool ReadRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool ReadRel::has_common() const { - return _internal_has_common(); -} -inline void ReadRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& ReadRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& ReadRel::common() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.common) - return _internal_common(); -} -inline void ReadRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.common) -} -inline ::substrait::RelCommon* ReadRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* ReadRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* ReadRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* ReadRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.common) - return _msg; -} -inline void ReadRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.common) -} - -// .substrait.NamedStruct base_schema = 2; -inline bool ReadRel::_internal_has_base_schema() const { - return this != internal_default_instance() && base_schema_ != nullptr; -} -inline bool ReadRel::has_base_schema() const { - return _internal_has_base_schema(); -} -inline const ::substrait::NamedStruct& ReadRel::_internal_base_schema() const { - const ::substrait::NamedStruct* p = base_schema_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_NamedStruct_default_instance_); -} -inline const ::substrait::NamedStruct& ReadRel::base_schema() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.base_schema) - return _internal_base_schema(); -} -inline void ReadRel::unsafe_arena_set_allocated_base_schema( - ::substrait::NamedStruct* base_schema) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); - } - base_schema_ = base_schema; - if (base_schema) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.base_schema) -} -inline ::substrait::NamedStruct* ReadRel::release_base_schema() { - - ::substrait::NamedStruct* temp = base_schema_; - base_schema_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::NamedStruct* ReadRel::unsafe_arena_release_base_schema() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.base_schema) - - ::substrait::NamedStruct* temp = base_schema_; - base_schema_ = nullptr; - return temp; -} -inline ::substrait::NamedStruct* ReadRel::_internal_mutable_base_schema() { - - if (base_schema_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::NamedStruct>(GetArenaForAllocation()); - base_schema_ = p; - } - return base_schema_; -} -inline ::substrait::NamedStruct* ReadRel::mutable_base_schema() { - ::substrait::NamedStruct* _msg = _internal_mutable_base_schema(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.base_schema) - return _msg; -} -inline void ReadRel::set_allocated_base_schema(::substrait::NamedStruct* base_schema) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema_); - } - if (base_schema) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(base_schema)); - if (message_arena != submessage_arena) { - base_schema = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, base_schema, submessage_arena); - } - - } else { - - } - base_schema_ = base_schema; - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.base_schema) -} - -// .substrait.Expression filter = 3; -inline bool ReadRel::_internal_has_filter() const { - return this != internal_default_instance() && filter_ != nullptr; -} -inline bool ReadRel::has_filter() const { - return _internal_has_filter(); -} -inline const ::substrait::Expression& ReadRel::_internal_filter() const { - const ::substrait::Expression* p = filter_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& ReadRel::filter() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.filter) - return _internal_filter(); -} -inline void ReadRel::unsafe_arena_set_allocated_filter( - ::substrait::Expression* filter) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); - } - filter_ = filter; - if (filter) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.filter) -} -inline ::substrait::Expression* ReadRel::release_filter() { - - ::substrait::Expression* temp = filter_; - filter_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* ReadRel::unsafe_arena_release_filter() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.filter) - - ::substrait::Expression* temp = filter_; - filter_ = nullptr; - return temp; -} -inline ::substrait::Expression* ReadRel::_internal_mutable_filter() { - - if (filter_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - filter_ = p; - } - return filter_; -} -inline ::substrait::Expression* ReadRel::mutable_filter() { - ::substrait::Expression* _msg = _internal_mutable_filter(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.filter) - return _msg; -} -inline void ReadRel::set_allocated_filter(::substrait::Expression* filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); - } - if (filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter)); - if (message_arena != submessage_arena) { - filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, filter, submessage_arena); - } - - } else { - - } - filter_ = filter; - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.filter) -} - -// .substrait.Expression.MaskExpression projection = 4; -inline bool ReadRel::_internal_has_projection() const { - return this != internal_default_instance() && projection_ != nullptr; -} -inline bool ReadRel::has_projection() const { - return _internal_has_projection(); -} -inline const ::substrait::Expression_MaskExpression& ReadRel::_internal_projection() const { - const ::substrait::Expression_MaskExpression* p = projection_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_MaskExpression_default_instance_); -} -inline const ::substrait::Expression_MaskExpression& ReadRel::projection() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.projection) - return _internal_projection(); -} -inline void ReadRel::unsafe_arena_set_allocated_projection( - ::substrait::Expression_MaskExpression* projection) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); - } - projection_ = projection; - if (projection) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.projection) -} -inline ::substrait::Expression_MaskExpression* ReadRel::release_projection() { - - ::substrait::Expression_MaskExpression* temp = projection_; - projection_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression_MaskExpression* ReadRel::unsafe_arena_release_projection() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.projection) - - ::substrait::Expression_MaskExpression* temp = projection_; - projection_ = nullptr; - return temp; -} -inline ::substrait::Expression_MaskExpression* ReadRel::_internal_mutable_projection() { - - if (projection_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression_MaskExpression>(GetArenaForAllocation()); - projection_ = p; - } - return projection_; -} -inline ::substrait::Expression_MaskExpression* ReadRel::mutable_projection() { - ::substrait::Expression_MaskExpression* _msg = _internal_mutable_projection(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.projection) - return _msg; -} -inline void ReadRel::set_allocated_projection(::substrait::Expression_MaskExpression* projection) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection_); - } - if (projection) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(projection)); - if (message_arena != submessage_arena) { - projection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, projection, submessage_arena); - } - - } else { - - } - projection_ = projection; - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.projection) -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool ReadRel::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool ReadRel::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& ReadRel::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& ReadRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.advanced_extension) - return _internal_advanced_extension(); -} -inline void ReadRel::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* ReadRel::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* ReadRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* ReadRel::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* ReadRel::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.advanced_extension) - return _msg; -} -inline void ReadRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.ReadRel.advanced_extension) -} - -// .substrait.ReadRel.VirtualTable virtual_table = 5; -inline bool ReadRel::_internal_has_virtual_table() const { - return read_type_case() == kVirtualTable; -} -inline bool ReadRel::has_virtual_table() const { - return _internal_has_virtual_table(); -} -inline void ReadRel::set_has_virtual_table() { - _oneof_case_[0] = kVirtualTable; -} -inline void ReadRel::clear_virtual_table() { - if (_internal_has_virtual_table()) { - if (GetArenaForAllocation() == nullptr) { - delete read_type_.virtual_table_; - } - clear_has_read_type(); - } -} -inline ::substrait::ReadRel_VirtualTable* ReadRel::release_virtual_table() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.virtual_table) - if (_internal_has_virtual_table()) { - clear_has_read_type(); - ::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - read_type_.virtual_table_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ReadRel_VirtualTable& ReadRel::_internal_virtual_table() const { - return _internal_has_virtual_table() - ? *read_type_.virtual_table_ - : reinterpret_cast< ::substrait::ReadRel_VirtualTable&>(::substrait::_ReadRel_VirtualTable_default_instance_); -} -inline const ::substrait::ReadRel_VirtualTable& ReadRel::virtual_table() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.virtual_table) - return _internal_virtual_table(); -} -inline ::substrait::ReadRel_VirtualTable* ReadRel::unsafe_arena_release_virtual_table() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.virtual_table) - if (_internal_has_virtual_table()) { - clear_has_read_type(); - ::substrait::ReadRel_VirtualTable* temp = read_type_.virtual_table_; - read_type_.virtual_table_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ReadRel::unsafe_arena_set_allocated_virtual_table(::substrait::ReadRel_VirtualTable* virtual_table) { - clear_read_type(); - if (virtual_table) { - set_has_virtual_table(); - read_type_.virtual_table_ = virtual_table; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.virtual_table) -} -inline ::substrait::ReadRel_VirtualTable* ReadRel::_internal_mutable_virtual_table() { - if (!_internal_has_virtual_table()) { - clear_read_type(); - set_has_virtual_table(); - read_type_.virtual_table_ = CreateMaybeMessage< ::substrait::ReadRel_VirtualTable >(GetArenaForAllocation()); - } - return read_type_.virtual_table_; -} -inline ::substrait::ReadRel_VirtualTable* ReadRel::mutable_virtual_table() { - ::substrait::ReadRel_VirtualTable* _msg = _internal_mutable_virtual_table(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.virtual_table) - return _msg; -} - -// .substrait.ReadRel.LocalFiles local_files = 6; -inline bool ReadRel::_internal_has_local_files() const { - return read_type_case() == kLocalFiles; -} -inline bool ReadRel::has_local_files() const { - return _internal_has_local_files(); -} -inline void ReadRel::set_has_local_files() { - _oneof_case_[0] = kLocalFiles; -} -inline void ReadRel::clear_local_files() { - if (_internal_has_local_files()) { - if (GetArenaForAllocation() == nullptr) { - delete read_type_.local_files_; - } - clear_has_read_type(); - } -} -inline ::substrait::ReadRel_LocalFiles* ReadRel::release_local_files() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.local_files) - if (_internal_has_local_files()) { - clear_has_read_type(); - ::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - read_type_.local_files_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ReadRel_LocalFiles& ReadRel::_internal_local_files() const { - return _internal_has_local_files() - ? *read_type_.local_files_ - : reinterpret_cast< ::substrait::ReadRel_LocalFiles&>(::substrait::_ReadRel_LocalFiles_default_instance_); -} -inline const ::substrait::ReadRel_LocalFiles& ReadRel::local_files() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.local_files) - return _internal_local_files(); -} -inline ::substrait::ReadRel_LocalFiles* ReadRel::unsafe_arena_release_local_files() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.local_files) - if (_internal_has_local_files()) { - clear_has_read_type(); - ::substrait::ReadRel_LocalFiles* temp = read_type_.local_files_; - read_type_.local_files_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ReadRel::unsafe_arena_set_allocated_local_files(::substrait::ReadRel_LocalFiles* local_files) { - clear_read_type(); - if (local_files) { - set_has_local_files(); - read_type_.local_files_ = local_files; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.local_files) -} -inline ::substrait::ReadRel_LocalFiles* ReadRel::_internal_mutable_local_files() { - if (!_internal_has_local_files()) { - clear_read_type(); - set_has_local_files(); - read_type_.local_files_ = CreateMaybeMessage< ::substrait::ReadRel_LocalFiles >(GetArenaForAllocation()); - } - return read_type_.local_files_; -} -inline ::substrait::ReadRel_LocalFiles* ReadRel::mutable_local_files() { - ::substrait::ReadRel_LocalFiles* _msg = _internal_mutable_local_files(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.local_files) - return _msg; -} - -// .substrait.ReadRel.NamedTable named_table = 7; -inline bool ReadRel::_internal_has_named_table() const { - return read_type_case() == kNamedTable; -} -inline bool ReadRel::has_named_table() const { - return _internal_has_named_table(); -} -inline void ReadRel::set_has_named_table() { - _oneof_case_[0] = kNamedTable; -} -inline void ReadRel::clear_named_table() { - if (_internal_has_named_table()) { - if (GetArenaForAllocation() == nullptr) { - delete read_type_.named_table_; - } - clear_has_read_type(); - } -} -inline ::substrait::ReadRel_NamedTable* ReadRel::release_named_table() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.named_table) - if (_internal_has_named_table()) { - clear_has_read_type(); - ::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - read_type_.named_table_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ReadRel_NamedTable& ReadRel::_internal_named_table() const { - return _internal_has_named_table() - ? *read_type_.named_table_ - : reinterpret_cast< ::substrait::ReadRel_NamedTable&>(::substrait::_ReadRel_NamedTable_default_instance_); -} -inline const ::substrait::ReadRel_NamedTable& ReadRel::named_table() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.named_table) - return _internal_named_table(); -} -inline ::substrait::ReadRel_NamedTable* ReadRel::unsafe_arena_release_named_table() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.named_table) - if (_internal_has_named_table()) { - clear_has_read_type(); - ::substrait::ReadRel_NamedTable* temp = read_type_.named_table_; - read_type_.named_table_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ReadRel::unsafe_arena_set_allocated_named_table(::substrait::ReadRel_NamedTable* named_table) { - clear_read_type(); - if (named_table) { - set_has_named_table(); - read_type_.named_table_ = named_table; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.named_table) -} -inline ::substrait::ReadRel_NamedTable* ReadRel::_internal_mutable_named_table() { - if (!_internal_has_named_table()) { - clear_read_type(); - set_has_named_table(); - read_type_.named_table_ = CreateMaybeMessage< ::substrait::ReadRel_NamedTable >(GetArenaForAllocation()); - } - return read_type_.named_table_; -} -inline ::substrait::ReadRel_NamedTable* ReadRel::mutable_named_table() { - ::substrait::ReadRel_NamedTable* _msg = _internal_mutable_named_table(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.named_table) - return _msg; -} - -// .substrait.ReadRel.ExtensionTable extension_table = 8; -inline bool ReadRel::_internal_has_extension_table() const { - return read_type_case() == kExtensionTable; -} -inline bool ReadRel::has_extension_table() const { - return _internal_has_extension_table(); -} -inline void ReadRel::set_has_extension_table() { - _oneof_case_[0] = kExtensionTable; -} -inline void ReadRel::clear_extension_table() { - if (_internal_has_extension_table()) { - if (GetArenaForAllocation() == nullptr) { - delete read_type_.extension_table_; - } - clear_has_read_type(); - } -} -inline ::substrait::ReadRel_ExtensionTable* ReadRel::release_extension_table() { - // @@protoc_insertion_point(field_release:substrait.ReadRel.extension_table) - if (_internal_has_extension_table()) { - clear_has_read_type(); - ::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - read_type_.extension_table_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ReadRel_ExtensionTable& ReadRel::_internal_extension_table() const { - return _internal_has_extension_table() - ? *read_type_.extension_table_ - : reinterpret_cast< ::substrait::ReadRel_ExtensionTable&>(::substrait::_ReadRel_ExtensionTable_default_instance_); -} -inline const ::substrait::ReadRel_ExtensionTable& ReadRel::extension_table() const { - // @@protoc_insertion_point(field_get:substrait.ReadRel.extension_table) - return _internal_extension_table(); -} -inline ::substrait::ReadRel_ExtensionTable* ReadRel::unsafe_arena_release_extension_table() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.ReadRel.extension_table) - if (_internal_has_extension_table()) { - clear_has_read_type(); - ::substrait::ReadRel_ExtensionTable* temp = read_type_.extension_table_; - read_type_.extension_table_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ReadRel::unsafe_arena_set_allocated_extension_table(::substrait::ReadRel_ExtensionTable* extension_table) { - clear_read_type(); - if (extension_table) { - set_has_extension_table(); - read_type_.extension_table_ = extension_table; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ReadRel.extension_table) -} -inline ::substrait::ReadRel_ExtensionTable* ReadRel::_internal_mutable_extension_table() { - if (!_internal_has_extension_table()) { - clear_read_type(); - set_has_extension_table(); - read_type_.extension_table_ = CreateMaybeMessage< ::substrait::ReadRel_ExtensionTable >(GetArenaForAllocation()); - } - return read_type_.extension_table_; -} -inline ::substrait::ReadRel_ExtensionTable* ReadRel::mutable_extension_table() { - ::substrait::ReadRel_ExtensionTable* _msg = _internal_mutable_extension_table(); - // @@protoc_insertion_point(field_mutable:substrait.ReadRel.extension_table) - return _msg; -} - -inline bool ReadRel::has_read_type() const { - return read_type_case() != READ_TYPE_NOT_SET; -} -inline void ReadRel::clear_has_read_type() { - _oneof_case_[0] = READ_TYPE_NOT_SET; -} -inline ReadRel::ReadTypeCase ReadRel::read_type_case() const { - return ReadRel::ReadTypeCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// ProjectRel - -// .substrait.RelCommon common = 1; -inline bool ProjectRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool ProjectRel::has_common() const { - return _internal_has_common(); -} -inline void ProjectRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& ProjectRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& ProjectRel::common() const { - // @@protoc_insertion_point(field_get:substrait.ProjectRel.common) - return _internal_common(); -} -inline void ProjectRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ProjectRel.common) -} -inline ::substrait::RelCommon* ProjectRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* ProjectRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.ProjectRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* ProjectRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* ProjectRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.common) - return _msg; -} -inline void ProjectRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.ProjectRel.common) -} - -// .substrait.Rel input = 2; -inline bool ProjectRel::_internal_has_input() const { - return this != internal_default_instance() && input_ != nullptr; -} -inline bool ProjectRel::has_input() const { - return _internal_has_input(); -} -inline void ProjectRel::clear_input() { - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; -} -inline const ::substrait::Rel& ProjectRel::_internal_input() const { - const ::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Rel_default_instance_); -} -inline const ::substrait::Rel& ProjectRel::input() const { - // @@protoc_insertion_point(field_get:substrait.ProjectRel.input) - return _internal_input(); -} -inline void ProjectRel::unsafe_arena_set_allocated_input( - ::substrait::Rel* input) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); - } - input_ = input; - if (input) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ProjectRel.input) -} -inline ::substrait::Rel* ProjectRel::release_input() { - - ::substrait::Rel* temp = input_; - input_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Rel* ProjectRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:substrait.ProjectRel.input) - - ::substrait::Rel* temp = input_; - input_ = nullptr; - return temp; -} -inline ::substrait::Rel* ProjectRel::_internal_mutable_input() { - - if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); - input_ = p; - } - return input_; -} -inline ::substrait::Rel* ProjectRel::mutable_input() { - ::substrait::Rel* _msg = _internal_mutable_input(); - // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.input) - return _msg; -} -inline void ProjectRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete input_; - } - if (input) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); - if (message_arena != submessage_arena) { - input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, input, submessage_arena); - } - - } else { - - } - input_ = input; - // @@protoc_insertion_point(field_set_allocated:substrait.ProjectRel.input) -} - -// repeated .substrait.Expression expressions = 3; -inline int ProjectRel::_internal_expressions_size() const { - return expressions_.size(); -} -inline int ProjectRel::expressions_size() const { - return _internal_expressions_size(); -} -inline ::substrait::Expression* ProjectRel::mutable_expressions(int index) { - // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.expressions) - return expressions_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* -ProjectRel::mutable_expressions() { - // @@protoc_insertion_point(field_mutable_list:substrait.ProjectRel.expressions) - return &expressions_; -} -inline const ::substrait::Expression& ProjectRel::_internal_expressions(int index) const { - return expressions_.Get(index); -} -inline const ::substrait::Expression& ProjectRel::expressions(int index) const { - // @@protoc_insertion_point(field_get:substrait.ProjectRel.expressions) - return _internal_expressions(index); -} -inline ::substrait::Expression* ProjectRel::_internal_add_expressions() { - return expressions_.Add(); -} -inline ::substrait::Expression* ProjectRel::add_expressions() { - ::substrait::Expression* _add = _internal_add_expressions(); - // @@protoc_insertion_point(field_add:substrait.ProjectRel.expressions) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& -ProjectRel::expressions() const { - // @@protoc_insertion_point(field_list:substrait.ProjectRel.expressions) - return expressions_; -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool ProjectRel::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool ProjectRel::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& ProjectRel::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& ProjectRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.ProjectRel.advanced_extension) - return _internal_advanced_extension(); -} -inline void ProjectRel::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ProjectRel.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* ProjectRel::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* ProjectRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.ProjectRel.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* ProjectRel::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* ProjectRel::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.ProjectRel.advanced_extension) - return _msg; -} -inline void ProjectRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.ProjectRel.advanced_extension) -} - -// ------------------------------------------------------------------- - -// JoinRel - -// .substrait.RelCommon common = 1; -inline bool JoinRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool JoinRel::has_common() const { - return _internal_has_common(); -} -inline void JoinRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& JoinRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& JoinRel::common() const { - // @@protoc_insertion_point(field_get:substrait.JoinRel.common) - return _internal_common(); -} -inline void JoinRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.common) -} -inline ::substrait::RelCommon* JoinRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* JoinRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.JoinRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* JoinRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* JoinRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.JoinRel.common) - return _msg; -} -inline void JoinRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.common) -} - -// .substrait.Rel left = 2; -inline bool JoinRel::_internal_has_left() const { - return this != internal_default_instance() && left_ != nullptr; -} -inline bool JoinRel::has_left() const { - return _internal_has_left(); -} -inline void JoinRel::clear_left() { - if (GetArenaForAllocation() == nullptr && left_ != nullptr) { - delete left_; - } - left_ = nullptr; -} -inline const ::substrait::Rel& JoinRel::_internal_left() const { - const ::substrait::Rel* p = left_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Rel_default_instance_); -} -inline const ::substrait::Rel& JoinRel::left() const { - // @@protoc_insertion_point(field_get:substrait.JoinRel.left) - return _internal_left(); -} -inline void JoinRel::unsafe_arena_set_allocated_left( - ::substrait::Rel* left) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(left_); - } - left_ = left; - if (left) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.left) -} -inline ::substrait::Rel* JoinRel::release_left() { - - ::substrait::Rel* temp = left_; - left_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Rel* JoinRel::unsafe_arena_release_left() { - // @@protoc_insertion_point(field_release:substrait.JoinRel.left) - - ::substrait::Rel* temp = left_; - left_ = nullptr; - return temp; -} -inline ::substrait::Rel* JoinRel::_internal_mutable_left() { - - if (left_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); - left_ = p; - } - return left_; -} -inline ::substrait::Rel* JoinRel::mutable_left() { - ::substrait::Rel* _msg = _internal_mutable_left(); - // @@protoc_insertion_point(field_mutable:substrait.JoinRel.left) - return _msg; -} -inline void JoinRel::set_allocated_left(::substrait::Rel* left) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete left_; - } - if (left) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(left); - if (message_arena != submessage_arena) { - left = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, left, submessage_arena); - } - - } else { - - } - left_ = left; - // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.left) -} - -// .substrait.Rel right = 3; -inline bool JoinRel::_internal_has_right() const { - return this != internal_default_instance() && right_ != nullptr; -} -inline bool JoinRel::has_right() const { - return _internal_has_right(); -} -inline void JoinRel::clear_right() { - if (GetArenaForAllocation() == nullptr && right_ != nullptr) { - delete right_; - } - right_ = nullptr; -} -inline const ::substrait::Rel& JoinRel::_internal_right() const { - const ::substrait::Rel* p = right_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Rel_default_instance_); -} -inline const ::substrait::Rel& JoinRel::right() const { - // @@protoc_insertion_point(field_get:substrait.JoinRel.right) - return _internal_right(); -} -inline void JoinRel::unsafe_arena_set_allocated_right( - ::substrait::Rel* right) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(right_); - } - right_ = right; - if (right) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.right) -} -inline ::substrait::Rel* JoinRel::release_right() { - - ::substrait::Rel* temp = right_; - right_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Rel* JoinRel::unsafe_arena_release_right() { - // @@protoc_insertion_point(field_release:substrait.JoinRel.right) - - ::substrait::Rel* temp = right_; - right_ = nullptr; - return temp; -} -inline ::substrait::Rel* JoinRel::_internal_mutable_right() { - - if (right_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); - right_ = p; - } - return right_; -} -inline ::substrait::Rel* JoinRel::mutable_right() { - ::substrait::Rel* _msg = _internal_mutable_right(); - // @@protoc_insertion_point(field_mutable:substrait.JoinRel.right) - return _msg; -} -inline void JoinRel::set_allocated_right(::substrait::Rel* right) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete right_; - } - if (right) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(right); - if (message_arena != submessage_arena) { - right = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, right, submessage_arena); - } - - } else { - - } - right_ = right; - // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.right) -} - -// .substrait.Expression expression = 4; -inline bool JoinRel::_internal_has_expression() const { - return this != internal_default_instance() && expression_ != nullptr; -} -inline bool JoinRel::has_expression() const { - return _internal_has_expression(); -} -inline const ::substrait::Expression& JoinRel::_internal_expression() const { - const ::substrait::Expression* p = expression_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& JoinRel::expression() const { - // @@protoc_insertion_point(field_get:substrait.JoinRel.expression) - return _internal_expression(); -} -inline void JoinRel::unsafe_arena_set_allocated_expression( - ::substrait::Expression* expression) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); - } - expression_ = expression; - if (expression) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.expression) -} -inline ::substrait::Expression* JoinRel::release_expression() { - - ::substrait::Expression* temp = expression_; - expression_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* JoinRel::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_release:substrait.JoinRel.expression) - - ::substrait::Expression* temp = expression_; - expression_ = nullptr; - return temp; -} -inline ::substrait::Expression* JoinRel::_internal_mutable_expression() { - - if (expression_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - expression_ = p; - } - return expression_; -} -inline ::substrait::Expression* JoinRel::mutable_expression() { - ::substrait::Expression* _msg = _internal_mutable_expression(); - // @@protoc_insertion_point(field_mutable:substrait.JoinRel.expression) - return _msg; -} -inline void JoinRel::set_allocated_expression(::substrait::Expression* expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); - } - if (expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression)); - if (message_arena != submessage_arena) { - expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, expression, submessage_arena); - } - - } else { - - } - expression_ = expression; - // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.expression) -} - -// .substrait.Expression post_join_filter = 5; -inline bool JoinRel::_internal_has_post_join_filter() const { - return this != internal_default_instance() && post_join_filter_ != nullptr; -} -inline bool JoinRel::has_post_join_filter() const { - return _internal_has_post_join_filter(); -} -inline const ::substrait::Expression& JoinRel::_internal_post_join_filter() const { - const ::substrait::Expression* p = post_join_filter_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& JoinRel::post_join_filter() const { - // @@protoc_insertion_point(field_get:substrait.JoinRel.post_join_filter) - return _internal_post_join_filter(); -} -inline void JoinRel::unsafe_arena_set_allocated_post_join_filter( - ::substrait::Expression* post_join_filter) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); - } - post_join_filter_ = post_join_filter; - if (post_join_filter) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.post_join_filter) -} -inline ::substrait::Expression* JoinRel::release_post_join_filter() { - - ::substrait::Expression* temp = post_join_filter_; - post_join_filter_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* JoinRel::unsafe_arena_release_post_join_filter() { - // @@protoc_insertion_point(field_release:substrait.JoinRel.post_join_filter) - - ::substrait::Expression* temp = post_join_filter_; - post_join_filter_ = nullptr; - return temp; -} -inline ::substrait::Expression* JoinRel::_internal_mutable_post_join_filter() { - - if (post_join_filter_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - post_join_filter_ = p; - } - return post_join_filter_; -} -inline ::substrait::Expression* JoinRel::mutable_post_join_filter() { - ::substrait::Expression* _msg = _internal_mutable_post_join_filter(); - // @@protoc_insertion_point(field_mutable:substrait.JoinRel.post_join_filter) - return _msg; -} -inline void JoinRel::set_allocated_post_join_filter(::substrait::Expression* post_join_filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter_); - } - if (post_join_filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(post_join_filter)); - if (message_arena != submessage_arena) { - post_join_filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, post_join_filter, submessage_arena); - } - - } else { - - } - post_join_filter_ = post_join_filter; - // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.post_join_filter) -} - -// .substrait.JoinRel.JoinType type = 6; -inline void JoinRel::clear_type() { - type_ = 0; -} -inline ::substrait::JoinRel_JoinType JoinRel::_internal_type() const { - return static_cast< ::substrait::JoinRel_JoinType >(type_); -} -inline ::substrait::JoinRel_JoinType JoinRel::type() const { - // @@protoc_insertion_point(field_get:substrait.JoinRel.type) - return _internal_type(); -} -inline void JoinRel::_internal_set_type(::substrait::JoinRel_JoinType value) { - - type_ = value; -} -inline void JoinRel::set_type(::substrait::JoinRel_JoinType value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:substrait.JoinRel.type) -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool JoinRel::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool JoinRel::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& JoinRel::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& JoinRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.JoinRel.advanced_extension) - return _internal_advanced_extension(); -} -inline void JoinRel::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.JoinRel.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* JoinRel::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* JoinRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.JoinRel.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* JoinRel::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* JoinRel::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.JoinRel.advanced_extension) - return _msg; -} -inline void JoinRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.JoinRel.advanced_extension) -} - -// ------------------------------------------------------------------- - -// FetchRel - -// .substrait.RelCommon common = 1; -inline bool FetchRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool FetchRel::has_common() const { - return _internal_has_common(); -} -inline void FetchRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& FetchRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& FetchRel::common() const { - // @@protoc_insertion_point(field_get:substrait.FetchRel.common) - return _internal_common(); -} -inline void FetchRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FetchRel.common) -} -inline ::substrait::RelCommon* FetchRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* FetchRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.FetchRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* FetchRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* FetchRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.FetchRel.common) - return _msg; -} -inline void FetchRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.FetchRel.common) -} - -// .substrait.Rel input = 2; -inline bool FetchRel::_internal_has_input() const { - return this != internal_default_instance() && input_ != nullptr; -} -inline bool FetchRel::has_input() const { - return _internal_has_input(); -} -inline void FetchRel::clear_input() { - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; -} -inline const ::substrait::Rel& FetchRel::_internal_input() const { - const ::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Rel_default_instance_); -} -inline const ::substrait::Rel& FetchRel::input() const { - // @@protoc_insertion_point(field_get:substrait.FetchRel.input) - return _internal_input(); -} -inline void FetchRel::unsafe_arena_set_allocated_input( - ::substrait::Rel* input) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); - } - input_ = input; - if (input) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FetchRel.input) -} -inline ::substrait::Rel* FetchRel::release_input() { - - ::substrait::Rel* temp = input_; - input_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Rel* FetchRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:substrait.FetchRel.input) - - ::substrait::Rel* temp = input_; - input_ = nullptr; - return temp; -} -inline ::substrait::Rel* FetchRel::_internal_mutable_input() { - - if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); - input_ = p; - } - return input_; -} -inline ::substrait::Rel* FetchRel::mutable_input() { - ::substrait::Rel* _msg = _internal_mutable_input(); - // @@protoc_insertion_point(field_mutable:substrait.FetchRel.input) - return _msg; -} -inline void FetchRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete input_; - } - if (input) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); - if (message_arena != submessage_arena) { - input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, input, submessage_arena); - } - - } else { - - } - input_ = input; - // @@protoc_insertion_point(field_set_allocated:substrait.FetchRel.input) -} - -// int64 offset = 3; -inline void FetchRel::clear_offset() { - offset_ = int64_t{0}; -} -inline int64_t FetchRel::_internal_offset() const { - return offset_; -} -inline int64_t FetchRel::offset() const { - // @@protoc_insertion_point(field_get:substrait.FetchRel.offset) - return _internal_offset(); -} -inline void FetchRel::_internal_set_offset(int64_t value) { - - offset_ = value; -} -inline void FetchRel::set_offset(int64_t value) { - _internal_set_offset(value); - // @@protoc_insertion_point(field_set:substrait.FetchRel.offset) -} - -// int64 count = 4; -inline void FetchRel::clear_count() { - count_ = int64_t{0}; -} -inline int64_t FetchRel::_internal_count() const { - return count_; -} -inline int64_t FetchRel::count() const { - // @@protoc_insertion_point(field_get:substrait.FetchRel.count) - return _internal_count(); -} -inline void FetchRel::_internal_set_count(int64_t value) { - - count_ = value; -} -inline void FetchRel::set_count(int64_t value) { - _internal_set_count(value); - // @@protoc_insertion_point(field_set:substrait.FetchRel.count) -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool FetchRel::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool FetchRel::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& FetchRel::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& FetchRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.FetchRel.advanced_extension) - return _internal_advanced_extension(); -} -inline void FetchRel::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FetchRel.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* FetchRel::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* FetchRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.FetchRel.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* FetchRel::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* FetchRel::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.FetchRel.advanced_extension) - return _msg; -} -inline void FetchRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.FetchRel.advanced_extension) -} - -// ------------------------------------------------------------------- - -// AggregateRel_Grouping - -// repeated .substrait.Expression grouping_expressions = 1; -inline int AggregateRel_Grouping::_internal_grouping_expressions_size() const { - return grouping_expressions_.size(); -} -inline int AggregateRel_Grouping::grouping_expressions_size() const { - return _internal_grouping_expressions_size(); -} -inline ::substrait::Expression* AggregateRel_Grouping::mutable_grouping_expressions(int index) { - // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Grouping.grouping_expressions) - return grouping_expressions_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >* -AggregateRel_Grouping::mutable_grouping_expressions() { - // @@protoc_insertion_point(field_mutable_list:substrait.AggregateRel.Grouping.grouping_expressions) - return &grouping_expressions_; -} -inline const ::substrait::Expression& AggregateRel_Grouping::_internal_grouping_expressions(int index) const { - return grouping_expressions_.Get(index); -} -inline const ::substrait::Expression& AggregateRel_Grouping::grouping_expressions(int index) const { - // @@protoc_insertion_point(field_get:substrait.AggregateRel.Grouping.grouping_expressions) - return _internal_grouping_expressions(index); -} -inline ::substrait::Expression* AggregateRel_Grouping::_internal_add_grouping_expressions() { - return grouping_expressions_.Add(); -} -inline ::substrait::Expression* AggregateRel_Grouping::add_grouping_expressions() { - ::substrait::Expression* _add = _internal_add_grouping_expressions(); - // @@protoc_insertion_point(field_add:substrait.AggregateRel.Grouping.grouping_expressions) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Expression >& -AggregateRel_Grouping::grouping_expressions() const { - // @@protoc_insertion_point(field_list:substrait.AggregateRel.Grouping.grouping_expressions) - return grouping_expressions_; -} - -// ------------------------------------------------------------------- - -// AggregateRel_Measure - -// .substrait.AggregateFunction measure = 1; -inline bool AggregateRel_Measure::_internal_has_measure() const { - return this != internal_default_instance() && measure_ != nullptr; -} -inline bool AggregateRel_Measure::has_measure() const { - return _internal_has_measure(); -} -inline const ::substrait::AggregateFunction& AggregateRel_Measure::_internal_measure() const { - const ::substrait::AggregateFunction* p = measure_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_AggregateFunction_default_instance_); -} -inline const ::substrait::AggregateFunction& AggregateRel_Measure::measure() const { - // @@protoc_insertion_point(field_get:substrait.AggregateRel.Measure.measure) - return _internal_measure(); -} -inline void AggregateRel_Measure::unsafe_arena_set_allocated_measure( - ::substrait::AggregateFunction* measure) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); - } - measure_ = measure; - if (measure) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.Measure.measure) -} -inline ::substrait::AggregateFunction* AggregateRel_Measure::release_measure() { - - ::substrait::AggregateFunction* temp = measure_; - measure_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::AggregateFunction* AggregateRel_Measure::unsafe_arena_release_measure() { - // @@protoc_insertion_point(field_release:substrait.AggregateRel.Measure.measure) - - ::substrait::AggregateFunction* temp = measure_; - measure_ = nullptr; - return temp; -} -inline ::substrait::AggregateFunction* AggregateRel_Measure::_internal_mutable_measure() { - - if (measure_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::AggregateFunction>(GetArenaForAllocation()); - measure_ = p; - } - return measure_; -} -inline ::substrait::AggregateFunction* AggregateRel_Measure::mutable_measure() { - ::substrait::AggregateFunction* _msg = _internal_mutable_measure(); - // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Measure.measure) - return _msg; -} -inline void AggregateRel_Measure::set_allocated_measure(::substrait::AggregateFunction* measure) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure_); - } - if (measure) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(measure)); - if (message_arena != submessage_arena) { - measure = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, measure, submessage_arena); - } - - } else { - - } - measure_ = measure; - // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.Measure.measure) -} - -// .substrait.Expression filter = 2; -inline bool AggregateRel_Measure::_internal_has_filter() const { - return this != internal_default_instance() && filter_ != nullptr; -} -inline bool AggregateRel_Measure::has_filter() const { - return _internal_has_filter(); -} -inline const ::substrait::Expression& AggregateRel_Measure::_internal_filter() const { - const ::substrait::Expression* p = filter_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& AggregateRel_Measure::filter() const { - // @@protoc_insertion_point(field_get:substrait.AggregateRel.Measure.filter) - return _internal_filter(); -} -inline void AggregateRel_Measure::unsafe_arena_set_allocated_filter( - ::substrait::Expression* filter) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); - } - filter_ = filter; - if (filter) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.Measure.filter) -} -inline ::substrait::Expression* AggregateRel_Measure::release_filter() { - - ::substrait::Expression* temp = filter_; - filter_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* AggregateRel_Measure::unsafe_arena_release_filter() { - // @@protoc_insertion_point(field_release:substrait.AggregateRel.Measure.filter) - - ::substrait::Expression* temp = filter_; - filter_ = nullptr; - return temp; -} -inline ::substrait::Expression* AggregateRel_Measure::_internal_mutable_filter() { - - if (filter_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - filter_ = p; - } - return filter_; -} -inline ::substrait::Expression* AggregateRel_Measure::mutable_filter() { - ::substrait::Expression* _msg = _internal_mutable_filter(); - // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.Measure.filter) - return _msg; -} -inline void AggregateRel_Measure::set_allocated_filter(::substrait::Expression* filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter_); - } - if (filter) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(filter)); - if (message_arena != submessage_arena) { - filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, filter, submessage_arena); - } - - } else { - - } - filter_ = filter; - // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.Measure.filter) -} - -// ------------------------------------------------------------------- - -// AggregateRel - -// .substrait.RelCommon common = 1; -inline bool AggregateRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool AggregateRel::has_common() const { - return _internal_has_common(); -} -inline void AggregateRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& AggregateRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& AggregateRel::common() const { - // @@protoc_insertion_point(field_get:substrait.AggregateRel.common) - return _internal_common(); -} -inline void AggregateRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.common) -} -inline ::substrait::RelCommon* AggregateRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* AggregateRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.AggregateRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* AggregateRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* AggregateRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.common) - return _msg; -} -inline void AggregateRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.common) -} - -// .substrait.Rel input = 2; -inline bool AggregateRel::_internal_has_input() const { - return this != internal_default_instance() && input_ != nullptr; -} -inline bool AggregateRel::has_input() const { - return _internal_has_input(); -} -inline void AggregateRel::clear_input() { - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; -} -inline const ::substrait::Rel& AggregateRel::_internal_input() const { - const ::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Rel_default_instance_); -} -inline const ::substrait::Rel& AggregateRel::input() const { - // @@protoc_insertion_point(field_get:substrait.AggregateRel.input) - return _internal_input(); -} -inline void AggregateRel::unsafe_arena_set_allocated_input( - ::substrait::Rel* input) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); - } - input_ = input; - if (input) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.input) -} -inline ::substrait::Rel* AggregateRel::release_input() { - - ::substrait::Rel* temp = input_; - input_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Rel* AggregateRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:substrait.AggregateRel.input) - - ::substrait::Rel* temp = input_; - input_ = nullptr; - return temp; -} -inline ::substrait::Rel* AggregateRel::_internal_mutable_input() { - - if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); - input_ = p; - } - return input_; -} -inline ::substrait::Rel* AggregateRel::mutable_input() { - ::substrait::Rel* _msg = _internal_mutable_input(); - // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.input) - return _msg; -} -inline void AggregateRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete input_; - } - if (input) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); - if (message_arena != submessage_arena) { - input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, input, submessage_arena); - } - - } else { - - } - input_ = input; - // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.input) -} - -// repeated .substrait.AggregateRel.Grouping groupings = 3; -inline int AggregateRel::_internal_groupings_size() const { - return groupings_.size(); -} -inline int AggregateRel::groupings_size() const { - return _internal_groupings_size(); -} -inline void AggregateRel::clear_groupings() { - groupings_.Clear(); -} -inline ::substrait::AggregateRel_Grouping* AggregateRel::mutable_groupings(int index) { - // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.groupings) - return groupings_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >* -AggregateRel::mutable_groupings() { - // @@protoc_insertion_point(field_mutable_list:substrait.AggregateRel.groupings) - return &groupings_; -} -inline const ::substrait::AggregateRel_Grouping& AggregateRel::_internal_groupings(int index) const { - return groupings_.Get(index); -} -inline const ::substrait::AggregateRel_Grouping& AggregateRel::groupings(int index) const { - // @@protoc_insertion_point(field_get:substrait.AggregateRel.groupings) - return _internal_groupings(index); -} -inline ::substrait::AggregateRel_Grouping* AggregateRel::_internal_add_groupings() { - return groupings_.Add(); -} -inline ::substrait::AggregateRel_Grouping* AggregateRel::add_groupings() { - ::substrait::AggregateRel_Grouping* _add = _internal_add_groupings(); - // @@protoc_insertion_point(field_add:substrait.AggregateRel.groupings) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Grouping >& -AggregateRel::groupings() const { - // @@protoc_insertion_point(field_list:substrait.AggregateRel.groupings) - return groupings_; -} - -// repeated .substrait.AggregateRel.Measure measures = 4; -inline int AggregateRel::_internal_measures_size() const { - return measures_.size(); -} -inline int AggregateRel::measures_size() const { - return _internal_measures_size(); -} -inline void AggregateRel::clear_measures() { - measures_.Clear(); -} -inline ::substrait::AggregateRel_Measure* AggregateRel::mutable_measures(int index) { - // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.measures) - return measures_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >* -AggregateRel::mutable_measures() { - // @@protoc_insertion_point(field_mutable_list:substrait.AggregateRel.measures) - return &measures_; -} -inline const ::substrait::AggregateRel_Measure& AggregateRel::_internal_measures(int index) const { - return measures_.Get(index); -} -inline const ::substrait::AggregateRel_Measure& AggregateRel::measures(int index) const { - // @@protoc_insertion_point(field_get:substrait.AggregateRel.measures) - return _internal_measures(index); -} -inline ::substrait::AggregateRel_Measure* AggregateRel::_internal_add_measures() { - return measures_.Add(); -} -inline ::substrait::AggregateRel_Measure* AggregateRel::add_measures() { - ::substrait::AggregateRel_Measure* _add = _internal_add_measures(); - // @@protoc_insertion_point(field_add:substrait.AggregateRel.measures) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::AggregateRel_Measure >& -AggregateRel::measures() const { - // @@protoc_insertion_point(field_list:substrait.AggregateRel.measures) - return measures_; -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool AggregateRel::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool AggregateRel::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& AggregateRel::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& AggregateRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.AggregateRel.advanced_extension) - return _internal_advanced_extension(); -} -inline void AggregateRel::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.AggregateRel.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* AggregateRel::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* AggregateRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.AggregateRel.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* AggregateRel::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* AggregateRel::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.AggregateRel.advanced_extension) - return _msg; -} -inline void AggregateRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.AggregateRel.advanced_extension) -} - -// ------------------------------------------------------------------- - -// SortRel - -// .substrait.RelCommon common = 1; -inline bool SortRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool SortRel::has_common() const { - return _internal_has_common(); -} -inline void SortRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& SortRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& SortRel::common() const { - // @@protoc_insertion_point(field_get:substrait.SortRel.common) - return _internal_common(); -} -inline void SortRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortRel.common) -} -inline ::substrait::RelCommon* SortRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* SortRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.SortRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* SortRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* SortRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.SortRel.common) - return _msg; -} -inline void SortRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.SortRel.common) -} - -// .substrait.Rel input = 2; -inline bool SortRel::_internal_has_input() const { - return this != internal_default_instance() && input_ != nullptr; -} -inline bool SortRel::has_input() const { - return _internal_has_input(); -} -inline void SortRel::clear_input() { - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; -} -inline const ::substrait::Rel& SortRel::_internal_input() const { - const ::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Rel_default_instance_); -} -inline const ::substrait::Rel& SortRel::input() const { - // @@protoc_insertion_point(field_get:substrait.SortRel.input) - return _internal_input(); -} -inline void SortRel::unsafe_arena_set_allocated_input( - ::substrait::Rel* input) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); - } - input_ = input; - if (input) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortRel.input) -} -inline ::substrait::Rel* SortRel::release_input() { - - ::substrait::Rel* temp = input_; - input_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Rel* SortRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:substrait.SortRel.input) - - ::substrait::Rel* temp = input_; - input_ = nullptr; - return temp; -} -inline ::substrait::Rel* SortRel::_internal_mutable_input() { - - if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); - input_ = p; - } - return input_; -} -inline ::substrait::Rel* SortRel::mutable_input() { - ::substrait::Rel* _msg = _internal_mutable_input(); - // @@protoc_insertion_point(field_mutable:substrait.SortRel.input) - return _msg; -} -inline void SortRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete input_; - } - if (input) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); - if (message_arena != submessage_arena) { - input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, input, submessage_arena); - } - - } else { - - } - input_ = input; - // @@protoc_insertion_point(field_set_allocated:substrait.SortRel.input) -} - -// repeated .substrait.SortField sorts = 3; -inline int SortRel::_internal_sorts_size() const { - return sorts_.size(); -} -inline int SortRel::sorts_size() const { - return _internal_sorts_size(); -} -inline ::substrait::SortField* SortRel::mutable_sorts(int index) { - // @@protoc_insertion_point(field_mutable:substrait.SortRel.sorts) - return sorts_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >* -SortRel::mutable_sorts() { - // @@protoc_insertion_point(field_mutable_list:substrait.SortRel.sorts) - return &sorts_; -} -inline const ::substrait::SortField& SortRel::_internal_sorts(int index) const { - return sorts_.Get(index); -} -inline const ::substrait::SortField& SortRel::sorts(int index) const { - // @@protoc_insertion_point(field_get:substrait.SortRel.sorts) - return _internal_sorts(index); -} -inline ::substrait::SortField* SortRel::_internal_add_sorts() { - return sorts_.Add(); -} -inline ::substrait::SortField* SortRel::add_sorts() { - ::substrait::SortField* _add = _internal_add_sorts(); - // @@protoc_insertion_point(field_add:substrait.SortRel.sorts) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::SortField >& -SortRel::sorts() const { - // @@protoc_insertion_point(field_list:substrait.SortRel.sorts) - return sorts_; -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool SortRel::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool SortRel::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& SortRel::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& SortRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.SortRel.advanced_extension) - return _internal_advanced_extension(); -} -inline void SortRel::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SortRel.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* SortRel::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* SortRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.SortRel.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* SortRel::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* SortRel::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.SortRel.advanced_extension) - return _msg; -} -inline void SortRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.SortRel.advanced_extension) -} - -// ------------------------------------------------------------------- - -// FilterRel - -// .substrait.RelCommon common = 1; -inline bool FilterRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool FilterRel::has_common() const { - return _internal_has_common(); -} -inline void FilterRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& FilterRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& FilterRel::common() const { - // @@protoc_insertion_point(field_get:substrait.FilterRel.common) - return _internal_common(); -} -inline void FilterRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.common) -} -inline ::substrait::RelCommon* FilterRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* FilterRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.FilterRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* FilterRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* FilterRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.FilterRel.common) - return _msg; -} -inline void FilterRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.common) -} - -// .substrait.Rel input = 2; -inline bool FilterRel::_internal_has_input() const { - return this != internal_default_instance() && input_ != nullptr; -} -inline bool FilterRel::has_input() const { - return _internal_has_input(); -} -inline void FilterRel::clear_input() { - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; -} -inline const ::substrait::Rel& FilterRel::_internal_input() const { - const ::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Rel_default_instance_); -} -inline const ::substrait::Rel& FilterRel::input() const { - // @@protoc_insertion_point(field_get:substrait.FilterRel.input) - return _internal_input(); -} -inline void FilterRel::unsafe_arena_set_allocated_input( - ::substrait::Rel* input) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); - } - input_ = input; - if (input) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.input) -} -inline ::substrait::Rel* FilterRel::release_input() { - - ::substrait::Rel* temp = input_; - input_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Rel* FilterRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:substrait.FilterRel.input) - - ::substrait::Rel* temp = input_; - input_ = nullptr; - return temp; -} -inline ::substrait::Rel* FilterRel::_internal_mutable_input() { - - if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); - input_ = p; - } - return input_; -} -inline ::substrait::Rel* FilterRel::mutable_input() { - ::substrait::Rel* _msg = _internal_mutable_input(); - // @@protoc_insertion_point(field_mutable:substrait.FilterRel.input) - return _msg; -} -inline void FilterRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete input_; - } - if (input) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); - if (message_arena != submessage_arena) { - input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, input, submessage_arena); - } - - } else { - - } - input_ = input; - // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.input) -} - -// .substrait.Expression condition = 3; -inline bool FilterRel::_internal_has_condition() const { - return this != internal_default_instance() && condition_ != nullptr; -} -inline bool FilterRel::has_condition() const { - return _internal_has_condition(); -} -inline const ::substrait::Expression& FilterRel::_internal_condition() const { - const ::substrait::Expression* p = condition_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Expression_default_instance_); -} -inline const ::substrait::Expression& FilterRel::condition() const { - // @@protoc_insertion_point(field_get:substrait.FilterRel.condition) - return _internal_condition(); -} -inline void FilterRel::unsafe_arena_set_allocated_condition( - ::substrait::Expression* condition) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); - } - condition_ = condition; - if (condition) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.condition) -} -inline ::substrait::Expression* FilterRel::release_condition() { - - ::substrait::Expression* temp = condition_; - condition_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Expression* FilterRel::unsafe_arena_release_condition() { - // @@protoc_insertion_point(field_release:substrait.FilterRel.condition) - - ::substrait::Expression* temp = condition_; - condition_ = nullptr; - return temp; -} -inline ::substrait::Expression* FilterRel::_internal_mutable_condition() { - - if (condition_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Expression>(GetArenaForAllocation()); - condition_ = p; - } - return condition_; -} -inline ::substrait::Expression* FilterRel::mutable_condition() { - ::substrait::Expression* _msg = _internal_mutable_condition(); - // @@protoc_insertion_point(field_mutable:substrait.FilterRel.condition) - return _msg; -} -inline void FilterRel::set_allocated_condition(::substrait::Expression* condition) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition_); - } - if (condition) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(condition)); - if (message_arena != submessage_arena) { - condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, condition, submessage_arena); - } - - } else { - - } - condition_ = condition; - // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.condition) -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool FilterRel::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool FilterRel::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& FilterRel::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& FilterRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.FilterRel.advanced_extension) - return _internal_advanced_extension(); -} -inline void FilterRel::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.FilterRel.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* FilterRel::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* FilterRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.FilterRel.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* FilterRel::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* FilterRel::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.FilterRel.advanced_extension) - return _msg; -} -inline void FilterRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.FilterRel.advanced_extension) -} - -// ------------------------------------------------------------------- - -// SetRel - -// .substrait.RelCommon common = 1; -inline bool SetRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool SetRel::has_common() const { - return _internal_has_common(); -} -inline void SetRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& SetRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& SetRel::common() const { - // @@protoc_insertion_point(field_get:substrait.SetRel.common) - return _internal_common(); -} -inline void SetRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SetRel.common) -} -inline ::substrait::RelCommon* SetRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* SetRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.SetRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* SetRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* SetRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.SetRel.common) - return _msg; -} -inline void SetRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.SetRel.common) -} - -// repeated .substrait.Rel inputs = 2; -inline int SetRel::_internal_inputs_size() const { - return inputs_.size(); -} -inline int SetRel::inputs_size() const { - return _internal_inputs_size(); -} -inline void SetRel::clear_inputs() { - inputs_.Clear(); -} -inline ::substrait::Rel* SetRel::mutable_inputs(int index) { - // @@protoc_insertion_point(field_mutable:substrait.SetRel.inputs) - return inputs_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >* -SetRel::mutable_inputs() { - // @@protoc_insertion_point(field_mutable_list:substrait.SetRel.inputs) - return &inputs_; -} -inline const ::substrait::Rel& SetRel::_internal_inputs(int index) const { - return inputs_.Get(index); -} -inline const ::substrait::Rel& SetRel::inputs(int index) const { - // @@protoc_insertion_point(field_get:substrait.SetRel.inputs) - return _internal_inputs(index); -} -inline ::substrait::Rel* SetRel::_internal_add_inputs() { - return inputs_.Add(); -} -inline ::substrait::Rel* SetRel::add_inputs() { - ::substrait::Rel* _add = _internal_add_inputs(); - // @@protoc_insertion_point(field_add:substrait.SetRel.inputs) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >& -SetRel::inputs() const { - // @@protoc_insertion_point(field_list:substrait.SetRel.inputs) - return inputs_; -} - -// .substrait.SetRel.SetOp op = 3; -inline void SetRel::clear_op() { - op_ = 0; -} -inline ::substrait::SetRel_SetOp SetRel::_internal_op() const { - return static_cast< ::substrait::SetRel_SetOp >(op_); -} -inline ::substrait::SetRel_SetOp SetRel::op() const { - // @@protoc_insertion_point(field_get:substrait.SetRel.op) - return _internal_op(); -} -inline void SetRel::_internal_set_op(::substrait::SetRel_SetOp value) { - - op_ = value; -} -inline void SetRel::set_op(::substrait::SetRel_SetOp value) { - _internal_set_op(value); - // @@protoc_insertion_point(field_set:substrait.SetRel.op) -} - -// .substrait.extensions.AdvancedExtension advanced_extension = 10; -inline bool SetRel::_internal_has_advanced_extension() const { - return this != internal_default_instance() && advanced_extension_ != nullptr; -} -inline bool SetRel::has_advanced_extension() const { - return _internal_has_advanced_extension(); -} -inline const ::substrait::extensions::AdvancedExtension& SetRel::_internal_advanced_extension() const { - const ::substrait::extensions::AdvancedExtension* p = advanced_extension_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::extensions::_AdvancedExtension_default_instance_); -} -inline const ::substrait::extensions::AdvancedExtension& SetRel::advanced_extension() const { - // @@protoc_insertion_point(field_get:substrait.SetRel.advanced_extension) - return _internal_advanced_extension(); -} -inline void SetRel::unsafe_arena_set_allocated_advanced_extension( - ::substrait::extensions::AdvancedExtension* advanced_extension) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - advanced_extension_ = advanced_extension; - if (advanced_extension) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.SetRel.advanced_extension) -} -inline ::substrait::extensions::AdvancedExtension* SetRel::release_advanced_extension() { - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::extensions::AdvancedExtension* SetRel::unsafe_arena_release_advanced_extension() { - // @@protoc_insertion_point(field_release:substrait.SetRel.advanced_extension) - - ::substrait::extensions::AdvancedExtension* temp = advanced_extension_; - advanced_extension_ = nullptr; - return temp; -} -inline ::substrait::extensions::AdvancedExtension* SetRel::_internal_mutable_advanced_extension() { - - if (advanced_extension_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::extensions::AdvancedExtension>(GetArenaForAllocation()); - advanced_extension_ = p; - } - return advanced_extension_; -} -inline ::substrait::extensions::AdvancedExtension* SetRel::mutable_advanced_extension() { - ::substrait::extensions::AdvancedExtension* _msg = _internal_mutable_advanced_extension(); - // @@protoc_insertion_point(field_mutable:substrait.SetRel.advanced_extension) - return _msg; -} -inline void SetRel::set_allocated_advanced_extension(::substrait::extensions::AdvancedExtension* advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension_); - } - if (advanced_extension) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(advanced_extension)); - if (message_arena != submessage_arena) { - advanced_extension = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, advanced_extension, submessage_arena); - } - - } else { - - } - advanced_extension_ = advanced_extension; - // @@protoc_insertion_point(field_set_allocated:substrait.SetRel.advanced_extension) -} - -// ------------------------------------------------------------------- - -// ExtensionSingleRel - -// .substrait.RelCommon common = 1; -inline bool ExtensionSingleRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool ExtensionSingleRel::has_common() const { - return _internal_has_common(); -} -inline void ExtensionSingleRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& ExtensionSingleRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& ExtensionSingleRel::common() const { - // @@protoc_insertion_point(field_get:substrait.ExtensionSingleRel.common) - return _internal_common(); -} -inline void ExtensionSingleRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionSingleRel.common) -} -inline ::substrait::RelCommon* ExtensionSingleRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* ExtensionSingleRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.ExtensionSingleRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* ExtensionSingleRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* ExtensionSingleRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.common) - return _msg; -} -inline void ExtensionSingleRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionSingleRel.common) -} - -// .substrait.Rel input = 2; -inline bool ExtensionSingleRel::_internal_has_input() const { - return this != internal_default_instance() && input_ != nullptr; -} -inline bool ExtensionSingleRel::has_input() const { - return _internal_has_input(); -} -inline void ExtensionSingleRel::clear_input() { - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; -} -inline const ::substrait::Rel& ExtensionSingleRel::_internal_input() const { - const ::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Rel_default_instance_); -} -inline const ::substrait::Rel& ExtensionSingleRel::input() const { - // @@protoc_insertion_point(field_get:substrait.ExtensionSingleRel.input) - return _internal_input(); -} -inline void ExtensionSingleRel::unsafe_arena_set_allocated_input( - ::substrait::Rel* input) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); - } - input_ = input; - if (input) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionSingleRel.input) -} -inline ::substrait::Rel* ExtensionSingleRel::release_input() { - - ::substrait::Rel* temp = input_; - input_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Rel* ExtensionSingleRel::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:substrait.ExtensionSingleRel.input) - - ::substrait::Rel* temp = input_; - input_ = nullptr; - return temp; -} -inline ::substrait::Rel* ExtensionSingleRel::_internal_mutable_input() { - - if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); - input_ = p; - } - return input_; -} -inline ::substrait::Rel* ExtensionSingleRel::mutable_input() { - ::substrait::Rel* _msg = _internal_mutable_input(); - // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.input) - return _msg; -} -inline void ExtensionSingleRel::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete input_; - } - if (input) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); - if (message_arena != submessage_arena) { - input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, input, submessage_arena); - } - - } else { - - } - input_ = input; - // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionSingleRel.input) -} - -// .google.protobuf.Any detail = 3; -inline bool ExtensionSingleRel::_internal_has_detail() const { - return this != internal_default_instance() && detail_ != nullptr; -} -inline bool ExtensionSingleRel::has_detail() const { - return _internal_has_detail(); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::_internal_detail() const { - const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_; - return p != nullptr ? *p : reinterpret_cast( - ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionSingleRel::detail() const { - // @@protoc_insertion_point(field_get:substrait.ExtensionSingleRel.detail) - return _internal_detail(); -} -inline void ExtensionSingleRel::unsafe_arena_set_allocated_detail( - ::PROTOBUF_NAMESPACE_ID::Any* detail) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); - } - detail_ = detail; - if (detail) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionSingleRel.detail) -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::release_detail() { - - ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; - detail_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::unsafe_arena_release_detail() { - // @@protoc_insertion_point(field_release:substrait.ExtensionSingleRel.detail) - - ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; - detail_ = nullptr; - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::_internal_mutable_detail() { - - if (detail_ == nullptr) { - auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); - detail_ = p; - } - return detail_; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionSingleRel::mutable_detail() { - ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail(); - // @@protoc_insertion_point(field_mutable:substrait.ExtensionSingleRel.detail) - return _msg; -} -inline void ExtensionSingleRel::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); - } - if (detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)); - if (message_arena != submessage_arena) { - detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, detail, submessage_arena); - } - - } else { - - } - detail_ = detail; - // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionSingleRel.detail) -} - -// ------------------------------------------------------------------- - -// ExtensionLeafRel - -// .substrait.RelCommon common = 1; -inline bool ExtensionLeafRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool ExtensionLeafRel::has_common() const { - return _internal_has_common(); -} -inline void ExtensionLeafRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& ExtensionLeafRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& ExtensionLeafRel::common() const { - // @@protoc_insertion_point(field_get:substrait.ExtensionLeafRel.common) - return _internal_common(); -} -inline void ExtensionLeafRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionLeafRel.common) -} -inline ::substrait::RelCommon* ExtensionLeafRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* ExtensionLeafRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.ExtensionLeafRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* ExtensionLeafRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* ExtensionLeafRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.ExtensionLeafRel.common) - return _msg; -} -inline void ExtensionLeafRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionLeafRel.common) -} - -// .google.protobuf.Any detail = 2; -inline bool ExtensionLeafRel::_internal_has_detail() const { - return this != internal_default_instance() && detail_ != nullptr; -} -inline bool ExtensionLeafRel::has_detail() const { - return _internal_has_detail(); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::_internal_detail() const { - const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_; - return p != nullptr ? *p : reinterpret_cast( - ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionLeafRel::detail() const { - // @@protoc_insertion_point(field_get:substrait.ExtensionLeafRel.detail) - return _internal_detail(); -} -inline void ExtensionLeafRel::unsafe_arena_set_allocated_detail( - ::PROTOBUF_NAMESPACE_ID::Any* detail) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); - } - detail_ = detail; - if (detail) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionLeafRel.detail) -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::release_detail() { - - ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; - detail_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::unsafe_arena_release_detail() { - // @@protoc_insertion_point(field_release:substrait.ExtensionLeafRel.detail) - - ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; - detail_ = nullptr; - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::_internal_mutable_detail() { - - if (detail_ == nullptr) { - auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); - detail_ = p; - } - return detail_; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionLeafRel::mutable_detail() { - ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail(); - // @@protoc_insertion_point(field_mutable:substrait.ExtensionLeafRel.detail) - return _msg; -} -inline void ExtensionLeafRel::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); - } - if (detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)); - if (message_arena != submessage_arena) { - detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, detail, submessage_arena); - } - - } else { - - } - detail_ = detail; - // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionLeafRel.detail) -} - -// ------------------------------------------------------------------- - -// ExtensionMultiRel - -// .substrait.RelCommon common = 1; -inline bool ExtensionMultiRel::_internal_has_common() const { - return this != internal_default_instance() && common_ != nullptr; -} -inline bool ExtensionMultiRel::has_common() const { - return _internal_has_common(); -} -inline void ExtensionMultiRel::clear_common() { - if (GetArenaForAllocation() == nullptr && common_ != nullptr) { - delete common_; - } - common_ = nullptr; -} -inline const ::substrait::RelCommon& ExtensionMultiRel::_internal_common() const { - const ::substrait::RelCommon* p = common_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_RelCommon_default_instance_); -} -inline const ::substrait::RelCommon& ExtensionMultiRel::common() const { - // @@protoc_insertion_point(field_get:substrait.ExtensionMultiRel.common) - return _internal_common(); -} -inline void ExtensionMultiRel::unsafe_arena_set_allocated_common( - ::substrait::RelCommon* common) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(common_); - } - common_ = common; - if (common) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionMultiRel.common) -} -inline ::substrait::RelCommon* ExtensionMultiRel::release_common() { - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::RelCommon* ExtensionMultiRel::unsafe_arena_release_common() { - // @@protoc_insertion_point(field_release:substrait.ExtensionMultiRel.common) - - ::substrait::RelCommon* temp = common_; - common_ = nullptr; - return temp; -} -inline ::substrait::RelCommon* ExtensionMultiRel::_internal_mutable_common() { - - if (common_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::RelCommon>(GetArenaForAllocation()); - common_ = p; - } - return common_; -} -inline ::substrait::RelCommon* ExtensionMultiRel::mutable_common() { - ::substrait::RelCommon* _msg = _internal_mutable_common(); - // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.common) - return _msg; -} -inline void ExtensionMultiRel::set_allocated_common(::substrait::RelCommon* common) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete common_; - } - if (common) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::RelCommon>::GetOwningArena(common); - if (message_arena != submessage_arena) { - common = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, common, submessage_arena); - } - - } else { - - } - common_ = common; - // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionMultiRel.common) -} - -// repeated .substrait.Rel inputs = 2; -inline int ExtensionMultiRel::_internal_inputs_size() const { - return inputs_.size(); -} -inline int ExtensionMultiRel::inputs_size() const { - return _internal_inputs_size(); -} -inline void ExtensionMultiRel::clear_inputs() { - inputs_.Clear(); -} -inline ::substrait::Rel* ExtensionMultiRel::mutable_inputs(int index) { - // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.inputs) - return inputs_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >* -ExtensionMultiRel::mutable_inputs() { - // @@protoc_insertion_point(field_mutable_list:substrait.ExtensionMultiRel.inputs) - return &inputs_; -} -inline const ::substrait::Rel& ExtensionMultiRel::_internal_inputs(int index) const { - return inputs_.Get(index); -} -inline const ::substrait::Rel& ExtensionMultiRel::inputs(int index) const { - // @@protoc_insertion_point(field_get:substrait.ExtensionMultiRel.inputs) - return _internal_inputs(index); -} -inline ::substrait::Rel* ExtensionMultiRel::_internal_add_inputs() { - return inputs_.Add(); -} -inline ::substrait::Rel* ExtensionMultiRel::add_inputs() { - ::substrait::Rel* _add = _internal_add_inputs(); - // @@protoc_insertion_point(field_add:substrait.ExtensionMultiRel.inputs) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Rel >& -ExtensionMultiRel::inputs() const { - // @@protoc_insertion_point(field_list:substrait.ExtensionMultiRel.inputs) - return inputs_; -} - -// .google.protobuf.Any detail = 3; -inline bool ExtensionMultiRel::_internal_has_detail() const { - return this != internal_default_instance() && detail_ != nullptr; -} -inline bool ExtensionMultiRel::has_detail() const { - return _internal_has_detail(); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::_internal_detail() const { - const ::PROTOBUF_NAMESPACE_ID::Any* p = detail_; - return p != nullptr ? *p : reinterpret_cast( - ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_); -} -inline const ::PROTOBUF_NAMESPACE_ID::Any& ExtensionMultiRel::detail() const { - // @@protoc_insertion_point(field_get:substrait.ExtensionMultiRel.detail) - return _internal_detail(); -} -inline void ExtensionMultiRel::unsafe_arena_set_allocated_detail( - ::PROTOBUF_NAMESPACE_ID::Any* detail) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); - } - detail_ = detail; - if (detail) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.ExtensionMultiRel.detail) -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::release_detail() { - - ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; - detail_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::unsafe_arena_release_detail() { - // @@protoc_insertion_point(field_release:substrait.ExtensionMultiRel.detail) - - ::PROTOBUF_NAMESPACE_ID::Any* temp = detail_; - detail_ = nullptr; - return temp; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::_internal_mutable_detail() { - - if (detail_ == nullptr) { - auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation()); - detail_ = p; - } - return detail_; -} -inline ::PROTOBUF_NAMESPACE_ID::Any* ExtensionMultiRel::mutable_detail() { - ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_detail(); - // @@protoc_insertion_point(field_mutable:substrait.ExtensionMultiRel.detail) - return _msg; -} -inline void ExtensionMultiRel::set_allocated_detail(::PROTOBUF_NAMESPACE_ID::Any* detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail_); - } - if (detail) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(detail)); - if (message_arena != submessage_arena) { - detail = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, detail, submessage_arena); - } - - } else { - - } - detail_ = detail; - // @@protoc_insertion_point(field_set_allocated:substrait.ExtensionMultiRel.detail) -} - -// ------------------------------------------------------------------- - -// RelRoot - -// .substrait.Rel input = 1; -inline bool RelRoot::_internal_has_input() const { - return this != internal_default_instance() && input_ != nullptr; -} -inline bool RelRoot::has_input() const { - return _internal_has_input(); -} -inline void RelRoot::clear_input() { - if (GetArenaForAllocation() == nullptr && input_ != nullptr) { - delete input_; - } - input_ = nullptr; -} -inline const ::substrait::Rel& RelRoot::_internal_input() const { - const ::substrait::Rel* p = input_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Rel_default_instance_); -} -inline const ::substrait::Rel& RelRoot::input() const { - // @@protoc_insertion_point(field_get:substrait.RelRoot.input) - return _internal_input(); -} -inline void RelRoot::unsafe_arena_set_allocated_input( - ::substrait::Rel* input) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(input_); - } - input_ = input; - if (input) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.RelRoot.input) -} -inline ::substrait::Rel* RelRoot::release_input() { - - ::substrait::Rel* temp = input_; - input_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Rel* RelRoot::unsafe_arena_release_input() { - // @@protoc_insertion_point(field_release:substrait.RelRoot.input) - - ::substrait::Rel* temp = input_; - input_ = nullptr; - return temp; -} -inline ::substrait::Rel* RelRoot::_internal_mutable_input() { - - if (input_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Rel>(GetArenaForAllocation()); - input_ = p; - } - return input_; -} -inline ::substrait::Rel* RelRoot::mutable_input() { - ::substrait::Rel* _msg = _internal_mutable_input(); - // @@protoc_insertion_point(field_mutable:substrait.RelRoot.input) - return _msg; -} -inline void RelRoot::set_allocated_input(::substrait::Rel* input) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete input_; - } - if (input) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Rel>::GetOwningArena(input); - if (message_arena != submessage_arena) { - input = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, input, submessage_arena); - } - - } else { - - } - input_ = input; - // @@protoc_insertion_point(field_set_allocated:substrait.RelRoot.input) -} - -// repeated string names = 2; -inline int RelRoot::_internal_names_size() const { - return names_.size(); -} -inline int RelRoot::names_size() const { - return _internal_names_size(); -} -inline void RelRoot::clear_names() { - names_.Clear(); -} -inline std::string* RelRoot::add_names() { - std::string* _s = _internal_add_names(); - // @@protoc_insertion_point(field_add_mutable:substrait.RelRoot.names) - return _s; -} -inline const std::string& RelRoot::_internal_names(int index) const { - return names_.Get(index); -} -inline const std::string& RelRoot::names(int index) const { - // @@protoc_insertion_point(field_get:substrait.RelRoot.names) - return _internal_names(index); -} -inline std::string* RelRoot::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:substrait.RelRoot.names) - return names_.Mutable(index); -} -inline void RelRoot::set_names(int index, const std::string& value) { - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.RelRoot.names) -} -inline void RelRoot::set_names(int index, std::string&& value) { - names_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.RelRoot.names) -} -inline void RelRoot::set_names(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.RelRoot.names) -} -inline void RelRoot::set_names(int index, const char* value, size_t size) { - names_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.RelRoot.names) -} -inline std::string* RelRoot::_internal_add_names() { - return names_.Add(); -} -inline void RelRoot::add_names(const std::string& value) { - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.RelRoot.names) -} -inline void RelRoot::add_names(std::string&& value) { - names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.RelRoot.names) -} -inline void RelRoot::add_names(const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.RelRoot.names) -} -inline void RelRoot::add_names(const char* value, size_t size) { - names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.RelRoot.names) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -RelRoot::names() const { - // @@protoc_insertion_point(field_list:substrait.RelRoot.names) - return names_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -RelRoot::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:substrait.RelRoot.names) - return &names_; -} - -// ------------------------------------------------------------------- - -// Rel - -// .substrait.ReadRel read = 1; -inline bool Rel::_internal_has_read() const { - return rel_type_case() == kRead; -} -inline bool Rel::has_read() const { - return _internal_has_read(); -} -inline void Rel::set_has_read() { - _oneof_case_[0] = kRead; -} -inline void Rel::clear_read() { - if (_internal_has_read()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.read_; - } - clear_has_rel_type(); - } -} -inline ::substrait::ReadRel* Rel::release_read() { - // @@protoc_insertion_point(field_release:substrait.Rel.read) - if (_internal_has_read()) { - clear_has_rel_type(); - ::substrait::ReadRel* temp = rel_type_.read_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.read_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ReadRel& Rel::_internal_read() const { - return _internal_has_read() - ? *rel_type_.read_ - : reinterpret_cast< ::substrait::ReadRel&>(::substrait::_ReadRel_default_instance_); -} -inline const ::substrait::ReadRel& Rel::read() const { - // @@protoc_insertion_point(field_get:substrait.Rel.read) - return _internal_read(); -} -inline ::substrait::ReadRel* Rel::unsafe_arena_release_read() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.read) - if (_internal_has_read()) { - clear_has_rel_type(); - ::substrait::ReadRel* temp = rel_type_.read_; - rel_type_.read_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_read(::substrait::ReadRel* read) { - clear_rel_type(); - if (read) { - set_has_read(); - rel_type_.read_ = read; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.read) -} -inline ::substrait::ReadRel* Rel::_internal_mutable_read() { - if (!_internal_has_read()) { - clear_rel_type(); - set_has_read(); - rel_type_.read_ = CreateMaybeMessage< ::substrait::ReadRel >(GetArenaForAllocation()); - } - return rel_type_.read_; -} -inline ::substrait::ReadRel* Rel::mutable_read() { - ::substrait::ReadRel* _msg = _internal_mutable_read(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.read) - return _msg; -} - -// .substrait.FilterRel filter = 2; -inline bool Rel::_internal_has_filter() const { - return rel_type_case() == kFilter; -} -inline bool Rel::has_filter() const { - return _internal_has_filter(); -} -inline void Rel::set_has_filter() { - _oneof_case_[0] = kFilter; -} -inline void Rel::clear_filter() { - if (_internal_has_filter()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.filter_; - } - clear_has_rel_type(); - } -} -inline ::substrait::FilterRel* Rel::release_filter() { - // @@protoc_insertion_point(field_release:substrait.Rel.filter) - if (_internal_has_filter()) { - clear_has_rel_type(); - ::substrait::FilterRel* temp = rel_type_.filter_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.filter_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FilterRel& Rel::_internal_filter() const { - return _internal_has_filter() - ? *rel_type_.filter_ - : reinterpret_cast< ::substrait::FilterRel&>(::substrait::_FilterRel_default_instance_); -} -inline const ::substrait::FilterRel& Rel::filter() const { - // @@protoc_insertion_point(field_get:substrait.Rel.filter) - return _internal_filter(); -} -inline ::substrait::FilterRel* Rel::unsafe_arena_release_filter() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.filter) - if (_internal_has_filter()) { - clear_has_rel_type(); - ::substrait::FilterRel* temp = rel_type_.filter_; - rel_type_.filter_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_filter(::substrait::FilterRel* filter) { - clear_rel_type(); - if (filter) { - set_has_filter(); - rel_type_.filter_ = filter; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.filter) -} -inline ::substrait::FilterRel* Rel::_internal_mutable_filter() { - if (!_internal_has_filter()) { - clear_rel_type(); - set_has_filter(); - rel_type_.filter_ = CreateMaybeMessage< ::substrait::FilterRel >(GetArenaForAllocation()); - } - return rel_type_.filter_; -} -inline ::substrait::FilterRel* Rel::mutable_filter() { - ::substrait::FilterRel* _msg = _internal_mutable_filter(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.filter) - return _msg; -} - -// .substrait.FetchRel fetch = 3; -inline bool Rel::_internal_has_fetch() const { - return rel_type_case() == kFetch; -} -inline bool Rel::has_fetch() const { - return _internal_has_fetch(); -} -inline void Rel::set_has_fetch() { - _oneof_case_[0] = kFetch; -} -inline void Rel::clear_fetch() { - if (_internal_has_fetch()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.fetch_; - } - clear_has_rel_type(); - } -} -inline ::substrait::FetchRel* Rel::release_fetch() { - // @@protoc_insertion_point(field_release:substrait.Rel.fetch) - if (_internal_has_fetch()) { - clear_has_rel_type(); - ::substrait::FetchRel* temp = rel_type_.fetch_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.fetch_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::FetchRel& Rel::_internal_fetch() const { - return _internal_has_fetch() - ? *rel_type_.fetch_ - : reinterpret_cast< ::substrait::FetchRel&>(::substrait::_FetchRel_default_instance_); -} -inline const ::substrait::FetchRel& Rel::fetch() const { - // @@protoc_insertion_point(field_get:substrait.Rel.fetch) - return _internal_fetch(); -} -inline ::substrait::FetchRel* Rel::unsafe_arena_release_fetch() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.fetch) - if (_internal_has_fetch()) { - clear_has_rel_type(); - ::substrait::FetchRel* temp = rel_type_.fetch_; - rel_type_.fetch_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_fetch(::substrait::FetchRel* fetch) { - clear_rel_type(); - if (fetch) { - set_has_fetch(); - rel_type_.fetch_ = fetch; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.fetch) -} -inline ::substrait::FetchRel* Rel::_internal_mutable_fetch() { - if (!_internal_has_fetch()) { - clear_rel_type(); - set_has_fetch(); - rel_type_.fetch_ = CreateMaybeMessage< ::substrait::FetchRel >(GetArenaForAllocation()); - } - return rel_type_.fetch_; -} -inline ::substrait::FetchRel* Rel::mutable_fetch() { - ::substrait::FetchRel* _msg = _internal_mutable_fetch(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.fetch) - return _msg; -} - -// .substrait.AggregateRel aggregate = 4; -inline bool Rel::_internal_has_aggregate() const { - return rel_type_case() == kAggregate; -} -inline bool Rel::has_aggregate() const { - return _internal_has_aggregate(); -} -inline void Rel::set_has_aggregate() { - _oneof_case_[0] = kAggregate; -} -inline void Rel::clear_aggregate() { - if (_internal_has_aggregate()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.aggregate_; - } - clear_has_rel_type(); - } -} -inline ::substrait::AggregateRel* Rel::release_aggregate() { - // @@protoc_insertion_point(field_release:substrait.Rel.aggregate) - if (_internal_has_aggregate()) { - clear_has_rel_type(); - ::substrait::AggregateRel* temp = rel_type_.aggregate_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.aggregate_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::AggregateRel& Rel::_internal_aggregate() const { - return _internal_has_aggregate() - ? *rel_type_.aggregate_ - : reinterpret_cast< ::substrait::AggregateRel&>(::substrait::_AggregateRel_default_instance_); -} -inline const ::substrait::AggregateRel& Rel::aggregate() const { - // @@protoc_insertion_point(field_get:substrait.Rel.aggregate) - return _internal_aggregate(); -} -inline ::substrait::AggregateRel* Rel::unsafe_arena_release_aggregate() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.aggregate) - if (_internal_has_aggregate()) { - clear_has_rel_type(); - ::substrait::AggregateRel* temp = rel_type_.aggregate_; - rel_type_.aggregate_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_aggregate(::substrait::AggregateRel* aggregate) { - clear_rel_type(); - if (aggregate) { - set_has_aggregate(); - rel_type_.aggregate_ = aggregate; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.aggregate) -} -inline ::substrait::AggregateRel* Rel::_internal_mutable_aggregate() { - if (!_internal_has_aggregate()) { - clear_rel_type(); - set_has_aggregate(); - rel_type_.aggregate_ = CreateMaybeMessage< ::substrait::AggregateRel >(GetArenaForAllocation()); - } - return rel_type_.aggregate_; -} -inline ::substrait::AggregateRel* Rel::mutable_aggregate() { - ::substrait::AggregateRel* _msg = _internal_mutable_aggregate(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.aggregate) - return _msg; -} - -// .substrait.SortRel sort = 5; -inline bool Rel::_internal_has_sort() const { - return rel_type_case() == kSort; -} -inline bool Rel::has_sort() const { - return _internal_has_sort(); -} -inline void Rel::set_has_sort() { - _oneof_case_[0] = kSort; -} -inline void Rel::clear_sort() { - if (_internal_has_sort()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.sort_; - } - clear_has_rel_type(); - } -} -inline ::substrait::SortRel* Rel::release_sort() { - // @@protoc_insertion_point(field_release:substrait.Rel.sort) - if (_internal_has_sort()) { - clear_has_rel_type(); - ::substrait::SortRel* temp = rel_type_.sort_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.sort_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::SortRel& Rel::_internal_sort() const { - return _internal_has_sort() - ? *rel_type_.sort_ - : reinterpret_cast< ::substrait::SortRel&>(::substrait::_SortRel_default_instance_); -} -inline const ::substrait::SortRel& Rel::sort() const { - // @@protoc_insertion_point(field_get:substrait.Rel.sort) - return _internal_sort(); -} -inline ::substrait::SortRel* Rel::unsafe_arena_release_sort() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.sort) - if (_internal_has_sort()) { - clear_has_rel_type(); - ::substrait::SortRel* temp = rel_type_.sort_; - rel_type_.sort_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_sort(::substrait::SortRel* sort) { - clear_rel_type(); - if (sort) { - set_has_sort(); - rel_type_.sort_ = sort; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.sort) -} -inline ::substrait::SortRel* Rel::_internal_mutable_sort() { - if (!_internal_has_sort()) { - clear_rel_type(); - set_has_sort(); - rel_type_.sort_ = CreateMaybeMessage< ::substrait::SortRel >(GetArenaForAllocation()); - } - return rel_type_.sort_; -} -inline ::substrait::SortRel* Rel::mutable_sort() { - ::substrait::SortRel* _msg = _internal_mutable_sort(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.sort) - return _msg; -} - -// .substrait.JoinRel join = 6; -inline bool Rel::_internal_has_join() const { - return rel_type_case() == kJoin; -} -inline bool Rel::has_join() const { - return _internal_has_join(); -} -inline void Rel::set_has_join() { - _oneof_case_[0] = kJoin; -} -inline void Rel::clear_join() { - if (_internal_has_join()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.join_; - } - clear_has_rel_type(); - } -} -inline ::substrait::JoinRel* Rel::release_join() { - // @@protoc_insertion_point(field_release:substrait.Rel.join) - if (_internal_has_join()) { - clear_has_rel_type(); - ::substrait::JoinRel* temp = rel_type_.join_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.join_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::JoinRel& Rel::_internal_join() const { - return _internal_has_join() - ? *rel_type_.join_ - : reinterpret_cast< ::substrait::JoinRel&>(::substrait::_JoinRel_default_instance_); -} -inline const ::substrait::JoinRel& Rel::join() const { - // @@protoc_insertion_point(field_get:substrait.Rel.join) - return _internal_join(); -} -inline ::substrait::JoinRel* Rel::unsafe_arena_release_join() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.join) - if (_internal_has_join()) { - clear_has_rel_type(); - ::substrait::JoinRel* temp = rel_type_.join_; - rel_type_.join_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_join(::substrait::JoinRel* join) { - clear_rel_type(); - if (join) { - set_has_join(); - rel_type_.join_ = join; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.join) -} -inline ::substrait::JoinRel* Rel::_internal_mutable_join() { - if (!_internal_has_join()) { - clear_rel_type(); - set_has_join(); - rel_type_.join_ = CreateMaybeMessage< ::substrait::JoinRel >(GetArenaForAllocation()); - } - return rel_type_.join_; -} -inline ::substrait::JoinRel* Rel::mutable_join() { - ::substrait::JoinRel* _msg = _internal_mutable_join(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.join) - return _msg; -} - -// .substrait.ProjectRel project = 7; -inline bool Rel::_internal_has_project() const { - return rel_type_case() == kProject; -} -inline bool Rel::has_project() const { - return _internal_has_project(); -} -inline void Rel::set_has_project() { - _oneof_case_[0] = kProject; -} -inline void Rel::clear_project() { - if (_internal_has_project()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.project_; - } - clear_has_rel_type(); - } -} -inline ::substrait::ProjectRel* Rel::release_project() { - // @@protoc_insertion_point(field_release:substrait.Rel.project) - if (_internal_has_project()) { - clear_has_rel_type(); - ::substrait::ProjectRel* temp = rel_type_.project_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.project_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ProjectRel& Rel::_internal_project() const { - return _internal_has_project() - ? *rel_type_.project_ - : reinterpret_cast< ::substrait::ProjectRel&>(::substrait::_ProjectRel_default_instance_); -} -inline const ::substrait::ProjectRel& Rel::project() const { - // @@protoc_insertion_point(field_get:substrait.Rel.project) - return _internal_project(); -} -inline ::substrait::ProjectRel* Rel::unsafe_arena_release_project() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.project) - if (_internal_has_project()) { - clear_has_rel_type(); - ::substrait::ProjectRel* temp = rel_type_.project_; - rel_type_.project_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_project(::substrait::ProjectRel* project) { - clear_rel_type(); - if (project) { - set_has_project(); - rel_type_.project_ = project; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.project) -} -inline ::substrait::ProjectRel* Rel::_internal_mutable_project() { - if (!_internal_has_project()) { - clear_rel_type(); - set_has_project(); - rel_type_.project_ = CreateMaybeMessage< ::substrait::ProjectRel >(GetArenaForAllocation()); - } - return rel_type_.project_; -} -inline ::substrait::ProjectRel* Rel::mutable_project() { - ::substrait::ProjectRel* _msg = _internal_mutable_project(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.project) - return _msg; -} - -// .substrait.SetRel set = 8; -inline bool Rel::_internal_has_set() const { - return rel_type_case() == kSet; -} -inline bool Rel::has_set() const { - return _internal_has_set(); -} -inline void Rel::set_has_set() { - _oneof_case_[0] = kSet; -} -inline void Rel::clear_set() { - if (_internal_has_set()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.set_; - } - clear_has_rel_type(); - } -} -inline ::substrait::SetRel* Rel::release_set() { - // @@protoc_insertion_point(field_release:substrait.Rel.set) - if (_internal_has_set()) { - clear_has_rel_type(); - ::substrait::SetRel* temp = rel_type_.set_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.set_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::SetRel& Rel::_internal_set() const { - return _internal_has_set() - ? *rel_type_.set_ - : reinterpret_cast< ::substrait::SetRel&>(::substrait::_SetRel_default_instance_); -} -inline const ::substrait::SetRel& Rel::set() const { - // @@protoc_insertion_point(field_get:substrait.Rel.set) - return _internal_set(); -} -inline ::substrait::SetRel* Rel::unsafe_arena_release_set() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.set) - if (_internal_has_set()) { - clear_has_rel_type(); - ::substrait::SetRel* temp = rel_type_.set_; - rel_type_.set_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_set(::substrait::SetRel* set) { - clear_rel_type(); - if (set) { - set_has_set(); - rel_type_.set_ = set; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.set) -} -inline ::substrait::SetRel* Rel::_internal_mutable_set() { - if (!_internal_has_set()) { - clear_rel_type(); - set_has_set(); - rel_type_.set_ = CreateMaybeMessage< ::substrait::SetRel >(GetArenaForAllocation()); - } - return rel_type_.set_; -} -inline ::substrait::SetRel* Rel::mutable_set() { - ::substrait::SetRel* _msg = _internal_mutable_set(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.set) - return _msg; -} - -// .substrait.ExtensionSingleRel extension_single = 9; -inline bool Rel::_internal_has_extension_single() const { - return rel_type_case() == kExtensionSingle; -} -inline bool Rel::has_extension_single() const { - return _internal_has_extension_single(); -} -inline void Rel::set_has_extension_single() { - _oneof_case_[0] = kExtensionSingle; -} -inline void Rel::clear_extension_single() { - if (_internal_has_extension_single()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.extension_single_; - } - clear_has_rel_type(); - } -} -inline ::substrait::ExtensionSingleRel* Rel::release_extension_single() { - // @@protoc_insertion_point(field_release:substrait.Rel.extension_single) - if (_internal_has_extension_single()) { - clear_has_rel_type(); - ::substrait::ExtensionSingleRel* temp = rel_type_.extension_single_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.extension_single_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ExtensionSingleRel& Rel::_internal_extension_single() const { - return _internal_has_extension_single() - ? *rel_type_.extension_single_ - : reinterpret_cast< ::substrait::ExtensionSingleRel&>(::substrait::_ExtensionSingleRel_default_instance_); -} -inline const ::substrait::ExtensionSingleRel& Rel::extension_single() const { - // @@protoc_insertion_point(field_get:substrait.Rel.extension_single) - return _internal_extension_single(); -} -inline ::substrait::ExtensionSingleRel* Rel::unsafe_arena_release_extension_single() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.extension_single) - if (_internal_has_extension_single()) { - clear_has_rel_type(); - ::substrait::ExtensionSingleRel* temp = rel_type_.extension_single_; - rel_type_.extension_single_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_extension_single(::substrait::ExtensionSingleRel* extension_single) { - clear_rel_type(); - if (extension_single) { - set_has_extension_single(); - rel_type_.extension_single_ = extension_single; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.extension_single) -} -inline ::substrait::ExtensionSingleRel* Rel::_internal_mutable_extension_single() { - if (!_internal_has_extension_single()) { - clear_rel_type(); - set_has_extension_single(); - rel_type_.extension_single_ = CreateMaybeMessage< ::substrait::ExtensionSingleRel >(GetArenaForAllocation()); - } - return rel_type_.extension_single_; -} -inline ::substrait::ExtensionSingleRel* Rel::mutable_extension_single() { - ::substrait::ExtensionSingleRel* _msg = _internal_mutable_extension_single(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_single) - return _msg; -} - -// .substrait.ExtensionMultiRel extension_multi = 10; -inline bool Rel::_internal_has_extension_multi() const { - return rel_type_case() == kExtensionMulti; -} -inline bool Rel::has_extension_multi() const { - return _internal_has_extension_multi(); -} -inline void Rel::set_has_extension_multi() { - _oneof_case_[0] = kExtensionMulti; -} -inline void Rel::clear_extension_multi() { - if (_internal_has_extension_multi()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.extension_multi_; - } - clear_has_rel_type(); - } -} -inline ::substrait::ExtensionMultiRel* Rel::release_extension_multi() { - // @@protoc_insertion_point(field_release:substrait.Rel.extension_multi) - if (_internal_has_extension_multi()) { - clear_has_rel_type(); - ::substrait::ExtensionMultiRel* temp = rel_type_.extension_multi_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.extension_multi_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ExtensionMultiRel& Rel::_internal_extension_multi() const { - return _internal_has_extension_multi() - ? *rel_type_.extension_multi_ - : reinterpret_cast< ::substrait::ExtensionMultiRel&>(::substrait::_ExtensionMultiRel_default_instance_); -} -inline const ::substrait::ExtensionMultiRel& Rel::extension_multi() const { - // @@protoc_insertion_point(field_get:substrait.Rel.extension_multi) - return _internal_extension_multi(); -} -inline ::substrait::ExtensionMultiRel* Rel::unsafe_arena_release_extension_multi() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.extension_multi) - if (_internal_has_extension_multi()) { - clear_has_rel_type(); - ::substrait::ExtensionMultiRel* temp = rel_type_.extension_multi_; - rel_type_.extension_multi_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_extension_multi(::substrait::ExtensionMultiRel* extension_multi) { - clear_rel_type(); - if (extension_multi) { - set_has_extension_multi(); - rel_type_.extension_multi_ = extension_multi; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.extension_multi) -} -inline ::substrait::ExtensionMultiRel* Rel::_internal_mutable_extension_multi() { - if (!_internal_has_extension_multi()) { - clear_rel_type(); - set_has_extension_multi(); - rel_type_.extension_multi_ = CreateMaybeMessage< ::substrait::ExtensionMultiRel >(GetArenaForAllocation()); - } - return rel_type_.extension_multi_; -} -inline ::substrait::ExtensionMultiRel* Rel::mutable_extension_multi() { - ::substrait::ExtensionMultiRel* _msg = _internal_mutable_extension_multi(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_multi) - return _msg; -} - -// .substrait.ExtensionLeafRel extension_leaf = 11; -inline bool Rel::_internal_has_extension_leaf() const { - return rel_type_case() == kExtensionLeaf; -} -inline bool Rel::has_extension_leaf() const { - return _internal_has_extension_leaf(); -} -inline void Rel::set_has_extension_leaf() { - _oneof_case_[0] = kExtensionLeaf; -} -inline void Rel::clear_extension_leaf() { - if (_internal_has_extension_leaf()) { - if (GetArenaForAllocation() == nullptr) { - delete rel_type_.extension_leaf_; - } - clear_has_rel_type(); - } -} -inline ::substrait::ExtensionLeafRel* Rel::release_extension_leaf() { - // @@protoc_insertion_point(field_release:substrait.Rel.extension_leaf) - if (_internal_has_extension_leaf()) { - clear_has_rel_type(); - ::substrait::ExtensionLeafRel* temp = rel_type_.extension_leaf_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - rel_type_.extension_leaf_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::ExtensionLeafRel& Rel::_internal_extension_leaf() const { - return _internal_has_extension_leaf() - ? *rel_type_.extension_leaf_ - : reinterpret_cast< ::substrait::ExtensionLeafRel&>(::substrait::_ExtensionLeafRel_default_instance_); -} -inline const ::substrait::ExtensionLeafRel& Rel::extension_leaf() const { - // @@protoc_insertion_point(field_get:substrait.Rel.extension_leaf) - return _internal_extension_leaf(); -} -inline ::substrait::ExtensionLeafRel* Rel::unsafe_arena_release_extension_leaf() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Rel.extension_leaf) - if (_internal_has_extension_leaf()) { - clear_has_rel_type(); - ::substrait::ExtensionLeafRel* temp = rel_type_.extension_leaf_; - rel_type_.extension_leaf_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Rel::unsafe_arena_set_allocated_extension_leaf(::substrait::ExtensionLeafRel* extension_leaf) { - clear_rel_type(); - if (extension_leaf) { - set_has_extension_leaf(); - rel_type_.extension_leaf_ = extension_leaf; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Rel.extension_leaf) -} -inline ::substrait::ExtensionLeafRel* Rel::_internal_mutable_extension_leaf() { - if (!_internal_has_extension_leaf()) { - clear_rel_type(); - set_has_extension_leaf(); - rel_type_.extension_leaf_ = CreateMaybeMessage< ::substrait::ExtensionLeafRel >(GetArenaForAllocation()); - } - return rel_type_.extension_leaf_; -} -inline ::substrait::ExtensionLeafRel* Rel::mutable_extension_leaf() { - ::substrait::ExtensionLeafRel* _msg = _internal_mutable_extension_leaf(); - // @@protoc_insertion_point(field_mutable:substrait.Rel.extension_leaf) - return _msg; -} - -inline bool Rel::has_rel_type() const { - return rel_type_case() != REL_TYPE_NOT_SET; -} -inline void Rel::clear_has_rel_type() { - _oneof_case_[0] = REL_TYPE_NOT_SET; -} -inline Rel::RelTypeCase Rel::rel_type_case() const { - return Rel::RelTypeCase(_oneof_case_[0]); -} -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace substrait - -PROTOBUF_NAMESPACE_OPEN - -template <> struct is_proto_enum< ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat>() { - return ::substrait::ReadRel_LocalFiles_FileOrFiles_FileFormat_descriptor(); -} -template <> struct is_proto_enum< ::substrait::JoinRel_JoinType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::JoinRel_JoinType>() { - return ::substrait::JoinRel_JoinType_descriptor(); -} -template <> struct is_proto_enum< ::substrait::SetRel_SetOp> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::SetRel_SetOp>() { - return ::substrait::SetRel_SetOp_descriptor(); -} - -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2frelations_2eproto diff --git a/cpp/src/generated/substrait/type.pb.cc b/cpp/src/generated/substrait/type.pb.cc deleted file mode 100644 index 5bb5b015941..00000000000 --- a/cpp/src/generated/substrait/type.pb.cc +++ /dev/null @@ -1,7858 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/type.proto - -#include "substrait/type.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace substrait { -constexpr Type_Boolean::Type_Boolean( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_BooleanDefaultTypeInternal { - constexpr Type_BooleanDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_BooleanDefaultTypeInternal() {} - union { - Type_Boolean _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_BooleanDefaultTypeInternal _Type_Boolean_default_instance_; -constexpr Type_I8::Type_I8( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_I8DefaultTypeInternal { - constexpr Type_I8DefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_I8DefaultTypeInternal() {} - union { - Type_I8 _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I8DefaultTypeInternal _Type_I8_default_instance_; -constexpr Type_I16::Type_I16( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_I16DefaultTypeInternal { - constexpr Type_I16DefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_I16DefaultTypeInternal() {} - union { - Type_I16 _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I16DefaultTypeInternal _Type_I16_default_instance_; -constexpr Type_I32::Type_I32( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_I32DefaultTypeInternal { - constexpr Type_I32DefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_I32DefaultTypeInternal() {} - union { - Type_I32 _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I32DefaultTypeInternal _Type_I32_default_instance_; -constexpr Type_I64::Type_I64( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_I64DefaultTypeInternal { - constexpr Type_I64DefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_I64DefaultTypeInternal() {} - union { - Type_I64 _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_I64DefaultTypeInternal _Type_I64_default_instance_; -constexpr Type_FP32::Type_FP32( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_FP32DefaultTypeInternal { - constexpr Type_FP32DefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_FP32DefaultTypeInternal() {} - union { - Type_FP32 _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FP32DefaultTypeInternal _Type_FP32_default_instance_; -constexpr Type_FP64::Type_FP64( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_FP64DefaultTypeInternal { - constexpr Type_FP64DefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_FP64DefaultTypeInternal() {} - union { - Type_FP64 _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FP64DefaultTypeInternal _Type_FP64_default_instance_; -constexpr Type_String::Type_String( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_StringDefaultTypeInternal { - constexpr Type_StringDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_StringDefaultTypeInternal() {} - union { - Type_String _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_StringDefaultTypeInternal _Type_String_default_instance_; -constexpr Type_Binary::Type_Binary( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_BinaryDefaultTypeInternal { - constexpr Type_BinaryDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_BinaryDefaultTypeInternal() {} - union { - Type_Binary _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_BinaryDefaultTypeInternal _Type_Binary_default_instance_; -constexpr Type_Timestamp::Type_Timestamp( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_TimestampDefaultTypeInternal { - constexpr Type_TimestampDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_TimestampDefaultTypeInternal() {} - union { - Type_Timestamp _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimestampDefaultTypeInternal _Type_Timestamp_default_instance_; -constexpr Type_Date::Type_Date( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_DateDefaultTypeInternal { - constexpr Type_DateDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_DateDefaultTypeInternal() {} - union { - Type_Date _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_DateDefaultTypeInternal _Type_Date_default_instance_; -constexpr Type_Time::Type_Time( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_TimeDefaultTypeInternal { - constexpr Type_TimeDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_TimeDefaultTypeInternal() {} - union { - Type_Time _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimeDefaultTypeInternal _Type_Time_default_instance_; -constexpr Type_TimestampTZ::Type_TimestampTZ( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_TimestampTZDefaultTypeInternal { - constexpr Type_TimestampTZDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_TimestampTZDefaultTypeInternal() {} - union { - Type_TimestampTZ _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_TimestampTZDefaultTypeInternal _Type_TimestampTZ_default_instance_; -constexpr Type_IntervalYear::Type_IntervalYear( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_IntervalYearDefaultTypeInternal { - constexpr Type_IntervalYearDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_IntervalYearDefaultTypeInternal() {} - union { - Type_IntervalYear _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_IntervalYearDefaultTypeInternal _Type_IntervalYear_default_instance_; -constexpr Type_IntervalDay::Type_IntervalDay( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_IntervalDayDefaultTypeInternal { - constexpr Type_IntervalDayDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_IntervalDayDefaultTypeInternal() {} - union { - Type_IntervalDay _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_IntervalDayDefaultTypeInternal _Type_IntervalDay_default_instance_; -constexpr Type_UUID::Type_UUID( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_UUIDDefaultTypeInternal { - constexpr Type_UUIDDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_UUIDDefaultTypeInternal() {} - union { - Type_UUID _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_UUIDDefaultTypeInternal _Type_UUID_default_instance_; -constexpr Type_FixedChar::Type_FixedChar( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : length_(0) - , type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_FixedCharDefaultTypeInternal { - constexpr Type_FixedCharDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_FixedCharDefaultTypeInternal() {} - union { - Type_FixedChar _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FixedCharDefaultTypeInternal _Type_FixedChar_default_instance_; -constexpr Type_VarChar::Type_VarChar( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : length_(0) - , type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_VarCharDefaultTypeInternal { - constexpr Type_VarCharDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_VarCharDefaultTypeInternal() {} - union { - Type_VarChar _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_VarCharDefaultTypeInternal _Type_VarChar_default_instance_; -constexpr Type_FixedBinary::Type_FixedBinary( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : length_(0) - , type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_FixedBinaryDefaultTypeInternal { - constexpr Type_FixedBinaryDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_FixedBinaryDefaultTypeInternal() {} - union { - Type_FixedBinary _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_FixedBinaryDefaultTypeInternal _Type_FixedBinary_default_instance_; -constexpr Type_Decimal::Type_Decimal( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : scale_(0) - , precision_(0) - , type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_DecimalDefaultTypeInternal { - constexpr Type_DecimalDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_DecimalDefaultTypeInternal() {} - union { - Type_Decimal _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_DecimalDefaultTypeInternal _Type_Decimal_default_instance_; -constexpr Type_Struct::Type_Struct( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : types_() - , type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_StructDefaultTypeInternal { - constexpr Type_StructDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_StructDefaultTypeInternal() {} - union { - Type_Struct _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_StructDefaultTypeInternal _Type_Struct_default_instance_; -constexpr Type_List::Type_List( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_(nullptr) - , type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_ListDefaultTypeInternal { - constexpr Type_ListDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_ListDefaultTypeInternal() {} - union { - Type_List _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_ListDefaultTypeInternal _Type_List_default_instance_; -constexpr Type_Map::Type_Map( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : key_(nullptr) - , value_(nullptr) - , type_variation_reference_(0u) - , nullability_(0) -{} -struct Type_MapDefaultTypeInternal { - constexpr Type_MapDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~Type_MapDefaultTypeInternal() {} - union { - Type_Map _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT Type_MapDefaultTypeInternal _Type_Map_default_instance_; -constexpr Type::Type( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct TypeDefaultTypeInternal { - constexpr TypeDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~TypeDefaultTypeInternal() {} - union { - Type _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT TypeDefaultTypeInternal _Type_default_instance_; -constexpr NamedStruct::NamedStruct( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : names_() - , struct__(nullptr){} -struct NamedStructDefaultTypeInternal { - constexpr NamedStructDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~NamedStructDefaultTypeInternal() {} - union { - NamedStruct _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT NamedStructDefaultTypeInternal _NamedStruct_default_instance_; -} // namespace substrait -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ftype_2eproto[25]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ftype_2eproto[1]; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ftype_2eproto = nullptr; - -const uint32_t TableStruct_substrait_2ftype_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Boolean, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_I8, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_I16, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_I32, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_I64, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_FP32, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_FP64, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_String, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_String, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_String, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Binary, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Timestamp, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Date, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Time, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_TimestampTZ, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalYear, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_IntervalDay, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_UUID, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, length_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedChar, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, length_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_VarChar, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, length_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_FixedBinary, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, scale_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, precision_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Decimal, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, types_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Struct, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_List, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_List, type_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_List, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_List, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, key_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, value_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, type_variation_reference_), - PROTOBUF_FIELD_OFFSET(::substrait::Type_Map, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::Type, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::Type, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::Type, kind_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, names_), - PROTOBUF_FIELD_OFFSET(::substrait::NamedStruct, struct__), -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, -1, sizeof(::substrait::Type_Boolean)}, - { 8, -1, -1, sizeof(::substrait::Type_I8)}, - { 16, -1, -1, sizeof(::substrait::Type_I16)}, - { 24, -1, -1, sizeof(::substrait::Type_I32)}, - { 32, -1, -1, sizeof(::substrait::Type_I64)}, - { 40, -1, -1, sizeof(::substrait::Type_FP32)}, - { 48, -1, -1, sizeof(::substrait::Type_FP64)}, - { 56, -1, -1, sizeof(::substrait::Type_String)}, - { 64, -1, -1, sizeof(::substrait::Type_Binary)}, - { 72, -1, -1, sizeof(::substrait::Type_Timestamp)}, - { 80, -1, -1, sizeof(::substrait::Type_Date)}, - { 88, -1, -1, sizeof(::substrait::Type_Time)}, - { 96, -1, -1, sizeof(::substrait::Type_TimestampTZ)}, - { 104, -1, -1, sizeof(::substrait::Type_IntervalYear)}, - { 112, -1, -1, sizeof(::substrait::Type_IntervalDay)}, - { 120, -1, -1, sizeof(::substrait::Type_UUID)}, - { 128, -1, -1, sizeof(::substrait::Type_FixedChar)}, - { 137, -1, -1, sizeof(::substrait::Type_VarChar)}, - { 146, -1, -1, sizeof(::substrait::Type_FixedBinary)}, - { 155, -1, -1, sizeof(::substrait::Type_Decimal)}, - { 165, -1, -1, sizeof(::substrait::Type_Struct)}, - { 174, -1, -1, sizeof(::substrait::Type_List)}, - { 183, -1, -1, sizeof(::substrait::Type_Map)}, - { 193, -1, -1, sizeof(::substrait::Type)}, - { 224, -1, -1, sizeof(::substrait::NamedStruct)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::substrait::_Type_Boolean_default_instance_), - reinterpret_cast(&::substrait::_Type_I8_default_instance_), - reinterpret_cast(&::substrait::_Type_I16_default_instance_), - reinterpret_cast(&::substrait::_Type_I32_default_instance_), - reinterpret_cast(&::substrait::_Type_I64_default_instance_), - reinterpret_cast(&::substrait::_Type_FP32_default_instance_), - reinterpret_cast(&::substrait::_Type_FP64_default_instance_), - reinterpret_cast(&::substrait::_Type_String_default_instance_), - reinterpret_cast(&::substrait::_Type_Binary_default_instance_), - reinterpret_cast(&::substrait::_Type_Timestamp_default_instance_), - reinterpret_cast(&::substrait::_Type_Date_default_instance_), - reinterpret_cast(&::substrait::_Type_Time_default_instance_), - reinterpret_cast(&::substrait::_Type_TimestampTZ_default_instance_), - reinterpret_cast(&::substrait::_Type_IntervalYear_default_instance_), - reinterpret_cast(&::substrait::_Type_IntervalDay_default_instance_), - reinterpret_cast(&::substrait::_Type_UUID_default_instance_), - reinterpret_cast(&::substrait::_Type_FixedChar_default_instance_), - reinterpret_cast(&::substrait::_Type_VarChar_default_instance_), - reinterpret_cast(&::substrait::_Type_FixedBinary_default_instance_), - reinterpret_cast(&::substrait::_Type_Decimal_default_instance_), - reinterpret_cast(&::substrait::_Type_Struct_default_instance_), - reinterpret_cast(&::substrait::_Type_List_default_instance_), - reinterpret_cast(&::substrait::_Type_Map_default_instance_), - reinterpret_cast(&::substrait::_Type_default_instance_), - reinterpret_cast(&::substrait::_NamedStruct_default_instance_), -}; - -const char descriptor_table_protodef_substrait_2ftype_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n\024substrait/type.proto\022\tsubstrait\"\245\033\n\004Ty" - "pe\022\'\n\004bool\030\001 \001(\0132\027.substrait.Type.Boolea" - "nH\000\022 \n\002i8\030\002 \001(\0132\022.substrait.Type.I8H\000\022\"\n" - "\003i16\030\003 \001(\0132\023.substrait.Type.I16H\000\022\"\n\003i32" - "\030\005 \001(\0132\023.substrait.Type.I32H\000\022\"\n\003i64\030\007 \001" - "(\0132\023.substrait.Type.I64H\000\022$\n\004fp32\030\n \001(\0132" - "\024.substrait.Type.FP32H\000\022$\n\004fp64\030\013 \001(\0132\024." - "substrait.Type.FP64H\000\022(\n\006string\030\014 \001(\0132\026." - "substrait.Type.StringH\000\022(\n\006binary\030\r \001(\0132" - "\026.substrait.Type.BinaryH\000\022.\n\ttimestamp\030\016" - " \001(\0132\031.substrait.Type.TimestampH\000\022$\n\004dat" - "e\030\020 \001(\0132\024.substrait.Type.DateH\000\022$\n\004time\030" - "\021 \001(\0132\024.substrait.Type.TimeH\000\0225\n\rinterva" - "l_year\030\023 \001(\0132\034.substrait.Type.IntervalYe" - "arH\000\0223\n\014interval_day\030\024 \001(\0132\033.substrait.T" - "ype.IntervalDayH\000\0223\n\014timestamp_tz\030\035 \001(\0132" - "\033.substrait.Type.TimestampTZH\000\022$\n\004uuid\030 " - " \001(\0132\024.substrait.Type.UUIDH\000\022/\n\nfixed_ch" - "ar\030\025 \001(\0132\031.substrait.Type.FixedCharH\000\022*\n" - "\007varchar\030\026 \001(\0132\027.substrait.Type.VarCharH" - "\000\0223\n\014fixed_binary\030\027 \001(\0132\033.substrait.Type" - ".FixedBinaryH\000\022*\n\007decimal\030\030 \001(\0132\027.substr" - "ait.Type.DecimalH\000\022(\n\006struct\030\031 \001(\0132\026.sub" - "strait.Type.StructH\000\022$\n\004list\030\033 \001(\0132\024.sub" - "strait.Type.ListH\000\022\"\n\003map\030\034 \001(\0132\023.substr" - "ait.Type.MapH\000\022%\n\033user_defined_type_refe" - "rence\030\037 \001(\rH\000\032]\n\007Boolean\022 \n\030type_variati" - "on_reference\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162" - "\033.substrait.Type.Nullability\032X\n\002I8\022 \n\030ty" - "pe_variation_reference\030\001 \001(\r\0220\n\013nullabil" - "ity\030\002 \001(\0162\033.substrait.Type.Nullability\032Y" - "\n\003I16\022 \n\030type_variation_reference\030\001 \001(\r\022" - "0\n\013nullability\030\002 \001(\0162\033.substrait.Type.Nu" - "llability\032Y\n\003I32\022 \n\030type_variation_refer" - "ence\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.substr" - "ait.Type.Nullability\032Y\n\003I64\022 \n\030type_vari" - "ation_reference\030\001 \001(\r\0220\n\013nullability\030\002 \001" - "(\0162\033.substrait.Type.Nullability\032Z\n\004FP32\022" - " \n\030type_variation_reference\030\001 \001(\r\0220\n\013nul" - "lability\030\002 \001(\0162\033.substrait.Type.Nullabil" - "ity\032Z\n\004FP64\022 \n\030type_variation_reference\030" - "\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.substrait.T" - "ype.Nullability\032\\\n\006String\022 \n\030type_variat" - "ion_reference\030\001 \001(\r\0220\n\013nullability\030\002 \001(\016" - "2\033.substrait.Type.Nullability\032\\\n\006Binary\022" - " \n\030type_variation_reference\030\001 \001(\r\0220\n\013nul" - "lability\030\002 \001(\0162\033.substrait.Type.Nullabil" - "ity\032_\n\tTimestamp\022 \n\030type_variation_refer" - "ence\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.substr" - "ait.Type.Nullability\032Z\n\004Date\022 \n\030type_var" - "iation_reference\030\001 \001(\r\0220\n\013nullability\030\002 " - "\001(\0162\033.substrait.Type.Nullability\032Z\n\004Time" - "\022 \n\030type_variation_reference\030\001 \001(\r\0220\n\013nu" - "llability\030\002 \001(\0162\033.substrait.Type.Nullabi" - "lity\032a\n\013TimestampTZ\022 \n\030type_variation_re" - "ference\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.sub" - "strait.Type.Nullability\032b\n\014IntervalYear\022" - " \n\030type_variation_reference\030\001 \001(\r\0220\n\013nul" - "lability\030\002 \001(\0162\033.substrait.Type.Nullabil" - "ity\032a\n\013IntervalDay\022 \n\030type_variation_ref" - "erence\030\001 \001(\r\0220\n\013nullability\030\002 \001(\0162\033.subs" - "trait.Type.Nullability\032Z\n\004UUID\022 \n\030type_v" - "ariation_reference\030\001 \001(\r\0220\n\013nullability\030" - "\002 \001(\0162\033.substrait.Type.Nullability\032o\n\tFi" - "xedChar\022\016\n\006length\030\001 \001(\005\022 \n\030type_variatio" - "n_reference\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033" - ".substrait.Type.Nullability\032m\n\007VarChar\022\016" - "\n\006length\030\001 \001(\005\022 \n\030type_variation_referen" - "ce\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrai" - "t.Type.Nullability\032q\n\013FixedBinary\022\016\n\006len" - "gth\030\001 \001(\005\022 \n\030type_variation_reference\030\002 " - "\001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrait.Typ" - "e.Nullability\032\177\n\007Decimal\022\r\n\005scale\030\001 \001(\005\022" - "\021\n\tprecision\030\002 \001(\005\022 \n\030type_variation_ref" - "erence\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033.subs" - "trait.Type.Nullability\032|\n\006Struct\022\036\n\005type" - "s\030\001 \003(\0132\017.substrait.Type\022 \n\030type_variati" - "on_reference\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162" - "\033.substrait.Type.Nullability\032y\n\004List\022\035\n\004" - "type\030\001 \001(\0132\017.substrait.Type\022 \n\030type_vari" - "ation_reference\030\002 \001(\r\0220\n\013nullability\030\003 \001" - "(\0162\033.substrait.Type.Nullability\032\227\001\n\003Map\022" - "\034\n\003key\030\001 \001(\0132\017.substrait.Type\022\036\n\005value\030\002" - " \001(\0132\017.substrait.Type\022 \n\030type_variation_" - "reference\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033.s" - "ubstrait.Type.Nullability\"^\n\013Nullability" - "\022\033\n\027NULLABILITY_UNSPECIFIED\020\000\022\030\n\024NULLABI" - "LITY_NULLABLE\020\001\022\030\n\024NULLABILITY_REQUIRED\020" - "\002B\006\n\004kind\"D\n\013NamedStruct\022\r\n\005names\030\001 \003(\t\022" - "&\n\006struct\030\002 \001(\0132\026.substrait.Type.StructB" - "+\n\022io.substrait.protoP\001\252\002\022Substrait.Prot" - "obufb\006proto3" - ; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ftype_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_2eproto = { - false, false, 3652, descriptor_table_protodef_substrait_2ftype_2eproto, "substrait/type.proto", - &descriptor_table_substrait_2ftype_2eproto_once, nullptr, 0, 25, - schemas, file_default_instances, TableStruct_substrait_2ftype_2eproto::offsets, - file_level_metadata_substrait_2ftype_2eproto, file_level_enum_descriptors_substrait_2ftype_2eproto, file_level_service_descriptors_substrait_2ftype_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ftype_2eproto_getter() { - return &descriptor_table_substrait_2ftype_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ftype_2eproto(&descriptor_table_substrait_2ftype_2eproto); -namespace substrait { -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_Nullability_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_2eproto); - return file_level_enum_descriptors_substrait_2ftype_2eproto[0]; -} -bool Type_Nullability_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr Type_Nullability Type::NULLABILITY_UNSPECIFIED; -constexpr Type_Nullability Type::NULLABILITY_NULLABLE; -constexpr Type_Nullability Type::NULLABILITY_REQUIRED; -constexpr Type_Nullability Type::Nullability_MIN; -constexpr Type_Nullability Type::Nullability_MAX; -constexpr int Type::Nullability_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) - -// =================================================================== - -class Type_Boolean::_Internal { - public: -}; - -Type_Boolean::Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.Boolean) -} -Type_Boolean::Type_Boolean(const Type_Boolean& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.Boolean) -} - -inline void Type_Boolean::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_Boolean::~Type_Boolean() { - // @@protoc_insertion_point(destructor:substrait.Type.Boolean) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_Boolean::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_Boolean::ArenaDtor(void* object) { - Type_Boolean* _this = reinterpret_cast< Type_Boolean* >(object); - (void)_this; -} -void Type_Boolean::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_Boolean::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_Boolean::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.Boolean) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_Boolean::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_Boolean::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Boolean) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Boolean) - return target; -} - -size_t Type_Boolean::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Boolean) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Boolean::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_Boolean::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Boolean::GetClassData() const { return &_class_data_; } - -void Type_Boolean::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_Boolean::MergeFrom(const Type_Boolean& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Boolean) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_Boolean::CopyFrom(const Type_Boolean& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Boolean) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_Boolean::IsInitialized() const { - return true; -} - -void Type_Boolean::InternalSwap(Type_Boolean* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_Boolean, nullability_) - + sizeof(Type_Boolean::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Boolean, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_Boolean::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[0]); -} - -// =================================================================== - -class Type_I8::_Internal { - public: -}; - -Type_I8::Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.I8) -} -Type_I8::Type_I8(const Type_I8& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.I8) -} - -inline void Type_I8::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_I8::~Type_I8() { - // @@protoc_insertion_point(destructor:substrait.Type.I8) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_I8::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_I8::ArenaDtor(void* object) { - Type_I8* _this = reinterpret_cast< Type_I8* >(object); - (void)_this; -} -void Type_I8::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_I8::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_I8::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.I8) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_I8::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_I8::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I8) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I8) - return target; -} - -size_t Type_I8::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I8) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I8::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_I8::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I8::GetClassData() const { return &_class_data_; } - -void Type_I8::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_I8::MergeFrom(const Type_I8& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I8) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_I8::CopyFrom(const Type_I8& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I8) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_I8::IsInitialized() const { - return true; -} - -void Type_I8::InternalSwap(Type_I8* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_I8, nullability_) - + sizeof(Type_I8::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_I8, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_I8::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[1]); -} - -// =================================================================== - -class Type_I16::_Internal { - public: -}; - -Type_I16::Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.I16) -} -Type_I16::Type_I16(const Type_I16& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.I16) -} - -inline void Type_I16::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_I16::~Type_I16() { - // @@protoc_insertion_point(destructor:substrait.Type.I16) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_I16::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_I16::ArenaDtor(void* object) { - Type_I16* _this = reinterpret_cast< Type_I16* >(object); - (void)_this; -} -void Type_I16::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_I16::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_I16::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.I16) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_I16::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_I16::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I16) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I16) - return target; -} - -size_t Type_I16::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I16) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I16::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_I16::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I16::GetClassData() const { return &_class_data_; } - -void Type_I16::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_I16::MergeFrom(const Type_I16& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I16) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_I16::CopyFrom(const Type_I16& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I16) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_I16::IsInitialized() const { - return true; -} - -void Type_I16::InternalSwap(Type_I16* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_I16, nullability_) - + sizeof(Type_I16::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_I16, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_I16::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[2]); -} - -// =================================================================== - -class Type_I32::_Internal { - public: -}; - -Type_I32::Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.I32) -} -Type_I32::Type_I32(const Type_I32& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.I32) -} - -inline void Type_I32::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_I32::~Type_I32() { - // @@protoc_insertion_point(destructor:substrait.Type.I32) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_I32::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_I32::ArenaDtor(void* object) { - Type_I32* _this = reinterpret_cast< Type_I32* >(object); - (void)_this; -} -void Type_I32::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_I32::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_I32::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.I32) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_I32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_I32::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I32) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I32) - return target; -} - -size_t Type_I32::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I32) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I32::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_I32::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I32::GetClassData() const { return &_class_data_; } - -void Type_I32::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_I32::MergeFrom(const Type_I32& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I32) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_I32::CopyFrom(const Type_I32& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I32) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_I32::IsInitialized() const { - return true; -} - -void Type_I32::InternalSwap(Type_I32* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_I32, nullability_) - + sizeof(Type_I32::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_I32, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_I32::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[3]); -} - -// =================================================================== - -class Type_I64::_Internal { - public: -}; - -Type_I64::Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.I64) -} -Type_I64::Type_I64(const Type_I64& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.I64) -} - -inline void Type_I64::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_I64::~Type_I64() { - // @@protoc_insertion_point(destructor:substrait.Type.I64) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_I64::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_I64::ArenaDtor(void* object) { - Type_I64* _this = reinterpret_cast< Type_I64* >(object); - (void)_this; -} -void Type_I64::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_I64::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_I64::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.I64) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_I64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_I64::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.I64) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.I64) - return target; -} - -size_t Type_I64::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.I64) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_I64::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_I64::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_I64::GetClassData() const { return &_class_data_; } - -void Type_I64::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_I64::MergeFrom(const Type_I64& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.I64) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_I64::CopyFrom(const Type_I64& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.I64) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_I64::IsInitialized() const { - return true; -} - -void Type_I64::InternalSwap(Type_I64* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_I64, nullability_) - + sizeof(Type_I64::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_I64, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_I64::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[4]); -} - -// =================================================================== - -class Type_FP32::_Internal { - public: -}; - -Type_FP32::Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.FP32) -} -Type_FP32::Type_FP32(const Type_FP32& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.FP32) -} - -inline void Type_FP32::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_FP32::~Type_FP32() { - // @@protoc_insertion_point(destructor:substrait.Type.FP32) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_FP32::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_FP32::ArenaDtor(void* object) { - Type_FP32* _this = reinterpret_cast< Type_FP32* >(object); - (void)_this; -} -void Type_FP32::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_FP32::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_FP32::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.FP32) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_FP32::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_FP32::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FP32) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FP32) - return target; -} - -size_t Type_FP32::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FP32) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FP32::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_FP32::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FP32::GetClassData() const { return &_class_data_; } - -void Type_FP32::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_FP32::MergeFrom(const Type_FP32& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FP32) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_FP32::CopyFrom(const Type_FP32& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FP32) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_FP32::IsInitialized() const { - return true; -} - -void Type_FP32::InternalSwap(Type_FP32* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_FP32, nullability_) - + sizeof(Type_FP32::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_FP32, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_FP32::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[5]); -} - -// =================================================================== - -class Type_FP64::_Internal { - public: -}; - -Type_FP64::Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.FP64) -} -Type_FP64::Type_FP64(const Type_FP64& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.FP64) -} - -inline void Type_FP64::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_FP64::~Type_FP64() { - // @@protoc_insertion_point(destructor:substrait.Type.FP64) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_FP64::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_FP64::ArenaDtor(void* object) { - Type_FP64* _this = reinterpret_cast< Type_FP64* >(object); - (void)_this; -} -void Type_FP64::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_FP64::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_FP64::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.FP64) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_FP64::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_FP64::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FP64) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FP64) - return target; -} - -size_t Type_FP64::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FP64) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FP64::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_FP64::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FP64::GetClassData() const { return &_class_data_; } - -void Type_FP64::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_FP64::MergeFrom(const Type_FP64& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FP64) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_FP64::CopyFrom(const Type_FP64& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FP64) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_FP64::IsInitialized() const { - return true; -} - -void Type_FP64::InternalSwap(Type_FP64* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_FP64, nullability_) - + sizeof(Type_FP64::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_FP64, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_FP64::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[6]); -} - -// =================================================================== - -class Type_String::_Internal { - public: -}; - -Type_String::Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.String) -} -Type_String::Type_String(const Type_String& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.String) -} - -inline void Type_String::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_String::~Type_String() { - // @@protoc_insertion_point(destructor:substrait.Type.String) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_String::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_String::ArenaDtor(void* object) { - Type_String* _this = reinterpret_cast< Type_String* >(object); - (void)_this; -} -void Type_String::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_String::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_String::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.String) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_String::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_String::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.String) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.String) - return target; -} - -size_t Type_String::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.String) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_String::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_String::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_String::GetClassData() const { return &_class_data_; } - -void Type_String::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_String::MergeFrom(const Type_String& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.String) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_String::CopyFrom(const Type_String& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.String) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_String::IsInitialized() const { - return true; -} - -void Type_String::InternalSwap(Type_String* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_String, nullability_) - + sizeof(Type_String::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_String, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_String::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[7]); -} - -// =================================================================== - -class Type_Binary::_Internal { - public: -}; - -Type_Binary::Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.Binary) -} -Type_Binary::Type_Binary(const Type_Binary& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.Binary) -} - -inline void Type_Binary::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_Binary::~Type_Binary() { - // @@protoc_insertion_point(destructor:substrait.Type.Binary) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_Binary::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_Binary::ArenaDtor(void* object) { - Type_Binary* _this = reinterpret_cast< Type_Binary* >(object); - (void)_this; -} -void Type_Binary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_Binary::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_Binary::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.Binary) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_Binary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_Binary::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Binary) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Binary) - return target; -} - -size_t Type_Binary::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Binary) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Binary::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_Binary::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Binary::GetClassData() const { return &_class_data_; } - -void Type_Binary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_Binary::MergeFrom(const Type_Binary& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Binary) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_Binary::CopyFrom(const Type_Binary& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Binary) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_Binary::IsInitialized() const { - return true; -} - -void Type_Binary::InternalSwap(Type_Binary* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_Binary, nullability_) - + sizeof(Type_Binary::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Binary, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_Binary::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[8]); -} - -// =================================================================== - -class Type_Timestamp::_Internal { - public: -}; - -Type_Timestamp::Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.Timestamp) -} -Type_Timestamp::Type_Timestamp(const Type_Timestamp& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.Timestamp) -} - -inline void Type_Timestamp::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_Timestamp::~Type_Timestamp() { - // @@protoc_insertion_point(destructor:substrait.Type.Timestamp) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_Timestamp::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_Timestamp::ArenaDtor(void* object) { - Type_Timestamp* _this = reinterpret_cast< Type_Timestamp* >(object); - (void)_this; -} -void Type_Timestamp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_Timestamp::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_Timestamp::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.Timestamp) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_Timestamp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_Timestamp::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Timestamp) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Timestamp) - return target; -} - -size_t Type_Timestamp::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Timestamp) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Timestamp::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_Timestamp::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Timestamp::GetClassData() const { return &_class_data_; } - -void Type_Timestamp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_Timestamp::MergeFrom(const Type_Timestamp& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Timestamp) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_Timestamp::CopyFrom(const Type_Timestamp& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Timestamp) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_Timestamp::IsInitialized() const { - return true; -} - -void Type_Timestamp::InternalSwap(Type_Timestamp* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_Timestamp, nullability_) - + sizeof(Type_Timestamp::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Timestamp, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_Timestamp::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[9]); -} - -// =================================================================== - -class Type_Date::_Internal { - public: -}; - -Type_Date::Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.Date) -} -Type_Date::Type_Date(const Type_Date& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.Date) -} - -inline void Type_Date::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_Date::~Type_Date() { - // @@protoc_insertion_point(destructor:substrait.Type.Date) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_Date::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_Date::ArenaDtor(void* object) { - Type_Date* _this = reinterpret_cast< Type_Date* >(object); - (void)_this; -} -void Type_Date::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_Date::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_Date::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.Date) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_Date::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_Date::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Date) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Date) - return target; -} - -size_t Type_Date::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Date) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Date::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_Date::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Date::GetClassData() const { return &_class_data_; } - -void Type_Date::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_Date::MergeFrom(const Type_Date& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Date) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_Date::CopyFrom(const Type_Date& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Date) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_Date::IsInitialized() const { - return true; -} - -void Type_Date::InternalSwap(Type_Date* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_Date, nullability_) - + sizeof(Type_Date::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Date, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_Date::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[10]); -} - -// =================================================================== - -class Type_Time::_Internal { - public: -}; - -Type_Time::Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.Time) -} -Type_Time::Type_Time(const Type_Time& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.Time) -} - -inline void Type_Time::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_Time::~Type_Time() { - // @@protoc_insertion_point(destructor:substrait.Type.Time) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_Time::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_Time::ArenaDtor(void* object) { - Type_Time* _this = reinterpret_cast< Type_Time* >(object); - (void)_this; -} -void Type_Time::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_Time::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_Time::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.Time) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_Time::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_Time::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Time) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Time) - return target; -} - -size_t Type_Time::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Time) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Time::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_Time::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Time::GetClassData() const { return &_class_data_; } - -void Type_Time::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_Time::MergeFrom(const Type_Time& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Time) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_Time::CopyFrom(const Type_Time& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Time) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_Time::IsInitialized() const { - return true; -} - -void Type_Time::InternalSwap(Type_Time* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_Time, nullability_) - + sizeof(Type_Time::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Time, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_Time::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[11]); -} - -// =================================================================== - -class Type_TimestampTZ::_Internal { - public: -}; - -Type_TimestampTZ::Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.TimestampTZ) -} -Type_TimestampTZ::Type_TimestampTZ(const Type_TimestampTZ& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.TimestampTZ) -} - -inline void Type_TimestampTZ::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_TimestampTZ::~Type_TimestampTZ() { - // @@protoc_insertion_point(destructor:substrait.Type.TimestampTZ) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_TimestampTZ::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_TimestampTZ::ArenaDtor(void* object) { - Type_TimestampTZ* _this = reinterpret_cast< Type_TimestampTZ* >(object); - (void)_this; -} -void Type_TimestampTZ::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_TimestampTZ::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_TimestampTZ::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.TimestampTZ) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_TimestampTZ::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_TimestampTZ::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.TimestampTZ) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.TimestampTZ) - return target; -} - -size_t Type_TimestampTZ::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.TimestampTZ) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_TimestampTZ::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_TimestampTZ::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_TimestampTZ::GetClassData() const { return &_class_data_; } - -void Type_TimestampTZ::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_TimestampTZ::MergeFrom(const Type_TimestampTZ& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.TimestampTZ) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_TimestampTZ::CopyFrom(const Type_TimestampTZ& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.TimestampTZ) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_TimestampTZ::IsInitialized() const { - return true; -} - -void Type_TimestampTZ::InternalSwap(Type_TimestampTZ* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_TimestampTZ, nullability_) - + sizeof(Type_TimestampTZ::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_TimestampTZ, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_TimestampTZ::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[12]); -} - -// =================================================================== - -class Type_IntervalYear::_Internal { - public: -}; - -Type_IntervalYear::Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.IntervalYear) -} -Type_IntervalYear::Type_IntervalYear(const Type_IntervalYear& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.IntervalYear) -} - -inline void Type_IntervalYear::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_IntervalYear::~Type_IntervalYear() { - // @@protoc_insertion_point(destructor:substrait.Type.IntervalYear) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_IntervalYear::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_IntervalYear::ArenaDtor(void* object) { - Type_IntervalYear* _this = reinterpret_cast< Type_IntervalYear* >(object); - (void)_this; -} -void Type_IntervalYear::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_IntervalYear::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_IntervalYear::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.IntervalYear) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_IntervalYear::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_IntervalYear::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.IntervalYear) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.IntervalYear) - return target; -} - -size_t Type_IntervalYear::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.IntervalYear) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_IntervalYear::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_IntervalYear::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_IntervalYear::GetClassData() const { return &_class_data_; } - -void Type_IntervalYear::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_IntervalYear::MergeFrom(const Type_IntervalYear& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.IntervalYear) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_IntervalYear::CopyFrom(const Type_IntervalYear& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.IntervalYear) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_IntervalYear::IsInitialized() const { - return true; -} - -void Type_IntervalYear::InternalSwap(Type_IntervalYear* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_IntervalYear, nullability_) - + sizeof(Type_IntervalYear::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_IntervalYear, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalYear::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[13]); -} - -// =================================================================== - -class Type_IntervalDay::_Internal { - public: -}; - -Type_IntervalDay::Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.IntervalDay) -} -Type_IntervalDay::Type_IntervalDay(const Type_IntervalDay& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.IntervalDay) -} - -inline void Type_IntervalDay::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_IntervalDay::~Type_IntervalDay() { - // @@protoc_insertion_point(destructor:substrait.Type.IntervalDay) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_IntervalDay::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_IntervalDay::ArenaDtor(void* object) { - Type_IntervalDay* _this = reinterpret_cast< Type_IntervalDay* >(object); - (void)_this; -} -void Type_IntervalDay::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_IntervalDay::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_IntervalDay::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.IntervalDay) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_IntervalDay::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_IntervalDay::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.IntervalDay) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.IntervalDay) - return target; -} - -size_t Type_IntervalDay::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.IntervalDay) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_IntervalDay::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_IntervalDay::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_IntervalDay::GetClassData() const { return &_class_data_; } - -void Type_IntervalDay::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_IntervalDay::MergeFrom(const Type_IntervalDay& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.IntervalDay) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_IntervalDay::CopyFrom(const Type_IntervalDay& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.IntervalDay) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_IntervalDay::IsInitialized() const { - return true; -} - -void Type_IntervalDay::InternalSwap(Type_IntervalDay* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_IntervalDay, nullability_) - + sizeof(Type_IntervalDay::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_IntervalDay, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_IntervalDay::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[14]); -} - -// =================================================================== - -class Type_UUID::_Internal { - public: -}; - -Type_UUID::Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.UUID) -} -Type_UUID::Type_UUID(const Type_UUID& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.UUID) -} - -inline void Type_UUID::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_UUID::~Type_UUID() { - // @@protoc_insertion_point(destructor:substrait.Type.UUID) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_UUID::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_UUID::ArenaDtor(void* object) { - Type_UUID* _this = reinterpret_cast< Type_UUID* >(object); - (void)_this; -} -void Type_UUID::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_UUID::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_UUID::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.UUID) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_UUID::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // uint32 type_variation_reference = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_UUID::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.UUID) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 2, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.UUID) - return target; -} - -size_t Type_UUID::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.UUID) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // uint32 type_variation_reference = 1; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 2; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_UUID::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_UUID::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_UUID::GetClassData() const { return &_class_data_; } - -void Type_UUID::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_UUID::MergeFrom(const Type_UUID& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.UUID) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_UUID::CopyFrom(const Type_UUID& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.UUID) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_UUID::IsInitialized() const { - return true; -} - -void Type_UUID::InternalSwap(Type_UUID* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_UUID, nullability_) - + sizeof(Type_UUID::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_UUID, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_UUID::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[15]); -} - -// =================================================================== - -class Type_FixedChar::_Internal { - public: -}; - -Type_FixedChar::Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.FixedChar) -} -Type_FixedChar::Type_FixedChar(const Type_FixedChar& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&length_, &from.length_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.FixedChar) -} - -inline void Type_FixedChar::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&length_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); -} - -Type_FixedChar::~Type_FixedChar() { - // @@protoc_insertion_point(destructor:substrait.Type.FixedChar) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_FixedChar::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_FixedChar::ArenaDtor(void* object) { - Type_FixedChar* _this = reinterpret_cast< Type_FixedChar* >(object); - (void)_this; -} -void Type_FixedChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_FixedChar::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_FixedChar::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.FixedChar) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&length_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_FixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 length = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 type_variation_reference = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_FixedChar::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FixedChar) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 length = 1; - if (this->_internal_length() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); - } - - // uint32 type_variation_reference = 2; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FixedChar) - return target; -} - -size_t Type_FixedChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FixedChar) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int32 length = 1; - if (this->_internal_length() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_length()); - } - - // uint32 type_variation_reference = 2; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FixedChar::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_FixedChar::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FixedChar::GetClassData() const { return &_class_data_; } - -void Type_FixedChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_FixedChar::MergeFrom(const Type_FixedChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FixedChar) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_length() != 0) { - _internal_set_length(from._internal_length()); - } - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_FixedChar::CopyFrom(const Type_FixedChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FixedChar) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_FixedChar::IsInitialized() const { - return true; -} - -void Type_FixedChar::InternalSwap(Type_FixedChar* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_FixedChar, nullability_) - + sizeof(Type_FixedChar::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_FixedChar, length_)>( - reinterpret_cast(&length_), - reinterpret_cast(&other->length_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedChar::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[16]); -} - -// =================================================================== - -class Type_VarChar::_Internal { - public: -}; - -Type_VarChar::Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.VarChar) -} -Type_VarChar::Type_VarChar(const Type_VarChar& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&length_, &from.length_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.VarChar) -} - -inline void Type_VarChar::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&length_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); -} - -Type_VarChar::~Type_VarChar() { - // @@protoc_insertion_point(destructor:substrait.Type.VarChar) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_VarChar::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_VarChar::ArenaDtor(void* object) { - Type_VarChar* _this = reinterpret_cast< Type_VarChar* >(object); - (void)_this; -} -void Type_VarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_VarChar::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_VarChar::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.VarChar) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&length_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_VarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 length = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 type_variation_reference = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_VarChar::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.VarChar) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 length = 1; - if (this->_internal_length() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); - } - - // uint32 type_variation_reference = 2; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.VarChar) - return target; -} - -size_t Type_VarChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.VarChar) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int32 length = 1; - if (this->_internal_length() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_length()); - } - - // uint32 type_variation_reference = 2; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_VarChar::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_VarChar::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_VarChar::GetClassData() const { return &_class_data_; } - -void Type_VarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_VarChar::MergeFrom(const Type_VarChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.VarChar) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_length() != 0) { - _internal_set_length(from._internal_length()); - } - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_VarChar::CopyFrom(const Type_VarChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.VarChar) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_VarChar::IsInitialized() const { - return true; -} - -void Type_VarChar::InternalSwap(Type_VarChar* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_VarChar, nullability_) - + sizeof(Type_VarChar::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_VarChar, length_)>( - reinterpret_cast(&length_), - reinterpret_cast(&other->length_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_VarChar::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[17]); -} - -// =================================================================== - -class Type_FixedBinary::_Internal { - public: -}; - -Type_FixedBinary::Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.FixedBinary) -} -Type_FixedBinary::Type_FixedBinary(const Type_FixedBinary& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&length_, &from.length_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.FixedBinary) -} - -inline void Type_FixedBinary::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&length_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); -} - -Type_FixedBinary::~Type_FixedBinary() { - // @@protoc_insertion_point(destructor:substrait.Type.FixedBinary) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_FixedBinary::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_FixedBinary::ArenaDtor(void* object) { - Type_FixedBinary* _this = reinterpret_cast< Type_FixedBinary* >(object); - (void)_this; -} -void Type_FixedBinary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_FixedBinary::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_FixedBinary::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.FixedBinary) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&length_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_FixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 length = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 type_variation_reference = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_FixedBinary::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.FixedBinary) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 length = 1; - if (this->_internal_length() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_length(), target); - } - - // uint32 type_variation_reference = 2; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.FixedBinary) - return target; -} - -size_t Type_FixedBinary::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.FixedBinary) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int32 length = 1; - if (this->_internal_length() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_length()); - } - - // uint32 type_variation_reference = 2; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_FixedBinary::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_FixedBinary::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_FixedBinary::GetClassData() const { return &_class_data_; } - -void Type_FixedBinary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_FixedBinary::MergeFrom(const Type_FixedBinary& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.FixedBinary) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_length() != 0) { - _internal_set_length(from._internal_length()); - } - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_FixedBinary::CopyFrom(const Type_FixedBinary& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.FixedBinary) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_FixedBinary::IsInitialized() const { - return true; -} - -void Type_FixedBinary::InternalSwap(Type_FixedBinary* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_FixedBinary, nullability_) - + sizeof(Type_FixedBinary::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_FixedBinary, length_)>( - reinterpret_cast(&length_), - reinterpret_cast(&other->length_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_FixedBinary::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[18]); -} - -// =================================================================== - -class Type_Decimal::_Internal { - public: -}; - -Type_Decimal::Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.Decimal) -} -Type_Decimal::Type_Decimal(const Type_Decimal& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&scale_, &from.scale_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&scale_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.Decimal) -} - -inline void Type_Decimal::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&scale_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&scale_)) + sizeof(nullability_)); -} - -Type_Decimal::~Type_Decimal() { - // @@protoc_insertion_point(destructor:substrait.Type.Decimal) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_Decimal::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_Decimal::ArenaDtor(void* object) { - Type_Decimal* _this = reinterpret_cast< Type_Decimal* >(object); - (void)_this; -} -void Type_Decimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_Decimal::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_Decimal::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.Decimal) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&scale_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&scale_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_Decimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // int32 scale = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - scale_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 precision = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - precision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 type_variation_reference = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_Decimal::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Decimal) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // int32 scale = 1; - if (this->_internal_scale() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_scale(), target); - } - - // int32 precision = 2; - if (this->_internal_precision() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_precision(), target); - } - - // uint32 type_variation_reference = 3; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 4, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Decimal) - return target; -} - -size_t Type_Decimal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Decimal) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // int32 scale = 1; - if (this->_internal_scale() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_scale()); - } - - // int32 precision = 2; - if (this->_internal_precision() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_precision()); - } - - // uint32 type_variation_reference = 3; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Decimal::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_Decimal::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Decimal::GetClassData() const { return &_class_data_; } - -void Type_Decimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_Decimal::MergeFrom(const Type_Decimal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Decimal) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_scale() != 0) { - _internal_set_scale(from._internal_scale()); - } - if (from._internal_precision() != 0) { - _internal_set_precision(from._internal_precision()); - } - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_Decimal::CopyFrom(const Type_Decimal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Decimal) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_Decimal::IsInitialized() const { - return true; -} - -void Type_Decimal::InternalSwap(Type_Decimal* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_Decimal, nullability_) - + sizeof(Type_Decimal::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Decimal, scale_)>( - reinterpret_cast(&scale_), - reinterpret_cast(&other->scale_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_Decimal::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[19]); -} - -// =================================================================== - -class Type_Struct::_Internal { - public: -}; - -Type_Struct::Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - types_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.Struct) -} -Type_Struct::Type_Struct(const Type_Struct& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - types_(from.types_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.Struct) -} - -inline void Type_Struct::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_variation_reference_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); -} - -Type_Struct::~Type_Struct() { - // @@protoc_insertion_point(destructor:substrait.Type.Struct) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_Struct::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void Type_Struct::ArenaDtor(void* object) { - Type_Struct* _this = reinterpret_cast< Type_Struct* >(object); - (void)_this; -} -void Type_Struct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_Struct::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_Struct::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.Struct) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - types_.Clear(); - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_Struct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.Type types = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_types(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // uint32 type_variation_reference = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_Struct::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Struct) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.Type types = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_types_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_types(i), target, stream); - } - - // uint32 type_variation_reference = 2; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Struct) - return target; -} - -size_t Type_Struct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Struct) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.Type types = 1; - total_size += 1UL * this->_internal_types_size(); - for (const auto& msg : this->types_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // uint32 type_variation_reference = 2; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Struct::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_Struct::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Struct::GetClassData() const { return &_class_data_; } - -void Type_Struct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_Struct::MergeFrom(const Type_Struct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Struct) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - types_.MergeFrom(from.types_); - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_Struct::CopyFrom(const Type_Struct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Struct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_Struct::IsInitialized() const { - return true; -} - -void Type_Struct::InternalSwap(Type_Struct* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - types_.InternalSwap(&other->types_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_Struct, nullability_) - + sizeof(Type_Struct::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Struct, type_variation_reference_)>( - reinterpret_cast(&type_variation_reference_), - reinterpret_cast(&other->type_variation_reference_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_Struct::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[20]); -} - -// =================================================================== - -class Type_List::_Internal { - public: - static const ::substrait::Type& type(const Type_List* msg); -}; - -const ::substrait::Type& -Type_List::_Internal::type(const Type_List* msg) { - return *msg->type_; -} -Type_List::Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.List) -} -Type_List::Type_List(const Type_List& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_type()) { - type_ = new ::substrait::Type(*from.type_); - } else { - type_ = nullptr; - } - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.List) -} - -inline void Type_List::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_)) + sizeof(nullability_)); -} - -Type_List::~Type_List() { - // @@protoc_insertion_point(destructor:substrait.Type.List) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_List::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete type_; -} - -void Type_List::ArenaDtor(void* object) { - Type_List* _this = reinterpret_cast< Type_List* >(object); - (void)_this; -} -void Type_List::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_List::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_List::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.List) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_List::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Type type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 type_variation_reference = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_List::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.List) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Type type = 1; - if (this->_internal_has_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::type(this), target, stream); - } - - // uint32 type_variation_reference = 2; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.List) - return target; -} - -size_t Type_List::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.List) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Type type = 1; - if (this->_internal_has_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_); - } - - // uint32 type_variation_reference = 2; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_List::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_List::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_List::GetClassData() const { return &_class_data_; } - -void Type_List::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_List::MergeFrom(const Type_List& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.List) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_type()) { - _internal_mutable_type()->::substrait::Type::MergeFrom(from._internal_type()); - } - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_List::CopyFrom(const Type_List& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.List) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_List::IsInitialized() const { - return true; -} - -void Type_List::InternalSwap(Type_List* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_List, nullability_) - + sizeof(Type_List::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_List, type_)>( - reinterpret_cast(&type_), - reinterpret_cast(&other->type_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_List::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[21]); -} - -// =================================================================== - -class Type_Map::_Internal { - public: - static const ::substrait::Type& key(const Type_Map* msg); - static const ::substrait::Type& value(const Type_Map* msg); -}; - -const ::substrait::Type& -Type_Map::_Internal::key(const Type_Map* msg) { - return *msg->key_; -} -const ::substrait::Type& -Type_Map::_Internal::value(const Type_Map* msg) { - return *msg->value_; -} -Type_Map::Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type.Map) -} -Type_Map::Type_Map(const Type_Map& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key()) { - key_ = new ::substrait::Type(*from.key_); - } else { - key_ = nullptr; - } - if (from._internal_has_value()) { - value_ = new ::substrait::Type(*from.value_); - } else { - value_ = nullptr; - } - ::memcpy(&type_variation_reference_, &from.type_variation_reference_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.Type.Map) -} - -inline void Type_Map::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&key_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&key_)) + sizeof(nullability_)); -} - -Type_Map::~Type_Map() { - // @@protoc_insertion_point(destructor:substrait.Type.Map) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type_Map::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete key_; - if (this != internal_default_instance()) delete value_; -} - -void Type_Map::ArenaDtor(void* object) { - Type_Map* _this = reinterpret_cast< Type_Map* >(object); - (void)_this; -} -void Type_Map::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type_Map::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type_Map::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type.Map) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && key_ != nullptr) { - delete key_; - } - key_ = nullptr; - if (GetArenaForAllocation() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; - ::memset(&type_variation_reference_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&type_variation_reference_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type_Map::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Type key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type value = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 type_variation_reference = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - type_variation_reference_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* Type_Map::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type.Map) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Type key = 1; - if (this->_internal_has_key()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::key(this), target, stream); - } - - // .substrait.Type value = 2; - if (this->_internal_has_value()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::value(this), target, stream); - } - - // uint32 type_variation_reference = 3; - if (this->_internal_type_variation_reference() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_type_variation_reference(), target); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 4, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type.Map) - return target; -} - -size_t Type_Map::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type.Map) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.Type key = 1; - if (this->_internal_has_key()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *key_); - } - - // .substrait.Type value = 2; - if (this->_internal_has_value()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *value_); - } - - // uint32 type_variation_reference = 3; - if (this->_internal_type_variation_reference() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_type_variation_reference()); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type_Map::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type_Map::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type_Map::GetClassData() const { return &_class_data_; } - -void Type_Map::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type_Map::MergeFrom(const Type_Map& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type.Map) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_key()) { - _internal_mutable_key()->::substrait::Type::MergeFrom(from._internal_key()); - } - if (from._internal_has_value()) { - _internal_mutable_value()->::substrait::Type::MergeFrom(from._internal_value()); - } - if (from._internal_type_variation_reference() != 0) { - _internal_set_type_variation_reference(from._internal_type_variation_reference()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type_Map::CopyFrom(const Type_Map& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type.Map) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type_Map::IsInitialized() const { - return true; -} - -void Type_Map::InternalSwap(Type_Map* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(Type_Map, nullability_) - + sizeof(Type_Map::nullability_) - - PROTOBUF_FIELD_OFFSET(Type_Map, key_)>( - reinterpret_cast(&key_), - reinterpret_cast(&other->key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type_Map::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[22]); -} - -// =================================================================== - -class Type::_Internal { - public: - static const ::substrait::Type_Boolean& bool_(const Type* msg); - static const ::substrait::Type_I8& i8(const Type* msg); - static const ::substrait::Type_I16& i16(const Type* msg); - static const ::substrait::Type_I32& i32(const Type* msg); - static const ::substrait::Type_I64& i64(const Type* msg); - static const ::substrait::Type_FP32& fp32(const Type* msg); - static const ::substrait::Type_FP64& fp64(const Type* msg); - static const ::substrait::Type_String& string(const Type* msg); - static const ::substrait::Type_Binary& binary(const Type* msg); - static const ::substrait::Type_Timestamp& timestamp(const Type* msg); - static const ::substrait::Type_Date& date(const Type* msg); - static const ::substrait::Type_Time& time(const Type* msg); - static const ::substrait::Type_IntervalYear& interval_year(const Type* msg); - static const ::substrait::Type_IntervalDay& interval_day(const Type* msg); - static const ::substrait::Type_TimestampTZ& timestamp_tz(const Type* msg); - static const ::substrait::Type_UUID& uuid(const Type* msg); - static const ::substrait::Type_FixedChar& fixed_char(const Type* msg); - static const ::substrait::Type_VarChar& varchar(const Type* msg); - static const ::substrait::Type_FixedBinary& fixed_binary(const Type* msg); - static const ::substrait::Type_Decimal& decimal(const Type* msg); - static const ::substrait::Type_Struct& struct_(const Type* msg); - static const ::substrait::Type_List& list(const Type* msg); - static const ::substrait::Type_Map& map(const Type* msg); -}; - -const ::substrait::Type_Boolean& -Type::_Internal::bool_(const Type* msg) { - return *msg->kind_.bool__; -} -const ::substrait::Type_I8& -Type::_Internal::i8(const Type* msg) { - return *msg->kind_.i8_; -} -const ::substrait::Type_I16& -Type::_Internal::i16(const Type* msg) { - return *msg->kind_.i16_; -} -const ::substrait::Type_I32& -Type::_Internal::i32(const Type* msg) { - return *msg->kind_.i32_; -} -const ::substrait::Type_I64& -Type::_Internal::i64(const Type* msg) { - return *msg->kind_.i64_; -} -const ::substrait::Type_FP32& -Type::_Internal::fp32(const Type* msg) { - return *msg->kind_.fp32_; -} -const ::substrait::Type_FP64& -Type::_Internal::fp64(const Type* msg) { - return *msg->kind_.fp64_; -} -const ::substrait::Type_String& -Type::_Internal::string(const Type* msg) { - return *msg->kind_.string_; -} -const ::substrait::Type_Binary& -Type::_Internal::binary(const Type* msg) { - return *msg->kind_.binary_; -} -const ::substrait::Type_Timestamp& -Type::_Internal::timestamp(const Type* msg) { - return *msg->kind_.timestamp_; -} -const ::substrait::Type_Date& -Type::_Internal::date(const Type* msg) { - return *msg->kind_.date_; -} -const ::substrait::Type_Time& -Type::_Internal::time(const Type* msg) { - return *msg->kind_.time_; -} -const ::substrait::Type_IntervalYear& -Type::_Internal::interval_year(const Type* msg) { - return *msg->kind_.interval_year_; -} -const ::substrait::Type_IntervalDay& -Type::_Internal::interval_day(const Type* msg) { - return *msg->kind_.interval_day_; -} -const ::substrait::Type_TimestampTZ& -Type::_Internal::timestamp_tz(const Type* msg) { - return *msg->kind_.timestamp_tz_; -} -const ::substrait::Type_UUID& -Type::_Internal::uuid(const Type* msg) { - return *msg->kind_.uuid_; -} -const ::substrait::Type_FixedChar& -Type::_Internal::fixed_char(const Type* msg) { - return *msg->kind_.fixed_char_; -} -const ::substrait::Type_VarChar& -Type::_Internal::varchar(const Type* msg) { - return *msg->kind_.varchar_; -} -const ::substrait::Type_FixedBinary& -Type::_Internal::fixed_binary(const Type* msg) { - return *msg->kind_.fixed_binary_; -} -const ::substrait::Type_Decimal& -Type::_Internal::decimal(const Type* msg) { - return *msg->kind_.decimal_; -} -const ::substrait::Type_Struct& -Type::_Internal::struct_(const Type* msg) { - return *msg->kind_.struct__; -} -const ::substrait::Type_List& -Type::_Internal::list(const Type* msg) { - return *msg->kind_.list_; -} -const ::substrait::Type_Map& -Type::_Internal::map(const Type* msg) { - return *msg->kind_.map_; -} -void Type::set_allocated_bool_(::substrait::Type_Boolean* bool_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (bool_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Boolean>::GetOwningArena(bool_); - if (message_arena != submessage_arena) { - bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, bool_, submessage_arena); - } - set_has_bool_(); - kind_.bool__ = bool_; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.bool) -} -void Type::set_allocated_i8(::substrait::Type_I8* i8) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i8) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I8>::GetOwningArena(i8); - if (message_arena != submessage_arena) { - i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i8, submessage_arena); - } - set_has_i8(); - kind_.i8_ = i8; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.i8) -} -void Type::set_allocated_i16(::substrait::Type_I16* i16) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i16) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I16>::GetOwningArena(i16); - if (message_arena != submessage_arena) { - i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i16, submessage_arena); - } - set_has_i16(); - kind_.i16_ = i16; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.i16) -} -void Type::set_allocated_i32(::substrait::Type_I32* i32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i32) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I32>::GetOwningArena(i32); - if (message_arena != submessage_arena) { - i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i32, submessage_arena); - } - set_has_i32(); - kind_.i32_ = i32; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.i32) -} -void Type::set_allocated_i64(::substrait::Type_I64* i64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i64) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_I64>::GetOwningArena(i64); - if (message_arena != submessage_arena) { - i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i64, submessage_arena); - } - set_has_i64(); - kind_.i64_ = i64; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.i64) -} -void Type::set_allocated_fp32(::substrait::Type_FP32* fp32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fp32) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FP32>::GetOwningArena(fp32); - if (message_arena != submessage_arena) { - fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fp32, submessage_arena); - } - set_has_fp32(); - kind_.fp32_ = fp32; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.fp32) -} -void Type::set_allocated_fp64(::substrait::Type_FP64* fp64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fp64) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FP64>::GetOwningArena(fp64); - if (message_arena != submessage_arena) { - fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fp64, submessage_arena); - } - set_has_fp64(); - kind_.fp64_ = fp64; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.fp64) -} -void Type::set_allocated_string(::substrait::Type_String* string) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (string) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_String>::GetOwningArena(string); - if (message_arena != submessage_arena) { - string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, string, submessage_arena); - } - set_has_string(); - kind_.string_ = string; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.string) -} -void Type::set_allocated_binary(::substrait::Type_Binary* binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Binary>::GetOwningArena(binary); - if (message_arena != submessage_arena) { - binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, binary, submessage_arena); - } - set_has_binary(); - kind_.binary_ = binary; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.binary) -} -void Type::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (timestamp) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Timestamp>::GetOwningArena(timestamp); - if (message_arena != submessage_arena) { - timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, timestamp, submessage_arena); - } - set_has_timestamp(); - kind_.timestamp_ = timestamp; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.timestamp) -} -void Type::set_allocated_date(::substrait::Type_Date* date) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (date) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Date>::GetOwningArena(date); - if (message_arena != submessage_arena) { - date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, date, submessage_arena); - } - set_has_date(); - kind_.date_ = date; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.date) -} -void Type::set_allocated_time(::substrait::Type_Time* time) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (time) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Time>::GetOwningArena(time); - if (message_arena != submessage_arena) { - time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, time, submessage_arena); - } - set_has_time(); - kind_.time_ = time; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.time) -} -void Type::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (interval_year) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_IntervalYear>::GetOwningArena(interval_year); - if (message_arena != submessage_arena) { - interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interval_year, submessage_arena); - } - set_has_interval_year(); - kind_.interval_year_ = interval_year; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.interval_year) -} -void Type::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (interval_day) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_IntervalDay>::GetOwningArena(interval_day); - if (message_arena != submessage_arena) { - interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interval_day, submessage_arena); - } - set_has_interval_day(); - kind_.interval_day_ = interval_day; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.interval_day) -} -void Type::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (timestamp_tz) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_TimestampTZ>::GetOwningArena(timestamp_tz); - if (message_arena != submessage_arena) { - timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, timestamp_tz, submessage_arena); - } - set_has_timestamp_tz(); - kind_.timestamp_tz_ = timestamp_tz; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.timestamp_tz) -} -void Type::set_allocated_uuid(::substrait::Type_UUID* uuid) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (uuid) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_UUID>::GetOwningArena(uuid); - if (message_arena != submessage_arena) { - uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, uuid, submessage_arena); - } - set_has_uuid(); - kind_.uuid_ = uuid; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.uuid) -} -void Type::set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fixed_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FixedChar>::GetOwningArena(fixed_char); - if (message_arena != submessage_arena) { - fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fixed_char, submessage_arena); - } - set_has_fixed_char(); - kind_.fixed_char_ = fixed_char; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.fixed_char) -} -void Type::set_allocated_varchar(::substrait::Type_VarChar* varchar) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (varchar) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_VarChar>::GetOwningArena(varchar); - if (message_arena != submessage_arena) { - varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, varchar, submessage_arena); - } - set_has_varchar(); - kind_.varchar_ = varchar; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.varchar) -} -void Type::set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fixed_binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_FixedBinary>::GetOwningArena(fixed_binary); - if (message_arena != submessage_arena) { - fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fixed_binary, submessage_arena); - } - set_has_fixed_binary(); - kind_.fixed_binary_ = fixed_binary; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.fixed_binary) -} -void Type::set_allocated_decimal(::substrait::Type_Decimal* decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Decimal>::GetOwningArena(decimal); - if (message_arena != submessage_arena) { - decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, decimal, submessage_arena); - } - set_has_decimal(); - kind_.decimal_ = decimal; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.decimal) -} -void Type::set_allocated_struct_(::substrait::Type_Struct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Struct>::GetOwningArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - set_has_struct_(); - kind_.struct__ = struct_; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.struct) -} -void Type::set_allocated_list(::substrait::Type_List* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_List>::GetOwningArena(list); - if (message_arena != submessage_arena) { - list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, list, submessage_arena); - } - set_has_list(); - kind_.list_ = list; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.list) -} -void Type::set_allocated_map(::substrait::Type_Map* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (map) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Map>::GetOwningArena(map); - if (message_arena != submessage_arena) { - map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, map, submessage_arena); - } - set_has_map(); - kind_.map_ = map; - } - // @@protoc_insertion_point(field_set_allocated:substrait.Type.map) -} -Type::Type(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.Type) -} -Type::Type(const Type& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_kind(); - switch (from.kind_case()) { - case kBool: { - _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); - break; - } - case kI8: { - _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); - break; - } - case kI16: { - _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); - break; - } - case kI32: { - _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); - break; - } - case kI64: { - _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); - break; - } - case kFp32: { - _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); - break; - } - case kFp64: { - _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); - break; - } - case kString: { - _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); - break; - } - case kBinary: { - _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); - break; - } - case kTimestamp: { - _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); - break; - } - case kDate: { - _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); - break; - } - case kTime: { - _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); - break; - } - case kIntervalYear: { - _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); - break; - } - case kIntervalDay: { - _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); - break; - } - case kTimestampTz: { - _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); - break; - } - case kUuid: { - _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); - break; - } - case kFixedChar: { - _internal_mutable_fixed_char()->::substrait::Type_FixedChar::MergeFrom(from._internal_fixed_char()); - break; - } - case kVarchar: { - _internal_mutable_varchar()->::substrait::Type_VarChar::MergeFrom(from._internal_varchar()); - break; - } - case kFixedBinary: { - _internal_mutable_fixed_binary()->::substrait::Type_FixedBinary::MergeFrom(from._internal_fixed_binary()); - break; - } - case kDecimal: { - _internal_mutable_decimal()->::substrait::Type_Decimal::MergeFrom(from._internal_decimal()); - break; - } - case kStruct: { - _internal_mutable_struct_()->::substrait::Type_Struct::MergeFrom(from._internal_struct_()); - break; - } - case kList: { - _internal_mutable_list()->::substrait::Type_List::MergeFrom(from._internal_list()); - break; - } - case kMap: { - _internal_mutable_map()->::substrait::Type_Map::MergeFrom(from._internal_map()); - break; - } - case kUserDefinedTypeReference: { - _internal_set_user_defined_type_reference(from._internal_user_defined_type_reference()); - break; - } - case KIND_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.Type) -} - -inline void Type::SharedCtor() { -clear_has_kind(); -} - -Type::~Type() { - // @@protoc_insertion_point(destructor:substrait.Type) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void Type::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_kind()) { - clear_kind(); - } -} - -void Type::ArenaDtor(void* object) { - Type* _this = reinterpret_cast< Type* >(object); - (void)_this; -} -void Type::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void Type::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void Type::clear_kind() { -// @@protoc_insertion_point(one_of_clear_start:substrait.Type) - switch (kind_case()) { - case kBool: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.bool__; - } - break; - } - case kI8: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i8_; - } - break; - } - case kI16: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i16_; - } - break; - } - case kI32: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i32_; - } - break; - } - case kI64: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i64_; - } - break; - } - case kFp32: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp32_; - } - break; - } - case kFp64: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp64_; - } - break; - } - case kString: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.string_; - } - break; - } - case kBinary: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.binary_; - } - break; - } - case kTimestamp: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_; - } - break; - } - case kDate: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.date_; - } - break; - } - case kTime: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.time_; - } - break; - } - case kIntervalYear: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_year_; - } - break; - } - case kIntervalDay: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_day_; - } - break; - } - case kTimestampTz: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_tz_; - } - break; - } - case kUuid: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.uuid_; - } - break; - } - case kFixedChar: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_char_; - } - break; - } - case kVarchar: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.varchar_; - } - break; - } - case kFixedBinary: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_binary_; - } - break; - } - case kDecimal: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.decimal_; - } - break; - } - case kStruct: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.struct__; - } - break; - } - case kList: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.list_; - } - break; - } - case kMap: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.map_; - } - break; - } - case kUserDefinedTypeReference: { - // No need to clear - break; - } - case KIND_NOT_SET: { - break; - } - } - _oneof_case_[0] = KIND_NOT_SET; -} - - -void Type::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.Type) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_kind(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* Type::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Type.Boolean bool = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I8 i8 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I16 i16 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I32 i32 = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I64 i64 = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.FP32 fp32 = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.FP64 fp64 = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.String string = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Binary binary = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Timestamp timestamp = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { - ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Date date = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Time time = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.IntervalYear interval_year = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.IntervalDay interval_day = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { - ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.FixedChar fixed_char = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.VarChar varchar = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { - ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.FixedBinary fixed_binary = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Decimal decimal = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { - ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Struct struct = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.List list = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { - ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Map map = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { - ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.TimestampTZ timestamp_tz = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { - ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 user_defined_type_reference = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { - _internal_set_user_defined_type_reference(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.UUID uuid = 32; - case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { - ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* Type::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.Type) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Type.Boolean bool = 1; - if (_internal_has_bool_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::bool_(this), target, stream); - } - - // .substrait.Type.I8 i8 = 2; - if (_internal_has_i8()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::i8(this), target, stream); - } - - // .substrait.Type.I16 i16 = 3; - if (_internal_has_i16()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::i16(this), target, stream); - } - - // .substrait.Type.I32 i32 = 5; - if (_internal_has_i32()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::i32(this), target, stream); - } - - // .substrait.Type.I64 i64 = 7; - if (_internal_has_i64()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 7, _Internal::i64(this), target, stream); - } - - // .substrait.Type.FP32 fp32 = 10; - if (_internal_has_fp32()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::fp32(this), target, stream); - } - - // .substrait.Type.FP64 fp64 = 11; - if (_internal_has_fp64()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 11, _Internal::fp64(this), target, stream); - } - - // .substrait.Type.String string = 12; - if (_internal_has_string()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 12, _Internal::string(this), target, stream); - } - - // .substrait.Type.Binary binary = 13; - if (_internal_has_binary()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 13, _Internal::binary(this), target, stream); - } - - // .substrait.Type.Timestamp timestamp = 14; - if (_internal_has_timestamp()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 14, _Internal::timestamp(this), target, stream); - } - - // .substrait.Type.Date date = 16; - if (_internal_has_date()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 16, _Internal::date(this), target, stream); - } - - // .substrait.Type.Time time = 17; - if (_internal_has_time()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 17, _Internal::time(this), target, stream); - } - - // .substrait.Type.IntervalYear interval_year = 19; - if (_internal_has_interval_year()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 19, _Internal::interval_year(this), target, stream); - } - - // .substrait.Type.IntervalDay interval_day = 20; - if (_internal_has_interval_day()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 20, _Internal::interval_day(this), target, stream); - } - - // .substrait.Type.FixedChar fixed_char = 21; - if (_internal_has_fixed_char()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 21, _Internal::fixed_char(this), target, stream); - } - - // .substrait.Type.VarChar varchar = 22; - if (_internal_has_varchar()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 22, _Internal::varchar(this), target, stream); - } - - // .substrait.Type.FixedBinary fixed_binary = 23; - if (_internal_has_fixed_binary()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 23, _Internal::fixed_binary(this), target, stream); - } - - // .substrait.Type.Decimal decimal = 24; - if (_internal_has_decimal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 24, _Internal::decimal(this), target, stream); - } - - // .substrait.Type.Struct struct = 25; - if (_internal_has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 25, _Internal::struct_(this), target, stream); - } - - // .substrait.Type.List list = 27; - if (_internal_has_list()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 27, _Internal::list(this), target, stream); - } - - // .substrait.Type.Map map = 28; - if (_internal_has_map()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 28, _Internal::map(this), target, stream); - } - - // .substrait.Type.TimestampTZ timestamp_tz = 29; - if (_internal_has_timestamp_tz()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 29, _Internal::timestamp_tz(this), target, stream); - } - - // uint32 user_defined_type_reference = 31; - if (_internal_has_user_defined_type_reference()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_type_reference(), target); - } - - // .substrait.Type.UUID uuid = 32; - if (_internal_has_uuid()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 32, _Internal::uuid(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.Type) - return target; -} - -size_t Type::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.Type) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (kind_case()) { - // .substrait.Type.Boolean bool = 1; - case kBool: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.bool__); - break; - } - // .substrait.Type.I8 i8 = 2; - case kI8: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i8_); - break; - } - // .substrait.Type.I16 i16 = 3; - case kI16: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i16_); - break; - } - // .substrait.Type.I32 i32 = 5; - case kI32: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i32_); - break; - } - // .substrait.Type.I64 i64 = 7; - case kI64: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i64_); - break; - } - // .substrait.Type.FP32 fp32 = 10; - case kFp32: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fp32_); - break; - } - // .substrait.Type.FP64 fp64 = 11; - case kFp64: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fp64_); - break; - } - // .substrait.Type.String string = 12; - case kString: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.string_); - break; - } - // .substrait.Type.Binary binary = 13; - case kBinary: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.binary_); - break; - } - // .substrait.Type.Timestamp timestamp = 14; - case kTimestamp: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.timestamp_); - break; - } - // .substrait.Type.Date date = 16; - case kDate: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.date_); - break; - } - // .substrait.Type.Time time = 17; - case kTime: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.time_); - break; - } - // .substrait.Type.IntervalYear interval_year = 19; - case kIntervalYear: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.interval_year_); - break; - } - // .substrait.Type.IntervalDay interval_day = 20; - case kIntervalDay: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.interval_day_); - break; - } - // .substrait.Type.TimestampTZ timestamp_tz = 29; - case kTimestampTz: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.timestamp_tz_); - break; - } - // .substrait.Type.UUID uuid = 32; - case kUuid: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.uuid_); - break; - } - // .substrait.Type.FixedChar fixed_char = 21; - case kFixedChar: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fixed_char_); - break; - } - // .substrait.Type.VarChar varchar = 22; - case kVarchar: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.varchar_); - break; - } - // .substrait.Type.FixedBinary fixed_binary = 23; - case kFixedBinary: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fixed_binary_); - break; - } - // .substrait.Type.Decimal decimal = 24; - case kDecimal: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.decimal_); - break; - } - // .substrait.Type.Struct struct = 25; - case kStruct: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.struct__); - break; - } - // .substrait.Type.List list = 27; - case kList: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.list_); - break; - } - // .substrait.Type.Map map = 28; - case kMap: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.map_); - break; - } - // uint32 user_defined_type_reference = 31; - case kUserDefinedTypeReference: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_user_defined_type_reference()); - break; - } - case KIND_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData Type::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - Type::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*Type::GetClassData() const { return &_class_data_; } - -void Type::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void Type::MergeFrom(const Type& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.Type) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.kind_case()) { - case kBool: { - _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); - break; - } - case kI8: { - _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); - break; - } - case kI16: { - _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); - break; - } - case kI32: { - _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); - break; - } - case kI64: { - _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); - break; - } - case kFp32: { - _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); - break; - } - case kFp64: { - _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); - break; - } - case kString: { - _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); - break; - } - case kBinary: { - _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); - break; - } - case kTimestamp: { - _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); - break; - } - case kDate: { - _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); - break; - } - case kTime: { - _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); - break; - } - case kIntervalYear: { - _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); - break; - } - case kIntervalDay: { - _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); - break; - } - case kTimestampTz: { - _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); - break; - } - case kUuid: { - _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); - break; - } - case kFixedChar: { - _internal_mutable_fixed_char()->::substrait::Type_FixedChar::MergeFrom(from._internal_fixed_char()); - break; - } - case kVarchar: { - _internal_mutable_varchar()->::substrait::Type_VarChar::MergeFrom(from._internal_varchar()); - break; - } - case kFixedBinary: { - _internal_mutable_fixed_binary()->::substrait::Type_FixedBinary::MergeFrom(from._internal_fixed_binary()); - break; - } - case kDecimal: { - _internal_mutable_decimal()->::substrait::Type_Decimal::MergeFrom(from._internal_decimal()); - break; - } - case kStruct: { - _internal_mutable_struct_()->::substrait::Type_Struct::MergeFrom(from._internal_struct_()); - break; - } - case kList: { - _internal_mutable_list()->::substrait::Type_List::MergeFrom(from._internal_list()); - break; - } - case kMap: { - _internal_mutable_map()->::substrait::Type_Map::MergeFrom(from._internal_map()); - break; - } - case kUserDefinedTypeReference: { - _internal_set_user_defined_type_reference(from._internal_user_defined_type_reference()); - break; - } - case KIND_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void Type::CopyFrom(const Type& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.Type) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Type::IsInitialized() const { - return true; -} - -void Type::InternalSwap(Type* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(kind_, other->kind_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata Type::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[23]); -} - -// =================================================================== - -class NamedStruct::_Internal { - public: - static const ::substrait::Type_Struct& struct_(const NamedStruct* msg); -}; - -const ::substrait::Type_Struct& -NamedStruct::_Internal::struct_(const NamedStruct* msg) { - return *msg->struct__; -} -NamedStruct::NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - names_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.NamedStruct) -} -NamedStruct::NamedStruct(const NamedStruct& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - names_(from.names_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_struct_()) { - struct__ = new ::substrait::Type_Struct(*from.struct__); - } else { - struct__ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.NamedStruct) -} - -inline void NamedStruct::SharedCtor() { -struct__ = nullptr; -} - -NamedStruct::~NamedStruct() { - // @@protoc_insertion_point(destructor:substrait.NamedStruct) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void NamedStruct::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete struct__; -} - -void NamedStruct::ArenaDtor(void* object) { - NamedStruct* _this = reinterpret_cast< NamedStruct* >(object); - (void)_this; -} -void NamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void NamedStruct::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void NamedStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.NamedStruct) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - names_.Clear(); - if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { - delete struct__; - } - struct__ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* NamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string names = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_names(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.NamedStruct.names")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.Type.Struct struct = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* NamedStruct::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.NamedStruct) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string names = 1; - for (int i = 0, n = this->_internal_names_size(); i < n; i++) { - const auto& s = this->_internal_names(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.NamedStruct.names"); - target = stream->WriteString(1, s, target); - } - - // .substrait.Type.Struct struct = 2; - if (this->_internal_has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::struct_(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.NamedStruct) - return target; -} - -size_t NamedStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.NamedStruct) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string names = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); - for (int i = 0, n = names_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - names_.Get(i)); - } - - // .substrait.Type.Struct struct = 2; - if (this->_internal_has_struct_()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *struct__); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData NamedStruct::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - NamedStruct::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*NamedStruct::GetClassData() const { return &_class_data_; } - -void NamedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void NamedStruct::MergeFrom(const NamedStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.NamedStruct) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - names_.MergeFrom(from.names_); - if (from._internal_has_struct_()) { - _internal_mutable_struct_()->::substrait::Type_Struct::MergeFrom(from._internal_struct_()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void NamedStruct::CopyFrom(const NamedStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.NamedStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool NamedStruct::IsInitialized() const { - return true; -} - -void NamedStruct::InternalSwap(NamedStruct* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - names_.InternalSwap(&other->names_); - swap(struct__, other->struct__); -} - -::PROTOBUF_NAMESPACE_ID::Metadata NamedStruct::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_2eproto_getter, &descriptor_table_substrait_2ftype_2eproto_once, - file_level_metadata_substrait_2ftype_2eproto[24]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::substrait::Type_Boolean* Arena::CreateMaybeMessage< ::substrait::Type_Boolean >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_Boolean >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_I8* Arena::CreateMaybeMessage< ::substrait::Type_I8 >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_I8 >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_I16* Arena::CreateMaybeMessage< ::substrait::Type_I16 >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_I16 >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_I32* Arena::CreateMaybeMessage< ::substrait::Type_I32 >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_I32 >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_I64* Arena::CreateMaybeMessage< ::substrait::Type_I64 >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_I64 >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_FP32* Arena::CreateMaybeMessage< ::substrait::Type_FP32 >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_FP32 >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_FP64* Arena::CreateMaybeMessage< ::substrait::Type_FP64 >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_FP64 >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_String* Arena::CreateMaybeMessage< ::substrait::Type_String >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_String >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_Binary* Arena::CreateMaybeMessage< ::substrait::Type_Binary >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_Binary >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_Timestamp* Arena::CreateMaybeMessage< ::substrait::Type_Timestamp >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_Timestamp >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_Date* Arena::CreateMaybeMessage< ::substrait::Type_Date >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_Date >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_Time* Arena::CreateMaybeMessage< ::substrait::Type_Time >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_Time >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage< ::substrait::Type_TimestampTZ >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_TimestampTZ >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_IntervalYear* Arena::CreateMaybeMessage< ::substrait::Type_IntervalYear >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_IntervalYear >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_IntervalDay* Arena::CreateMaybeMessage< ::substrait::Type_IntervalDay >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_IntervalDay >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_UUID* Arena::CreateMaybeMessage< ::substrait::Type_UUID >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_UUID >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_FixedChar* Arena::CreateMaybeMessage< ::substrait::Type_FixedChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_FixedChar >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_VarChar* Arena::CreateMaybeMessage< ::substrait::Type_VarChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_VarChar >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_FixedBinary* Arena::CreateMaybeMessage< ::substrait::Type_FixedBinary >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_FixedBinary >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_Decimal* Arena::CreateMaybeMessage< ::substrait::Type_Decimal >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_Decimal >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_Struct* Arena::CreateMaybeMessage< ::substrait::Type_Struct >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_Struct >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_List* Arena::CreateMaybeMessage< ::substrait::Type_List >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_List >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type_Map* Arena::CreateMaybeMessage< ::substrait::Type_Map >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type_Map >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::Type* Arena::CreateMaybeMessage< ::substrait::Type >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::Type >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::NamedStruct* Arena::CreateMaybeMessage< ::substrait::NamedStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::NamedStruct >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/type.pb.h b/cpp/src/generated/substrait/type.pb.h deleted file mode 100644 index b528e2f1b56..00000000000 --- a/cpp/src/generated/substrait/type.pb.h +++ /dev/null @@ -1,8265 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/type.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3019000 -#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 3019003 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_substrait_2ftype_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_substrait_2ftype_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[25] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const uint32_t offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_2eproto; -namespace substrait { -class NamedStruct; -struct NamedStructDefaultTypeInternal; -extern NamedStructDefaultTypeInternal _NamedStruct_default_instance_; -class Type; -struct TypeDefaultTypeInternal; -extern TypeDefaultTypeInternal _Type_default_instance_; -class Type_Binary; -struct Type_BinaryDefaultTypeInternal; -extern Type_BinaryDefaultTypeInternal _Type_Binary_default_instance_; -class Type_Boolean; -struct Type_BooleanDefaultTypeInternal; -extern Type_BooleanDefaultTypeInternal _Type_Boolean_default_instance_; -class Type_Date; -struct Type_DateDefaultTypeInternal; -extern Type_DateDefaultTypeInternal _Type_Date_default_instance_; -class Type_Decimal; -struct Type_DecimalDefaultTypeInternal; -extern Type_DecimalDefaultTypeInternal _Type_Decimal_default_instance_; -class Type_FP32; -struct Type_FP32DefaultTypeInternal; -extern Type_FP32DefaultTypeInternal _Type_FP32_default_instance_; -class Type_FP64; -struct Type_FP64DefaultTypeInternal; -extern Type_FP64DefaultTypeInternal _Type_FP64_default_instance_; -class Type_FixedBinary; -struct Type_FixedBinaryDefaultTypeInternal; -extern Type_FixedBinaryDefaultTypeInternal _Type_FixedBinary_default_instance_; -class Type_FixedChar; -struct Type_FixedCharDefaultTypeInternal; -extern Type_FixedCharDefaultTypeInternal _Type_FixedChar_default_instance_; -class Type_I16; -struct Type_I16DefaultTypeInternal; -extern Type_I16DefaultTypeInternal _Type_I16_default_instance_; -class Type_I32; -struct Type_I32DefaultTypeInternal; -extern Type_I32DefaultTypeInternal _Type_I32_default_instance_; -class Type_I64; -struct Type_I64DefaultTypeInternal; -extern Type_I64DefaultTypeInternal _Type_I64_default_instance_; -class Type_I8; -struct Type_I8DefaultTypeInternal; -extern Type_I8DefaultTypeInternal _Type_I8_default_instance_; -class Type_IntervalDay; -struct Type_IntervalDayDefaultTypeInternal; -extern Type_IntervalDayDefaultTypeInternal _Type_IntervalDay_default_instance_; -class Type_IntervalYear; -struct Type_IntervalYearDefaultTypeInternal; -extern Type_IntervalYearDefaultTypeInternal _Type_IntervalYear_default_instance_; -class Type_List; -struct Type_ListDefaultTypeInternal; -extern Type_ListDefaultTypeInternal _Type_List_default_instance_; -class Type_Map; -struct Type_MapDefaultTypeInternal; -extern Type_MapDefaultTypeInternal _Type_Map_default_instance_; -class Type_String; -struct Type_StringDefaultTypeInternal; -extern Type_StringDefaultTypeInternal _Type_String_default_instance_; -class Type_Struct; -struct Type_StructDefaultTypeInternal; -extern Type_StructDefaultTypeInternal _Type_Struct_default_instance_; -class Type_Time; -struct Type_TimeDefaultTypeInternal; -extern Type_TimeDefaultTypeInternal _Type_Time_default_instance_; -class Type_Timestamp; -struct Type_TimestampDefaultTypeInternal; -extern Type_TimestampDefaultTypeInternal _Type_Timestamp_default_instance_; -class Type_TimestampTZ; -struct Type_TimestampTZDefaultTypeInternal; -extern Type_TimestampTZDefaultTypeInternal _Type_TimestampTZ_default_instance_; -class Type_UUID; -struct Type_UUIDDefaultTypeInternal; -extern Type_UUIDDefaultTypeInternal _Type_UUID_default_instance_; -class Type_VarChar; -struct Type_VarCharDefaultTypeInternal; -extern Type_VarCharDefaultTypeInternal _Type_VarChar_default_instance_; -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> ::substrait::NamedStruct* Arena::CreateMaybeMessage<::substrait::NamedStruct>(Arena*); -template<> ::substrait::Type* Arena::CreateMaybeMessage<::substrait::Type>(Arena*); -template<> ::substrait::Type_Binary* Arena::CreateMaybeMessage<::substrait::Type_Binary>(Arena*); -template<> ::substrait::Type_Boolean* Arena::CreateMaybeMessage<::substrait::Type_Boolean>(Arena*); -template<> ::substrait::Type_Date* Arena::CreateMaybeMessage<::substrait::Type_Date>(Arena*); -template<> ::substrait::Type_Decimal* Arena::CreateMaybeMessage<::substrait::Type_Decimal>(Arena*); -template<> ::substrait::Type_FP32* Arena::CreateMaybeMessage<::substrait::Type_FP32>(Arena*); -template<> ::substrait::Type_FP64* Arena::CreateMaybeMessage<::substrait::Type_FP64>(Arena*); -template<> ::substrait::Type_FixedBinary* Arena::CreateMaybeMessage<::substrait::Type_FixedBinary>(Arena*); -template<> ::substrait::Type_FixedChar* Arena::CreateMaybeMessage<::substrait::Type_FixedChar>(Arena*); -template<> ::substrait::Type_I16* Arena::CreateMaybeMessage<::substrait::Type_I16>(Arena*); -template<> ::substrait::Type_I32* Arena::CreateMaybeMessage<::substrait::Type_I32>(Arena*); -template<> ::substrait::Type_I64* Arena::CreateMaybeMessage<::substrait::Type_I64>(Arena*); -template<> ::substrait::Type_I8* Arena::CreateMaybeMessage<::substrait::Type_I8>(Arena*); -template<> ::substrait::Type_IntervalDay* Arena::CreateMaybeMessage<::substrait::Type_IntervalDay>(Arena*); -template<> ::substrait::Type_IntervalYear* Arena::CreateMaybeMessage<::substrait::Type_IntervalYear>(Arena*); -template<> ::substrait::Type_List* Arena::CreateMaybeMessage<::substrait::Type_List>(Arena*); -template<> ::substrait::Type_Map* Arena::CreateMaybeMessage<::substrait::Type_Map>(Arena*); -template<> ::substrait::Type_String* Arena::CreateMaybeMessage<::substrait::Type_String>(Arena*); -template<> ::substrait::Type_Struct* Arena::CreateMaybeMessage<::substrait::Type_Struct>(Arena*); -template<> ::substrait::Type_Time* Arena::CreateMaybeMessage<::substrait::Type_Time>(Arena*); -template<> ::substrait::Type_Timestamp* Arena::CreateMaybeMessage<::substrait::Type_Timestamp>(Arena*); -template<> ::substrait::Type_TimestampTZ* Arena::CreateMaybeMessage<::substrait::Type_TimestampTZ>(Arena*); -template<> ::substrait::Type_UUID* Arena::CreateMaybeMessage<::substrait::Type_UUID>(Arena*); -template<> ::substrait::Type_VarChar* Arena::CreateMaybeMessage<::substrait::Type_VarChar>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace substrait { - -enum Type_Nullability : int { - Type_Nullability_NULLABILITY_UNSPECIFIED = 0, - Type_Nullability_NULLABILITY_NULLABLE = 1, - Type_Nullability_NULLABILITY_REQUIRED = 2, - Type_Nullability_Type_Nullability_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - Type_Nullability_Type_Nullability_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool Type_Nullability_IsValid(int value); -constexpr Type_Nullability Type_Nullability_Nullability_MIN = Type_Nullability_NULLABILITY_UNSPECIFIED; -constexpr Type_Nullability Type_Nullability_Nullability_MAX = Type_Nullability_NULLABILITY_REQUIRED; -constexpr int Type_Nullability_Nullability_ARRAYSIZE = Type_Nullability_Nullability_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Type_Nullability_descriptor(); -template -inline const std::string& Type_Nullability_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Type_Nullability_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - Type_Nullability_descriptor(), enum_t_value); -} -inline bool Type_Nullability_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Type_Nullability* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - Type_Nullability_descriptor(), name, value); -} -// =================================================================== - -class Type_Boolean final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Boolean) */ { - public: - inline Type_Boolean() : Type_Boolean(nullptr) {} - ~Type_Boolean() override; - explicit constexpr Type_Boolean(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_Boolean(const Type_Boolean& from); - Type_Boolean(Type_Boolean&& from) noexcept - : Type_Boolean() { - *this = ::std::move(from); - } - - inline Type_Boolean& operator=(const Type_Boolean& from) { - CopyFrom(from); - return *this; - } - inline Type_Boolean& operator=(Type_Boolean&& 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 Type_Boolean& default_instance() { - return *internal_default_instance(); - } - static inline const Type_Boolean* internal_default_instance() { - return reinterpret_cast( - &_Type_Boolean_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(Type_Boolean& a, Type_Boolean& b) { - a.Swap(&b); - } - inline void Swap(Type_Boolean* 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(Type_Boolean* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_Boolean* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_Boolean& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_Boolean& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_Boolean* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.Boolean"; - } - protected: - explicit Type_Boolean(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.Boolean) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_I8 final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I8) */ { - public: - inline Type_I8() : Type_I8(nullptr) {} - ~Type_I8() override; - explicit constexpr Type_I8(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_I8(const Type_I8& from); - Type_I8(Type_I8&& from) noexcept - : Type_I8() { - *this = ::std::move(from); - } - - inline Type_I8& operator=(const Type_I8& from) { - CopyFrom(from); - return *this; - } - inline Type_I8& operator=(Type_I8&& 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 Type_I8& default_instance() { - return *internal_default_instance(); - } - static inline const Type_I8* internal_default_instance() { - return reinterpret_cast( - &_Type_I8_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(Type_I8& a, Type_I8& b) { - a.Swap(&b); - } - inline void Swap(Type_I8* 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(Type_I8* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_I8* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_I8& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_I8& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_I8* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.I8"; - } - protected: - explicit Type_I8(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.I8) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_I16 final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I16) */ { - public: - inline Type_I16() : Type_I16(nullptr) {} - ~Type_I16() override; - explicit constexpr Type_I16(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_I16(const Type_I16& from); - Type_I16(Type_I16&& from) noexcept - : Type_I16() { - *this = ::std::move(from); - } - - inline Type_I16& operator=(const Type_I16& from) { - CopyFrom(from); - return *this; - } - inline Type_I16& operator=(Type_I16&& 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 Type_I16& default_instance() { - return *internal_default_instance(); - } - static inline const Type_I16* internal_default_instance() { - return reinterpret_cast( - &_Type_I16_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(Type_I16& a, Type_I16& b) { - a.Swap(&b); - } - inline void Swap(Type_I16* 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(Type_I16* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_I16* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_I16& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_I16& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_I16* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.I16"; - } - protected: - explicit Type_I16(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.I16) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_I32 final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I32) */ { - public: - inline Type_I32() : Type_I32(nullptr) {} - ~Type_I32() override; - explicit constexpr Type_I32(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_I32(const Type_I32& from); - Type_I32(Type_I32&& from) noexcept - : Type_I32() { - *this = ::std::move(from); - } - - inline Type_I32& operator=(const Type_I32& from) { - CopyFrom(from); - return *this; - } - inline Type_I32& operator=(Type_I32&& 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 Type_I32& default_instance() { - return *internal_default_instance(); - } - static inline const Type_I32* internal_default_instance() { - return reinterpret_cast( - &_Type_I32_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(Type_I32& a, Type_I32& b) { - a.Swap(&b); - } - inline void Swap(Type_I32* 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(Type_I32* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_I32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_I32& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_I32& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_I32* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.I32"; - } - protected: - explicit Type_I32(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.I32) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_I64 final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.I64) */ { - public: - inline Type_I64() : Type_I64(nullptr) {} - ~Type_I64() override; - explicit constexpr Type_I64(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_I64(const Type_I64& from); - Type_I64(Type_I64&& from) noexcept - : Type_I64() { - *this = ::std::move(from); - } - - inline Type_I64& operator=(const Type_I64& from) { - CopyFrom(from); - return *this; - } - inline Type_I64& operator=(Type_I64&& 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 Type_I64& default_instance() { - return *internal_default_instance(); - } - static inline const Type_I64* internal_default_instance() { - return reinterpret_cast( - &_Type_I64_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(Type_I64& a, Type_I64& b) { - a.Swap(&b); - } - inline void Swap(Type_I64* 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(Type_I64* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_I64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_I64& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_I64& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_I64* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.I64"; - } - protected: - explicit Type_I64(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.I64) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_FP32 final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FP32) */ { - public: - inline Type_FP32() : Type_FP32(nullptr) {} - ~Type_FP32() override; - explicit constexpr Type_FP32(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_FP32(const Type_FP32& from); - Type_FP32(Type_FP32&& from) noexcept - : Type_FP32() { - *this = ::std::move(from); - } - - inline Type_FP32& operator=(const Type_FP32& from) { - CopyFrom(from); - return *this; - } - inline Type_FP32& operator=(Type_FP32&& 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 Type_FP32& default_instance() { - return *internal_default_instance(); - } - static inline const Type_FP32* internal_default_instance() { - return reinterpret_cast( - &_Type_FP32_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(Type_FP32& a, Type_FP32& b) { - a.Swap(&b); - } - inline void Swap(Type_FP32* 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(Type_FP32* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_FP32* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_FP32& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_FP32& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_FP32* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.FP32"; - } - protected: - explicit Type_FP32(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.FP32) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_FP64 final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FP64) */ { - public: - inline Type_FP64() : Type_FP64(nullptr) {} - ~Type_FP64() override; - explicit constexpr Type_FP64(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_FP64(const Type_FP64& from); - Type_FP64(Type_FP64&& from) noexcept - : Type_FP64() { - *this = ::std::move(from); - } - - inline Type_FP64& operator=(const Type_FP64& from) { - CopyFrom(from); - return *this; - } - inline Type_FP64& operator=(Type_FP64&& 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 Type_FP64& default_instance() { - return *internal_default_instance(); - } - static inline const Type_FP64* internal_default_instance() { - return reinterpret_cast( - &_Type_FP64_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(Type_FP64& a, Type_FP64& b) { - a.Swap(&b); - } - inline void Swap(Type_FP64* 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(Type_FP64* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_FP64* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_FP64& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_FP64& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_FP64* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.FP64"; - } - protected: - explicit Type_FP64(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.FP64) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_String final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.String) */ { - public: - inline Type_String() : Type_String(nullptr) {} - ~Type_String() override; - explicit constexpr Type_String(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_String(const Type_String& from); - Type_String(Type_String&& from) noexcept - : Type_String() { - *this = ::std::move(from); - } - - inline Type_String& operator=(const Type_String& from) { - CopyFrom(from); - return *this; - } - inline Type_String& operator=(Type_String&& 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 Type_String& default_instance() { - return *internal_default_instance(); - } - static inline const Type_String* internal_default_instance() { - return reinterpret_cast( - &_Type_String_default_instance_); - } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(Type_String& a, Type_String& b) { - a.Swap(&b); - } - inline void Swap(Type_String* 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(Type_String* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_String* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_String& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_String& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_String* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.String"; - } - protected: - explicit Type_String(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.String) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_Binary final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Binary) */ { - public: - inline Type_Binary() : Type_Binary(nullptr) {} - ~Type_Binary() override; - explicit constexpr Type_Binary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_Binary(const Type_Binary& from); - Type_Binary(Type_Binary&& from) noexcept - : Type_Binary() { - *this = ::std::move(from); - } - - inline Type_Binary& operator=(const Type_Binary& from) { - CopyFrom(from); - return *this; - } - inline Type_Binary& operator=(Type_Binary&& 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 Type_Binary& default_instance() { - return *internal_default_instance(); - } - static inline const Type_Binary* internal_default_instance() { - return reinterpret_cast( - &_Type_Binary_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(Type_Binary& a, Type_Binary& b) { - a.Swap(&b); - } - inline void Swap(Type_Binary* 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(Type_Binary* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_Binary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_Binary& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_Binary& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_Binary* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.Binary"; - } - protected: - explicit Type_Binary(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.Binary) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_Timestamp final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Timestamp) */ { - public: - inline Type_Timestamp() : Type_Timestamp(nullptr) {} - ~Type_Timestamp() override; - explicit constexpr Type_Timestamp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_Timestamp(const Type_Timestamp& from); - Type_Timestamp(Type_Timestamp&& from) noexcept - : Type_Timestamp() { - *this = ::std::move(from); - } - - inline Type_Timestamp& operator=(const Type_Timestamp& from) { - CopyFrom(from); - return *this; - } - inline Type_Timestamp& operator=(Type_Timestamp&& 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 Type_Timestamp& default_instance() { - return *internal_default_instance(); - } - static inline const Type_Timestamp* internal_default_instance() { - return reinterpret_cast( - &_Type_Timestamp_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(Type_Timestamp& a, Type_Timestamp& b) { - a.Swap(&b); - } - inline void Swap(Type_Timestamp* 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(Type_Timestamp* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_Timestamp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_Timestamp& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_Timestamp& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_Timestamp* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.Timestamp"; - } - protected: - explicit Type_Timestamp(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.Timestamp) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_Date final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Date) */ { - public: - inline Type_Date() : Type_Date(nullptr) {} - ~Type_Date() override; - explicit constexpr Type_Date(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_Date(const Type_Date& from); - Type_Date(Type_Date&& from) noexcept - : Type_Date() { - *this = ::std::move(from); - } - - inline Type_Date& operator=(const Type_Date& from) { - CopyFrom(from); - return *this; - } - inline Type_Date& operator=(Type_Date&& 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 Type_Date& default_instance() { - return *internal_default_instance(); - } - static inline const Type_Date* internal_default_instance() { - return reinterpret_cast( - &_Type_Date_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(Type_Date& a, Type_Date& b) { - a.Swap(&b); - } - inline void Swap(Type_Date* 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(Type_Date* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_Date* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_Date& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_Date& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_Date* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.Date"; - } - protected: - explicit Type_Date(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.Date) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_Time final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Time) */ { - public: - inline Type_Time() : Type_Time(nullptr) {} - ~Type_Time() override; - explicit constexpr Type_Time(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_Time(const Type_Time& from); - Type_Time(Type_Time&& from) noexcept - : Type_Time() { - *this = ::std::move(from); - } - - inline Type_Time& operator=(const Type_Time& from) { - CopyFrom(from); - return *this; - } - inline Type_Time& operator=(Type_Time&& 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 Type_Time& default_instance() { - return *internal_default_instance(); - } - static inline const Type_Time* internal_default_instance() { - return reinterpret_cast( - &_Type_Time_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(Type_Time& a, Type_Time& b) { - a.Swap(&b); - } - inline void Swap(Type_Time* 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(Type_Time* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_Time* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_Time& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_Time& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_Time* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.Time"; - } - protected: - explicit Type_Time(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.Time) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_TimestampTZ final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.TimestampTZ) */ { - public: - inline Type_TimestampTZ() : Type_TimestampTZ(nullptr) {} - ~Type_TimestampTZ() override; - explicit constexpr Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_TimestampTZ(const Type_TimestampTZ& from); - Type_TimestampTZ(Type_TimestampTZ&& from) noexcept - : Type_TimestampTZ() { - *this = ::std::move(from); - } - - inline Type_TimestampTZ& operator=(const Type_TimestampTZ& from) { - CopyFrom(from); - return *this; - } - inline Type_TimestampTZ& operator=(Type_TimestampTZ&& 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 Type_TimestampTZ& default_instance() { - return *internal_default_instance(); - } - static inline const Type_TimestampTZ* internal_default_instance() { - return reinterpret_cast( - &_Type_TimestampTZ_default_instance_); - } - static constexpr int kIndexInFileMessages = - 12; - - friend void swap(Type_TimestampTZ& a, Type_TimestampTZ& b) { - a.Swap(&b); - } - inline void Swap(Type_TimestampTZ* 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(Type_TimestampTZ* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_TimestampTZ* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_TimestampTZ& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_TimestampTZ& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_TimestampTZ* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.TimestampTZ"; - } - protected: - explicit Type_TimestampTZ(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.TimestampTZ) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_IntervalYear final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.IntervalYear) */ { - public: - inline Type_IntervalYear() : Type_IntervalYear(nullptr) {} - ~Type_IntervalYear() override; - explicit constexpr Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_IntervalYear(const Type_IntervalYear& from); - Type_IntervalYear(Type_IntervalYear&& from) noexcept - : Type_IntervalYear() { - *this = ::std::move(from); - } - - inline Type_IntervalYear& operator=(const Type_IntervalYear& from) { - CopyFrom(from); - return *this; - } - inline Type_IntervalYear& operator=(Type_IntervalYear&& 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 Type_IntervalYear& default_instance() { - return *internal_default_instance(); - } - static inline const Type_IntervalYear* internal_default_instance() { - return reinterpret_cast( - &_Type_IntervalYear_default_instance_); - } - static constexpr int kIndexInFileMessages = - 13; - - friend void swap(Type_IntervalYear& a, Type_IntervalYear& b) { - a.Swap(&b); - } - inline void Swap(Type_IntervalYear* 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(Type_IntervalYear* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_IntervalYear* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_IntervalYear& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_IntervalYear& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_IntervalYear* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.IntervalYear"; - } - protected: - explicit Type_IntervalYear(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.IntervalYear) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_IntervalDay final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.IntervalDay) */ { - public: - inline Type_IntervalDay() : Type_IntervalDay(nullptr) {} - ~Type_IntervalDay() override; - explicit constexpr Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_IntervalDay(const Type_IntervalDay& from); - Type_IntervalDay(Type_IntervalDay&& from) noexcept - : Type_IntervalDay() { - *this = ::std::move(from); - } - - inline Type_IntervalDay& operator=(const Type_IntervalDay& from) { - CopyFrom(from); - return *this; - } - inline Type_IntervalDay& operator=(Type_IntervalDay&& 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 Type_IntervalDay& default_instance() { - return *internal_default_instance(); - } - static inline const Type_IntervalDay* internal_default_instance() { - return reinterpret_cast( - &_Type_IntervalDay_default_instance_); - } - static constexpr int kIndexInFileMessages = - 14; - - friend void swap(Type_IntervalDay& a, Type_IntervalDay& b) { - a.Swap(&b); - } - inline void Swap(Type_IntervalDay* 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(Type_IntervalDay* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_IntervalDay* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_IntervalDay& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_IntervalDay& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_IntervalDay* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.IntervalDay"; - } - protected: - explicit Type_IntervalDay(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.IntervalDay) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_UUID final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.UUID) */ { - public: - inline Type_UUID() : Type_UUID(nullptr) {} - ~Type_UUID() override; - explicit constexpr Type_UUID(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_UUID(const Type_UUID& from); - Type_UUID(Type_UUID&& from) noexcept - : Type_UUID() { - *this = ::std::move(from); - } - - inline Type_UUID& operator=(const Type_UUID& from) { - CopyFrom(from); - return *this; - } - inline Type_UUID& operator=(Type_UUID&& 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 Type_UUID& default_instance() { - return *internal_default_instance(); - } - static inline const Type_UUID* internal_default_instance() { - return reinterpret_cast( - &_Type_UUID_default_instance_); - } - static constexpr int kIndexInFileMessages = - 15; - - friend void swap(Type_UUID& a, Type_UUID& b) { - a.Swap(&b); - } - inline void Swap(Type_UUID* 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(Type_UUID* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_UUID* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_UUID& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_UUID& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_UUID* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.UUID"; - } - protected: - explicit Type_UUID(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeVariationReferenceFieldNumber = 1, - kNullabilityFieldNumber = 2, - }; - // uint32 type_variation_reference = 1; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 2; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.UUID) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_FixedChar final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FixedChar) */ { - public: - inline Type_FixedChar() : Type_FixedChar(nullptr) {} - ~Type_FixedChar() override; - explicit constexpr Type_FixedChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_FixedChar(const Type_FixedChar& from); - Type_FixedChar(Type_FixedChar&& from) noexcept - : Type_FixedChar() { - *this = ::std::move(from); - } - - inline Type_FixedChar& operator=(const Type_FixedChar& from) { - CopyFrom(from); - return *this; - } - inline Type_FixedChar& operator=(Type_FixedChar&& 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 Type_FixedChar& default_instance() { - return *internal_default_instance(); - } - static inline const Type_FixedChar* internal_default_instance() { - return reinterpret_cast( - &_Type_FixedChar_default_instance_); - } - static constexpr int kIndexInFileMessages = - 16; - - friend void swap(Type_FixedChar& a, Type_FixedChar& b) { - a.Swap(&b); - } - inline void Swap(Type_FixedChar* 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(Type_FixedChar* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_FixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_FixedChar& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_FixedChar& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_FixedChar* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.FixedChar"; - } - protected: - explicit Type_FixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLengthFieldNumber = 1, - kTypeVariationReferenceFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // int32 length = 1; - void clear_length(); - int32_t length() const; - void set_length(int32_t value); - private: - int32_t _internal_length() const; - void _internal_set_length(int32_t value); - public: - - // uint32 type_variation_reference = 2; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.FixedChar) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int32_t length_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_VarChar final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.VarChar) */ { - public: - inline Type_VarChar() : Type_VarChar(nullptr) {} - ~Type_VarChar() override; - explicit constexpr Type_VarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_VarChar(const Type_VarChar& from); - Type_VarChar(Type_VarChar&& from) noexcept - : Type_VarChar() { - *this = ::std::move(from); - } - - inline Type_VarChar& operator=(const Type_VarChar& from) { - CopyFrom(from); - return *this; - } - inline Type_VarChar& operator=(Type_VarChar&& 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 Type_VarChar& default_instance() { - return *internal_default_instance(); - } - static inline const Type_VarChar* internal_default_instance() { - return reinterpret_cast( - &_Type_VarChar_default_instance_); - } - static constexpr int kIndexInFileMessages = - 17; - - friend void swap(Type_VarChar& a, Type_VarChar& b) { - a.Swap(&b); - } - inline void Swap(Type_VarChar* 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(Type_VarChar* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_VarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_VarChar& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_VarChar& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_VarChar* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.VarChar"; - } - protected: - explicit Type_VarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLengthFieldNumber = 1, - kTypeVariationReferenceFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // int32 length = 1; - void clear_length(); - int32_t length() const; - void set_length(int32_t value); - private: - int32_t _internal_length() const; - void _internal_set_length(int32_t value); - public: - - // uint32 type_variation_reference = 2; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.VarChar) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int32_t length_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_FixedBinary final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.FixedBinary) */ { - public: - inline Type_FixedBinary() : Type_FixedBinary(nullptr) {} - ~Type_FixedBinary() override; - explicit constexpr Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_FixedBinary(const Type_FixedBinary& from); - Type_FixedBinary(Type_FixedBinary&& from) noexcept - : Type_FixedBinary() { - *this = ::std::move(from); - } - - inline Type_FixedBinary& operator=(const Type_FixedBinary& from) { - CopyFrom(from); - return *this; - } - inline Type_FixedBinary& operator=(Type_FixedBinary&& 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 Type_FixedBinary& default_instance() { - return *internal_default_instance(); - } - static inline const Type_FixedBinary* internal_default_instance() { - return reinterpret_cast( - &_Type_FixedBinary_default_instance_); - } - static constexpr int kIndexInFileMessages = - 18; - - friend void swap(Type_FixedBinary& a, Type_FixedBinary& b) { - a.Swap(&b); - } - inline void Swap(Type_FixedBinary* 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(Type_FixedBinary* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_FixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_FixedBinary& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_FixedBinary& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_FixedBinary* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.FixedBinary"; - } - protected: - explicit Type_FixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLengthFieldNumber = 1, - kTypeVariationReferenceFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // int32 length = 1; - void clear_length(); - int32_t length() const; - void set_length(int32_t value); - private: - int32_t _internal_length() const; - void _internal_set_length(int32_t value); - public: - - // uint32 type_variation_reference = 2; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.FixedBinary) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int32_t length_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_Decimal final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Decimal) */ { - public: - inline Type_Decimal() : Type_Decimal(nullptr) {} - ~Type_Decimal() override; - explicit constexpr Type_Decimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_Decimal(const Type_Decimal& from); - Type_Decimal(Type_Decimal&& from) noexcept - : Type_Decimal() { - *this = ::std::move(from); - } - - inline Type_Decimal& operator=(const Type_Decimal& from) { - CopyFrom(from); - return *this; - } - inline Type_Decimal& operator=(Type_Decimal&& 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 Type_Decimal& default_instance() { - return *internal_default_instance(); - } - static inline const Type_Decimal* internal_default_instance() { - return reinterpret_cast( - &_Type_Decimal_default_instance_); - } - static constexpr int kIndexInFileMessages = - 19; - - friend void swap(Type_Decimal& a, Type_Decimal& b) { - a.Swap(&b); - } - inline void Swap(Type_Decimal* 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(Type_Decimal* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_Decimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_Decimal& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_Decimal& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_Decimal* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.Decimal"; - } - protected: - explicit Type_Decimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kScaleFieldNumber = 1, - kPrecisionFieldNumber = 2, - kTypeVariationReferenceFieldNumber = 3, - kNullabilityFieldNumber = 4, - }; - // int32 scale = 1; - void clear_scale(); - int32_t scale() const; - void set_scale(int32_t value); - private: - int32_t _internal_scale() const; - void _internal_set_scale(int32_t value); - public: - - // int32 precision = 2; - void clear_precision(); - int32_t precision() const; - void set_precision(int32_t value); - private: - int32_t _internal_precision() const; - void _internal_set_precision(int32_t value); - public: - - // uint32 type_variation_reference = 3; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 4; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.Decimal) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - int32_t scale_; - int32_t precision_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_Struct final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Struct) */ { - public: - inline Type_Struct() : Type_Struct(nullptr) {} - ~Type_Struct() override; - explicit constexpr Type_Struct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_Struct(const Type_Struct& from); - Type_Struct(Type_Struct&& from) noexcept - : Type_Struct() { - *this = ::std::move(from); - } - - inline Type_Struct& operator=(const Type_Struct& from) { - CopyFrom(from); - return *this; - } - inline Type_Struct& operator=(Type_Struct&& 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 Type_Struct& default_instance() { - return *internal_default_instance(); - } - static inline const Type_Struct* internal_default_instance() { - return reinterpret_cast( - &_Type_Struct_default_instance_); - } - static constexpr int kIndexInFileMessages = - 20; - - friend void swap(Type_Struct& a, Type_Struct& b) { - a.Swap(&b); - } - inline void Swap(Type_Struct* 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(Type_Struct* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_Struct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_Struct& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_Struct& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_Struct* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.Struct"; - } - protected: - explicit Type_Struct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypesFieldNumber = 1, - kTypeVariationReferenceFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // repeated .substrait.Type types = 1; - int types_size() const; - private: - int _internal_types_size() const; - public: - void clear_types(); - ::substrait::Type* mutable_types(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >* - mutable_types(); - private: - const ::substrait::Type& _internal_types(int index) const; - ::substrait::Type* _internal_add_types(); - public: - const ::substrait::Type& types(int index) const; - ::substrait::Type* add_types(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >& - types() const; - - // uint32 type_variation_reference = 2; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.Struct) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type > types_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_List final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.List) */ { - public: - inline Type_List() : Type_List(nullptr) {} - ~Type_List() override; - explicit constexpr Type_List(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_List(const Type_List& from); - Type_List(Type_List&& from) noexcept - : Type_List() { - *this = ::std::move(from); - } - - inline Type_List& operator=(const Type_List& from) { - CopyFrom(from); - return *this; - } - inline Type_List& operator=(Type_List&& 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 Type_List& default_instance() { - return *internal_default_instance(); - } - static inline const Type_List* internal_default_instance() { - return reinterpret_cast( - &_Type_List_default_instance_); - } - static constexpr int kIndexInFileMessages = - 21; - - friend void swap(Type_List& a, Type_List& b) { - a.Swap(&b); - } - inline void Swap(Type_List* 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(Type_List* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_List& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_List& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_List* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.List"; - } - protected: - explicit Type_List(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeFieldNumber = 1, - kTypeVariationReferenceFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // .substrait.Type type = 1; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - const ::substrait::Type& type() const; - PROTOBUF_NODISCARD ::substrait::Type* release_type(); - ::substrait::Type* mutable_type(); - void set_allocated_type(::substrait::Type* type); - private: - const ::substrait::Type& _internal_type() const; - ::substrait::Type* _internal_mutable_type(); - public: - void unsafe_arena_set_allocated_type( - ::substrait::Type* type); - ::substrait::Type* unsafe_arena_release_type(); - - // uint32 type_variation_reference = 2; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.List) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Type* type_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type_Map final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type.Map) */ { - public: - inline Type_Map() : Type_Map(nullptr) {} - ~Type_Map() override; - explicit constexpr Type_Map(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type_Map(const Type_Map& from); - Type_Map(Type_Map&& from) noexcept - : Type_Map() { - *this = ::std::move(from); - } - - inline Type_Map& operator=(const Type_Map& from) { - CopyFrom(from); - return *this; - } - inline Type_Map& operator=(Type_Map&& 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 Type_Map& default_instance() { - return *internal_default_instance(); - } - static inline const Type_Map* internal_default_instance() { - return reinterpret_cast( - &_Type_Map_default_instance_); - } - static constexpr int kIndexInFileMessages = - 22; - - friend void swap(Type_Map& a, Type_Map& b) { - a.Swap(&b); - } - inline void Swap(Type_Map* 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(Type_Map* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type_Map* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type_Map& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type_Map& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type_Map* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type.Map"; - } - protected: - explicit Type_Map(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kKeyFieldNumber = 1, - kValueFieldNumber = 2, - kTypeVariationReferenceFieldNumber = 3, - kNullabilityFieldNumber = 4, - }; - // .substrait.Type key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::substrait::Type& key() const; - PROTOBUF_NODISCARD ::substrait::Type* release_key(); - ::substrait::Type* mutable_key(); - void set_allocated_key(::substrait::Type* key); - private: - const ::substrait::Type& _internal_key() const; - ::substrait::Type* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::substrait::Type* key); - ::substrait::Type* unsafe_arena_release_key(); - - // .substrait.Type value = 2; - bool has_value() const; - private: - bool _internal_has_value() const; - public: - void clear_value(); - const ::substrait::Type& value() const; - PROTOBUF_NODISCARD ::substrait::Type* release_value(); - ::substrait::Type* mutable_value(); - void set_allocated_value(::substrait::Type* value); - private: - const ::substrait::Type& _internal_value() const; - ::substrait::Type* _internal_mutable_value(); - public: - void unsafe_arena_set_allocated_value( - ::substrait::Type* value); - ::substrait::Type* unsafe_arena_release_value(); - - // uint32 type_variation_reference = 3; - void clear_type_variation_reference(); - uint32_t type_variation_reference() const; - void set_type_variation_reference(uint32_t value); - private: - uint32_t _internal_type_variation_reference() const; - void _internal_set_type_variation_reference(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 4; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.Type.Map) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::Type* key_; - ::substrait::Type* value_; - uint32_t type_variation_reference_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class Type final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.Type) */ { - public: - inline Type() : Type(nullptr) {} - ~Type() override; - explicit constexpr Type(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - Type(const Type& from); - Type(Type&& from) noexcept - : Type() { - *this = ::std::move(from); - } - - inline Type& operator=(const Type& from) { - CopyFrom(from); - return *this; - } - inline Type& operator=(Type&& 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 Type& default_instance() { - return *internal_default_instance(); - } - enum KindCase { - kBool = 1, - kI8 = 2, - kI16 = 3, - kI32 = 5, - kI64 = 7, - kFp32 = 10, - kFp64 = 11, - kString = 12, - kBinary = 13, - kTimestamp = 14, - kDate = 16, - kTime = 17, - kIntervalYear = 19, - kIntervalDay = 20, - kTimestampTz = 29, - kUuid = 32, - kFixedChar = 21, - kVarchar = 22, - kFixedBinary = 23, - kDecimal = 24, - kStruct = 25, - kList = 27, - kMap = 28, - kUserDefinedTypeReference = 31, - KIND_NOT_SET = 0, - }; - - static inline const Type* internal_default_instance() { - return reinterpret_cast( - &_Type_default_instance_); - } - static constexpr int kIndexInFileMessages = - 23; - - friend void swap(Type& a, Type& b) { - a.Swap(&b); - } - inline void Swap(Type* 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(Type* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Type* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const Type& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const Type& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(Type* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.Type"; - } - protected: - explicit Type(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef Type_Boolean Boolean; - typedef Type_I8 I8; - typedef Type_I16 I16; - typedef Type_I32 I32; - typedef Type_I64 I64; - typedef Type_FP32 FP32; - typedef Type_FP64 FP64; - typedef Type_String String; - typedef Type_Binary Binary; - typedef Type_Timestamp Timestamp; - typedef Type_Date Date; - typedef Type_Time Time; - typedef Type_TimestampTZ TimestampTZ; - typedef Type_IntervalYear IntervalYear; - typedef Type_IntervalDay IntervalDay; - typedef Type_UUID UUID; - typedef Type_FixedChar FixedChar; - typedef Type_VarChar VarChar; - typedef Type_FixedBinary FixedBinary; - typedef Type_Decimal Decimal; - typedef Type_Struct Struct; - typedef Type_List List; - typedef Type_Map Map; - - typedef Type_Nullability Nullability; - static constexpr Nullability NULLABILITY_UNSPECIFIED = - Type_Nullability_NULLABILITY_UNSPECIFIED; - static constexpr Nullability NULLABILITY_NULLABLE = - Type_Nullability_NULLABILITY_NULLABLE; - static constexpr Nullability NULLABILITY_REQUIRED = - Type_Nullability_NULLABILITY_REQUIRED; - static inline bool Nullability_IsValid(int value) { - return Type_Nullability_IsValid(value); - } - static constexpr Nullability Nullability_MIN = - Type_Nullability_Nullability_MIN; - static constexpr Nullability Nullability_MAX = - Type_Nullability_Nullability_MAX; - static constexpr int Nullability_ARRAYSIZE = - Type_Nullability_Nullability_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - Nullability_descriptor() { - return Type_Nullability_descriptor(); - } - template - static inline const std::string& Nullability_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function Nullability_Name."); - return Type_Nullability_Name(enum_t_value); - } - static inline bool Nullability_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - Nullability* value) { - return Type_Nullability_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kBoolFieldNumber = 1, - kI8FieldNumber = 2, - kI16FieldNumber = 3, - kI32FieldNumber = 5, - kI64FieldNumber = 7, - kFp32FieldNumber = 10, - kFp64FieldNumber = 11, - kStringFieldNumber = 12, - kBinaryFieldNumber = 13, - kTimestampFieldNumber = 14, - kDateFieldNumber = 16, - kTimeFieldNumber = 17, - kIntervalYearFieldNumber = 19, - kIntervalDayFieldNumber = 20, - kTimestampTzFieldNumber = 29, - kUuidFieldNumber = 32, - kFixedCharFieldNumber = 21, - kVarcharFieldNumber = 22, - kFixedBinaryFieldNumber = 23, - kDecimalFieldNumber = 24, - kStructFieldNumber = 25, - kListFieldNumber = 27, - kMapFieldNumber = 28, - kUserDefinedTypeReferenceFieldNumber = 31, - }; - // .substrait.Type.Boolean bool = 1; - bool has_bool_() const; - private: - bool _internal_has_bool_() const; - public: - void clear_bool_(); - const ::substrait::Type_Boolean& bool_() const; - PROTOBUF_NODISCARD ::substrait::Type_Boolean* release_bool_(); - ::substrait::Type_Boolean* mutable_bool_(); - void set_allocated_bool_(::substrait::Type_Boolean* bool_); - private: - const ::substrait::Type_Boolean& _internal_bool_() const; - ::substrait::Type_Boolean* _internal_mutable_bool_(); - public: - void unsafe_arena_set_allocated_bool_( - ::substrait::Type_Boolean* bool_); - ::substrait::Type_Boolean* unsafe_arena_release_bool_(); - - // .substrait.Type.I8 i8 = 2; - bool has_i8() const; - private: - bool _internal_has_i8() const; - public: - void clear_i8(); - const ::substrait::Type_I8& i8() const; - PROTOBUF_NODISCARD ::substrait::Type_I8* release_i8(); - ::substrait::Type_I8* mutable_i8(); - void set_allocated_i8(::substrait::Type_I8* i8); - private: - const ::substrait::Type_I8& _internal_i8() const; - ::substrait::Type_I8* _internal_mutable_i8(); - public: - void unsafe_arena_set_allocated_i8( - ::substrait::Type_I8* i8); - ::substrait::Type_I8* unsafe_arena_release_i8(); - - // .substrait.Type.I16 i16 = 3; - bool has_i16() const; - private: - bool _internal_has_i16() const; - public: - void clear_i16(); - const ::substrait::Type_I16& i16() const; - PROTOBUF_NODISCARD ::substrait::Type_I16* release_i16(); - ::substrait::Type_I16* mutable_i16(); - void set_allocated_i16(::substrait::Type_I16* i16); - private: - const ::substrait::Type_I16& _internal_i16() const; - ::substrait::Type_I16* _internal_mutable_i16(); - public: - void unsafe_arena_set_allocated_i16( - ::substrait::Type_I16* i16); - ::substrait::Type_I16* unsafe_arena_release_i16(); - - // .substrait.Type.I32 i32 = 5; - bool has_i32() const; - private: - bool _internal_has_i32() const; - public: - void clear_i32(); - const ::substrait::Type_I32& i32() const; - PROTOBUF_NODISCARD ::substrait::Type_I32* release_i32(); - ::substrait::Type_I32* mutable_i32(); - void set_allocated_i32(::substrait::Type_I32* i32); - private: - const ::substrait::Type_I32& _internal_i32() const; - ::substrait::Type_I32* _internal_mutable_i32(); - public: - void unsafe_arena_set_allocated_i32( - ::substrait::Type_I32* i32); - ::substrait::Type_I32* unsafe_arena_release_i32(); - - // .substrait.Type.I64 i64 = 7; - bool has_i64() const; - private: - bool _internal_has_i64() const; - public: - void clear_i64(); - const ::substrait::Type_I64& i64() const; - PROTOBUF_NODISCARD ::substrait::Type_I64* release_i64(); - ::substrait::Type_I64* mutable_i64(); - void set_allocated_i64(::substrait::Type_I64* i64); - private: - const ::substrait::Type_I64& _internal_i64() const; - ::substrait::Type_I64* _internal_mutable_i64(); - public: - void unsafe_arena_set_allocated_i64( - ::substrait::Type_I64* i64); - ::substrait::Type_I64* unsafe_arena_release_i64(); - - // .substrait.Type.FP32 fp32 = 10; - bool has_fp32() const; - private: - bool _internal_has_fp32() const; - public: - void clear_fp32(); - const ::substrait::Type_FP32& fp32() const; - PROTOBUF_NODISCARD ::substrait::Type_FP32* release_fp32(); - ::substrait::Type_FP32* mutable_fp32(); - void set_allocated_fp32(::substrait::Type_FP32* fp32); - private: - const ::substrait::Type_FP32& _internal_fp32() const; - ::substrait::Type_FP32* _internal_mutable_fp32(); - public: - void unsafe_arena_set_allocated_fp32( - ::substrait::Type_FP32* fp32); - ::substrait::Type_FP32* unsafe_arena_release_fp32(); - - // .substrait.Type.FP64 fp64 = 11; - bool has_fp64() const; - private: - bool _internal_has_fp64() const; - public: - void clear_fp64(); - const ::substrait::Type_FP64& fp64() const; - PROTOBUF_NODISCARD ::substrait::Type_FP64* release_fp64(); - ::substrait::Type_FP64* mutable_fp64(); - void set_allocated_fp64(::substrait::Type_FP64* fp64); - private: - const ::substrait::Type_FP64& _internal_fp64() const; - ::substrait::Type_FP64* _internal_mutable_fp64(); - public: - void unsafe_arena_set_allocated_fp64( - ::substrait::Type_FP64* fp64); - ::substrait::Type_FP64* unsafe_arena_release_fp64(); - - // .substrait.Type.String string = 12; - bool has_string() const; - private: - bool _internal_has_string() const; - public: - void clear_string(); - const ::substrait::Type_String& string() const; - PROTOBUF_NODISCARD ::substrait::Type_String* release_string(); - ::substrait::Type_String* mutable_string(); - void set_allocated_string(::substrait::Type_String* string); - private: - const ::substrait::Type_String& _internal_string() const; - ::substrait::Type_String* _internal_mutable_string(); - public: - void unsafe_arena_set_allocated_string( - ::substrait::Type_String* string); - ::substrait::Type_String* unsafe_arena_release_string(); - - // .substrait.Type.Binary binary = 13; - bool has_binary() const; - private: - bool _internal_has_binary() const; - public: - void clear_binary(); - const ::substrait::Type_Binary& binary() const; - PROTOBUF_NODISCARD ::substrait::Type_Binary* release_binary(); - ::substrait::Type_Binary* mutable_binary(); - void set_allocated_binary(::substrait::Type_Binary* binary); - private: - const ::substrait::Type_Binary& _internal_binary() const; - ::substrait::Type_Binary* _internal_mutable_binary(); - public: - void unsafe_arena_set_allocated_binary( - ::substrait::Type_Binary* binary); - ::substrait::Type_Binary* unsafe_arena_release_binary(); - - // .substrait.Type.Timestamp timestamp = 14; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - const ::substrait::Type_Timestamp& timestamp() const; - PROTOBUF_NODISCARD ::substrait::Type_Timestamp* release_timestamp(); - ::substrait::Type_Timestamp* mutable_timestamp(); - void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp); - private: - const ::substrait::Type_Timestamp& _internal_timestamp() const; - ::substrait::Type_Timestamp* _internal_mutable_timestamp(); - public: - void unsafe_arena_set_allocated_timestamp( - ::substrait::Type_Timestamp* timestamp); - ::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); - - // .substrait.Type.Date date = 16; - bool has_date() const; - private: - bool _internal_has_date() const; - public: - void clear_date(); - const ::substrait::Type_Date& date() const; - PROTOBUF_NODISCARD ::substrait::Type_Date* release_date(); - ::substrait::Type_Date* mutable_date(); - void set_allocated_date(::substrait::Type_Date* date); - private: - const ::substrait::Type_Date& _internal_date() const; - ::substrait::Type_Date* _internal_mutable_date(); - public: - void unsafe_arena_set_allocated_date( - ::substrait::Type_Date* date); - ::substrait::Type_Date* unsafe_arena_release_date(); - - // .substrait.Type.Time time = 17; - bool has_time() const; - private: - bool _internal_has_time() const; - public: - void clear_time(); - const ::substrait::Type_Time& time() const; - PROTOBUF_NODISCARD ::substrait::Type_Time* release_time(); - ::substrait::Type_Time* mutable_time(); - void set_allocated_time(::substrait::Type_Time* time); - private: - const ::substrait::Type_Time& _internal_time() const; - ::substrait::Type_Time* _internal_mutable_time(); - public: - void unsafe_arena_set_allocated_time( - ::substrait::Type_Time* time); - ::substrait::Type_Time* unsafe_arena_release_time(); - - // .substrait.Type.IntervalYear interval_year = 19; - bool has_interval_year() const; - private: - bool _internal_has_interval_year() const; - public: - void clear_interval_year(); - const ::substrait::Type_IntervalYear& interval_year() const; - PROTOBUF_NODISCARD ::substrait::Type_IntervalYear* release_interval_year(); - ::substrait::Type_IntervalYear* mutable_interval_year(); - void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year); - private: - const ::substrait::Type_IntervalYear& _internal_interval_year() const; - ::substrait::Type_IntervalYear* _internal_mutable_interval_year(); - public: - void unsafe_arena_set_allocated_interval_year( - ::substrait::Type_IntervalYear* interval_year); - ::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); - - // .substrait.Type.IntervalDay interval_day = 20; - bool has_interval_day() const; - private: - bool _internal_has_interval_day() const; - public: - void clear_interval_day(); - const ::substrait::Type_IntervalDay& interval_day() const; - PROTOBUF_NODISCARD ::substrait::Type_IntervalDay* release_interval_day(); - ::substrait::Type_IntervalDay* mutable_interval_day(); - void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day); - private: - const ::substrait::Type_IntervalDay& _internal_interval_day() const; - ::substrait::Type_IntervalDay* _internal_mutable_interval_day(); - public: - void unsafe_arena_set_allocated_interval_day( - ::substrait::Type_IntervalDay* interval_day); - ::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); - - // .substrait.Type.TimestampTZ timestamp_tz = 29; - bool has_timestamp_tz() const; - private: - bool _internal_has_timestamp_tz() const; - public: - void clear_timestamp_tz(); - const ::substrait::Type_TimestampTZ& timestamp_tz() const; - PROTOBUF_NODISCARD ::substrait::Type_TimestampTZ* release_timestamp_tz(); - ::substrait::Type_TimestampTZ* mutable_timestamp_tz(); - void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz); - private: - const ::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; - ::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); - public: - void unsafe_arena_set_allocated_timestamp_tz( - ::substrait::Type_TimestampTZ* timestamp_tz); - ::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); - - // .substrait.Type.UUID uuid = 32; - bool has_uuid() const; - private: - bool _internal_has_uuid() const; - public: - void clear_uuid(); - const ::substrait::Type_UUID& uuid() const; - PROTOBUF_NODISCARD ::substrait::Type_UUID* release_uuid(); - ::substrait::Type_UUID* mutable_uuid(); - void set_allocated_uuid(::substrait::Type_UUID* uuid); - private: - const ::substrait::Type_UUID& _internal_uuid() const; - ::substrait::Type_UUID* _internal_mutable_uuid(); - public: - void unsafe_arena_set_allocated_uuid( - ::substrait::Type_UUID* uuid); - ::substrait::Type_UUID* unsafe_arena_release_uuid(); - - // .substrait.Type.FixedChar fixed_char = 21; - bool has_fixed_char() const; - private: - bool _internal_has_fixed_char() const; - public: - void clear_fixed_char(); - const ::substrait::Type_FixedChar& fixed_char() const; - PROTOBUF_NODISCARD ::substrait::Type_FixedChar* release_fixed_char(); - ::substrait::Type_FixedChar* mutable_fixed_char(); - void set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char); - private: - const ::substrait::Type_FixedChar& _internal_fixed_char() const; - ::substrait::Type_FixedChar* _internal_mutable_fixed_char(); - public: - void unsafe_arena_set_allocated_fixed_char( - ::substrait::Type_FixedChar* fixed_char); - ::substrait::Type_FixedChar* unsafe_arena_release_fixed_char(); - - // .substrait.Type.VarChar varchar = 22; - bool has_varchar() const; - private: - bool _internal_has_varchar() const; - public: - void clear_varchar(); - const ::substrait::Type_VarChar& varchar() const; - PROTOBUF_NODISCARD ::substrait::Type_VarChar* release_varchar(); - ::substrait::Type_VarChar* mutable_varchar(); - void set_allocated_varchar(::substrait::Type_VarChar* varchar); - private: - const ::substrait::Type_VarChar& _internal_varchar() const; - ::substrait::Type_VarChar* _internal_mutable_varchar(); - public: - void unsafe_arena_set_allocated_varchar( - ::substrait::Type_VarChar* varchar); - ::substrait::Type_VarChar* unsafe_arena_release_varchar(); - - // .substrait.Type.FixedBinary fixed_binary = 23; - bool has_fixed_binary() const; - private: - bool _internal_has_fixed_binary() const; - public: - void clear_fixed_binary(); - const ::substrait::Type_FixedBinary& fixed_binary() const; - PROTOBUF_NODISCARD ::substrait::Type_FixedBinary* release_fixed_binary(); - ::substrait::Type_FixedBinary* mutable_fixed_binary(); - void set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary); - private: - const ::substrait::Type_FixedBinary& _internal_fixed_binary() const; - ::substrait::Type_FixedBinary* _internal_mutable_fixed_binary(); - public: - void unsafe_arena_set_allocated_fixed_binary( - ::substrait::Type_FixedBinary* fixed_binary); - ::substrait::Type_FixedBinary* unsafe_arena_release_fixed_binary(); - - // .substrait.Type.Decimal decimal = 24; - bool has_decimal() const; - private: - bool _internal_has_decimal() const; - public: - void clear_decimal(); - const ::substrait::Type_Decimal& decimal() const; - PROTOBUF_NODISCARD ::substrait::Type_Decimal* release_decimal(); - ::substrait::Type_Decimal* mutable_decimal(); - void set_allocated_decimal(::substrait::Type_Decimal* decimal); - private: - const ::substrait::Type_Decimal& _internal_decimal() const; - ::substrait::Type_Decimal* _internal_mutable_decimal(); - public: - void unsafe_arena_set_allocated_decimal( - ::substrait::Type_Decimal* decimal); - ::substrait::Type_Decimal* unsafe_arena_release_decimal(); - - // .substrait.Type.Struct struct = 25; - bool has_struct_() const; - private: - bool _internal_has_struct_() const; - public: - void clear_struct_(); - const ::substrait::Type_Struct& struct_() const; - PROTOBUF_NODISCARD ::substrait::Type_Struct* release_struct_(); - ::substrait::Type_Struct* mutable_struct_(); - void set_allocated_struct_(::substrait::Type_Struct* struct_); - private: - const ::substrait::Type_Struct& _internal_struct_() const; - ::substrait::Type_Struct* _internal_mutable_struct_(); - public: - void unsafe_arena_set_allocated_struct_( - ::substrait::Type_Struct* struct_); - ::substrait::Type_Struct* unsafe_arena_release_struct_(); - - // .substrait.Type.List list = 27; - bool has_list() const; - private: - bool _internal_has_list() const; - public: - void clear_list(); - const ::substrait::Type_List& list() const; - PROTOBUF_NODISCARD ::substrait::Type_List* release_list(); - ::substrait::Type_List* mutable_list(); - void set_allocated_list(::substrait::Type_List* list); - private: - const ::substrait::Type_List& _internal_list() const; - ::substrait::Type_List* _internal_mutable_list(); - public: - void unsafe_arena_set_allocated_list( - ::substrait::Type_List* list); - ::substrait::Type_List* unsafe_arena_release_list(); - - // .substrait.Type.Map map = 28; - bool has_map() const; - private: - bool _internal_has_map() const; - public: - void clear_map(); - const ::substrait::Type_Map& map() const; - PROTOBUF_NODISCARD ::substrait::Type_Map* release_map(); - ::substrait::Type_Map* mutable_map(); - void set_allocated_map(::substrait::Type_Map* map); - private: - const ::substrait::Type_Map& _internal_map() const; - ::substrait::Type_Map* _internal_mutable_map(); - public: - void unsafe_arena_set_allocated_map( - ::substrait::Type_Map* map); - ::substrait::Type_Map* unsafe_arena_release_map(); - - // uint32 user_defined_type_reference = 31; - bool has_user_defined_type_reference() const; - private: - bool _internal_has_user_defined_type_reference() const; - public: - void clear_user_defined_type_reference(); - uint32_t user_defined_type_reference() const; - void set_user_defined_type_reference(uint32_t value); - private: - uint32_t _internal_user_defined_type_reference() const; - void _internal_set_user_defined_type_reference(uint32_t value); - public: - - void clear_kind(); - KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:substrait.Type) - private: - class _Internal; - void set_has_bool_(); - void set_has_i8(); - void set_has_i16(); - void set_has_i32(); - void set_has_i64(); - void set_has_fp32(); - void set_has_fp64(); - void set_has_string(); - void set_has_binary(); - void set_has_timestamp(); - void set_has_date(); - void set_has_time(); - void set_has_interval_year(); - void set_has_interval_day(); - void set_has_timestamp_tz(); - void set_has_uuid(); - void set_has_fixed_char(); - void set_has_varchar(); - void set_has_fixed_binary(); - void set_has_decimal(); - void set_has_struct_(); - void set_has_list(); - void set_has_map(); - void set_has_user_defined_type_reference(); - - inline bool has_kind() const; - inline void clear_has_kind(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union KindUnion { - constexpr KindUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Type_Boolean* bool__; - ::substrait::Type_I8* i8_; - ::substrait::Type_I16* i16_; - ::substrait::Type_I32* i32_; - ::substrait::Type_I64* i64_; - ::substrait::Type_FP32* fp32_; - ::substrait::Type_FP64* fp64_; - ::substrait::Type_String* string_; - ::substrait::Type_Binary* binary_; - ::substrait::Type_Timestamp* timestamp_; - ::substrait::Type_Date* date_; - ::substrait::Type_Time* time_; - ::substrait::Type_IntervalYear* interval_year_; - ::substrait::Type_IntervalDay* interval_day_; - ::substrait::Type_TimestampTZ* timestamp_tz_; - ::substrait::Type_UUID* uuid_; - ::substrait::Type_FixedChar* fixed_char_; - ::substrait::Type_VarChar* varchar_; - ::substrait::Type_FixedBinary* fixed_binary_; - ::substrait::Type_Decimal* decimal_; - ::substrait::Type_Struct* struct__; - ::substrait::Type_List* list_; - ::substrait::Type_Map* map_; - uint32_t user_defined_type_reference_; - } kind_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// ------------------------------------------------------------------- - -class NamedStruct final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.NamedStruct) */ { - public: - inline NamedStruct() : NamedStruct(nullptr) {} - ~NamedStruct() override; - explicit constexpr NamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - NamedStruct(const NamedStruct& from); - NamedStruct(NamedStruct&& from) noexcept - : NamedStruct() { - *this = ::std::move(from); - } - - inline NamedStruct& operator=(const NamedStruct& from) { - CopyFrom(from); - return *this; - } - inline NamedStruct& operator=(NamedStruct&& 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 NamedStruct& default_instance() { - return *internal_default_instance(); - } - static inline const NamedStruct* internal_default_instance() { - return reinterpret_cast( - &_NamedStruct_default_instance_); - } - static constexpr int kIndexInFileMessages = - 24; - - friend void swap(NamedStruct& a, NamedStruct& b) { - a.Swap(&b); - } - inline void Swap(NamedStruct* 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(NamedStruct* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - NamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const NamedStruct& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const NamedStruct& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(NamedStruct* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.NamedStruct"; - } - protected: - explicit NamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kNamesFieldNumber = 1, - kStructFieldNumber = 2, - }; - // repeated string names = 1; - int names_size() const; - private: - int _internal_names_size() const; - public: - void clear_names(); - const std::string& names(int index) const; - std::string* mutable_names(int index); - void set_names(int index, const std::string& value); - void set_names(int index, std::string&& value); - void set_names(int index, const char* value); - void set_names(int index, const char* value, size_t size); - std::string* add_names(); - void add_names(const std::string& value); - void add_names(std::string&& value); - void add_names(const char* value); - void add_names(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); - private: - const std::string& _internal_names(int index) const; - std::string* _internal_add_names(); - public: - - // .substrait.Type.Struct struct = 2; - bool has_struct_() const; - private: - bool _internal_has_struct_() const; - public: - void clear_struct_(); - const ::substrait::Type_Struct& struct_() const; - PROTOBUF_NODISCARD ::substrait::Type_Struct* release_struct_(); - ::substrait::Type_Struct* mutable_struct_(); - void set_allocated_struct_(::substrait::Type_Struct* struct_); - private: - const ::substrait::Type_Struct& _internal_struct_() const; - ::substrait::Type_Struct* _internal_mutable_struct_(); - public: - void unsafe_arena_set_allocated_struct_( - ::substrait::Type_Struct* struct_); - ::substrait::Type_Struct* unsafe_arena_release_struct_(); - - // @@protoc_insertion_point(class_scope:substrait.NamedStruct) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::substrait::Type_Struct* struct__; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// Type_Boolean - -// uint32 type_variation_reference = 1; -inline void Type_Boolean::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_Boolean::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_Boolean::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.Boolean.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_Boolean::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_Boolean::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.Boolean.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_Boolean::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_Boolean::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_Boolean::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.Boolean.nullability) - return _internal_nullability(); -} -inline void Type_Boolean::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_Boolean::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.Boolean.nullability) -} - -// ------------------------------------------------------------------- - -// Type_I8 - -// uint32 type_variation_reference = 1; -inline void Type_I8::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_I8::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_I8::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.I8.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_I8::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_I8::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.I8.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_I8::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_I8::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_I8::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.I8.nullability) - return _internal_nullability(); -} -inline void Type_I8::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_I8::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.I8.nullability) -} - -// ------------------------------------------------------------------- - -// Type_I16 - -// uint32 type_variation_reference = 1; -inline void Type_I16::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_I16::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_I16::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.I16.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_I16::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_I16::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.I16.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_I16::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_I16::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_I16::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.I16.nullability) - return _internal_nullability(); -} -inline void Type_I16::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_I16::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.I16.nullability) -} - -// ------------------------------------------------------------------- - -// Type_I32 - -// uint32 type_variation_reference = 1; -inline void Type_I32::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_I32::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_I32::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.I32.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_I32::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_I32::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.I32.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_I32::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_I32::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_I32::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.I32.nullability) - return _internal_nullability(); -} -inline void Type_I32::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_I32::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.I32.nullability) -} - -// ------------------------------------------------------------------- - -// Type_I64 - -// uint32 type_variation_reference = 1; -inline void Type_I64::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_I64::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_I64::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.I64.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_I64::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_I64::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.I64.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_I64::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_I64::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_I64::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.I64.nullability) - return _internal_nullability(); -} -inline void Type_I64::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_I64::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.I64.nullability) -} - -// ------------------------------------------------------------------- - -// Type_FP32 - -// uint32 type_variation_reference = 1; -inline void Type_FP32::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_FP32::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_FP32::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.FP32.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_FP32::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_FP32::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.FP32.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_FP32::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_FP32::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_FP32::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.FP32.nullability) - return _internal_nullability(); -} -inline void Type_FP32::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_FP32::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.FP32.nullability) -} - -// ------------------------------------------------------------------- - -// Type_FP64 - -// uint32 type_variation_reference = 1; -inline void Type_FP64::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_FP64::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_FP64::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.FP64.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_FP64::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_FP64::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.FP64.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_FP64::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_FP64::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_FP64::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.FP64.nullability) - return _internal_nullability(); -} -inline void Type_FP64::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_FP64::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.FP64.nullability) -} - -// ------------------------------------------------------------------- - -// Type_String - -// uint32 type_variation_reference = 1; -inline void Type_String::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_String::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_String::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.String.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_String::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_String::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.String.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_String::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_String::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_String::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.String.nullability) - return _internal_nullability(); -} -inline void Type_String::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_String::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.String.nullability) -} - -// ------------------------------------------------------------------- - -// Type_Binary - -// uint32 type_variation_reference = 1; -inline void Type_Binary::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_Binary::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_Binary::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.Binary.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_Binary::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_Binary::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.Binary.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_Binary::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_Binary::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_Binary::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.Binary.nullability) - return _internal_nullability(); -} -inline void Type_Binary::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_Binary::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.Binary.nullability) -} - -// ------------------------------------------------------------------- - -// Type_Timestamp - -// uint32 type_variation_reference = 1; -inline void Type_Timestamp::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_Timestamp::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_Timestamp::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.Timestamp.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_Timestamp::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_Timestamp::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.Timestamp.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_Timestamp::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_Timestamp::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_Timestamp::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.Timestamp.nullability) - return _internal_nullability(); -} -inline void Type_Timestamp::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_Timestamp::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.Timestamp.nullability) -} - -// ------------------------------------------------------------------- - -// Type_Date - -// uint32 type_variation_reference = 1; -inline void Type_Date::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_Date::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_Date::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.Date.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_Date::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_Date::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.Date.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_Date::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_Date::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_Date::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.Date.nullability) - return _internal_nullability(); -} -inline void Type_Date::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_Date::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.Date.nullability) -} - -// ------------------------------------------------------------------- - -// Type_Time - -// uint32 type_variation_reference = 1; -inline void Type_Time::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_Time::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_Time::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.Time.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_Time::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_Time::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.Time.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_Time::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_Time::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_Time::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.Time.nullability) - return _internal_nullability(); -} -inline void Type_Time::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_Time::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.Time.nullability) -} - -// ------------------------------------------------------------------- - -// Type_TimestampTZ - -// uint32 type_variation_reference = 1; -inline void Type_TimestampTZ::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_TimestampTZ::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_TimestampTZ::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.TimestampTZ.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_TimestampTZ::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_TimestampTZ::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.TimestampTZ.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_TimestampTZ::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_TimestampTZ::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_TimestampTZ::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.TimestampTZ.nullability) - return _internal_nullability(); -} -inline void Type_TimestampTZ::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_TimestampTZ::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.TimestampTZ.nullability) -} - -// ------------------------------------------------------------------- - -// Type_IntervalYear - -// uint32 type_variation_reference = 1; -inline void Type_IntervalYear::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_IntervalYear::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_IntervalYear::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.IntervalYear.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_IntervalYear::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_IntervalYear::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.IntervalYear.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_IntervalYear::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_IntervalYear::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_IntervalYear::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.IntervalYear.nullability) - return _internal_nullability(); -} -inline void Type_IntervalYear::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_IntervalYear::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.IntervalYear.nullability) -} - -// ------------------------------------------------------------------- - -// Type_IntervalDay - -// uint32 type_variation_reference = 1; -inline void Type_IntervalDay::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_IntervalDay::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_IntervalDay::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.IntervalDay.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_IntervalDay::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_IntervalDay::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.IntervalDay.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_IntervalDay::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_IntervalDay::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_IntervalDay::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.IntervalDay.nullability) - return _internal_nullability(); -} -inline void Type_IntervalDay::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_IntervalDay::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.IntervalDay.nullability) -} - -// ------------------------------------------------------------------- - -// Type_UUID - -// uint32 type_variation_reference = 1; -inline void Type_UUID::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_UUID::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_UUID::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.UUID.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_UUID::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_UUID::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.UUID.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 2; -inline void Type_UUID::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_UUID::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_UUID::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.UUID.nullability) - return _internal_nullability(); -} -inline void Type_UUID::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_UUID::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.UUID.nullability) -} - -// ------------------------------------------------------------------- - -// Type_FixedChar - -// int32 length = 1; -inline void Type_FixedChar::clear_length() { - length_ = 0; -} -inline int32_t Type_FixedChar::_internal_length() const { - return length_; -} -inline int32_t Type_FixedChar::length() const { - // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.length) - return _internal_length(); -} -inline void Type_FixedChar::_internal_set_length(int32_t value) { - - length_ = value; -} -inline void Type_FixedChar::set_length(int32_t value) { - _internal_set_length(value); - // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.length) -} - -// uint32 type_variation_reference = 2; -inline void Type_FixedChar::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_FixedChar::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_FixedChar::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_FixedChar::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_FixedChar::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 3; -inline void Type_FixedChar::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_FixedChar::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_FixedChar::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.FixedChar.nullability) - return _internal_nullability(); -} -inline void Type_FixedChar::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_FixedChar::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.FixedChar.nullability) -} - -// ------------------------------------------------------------------- - -// Type_VarChar - -// int32 length = 1; -inline void Type_VarChar::clear_length() { - length_ = 0; -} -inline int32_t Type_VarChar::_internal_length() const { - return length_; -} -inline int32_t Type_VarChar::length() const { - // @@protoc_insertion_point(field_get:substrait.Type.VarChar.length) - return _internal_length(); -} -inline void Type_VarChar::_internal_set_length(int32_t value) { - - length_ = value; -} -inline void Type_VarChar::set_length(int32_t value) { - _internal_set_length(value); - // @@protoc_insertion_point(field_set:substrait.Type.VarChar.length) -} - -// uint32 type_variation_reference = 2; -inline void Type_VarChar::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_VarChar::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_VarChar::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.VarChar.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_VarChar::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_VarChar::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.VarChar.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 3; -inline void Type_VarChar::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_VarChar::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_VarChar::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.VarChar.nullability) - return _internal_nullability(); -} -inline void Type_VarChar::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_VarChar::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.VarChar.nullability) -} - -// ------------------------------------------------------------------- - -// Type_FixedBinary - -// int32 length = 1; -inline void Type_FixedBinary::clear_length() { - length_ = 0; -} -inline int32_t Type_FixedBinary::_internal_length() const { - return length_; -} -inline int32_t Type_FixedBinary::length() const { - // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.length) - return _internal_length(); -} -inline void Type_FixedBinary::_internal_set_length(int32_t value) { - - length_ = value; -} -inline void Type_FixedBinary::set_length(int32_t value) { - _internal_set_length(value); - // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.length) -} - -// uint32 type_variation_reference = 2; -inline void Type_FixedBinary::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_FixedBinary::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_FixedBinary::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_FixedBinary::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_FixedBinary::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 3; -inline void Type_FixedBinary::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_FixedBinary::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_FixedBinary::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.FixedBinary.nullability) - return _internal_nullability(); -} -inline void Type_FixedBinary::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_FixedBinary::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.FixedBinary.nullability) -} - -// ------------------------------------------------------------------- - -// Type_Decimal - -// int32 scale = 1; -inline void Type_Decimal::clear_scale() { - scale_ = 0; -} -inline int32_t Type_Decimal::_internal_scale() const { - return scale_; -} -inline int32_t Type_Decimal::scale() const { - // @@protoc_insertion_point(field_get:substrait.Type.Decimal.scale) - return _internal_scale(); -} -inline void Type_Decimal::_internal_set_scale(int32_t value) { - - scale_ = value; -} -inline void Type_Decimal::set_scale(int32_t value) { - _internal_set_scale(value); - // @@protoc_insertion_point(field_set:substrait.Type.Decimal.scale) -} - -// int32 precision = 2; -inline void Type_Decimal::clear_precision() { - precision_ = 0; -} -inline int32_t Type_Decimal::_internal_precision() const { - return precision_; -} -inline int32_t Type_Decimal::precision() const { - // @@protoc_insertion_point(field_get:substrait.Type.Decimal.precision) - return _internal_precision(); -} -inline void Type_Decimal::_internal_set_precision(int32_t value) { - - precision_ = value; -} -inline void Type_Decimal::set_precision(int32_t value) { - _internal_set_precision(value); - // @@protoc_insertion_point(field_set:substrait.Type.Decimal.precision) -} - -// uint32 type_variation_reference = 3; -inline void Type_Decimal::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_Decimal::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_Decimal::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.Decimal.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_Decimal::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_Decimal::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.Decimal.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 4; -inline void Type_Decimal::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_Decimal::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_Decimal::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.Decimal.nullability) - return _internal_nullability(); -} -inline void Type_Decimal::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_Decimal::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.Decimal.nullability) -} - -// ------------------------------------------------------------------- - -// Type_Struct - -// repeated .substrait.Type types = 1; -inline int Type_Struct::_internal_types_size() const { - return types_.size(); -} -inline int Type_Struct::types_size() const { - return _internal_types_size(); -} -inline void Type_Struct::clear_types() { - types_.Clear(); -} -inline ::substrait::Type* Type_Struct::mutable_types(int index) { - // @@protoc_insertion_point(field_mutable:substrait.Type.Struct.types) - return types_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >* -Type_Struct::mutable_types() { - // @@protoc_insertion_point(field_mutable_list:substrait.Type.Struct.types) - return &types_; -} -inline const ::substrait::Type& Type_Struct::_internal_types(int index) const { - return types_.Get(index); -} -inline const ::substrait::Type& Type_Struct::types(int index) const { - // @@protoc_insertion_point(field_get:substrait.Type.Struct.types) - return _internal_types(index); -} -inline ::substrait::Type* Type_Struct::_internal_add_types() { - return types_.Add(); -} -inline ::substrait::Type* Type_Struct::add_types() { - ::substrait::Type* _add = _internal_add_types(); - // @@protoc_insertion_point(field_add:substrait.Type.Struct.types) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::Type >& -Type_Struct::types() const { - // @@protoc_insertion_point(field_list:substrait.Type.Struct.types) - return types_; -} - -// uint32 type_variation_reference = 2; -inline void Type_Struct::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_Struct::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_Struct::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.Struct.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_Struct::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_Struct::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.Struct.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 3; -inline void Type_Struct::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_Struct::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_Struct::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.Struct.nullability) - return _internal_nullability(); -} -inline void Type_Struct::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_Struct::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.Struct.nullability) -} - -// ------------------------------------------------------------------- - -// Type_List - -// .substrait.Type type = 1; -inline bool Type_List::_internal_has_type() const { - return this != internal_default_instance() && type_ != nullptr; -} -inline bool Type_List::has_type() const { - return _internal_has_type(); -} -inline void Type_List::clear_type() { - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; -} -inline const ::substrait::Type& Type_List::_internal_type() const { - const ::substrait::Type* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Type_default_instance_); -} -inline const ::substrait::Type& Type_List::type() const { - // @@protoc_insertion_point(field_get:substrait.Type.List.type) - return _internal_type(); -} -inline void Type_List::unsafe_arena_set_allocated_type( - ::substrait::Type* type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); - } - type_ = type; - if (type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.List.type) -} -inline ::substrait::Type* Type_List::release_type() { - - ::substrait::Type* temp = type_; - type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Type* Type_List::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:substrait.Type.List.type) - - ::substrait::Type* temp = type_; - type_ = nullptr; - return temp; -} -inline ::substrait::Type* Type_List::_internal_mutable_type() { - - if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); - type_ = p; - } - return type_; -} -inline ::substrait::Type* Type_List::mutable_type() { - ::substrait::Type* _msg = _internal_mutable_type(); - // @@protoc_insertion_point(field_mutable:substrait.Type.List.type) - return _msg; -} -inline void Type_List::set_allocated_type(::substrait::Type* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete type_; - } - if (type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type>::GetOwningArena(type); - if (message_arena != submessage_arena) { - type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type, submessage_arena); - } - - } else { - - } - type_ = type; - // @@protoc_insertion_point(field_set_allocated:substrait.Type.List.type) -} - -// uint32 type_variation_reference = 2; -inline void Type_List::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_List::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_List::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.List.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_List::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_List::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.List.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 3; -inline void Type_List::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_List::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_List::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.List.nullability) - return _internal_nullability(); -} -inline void Type_List::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_List::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.List.nullability) -} - -// ------------------------------------------------------------------- - -// Type_Map - -// .substrait.Type key = 1; -inline bool Type_Map::_internal_has_key() const { - return this != internal_default_instance() && key_ != nullptr; -} -inline bool Type_Map::has_key() const { - return _internal_has_key(); -} -inline void Type_Map::clear_key() { - if (GetArenaForAllocation() == nullptr && key_ != nullptr) { - delete key_; - } - key_ = nullptr; -} -inline const ::substrait::Type& Type_Map::_internal_key() const { - const ::substrait::Type* p = key_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Type_default_instance_); -} -inline const ::substrait::Type& Type_Map::key() const { - // @@protoc_insertion_point(field_get:substrait.Type.Map.key) - return _internal_key(); -} -inline void Type_Map::unsafe_arena_set_allocated_key( - ::substrait::Type* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); - } - key_ = key; - if (key) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.Map.key) -} -inline ::substrait::Type* Type_Map::release_key() { - - ::substrait::Type* temp = key_; - key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Type* Type_Map::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:substrait.Type.Map.key) - - ::substrait::Type* temp = key_; - key_ = nullptr; - return temp; -} -inline ::substrait::Type* Type_Map::_internal_mutable_key() { - - if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); - key_ = p; - } - return key_; -} -inline ::substrait::Type* Type_Map::mutable_key() { - ::substrait::Type* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:substrait.Type.Map.key) - return _msg; -} -inline void Type_Map::set_allocated_key(::substrait::Type* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type>::GetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - - } else { - - } - key_ = key; - // @@protoc_insertion_point(field_set_allocated:substrait.Type.Map.key) -} - -// .substrait.Type value = 2; -inline bool Type_Map::_internal_has_value() const { - return this != internal_default_instance() && value_ != nullptr; -} -inline bool Type_Map::has_value() const { - return _internal_has_value(); -} -inline void Type_Map::clear_value() { - if (GetArenaForAllocation() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; -} -inline const ::substrait::Type& Type_Map::_internal_value() const { - const ::substrait::Type* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Type_default_instance_); -} -inline const ::substrait::Type& Type_Map::value() const { - // @@protoc_insertion_point(field_get:substrait.Type.Map.value) - return _internal_value(); -} -inline void Type_Map::unsafe_arena_set_allocated_value( - ::substrait::Type* value) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); - } - value_ = value; - if (value) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.Map.value) -} -inline ::substrait::Type* Type_Map::release_value() { - - ::substrait::Type* temp = value_; - value_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Type* Type_Map::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:substrait.Type.Map.value) - - ::substrait::Type* temp = value_; - value_ = nullptr; - return temp; -} -inline ::substrait::Type* Type_Map::_internal_mutable_value() { - - if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type>(GetArenaForAllocation()); - value_ = p; - } - return value_; -} -inline ::substrait::Type* Type_Map::mutable_value() { - ::substrait::Type* _msg = _internal_mutable_value(); - // @@protoc_insertion_point(field_mutable:substrait.Type.Map.value) - return _msg; -} -inline void Type_Map::set_allocated_value(::substrait::Type* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete value_; - } - if (value) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type>::GetOwningArena(value); - if (message_arena != submessage_arena) { - value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value, submessage_arena); - } - - } else { - - } - value_ = value; - // @@protoc_insertion_point(field_set_allocated:substrait.Type.Map.value) -} - -// uint32 type_variation_reference = 3; -inline void Type_Map::clear_type_variation_reference() { - type_variation_reference_ = 0u; -} -inline uint32_t Type_Map::_internal_type_variation_reference() const { - return type_variation_reference_; -} -inline uint32_t Type_Map::type_variation_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.Map.type_variation_reference) - return _internal_type_variation_reference(); -} -inline void Type_Map::_internal_set_type_variation_reference(uint32_t value) { - - type_variation_reference_ = value; -} -inline void Type_Map::set_type_variation_reference(uint32_t value) { - _internal_set_type_variation_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.Map.type_variation_reference) -} - -// .substrait.Type.Nullability nullability = 4; -inline void Type_Map::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability Type_Map::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability Type_Map::nullability() const { - // @@protoc_insertion_point(field_get:substrait.Type.Map.nullability) - return _internal_nullability(); -} -inline void Type_Map::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void Type_Map::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.Type.Map.nullability) -} - -// ------------------------------------------------------------------- - -// Type - -// .substrait.Type.Boolean bool = 1; -inline bool Type::_internal_has_bool_() const { - return kind_case() == kBool; -} -inline bool Type::has_bool_() const { - return _internal_has_bool_(); -} -inline void Type::set_has_bool_() { - _oneof_case_[0] = kBool; -} -inline void Type::clear_bool_() { - if (_internal_has_bool_()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.bool__; - } - clear_has_kind(); - } -} -inline ::substrait::Type_Boolean* Type::release_bool_() { - // @@protoc_insertion_point(field_release:substrait.Type.bool) - if (_internal_has_bool_()) { - clear_has_kind(); - ::substrait::Type_Boolean* temp = kind_.bool__; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.bool__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Boolean& Type::_internal_bool_() const { - return _internal_has_bool_() - ? *kind_.bool__ - : reinterpret_cast< ::substrait::Type_Boolean&>(::substrait::_Type_Boolean_default_instance_); -} -inline const ::substrait::Type_Boolean& Type::bool_() const { - // @@protoc_insertion_point(field_get:substrait.Type.bool) - return _internal_bool_(); -} -inline ::substrait::Type_Boolean* Type::unsafe_arena_release_bool_() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.bool) - if (_internal_has_bool_()) { - clear_has_kind(); - ::substrait::Type_Boolean* temp = kind_.bool__; - kind_.bool__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_bool_(::substrait::Type_Boolean* bool_) { - clear_kind(); - if (bool_) { - set_has_bool_(); - kind_.bool__ = bool_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.bool) -} -inline ::substrait::Type_Boolean* Type::_internal_mutable_bool_() { - if (!_internal_has_bool_()) { - clear_kind(); - set_has_bool_(); - kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArenaForAllocation()); - } - return kind_.bool__; -} -inline ::substrait::Type_Boolean* Type::mutable_bool_() { - ::substrait::Type_Boolean* _msg = _internal_mutable_bool_(); - // @@protoc_insertion_point(field_mutable:substrait.Type.bool) - return _msg; -} - -// .substrait.Type.I8 i8 = 2; -inline bool Type::_internal_has_i8() const { - return kind_case() == kI8; -} -inline bool Type::has_i8() const { - return _internal_has_i8(); -} -inline void Type::set_has_i8() { - _oneof_case_[0] = kI8; -} -inline void Type::clear_i8() { - if (_internal_has_i8()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i8_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_I8* Type::release_i8() { - // @@protoc_insertion_point(field_release:substrait.Type.i8) - if (_internal_has_i8()) { - clear_has_kind(); - ::substrait::Type_I8* temp = kind_.i8_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i8_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I8& Type::_internal_i8() const { - return _internal_has_i8() - ? *kind_.i8_ - : reinterpret_cast< ::substrait::Type_I8&>(::substrait::_Type_I8_default_instance_); -} -inline const ::substrait::Type_I8& Type::i8() const { - // @@protoc_insertion_point(field_get:substrait.Type.i8) - return _internal_i8(); -} -inline ::substrait::Type_I8* Type::unsafe_arena_release_i8() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i8) - if (_internal_has_i8()) { - clear_has_kind(); - ::substrait::Type_I8* temp = kind_.i8_; - kind_.i8_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_i8(::substrait::Type_I8* i8) { - clear_kind(); - if (i8) { - set_has_i8(); - kind_.i8_ = i8; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i8) -} -inline ::substrait::Type_I8* Type::_internal_mutable_i8() { - if (!_internal_has_i8()) { - clear_kind(); - set_has_i8(); - kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArenaForAllocation()); - } - return kind_.i8_; -} -inline ::substrait::Type_I8* Type::mutable_i8() { - ::substrait::Type_I8* _msg = _internal_mutable_i8(); - // @@protoc_insertion_point(field_mutable:substrait.Type.i8) - return _msg; -} - -// .substrait.Type.I16 i16 = 3; -inline bool Type::_internal_has_i16() const { - return kind_case() == kI16; -} -inline bool Type::has_i16() const { - return _internal_has_i16(); -} -inline void Type::set_has_i16() { - _oneof_case_[0] = kI16; -} -inline void Type::clear_i16() { - if (_internal_has_i16()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i16_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_I16* Type::release_i16() { - // @@protoc_insertion_point(field_release:substrait.Type.i16) - if (_internal_has_i16()) { - clear_has_kind(); - ::substrait::Type_I16* temp = kind_.i16_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i16_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I16& Type::_internal_i16() const { - return _internal_has_i16() - ? *kind_.i16_ - : reinterpret_cast< ::substrait::Type_I16&>(::substrait::_Type_I16_default_instance_); -} -inline const ::substrait::Type_I16& Type::i16() const { - // @@protoc_insertion_point(field_get:substrait.Type.i16) - return _internal_i16(); -} -inline ::substrait::Type_I16* Type::unsafe_arena_release_i16() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i16) - if (_internal_has_i16()) { - clear_has_kind(); - ::substrait::Type_I16* temp = kind_.i16_; - kind_.i16_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_i16(::substrait::Type_I16* i16) { - clear_kind(); - if (i16) { - set_has_i16(); - kind_.i16_ = i16; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i16) -} -inline ::substrait::Type_I16* Type::_internal_mutable_i16() { - if (!_internal_has_i16()) { - clear_kind(); - set_has_i16(); - kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArenaForAllocation()); - } - return kind_.i16_; -} -inline ::substrait::Type_I16* Type::mutable_i16() { - ::substrait::Type_I16* _msg = _internal_mutable_i16(); - // @@protoc_insertion_point(field_mutable:substrait.Type.i16) - return _msg; -} - -// .substrait.Type.I32 i32 = 5; -inline bool Type::_internal_has_i32() const { - return kind_case() == kI32; -} -inline bool Type::has_i32() const { - return _internal_has_i32(); -} -inline void Type::set_has_i32() { - _oneof_case_[0] = kI32; -} -inline void Type::clear_i32() { - if (_internal_has_i32()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i32_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_I32* Type::release_i32() { - // @@protoc_insertion_point(field_release:substrait.Type.i32) - if (_internal_has_i32()) { - clear_has_kind(); - ::substrait::Type_I32* temp = kind_.i32_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I32& Type::_internal_i32() const { - return _internal_has_i32() - ? *kind_.i32_ - : reinterpret_cast< ::substrait::Type_I32&>(::substrait::_Type_I32_default_instance_); -} -inline const ::substrait::Type_I32& Type::i32() const { - // @@protoc_insertion_point(field_get:substrait.Type.i32) - return _internal_i32(); -} -inline ::substrait::Type_I32* Type::unsafe_arena_release_i32() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i32) - if (_internal_has_i32()) { - clear_has_kind(); - ::substrait::Type_I32* temp = kind_.i32_; - kind_.i32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_i32(::substrait::Type_I32* i32) { - clear_kind(); - if (i32) { - set_has_i32(); - kind_.i32_ = i32; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i32) -} -inline ::substrait::Type_I32* Type::_internal_mutable_i32() { - if (!_internal_has_i32()) { - clear_kind(); - set_has_i32(); - kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArenaForAllocation()); - } - return kind_.i32_; -} -inline ::substrait::Type_I32* Type::mutable_i32() { - ::substrait::Type_I32* _msg = _internal_mutable_i32(); - // @@protoc_insertion_point(field_mutable:substrait.Type.i32) - return _msg; -} - -// .substrait.Type.I64 i64 = 7; -inline bool Type::_internal_has_i64() const { - return kind_case() == kI64; -} -inline bool Type::has_i64() const { - return _internal_has_i64(); -} -inline void Type::set_has_i64() { - _oneof_case_[0] = kI64; -} -inline void Type::clear_i64() { - if (_internal_has_i64()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i64_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_I64* Type::release_i64() { - // @@protoc_insertion_point(field_release:substrait.Type.i64) - if (_internal_has_i64()) { - clear_has_kind(); - ::substrait::Type_I64* temp = kind_.i64_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I64& Type::_internal_i64() const { - return _internal_has_i64() - ? *kind_.i64_ - : reinterpret_cast< ::substrait::Type_I64&>(::substrait::_Type_I64_default_instance_); -} -inline const ::substrait::Type_I64& Type::i64() const { - // @@protoc_insertion_point(field_get:substrait.Type.i64) - return _internal_i64(); -} -inline ::substrait::Type_I64* Type::unsafe_arena_release_i64() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.i64) - if (_internal_has_i64()) { - clear_has_kind(); - ::substrait::Type_I64* temp = kind_.i64_; - kind_.i64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_i64(::substrait::Type_I64* i64) { - clear_kind(); - if (i64) { - set_has_i64(); - kind_.i64_ = i64; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.i64) -} -inline ::substrait::Type_I64* Type::_internal_mutable_i64() { - if (!_internal_has_i64()) { - clear_kind(); - set_has_i64(); - kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArenaForAllocation()); - } - return kind_.i64_; -} -inline ::substrait::Type_I64* Type::mutable_i64() { - ::substrait::Type_I64* _msg = _internal_mutable_i64(); - // @@protoc_insertion_point(field_mutable:substrait.Type.i64) - return _msg; -} - -// .substrait.Type.FP32 fp32 = 10; -inline bool Type::_internal_has_fp32() const { - return kind_case() == kFp32; -} -inline bool Type::has_fp32() const { - return _internal_has_fp32(); -} -inline void Type::set_has_fp32() { - _oneof_case_[0] = kFp32; -} -inline void Type::clear_fp32() { - if (_internal_has_fp32()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp32_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_FP32* Type::release_fp32() { - // @@protoc_insertion_point(field_release:substrait.Type.fp32) - if (_internal_has_fp32()) { - clear_has_kind(); - ::substrait::Type_FP32* temp = kind_.fp32_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fp32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_FP32& Type::_internal_fp32() const { - return _internal_has_fp32() - ? *kind_.fp32_ - : reinterpret_cast< ::substrait::Type_FP32&>(::substrait::_Type_FP32_default_instance_); -} -inline const ::substrait::Type_FP32& Type::fp32() const { - // @@protoc_insertion_point(field_get:substrait.Type.fp32) - return _internal_fp32(); -} -inline ::substrait::Type_FP32* Type::unsafe_arena_release_fp32() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fp32) - if (_internal_has_fp32()) { - clear_has_kind(); - ::substrait::Type_FP32* temp = kind_.fp32_; - kind_.fp32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_fp32(::substrait::Type_FP32* fp32) { - clear_kind(); - if (fp32) { - set_has_fp32(); - kind_.fp32_ = fp32; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fp32) -} -inline ::substrait::Type_FP32* Type::_internal_mutable_fp32() { - if (!_internal_has_fp32()) { - clear_kind(); - set_has_fp32(); - kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArenaForAllocation()); - } - return kind_.fp32_; -} -inline ::substrait::Type_FP32* Type::mutable_fp32() { - ::substrait::Type_FP32* _msg = _internal_mutable_fp32(); - // @@protoc_insertion_point(field_mutable:substrait.Type.fp32) - return _msg; -} - -// .substrait.Type.FP64 fp64 = 11; -inline bool Type::_internal_has_fp64() const { - return kind_case() == kFp64; -} -inline bool Type::has_fp64() const { - return _internal_has_fp64(); -} -inline void Type::set_has_fp64() { - _oneof_case_[0] = kFp64; -} -inline void Type::clear_fp64() { - if (_internal_has_fp64()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp64_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_FP64* Type::release_fp64() { - // @@protoc_insertion_point(field_release:substrait.Type.fp64) - if (_internal_has_fp64()) { - clear_has_kind(); - ::substrait::Type_FP64* temp = kind_.fp64_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fp64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_FP64& Type::_internal_fp64() const { - return _internal_has_fp64() - ? *kind_.fp64_ - : reinterpret_cast< ::substrait::Type_FP64&>(::substrait::_Type_FP64_default_instance_); -} -inline const ::substrait::Type_FP64& Type::fp64() const { - // @@protoc_insertion_point(field_get:substrait.Type.fp64) - return _internal_fp64(); -} -inline ::substrait::Type_FP64* Type::unsafe_arena_release_fp64() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fp64) - if (_internal_has_fp64()) { - clear_has_kind(); - ::substrait::Type_FP64* temp = kind_.fp64_; - kind_.fp64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_fp64(::substrait::Type_FP64* fp64) { - clear_kind(); - if (fp64) { - set_has_fp64(); - kind_.fp64_ = fp64; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fp64) -} -inline ::substrait::Type_FP64* Type::_internal_mutable_fp64() { - if (!_internal_has_fp64()) { - clear_kind(); - set_has_fp64(); - kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArenaForAllocation()); - } - return kind_.fp64_; -} -inline ::substrait::Type_FP64* Type::mutable_fp64() { - ::substrait::Type_FP64* _msg = _internal_mutable_fp64(); - // @@protoc_insertion_point(field_mutable:substrait.Type.fp64) - return _msg; -} - -// .substrait.Type.String string = 12; -inline bool Type::_internal_has_string() const { - return kind_case() == kString; -} -inline bool Type::has_string() const { - return _internal_has_string(); -} -inline void Type::set_has_string() { - _oneof_case_[0] = kString; -} -inline void Type::clear_string() { - if (_internal_has_string()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.string_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_String* Type::release_string() { - // @@protoc_insertion_point(field_release:substrait.Type.string) - if (_internal_has_string()) { - clear_has_kind(); - ::substrait::Type_String* temp = kind_.string_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.string_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_String& Type::_internal_string() const { - return _internal_has_string() - ? *kind_.string_ - : reinterpret_cast< ::substrait::Type_String&>(::substrait::_Type_String_default_instance_); -} -inline const ::substrait::Type_String& Type::string() const { - // @@protoc_insertion_point(field_get:substrait.Type.string) - return _internal_string(); -} -inline ::substrait::Type_String* Type::unsafe_arena_release_string() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.string) - if (_internal_has_string()) { - clear_has_kind(); - ::substrait::Type_String* temp = kind_.string_; - kind_.string_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_string(::substrait::Type_String* string) { - clear_kind(); - if (string) { - set_has_string(); - kind_.string_ = string; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.string) -} -inline ::substrait::Type_String* Type::_internal_mutable_string() { - if (!_internal_has_string()) { - clear_kind(); - set_has_string(); - kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArenaForAllocation()); - } - return kind_.string_; -} -inline ::substrait::Type_String* Type::mutable_string() { - ::substrait::Type_String* _msg = _internal_mutable_string(); - // @@protoc_insertion_point(field_mutable:substrait.Type.string) - return _msg; -} - -// .substrait.Type.Binary binary = 13; -inline bool Type::_internal_has_binary() const { - return kind_case() == kBinary; -} -inline bool Type::has_binary() const { - return _internal_has_binary(); -} -inline void Type::set_has_binary() { - _oneof_case_[0] = kBinary; -} -inline void Type::clear_binary() { - if (_internal_has_binary()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.binary_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_Binary* Type::release_binary() { - // @@protoc_insertion_point(field_release:substrait.Type.binary) - if (_internal_has_binary()) { - clear_has_kind(); - ::substrait::Type_Binary* temp = kind_.binary_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Binary& Type::_internal_binary() const { - return _internal_has_binary() - ? *kind_.binary_ - : reinterpret_cast< ::substrait::Type_Binary&>(::substrait::_Type_Binary_default_instance_); -} -inline const ::substrait::Type_Binary& Type::binary() const { - // @@protoc_insertion_point(field_get:substrait.Type.binary) - return _internal_binary(); -} -inline ::substrait::Type_Binary* Type::unsafe_arena_release_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.binary) - if (_internal_has_binary()) { - clear_has_kind(); - ::substrait::Type_Binary* temp = kind_.binary_; - kind_.binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_binary(::substrait::Type_Binary* binary) { - clear_kind(); - if (binary) { - set_has_binary(); - kind_.binary_ = binary; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.binary) -} -inline ::substrait::Type_Binary* Type::_internal_mutable_binary() { - if (!_internal_has_binary()) { - clear_kind(); - set_has_binary(); - kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArenaForAllocation()); - } - return kind_.binary_; -} -inline ::substrait::Type_Binary* Type::mutable_binary() { - ::substrait::Type_Binary* _msg = _internal_mutable_binary(); - // @@protoc_insertion_point(field_mutable:substrait.Type.binary) - return _msg; -} - -// .substrait.Type.Timestamp timestamp = 14; -inline bool Type::_internal_has_timestamp() const { - return kind_case() == kTimestamp; -} -inline bool Type::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void Type::set_has_timestamp() { - _oneof_case_[0] = kTimestamp; -} -inline void Type::clear_timestamp() { - if (_internal_has_timestamp()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_Timestamp* Type::release_timestamp() { - // @@protoc_insertion_point(field_release:substrait.Type.timestamp) - if (_internal_has_timestamp()) { - clear_has_kind(); - ::substrait::Type_Timestamp* temp = kind_.timestamp_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.timestamp_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Timestamp& Type::_internal_timestamp() const { - return _internal_has_timestamp() - ? *kind_.timestamp_ - : reinterpret_cast< ::substrait::Type_Timestamp&>(::substrait::_Type_Timestamp_default_instance_); -} -inline const ::substrait::Type_Timestamp& Type::timestamp() const { - // @@protoc_insertion_point(field_get:substrait.Type.timestamp) - return _internal_timestamp(); -} -inline ::substrait::Type_Timestamp* Type::unsafe_arena_release_timestamp() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.timestamp) - if (_internal_has_timestamp()) { - clear_has_kind(); - ::substrait::Type_Timestamp* temp = kind_.timestamp_; - kind_.timestamp_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { - clear_kind(); - if (timestamp) { - set_has_timestamp(); - kind_.timestamp_ = timestamp; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.timestamp) -} -inline ::substrait::Type_Timestamp* Type::_internal_mutable_timestamp() { - if (!_internal_has_timestamp()) { - clear_kind(); - set_has_timestamp(); - kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArenaForAllocation()); - } - return kind_.timestamp_; -} -inline ::substrait::Type_Timestamp* Type::mutable_timestamp() { - ::substrait::Type_Timestamp* _msg = _internal_mutable_timestamp(); - // @@protoc_insertion_point(field_mutable:substrait.Type.timestamp) - return _msg; -} - -// .substrait.Type.Date date = 16; -inline bool Type::_internal_has_date() const { - return kind_case() == kDate; -} -inline bool Type::has_date() const { - return _internal_has_date(); -} -inline void Type::set_has_date() { - _oneof_case_[0] = kDate; -} -inline void Type::clear_date() { - if (_internal_has_date()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.date_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_Date* Type::release_date() { - // @@protoc_insertion_point(field_release:substrait.Type.date) - if (_internal_has_date()) { - clear_has_kind(); - ::substrait::Type_Date* temp = kind_.date_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.date_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Date& Type::_internal_date() const { - return _internal_has_date() - ? *kind_.date_ - : reinterpret_cast< ::substrait::Type_Date&>(::substrait::_Type_Date_default_instance_); -} -inline const ::substrait::Type_Date& Type::date() const { - // @@protoc_insertion_point(field_get:substrait.Type.date) - return _internal_date(); -} -inline ::substrait::Type_Date* Type::unsafe_arena_release_date() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.date) - if (_internal_has_date()) { - clear_has_kind(); - ::substrait::Type_Date* temp = kind_.date_; - kind_.date_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_date(::substrait::Type_Date* date) { - clear_kind(); - if (date) { - set_has_date(); - kind_.date_ = date; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.date) -} -inline ::substrait::Type_Date* Type::_internal_mutable_date() { - if (!_internal_has_date()) { - clear_kind(); - set_has_date(); - kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArenaForAllocation()); - } - return kind_.date_; -} -inline ::substrait::Type_Date* Type::mutable_date() { - ::substrait::Type_Date* _msg = _internal_mutable_date(); - // @@protoc_insertion_point(field_mutable:substrait.Type.date) - return _msg; -} - -// .substrait.Type.Time time = 17; -inline bool Type::_internal_has_time() const { - return kind_case() == kTime; -} -inline bool Type::has_time() const { - return _internal_has_time(); -} -inline void Type::set_has_time() { - _oneof_case_[0] = kTime; -} -inline void Type::clear_time() { - if (_internal_has_time()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.time_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_Time* Type::release_time() { - // @@protoc_insertion_point(field_release:substrait.Type.time) - if (_internal_has_time()) { - clear_has_kind(); - ::substrait::Type_Time* temp = kind_.time_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.time_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Time& Type::_internal_time() const { - return _internal_has_time() - ? *kind_.time_ - : reinterpret_cast< ::substrait::Type_Time&>(::substrait::_Type_Time_default_instance_); -} -inline const ::substrait::Type_Time& Type::time() const { - // @@protoc_insertion_point(field_get:substrait.Type.time) - return _internal_time(); -} -inline ::substrait::Type_Time* Type::unsafe_arena_release_time() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.time) - if (_internal_has_time()) { - clear_has_kind(); - ::substrait::Type_Time* temp = kind_.time_; - kind_.time_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_time(::substrait::Type_Time* time) { - clear_kind(); - if (time) { - set_has_time(); - kind_.time_ = time; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.time) -} -inline ::substrait::Type_Time* Type::_internal_mutable_time() { - if (!_internal_has_time()) { - clear_kind(); - set_has_time(); - kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArenaForAllocation()); - } - return kind_.time_; -} -inline ::substrait::Type_Time* Type::mutable_time() { - ::substrait::Type_Time* _msg = _internal_mutable_time(); - // @@protoc_insertion_point(field_mutable:substrait.Type.time) - return _msg; -} - -// .substrait.Type.IntervalYear interval_year = 19; -inline bool Type::_internal_has_interval_year() const { - return kind_case() == kIntervalYear; -} -inline bool Type::has_interval_year() const { - return _internal_has_interval_year(); -} -inline void Type::set_has_interval_year() { - _oneof_case_[0] = kIntervalYear; -} -inline void Type::clear_interval_year() { - if (_internal_has_interval_year()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_year_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_IntervalYear* Type::release_interval_year() { - // @@protoc_insertion_point(field_release:substrait.Type.interval_year) - if (_internal_has_interval_year()) { - clear_has_kind(); - ::substrait::Type_IntervalYear* temp = kind_.interval_year_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.interval_year_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_IntervalYear& Type::_internal_interval_year() const { - return _internal_has_interval_year() - ? *kind_.interval_year_ - : reinterpret_cast< ::substrait::Type_IntervalYear&>(::substrait::_Type_IntervalYear_default_instance_); -} -inline const ::substrait::Type_IntervalYear& Type::interval_year() const { - // @@protoc_insertion_point(field_get:substrait.Type.interval_year) - return _internal_interval_year(); -} -inline ::substrait::Type_IntervalYear* Type::unsafe_arena_release_interval_year() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.interval_year) - if (_internal_has_interval_year()) { - clear_has_kind(); - ::substrait::Type_IntervalYear* temp = kind_.interval_year_; - kind_.interval_year_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { - clear_kind(); - if (interval_year) { - set_has_interval_year(); - kind_.interval_year_ = interval_year; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.interval_year) -} -inline ::substrait::Type_IntervalYear* Type::_internal_mutable_interval_year() { - if (!_internal_has_interval_year()) { - clear_kind(); - set_has_interval_year(); - kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArenaForAllocation()); - } - return kind_.interval_year_; -} -inline ::substrait::Type_IntervalYear* Type::mutable_interval_year() { - ::substrait::Type_IntervalYear* _msg = _internal_mutable_interval_year(); - // @@protoc_insertion_point(field_mutable:substrait.Type.interval_year) - return _msg; -} - -// .substrait.Type.IntervalDay interval_day = 20; -inline bool Type::_internal_has_interval_day() const { - return kind_case() == kIntervalDay; -} -inline bool Type::has_interval_day() const { - return _internal_has_interval_day(); -} -inline void Type::set_has_interval_day() { - _oneof_case_[0] = kIntervalDay; -} -inline void Type::clear_interval_day() { - if (_internal_has_interval_day()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_day_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_IntervalDay* Type::release_interval_day() { - // @@protoc_insertion_point(field_release:substrait.Type.interval_day) - if (_internal_has_interval_day()) { - clear_has_kind(); - ::substrait::Type_IntervalDay* temp = kind_.interval_day_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.interval_day_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_IntervalDay& Type::_internal_interval_day() const { - return _internal_has_interval_day() - ? *kind_.interval_day_ - : reinterpret_cast< ::substrait::Type_IntervalDay&>(::substrait::_Type_IntervalDay_default_instance_); -} -inline const ::substrait::Type_IntervalDay& Type::interval_day() const { - // @@protoc_insertion_point(field_get:substrait.Type.interval_day) - return _internal_interval_day(); -} -inline ::substrait::Type_IntervalDay* Type::unsafe_arena_release_interval_day() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.interval_day) - if (_internal_has_interval_day()) { - clear_has_kind(); - ::substrait::Type_IntervalDay* temp = kind_.interval_day_; - kind_.interval_day_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { - clear_kind(); - if (interval_day) { - set_has_interval_day(); - kind_.interval_day_ = interval_day; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.interval_day) -} -inline ::substrait::Type_IntervalDay* Type::_internal_mutable_interval_day() { - if (!_internal_has_interval_day()) { - clear_kind(); - set_has_interval_day(); - kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArenaForAllocation()); - } - return kind_.interval_day_; -} -inline ::substrait::Type_IntervalDay* Type::mutable_interval_day() { - ::substrait::Type_IntervalDay* _msg = _internal_mutable_interval_day(); - // @@protoc_insertion_point(field_mutable:substrait.Type.interval_day) - return _msg; -} - -// .substrait.Type.TimestampTZ timestamp_tz = 29; -inline bool Type::_internal_has_timestamp_tz() const { - return kind_case() == kTimestampTz; -} -inline bool Type::has_timestamp_tz() const { - return _internal_has_timestamp_tz(); -} -inline void Type::set_has_timestamp_tz() { - _oneof_case_[0] = kTimestampTz; -} -inline void Type::clear_timestamp_tz() { - if (_internal_has_timestamp_tz()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_tz_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_TimestampTZ* Type::release_timestamp_tz() { - // @@protoc_insertion_point(field_release:substrait.Type.timestamp_tz) - if (_internal_has_timestamp_tz()) { - clear_has_kind(); - ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.timestamp_tz_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_TimestampTZ& Type::_internal_timestamp_tz() const { - return _internal_has_timestamp_tz() - ? *kind_.timestamp_tz_ - : reinterpret_cast< ::substrait::Type_TimestampTZ&>(::substrait::_Type_TimestampTZ_default_instance_); -} -inline const ::substrait::Type_TimestampTZ& Type::timestamp_tz() const { - // @@protoc_insertion_point(field_get:substrait.Type.timestamp_tz) - return _internal_timestamp_tz(); -} -inline ::substrait::Type_TimestampTZ* Type::unsafe_arena_release_timestamp_tz() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.timestamp_tz) - if (_internal_has_timestamp_tz()) { - clear_has_kind(); - ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; - kind_.timestamp_tz_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { - clear_kind(); - if (timestamp_tz) { - set_has_timestamp_tz(); - kind_.timestamp_tz_ = timestamp_tz; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.timestamp_tz) -} -inline ::substrait::Type_TimestampTZ* Type::_internal_mutable_timestamp_tz() { - if (!_internal_has_timestamp_tz()) { - clear_kind(); - set_has_timestamp_tz(); - kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArenaForAllocation()); - } - return kind_.timestamp_tz_; -} -inline ::substrait::Type_TimestampTZ* Type::mutable_timestamp_tz() { - ::substrait::Type_TimestampTZ* _msg = _internal_mutable_timestamp_tz(); - // @@protoc_insertion_point(field_mutable:substrait.Type.timestamp_tz) - return _msg; -} - -// .substrait.Type.UUID uuid = 32; -inline bool Type::_internal_has_uuid() const { - return kind_case() == kUuid; -} -inline bool Type::has_uuid() const { - return _internal_has_uuid(); -} -inline void Type::set_has_uuid() { - _oneof_case_[0] = kUuid; -} -inline void Type::clear_uuid() { - if (_internal_has_uuid()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.uuid_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_UUID* Type::release_uuid() { - // @@protoc_insertion_point(field_release:substrait.Type.uuid) - if (_internal_has_uuid()) { - clear_has_kind(); - ::substrait::Type_UUID* temp = kind_.uuid_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.uuid_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_UUID& Type::_internal_uuid() const { - return _internal_has_uuid() - ? *kind_.uuid_ - : reinterpret_cast< ::substrait::Type_UUID&>(::substrait::_Type_UUID_default_instance_); -} -inline const ::substrait::Type_UUID& Type::uuid() const { - // @@protoc_insertion_point(field_get:substrait.Type.uuid) - return _internal_uuid(); -} -inline ::substrait::Type_UUID* Type::unsafe_arena_release_uuid() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.uuid) - if (_internal_has_uuid()) { - clear_has_kind(); - ::substrait::Type_UUID* temp = kind_.uuid_; - kind_.uuid_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_uuid(::substrait::Type_UUID* uuid) { - clear_kind(); - if (uuid) { - set_has_uuid(); - kind_.uuid_ = uuid; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.uuid) -} -inline ::substrait::Type_UUID* Type::_internal_mutable_uuid() { - if (!_internal_has_uuid()) { - clear_kind(); - set_has_uuid(); - kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArenaForAllocation()); - } - return kind_.uuid_; -} -inline ::substrait::Type_UUID* Type::mutable_uuid() { - ::substrait::Type_UUID* _msg = _internal_mutable_uuid(); - // @@protoc_insertion_point(field_mutable:substrait.Type.uuid) - return _msg; -} - -// .substrait.Type.FixedChar fixed_char = 21; -inline bool Type::_internal_has_fixed_char() const { - return kind_case() == kFixedChar; -} -inline bool Type::has_fixed_char() const { - return _internal_has_fixed_char(); -} -inline void Type::set_has_fixed_char() { - _oneof_case_[0] = kFixedChar; -} -inline void Type::clear_fixed_char() { - if (_internal_has_fixed_char()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_char_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_FixedChar* Type::release_fixed_char() { - // @@protoc_insertion_point(field_release:substrait.Type.fixed_char) - if (_internal_has_fixed_char()) { - clear_has_kind(); - ::substrait::Type_FixedChar* temp = kind_.fixed_char_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fixed_char_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_FixedChar& Type::_internal_fixed_char() const { - return _internal_has_fixed_char() - ? *kind_.fixed_char_ - : reinterpret_cast< ::substrait::Type_FixedChar&>(::substrait::_Type_FixedChar_default_instance_); -} -inline const ::substrait::Type_FixedChar& Type::fixed_char() const { - // @@protoc_insertion_point(field_get:substrait.Type.fixed_char) - return _internal_fixed_char(); -} -inline ::substrait::Type_FixedChar* Type::unsafe_arena_release_fixed_char() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fixed_char) - if (_internal_has_fixed_char()) { - clear_has_kind(); - ::substrait::Type_FixedChar* temp = kind_.fixed_char_; - kind_.fixed_char_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_fixed_char(::substrait::Type_FixedChar* fixed_char) { - clear_kind(); - if (fixed_char) { - set_has_fixed_char(); - kind_.fixed_char_ = fixed_char; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fixed_char) -} -inline ::substrait::Type_FixedChar* Type::_internal_mutable_fixed_char() { - if (!_internal_has_fixed_char()) { - clear_kind(); - set_has_fixed_char(); - kind_.fixed_char_ = CreateMaybeMessage< ::substrait::Type_FixedChar >(GetArenaForAllocation()); - } - return kind_.fixed_char_; -} -inline ::substrait::Type_FixedChar* Type::mutable_fixed_char() { - ::substrait::Type_FixedChar* _msg = _internal_mutable_fixed_char(); - // @@protoc_insertion_point(field_mutable:substrait.Type.fixed_char) - return _msg; -} - -// .substrait.Type.VarChar varchar = 22; -inline bool Type::_internal_has_varchar() const { - return kind_case() == kVarchar; -} -inline bool Type::has_varchar() const { - return _internal_has_varchar(); -} -inline void Type::set_has_varchar() { - _oneof_case_[0] = kVarchar; -} -inline void Type::clear_varchar() { - if (_internal_has_varchar()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.varchar_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_VarChar* Type::release_varchar() { - // @@protoc_insertion_point(field_release:substrait.Type.varchar) - if (_internal_has_varchar()) { - clear_has_kind(); - ::substrait::Type_VarChar* temp = kind_.varchar_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.varchar_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_VarChar& Type::_internal_varchar() const { - return _internal_has_varchar() - ? *kind_.varchar_ - : reinterpret_cast< ::substrait::Type_VarChar&>(::substrait::_Type_VarChar_default_instance_); -} -inline const ::substrait::Type_VarChar& Type::varchar() const { - // @@protoc_insertion_point(field_get:substrait.Type.varchar) - return _internal_varchar(); -} -inline ::substrait::Type_VarChar* Type::unsafe_arena_release_varchar() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.varchar) - if (_internal_has_varchar()) { - clear_has_kind(); - ::substrait::Type_VarChar* temp = kind_.varchar_; - kind_.varchar_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_varchar(::substrait::Type_VarChar* varchar) { - clear_kind(); - if (varchar) { - set_has_varchar(); - kind_.varchar_ = varchar; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.varchar) -} -inline ::substrait::Type_VarChar* Type::_internal_mutable_varchar() { - if (!_internal_has_varchar()) { - clear_kind(); - set_has_varchar(); - kind_.varchar_ = CreateMaybeMessage< ::substrait::Type_VarChar >(GetArenaForAllocation()); - } - return kind_.varchar_; -} -inline ::substrait::Type_VarChar* Type::mutable_varchar() { - ::substrait::Type_VarChar* _msg = _internal_mutable_varchar(); - // @@protoc_insertion_point(field_mutable:substrait.Type.varchar) - return _msg; -} - -// .substrait.Type.FixedBinary fixed_binary = 23; -inline bool Type::_internal_has_fixed_binary() const { - return kind_case() == kFixedBinary; -} -inline bool Type::has_fixed_binary() const { - return _internal_has_fixed_binary(); -} -inline void Type::set_has_fixed_binary() { - _oneof_case_[0] = kFixedBinary; -} -inline void Type::clear_fixed_binary() { - if (_internal_has_fixed_binary()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_binary_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_FixedBinary* Type::release_fixed_binary() { - // @@protoc_insertion_point(field_release:substrait.Type.fixed_binary) - if (_internal_has_fixed_binary()) { - clear_has_kind(); - ::substrait::Type_FixedBinary* temp = kind_.fixed_binary_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fixed_binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_FixedBinary& Type::_internal_fixed_binary() const { - return _internal_has_fixed_binary() - ? *kind_.fixed_binary_ - : reinterpret_cast< ::substrait::Type_FixedBinary&>(::substrait::_Type_FixedBinary_default_instance_); -} -inline const ::substrait::Type_FixedBinary& Type::fixed_binary() const { - // @@protoc_insertion_point(field_get:substrait.Type.fixed_binary) - return _internal_fixed_binary(); -} -inline ::substrait::Type_FixedBinary* Type::unsafe_arena_release_fixed_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.fixed_binary) - if (_internal_has_fixed_binary()) { - clear_has_kind(); - ::substrait::Type_FixedBinary* temp = kind_.fixed_binary_; - kind_.fixed_binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_fixed_binary(::substrait::Type_FixedBinary* fixed_binary) { - clear_kind(); - if (fixed_binary) { - set_has_fixed_binary(); - kind_.fixed_binary_ = fixed_binary; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.fixed_binary) -} -inline ::substrait::Type_FixedBinary* Type::_internal_mutable_fixed_binary() { - if (!_internal_has_fixed_binary()) { - clear_kind(); - set_has_fixed_binary(); - kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::Type_FixedBinary >(GetArenaForAllocation()); - } - return kind_.fixed_binary_; -} -inline ::substrait::Type_FixedBinary* Type::mutable_fixed_binary() { - ::substrait::Type_FixedBinary* _msg = _internal_mutable_fixed_binary(); - // @@protoc_insertion_point(field_mutable:substrait.Type.fixed_binary) - return _msg; -} - -// .substrait.Type.Decimal decimal = 24; -inline bool Type::_internal_has_decimal() const { - return kind_case() == kDecimal; -} -inline bool Type::has_decimal() const { - return _internal_has_decimal(); -} -inline void Type::set_has_decimal() { - _oneof_case_[0] = kDecimal; -} -inline void Type::clear_decimal() { - if (_internal_has_decimal()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.decimal_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_Decimal* Type::release_decimal() { - // @@protoc_insertion_point(field_release:substrait.Type.decimal) - if (_internal_has_decimal()) { - clear_has_kind(); - ::substrait::Type_Decimal* temp = kind_.decimal_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.decimal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Decimal& Type::_internal_decimal() const { - return _internal_has_decimal() - ? *kind_.decimal_ - : reinterpret_cast< ::substrait::Type_Decimal&>(::substrait::_Type_Decimal_default_instance_); -} -inline const ::substrait::Type_Decimal& Type::decimal() const { - // @@protoc_insertion_point(field_get:substrait.Type.decimal) - return _internal_decimal(); -} -inline ::substrait::Type_Decimal* Type::unsafe_arena_release_decimal() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.decimal) - if (_internal_has_decimal()) { - clear_has_kind(); - ::substrait::Type_Decimal* temp = kind_.decimal_; - kind_.decimal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_decimal(::substrait::Type_Decimal* decimal) { - clear_kind(); - if (decimal) { - set_has_decimal(); - kind_.decimal_ = decimal; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.decimal) -} -inline ::substrait::Type_Decimal* Type::_internal_mutable_decimal() { - if (!_internal_has_decimal()) { - clear_kind(); - set_has_decimal(); - kind_.decimal_ = CreateMaybeMessage< ::substrait::Type_Decimal >(GetArenaForAllocation()); - } - return kind_.decimal_; -} -inline ::substrait::Type_Decimal* Type::mutable_decimal() { - ::substrait::Type_Decimal* _msg = _internal_mutable_decimal(); - // @@protoc_insertion_point(field_mutable:substrait.Type.decimal) - return _msg; -} - -// .substrait.Type.Struct struct = 25; -inline bool Type::_internal_has_struct_() const { - return kind_case() == kStruct; -} -inline bool Type::has_struct_() const { - return _internal_has_struct_(); -} -inline void Type::set_has_struct_() { - _oneof_case_[0] = kStruct; -} -inline void Type::clear_struct_() { - if (_internal_has_struct_()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.struct__; - } - clear_has_kind(); - } -} -inline ::substrait::Type_Struct* Type::release_struct_() { - // @@protoc_insertion_point(field_release:substrait.Type.struct) - if (_internal_has_struct_()) { - clear_has_kind(); - ::substrait::Type_Struct* temp = kind_.struct__; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Struct& Type::_internal_struct_() const { - return _internal_has_struct_() - ? *kind_.struct__ - : reinterpret_cast< ::substrait::Type_Struct&>(::substrait::_Type_Struct_default_instance_); -} -inline const ::substrait::Type_Struct& Type::struct_() const { - // @@protoc_insertion_point(field_get:substrait.Type.struct) - return _internal_struct_(); -} -inline ::substrait::Type_Struct* Type::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.struct) - if (_internal_has_struct_()) { - clear_has_kind(); - ::substrait::Type_Struct* temp = kind_.struct__; - kind_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_struct_(::substrait::Type_Struct* struct_) { - clear_kind(); - if (struct_) { - set_has_struct_(); - kind_.struct__ = struct_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.struct) -} -inline ::substrait::Type_Struct* Type::_internal_mutable_struct_() { - if (!_internal_has_struct_()) { - clear_kind(); - set_has_struct_(); - kind_.struct__ = CreateMaybeMessage< ::substrait::Type_Struct >(GetArenaForAllocation()); - } - return kind_.struct__; -} -inline ::substrait::Type_Struct* Type::mutable_struct_() { - ::substrait::Type_Struct* _msg = _internal_mutable_struct_(); - // @@protoc_insertion_point(field_mutable:substrait.Type.struct) - return _msg; -} - -// .substrait.Type.List list = 27; -inline bool Type::_internal_has_list() const { - return kind_case() == kList; -} -inline bool Type::has_list() const { - return _internal_has_list(); -} -inline void Type::set_has_list() { - _oneof_case_[0] = kList; -} -inline void Type::clear_list() { - if (_internal_has_list()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.list_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_List* Type::release_list() { - // @@protoc_insertion_point(field_release:substrait.Type.list) - if (_internal_has_list()) { - clear_has_kind(); - ::substrait::Type_List* temp = kind_.list_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_List& Type::_internal_list() const { - return _internal_has_list() - ? *kind_.list_ - : reinterpret_cast< ::substrait::Type_List&>(::substrait::_Type_List_default_instance_); -} -inline const ::substrait::Type_List& Type::list() const { - // @@protoc_insertion_point(field_get:substrait.Type.list) - return _internal_list(); -} -inline ::substrait::Type_List* Type::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.list) - if (_internal_has_list()) { - clear_has_kind(); - ::substrait::Type_List* temp = kind_.list_; - kind_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_list(::substrait::Type_List* list) { - clear_kind(); - if (list) { - set_has_list(); - kind_.list_ = list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.list) -} -inline ::substrait::Type_List* Type::_internal_mutable_list() { - if (!_internal_has_list()) { - clear_kind(); - set_has_list(); - kind_.list_ = CreateMaybeMessage< ::substrait::Type_List >(GetArenaForAllocation()); - } - return kind_.list_; -} -inline ::substrait::Type_List* Type::mutable_list() { - ::substrait::Type_List* _msg = _internal_mutable_list(); - // @@protoc_insertion_point(field_mutable:substrait.Type.list) - return _msg; -} - -// .substrait.Type.Map map = 28; -inline bool Type::_internal_has_map() const { - return kind_case() == kMap; -} -inline bool Type::has_map() const { - return _internal_has_map(); -} -inline void Type::set_has_map() { - _oneof_case_[0] = kMap; -} -inline void Type::clear_map() { - if (_internal_has_map()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.map_; - } - clear_has_kind(); - } -} -inline ::substrait::Type_Map* Type::release_map() { - // @@protoc_insertion_point(field_release:substrait.Type.map) - if (_internal_has_map()) { - clear_has_kind(); - ::substrait::Type_Map* temp = kind_.map_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Map& Type::_internal_map() const { - return _internal_has_map() - ? *kind_.map_ - : reinterpret_cast< ::substrait::Type_Map&>(::substrait::_Type_Map_default_instance_); -} -inline const ::substrait::Type_Map& Type::map() const { - // @@protoc_insertion_point(field_get:substrait.Type.map) - return _internal_map(); -} -inline ::substrait::Type_Map* Type::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.Type.map) - if (_internal_has_map()) { - clear_has_kind(); - ::substrait::Type_Map* temp = kind_.map_; - kind_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Type::unsafe_arena_set_allocated_map(::substrait::Type_Map* map) { - clear_kind(); - if (map) { - set_has_map(); - kind_.map_ = map; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.Type.map) -} -inline ::substrait::Type_Map* Type::_internal_mutable_map() { - if (!_internal_has_map()) { - clear_kind(); - set_has_map(); - kind_.map_ = CreateMaybeMessage< ::substrait::Type_Map >(GetArenaForAllocation()); - } - return kind_.map_; -} -inline ::substrait::Type_Map* Type::mutable_map() { - ::substrait::Type_Map* _msg = _internal_mutable_map(); - // @@protoc_insertion_point(field_mutable:substrait.Type.map) - return _msg; -} - -// uint32 user_defined_type_reference = 31; -inline bool Type::_internal_has_user_defined_type_reference() const { - return kind_case() == kUserDefinedTypeReference; -} -inline bool Type::has_user_defined_type_reference() const { - return _internal_has_user_defined_type_reference(); -} -inline void Type::set_has_user_defined_type_reference() { - _oneof_case_[0] = kUserDefinedTypeReference; -} -inline void Type::clear_user_defined_type_reference() { - if (_internal_has_user_defined_type_reference()) { - kind_.user_defined_type_reference_ = 0u; - clear_has_kind(); - } -} -inline uint32_t Type::_internal_user_defined_type_reference() const { - if (_internal_has_user_defined_type_reference()) { - return kind_.user_defined_type_reference_; - } - return 0u; -} -inline void Type::_internal_set_user_defined_type_reference(uint32_t value) { - if (!_internal_has_user_defined_type_reference()) { - clear_kind(); - set_has_user_defined_type_reference(); - } - kind_.user_defined_type_reference_ = value; -} -inline uint32_t Type::user_defined_type_reference() const { - // @@protoc_insertion_point(field_get:substrait.Type.user_defined_type_reference) - return _internal_user_defined_type_reference(); -} -inline void Type::set_user_defined_type_reference(uint32_t value) { - _internal_set_user_defined_type_reference(value); - // @@protoc_insertion_point(field_set:substrait.Type.user_defined_type_reference) -} - -inline bool Type::has_kind() const { - return kind_case() != KIND_NOT_SET; -} -inline void Type::clear_has_kind() { - _oneof_case_[0] = KIND_NOT_SET; -} -inline Type::KindCase Type::kind_case() const { - return Type::KindCase(_oneof_case_[0]); -} -// ------------------------------------------------------------------- - -// NamedStruct - -// repeated string names = 1; -inline int NamedStruct::_internal_names_size() const { - return names_.size(); -} -inline int NamedStruct::names_size() const { - return _internal_names_size(); -} -inline void NamedStruct::clear_names() { - names_.Clear(); -} -inline std::string* NamedStruct::add_names() { - std::string* _s = _internal_add_names(); - // @@protoc_insertion_point(field_add_mutable:substrait.NamedStruct.names) - return _s; -} -inline const std::string& NamedStruct::_internal_names(int index) const { - return names_.Get(index); -} -inline const std::string& NamedStruct::names(int index) const { - // @@protoc_insertion_point(field_get:substrait.NamedStruct.names) - return _internal_names(index); -} -inline std::string* NamedStruct::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:substrait.NamedStruct.names) - return names_.Mutable(index); -} -inline void NamedStruct::set_names(int index, const std::string& value) { - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.NamedStruct.names) -} -inline void NamedStruct::set_names(int index, std::string&& value) { - names_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.NamedStruct.names) -} -inline void NamedStruct::set_names(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.NamedStruct.names) -} -inline void NamedStruct::set_names(int index, const char* value, size_t size) { - names_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.NamedStruct.names) -} -inline std::string* NamedStruct::_internal_add_names() { - return names_.Add(); -} -inline void NamedStruct::add_names(const std::string& value) { - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.NamedStruct.names) -} -inline void NamedStruct::add_names(std::string&& value) { - names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.NamedStruct.names) -} -inline void NamedStruct::add_names(const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.NamedStruct.names) -} -inline void NamedStruct::add_names(const char* value, size_t size) { - names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.NamedStruct.names) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -NamedStruct::names() const { - // @@protoc_insertion_point(field_list:substrait.NamedStruct.names) - return names_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -NamedStruct::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:substrait.NamedStruct.names) - return &names_; -} - -// .substrait.Type.Struct struct = 2; -inline bool NamedStruct::_internal_has_struct_() const { - return this != internal_default_instance() && struct__ != nullptr; -} -inline bool NamedStruct::has_struct_() const { - return _internal_has_struct_(); -} -inline void NamedStruct::clear_struct_() { - if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { - delete struct__; - } - struct__ = nullptr; -} -inline const ::substrait::Type_Struct& NamedStruct::_internal_struct_() const { - const ::substrait::Type_Struct* p = struct__; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_Type_Struct_default_instance_); -} -inline const ::substrait::Type_Struct& NamedStruct::struct_() const { - // @@protoc_insertion_point(field_get:substrait.NamedStruct.struct) - return _internal_struct_(); -} -inline void NamedStruct::unsafe_arena_set_allocated_struct_( - ::substrait::Type_Struct* struct_) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); - } - struct__ = struct_; - if (struct_) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.NamedStruct.struct) -} -inline ::substrait::Type_Struct* NamedStruct::release_struct_() { - - ::substrait::Type_Struct* temp = struct__; - struct__ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::Type_Struct* NamedStruct::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_release:substrait.NamedStruct.struct) - - ::substrait::Type_Struct* temp = struct__; - struct__ = nullptr; - return temp; -} -inline ::substrait::Type_Struct* NamedStruct::_internal_mutable_struct_() { - - if (struct__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::Type_Struct>(GetArenaForAllocation()); - struct__ = p; - } - return struct__; -} -inline ::substrait::Type_Struct* NamedStruct::mutable_struct_() { - ::substrait::Type_Struct* _msg = _internal_mutable_struct_(); - // @@protoc_insertion_point(field_mutable:substrait.NamedStruct.struct) - return _msg; -} -inline void NamedStruct::set_allocated_struct_(::substrait::Type_Struct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete struct__; - } - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::Type_Struct>::GetOwningArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - - } else { - - } - struct__ = struct_; - // @@protoc_insertion_point(field_set_allocated:substrait.NamedStruct.struct) -} - -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace substrait - -PROTOBUF_NAMESPACE_OPEN - -template <> struct is_proto_enum< ::substrait::Type_Nullability> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::Type_Nullability>() { - return ::substrait::Type_Nullability_descriptor(); -} - -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_2eproto diff --git a/cpp/src/generated/substrait/type_expressions.pb.cc b/cpp/src/generated/substrait/type_expressions.pb.cc deleted file mode 100644 index 1179ab8e3ad..00000000000 --- a/cpp/src/generated/substrait/type_expressions.pb.cc +++ /dev/null @@ -1,6038 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/type_expressions.proto - -#include "substrait/type_expressions.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -// @@protoc_insertion_point(includes) -#include - -PROTOBUF_PRAGMA_INIT_SEG -namespace substrait { -constexpr DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : length_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct DerivationExpression_ExpressionFixedCharDefaultTypeInternal { - constexpr DerivationExpression_ExpressionFixedCharDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_ExpressionFixedCharDefaultTypeInternal() {} - union { - DerivationExpression_ExpressionFixedChar _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionFixedCharDefaultTypeInternal _DerivationExpression_ExpressionFixedChar_default_instance_; -constexpr DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : length_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct DerivationExpression_ExpressionVarCharDefaultTypeInternal { - constexpr DerivationExpression_ExpressionVarCharDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_ExpressionVarCharDefaultTypeInternal() {} - union { - DerivationExpression_ExpressionVarChar _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionVarCharDefaultTypeInternal _DerivationExpression_ExpressionVarChar_default_instance_; -constexpr DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : length_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal { - constexpr DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal() {} - union { - DerivationExpression_ExpressionFixedBinary _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal _DerivationExpression_ExpressionFixedBinary_default_instance_; -constexpr DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : scale_(nullptr) - , precision_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct DerivationExpression_ExpressionDecimalDefaultTypeInternal { - constexpr DerivationExpression_ExpressionDecimalDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_ExpressionDecimalDefaultTypeInternal() {} - union { - DerivationExpression_ExpressionDecimal _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionDecimalDefaultTypeInternal _DerivationExpression_ExpressionDecimal_default_instance_; -constexpr DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : types_() - , variation_pointer_(0u) - , nullability_(0) -{} -struct DerivationExpression_ExpressionStructDefaultTypeInternal { - constexpr DerivationExpression_ExpressionStructDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_ExpressionStructDefaultTypeInternal() {} - union { - DerivationExpression_ExpressionStruct _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionStructDefaultTypeInternal _DerivationExpression_ExpressionStruct_default_instance_; -constexpr DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : names_() - , struct__(nullptr){} -struct DerivationExpression_ExpressionNamedStructDefaultTypeInternal { - constexpr DerivationExpression_ExpressionNamedStructDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_ExpressionNamedStructDefaultTypeInternal() {} - union { - DerivationExpression_ExpressionNamedStruct _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionNamedStructDefaultTypeInternal _DerivationExpression_ExpressionNamedStruct_default_instance_; -constexpr DerivationExpression_ExpressionList::DerivationExpression_ExpressionList( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : type_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct DerivationExpression_ExpressionListDefaultTypeInternal { - constexpr DerivationExpression_ExpressionListDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_ExpressionListDefaultTypeInternal() {} - union { - DerivationExpression_ExpressionList _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionListDefaultTypeInternal _DerivationExpression_ExpressionList_default_instance_; -constexpr DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : key_(nullptr) - , value_(nullptr) - , variation_pointer_(0u) - , nullability_(0) -{} -struct DerivationExpression_ExpressionMapDefaultTypeInternal { - constexpr DerivationExpression_ExpressionMapDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_ExpressionMapDefaultTypeInternal() {} - union { - DerivationExpression_ExpressionMap _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ExpressionMapDefaultTypeInternal _DerivationExpression_ExpressionMap_default_instance_; -constexpr DerivationExpression_IfElse::DerivationExpression_IfElse( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : if_condition_(nullptr) - , if_return_(nullptr) - , else_return_(nullptr){} -struct DerivationExpression_IfElseDefaultTypeInternal { - constexpr DerivationExpression_IfElseDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_IfElseDefaultTypeInternal() {} - union { - DerivationExpression_IfElse _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_IfElseDefaultTypeInternal _DerivationExpression_IfElse_default_instance_; -constexpr DerivationExpression_UnaryOp::DerivationExpression_UnaryOp( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : arg_(nullptr) - , op_type_(0) -{} -struct DerivationExpression_UnaryOpDefaultTypeInternal { - constexpr DerivationExpression_UnaryOpDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_UnaryOpDefaultTypeInternal() {} - union { - DerivationExpression_UnaryOp _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_UnaryOpDefaultTypeInternal _DerivationExpression_UnaryOp_default_instance_; -constexpr DerivationExpression_BinaryOp::DerivationExpression_BinaryOp( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : arg1_(nullptr) - , arg2_(nullptr) - , op_type_(0) -{} -struct DerivationExpression_BinaryOpDefaultTypeInternal { - constexpr DerivationExpression_BinaryOpDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_BinaryOpDefaultTypeInternal() {} - union { - DerivationExpression_BinaryOp _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_BinaryOpDefaultTypeInternal _DerivationExpression_BinaryOp_default_instance_; -constexpr DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : name_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string) - , expression_(nullptr){} -struct DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal { - constexpr DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal() {} - union { - DerivationExpression_ReturnProgram_Assignment _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal _DerivationExpression_ReturnProgram_Assignment_default_instance_; -constexpr DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : assignments_() - , final_expression_(nullptr){} -struct DerivationExpression_ReturnProgramDefaultTypeInternal { - constexpr DerivationExpression_ReturnProgramDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpression_ReturnProgramDefaultTypeInternal() {} - union { - DerivationExpression_ReturnProgram _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpression_ReturnProgramDefaultTypeInternal _DerivationExpression_ReturnProgram_default_instance_; -constexpr DerivationExpression::DerivationExpression( - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized) - : _oneof_case_{}{} -struct DerivationExpressionDefaultTypeInternal { - constexpr DerivationExpressionDefaultTypeInternal() - : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {} - ~DerivationExpressionDefaultTypeInternal() {} - union { - DerivationExpression _instance; - }; -}; -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT DerivationExpressionDefaultTypeInternal _DerivationExpression_default_instance_; -} // namespace substrait -static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_substrait_2ftype_5fexpressions_2eproto[14]; -static const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[2]; -static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_substrait_2ftype_5fexpressions_2eproto = nullptr; - -const uint32_t TableStruct_substrait_2ftype_5fexpressions_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, length_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedChar, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, length_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionVarChar, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, length_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionFixedBinary, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, scale_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, precision_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionDecimal, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, types_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionStruct, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, names_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionNamedStruct, struct__), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, type_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionList, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, key_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, value_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, variation_pointer_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ExpressionMap, nullability_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, if_condition_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, if_return_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_IfElse, else_return_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, op_type_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_UnaryOp, arg_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, op_type_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, arg1_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_BinaryOp, arg2_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, name_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram_Assignment, expression_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, assignments_), - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression_ReturnProgram, final_expression_), - ~0u, // no _has_bits_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, _internal_metadata_), - ~0u, // no _extensions_ - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, _oneof_case_[0]), - ~0u, // no _weak_field_map_ - ~0u, // no _inlined_string_donated_ - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag, - PROTOBUF_FIELD_OFFSET(::substrait::DerivationExpression, kind_), -}; -static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedChar)}, - { 9, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionVarChar)}, - { 18, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionFixedBinary)}, - { 27, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionDecimal)}, - { 37, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionStruct)}, - { 46, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionNamedStruct)}, - { 54, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionList)}, - { 63, -1, -1, sizeof(::substrait::DerivationExpression_ExpressionMap)}, - { 73, -1, -1, sizeof(::substrait::DerivationExpression_IfElse)}, - { 82, -1, -1, sizeof(::substrait::DerivationExpression_UnaryOp)}, - { 90, -1, -1, sizeof(::substrait::DerivationExpression_BinaryOp)}, - { 99, -1, -1, sizeof(::substrait::DerivationExpression_ReturnProgram_Assignment)}, - { 107, -1, -1, sizeof(::substrait::DerivationExpression_ReturnProgram)}, - { 115, -1, -1, sizeof(::substrait::DerivationExpression)}, -}; - -static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = { - reinterpret_cast(&::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_ExpressionVarChar_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_ExpressionDecimal_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_ExpressionStruct_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_ExpressionNamedStruct_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_ExpressionList_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_ExpressionMap_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_IfElse_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_UnaryOp_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_BinaryOp_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_ReturnProgram_Assignment_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_ReturnProgram_default_instance_), - reinterpret_cast(&::substrait::_DerivationExpression_default_instance_), -}; - -const char descriptor_table_protodef_substrait_2ftype_5fexpressions_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = - "\n substrait/type_expressions.proto\022\tsubs" - "trait\032\024substrait/type.proto\"\366\036\n\024Derivati" - "onExpression\022\'\n\004bool\030\001 \001(\0132\027.substrait.T" - "ype.BooleanH\000\022 \n\002i8\030\002 \001(\0132\022.substrait.Ty" - "pe.I8H\000\022\"\n\003i16\030\003 \001(\0132\023.substrait.Type.I1" - "6H\000\022\"\n\003i32\030\005 \001(\0132\023.substrait.Type.I32H\000\022" - "\"\n\003i64\030\007 \001(\0132\023.substrait.Type.I64H\000\022$\n\004f" - "p32\030\n \001(\0132\024.substrait.Type.FP32H\000\022$\n\004fp6" - "4\030\013 \001(\0132\024.substrait.Type.FP64H\000\022(\n\006strin" - "g\030\014 \001(\0132\026.substrait.Type.StringH\000\022(\n\006bin" - "ary\030\r \001(\0132\026.substrait.Type.BinaryH\000\022.\n\tt" - "imestamp\030\016 \001(\0132\031.substrait.Type.Timestam" - "pH\000\022$\n\004date\030\020 \001(\0132\024.substrait.Type.DateH" - "\000\022$\n\004time\030\021 \001(\0132\024.substrait.Type.TimeH\000\022" - "5\n\rinterval_year\030\023 \001(\0132\034.substrait.Type." - "IntervalYearH\000\0223\n\014interval_day\030\024 \001(\0132\033.s" - "ubstrait.Type.IntervalDayH\000\0223\n\014timestamp" - "_tz\030\035 \001(\0132\033.substrait.Type.TimestampTZH\000" - "\022$\n\004uuid\030 \001(\0132\024.substrait.Type.UUIDH\000\022I" - "\n\nfixed_char\030\025 \001(\01323.substrait.Derivatio" - "nExpression.ExpressionFixedCharH\000\022D\n\007var" - "char\030\026 \001(\01321.substrait.DerivationExpress" - "ion.ExpressionVarCharH\000\022M\n\014fixed_binary\030" - "\027 \001(\01325.substrait.DerivationExpression.E" - "xpressionFixedBinaryH\000\022D\n\007decimal\030\030 \001(\0132" - "1.substrait.DerivationExpression.Express" - "ionDecimalH\000\022B\n\006struct\030\031 \001(\01320.substrait" - ".DerivationExpression.ExpressionStructH\000" - "\022>\n\004list\030\033 \001(\0132..substrait.DerivationExp" - "ression.ExpressionListH\000\022<\n\003map\030\034 \001(\0132-." - "substrait.DerivationExpression.Expressio" - "nMapH\000\022\036\n\024user_defined_pointer\030\037 \001(\rH\000\022\035" - "\n\023type_parameter_name\030! \001(\tH\000\022 \n\026integer" - "_parameter_name\030\" \001(\tH\000\022\031\n\017integer_liter" - "al\030# \001(\005H\000\022;\n\010unary_op\030$ \001(\0132\'.substrait" - ".DerivationExpression.UnaryOpH\000\022=\n\tbinar" - "y_op\030% \001(\0132(.substrait.DerivationExpress" - "ion.BinaryOpH\000\0229\n\007if_else\030& \001(\0132&.substr" - "ait.DerivationExpression.IfElseH\000\022G\n\016ret" - "urn_program\030\' \001(\0132-.substrait.Derivation" - "Expression.ReturnProgramH\000\032\223\001\n\023Expressio" - "nFixedChar\022/\n\006length\030\001 \001(\0132\037.substrait.D" - "erivationExpression\022\031\n\021variation_pointer" - "\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.substrait." - "Type.Nullability\032\221\001\n\021ExpressionVarChar\022/" - "\n\006length\030\001 \001(\0132\037.substrait.DerivationExp" - "ression\022\031\n\021variation_pointer\030\002 \001(\r\0220\n\013nu" - "llability\030\003 \001(\0162\033.substrait.Type.Nullabi" - "lity\032\225\001\n\025ExpressionFixedBinary\022/\n\006length" - "\030\001 \001(\0132\037.substrait.DerivationExpression\022" - "\031\n\021variation_pointer\030\002 \001(\r\0220\n\013nullabilit" - "y\030\003 \001(\0162\033.substrait.Type.Nullability\032\304\001\n" - "\021ExpressionDecimal\022.\n\005scale\030\001 \001(\0132\037.subs" - "trait.DerivationExpression\0222\n\tprecision\030" - "\002 \001(\0132\037.substrait.DerivationExpression\022\031" - "\n\021variation_pointer\030\003 \001(\r\0220\n\013nullability" - "\030\004 \001(\0162\033.substrait.Type.Nullability\032\217\001\n\020" - "ExpressionStruct\022.\n\005types\030\001 \003(\0132\037.substr" - "ait.DerivationExpression\022\031\n\021variation_po" - "inter\030\002 \001(\r\0220\n\013nullability\030\003 \001(\0162\033.subst" - "rait.Type.Nullability\032h\n\025ExpressionNamed" - "Struct\022\r\n\005names\030\001 \003(\t\022@\n\006struct\030\002 \001(\01320." - "substrait.DerivationExpression.Expressio" - "nStruct\032\214\001\n\016ExpressionList\022-\n\004type\030\001 \001(\013" - "2\037.substrait.DerivationExpression\022\031\n\021var" - "iation_pointer\030\002 \001(\r\0220\n\013nullability\030\003 \001(" - "\0162\033.substrait.Type.Nullability\032\272\001\n\rExpre" - "ssionMap\022,\n\003key\030\001 \001(\0132\037.substrait.Deriva" - "tionExpression\022.\n\005value\030\002 \001(\0132\037.substrai" - "t.DerivationExpression\022\031\n\021variation_poin" - "ter\030\003 \001(\r\0220\n\013nullability\030\004 \001(\0162\033.substra" - "it.Type.Nullability\032\251\001\n\006IfElse\0225\n\014if_con" - "dition\030\001 \001(\0132\037.substrait.DerivationExpre" - "ssion\0222\n\tif_return\030\002 \001(\0132\037.substrait.Der" - "ivationExpression\0224\n\013else_return\030\003 \001(\0132\037" - ".substrait.DerivationExpression\032\312\001\n\007Unar" - "yOp\022D\n\007op_type\030\001 \001(\01623.substrait.Derivat" - "ionExpression.UnaryOp.UnaryOpType\022,\n\003arg" - "\030\002 \001(\0132\037.substrait.DerivationExpression\"" - "K\n\013UnaryOpType\022\035\n\031UNARY_OP_TYPE_UNSPECIF" - "IED\020\000\022\035\n\031UNARY_OP_TYPE_BOOLEAN_NOT\020\001\032\240\004\n" - "\010BinaryOp\022F\n\007op_type\030\001 \001(\01625.substrait.D" - "erivationExpression.BinaryOp.BinaryOpTyp" - "e\022-\n\004arg1\030\002 \001(\0132\037.substrait.DerivationEx" - "pression\022-\n\004arg2\030\003 \001(\0132\037.substrait.Deriv" - "ationExpression\"\355\002\n\014BinaryOpType\022\036\n\032BINA" - "RY_OP_TYPE_UNSPECIFIED\020\000\022\027\n\023BINARY_OP_TY" - "PE_PLUS\020\001\022\030\n\024BINARY_OP_TYPE_MINUS\020\002\022\033\n\027B" - "INARY_OP_TYPE_MULTIPLY\020\003\022\031\n\025BINARY_OP_TY" - "PE_DIVIDE\020\004\022\026\n\022BINARY_OP_TYPE_MIN\020\005\022\026\n\022B" - "INARY_OP_TYPE_MAX\020\006\022\037\n\033BINARY_OP_TYPE_GR" - "EATER_THAN\020\007\022\034\n\030BINARY_OP_TYPE_LESS_THAN" - "\020\010\022\026\n\022BINARY_OP_TYPE_AND\020\t\022\025\n\021BINARY_OP_" - "TYPE_OR\020\n\022\031\n\025BINARY_OP_TYPE_EQUALS\020\013\022\031\n\025" - "BINARY_OP_TYPE_COVERS\020\014\032\352\001\n\rReturnProgra" - "m\022M\n\013assignments\030\001 \003(\01328.substrait.Deriv" - "ationExpression.ReturnProgram.Assignment" - "\0229\n\020final_expression\030\002 \001(\0132\037.substrait.D" - "erivationExpression\032O\n\nAssignment\022\014\n\004nam" - "e\030\001 \001(\t\0223\n\nexpression\030\002 \001(\0132\037.substrait." - "DerivationExpressionB\006\n\004kindB+\n\022io.subst" - "rait.protoP\001\252\002\022Substrait.Protobufb\006proto" - "3" - ; -static const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable*const descriptor_table_substrait_2ftype_5fexpressions_2eproto_deps[1] = { - &::descriptor_table_substrait_2ftype_2eproto, -}; -static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_substrait_2ftype_5fexpressions_2eproto_once; -const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_5fexpressions_2eproto = { - false, false, 4081, descriptor_table_protodef_substrait_2ftype_5fexpressions_2eproto, "substrait/type_expressions.proto", - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, descriptor_table_substrait_2ftype_5fexpressions_2eproto_deps, 1, 14, - schemas, file_default_instances, TableStruct_substrait_2ftype_5fexpressions_2eproto::offsets, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto, file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto, file_level_service_descriptors_substrait_2ftype_5fexpressions_2eproto, -}; -PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter() { - return &descriptor_table_substrait_2ftype_5fexpressions_2eproto; -} - -// Force running AddDescriptors() at dynamic initialization time. -PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_substrait_2ftype_5fexpressions_2eproto(&descriptor_table_substrait_2ftype_5fexpressions_2eproto); -namespace substrait { -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_UnaryOpType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_5fexpressions_2eproto); - return file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[0]; -} -bool DerivationExpression_UnaryOp_UnaryOpType_IsValid(int value) { - switch (value) { - case 0: - case 1: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UNARY_OP_TYPE_UNSPECIFIED; -constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UNARY_OP_TYPE_BOOLEAN_NOT; -constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UnaryOpType_MIN; -constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::UnaryOpType_MAX; -constexpr int DerivationExpression_UnaryOp::UnaryOpType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_BinaryOpType_descriptor() { - ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&descriptor_table_substrait_2ftype_5fexpressions_2eproto); - return file_level_enum_descriptors_substrait_2ftype_5fexpressions_2eproto[1]; -} -bool DerivationExpression_BinaryOp_BinaryOpType_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - case 9: - case 10: - case 11: - case 12: - return true; - default: - return false; - } -} - -#if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_UNSPECIFIED; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_PLUS; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MINUS; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MULTIPLY; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_DIVIDE; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MIN; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_MAX; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_GREATER_THAN; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_LESS_THAN; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_AND; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_OR; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_EQUALS; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BINARY_OP_TYPE_COVERS; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BinaryOpType_MIN; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::BinaryOpType_MAX; -constexpr int DerivationExpression_BinaryOp::BinaryOpType_ARRAYSIZE; -#endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912)) - -// =================================================================== - -class DerivationExpression_ExpressionFixedChar::_Internal { - public: - static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedChar* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_ExpressionFixedChar::_Internal::length(const DerivationExpression_ExpressionFixedChar* msg) { - return *msg->length_; -} -DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionFixedChar) -} -DerivationExpression_ExpressionFixedChar::DerivationExpression_ExpressionFixedChar(const DerivationExpression_ExpressionFixedChar& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_length()) { - length_ = new ::substrait::DerivationExpression(*from.length_); - } else { - length_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedChar) -} - -inline void DerivationExpression_ExpressionFixedChar::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&length_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); -} - -DerivationExpression_ExpressionFixedChar::~DerivationExpression_ExpressionFixedChar() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionFixedChar) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_ExpressionFixedChar::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete length_; -} - -void DerivationExpression_ExpressionFixedChar::ArenaDtor(void* object) { - DerivationExpression_ExpressionFixedChar* _this = reinterpret_cast< DerivationExpression_ExpressionFixedChar* >(object); - (void)_this; -} -void DerivationExpression_ExpressionFixedChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_ExpressionFixedChar::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_ExpressionFixedChar::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionFixedChar) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_ExpressionFixedChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.DerivationExpression length = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* DerivationExpression_ExpressionFixedChar::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionFixedChar) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.DerivationExpression length = 1; - if (this->_internal_has_length()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::length(this), target, stream); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionFixedChar) - return target; -} - -size_t DerivationExpression_ExpressionFixedChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionFixedChar) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.DerivationExpression length = 1; - if (this->_internal_has_length()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *length_); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionFixedChar::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_ExpressionFixedChar::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionFixedChar::GetClassData() const { return &_class_data_; } - -void DerivationExpression_ExpressionFixedChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_ExpressionFixedChar::MergeFrom(const DerivationExpression_ExpressionFixedChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionFixedChar) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_length()) { - _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_ExpressionFixedChar::CopyFrom(const DerivationExpression_ExpressionFixedChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionFixedChar) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_ExpressionFixedChar::IsInitialized() const { - return true; -} - -void DerivationExpression_ExpressionFixedChar::InternalSwap(DerivationExpression_ExpressionFixedChar* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedChar, nullability_) - + sizeof(DerivationExpression_ExpressionFixedChar::nullability_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedChar, length_)>( - reinterpret_cast(&length_), - reinterpret_cast(&other->length_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedChar::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[0]); -} - -// =================================================================== - -class DerivationExpression_ExpressionVarChar::_Internal { - public: - static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionVarChar* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_ExpressionVarChar::_Internal::length(const DerivationExpression_ExpressionVarChar* msg) { - return *msg->length_; -} -DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionVarChar) -} -DerivationExpression_ExpressionVarChar::DerivationExpression_ExpressionVarChar(const DerivationExpression_ExpressionVarChar& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_length()) { - length_ = new ::substrait::DerivationExpression(*from.length_); - } else { - length_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionVarChar) -} - -inline void DerivationExpression_ExpressionVarChar::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&length_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); -} - -DerivationExpression_ExpressionVarChar::~DerivationExpression_ExpressionVarChar() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionVarChar) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_ExpressionVarChar::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete length_; -} - -void DerivationExpression_ExpressionVarChar::ArenaDtor(void* object) { - DerivationExpression_ExpressionVarChar* _this = reinterpret_cast< DerivationExpression_ExpressionVarChar* >(object); - (void)_this; -} -void DerivationExpression_ExpressionVarChar::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_ExpressionVarChar::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_ExpressionVarChar::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionVarChar) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_ExpressionVarChar::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.DerivationExpression length = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* DerivationExpression_ExpressionVarChar::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionVarChar) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.DerivationExpression length = 1; - if (this->_internal_has_length()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::length(this), target, stream); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionVarChar) - return target; -} - -size_t DerivationExpression_ExpressionVarChar::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionVarChar) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.DerivationExpression length = 1; - if (this->_internal_has_length()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *length_); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionVarChar::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_ExpressionVarChar::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionVarChar::GetClassData() const { return &_class_data_; } - -void DerivationExpression_ExpressionVarChar::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_ExpressionVarChar::MergeFrom(const DerivationExpression_ExpressionVarChar& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionVarChar) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_length()) { - _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_ExpressionVarChar::CopyFrom(const DerivationExpression_ExpressionVarChar& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionVarChar) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_ExpressionVarChar::IsInitialized() const { - return true; -} - -void DerivationExpression_ExpressionVarChar::InternalSwap(DerivationExpression_ExpressionVarChar* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionVarChar, nullability_) - + sizeof(DerivationExpression_ExpressionVarChar::nullability_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionVarChar, length_)>( - reinterpret_cast(&length_), - reinterpret_cast(&other->length_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionVarChar::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[1]); -} - -// =================================================================== - -class DerivationExpression_ExpressionFixedBinary::_Internal { - public: - static const ::substrait::DerivationExpression& length(const DerivationExpression_ExpressionFixedBinary* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_ExpressionFixedBinary::_Internal::length(const DerivationExpression_ExpressionFixedBinary* msg) { - return *msg->length_; -} -DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionFixedBinary) -} -DerivationExpression_ExpressionFixedBinary::DerivationExpression_ExpressionFixedBinary(const DerivationExpression_ExpressionFixedBinary& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_length()) { - length_ = new ::substrait::DerivationExpression(*from.length_); - } else { - length_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionFixedBinary) -} - -inline void DerivationExpression_ExpressionFixedBinary::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&length_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&length_)) + sizeof(nullability_)); -} - -DerivationExpression_ExpressionFixedBinary::~DerivationExpression_ExpressionFixedBinary() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionFixedBinary) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_ExpressionFixedBinary::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete length_; -} - -void DerivationExpression_ExpressionFixedBinary::ArenaDtor(void* object) { - DerivationExpression_ExpressionFixedBinary* _this = reinterpret_cast< DerivationExpression_ExpressionFixedBinary* >(object); - (void)_this; -} -void DerivationExpression_ExpressionFixedBinary::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_ExpressionFixedBinary::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_ExpressionFixedBinary::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionFixedBinary) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_ExpressionFixedBinary::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.DerivationExpression length = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_length(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* DerivationExpression_ExpressionFixedBinary::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionFixedBinary) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.DerivationExpression length = 1; - if (this->_internal_has_length()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::length(this), target, stream); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionFixedBinary) - return target; -} - -size_t DerivationExpression_ExpressionFixedBinary::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionFixedBinary) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.DerivationExpression length = 1; - if (this->_internal_has_length()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *length_); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionFixedBinary::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_ExpressionFixedBinary::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionFixedBinary::GetClassData() const { return &_class_data_; } - -void DerivationExpression_ExpressionFixedBinary::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_ExpressionFixedBinary::MergeFrom(const DerivationExpression_ExpressionFixedBinary& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionFixedBinary) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_length()) { - _internal_mutable_length()->::substrait::DerivationExpression::MergeFrom(from._internal_length()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_ExpressionFixedBinary::CopyFrom(const DerivationExpression_ExpressionFixedBinary& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionFixedBinary) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_ExpressionFixedBinary::IsInitialized() const { - return true; -} - -void DerivationExpression_ExpressionFixedBinary::InternalSwap(DerivationExpression_ExpressionFixedBinary* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedBinary, nullability_) - + sizeof(DerivationExpression_ExpressionFixedBinary::nullability_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionFixedBinary, length_)>( - reinterpret_cast(&length_), - reinterpret_cast(&other->length_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionFixedBinary::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[2]); -} - -// =================================================================== - -class DerivationExpression_ExpressionDecimal::_Internal { - public: - static const ::substrait::DerivationExpression& scale(const DerivationExpression_ExpressionDecimal* msg); - static const ::substrait::DerivationExpression& precision(const DerivationExpression_ExpressionDecimal* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_ExpressionDecimal::_Internal::scale(const DerivationExpression_ExpressionDecimal* msg) { - return *msg->scale_; -} -const ::substrait::DerivationExpression& -DerivationExpression_ExpressionDecimal::_Internal::precision(const DerivationExpression_ExpressionDecimal* msg) { - return *msg->precision_; -} -DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionDecimal) -} -DerivationExpression_ExpressionDecimal::DerivationExpression_ExpressionDecimal(const DerivationExpression_ExpressionDecimal& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_scale()) { - scale_ = new ::substrait::DerivationExpression(*from.scale_); - } else { - scale_ = nullptr; - } - if (from._internal_has_precision()) { - precision_ = new ::substrait::DerivationExpression(*from.precision_); - } else { - precision_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionDecimal) -} - -inline void DerivationExpression_ExpressionDecimal::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&scale_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&scale_)) + sizeof(nullability_)); -} - -DerivationExpression_ExpressionDecimal::~DerivationExpression_ExpressionDecimal() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionDecimal) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_ExpressionDecimal::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete scale_; - if (this != internal_default_instance()) delete precision_; -} - -void DerivationExpression_ExpressionDecimal::ArenaDtor(void* object) { - DerivationExpression_ExpressionDecimal* _this = reinterpret_cast< DerivationExpression_ExpressionDecimal* >(object); - (void)_this; -} -void DerivationExpression_ExpressionDecimal::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_ExpressionDecimal::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_ExpressionDecimal::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionDecimal) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && scale_ != nullptr) { - delete scale_; - } - scale_ = nullptr; - if (GetArenaForAllocation() == nullptr && precision_ != nullptr) { - delete precision_; - } - precision_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_ExpressionDecimal::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.DerivationExpression scale = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_scale(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression precision = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_precision(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* DerivationExpression_ExpressionDecimal::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionDecimal) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.DerivationExpression scale = 1; - if (this->_internal_has_scale()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::scale(this), target, stream); - } - - // .substrait.DerivationExpression precision = 2; - if (this->_internal_has_precision()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::precision(this), target, stream); - } - - // uint32 variation_pointer = 3; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 4, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionDecimal) - return target; -} - -size_t DerivationExpression_ExpressionDecimal::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionDecimal) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.DerivationExpression scale = 1; - if (this->_internal_has_scale()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *scale_); - } - - // .substrait.DerivationExpression precision = 2; - if (this->_internal_has_precision()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *precision_); - } - - // uint32 variation_pointer = 3; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionDecimal::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_ExpressionDecimal::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionDecimal::GetClassData() const { return &_class_data_; } - -void DerivationExpression_ExpressionDecimal::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_ExpressionDecimal::MergeFrom(const DerivationExpression_ExpressionDecimal& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionDecimal) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_scale()) { - _internal_mutable_scale()->::substrait::DerivationExpression::MergeFrom(from._internal_scale()); - } - if (from._internal_has_precision()) { - _internal_mutable_precision()->::substrait::DerivationExpression::MergeFrom(from._internal_precision()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_ExpressionDecimal::CopyFrom(const DerivationExpression_ExpressionDecimal& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionDecimal) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_ExpressionDecimal::IsInitialized() const { - return true; -} - -void DerivationExpression_ExpressionDecimal::InternalSwap(DerivationExpression_ExpressionDecimal* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionDecimal, nullability_) - + sizeof(DerivationExpression_ExpressionDecimal::nullability_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionDecimal, scale_)>( - reinterpret_cast(&scale_), - reinterpret_cast(&other->scale_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionDecimal::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[3]); -} - -// =================================================================== - -class DerivationExpression_ExpressionStruct::_Internal { - public: -}; - -DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - types_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionStruct) -} -DerivationExpression_ExpressionStruct::DerivationExpression_ExpressionStruct(const DerivationExpression_ExpressionStruct& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - types_(from.types_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionStruct) -} - -inline void DerivationExpression_ExpressionStruct::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&variation_pointer_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); -} - -DerivationExpression_ExpressionStruct::~DerivationExpression_ExpressionStruct() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionStruct) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_ExpressionStruct::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); -} - -void DerivationExpression_ExpressionStruct::ArenaDtor(void* object) { - DerivationExpression_ExpressionStruct* _this = reinterpret_cast< DerivationExpression_ExpressionStruct* >(object); - (void)_this; -} -void DerivationExpression_ExpressionStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_ExpressionStruct::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_ExpressionStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionStruct) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - types_.Clear(); - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_ExpressionStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.DerivationExpression types = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_types(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* DerivationExpression_ExpressionStruct::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionStruct) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.DerivationExpression types = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_types_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_types(i), target, stream); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionStruct) - return target; -} - -size_t DerivationExpression_ExpressionStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionStruct) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.DerivationExpression types = 1; - total_size += 1UL * this->_internal_types_size(); - for (const auto& msg : this->types_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionStruct::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_ExpressionStruct::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionStruct::GetClassData() const { return &_class_data_; } - -void DerivationExpression_ExpressionStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_ExpressionStruct::MergeFrom(const DerivationExpression_ExpressionStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionStruct) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - types_.MergeFrom(from.types_); - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_ExpressionStruct::CopyFrom(const DerivationExpression_ExpressionStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_ExpressionStruct::IsInitialized() const { - return true; -} - -void DerivationExpression_ExpressionStruct::InternalSwap(DerivationExpression_ExpressionStruct* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - types_.InternalSwap(&other->types_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, nullability_) - + sizeof(DerivationExpression_ExpressionStruct::nullability_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionStruct, variation_pointer_)>( - reinterpret_cast(&variation_pointer_), - reinterpret_cast(&other->variation_pointer_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionStruct::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[4]); -} - -// =================================================================== - -class DerivationExpression_ExpressionNamedStruct::_Internal { - public: - static const ::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression_ExpressionNamedStruct* msg); -}; - -const ::substrait::DerivationExpression_ExpressionStruct& -DerivationExpression_ExpressionNamedStruct::_Internal::struct_(const DerivationExpression_ExpressionNamedStruct* msg) { - return *msg->struct__; -} -DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - names_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionNamedStruct) -} -DerivationExpression_ExpressionNamedStruct::DerivationExpression_ExpressionNamedStruct(const DerivationExpression_ExpressionNamedStruct& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - names_(from.names_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_struct_()) { - struct__ = new ::substrait::DerivationExpression_ExpressionStruct(*from.struct__); - } else { - struct__ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionNamedStruct) -} - -inline void DerivationExpression_ExpressionNamedStruct::SharedCtor() { -struct__ = nullptr; -} - -DerivationExpression_ExpressionNamedStruct::~DerivationExpression_ExpressionNamedStruct() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionNamedStruct) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_ExpressionNamedStruct::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete struct__; -} - -void DerivationExpression_ExpressionNamedStruct::ArenaDtor(void* object) { - DerivationExpression_ExpressionNamedStruct* _this = reinterpret_cast< DerivationExpression_ExpressionNamedStruct* >(object); - (void)_this; -} -void DerivationExpression_ExpressionNamedStruct::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_ExpressionNamedStruct::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_ExpressionNamedStruct::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionNamedStruct) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - names_.Clear(); - if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { - delete struct__; - } - struct__ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_ExpressionNamedStruct::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated string names = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - auto str = _internal_add_names(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.ExpressionNamedStruct.names")); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.ExpressionStruct struct = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DerivationExpression_ExpressionNamedStruct::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionNamedStruct) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated string names = 1; - for (int i = 0, n = this->_internal_names_size(); i < n; i++) { - const auto& s = this->_internal_names(i); - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.DerivationExpression.ExpressionNamedStruct.names"); - target = stream->WriteString(1, s, target); - } - - // .substrait.DerivationExpression.ExpressionStruct struct = 2; - if (this->_internal_has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::struct_(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionNamedStruct) - return target; -} - -size_t DerivationExpression_ExpressionNamedStruct::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionNamedStruct) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated string names = 1; - total_size += 1 * - ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(names_.size()); - for (int i = 0, n = names_.size(); i < n; i++) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - names_.Get(i)); - } - - // .substrait.DerivationExpression.ExpressionStruct struct = 2; - if (this->_internal_has_struct_()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *struct__); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionNamedStruct::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_ExpressionNamedStruct::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionNamedStruct::GetClassData() const { return &_class_data_; } - -void DerivationExpression_ExpressionNamedStruct::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_ExpressionNamedStruct::MergeFrom(const DerivationExpression_ExpressionNamedStruct& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionNamedStruct) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - names_.MergeFrom(from.names_); - if (from._internal_has_struct_()) { - _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_ExpressionNamedStruct::CopyFrom(const DerivationExpression_ExpressionNamedStruct& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionNamedStruct) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_ExpressionNamedStruct::IsInitialized() const { - return true; -} - -void DerivationExpression_ExpressionNamedStruct::InternalSwap(DerivationExpression_ExpressionNamedStruct* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - names_.InternalSwap(&other->names_); - swap(struct__, other->struct__); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionNamedStruct::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[5]); -} - -// =================================================================== - -class DerivationExpression_ExpressionList::_Internal { - public: - static const ::substrait::DerivationExpression& type(const DerivationExpression_ExpressionList* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_ExpressionList::_Internal::type(const DerivationExpression_ExpressionList* msg) { - return *msg->type_; -} -DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionList) -} -DerivationExpression_ExpressionList::DerivationExpression_ExpressionList(const DerivationExpression_ExpressionList& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_type()) { - type_ = new ::substrait::DerivationExpression(*from.type_); - } else { - type_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionList) -} - -inline void DerivationExpression_ExpressionList::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&type_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&type_)) + sizeof(nullability_)); -} - -DerivationExpression_ExpressionList::~DerivationExpression_ExpressionList() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionList) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_ExpressionList::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete type_; -} - -void DerivationExpression_ExpressionList::ArenaDtor(void* object) { - DerivationExpression_ExpressionList* _this = reinterpret_cast< DerivationExpression_ExpressionList* >(object); - (void)_this; -} -void DerivationExpression_ExpressionList::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_ExpressionList::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_ExpressionList::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionList) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_ExpressionList::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.DerivationExpression type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_type(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 16)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* DerivationExpression_ExpressionList::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionList) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.DerivationExpression type = 1; - if (this->_internal_has_type()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::type(this), target, stream); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 3, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionList) - return target; -} - -size_t DerivationExpression_ExpressionList::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionList) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.DerivationExpression type = 1; - if (this->_internal_has_type()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *type_); - } - - // uint32 variation_pointer = 2; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 3; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionList::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_ExpressionList::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionList::GetClassData() const { return &_class_data_; } - -void DerivationExpression_ExpressionList::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_ExpressionList::MergeFrom(const DerivationExpression_ExpressionList& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionList) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_type()) { - _internal_mutable_type()->::substrait::DerivationExpression::MergeFrom(from._internal_type()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_ExpressionList::CopyFrom(const DerivationExpression_ExpressionList& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionList) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_ExpressionList::IsInitialized() const { - return true; -} - -void DerivationExpression_ExpressionList::InternalSwap(DerivationExpression_ExpressionList* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionList, nullability_) - + sizeof(DerivationExpression_ExpressionList::nullability_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionList, type_)>( - reinterpret_cast(&type_), - reinterpret_cast(&other->type_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionList::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[6]); -} - -// =================================================================== - -class DerivationExpression_ExpressionMap::_Internal { - public: - static const ::substrait::DerivationExpression& key(const DerivationExpression_ExpressionMap* msg); - static const ::substrait::DerivationExpression& value(const DerivationExpression_ExpressionMap* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_ExpressionMap::_Internal::key(const DerivationExpression_ExpressionMap* msg) { - return *msg->key_; -} -const ::substrait::DerivationExpression& -DerivationExpression_ExpressionMap::_Internal::value(const DerivationExpression_ExpressionMap* msg) { - return *msg->value_; -} -DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ExpressionMap) -} -DerivationExpression_ExpressionMap::DerivationExpression_ExpressionMap(const DerivationExpression_ExpressionMap& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_key()) { - key_ = new ::substrait::DerivationExpression(*from.key_); - } else { - key_ = nullptr; - } - if (from._internal_has_value()) { - value_ = new ::substrait::DerivationExpression(*from.value_); - } else { - value_ = nullptr; - } - ::memcpy(&variation_pointer_, &from.variation_pointer_, - static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ExpressionMap) -} - -inline void DerivationExpression_ExpressionMap::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&key_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&nullability_) - - reinterpret_cast(&key_)) + sizeof(nullability_)); -} - -DerivationExpression_ExpressionMap::~DerivationExpression_ExpressionMap() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ExpressionMap) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_ExpressionMap::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete key_; - if (this != internal_default_instance()) delete value_; -} - -void DerivationExpression_ExpressionMap::ArenaDtor(void* object) { - DerivationExpression_ExpressionMap* _this = reinterpret_cast< DerivationExpression_ExpressionMap* >(object); - (void)_this; -} -void DerivationExpression_ExpressionMap::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_ExpressionMap::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_ExpressionMap::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ExpressionMap) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && key_ != nullptr) { - delete key_; - } - key_ = nullptr; - if (GetArenaForAllocation() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; - ::memset(&variation_pointer_, 0, static_cast( - reinterpret_cast(&nullability_) - - reinterpret_cast(&variation_pointer_)) + sizeof(nullability_)); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_ExpressionMap::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.DerivationExpression key = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_key(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression value = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_value(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 variation_pointer = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - variation_pointer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Nullability nullability = 4; - case 4: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 32)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_nullability(static_cast<::substrait::Type_Nullability>(val)); - } 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* DerivationExpression_ExpressionMap::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ExpressionMap) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.DerivationExpression key = 1; - if (this->_internal_has_key()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::key(this), target, stream); - } - - // .substrait.DerivationExpression value = 2; - if (this->_internal_has_value()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::value(this), target, stream); - } - - // uint32 variation_pointer = 3; - if (this->_internal_variation_pointer() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variation_pointer(), target); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 4, this->_internal_nullability(), target); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ExpressionMap) - return target; -} - -size_t DerivationExpression_ExpressionMap::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ExpressionMap) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.DerivationExpression key = 1; - if (this->_internal_has_key()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *key_); - } - - // .substrait.DerivationExpression value = 2; - if (this->_internal_has_value()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *value_); - } - - // uint32 variation_pointer = 3; - if (this->_internal_variation_pointer() != 0) { - total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_variation_pointer()); - } - - // .substrait.Type.Nullability nullability = 4; - if (this->_internal_nullability() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_nullability()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ExpressionMap::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_ExpressionMap::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ExpressionMap::GetClassData() const { return &_class_data_; } - -void DerivationExpression_ExpressionMap::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_ExpressionMap::MergeFrom(const DerivationExpression_ExpressionMap& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ExpressionMap) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_key()) { - _internal_mutable_key()->::substrait::DerivationExpression::MergeFrom(from._internal_key()); - } - if (from._internal_has_value()) { - _internal_mutable_value()->::substrait::DerivationExpression::MergeFrom(from._internal_value()); - } - if (from._internal_variation_pointer() != 0) { - _internal_set_variation_pointer(from._internal_variation_pointer()); - } - if (from._internal_nullability() != 0) { - _internal_set_nullability(from._internal_nullability()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_ExpressionMap::CopyFrom(const DerivationExpression_ExpressionMap& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ExpressionMap) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_ExpressionMap::IsInitialized() const { - return true; -} - -void DerivationExpression_ExpressionMap::InternalSwap(DerivationExpression_ExpressionMap* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionMap, nullability_) - + sizeof(DerivationExpression_ExpressionMap::nullability_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_ExpressionMap, key_)>( - reinterpret_cast(&key_), - reinterpret_cast(&other->key_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ExpressionMap::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[7]); -} - -// =================================================================== - -class DerivationExpression_IfElse::_Internal { - public: - static const ::substrait::DerivationExpression& if_condition(const DerivationExpression_IfElse* msg); - static const ::substrait::DerivationExpression& if_return(const DerivationExpression_IfElse* msg); - static const ::substrait::DerivationExpression& else_return(const DerivationExpression_IfElse* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_IfElse::_Internal::if_condition(const DerivationExpression_IfElse* msg) { - return *msg->if_condition_; -} -const ::substrait::DerivationExpression& -DerivationExpression_IfElse::_Internal::if_return(const DerivationExpression_IfElse* msg) { - return *msg->if_return_; -} -const ::substrait::DerivationExpression& -DerivationExpression_IfElse::_Internal::else_return(const DerivationExpression_IfElse* msg) { - return *msg->else_return_; -} -DerivationExpression_IfElse::DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.IfElse) -} -DerivationExpression_IfElse::DerivationExpression_IfElse(const DerivationExpression_IfElse& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_if_condition()) { - if_condition_ = new ::substrait::DerivationExpression(*from.if_condition_); - } else { - if_condition_ = nullptr; - } - if (from._internal_has_if_return()) { - if_return_ = new ::substrait::DerivationExpression(*from.if_return_); - } else { - if_return_ = nullptr; - } - if (from._internal_has_else_return()) { - else_return_ = new ::substrait::DerivationExpression(*from.else_return_); - } else { - else_return_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.IfElse) -} - -inline void DerivationExpression_IfElse::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&if_condition_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&else_return_) - - reinterpret_cast(&if_condition_)) + sizeof(else_return_)); -} - -DerivationExpression_IfElse::~DerivationExpression_IfElse() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.IfElse) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_IfElse::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete if_condition_; - if (this != internal_default_instance()) delete if_return_; - if (this != internal_default_instance()) delete else_return_; -} - -void DerivationExpression_IfElse::ArenaDtor(void* object) { - DerivationExpression_IfElse* _this = reinterpret_cast< DerivationExpression_IfElse* >(object); - (void)_this; -} -void DerivationExpression_IfElse::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_IfElse::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_IfElse::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.IfElse) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && if_condition_ != nullptr) { - delete if_condition_; - } - if_condition_ = nullptr; - if (GetArenaForAllocation() == nullptr && if_return_ != nullptr) { - delete if_return_; - } - if_return_ = nullptr; - if (GetArenaForAllocation() == nullptr && else_return_ != nullptr) { - delete else_return_; - } - else_return_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_IfElse::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.DerivationExpression if_condition = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_if_condition(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression if_return = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_if_return(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression else_return = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_else_return(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DerivationExpression_IfElse::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.IfElse) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.DerivationExpression if_condition = 1; - if (this->_internal_has_if_condition()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::if_condition(this), target, stream); - } - - // .substrait.DerivationExpression if_return = 2; - if (this->_internal_has_if_return()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::if_return(this), target, stream); - } - - // .substrait.DerivationExpression else_return = 3; - if (this->_internal_has_else_return()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::else_return(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.IfElse) - return target; -} - -size_t DerivationExpression_IfElse::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.IfElse) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.DerivationExpression if_condition = 1; - if (this->_internal_has_if_condition()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *if_condition_); - } - - // .substrait.DerivationExpression if_return = 2; - if (this->_internal_has_if_return()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *if_return_); - } - - // .substrait.DerivationExpression else_return = 3; - if (this->_internal_has_else_return()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *else_return_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_IfElse::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_IfElse::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_IfElse::GetClassData() const { return &_class_data_; } - -void DerivationExpression_IfElse::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_IfElse::MergeFrom(const DerivationExpression_IfElse& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.IfElse) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_if_condition()) { - _internal_mutable_if_condition()->::substrait::DerivationExpression::MergeFrom(from._internal_if_condition()); - } - if (from._internal_has_if_return()) { - _internal_mutable_if_return()->::substrait::DerivationExpression::MergeFrom(from._internal_if_return()); - } - if (from._internal_has_else_return()) { - _internal_mutable_else_return()->::substrait::DerivationExpression::MergeFrom(from._internal_else_return()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_IfElse::CopyFrom(const DerivationExpression_IfElse& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.IfElse) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_IfElse::IsInitialized() const { - return true; -} - -void DerivationExpression_IfElse::InternalSwap(DerivationExpression_IfElse* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DerivationExpression_IfElse, else_return_) - + sizeof(DerivationExpression_IfElse::else_return_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_IfElse, if_condition_)>( - reinterpret_cast(&if_condition_), - reinterpret_cast(&other->if_condition_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_IfElse::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[8]); -} - -// =================================================================== - -class DerivationExpression_UnaryOp::_Internal { - public: - static const ::substrait::DerivationExpression& arg(const DerivationExpression_UnaryOp* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_UnaryOp::_Internal::arg(const DerivationExpression_UnaryOp* msg) { - return *msg->arg_; -} -DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.UnaryOp) -} -DerivationExpression_UnaryOp::DerivationExpression_UnaryOp(const DerivationExpression_UnaryOp& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_arg()) { - arg_ = new ::substrait::DerivationExpression(*from.arg_); - } else { - arg_ = nullptr; - } - op_type_ = from.op_type_; - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.UnaryOp) -} - -inline void DerivationExpression_UnaryOp::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&arg_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&op_type_) - - reinterpret_cast(&arg_)) + sizeof(op_type_)); -} - -DerivationExpression_UnaryOp::~DerivationExpression_UnaryOp() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.UnaryOp) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_UnaryOp::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete arg_; -} - -void DerivationExpression_UnaryOp::ArenaDtor(void* object) { - DerivationExpression_UnaryOp* _this = reinterpret_cast< DerivationExpression_UnaryOp* >(object); - (void)_this; -} -void DerivationExpression_UnaryOp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_UnaryOp::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_UnaryOp::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.UnaryOp) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && arg_ != nullptr) { - delete arg_; - } - arg_ = nullptr; - op_type_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_UnaryOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_op_type(static_cast<::substrait::DerivationExpression_UnaryOp_UnaryOpType>(val)); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression arg = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_arg(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DerivationExpression_UnaryOp::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.UnaryOp) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; - if (this->_internal_op_type() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 1, this->_internal_op_type(), target); - } - - // .substrait.DerivationExpression arg = 2; - if (this->_internal_has_arg()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::arg(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.UnaryOp) - return target; -} - -size_t DerivationExpression_UnaryOp::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.UnaryOp) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.DerivationExpression arg = 2; - if (this->_internal_has_arg()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *arg_); - } - - // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; - if (this->_internal_op_type() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_UnaryOp::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_UnaryOp::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_UnaryOp::GetClassData() const { return &_class_data_; } - -void DerivationExpression_UnaryOp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_UnaryOp::MergeFrom(const DerivationExpression_UnaryOp& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.UnaryOp) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_arg()) { - _internal_mutable_arg()->::substrait::DerivationExpression::MergeFrom(from._internal_arg()); - } - if (from._internal_op_type() != 0) { - _internal_set_op_type(from._internal_op_type()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_UnaryOp::CopyFrom(const DerivationExpression_UnaryOp& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.UnaryOp) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_UnaryOp::IsInitialized() const { - return true; -} - -void DerivationExpression_UnaryOp::InternalSwap(DerivationExpression_UnaryOp* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DerivationExpression_UnaryOp, op_type_) - + sizeof(DerivationExpression_UnaryOp::op_type_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_UnaryOp, arg_)>( - reinterpret_cast(&arg_), - reinterpret_cast(&other->arg_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_UnaryOp::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[9]); -} - -// =================================================================== - -class DerivationExpression_BinaryOp::_Internal { - public: - static const ::substrait::DerivationExpression& arg1(const DerivationExpression_BinaryOp* msg); - static const ::substrait::DerivationExpression& arg2(const DerivationExpression_BinaryOp* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_BinaryOp::_Internal::arg1(const DerivationExpression_BinaryOp* msg) { - return *msg->arg1_; -} -const ::substrait::DerivationExpression& -DerivationExpression_BinaryOp::_Internal::arg2(const DerivationExpression_BinaryOp* msg) { - return *msg->arg2_; -} -DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.BinaryOp) -} -DerivationExpression_BinaryOp::DerivationExpression_BinaryOp(const DerivationExpression_BinaryOp& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_arg1()) { - arg1_ = new ::substrait::DerivationExpression(*from.arg1_); - } else { - arg1_ = nullptr; - } - if (from._internal_has_arg2()) { - arg2_ = new ::substrait::DerivationExpression(*from.arg2_); - } else { - arg2_ = nullptr; - } - op_type_ = from.op_type_; - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.BinaryOp) -} - -inline void DerivationExpression_BinaryOp::SharedCtor() { -::memset(reinterpret_cast(this) + static_cast( - reinterpret_cast(&arg1_) - reinterpret_cast(this)), - 0, static_cast(reinterpret_cast(&op_type_) - - reinterpret_cast(&arg1_)) + sizeof(op_type_)); -} - -DerivationExpression_BinaryOp::~DerivationExpression_BinaryOp() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.BinaryOp) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_BinaryOp::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete arg1_; - if (this != internal_default_instance()) delete arg2_; -} - -void DerivationExpression_BinaryOp::ArenaDtor(void* object) { - DerivationExpression_BinaryOp* _this = reinterpret_cast< DerivationExpression_BinaryOp* >(object); - (void)_this; -} -void DerivationExpression_BinaryOp::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_BinaryOp::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_BinaryOp::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.BinaryOp) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaForAllocation() == nullptr && arg1_ != nullptr) { - delete arg1_; - } - arg1_ = nullptr; - if (GetArenaForAllocation() == nullptr && arg2_ != nullptr) { - delete arg2_; - } - arg2_ = nullptr; - op_type_ = 0; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_BinaryOp::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 8)) { - uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); - CHK_(ptr); - _internal_set_op_type(static_cast<::substrait::DerivationExpression_BinaryOp_BinaryOpType>(val)); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression arg1 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_arg1(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression arg2 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_arg2(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DerivationExpression_BinaryOp::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.BinaryOp) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; - if (this->_internal_op_type() != 0) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray( - 1, this->_internal_op_type(), target); - } - - // .substrait.DerivationExpression arg1 = 2; - if (this->_internal_has_arg1()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::arg1(this), target, stream); - } - - // .substrait.DerivationExpression arg2 = 3; - if (this->_internal_has_arg2()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::arg2(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.BinaryOp) - return target; -} - -size_t DerivationExpression_BinaryOp::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.BinaryOp) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // .substrait.DerivationExpression arg1 = 2; - if (this->_internal_has_arg1()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *arg1_); - } - - // .substrait.DerivationExpression arg2 = 3; - if (this->_internal_has_arg2()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *arg2_); - } - - // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; - if (this->_internal_op_type() != 0) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_op_type()); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_BinaryOp::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_BinaryOp::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_BinaryOp::GetClassData() const { return &_class_data_; } - -void DerivationExpression_BinaryOp::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_BinaryOp::MergeFrom(const DerivationExpression_BinaryOp& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.BinaryOp) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_has_arg1()) { - _internal_mutable_arg1()->::substrait::DerivationExpression::MergeFrom(from._internal_arg1()); - } - if (from._internal_has_arg2()) { - _internal_mutable_arg2()->::substrait::DerivationExpression::MergeFrom(from._internal_arg2()); - } - if (from._internal_op_type() != 0) { - _internal_set_op_type(from._internal_op_type()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_BinaryOp::CopyFrom(const DerivationExpression_BinaryOp& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.BinaryOp) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_BinaryOp::IsInitialized() const { - return true; -} - -void DerivationExpression_BinaryOp::InternalSwap(DerivationExpression_BinaryOp* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::PROTOBUF_NAMESPACE_ID::internal::memswap< - PROTOBUF_FIELD_OFFSET(DerivationExpression_BinaryOp, op_type_) - + sizeof(DerivationExpression_BinaryOp::op_type_) - - PROTOBUF_FIELD_OFFSET(DerivationExpression_BinaryOp, arg1_)>( - reinterpret_cast(&arg1_), - reinterpret_cast(&other->arg1_)); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_BinaryOp::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[10]); -} - -// =================================================================== - -class DerivationExpression_ReturnProgram_Assignment::_Internal { - public: - static const ::substrait::DerivationExpression& expression(const DerivationExpression_ReturnProgram_Assignment* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_ReturnProgram_Assignment::_Internal::expression(const DerivationExpression_ReturnProgram_Assignment* msg) { - return *msg->expression_; -} -DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ReturnProgram.Assignment) -} -DerivationExpression_ReturnProgram_Assignment::DerivationExpression_ReturnProgram_Assignment(const DerivationExpression_ReturnProgram_Assignment& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (!from._internal_name().empty()) { - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), - GetArenaForAllocation()); - } - if (from._internal_has_expression()) { - expression_ = new ::substrait::DerivationExpression(*from.expression_); - } else { - expression_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ReturnProgram.Assignment) -} - -inline void DerivationExpression_ReturnProgram_Assignment::SharedCtor() { -name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING -expression_ = nullptr; -} - -DerivationExpression_ReturnProgram_Assignment::~DerivationExpression_ReturnProgram_Assignment() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ReturnProgram.Assignment) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_ReturnProgram_Assignment::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - if (this != internal_default_instance()) delete expression_; -} - -void DerivationExpression_ReturnProgram_Assignment::ArenaDtor(void* object) { - DerivationExpression_ReturnProgram_Assignment* _this = reinterpret_cast< DerivationExpression_ReturnProgram_Assignment* >(object); - (void)_this; -} -void DerivationExpression_ReturnProgram_Assignment::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_ReturnProgram_Assignment::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_ReturnProgram_Assignment::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ReturnProgram.Assignment) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmpty(); - if (GetArenaForAllocation() == nullptr && expression_ != nullptr) { - delete expression_; - } - expression_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_ReturnProgram_Assignment::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // string name = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.ReturnProgram.Assignment.name")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression expression = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_expression(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DerivationExpression_ReturnProgram_Assignment::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ReturnProgram.Assignment) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // string name = 1; - if (!this->_internal_name().empty()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_name().data(), static_cast(this->_internal_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.DerivationExpression.ReturnProgram.Assignment.name"); - target = stream->WriteStringMaybeAliased( - 1, this->_internal_name(), target); - } - - // .substrait.DerivationExpression expression = 2; - if (this->_internal_has_expression()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::expression(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ReturnProgram.Assignment) - return target; -} - -size_t DerivationExpression_ReturnProgram_Assignment::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ReturnProgram.Assignment) - 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 name = 1; - if (!this->_internal_name().empty()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_name()); - } - - // .substrait.DerivationExpression expression = 2; - if (this->_internal_has_expression()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *expression_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ReturnProgram_Assignment::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_ReturnProgram_Assignment::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ReturnProgram_Assignment::GetClassData() const { return &_class_data_; } - -void DerivationExpression_ReturnProgram_Assignment::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_ReturnProgram_Assignment::MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ReturnProgram.Assignment) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_name().empty()) { - _internal_set_name(from._internal_name()); - } - if (from._internal_has_expression()) { - _internal_mutable_expression()->::substrait::DerivationExpression::MergeFrom(from._internal_expression()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_ReturnProgram_Assignment::CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ReturnProgram.Assignment) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_ReturnProgram_Assignment::IsInitialized() const { - return true; -} - -void DerivationExpression_ReturnProgram_Assignment::InternalSwap(DerivationExpression_ReturnProgram_Assignment* 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( - &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), - &name_, lhs_arena, - &other->name_, rhs_arena - ); - swap(expression_, other->expression_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ReturnProgram_Assignment::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[11]); -} - -// =================================================================== - -class DerivationExpression_ReturnProgram::_Internal { - public: - static const ::substrait::DerivationExpression& final_expression(const DerivationExpression_ReturnProgram* msg); -}; - -const ::substrait::DerivationExpression& -DerivationExpression_ReturnProgram::_Internal::final_expression(const DerivationExpression_ReturnProgram* msg) { - return *msg->final_expression_; -} -DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned), - assignments_(arena) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression.ReturnProgram) -} -DerivationExpression_ReturnProgram::DerivationExpression_ReturnProgram(const DerivationExpression_ReturnProgram& from) - : ::PROTOBUF_NAMESPACE_ID::Message(), - assignments_(from.assignments_) { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - if (from._internal_has_final_expression()) { - final_expression_ = new ::substrait::DerivationExpression(*from.final_expression_); - } else { - final_expression_ = nullptr; - } - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression.ReturnProgram) -} - -inline void DerivationExpression_ReturnProgram::SharedCtor() { -final_expression_ = nullptr; -} - -DerivationExpression_ReturnProgram::~DerivationExpression_ReturnProgram() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression.ReturnProgram) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression_ReturnProgram::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (this != internal_default_instance()) delete final_expression_; -} - -void DerivationExpression_ReturnProgram::ArenaDtor(void* object) { - DerivationExpression_ReturnProgram* _this = reinterpret_cast< DerivationExpression_ReturnProgram* >(object); - (void)_this; -} -void DerivationExpression_ReturnProgram::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression_ReturnProgram::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression_ReturnProgram::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression.ReturnProgram) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - assignments_.Clear(); - if (GetArenaForAllocation() == nullptr && final_expression_ != nullptr) { - delete final_expression_; - } - final_expression_ = nullptr; - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression_ReturnProgram::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr -= 1; - do { - ptr += 1; - ptr = ctx->ParseMessage(_internal_add_assignments(), ptr); - CHK_(ptr); - if (!ctx->DataAvailable(ptr)) break; - } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression final_expression = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_final_expression(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DerivationExpression_ReturnProgram::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression.ReturnProgram) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; - for (unsigned int i = 0, - n = static_cast(this->_internal_assignments_size()); i < n; i++) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage(1, this->_internal_assignments(i), target, stream); - } - - // .substrait.DerivationExpression final_expression = 2; - if (this->_internal_has_final_expression()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::final_expression(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression.ReturnProgram) - return target; -} - -size_t DerivationExpression_ReturnProgram::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression.ReturnProgram) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; - total_size += 1UL * this->_internal_assignments_size(); - for (const auto& msg : this->assignments_) { - total_size += - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); - } - - // .substrait.DerivationExpression final_expression = 2; - if (this->_internal_has_final_expression()) { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *final_expression_); - } - - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression_ReturnProgram::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression_ReturnProgram::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression_ReturnProgram::GetClassData() const { return &_class_data_; } - -void DerivationExpression_ReturnProgram::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression_ReturnProgram::MergeFrom(const DerivationExpression_ReturnProgram& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression.ReturnProgram) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - assignments_.MergeFrom(from.assignments_); - if (from._internal_has_final_expression()) { - _internal_mutable_final_expression()->::substrait::DerivationExpression::MergeFrom(from._internal_final_expression()); - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression_ReturnProgram::CopyFrom(const DerivationExpression_ReturnProgram& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression.ReturnProgram) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression_ReturnProgram::IsInitialized() const { - return true; -} - -void DerivationExpression_ReturnProgram::InternalSwap(DerivationExpression_ReturnProgram* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - assignments_.InternalSwap(&other->assignments_); - swap(final_expression_, other->final_expression_); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression_ReturnProgram::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[12]); -} - -// =================================================================== - -class DerivationExpression::_Internal { - public: - static const ::substrait::Type_Boolean& bool_(const DerivationExpression* msg); - static const ::substrait::Type_I8& i8(const DerivationExpression* msg); - static const ::substrait::Type_I16& i16(const DerivationExpression* msg); - static const ::substrait::Type_I32& i32(const DerivationExpression* msg); - static const ::substrait::Type_I64& i64(const DerivationExpression* msg); - static const ::substrait::Type_FP32& fp32(const DerivationExpression* msg); - static const ::substrait::Type_FP64& fp64(const DerivationExpression* msg); - static const ::substrait::Type_String& string(const DerivationExpression* msg); - static const ::substrait::Type_Binary& binary(const DerivationExpression* msg); - static const ::substrait::Type_Timestamp& timestamp(const DerivationExpression* msg); - static const ::substrait::Type_Date& date(const DerivationExpression* msg); - static const ::substrait::Type_Time& time(const DerivationExpression* msg); - static const ::substrait::Type_IntervalYear& interval_year(const DerivationExpression* msg); - static const ::substrait::Type_IntervalDay& interval_day(const DerivationExpression* msg); - static const ::substrait::Type_TimestampTZ& timestamp_tz(const DerivationExpression* msg); - static const ::substrait::Type_UUID& uuid(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_ExpressionFixedChar& fixed_char(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_ExpressionVarChar& varchar(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_ExpressionDecimal& decimal(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_ExpressionStruct& struct_(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_ExpressionList& list(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_ExpressionMap& map(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_UnaryOp& unary_op(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_BinaryOp& binary_op(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_IfElse& if_else(const DerivationExpression* msg); - static const ::substrait::DerivationExpression_ReturnProgram& return_program(const DerivationExpression* msg); -}; - -const ::substrait::Type_Boolean& -DerivationExpression::_Internal::bool_(const DerivationExpression* msg) { - return *msg->kind_.bool__; -} -const ::substrait::Type_I8& -DerivationExpression::_Internal::i8(const DerivationExpression* msg) { - return *msg->kind_.i8_; -} -const ::substrait::Type_I16& -DerivationExpression::_Internal::i16(const DerivationExpression* msg) { - return *msg->kind_.i16_; -} -const ::substrait::Type_I32& -DerivationExpression::_Internal::i32(const DerivationExpression* msg) { - return *msg->kind_.i32_; -} -const ::substrait::Type_I64& -DerivationExpression::_Internal::i64(const DerivationExpression* msg) { - return *msg->kind_.i64_; -} -const ::substrait::Type_FP32& -DerivationExpression::_Internal::fp32(const DerivationExpression* msg) { - return *msg->kind_.fp32_; -} -const ::substrait::Type_FP64& -DerivationExpression::_Internal::fp64(const DerivationExpression* msg) { - return *msg->kind_.fp64_; -} -const ::substrait::Type_String& -DerivationExpression::_Internal::string(const DerivationExpression* msg) { - return *msg->kind_.string_; -} -const ::substrait::Type_Binary& -DerivationExpression::_Internal::binary(const DerivationExpression* msg) { - return *msg->kind_.binary_; -} -const ::substrait::Type_Timestamp& -DerivationExpression::_Internal::timestamp(const DerivationExpression* msg) { - return *msg->kind_.timestamp_; -} -const ::substrait::Type_Date& -DerivationExpression::_Internal::date(const DerivationExpression* msg) { - return *msg->kind_.date_; -} -const ::substrait::Type_Time& -DerivationExpression::_Internal::time(const DerivationExpression* msg) { - return *msg->kind_.time_; -} -const ::substrait::Type_IntervalYear& -DerivationExpression::_Internal::interval_year(const DerivationExpression* msg) { - return *msg->kind_.interval_year_; -} -const ::substrait::Type_IntervalDay& -DerivationExpression::_Internal::interval_day(const DerivationExpression* msg) { - return *msg->kind_.interval_day_; -} -const ::substrait::Type_TimestampTZ& -DerivationExpression::_Internal::timestamp_tz(const DerivationExpression* msg) { - return *msg->kind_.timestamp_tz_; -} -const ::substrait::Type_UUID& -DerivationExpression::_Internal::uuid(const DerivationExpression* msg) { - return *msg->kind_.uuid_; -} -const ::substrait::DerivationExpression_ExpressionFixedChar& -DerivationExpression::_Internal::fixed_char(const DerivationExpression* msg) { - return *msg->kind_.fixed_char_; -} -const ::substrait::DerivationExpression_ExpressionVarChar& -DerivationExpression::_Internal::varchar(const DerivationExpression* msg) { - return *msg->kind_.varchar_; -} -const ::substrait::DerivationExpression_ExpressionFixedBinary& -DerivationExpression::_Internal::fixed_binary(const DerivationExpression* msg) { - return *msg->kind_.fixed_binary_; -} -const ::substrait::DerivationExpression_ExpressionDecimal& -DerivationExpression::_Internal::decimal(const DerivationExpression* msg) { - return *msg->kind_.decimal_; -} -const ::substrait::DerivationExpression_ExpressionStruct& -DerivationExpression::_Internal::struct_(const DerivationExpression* msg) { - return *msg->kind_.struct__; -} -const ::substrait::DerivationExpression_ExpressionList& -DerivationExpression::_Internal::list(const DerivationExpression* msg) { - return *msg->kind_.list_; -} -const ::substrait::DerivationExpression_ExpressionMap& -DerivationExpression::_Internal::map(const DerivationExpression* msg) { - return *msg->kind_.map_; -} -const ::substrait::DerivationExpression_UnaryOp& -DerivationExpression::_Internal::unary_op(const DerivationExpression* msg) { - return *msg->kind_.unary_op_; -} -const ::substrait::DerivationExpression_BinaryOp& -DerivationExpression::_Internal::binary_op(const DerivationExpression* msg) { - return *msg->kind_.binary_op_; -} -const ::substrait::DerivationExpression_IfElse& -DerivationExpression::_Internal::if_else(const DerivationExpression* msg) { - return *msg->kind_.if_else_; -} -const ::substrait::DerivationExpression_ReturnProgram& -DerivationExpression::_Internal::return_program(const DerivationExpression* msg) { - return *msg->kind_.return_program_; -} -void DerivationExpression::set_allocated_bool_(::substrait::Type_Boolean* bool_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (bool_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(bool_)); - if (message_arena != submessage_arena) { - bool_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, bool_, submessage_arena); - } - set_has_bool_(); - kind_.bool__ = bool_; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.bool) -} -void DerivationExpression::clear_bool_() { - if (_internal_has_bool_()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.bool__; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_i8(::substrait::Type_I8* i8) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i8) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i8)); - if (message_arena != submessage_arena) { - i8 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i8, submessage_arena); - } - set_has_i8(); - kind_.i8_ = i8; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i8) -} -void DerivationExpression::clear_i8() { - if (_internal_has_i8()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i8_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_i16(::substrait::Type_I16* i16) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i16) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i16)); - if (message_arena != submessage_arena) { - i16 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i16, submessage_arena); - } - set_has_i16(); - kind_.i16_ = i16; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i16) -} -void DerivationExpression::clear_i16() { - if (_internal_has_i16()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i16_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_i32(::substrait::Type_I32* i32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i32) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i32)); - if (message_arena != submessage_arena) { - i32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i32, submessage_arena); - } - set_has_i32(); - kind_.i32_ = i32; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i32) -} -void DerivationExpression::clear_i32() { - if (_internal_has_i32()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i32_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_i64(::substrait::Type_I64* i64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (i64) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(i64)); - if (message_arena != submessage_arena) { - i64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, i64, submessage_arena); - } - set_has_i64(); - kind_.i64_ = i64; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.i64) -} -void DerivationExpression::clear_i64() { - if (_internal_has_i64()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i64_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_fp32(::substrait::Type_FP32* fp32) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fp32) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp32)); - if (message_arena != submessage_arena) { - fp32 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fp32, submessage_arena); - } - set_has_fp32(); - kind_.fp32_ = fp32; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fp32) -} -void DerivationExpression::clear_fp32() { - if (_internal_has_fp32()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp32_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_fp64(::substrait::Type_FP64* fp64) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fp64) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(fp64)); - if (message_arena != submessage_arena) { - fp64 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fp64, submessage_arena); - } - set_has_fp64(); - kind_.fp64_ = fp64; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fp64) -} -void DerivationExpression::clear_fp64() { - if (_internal_has_fp64()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp64_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_string(::substrait::Type_String* string) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (string) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(string)); - if (message_arena != submessage_arena) { - string = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, string, submessage_arena); - } - set_has_string(); - kind_.string_ = string; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.string) -} -void DerivationExpression::clear_string() { - if (_internal_has_string()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.string_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_binary(::substrait::Type_Binary* binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(binary)); - if (message_arena != submessage_arena) { - binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, binary, submessage_arena); - } - set_has_binary(); - kind_.binary_ = binary; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.binary) -} -void DerivationExpression::clear_binary() { - if (_internal_has_binary()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.binary_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (timestamp) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp)); - if (message_arena != submessage_arena) { - timestamp = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, timestamp, submessage_arena); - } - set_has_timestamp(); - kind_.timestamp_ = timestamp; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.timestamp) -} -void DerivationExpression::clear_timestamp() { - if (_internal_has_timestamp()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_date(::substrait::Type_Date* date) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (date) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(date)); - if (message_arena != submessage_arena) { - date = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, date, submessage_arena); - } - set_has_date(); - kind_.date_ = date; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.date) -} -void DerivationExpression::clear_date() { - if (_internal_has_date()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.date_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_time(::substrait::Type_Time* time) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (time) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(time)); - if (message_arena != submessage_arena) { - time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, time, submessage_arena); - } - set_has_time(); - kind_.time_ = time; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.time) -} -void DerivationExpression::clear_time() { - if (_internal_has_time()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.time_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (interval_year) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_year)); - if (message_arena != submessage_arena) { - interval_year = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interval_year, submessage_arena); - } - set_has_interval_year(); - kind_.interval_year_ = interval_year; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.interval_year) -} -void DerivationExpression::clear_interval_year() { - if (_internal_has_interval_year()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_year_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (interval_day) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_day)); - if (message_arena != submessage_arena) { - interval_day = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, interval_day, submessage_arena); - } - set_has_interval_day(); - kind_.interval_day_ = interval_day; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.interval_day) -} -void DerivationExpression::clear_interval_day() { - if (_internal_has_interval_day()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_day_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (timestamp_tz) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(timestamp_tz)); - if (message_arena != submessage_arena) { - timestamp_tz = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, timestamp_tz, submessage_arena); - } - set_has_timestamp_tz(); - kind_.timestamp_tz_ = timestamp_tz; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.timestamp_tz) -} -void DerivationExpression::clear_timestamp_tz() { - if (_internal_has_timestamp_tz()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_tz_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_uuid(::substrait::Type_UUID* uuid) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (uuid) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper< - ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena( - reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(uuid)); - if (message_arena != submessage_arena) { - uuid = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, uuid, submessage_arena); - } - set_has_uuid(); - kind_.uuid_ = uuid; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.uuid) -} -void DerivationExpression::clear_uuid() { - if (_internal_has_uuid()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.uuid_; - } - clear_has_kind(); - } -} -void DerivationExpression::set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fixed_char) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionFixedChar>::GetOwningArena(fixed_char); - if (message_arena != submessage_arena) { - fixed_char = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fixed_char, submessage_arena); - } - set_has_fixed_char(); - kind_.fixed_char_ = fixed_char; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fixed_char) -} -void DerivationExpression::set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (varchar) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionVarChar>::GetOwningArena(varchar); - if (message_arena != submessage_arena) { - varchar = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, varchar, submessage_arena); - } - set_has_varchar(); - kind_.varchar_ = varchar; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.varchar) -} -void DerivationExpression::set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (fixed_binary) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionFixedBinary>::GetOwningArena(fixed_binary); - if (message_arena != submessage_arena) { - fixed_binary = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, fixed_binary, submessage_arena); - } - set_has_fixed_binary(); - kind_.fixed_binary_ = fixed_binary; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.fixed_binary) -} -void DerivationExpression::set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (decimal) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionDecimal>::GetOwningArena(decimal); - if (message_arena != submessage_arena) { - decimal = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, decimal, submessage_arena); - } - set_has_decimal(); - kind_.decimal_ = decimal; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.decimal) -} -void DerivationExpression::set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionStruct>::GetOwningArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - set_has_struct_(); - kind_.struct__ = struct_; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.struct) -} -void DerivationExpression::set_allocated_list(::substrait::DerivationExpression_ExpressionList* list) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (list) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionList>::GetOwningArena(list); - if (message_arena != submessage_arena) { - list = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, list, submessage_arena); - } - set_has_list(); - kind_.list_ = list; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.list) -} -void DerivationExpression::set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (map) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionMap>::GetOwningArena(map); - if (message_arena != submessage_arena) { - map = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, map, submessage_arena); - } - set_has_map(); - kind_.map_ = map; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.map) -} -void DerivationExpression::set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (unary_op) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_UnaryOp>::GetOwningArena(unary_op); - if (message_arena != submessage_arena) { - unary_op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, unary_op, submessage_arena); - } - set_has_unary_op(); - kind_.unary_op_ = unary_op; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.unary_op) -} -void DerivationExpression::set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (binary_op) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_BinaryOp>::GetOwningArena(binary_op); - if (message_arena != submessage_arena) { - binary_op = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, binary_op, submessage_arena); - } - set_has_binary_op(); - kind_.binary_op_ = binary_op; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.binary_op) -} -void DerivationExpression::set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (if_else) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_IfElse>::GetOwningArena(if_else); - if (message_arena != submessage_arena) { - if_else = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, if_else, submessage_arena); - } - set_has_if_else(); - kind_.if_else_ = if_else; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.if_else) -} -void DerivationExpression::set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - clear_kind(); - if (return_program) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ReturnProgram>::GetOwningArena(return_program); - if (message_arena != submessage_arena) { - return_program = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, return_program, submessage_arena); - } - set_has_return_program(); - kind_.return_program_ = return_program; - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.return_program) -} -DerivationExpression::DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned) - : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { - SharedCtor(); - if (!is_message_owned) { - RegisterArenaDtor(arena); - } - // @@protoc_insertion_point(arena_constructor:substrait.DerivationExpression) -} -DerivationExpression::DerivationExpression(const DerivationExpression& from) - : ::PROTOBUF_NAMESPACE_ID::Message() { - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); - clear_has_kind(); - switch (from.kind_case()) { - case kBool: { - _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); - break; - } - case kI8: { - _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); - break; - } - case kI16: { - _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); - break; - } - case kI32: { - _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); - break; - } - case kI64: { - _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); - break; - } - case kFp32: { - _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); - break; - } - case kFp64: { - _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); - break; - } - case kString: { - _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); - break; - } - case kBinary: { - _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); - break; - } - case kTimestamp: { - _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); - break; - } - case kDate: { - _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); - break; - } - case kTime: { - _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); - break; - } - case kIntervalYear: { - _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); - break; - } - case kIntervalDay: { - _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); - break; - } - case kTimestampTz: { - _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); - break; - } - case kUuid: { - _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); - break; - } - case kFixedChar: { - _internal_mutable_fixed_char()->::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char()); - break; - } - case kVarchar: { - _internal_mutable_varchar()->::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar()); - break; - } - case kFixedBinary: { - _internal_mutable_fixed_binary()->::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary()); - break; - } - case kDecimal: { - _internal_mutable_decimal()->::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal()); - break; - } - case kStruct: { - _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); - break; - } - case kList: { - _internal_mutable_list()->::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list()); - break; - } - case kMap: { - _internal_mutable_map()->::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map()); - break; - } - case kUserDefinedPointer: { - _internal_set_user_defined_pointer(from._internal_user_defined_pointer()); - break; - } - case kTypeParameterName: { - _internal_set_type_parameter_name(from._internal_type_parameter_name()); - break; - } - case kIntegerParameterName: { - _internal_set_integer_parameter_name(from._internal_integer_parameter_name()); - break; - } - case kIntegerLiteral: { - _internal_set_integer_literal(from._internal_integer_literal()); - break; - } - case kUnaryOp: { - _internal_mutable_unary_op()->::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op()); - break; - } - case kBinaryOp: { - _internal_mutable_binary_op()->::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op()); - break; - } - case kIfElse: { - _internal_mutable_if_else()->::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else()); - break; - } - case kReturnProgram: { - _internal_mutable_return_program()->::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program()); - break; - } - case KIND_NOT_SET: { - break; - } - } - // @@protoc_insertion_point(copy_constructor:substrait.DerivationExpression) -} - -inline void DerivationExpression::SharedCtor() { -clear_has_kind(); -} - -DerivationExpression::~DerivationExpression() { - // @@protoc_insertion_point(destructor:substrait.DerivationExpression) - if (GetArenaForAllocation() != nullptr) return; - SharedDtor(); - _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -inline void DerivationExpression::SharedDtor() { - GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); - if (has_kind()) { - clear_kind(); - } -} - -void DerivationExpression::ArenaDtor(void* object) { - DerivationExpression* _this = reinterpret_cast< DerivationExpression* >(object); - (void)_this; -} -void DerivationExpression::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { -} -void DerivationExpression::SetCachedSize(int size) const { - _cached_size_.Set(size); -} - -void DerivationExpression::clear_kind() { -// @@protoc_insertion_point(one_of_clear_start:substrait.DerivationExpression) - switch (kind_case()) { - case kBool: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.bool__; - } - break; - } - case kI8: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i8_; - } - break; - } - case kI16: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i16_; - } - break; - } - case kI32: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i32_; - } - break; - } - case kI64: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.i64_; - } - break; - } - case kFp32: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp32_; - } - break; - } - case kFp64: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fp64_; - } - break; - } - case kString: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.string_; - } - break; - } - case kBinary: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.binary_; - } - break; - } - case kTimestamp: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_; - } - break; - } - case kDate: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.date_; - } - break; - } - case kTime: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.time_; - } - break; - } - case kIntervalYear: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_year_; - } - break; - } - case kIntervalDay: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.interval_day_; - } - break; - } - case kTimestampTz: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.timestamp_tz_; - } - break; - } - case kUuid: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.uuid_; - } - break; - } - case kFixedChar: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_char_; - } - break; - } - case kVarchar: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.varchar_; - } - break; - } - case kFixedBinary: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_binary_; - } - break; - } - case kDecimal: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.decimal_; - } - break; - } - case kStruct: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.struct__; - } - break; - } - case kList: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.list_; - } - break; - } - case kMap: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.map_; - } - break; - } - case kUserDefinedPointer: { - // No need to clear - break; - } - case kTypeParameterName: { - kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kIntegerParameterName: { - kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - break; - } - case kIntegerLiteral: { - // No need to clear - break; - } - case kUnaryOp: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.unary_op_; - } - break; - } - case kBinaryOp: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.binary_op_; - } - break; - } - case kIfElse: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.if_else_; - } - break; - } - case kReturnProgram: { - if (GetArenaForAllocation() == nullptr) { - delete kind_.return_program_; - } - break; - } - case KIND_NOT_SET: { - break; - } - } - _oneof_case_[0] = KIND_NOT_SET; -} - - -void DerivationExpression::Clear() { -// @@protoc_insertion_point(message_clear_start:substrait.DerivationExpression) - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_kind(); - _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); -} - -const char* DerivationExpression::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { -#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure - while (!ctx->Done(&ptr)) { - uint32_t tag; - ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); - switch (tag >> 3) { - // .substrait.Type.Boolean bool = 1; - case 1: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - ptr = ctx->ParseMessage(_internal_mutable_bool_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I8 i8 = 2; - case 2: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - ptr = ctx->ParseMessage(_internal_mutable_i8(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I16 i16 = 3; - case 3: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { - ptr = ctx->ParseMessage(_internal_mutable_i16(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I32 i32 = 5; - case 5: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_i32(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.I64 i64 = 7; - case 7: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_i64(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.FP32 fp32 = 10; - case 10: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 82)) { - ptr = ctx->ParseMessage(_internal_mutable_fp32(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.FP64 fp64 = 11; - case 11: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 90)) { - ptr = ctx->ParseMessage(_internal_mutable_fp64(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.String string = 12; - case 12: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 98)) { - ptr = ctx->ParseMessage(_internal_mutable_string(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Binary binary = 13; - case 13: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 106)) { - ptr = ctx->ParseMessage(_internal_mutable_binary(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Timestamp timestamp = 14; - case 14: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 114)) { - ptr = ctx->ParseMessage(_internal_mutable_timestamp(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Date date = 16; - case 16: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 130)) { - ptr = ctx->ParseMessage(_internal_mutable_date(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.Time time = 17; - case 17: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 138)) { - ptr = ctx->ParseMessage(_internal_mutable_time(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.IntervalYear interval_year = 19; - case 19: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 154)) { - ptr = ctx->ParseMessage(_internal_mutable_interval_year(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.IntervalDay interval_day = 20; - case 20: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 162)) { - ptr = ctx->ParseMessage(_internal_mutable_interval_day(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; - case 21: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 170)) { - ptr = ctx->ParseMessage(_internal_mutable_fixed_char(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.ExpressionVarChar varchar = 22; - case 22: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 178)) { - ptr = ctx->ParseMessage(_internal_mutable_varchar(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; - case 23: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 186)) { - ptr = ctx->ParseMessage(_internal_mutable_fixed_binary(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.ExpressionDecimal decimal = 24; - case 24: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 194)) { - ptr = ctx->ParseMessage(_internal_mutable_decimal(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.ExpressionStruct struct = 25; - case 25: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 202)) { - ptr = ctx->ParseMessage(_internal_mutable_struct_(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.ExpressionList list = 27; - case 27: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { - ptr = ctx->ParseMessage(_internal_mutable_list(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.ExpressionMap map = 28; - case 28: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { - ptr = ctx->ParseMessage(_internal_mutable_map(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.TimestampTZ timestamp_tz = 29; - case 29: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { - ptr = ctx->ParseMessage(_internal_mutable_timestamp_tz(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // uint32 user_defined_pointer = 31; - case 31: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 248)) { - _internal_set_user_defined_pointer(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.Type.UUID uuid = 32; - case 32: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { - ptr = ctx->ParseMessage(_internal_mutable_uuid(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string type_parameter_name = 33; - case 33: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { - auto str = _internal_mutable_type_parameter_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.type_parameter_name")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // string integer_parameter_name = 34; - case 34: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 18)) { - auto str = _internal_mutable_integer_parameter_name(); - ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); - CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "substrait.DerivationExpression.integer_parameter_name")); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // int32 integer_literal = 35; - case 35: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 24)) { - _internal_set_integer_literal(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr)); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.UnaryOp unary_op = 36; - case 36: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 34)) { - ptr = ctx->ParseMessage(_internal_mutable_unary_op(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.BinaryOp binary_op = 37; - case 37: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 42)) { - ptr = ctx->ParseMessage(_internal_mutable_binary_op(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.IfElse if_else = 38; - case 38: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 50)) { - ptr = ctx->ParseMessage(_internal_mutable_if_else(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - // .substrait.DerivationExpression.ReturnProgram return_program = 39; - case 39: - if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 58)) { - ptr = ctx->ParseMessage(_internal_mutable_return_program(), ptr); - CHK_(ptr); - } else - goto handle_unusual; - continue; - default: - goto handle_unusual; - } // switch - handle_unusual: - if ((tag == 0) || ((tag & 7) == 4)) { - CHK_(ptr); - ctx->SetLastTag(tag); - goto message_done; - } - ptr = UnknownFieldParse( - tag, - _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), - ptr, ctx); - CHK_(ptr != nullptr); - } // while -message_done: - return ptr; -failure: - ptr = nullptr; - goto message_done; -#undef CHK_ -} - -uint8_t* DerivationExpression::_InternalSerialize( - uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { - // @@protoc_insertion_point(serialize_to_array_start:substrait.DerivationExpression) - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - // .substrait.Type.Boolean bool = 1; - if (_internal_has_bool_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 1, _Internal::bool_(this), target, stream); - } - - // .substrait.Type.I8 i8 = 2; - if (_internal_has_i8()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 2, _Internal::i8(this), target, stream); - } - - // .substrait.Type.I16 i16 = 3; - if (_internal_has_i16()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 3, _Internal::i16(this), target, stream); - } - - // .substrait.Type.I32 i32 = 5; - if (_internal_has_i32()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 5, _Internal::i32(this), target, stream); - } - - // .substrait.Type.I64 i64 = 7; - if (_internal_has_i64()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 7, _Internal::i64(this), target, stream); - } - - // .substrait.Type.FP32 fp32 = 10; - if (_internal_has_fp32()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 10, _Internal::fp32(this), target, stream); - } - - // .substrait.Type.FP64 fp64 = 11; - if (_internal_has_fp64()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 11, _Internal::fp64(this), target, stream); - } - - // .substrait.Type.String string = 12; - if (_internal_has_string()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 12, _Internal::string(this), target, stream); - } - - // .substrait.Type.Binary binary = 13; - if (_internal_has_binary()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 13, _Internal::binary(this), target, stream); - } - - // .substrait.Type.Timestamp timestamp = 14; - if (_internal_has_timestamp()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 14, _Internal::timestamp(this), target, stream); - } - - // .substrait.Type.Date date = 16; - if (_internal_has_date()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 16, _Internal::date(this), target, stream); - } - - // .substrait.Type.Time time = 17; - if (_internal_has_time()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 17, _Internal::time(this), target, stream); - } - - // .substrait.Type.IntervalYear interval_year = 19; - if (_internal_has_interval_year()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 19, _Internal::interval_year(this), target, stream); - } - - // .substrait.Type.IntervalDay interval_day = 20; - if (_internal_has_interval_day()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 20, _Internal::interval_day(this), target, stream); - } - - // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; - if (_internal_has_fixed_char()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 21, _Internal::fixed_char(this), target, stream); - } - - // .substrait.DerivationExpression.ExpressionVarChar varchar = 22; - if (_internal_has_varchar()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 22, _Internal::varchar(this), target, stream); - } - - // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; - if (_internal_has_fixed_binary()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 23, _Internal::fixed_binary(this), target, stream); - } - - // .substrait.DerivationExpression.ExpressionDecimal decimal = 24; - if (_internal_has_decimal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 24, _Internal::decimal(this), target, stream); - } - - // .substrait.DerivationExpression.ExpressionStruct struct = 25; - if (_internal_has_struct_()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 25, _Internal::struct_(this), target, stream); - } - - // .substrait.DerivationExpression.ExpressionList list = 27; - if (_internal_has_list()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 27, _Internal::list(this), target, stream); - } - - // .substrait.DerivationExpression.ExpressionMap map = 28; - if (_internal_has_map()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 28, _Internal::map(this), target, stream); - } - - // .substrait.Type.TimestampTZ timestamp_tz = 29; - if (_internal_has_timestamp_tz()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 29, _Internal::timestamp_tz(this), target, stream); - } - - // uint32 user_defined_pointer = 31; - if (_internal_has_user_defined_pointer()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(31, this->_internal_user_defined_pointer(), target); - } - - // .substrait.Type.UUID uuid = 32; - if (_internal_has_uuid()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 32, _Internal::uuid(this), target, stream); - } - - // string type_parameter_name = 33; - if (_internal_has_type_parameter_name()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_type_parameter_name().data(), static_cast(this->_internal_type_parameter_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.DerivationExpression.type_parameter_name"); - target = stream->WriteStringMaybeAliased( - 33, this->_internal_type_parameter_name(), target); - } - - // string integer_parameter_name = 34; - if (_internal_has_integer_parameter_name()) { - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String( - this->_internal_integer_parameter_name().data(), static_cast(this->_internal_integer_parameter_name().length()), - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE, - "substrait.DerivationExpression.integer_parameter_name"); - target = stream->WriteStringMaybeAliased( - 34, this->_internal_integer_parameter_name(), target); - } - - // int32 integer_literal = 35; - if (_internal_has_integer_literal()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(35, this->_internal_integer_literal(), target); - } - - // .substrait.DerivationExpression.UnaryOp unary_op = 36; - if (_internal_has_unary_op()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 36, _Internal::unary_op(this), target, stream); - } - - // .substrait.DerivationExpression.BinaryOp binary_op = 37; - if (_internal_has_binary_op()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 37, _Internal::binary_op(this), target, stream); - } - - // .substrait.DerivationExpression.IfElse if_else = 38; - if (_internal_has_if_else()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 38, _Internal::if_else(this), target, stream); - } - - // .substrait.DerivationExpression.ReturnProgram return_program = 39; - if (_internal_has_return_program()) { - target = stream->EnsureSpace(target); - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: - InternalWriteMessage( - 39, _Internal::return_program(this), target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { - target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray( - _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:substrait.DerivationExpression) - return target; -} - -size_t DerivationExpression::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:substrait.DerivationExpression) - size_t total_size = 0; - - uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - switch (kind_case()) { - // .substrait.Type.Boolean bool = 1; - case kBool: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.bool__); - break; - } - // .substrait.Type.I8 i8 = 2; - case kI8: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i8_); - break; - } - // .substrait.Type.I16 i16 = 3; - case kI16: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i16_); - break; - } - // .substrait.Type.I32 i32 = 5; - case kI32: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i32_); - break; - } - // .substrait.Type.I64 i64 = 7; - case kI64: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.i64_); - break; - } - // .substrait.Type.FP32 fp32 = 10; - case kFp32: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fp32_); - break; - } - // .substrait.Type.FP64 fp64 = 11; - case kFp64: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fp64_); - break; - } - // .substrait.Type.String string = 12; - case kString: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.string_); - break; - } - // .substrait.Type.Binary binary = 13; - case kBinary: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.binary_); - break; - } - // .substrait.Type.Timestamp timestamp = 14; - case kTimestamp: { - total_size += 1 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.timestamp_); - break; - } - // .substrait.Type.Date date = 16; - case kDate: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.date_); - break; - } - // .substrait.Type.Time time = 17; - case kTime: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.time_); - break; - } - // .substrait.Type.IntervalYear interval_year = 19; - case kIntervalYear: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.interval_year_); - break; - } - // .substrait.Type.IntervalDay interval_day = 20; - case kIntervalDay: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.interval_day_); - break; - } - // .substrait.Type.TimestampTZ timestamp_tz = 29; - case kTimestampTz: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.timestamp_tz_); - break; - } - // .substrait.Type.UUID uuid = 32; - case kUuid: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.uuid_); - break; - } - // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; - case kFixedChar: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fixed_char_); - break; - } - // .substrait.DerivationExpression.ExpressionVarChar varchar = 22; - case kVarchar: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.varchar_); - break; - } - // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; - case kFixedBinary: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.fixed_binary_); - break; - } - // .substrait.DerivationExpression.ExpressionDecimal decimal = 24; - case kDecimal: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.decimal_); - break; - } - // .substrait.DerivationExpression.ExpressionStruct struct = 25; - case kStruct: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.struct__); - break; - } - // .substrait.DerivationExpression.ExpressionList list = 27; - case kList: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.list_); - break; - } - // .substrait.DerivationExpression.ExpressionMap map = 28; - case kMap: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.map_); - break; - } - // uint32 user_defined_pointer = 31; - case kUserDefinedPointer: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size( - this->_internal_user_defined_pointer()); - break; - } - // string type_parameter_name = 33; - case kTypeParameterName: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_type_parameter_name()); - break; - } - // string integer_parameter_name = 34; - case kIntegerParameterName: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize( - this->_internal_integer_parameter_name()); - break; - } - // int32 integer_literal = 35; - case kIntegerLiteral: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size( - this->_internal_integer_literal()); - break; - } - // .substrait.DerivationExpression.UnaryOp unary_op = 36; - case kUnaryOp: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.unary_op_); - break; - } - // .substrait.DerivationExpression.BinaryOp binary_op = 37; - case kBinaryOp: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.binary_op_); - break; - } - // .substrait.DerivationExpression.IfElse if_else = 38; - case kIfElse: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.if_else_); - break; - } - // .substrait.DerivationExpression.ReturnProgram return_program = 39; - case kReturnProgram: { - total_size += 2 + - ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( - *kind_.return_program_); - break; - } - case KIND_NOT_SET: { - break; - } - } - return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_); -} - -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData DerivationExpression::_class_data_ = { - ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck, - DerivationExpression::MergeImpl -}; -const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*DerivationExpression::GetClassData() const { return &_class_data_; } - -void DerivationExpression::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, - const ::PROTOBUF_NAMESPACE_ID::Message& from) { - static_cast(to)->MergeFrom( - static_cast(from)); -} - - -void DerivationExpression::MergeFrom(const DerivationExpression& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:substrait.DerivationExpression) - GOOGLE_DCHECK_NE(&from, this); - uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - switch (from.kind_case()) { - case kBool: { - _internal_mutable_bool_()->::substrait::Type_Boolean::MergeFrom(from._internal_bool_()); - break; - } - case kI8: { - _internal_mutable_i8()->::substrait::Type_I8::MergeFrom(from._internal_i8()); - break; - } - case kI16: { - _internal_mutable_i16()->::substrait::Type_I16::MergeFrom(from._internal_i16()); - break; - } - case kI32: { - _internal_mutable_i32()->::substrait::Type_I32::MergeFrom(from._internal_i32()); - break; - } - case kI64: { - _internal_mutable_i64()->::substrait::Type_I64::MergeFrom(from._internal_i64()); - break; - } - case kFp32: { - _internal_mutable_fp32()->::substrait::Type_FP32::MergeFrom(from._internal_fp32()); - break; - } - case kFp64: { - _internal_mutable_fp64()->::substrait::Type_FP64::MergeFrom(from._internal_fp64()); - break; - } - case kString: { - _internal_mutable_string()->::substrait::Type_String::MergeFrom(from._internal_string()); - break; - } - case kBinary: { - _internal_mutable_binary()->::substrait::Type_Binary::MergeFrom(from._internal_binary()); - break; - } - case kTimestamp: { - _internal_mutable_timestamp()->::substrait::Type_Timestamp::MergeFrom(from._internal_timestamp()); - break; - } - case kDate: { - _internal_mutable_date()->::substrait::Type_Date::MergeFrom(from._internal_date()); - break; - } - case kTime: { - _internal_mutable_time()->::substrait::Type_Time::MergeFrom(from._internal_time()); - break; - } - case kIntervalYear: { - _internal_mutable_interval_year()->::substrait::Type_IntervalYear::MergeFrom(from._internal_interval_year()); - break; - } - case kIntervalDay: { - _internal_mutable_interval_day()->::substrait::Type_IntervalDay::MergeFrom(from._internal_interval_day()); - break; - } - case kTimestampTz: { - _internal_mutable_timestamp_tz()->::substrait::Type_TimestampTZ::MergeFrom(from._internal_timestamp_tz()); - break; - } - case kUuid: { - _internal_mutable_uuid()->::substrait::Type_UUID::MergeFrom(from._internal_uuid()); - break; - } - case kFixedChar: { - _internal_mutable_fixed_char()->::substrait::DerivationExpression_ExpressionFixedChar::MergeFrom(from._internal_fixed_char()); - break; - } - case kVarchar: { - _internal_mutable_varchar()->::substrait::DerivationExpression_ExpressionVarChar::MergeFrom(from._internal_varchar()); - break; - } - case kFixedBinary: { - _internal_mutable_fixed_binary()->::substrait::DerivationExpression_ExpressionFixedBinary::MergeFrom(from._internal_fixed_binary()); - break; - } - case kDecimal: { - _internal_mutable_decimal()->::substrait::DerivationExpression_ExpressionDecimal::MergeFrom(from._internal_decimal()); - break; - } - case kStruct: { - _internal_mutable_struct_()->::substrait::DerivationExpression_ExpressionStruct::MergeFrom(from._internal_struct_()); - break; - } - case kList: { - _internal_mutable_list()->::substrait::DerivationExpression_ExpressionList::MergeFrom(from._internal_list()); - break; - } - case kMap: { - _internal_mutable_map()->::substrait::DerivationExpression_ExpressionMap::MergeFrom(from._internal_map()); - break; - } - case kUserDefinedPointer: { - _internal_set_user_defined_pointer(from._internal_user_defined_pointer()); - break; - } - case kTypeParameterName: { - _internal_set_type_parameter_name(from._internal_type_parameter_name()); - break; - } - case kIntegerParameterName: { - _internal_set_integer_parameter_name(from._internal_integer_parameter_name()); - break; - } - case kIntegerLiteral: { - _internal_set_integer_literal(from._internal_integer_literal()); - break; - } - case kUnaryOp: { - _internal_mutable_unary_op()->::substrait::DerivationExpression_UnaryOp::MergeFrom(from._internal_unary_op()); - break; - } - case kBinaryOp: { - _internal_mutable_binary_op()->::substrait::DerivationExpression_BinaryOp::MergeFrom(from._internal_binary_op()); - break; - } - case kIfElse: { - _internal_mutable_if_else()->::substrait::DerivationExpression_IfElse::MergeFrom(from._internal_if_else()); - break; - } - case kReturnProgram: { - _internal_mutable_return_program()->::substrait::DerivationExpression_ReturnProgram::MergeFrom(from._internal_return_program()); - break; - } - case KIND_NOT_SET: { - break; - } - } - _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); -} - -void DerivationExpression::CopyFrom(const DerivationExpression& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:substrait.DerivationExpression) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DerivationExpression::IsInitialized() const { - return true; -} - -void DerivationExpression::InternalSwap(DerivationExpression* other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(kind_, other->kind_); - swap(_oneof_case_[0], other->_oneof_case_[0]); -} - -::PROTOBUF_NAMESPACE_ID::Metadata DerivationExpression::GetMetadata() const { - return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors( - &descriptor_table_substrait_2ftype_5fexpressions_2eproto_getter, &descriptor_table_substrait_2ftype_5fexpressions_2eproto_once, - file_level_metadata_substrait_2ftype_5fexpressions_2eproto[13]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionFixedChar >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionVarChar >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionVarChar >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedBinary >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionFixedBinary >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionDecimal >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionDecimal >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionStruct >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionNamedStruct >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionNamedStruct >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionList >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionList >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionMap >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ExpressionMap >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_IfElse >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_IfElse >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_UnaryOp >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_UnaryOp >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_BinaryOp >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_BinaryOp >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram_Assignment >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ReturnProgram_Assignment >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression_ReturnProgram >(arena); -} -template<> PROTOBUF_NOINLINE ::substrait::DerivationExpression* Arena::CreateMaybeMessage< ::substrait::DerivationExpression >(Arena* arena) { - return Arena::CreateMessageInternal< ::substrait::DerivationExpression >(arena); -} -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) -#include diff --git a/cpp/src/generated/substrait/type_expressions.pb.h b/cpp/src/generated/substrait/type_expressions.pb.h deleted file mode 100644 index 0548e41e676..00000000000 --- a/cpp/src/generated/substrait/type_expressions.pb.h +++ /dev/null @@ -1,7743 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: substrait/type_expressions.proto - -#ifndef GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto -#define GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto - -#include -#include - -#include -#if PROTOBUF_VERSION < 3019000 -#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 3019003 < 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include -#include "substrait/type.pb.h" -// @@protoc_insertion_point(includes) -#include -#define PROTOBUF_INTERNAL_EXPORT_substrait_2ftype_5fexpressions_2eproto -PROTOBUF_NAMESPACE_OPEN -namespace internal { -class AnyMetadata; -} // namespace internal -PROTOBUF_NAMESPACE_CLOSE - -// Internal implementation detail -- do not use these members. -struct TableStruct_substrait_2ftype_5fexpressions_2eproto { - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14] - PROTOBUF_SECTION_VARIABLE(protodesc_cold); - static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[]; - static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[]; - static const uint32_t offsets[]; -}; -extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_substrait_2ftype_5fexpressions_2eproto; -namespace substrait { -class DerivationExpression; -struct DerivationExpressionDefaultTypeInternal; -extern DerivationExpressionDefaultTypeInternal _DerivationExpression_default_instance_; -class DerivationExpression_BinaryOp; -struct DerivationExpression_BinaryOpDefaultTypeInternal; -extern DerivationExpression_BinaryOpDefaultTypeInternal _DerivationExpression_BinaryOp_default_instance_; -class DerivationExpression_ExpressionDecimal; -struct DerivationExpression_ExpressionDecimalDefaultTypeInternal; -extern DerivationExpression_ExpressionDecimalDefaultTypeInternal _DerivationExpression_ExpressionDecimal_default_instance_; -class DerivationExpression_ExpressionFixedBinary; -struct DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal; -extern DerivationExpression_ExpressionFixedBinaryDefaultTypeInternal _DerivationExpression_ExpressionFixedBinary_default_instance_; -class DerivationExpression_ExpressionFixedChar; -struct DerivationExpression_ExpressionFixedCharDefaultTypeInternal; -extern DerivationExpression_ExpressionFixedCharDefaultTypeInternal _DerivationExpression_ExpressionFixedChar_default_instance_; -class DerivationExpression_ExpressionList; -struct DerivationExpression_ExpressionListDefaultTypeInternal; -extern DerivationExpression_ExpressionListDefaultTypeInternal _DerivationExpression_ExpressionList_default_instance_; -class DerivationExpression_ExpressionMap; -struct DerivationExpression_ExpressionMapDefaultTypeInternal; -extern DerivationExpression_ExpressionMapDefaultTypeInternal _DerivationExpression_ExpressionMap_default_instance_; -class DerivationExpression_ExpressionNamedStruct; -struct DerivationExpression_ExpressionNamedStructDefaultTypeInternal; -extern DerivationExpression_ExpressionNamedStructDefaultTypeInternal _DerivationExpression_ExpressionNamedStruct_default_instance_; -class DerivationExpression_ExpressionStruct; -struct DerivationExpression_ExpressionStructDefaultTypeInternal; -extern DerivationExpression_ExpressionStructDefaultTypeInternal _DerivationExpression_ExpressionStruct_default_instance_; -class DerivationExpression_ExpressionVarChar; -struct DerivationExpression_ExpressionVarCharDefaultTypeInternal; -extern DerivationExpression_ExpressionVarCharDefaultTypeInternal _DerivationExpression_ExpressionVarChar_default_instance_; -class DerivationExpression_IfElse; -struct DerivationExpression_IfElseDefaultTypeInternal; -extern DerivationExpression_IfElseDefaultTypeInternal _DerivationExpression_IfElse_default_instance_; -class DerivationExpression_ReturnProgram; -struct DerivationExpression_ReturnProgramDefaultTypeInternal; -extern DerivationExpression_ReturnProgramDefaultTypeInternal _DerivationExpression_ReturnProgram_default_instance_; -class DerivationExpression_ReturnProgram_Assignment; -struct DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal; -extern DerivationExpression_ReturnProgram_AssignmentDefaultTypeInternal _DerivationExpression_ReturnProgram_Assignment_default_instance_; -class DerivationExpression_UnaryOp; -struct DerivationExpression_UnaryOpDefaultTypeInternal; -extern DerivationExpression_UnaryOpDefaultTypeInternal _DerivationExpression_UnaryOp_default_instance_; -} // namespace substrait -PROTOBUF_NAMESPACE_OPEN -template<> ::substrait::DerivationExpression* Arena::CreateMaybeMessage<::substrait::DerivationExpression>(Arena*); -template<> ::substrait::DerivationExpression_BinaryOp* Arena::CreateMaybeMessage<::substrait::DerivationExpression_BinaryOp>(Arena*); -template<> ::substrait::DerivationExpression_ExpressionDecimal* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionDecimal>(Arena*); -template<> ::substrait::DerivationExpression_ExpressionFixedBinary* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionFixedBinary>(Arena*); -template<> ::substrait::DerivationExpression_ExpressionFixedChar* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionFixedChar>(Arena*); -template<> ::substrait::DerivationExpression_ExpressionList* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionList>(Arena*); -template<> ::substrait::DerivationExpression_ExpressionMap* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionMap>(Arena*); -template<> ::substrait::DerivationExpression_ExpressionNamedStruct* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionNamedStruct>(Arena*); -template<> ::substrait::DerivationExpression_ExpressionStruct* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionStruct>(Arena*); -template<> ::substrait::DerivationExpression_ExpressionVarChar* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ExpressionVarChar>(Arena*); -template<> ::substrait::DerivationExpression_IfElse* Arena::CreateMaybeMessage<::substrait::DerivationExpression_IfElse>(Arena*); -template<> ::substrait::DerivationExpression_ReturnProgram* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ReturnProgram>(Arena*); -template<> ::substrait::DerivationExpression_ReturnProgram_Assignment* Arena::CreateMaybeMessage<::substrait::DerivationExpression_ReturnProgram_Assignment>(Arena*); -template<> ::substrait::DerivationExpression_UnaryOp* Arena::CreateMaybeMessage<::substrait::DerivationExpression_UnaryOp>(Arena*); -PROTOBUF_NAMESPACE_CLOSE -namespace substrait { - -enum DerivationExpression_UnaryOp_UnaryOpType : int { - DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED = 0, - DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT = 1, - DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - DerivationExpression_UnaryOp_UnaryOpType_DerivationExpression_UnaryOp_UnaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool DerivationExpression_UnaryOp_UnaryOpType_IsValid(int value); -constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MIN = DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED; -constexpr DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX = DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT; -constexpr int DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_ARRAYSIZE = DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_UnaryOp_UnaryOpType_descriptor(); -template -inline const std::string& DerivationExpression_UnaryOp_UnaryOpType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function DerivationExpression_UnaryOp_UnaryOpType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - DerivationExpression_UnaryOp_UnaryOpType_descriptor(), enum_t_value); -} -inline bool DerivationExpression_UnaryOp_UnaryOpType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_UnaryOp_UnaryOpType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - DerivationExpression_UnaryOp_UnaryOpType_descriptor(), name, value); -} -enum DerivationExpression_BinaryOp_BinaryOpType : int { - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED = 0, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_PLUS = 1, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MINUS = 2, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MULTIPLY = 3, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_DIVIDE = 4, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MIN = 5, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MAX = 6, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_GREATER_THAN = 7, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_LESS_THAN = 8, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_AND = 9, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_OR = 10, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_EQUALS = 11, - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS = 12, - DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), - DerivationExpression_BinaryOp_BinaryOpType_DerivationExpression_BinaryOp_BinaryOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() -}; -bool DerivationExpression_BinaryOp_BinaryOpType_IsValid(int value); -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MIN = DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED; -constexpr DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX = DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS; -constexpr int DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_ARRAYSIZE = DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX + 1; - -const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DerivationExpression_BinaryOp_BinaryOpType_descriptor(); -template -inline const std::string& DerivationExpression_BinaryOp_BinaryOpType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function DerivationExpression_BinaryOp_BinaryOpType_Name."); - return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( - DerivationExpression_BinaryOp_BinaryOpType_descriptor(), enum_t_value); -} -inline bool DerivationExpression_BinaryOp_BinaryOpType_Parse( - ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DerivationExpression_BinaryOp_BinaryOpType* value) { - return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( - DerivationExpression_BinaryOp_BinaryOpType_descriptor(), name, value); -} -// =================================================================== - -class DerivationExpression_ExpressionFixedChar final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionFixedChar) */ { - public: - inline DerivationExpression_ExpressionFixedChar() : DerivationExpression_ExpressionFixedChar(nullptr) {} - ~DerivationExpression_ExpressionFixedChar() override; - explicit constexpr DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_ExpressionFixedChar(const DerivationExpression_ExpressionFixedChar& from); - DerivationExpression_ExpressionFixedChar(DerivationExpression_ExpressionFixedChar&& from) noexcept - : DerivationExpression_ExpressionFixedChar() { - *this = ::std::move(from); - } - - inline DerivationExpression_ExpressionFixedChar& operator=(const DerivationExpression_ExpressionFixedChar& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_ExpressionFixedChar& operator=(DerivationExpression_ExpressionFixedChar&& 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 DerivationExpression_ExpressionFixedChar& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_ExpressionFixedChar* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_ExpressionFixedChar_default_instance_); - } - static constexpr int kIndexInFileMessages = - 0; - - friend void swap(DerivationExpression_ExpressionFixedChar& a, DerivationExpression_ExpressionFixedChar& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_ExpressionFixedChar* 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(DerivationExpression_ExpressionFixedChar* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_ExpressionFixedChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_ExpressionFixedChar& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_ExpressionFixedChar& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_ExpressionFixedChar* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.ExpressionFixedChar"; - } - protected: - explicit DerivationExpression_ExpressionFixedChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLengthFieldNumber = 1, - kVariationPointerFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // .substrait.DerivationExpression length = 1; - bool has_length() const; - private: - bool _internal_has_length() const; - public: - void clear_length(); - const ::substrait::DerivationExpression& length() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length(); - ::substrait::DerivationExpression* mutable_length(); - void set_allocated_length(::substrait::DerivationExpression* length); - private: - const ::substrait::DerivationExpression& _internal_length() const; - ::substrait::DerivationExpression* _internal_mutable_length(); - public: - void unsafe_arena_set_allocated_length( - ::substrait::DerivationExpression* length); - ::substrait::DerivationExpression* unsafe_arena_release_length(); - - // uint32 variation_pointer = 2; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionFixedChar) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::DerivationExpression* length_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_ExpressionVarChar final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionVarChar) */ { - public: - inline DerivationExpression_ExpressionVarChar() : DerivationExpression_ExpressionVarChar(nullptr) {} - ~DerivationExpression_ExpressionVarChar() override; - explicit constexpr DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_ExpressionVarChar(const DerivationExpression_ExpressionVarChar& from); - DerivationExpression_ExpressionVarChar(DerivationExpression_ExpressionVarChar&& from) noexcept - : DerivationExpression_ExpressionVarChar() { - *this = ::std::move(from); - } - - inline DerivationExpression_ExpressionVarChar& operator=(const DerivationExpression_ExpressionVarChar& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_ExpressionVarChar& operator=(DerivationExpression_ExpressionVarChar&& 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 DerivationExpression_ExpressionVarChar& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_ExpressionVarChar* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_ExpressionVarChar_default_instance_); - } - static constexpr int kIndexInFileMessages = - 1; - - friend void swap(DerivationExpression_ExpressionVarChar& a, DerivationExpression_ExpressionVarChar& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_ExpressionVarChar* 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(DerivationExpression_ExpressionVarChar* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_ExpressionVarChar* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_ExpressionVarChar& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_ExpressionVarChar& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_ExpressionVarChar* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.ExpressionVarChar"; - } - protected: - explicit DerivationExpression_ExpressionVarChar(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLengthFieldNumber = 1, - kVariationPointerFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // .substrait.DerivationExpression length = 1; - bool has_length() const; - private: - bool _internal_has_length() const; - public: - void clear_length(); - const ::substrait::DerivationExpression& length() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length(); - ::substrait::DerivationExpression* mutable_length(); - void set_allocated_length(::substrait::DerivationExpression* length); - private: - const ::substrait::DerivationExpression& _internal_length() const; - ::substrait::DerivationExpression* _internal_mutable_length(); - public: - void unsafe_arena_set_allocated_length( - ::substrait::DerivationExpression* length); - ::substrait::DerivationExpression* unsafe_arena_release_length(); - - // uint32 variation_pointer = 2; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionVarChar) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::DerivationExpression* length_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_ExpressionFixedBinary final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionFixedBinary) */ { - public: - inline DerivationExpression_ExpressionFixedBinary() : DerivationExpression_ExpressionFixedBinary(nullptr) {} - ~DerivationExpression_ExpressionFixedBinary() override; - explicit constexpr DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_ExpressionFixedBinary(const DerivationExpression_ExpressionFixedBinary& from); - DerivationExpression_ExpressionFixedBinary(DerivationExpression_ExpressionFixedBinary&& from) noexcept - : DerivationExpression_ExpressionFixedBinary() { - *this = ::std::move(from); - } - - inline DerivationExpression_ExpressionFixedBinary& operator=(const DerivationExpression_ExpressionFixedBinary& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_ExpressionFixedBinary& operator=(DerivationExpression_ExpressionFixedBinary&& 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 DerivationExpression_ExpressionFixedBinary& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_ExpressionFixedBinary* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_ExpressionFixedBinary_default_instance_); - } - static constexpr int kIndexInFileMessages = - 2; - - friend void swap(DerivationExpression_ExpressionFixedBinary& a, DerivationExpression_ExpressionFixedBinary& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_ExpressionFixedBinary* 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(DerivationExpression_ExpressionFixedBinary* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_ExpressionFixedBinary* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_ExpressionFixedBinary& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_ExpressionFixedBinary& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_ExpressionFixedBinary* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.ExpressionFixedBinary"; - } - protected: - explicit DerivationExpression_ExpressionFixedBinary(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kLengthFieldNumber = 1, - kVariationPointerFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // .substrait.DerivationExpression length = 1; - bool has_length() const; - private: - bool _internal_has_length() const; - public: - void clear_length(); - const ::substrait::DerivationExpression& length() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_length(); - ::substrait::DerivationExpression* mutable_length(); - void set_allocated_length(::substrait::DerivationExpression* length); - private: - const ::substrait::DerivationExpression& _internal_length() const; - ::substrait::DerivationExpression* _internal_mutable_length(); - public: - void unsafe_arena_set_allocated_length( - ::substrait::DerivationExpression* length); - ::substrait::DerivationExpression* unsafe_arena_release_length(); - - // uint32 variation_pointer = 2; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionFixedBinary) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::DerivationExpression* length_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_ExpressionDecimal final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionDecimal) */ { - public: - inline DerivationExpression_ExpressionDecimal() : DerivationExpression_ExpressionDecimal(nullptr) {} - ~DerivationExpression_ExpressionDecimal() override; - explicit constexpr DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_ExpressionDecimal(const DerivationExpression_ExpressionDecimal& from); - DerivationExpression_ExpressionDecimal(DerivationExpression_ExpressionDecimal&& from) noexcept - : DerivationExpression_ExpressionDecimal() { - *this = ::std::move(from); - } - - inline DerivationExpression_ExpressionDecimal& operator=(const DerivationExpression_ExpressionDecimal& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_ExpressionDecimal& operator=(DerivationExpression_ExpressionDecimal&& 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 DerivationExpression_ExpressionDecimal& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_ExpressionDecimal* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_ExpressionDecimal_default_instance_); - } - static constexpr int kIndexInFileMessages = - 3; - - friend void swap(DerivationExpression_ExpressionDecimal& a, DerivationExpression_ExpressionDecimal& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_ExpressionDecimal* 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(DerivationExpression_ExpressionDecimal* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_ExpressionDecimal* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_ExpressionDecimal& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_ExpressionDecimal& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_ExpressionDecimal* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.ExpressionDecimal"; - } - protected: - explicit DerivationExpression_ExpressionDecimal(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kScaleFieldNumber = 1, - kPrecisionFieldNumber = 2, - kVariationPointerFieldNumber = 3, - kNullabilityFieldNumber = 4, - }; - // .substrait.DerivationExpression scale = 1; - bool has_scale() const; - private: - bool _internal_has_scale() const; - public: - void clear_scale(); - const ::substrait::DerivationExpression& scale() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_scale(); - ::substrait::DerivationExpression* mutable_scale(); - void set_allocated_scale(::substrait::DerivationExpression* scale); - private: - const ::substrait::DerivationExpression& _internal_scale() const; - ::substrait::DerivationExpression* _internal_mutable_scale(); - public: - void unsafe_arena_set_allocated_scale( - ::substrait::DerivationExpression* scale); - ::substrait::DerivationExpression* unsafe_arena_release_scale(); - - // .substrait.DerivationExpression precision = 2; - bool has_precision() const; - private: - bool _internal_has_precision() const; - public: - void clear_precision(); - const ::substrait::DerivationExpression& precision() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_precision(); - ::substrait::DerivationExpression* mutable_precision(); - void set_allocated_precision(::substrait::DerivationExpression* precision); - private: - const ::substrait::DerivationExpression& _internal_precision() const; - ::substrait::DerivationExpression* _internal_mutable_precision(); - public: - void unsafe_arena_set_allocated_precision( - ::substrait::DerivationExpression* precision); - ::substrait::DerivationExpression* unsafe_arena_release_precision(); - - // uint32 variation_pointer = 3; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 4; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionDecimal) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::DerivationExpression* scale_; - ::substrait::DerivationExpression* precision_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_ExpressionStruct final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionStruct) */ { - public: - inline DerivationExpression_ExpressionStruct() : DerivationExpression_ExpressionStruct(nullptr) {} - ~DerivationExpression_ExpressionStruct() override; - explicit constexpr DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_ExpressionStruct(const DerivationExpression_ExpressionStruct& from); - DerivationExpression_ExpressionStruct(DerivationExpression_ExpressionStruct&& from) noexcept - : DerivationExpression_ExpressionStruct() { - *this = ::std::move(from); - } - - inline DerivationExpression_ExpressionStruct& operator=(const DerivationExpression_ExpressionStruct& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_ExpressionStruct& operator=(DerivationExpression_ExpressionStruct&& 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 DerivationExpression_ExpressionStruct& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_ExpressionStruct* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_ExpressionStruct_default_instance_); - } - static constexpr int kIndexInFileMessages = - 4; - - friend void swap(DerivationExpression_ExpressionStruct& a, DerivationExpression_ExpressionStruct& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_ExpressionStruct* 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(DerivationExpression_ExpressionStruct* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_ExpressionStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_ExpressionStruct& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_ExpressionStruct& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_ExpressionStruct* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.ExpressionStruct"; - } - protected: - explicit DerivationExpression_ExpressionStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypesFieldNumber = 1, - kVariationPointerFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // repeated .substrait.DerivationExpression types = 1; - int types_size() const; - private: - int _internal_types_size() const; - public: - void clear_types(); - ::substrait::DerivationExpression* mutable_types(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >* - mutable_types(); - private: - const ::substrait::DerivationExpression& _internal_types(int index) const; - ::substrait::DerivationExpression* _internal_add_types(); - public: - const ::substrait::DerivationExpression& types(int index) const; - ::substrait::DerivationExpression* add_types(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >& - types() const; - - // uint32 variation_pointer = 2; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionStruct) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression > types_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_ExpressionNamedStruct final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionNamedStruct) */ { - public: - inline DerivationExpression_ExpressionNamedStruct() : DerivationExpression_ExpressionNamedStruct(nullptr) {} - ~DerivationExpression_ExpressionNamedStruct() override; - explicit constexpr DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_ExpressionNamedStruct(const DerivationExpression_ExpressionNamedStruct& from); - DerivationExpression_ExpressionNamedStruct(DerivationExpression_ExpressionNamedStruct&& from) noexcept - : DerivationExpression_ExpressionNamedStruct() { - *this = ::std::move(from); - } - - inline DerivationExpression_ExpressionNamedStruct& operator=(const DerivationExpression_ExpressionNamedStruct& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_ExpressionNamedStruct& operator=(DerivationExpression_ExpressionNamedStruct&& 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 DerivationExpression_ExpressionNamedStruct& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_ExpressionNamedStruct* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_ExpressionNamedStruct_default_instance_); - } - static constexpr int kIndexInFileMessages = - 5; - - friend void swap(DerivationExpression_ExpressionNamedStruct& a, DerivationExpression_ExpressionNamedStruct& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_ExpressionNamedStruct* 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(DerivationExpression_ExpressionNamedStruct* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_ExpressionNamedStruct* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_ExpressionNamedStruct& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_ExpressionNamedStruct& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_ExpressionNamedStruct* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.ExpressionNamedStruct"; - } - protected: - explicit DerivationExpression_ExpressionNamedStruct(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kNamesFieldNumber = 1, - kStructFieldNumber = 2, - }; - // repeated string names = 1; - int names_size() const; - private: - int _internal_names_size() const; - public: - void clear_names(); - const std::string& names(int index) const; - std::string* mutable_names(int index); - void set_names(int index, const std::string& value); - void set_names(int index, std::string&& value); - void set_names(int index, const char* value); - void set_names(int index, const char* value, size_t size); - std::string* add_names(); - void add_names(const std::string& value); - void add_names(std::string&& value); - void add_names(const char* value); - void add_names(const char* value, size_t size); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& names() const; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_names(); - private: - const std::string& _internal_names(int index) const; - std::string* _internal_add_names(); - public: - - // .substrait.DerivationExpression.ExpressionStruct struct = 2; - bool has_struct_() const; - private: - bool _internal_has_struct_() const; - public: - void clear_struct_(); - const ::substrait::DerivationExpression_ExpressionStruct& struct_() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionStruct* release_struct_(); - ::substrait::DerivationExpression_ExpressionStruct* mutable_struct_(); - void set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_); - private: - const ::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const; - ::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_(); - public: - void unsafe_arena_set_allocated_struct_( - ::substrait::DerivationExpression_ExpressionStruct* struct_); - ::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_(); - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionNamedStruct) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField names_; - ::substrait::DerivationExpression_ExpressionStruct* struct__; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_ExpressionList final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionList) */ { - public: - inline DerivationExpression_ExpressionList() : DerivationExpression_ExpressionList(nullptr) {} - ~DerivationExpression_ExpressionList() override; - explicit constexpr DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_ExpressionList(const DerivationExpression_ExpressionList& from); - DerivationExpression_ExpressionList(DerivationExpression_ExpressionList&& from) noexcept - : DerivationExpression_ExpressionList() { - *this = ::std::move(from); - } - - inline DerivationExpression_ExpressionList& operator=(const DerivationExpression_ExpressionList& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_ExpressionList& operator=(DerivationExpression_ExpressionList&& 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 DerivationExpression_ExpressionList& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_ExpressionList* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_ExpressionList_default_instance_); - } - static constexpr int kIndexInFileMessages = - 6; - - friend void swap(DerivationExpression_ExpressionList& a, DerivationExpression_ExpressionList& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_ExpressionList* 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(DerivationExpression_ExpressionList* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_ExpressionList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_ExpressionList& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_ExpressionList& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_ExpressionList* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.ExpressionList"; - } - protected: - explicit DerivationExpression_ExpressionList(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kTypeFieldNumber = 1, - kVariationPointerFieldNumber = 2, - kNullabilityFieldNumber = 3, - }; - // .substrait.DerivationExpression type = 1; - bool has_type() const; - private: - bool _internal_has_type() const; - public: - void clear_type(); - const ::substrait::DerivationExpression& type() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_type(); - ::substrait::DerivationExpression* mutable_type(); - void set_allocated_type(::substrait::DerivationExpression* type); - private: - const ::substrait::DerivationExpression& _internal_type() const; - ::substrait::DerivationExpression* _internal_mutable_type(); - public: - void unsafe_arena_set_allocated_type( - ::substrait::DerivationExpression* type); - ::substrait::DerivationExpression* unsafe_arena_release_type(); - - // uint32 variation_pointer = 2; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 3; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionList) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::DerivationExpression* type_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_ExpressionMap final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ExpressionMap) */ { - public: - inline DerivationExpression_ExpressionMap() : DerivationExpression_ExpressionMap(nullptr) {} - ~DerivationExpression_ExpressionMap() override; - explicit constexpr DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_ExpressionMap(const DerivationExpression_ExpressionMap& from); - DerivationExpression_ExpressionMap(DerivationExpression_ExpressionMap&& from) noexcept - : DerivationExpression_ExpressionMap() { - *this = ::std::move(from); - } - - inline DerivationExpression_ExpressionMap& operator=(const DerivationExpression_ExpressionMap& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_ExpressionMap& operator=(DerivationExpression_ExpressionMap&& 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 DerivationExpression_ExpressionMap& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_ExpressionMap* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_ExpressionMap_default_instance_); - } - static constexpr int kIndexInFileMessages = - 7; - - friend void swap(DerivationExpression_ExpressionMap& a, DerivationExpression_ExpressionMap& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_ExpressionMap* 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(DerivationExpression_ExpressionMap* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_ExpressionMap* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_ExpressionMap& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_ExpressionMap& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_ExpressionMap* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.ExpressionMap"; - } - protected: - explicit DerivationExpression_ExpressionMap(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kKeyFieldNumber = 1, - kValueFieldNumber = 2, - kVariationPointerFieldNumber = 3, - kNullabilityFieldNumber = 4, - }; - // .substrait.DerivationExpression key = 1; - bool has_key() const; - private: - bool _internal_has_key() const; - public: - void clear_key(); - const ::substrait::DerivationExpression& key() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_key(); - ::substrait::DerivationExpression* mutable_key(); - void set_allocated_key(::substrait::DerivationExpression* key); - private: - const ::substrait::DerivationExpression& _internal_key() const; - ::substrait::DerivationExpression* _internal_mutable_key(); - public: - void unsafe_arena_set_allocated_key( - ::substrait::DerivationExpression* key); - ::substrait::DerivationExpression* unsafe_arena_release_key(); - - // .substrait.DerivationExpression value = 2; - bool has_value() const; - private: - bool _internal_has_value() const; - public: - void clear_value(); - const ::substrait::DerivationExpression& value() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_value(); - ::substrait::DerivationExpression* mutable_value(); - void set_allocated_value(::substrait::DerivationExpression* value); - private: - const ::substrait::DerivationExpression& _internal_value() const; - ::substrait::DerivationExpression* _internal_mutable_value(); - public: - void unsafe_arena_set_allocated_value( - ::substrait::DerivationExpression* value); - ::substrait::DerivationExpression* unsafe_arena_release_value(); - - // uint32 variation_pointer = 3; - void clear_variation_pointer(); - uint32_t variation_pointer() const; - void set_variation_pointer(uint32_t value); - private: - uint32_t _internal_variation_pointer() const; - void _internal_set_variation_pointer(uint32_t value); - public: - - // .substrait.Type.Nullability nullability = 4; - void clear_nullability(); - ::substrait::Type_Nullability nullability() const; - void set_nullability(::substrait::Type_Nullability value); - private: - ::substrait::Type_Nullability _internal_nullability() const; - void _internal_set_nullability(::substrait::Type_Nullability value); - public: - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ExpressionMap) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::DerivationExpression* key_; - ::substrait::DerivationExpression* value_; - uint32_t variation_pointer_; - int nullability_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_IfElse final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.IfElse) */ { - public: - inline DerivationExpression_IfElse() : DerivationExpression_IfElse(nullptr) {} - ~DerivationExpression_IfElse() override; - explicit constexpr DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_IfElse(const DerivationExpression_IfElse& from); - DerivationExpression_IfElse(DerivationExpression_IfElse&& from) noexcept - : DerivationExpression_IfElse() { - *this = ::std::move(from); - } - - inline DerivationExpression_IfElse& operator=(const DerivationExpression_IfElse& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_IfElse& operator=(DerivationExpression_IfElse&& 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 DerivationExpression_IfElse& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_IfElse* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_IfElse_default_instance_); - } - static constexpr int kIndexInFileMessages = - 8; - - friend void swap(DerivationExpression_IfElse& a, DerivationExpression_IfElse& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_IfElse* 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(DerivationExpression_IfElse* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_IfElse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_IfElse& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_IfElse& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_IfElse* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.IfElse"; - } - protected: - explicit DerivationExpression_IfElse(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kIfConditionFieldNumber = 1, - kIfReturnFieldNumber = 2, - kElseReturnFieldNumber = 3, - }; - // .substrait.DerivationExpression if_condition = 1; - bool has_if_condition() const; - private: - bool _internal_has_if_condition() const; - public: - void clear_if_condition(); - const ::substrait::DerivationExpression& if_condition() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_if_condition(); - ::substrait::DerivationExpression* mutable_if_condition(); - void set_allocated_if_condition(::substrait::DerivationExpression* if_condition); - private: - const ::substrait::DerivationExpression& _internal_if_condition() const; - ::substrait::DerivationExpression* _internal_mutable_if_condition(); - public: - void unsafe_arena_set_allocated_if_condition( - ::substrait::DerivationExpression* if_condition); - ::substrait::DerivationExpression* unsafe_arena_release_if_condition(); - - // .substrait.DerivationExpression if_return = 2; - bool has_if_return() const; - private: - bool _internal_has_if_return() const; - public: - void clear_if_return(); - const ::substrait::DerivationExpression& if_return() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_if_return(); - ::substrait::DerivationExpression* mutable_if_return(); - void set_allocated_if_return(::substrait::DerivationExpression* if_return); - private: - const ::substrait::DerivationExpression& _internal_if_return() const; - ::substrait::DerivationExpression* _internal_mutable_if_return(); - public: - void unsafe_arena_set_allocated_if_return( - ::substrait::DerivationExpression* if_return); - ::substrait::DerivationExpression* unsafe_arena_release_if_return(); - - // .substrait.DerivationExpression else_return = 3; - bool has_else_return() const; - private: - bool _internal_has_else_return() const; - public: - void clear_else_return(); - const ::substrait::DerivationExpression& else_return() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_else_return(); - ::substrait::DerivationExpression* mutable_else_return(); - void set_allocated_else_return(::substrait::DerivationExpression* else_return); - private: - const ::substrait::DerivationExpression& _internal_else_return() const; - ::substrait::DerivationExpression* _internal_mutable_else_return(); - public: - void unsafe_arena_set_allocated_else_return( - ::substrait::DerivationExpression* else_return); - ::substrait::DerivationExpression* unsafe_arena_release_else_return(); - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.IfElse) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::DerivationExpression* if_condition_; - ::substrait::DerivationExpression* if_return_; - ::substrait::DerivationExpression* else_return_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_UnaryOp final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.UnaryOp) */ { - public: - inline DerivationExpression_UnaryOp() : DerivationExpression_UnaryOp(nullptr) {} - ~DerivationExpression_UnaryOp() override; - explicit constexpr DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_UnaryOp(const DerivationExpression_UnaryOp& from); - DerivationExpression_UnaryOp(DerivationExpression_UnaryOp&& from) noexcept - : DerivationExpression_UnaryOp() { - *this = ::std::move(from); - } - - inline DerivationExpression_UnaryOp& operator=(const DerivationExpression_UnaryOp& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_UnaryOp& operator=(DerivationExpression_UnaryOp&& 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 DerivationExpression_UnaryOp& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_UnaryOp* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_UnaryOp_default_instance_); - } - static constexpr int kIndexInFileMessages = - 9; - - friend void swap(DerivationExpression_UnaryOp& a, DerivationExpression_UnaryOp& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_UnaryOp* 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(DerivationExpression_UnaryOp* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_UnaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_UnaryOp& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_UnaryOp& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_UnaryOp* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.UnaryOp"; - } - protected: - explicit DerivationExpression_UnaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef DerivationExpression_UnaryOp_UnaryOpType UnaryOpType; - static constexpr UnaryOpType UNARY_OP_TYPE_UNSPECIFIED = - DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_UNSPECIFIED; - static constexpr UnaryOpType UNARY_OP_TYPE_BOOLEAN_NOT = - DerivationExpression_UnaryOp_UnaryOpType_UNARY_OP_TYPE_BOOLEAN_NOT; - static inline bool UnaryOpType_IsValid(int value) { - return DerivationExpression_UnaryOp_UnaryOpType_IsValid(value); - } - static constexpr UnaryOpType UnaryOpType_MIN = - DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MIN; - static constexpr UnaryOpType UnaryOpType_MAX = - DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_MAX; - static constexpr int UnaryOpType_ARRAYSIZE = - DerivationExpression_UnaryOp_UnaryOpType_UnaryOpType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - UnaryOpType_descriptor() { - return DerivationExpression_UnaryOp_UnaryOpType_descriptor(); - } - template - static inline const std::string& UnaryOpType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function UnaryOpType_Name."); - return DerivationExpression_UnaryOp_UnaryOpType_Name(enum_t_value); - } - static inline bool UnaryOpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - UnaryOpType* value) { - return DerivationExpression_UnaryOp_UnaryOpType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kArgFieldNumber = 2, - kOpTypeFieldNumber = 1, - }; - // .substrait.DerivationExpression arg = 2; - bool has_arg() const; - private: - bool _internal_has_arg() const; - public: - void clear_arg(); - const ::substrait::DerivationExpression& arg() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg(); - ::substrait::DerivationExpression* mutable_arg(); - void set_allocated_arg(::substrait::DerivationExpression* arg); - private: - const ::substrait::DerivationExpression& _internal_arg() const; - ::substrait::DerivationExpression* _internal_mutable_arg(); - public: - void unsafe_arena_set_allocated_arg( - ::substrait::DerivationExpression* arg); - ::substrait::DerivationExpression* unsafe_arena_release_arg(); - - // .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; - void clear_op_type(); - ::substrait::DerivationExpression_UnaryOp_UnaryOpType op_type() const; - void set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value); - private: - ::substrait::DerivationExpression_UnaryOp_UnaryOpType _internal_op_type() const; - void _internal_set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value); - public: - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.UnaryOp) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::DerivationExpression* arg_; - int op_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_BinaryOp final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.BinaryOp) */ { - public: - inline DerivationExpression_BinaryOp() : DerivationExpression_BinaryOp(nullptr) {} - ~DerivationExpression_BinaryOp() override; - explicit constexpr DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_BinaryOp(const DerivationExpression_BinaryOp& from); - DerivationExpression_BinaryOp(DerivationExpression_BinaryOp&& from) noexcept - : DerivationExpression_BinaryOp() { - *this = ::std::move(from); - } - - inline DerivationExpression_BinaryOp& operator=(const DerivationExpression_BinaryOp& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_BinaryOp& operator=(DerivationExpression_BinaryOp&& 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 DerivationExpression_BinaryOp& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_BinaryOp* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_BinaryOp_default_instance_); - } - static constexpr int kIndexInFileMessages = - 10; - - friend void swap(DerivationExpression_BinaryOp& a, DerivationExpression_BinaryOp& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_BinaryOp* 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(DerivationExpression_BinaryOp* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_BinaryOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_BinaryOp& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_BinaryOp& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_BinaryOp* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.BinaryOp"; - } - protected: - explicit DerivationExpression_BinaryOp(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef DerivationExpression_BinaryOp_BinaryOpType BinaryOpType; - static constexpr BinaryOpType BINARY_OP_TYPE_UNSPECIFIED = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_UNSPECIFIED; - static constexpr BinaryOpType BINARY_OP_TYPE_PLUS = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_PLUS; - static constexpr BinaryOpType BINARY_OP_TYPE_MINUS = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MINUS; - static constexpr BinaryOpType BINARY_OP_TYPE_MULTIPLY = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MULTIPLY; - static constexpr BinaryOpType BINARY_OP_TYPE_DIVIDE = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_DIVIDE; - static constexpr BinaryOpType BINARY_OP_TYPE_MIN = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MIN; - static constexpr BinaryOpType BINARY_OP_TYPE_MAX = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_MAX; - static constexpr BinaryOpType BINARY_OP_TYPE_GREATER_THAN = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_GREATER_THAN; - static constexpr BinaryOpType BINARY_OP_TYPE_LESS_THAN = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_LESS_THAN; - static constexpr BinaryOpType BINARY_OP_TYPE_AND = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_AND; - static constexpr BinaryOpType BINARY_OP_TYPE_OR = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_OR; - static constexpr BinaryOpType BINARY_OP_TYPE_EQUALS = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_EQUALS; - static constexpr BinaryOpType BINARY_OP_TYPE_COVERS = - DerivationExpression_BinaryOp_BinaryOpType_BINARY_OP_TYPE_COVERS; - static inline bool BinaryOpType_IsValid(int value) { - return DerivationExpression_BinaryOp_BinaryOpType_IsValid(value); - } - static constexpr BinaryOpType BinaryOpType_MIN = - DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MIN; - static constexpr BinaryOpType BinaryOpType_MAX = - DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_MAX; - static constexpr int BinaryOpType_ARRAYSIZE = - DerivationExpression_BinaryOp_BinaryOpType_BinaryOpType_ARRAYSIZE; - static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* - BinaryOpType_descriptor() { - return DerivationExpression_BinaryOp_BinaryOpType_descriptor(); - } - template - static inline const std::string& BinaryOpType_Name(T enum_t_value) { - static_assert(::std::is_same::value || - ::std::is_integral::value, - "Incorrect type passed to function BinaryOpType_Name."); - return DerivationExpression_BinaryOp_BinaryOpType_Name(enum_t_value); - } - static inline bool BinaryOpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, - BinaryOpType* value) { - return DerivationExpression_BinaryOp_BinaryOpType_Parse(name, value); - } - - // accessors ------------------------------------------------------- - - enum : int { - kArg1FieldNumber = 2, - kArg2FieldNumber = 3, - kOpTypeFieldNumber = 1, - }; - // .substrait.DerivationExpression arg1 = 2; - bool has_arg1() const; - private: - bool _internal_has_arg1() const; - public: - void clear_arg1(); - const ::substrait::DerivationExpression& arg1() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg1(); - ::substrait::DerivationExpression* mutable_arg1(); - void set_allocated_arg1(::substrait::DerivationExpression* arg1); - private: - const ::substrait::DerivationExpression& _internal_arg1() const; - ::substrait::DerivationExpression* _internal_mutable_arg1(); - public: - void unsafe_arena_set_allocated_arg1( - ::substrait::DerivationExpression* arg1); - ::substrait::DerivationExpression* unsafe_arena_release_arg1(); - - // .substrait.DerivationExpression arg2 = 3; - bool has_arg2() const; - private: - bool _internal_has_arg2() const; - public: - void clear_arg2(); - const ::substrait::DerivationExpression& arg2() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_arg2(); - ::substrait::DerivationExpression* mutable_arg2(); - void set_allocated_arg2(::substrait::DerivationExpression* arg2); - private: - const ::substrait::DerivationExpression& _internal_arg2() const; - ::substrait::DerivationExpression* _internal_mutable_arg2(); - public: - void unsafe_arena_set_allocated_arg2( - ::substrait::DerivationExpression* arg2); - ::substrait::DerivationExpression* unsafe_arena_release_arg2(); - - // .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; - void clear_op_type(); - ::substrait::DerivationExpression_BinaryOp_BinaryOpType op_type() const; - void set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value); - private: - ::substrait::DerivationExpression_BinaryOp_BinaryOpType _internal_op_type() const; - void _internal_set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value); - public: - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.BinaryOp) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::substrait::DerivationExpression* arg1_; - ::substrait::DerivationExpression* arg2_; - int op_type_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_ReturnProgram_Assignment final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ReturnProgram.Assignment) */ { - public: - inline DerivationExpression_ReturnProgram_Assignment() : DerivationExpression_ReturnProgram_Assignment(nullptr) {} - ~DerivationExpression_ReturnProgram_Assignment() override; - explicit constexpr DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_ReturnProgram_Assignment(const DerivationExpression_ReturnProgram_Assignment& from); - DerivationExpression_ReturnProgram_Assignment(DerivationExpression_ReturnProgram_Assignment&& from) noexcept - : DerivationExpression_ReturnProgram_Assignment() { - *this = ::std::move(from); - } - - inline DerivationExpression_ReturnProgram_Assignment& operator=(const DerivationExpression_ReturnProgram_Assignment& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_ReturnProgram_Assignment& operator=(DerivationExpression_ReturnProgram_Assignment&& 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 DerivationExpression_ReturnProgram_Assignment& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_ReturnProgram_Assignment* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_ReturnProgram_Assignment_default_instance_); - } - static constexpr int kIndexInFileMessages = - 11; - - friend void swap(DerivationExpression_ReturnProgram_Assignment& a, DerivationExpression_ReturnProgram_Assignment& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_ReturnProgram_Assignment* 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(DerivationExpression_ReturnProgram_Assignment* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_ReturnProgram_Assignment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_ReturnProgram_Assignment& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_ReturnProgram_Assignment& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_ReturnProgram_Assignment* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.ReturnProgram.Assignment"; - } - protected: - explicit DerivationExpression_ReturnProgram_Assignment(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - 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 { - kNameFieldNumber = 1, - kExpressionFieldNumber = 2, - }; - // string name = 1; - void clear_name(); - const std::string& name() const; - template - void set_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* name); - private: - const std::string& _internal_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value); - std::string* _internal_mutable_name(); - public: - - // .substrait.DerivationExpression expression = 2; - bool has_expression() const; - private: - bool _internal_has_expression() const; - public: - void clear_expression(); - const ::substrait::DerivationExpression& expression() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_expression(); - ::substrait::DerivationExpression* mutable_expression(); - void set_allocated_expression(::substrait::DerivationExpression* expression); - private: - const ::substrait::DerivationExpression& _internal_expression() const; - ::substrait::DerivationExpression* _internal_mutable_expression(); - public: - void unsafe_arena_set_allocated_expression( - ::substrait::DerivationExpression* expression); - ::substrait::DerivationExpression* unsafe_arena_release_expression(); - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ReturnProgram.Assignment) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_; - ::substrait::DerivationExpression* expression_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression_ReturnProgram final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression.ReturnProgram) */ { - public: - inline DerivationExpression_ReturnProgram() : DerivationExpression_ReturnProgram(nullptr) {} - ~DerivationExpression_ReturnProgram() override; - explicit constexpr DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression_ReturnProgram(const DerivationExpression_ReturnProgram& from); - DerivationExpression_ReturnProgram(DerivationExpression_ReturnProgram&& from) noexcept - : DerivationExpression_ReturnProgram() { - *this = ::std::move(from); - } - - inline DerivationExpression_ReturnProgram& operator=(const DerivationExpression_ReturnProgram& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression_ReturnProgram& operator=(DerivationExpression_ReturnProgram&& 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 DerivationExpression_ReturnProgram& default_instance() { - return *internal_default_instance(); - } - static inline const DerivationExpression_ReturnProgram* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_ReturnProgram_default_instance_); - } - static constexpr int kIndexInFileMessages = - 12; - - friend void swap(DerivationExpression_ReturnProgram& a, DerivationExpression_ReturnProgram& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression_ReturnProgram* 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(DerivationExpression_ReturnProgram* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression_ReturnProgram* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression_ReturnProgram& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression_ReturnProgram& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression_ReturnProgram* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression.ReturnProgram"; - } - protected: - explicit DerivationExpression_ReturnProgram(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef DerivationExpression_ReturnProgram_Assignment Assignment; - - // accessors ------------------------------------------------------- - - enum : int { - kAssignmentsFieldNumber = 1, - kFinalExpressionFieldNumber = 2, - }; - // repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; - int assignments_size() const; - private: - int _internal_assignments_size() const; - public: - void clear_assignments(); - ::substrait::DerivationExpression_ReturnProgram_Assignment* mutable_assignments(int index); - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >* - mutable_assignments(); - private: - const ::substrait::DerivationExpression_ReturnProgram_Assignment& _internal_assignments(int index) const; - ::substrait::DerivationExpression_ReturnProgram_Assignment* _internal_add_assignments(); - public: - const ::substrait::DerivationExpression_ReturnProgram_Assignment& assignments(int index) const; - ::substrait::DerivationExpression_ReturnProgram_Assignment* add_assignments(); - const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >& - assignments() const; - - // .substrait.DerivationExpression final_expression = 2; - bool has_final_expression() const; - private: - bool _internal_has_final_expression() const; - public: - void clear_final_expression(); - const ::substrait::DerivationExpression& final_expression() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression* release_final_expression(); - ::substrait::DerivationExpression* mutable_final_expression(); - void set_allocated_final_expression(::substrait::DerivationExpression* final_expression); - private: - const ::substrait::DerivationExpression& _internal_final_expression() const; - ::substrait::DerivationExpression* _internal_mutable_final_expression(); - public: - void unsafe_arena_set_allocated_final_expression( - ::substrait::DerivationExpression* final_expression); - ::substrait::DerivationExpression* unsafe_arena_release_final_expression(); - - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression.ReturnProgram) - private: - class _Internal; - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment > assignments_; - ::substrait::DerivationExpression* final_expression_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// ------------------------------------------------------------------- - -class DerivationExpression final : - public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:substrait.DerivationExpression) */ { - public: - inline DerivationExpression() : DerivationExpression(nullptr) {} - ~DerivationExpression() override; - explicit constexpr DerivationExpression(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); - - DerivationExpression(const DerivationExpression& from); - DerivationExpression(DerivationExpression&& from) noexcept - : DerivationExpression() { - *this = ::std::move(from); - } - - inline DerivationExpression& operator=(const DerivationExpression& from) { - CopyFrom(from); - return *this; - } - inline DerivationExpression& operator=(DerivationExpression&& 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 DerivationExpression& default_instance() { - return *internal_default_instance(); - } - enum KindCase { - kBool = 1, - kI8 = 2, - kI16 = 3, - kI32 = 5, - kI64 = 7, - kFp32 = 10, - kFp64 = 11, - kString = 12, - kBinary = 13, - kTimestamp = 14, - kDate = 16, - kTime = 17, - kIntervalYear = 19, - kIntervalDay = 20, - kTimestampTz = 29, - kUuid = 32, - kFixedChar = 21, - kVarchar = 22, - kFixedBinary = 23, - kDecimal = 24, - kStruct = 25, - kList = 27, - kMap = 28, - kUserDefinedPointer = 31, - kTypeParameterName = 33, - kIntegerParameterName = 34, - kIntegerLiteral = 35, - kUnaryOp = 36, - kBinaryOp = 37, - kIfElse = 38, - kReturnProgram = 39, - KIND_NOT_SET = 0, - }; - - static inline const DerivationExpression* internal_default_instance() { - return reinterpret_cast( - &_DerivationExpression_default_instance_); - } - static constexpr int kIndexInFileMessages = - 13; - - friend void swap(DerivationExpression& a, DerivationExpression& b) { - a.Swap(&b); - } - inline void Swap(DerivationExpression* 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(DerivationExpression* other) { - if (other == this) return; - GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DerivationExpression* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { - return CreateMaybeMessage(arena); - } - using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; - void CopyFrom(const DerivationExpression& from); - using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; - void MergeFrom(const DerivationExpression& from); - private: - static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from); - 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 _cached_size_.Get(); } - - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const final; - void InternalSwap(DerivationExpression* other); - - private: - friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; - static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { - return "substrait.DerivationExpression"; - } - protected: - explicit DerivationExpression(::PROTOBUF_NAMESPACE_ID::Arena* arena, - bool is_message_owned = false); - private: - static void ArenaDtor(void* object); - inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena); - public: - - static const ClassData _class_data_; - const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; - - ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; - - // nested types ---------------------------------------------------- - - typedef DerivationExpression_ExpressionFixedChar ExpressionFixedChar; - typedef DerivationExpression_ExpressionVarChar ExpressionVarChar; - typedef DerivationExpression_ExpressionFixedBinary ExpressionFixedBinary; - typedef DerivationExpression_ExpressionDecimal ExpressionDecimal; - typedef DerivationExpression_ExpressionStruct ExpressionStruct; - typedef DerivationExpression_ExpressionNamedStruct ExpressionNamedStruct; - typedef DerivationExpression_ExpressionList ExpressionList; - typedef DerivationExpression_ExpressionMap ExpressionMap; - typedef DerivationExpression_IfElse IfElse; - typedef DerivationExpression_UnaryOp UnaryOp; - typedef DerivationExpression_BinaryOp BinaryOp; - typedef DerivationExpression_ReturnProgram ReturnProgram; - - // accessors ------------------------------------------------------- - - enum : int { - kBoolFieldNumber = 1, - kI8FieldNumber = 2, - kI16FieldNumber = 3, - kI32FieldNumber = 5, - kI64FieldNumber = 7, - kFp32FieldNumber = 10, - kFp64FieldNumber = 11, - kStringFieldNumber = 12, - kBinaryFieldNumber = 13, - kTimestampFieldNumber = 14, - kDateFieldNumber = 16, - kTimeFieldNumber = 17, - kIntervalYearFieldNumber = 19, - kIntervalDayFieldNumber = 20, - kTimestampTzFieldNumber = 29, - kUuidFieldNumber = 32, - kFixedCharFieldNumber = 21, - kVarcharFieldNumber = 22, - kFixedBinaryFieldNumber = 23, - kDecimalFieldNumber = 24, - kStructFieldNumber = 25, - kListFieldNumber = 27, - kMapFieldNumber = 28, - kUserDefinedPointerFieldNumber = 31, - kTypeParameterNameFieldNumber = 33, - kIntegerParameterNameFieldNumber = 34, - kIntegerLiteralFieldNumber = 35, - kUnaryOpFieldNumber = 36, - kBinaryOpFieldNumber = 37, - kIfElseFieldNumber = 38, - kReturnProgramFieldNumber = 39, - }; - // .substrait.Type.Boolean bool = 1; - bool has_bool_() const; - private: - bool _internal_has_bool_() const; - public: - void clear_bool_(); - const ::substrait::Type_Boolean& bool_() const; - PROTOBUF_NODISCARD ::substrait::Type_Boolean* release_bool_(); - ::substrait::Type_Boolean* mutable_bool_(); - void set_allocated_bool_(::substrait::Type_Boolean* bool_); - private: - const ::substrait::Type_Boolean& _internal_bool_() const; - ::substrait::Type_Boolean* _internal_mutable_bool_(); - public: - void unsafe_arena_set_allocated_bool_( - ::substrait::Type_Boolean* bool_); - ::substrait::Type_Boolean* unsafe_arena_release_bool_(); - - // .substrait.Type.I8 i8 = 2; - bool has_i8() const; - private: - bool _internal_has_i8() const; - public: - void clear_i8(); - const ::substrait::Type_I8& i8() const; - PROTOBUF_NODISCARD ::substrait::Type_I8* release_i8(); - ::substrait::Type_I8* mutable_i8(); - void set_allocated_i8(::substrait::Type_I8* i8); - private: - const ::substrait::Type_I8& _internal_i8() const; - ::substrait::Type_I8* _internal_mutable_i8(); - public: - void unsafe_arena_set_allocated_i8( - ::substrait::Type_I8* i8); - ::substrait::Type_I8* unsafe_arena_release_i8(); - - // .substrait.Type.I16 i16 = 3; - bool has_i16() const; - private: - bool _internal_has_i16() const; - public: - void clear_i16(); - const ::substrait::Type_I16& i16() const; - PROTOBUF_NODISCARD ::substrait::Type_I16* release_i16(); - ::substrait::Type_I16* mutable_i16(); - void set_allocated_i16(::substrait::Type_I16* i16); - private: - const ::substrait::Type_I16& _internal_i16() const; - ::substrait::Type_I16* _internal_mutable_i16(); - public: - void unsafe_arena_set_allocated_i16( - ::substrait::Type_I16* i16); - ::substrait::Type_I16* unsafe_arena_release_i16(); - - // .substrait.Type.I32 i32 = 5; - bool has_i32() const; - private: - bool _internal_has_i32() const; - public: - void clear_i32(); - const ::substrait::Type_I32& i32() const; - PROTOBUF_NODISCARD ::substrait::Type_I32* release_i32(); - ::substrait::Type_I32* mutable_i32(); - void set_allocated_i32(::substrait::Type_I32* i32); - private: - const ::substrait::Type_I32& _internal_i32() const; - ::substrait::Type_I32* _internal_mutable_i32(); - public: - void unsafe_arena_set_allocated_i32( - ::substrait::Type_I32* i32); - ::substrait::Type_I32* unsafe_arena_release_i32(); - - // .substrait.Type.I64 i64 = 7; - bool has_i64() const; - private: - bool _internal_has_i64() const; - public: - void clear_i64(); - const ::substrait::Type_I64& i64() const; - PROTOBUF_NODISCARD ::substrait::Type_I64* release_i64(); - ::substrait::Type_I64* mutable_i64(); - void set_allocated_i64(::substrait::Type_I64* i64); - private: - const ::substrait::Type_I64& _internal_i64() const; - ::substrait::Type_I64* _internal_mutable_i64(); - public: - void unsafe_arena_set_allocated_i64( - ::substrait::Type_I64* i64); - ::substrait::Type_I64* unsafe_arena_release_i64(); - - // .substrait.Type.FP32 fp32 = 10; - bool has_fp32() const; - private: - bool _internal_has_fp32() const; - public: - void clear_fp32(); - const ::substrait::Type_FP32& fp32() const; - PROTOBUF_NODISCARD ::substrait::Type_FP32* release_fp32(); - ::substrait::Type_FP32* mutable_fp32(); - void set_allocated_fp32(::substrait::Type_FP32* fp32); - private: - const ::substrait::Type_FP32& _internal_fp32() const; - ::substrait::Type_FP32* _internal_mutable_fp32(); - public: - void unsafe_arena_set_allocated_fp32( - ::substrait::Type_FP32* fp32); - ::substrait::Type_FP32* unsafe_arena_release_fp32(); - - // .substrait.Type.FP64 fp64 = 11; - bool has_fp64() const; - private: - bool _internal_has_fp64() const; - public: - void clear_fp64(); - const ::substrait::Type_FP64& fp64() const; - PROTOBUF_NODISCARD ::substrait::Type_FP64* release_fp64(); - ::substrait::Type_FP64* mutable_fp64(); - void set_allocated_fp64(::substrait::Type_FP64* fp64); - private: - const ::substrait::Type_FP64& _internal_fp64() const; - ::substrait::Type_FP64* _internal_mutable_fp64(); - public: - void unsafe_arena_set_allocated_fp64( - ::substrait::Type_FP64* fp64); - ::substrait::Type_FP64* unsafe_arena_release_fp64(); - - // .substrait.Type.String string = 12; - bool has_string() const; - private: - bool _internal_has_string() const; - public: - void clear_string(); - const ::substrait::Type_String& string() const; - PROTOBUF_NODISCARD ::substrait::Type_String* release_string(); - ::substrait::Type_String* mutable_string(); - void set_allocated_string(::substrait::Type_String* string); - private: - const ::substrait::Type_String& _internal_string() const; - ::substrait::Type_String* _internal_mutable_string(); - public: - void unsafe_arena_set_allocated_string( - ::substrait::Type_String* string); - ::substrait::Type_String* unsafe_arena_release_string(); - - // .substrait.Type.Binary binary = 13; - bool has_binary() const; - private: - bool _internal_has_binary() const; - public: - void clear_binary(); - const ::substrait::Type_Binary& binary() const; - PROTOBUF_NODISCARD ::substrait::Type_Binary* release_binary(); - ::substrait::Type_Binary* mutable_binary(); - void set_allocated_binary(::substrait::Type_Binary* binary); - private: - const ::substrait::Type_Binary& _internal_binary() const; - ::substrait::Type_Binary* _internal_mutable_binary(); - public: - void unsafe_arena_set_allocated_binary( - ::substrait::Type_Binary* binary); - ::substrait::Type_Binary* unsafe_arena_release_binary(); - - // .substrait.Type.Timestamp timestamp = 14; - bool has_timestamp() const; - private: - bool _internal_has_timestamp() const; - public: - void clear_timestamp(); - const ::substrait::Type_Timestamp& timestamp() const; - PROTOBUF_NODISCARD ::substrait::Type_Timestamp* release_timestamp(); - ::substrait::Type_Timestamp* mutable_timestamp(); - void set_allocated_timestamp(::substrait::Type_Timestamp* timestamp); - private: - const ::substrait::Type_Timestamp& _internal_timestamp() const; - ::substrait::Type_Timestamp* _internal_mutable_timestamp(); - public: - void unsafe_arena_set_allocated_timestamp( - ::substrait::Type_Timestamp* timestamp); - ::substrait::Type_Timestamp* unsafe_arena_release_timestamp(); - - // .substrait.Type.Date date = 16; - bool has_date() const; - private: - bool _internal_has_date() const; - public: - void clear_date(); - const ::substrait::Type_Date& date() const; - PROTOBUF_NODISCARD ::substrait::Type_Date* release_date(); - ::substrait::Type_Date* mutable_date(); - void set_allocated_date(::substrait::Type_Date* date); - private: - const ::substrait::Type_Date& _internal_date() const; - ::substrait::Type_Date* _internal_mutable_date(); - public: - void unsafe_arena_set_allocated_date( - ::substrait::Type_Date* date); - ::substrait::Type_Date* unsafe_arena_release_date(); - - // .substrait.Type.Time time = 17; - bool has_time() const; - private: - bool _internal_has_time() const; - public: - void clear_time(); - const ::substrait::Type_Time& time() const; - PROTOBUF_NODISCARD ::substrait::Type_Time* release_time(); - ::substrait::Type_Time* mutable_time(); - void set_allocated_time(::substrait::Type_Time* time); - private: - const ::substrait::Type_Time& _internal_time() const; - ::substrait::Type_Time* _internal_mutable_time(); - public: - void unsafe_arena_set_allocated_time( - ::substrait::Type_Time* time); - ::substrait::Type_Time* unsafe_arena_release_time(); - - // .substrait.Type.IntervalYear interval_year = 19; - bool has_interval_year() const; - private: - bool _internal_has_interval_year() const; - public: - void clear_interval_year(); - const ::substrait::Type_IntervalYear& interval_year() const; - PROTOBUF_NODISCARD ::substrait::Type_IntervalYear* release_interval_year(); - ::substrait::Type_IntervalYear* mutable_interval_year(); - void set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year); - private: - const ::substrait::Type_IntervalYear& _internal_interval_year() const; - ::substrait::Type_IntervalYear* _internal_mutable_interval_year(); - public: - void unsafe_arena_set_allocated_interval_year( - ::substrait::Type_IntervalYear* interval_year); - ::substrait::Type_IntervalYear* unsafe_arena_release_interval_year(); - - // .substrait.Type.IntervalDay interval_day = 20; - bool has_interval_day() const; - private: - bool _internal_has_interval_day() const; - public: - void clear_interval_day(); - const ::substrait::Type_IntervalDay& interval_day() const; - PROTOBUF_NODISCARD ::substrait::Type_IntervalDay* release_interval_day(); - ::substrait::Type_IntervalDay* mutable_interval_day(); - void set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day); - private: - const ::substrait::Type_IntervalDay& _internal_interval_day() const; - ::substrait::Type_IntervalDay* _internal_mutable_interval_day(); - public: - void unsafe_arena_set_allocated_interval_day( - ::substrait::Type_IntervalDay* interval_day); - ::substrait::Type_IntervalDay* unsafe_arena_release_interval_day(); - - // .substrait.Type.TimestampTZ timestamp_tz = 29; - bool has_timestamp_tz() const; - private: - bool _internal_has_timestamp_tz() const; - public: - void clear_timestamp_tz(); - const ::substrait::Type_TimestampTZ& timestamp_tz() const; - PROTOBUF_NODISCARD ::substrait::Type_TimestampTZ* release_timestamp_tz(); - ::substrait::Type_TimestampTZ* mutable_timestamp_tz(); - void set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz); - private: - const ::substrait::Type_TimestampTZ& _internal_timestamp_tz() const; - ::substrait::Type_TimestampTZ* _internal_mutable_timestamp_tz(); - public: - void unsafe_arena_set_allocated_timestamp_tz( - ::substrait::Type_TimestampTZ* timestamp_tz); - ::substrait::Type_TimestampTZ* unsafe_arena_release_timestamp_tz(); - - // .substrait.Type.UUID uuid = 32; - bool has_uuid() const; - private: - bool _internal_has_uuid() const; - public: - void clear_uuid(); - const ::substrait::Type_UUID& uuid() const; - PROTOBUF_NODISCARD ::substrait::Type_UUID* release_uuid(); - ::substrait::Type_UUID* mutable_uuid(); - void set_allocated_uuid(::substrait::Type_UUID* uuid); - private: - const ::substrait::Type_UUID& _internal_uuid() const; - ::substrait::Type_UUID* _internal_mutable_uuid(); - public: - void unsafe_arena_set_allocated_uuid( - ::substrait::Type_UUID* uuid); - ::substrait::Type_UUID* unsafe_arena_release_uuid(); - - // .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; - bool has_fixed_char() const; - private: - bool _internal_has_fixed_char() const; - public: - void clear_fixed_char(); - const ::substrait::DerivationExpression_ExpressionFixedChar& fixed_char() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionFixedChar* release_fixed_char(); - ::substrait::DerivationExpression_ExpressionFixedChar* mutable_fixed_char(); - void set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char); - private: - const ::substrait::DerivationExpression_ExpressionFixedChar& _internal_fixed_char() const; - ::substrait::DerivationExpression_ExpressionFixedChar* _internal_mutable_fixed_char(); - public: - void unsafe_arena_set_allocated_fixed_char( - ::substrait::DerivationExpression_ExpressionFixedChar* fixed_char); - ::substrait::DerivationExpression_ExpressionFixedChar* unsafe_arena_release_fixed_char(); - - // .substrait.DerivationExpression.ExpressionVarChar varchar = 22; - bool has_varchar() const; - private: - bool _internal_has_varchar() const; - public: - void clear_varchar(); - const ::substrait::DerivationExpression_ExpressionVarChar& varchar() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionVarChar* release_varchar(); - ::substrait::DerivationExpression_ExpressionVarChar* mutable_varchar(); - void set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar); - private: - const ::substrait::DerivationExpression_ExpressionVarChar& _internal_varchar() const; - ::substrait::DerivationExpression_ExpressionVarChar* _internal_mutable_varchar(); - public: - void unsafe_arena_set_allocated_varchar( - ::substrait::DerivationExpression_ExpressionVarChar* varchar); - ::substrait::DerivationExpression_ExpressionVarChar* unsafe_arena_release_varchar(); - - // .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; - bool has_fixed_binary() const; - private: - bool _internal_has_fixed_binary() const; - public: - void clear_fixed_binary(); - const ::substrait::DerivationExpression_ExpressionFixedBinary& fixed_binary() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionFixedBinary* release_fixed_binary(); - ::substrait::DerivationExpression_ExpressionFixedBinary* mutable_fixed_binary(); - void set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary); - private: - const ::substrait::DerivationExpression_ExpressionFixedBinary& _internal_fixed_binary() const; - ::substrait::DerivationExpression_ExpressionFixedBinary* _internal_mutable_fixed_binary(); - public: - void unsafe_arena_set_allocated_fixed_binary( - ::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary); - ::substrait::DerivationExpression_ExpressionFixedBinary* unsafe_arena_release_fixed_binary(); - - // .substrait.DerivationExpression.ExpressionDecimal decimal = 24; - bool has_decimal() const; - private: - bool _internal_has_decimal() const; - public: - void clear_decimal(); - const ::substrait::DerivationExpression_ExpressionDecimal& decimal() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionDecimal* release_decimal(); - ::substrait::DerivationExpression_ExpressionDecimal* mutable_decimal(); - void set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal); - private: - const ::substrait::DerivationExpression_ExpressionDecimal& _internal_decimal() const; - ::substrait::DerivationExpression_ExpressionDecimal* _internal_mutable_decimal(); - public: - void unsafe_arena_set_allocated_decimal( - ::substrait::DerivationExpression_ExpressionDecimal* decimal); - ::substrait::DerivationExpression_ExpressionDecimal* unsafe_arena_release_decimal(); - - // .substrait.DerivationExpression.ExpressionStruct struct = 25; - bool has_struct_() const; - private: - bool _internal_has_struct_() const; - public: - void clear_struct_(); - const ::substrait::DerivationExpression_ExpressionStruct& struct_() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionStruct* release_struct_(); - ::substrait::DerivationExpression_ExpressionStruct* mutable_struct_(); - void set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_); - private: - const ::substrait::DerivationExpression_ExpressionStruct& _internal_struct_() const; - ::substrait::DerivationExpression_ExpressionStruct* _internal_mutable_struct_(); - public: - void unsafe_arena_set_allocated_struct_( - ::substrait::DerivationExpression_ExpressionStruct* struct_); - ::substrait::DerivationExpression_ExpressionStruct* unsafe_arena_release_struct_(); - - // .substrait.DerivationExpression.ExpressionList list = 27; - bool has_list() const; - private: - bool _internal_has_list() const; - public: - void clear_list(); - const ::substrait::DerivationExpression_ExpressionList& list() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionList* release_list(); - ::substrait::DerivationExpression_ExpressionList* mutable_list(); - void set_allocated_list(::substrait::DerivationExpression_ExpressionList* list); - private: - const ::substrait::DerivationExpression_ExpressionList& _internal_list() const; - ::substrait::DerivationExpression_ExpressionList* _internal_mutable_list(); - public: - void unsafe_arena_set_allocated_list( - ::substrait::DerivationExpression_ExpressionList* list); - ::substrait::DerivationExpression_ExpressionList* unsafe_arena_release_list(); - - // .substrait.DerivationExpression.ExpressionMap map = 28; - bool has_map() const; - private: - bool _internal_has_map() const; - public: - void clear_map(); - const ::substrait::DerivationExpression_ExpressionMap& map() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_ExpressionMap* release_map(); - ::substrait::DerivationExpression_ExpressionMap* mutable_map(); - void set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map); - private: - const ::substrait::DerivationExpression_ExpressionMap& _internal_map() const; - ::substrait::DerivationExpression_ExpressionMap* _internal_mutable_map(); - public: - void unsafe_arena_set_allocated_map( - ::substrait::DerivationExpression_ExpressionMap* map); - ::substrait::DerivationExpression_ExpressionMap* unsafe_arena_release_map(); - - // uint32 user_defined_pointer = 31; - bool has_user_defined_pointer() const; - private: - bool _internal_has_user_defined_pointer() const; - public: - void clear_user_defined_pointer(); - uint32_t user_defined_pointer() const; - void set_user_defined_pointer(uint32_t value); - private: - uint32_t _internal_user_defined_pointer() const; - void _internal_set_user_defined_pointer(uint32_t value); - public: - - // string type_parameter_name = 33; - bool has_type_parameter_name() const; - private: - bool _internal_has_type_parameter_name() const; - public: - void clear_type_parameter_name(); - const std::string& type_parameter_name() const; - template - void set_type_parameter_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_type_parameter_name(); - PROTOBUF_NODISCARD std::string* release_type_parameter_name(); - void set_allocated_type_parameter_name(std::string* type_parameter_name); - private: - const std::string& _internal_type_parameter_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_type_parameter_name(const std::string& value); - std::string* _internal_mutable_type_parameter_name(); - public: - - // string integer_parameter_name = 34; - bool has_integer_parameter_name() const; - private: - bool _internal_has_integer_parameter_name() const; - public: - void clear_integer_parameter_name(); - const std::string& integer_parameter_name() const; - template - void set_integer_parameter_name(ArgT0&& arg0, ArgT... args); - std::string* mutable_integer_parameter_name(); - PROTOBUF_NODISCARD std::string* release_integer_parameter_name(); - void set_allocated_integer_parameter_name(std::string* integer_parameter_name); - private: - const std::string& _internal_integer_parameter_name() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_integer_parameter_name(const std::string& value); - std::string* _internal_mutable_integer_parameter_name(); - public: - - // int32 integer_literal = 35; - bool has_integer_literal() const; - private: - bool _internal_has_integer_literal() const; - public: - void clear_integer_literal(); - int32_t integer_literal() const; - void set_integer_literal(int32_t value); - private: - int32_t _internal_integer_literal() const; - void _internal_set_integer_literal(int32_t value); - public: - - // .substrait.DerivationExpression.UnaryOp unary_op = 36; - bool has_unary_op() const; - private: - bool _internal_has_unary_op() const; - public: - void clear_unary_op(); - const ::substrait::DerivationExpression_UnaryOp& unary_op() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_UnaryOp* release_unary_op(); - ::substrait::DerivationExpression_UnaryOp* mutable_unary_op(); - void set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op); - private: - const ::substrait::DerivationExpression_UnaryOp& _internal_unary_op() const; - ::substrait::DerivationExpression_UnaryOp* _internal_mutable_unary_op(); - public: - void unsafe_arena_set_allocated_unary_op( - ::substrait::DerivationExpression_UnaryOp* unary_op); - ::substrait::DerivationExpression_UnaryOp* unsafe_arena_release_unary_op(); - - // .substrait.DerivationExpression.BinaryOp binary_op = 37; - bool has_binary_op() const; - private: - bool _internal_has_binary_op() const; - public: - void clear_binary_op(); - const ::substrait::DerivationExpression_BinaryOp& binary_op() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_BinaryOp* release_binary_op(); - ::substrait::DerivationExpression_BinaryOp* mutable_binary_op(); - void set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op); - private: - const ::substrait::DerivationExpression_BinaryOp& _internal_binary_op() const; - ::substrait::DerivationExpression_BinaryOp* _internal_mutable_binary_op(); - public: - void unsafe_arena_set_allocated_binary_op( - ::substrait::DerivationExpression_BinaryOp* binary_op); - ::substrait::DerivationExpression_BinaryOp* unsafe_arena_release_binary_op(); - - // .substrait.DerivationExpression.IfElse if_else = 38; - bool has_if_else() const; - private: - bool _internal_has_if_else() const; - public: - void clear_if_else(); - const ::substrait::DerivationExpression_IfElse& if_else() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_IfElse* release_if_else(); - ::substrait::DerivationExpression_IfElse* mutable_if_else(); - void set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else); - private: - const ::substrait::DerivationExpression_IfElse& _internal_if_else() const; - ::substrait::DerivationExpression_IfElse* _internal_mutable_if_else(); - public: - void unsafe_arena_set_allocated_if_else( - ::substrait::DerivationExpression_IfElse* if_else); - ::substrait::DerivationExpression_IfElse* unsafe_arena_release_if_else(); - - // .substrait.DerivationExpression.ReturnProgram return_program = 39; - bool has_return_program() const; - private: - bool _internal_has_return_program() const; - public: - void clear_return_program(); - const ::substrait::DerivationExpression_ReturnProgram& return_program() const; - PROTOBUF_NODISCARD ::substrait::DerivationExpression_ReturnProgram* release_return_program(); - ::substrait::DerivationExpression_ReturnProgram* mutable_return_program(); - void set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program); - private: - const ::substrait::DerivationExpression_ReturnProgram& _internal_return_program() const; - ::substrait::DerivationExpression_ReturnProgram* _internal_mutable_return_program(); - public: - void unsafe_arena_set_allocated_return_program( - ::substrait::DerivationExpression_ReturnProgram* return_program); - ::substrait::DerivationExpression_ReturnProgram* unsafe_arena_release_return_program(); - - void clear_kind(); - KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:substrait.DerivationExpression) - private: - class _Internal; - void set_has_bool_(); - void set_has_i8(); - void set_has_i16(); - void set_has_i32(); - void set_has_i64(); - void set_has_fp32(); - void set_has_fp64(); - void set_has_string(); - void set_has_binary(); - void set_has_timestamp(); - void set_has_date(); - void set_has_time(); - void set_has_interval_year(); - void set_has_interval_day(); - void set_has_timestamp_tz(); - void set_has_uuid(); - void set_has_fixed_char(); - void set_has_varchar(); - void set_has_fixed_binary(); - void set_has_decimal(); - void set_has_struct_(); - void set_has_list(); - void set_has_map(); - void set_has_user_defined_pointer(); - void set_has_type_parameter_name(); - void set_has_integer_parameter_name(); - void set_has_integer_literal(); - void set_has_unary_op(); - void set_has_binary_op(); - void set_has_if_else(); - void set_has_return_program(); - - inline bool has_kind() const; - inline void clear_has_kind(); - - template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; - typedef void InternalArenaConstructable_; - typedef void DestructorSkippable_; - union KindUnion { - constexpr KindUnion() : _constinit_{} {} - ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; - ::substrait::Type_Boolean* bool__; - ::substrait::Type_I8* i8_; - ::substrait::Type_I16* i16_; - ::substrait::Type_I32* i32_; - ::substrait::Type_I64* i64_; - ::substrait::Type_FP32* fp32_; - ::substrait::Type_FP64* fp64_; - ::substrait::Type_String* string_; - ::substrait::Type_Binary* binary_; - ::substrait::Type_Timestamp* timestamp_; - ::substrait::Type_Date* date_; - ::substrait::Type_Time* time_; - ::substrait::Type_IntervalYear* interval_year_; - ::substrait::Type_IntervalDay* interval_day_; - ::substrait::Type_TimestampTZ* timestamp_tz_; - ::substrait::Type_UUID* uuid_; - ::substrait::DerivationExpression_ExpressionFixedChar* fixed_char_; - ::substrait::DerivationExpression_ExpressionVarChar* varchar_; - ::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary_; - ::substrait::DerivationExpression_ExpressionDecimal* decimal_; - ::substrait::DerivationExpression_ExpressionStruct* struct__; - ::substrait::DerivationExpression_ExpressionList* list_; - ::substrait::DerivationExpression_ExpressionMap* map_; - uint32_t user_defined_pointer_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_parameter_name_; - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr integer_parameter_name_; - int32_t integer_literal_; - ::substrait::DerivationExpression_UnaryOp* unary_op_; - ::substrait::DerivationExpression_BinaryOp* binary_op_; - ::substrait::DerivationExpression_IfElse* if_else_; - ::substrait::DerivationExpression_ReturnProgram* return_program_; - } kind_; - mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; - uint32_t _oneof_case_[1]; - - friend struct ::TableStruct_substrait_2ftype_5fexpressions_2eproto; -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// DerivationExpression_ExpressionFixedChar - -// .substrait.DerivationExpression length = 1; -inline bool DerivationExpression_ExpressionFixedChar::_internal_has_length() const { - return this != internal_default_instance() && length_ != nullptr; -} -inline bool DerivationExpression_ExpressionFixedChar::has_length() const { - return _internal_has_length(); -} -inline void DerivationExpression_ExpressionFixedChar::clear_length() { - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::_internal_length() const { - const ::substrait::DerivationExpression* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedChar::length() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.length) - return _internal_length(); -} -inline void DerivationExpression_ExpressionFixedChar::unsafe_arena_set_allocated_length( - ::substrait::DerivationExpression* length) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); - } - length_ = length; - if (length) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionFixedChar.length) -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::release_length() { - - ::substrait::DerivationExpression* temp = length_; - length_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionFixedChar.length) - - ::substrait::DerivationExpression* temp = length_; - length_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::_internal_mutable_length() { - - if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - length_ = p; - } - return length_; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedChar::mutable_length() { - ::substrait::DerivationExpression* _msg = _internal_mutable_length(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionFixedChar.length) - return _msg; -} -inline void DerivationExpression_ExpressionFixedChar::set_allocated_length(::substrait::DerivationExpression* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete length_; - } - if (length) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length); - if (message_arena != submessage_arena) { - length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, length, submessage_arena); - } - - } else { - - } - length_ = length; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionFixedChar.length) -} - -// uint32 variation_pointer = 2; -inline void DerivationExpression_ExpressionFixedChar::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t DerivationExpression_ExpressionFixedChar::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t DerivationExpression_ExpressionFixedChar::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.variation_pointer) - return _internal_variation_pointer(); -} -inline void DerivationExpression_ExpressionFixedChar::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void DerivationExpression_ExpressionFixedChar::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedChar.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 3; -inline void DerivationExpression_ExpressionFixedChar::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedChar::nullability() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedChar.nullability) - return _internal_nullability(); -} -inline void DerivationExpression_ExpressionFixedChar::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void DerivationExpression_ExpressionFixedChar::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedChar.nullability) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_ExpressionVarChar - -// .substrait.DerivationExpression length = 1; -inline bool DerivationExpression_ExpressionVarChar::_internal_has_length() const { - return this != internal_default_instance() && length_ != nullptr; -} -inline bool DerivationExpression_ExpressionVarChar::has_length() const { - return _internal_has_length(); -} -inline void DerivationExpression_ExpressionVarChar::clear_length() { - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::_internal_length() const { - const ::substrait::DerivationExpression* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionVarChar::length() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.length) - return _internal_length(); -} -inline void DerivationExpression_ExpressionVarChar::unsafe_arena_set_allocated_length( - ::substrait::DerivationExpression* length) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); - } - length_ = length; - if (length) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionVarChar.length) -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::release_length() { - - ::substrait::DerivationExpression* temp = length_; - length_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionVarChar.length) - - ::substrait::DerivationExpression* temp = length_; - length_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::_internal_mutable_length() { - - if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - length_ = p; - } - return length_; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionVarChar::mutable_length() { - ::substrait::DerivationExpression* _msg = _internal_mutable_length(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionVarChar.length) - return _msg; -} -inline void DerivationExpression_ExpressionVarChar::set_allocated_length(::substrait::DerivationExpression* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete length_; - } - if (length) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length); - if (message_arena != submessage_arena) { - length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, length, submessage_arena); - } - - } else { - - } - length_ = length; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionVarChar.length) -} - -// uint32 variation_pointer = 2; -inline void DerivationExpression_ExpressionVarChar::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t DerivationExpression_ExpressionVarChar::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t DerivationExpression_ExpressionVarChar::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.variation_pointer) - return _internal_variation_pointer(); -} -inline void DerivationExpression_ExpressionVarChar::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void DerivationExpression_ExpressionVarChar::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionVarChar.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 3; -inline void DerivationExpression_ExpressionVarChar::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionVarChar::nullability() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionVarChar.nullability) - return _internal_nullability(); -} -inline void DerivationExpression_ExpressionVarChar::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void DerivationExpression_ExpressionVarChar::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionVarChar.nullability) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_ExpressionFixedBinary - -// .substrait.DerivationExpression length = 1; -inline bool DerivationExpression_ExpressionFixedBinary::_internal_has_length() const { - return this != internal_default_instance() && length_ != nullptr; -} -inline bool DerivationExpression_ExpressionFixedBinary::has_length() const { - return _internal_has_length(); -} -inline void DerivationExpression_ExpressionFixedBinary::clear_length() { - if (GetArenaForAllocation() == nullptr && length_ != nullptr) { - delete length_; - } - length_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::_internal_length() const { - const ::substrait::DerivationExpression* p = length_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionFixedBinary::length() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.length) - return _internal_length(); -} -inline void DerivationExpression_ExpressionFixedBinary::unsafe_arena_set_allocated_length( - ::substrait::DerivationExpression* length) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(length_); - } - length_ = length; - if (length) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionFixedBinary.length) -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::release_length() { - - ::substrait::DerivationExpression* temp = length_; - length_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::unsafe_arena_release_length() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionFixedBinary.length) - - ::substrait::DerivationExpression* temp = length_; - length_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::_internal_mutable_length() { - - if (length_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - length_ = p; - } - return length_; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionFixedBinary::mutable_length() { - ::substrait::DerivationExpression* _msg = _internal_mutable_length(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionFixedBinary.length) - return _msg; -} -inline void DerivationExpression_ExpressionFixedBinary::set_allocated_length(::substrait::DerivationExpression* length) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete length_; - } - if (length) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(length); - if (message_arena != submessage_arena) { - length = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, length, submessage_arena); - } - - } else { - - } - length_ = length; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionFixedBinary.length) -} - -// uint32 variation_pointer = 2; -inline void DerivationExpression_ExpressionFixedBinary::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t DerivationExpression_ExpressionFixedBinary::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t DerivationExpression_ExpressionFixedBinary::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer) - return _internal_variation_pointer(); -} -inline void DerivationExpression_ExpressionFixedBinary::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void DerivationExpression_ExpressionFixedBinary::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedBinary.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 3; -inline void DerivationExpression_ExpressionFixedBinary::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionFixedBinary::nullability() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionFixedBinary.nullability) - return _internal_nullability(); -} -inline void DerivationExpression_ExpressionFixedBinary::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void DerivationExpression_ExpressionFixedBinary::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionFixedBinary.nullability) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_ExpressionDecimal - -// .substrait.DerivationExpression scale = 1; -inline bool DerivationExpression_ExpressionDecimal::_internal_has_scale() const { - return this != internal_default_instance() && scale_ != nullptr; -} -inline bool DerivationExpression_ExpressionDecimal::has_scale() const { - return _internal_has_scale(); -} -inline void DerivationExpression_ExpressionDecimal::clear_scale() { - if (GetArenaForAllocation() == nullptr && scale_ != nullptr) { - delete scale_; - } - scale_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_scale() const { - const ::substrait::DerivationExpression* p = scale_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::scale() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.scale) - return _internal_scale(); -} -inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_scale( - ::substrait::DerivationExpression* scale) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(scale_); - } - scale_ = scale; - if (scale) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionDecimal.scale) -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_scale() { - - ::substrait::DerivationExpression* temp = scale_; - scale_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_scale() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionDecimal.scale) - - ::substrait::DerivationExpression* temp = scale_; - scale_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_scale() { - - if (scale_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - scale_ = p; - } - return scale_; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_scale() { - ::substrait::DerivationExpression* _msg = _internal_mutable_scale(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionDecimal.scale) - return _msg; -} -inline void DerivationExpression_ExpressionDecimal::set_allocated_scale(::substrait::DerivationExpression* scale) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete scale_; - } - if (scale) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(scale); - if (message_arena != submessage_arena) { - scale = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, scale, submessage_arena); - } - - } else { - - } - scale_ = scale; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionDecimal.scale) -} - -// .substrait.DerivationExpression precision = 2; -inline bool DerivationExpression_ExpressionDecimal::_internal_has_precision() const { - return this != internal_default_instance() && precision_ != nullptr; -} -inline bool DerivationExpression_ExpressionDecimal::has_precision() const { - return _internal_has_precision(); -} -inline void DerivationExpression_ExpressionDecimal::clear_precision() { - if (GetArenaForAllocation() == nullptr && precision_ != nullptr) { - delete precision_; - } - precision_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::_internal_precision() const { - const ::substrait::DerivationExpression* p = precision_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionDecimal::precision() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.precision) - return _internal_precision(); -} -inline void DerivationExpression_ExpressionDecimal::unsafe_arena_set_allocated_precision( - ::substrait::DerivationExpression* precision) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(precision_); - } - precision_ = precision; - if (precision) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionDecimal.precision) -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::release_precision() { - - ::substrait::DerivationExpression* temp = precision_; - precision_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::unsafe_arena_release_precision() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionDecimal.precision) - - ::substrait::DerivationExpression* temp = precision_; - precision_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::_internal_mutable_precision() { - - if (precision_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - precision_ = p; - } - return precision_; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionDecimal::mutable_precision() { - ::substrait::DerivationExpression* _msg = _internal_mutable_precision(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionDecimal.precision) - return _msg; -} -inline void DerivationExpression_ExpressionDecimal::set_allocated_precision(::substrait::DerivationExpression* precision) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete precision_; - } - if (precision) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(precision); - if (message_arena != submessage_arena) { - precision = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, precision, submessage_arena); - } - - } else { - - } - precision_ = precision; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionDecimal.precision) -} - -// uint32 variation_pointer = 3; -inline void DerivationExpression_ExpressionDecimal::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t DerivationExpression_ExpressionDecimal::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t DerivationExpression_ExpressionDecimal::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.variation_pointer) - return _internal_variation_pointer(); -} -inline void DerivationExpression_ExpressionDecimal::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void DerivationExpression_ExpressionDecimal::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionDecimal.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 4; -inline void DerivationExpression_ExpressionDecimal::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionDecimal::nullability() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionDecimal.nullability) - return _internal_nullability(); -} -inline void DerivationExpression_ExpressionDecimal::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void DerivationExpression_ExpressionDecimal::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionDecimal.nullability) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_ExpressionStruct - -// repeated .substrait.DerivationExpression types = 1; -inline int DerivationExpression_ExpressionStruct::_internal_types_size() const { - return types_.size(); -} -inline int DerivationExpression_ExpressionStruct::types_size() const { - return _internal_types_size(); -} -inline void DerivationExpression_ExpressionStruct::clear_types() { - types_.Clear(); -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::mutable_types(int index) { - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionStruct.types) - return types_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >* -DerivationExpression_ExpressionStruct::mutable_types() { - // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ExpressionStruct.types) - return &types_; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::_internal_types(int index) const { - return types_.Get(index); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionStruct::types(int index) const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.types) - return _internal_types(index); -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::_internal_add_types() { - return types_.Add(); -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionStruct::add_types() { - ::substrait::DerivationExpression* _add = _internal_add_types(); - // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionStruct.types) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression >& -DerivationExpression_ExpressionStruct::types() const { - // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ExpressionStruct.types) - return types_; -} - -// uint32 variation_pointer = 2; -inline void DerivationExpression_ExpressionStruct::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t DerivationExpression_ExpressionStruct::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t DerivationExpression_ExpressionStruct::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.variation_pointer) - return _internal_variation_pointer(); -} -inline void DerivationExpression_ExpressionStruct::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void DerivationExpression_ExpressionStruct::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionStruct.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 3; -inline void DerivationExpression_ExpressionStruct::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionStruct::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionStruct::nullability() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionStruct.nullability) - return _internal_nullability(); -} -inline void DerivationExpression_ExpressionStruct::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void DerivationExpression_ExpressionStruct::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionStruct.nullability) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_ExpressionNamedStruct - -// repeated string names = 1; -inline int DerivationExpression_ExpressionNamedStruct::_internal_names_size() const { - return names_.size(); -} -inline int DerivationExpression_ExpressionNamedStruct::names_size() const { - return _internal_names_size(); -} -inline void DerivationExpression_ExpressionNamedStruct::clear_names() { - names_.Clear(); -} -inline std::string* DerivationExpression_ExpressionNamedStruct::add_names() { - std::string* _s = _internal_add_names(); - // @@protoc_insertion_point(field_add_mutable:substrait.DerivationExpression.ExpressionNamedStruct.names) - return _s; -} -inline const std::string& DerivationExpression_ExpressionNamedStruct::_internal_names(int index) const { - return names_.Get(index); -} -inline const std::string& DerivationExpression_ExpressionNamedStruct::names(int index) const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionNamedStruct.names) - return _internal_names(index); -} -inline std::string* DerivationExpression_ExpressionNamedStruct::mutable_names(int index) { - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionNamedStruct.names) - return names_.Mutable(index); -} -inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const std::string& value) { - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names) -} -inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, std::string&& value) { - names_.Mutable(index)->assign(std::move(value)); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionNamedStruct.names) -} -inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:substrait.DerivationExpression.ExpressionNamedStruct.names) -} -inline void DerivationExpression_ExpressionNamedStruct::set_names(int index, const char* value, size_t size) { - names_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:substrait.DerivationExpression.ExpressionNamedStruct.names) -} -inline std::string* DerivationExpression_ExpressionNamedStruct::_internal_add_names() { - return names_.Add(); -} -inline void DerivationExpression_ExpressionNamedStruct::add_names(const std::string& value) { - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionNamedStruct.names) -} -inline void DerivationExpression_ExpressionNamedStruct::add_names(std::string&& value) { - names_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ExpressionNamedStruct.names) -} -inline void DerivationExpression_ExpressionNamedStruct::add_names(const char* value) { - GOOGLE_DCHECK(value != nullptr); - names_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:substrait.DerivationExpression.ExpressionNamedStruct.names) -} -inline void DerivationExpression_ExpressionNamedStruct::add_names(const char* value, size_t size) { - names_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:substrait.DerivationExpression.ExpressionNamedStruct.names) -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& -DerivationExpression_ExpressionNamedStruct::names() const { - // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ExpressionNamedStruct.names) - return names_; -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* -DerivationExpression_ExpressionNamedStruct::mutable_names() { - // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ExpressionNamedStruct.names) - return &names_; -} - -// .substrait.DerivationExpression.ExpressionStruct struct = 2; -inline bool DerivationExpression_ExpressionNamedStruct::_internal_has_struct_() const { - return this != internal_default_instance() && struct__ != nullptr; -} -inline bool DerivationExpression_ExpressionNamedStruct::has_struct_() const { - return _internal_has_struct_(); -} -inline void DerivationExpression_ExpressionNamedStruct::clear_struct_() { - if (GetArenaForAllocation() == nullptr && struct__ != nullptr) { - delete struct__; - } - struct__ = nullptr; -} -inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::_internal_struct_() const { - const ::substrait::DerivationExpression_ExpressionStruct* p = struct__; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_ExpressionStruct_default_instance_); -} -inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression_ExpressionNamedStruct::struct_() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionNamedStruct.struct) - return _internal_struct_(); -} -inline void DerivationExpression_ExpressionNamedStruct::unsafe_arena_set_allocated_struct_( - ::substrait::DerivationExpression_ExpressionStruct* struct_) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(struct__); - } - struct__ = struct_; - if (struct_) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionNamedStruct.struct) -} -inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::release_struct_() { - - ::substrait::DerivationExpression_ExpressionStruct* temp = struct__; - struct__ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionNamedStruct.struct) - - ::substrait::DerivationExpression_ExpressionStruct* temp = struct__; - struct__ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::_internal_mutable_struct_() { - - if (struct__ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression_ExpressionStruct>(GetArenaForAllocation()); - struct__ = p; - } - return struct__; -} -inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression_ExpressionNamedStruct::mutable_struct_() { - ::substrait::DerivationExpression_ExpressionStruct* _msg = _internal_mutable_struct_(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionNamedStruct.struct) - return _msg; -} -inline void DerivationExpression_ExpressionNamedStruct::set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete struct__; - } - if (struct_) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression_ExpressionStruct>::GetOwningArena(struct_); - if (message_arena != submessage_arena) { - struct_ = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, struct_, submessage_arena); - } - - } else { - - } - struct__ = struct_; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionNamedStruct.struct) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_ExpressionList - -// .substrait.DerivationExpression type = 1; -inline bool DerivationExpression_ExpressionList::_internal_has_type() const { - return this != internal_default_instance() && type_ != nullptr; -} -inline bool DerivationExpression_ExpressionList::has_type() const { - return _internal_has_type(); -} -inline void DerivationExpression_ExpressionList::clear_type() { - if (GetArenaForAllocation() == nullptr && type_ != nullptr) { - delete type_; - } - type_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionList::_internal_type() const { - const ::substrait::DerivationExpression* p = type_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionList::type() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.type) - return _internal_type(); -} -inline void DerivationExpression_ExpressionList::unsafe_arena_set_allocated_type( - ::substrait::DerivationExpression* type) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(type_); - } - type_ = type; - if (type) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionList.type) -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::release_type() { - - ::substrait::DerivationExpression* temp = type_; - type_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::unsafe_arena_release_type() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionList.type) - - ::substrait::DerivationExpression* temp = type_; - type_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::_internal_mutable_type() { - - if (type_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - type_ = p; - } - return type_; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionList::mutable_type() { - ::substrait::DerivationExpression* _msg = _internal_mutable_type(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionList.type) - return _msg; -} -inline void DerivationExpression_ExpressionList::set_allocated_type(::substrait::DerivationExpression* type) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete type_; - } - if (type) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(type); - if (message_arena != submessage_arena) { - type = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, type, submessage_arena); - } - - } else { - - } - type_ = type; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionList.type) -} - -// uint32 variation_pointer = 2; -inline void DerivationExpression_ExpressionList::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t DerivationExpression_ExpressionList::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t DerivationExpression_ExpressionList::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.variation_pointer) - return _internal_variation_pointer(); -} -inline void DerivationExpression_ExpressionList::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void DerivationExpression_ExpressionList::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionList.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 3; -inline void DerivationExpression_ExpressionList::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionList::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionList::nullability() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionList.nullability) - return _internal_nullability(); -} -inline void DerivationExpression_ExpressionList::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void DerivationExpression_ExpressionList::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionList.nullability) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_ExpressionMap - -// .substrait.DerivationExpression key = 1; -inline bool DerivationExpression_ExpressionMap::_internal_has_key() const { - return this != internal_default_instance() && key_ != nullptr; -} -inline bool DerivationExpression_ExpressionMap::has_key() const { - return _internal_has_key(); -} -inline void DerivationExpression_ExpressionMap::clear_key() { - if (GetArenaForAllocation() == nullptr && key_ != nullptr) { - delete key_; - } - key_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_key() const { - const ::substrait::DerivationExpression* p = key_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::key() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.key) - return _internal_key(); -} -inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_key( - ::substrait::DerivationExpression* key) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_); - } - key_ = key; - if (key) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionMap.key) -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_key() { - - ::substrait::DerivationExpression* temp = key_; - key_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_key() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionMap.key) - - ::substrait::DerivationExpression* temp = key_; - key_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_key() { - - if (key_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - key_ = p; - } - return key_; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_key() { - ::substrait::DerivationExpression* _msg = _internal_mutable_key(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionMap.key) - return _msg; -} -inline void DerivationExpression_ExpressionMap::set_allocated_key(::substrait::DerivationExpression* key) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete key_; - } - if (key) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(key); - if (message_arena != submessage_arena) { - key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, key, submessage_arena); - } - - } else { - - } - key_ = key; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionMap.key) -} - -// .substrait.DerivationExpression value = 2; -inline bool DerivationExpression_ExpressionMap::_internal_has_value() const { - return this != internal_default_instance() && value_ != nullptr; -} -inline bool DerivationExpression_ExpressionMap::has_value() const { - return _internal_has_value(); -} -inline void DerivationExpression_ExpressionMap::clear_value() { - if (GetArenaForAllocation() == nullptr && value_ != nullptr) { - delete value_; - } - value_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::_internal_value() const { - const ::substrait::DerivationExpression* p = value_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ExpressionMap::value() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.value) - return _internal_value(); -} -inline void DerivationExpression_ExpressionMap::unsafe_arena_set_allocated_value( - ::substrait::DerivationExpression* value) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_); - } - value_ = value; - if (value) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ExpressionMap.value) -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::release_value() { - - ::substrait::DerivationExpression* temp = value_; - value_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::unsafe_arena_release_value() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ExpressionMap.value) - - ::substrait::DerivationExpression* temp = value_; - value_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::_internal_mutable_value() { - - if (value_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - value_ = p; - } - return value_; -} -inline ::substrait::DerivationExpression* DerivationExpression_ExpressionMap::mutable_value() { - ::substrait::DerivationExpression* _msg = _internal_mutable_value(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ExpressionMap.value) - return _msg; -} -inline void DerivationExpression_ExpressionMap::set_allocated_value(::substrait::DerivationExpression* value) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete value_; - } - if (value) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(value); - if (message_arena != submessage_arena) { - value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, value, submessage_arena); - } - - } else { - - } - value_ = value; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ExpressionMap.value) -} - -// uint32 variation_pointer = 3; -inline void DerivationExpression_ExpressionMap::clear_variation_pointer() { - variation_pointer_ = 0u; -} -inline uint32_t DerivationExpression_ExpressionMap::_internal_variation_pointer() const { - return variation_pointer_; -} -inline uint32_t DerivationExpression_ExpressionMap::variation_pointer() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.variation_pointer) - return _internal_variation_pointer(); -} -inline void DerivationExpression_ExpressionMap::_internal_set_variation_pointer(uint32_t value) { - - variation_pointer_ = value; -} -inline void DerivationExpression_ExpressionMap::set_variation_pointer(uint32_t value) { - _internal_set_variation_pointer(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionMap.variation_pointer) -} - -// .substrait.Type.Nullability nullability = 4; -inline void DerivationExpression_ExpressionMap::clear_nullability() { - nullability_ = 0; -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionMap::_internal_nullability() const { - return static_cast< ::substrait::Type_Nullability >(nullability_); -} -inline ::substrait::Type_Nullability DerivationExpression_ExpressionMap::nullability() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ExpressionMap.nullability) - return _internal_nullability(); -} -inline void DerivationExpression_ExpressionMap::_internal_set_nullability(::substrait::Type_Nullability value) { - - nullability_ = value; -} -inline void DerivationExpression_ExpressionMap::set_nullability(::substrait::Type_Nullability value) { - _internal_set_nullability(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ExpressionMap.nullability) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_IfElse - -// .substrait.DerivationExpression if_condition = 1; -inline bool DerivationExpression_IfElse::_internal_has_if_condition() const { - return this != internal_default_instance() && if_condition_ != nullptr; -} -inline bool DerivationExpression_IfElse::has_if_condition() const { - return _internal_has_if_condition(); -} -inline void DerivationExpression_IfElse::clear_if_condition() { - if (GetArenaForAllocation() == nullptr && if_condition_ != nullptr) { - delete if_condition_; - } - if_condition_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_condition() const { - const ::substrait::DerivationExpression* p = if_condition_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::if_condition() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.if_condition) - return _internal_if_condition(); -} -inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_condition( - ::substrait::DerivationExpression* if_condition) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_condition_); - } - if_condition_ = if_condition; - if (if_condition) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.if_condition) -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_condition() { - - ::substrait::DerivationExpression* temp = if_condition_; - if_condition_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_condition() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.if_condition) - - ::substrait::DerivationExpression* temp = if_condition_; - if_condition_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_condition() { - - if (if_condition_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - if_condition_ = p; - } - return if_condition_; -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_condition() { - ::substrait::DerivationExpression* _msg = _internal_mutable_if_condition(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.if_condition) - return _msg; -} -inline void DerivationExpression_IfElse::set_allocated_if_condition(::substrait::DerivationExpression* if_condition) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete if_condition_; - } - if (if_condition) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(if_condition); - if (message_arena != submessage_arena) { - if_condition = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, if_condition, submessage_arena); - } - - } else { - - } - if_condition_ = if_condition; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.if_condition) -} - -// .substrait.DerivationExpression if_return = 2; -inline bool DerivationExpression_IfElse::_internal_has_if_return() const { - return this != internal_default_instance() && if_return_ != nullptr; -} -inline bool DerivationExpression_IfElse::has_if_return() const { - return _internal_has_if_return(); -} -inline void DerivationExpression_IfElse::clear_if_return() { - if (GetArenaForAllocation() == nullptr && if_return_ != nullptr) { - delete if_return_; - } - if_return_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_if_return() const { - const ::substrait::DerivationExpression* p = if_return_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::if_return() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.if_return) - return _internal_if_return(); -} -inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_if_return( - ::substrait::DerivationExpression* if_return) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(if_return_); - } - if_return_ = if_return; - if (if_return) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.if_return) -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_if_return() { - - ::substrait::DerivationExpression* temp = if_return_; - if_return_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_if_return() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.if_return) - - ::substrait::DerivationExpression* temp = if_return_; - if_return_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_if_return() { - - if (if_return_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - if_return_ = p; - } - return if_return_; -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_if_return() { - ::substrait::DerivationExpression* _msg = _internal_mutable_if_return(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.if_return) - return _msg; -} -inline void DerivationExpression_IfElse::set_allocated_if_return(::substrait::DerivationExpression* if_return) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete if_return_; - } - if (if_return) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(if_return); - if (message_arena != submessage_arena) { - if_return = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, if_return, submessage_arena); - } - - } else { - - } - if_return_ = if_return; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.if_return) -} - -// .substrait.DerivationExpression else_return = 3; -inline bool DerivationExpression_IfElse::_internal_has_else_return() const { - return this != internal_default_instance() && else_return_ != nullptr; -} -inline bool DerivationExpression_IfElse::has_else_return() const { - return _internal_has_else_return(); -} -inline void DerivationExpression_IfElse::clear_else_return() { - if (GetArenaForAllocation() == nullptr && else_return_ != nullptr) { - delete else_return_; - } - else_return_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::_internal_else_return() const { - const ::substrait::DerivationExpression* p = else_return_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_IfElse::else_return() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.IfElse.else_return) - return _internal_else_return(); -} -inline void DerivationExpression_IfElse::unsafe_arena_set_allocated_else_return( - ::substrait::DerivationExpression* else_return) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(else_return_); - } - else_return_ = else_return; - if (else_return) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.IfElse.else_return) -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::release_else_return() { - - ::substrait::DerivationExpression* temp = else_return_; - else_return_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::unsafe_arena_release_else_return() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.IfElse.else_return) - - ::substrait::DerivationExpression* temp = else_return_; - else_return_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::_internal_mutable_else_return() { - - if (else_return_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - else_return_ = p; - } - return else_return_; -} -inline ::substrait::DerivationExpression* DerivationExpression_IfElse::mutable_else_return() { - ::substrait::DerivationExpression* _msg = _internal_mutable_else_return(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.IfElse.else_return) - return _msg; -} -inline void DerivationExpression_IfElse::set_allocated_else_return(::substrait::DerivationExpression* else_return) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete else_return_; - } - if (else_return) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(else_return); - if (message_arena != submessage_arena) { - else_return = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, else_return, submessage_arena); - } - - } else { - - } - else_return_ = else_return; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.IfElse.else_return) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_UnaryOp - -// .substrait.DerivationExpression.UnaryOp.UnaryOpType op_type = 1; -inline void DerivationExpression_UnaryOp::clear_op_type() { - op_type_ = 0; -} -inline ::substrait::DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::_internal_op_type() const { - return static_cast< ::substrait::DerivationExpression_UnaryOp_UnaryOpType >(op_type_); -} -inline ::substrait::DerivationExpression_UnaryOp_UnaryOpType DerivationExpression_UnaryOp::op_type() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.UnaryOp.op_type) - return _internal_op_type(); -} -inline void DerivationExpression_UnaryOp::_internal_set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value) { - - op_type_ = value; -} -inline void DerivationExpression_UnaryOp::set_op_type(::substrait::DerivationExpression_UnaryOp_UnaryOpType value) { - _internal_set_op_type(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.UnaryOp.op_type) -} - -// .substrait.DerivationExpression arg = 2; -inline bool DerivationExpression_UnaryOp::_internal_has_arg() const { - return this != internal_default_instance() && arg_ != nullptr; -} -inline bool DerivationExpression_UnaryOp::has_arg() const { - return _internal_has_arg(); -} -inline void DerivationExpression_UnaryOp::clear_arg() { - if (GetArenaForAllocation() == nullptr && arg_ != nullptr) { - delete arg_; - } - arg_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::_internal_arg() const { - const ::substrait::DerivationExpression* p = arg_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_UnaryOp::arg() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.UnaryOp.arg) - return _internal_arg(); -} -inline void DerivationExpression_UnaryOp::unsafe_arena_set_allocated_arg( - ::substrait::DerivationExpression* arg) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg_); - } - arg_ = arg; - if (arg) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.UnaryOp.arg) -} -inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::release_arg() { - - ::substrait::DerivationExpression* temp = arg_; - arg_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::unsafe_arena_release_arg() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.UnaryOp.arg) - - ::substrait::DerivationExpression* temp = arg_; - arg_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::_internal_mutable_arg() { - - if (arg_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - arg_ = p; - } - return arg_; -} -inline ::substrait::DerivationExpression* DerivationExpression_UnaryOp::mutable_arg() { - ::substrait::DerivationExpression* _msg = _internal_mutable_arg(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.UnaryOp.arg) - return _msg; -} -inline void DerivationExpression_UnaryOp::set_allocated_arg(::substrait::DerivationExpression* arg) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete arg_; - } - if (arg) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg); - if (message_arena != submessage_arena) { - arg = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, arg, submessage_arena); - } - - } else { - - } - arg_ = arg; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.UnaryOp.arg) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_BinaryOp - -// .substrait.DerivationExpression.BinaryOp.BinaryOpType op_type = 1; -inline void DerivationExpression_BinaryOp::clear_op_type() { - op_type_ = 0; -} -inline ::substrait::DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::_internal_op_type() const { - return static_cast< ::substrait::DerivationExpression_BinaryOp_BinaryOpType >(op_type_); -} -inline ::substrait::DerivationExpression_BinaryOp_BinaryOpType DerivationExpression_BinaryOp::op_type() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.op_type) - return _internal_op_type(); -} -inline void DerivationExpression_BinaryOp::_internal_set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value) { - - op_type_ = value; -} -inline void DerivationExpression_BinaryOp::set_op_type(::substrait::DerivationExpression_BinaryOp_BinaryOpType value) { - _internal_set_op_type(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.BinaryOp.op_type) -} - -// .substrait.DerivationExpression arg1 = 2; -inline bool DerivationExpression_BinaryOp::_internal_has_arg1() const { - return this != internal_default_instance() && arg1_ != nullptr; -} -inline bool DerivationExpression_BinaryOp::has_arg1() const { - return _internal_has_arg1(); -} -inline void DerivationExpression_BinaryOp::clear_arg1() { - if (GetArenaForAllocation() == nullptr && arg1_ != nullptr) { - delete arg1_; - } - arg1_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg1() const { - const ::substrait::DerivationExpression* p = arg1_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg1() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.arg1) - return _internal_arg1(); -} -inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg1( - ::substrait::DerivationExpression* arg1) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg1_); - } - arg1_ = arg1; - if (arg1) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.BinaryOp.arg1) -} -inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg1() { - - ::substrait::DerivationExpression* temp = arg1_; - arg1_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg1() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.BinaryOp.arg1) - - ::substrait::DerivationExpression* temp = arg1_; - arg1_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg1() { - - if (arg1_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - arg1_ = p; - } - return arg1_; -} -inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg1() { - ::substrait::DerivationExpression* _msg = _internal_mutable_arg1(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.BinaryOp.arg1) - return _msg; -} -inline void DerivationExpression_BinaryOp::set_allocated_arg1(::substrait::DerivationExpression* arg1) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete arg1_; - } - if (arg1) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg1); - if (message_arena != submessage_arena) { - arg1 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, arg1, submessage_arena); - } - - } else { - - } - arg1_ = arg1; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.BinaryOp.arg1) -} - -// .substrait.DerivationExpression arg2 = 3; -inline bool DerivationExpression_BinaryOp::_internal_has_arg2() const { - return this != internal_default_instance() && arg2_ != nullptr; -} -inline bool DerivationExpression_BinaryOp::has_arg2() const { - return _internal_has_arg2(); -} -inline void DerivationExpression_BinaryOp::clear_arg2() { - if (GetArenaForAllocation() == nullptr && arg2_ != nullptr) { - delete arg2_; - } - arg2_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::_internal_arg2() const { - const ::substrait::DerivationExpression* p = arg2_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_BinaryOp::arg2() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.BinaryOp.arg2) - return _internal_arg2(); -} -inline void DerivationExpression_BinaryOp::unsafe_arena_set_allocated_arg2( - ::substrait::DerivationExpression* arg2) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(arg2_); - } - arg2_ = arg2; - if (arg2) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.BinaryOp.arg2) -} -inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::release_arg2() { - - ::substrait::DerivationExpression* temp = arg2_; - arg2_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::unsafe_arena_release_arg2() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.BinaryOp.arg2) - - ::substrait::DerivationExpression* temp = arg2_; - arg2_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::_internal_mutable_arg2() { - - if (arg2_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - arg2_ = p; - } - return arg2_; -} -inline ::substrait::DerivationExpression* DerivationExpression_BinaryOp::mutable_arg2() { - ::substrait::DerivationExpression* _msg = _internal_mutable_arg2(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.BinaryOp.arg2) - return _msg; -} -inline void DerivationExpression_BinaryOp::set_allocated_arg2(::substrait::DerivationExpression* arg2) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete arg2_; - } - if (arg2) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(arg2); - if (message_arena != submessage_arena) { - arg2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, arg2, submessage_arena); - } - - } else { - - } - arg2_ = arg2; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.BinaryOp.arg2) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_ReturnProgram_Assignment - -// string name = 1; -inline void DerivationExpression_ReturnProgram_Assignment::clear_name() { - name_.ClearToEmpty(); -} -inline const std::string& DerivationExpression_ReturnProgram_Assignment::name() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.Assignment.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE -void DerivationExpression_ReturnProgram_Assignment::set_name(ArgT0&& arg0, ArgT... args) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.ReturnProgram.Assignment.name) -} -inline std::string* DerivationExpression_ReturnProgram_Assignment::mutable_name() { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.Assignment.name) - return _s; -} -inline const std::string& DerivationExpression_ReturnProgram_Assignment::_internal_name() const { - return name_.Get(); -} -inline void DerivationExpression_ReturnProgram_Assignment::_internal_set_name(const std::string& value) { - - name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_name() { - - return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* DerivationExpression_ReturnProgram_Assignment::release_name() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.Assignment.name) - return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); -} -inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_name(std::string* name) { - if (name != nullptr) { - - } else { - - } - name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name, - GetArenaForAllocation()); -#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING - if (name_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) { - name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation()); - } -#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.name) -} - -// .substrait.DerivationExpression expression = 2; -inline bool DerivationExpression_ReturnProgram_Assignment::_internal_has_expression() const { - return this != internal_default_instance() && expression_ != nullptr; -} -inline bool DerivationExpression_ReturnProgram_Assignment::has_expression() const { - return _internal_has_expression(); -} -inline void DerivationExpression_ReturnProgram_Assignment::clear_expression() { - if (GetArenaForAllocation() == nullptr && expression_ != nullptr) { - delete expression_; - } - expression_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::_internal_expression() const { - const ::substrait::DerivationExpression* p = expression_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram_Assignment::expression() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.Assignment.expression) - return _internal_expression(); -} -inline void DerivationExpression_ReturnProgram_Assignment::unsafe_arena_set_allocated_expression( - ::substrait::DerivationExpression* expression) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(expression_); - } - expression_ = expression; - if (expression) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.expression) -} -inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::release_expression() { - - ::substrait::DerivationExpression* temp = expression_; - expression_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::unsafe_arena_release_expression() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.Assignment.expression) - - ::substrait::DerivationExpression* temp = expression_; - expression_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::_internal_mutable_expression() { - - if (expression_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - expression_ = p; - } - return expression_; -} -inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram_Assignment::mutable_expression() { - ::substrait::DerivationExpression* _msg = _internal_mutable_expression(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.Assignment.expression) - return _msg; -} -inline void DerivationExpression_ReturnProgram_Assignment::set_allocated_expression(::substrait::DerivationExpression* expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete expression_; - } - if (expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(expression); - if (message_arena != submessage_arena) { - expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, expression, submessage_arena); - } - - } else { - - } - expression_ = expression; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.Assignment.expression) -} - -// ------------------------------------------------------------------- - -// DerivationExpression_ReturnProgram - -// repeated .substrait.DerivationExpression.ReturnProgram.Assignment assignments = 1; -inline int DerivationExpression_ReturnProgram::_internal_assignments_size() const { - return assignments_.size(); -} -inline int DerivationExpression_ReturnProgram::assignments_size() const { - return _internal_assignments_size(); -} -inline void DerivationExpression_ReturnProgram::clear_assignments() { - assignments_.Clear(); -} -inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::mutable_assignments(int index) { - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.assignments) - return assignments_.Mutable(index); -} -inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >* -DerivationExpression_ReturnProgram::mutable_assignments() { - // @@protoc_insertion_point(field_mutable_list:substrait.DerivationExpression.ReturnProgram.assignments) - return &assignments_; -} -inline const ::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::_internal_assignments(int index) const { - return assignments_.Get(index); -} -inline const ::substrait::DerivationExpression_ReturnProgram_Assignment& DerivationExpression_ReturnProgram::assignments(int index) const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.assignments) - return _internal_assignments(index); -} -inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::_internal_add_assignments() { - return assignments_.Add(); -} -inline ::substrait::DerivationExpression_ReturnProgram_Assignment* DerivationExpression_ReturnProgram::add_assignments() { - ::substrait::DerivationExpression_ReturnProgram_Assignment* _add = _internal_add_assignments(); - // @@protoc_insertion_point(field_add:substrait.DerivationExpression.ReturnProgram.assignments) - return _add; -} -inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::substrait::DerivationExpression_ReturnProgram_Assignment >& -DerivationExpression_ReturnProgram::assignments() const { - // @@protoc_insertion_point(field_list:substrait.DerivationExpression.ReturnProgram.assignments) - return assignments_; -} - -// .substrait.DerivationExpression final_expression = 2; -inline bool DerivationExpression_ReturnProgram::_internal_has_final_expression() const { - return this != internal_default_instance() && final_expression_ != nullptr; -} -inline bool DerivationExpression_ReturnProgram::has_final_expression() const { - return _internal_has_final_expression(); -} -inline void DerivationExpression_ReturnProgram::clear_final_expression() { - if (GetArenaForAllocation() == nullptr && final_expression_ != nullptr) { - delete final_expression_; - } - final_expression_ = nullptr; -} -inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram::_internal_final_expression() const { - const ::substrait::DerivationExpression* p = final_expression_; - return p != nullptr ? *p : reinterpret_cast( - ::substrait::_DerivationExpression_default_instance_); -} -inline const ::substrait::DerivationExpression& DerivationExpression_ReturnProgram::final_expression() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.ReturnProgram.final_expression) - return _internal_final_expression(); -} -inline void DerivationExpression_ReturnProgram::unsafe_arena_set_allocated_final_expression( - ::substrait::DerivationExpression* final_expression) { - if (GetArenaForAllocation() == nullptr) { - delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(final_expression_); - } - final_expression_ = final_expression; - if (final_expression) { - - } else { - - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.ReturnProgram.final_expression) -} -inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::release_final_expression() { - - ::substrait::DerivationExpression* temp = final_expression_; - final_expression_ = nullptr; -#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE - auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - if (GetArenaForAllocation() == nullptr) { delete old; } -#else // PROTOBUF_FORCE_COPY_IN_RELEASE - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } -#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::unsafe_arena_release_final_expression() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.ReturnProgram.final_expression) - - ::substrait::DerivationExpression* temp = final_expression_; - final_expression_ = nullptr; - return temp; -} -inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::_internal_mutable_final_expression() { - - if (final_expression_ == nullptr) { - auto* p = CreateMaybeMessage<::substrait::DerivationExpression>(GetArenaForAllocation()); - final_expression_ = p; - } - return final_expression_; -} -inline ::substrait::DerivationExpression* DerivationExpression_ReturnProgram::mutable_final_expression() { - ::substrait::DerivationExpression* _msg = _internal_mutable_final_expression(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.ReturnProgram.final_expression) - return _msg; -} -inline void DerivationExpression_ReturnProgram::set_allocated_final_expression(::substrait::DerivationExpression* final_expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); - if (message_arena == nullptr) { - delete final_expression_; - } - if (final_expression) { - ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = - ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::substrait::DerivationExpression>::GetOwningArena(final_expression); - if (message_arena != submessage_arena) { - final_expression = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( - message_arena, final_expression, submessage_arena); - } - - } else { - - } - final_expression_ = final_expression; - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.ReturnProgram.final_expression) -} - -// ------------------------------------------------------------------- - -// DerivationExpression - -// .substrait.Type.Boolean bool = 1; -inline bool DerivationExpression::_internal_has_bool_() const { - return kind_case() == kBool; -} -inline bool DerivationExpression::has_bool_() const { - return _internal_has_bool_(); -} -inline void DerivationExpression::set_has_bool_() { - _oneof_case_[0] = kBool; -} -inline ::substrait::Type_Boolean* DerivationExpression::release_bool_() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.bool) - if (_internal_has_bool_()) { - clear_has_kind(); - ::substrait::Type_Boolean* temp = kind_.bool__; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.bool__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Boolean& DerivationExpression::_internal_bool_() const { - return _internal_has_bool_() - ? *kind_.bool__ - : reinterpret_cast< ::substrait::Type_Boolean&>(::substrait::_Type_Boolean_default_instance_); -} -inline const ::substrait::Type_Boolean& DerivationExpression::bool_() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.bool) - return _internal_bool_(); -} -inline ::substrait::Type_Boolean* DerivationExpression::unsafe_arena_release_bool_() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.bool) - if (_internal_has_bool_()) { - clear_has_kind(); - ::substrait::Type_Boolean* temp = kind_.bool__; - kind_.bool__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_bool_(::substrait::Type_Boolean* bool_) { - clear_kind(); - if (bool_) { - set_has_bool_(); - kind_.bool__ = bool_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.bool) -} -inline ::substrait::Type_Boolean* DerivationExpression::_internal_mutable_bool_() { - if (!_internal_has_bool_()) { - clear_kind(); - set_has_bool_(); - kind_.bool__ = CreateMaybeMessage< ::substrait::Type_Boolean >(GetArenaForAllocation()); - } - return kind_.bool__; -} -inline ::substrait::Type_Boolean* DerivationExpression::mutable_bool_() { - ::substrait::Type_Boolean* _msg = _internal_mutable_bool_(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.bool) - return _msg; -} - -// .substrait.Type.I8 i8 = 2; -inline bool DerivationExpression::_internal_has_i8() const { - return kind_case() == kI8; -} -inline bool DerivationExpression::has_i8() const { - return _internal_has_i8(); -} -inline void DerivationExpression::set_has_i8() { - _oneof_case_[0] = kI8; -} -inline ::substrait::Type_I8* DerivationExpression::release_i8() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i8) - if (_internal_has_i8()) { - clear_has_kind(); - ::substrait::Type_I8* temp = kind_.i8_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i8_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I8& DerivationExpression::_internal_i8() const { - return _internal_has_i8() - ? *kind_.i8_ - : reinterpret_cast< ::substrait::Type_I8&>(::substrait::_Type_I8_default_instance_); -} -inline const ::substrait::Type_I8& DerivationExpression::i8() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i8) - return _internal_i8(); -} -inline ::substrait::Type_I8* DerivationExpression::unsafe_arena_release_i8() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i8) - if (_internal_has_i8()) { - clear_has_kind(); - ::substrait::Type_I8* temp = kind_.i8_; - kind_.i8_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_i8(::substrait::Type_I8* i8) { - clear_kind(); - if (i8) { - set_has_i8(); - kind_.i8_ = i8; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i8) -} -inline ::substrait::Type_I8* DerivationExpression::_internal_mutable_i8() { - if (!_internal_has_i8()) { - clear_kind(); - set_has_i8(); - kind_.i8_ = CreateMaybeMessage< ::substrait::Type_I8 >(GetArenaForAllocation()); - } - return kind_.i8_; -} -inline ::substrait::Type_I8* DerivationExpression::mutable_i8() { - ::substrait::Type_I8* _msg = _internal_mutable_i8(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i8) - return _msg; -} - -// .substrait.Type.I16 i16 = 3; -inline bool DerivationExpression::_internal_has_i16() const { - return kind_case() == kI16; -} -inline bool DerivationExpression::has_i16() const { - return _internal_has_i16(); -} -inline void DerivationExpression::set_has_i16() { - _oneof_case_[0] = kI16; -} -inline ::substrait::Type_I16* DerivationExpression::release_i16() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i16) - if (_internal_has_i16()) { - clear_has_kind(); - ::substrait::Type_I16* temp = kind_.i16_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i16_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I16& DerivationExpression::_internal_i16() const { - return _internal_has_i16() - ? *kind_.i16_ - : reinterpret_cast< ::substrait::Type_I16&>(::substrait::_Type_I16_default_instance_); -} -inline const ::substrait::Type_I16& DerivationExpression::i16() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i16) - return _internal_i16(); -} -inline ::substrait::Type_I16* DerivationExpression::unsafe_arena_release_i16() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i16) - if (_internal_has_i16()) { - clear_has_kind(); - ::substrait::Type_I16* temp = kind_.i16_; - kind_.i16_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_i16(::substrait::Type_I16* i16) { - clear_kind(); - if (i16) { - set_has_i16(); - kind_.i16_ = i16; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i16) -} -inline ::substrait::Type_I16* DerivationExpression::_internal_mutable_i16() { - if (!_internal_has_i16()) { - clear_kind(); - set_has_i16(); - kind_.i16_ = CreateMaybeMessage< ::substrait::Type_I16 >(GetArenaForAllocation()); - } - return kind_.i16_; -} -inline ::substrait::Type_I16* DerivationExpression::mutable_i16() { - ::substrait::Type_I16* _msg = _internal_mutable_i16(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i16) - return _msg; -} - -// .substrait.Type.I32 i32 = 5; -inline bool DerivationExpression::_internal_has_i32() const { - return kind_case() == kI32; -} -inline bool DerivationExpression::has_i32() const { - return _internal_has_i32(); -} -inline void DerivationExpression::set_has_i32() { - _oneof_case_[0] = kI32; -} -inline ::substrait::Type_I32* DerivationExpression::release_i32() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i32) - if (_internal_has_i32()) { - clear_has_kind(); - ::substrait::Type_I32* temp = kind_.i32_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I32& DerivationExpression::_internal_i32() const { - return _internal_has_i32() - ? *kind_.i32_ - : reinterpret_cast< ::substrait::Type_I32&>(::substrait::_Type_I32_default_instance_); -} -inline const ::substrait::Type_I32& DerivationExpression::i32() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i32) - return _internal_i32(); -} -inline ::substrait::Type_I32* DerivationExpression::unsafe_arena_release_i32() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i32) - if (_internal_has_i32()) { - clear_has_kind(); - ::substrait::Type_I32* temp = kind_.i32_; - kind_.i32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_i32(::substrait::Type_I32* i32) { - clear_kind(); - if (i32) { - set_has_i32(); - kind_.i32_ = i32; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i32) -} -inline ::substrait::Type_I32* DerivationExpression::_internal_mutable_i32() { - if (!_internal_has_i32()) { - clear_kind(); - set_has_i32(); - kind_.i32_ = CreateMaybeMessage< ::substrait::Type_I32 >(GetArenaForAllocation()); - } - return kind_.i32_; -} -inline ::substrait::Type_I32* DerivationExpression::mutable_i32() { - ::substrait::Type_I32* _msg = _internal_mutable_i32(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i32) - return _msg; -} - -// .substrait.Type.I64 i64 = 7; -inline bool DerivationExpression::_internal_has_i64() const { - return kind_case() == kI64; -} -inline bool DerivationExpression::has_i64() const { - return _internal_has_i64(); -} -inline void DerivationExpression::set_has_i64() { - _oneof_case_[0] = kI64; -} -inline ::substrait::Type_I64* DerivationExpression::release_i64() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.i64) - if (_internal_has_i64()) { - clear_has_kind(); - ::substrait::Type_I64* temp = kind_.i64_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.i64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_I64& DerivationExpression::_internal_i64() const { - return _internal_has_i64() - ? *kind_.i64_ - : reinterpret_cast< ::substrait::Type_I64&>(::substrait::_Type_I64_default_instance_); -} -inline const ::substrait::Type_I64& DerivationExpression::i64() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.i64) - return _internal_i64(); -} -inline ::substrait::Type_I64* DerivationExpression::unsafe_arena_release_i64() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.i64) - if (_internal_has_i64()) { - clear_has_kind(); - ::substrait::Type_I64* temp = kind_.i64_; - kind_.i64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_i64(::substrait::Type_I64* i64) { - clear_kind(); - if (i64) { - set_has_i64(); - kind_.i64_ = i64; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.i64) -} -inline ::substrait::Type_I64* DerivationExpression::_internal_mutable_i64() { - if (!_internal_has_i64()) { - clear_kind(); - set_has_i64(); - kind_.i64_ = CreateMaybeMessage< ::substrait::Type_I64 >(GetArenaForAllocation()); - } - return kind_.i64_; -} -inline ::substrait::Type_I64* DerivationExpression::mutable_i64() { - ::substrait::Type_I64* _msg = _internal_mutable_i64(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.i64) - return _msg; -} - -// .substrait.Type.FP32 fp32 = 10; -inline bool DerivationExpression::_internal_has_fp32() const { - return kind_case() == kFp32; -} -inline bool DerivationExpression::has_fp32() const { - return _internal_has_fp32(); -} -inline void DerivationExpression::set_has_fp32() { - _oneof_case_[0] = kFp32; -} -inline ::substrait::Type_FP32* DerivationExpression::release_fp32() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fp32) - if (_internal_has_fp32()) { - clear_has_kind(); - ::substrait::Type_FP32* temp = kind_.fp32_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fp32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_FP32& DerivationExpression::_internal_fp32() const { - return _internal_has_fp32() - ? *kind_.fp32_ - : reinterpret_cast< ::substrait::Type_FP32&>(::substrait::_Type_FP32_default_instance_); -} -inline const ::substrait::Type_FP32& DerivationExpression::fp32() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fp32) - return _internal_fp32(); -} -inline ::substrait::Type_FP32* DerivationExpression::unsafe_arena_release_fp32() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fp32) - if (_internal_has_fp32()) { - clear_has_kind(); - ::substrait::Type_FP32* temp = kind_.fp32_; - kind_.fp32_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_fp32(::substrait::Type_FP32* fp32) { - clear_kind(); - if (fp32) { - set_has_fp32(); - kind_.fp32_ = fp32; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fp32) -} -inline ::substrait::Type_FP32* DerivationExpression::_internal_mutable_fp32() { - if (!_internal_has_fp32()) { - clear_kind(); - set_has_fp32(); - kind_.fp32_ = CreateMaybeMessage< ::substrait::Type_FP32 >(GetArenaForAllocation()); - } - return kind_.fp32_; -} -inline ::substrait::Type_FP32* DerivationExpression::mutable_fp32() { - ::substrait::Type_FP32* _msg = _internal_mutable_fp32(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fp32) - return _msg; -} - -// .substrait.Type.FP64 fp64 = 11; -inline bool DerivationExpression::_internal_has_fp64() const { - return kind_case() == kFp64; -} -inline bool DerivationExpression::has_fp64() const { - return _internal_has_fp64(); -} -inline void DerivationExpression::set_has_fp64() { - _oneof_case_[0] = kFp64; -} -inline ::substrait::Type_FP64* DerivationExpression::release_fp64() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fp64) - if (_internal_has_fp64()) { - clear_has_kind(); - ::substrait::Type_FP64* temp = kind_.fp64_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fp64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_FP64& DerivationExpression::_internal_fp64() const { - return _internal_has_fp64() - ? *kind_.fp64_ - : reinterpret_cast< ::substrait::Type_FP64&>(::substrait::_Type_FP64_default_instance_); -} -inline const ::substrait::Type_FP64& DerivationExpression::fp64() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fp64) - return _internal_fp64(); -} -inline ::substrait::Type_FP64* DerivationExpression::unsafe_arena_release_fp64() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fp64) - if (_internal_has_fp64()) { - clear_has_kind(); - ::substrait::Type_FP64* temp = kind_.fp64_; - kind_.fp64_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_fp64(::substrait::Type_FP64* fp64) { - clear_kind(); - if (fp64) { - set_has_fp64(); - kind_.fp64_ = fp64; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fp64) -} -inline ::substrait::Type_FP64* DerivationExpression::_internal_mutable_fp64() { - if (!_internal_has_fp64()) { - clear_kind(); - set_has_fp64(); - kind_.fp64_ = CreateMaybeMessage< ::substrait::Type_FP64 >(GetArenaForAllocation()); - } - return kind_.fp64_; -} -inline ::substrait::Type_FP64* DerivationExpression::mutable_fp64() { - ::substrait::Type_FP64* _msg = _internal_mutable_fp64(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fp64) - return _msg; -} - -// .substrait.Type.String string = 12; -inline bool DerivationExpression::_internal_has_string() const { - return kind_case() == kString; -} -inline bool DerivationExpression::has_string() const { - return _internal_has_string(); -} -inline void DerivationExpression::set_has_string() { - _oneof_case_[0] = kString; -} -inline ::substrait::Type_String* DerivationExpression::release_string() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.string) - if (_internal_has_string()) { - clear_has_kind(); - ::substrait::Type_String* temp = kind_.string_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.string_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_String& DerivationExpression::_internal_string() const { - return _internal_has_string() - ? *kind_.string_ - : reinterpret_cast< ::substrait::Type_String&>(::substrait::_Type_String_default_instance_); -} -inline const ::substrait::Type_String& DerivationExpression::string() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.string) - return _internal_string(); -} -inline ::substrait::Type_String* DerivationExpression::unsafe_arena_release_string() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.string) - if (_internal_has_string()) { - clear_has_kind(); - ::substrait::Type_String* temp = kind_.string_; - kind_.string_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_string(::substrait::Type_String* string) { - clear_kind(); - if (string) { - set_has_string(); - kind_.string_ = string; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.string) -} -inline ::substrait::Type_String* DerivationExpression::_internal_mutable_string() { - if (!_internal_has_string()) { - clear_kind(); - set_has_string(); - kind_.string_ = CreateMaybeMessage< ::substrait::Type_String >(GetArenaForAllocation()); - } - return kind_.string_; -} -inline ::substrait::Type_String* DerivationExpression::mutable_string() { - ::substrait::Type_String* _msg = _internal_mutable_string(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.string) - return _msg; -} - -// .substrait.Type.Binary binary = 13; -inline bool DerivationExpression::_internal_has_binary() const { - return kind_case() == kBinary; -} -inline bool DerivationExpression::has_binary() const { - return _internal_has_binary(); -} -inline void DerivationExpression::set_has_binary() { - _oneof_case_[0] = kBinary; -} -inline ::substrait::Type_Binary* DerivationExpression::release_binary() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.binary) - if (_internal_has_binary()) { - clear_has_kind(); - ::substrait::Type_Binary* temp = kind_.binary_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Binary& DerivationExpression::_internal_binary() const { - return _internal_has_binary() - ? *kind_.binary_ - : reinterpret_cast< ::substrait::Type_Binary&>(::substrait::_Type_Binary_default_instance_); -} -inline const ::substrait::Type_Binary& DerivationExpression::binary() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.binary) - return _internal_binary(); -} -inline ::substrait::Type_Binary* DerivationExpression::unsafe_arena_release_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.binary) - if (_internal_has_binary()) { - clear_has_kind(); - ::substrait::Type_Binary* temp = kind_.binary_; - kind_.binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_binary(::substrait::Type_Binary* binary) { - clear_kind(); - if (binary) { - set_has_binary(); - kind_.binary_ = binary; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.binary) -} -inline ::substrait::Type_Binary* DerivationExpression::_internal_mutable_binary() { - if (!_internal_has_binary()) { - clear_kind(); - set_has_binary(); - kind_.binary_ = CreateMaybeMessage< ::substrait::Type_Binary >(GetArenaForAllocation()); - } - return kind_.binary_; -} -inline ::substrait::Type_Binary* DerivationExpression::mutable_binary() { - ::substrait::Type_Binary* _msg = _internal_mutable_binary(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.binary) - return _msg; -} - -// .substrait.Type.Timestamp timestamp = 14; -inline bool DerivationExpression::_internal_has_timestamp() const { - return kind_case() == kTimestamp; -} -inline bool DerivationExpression::has_timestamp() const { - return _internal_has_timestamp(); -} -inline void DerivationExpression::set_has_timestamp() { - _oneof_case_[0] = kTimestamp; -} -inline ::substrait::Type_Timestamp* DerivationExpression::release_timestamp() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.timestamp) - if (_internal_has_timestamp()) { - clear_has_kind(); - ::substrait::Type_Timestamp* temp = kind_.timestamp_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.timestamp_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Timestamp& DerivationExpression::_internal_timestamp() const { - return _internal_has_timestamp() - ? *kind_.timestamp_ - : reinterpret_cast< ::substrait::Type_Timestamp&>(::substrait::_Type_Timestamp_default_instance_); -} -inline const ::substrait::Type_Timestamp& DerivationExpression::timestamp() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.timestamp) - return _internal_timestamp(); -} -inline ::substrait::Type_Timestamp* DerivationExpression::unsafe_arena_release_timestamp() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.timestamp) - if (_internal_has_timestamp()) { - clear_has_kind(); - ::substrait::Type_Timestamp* temp = kind_.timestamp_; - kind_.timestamp_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_timestamp(::substrait::Type_Timestamp* timestamp) { - clear_kind(); - if (timestamp) { - set_has_timestamp(); - kind_.timestamp_ = timestamp; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.timestamp) -} -inline ::substrait::Type_Timestamp* DerivationExpression::_internal_mutable_timestamp() { - if (!_internal_has_timestamp()) { - clear_kind(); - set_has_timestamp(); - kind_.timestamp_ = CreateMaybeMessage< ::substrait::Type_Timestamp >(GetArenaForAllocation()); - } - return kind_.timestamp_; -} -inline ::substrait::Type_Timestamp* DerivationExpression::mutable_timestamp() { - ::substrait::Type_Timestamp* _msg = _internal_mutable_timestamp(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.timestamp) - return _msg; -} - -// .substrait.Type.Date date = 16; -inline bool DerivationExpression::_internal_has_date() const { - return kind_case() == kDate; -} -inline bool DerivationExpression::has_date() const { - return _internal_has_date(); -} -inline void DerivationExpression::set_has_date() { - _oneof_case_[0] = kDate; -} -inline ::substrait::Type_Date* DerivationExpression::release_date() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.date) - if (_internal_has_date()) { - clear_has_kind(); - ::substrait::Type_Date* temp = kind_.date_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.date_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Date& DerivationExpression::_internal_date() const { - return _internal_has_date() - ? *kind_.date_ - : reinterpret_cast< ::substrait::Type_Date&>(::substrait::_Type_Date_default_instance_); -} -inline const ::substrait::Type_Date& DerivationExpression::date() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.date) - return _internal_date(); -} -inline ::substrait::Type_Date* DerivationExpression::unsafe_arena_release_date() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.date) - if (_internal_has_date()) { - clear_has_kind(); - ::substrait::Type_Date* temp = kind_.date_; - kind_.date_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_date(::substrait::Type_Date* date) { - clear_kind(); - if (date) { - set_has_date(); - kind_.date_ = date; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.date) -} -inline ::substrait::Type_Date* DerivationExpression::_internal_mutable_date() { - if (!_internal_has_date()) { - clear_kind(); - set_has_date(); - kind_.date_ = CreateMaybeMessage< ::substrait::Type_Date >(GetArenaForAllocation()); - } - return kind_.date_; -} -inline ::substrait::Type_Date* DerivationExpression::mutable_date() { - ::substrait::Type_Date* _msg = _internal_mutable_date(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.date) - return _msg; -} - -// .substrait.Type.Time time = 17; -inline bool DerivationExpression::_internal_has_time() const { - return kind_case() == kTime; -} -inline bool DerivationExpression::has_time() const { - return _internal_has_time(); -} -inline void DerivationExpression::set_has_time() { - _oneof_case_[0] = kTime; -} -inline ::substrait::Type_Time* DerivationExpression::release_time() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.time) - if (_internal_has_time()) { - clear_has_kind(); - ::substrait::Type_Time* temp = kind_.time_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.time_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_Time& DerivationExpression::_internal_time() const { - return _internal_has_time() - ? *kind_.time_ - : reinterpret_cast< ::substrait::Type_Time&>(::substrait::_Type_Time_default_instance_); -} -inline const ::substrait::Type_Time& DerivationExpression::time() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.time) - return _internal_time(); -} -inline ::substrait::Type_Time* DerivationExpression::unsafe_arena_release_time() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.time) - if (_internal_has_time()) { - clear_has_kind(); - ::substrait::Type_Time* temp = kind_.time_; - kind_.time_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_time(::substrait::Type_Time* time) { - clear_kind(); - if (time) { - set_has_time(); - kind_.time_ = time; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.time) -} -inline ::substrait::Type_Time* DerivationExpression::_internal_mutable_time() { - if (!_internal_has_time()) { - clear_kind(); - set_has_time(); - kind_.time_ = CreateMaybeMessage< ::substrait::Type_Time >(GetArenaForAllocation()); - } - return kind_.time_; -} -inline ::substrait::Type_Time* DerivationExpression::mutable_time() { - ::substrait::Type_Time* _msg = _internal_mutable_time(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.time) - return _msg; -} - -// .substrait.Type.IntervalYear interval_year = 19; -inline bool DerivationExpression::_internal_has_interval_year() const { - return kind_case() == kIntervalYear; -} -inline bool DerivationExpression::has_interval_year() const { - return _internal_has_interval_year(); -} -inline void DerivationExpression::set_has_interval_year() { - _oneof_case_[0] = kIntervalYear; -} -inline ::substrait::Type_IntervalYear* DerivationExpression::release_interval_year() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.interval_year) - if (_internal_has_interval_year()) { - clear_has_kind(); - ::substrait::Type_IntervalYear* temp = kind_.interval_year_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.interval_year_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_IntervalYear& DerivationExpression::_internal_interval_year() const { - return _internal_has_interval_year() - ? *kind_.interval_year_ - : reinterpret_cast< ::substrait::Type_IntervalYear&>(::substrait::_Type_IntervalYear_default_instance_); -} -inline const ::substrait::Type_IntervalYear& DerivationExpression::interval_year() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.interval_year) - return _internal_interval_year(); -} -inline ::substrait::Type_IntervalYear* DerivationExpression::unsafe_arena_release_interval_year() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.interval_year) - if (_internal_has_interval_year()) { - clear_has_kind(); - ::substrait::Type_IntervalYear* temp = kind_.interval_year_; - kind_.interval_year_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_interval_year(::substrait::Type_IntervalYear* interval_year) { - clear_kind(); - if (interval_year) { - set_has_interval_year(); - kind_.interval_year_ = interval_year; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.interval_year) -} -inline ::substrait::Type_IntervalYear* DerivationExpression::_internal_mutable_interval_year() { - if (!_internal_has_interval_year()) { - clear_kind(); - set_has_interval_year(); - kind_.interval_year_ = CreateMaybeMessage< ::substrait::Type_IntervalYear >(GetArenaForAllocation()); - } - return kind_.interval_year_; -} -inline ::substrait::Type_IntervalYear* DerivationExpression::mutable_interval_year() { - ::substrait::Type_IntervalYear* _msg = _internal_mutable_interval_year(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.interval_year) - return _msg; -} - -// .substrait.Type.IntervalDay interval_day = 20; -inline bool DerivationExpression::_internal_has_interval_day() const { - return kind_case() == kIntervalDay; -} -inline bool DerivationExpression::has_interval_day() const { - return _internal_has_interval_day(); -} -inline void DerivationExpression::set_has_interval_day() { - _oneof_case_[0] = kIntervalDay; -} -inline ::substrait::Type_IntervalDay* DerivationExpression::release_interval_day() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.interval_day) - if (_internal_has_interval_day()) { - clear_has_kind(); - ::substrait::Type_IntervalDay* temp = kind_.interval_day_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.interval_day_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_IntervalDay& DerivationExpression::_internal_interval_day() const { - return _internal_has_interval_day() - ? *kind_.interval_day_ - : reinterpret_cast< ::substrait::Type_IntervalDay&>(::substrait::_Type_IntervalDay_default_instance_); -} -inline const ::substrait::Type_IntervalDay& DerivationExpression::interval_day() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.interval_day) - return _internal_interval_day(); -} -inline ::substrait::Type_IntervalDay* DerivationExpression::unsafe_arena_release_interval_day() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.interval_day) - if (_internal_has_interval_day()) { - clear_has_kind(); - ::substrait::Type_IntervalDay* temp = kind_.interval_day_; - kind_.interval_day_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_interval_day(::substrait::Type_IntervalDay* interval_day) { - clear_kind(); - if (interval_day) { - set_has_interval_day(); - kind_.interval_day_ = interval_day; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.interval_day) -} -inline ::substrait::Type_IntervalDay* DerivationExpression::_internal_mutable_interval_day() { - if (!_internal_has_interval_day()) { - clear_kind(); - set_has_interval_day(); - kind_.interval_day_ = CreateMaybeMessage< ::substrait::Type_IntervalDay >(GetArenaForAllocation()); - } - return kind_.interval_day_; -} -inline ::substrait::Type_IntervalDay* DerivationExpression::mutable_interval_day() { - ::substrait::Type_IntervalDay* _msg = _internal_mutable_interval_day(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.interval_day) - return _msg; -} - -// .substrait.Type.TimestampTZ timestamp_tz = 29; -inline bool DerivationExpression::_internal_has_timestamp_tz() const { - return kind_case() == kTimestampTz; -} -inline bool DerivationExpression::has_timestamp_tz() const { - return _internal_has_timestamp_tz(); -} -inline void DerivationExpression::set_has_timestamp_tz() { - _oneof_case_[0] = kTimestampTz; -} -inline ::substrait::Type_TimestampTZ* DerivationExpression::release_timestamp_tz() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.timestamp_tz) - if (_internal_has_timestamp_tz()) { - clear_has_kind(); - ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.timestamp_tz_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_TimestampTZ& DerivationExpression::_internal_timestamp_tz() const { - return _internal_has_timestamp_tz() - ? *kind_.timestamp_tz_ - : reinterpret_cast< ::substrait::Type_TimestampTZ&>(::substrait::_Type_TimestampTZ_default_instance_); -} -inline const ::substrait::Type_TimestampTZ& DerivationExpression::timestamp_tz() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.timestamp_tz) - return _internal_timestamp_tz(); -} -inline ::substrait::Type_TimestampTZ* DerivationExpression::unsafe_arena_release_timestamp_tz() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.timestamp_tz) - if (_internal_has_timestamp_tz()) { - clear_has_kind(); - ::substrait::Type_TimestampTZ* temp = kind_.timestamp_tz_; - kind_.timestamp_tz_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_timestamp_tz(::substrait::Type_TimestampTZ* timestamp_tz) { - clear_kind(); - if (timestamp_tz) { - set_has_timestamp_tz(); - kind_.timestamp_tz_ = timestamp_tz; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.timestamp_tz) -} -inline ::substrait::Type_TimestampTZ* DerivationExpression::_internal_mutable_timestamp_tz() { - if (!_internal_has_timestamp_tz()) { - clear_kind(); - set_has_timestamp_tz(); - kind_.timestamp_tz_ = CreateMaybeMessage< ::substrait::Type_TimestampTZ >(GetArenaForAllocation()); - } - return kind_.timestamp_tz_; -} -inline ::substrait::Type_TimestampTZ* DerivationExpression::mutable_timestamp_tz() { - ::substrait::Type_TimestampTZ* _msg = _internal_mutable_timestamp_tz(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.timestamp_tz) - return _msg; -} - -// .substrait.Type.UUID uuid = 32; -inline bool DerivationExpression::_internal_has_uuid() const { - return kind_case() == kUuid; -} -inline bool DerivationExpression::has_uuid() const { - return _internal_has_uuid(); -} -inline void DerivationExpression::set_has_uuid() { - _oneof_case_[0] = kUuid; -} -inline ::substrait::Type_UUID* DerivationExpression::release_uuid() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.uuid) - if (_internal_has_uuid()) { - clear_has_kind(); - ::substrait::Type_UUID* temp = kind_.uuid_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.uuid_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::Type_UUID& DerivationExpression::_internal_uuid() const { - return _internal_has_uuid() - ? *kind_.uuid_ - : reinterpret_cast< ::substrait::Type_UUID&>(::substrait::_Type_UUID_default_instance_); -} -inline const ::substrait::Type_UUID& DerivationExpression::uuid() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.uuid) - return _internal_uuid(); -} -inline ::substrait::Type_UUID* DerivationExpression::unsafe_arena_release_uuid() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.uuid) - if (_internal_has_uuid()) { - clear_has_kind(); - ::substrait::Type_UUID* temp = kind_.uuid_; - kind_.uuid_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_uuid(::substrait::Type_UUID* uuid) { - clear_kind(); - if (uuid) { - set_has_uuid(); - kind_.uuid_ = uuid; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.uuid) -} -inline ::substrait::Type_UUID* DerivationExpression::_internal_mutable_uuid() { - if (!_internal_has_uuid()) { - clear_kind(); - set_has_uuid(); - kind_.uuid_ = CreateMaybeMessage< ::substrait::Type_UUID >(GetArenaForAllocation()); - } - return kind_.uuid_; -} -inline ::substrait::Type_UUID* DerivationExpression::mutable_uuid() { - ::substrait::Type_UUID* _msg = _internal_mutable_uuid(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.uuid) - return _msg; -} - -// .substrait.DerivationExpression.ExpressionFixedChar fixed_char = 21; -inline bool DerivationExpression::_internal_has_fixed_char() const { - return kind_case() == kFixedChar; -} -inline bool DerivationExpression::has_fixed_char() const { - return _internal_has_fixed_char(); -} -inline void DerivationExpression::set_has_fixed_char() { - _oneof_case_[0] = kFixedChar; -} -inline void DerivationExpression::clear_fixed_char() { - if (_internal_has_fixed_char()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_char_; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::release_fixed_char() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fixed_char) - if (_internal_has_fixed_char()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fixed_char_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::_internal_fixed_char() const { - return _internal_has_fixed_char() - ? *kind_.fixed_char_ - : reinterpret_cast< ::substrait::DerivationExpression_ExpressionFixedChar&>(::substrait::_DerivationExpression_ExpressionFixedChar_default_instance_); -} -inline const ::substrait::DerivationExpression_ExpressionFixedChar& DerivationExpression::fixed_char() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fixed_char) - return _internal_fixed_char(); -} -inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::unsafe_arena_release_fixed_char() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fixed_char) - if (_internal_has_fixed_char()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionFixedChar* temp = kind_.fixed_char_; - kind_.fixed_char_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_fixed_char(::substrait::DerivationExpression_ExpressionFixedChar* fixed_char) { - clear_kind(); - if (fixed_char) { - set_has_fixed_char(); - kind_.fixed_char_ = fixed_char; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fixed_char) -} -inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::_internal_mutable_fixed_char() { - if (!_internal_has_fixed_char()) { - clear_kind(); - set_has_fixed_char(); - kind_.fixed_char_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedChar >(GetArenaForAllocation()); - } - return kind_.fixed_char_; -} -inline ::substrait::DerivationExpression_ExpressionFixedChar* DerivationExpression::mutable_fixed_char() { - ::substrait::DerivationExpression_ExpressionFixedChar* _msg = _internal_mutable_fixed_char(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fixed_char) - return _msg; -} - -// .substrait.DerivationExpression.ExpressionVarChar varchar = 22; -inline bool DerivationExpression::_internal_has_varchar() const { - return kind_case() == kVarchar; -} -inline bool DerivationExpression::has_varchar() const { - return _internal_has_varchar(); -} -inline void DerivationExpression::set_has_varchar() { - _oneof_case_[0] = kVarchar; -} -inline void DerivationExpression::clear_varchar() { - if (_internal_has_varchar()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.varchar_; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::release_varchar() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.varchar) - if (_internal_has_varchar()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.varchar_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::_internal_varchar() const { - return _internal_has_varchar() - ? *kind_.varchar_ - : reinterpret_cast< ::substrait::DerivationExpression_ExpressionVarChar&>(::substrait::_DerivationExpression_ExpressionVarChar_default_instance_); -} -inline const ::substrait::DerivationExpression_ExpressionVarChar& DerivationExpression::varchar() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.varchar) - return _internal_varchar(); -} -inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::unsafe_arena_release_varchar() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.varchar) - if (_internal_has_varchar()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionVarChar* temp = kind_.varchar_; - kind_.varchar_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_varchar(::substrait::DerivationExpression_ExpressionVarChar* varchar) { - clear_kind(); - if (varchar) { - set_has_varchar(); - kind_.varchar_ = varchar; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.varchar) -} -inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::_internal_mutable_varchar() { - if (!_internal_has_varchar()) { - clear_kind(); - set_has_varchar(); - kind_.varchar_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionVarChar >(GetArenaForAllocation()); - } - return kind_.varchar_; -} -inline ::substrait::DerivationExpression_ExpressionVarChar* DerivationExpression::mutable_varchar() { - ::substrait::DerivationExpression_ExpressionVarChar* _msg = _internal_mutable_varchar(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.varchar) - return _msg; -} - -// .substrait.DerivationExpression.ExpressionFixedBinary fixed_binary = 23; -inline bool DerivationExpression::_internal_has_fixed_binary() const { - return kind_case() == kFixedBinary; -} -inline bool DerivationExpression::has_fixed_binary() const { - return _internal_has_fixed_binary(); -} -inline void DerivationExpression::set_has_fixed_binary() { - _oneof_case_[0] = kFixedBinary; -} -inline void DerivationExpression::clear_fixed_binary() { - if (_internal_has_fixed_binary()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.fixed_binary_; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::release_fixed_binary() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.fixed_binary) - if (_internal_has_fixed_binary()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.fixed_binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::_internal_fixed_binary() const { - return _internal_has_fixed_binary() - ? *kind_.fixed_binary_ - : reinterpret_cast< ::substrait::DerivationExpression_ExpressionFixedBinary&>(::substrait::_DerivationExpression_ExpressionFixedBinary_default_instance_); -} -inline const ::substrait::DerivationExpression_ExpressionFixedBinary& DerivationExpression::fixed_binary() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.fixed_binary) - return _internal_fixed_binary(); -} -inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::unsafe_arena_release_fixed_binary() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.fixed_binary) - if (_internal_has_fixed_binary()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionFixedBinary* temp = kind_.fixed_binary_; - kind_.fixed_binary_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_fixed_binary(::substrait::DerivationExpression_ExpressionFixedBinary* fixed_binary) { - clear_kind(); - if (fixed_binary) { - set_has_fixed_binary(); - kind_.fixed_binary_ = fixed_binary; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.fixed_binary) -} -inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::_internal_mutable_fixed_binary() { - if (!_internal_has_fixed_binary()) { - clear_kind(); - set_has_fixed_binary(); - kind_.fixed_binary_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionFixedBinary >(GetArenaForAllocation()); - } - return kind_.fixed_binary_; -} -inline ::substrait::DerivationExpression_ExpressionFixedBinary* DerivationExpression::mutable_fixed_binary() { - ::substrait::DerivationExpression_ExpressionFixedBinary* _msg = _internal_mutable_fixed_binary(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.fixed_binary) - return _msg; -} - -// .substrait.DerivationExpression.ExpressionDecimal decimal = 24; -inline bool DerivationExpression::_internal_has_decimal() const { - return kind_case() == kDecimal; -} -inline bool DerivationExpression::has_decimal() const { - return _internal_has_decimal(); -} -inline void DerivationExpression::set_has_decimal() { - _oneof_case_[0] = kDecimal; -} -inline void DerivationExpression::clear_decimal() { - if (_internal_has_decimal()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.decimal_; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::release_decimal() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.decimal) - if (_internal_has_decimal()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.decimal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::_internal_decimal() const { - return _internal_has_decimal() - ? *kind_.decimal_ - : reinterpret_cast< ::substrait::DerivationExpression_ExpressionDecimal&>(::substrait::_DerivationExpression_ExpressionDecimal_default_instance_); -} -inline const ::substrait::DerivationExpression_ExpressionDecimal& DerivationExpression::decimal() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.decimal) - return _internal_decimal(); -} -inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::unsafe_arena_release_decimal() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.decimal) - if (_internal_has_decimal()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionDecimal* temp = kind_.decimal_; - kind_.decimal_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_decimal(::substrait::DerivationExpression_ExpressionDecimal* decimal) { - clear_kind(); - if (decimal) { - set_has_decimal(); - kind_.decimal_ = decimal; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.decimal) -} -inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::_internal_mutable_decimal() { - if (!_internal_has_decimal()) { - clear_kind(); - set_has_decimal(); - kind_.decimal_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionDecimal >(GetArenaForAllocation()); - } - return kind_.decimal_; -} -inline ::substrait::DerivationExpression_ExpressionDecimal* DerivationExpression::mutable_decimal() { - ::substrait::DerivationExpression_ExpressionDecimal* _msg = _internal_mutable_decimal(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.decimal) - return _msg; -} - -// .substrait.DerivationExpression.ExpressionStruct struct = 25; -inline bool DerivationExpression::_internal_has_struct_() const { - return kind_case() == kStruct; -} -inline bool DerivationExpression::has_struct_() const { - return _internal_has_struct_(); -} -inline void DerivationExpression::set_has_struct_() { - _oneof_case_[0] = kStruct; -} -inline void DerivationExpression::clear_struct_() { - if (_internal_has_struct_()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.struct__; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::release_struct_() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.struct) - if (_internal_has_struct_()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::_internal_struct_() const { - return _internal_has_struct_() - ? *kind_.struct__ - : reinterpret_cast< ::substrait::DerivationExpression_ExpressionStruct&>(::substrait::_DerivationExpression_ExpressionStruct_default_instance_); -} -inline const ::substrait::DerivationExpression_ExpressionStruct& DerivationExpression::struct_() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.struct) - return _internal_struct_(); -} -inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::unsafe_arena_release_struct_() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.struct) - if (_internal_has_struct_()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionStruct* temp = kind_.struct__; - kind_.struct__ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_struct_(::substrait::DerivationExpression_ExpressionStruct* struct_) { - clear_kind(); - if (struct_) { - set_has_struct_(); - kind_.struct__ = struct_; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.struct) -} -inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::_internal_mutable_struct_() { - if (!_internal_has_struct_()) { - clear_kind(); - set_has_struct_(); - kind_.struct__ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionStruct >(GetArenaForAllocation()); - } - return kind_.struct__; -} -inline ::substrait::DerivationExpression_ExpressionStruct* DerivationExpression::mutable_struct_() { - ::substrait::DerivationExpression_ExpressionStruct* _msg = _internal_mutable_struct_(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.struct) - return _msg; -} - -// .substrait.DerivationExpression.ExpressionList list = 27; -inline bool DerivationExpression::_internal_has_list() const { - return kind_case() == kList; -} -inline bool DerivationExpression::has_list() const { - return _internal_has_list(); -} -inline void DerivationExpression::set_has_list() { - _oneof_case_[0] = kList; -} -inline void DerivationExpression::clear_list() { - if (_internal_has_list()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.list_; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::release_list() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.list) - if (_internal_has_list()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionList* temp = kind_.list_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_ExpressionList& DerivationExpression::_internal_list() const { - return _internal_has_list() - ? *kind_.list_ - : reinterpret_cast< ::substrait::DerivationExpression_ExpressionList&>(::substrait::_DerivationExpression_ExpressionList_default_instance_); -} -inline const ::substrait::DerivationExpression_ExpressionList& DerivationExpression::list() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.list) - return _internal_list(); -} -inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::unsafe_arena_release_list() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.list) - if (_internal_has_list()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionList* temp = kind_.list_; - kind_.list_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_list(::substrait::DerivationExpression_ExpressionList* list) { - clear_kind(); - if (list) { - set_has_list(); - kind_.list_ = list; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.list) -} -inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::_internal_mutable_list() { - if (!_internal_has_list()) { - clear_kind(); - set_has_list(); - kind_.list_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionList >(GetArenaForAllocation()); - } - return kind_.list_; -} -inline ::substrait::DerivationExpression_ExpressionList* DerivationExpression::mutable_list() { - ::substrait::DerivationExpression_ExpressionList* _msg = _internal_mutable_list(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.list) - return _msg; -} - -// .substrait.DerivationExpression.ExpressionMap map = 28; -inline bool DerivationExpression::_internal_has_map() const { - return kind_case() == kMap; -} -inline bool DerivationExpression::has_map() const { - return _internal_has_map(); -} -inline void DerivationExpression::set_has_map() { - _oneof_case_[0] = kMap; -} -inline void DerivationExpression::clear_map() { - if (_internal_has_map()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.map_; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::release_map() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.map) - if (_internal_has_map()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_ExpressionMap& DerivationExpression::_internal_map() const { - return _internal_has_map() - ? *kind_.map_ - : reinterpret_cast< ::substrait::DerivationExpression_ExpressionMap&>(::substrait::_DerivationExpression_ExpressionMap_default_instance_); -} -inline const ::substrait::DerivationExpression_ExpressionMap& DerivationExpression::map() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.map) - return _internal_map(); -} -inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::unsafe_arena_release_map() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.map) - if (_internal_has_map()) { - clear_has_kind(); - ::substrait::DerivationExpression_ExpressionMap* temp = kind_.map_; - kind_.map_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_map(::substrait::DerivationExpression_ExpressionMap* map) { - clear_kind(); - if (map) { - set_has_map(); - kind_.map_ = map; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.map) -} -inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::_internal_mutable_map() { - if (!_internal_has_map()) { - clear_kind(); - set_has_map(); - kind_.map_ = CreateMaybeMessage< ::substrait::DerivationExpression_ExpressionMap >(GetArenaForAllocation()); - } - return kind_.map_; -} -inline ::substrait::DerivationExpression_ExpressionMap* DerivationExpression::mutable_map() { - ::substrait::DerivationExpression_ExpressionMap* _msg = _internal_mutable_map(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.map) - return _msg; -} - -// uint32 user_defined_pointer = 31; -inline bool DerivationExpression::_internal_has_user_defined_pointer() const { - return kind_case() == kUserDefinedPointer; -} -inline bool DerivationExpression::has_user_defined_pointer() const { - return _internal_has_user_defined_pointer(); -} -inline void DerivationExpression::set_has_user_defined_pointer() { - _oneof_case_[0] = kUserDefinedPointer; -} -inline void DerivationExpression::clear_user_defined_pointer() { - if (_internal_has_user_defined_pointer()) { - kind_.user_defined_pointer_ = 0u; - clear_has_kind(); - } -} -inline uint32_t DerivationExpression::_internal_user_defined_pointer() const { - if (_internal_has_user_defined_pointer()) { - return kind_.user_defined_pointer_; - } - return 0u; -} -inline void DerivationExpression::_internal_set_user_defined_pointer(uint32_t value) { - if (!_internal_has_user_defined_pointer()) { - clear_kind(); - set_has_user_defined_pointer(); - } - kind_.user_defined_pointer_ = value; -} -inline uint32_t DerivationExpression::user_defined_pointer() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.user_defined_pointer) - return _internal_user_defined_pointer(); -} -inline void DerivationExpression::set_user_defined_pointer(uint32_t value) { - _internal_set_user_defined_pointer(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.user_defined_pointer) -} - -// string type_parameter_name = 33; -inline bool DerivationExpression::_internal_has_type_parameter_name() const { - return kind_case() == kTypeParameterName; -} -inline bool DerivationExpression::has_type_parameter_name() const { - return _internal_has_type_parameter_name(); -} -inline void DerivationExpression::set_has_type_parameter_name() { - _oneof_case_[0] = kTypeParameterName; -} -inline void DerivationExpression::clear_type_parameter_name() { - if (_internal_has_type_parameter_name()) { - kind_.type_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_kind(); - } -} -inline const std::string& DerivationExpression::type_parameter_name() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.type_parameter_name) - return _internal_type_parameter_name(); -} -template -inline void DerivationExpression::set_type_parameter_name(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_type_parameter_name()) { - clear_kind(); - set_has_type_parameter_name(); - kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.type_parameter_name) -} -inline std::string* DerivationExpression::mutable_type_parameter_name() { - std::string* _s = _internal_mutable_type_parameter_name(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.type_parameter_name) - return _s; -} -inline const std::string& DerivationExpression::_internal_type_parameter_name() const { - if (_internal_has_type_parameter_name()) { - return kind_.type_parameter_name_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void DerivationExpression::_internal_set_type_parameter_name(const std::string& value) { - if (!_internal_has_type_parameter_name()) { - clear_kind(); - set_has_type_parameter_name(); - kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - kind_.type_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* DerivationExpression::_internal_mutable_type_parameter_name() { - if (!_internal_has_type_parameter_name()) { - clear_kind(); - set_has_type_parameter_name(); - kind_.type_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return kind_.type_parameter_name_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* DerivationExpression::release_type_parameter_name() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.type_parameter_name) - if (_internal_has_type_parameter_name()) { - clear_has_kind(); - return kind_.type_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void DerivationExpression::set_allocated_type_parameter_name(std::string* type_parameter_name) { - if (has_kind()) { - clear_kind(); - } - if (type_parameter_name != nullptr) { - set_has_type_parameter_name(); - kind_.type_parameter_name_.UnsafeSetDefault(type_parameter_name); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(type_parameter_name); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.type_parameter_name) -} - -// string integer_parameter_name = 34; -inline bool DerivationExpression::_internal_has_integer_parameter_name() const { - return kind_case() == kIntegerParameterName; -} -inline bool DerivationExpression::has_integer_parameter_name() const { - return _internal_has_integer_parameter_name(); -} -inline void DerivationExpression::set_has_integer_parameter_name() { - _oneof_case_[0] = kIntegerParameterName; -} -inline void DerivationExpression::clear_integer_parameter_name() { - if (_internal_has_integer_parameter_name()) { - kind_.integer_parameter_name_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); - clear_has_kind(); - } -} -inline const std::string& DerivationExpression::integer_parameter_name() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.integer_parameter_name) - return _internal_integer_parameter_name(); -} -template -inline void DerivationExpression::set_integer_parameter_name(ArgT0&& arg0, ArgT... args) { - if (!_internal_has_integer_parameter_name()) { - clear_kind(); - set_has_integer_parameter_name(); - kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast(arg0), args..., GetArenaForAllocation()); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.integer_parameter_name) -} -inline std::string* DerivationExpression::mutable_integer_parameter_name() { - std::string* _s = _internal_mutable_integer_parameter_name(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.integer_parameter_name) - return _s; -} -inline const std::string& DerivationExpression::_internal_integer_parameter_name() const { - if (_internal_has_integer_parameter_name()) { - return kind_.integer_parameter_name_.Get(); - } - return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(); -} -inline void DerivationExpression::_internal_set_integer_parameter_name(const std::string& value) { - if (!_internal_has_integer_parameter_name()) { - clear_kind(); - set_has_integer_parameter_name(); - kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - kind_.integer_parameter_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation()); -} -inline std::string* DerivationExpression::_internal_mutable_integer_parameter_name() { - if (!_internal_has_integer_parameter_name()) { - clear_kind(); - set_has_integer_parameter_name(); - kind_.integer_parameter_name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); - } - return kind_.integer_parameter_name_.Mutable( - ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation()); -} -inline std::string* DerivationExpression::release_integer_parameter_name() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.integer_parameter_name) - if (_internal_has_integer_parameter_name()) { - clear_has_kind(); - return kind_.integer_parameter_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation()); - } else { - return nullptr; - } -} -inline void DerivationExpression::set_allocated_integer_parameter_name(std::string* integer_parameter_name) { - if (has_kind()) { - clear_kind(); - } - if (integer_parameter_name != nullptr) { - set_has_integer_parameter_name(); - kind_.integer_parameter_name_.UnsafeSetDefault(integer_parameter_name); - ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation(); - if (arena != nullptr) { - arena->Own(integer_parameter_name); - } - } - // @@protoc_insertion_point(field_set_allocated:substrait.DerivationExpression.integer_parameter_name) -} - -// int32 integer_literal = 35; -inline bool DerivationExpression::_internal_has_integer_literal() const { - return kind_case() == kIntegerLiteral; -} -inline bool DerivationExpression::has_integer_literal() const { - return _internal_has_integer_literal(); -} -inline void DerivationExpression::set_has_integer_literal() { - _oneof_case_[0] = kIntegerLiteral; -} -inline void DerivationExpression::clear_integer_literal() { - if (_internal_has_integer_literal()) { - kind_.integer_literal_ = 0; - clear_has_kind(); - } -} -inline int32_t DerivationExpression::_internal_integer_literal() const { - if (_internal_has_integer_literal()) { - return kind_.integer_literal_; - } - return 0; -} -inline void DerivationExpression::_internal_set_integer_literal(int32_t value) { - if (!_internal_has_integer_literal()) { - clear_kind(); - set_has_integer_literal(); - } - kind_.integer_literal_ = value; -} -inline int32_t DerivationExpression::integer_literal() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.integer_literal) - return _internal_integer_literal(); -} -inline void DerivationExpression::set_integer_literal(int32_t value) { - _internal_set_integer_literal(value); - // @@protoc_insertion_point(field_set:substrait.DerivationExpression.integer_literal) -} - -// .substrait.DerivationExpression.UnaryOp unary_op = 36; -inline bool DerivationExpression::_internal_has_unary_op() const { - return kind_case() == kUnaryOp; -} -inline bool DerivationExpression::has_unary_op() const { - return _internal_has_unary_op(); -} -inline void DerivationExpression::set_has_unary_op() { - _oneof_case_[0] = kUnaryOp; -} -inline void DerivationExpression::clear_unary_op() { - if (_internal_has_unary_op()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.unary_op_; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::release_unary_op() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.unary_op) - if (_internal_has_unary_op()) { - clear_has_kind(); - ::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.unary_op_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_UnaryOp& DerivationExpression::_internal_unary_op() const { - return _internal_has_unary_op() - ? *kind_.unary_op_ - : reinterpret_cast< ::substrait::DerivationExpression_UnaryOp&>(::substrait::_DerivationExpression_UnaryOp_default_instance_); -} -inline const ::substrait::DerivationExpression_UnaryOp& DerivationExpression::unary_op() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.unary_op) - return _internal_unary_op(); -} -inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::unsafe_arena_release_unary_op() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.unary_op) - if (_internal_has_unary_op()) { - clear_has_kind(); - ::substrait::DerivationExpression_UnaryOp* temp = kind_.unary_op_; - kind_.unary_op_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_unary_op(::substrait::DerivationExpression_UnaryOp* unary_op) { - clear_kind(); - if (unary_op) { - set_has_unary_op(); - kind_.unary_op_ = unary_op; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.unary_op) -} -inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::_internal_mutable_unary_op() { - if (!_internal_has_unary_op()) { - clear_kind(); - set_has_unary_op(); - kind_.unary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_UnaryOp >(GetArenaForAllocation()); - } - return kind_.unary_op_; -} -inline ::substrait::DerivationExpression_UnaryOp* DerivationExpression::mutable_unary_op() { - ::substrait::DerivationExpression_UnaryOp* _msg = _internal_mutable_unary_op(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.unary_op) - return _msg; -} - -// .substrait.DerivationExpression.BinaryOp binary_op = 37; -inline bool DerivationExpression::_internal_has_binary_op() const { - return kind_case() == kBinaryOp; -} -inline bool DerivationExpression::has_binary_op() const { - return _internal_has_binary_op(); -} -inline void DerivationExpression::set_has_binary_op() { - _oneof_case_[0] = kBinaryOp; -} -inline void DerivationExpression::clear_binary_op() { - if (_internal_has_binary_op()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.binary_op_; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::release_binary_op() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.binary_op) - if (_internal_has_binary_op()) { - clear_has_kind(); - ::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.binary_op_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_BinaryOp& DerivationExpression::_internal_binary_op() const { - return _internal_has_binary_op() - ? *kind_.binary_op_ - : reinterpret_cast< ::substrait::DerivationExpression_BinaryOp&>(::substrait::_DerivationExpression_BinaryOp_default_instance_); -} -inline const ::substrait::DerivationExpression_BinaryOp& DerivationExpression::binary_op() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.binary_op) - return _internal_binary_op(); -} -inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::unsafe_arena_release_binary_op() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.binary_op) - if (_internal_has_binary_op()) { - clear_has_kind(); - ::substrait::DerivationExpression_BinaryOp* temp = kind_.binary_op_; - kind_.binary_op_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_binary_op(::substrait::DerivationExpression_BinaryOp* binary_op) { - clear_kind(); - if (binary_op) { - set_has_binary_op(); - kind_.binary_op_ = binary_op; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.binary_op) -} -inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::_internal_mutable_binary_op() { - if (!_internal_has_binary_op()) { - clear_kind(); - set_has_binary_op(); - kind_.binary_op_ = CreateMaybeMessage< ::substrait::DerivationExpression_BinaryOp >(GetArenaForAllocation()); - } - return kind_.binary_op_; -} -inline ::substrait::DerivationExpression_BinaryOp* DerivationExpression::mutable_binary_op() { - ::substrait::DerivationExpression_BinaryOp* _msg = _internal_mutable_binary_op(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.binary_op) - return _msg; -} - -// .substrait.DerivationExpression.IfElse if_else = 38; -inline bool DerivationExpression::_internal_has_if_else() const { - return kind_case() == kIfElse; -} -inline bool DerivationExpression::has_if_else() const { - return _internal_has_if_else(); -} -inline void DerivationExpression::set_has_if_else() { - _oneof_case_[0] = kIfElse; -} -inline void DerivationExpression::clear_if_else() { - if (_internal_has_if_else()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.if_else_; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_IfElse* DerivationExpression::release_if_else() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.if_else) - if (_internal_has_if_else()) { - clear_has_kind(); - ::substrait::DerivationExpression_IfElse* temp = kind_.if_else_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.if_else_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_IfElse& DerivationExpression::_internal_if_else() const { - return _internal_has_if_else() - ? *kind_.if_else_ - : reinterpret_cast< ::substrait::DerivationExpression_IfElse&>(::substrait::_DerivationExpression_IfElse_default_instance_); -} -inline const ::substrait::DerivationExpression_IfElse& DerivationExpression::if_else() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.if_else) - return _internal_if_else(); -} -inline ::substrait::DerivationExpression_IfElse* DerivationExpression::unsafe_arena_release_if_else() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.if_else) - if (_internal_has_if_else()) { - clear_has_kind(); - ::substrait::DerivationExpression_IfElse* temp = kind_.if_else_; - kind_.if_else_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_if_else(::substrait::DerivationExpression_IfElse* if_else) { - clear_kind(); - if (if_else) { - set_has_if_else(); - kind_.if_else_ = if_else; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.if_else) -} -inline ::substrait::DerivationExpression_IfElse* DerivationExpression::_internal_mutable_if_else() { - if (!_internal_has_if_else()) { - clear_kind(); - set_has_if_else(); - kind_.if_else_ = CreateMaybeMessage< ::substrait::DerivationExpression_IfElse >(GetArenaForAllocation()); - } - return kind_.if_else_; -} -inline ::substrait::DerivationExpression_IfElse* DerivationExpression::mutable_if_else() { - ::substrait::DerivationExpression_IfElse* _msg = _internal_mutable_if_else(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.if_else) - return _msg; -} - -// .substrait.DerivationExpression.ReturnProgram return_program = 39; -inline bool DerivationExpression::_internal_has_return_program() const { - return kind_case() == kReturnProgram; -} -inline bool DerivationExpression::has_return_program() const { - return _internal_has_return_program(); -} -inline void DerivationExpression::set_has_return_program() { - _oneof_case_[0] = kReturnProgram; -} -inline void DerivationExpression::clear_return_program() { - if (_internal_has_return_program()) { - if (GetArenaForAllocation() == nullptr) { - delete kind_.return_program_; - } - clear_has_kind(); - } -} -inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::release_return_program() { - // @@protoc_insertion_point(field_release:substrait.DerivationExpression.return_program) - if (_internal_has_return_program()) { - clear_has_kind(); - ::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_; - if (GetArenaForAllocation() != nullptr) { - temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); - } - kind_.return_program_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::substrait::DerivationExpression_ReturnProgram& DerivationExpression::_internal_return_program() const { - return _internal_has_return_program() - ? *kind_.return_program_ - : reinterpret_cast< ::substrait::DerivationExpression_ReturnProgram&>(::substrait::_DerivationExpression_ReturnProgram_default_instance_); -} -inline const ::substrait::DerivationExpression_ReturnProgram& DerivationExpression::return_program() const { - // @@protoc_insertion_point(field_get:substrait.DerivationExpression.return_program) - return _internal_return_program(); -} -inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::unsafe_arena_release_return_program() { - // @@protoc_insertion_point(field_unsafe_arena_release:substrait.DerivationExpression.return_program) - if (_internal_has_return_program()) { - clear_has_kind(); - ::substrait::DerivationExpression_ReturnProgram* temp = kind_.return_program_; - kind_.return_program_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void DerivationExpression::unsafe_arena_set_allocated_return_program(::substrait::DerivationExpression_ReturnProgram* return_program) { - clear_kind(); - if (return_program) { - set_has_return_program(); - kind_.return_program_ = return_program; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:substrait.DerivationExpression.return_program) -} -inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::_internal_mutable_return_program() { - if (!_internal_has_return_program()) { - clear_kind(); - set_has_return_program(); - kind_.return_program_ = CreateMaybeMessage< ::substrait::DerivationExpression_ReturnProgram >(GetArenaForAllocation()); - } - return kind_.return_program_; -} -inline ::substrait::DerivationExpression_ReturnProgram* DerivationExpression::mutable_return_program() { - ::substrait::DerivationExpression_ReturnProgram* _msg = _internal_mutable_return_program(); - // @@protoc_insertion_point(field_mutable:substrait.DerivationExpression.return_program) - return _msg; -} - -inline bool DerivationExpression::has_kind() const { - return kind_case() != KIND_NOT_SET; -} -inline void DerivationExpression::clear_has_kind() { - _oneof_case_[0] = KIND_NOT_SET; -} -inline DerivationExpression::KindCase DerivationExpression::kind_case() const { - return DerivationExpression::KindCase(_oneof_case_[0]); -} -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace substrait - -PROTOBUF_NAMESPACE_OPEN - -template <> struct is_proto_enum< ::substrait::DerivationExpression_UnaryOp_UnaryOpType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::DerivationExpression_UnaryOp_UnaryOpType>() { - return ::substrait::DerivationExpression_UnaryOp_UnaryOpType_descriptor(); -} -template <> struct is_proto_enum< ::substrait::DerivationExpression_BinaryOp_BinaryOpType> : ::std::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::substrait::DerivationExpression_BinaryOp_BinaryOpType>() { - return ::substrait::DerivationExpression_BinaryOp_BinaryOpType_descriptor(); -} - -PROTOBUF_NAMESPACE_CLOSE - -// @@protoc_insertion_point(global_scope) - -#include -#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_substrait_2ftype_5fexpressions_2eproto From aa0e94b516be9542bd1a88d84a20443e0edfbba7 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 11:23:13 +0100 Subject: [PATCH 071/113] Split ARROW_SUBSTRAIT_REPO_AND_TAG option --- cpp/cmake_modules/DefineOptions.cmake | 19 +++++++++++++------ cpp/src/arrow/engine/CMakeLists.txt | 9 --------- 2 files changed, 13 insertions(+), 15 deletions(-) diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake index 8a7f31041d7..3db3d16dcfb 100644 --- a/cpp/cmake_modules/DefineOptions.cmake +++ b/cpp/cmake_modules/DefineOptions.cmake @@ -478,12 +478,19 @@ advised that if this is enabled 'install' will fail silently on components;\ that have not been built" OFF) - set(ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT - "https://github.com/substrait-io/substrait e1b4c04a1b518912f4c4065b16a1b2c0ac8e14cf" - ) - define_option_string(ARROW_SUBSTRAIT_REPO_AND_TAG - "Custom 'repository_url tag' for generating substrait accessors" - "${ARROW_SUBSTRAIT_REPO_AND_TAG_DEFAULT}") + set(ARROW_SUBSTRAIT_REPO_DEFAULT + "https://github.com/substrait-io/substrait") + define_option_string(ARROW_SUBSTRAIT_REPO + "Custom git repository URL for downloading Substrait sources.;\ +See also ARROW_SUBSTRAIT_TAG" + "${ARROW_SUBSTRAIT_REPO_DEFAULT}") + + set(ARROW_SUBSTRAIT_TAG_DEFAULT + "e1b4c04a1b518912f4c4065b16a1b2c0ac8e14cf") + define_option_string(ARROW_SUBSTRAIT_TAG + "Custom git hash/tag/branch for Substrait repository.;\ +See also ARROW_SUBSTRAIT_REPO" + "${ARROW_SUBSTRAIT_TAG_DEFAULT}") option(ARROW_BUILD_CONFIG_SUMMARY_JSON "Summarize build configuration in a JSON file" ON) diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index cc6c781613a..d9e9e2d11d8 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -47,15 +47,6 @@ set(SUBSTRAIT_PROTOS type type_expressions) -string(FIND "${ARROW_SUBSTRAIT_REPO_AND_TAG}" " " TAG_START) -if(TAG_START EQUAL -1) - message(FATAL_ERROR "Cannot parse ARROW_SUBSTRAIT_REPO_AND_TAG='${ARROW_SUBSTRAIT_REPO_AND_TAG}'" - ) -endif() -string(SUBSTRING "${ARROW_SUBSTRAIT_REPO_AND_TAG}" 0 ${TAG_START} ARROW_SUBSTRAIT_REPO) -string(SUBSTRING "${ARROW_SUBSTRAIT_REPO_AND_TAG}" ${TAG_START} -1 ARROW_SUBSTRAIT_TAG) -string(STRIP "${ARROW_SUBSTRAIT_TAG}" ARROW_SUBSTRAIT_TAG) - externalproject_add(substrait_ep GIT_REPOSITORY "${ARROW_SUBSTRAIT_REPO}" GIT_TAG "${ARROW_SUBSTRAIT_TAG}" From 584b49e7a6e9c40b7aec13eb1ba5e841684bcfc2 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 11:36:45 +0100 Subject: [PATCH 072/113] Reorganize Arrow/Substrait example --- .../arrow/engine_substrait_consumption.cc | 122 +++++++++--------- 1 file changed, 60 insertions(+), 62 deletions(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index 1dfaff1b67d..e31a323bc42 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -37,8 +37,6 @@ namespace cp = ::arrow::compute; } \ } while (0); -arrow::Future> GetSubstraitFromServer(); - class IgnoringConsumer : public cp::SinkNodeConsumer { public: explicit IgnoringConsumer(size_t tag) : tag_{tag} {} @@ -64,66 +62,6 @@ class IgnoringConsumer : public cp::SinkNodeConsumer { size_t tag_; }; -int main(int argc, char** argv) { - // Plans arrive at the consumer serialized in a substrait-formatted Buffer - auto maybe_serialized_plan = GetSubstraitFromServer().result(); - ABORT_ON_FAILURE(maybe_serialized_plan.status()); - std::shared_ptr serialized_plan = - std::move(maybe_serialized_plan).ValueOrDie(); - - // Print the received plan to stdout as JSON - arrow::Result maybe_plan_json = - eng::internal::SubstraitToJSON("Plan", *serialized_plan); - ABORT_ON_FAILURE(maybe_plan_json.status()); - std::cout << std::string('#', 50) << " received substrait::Plan:" << std::endl; - std::cout << maybe_plan_json.ValueOrDie() << std::endl; - - // Deserializing a plan requires a factory for consumers: each time a sink node is - // deserialized, a consumer is constructed into which its batches will be piped. - std::vector> consumers; - std::function()> consumer_factory = [&] { - // All batches produced by the plan will be fed into IgnoringConsumers: - auto tag = consumers.size(); - consumers.emplace_back(new IgnoringConsumer{tag}); - return consumers.back(); - }; - - // NOTE Although most of the Deserialize functions require a const ExtensionSet& to - // resolve extension references, a Plan is what we use to construct that ExtensionSet. - // (It should be an optional output later.) In particular, it does not need to be kept - // alive nor does the serialized plan- none of the arrow:: objects in the output will - // contain references to memory owned by either. - auto maybe_decls = eng::DeserializePlan(*serialized_plan, consumer_factory); - ABORT_ON_FAILURE(maybe_decls.status()); - std::vector decls = std::move(maybe_decls).ValueOrDie(); - - // It's safe to drop the serialized plan; we don't leave references to its memory - serialized_plan.reset(); - - // Construct an empty plan (note: configure Function registry and ThreadPool here) - auto maybe_plan = cp::ExecPlan::Make(); - ABORT_ON_FAILURE(maybe_plan.status()); - std::shared_ptr plan = std::move(maybe_plan).ValueOrDie(); - - for (const cp::Declaration& decl : decls) { - // Add decl to plan (note: configure ExecNode registry here) - ABORT_ON_FAILURE(decl.AddToPlan(plan.get()).status()); - } - - // Validate the plan and print it to stdout - ABORT_ON_FAILURE(plan->Validate()); - std::cout << std::string('#', 50) << " produced arrow::ExecPlan:" << std::endl; - std::cout << plan->ToString() << std::endl; - - // Start the plan... - std::cout << std::string('#', 50) << " consuming batches:" << std::endl; - ABORT_ON_FAILURE(plan->StartProducing()); - - // ... and wait for it to finish - ABORT_ON_FAILURE(plan->finished().status()); - return EXIT_SUCCESS; -} - arrow::Future> GetSubstraitFromServer() { // Emulate server interaction by parsing hard coded JSON return eng::internal::SubstraitFromJSON("Plan", R"({ @@ -185,3 +123,63 @@ arrow::Future> GetSubstraitFromServer() { ] })"); } + +int main(int argc, char** argv) { + // Plans arrive at the consumer serialized in a substrait-formatted Buffer + auto maybe_serialized_plan = GetSubstraitFromServer().result(); + ABORT_ON_FAILURE(maybe_serialized_plan.status()); + std::shared_ptr serialized_plan = + std::move(maybe_serialized_plan).ValueOrDie(); + + // Print the received plan to stdout as JSON + arrow::Result maybe_plan_json = + eng::internal::SubstraitToJSON("Plan", *serialized_plan); + ABORT_ON_FAILURE(maybe_plan_json.status()); + std::cout << std::string('#', 50) << " received substrait::Plan:" << std::endl; + std::cout << maybe_plan_json.ValueOrDie() << std::endl; + + // Deserializing a plan requires a factory for consumers: each time a sink node is + // deserialized, a consumer is constructed into which its batches will be piped. + std::vector> consumers; + std::function()> consumer_factory = [&] { + // All batches produced by the plan will be fed into IgnoringConsumers: + auto tag = consumers.size(); + consumers.emplace_back(new IgnoringConsumer{tag}); + return consumers.back(); + }; + + // NOTE Although most of the Deserialize functions require a const ExtensionSet& to + // resolve extension references, a Plan is what we use to construct that ExtensionSet. + // (It should be an optional output later.) In particular, it does not need to be kept + // alive nor does the serialized plan- none of the arrow:: objects in the output will + // contain references to memory owned by either. + auto maybe_decls = eng::DeserializePlan(*serialized_plan, consumer_factory); + ABORT_ON_FAILURE(maybe_decls.status()); + std::vector decls = std::move(maybe_decls).ValueOrDie(); + + // It's safe to drop the serialized plan; we don't leave references to its memory + serialized_plan.reset(); + + // Construct an empty plan (note: configure Function registry and ThreadPool here) + auto maybe_plan = cp::ExecPlan::Make(); + ABORT_ON_FAILURE(maybe_plan.status()); + std::shared_ptr plan = std::move(maybe_plan).ValueOrDie(); + + for (const cp::Declaration& decl : decls) { + // Add decl to plan (note: configure ExecNode registry here) + ABORT_ON_FAILURE(decl.AddToPlan(plan.get()).status()); + } + + // Validate the plan and print it to stdout + ABORT_ON_FAILURE(plan->Validate()); + std::cout << std::string('#', 50) << " produced arrow::ExecPlan:" << std::endl; + std::cout << plan->ToString() << std::endl; + + // Start the plan... + std::cout << std::string('#', 50) << " consuming batches:" << std::endl; + ABORT_ON_FAILURE(plan->StartProducing()); + + // ... and wait for it to finish + ABORT_ON_FAILURE(plan->finished().status()); + return EXIT_SUCCESS; +} From ba74f7dfd0ea639d3111e1471ca957e23908f91f Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 11:41:17 +0100 Subject: [PATCH 073/113] Remove redundant :: namespace prefixes in Arrow/Substrait example Co-authored-by: Weston Pace --- cpp/examples/arrow/engine_substrait_consumption.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index e31a323bc42..117f30a3e30 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -25,8 +25,8 @@ #include #include -namespace eng = ::arrow::engine; -namespace cp = ::arrow::compute; +namespace eng = arrow::engine; +namespace cp = arrow::compute; #define ABORT_ON_FAILURE(expr) \ do { \ From f1e625918cf3495842e5b80b2fad635b675232f4 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 12:09:30 +0100 Subject: [PATCH 074/113] Clarify comment in Arrow/Substrait example --- cpp/examples/arrow/engine_substrait_consumption.cc | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index 117f30a3e30..1f0295fdbb8 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -138,8 +138,10 @@ int main(int argc, char** argv) { std::cout << std::string('#', 50) << " received substrait::Plan:" << std::endl; std::cout << maybe_plan_json.ValueOrDie() << std::endl; - // Deserializing a plan requires a factory for consumers: each time a sink node is - // deserialized, a consumer is constructed into which its batches will be piped. + // The data sink(s) for plans is/are implicit in substrait plans, but explicit in + // Arrow. Therefore, deserializing a plan requires a factory for consumers: each + // time the root of a substrait relation tree is deserialized, an Arrow consumer is + // constructed into which its batches will be piped. std::vector> consumers; std::function()> consumer_factory = [&] { // All batches produced by the plan will be fed into IgnoringConsumers: From 283e87b378afe15be2d974f8bbc516009abd3c86 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 12:26:26 +0100 Subject: [PATCH 075/113] Document IgnoringConsumer::tag_ in Arrow/Substrait example --- cpp/examples/arrow/engine_substrait_consumption.cc | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index 1f0295fdbb8..5f5aca50ad8 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -59,6 +59,10 @@ class IgnoringConsumer : public cp::SinkNodeConsumer { } private: + // A unique label for instances to help distinguish logging output if a plan has + // multiple sinks + // + // In this example, this is set to the zero-based index of the relation tree in the plan size_t tag_; }; From d64d53b8b95a3580de42b24cc866c702f90173db Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 12:33:40 +0100 Subject: [PATCH 076/113] Clarify comment in Arrow/Substrait example --- cpp/examples/arrow/engine_substrait_consumption.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index 5f5aca50ad8..5563f5eeaa4 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -129,7 +129,8 @@ arrow::Future> GetSubstraitFromServer() { } int main(int argc, char** argv) { - // Plans arrive at the consumer serialized in a substrait-formatted Buffer + // Plans arrive at the consumer serialized in a Buffer, using the binary protobuf + // serialization of a substrait Plan auto maybe_serialized_plan = GetSubstraitFromServer().result(); ABORT_ON_FAILURE(maybe_serialized_plan.status()); std::shared_ptr serialized_plan = From e730309ded4da2242adce276040c9f9421d2a342 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 12:46:43 +0100 Subject: [PATCH 077/113] Clarify Arrow/Substrait example; remove unnecessary implementation details from comments --- cpp/examples/arrow/engine_substrait_consumption.cc | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index 5563f5eeaa4..fea874c693e 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -155,12 +155,9 @@ int main(int argc, char** argv) { return consumers.back(); }; - // NOTE Although most of the Deserialize functions require a const ExtensionSet& to - // resolve extension references, a Plan is what we use to construct that ExtensionSet. - // (It should be an optional output later.) In particular, it does not need to be kept - // alive nor does the serialized plan- none of the arrow:: objects in the output will - // contain references to memory owned by either. - auto maybe_decls = eng::DeserializePlan(*serialized_plan, consumer_factory); + // Deserialize each relation tree in the substrait plan to an Arrow compute Declaration + arrow::Result> maybe_decls = + eng::DeserializePlan(*serialized_plan, consumer_factory); ABORT_ON_FAILURE(maybe_decls.status()); std::vector decls = std::move(maybe_decls).ValueOrDie(); @@ -168,7 +165,7 @@ int main(int argc, char** argv) { serialized_plan.reset(); // Construct an empty plan (note: configure Function registry and ThreadPool here) - auto maybe_plan = cp::ExecPlan::Make(); + arrow::Result> maybe_plan = cp::ExecPlan::Make(); ABORT_ON_FAILURE(maybe_plan.status()); std::shared_ptr plan = std::move(maybe_plan).ValueOrDie(); From 2901721b88f3469825a00b9b5571c26acb6ddb81 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 12:58:39 +0100 Subject: [PATCH 078/113] Clarify comment in Arrow/Substrait example --- cpp/examples/arrow/engine_substrait_consumption.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index fea874c693e..0c6aa51901e 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -169,8 +169,8 @@ int main(int argc, char** argv) { ABORT_ON_FAILURE(maybe_plan.status()); std::shared_ptr plan = std::move(maybe_plan).ValueOrDie(); + // Add decls to plan (note: configure ExecNode registry before this point) for (const cp::Declaration& decl : decls) { - // Add decl to plan (note: configure ExecNode registry here) ABORT_ON_FAILURE(decl.AddToPlan(plan.get()).status()); } From 96aebea28c82de8937abd0589b68fce6d4aa7760 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 13:26:13 +0100 Subject: [PATCH 079/113] Simplify includes for Arrow/Substrait example Co-authored-by: Weston Pace --- cpp/examples/arrow/engine_substrait_consumption.cc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index 0c6aa51901e..cb1d893092a 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -17,8 +17,7 @@ #include #include -#include -#include +#include #include #include From a8dd17202a0bb07fab58ed8d30403662c6aba2a8 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 14:21:44 +0100 Subject: [PATCH 080/113] Revert error message --- cpp/src/arrow/type.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cpp/src/arrow/type.cc b/cpp/src/arrow/type.cc index 5842d4bc92f..2a382662497 100644 --- a/cpp/src/arrow/type.cc +++ b/cpp/src/arrow/type.cc @@ -1544,7 +1544,7 @@ Result> Schema::AddField( Result> Schema::SetField( int i, const std::shared_ptr& field) const { if (i < 0 || i > this->num_fields()) { - return Status::Invalid("Invalid column index to add field."); + return Status::Invalid("Invalid column index to set field."); } return std::make_shared( From 1404f710a8bde0593d5739b2960e4f35b79ce848 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 17:35:59 +0100 Subject: [PATCH 081/113] Remove duplicate definition of u32 Co-authored-by: Weston Pace --- format/substrait/extension_types.yaml | 4 ---- 1 file changed, 4 deletions(-) diff --git a/format/substrait/extension_types.yaml b/format/substrait/extension_types.yaml index 8909ae7372d..ae772439322 100644 --- a/format/substrait/extension_types.yaml +++ b/format/substrait/extension_types.yaml @@ -90,10 +90,6 @@ type_variations: name: u32 description: an unsigned 32 bit integer functions: SEPARATE - - parent: i32 - name: u32 - description: an unsigned 32 bit integer - functions: SEPARATE - parent: i64 name: u64 description: an unsigned 64 bit integer From 4b9296174ed5b83462b389795c207f43de9fe90a Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 1 Feb 2022 19:11:25 +0100 Subject: [PATCH 082/113] Minor improvements to expression_internal.cc based on code review Co-authored-by: Weston Pace --- cpp/src/arrow/engine/substrait/expression_internal.cc | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 796f9ab5a72..a1623d6f11b 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -22,12 +22,10 @@ #include #include "arrow/builder.h" -#include "arrow/compute/cast.h" #include "arrow/compute/exec/expression.h" #include "arrow/compute/exec/expression_internal.h" #include "arrow/engine/substrait/extension_types.h" #include "arrow/engine/substrait/type_internal.h" -#include "arrow/engine/visibility.h" #include "arrow/result.h" #include "arrow/status.h" #include "arrow/util/make_unique.h" @@ -153,7 +151,7 @@ Result FromProto(const substrait::Expression& expr, size_t name_counter = 0; args.reserve(if_then.ifs_size() + 2); args.emplace_back(); - for (auto if_ : if_then.ifs()) { + for (const auto& if_ : if_then.ifs()) { ARROW_ASSIGN_OR_RAISE(auto compute_if, FromProto(if_.if_(), ext_set)); ARROW_ASSIGN_OR_RAISE(auto compute_then, FromProto(if_.then(), ext_set)); conditions.emplace_back(std::move(compute_if)); @@ -325,7 +323,7 @@ Result FromProto(const substrait::Expression::Literal& lit, } } - ARROW_ASSIGN_OR_RAISE(auto builder, MakeBuilder(std::move(element_type))); + ARROW_ASSIGN_OR_RAISE(auto builder, MakeBuilder(element_type)); RETURN_NOT_OK(builder->AppendScalars(values)); ARROW_ASSIGN_OR_RAISE(auto arr, builder->Finish()); return Datum(ListScalar(std::move(arr))); From a9862a1f15c0de55a1e0204798a155fcbc1ab424 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 2 Feb 2022 12:01:10 +0100 Subject: [PATCH 083/113] Fix std::string(n,c) argument order in Substrait example --- cpp/examples/arrow/engine_substrait_consumption.cc | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index cb1d893092a..c7c390962b9 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -139,7 +139,7 @@ int main(int argc, char** argv) { arrow::Result maybe_plan_json = eng::internal::SubstraitToJSON("Plan", *serialized_plan); ABORT_ON_FAILURE(maybe_plan_json.status()); - std::cout << std::string('#', 50) << " received substrait::Plan:" << std::endl; + std::cout << std::string(50, '#') << " received substrait::Plan:" << std::endl; std::cout << maybe_plan_json.ValueOrDie() << std::endl; // The data sink(s) for plans is/are implicit in substrait plans, but explicit in @@ -175,11 +175,11 @@ int main(int argc, char** argv) { // Validate the plan and print it to stdout ABORT_ON_FAILURE(plan->Validate()); - std::cout << std::string('#', 50) << " produced arrow::ExecPlan:" << std::endl; + std::cout << std::string(50, '#') << " produced arrow::ExecPlan:" << std::endl; std::cout << plan->ToString() << std::endl; // Start the plan... - std::cout << std::string('#', 50) << " consuming batches:" << std::endl; + std::cout << std::string(50, '#') << " consuming batches:" << std::endl; ABORT_ON_FAILURE(plan->StartProducing()); // ... and wait for it to finish From 4b55deef4d8ca253b597437d1fd4c16275254d2c Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 2 Feb 2022 12:02:08 +0100 Subject: [PATCH 084/113] Avoid shared_ptr copy, fix move -> forward in datum.h --- cpp/src/arrow/datum.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/cpp/src/arrow/datum.h b/cpp/src/arrow/datum.h index 45e0d682fa9..48388386b9b 100644 --- a/cpp/src/arrow/datum.h +++ b/cpp/src/arrow/datum.h @@ -149,16 +149,16 @@ struct ARROW_EXPORT Datum { template ::value, bool IsScalar = std::is_base_of::value, typename = enable_if_t> - Datum(const std::shared_ptr& value) // NOLINT implicit conversion + Datum(std::shared_ptr value) // NOLINT implicit conversion : Datum(std::shared_ptr::type>( - value)) {} + std::move(value))) {} // Cast from subtypes of Array or Scalar to Datum template ::value, bool IsScalar = std::is_base_of::value, typename = enable_if_t> Datum(T&& value) // NOLINT implicit conversion - : Datum(std::make_shared(std::move(value))) {} + : Datum(std::make_shared(std::forward(value))) {} // Convenience constructors explicit Datum(bool value); From 7f814920896c78e510da0649cc39be41e4abf3be Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 2 Feb 2022 13:46:37 +0100 Subject: [PATCH 085/113] Add convenience constructors from std::string to *BinaryScalars --- .../engine/substrait/expression_internal.cc | 19 ++++--------------- cpp/src/arrow/scalar.cc | 12 ++++++++++++ cpp/src/arrow/scalar.h | 11 ++++++++++- 3 files changed, 26 insertions(+), 16 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index a1623d6f11b..c8d56c2a59c 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -41,17 +41,6 @@ namespace internal { using ::arrow::internal::make_unique; } // namespace internal -namespace { - -std::shared_ptr FixedSizeBinaryScalarFromBytes( - const std::string& bytes) { - auto buf = Buffer::FromString(bytes); - auto type = fixed_size_binary(static_cast(buf->size())); - return std::make_shared(std::move(buf), std::move(type)); -} - -} // namespace - Result FromProto(const substrait::Expression& expr, const ExtensionSet& ext_set) { switch (expr.rex_type_case()) { @@ -216,7 +205,7 @@ Result FromProto(const substrait::Expression::Literal& lit, case substrait::Expression::Literal::kString: return Datum(lit.string()); case substrait::Expression::Literal::kBinary: - return Datum(BinaryScalar(Buffer::FromString(lit.binary()))); + return Datum(BinaryScalar(lit.binary())); case substrait::Expression::Literal::kTimestamp: return Datum( @@ -250,11 +239,11 @@ Result FromProto(const substrait::Expression::Literal& lit, } case substrait::Expression::Literal::kUuid: - return Datum(ExtensionScalar(FixedSizeBinaryScalarFromBytes(lit.uuid()), uuid())); + return Datum(ExtensionScalar(FixedSizeBinaryScalar(lit.uuid()), uuid())); case substrait::Expression::Literal::kFixedChar: return Datum( - ExtensionScalar(FixedSizeBinaryScalarFromBytes(lit.fixed_char()), + ExtensionScalar(FixedSizeBinaryScalar(lit.fixed_char()), fixed_char(static_cast(lit.fixed_char().size())))); case substrait::Expression::Literal::kVarChar: @@ -263,7 +252,7 @@ Result FromProto(const substrait::Expression::Literal& lit, varchar(static_cast(lit.var_char().length())))); case substrait::Expression::Literal::kFixedBinary: - return Datum(FixedSizeBinaryScalarFromBytes(lit.fixed_binary())); + return Datum(FixedSizeBinaryScalar(lit.fixed_binary())); case substrait::Expression::Literal::kDecimal: { if (lit.decimal().value().size() != sizeof(Decimal128)) { diff --git a/cpp/src/arrow/scalar.cc b/cpp/src/arrow/scalar.cc index 23c07e6ade2..23c463b6523 100644 --- a/cpp/src/arrow/scalar.cc +++ b/cpp/src/arrow/scalar.cc @@ -475,9 +475,15 @@ Status Scalar::ValidateFull() const { return ScalarValidateImpl(/*full_validation=*/true).Validate(*this); } +BinaryScalar::BinaryScalar(std::string s) + : BinaryScalar(Buffer::FromString(std::move(s))) {} + StringScalar::StringScalar(std::string s) : StringScalar(Buffer::FromString(std::move(s))) {} +LargeBinaryScalar::LargeBinaryScalar(std::string s) + : LargeBinaryScalar(Buffer::FromString(std::move(s))) {} + LargeStringScalar::LargeStringScalar(std::string s) : LargeStringScalar(Buffer::FromString(std::move(s))) {} @@ -488,6 +494,12 @@ FixedSizeBinaryScalar::FixedSizeBinaryScalar(std::shared_ptr value, this->value->size()); } +FixedSizeBinaryScalar::FixedSizeBinaryScalar(const std::shared_ptr& value) + : BinaryScalar(value, fixed_size_binary(static_cast(value->size()))) {} + +FixedSizeBinaryScalar::FixedSizeBinaryScalar(std::string s) + : FixedSizeBinaryScalar(Buffer::FromString(std::move(s))) {} + BaseListScalar::BaseListScalar(std::shared_ptr value, std::shared_ptr type) : Scalar{std::move(type), true}, value(std::move(value)) { diff --git a/cpp/src/arrow/scalar.h b/cpp/src/arrow/scalar.h index e5a398b7014..943a6420d80 100644 --- a/cpp/src/arrow/scalar.h +++ b/cpp/src/arrow/scalar.h @@ -250,6 +250,8 @@ struct ARROW_EXPORT BinaryScalar : public BaseBinaryScalar { explicit BinaryScalar(std::shared_ptr value) : BinaryScalar(std::move(value), binary()) {} + explicit BinaryScalar(std::string s); + BinaryScalar() : BinaryScalar(binary()) {} }; @@ -275,6 +277,8 @@ struct ARROW_EXPORT LargeBinaryScalar : public BaseBinaryScalar { explicit LargeBinaryScalar(std::shared_ptr value) : LargeBinaryScalar(std::move(value), large_binary()) {} + explicit LargeBinaryScalar(std::string s); + LargeBinaryScalar() : LargeBinaryScalar(large_binary()) {} }; @@ -295,7 +299,12 @@ struct ARROW_EXPORT FixedSizeBinaryScalar : public BinaryScalar { FixedSizeBinaryScalar(std::shared_ptr value, std::shared_ptr type); - explicit FixedSizeBinaryScalar(std::shared_ptr type) : BinaryScalar(type) {} + explicit FixedSizeBinaryScalar(const std::shared_ptr& value); + + explicit FixedSizeBinaryScalar(std::string s); + + explicit FixedSizeBinaryScalar(std::shared_ptr type) + : BinaryScalar(std::move(type)) {} }; template From a284e1861d0dda748ffdc68e744b3dbd90d6f16a Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 2 Feb 2022 15:16:05 +0100 Subject: [PATCH 086/113] Map Substrait date to Arrow Date32 instead of Date64 --- cpp/src/arrow/engine/substrait/expression_internal.cc | 8 ++++---- cpp/src/arrow/engine/substrait/serde_test.cc | 8 +++----- cpp/src/arrow/engine/substrait/type_internal.cc | 6 +++--- 3 files changed, 10 insertions(+), 12 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index c8d56c2a59c..407e2ed1eba 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -216,9 +216,9 @@ Result FromProto(const substrait::Expression::Literal& lit, TimeUnit::MICRO, TimestampTzTimezoneString())); case substrait::Expression::Literal::kDate: - return Datum(Date64Scalar(static_cast(lit.date()))); + return Datum(Date32Scalar(lit.date())); case substrait::Expression::Literal::kTime: - return Datum(Time64Scalar(static_cast(lit.time()), TimeUnit::MICRO)); + return Datum(Time64Scalar(lit.time(), TimeUnit::MICRO)); case substrait::Expression::Literal::kIntervalYearToMonth: case substrait::Expression::Literal::kIntervalDayToSecond: { @@ -466,8 +466,8 @@ struct ScalarToProtoImpl { return FromBuffer(&Lit::set_fixed_binary, s); } - Status Visit(const Date32Scalar& s) { return NotImplemented(s); } - Status Visit(const Date64Scalar& s) { return Primitive(&Lit::set_date, s); } + Status Visit(const Date32Scalar& s) { return Primitive(&Lit::set_date, s); } + Status Visit(const Date64Scalar& s) { return NotImplemented(s); } Status Visit(const TimestampScalar& s) { const auto& t = checked_cast(*s.type); diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 983ff6d5a3d..2d3902d3b59 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -154,7 +154,7 @@ TEST(Substrait, SupportedTypes) { ExpectEq(R"({"binary": {}})", binary()); ExpectEq(R"({"timestamp": {}})", timestamp(TimeUnit::MICRO)); - ExpectEq(R"({"date": {}})", date64()); + ExpectEq(R"({"date": {}})", date32()); ExpectEq(R"({"time": {}})", time64(TimeUnit::MICRO)); ExpectEq(R"({"timestamp_tz": {}})", timestamp(TimeUnit::MICRO, "UTC")); ExpectEq(R"({"interval_year": {}})", interval_year()); @@ -278,7 +278,7 @@ TEST(Substrait, NoEquivalentArrowType) { TEST(Substrait, NoEquivalentSubstraitType) { for (auto type : { - date32(), + date64(), timestamp(TimeUnit::SECOND), timestamp(TimeUnit::NANO), timestamp(TimeUnit::MICRO, "New York"), @@ -343,9 +343,7 @@ TEST(Substrait, SupportedLiterals) { ExpectEq(R"({"timestamp": "579"})", TimestampScalar(579, TimeUnit::MICRO)); - constexpr int64_t kDayFiveOfEpoch = 24 * 60 * 60 * 1000 * 5; - static_assert(kDayFiveOfEpoch == 432000000, "until c++ gets string interpolation"); - ExpectEq(R"({"date": "432000000"})", Date64Scalar(kDayFiveOfEpoch)); + ExpectEq(R"({"date": "5"})", Date32Scalar(5)); ExpectEq(R"({"time": "64"})", Time64Scalar(64, TimeUnit::MICRO)); diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 0b516436140..0752e2c19ee 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -129,7 +129,7 @@ Result, bool>> FromProto( return FromProtoImpl(type.timestamp_tz(), TimeUnit::MICRO, TimestampTzTimezoneString()); case substrait::Type::kDate: - return FromProtoImpl(type.date()); + return FromProtoImpl(type.date()); case substrait::Type::kTime: return FromProtoImpl(type.time(), TimeUnit::MICRO); @@ -269,10 +269,10 @@ struct DataTypeToProtoImpl { return Status::OK(); } - Status Visit(const Date32Type& t) { return NotImplemented(t); } - Status Visit(const Date64Type& t) { + Status Visit(const Date32Type& t) { return SetWith(&substrait::Type::set_allocated_date); } + Status Visit(const Date64Type& t) { return NotImplemented(t); } Status Visit(const TimestampType& t) { if (t.unit() != TimeUnit::MICRO) return NotImplemented(t); From d099775f5cb87e381e3278870ed6715601e04772 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 2 Feb 2022 15:37:36 +0100 Subject: [PATCH 087/113] Clarify lack of struct field names in Substrait in comment as requested --- cpp/src/arrow/engine/substrait/expression_internal.cc | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 407e2ed1eba..6055199591d 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -275,12 +275,16 @@ Result FromProto(const substrait::Expression::Literal& lit, const auto& struct_ = lit.struct_(); ScalarVector fields(struct_.fields_size()); - std::vector field_names(fields.size(), ""); for (int i = 0; i < struct_.fields_size(); ++i) { ARROW_ASSIGN_OR_RAISE(auto field, FromProto(struct_.fields(i), ext_set)); DCHECK(field.is_scalar()); fields[i] = field.scalar(); } + + // Note that Substrait struct types don't have field names, but Arrow does, so we + // just use empty strings for them. + std::vector field_names(fields.size(), ""); + ARROW_ASSIGN_OR_RAISE( auto scalar, StructScalar::Make(std::move(fields), std::move(field_names))); return Datum(std::move(scalar)); From bdb0b74cfad6bd5e4e1751b6261feb8ed77ca096 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 2 Feb 2022 17:18:57 +0100 Subject: [PATCH 088/113] Slightly improve Substrait to Arrow conversion error messages --- cpp/src/arrow/engine/substrait/expression_internal.cc | 10 ++++++---- cpp/src/arrow/engine/substrait/relation_internal.cc | 5 +++-- cpp/src/arrow/engine/substrait/type_internal.cc | 4 ++-- 3 files changed, 11 insertions(+), 8 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 6055199591d..0ac2f2946c4 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -171,8 +171,9 @@ Result FromProto(const substrait::Expression& expr, break; } - return Status::NotImplemented("conversion to arrow::compute::Expression from ", - expr.DebugString()); + return Status::NotImplemented( + "conversion to arrow::compute::Expression from Substrait expression ", + expr.DebugString()); } Result FromProto(const substrait::Expression::Literal& lit, @@ -413,7 +414,7 @@ Result FromProto(const substrait::Expression::Literal& lit, case substrait::Expression::Literal::kNull: { ARROW_ASSIGN_OR_RAISE(auto type_nullable, FromProto(lit.null(), ext_set)); if (!type_nullable.second) { - return Status::Invalid("Null literal ", lit.DebugString(), + return Status::Invalid("Substrait null literal ", lit.DebugString(), " is of non-nullable type"); } @@ -424,7 +425,8 @@ Result FromProto(const substrait::Expression::Literal& lit, break; } - return Status::NotImplemented("conversion to arrow::Datum from ", lit.DebugString()); + return Status::NotImplemented("conversion to arrow::Datum from Substrait literal ", + lit.DebugString()); } namespace { diff --git a/cpp/src/arrow/engine/substrait/relation_internal.cc b/cpp/src/arrow/engine/substrait/relation_internal.cc index 75dc0ecff76..936f27f8aa0 100644 --- a/cpp/src/arrow/engine/substrait/relation_internal.cc +++ b/cpp/src/arrow/engine/substrait/relation_internal.cc @@ -178,8 +178,9 @@ Result FromProto(const substrait::Rel& rel, break; } - return Status::NotImplemented("conversion to arrow::compute::Declaration from ", - rel.DebugString()); + return Status::NotImplemented( + "conversion to arrow::compute::Declaration from Substrait relation ", + rel.DebugString()); } } // namespace engine diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 0752e2c19ee..9f252ea3dc8 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -220,7 +220,7 @@ Result, bool>> FromProto( break; } - return Status::NotImplemented("conversion to arrow::DataType from ", + return Status::NotImplemented("conversion to arrow::DataType from Substrait type ", type.DebugString()); } @@ -425,7 +425,7 @@ Result> FromProto(const substrait::NamedStruct& named_st const ExtensionSet& ext_set) { if (!named_struct.has_struct_()) { return Status::Invalid("While converting ", named_struct.DebugString(), - " no anonymous struct type was provided to which to names " + " no anonymous struct type was provided to which names " "could be attached."); } const auto& struct_ = named_struct.struct_(); From 94537075d556df2936b6f3668ac102bdc0d755a8 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 2 Feb 2022 17:56:43 +0100 Subject: [PATCH 089/113] Add docstrings to functions defined in serde.h --- cpp/src/arrow/engine/substrait/serde.h | 83 ++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index a9f0fcfca5a..fbea2541db6 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -34,43 +34,126 @@ namespace arrow { namespace engine { +/// Factory function type for generating the node that consumes the batches produced by +/// each toplevel Substrait relation when deserializing a Substrait Plan. using ConsumerFactory = std::function()>; +/// \brief Deserializes a Substrait Plan message to a list of ExecNode declarations +/// +/// \param[in] buffer a buffer containing the protobuf serialization of a Substrait Plan +/// message +/// \param[in] consumer_factory factory function for generating the node that consumes +/// the batches produced by each toplevel Substrait relation +/// \param[out] ext_set if non-null, the extension mapping used by the Substrait Plan is +/// returned here. +/// \return a vector of ExecNode declarations, one for each toplevel relation in the +/// Substrait Plan ARROW_ENGINE_EXPORT Result> DeserializePlan( const Buffer&, const ConsumerFactory&, ExtensionSet* ext_set = NULLPTR); +/// \brief Deserializes a Substrait Type message to the corresponding Arrow type +/// +/// \param[in] buffer a buffer containing the protobuf serialization of a Substrait Type +/// message +/// \param[in] extension_set the extension mapping to use, normally provided by the +/// surrounding Plan message +/// \return the corresponding Arrow data type ARROW_ENGINE_EXPORT Result> DeserializeType(const Buffer&, const ExtensionSet&); +/// \brief Serializes an Arrow type to a Substrait Type message +/// +/// \param[in] type the Arrow data type to serialize +/// \param[in,out] extension_set the extension mapping to use; may be updated to add a +/// mapping for the given type +/// \return a buffer containing the protobuf serialization of the corresponding Substrait +/// Type message ARROW_ENGINE_EXPORT Result> SerializeType(const DataType&, ExtensionSet*); +/// \brief Deserializes a Substrait NamedStruct message to an Arrow schema +/// +/// \param[in] buffer a buffer containing the protobuf serialization of a Substrait +/// NamedStruct message +/// \param[in] extension_set the extension mapping to use, normally provided by the +/// surrounding Plan message +/// \return the corresponding Arrow schema ARROW_ENGINE_EXPORT Result> DeserializeSchema(const Buffer&, const ExtensionSet&); +/// \brief Serializes an Arrow schema to a Substrait NamedStruct message +/// +/// \param[in] schema the Arrow schema to serialize +/// \param[in,out] extension_set the extension mapping to use; may be updated to add +/// mappings for the types used in the schema +/// \return a buffer containing the protobuf serialization of the corresponding Substrait +/// NamedStruct message ARROW_ENGINE_EXPORT Result> SerializeSchema(const Schema&, ExtensionSet*); +/// \brief Deserializes a Substrait Expression message to a compute expression +/// +/// \param[in] buffer a buffer containing the protobuf serialization of a Substrait +/// Expression message +/// \param[in] extension_set the extension mapping to use, normally provided by the +/// surrounding Plan message +/// \return the corresponding Arrow compute expression ARROW_ENGINE_EXPORT Result DeserializeExpression(const Buffer&, const ExtensionSet&); +/// \brief Serializes an Arrow compute expression to a Substrait Expression message +/// +/// \param[in] expression the Arrow compute expression to serialize +/// \param[in,out] extension_set the extension mapping to use; may be updated to add +/// mappings for the types used in the expression +/// \return a buffer containing the protobuf serialization of the corresponding Substrait +/// Expression message ARROW_ENGINE_EXPORT Result> SerializeExpression(const compute::Expression&, ExtensionSet*); +/// \brief Deserializes a Substrait Rel (relation) message to an ExecNode declaration +/// +/// \param[in] buffer a buffer containing the protobuf serialization of a Substrait +/// Rel message +/// \param[in] extension_set the extension mapping to use, normally provided by the +/// surrounding Plan message +/// \return the corresponding ExecNode declaration ARROW_ENGINE_EXPORT Result DeserializeRelation(const Buffer&, const ExtensionSet&); namespace internal { +/// \brief Checks whether two protobuf serializations of a particular Substrait message +/// type are equivalent +/// +/// Note that a binary comparison of the two buffers is pessimistic, among other reasons +/// because the fields of a message can be specified in any order in the serialization. +/// +/// \param[in] message_name the name of the Substrait message type to check +/// \param[in] l_buf buffer containing the first protobuf serialization to compare +/// \param[in] r_buf buffer containing the second protobuf serialization to compare +/// \return success if equivalent, failure if not ARROW_ENGINE_EXPORT Status CheckMessagesEquivalent(util::string_view message_name, const Buffer&, const Buffer&); +/// \brief Utility function to convert a JSON serialization of a Substrait message to +/// its binary serialization +/// +/// \param[in] type_name the name of the Substrait message type to convert +/// \param[in] json the JSON string to convert +/// \return a buffer filled with the binary protobuf serialization of message ARROW_ENGINE_EXPORT Result> SubstraitFromJSON(util::string_view type_name, util::string_view json); +/// \brief Utility function to convert a binary protobuf serialization of a Substrait +/// message to JSON +/// +/// \param[in] type_name the name of the Substrait message type to convert +/// \param[in] buf the buffer containing the binary protobuf serialization of the message +/// \return a JSON string representing the message ARROW_ENGINE_EXPORT Result SubstraitToJSON(util::string_view type_name, const Buffer& buf); From c58b9c6cb995f2508f67a82d123a0814d9d68cce Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 2 Feb 2022 18:41:34 +0100 Subject: [PATCH 090/113] Add missing NotImplemented checks for Substrait FileOrFiles message --- .../arrow/engine/substrait/relation_internal.cc | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/cpp/src/arrow/engine/substrait/relation_internal.cc b/cpp/src/arrow/engine/substrait/relation_internal.cc index 936f27f8aa0..1cd0aacaf43 100644 --- a/cpp/src/arrow/engine/substrait/relation_internal.cc +++ b/cpp/src/arrow/engine/substrait/relation_internal.cc @@ -119,6 +119,21 @@ Result FromProto(const substrait::Rel& rel, } auto path = item.uri_file().substr(7); + if (item.partition_index() != 0) { + return Status::NotImplemented( + "non-default substrait::ReadRel::LocalFiles::FileOrFiles::partition_index"); + } + + if (item.start() != 0) { + return Status::NotImplemented( + "non-default substrait::ReadRel::LocalFiles::FileOrFiles::start offset"); + } + + if (item.length() != 0) { + return Status::NotImplemented( + "non-default substrait::ReadRel::LocalFiles::FileOrFiles::length"); + } + ARROW_ASSIGN_OR_RAISE(auto fragment, format->MakeFragment(dataset::FileSource{ std::move(path), filesystem})); fragments.push_back(std::move(fragment)); From fc3d4804adc1dd4c57da3075a7a19257c72e5c65 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 2 Feb 2022 18:45:50 +0100 Subject: [PATCH 091/113] Remove unused associated type --- cpp/src/arrow/engine/simple_extension_type_internal.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/cpp/src/arrow/engine/simple_extension_type_internal.h b/cpp/src/arrow/engine/simple_extension_type_internal.h index ecffba3d109..d0644b3aa8b 100644 --- a/cpp/src/arrow/engine/simple_extension_type_internal.h +++ b/cpp/src/arrow/engine/simple_extension_type_internal.h @@ -36,8 +36,6 @@ template GetStorage(const Params&)> class SimpleExtensionType : public ExtensionType { public: - using ParamsType = Params; - explicit SimpleExtensionType(std::shared_ptr storage_type, Params params = {}) : ExtensionType(std::move(storage_type)), params_(std::move(params)) {} From 2da302371d292afe63f14bca1365c2ab36f203d6 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 2 Feb 2022 20:07:04 +0100 Subject: [PATCH 092/113] Fix parameter name links in docstrings added in 9453707 --- cpp/src/arrow/engine/substrait/serde.h | 56 ++++++++++++++------------ 1 file changed, 31 insertions(+), 25 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index fbea2541db6..14c56926474 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -40,7 +40,7 @@ using ConsumerFactory = std::function /// \brief Deserializes a Substrait Plan message to a list of ExecNode declarations /// -/// \param[in] buffer a buffer containing the protobuf serialization of a Substrait Plan +/// \param[in] buf a buffer containing the protobuf serialization of a Substrait Plan /// message /// \param[in] consumer_factory factory function for generating the node that consumes /// the batches produced by each toplevel Substrait relation @@ -49,78 +49,84 @@ using ConsumerFactory = std::function /// \return a vector of ExecNode declarations, one for each toplevel relation in the /// Substrait Plan ARROW_ENGINE_EXPORT Result> DeserializePlan( - const Buffer&, const ConsumerFactory&, ExtensionSet* ext_set = NULLPTR); + const Buffer& buf, const ConsumerFactory& consumer_factory, + ExtensionSet* ext_set = NULLPTR); /// \brief Deserializes a Substrait Type message to the corresponding Arrow type /// -/// \param[in] buffer a buffer containing the protobuf serialization of a Substrait Type +/// \param[in] buf a buffer containing the protobuf serialization of a Substrait Type /// message -/// \param[in] extension_set the extension mapping to use, normally provided by the +/// \param[in] ext_set the extension mapping to use, normally provided by the /// surrounding Plan message /// \return the corresponding Arrow data type ARROW_ENGINE_EXPORT -Result> DeserializeType(const Buffer&, const ExtensionSet&); +Result> DeserializeType(const Buffer& buf, + const ExtensionSet& ext_set); /// \brief Serializes an Arrow type to a Substrait Type message /// /// \param[in] type the Arrow data type to serialize -/// \param[in,out] extension_set the extension mapping to use; may be updated to add a +/// \param[in,out] ext_set the extension mapping to use; may be updated to add a /// mapping for the given type /// \return a buffer containing the protobuf serialization of the corresponding Substrait /// Type message ARROW_ENGINE_EXPORT -Result> SerializeType(const DataType&, ExtensionSet*); +Result> SerializeType(const DataType& type, + ExtensionSet* ext_set); /// \brief Deserializes a Substrait NamedStruct message to an Arrow schema /// -/// \param[in] buffer a buffer containing the protobuf serialization of a Substrait +/// \param[in] buf a buffer containing the protobuf serialization of a Substrait /// NamedStruct message -/// \param[in] extension_set the extension mapping to use, normally provided by the +/// \param[in] ext_set the extension mapping to use, normally provided by the /// surrounding Plan message /// \return the corresponding Arrow schema ARROW_ENGINE_EXPORT -Result> DeserializeSchema(const Buffer&, const ExtensionSet&); +Result> DeserializeSchema(const Buffer& buf, + const ExtensionSet& ext_set); /// \brief Serializes an Arrow schema to a Substrait NamedStruct message /// /// \param[in] schema the Arrow schema to serialize -/// \param[in,out] extension_set the extension mapping to use; may be updated to add +/// \param[in,out] ext_set the extension mapping to use; may be updated to add /// mappings for the types used in the schema /// \return a buffer containing the protobuf serialization of the corresponding Substrait /// NamedStruct message ARROW_ENGINE_EXPORT -Result> SerializeSchema(const Schema&, ExtensionSet*); +Result> SerializeSchema(const Schema& schema, + ExtensionSet* ext_set); /// \brief Deserializes a Substrait Expression message to a compute expression /// -/// \param[in] buffer a buffer containing the protobuf serialization of a Substrait +/// \param[in] buf a buffer containing the protobuf serialization of a Substrait /// Expression message -/// \param[in] extension_set the extension mapping to use, normally provided by the +/// \param[in] ext_set the extension mapping to use, normally provided by the /// surrounding Plan message /// \return the corresponding Arrow compute expression ARROW_ENGINE_EXPORT -Result DeserializeExpression(const Buffer&, const ExtensionSet&); +Result DeserializeExpression(const Buffer& buf, + const ExtensionSet& ext_set); /// \brief Serializes an Arrow compute expression to a Substrait Expression message /// -/// \param[in] expression the Arrow compute expression to serialize -/// \param[in,out] extension_set the extension mapping to use; may be updated to add +/// \param[in] expr the Arrow compute expression to serialize +/// \param[in,out] ext_set the extension mapping to use; may be updated to add /// mappings for the types used in the expression /// \return a buffer containing the protobuf serialization of the corresponding Substrait /// Expression message ARROW_ENGINE_EXPORT -Result> SerializeExpression(const compute::Expression&, - ExtensionSet*); +Result> SerializeExpression(const compute::Expression& expr, + ExtensionSet* ext_set); /// \brief Deserializes a Substrait Rel (relation) message to an ExecNode declaration /// -/// \param[in] buffer a buffer containing the protobuf serialization of a Substrait +/// \param[in] buf a buffer containing the protobuf serialization of a Substrait /// Rel message -/// \param[in] extension_set the extension mapping to use, normally provided by the +/// \param[in] ext_set the extension mapping to use, normally provided by the /// surrounding Plan message /// \return the corresponding ExecNode declaration -ARROW_ENGINE_EXPORT Result DeserializeRelation(const Buffer&, - const ExtensionSet&); +ARROW_ENGINE_EXPORT Result DeserializeRelation( + const Buffer& buf, const ExtensionSet& ext_set); namespace internal { @@ -135,8 +141,8 @@ namespace internal { /// \param[in] r_buf buffer containing the second protobuf serialization to compare /// \return success if equivalent, failure if not ARROW_ENGINE_EXPORT -Status CheckMessagesEquivalent(util::string_view message_name, const Buffer&, - const Buffer&); +Status CheckMessagesEquivalent(util::string_view message_name, const Buffer& l_buf, + const Buffer& r_buf); /// \brief Utility function to convert a JSON serialization of a Substrait message to /// its binary serialization From 231f95ae6cd8c8e10101666564a557b8ed7a1e62 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 3 Feb 2022 11:38:30 +0100 Subject: [PATCH 093/113] ARROW_ENGINE currently depends on ARROW_PARQUET (only place it can get data from when using Substrait) --- cpp/CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt index c26c6403676..dfef91aeb8d 100644 --- a/cpp/CMakeLists.txt +++ b/cpp/CMakeLists.txt @@ -351,6 +351,7 @@ if(ARROW_CUDA endif() if(ARROW_ENGINE) + set(ARROW_PARQUET ON) set(ARROW_COMPUTE ON) set(ARROW_DATASET ON) endif() From e7ec32d91ac0ecebb5bf3597ec0c99fd387974d2 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 3 Feb 2022 12:04:08 +0100 Subject: [PATCH 094/113] Fix CMake module style violations --- cpp/cmake_modules/DefineOptions.cmake | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/cpp/cmake_modules/DefineOptions.cmake b/cpp/cmake_modules/DefineOptions.cmake index 3db3d16dcfb..30b1d0e075b 100644 --- a/cpp/cmake_modules/DefineOptions.cmake +++ b/cpp/cmake_modules/DefineOptions.cmake @@ -478,19 +478,15 @@ advised that if this is enabled 'install' will fail silently on components;\ that have not been built" OFF) - set(ARROW_SUBSTRAIT_REPO_DEFAULT - "https://github.com/substrait-io/substrait") + set(ARROW_SUBSTRAIT_REPO_DEFAULT "https://github.com/substrait-io/substrait") define_option_string(ARROW_SUBSTRAIT_REPO "Custom git repository URL for downloading Substrait sources.;\ -See also ARROW_SUBSTRAIT_TAG" - "${ARROW_SUBSTRAIT_REPO_DEFAULT}") +See also ARROW_SUBSTRAIT_TAG" "${ARROW_SUBSTRAIT_REPO_DEFAULT}") - set(ARROW_SUBSTRAIT_TAG_DEFAULT - "e1b4c04a1b518912f4c4065b16a1b2c0ac8e14cf") + set(ARROW_SUBSTRAIT_TAG_DEFAULT "e1b4c04a1b518912f4c4065b16a1b2c0ac8e14cf") define_option_string(ARROW_SUBSTRAIT_TAG "Custom git hash/tag/branch for Substrait repository.;\ -See also ARROW_SUBSTRAIT_REPO" - "${ARROW_SUBSTRAIT_TAG_DEFAULT}") +See also ARROW_SUBSTRAIT_REPO" "${ARROW_SUBSTRAIT_TAG_DEFAULT}") option(ARROW_BUILD_CONFIG_SUMMARY_JSON "Summarize build configuration in a JSON file" ON) From cbc98426ab19fa79eb800a81cfa2c41af067381f Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 3 Feb 2022 14:20:12 +0100 Subject: [PATCH 095/113] Fix correspondence between extension_types.yaml and extension_set.cc, clean up comments --- .../arrow/engine/substrait/extension_set.cc | 11 ++++ format/substrait/extension_types.yaml | 54 +++++-------------- 2 files changed, 23 insertions(+), 42 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/extension_set.cc b/cpp/src/arrow/engine/substrait/extension_set.cc index 084f8f3bb4f..9d582bbd28e 100644 --- a/cpp/src/arrow/engine/substrait/extension_set.cc +++ b/cpp/src/arrow/engine/substrait/extension_set.cc @@ -208,11 +208,15 @@ ExtensionIdRegistry* default_extension_id_registry() { util::string_view name; }; + // The type (variation) mappings listed below need to be kept in sync + // with the YAML at substrait/format/extension_types.yaml manually; + // see ARROW-15535. for (TypeName e : { TypeName{uint8(), "u8"}, TypeName{uint16(), "u16"}, TypeName{uint32(), "u32"}, TypeName{uint64(), "u64"}, + TypeName{float16(), "fp16"}, }) { DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type), /*is_variation=*/true)); @@ -220,11 +224,18 @@ ExtensionIdRegistry* default_extension_id_registry() { for (TypeName e : { TypeName{null(), "null"}, + TypeName{month_interval(), "interval_month"}, + TypeName{day_time_interval(), "interval_day_milli"}, + TypeName{month_day_nano_interval(), "interval_month_day_nano"}, }) { DCHECK_OK(RegisterType({kArrowExtTypesUri, e.name}, std::move(e.type), /*is_variation=*/false)); } + // TODO: this is just a placeholder right now. We'll need a YAML file for + // all functions (and prototypes) that Arrow provides that are relevant + // for Substrait, and include mappings for all of them here. See + // ARROW-15535. for (util::string_view name : { "add", }) { diff --git a/format/substrait/extension_types.yaml b/format/substrait/extension_types.yaml index ae772439322..c905c8b04be 100644 --- a/format/substrait/extension_types.yaml +++ b/format/substrait/extension_types.yaml @@ -21,61 +21,31 @@ # - null # - unsigned integers # - half-precision floating point numbers -# - 32 bit times and dates +# - 32-bit times and 64-bit dates # - timestamps with units other than microseconds # - timestamps with timezones other than UTC -# - 256 bit decimals +# - 256-bit decimals # - sparse and dense unions # - dictionary encoded types # - durations # - string and binary with 64 bit offsets -# - list with 64 bit offsets +# - list with 64-bit offsets # - interval # - interval # - interval # - arrow::ExtensionTypes - -# FIXME these extension types are not parameterizable, which means among -# other things that we can't declare dictionary type here at all since +# +# Note that not all of these are currently implemented. In particular, these +# extension types are currently not parameterizable in Substrait, which means +# among other things that we can't declare dictionary type here at all since # we'd have to declare a different dictionary type for all encoded types -# (but that is an infinite space). Similarly, do we need to declare a -# timestamp variation for all possible timezone strings? +# (but that is an infinite space). Similarly, we would have to declare a +# timestamp variation for all possible timezone strings. # # Ultimately these declarations are a promise which needs to be backed by -# equivalent serde in c++. For example, consider u8: when serializing to -# substrait, we need to wrap instances of arrow::uint8 into the type -# variation listed below. It would be ideal if we could SinglePointOfTruth -# this correspondence; either generating c++ from the YAML or YAML from the -# c++. -# -# At present (AFAICT) it's not valid to make this user extensible because -# even if a user adds their custom scalar function to the registry *and* -# defines the mapping from that scalar function to a substrait::ExtensionFunction -# the corresponding YAML doesn't exist at any URI and so it can't be used in -# substrait. Perhaps we could still help that case by providing a tool to -# generate YAML from functions; that'd simplify the lives of people trying to -# write arrow::compute::Functions to "define the function and if you want to -# reference it from substrait generate this YAML and put it at some URI". -# -# In any case for the foreseeable future generation would be far too brittle; -# URIs will not be accessed by anything but humans and the YAML is effectively -# structured documentation. Thus extenders should pass the URI in the same way -# they pass a description string; it's opaque to anything in arrow. -# -# We'll need a global mapping which contains: -# arrow::uint8 <-> { -# uri: "https://github.com/apache/arrow/blob//format/substrait/extension_types.yaml", -# name: "u8" -# } -# -# And additionally convenient builders for subsets of that mapping during serde: -# arrow::uint8 <-> reference to anchor -# -# Worth noting: it's valid to have multiple ExtensionFunctions with the same name, -# as long as all impls' mangled ("compound") names are unique. -# Also worth noting: Options may only be enumerations. This will get strange with -# functions like is_in, where we'll have to require that one argument is a literal -# list or something. +# equivalent serde in c++. This is handled by default_extension_id_registry(), +# defined in cpp/src/arrow/engine/substrait/extension_set.cc. These files +# currently need to be kept in sync manually; see ARROW-15535. type_variations: - parent: i8 From 736c7a6abd77a810a50dbf831462e0f44d934f6e Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 3 Feb 2022 14:49:57 +0100 Subject: [PATCH 096/113] Fix make_shared where T = universal reference --- cpp/src/arrow/datum.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/cpp/src/arrow/datum.h b/cpp/src/arrow/datum.h index 48388386b9b..bce53decd4a 100644 --- a/cpp/src/arrow/datum.h +++ b/cpp/src/arrow/datum.h @@ -154,11 +154,12 @@ struct ARROW_EXPORT Datum { std::move(value))) {} // Cast from subtypes of Array or Scalar to Datum - template ::value, + template ::type, + bool IsArray = std::is_base_of::value, bool IsScalar = std::is_base_of::value, typename = enable_if_t> Datum(T&& value) // NOLINT implicit conversion - : Datum(std::make_shared(std::forward(value))) {} + : Datum(std::make_shared(std::forward(value))) {} // Convenience constructors explicit Datum(bool value); From 15fdc58c9d0bfb669bf54518b807fea7cdc5e1e8 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 3 Feb 2022 14:55:36 +0100 Subject: [PATCH 097/113] Clarify comment --- cpp/src/arrow/engine/substrait/extension_set.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/extension_set.h b/cpp/src/arrow/engine/substrait/extension_set.h index e9ea80a0043..13cdce33604 100644 --- a/cpp/src/arrow/engine/substrait/extension_set.h +++ b/cpp/src/arrow/engine/substrait/extension_set.h @@ -30,8 +30,9 @@ namespace arrow { namespace engine { /// A mapping from arrow types and functions to the (uri, name) which identifies -/// the corresponding substrait extension. Substrait types and variations must be -/// registered with their corresponding arrow::DataType before they can be used! +/// the corresponding substrait extension. Substrait extension types and +/// variations must be registered with their corresponding arrow::DataType before +/// they can be used! class ARROW_ENGINE_EXPORT ExtensionIdRegistry { public: /// All uris registered in this ExtensionIdRegistry From 22ad42f483c84ad89758fb121a9422660f92e91a Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 3 Feb 2022 16:10:30 +0100 Subject: [PATCH 098/113] Remove unnecessary imports in extension_types.cc --- cpp/src/arrow/engine/substrait/extension_types.cc | 4 ---- 1 file changed, 4 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/extension_types.cc b/cpp/src/arrow/engine/substrait/extension_types.cc index 32de8980e3e..b8fd191b3fd 100644 --- a/cpp/src/arrow/engine/substrait/extension_types.cc +++ b/cpp/src/arrow/engine/substrait/extension_types.cc @@ -17,11 +17,7 @@ #include "arrow/engine/substrait/extension_types.h" -#include -#include - #include "arrow/engine/simple_extension_type_internal.h" -#include "arrow/util/hash_util.h" #include "arrow/util/hashing.h" #include "arrow/util/string_view.h" From bae182260b6357ab36df4fcb1abd365f835a765d Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Thu, 3 Feb 2022 16:38:31 +0100 Subject: [PATCH 099/113] Document plan_internal.h --- .../arrow/engine/substrait/plan_internal.h | 22 ++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/plan_internal.h b/cpp/src/arrow/engine/substrait/plan_internal.h index cdec386b1ea..0ab06ece1ce 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.h +++ b/cpp/src/arrow/engine/substrait/plan_internal.h @@ -28,12 +28,28 @@ namespace arrow { namespace engine { +/// \brief Replaces the extension information of a Substrait Plan message with the given +/// extension set, such that the anchors defined therein can be used in the rest of the +/// plan. +/// +/// \param[in] ext_set the extension set to copy the extension information from +/// \param[in,out] plan the Substrait plan message that is to be updated +/// \return success or failure ARROW_ENGINE_EXPORT -Status AddExtensionSetToPlan(const ExtensionSet&, substrait::Plan*); - +Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan); + +/// \brief Interprets the extension information of a Substrait Plan message into an +/// ExtensionSet. +/// +/// Note that the extension registry is not currently mutated, but may be in the future. +/// +/// \param[in] plan the plan message to take the information from +/// \param[in,out] registry registry defining which Arrow types and compute functions +/// correspond to Substrait's URI/name pairs ARROW_ENGINE_EXPORT Result GetExtensionSetFromPlan( - const substrait::Plan&, ExtensionIdRegistry* = default_extension_id_registry()); + const substrait::Plan& plan, + ExtensionIdRegistry* registry = default_extension_id_registry()); } // namespace engine } // namespace arrow From 6240ca2c355e50c3c205083b9b0b00c953fd2dc4 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Fri, 4 Feb 2022 11:16:03 +0100 Subject: [PATCH 100/113] Disable ARROW_ENGINE in CI job where ARROW_PARQUET doesn't work (which is a dependency) --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index 11985571d30..71cfe17844c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -99,6 +99,7 @@ jobs: -e ARROW_GCS=OFF -e ARROW_MIMALLOC=OFF -e ARROW_ORC=OFF + -e ARROW_ENGINE=OFF -e ARROW_PARQUET=OFF -e ARROW_S3=OFF -e CMAKE_UNITY_BUILD=ON From b8ff996a0c006f718b52e65135dab51cbba7ee92 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Mon, 7 Feb 2022 17:36:50 +0100 Subject: [PATCH 101/113] Improve docstring --- cpp/src/arrow/engine/substrait/serde.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/serde.h b/cpp/src/arrow/engine/substrait/serde.h index 14c56926474..9e63a1befb5 100644 --- a/cpp/src/arrow/engine/substrait/serde.h +++ b/cpp/src/arrow/engine/substrait/serde.h @@ -133,8 +133,8 @@ namespace internal { /// \brief Checks whether two protobuf serializations of a particular Substrait message /// type are equivalent /// -/// Note that a binary comparison of the two buffers is pessimistic, among other reasons -/// because the fields of a message can be specified in any order in the serialization. +/// Note that a binary comparison of the two buffers is insufficient. One reason for this +/// is that the fields of a message can be specified in any order in the serialization. /// /// \param[in] message_name the name of the Substrait message type to check /// \param[in] l_buf buffer containing the first protobuf serialization to compare From f4b351fd0586f83abb6b332496b07eef2aace5d9 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Mon, 7 Feb 2022 17:44:24 +0100 Subject: [PATCH 102/113] Remove usage of scan_options->projection --- cpp/src/arrow/engine/substrait/relation_internal.cc | 13 ++----------- cpp/src/arrow/engine/substrait/serde_test.cc | 8 -------- 2 files changed, 2 insertions(+), 19 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/relation_internal.cc b/cpp/src/arrow/engine/substrait/relation_internal.cc index 1cd0aacaf43..ae2244c87f5 100644 --- a/cpp/src/arrow/engine/substrait/relation_internal.cc +++ b/cpp/src/arrow/engine/substrait/relation_internal.cc @@ -70,20 +70,11 @@ Result FromProto(const substrait::Rel& rel, } if (read.has_projection()) { + // NOTE: scan_options->projection is not used by the scanner and thus can't be + // used for this return Status::NotImplemented("substrait::ReadRel::projection"); } - { - // just project all fields - std::vector expressions{base_schema->fields().size()}; - for (int i = 0; i < base_schema->num_fields(); ++i) { - expressions[i] = compute::field_ref(i); - } - scan_options->projection = - compute::call("make_struct", std::move(expressions), - compute::MakeStructOptions{base_schema->field_names()}); - } - if (!read.has_local_files()) { return Status::NotImplemented( "substrait::ReadRel with read_type other than LocalFiles"); diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 2d3902d3b59..be68181fc88 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -659,14 +659,6 @@ TEST(Substrait, ReadRel) { // filter on the boolean field (#1) EXPECT_EQ(scan_node_options.scan_options->filter, compute::field_ref(1)); - // project all fields - EXPECT_EQ(scan_node_options.scan_options->projection, - compute::call("make_struct", - { - compute::field_ref(0), - compute::field_ref(1), - }, - compute::MakeStructOptions{{"i", "b"}})); // dataset is a FileSystemDataset in parquet format with the specified schema ASSERT_EQ(scan_node_options.dataset->type_name(), "filesystem"); From 709ab65255fc8fbe481e8e1e59621507405940ac Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 8 Feb 2022 16:54:59 +0100 Subject: [PATCH 103/113] Remove unused test helper function --- cpp/src/arrow/engine/substrait/serde_test.cc | 6 ------ 1 file changed, 6 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index be68181fc88..9c7e737c201 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -86,12 +86,6 @@ std::shared_ptr StripFieldNames(std::shared_ptr type) { return type; } -// map to an index-only field reference -inline FieldRef BoringRef(FieldRef ref) { - auto path = *ref.FindOne(*kBoringSchema); - return {std::move(path)}; -} - inline compute::Expression UseBoringRefs(const compute::Expression& expr) { if (expr.literal()) return expr; From c8e93eaee78fb5662880120501e600ab9c6d5b32 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Tue, 8 Feb 2022 20:20:36 +0100 Subject: [PATCH 104/113] Add test for round-tripping Substrait Map, and fix implementation --- cpp/src/arrow/engine/substrait/serde_test.cc | 6 ++++++ cpp/src/arrow/engine/substrait/type_internal.cc | 4 ++-- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 9c7e737c201..0381a363323 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -172,6 +172,12 @@ TEST(Substrait, SupportedTypes) { field("", int64()), field("", list(utf8())), })); + + ExpectEq(R"({"map": { + "key": {"string":{"nullability": "NULLABILITY_REQUIRED"}}, + "value": {"string":{}} + }})", + map(utf8(), field("", utf8()), false)); } TEST(Substrait, SupportedExtensionTypes) { diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 9f252ea3dc8..346dd2e124b 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -339,8 +339,8 @@ struct DataTypeToProtoImpl { ARROW_ASSIGN_OR_RAISE(auto key, ToProto(*t.key_type(), /*nullable=*/false, ext_set_)); map->set_allocated_key(key.release()); - ARROW_ASSIGN_OR_RAISE( - auto value, ToProto(*t.value_type(), t.value_field()->nullable(), ext_set_)); + ARROW_ASSIGN_OR_RAISE(auto value, + ToProto(*t.item_type(), t.item_field()->nullable(), ext_set_)); map->set_allocated_value(value.release()); return Status::OK(); From fc9d1a9d219c680d72cd86a74188aef41e6fcb21 Mon Sep 17 00:00:00 2001 From: Weston Pace Date: Tue, 8 Feb 2022 14:51:39 -1000 Subject: [PATCH 105/113] Added doc strings for SimpleExtensionType --- .../arrow/engine/simple_extension_type_internal.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/cpp/src/arrow/engine/simple_extension_type_internal.h b/cpp/src/arrow/engine/simple_extension_type_internal.h index d0644b3aa8b..b177425a9a9 100644 --- a/cpp/src/arrow/engine/simple_extension_type_internal.h +++ b/cpp/src/arrow/engine/simple_extension_type_internal.h @@ -31,6 +31,16 @@ namespace arrow { namespace engine { +/// \brief A helper class for creating simple extension types +/// +/// Extension types can be parameterized by flat structs +/// +/// Each item in the struct will be serialized and deserialized using +/// the STL insertion and extraction operators (i.e. << and >>). +/// +/// Note: The serialization is a very barebones JSON-like format and +/// probably shouldn't be hand-edited + template GetStorage(const Params&)> @@ -45,6 +55,9 @@ class SimpleExtensionType : public ExtensionType { std::move(params)); } + /// \brief Returns the parameters object for the type + /// + /// If the type is not an instance of this extension type then nullptr will be returned static const Params* GetIf(const DataType& type) { if (type.id() != Type::EXTENSION) return nullptr; @@ -58,6 +71,7 @@ class SimpleExtensionType : public ExtensionType { std::string ToString() const override { return "extension<" + this->Serialize() + ">"; } + /// \brief A comparator which returns true iff all parameter properties are equal struct ExtensionEqualsImpl { ExtensionEqualsImpl(const Params& l, const Params& r) : left_(l), right_(r) { kProperties->ForEach(*this); @@ -72,6 +86,7 @@ class SimpleExtensionType : public ExtensionType { const Params& right_; bool equal_ = true; }; + bool ExtensionEquals(const ExtensionType& other) const override { if (kExtensionName != other.extension_name()) return false; const auto& other_params = static_cast(other).params_; From 8bd00a26cff8c2dcc7736fc771e7c739f9990755 Mon Sep 17 00:00:00 2001 From: Weston Pace Date: Tue, 8 Feb 2022 17:17:05 -1000 Subject: [PATCH 106/113] Made a simplification pass on the extension set. I added some comments explaining the behavior and hid more of the underlying implementation which will help future-proof us in case we move to a map-based version in the future. Fixed a bug in execution plan creation where we were referencing the Substrait function name instead of the Arrow function name. --- .../engine/substrait/expression_internal.cc | 5 +- .../arrow/engine/substrait/extension_set.cc | 50 +++--- .../arrow/engine/substrait/extension_set.h | 146 ++++++++++++++---- .../arrow/engine/substrait/plan_internal.cc | 29 ++-- cpp/src/arrow/engine/substrait/serde_test.cc | 50 +++--- .../arrow/engine/substrait/type_internal.cc | 8 +- 6 files changed, 193 insertions(+), 95 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/expression_internal.cc b/cpp/src/arrow/engine/substrait/expression_internal.cc index 0ac2f2946c4..686ef5d5572 100644 --- a/cpp/src/arrow/engine/substrait/expression_internal.cc +++ b/cpp/src/arrow/engine/substrait/expression_internal.cc @@ -157,14 +157,15 @@ Result FromProto(const substrait::Expression& expr, case substrait::Expression::kScalarFunction: { const auto& scalar_fn = expr.scalar_function(); - auto id = ext_set.function_ids()[scalar_fn.function_reference()]; + ARROW_ASSIGN_OR_RAISE(auto decoded_function, + ext_set.DecodeFunction(scalar_fn.function_reference())); std::vector arguments(scalar_fn.args_size()); for (int i = 0; i < scalar_fn.args_size(); ++i) { ARROW_ASSIGN_OR_RAISE(arguments[i], FromProto(scalar_fn.args(i), ext_set)); } - return compute::call(id.name.to_string(), std::move(arguments)); + return compute::call(decoded_function.name.to_string(), std::move(arguments)); } default: diff --git a/cpp/src/arrow/engine/substrait/extension_set.cc b/cpp/src/arrow/engine/substrait/extension_set.cc index 9d582bbd28e..fe43ab28799 100644 --- a/cpp/src/arrow/engine/substrait/extension_set.cc +++ b/cpp/src/arrow/engine/substrait/extension_set.cc @@ -55,6 +55,9 @@ struct IdHashEq { } // namespace +// A builder used when creating a Substrait plan from an Arrow execution plan. In +// that situation we do not have a set of anchor values already defined so we keep +// a map of what Ids we have seen. struct ExtensionSet::Impl { void AddUri(util::string_view uri, ExtensionSet* self) { if (uris_.find(uri) != uris_.end()) return; @@ -72,18 +75,16 @@ struct ExtensionSet::Impl { " was referenced by an extension but was not declared in the ExtensionSet."); } - uint32_t EncodeType(Id id, const std::shared_ptr& type, bool is_variation, - ExtensionSet* self) { + uint32_t EncodeType(ExtensionIdRegistry::TypeRecord type_record, ExtensionSet* self) { // note: at this point we're guaranteed to have an Id which points to memory owned by // the set's registry. - AddUri(id.uri, self); - auto it_success = types_.emplace(id, static_cast(types_.size())); + AddUri(type_record.id.uri, self); + auto it_success = + types_.emplace(type_record.id, static_cast(types_.size())); if (it_success.second) { - DCHECK_EQ(self->type_ids_.size(), self->types_.size()); - self->type_ids_.push_back(id); - self->types_.push_back(type); - self->type_is_variation_.push_back(is_variation); + self->types_.push_back( + {type_record.id, type_record.type, type_record.is_variation}); } return it_success.first->second; @@ -96,9 +97,7 @@ struct ExtensionSet::Impl { auto it_success = functions_.emplace(id, static_cast(functions_.size())); if (it_success.second) { - DCHECK_EQ(self->function_ids_.size(), self->function_names_.size()); - self->function_ids_.push_back(id); - self->function_names_.push_back(function_name); + self->functions_.push_back({id, function_name}); } return it_success.first->second; @@ -148,44 +147,55 @@ Result ExtensionSet::Make(std::vector uris, RETURN_NOT_OK(set.impl_->CheckHasUri(type_ids[i].uri)); if (auto rec = registry->GetType(type_ids[i], type_is_variation[i])) { - set.types_[i] = rec->type; - type_ids[i] = rec->id; // use Id which references memory owned by the registry + set.types_[i] = {rec->id, rec->type, rec->is_variation}; continue; } return Status::Invalid("Type", (type_is_variation[i] ? " variation" : ""), " ", type_ids[i].uri, "#", type_ids[i].name, " not found"); } - set.function_names_.resize(function_ids.size()); + set.functions_.resize(function_ids.size()); for (size_t i = 0; i < function_ids.size(); ++i) { if (function_ids[i].empty()) continue; RETURN_NOT_OK(set.impl_->CheckHasUri(function_ids[i].uri)); if (auto rec = registry->GetFunction(function_ids[i])) { - set.function_names_[i] = rec->function_name; - function_ids[i] = rec->id; // use Id which references memory owned by the registry + set.functions_[i] = {rec->id, rec->function_name}; continue; } return Status::Invalid("Function ", function_ids[i].uri, "#", type_ids[i].name, " not found"); } - set.function_ids_ = std::move(function_ids); - set.type_ids_ = std::move(type_ids); - set.type_is_variation_ = std::move(type_is_variation); set.uris_ = std::move(uris); return std::move(set); } +Result ExtensionSet::DecodeType(uint32_t anchor) const { + if (anchor >= types_.size() || types_[anchor].id.empty()) { + return Status::Invalid("User defined type reference ", anchor, + " did not have a corresponding anchor in the extension set"); + } + return types_[anchor]; +} + Result ExtensionSet::EncodeType(const DataType& type) { if (auto rec = registry_->GetType(type)) { - return impl_->EncodeType(rec->id, rec->type, rec->is_variation, this); + return impl_->EncodeType(*rec, this); } return Status::KeyError("type ", type.ToString(), " not found in the registry"); } +Result ExtensionSet::DecodeFunction(uint32_t anchor) const { + if (anchor >= functions_.size() || functions_[anchor].id.empty()) { + return Status::Invalid("User defined function reference ", anchor, + " did not have a corresponding anchor in the extension set"); + } + return functions_[anchor]; +} + Result ExtensionSet::EncodeFunction(util::string_view function_name) { if (auto rec = registry_->GetFunction(function_name)) { return impl_->EncodeFunction(rec->id, rec->function_name, this); diff --git a/cpp/src/arrow/engine/substrait/extension_set.h b/cpp/src/arrow/engine/substrait/extension_set.h index 13cdce33604..b3867552d78 100644 --- a/cpp/src/arrow/engine/substrait/extension_set.h +++ b/cpp/src/arrow/engine/substrait/extension_set.h @@ -29,10 +29,21 @@ namespace arrow { namespace engine { -/// A mapping from arrow types and functions to the (uri, name) which identifies -/// the corresponding substrait extension. Substrait extension types and -/// variations must be registered with their corresponding arrow::DataType before -/// they can be used! +/// Substrait identifies functions and custom data types using a (uri, name) pair. +/// +/// This reigstry is a bidirectional mapping between Substrait IDs and their corresponding +/// Arrow counterparts (arrow::DataType and function names in a function registry) +/// +/// Substrait extension types and variations must be registered with their corresponding +/// arrow::DataType before they can be used! +/// +/// Conceptually this can be thought of as two pairs of `unordered_map`s. One pair to +/// go back and forth between Substrait ID and arrow::DataType and another pair to go +/// back and forth between Substrait ID and Arrow function names. +/// +/// Unlike an ExtensionSet this registry is not created automatically when consuming +/// Substrait plans and must be configured ahead of time (although there is a default +/// instance). class ARROW_ENGINE_EXPORT ExtensionIdRegistry { public: /// All uris registered in this ExtensionIdRegistry @@ -44,6 +55,7 @@ class ARROW_ENGINE_EXPORT ExtensionIdRegistry { bool empty() const { return uri.empty() && name.empty(); } }; + /// \brief A mapping between a Substrait ID and an arrow::DataType struct TypeRecord { Id id; const std::shared_ptr& type; @@ -53,13 +65,18 @@ class ARROW_ENGINE_EXPORT ExtensionIdRegistry { virtual util::optional GetType(Id, bool is_variation) const = 0; virtual Status RegisterType(Id, std::shared_ptr, bool is_variation) = 0; - // FIXME some functions will not be simple enough to convert without access to their - // arguments/options. For example is_in embeds the set in options rather than using an - // argument: - // is_in(x, SetLookupOptions(set)) <-> (k...Uri, "is_in")(x, set) - // - // ... for another example, depending on the value of the first argument to - // substrait::add it either corresponds to arrow::add or arrow::add_checked + /// \brief A mapping between a Substrait ID and an Arrow function + /// + /// Note: At the moment we identify functions solely by the name + /// of the function in the function registry. + /// + /// TODO(ARROW-15582) some functions will not be simple enough to convert without access + /// to their arguments/options. For example is_in embeds the set in options rather than + /// using an argument: + /// is_in(x, SetLookupOptions(set)) <-> (k...Uri, "is_in")(x, set) + /// + /// ... for another example, depending on the value of the first argument to + /// substrait::add it either corresponds to arrow::add or arrow::add_checked struct FunctionRecord { Id id; const std::string& function_name; @@ -74,9 +91,36 @@ constexpr util::string_view kArrowExtTypesUri = "https://github.com/apache/arrow/blob/master/format/substrait/" "extension_types.yaml"; +/// A default registry with all supported functions and data types registered +/// +/// Note: Function support is currently very minimal, see ARROW-15538 ARROW_ENGINE_EXPORT ExtensionIdRegistry* default_extension_id_registry(); -/// A subset of an ExtensionIdRegistry with extensions identifiable by an integer. +/// \brief A set of extensions used within a plan +/// +/// Each time an extension is used within a Substrait plan the extension +/// must be included in an extension set that is defined at the root of the +/// plan. +/// +/// The plan refers to a specific extension using an "anchor" which is an +/// arbitrary integer invented by the producer that has no meaning beyond a +/// plan but which should be consistent within a plan. +/// +/// To support serialization and deserialization this type serves as a +/// bidirectional map between Substrait ID and "anchor"s. +/// +/// When deserializing a Substrait plan the extension set should be extracted +/// after the plan has been converted from Protobuf and before the plan +/// is converted to an execution plan. +/// +/// The extension set can be kept and reused during serialization if a perfect +/// round trip is required. If serialization is not needed or round tripping +/// is not required then the extension set can be safely discarded after the +/// plan has been converted into an execution plan. +/// +/// When converting an execution plan into a Substrait plan an extension set +/// can be automatically generated or a previously generated extension set can +/// be used. /// /// ExtensionSet does not own strings; it only refers to strings in an /// ExtensionIdRegistry. @@ -84,6 +128,17 @@ class ARROW_ENGINE_EXPORT ExtensionSet { public: using Id = ExtensionIdRegistry::Id; + struct FunctionRecord { + Id id; + util::string_view name; + }; + + struct TypeRecord { + Id id; + std::shared_ptr type; + bool is_variation; + }; + /// Construct an empty ExtensionSet to be populated during serialization. explicit ExtensionSet(ExtensionIdRegistry* = default_extension_id_registry()); ARROW_DEFAULT_MOVE_AND_ASSIGN(ExtensionSet); @@ -96,38 +151,77 @@ class ARROW_ENGINE_EXPORT ExtensionSet { /// /// Views will be replaced with equivalent views pointing to memory owned by the /// registry. + /// + /// Note: This is an advanced operation. The order of the ids, types, and functions + /// must match the anchor numbers chosen for a plan. + /// + /// An extension set should instead be created using + /// arrow::engine::GetExtensionSetFromPlan static Result Make( std::vector uris, std::vector type_ids, std::vector type_is_variation, std::vector function_ids, ExtensionIdRegistry* = default_extension_id_registry()); // index in these vectors == value of _anchor/_reference fields - /// FIXME this assumes that _anchor/_references won't be huge, which is not guaranteed. - /// Could it be? + /// TODO(ARROW-15583) this assumes that _anchor/_references won't be huge, which is not + /// guaranteed. Could it be? const std::vector& uris() const { return uris_; } - const DataTypeVector& types() const { return types_; } - const std::vector& type_ids() const { return type_ids_; } - bool type_is_variation(uint32_t i) const { return type_is_variation_[i]; } + /// \brief Returns a data type given an anchor + /// + /// This is used when converting a Substrait plan to an Arrow execution plan. + /// + /// If the anchor does not exist in this extension set an error will be returned. + Result DecodeType(uint32_t anchor) const; + + /// \brief Returns the number of custom types in this extension set + std::size_t num_types() const { return types_.size(); } - /// Encode a type, looking it up first in this set's ExtensionIdRegistry. - /// If no type is found, an error will be raised. + /// \brief Lookup the anchor for a given type + /// + /// This operation is used when converting an Arrow execution plan to a Substrait plan. + /// If the type has been previously encoded then the same anchor value will returned. + /// + /// If the type has not been previously encoded then a new anchor value will be created. + /// + /// If the type does not exist in the extension id registry then an error will be + /// returned. + /// + /// \return An anchor that can be used to refer to the type within a plan Result EncodeType(const DataType& type); - const std::vector& function_ids() const { return function_ids_; } - const std::vector& function_names() const { return function_names_; } + /// \brief Returns a function given an anchor + /// + /// This is used when converting a Substrait plan to an Arrow execution plan. + /// + /// If the anchor does not exist in this extension set an error will be returned. + Result DecodeFunction(uint32_t anchor) const; + /// \brief Lookup the anchor for a given function + /// + /// This operation is used when converting an Arrow execution plan to a Substrait plan. + /// If the function has been previously encoded then the same anchor value will be + /// returned. + /// + /// If the function has not been previously encoded then a new anchor value will be + /// created. + /// + /// If the function name is not in the extension id registry then an error will be + /// returned. + /// + /// \return An anchor that can be used to refer to the function within a plan Result EncodeFunction(util::string_view function_name); + /// \brief Returns the number of custom functions in this extension set + std::size_t num_functions() const { return functions_.size(); } + private: ExtensionIdRegistry* registry_; + /// The subset of extension registry URIs referenced by this extension set std::vector uris_; - DataTypeVector types_; - std::vector type_ids_; - std::vector type_is_variation_; + std::vector types_; - std::vector function_ids_; - std::vector function_names_; + std::vector functions_; // pimpl pattern to hide lookup details struct Impl; diff --git a/cpp/src/arrow/engine/substrait/plan_internal.cc b/cpp/src/arrow/engine/substrait/plan_internal.cc index 90fda742713..8ffbcc005da 100644 --- a/cpp/src/arrow/engine/substrait/plan_internal.cc +++ b/cpp/src/arrow/engine/substrait/plan_internal.cc @@ -53,42 +53,41 @@ Status AddExtensionSetToPlan(const ExtensionSet& ext_set, substrait::Plan* plan) } auto extensions = plan->mutable_extensions(); - extensions->Reserve( - static_cast(ext_set.type_ids().size() + ext_set.function_ids().size())); + extensions->Reserve(static_cast(ext_set.num_types() + ext_set.num_functions())); using ExtDecl = substrait::extensions::SimpleExtensionDeclaration; - for (uint32_t anchor = 0; anchor < ext_set.type_ids().size(); ++anchor) { - auto id = ext_set.type_ids()[anchor]; - if (id.empty()) continue; + for (uint32_t anchor = 0; anchor < ext_set.num_types(); ++anchor) { + ARROW_ASSIGN_OR_RAISE(auto type_record, ext_set.DecodeType(anchor)); + if (type_record.id.empty()) continue; auto ext_decl = internal::make_unique(); - if (ext_set.type_is_variation(anchor)) { + if (type_record.is_variation) { auto type_var = internal::make_unique(); - type_var->set_extension_uri_reference(map[id.uri]); + type_var->set_extension_uri_reference(map[type_record.id.uri]); type_var->set_type_variation_anchor(anchor); - type_var->set_name(id.name.to_string()); + type_var->set_name(type_record.id.name.to_string()); ext_decl->set_allocated_extension_type_variation(type_var.release()); } else { auto type = internal::make_unique(); - type->set_extension_uri_reference(map[id.uri]); + type->set_extension_uri_reference(map[type_record.id.uri]); type->set_type_anchor(anchor); - type->set_name(id.name.to_string()); + type->set_name(type_record.id.name.to_string()); ext_decl->set_allocated_extension_type(type.release()); } extensions->AddAllocated(ext_decl.release()); } - for (uint32_t anchor = 0; anchor < ext_set.function_ids().size(); ++anchor) { - auto id = ext_set.function_ids()[anchor]; - if (id.empty()) continue; + for (uint32_t anchor = 0; anchor < ext_set.num_functions(); ++anchor) { + ARROW_ASSIGN_OR_RAISE(auto function_record, ext_set.DecodeFunction(anchor)); + if (function_record.id.empty()) continue; auto fn = internal::make_unique(); - fn->set_extension_uri_reference(map[id.uri]); + fn->set_extension_uri_reference(map[function_record.id.uri]); fn->set_function_anchor(anchor); - fn->set_name(id.name.to_string()); + fn->set_name(function_record.id.name.to_string()); auto ext_decl = internal::make_unique(); ext_decl->set_allocated_extension_function(fn.release()); diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 0381a363323..01fb9b31031 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -124,7 +124,7 @@ TEST(Substrait, SupportedTypes) { EXPECT_EQ(*type, *expected_type); ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &empty)); - EXPECT_EQ(empty.types().size(), 0); + EXPECT_EQ(empty.num_types(), 0); // FIXME chokes on NULLABILITY_UNSPECIFIED // EXPECT_THAT(internal::CheckMessagesEquivalent("Type", *buf, *serialized), Ok()); @@ -190,7 +190,7 @@ TEST(Substrait, SupportedExtensionTypes) { uint32(), uint64(), }) { - auto anchor = ext_set.types().size(); + auto anchor = ext_set.num_types(); EXPECT_THAT(ext_set.EncodeType(*expected_type), ResultWith(Eq(anchor))); auto buf = SubstraitFromJSON( @@ -199,9 +199,9 @@ TEST(Substrait, SupportedExtensionTypes) { ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf, ext_set)); EXPECT_EQ(*type, *expected_type); - auto size = ext_set.types().size(); + auto size = ext_set.num_types(); ASSERT_OK_AND_ASSIGN(auto serialized, SerializeType(*type, &ext_set)); - EXPECT_EQ(ext_set.types().size(), size) << "was already added to the set above"; + EXPECT_EQ(ext_set.num_types(), size) << "was already added to the set above"; ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeType(*serialized, ext_set)); EXPECT_EQ(*roundtripped, *expected_type); @@ -318,8 +318,7 @@ TEST(Substrait, SupportedLiterals) { ASSERT_THAT(*expr.literal(), DataEq(expected_value)); ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); - EXPECT_EQ(ext_set.function_ids().size(), - 0); // shouldn't need extensions for core literals + EXPECT_EQ(ext_set.num_functions(), 0); // shouldn't need extensions for core literals ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set)); @@ -458,7 +457,7 @@ TEST(Substrait, FieldRefRoundTrip) { ExtensionSet ext_set; ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); - EXPECT_EQ(ext_set.function_ids().size(), + EXPECT_EQ(ext_set.num_functions(), 0); // shouldn't need extensions for core field references ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set)); ASSERT_TRUE(roundtripped.field_ref()); @@ -590,7 +589,7 @@ TEST(Substrait, CallSpecialCaseRoundTrip) { // These are special cased as core expressions in substrait; shouldn't require any // extensions. - EXPECT_EQ(ext_set.function_ids().size(), 0); + EXPECT_EQ(ext_set.num_functions(), 0); ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set)); ASSERT_OK_AND_ASSIGN(roundtripped, roundtripped.Bind(*kBoringSchema)); @@ -609,7 +608,7 @@ TEST(Substrait, CallExtensionFunction) { ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); // These require an extension, so we should have a single-element ext_set. - EXPECT_EQ(ext_set.function_ids().size(), 1); + EXPECT_EQ(ext_set.num_functions(), 1); ASSERT_OK_AND_ASSIGN(auto roundtripped, DeserializeExpression(*serialized, ext_set)); ASSERT_OK_AND_ASSIGN(roundtripped, roundtripped.Bind(*kBoringSchema)); @@ -716,23 +715,22 @@ TEST(Substrait, ExtensionSetFromPlan) { *buf, [] { return std::shared_ptr{nullptr}; }, &ext_set)); - EXPECT_EQ(ext_set.uris()[7], kArrowExtTypesUri); - - ASSERT_NE(ext_set.types()[42], nullptr); - EXPECT_EQ(ext_set.type_ids()[42].uri, kArrowExtTypesUri); - EXPECT_EQ(ext_set.type_ids()[42].name, "null"); - EXPECT_EQ(*ext_set.types()[42], NullType()); - EXPECT_FALSE(ext_set.type_is_variation(42)); - - ASSERT_NE(ext_set.types()[23], nullptr); - EXPECT_EQ(ext_set.type_ids()[23].uri, kArrowExtTypesUri); - EXPECT_EQ(ext_set.type_ids()[23].name, "u8"); - EXPECT_EQ(*ext_set.types()[23], UInt8Type()); - EXPECT_TRUE(ext_set.type_is_variation(23)); - - EXPECT_EQ(ext_set.function_ids()[42].uri, kArrowExtTypesUri); - EXPECT_EQ(ext_set.function_ids()[42].name, "add"); - EXPECT_EQ(ext_set.function_names()[42], "add"); + EXPECT_OK_AND_ASSIGN(auto decoded_null_type, ext_set.DecodeType(42)); + EXPECT_EQ(decoded_null_type.id.uri, kArrowExtTypesUri); + EXPECT_EQ(decoded_null_type.id.name, "null"); + EXPECT_EQ(*decoded_null_type.type, NullType()); + EXPECT_FALSE(decoded_null_type.is_variation); + + EXPECT_OK_AND_ASSIGN(auto decoded_uint8_type, ext_set.DecodeType(23)); + EXPECT_EQ(decoded_uint8_type.id.uri, kArrowExtTypesUri); + EXPECT_EQ(decoded_uint8_type.id.name, "u8"); + EXPECT_EQ(*decoded_uint8_type.type, UInt8Type()); + EXPECT_TRUE(decoded_uint8_type.is_variation); + + EXPECT_OK_AND_ASSIGN(auto decoded_add_func, ext_set.DecodeFunction(42)); + EXPECT_EQ(decoded_add_func.id.uri, kArrowExtTypesUri); + EXPECT_EQ(decoded_add_func.id.name, "add"); + EXPECT_EQ(decoded_add_func.name, "add"); } } // namespace engine diff --git a/cpp/src/arrow/engine/substrait/type_internal.cc b/cpp/src/arrow/engine/substrait/type_internal.cc index 346dd2e124b..49ca1bbfabf 100644 --- a/cpp/src/arrow/engine/substrait/type_internal.cc +++ b/cpp/src/arrow/engine/substrait/type_internal.cc @@ -208,12 +208,8 @@ Result, bool>> FromProto( case substrait::Type::kUserDefinedTypeReference: { uint32_t anchor = type.user_defined_type_reference(); - if (anchor >= ext_set.types().size() || ext_set.types()[anchor] == nullptr) { - return Status::Invalid( - "User defined type reference ", anchor, - " did not have a corresponding anchor in the extension set"); - } - return std::make_pair(ext_set.types()[anchor], true); + ARROW_ASSIGN_OR_RAISE(auto type_record, ext_set.DecodeType(anchor)); + return std::make_pair(std::move(type_record.type), true); } default: From 2156716ce62474d65211ff4143a57d1c6e365aa2 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Wed, 9 Feb 2022 12:21:30 +0100 Subject: [PATCH 107/113] Remove questionable SubstraitToJson & SubstraitFromJson test helper functions --- cpp/src/arrow/engine/substrait/serde_test.cc | 81 +++++++++----------- 1 file changed, 36 insertions(+), 45 deletions(-) diff --git a/cpp/src/arrow/engine/substrait/serde_test.cc b/cpp/src/arrow/engine/substrait/serde_test.cc index 0381a363323..dfd90c6814e 100644 --- a/cpp/src/arrow/engine/substrait/serde_test.cc +++ b/cpp/src/arrow/engine/substrait/serde_test.cc @@ -100,25 +100,12 @@ inline compute::Expression UseBoringRefs(const compute::Expression& expr) { return compute::Expression{std::move(modified_call)}; } -std::shared_ptr SubstraitFromJSON(util::string_view type_name, - util::string_view json) { - auto maybe_buf = internal::SubstraitFromJSON(type_name, json); - DCHECK_OK(maybe_buf.status()); - return maybe_buf.ValueOrDie(); -} - -std::string SubstraitToJSON(util::string_view type_name, const Buffer& buf) { - auto maybe_buf = internal::SubstraitToJSON(type_name, buf); - DCHECK_OK(maybe_buf.status()); - return maybe_buf.ValueOrDie(); -} - TEST(Substrait, SupportedTypes) { auto ExpectEq = [](util::string_view json, std::shared_ptr expected_type) { ARROW_SCOPED_TRACE(json); ExtensionSet empty; - auto buf = SubstraitFromJSON("Type", json); + ASSERT_OK_AND_ASSIGN(auto buf, internal::SubstraitFromJSON("Type", json)); ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf, empty)); EXPECT_EQ(*type, *expected_type); @@ -193,8 +180,10 @@ TEST(Substrait, SupportedExtensionTypes) { auto anchor = ext_set.types().size(); EXPECT_THAT(ext_set.EncodeType(*expected_type), ResultWith(Eq(anchor))); - auto buf = SubstraitFromJSON( - "Type", "{\"user_defined_type_reference\": " + std::to_string(anchor) + "}"); + ASSERT_OK_AND_ASSIGN( + auto buf, + internal::SubstraitFromJSON( + "Type", "{\"user_defined_type_reference\": " + std::to_string(anchor) + "}")); ASSERT_OK_AND_ASSIGN(auto type, DeserializeType(*buf, ext_set)); EXPECT_EQ(*type, *expected_type); @@ -211,7 +200,7 @@ TEST(Substrait, SupportedExtensionTypes) { TEST(Substrait, NamedStruct) { ExtensionSet ext_set; - auto buf = SubstraitFromJSON("NamedStruct", R"({ + ASSERT_OK_AND_ASSIGN(auto buf, internal::SubstraitFromJSON("NamedStruct", R"({ "struct": { "types": [ {"i64": {}}, @@ -226,7 +215,7 @@ TEST(Substrait, NamedStruct) { ] }, "names": ["a", "b", "c", "d", "e", "f"] - })"); + })")); ASSERT_OK_AND_ASSIGN(auto schema, DeserializeSchema(*buf, ext_set)); Schema expected_schema({ field("a", int64()), @@ -244,17 +233,17 @@ TEST(Substrait, NamedStruct) { EXPECT_EQ(*roundtripped, expected_schema); // too few names - buf = SubstraitFromJSON("NamedStruct", R"({ + ASSERT_OK_AND_ASSIGN(buf, internal::SubstraitFromJSON("NamedStruct", R"({ "struct": {"types": [{"i32": {}}, {"i32": {}}, {"i32": {}}]}, "names": [] - })"); + })")); EXPECT_THAT(DeserializeSchema(*buf, ext_set), Raises(StatusCode::Invalid)); // too many names - buf = SubstraitFromJSON("NamedStruct", R"({ + ASSERT_OK_AND_ASSIGN(buf, internal::SubstraitFromJSON("NamedStruct", R"({ "struct": {"types": []}, "names": ["a", "b", "c"] - })"); + })")); EXPECT_THAT(DeserializeSchema(*buf, ext_set), Raises(StatusCode::Invalid)); // no schema metadata allowed @@ -269,7 +258,8 @@ TEST(Substrait, NamedStruct) { } TEST(Substrait, NoEquivalentArrowType) { - auto buf = SubstraitFromJSON("Type", R"({"user_defined_type_reference": 99})"); + ASSERT_OK_AND_ASSIGN(auto buf, internal::SubstraitFromJSON( + "Type", R"({"user_defined_type_reference": 99})")); ExtensionSet empty; ASSERT_THAT( DeserializeType(*buf, empty), @@ -310,7 +300,9 @@ TEST(Substrait, SupportedLiterals) { auto ExpectEq = [](util::string_view json, Datum expected_value) { ARROW_SCOPED_TRACE(json); - auto buf = SubstraitFromJSON("Expression", "{\"literal\":" + json.to_string() + "}"); + ASSERT_OK_AND_ASSIGN( + auto buf, internal::SubstraitFromJSON("Expression", + "{\"literal\":" + json.to_string() + "}")); ExtensionSet ext_set; ASSERT_OK_AND_ASSIGN(auto expr, DeserializeExpression(*buf, ext_set)); @@ -408,7 +400,8 @@ TEST(Substrait, SupportedLiterals) { }) { ExtensionSet set; ASSERT_OK_AND_ASSIGN(auto buf, SerializeType(*type, &set)); - ExpectEq("{\"null\": " + SubstraitToJSON("Type", *buf) + "}", MakeNullScalar(type)); + ASSERT_OK_AND_ASSIGN(auto json, internal::SubstraitToJSON("Type", *buf)); + ExpectEq("{\"null\": " + json + "}", MakeNullScalar(type)); } } @@ -416,20 +409,18 @@ TEST(Substrait, CannotDeserializeLiteral) { ExtensionSet ext_set; // Invalid: missing List.element_type - EXPECT_THAT( - DeserializeExpression( - *SubstraitFromJSON("Expression", R"({"literal": {"list": {"values": []}}})"), - ext_set), - Raises(StatusCode::Invalid)); + ASSERT_OK_AND_ASSIGN( + auto buf, internal::SubstraitFromJSON("Expression", + R"({"literal": {"list": {"values": []}}})")); + EXPECT_THAT(DeserializeExpression(*buf, ext_set), Raises(StatusCode::Invalid)); // Invalid: required null literal - EXPECT_THAT( - DeserializeExpression( - *SubstraitFromJSON( - "Expression", - R"({"literal": {"null": {"bool": {"nullability": "NULLABILITY_REQUIRED"}}}})"), - ext_set), - Raises(StatusCode::Invalid)); + ASSERT_OK_AND_ASSIGN( + buf, + internal::SubstraitFromJSON( + "Expression", + R"({"literal": {"null": {"bool": {"nullability": "NULLABILITY_REQUIRED"}}}})")); + EXPECT_THAT(DeserializeExpression(*buf, ext_set), Raises(StatusCode::Invalid)); // no equivalent arrow scalar // FIXME no way to specify scalars of user_defined_type_reference @@ -476,7 +467,7 @@ TEST(Substrait, RecursiveFieldRef) { ASSERT_OK_AND_ASSIGN(auto expr, compute::field_ref(ref).Bind(*kBoringSchema)); ExtensionSet ext_set; ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); - auto expected = SubstraitFromJSON("Expression", R"({ + ASSERT_OK_AND_ASSIGN(auto expected, internal::SubstraitFromJSON("Expression", R"({ "selection": { "directReference": { "structField": { @@ -490,7 +481,7 @@ TEST(Substrait, RecursiveFieldRef) { }, "rootReference": {} } - })"); + })")); ASSERT_OK(internal::CheckMessagesEquivalent("Expression", *serialized, *expected)); } @@ -508,7 +499,7 @@ TEST(Substrait, FieldRefsInExpressions) { ExtensionSet ext_set; ASSERT_OK_AND_ASSIGN(auto serialized, SerializeExpression(expr, &ext_set)); - auto expected = SubstraitFromJSON("Expression", R"({ + ASSERT_OK_AND_ASSIGN(auto expected, internal::SubstraitFromJSON("Expression", R"({ "selection": { "directReference": { "structField": { @@ -527,7 +518,7 @@ TEST(Substrait, FieldRefsInExpressions) { } } } - })"); + })")); ASSERT_OK(internal::CheckMessagesEquivalent("Expression", *serialized, *expected)); } @@ -618,7 +609,7 @@ TEST(Substrait, CallExtensionFunction) { } TEST(Substrait, ReadRel) { - auto buf = SubstraitFromJSON("Rel", R"({ + ASSERT_OK_AND_ASSIGN(auto buf, internal::SubstraitFromJSON("Rel", R"({ "read": { "base_schema": { "struct": { @@ -648,7 +639,7 @@ TEST(Substrait, ReadRel) { ] } } - })"); + })")); ExtensionSet ext_set; ASSERT_OK_AND_ASSIGN(auto rel, DeserializeRelation(*buf, ext_set)); @@ -670,7 +661,7 @@ TEST(Substrait, ReadRel) { } TEST(Substrait, ExtensionSetFromPlan) { - auto buf = SubstraitFromJSON("Plan", R"({ + ASSERT_OK_AND_ASSIGN(auto buf, internal::SubstraitFromJSON("Plan", R"({ "relations": [ {"rel": { "read": { @@ -707,7 +698,7 @@ TEST(Substrait, ExtensionSetFromPlan) { "name": "add" }} ] - })"); + })")); ExtensionSet ext_set; ASSERT_OK_AND_ASSIGN( From f5483f47de8c8cb262545af6564178196fd234ac Mon Sep 17 00:00:00 2001 From: Weston Pace Date: Wed, 9 Feb 2022 16:51:39 -1000 Subject: [PATCH 108/113] Removing unneeded protobuf cmake flag --- cpp/src/arrow/engine/CMakeLists.txt | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/cpp/src/arrow/engine/CMakeLists.txt b/cpp/src/arrow/engine/CMakeLists.txt index d9e9e2d11d8..0f00a6600f4 100644 --- a/cpp/src/arrow/engine/CMakeLists.txt +++ b/cpp/src/arrow/engine/CMakeLists.txt @@ -122,8 +122,7 @@ add_arrow_lib(arrow_engine ${SUBSTRAIT_GEN_DIR}) foreach(LIB_TARGET ${ARROW_ENGINE_LIBRARIES}) - target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_ENGINE_EXPORTING - LIBPROTOBUF_EXPORTS) + target_compile_definitions(${LIB_TARGET} PRIVATE ARROW_ENGINE_EXPORTING) endforeach() set(ARROW_ENGINE_TEST_LINK_LIBS ${ARROW_ENGINE_LINK_lIBS} ${ARROW_TEST_LINK_LIBS}) From 1b8ef91df75029d6cdbf2932d3a87583fbec3dcc Mon Sep 17 00:00:00 2001 From: Weston Pace Date: Thu, 10 Feb 2022 16:51:32 -1000 Subject: [PATCH 109/113] Fix up the substrait consumption example to take in a filename instead of use hard coded filenames. If no filename is specified we return 0 which is needed because CI will call the examples and we cannot fail. Removed the filter from the example expression because it triggers ARROW-15658 and we need to resolve ARROW-15586 first anyways. Added logic in the scanner to provide a default projection when none is specified. --- .../arrow/engine_substrait_consumption.cc | 35 +++++++++---------- cpp/src/arrow/dataset/scanner.cc | 11 ++++++ 2 files changed, 28 insertions(+), 18 deletions(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index c7c390962b9..b25eec22020 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -65,9 +65,12 @@ class IgnoringConsumer : public cp::SinkNodeConsumer { size_t tag_; }; -arrow::Future> GetSubstraitFromServer() { +const std::string kFilenamePlaceholder = "FILENAME_PLACEHOLDER"; + +arrow::Future> GetSubstraitFromServer( + const std::string& filename) { // Emulate server interaction by parsing hard coded JSON - return eng::internal::SubstraitFromJSON("Plan", R"({ + std::string substrait_json = R"({ "relations": [ {"rel": { "read": { @@ -77,23 +80,10 @@ arrow::Future> GetSubstraitFromServer() { }, "names": ["i", "b"] }, - "filter": { - "selection": { - "directReference": { - "structField": { - "field": 1 - } - } - } - }, "local_files": { "items": [ { - "uri_file": "file:///tmp/dat1.parquet", - "format": "FILE_FORMAT_PARQUET" - }, - { - "uri_file": "file:///tmp/dat2.parquet", + "uri_file": "file://FILENAME_PLACEHOLDER", "format": "FILE_FORMAT_PARQUET" } ] @@ -124,13 +114,22 @@ arrow::Future> GetSubstraitFromServer() { "name": "add" }} ] - })"); + })"; + substrait_json.replace(substrait_json.find(kFilenamePlaceholder), + kFilenamePlaceholder.size(), filename); + return eng::internal::SubstraitFromJSON("Plan", substrait_json); } int main(int argc, char** argv) { + if (argc < 2) { + std::cout << "Please specify a parquet file to scan" << std::endl; + // Fake pass for CI + return EXIT_SUCCESS; + } + // Plans arrive at the consumer serialized in a Buffer, using the binary protobuf // serialization of a substrait Plan - auto maybe_serialized_plan = GetSubstraitFromServer().result(); + auto maybe_serialized_plan = GetSubstraitFromServer(argv[1]).result(); ABORT_ON_FAILURE(maybe_serialized_plan.status()); std::shared_ptr serialized_plan = std::move(maybe_serialized_plan).ValueOrDie(); diff --git a/cpp/src/arrow/dataset/scanner.cc b/cpp/src/arrow/dataset/scanner.cc index c99316f764a..7ecfb3ead46 100644 --- a/cpp/src/arrow/dataset/scanner.cc +++ b/cpp/src/arrow/dataset/scanner.cc @@ -766,6 +766,17 @@ Result MakeScanNode(compute::ExecPlan* plan, scan_options->filter.Bind(*dataset->schema())); } + // If no projection schema is specified we will use a default projection. In + // general we should not be able to get here if using the ScannerBuilder but + // it is possible to get here if scan_options is used directly. To be cleaned up + // in ARROW-12311 + if (!scan_options->projected_schema) { + ARROW_ASSIGN_OR_RAISE(auto projection_descr, + ProjectionDescr::Default(*dataset->schema())); + scan_options->projected_schema = std::move(projection_descr.schema); + scan_options->projection = projection_descr.expression; + } + if (!scan_options->projection.IsBound()) { auto fields = dataset->schema()->fields(); for (const auto& aug_field : kAugmentedFields) { From 78d0fca0c35e4068fa089ca4bade60f240e38a6d Mon Sep 17 00:00:00 2001 From: Weston Pace Date: Thu, 10 Feb 2022 20:12:25 -1000 Subject: [PATCH 110/113] Update cpp/src/arrow/engine/substrait/extension_set.h Co-authored-by: Jeroen van Straten --- cpp/src/arrow/engine/substrait/extension_set.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cpp/src/arrow/engine/substrait/extension_set.h b/cpp/src/arrow/engine/substrait/extension_set.h index b3867552d78..743832d9776 100644 --- a/cpp/src/arrow/engine/substrait/extension_set.h +++ b/cpp/src/arrow/engine/substrait/extension_set.h @@ -31,7 +31,7 @@ namespace engine { /// Substrait identifies functions and custom data types using a (uri, name) pair. /// -/// This reigstry is a bidirectional mapping between Substrait IDs and their corresponding +/// This registry is a bidirectional mapping between Substrait IDs and their corresponding /// Arrow counterparts (arrow::DataType and function names in a function registry) /// /// Substrait extension types and variations must be registered with their corresponding From 2b0131ca253484549e465a5be1f44fdde05d105e Mon Sep 17 00:00:00 2001 From: Weston Pace Date: Thu, 10 Feb 2022 20:14:08 -1000 Subject: [PATCH 111/113] Cleaned up comments per PR review --- cpp/src/arrow/engine/substrait/extension_set.h | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/cpp/src/arrow/engine/substrait/extension_set.h b/cpp/src/arrow/engine/substrait/extension_set.h index 743832d9776..2eb44822375 100644 --- a/cpp/src/arrow/engine/substrait/extension_set.h +++ b/cpp/src/arrow/engine/substrait/extension_set.h @@ -174,7 +174,11 @@ class ARROW_ENGINE_EXPORT ExtensionSet { /// If the anchor does not exist in this extension set an error will be returned. Result DecodeType(uint32_t anchor) const; - /// \brief Returns the number of custom types in this extension set + /// \brief Returns the number of custom type records in this extension set + /// + /// Note: the types are currently stored as a sparse vector, so this may return a value + /// larger than the actual number of types. This behavior may change in the future; see + /// ARROW-15583. std::size_t num_types() const { return types_.size(); } /// \brief Lookup the anchor for a given type @@ -213,6 +217,10 @@ class ARROW_ENGINE_EXPORT ExtensionSet { Result EncodeFunction(util::string_view function_name); /// \brief Returns the number of custom functions in this extension set + /// + /// Note: the functions are currently stored as a sparse vector, so this may return a + /// value larger than the actual number of functions. This behavior may change in the + /// future; see ARROW-15583. std::size_t num_functions() const { return functions_.size(); } private: From b7a2a1e0331cd4cc966e31b50c144807da6e3e22 Mon Sep 17 00:00:00 2001 From: Jeroen van Straten Date: Fri, 11 Feb 2022 19:11:32 +0100 Subject: [PATCH 112/113] Fix lint violation --- cpp/examples/arrow/engine_substrait_consumption.cc | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/cpp/examples/arrow/engine_substrait_consumption.cc b/cpp/examples/arrow/engine_substrait_consumption.cc index b25eec22020..b0109b36888 100644 --- a/cpp/examples/arrow/engine_substrait_consumption.cc +++ b/cpp/examples/arrow/engine_substrait_consumption.cc @@ -65,8 +65,6 @@ class IgnoringConsumer : public cp::SinkNodeConsumer { size_t tag_; }; -const std::string kFilenamePlaceholder = "FILENAME_PLACEHOLDER"; - arrow::Future> GetSubstraitFromServer( const std::string& filename) { // Emulate server interaction by parsing hard coded JSON @@ -115,8 +113,9 @@ arrow::Future> GetSubstraitFromServer( }} ] })"; - substrait_json.replace(substrait_json.find(kFilenamePlaceholder), - kFilenamePlaceholder.size(), filename); + std::string filename_placeholder = "FILENAME_PLACEHOLDER"; + substrait_json.replace(substrait_json.find(filename_placeholder), + filename_placeholder.size(), filename); return eng::internal::SubstraitFromJSON("Plan", substrait_json); } From 90d7ae34a03d9660299c559fde2c37c82cffd2b1 Mon Sep 17 00:00:00 2001 From: Weston Pace Date: Fri, 11 Feb 2022 09:31:29 -1000 Subject: [PATCH 113/113] If we build protobuf from source we always build it statically. We need to reset the USE_STATIC_LIBS flag so that downstream components know it was built statically even if a shared library was requested. --- cpp/cmake_modules/ThirdpartyToolchain.cmake | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/cpp/cmake_modules/ThirdpartyToolchain.cmake b/cpp/cmake_modules/ThirdpartyToolchain.cmake index a391dc88724..54cd6a7a815 100644 --- a/cpp/cmake_modules/ThirdpartyToolchain.cmake +++ b/cpp/cmake_modules/ThirdpartyToolchain.cmake @@ -1426,6 +1426,11 @@ macro(build_protobuf) set(PROTOBUF_VENDORED TRUE) set(PROTOBUF_PREFIX "${CMAKE_CURRENT_BINARY_DIR}/protobuf_ep-install") set(PROTOBUF_INCLUDE_DIR "${PROTOBUF_PREFIX}/include") + # This flag is based on what the user initially requested but if + # we've fallen back to building protobuf we always build it statically + # so we need to reset the flag so that we can link against it correctly + # later. + set(Protobuf_USE_STATIC_LIBS ON) # Newer protobuf releases always have a lib prefix independent from CMAKE_STATIC_LIBRARY_PREFIX set(PROTOBUF_STATIC_LIB "${PROTOBUF_PREFIX}/lib/libprotobuf${CMAKE_STATIC_LIBRARY_SUFFIX}") @@ -1532,7 +1537,7 @@ if(ARROW_WITH_PROTOBUF) PC_PACKAGE_NAMES protobuf) - if(ARROW_PROTOBUF_USE_SHARED AND MSVC_TOOLCHAIN) + if(NOT Protobuf_USE_STATIC_LIBS AND MSVC_TOOLCHAIN) add_definitions(-DPROTOBUF_USE_DLLS) endif()